Пример #1
0
int main(void)
{
	char *s = "/path/file";
  const char * ftype;

  int msflags = MAGIC_CHECK | MAGIC_COMPRESS | MAGIC_NO_CHECK_TOKENS;
  magic_t ms = NULL;
  ms = magic_open(msflags);
  if (ms == NULL) {
      printf("magic_open(0x%x) failed: %s\n", msflags, errno);
      return 1;
  }

  if (magic_load(ms, NULL) == -1) {
	    printf("magic_load failed: %s\n", magic_error(ms));
      return 1;
  }

  ftype = magic_file(ms, s);

  if (ftype == NULL) {
      printf("Error reconociendo fichero: %s", magic_error(ms));
	    return 1;
  } else {
      printf("tipo de fichero: %s\n", ftype);
  }

  magic_close(ms);

  return 0;
}
Пример #2
0
/**
 *  \brief Initialize the "magic" context.
 */
int MagicInit(void)
{
    BUG_ON(g_magic_ctx != NULL);

    SCEnter();

    char *filename = NULL;
    FILE *fd = NULL;

    SCMutexInit(&g_magic_lock, NULL);
    SCMutexLock(&g_magic_lock);

    g_magic_ctx = magic_open(0);
    if (g_magic_ctx == NULL) {
        SCLogError(SC_ERR_MAGIC_OPEN, "magic_open failed: %s",
                magic_error(g_magic_ctx));
        goto error;
    }

    (void)ConfGet("magic-file", &filename);


    if (filename != NULL) {
        if (strlen(filename) == 0) {
            /* set filename to NULL on *nix systems so magic_load uses system
             * default path (see man libmagic) */
            SCLogConfig("using system default magic-file");
            filename = NULL;
        }
        else {
            SCLogConfig("using magic-file %s", filename);

            if ( (fd = fopen(filename, "r")) == NULL) {
                SCLogWarning(SC_ERR_FOPEN, "Error opening file: \"%s\": %s",
                        filename, strerror(errno));
                goto error;
            }
            fclose(fd);
        }
    }

    if (magic_load(g_magic_ctx, filename) != 0) {
        SCLogError(SC_ERR_MAGIC_LOAD, "magic_load failed: %s",
                magic_error(g_magic_ctx));
        goto error;
    }

    SCMutexUnlock(&g_magic_lock);
    SCReturnInt(0);

error:
    if (g_magic_ctx != NULL) {
        magic_close(g_magic_ctx);
        g_magic_ctx = NULL;
    }

    SCMutexUnlock(&g_magic_lock);
    SCReturnInt(-1);
}
Пример #3
0
void FileType::init() {
	magic_ = magic_open(MAGIC_MIME_TYPE | MAGIC_NO_CHECK_COMPRESS); 
	if (!magic_) {
		printf("Error:%s", magic_error(magic_));
	}
	if (magic_load(magic_, 0)) {
		printf("Error:%s", magic_error(magic_));
	}
}
Пример #4
0
static void *DetectFilemagicThreadInit(void *data)
{
    char *filename = NULL;
    FILE *fd = NULL;
    DetectFilemagicData *filemagic = (DetectFilemagicData *)data;
    BUG_ON(filemagic == NULL);

    DetectFilemagicThreadData *t = SCMalloc(sizeof(DetectFilemagicThreadData));
    if (unlikely(t == NULL)) {
        SCLogError(SC_ERR_MEM_ALLOC, "couldn't alloc ctx memory");
        return NULL;
    }
    memset(t, 0x00, sizeof(DetectFilemagicThreadData));

    t->ctx = magic_open(0);
    if (t->ctx == NULL) {
        SCLogError(SC_ERR_MAGIC_OPEN, "magic_open failed: %s", magic_error(t->ctx));
        goto error;
    }

    (void)ConfGet("magic-file", &filename);
    if (filename != NULL) {
        if (strlen(filename) == 0) {
            /* set filename to NULL on *nix systems so magic_load uses system default path (see man libmagic) */
            SCLogInfo("using system default magic-file");
            filename = NULL;
        }
        else {
            SCLogInfo("using magic-file %s", filename);

            if ( (fd = fopen(filename, "r")) == NULL) {
                SCLogWarning(SC_ERR_FOPEN, "Error opening file: \"%s\": %s", filename, strerror(errno));
                goto error;
            }
            fclose(fd);
        }
    }

    if (magic_load(t->ctx, filename) != 0) {
        SCLogError(SC_ERR_MAGIC_LOAD, "magic_load failed: %s", magic_error(t->ctx));
        goto error;
    }

    return (void *)t;

error:
    if (t->ctx)
        magic_close(t->ctx);
    SCFree(t);
    return NULL;
}
Пример #5
0
int
main(int argc, char **argv)
{
	struct magic_set *ms;
	const char *result;
	char *desired;
	size_t desired_len;
	int i;
	FILE *fp;

	ms = magic_open(MAGIC_NONE);
	if (ms == NULL) {
		(void)fprintf(stderr, "ERROR opening MAGIC_NONE: out of memory\n");
		return 10;
	}
	if (magic_load(ms, NULL) == -1) {
		(void)fprintf(stderr, "ERROR loading with NULL file: %s\n", magic_error(ms));
		return 11;
	}

	if (argc > 1) {
		if (argc != 3) {
			(void)fprintf(stderr, "Usage: test TEST-FILE RESULT\n");
		} else {
			if ((result = magic_file(ms, argv[1])) == NULL) {
				(void)fprintf(stderr, "ERROR loading file %s: %s\n", argv[1], magic_error(ms));
				return 12;
			} else {
				fp = fopen(argv[2], "r");
				if (fp == NULL) {
					(void)fprintf(stderr, "ERROR opening `%s': ", argv[2]);
					perror(NULL);
					return 13;
				}
				desired = slurp(fp, &desired_len);
				fclose(fp);
				(void)printf("%s: %s\n", argv[1], result);
                                if (strcmp(result, desired) != 0) {
					(void)fprintf(stderr, "Error: result was\n%s\nexpected:\n%s\n", result, desired);
					return 1;
                                }
			}
		}
	}

	magic_close(ms);
	return 0;
}
Пример #6
0
static PyObject* py_magic_buffer(PyObject* self, PyObject* args)
{
    PyObject *pycookie;
    magic_t cookie;
    void* buffer = NULL;
    int buffer_length = 0;
    const char* message = NULL;
    PyObject* result = Py_None;

    if(!(PyArg_ParseTuple(args, "Os#", &pycookie, (char**)&buffer, 
    						&buffer_length)))
        return NULL;

    cookie = PyCObject_AsVoidPtr(pycookie);

    message = magic_buffer(cookie, buffer, buffer_length);

    if(message != NULL) {
        result = PyString_FromString(message);
    } else {
    	/** An error occurs we return it now: */
        PyErr_SetString(PyExc_RuntimeError, magic_error(cookie));
	return NULL;
    };
    
    return PyString_FromString(message);
}
Пример #7
0
QString Configuration::getMimeType(const QFileInfo& info) {
    QString result("application/octet-stream");
    magic_t magicMimePredictor;
    magicMimePredictor = magic_open(MAGIC_MIME_TYPE); // Open predictor
    if (!magicMimePredictor) {
        qDebug() << "libmagic: Unable to initialize magic library";
    }
    else
    {
        if (magic_load(magicMimePredictor, 0)) { // if not 0 - error
            qDebug() << "libmagic: Can't load magic database - " +
                        QString(magic_error(magicMimePredictor));
            magic_close(magicMimePredictor); // Close predictor
        }
        else
        {
            char *file = info.canonicalFilePath().toAscii().data();
            const char *mime;
            mime = magic_file(magicMimePredictor, file); // getting mime-type
            result = QString(mime);
            magic_close(magicMimePredictor); // Close predictor
        }
    }
    qDebug() << "libmagic: result mime type - " + result + "for file: " +
                info.canonicalFilePath();
    return result;
}
Пример #8
0
QString getFileMimeType(const QFileInfo& fileInfo)
{

    QString result("application/octet-stream");

    magic_t magicMimePredictor;
    magicMimePredictor = magic_open(MAGIC_MIME_TYPE); // Open predictor
    if (!magicMimePredictor) {
        qWarning() << "libmagic: Unable to initialize magic library";
        return result;
    }


    if (magic_load(magicMimePredictor, 0)) { // if not 0 - error
        qWarning() << QString("libmagic: Can't load magic database - %1").arg(magic_error(magicMimePredictor));
        magic_close(magicMimePredictor); // Close predictor
        return result;
    }

    QByteArray ar = fileInfo.absoluteFilePath().toLocal8Bit();
    char *file = ar.data();

    // getting mime-type ........................
    const char *mime;
    mime = magic_file(magicMimePredictor, file);
    result = QString(mime);

    // Close predictor ..........................
    magic_close(magicMimePredictor);

    return result;
}
Пример #9
0
const char* FileType::get_file_type(char* file_name) {
	const char* mime = magic_file(magic_, file_name);
	if (!mime) {
		printf("Error:%s", magic_error(magic_));
	}
	return mime;
}
Пример #10
0
static VALUE
magic_library_error(VALUE klass, void *data)
{
    magic_exception_t e;
    const char *message = NULL;
    const char *empty = "(null)";

    magic_t cookie = data;
    assert(cookie != NULL && "Must be a valid pointer to `magic_t' type");

    e.magic_errno = -1;
    e.magic_error = error(E_UNKNOWN);
    e.klass = klass;

    message = magic_error(cookie);
    if (message) {
        e.magic_errno = magic_errno(cookie);
        e.magic_error = message;
    }

    assert(strncmp(e.magic_error, empty, strlen(empty)) != 0 && \
            "Empty or invalid error message");

    return magic_exception(&e);
}
Пример #11
0
/*
 * call-seq:
 *    magic.file( path ) -> string or array
 *
 * Returns
 *
 * Example:
 *
 *    magic = Magic.new   #=> #<Magic:0x007f8fdc012e58>
 *
 * Will raise <i>Magic::LibraryError</i> exception if, or
 *
 * See also: Magic#buffer and Magic#descriptor
 */
