* apprentice - make one pass through /etc/magic, learning its secrets.

*/

#include "file.h"

#ifndef lint

#endif /* lint */

#include "magic.h"

#include <stdlib.h>

#include <unistd.h>

#endif

#include <string.h>

#include <assert.h>

#include <ctype.h>

#include <fcntl.h>

#define EATAB {while (isascii((unsigned char) *l) && \

isspace((unsigned char) *l)) ++l;}

private int parse_strength(struct magic_set *, struct magic_entry *, const char *);

private int parse_apple(struct magic_set *, struct magic_entry *, const char *);

private size_t maxmagic = 0;

private size_t magicsize = sizeof(struct magic);

private const char usg_hdr[] = "cont\toffset\ttype\topcode\tmask\tvalue\tdesc";

private struct {

const char *name;

size_t len;

{ NULL, 0, NULL }

};

static const struct type_tbl_s {

const char name[16];

# undef XX_NULL

};

private int

get_type(const char *l, const char **t)

{

if (rv != 0)

return -1;

rv = apprentice_compile(ms, &magic, &nmagic, fn);

return rv;

}

if ((rv = apprentice_map(ms, &magic, &nmagic, fn)) == -1) {

if (rv != 0)

return -1;

}

return -1;

}

ml->magic = magic;

ml->nmagic = nmagic;

}

return 0;

}

protected void

if (p == NULL)

return;

switch (type) {

break;

case 1:

p--;

/*FALLTHROUGH*/

case 0:

break;

default:

abort();

}

char *p, *mfn;

int file_err, errs = -1;

struct mlist *mlist;

if ((fn = magic_getpath(fn, action)) == NULL)

return NULL;

init_file_tables();

}

fn = mfn;

mlist->next = mlist->prev = mlist;

while (fn) {

fn = p;

}

if (errs == -1) {

mlist = NULL;

file_error(ms, 0, "could not find any magic files!");

return NULL;

}

return mlist;

}

abort();

}

/*

* Magic entries with no description get a bonus because they depend

* on subsequent magic entries to print something.

private int

apprentice_sort(const void *a, const void *b)

{

size_t sa = apprentice_magic_strength(ma->mp);

size_t sb = apprentice_magic_strength(mb->mp);

if (sa == sb)

load_1(struct magic_set *ms, int action, const char *fn, int *errs,

struct magic_entry **marray, uint32_t *marraycount)

{

char *line = NULL;

if (errno != ENOENT)

file_error(ms, errno, "cannot read magic file `%s'",

fn);

return;

}

if (len == 0) /* null line, garbage, etc */

continue;

if (line[len - 1] == '\n') {

break;

}

}

}

/*

apprentice_load(struct magic_set *ms, struct magic **magicp, uint32_t *nmagicp,

const char *fn, int action)

{

struct magic_entry *marray;

uint32_t marraycount, i, mentrycount = 0, starttest;

struct stat st;

ms->flags |= MAGIC_CHECK; /* Enable checks for parsed files */

marraycount = 0;

/* print silly verbose header for USG compat. */

(void)fprintf(stderr, "%s\n", usg_hdr);

/* load directory or file */

if (!dir) {

errs++;

goto out;

}

file_oomem(ms,

errs++;

goto out;

}

if (stat(mfn, &st) == -1 || !S_ISREG(st.st_mode)) {

continue;

}

if (files >= maxfiles) {

if ((filearr = CAST(char **,

realloc(filearr, mlen))) == NULL) {

file_oomem(ms, mlen);

errs++;

goto out;

}

}

}

qsort(filearr, files, sizeof(*filearr), cmpstrp);

for (i = 0; i < files; i++) {

load_1(ms, action, filearr[i], &errs, &marray,

&marraycount);

}

free(filearr);

} else

for (i = 0; i < marraycount; i++)

mentrycount += marray[i].cont_count;

mentrycount = 0;

for (i = 0; i < marraycount; i++) {

mentrycount += marray[i].cont_count;

}

out:

if (errs) {

*magicp = NULL;

*nmagicp = 0;

return -1;

}

me = &(*mentryp)[*nmentryp - 1];

if (me->cont_count == me->max_count) {

struct magic *nm;

size_t cnt = me->max_count + ALLOC_CHUNK;

me->mp = m = nm;

me->max_count = CAST(uint32_t, cnt);

}

struct magic_entry *mp;

maxmagic += ALLOC_INCR;

*mentryp = mp;

}

me = &(*mentryp)[*nmentryp];

if (me->mp == NULL) {

me->mp = m;

me->max_count = ALLOC_CHUNK;

} else

if (m->type == FILE_INVALID) {

if (ms->flags & MAGIC_CHECK)

file_magwarn(ms, "type `%s' invalid", l);

return -1;

}

m->mask_op = 0;

