Virgin import of Christos Zoulas's FILE 4.19.

1 files changed, 306 insertions, 304 deletions

diff --git a/contrib/file/softmagic.c b/contrib/file/softmagic.c
index edcba5e..7725048 100644
--- a/contrib/file/softmagic.c
+++ b/contrib/file/softmagic.c
@@ -39,24 +39,28 @@
 
 
 #ifndef	lint
-FILE_RCSID("@(#)$Id: softmagic.c,v 1.78 2006/03/12 22:09:33 christos Exp $")
+FILE_RCSID("@(#)$Id: softmagic.c,v 1.87 2006/12/11 21:48:49 christos Exp $")
 #endif	/* lint */
 
 private int match(struct magic_set *, struct magic *, uint32_t,
     const unsigned char *, size_t);
 private int mget(struct magic_set *, union VALUETYPE *, const unsigned char *,
     struct magic *, size_t, unsigned int);
-private int mcheck(struct magic_set *, union VALUETYPE *, struct magic *);
+private int magiccheck(struct magic_set *, union VALUETYPE *, struct magic *);
 private int32_t mprint(struct magic_set *, union VALUETYPE *, struct magic *);
 private void mdebug(uint32_t, const char *, size_t);
 private int mcopy(struct magic_set *, union VALUETYPE *, int, int,
-    const unsigned char *, size_t, size_t);
+    const unsigned char *, uint32_t, size_t);
 private int mconvert(struct magic_set *, union VALUETYPE *, struct magic *);
 private int check_mem(struct magic_set *, unsigned int);
+private int print_sep(struct magic_set *, int);
+private void cvt_8(union VALUETYPE *, const struct magic *);
+private void cvt_16(union VALUETYPE *, const struct magic *);
+private void cvt_32(union VALUETYPE *, const struct magic *);
+private void cvt_64(union VALUETYPE *, const struct magic *);
 
 /*
- * softmagic - lookup one file in database 
- * (already read from MAGIC by apprentice.c).
+ * softmagic - lookup one file in parsed, in-memory copy of database
  * Passed the name and FILE * of one file to be typed.
  */
 /*ARGSUSED1*/		/* nbytes passed for regularity, maybe need later */
@@ -64,9 +68,10 @@ protected int
 file_softmagic(struct magic_set *ms, const unsigned char *buf, size_t nbytes)
 {
 	struct mlist *ml;
+	int rv;
 	for (ml = ms->mlist->next; ml != ms->mlist; ml = ml->next)
-		if (match(ms, ml->magic, ml->nmagic, buf, nbytes))
-			return 1;
+		if ((rv = match(ms, ml->magic, ml->nmagic, buf, nbytes)) != 0)
+			return rv;
 
 	return 0;
 }
