file.h File Reference

#include "mconfig.h"
#include <rz_magic.h>
#include <stdio.h>
#include <errno.h>
#include <fcntl.h>
#include <inttypes.h>
#include <rz_regex.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdarg.h>

Go to the source code of this file.

Macros
#define	O_BINARY   0

Typedefs
typedef unsigned long	unichar

Functions
const char *	file_fmttime (unsigned int, int, char *)
int	file_buffer (struct rz_magic_set *, int, const char *, const void *, size_t)
int	file_fsmagic (struct rz_magic_set *, const char *, struct stat *)
int	file_pipe2file (struct rz_magic_set *, int, const void *, size_t)
int	file_printf (struct rz_magic_set *, const char *,...)
int	file_reset (struct rz_magic_set *)
int	file_tryelf (struct rz_magic_set *, int, const unsigned char *, size_t)
int	file_zmagic (struct rz_magic_set *, int, const char *, const ut8 *, size_t)
int	file_ascmagic (struct rz_magic_set *, const unsigned char *, size_t)
int	file_is_tar (struct rz_magic_set *, const unsigned char *, size_t)
int	file_softmagic (struct rz_magic_set *, const unsigned char *, size_t, int)
struct mlist *	file_apprentice (struct rz_magic_set *, const char *, int)
ut64	file_signextend (RzMagic *, struct rz_magic *, ut64)
void	file_delmagic (struct rz_magic *, int type, size_t entries)
void	file_badread (struct rz_magic_set *)
void	file_badseek (struct rz_magic_set *)
void	file_oomem (struct rz_magic_set *, size_t)
void	file_error (struct rz_magic_set *, int, const char *,...)
void	file_magerror (struct rz_magic_set *, const char *,...)
void	file_magwarn (struct rz_magic_set *, const char *,...)
void	file_mdump (struct rz_magic *)
void	file_showstr (FILE *, const char *, size_t)
size_t	file_mbswidth (const char *)
const char *	file_getbuffer (struct rz_magic_set *)
ssize_t	sread (int, void *, size_t, int)
int	file_check_mem (struct rz_magic_set *, unsigned int)
int	file_looks_utf8 (const unsigned char *, size_t, unichar *, size_t *)
int	vasprintf (char **ptr, const char *format_string, va_list vargs)
int	asprintf (char **ptr, const char *format_string,...)

Macro Definition Documentation

O_BINARY

#define O_BINARY   0

Definition at line 90 of file file.h.

Typedef Documentation

unichar

typedef unsigned long unichar

Definition at line 51 of file file.h.

Function Documentation

asprintf()

int asprintf	(	char **	ptr,
		const char *	format_string,
			...
	)

file_apprentice()

struct mlist* file_apprentice	(	struct rz_magic_set *	,
		const char *	,
		int
	)

file_ascmagic()

int file_ascmagic	(	struct rz_magic_set *	,
		const unsigned char *	,
		size_t
	)

file_badread()

void file_badread

(

struct rz_magic_set *

)

Referenced by apprentice_map().

file_badseek()

void file_badseek

(

struct rz_magic_set *

)

file_buffer()

int file_buffer	(	struct rz_magic_set *	,
		int	,
		const char *	,
		const void *	,
		size_t
	)

Referenced by file_or_fd(), and rz_magic_buffer().

file_check_mem()

int file_check_mem	(	struct rz_magic_set *	,
		unsigned int
	)

Referenced by match(), and parse().

file_delmagic()

void file_delmagic	(	struct rz_magic *	p,
		int	type,
		size_t	entries
	)

Definition at line 255 of file apprentice.c.

                                                                 {
    if (p) {
        switch (type) {
#if QUICK
        case 2:
            p--;
            (void)munmap((void *)p, sizeof(*p) * (entries + 1));
            break;
#endif
        case 1:
            p--;
            /*FALLTHROUGH*/
        case 0:
            RZ_FREE(p);
            break;
        default:
            abort(); // do not abort, ever XXX this is a lib, so it shouldn just report an error
        }
    }
}

