magic.c File Reference

#include <rz_userconf.h>
#include <rz_magic.h>
#include "file.h"

Go to the source code of this file.

Macros
#define	PIPE_BUF   512
#define	SLOP   (1 + sizeof(union VALUETYPE))

Functions
	RZ_LIB_VERSION (rz_magic)
static void	free_mlist (struct mlist *mlist)
static int	info_from_stat (RzMagic *ms, unsigned short md)
static void	close_and_restore (const RzMagic *ms, const char *name, int fd, const struct stat *sb)
static const char *	file_or_fd (RzMagic *ms, const char *inname, int fd)
RZ_API RzMagic *	rz_magic_new (int flags)
RZ_API void	rz_magic_free (RzMagic *ms)
RZ_API bool	rz_magic_load_buffer (RzMagic *ms, const char *magicdata)
RZ_API bool	rz_magic_load (RzMagic *ms, const char *magicfile)
RZ_API bool	rz_magic_compile (RzMagic *ms, const char *magicfile)
RZ_API bool	rz_magic_check (RzMagic *ms, const char *magicfile)
RZ_API const char *	rz_magic_descriptor (RzMagic *ms, int fd)
RZ_API const char *	rz_magic_file (RzMagic *ms, const char *inname)
RZ_API const char *	rz_magic_buffer (RzMagic *ms, const void *buf, size_t nb)
RZ_API const char *	rz_magic_error (RzMagic *ms)
RZ_API int	rz_magic_errno (RzMagic *ms)
RZ_API void	rz_magic_setflags (RzMagic *ms, int flags)

Macro Definition Documentation

PIPE_BUF

#define PIPE_BUF   512

Definition at line 83 of file magic.c.

SLOP

#define SLOP   (1 + sizeof(union VALUETYPE))

Function Documentation

close_and_restore()

static void close_and_restore ( const RzMagic *  ms, const char *  name, int  fd, const struct stat *  sb  )

static

Definition at line 125 of file magic.c.

                                                                                                  {
    if (fd >= 0) {
        close(fd);
    }
}

References close, and fd.

Referenced by file_or_fd().

file_or_fd()

static const char* file_or_fd ( RzMagic *  ms, const char *  inname, int  fd  )

static

Definition at line 131 of file magic.c.

                                                                       {
    bool ispipe = false;
    int rv = -1;
    unsigned char *buf;
    struct stat sb;
    int nbytes = 0; /* number of bytes read from a datafile */
 
    /*
     * one extra for terminating '\0', and
     * some overlapping space for matches near EOF
     */
#define SLOP (1 + sizeof(union VALUETYPE))
    if (!(buf = malloc(HOWMANY + SLOP))) {
        return NULL;
    }
 
    if (file_reset(ms) == -1) {
        goto done;
    }
 
    switch (file_fsmagic(ms, inname, &sb)) {
    case -1: goto done; /* error */
    case 0: break; /* nothing found */
    default: rv = 0; goto done; /* matched it and printed type */
    }
 
    if (!inname) {
        if (fstat(fd, &sb) == 0 && S_ISFIFO(sb.st_mode)) {
            ispipe = true;
        }
    } else {
        int flags = O_RDONLY | O_BINARY;
 
        if (stat(inname, &sb) == 0 && S_ISFIFO(sb.st_mode)) {
#if O_NONBLOCK
            flags |= O_NONBLOCK;
#endif
            ispipe = true;
        }
        errno = 0;
        if ((fd = open(inname, flags)) < 0) {
            eprintf("couldn't open file\n");
            if (info_from_stat(ms, sb.st_mode) == -1) {
                goto done;
            }
            rv = 0;
            goto done;
        }
#ifdef O_NONBLOCK
        if ((flags = fcntl(fd, F_GETFL)) != -1) {
            flags &= ~O_NONBLOCK;
            (void)fcntl(fd, F_SETFL, flags);
        }
#endif
    }
 
    /*
     * try looking at the first HOWMANY bytes
     */
#ifdef O_NONBLOCK
    if (ispipe) {
        ssize_t r = 0;
 
        // while ((r = sread(fd, (void *)&buf[nbytes],
        while ((r = read(fd, (void *)&buf[nbytes],
                (size_t)(HOWMANY - nbytes))) > 0) {
            nbytes += r;
            if (r < PIPE_BUF) {
                break;
            }
        }
 
        if (nbytes == 0) {
            /* We can not read it, but we were able to stat it. */
            if (info_from_stat(ms, sb.st_mode) == -1) {
                goto done;
            }
            rv = 0;
            goto done;
        }
    } else {
#endif
        if ((nbytes = read(fd, (char *)buf, HOWMANY)) == -1) {
            file_error(ms, errno, "cannot read `%s'", inname);
            goto done;
        }
#ifdef O_NONBLOCK
    }
#endif
 
    (void)memset(buf + nbytes, 0, SLOP); /* NUL terminate */
    if (file_buffer(ms, fd, inname, buf, (size_t)nbytes) == -1) {
        goto done;
    }
    rv = 0;
done:
    free(buf);
    close_and_restore(ms, inname, fd, &sb);
    return rv == 0 ? file_getbuffer(ms) : NULL;
}

