![[BACK]](/icons/back.gif){kind=icon}
Return to magic-load.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / file|
Return to magic-load.c CVS log | Up to [local] / src / usr.bin / file |
1.2 ! nicm 1: /* $OpenBSD: magic-load.c,v 1.1 2015/04/24 16:24:11 nicm Exp $ */
1.1 nicm 2:
3: /*
4: * Copyright (c) 2015 Nicholas Marriott <nicm@openbsd.org>
5: *
6: * Permission to use, copy, modify, and distribute this software for any
7: * purpose with or without fee is hereby granted, provided that the above
8: * copyright notice and this permission notice appear in all copies.
9: *
10: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14: * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
15: * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
16: * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17: */
18:
19: #include <sys/types.h>
20:
21: #include <ctype.h>
22: #include <errno.h>
23: #include <limits.h>
24: #include <regex.h>
25: #include <stdarg.h>
26: #include <stdio.h>
27: #include <stdlib.h>
28: #include <string.h>
29:
30: #include "magic.h"
31: #include "xmalloc.h"
32:
33: static int
34: magic_odigit(u_char c)
35: {
36: if (c >= '0' && c <= '7')
37: return (c - '0');
38: return (-1);
39: }
40:
41: static int
42: magic_xdigit(u_char c)
43: {
44: if (c >= '0' && c <= '9')
45: return (c - '0');
46: if (c >= 'a' && c <= 'f')
47: return (10 + c - 'a');
48: if (c >= 'A' && c <= 'F')
49: return (10 + c - 'A');
50: return (-1);
51: }
52:
53: static void
54: magic_mark_text(struct magic_line *ml, int text)
55: {
56: do {
57: ml->text = text;
58: ml = ml->parent;
59: } while (ml != NULL);
60: }
61:
62: static int
63: magic_make_pattern(struct magic_line *ml, const char *name, regex_t *re,
64: const char *p)
65: {
66: int error;
67: char errbuf[256];
68:
69: error = regcomp(re, p, REG_EXTENDED|REG_NOSUB);
70: if (error != 0) {
71: regerror(error, re, errbuf, sizeof errbuf);
72: magic_warn(ml, "bad %s pattern: %s", name, errbuf);
73: return (-1);
74: }
75: return (0);
76: }
77:
78: static int
79: magic_set_result(struct magic_line *ml, const char *s)
80: {
81: const char *fmt;
82: const char *endfmt;
83: const char *cp;
84: regex_t *re = NULL;
85: regmatch_t pmatch;
86: size_t fmtlen;
87:
88: while (isspace((u_char)*s))
89: s++;
90: if (*s == '\0') {
91: ml->result = NULL;
92: return (0);
93: }
94: ml->result = xstrdup(s);
95:
96: fmt = NULL;
97: for (cp = s; *cp != '\0'; cp++) {
98: if (cp[0] == '%' && cp[1] != '%') {
99: if (fmt != NULL) {
100: magic_warn(ml, "multiple formats");
101: return (-1);
102: }
103: fmt = cp;
104: }
105: }
106: if (fmt == NULL)
107: return (0);
108: fmt++;
109:
110: for (endfmt = fmt; *endfmt != '\0'; endfmt++) {
111: if (strchr("diouxXeEfFgGsc", *endfmt) != NULL)
112: break;
113: }
114: if (*endfmt == '\0') {
115: magic_warn(ml, "unterminated format");
116: return (-1);
117: }
118: fmtlen = endfmt + 1 - fmt;
119: if (fmtlen > 32) {
120: magic_warn(ml, "format too long");
121: return (-1);
122: }
123:
124: if (*endfmt == 's') {
125: switch (ml->type) {
126: case MAGIC_TYPE_DATE:
127: case MAGIC_TYPE_LDATE:
128: case MAGIC_TYPE_UDATE:
129: case MAGIC_TYPE_ULDATE:
130: case MAGIC_TYPE_BEDATE:
131: case MAGIC_TYPE_BELDATE:
132: case MAGIC_TYPE_UBEDATE:
133: case MAGIC_TYPE_UBELDATE:
134: case MAGIC_TYPE_QDATE:
135: case MAGIC_TYPE_QLDATE:
136: case MAGIC_TYPE_UQDATE:
137: case MAGIC_TYPE_UQLDATE:
138: case MAGIC_TYPE_BEQDATE:
139: case MAGIC_TYPE_BEQLDATE:
140: case MAGIC_TYPE_UBEQDATE:
141: case MAGIC_TYPE_UBEQLDATE:
142: case MAGIC_TYPE_LEQDATE:
143: case MAGIC_TYPE_LEQLDATE:
144: case MAGIC_TYPE_ULEQDATE:
145: case MAGIC_TYPE_ULEQLDATE:
146: case MAGIC_TYPE_LEDATE:
147: case MAGIC_TYPE_LELDATE:
148: case MAGIC_TYPE_ULEDATE:
149: case MAGIC_TYPE_ULELDATE:
150: case MAGIC_TYPE_MEDATE:
151: case MAGIC_TYPE_MELDATE:
152: case MAGIC_TYPE_STRING:
153: case MAGIC_TYPE_PSTRING:
154: case MAGIC_TYPE_BESTRING16:
155: case MAGIC_TYPE_LESTRING16:
156: case MAGIC_TYPE_REGEX:
157: case MAGIC_TYPE_SEARCH:
158: break;
159: default:
160: ml->stringify = 1;
161: break;
162: }
163: }
164:
165: if (!ml->root->compiled) {
166: /*
167: * XXX %ld (and %lu and so on) is invalid on 64-bit platforms
168: * with byte, short, long. We get lucky because our first and
169: * only argument ends up in a register. Accept it for now.
170: */
171: if (magic_make_pattern(ml, "short", &ml->root->format_short,
172: "^-?[0-9]*(\\.[0-9]*)?(c|(l|h|hh)?[iduxX])$") != 0)
173: return (-1);
174: if (magic_make_pattern(ml, "long", &ml->root->format_long,
175: "^-?[0-9]*(\\.[0-9]*)?(c|(l|h|hh)?[iduxX])$") != 0)
176: return (-1);
177: if (magic_make_pattern(ml, "quad", &ml->root->format_quad,
178: "^-?[0-9]*(\\.[0-9]*)?ll[iduxX]$") != 0)
179: return (-1);
180: if (magic_make_pattern(ml, "float", &ml->root->format_float,
181: "^-?[0-9]*(\\.[0-9]*)?[eEfFgG]$") != 0)
182: return (-1);
183: if (magic_make_pattern(ml, "string", &ml->root->format_string,
184: "^-?[0-9]*(\\.[0-9]*)?s$") != 0)
185: return (-1);
186: ml->root->compiled = 1;
187: }
188:
189: if (ml->stringify)
190: re = &ml->root->format_string;
191: else {
192: switch (ml->type) {
193: case MAGIC_TYPE_NONE:
194: case MAGIC_TYPE_DEFAULT:
195: return (0); /* don't use result */
196: case MAGIC_TYPE_BYTE:
197: case MAGIC_TYPE_UBYTE:
198: case MAGIC_TYPE_SHORT:
199: case MAGIC_TYPE_USHORT:
200: case MAGIC_TYPE_BESHORT:
201: case MAGIC_TYPE_UBESHORT:
202: case MAGIC_TYPE_LESHORT:
203: case MAGIC_TYPE_ULESHORT:
204: re = &ml->root->format_short;
205: break;
206: case MAGIC_TYPE_LONG:
207: case MAGIC_TYPE_ULONG:
208: case MAGIC_TYPE_BELONG:
209: case MAGIC_TYPE_UBELONG:
210: case MAGIC_TYPE_LELONG:
211: case MAGIC_TYPE_ULELONG:
212: case MAGIC_TYPE_MELONG:
213: re = &ml->root->format_long;
214: break;
215: case MAGIC_TYPE_QUAD:
216: case MAGIC_TYPE_UQUAD:
217: case MAGIC_TYPE_BEQUAD:
218: case MAGIC_TYPE_UBEQUAD:
219: case MAGIC_TYPE_LEQUAD:
220: case MAGIC_TYPE_ULEQUAD:
221: re = &ml->root->format_quad;
222: break;
223: case MAGIC_TYPE_FLOAT:
224: case MAGIC_TYPE_BEFLOAT:
225: case MAGIC_TYPE_LEFLOAT:
226: case MAGIC_TYPE_DOUBLE:
227: case MAGIC_TYPE_BEDOUBLE:
228: case MAGIC_TYPE_LEDOUBLE:
229: re = &ml->root->format_float;
230: break;
231: case MAGIC_TYPE_DATE:
232: case MAGIC_TYPE_LDATE:
233: case MAGIC_TYPE_UDATE:
234: case MAGIC_TYPE_ULDATE:
235: case MAGIC_TYPE_BEDATE:
236: case MAGIC_TYPE_BELDATE:
237: case MAGIC_TYPE_UBEDATE:
238: case MAGIC_TYPE_UBELDATE:
239: case MAGIC_TYPE_QDATE:
240: case MAGIC_TYPE_QLDATE:
241: case MAGIC_TYPE_UQDATE:
242: case MAGIC_TYPE_UQLDATE:
243: case MAGIC_TYPE_BEQDATE:
244: case MAGIC_TYPE_BEQLDATE:
245: case MAGIC_TYPE_UBEQDATE:
246: case MAGIC_TYPE_UBEQLDATE:
247: case MAGIC_TYPE_LEQDATE:
248: case MAGIC_TYPE_LEQLDATE:
249: case MAGIC_TYPE_ULEQDATE:
250: case MAGIC_TYPE_ULEQLDATE:
251: case MAGIC_TYPE_LEDATE:
252: case MAGIC_TYPE_LELDATE:
253: case MAGIC_TYPE_ULEDATE:
254: case MAGIC_TYPE_ULELDATE:
255: case MAGIC_TYPE_MEDATE:
256: case MAGIC_TYPE_MELDATE:
257: case MAGIC_TYPE_STRING:
258: case MAGIC_TYPE_PSTRING:
259: case MAGIC_TYPE_REGEX:
260: case MAGIC_TYPE_SEARCH:
261: re = &ml->root->format_string;
262: break;
263: case MAGIC_TYPE_BESTRING16:
264: case MAGIC_TYPE_LESTRING16:
265: magic_warn(ml, "unsupported type %s", ml->type_string);
266: return (-1);
267: }
268: }
269:
270: pmatch.rm_so = 0;
271: pmatch.rm_eo = fmtlen;
272: if (regexec(re, fmt, 1, &pmatch, REG_STARTEND) != 0) {
273: magic_warn(ml, "bad format for %s: %%%.*s", ml->type_string,
274: (int)fmtlen, fmt);
275: return (-1);
276: }
277:
278: return (0);
279: }
280:
281: static u_int
282: magic_get_strength(struct magic_line *ml)
283: {
284: int n;
285: size_t size;
286:
287: if (ml->test_not || ml->test_operator == 'x')
288: return (1);
289:
290: n = 20;
291: switch (ml->type) {
292: case MAGIC_TYPE_NONE:
293: case MAGIC_TYPE_DEFAULT:
294: return (0);
295: case MAGIC_TYPE_BYTE:
296: case MAGIC_TYPE_UBYTE:
297: n += 1 * MAGIC_STRENGTH_MULTIPLIER;
298: break;
299: case MAGIC_TYPE_SHORT:
300: case MAGIC_TYPE_USHORT:
301: case MAGIC_TYPE_BESHORT:
302: case MAGIC_TYPE_UBESHORT:
303: case MAGIC_TYPE_LESHORT:
304: case MAGIC_TYPE_ULESHORT:
305: n += 2 * MAGIC_STRENGTH_MULTIPLIER;
306: break;
307: case MAGIC_TYPE_LONG:
308: case MAGIC_TYPE_ULONG:
309: case MAGIC_TYPE_FLOAT:
310: case MAGIC_TYPE_DATE:
311: case MAGIC_TYPE_LDATE:
312: case MAGIC_TYPE_UDATE:
313: case MAGIC_TYPE_ULDATE:
314: case MAGIC_TYPE_BELONG:
315: case MAGIC_TYPE_UBELONG:
316: case MAGIC_TYPE_BEFLOAT:
317: case MAGIC_TYPE_BEDATE:
318: case MAGIC_TYPE_BELDATE:
319: case MAGIC_TYPE_UBEDATE:
320: case MAGIC_TYPE_UBELDATE:
321: n += 4 * MAGIC_STRENGTH_MULTIPLIER;
322: break;
323: case MAGIC_TYPE_QUAD:
324: case MAGIC_TYPE_UQUAD:
325: case MAGIC_TYPE_DOUBLE:
326: case MAGIC_TYPE_QDATE:
327: case MAGIC_TYPE_QLDATE:
328: case MAGIC_TYPE_UQDATE:
329: case MAGIC_TYPE_UQLDATE:
330: case MAGIC_TYPE_BEQUAD:
331: case MAGIC_TYPE_UBEQUAD:
332: case MAGIC_TYPE_BEDOUBLE:
333: case MAGIC_TYPE_BEQDATE:
334: case MAGIC_TYPE_BEQLDATE:
335: case MAGIC_TYPE_UBEQDATE:
336: case MAGIC_TYPE_UBEQLDATE:
337: case MAGIC_TYPE_LEQUAD:
338: case MAGIC_TYPE_ULEQUAD:
339: case MAGIC_TYPE_LEDOUBLE:
340: case MAGIC_TYPE_LEQDATE:
341: case MAGIC_TYPE_LEQLDATE:
342: case MAGIC_TYPE_ULEQDATE:
343: case MAGIC_TYPE_ULEQLDATE:
344: case MAGIC_TYPE_LELONG:
345: case MAGIC_TYPE_ULELONG:
346: case MAGIC_TYPE_LEFLOAT:
347: case MAGIC_TYPE_LEDATE:
348: case MAGIC_TYPE_LELDATE:
349: case MAGIC_TYPE_ULEDATE:
350: case MAGIC_TYPE_ULELDATE:
351: case MAGIC_TYPE_MELONG:
352: case MAGIC_TYPE_MEDATE:
353: case MAGIC_TYPE_MELDATE:
354: n += 8 * MAGIC_STRENGTH_MULTIPLIER;
355: break;
356: case MAGIC_TYPE_STRING:
357: case MAGIC_TYPE_PSTRING:
358: n += ml->test_string_size * MAGIC_STRENGTH_MULTIPLIER;
359: break;
360: case MAGIC_TYPE_BESTRING16:
361: case MAGIC_TYPE_LESTRING16:
362: n += ml->test_string_size * MAGIC_STRENGTH_MULTIPLIER / 2;
363: break;
364: case MAGIC_TYPE_REGEX:
365: case MAGIC_TYPE_SEARCH:
366: size = MAGIC_STRENGTH_MULTIPLIER / ml->test_string_size;
367: if (size < 1)
368: size = 1;
369: n += ml->test_string_size * size;
370: break;
371: }
372: switch (ml->test_operator) {
373: case '=':
374: n += MAGIC_STRENGTH_MULTIPLIER;
375: break;
376: case '<':
377: case '>':
378: case '[':
379: case ']':
380: n -= 2 * MAGIC_STRENGTH_MULTIPLIER;
381: break;
382: case '^':
383: case '&':
384: n -= MAGIC_STRENGTH_MULTIPLIER;
385: break;
386: }
387: return (n <= 0 ? 1 : n);
388: }
389:
390: static int
391: magic_get_string(char **line, char *out, size_t *outlen)
392: {
393: char *start, *cp, c;
394: int d0, d1, d2;
395:
396: start = out;
397: for (cp = *line; *cp != '\0' && !isspace((u_char)*cp); cp++) {
398: if (*cp != '\\') {
399: *out++ = *cp;
400: continue;
401: }
402:
403: switch (c = *++cp) {
404: case ' ':
405: *out++ = ' ';
406: break;
407: case '0':
408: case '1':
409: case '2':
410: case '3':
411: case '4':
412: case '5':
413: case '6':
414: case '7':
415: d0 = magic_odigit(cp[0]);
416: if (cp[0] != '\0')
417: d1 = magic_odigit(cp[1]);
418: else
419: d1 = -1;
420: if (cp[0] != '\0' && cp[1] != '\0')
421: d2 = magic_odigit(cp[2]);
422: else
423: d2 = -1;
424:
425: if (d0 != -1 && d1 != -1 && d2 != -1) {
426: *out = d2 | (d1 << 3) | (d0 << 6);
427: cp += 2;
428: } else if (d0 != -1 && d1 != -1) {
429: *out = d1 | (d0 << 3);
430: cp++;
431: } else if (d0 != -1)
432: *out = d0;
433: else
434: return (-1);
435: out++;
436: break;
437: case 'x':
438: d0 = magic_xdigit(cp[1]);
439: if (cp[1] != '\0')
440: d1 = magic_xdigit(cp[2]);
441: else
442: d1 = -1;
443:
444: if (d0 != -1 && d1 != -1) {
445: *out = d1 | (d0 << 4);
446: cp += 2;
447: } else if (d0 != -1) {
448: *out = d0;
449: cp++;
450: } else
451: return (-1);
452: out++;
453:
454: break;
455: case 'a':
456: *out++ = '\a';
457: break;
458: case 'b':
459: *out++ = '\b';
460: break;
461: case 't':
462: *out++ = '\t';
463: break;
464: case 'f':
465: *out++ = '\f';
466: break;
467: case 'n':
468: *out++ = '\n';
469: break;
470: case 'r':
471: *out++ = '\r';
472: break;
473: case '\\':
474: *out++ = '\\';
475: break;
476: case '\'':
477: *out++ = '\'';
478: break;
479: case '\"':
480: *out++ = '\"';
481: break;
482: default:
483: *out++ = c;
484: break;
485: }
486: }
487: *out = '\0';
488: *outlen = out - start;
489:
490: *line = cp;
491: return (0);
492: }
493:
494: static int
495: magic_parse_offset(struct magic_line *ml, char **line)
496: {
497: char *copy, *s, *cp, *endptr;
498:
499: while (isspace((u_char)**line))
500: (*line)++;
501: copy = s = cp = xmalloc(strlen(*line) + 1);
502: while (**line != '\0' && !isspace((u_char)**line))
503: *cp++ = *(*line)++;
504: *cp = '\0';
505:
506: ml->offset = 0;
507: ml->offset_relative = 0;
508:
509: ml->indirect_type = ' ';
510: ml->indirect_relative = 0;
511: ml->indirect_offset = 0;
512: ml->indirect_operator = ' ';
513: ml->indirect_operand = 0;
514:
515: if (*s == '&') {
516: ml->offset_relative = 1;
517: s++;
518: }
519:
520: if (*s != '(') {
521: endptr = magic_strtoll(s, &ml->offset);
522: if (endptr == NULL || *endptr != '\0') {
523: magic_warn(ml, "missing closing bracket");
524: goto fail;
525: }
526: if (ml->offset < 0 && !ml->offset_relative) {
527: magic_warn(ml, "negative absolute offset");
528: goto fail;
529: }
530: goto done;
531: }
532: s++;
533:
534: if (*s == '&') {
535: ml->indirect_relative = 1;
536: s++;
537: }
538:
539: endptr = magic_strtoll(s, &ml->indirect_offset);
540: if (endptr == NULL) {
541: magic_warn(ml, "can't parse offset");
542: goto fail;
543: }
544: s = endptr;
545: if (*s == ')')
546: goto done;
547:
548: if (*s == '.') {
549: s++;
550: if (strchr("bslBSL", *s) == NULL) {
551: magic_warn(ml, "unknown offset type");
552: goto fail;
553: }
554: ml->indirect_type = *s;
555: s++;
556: if (*s == ')')
557: goto done;
558: }
559:
560: if (strchr("+-*", *s) == NULL) {
561: magic_warn(ml, "unknown offset operator");
562: goto fail;
563: }
564: ml->indirect_operator = *s;
565: s++;
566: if (*s == ')')
567: goto done;
568:
569: if (*s == '(') {
570: s++;
571: endptr = magic_strtoll(s, &ml->indirect_operand);
572: if (endptr == NULL || *endptr != ')') {
573: magic_warn(ml, "missing closing bracket");
574: goto fail;
575: }
576: if (*++endptr != ')') {
577: magic_warn(ml, "missing closing bracket");
578: goto fail;
579: }
580: } else {
581: endptr = magic_strtoll(s, &ml->indirect_operand);
582: if (endptr == NULL || *endptr != ')') {
583: magic_warn(ml, "missing closing bracket");
584: goto fail;
585: }
586: }
587:
588: done:
589: free(copy);
590: return (0);
591:
592: fail:
593: free(copy);
594: return (-1);
595: }
596:
597: static int
598: magic_parse_type(struct magic_line *ml, char **line)
599: {
600: char *copy, *s, *cp, *endptr;
601:
602: while (isspace((u_char)**line))
603: (*line)++;
604: copy = s = cp = xmalloc(strlen(*line) + 1);
605: while (**line != '\0' && !isspace((u_char)**line))
606: *cp++ = *(*line)++;
607: *cp = '\0';
608:
609: ml->type = MAGIC_TYPE_NONE;
610: ml->type_string = xstrdup(s);
611:
612: ml->type_operator = ' ';
613: ml->type_operand = 0;
614:
615: if (strncmp(s, "string", (sizeof "string") - 1) == 0) {
616: ml->type = MAGIC_TYPE_STRING;
617: magic_mark_text(ml, 0);
618: goto done;
619: }
620: if (strncmp(s, "search", (sizeof "search") - 1) == 0) {
621: ml->type = MAGIC_TYPE_SEARCH;
622: goto done;
623: }
624: if (strncmp(s, "regex", (sizeof "regex") - 1) == 0) {
625: ml->type = MAGIC_TYPE_REGEX;
626: goto done;
627: }
628:
629: cp = &s[strcspn(s, "-&")];
630: if (*cp != '\0') {
631: ml->type_operator = *cp;
632: endptr = magic_strtoull(cp + 1, &ml->type_operand);
633: if (endptr == NULL || *endptr != '\0') {
634: magic_warn(ml, "can't parse operand");
635: goto fail;
636: }
637: *cp = '\0';
638: }
639:
640: if (strcmp(s, "byte") == 0)
641: ml->type = MAGIC_TYPE_BYTE;
642: else if (strcmp(s, "short") == 0)
643: ml->type = MAGIC_TYPE_SHORT;
644: else if (strcmp(s, "long") == 0)
645: ml->type = MAGIC_TYPE_LONG;
646: else if (strcmp(s, "quad") == 0)
647: ml->type = MAGIC_TYPE_QUAD;
648: else if (strcmp(s, "ubyte") == 0)
649: ml->type = MAGIC_TYPE_UBYTE;
650: else if (strcmp(s, "ushort") == 0)
651: ml->type = MAGIC_TYPE_USHORT;
652: else if (strcmp(s, "ulong") == 0)
653: ml->type = MAGIC_TYPE_ULONG;
654: else if (strcmp(s, "uquad") == 0)
655: ml->type = MAGIC_TYPE_UQUAD;
656: else if (strcmp(s, "float") == 0)
657: ml->type = MAGIC_TYPE_FLOAT;
658: else if (strcmp(s, "double") == 0)
659: ml->type = MAGIC_TYPE_DOUBLE;
660: else if (strcmp(s, "pstring") == 0)
661: ml->type = MAGIC_TYPE_PSTRING;
662: else if (strcmp(s, "date") == 0)
663: ml->type = MAGIC_TYPE_DATE;
664: else if (strcmp(s, "qdate") == 0)
665: ml->type = MAGIC_TYPE_QDATE;
666: else if (strcmp(s, "ldate") == 0)
667: ml->type = MAGIC_TYPE_LDATE;
668: else if (strcmp(s, "qldate") == 0)
669: ml->type = MAGIC_TYPE_QLDATE;
670: else if (strcmp(s, "udate") == 0)
671: ml->type = MAGIC_TYPE_UDATE;
672: else if (strcmp(s, "uqdate") == 0)
673: ml->type = MAGIC_TYPE_UQDATE;
674: else if (strcmp(s, "uldate") == 0)
675: ml->type = MAGIC_TYPE_ULDATE;
676: else if (strcmp(s, "uqldate") == 0)
677: ml->type = MAGIC_TYPE_UQLDATE;
678: else if (strcmp(s, "beshort") == 0)
679: ml->type = MAGIC_TYPE_BESHORT;
680: else if (strcmp(s, "belong") == 0)
681: ml->type = MAGIC_TYPE_BELONG;
682: else if (strcmp(s, "bequad") == 0)
683: ml->type = MAGIC_TYPE_BEQUAD;
684: else if (strcmp(s, "ubeshort") == 0)
685: ml->type = MAGIC_TYPE_UBESHORT;
686: else if (strcmp(s, "ubelong") == 0)
687: ml->type = MAGIC_TYPE_UBELONG;
688: else if (strcmp(s, "ubequad") == 0)
689: ml->type = MAGIC_TYPE_UBEQUAD;
690: else if (strcmp(s, "befloat") == 0)
691: ml->type = MAGIC_TYPE_BEFLOAT;
692: else if (strcmp(s, "bedouble") == 0)
693: ml->type = MAGIC_TYPE_BEDOUBLE;
694: else if (strcmp(s, "bedate") == 0)
695: ml->type = MAGIC_TYPE_BEDATE;
696: else if (strcmp(s, "beqdate") == 0)
697: ml->type = MAGIC_TYPE_BEQDATE;
698: else if (strcmp(s, "beldate") == 0)
699: ml->type = MAGIC_TYPE_BELDATE;
700: else if (strcmp(s, "beqldate") == 0)
701: ml->type = MAGIC_TYPE_BEQLDATE;
702: else if (strcmp(s, "ubedate") == 0)
703: ml->type = MAGIC_TYPE_UBEDATE;
704: else if (strcmp(s, "ubeqdate") == 0)
705: ml->type = MAGIC_TYPE_UBEQDATE;
706: else if (strcmp(s, "ubeldate") == 0)
707: ml->type = MAGIC_TYPE_UBELDATE;
708: else if (strcmp(s, "ubeqldate") == 0)
709: ml->type = MAGIC_TYPE_UBEQLDATE;
710: else if (strcmp(s, "bestring16") == 0)
711: ml->type = MAGIC_TYPE_BESTRING16;
712: else if (strcmp(s, "leshort") == 0)
713: ml->type = MAGIC_TYPE_LESHORT;
714: else if (strcmp(s, "lelong") == 0)
715: ml->type = MAGIC_TYPE_LELONG;
716: else if (strcmp(s, "lequad") == 0)
717: ml->type = MAGIC_TYPE_LEQUAD;
718: else if (strcmp(s, "uleshort") == 0)
719: ml->type = MAGIC_TYPE_ULESHORT;
720: else if (strcmp(s, "ulelong") == 0)
721: ml->type = MAGIC_TYPE_ULELONG;
722: else if (strcmp(s, "ulequad") == 0)
723: ml->type = MAGIC_TYPE_ULEQUAD;
724: else if (strcmp(s, "lefloat") == 0)
725: ml->type = MAGIC_TYPE_LEFLOAT;
726: else if (strcmp(s, "ledouble") == 0)
727: ml->type = MAGIC_TYPE_LEDOUBLE;
728: else if (strcmp(s, "ledate") == 0)
729: ml->type = MAGIC_TYPE_LEDATE;
730: else if (strcmp(s, "leqdate") == 0)
731: ml->type = MAGIC_TYPE_LEQDATE;
732: else if (strcmp(s, "leldate") == 0)
733: ml->type = MAGIC_TYPE_LELDATE;
734: else if (strcmp(s, "leqldate") == 0)
735: ml->type = MAGIC_TYPE_LEQLDATE;
736: else if (strcmp(s, "uledate") == 0)
737: ml->type = MAGIC_TYPE_ULEDATE;
738: else if (strcmp(s, "uleqdate") == 0)
739: ml->type = MAGIC_TYPE_ULEQDATE;
740: else if (strcmp(s, "uleldate") == 0)
741: ml->type = MAGIC_TYPE_ULELDATE;
742: else if (strcmp(s, "uleqldate") == 0)
743: ml->type = MAGIC_TYPE_ULEQLDATE;
744: else if (strcmp(s, "lestring16") == 0)
745: ml->type = MAGIC_TYPE_LESTRING16;
746: else if (strcmp(s, "melong") == 0)
747: ml->type = MAGIC_TYPE_MELONG;
748: else if (strcmp(s, "medate") == 0)
749: ml->type = MAGIC_TYPE_MEDATE;
750: else if (strcmp(s, "meldate") == 0)
751: ml->type = MAGIC_TYPE_MELDATE;
752: else if (strcmp(s, "default") == 0)
753: ml->type = MAGIC_TYPE_DEFAULT;
754: else {
755: magic_warn(ml, "unknown type");
756: goto fail;
757: }
758: magic_mark_text(ml, 0);
759:
760: done:
761: free(copy);
762: return (0);
763:
764: fail:
765: free(copy);
766: return (-1);
767: }
768:
769: static int
770: magic_parse_value(struct magic_line *ml, char **line)
771: {
772: char *copy, *s, *cp, *endptr;
773: size_t slen;
774:
775: while (isspace((u_char)**line))
776: (*line)++;
777:
778: ml->test_operator = '=';
779: ml->test_not = 0;
780: ml->test_string = NULL;
781: ml->test_string_size = 0;
782: ml->test_unsigned = 0;
783: ml->test_signed = 0;
784:
785: s = *line;
786: if (s[0] == 'x' && (s[1] == '\0' || isspace((u_char)s[1]))) {
787: (*line)++;
788: ml->test_operator = 'x';
789: return (0);
790: }
791:
792: if (**line == '!') {
793: ml->test_not = 1;
794: (*line)++;
795: }
796:
797: switch (ml->type) {
798: case MAGIC_TYPE_STRING:
799: case MAGIC_TYPE_PSTRING:
800: case MAGIC_TYPE_SEARCH:
801: if (**line == '>' || **line == '<' || **line == '=') {
802: ml->test_operator = **line;
803: (*line)++;
804: }
805: /* FALLTHROUGH */
806: case MAGIC_TYPE_REGEX:
807: copy = s = xmalloc(strlen(*line) + 1);
808: if (magic_get_string(line, s, &slen) != 0) {
809: magic_warn(ml, "can't parse string");
810: goto fail;
811: }
812: ml->test_string_size = slen;
813: ml->test_string = s;
814: return (0); /* do not free */
815: default:
816: break;
817: }
818:
819: copy = s = cp = xmalloc(strlen(*line) + 1);
820: if ((*line)[0] == '=' && (*line)[1] == ' ') {
821: /*
822: * Extra spaces such as "byte&7 = 0" are accepted, which is
823: * annoying. But it seems to be only for =, so special case it.
824: */
825: *cp++ = '=';
826: (*line) += 2;
827: }
828: while (**line != '\0' && !isspace((u_char)**line))
829: *cp++ = *(*line)++;
830: *cp = '\0';
831:
832: if (*s == '\0')
833: goto done;
834:
835: if (s[0] == '<' && s[1] == '=') {
836: ml->test_operator = '[';
837: s += 2;
838: } else if (s[0] == '>' && s[1] == '=') {
839: ml->test_operator = ']';
840: s += 2;
841: } else if (strchr("=<>&^", *s) != NULL) {
842: ml->test_operator = *s;
843: s++;
844: }
845:
846: if (*ml->type_string == 'u')
847: endptr = magic_strtoull(s, &ml->test_unsigned);
848: else
849: endptr = magic_strtoll(s, &ml->test_signed);
850: if (endptr == NULL || *endptr != '\0') {
851: magic_warn(ml, "can't parse number");
852: goto fail;
853: }
854:
855: done:
856: free(copy);
857: return (0);
858:
859: fail:
860: free(copy);
861: return (-1);
862: }
863:
864: static void
865: magic_free_line(struct magic_line *ml)
866: {
1.2 ! nicm 867: free((void *)ml->type_string);
1.1 nicm 868:
1.2 ! nicm 869: free((void *)ml->mimetype);
! 870: free((void *)ml->result);
1.1 nicm 871:
872: free(ml);
873: }
874:
875: int
876: magic_compare(struct magic_line *ml1, struct magic_line *ml2)
877: {
878: if (ml1->strength < ml2->strength)
879: return (1);
880: if (ml1->strength > ml2->strength)
881: return (-1);
882:
883: /*
884: * The original file depends on the (undefined!) qsort(3) behaviour
885: * when the strength is equal. This is impossible to reproduce with an
886: * RB tree so just use the line number and hope for the best.
887: */
888: if (ml1->line < ml2->line)
889: return (-1);
890: if (ml1->line > ml2->line)
891: return (1);
892:
893: return (0);
894: }
895: RB_GENERATE(magic_tree, magic_line, node, magic_compare);
896:
897: static void
898: magic_set_mimetype(struct magic *m, u_int at, struct magic_line *ml, char *line)
899: {
900: char *mimetype, *cp;
901:
902: mimetype = line + (sizeof "!:mime") - 1;
903: while (isspace((u_char)*mimetype))
904: mimetype++;
905:
906: cp = strchr(mimetype, '#');
907: if (cp != NULL)
908: *cp = '\0';
909:
910: if (*mimetype != '\0') {
911: cp = mimetype + strlen(mimetype) - 1;
912: while (cp != mimetype && isspace((u_char)*cp))
913: *cp-- = '\0';
914: }
915:
916: cp = mimetype;
917: while (*cp != '\0') {
918: if (!isalnum((u_char)*cp) && strchr("/-.+", *cp) == NULL)
919: break;
920: cp++;
921: }
922: if (*mimetype == '\0' || *cp != '\0') {
923: fprintf(stderr, "%s:%u: invalid MIME type: %s\n", m->path, at,
924: mimetype);
925: return;
926: }
927: if (ml == NULL) {
928: fprintf(stderr, "%s:%u: stray MIME type: %s\n", m->path, at,
929: mimetype);
930: return;
931: }
932: ml->mimetype = xstrdup(mimetype);
933: }
934:
935: struct magic *
936: magic_load(FILE *f, const char *path, int warnings)
937: {
938: struct magic *m;
939: struct magic_line *ml = NULL, *parent, *parent0;
940: char *line, *tmp;
941: size_t size;
942: u_int at, level, n, i;
943:
944: m = xcalloc(1, sizeof *m);
945: m->path = xstrdup(path);
946: m->warnings = warnings;
947: RB_INIT(&m->tree);
948:
949: parent = NULL;
950: parent0 = NULL;
951: level = 0;
952:
953: at = 0;
954: tmp = NULL;
955: while ((line = fgetln(f, &size))) {
956: if (line[size - 1] == '\n')
957: line[size - 1] = '\0';
958: else {
959: tmp = xmalloc(size + 1);
960: memcpy(tmp, line, size);
961: tmp[size] = '\0';
962: line = tmp;
963: }
964: at++;
965:
966: while (isspace((u_char)*line))
967: line++;
968: if (*line == '\0' || *line == '#')
969: continue;
970:
971: if (strncmp (line, "!:mime", (sizeof "!:mime") - 1) == 0) {
972: magic_set_mimetype(m, at, ml, line);
973: continue;
974: }
975:
976: n = 0;
977: for (; *line == '>'; line++)
978: n++;
979:
980: ml = xcalloc(1, sizeof *ml);
981: ml->root = m;
982: ml->line = at;
983: ml->type = MAGIC_TYPE_NONE;
984: TAILQ_INIT(&ml->children);
985: ml->text = 1;
986:
987: if (n == level + 1) {
988: parent = parent0;
989: } else if (n < level) {
990: for (i = n; i < level && parent != NULL; i++)
991: parent = parent->parent;
992: } else if (n != level) {
993: magic_warn(ml, "level skipped (%u->%u)", level, n);
994: free(ml);
995: continue;
996: }
997: ml->parent = parent;
998: level = n;
999:
1000: if (magic_parse_offset(ml, &line) != 0 ||
1001: magic_parse_type(ml, &line) != 0 ||
1002: magic_parse_value(ml, &line) != 0 ||
1003: magic_set_result(ml, line) != 0) {
1004: magic_free_line(ml);
1005: ml = NULL;
1006: continue;
1007: }
1008:
1009: ml->strength = magic_get_strength(ml);
1010: if (ml->parent == NULL)
1011: RB_INSERT(magic_tree, &m->tree, ml);
1012: else
1013: TAILQ_INSERT_TAIL(&ml->parent->children, ml, entry);
1014: parent0 = ml;
1015: }
1016: free(tmp);
1017:
1018: fclose(f);
1019: return (m);
1020: }