VALUE
rb_mgc_file(VALUE object, VALUE value)
{
    int rv;
    magic_arguments_t ma;
    const char *cstring = NULL;
    const char *empty = "(null)";

    Check_Type(value, T_STRING);

    CHECK_MAGIC_OPEN(object);
    MAGIC_COOKIE(ma.cookie);

    ma.flags = NUM2INT(rb_mgc_getflags(object));
    ma.data.file.path = RVAL2CSTR(value);

    cstring = (const char *)MAGIC_SYNCHRONIZED(magic_file_internal, &ma);
    if (!cstring) {
        rv = magic_version_wrapper();

        if (ma.flags & MAGIC_ERROR) {
            MAGIC_LIBRARY_ERROR(ma.cookie);
        }
        else if (rv < 515) {
            (void)magic_errno(ma.cookie);
            cstring = magic_error(ma.cookie);
        }
    }

    assert(cstring != NULL && "Must be a valid pointer to `const char' type");
    assert(strncmp(cstring, empty, strlen(empty)) != 0 && \
            "Empty or invalid result");

    return magic_return(CSTR2RVAL(cstring), &ma);
}
Пример #12
0
static PyObject* py_magic_file(PyObject* self, PyObject* args)
{
    char* filename = NULL;
    PyObject *pycookie;
    magic_t cookie;
    const char* message = NULL;
    PyObject* result = Py_None;

    if(!(PyArg_ParseTuple(args, "Os", &pycookie, &filename)))
        return NULL;

    cookie = PyCObject_AsVoidPtr(pycookie);

    message = magic_file(cookie, filename);

    if(message != NULL) {
        result = PyString_FromString(message);
    } else {
    	/** An error occurs we return it now: */
        PyErr_SetString(PyExc_RuntimeError, magic_error(cookie));
	return NULL;
    };
    
    return PyString_FromString(message);
}
Пример #13
0
    /**
     * The run() method is where the module's work is performed.
     * The module will be passed a pointer to a file from which both
     * content and metadata can be retrieved.
     * @param pFile A pointer to a file to be processed.
     * @returns TskModule::OK on success and TskModule::FAIL on error.
     */
    TskModule::Status TSK_MODULE_EXPORT run(TskFile * pFile)
    {
        if (pFile == NULL)
        {
            LOGERROR("FileTypeSigModule: Passed NULL file pointer.");
            return TskModule::FAIL;
        }

        if (pFile->getSize() == 0)
            return TskModule::OK;

        try
        {
            char buffer[FILE_BUFFER_SIZE];

            //Do that magic magic
            ssize_t readLen = pFile->read(buffer, FILE_BUFFER_SIZE);
            // we shouldn't get zero as a return value since we know the file is not 0 sized at this point
            if (readLen <= 0) {
                std::stringstream msg;
                msg << "FileTypeSigModule: Error reading file contents for file " << pFile->getId();
                LOGERROR(msg.str());
                return TskModule::FAIL;
            }

            const char *type = magic_buffer(magicHandle, buffer, readLen);
            if (type == NULL) {
                std::stringstream msg;
                msg << "FileTypeSigModule: Error getting file type: " << magic_error(magicHandle);
                LOGERROR(msg.str());
                return TskModule::FAIL;
            }

            // clean up type -- we've seen invalid UTF-8 data being returned
            char cleanType[1024];
            cleanType[1023] = '\0';
            strncpy(cleanType, type, 1023);
            TskUtilities::cleanUTF8(cleanType);

            // Add to blackboard
            TskBlackboardAttribute attr(TSK_FILE_TYPE_SIG, MODULE_NAME, "", cleanType);
            pFile->addGenInfoAttribute(attr);
        }
        catch (TskException& tskEx)
        {
            std::stringstream msg;
            msg << "FileTypeModule: Caught framework exception: " << tskEx.message();
            LOGERROR(msg.str());
            return TskModule::FAIL;
        }
        catch (std::exception& ex)
        {
            std::stringstream msg;
            msg << "FileTypeModule: Caught exception: " << ex.what();
            LOGERROR(msg.str());
            return TskModule::FAIL;
        }

        return TskModule::OK;
    }
