![[BACK]](/icons/back.gif){kind=icon}
Return to apprentice.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / file|
Return to apprentice.c CVS log | Up to [local] / src / usr.bin / file |
1.1 ! deraadt 1: /*
! 2: * apprentice - make one pass through /etc/magic, learning its secrets.
! 3: *
! 4: * Copyright (c) Ian F. Darwin, 1987.
! 5: * Written by Ian F. Darwin.
! 6: *
! 7: * This software is not subject to any license of the American Telephone
! 8: * and Telegraph Company or of the Regents of the University of California.
! 9: *
! 10: * Permission is granted to anyone to use this software for any purpose on
! 11: * any computer system, and to alter it and redistribute it freely, subject
! 12: * to the following restrictions:
! 13: *
! 14: * 1. The author is not responsible for the consequences of use of this
! 15: * software, no matter how awful, even if they arise from flaws in it.
! 16: *
! 17: * 2. The origin of this software must not be misrepresented, either by
! 18: * explicit claim or by omission. Since few users ever read sources,
! 19: * credits must appear in the documentation.
! 20: *
! 21: * 3. Altered versions must be plainly marked as such, and must not be
! 22: * misrepresented as being the original software. Since few users
! 23: * ever read sources, credits must appear in the documentation.
! 24: *
! 25: * 4. This notice may not be removed or altered.
! 26: */
! 27:
! 28: #include <stdio.h>
! 29: #include <stdlib.h>
! 30: #include <string.h>
! 31: #include <ctype.h>
! 32: #include "file.h"
! 33:
! 34: #ifndef lint
! 35: static char *moduleid =
! 36: "@(#)$Id: apprentice.c,v 1.9 1995/05/21 00:13:24 christos Exp $";
! 37: #endif /* lint */
! 38:
! 39: #define EATAB {while (isascii((unsigned char) *l) && \
! 40: isspace((unsigned char) *l)) ++l;}
! 41: #define LOWCASE(l) (isupper((unsigned char) (l)) ? \
! 42: tolower((unsigned char) (l)) : (l))
! 43:
! 44:
! 45: static int getvalue __P((struct magic *, char **));
! 46: static int hextoint __P((int));
! 47: static char *getstr __P((char *, char *, int, int *));
! 48: static int parse __P((char *, int *, int));
! 49: static void eatsize __P((char **));
! 50:
! 51: static int maxmagic = 0;
! 52:
! 53:
! 54: int
! 55: apprentice(fn, check)
! 56: char *fn; /* name of magic file */
! 57: int check; /* non-zero? checking-only run. */
! 58: {
! 59: FILE *f;
! 60: char line[BUFSIZ+1];
! 61: int errs = 0;
! 62:
! 63: f = fopen(fn, "r");
! 64: if (f==NULL) {
! 65: (void) fprintf(stderr, "%s: can't read magic file %s\n",
! 66: progname, fn);
! 67: if (check)
! 68: return -1;
! 69: else
! 70: exit(1);
! 71: }
! 72:
! 73: maxmagic = MAXMAGIS;
! 74: if ((magic = (struct magic *) calloc(sizeof(struct magic), maxmagic))
! 75: == NULL) {
! 76: (void) fprintf(stderr, "%s: Out of memory.\n", progname);
! 77: if (check)
! 78: return -1;
! 79: else
! 80: exit(1);
! 81: }
! 82:
! 83: /* parse it */
! 84: if (check) /* print silly verbose header for USG compat. */
! 85: (void) printf("cont\toffset\ttype\topcode\tmask\tvalue\tdesc\n");
! 86:
! 87: for (lineno = 1;fgets(line, BUFSIZ, f) != NULL; lineno++) {
! 88: if (line[0]=='#') /* comment, do not parse */
! 89: continue;
! 90: if (strlen(line) <= (unsigned)1) /* null line, garbage, etc */
! 91: continue;
! 92: line[strlen(line)-1] = '\0'; /* delete newline */
! 93: if (parse(line, &nmagic, check) != 0)
! 94: ++errs;
! 95: }
! 96:
! 97: (void) fclose(f);
! 98: return errs ? -1 : 0;
! 99: }
! 100:
! 101: /*
! 102: * extend the sign bit if the comparison is to be signed
! 103: */
! 104: unsigned long
! 105: signextend(m, v)
! 106: struct magic *m;
! 107: unsigned long v;
! 108: {
! 109: if (!(m->flag & UNSIGNED))
! 110: switch(m->type) {
! 111: /*
! 112: * Do not remove the casts below. They are
! 113: * vital. When later compared with the data,
! 114: * the sign extension must have happened.
! 115: */
! 116: case BYTE:
! 117: v = (char) v;
! 118: break;
! 119: case SHORT:
! 120: case BESHORT:
! 121: case LESHORT:
! 122: v = (short) v;
! 123: break;
! 124: case DATE:
! 125: case BEDATE:
! 126: case LEDATE:
! 127: case LONG:
! 128: case BELONG:
! 129: case LELONG:
! 130: v = (long) v;
! 131: break;
! 132: case STRING:
! 133: break;
! 134: default:
! 135: magwarn("can't happen: m->type=%d\n",
! 136: m->type);
! 137: return -1;
! 138: }
! 139: return v;
! 140: }
! 141:
! 142: /*
! 143: * parse one line from magic file, put into magic[index++] if valid
! 144: */
! 145: static int
! 146: parse(l, ndx, check)
! 147: char *l;
! 148: int *ndx, check;
! 149: {
! 150: int i = 0, nd = *ndx;
! 151: struct magic *m;
! 152: char *t, *s;
! 153:
! 154: #define ALLOC_INCR 20
! 155: if (nd+1 >= maxmagic){
! 156: maxmagic += ALLOC_INCR;
! 157: if ((magic = (struct magic *) realloc(magic,
! 158: sizeof(struct magic) *
! 159: maxmagic)) == NULL) {
! 160: (void) fprintf(stderr, "%s: Out of memory.\n", progname);
! 161: if (check)
! 162: return -1;
! 163: else
! 164: exit(1);
! 165: }
! 166: memset(&magic[*ndx], 0, sizeof(struct magic) * ALLOC_INCR);
! 167: }
! 168: m = &magic[*ndx];
! 169: m->flag = 0;
! 170: m->cont_level = 0;
! 171:
! 172: while (*l == '>') {
! 173: ++l; /* step over */
! 174: m->cont_level++;
! 175: }
! 176:
! 177: if (m->cont_level != 0 && *l == '(') {
! 178: ++l; /* step over */
! 179: m->flag |= INDIR;
! 180: }
! 181:
! 182: /* get offset, then skip over it */
! 183: m->offset = (int) strtoul(l,&t,0);
! 184: if (l == t)
! 185: magwarn("offset %s invalid", l);
! 186: l = t;
! 187:
! 188: if (m->flag & INDIR) {
! 189: m->in.type = LONG;
! 190: m->in.offset = 0;
! 191: /*
! 192: * read [.lbs][+-]nnnnn)
! 193: */
! 194: if (*l == '.') {
! 195: l++;
! 196: switch (LOWCASE(*l)) {
! 197: case 'l':
! 198: m->in.type = LONG;
! 199: break;
! 200: case 'h':
! 201: case 's':
! 202: m->in.type = SHORT;
! 203: break;
! 204: case 'c':
! 205: case 'b':
! 206: m->in.type = BYTE;
! 207: break;
! 208: default:
! 209: magwarn("indirect offset type %c invalid", *l);
! 210: break;
! 211: }
! 212: l++;
! 213: }
! 214: s = l;
! 215: if (*l == '+' || *l == '-') l++;
! 216: if (isdigit((unsigned char)*l)) {
! 217: m->in.offset = strtoul(l, &t, 0);
! 218: if (*s == '-') m->in.offset = - m->in.offset;
! 219: }
! 220: else
! 221: t = l;
! 222: if (*t++ != ')')
! 223: magwarn("missing ')' in indirect offset");
! 224: l = t;
! 225: }
! 226:
! 227:
! 228: while (isascii((unsigned char)*l) && isdigit((unsigned char)*l))
! 229: ++l;
! 230: EATAB;
! 231:
! 232: #define NBYTE 4
! 233: #define NSHORT 5
! 234: #define NLONG 4
! 235: #define NSTRING 6
! 236: #define NDATE 4
! 237: #define NBESHORT 7
! 238: #define NBELONG 6
! 239: #define NBEDATE 6
! 240: #define NLESHORT 7
! 241: #define NLELONG 6
! 242: #define NLEDATE 6
! 243:
! 244: if (*l == 'u') {
! 245: ++l;
! 246: m->flag |= UNSIGNED;
! 247: }
! 248:
! 249: /* get type, skip it */
! 250: if (strncmp(l, "byte", NBYTE)==0) {
! 251: m->type = BYTE;
! 252: l += NBYTE;
! 253: } else if (strncmp(l, "short", NSHORT)==0) {
! 254: m->type = SHORT;
! 255: l += NSHORT;
! 256: } else if (strncmp(l, "long", NLONG)==0) {
! 257: m->type = LONG;
! 258: l += NLONG;
! 259: } else if (strncmp(l, "string", NSTRING)==0) {
! 260: m->type = STRING;
! 261: l += NSTRING;
! 262: } else if (strncmp(l, "date", NDATE)==0) {
! 263: m->type = DATE;
! 264: l += NDATE;
! 265: } else if (strncmp(l, "beshort", NBESHORT)==0) {
! 266: m->type = BESHORT;
! 267: l += NBESHORT;
! 268: } else if (strncmp(l, "belong", NBELONG)==0) {
! 269: m->type = BELONG;
! 270: l += NBELONG;
! 271: } else if (strncmp(l, "bedate", NBEDATE)==0) {
! 272: m->type = BEDATE;
! 273: l += NBEDATE;
! 274: } else if (strncmp(l, "leshort", NLESHORT)==0) {
! 275: m->type = LESHORT;
! 276: l += NLESHORT;
! 277: } else if (strncmp(l, "lelong", NLELONG)==0) {
! 278: m->type = LELONG;
! 279: l += NLELONG;
! 280: } else if (strncmp(l, "ledate", NLEDATE)==0) {
! 281: m->type = LEDATE;
! 282: l += NLEDATE;
! 283: } else {
! 284: magwarn("type %s invalid", l);
! 285: return -1;
! 286: }
! 287: /* New-style anding: "0 byte&0x80 =0x80 dynamically linked" */
! 288: if (*l == '&') {
! 289: ++l;
! 290: m->mask = signextend(m, strtoul(l, &l, 0));
! 291: eatsize(&l);
! 292: } else
! 293: m->mask = ~0L;
! 294: EATAB;
! 295:
! 296: switch (*l) {
! 297: case '>':
! 298: case '<':
! 299: /* Old-style anding: "0 byte &0x80 dynamically linked" */
! 300: case '&':
! 301: case '^':
! 302: case '=':
! 303: m->reln = *l;
! 304: ++l;
! 305: break;
! 306: case '!':
! 307: if (m->type != STRING) {
! 308: m->reln = *l;
! 309: ++l;
! 310: break;
! 311: }
! 312: /* FALL THROUGH */
! 313: default:
! 314: if (*l == 'x' && isascii((unsigned char)l[1]) &&
! 315: isspace((unsigned char)l[1])) {
! 316: m->reln = *l;
! 317: ++l;
! 318: goto GetDesc; /* Bill The Cat */
! 319: }
! 320: m->reln = '=';
! 321: break;
! 322: }
! 323: EATAB;
! 324:
! 325: if (getvalue(m, &l))
! 326: return -1;
! 327: /*
! 328: * TODO finish this macro and start using it!
! 329: * #define offsetcheck {if (offset > HOWMANY-1)
! 330: * magwarn("offset too big"); }
! 331: */
! 332:
! 333: /*
! 334: * now get last part - the description
! 335: */
! 336: GetDesc:
! 337: EATAB;
! 338: if (l[0] == '\b') {
! 339: ++l;
! 340: m->nospflag = 1;
! 341: } else if ((l[0] == '\\') && (l[1] == 'b')) {
! 342: ++l;
! 343: ++l;
! 344: m->nospflag = 1;
! 345: } else
! 346: m->nospflag = 0;
! 347: while ((m->desc[i++] = *l++) != '\0' && i<MAXDESC)
! 348: /* NULLBODY */;
! 349:
! 350: if (check) {
! 351: mdump(m);
! 352: }
! 353: ++(*ndx); /* make room for next */
! 354: return 0;
! 355: }
! 356:
! 357: /*
! 358: * Read a numeric value from a pointer, into the value union of a magic
! 359: * pointer, according to the magic type. Update the string pointer to point
! 360: * just after the number read. Return 0 for success, non-zero for failure.
! 361: */
! 362: static int
! 363: getvalue(m, p)
! 364: struct magic *m;
! 365: char **p;
! 366: {
! 367: int slen;
! 368:
! 369: if (m->type == STRING) {
! 370: *p = getstr(*p, m->value.s, sizeof(m->value.s), &slen);
! 371: m->vallen = slen;
! 372: } else
! 373: if (m->reln != 'x') {
! 374: m->value.l = signextend(m, strtoul(*p, p, 0));
! 375: eatsize(p);
! 376: }
! 377: return 0;
! 378: }
! 379:
! 380: /*
! 381: * Convert a string containing C character escapes. Stop at an unescaped
! 382: * space or tab.
! 383: * Copy the converted version to "p", returning its length in *slen.
! 384: * Return updated scan pointer as function result.
! 385: */
! 386: static char *
! 387: getstr(s, p, plen, slen)
! 388: register char *s;
! 389: register char *p;
! 390: int plen, *slen;
! 391: {
! 392: char *origs = s, *origp = p;
! 393: char *pmax = p + plen - 1;
! 394: register int c;
! 395: register int val;
! 396:
! 397: while ((c = *s++) != '\0') {
! 398: if (isspace((unsigned char) c))
! 399: break;
! 400: if (p >= pmax) {
! 401: fprintf(stderr, "String too long: %s\n", origs);
! 402: break;
! 403: }
! 404: if(c == '\\') {
! 405: switch(c = *s++) {
! 406:
! 407: case '\0':
! 408: goto out;
! 409:
! 410: default:
! 411: *p++ = (char) c;
! 412: break;
! 413:
! 414: case 'n':
! 415: *p++ = '\n';
! 416: break;
! 417:
! 418: case 'r':
! 419: *p++ = '\r';
! 420: break;
! 421:
! 422: case 'b':
! 423: *p++ = '\b';
! 424: break;
! 425:
! 426: case 't':
! 427: *p++ = '\t';
! 428: break;
! 429:
! 430: case 'f':
! 431: *p++ = '\f';
! 432: break;
! 433:
! 434: case 'v':
! 435: *p++ = '\v';
! 436: break;
! 437:
! 438: /* \ and up to 3 octal digits */
! 439: case '0':
! 440: case '1':
! 441: case '2':
! 442: case '3':
! 443: case '4':
! 444: case '5':
! 445: case '6':
! 446: case '7':
! 447: val = c - '0';
! 448: c = *s++; /* try for 2 */
! 449: if(c >= '0' && c <= '7') {
! 450: val = (val<<3) | (c - '0');
! 451: c = *s++; /* try for 3 */
! 452: if(c >= '0' && c <= '7')
! 453: val = (val<<3) | (c-'0');
! 454: else
! 455: --s;
! 456: }
! 457: else
! 458: --s;
! 459: *p++ = (char)val;
! 460: break;
! 461:
! 462: /* \x and up to 3 hex digits */
! 463: case 'x':
! 464: val = 'x'; /* Default if no digits */
! 465: c = hextoint(*s++); /* Get next char */
! 466: if (c >= 0) {
! 467: val = c;
! 468: c = hextoint(*s++);
! 469: if (c >= 0) {
! 470: val = (val << 4) + c;
! 471: c = hextoint(*s++);
! 472: if (c >= 0) {
! 473: val = (val << 4) + c;
! 474: } else
! 475: --s;
! 476: } else
! 477: --s;
! 478: } else
! 479: --s;
! 480: *p++ = (char)val;
! 481: break;
! 482: }
! 483: } else
! 484: *p++ = (char)c;
! 485: }
! 486: out:
! 487: *p = '\0';
! 488: *slen = p - origp;
! 489: return s;
! 490: }
! 491:
! 492:
! 493: /* Single hex char to int; -1 if not a hex char. */
! 494: static int
! 495: hextoint(c)
! 496: int c;
! 497: {
! 498: if (!isascii((unsigned char) c)) return -1;
! 499: if (isdigit((unsigned char) c)) return c - '0';
! 500: if ((c>='a')&&(c<='f')) return c + 10 - 'a';
! 501: if ((c>='A')&&(c<='F')) return c + 10 - 'A';
! 502: return -1;
! 503: }
! 504:
! 505:
! 506: /*
! 507: * Print a string containing C character escapes.
! 508: */
! 509: void
! 510: showstr(fp, s, len)
! 511: FILE *fp;
! 512: const char *s;
! 513: int len;
! 514: {
! 515: register char c;
! 516:
! 517: for (;;) {
! 518: c = *s++;
! 519: if (len == -1) {
! 520: if (c == '\0')
! 521: break;
! 522: }
! 523: else {
! 524: if (len-- == 0)
! 525: break;
! 526: }
! 527: if(c >= 040 && c <= 0176) /* TODO isprint && !iscntrl */
! 528: (void) fputc(c, fp);
! 529: else {
! 530: (void) fputc('\\', fp);
! 531: switch (c) {
! 532:
! 533: case '\n':
! 534: (void) fputc('n', fp);
! 535: break;
! 536:
! 537: case '\r':
! 538: (void) fputc('r', fp);
! 539: break;
! 540:
! 541: case '\b':
! 542: (void) fputc('b', fp);
! 543: break;
! 544:
! 545: case '\t':
! 546: (void) fputc('t', fp);
! 547: break;
! 548:
! 549: case '\f':
! 550: (void) fputc('f', fp);
! 551: break;
! 552:
! 553: case '\v':
! 554: (void) fputc('v', fp);
! 555: break;
! 556:
! 557: default:
! 558: (void) fprintf(fp, "%.3o", c & 0377);
! 559: break;
! 560: }
! 561: }
! 562: }
! 563: }
! 564:
! 565: /*
! 566: * eatsize(): Eat the size spec from a number [eg. 10UL]
! 567: */
! 568: static void
! 569: eatsize(p)
! 570: char **p;
! 571: {
! 572: char *l = *p;
! 573:
! 574: if (LOWCASE(*l) == 'u')
! 575: l++;
! 576:
! 577: switch (LOWCASE(*l)) {
! 578: case 'l': /* long */
! 579: case 's': /* short */
! 580: case 'h': /* short */
! 581: case 'b': /* char/byte */
! 582: case 'c': /* char/byte */
! 583: l++;
! 584: /*FALLTHROUGH*/
! 585: default:
! 586: break;
! 587: }
! 588:
! 589: *p = l;
! 590: }