apprentice.c 38 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853
  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. * apprentice - make one pass through /etc/magic, learning its secrets.
  30. */
  31. #include "file.h"
  32. #include "magic.h"
  33. #include <stdlib.h>
  34. #ifdef HAVE_UNISTD_H
  35. #include <unistd.h>
  36. #endif
  37. #include <string.h>
  38. #include <assert.h>
  39. #include <ctype.h>
  40. #include <fcntl.h>
  41. #include <sys/stat.h>
  42. #include <sys/param.h>
  43. #ifdef QUICK
  44. #include <sys/mman.h>
  45. #endif
  46. #ifndef lint
  47. FILE_RCSID("@(#)$File: apprentice.c,v 1.105 2007/05/16 20:51:40 christos Exp $")
  48. #endif /* lint */
  49. #define EATAB {while (isascii((unsigned char) *l) && \
  50. isspace((unsigned char) *l)) ++l;}
  51. #define LOWCASE(l) (isupper((unsigned char) (l)) ? \
  52. tolower((unsigned char) (l)) : (l))
  53. /*
  54. * Work around a bug in headers on Digital Unix.
  55. * At least confirmed for: OSF1 V4.0 878
  56. */
  57. #if defined(__osf__) && defined(__DECC)
  58. #ifdef MAP_FAILED
  59. #undef MAP_FAILED
  60. #endif
  61. #endif
  62. #ifndef MAP_FAILED
  63. #define MAP_FAILED (void *) -1
  64. #endif
  65. #ifndef MAP_FILE
  66. #define MAP_FILE 0
  67. #endif
  68. #ifndef MAXPATHLEN
  69. #define MAXPATHLEN 1024
  70. #endif
  71. struct magic_entry {
  72. struct magic *mp;
  73. uint32_t cont_count;
  74. uint32_t max_count;
  75. };
  76. int file_formats[FILE_NAMES_SIZE];
  77. const size_t file_nformats = FILE_NAMES_SIZE;
  78. const char *file_names[FILE_NAMES_SIZE];
  79. const size_t file_nnames = FILE_NAMES_SIZE;
  80. private int getvalue(struct magic_set *ms, struct magic *, const char **, int);
  81. private int hextoint(int);
  82. private const char *getstr(struct magic_set *, const char *, char *, int,
  83. int *, int);
  84. private int parse(struct magic_set *, struct magic_entry **, uint32_t *,
  85. const char *, size_t, int);
  86. private void eatsize(const char **);
  87. private int apprentice_1(struct magic_set *, const char *, int, struct mlist *);
  88. private size_t apprentice_magic_strength(const struct magic *);
  89. private int apprentice_sort(const void *, const void *);
  90. private int apprentice_file(struct magic_set *, struct magic **, uint32_t *,
  91. const char *, int);
  92. private void byteswap(struct magic *, uint32_t);
  93. private void bs1(struct magic *);
  94. private uint16_t swap2(uint16_t);
  95. private uint32_t swap4(uint32_t);
  96. private uint64_t swap8(uint64_t);
  97. private char *mkdbname(const char *, char *, size_t, int);
  98. private int apprentice_map(struct magic_set *, struct magic **, uint32_t *,
  99. const char *);
  100. private int apprentice_compile(struct magic_set *, struct magic **, uint32_t *,
  101. const char *);
  102. private int check_format_type(const char *, int);
  103. private int check_format(struct magic_set *, struct magic *);
  104. private size_t maxmagic = 0;
  105. private size_t magicsize = sizeof(struct magic);
  106. #ifdef COMPILE_ONLY
  107. int main(int, char *[]);
  108. int
  109. main(int argc, char *argv[])
  110. {
  111. int ret;
  112. struct magic_set *ms;
  113. char *progname;
  114. if ((progname = strrchr(argv[0], '/')) != NULL)
  115. progname++;
  116. else
  117. progname = argv[0];
  118. if (argc != 2) {
  119. (void)fprintf(stderr, "Usage: %s file\n", progname);
  120. return 1;
  121. }
  122. if ((ms = magic_open(MAGIC_CHECK)) == NULL) {
  123. (void)fprintf(stderr, "%s: %s\n", progname, strerror(errno));
  124. return 1;
  125. }
  126. ret = magic_compile(ms, argv[1]) == -1 ? 1 : 0;
  127. if (ret == 1)
  128. (void)fprintf(stderr, "%s: %s\n", progname, magic_error(ms));
  129. magic_close(ms);
  130. return ret;
  131. }
  132. #endif /* COMPILE_ONLY */
  133. static const struct type_tbl_s {
  134. const char *name;
  135. const size_t len;
  136. const int type;
  137. const int format;
  138. } type_tbl[] = {
  139. # define XX(s) s, (sizeof(s) - 1)
  140. # define XX_NULL NULL, 0
  141. { XX("byte"), FILE_BYTE, FILE_FMT_NUM },
  142. { XX("short"), FILE_SHORT, FILE_FMT_NUM },
  143. { XX("default"), FILE_DEFAULT, FILE_FMT_STR },
  144. { XX("long"), FILE_LONG, FILE_FMT_NUM },
  145. { XX("string"), FILE_STRING, FILE_FMT_STR },
  146. { XX("date"), FILE_DATE, FILE_FMT_STR },
  147. { XX("beshort"), FILE_BESHORT, FILE_FMT_NUM },
  148. { XX("belong"), FILE_BELONG, FILE_FMT_NUM },
  149. { XX("bedate"), FILE_BEDATE, FILE_FMT_STR },
  150. { XX("leshort"), FILE_LESHORT, FILE_FMT_NUM },
  151. { XX("lelong"), FILE_LELONG, FILE_FMT_NUM },
  152. { XX("ledate"), FILE_LEDATE, FILE_FMT_STR },
  153. { XX("pstring"), FILE_PSTRING, FILE_FMT_STR },
  154. { XX("ldate"), FILE_LDATE, FILE_FMT_STR },
  155. { XX("beldate"), FILE_BELDATE, FILE_FMT_STR },
  156. { XX("leldate"), FILE_LELDATE, FILE_FMT_STR },
  157. { XX("regex"), FILE_REGEX, FILE_FMT_STR },
  158. { XX("bestring16"), FILE_BESTRING16, FILE_FMT_STR },
  159. { XX("lestring16"), FILE_LESTRING16, FILE_FMT_STR },
  160. { XX("search"), FILE_SEARCH, FILE_FMT_STR },
  161. { XX("medate"), FILE_MEDATE, FILE_FMT_STR },
  162. { XX("meldate"), FILE_MELDATE, FILE_FMT_STR },
  163. { XX("melong"), FILE_MELONG, FILE_FMT_NUM },
  164. { XX("quad"), FILE_QUAD, FILE_FMT_QUAD },
  165. { XX("lequad"), FILE_LEQUAD, FILE_FMT_QUAD },
  166. { XX("bequad"), FILE_BEQUAD, FILE_FMT_QUAD },
  167. { XX("qdate"), FILE_QDATE, FILE_FMT_STR },
  168. { XX("leqdate"), FILE_LEQDATE, FILE_FMT_STR },
  169. { XX("beqdate"), FILE_BEQDATE, FILE_FMT_STR },
  170. { XX("qldate"), FILE_QLDATE, FILE_FMT_STR },
  171. { XX("leqldate"), FILE_LEQLDATE, FILE_FMT_STR },
  172. { XX("beqldate"), FILE_BEQLDATE, FILE_FMT_STR },
  173. { XX_NULL, FILE_INVALID, FILE_FMT_NONE },
  174. # undef XX
  175. # undef XX_NULL
  176. };
  177. private int
  178. get_type(const char *l, const char **t)
  179. {
  180. const struct type_tbl_s *p;
  181. for (p = type_tbl; p->name; p++) {
  182. if (strncmp(l, p->name, p->len) == 0) {
  183. if (t)
  184. *t = l + p->len;
  185. break;
  186. }
  187. }
  188. return p->type;
  189. }
  190. private void
  191. init_file_tables(void)
  192. {
  193. static int done = 0;
  194. const struct type_tbl_s *p;
  195. if (done)
  196. return;
  197. done++;
  198. for (p = type_tbl; p->name; p++) {
  199. assert(p->type < FILE_NAMES_SIZE);
  200. file_names[p->type] = p->name;
  201. file_formats[p->type] = p->format;
  202. }
  203. }
  204. /*
  205. * Handle one file.
  206. */
  207. private int
  208. apprentice_1(struct magic_set *ms, const char *fn, int action,
  209. struct mlist *mlist)
  210. {
  211. struct magic *magic = NULL;
  212. uint32_t nmagic = 0;
  213. struct mlist *ml;
  214. int rv = -1;
  215. int mapped;
  216. if (magicsize != FILE_MAGICSIZE) {
  217. file_error(ms, 0, "magic element size %lu != %lu",
  218. (unsigned long)sizeof(*magic),
  219. (unsigned long)FILE_MAGICSIZE);
  220. return -1;
  221. }
  222. if (action == FILE_COMPILE) {
  223. rv = apprentice_file(ms, &magic, &nmagic, fn, action);
  224. if (rv != 0)
  225. return -1;
  226. rv = apprentice_compile(ms, &magic, &nmagic, fn);
  227. free(magic);
  228. return rv;
  229. }
  230. #ifndef COMPILE_ONLY
  231. if ((rv = apprentice_map(ms, &magic, &nmagic, fn)) == -1) {
  232. if (ms->flags & MAGIC_CHECK)
  233. file_magwarn(ms, "using regular magic file `%s'", fn);
  234. rv = apprentice_file(ms, &magic, &nmagic, fn, action);
  235. if (rv != 0)
  236. return -1;
  237. mapped = 0;
  238. }
  239. mapped = rv;
  240. if (magic == NULL || nmagic == 0) {
  241. file_delmagic(magic, mapped, nmagic);
  242. return -1;
  243. }
  244. if ((ml = malloc(sizeof(*ml))) == NULL) {
  245. file_delmagic(magic, mapped, nmagic);
  246. file_oomem(ms, sizeof(*ml));
  247. return -1;
  248. }
  249. ml->magic = magic;
  250. ml->nmagic = nmagic;
  251. ml->mapped = mapped;
  252. mlist->prev->next = ml;
  253. ml->prev = mlist->prev;
  254. ml->next = mlist;
  255. mlist->prev = ml;
  256. return 0;
  257. #endif /* COMPILE_ONLY */
  258. }
  259. protected void
  260. file_delmagic(struct magic *p, int type, size_t entries)
  261. {
  262. if (p == NULL)
  263. return;
  264. switch (type) {
  265. case 2:
  266. p--;
  267. (void)munmap((void *)p, sizeof(*p) * (entries + 1));
  268. break;
  269. case 1:
  270. p--;
  271. /*FALLTHROUGH*/
  272. case 0:
  273. free(p);
  274. break;
  275. default:
  276. abort();
  277. }
  278. }
  279. /* const char *fn: list of magic files */
  280. protected struct mlist *
  281. file_apprentice(struct magic_set *ms, const char *fn, int action)
  282. {
  283. char *p, *mfn, *afn = NULL;
  284. int file_err, errs = -1;
  285. struct mlist *mlist;
  286. static const char mime[] = ".mime";
  287. init_file_tables();
  288. if (fn == NULL)
  289. fn = getenv("MAGIC");
  290. if (fn == NULL)
  291. fn = MAGIC;
  292. if ((mfn = strdup(fn)) == NULL) {
  293. file_oomem(ms, strlen(fn));
  294. return NULL;
  295. }
  296. fn = mfn;
  297. if ((mlist = malloc(sizeof(*mlist))) == NULL) {
  298. free(mfn);
  299. file_oomem(ms, sizeof(*mlist));
  300. return NULL;
  301. }
  302. mlist->next = mlist->prev = mlist;
  303. while (fn) {
  304. p = strchr(fn, PATHSEP);
  305. if (p)
  306. *p++ = '\0';
  307. if (*fn == '\0')
  308. break;
  309. if (ms->flags & MAGIC_MIME) {
  310. size_t len = strlen(fn) + sizeof(mime);
  311. if ((afn = malloc(len)) == NULL) {
  312. free(mfn);
  313. free(mlist);
  314. file_oomem(ms, len);
  315. return NULL;
  316. }
  317. (void)strcpy(afn, fn);
  318. (void)strcat(afn, mime);
  319. fn = afn;
  320. }
  321. file_err = apprentice_1(ms, fn, action, mlist);
  322. if (file_err > errs)
  323. errs = file_err;
  324. if (afn) {
  325. free(afn);
  326. afn = NULL;
  327. }
  328. fn = p;
  329. }
  330. if (errs == -1) {
  331. free(mfn);
  332. free(mlist);
  333. mlist = NULL;
  334. file_error(ms, 0, "could not find any magic files!");
  335. return NULL;
  336. }
  337. free(mfn);
  338. return mlist;
  339. }
  340. /*
  341. * Get weight of this magic entry, for sorting purposes.
  342. */
  343. private size_t
  344. apprentice_magic_strength(const struct magic *m)
  345. {
  346. #define MULT 10
  347. size_t val = 2 * MULT; /* baseline strength */
  348. switch (m->type) {
  349. case FILE_DEFAULT: /* make sure this sorts last */
  350. return 0;
  351. case FILE_BYTE:
  352. val += 1 * MULT;
  353. break;
  354. case FILE_SHORT:
  355. case FILE_LESHORT:
  356. case FILE_BESHORT:
  357. val += 2 * MULT;
  358. break;
  359. case FILE_LONG:
  360. case FILE_LELONG:
  361. case FILE_BELONG:
  362. case FILE_MELONG:
  363. val += 4 * MULT;
  364. break;
  365. case FILE_PSTRING:
  366. case FILE_STRING:
  367. val += m->vallen * MULT;
  368. break;
  369. case FILE_BESTRING16:
  370. case FILE_LESTRING16:
  371. val += m->vallen * MULT / 2;
  372. break;
  373. case FILE_SEARCH:
  374. case FILE_REGEX:
  375. val += m->vallen;
  376. break;
  377. case FILE_DATE:
  378. case FILE_LEDATE:
  379. case FILE_BEDATE:
  380. case FILE_MEDATE:
  381. case FILE_LDATE:
  382. case FILE_LELDATE:
  383. case FILE_BELDATE:
  384. case FILE_MELDATE:
  385. val += 4 * MULT;
  386. break;
  387. case FILE_QUAD:
  388. case FILE_BEQUAD:
  389. case FILE_LEQUAD:
  390. case FILE_QDATE:
  391. case FILE_LEQDATE:
  392. case FILE_BEQDATE:
  393. case FILE_QLDATE:
  394. case FILE_LEQLDATE:
  395. case FILE_BEQLDATE:
  396. val += 8 * MULT;
  397. break;
  398. default:
  399. val = 0;
  400. (void)fprintf(stderr, "Bad type %d\n", m->type);
  401. abort();
  402. }
  403. switch (m->reln) {
  404. case 'x': /* matches anything penalize */
  405. val = 0;
  406. break;
  407. case '!':
  408. case '=': /* Exact match, prefer */
  409. val += MULT;
  410. break;
  411. case '>':
  412. case '<': /* comparison match reduce strength */
  413. val -= 2 * MULT;
  414. break;
  415. case '^':
  416. case '&': /* masking bits, we could count them too */
  417. val -= MULT;
  418. break;
  419. default:
  420. (void)fprintf(stderr, "Bad relation %c\n", m->reln);
  421. abort();
  422. }
  423. if (val == 0) /* ensure we only return 0 for FILE_DEFAULT */
  424. val = 1;
  425. return val;
  426. }
  427. /*
  428. * Sort callback for sorting entries by "strength" (basically length)
  429. */
  430. private int
  431. apprentice_sort(const void *a, const void *b)
  432. {
  433. const struct magic_entry *ma = a;
  434. const struct magic_entry *mb = b;
  435. size_t sa = apprentice_magic_strength(ma->mp);
  436. size_t sb = apprentice_magic_strength(mb->mp);
  437. if (sa == sb)
  438. return 0;
  439. else if (sa > sb)
  440. return -1;
  441. else
  442. return 1;
  443. }
  444. /*
  445. * parse from a file
  446. * const char *fn: name of magic file
  447. */
  448. private int
  449. apprentice_file(struct magic_set *ms, struct magic **magicp, uint32_t *nmagicp,
  450. const char *fn, int action)
  451. {
  452. private const char hdr[] =
  453. "cont\toffset\ttype\topcode\tmask\tvalue\tdesc";
  454. FILE *f;
  455. char line[BUFSIZ+1];
  456. int errs = 0;
  457. struct magic_entry *marray;
  458. uint32_t marraycount, i, mentrycount = 0;
  459. size_t lineno = 0;
  460. ms->flags |= MAGIC_CHECK; /* Enable checks for parsed files */
  461. f = fopen(ms->file = fn, "r");
  462. if (f == NULL) {
  463. if (errno != ENOENT)
  464. file_error(ms, errno, "cannot read magic file `%s'",
  465. fn);
  466. return -1;
  467. }
  468. maxmagic = MAXMAGIS;
  469. if ((marray = calloc(maxmagic, sizeof(*marray))) == NULL) {
  470. (void)fclose(f);
  471. file_oomem(ms, maxmagic * sizeof(*marray));
  472. return -1;
  473. }
  474. marraycount = 0;
  475. /* print silly verbose header for USG compat. */
  476. if (action == FILE_CHECK)
  477. (void)fprintf(stderr, "%s\n", hdr);
  478. /* read and parse this file */
  479. for (ms->line = 1; fgets(line, BUFSIZ, f) != NULL; ms->line++) {
  480. size_t len;
  481. len = strlen(line);
  482. if (len == 0) /* null line, garbage, etc */
  483. continue;
  484. if (line[len - 1] == '\n') {
  485. lineno++;
  486. line[len - 1] = '\0'; /* delete newline */
  487. }
  488. if (line[0] == '\0') /* empty, do not parse */
  489. continue;
  490. if (line[0] == '#') /* comment, do not parse */
  491. continue;
  492. if (parse(ms, &marray, &marraycount, line, lineno, action) != 0)
  493. errs++;
  494. }
  495. (void)fclose(f);
  496. if (errs)
  497. goto out;
  498. #ifndef NOORDER
  499. qsort(marray, marraycount, sizeof(*marray), apprentice_sort);
  500. /*
  501. * Make sure that any level 0 "default" line is last (if one exists).
  502. */
  503. for (i = 0; i < marraycount; i++) {
  504. if (marray[i].mp->cont_level == 0 &&
  505. marray[i].mp->type == FILE_DEFAULT) {
  506. while (++i < marraycount)
  507. if (marray[i].mp->cont_level == 0)
  508. break;
  509. if (i != marraycount) {
  510. ms->line = marray[i].mp->lineno; /* XXX - Ugh! */
  511. file_magwarn(ms,
  512. "level 0 \"default\" did not sort last");
  513. }
  514. break;
  515. }
  516. }
  517. #endif
  518. for (i = 0; i < marraycount; i++)
  519. mentrycount += marray[i].cont_count;
  520. if ((*magicp = malloc(sizeof(**magicp) * mentrycount)) == NULL) {
  521. file_oomem(ms, sizeof(**magicp) * mentrycount);
  522. errs++;
  523. goto out;
  524. }
  525. mentrycount = 0;
  526. for (i = 0; i < marraycount; i++) {
  527. (void)memcpy(*magicp + mentrycount, marray[i].mp,
  528. marray[i].cont_count * sizeof(**magicp));
  529. mentrycount += marray[i].cont_count;
  530. }
  531. out:
  532. for (i = 0; i < marraycount; i++)
  533. free(marray[i].mp);
  534. free(marray);
  535. if (errs) {
  536. *magicp = NULL;
  537. *nmagicp = 0;
  538. return errs;
  539. } else {
  540. *nmagicp = mentrycount;
  541. return 0;
  542. }
  543. }
  544. /*
  545. * extend the sign bit if the comparison is to be signed
  546. */
  547. protected uint64_t
  548. file_signextend(struct magic_set *ms, struct magic *m, uint64_t v)
  549. {
  550. if (!(m->flag & UNSIGNED)) {
  551. switch(m->type) {
  552. /*
  553. * Do not remove the casts below. They are
  554. * vital. When later compared with the data,
  555. * the sign extension must have happened.
  556. */
  557. case FILE_BYTE:
  558. v = (char) v;
  559. break;
  560. case FILE_SHORT:
  561. case FILE_BESHORT:
  562. case FILE_LESHORT:
  563. v = (short) v;
  564. break;
  565. case FILE_DATE:
  566. case FILE_BEDATE:
  567. case FILE_LEDATE:
  568. case FILE_MEDATE:
  569. case FILE_LDATE:
  570. case FILE_BELDATE:
  571. case FILE_LELDATE:
  572. case FILE_MELDATE:
  573. case FILE_LONG:
  574. case FILE_BELONG:
  575. case FILE_LELONG:
  576. case FILE_MELONG:
  577. v = (int32_t) v;
  578. break;
  579. case FILE_QUAD:
  580. case FILE_BEQUAD:
  581. case FILE_LEQUAD:
  582. case FILE_QDATE:
  583. case FILE_QLDATE:
  584. case FILE_BEQDATE:
  585. case FILE_BEQLDATE:
  586. case FILE_LEQDATE:
  587. case FILE_LEQLDATE:
  588. v = (int64_t) v;
  589. break;
  590. case FILE_STRING:
  591. case FILE_PSTRING:
  592. case FILE_BESTRING16:
  593. case FILE_LESTRING16:
  594. case FILE_REGEX:
  595. case FILE_SEARCH:
  596. case FILE_DEFAULT:
  597. break;
  598. default:
  599. if (ms->flags & MAGIC_CHECK)
  600. file_magwarn(ms, "cannot happen: m->type=%d\n",
  601. m->type);
  602. return ~0U;
  603. }
  604. }
  605. return v;
  606. }
  607. private int
  608. string_modifier_check(struct magic_set *ms, struct magic const *m)
  609. {
  610. if ((ms->flags & MAGIC_CHECK) == 0)
  611. return 0;
  612. switch (m->type) {
  613. case FILE_BESTRING16:
  614. case FILE_LESTRING16:
  615. if (m->str_flags != 0) {
  616. file_magwarn(ms, "no modifiers allowed for 16-bit strings\n");
  617. return -1;
  618. }
  619. break;
  620. case FILE_STRING:
  621. case FILE_PSTRING:
  622. if ((m->str_flags & REGEX_OFFSET_START) != 0) {
  623. file_magwarn(ms, "'/%c' only allowed on regex and search\n",
  624. CHAR_REGEX_OFFSET_START);
  625. return -1;
  626. }
  627. break;
  628. case FILE_SEARCH:
  629. break;
  630. case FILE_REGEX:
  631. if ((m->str_flags & STRING_COMPACT_BLANK) != 0) {
  632. file_magwarn(ms, "'/%c' not allowed on regex\n",
  633. CHAR_COMPACT_BLANK);
  634. return -1;
  635. }
  636. if ((m->str_flags & STRING_COMPACT_OPTIONAL_BLANK) != 0) {
  637. file_magwarn(ms, "'/%c' not allowed on regex\n",
  638. CHAR_COMPACT_OPTIONAL_BLANK);
  639. return -1;
  640. }
  641. break;
  642. default:
  643. file_magwarn(ms, "coding error: m->type=%d\n",
  644. m->type);
  645. return -1;
  646. }
  647. return 0;
  648. }
  649. private int
  650. get_op(char c)
  651. {
  652. switch (c) {
  653. case '&':
  654. return FILE_OPAND;
  655. case '|':
  656. return FILE_OPOR;
  657. case '^':
  658. return FILE_OPXOR;
  659. case '+':
  660. return FILE_OPADD;
  661. case '-':
  662. return FILE_OPMINUS;
  663. case '*':
  664. return FILE_OPMULTIPLY;
  665. case '/':
  666. return FILE_OPDIVIDE;
  667. case '%':
  668. return FILE_OPMODULO;
  669. default:
  670. return -1;
  671. }
  672. }
  673. #ifdef ENABLE_CONDITIONALS
  674. private int
  675. get_cond(const char *l, const char **t)
  676. {
  677. static struct cond_tbl_s {
  678. const char *name;
  679. const size_t len;
  680. const int cond;
  681. } cond_tbl[] = {
  682. { "if", 2, COND_IF },
  683. { "elif", 4, COND_ELIF },
  684. { "else", 4, COND_ELSE },
  685. { NULL, 0, COND_NONE },
  686. };
  687. struct cond_tbl_s *p;
  688. for (p = cond_tbl; p->name; p++) {
  689. if (strncmp(l, p->name, p->len) == 0 &&
  690. isspace((unsigned char)l[p->len])) {
  691. if (t)
  692. *t = l + p->len;
  693. break;
  694. }
  695. }
  696. return p->cond;
  697. }
  698. private int
  699. check_cond(struct magic_set *ms, int cond, uint32_t cont_level)
  700. {
  701. int last_cond;
  702. last_cond = ms->c.li[cont_level].last_cond;
  703. switch (cond) {
  704. case COND_IF:
  705. if (last_cond != COND_NONE && last_cond != COND_ELIF) {
  706. if (ms->flags & MAGIC_CHECK)
  707. file_magwarn(ms, "syntax error: `if'");
  708. return -1;
  709. }
  710. last_cond = COND_IF;
  711. break;
  712. case COND_ELIF:
  713. if (last_cond != COND_IF && last_cond != COND_ELIF) {
  714. if (ms->flags & MAGIC_CHECK)
  715. file_magwarn(ms, "syntax error: `elif'");
  716. return -1;
  717. }
  718. last_cond = COND_ELIF;
  719. break;
  720. case COND_ELSE:
  721. if (last_cond != COND_IF && last_cond != COND_ELIF) {
  722. if (ms->flags & MAGIC_CHECK)
  723. file_magwarn(ms, "syntax error: `else'");
  724. return -1;
  725. }
  726. last_cond = COND_NONE;
  727. break;
  728. case COND_NONE:
  729. last_cond = COND_NONE;
  730. break;
  731. }
  732. ms->c.li[cont_level].last_cond = last_cond;
  733. return 0;
  734. }
  735. #endif /* ENABLE_CONDITIONALS */
  736. /*
  737. * parse one line from magic file, put into magic[index++] if valid
  738. */
  739. private int
  740. parse(struct magic_set *ms, struct magic_entry **mentryp, uint32_t *nmentryp,
  741. const char *line, size_t lineno, int action)
  742. {
  743. #ifdef ENABLE_CONDITIONALS
  744. static uint32_t last_cont_level = 0;
  745. #endif
  746. size_t i;
  747. struct magic_entry *me;
  748. struct magic *m;
  749. const char *l = line;
  750. char *t;
  751. int op;
  752. uint32_t cont_level;
  753. cont_level = 0;
  754. while (*l == '>') {
  755. ++l; /* step over */
  756. cont_level++;
  757. }
  758. #ifdef ENABLE_CONDITIONALS
  759. if (cont_level == 0 || cont_level > last_cont_level)
  760. if (file_check_mem(ms, cont_level) == -1)
  761. return -1;
  762. last_cont_level = cont_level;
  763. #endif
  764. #define ALLOC_CHUNK (size_t)10
  765. #define ALLOC_INCR (size_t)200
  766. if (cont_level != 0) {
  767. if (*nmentryp == 0) {
  768. file_error(ms, 0, "No current entry for continuation");
  769. return -1;
  770. }
  771. me = &(*mentryp)[*nmentryp - 1];
  772. if (me->cont_count == me->max_count) {
  773. struct magic *nm;
  774. size_t cnt = me->max_count + ALLOC_CHUNK;
  775. if ((nm = realloc(me->mp, sizeof(*nm) * cnt)) == NULL) {
  776. file_oomem(ms, sizeof(*nm) * cnt);
  777. return -1;
  778. }
  779. me->mp = m = nm;
  780. me->max_count = cnt;
  781. }
  782. m = &me->mp[me->cont_count++];
  783. (void)memset(m, 0, sizeof(*m));
  784. m->cont_level = cont_level;
  785. } else {
  786. if (*nmentryp == maxmagic) {
  787. struct magic_entry *mp;
  788. maxmagic += ALLOC_INCR;
  789. if ((mp = realloc(*mentryp, sizeof(*mp) * maxmagic)) ==
  790. NULL) {
  791. file_oomem(ms, sizeof(*mp) * maxmagic);
  792. return -1;
  793. }
  794. (void)memset(&mp[*nmentryp], 0, sizeof(*mp) *
  795. ALLOC_INCR);
  796. *mentryp = mp;
  797. }
  798. me = &(*mentryp)[*nmentryp];
  799. if (me->mp == NULL) {
  800. if ((m = malloc(sizeof(*m) * ALLOC_CHUNK)) == NULL) {
  801. file_oomem(ms, sizeof(*m) * ALLOC_CHUNK);
  802. return -1;
  803. }
  804. me->mp = m;
  805. me->max_count = ALLOC_CHUNK;
  806. } else
  807. m = me->mp;
  808. (void)memset(m, 0, sizeof(*m));
  809. m->cont_level = 0;
  810. me->cont_count = 1;
  811. }
  812. m->lineno = lineno;
  813. if (*l == '&') { /* m->cont_level == 0 checked below. */
  814. ++l; /* step over */
  815. m->flag |= OFFADD;
  816. }
  817. if (*l == '(') {
  818. ++l; /* step over */
  819. m->flag |= INDIR;
  820. if (m->flag & OFFADD)
  821. m->flag = (m->flag & ~OFFADD) | INDIROFFADD;
  822. if (*l == '&') { /* m->cont_level == 0 checked below */
  823. ++l; /* step over */
  824. m->flag |= OFFADD;
  825. }
  826. }
  827. /* Indirect offsets are not valid at level 0. */
  828. if (m->cont_level == 0 && (m->flag & (OFFADD | INDIROFFADD)))
  829. if (ms->flags & MAGIC_CHECK)
  830. file_magwarn(ms, "relative offset at level 0");
  831. /* get offset, then skip over it */
  832. m->offset = (uint32_t)strtoul(l, &t, 0);
  833. if (l == t)
  834. if (ms->flags & MAGIC_CHECK)
  835. file_magwarn(ms, "offset `%s' invalid", l);
  836. l = t;
  837. if (m->flag & INDIR) {
  838. m->in_type = FILE_LONG;
  839. m->in_offset = 0;
  840. /*
  841. * read [.lbs][+-]nnnnn)
  842. */
  843. if (*l == '.') {
  844. l++;
  845. switch (*l) {
  846. case 'l':
  847. m->in_type = FILE_LELONG;
  848. break;
  849. case 'L':
  850. m->in_type = FILE_BELONG;
  851. break;
  852. case 'm':
  853. m->in_type = FILE_MELONG;
  854. break;
  855. case 'h':
  856. case 's':
  857. m->in_type = FILE_LESHORT;
  858. break;
  859. case 'H':
  860. case 'S':
  861. m->in_type = FILE_BESHORT;
  862. break;
  863. case 'c':
  864. case 'b':
  865. case 'C':
  866. case 'B':
  867. m->in_type = FILE_BYTE;
  868. break;
  869. default:
  870. if (ms->flags & MAGIC_CHECK)
  871. file_magwarn(ms,
  872. "indirect offset type `%c' invalid",
  873. *l);
  874. break;
  875. }
  876. l++;
  877. }
  878. m->in_op = 0;
  879. if (*l == '~') {
  880. m->in_op |= FILE_OPINVERSE;
  881. l++;
  882. }
  883. if ((op = get_op(*l)) != -1) {
  884. m->in_op |= op;
  885. l++;
  886. }
  887. if (*l == '(') {
  888. m->in_op |= FILE_OPINDIRECT;
  889. l++;
  890. }
  891. if (isdigit((unsigned char)*l) || *l == '-') {
  892. m->in_offset = (int32_t)strtol(l, &t, 0);
  893. if (l == t)
  894. if (ms->flags & MAGIC_CHECK)
  895. file_magwarn(ms,
  896. "in_offset `%s' invalid", l);
  897. l = t;
  898. }
  899. if (*l++ != ')' ||
  900. ((m->in_op & FILE_OPINDIRECT) && *l++ != ')'))
  901. if (ms->flags & MAGIC_CHECK)
  902. file_magwarn(ms,
  903. "missing ')' in indirect offset");
  904. }
  905. EATAB;
  906. #ifdef ENABLE_CONDITIONALS
  907. m->cond = get_cond(l, &l);
  908. if (check_cond(ms, m->cond, cont_level) == -1)
  909. return -1;
  910. EATAB;
  911. #endif
  912. if (*l == 'u') {
  913. ++l;
  914. m->flag |= UNSIGNED;
  915. }
  916. m->type = get_type(l, &l);
  917. if (m->type == FILE_INVALID) {
  918. if (ms->flags & MAGIC_CHECK)
  919. file_magwarn(ms, "type `%s' invalid", l);
  920. return -1;
  921. }
  922. /* New-style anding: "0 byte&0x80 =0x80 dynamically linked" */
  923. /* New and improved: ~ & | ^ + - * / % -- exciting, isn't it? */
  924. m->mask_op = 0;
  925. if (*l == '~') {
  926. if (!IS_STRING(m->type))
  927. m->mask_op |= FILE_OPINVERSE;
  928. else if (ms->flags & MAGIC_CHECK)
  929. file_magwarn(ms, "'~' invalid for string types");
  930. ++l;
  931. }
  932. m->str_count = 0;
  933. m->str_flags = 0;
  934. m->num_mask = 0;
  935. if ((op = get_op(*l)) != -1) {
  936. if (!IS_STRING(m->type)) {
  937. uint64_t val;
  938. ++l;
  939. m->mask_op |= op;
  940. val = (uint64_t)strtoull(l, &t, 0);
  941. l = t;
  942. m->num_mask = file_signextend(ms, m, val);
  943. eatsize(&l);
  944. }
  945. else if (op == FILE_OPDIVIDE) {
  946. int have_count = 0;
  947. while (!isspace((unsigned char)*++l)) {
  948. switch (*l) {
  949. /* for portability avoid "case '0' ... '9':" */
  950. case '0': case '1': case '2':
  951. case '3': case '4': case '5':
  952. case '6': case '7': case '8':
  953. case '9': {
  954. if (have_count && ms->flags & MAGIC_CHECK)
  955. file_magwarn(ms,
  956. "multiple counts");
  957. have_count = 1;
  958. m->str_count = strtoul(l, &t, 0);
  959. l = t - 1;
  960. break;
  961. }
  962. case CHAR_COMPACT_BLANK:
  963. m->str_flags |= STRING_COMPACT_BLANK;
  964. break;
  965. case CHAR_COMPACT_OPTIONAL_BLANK:
  966. m->str_flags |=
  967. STRING_COMPACT_OPTIONAL_BLANK;
  968. break;
  969. case CHAR_IGNORE_LOWERCASE:
  970. m->str_flags |= STRING_IGNORE_LOWERCASE;
  971. break;
  972. case CHAR_IGNORE_UPPERCASE:
  973. m->str_flags |= STRING_IGNORE_UPPERCASE;
  974. break;
  975. case CHAR_REGEX_OFFSET_START:
  976. m->str_flags |= REGEX_OFFSET_START;
  977. break;
  978. default:
  979. if (ms->flags & MAGIC_CHECK)
  980. file_magwarn(ms,
  981. "string extension `%c' invalid",
  982. *l);
  983. return -1;
  984. }
  985. /* allow multiple '/' for readability */
  986. if (l[1] == '/' && !isspace((unsigned char)l[2]))
  987. l++;
  988. }
  989. if (string_modifier_check(ms, m) == -1)
  990. return -1;
  991. }
  992. else {
  993. if (ms->flags & MAGIC_CHECK)
  994. file_magwarn(ms, "invalid string op: %c", *t);
  995. return -1;
  996. }
  997. }
  998. /*
  999. * We used to set mask to all 1's here, instead let's just not do
  1000. * anything if mask = 0 (unless you have a better idea)
  1001. */
  1002. EATAB;
  1003. switch (*l) {
  1004. case '>':
  1005. case '<':
  1006. /* Old-style anding: "0 byte &0x80 dynamically linked" */
  1007. case '&':
  1008. case '^':
  1009. case '=':
  1010. m->reln = *l;
  1011. ++l;
  1012. if (*l == '=') {
  1013. /* HP compat: ignore &= etc. */
  1014. ++l;
  1015. }
  1016. break;
  1017. case '!':
  1018. m->reln = *l;
  1019. ++l;
  1020. break;
  1021. default:
  1022. m->reln = '='; /* the default relation */
  1023. if (*l == 'x' && ((isascii((unsigned char)l[1]) &&
  1024. isspace((unsigned char)l[1])) || !l[1])) {
  1025. m->reln = *l;
  1026. ++l;
  1027. }
  1028. break;
  1029. }
  1030. /*
  1031. * Grab the value part, except for an 'x' reln.
  1032. */
  1033. if (m->reln != 'x' && getvalue(ms, m, &l, action))
  1034. return -1;
  1035. /*
  1036. * TODO finish this macro and start using it!
  1037. * #define offsetcheck {if (offset > HOWMANY-1)
  1038. * magwarn("offset too big"); }
  1039. */
  1040. /*
  1041. * Now get last part - the description
  1042. */
  1043. EATAB;
  1044. if (l[0] == '\b') {
  1045. ++l;
  1046. m->nospflag = 1;
  1047. } else if ((l[0] == '\\') && (l[1] == 'b')) {
  1048. ++l;
  1049. ++l;
  1050. m->nospflag = 1;
  1051. } else
  1052. m->nospflag = 0;
  1053. for (i = 0; (m->desc[i++] = *l++) != '\0' && i < sizeof(m->desc); )
  1054. continue;
  1055. if (i == sizeof(m->desc)) {
  1056. m->desc[sizeof(m->desc) - 1] = '\0';
  1057. if (ms->flags & MAGIC_CHECK)
  1058. file_magwarn(ms, "description `%s' truncated", m->desc);
  1059. }
  1060. /*
  1061. * We only do this check while compiling, or if any of the magic
  1062. * files were not compiled.
  1063. */
  1064. if (ms->flags & MAGIC_CHECK) {
  1065. if (check_format(ms, m) == -1)
  1066. return -1;
  1067. }
  1068. #ifndef COMPILE_ONLY
  1069. if (action == FILE_CHECK) {
  1070. file_mdump(m);
  1071. }
  1072. #endif
  1073. if (m->cont_level == 0)
  1074. ++(*nmentryp); /* make room for next */
  1075. return 0;
  1076. }
  1077. private int
  1078. check_format_type(const char *ptr, int type)
  1079. {
  1080. int quad = 0;
  1081. if (*ptr == '\0') {
  1082. /* Missing format string; bad */
  1083. return -1;
  1084. }
  1085. switch (type) {
  1086. case FILE_FMT_QUAD:
  1087. quad = 1;
  1088. /*FALLTHROUGH*/
  1089. case FILE_FMT_NUM:
  1090. if (*ptr == '-')
  1091. ptr++;
  1092. if (*ptr == '.')
  1093. ptr++;
  1094. while (isdigit((unsigned char)*ptr)) ptr++;
  1095. if (*ptr == '.')
  1096. ptr++;
  1097. while (isdigit((unsigned char)*ptr)) ptr++;
  1098. if (quad) {
  1099. if (*ptr++ != 'l')
  1100. return -1;
  1101. if (*ptr++ != 'l')
  1102. return -1;
  1103. }
  1104. switch (*ptr++) {
  1105. case 'l':
  1106. switch (*ptr++) {
  1107. case 'i':
  1108. case 'd':
  1109. case 'u':
  1110. case 'x':
  1111. case 'X':
  1112. return 0;
  1113. default:
  1114. return -1;
  1115. }
  1116. case 'h':
  1117. switch (*ptr++) {
  1118. case 'h':
  1119. switch (*ptr++) {
  1120. case 'i':
  1121. case 'd':
  1122. case 'u':
  1123. case 'x':
  1124. case 'X':
  1125. return 0;
  1126. default:
  1127. return -1;
  1128. }
  1129. case 'd':
  1130. return 0;
  1131. default:
  1132. return -1;
  1133. }
  1134. case 'i':
  1135. case 'c':
  1136. case 'd':
  1137. case 'u':
  1138. case 'x':
  1139. case 'X':
  1140. return 0;
  1141. default:
  1142. return -1;
  1143. }
  1144. case FILE_FMT_STR:
  1145. if (*ptr == '-')
  1146. ptr++;
  1147. while (isdigit((unsigned char )*ptr))
  1148. ptr++;
  1149. if (*ptr == '.') {
  1150. ptr++;
  1151. while (isdigit((unsigned char )*ptr))
  1152. ptr++;
  1153. }
  1154. switch (*ptr++) {
  1155. case 's':
  1156. return 0;
  1157. default:
  1158. return -1;
  1159. }
  1160. default:
  1161. /* internal error */
  1162. abort();
  1163. }
  1164. /*NOTREACHED*/
  1165. return -1;
  1166. }
  1167. /*
  1168. * Check that the optional printf format in description matches
  1169. * the type of the magic.
  1170. */
  1171. private int
  1172. check_format(struct magic_set *ms, struct magic *m)
  1173. {
  1174. char *ptr;
  1175. for (ptr = m->desc; *ptr; ptr++)
  1176. if (*ptr == '%')
  1177. break;
  1178. if (*ptr == '\0') {
  1179. /* No format string; ok */
  1180. return 1;
  1181. }
  1182. assert(file_nformats == file_nnames);
  1183. if (m->type >= file_nformats) {
  1184. file_error(ms, 0, "Internal error inconsistency between "
  1185. "m->type and format strings");
  1186. return -1;
  1187. }
  1188. if (file_formats[m->type] == FILE_FMT_NONE) {
  1189. file_error(ms, 0, "No format string for `%s' with description "
  1190. "`%s'", m->desc, file_names[m->type]);
  1191. return -1;
  1192. }
  1193. ptr++;
  1194. if (check_format_type(ptr, file_formats[m->type]) == -1) {
  1195. /*
  1196. * TODO: this error message is unhelpful if the format
  1197. * string is not one character long
  1198. */
  1199. file_error(ms, 0, "Printf format `%c' is not valid for type "
  1200. " `%s' in description `%s'", *ptr,
  1201. file_names[m->type], m->desc);
  1202. return -1;
  1203. }
  1204. for (; *ptr; ptr++) {
  1205. if (*ptr == '%') {
  1206. file_error(ms, 0,
  1207. "Too many format strings (should have at most one) "
  1208. "for `%s' with description `%s'",
  1209. file_names[m->type], m->desc);
  1210. return -1;
  1211. }
  1212. }
  1213. return 0;
  1214. }
  1215. /*
  1216. * Read a numeric value from a pointer, into the value union of a magic
  1217. * pointer, according to the magic type. Update the string pointer to point
  1218. * just after the number read. Return 0 for success, non-zero for failure.
  1219. */
  1220. private int
  1221. getvalue(struct magic_set *ms, struct magic *m, const char **p, int action)
  1222. {
  1223. int slen;
  1224. switch (m->type) {
  1225. case FILE_BESTRING16:
  1226. case FILE_LESTRING16:
  1227. case FILE_STRING:
  1228. case FILE_PSTRING:
  1229. case FILE_REGEX:
  1230. case FILE_SEARCH:
  1231. *p = getstr(ms, *p, m->value.s, sizeof(m->value.s), &slen, action);
  1232. if (*p == NULL) {
  1233. if (ms->flags & MAGIC_CHECK)
  1234. file_magwarn(ms, "cannot get string from `%s'",
  1235. m->value.s);
  1236. return -1;
  1237. }
  1238. m->vallen = slen;
  1239. return 0;
  1240. default:
  1241. if (m->reln != 'x') {
  1242. char *ep;
  1243. m->value.q = file_signextend(ms, m,
  1244. (uint64_t)strtoull(*p, &ep, 0));
  1245. *p = ep;
  1246. eatsize(p);
  1247. }
  1248. return 0;
  1249. }
  1250. }
  1251. /*
  1252. * Convert a string containing C character escapes. Stop at an unescaped
  1253. * space or tab.
  1254. * Copy the converted version to "p", returning its length in *slen.
  1255. * Return updated scan pointer as function result.
  1256. */
  1257. private const char *
  1258. getstr(struct magic_set *ms, const char *s, char *p, int plen, int *slen, int action)
  1259. {
  1260. const char *origs = s;
  1261. char *origp = p;
  1262. char *pmax = p + plen - 1;
  1263. int c;
  1264. int val;
  1265. while ((c = *s++) != '\0') {
  1266. if (isspace((unsigned char) c))
  1267. break;
  1268. if (p >= pmax) {
  1269. file_error(ms, 0, "string too long: `%s'", origs);
  1270. return NULL;
  1271. }
  1272. if (c == '\\') {
  1273. switch(c = *s++) {
  1274. case '\0':
  1275. if (action == FILE_COMPILE)
  1276. file_magwarn(ms, "incomplete escape");
  1277. goto out;
  1278. case '\t':
  1279. if (action == FILE_COMPILE) {
  1280. file_magwarn(ms,
  1281. "escaped tab found, use \\t instead");
  1282. action++;
  1283. }
  1284. /*FALLTHROUGH*/
  1285. default:
  1286. if (action == FILE_COMPILE) {
  1287. if (isprint((unsigned char)c))
  1288. file_magwarn(ms,
  1289. "no need to escape `%c'", c);
  1290. else
  1291. file_magwarn(ms,
  1292. "unknown escape sequence: \\%03o", c);
  1293. }
  1294. /*FALLTHROUGH*/
  1295. /* space, perhaps force people to use \040? */
  1296. case ' ':
  1297. #if 0
  1298. /*
  1299. * Other things people escape, but shouldn't need to,
  1300. * so we disallow them
  1301. */
  1302. case '\'':
  1303. case '"':
  1304. case '?':
  1305. #endif
  1306. /* Relations */
  1307. case '>':
  1308. case '<':
  1309. case '&':
  1310. case '^':
  1311. case '=':
  1312. case '!':
  1313. /* and baskslash itself */
  1314. case '\\':
  1315. *p++ = (char) c;
  1316. break;
  1317. case 'a':
  1318. *p++ = '\a';
  1319. break;
  1320. case 'b':
  1321. *p++ = '\b';
  1322. break;
  1323. case 'f':
  1324. *p++ = '\f';
  1325. break;
  1326. case 'n':
  1327. *p++ = '\n';
  1328. break;
  1329. case 'r':
  1330. *p++ = '\r';
  1331. break;
  1332. case 't':
  1333. *p++ = '\t';
  1334. break;
  1335. case 'v':
  1336. *p++ = '\v';
  1337. break;
  1338. /* \ and up to 3 octal digits */
  1339. case '0':
  1340. case '1':
  1341. case '2':
  1342. case '3':
  1343. case '4':
  1344. case '5':
  1345. case '6':
  1346. case '7':
  1347. val = c - '0';
  1348. c = *s++; /* try for 2 */
  1349. if (c >= '0' && c <= '7') {
  1350. val = (val << 3) | (c - '0');
  1351. c = *s++; /* try for 3 */
  1352. if (c >= '0' && c <= '7')
  1353. val = (val << 3) | (c-'0');
  1354. else
  1355. --s;
  1356. }
  1357. else
  1358. --s;
  1359. *p++ = (char)val;
  1360. break;
  1361. /* \x and up to 2 hex digits */
  1362. case 'x':
  1363. val = 'x'; /* Default if no digits */
  1364. c = hextoint(*s++); /* Get next char */
  1365. if (c >= 0) {
  1366. val = c;
  1367. c = hextoint(*s++);
  1368. if (c >= 0)
  1369. val = (val << 4) + c;
  1370. else
  1371. --s;
  1372. } else
  1373. --s;
  1374. *p++ = (char)val;
  1375. break;
  1376. }
  1377. } else
  1378. *p++ = (char)c;
  1379. }
  1380. out:
  1381. *p = '\0';
  1382. *slen = p - origp;
  1383. return s;
  1384. }
  1385. /* Single hex char to int; -1 if not a hex char. */
  1386. private int
  1387. hextoint(int c)
  1388. {
  1389. if (!isascii((unsigned char) c))
  1390. return -1;
  1391. if (isdigit((unsigned char) c))
  1392. return c - '0';
  1393. if ((c >= 'a') && (c <= 'f'))
  1394. return c + 10 - 'a';
  1395. if (( c>= 'A') && (c <= 'F'))
  1396. return c + 10 - 'A';
  1397. return -1;
  1398. }
  1399. /*
  1400. * Print a string containing C character escapes.
  1401. */
  1402. protected void
  1403. file_showstr(FILE *fp, const char *s, size_t len)
  1404. {
  1405. char c;
  1406. for (;;) {
  1407. c = *s++;
  1408. if (len == ~0U) {
  1409. if (c == '\0')
  1410. break;
  1411. }
  1412. else {
  1413. if (len-- == 0)
  1414. break;
  1415. }
  1416. if (c >= 040 && c <= 0176) /* TODO isprint && !iscntrl */
  1417. (void) fputc(c, fp);
  1418. else {
  1419. (void) fputc('\\', fp);
  1420. switch (c) {
  1421. case '\a':
  1422. (void) fputc('a', fp);
  1423. break;
  1424. case '\b':
  1425. (void) fputc('b', fp);
  1426. break;
  1427. case '\f':
  1428. (void) fputc('f', fp);
  1429. break;
  1430. case '\n':
  1431. (void) fputc('n', fp);
  1432. break;
  1433. case '\r':
  1434. (void) fputc('r', fp);
  1435. break;
  1436. case '\t':
  1437. (void) fputc('t', fp);
  1438. break;
  1439. case '\v':
  1440. (void) fputc('v', fp);
  1441. break;
  1442. default:
  1443. (void) fprintf(fp, "%.3o", c & 0377);
  1444. break;
  1445. }
  1446. }
  1447. }
  1448. }
  1449. /*
  1450. * eatsize(): Eat the size spec from a number [eg. 10UL]
  1451. */
  1452. private void
  1453. eatsize(const char **p)
  1454. {
  1455. const char *l = *p;
  1456. if (LOWCASE(*l) == 'u')
  1457. l++;
  1458. switch (LOWCASE(*l)) {
  1459. case 'l': /* long */
  1460. case 's': /* short */
  1461. case 'h': /* short */
  1462. case 'b': /* char/byte */
  1463. case 'c': /* char/byte */
  1464. l++;
  1465. /*FALLTHROUGH*/
  1466. default:
  1467. break;
  1468. }
  1469. *p = l;
  1470. }
  1471. /*
  1472. * handle a compiled file.
  1473. */
  1474. private int
  1475. apprentice_map(struct magic_set *ms, struct magic **magicp, uint32_t *nmagicp,
  1476. const char *fn)
  1477. {
  1478. int fd;
  1479. struct stat st;
  1480. uint32_t *ptr;
  1481. uint32_t version;
  1482. int needsbyteswap;
  1483. char buf[MAXPATHLEN];
  1484. char *dbname = mkdbname(fn, buf, sizeof(buf), 0);
  1485. void *mm = NULL;
  1486. if (dbname == NULL)
  1487. return -1;
  1488. if ((fd = open(dbname, O_RDONLY|O_BINARY)) == -1)
  1489. return -1;
  1490. if (fstat(fd, &st) == -1) {
  1491. file_error(ms, errno, "cannot stat `%s'", dbname);
  1492. goto error;
  1493. }
  1494. if (st.st_size < 16) {
  1495. file_error(ms, 0, "file `%s' is too small", dbname);
  1496. goto error;
  1497. }
  1498. #ifdef QUICK
  1499. if ((mm = mmap(0, (size_t)st.st_size, PROT_READ|PROT_WRITE,
  1500. MAP_PRIVATE|MAP_FILE, fd, (off_t)0)) == MAP_FAILED) {
  1501. file_error(ms, errno, "cannot map `%s'", dbname);
  1502. goto error;
  1503. }
  1504. #define RET 2
  1505. #else
  1506. if ((mm = malloc((size_t)st.st_size)) == NULL) {
  1507. file_oomem(ms, (size_t)st.st_size);
  1508. goto error;
  1509. }
  1510. if (read(fd, mm, (size_t)st.st_size) != (size_t)st.st_size) {
  1511. file_badread(ms);
  1512. goto error;
  1513. }
  1514. #define RET 1
  1515. #endif
  1516. *magicp = mm;
  1517. (void)close(fd);
  1518. fd = -1;
  1519. ptr = (uint32_t *)(void *)*magicp;
  1520. if (*ptr != MAGICNO) {
  1521. if (swap4(*ptr) != MAGICNO) {
  1522. file_error(ms, 0, "bad magic in `%s'");
  1523. goto error;
  1524. }
  1525. needsbyteswap = 1;
  1526. } else
  1527. needsbyteswap = 0;
  1528. if (needsbyteswap)
  1529. version = swap4(ptr[1]);
  1530. else
  1531. version = ptr[1];
  1532. if (version != VERSIONNO) {
  1533. file_error(ms, 0, "version mismatch (%d != %d) in `%s'",
  1534. version, VERSIONNO, dbname);
  1535. goto error;
  1536. }
  1537. *nmagicp = (uint32_t)(st.st_size / sizeof(struct magic)) - 1;
  1538. (*magicp)++;
  1539. if (needsbyteswap)
  1540. byteswap(*magicp, *nmagicp);
  1541. return RET;
  1542. error:
  1543. if (fd != -1)
  1544. (void)close(fd);
  1545. if (mm) {
  1546. #ifdef QUICK
  1547. (void)munmap((void *)mm, (size_t)st.st_size);
  1548. #else
  1549. free(mm);
  1550. #endif
  1551. } else {
  1552. *magicp = NULL;
  1553. *nmagicp = 0;
  1554. }
  1555. return -1;
  1556. }
  1557. private const uint32_t ar[] = {
  1558. MAGICNO, VERSIONNO
  1559. };
  1560. /*
  1561. * handle an mmaped file.
  1562. */
  1563. private int
  1564. apprentice_compile(struct magic_set *ms, struct magic **magicp,
  1565. uint32_t *nmagicp, const char *fn)
  1566. {
  1567. int fd;
  1568. char buf[MAXPATHLEN];
  1569. char *dbname = mkdbname(fn, buf, sizeof(buf), 1);
  1570. if (dbname == NULL)
  1571. return -1;
  1572. if ((fd = open(dbname, O_WRONLY|O_CREAT|O_TRUNC|O_BINARY, 0644)) == -1) {
  1573. file_error(ms, errno, "cannot open `%s'", dbname);
  1574. return -1;
  1575. }
  1576. if (write(fd, ar, sizeof(ar)) != (ssize_t)sizeof(ar)) {
  1577. file_error(ms, errno, "error writing `%s'", dbname);
  1578. return -1;
  1579. }
  1580. if (lseek(fd, (off_t)sizeof(struct magic), SEEK_SET)
  1581. != sizeof(struct magic)) {
  1582. file_error(ms, errno, "error seeking `%s'", dbname);
  1583. return -1;
  1584. }
  1585. if (write(fd, *magicp, (sizeof(struct magic) * *nmagicp))
  1586. != (ssize_t)(sizeof(struct magic) * *nmagicp)) {
  1587. file_error(ms, errno, "error writing `%s'", dbname);
  1588. return -1;
  1589. }
  1590. (void)close(fd);
  1591. return 0;
  1592. }
  1593. private const char ext[] = ".mgc";
  1594. /*
  1595. * make a dbname
  1596. */
  1597. private char *
  1598. mkdbname(const char *fn, char *buf, size_t bufsiz, int strip)
  1599. {
  1600. if (strip) {
  1601. const char *p;
  1602. if ((p = strrchr(fn, '/')) != NULL)
  1603. fn = ++p;
  1604. }
  1605. (void)snprintf(buf, bufsiz, "%s%s", fn, ext);
  1606. return buf;
  1607. }
  1608. /*
  1609. * Byteswap an mmap'ed file if needed
  1610. */
  1611. private void
  1612. byteswap(struct magic *magic, uint32_t nmagic)
  1613. {
  1614. uint32_t i;
  1615. for (i = 0; i < nmagic; i++)
  1616. bs1(&magic[i]);
  1617. }
  1618. /*
  1619. * swap a short
  1620. */
  1621. private uint16_t
  1622. swap2(uint16_t sv)
  1623. {
  1624. uint16_t rv;
  1625. uint8_t *s = (uint8_t *)(void *)&sv;
  1626. uint8_t *d = (uint8_t *)(void *)&rv;
  1627. d[0] = s[1];
  1628. d[1] = s[0];
  1629. return rv;
  1630. }
  1631. /*
  1632. * swap an int
  1633. */
  1634. private uint32_t
  1635. swap4(uint32_t sv)
  1636. {
  1637. uint32_t rv;
  1638. uint8_t *s = (uint8_t *)(void *)&sv;
  1639. uint8_t *d = (uint8_t *)(void *)&rv;
  1640. d[0] = s[3];
  1641. d[1] = s[2];
  1642. d[2] = s[1];
  1643. d[3] = s[0];
  1644. return rv;
  1645. }
  1646. /*
  1647. * swap a quad
  1648. */
  1649. private uint64_t
  1650. swap8(uint64_t sv)
  1651. {
  1652. uint32_t rv;
  1653. uint8_t *s = (uint8_t *)(void *)&sv;
  1654. uint8_t *d = (uint8_t *)(void *)&rv;
  1655. d[0] = s[3];
  1656. d[1] = s[2];
  1657. d[2] = s[1];
  1658. d[3] = s[0];
  1659. d[4] = s[7];
  1660. d[5] = s[6];
  1661. d[6] = s[5];
  1662. d[7] = s[4];
  1663. return rv;
  1664. }
  1665. /*
  1666. * byteswap a single magic entry
  1667. */
  1668. private void
  1669. bs1(struct magic *m)
  1670. {
  1671. m->cont_level = swap2(m->cont_level);
  1672. m->offset = swap4((uint32_t)m->offset);
  1673. m->in_offset = swap4((uint32_t)m->in_offset);
  1674. m->lineno = swap4((uint32_t)m->lineno);
  1675. if (IS_STRING(m->type)) {
  1676. m->str_count = swap4(m->str_count);
  1677. m->str_flags = swap4(m->str_flags);
  1678. }
  1679. else {
  1680. m->value.q = swap8(m->value.q);
  1681. m->num_mask = swap8(m->num_mask);
  1682. }
  1683. }