References close_and_restore(), done, eprintf, F_GETFL, F_SETFL, fcntl, fd, file_buffer(), file_error(), file_fsmagic(), file_getbuffer(), file_reset(), flags, free(), fstat, info_from_stat(), malloc(), memset(), nbytes, NULL, O_BINARY, O_NONBLOCK, O_RDONLY, PIPE_BUF, r, read(), sb, SLOP, and stat.

Referenced by rz_magic_descriptor(), and rz_magic_file().

free_mlist()

static void free_mlist ( struct mlist *  mlist )

static

Definition at line 87 of file magic.c.

                                            {
    struct mlist *ml;
    if (!mlist) {
        return;
    }
    for (ml = mlist->next; ml != mlist;) {
        struct mlist *next = ml->next;
        struct rz_magic *mg = ml->magic;
        file_delmagic(mg, ml->mapped, ml->nmagic);
        free(ml);
        ml = next;
    }
    free(ml);
}

References file_delmagic(), and free().

Referenced by rz_magic_check(), rz_magic_compile(), rz_magic_free(), rz_magic_load(), and rz_magic_load_buffer().

info_from_stat()

static int info_from_stat ( RzMagic *  ms, unsigned short  md  )

static

Definition at line 102 of file magic.c.

                                                          {
    /* We cannot open it, but we were able to stat it. */
    if (md & 0222) {
        if (file_printf(ms, "writable, ") == -1) {
            return -1;
        }
    }
    if (md & 0111) {
        if (file_printf(ms, "executable, ") == -1) {
            return -1;
        }
    }
    if (S_ISREG(md)) {
        if (file_printf(ms, "regular file, ") == -1) {
            return -1;
        }
    }
    if (file_printf(ms, "no read permission") == -1) {
        return -1;
    }
    return 0;
}

References file_printf(), benchmark::md, and S_ISREG.

Referenced by file_or_fd().

RZ_LIB_VERSION()

RZ_LIB_VERSION

(

rz_magic

)

rz_magic_buffer()

RZ_API const char* rz_magic_buffer	(	RzMagic *	ms,
		const void *	buf,
		size_t	nb
	)

Definition at line 308 of file magic.c.

                                                                            {
    if (file_reset(ms) == -1) {
        return NULL;
    }
    if (file_buffer(ms, -1, NULL, buf, nb) == -1) {
        return NULL;
    }
    return file_getbuffer(ms);
}

References file_buffer(), file_getbuffer(), file_reset(), and NULL.

Referenced by get_filetype(), and rz_core_magic_at().

rz_magic_check()

RZ_API bool rz_magic_check	(	RzMagic *	ms,
		const char *	magicfile
	)

Definition at line 294 of file magic.c.

                                                               {
    struct mlist *ml = file_apprentice(ms, magicfile, FILE_CHECK);
    free_mlist(ml);
    return ml != NULL;
}

References file_apprentice(), free_mlist(), and NULL.

rz_magic_compile()

