apprentice.c 54 KB

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