Пример #14
0
/** Get filetype of file given by file descriptor.
 * Returns a long decriptive string of the filetype, similar to the file
 * console utility.
 * @param fd file descriptor of open file, make sure the file descriptor is rewinded
 * Warning, the file descriptor is closed by the underlying libmagic. Use dup() to
 * duplicate it and pass this as file descriptor if you need the file afterwards.
 * @return descriptive string
 */
std::string
filetype_file(int fd)
{
  std::string rv;

#ifdef HAVE_LIBMAGIC
  magic_t m = magic_open( MAGIC_ERROR );
  magic_load( m, NULL );

  const char * res = magic_descriptor( m, fd );
  if ( res == NULL ) {
    fawkes::Exception e("Failed to determine file type of descriptor: %s", magic_error(m));
    magic_close(m);
    throw e;
  }

  rv = res;
  magic_close( m );
#else
  throw fawkes::Exception("Failed to determine file type "
			  "(libmagic not available at compile time)");
#endif

  return rv;
}
Пример #15
0
void load_magic(void) {
	
	magic = magic_open(magic_flags);
	
	if (magic == NULL) {
		fprintf(stderr, "magic_open failed: %s\n", magic_error(magic));
		exit(1);
	}

	if (magic_load(magic, NULL) < 0) {
		fprintf(stderr, "magic_load failed: %s\n", magic_error(magic));
		exit(1);
	}

	return;
}
Пример #16
0
/** Get mime-type of file given by file descriptor.
 * This function gives a brief mime-type for the given file.
 * @param fd file descriptor of open file, make sure the file descriptor is rewinded.
 * Warning, the file descriptor is closed by the underlying libmagic. Use dup() to
 * duplicate it and pass this as file descriptor if you need the file afterwards.
 * @return descriptive string
 */
