magic.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485
  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. #ifdef WIN32
  28. #include <windows.h>
  29. #include <shlwapi.h>
  30. #endif
  31. #include "file.h"
  32. #ifndef lint
  33. FILE_RCSID("@(#)$File: magic.c,v 1.78 2013/01/07 18:20:19 christos Exp $")
  34. #endif /* lint */
  35. #include "magic.h"
  36. #include <stdlib.h>
  37. #include <unistd.h>
  38. #include <string.h>
  39. #ifdef QUICK
  40. #include <sys/mman.h>
  41. #endif
  42. #ifdef HAVE_LIMITS_H
  43. #include <limits.h> /* for PIPE_BUF */
  44. #endif
  45. #if defined(HAVE_UTIMES)
  46. # include <sys/time.h>
  47. #elif defined(HAVE_UTIME)
  48. # if defined(HAVE_SYS_UTIME_H)
  49. # include <sys/utime.h>
  50. # elif defined(HAVE_UTIME_H)
  51. # include <utime.h>
  52. # endif
  53. #endif
  54. #ifdef HAVE_UNISTD_H
  55. #include <unistd.h> /* for read() */
  56. #endif
  57. #ifndef PIPE_BUF
  58. /* Get the PIPE_BUF from pathconf */
  59. #ifdef _PC_PIPE_BUF
  60. #define PIPE_BUF pathconf(".", _PC_PIPE_BUF)
  61. #else
  62. #define PIPE_BUF 512
  63. #endif
  64. #endif
  65. private void close_and_restore(const struct magic_set *, const char *, int,
  66. const struct stat *);
  67. private int unreadable_info(struct magic_set *, mode_t, const char *);
  68. private const char* get_default_magic(void);
  69. #ifndef COMPILE_ONLY
  70. private const char *file_or_fd(struct magic_set *, const char *, int);
  71. #endif
  72. #ifndef STDIN_FILENO
  73. #define STDIN_FILENO 0
  74. #endif
  75. private const char *
  76. get_default_magic(void)
  77. {
  78. static const char hmagic[] = "/.magic/magic.mgc";
  79. static char *default_magic;
  80. char *home, *hmagicpath;
  81. #ifndef WIN32
  82. struct stat st;
  83. if (default_magic) {
  84. free(default_magic);
  85. default_magic = NULL;
  86. }
  87. if ((home = getenv("HOME")) == NULL)
  88. return MAGIC;
  89. if (asprintf(&hmagicpath, "%s/.magic.mgc", home) < 0)
  90. return MAGIC;
  91. if (stat(hmagicpath, &st) == -1) {
  92. free(hmagicpath);
  93. if (asprintf(&hmagicpath, "%s/.magic", home) < 0)
  94. return MAGIC;
  95. if (stat(hmagicpath, &st) == -1)
  96. goto out;
  97. if (S_ISDIR(st.st_mode)) {
  98. free(hmagicpath);
  99. if (asprintf(&hmagicpath, "%s/%s", home, hmagic) < 0)
  100. return MAGIC;
  101. if (access(hmagicpath, R_OK) == -1)
  102. goto out;
  103. }
  104. }
  105. if (asprintf(&default_magic, "%s:%s", hmagicpath, MAGIC) < 0)
  106. goto out;
  107. free(hmagicpath);
  108. return default_magic;
  109. out:
  110. default_magic = NULL;
  111. free(hmagicpath);
  112. return MAGIC;
  113. #else
  114. char *hmagicp = hmagicpath;
  115. char *tmppath = NULL;
  116. #define APPENDPATH() \
  117. do { \
  118. if (tmppath && access(tmppath, R_OK) != -1) { \
  119. if (hmagicpath == NULL) \
  120. hmagicpath = tmppath; \
  121. else { \
  122. if (asprintf(&hmagicp, "%s%c%s", hmagicpath, \
  123. PATHSEP, tmppath) >= 0) { \
  124. free(hmagicpath); \
  125. hmagicpath = hmagicp; \
  126. } \
  127. free(tmppath); \
  128. } \
  129. tmppath = NULL; \
  130. } \
  131. } while (/*CONSTCOND*/0)
  132. if (default_magic) {
  133. free(default_magic);
  134. default_magic = NULL;
  135. }
  136. /* First, try to get user-specific magic file */
  137. if ((home = getenv("LOCALAPPDATA")) == NULL) {
  138. if ((home = getenv("USERPROFILE")) != NULL)
  139. if (asprintf(&tmppath,
  140. "%s/Local Settings/Application Data%s", home,
  141. hmagic) < 0)
  142. tmppath = NULL;
  143. } else {
  144. if (asprintf(&tmppath, "%s%s", home, hmagic) < 0)
  145. tmppath = NULL;
  146. }
  147. APPENDPATH();
  148. /* Second, try to get a magic file from Common Files */
  149. if ((home = getenv("COMMONPROGRAMFILES")) != NULL) {
  150. if (asprintf(&tmppath, "%s%s", home, hmagic) >= 0)
  151. APPENDPATH();
  152. }
  153. /* Third, try to get magic file relative to dll location */
  154. LPTSTR dllpath = malloc(sizeof(*dllpath) * (MAX_PATH + 1));
  155. dllpath[MAX_PATH] = 0; /* just in case long path gets truncated and not null terminated */
  156. if (GetModuleFileNameA(NULL, dllpath, MAX_PATH)){
  157. PathRemoveFileSpecA(dllpath);
  158. if (strlen(dllpath) > 3 &&
  159. stricmp(&dllpath[strlen(dllpath) - 3], "bin") == 0) {
  160. if (asprintf(&tmppath,
  161. "%s/../share/misc/magic.mgc", dllpath) >= 0)
  162. APPENDPATH();
  163. } else {
  164. if (asprintf(&tmppath,
  165. "%s/share/misc/magic.mgc", dllpath) >= 0)
  166. APPENDPATH();
  167. else if (asprintf(&tmppath,
  168. "%s/magic.mgc", dllpath) >= 0)
  169. APPENDPATH();
  170. }
  171. }
  172. /* Don't put MAGIC constant - it likely points to a file within MSys
  173. tree */
  174. default_magic = hmagicpath;
  175. return default_magic;
  176. #endif
  177. }
  178. public const char *
  179. magic_getpath(const char *magicfile, int action)
  180. {
  181. if (magicfile != NULL)
  182. return magicfile;
  183. magicfile = getenv("MAGIC");
  184. if (magicfile != NULL)
  185. return magicfile;
  186. return action == FILE_LOAD ? get_default_magic() : MAGIC;
  187. }
  188. public struct magic_set *
  189. magic_open(int flags)
  190. {
  191. return file_ms_alloc(flags);
  192. }
  193. private int
  194. unreadable_info(struct magic_set *ms, mode_t md, const char *file)
  195. {
  196. /* We cannot open it, but we were able to stat it. */
  197. if (access(file, W_OK) == 0)
  198. if (file_printf(ms, "writable, ") == -1)
  199. return -1;
  200. if (access(file, X_OK) == 0)
  201. if (file_printf(ms, "executable, ") == -1)
  202. return -1;
  203. if (S_ISREG(md))
  204. if (file_printf(ms, "regular file, ") == -1)
  205. return -1;
  206. if (file_printf(ms, "no read permission") == -1)
  207. return -1;
  208. return 0;
  209. }
  210. public void
  211. magic_close(struct magic_set *ms)
  212. {
  213. if (ms == NULL)
  214. return;
  215. file_ms_free(ms);
  216. }
  217. /*
  218. * load a magic file
  219. */
  220. public int
  221. magic_load(struct magic_set *ms, const char *magicfile)
  222. {
  223. if (ms == NULL)
  224. return -1;
  225. return file_apprentice(ms, magicfile, FILE_LOAD);
  226. }
  227. public int
  228. magic_compile(struct magic_set *ms, const char *magicfile)
  229. {
  230. if (ms == NULL)
  231. return -1;
  232. return file_apprentice(ms, magicfile, FILE_COMPILE);
  233. }
  234. public int
  235. magic_check(struct magic_set *ms, const char *magicfile)
  236. {
  237. if (ms == NULL)
  238. return -1;
  239. return file_apprentice(ms, magicfile, FILE_CHECK);
  240. }
  241. public int
  242. magic_list(struct magic_set *ms, const char *magicfile)
  243. {
  244. if (ms == NULL)
  245. return -1;
  246. return file_apprentice(ms, magicfile, FILE_LIST);
  247. }
  248. private void
  249. close_and_restore(const struct magic_set *ms, const char *name, int fd,
  250. const struct stat *sb)
  251. {
  252. if (fd == STDIN_FILENO)
  253. return;
  254. (void) close(fd);
  255. if ((ms->flags & MAGIC_PRESERVE_ATIME) != 0) {
  256. /*
  257. * Try to restore access, modification times if read it.
  258. * This is really *bad* because it will modify the status
  259. * time of the file... And of course this will affect
  260. * backup programs
  261. */
  262. #ifdef HAVE_UTIMES
  263. struct timeval utsbuf[2];
  264. (void)memset(utsbuf, 0, sizeof(utsbuf));
  265. utsbuf[0].tv_sec = sb->st_atime;
  266. utsbuf[1].tv_sec = sb->st_mtime;
  267. (void) utimes(name, utsbuf); /* don't care if loses */
  268. #elif defined(HAVE_UTIME_H) || defined(HAVE_SYS_UTIME_H)
  269. struct utimbuf utbuf;
  270. (void)memset(&utbuf, 0, sizeof(utbuf));
  271. utbuf.actime = sb->st_atime;
  272. utbuf.modtime = sb->st_mtime;
  273. (void) utime(name, &utbuf); /* don't care if loses */
  274. #endif
  275. }
  276. }
  277. #ifndef COMPILE_ONLY
  278. /*
  279. * find type of descriptor
  280. */
  281. public const char *
  282. magic_descriptor(struct magic_set *ms, int fd)
  283. {
  284. if (ms == NULL)
  285. return NULL;
  286. return file_or_fd(ms, NULL, fd);
  287. }
  288. /*
  289. * find type of named file
  290. */
  291. public const char *
  292. magic_file(struct magic_set *ms, const char *inname)
  293. {
  294. if (ms == NULL)
  295. return NULL;
  296. return file_or_fd(ms, inname, STDIN_FILENO);
  297. }
  298. private const char *
  299. file_or_fd(struct magic_set *ms, const char *inname, int fd)
  300. {
  301. int rv = -1;
  302. unsigned char *buf;
  303. struct stat sb;
  304. ssize_t nbytes = 0; /* number of bytes read from a datafile */
  305. int ispipe = 0;
  306. /*
  307. * one extra for terminating '\0', and
  308. * some overlapping space for matches near EOF
  309. */
  310. #define SLOP (1 + sizeof(union VALUETYPE))
  311. if ((buf = CAST(unsigned char *, malloc(HOWMANY + SLOP))) == NULL)
  312. return NULL;
  313. if (file_reset(ms) == -1)
  314. goto done;
  315. switch (file_fsmagic(ms, inname, &sb)) {
  316. case -1: /* error */
  317. goto done;
  318. case 0: /* nothing found */
  319. break;
  320. default: /* matched it and printed type */
  321. rv = 0;
  322. goto done;
  323. }
  324. if (inname == NULL) {
  325. if (fstat(fd, &sb) == 0 && S_ISFIFO(sb.st_mode))
  326. ispipe = 1;
  327. } else {
  328. int flags = O_RDONLY|O_BINARY;
  329. if (stat(inname, &sb) == 0 && S_ISFIFO(sb.st_mode)) {
  330. #ifdef O_NONBLOCK
  331. flags |= O_NONBLOCK;
  332. #endif
  333. ispipe = 1;
  334. }
  335. errno = 0;
  336. if ((fd = open(inname, flags)) < 0) {
  337. if (unreadable_info(ms, sb.st_mode, inname) == -1)
  338. goto done;
  339. rv = 0;
  340. goto done;
  341. }
  342. #ifdef O_NONBLOCK
  343. if ((flags = fcntl(fd, F_GETFL)) != -1) {
  344. flags &= ~O_NONBLOCK;
  345. (void)fcntl(fd, F_SETFL, flags);
  346. }
  347. #endif
  348. }
  349. /*
  350. * try looking at the first HOWMANY bytes
  351. */
  352. if (ispipe) {
  353. ssize_t r = 0;
  354. while ((r = sread(fd, (void *)&buf[nbytes],
  355. (size_t)(HOWMANY - nbytes), 1)) > 0) {
  356. nbytes += r;
  357. if (r < PIPE_BUF) break;
  358. }
  359. if (nbytes == 0) {
  360. /* We can not read it, but we were able to stat it. */
  361. if (unreadable_info(ms, sb.st_mode, inname) == -1)
  362. goto done;
  363. rv = 0;
  364. goto done;
  365. }
  366. } else {
  367. if ((nbytes = read(fd, (char *)buf, HOWMANY)) == -1) {
  368. file_error(ms, errno, "cannot read `%s'", inname);
  369. goto done;
  370. }
  371. }
  372. (void)memset(buf + nbytes, 0, SLOP); /* NUL terminate */
  373. if (file_buffer(ms, fd, inname, buf, (size_t)nbytes) == -1)
  374. goto done;
  375. rv = 0;
  376. done:
  377. free(buf);
  378. close_and_restore(ms, inname, fd, &sb);
  379. return rv == 0 ? file_getbuffer(ms) : NULL;
  380. }
  381. public const char *
  382. magic_buffer(struct magic_set *ms, const void *buf, size_t nb)
  383. {
  384. if (ms == NULL)
  385. return NULL;
  386. if (file_reset(ms) == -1)
  387. return NULL;
  388. /*
  389. * The main work is done here!
  390. * We have the file name and/or the data buffer to be identified.
  391. */
  392. if (file_buffer(ms, -1, NULL, buf, nb) == -1) {
  393. return NULL;
  394. }
  395. return file_getbuffer(ms);
  396. }
  397. #endif
  398. public const char *
  399. magic_error(struct magic_set *ms)
  400. {
  401. if (ms == NULL)
  402. return "Magic database is not open";
  403. return (ms->event_flags & EVENT_HAD_ERR) ? ms->o.buf : NULL;
  404. }
  405. public int
  406. magic_errno(struct magic_set *ms)
  407. {
  408. if (ms == NULL)
  409. return EINVAL;
  410. return (ms->event_flags & EVENT_HAD_ERR) ? ms->error : 0;
  411. }
  412. public int
  413. magic_setflags(struct magic_set *ms, int flags)
  414. {
  415. if (ms == NULL)
  416. return -1;
  417. #if !defined(HAVE_UTIME) && !defined(HAVE_UTIMES)
  418. if (flags & MAGIC_PRESERVE_ATIME)
  419. return -1;
  420. #endif
  421. ms->flags = flags;
  422. return 0;
  423. }
  424. public int
  425. magic_version(void)
  426. {
  427. return MAGIC_VERSION;
  428. }