apprentice.c 80 KB

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