std::string
mimetype_file(int fd)
{
  std::string rv;

#ifdef HAVE_LIBMAGIC
#  ifdef MAGIC_MIME_TYPE
  magic_t m = magic_open( MAGIC_ERROR | MAGIC_MIME_TYPE );
#  else
  magic_t m = magic_open( MAGIC_ERROR | MAGIC_MIME );
#  endif
  magic_load( m, NULL );

  const char * res = magic_descriptor( m, fd );
  if ( res == NULL ) {
    fawkes::Exception e("Failed to determine mime type of descriptor: %s", magic_error(m));
    magic_close(m);
    throw e;
  }

  rv = res;
#  ifndef MAGIC_MIME_TYPE
  rv = rv.substr(0, rv.find(","));
#  endif
  magic_close(m);
#else
  throw fawkes::Exception("Failed to determine file type "
			  "(libmagic not available at compile time)");
#endif
  return rv;
}
Пример #17
0
rpmmg rpmmgNew(const char * fn, int flags)
{
    rpmmg mg = rpmmgGetPool(_rpmmgPool);
    int xx;

    if (fn)
	mg->fn = xstrdup(fn);
#if defined(HAVE_MAGIC_H)
    mg->flags = (flags ? flags : MAGIC_CHECK);/* XXX MAGIC_COMPRESS flag? */
    mg->ms = magic_open(flags);
    if (mg->ms == NULL) {
	rpmlog(RPMLOG_ERR, _("magic_open(0x%x) failed: %s\n"),
		flags, strerror(errno));
	return rpmmgFree(mg);
    }
    xx = magic_load(mg->ms, mg->fn);
    if (xx == -1) {
        rpmlog(RPMLOG_ERR, _("magic_load(ms, %s) failed: %s\n"),
                (fn ? fn : "(nil)"), magic_error(mg->ms));
	return rpmmgFree(mg);
    }
#endif

    return rpmmgLink(mg);
}
Пример #18
0
const char * rpmmgBuffer(rpmmg mg, const char * b, size_t nb)
{
    const char * t = NULL;

if (_rpmmg_debug)
fprintf(stderr, "--> rpmmgBuffer(%p, %p[%d])\n", mg, b, (int)nb);
    if (nb == 0) nb = strlen(b);
#if defined(HAVE_MAGIC_H)
    if (mg->ms) {
	t = magic_buffer(mg->ms, b, nb);
	/* XXX HACK: libmagic compiled without <pcreposix.h> spews here. */
	if (t == NULL) {
	    const char * msg = magic_error(mg->ms);
	    if (strstr(msg, "regexec error 17, (match failed)") == NULL)
		rpmlog(RPMLOG_ERR, _("magic_buffer(ms, %p[%u]) failed: %s\n"),
			b, (unsigned)nb, msg);
	}
    }
#endif

    if (t == NULL) t = "";
    t = xstrdup(t);

if (_rpmmg_debug)
fprintf(stderr, "<-- rpmmgBuffer(%p, %p[%d]) %s\n", mg, b, (int)nb, t);
    return t;
}
Пример #19
0
/*
 * Sandboxed magic_buffer invocation
 * 
 * a0 holds length of the output capabilty, a1 holds the length of the
 * magic data, and a2 holds the length of the input file buffer.  a3
 * indicates if timing data should be collected.
 */
