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