1 /*
2 * Copyright (c) Ian F. Darwin 1986-1995.
3 * Software written by Ian F. Darwin and others;
4 * maintained 1995-present by Christos Zoulas and others.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice immediately at the beginning of the file, without modification,
11 * this list of conditions, and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
20 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28 /*
29 * apprentice - make one pass through /etc/magic, learning its secrets.
30 */
31
32 #include "php.h"
33
34 #include "file.h"
35
36 #ifndef lint
37 FILE_RCSID("@(#)$File: apprentice.c,v 1.297 2020/05/09 18:57:15 christos Exp $")
38 #endif /* lint */
39
40 #include "magic.h"
41 #include "patchlevel.h"
42 #include <stdlib.h>
43
44 #if defined(__hpux) && !defined(HAVE_STRTOULL)
45 #if SIZEOF_LONG == 8
46 # define strtoull strtoul
47 #else
48 # define strtoull __strtoull
49 #endif
50 #endif
51
52 #ifdef PHP_WIN32
53 #include "win32/unistd.h"
54 #define strtoull _strtoui64
55 #else
56 #ifdef HAVE_UNISTD_H
57 #include <unistd.h>
58 #endif
59 #endif
60 #include <string.h>
61 #include <assert.h>
62 #include <ctype.h>
63 #include <fcntl.h>
64
65 #ifndef SSIZE_MAX
66 #define MAXMAGIC_SIZE ((ssize_t)0x7fffffff)
67 #else
68 #define MAXMAGIC_SIZE SSIZE_MAX
69 #endif
70
71
72 #define EATAB {while (isascii(CAST(unsigned char, *l)) && \
73 isspace(CAST(unsigned char, *l))) ++l;}
74 #define LOWCASE(l) (isupper(CAST(unsigned char, l)) ? \
75 tolower(CAST(unsigned char, l)) : (l))
76 /*
77 * Work around a bug in headers on Digital Unix.
78 * At least confirmed for: OSF1 V4.0 878
79 */
80 #if defined(__osf__) && defined(__DECC)
81 #ifdef MAP_FAILED
82 #undef MAP_FAILED
83 #endif
84 #endif
85
86 #ifndef offsetof
87 #define offsetof(STRUCTURE,FIELD) ((int)((char*)&((STRUCTURE*)0)->FIELD))
88 #endif
89
90 #ifndef MAP_FAILED
91 #define MAP_FAILED (void *) -1
92 #endif
93
94 #ifndef MAP_FILE
95 #define MAP_FILE 0
96 #endif
97
98 #define ALLOC_CHUNK CAST(size_t, 10)
99 #define ALLOC_INCR CAST(size_t, 200)
100
101 #define MAP_TYPE_USER 0
102 #define MAP_TYPE_MALLOC 1
103 #define MAP_TYPE_MMAP 2
104
105 struct magic_entry {
106 struct magic *mp;
107 uint32_t cont_count;
108 uint32_t max_count;
109 };
110
111 struct magic_entry_set {
112 struct magic_entry *me;
113 uint32_t count;
114 uint32_t max;
115 };
116
117 struct magic_map {
118 void *p;
119 size_t len;
120 int type;
121 struct magic *magic[MAGIC_SETS];
122 uint32_t nmagic[MAGIC_SETS];
123 };
124
125 int file_formats[FILE_NAMES_SIZE];
126 const size_t file_nformats = FILE_NAMES_SIZE;
127 const char *file_names[FILE_NAMES_SIZE];
128 const size_t file_nnames = FILE_NAMES_SIZE;
129
130 private int getvalue(struct magic_set *ms, struct magic *, const char **, int);
131 private int hextoint(int);
132 private const char *getstr(struct magic_set *, struct magic *, const char *,
133 int);
134 private int parse(struct magic_set *, struct magic_entry *, const char *,
135 size_t, int);
136 private void eatsize(const char **);
137 private int apprentice_1(struct magic_set *, const char *, int);
138 private size_t apprentice_magic_strength(const struct magic *);
139 private int apprentice_sort(const void *, const void *);
140 private void apprentice_list(struct mlist *, int );
141 private struct magic_map *apprentice_load(struct magic_set *,
142 const char *, int);
143 private struct mlist *mlist_alloc(void);
144 private void mlist_free_all(struct magic_set *);
145 private void mlist_free(struct mlist *);
146 private void byteswap(struct magic *, uint32_t);
147 private void bs1(struct magic *);
148 private uint16_t swap2(uint16_t);
149 private uint32_t swap4(uint32_t);
150 private uint64_t swap8(uint64_t);
151 private char *mkdbname(struct magic_set *, const char *, int);
152 private struct magic_map *apprentice_map(struct magic_set *, const char *);
153 private void apprentice_unmap(struct magic_map *);
154 private int apprentice_compile(struct magic_set *, struct magic_map *,
155 const char *);
156 private int check_format_type(const char *, int, const char **);
157 private int check_format(struct magic_set *, struct magic *);
158 private int get_op(char);
159 private int parse_mime(struct magic_set *, struct magic_entry *, const char *,
160 size_t);
161 private int parse_strength(struct magic_set *, struct magic_entry *,
162 const char *, size_t);
163 private int parse_apple(struct magic_set *, struct magic_entry *, const char *,
164 size_t);
165 private int parse_ext(struct magic_set *, struct magic_entry *, const char *,
166 size_t);
167
168
169 private size_t magicsize = sizeof(struct magic);
170
171 private const char usg_hdr[] = "cont\toffset\ttype\topcode\tmask\tvalue\tdesc";
172
173 private struct {
174 const char *name;
175 size_t len;
176 int (*fun)(struct magic_set *, struct magic_entry *, const char *,
177 size_t);
178 } bang[] = {
179 #define DECLARE_FIELD(name) { # name, sizeof(# name) - 1, parse_ ## name }
180 DECLARE_FIELD(mime),
181 DECLARE_FIELD(apple),
182 DECLARE_FIELD(ext),
183 DECLARE_FIELD(strength),
184 #undef DECLARE_FIELD
185 { NULL, 0, NULL }
186 };
187
188 #include "../data_file.c"
189
190 struct type_tbl_s {
191 const char name[16];
192 const size_t len;
193 const int type;
194 const int format;
195 };
196
197 /*
198 * XXX - the actual Single UNIX Specification says that "long" means "long",
199 * as in the C data type, but we treat it as meaning "4-byte integer".
200 * Given that the OS X version of file 5.04 did the same, I guess that passes
201 * the actual test; having "long" be dependent on how big a "long" is on
202 * the machine running "file" is silly.
203 */
204 static const struct type_tbl_s type_tbl[] = {
205 # define XX(s) s, (sizeof(s) - 1)
206 # define XX_NULL "", 0
207 { XX("invalid"), FILE_INVALID, FILE_FMT_NONE },
208 { XX("byte"), FILE_BYTE, FILE_FMT_NUM },
209 { XX("short"), FILE_SHORT, FILE_FMT_NUM },
210 { XX("default"), FILE_DEFAULT, FILE_FMT_NONE },
211 { XX("long"), FILE_LONG, FILE_FMT_NUM },
212 { XX("string"), FILE_STRING, FILE_FMT_STR },
213 { XX("date"), FILE_DATE, FILE_FMT_STR },
214 { XX("beshort"), FILE_BESHORT, FILE_FMT_NUM },
215 { XX("belong"), FILE_BELONG, FILE_FMT_NUM },
216 { XX("bedate"), FILE_BEDATE, FILE_FMT_STR },
217 { XX("leshort"), FILE_LESHORT, FILE_FMT_NUM },
218 { XX("lelong"), FILE_LELONG, FILE_FMT_NUM },
219 { XX("ledate"), FILE_LEDATE, FILE_FMT_STR },
220 { XX("pstring"), FILE_PSTRING, FILE_FMT_STR },
221 { XX("ldate"), FILE_LDATE, FILE_FMT_STR },
222 { XX("beldate"), FILE_BELDATE, FILE_FMT_STR },
223 { XX("leldate"), FILE_LELDATE, FILE_FMT_STR },
224 { XX("regex"), FILE_REGEX, FILE_FMT_STR },
225 { XX("bestring16"), FILE_BESTRING16, FILE_FMT_STR },
226 { XX("lestring16"), FILE_LESTRING16, FILE_FMT_STR },
227 { XX("search"), FILE_SEARCH, FILE_FMT_STR },
228 { XX("medate"), FILE_MEDATE, FILE_FMT_STR },
229 { XX("meldate"), FILE_MELDATE, FILE_FMT_STR },
230 { XX("melong"), FILE_MELONG, FILE_FMT_NUM },
231 { XX("quad"), FILE_QUAD, FILE_FMT_QUAD },
232 { XX("lequad"), FILE_LEQUAD, FILE_FMT_QUAD },
233 { XX("bequad"), FILE_BEQUAD, FILE_FMT_QUAD },
234 { XX("qdate"), FILE_QDATE, FILE_FMT_STR },
235 { XX("leqdate"), FILE_LEQDATE, FILE_FMT_STR },
236 { XX("beqdate"), FILE_BEQDATE, FILE_FMT_STR },
237 { XX("qldate"), FILE_QLDATE, FILE_FMT_STR },
238 { XX("leqldate"), FILE_LEQLDATE, FILE_FMT_STR },
239 { XX("beqldate"), FILE_BEQLDATE, FILE_FMT_STR },
240 { XX("float"), FILE_FLOAT, FILE_FMT_FLOAT },
241 { XX("befloat"), FILE_BEFLOAT, FILE_FMT_FLOAT },
242 { XX("lefloat"), FILE_LEFLOAT, FILE_FMT_FLOAT },
243 { XX("double"), FILE_DOUBLE, FILE_FMT_DOUBLE },
244 { XX("bedouble"), FILE_BEDOUBLE, FILE_FMT_DOUBLE },
245 { XX("ledouble"), FILE_LEDOUBLE, FILE_FMT_DOUBLE },
246 { XX("leid3"), FILE_LEID3, FILE_FMT_NUM },
247 { XX("beid3"), FILE_BEID3, FILE_FMT_NUM },
248 { XX("indirect"), FILE_INDIRECT, FILE_FMT_NUM },
249 { XX("qwdate"), FILE_QWDATE, FILE_FMT_STR },
250 { XX("leqwdate"), FILE_LEQWDATE, FILE_FMT_STR },
251 { XX("beqwdate"), FILE_BEQWDATE, FILE_FMT_STR },
252 { XX("name"), FILE_NAME, FILE_FMT_NONE },
253 { XX("use"), FILE_USE, FILE_FMT_NONE },
254 { XX("clear"), FILE_CLEAR, FILE_FMT_NONE },
255 { XX("der"), FILE_DER, FILE_FMT_STR },
256 { XX("guid"), FILE_GUID, FILE_FMT_STR },
257 { XX("offset"), FILE_OFFSET, FILE_FMT_QUAD },
258 { XX_NULL, FILE_INVALID, FILE_FMT_NONE },
259 };
260
261 /*
262 * These are not types, and cannot be preceded by "u" to make them
263 * unsigned.
264 */
265 static const struct type_tbl_s special_tbl[] = {
266 { XX("der"), FILE_DER, FILE_FMT_STR },
267 { XX("name"), FILE_NAME, FILE_FMT_STR },
268 { XX("use"), FILE_USE, FILE_FMT_STR },
269 { XX_NULL, FILE_INVALID, FILE_FMT_NONE },
270 };
271 # undef XX
272 # undef XX_NULL
273
274 private int
get_type(const struct type_tbl_s * tbl,const char * l,const char ** t)275 get_type(const struct type_tbl_s *tbl, const char *l, const char **t)
276 {
277 const struct type_tbl_s *p;
278
279 for (p = tbl; p->len; p++) {
280 if (strncmp(l, p->name, p->len) == 0) {
281 if (t)
282 *t = l + p->len;
283 break;
284 }
285 }
286 return p->type;
287 }
288
289 private off_t
maxoff_t(void)290 maxoff_t(void) {
291 if (/*CONSTCOND*/sizeof(off_t) == sizeof(int))
292 return CAST(off_t, INT_MAX);
293 if (/*CONSTCOND*/sizeof(off_t) == sizeof(long))
294 return CAST(off_t, LONG_MAX);
295 return 0x7fffffff;
296 }
297
298 private int
get_standard_integer_type(const char * l,const char ** t)299 get_standard_integer_type(const char *l, const char **t)
300 {
301 int type;
302
303 if (isalpha(CAST(unsigned char, l[1]))) {
304 switch (l[1]) {
305 case 'C':
306 /* "dC" and "uC" */
307 type = FILE_BYTE;
308 break;
309 case 'S':
310 /* "dS" and "uS" */
311 type = FILE_SHORT;
312 break;
313 case 'I':
314 case 'L':
315 /*
316 * "dI", "dL", "uI", and "uL".
317 *
318 * XXX - the actual Single UNIX Specification says
319 * that "L" means "long", as in the C data type,
320 * but we treat it as meaning "4-byte integer".
321 * Given that the OS X version of file 5.04 did
322 * the same, I guess that passes the actual SUS
323 * validation suite; having "dL" be dependent on
324 * how big a "long" is on the machine running
325 * "file" is silly.
326 */
327 type = FILE_LONG;
328 break;
329 case 'Q':
330 /* "dQ" and "uQ" */
331 type = FILE_QUAD;
332 break;
333 default:
334 /* "d{anything else}", "u{anything else}" */
335 return FILE_INVALID;
336 }
337 l += 2;
338 } else if (isdigit(CAST(unsigned char, l[1]))) {
339 /*
340 * "d{num}" and "u{num}"; we only support {num} values
341 * of 1, 2, 4, and 8 - the Single UNIX Specification
342 * doesn't say anything about whether arbitrary
343 * values should be supported, but both the Solaris 10
344 * and OS X Mountain Lion versions of file passed the
345 * Single UNIX Specification validation suite, and
346 * neither of them support values bigger than 8 or
347 * non-power-of-2 values.
348 */
349 if (isdigit(CAST(unsigned char, l[2]))) {
350 /* Multi-digit, so > 9 */
351 return FILE_INVALID;
352 }
353 switch (l[1]) {
354 case '1':
355 type = FILE_BYTE;
356 break;
357 case '2':
358 type = FILE_SHORT;
359 break;
360 case '4':
361 type = FILE_LONG;
362 break;
363 case '8':
364 type = FILE_QUAD;
365 break;
366 default:
367 /* XXX - what about 3, 5, 6, or 7? */
368 return FILE_INVALID;
369 }
370 l += 2;
371 } else {
372 /*
373 * "d" or "u" by itself.
374 */
375 type = FILE_LONG;
376 ++l;
377 }
378 if (t)
379 *t = l;
380 return type;
381 }
382
383 private void
init_file_tables(void)384 init_file_tables(void)
385 {
386 static int done = 0;
387 const struct type_tbl_s *p;
388
389 if (done)
390 return;
391 done++;
392
393 for (p = type_tbl; p->len; p++) {
394 assert(p->type < FILE_NAMES_SIZE);
395 file_names[p->type] = p->name;
396 file_formats[p->type] = p->format;
397 }
398 assert(p - type_tbl == FILE_NAMES_SIZE);
399 }
400
401 private int
add_mlist(struct mlist * mlp,struct magic_map * map,size_t idx)402 add_mlist(struct mlist *mlp, struct magic_map *map, size_t idx)
403 {
404 struct mlist *ml;
405
406 mlp->map = NULL;
407 if ((ml = CAST(struct mlist *, emalloc(sizeof(*ml)))) == NULL)
408 return -1;
409
410 ml->map = idx == 0 ? map : NULL;
411 ml->magic = map->magic[idx];
412 ml->nmagic = map->nmagic[idx];
413
414 mlp->prev->next = ml;
415 ml->prev = mlp->prev;
416 ml->next = mlp;
417 mlp->prev = ml;
418 return 0;
419 }
420
421 /*
422 * Handle one file or directory.
423 */
424 private int
apprentice_1(struct magic_set * ms,const char * fn,int action)425 apprentice_1(struct magic_set *ms, const char *fn, int action)
426 {
427 struct magic_map *map;
428 #ifndef COMPILE_ONLY
429 struct mlist *ml;
430 size_t i;
431 #endif
432
433 if (magicsize != FILE_MAGICSIZE) {
434 file_error(ms, 0, "magic element size %lu != %lu",
435 CAST(unsigned long, sizeof(*map->magic[0])),
436 CAST(unsigned long, FILE_MAGICSIZE));
437 return -1;
438 }
439
440 if (action == FILE_COMPILE) {
441 map = apprentice_load(ms, fn, action);
442 if (map == NULL)
443 return -1;
444 return apprentice_compile(ms, map, fn);
445 }
446
447 #ifndef COMPILE_ONLY
448 map = apprentice_map(ms, fn);
449 if (map == NULL) {
450 if (ms->flags & MAGIC_CHECK)
451 file_magwarn(ms, "using regular magic file `%s'", fn);
452 map = apprentice_load(ms, fn, action);
453 if (map == NULL)
454 return -1;
455 }
456
457 for (i = 0; i < MAGIC_SETS; i++) {
458 if (add_mlist(ms->mlist[i], map, i) == -1) {
459 /* failed to add to any list, free explicitly */
460 if (i == 0)
461 apprentice_unmap(map);
462 else
463 mlist_free_all(ms);
464 file_oomem(ms, sizeof(*ml));
465 return -1;
466 }
467 }
468
469 if (action == FILE_LIST) {
470 for (i = 0; i < MAGIC_SETS; i++) {
471 printf("Set %" SIZE_T_FORMAT "u:\nBinary patterns:\n",
472 i);
473 apprentice_list(ms->mlist[i], BINTEST);
474 printf("Text patterns:\n");
475 apprentice_list(ms->mlist[i], TEXTTEST);
476 }
477 }
478 return 0;
479 #else
480 return 0;
481 #endif /* COMPILE_ONLY */
482 }
483
484 protected void
file_ms_free(struct magic_set * ms)485 file_ms_free(struct magic_set *ms)
486 {
487 size_t i;
488 if (ms == NULL)
489 return;
490 for (i = 0; i < MAGIC_SETS; i++)
491 mlist_free(ms->mlist[i]);
492 if (ms->o.pbuf) {
493 efree(ms->o.pbuf);
494 }
495 if (ms->o.buf) {
496 efree(ms->o.buf);
497 }
498 if (ms->c.li) {
499 efree(ms->c.li);
500 }
501 efree(ms);
502 }
503
504 protected struct magic_set *
file_ms_alloc(int flags)505 file_ms_alloc(int flags)
506 {
507 struct magic_set *ms;
508 size_t i, len;
509
510 if ((ms = CAST(struct magic_set *, ecalloc(CAST(size_t, 1u),
511 sizeof(struct magic_set)))) == NULL)
512 return NULL;
513
514 if (magic_setflags(ms, flags) == -1) {
515 errno = EINVAL;
516 goto free;
517 }
518
519 ms->o.buf = ms->o.pbuf = NULL;
520 ms->o.blen = 0;
521 len = (ms->c.len = 10) * sizeof(*ms->c.li);
522
523 if ((ms->c.li = CAST(struct level_info *, emalloc(len))) == NULL)
524 goto free;
525
526 ms->event_flags = 0;
527 ms->error = -1;
528 for (i = 0; i < MAGIC_SETS; i++)
529 ms->mlist[i] = NULL;
530 ms->file = "unknown";
531 ms->line = 0;
532 ms->indir_max = FILE_INDIR_MAX;
533 ms->name_max = FILE_NAME_MAX;
534 ms->elf_shnum_max = FILE_ELF_SHNUM_MAX;
535 ms->elf_phnum_max = FILE_ELF_PHNUM_MAX;
536 ms->elf_notes_max = FILE_ELF_NOTES_MAX;
537 ms->regex_max = FILE_REGEX_MAX;
538 ms->bytes_max = FILE_BYTES_MAX;
539 return ms;
540 free:
541 efree(ms);
542 return NULL;
543 }
544
545 private void
apprentice_unmap(struct magic_map * map)546 apprentice_unmap(struct magic_map *map)
547 {
548 if (map == NULL)
549 return;
550 if (map->p != php_magic_database) {
551 if (map->p == NULL) {
552 int j;
553 for (j = 0; j < MAGIC_SETS; j++) {
554 if (map->magic[j]) {
555 efree(map->magic[j]);
556 }
557 }
558 } else {
559 efree(map->p);
560 }
561 }
562 efree(map);
563 }
564
565 private struct mlist *
mlist_alloc(void)566 mlist_alloc(void)
567 {
568 struct mlist *mlist;
569 if ((mlist = CAST(struct mlist *, ecalloc(1, sizeof(*mlist)))) == NULL) {
570 return NULL;
571 }
572 mlist->next = mlist->prev = mlist;
573 return mlist;
574 }
575
576 private void
mlist_free_all(struct magic_set * ms)577 mlist_free_all(struct magic_set *ms)
578 {
579 size_t i;
580
581 for (i = 0; i < MAGIC_SETS; i++) {
582 mlist_free(ms->mlist[i]);
583 ms->mlist[i] = NULL;
584 }
585 }
586
587 private void
mlist_free_one(struct mlist * ml)588 mlist_free_one(struct mlist *ml)
589 {
590 if (ml->map)
591 apprentice_unmap(CAST(struct magic_map *, ml->map));
592 efree(ml);
593 }
594
595 private void
mlist_free(struct mlist * mlist)596 mlist_free(struct mlist *mlist)
597 {
598 struct mlist *ml, *next;
599
600 if (mlist == NULL)
601 return;
602
603 for (ml = mlist->next; ml != mlist;) {
604 next = ml->next;
605 mlist_free_one(ml);
606 ml = next;
607 }
608 mlist_free_one(mlist);
609 }
610
611 /* const char *fn: list of magic files and directories */
612 protected int
file_apprentice(struct magic_set * ms,const char * fn,int action)613 file_apprentice(struct magic_set *ms, const char *fn, int action)
614 {
615 char *p, *mfn;
616 int fileerr, errs = -1;
617 size_t i, j;
618
619 (void)file_reset(ms, 0);
620
621 /* XXX disabling default magic loading so the compiled in data is used */
622 #if 0
623 if ((fn = magic_getpath(fn, action)) == NULL)
624 return -1;
625 #endif
626
627 init_file_tables();
628
629 if (fn == NULL)
630 fn = getenv("MAGIC");
631 if (fn == NULL) {
632 for (i = 0; i < MAGIC_SETS; i++) {
633 mlist_free(ms->mlist[i]);
634 if ((ms->mlist[i] = mlist_alloc()) == NULL) {
635 file_oomem(ms, sizeof(*ms->mlist[i]));
636 return -1;
637 }
638 }
639 return apprentice_1(ms, fn, action);
640 }
641
642 if ((mfn = estrdup(fn)) == NULL) {
643 file_oomem(ms, strlen(fn));
644 return -1;
645 }
646
647 for (i = 0; i < MAGIC_SETS; i++) {
648 mlist_free(ms->mlist[i]);
649 if ((ms->mlist[i] = mlist_alloc()) == NULL) {
650 file_oomem(ms, sizeof(*ms->mlist[i]));
651 for (j = 0; j < i; j++) {
652 mlist_free(ms->mlist[j]);
653 ms->mlist[j] = NULL;
654 }
655 efree(mfn);
656 return -1;
657 }
658 }
659 fn = mfn;
660
661 while (fn) {
662 p = strchr(fn, PATHSEP);
663 if (p)
664 *p++ = '\0';
665 if (*fn == '\0')
666 break;
667 fileerr = apprentice_1(ms, fn, action);
668 errs = MAX(errs, fileerr);
669 fn = p;
670 }
671
672 efree(mfn);
673
674 if (errs == -1) {
675 for (i = 0; i < MAGIC_SETS; i++) {
676 mlist_free(ms->mlist[i]);
677 ms->mlist[i] = NULL;
678 }
679 file_error(ms, 0, "could not find any valid magic files!");
680 return -1;
681 }
682
683 #if 0
684 /*
685 * Always leave the database loaded
686 */
687 if (action == FILE_LOAD)
688 return 0;
689
690 for (i = 0; i < MAGIC_SETS; i++) {
691 mlist_free(ms->mlist[i]);
692 ms->mlist[i] = NULL;
693 }
694 #endif
695
696 switch (action) {
697 case FILE_LOAD:
698 case FILE_COMPILE:
699 case FILE_CHECK:
700 case FILE_LIST:
701 return 0;
702 default:
703 file_error(ms, 0, "Invalid action %d", action);
704 return -1;
705 }
706 }
707
708 /*
709 * Compute the real length of a magic expression, for the purposes
710 * of determining how "strong" a magic expression is (approximating
711 * how specific its matches are):
712 * - magic characters count 0 unless escaped.
713 * - [] expressions count 1
714 * - {} expressions count 0
715 * - regular characters or escaped magic characters count 1
716 * - 0 length expressions count as one
717 */
718 private size_t
nonmagic(const char * str)719 nonmagic(const char *str)
720 {
721 const char *p;
722 size_t rv = 0;
723
724 for (p = str; *p; p++)
725 switch (*p) {
726 case '\\': /* Escaped anything counts 1 */
727 if (!*++p)
728 p--;
729 rv++;
730 continue;
731 case '?': /* Magic characters count 0 */
732 case '*':
733 case '.':
734 case '+':
735 case '^':
736 case '$':
737 continue;
738 case '[': /* Bracketed expressions count 1 the ']' */
739 while (*p && *p != ']')
740 p++;
741 p--;
742 continue;
743 case '{': /* Braced expressions count 0 */
744 while (*p && *p != '}')
745 p++;
746 if (!*p)
747 p--;
748 continue;
749 default: /* Anything else counts 1 */
750 rv++;
751 continue;
752 }
753
754 return rv == 0 ? 1 : rv; /* Return at least 1 */
755 }
756
757
758 private size_t
typesize(int type)759 typesize(int type)
760 {
761 switch (type) {
762 case FILE_BYTE:
763 return 1;
764
765 case FILE_SHORT:
766 case FILE_LESHORT:
767 case FILE_BESHORT:
768 return 2;
769
770 case FILE_LONG:
771 case FILE_LELONG:
772 case FILE_BELONG:
773 case FILE_MELONG:
774 return 4;
775
776 case FILE_DATE:
777 case FILE_LEDATE:
778 case FILE_BEDATE:
779 case FILE_MEDATE:
780 case FILE_LDATE:
781 case FILE_LELDATE:
782 case FILE_BELDATE:
783 case FILE_MELDATE:
784 case FILE_FLOAT:
785 case FILE_BEFLOAT:
786 case FILE_LEFLOAT:
787 return 4;
788
789 case FILE_QUAD:
790 case FILE_BEQUAD:
791 case FILE_LEQUAD:
792 case FILE_QDATE:
793 case FILE_LEQDATE:
794 case FILE_BEQDATE:
795 case FILE_QLDATE:
796 case FILE_LEQLDATE:
797 case FILE_BEQLDATE:
798 case FILE_QWDATE:
799 case FILE_LEQWDATE:
800 case FILE_BEQWDATE:
801 case FILE_DOUBLE:
802 case FILE_BEDOUBLE:
803 case FILE_LEDOUBLE:
804 case FILE_OFFSET:
805 return 8;
806
807 case FILE_GUID:
808 return 16;
809
810 default:
811 return FILE_BADSIZE;
812 }
813 }
814
815 /*
816 * Get weight of this magic entry, for sorting purposes.
817 */
818 private size_t
apprentice_magic_strength(const struct magic * m)819 apprentice_magic_strength(const struct magic *m)
820 {
821 #define MULT 10U
822 size_t ts, v;
823 ssize_t val = 2 * MULT; /* baseline strength */
824
825 switch (m->type) {
826 case FILE_DEFAULT: /* make sure this sorts last */
827 if (m->factor_op != FILE_FACTOR_OP_NONE)
828 abort();
829 return 0;
830
831 case FILE_BYTE:
832 case FILE_SHORT:
833 case FILE_LESHORT:
834 case FILE_BESHORT:
835 case FILE_LONG:
836 case FILE_LELONG:
837 case FILE_BELONG:
838 case FILE_MELONG:
839 case FILE_DATE:
840 case FILE_LEDATE:
841 case FILE_BEDATE:
842 case FILE_MEDATE:
843 case FILE_LDATE:
844 case FILE_LELDATE:
845 case FILE_BELDATE:
846 case FILE_MELDATE:
847 case FILE_FLOAT:
848 case FILE_BEFLOAT:
849 case FILE_LEFLOAT:
850 case FILE_QUAD:
851 case FILE_BEQUAD:
852 case FILE_LEQUAD:
853 case FILE_QDATE:
854 case FILE_LEQDATE:
855 case FILE_BEQDATE:
856 case FILE_QLDATE:
857 case FILE_LEQLDATE:
858 case FILE_BEQLDATE:
859 case FILE_QWDATE:
860 case FILE_LEQWDATE:
861 case FILE_BEQWDATE:
862 case FILE_DOUBLE:
863 case FILE_BEDOUBLE:
864 case FILE_LEDOUBLE:
865 case FILE_GUID:
866 case FILE_OFFSET:
867 ts = typesize(m->type);
868 if (ts == FILE_BADSIZE)
869 abort();
870 val += ts * MULT;
871 break;
872
873 case FILE_PSTRING:
874 case FILE_STRING:
875 val += m->vallen * MULT;
876 break;
877
878 case FILE_BESTRING16:
879 case FILE_LESTRING16:
880 val += m->vallen * MULT / 2;
881 break;
882
883 case FILE_SEARCH:
884 if (m->vallen == 0)
885 break;
886 val += m->vallen * MAX(MULT / m->vallen, 1);
887 break;
888
889 case FILE_REGEX:
890 v = nonmagic(m->value.s);
891 val += v * MAX(MULT / v, 1);
892 break;
893
894 case FILE_INDIRECT:
895 case FILE_NAME:
896 case FILE_USE:
897 break;
898
899 case FILE_DER:
900 val += MULT;
901 break;
902
903 default:
904 (void)fprintf(stderr, "Bad type %d\n", m->type);
905 abort();
906 }
907
908 switch (m->reln) {
909 case 'x': /* matches anything penalize */
910 case '!': /* matches almost anything penalize */
911 val = 0;
912 break;
913
914 case '=': /* Exact match, prefer */
915 val += MULT;
916 break;
917
918 case '>':
919 case '<': /* comparison match reduce strength */
920 val -= 2 * MULT;
921 break;
922
923 case '^':
924 case '&': /* masking bits, we could count them too */
925 val -= MULT;
926 break;
927
928 default:
929 (void)fprintf(stderr, "Bad relation %c\n", m->reln);
930 abort();
931 }
932
933 switch (m->factor_op) {
934 case FILE_FACTOR_OP_NONE:
935 break;
936 case FILE_FACTOR_OP_PLUS:
937 val += m->factor;
938 break;
939 case FILE_FACTOR_OP_MINUS:
940 val -= m->factor;
941 break;
942 case FILE_FACTOR_OP_TIMES:
943 val *= m->factor;
944 break;
945 case FILE_FACTOR_OP_DIV:
946 val /= m->factor;
947 break;
948 default:
949 abort();
950 }
951
952 if (val <= 0) /* ensure we only return 0 for FILE_DEFAULT */
953 val = 1;
954
955 /*
956 * Magic entries with no description get a bonus because they depend
957 * on subsequent magic entries to print something.
958 */
959 if (m->desc[0] == '\0')
960 val++;
961 return val;
962 }
963
964 /*
965 * Sort callback for sorting entries by "strength" (basically length)
966 */
967 private int
apprentice_sort(const void * a,const void * b)968 apprentice_sort(const void *a, const void *b)
969 {
970 const struct magic_entry *ma = CAST(const struct magic_entry *, a);
971 const struct magic_entry *mb = CAST(const struct magic_entry *, b);
972 size_t sa = apprentice_magic_strength(ma->mp);
973 size_t sb = apprentice_magic_strength(mb->mp);
974 if (sa == sb)
975 return 0;
976 else if (sa > sb)
977 return -1;
978 else
979 return 1;
980 }
981
982 /*
983 * Shows sorted patterns list in the order which is used for the matching
984 */
985 private void
apprentice_list(struct mlist * mlist,int mode)986 apprentice_list(struct mlist *mlist, int mode)
987 {
988 uint32_t magindex = 0;
989 struct mlist *ml;
990 for (ml = mlist->next; ml != mlist; ml = ml->next) {
991 for (magindex = 0; magindex < ml->nmagic; magindex++) {
992 struct magic *m = &ml->magic[magindex];
993 if ((m->flag & mode) != mode) {
994 /* Skip sub-tests */
995 while (magindex + 1 < ml->nmagic &&
996 ml->magic[magindex + 1].cont_level != 0)
997 ++magindex;
998 continue; /* Skip to next top-level test*/
999 }
1000
1001 /*
1002 * Try to iterate over the tree until we find item with
1003 * description/mimetype.
1004 */
1005 while (magindex + 1 < ml->nmagic &&
1006 ml->magic[magindex + 1].cont_level != 0 &&
1007 *ml->magic[magindex].desc == '\0' &&
1008 *ml->magic[magindex].mimetype == '\0')
1009 magindex++;
1010
1011 printf("Strength = %3" SIZE_T_FORMAT "u@%u: %s [%s]\n",
1012 apprentice_magic_strength(m),
1013 ml->magic[magindex].lineno,
1014 ml->magic[magindex].desc,
1015 ml->magic[magindex].mimetype);
1016 }
1017 }
1018 }
1019
1020 private void
set_test_type(struct magic * mstart,struct magic * m)1021 set_test_type(struct magic *mstart, struct magic *m)
1022 {
1023 switch (m->type) {
1024 case FILE_BYTE:
1025 case FILE_SHORT:
1026 case FILE_LONG:
1027 case FILE_DATE:
1028 case FILE_BESHORT:
1029 case FILE_BELONG:
1030 case FILE_BEDATE:
1031 case FILE_LESHORT:
1032 case FILE_LELONG:
1033 case FILE_LEDATE:
1034 case FILE_LDATE:
1035 case FILE_BELDATE:
1036 case FILE_LELDATE:
1037 case FILE_MEDATE:
1038 case FILE_MELDATE:
1039 case FILE_MELONG:
1040 case FILE_QUAD:
1041 case FILE_LEQUAD:
1042 case FILE_BEQUAD:
1043 case FILE_QDATE:
1044 case FILE_LEQDATE:
1045 case FILE_BEQDATE:
1046 case FILE_QLDATE:
1047 case FILE_LEQLDATE:
1048 case FILE_BEQLDATE:
1049 case FILE_QWDATE:
1050 case FILE_LEQWDATE:
1051 case FILE_BEQWDATE:
1052 case FILE_FLOAT:
1053 case FILE_BEFLOAT:
1054 case FILE_LEFLOAT:
1055 case FILE_DOUBLE:
1056 case FILE_BEDOUBLE:
1057 case FILE_LEDOUBLE:
1058 case FILE_DER:
1059 case FILE_GUID:
1060 case FILE_OFFSET:
1061 mstart->flag |= BINTEST;
1062 break;
1063 case FILE_STRING:
1064 case FILE_PSTRING:
1065 case FILE_BESTRING16:
1066 case FILE_LESTRING16:
1067 /* Allow text overrides */
1068 if (mstart->str_flags & STRING_TEXTTEST)
1069 mstart->flag |= TEXTTEST;
1070 else
1071 mstart->flag |= BINTEST;
1072 break;
1073 case FILE_REGEX:
1074 case FILE_SEARCH:
1075 /* Check for override */
1076 if (mstart->str_flags & STRING_BINTEST)
1077 mstart->flag |= BINTEST;
1078 if (mstart->str_flags & STRING_TEXTTEST)
1079 mstart->flag |= TEXTTEST;
1080
1081 if (mstart->flag & (TEXTTEST|BINTEST))
1082 break;
1083
1084 /* binary test if pattern is not text */
1085 if (file_looks_utf8(m->value.us, CAST(size_t, m->vallen), NULL,
1086 NULL) <= 0)
1087 mstart->flag |= BINTEST;
1088 else
1089 mstart->flag |= TEXTTEST;
1090 break;
1091 case FILE_DEFAULT:
1092 /* can't deduce anything; we shouldn't see this at the
1093 top level anyway */
1094 break;
1095 case FILE_INVALID:
1096 default:
1097 /* invalid search type, but no need to complain here */
1098 break;
1099 }
1100 }
1101
1102 private int
addentry(struct magic_set * ms,struct magic_entry * me,struct magic_entry_set * mset)1103 addentry(struct magic_set *ms, struct magic_entry *me,
1104 struct magic_entry_set *mset)
1105 {
1106 size_t i = me->mp->type == FILE_NAME ? 1 : 0;
1107 if (mset[i].count == mset[i].max) {
1108 struct magic_entry *mp;
1109
1110 mset[i].max += ALLOC_INCR;
1111 if ((mp = CAST(struct magic_entry *,
1112 erealloc(mset[i].me, sizeof(*mp) * mset[i].max))) ==
1113 NULL) {
1114 file_oomem(ms, sizeof(*mp) * mset[i].max);
1115 return -1;
1116 }
1117 (void)memset(&mp[mset[i].count], 0, sizeof(*mp) *
1118 ALLOC_INCR);
1119 mset[i].me = mp;
1120 }
1121 mset[i].me[mset[i].count++] = *me;
1122 memset(me, 0, sizeof(*me));
1123 return 0;
1124 }
1125
1126 /*
1127 * Load and parse one file.
1128 */
1129 private void
load_1(struct magic_set * ms,int action,const char * fn,int * errs,struct magic_entry_set * mset)1130 load_1(struct magic_set *ms, int action, const char *fn, int *errs,
1131 struct magic_entry_set *mset)
1132 {
1133 char buffer[BUFSIZ + 1];
1134 char *line = NULL;
1135 size_t len;
1136 size_t lineno = 0;
1137 struct magic_entry me;
1138
1139 php_stream *stream;
1140
1141
1142 ms->file = fn;
1143 stream = php_stream_open_wrapper((char *)fn, "rb", REPORT_ERRORS, NULL);
1144
1145 if (stream == NULL) {
1146 if (errno != ENOENT)
1147 file_error(ms, errno, "cannot read magic file `%s'",
1148 fn);
1149 (*errs)++;
1150 return;
1151 }
1152
1153 memset(&me, 0, sizeof(me));
1154 /* read and parse this file */
1155 for (ms->line = 1; (line = php_stream_get_line(stream, buffer , BUFSIZ, &len)) != NULL; ms->line++) {
1156 if (len == 0) /* null line, garbage, etc */
1157 continue;
1158 if (line[len - 1] == '\n') {
1159 lineno++;
1160 line[len - 1] = '\0'; /* delete newline */
1161 }
1162 switch (line[0]) {
1163 case '\0': /* empty, do not parse */
1164 case '#': /* comment, do not parse */
1165 continue;
1166 case '!':
1167 if (line[1] == ':') {
1168 size_t i;
1169
1170 for (i = 0; bang[i].name != NULL; i++) {
1171 if (CAST(size_t, len - 2) > bang[i].len &&
1172 memcmp(bang[i].name, line + 2,
1173 bang[i].len) == 0)
1174 break;
1175 }
1176 if (bang[i].name == NULL) {
1177 file_error(ms, 0,
1178 "Unknown !: entry `%s'", line);
1179 (*errs)++;
1180 continue;
1181 }
1182 if (me.mp == NULL) {
1183 file_error(ms, 0,
1184 "No current entry for :!%s type",
1185 bang[i].name);
1186 (*errs)++;
1187 continue;
1188 }
1189 if ((*bang[i].fun)(ms, &me,
1190 line + bang[i].len + 2,
1191 len - bang[i].len - 2) != 0) {
1192 (*errs)++;
1193 continue;
1194 }
1195 continue;
1196 }
1197 /*FALLTHROUGH*/
1198 default:
1199 again:
1200 switch (parse(ms, &me, line, lineno, action)) {
1201 case 0:
1202 continue;
1203 case 1:
1204 (void)addentry(ms, &me, mset);
1205 goto again;
1206 default:
1207 (*errs)++;
1208 break;
1209 }
1210 }
1211 }
1212 if (me.mp)
1213 (void)addentry(ms, &me, mset);
1214 efree(line);
1215 php_stream_close(stream);
1216 }
1217
1218 /*
1219 * parse a file or directory of files
1220 * const char *fn: name of magic file or directory
1221 */
1222 private int
cmpstrp(const void * p1,const void * p2)1223 cmpstrp(const void *p1, const void *p2)
1224 {
1225 return strcmp(*RCAST(char *const *, p1), *RCAST(char *const *, p2));
1226 }
1227
1228
1229 private uint32_t
set_text_binary(struct magic_set * ms,struct magic_entry * me,uint32_t nme,uint32_t starttest)1230 set_text_binary(struct magic_set *ms, struct magic_entry *me, uint32_t nme,
1231 uint32_t starttest)
1232 {
1233 static const char text[] = "text";
1234 static const char binary[] = "binary";
1235 static const size_t len = sizeof(text);
1236
1237 uint32_t i = starttest;
1238
1239 do {
1240 set_test_type(me[starttest].mp, me[i].mp);
1241 if ((ms->flags & MAGIC_DEBUG) == 0)
1242 continue;
1243 (void)fprintf(stderr, "%s%s%s: %s\n",
1244 me[i].mp->mimetype,
1245 me[i].mp->mimetype[0] == '\0' ? "" : "; ",
1246 me[i].mp->desc[0] ? me[i].mp->desc : "(no description)",
1247 me[i].mp->flag & BINTEST ? binary : text);
1248 if (me[i].mp->flag & BINTEST) {
1249 char *p = strstr(me[i].mp->desc, text);
1250 if (p && (p == me[i].mp->desc ||
1251 isspace(CAST(unsigned char, p[-1]))) &&
1252 (p + len - me[i].mp->desc == MAXstring
1253 || (p[len] == '\0' ||
1254 isspace(CAST(unsigned char, p[len])))))
1255 (void)fprintf(stderr, "*** Possible "
1256 "binary test for text type\n");
1257 }
1258 } while (++i < nme && me[i].mp->cont_level != 0);
1259 return i;
1260 }
1261
1262 private void
set_last_default(struct magic_set * ms,struct magic_entry * me,uint32_t nme)1263 set_last_default(struct magic_set *ms, struct magic_entry *me, uint32_t nme)
1264 {
1265 uint32_t i;
1266 for (i = 0; i < nme; i++) {
1267 if (me[i].mp->cont_level == 0 &&
1268 me[i].mp->type == FILE_DEFAULT) {
1269 while (++i < nme)
1270 if (me[i].mp->cont_level == 0)
1271 break;
1272 if (i != nme) {
1273 /* XXX - Ugh! */
1274 ms->line = me[i].mp->lineno;
1275 file_magwarn(ms,
1276 "level 0 \"default\" did not sort last");
1277 }
1278 return;
1279 }
1280 }
1281 }
1282
1283 private int
coalesce_entries(struct magic_set * ms,struct magic_entry * me,uint32_t nme,struct magic ** ma,uint32_t * nma)1284 coalesce_entries(struct magic_set *ms, struct magic_entry *me, uint32_t nme,
1285 struct magic **ma, uint32_t *nma)
1286 {
1287 uint32_t i, mentrycount = 0;
1288 size_t slen;
1289
1290 for (i = 0; i < nme; i++)
1291 mentrycount += me[i].cont_count;
1292
1293 slen = sizeof(**ma) * mentrycount;
1294 if ((*ma = CAST(struct magic *, emalloc(slen))) == NULL) {
1295 file_oomem(ms, slen);
1296 return -1;
1297 }
1298
1299 mentrycount = 0;
1300 for (i = 0; i < nme; i++) {
1301 (void)memcpy(*ma + mentrycount, me[i].mp,
1302 me[i].cont_count * sizeof(**ma));
1303 mentrycount += me[i].cont_count;
1304 }
1305 *nma = mentrycount;
1306 return 0;
1307 }
1308
1309 private void
magic_entry_free(struct magic_entry * me,uint32_t nme)1310 magic_entry_free(struct magic_entry *me, uint32_t nme)
1311 {
1312 uint32_t i;
1313 if (me == NULL)
1314 return;
1315 for (i = 0; i < nme; i++)
1316 efree(me[i].mp);
1317 efree(me);
1318 }
1319
1320 private struct magic_map *
apprentice_load(struct magic_set * ms,const char * fn,int action)1321 apprentice_load(struct magic_set *ms, const char *fn, int action)
1322 {
1323 int errs = 0;
1324 uint32_t i, j;
1325 size_t files = 0, maxfiles = 0;
1326 char **filearr = NULL;
1327 zend_stat_t st;
1328 struct magic_map *map;
1329 struct magic_entry_set mset[MAGIC_SETS];
1330 php_stream *dir;
1331 php_stream_dirent d;
1332
1333
1334 memset(mset, 0, sizeof(mset));
1335 ms->flags |= MAGIC_CHECK; /* Enable checks for parsed files */
1336
1337
1338 if ((map = CAST(struct magic_map *, ecalloc(1, sizeof(*map)))) == NULL)
1339 {
1340 file_oomem(ms, sizeof(*map));
1341 return NULL;
1342 }
1343 map->type = MAP_TYPE_MALLOC;
1344
1345 /* print silly verbose header for USG compat. */
1346 if (action == FILE_CHECK)
1347 (void)fprintf(stderr, "%s\n", usg_hdr);
1348
1349 /* load directory or file */
1350 /* FIXME: Read file names and sort them to prevent
1351 non-determinism. See Debian bug #488562. */
1352 if (php_sys_stat(fn, &st) == 0 && S_ISDIR(st.st_mode)) {
1353 int mflen;
1354 char mfn[MAXPATHLEN];
1355
1356 dir = php_stream_opendir((char *)fn, REPORT_ERRORS, NULL);
1357 if (!dir) {
1358 errs++;
1359 goto out;
1360 }
1361 while (php_stream_readdir(dir, &d)) {
1362 if ((mflen = snprintf(mfn, sizeof(mfn), "%s/%s", fn, d.d_name)) < 0) {
1363 file_oomem(ms,
1364 strlen(fn) + strlen(d.d_name) + 2);
1365 errs++;
1366 php_stream_closedir(dir);
1367 goto out;
1368 }
1369 if (zend_stat(mfn, &st) == -1 || !S_ISREG(st.st_mode)) {
1370 continue;
1371 }
1372 if (files >= maxfiles) {
1373 size_t mlen;
1374 maxfiles = (maxfiles + 1) * 2;
1375 mlen = maxfiles * sizeof(*filearr);
1376 if ((filearr = CAST(char **,
1377 erealloc(filearr, mlen))) == NULL) {
1378 file_oomem(ms, mlen);
1379 php_stream_closedir(dir);
1380 errs++;
1381 goto out;
1382 }
1383 }
1384 filearr[files++] = estrndup(mfn, (mflen > sizeof(mfn) - 1)? sizeof(mfn) - 1: mflen);
1385 }
1386 php_stream_closedir(dir);
1387 if (filearr) {
1388 qsort(filearr, files, sizeof(*filearr), cmpstrp);
1389 for (i = 0; i < files; i++) {
1390 load_1(ms, action, filearr[i], &errs, mset);
1391 efree(filearr[i]);
1392 }
1393 efree(filearr);
1394 }
1395 } else
1396 load_1(ms, action, fn, &errs, mset);
1397 if (errs)
1398 goto out;
1399
1400 for (j = 0; j < MAGIC_SETS; j++) {
1401 /* Set types of tests */
1402 for (i = 0; i < mset[j].count; ) {
1403 if (mset[j].me[i].mp->cont_level != 0) {
1404 i++;
1405 continue;
1406 }
1407 i = set_text_binary(ms, mset[j].me, mset[j].count, i);
1408 }
1409 if (mset[j].me)
1410 qsort(mset[j].me, mset[j].count, sizeof(*mset[j].me),
1411 apprentice_sort);
1412
1413 /*
1414 * Make sure that any level 0 "default" line is last
1415 * (if one exists).
1416 */
1417 set_last_default(ms, mset[j].me, mset[j].count);
1418
1419 /* coalesce per file arrays into a single one */
1420 if (coalesce_entries(ms, mset[j].me, mset[j].count,
1421 &map->magic[j], &map->nmagic[j]) == -1) {
1422 errs++;
1423 goto out;
1424 }
1425 }
1426
1427 out:
1428 for (j = 0; j < MAGIC_SETS; j++)
1429 magic_entry_free(mset[j].me, mset[j].count);
1430
1431 if (errs) {
1432 apprentice_unmap(map);
1433 return NULL;
1434 }
1435 return map;
1436 }
1437
1438 /*
1439 * extend the sign bit if the comparison is to be signed
1440 */
1441 protected uint64_t
file_signextend(struct magic_set * ms,struct magic * m,uint64_t v)1442 file_signextend(struct magic_set *ms, struct magic *m, uint64_t v)
1443 {
1444 if (!(m->flag & UNSIGNED)) {
1445 switch(m->type) {
1446 /*
1447 * Do not remove the casts below. They are
1448 * vital. When later compared with the data,
1449 * the sign extension must have happened.
1450 */
1451 case FILE_BYTE:
1452 v = CAST(signed char, v);
1453 break;
1454 case FILE_SHORT:
1455 case FILE_BESHORT:
1456 case FILE_LESHORT:
1457 v = CAST(short, v);
1458 break;
1459 case FILE_DATE:
1460 case FILE_BEDATE:
1461 case FILE_LEDATE:
1462 case FILE_MEDATE:
1463 case FILE_LDATE:
1464 case FILE_BELDATE:
1465 case FILE_LELDATE:
1466 case FILE_MELDATE:
1467 case FILE_LONG:
1468 case FILE_BELONG:
1469 case FILE_LELONG:
1470 case FILE_MELONG:
1471 case FILE_FLOAT:
1472 case FILE_BEFLOAT:
1473 case FILE_LEFLOAT:
1474 v = CAST(int32_t, v);
1475 break;
1476 case FILE_QUAD:
1477 case FILE_BEQUAD:
1478 case FILE_LEQUAD:
1479 case FILE_QDATE:
1480 case FILE_QLDATE:
1481 case FILE_QWDATE:
1482 case FILE_BEQDATE:
1483 case FILE_BEQLDATE:
1484 case FILE_BEQWDATE:
1485 case FILE_LEQDATE:
1486 case FILE_LEQLDATE:
1487 case FILE_LEQWDATE:
1488 case FILE_DOUBLE:
1489 case FILE_BEDOUBLE:
1490 case FILE_LEDOUBLE:
1491 case FILE_OFFSET:
1492 v = CAST(int64_t, v);
1493 break;
1494 case FILE_STRING:
1495 case FILE_PSTRING:
1496 case FILE_BESTRING16:
1497 case FILE_LESTRING16:
1498 case FILE_REGEX:
1499 case FILE_SEARCH:
1500 case FILE_DEFAULT:
1501 case FILE_INDIRECT:
1502 case FILE_NAME:
1503 case FILE_USE:
1504 case FILE_CLEAR:
1505 case FILE_DER:
1506 case FILE_GUID:
1507 break;
1508 default:
1509 if (ms->flags & MAGIC_CHECK)
1510 file_magwarn(ms, "cannot happen: m->type=%d\n",
1511 m->type);
1512 return FILE_BADSIZE;
1513 }
1514 }
1515 return v;
1516 }
1517
1518 private int
string_modifier_check(struct magic_set * ms,struct magic * m)1519 string_modifier_check(struct magic_set *ms, struct magic *m)
1520 {
1521 if ((ms->flags & MAGIC_CHECK) == 0)
1522 return 0;
1523
1524 if ((m->type != FILE_REGEX || (m->str_flags & REGEX_LINE_COUNT) == 0) &&
1525 (m->type != FILE_PSTRING && (m->str_flags & PSTRING_LEN) != 0)) {
1526 file_magwarn(ms,
1527 "'/BHhLl' modifiers are only allowed for pascal strings\n");
1528 return -1;
1529 }
1530 switch (m->type) {
1531 case FILE_BESTRING16:
1532 case FILE_LESTRING16:
1533 if (m->str_flags != 0) {
1534 file_magwarn(ms,
1535 "no modifiers allowed for 16-bit strings\n");
1536 return -1;
1537 }
1538 break;
1539 case FILE_STRING:
1540 case FILE_PSTRING:
1541 if ((m->str_flags & REGEX_OFFSET_START) != 0) {
1542 file_magwarn(ms,
1543 "'/%c' only allowed on regex and search\n",
1544 CHAR_REGEX_OFFSET_START);
1545 return -1;
1546 }
1547 break;
1548 case FILE_SEARCH:
1549 if (m->str_range == 0) {
1550 file_magwarn(ms,
1551 "missing range; defaulting to %d\n",
1552 STRING_DEFAULT_RANGE);
1553 m->str_range = STRING_DEFAULT_RANGE;
1554 return -1;
1555 }
1556 break;
1557 case FILE_REGEX:
1558 if ((m->str_flags & STRING_COMPACT_WHITESPACE) != 0) {
1559 file_magwarn(ms, "'/%c' not allowed on regex\n",
1560 CHAR_COMPACT_WHITESPACE);
1561 return -1;
1562 }
1563 if ((m->str_flags & STRING_COMPACT_OPTIONAL_WHITESPACE) != 0) {
1564 file_magwarn(ms, "'/%c' not allowed on regex\n",
1565 CHAR_COMPACT_OPTIONAL_WHITESPACE);
1566 return -1;
1567 }
1568 break;
1569 default:
1570 file_magwarn(ms, "coding error: m->type=%d\n",
1571 m->type);
1572 return -1;
1573 }
1574 return 0;
1575 }
1576
1577 private int
get_op(char c)1578 get_op(char c)
1579 {
1580 switch (c) {
1581 case '&':
1582 return FILE_OPAND;
1583 case '|':
1584 return FILE_OPOR;
1585 case '^':
1586 return FILE_OPXOR;
1587 case '+':
1588 return FILE_OPADD;
1589 case '-':
1590 return FILE_OPMINUS;
1591 case '*':
1592 return FILE_OPMULTIPLY;
1593 case '/':
1594 return FILE_OPDIVIDE;
1595 case '%':
1596 return FILE_OPMODULO;
1597 default:
1598 return -1;
1599 }
1600 }
1601
1602 #ifdef ENABLE_CONDITIONALS
1603 private int
get_cond(const char * l,const char ** t)1604 get_cond(const char *l, const char **t)
1605 {
1606 static const struct cond_tbl_s {
1607 char name[8];
1608 size_t len;
1609 int cond;
1610 } cond_tbl[] = {
1611 { "if", 2, COND_IF },
1612 { "elif", 4, COND_ELIF },
1613 { "else", 4, COND_ELSE },
1614 { "", 0, COND_NONE },
1615 };
1616 const struct cond_tbl_s *p;
1617
1618 for (p = cond_tbl; p->len; p++) {
1619 if (strncmp(l, p->name, p->len) == 0 &&
1620 isspace(CAST(unsigned char, l[p->len]))) {
1621 if (t)
1622 *t = l + p->len;
1623 break;
1624 }
1625 }
1626 return p->cond;
1627 }
1628
1629 private int
check_cond(struct magic_set * ms,int cond,uint32_t cont_level)1630 check_cond(struct magic_set *ms, int cond, uint32_t cont_level)
1631 {
1632 int last_cond;
1633 last_cond = ms->c.li[cont_level].last_cond;
1634
1635 switch (cond) {
1636 case COND_IF:
1637 if (last_cond != COND_NONE && last_cond != COND_ELIF) {
1638 if (ms->flags & MAGIC_CHECK)
1639 file_magwarn(ms, "syntax error: `if'");
1640 return -1;
1641 }
1642 last_cond = COND_IF;
1643 break;
1644
1645 case COND_ELIF:
1646 if (last_cond != COND_IF && last_cond != COND_ELIF) {
1647 if (ms->flags & MAGIC_CHECK)
1648 file_magwarn(ms, "syntax error: `elif'");
1649 return -1;
1650 }
1651 last_cond = COND_ELIF;
1652 break;
1653
1654 case COND_ELSE:
1655 if (last_cond != COND_IF && last_cond != COND_ELIF) {
1656 if (ms->flags & MAGIC_CHECK)
1657 file_magwarn(ms, "syntax error: `else'");
1658 return -1;
1659 }
1660 last_cond = COND_NONE;
1661 break;
1662
1663 case COND_NONE:
1664 last_cond = COND_NONE;
1665 break;
1666 }
1667
1668 ms->c.li[cont_level].last_cond = last_cond;
1669 return 0;
1670 }
1671 #endif /* ENABLE_CONDITIONALS */
1672
1673 private int
parse_indirect_modifier(struct magic_set * ms,struct magic * m,const char ** lp)1674 parse_indirect_modifier(struct magic_set *ms, struct magic *m, const char **lp)
1675 {
1676 const char *l = *lp;
1677
1678 while (!isspace(CAST(unsigned char, *++l)))
1679 switch (*l) {
1680 case CHAR_INDIRECT_RELATIVE:
1681 m->str_flags |= INDIRECT_RELATIVE;
1682 break;
1683 default:
1684 if (ms->flags & MAGIC_CHECK)
1685 file_magwarn(ms, "indirect modifier `%c' "
1686 "invalid", *l);
1687 *lp = l;
1688 return -1;
1689 }
1690 *lp = l;
1691 return 0;
1692 }
1693
1694 private void
parse_op_modifier(struct magic_set * ms,struct magic * m,const char ** lp,int op)1695 parse_op_modifier(struct magic_set *ms, struct magic *m, const char **lp,
1696 int op)
1697 {
1698 const char *l = *lp;
1699 char *t;
1700 uint64_t val;
1701
1702 ++l;
1703 m->mask_op |= op;
1704 val = CAST(uint64_t, strtoull(l, &t, 0));
1705 l = t;
1706 m->num_mask = file_signextend(ms, m, val);
1707 eatsize(&l);
1708 *lp = l;
1709 }
1710
1711 private int
parse_string_modifier(struct magic_set * ms,struct magic * m,const char ** lp)1712 parse_string_modifier(struct magic_set *ms, struct magic *m, const char **lp)
1713 {
1714 const char *l = *lp;
1715 char *t;
1716 int have_range = 0;
1717
1718 while (!isspace(CAST(unsigned char, *++l))) {
1719 switch (*l) {
1720 case '0': case '1': case '2':
1721 case '3': case '4': case '5':
1722 case '6': case '7': case '8':
1723 case '9':
1724 if (have_range && (ms->flags & MAGIC_CHECK))
1725 file_magwarn(ms, "multiple ranges");
1726 have_range = 1;
1727 m->str_range = CAST(uint32_t, strtoul(l, &t, 0));
1728 if (m->str_range == 0)
1729 file_magwarn(ms, "zero range");
1730 l = t - 1;
1731 break;
1732 case CHAR_COMPACT_WHITESPACE:
1733 m->str_flags |= STRING_COMPACT_WHITESPACE;
1734 break;
1735 case CHAR_COMPACT_OPTIONAL_WHITESPACE:
1736 m->str_flags |= STRING_COMPACT_OPTIONAL_WHITESPACE;
1737 break;
1738 case CHAR_IGNORE_LOWERCASE:
1739 m->str_flags |= STRING_IGNORE_LOWERCASE;
1740 break;
1741 case CHAR_IGNORE_UPPERCASE:
1742 m->str_flags |= STRING_IGNORE_UPPERCASE;
1743 break;
1744 case CHAR_REGEX_OFFSET_START:
1745 m->str_flags |= REGEX_OFFSET_START;
1746 break;
1747 case CHAR_BINTEST:
1748 m->str_flags |= STRING_BINTEST;
1749 break;
1750 case CHAR_TEXTTEST:
1751 m->str_flags |= STRING_TEXTTEST;
1752 break;
1753 case CHAR_TRIM:
1754 m->str_flags |= STRING_TRIM;
1755 break;
1756 case CHAR_PSTRING_1_LE:
1757 #define SET_LENGTH(a) m->str_flags = (m->str_flags & ~PSTRING_LEN) | (a)
1758 if (m->type != FILE_PSTRING)
1759 goto bad;
1760 SET_LENGTH(PSTRING_1_LE);
1761 break;
1762 case CHAR_PSTRING_2_BE:
1763 if (m->type != FILE_PSTRING)
1764 goto bad;
1765 SET_LENGTH(PSTRING_2_BE);
1766 break;
1767 case CHAR_PSTRING_2_LE:
1768 if (m->type != FILE_PSTRING)
1769 goto bad;
1770 SET_LENGTH(PSTRING_2_LE);
1771 break;
1772 case CHAR_PSTRING_4_BE:
1773 if (m->type != FILE_PSTRING)
1774 goto bad;
1775 SET_LENGTH(PSTRING_4_BE);
1776 break;
1777 case CHAR_PSTRING_4_LE:
1778 switch (m->type) {
1779 case FILE_PSTRING:
1780 case FILE_REGEX:
1781 break;
1782 default:
1783 goto bad;
1784 }
1785 SET_LENGTH(PSTRING_4_LE);
1786 break;
1787 case CHAR_PSTRING_LENGTH_INCLUDES_ITSELF:
1788 if (m->type != FILE_PSTRING)
1789 goto bad;
1790 m->str_flags |= PSTRING_LENGTH_INCLUDES_ITSELF;
1791 break;
1792 default:
1793 bad:
1794 if (ms->flags & MAGIC_CHECK)
1795 file_magwarn(ms, "string modifier `%c' "
1796 "invalid", *l);
1797 goto out;
1798 }
1799 /* allow multiple '/' for readability */
1800 if (l[1] == '/' && !isspace(CAST(unsigned char, l[2])))
1801 l++;
1802 }
1803 if (string_modifier_check(ms, m) == -1)
1804 goto out;
1805 *lp = l;
1806 return 0;
1807 out:
1808 *lp = l;
1809 return -1;
1810 }
1811
1812 /*
1813 * parse one line from magic file, put into magic[index++] if valid
1814 */
1815 private int
parse(struct magic_set * ms,struct magic_entry * me,const char * line,size_t lineno,int action)1816 parse(struct magic_set *ms, struct magic_entry *me, const char *line,
1817 size_t lineno, int action)
1818 {
1819 #ifdef ENABLE_CONDITIONALS
1820 static uint32_t last_cont_level = 0;
1821 #endif
1822 size_t i;
1823 struct magic *m;
1824 const char *l = line;
1825 char *t;
1826 int op;
1827 uint32_t cont_level;
1828 int32_t diff;
1829
1830 cont_level = 0;
1831
1832 /*
1833 * Parse the offset.
1834 */
1835 while (*l == '>') {
1836 ++l; /* step over */
1837 cont_level++;
1838 }
1839 #ifdef ENABLE_CONDITIONALS
1840 if (cont_level == 0 || cont_level > last_cont_level)
1841 if (file_check_mem(ms, cont_level) == -1)
1842 return -1;
1843 last_cont_level = cont_level;
1844 #endif
1845 if (cont_level != 0) {
1846 if (me->mp == NULL) {
1847 file_magerror(ms, "No current entry for continuation");
1848 return -1;
1849 }
1850 if (me->cont_count == 0) {
1851 file_magerror(ms, "Continuations present with 0 count");
1852 return -1;
1853 }
1854 m = &me->mp[me->cont_count - 1];
1855 diff = CAST(int32_t, cont_level) - CAST(int32_t, m->cont_level);
1856 if (diff > 1)
1857 file_magwarn(ms, "New continuation level %u is more "
1858 "than one larger than current level %u", cont_level,
1859 m->cont_level);
1860 if (me->cont_count == me->max_count) {
1861 struct magic *nm;
1862 size_t cnt = me->max_count + ALLOC_CHUNK;
1863 if ((nm = CAST(struct magic *, erealloc(me->mp,
1864 sizeof(*nm) * cnt))) == NULL) {
1865 file_oomem(ms, sizeof(*nm) * cnt);
1866 return -1;
1867 }
1868 me->mp = nm;
1869 me->max_count = CAST(uint32_t, cnt);
1870 }
1871 m = &me->mp[me->cont_count++];
1872 (void)memset(m, 0, sizeof(*m));
1873 m->cont_level = cont_level;
1874 } else {
1875 static const size_t len = sizeof(*m) * ALLOC_CHUNK;
1876 if (me->mp != NULL)
1877 return 1;
1878 if ((m = CAST(struct magic *, emalloc(len))) == NULL) {
1879 file_oomem(ms, len);
1880 return -1;
1881 }
1882 me->mp = m;
1883 me->max_count = ALLOC_CHUNK;
1884 (void)memset(m, 0, sizeof(*m));
1885 m->factor_op = FILE_FACTOR_OP_NONE;
1886 m->cont_level = 0;
1887 me->cont_count = 1;
1888 }
1889 m->lineno = CAST(uint32_t, lineno);
1890
1891 if (*l == '&') { /* m->cont_level == 0 checked below. */
1892 ++l; /* step over */
1893 m->flag |= OFFADD;
1894 }
1895 if (*l == '(') {
1896 ++l; /* step over */
1897 m->flag |= INDIR;
1898 if (m->flag & OFFADD)
1899 m->flag = (m->flag & ~OFFADD) | INDIROFFADD;
1900
1901 if (*l == '&') { /* m->cont_level == 0 checked below */
1902 ++l; /* step over */
1903 m->flag |= OFFADD;
1904 }
1905 }
1906 /* Indirect offsets are not valid at level 0. */
1907 if (m->cont_level == 0 && (m->flag & (OFFADD | INDIROFFADD))) {
1908 if (ms->flags & MAGIC_CHECK)
1909 file_magwarn(ms, "relative offset at level 0");
1910 return -1;
1911 }
1912
1913 /* get offset, then skip over it */
1914 if (*l == '-') {
1915 ++l; /* step over */
1916 m->flag |= OFFNEGATIVE;
1917 }
1918 m->offset = CAST(int32_t, strtol(l, &t, 0));
1919 if (l == t) {
1920 if (ms->flags & MAGIC_CHECK)
1921 file_magwarn(ms, "offset `%s' invalid", l);
1922 return -1;
1923 }
1924
1925 l = t;
1926
1927 if (m->flag & INDIR) {
1928 m->in_type = FILE_LONG;
1929 m->in_offset = 0;
1930 m->in_op = 0;
1931 /*
1932 * read [.,lbs][+-]nnnnn)
1933 */
1934 if (*l == '.' || *l == ',') {
1935 if (*l == ',')
1936 m->in_op |= FILE_OPSIGNED;
1937 l++;
1938 switch (*l) {
1939 case 'l':
1940 m->in_type = FILE_LELONG;
1941 break;
1942 case 'L':
1943 m->in_type = FILE_BELONG;
1944 break;
1945 case 'm':
1946 m->in_type = FILE_MELONG;
1947 break;
1948 case 'h':
1949 case 's':
1950 m->in_type = FILE_LESHORT;
1951 break;
1952 case 'H':
1953 case 'S':
1954 m->in_type = FILE_BESHORT;
1955 break;
1956 case 'c':
1957 case 'b':
1958 case 'C':
1959 case 'B':
1960 m->in_type = FILE_BYTE;
1961 break;
1962 case 'e':
1963 case 'f':
1964 case 'g':
1965 m->in_type = FILE_LEDOUBLE;
1966 break;
1967 case 'E':
1968 case 'F':
1969 case 'G':
1970 m->in_type = FILE_BEDOUBLE;
1971 break;
1972 case 'i':
1973 m->in_type = FILE_LEID3;
1974 break;
1975 case 'I':
1976 m->in_type = FILE_BEID3;
1977 break;
1978 case 'q':
1979 m->in_type = FILE_LEQUAD;
1980 break;
1981 case 'Q':
1982 m->in_type = FILE_BEQUAD;
1983 break;
1984 default:
1985 if (ms->flags & MAGIC_CHECK)
1986 file_magwarn(ms,
1987 "indirect offset type `%c' invalid",
1988 *l);
1989 return -1;
1990 }
1991 l++;
1992 }
1993
1994 if (*l == '~') {
1995 m->in_op |= FILE_OPINVERSE;
1996 l++;
1997 }
1998 if ((op = get_op(*l)) != -1) {
1999 m->in_op |= op;
2000 l++;
2001 }
2002 if (*l == '(') {
2003 m->in_op |= FILE_OPINDIRECT;
2004 l++;
2005 }
2006 if (isdigit(CAST(unsigned char, *l)) || *l == '-') {
2007 m->in_offset = CAST(int32_t, strtol(l, &t, 0));
2008 if (l == t) {
2009 if (ms->flags & MAGIC_CHECK)
2010 file_magwarn(ms,
2011 "in_offset `%s' invalid", l);
2012 return -1;
2013 }
2014 l = t;
2015 }
2016 if (*l++ != ')' ||
2017 ((m->in_op & FILE_OPINDIRECT) && *l++ != ')')) {
2018 if (ms->flags & MAGIC_CHECK)
2019 file_magwarn(ms,
2020 "missing ')' in indirect offset");
2021 return -1;
2022 }
2023 }
2024 EATAB;
2025
2026 #ifdef ENABLE_CONDITIONALS
2027 m->cond = get_cond(l, &l);
2028 if (check_cond(ms, m->cond, cont_level) == -1)
2029 return -1;
2030
2031 EATAB;
2032 #endif
2033
2034 /*
2035 * Parse the type.
2036 */
2037 if (*l == 'u') {
2038 /*
2039 * Try it as a keyword type prefixed by "u"; match what
2040 * follows the "u". If that fails, try it as an SUS
2041 * integer type.
2042 */
2043 m->type = get_type(type_tbl, l + 1, &l);
2044 if (m->type == FILE_INVALID) {
2045 /*
2046 * Not a keyword type; parse it as an SUS type,
2047 * 'u' possibly followed by a number or C/S/L.
2048 */
2049 m->type = get_standard_integer_type(l, &l);
2050 }
2051 /* It's unsigned. */
2052 if (m->type != FILE_INVALID)
2053 m->flag |= UNSIGNED;
2054 } else {
2055 /*
2056 * Try it as a keyword type. If that fails, try it as
2057 * an SUS integer type if it begins with "d" or as an
2058 * SUS string type if it begins with "s". In any case,
2059 * it's not unsigned.
2060 */
2061 m->type = get_type(type_tbl, l, &l);
2062 if (m->type == FILE_INVALID) {
2063 /*
2064 * Not a keyword type; parse it as an SUS type,
2065 * either 'd' possibly followed by a number or
2066 * C/S/L, or just 's'.
2067 */
2068 if (*l == 'd')
2069 m->type = get_standard_integer_type(l, &l);
2070 else if (*l == 's'
2071 && !isalpha(CAST(unsigned char, l[1]))) {
2072 m->type = FILE_STRING;
2073 ++l;
2074 }
2075 }
2076 }
2077
2078 if (m->type == FILE_INVALID) {
2079 /* Not found - try it as a special keyword. */
2080 m->type = get_type(special_tbl, l, &l);
2081 }
2082
2083 if (m->type == FILE_INVALID) {
2084 if (ms->flags & MAGIC_CHECK)
2085 file_magwarn(ms, "type `%s' invalid", l);
2086 return -1;
2087 }
2088
2089 /* New-style anding: "0 byte&0x80 =0x80 dynamically linked" */
2090 /* New and improved: ~ & | ^ + - * / % -- exciting, isn't it? */
2091
2092 m->mask_op = 0;
2093 if (*l == '~') {
2094 if (!IS_LIBMAGIC_STRING(m->type))
2095 m->mask_op |= FILE_OPINVERSE;
2096 else if (ms->flags & MAGIC_CHECK)
2097 file_magwarn(ms, "'~' invalid for string types");
2098 ++l;
2099 }
2100 m->str_range = 0;
2101 m->str_flags = m->type == FILE_PSTRING ? PSTRING_1_LE : 0;
2102 if ((op = get_op(*l)) != -1) {
2103 if (IS_LIBMAGIC_STRING(m->type)) {
2104 int r;
2105
2106 if (op != FILE_OPDIVIDE) {
2107 if (ms->flags & MAGIC_CHECK)
2108 file_magwarn(ms,
2109 "invalid string/indirect op: "
2110 "`%c'", *t);
2111 return -1;
2112 }
2113
2114 if (m->type == FILE_INDIRECT)
2115 r = parse_indirect_modifier(ms, m, &l);
2116 else
2117 r = parse_string_modifier(ms, m, &l);
2118 if (r == -1)
2119 return -1;
2120 } else
2121 parse_op_modifier(ms, m, &l, op);
2122 }
2123
2124 /*
2125 * We used to set mask to all 1's here, instead let's just not do
2126 * anything if mask = 0 (unless you have a better idea)
2127 */
2128 EATAB;
2129
2130 switch (*l) {
2131 case '>':
2132 case '<':
2133 m->reln = *l;
2134 ++l;
2135 if (*l == '=') {
2136 if (ms->flags & MAGIC_CHECK) {
2137 file_magwarn(ms, "%c= not supported",
2138 m->reln);
2139 return -1;
2140 }
2141 ++l;
2142 }
2143 break;
2144 /* Old-style anding: "0 byte &0x80 dynamically linked" */
2145 case '&':
2146 case '^':
2147 case '=':
2148 m->reln = *l;
2149 ++l;
2150 if (*l == '=') {
2151 /* HP compat: ignore &= etc. */
2152 ++l;
2153 }
2154 break;
2155 case '!':
2156 m->reln = *l;
2157 ++l;
2158 break;
2159 default:
2160 m->reln = '='; /* the default relation */
2161 if (*l == 'x' && ((isascii(CAST(unsigned char, l[1])) &&
2162 isspace(CAST(unsigned char, l[1]))) || !l[1])) {
2163 m->reln = *l;
2164 ++l;
2165 }
2166 break;
2167 }
2168 /*
2169 * Grab the value part, except for an 'x' reln.
2170 */
2171 if (m->reln != 'x' && getvalue(ms, m, &l, action))
2172 return -1;
2173
2174 /*
2175 * TODO finish this macro and start using it!
2176 * #define offsetcheck {if (offset > ms->bytes_max -1)
2177 * magwarn("offset too big"); }
2178 */
2179
2180 /*
2181 * Now get last part - the description
2182 */
2183 EATAB;
2184 if (l[0] == '\b') {
2185 ++l;
2186 m->flag |= NOSPACE;
2187 } else if ((l[0] == '\\') && (l[1] == 'b')) {
2188 ++l;
2189 ++l;
2190 m->flag |= NOSPACE;
2191 }
2192 for (i = 0; (m->desc[i++] = *l++) != '\0' && i < sizeof(m->desc); )
2193 continue;
2194 if (i == sizeof(m->desc)) {
2195 m->desc[sizeof(m->desc) - 1] = '\0';
2196 if (ms->flags & MAGIC_CHECK)
2197 file_magwarn(ms, "description `%s' truncated", m->desc);
2198 }
2199
2200 /*
2201 * We only do this check while compiling, or if any of the magic
2202 * files were not compiled.
2203 */
2204 if (ms->flags & MAGIC_CHECK) {
2205 if (check_format(ms, m) == -1)
2206 return -1;
2207 }
2208 #ifndef COMPILE_ONLY
2209 if (action == FILE_CHECK) {
2210 file_mdump(m);
2211 }
2212 #endif
2213 m->mimetype[0] = '\0'; /* initialise MIME type to none */
2214 return 0;
2215 }
2216
2217 /*
2218 * parse a STRENGTH annotation line from magic file, put into magic[index - 1]
2219 * if valid
2220 */
2221 private int
parse_strength(struct magic_set * ms,struct magic_entry * me,const char * line,size_t len)2222 parse_strength(struct magic_set *ms, struct magic_entry *me, const char *line,
2223 size_t len)
2224 {
2225 const char *l = line;
2226 char *el;
2227 unsigned long factor;
2228 struct magic *m = &me->mp[0];
2229
2230 if (m->factor_op != FILE_FACTOR_OP_NONE) {
2231 file_magwarn(ms,
2232 "Current entry already has a strength type: %c %d",
2233 m->factor_op, m->factor);
2234 return -1;
2235 }
2236 if (m->type == FILE_NAME) {
2237 file_magwarn(ms, "%s: Strength setting is not supported in "
2238 "\"name\" magic entries", m->value.s);
2239 return -1;
2240 }
2241 EATAB;
2242 switch (*l) {
2243 case FILE_FACTOR_OP_NONE:
2244 case FILE_FACTOR_OP_PLUS:
2245 case FILE_FACTOR_OP_MINUS:
2246 case FILE_FACTOR_OP_TIMES:
2247 case FILE_FACTOR_OP_DIV:
2248 m->factor_op = *l++;
2249 break;
2250 default:
2251 file_magwarn(ms, "Unknown factor op `%c'", *l);
2252 return -1;
2253 }
2254 EATAB;
2255 factor = strtoul(l, &el, 0);
2256 if (factor > 255) {
2257 file_magwarn(ms, "Too large factor `%lu'", factor);
2258 goto out;
2259 }
2260 if (*el && !isspace(CAST(unsigned char, *el))) {
2261 file_magwarn(ms, "Bad factor `%s'", l);
2262 goto out;
2263 }
2264 m->factor = CAST(uint8_t, factor);
2265 if (m->factor == 0 && m->factor_op == FILE_FACTOR_OP_DIV) {
2266 file_magwarn(ms, "Cannot have factor op `%c' and factor %u",
2267 m->factor_op, m->factor);
2268 goto out;
2269 }
2270 return 0;
2271 out:
2272 m->factor_op = FILE_FACTOR_OP_NONE;
2273 m->factor = 0;
2274 return -1;
2275 }
2276
2277 private int
goodchar(unsigned char x,const char * extra)2278 goodchar(unsigned char x, const char *extra)
2279 {
2280 return (isascii(x) && isalnum(x)) || strchr(extra, x);
2281 }
2282
2283 private int
parse_extra(struct magic_set * ms,struct magic_entry * me,const char * line,size_t llen,zend_off_t off,size_t len,const char * name,const char * extra,int nt)2284 parse_extra(struct magic_set *ms, struct magic_entry *me, const char *line,
2285 size_t llen, zend_off_t off, size_t len, const char *name, const char *extra, int nt)
2286 {
2287 size_t i;
2288 const char *l = line;
2289 struct magic *m = &me->mp[me->cont_count == 0 ? 0 : me->cont_count - 1];
2290 char *buf = CAST(char *, CAST(void *, m)) + off;
2291
2292 if (buf[0] != '\0') {
2293 len = nt ? strlen(buf) : len;
2294 file_magwarn(ms, "Current entry already has a %s type "
2295 "`%.*s', new type `%s'", name, CAST(int, len), buf, l);
2296 return -1;
2297 }
2298
2299 if (*m->desc == '\0') {
2300 file_magwarn(ms, "Current entry does not yet have a "
2301 "description for adding a %s type", name);
2302 return -1;
2303 }
2304
2305 EATAB;
2306 for (i = 0; *l && i < llen && i < len && goodchar(*l, extra);
2307 buf[i++] = *l++)
2308 continue;
2309
2310 if (i == len && *l) {
2311 if (nt)
2312 buf[len - 1] = '\0';
2313 if (ms->flags & MAGIC_CHECK)
2314 file_magwarn(ms, "%s type `%s' truncated %"
2315 SIZE_T_FORMAT "u", name, line, i);
2316 } else {
2317 if (!isspace(CAST(unsigned char, *l)) && !goodchar(*l, extra))
2318 file_magwarn(ms, "%s type `%s' has bad char '%c'",
2319 name, line, *l);
2320 if (nt)
2321 buf[i] = '\0';
2322 }
2323
2324 if (i > 0)
2325 return 0;
2326
2327 file_magerror(ms, "Bad magic entry '%s'", line);
2328 return -1;
2329 }
2330
2331 /*
2332 * Parse an Apple CREATOR/TYPE annotation from magic file and put it into
2333 * magic[index - 1]
2334 */
2335 private int
parse_apple(struct magic_set * ms,struct magic_entry * me,const char * line,size_t len)2336 parse_apple(struct magic_set *ms, struct magic_entry *me, const char *line,
2337 size_t len)
2338 {
2339 struct magic *m = &me->mp[0];
2340
2341 return parse_extra(ms, me, line, len,
2342 CAST(off_t, offsetof(struct magic, apple)),
2343 sizeof(m->apple), "APPLE", "!+-./?", 0);
2344 }
2345
2346 /*
2347 * Parse a comma-separated list of extensions
2348 */
2349 private int
parse_ext(struct magic_set * ms,struct magic_entry * me,const char * line,size_t len)2350 parse_ext(struct magic_set *ms, struct magic_entry *me, const char *line,
2351 size_t len)
2352 {
2353 struct magic *m = &me->mp[0];
2354
2355 return parse_extra(ms, me, line, len,
2356 CAST(off_t, offsetof(struct magic, ext)),
2357 sizeof(m->ext), "EXTENSION", ",!+-/@?_$", 0);
2358 }
2359
2360 /*
2361 * parse a MIME annotation line from magic file, put into magic[index - 1]
2362 * if valid
2363 */
2364 private int
parse_mime(struct magic_set * ms,struct magic_entry * me,const char * line,size_t len)2365 parse_mime(struct magic_set *ms, struct magic_entry *me, const char *line,
2366 size_t len)
2367 {
2368 struct magic *m = &me->mp[0];
2369
2370 return parse_extra(ms, me, line, len,
2371 CAST(off_t, offsetof(struct magic, mimetype)),
2372 sizeof(m->mimetype), "MIME", "+-/.$?:{}", 1);
2373 }
2374
2375 private int
check_format_type(const char * ptr,int type,const char ** estr)2376 check_format_type(const char *ptr, int type, const char **estr)
2377 {
2378 int quad = 0, h;
2379 size_t len, cnt;
2380 if (*ptr == '\0') {
2381 /* Missing format string; bad */
2382 *estr = "missing format spec";
2383 return -1;
2384 }
2385
2386 switch (file_formats[type]) {
2387 case FILE_FMT_QUAD:
2388 quad = 1;
2389 /*FALLTHROUGH*/
2390 case FILE_FMT_NUM:
2391 if (quad == 0) {
2392 switch (type) {
2393 case FILE_BYTE:
2394 h = 2;
2395 break;
2396 case FILE_SHORT:
2397 case FILE_BESHORT:
2398 case FILE_LESHORT:
2399 h = 1;
2400 break;
2401 case FILE_LONG:
2402 case FILE_BELONG:
2403 case FILE_LELONG:
2404 case FILE_MELONG:
2405 case FILE_LEID3:
2406 case FILE_BEID3:
2407 case FILE_INDIRECT:
2408 h = 0;
2409 break;
2410 default:
2411 abort();
2412 }
2413 } else
2414 h = 0;
2415 if (*ptr == '-')
2416 ptr++;
2417 if (*ptr == '.')
2418 ptr++;
2419 if (*ptr == '#')
2420 ptr++;
2421 #define CHECKLEN() do { \
2422 for (len = cnt = 0; isdigit(CAST(unsigned char, *ptr)); ptr++, cnt++) \
2423 len = len * 10 + (*ptr - '0'); \
2424 if (cnt > 5 || len > 1024) \
2425 goto toolong; \
2426 } while (/*CONSTCOND*/0)
2427
2428 CHECKLEN();
2429 if (*ptr == '.')
2430 ptr++;
2431 CHECKLEN();
2432 if (quad) {
2433 if (*ptr++ != 'l')
2434 goto invalid;
2435 if (*ptr++ != 'l')
2436 goto invalid;
2437 }
2438
2439 switch (*ptr++) {
2440 #ifdef STRICT_FORMAT /* "long" formats are int formats for us */
2441 /* so don't accept the 'l' modifier */
2442 case 'l':
2443 switch (*ptr++) {
2444 case 'i':
2445 case 'd':
2446 case 'u':
2447 case 'o':
2448 case 'x':
2449 case 'X':
2450 if (h == 0)
2451 return 0;
2452 /*FALLTHROUGH*/
2453 default:
2454 goto invalid;
2455 }
2456
2457 /*
2458 * Don't accept h and hh modifiers. They make writing
2459 * magic entries more complicated, for very little benefit
2460 */
2461 case 'h':
2462 if (h-- <= 0)
2463 goto invalid;
2464 switch (*ptr++) {
2465 case 'h':
2466 if (h-- <= 0)
2467 goto invalid;
2468 switch (*ptr++) {
2469 case 'i':
2470 case 'd':
2471 case 'u':
2472 case 'o':
2473 case 'x':
2474 case 'X':
2475 return 0;
2476 default:
2477 goto invalid;
2478 }
2479 case 'i':
2480 case 'd':
2481 case 'u':
2482 case 'o':
2483 case 'x':
2484 case 'X':
2485 if (h == 0)
2486 return 0;
2487 /*FALLTHROUGH*/
2488 default:
2489 goto invalid;
2490 }
2491 #endif
2492 case 'c':
2493 if (h == 2)
2494 return 0;
2495 goto invalid;
2496 case 'i':
2497 case 'd':
2498 case 'u':
2499 case 'o':
2500 case 'x':
2501 case 'X':
2502 #ifdef STRICT_FORMAT
2503 if (h == 0)
2504 return 0;
2505 /*FALLTHROUGH*/
2506 #else
2507 return 0;
2508 #endif
2509 default:
2510 goto invalid;
2511 }
2512
2513 case FILE_FMT_FLOAT:
2514 case FILE_FMT_DOUBLE:
2515 if (*ptr == '-')
2516 ptr++;
2517 if (*ptr == '.')
2518 ptr++;
2519 CHECKLEN();
2520 if (*ptr == '.')
2521 ptr++;
2522 CHECKLEN();
2523 switch (*ptr++) {
2524 case 'e':
2525 case 'E':
2526 case 'f':
2527 case 'F':
2528 case 'g':
2529 case 'G':
2530 return 0;
2531
2532 default:
2533 goto invalid;
2534 }
2535
2536
2537 case FILE_FMT_STR:
2538 if (*ptr == '-')
2539 ptr++;
2540 while (isdigit(CAST(unsigned char, *ptr)))
2541 ptr++;
2542 if (*ptr == '.') {
2543 ptr++;
2544 while (isdigit(CAST(unsigned char , *ptr)))
2545 ptr++;
2546 }
2547
2548 switch (*ptr++) {
2549 case 's':
2550 return 0;
2551 default:
2552 goto invalid;
2553 }
2554
2555 default:
2556 /* internal error */
2557 abort();
2558 }
2559 invalid:
2560 *estr = "not valid";
2561 toolong:
2562 *estr = "too long";
2563 return -1;
2564 }
2565
2566 /*
2567 * Check that the optional printf format in description matches
2568 * the type of the magic.
2569 */
2570 private int
check_format(struct magic_set * ms,struct magic * m)2571 check_format(struct magic_set *ms, struct magic *m)
2572 {
2573 char *ptr;
2574 const char *estr;
2575
2576 for (ptr = m->desc; *ptr; ptr++)
2577 if (*ptr == '%')
2578 break;
2579 if (*ptr == '\0') {
2580 /* No format string; ok */
2581 return 1;
2582 }
2583
2584 assert(file_nformats == file_nnames);
2585
2586 if (m->type >= file_nformats) {
2587 file_magwarn(ms, "Internal error inconsistency between "
2588 "m->type and format strings");
2589 return -1;
2590 }
2591 if (file_formats[m->type] == FILE_FMT_NONE) {
2592 file_magwarn(ms, "No format string for `%s' with description "
2593 "`%s'", m->desc, file_names[m->type]);
2594 return -1;
2595 }
2596
2597 ptr++;
2598 if (check_format_type(ptr, m->type, &estr) == -1) {
2599 /*
2600 * TODO: this error message is unhelpful if the format
2601 * string is not one character long
2602 */
2603 file_magwarn(ms, "Printf format is %s for type "
2604 "`%s' in description `%s'", estr,
2605 file_names[m->type], m->desc);
2606 return -1;
2607 }
2608
2609 for (; *ptr; ptr++) {
2610 if (*ptr == '%') {
2611 file_magwarn(ms,
2612 "Too many format strings (should have at most one) "
2613 "for `%s' with description `%s'",
2614 file_names[m->type], m->desc);
2615 return -1;
2616 }
2617 }
2618 return 0;
2619 }
2620
2621 /*
2622 * Read a numeric value from a pointer, into the value union of a magic
2623 * pointer, according to the magic type. Update the string pointer to point
2624 * just after the number read. Return 0 for success, non-zero for failure.
2625 */
2626 private int
getvalue(struct magic_set * ms,struct magic * m,const char ** p,int action)2627 getvalue(struct magic_set *ms, struct magic *m, const char **p, int action)
2628 {
2629 char *ep;
2630 uint64_t ull;
2631
2632 switch (m->type) {
2633 case FILE_BESTRING16:
2634 case FILE_LESTRING16:
2635 case FILE_STRING:
2636 case FILE_PSTRING:
2637 case FILE_REGEX:
2638 case FILE_SEARCH:
2639 case FILE_NAME:
2640 case FILE_USE:
2641 case FILE_DER:
2642 *p = getstr(ms, m, *p, action == FILE_COMPILE);
2643 if (*p == NULL) {
2644 if (ms->flags & MAGIC_CHECK)
2645 file_magwarn(ms, "cannot get string from `%s'",
2646 m->value.s);
2647 return -1;
2648 }
2649 if (m->type == FILE_REGEX) {
2650 zend_string *pattern;
2651 int options = 0;
2652 pcre_cache_entry *pce;
2653
2654 pattern = convert_libmagic_pattern(m->value.s, strlen(m->value.s), options);
2655
2656 if ((pce = pcre_get_compiled_regex_cache(pattern)) == NULL) {
2657 zend_string_release(pattern);
2658 return -1;
2659 }
2660 zend_string_release(pattern);
2661
2662 return 0;
2663 }
2664 return 0;
2665 default:
2666 if (m->reln == 'x')
2667 return 0;
2668 break;
2669 }
2670
2671 switch (m->type) {
2672 case FILE_FLOAT:
2673 case FILE_BEFLOAT:
2674 case FILE_LEFLOAT:
2675 errno = 0;
2676 #ifdef HAVE_STRTOF
2677 m->value.f = strtof(*p, &ep);
2678 #else
2679 m->value.f = (float)strtod(*p, &ep);
2680 #endif
2681 if (errno == 0)
2682 *p = ep;
2683 return 0;
2684 case FILE_DOUBLE:
2685 case FILE_BEDOUBLE:
2686 case FILE_LEDOUBLE:
2687 errno = 0;
2688 m->value.d = strtod(*p, &ep);
2689 if (errno == 0)
2690 *p = ep;
2691 return 0;
2692 case FILE_GUID:
2693 if (file_parse_guid(*p, m->value.guid) == -1)
2694 return -1;
2695 *p += FILE_GUID_SIZE - 1;
2696 return 0;
2697 default:
2698 errno = 0;
2699 ull = CAST(uint64_t, strtoull(*p, &ep, 0));
2700 m->value.q = file_signextend(ms, m, ull);
2701 if (*p == ep) {
2702 file_magwarn(ms, "Unparseable number `%s'", *p);
2703 } else {
2704 size_t ts = typesize(m->type);
2705 uint64_t x;
2706 const char *q;
2707
2708 if (ts == FILE_BADSIZE) {
2709 file_magwarn(ms,
2710 "Expected numeric type got `%s'",
2711 type_tbl[m->type].name);
2712 }
2713 for (q = *p; isspace(CAST(unsigned char, *q)); q++)
2714 continue;
2715 if (*q == '-')
2716 ull = -CAST(int64_t, ull);
2717 switch (ts) {
2718 case 1:
2719 x = CAST(uint64_t, ull & ~0xffULL);
2720 break;
2721 case 2:
2722 x = CAST(uint64_t, ull & ~0xffffULL);
2723 break;
2724 case 4:
2725 x = CAST(uint64_t, ull & ~0xffffffffULL);
2726 break;
2727 case 8:
2728 x = 0;
2729 break;
2730 default:
2731 abort();
2732 }
2733 if (x) {
2734 file_magwarn(ms, "Overflow for numeric"
2735 " type `%s' value %#" PRIx64,
2736 type_tbl[m->type].name, ull);
2737 }
2738 }
2739 if (errno == 0) {
2740 *p = ep;
2741 eatsize(p);
2742 }
2743 return 0;
2744 }
2745 }
2746
2747 /*
2748 * Convert a string containing C character escapes. Stop at an unescaped
2749 * space or tab.
2750 * Copy the converted version to "m->value.s", and the length in m->vallen.
2751 * Return updated scan pointer as function result. Warn if set.
2752 */
2753 private const char *
getstr(struct magic_set * ms,struct magic * m,const char * s,int warn)2754 getstr(struct magic_set *ms, struct magic *m, const char *s, int warn)
2755 {
2756 const char *origs = s;
2757 char *p = m->value.s;
2758 size_t plen = sizeof(m->value.s);
2759 char *origp = p;
2760 char *pmax = p + plen - 1;
2761 int c;
2762 int val;
2763
2764 while ((c = *s++) != '\0') {
2765 if (isspace(CAST(unsigned char, c)))
2766 break;
2767 if (p >= pmax) {
2768 file_error(ms, 0, "string too long: `%s'", origs);
2769 return NULL;
2770 }
2771 if (c == '\\') {
2772 switch(c = *s++) {
2773
2774 case '\0':
2775 if (warn)
2776 file_magwarn(ms, "incomplete escape");
2777 s--;
2778 goto out;
2779
2780 case '\t':
2781 if (warn) {
2782 file_magwarn(ms,
2783 "escaped tab found, use \\t instead");
2784 warn = 0; /* already did */
2785 }
2786 /*FALLTHROUGH*/
2787 default:
2788 if (warn) {
2789 if (isprint(CAST(unsigned char, c))) {
2790 /* Allow escaping of
2791 * ``relations'' */
2792 if (strchr("<>&^=!", c) == NULL
2793 && (m->type != FILE_REGEX ||
2794 strchr("[]().*?^$|{}", c)
2795 == NULL)) {
2796 file_magwarn(ms, "no "
2797 "need to escape "
2798 "`%c'", c);
2799 }
2800 } else {
2801 file_magwarn(ms,
2802 "unknown escape sequence: "
2803 "\\%03o", c);
2804 }
2805 }
2806 /*FALLTHROUGH*/
2807 /* space, perhaps force people to use \040? */
2808 case ' ':
2809 #if 0
2810 /*
2811 * Other things people escape, but shouldn't need to,
2812 * so we disallow them
2813 */
2814 case '\'':
2815 case '"':
2816 case '?':
2817 #endif
2818 /* Relations */
2819 case '>':
2820 case '<':
2821 case '&':
2822 case '^':
2823 case '=':
2824 case '!':
2825 /* and baskslash itself */
2826 case '\\':
2827 *p++ = CAST(char, c);
2828 break;
2829
2830 case 'a':
2831 *p++ = '\a';
2832 break;
2833
2834 case 'b':
2835 *p++ = '\b';
2836 break;
2837
2838 case 'f':
2839 *p++ = '\f';
2840 break;
2841
2842 case 'n':
2843 *p++ = '\n';
2844 break;
2845
2846 case 'r':
2847 *p++ = '\r';
2848 break;
2849
2850 case 't':
2851 *p++ = '\t';
2852 break;
2853
2854 case 'v':
2855 *p++ = '\v';
2856 break;
2857
2858 /* \ and up to 3 octal digits */
2859 case '0':
2860 case '1':
2861 case '2':
2862 case '3':
2863 case '4':
2864 case '5':
2865 case '6':
2866 case '7':
2867 val = c - '0';
2868 c = *s++; /* try for 2 */
2869 if (c >= '0' && c <= '7') {
2870 val = (val << 3) | (c - '0');
2871 c = *s++; /* try for 3 */
2872 if (c >= '0' && c <= '7')
2873 val = (val << 3) | (c-'0');
2874 else
2875 --s;
2876 }
2877 else
2878 --s;
2879 *p++ = CAST(char, val);
2880 break;
2881
2882 /* \x and up to 2 hex digits */
2883 case 'x':
2884 val = 'x'; /* Default if no digits */
2885 c = hextoint(*s++); /* Get next char */
2886 if (c >= 0) {
2887 val = c;
2888 c = hextoint(*s++);
2889 if (c >= 0)
2890 val = (val << 4) + c;
2891 else
2892 --s;
2893 } else
2894 --s;
2895 *p++ = CAST(char, val);
2896 break;
2897 }
2898 } else
2899 *p++ = CAST(char, c);
2900 }
2901 --s;
2902 out:
2903 *p = '\0';
2904 m->vallen = CAST(unsigned char, (p - origp));
2905 if (m->type == FILE_PSTRING) {
2906 size_t l = file_pstring_length_size(ms, m);
2907 if (l == FILE_BADSIZE)
2908 return NULL;
2909 m->vallen += CAST(unsigned char, l);
2910 }
2911 return s;
2912 }
2913
2914
2915 /* Single hex char to int; -1 if not a hex char. */
2916 private int
hextoint(int c)2917 hextoint(int c)
2918 {
2919 if (!isascii(CAST(unsigned char, c)))
2920 return -1;
2921 if (isdigit(CAST(unsigned char, c)))
2922 return c - '0';
2923 if ((c >= 'a') && (c <= 'f'))
2924 return c + 10 - 'a';
2925 if (( c>= 'A') && (c <= 'F'))
2926 return c + 10 - 'A';
2927 return -1;
2928 }
2929
2930
2931 /*
2932 * Print a string containing C character escapes.
2933 */
2934 protected void
file_showstr(FILE * fp,const char * s,size_t len)2935 file_showstr(FILE *fp, const char *s, size_t len)
2936 {
2937 char c;
2938
2939 for (;;) {
2940 if (len == FILE_BADSIZE) {
2941 c = *s++;
2942 if (c == '\0')
2943 break;
2944 }
2945 else {
2946 if (len-- == 0)
2947 break;
2948 c = *s++;
2949 }
2950 if (c >= 040 && c <= 0176) /* TODO isprint && !iscntrl */
2951 (void) fputc(c, fp);
2952 else {
2953 (void) fputc('\\', fp);
2954 switch (c) {
2955 case '\a':
2956 (void) fputc('a', fp);
2957 break;
2958
2959 case '\b':
2960 (void) fputc('b', fp);
2961 break;
2962
2963 case '\f':
2964 (void) fputc('f', fp);
2965 break;
2966
2967 case '\n':
2968 (void) fputc('n', fp);
2969 break;
2970
2971 case '\r':
2972 (void) fputc('r', fp);
2973 break;
2974
2975 case '\t':
2976 (void) fputc('t', fp);
2977 break;
2978
2979 case '\v':
2980 (void) fputc('v', fp);
2981 break;
2982
2983 default:
2984 (void) fprintf(fp, "%.3o", c & 0377);
2985 break;
2986 }
2987 }
2988 }
2989 }
2990
2991 /*
2992 * eatsize(): Eat the size spec from a number [eg. 10UL]
2993 */
2994 private void
eatsize(const char ** p)2995 eatsize(const char **p)
2996 {
2997 const char *l = *p;
2998
2999 if (LOWCASE(*l) == 'u')
3000 l++;
3001
3002 switch (LOWCASE(*l)) {
3003 case 'l': /* long */
3004 case 's': /* short */
3005 case 'h': /* short */
3006 case 'b': /* char/byte */
3007 case 'c': /* char/byte */
3008 l++;
3009 /*FALLTHROUGH*/
3010 default:
3011 break;
3012 }
3013
3014 *p = l;
3015 }
3016
3017 /*
3018 * handle a compiled file.
3019 */
3020
3021 private struct magic_map *
apprentice_map(struct magic_set * ms,const char * fn)3022 apprentice_map(struct magic_set *ms, const char *fn)
3023 {
3024 uint32_t *ptr;
3025 uint32_t version, entries = 0, nentries;
3026 int needsbyteswap;
3027 char *dbname = NULL;
3028 struct magic_map *map;
3029 size_t i;
3030 php_stream *stream = NULL;
3031 php_stream_statbuf st;
3032
3033
3034
3035 if ((map = CAST(struct magic_map *, ecalloc(1, sizeof(*map)))) == NULL) {
3036 file_oomem(ms, sizeof(*map));
3037 return NULL;
3038 }
3039
3040 if (fn == NULL) {
3041 map->p = (void *)&php_magic_database;
3042 goto internal_loaded;
3043 }
3044
3045 #ifdef PHP_WIN32
3046 /* Don't bother on windows with php_stream_open_wrapper,
3047 return to give apprentice_load() a chance. */
3048 if (php_stream_stat_path_ex((char *)fn, 0, &st, NULL) == SUCCESS) {
3049 if (st.sb.st_mode & S_IFDIR) {
3050 goto error;
3051 }
3052 }
3053 #endif
3054
3055 dbname = mkdbname(ms, fn, 0);
3056 if (dbname == NULL)
3057 goto error;
3058
3059 stream = php_stream_open_wrapper((char *)fn, "rb", REPORT_ERRORS, NULL);
3060
3061 if (!stream) {
3062 goto error;
3063 }
3064
3065 #ifndef PHP_WIN32
3066 if (php_stream_stat(stream, &st) < 0) {
3067 file_error(ms, errno, "cannot stat `%s'", dbname);
3068 goto error;
3069 }
3070 #endif
3071 if (st.sb.st_size < 8 || st.sb.st_size > maxoff_t()) {
3072 file_error(ms, 0, "file `%s' is too %s", dbname,
3073 st.sb.st_size < 8 ? "small" : "large");
3074 goto error;
3075 }
3076
3077 map->type = MAP_TYPE_MALLOC;
3078 map->len = CAST(size_t, st.sb.st_size);
3079 map->p = CAST(void *, emalloc(map->len));
3080
3081 if (php_stream_read(stream, map->p, (size_t)st.sb.st_size) != (size_t)st.sb.st_size) {
3082 file_badread(ms);
3083 goto error;
3084 }
3085
3086 php_stream_close(stream);
3087 stream = NULL;
3088
3089 internal_loaded:
3090 ptr = (uint32_t *)(void *)map->p;
3091 if (*ptr != MAGICNO) {
3092 if (swap4(*ptr) != MAGICNO) {
3093 file_error(ms, 0, "bad magic in `%s'", dbname);
3094 goto error;
3095 }
3096 needsbyteswap = 1;
3097 } else
3098 needsbyteswap = 0;
3099 if (needsbyteswap)
3100 version = swap4(ptr[1]);
3101 else
3102 version = ptr[1];
3103 if (version != VERSIONNO) {
3104 file_error(ms, 0, "File %d.%d supports only version %d magic "
3105 "files. `%s' is version %d", FILE_VERSION_MAJOR, patchlevel,
3106 VERSIONNO, dbname, version);
3107 goto error;
3108 }
3109
3110 /* php_magic_database is a const, performing writes will segfault. This is for big-endian
3111 machines only, PPC and Sparc specifically. Consider static variable or MINIT in
3112 future. */
3113 if (needsbyteswap && fn == NULL) {
3114 map->p = emalloc(sizeof(php_magic_database));
3115 map->p = memcpy(map->p, php_magic_database, sizeof(php_magic_database));
3116 }
3117
3118 if (NULL != fn) {
3119 nentries = (uint32_t)(st.sb.st_size / sizeof(struct magic));
3120 entries = (uint32_t)(st.sb.st_size / sizeof(struct magic));
3121 if ((zend_off_t)(entries * sizeof(struct magic)) != st.sb.st_size) {
3122 file_error(ms, 0, "Size of `%s' %llu is not a multiple of %zu",
3123 dbname, (unsigned long long)st.sb.st_size,
3124 sizeof(struct magic));
3125 goto error;
3126 }
3127 }
3128 map->magic[0] = CAST(struct magic *, map->p) + 1;
3129 nentries = 0;
3130 for (i = 0; i < MAGIC_SETS; i++) {
3131 if (needsbyteswap)
3132 map->nmagic[i] = swap4(ptr[i + 2]);
3133 else
3134 map->nmagic[i] = ptr[i + 2];
3135 if (i != MAGIC_SETS - 1)
3136 map->magic[i + 1] = map->magic[i] + map->nmagic[i];
3137 nentries += map->nmagic[i];
3138 }
3139 if (NULL != fn && entries != nentries + 1) {
3140 file_error(ms, 0, "Inconsistent entries in `%s' %u != %u",
3141 dbname, entries, nentries + 1);
3142 goto error;
3143 }
3144 if (needsbyteswap)
3145 for (i = 0; i < MAGIC_SETS; i++)
3146 byteswap(map->magic[i], map->nmagic[i]);
3147
3148 if (dbname) {
3149 efree(dbname);
3150 }
3151 return map;
3152
3153 error:
3154 if (stream) {
3155 php_stream_close(stream);
3156 }
3157 apprentice_unmap(map);
3158 if (dbname) {
3159 efree(dbname);
3160 }
3161 return NULL;
3162 }
3163
3164 /*
3165 * handle an mmaped file.
3166 */
3167 private int
apprentice_compile(struct magic_set * ms,struct magic_map * map,const char * fn)3168 apprentice_compile(struct magic_set *ms, struct magic_map *map, const char *fn)
3169 {
3170 static const size_t nm = sizeof(*map->nmagic) * MAGIC_SETS;
3171 static const size_t m = sizeof(**map->magic);
3172 size_t len;
3173 char *dbname;
3174 int rv = -1;
3175 uint32_t i;
3176 union {
3177 struct magic m;
3178 uint32_t h[2 + MAGIC_SETS];
3179 } hdr;
3180 php_stream *stream;
3181
3182 dbname = mkdbname(ms, fn, 1);
3183
3184 if (dbname == NULL)
3185 goto out;
3186
3187 /* wb+ == O_WRONLY|O_CREAT|O_TRUNC|O_BINARY */
3188 stream = php_stream_open_wrapper((char *)fn, "wb+", REPORT_ERRORS, NULL);
3189
3190 if (!stream) {
3191 file_error(ms, errno, "cannot open `%s'", dbname);
3192 goto out;
3193 }
3194 memset(&hdr, 0, sizeof(hdr));
3195 hdr.h[0] = MAGICNO;
3196 hdr.h[1] = VERSIONNO;
3197 memcpy(hdr.h + 2, map->nmagic, nm);
3198
3199 if (php_stream_write(stream,(const char *)&hdr, sizeof(hdr)) != (ssize_t)sizeof(hdr)) {
3200 file_error(ms, errno, "error writing `%s'", dbname);
3201 goto out;
3202 }
3203
3204 for (i = 0; i < MAGIC_SETS; i++) {
3205 len = m * map->nmagic[i];
3206 if (php_stream_write(stream, (const char *)map->magic[i], len) != (ssize_t)len) {
3207 file_error(ms, errno, "error writing `%s'", dbname);
3208 goto out;
3209 }
3210 }
3211
3212 if (stream) {
3213 php_stream_close(stream);
3214 }
3215 rv = 0;
3216 out:
3217 efree(dbname);
3218 return rv;
3219 }
3220
3221 private const char ext[] = ".mgc";
3222 /*
3223 * make a dbname
3224 */
3225 private char *
mkdbname(struct magic_set * ms,const char * fn,int strip)3226 mkdbname(struct magic_set *ms, const char *fn, int strip)
3227 {
3228 const char *p, *q;
3229 char *buf;
3230
3231 if (strip) {
3232 if ((p = strrchr(fn, '/')) != NULL)
3233 fn = ++p;
3234 }
3235
3236 for (q = fn; *q; q++)
3237 continue;
3238 /* Look for .mgc */
3239 for (p = ext + sizeof(ext) - 1; p >= ext && q >= fn; p--, q--)
3240 if (*p != *q)
3241 break;
3242
3243 /* Did not find .mgc, restore q */
3244 if (p >= ext)
3245 while (*q)
3246 q++;
3247
3248 q++;
3249 /* Compatibility with old code that looked in .mime */
3250 if (ms->flags & MAGIC_MIME) {
3251 spprintf(&buf, MAXPATHLEN, "%.*s.mime%s", CAST(int, q - fn), fn, ext);
3252 #ifdef PHP_WIN32
3253 if (VCWD_ACCESS(buf, R_OK) == 0) {
3254 #else
3255 if (VCWD_ACCESS(buf, R_OK) != -1) {
3256 #endif
3257 ms->flags &= MAGIC_MIME_TYPE;
3258 return buf;
3259 }
3260 efree(buf);
3261 }
3262 spprintf(&buf, MAXPATHLEN, "%.*s%s", CAST(int, q - fn), fn, ext);
3263
3264 /* Compatibility with old code that looked in .mime */
3265 if (strstr(fn, ".mime") != NULL)
3266 ms->flags &= MAGIC_MIME_TYPE;
3267 return buf;
3268 }
3269
3270 /*
3271 * Byteswap an mmap'ed file if needed
3272 */
3273 private void
3274 byteswap(struct magic *magic, uint32_t nmagic)
3275 {
3276 uint32_t i;
3277 for (i = 0; i < nmagic; i++)
3278 bs1(&magic[i]);
3279 }
3280
3281 /*
3282 * swap a short
3283 */
3284 private uint16_t
3285 swap2(uint16_t sv)
3286 {
3287 uint16_t rv;
3288 uint8_t *s = RCAST(uint8_t *, RCAST(void *, &sv));
3289 uint8_t *d = RCAST(uint8_t *, RCAST(void *, &rv));
3290 d[0] = s[1];
3291 d[1] = s[0];
3292 return rv;
3293 }
3294
3295 /*
3296 * swap an int
3297 */
3298 private uint32_t
3299 swap4(uint32_t sv)
3300 {
3301 uint32_t rv;
3302 uint8_t *s = RCAST(uint8_t *, RCAST(void *, &sv));
3303 uint8_t *d = RCAST(uint8_t *, RCAST(void *, &rv));
3304 d[0] = s[3];
3305 d[1] = s[2];
3306 d[2] = s[1];
3307 d[3] = s[0];
3308 return rv;
3309 }
3310
3311 /*
3312 * swap a quad
3313 */
3314 private uint64_t
3315 swap8(uint64_t sv)
3316 {
3317 uint64_t rv;
3318 uint8_t *s = RCAST(uint8_t *, RCAST(void *, &sv));
3319 uint8_t *d = RCAST(uint8_t *, RCAST(void *, &rv));
3320 #if 0
3321 d[0] = s[3];
3322 d[1] = s[2];
3323 d[2] = s[1];
3324 d[3] = s[0];
3325 d[4] = s[7];
3326 d[5] = s[6];
3327 d[6] = s[5];
3328 d[7] = s[4];
3329 #else
3330 d[0] = s[7];
3331 d[1] = s[6];
3332 d[2] = s[5];
3333 d[3] = s[4];
3334 d[4] = s[3];
3335 d[5] = s[2];
3336 d[6] = s[1];
3337 d[7] = s[0];
3338 #endif
3339 return rv;
3340 }
3341
3342 /*
3343 * byteswap a single magic entry
3344 */
3345 private void
3346 bs1(struct magic *m)
3347 {
3348 m->cont_level = swap2(m->cont_level);
3349 m->offset = swap4(CAST(uint32_t, m->offset));
3350 m->in_offset = swap4(CAST(uint32_t, m->in_offset));
3351 m->lineno = swap4(CAST(uint32_t, m->lineno));
3352 if (IS_LIBMAGIC_STRING(m->type)) {
3353 m->str_range = swap4(m->str_range);
3354 m->str_flags = swap4(m->str_flags);
3355 }
3356 else {
3357 m->value.q = swap8(m->value.q);
3358 m->num_mask = swap8(m->num_mask);
3359 }
3360 }
3361
3362 protected size_t
3363 file_pstring_length_size(struct magic_set *ms, const struct magic *m)
3364 {
3365 switch (m->str_flags & PSTRING_LEN) {
3366 case PSTRING_1_LE:
3367 return 1;
3368 case PSTRING_2_LE:
3369 case PSTRING_2_BE:
3370 return 2;
3371 case PSTRING_4_LE:
3372 case PSTRING_4_BE:
3373 return 4;
3374 default:
3375 file_error(ms, 0, "corrupt magic file "
3376 "(bad pascal string length %d)",
3377 m->str_flags & PSTRING_LEN);
3378 return FILE_BADSIZE;
3379 }
3380 }
3381 protected size_t
3382 file_pstring_get_length(struct magic_set *ms, const struct magic *m,
3383 const char *ss)
3384 {
3385 size_t len = 0;
3386 const unsigned char *s = RCAST(const unsigned char *, ss);
3387 unsigned int s3, s2, s1, s0;
3388
3389 switch (m->str_flags & PSTRING_LEN) {
3390 case PSTRING_1_LE:
3391 len = *s;
3392 break;
3393 case PSTRING_2_LE:
3394 s0 = s[0];
3395 s1 = s[1];
3396 len = (s1 << 8) | s0;
3397 break;
3398 case PSTRING_2_BE:
3399 s0 = s[0];
3400 s1 = s[1];
3401 len = (s0 << 8) | s1;
3402 break;
3403 case PSTRING_4_LE:
3404 s0 = s[0];
3405 s1 = s[1];
3406 s2 = s[2];
3407 s3 = s[3];
3408 len = (s3 << 24) | (s2 << 16) | (s1 << 8) | s0;
3409 break;
3410 case PSTRING_4_BE:
3411 s0 = s[0];
3412 s1 = s[1];
3413 s2 = s[2];
3414 s3 = s[3];
3415 len = (s0 << 24) | (s1 << 16) | (s2 << 8) | s3;
3416 break;
3417 default:
3418 file_error(ms, 0, "corrupt magic file "
3419 "(bad pascal string length %d)",
3420 m->str_flags & PSTRING_LEN);
3421 return FILE_BADSIZE;
3422 }
3423
3424 if (m->str_flags & PSTRING_LENGTH_INCLUDES_ITSELF) {
3425 size_t l = file_pstring_length_size(ms, m);
3426 if (l == FILE_BADSIZE)
3427 return l;
3428 len -= l;
3429 }
3430
3431 return len;
3432 }
3433
3434 protected int
3435 file_magicfind(struct magic_set *ms, const char *name, struct mlist *v)
3436 {
3437 uint32_t i, j;
3438 struct mlist *mlist, *ml;
3439
3440 mlist = ms->mlist[1];
3441
3442 for (ml = mlist->next; ml != mlist; ml = ml->next) {
3443 struct magic *ma = ml->magic;
3444 uint32_t nma = ml->nmagic;
3445 for (i = 0; i < nma; i++) {
3446 if (ma[i].type != FILE_NAME)
3447 continue;
3448 if (strcmp(ma[i].value.s, name) == 0) {
3449 v->magic = &ma[i];
3450 for (j = i + 1; j < nma; j++)
3451 if (ma[j].cont_level == 0)
3452 break;
3453 v->nmagic = j - i;
3454 return 0;
3455 }
3456 }
3457 }
3458 return -1;
3459 }
3460