int
invoke(register_t a0, register_t a1, register_t a2, register_t a3)
{
	int ret = 0;
	size_t outsize, magicsize, filesize;
	char *filebuf;
	const char *type, *errstr;
	void *magicbuf;
	magic_t magic;
	int dotimings;
	uint32_t timings[4];

	outsize = a0;
	magicsize = a1;
	filesize = a2;
	dotimings = a3;

	if (dotimings)
		timings[0] = sysarch(MIPS_GET_COUNT, NULL);

	if ((magicbuf = malloc(magicsize)) == NULL)
		return (-1);
	memcpy_fromcap(magicbuf, MINIFILE_MAGIC_CAP, 0, magicsize);
	magic = magic_open(MAGIC_MIME_TYPE);
        if (magic == NULL)
		return (-1);
        if (magic_load_buffers(magic, &magicbuf, &magicsize, 1) == -1) {
                magic_close(magic);
                return (-1);
        }

	if ((filebuf = malloc(filesize)) == NULL)
		return (-1);
	memcpy_fromcap(filebuf, MINIFILE_FILE_CAP, 0, filesize);

	if (dotimings)
		timings[1] = sysarch(MIPS_GET_COUNT, NULL);

        type = magic_buffer(magic, filebuf, filesize);
	if (type == NULL) {
		ret = -1;
		errstr = magic_error(magic);
		type = (errstr == NULL ? "badmagic" : errstr);
	}

	if (dotimings)
		timings[2] = sysarch(MIPS_GET_COUNT, NULL);

	memcpy_tocap(MINIFILE_OUT_CAP, type, 0, MIN(strlen(type) + 1, outsize));

	if (dotimings) {
		timings[3] = sysarch(MIPS_GET_COUNT, NULL);

		memcpy_tocap(MINIFILE_TIMING_CAP, timings, 0,
		    (4 * sizeof(uint32_t)));
	}

	return (ret);
}
Пример #20
0
bool FileDetector::isValid() const
{
    if (magic_error(mCookie))
    {
        return false;
    }
    return true;
}
Пример #21
0
/**
 *  \brief Initialize the "magic" context.
 */