References entries(), munmap, p, RZ_FREE, and type.

Referenced by apprentice_1(), and free_mlist().

file_error()

void file_error	(	struct rz_magic_set *	,
		int	,
		const char *	,
			...
	)

Referenced by apprentice_1(), apprentice_compile(), apprentice_map(), bad_link(), file_apprentice(), file_fsmagic(), file_or_fd(), getstr(), load_1(), parse(), and parse_mime().

file_fmttime()

const char* file_fmttime	(	unsigned int	v,
		int	local,
		char *	pp
	)

Definition at line 188 of file mdump.c.

                                                      {
    time_t t = (time_t)v;
    struct tm *tm;
    struct tm timestruct;
 
    if (local) {
        rz_ctime_r(&t, pp);
    } else {
#ifndef HAVE_DAYLIGHT
        static int daylight = 0;
#ifdef HAVE_TM_ISDST
        static time_t now = (time_t)0;
 
        if (now == (time_t)0) {
            struct tm *tm1;
            (void)time(&now);
            tm1 = rz_localtime_r(&now, &timestruct);
            if (!tm1)
                return "*Invalid time*";
            daylight = tm1->tm_isdst;
        }
#endif /* HAVE_TM_ISDST */
#endif /* HAVE_DAYLIGHT */
        if (daylight)
            t += 3600;
        tm = rz_gmtime_r(&t, &timestruct);
        if (!tm)
            return "*Invalid time*";
        rz_asctime_r(tm, pp);
    }
 
    pp[strcspn(pp, "\n")] = '\0';
    return pp;
}

References local, rz_asctime_r(), rz_ctime_r(), rz_gmtime_r(), rz_localtime_r(), time, and v.

Referenced by file_mdump(), and mprint().

file_fsmagic()

int file_fsmagic	(	struct rz_magic_set *	ms,
		const char *	fn,
		struct stat *	sb
	)

