![[BACK]](/icons/back.gif){kind=icon}
Return to softmagic.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / file|
Return to softmagic.c CVS log | Up to [local] / src / usr.bin / file |
1.1 ! deraadt 1: /*
! 2: * softmagic - interpret variable magic from /etc/magic
! 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 <string.h>
! 30: #include <time.h>
! 31: #include <sys/types.h>
! 32:
! 33: #include "file.h"
! 34:
! 35: #ifndef lint
! 36: static char *moduleid =
! 37: "@(#)$Id: softmagic.c,v 1.9 1995/05/21 00:13:32 christos Exp $";
! 38: #endif /* lint */
! 39:
! 40: static int match __P((unsigned char *, int));
! 41: static int mget __P((union VALUETYPE *,
! 42: unsigned char *, struct magic *, int));
! 43: static int mcheck __P((union VALUETYPE *, struct magic *));
! 44: static void mprint __P((union VALUETYPE *, struct magic *));
! 45: static void mdebug __P((long, char *, int));
! 46: static int mconvert __P((union VALUETYPE *, struct magic *));
! 47:
! 48: /*
! 49: * softmagic - lookup one file in database
! 50: * (already read from /etc/magic by apprentice.c).
! 51: * Passed the name and FILE * of one file to be typed.
! 52: */
! 53: /*ARGSUSED1*/ /* nbytes passed for regularity, maybe need later */
! 54: int
! 55: softmagic(buf, nbytes)
! 56: unsigned char *buf;
! 57: int nbytes;
! 58: {
! 59: if (match(buf, nbytes))
! 60: return 1;
! 61:
! 62: return 0;
! 63: }
! 64:
! 65: /*
! 66: * Go through the whole list, stopping if you find a match. Process all
! 67: * the continuations of that match before returning.
! 68: *
! 69: * We support multi-level continuations:
! 70: *
! 71: * At any time when processing a successful top-level match, there is a
! 72: * current continuation level; it represents the level of the last
! 73: * successfully matched continuation.
! 74: *
! 75: * Continuations above that level are skipped as, if we see one, it
! 76: * means that the continuation that controls them - i.e, the
! 77: * lower-level continuation preceding them - failed to match.
! 78: *
! 79: * Continuations below that level are processed as, if we see one,
! 80: * it means we've finished processing or skipping higher-level
! 81: * continuations under the control of a successful or unsuccessful
! 82: * lower-level continuation, and are now seeing the next lower-level
! 83: * continuation and should process it. The current continuation
! 84: * level reverts to the level of the one we're seeing.
! 85: *
! 86: * Continuations at the current level are processed as, if we see
! 87: * one, there's no lower-level continuation that may have failed.
! 88: *
! 89: * If a continuation matches, we bump the current continuation level
! 90: * so that higher-level continuations are processed.
! 91: */
! 92: static int
! 93: match(s, nbytes)
! 94: unsigned char *s;
! 95: int nbytes;
! 96: {
! 97: int magindex = 0;
! 98: int cont_level = 0;
! 99: int need_separator = 0;
! 100: union VALUETYPE p;
! 101:
! 102: for (magindex = 0; magindex < nmagic; magindex++) {
! 103: /* if main entry matches, print it... */
! 104: if (!mget(&p, s, &magic[magindex], nbytes) ||
! 105: !mcheck(&p, &magic[magindex])) {
! 106: /*
! 107: * main entry didn't match,
! 108: * flush its continuations
! 109: */
! 110: while (magindex < nmagic &&
! 111: magic[magindex + 1].cont_level != 0)
! 112: magindex++;
! 113: continue;
! 114: }
! 115:
! 116: mprint(&p, &magic[magindex]);
! 117: /*
! 118: * If we printed something, we'll need to print
! 119: * a blank before we print something else.
! 120: */
! 121: if (magic[magindex].desc[0])
! 122: need_separator = 1;
! 123: /* and any continuations that match */
! 124: cont_level++;
! 125: while (magic[magindex+1].cont_level != 0 &&
! 126: ++magindex < nmagic) {
! 127: if (cont_level >= magic[magindex].cont_level) {
! 128: if (cont_level > magic[magindex].cont_level) {
! 129: /*
! 130: * We're at the end of the level
! 131: * "cont_level" continuations.
! 132: */
! 133: cont_level = magic[magindex].cont_level;
! 134: }
! 135: if (mget(&p, s, &magic[magindex], nbytes) &&
! 136: mcheck(&p, &magic[magindex])) {
! 137: /*
! 138: * This continuation matched.
! 139: * Print its message, with
! 140: * a blank before it if
! 141: * the previous item printed
! 142: * and this item isn't empty.
! 143: */
! 144: /* space if previous printed */
! 145: if (need_separator
! 146: && (magic[magindex].nospflag == 0)
! 147: && (magic[magindex].desc[0] != '\0')
! 148: ) {
! 149: (void) putchar(' ');
! 150: need_separator = 0;
! 151: }
! 152: mprint(&p, &magic[magindex]);
! 153: if (magic[magindex].desc[0])
! 154: need_separator = 1;
! 155:
! 156: /*
! 157: * If we see any continuations
! 158: * at a higher level,
! 159: * process them.
! 160: */
! 161: cont_level++;
! 162: }
! 163: }
! 164: }
! 165: return 1; /* all through */
! 166: }
! 167: return 0; /* no match at all */
! 168: }
! 169:
! 170: static void
! 171: mprint(p, m)
! 172: union VALUETYPE *p;
! 173: struct magic *m;
! 174: {
! 175: char *pp, *rt;
! 176: unsigned long v;
! 177:
! 178:
! 179: switch (m->type) {
! 180: case BYTE:
! 181: v = p->b;
! 182: v = signextend(m, v) & m->mask;
! 183: (void) printf(m->desc, (unsigned char) v);
! 184: break;
! 185:
! 186: case SHORT:
! 187: case BESHORT:
! 188: case LESHORT:
! 189: v = p->h;
! 190: v = signextend(m, v) & m->mask;
! 191: (void) printf(m->desc, (unsigned short) v);
! 192: break;
! 193:
! 194: case LONG:
! 195: case BELONG:
! 196: case LELONG:
! 197: v = p->l;
! 198: v = signextend(m, v) & m->mask;
! 199: (void) printf(m->desc, (unsigned long) v);
! 200: break;
! 201:
! 202: case STRING:
! 203: if (m->reln == '=') {
! 204: (void) printf(m->desc, m->value.s);
! 205: }
! 206: else {
! 207: (void) printf(m->desc, p->s);
! 208: }
! 209: return;
! 210:
! 211: case DATE:
! 212: case BEDATE:
! 213: case LEDATE:
! 214: pp = ctime((time_t*) &p->l);
! 215: if ((rt = strchr(pp, '\n')) != NULL)
! 216: *rt = '\0';
! 217: (void) printf(m->desc, pp);
! 218: return;
! 219: default:
! 220: error("invalid m->type (%d) in mprint().\n", m->type);
! 221: /*NOTREACHED*/
! 222: }
! 223: }
! 224:
! 225: /*
! 226: * Convert the byte order of the data we are looking at
! 227: */
! 228: static int
! 229: mconvert(p, m)
! 230: union VALUETYPE *p;
! 231: struct magic *m;
! 232: {
! 233: char *rt;
! 234:
! 235: switch (m->type) {
! 236: case BYTE:
! 237: case SHORT:
! 238: case LONG:
! 239: case DATE:
! 240: return 1;
! 241: case STRING:
! 242: /* Null terminate and eat the return */
! 243: p->s[sizeof(p->s) - 1] = '\0';
! 244: if ((rt = strchr(p->s, '\n')) != NULL)
! 245: *rt = '\0';
! 246: return 1;
! 247: case BESHORT:
! 248: p->h = (short)((p->hs[0]<<8)|(p->hs[1]));
! 249: return 1;
! 250: case BELONG:
! 251: case BEDATE:
! 252: p->l = (long)
! 253: ((p->hl[0]<<24)|(p->hl[1]<<16)|(p->hl[2]<<8)|(p->hl[3]));
! 254: return 1;
! 255: case LESHORT:
! 256: p->h = (short)((p->hs[1]<<8)|(p->hs[0]));
! 257: return 1;
! 258: case LELONG:
! 259: case LEDATE:
! 260: p->l = (long)
! 261: ((p->hl[3]<<24)|(p->hl[2]<<16)|(p->hl[1]<<8)|(p->hl[0]));
! 262: return 1;
! 263: default:
! 264: error("invalid type %d in mconvert().\n", m->type);
! 265: return 0;
! 266: }
! 267: }
! 268:
! 269:
! 270: static void
! 271: mdebug(offset, str, len)
! 272: long offset;
! 273: char *str;
! 274: int len;
! 275: {
! 276: (void) fprintf(stderr, "mget @%ld: ", offset);
! 277: showstr(stderr, (char *) str, len);
! 278: (void) fputc('\n', stderr);
! 279: (void) fputc('\n', stderr);
! 280: }
! 281:
! 282: static int
! 283: mget(p, s, m, nbytes)
! 284: union VALUETYPE* p;
! 285: unsigned char *s;
! 286: struct magic *m;
! 287: int nbytes;
! 288: {
! 289: long offset = m->offset;
! 290:
! 291: if (offset + sizeof(union VALUETYPE) <= nbytes)
! 292: memcpy(p, s + offset, sizeof(union VALUETYPE));
! 293: else {
! 294: /*
! 295: * the usefulness of padding with zeroes eludes me, it
! 296: * might even cause problems
! 297: */
! 298: long have = nbytes - offset;
! 299: memset(p, 0, sizeof(union VALUETYPE));
! 300: if (have > 0)
! 301: memcpy(p, s + offset, have);
! 302: }
! 303:
! 304:
! 305: if (debug) {
! 306: mdebug(offset, (char *) p, sizeof(union VALUETYPE));
! 307: mdump(m);
! 308: }
! 309:
! 310: if (!mconvert(p, m))
! 311: return 0;
! 312:
! 313: if (m->flag & INDIR) {
! 314:
! 315: switch (m->in.type) {
! 316: case BYTE:
! 317: offset = p->b + m->in.offset;
! 318: break;
! 319: case SHORT:
! 320: offset = p->h + m->in.offset;
! 321: break;
! 322: case LONG:
! 323: offset = p->l + m->in.offset;
! 324: break;
! 325: }
! 326:
! 327: if (offset + sizeof(union VALUETYPE) > nbytes)
! 328: return 0;
! 329:
! 330: memcpy(p, s + offset, sizeof(union VALUETYPE));
! 331:
! 332: if (debug) {
! 333: mdebug(offset, (char *) p, sizeof(union VALUETYPE));
! 334: mdump(m);
! 335: }
! 336:
! 337: if (!mconvert(p, m))
! 338: return 0;
! 339: }
! 340: return 1;
! 341: }
! 342:
! 343: static int
! 344: mcheck(p, m)
! 345: union VALUETYPE* p;
! 346: struct magic *m;
! 347: {
! 348: register unsigned long l = m->value.l;
! 349: register unsigned long v;
! 350: int matched;
! 351:
! 352: if ( (m->value.s[0] == 'x') && (m->value.s[1] == '\0') ) {
! 353: fprintf(stderr, "BOINK");
! 354: return 1;
! 355: }
! 356:
! 357:
! 358: switch (m->type) {
! 359: case BYTE:
! 360: v = p->b;
! 361: break;
! 362:
! 363: case SHORT:
! 364: case BESHORT:
! 365: case LESHORT:
! 366: v = p->h;
! 367: break;
! 368:
! 369: case LONG:
! 370: case BELONG:
! 371: case LELONG:
! 372: case DATE:
! 373: case BEDATE:
! 374: case LEDATE:
! 375: v = p->l;
! 376: break;
! 377:
! 378: case STRING:
! 379: l = 0;
! 380: /* What we want here is:
! 381: * v = strncmp(m->value.s, p->s, m->vallen);
! 382: * but ignoring any nulls. bcmp doesn't give -/+/0
! 383: * and isn't universally available anyway.
! 384: */
! 385: v = 0;
! 386: {
! 387: register unsigned char *a = (unsigned char*)m->value.s;
! 388: register unsigned char *b = (unsigned char*)p->s;
! 389: register int len = m->vallen;
! 390:
! 391: while (--len >= 0)
! 392: if ((v = *b++ - *a++) != 0)
! 393: break;
! 394: }
! 395: break;
! 396: default:
! 397: error("invalid type %d in mcheck().\n", m->type);
! 398: return 0;/*NOTREACHED*/
! 399: }
! 400:
! 401: v = signextend(m, v) & m->mask;
! 402:
! 403: switch (m->reln) {
! 404: case 'x':
! 405: if (debug)
! 406: (void) fprintf(stderr, "%lu == *any* = 1\n", v);
! 407: matched = 1;
! 408: break;
! 409:
! 410: case '!':
! 411: matched = v != l;
! 412: if (debug)
! 413: (void) fprintf(stderr, "%lu != %lu = %d\n",
! 414: v, l, matched);
! 415: break;
! 416:
! 417: case '=':
! 418: matched = v == l;
! 419: if (debug)
! 420: (void) fprintf(stderr, "%lu == %lu = %d\n",
! 421: v, l, matched);
! 422: break;
! 423:
! 424: case '>':
! 425: if (m->flag & UNSIGNED) {
! 426: matched = v > l;
! 427: if (debug)
! 428: (void) fprintf(stderr, "%lu > %lu = %d\n",
! 429: v, l, matched);
! 430: }
! 431: else {
! 432: matched = (long) v > (long) l;
! 433: if (debug)
! 434: (void) fprintf(stderr, "%ld > %ld = %d\n",
! 435: v, l, matched);
! 436: }
! 437: break;
! 438:
! 439: case '<':
! 440: if (m->flag & UNSIGNED) {
! 441: matched = v < l;
! 442: if (debug)
! 443: (void) fprintf(stderr, "%lu < %lu = %d\n",
! 444: v, l, matched);
! 445: }
! 446: else {
! 447: matched = (long) v < (long) l;
! 448: if (debug)
! 449: (void) fprintf(stderr, "%ld < %ld = %d\n",
! 450: v, l, matched);
! 451: }
! 452: break;
! 453:
! 454: case '&':
! 455: matched = (v & l) == l;
! 456: if (debug)
! 457: (void) fprintf(stderr, "((%lx & %lx) == %lx) = %d\n",
! 458: v, l, l, matched);
! 459: break;
! 460:
! 461: case '^':
! 462: matched = (v & l) != l;
! 463: if (debug)
! 464: (void) fprintf(stderr, "((%lx & %lx) != %lx) = %d\n",
! 465: v, l, l, matched);
! 466: break;
! 467:
! 468: default:
! 469: matched = 0;
! 470: error("mcheck: can't happen: invalid relation %d.\n", m->reln);
! 471: break;/*NOTREACHED*/
! 472: }
! 473:
! 474: return matched;
! 475: }