int MagicInit(void)
{
    BUG_ON(g_magic_ctx != NULL);

    SCEnter();

    char *filename = NULL;
    FILE *fd = NULL;

    SCMutexInit(&g_magic_lock, NULL);
    SCMutexLock(&g_magic_lock);

    g_magic_ctx = magic_open(0);
    if (g_magic_ctx == NULL) {
        SCLogError(SC_ERR_MAGIC_OPEN, "magic_open failed: %s", magic_error(g_magic_ctx));
        goto error;
    }

    (void)ConfGet("magic-file", &filename);
    if (filename != NULL) {
        SCLogInfo("using magic-file %s", filename);

        if ( (fd = fopen(filename, "r")) == NULL) {
            SCLogWarning(SC_ERR_FOPEN, "Error opening file: \"%s\": %s", filename, strerror(errno));
            goto error;
        }
        fclose(fd);
    }

    if (magic_load(g_magic_ctx, filename) != 0) {
        SCLogError(SC_ERR_MAGIC_LOAD, "magic_load failed: %s", magic_error(g_magic_ctx));
        goto error;
    }

    SCMutexUnlock(&g_magic_lock);
    SCReturnInt(0);

error:
    if (g_magic_ctx != NULL) {
        magic_close(g_magic_ctx);
        g_magic_ctx = NULL;
    }

    SCMutexUnlock(&g_magic_lock);
    SCReturnInt(-1);
}
Пример #22
0
    /**
     * Module initialization function. Takes a string as input that allows
     * arguments to be passed into the module.
     * @param arguments Tells the module which
     */
    TskModule::Status TSK_MODULE_EXPORT initialize(const char* arguments)
    {
        magicHandle = magic_open(MAGIC_NONE);
        if (magicHandle == NULL) {
            LOGERROR("FileTypeSigModule: Error allocating magic cookie.");
            return TskModule::FAIL;
        }

//Attempt to load magic database from default places on Linux.
//Don't bother trying magic_load() for defaults on win32 because it will always cause an exception instead of gracefully returning.
#ifndef TSK_WIN32
        /* Load the default magic database, which is found in this order:
               1. MAGIC env variable
               2. $HOME/.magic.mgc (or $HOME/.magic dir)
               3. /usr/share/misc/magic.mgc (or /usr/share/misc/magic dir) (unless libmagic was build configured abnormally)
        */
        if (magic_load(magicHandle, NULL)) {
            std::stringstream msg;
            msg << "FileTypeSigModule: Error loading default magic file: " << magic_error(magicHandle);
            LOGERROR(msg.str());
            //don't return, just fall through to the default loading below
        } else {
            return TskModule::OK;
        }
#endif
        //Load the magic database file in the repo
        std::string path = GetSystemProperty(TskSystemProperties::MODULE_CONFIG_DIR) + Poco::Path::separator() + MODULE_NAME + Poco::Path::separator() + "magic.mgc";

        Poco::File magicFile = Poco::File(path);
        if (magicFile.exists() == false) {
            std::stringstream msg;
            msg << "FileTypeSigModule: Magic file not found: " << path;
            LOGERROR(msg.str());
            return TskModule::FAIL;
        }

        if (magic_load(magicHandle, path.c_str())) {
            std::stringstream msg;
            msg << "FileTypeSigModule: Error loading magic file: " << magic_error(magicHandle) << GetSystemProperty(TskSystemProperties::MODULE_CONFIG_DIR);
            LOGERROR(msg.str());
            return TskModule::FAIL;
        }

        return TskModule::OK;
    }