Definition at line 76 of file fsmagic.c.

                                                                           {
    int ret = 0;
    int mime = ms->flags & RZ_MAGIC_MIME;
#ifdef S_IFLNK
    char buf[BUFSIZ + 4];
    int nch;
    struct stat tstatbuf;
#endif
    if (!fn)
        return 0;
        /*
         * Fstat is cheaper but fails for files you don't have read perms on.
         * On 4.2BSD and similar systems, use lstat() to identify symlinks.
         */
#ifdef S_IFLNK
    if ((ms->flags & RZ_MAGIC_SYMLINK) == 0)
        ret = lstat(fn, sb);
    else
#endif
        ret = stat(fn, sb); /* don't merge into if; see "ret =" above */
 
    if (ret) {
        if (ms->flags & RZ_MAGIC_ERROR) {
            file_error(ms, errno, "cannot stat `%s'", fn);
            return -1;
        }
        if (file_printf(ms, "cannot open `%s' (%s)",
                fn, strerror(errno)) == -1)
            return -1;
        return 1;
    }
 
    if (mime) {
        if ((sb->st_mode & S_IFMT) != S_IFREG) {
            if ((mime & RZ_MAGIC_MIME_TYPE) &&
                file_printf(ms, "application/x-not-regular-file") == -1)
                return -1;
            return 1;
        }
    } else {
#ifdef S_ISUID
        if (sb->st_mode & S_ISUID)
            if (file_printf(ms, "setuid ") == -1)
                return -1;
#endif
#ifdef S_ISGID
        if (sb->st_mode & S_ISGID)
            if (file_printf(ms, "setgid ") == -1)
                return -1;
#endif
#ifdef S_ISVTX
        if (sb->st_mode & S_ISVTX)
            if (file_printf(ms, "sticky ") == -1)
                return -1;
#endif
    }
 
    switch (sb->st_mode & S_IFMT) {
    case S_IFDIR:
        if (file_printf(ms, "directory") == -1)
            return -1;
        return 1;
#ifdef S_IFCHR
    case S_IFCHR:
        /*
         * If -s has been specified, treat character special files
         * like ordinary files.  Otherwise, just report that they
         * are block special files and go on to the next file.
         */
        if ((ms->flags & RZ_MAGIC_DEVICES) != 0)
            break;
#ifdef HAVE_STAT_ST_RDEV
#ifdef dv_unit
        if (file_printf(ms, "character special (%d/%d/%d)",
                major(sb->st_rdev), dv_unit(sb->st_rdev),
                dv_subunit(sb->st_rdev)) == -1)
            return -1;
#else
        if (file_printf(ms, "character special (%ld/%ld)",
                (long)major(sb->st_rdev), (long)minor(sb->st_rdev)) == -1)
            return -1;
#endif
#else
        if (file_printf(ms, "character special") == -1)
            return -1;
#endif
        return 1;
#endif
#ifdef S_IFBLK
    case S_IFBLK:
        /*
         * If -s has been specified, treat block special files
         * like ordinary files.  Otherwise, just report that they
         * are block special files and go on to the next file.
         */
        if ((ms->flags & RZ_MAGIC_DEVICES) != 0)
            break;
#ifdef HAVE_STAT_ST_RDEV
#ifdef dv_unit
        if (file_printf(ms, "block special (%d/%d/%d)",
                major(sb->st_rdev), dv_unit(sb->st_rdev),
                dv_subunit(sb->st_rdev)) == -1)
            return -1;
#else
        if (file_printf(ms, "block special (%ld/%ld)",
                (long)major(sb->st_rdev), (long)minor(sb->st_rdev)) == -1)
            return -1;
#endif
#else
        if (file_printf(ms, "block special") == -1)
            return -1;
#endif
        return 1;
#endif
        /* TODO add code to handle V7 MUX and Blit MUX files */
#ifdef S_IFIFO
    case S_IFIFO:
        if ((ms->flags & RZ_MAGIC_DEVICES) != 0)
            break;
        if (file_printf(ms, "fifo (named pipe)") == -1)
            return -1;
        return 1;
#endif
#ifdef S_IFDOOR
    case S_IFDOOR:
        return (file_printf(ms, "door") == -1) ? -1 : 1;
#endif
#ifdef S_IFLNK
    case S_IFLNK:
        if ((nch = readlink(fn, buf, BUFSIZ - 1)) <= 0) {
            if (ms->flags & RZ_MAGIC_ERROR) {
                file_error(ms, errno, "unreadable symlink `%s'", fn);
                return -1;
            }
            if (file_printf(ms,
                    "unreadable symlink `%s' (%s)", fn,
                    strerror(errno)) == -1)
                return -1;
            return 1;
        }
        buf[nch] = '\0'; /* readlink(2) does not do this */
 
        /* If broken symlink, say so and quit early. */
        if (*buf == '/') {
            if (stat(buf, &tstatbuf) < 0)
                return bad_link(ms, errno, buf);
        } else {
            char *tmp;
            char buf2[BUFSIZ + BUFSIZ + 4];
 
            if (!(tmp = strrchr(fn, '/'))) {
                tmp = buf; /* in current directory anyway */
            } else {
                if (tmp - fn + 1 > BUFSIZ) {
                    if (ms->flags & RZ_MAGIC_ERROR) {
                        file_error(ms, 0, "path too long: `%s'", buf);
                        return -1;
                    }
                    if (file_printf(ms, "path too long: `%s'", fn) == -1)
                        return -1;
                    return 1;
                }
                snprintf(buf2, sizeof(buf2), "%s%s", fn, buf);
                tmp = buf2;
            }
            if (stat(tmp, &tstatbuf) < 0)
                return bad_link(ms, errno, buf);
        }
 
        /* Otherwise, handle it. */
        if ((ms->flags & RZ_MAGIC_SYMLINK) != 0) {
            const char *p;
            ms->flags &= RZ_MAGIC_SYMLINK;
            p = rz_magic_file(ms, buf);
            ms->flags |= RZ_MAGIC_SYMLINK;
            return p != NULL ? 1 : -1;
        } else { /* just print what it points to */
            if (file_printf(ms, "symbolic link to `%s'", buf) == -1)
                return -1;
        }
        return 1;
#endif
#ifdef S_IFSOCK
    case S_IFSOCK:
        if (file_printf(ms, "socket") == -1)
            return -1;
        return 1;
#endif
    case S_IFREG:
        break;
    default:
        file_error(ms, 0, "invalid mode 0%o", sb->st_mode);
        return -1;
        /*NOTREACHED*/
    }
    /*
     * regular file, check next possibility
     *
     * If stat() tells us the file has zero length, report here that
     * the file is empty, so we can skip all the work of opening and
     * reading the file.
     * But if the -s option has been given, we skip this optimization,
     * since on some systems, stat() reports zero size for raw disk
     * partitions.  (If the block special device really has zero length,
     * the fact that it is empty will be detected and reported correctly
     * when we read the file.)
     */
    if ((ms->flags & RZ_MAGIC_DEVICES) == 0 && sb->st_size == 0) {
        if ((!mime || (mime & RZ_MAGIC_MIME_TYPE)) &&
            file_printf(ms, mime ? "application/x-empty" : "empty") == -1)
            return -1;
        return 1;
    }
    return 0;
}

