contrib/file/softmagic.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  * softmagic - interpret variable magic from MAGIC
  30  */
  31
  32 #include "file.h"
  33
  34 #ifndef lint
  35 FILE_RCSID("@(#)$File: softmagic.c,v 1.135 2009/03/27 22:42:49 christos Exp $")
  36 #endif  /* lint */
  37
  38 #include "magic.h"
  39 #include <string.h>
  40 #include <ctype.h>
  41 #include <stdlib.h>
  42 #include <time.h>
  43
  44
  45 private int match(struct magic_set *, struct magic *, uint32_t,
  46     const unsigned char *, size_t, int, int);
  47 private int mget(struct magic_set *, const unsigned char *,
  48     struct magic *, size_t, unsigned int, int);
  49 private int magiccheck(struct magic_set *, struct magic *);
  50 private int32_t mprint(struct magic_set *, struct magic *);
  51 private int32_t moffset(struct magic_set *, struct magic *);
  52 private void mdebug(uint32_t, const char *, size_t);
  53 private int mcopy(struct magic_set *, union VALUETYPE *, int, int,
  54     const unsigned char *, uint32_t, size_t, size_t);
  55 private int mconvert(struct magic_set *, struct magic *);
  56 private int print_sep(struct magic_set *, int);
  57 private int handle_annotation(struct magic_set *, struct magic *);
  58 private void cvt_8(union VALUETYPE *, const struct magic *);
  59 private void cvt_16(union VALUETYPE *, const struct magic *);
  60 private void cvt_32(union VALUETYPE *, const struct magic *);
  61 private void cvt_64(union VALUETYPE *, const struct magic *);
  62
  63 #define OFFSET_OOB(n, o, i)     ((n) < (o) || (i) > ((n) - (o)))
  64
  65 #define MAX_RECURSION_LEVEL     10
  66
  67 /*
  68  * softmagic - lookup one file in parsed, in-memory copy of database
  69  * Passed the name and FILE * of one file to be typed.
  70  */
  71 /*ARGSUSED1*/           /* nbytes passed for regularity, maybe need later */
  72 protected int
  73 file_softmagic(struct magic_set *ms, const unsigned char *buf, size_t nbytes,
  74                size_t level, int mode)
  75 {
  76         struct mlist *ml;
  77         int rv;
  78         for (ml = ms->mlist->next; ml != ms->mlist; ml = ml->next)
  79                 if ((rv = match(ms, ml->magic, ml->nmagic, buf, nbytes, mode, level)) != 0)
  80                         return rv;
  81
  82         return 0;
  83 }
  84
  85 /*
  86  * Go through the whole list, stopping if you find a match.  Process all
  87  * the continuations of that match before returning.
  88  *
  89  * We support multi-level continuations:
  90  *
  91  *      At any time when processing a successful top-level match, there is a
  92  *      current continuation level; it represents the level of the last
  93  *      successfully matched continuation.
  94  *
  95  *      Continuations above that level are skipped as, if we see one, it
  96  *      means that the continuation that controls them - i.e, the
  97  *      lower-level continuation preceding them - failed to match.
  98  *
  99  *      Continuations below that level are processed as, if we see one,
 100  *      it means we've finished processing or skipping higher-level
 101  *      continuations under the control of a successful or unsuccessful
 102  *      lower-level continuation, and are now seeing the next lower-level
 103  *      continuation and should process it.  The current continuation
 104  *      level reverts to the level of the one we're seeing.
 105  *
 106  *      Continuations at the current level are processed as, if we see
 107  *      one, there's no lower-level continuation that may have failed.
 108  *
 109  *      If a continuation matches, we bump the current continuation level
 110  *      so that higher-level continuations are processed.
 111  */
 112 private int
 113 match(struct magic_set *ms, struct magic *magic, uint32_t nmagic,
 114     const unsigned char *s, size_t nbytes, int mode, int recursion_level)
 115 {
 116         uint32_t magindex = 0;
 117         unsigned int cont_level = 0;
 118         int need_separator = 0;
 119         int returnval = 0, e; /* if a match is found it is set to 1*/
 120         int firstline = 1; /* a flag to print X\n  X\n- X */
 121         int printed_something = 0;
 122         int print = (ms->flags & (MAGIC_MIME|MAGIC_APPLE)) == 0;
 123
 124         if (file_check_mem(ms, cont_level) == -1)
 125                 return -1;
 126
 127         for (magindex = 0; magindex < nmagic; magindex++) {
 128                 int flush = 0;
 129                 struct magic *m = &magic[magindex];
 130
 131                 if ((m->flag & BINTEST) != mode) {
 132                         /* Skip sub-tests */
 133                         while (magic[magindex + 1].cont_level != 0 &&
 134                                ++magindex < nmagic)
 135                                 continue;
 136                         continue; /* Skip to next top-level test*/
 137                 }
 138
 139                 ms->offset = m->offset;
 140                 ms->line = m->lineno;
 141
 142                 /* if main entry matches, print it... */
 143                 switch (mget(ms, s, m, nbytes, cont_level, recursion_level + 1)) {
 144                 case -1:
 145                         return -1;
 146                 case 0:
 147                         flush = m->reln != '!';
 148                         break;
 149                 default:
 150                         if (m->type == FILE_INDIRECT)
 151                                 returnval = 1;
 152
 153                         switch (magiccheck(ms, m)) {
 154                         case -1:
 155                                 return -1;
 156                         case 0:
 157                                 flush++;
 158                                 break;
 159                         default:
 160                                 flush = 0;
 161                                 break;
 162                         }
 163                         break;
 164                 }
 165                 if (flush) {
 166                         /*
 167                          * main entry didn't match,
 168                          * flush its continuations
 169                          */
 170                         while (magindex < nmagic - 1 &&
 171                             magic[magindex + 1].cont_level != 0)
 172                                 magindex++;
 173                         continue;
 174                 }
 175
 176                 /*
 177                  * If we are going to print something, we'll need to print
 178                  * a blank before we print something else.
 179                  */
 180                 if (*m->desc) {
 181                         need_separator = 1;
 182                         printed_something = 1;
 183                         if ((e = handle_annotation(ms, m)) != 0)
 184                                 return e;
 185                         if (print_sep(ms, firstline) == -1)
 186                                 return -1;
 187                 }
 188
 189
 190                 if (print && mprint(ms, m) == -1)
 191                         return -1;
 192
 193                 ms->c.li[cont_level].off = moffset(ms, m);
 194
 195                 /* and any continuations that match */
 196                 if (file_check_mem(ms, ++cont_level) == -1)
 197                         return -1;
 198
 199                 while (magic[magindex+1].cont_level != 0 &&
 200                     ++magindex < nmagic) {
 201                         m = &magic[magindex];
 202                         ms->line = m->lineno; /* for messages */
 203
 204                         if (cont_level < m->cont_level)
 205                                 continue;
 206                         if (cont_level > m->cont_level) {
 207                                 /*
 208                                  * We're at the end of the level
 209                                  * "cont_level" continuations.
 210                                  */
 211                                 cont_level = m->cont_level;
 212                         }
 213                         ms->offset = m->offset;
 214                         if (m->flag & OFFADD) {
 215                                 ms->offset +=
 216                                     ms->c.li[cont_level - 1].off;
 217                         }
 218
 219 #ifdef ENABLE_CONDITIONALS
 220                         if (m->cond == COND_ELSE ||
 221                             m->cond == COND_ELIF) {
 222                                 if (ms->c.li[cont_level].last_match == 1)
 223                                         continue;
 224                         }
 225 #endif
 226                         switch (mget(ms, s, m, nbytes, cont_level, recursion_level + 1)) {
 227                         case -1:
 228                                 return -1;
 229                         case 0:
 230                                 if (m->reln != '!')
 231                                         continue;
 232                                 flush = 1;
 233                                 break;
 234                         default:
 235                                 if (m->type == FILE_INDIRECT)
 236                                         returnval = 1;
 237                                 flush = 0;
 238                                 break;
 239                         }
 240
 241                         switch (flush ? 1 : magiccheck(ms, m)) {
 242                         case -1:
 243                                 return -1;
 244                         case 0:
 245 #ifdef ENABLE_CONDITIONALS
 246                                 ms->c.li[cont_level].last_match = 0;
 247 #endif
 248                                 break;
 249                         default:
 250 #ifdef ENABLE_CONDITIONALS
 251                                 ms->c.li[cont_level].last_match = 1;
 252 #endif
 253                                 if (m->type != FILE_DEFAULT)
 254                                         ms->c.li[cont_level].got_match = 1;
 255                                 else if (ms->c.li[cont_level].got_match) {
 256                                         ms->c.li[cont_level].got_match = 0;
 257                                         break;
 258                                 }
 259                                 /*
 260                                  * If we are going to print something,
 261                                  * make sure that we have a separator first.
 262                                  */
 263                                 if (*m->desc) {
 264                                         if ((e = handle_annotation(ms, m)) != 0)
 265                                                 return e;
 266                                         if (!printed_something) {
 267                                                 printed_something = 1;
 268                                                 if (print_sep(ms, firstline)
 269                                                     == -1)
 270                                                         return -1;
 271                                         }
 272                                 }
 273                                 /*
 274                                  * This continuation matched.  Print
 275                                  * its message, with a blank before it
 276                                  * if the previous item printed and
 277                                  * this item isn't empty.
 278                                  */
 279                                 /* space if previous printed */
 280                                 if (need_separator
 281                                     && ((m->flag & NOSPACE) == 0)
 282                                     && *m->desc) {
 283                                         if (print &&
 284                                             file_printf(ms, " ") == -1)
 285                                                 return -1;
 286                                         need_separator = 0;
 287                                 }
 288                                 if (print && mprint(ms, m) == -1)
 289                                         return -1;
 290
 291                                 ms->c.li[cont_level].off = moffset(ms, m);
 292
 293                                 if (*m->desc)
 294                                         need_separator = 1;
 295
 296                                 /*
 297                                  * If we see any continuations
 298                                  * at a higher level,
 299                                  * process them.
 300                                  */
 301                                 if (file_check_mem(ms, ++cont_level) == -1)
 302                                         return -1;
 303                                 break;
 304                         }
 305                 }
 306                 if (printed_something) {
 307                         firstline = 0;
 308                         if (print)
 309                                 returnval = 1;
 310                 }
 311                 if ((ms->flags & MAGIC_CONTINUE) == 0 && printed_something) {
 312                         return returnval; /* don't keep searching */
 313                 }
 314         }
 315         return returnval;  /* This is hit if -k is set or there is no match */
 316 }
 317
 318 private int
 319 check_fmt(struct magic_set *ms, struct magic *m)
 320 {
 321         regex_t rx;
 322         int rc;
 323
 324         if (strchr(m->desc, '%') == NULL)
 325                 return 0;
 326
 327         rc = regcomp(&rx, "%[-0-9\\.]*s", REG_EXTENDED|REG_NOSUB);
 328         if (rc) {
 329                 char errmsg[512];
 330                 (void)regerror(rc, &rx, errmsg, sizeof(errmsg));
 331                 file_magerror(ms, "regex error %d, (%s)", rc, errmsg);
 332                 return -1;
 333         } else {
 334                 rc = regexec(&rx, m->desc, 0, 0, 0);
 335                 regfree(&rx);
 336                 return !rc;
 337         }
 338 }
 339
 340 #ifndef HAVE_STRNDUP
 341 char * strndup(const char *, size_t);
 342
 343 char *
 344 strndup(const char *str, size_t n)
 345 {
 346         size_t len;
 347         char *copy;
 348
 349         for (len = 0; len < n && str[len]; len++)
 350                 continue;
 351         if ((copy = malloc(len + 1)) == NULL)
 352                 return NULL;
 353         (void)memcpy(copy, str, len);
 354         copy[len] = '\0';
 355         return copy;
 356 }
 357 #endif /* HAVE_STRNDUP */
 358
 359 private int32_t
 360 mprint(struct magic_set *ms, struct magic *m)
 361 {
 362         uint64_t v;
 363         float vf;
 364         double vd;
 365         int64_t t = 0;
 366         char buf[128];
 367         union VALUETYPE *p = &ms->ms_value;
 368
 369         switch (m->type) {
 370         case FILE_BYTE:
 371                 v = file_signextend(ms, m, (uint64_t)p->b);
 372                 switch (check_fmt(ms, m)) {
 373                 case -1:
 374                         return -1;
 375                 case 1:
 376                         (void)snprintf(buf, sizeof(buf), "%c",
 377                             (unsigned char)v);
 378                         if (file_printf(ms, m->desc, buf) == -1)
 379                                 return -1;
 380                         break;
 381                 default:
 382                         if (file_printf(ms, m->desc, (unsigned char) v) == -1)
 383                                 return -1;
 384                         break;
 385                 }
 386                 t = ms->offset + sizeof(char);
 387                 break;
 388
 389         case FILE_SHORT:
 390         case FILE_BESHORT:
 391         case FILE_LESHORT:
 392                 v = file_signextend(ms, m, (uint64_t)p->h);
 393                 switch (check_fmt(ms, m)) {
 394                 case -1:
 395                         return -1;
 396                 case 1:
 397                         (void)snprintf(buf, sizeof(buf), "%hu",
 398                             (unsigned short)v);
 399                         if (file_printf(ms, m->desc, buf) == -1)
 400                                 return -1;
 401                         break;
 402                 default:
 403                         if (
 404                             file_printf(ms, m->desc, (unsigned short) v) == -1)
 405                                 return -1;
 406                         break;
 407                 }
 408                 t = ms->offset + sizeof(short);
 409                 break;
 410
 411         case FILE_LONG:
 412         case FILE_BELONG:
 413         case FILE_LELONG:
 414         case FILE_MELONG:
 415                 v = file_signextend(ms, m, (uint64_t)p->l);
 416                 switch (check_fmt(ms, m)) {
 417                 case -1:
 418                         return -1;
 419                 case 1:
 420                         (void)snprintf(buf, sizeof(buf), "%u", (uint32_t)v);
 421                         if (file_printf(ms, m->desc, buf) == -1)
 422                                 return -1;
 423                         break;
 424                 default:
 425                         if (file_printf(ms, m->desc, (uint32_t) v) == -1)
 426                                 return -1;
 427                         break;
 428                 }
 429                 t = ms->offset + sizeof(int32_t);
 430                 break;
 431
 432         case FILE_QUAD:
 433         case FILE_BEQUAD:
 434         case FILE_LEQUAD:
 435                 v = file_signextend(ms, m, p->q);
 436                 if (file_printf(ms, m->desc, (uint64_t) v) == -1)
 437                         return -1;
 438                 t = ms->offset + sizeof(int64_t);
 439                 break;
 440
 441         case FILE_STRING:
 442         case FILE_PSTRING:
 443         case FILE_BESTRING16:
 444         case FILE_LESTRING16:
 445                 if (m->reln == '=' || m->reln == '!') {
 446                         if (file_printf(ms, m->desc, m->value.s) == -1)
 447                                 return -1;
 448                         t = ms->offset + m->vallen;
 449                 }
 450                 else {
 451                         if (*m->value.s == '\0')
 452                                 p->s[strcspn(p->s, "\n")] = '\0';
 453                         if (file_printf(ms, m->desc, p->s) == -1)
 454                                 return -1;
 455                         t = ms->offset + strlen(p->s);
 456                         if (m->type == FILE_PSTRING)
 457                                 t++;
 458                 }
 459                 break;
 460
 461         case FILE_DATE:
 462         case FILE_BEDATE:
 463         case FILE_LEDATE:
 464         case FILE_MEDATE:
 465                 if (file_printf(ms, m->desc, file_fmttime(p->l, 1)) == -1)
 466                         return -1;
 467                 t = ms->offset + sizeof(time_t);
 468                 break;
 469
 470         case FILE_LDATE:
 471         case FILE_BELDATE:
 472         case FILE_LELDATE:
 473         case FILE_MELDATE:
 474                 if (file_printf(ms, m->desc, file_fmttime(p->l, 0)) == -1)
 475                         return -1;
 476                 t = ms->offset + sizeof(time_t);
 477                 break;
 478
 479         case FILE_QDATE:
 480         case FILE_BEQDATE:
 481         case FILE_LEQDATE:
 482                 if (file_printf(ms, m->desc, file_fmttime((uint32_t)p->q,
 483                     1)) == -1)
 484                         return -1;
 485                 t = ms->offset + sizeof(uint64_t);
 486                 break;
 487
 488         case FILE_QLDATE:
 489         case FILE_BEQLDATE:
 490         case FILE_LEQLDATE:
 491                 if (file_printf(ms, m->desc, file_fmttime((uint32_t)p->q,
 492                     0)) == -1)
 493                         return -1;
 494                 t = ms->offset + sizeof(uint64_t);
 495                 break;
 496
 497         case FILE_FLOAT:
 498         case FILE_BEFLOAT:
 499         case FILE_LEFLOAT:
 500                 vf = p->f;
 501                 switch (check_fmt(ms, m)) {
 502                 case -1:
 503                         return -1;
 504                 case 1:
 505                         (void)snprintf(buf, sizeof(buf), "%g", vf);
 506                         if (file_printf(ms, m->desc, buf) == -1)
 507                                 return -1;
 508                         break;
 509                 default:
 510                         if (file_printf(ms, m->desc, vf) == -1)
 511                                 return -1;
 512                         break;
 513                 }
 514                 t = ms->offset + sizeof(float);
 515                 break;
 516
 517         case FILE_DOUBLE:
 518         case FILE_BEDOUBLE:
 519         case FILE_LEDOUBLE:
 520                 vd = p->d;
 521                 switch (check_fmt(ms, m)) {
 522                 case -1:
 523                         return -1;
 524                 case 1:
 525                         (void)snprintf(buf, sizeof(buf), "%g", vd);
 526                         if (file_printf(ms, m->desc, buf) == -1)
 527                                 return -1;
 528                         break;
 529                 default:
 530                         if (file_printf(ms, m->desc, vd) == -1)
 531                                 return -1;
 532                         break;
 533                 }
 534                 t = ms->offset + sizeof(double);
 535                 break;
 536
 537         case FILE_REGEX: {
 538                 char *cp;
 539                 int rval;
 540
 541                 cp = strndup((const char *)ms->search.s, ms->search.rm_len);
 542                 if (cp == NULL) {
 543                         file_oomem(ms, ms->search.rm_len);
 544                         return -1;
 545                 }
 546                 rval = file_printf(ms, m->desc, cp);
 547                 free(cp);
 548
 549                 if (rval == -1)
 550                         return -1;
 551
 552                 if ((m->str_flags & REGEX_OFFSET_START))
 553                         t = ms->search.offset;
 554                 else
 555                         t = ms->search.offset + ms->search.rm_len;
 556                 break;
 557         }
 558
 559         case FILE_SEARCH:
 560                 if (file_printf(ms, m->desc, m->value.s) == -1)
 561                         return -1;
 562                 if ((m->str_flags & REGEX_OFFSET_START))
 563                         t = ms->search.offset;
 564                 else
 565                         t = ms->search.offset + m->vallen;
 566                 break;
 567
 568         case FILE_DEFAULT:
 569                 if (file_printf(ms, m->desc, m->value.s) == -1)
 570                         return -1;
 571                 t = ms->offset;
 572                 break;
 573
 574         case FILE_INDIRECT:
 575                 t = ms->offset;
 576                 break;
 577
 578         default:
 579                 file_magerror(ms, "invalid m->type (%d) in mprint()", m->type);
 580                 return -1;
 581         }
 582         return (int32_t)t;
 583 }
 584
 585 private int32_t
 586 moffset(struct magic_set *ms, struct magic *m)
 587 {
 588         switch (m->type) {
 589         case FILE_BYTE:
 590                 return ms->offset + sizeof(char);
 591
 592         case FILE_SHORT:
 593         case FILE_BESHORT:
 594         case FILE_LESHORT:
 595                 return ms->offset + sizeof(short);
 596
 597         case FILE_LONG:
 598         case FILE_BELONG:
 599         case FILE_LELONG:
 600         case FILE_MELONG:
 601                 return ms->offset + sizeof(int32_t);
 602
 603         case FILE_QUAD:
 604         case FILE_BEQUAD:
 605         case FILE_LEQUAD:
 606                 return ms->offset + sizeof(int64_t);
 607
 608         case FILE_STRING:
 609         case FILE_PSTRING:
 610         case FILE_BESTRING16:
 611         case FILE_LESTRING16:
 612                 if (m->reln == '=' || m->reln == '!')
 613                         return ms->offset + m->vallen;
 614                 else {
 615                         union VALUETYPE *p = &ms->ms_value;
 616                         uint32_t t;
 617
 618                         if (*m->value.s == '\0')
 619                                 p->s[strcspn(p->s, "\n")] = '\0';
 620                         t = ms->offset + strlen(p->s);
 621                         if (m->type == FILE_PSTRING)
 622                                 t++;
 623                         return t;
 624                 }
 625
 626         case FILE_DATE:
 627         case FILE_BEDATE:
 628         case FILE_LEDATE:
 629         case FILE_MEDATE:
 630                 return ms->offset + sizeof(time_t);
 631
 632         case FILE_LDATE:
 633         case FILE_BELDATE:
 634         case FILE_LELDATE:
 635         case FILE_MELDATE:
 636                 return ms->offset + sizeof(time_t);
 637
 638         case FILE_QDATE:
 639         case FILE_BEQDATE:
 640         case FILE_LEQDATE:
 641                 return ms->offset + sizeof(uint64_t);
 642
 643         case FILE_QLDATE:
 644         case FILE_BEQLDATE:
 645         case FILE_LEQLDATE:
 646                 return ms->offset + sizeof(uint64_t);
 647
 648         case FILE_FLOAT:
 649         case FILE_BEFLOAT:
 650         case FILE_LEFLOAT:
 651                 return ms->offset + sizeof(float);
 652
 653         case FILE_DOUBLE:
 654         case FILE_BEDOUBLE:
 655         case FILE_LEDOUBLE:
 656                 return ms->offset + sizeof(double);
 657                 break;
 658
 659         case FILE_REGEX:
 660                 if ((m->str_flags & REGEX_OFFSET_START) != 0)
 661                         return ms->search.offset;
 662                 else
 663                         return ms->search.offset + ms->search.rm_len;
 664
 665         case FILE_SEARCH:
 666                 if ((m->str_flags & REGEX_OFFSET_START) != 0)
 667                         return ms->search.offset;
 668                 else
 669                         return ms->search.offset + m->vallen;
 670
 671         case FILE_DEFAULT:
 672                 return ms->offset;
 673
 674         case FILE_INDIRECT:
 675                 return ms->offset;
 676
 677         default:
 678                 return 0;
 679         }
 680 }
 681
 682 #define DO_CVT(fld, cast) \
 683         if (m->num_mask) \
 684                 switch (m->mask_op & FILE_OPS_MASK) { \
 685                 case FILE_OPAND: \
 686                         p->fld &= cast m->num_mask; \
 687                         break; \
 688                 case FILE_OPOR: \
 689                         p->fld |= cast m->num_mask; \
 690                         break; \
 691                 case FILE_OPXOR: \
 692                         p->fld ^= cast m->num_mask; \
 693                         break; \
 694                 case FILE_OPADD: \
 695                         p->fld += cast m->num_mask; \
 696                         break; \
 697                 case FILE_OPMINUS: \
 698                         p->fld -= cast m->num_mask; \
 699                         break; \
 700                 case FILE_OPMULTIPLY: \
 701                         p->fld *= cast m->num_mask; \
 702                         break; \
 703                 case FILE_OPDIVIDE: \
 704                         p->fld /= cast m->num_mask; \
 705                         break; \
 706                 case FILE_OPMODULO: \
 707                         p->fld %= cast m->num_mask; \
 708                         break; \
 709                 } \
 710         if (m->mask_op & FILE_OPINVERSE) \
 711                 p->fld = ~p->fld \
 712
 713 private void
 714 cvt_8(union VALUETYPE *p, const struct magic *m)
 715 {
 716         DO_CVT(b, (uint8_t));
 717 }
 718
 719 private void
 720 cvt_16(union VALUETYPE *p, const struct magic *m)
 721 {
 722         DO_CVT(h, (uint16_t));
 723 }
 724
 725 private void
 726 cvt_32(union VALUETYPE *p, const struct magic *m)
 727 {
 728         DO_CVT(l, (uint32_t));
 729 }
 730
 731 private void
 732 cvt_64(union VALUETYPE *p, const struct magic *m)
 733 {
 734         DO_CVT(q, (uint64_t));
 735 }
 736
 737 #define DO_CVT2(fld, cast) \
 738         if (m->num_mask) \
 739                 switch (m->mask_op & FILE_OPS_MASK) { \
 740                 case FILE_OPADD: \
 741                         p->fld += cast m->num_mask; \
 742                         break; \
 743                 case FILE_OPMINUS: \
 744                         p->fld -= cast m->num_mask; \
 745                         break; \
 746                 case FILE_OPMULTIPLY: \
 747                         p->fld *= cast m->num_mask; \
 748                         break; \
 749                 case FILE_OPDIVIDE: \
 750                         p->fld /= cast m->num_mask; \
 751                         break; \
 752                 } \
 753
 754 private void
 755 cvt_float(union VALUETYPE *p, const struct magic *m)
 756 {
 757         DO_CVT2(f, (float));
 758 }
 759
 760 private void
 761 cvt_double(union VALUETYPE *p, const struct magic *m)
 762 {
 763         DO_CVT2(d, (double));
 764 }
 765
 766 /*
 767  * Convert the byte order of the data we are looking at
 768  * While we're here, let's apply the mask operation
 769  * (unless you have a better idea)
 770  */
 771 private int
 772 mconvert(struct magic_set *ms, struct magic *m)
 773 {
 774         union VALUETYPE *p = &ms->ms_value;
 775
 776         switch (m->type) {
 777         case FILE_BYTE:
 778                 cvt_8(p, m);
 779                 return 1;
 780         case FILE_SHORT:
 781                 cvt_16(p, m);
 782                 return 1;
 783         case FILE_LONG:
 784         case FILE_DATE:
 785         case FILE_LDATE:
 786                 cvt_32(p, m);
 787                 return 1;
 788         case FILE_QUAD:
 789         case FILE_QDATE:
 790         case FILE_QLDATE:
 791                 cvt_64(p, m);
 792                 return 1;
 793         case FILE_STRING:
 794         case FILE_BESTRING16:
 795         case FILE_LESTRING16: {
 796                 /* Null terminate and eat *trailing* return */
 797                 p->s[sizeof(p->s) - 1] = '\0';
 798 #if 0
 799                 /* Why? breaks magic numbers that end with \xa */
 800                 len = strlen(p->s);
 801                 if (len-- && p->s[len] == '\n')
 802                         p->s[len] = '\0';
 803 #endif
 804                 return 1;
 805         }
 806         case FILE_PSTRING: {
 807                 char *ptr1 = p->s, *ptr2 = ptr1 + 1;
 808                 size_t len = *p->s;
 809                 if (len >= sizeof(p->s))
 810                         len = sizeof(p->s) - 1;
 811                 while (len--)
 812                         *ptr1++ = *ptr2++;
 813                 *ptr1 = '\0';
 814 #if 0
 815                 /* Why? breaks magic numbers that end with \xa */
 816                 len = strlen(p->s);
 817                 if (len-- && p->s[len] == '\n')
 818                         p->s[len] = '\0';
 819 #endif
 820                 return 1;
 821         }
 822         case FILE_BESHORT:
 823                 p->h = (short)((p->hs[0]<<8)|(p->hs[1]));
 824                 cvt_16(p, m);
 825                 return 1;
 826         case FILE_BELONG:
 827         case FILE_BEDATE:
 828         case FILE_BELDATE:
 829                 p->l = (int32_t)
 830                     ((p->hl[0]<<24)|(p->hl[1]<<16)|(p->hl[2]<<8)|(p->hl[3]));
 831                 cvt_32(p, m);
 832                 return 1;
 833         case FILE_BEQUAD:
 834         case FILE_BEQDATE:
 835         case FILE_BEQLDATE:
 836                 p->q = (uint64_t)
 837                     (((uint64_t)p->hq[0]<<56)|((uint64_t)p->hq[1]<<48)|
 838                      ((uint64_t)p->hq[2]<<40)|((uint64_t)p->hq[3]<<32)|
 839                      ((uint64_t)p->hq[4]<<24)|((uint64_t)p->hq[5]<<16)|
 840                      ((uint64_t)p->hq[6]<<8)|((uint64_t)p->hq[7]));
 841                 cvt_64(p, m);
 842                 return 1;
 843         case FILE_LESHORT:
 844                 p->h = (short)((p->hs[1]<<8)|(p->hs[0]));
 845                 cvt_16(p, m);
 846                 return 1;
 847         case FILE_LELONG:
 848         case FILE_LEDATE:
 849         case FILE_LELDATE:
 850                 p->l = (int32_t)
 851                     ((p->hl[3]<<24)|(p->hl[2]<<16)|(p->hl[1]<<8)|(p->hl[0]));
 852                 cvt_32(p, m);
 853                 return 1;
 854         case FILE_LEQUAD:
 855         case FILE_LEQDATE:
 856         case FILE_LEQLDATE:
 857                 p->q = (uint64_t)
 858                     (((uint64_t)p->hq[7]<<56)|((uint64_t)p->hq[6]<<48)|
 859                      ((uint64_t)p->hq[5]<<40)|((uint64_t)p->hq[4]<<32)|
 860                      ((uint64_t)p->hq[3]<<24)|((uint64_t)p->hq[2]<<16)|
 861                      ((uint64_t)p->hq[1]<<8)|((uint64_t)p->hq[0]));
 862                 cvt_64(p, m);
 863                 return 1;
 864         case FILE_MELONG:
 865         case FILE_MEDATE:
 866         case FILE_MELDATE:
 867                 p->l = (int32_t)
 868                     ((p->hl[1]<<24)|(p->hl[0]<<16)|(p->hl[3]<<8)|(p->hl[2]));
 869                 cvt_32(p, m);
 870                 return 1;
 871         case FILE_FLOAT:
 872                 cvt_float(p, m);
 873                 return 1;
 874         case FILE_BEFLOAT:
 875                 p->l =  ((uint32_t)p->hl[0]<<24)|((uint32_t)p->hl[1]<<16)|
 876                         ((uint32_t)p->hl[2]<<8) |((uint32_t)p->hl[3]);
 877                 cvt_float(p, m);
 878                 return 1;
 879         case FILE_LEFLOAT:
 880                 p->l =  ((uint32_t)p->hl[3]<<24)|((uint32_t)p->hl[2]<<16)|
 881                         ((uint32_t)p->hl[1]<<8) |((uint32_t)p->hl[0]);
 882                 cvt_float(p, m);
 883                 return 1;
 884         case FILE_DOUBLE:
 885                 cvt_double(p, m);
 886                 return 1;
 887         case FILE_BEDOUBLE:
 888                 p->q =  ((uint64_t)p->hq[0]<<56)|((uint64_t)p->hq[1]<<48)|
 889                         ((uint64_t)p->hq[2]<<40)|((uint64_t)p->hq[3]<<32)|
 890                         ((uint64_t)p->hq[4]<<24)|((uint64_t)p->hq[5]<<16)|
 891                         ((uint64_t)p->hq[6]<<8) |((uint64_t)p->hq[7]);
 892                 cvt_double(p, m);
 893                 return 1;
 894         case FILE_LEDOUBLE:
 895                 p->q =  ((uint64_t)p->hq[7]<<56)|((uint64_t)p->hq[6]<<48)|
 896                         ((uint64_t)p->hq[5]<<40)|((uint64_t)p->hq[4]<<32)|
 897                         ((uint64_t)p->hq[3]<<24)|((uint64_t)p->hq[2]<<16)|
 898                         ((uint64_t)p->hq[1]<<8) |((uint64_t)p->hq[0]);
 899                 cvt_double(p, m);
 900                 return 1;
 901         case FILE_REGEX:
 902         case FILE_SEARCH:
 903         case FILE_DEFAULT:
 904                 return 1;
 905         default:
 906                 file_magerror(ms, "invalid type %d in mconvert()", m->type);
 907                 return 0;
 908         }
 909 }
 910
 911
 912 private void
 913 mdebug(uint32_t offset, const char *str, size_t len)
 914 {
 915         (void) fprintf(stderr, "mget @%d: ", offset);
 916         file_showstr(stderr, str, len);
 917         (void) fputc('\n', stderr);
 918         (void) fputc('\n', stderr);
 919 }
 920
 921 private int
 922 mcopy(struct magic_set *ms, union VALUETYPE *p, int type, int indir,
 923     const unsigned char *s, uint32_t offset, size_t nbytes, size_t linecnt)
 924 {
 925         /*
 926          * Note: FILE_SEARCH and FILE_REGEX do not actually copy
 927          * anything, but setup pointers into the source
 928          */
 929         if (indir == 0) {
 930                 switch (type) {
 931                 case FILE_SEARCH:
 932                         ms->search.s = (const char *)s + offset;
 933                         ms->search.s_len = nbytes - offset;
 934                         ms->search.offset = offset;
 935                         return 0;
 936
 937                 case FILE_REGEX: {
 938                         const char *b;
 939                         const char *c;
 940                         const char *last;       /* end of search region */
 941                         const char *buf;        /* start of search region */
 942                         const char *end;
 943                         size_t lines;
 944
 945                         if (s == NULL) {
 946                                 ms->search.s_len = 0;
 947                                 ms->search.s = NULL;
 948                                 return 0;
 949                         }
 950                         buf = (const char *)s + offset;
 951                         end = last = (const char *)s + nbytes;
 952                         /* mget() guarantees buf <= last */
 953                         for (lines = linecnt, b = buf;
 954                              lines && ((b = memchr(c = b, '\n', end - b)) || (b = memchr(c, '\r', end - c)));
 955                              lines--, b++) {
 956                                 last = b;
 957                                 if (b[0] == '\r' && b[1] == '\n')
 958                                         b++;
 959                         }
 960                         if (lines)
 961                                 last = (const char *)s + nbytes;
 962
 963                         ms->search.s = buf;
 964                         ms->search.s_len = last - buf;
 965                         ms->search.offset = offset;
 966                         ms->search.rm_len = 0;
 967                         return 0;
 968                 }
 969                 case FILE_BESTRING16:
 970                 case FILE_LESTRING16: {
 971                         const unsigned char *src = s + offset;
 972                         const unsigned char *esrc = s + nbytes;
 973                         char *dst = p->s;
 974                         char *edst = &p->s[sizeof(p->s) - 1];
 975
 976                         if (type == FILE_BESTRING16)
 977                                 src++;
 978
 979                         /* check for pointer overflow */
 980                         if (src < s) {
 981                                 file_magerror(ms, "invalid offset %u in mcopy()",
 982                                     offset);
 983                                 return -1;
 984                         }
 985                         for (/*EMPTY*/; src < esrc; src += 2, dst++) {
 986                                 if (dst < edst)
 987                                         *dst = *src;
 988                                 else
 989                                         break;
 990                                 if (*dst == '\0') {
 991                                         if (type == FILE_BESTRING16 ?
 992                                             *(src - 1) != '\0' :
 993                                             *(src + 1) != '\0')
 994                                                 *dst = ' ';
 995                                 }
 996                         }
 997                         *edst = '\0';
 998                         return 0;
 999                 }
1000                 case FILE_STRING:       /* XXX - these two should not need */
1001                 case FILE_PSTRING:      /* to copy anything, but do anyway. */
1002                 default:
1003                         break;
1004                 }
1005         }
1006
1007         if (offset >= nbytes) {
1008                 (void)memset(p, '\0', sizeof(*p));
1009                 return 0;
1010         }
1011         if (nbytes - offset < sizeof(*p))
1012                 nbytes = nbytes - offset;
1013         else
1014                 nbytes = sizeof(*p);
1015
1016         (void)memcpy(p, s + offset, nbytes);
1017
1018         /*
1019          * the usefulness of padding with zeroes eludes me, it
1020          * might even cause problems
1021          */
1022         if (nbytes < sizeof(*p))
1023                 (void)memset(((char *)(void *)p) + nbytes, '\0',
1024                     sizeof(*p) - nbytes);
1025         return 0;
1026 }
1027
1028 private int
1029 mget(struct magic_set *ms, const unsigned char *s,
1030     struct magic *m, size_t nbytes, unsigned int cont_level, int recursion_level)
1031 {
1032         uint32_t offset = ms->offset;
1033         uint32_t count = m->str_range;
1034         union VALUETYPE *p = &ms->ms_value;
1035
1036         if (recursion_level >= MAX_RECURSION_LEVEL) {
1037                 file_error(ms, 0, "recursion nesting exceeded");
1038                 return -1;
1039         }
1040
1041         if (mcopy(ms, p, m->type, m->flag & INDIR, s, offset, nbytes, count) == -1)
1042                 return -1;
1043
1044         if ((ms->flags & MAGIC_DEBUG) != 0) {
1045                 mdebug(offset, (char *)(void *)p, sizeof(union VALUETYPE));
1046 #ifndef COMPILE_ONLY
1047                 file_mdump(m);
1048 #endif
1049         }
1050
1051         if (m->flag & INDIR) {
1052                 int off = m->in_offset;
1053                 if (m->in_op & FILE_OPINDIRECT) {
1054                         const union VALUETYPE *q = CAST(const union VALUETYPE *,
1055                             ((const void *)(s + offset + off)));
1056                         switch (m->in_type) {
1057                         case FILE_BYTE:
1058                                 off = q->b;
1059                                 break;
1060                         case FILE_SHORT:
1061                                 off = q->h;
1062                                 break;
1063                         case FILE_BESHORT:
1064                                 off = (short)((q->hs[0]<<8)|(q->hs[1]));
1065                                 break;
1066                         case FILE_LESHORT:
1067                                 off = (short)((q->hs[1]<<8)|(q->hs[0]));
1068                                 break;
1069                         case FILE_LONG:
1070                                 off = q->l;
1071                                 break;
1072                         case FILE_BELONG:
1073                         case FILE_BEID3:
1074                                 off = (int32_t)((q->hl[0]<<24)|(q->hl[1]<<16)|
1075                                                  (q->hl[2]<<8)|(q->hl[3]));
1076                                 break;
1077                         case FILE_LEID3:
1078                         case FILE_LELONG:
1079                                 off = (int32_t)((q->hl[3]<<24)|(q->hl[2]<<16)|
1080                                                  (q->hl[1]<<8)|(q->hl[0]));
1081                                 break;
1082                         case FILE_MELONG:
1083                                 off = (int32_t)((q->hl[1]<<24)|(q->hl[0]<<16)|
1084                                                  (q->hl[3]<<8)|(q->hl[2]));
1085                                 break;
1086                         }
1087                 }
1088                 switch (m->in_type) {
1089                 case FILE_BYTE:
1090                         if (OFFSET_OOB(nbytes, offset, 1))
1091                                 return 0;
1092                         if (off) {
1093                                 switch (m->in_op & FILE_OPS_MASK) {
1094                                 case FILE_OPAND:
1095                                         offset = p->b & off;
1096                                         break;
1097                                 case FILE_OPOR:
1098                                         offset = p->b | off;
1099                                         break;
1100                                 case FILE_OPXOR:
1101                                         offset = p->b ^ off;
1102                                         break;
1103                                 case FILE_OPADD:
1104                                         offset = p->b + off;
1105                                         break;
1106                                 case FILE_OPMINUS:
1107                                         offset = p->b - off;
1108                                         break;
1109                                 case FILE_OPMULTIPLY:
1110                                         offset = p->b * off;
1111                                         break;
1112                                 case FILE_OPDIVIDE:
1113                                         offset = p->b / off;
1114                                         break;
1115                                 case FILE_OPMODULO:
1116                                         offset = p->b % off;
1117                                         break;
1118                                 }
1119                         } else
1120                                 offset = p->b;
1121                         if (m->in_op & FILE_OPINVERSE)
1122                                 offset = ~offset;
1123                         break;
1124                 case FILE_BESHORT:
1125                         if (OFFSET_OOB(nbytes, offset, 2))
1126                                 return 0;
1127                         if (off) {
1128                                 switch (m->in_op & FILE_OPS_MASK) {
1129                                 case FILE_OPAND:
1130                                         offset = (short)((p->hs[0]<<8)|
1131                                                          (p->hs[1])) &
1132                                                  off;
1133                                         break;
1134                                 case FILE_OPOR:
1135                                         offset = (short)((p->hs[0]<<8)|
1136                                                          (p->hs[1])) |
1137                                                  off;
1138                                         break;
1139                                 case FILE_OPXOR:
1140                                         offset = (short)((p->hs[0]<<8)|
1141                                                          (p->hs[1])) ^
1142                                                  off;
1143                                         break;
1144                                 case FILE_OPADD:
1145                                         offset = (short)((p->hs[0]<<8)|
1146                                                          (p->hs[1])) +
1147                                                  off;
1148                                         break;
1149                                 case FILE_OPMINUS:
1150                                         offset = (short)((p->hs[0]<<8)|
1151                                                          (p->hs[1])) -
1152                                                  off;
1153                                         break;
1154                                 case FILE_OPMULTIPLY:
1155                                         offset = (short)((p->hs[0]<<8)|
1156                                                          (p->hs[1])) *
1157                                                  off;
1158                                         break;
1159                                 case FILE_OPDIVIDE:
1160                                         offset = (short)((p->hs[0]<<8)|
1161                                                          (p->hs[1])) /
1162                                                  off;
1163                                         break;
1164                                 case FILE_OPMODULO:
1165                                         offset = (short)((p->hs[0]<<8)|
1166                                                          (p->hs[1])) %
1167                                                  off;
1168                                         break;
1169                                 }
1170                         } else
1171                                 offset = (short)((p->hs[0]<<8)|
1172                                                  (p->hs[1]));
1173                         if (m->in_op & FILE_OPINVERSE)
1174                                 offset = ~offset;
1175                         break;
1176                 case FILE_LESHORT:
1177                         if (OFFSET_OOB(nbytes, offset, 2))
1178                                 return 0;
1179                         if (off) {
1180                                 switch (m->in_op & FILE_OPS_MASK) {
1181                                 case FILE_OPAND:
1182                                         offset = (short)((p->hs[1]<<8)|
1183                                                          (p->hs[0])) &
1184                                                  off;
1185                                         break;
1186                                 case FILE_OPOR:
1187                                         offset = (short)((p->hs[1]<<8)|
1188                                                          (p->hs[0])) |
1189                                                  off;
1190                                         break;
1191                                 case FILE_OPXOR:
1192                                         offset = (short)((p->hs[1]<<8)|
1193                                                          (p->hs[0])) ^
1194                                                  off;
1195                                         break;
1196                                 case FILE_OPADD:
1197                                         offset = (short)((p->hs[1]<<8)|
1198                                                          (p->hs[0])) +
1199                                                  off;
1200                                         break;
1201                                 case FILE_OPMINUS:
1202                                         offset = (short)((p->hs[1]<<8)|
1203                                                          (p->hs[0])) -
1204                                                  off;
1205                                         break;
1206                                 case FILE_OPMULTIPLY:
1207                                         offset = (short)((p->hs[1]<<8)|
1208                                                          (p->hs[0])) *
1209                                                  off;
1210                                         break;
1211                                 case FILE_OPDIVIDE:
1212                                         offset = (short)((p->hs[1]<<8)|
1213                                                          (p->hs[0])) /
1214                                                  off;
1215                                         break;
1216                                 case FILE_OPMODULO:
1217                                         offset = (short)((p->hs[1]<<8)|
1218                                                          (p->hs[0])) %
1219                                                  off;
1220                                         break;
1221                                 }
1222                         } else
1223                                 offset = (short)((p->hs[1]<<8)|
1224                                                  (p->hs[0]));
1225                         if (m->in_op & FILE_OPINVERSE)
1226                                 offset = ~offset;
1227                         break;
1228                 case FILE_SHORT:
1229                         if (OFFSET_OOB(nbytes, offset, 2))
1230                                 return 0;
1231                         if (off) {
1232                                 switch (m->in_op & FILE_OPS_MASK) {
1233                                 case FILE_OPAND:
1234                                         offset = p->h & off;
1235                                         break;
1236                                 case FILE_OPOR:
1237                                         offset = p->h | off;
1238                                         break;
1239                                 case FILE_OPXOR:
1240                                         offset = p->h ^ off;
1241                                         break;
1242                                 case FILE_OPADD:
1243                                         offset = p->h + off;
1244                                         break;
1245                                 case FILE_OPMINUS:
1246                                         offset = p->h - off;
1247                                         break;
1248                                 case FILE_OPMULTIPLY:
1249                                         offset = p->h * off;
1250                                         break;
1251                                 case FILE_OPDIVIDE:
1252                                         offset = p->h / off;
1253                                         break;
1254                                 case FILE_OPMODULO:
1255                                         offset = p->h % off;
1256                                         break;
1257                                 }
1258                         }
1259                         else
1260                                 offset = p->h;
1261                         if (m->in_op & FILE_OPINVERSE)
1262                                 offset = ~offset;
1263                         break;
1264                 case FILE_BELONG:
1265                 case FILE_BEID3:
1266                         if (OFFSET_OOB(nbytes, offset, 4))
1267                                 return 0;
1268                         if (off) {
1269                                 switch (m->in_op & FILE_OPS_MASK) {
1270                                 case FILE_OPAND:
1271                                         offset = (int32_t)((p->hl[0]<<24)|
1272                                                          (p->hl[1]<<16)|
1273                                                          (p->hl[2]<<8)|
1274                                                          (p->hl[3])) &
1275                                                  off;
1276                                         break;
1277                                 case FILE_OPOR:
1278                                         offset = (int32_t)((p->hl[0]<<24)|
1279                                                          (p->hl[1]<<16)|
1280                                                          (p->hl[2]<<8)|
1281                                                          (p->hl[3])) |
1282                                                  off;
1283                                         break;
1284                                 case FILE_OPXOR:
1285                                         offset = (int32_t)((p->hl[0]<<24)|
1286                                                          (p->hl[1]<<16)|
1287                                                          (p->hl[2]<<8)|
1288                                                          (p->hl[3])) ^
1289                                                  off;
1290                                         break;
1291                                 case FILE_OPADD:
1292                                         offset = (int32_t)((p->hl[0]<<24)|
1293                                                          (p->hl[1]<<16)|
1294                                                          (p->hl[2]<<8)|
1295                                                          (p->hl[3])) +
1296                                                  off;
1297                                         break;
1298                                 case FILE_OPMINUS:
1299                                         offset = (int32_t)((p->hl[0]<<24)|
1300                                                          (p->hl[1]<<16)|
1301                                                          (p->hl[2]<<8)|
1302                                                          (p->hl[3])) -
1303                                                  off;
1304                                         break;
1305                                 case FILE_OPMULTIPLY:
1306                                         offset = (int32_t)((p->hl[0]<<24)|
1307                                                          (p->hl[1]<<16)|
1308                                                          (p->hl[2]<<8)|
1309                                                          (p->hl[3])) *
1310                                                  off;
1311                                         break;
1312                                 case FILE_OPDIVIDE:
1313                                         offset = (int32_t)((p->hl[0]<<24)|
1314                                                          (p->hl[1]<<16)|
1315                                                          (p->hl[2]<<8)|
1316                                                          (p->hl[3])) /
1317                                                  off;
1318                                         break;
1319                                 case FILE_OPMODULO:
1320                                         offset = (int32_t)((p->hl[0]<<24)|
1321                                                          (p->hl[1]<<16)|
1322                                                          (p->hl[2]<<8)|
1323                                                          (p->hl[3])) %
1324                                                  off;
1325                                         break;
1326                                 }
1327                         } else
1328                                 offset = (int32_t)((p->hl[0]<<24)|
1329                                                  (p->hl[1]<<16)|
1330                                                  (p->hl[2]<<8)|
1331                                                  (p->hl[3]));
1332                         if (m->in_op & FILE_OPINVERSE)
1333                                 offset = ~offset;
1334                         break;
1335                 case FILE_LELONG:
1336                 case FILE_LEID3:
1337                         if (OFFSET_OOB(nbytes, offset, 4))
1338                                 return 0;
1339                         if (off) {
1340                                 switch (m->in_op & FILE_OPS_MASK) {
1341                                 case FILE_OPAND:
1342                                         offset = (int32_t)((p->hl[3]<<24)|
1343                                                          (p->hl[2]<<16)|
1344                                                          (p->hl[1]<<8)|
1345                                                          (p->hl[0])) &
1346                                                  off;
1347                                         break;
1348                                 case FILE_OPOR:
1349                                         offset = (int32_t)((p->hl[3]<<24)|
1350                                                          (p->hl[2]<<16)|
1351                                                          (p->hl[1]<<8)|
1352                                                          (p->hl[0])) |
1353                                                  off;
1354                                         break;
1355                                 case FILE_OPXOR:
1356                                         offset = (int32_t)((p->hl[3]<<24)|
1357                                                          (p->hl[2]<<16)|
1358                                                          (p->hl[1]<<8)|
1359                                                          (p->hl[0])) ^
1360                                                  off;
1361                                         break;
1362                                 case FILE_OPADD:
1363                                         offset = (int32_t)((p->hl[3]<<24)|
1364                                                          (p->hl[2]<<16)|
1365                                                          (p->hl[1]<<8)|
1366                                                          (p->hl[0])) +
1367                                                  off;
1368                                         break;
1369                                 case FILE_OPMINUS:
1370                                         offset = (int32_t)((p->hl[3]<<24)|
1371                                                          (p->hl[2]<<16)|
1372                                                          (p->hl[1]<<8)|
1373                                                          (p->hl[0])) -
1374                                                  off;
1375                                         break;
1376                                 case FILE_OPMULTIPLY:
1377                                         offset = (int32_t)((p->hl[3]<<24)|
1378                                                          (p->hl[2]<<16)|
1379                                                          (p->hl[1]<<8)|
1380                                                          (p->hl[0])) *
1381                                                  off;
1382                                         break;
1383                                 case FILE_OPDIVIDE:
1384                                         offset = (int32_t)((p->hl[3]<<24)|
1385                                                          (p->hl[2]<<16)|
1386                                                          (p->hl[1]<<8)|
1387                                                          (p->hl[0])) /
1388                                                  off;
1389                                         break;
1390                                 case FILE_OPMODULO:
1391                                         offset = (int32_t)((p->hl[3]<<24)|
1392                                                          (p->hl[2]<<16)|
1393                                                          (p->hl[1]<<8)|
1394                                                          (p->hl[0])) %
1395                                                  off;
1396                                         break;
1397                                 }
1398                         } else
1399                                 offset = (int32_t)((p->hl[3]<<24)|
1400                                                  (p->hl[2]<<16)|
1401                                                  (p->hl[1]<<8)|
1402                                                  (p->hl[0]));
1403                         if (m->in_op & FILE_OPINVERSE)
1404                                 offset = ~offset;
1405                         break;
1406                 case FILE_MELONG:
1407                         if (OFFSET_OOB(nbytes, offset, 4))
1408                                 return 0;
1409                         if (off) {
1410                                 switch (m->in_op & FILE_OPS_MASK) {
1411                                 case FILE_OPAND:
1412                                         offset = (int32_t)((p->hl[1]<<24)|
1413                                                          (p->hl[0]<<16)|
1414                                                          (p->hl[3]<<8)|
1415                                                          (p->hl[2])) &
1416                                                  off;
1417                                         break;
1418                                 case FILE_OPOR:
1419                                         offset = (int32_t)((p->hl[1]<<24)|
1420                                                          (p->hl[0]<<16)|
1421                                                          (p->hl[3]<<8)|
1422                                                          (p->hl[2])) |
1423                                                  off;
1424                                         break;
1425                                 case FILE_OPXOR:
1426                                         offset = (int32_t)((p->hl[1]<<24)|
1427                                                          (p->hl[0]<<16)|
1428                                                          (p->hl[3]<<8)|
1429                                                          (p->hl[2])) ^
1430                                                  off;
1431                                         break;
1432                                 case FILE_OPADD:
1433                                         offset = (int32_t)((p->hl[1]<<24)|
1434                                                          (p->hl[0]<<16)|
1435                                                          (p->hl[3]<<8)|
1436                                                          (p->hl[2])) +
1437                                                  off;
1438                                         break;
1439                                 case FILE_OPMINUS:
1440                                         offset = (int32_t)((p->hl[1]<<24)|
1441                                                          (p->hl[0]<<16)|
1442                                                          (p->hl[3]<<8)|
1443                                                          (p->hl[2])) -
1444                                                  off;
1445                                         break;
1446                                 case FILE_OPMULTIPLY:
1447                                         offset = (int32_t)((p->hl[1]<<24)|
1448                                                          (p->hl[0]<<16)|
1449                                                          (p->hl[3]<<8)|
1450                                                          (p->hl[2])) *
1451                                                  off;
1452                                         break;
1453                                 case FILE_OPDIVIDE:
1454                                         offset = (int32_t)((p->hl[1]<<24)|
1455                                                          (p->hl[0]<<16)|
1456                                                          (p->hl[3]<<8)|
1457                                                          (p->hl[2])) /
1458                                                  off;
1459                                         break;
1460                                 case FILE_OPMODULO:
1461                                         offset = (int32_t)((p->hl[1]<<24)|
1462                                                          (p->hl[0]<<16)|
1463                                                          (p->hl[3]<<8)|
1464                                                          (p->hl[2])) %
1465                                                  off;
1466                                         break;
1467                                 }
1468                         } else
1469                                 offset = (int32_t)((p->hl[1]<<24)|
1470                                                  (p->hl[0]<<16)|
1471                                                  (p->hl[3]<<8)|
1472                                                  (p->hl[2]));
1473                         if (m->in_op & FILE_OPINVERSE)
1474                                 offset = ~offset;
1475                         break;
1476                 case FILE_LONG:
1477                         if (OFFSET_OOB(nbytes, offset, 4))
1478                                 return 0;
1479                         if (off) {
1480                                 switch (m->in_op & FILE_OPS_MASK) {
1481                                 case FILE_OPAND:
1482                                         offset = p->l & off;
1483                                         break;
1484                                 case FILE_OPOR:
1485                                         offset = p->l | off;
1486                                         break;
1487                                 case FILE_OPXOR:
1488                                         offset = p->l ^ off;
1489                                         break;
1490                                 case FILE_OPADD:
1491                                         offset = p->l + off;
1492                                         break;
1493                                 case FILE_OPMINUS:
1494                                         offset = p->l - off;
1495                                         break;
1496                                 case FILE_OPMULTIPLY:
1497                                         offset = p->l * off;
1498                                         break;
1499                                 case FILE_OPDIVIDE:
1500                                         offset = p->l / off;
1501                                         break;
1502                                 case FILE_OPMODULO:
1503                                         offset = p->l % off;
1504                                         break;
1505                                 }
1506                         } else
1507                                 offset = p->l;
1508                         if (m->in_op & FILE_OPINVERSE)
1509                                 offset = ~offset;
1510                         break;
1511                 }
1512
1513                 switch (m->in_type) {
1514                 case FILE_LEID3:
1515                 case FILE_BEID3:
1516                         offset = ((((offset >>  0) & 0x7f) <<  0) |
1517                                  (((offset >>  8) & 0x7f) <<  7) |
1518                                  (((offset >> 16) & 0x7f) << 14) |
1519                                  (((offset >> 24) & 0x7f) << 21)) + 10;
1520                         break;
1521                 default:
1522                         break;
1523                 }
1524
1525                 if (m->flag & INDIROFFADD) {
1526                         offset += ms->c.li[cont_level-1].off;
1527                 }
1528                 if (mcopy(ms, p, m->type, 0, s, offset, nbytes, count) == -1)
1529                         return -1;
1530                 ms->offset = offset;
1531
1532                 if ((ms->flags & MAGIC_DEBUG) != 0) {
1533                         mdebug(offset, (char *)(void *)p,
1534                             sizeof(union VALUETYPE));
1535 #ifndef COMPILE_ONLY
1536                         file_mdump(m);
1537 #endif
1538                 }
1539         }
1540
1541         /* Verify we have enough data to match magic type */
1542         switch (m->type) {
1543         case FILE_BYTE:
1544                 if (OFFSET_OOB(nbytes, offset, 1))
1545                         return 0;
1546                 break;
1547
1548         case FILE_SHORT:
1549         case FILE_BESHORT:
1550         case FILE_LESHORT:
1551                 if (OFFSET_OOB(nbytes, offset, 2))
1552                         return 0;
1553                 break;
1554
1555         case FILE_LONG:
1556         case FILE_BELONG:
1557         case FILE_LELONG:
1558         case FILE_MELONG:
1559         case FILE_DATE:
1560         case FILE_BEDATE:
1561         case FILE_LEDATE:
1562         case FILE_MEDATE:
1563         case FILE_LDATE:
1564         case FILE_BELDATE:
1565         case FILE_LELDATE:
1566         case FILE_MELDATE:
1567         case FILE_FLOAT:
1568         case FILE_BEFLOAT:
1569         case FILE_LEFLOAT:
1570                 if (OFFSET_OOB(nbytes, offset, 4))
1571                         return 0;
1572                 break;
1573
1574         case FILE_DOUBLE:
1575         case FILE_BEDOUBLE:
1576         case FILE_LEDOUBLE:
1577                 if (OFFSET_OOB(nbytes, offset, 8))
1578                         return 0;
1579                 break;
1580
1581         case FILE_STRING:
1582         case FILE_PSTRING:
1583         case FILE_SEARCH:
1584                 if (OFFSET_OOB(nbytes, offset, m->vallen))
1585                         return 0;
1586                 break;
1587
1588         case FILE_REGEX:
1589                 if (OFFSET_OOB(nbytes, offset, 0))
1590                         return 0;
1591                 break;
1592
1593         case FILE_INDIRECT:
1594                 if (offset == 0)
1595                         return 0;
1596                 if ((ms->flags & (MAGIC_MIME|MAGIC_APPLE)) == 0 &&
1597                     file_printf(ms, m->desc) == -1)
1598                         return -1;
1599                 if (OFFSET_OOB(nbytes, offset, 0))
1600                         return 0;
1601                 return file_softmagic(ms, s + offset, nbytes - offset,
1602                     recursion_level, BINTEST);
1603
1604         case FILE_DEFAULT:      /* nothing to check */
1605         default:
1606                 break;
1607         }
1608         if (!mconvert(ms, m))
1609                 return 0;
1610         return 1;
1611 }
1612
1613 private uint64_t
1614 file_strncmp(const char *s1, const char *s2, size_t len, uint32_t flags)
1615 {
1616         /*
1617          * Convert the source args to unsigned here so that (1) the
1618          * compare will be unsigned as it is in strncmp() and (2) so
1619          * the ctype functions will work correctly without extra
1620          * casting.
1621          */
1622         const unsigned char *a = (const unsigned char *)s1;
1623         const unsigned char *b = (const unsigned char *)s2;
1624         uint64_t v;
1625
1626         /*
1627          * What we want here is v = strncmp(s1, s2, len),
1628          * but ignoring any nulls.
1629          */
1630         v = 0;
1631         if (0L == flags) { /* normal string: do it fast */
1632                 while (len-- > 0)
1633                         if ((v = *b++ - *a++) != '\0')
1634                                 break;
1635         }
1636         else { /* combine the others */
1637                 while (len-- > 0) {
1638                         if ((flags & STRING_IGNORE_LOWERCASE) &&
1639                             islower(*a)) {
1640                                 if ((v = tolower(*b++) - *a++) != '\0')
1641                                         break;
1642                         }
1643                         else if ((flags & STRING_IGNORE_UPPERCASE) &&
1644                             isupper(*a)) {
1645                                 if ((v = toupper(*b++) - *a++) != '\0')
1646                                         break;
1647                         }
1648                         else if ((flags & STRING_COMPACT_BLANK) &&
1649                             isspace(*a)) {
1650                                 a++;
1651                                 if (isspace(*b++)) {
1652                                         while (isspace(*b))
1653                                                 b++;
1654                                 }
1655                                 else {
1656                                         v = 1;
1657                                         break;
1658                                 }
1659                         }
1660                         else if ((flags & STRING_COMPACT_OPTIONAL_BLANK) &&
1661                             isspace(*a)) {
1662                                 a++;
1663                                 while (isspace(*b))
1664                                         b++;
1665                         }
1666                         else {
1667                                 if ((v = *b++ - *a++) != '\0')
1668                                         break;
1669                         }
1670                 }
1671         }
1672         return v;
1673 }
1674
1675 private uint64_t
1676 file_strncmp16(const char *a, const char *b, size_t len, uint32_t flags)
1677 {
1678         /*
1679          * XXX - The 16-bit string compare probably needs to be done
1680          * differently, especially if the flags are to be supported.
1681          * At the moment, I am unsure.
1682          */
1683         flags = 0;
1684         return file_strncmp(a, b, len, flags);
1685 }
1686
1687 private int
1688 magiccheck(struct magic_set *ms, struct magic *m)
1689 {
1690         uint64_t l = m->value.q;
1691         uint64_t v;
1692         float fl, fv;
1693         double dl, dv;
1694         int matched;
1695         union VALUETYPE *p = &ms->ms_value;
1696
1697         switch (m->type) {
1698         case FILE_BYTE:
1699                 v = p->b;
1700                 break;
1701
1702         case FILE_SHORT:
1703         case FILE_BESHORT:
1704         case FILE_LESHORT:
1705                 v = p->h;
1706                 break;
1707
1708         case FILE_LONG:
1709         case FILE_BELONG:
1710         case FILE_LELONG:
1711         case FILE_MELONG:
1712         case FILE_DATE:
1713         case FILE_BEDATE:
1714         case FILE_LEDATE:
1715         case FILE_MEDATE:
1716         case FILE_LDATE:
1717         case FILE_BELDATE:
1718         case FILE_LELDATE:
1719         case FILE_MELDATE:
1720                 v = p->l;
1721                 break;
1722
1723         case FILE_QUAD:
1724         case FILE_LEQUAD:
1725         case FILE_BEQUAD:
1726         case FILE_QDATE:
1727         case FILE_BEQDATE:
1728         case FILE_LEQDATE:
1729         case FILE_QLDATE:
1730         case FILE_BEQLDATE:
1731         case FILE_LEQLDATE:
1732                 v = p->q;
1733                 break;
1734
1735         case FILE_FLOAT:
1736         case FILE_BEFLOAT:
1737         case FILE_LEFLOAT:
1738                 fl = m->value.f;
1739                 fv = p->f;
1740                 switch (m->reln) {
1741                 case 'x':
1742                         matched = 1;
1743                         break;
1744
1745                 case '!':
1746                         matched = fv != fl;
1747                         break;
1748
1749                 case '=':
1750                         matched = fv == fl;
1751                         break;
1752
1753                 case '>':
1754                         matched = fv > fl;
1755                         break;
1756
1757                 case '<':
1758                         matched = fv < fl;
1759                         break;
1760
1761                 default:
1762                         matched = 0;
1763                         file_magerror(ms, "cannot happen with float: invalid relation `%c'",
1764                             m->reln);
1765                         return -1;
1766                 }
1767                 return matched;
1768
1769         case FILE_DOUBLE:
1770         case FILE_BEDOUBLE:
1771         case FILE_LEDOUBLE:
1772                 dl = m->value.d;
1773                 dv = p->d;
1774                 switch (m->reln) {
1775                 case 'x':
1776                         matched = 1;
1777                         break;
1778
1779                 case '!':
1780                         matched = dv != dl;
1781                         break;
1782
1783                 case '=':
1784                         matched = dv == dl;
1785                         break;
1786
1787                 case '>':
1788                         matched = dv > dl;
1789                         break;
1790
1791                 case '<':
1792                         matched = dv < dl;
1793                         break;
1794
1795                 default:
1796                         matched = 0;
1797                         file_magerror(ms, "cannot happen with double: invalid relation `%c'", m->reln);
1798                         return -1;
1799                 }
1800                 return matched;
1801
1802         case FILE_DEFAULT:
1803                 l = 0;
1804                 v = 0;
1805                 break;
1806
1807         case FILE_STRING:
1808         case FILE_PSTRING:
1809                 l = 0;
1810                 v = file_strncmp(m->value.s, p->s, (size_t)m->vallen, m->str_flags);
1811                 break;
1812
1813         case FILE_BESTRING16:
1814         case FILE_LESTRING16:
1815                 l = 0;
1816                 v = file_strncmp16(m->value.s, p->s, (size_t)m->vallen, m->str_flags);
1817                 break;
1818
1819         case FILE_SEARCH: { /* search ms->search.s for the string m->value.s */
1820                 size_t slen;
1821                 size_t idx;
1822
1823                 if (ms->search.s == NULL)
1824                         return 0;
1825
1826                 slen = MIN(m->vallen, sizeof(m->value.s));
1827                 l = 0;
1828                 v = 0;
1829
1830                 for (idx = 0; m->str_range == 0 || idx < m->str_range; idx++) {
1831                         if (slen + idx > ms->search.s_len)
1832                                 break;
1833
1834                         v = file_strncmp(m->value.s, ms->search.s + idx, slen, m->str_flags);
1835                         if (v == 0) {   /* found match */
1836                                 ms->search.offset += idx;
1837                                 break;
1838                         }
1839                 }
1840                 break;
1841         }
1842         case FILE_REGEX: {
1843                 int rc;
1844                 regex_t rx;
1845                 char errmsg[512];
1846
1847                 if (ms->search.s == NULL)
1848                         return 0;
1849
1850                 l = 0;
1851                 rc = regcomp(&rx, m->value.s,
1852                     REG_EXTENDED|REG_NEWLINE|
1853                     ((m->str_flags & STRING_IGNORE_CASE) ? REG_ICASE : 0));
1854                 if (rc) {
1855                         (void)regerror(rc, &rx, errmsg, sizeof(errmsg));
1856                         file_magerror(ms, "regex error %d, (%s)",
1857                             rc, errmsg);
1858                         v = (uint64_t)-1;
1859                 }
1860                 else {
1861                         regmatch_t pmatch[1];
1862 #ifndef REG_STARTEND
1863 #define REG_STARTEND    0
1864                         size_t l = ms->search.s_len - 1;
1865                         char c = ms->search.s[l];
1866                         ((char *)(intptr_t)ms->search.s)[l] = '\0';
1867 #else
1868                         pmatch[0].rm_so = 0;
1869                         pmatch[0].rm_eo = ms->search.s_len;
1870 #endif
1871                         rc = regexec(&rx, (const char *)ms->search.s,
1872                             1, pmatch, REG_STARTEND);
1873 #if REG_STARTEND == 0
1874                         ((char *)(intptr_t)ms->search.s)[l] = c;
1875 #endif
1876                         switch (rc) {
1877                         case 0:
1878                                 ms->search.s += (int)pmatch[0].rm_so;
1879                                 ms->search.offset += (size_t)pmatch[0].rm_so;
1880                                 ms->search.rm_len =
1881                                     (size_t)(pmatch[0].rm_eo - pmatch[0].rm_so);
1882                                 v = 0;
1883                                 break;
1884
1885                         case REG_NOMATCH:
1886                                 v = 1;
1887                                 break;
1888
1889                         default:
1890                                 (void)regerror(rc, &rx, errmsg, sizeof(errmsg));
1891                                 file_magerror(ms, "regexec error %d, (%s)",
1892                                     rc, errmsg);
1893                                 v = (uint64_t)-1;
1894                                 break;
1895                         }
1896                         regfree(&rx);
1897                 }
1898                 if (v == (uint64_t)-1)
1899                         return -1;
1900                 break;
1901         }
1902         case FILE_INDIRECT:
1903                 return 1;
1904         default:
1905                 file_magerror(ms, "invalid type %d in magiccheck()", m->type);
1906                 return -1;
1907         }
1908
1909         v = file_signextend(ms, m, v);
1910
1911         switch (m->reln) {
1912         case 'x':
1913                 if ((ms->flags & MAGIC_DEBUG) != 0)
1914                         (void) fprintf(stderr, "%llu == *any* = 1\n",
1915                             (unsigned long long)v);
1916                 matched = 1;
1917                 break;
1918
1919         case '!':
1920                 matched = v != l;
1921                 if ((ms->flags & MAGIC_DEBUG) != 0)
1922                         (void) fprintf(stderr, "%llu != %llu = %d\n",
1923                             (unsigned long long)v, (unsigned long long)l,
1924                             matched);
1925                 break;
1926
1927         case '=':
1928                 matched = v == l;
1929                 if ((ms->flags & MAGIC_DEBUG) != 0)
1930                         (void) fprintf(stderr, "%llu == %llu = %d\n",
1931                             (unsigned long long)v, (unsigned long long)l,
1932                             matched);
1933                 break;
1934
1935         case '>':
1936                 if (m->flag & UNSIGNED) {
1937                         matched = v > l;
1938                         if ((ms->flags & MAGIC_DEBUG) != 0)
1939                                 (void) fprintf(stderr, "%llu > %llu = %d\n",
1940                                     (unsigned long long)v,
1941                                     (unsigned long long)l, matched);
1942                 }
1943                 else {
1944                         matched = (int64_t) v > (int64_t) l;
1945                         if ((ms->flags & MAGIC_DEBUG) != 0)
1946                                 (void) fprintf(stderr, "%lld > %lld = %d\n",
1947                                     (long long)v, (long long)l, matched);
1948                 }
1949                 break;
1950
1951         case '<':
1952                 if (m->flag & UNSIGNED) {
1953                         matched = v < l;
1954                         if ((ms->flags & MAGIC_DEBUG) != 0)
1955                                 (void) fprintf(stderr, "%llu < %llu = %d\n",
1956                                     (unsigned long long)v,
1957                                     (unsigned long long)l, matched);
1958                 }
1959                 else {
1960                         matched = (int64_t) v < (int64_t) l;
1961                         if ((ms->flags & MAGIC_DEBUG) != 0)
1962                                 (void) fprintf(stderr, "%lld < %lld = %d\n",
1963                                        (long long)v, (long long)l, matched);
1964                 }
1965                 break;
1966
1967         case '&':
1968                 matched = (v & l) == l;
1969                 if ((ms->flags & MAGIC_DEBUG) != 0)
1970                         (void) fprintf(stderr, "((%llx & %llx) == %llx) = %d\n",
1971                             (unsigned long long)v, (unsigned long long)l,
1972                             (unsigned long long)l, matched);
1973                 break;
1974
1975         case '^':
1976                 matched = (v & l) != l;
1977                 if ((ms->flags & MAGIC_DEBUG) != 0)
1978                         (void) fprintf(stderr, "((%llx & %llx) != %llx) = %d\n",
1979                             (unsigned long long)v, (unsigned long long)l,
1980                             (unsigned long long)l, matched);
1981                 break;
1982
1983         default:
1984                 matched = 0;
1985                 file_magerror(ms, "cannot happen: invalid relation `%c'",
1986                     m->reln);
1987                 return -1;
1988         }
1989
1990         return matched;
1991 }
1992
1993 private int
1994 handle_annotation(struct magic_set *ms, struct magic *m)
1995 {
1996         if (ms->flags & MAGIC_APPLE) {
1997                 if (file_printf(ms, "%.8s", m->apple) == -1)
1998                         return -1;
1999                 return 1;
2000         }
2001         if ((ms->flags & MAGIC_MIME_TYPE) && m->mimetype[0]) {
2002                 if (file_printf(ms, "%s", m->mimetype) == -1)
2003                         return -1;
2004                 return 1;
2005         }
2006         return 0;
2007 }
2008
2009 private int
2010 print_sep(struct magic_set *ms, int firstline)
2011 {
2012         if (ms->flags & MAGIC_MIME)
2013                 return 0;
2014         if (firstline)
2015                 return 0;
2016         /*
2017          * we found another match
2018          * put a newline and '-' to do some simple formatting
2019          */
2020         return file_printf(ms, "\n- ");
2021 }