Пример #23
0
void init_magic(magic_t *cookie_ptr)
{
    if (!cookie_ptr || *cookie_ptr) {
        return;
    }

    *cookie_ptr = magic_open(MAGIC_MIME_TYPE);

    if (!*cookie_ptr) {
        const char *err = magic_error(*cookie_ptr);
        merror("%s: ERROR: Can't init libmagic: %s", ARGV0, err ? err : "unknown");
    } else if (magic_load(*cookie_ptr, NULL) < 0) {
        const char *err = magic_error(*cookie_ptr);
        merror("%s: ERROR: Can't load magic file: %s", ARGV0, err ? err : "unknown");
        magic_close(*cookie_ptr);
        *cookie_ptr = 0;
    }
}
Пример #24
0
const char * rpmmgFile(rpmmg mg, const char *fn)
{
    const char * t = NULL;

if (_rpmmg_debug)
fprintf(stderr, "--> rpmmgFile(%p, %s)\n", mg, (fn ? fn : "(nil)"));

#if defined(HAVE_MAGIC_H)
    if (mg->ms) {
	const char * lpath = NULL;
	int ut = urlPath(fn, &lpath);

	switch (ut) {
	case URL_IS_FTP:
	case URL_IS_HKP:
	case URL_IS_HTTP:
	case URL_IS_HTTPS:
	{   char b[512];
	    size_t nb = 0;
	    FD_t fd;
	    
	    fd = Fopen(fn, "r.ufdio");
	    if (fd != NULL && !Ferror(fd)) {
		nb = Fread(b, 1, sizeof(b), fd);
		(void) Fclose(fd);
	    }
	    if (nb > 0)
		return rpmmgBuffer(mg, b, nb);
	}   break;
	case URL_IS_DASH:
	case URL_IS_MONGO:	/* XXX FIXME */
	    break;
	case URL_IS_PATH:
	    fn = lpath;
	    /*@fallthrough@*/
	case URL_IS_UNKNOWN:
	default:
	    t = magic_file(mg->ms, fn);
	    /* XXX HACK: libmagic compiled without <pcreposix.h> spews here. */
	    if (t == NULL) {
		const char * msg = magic_error(mg->ms);
		if (strstr(msg, "regexec error 17, (match failed)") == NULL)
		    rpmlog(RPMLOG_ERR, _("magic_file(ms, %s) failed: %s\n"),
			    (fn ? fn : "(nil)"), msg);
	    }
	    break;
	}
    }
#endif

    if (t == NULL) t = "";
    t = xstrdup(t);

if (_rpmmg_debug)
fprintf(stderr, "<-- rpmmgFile(%p, %s) %s\n", mg, (fn ? fn : "(nil)"), t);
    return t;
}
Пример #25
0
FileDetector::FileDetector(const std::string &installDir): mCookie(magic_open(MAGIC_MIME_TYPE)), pBuffer(new char[MAGIC_BUFFER_SIZE])
{
    magic_load(mCookie, 0);
    if (magic_error(mCookie))
    {
        magic_close(mCookie);
        mCookie = magic_open(MAGIC_MIME_TYPE);
        magic_load(mCookie, (installDir + "magic.mgc").c_str());
    }
}
Пример #26
0
static const char*
guess_type_magic(const char* path) {
  const char* mime_type = NULL;

  /* creat magic cookie */
  const int flags =
    MAGIC_MIME_TYPE |
    MAGIC_SYMLINK |
    MAGIC_NO_CHECK_APPTYPE |
    MAGIC_NO_CHECK_CDF |
    MAGIC_NO_CHECK_ELF |
    MAGIC_NO_CHECK_ENCODING;
  magic_t magic = magic_open(flags);
  if (magic == NULL) {
    girara_debug("failed creating the magic cookie");
    goto cleanup;
  }

  /* ... and load mime database */
  if (magic_load(magic, NULL) < 0) {
    girara_debug("failed loading the magic database: %s", magic_error(magic));
    goto cleanup;
  }

  /* get the mime type */
  mime_type = magic_file(magic, path);
  if (mime_type == NULL) {
    girara_debug("failed guessing filetype: %s", magic_error(magic));
    goto cleanup;
  }
  /* dup so we own the memory */
  mime_type = g_strdup(mime_type);

  girara_debug("magic detected filetype: %s", mime_type);

cleanup:
  if (magic != NULL) {
    magic_close(magic);
  }

  return mime_type;
}
Пример #27
0
int main(int argc, char *argv[])
{
    const char *magic_result;
    magic_t magic_cookie;
    int ret = EXIT_FAILURE;
    const int MAGIC_FLAGS_LENGTH = 3;
    struct magic_flag_s magic_flags[] = {
        mk_magic_flag(MAGIC_NONE),
        mk_magic_flag(MAGIC_MIME),
        mk_magic_flag(MAGIC_MIME_ENCODING),
    };

    // Function magic_open() takes flags that modify libmagic's behaviour, but
    // they can be modified later by using function magic_setflags().
    magic_cookie = magic_open(MAGIC_NONE); 
    if (magic_cookie == NULL)
    {
        printf("Unable to initialize libmagic.\n");
        goto fail;
    }

    // NULL - Using default database, it is possible to specify your own.
    if (magic_load(magic_cookie, NULL) != 0)
    {
        printf("Failed while loading magic database: %s\n",
            magic_error(magic_cookie));
        goto fail_with_cleanup;
    }

    for (int i = 1; i < argc; i++)
    {
        for (int j = 0; j < MAGIC_FLAGS_LENGTH; j++)
        {
            magic_setflags(magic_cookie, magic_flags[j].value);

            // I'm assuming that magic_file() returns pointer to some allocated
            // memmory associated with magic_cookie and therefore it's not
            // necessary to dealocate it afterwards.
            magic_result = magic_file(magic_cookie, argv[i]);
            if (magic_result != NULL)
            {
                printf("Result with %s flag: %s\n",
                    magic_flags[j].string, magic_result);
            }
        }
    }
    ret = EXIT_SUCCESS;

fail_with_cleanup:
    magic_close(magic_cookie);

fail:
    return ret;
}
Пример #28
0
/* Use libmagic to detect file language
 */
