Lines Matching +full:1 +full:ms
9 * 1. Redistributions of source code must retain the above copyright
76 #define MAP_FAILED (void *) -1
87 #define MAP_TYPE_MALLOC 1
115 file_private int getvalue(struct magic_set *ms, struct magic *, const char **, int);
179 #define DECLARE_FIELD(name) { # name, sizeof(# name) - 1, parse_ ## name }
196 struct magic_set *ms;
206 return 1;
209 if ((ms = magic_open(MAGIC_CHECK)) == NULL) {
211 return 1;
213 ret = magic_compile(ms, argv[1]) == -1 ? 1 : 0;
214 if (ret == 1)
215 (void)fprintf(stderr, "%s: %s\n", progname, magic_error(ms));
216 magic_close(ms);
236 # define XX(s) s, (sizeof(s) - 1)
344 if (isalpha(CAST(unsigned char, l[1]))) {
345 switch (l[1]) {
379 } else if (isdigit(CAST(unsigned char, l[1]))) {
382 * of 1, 2, 4, and 8 - the Single UNIX Specification
394 switch (l[1]) {
395 case '1':
449 return -1;
459 return -1;
474 apprentice_1(struct magic_set *ms, const char *fn, int action)
482 file_error(ms, 0, "magic element size %lu != %lu",
485 return -1;
489 map = apprentice_load(ms, fn, action);
491 return -1;
492 return apprentice_compile(ms, map, fn);
496 map = apprentice_map(ms, fn);
498 if (ms->flags & MAGIC_CHECK)
499 file_magwarn(ms, "using regular magic file `%s'", fn);
500 map = apprentice_load(ms, fn, action);
502 return -1;
506 if (add_mlist(ms->mlist[i], map, i) == -1) {
511 mlist_free_all(ms);
512 file_oomem(ms, sizeof(*ms->mlist[0]));
513 return -1;
521 apprentice_list(ms->mlist[i], BINTEST);
523 apprentice_list(ms->mlist[i], TEXTTEST);
533 file_ms_free(struct magic_set *ms)
536 if (ms == NULL)
539 mlist_free(ms->mlist[i]);
540 free(ms->o.pbuf);
541 free(ms->o.buf);
542 free(ms->c.li);
543 free(ms->fnamebuf);
545 freelocale(ms->c_lc_ctype);
547 free(ms);
553 struct magic_set *ms;
556 if ((ms = CAST(struct magic_set *, calloc(CAST(size_t, 1u),
557 sizeof(*ms)))) == NULL)
560 if (magic_setflags(ms, flags) == -1) {
565 ms->o.buf = ms->o.pbuf = NULL;
566 ms->o.blen = 0;
567 len = (ms->c.len = 10) * sizeof(*ms->c.li);
569 if ((ms->c.li = CAST(struct level_info *, malloc(len))) == NULL)
572 ms->event_flags = 0;
573 ms->error = -1;
575 ms->mlist[i] = NULL;
576 ms->fnamebuf = NULL;
577 ms->file = "unknown";
578 ms->line = 0;
579 ms->magwarn = 0;
580 ms->indir_max = FILE_INDIR_MAX;
581 ms->name_max = FILE_NAME_MAX;
582 ms->elf_shnum_max = FILE_ELF_SHNUM_MAX;
583 ms->elf_shsize_max = FILE_ELF_SHSIZE_MAX;
584 ms->elf_phnum_max = FILE_ELF_PHNUM_MAX;
585 ms->elf_notes_max = FILE_ELF_NOTES_MAX;
586 ms->regex_max = FILE_REGEX_MAX;
587 ms->bytes_max = FILE_BYTES_MAX;
588 ms->encoding_max = FILE_ENCODING_MAX;
589 ms->magwarn_max = FILE_MAGWARN_MAX;
591 ms->c_lc_ctype = newlocale(LC_CTYPE_MASK, "C", 0);
592 assert(ms->c_lc_ctype != NULL);
594 return ms;
596 free(ms);
638 if ((mlist = CAST(struct mlist *, calloc(1, sizeof(*mlist)))) == NULL) {
646 mlist_free_all(struct magic_set *ms)
651 mlist_free(ms->mlist[i]);
652 ms->mlist[i] = NULL;
695 buffer_apprentice(struct magic_set *ms, struct magic **bufs,
702 return -1;
704 (void)file_reset(ms, 0);
709 mlist_free(ms->mlist[i]);
710 if ((ms->mlist[i] = mlist_alloc()) == NULL) {
711 file_oomem(ms, sizeof(*ms->mlist[0]));
717 map = apprentice_buf(ms, bufs[i], sizes[i]);
722 if (add_mlist(ms->mlist[j], map, j) == -1) {
723 file_oomem(ms, sizeof(*ms->mlist[0]));
731 mlist_free_all(ms);
732 return -1;
738 file_apprentice(struct magic_set *ms, const char *fn, int action)
741 int fileerr, errs = -1;
744 (void)file_reset(ms, 0);
747 return -1;
751 free(ms->fnamebuf);
752 if ((ms->fnamebuf = strdup(fn)) == NULL) {
753 file_oomem(ms, strlen(fn));
754 return -1;
758 mlist_free(ms->mlist[i]);
759 if ((ms->mlist[i] = mlist_alloc()) == NULL) {
760 file_oomem(ms, sizeof(*ms->mlist[0]));
762 mlist_free(ms->mlist[j]);
763 ms->mlist[j] = NULL;
765 return -1;
768 fn = ms->fnamebuf;
776 fileerr = apprentice_1(ms, fn, action);
781 if (errs == -1) {
783 mlist_free(ms->mlist[i]);
784 ms->mlist[i] = NULL;
786 file_error(ms, 0, "could not find any valid magic files!");
787 return -1;
798 mlist_free(ms->mlist[i]);
799 ms->mlist[i] = NULL;
810 file_error(ms, 0, "Invalid action %d", action);
811 return -1;
820 * - [] expressions count 1
822 * - regular characters or escaped magic characters count 1
833 case '\\': /* Escaped anything counts 1 */
845 case '[': /* Bracketed expressions count 1 the ']' */
856 default: /* Anything else counts 1 */
861 return rv == 0 ? 1 : rv; /* Return at least 1 */
870 return 1;
1019 val += m->vallen * MAX(MULT / m->vallen, 1);
1024 val += v * MAX(MULT / v, 1);
1085 for (i = 1; m[i].cont_level != 0 && i < MIN(nmagic, 3); i++) {
1087 (i + 1);
1116 val = 1;
1157 return x > 0 ? -1 : 1;
1159 return sa > sb ? -1 : 1;
1175 while (magindex + 1 < ml->nmagic &&
1176 ml->magic[magindex + 1].cont_level != 0)
1186 for (; magindex + 1 < ml->nmagic &&
1187 ml->magic[magindex + 1].cont_level != 0;
1189 uint32_t mi = magindex + 1;
1299 addentry(struct magic_set *ms, struct magic_entry *me,
1302 size_t i = me->mp->type == FILE_NAME ? 1 : 0;
1310 file_oomem(ms, sizeof(*mp) * incr);
1311 return -1;
1328 load_1(struct magic_set *ms, int action, const char *fn, int *errs,
1336 FILE *f = fopen(ms->file = fn, "r");
1339 file_error(ms, errno, "cannot read magic file `%s'",
1347 for (ms->line = 1; (len = getline(&line, &llen, f)) != -1;
1348 ms->line++) {
1349 if (ms->magwarn >= ms->magwarn_max)
1353 if (line[len - 1] == '\n') {
1355 line[len - 1] = '\0'; /* delete newline */
1362 if (line[1] == ':') {
1372 file_error(ms, 0,
1378 file_error(ms, 0,
1384 if ((*bang[i].fun)(ms, &me,
1395 switch (parse(ms, &me, fn, line, lineno, action)) {
1398 case 1:
1399 (void)addentry(ms, &me, mset);
1408 (void)addentry(ms, &me, mset);
1425 set_text_binary(struct magic_set *ms, struct magic_entry *me, uint32_t nme,
1436 if ((ms->flags & MAGIC_DEBUG) == 0)
1446 isspace(CAST(unsigned char, p[-1]))) &&
1458 set_last_default(struct magic_set *ms, struct magic_entry *me, uint32_t nme)
1469 ms->line = me[i].mp->lineno;
1470 file_magwarn(ms,
1479 coalesce_entries(struct magic_set *ms, struct magic_entry *me, uint32_t nme,
1496 file_oomem(ms, slen);
1497 return -1;
1522 apprentice_load(struct magic_set *ms, const char *fn, int action)
1535 ms->flags |= MAGIC_CHECK; /* Enable checks for parsed files */
1538 if ((map = CAST(struct magic_map *, calloc(1, sizeof(*map)))) == NULL)
1540 file_oomem(ms, sizeof(*map));
1560 file_oomem(ms,
1566 if (stat(mfn, &st) == -1 || !S_ISREG(st.st_mode)) {
1573 maxfiles = (maxfiles + 1) * 2;
1577 file_oomem(ms, mlen);
1591 load_1(ms, action, filearr[i], &errs, mset);
1598 load_1(ms, action, fn, &errs, mset);
1609 i = set_text_binary(ms, mset[j].me, mset[j].count, i);
1619 set_last_default(ms, mset[j].me, mset[j].count);
1625 if (coalesce_entries(ms, mset[j].me, mset[j].count,
1626 &map->magic[j], &map->nmagic[j]) == -1) {
1648 file_signextend(struct magic_set *ms, struct magic *m, uint64_t v)
1724 if (ms->flags & MAGIC_CHECK)
1725 file_magwarn(ms, "cannot happen: m->type=%d\n",
1734 string_modifier_check(struct magic_set *ms, struct magic *m)
1736 if ((ms->flags & MAGIC_CHECK) == 0)
1741 file_magwarn(ms,
1743 return -1;
1749 file_magwarn(ms,
1751 return -1;
1757 file_magwarn(ms,
1760 return -1;
1765 file_magwarn(ms,
1769 return -1;
1774 file_magwarn(ms, "'/%c' not allowed on regex\n",
1776 return -1;
1779 file_magwarn(ms, "'/%c' not allowed on regex\n",
1781 return -1;
1785 file_magwarn(ms, "coding error: m->type=%d\n",
1787 return -1;
1813 return -1;
1845 check_cond(struct magic_set *ms, int cond, uint32_t cont_level)
1848 last_cond = ms->c.li[cont_level].last_cond;
1853 if (ms->flags & MAGIC_CHECK)
1854 file_magwarn(ms, "syntax error: `if'");
1855 return -1;
1862 if (ms->flags & MAGIC_CHECK)
1863 file_magwarn(ms, "syntax error: `elif'");
1864 return -1;
1871 if (ms->flags & MAGIC_CHECK)
1872 file_magwarn(ms, "syntax error: `else'");
1873 return -1;
1883 ms->c.li[cont_level].last_cond = last_cond;
1889 parse_indirect_modifier(struct magic_set *ms, struct magic *m, const char **lp)
1899 if (ms->flags & MAGIC_CHECK)
1900 file_magwarn(ms, "indirect modifier `%c' "
1903 return -1;
1910 parse_op_modifier(struct magic_set *ms, struct magic *m, const char **lp,
1921 m->num_mask = file_signextend(ms, m, val);
1927 parse_string_modifier(struct magic_set *ms, struct magic *m, const char **lp)
1935 case '0': case '1': case '2':
1939 if (have_range && (ms->flags & MAGIC_CHECK))
1940 file_magwarn(ms, "multiple ranges");
1941 have_range = 1;
1944 file_magwarn(ms, "zero range");
1945 l = t - 1;
2012 if (ms->flags & MAGIC_CHECK)
2013 file_magwarn(ms, "string modifier `%c' "
2018 if (l[1] == '/' && !isspace(CAST(unsigned char, l[2])))
2021 if (string_modifier_check(ms, m) == -1)
2027 return -1;
2034 parse(struct magic_set *ms, struct magic_entry *me, const char *file,
2059 if (file_check_mem(ms, cont_level) == -1)
2060 return -1;
2065 file_magerror(ms, "No current entry for continuation");
2066 return -1;
2069 file_magerror(ms, "Continuations present with 0 count");
2070 return -1;
2072 m = &me->mp[me->cont_count - 1];
2074 if (diff > 1)
2075 file_magwarn(ms, "New continuation level %u is more "
2083 file_oomem(ms, sizeof(*nm) * cnt);
2084 return -1;
2095 return 1;
2097 file_oomem(ms, len);
2098 return -1;
2105 me->cont_count = 1;
2126 if (ms->flags & MAGIC_CHECK)
2127 file_magwarn(ms, "relative offset at level 0");
2128 return -1;
2134 m->flag |= l[-1] == '-' ? OFFNEGATIVE : OFFPOSITIVE;
2138 if (ms->flags & MAGIC_CHECK)
2139 file_magwarn(ms, "offset `%s' invalid", l);
2140 return -1;
2206 if (ms->flags & MAGIC_CHECK)
2207 file_magwarn(ms,
2210 return -1;
2219 if ((op = get_op(*l)) != -1) {
2230 if (ms->flags & MAGIC_CHECK)
2231 file_magwarn(ms,
2233 return -1;
2239 if (ms->flags & MAGIC_CHECK)
2240 file_magwarn(ms,
2242 return -1;
2249 if (check_cond(ms, m->cond, cont_level) == -1)
2250 return -1;
2264 m->type = get_type(type_tbl, l + 1, &l);
2292 && !isalpha(CAST(unsigned char, l[1]))) {
2305 if (ms->flags & MAGIC_CHECK)
2306 file_magwarn(ms, "type `%s' invalid", l);
2307 return -1;
2311 if (ms->flags & MAGIC_CHECK)
2312 file_magwarn(ms, "`name%s' entries can only be "
2314 return -1;
2324 else if (ms->flags & MAGIC_CHECK)
2325 file_magwarn(ms, "'~' invalid for string types");
2330 if ((op = get_op(*l)) != -1) {
2335 if (ms->flags & MAGIC_CHECK)
2336 file_magwarn(ms,
2339 return -1;
2343 r = parse_indirect_modifier(ms, m, &l);
2345 r = parse_string_modifier(ms, m, &l);
2346 if (r == -1)
2347 return -1;
2349 parse_op_modifier(ms, m, &l, op);
2353 * We used to set mask to all 1's here, instead let's just not do
2364 if (ms->flags & MAGIC_CHECK) {
2365 file_magwarn(ms, "%c= not supported",
2367 return -1;
2389 if (*l == 'x' && ((isascii(CAST(unsigned char, l[1])) &&
2390 isspace(CAST(unsigned char, l[1]))) || !l[1])) {
2399 if (m->reln != 'x' && getvalue(ms, m, &l, action))
2400 return -1;
2404 * #define offsetcheck {if (offset > ms->bytes_max -1)
2415 } else if ((l[0] == '\\') && (l[1] == 'b')) {
2424 strlcpy(m->desc + 1, file, sizeof(m->desc) - 1);
2427 m->desc[sizeof(m->desc) - 1] = '\0';
2428 if (ms->flags & MAGIC_CHECK)
2429 file_magwarn(ms, "description `%s' truncated", m->desc);
2436 if (ms->flags & MAGIC_CHECK) {
2437 if (check_format(ms, m) == -1)
2438 return -1;
2450 * parse a STRENGTH annotation line from magic file, put into magic[index - 1]
2455 parse_strength(struct magic_set *ms, struct magic_entry *me, const char *line,
2465 file_magwarn(ms,
2468 return -1;
2471 file_magwarn(ms, "%s: Strength setting is not supported in "
2473 file_printable(ms, sbuf, sizeof(sbuf), m->value.s,
2475 return -1;
2488 file_magwarn(ms, "Unknown factor op `%c'", *l);
2489 return -1;
2494 file_magwarn(ms, "Too large factor `%lu'", factor);
2498 file_magwarn(ms, "Bad factor `%s'", l);
2503 file_magwarn(ms, "Cannot have factor op `%c' and factor %u",
2511 return -1;
2521 parse_extra(struct magic_set *ms, struct magic_entry *me, const char *line,
2527 struct magic *m = &me->mp[me->cont_count == 0 ? 0 : me->cont_count - 1];
2532 file_magwarn(ms, "Current entry already has a %s type "
2534 return -1;
2538 file_magwarn(ms, "Current entry does not yet have a "
2540 return -1;
2550 buf[len - 1] = '\0';
2551 if (ms->flags & MAGIC_CHECK)
2552 file_magwarn(ms, "%s type `%s' truncated %"
2556 file_magwarn(ms, "%s type `%s' has bad char '%c'",
2565 file_magerror(ms, "Bad magic entry '%s'", line);
2566 return -1;
2571 * magic[index - 1]
2574 parse_apple(struct magic_set *ms, struct magic_entry *me, const char *line,
2577 return parse_extra(ms, me, line, len,
2579 sizeof(me->mp[me->cont_count - 1].apple), "APPLE", "!+-./?", 0);
2586 parse_ext(struct magic_set *ms, struct magic_entry *me, const char *line,
2589 return parse_extra(ms, me, line, len,
2591 sizeof(me->mp[me->cont_count - 1].ext), "EXTENSION", ",!+-/@?_$&~",
2598 * parse a MIME annotation line from magic file, put into magic[index - 1]
2602 parse_mime(struct magic_set *ms, struct magic_entry *me, const char *line,
2605 return parse_extra(ms, me, line, len,
2607 sizeof(me->mp[me->cont_count - 1].mimetype), "MIME", "+-/.$?:{};=",
2608 1);
2619 return -1;
2624 quad = 1;
2635 h = 1;
2795 return -1;
2798 return -1;
2806 check_format(struct magic_set *ms, struct magic *m)
2816 return 1;
2822 file_magwarn(ms, "Internal error inconsistency between "
2824 return -1;
2827 file_magwarn(ms, "No format string for `%s' with description "
2829 return -1;
2833 if (check_format_type(ptr, m->type, &estr) == -1) {
2838 file_magwarn(ms, "Printf format is %s for type "
2841 return -1;
2846 file_magwarn(ms,
2850 return -1;
2862 getvalue(struct magic_set *ms, struct magic *m, const char **p, int action)
2879 *p = getstr(ms, m, *p, action == FILE_COMPILE);
2881 if (ms->flags & MAGIC_CHECK)
2882 file_magwarn(ms, "cannot get string from `%s'",
2884 return -1;
2889 file_regcomp(ms, &rx, m->value.s, REG_EXTENDED);
2893 return rc ? -1 : 0;
2924 if (file_parse_guid(*p, m->value.guid) == -1)
2925 return -1;
2926 *p += FILE_GUID_SIZE - 1;
2931 m->value.q = file_signextend(ms, m, ull);
2933 file_magwarn(ms, "Unparsable number `%s'", *p);
2934 return -1;
2941 file_magwarn(ms,
2944 return -1;
2951 case 1:
2972 file_magwarn(ms, "Overflow for numeric"
2975 return -1;
2993 getstr(struct magic_set *ms, struct magic *m, const char *s, int warn)
2999 char *pmax = p + plen - 1;
3008 file_error(ms, 0, "string too long: `%s'", origs);
3025 file_magwarn(ms, "incomplete escape");
3031 file_magwarn(ms, "escaped dot ('.') found, "
3038 file_magwarn(ms,
3052 file_magwarn(ms, "no "
3057 file_magwarn(ms,
3116 case '1':
3160 size_t l = file_pstring_length_size(ms, m);
3169 /* Single hex char to int; -1 if not a hex char. */
3174 return -1;
3181 return -1;
3275 apprentice_buf(struct magic_set *ms, struct magic *buf, size_t len)
3279 if ((map = CAST(struct magic_map *, calloc(1, sizeof(*map)))) == NULL) {
3280 file_oomem(ms, sizeof(*map));
3286 if (check_buffer(ms, map, "buffer") != 0) {
3298 apprentice_map(struct magic_set *ms, const char *fn)
3306 fd = -1;
3307 if ((map = CAST(struct magic_map *, calloc(1, sizeof(*map)))) == NULL) {
3308 file_oomem(ms, sizeof(*map));
3313 dbname = mkdbname(ms, fn, 0);
3317 if ((fd = open(dbname, O_RDONLY|O_BINARY)) == -1)
3320 if (fstat(fd, &st) == -1) {
3321 file_error(ms, errno, "cannot stat `%s'", dbname);
3325 file_error(ms, 0, "file `%s' is too %s", dbname,
3335 file_error(ms, errno, "cannot map `%s'", dbname);
3341 file_oomem(ms, map->len);
3345 file_badread(ms);
3350 fd = -1;
3352 if (check_buffer(ms, map, dbname) != 0) {
3356 if (mprotect(map->p, CAST(size_t, st.st_size), PROT_READ) == -1) {
3357 file_error(ms, errno, "cannot mprotect `%s'", dbname);
3366 if (fd != -1)
3374 check_buffer(struct magic_set *ms, struct magic_map *map, const char *dbname)
3382 if (entries < MAGIC_SETS + 1) {
3383 file_error(ms, 0, "Too few magic entries %u in `%s'",
3385 return -1;
3388 file_error(ms, 0, "Size of `%s' %" SIZE_T_FORMAT "u is not "
3391 return -1;
3397 file_error(ms, 0, "bad magic in `%s'", dbname);
3398 return -1;
3400 needsbyteswap = 1;
3404 version = swap4(ptr[1]);
3406 version = ptr[1];
3408 file_error(ms, 0, "File %s supports only version %d magic "
3411 return -1;
3413 map->magic[0] = CAST(struct magic *, map->p) + 1;
3420 if (i != MAGIC_SETS - 1)
3421 map->magic[i + 1] = map->magic[i] + map->nmagic[i];
3424 if (entries != nentries + 1) {
3425 file_error(ms, 0, "Inconsistent entries in `%s' %u != %u",
3426 dbname, entries, nentries + 1);
3427 return -1;
3439 apprentice_compile(struct magic_set *ms, struct magic_map *map, const char *fn)
3443 int fd = -1;
3446 int rv = -1;
3453 dbname = mkdbname(ms, fn, 1);
3458 if ((fd = open(dbname, O_WRONLY|O_CREAT|O_TRUNC|O_BINARY, 0644)) == -1)
3460 file_error(ms, errno, "cannot open `%s'", dbname);
3465 hdr.h[1] = VERSIONNO;
3469 file_error(ms, errno, "error writing `%s'", dbname);
3476 file_error(ms, errno, "error writing `%s'", dbname);
3483 if (fd != -1)
3496 mkdbname(struct magic_set *ms, const char *fn, int strip)
3509 for (p = ext + sizeof(ext) - 1; p >= ext && q >= fn; p--, q--)
3520 if (ms->flags & MAGIC_MIME) {
3524 if (access(buf, R_OK) != -1) {
3525 ms->flags &= MAGIC_MIME_TYPE;
3535 ms->flags &= MAGIC_MIME_TYPE;
3560 d[0] = s[1];
3561 d[1] = s[0];
3575 d[1] = s[2];
3576 d[2] = s[1];
3592 d[1] = s[2];
3593 d[2] = s[1];
3601 d[1] = s[6];
3606 d[6] = s[1];
3624 *l = c - us + 1;
3637 *l = c - us + 1;
3664 file_pstring_length_size(struct magic_set *ms, const struct magic *m)
3668 return 1;
3676 file_error(ms, 0, "corrupt magic file "
3683 file_pstring_get_length(struct magic_set *ms, const struct magic *m,
3696 s1 = s[1];
3701 s1 = s[1];
3706 s1 = s[1];
3713 s1 = s[1];
3719 file_error(ms, 0, "corrupt magic file "
3726 size_t l = file_pstring_length_size(ms, m);
3736 file_magicfind(struct magic_set *ms, const char *name, struct mlist *v)
3741 mlist = ms->mlist[1];
3751 for (j = i + 1; j < ml->nmagic; j++)
3759 return -1;