apprentice.c 47 KB

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