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; }
/** * \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); }
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_)); } }
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; }
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; }
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); }
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; }
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; }
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; }
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); }
/* * 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); }
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); }
/** * 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; }
/** 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; }
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; }
/** 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; }
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); }
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; }
/* * 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); }
bool FileDetector::isValid() const { if (magic_error(mCookie)) { return false; } return true; }
/** * \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); }
/** * 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; }
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; } }
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; }
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()); } }
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; }
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; }
/* 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); }
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; }
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); }