Annotation of embedaddon/php/ext/fileinfo/libmagic/magic.c, revision 1.1.1.1
1.1 misho 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:
28: #include "file.h"
29:
30: #ifndef lint
31: FILE_RCSID("@(#)$File: magic.c,v 1.62 2009/03/20 21:25:41 christos Exp $")
32: #endif /* lint */
33:
34: #include "magic.h"
35:
36: #include <stdlib.h>
37: #ifdef PHP_WIN32
38: #include "win32/unistd.h"
39: #else
40: #include <unistd.h>
41: #endif
42: #include <string.h>
43: #ifdef PHP_WIN32
44: # include "config.w32.h"
45: #else
46: # include "php_config.h"
47: #endif
48:
49: #include <limits.h> /* for PIPE_BUF */
50:
51: #if defined(HAVE_UTIMES)
52: # include <sys/time.h>
53: #elif defined(HAVE_UTIME)
54: # if defined(HAVE_SYS_UTIME_H)
55: # include <sys/utime.h>
56: # elif defined(HAVE_UTIME_H)
57: # include <utime.h>
58: # endif
59: #endif
60:
61: #ifdef HAVE_UNISTD_H
62: #include <unistd.h> /* for read() */
63: #endif
64:
65: #ifndef PHP_WIN32
66: # include <netinet/in.h> /* for byte swapping */
67: #endif
68:
69: #include "patchlevel.h"
70:
71: #ifndef PIPE_BUF
72: /* Get the PIPE_BUF from pathconf */
73: #ifdef _PC_PIPE_BUF
74: #define PIPE_BUF pathconf(".", _PC_PIPE_BUF)
75: #else
76: #define PIPE_BUF 512
77: #endif
78: #endif
79:
80: #ifdef PHP_WIN32
81: # undef S_IFLNK
82: # undef S_IFIFO
83: #endif
84:
85: private void free_mlist(struct mlist *);
86: private void close_and_restore(const struct magic_set *, const char *, int,
87: const struct stat *);
88: private int unreadable_info(struct magic_set *, mode_t, const char *);
89: private const char *file_or_stream(struct magic_set *, const char *, php_stream *);
90:
91: #ifndef STDIN_FILENO
92: #define STDIN_FILENO 0
93: #endif
94:
95: public struct magic_set *
96: magic_open(int flags)
97: {
98: struct magic_set *ms;
99:
100: ms = ecalloc((size_t)1, sizeof(struct magic_set));
101:
102: if (magic_setflags(ms, flags) == -1) {
103: errno = EINVAL;
104: goto free;
105: }
106:
107: ms->o.buf = ms->o.pbuf = NULL;
108:
109: ms->c.li = emalloc((ms->c.len = 10) * sizeof(*ms->c.li));
110:
111: ms->event_flags = 0;
112: ms->error = -1;
113: ms->mlist = NULL;
114: ms->file = "unknown";
115: ms->line = 0;
116: return ms;
117: free:
118: efree(ms);
119: return NULL;
120: }
121:
122: private void
123: free_mlist(struct mlist *mlist)
124: {
125: struct mlist *ml;
126:
127: if (mlist == NULL)
128: return;
129:
130: for (ml = mlist->next; ml != mlist;) {
131: struct mlist *next = ml->next;
132: struct magic *mg = ml->magic;
133: file_delmagic(mg, ml->mapped, ml->nmagic);
134: efree(ml);
135: ml = next;
136: }
137: efree(ml);
138: }
139:
140: private int
141: unreadable_info(struct magic_set *ms, mode_t md, const char *file)
142: {
143: /* We cannot open it, but we were able to stat it. */
144: if (access(file, W_OK) == 0)
145: if (file_printf(ms, "writable, ") == -1)
146: return -1;
147: if (access(file, X_OK) == 0)
148: if (file_printf(ms, "executable, ") == -1)
149: return -1;
150: if (S_ISREG(md))
151: if (file_printf(ms, "regular file, ") == -1)
152: return -1;
153: if (file_printf(ms, "no read permission") == -1)
154: return -1;
155: return 0;
156: }
157:
158: public void
159: magic_close(struct magic_set *ms)
160: {
161: if (ms->mlist) {
162: free_mlist(ms->mlist);
163: }
164: if (ms->o.pbuf) {
165: efree(ms->o.pbuf);
166: }
167: if (ms->o.buf) {
168: efree(ms->o.buf);
169: }
170: if (ms->c.li) {
171: efree(ms->c.li);
172: }
173: efree(ms);
174: }
175:
176: /*
177: * load a magic file
178: */
179: public int
180: magic_load(struct magic_set *ms, const char *magicfile)
181: {
182: struct mlist *ml = file_apprentice(ms, magicfile, FILE_LOAD);
183: if (ml) {
184: free_mlist(ms->mlist);
185: ms->mlist = ml;
186: return 0;
187: }
188: return -1;
189: }
190:
191: public int
192: magic_compile(struct magic_set *ms, const char *magicfile)
193: {
194: struct mlist *ml = file_apprentice(ms, magicfile, FILE_COMPILE);
195: free_mlist(ml);
196: return ml ? 0 : -1;
197: }
198:
199: private void
200: close_and_restore(const struct magic_set *ms, const char *name, int fd,
201: const struct stat *sb)
202: {
203:
204: if ((ms->flags & MAGIC_PRESERVE_ATIME) != 0) {
205: /*
206: * Try to restore access, modification times if read it.
207: * This is really *bad* because it will modify the status
208: * time of the file... And of course this will affect
209: * backup programs
210: */
211: #ifdef HAVE_UTIMES
212: struct timeval utsbuf[2];
213: (void)memset(utsbuf, 0, sizeof(utsbuf));
214: utsbuf[0].tv_sec = sb->st_atime;
215: utsbuf[1].tv_sec = sb->st_mtime;
216:
217: (void) utimes(name, utsbuf); /* don't care if loses */
218: #elif defined(HAVE_UTIME_H) || defined(HAVE_SYS_UTIME_H)
219: struct utimbuf utbuf;
220:
221: (void)memset(&utbuf, 0, sizeof(utbuf));
222: utbuf.actime = sb->st_atime;
223: utbuf.modtime = sb->st_mtime;
224: (void) utime(name, &utbuf); /* don't care if loses */
225: #endif
226: }
227: }
228:
229:
230: /*
231: * find type of descriptor
232: */
233: public const char *
234: magic_descriptor(struct magic_set *ms, int fd)
235: {
236: return file_or_stream(ms, NULL, NULL);
237: }
238:
239: /*
240: * find type of named file
241: */
242: public const char *
243: magic_file(struct magic_set *ms, const char *inname)
244: {
245: return file_or_stream(ms, inname, NULL);
246: }
247:
248: public const char *
249: magic_stream(struct magic_set *ms, php_stream *stream)
250: {
251: return file_or_stream(ms, NULL, stream);
252: }
253:
254: private const char *
255: file_or_stream(struct magic_set *ms, const char *inname, php_stream *stream)
256: {
257: int rv = -1;
258: unsigned char *buf;
259: struct stat sb;
260: ssize_t nbytes = 0; /* number of bytes read from a datafile */
261: int no_in_stream = 0;
262: TSRMLS_FETCH();
263:
264: if (!inname && !stream) {
265: return NULL;
266: }
267:
268: /*
269: * one extra for terminating '\0', and
270: * some overlapping space for matches near EOF
271: */
272: #define SLOP (1 + sizeof(union VALUETYPE))
273: buf = emalloc(HOWMANY + SLOP);
274:
275: if (file_reset(ms) == -1) {
276: goto done;
277: }
278:
279: switch (file_fsmagic(ms, inname, &sb, stream)) {
280: case -1: /* error */
281: goto done;
282: case 0: /* nothing found */
283: break;
284: default: /* matched it and printed type */
285: rv = 0;
286: goto done;
287: }
288:
289: errno = 0;
290:
291: if (!stream && inname) {
292: no_in_stream = 1;
293: #if PHP_API_VERSION < 20100412
294: stream = php_stream_open_wrapper((char *)inname, "rb", REPORT_ERRORS|ENFORCE_SAFE_MODE, NULL);
295: #else
296: stream = php_stream_open_wrapper((char *)inname, "rb", REPORT_ERRORS, NULL);
297: #endif
298: }
299:
300: if (!stream) {
301: if (unreadable_info(ms, sb.st_mode, inname) == -1)
302: goto done;
303: rv = 0;
304: goto done;
305: }
306:
307: #ifdef O_NONBLOCK
308: /* we should be already be in non blocking mode for network socket */
309: #endif
310:
311: /*
312: * try looking at the first HOWMANY bytes
313: */
314: if ((nbytes = php_stream_read(stream, (char *)buf, HOWMANY)) < 0) {
315: file_error(ms, errno, "cannot read `%s'", inname);
316: goto done;
317: }
318:
319: (void)memset(buf + nbytes, 0, SLOP); /* NUL terminate */
320: if (file_buffer(ms, stream, inname, buf, (size_t)nbytes) == -1)
321: goto done;
322: rv = 0;
323: done:
324: efree(buf);
325:
326: if (no_in_stream && stream) {
327: php_stream_close(stream);
328: }
329:
330: close_and_restore(ms, inname, 0, &sb);
331: return rv == 0 ? file_getbuffer(ms) : NULL;
332: }
333:
334: public const char *
335: magic_buffer(struct magic_set *ms, const void *buf, size_t nb)
336: {
337: if (file_reset(ms) == -1)
338: return NULL;
339: /*
340: * The main work is done here!
341: * We have the file name and/or the data buffer to be identified.
342: */
343: if (file_buffer(ms, NULL, NULL, buf, nb) == -1) {
344: return NULL;
345: }
346: return file_getbuffer(ms);
347: }
348:
349: public const char *
350: magic_error(struct magic_set *ms)
351: {
352: return (ms->event_flags & EVENT_HAD_ERR) ? ms->o.buf : NULL;
353: }
354:
355: public int
356: magic_errno(struct magic_set *ms)
357: {
358: return (ms->event_flags & EVENT_HAD_ERR) ? ms->error : 0;
359: }
360:
361: public int
362: magic_setflags(struct magic_set *ms, int flags)
363: {
364: #if !defined(HAVE_UTIME) && !defined(HAVE_UTIMES)
365: if (flags & MAGIC_PRESERVE_ATIME)
366: return -1;
367: #endif
368: ms->flags = flags;
369: return 0;
370: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to magic.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / fileinfo / libmagic