Lines Matching +full:1 +full:ms
9 * 1. Redistributions of source code must retain the above copyright
75 (CAST(uint64_t, (p)[1])<<48)| \
89 (CAST(uint64_t, (p)[1])<<8)| \
94 (CAST(uint32_t, (p)[1])<<8)| \
98 (CAST(uint32_t, (p)[1])<<16)| \
102 (CAST(uint32_t, (p)[1])<<24)| \
107 #define BE16(p) ((CAST(uint16_t, (p)[0])<<8)|(CAST(uint16_t, (p)[1])))
108 #define LE16(p) ((CAST(uint16_t, (p)[1])<<8)|(CAST(uint16_t, (p)[0])))
119 file_softmagic(struct magic_set *ms, const struct buffer *b,
123 int rv = 0, printed_something = 0, need_separator = 0, firstline = 1;
135 for (ml = ms->mlist[0]->next; ml != ms->mlist[0]; ml = ml->next) {
136 int ret = match(ms, ml->magic, ml->magic_rxcomp, ml->nmagic, b,
141 case -1:
146 if ((ms->flags & MAGIC_CONTINUE) == 0)
161 file_fmtcheck(struct magic_set *ms, const char *desc, const char *def,
171 file_magerror(ms,
208 match(struct magic_set *ms, struct magic *magic, file_regex_t **magic_rxcomp,
216 int found_matchv = 0; /* if a match is found it is set to 1*/
219 int print = (ms->flags & MAGIC_NODESC) == 0;
230 if (file_check_mem(ms, cont_level) == -1)
231 return -1;
246 while (magindex < nmagic - 1 &&
247 magic[magindex + 1].cont_level != 0)
253 if (msetoffset(ms, m, &bb, b, offset, cont_level) == -1)
255 ms->line = m->lineno;
258 switch (mget(ms, m, b, CAST(const unsigned char *, bb.fbuf),
264 case -1:
265 return -1;
271 *found_match = 1;
272 *returnval = 1;
275 switch (magiccheck(ms, m, m_rxcomp)) {
276 case -1:
277 return -1;
295 if ((e = handle_annotation(ms, m, *firstline)) != 0)
297 *found_match = 1;
298 *need_separator = 1;
299 *printed_something = 1;
300 *returnval = 1;
310 *found_match = 1;
312 *returnval = 1;
313 *need_separator = 1;
314 *printed_something = 1;
315 if (print_sep(ms, *firstline) == -1)
316 return -1;
317 if (mprint(ms, m) == -1)
318 return -1;
322 switch (moffset(ms, m, &bb, offset, &ms->c.li[cont_level].off)) {
323 case -1:
331 if (file_check_mem(ms, ++cont_level) == -1)
332 return -1;
334 while (magindex + 1 < nmagic &&
335 magic[magindex + 1].cont_level != 0) {
338 ms->line = m->lineno; /* for messages */
349 if (msetoffset(ms, m, &bb, b, offset, cont_level) == -1)
353 if ((ms->flags & MAGIC_DEBUG) != 0)
359 ms->offset +=
360 ms->c.li[cont_level - 1].off;
366 if (ms->c.li[cont_level].last_match == 1)
370 switch (mget(ms, m, b, CAST(const unsigned char *,
375 case -1:
376 return -1;
380 flush = 1;
384 *found_match = 1;
385 *returnval = 1;
391 switch (flush ? 1 : magiccheck(ms, m, m_rxcomp)) {
392 case -1:
393 return -1;
396 ms->c.li[cont_level].last_match = 0;
401 ms->c.li[cont_level].last_match = 1;
404 ms->c.li[cont_level].got_match = 0;
405 else if (ms->c.li[cont_level].got_match) {
409 ms->c.li[cont_level].got_match = 1;
411 if ((e = handle_annotation(ms, m, *firstline))
413 *found_match = 1;
414 *need_separator = 1;
415 *printed_something = 1;
416 *returnval = 1;
420 *found_match = 1;
423 *returnval = 1;
436 *printed_something = 1;
437 if (print_sep(ms, *firstline)
438 == -1)
439 return -1;
444 if (file_printf(ms, " ") == -1)
445 return -1;
447 if (mprint(ms, m) == -1)
448 return -1;
449 *need_separator = 1;
452 switch (moffset(ms, m, &bb, offset,
453 &ms->c.li[cont_level].off)) {
454 case -1:
467 if (file_check_mem(ms, ++cont_level) == -1)
468 return -1;
476 if ((ms->flags & MAGIC_CONTINUE) == 0)
488 check_fmt(struct magic_set *ms, const char *fmt)
491 int rc, rv = -1;
497 rc = file_regcomp(ms, &rx, pat, REG_EXTENDED|REG_NOSUB);
499 rc = file_regexec(ms, &rx, fmt, 0, 0, 0);
520 if ((copy = CAST(char *, malloc(len + 1))) == NULL)
529 varexpand(struct magic_set *ms, char *buf, size_t len, const char *str)
537 return -1;
542 if (!*ptr || ptr[1] != '?')
543 return -1;
547 return -1;
548 for (ee = e = et + 1; *ee && *ee != '}'; ee++)
551 return -1;
554 if (ms->mode & 0111) {
563 return -1;
566 return -1;
570 sptr = ee + 1;
575 return -1;
584 mprint(struct magic_set *ms, struct magic *m)
591 union VALUETYPE *p = &ms->ms_value;
593 if (varexpand(ms, ebuf, sizeof(ebuf), m->desc) == -1)
599 v = file_signextend(ms, m, CAST(uint64_t, value)); \
600 switch (check_fmt(ms, desc)) { \
601 case -1: \
602 return -1; \
603 case 1: \
611 if (file_printf(ms, F(ms, desc, "%s"), buf) == -1) \
612 return -1; \
616 if (file_printf(ms, F(ms, desc, "%" format "u"), \
617 CAST(utype, v)) == -1) \
618 return -1; \
620 if (file_printf(ms, F(ms, desc, "%" format "d"), \
621 CAST(stype, v)) == -1) \
622 return -1; \
654 if (file_printf(ms, F(ms, desc, "%s"),
655 file_printable(ms, sbuf, sizeof(sbuf), m->value.s,
656 sizeof(m->value.s))) == -1)
657 return -1;
670 if (file_printf(ms, F(ms, desc, "%s"),
671 file_printable(ms, sbuf, sizeof(sbuf), str,
672 sizeof(p->s) - (str - p->s))) == -1)
673 return -1;
676 size_t l = file_pstring_length_size(ms, m);
678 return -1;
687 if (file_printf(ms, F(ms, desc, "%s"),
688 file_fmtdatetime(tbuf, sizeof(tbuf), p->l, 0)) == -1)
689 return -1;
696 if (file_printf(ms, F(ms, desc, "%s"),
698 == -1)
699 return -1;
705 if (file_printf(ms, F(ms, desc, "%s"),
706 file_fmtdatetime(tbuf, sizeof(tbuf), p->q, 0)) == -1)
707 return -1;
713 if (file_printf(ms, F(ms, desc, "%s"),
714 file_fmtdatetime(tbuf, sizeof(tbuf), p->q, FILE_T_LOCAL)) == -1)
715 return -1;
721 if (file_printf(ms, F(ms, desc, "%s"),
723 == -1)
724 return -1;
731 switch (check_fmt(ms, desc)) {
732 case -1:
733 return -1;
734 case 1:
736 if (file_printf(ms, F(ms, desc, "%s"), buf) == -1)
737 return -1;
740 if (file_printf(ms, F(ms, desc, "%g"), vf) == -1)
741 return -1;
750 switch (check_fmt(ms, desc)) {
751 case -1:
752 return -1;
753 case 1:
755 if (file_printf(ms, F(ms, desc, "%s"), buf) == -1)
756 return -1;
759 if (file_printf(ms, F(ms, desc, "%g"), vd) == -1)
760 return -1;
770 cp = strndup(RCAST(const char *, ms->search.s),
771 ms->search.rm_len);
773 file_oomem(ms, ms->search.rm_len);
774 return -1;
778 rval = file_printf(ms, F(ms, desc, "%s"), file_printable(ms,
779 sbuf, sizeof(sbuf), scp, ms->search.rm_len));
782 if (rval == -1)
783 return -1;
789 if (file_printf(ms, "%s", m->desc) == -1)
790 return -1;
798 if (file_printf(ms, F(ms, desc, "%s"),
799 file_printable(ms, sbuf, sizeof(sbuf), ms->ms_value.s,
800 sizeof(ms->ms_value.s))) == -1)
801 return -1;
804 (void) file_print_guid(buf, sizeof(buf), ms->ms_value.guid);
805 if (file_printf(ms, F(ms, desc, "%s"), buf) == -1)
806 return -1;
811 if (file_printf(ms, F(ms, desc, "%s"),
812 file_fmtdate(tbuf, sizeof(tbuf), p->h)) == -1)
813 return -1;
818 if (file_printf(ms, F(ms, desc, "%s"),
819 file_fmttime(tbuf, sizeof(tbuf), p->h)) == -1)
820 return -1;
824 if (file_printf(ms, F(ms, desc, "%s"), buf) == -1)
825 return -1;
828 file_magerror(ms, "invalid m->type (%d) in mprint()", m->type);
829 return -1;
835 moffset(struct magic_set *ms, struct magic *m, const struct buffer *b,
843 o = CAST(int32_t, (ms->offset + sizeof(char)));
855 o = CAST(int32_t, (ms->offset + sizeof(short)));
862 o = CAST(int32_t, (ms->offset + sizeof(int32_t)));
868 o = CAST(int32_t, (ms->offset + sizeof(int64_t)));
877 o = ms->offset + m->vallen;
879 union VALUETYPE *p = &ms->ms_value;
883 o = CAST(uint32_t, (ms->offset + strlen(p->s)));
885 size_t l = file_pstring_length_size(ms, m);
887 return -1;
897 o = CAST(int32_t, (ms->offset + sizeof(uint32_t)));
904 o = CAST(int32_t, (ms->offset + sizeof(uint32_t)));
910 o = CAST(int32_t, (ms->offset + sizeof(uint64_t)));
916 o = CAST(int32_t, (ms->offset + sizeof(uint64_t)));
922 o = CAST(int32_t, (ms->offset + sizeof(float)));
928 o = CAST(int32_t, (ms->offset + sizeof(double)));
933 o = CAST(int32_t, ms->search.offset - offset);
936 (ms->search.offset + ms->search.rm_len - offset));
941 o = CAST(int32_t, ms->search.offset - offset);
943 o = CAST(int32_t, (ms->search.offset + m->vallen - offset));
951 o = ms->offset;
955 o = der_offs(ms, m, nbytes);
956 if (o == -1 || CAST(size_t, o) > nbytes) {
957 if ((ms->flags & MAGIC_DEBUG) != 0) {
968 o = CAST(int32_t, (ms->offset + 2 * sizeof(uint64_t)));
978 file_error(ms, 0, "Offset out of range %" SIZE_T_FORMAT
981 return -1;
984 return 1;
988 cvt_id3(struct magic_set *ms, uint32_t v)
994 if ((ms->flags & MAGIC_DEBUG) != 0)
1072 return -1; \
1077 return -1; \
1126 return -1; \
1151 mconvert(struct magic_set *ms, struct magic *m, int flip)
1153 union VALUETYPE *p = &ms->ms_value;
1157 if (cvt_8(p, m) == -1)
1159 return 1;
1167 if (cvt_16(p, m) == -1)
1169 return 1;
1173 if (cvt_32(p, m) == -1)
1175 return 1;
1181 if (cvt_64(p, m) == -1)
1183 return 1;
1189 p->s[sizeof(p->s) - 1] = '\0';
1190 return 1;
1194 size_t len, sz = file_pstring_length_size(ms, m);
1199 len = file_pstring_get_length(ms, m, ptr1);
1206 * is 1, 2, or 4. We need at least 1 byte for NUL
1217 return 1;
1221 if (cvt_16(p, m) == -1)
1223 return 1;
1228 if (cvt_32(p, m) == -1)
1230 return 1;
1236 if (cvt_64(p, m) == -1)
1238 return 1;
1241 if (cvt_16(p, m) == -1)
1243 return 1;
1248 if (cvt_32(p, m) == -1)
1250 return 1;
1256 if (cvt_64(p, m) == -1)
1258 return 1;
1263 if (cvt_32(p, m) == -1)
1265 return 1;
1267 if (cvt_float(p, m) == -1)
1269 return 1;
1272 if (cvt_float(p, m) == -1)
1274 return 1;
1277 if (cvt_float(p, m) == -1)
1279 return 1;
1281 if (cvt_double(p, m) == -1)
1283 return 1;
1286 if (cvt_double(p, m) == -1)
1288 return 1;
1291 if (cvt_double(p, m) == -1)
1293 return 1;
1302 return 1;
1304 file_magerror(ms, "invalid type %d in mconvert()", m->type);
1308 file_magerror(ms, "zerodivide in mconvert()");
1323 mcopy(struct magic_set *ms, union VALUETYPE *p, int type, int indir,
1337 ms->search.s = RCAST(const char *, s) + offset;
1338 ms->search.s_len = nbytes - offset;
1339 ms->search.offset = offset;
1351 ms->search.s_len = 0;
1352 ms->search.s = NULL;
1366 if (bytecnt > ms->regex_max)
1367 bytecnt = ms->regex_max;
1378 if (b < end - 1 && b[0] == '\r' && b[1] == '\n')
1380 if (b < end - 1 && b[0] == '\n')
1387 ms->search.s = buf;
1388 ms->search.s_len = last - buf;
1389 ms->search.offset = offset;
1390 ms->search.rm_len = 0;
1398 char *edst = &p->s[sizeof(p->s) - 1];
1413 *(src - 1) != '\0' :
1414 ((src + 1 < esrc) &&
1415 *(src + 1) != '\0'))
1461 do_ops(struct magic_set *ms, struct magic *m, uint32_t *rv, intmax_t lhs,
1468 if ((ms->flags & MAGIC_DEBUG) != 0)
1470 return 1;
1505 if ((ms->flags & MAGIC_DEBUG) != 0)
1507 return 1;
1514 msetoffset(struct magic_set *ms, struct magic *m, struct buffer *bb,
1524 file_error(ms, 0, "negative offset %d at continuation"
1526 return -1;
1529 if (buffer_fill(b) == -1)
1530 return -1;
1533 file_magerror(ms, "non zero offset %" SIZE_T_FORMAT
1535 return -1;
1538 return -1;
1539 buffer_init(bb, -1, NULL, b->ebuf, b->elen);
1540 ms->eoffset = ms->offset = CAST(int32_t, b->elen - m->offset);
1546 buffer_init(bb, -1, NULL, b->fbuf, b->flen);
1547 ms->offset = offset;
1548 ms->eoffset = 0;
1550 ms->offset = ms->eoffset + offset;
1553 if ((ms->flags & MAGIC_DEBUG) != 0) {
1557 bb->fbuf, bb->flen, bb->elen, ms->offset, b->fbuf,
1564 save_cont(struct magic_set *ms, struct cont *c)
1567 *c = ms->c;
1569 ms->c.li = CAST(struct level_info *, malloc(len));
1570 if (ms->c.li == NULL) {
1571 ms->c = *c;
1572 return -1;
1574 memcpy(ms->c.li, c->li, len);
1579 restore_cont(struct magic_set *ms, struct cont *c)
1581 free(ms->c.li);
1582 ms->c = *c;
1586 mget(struct magic_set *ms, struct magic *m, const struct buffer *b,
1592 uint32_t eoffset, offset = ms->offset;
1598 union VALUETYPE *p = &ms->ms_value;
1602 if (*indir_count >= ms->indir_max) {
1603 file_error(ms, 0, "indirect count (%hu) exceeded",
1605 return -1;
1608 if (*name_count >= ms->name_max) {
1609 file_error(ms, 0, "name use count (%hu) exceeded",
1611 return -1;
1615 if (mcopy(ms, p, m->type, m->flag & INDIR, s,
1616 CAST(uint32_t, offset + o), CAST(uint32_t, nbytes), m) == -1)
1617 return -1;
1619 if ((ms->flags & MAGIC_DEBUG) != 0) {
1643 if (OFFSET_OOB(nbytes, offset + off, 1))
1702 if ((ms->flags & MAGIC_DEBUG) != 0)
1706 if ((ms->flags & MAGIC_DEBUG) != 0)
1711 if (OFFSET_OOB(nbytes, offset, 1))
1713 if (do_ops(ms, m, &offset, SEXT(sgn,8,p->b), off))
1719 if (do_ops(ms, m, &offset, SEXT(sgn,16,BE16(p->hs)), off))
1725 if (do_ops(ms, m, &offset, SEXT(sgn,16,LE16(p->hs)), off))
1731 if (do_ops(ms, m, &offset, SEXT(sgn,16,p->h), off))
1740 lhs = cvt_id3(ms, CAST(uint32_t, lhs));
1741 if (do_ops(ms, m, &offset, SEXT(sgn,32,lhs), off))
1750 lhs = cvt_id3(ms, CAST(uint32_t, lhs));
1751 if (do_ops(ms, m, &offset, SEXT(sgn,32,lhs), off))
1757 if (do_ops(ms, m, &offset, SEXT(sgn,32,ME32(p->hl)), off))
1763 if (do_ops(ms, m, &offset, SEXT(sgn,32,p->l), off))
1769 if (do_ops(ms, m, &offset, SEXT(sgn,64,LE64(p->hq)), off))
1775 if (do_ops(ms, m, &offset, SEXT(sgn,64,BE64(p->hq)), off))
1781 if(do_ops(ms, m, &offset,
1786 if ((ms->flags & MAGIC_DEBUG) != 0)
1793 if ((ms->flags & MAGIC_DEBUG) != 0)
1798 offset += ms->c.li[cont_level - 1].off;
1800 if ((ms->flags & MAGIC_DEBUG) != 0)
1805 if ((ms->flags & MAGIC_DEBUG) != 0)
1808 if (mcopy(ms, p, m->type, 0, s, offset, nbytes, m) == -1)
1809 return -1;
1810 ms->offset = offset;
1812 if ((ms->flags & MAGIC_DEBUG) != 0) {
1824 if (OFFSET_OOB(nbytes, offset, 1))
1888 if ((pb = file_push_buffer(ms)) == NULL)
1889 return -1;
1897 rv = -1;
1898 for (mlp = ms->mlist[0]->next; mlp != ms->mlist[0];
1901 if ((rv = match(ms, mlp->magic, mlp->magic_rxcomp,
1909 if ((ms->flags & MAGIC_DEBUG) != 0)
1912 rbuf = file_pop_buffer(ms, pb);
1913 if (rbuf == NULL && ms->event_flags & EVENT_HAD_ERR)
1914 return -1;
1916 if (rv == 1) {
1917 if ((ms->flags & MAGIC_NODESC) == 0 &&
1918 file_printf(ms, F(ms, m->desc, "%u"), offset) == -1)
1921 return -1;
1923 if (file_printf(ms, "%s", rbuf) == -1) {
1925 return -1;
1939 if (file_magicfind(ms, rbuf, &ml) == -1) {
1940 file_error(ms, 0, "cannot find entry `%s'", rbuf);
1941 return -1;
1943 if (save_cont(ms, &c) == -1) {
1944 file_error(ms, errno, "can't allocate continuation");
1945 return -1;
1954 eoffset = ms->eoffset;
1955 rv = match(ms, ml.magic, ml.magic_rxcomp, ml.nmagic, b,
1959 ms->ms_value.q = nfound_match;
1963 restore_cont(ms, &c);
1965 if (rv != 1)
1967 ms->offset = offset;
1968 ms->eoffset = eoffset;
1972 if (ms->flags & MAGIC_NODESC)
1973 return 1;
1974 if (file_printf(ms, "%s", m->desc) == -1)
1975 return -1;
1976 return 1;
1983 if (!mconvert(ms, m, flip))
1985 return 1;
1993 * Convert the source args to unsigned here so that (1) the
2019 v = 1;
2042 v = 1;
2059 v = 1;
2079 alloc_regex(struct magic_set *ms, struct magic *m)
2085 file_error(ms, errno, "can't allocate %" SIZE_T_FORMAT
2090 rc = file_regcomp(ms, rx, m->value.s, REG_EXTENDED | REG_NEWLINE |
2100 magiccheck(struct magic_set *ms, struct magic *m, file_regex_t **m_cache)
2107 union VALUETYPE *p = &ms->ms_value;
2164 matched = 1;
2168 matched = isunordered(fl, fv) ? 1 : fv != fl;
2184 file_magerror(ms, "cannot happen with float: "
2186 return -1;
2197 matched = 1;
2201 matched = isunordered(dv, dl) ? 1 : dv != dl;
2217 file_magerror(ms, "cannot happen with double: "
2219 return -1;
2244 case FILE_SEARCH: { /* search ms->search.s for the string m->value.s */
2248 if (ms->search.s == NULL)
2254 if ((ms->flags & MAGIC_DEBUG) != 0) {
2255 size_t xlen = ms->search.s_len > 100 ? 100
2256 : ms->search.s_len;
2259 file_showstr(stderr, ms->search.s, xlen);
2260 fprintf(stderr, "%s] for [", ms->search.s_len == xlen
2268 if (m->str_range == 0 || ms->search.s_len < idx)
2269 idx = ms->search.s_len;
2270 found = CAST(const char *, memmem(ms->search.s, idx,
2272 if ((ms->flags & MAGIC_DEBUG) != 0) {
2277 v = 1;
2280 idx = found - ms->search.s;
2281 ms->search.offset += idx;
2282 ms->search.rm_len = ms->search.s_len - idx;
2288 if (slen + idx > ms->search.s_len) {
2289 v = 1;
2293 v = file_strncmp(m->value.s, ms->search.s + idx, slen,
2294 ms->search.s_len - idx, m->str_flags);
2296 ms->search.offset += idx;
2297 ms->search.rm_len = ms->search.s_len - idx;
2301 if ((ms->flags & MAGIC_DEBUG) != 0) {
2311 size_t slen = ms->search.s_len;
2314 if (ms->search.s == NULL)
2318 rx = *m_cache = alloc_regex(ms, m);
2320 return -1;
2326 file_error(ms, errno,
2329 return -1;
2331 memcpy(copy, ms->search.s, slen);
2338 rc = file_regexec(ms, rx, RCAST(const char *, search),
2339 1, &pmatch, 0);
2343 ms->search.s += CAST(int, pmatch.rm_so);
2344 ms->search.offset += CAST(size_t, pmatch.rm_so);
2345 ms->search.rm_len = CAST(size_t,
2351 v = 1;
2355 return -1;
2360 return ms->ms_value.q != 0;
2363 return 1;
2365 matched = der_cmp(ms, m);
2366 if (matched == -1) {
2367 if ((ms->flags & MAGIC_DEBUG) != 0) {
2379 file_magerror(ms, "invalid type %d in magiccheck()", m->type);
2380 return -1;
2383 v = file_signextend(ms, m, v);
2387 if ((ms->flags & MAGIC_DEBUG) != 0)
2389 "u == *any* = 1", CAST(unsigned long long, v));
2390 matched = 1;
2395 if ((ms->flags & MAGIC_DEBUG) != 0)
2404 if ((ms->flags & MAGIC_DEBUG) != 0)
2414 if ((ms->flags & MAGIC_DEBUG) != 0)
2422 if ((ms->flags & MAGIC_DEBUG) != 0)
2433 if ((ms->flags & MAGIC_DEBUG) != 0)
2441 if ((ms->flags & MAGIC_DEBUG) != 0)
2451 if ((ms->flags & MAGIC_DEBUG) != 0)
2462 if ((ms->flags & MAGIC_DEBUG) != 0)
2471 file_magerror(ms, "cannot happen: invalid relation `%c'",
2473 return -1;
2475 if ((ms->flags & MAGIC_DEBUG) != 0) {
2477 file_magic_strength(m, 1));
2484 handle_annotation(struct magic_set *ms, struct magic *m, int firstline)
2486 if ((ms->flags & MAGIC_APPLE) && m->apple[0]) {
2487 if (print_sep(ms, firstline) == -1)
2488 return -1;
2489 if (file_printf(ms, "%.8s", m->apple) == -1)
2490 return -1;
2491 return 1;
2493 if ((ms->flags & MAGIC_EXTENSION) && m->ext[0]) {
2494 if (print_sep(ms, firstline) == -1)
2495 return -1;
2496 if (file_printf(ms, "%s", m->ext) == -1)
2497 return -1;
2498 return 1;
2500 if ((ms->flags & MAGIC_MIME_TYPE) && m->mimetype[0]) {
2503 if (print_sep(ms, firstline) == -1)
2504 return -1;
2505 if (varexpand(ms, buf, sizeof(buf), m->mimetype) == -1)
2509 if (file_printf(ms, "%s", p) == -1)
2510 return -1;
2511 return 1;
2517 print_sep(struct magic_set *ms, int firstline)
2525 return file_separator(ms);