funcs.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558
  1. /*
  2. * Copyright (c) Christos Zoulas 2003.
  3. * All Rights Reserved.
  4. *
  5. * Redistribution and use in source and binary forms, with or without
  6. * modification, are permitted provided that the following conditions
  7. * are met:
  8. * 1. Redistributions of source code must retain the above copyright
  9. * notice immediately at the beginning of the file, without modification,
  10. * this list of conditions, and the following disclaimer.
  11. * 2. Redistributions in binary form must reproduce the above copyright
  12. * notice, this list of conditions and the following disclaimer in the
  13. * documentation and/or other materials provided with the distribution.
  14. *
  15. * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16. * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17. * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18. * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
  19. * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20. * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21. * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22. * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23. * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24. * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25. * SUCH DAMAGE.
  26. */
  27. #include "file.h"
  28. #ifndef lint
  29. FILE_RCSID("@(#)$File: funcs.c,v 1.78 2014/12/11 12:34:24 christos Exp $")
  30. #endif /* lint */
  31. #include "magic.h"
  32. #include <assert.h>
  33. #include <stdarg.h>
  34. #include <stdlib.h>
  35. #include <string.h>
  36. #include <ctype.h>
  37. #if defined(HAVE_WCHAR_H)
  38. #include <wchar.h>
  39. #endif
  40. #if defined(HAVE_WCTYPE_H)
  41. #include <wctype.h>
  42. #endif
  43. #if defined(HAVE_LIMITS_H)
  44. #include <limits.h>
  45. #endif
  46. #ifndef SIZE_MAX
  47. #define SIZE_MAX ((size_t)~0)
  48. #endif
  49. /*
  50. * Like printf, only we append to a buffer.
  51. */
  52. protected int
  53. file_vprintf(struct magic_set *ms, const char *fmt, va_list ap)
  54. {
  55. int len;
  56. char *buf, *newstr;
  57. if (ms->event_flags & EVENT_HAD_ERR)
  58. return 0;
  59. len = vasprintf(&buf, fmt, ap);
  60. if (len < 0)
  61. goto out;
  62. if (ms->o.buf != NULL) {
  63. len = asprintf(&newstr, "%s%s", ms->o.buf, buf);
  64. free(buf);
  65. if (len < 0)
  66. goto out;
  67. free(ms->o.buf);
  68. buf = newstr;
  69. }
  70. ms->o.buf = buf;
  71. return 0;
  72. out:
  73. file_error(ms, errno, "vasprintf failed");
  74. return -1;
  75. }
  76. protected int
  77. file_printf(struct magic_set *ms, const char *fmt, ...)
  78. {
  79. int rv;
  80. va_list ap;
  81. va_start(ap, fmt);
  82. rv = file_vprintf(ms, fmt, ap);
  83. va_end(ap);
  84. return rv;
  85. }
  86. /*
  87. * error - print best error message possible
  88. */
  89. /*VARARGS*/
  90. __attribute__((__format__(__printf__, 3, 0)))
  91. private void
  92. file_error_core(struct magic_set *ms, int error, const char *f, va_list va,
  93. size_t lineno)
  94. {
  95. /* Only the first error is ok */
  96. if (ms->event_flags & EVENT_HAD_ERR)
  97. return;
  98. if (lineno != 0) {
  99. free(ms->o.buf);
  100. ms->o.buf = NULL;
  101. file_printf(ms, "line %" SIZE_T_FORMAT "u: ", lineno);
  102. }
  103. file_vprintf(ms, f, va);
  104. if (error > 0)
  105. file_printf(ms, " (%s)", strerror(error));
  106. ms->event_flags |= EVENT_HAD_ERR;
  107. ms->error = error;
  108. }
  109. /*VARARGS*/
  110. protected void
  111. file_error(struct magic_set *ms, int error, const char *f, ...)
  112. {
  113. va_list va;
  114. va_start(va, f);
  115. file_error_core(ms, error, f, va, 0);
  116. va_end(va);
  117. }
  118. /*
  119. * Print an error with magic line number.
  120. */
  121. /*VARARGS*/
  122. protected void
  123. file_magerror(struct magic_set *ms, const char *f, ...)
  124. {
  125. va_list va;
  126. va_start(va, f);
  127. file_error_core(ms, 0, f, va, ms->line);
  128. va_end(va);
  129. }
  130. protected void
  131. file_oomem(struct magic_set *ms, size_t len)
  132. {
  133. file_error(ms, errno, "cannot allocate %" SIZE_T_FORMAT "u bytes",
  134. len);
  135. }
  136. protected void
  137. file_badseek(struct magic_set *ms)
  138. {
  139. file_error(ms, errno, "error seeking");
  140. }
  141. protected void
  142. file_badread(struct magic_set *ms)
  143. {
  144. file_error(ms, errno, "error reading");
  145. }
  146. #ifndef COMPILE_ONLY
  147. protected int
  148. file_buffer(struct magic_set *ms, int fd, const char *inname __attribute__ ((unused)),
  149. const void *buf, size_t nb)
  150. {
  151. int m = 0, rv = 0, looks_text = 0;
  152. int mime = ms->flags & MAGIC_MIME;
  153. const unsigned char *ubuf = CAST(const unsigned char *, buf);
  154. unichar *u8buf = NULL;
  155. size_t ulen;
  156. const char *code = NULL;
  157. const char *code_mime = "binary";
  158. const char *type = "application/octet-stream";
  159. const char *def = "data";
  160. const char *ftype = NULL;
  161. if (nb == 0) {
  162. def = "empty";
  163. type = "application/x-empty";
  164. goto simple;
  165. } else if (nb == 1) {
  166. def = "very short file (no magic)";
  167. goto simple;
  168. }
  169. if ((ms->flags & MAGIC_NO_CHECK_ENCODING) == 0) {
  170. looks_text = file_encoding(ms, ubuf, nb, &u8buf, &ulen,
  171. &code, &code_mime, &ftype);
  172. }
  173. #ifdef __EMX__
  174. if ((ms->flags & MAGIC_NO_CHECK_APPTYPE) == 0 && inname) {
  175. switch (file_os2_apptype(ms, inname, buf, nb)) {
  176. case -1:
  177. return -1;
  178. case 0:
  179. break;
  180. default:
  181. return 1;
  182. }
  183. }
  184. #endif
  185. #if HAVE_FORK
  186. /* try compression stuff */
  187. if ((ms->flags & MAGIC_NO_CHECK_COMPRESS) == 0)
  188. if ((m = file_zmagic(ms, fd, inname, ubuf, nb)) != 0) {
  189. if ((ms->flags & MAGIC_DEBUG) != 0)
  190. (void)fprintf(stderr, "zmagic %d\n", m);
  191. goto done_encoding;
  192. }
  193. #endif
  194. /* Check if we have a tar file */
  195. if ((ms->flags & MAGIC_NO_CHECK_TAR) == 0)
  196. if ((m = file_is_tar(ms, ubuf, nb)) != 0) {
  197. if ((ms->flags & MAGIC_DEBUG) != 0)
  198. (void)fprintf(stderr, "tar %d\n", m);
  199. goto done;
  200. }
  201. /* Check if we have a CDF file */
  202. if ((ms->flags & MAGIC_NO_CHECK_CDF) == 0)
  203. if ((m = file_trycdf(ms, fd, ubuf, nb)) != 0) {
  204. if ((ms->flags & MAGIC_DEBUG) != 0)
  205. (void)fprintf(stderr, "cdf %d\n", m);
  206. goto done;
  207. }
  208. /* try soft magic tests */
  209. if ((ms->flags & MAGIC_NO_CHECK_SOFT) == 0)
  210. if ((m = file_softmagic(ms, ubuf, nb, 0, NULL, BINTEST,
  211. looks_text)) != 0) {
  212. if ((ms->flags & MAGIC_DEBUG) != 0)
  213. (void)fprintf(stderr, "softmagic %d\n", m);
  214. #ifdef BUILTIN_ELF
  215. if ((ms->flags & MAGIC_NO_CHECK_ELF) == 0 && m == 1 &&
  216. nb > 5 && fd != -1) {
  217. /*
  218. * We matched something in the file, so this
  219. * *might* be an ELF file, and the file is at
  220. * least 5 bytes long, so if it's an ELF file
  221. * it has at least one byte past the ELF magic
  222. * number - try extracting information from the
  223. * ELF headers that cannot easily * be
  224. * extracted with rules in the magic file.
  225. */
  226. if ((m = file_tryelf(ms, fd, ubuf, nb)) != 0)
  227. if ((ms->flags & MAGIC_DEBUG) != 0)
  228. (void)fprintf(stderr,
  229. "elf %d\n", m);
  230. }
  231. #endif
  232. goto done;
  233. }
  234. /* try text properties */
  235. if ((ms->flags & MAGIC_NO_CHECK_TEXT) == 0) {
  236. if ((m = file_ascmagic(ms, ubuf, nb, looks_text)) != 0) {
  237. if ((ms->flags & MAGIC_DEBUG) != 0)
  238. (void)fprintf(stderr, "ascmagic %d\n", m);
  239. goto done;
  240. }
  241. }
  242. simple:
  243. /* give up */
  244. m = 1;
  245. if ((!mime || (mime & MAGIC_MIME_TYPE)) &&
  246. file_printf(ms, "%s", mime ? type : def) == -1) {
  247. rv = -1;
  248. }
  249. done:
  250. if ((ms->flags & MAGIC_MIME_ENCODING) != 0) {
  251. if (ms->flags & MAGIC_MIME_TYPE)
  252. if (file_printf(ms, "; charset=") == -1)
  253. rv = -1;
  254. if (file_printf(ms, "%s", code_mime) == -1)
  255. rv = -1;
  256. }
  257. #if HAVE_FORK
  258. done_encoding:
  259. #endif
  260. free(u8buf);
  261. if (rv)
  262. return rv;
  263. return m;
  264. }
  265. #endif
  266. protected int
  267. file_reset(struct magic_set *ms)
  268. {
  269. if (ms->mlist[0] == NULL) {
  270. file_error(ms, 0, "no magic files loaded");
  271. return -1;
  272. }
  273. if (ms->o.buf) {
  274. free(ms->o.buf);
  275. ms->o.buf = NULL;
  276. }
  277. if (ms->o.pbuf) {
  278. free(ms->o.pbuf);
  279. ms->o.pbuf = NULL;
  280. }
  281. ms->event_flags &= ~EVENT_HAD_ERR;
  282. ms->error = -1;
  283. return 0;
  284. }
  285. #define OCTALIFY(n, o) \
  286. /*LINTED*/ \
  287. (void)(*(n)++ = '\\', \
  288. *(n)++ = (((uint32_t)*(o) >> 6) & 3) + '0', \
  289. *(n)++ = (((uint32_t)*(o) >> 3) & 7) + '0', \
  290. *(n)++ = (((uint32_t)*(o) >> 0) & 7) + '0', \
  291. (o)++)
  292. protected const char *
  293. file_getbuffer(struct magic_set *ms)
  294. {
  295. char *pbuf, *op, *np;
  296. size_t psize, len;
  297. if (ms->event_flags & EVENT_HAD_ERR)
  298. return NULL;
  299. if (ms->flags & MAGIC_RAW)
  300. return ms->o.buf;
  301. if (ms->o.buf == NULL)
  302. return NULL;
  303. /* * 4 is for octal representation, + 1 is for NUL */
  304. len = strlen(ms->o.buf);
  305. if (len > (SIZE_MAX - 1) / 4) {
  306. file_oomem(ms, len);
  307. return NULL;
  308. }
  309. psize = len * 4 + 1;
  310. if ((pbuf = CAST(char *, realloc(ms->o.pbuf, psize))) == NULL) {
  311. file_oomem(ms, psize);
  312. return NULL;
  313. }
  314. ms->o.pbuf = pbuf;
  315. #if defined(HAVE_WCHAR_H) && defined(HAVE_MBRTOWC) && defined(HAVE_WCWIDTH)
  316. {
  317. mbstate_t state;
  318. wchar_t nextchar;
  319. int mb_conv = 1;
  320. size_t bytesconsumed;
  321. char *eop;
  322. (void)memset(&state, 0, sizeof(mbstate_t));
  323. np = ms->o.pbuf;
  324. op = ms->o.buf;
  325. eop = op + len;
  326. while (op < eop) {
  327. bytesconsumed = mbrtowc(&nextchar, op,
  328. (size_t)(eop - op), &state);
  329. if (bytesconsumed == (size_t)(-1) ||
  330. bytesconsumed == (size_t)(-2)) {
  331. mb_conv = 0;
  332. break;
  333. }
  334. if (iswprint(nextchar)) {
  335. (void)memcpy(np, op, bytesconsumed);
  336. op += bytesconsumed;
  337. np += bytesconsumed;
  338. } else {
  339. while (bytesconsumed-- > 0)
  340. OCTALIFY(np, op);
  341. }
  342. }
  343. *np = '\0';
  344. /* Parsing succeeded as a multi-byte sequence */
  345. if (mb_conv != 0)
  346. return ms->o.pbuf;
  347. }
  348. #endif
  349. for (np = ms->o.pbuf, op = ms->o.buf; *op;) {
  350. if (isprint((unsigned char)*op)) {
  351. *np++ = *op++;
  352. } else {
  353. OCTALIFY(np, op);
  354. }
  355. }
  356. *np = '\0';
  357. return ms->o.pbuf;
  358. }
  359. protected int
  360. file_check_mem(struct magic_set *ms, unsigned int level)
  361. {
  362. size_t len;
  363. if (level >= ms->c.len) {
  364. len = (ms->c.len += 20) * sizeof(*ms->c.li);
  365. ms->c.li = CAST(struct level_info *, (ms->c.li == NULL) ?
  366. malloc(len) :
  367. realloc(ms->c.li, len));
  368. if (ms->c.li == NULL) {
  369. file_oomem(ms, len);
  370. return -1;
  371. }
  372. }
  373. ms->c.li[level].got_match = 0;
  374. #ifdef ENABLE_CONDITIONALS
  375. ms->c.li[level].last_match = 0;
  376. ms->c.li[level].last_cond = COND_NONE;
  377. #endif /* ENABLE_CONDITIONALS */
  378. return 0;
  379. }
  380. protected size_t
  381. file_printedlen(const struct magic_set *ms)
  382. {
  383. return ms->o.buf == NULL ? 0 : strlen(ms->o.buf);
  384. }
  385. protected int
  386. file_replace(struct magic_set *ms, const char *pat, const char *rep)
  387. {
  388. file_regex_t rx;
  389. int rc, rv = -1;
  390. rc = file_regcomp(&rx, pat, REG_EXTENDED);
  391. if (rc) {
  392. file_regerror(&rx, rc, ms);
  393. } else {
  394. regmatch_t rm;
  395. int nm = 0;
  396. while (file_regexec(&rx, ms->o.buf, 1, &rm, 0) == 0) {
  397. ms->o.buf[rm.rm_so] = '\0';
  398. if (file_printf(ms, "%s%s", rep,
  399. rm.rm_eo != 0 ? ms->o.buf + rm.rm_eo : "") == -1)
  400. goto out;
  401. nm++;
  402. }
  403. rv = nm;
  404. }
  405. out:
  406. file_regfree(&rx);
  407. return rv;
  408. }
  409. protected int
  410. file_regcomp(file_regex_t *rx, const char *pat, int flags)
  411. {
  412. #ifdef USE_C_LOCALE
  413. rx->c_lc_ctype = newlocale(LC_CTYPE_MASK, "C", 0);
  414. assert(rx->c_lc_ctype != NULL);
  415. rx->old_lc_ctype = uselocale(rx->c_lc_ctype);
  416. assert(rx->old_lc_ctype != NULL);
  417. #endif
  418. rx->pat = pat;
  419. return rx->rc = regcomp(&rx->rx, pat, flags);
  420. }
  421. protected int
  422. file_regexec(file_regex_t *rx, const char *str, size_t nmatch,
  423. regmatch_t* pmatch, int eflags)
  424. {
  425. assert(rx->rc == 0);
  426. return regexec(&rx->rx, str, nmatch, pmatch, eflags);
  427. }
  428. protected void
  429. file_regfree(file_regex_t *rx)
  430. {
  431. if (rx->rc == 0)
  432. regfree(&rx->rx);
  433. #ifdef USE_C_LOCALE
  434. (void)uselocale(rx->old_lc_ctype);
  435. freelocale(rx->c_lc_ctype);
  436. #endif
  437. }
  438. protected void
  439. file_regerror(file_regex_t *rx, int rc, struct magic_set *ms)
  440. {
  441. char errmsg[512];
  442. (void)regerror(rc, &rx->rx, errmsg, sizeof(errmsg));
  443. file_magerror(ms, "regex error %d for `%s', (%s)", rc, rx->pat,
  444. errmsg);
  445. }
  446. protected file_pushbuf_t *
  447. file_push_buffer(struct magic_set *ms)
  448. {
  449. file_pushbuf_t *pb;
  450. if (ms->event_flags & EVENT_HAD_ERR)
  451. return NULL;
  452. if ((pb = (CAST(file_pushbuf_t *, malloc(sizeof(*pb))))) == NULL)
  453. return NULL;
  454. pb->buf = ms->o.buf;
  455. pb->offset = ms->offset;
  456. ms->o.buf = NULL;
  457. ms->offset = 0;
  458. return pb;
  459. }
  460. protected char *
  461. file_pop_buffer(struct magic_set *ms, file_pushbuf_t *pb)
  462. {
  463. char *rbuf;
  464. if (ms->event_flags & EVENT_HAD_ERR) {
  465. free(pb->buf);
  466. free(pb);
  467. return NULL;
  468. }
  469. rbuf = ms->o.buf;
  470. ms->o.buf = pb->buf;
  471. ms->offset = pb->offset;
  472. free(pb);
  473. return rbuf;
  474. }
  475. /*
  476. * convert string to ascii printable format.
  477. */
  478. protected char *
  479. file_printable(char *buf, size_t bufsiz, const char *str)
  480. {
  481. char *ptr, *eptr;
  482. const unsigned char *s = (const unsigned char *)str;
  483. for (ptr = buf, eptr = ptr + bufsiz - 1; ptr < eptr && *s; s++) {
  484. if (isprint(*s)) {
  485. *ptr++ = *s;
  486. continue;
  487. }
  488. if (ptr >= eptr - 3)
  489. break;
  490. *ptr++ = '\\';
  491. *ptr++ = ((*s >> 6) & 7) + '0';
  492. *ptr++ = ((*s >> 3) & 7) + '0';
  493. *ptr++ = ((*s >> 0) & 7) + '0';
  494. }
  495. *ptr = '\0';
  496. return buf;
  497. }