Upgrade to file-4.18.
[dragonfly.git] / contrib / file-4 / src / apprentice.c
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 "file.h"
33 #include "magic.h"
34 #include <stdlib.h>
35 #ifdef HAVE_UNISTD_H
36 #include <unistd.h>
37 #endif
38 #include <string.h>
39 #include <ctype.h>
40 #include <fcntl.h>
41 #include <sys/stat.h>
42 #include <sys/param.h>
43 #ifdef QUICK
44 #include <sys/mman.h>
45 #endif
46
47 #ifndef lint
48 FILE_RCSID("@(#)$Id: apprentice.c,v 1.84 2005/03/25 18:03:18 christos Exp $")
49 #endif  /* lint */
50
51 #define EATAB {while (isascii((unsigned char) *l) && \
52                       isspace((unsigned char) *l))  ++l;}
53 #define LOWCASE(l) (isupper((unsigned char) (l)) ? \
54                         tolower((unsigned char) (l)) : (l))
55 /*
56  * Work around a bug in headers on Digital Unix.
57  * At least confirmed for: OSF1 V4.0 878
58  */
59 #if defined(__osf__) && defined(__DECC)
60 #ifdef MAP_FAILED
61 #undef MAP_FAILED
62 #endif
63 #endif
64
65 #ifndef MAP_FAILED
66 #define MAP_FAILED (void *) -1
67 #endif
68
69 #ifndef MAP_FILE
70 #define MAP_FILE 0
71 #endif
72
73 #ifndef MAXPATHLEN
74 #define MAXPATHLEN      1024
75 #endif
76
77 #define IS_PLAINSTRING(t) ((t) == FILE_STRING || (t) == FILE_PSTRING || \
78     (t) == FILE_BESTRING16 || (t) == FILE_LESTRING16)
79     
80 #define IS_STRING(t) (IS_PLAINSTRING(t) || (t) == FILE_REGEX || \
81     (t) == FILE_SEARCH)
82
83 private int getvalue(struct magic_set *ms, struct magic *, char **);
84 private int hextoint(int);
85 private char *getstr(struct magic_set *, char *, char *, int, int *);
86 private int parse(struct magic_set *, struct magic **, uint32_t *, char *, int);
87 private void eatsize(char **);
88 private int apprentice_1(struct magic_set *, const char *, int, struct mlist *);
89 private int apprentice_file(struct magic_set *, struct magic **, uint32_t *,
90     const char *, int);
91 private void byteswap(struct magic *, uint32_t);
92 private void bs1(struct magic *);
93 private uint16_t swap2(uint16_t);
94 private uint32_t swap4(uint32_t);
95 private char *mkdbname(const char *, char *, size_t, int);
96 private int apprentice_map(struct magic_set *, struct magic **, uint32_t *,
97     const char *);
98 private int apprentice_compile(struct magic_set *, struct magic **, uint32_t *,
99     const char *);
100 private int check_format(struct magic_set *, struct magic *);
101
102 private size_t maxmagic = 0;
103 private size_t magicsize = sizeof(struct magic);
104
105 #ifdef COMPILE_ONLY
106
107 int main(int, char *[]);
108
109 int
110 main(int argc, char *argv[])
111 {
112         int ret;
113         struct magic_set *ms;
114         char *progname;
115
116         if ((progname = strrchr(argv[0], '/')) != NULL)
117                 progname++;
118         else
119                 progname = argv[0];
120
121         if (argc != 2) {
122                 (void)fprintf(stderr, "Usage: %s file\n", progname);
123                 return 1;
124         }
125
126         if ((ms = magic_open(MAGIC_CHECK)) == NULL) {
127                 (void)fprintf(stderr, "%s: %s\n", progname, strerror(errno));
128                 return 1;
129         }
130         ret = magic_compile(ms, argv[1]) == -1 ? 1 : 0;
131         if (ret == 1)
132                 (void)fprintf(stderr, "%s: %s\n", progname, magic_error(ms));
133         magic_close(ms);
134         return ret;
135 }
136 #endif /* COMPILE_ONLY */
137
138
139 /*
140  * Handle one file.
141  */
142 private int
143 apprentice_1(struct magic_set *ms, const char *fn, int action,
144     struct mlist *mlist)
145 {
146         struct magic *magic = NULL;
147         uint32_t nmagic = 0;
148         struct mlist *ml;
149         int rv = -1;
150         int mapped;
151
152         if (magicsize != FILE_MAGICSIZE) {
153                 file_error(ms, 0, "magic element size %lu != %lu",
154                     (unsigned long)sizeof(*magic),
155                     (unsigned long)FILE_MAGICSIZE);
156                 return -1;
157         }
158
159         if (action == FILE_COMPILE) {
160                 rv = apprentice_file(ms, &magic, &nmagic, fn, action);
161                 if (rv != 0)
162                         return -1;
163                 rv = apprentice_compile(ms, &magic, &nmagic, fn);
164                 free(magic);
165                 return rv;
166         }
167 #ifndef COMPILE_ONLY
168         if ((rv = apprentice_map(ms, &magic, &nmagic, fn)) == -1) {
169                 if (ms->flags & MAGIC_CHECK)
170                         file_magwarn(ms, "using regular magic file `%s'", fn);
171                 rv = apprentice_file(ms, &magic, &nmagic, fn, action);
172                 if (rv != 0)
173                         return -1;
174                 mapped = 0;
175         }
176
177         if (rv == -1)
178                 return rv;
179         mapped = rv;
180              
181         if (magic == NULL || nmagic == 0) {
182                 file_delmagic(magic, mapped, nmagic);
183                 return -1;
184         }
185
186         if ((ml = malloc(sizeof(*ml))) == NULL) {
187                 file_delmagic(magic, mapped, nmagic);
188                 file_oomem(ms);
189                 return -1;
190         }
191
192         ml->magic = magic;
193         ml->nmagic = nmagic;
194         ml->mapped = mapped;
195
196         mlist->prev->next = ml;
197         ml->prev = mlist->prev;
198         ml->next = mlist;
199         mlist->prev = ml;
200
201         return 0;
202 #endif /* COMPILE_ONLY */
203 }
204
205 protected void
206 file_delmagic(struct magic *p, int type, size_t entries)
207 {
208         if (p == NULL)
209                 return;
210         switch (type) {
211         case 2:
212                 p--;
213                 (void)munmap((void *)p, sizeof(*p) * (entries + 1));
214                 break;
215         case 1:
216                 p--;
217                 /*FALLTHROUGH*/
218         case 0:
219                 free(p);
220                 break;
221         default:
222                 abort();
223         }
224 }
225
226
227 /* const char *fn: list of magic files */
228 protected struct mlist *
229 file_apprentice(struct magic_set *ms, const char *fn, int action)
230 {
231         char *p, *mfn, *afn = NULL;
232         int file_err, errs = -1;
233         struct mlist *mlist;
234
235         if (fn == NULL)
236                 fn = getenv("MAGIC");
237         if (fn == NULL)
238                 fn = MAGIC;
239
240         if ((fn = mfn = strdup(fn)) == NULL) {
241                 file_oomem(ms);
242                 return NULL;
243         }
244
245         if ((mlist = malloc(sizeof(*mlist))) == NULL) {
246                 free(mfn);
247                 file_oomem(ms);
248                 return NULL;
249         }
250         mlist->next = mlist->prev = mlist;
251
252         while (fn) {
253                 p = strchr(fn, PATHSEP);
254                 if (p)
255                         *p++ = '\0';
256                 if (*fn == '\0')
257                         break;
258                 if (ms->flags & MAGIC_MIME) {
259                         if ((afn = malloc(strlen(fn) + 5 + 1)) == NULL) {
260                                 free(mfn);
261                                 free(mlist);
262                                 file_oomem(ms);
263                                 return NULL;
264                         }
265                         (void)strcpy(afn, fn);
266                         (void)strcat(afn, ".mime");
267                         fn = afn;
268                 }
269                 file_err = apprentice_1(ms, fn, action, mlist);
270                 if (file_err > errs)
271                         errs = file_err;
272                 if (afn) {
273                         free(afn);
274                         afn = NULL;
275                 }
276                 fn = p;
277         }
278         if (errs == -1) {
279                 free(mfn);
280                 free(mlist);
281                 mlist = NULL;
282                 file_error(ms, 0, "could not find any magic files!");
283                 return NULL;
284         }
285         free(mfn);
286         return mlist;
287 }
288
289 /*
290  * parse from a file
291  * const char *fn: name of magic file
292  */
293 private int
294 apprentice_file(struct magic_set *ms, struct magic **magicp, uint32_t *nmagicp,
295     const char *fn, int action)
296 {
297         private const char hdr[] =
298                 "cont\toffset\ttype\topcode\tmask\tvalue\tdesc";
299         FILE *f;
300         char line[BUFSIZ+1];
301         int errs = 0;
302
303         f = fopen(ms->file = fn, "r");
304         if (f == NULL) {
305                 if (errno != ENOENT)
306                         file_error(ms, errno, "cannot read magic file `%s'",
307                             fn);
308                 return -1;
309         }
310
311         maxmagic = MAXMAGIS;
312         *magicp = (struct magic *) calloc(maxmagic, sizeof(struct magic));
313         if (*magicp == NULL) {
314                 (void)fclose(f);
315                 file_oomem(ms);
316                 return -1;
317         }
318
319         /* print silly verbose header for USG compat. */
320         if (action == FILE_CHECK)
321                 (void)fprintf(stderr, "%s\n", hdr);
322
323         /* parse it */
324         for (ms->line = 1; fgets(line, BUFSIZ, f) != NULL; ms->line++) {
325                 size_t len;
326                 if (line[0]=='#')       /* comment, do not parse */
327                         continue;
328                 len = strlen(line);
329                 if (len < 2) /* null line, garbage, etc */
330                         continue;
331                 line[len - 1] = '\0'; /* delete newline */
332                 if (parse(ms, magicp, nmagicp, line, action) != 0)
333                         errs = 1;
334         }
335
336         (void)fclose(f);
337         if (errs) {
338                 free(*magicp);
339                 *magicp = NULL;
340                 *nmagicp = 0;
341         }
342         return errs;
343 }
344
345 /*
346  * extend the sign bit if the comparison is to be signed
347  */
348 protected uint32_t
349 file_signextend(struct magic_set *ms, struct magic *m, uint32_t v)
350 {
351         if (!(m->flag & UNSIGNED))
352                 switch(m->type) {
353                 /*
354                  * Do not remove the casts below.  They are
355                  * vital.  When later compared with the data,
356                  * the sign extension must have happened.
357                  */
358                 case FILE_BYTE:
359                         v = (char) v;
360                         break;
361                 case FILE_SHORT:
362                 case FILE_BESHORT:
363                 case FILE_LESHORT:
364                         v = (short) v;
365                         break;
366                 case FILE_DATE:
367                 case FILE_BEDATE:
368                 case FILE_LEDATE:
369                 case FILE_LDATE:
370                 case FILE_BELDATE:
371                 case FILE_LELDATE:
372                 case FILE_LONG:
373                 case FILE_BELONG:
374                 case FILE_LELONG:
375                         v = (int32_t) v;
376                         break;
377                 case FILE_STRING:
378                 case FILE_PSTRING:
379                 case FILE_BESTRING16:
380                 case FILE_LESTRING16:
381                 case FILE_REGEX:
382                 case FILE_SEARCH:
383                         break;
384                 default:
385                         if (ms->flags & MAGIC_CHECK)
386                             file_magwarn(ms, "cannot happen: m->type=%d\n",
387                                     m->type);
388                         return ~0U;
389                 }
390         return v;
391 }
392
393 /*
394  * parse one line from magic file, put into magic[index++] if valid
395  */
396 private int
397 parse(struct magic_set *ms, struct magic **magicp, uint32_t *nmagicp, char *l,
398     int action)
399 {
400         int i = 0;
401         struct magic *m;
402         char *t;
403         private const char *fops = FILE_OPS;
404         uint32_t val;
405
406 #define ALLOC_INCR      200
407         if (*nmagicp + 1 >= maxmagic){
408                 maxmagic += ALLOC_INCR;
409                 if ((m = (struct magic *) realloc(*magicp,
410                     sizeof(struct magic) * maxmagic)) == NULL) {
411                         file_oomem(ms);
412                         if (*magicp)
413                                 free(*magicp);
414                         return -1;
415                 }
416                 *magicp = m;
417                 memset(&(*magicp)[*nmagicp], 0, sizeof(struct magic)
418                     * ALLOC_INCR);
419         }
420         m = &(*magicp)[*nmagicp];
421         m->flag = 0;
422         m->cont_level = 0;
423
424         while (*l == '>') {
425                 ++l;            /* step over */
426                 m->cont_level++; 
427         }
428
429         if (m->cont_level != 0 && *l == '&') {
430                 ++l;            /* step over */
431                 m->flag |= OFFADD;
432         }
433         if (m->cont_level != 0 && *l == '(') {
434                 ++l;            /* step over */
435                 m->flag |= INDIR;
436                 if (m->flag & OFFADD)
437                         m->flag = (m->flag & ~OFFADD) | INDIROFFADD;
438         }
439         if (m->cont_level != 0 && *l == '&') {
440                 ++l;            /* step over */
441                 m->flag |= OFFADD;
442         }
443
444         /* get offset, then skip over it */
445         m->offset = (uint32_t)strtoul(l, &t, 0);
446         if (l == t)
447                 if (ms->flags & MAGIC_CHECK)
448                         file_magwarn(ms, "offset `%s' invalid", l);
449         l = t;
450
451         if (m->flag & INDIR) {
452                 m->in_type = FILE_LONG;
453                 m->in_offset = 0;
454                 /*
455                  * read [.lbs][+-]nnnnn)
456                  */
457                 if (*l == '.') {
458                         l++;
459                         switch (*l) {
460                         case 'l':
461                                 m->in_type = FILE_LELONG;
462                                 break;
463                         case 'L':
464                                 m->in_type = FILE_BELONG;
465                                 break;
466                         case 'h':
467                         case 's':
468                                 m->in_type = FILE_LESHORT;
469                                 break;
470                         case 'H':
471                         case 'S':
472                                 m->in_type = FILE_BESHORT;
473                                 break;
474                         case 'c':
475                         case 'b':
476                         case 'C':
477                         case 'B':
478                                 m->in_type = FILE_BYTE;
479                                 break;
480                         default:
481                                 if (ms->flags & MAGIC_CHECK)
482                                         file_magwarn(ms,
483                                             "indirect offset type `%c' invalid",
484                                             *l);
485                                 break;
486                         }
487                         l++;
488                 }
489                 if (*l == '~') {
490                         m->in_op |= FILE_OPINVERSE;
491                         l++;
492                 }
493                 switch (*l) {
494                 case '&':
495                         m->in_op |= FILE_OPAND;
496                         l++;
497                         break;
498                 case '|':
499                         m->in_op |= FILE_OPOR;
500                         l++;
501                         break;
502                 case '^':
503                         m->in_op |= FILE_OPXOR;
504                         l++;
505                         break;
506                 case '+':
507                         m->in_op |= FILE_OPADD;
508                         l++;
509                         break;
510                 case '-':
511                         m->in_op |= FILE_OPMINUS;
512                         l++;
513                         break;
514                 case '*':
515                         m->in_op |= FILE_OPMULTIPLY;
516                         l++;
517                         break;
518                 case '/':
519                         m->in_op |= FILE_OPDIVIDE;
520                         l++;
521                         break;
522                 case '%':
523                         m->in_op |= FILE_OPMODULO;
524                         l++;
525                         break;
526                 }
527                 if (*l == '(') {
528                         m->in_op |= FILE_OPINDIRECT;
529                         l++;
530                 }
531                 if (isdigit((unsigned char)*l) || *l == '-') 
532                         m->in_offset = (int32_t)strtol(l, &t, 0);
533                 else
534                         t = l;
535                 if (*t++ != ')' ||
536                     ((m->in_op & FILE_OPINDIRECT) && *t++ != ')')) 
537                         if (ms->flags & MAGIC_CHECK)
538                                 file_magwarn(ms,
539                                     "missing ')' in indirect offset");
540                 l = t;
541         }
542
543
544         while (isascii((unsigned char)*l) && isdigit((unsigned char)*l))
545                 ++l;
546         EATAB;
547
548 #define NBYTE           4
549 #define NSHORT          5
550 #define NLONG           4
551 #define NSTRING         6
552 #define NDATE           4
553 #define NBESHORT        7
554 #define NBELONG         6
555 #define NBEDATE         6
556 #define NLESHORT        7
557 #define NLELONG         6
558 #define NLEDATE         6
559 #define NPSTRING        7
560 #define NLDATE          5
561 #define NBELDATE        7
562 #define NLELDATE        7
563 #define NREGEX          5
564 #define NBESTRING16     10
565 #define NLESTRING16     10
566 #define NSEARCH         6
567
568         if (*l == 'u') {
569                 ++l;
570                 m->flag |= UNSIGNED;
571         }
572
573         /* get type, skip it */
574         if (strncmp(l, "char", NBYTE)==0) {     /* HP/UX compat */
575                 m->type = FILE_BYTE;
576                 l += NBYTE;
577         } else if (strncmp(l, "byte", NBYTE)==0) {
578                 m->type = FILE_BYTE;
579                 l += NBYTE;
580         } else if (strncmp(l, "short", NSHORT)==0) {
581                 m->type = FILE_SHORT;
582                 l += NSHORT;
583         } else if (strncmp(l, "long", NLONG)==0) {
584                 m->type = FILE_LONG;
585                 l += NLONG;
586         } else if (strncmp(l, "string", NSTRING)==0) {
587                 m->type = FILE_STRING;
588                 l += NSTRING;
589         } else if (strncmp(l, "date", NDATE)==0) {
590                 m->type = FILE_DATE;
591                 l += NDATE;
592         } else if (strncmp(l, "beshort", NBESHORT)==0) {
593                 m->type = FILE_BESHORT;
594                 l += NBESHORT;
595         } else if (strncmp(l, "belong", NBELONG)==0) {
596                 m->type = FILE_BELONG;
597                 l += NBELONG;
598         } else if (strncmp(l, "bedate", NBEDATE)==0) {
599                 m->type = FILE_BEDATE;
600                 l += NBEDATE;
601         } else if (strncmp(l, "leshort", NLESHORT)==0) {
602                 m->type = FILE_LESHORT;
603                 l += NLESHORT;
604         } else if (strncmp(l, "lelong", NLELONG)==0) {
605                 m->type = FILE_LELONG;
606                 l += NLELONG;
607         } else if (strncmp(l, "ledate", NLEDATE)==0) {
608                 m->type = FILE_LEDATE;
609                 l += NLEDATE;
610         } else if (strncmp(l, "pstring", NPSTRING)==0) {
611                 m->type = FILE_PSTRING;
612                 l += NPSTRING;
613         } else if (strncmp(l, "ldate", NLDATE)==0) {
614                 m->type = FILE_LDATE;
615                 l += NLDATE;
616         } else if (strncmp(l, "beldate", NBELDATE)==0) {
617                 m->type = FILE_BELDATE;
618                 l += NBELDATE;
619         } else if (strncmp(l, "leldate", NLELDATE)==0) {
620                 m->type = FILE_LELDATE;
621                 l += NLELDATE;
622         } else if (strncmp(l, "regex", NREGEX)==0) {
623                 m->type = FILE_REGEX;
624                 l += NREGEX;
625         } else if (strncmp(l, "bestring16", NBESTRING16)==0) {
626                 m->type = FILE_BESTRING16;
627                 l += NBESTRING16;
628         } else if (strncmp(l, "lestring16", NLESTRING16)==0) {
629                 m->type = FILE_LESTRING16;
630                 l += NLESTRING16;
631         } else if (strncmp(l, "search", NSEARCH)==0) {
632                 m->type = FILE_SEARCH;
633                 l += NSEARCH;
634         } else {
635                 if (ms->flags & MAGIC_CHECK)
636                         file_magwarn(ms, "type `%s' invalid", l);
637                 return -1;
638         }
639         /* New-style anding: "0 byte&0x80 =0x80 dynamically linked" */
640         /* New and improved: ~ & | ^ + - * / % -- exciting, isn't it? */
641         if (*l == '~') {
642                 if (!IS_STRING(m->type))
643                         m->mask_op |= FILE_OPINVERSE;
644                 ++l;
645         }
646         if ((t = strchr(fops,  *l)) != NULL) {
647                 uint32_t op = (uint32_t)(t - fops);
648                 if (op != FILE_OPDIVIDE || !IS_PLAINSTRING(m->type)) {
649                         ++l;
650                         m->mask_op |= op;
651                         val = (uint32_t)strtoul(l, &l, 0);
652                         m->mask = file_signextend(ms, m, val);
653                         eatsize(&l);
654                 } else {
655                         m->mask = 0L;
656                         while (!isspace((unsigned char)*++l)) {
657                                 switch (*l) {
658                                 case CHAR_IGNORE_LOWERCASE:
659                                         m->mask |= STRING_IGNORE_LOWERCASE;
660                                         break;
661                                 case CHAR_COMPACT_BLANK:
662                                         m->mask |= STRING_COMPACT_BLANK;
663                                         break;
664                                 case CHAR_COMPACT_OPTIONAL_BLANK:
665                                         m->mask |=
666                                             STRING_COMPACT_OPTIONAL_BLANK;
667                                         break;
668                                 default:
669                                         if (ms->flags & MAGIC_CHECK)
670                                                 file_magwarn(ms,
671                                                 "string extension `%c' invalid",
672                                                 *l);
673                                         return -1;
674                                 }
675                         }
676                         ++l;
677                 }
678         }
679         /*
680          * We used to set mask to all 1's here, instead let's just not do
681          * anything if mask = 0 (unless you have a better idea)
682          */
683         EATAB;
684   
685         switch (*l) {
686         case '>':
687         case '<':
688         /* Old-style anding: "0 byte &0x80 dynamically linked" */
689         case '&':
690         case '^':
691         case '=':
692                 m->reln = *l;
693                 ++l;
694                 if (*l == '=') {
695                    /* HP compat: ignore &= etc. */
696                    ++l;
697                 }
698                 break;
699         case '!':
700                 m->reln = *l;
701                 ++l;
702                 break;
703         default:
704                 if (*l == 'x' && ((isascii((unsigned char)l[1]) && 
705                     isspace((unsigned char)l[1])) || !l[1])) {
706                         m->reln = *l;
707                         ++l;
708                         goto GetDesc;   /* Bill The Cat */
709                 }
710                 m->reln = '=';
711                 break;
712         }
713         EATAB;
714   
715         if (getvalue(ms, m, &l))
716                 return -1;
717         /*
718          * TODO finish this macro and start using it!
719          * #define offsetcheck {if (offset > HOWMANY-1) 
720          *      magwarn("offset too big"); }
721          */
722
723         /*
724          * now get last part - the description
725          */
726 GetDesc:
727         EATAB;
728         if (l[0] == '\b') {
729                 ++l;
730                 m->nospflag = 1;
731         } else if ((l[0] == '\\') && (l[1] == 'b')) {
732                 ++l;
733                 ++l;
734                 m->nospflag = 1;
735         } else
736                 m->nospflag = 0;
737         while ((m->desc[i++] = *l++) != '\0' && i < MAXDESC)
738                 /* NULLBODY */;
739
740         if (ms->flags & MAGIC_CHECK) {
741                 if (!check_format(ms, m))
742                         return -1;
743         }
744 #ifndef COMPILE_ONLY
745         if (action == FILE_CHECK) {
746                 file_mdump(m);
747         }
748 #endif
749         ++(*nmagicp);           /* make room for next */
750         return 0;
751 }
752
753 /*
754  * Check that the optional printf format in description matches
755  * the type of the magic.
756  */
757 private int
758 check_format(struct magic_set *ms, struct magic *m)
759 {
760         static const char *formats[] = { FILE_FORMAT_STRING };
761         static const char *names[] = { FILE_FORMAT_NAME };
762         char *ptr;
763
764         for (ptr = m->desc; *ptr; ptr++)
765                 if (*ptr == '%')
766                         break;
767         if (*ptr == '\0') {
768                 /* No format string; ok */
769                 return 1;
770         }
771         if (m->type >= sizeof(formats)/sizeof(formats[0])) {
772                 file_magwarn(ms, "Internal error inconsistency between m->type"
773                     " and format strings");
774                 return 0;
775         }
776         if (formats[m->type] == NULL) {
777                 file_magwarn(ms, "No format string for `%s' with description "
778                     "`%s'", m->desc, names[m->type]);
779                 return 0;
780         }
781         for (; *ptr; ptr++) {
782                 if (*ptr == 'l' || *ptr == 'h') {
783                         /* XXX: we should really fix this one day */
784                         continue;
785                 }
786                 if (islower((unsigned char)*ptr) || *ptr == 'X')
787                         break;
788         }
789         if (*ptr == '\0') {
790                 /* Missing format string; bad */
791                 file_magwarn(ms, "Invalid format `%s' for type `%s'",
792                         m->desc, names[m->type]);
793                 return 0;
794         }
795         if (strchr(formats[m->type], *ptr) == NULL) {
796                 file_magwarn(ms, "Printf format `%c' is not valid for type `%s'"
797                     " in description `%s'",
798                         *ptr, names[m->type], m->desc);
799                 return 0;
800         }
801         return 1;
802 }
803
804 /* 
805  * Read a numeric value from a pointer, into the value union of a magic 
806  * pointer, according to the magic type.  Update the string pointer to point 
807  * just after the number read.  Return 0 for success, non-zero for failure.
808  */
809 private int
810 getvalue(struct magic_set *ms, struct magic *m, char **p)
811 {
812         int slen;
813
814         switch (m->type) {
815         case FILE_BESTRING16:
816         case FILE_LESTRING16:
817         case FILE_STRING:
818         case FILE_PSTRING:
819         case FILE_REGEX:
820         case FILE_SEARCH:
821                 *p = getstr(ms, *p, m->value.s, sizeof(m->value.s), &slen);
822                 if (*p == NULL) {
823                         if (ms->flags & MAGIC_CHECK)
824                                 file_magwarn(ms, "cannot get string from `%s'",
825                                     m->value.s);
826                         return -1;
827                 }
828                 m->vallen = slen;
829                 return 0;
830         default:
831                 if (m->reln != 'x') {
832                         m->value.l = file_signextend(ms, m,
833                             (uint32_t)strtoul(*p, p, 0));
834                         eatsize(p);
835                 }
836                 return 0;
837         }
838 }
839
840 /*
841  * Convert a string containing C character escapes.  Stop at an unescaped
842  * space or tab.
843  * Copy the converted version to "p", returning its length in *slen.
844  * Return updated scan pointer as function result.
845  */
846 private char *
847 getstr(struct magic_set *ms, char *s, char *p, int plen, int *slen)
848 {
849         char    *origs = s, *origp = p;
850         char    *pmax = p + plen - 1;
851         int     c;
852         int     val;
853
854         while ((c = *s++) != '\0') {
855                 if (isspace((unsigned char) c))
856                         break;
857                 if (p >= pmax) {
858                         file_error(ms, 0, "string too long: `%s'", origs);
859                         return NULL;
860                 }
861                 if(c == '\\') {
862                         switch(c = *s++) {
863
864                         case '\0':
865                                 goto out;
866
867                         default:
868                                 *p++ = (char) c;
869                                 break;
870
871                         case 'n':
872                                 *p++ = '\n';
873                                 break;
874
875                         case 'r':
876                                 *p++ = '\r';
877                                 break;
878
879                         case 'b':
880                                 *p++ = '\b';
881                                 break;
882
883                         case 't':
884                                 *p++ = '\t';
885                                 break;
886
887                         case 'f':
888                                 *p++ = '\f';
889                                 break;
890
891                         case 'v':
892                                 *p++ = '\v';
893                                 break;
894
895                         /* \ and up to 3 octal digits */
896                         case '0':
897                         case '1':
898                         case '2':
899                         case '3':
900                         case '4':
901                         case '5':
902                         case '6':
903                         case '7':
904                                 val = c - '0';
905                                 c = *s++;  /* try for 2 */
906                                 if(c >= '0' && c <= '7') {
907                                         val = (val<<3) | (c - '0');
908                                         c = *s++;  /* try for 3 */
909                                         if(c >= '0' && c <= '7')
910                                                 val = (val<<3) | (c-'0');
911                                         else
912                                                 --s;
913                                 }
914                                 else
915                                         --s;
916                                 *p++ = (char)val;
917                                 break;
918
919                         /* \x and up to 2 hex digits */
920                         case 'x':
921                                 val = 'x';      /* Default if no digits */
922                                 c = hextoint(*s++);     /* Get next char */
923                                 if (c >= 0) {
924                                         val = c;
925                                         c = hextoint(*s++);
926                                         if (c >= 0)
927                                                 val = (val << 4) + c;
928                                         else
929                                                 --s;
930                                 } else
931                                         --s;
932                                 *p++ = (char)val;
933                                 break;
934                         }
935                 } else
936                         *p++ = (char)c;
937         }
938 out:
939         *p = '\0';
940         *slen = p - origp;
941         return s;
942 }
943
944
945 /* Single hex char to int; -1 if not a hex char. */
946 private int
947 hextoint(int c)
948 {
949         if (!isascii((unsigned char) c))
950                 return -1;
951         if (isdigit((unsigned char) c))
952                 return c - '0';
953         if ((c >= 'a')&&(c <= 'f'))
954                 return c + 10 - 'a';
955         if (( c>= 'A')&&(c <= 'F'))
956                 return c + 10 - 'A';
957         return -1;
958 }
959
960
961 /*
962  * Print a string containing C character escapes.
963  */
964 protected void
965 file_showstr(FILE *fp, const char *s, size_t len)
966 {
967         char    c;
968
969         for (;;) {
970                 c = *s++;
971                 if (len == ~0U) {
972                         if (c == '\0')
973                                 break;
974                 }
975                 else  {
976                         if (len-- == 0)
977                                 break;
978                 }
979                 if(c >= 040 && c <= 0176)       /* TODO isprint && !iscntrl */
980                         (void) fputc(c, fp);
981                 else {
982                         (void) fputc('\\', fp);
983                         switch (c) {
984                         
985                         case '\n':
986                                 (void) fputc('n', fp);
987                                 break;
988
989                         case '\r':
990                                 (void) fputc('r', fp);
991                                 break;
992
993                         case '\b':
994                                 (void) fputc('b', fp);
995                                 break;
996
997                         case '\t':
998                                 (void) fputc('t', fp);
999                                 break;
1000
1001                         case '\f':
1002                                 (void) fputc('f', fp);
1003                                 break;
1004
1005                         case '\v':
1006                                 (void) fputc('v', fp);
1007                                 break;
1008
1009                         default:
1010                                 (void) fprintf(fp, "%.3o", c & 0377);
1011                                 break;
1012                         }
1013                 }
1014         }
1015 }
1016
1017 /*
1018  * eatsize(): Eat the size spec from a number [eg. 10UL]
1019  */
1020 private void
1021 eatsize(char **p)
1022 {
1023         char *l = *p;
1024
1025         if (LOWCASE(*l) == 'u') 
1026                 l++;
1027
1028         switch (LOWCASE(*l)) {
1029         case 'l':    /* long */
1030         case 's':    /* short */
1031         case 'h':    /* short */
1032         case 'b':    /* char/byte */
1033         case 'c':    /* char/byte */
1034                 l++;
1035                 /*FALLTHROUGH*/
1036         default:
1037                 break;
1038         }
1039
1040         *p = l;
1041 }
1042
1043 /*
1044  * handle a compiled file.
1045  */
1046 private int
1047 apprentice_map(struct magic_set *ms, struct magic **magicp, uint32_t *nmagicp,
1048     const char *fn)
1049 {
1050         int fd;
1051         struct stat st;
1052         uint32_t *ptr;
1053         uint32_t version;
1054         int needsbyteswap;
1055         char buf[MAXPATHLEN];
1056         char *dbname = mkdbname(fn, buf, sizeof(buf), 0);
1057         void *mm = NULL;
1058
1059         if (dbname == NULL)
1060                 return -1;
1061
1062         if ((fd = open(dbname, O_RDONLY)) == -1)
1063                 return -1;
1064
1065         if (fstat(fd, &st) == -1) {
1066                 file_error(ms, errno, "cannot stat `%s'", dbname);
1067                 goto error;
1068         }
1069         if (st.st_size < 16) {
1070                 file_error(ms, 0, "file `%s' is too small", dbname);
1071                 goto error;
1072         }
1073
1074 #ifdef QUICK
1075         if ((mm = mmap(0, (size_t)st.st_size, PROT_READ|PROT_WRITE,
1076             MAP_PRIVATE|MAP_FILE, fd, (off_t)0)) == MAP_FAILED) {
1077                 file_error(ms, errno, "cannot map `%s'", dbname);
1078                 goto error;
1079         }
1080 #define RET     2
1081 #else
1082         if ((mm = malloc((size_t)st.st_size)) == NULL) {
1083                 file_oomem(ms);
1084                 goto error;
1085         }
1086         if (read(fd, mm, (size_t)st.st_size) != (size_t)st.st_size) {
1087                 file_badread(ms);
1088                 goto error;
1089         }
1090 #define RET     1
1091 #endif
1092         *magicp = mm;
1093         (void)close(fd);
1094         fd = -1;
1095         ptr = (uint32_t *)(void *)*magicp;
1096         if (*ptr != MAGICNO) {
1097                 if (swap4(*ptr) != MAGICNO) {
1098                         file_error(ms, 0, "bad magic in `%s'");
1099                         goto error;
1100                 }
1101                 needsbyteswap = 1;
1102         } else
1103                 needsbyteswap = 0;
1104         if (needsbyteswap)
1105                 version = swap4(ptr[1]);
1106         else
1107                 version = ptr[1];
1108         if (version != VERSIONNO) {
1109                 file_error(ms, 0, "version mismatch (%d != %d) in `%s'",
1110                     version, VERSIONNO, dbname);
1111                 goto error;
1112         }
1113         *nmagicp = (uint32_t)(st.st_size / sizeof(struct magic)) - 1;
1114         (*magicp)++;
1115         if (needsbyteswap)
1116                 byteswap(*magicp, *nmagicp);
1117         return RET;
1118
1119 error:
1120         if (fd != -1)
1121                 (void)close(fd);
1122         if (mm) {
1123 #ifdef QUICK
1124                 (void)munmap((void *)mm, (size_t)st.st_size);
1125 #else
1126                 free(mm);
1127 #endif
1128         } else {
1129                 *magicp = NULL;
1130                 *nmagicp = 0;
1131         }
1132         return -1;
1133 }
1134
1135 private const uint32_t ar[] = {
1136     MAGICNO, VERSIONNO
1137 };
1138 /*
1139  * handle an mmaped file.
1140  */
1141 private int
1142 apprentice_compile(struct magic_set *ms, struct magic **magicp,
1143     uint32_t *nmagicp, const char *fn)
1144 {
1145         int fd;
1146         char buf[MAXPATHLEN];
1147         char *dbname = mkdbname(fn, buf, sizeof(buf), 1);
1148
1149         if (dbname == NULL) 
1150                 return -1;
1151
1152         if ((fd = open(dbname, O_WRONLY|O_CREAT|O_TRUNC, 0644)) == -1) {
1153                 file_error(ms, errno, "cannot open `%s'", dbname);
1154                 return -1;
1155         }
1156
1157         if (write(fd, ar, sizeof(ar)) != (ssize_t)sizeof(ar)) {
1158                 file_error(ms, errno, "error writing `%s'", dbname);
1159                 return -1;
1160         }
1161
1162         if (lseek(fd, (off_t)sizeof(struct magic), SEEK_SET)
1163             != sizeof(struct magic)) {
1164                 file_error(ms, errno, "error seeking `%s'", dbname);
1165                 return -1;
1166         }
1167
1168         if (write(fd, *magicp, (sizeof(struct magic) * *nmagicp)) 
1169             != (ssize_t)(sizeof(struct magic) * *nmagicp)) {
1170                 file_error(ms, errno, "error writing `%s'", dbname);
1171                 return -1;
1172         }
1173
1174         (void)close(fd);
1175         return 0;
1176 }
1177
1178 private const char ext[] = ".mgc";
1179 /*
1180  * make a dbname
1181  */
1182 private char *
1183 mkdbname(const char *fn, char *buf, size_t bufsiz, int strip)
1184 {
1185         if (strip) {
1186                 const char *p;
1187                 if ((p = strrchr(fn, '/')) != NULL)
1188                         fn = ++p;
1189         }
1190
1191         (void)snprintf(buf, bufsiz, "%s%s", fn, ext);
1192         return buf;
1193 }
1194
1195 /*
1196  * Byteswap an mmap'ed file if needed
1197  */
1198 private void
1199 byteswap(struct magic *magic, uint32_t nmagic)
1200 {
1201         uint32_t i;
1202         for (i = 0; i < nmagic; i++)
1203                 bs1(&magic[i]);
1204 }
1205
1206 /*
1207  * swap a short
1208  */
1209 private uint16_t
1210 swap2(uint16_t sv)
1211 {
1212         uint16_t rv;
1213         uint8_t *s = (uint8_t *)(void *)&sv; 
1214         uint8_t *d = (uint8_t *)(void *)&rv; 
1215         d[0] = s[1];
1216         d[1] = s[0];
1217         return rv;
1218 }
1219
1220 /*
1221  * swap an int
1222  */
1223 private uint32_t
1224 swap4(uint32_t sv)
1225 {
1226         uint32_t rv;
1227         uint8_t *s = (uint8_t *)(void *)&sv; 
1228         uint8_t *d = (uint8_t *)(void *)&rv; 
1229         d[0] = s[3];
1230         d[1] = s[2];
1231         d[2] = s[1];
1232         d[3] = s[0];
1233         return rv;
1234 }
1235
1236 /*
1237  * byteswap a single magic entry
1238  */
1239 private void
1240 bs1(struct magic *m)
1241 {
1242         m->cont_level = swap2(m->cont_level);
1243         m->offset = swap4((uint32_t)m->offset);
1244         m->in_offset = swap4((uint32_t)m->in_offset);
1245         if (!IS_STRING(m->type))
1246                 m->value.l = swap4(m->value.l);
1247         m->mask = swap4(m->mask);
1248 }