softmagic.c 58 KB

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