softmagic.c 48 KB

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