const char *detect_language_magic(SourceFile *sourcefile) {
  char line[80];

  magic_t cookie = magic_open(MAGIC_NONE);
  if (cookie == NULL) {
    fprintf(stderr, "libmagic: %s\n", magic_error(cookie));
    exit(1);
  }
  if (magic_load(cookie, NULL) != 0) {
    fprintf(stderr, "libmagic: %s\n", magic_error(cookie));
    magic_close(cookie);
    exit(1);
  }

  if (sourcefile->diskpath) {
    const char *magic = magic_file(cookie, sourcefile->diskpath);
    if (magic == NULL) {
      fprintf(stderr, "libmagic: %s\n", magic_error(cookie));
      magic_close(cookie);
      exit(1);
    }
    strncpy(line, magic, sizeof(line));
    line[sizeof(line)-1] = '\0';
  } else {
    char *p = ohcount_sourcefile_get_contents(sourcefile);
    if (!p) return NULL;

    const char *magic = magic_buffer(cookie, p, strlen(p));
    if (magic == NULL) {
      fprintf(stderr, "libmagic: %s\n", magic_error(cookie));
      magic_close(cookie);
      exit(1);
    }
    strncpy(line, magic, sizeof(line));
    line[sizeof(line)-1] = '\0';
  }

  magic_close(cookie);

  return magic_parse(line);
}
Пример #29
0
std::string Magic::getType(const Poco::Path& path, int flags) const
{
    Poco::File file(path);

    if(!file.exists())
    {
        throw Poco::FileNotFoundException(file.path());
    }
    
    magic_t magic_cookie_ptr;

    magic_cookie_ptr = magic_open(flags);

    if (!magic_cookie_ptr)
    {
        throw Poco::IOException("Unable to initialize magic magic_cookie_ptr");
    }

    if (magic_load(magic_cookie_ptr, 0) != 0) {
        std::string errorString = magic_error(magic_cookie_ptr);
        magic_close(magic_cookie_ptr);
        throw Poco::IOException("Unable to load magic database: " + errorString);
    }

    const char* result = magic_file(magic_cookie_ptr, path.toString().c_str());

    if(!result)
    {
        std::string errorString = magic_error(magic_cookie_ptr);
        magic_close(magic_cookie_ptr);
        throw Poco::IOException("magic_file returned NULL: " + errorString);
    }

    std::string resultString = result; // copy before close
    
    magic_close(magic_cookie_ptr);
    
    return resultString;
}
Пример #30
0
static void
add_content_type(struct vmod_fsdirector_file_system *fs, const char *path)
{
	const char *mime = magic_file(fs->magic_cookie, path);

	// XXX how to free a string from magic_file or magic_error ?
	if (mime == NULL) {
		perror(magic_error(fs->magic_cookie));
		return;
	}

	dprintf(fs->htc.fd, "Content-Type: %s\r\n", mime);
}