if (*l == '~') {

m->mask_op |= FILE_OPINVERSE;

else if (ms->flags & MAGIC_CHECK)

file_magwarn(ms, "'~' invalid for string types");

m->str_range = 0;

m->str_flags = m->type == FILE_PSTRING ? PSTRING_1_LE : 0;

if ((op = get_op(*l)) != -1) {

uint64_t val;

++l;

m->mask_op |= op;

if (check_format(ms, m) == -1)

return -1;

}

m->mimetype[0] = '\0'; /* initialise MIME type to none */

if (m->cont_level == 0)

++(*nmentryp); /* make room for next */

/*

* handle a compiled file.

*/

private int

apprentice_map(struct magic_set *ms, struct magic **magicp, uint32_t *nmagicp,

const char *fn)

{

uint32_t *ptr;

uint32_t version;

int needsbyteswap;

char *dbname = NULL;

void *mm = NULL;

dbname = mkdbname(ms, fn, 0);

if (dbname == NULL)

goto error2;

goto error2;

file_error(ms, errno, "cannot stat `%s'", dbname);

goto error1;

}

file_error(ms, 0, "file `%s' is too small", dbname);

goto error1;

}

file_badread(ms);

goto error1;

}

ptr = (uint32_t *)(void *)*magicp;

if (*ptr != MAGICNO) {

if (swap4(*ptr) != MAGICNO) {

else

version = ptr[1];

if (version != VERSIONNO) {

VERSIONNO, dbname, version);

goto error1;

}

(*nmagicp)--;

(*magicp)++;

byteswap(*magicp, *nmagicp);

error1:

} else {

*magicp = NULL;

*nmagicp = 0;

}

error2:

return -1;

}

apprentice_compile(struct magic_set *ms, struct magic **magicp,

uint32_t *nmagicp, const char *fn)

{

char *dbname;

int rv = -1;

if (dbname == NULL)

goto out;

file_error(ms, errno, "cannot open `%s'", dbname);

goto out;

}

file_error(ms, errno, "error writing `%s'", dbname);

goto out;

}

file_error(ms, errno, "error seeking `%s'", dbname);

goto out;

}

file_error(ms, errno, "error writing `%s'", dbname);

goto out;

}

rv = 0;

out:

return rv;

}

{

const char *p, *q;

char *buf;

if (strip) {

if ((p = strrchr(fn, '/')) != NULL)

q++;

/* Compatibility with old code that looked in .mime */

if (ms->flags & MAGIC_MIME) {

ms->flags &= MAGIC_MIME_TYPE;

return buf;

}

}

/* Compatibility with old code that looked in .mime */

if (strstr(p, ".mime") != NULL)

m->offset = swap4((uint32_t)m->offset);

m->in_offset = swap4((uint32_t)m->in_offset);

m->lineno = swap4((uint32_t)m->lineno);

m->str_range = swap4(m->str_range);

m->str_flags = swap4(m->str_flags);

}

/* malloc size is a conservative overestimate; could be

improved, or at least realloced after conversion. */

mlen = ulen * 6;

if ((utf8_end = encode_utf8(utf8_buf, mlen, ubuf, ulen))

== NULL)

goto done;

}

rv = 1;

done:

return rv;

}

#include <err.h>

#endif

#include <stdlib.h>

#include <unistd.h>

#include <string.h>

#include <time.h>

#include <ctype.h>

if (info->i_fd == -1)

return -1;

return -1;

return -1;

return (ssize_t)len;

cdf_directory_t *d;

char name[__arraycount(d->d_name)];

cdf_stream_t scn;

static const char *types[] = { "empty", "user storage",

"user stream", "lockbytes", "property", "root storage" };

cdf_dump_property_info(const cdf_property_info_t *info, size_t count)

{

cdf_timestamp_t tp;

char buf[64];

size_t i, j;

break;

case CDF_FILETIME:

tp = info[i].pi_tp;

if (tp < 1000000000000000LL) {

cdf_print_elapsed_time(buf, sizeof(buf), tp);

(void)fprintf(stderr, "timestamp %s\n", buf);

} else {

#ifndef _H_CDF_

#define _H_CDF_

#include <winsock2.h>

#define timespec timeval

#define tv_nsec tv_usec

typedef struct {

uint64_t h_magic;

uint64_t h_uuid[2];

uint16_t h_revision;

uint16_t h_version;

size_t i_len;

} cdf_info_t;

int cdf_read_header(const cdf_info_t *, cdf_header_t *);

void cdf_swap_header(cdf_header_t *);

void cdf_unpack_header(cdf_header_t *, char *);

}

int

{

struct tm tm;

#ifdef HAVE_STRUCT_TM_TM_ZONE

#endif

int rdays;

t /= CDF_TIME_PREC;

tm.tm_sec = (int)(t % 60);

tm.tm_hour = (int)(t % 24);

t /= 24;

tm.tm_year = (int)(CDF_BASE_YEAR + (t / 365));

rdays = cdf_getdays(tm.tm_year);

int

/*ARGSUSED*/

{

#ifndef __lint__

(void)&t;

errno = EINVAL;

return -1;

}

*t = tm.tm_sec;

*t += tm.tm_min * 60;

*t += tm.tm_hour * 60 * 60;

int

main(int argc, char *argv[])

{

static const cdf_timestamp_t tst = 0x01A5E403C2D59C00ULL;

static const char *ref = "Sat Apr 23 01:30:00 1977";

char *p, *q;

* uncompress(method, old, n, newch) - uncompress old into new,

* using method, return sizeof new

*/

#include "file.h"

#ifndef lint

#endif

#include <string.h>