?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update to file 4.13. Put the contrib files into contrib/file-4 instead
[dragonfly.git] / contrib / file-4 / src / softmagic.c
blob1202f72661888adfaf2d20edbdb12cc89a38cd02
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 #include "magic.h"
34 #include <string.h>
35 #include <ctype.h>
36 #include <stdlib.h>
37 #include <time.h>
38 #include <regex.h>
39
40
41 #ifndef lint
42 FILE_RCSID("@(#)$Id: softmagic.c,v 1.72 2004/11/24 17:38:25 christos Exp $")
43 #endif /* lint */
44
45 private int match(struct magic_set *, struct magic *, uint32_t,
46 const unsigned char *, size_t);
47 private int mget(struct magic_set *, union VALUETYPE *, const unsigned char *,
48 struct magic *, size_t);
49 private int mcheck(struct magic_set *, union VALUETYPE *, struct magic *);
50 private int32_t mprint(struct magic_set *, union VALUETYPE *, struct magic *);
51 private void mdebug(uint32_t, const char *, size_t);
52 private int mcopy(struct magic_set *, union VALUETYPE *, int, int,
53 const unsigned char *, size_t, size_t);
54 private int mconvert(struct magic_set *, union VALUETYPE *, struct magic *);
55 private int check_mem(struct magic_set *, unsigned int);
56
57 /*
58 * softmagic - lookup one file in database
59 * (already read from MAGIC by apprentice.c).
60 * Passed the name and FILE * of one file to be typed.
61 */
62 /*ARGSUSED1*/ /* nbytes passed for regularity, maybe need later */
63 protected int
64 file_softmagic(struct magic_set *ms, const unsigned char *buf, size_t nbytes)
65 {
66 struct mlist *ml;
67 for (ml = ms->mlist->next; ml != ms->mlist; ml = ml->next)
68 if (match(ms, ml->magic, ml->nmagic, buf, nbytes))
69 return 1;
70
71 return 0;
72 }
73
74 /*
75 * Go through the whole list, stopping if you find a match. Process all
76 * the continuations of that match before returning.
77 *
78 * We support multi-level continuations:
79 *
80 * At any time when processing a successful top-level match, there is a
81 * current continuation level; it represents the level of the last
82 * successfully matched continuation.
83 *
84 * Continuations above that level are skipped as, if we see one, it
85 * means that the continuation that controls them - i.e, the
86 * lower-level continuation preceding them - failed to match.
87 *
88 * Continuations below that level are processed as, if we see one,
89 * it means we've finished processing or skipping higher-level
90 * continuations under the control of a successful or unsuccessful
91 * lower-level continuation, and are now seeing the next lower-level
92 * continuation and should process it. The current continuation
93 * level reverts to the level of the one we're seeing.
94 *
95 * Continuations at the current level are processed as, if we see
96 * one, there's no lower-level continuation that may have failed.
97 *
98 * If a continuation matches, we bump the current continuation level
99 * so that higher-level continuations are processed.
100 */
101 private int
102 match(struct magic_set *ms, struct magic *magic, uint32_t nmagic,
103 const unsigned char *s, size_t nbytes)
104 {
105 uint32_t magindex = 0;
106 unsigned int cont_level = 0;
107 int need_separator = 0;
108 union VALUETYPE p;
109 int32_t oldoff = 0;
110 int returnval = 0; /* if a match is found it is set to 1*/
111 int firstline = 1; /* a flag to print X\n X\n- X */
112
113 if (check_mem(ms, cont_level) == -1)
114 return -1;
115
116 for (magindex = 0; magindex < nmagic; magindex++) {
117 /* if main entry matches, print it... */
118 int flush = !mget(ms, &p, s, &magic[magindex], nbytes);
119 switch (mcheck(ms, &p, &magic[magindex])) {
120 case -1:
121 return -1;
122 case 0:
123 flush++;
124 break;
125 default:
126 break;
127 }
128 if (flush) {
129 /*
130 * main entry didn't match,
131 * flush its continuations
132 */
133 while (magindex < nmagic - 1 &&
134 magic[magindex + 1].cont_level != 0)
135 magindex++;
136 continue;
137 }
138
139 if (!firstline) { /* we found another match */
140 /* put a newline and '-' to do some simple formatting*/
141 if (file_printf(ms, "\n- ") == -1)
142 return -1;
143 }
144
145 if ((ms->c.off[cont_level] = mprint(ms, &p, &magic[magindex]))
146 == -1)
147 return -1;
148 /*
149 * If we printed something, we'll need to print
150 * a blank before we print something else.
151 */
152 if (magic[magindex].desc[0])
153 need_separator = 1;
154 /* and any continuations that match */
155 if (check_mem(ms, ++cont_level) == -1)
156 return -1;
157
158 while (magic[magindex+1].cont_level != 0 &&
159 ++magindex < nmagic) {
160 if (cont_level < magic[magindex].cont_level)
161 continue;
162 if (cont_level > magic[magindex].cont_level) {
163 /*
164 * We're at the end of the level
165 * "cont_level" continuations.
166 */
167 cont_level = magic[magindex].cont_level;
168 }
169 if (magic[magindex].flag & OFFADD) {
170 oldoff=magic[magindex].offset;
171 magic[magindex].offset += ms->c.off[cont_level-1];
172 }
173 if (!mget(ms, &p, s, &magic[magindex], nbytes))
174 goto done;
175
176 switch (mcheck(ms, &p, &magic[magindex])) {
177 case -1:
178 return -1;
179 case 0:
180 break;
181 default:
182 /*
183 * This continuation matched.
184 * Print its message, with
185 * a blank before it if
186 * the previous item printed
187 * and this item isn't empty.
188 */
189 /* space if previous printed */
190 if (need_separator
191 && (magic[magindex].nospflag == 0)
192 && (magic[magindex].desc[0] != '\0')) {
193 if (file_printf(ms, " ") == -1)
194 return -1;
195 need_separator = 0;
196 }
197 if ((ms->c.off[cont_level] = mprint(ms, &p,
198 &magic[magindex])) == -1)
199 return -1;
200 if (magic[magindex].desc[0])
201 need_separator = 1;
202
203 /*
204 * If we see any continuations
205 * at a higher level,
206 * process them.
207 */
208 if (check_mem(ms, ++cont_level) == -1)
209 return -1;
210 }
211 done:
212 if (magic[magindex].flag & OFFADD) {
213 magic[magindex].offset = oldoff;
214 }
215 }
216 firstline = 0;
217 returnval = 1;
218 if ((ms->flags & MAGIC_CONTINUE) == 0) {
219 return 1; /* don't keep searching */
220 }
221 }
222 return returnval; /* This is hit if -k is set or there is no match */
223 }
224
225 private int
226 check_mem(struct magic_set *ms, unsigned int level)
227 {
228 size_t len;
229
230 if (level < ms->c.len)
231 return 0;
232
233 len = (ms->c.len += 20) * sizeof(*ms->c.off);
234 ms->c.off = (ms->c.off == NULL) ? malloc(len) : realloc(ms->c.off, len);
235 if (ms->c.off != NULL)
236 return 0;
237 file_oomem(ms);
238 return -1;
239 }
240
241 private int32_t
242 mprint(struct magic_set *ms, union VALUETYPE *p, struct magic *m)
243 {
244 uint32_t v;
245 int32_t t=0 ;
246
247
248 switch (m->type) {
249 case FILE_BYTE:
250 v = file_signextend(ms, m, (size_t)p->b);
251 if (file_printf(ms, m->desc, (unsigned char) v) == -1)
252 return -1;
253 t = m->offset + sizeof(char);
254 break;
255
256 case FILE_SHORT:
257 case FILE_BESHORT:
258 case FILE_LESHORT:
259 v = file_signextend(ms, m, (size_t)p->h);
260 if (file_printf(ms, m->desc, (unsigned short) v) == -1)
261 return -1;
262 t = m->offset + sizeof(short);
263 break;
264
265 case FILE_LONG:
266 case FILE_BELONG:
267 case FILE_LELONG:
268 v = file_signextend(ms, m, p->l);
269 if (file_printf(ms, m->desc, (uint32_t) v) == -1)
270 return -1;
271 t = m->offset + sizeof(int32_t);
272 break;
273
274 case FILE_STRING:
275 case FILE_PSTRING:
276 case FILE_BESTRING16:
277 case FILE_LESTRING16:
278 if (m->reln == '=') {
279 if (file_printf(ms, m->desc, m->value.s) == -1)
280 return -1;
281 t = m->offset + strlen(m->value.s);
282 }
283 else {
284 if (*m->value.s == '\0') {
285 char *cp = strchr(p->s,'\n');
286 if (cp)
287 *cp = '\0';
288 }
289 if (file_printf(ms, m->desc, p->s) == -1)
290 return -1;
291 t = m->offset + strlen(p->s);
292 }
293 break;
294
295 case FILE_DATE:
296 case FILE_BEDATE:
297 case FILE_LEDATE:
298 if (file_printf(ms, m->desc, file_fmttime(p->l, 1)) == -1)
299 return -1;
300 t = m->offset + sizeof(time_t);
301 break;
302
303 case FILE_LDATE:
304 case FILE_BELDATE:
305 case FILE_LELDATE:
306 if (file_printf(ms, m->desc, file_fmttime(p->l, 0)) == -1)
307 return -1;
308 t = m->offset + sizeof(time_t);
309 break;
310 case FILE_REGEX:
311 if (file_printf(ms, m->desc, p->s) == -1)
312 return -1;
313 t = m->offset + strlen(p->s);
314 break;
315
316 default:
317 file_error(ms, 0, "invalid m->type (%d) in mprint()", m->type);
318 return -1;
319 }
320 return(t);
321 }
322
323 /*
324 * Convert the byte order of the data we are looking at
325 * While we're here, let's apply the mask operation
326 * (unless you have a better idea)
327 */
328 private int
329 mconvert(struct magic_set *ms, union VALUETYPE *p, struct magic *m)
330 {
331 switch (m->type) {
332 case FILE_BYTE:
333 if (m->mask)
334 switch (m->mask_op&0x7F) {
335 case FILE_OPAND:
336 p->b &= m->mask;
337 break;
338 case FILE_OPOR:
339 p->b |= m->mask;
340 break;
341 case FILE_OPXOR:
342 p->b ^= m->mask;
343 break;
344 case FILE_OPADD:
345 p->b += m->mask;
346 break;
347 case FILE_OPMINUS:
348 p->b -= m->mask;
349 break;
350 case FILE_OPMULTIPLY:
351 p->b *= m->mask;
352 break;
353 case FILE_OPDIVIDE:
354 p->b /= m->mask;
355 break;
356 case FILE_OPMODULO:
357 p->b %= m->mask;
358 break;
359 }
360 if (m->mask_op & FILE_OPINVERSE)
361 p->b = ~p->b;
362 return 1;
363 case FILE_SHORT:
364 if (m->mask)
365 switch (m->mask_op&0x7F) {
366 case FILE_OPAND:
367 p->h &= m->mask;
368 break;
369 case FILE_OPOR:
370 p->h |= m->mask;
371 break;
372 case FILE_OPXOR:
373 p->h ^= m->mask;
374 break;
375 case FILE_OPADD:
376 p->h += m->mask;
377 break;
378 case FILE_OPMINUS:
379 p->h -= m->mask;
380 break;
381 case FILE_OPMULTIPLY:
382 p->h *= m->mask;
383 break;
384 case FILE_OPDIVIDE:
385 p->h /= m->mask;
386 break;
387 case FILE_OPMODULO:
388 p->h %= m->mask;
389 break;
390 }
391 if (m->mask_op & FILE_OPINVERSE)
392 p->h = ~p->h;
393 return 1;
394 case FILE_LONG:
395 case FILE_DATE:
396 case FILE_LDATE:
397 if (m->mask)
398 switch (m->mask_op&0x7F) {
399 case FILE_OPAND:
400 p->l &= m->mask;
401 break;
402 case FILE_OPOR:
403 p->l |= m->mask;
404 break;
405 case FILE_OPXOR:
406 p->l ^= m->mask;
407 break;
408 case FILE_OPADD:
409 p->l += m->mask;
410 break;
411 case FILE_OPMINUS:
412 p->l -= m->mask;
413 break;
414 case FILE_OPMULTIPLY:
415 p->l *= m->mask;
416 break;
417 case FILE_OPDIVIDE:
418 p->l /= m->mask;
419 break;
420 case FILE_OPMODULO:
421 p->l %= m->mask;
422 break;
423 }
424 if (m->mask_op & FILE_OPINVERSE)
425 p->l = ~p->l;
426 return 1;
427 case FILE_STRING:
428 case FILE_BESTRING16:
429 case FILE_LESTRING16:
430 {
431 size_t len;
432
433 /* Null terminate and eat *trailing* return */
434 p->s[sizeof(p->s) - 1] = '\0';
435 len = strlen(p->s);
436 if (len-- && p->s[len] == '\n')
437 p->s[len] = '\0';
438 return 1;
439 }
440 case FILE_PSTRING:
441 {
442 char *ptr1 = p->s, *ptr2 = ptr1 + 1;
443 size_t len = *p->s;
444 if (len >= sizeof(p->s))
445 len = sizeof(p->s) - 1;
446 while (len--)
447 *ptr1++ = *ptr2++;
448 *ptr1 = '\0';
449 len = strlen(p->s);
450 if (len-- && p->s[len] == '\n')
451 p->s[len] = '\0';
452 return 1;
453 }
454 case FILE_BESHORT:
455 p->h = (short)((p->hs[0]<<8)|(p->hs[1]));
456 if (m->mask)
457 switch (m->mask_op&0x7F) {
458 case FILE_OPAND:
459 p->h &= m->mask;
460 break;
461 case FILE_OPOR:
462 p->h |= m->mask;
463 break;
464 case FILE_OPXOR:
465 p->h ^= m->mask;
466 break;
467 case FILE_OPADD:
468 p->h += m->mask;
469 break;
470 case FILE_OPMINUS:
471 p->h -= m->mask;
472 break;
473 case FILE_OPMULTIPLY:
474 p->h *= m->mask;
475 break;
476 case FILE_OPDIVIDE:
477 p->h /= m->mask;
478 break;
479 case FILE_OPMODULO:
480 p->h %= m->mask;
481 break;
482 }
483 if (m->mask_op & FILE_OPINVERSE)
484 p->h = ~p->h;
485 return 1;
486 case FILE_BELONG:
487 case FILE_BEDATE:
488 case FILE_BELDATE:
489 p->l = (int32_t)
490 ((p->hl[0]<<24)|(p->hl[1]<<16)|(p->hl[2]<<8)|(p->hl[3]));
491 if (m->mask)
492 switch (m->mask_op&0x7F) {
493 case FILE_OPAND:
494 p->l &= m->mask;
495 break;
496 case FILE_OPOR:
497 p->l |= m->mask;
498 break;
499 case FILE_OPXOR:
500 p->l ^= m->mask;
501 break;
502 case FILE_OPADD:
503 p->l += m->mask;
504 break;
505 case FILE_OPMINUS:
506 p->l -= m->mask;
507 break;
508 case FILE_OPMULTIPLY:
509 p->l *= m->mask;
510 break;
511 case FILE_OPDIVIDE:
512 p->l /= m->mask;
513 break;
514 case FILE_OPMODULO:
515 p->l %= m->mask;
516 break;
517 }
518 if (m->mask_op & FILE_OPINVERSE)
519 p->l = ~p->l;
520 return 1;
521 case FILE_LESHORT:
522 p->h = (short)((p->hs[1]<<8)|(p->hs[0]));
523 if (m->mask)
524 switch (m->mask_op&0x7F) {
525 case FILE_OPAND:
526 p->h &= m->mask;
527 break;
528 case FILE_OPOR:
529 p->h |= m->mask;
530 break;
531 case FILE_OPXOR:
532 p->h ^= m->mask;
533 break;
534 case FILE_OPADD:
535 p->h += m->mask;
536 break;
537 case FILE_OPMINUS:
538 p->h -= m->mask;
539 break;
540 case FILE_OPMULTIPLY:
541 p->h *= m->mask;
542 break;
543 case FILE_OPDIVIDE:
544 p->h /= m->mask;
545 break;
546 case FILE_OPMODULO:
547 p->h %= m->mask;
548 break;
549 }
550 if (m->mask_op & FILE_OPINVERSE)
551 p->h = ~p->h;
552 return 1;
553 case FILE_LELONG:
554 case FILE_LEDATE:
555 case FILE_LELDATE:
556 p->l = (int32_t)
557 ((p->hl[3]<<24)|(p->hl[2]<<16)|(p->hl[1]<<8)|(p->hl[0]));
558 if (m->mask)
559 switch (m->mask_op&0x7F) {
560 case FILE_OPAND:
561 p->l &= m->mask;
562 break;
563 case FILE_OPOR:
564 p->l |= m->mask;
565 break;
566 case FILE_OPXOR:
567 p->l ^= m->mask;
568 break;
569 case FILE_OPADD:
570 p->l += m->mask;
571 break;
572 case FILE_OPMINUS:
573 p->l -= m->mask;
574 break;
575 case FILE_OPMULTIPLY:
576 p->l *= m->mask;
577 break;
578 case FILE_OPDIVIDE:
579 p->l /= m->mask;
580 break;
581 case FILE_OPMODULO:
582 p->l %= m->mask;
583 break;
584 }
585 if (m->mask_op & FILE_OPINVERSE)
586 p->l = ~p->l;
587 return 1;
588 case FILE_REGEX:
589 return 1;
590 default:
591 file_error(ms, 0, "invalid type %d in mconvert()", m->type);
592 return 0;
593 }
594 }
595
596
597 private void
598 mdebug(uint32_t offset, const char *str, size_t len)
599 {
600 (void) fprintf(stderr, "mget @%d: ", offset);
601 file_showstr(stderr, str, len);
602 (void) fputc('\n', stderr);
603 (void) fputc('\n', stderr);
604 }
605
606 private int
607 mcopy(struct magic_set *ms, union VALUETYPE *p, int type, int indir,
608 const unsigned char *s, size_t offset, size_t nbytes)
609 {
610 if (type == FILE_REGEX && indir == 0) {
611 /*
612 * offset is interpreted as last line to search,
613 * (starting at 1), not as bytes-from start-of-file
614 */
615 unsigned char *b, *last = NULL;
616 if ((p->buf = strdup((const char *)s)) == NULL) {
617 file_oomem(ms);
618 return -1;
619 }
620 for (b = (unsigned char *)p->buf; offset &&
621 (b = (unsigned char *)strchr((char *)b, '\n')) != NULL;
622 offset--, s++)
623 last = b;
624 if (last != NULL)
625 *last = '\0';
626 return 0;
627 }
628
629 if (indir == 0 && (type == FILE_BESTRING16 || type == FILE_LESTRING16))
630 {
631 const char *src = s + offset;
632 const char *esrc = s + nbytes;
633 char *dst = p->s, *edst = &p->s[sizeof(p->s) - 1];
634
635 if (type == FILE_BESTRING16)
636 src++;
637
638 for (;src < esrc; src++, dst++) {
639 if (dst < edst)
640 *dst = *src++;
641 else
642 break;
643 if (*dst == '\0')
644 *dst = ' ';
645 }
646 *edst = '\0';
647 return 0;
648 }
649
650 if (offset >= nbytes) {
651 (void)memset(p, '\0', sizeof(*p));
652 return 0;
653 }
654 if (nbytes - offset < sizeof(*p))
655 nbytes = nbytes - offset;
656 else
657 nbytes = sizeof(*p);
658
659 (void)memcpy(p, s + offset, nbytes);
660
661 /*
662 * the usefulness of padding with zeroes eludes me, it
663 * might even cause problems
664 */
665 if (nbytes < sizeof(*p))
666 (void)memset(((char *)p) + nbytes, '\0', sizeof(*p) - nbytes);
667 return 0;
668 }
669
670 private int
671 mget(struct magic_set *ms, union VALUETYPE *p, const unsigned char *s,
672 struct magic *m, size_t nbytes)
673 {
674 uint32_t offset = m->offset;
675
676 if (mcopy(ms, p, m->type, m->flag & INDIR, s, offset, nbytes) == -1)
677 return -1;
678
679 /* Verify we have enough data to match magic type */
680 switch (m->type) {
681 case FILE_BYTE:
682 if (nbytes < (offset + 1)) /* should alway be true */
683 return 0;
684 break;
685
686 case FILE_SHORT:
687 case FILE_BESHORT:
688 case FILE_LESHORT:
689 if (nbytes < (offset + 2))
690 return 0;
691 break;
692
693 case FILE_LONG:
694 case FILE_BELONG:
695 case FILE_LELONG:
696 case FILE_DATE:
697 case FILE_BEDATE:
698 case FILE_LEDATE:
699 case FILE_LDATE:
700 case FILE_BELDATE:
701 case FILE_LELDATE:
702 if (nbytes < (offset + 4))
703 return 0;
704 break;
705
706 case FILE_STRING:
707 case FILE_PSTRING:
708 if (nbytes < (offset + m->vallen))
709 return 0;
710 break;
711 }
712
713 if ((ms->flags & MAGIC_DEBUG) != 0) {
714 mdebug(offset, (char *)(void *)p, sizeof(union VALUETYPE));
715 file_mdump(m);
716 }
717
718 if (m->flag & INDIR) {
719 switch (m->in_type) {
720 case FILE_BYTE:
721 if (m->in_offset) {
722 switch (m->in_op&0x7F) {
723 case FILE_OPAND:
724 offset = p->b & m->in_offset;
725 break;
726 case FILE_OPOR:
727 offset = p->b | m->in_offset;
728 break;
729 case FILE_OPXOR:
730 offset = p->b ^ m->in_offset;
731 break;
732 case FILE_OPADD:
733 offset = p->b + m->in_offset;
734 break;
735 case FILE_OPMINUS:
736 offset = p->b - m->in_offset;
737 break;
738 case FILE_OPMULTIPLY:
739 offset = p->b * m->in_offset;
740 break;
741 case FILE_OPDIVIDE:
742 offset = p->b / m->in_offset;
743 break;
744 case FILE_OPMODULO:
745 offset = p->b % m->in_offset;
746 break;
747 }
748 } else
749 offset = p->b;
750 if (m->in_op & FILE_OPINVERSE)
751 offset = ~offset;
752 break;
753 case FILE_BESHORT:
754 if (m->in_offset) {
755 switch (m->in_op & 0x7F) {
756 case FILE_OPAND:
757 offset = (short)((p->hs[0]<<8)|
758 (p->hs[1])) &
759 m->in_offset;
760 break;
761 case FILE_OPOR:
762 offset = (short)((p->hs[0]<<8)|
763 (p->hs[1])) |
764 m->in_offset;
765 break;
766 case FILE_OPXOR:
767 offset = (short)((p->hs[0]<<8)|
768 (p->hs[1])) ^
769 m->in_offset;
770 break;
771 case FILE_OPADD:
772 offset = (short)((p->hs[0]<<8)|
773 (p->hs[1])) +
774 m->in_offset;
775 break;
776 case FILE_OPMINUS:
777 offset = (short)((p->hs[0]<<8)|
778 (p->hs[1])) -
779 m->in_offset;
780 break;
781 case FILE_OPMULTIPLY:
782 offset = (short)((p->hs[0]<<8)|
783 (p->hs[1])) *
784 m->in_offset;
785 break;
786 case FILE_OPDIVIDE:
787 offset = (short)((p->hs[0]<<8)|
788 (p->hs[1])) /
789 m->in_offset;
790 break;
791 case FILE_OPMODULO:
792 offset = (short)((p->hs[0]<<8)|
793 (p->hs[1])) %
794 m->in_offset;
795 break;
796 }
797 } else
798 offset = (short)((p->hs[0]<<8)|
799 (p->hs[1]));
800 if (m->in_op & FILE_OPINVERSE)
801 offset = ~offset;
802 break;
803 case FILE_LESHORT:
804 if (m->in_offset) {
805 switch (m->in_op & 0x7F) {
806 case FILE_OPAND:
807 offset = (short)((p->hs[1]<<8)|
808 (p->hs[0])) &
809 m->in_offset;
810 break;
811 case FILE_OPOR:
812 offset = (short)((p->hs[1]<<8)|
813 (p->hs[0])) |
814 m->in_offset;
815 break;
816 case FILE_OPXOR:
817 offset = (short)((p->hs[1]<<8)|
818 (p->hs[0])) ^
819 m->in_offset;
820 break;
821 case FILE_OPADD:
822 offset = (short)((p->hs[1]<<8)|
823 (p->hs[0])) +
824 m->in_offset;
825 break;
826 case FILE_OPMINUS:
827 offset = (short)((p->hs[1]<<8)|
828 (p->hs[0])) -
829 m->in_offset;
830 break;
831 case FILE_OPMULTIPLY:
832 offset = (short)((p->hs[1]<<8)|
833 (p->hs[0])) *
834 m->in_offset;
835 break;
836 case FILE_OPDIVIDE:
837 offset = (short)((p->hs[1]<<8)|
838 (p->hs[0])) /
839 m->in_offset;
840 break;
841 case FILE_OPMODULO:
842 offset = (short)((p->hs[1]<<8)|
843 (p->hs[0])) %
844 m->in_offset;
845 break;
846 }
847 } else
848 offset = (short)((p->hs[1]<<8)|
849 (p->hs[0]));
850 if (m->in_op & FILE_OPINVERSE)
851 offset = ~offset;
852 break;
853 case FILE_SHORT:
854 if (m->in_offset) {
855 switch (m->in_op & 0x7F) {
856 case FILE_OPAND:
857 offset = p->h & m->in_offset;
858 break;
859 case FILE_OPOR:
860 offset = p->h | m->in_offset;
861 break;
862 case FILE_OPXOR:
863 offset = p->h ^ m->in_offset;
864 break;
865 case FILE_OPADD:
866 offset = p->h + m->in_offset;
867 break;
868 case FILE_OPMINUS:
869 offset = p->h - m->in_offset;
870 break;
871 case FILE_OPMULTIPLY:
872 offset = p->h * m->in_offset;
873 break;
874 case FILE_OPDIVIDE:
875 offset = p->h / m->in_offset;
876 break;
877 case FILE_OPMODULO:
878 offset = p->h % m->in_offset;
879 break;
880 }
881 }
882 else
883 offset = p->h;
884 if (m->in_op & FILE_OPINVERSE)
885 offset = ~offset;
886 break;
887 case FILE_BELONG:
888 if (m->in_offset) {
889 switch (m->in_op & 0x7F) {
890 case FILE_OPAND:
891 offset = (int32_t)((p->hl[0]<<24)|
892 (p->hl[1]<<16)|
893 (p->hl[2]<<8)|
894 (p->hl[3])) &
895 m->in_offset;
896 break;
897 case FILE_OPOR:
898 offset = (int32_t)((p->hl[0]<<24)|
899 (p->hl[1]<<16)|
900 (p->hl[2]<<8)|
901 (p->hl[3])) |
902 m->in_offset;
903 break;
904 case FILE_OPXOR:
905 offset = (int32_t)((p->hl[0]<<24)|
906 (p->hl[1]<<16)|
907 (p->hl[2]<<8)|
908 (p->hl[3])) ^
909 m->in_offset;
910 break;
911 case FILE_OPADD:
912 offset = (int32_t)((p->hl[0]<<24)|
913 (p->hl[1]<<16)|
914 (p->hl[2]<<8)|
915 (p->hl[3])) +
916 m->in_offset;
917 break;
918 case FILE_OPMINUS:
919 offset = (int32_t)((p->hl[0]<<24)|
920 (p->hl[1]<<16)|
921 (p->hl[2]<<8)|
922 (p->hl[3])) -
923 m->in_offset;
924 break;
925 case FILE_OPMULTIPLY:
926 offset = (int32_t)((p->hl[0]<<24)|
927 (p->hl[1]<<16)|
928 (p->hl[2]<<8)|
929 (p->hl[3])) *
930 m->in_offset;
931 break;
932 case FILE_OPDIVIDE:
933 offset = (int32_t)((p->hl[0]<<24)|
934 (p->hl[1]<<16)|
935 (p->hl[2]<<8)|
936 (p->hl[3])) /
937 m->in_offset;
938 break;
939 case FILE_OPMODULO:
940 offset = (int32_t)((p->hl[0]<<24)|
941 (p->hl[1]<<16)|
942 (p->hl[2]<<8)|
943 (p->hl[3])) %
944 m->in_offset;
945 break;
946 }
947 } else
948 offset = (int32_t)((p->hl[0]<<24)|
949 (p->hl[1]<<16)|
950 (p->hl[2]<<8)|
951 (p->hl[3]));
952 if (m->in_op & FILE_OPINVERSE)
953 offset = ~offset;
954 break;
955 case FILE_LELONG:
956 if (m->in_offset) {
957 switch (m->in_op & 0x7F) {
958 case FILE_OPAND:
959 offset = (int32_t)((p->hl[3]<<24)|
960 (p->hl[2]<<16)|
961 (p->hl[1]<<8)|
962 (p->hl[0])) &
963 m->in_offset;
964 break;
965 case FILE_OPOR:
966 offset = (int32_t)((p->hl[3]<<24)|
967 (p->hl[2]<<16)|
968 (p->hl[1]<<8)|
969 (p->hl[0])) |
970 m->in_offset;
971 break;
972 case FILE_OPXOR:
973 offset = (int32_t)((p->hl[3]<<24)|
974 (p->hl[2]<<16)|
975 (p->hl[1]<<8)|
976 (p->hl[0])) ^
977 m->in_offset;
978 break;
979 case FILE_OPADD:
980 offset = (int32_t)((p->hl[3]<<24)|
981 (p->hl[2]<<16)|
982 (p->hl[1]<<8)|
983 (p->hl[0])) +
984 m->in_offset;
985 break;
986 case FILE_OPMINUS:
987 offset = (int32_t)((p->hl[3]<<24)|
988 (p->hl[2]<<16)|
989 (p->hl[1]<<8)|
990 (p->hl[0])) -
991 m->in_offset;
992 break;
993 case FILE_OPMULTIPLY:
994 offset = (int32_t)((p->hl[3]<<24)|
995 (p->hl[2]<<16)|
996 (p->hl[1]<<8)|
997 (p->hl[0])) *
998 m->in_offset;
999 break;
1000 case FILE_OPDIVIDE:
1001 offset = (int32_t)((p->hl[3]<<24)|
1002 (p->hl[2]<<16)|
1003 (p->hl[1]<<8)|
1004 (p->hl[0])) /
1005 m->in_offset;
1006 break;
1007 case FILE_OPMODULO:
1008 offset = (int32_t)((p->hl[3]<<24)|
1009 (p->hl[2]<<16)|
1010 (p->hl[1]<<8)|
1011 (p->hl[0])) %
1012 m->in_offset;
1013 break;
1014 }
1015 } else
1016 offset = (int32_t)((p->hl[3]<<24)|
1017 (p->hl[2]<<16)|
1018 (p->hl[1]<<8)|
1019 (p->hl[0]));
1020 if (m->in_op & FILE_OPINVERSE)
1021 offset = ~offset;
1022 break;
1023 case FILE_LONG:
1024 if (m->in_offset) {
1025 switch (m->in_op & 0x7F) {
1026 case FILE_OPAND:
1027 offset = p->l & m->in_offset;
1028 break;
1029 case FILE_OPOR:
1030 offset = p->l | m->in_offset;
1031 break;
1032 case FILE_OPXOR:
1033 offset = p->l ^ m->in_offset;
1034 break;
1035 case FILE_OPADD:
1036 offset = p->l + m->in_offset;
1037 break;
1038 case FILE_OPMINUS:
1039 offset = p->l - m->in_offset;
1040 break;
1041 case FILE_OPMULTIPLY:
1042 offset = p->l * m->in_offset;
1043 break;
1044 case FILE_OPDIVIDE:
1045 offset = p->l / m->in_offset;
1046 break;
1047 case FILE_OPMODULO:
1048 offset = p->l % m->in_offset;
1049 break;
1050 /* case TOOMANYSWITCHBLOCKS:
1051 * ugh = p->eye % m->strain;
1052 * rub;
1053 * case BEER:
1054 * off = p->tab & m->in_gest;
1055 * sleep;
1056 */
1057 }
1058 } else
1059 offset = p->l;
1060 if (m->in_op & FILE_OPINVERSE)
1061 offset = ~offset;
1062 break;
1063 }
1064
1065 if (mcopy(ms, p, m->type, 0, s, offset, nbytes) == -1)
1066 return -1;
1067
1068 if ((ms->flags & MAGIC_DEBUG) != 0) {
1069 mdebug(offset, (char *)(void *)p,
1070 sizeof(union VALUETYPE));
1071 file_mdump(m);
1072 }
1073 }
1074 if (!mconvert(ms, p, m))
1075 return 0;
1076 return 1;
1077 }
1078
1079 private int
1080 mcheck(struct magic_set *ms, union VALUETYPE *p, struct magic *m)
1081 {
1082 uint32_t l = m->value.l;
1083 uint32_t v;
1084 int matched;
1085
1086 if ( (m->value.s[0] == 'x') && (m->value.s[1] == '\0') ) {
1087 return 1;
1088 }
1089
1090
1091 switch (m->type) {
1092 case FILE_BYTE:
1093 v = p->b;
1094 break;
1095
1096 case FILE_SHORT:
1097 case FILE_BESHORT:
1098 case FILE_LESHORT:
1099 v = p->h;
1100 break;
1101
1102 case FILE_LONG:
1103 case FILE_BELONG:
1104 case FILE_LELONG:
1105 case FILE_DATE:
1106 case FILE_BEDATE:
1107 case FILE_LEDATE:
1108 case FILE_LDATE:
1109 case FILE_BELDATE:
1110 case FILE_LELDATE:
1111 v = p->l;
1112 break;
1113
1114 case FILE_STRING:
1115 case FILE_BESTRING16:
1116 case FILE_LESTRING16:
1117 case FILE_PSTRING:
1118 {
1119 /*
1120 * What we want here is:
1121 * v = strncmp(m->value.s, p->s, m->vallen);
1122 * but ignoring any nulls. bcmp doesn't give -/+/0
1123 * and isn't universally available anyway.
1124 */
1125 unsigned char *a = (unsigned char*)m->value.s;
1126 unsigned char *b = (unsigned char*)p->s;
1127 int len = m->vallen;
1128 l = 0;
1129 v = 0;
1130 if (0L == m->mask) { /* normal string: do it fast */
1131 while (--len >= 0)
1132 if ((v = *b++ - *a++) != '\0')
1133 break;
1134 } else { /* combine the others */
1135 while (--len >= 0) {
1136 if ((m->mask & STRING_IGNORE_LOWERCASE) &&
1137 islower(*a)) {
1138 if ((v = tolower(*b++) - *a++) != '\0')
1139 break;
1140 } else if ((m->mask & STRING_COMPACT_BLANK) &&
1141 isspace(*a)) {
1142 a++;
1143 if (isspace(*b++)) {
1144 while (isspace(*b))
1145 b++;
1146 } else {
1147 v = 1;
1148 break;
1149 }
1150 } else if (isspace(*a) &&
1151 (m->mask & STRING_COMPACT_OPTIONAL_BLANK)) {
1152 a++;
1153 while (isspace(*b))
1154 b++;
1155 } else {
1156 if ((v = *b++ - *a++) != '\0')
1157 break;
1158 }
1159 }
1160 }
1161 break;
1162 }
1163 case FILE_REGEX:
1164 {
1165 int rc;
1166 regex_t rx;
1167 char errmsg[512];
1168
1169 rc = regcomp(&rx, m->value.s, REG_EXTENDED|REG_NOSUB);
1170 if (rc) {
1171 free(p->buf);
1172 regerror(rc, &rx, errmsg, sizeof(errmsg));
1173 file_error(ms, 0, "regex error %d, (%s)", rc, errmsg);
1174 return -1;
1175 } else {
1176 rc = regexec(&rx, p->buf, 0, 0, 0);
1177 regfree(&rx);
1178 free(p->buf);
1179 return !rc;
1180 }
1181 }
1182 default:
1183 file_error(ms, 0, "invalid type %d in mcheck()", m->type);
1184 return -1;
1185 }
1186
1187 if (m->type != FILE_STRING && m->type != FILE_PSTRING)
1188 v = file_signextend(ms, m, v);
1189
1190 switch (m->reln) {
1191 case 'x':
1192 if ((ms->flags & MAGIC_DEBUG) != 0)
1193 (void) fprintf(stderr, "%u == *any* = 1\n", v);
1194 matched = 1;
1195 break;
1196
1197 case '!':
1198 matched = v != l;
1199 if ((ms->flags & MAGIC_DEBUG) != 0)
1200 (void) fprintf(stderr, "%u != %u = %d\n",
1201 v, l, matched);
1202 break;
1203
1204 case '=':
1205 matched = v == l;
1206 if ((ms->flags & MAGIC_DEBUG) != 0)
1207 (void) fprintf(stderr, "%u == %u = %d\n",
1208 v, l, matched);
1209 break;
1210
1211 case '>':
1212 if (m->flag & UNSIGNED) {
1213 matched = v > l;
1214 if ((ms->flags & MAGIC_DEBUG) != 0)
1215 (void) fprintf(stderr, "%u > %u = %d\n",
1216 v, l, matched);
1217 }
1218 else {
1219 matched = (int32_t) v > (int32_t) l;
1220 if ((ms->flags & MAGIC_DEBUG) != 0)
1221 (void) fprintf(stderr, "%d > %d = %d\n",
1222 v, l, matched);
1223 }
1224 break;
1225
1226 case '<':
1227 if (m->flag & UNSIGNED) {
1228 matched = v < l;
1229 if ((ms->flags & MAGIC_DEBUG) != 0)
1230 (void) fprintf(stderr, "%u < %u = %d\n",
1231 v, l, matched);
1232 }
1233 else {
1234 matched = (int32_t) v < (int32_t) l;
1235 if ((ms->flags & MAGIC_DEBUG) != 0)
1236 (void) fprintf(stderr, "%d < %d = %d\n",
1237 v, l, matched);
1238 }
1239 break;
1240
1241 case '&':
1242 matched = (v & l) == l;
1243 if ((ms->flags & MAGIC_DEBUG) != 0)
1244 (void) fprintf(stderr, "((%x & %x) == %x) = %d\n",
1245 v, l, l, matched);
1246 break;
1247
1248 case '^':
1249 matched = (v & l) != l;
1250 if ((ms->flags & MAGIC_DEBUG) != 0)
1251 (void) fprintf(stderr, "((%x & %x) != %x) = %d\n",
1252 v, l, l, matched);
1253 break;
1254
1255 default:
1256 matched = 0;
1257 file_error(ms, 0, "cannot happen: invalid relation `%c'",
1258 m->reln);
1259 return -1;
1260 }
1261
1262 return matched;
1263 }
DragonFly BSD