References bad_link(), buf2, file_error(), file_printf(), fn, major, mime, minor, nch(), NULL, p, readlink, rz_magic_file(), S_IFLNK, sb, snprintf, stat, and autogen_x86imm::tmp.

Referenced by file_or_fd().

file_getbuffer()

const char* file_getbuffer

(

struct rz_magic_set *

)

Referenced by file_or_fd(), and rz_magic_buffer().

file_is_tar()

int file_is_tar	(	struct rz_magic_set *	,
		const unsigned char *	,
		size_t
	)

Referenced by file_buffer().

file_looks_utf8()

int file_looks_utf8	(	const unsigned char *	buf,
		size_t	nbytes,
		unichar *	ubuf,
		size_t *	ulen
	)

Definition at line 605 of file ascmagic.c.

                                                                                {
    size_t i;
    int n;
    unichar c;
    int gotone = 0, ctrl = 0;
 
    if (ubuf) {
        *ulen = 0;
    }
 
    for (i = 0; i < nbytes; i++) {
        if ((buf[i] & 0x80) == 0) { /* 0xxxxxxx is plain ASCII */
            /*
             * Even if the whole file is valid UTF-8 sequences,
             * still reject it if it uses weird control characters.
             */
 
            if (text_chars[buf[i]] != T) {
                ctrl = 1;
            }
 
            if (ubuf) {
                ubuf[(*ulen)++] = buf[i];
            }
        } else if ((buf[i] & 0x40) == 0) { /* 10xxxxxx never 1st byte */
            return -1;
        } else { /* 11xxxxxx begins UTF-8 */
            int following;
 
            if ((buf[i] & 0x20) == 0) { /* 110xxxxx */
                c = buf[i] & 0x1f;
                following = 1;
            } else if ((buf[i] & 0x10) == 0) { /* 1110xxxx */
                c = buf[i] & 0x0f;
                following = 2;
            } else if ((buf[i] & 0x08) == 0) { /* 11110xxx */
                c = buf[i] & 0x07;
                following = 3;
            } else if ((buf[i] & 0x04) == 0) { /* 111110xx */
                c = buf[i] & 0x03;
                following = 4;
            } else if ((buf[i] & 0x02) == 0) { /* 1111110x */
                c = buf[i] & 0x01;
                following = 5;
            } else {
                return -1;
            }
 
            for (n = 0; n < following; n++) {
                i++;
                if (i >= nbytes) {
                    goto done;
                }
 
                if ((buf[i] & 0x80) == 0 || (buf[i] & 0x40)) {
                    return -1;
                }
 
                c = (c << 6) + (buf[i] & 0x3f);
            }
 
            if (ubuf) {
                ubuf[(*ulen)++] = c;
            }
            gotone = 1;
        }
    }
done:
    return ctrl ? 0 : (gotone ? 2 : 1);
}

