softmagic.c 55 KB

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