RZ_API bool rz_magic_compile	(	RzMagic *	ms,
		const char *	magicfile
	)

Definition at line 288 of file magic.c.

                                                                 {
    struct mlist *ml = file_apprentice(ms, magicfile, FILE_COMPILE);
    free_mlist(ml);
    return ml != NULL;
}

References file_apprentice(), free_mlist(), and NULL.

rz_magic_descriptor()

RZ_API const char* rz_magic_descriptor	(	RzMagic *	ms,
		int	fd
	)

Definition at line 300 of file magic.c.

                                                            {
    return file_or_fd(ms, NULL, fd);
}

References fd, file_or_fd(), and NULL.

rz_magic_errno()

RZ_API int rz_magic_errno

(

RzMagic *

ms

)

Definition at line 325 of file magic.c.

                                       {
    if (ms && ms->haderr) {
        return ms->error;
    }
    return 0;
}

rz_magic_error()

RZ_API const char* rz_magic_error

(

RzMagic *

ms

)

Definition at line 318 of file magic.c.

                                               {
    if (ms && ms->haderr) {
        return ms->o.buf;
    }
    return NULL;
}

References NULL.

Referenced by rz_core_magic_at().

rz_magic_file()

RZ_API const char* rz_magic_file	(	RzMagic *	ms,
		const char *	inname
	)

Definition at line 304 of file magic.c.

                                                                  {
    return file_or_fd(ms, inname, 0); // 0 = stdin
}

References file_or_fd().

Referenced by file_fsmagic().

rz_magic_free()

RZ_API void rz_magic_free

(

RzMagic *

ms

)

Definition at line 254 of file magic.c.

                                       {
    if (ms) {
        free_mlist(ms->mlist);
        free(ms->o.pbuf);
        free(ms->o.buf);
        free(ms->c.li);
        free(ms);
    }
}

References free(), and free_mlist().

Referenced by get_filetype(), and rz_core_magic_at().

rz_magic_load()

RZ_API bool rz_magic_load	(	RzMagic *	ms,
		const char *	magicfile
	)

Definition at line 278 of file magic.c.

                                                              {
    struct mlist *ml = file_apprentice(ms, magicfile, FILE_LOAD);
    if (ml) {
        free_mlist(ms->mlist);
        ms->mlist = ml;
        return true;
    }
    return false;
}

References file_apprentice(), and free_mlist().

Referenced by get_filetype(), and rz_core_magic_at().

rz_magic_load_buffer()

RZ_API bool rz_magic_load_buffer	(	RzMagic *	ms,
		const char *	magicdata
	)

Definition at line 264 of file magic.c.

                                                                     {
    if (*magicdata == '#') {
        struct mlist *ml = file_apprentice(ms, magicdata, FILE_LOAD);
        if (ml) {
            free_mlist(ms->mlist);
            ms->mlist = ml;
            return true;
        }
    } else {
        eprintf("Magic buffers should start with #\n");
    }
    return false;
}

References eprintf, file_apprentice(), and free_mlist().

rz_magic_new()

RZ_API RzMagic* rz_magic_new

(

int

flags

)

Definition at line 235 of file magic.c.

                                        {
    RzMagic *ms = RZ_NEW0(RzMagic);
    if (!ms) {
        return NULL;
    }
    rz_magic_setflags(ms, flags);
    ms->o.buf = ms->o.pbuf = NULL;
    ms->c.li = malloc((ms->c.len = 10) * sizeof(*ms->c.li));
    if (!ms->c.li) {
        free(ms);
        return NULL;
    }
    file_reset(ms);
    ms->mlist = NULL;
    ms->file = "unknown";
    ms->line = 0;
    return ms;
}

References file_reset(), flags, free(), malloc(), NULL, rz_magic_setflags(), and RZ_NEW0.

Referenced by get_filetype(), and rz_core_magic_at().

rz_magic_setflags()

RZ_API void rz_magic_setflags	(	RzMagic *	ms,
		int	flags
	)

Definition at line 332 of file magic.c.

                                                      {
    if (ms) {
        ms->flags = flags;
    }
}

References flags.

Referenced by rz_magic_new().