References c, done, i, n, nbytes, T, and text_chars.

Referenced by file_ascmagic(), looks_utf8_with_BOM(), and set_test_type().

file_magerror()

void file_magerror	(	struct rz_magic_set *	,
		const char *	,
			...
	)

Referenced by check_fmt(), magiccheck(), mconvert(), mcopy(), and mprint().

file_magwarn()

void file_magwarn	(	struct rz_magic_set *	ms,
		const char *	f,
			...
	)

Definition at line 172 of file mdump.c.

                                                               {
    va_list va;
 
    /* cuz we use stdout for most, stderr here */
    (void)fflush(stdout);
 
    if (ms->file)
        (void)eprintf("%s, %lu: ", ms->file,
            (unsigned long)ms->line);
    (void)eprintf("Warning: ");
    va_start(va, f);
    (void)vfprintf(stderr, f, va);
    va_end(va);
    (void)fputc('\n', stderr);
}

References eprintf, and f.

Referenced by apprentice_load(), check_cond(), check_format(), file_signextend(), getstr(), getvalue(), parse(), parse_mime(), and string_modifier_check().

file_mbswidth()

size_t file_mbswidth

(

const char *

)

file_mdump()

void file_mdump

(

struct rz_magic *

m

)

Definition at line 47 of file mdump.c.

                                    {
    static const char optyp[] = { FILE_OPS };
    char pp[ASCTIME_BUF_MINLEN];
 
    (void)eprintf("[%u", m->lineno);
    (void)eprintf("%.*s %u", m->cont_level & 7, ">>>>>>>>", m->offset);
 
    if (m->flag & INDIR) {
        (void)eprintf("(%s,",
            /* Note: type is unsigned */
            (m->in_type < file_nnames) ? magic_file_names[m->in_type] : "*bad*");
        if (m->in_op & FILE_OPINVERSE)
            (void)fputc('~', stderr);
        (void)eprintf("%c%u),",
            ((m->in_op & FILE_OPS_MASK) < SZOF(optyp)) ? optyp[m->in_op & FILE_OPS_MASK] : '?',
            m->in_offset);
    }
    (void)eprintf(" %s%s", (m->flag & UNSIGNED) ? "u" : "",
        /* Note: type is unsigned */
        (m->type < file_nnames) ? magic_file_names[m->type] : "*bad*");
    if (m->mask_op & FILE_OPINVERSE)
        (void)fputc('~', stderr);
 
    if (MAGIC_IS_STRING(m->type)) {
        if (m->str_flags) {
            (void)fputc('/', stderr);
            if (m->str_flags & STRING_COMPACT_BLANK)
                (void)fputc(CHAR_COMPACT_BLANK, stderr);
            if (m->str_flags & STRING_COMPACT_OPTIONAL_BLANK)
                (void)fputc(CHAR_COMPACT_OPTIONAL_BLANK,
                    stderr);
            if (m->str_flags & STRING_IGNORE_LOWERCASE)
                (void)fputc(CHAR_IGNORE_LOWERCASE, stderr);
            if (m->str_flags & STRING_IGNORE_UPPERCASE)
                (void)fputc(CHAR_IGNORE_UPPERCASE, stderr);
            if (m->str_flags & REGEX_OFFSET_START)
                (void)fputc(CHAR_REGEX_OFFSET_START, stderr);
        }
        if (m->str_range)
            (void)eprintf("/%u", m->str_range);
    } else {
        if ((m->mask_op & FILE_OPS_MASK) < SZOF(optyp))
            (void)fputc(optyp[m->mask_op & FILE_OPS_MASK], stderr);
        else
            (void)fputc('?', stderr);
 
        if (m->num_mask)
            (void)eprintf("%08" PFMT64x, (ut64)m->num_mask);
    }
    (void)eprintf(",%c", m->reln);
 
    if (m->reln != 'x') {
        switch (m->type) {
        case FILE_BYTE:
        case FILE_SHORT:
        case FILE_LONG:
        case FILE_LESHORT:
        case FILE_LELONG:
        case FILE_MELONG:
        case FILE_BESHORT:
        case FILE_BELONG:
            (void)eprintf("%d", m->value.l);
            break;
        case FILE_BEQUAD:
        case FILE_LEQUAD:
        case FILE_QUAD:
            (void)eprintf("%" PFMT64d, (ut64)m->value.q);
            break;
        case FILE_PSTRING:
        case FILE_STRING:
        case FILE_REGEX:
        case FILE_BESTRING16:
        case FILE_LESTRING16:
        case FILE_SEARCH:
            file_showstr(stderr, m->value.s, (size_t)m->vallen);
            break;
        case FILE_DATE:
        case FILE_LEDATE:
        case FILE_BEDATE:
        case FILE_MEDATE:
            (void)eprintf("%s,",
                file_fmttime(m->value.l, 1, pp));
            break;
        case FILE_LDATE:
        case FILE_LELDATE:
        case FILE_BELDATE:
        case FILE_MELDATE:
            (void)eprintf("%s,",
                file_fmttime(m->value.l, 0, pp));
            break;
        case FILE_QDATE:
        case FILE_LEQDATE:
        case FILE_BEQDATE:
            (void)eprintf("%s,",
                file_fmttime((ut32)m->value.q, 1, pp));
            break;
        case FILE_QLDATE:
        case FILE_LEQLDATE:
        case FILE_BEQLDATE:
            (void)eprintf("%s,",
                file_fmttime((ut32)m->value.q, 0, pp));
            break;
        case FILE_FLOAT:
        case FILE_BEFLOAT:
        case FILE_LEFLOAT:
            (void)eprintf("%G", m->value.f);
            break;
        case FILE_DOUBLE:
        case FILE_BEDOUBLE:
        case FILE_LEDOUBLE:
            (void)eprintf("%G", m->value.d);
            break;
        case FILE_DEFAULT:
            /* XXX - do anything here? */
            break;
        default:
            (void)fputs("*bad*", stderr);
            break;
        }
    }
    (void)eprintf(",\"%s\"]\n", m->desc);
}

