mirror of
https://github.com/matrix-construct/construct
synced 2024-10-31 19:08:59 +01:00
231 lines
4.7 KiB
C++
231 lines
4.7 KiB
C++
// Matrix Construct
|
|
//
|
|
// Copyright (C) Matrix Construct Developers, Authors & Contributors
|
|
// Copyright (C) 2016-2018 Jason Volk <jason@zemos.net>
|
|
//
|
|
// Permission to use, copy, modify, and/or distribute this software for any
|
|
// purpose with or without fee is hereby granted, provided that the above
|
|
// copyright notice and this permission notice is present in all copies. The
|
|
// full license for this software is available in the LICENSE file.
|
|
|
|
#include <RB_INC_MAGIC_H
|
|
|
|
namespace ircd::magic
|
|
{
|
|
extern const char *const fallback_paths[];
|
|
extern magic_t cookie;
|
|
extern int flags;
|
|
|
|
static void version_check();
|
|
static void throw_on_error(const magic_t &);
|
|
static void set_flags(const magic_t &, const int &flags);
|
|
static string_view call(const magic_t &, const int &flags, const mutable_buffer &, const std::function<const char *()> &);
|
|
static string_view call(const magic_t &, const int &flags, const mutable_buffer &, const const_buffer &);
|
|
}
|
|
|
|
decltype(ircd::magic::version_api)
|
|
ircd::magic::version_api
|
|
{
|
|
"magic", info::versions::API, MAGIC_VERSION
|
|
};
|
|
|
|
decltype(ircd::magic::version_abi)
|
|
ircd::magic::version_abi
|
|
{
|
|
"magic", info::versions::ABI, ::magic_version()
|
|
};
|
|
|
|
decltype(ircd::magic::file_path)
|
|
ircd::magic::file_path
|
|
{
|
|
{ "name", "ircd.magic.file" },
|
|
{
|
|
"default",
|
|
getenv("MAGIC")?
|
|
getenv("MAGIC"):
|
|
RB_MAGIC_FILE
|
|
},
|
|
};
|
|
|
|
decltype(ircd::magic::fallback_paths)
|
|
ircd::magic::fallback_paths
|
|
{
|
|
"/usr/local/share/misc/magic.mgc",
|
|
"/usr/share/misc/magic.mgc",
|
|
"/usr/share/file/misc/magic.mgc",
|
|
nullptr
|
|
};
|
|
|
|
decltype(ircd::magic::cookie)
|
|
ircd::magic::cookie;
|
|
|
|
// magic_getflags() may not be available; this will supplement for our
|
|
// tracking of their flags state.
|
|
decltype(ircd::magic::flags)
|
|
ircd::magic::flags
|
|
{
|
|
MAGIC_NONE
|
|
};
|
|
|
|
//
|
|
// init
|
|
//
|
|
|
|
ircd::magic::init::init()
|
|
{
|
|
const auto load
|
|
{
|
|
[](const string_view &path)
|
|
{
|
|
return !empty(path)
|
|
&& fs::exists(path)
|
|
&& magic_check(cookie, fs::path_cstr(path)) == 0
|
|
&& magic_load(cookie, fs::path_cstr(path)) == 0
|
|
;
|
|
}
|
|
};
|
|
|
|
version_check();
|
|
if(unlikely(!(cookie = ::magic_open(flags))))
|
|
throw error
|
|
{
|
|
"magic_open() failed"
|
|
};
|
|
|
|
// Try the conf item first
|
|
if(load(string_view(file_path)))
|
|
return;
|
|
|
|
for(const char *const *path{fallback_paths}; *path; ++path)
|
|
if(load(*path))
|
|
return;
|
|
|
|
throw error
|
|
{
|
|
"Failed to open any magic database"
|
|
};
|
|
}
|
|
|
|
[[gnu::cold]]
|
|
ircd::magic::init::~init()
|
|
noexcept
|
|
{
|
|
::magic_close(cookie);
|
|
}
|
|
|
|
//
|
|
// interface
|
|
//
|
|
|
|
ircd::string_view
|
|
ircd::magic::description(const mutable_buffer &out,
|
|
const const_buffer &buffer)
|
|
{
|
|
return call(cookie, MAGIC_NONE, out, buffer);
|
|
}
|
|
|
|
ircd::string_view
|
|
ircd::magic::extensions(const mutable_buffer &out,
|
|
const const_buffer &buffer)
|
|
{
|
|
return call(cookie, MAGIC_EXTENSION, out, buffer);
|
|
}
|
|
|
|
ircd::string_view
|
|
ircd::magic::mime_encoding(const mutable_buffer &out,
|
|
const const_buffer &buffer)
|
|
{
|
|
return call(cookie, MAGIC_MIME_ENCODING, out, buffer);
|
|
}
|
|
|
|
ircd::string_view
|
|
ircd::magic::mime_type(const mutable_buffer &out,
|
|
const const_buffer &buffer)
|
|
{
|
|
return call(cookie, MAGIC_MIME_TYPE, out, buffer);
|
|
}
|
|
|
|
ircd::string_view
|
|
ircd::magic::mime(const mutable_buffer &out,
|
|
const const_buffer &buffer)
|
|
{
|
|
return call(cookie, MAGIC_MIME, out, buffer);
|
|
}
|
|
|
|
ircd::string_view
|
|
ircd::magic::call(const magic_t &cookie,
|
|
const int &flags,
|
|
const mutable_buffer &out,
|
|
const const_buffer &buffer)
|
|
{
|
|
return call(cookie, flags, out, [&cookie, &buffer]
|
|
{
|
|
return magic_buffer(cookie, data(buffer), size(buffer));
|
|
});
|
|
}
|
|
|
|
ircd::string_view
|
|
ircd::magic::call(const magic_t &cookie,
|
|
const int &ours,
|
|
const mutable_buffer &out,
|
|
const std::function<const char *()> &closure)
|
|
{
|
|
const auto &theirs{magic::flags};
|
|
const unwind reset{[&theirs, &cookie]
|
|
{
|
|
set_flags(cookie, theirs);
|
|
}};
|
|
|
|
set_flags(cookie, ours);
|
|
string_view str
|
|
{
|
|
closure()
|
|
};
|
|
|
|
if(!str)
|
|
{
|
|
throw_on_error(cookie);
|
|
str = "application/octet-stream"_sv;
|
|
}
|
|
|
|
return { data(out), copy(out, str) };
|
|
}
|
|
|
|
void
|
|
ircd::magic::set_flags(const magic_t &cookie,
|
|
const int &flags)
|
|
{
|
|
if(unlikely(magic_setflags(cookie, flags) == -1))
|
|
throw_on_error(cookie);
|
|
}
|
|
|
|
void
|
|
ircd::magic::throw_on_error(const magic_t &cookie)
|
|
{
|
|
const char *const errstr
|
|
{
|
|
::magic_error(cookie)
|
|
};
|
|
|
|
if(unlikely(errstr))
|
|
throw error
|
|
{
|
|
"%s", errstr
|
|
};
|
|
|
|
assert(magic_errno(cookie) == 0);
|
|
}
|
|
|
|
void
|
|
ircd::magic::version_check()
|
|
{
|
|
if(likely(MAGIC_VERSION == ::magic_version()))
|
|
return;
|
|
|
|
log::warning
|
|
{
|
|
"Linked libmagic version %d is not the compiled magic.h version %d.\n",
|
|
::magic_version(),
|
|
MAGIC_VERSION
|
|
};
|
|
}
|