@@ -109,18 +114,21 @@ match(struct magic_set *ms, struct magic *magic, uint32_t nmagic,
 	int32_t oldoff = 0;
 	int returnval = 0; /* if a match is found it is set to 1*/
 	int firstline = 1; /* a flag to print X\n  X\n- X */
+	int printed_something = 0;
 
 	if (check_mem(ms, cont_level) == -1)
 		return -1;
 
 	for (magindex = 0; magindex < nmagic; magindex++) {
 		/* if main entry matches, print it... */
+		ms->offset = magic[magindex].offset;
 		int flush = !mget(ms, &p, s, &magic[magindex], nbytes,
 		    cont_level);
 		if (flush) {
-			if (magic[magindex].reln == '!') flush = 0;
+			if (magic[magindex].reln == '!')
+				flush = 0;
 		} else {	
-			switch (mcheck(ms, &p, &magic[magindex])) {
+			switch (magiccheck(ms, &p, &magic[magindex])) {
 			case -1:
 				return -1;
 			case 0:
@@ -141,21 +149,21 @@ match(struct magic_set *ms, struct magic *magic, uint32_t nmagic,
 			continue;
 		}
 
-		if (!firstline) { /* we found another match */
-			/* put a newline and '-' to do some simple formatting*/
-			if (file_printf(ms, "\n- ") == -1)
+		/*
+		 * If we are going to print something, we'll need to print
+		 * a blank before we print something else.
+		 */
+		if (magic[magindex].desc[0]) {
+			need_separator = 1;
+			printed_something = 1;
+			if (print_sep(ms, firstline) == -1)
 				return -1;
 		}
 
 		if ((ms->c.off[cont_level] = mprint(ms, &p, &magic[magindex]))
 		    == -1)
 			return -1;
-		/*
-		 * If we printed something, we'll need to print
-		 * a blank before we print something else.
-		 */
-		if (magic[magindex].desc[0])
-			need_separator = 1;
+
 		/* and any continuations that match */
 		if (check_mem(ms, ++cont_level) == -1)
 			return -1;
@@ -171,24 +179,33 @@ match(struct magic_set *ms, struct magic *magic, uint32_t nmagic,
 				 */
 				cont_level = magic[magindex].cont_level;
 			}
-			oldoff = magic[magindex].offset;
+			ms->offset = magic[magindex].offset;
 			if (magic[magindex].flag & OFFADD) {
-				magic[magindex].offset +=
+				ms->offset +=
 				    ms->c.off[cont_level - 1];
 			}
 
 			flush = !mget(ms, &p, s, &magic[magindex], nbytes,
 			    cont_level);
 			if (flush && magic[magindex].reln != '!')
-				goto done;
+				continue;
 				
-			switch (flush ? 1 : mcheck(ms, &p, &magic[magindex])) {
+			switch (flush ? 1 : magiccheck(ms, &p, &magic[magindex])) {
 			case -1:
 				return -1;
 			case 0:
 				break;
 			default:
 				/*
+				 * If we are going to print something,
+				 * make sure that we have a separator first.
+				 */
+				if (magic[magindex].desc[0]) {
+					printed_something = 1;
+					if (print_sep(ms, firstline) == -1)
+						return -1;
+				}
+				/*
 				 * This continuation matched.
 				 * Print its message, with
 				 * a blank before it if
@@ -217,12 +234,11 @@ match(struct magic_set *ms, struct magic *magic, uint32_t nmagic,
 				if (check_mem(ms, ++cont_level) == -1)
 					return -1;
 			}
-done:
-			magic[magindex].offset = oldoff;
 		}
 		firstline = 0;
-		returnval = 1;
-		if ((ms->flags & MAGIC_CONTINUE) == 0) {
+		if (printed_something)
+			returnval = 1;
+		if ((ms->flags & MAGIC_CONTINUE) == 0 && printed_something) {
 			return 1; /* don't keep searching */
 		}			
 	}
@@ -241,44 +257,113 @@ check_mem(struct magic_set *ms, unsigned int level)
 	ms->c.off = (ms->c.off == NULL) ? malloc(len) : realloc(ms->c.off, len);
 	if (ms->c.off != NULL)
 		return 0;
-	file_oomem(ms);
+	file_oomem(ms, len);
 	return -1;
 }
 
+private int
+check_fmt(struct magic_set *ms, struct magic *m)
+{
+	regex_t rx;
+	int rc;
+
+	if (strchr(m->desc, '%') == NULL)
+		return 0;
+
+	rc = regcomp(&rx, "%[-0-9\\.]*s", REG_EXTENDED|REG_NOSUB);
+	if (rc) {
+		char errmsg[512];
+		regerror(rc, &rx, errmsg, sizeof(errmsg));
+		file_error(ms, 0, "regex error %d, (%s)", rc, errmsg);
+		return -1;
+	} else {
+		rc = regexec(&rx, m->desc, 0, 0, 0);
+		regfree(&rx);
+		return !rc;
+	}
+}
+
 private int32_t
 mprint(struct magic_set *ms, union VALUETYPE *p, struct magic *m)
 {
-	uint32_t v;
-	int32_t t=0 ;
+	uint64_t v;
+	int32_t t = 0;
+ 	char buf[512];
 
 
   	switch (m->type) {
   	case FILE_BYTE:
-		v = file_signextend(ms, m, (size_t)p->b);
-		if (file_printf(ms, m->desc, (unsigned char) v) == -1)
+		v = file_signextend(ms, m, (uint64_t)p->b);
+		switch (check_fmt(ms, m)) {
+		case -1:
 			return -1;
-		t = m->offset + sizeof(char);
+		case 1:
+			if (snprintf(buf, sizeof(buf), "%c",
+			    (unsigned char)v) < 0)
+				return -1;
+			if (file_printf(ms, m->desc, buf) == -1)
+				return -1;
+			break;
+		default:
+			if (file_printf(ms, m->desc, (unsigned char) v) == -1)
+				return -1;
+			break;
+		}
+		t = ms->offset + sizeof(char);
 		break;
 
   	case FILE_SHORT:
   	case FILE_BESHORT:
   	case FILE_LESHORT:
-		v = file_signextend(ms, m, (size_t)p->h);
-		if (file_printf(ms, m->desc, (unsigned short) v) == -1)
+		v = file_signextend(ms, m, (uint64_t)p->h);
+		switch (check_fmt(ms, m)) {
+		case -1:
 			return -1;
-		t = m->offset + sizeof(short);
+		case 1:
+			if (snprintf(buf, sizeof(buf), "%hu",
+			    (unsigned short)v) < 0)
+				return -1;
+			if (file_printf(ms, m->desc, buf) == -1)
+				return -1;
+			break;
+		default:
+			if (file_printf(ms, m->desc, (unsigned short) v) == -1)
+				return -1;
+			break;
+		}
+		t = ms->offset + sizeof(short);
 		break;
 
   	case FILE_LONG:
   	case FILE_BELONG:
   	case FILE_LELONG:
   	case FILE_MELONG:
-		v = file_signextend(ms, m, p->l);
-		if (file_printf(ms, m->desc, (uint32_t) v) == -1)
+		v = file_signextend(ms, m, (uint64_t)p->l);
+		switch (check_fmt(ms, m)) {
+		case -1:
 			return -1;
-		t = m->offset + sizeof(int32_t);
+		case 1:
+			if (snprintf(buf, sizeof(buf), "%u", (uint32_t)v) < 0)
+				return -1;
+			if (file_printf(ms, m->desc, buf) == -1)
+				return -1;
+			break;
+		default:
+			if (file_printf(ms, m->desc, (uint32_t) v) == -1)
+				return -1;
+			break;
+		}
+		t = ms->offset + sizeof(int32_t);
   		break;
 
+  	case FILE_QUAD:
+  	case FILE_BEQUAD:
+  	case FILE_LEQUAD:
+		v = file_signextend(ms, m, p->q);
+		if (file_printf(ms, m->desc, (uint64_t) v) == -1)
+			return -1;
+		t = ms->offset + sizeof(int64_t);
+  		break;
   	case FILE_STRING:
   	case FILE_PSTRING:
   	case FILE_BESTRING16:
@@ -286,7 +371,7 @@ mprint(struct magic_set *ms, union VALUETYPE *p, struct magic *m)
 		if (m->reln == '=' || m->reln == '!') {
 			if (file_printf(ms, m->desc, m->value.s) == -1)
 				return -1;
-			t = m->offset + m->vallen;
+			t = ms->offset + m->vallen;
 		}
 		else {
 			if (*m->value.s == '\0') {
@@ -296,7 +381,7 @@ mprint(struct magic_set *ms, union VALUETYPE *p, struct magic *m)
 			}
 			if (file_printf(ms, m->desc, p->s) == -1)
 				return -1;
-			t = m->offset + strlen(p->s);
+			t = ms->offset + strlen(p->s);
 		}
 		break;
 
@@ -306,7 +391,7 @@ mprint(struct magic_set *ms, union VALUETYPE *p, struct magic *m)
 	case FILE_MEDATE:
 		if (file_printf(ms, m->desc, file_fmttime(p->l, 1)) == -1)
 			return -1;
-		t = m->offset + sizeof(time_t);
+		t = ms->offset + sizeof(time_t);
 		break;
 
 	case FILE_LDATE:
@@ -315,17 +400,37 @@ mprint(struct magic_set *ms, union VALUETYPE *p, struct magic *m)
 	case FILE_MELDATE:
 		if (file_printf(ms, m->desc, file_fmttime(p->l, 0)) == -1)
 			return -1;
-		t = m->offset + sizeof(time_t);
+		t = ms->offset + sizeof(time_t);
+		break;
+
+	case FILE_QDATE:
+	case FILE_BEQDATE:
+	case FILE_LEQDATE:
+		if (file_printf(ms, m->desc, file_fmttime((uint32_t)p->q, 1))
+		    == -1)
+			return -1;
+		t = ms->offset + sizeof(uint64_t);
+		break;
+
+	case FILE_QLDATE:
+	case FILE_BEQLDATE:
+	case FILE_LEQLDATE:
+		if (file_printf(ms, m->desc, file_fmttime((uint32_t)p->q, 0))
+		    == -1)
+			return -1;
+		t = ms->offset + sizeof(uint64_t);
 		break;
+
 	case FILE_REGEX:
 	  	if (file_printf(ms, m->desc, p->s) == -1)
 			return -1;
-		t = m->offset + strlen(p->s);
+		t = ms->offset + strlen(p->s);
 		break;
+
 	case FILE_SEARCH:
 	  	if (file_printf(ms, m->desc, m->value.s) == -1)
 			return -1;
-		t = m->offset + m->vallen;
+		t = ms->offset + m->vallen;
 		break;
 
 	default:
@@ -335,6 +440,62 @@ mprint(struct magic_set *ms, union VALUETYPE *p, struct magic *m)
 	return(t);
 }
 
+
+#define DO_CVT(fld, cast) \
+	if (m->mask) \
+		switch (m->mask_op & 0x7F) { \
+		case FILE_OPAND: \
+			p->fld &= cast m->mask; \
+			break; \
+		case FILE_OPOR: \
+			p->fld |= cast m->mask; \
+			break; \
+		case FILE_OPXOR: \
+			p->fld ^= cast m->mask; \
+			break; \
+		case FILE_OPADD: \
+			p->fld += cast m->mask; \
+			break; \
+		case FILE_OPMINUS: \
+			p->fld -= cast m->mask; \
+			break; \
+		case FILE_OPMULTIPLY: \
+			p->fld *= cast m->mask; \
+			break; \
+		case FILE_OPDIVIDE: \
+			p->fld /= cast m->mask; \
+			break; \
+		case FILE_OPMODULO: \
+			p->fld %= cast m->mask; \
+			break; \
+		} \
+	if (m->mask_op & FILE_OPINVERSE) \
+		p->fld = ~p->fld \
+
+private void
+cvt_8(union VALUETYPE *p, const struct magic *m)
+{
+	DO_CVT(b, (uint8_t));
+}
+
+private void
+cvt_16(union VALUETYPE *p, const struct magic *m)
+{
+	DO_CVT(h, (uint16_t));
+}
+
+private void
+cvt_32(union VALUETYPE *p, const struct magic *m)
+{
+	DO_CVT(l, (uint32_t));
+}
+
+private void
+cvt_64(union VALUETYPE *p, const struct magic *m)
+{
+	DO_CVT(q, (uint64_t));
+}
+
 /*
  * Convert the byte order of the data we are looking at
  * While we're here, let's apply the mask operation
@@ -345,99 +506,20 @@ mconvert(struct magic_set *ms, union VALUETYPE *p, struct magic *m)
 {
 	switch (m->type) {
 	case FILE_BYTE:
-		if (m->mask)
-			switch (m->mask_op & 0x7F) {
-			case FILE_OPAND:
-				p->b &= m->mask;
-				break;
-			case FILE_OPOR:
-				p->b |= m->mask;
-				break;
-			case FILE_OPXOR:
-				p->b ^= m->mask;
-				break;
-			case FILE_OPADD:
-				p->b += m->mask;
-				break;
-			case FILE_OPMINUS:
-				p->b -= m->mask;
-				break;
-			case FILE_OPMULTIPLY:
-				p->b *= m->mask;
-				break;
-			case FILE_OPDIVIDE:
-				p->b /= m->mask;
-				break;
-			case FILE_OPMODULO:
-				p->b %= m->mask;
-				break;
-			}
-		if (m->mask_op & FILE_OPINVERSE)
-			p->b = ~p->b;
+		cvt_8(p, m);
 		return 1;
 	case FILE_SHORT:
-		if (m->mask)
-			switch (m->mask_op & 0x7F) {
-			case FILE_OPAND:
-				p->h &= m->mask;
-				break;
-			case FILE_OPOR:
-				p->h |= m->mask;
-				break;
-			case FILE_OPXOR:
-				p->h ^= m->mask;
-				break;
-			case FILE_OPADD:
-				p->h += m->mask;
-				break;
-			case FILE_OPMINUS:
-				p->h -= m->mask;
-				break;
-			case FILE_OPMULTIPLY:
-				p->h *= m->mask;
-				break;
-			case FILE_OPDIVIDE:
-				p->h /= m->mask;
-				break;
-			case FILE_OPMODULO:
-				p->h %= m->mask;
-				break;
-			}
-		if (m->mask_op & FILE_OPINVERSE)
-			p->h = ~p->h;
+		cvt_16(p, m);
 		return 1;
 	case FILE_LONG:
 	case FILE_DATE:
 	case FILE_LDATE:
-		if (m->mask)
-			switch (m->mask_op & 0x7F) {
-			case FILE_OPAND:
-				p->l &= m->mask;
-				break;
-			case FILE_OPOR:
-				p->l |= m->mask;
-				break;
-			case FILE_OPXOR:
-				p->l ^= m->mask;
-				break;
-			case FILE_OPADD:
-				p->l += m->mask;
-				break;
-			case FILE_OPMINUS:
-				p->l -= m->mask;
-				break;
-			case FILE_OPMULTIPLY:
-				p->l *= m->mask;
-				break;
-			case FILE_OPDIVIDE:
-				p->l /= m->mask;
-				break;
-			case FILE_OPMODULO:
-				p->l %= m->mask;
-				break;
-			}
-		if (m->mask_op & FILE_OPINVERSE)
-			p->l = ~p->l;
+		cvt_32(p, m);
+		return 1;
+	case FILE_QUAD:
+	case FILE_QDATE:
+	case FILE_QLDATE:
+		cvt_64(p, m);
 		return 1;
 	case FILE_STRING:
 	case FILE_BESTRING16:
@@ -468,172 +550,50 @@ mconvert(struct magic_set *ms, union VALUETYPE *p, struct magic *m)
 		}
 	case FILE_BESHORT:
 		p->h = (short)((p->hs[0]<<8)|(p->hs[1]));
-		if (m->mask)
-			switch (m->mask_op&0x7F) {
-			case FILE_OPAND:
-				p->h &= m->mask;
-				break;
-			case FILE_OPOR:
-				p->h |= m->mask;
-				break;
-			case FILE_OPXOR:
-				p->h ^= m->mask;
-				break;
-			case FILE_OPADD:
-				p->h += m->mask;
-				break;
-			case FILE_OPMINUS:
-				p->h -= m->mask;
-				break;
-			case FILE_OPMULTIPLY:
-				p->h *= m->mask;
-				break;
-			case FILE_OPDIVIDE:
-				p->h /= m->mask;
-				break;
-			case FILE_OPMODULO:
-				p->h %= m->mask;
-				break;
-			}
-		if (m->mask_op & FILE_OPINVERSE)
-			p->h = ~p->h;
+		cvt_16(p, m);
 		return 1;
 	case FILE_BELONG:
 	case FILE_BEDATE:
 	case FILE_BELDATE:
 		p->l = (int32_t)
 		    ((p->hl[0]<<24)|(p->hl[1]<<16)|(p->hl[2]<<8)|(p->hl[3]));
-		if (m->mask)
-			switch (m->mask_op&0x7F) {
-			case FILE_OPAND:
-				p->l &= m->mask;
-				break;
-			case FILE_OPOR:
-				p->l |= m->mask;
-				break;
-			case FILE_OPXOR:
-				p->l ^= m->mask;
-				break;
-			case FILE_OPADD:
-				p->l += m->mask;
-				break;
-			case FILE_OPMINUS:
-				p->l -= m->mask;
-				break;
-			case FILE_OPMULTIPLY:
-				p->l *= m->mask;
-				break;
-			case FILE_OPDIVIDE:
-				p->l /= m->mask;
-				break;
-			case FILE_OPMODULO:
-				p->l %= m->mask;
-				break;
-			}
-		if (m->mask_op & FILE_OPINVERSE)
-			p->l = ~p->l;
+		cvt_32(p, m);
+		return 1;
+	case FILE_BEQUAD:
+	case FILE_BEQDATE:
+	case FILE_BEQLDATE:
+		p->q = (int64_t)
+		    (((int64_t)p->hq[0]<<56)|((int64_t)p->hq[1]<<48)|
+		     ((int64_t)p->hq[2]<<40)|((int64_t)p->hq[3]<<32)|
+		     (p->hq[4]<<24)|(p->hq[5]<<16)|(p->hq[6]<<8)|(p->hq[7]));
+		cvt_64(p, m);
 		return 1;
 	case FILE_LESHORT:
 		p->h = (short)((p->hs[1]<<8)|(p->hs[0]));
-		if (m->mask)
-			switch (m->mask_op&0x7F) {
-			case FILE_OPAND:
-				p->h &= m->mask;
-				break;
-			case FILE_OPOR:
-				p->h |= m->mask;
-				break;
-			case FILE_OPXOR:
-				p->h ^= m->mask;
-				break;
-			case FILE_OPADD:
-				p->h += m->mask;
-				break;
-			case FILE_OPMINUS:
-				p->h -= m->mask;
-				break;
-			case FILE_OPMULTIPLY:
-				p->h *= m->mask;
-				break;
-			case FILE_OPDIVIDE:
-				p->h /= m->mask;
-				break;
-			case FILE_OPMODULO:
-				p->h %= m->mask;
-				break;
-			}
-		if (m->mask_op & FILE_OPINVERSE)
-			p->h = ~p->h;
+		cvt_16(p, m);
 		return 1;
 	case FILE_LELONG:
 	case FILE_LEDATE:
 	case FILE_LELDATE:
 		p->l = (int32_t)
 		    ((p->hl[3]<<24)|(p->hl[2]<<16)|(p->hl[1]<<8)|(p->hl[0]));
-		if (m->mask)
-			switch (m->mask_op&0x7F) {
-			case FILE_OPAND:
-				p->l &= m->mask;
-				break;
-			case FILE_OPOR:
-				p->l |= m->mask;
-				break;
-			case FILE_OPXOR:
-				p->l ^= m->mask;
-				break;
-			case FILE_OPADD:
-				p->l += m->mask;
-				break;
-			case FILE_OPMINUS:
-				p->l -= m->mask;
-				break;
-			case FILE_OPMULTIPLY:
-				p->l *= m->mask;
-				break;
-			case FILE_OPDIVIDE:
-				p->l /= m->mask;
-				break;
-			case FILE_OPMODULO:
-				p->l %= m->mask;
-				break;
-			}
-		if (m->mask_op & FILE_OPINVERSE)
-			p->l = ~p->l;
+		cvt_32(p, m);
+		return 1;
+	case FILE_LEQUAD:
+	case FILE_LEQDATE:
+	case FILE_LEQLDATE:
+		p->q = (int64_t)
+		    (((int64_t)p->hq[7]<<56)|((int64_t)p->hq[6]<<48)|
+		     ((int64_t)p->hq[5]<<40)|((int64_t)p->hq[4]<<32)|
+		     (p->hq[3]<<24)|(p->hq[2]<<16)|(p->hq[1]<<8)|(p->hq[0]));
+		cvt_64(p, m);
 		return 1;
 	case FILE_MELONG:
 	case FILE_MEDATE:
 	case FILE_MELDATE:
 		p->l = (int32_t)
 		    ((p->hl[1]<<24)|(p->hl[0]<<16)|(p->hl[3]<<8)|(p->hl[2]));
-		if (m->mask)
-			switch (m->mask_op&0x7F) {
-			case FILE_OPAND:
-				p->l &= m->mask;
-				break;
-			case FILE_OPOR:
-				p->l |= m->mask;
-				break;
-			case FILE_OPXOR:
-				p->l ^= m->mask;
-				break;
-			case FILE_OPADD:
-				p->l += m->mask;
-				break;
-			case FILE_OPMINUS:
-				p->l -= m->mask;
-				break;
-			case FILE_OPMULTIPLY:
-				p->l *= m->mask;
-				break;
-			case FILE_OPDIVIDE:
-				p->l /= m->mask;
-				break;
-			case FILE_OPMODULO:
-				p->l %= m->mask;
-				break;
-			}
-		if (m->mask_op & FILE_OPINVERSE)
-			p->l = ~p->l;
+		cvt_32(p, m);
 		return 1;
 	case FILE_REGEX:
 	case FILE_SEARCH:
@@ -656,7 +616,7 @@ mdebug(uint32_t offset, const char *str, size_t len)
 
 private int
 mcopy(struct magic_set *ms, union VALUETYPE *p, int type, int indir,
-    const unsigned char *s, size_t offset, size_t nbytes)
+    const unsigned char *s, uint32_t offset, size_t nbytes)
 {
 	if (type == FILE_REGEX && indir == 0) {
 		/*
@@ -670,7 +630,7 @@ mcopy(struct magic_set *ms, union VALUETYPE *p, int type, int indir,
 			return 0;
 		}
 		if ((p->search.buf = strdup((const char *)s)) == NULL) {
-			file_oomem(ms);
+			file_oomem(ms, strlen((const char *)s));
 			return -1;
 		}
 		for (b = p->search.buf; offset && 
@@ -694,6 +654,13 @@ mcopy(struct magic_set *ms, union VALUETYPE *p, int type, int indir,
 		if (type == FILE_BESTRING16)
 			src++;
 
+		/* check for pointer overflow */
+		if (src < s) {
+			file_error(ms, 0, "invalid offset %zu in mcopy()",
+			    offset);
+			return -1;
+		}
+
 		for (;src < esrc; src++, dst++) {
 			if (dst < edst)
 				*dst = *src++;
@@ -731,7 +698,7 @@ private int
 mget(struct magic_set *ms, union VALUETYPE *p, const unsigned char *s,
     struct magic *m, size_t nbytes, unsigned int cont_level)
 {
-	uint32_t offset = m->offset;
+	uint32_t offset = ms->offset;
 
 	if (mcopy(ms, p, m->type, m->flag & INDIR, s, offset, nbytes) == -1)
 		return -1;
@@ -1208,7 +1175,7 @@ mget(struct magic_set *ms, union VALUETYPE *p, const unsigned char *s,
 		if (m->flag & INDIROFFADD) offset += ms->c.off[cont_level-1];
 		if (mcopy(ms, p, m->type, 0, s, offset, nbytes) == -1)
 			return -1;
-		m->offset = offset;
+		ms->offset = offset;
 
 		if ((ms->flags & MAGIC_DEBUG) != 0) {
 			mdebug(offset, (char *)(void *)p,
@@ -1257,7 +1224,7 @@ mget(struct magic_set *ms, union VALUETYPE *p, const unsigned char *s,
 	}
 
 	if (m->type == FILE_SEARCH) {
-		size_t mlen = m->mask + m->vallen;
+		size_t mlen = (size_t)(m->mask + m->vallen);
 		size_t flen = nbytes - offset;
 		if (flen < mlen)
 			mlen = flen;
@@ -1276,10 +1243,10 @@ mget(struct magic_set *ms, union VALUETYPE *p, const unsigned char *s,
 }
 
 private int
-mcheck(struct magic_set *ms, union VALUETYPE *p, struct magic *m)
+magiccheck(struct magic_set *ms, union VALUETYPE *p, struct magic *m)
 {
-	uint32_t l = m->value.l;
-	uint32_t v;
+	uint64_t l = m->value.q;
+	uint64_t v;
 	int matched;
 
 	if ( (m->value.s[0] == 'x') && (m->value.s[1] == '\0') ) {
@@ -1313,6 +1280,18 @@ mcheck(struct magic_set *ms, union VALUETYPE *p, struct magic *m)
 		v = p->l;
 		break;
 
+	case FILE_QUAD:
+	case FILE_LEQUAD:
+	case FILE_BEQUAD:
+	case FILE_QDATE:
+	case FILE_BEQDATE:
+	case FILE_LEQDATE:
+	case FILE_QLDATE:
+	case FILE_BEQLDATE:
+	case FILE_LEQLDATE:
+		v = p->q;
+		break;
+
 	case FILE_STRING:
 	case FILE_BESTRING16:
 	case FILE_LESTRING16:
@@ -1408,21 +1387,25 @@ mcheck(struct magic_set *ms, union VALUETYPE *p, struct magic *m)
 			while (len-- > 0 && (v = *b++ - *a++) == 0)
 				continue;
 			if (!v) {
-				m->offset += range - 1;
+				ms->offset += range - 1;
 				break;
 			}
-			if (range + slen >= p->search.buflen)
+			if (range + slen >= p->search.buflen) {
+				v = 1;
 				break;
+			}
 			len = slen;
 			a = (unsigned char*)m->value.s;
 			b = (unsigned char*)p->search.buf + range;
 		}
 		free(p->search.buf);
 		p->search.buf = NULL;
+		if (v)
+			return 0;
 		break;
 	}
 	default:
-		file_error(ms, 0, "invalid type %d in mcheck()", m->type);
+		file_error(ms, 0, "invalid type %d in magiccheck()", m->type);
 		return -1;
 	}
 
@@ -1432,36 +1415,40 @@ mcheck(struct magic_set *ms, union VALUETYPE *p, struct magic *m)
 	switch (m->reln) {
 	case 'x':
 		if ((ms->flags & MAGIC_DEBUG) != 0)
-			(void) fprintf(stderr, "%u == *any* = 1\n", v);
+			(void) fprintf(stderr, "%llu == *any* = 1\n",
+			    (unsigned long long)v);
 		matched = 1;
 		break;
 
 	case '!':
 		matched = v != l;
 		if ((ms->flags & MAGIC_DEBUG) != 0)
-			(void) fprintf(stderr, "%u != %u = %d\n",
-				       v, l, matched);
+			(void) fprintf(stderr, "%llu != %llu = %d\n",
+			    (unsigned long long)v, (unsigned long long)l,
+			    matched);
 		break;
 
 	case '=':
 		matched = v == l;
 		if ((ms->flags & MAGIC_DEBUG) != 0)
-			(void) fprintf(stderr, "%u == %u = %d\n",
-				       v, l, matched);
+			(void) fprintf(stderr, "%llu == %llu = %d\n",
+			    (unsigned long long)v, (unsigned long long)l,
+			    matched);
 		break;
 
 	case '>':
 		if (m->flag & UNSIGNED) {
 			matched = v > l;
 			if ((ms->flags & MAGIC_DEBUG) != 0)
-				(void) fprintf(stderr, "%u > %u = %d\n",
-					       v, l, matched);
+				(void) fprintf(stderr, "%llu > %llu = %d\n",
+				    (unsigned long long)v,
+				    (unsigned long long)l, matched);
 		}
 		else {
 			matched = (int32_t) v > (int32_t) l;
 			if ((ms->flags & MAGIC_DEBUG) != 0)
-				(void) fprintf(stderr, "%d > %d = %d\n",
-					       v, l, matched);
+				(void) fprintf(stderr, "%lld > %lld = %d\n",
+				    (long long)v, (long long)l, matched);
 		}
 		break;
 
@@ -1469,29 +1456,32 @@ mcheck(struct magic_set *ms, union VALUETYPE *p, struct magic *m)
 		if (m->flag & UNSIGNED) {
 			matched = v < l;
 			if ((ms->flags & MAGIC_DEBUG) != 0)
-				(void) fprintf(stderr, "%u < %u = %d\n",
-					       v, l, matched);
+				(void) fprintf(stderr, "%llu < %llu = %d\n",
+				    (unsigned long long)v,
+				    (unsigned long long)l, matched);
 		}
 		else {
 			matched = (int32_t) v < (int32_t) l;
 			if ((ms->flags & MAGIC_DEBUG) != 0)
-				(void) fprintf(stderr, "%d < %d = %d\n",
-					       v, l, matched);
+				(void) fprintf(stderr, "%lld < %lld = %d\n",
+				       (long long)v, (long long)l, matched);
 		}
 		break;
 
 	case '&':
 		matched = (v & l) == l;
 		if ((ms->flags & MAGIC_DEBUG) != 0)
-			(void) fprintf(stderr, "((%x & %x) == %x) = %d\n",
-				       v, l, l, matched);
+			(void) fprintf(stderr, "((%llx & %llx) == %llx) = %d\n",
+			    (unsigned long long)v, (unsigned long long)l,
+			    (unsigned long long)l, matched);
 		break;
 
 	case '^':
 		matched = (v & l) != l;
 		if ((ms->flags & MAGIC_DEBUG) != 0)
-			(void) fprintf(stderr, "((%x & %x) != %x) = %d\n",
-				       v, l, l, matched);
+			(void) fprintf(stderr, "((%llx & %llx) != %llx) = %d\n",
+			    (unsigned long long)v, (unsigned long long)l,
+			    (unsigned long long)l, matched);
 		break;
 
 	default:
@@ -1503,3 +1493,15 @@ mcheck(struct magic_set *ms, union VALUETYPE *p, struct magic *m)
 
 	return matched;
 }
+
+private int
+print_sep(struct magic_set *ms, int firstline)
+{
+	if (firstline)
+		return 0;
+	/*
+	 * we found another match 
+	 * put a newline and '-' to do some simple formatting
+	 */
+	return file_printf(ms, "\n- ");
+}