/* * Like printf, only we print to a buffer and advance it. */ protected int file_printf(struct magic_set *ms, const char *fmt, ...) { va_list ap; size_t len; char *buf; va_start(ap, fmt); if ((len = _vsnprintf(ms->o.ptr, ms->o.len, fmt, ap)) >= ms->o.len) { va_end(ap); if ((buf = realloc(ms->o.buf, len + 1024)) == NULL) { file_oomem(ms); return -1; } ms->o.ptr = buf + (ms->o.ptr - ms->o.buf); ms->o.buf = buf; ms->o.len = ms->o.size - (ms->o.ptr - ms->o.buf); ms->o.size = len + 1024; va_start(ap, fmt); len = _vsnprintf(ms->o.ptr, ms->o.len, fmt, ap); } ms->o.ptr += len; ms->o.len -= len; va_end(ap); return 0; }
/* * Handle one file or directory. */ static int apprentice_1(RMagic *ms, const char *fn, int action, struct mlist *mlist) { struct r_magic *magic = NULL; ut32 nmagic = 0; struct mlist *ml; int rv = -1; int mapped; if (!ms) return -1; ms->haderr = 0; if (magicsize != FILE_MAGICSIZE) { file_error(ms, 0, "magic element size %lu != %lu", (unsigned long)(size_t)sizeof (*magic), (unsigned long)FILE_MAGICSIZE); return -1; } ms->file = fn; // fix use of ms->file before being initialized if (action == FILE_COMPILE) { rv = apprentice_load (ms, &magic, &nmagic, fn, action); if (rv != 0) return -1; rv = apprentice_compile (ms, &magic, &nmagic, fn); free (magic); return rv; } if ((rv = apprentice_map (ms, &magic, &nmagic, fn)) == -1) { //if (ms->flags & R_MAGIC_CHECK) // file_magwarn(ms, "using regular magic file `%s'", fn); rv = apprentice_load (ms, &magic, &nmagic, fn, action); if (rv != 0) return -1; } mapped = rv; if (magic == NULL) { file_delmagic (magic, mapped, nmagic); return -1; } if ((ml = malloc (sizeof (*ml))) == NULL) { file_delmagic (magic, mapped, nmagic); file_oomem (ms, sizeof(*ml)); free (magic); return -1; } ml->magic = magic; ml->nmagic = nmagic; ml->mapped = mapped; mlist->prev->next = ml; ml->prev = mlist->prev; ml->next = mlist; mlist->prev = ml; return 0; }
/* const char *fn: list of magic files and directories */ struct mlist * file_apprentice(RMagic *ms, const char *fn, int action) { char *p, *mfn; int file_err, errs = -1; struct mlist *mlist; init_file_tables (); if (!fn) fn = getenv ("MAGIC"); if (!fn) fn = MAGICFILE; if (!(mfn = strdup (fn))) { file_oomem (ms, strlen (fn)); return NULL; } fn = mfn; if (!(mlist = malloc (sizeof (*mlist)))) { free (mfn); file_oomem (ms, sizeof (*mlist)); return NULL; } mlist->next = mlist->prev = mlist; while (fn) { p = strchr (fn, PATHSEP); if (p) *p++ = '\0'; if (*fn == '\0') break; file_err = apprentice_1 (ms, fn, action, mlist); errs = R_MAX (errs, file_err); fn = p; } if (errs == -1) { free (mfn); free (mlist); mlist = NULL; file_error (ms, 0, "could not find any magic files!"); return NULL; } free (mfn); return mlist; }
int file_check_mem(RMagic *ms, unsigned int level) { if (level >= ms->c.len) { size_t len = (ms->c.len += 20) * sizeof (*ms->c.li); ms->c.li = (ms->c.li == NULL) ? malloc (len) : realloc (ms->c.li, len); if (ms->c.li == NULL) { file_oomem (ms, len); return -1; } } ms->c.li[level].got_match = 0; ms->c.li[level].last_match = 0; ms->c.li[level].last_cond = COND_NONE; return 0; }
const char *file_getbuffer(RMagic *ms) { char *pbuf, *op, *np; size_t psize, len; if (ms->haderr) return NULL; if (ms->flags & R_MAGIC_RAW) return ms->o.buf; if (ms->o.buf == NULL) { eprintf ("ms->o.buf = NULL\n"); return NULL; } /* * 4 is for octal representation, + 1 is for NUL */ len = strlen (ms->o.buf); if (len > (SIZE_MAX - 1) / 4) { file_oomem (ms, len); return NULL; } psize = len * 4 + 1; if ((pbuf = realloc (ms->o.pbuf, psize)) == NULL) { file_oomem (ms, psize); return NULL; } ms->o.pbuf = pbuf; #if 1 //defined(HAVE_WCHAR_H) && defined(HAVE_MBRTOWC) && defined(HAVE_WCWIDTH) { mbstate_t state; wchar_t nextchar; int mb_conv = 1; size_t bytesconsumed; char *eop; (void)memset(&state, 0, sizeof(mbstate_t)); np = ms->o.pbuf; op = ms->o.buf; eop = op + len; while (op < eop) { bytesconsumed = mbrtowc(&nextchar, op, (size_t)(eop - op), &state); if (bytesconsumed == (size_t)(-1) || bytesconsumed == (size_t)(-2)) { mb_conv = 0; break; } if (iswprint(nextchar)) { (void)memcpy(np, op, bytesconsumed); op += bytesconsumed; np += bytesconsumed; } else { while (bytesconsumed-- > 0) OCTALIFY(np, op); } } *np = '\0'; /* Parsing succeeded as a multi-byte sequence */ if (mb_conv != 0) return ms->o.pbuf; } #endif for (np = ms->o.pbuf, op = ms->o.buf; *op; op++) { if (isprint ((ut8)*op)) { *np++ = *op; } else { OCTALIFY (np, op); } } *np = '\0'; return ms->o.pbuf; }
/* * parse one line from magic file, put into magic[index++] if valid */ static int parse(RMagic *ms, struct r_magic_entry **mentryp, ut32 *nmentryp, const char *line, size_t lineno, int action) { static ut32 last_cont_level = 0; size_t i; struct r_magic_entry *me; struct r_magic *m; const char *l = line; char *t; int op; ut32 cont_level = 0; for (; *l == '>'; l++, cont_level++); if (cont_level == 0 || cont_level > last_cont_level) if (file_check_mem (ms, cont_level) == -1) return -1; last_cont_level = cont_level; #define ALLOC_CHUNK (size_t)10 #define ALLOC_INCR (size_t)200 if (cont_level != 0) { if (*nmentryp == 0) { file_error(ms, 0, "No current entry for continuation"); return -1; } me = &(*mentryp)[*nmentryp - 1]; if (me->cont_count == me->max_count) { struct r_magic *nm; size_t cnt = me->max_count + ALLOC_CHUNK; if (!(nm = realloc(me->mp, sizeof (*nm) * cnt))) { file_oomem(ms, sizeof (*nm) * cnt); return -1; } me->mp = nm; me->max_count = cnt; } m = &me->mp[me->cont_count++]; (void)memset(m, 0, sizeof (*m)); m->cont_level = cont_level; } else { if (*nmentryp == maxmagic) { struct r_magic_entry *mp; maxmagic += ALLOC_INCR; if (!(mp = realloc (*mentryp, sizeof (*mp) * maxmagic))) { file_oomem (ms, sizeof (*mp) * maxmagic); return -1; } (void)memset(&mp[*nmentryp], 0, sizeof (*mp) * ALLOC_INCR); *mentryp = mp; } me = &(*mentryp)[*nmentryp]; if (!me->mp) { if (!(m = malloc (sizeof (*m) * ALLOC_CHUNK))) { file_oomem (ms, sizeof (*m) * ALLOC_CHUNK); return -1; } me->mp = m; me->max_count = ALLOC_CHUNK; } else m = me->mp; (void)memset(m, 0, sizeof (*m)); m->cont_level = 0; me->cont_count = 1; } m->lineno = lineno; if (*l == '&') { /* m->cont_level == 0 checked below. */ ++l; /* step over */ m->flag |= OFFADD; } if (*l == '(') { ++l; /* step over */ m->flag |= INDIR; if (m->flag & OFFADD) m->flag = (m->flag & ~OFFADD) | INDIROFFADD; if (*l == '&') { /* m->cont_level == 0 checked below */ ++l; /* step over */ m->flag |= OFFADD; } } /* Indirect offsets are not valid at level 0. */ if (m->cont_level == 0 && (m->flag & (OFFADD | INDIROFFADD))) if (ms->flags & R_MAGIC_CHECK) file_magwarn(ms, "relative offset at level 0"); /* get offset, then skip over it */ m->offset = (ut32)strtoul(l, &t, 0); if ((l == t) && (ms->flags & R_MAGIC_CHECK)) file_magwarn(ms, "offset `%s' invalid", l); l = t; if (m->flag & INDIR) { m->in_type = FILE_LONG; m->in_offset = 0; /* * read [.lbs][+-]nnnnn) */ if (*l == '.') { l++; switch (*l) { case 'l': m->in_type = FILE_LELONG; break; case 'L': m->in_type = FILE_BELONG; break; case 'm': m->in_type = FILE_MELONG; break; case 'h': case 's': m->in_type = FILE_LESHORT; break; case 'H': case 'S': m->in_type = FILE_BESHORT; break; case 'c': case 'b': case 'C': case 'B': m->in_type = FILE_BYTE; break; case 'e': case 'f': case 'g': m->in_type = FILE_LEDOUBLE; break; case 'E': case 'F': case 'G': m->in_type = FILE_BEDOUBLE; break; default: if (ms->flags & R_MAGIC_CHECK) file_magwarn(ms, "indirect offset type `%c' invalid", *l); break; } l++; } m->in_op = 0; if (*l == '~') { m->in_op |= FILE_OPINVERSE; l++; } if ((op = get_op(*l)) != -1) { m->in_op |= op; l++; } if (*l == '(') { m->in_op |= FILE_OPINDIRECT; l++; } if (isdigit((ut8)*l) || *l == '-') { m->in_offset = (int32_t)strtol(l, &t, 0); if (l == t) if (ms->flags & R_MAGIC_CHECK) file_magwarn(ms, "in_offset `%s' invalid", l); l = t; } if (*l++ != ')' || ((m->in_op & FILE_OPINDIRECT) && *l++ != ')')) if (ms->flags & R_MAGIC_CHECK) file_magwarn(ms, "missing ')' in indirect offset"); } EATAB; m->cond = get_cond(l, &l); if (check_cond(ms, m->cond, cont_level) == -1) return -1; EATAB; if (*l == 'u') { ++l; m->flag |= UNSIGNED; } m->type = get_type(l, &l); if (m->type == FILE_INVALID) { if (ms->flags & R_MAGIC_CHECK) file_magwarn(ms, "type `%s' invalid", l); return -1; } /* New-style anding: "0 byte&0x80 =0x80 dynamically linked" */ /* New and improved: ~ & | ^ + - * / % -- exciting, isn't it? */ m->mask_op = 0; if (*l == '~') { if (!MAGIC_IS_STRING (m->type)) m->mask_op |= FILE_OPINVERSE; else if (ms->flags & R_MAGIC_CHECK) file_magwarn (ms, "'~' invalid for string types"); ++l; } m->str_range = 0; m->str_flags = 0; m->num_mask = 0; if ((op = get_op (*l)) != -1) { if (!MAGIC_IS_STRING (m->type)) { ut64 val; ++l; m->mask_op |= op; val = (ut64)strtoull (l, &t, 0); l = t; m->num_mask = file_signextend (ms, m, val); eatsize (&l); } else if (op == FILE_OPDIVIDE) { int have_range = 0; while (!isspace ((ut8)*++l)) { switch (*l) { case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': if (have_range && (ms->flags & R_MAGIC_CHECK)) file_magwarn(ms, "multiple ranges"); have_range = 1; m->str_range = strtoul(l, &t, 0); if (m->str_range == 0) file_magwarn(ms, "zero range"); l = t - 1; break; case CHAR_COMPACT_BLANK: m->str_flags |= STRING_COMPACT_BLANK; break; case CHAR_COMPACT_OPTIONAL_BLANK: m->str_flags |= STRING_COMPACT_OPTIONAL_BLANK; break; case CHAR_IGNORE_LOWERCASE: m->str_flags |= STRING_IGNORE_LOWERCASE; break; case CHAR_IGNORE_UPPERCASE: m->str_flags |= STRING_IGNORE_UPPERCASE; break; case CHAR_REGEX_OFFSET_START: m->str_flags |= REGEX_OFFSET_START; break; default: if (ms->flags & R_MAGIC_CHECK) file_magwarn(ms, "string extension `%c' invalid", *l); return -1; } /* allow multiple '/' for readability */ if (l[1] == '/' && !isspace ((ut8)l[2])) l++; } if (string_modifier_check(ms, m) == -1) return -1; } else { if (ms->flags & R_MAGIC_CHECK) file_magwarn(ms, "invalid string op: %c", *t); return -1; } } /* * We used to set mask to all 1's here, instead let's just not do * anything if mask = 0 (unless you have a better idea) */ EATAB; switch (*l) { case '>': case '<': /* Old-style anding: "0 byte &0x80 dynamically linked" */ case '&': case '^': case '=': m->reln = *l; ++l; if (*l == '=') { /* HP compat: ignore &= etc. */ ++l; } break; case '!': m->reln = *l; ++l; break; default: m->reln = '='; /* the default relation */ if (*l == 'x' && ((isascii((ut8)l[1]) && isspace ((ut8)l[1])) || !l[1])) { m->reln = *l; ++l; } break; } /* * Grab the value part, except for an 'x' reln. */ if (m->reln != 'x' && getvalue (ms, m, &l, action)) return -1; /* * TODO finish this macro and start using it! * #define offsetcheck {if (offset > HOWMANY-1) * magwarn("offset too big"); } */ /* * Now get last part - the description */ EATAB; if (l[0] == '\b') { ++l; m->flag |= NOSPACE; } else if ((l[0] == '\\') && (l[1] == 'b')) { ++l; ++l; m->flag |= NOSPACE; } for (i = 0; (m->desc[i++] = *l++) != '\0' && i < sizeof (m->desc); ) continue; if (i == sizeof (m->desc)) { m->desc[sizeof (m->desc) - 1] = '\0'; if (ms->flags & R_MAGIC_CHECK) file_magwarn(ms, "description `%s' truncated", m->desc); } /* * We only do this check while compiling, or if any of the magic * files were not compiled. */ if (ms->flags & R_MAGIC_CHECK) if (check_format (ms, m) == -1) return -1; if (action == FILE_CHECK) file_mdump (m); m->mimetype[0] = '\0'; /* initialise MIME type to none */ if (m->cont_level == 0) ++(*nmentryp); /* make room for next */ return 0; }
/* * parse a file or directory of files * const char *fn: name of magic file or directory */ static int apprentice_load(RMagic *ms, struct r_magic **magicp, ut32 *nmagicp, const char *fn, int action) { ut32 marraycount, i, mentrycount = 0, starttest; struct r_magic_entry *marray; char subfn[MAXPATHLEN]; struct dirent *d; struct stat st; int errs = 0; DIR *dir; ms->flags |= R_MAGIC_CHECK; /* Enable checks for parsed files */ maxmagic = MAXMAGIS; if (!(marray = calloc (maxmagic, sizeof (*marray)))) { file_oomem (ms, maxmagic * sizeof (*marray)); return -1; } marraycount = 0; /* print silly verbose header for USG compat. */ if (action == FILE_CHECK) eprintf ("%s\n", usg_hdr); /* load directory or file */ if (stat (fn, &st) == 0 && S_ISDIR (st.st_mode)) { if (r_sandbox_enable (0) && !r_sandbox_check_path (fn)) { free (marray); return -1; } dir = opendir (fn); if (dir) { while ((d = readdir (dir))) { if (*d->d_name=='.') continue; snprintf (subfn, sizeof (subfn), "%s/%s", fn, d->d_name); if (stat (subfn, &st) == 0 && S_ISREG (st.st_mode)) load_1 (ms, action, subfn, &errs, &marray, &marraycount); //else perror (subfn); } closedir (dir); } else errs++; } else load_1 (ms, action, fn, &errs, &marray, &marraycount); if (errs) goto out; /* Set types of tests */ for (i = 0; i < marraycount; ) { if (marray[i].mp->cont_level != 0) { i++; continue; } starttest = i; do { set_test_type(marray[starttest].mp, marray[i].mp); if (ms->flags & R_MAGIC_DEBUG) { (void)fprintf(stderr, "%s%s%s: %s\n", marray[i].mp->mimetype, marray[i].mp->mimetype[0] == '\0' ? "" : "; ", marray[i].mp->desc[0] ? marray[i].mp->desc : "(no description)", marray[i].mp->flag & BINTEST ? "binary" : "text"); if (marray[i].mp->flag & BINTEST) { #define SYMBOL "text" #define SYMLEN sizeof (SYMBOL) char *p = strstr(marray[i].mp->desc, "text"); if (p && (p == marray[i].mp->desc || isspace((unsigned char)p[-1])) && (p + SYMLEN - marray[i].mp->desc == MAXstring || (p[SYMLEN] == '\0' || isspace((unsigned char)p[SYMLEN])))) { (void)fprintf(stderr, "*** Possible binary test for text type\n"); } #undef SYMBOL #undef SYMLEN } } } while (++i < marraycount && marray[i].mp->cont_level != 0); } qsort (marray, marraycount, sizeof (*marray), apprentice_sort); /* * Make sure that any level 0 "default" line is last (if one exists). */ for (i = 0; i < marraycount; i++) { if (marray[i].mp->cont_level == 0 && marray[i].mp->type == FILE_DEFAULT) { while (++i < marraycount) if (marray[i].mp->cont_level == 0) break; if (i != marraycount) { ms->line = marray[i].mp->lineno; /* XXX - Ugh! */ file_magwarn (ms, "level 0 \"default\" did not sort last"); } break; } } for (i = 0; i < marraycount; i++) mentrycount += marray[i].cont_count; if (!(*magicp = malloc (1 + (sizeof (**magicp) * mentrycount)))) { file_oomem (ms, sizeof (**magicp) * mentrycount); errs++; goto out; } mentrycount = 0; for (i = 0; i < marraycount; i++) { (void)memcpy (*magicp + mentrycount, marray[i].mp, marray[i].cont_count * sizeof (**magicp)); mentrycount += marray[i].cont_count; } out: for (i = 0; i < marraycount; i++) free(marray[i].mp); free (marray); if (errs) { *magicp = NULL; *nmagicp = 0; return errs; } *nmagicp = mentrycount; return 0; }
/* * handle a compiled file. */ static int apprentice_map(RMagic *ms, struct r_magic **magicp, ut32 *nmagicp, const char *fn) { int fd; struct stat st; ut32 *ptr; ut32 version; int needsbyteswap; char *dbname = NULL; void *mm = NULL; dbname = mkdbname (fn, 0); if (!dbname) goto error2; if ((fd = r_sandbox_open (dbname, O_RDONLY|O_BINARY, 0)) == -1) goto error2; if (fstat(fd, &st) == -1) { file_error (ms, errno, "cannot stat `%s'", dbname); goto error1; } if (st.st_size < 8) { file_error (ms, 0, "file `%s' is too small", dbname); goto error1; } #ifdef QUICK if ((mm = mmap (0, (size_t)st.st_size, PROT_READ, //OPENBSDBUG |PROT_WRITE, MAP_PRIVATE|MAP_FILE, fd, (off_t)0)) == MAP_FAILED) { file_error (ms, errno, "cannot map `%s'"); //, dbname); goto error1; } #define RET 2 #else if (!(mm = malloc ((size_t)st.st_size))) { file_oomem(ms, (size_t)st.st_size); goto error1; } if (read (fd, mm, (size_t)st.st_size) != (size_t)st.st_size) { file_badread(ms); goto error1; } #define RET 1 #endif *magicp = mm; (void)close (fd); fd = -1; ptr = (ut32 *)(void *)*magicp; if (*ptr != MAGICNO) { if (swap4(*ptr) != MAGICNO) { //OPENBSDBUG file_error(ms, 0, "bad magic in `%s'"); file_error(ms, 0, "bad magic in `%s'", dbname); goto error1; } needsbyteswap = 1; } else needsbyteswap = 0; version = needsbyteswap? swap4(ptr[1]): ptr[1]; if (version != VERSIONNO) { file_error(ms, 0, "File %d.%d supports only %d version magic " "files. `%s' is version %d", FILE_VERSION_MAJOR, patchlevel, VERSIONNO, dbname, version); goto error1; } *nmagicp = (ut32)(st.st_size / sizeof (struct r_magic)); if (*nmagicp > 0) (*nmagicp)--; (*magicp)++; if (needsbyteswap) byteswap (*magicp, *nmagicp); free (dbname); return RET; error1: if (fd != -1) (void)close (fd); if (mm) { #ifdef QUICK (void)munmap((void *)mm, (size_t)st.st_size); #else free(mm); #endif } else { *magicp = NULL; *nmagicp = 0; } error2: free (dbname); return -1; }
int file_ascmagic(RMagic *ms, const ut8 *buf, size_t nbytes) { return 0; size_t i; ut8 *nbuf = NULL, *utf8_buf = NULL, *utf8_end; unichar *ubuf = NULL; size_t ulen, mlen; const struct names *p; int rv = -1; int mime = ms->flags & R_MAGIC_MIME; const char *code = NULL; const char *code_mime = NULL; const char *type = NULL; const char *subtype = NULL; const char *subtype_mime = NULL; int has_escapes = 0; int has_backspace = 0; int seen_cr = 0; int n_crlf = 0; int n_lf = 0; int n_cr = 0; int n_nel = 0; size_t last_line_end = (size_t)-1; int has_long_lines = 0; /* * Undo the NUL-termination kindly provided by process() * but leave at least one byte to look at */ while (nbytes > 1 && buf[nbytes - 1] == '\0') nbytes--; if (!(nbuf = calloc(1, (nbytes + 1) * sizeof(nbuf[0])))) goto done; if (!(ubuf = calloc(1, (nbytes + 1) * sizeof(ubuf[0])))) goto done; /* * Then try to determine whether it's any character code we can * identify. Each of these tests, if it succeeds, will leave * the text converted into one-unichar-per-character Unicode in * ubuf, and the number of characters converted in ulen. */ if (looks_ascii(buf, nbytes, ubuf, &ulen)) { code = "ASCII"; code_mime = "us-ascii"; type = "text"; } else if (looks_utf8_with_BOM(buf, nbytes, ubuf, &ulen) > 0) { code = "UTF-8 Unicode (with BOM)"; code_mime = "utf-8"; type = "text"; } else if (file_looks_utf8(buf, nbytes, ubuf, &ulen) > 1) { code = "UTF-8 Unicode"; code_mime = "utf-8"; type = "text"; } else if ((i = looks_ucs16(buf, nbytes, ubuf, &ulen)) != 0) { if (i == 1) code = "Little-endian UTF-16 Unicode"; else code = "Big-endian UTF-16 Unicode"; type = "character data"; code_mime = "utf-16"; /* is this defined? */ } else if (looks_latin1(buf, nbytes, ubuf, &ulen)) { if (!memcmp (buf, "\xff\xff\xff\xff", 4)) { // uninitialized memory is not iso-8859!! goto done; } code = "ISO-8859"; type = "text"; code_mime = "iso-8859-1"; } else if (looks_extended(buf, nbytes, ubuf, &ulen)) { code = "Non-ISO extended-ASCII"; type = "text"; code_mime = "unknown"; } else { from_ebcdic(buf, nbytes, nbuf); if (looks_ascii(nbuf, nbytes, ubuf, &ulen)) { code = "EBCDIC"; type = "character data"; code_mime = "ebcdic"; } else if (looks_latin1(nbuf, nbytes, ubuf, &ulen)) { code = "International EBCDIC"; type = "character data"; code_mime = "ebcdic"; } else { rv = 0; goto done; /* doesn't look like text at all */ } } if (nbytes <= 1) { rv = 0; goto done; } /* Convert ubuf to UTF-8 and try text soft magic */ /* If original was ASCII or UTF-8, could use nbuf instead of re-converting. */ /* malloc size is a conservative overestimate; could be re-converting improved, or at least realloced after re-converting conversion. */ mlen = ulen * 6; if (!(utf8_buf = malloc(mlen))) { file_oomem(ms, mlen); goto done; } if (!(utf8_end = encode_utf8(utf8_buf, mlen, ubuf, ulen))) goto done; if (file_softmagic(ms, utf8_buf, utf8_end - utf8_buf, TEXTTEST) != 0) { rv = 1; goto done; } /* look for tokens from names.h - this is expensive! */ if ((ms->flags & R_MAGIC_NO_CHECK_TOKENS) != 0) goto subtype_identified; i = 0; while (i < ulen) { size_t end; /* skip past any leading space */ while (i < ulen && ISSPC(ubuf[i])) i++; if (i >= ulen) break; /* find the next whitespace */ for (end = i + 1; end < nbytes; end++) if (ISSPC(ubuf[end])) break; /* compare the word thus isolated against the token list */ for (p = names; p < names + NNAMES; p++) { if (ascmatch((const ut8 *)p->name, ubuf + i, end - i)) { subtype = types[p->type].human; subtype_mime = types[p->type].mime; goto subtype_identified; } } i = end; } subtype_identified: /* Now try to discover other details about the file. */ for (i = 0; i < ulen; i++) { if (ubuf[i] == '\n') { if (seen_cr) n_crlf++; else n_lf++; last_line_end = i; } else if (seen_cr) n_cr++; seen_cr = (ubuf[i] == '\r'); if (seen_cr) last_line_end = i; if (ubuf[i] == 0x85) { /* X3.64/ECMA-43 "next line" character */ n_nel++; last_line_end = i; } /* If this line is _longer_ than MAXLINELEN, remember it. */ if (i > last_line_end + MAXLINELEN) has_long_lines = 1; if (ubuf[i] == '\033') has_escapes = 1; if (ubuf[i] == '\b') has_backspace = 1; } /* Beware, if the data has been truncated, the final CR could have been followed by a LF. If we have HOWMANY bytes, it indicates that the data might have been truncated, probably even before this function was called. */ if (seen_cr && nbytes < HOWMANY) n_cr++; if (mime) { if (mime & R_MAGIC_MIME_TYPE) { if (subtype_mime) { if (file_printf(ms, subtype_mime) == -1) goto done; } else { if (file_printf(ms, "text/plain") == -1) goto done; } } if ((mime == 0 || mime == R_MAGIC_MIME) && code_mime) { if ((mime & R_MAGIC_MIME_TYPE) && file_printf(ms, " charset=") == -1) goto done; if (file_printf(ms, code_mime) == -1) goto done; } if (mime == R_MAGIC_MIME_ENCODING) if (file_printf(ms, "binary") == -1){ rv = 1; goto done; } } else { if (file_printf(ms, code) == -1) goto done; if (subtype) { if (file_printf(ms, " ") == -1) goto done; if (file_printf(ms, subtype) == -1) goto done; } if (file_printf(ms, " ") == -1) goto done; if (file_printf(ms, type) == -1) goto done; if (has_long_lines) if (file_printf(ms, ", with very long lines") == -1) goto done; /* * Only report line terminators if we find one other than LF, * or if we find none at all. */ if ((n_crlf == 0 && n_cr == 0 && n_nel == 0 && n_lf == 0) || (n_crlf != 0 || n_cr != 0 || n_nel != 0)) { if (file_printf(ms, ", with") == -1) goto done; if (n_crlf == 0 && n_cr == 0 && n_nel == 0 && n_lf == 0) { if (file_printf(ms, " no") == -1) goto done; } else { if (n_crlf) { if (file_printf(ms, " CRLF") == -1) goto done; if (n_cr || n_lf || n_nel) if (file_printf(ms, ",") == -1) goto done; } if (n_cr) { if (file_printf(ms, " CR") == -1) goto done; if (n_lf || n_nel) if (file_printf(ms, ",") == -1) goto done; } if (n_lf) { if (file_printf(ms, " LF") == -1) goto done; if (n_nel) if (file_printf(ms, ",") == -1) goto done; } if (n_nel) if (file_printf(ms, " NEL") == -1) goto done; } if (file_printf(ms, " line terminators") == -1) goto done; } if (has_escapes) if (file_printf(ms, ", with escape sequences") == -1) goto done; if (has_backspace) if (file_printf(ms, ", with overstriking") == -1) goto done; } rv = 1; done: free (nbuf); free (ubuf); free (utf8_buf); return rv; }
static st32 mprint(RMagic *ms, struct r_magic *m) { ut64 v; float vf; double vd; ut64 t = 0; char *buf = NULL; union VALUETYPE *p = &ms->ms_value; switch (m->type) { case FILE_BYTE: v = file_signextend(ms, m, (ut64)p->b); switch (check_fmt(ms, m)) { case -1: return -1; case 1: buf = malloc (2); if (snprintf (buf, 2, "%c", (ut8)v)<0) { free (buf); return -1; } if (file_printf (ms, R_MAGIC_DESC, buf) == -1) { free (buf); return -1; } break; default: if (file_printf(ms, R_MAGIC_DESC, (ut8) v) == -1) return -1; break; } t = ms->offset + sizeof(char); break; case FILE_SHORT: case FILE_BESHORT: case FILE_LESHORT: v = file_signextend (ms, m, (ut64)p->h); switch (check_fmt (ms, m)) { case -1: return -1; case 1: buf = malloc (32); if (snprintf (buf, 32, "%hu", (unsigned short)v) < 0) { free (buf); return -1; } if (file_printf(ms, R_MAGIC_DESC, buf) == -1) { free (buf); return -1; } break; default: if (file_printf(ms, R_MAGIC_DESC, (unsigned short) v) == -1) return -1; break; } t = ms->offset + sizeof(short); break; case FILE_LONG: case FILE_BELONG: case FILE_LELONG: case FILE_MELONG: v = file_signextend(ms, m, (ut64)p->l); switch (check_fmt(ms, m)) { case -1: return -1; case 1: buf = malloc (32); if (snprintf (buf, 32, "%u", (ut32)v) < 0) { free (buf); return -1; } if (file_printf(ms, R_MAGIC_DESC, buf) == -1) { free (buf); return -1; } break; default: if (file_printf(ms, R_MAGIC_DESC, (ut32) v) == -1) return -1; break; } t = ms->offset + sizeof(st32); break; case FILE_QUAD: case FILE_BEQUAD: case FILE_LEQUAD: v = file_signextend(ms, m, p->q); if (file_printf(ms, R_MAGIC_DESC, (ut64) v) == -1) return -1; t = ms->offset + sizeof(ut64); break; case FILE_STRING: case FILE_PSTRING: case FILE_BESTRING16: case FILE_LESTRING16: if (m->reln == '=' || m->reln == '!') { if (file_printf (ms, R_MAGIC_DESC, m->value.s) == -1) return -1; t = ms->offset + m->vallen; } else { if (*m->value.s == '\0') p->s[strcspn (p->s, "\n")] = '\0'; if (file_printf (ms, R_MAGIC_DESC, p->s) == -1) return -1; t = ms->offset + strlen (p->s); if (m->type == FILE_PSTRING) t++; } break; case FILE_DATE: case FILE_BEDATE: case FILE_LEDATE: case FILE_MEDATE: if (file_printf(ms, R_MAGIC_DESC, file_fmttime(p->l, 1)) == -1) return -1; t = ms->offset + sizeof(time_t); break; case FILE_LDATE: case FILE_BELDATE: case FILE_LELDATE: case FILE_MELDATE: if (file_printf(ms, R_MAGIC_DESC, file_fmttime(p->l, 0)) == -1) return -1; t = ms->offset + sizeof(time_t); break; case FILE_QDATE: case FILE_BEQDATE: case FILE_LEQDATE: if (file_printf(ms, R_MAGIC_DESC, file_fmttime((ut32)p->q, 1)) == -1) return -1; t = ms->offset + sizeof(ut64); break; case FILE_QLDATE: case FILE_BEQLDATE: case FILE_LEQLDATE: if (file_printf(ms, R_MAGIC_DESC, file_fmttime((ut32)p->q, 0)) == -1) return -1; t = ms->offset + sizeof(ut64); break; case FILE_FLOAT: case FILE_BEFLOAT: case FILE_LEFLOAT: vf = p->f; switch (check_fmt(ms, m)) { case -1: return -1; case 1: buf = malloc (32); if (snprintf (buf, 32, "%g", vf) < 0) { free (buf); return -1; } if (file_printf (ms, R_MAGIC_DESC, buf) == -1) { free (buf); return -1; } break; default: if (file_printf(ms, R_MAGIC_DESC, vf) == -1) return -1; break; } t = ms->offset + sizeof(float); break; case FILE_DOUBLE: case FILE_BEDOUBLE: case FILE_LEDOUBLE: vd = p->d; switch (check_fmt(ms, m)) { case -1: return -1; case 1: buf = malloc (32); if (snprintf (buf, 32, "%g", vd) < 0) { free (buf); return -1; } if (file_printf (ms, R_MAGIC_DESC, buf) == -1) { free (buf); return -1; } break; default: if (file_printf(ms, R_MAGIC_DESC, vd) == -1) return -1; break; } t = ms->offset + sizeof(double); break; case FILE_REGEX: { char *cp; int rval; cp = strdupn((const char *)ms->search.s, ms->search.rm_len); if (cp == NULL) { file_oomem(ms, ms->search.rm_len); return -1; } rval = file_printf(ms, R_MAGIC_DESC, cp); free(cp); if (rval == -1) return -1; if ((m->str_flags & REGEX_OFFSET_START)) t = ms->search.offset; else t = ms->search.offset + ms->search.rm_len; break; } case FILE_SEARCH: if (file_printf(ms, R_MAGIC_DESC, m->value.s) == -1) return -1; if ((m->str_flags & REGEX_OFFSET_START)) t = ms->search.offset; else t = ms->search.offset + m->vallen; break; case FILE_DEFAULT: if (file_printf(ms, R_MAGIC_DESC, m->value.s) == -1) return -1; t = ms->offset; break; default: file_magerror(ms, "invalid m->type (%d) in mprint()", m->type); return -1; } free (buf); return(t); }