/*{{{ main */
int main (int argc, char *argv[])
{
Application *app;
gboolean verbose = FALSE;
gboolean version = FALSE;
GError *error = NULL;
GOptionContext *context;
gchar **s_params = NULL;
gchar **s_config = NULL;
gboolean foreground = FALSE;
gchar conf_str[1023];
struct stat st;
gchar **cache_dir = NULL;
gchar **s_fuse_opts = NULL;
gchar **s_log_file = NULL;
guint32 part_size = 0;
gboolean disable_syslog = FALSE;
gboolean disable_stats = FALSE;
gboolean force_head_requests = FALSE;
gint uid = -1;
gint gid = -1;
gint fmode = -1;
gint dmode = -1;
struct event_config *ev_config;
srand (time (NULL));
app = g_new0 (Application, 1);
app->conf_path = g_build_filename (SYSCONFDIR, "riofs.conf.xml", NULL);
g_snprintf (conf_str, sizeof (conf_str), "Path to configuration file. Default: %s", app->conf_path);
GOptionEntry entries[] = {
{ G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_STRING_ARRAY, &s_params, NULL, NULL },
{ "config", 'c', 0, G_OPTION_ARG_FILENAME_ARRAY, &s_config, conf_str, NULL},
{ "uid", 0, 0, G_OPTION_ARG_INT, &uid, "Set UID of filesystem owner.", NULL },
{ "gid", 0, 0, G_OPTION_ARG_INT, &gid, "Set GID of filesystem owner.", NULL },
{ "fmode", 0, 0, G_OPTION_ARG_INT, &fmode, "Set mode for all files.", NULL },
{ "dmode", 0, 0, G_OPTION_ARG_INT, &dmode, "Set mode for all directories.", NULL },
{ "foreground", 'f', 0, G_OPTION_ARG_NONE, &foreground, "Flag. Do not daemonize process.", NULL },
{ "cache-dir", 0, 0, G_OPTION_ARG_STRING_ARRAY, &cache_dir, "Set cache directory.", NULL },
{ "fuse-options", 'o', 0, G_OPTION_ARG_STRING_ARRAY, &s_fuse_opts, "Fuse options.", "\"opt[,opt...]\"" },
{ "disable-syslog", 0, 0, G_OPTION_ARG_NONE, &disable_syslog, "Flag. Disable logging to syslog.", NULL },
{ "disable-stats", 0, 0, G_OPTION_ARG_NONE, &disable_stats, "Flag. Disable Statistics HTTP interface.", NULL },
{ "part-size", 0, 0, G_OPTION_ARG_INT, &part_size, "Set file part size (in bytes).", NULL },
{ "log-file", 'l', 0, G_OPTION_ARG_STRING_ARRAY, &s_log_file, "File to write output.", NULL },
{ "force-head-requests", 0, 0, G_OPTION_ARG_NONE, &force_head_requests, "Flag. Send HEAD request for each file.", NULL },
{ "verbose", 'v', 0, G_OPTION_ARG_NONE, &verbose, "Verbose output.", NULL },
{ "version", 'V', 0, G_OPTION_ARG_NONE, &version, "Show application version and exit.", NULL },
{ NULL, 0, 0, G_OPTION_ARG_NONE, NULL, NULL, NULL }
};
// init libraries
CRYPTO_set_mem_functions (g_malloc0, g_realloc, g_free);
ENGINE_load_builtin_engines ();
ENGINE_register_all_complete ();
ERR_load_crypto_strings ();
OpenSSL_add_all_algorithms ();
#ifdef SSL_ENABLED
SSL_load_error_strings ();
SSL_library_init ();
#endif
if (!RAND_poll ()) {
fprintf(stderr, "RAND_poll() failed.\n");
return -1;
}
g_random_set_seed (time (NULL));
// init main app structure
ev_config = event_config_new ();
#if defined(__APPLE__)
// method select is the preferred method on OS X. kqueue and poll are not supported.
event_config_avoid_method (ev_config, "kqueue");
event_config_avoid_method (ev_config, "poll");
#endif
app->evbase = event_base_new_with_config (ev_config);
event_config_free (ev_config);
if (!app->evbase) {
LOG_err (APP_LOG, "Failed to create event base !");
application_destroy (app);
return -1;
}
app->dns_base = evdns_base_new (app->evbase, 1);
if (!app->dns_base) {
LOG_err (APP_LOG, "Failed to create DNS base !");
application_destroy (app);
return -1;
}
app->f_log = NULL;
app->log_file_name = NULL;
/*{{{ cmd line args */
// parse command line options
context = g_option_context_new ("[bucketname] [mountpoint]");
g_option_context_add_main_entries (context, entries, NULL);
g_option_context_set_description (context, "Please set both AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY environment variables!");
if (!g_option_context_parse (context, &argc, &argv, &error)) {
g_fprintf (stderr, "Failed to parse command line options: %s\n", error->message);
application_destroy (app);
g_option_context_free (context);
return -1;
}
g_option_context_free (context);
// check if --version is specified
if (version) {
g_fprintf (stdout, "RioFS File System v%s\n", VERSION);
g_fprintf (stdout, "Copyright (C) 2012-2014 Paul Ionkin <*****@*****.**>\n");
g_fprintf (stdout, "Copyright (C) 2012-2014 Skoobe GmbH. All rights reserved.\n");
g_fprintf (stdout, "Libraries:\n");
g_fprintf (stdout, " GLib: %d.%d.%d libevent: %s fuse: %d.%d",
GLIB_MAJOR_VERSION, GLIB_MINOR_VERSION, GLIB_MICRO_VERSION,
LIBEVENT_VERSION,
FUSE_MAJOR_VERSION, FUSE_MINOR_VERSION
);
#if defined(__APPLE__) || defined(__FreeBSD__)
g_fprintf (stdout, "\n");
#else
g_fprintf (stdout, " glibc: %s\n", gnu_get_libc_version ());
#endif
g_fprintf (stdout, "Features:\n");
g_fprintf (stdout, " libevent backend method: %s\n", event_base_get_method(app->evbase));
/*
{
int i;
const char **methods = event_get_supported_methods ();
g_fprintf (stdout, " Available libevent backend methods:\n");
for (i = 0; methods[i] != NULL; ++i) {
g_fprintf (stdout, " %s\n", methods[i]);
}
}
*/
return 0;
}
if (!s_params || g_strv_length (s_params) != 2) {
LOG_err (APP_LOG, "Wrong number of provided arguments!\nTry `%s --help' for more information.", argv[0]);
application_destroy (app);
return -1;
}
if (verbose)
log_level = LOG_debug;
else
log_level = LOG_msg;
/*}}}*/
/*{{{ parse config file */
// user provided alternative config path
if (s_config && g_strv_length (s_config) > 0) {
g_free (app->conf_path);
app->conf_path = g_strdup (s_config[0]);
g_strfreev (s_config);
}
app->conf = conf_create ();
if (access (app->conf_path, R_OK) == 0) {
LOG_debug (APP_LOG, "Using config file: %s", app->conf_path);
if (!conf_parse_file (app->conf, app->conf_path)) {
LOG_err (APP_LOG, "Failed to parse configuration file: %s", app->conf_path);
application_destroy (app);
return -1;
}
} else {
LOG_err (APP_LOG, "Configuration file is not found !");
application_destroy (app);
return -1;
}
if (!conf_check_keys (app->conf, conf_keys_str, conf_keys_len)) {
LOG_err (APP_LOG, "Configuration file is missing keys, please re-check your configuration file: %s", app->conf_path);
application_destroy (app);
return -1;
}
if (disable_syslog) {
conf_set_boolean (app->conf, "log.use_syslog", FALSE);
}
// update logging settings
logger_set_syslog (conf_get_boolean (app->conf, "log.use_syslog"));
logger_set_color (conf_get_boolean (app->conf, "log.use_color"));
if (cache_dir && g_strv_length (cache_dir) > 0) {
conf_set_string (app->conf, "filesystem.cache_dir", cache_dir[0]);
g_strfreev (cache_dir);
}
if (!verbose)
log_level = conf_get_int (app->conf, "log.level");
if (uid >= 0)
conf_set_int (app->conf, "filesystem.uid", uid);
if (gid >= 0)
conf_set_int (app->conf, "filesystem.gid", gid);
if (fmode >= 0)
conf_set_int (app->conf, "filesystem.file_mode", fmode);
if (dmode >= 0)
conf_set_int (app->conf, "filesystem.dir_mode", dmode);
/*}}}*/
// try to get access parameters from the environment
if (getenv ("AWS_ACCESS_KEY_ID")) {
conf_set_string (app->conf, "s3.access_key_id", getenv ("AWS_ACCESS_KEY_ID"));
// else check if it's set it the config file
} else {
if (!conf_node_exists (app->conf, "s3.access_key_id")) {
LOG_err (APP_LOG, "Environment variables are not set!\nTry `%s --help' for more information.", argv[0]);
application_destroy (app);
return -1;
}
}
if (getenv ("AWS_SECRET_ACCESS_KEY")) {
conf_set_string (app->conf, "s3.secret_access_key", getenv ("AWS_SECRET_ACCESS_KEY"));
} else {
if (!conf_node_exists (app->conf, "s3.secret_access_key")) {
LOG_err (APP_LOG, "Environment variables are not set!\nTry `%s --help' for more information.", argv[0]);
application_destroy (app);
return -1;
}
}
// check if both strings are set
if (!conf_get_string (app->conf, "s3.access_key_id") || !conf_get_string (app->conf, "s3.secret_access_key")) {
LOG_err (APP_LOG, "Environment variables are not set!\nTry `%s --help' for more information.", argv[0]);
application_destroy (app);
return -1;
}
// foreground is set
if (foreground)
conf_set_boolean (app->conf, "app.foreground", foreground);
if (part_size)
conf_set_uint (app->conf, "s3.part_size", part_size);
if (disable_stats)
conf_set_boolean (app->conf, "statistics.enabled", FALSE);
if (force_head_requests)
conf_set_boolean (app->conf, "s3.force_head_requests_on_lookup", TRUE);
else
conf_set_boolean (app->conf, "s3.force_head_requests_on_lookup", FALSE);
conf_set_string (app->conf, "s3.bucket_name", s_params[0]);
if (!application_set_url (app, conf_get_string (app->conf, "s3.endpoint"))) {
application_destroy (app);
return -1;
}
if (s_fuse_opts && g_strv_length (s_fuse_opts) > 0) {
app->fuse_opts = g_strdup (s_fuse_opts[0]);
g_strfreev (s_fuse_opts);
}
if (s_log_file && g_strv_length (s_log_file) > 0) {
app->log_file_name = g_strdup (s_log_file[0]);
app->f_log = fopen (s_log_file[0], "a+");
if (!app->f_log) {
LOG_err (APP_LOG, "Failed to open log file: %s Error: %s", s_log_file[0], strerror (errno));
application_destroy (app);
return -1;
}
LOG_debug (APP_LOG, "Using %s for storing application logs.", s_log_file[0]);
logger_set_file (app->f_log);
g_strfreev (s_log_file);
}
conf_set_string (app->conf, "app.mountpoint", s_params[1]);
// check if directory exists
if (stat (conf_get_string (app->conf, "app.mountpoint"), &st) == -1) {
LOG_err (APP_LOG, "Mountpoint %s does not exist! Please check directory permissions!",
conf_get_string (app->conf, "app.mountpoint"));
application_destroy (app);
return -1;
}
// check if it's a directory
if (!S_ISDIR (st.st_mode)) {
LOG_err (APP_LOG, "Mountpoint %s is not a directory!", conf_get_string (app->conf, "app.mountpoint"));
application_destroy (app);
return -1;
}
g_strfreev (s_params);
#ifdef SSL_ENABLED
app->ssl_ctx = SSL_CTX_new (SSLv23_client_method ());
if (!app->ssl_ctx) {
LOG_err (APP_LOG, "Failed to initialize SSL engine !");
application_exit (app);
return -1;
}
SSL_CTX_set_options (app->ssl_ctx, SSL_OP_ALL);
#endif
#ifdef MAGIC_ENABLED
app->magic_ctx = magic_open(MAGIC_MIME_TYPE);
if (!app->magic_ctx) {
LOG_err(APP_LOG, "Failed to initialize magic library\n");
return -1;
}
if (magic_load(app->magic_ctx, NULL)) {
LOG_err(APP_LOG, "Failed to load magic database: %s\n", magic_error(app->magic_ctx));
magic_close(app->magic_ctx);
return -1;
}
#endif
app->stat_srv = stat_srv_create (app);
if (!app->stat_srv) {
application_exit (app);
return -1;
}
// perform the initial request to get bucket ACL (handles redirect as well)
app->service_con = http_connection_create (app);
if (!app->service_con) {
application_destroy (app);
return -1;
}
bucket_client_get (app->service_con, "/?acl", application_on_bucket_acl_cb, app);
// start the loop
event_base_dispatch (app->evbase);
application_destroy (app);
return 0;
}
/*
GC never seems to happen until the program terminates, but this is called
on any unclosed objects
*/
static void magick_free(magic_t cookie)
{
magic_close(cookie);
}
Magic::~Magic() { magic_close(magic_); }
/*{{{ application_destroy */
static void application_destroy (Application *app)
{
LOG_debug (APP_LOG, "Destroying application !");
g_free (app->conf_path);
if (app->read_client_pool)
client_pool_destroy (app->read_client_pool);
if (app->write_client_pool)
client_pool_destroy (app->write_client_pool);
if (app->ops_client_pool)
client_pool_destroy (app->ops_client_pool);
if (app->dir_tree)
dir_tree_destroy (app->dir_tree);
if (app->cmng)
cache_mng_destroy (app->cmng);
if (app->sigint_ev)
event_free (app->sigint_ev);
if (app->sigterm_ev)
event_free (app->sigterm_ev);
if (app->sigpipe_ev)
event_free (app->sigpipe_ev);
if (app->sigusr1_ev)
event_free (app->sigusr1_ev);
if (app->sigusr2_ev)
event_free (app->sigusr2_ev);
if (app->service_con)
http_connection_destroy (app->service_con);
if (app->stat_srv)
stat_srv_destroy (app->stat_srv);
// destroy Fuse
if (app->rfuse)
rfuse_destroy (app->rfuse);
if (app->dns_base)
evdns_base_free (app->dns_base, 0);
if (app->evbase)
event_base_free (app->evbase);
if (app->uri)
evhttp_uri_free (app->uri);
if (app->conf)
conf_destroy (app->conf);
if (app->fuse_opts)
g_free (app->fuse_opts);
#ifdef SSL_ENABLED
SSL_CTX_free (app->ssl_ctx);
#endif
#ifdef MAGIC_ENABLED
magic_close(app->magic_ctx);
#endif
logger_destroy ();
if (app->f_log)
fclose (app->f_log);
if (app->log_file_name)
g_free (app->log_file_name);
g_free (app);
ENGINE_cleanup ();
CRYPTO_cleanup_all_ex_data ();
ERR_free_strings ();
ERR_remove_thread_state (NULL);
EVP_cleanup ();
CRYPTO_mem_leaks_fp (stderr);
}
char *uploadfile(char *filename, char *lookForSimilar, char *lang) {
#ifndef CAN_MAGIC
o_log(ERROR, "Unable to determin the file type, aborting.");
return NULL;
#else
int width = 0, height = 0, itype = PLACE_HOLDER;
char *final_filename, *ocrText = NULL, *tmp;
#ifdef CAN_PDF
char *thumbext = NULL;
#else
#ifdef CAN_READODF
char *thumbext = NULL;
#endif /* CAN_READODF */
#endif /* CAN_PDF */
char *docid;
char *ftype;
char *datafile;
char *thumbfile = NULL;
PIX *pix;
datafile = o_printf("/tmp/%s.dat", filename);
magic_t cookie = magic_open(MAGIC_MIME_TYPE);
magic_load( cookie, NULL );
const char *t = magic_file( cookie, datafile );
ftype = o_strdup( t );
o_log( ERROR, "Uploaded file looks to be of type: %s", ftype );
magic_close( cookie );
// --------------------------------------
if( 0 == strcmp("application/pdf", ftype) ) {
itype = PDF_FILETYPE;
#ifdef CAN_PDF
thumbfile = o_printf("/tmp/%s.thumb", filename);
ocrText = parse_pdf( datafile, thumbfile ); // pdf_plug.cc [create thumbnail and return body text]
thumbext = o_strdup("jpg");
#endif /* CAN_PDF */
o_log( INFORMATION, "Processed PDF");
}
// --------------------------------------
else if( 0 == strcmp("application/vnd.oasis.opendocument.text", ftype) ) {
itype = ODF_FILETYPE;
#ifdef CAN_READODF
thumbfile = o_printf("/tmp/%s.thumb", filename);
get_odf_Thumb( datafile, thumbfile );
ocrText = get_odf_Text( datafile ); // odf_plug.c
thumbext = o_strdup("png");
#endif /* CAN_READODF */
o_log( INFORMATION, "Processed ODF doc");
}
// --------------------------------------
else if( 0 == strcmp("image/jpeg", ftype) ) {
itype = JPG_FILETYPE;
#ifdef CAN_OCR
PIX *pix_l;
if ( ( pix_l = pixRead( datafile ) ) == NULL) {
o_log(ERROR, "Could not load the image data into a PIX");
return NULL;
}
int depth;
pixGetDimensions( pix_l, &width, &height, &depth );
o_log(INFORMATION, "Convertion process: Loaded (depth: %d)", depth );
pix = pixScaleRGBToGrayFast( pix_l, 1, COLOR_GREEN );
pixDestroy( &pix_l );
if (pix == NULL ) {
o_log(ERROR,"Conversion process failed pixScaleRGBToGrayFast! skip ocr");
}
else {
o_log(INFORMATION, "Convertion process: Reduced depth to %d", pixGetDepth(pix));
ocrText = getTextFromImage(pix, 0, "eng");
}
#endif /* CAN_OCR */
o_log( INFORMATION, "Processed JPG doc");
}
// --------------------------------------
else {
free( ftype );
free( datafile );
o_log(ERROR, "unknown file type.");
return NULL;
}
free( ftype );
// Set a default OCR text string
if( ocrText == NULL ) {
ocrText = o_strdup( getString("LOCAL_ocr_default_text", lang ) );
}
// Save the record to the DB
o_log(DEBUGM, "Saving doc import record");
docid = addNewFileDoc(itype, width, height, ocrText); // ocrText get freed in this method
// Move the main datafile to the file store location
final_filename = o_printf("%s/scans/%s", BASE_DIR, docid); // none image imported docs, are stored with no "_x" postfix.
if( itype == JPG_FILETYPE ) {
conCat(&final_filename, "_1");
}
addFileExt(&final_filename, itype);
fcopy(datafile, final_filename);
o_log( DEBUGM, "Moved data file");
// The original file will be unlinked by the HTTPD process
free(datafile);
// Move any thumbnail image to the file store location
if( thumbfile ) {
free(final_filename); // This currently holds the main PDG or ODF file.
final_filename = o_printf("%s/scans/%s_thumb.%s", BASE_DIR, docid, thumbext); // any thumbnails are postfixed with "_thumb"
fcopy(thumbfile, final_filename);
o_log( DEBUGM, "Moved thumbnail file");
unlink(thumbfile);
free(thumbfile);
free(thumbext);
#ifdef CAN_PHASH
o_log( DEBUGM, "About to perform pHash on file");
unsigned long long hash = getImagePhash_fn( final_filename );
savePhash( atoi(docid), hash );
#endif /* CAN_PHASH */
}
else {
#ifdef CAN_PHASH
o_log( DEBUGM, "About to perform pHash on pix");
unsigned long long hash = getImagePhash_px( pix );
savePhash( atoi(docid), hash );
#endif /* CAN_PHASH */
pixDestroy( &pix );
}
free(final_filename);
// Should we look for a similar doc, on opening?
char *findSim = "";
#ifdef CAN_PHASH
if( lookForSimilar != (void *)NULL ) {
findSim = "&findSimilar=1";
}
#endif /* CAN_PHASH */
// Open the document for editing.
tmp = o_printf("<html><HEAD><META HTTP-EQUIV=\"refresh\" CONTENT=\"0;URL=/opendias/docDetail.html?docid=%s%s\"></HEAD><body></body></html>", docid, findSim);
free(docid);
return tmp;
#endif /* CAN_MAGIC */
}
void search_journal_lost_inode(char* des_dir, __u32 t_after, __u32 t_before, int flag){
struct ext2_inode *p_inode;
struct ext2_inode inode;
int i;
char *pathname = NULL;
char *i_pathname = NULL;
char *buf= NULL;
unsigned char *tmp_buf = NULL;
__u32 blocksize, inodesize;
__u32 inode_per_block;
ext2_ino_t inode_max, inode_nr;
pathname = malloc(26);
blocksize = current_fs->blocksize;
inodesize = current_fs->super->s_inode_size;
inode_max = current_fs->super->s_inodes_count;
inode_per_block = blocksize / inodesize;
inode_nr = inode_max ;
buf = malloc(blocksize);
if (! (flag & 0x01) ){
tmp_buf = malloc (12 * blocksize);
if (!tmp_buf)
goto errout;
cookie = magic_open(MAGIC_MIME | MAGIC_NO_CHECK_COMPRESS | MAGIC_NO_CHECK_ELF | MAGIC_CONTINUE);
if ((! cookie) || magic_load(cookie, NULL)){
fprintf(stderr,"ERROR: can't find libmagic\n");
goto errout;
}
}
while ( get_pool_block(buf) ){
for (i=0 ;i < inode_per_block; i++){
inode_nr++;
p_inode = (struct ext2_inode*) (buf + (i * inodesize));
memset(&inode, 0, sizeof(struct ext2_inode));
#ifdef WORDS_BIGENDIAN
ext2fs_swap_inode(current_fs, &inode, p_inode, 0);
#else
memcpy(&inode, p_inode,128);
#endif
if((inode.i_dtime) || (!inode.i_size) || (!inode.i_blocks) || (!LINUX_S_ISREG(inode.i_mode)))
continue;
if (check_file_stat(&inode)){
i_pathname = identify_filename(i_pathname, tmp_buf, &inode, inode_nr);
sprintf(pathname,"<%lu>",(long unsigned int)inode_nr);
recover_file(des_dir,"MAGIC-2", ((i_pathname)?i_pathname : pathname), &inode, inode_nr, 1);
}
if(i_pathname){
free(i_pathname);
i_pathname = NULL;
}
}
}
errout:
if (pathname)
free(pathname);
if(buf) {
free(buf);
buf = NULL;
}
if (tmp_buf){
free(tmp_buf);
tmp_buf = NULL;
}
if (cookie){
magic_close(cookie);
cookie = 0;
}
return;
}
int main(int argc, char **argv)
{
int arch = 32;
magic_t magic;
char dll_real_path[PATH_MAX];
char wineprefix_real_path[PATH_MAX];
if (argc != 3 && argc != 4) {
fprintf(stderr, "usage: %s <vst.dll> <vst.so> [<wine-prefix>]\n", argv[0]);
return 2;
}
int has_wineprefix = argc == 4;
struct stat st_dll;
if (stat(argv[1], &st_dll) ||
!realpath(argv[1], dll_real_path)) {
fprintf(stderr, "%s: %m\n", argv[1]);
return 1;
}
struct stat st_tpl;
if (stat(VST_BRIDGE_TPL_PATH, &st_tpl)) {
fprintf(stderr, "%s: %m\n", VST_BRIDGE_TPL_PATH);
return 1;
}
if (has_wineprefix) {
struct stat st_wineprefix;
if (stat(argv[3], &st_wineprefix) ||
!realpath(argv[3], wineprefix_real_path)) {
fprintf(stderr, "%s: %m\n", argv[3]);
return 1;
}
if (!S_ISDIR(st_wineprefix.st_mode)) {
fprintf(stderr, "%s: %s\n", argv[3], strerror(ENOTDIR));
return 1;
}
}
magic = magic_open(MAGIC_NONE);
if (!magic)
fprintf(stderr, "failed to initialize magic\n");
else {
magic_load(magic, NULL);
if (strstr(magic_file(magic, dll_real_path), "80386"))
arch = 32;
else if (strstr(magic_file(magic, dll_real_path), "x86-64"))
arch = 64;
printf("detected %d bits dll\n", arch);
magic_close(magic);
}
// copy file
int fd_tpl = open(VST_BRIDGE_TPL_PATH, O_RDONLY, 0644);
if (fd_tpl < 0) {
fprintf(stderr, "%s: %m\n", VST_BRIDGE_TPL_PATH);
return 1;
}
int fd_so = open(argv[2], O_CREAT | O_TRUNC | O_RDWR, 0755);
if (fd_so < 0) {
fprintf(stderr, "%s: %m\n", argv[2]);
return 1;
}
if (fchmod(fd_so, 0755))
fprintf(stderr, "chmod(%s, 0755): %m\n", argv[2]);
if (sendfile(fd_so, fd_tpl, NULL, st_tpl.st_size) != st_tpl.st_size) {
fprintf(stderr, "copy %s to %s: %m\n", VST_BRIDGE_TPL_PATH, argv[2]);
return 1;
}
close(fd_tpl);
void *mem_so = mmap(NULL, st_tpl.st_size, PROT_READ | PROT_WRITE, MAP_SHARED,
fd_so, 0);
if (mem_so == MAP_FAILED) {
fprintf(stderr, "mmap(%s): %m\n", argv[2]);
return 1;
}
replace_magic(mem_so, st_tpl.st_size, VST_BRIDGE_TPL_DLL, dll_real_path);
replace_magic(mem_so, st_tpl.st_size, VST_BRIDGE_TPL_HOST, arch == 32 ? VST_BRIDGE_HOST32_PATH : VST_BRIDGE_HOST64_PATH);
if (has_wineprefix)
replace_magic(mem_so, st_tpl.st_size, VST_BRIDGE_TPL_WINEPREFIX, wineprefix_real_path);
munmap(mem_so, st_tpl.st_size);
close(fd_so);
return 0;
}
static void _php_finfo_get_type(INTERNAL_FUNCTION_PARAMETERS, int mode, int mimetype_emu) /* {{{ */
{
zend_long options = 0;
char *ret_val = NULL, *buffer = NULL;
size_t buffer_len;
php_fileinfo *finfo = NULL;
zval *zfinfo, *zcontext = NULL;
zval *what;
char mime_directory[] = "directory";
struct magic_set *magic = NULL;
FILEINFO_DECLARE_INIT_OBJECT(object)
if (mimetype_emu) {
/* mime_content_type(..) emulation */
if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &what) == FAILURE) {
return;
}
switch (Z_TYPE_P(what)) {
case IS_STRING:
buffer = Z_STRVAL_P(what);
buffer_len = Z_STRLEN_P(what);
mode = FILEINFO_MODE_FILE;
break;
case IS_RESOURCE:
mode = FILEINFO_MODE_STREAM;
break;
default:
php_error_docref(NULL, E_WARNING, "Can only process string or stream arguments");
RETURN_FALSE;
}
magic = magic_open(MAGIC_MIME_TYPE);
if (magic_load(magic, NULL) == -1) {
php_error_docref(NULL, E_WARNING, "Failed to load magic database.");
goto common;
}
} else if (object) {
if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|lr", &buffer, &buffer_len, &options, &zcontext) == FAILURE) {
RETURN_FALSE;
}
FILEINFO_FROM_OBJECT(finfo, object);
magic = finfo->magic;
} else {
if (zend_parse_parameters(ZEND_NUM_ARGS(), "rs|lr", &zfinfo, &buffer, &buffer_len, &options, &zcontext) == FAILURE) {
RETURN_FALSE;
}
if ((finfo = (php_fileinfo *)zend_fetch_resource(Z_RES_P(zfinfo), "file_info", le_fileinfo)) == NULL) {
RETURN_FALSE;
}
magic = finfo->magic;
}
/* Set options for the current file/buffer. */
if (options) {
FINFO_SET_OPTION(magic, options)
}
switch (mode) {
case FILEINFO_MODE_BUFFER:
{
ret_val = (char *) magic_buffer(magic, buffer, buffer_len);
break;
}
case FILEINFO_MODE_STREAM:
{
php_stream *stream;
zend_off_t streampos;
php_stream_from_zval_no_verify(stream, what);
if (!stream) {
goto common;
}
streampos = php_stream_tell(stream); /* remember stream position for restoration */
php_stream_seek(stream, 0, SEEK_SET);
ret_val = (char *) magic_stream(magic, stream);
php_stream_seek(stream, streampos, SEEK_SET);
break;
}
case FILEINFO_MODE_FILE:
{
/* determine if the file is a local file or remote URL */
const char *tmp2;
php_stream_wrapper *wrap;
php_stream_statbuf ssb;
if (buffer == NULL || !*buffer) {
php_error_docref(NULL, E_WARNING, "Empty filename or path");
RETVAL_FALSE;
goto clean;
}
if (CHECK_NULL_PATH(buffer, buffer_len)) {
php_error_docref(NULL, E_WARNING, "Invalid path");
RETVAL_FALSE;
goto clean;
}
wrap = php_stream_locate_url_wrapper(buffer, &tmp2, 0);
if (wrap) {
php_stream *stream;
php_stream_context *context = php_stream_context_from_zval(zcontext, 0);
#ifdef PHP_WIN32
if (php_stream_stat_path_ex(buffer, 0, &ssb, context) == SUCCESS) {
if (ssb.sb.st_mode & S_IFDIR) {
ret_val = mime_directory;
goto common;
}
}
#endif
#if PHP_API_VERSION < 20100412
stream = php_stream_open_wrapper_ex(buffer, "rb", ENFORCE_SAFE_MODE | REPORT_ERRORS, NULL, context);
#else
stream = php_stream_open_wrapper_ex(buffer, "rb", REPORT_ERRORS, NULL, context);
#endif
if (!stream) {
RETVAL_FALSE;
goto clean;
}
if (php_stream_stat(stream, &ssb) == SUCCESS) {
if (ssb.sb.st_mode & S_IFDIR) {
ret_val = mime_directory;
} else {
ret_val = (char *)magic_stream(magic, stream);
}
}
php_stream_close(stream);
}
break;
}
default:
php_error_docref(NULL, E_WARNING, "Can only process string or stream arguments");
}
common:
if (ret_val) {
RETVAL_STRING(ret_val);
} else {
php_error_docref(NULL, E_WARNING, "Failed identify data %d:%s", magic_errno(magic), magic_error(magic));
RETVAL_FALSE;
}
clean:
if (mimetype_emu) {
magic_close(magic);
}
/* Restore options */
if (options) {
FINFO_SET_OPTION(magic, finfo->options)
}
return;
}
FileType::~FileType() {
if (magic_) {
magic_close(magic_);
}
}
static char *
cpio_arch (guestfs_h *g, const char *file, const char *path)
{
CLEANUP_FREE char *tmpdir = guestfs_get_tmpdir (g), *dir = NULL;
CLEANUP_FREE char *initrd = NULL;
CLEANUP_CMD_CLOSE struct command *cmd = guestfs___new_command (g);
char *ret = NULL;
const char *method;
int64_t size;
int r;
size_t i;
if (asprintf (&dir, "%s/libguestfsXXXXXX", tmpdir) == -1) {
perror ("asprintf");
return NULL;
}
if (strstr (file, "gzip"))
method = "zcat";
else if (strstr (file, "bzip2"))
method = "bzcat";
else
method = "cat";
/* Security: Refuse to download initrd if it is huge. */
size = guestfs_filesize (g, path);
if (size == -1 || size > 100000000) {
error (g, _("size of %s unreasonable (%" PRIi64 " bytes)"),
path, size);
goto out;
}
if (mkdtemp (dir) == NULL) {
perrorf (g, "mkdtemp");
goto out;
}
initrd = safe_asprintf (g, "%s/initrd", dir);
if (guestfs_download (g, path, initrd) == -1)
goto out;
/* Construct a command to extract named binaries from the initrd file. */
guestfs___cmd_add_string_unquoted (cmd, "cd ");
guestfs___cmd_add_string_quoted (cmd, dir);
guestfs___cmd_add_string_unquoted (cmd, " && ");
guestfs___cmd_add_string_unquoted (cmd, method);
guestfs___cmd_add_string_unquoted (cmd, " initrd | cpio --quiet -id");
for (i = 0; initrd_binaries[i] != NULL; ++i) {
guestfs___cmd_add_string_unquoted (cmd, " ");
guestfs___cmd_add_string_quoted (cmd, initrd_binaries[i]);
}
r = guestfs___cmd_run (cmd);
if (r == -1)
goto out;
if (!WIFEXITED (r) || WEXITSTATUS (r) != 0) {
guestfs___external_command_failed (g, r, "cpio", path);
goto out;
}
for (i = 0; initrd_binaries[i] != NULL; ++i) {
CLEANUP_FREE char *bin =
safe_asprintf (g, "%s/%s", dir, initrd_binaries[i]);
if (is_regular_file (bin)) {
int flags = g->verbose ? MAGIC_DEBUG : 0;
flags |= MAGIC_ERROR | MAGIC_RAW;
magic_t m = magic_open (flags);
if (m == NULL) {
perrorf (g, "magic_open");
goto out;
}
if (magic_load (m, NULL) == -1) {
perrorf (g, "magic_load: default magic database file");
magic_close (m);
goto out;
}
const char *line = magic_file (m, bin);
if (line == NULL) {
perrorf (g, "magic_file: %s", bin);
magic_close (m);
goto out;
}
CLEANUP_FREE char *elf_arch = match1 (g, line, re_file_elf);
if (elf_arch != NULL) {
ret = canonical_elf_arch (g, elf_arch);
magic_close (m);
goto out;
}
magic_close (m);
}
}
error (g, "file_architecture: could not determine architecture of cpio archive");
out:
guestfs___recursive_remove_dir (g, dir);
return ret;
}
int
main(int argc, char *argv[])
{
int optcode = 0;
int option_index = 0, ret = 0;
char *file = NULL;
int method = MAGIC_DEVICES;
char *tmp_method = NULL;
char *type = NULL;
const char *magic_full;
magic_t magic_cookie;
static struct option long_options[] = {
{"file", required_argument, 0, C_FILE},
{"method", required_argument, 0, C_METHOD},
{"type", required_argument, 0, C_TYPE},
/* End of options marker */
{0, 0, 0, 0}
};
if (argc <2 )
usage();
while (TRUE) {
optcode = getopt_long_only(argc, argv, "", long_options, &option_index);
if (optcode == -1)
break;
switch (optcode) {
case C_FILE:
file = malloc(strlen(optarg) + 1);
memset(file, 0, strlen(optarg) + 1);
strcpy(file, optarg);
break;
case C_METHOD:
tmp_method = malloc(strlen(optarg) + 1);
memset(tmp_method, 0, strlen(optarg) + 1);
strcpy(tmp_method, optarg);
method = magicIndex(tmp_method);
if (method == 0) {
method = MAGIC_DEVICES;
warn("Magic index not found for %s, forcing to MAGIC_DEVICES\n",tmp_method);
}
free(tmp_method);
break;
case C_TYPE:
file = malloc(strlen(optarg) + 1);
memset(file, 0, strlen(optarg) + 1);
strcpy(file, optarg);
break;
}
}
// init cookie, can be logical operand, e.g: " MAGIC_DEVICES|MAGIC_NO_CHECK_COMPRESS|MAGIC_NO_CHECK_ENCODING "
magic_cookie = magic_open(method);
if (magic_cookie == NULL) {
printf("unable to initialize magic library\n");
return 1;
}
// load magic database
if (magic_load(magic_cookie, NULL) != 0) {
printf("cannot load magic database - %s\n", magic_error(magic_cookie));
magic_close(magic_cookie);
return 1;
}
magic_full = magic_file(magic_cookie, file);
printf("%s\n", magic_full);
magic_close(magic_cookie);
return 0;
}
ZLUnixFSManager::~ZLUnixFSManager() {
if (myMagic) {
magic_close(myMagic);
}
}
ZLUnixFSManager::ZLUnixFSManager() : myMagic(magic_open(MAGIC_MIME_TYPE)) {
if (myMagic && magic_load(myMagic, NULL) != 0) {
magic_close(myMagic);
myMagic = NULL;
}
}
int main(int argc, char *argv[])
{
char *out_file = NULL, *last_optarg = NULL;
char *magic_file_contents = NULL, *marker = NULL, *magic = NULL;
size_t mfsize = 0;
int c = 0, i = 0;
int filter_count = 0, magic_offset = 0, magic_size = 0, wildcard = 0, num_sigs = 0, check_magic_file = 0, fast_filter = 0;
int update = 0, ignore_short_sigs = 1, use_default_filters = 1;
int retval = EXIT_FAILURE;
struct magic_signature *signatures[MAX_SIGNATURES];
struct magic_filter *filters[MAX_FILTERS];
struct binconf config = { 0 };
int long_opt_index = 0;
char *short_options = "b:l:m:o:f:y:x:i:aAcCdkstvquh";
struct option long_options[] = {
{ "align", required_argument, NULL, 'b' },
{ "length", required_argument, NULL, 'l' },
{ "magic", required_argument, NULL, 'm' },
{ "offset", required_argument, NULL, 'o' },
{ "file", required_argument, NULL, 'f' },
{ "search", required_argument, NULL, 'y' },
{ "exclude", required_argument, NULL, 'x' },
{ "include", required_argument, NULL, 'i' },
{ "all", no_argument, NULL, 'a' },
{ "opcodes", no_argument, NULL, 'A' },
{ "validate", no_argument, NULL, 'c' },
{ "cast", no_argument, NULL, 'C' },
{ "defaults", no_argument, NULL, 'd' },
{ "keep-going", no_argument, NULL, 'k' },
{ "smart", no_argument, NULL, 's' },
{ "fast", no_argument, NULL, 't' },
{ "verbose", no_argument, NULL, 'v' },
{ "quiet", no_argument, NULL, 'q' },
{ "update", no_argument, NULL, 'u' },
{ "help", no_argument, NULL, 'h' },
{ 0, 0, 0, 0 }
};
/* Need at least one argument: the target file */
if(argc == 1)
{
usage(argv[0]);
goto end;
}
/* Initialize global variables */
memset((void *) &globals,0,sizeof(globals));
/* Initialize default configuration settings */
config.flags = MAGIC_NONE;
config.align = DEFAULT_BYTE_ALIGN;
config.smart = 1;
while((c = getopt_long(argc, argv, short_options, long_options, &long_opt_index)) != -1)
{
switch(c)
{
case 'a':
ignore_short_sigs = 0;
break;
case 'b':
config.align = str2int(optarg);
break;
case 'c':
check_magic_file = 1;
break;
case 'C':
config.magic = strdup(MAGIC_CAST);
config.flags |= MAGIC_CONTINUE;
break;
case 'A':
config.magic = strdup(MAGIC_ARCH);
ignore_short_sigs = 0;
break;
case 'f':
out_file = strdup(optarg);
break;
case 'i':
add_filter(filters, &filter_count, FILTER_ADD, optarg);
break;
case 'l':
config.length = str2int(optarg);
break;
case 'm':
config.magic = strdup(optarg);
break;
case 'o':
config.offset = str2int(optarg);
break;
case 'd':
use_default_filters = 0;
break;
case 's':
config.smart = 0;
break;
case 't':
fast_filter = 1;
break;
case 'k':
config.flags |= MAGIC_CONTINUE;
break;
case 'y':
fast_filter = 1;
use_default_filters = 0;
add_filter(filters, &filter_count, FILTER_INCLUDE, optarg);
break;
case 'x':
add_filter(filters, &filter_count, FILTER_EXCLUDE, optarg);
break;
case 'q':
globals.quiet = 1;
break;
case 'u':
update = 1;
break;
case 'v':
config.verbose = 1;
break;
default:
usage(argv[0]);
goto end;
}
/* Keep a copy of the last optarg so we can distinguish between option arguments and file names later on */
if(optarg)
{
if(last_optarg) free(last_optarg);
last_optarg = strdup(optarg);
}
}
/* Update magic files from SVN repository */
if(update)
{
printf("Updating magic signatures...");
if(update_magic_file(BINWALK_UPDATE_URL, MAGIC) &&
update_magic_file(BINCAST_UPDATE_URL, MAGIC_CAST) &&
update_magic_file(BINARCH_UPDATE_URL, MAGIC_ARCH))
{
printf("finished.\n");
retval = EXIT_SUCCESS;
}
else
{
printf("failed.\n");
}
goto end;
}
/* Unless otherwise specified, apply default filters */
if(use_default_filters)
{
add_filter(filters, &filter_count, FILTER_ADD, GZIP_FILTER);
add_filter(filters, &filter_count, FILTER_ADD, LZMA_FILTER);
add_filter(filters, &filter_count, FILTER_ADD, JFFS_FILTER);
add_filter(filters, &filter_count, FILTER_EXCLUDE, INVALID_FILTER);
}
/* Use the default magic file if none was specified on the command line */
if(config.magic == NULL)
{
config.magic = strdup(MAGIC);
}
/* Initialize libmagic */
config.cookie = magic_open(config.flags);
if(!config.cookie)
{
fprintf(stderr,"ERROR: Failed to initialize libmagic: %s\n", magic_error(config.cookie));
goto end;
}
/* Validate the magic file */
if(check_magic_file)
{
if(magic_check(config.cookie, config.magic) != 0)
{
fprintf(stderr, "ERROR: Invalid magic file '%s': %s\n", config.magic, magic_error(config.cookie));
}
else
{
retval = EXIT_SUCCESS;
}
goto end;
}
/* If an output file was specified, open it */
if(out_file != NULL)
{
globals.fsout = fopen(out_file,"w");
if(!globals.fsout)
{
perror("ERROR: Failed to open output file for writing");
goto end;
}
}
/* Load the magic signatures file */
if(magic_load(config.cookie, config.magic) == -1)
{
fprintf(stderr,"ERROR: Failed to load magic file '%s': %s\n", config.magic, magic_error(config.cookie));
goto end;
}
if(config.smart)
{
/* Load magic signatures into the signatures struct array. */
magic_file_contents = (char *) file_read((char *) config.magic, &mfsize);
marker = magic_file_contents;
for(i=0; i<mfsize && num_sigs < MAX_SIGNATURES; i++)
{
/* The first line for each magic entry will start with a decimal offset value. This is the line
* that contains the actual signature, and is the one we want to parse. The rest are comments,
* whitespace or subsequent signture parsing data that we let libmagic handle later on.
*/
if(marker[0] >= '0' && marker[0] <= '9')
{
/* Parse out the magic value, file offset and size for this entry */
magic = parse_magic(marker, &magic_offset, &magic_size, &wildcard, filters, filter_count, ignore_short_sigs, fast_filter);
if(magic && magic_size > 0)
{
signatures[num_sigs] = malloc(sizeof(struct magic_signature));
signatures[num_sigs]->size = magic_size;
signatures[num_sigs]->offset = magic_offset;
signatures[num_sigs]->wildcard = wildcard;
signatures[num_sigs]->signature = malloc(magic_size);
memcpy(signatures[num_sigs]->signature, magic, magic_size);
num_sigs++;
}
if(magic) free(magic);
}
/* Find the next new line. Break if not found, skip to the next character if one is found. */
marker = strstr(marker, "\n");
if(!marker) break;
marker++;
}
}
else
{
num_sigs = 1;
}
/* Process all the files specified on the command line */
for(i=argc-1; i>0; i--)
{
/* If we've gotten to the arguments, we're done */
if((argv[i][0] == '-') ||
((last_optarg != NULL) && (strcmp(argv[i], last_optarg) == 0))
)
{
break;
}
retval = process_file(argv[i], &config, signatures, num_sigs, filters, filter_count);
}
end:
if(config.magic) free(config.magic);
if(magic_file_contents) munmap((void *) magic_file_contents, mfsize);
if(globals.fsout != NULL) fclose(globals.fsout);
if(config.cookie) magic_close(config.cookie);
return retval;
}
/* Casts libmagic on the file <lpfile> to determine its type and
* tries to find and run a handler for that type of files.
*/
int runmime (wchar_t *logfile, LPSHELLEXECUTEINFOW einfo, wchar_t *lpfile, wchar_t *lpdirectory)
{
magic_t magicmimetype = NULL, magicmimeencoding = NULL, magicapple = NULL, magicname = NULL;
char *mimetype, *mimeencoding, *apple, *name;
char *argv1 = NULL;
MimeResults mres;
int ret = 0;
logtofilew (logfile, L">runmime\n");
magicname = load (NULL, MAGIC_NONE);
magicmimetype = load (NULL, MAGIC_MIME_TYPE);
magicmimeencoding = load (NULL, MAGIC_MIME_ENCODING);
magicapple = load (NULL, MAGIC_APPLE);
logtofilew (logfile, L"magics: %08x, %08x, %08x, %08x\n", magicname, magicmimetype, magicmimeencoding, magicapple);
wchartostr (lpfile, &argv1, CP_THREAD_ACP);
logtofilew (logfile, L"file to check is %S\n", argv1);
memset (&mres, 0, sizeof (mres));
mres.type = (char *) magic_file (magicmimetype, argv1);
mres.enc = (char *) magic_file (magicmimeencoding, argv1);
mres.apple = (char *) magic_file (magicapple, argv1);
mres.name = (char *) magic_file (magicname, argv1);
logtofilew (logfile, L"magic results: {%S} {%S} {%S} {%S}\n", mres.name, mres.type, mres.enc, mres.apple);
if (mres.name != NULL)
mres.name = strdup (mres.name);
if (mres.type != NULL)
mres.type = strdup (mres.type);
if (mres.enc != NULL)
mres.enc = strdup (mres.enc);
if (mres.apple != NULL)
mres.apple = strdup (mres.apple);
strtowchar (mres.name, &mres.wname, CP_THREAD_ACP);
strtowchar (mres.type, &mres.wtype, CP_THREAD_ACP);
strtowchar (mres.enc, &mres.wenc, CP_THREAD_ACP);
strtowchar (mres.apple, &mres.wapple, CP_THREAD_ACP);
magic_close (magicmimetype);
magic_close (magicmimeencoding);
magic_close (magicapple);
magic_close (magicname);
if (argv1 != NULL)
free (argv1);
if (mres.type == NULL && mres.apple == NULL && mres.name == NULL)
{
logtofilew (logfile, L"Zero results, returning.\n");
ret = -1;
}
else
{
ret = handle (logfile, &mres, einfo, lpfile, lpdirectory);
}
if (mres.name != NULL)
free (mres.name);
if (mres.type != NULL)
free (mres.type);
if (mres.enc != NULL)
free (mres.enc);
if (mres.apple != NULL)
free (mres.apple);
if (mres.wname != NULL)
free (mres.wname);
if (mres.wtype != NULL)
free (mres.wtype);
if (mres.wenc != NULL)
free (mres.wenc);
if (mres.wapple != NULL)
free (mres.wapple);
logtofilew (logfile, L"<runmime %d\n", ret);
return ret;
}
/**
* \brief Get the mimetype for a package
* \param argc the number of command line arguments
* \param argv the command line arguments
* \return 0 on a successful program execution
*/
int main(int argc, char *argv[])
{
int arg;
char *Parm = NULL;
char *Path = NULL;
int c;
char *agent_desc = "Determines mimetype for each file";
int pfile_count = 0;
int Agent_pk;
int ars_pk = 0;
int upload_pk = 0; // the upload primary key
int user_pk = 0;
char *AgentARSName = "mimetype_ars";
int rv;
PGresult *result;
char sqlbuf[1024];
int CmdlineFlag = 0; /** run from command line flag, 1 yes, 0 not */
char *SVN_REV;
char *VERSION;
char agent_rev[MAXCMD];
/** initialize the scheduler connection */
fo_scheduler_connect(&argc, argv, &pgConn);
/* Process command-line */
while((c = getopt(argc,argv,"iCc:hvV")) != -1)
{
switch(c)
{
case 'i':
PQfinish(pgConn);
return(0);
case 'c':
/* do nothing with this option */
break;
case 'C':
CmdlineFlag = 1;
break;
case 'v':
agent_verbose++;
break;
case 'V':
printf("%s", BuildVersion);
PQfinish(pgConn);
return(0);
default:
Usage(argv[0]);
PQfinish(pgConn);
exit(-1);
}
}
SVN_REV = fo_sysconfig("mimetype", "SVN_REV");
VERSION = fo_sysconfig("mimetype", "VERSION");
sprintf(agent_rev, "%s.%s", VERSION, SVN_REV);
/* Get the Agent Key from the DB */
Agent_pk = fo_GetAgentKey(pgConn, basename(argv[0]), 0, agent_rev, agent_desc);
FMimetype = fopen("/etc/mime.types","rb");
if (!FMimetype)
{
LOG_WARNING("Unable to open /etc/mime.types\n");
}
MagicCookie = magic_open(MAGIC_PRESERVE_ATIME|MAGIC_MIME);
if (MagicCookie == NULL)
{
LOG_FATAL("Failed to initialize magic cookie\n");
PQfinish(pgConn);
exit(-1);
}
if (magic_load(MagicCookie,NULL) != 0)
{
LOG_FATAL("Failed to load magic file: UnMagic\n");
PQfinish(pgConn);
exit(-1);
}
/* Run from the command-line (for testing) */
for(arg=optind; arg < argc; arg++)
{
Akey = -1;
memset(A,'\0',sizeof(A));
strncpy(A,argv[arg],sizeof(A));
DBCheckMime(A);
}
/* Run from scheduler! */
if (0 == CmdlineFlag)
{
user_pk = fo_scheduler_userID(); /* get user_pk for user who queued the agent */
while(fo_scheduler_next())
{
/** get piece of information, including upload_pk, others */
Parm = fo_scheduler_current();
if (Parm && Parm[0])
{
upload_pk = atoi(Parm);
/* Check Permissions */
if (GetUploadPerm(pgConn, upload_pk, user_pk) < PERM_WRITE)
{
LOG_ERROR("You have no update permissions on upload %d", upload_pk);
continue;
}
/* does ars table exist?
* If not, create it.
*/
rv = fo_tableExists(pgConn, AgentARSName);
if (!rv)
{
rv = fo_CreateARSTable(pgConn, AgentARSName);
if (!rv) return(0);
}
/* check ars table if this is duplicate request*/
memset(sqlbuf, 0, sizeof(sqlbuf));
snprintf(sqlbuf, sizeof(sqlbuf),
"select ars_pk from mimetype_ars,agent \
where agent_pk=agent_fk and ars_success=true \
and upload_fk='%d' and agent_fk='%d'",
upload_pk, Agent_pk);
result = PQexec(pgConn, sqlbuf);
if (fo_checkPQresult(pgConn, result, sqlbuf, __FILE__, __LINE__)) exit(-1);
if (PQntuples(result) > 0)
{
PQclear(result);
LOG_WARNING("Ignoring requested mimetype analysis of upload %d - Results are already in database.\n",upload_pk);
continue;
}
PQclear(result);
/* Record analysis start in mimetype_ars, the mimetype audit trail. */
ars_pk = fo_WriteARS(pgConn, ars_pk, upload_pk, Agent_pk, AgentARSName, 0, 0);
/** get all pfile ids on a upload record */
memset(sqlbuf, 0, sizeof(sqlbuf));
snprintf(sqlbuf, sizeof(sqlbuf), "SELECT DISTINCT(pfile_pk) as Akey, pfile_sha1 || '.' || pfile_md5 || '.' || pfile_size AS A FROM uploadtree, pfile WHERE uploadtree.pfile_fk = pfile.pfile_pk AND pfile_mimetypefk is NULL AND upload_fk = '%d';", upload_pk);
result = PQexec(pgConn, sqlbuf);
if (fo_checkPQresult(pgConn, result, sqlbuf, __FILE__, __LINE__)) exit(-1);
pfile_count = PQntuples(result);
int i;
for(i=0; i < pfile_count; i++)
{
Akey = atoi(PQgetvalue(result, i, 0));
strncpy(A, PQgetvalue(result, i, 1), sizeof(A));
if (Akey <= 0 || A[0]=='\0')
{
printf("ERROR: Data is in an unknown format.\n");
PQfinish(pgConn);
exit(-1);
}
/* Process the repository file */
/** Find the path **/
Path = fo_RepMkPath("files",A);
if (Path && fo_RepExist("files",A))
{
/* Get the mimetype! */
DBCheckMime(Path);
}
else
{
printf("ERROR pfile %d Unable to process.\n",Akey);
printf("LOG pfile %d File '%s' not found.\n",Akey,A);
PQfinish(pgConn);
exit(-1);
}
/* Clean up Path memory */
if(Path)
{
free(Path);
Path = NULL;
}
fo_scheduler_heart(1);
}
PQclear(result);
/* Record analysis success in mimetype_ars. */
if (ars_pk) fo_WriteARS(pgConn, ars_pk, upload_pk, Agent_pk, AgentARSName, 0, 1);
}
}
} /* if run from scheduler */
/* Clean up */
if (FMimetype) fclose(FMimetype);
magic_close(MagicCookie);
if (DBMime) PQclear(DBMime);
if (pgConn) PQfinish(pgConn);
/** after cleaning up agent, disconnect from the scheduler, this doesn't return */
fo_scheduler_disconnect(0);
return(0);
} /* main() */
// search inode by use imap (step1: flag 1 = only directory ; step2: flag 0 = only file)
static void search_imap_inode(char* des_dir, __u32 t_after, __u32 t_before, int flag)
{
struct ext2_group_desc *gdp;
struct ext2_inode_large *inode;
//struct dir_list_head_t *dir = NULL;
struct ring_buf* i_list = NULL;
r_item* item = NULL;
int zero_flag, retval, load, x ,i ;
char *pathname = NULL;
char *i_pathname = NULL;
char *buf= NULL;
unsigned char *tmp_buf = NULL;
__u32 blocksize, inodesize, inode_max, inode_per_group, block_count;
__u32 inode_per_block , inode_block_group, group;
blk_t block_nr;
__u32 c_time, d_time, mode;
ext2_ino_t first_block_inode_nr , inode_nr;
pathname = malloc(26);
blocksize = current_fs->blocksize;
inodesize = current_fs->super->s_inode_size;
inode_max = current_fs->super->s_inodes_count;
inode_per_group = current_fs->super->s_inodes_per_group;
buf = malloc(blocksize);
if (! (flag & 0x01) ){
tmp_buf = malloc (12 * blocksize);
if (!tmp_buf)
goto errout;
cookie = magic_open(MAGIC_MIME | MAGIC_NO_CHECK_COMPRESS | MAGIC_NO_CHECK_ELF | MAGIC_CONTINUE);
if ((! cookie) || magic_load(cookie, NULL)){
fprintf(stderr,"ERROR: can't find libmagic\n");
goto errout;
}
}
inode_per_block = blocksize / inodesize;
inode_block_group = inode_per_group / inode_per_block;
for (group = 0 ; group < current_fs->group_desc_count ; group++){
#ifdef EXT2_FLAG_64BITS
gdp = ext2fs_group_desc(current_fs, current_fs->group_desc, group);
#else
gdp = ¤t_fs->group_desc[group];
#endif
zero_flag = 0;
if (!(flag & 0x02)){ //skip this in disaster mode
// NEXT GROUP IF INODE NOT INIT
if (gdp->bg_flags & (EXT2_BG_INODE_UNINIT)) continue;
// SET ZERO-FLAG IF FREE INODES == INODE/GROUP for fast ext3
if (gdp->bg_free_inodes_count == inode_per_group) zero_flag = 1;
}
//FIXME for struct ext4_group_desc 48/64BIT
for (block_nr = gdp->bg_inode_table , block_count = 0 ;
block_nr < (gdp->bg_inode_table + inode_block_group); block_nr++, block_count++) {
if (!(flag & 0x02)){ //skip this in disaster mode
// break if the first block only zero inode
if ((block_count ==1) && (zero_flag == (inode_per_block + 1))) break;
}
//FIXME inode_max ????
first_block_inode_nr = (group * inode_per_group) + (block_count * inode_per_block) + 1;
load = 0;
for (i = 0; i<inode_per_block;i++){
if ( ! ext2fs_test_block_bitmap(imap,first_block_inode_nr + i)){
load++;
break;
}
}
if (load){
retval = read_block ( current_fs , &block_nr , buf);
if (retval) return;
for (inode_nr = first_block_inode_nr ,x = 0; x < inode_per_block ; inode_nr++ , x++){
if ( ! ext2fs_test_block_bitmap(imap,inode_nr)){
inode = (struct ext2_inode_large*) (buf + (x*inodesize));
c_time = ext2fs_le32_to_cpu(inode->i_ctime);
mode = ext2fs_le32_to_cpu(inode->i_mode);
if ( ! ( flag & 0x02)) {
//no check this inode in disaster mode
if ((! c_time ) && (!(inode->i_mode & LINUX_S_IFMT)) ) {
if(zero_flag) zero_flag++ ;
continue;
}
d_time = ext2fs_le32_to_cpu(inode->i_dtime);
if ( (! d_time) || d_time <= t_after){
ext2fs_mark_generic_bitmap(imap,inode_nr);
continue;
}
}
// 1. magical step
if (LINUX_S_ISDIR(mode) && ( flag & 0x01) && (pathname)){
sprintf(pathname,"<%lu>",(long unsigned int)inode_nr);
struct dir_list_head_t * dir = NULL;
if (flag & 0x02){
//disaster mode
//only search for undeleted entry
dir = get_dir3(NULL,0, inode_nr , "MAGIC-1",pathname, t_after,t_before, 0);
if (dir) {
lookup_local(des_dir, dir,t_after,t_before, RECOV_ALL | LOST_DIR_SEARCH );
clear_dir_list(dir);
}
}
else{ //search for all
dir = get_dir3(NULL,0, inode_nr , "MAGIC-1",pathname, t_after,t_before, DELETED_OPT);
if (dir) {
lookup_local(des_dir,dir,t_after,t_before,DELETED_OPT|RECOV_ALL|LOST_DIR_SEARCH);
clear_dir_list(dir);
}
}
}
// 2. magical step
if (! (flag & 0x01) ){
i_list = get_j_inode_list(current_fs->super, inode_nr);
item = get_undel_inode(i_list,t_after,t_before);
ext2fs_mark_generic_bitmap(imap,inode_nr);
if (item) {
if (! LINUX_S_ISDIR(item->inode->i_mode) ) {
i_pathname = identify_filename(i_pathname, tmp_buf,
(struct ext2_inode*)item->inode, inode_nr);
sprintf(pathname,"<%lu>",(long unsigned int)inode_nr);
recover_file(des_dir,"MAGIC-2", ((i_pathname)?i_pathname : pathname),
(struct ext2_inode*)item->inode, inode_nr, 0);
if(i_pathname){
free(i_pathname);
i_pathname = NULL;
}
}
}
if (i_list) ring_del(i_list);
}
}
}
}
}
}
errout:
if (pathname)
free(pathname);
if(buf) {
free(buf);
buf = NULL;
}
if (tmp_buf){
free(tmp_buf);
tmp_buf = NULL;
}
if (cookie){
magic_close(cookie);
cookie = 0;
}
return;
}
~CarlaMagic()
{
if (fMagic != nullptr)
magic_close(fMagic);
}
static void magic_destroy_notify(gpointer data)
{
magic_close((magic_t)data);
}