References ASCTIME_BUF_MINLEN, eprintf, file_fmttime(), file_nnames, file_showstr(), regress::m, magic_file_names, PFMT64d, PFMT64x, SZOF, UNSIGNED, and ut64().

Referenced by mget(), and parse().

file_oomem()

void file_oomem	(	struct rz_magic_set *	,
		size_t
	)

Referenced by apprentice_1(), apprentice_load(), apprentice_map(), file_apprentice(), file_ascmagic(), mprint(), and parse().

file_pipe2file()

int file_pipe2file	(	struct rz_magic_set *	,
		int	,
		const void *	,
		size_t
	)

file_printf()

int file_printf	(	struct rz_magic_set *	,
		const char *	,
			...
	)

Referenced by bad_link(), file_ascmagic(), file_fsmagic(), file_is_tar(), info_from_stat(), match(), mprint(), and print_sep().

file_reset()

int file_reset

(

struct rz_magic_set *

)

Referenced by file_or_fd(), rz_magic_buffer(), and rz_magic_new().

file_showstr()

void file_showstr	(	FILE *	fp,
		const char *	s,
		size_t	len
	)

Definition at line 1778 of file apprentice.c.

                                                       {
    for (;;) {
        char c = *s++;
        if (len == ~0U) {
            if (c == '\0') {
                break;
            }
        } else {
            if (len-- == 0) {
                break;
            }
        }
        if (c >= 040 && c <= 0176) { /* TODO isprint && !iscntrl */
            fputc(c, fp);
        } else {
            fputc('\\', fp);
            switch (c) {
            case '\a': fputc('a', fp); break;
            case '\b': fputc('b', fp); break;
            case '\f': fputc('f', fp); break;
            case '\n': fputc('n', fp); break;
            case '\r': fputc('r', fp); break;
            case '\t': fputc('t', fp); break;
            case '\v': fputc('v', fp); break;
            default: fprintf(fp, "%.3o", c & 0377); break;
            }
        }
    }
}

