apprentice.c 64 KB

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