References c, len, and s.

Referenced by file_mdump(), and mdebug().

file_signextend()

ut64 file_signextend	(	RzMagic *	ms,
		struct rz_magic *	m,
		ut64	v
	)

Definition at line 757 of file apprentice.c.

                                                              {
    if (!(m->flag & UNSIGNED)) {
        switch (m->type) {
        /*
         * Do not remove the casts below.  They are
         * vital.  When later compared with the data,
         * the sign extension must have happened.
         */
        case FILE_BYTE:
            v = (char)v;
            break;
        case FILE_SHORT:
        case FILE_BESHORT:
        case FILE_LESHORT:
            v = (short)v;
            break;
        case FILE_DATE:
        case FILE_BEDATE:
        case FILE_LEDATE:
        case FILE_MEDATE:
        case FILE_LDATE:
        case FILE_BELDATE:
        case FILE_LELDATE:
        case FILE_MELDATE:
        case FILE_LONG:
        case FILE_BELONG:
        case FILE_LELONG:
        case FILE_MELONG:
        case FILE_FLOAT:
        case FILE_BEFLOAT:
        case FILE_LEFLOAT:
            v = (int32_t)v;
            break;
        case FILE_QUAD:
        case FILE_BEQUAD:
        case FILE_LEQUAD:
        case FILE_QDATE:
        case FILE_QLDATE:
        case FILE_BEQDATE:
        case FILE_BEQLDATE:
        case FILE_LEQDATE:
        case FILE_LEQLDATE:
        case FILE_DOUBLE:
        case FILE_BEDOUBLE:
        case FILE_LEDOUBLE:
            v = (int64_t)v;
            break;
        case FILE_STRING:
        case FILE_PSTRING:
        case FILE_BESTRING16:
        case FILE_LESTRING16:
        case FILE_REGEX:
        case FILE_SEARCH:
        case FILE_DEFAULT:
            break;
        default:
            if (ms->flags & RZ_MAGIC_CHECK) {
                file_magwarn(ms, "cannot happen: m->type=%d\n",
                    m->type);
            }
            return ~0U;
        }
    }
    return v;
}

References file_magwarn(), regress::m, UNSIGNED, and v.

Referenced by getvalue(), magiccheck(), mprint(), and parse().

file_softmagic()

int file_softmagic	(	struct rz_magic_set *	,
		const unsigned char *	,
		size_t	,
		int
	)

Referenced by file_ascmagic(), and file_buffer().

file_tryelf()

int file_tryelf	(	struct rz_magic_set *	,
		int	,
		const unsigned char *	,
		size_t
	)

file_zmagic()

int file_zmagic	(	struct rz_magic_set *	,
		int	,
		const char *	,
		const ut8 *	,
		size_t
	)

Referenced by file_buffer().

sread()

ssize_t sread	(	int	,
		void *	,
		size_t	,
		int
	)

vasprintf()

int vasprintf	(	char **	ptr,
		const char *	format_string,
		va_list	vargs
	)