Lines Matching refs:ms
87 - struct magic_set *ms;
100 - if ((ms = magic_open(MAGIC_CHECK)) == NULL) {
104 - ret = magic_compile(ms, argv[1]) == -1 ? 1 : 0;
106 - (void)fprintf(stderr, "%s: %s\n", progname, magic_error(ms));
107 - magic_close(ms);
125 apprentice_1(struct magic_set *ms, const char *fn, int action)
134 file_error(ms, 0, "magic element size %lu != %lu",
136 return apprentice_compile(ms, map, fn);
140 map = apprentice_map(ms, fn);
144 - if (ms->flags & MAGIC_CHECK)
145 - file_magwarn(ms, "using regular magic file `%s'", fn);
146 - map = apprentice_load(ms, fn, action);
148 + if (ms->flags & MAGIC_CHECK)
149 + file_magwarn(ms, "using regular magic file `%s'", fn);
150 + map = apprentice_load(ms, fn, action);
168 mlist_free(ms->mlist[i]);
169 - free(ms->o.pbuf);
170 - free(ms->o.buf);
171 - free(ms->c.li);
172 - free(ms);
173 + if (ms->o.pbuf) {
174 + efree(ms->o.pbuf);
176 + if (ms->o.buf) {
177 + efree(ms->o.buf);
179 + if (ms->c.li) {
180 + efree(ms->c.li);
182 + efree(ms);
187 struct magic_set *ms;
190 - if ((ms = CAST(struct magic_set *, calloc(CAST(size_t, 1u),
191 + if ((ms = CAST(struct magic_set *, ecalloc(CAST(size_t, 1u),
196 ms->o.buf = ms->o.pbuf = NULL;
197 len = (ms->c.len = 10) * sizeof(*ms->c.li);
199 - if ((ms->c.li = CAST(struct level_info *, malloc(len))) == NULL)
200 + if ((ms->c.li = CAST(struct level_info *, emalloc(len))) == NULL)
203 ms->event_flags = 0;
205 ms->bytes_max = FILE_BYTES_MAX;
206 return ms;
208 - free(ms);
209 + efree(ms);
282 -buffer_apprentice(struct magic_set *ms, struct magic **bufs,
292 - (void)file_reset(ms, 0);
297 - mlist_free(ms->mlist[i]);
298 - if ((ms->mlist[i] = mlist_alloc()) == NULL) {
299 - file_oomem(ms, sizeof(*ms->mlist[i]));
305 - map = apprentice_buf(ms, bufs[i], sizes[i]);
310 - if (add_mlist(ms->mlist[j], map, j) == -1) {
311 - file_oomem(ms, sizeof(*ml));
320 - mlist_free(ms->mlist[i]);
321 - ms->mlist[i] = NULL;
329 file_apprentice(struct magic_set *ms, const char *fn, int action)
332 (void)file_reset(ms, 0);
347 + mlist_free(ms->mlist[i]);
348 + if ((ms->mlist[i] = mlist_alloc()) == NULL) {
349 + file_oomem(ms, sizeof(*ms->mlist[i]));
353 + return apprentice_1(ms, fn, action);
357 file_oomem(ms, strlen(fn));
361 mlist_free(ms->mlist[i]);
362 ms->mlist[i] = NULL;
385 file_oomem(ms, sizeof(*mp) * mset[i].max);
388 load_1(struct magic_set *ms, int action, const char *fn, int *errs,
399 - FILE *f = fopen(ms->file = fn, "r");
404 + ms->file = fn;
409 file_error(ms, errno, "cannot read magic file `%s'",
415 - for (ms->line = 1; (len = getline(&line, &llen, f)) != -1;
416 - ms->line++) {
417 + for (ms->line = 1; (line = php_stream_get_line(stream, buffer , BUFSIZ, &len)) != NULL; ms->line+…
424 (void)addentry(ms, &me, mset);
438 file_oomem(ms, slen);
469 ms->flags |= MAGIC_CHECK; /* Enable checks for parsed files */
475 file_oomem(ms, sizeof(*map));
500 file_oomem(ms,
520 file_oomem(ms, mlen);
536 load_1(ms, action, filearr[i], &errs, mset);
544 load_1(ms, action, fn, &errs, mset);
552 file_oomem(ms, sizeof(*nm) * cnt);
560 file_oomem(ms, len);
564 file_magwarn(ms, "offset `%s' invalid", l);
570 - if (ms->flags & MAGIC_CHECK) {
571 - file_magwarn(ms,
588 else if (ms->flags & MAGIC_CHECK)
589 file_magwarn(ms, "'~' invalid for string types");
600 if (check_format(ms, m) == -1)
614 parse_extra(struct magic_set *ms, struct magic_entry *me, const char *line,
623 return parse_extra(ms, me, line,
636 - if (ms->flags & MAGIC_CHECK)
637 - file_regerror(&rx, rc, ms);
674 apprentice_map(struct magic_set *ms, const char *fn)
693 file_oomem(ms, sizeof(*map));
714 dbname = mkdbname(ms, fn, 0);
728 file_error(ms, errno, "cannot stat `%s'", dbname);
734 file_error(ms, 0, "file `%s' is too %s", dbname,
745 - file_error(ms, errno, "cannot map `%s'", dbname);
751 - file_oomem(ms, map->len);
759 file_badread(ms);
767 - if (check_buffer(ms, map, dbname) != 0) {
776 + file_error(ms, 0, "bad magic in `%s'", dbname);
787 + file_error(ms, 0, "File %d.%d supports only version %d magic "
794 - file_error(ms, errno, "cannot mprotect `%s'", dbname);
808 + file_error(ms, 0, "Size of `%s' %llu is not a multiple of %zu",
826 + file_error(ms, 0, "Inconsistent entries in `%s' %u != %u",
858 check_buffer(struct magic_set *ms, struct magic_map *map, const char *dbname)
863 file_error(ms, 0, "File %s supports only version %d magic "
891 dbname = mkdbname(ms, fn, 1);
902 file_error(ms, errno, "cannot open `%s'", dbname);
911 file_error(ms, errno, "error writing `%s'", dbname);
920 file_error(ms, errno, "error writing `%s'", dbname);
943 if (ms->flags & MAGIC_MIME) {
954 ms->flags &= MAGIC_MIME_TYPE;
979 rv = file_ascmagic_with_encoding(ms, &bb,
993 file_oomem(ms, mlen);
1452 prv = format_decompression_error(ms, i, newbuf);
1454 - prv = file_buffer(ms, -1, NULL, name, newbuf, nsz);
1455 + prv = file_buffer(ms, NULL, NULL, name, newbuf, nsz);
1463 - if (file_buffer(ms, -1, NULL, NULL, buf, nbytes) == -1) {
1464 + if (file_buffer(ms, NULL, NULL, NULL, buf, nbytes) == -1) {
1465 if (file_pop_buffer(ms, pb) != NULL)
1469 if ((rbuf = file_pop_buffer(ms, pb)) != NULL) {
1470 if (file_printf(ms, "%s", rbuf) == -1) {
1478 if (!mime && file_printf(ms, ")") == -1)
1487 ms->flags |= MAGIC_COMPRESS;
1522 file_badseek(ms);
1580 return toomany(ms, "program headers", phnum);
1582 if (dophn_core(ms, clazz, swap, fd,
1589 if (shnum > ms->elf_shnum_max)
1590 return toomany(ms, "section", shnum);
1591 if (dophn_exec(ms, clazz, swap, fd,
1598 if (shnum > ms->elf_shnum_max)
1599 return toomany(ms, "section headers", shnum);
1600 if (doshn(ms, clazz, swap, fd,
1624 file_oomem(ms, mlen);
1631 file_oomem(ms, mlen);
1949 -bad_link(struct magic_set *ms, int err, char *buf)
1951 - int mime = ms->flags & MAGIC_MIME;
1953 - file_printf(ms, "inode/symlink")
1957 - if (ms->flags & MAGIC_ERROR) {
1958 - file_error(ms, err,
1962 - if (file_printf(ms, "broken symbolic link to %s", buf) == -1)
1973 handle_mime(struct magic_set *ms, int mime, const char *str)
1978 -file_fsmagic(struct magic_set *ms, const char *fn, struct stat *sb)
1979 +file_fsmagic(struct magic_set *ms, const char *fn, zend_stat_t *sb)
1982 int mime = ms->flags & MAGIC_MIME;
1983 int silent = ms->flags & (MAGIC_APPLE|MAGIC_EXTENSION);
1999 - if ((ms->flags & MAGIC_SYMLINK) == 0)
2036 if (ms->flags & MAGIC_ERROR) {
2043 - if (handle_mime(ms, mime, "directory") == -1)
2046 - } else if (file_printf(ms, "%sdirectory", COMMA) == -1)
2056 - if ((ms->flags & MAGIC_DEVICES) != 0) {
2061 - if (handle_mime(ms, mime, "chardevice") == -1)
2075 + if ((ms->flags & MAGIC_DEVICES) != 0) {
2080 + if (handle_mime(ms, mime, "chardevice") == -1)
2085 if (file_printf(ms, "%scharacter special (%d/%d/%d)",
2089 if (file_printf(ms, "%scharacter special", COMMA) == -1)
2102 - if ((ms->flags & MAGIC_DEVICES) != 0) {
2107 - if (handle_mime(ms, mime, "blockdevice") == -1)
2113 - if (file_printf(ms, "%sblock special (%d/%d/%d)",
2118 - if (file_printf(ms, "%sblock special (%ld/%ld)",
2126 - if (file_printf(ms, "%sblock special", COMMA) == -1)
2136 if((ms->flags & MAGIC_DEVICES) != 0)
2143 if (ms->flags & MAGIC_ERROR) {
2144 - file_error(ms, errno, "unreadable symlink `%s'",
2146 + file_error(ms, errno, "unreadable symlink `%s'", fn);
2150 - if (handle_mime(ms, mime, "symlink") == -1)
2153 - } else if (file_printf(ms,
2169 - return bad_link(ms, errno, buf);
2173 - return bad_link(ms, errno, buf);
2182 - if (ms->flags & MAGIC_ERROR) {
2183 - file_error(ms, 0,
2188 - if (handle_mime(ms, mime,
2192 - } else if (file_printf(ms,
2206 - return bad_link(ms, errno, buf);
2212 - if ((ms->flags & MAGIC_SYMLINK) != 0) {
2214 - ms->flags &= MAGIC_SYMLINK;
2215 - p = magic_file(ms, buf);
2216 - ms->flags |= MAGIC_SYMLINK;
2221 - if (handle_mime(ms, mime, "symlink") == -1)
2224 - } else if (file_printf(ms, "%ssymbolic link to %s",
2252 -file_vprintf(struct magic_set *ms, const char *fmt, va_list ap)
2259 - if (ms->event_flags & EVENT_HAD_ERR)
2265 - if (ms->o.buf != NULL) {
2266 - len = asprintf(&newstr, "%s%s", ms->o.buf, buf);
2270 - free(ms->o.buf);
2273 - ms->o.buf = buf;
2284 file_printf(struct magic_set *ms, const char *fmt, ...)
2291 - rv = file_vprintf(ms, fmt, ap);
2296 + if (ms->o.buf != NULL) {
2297 + spprintf(&newstr, 0, "%s%s", ms->o.buf, (buf ? buf : ""));
2301 + efree(ms->o.buf);
2302 + ms->o.buf = newstr;
2304 + ms->o.buf = buf;
2315 file_error_core(struct magic_set *ms, int error, const char *f, va_list va,
2321 if (ms->event_flags & EVENT_HAD_ERR)
2324 - free(ms->o.buf);
2325 + efree(ms->o.buf);
2326 ms->o.buf = NULL;
2327 - (void)file_printf(ms, "line %" SIZE_T_FORMAT "u:", lineno);
2328 + file_printf(ms, "line %" SIZE_T_FORMAT "u:", lineno);
2330 - if (ms->o.buf && *ms->o.buf)
2331 - (void)file_printf(ms, " ");
2332 - (void)file_vprintf(ms, f, va);
2334 - (void)file_printf(ms, " (%s)", strerror(error));
2340 + file_printf(ms, "%s (%s)", (*buf ? buf : ""), strerror(error));
2342 + file_printf(ms, "%s", buf);
2349 ms->event_flags |= EVENT_HAD_ERR;
2350 ms->error = error;
2353 file_error(ms, errno, "error reading");
2359 file_separator(struct magic_set *ms)
2365 -file_buffer(struct magic_set *ms, int fd, struct stat *st,
2367 +file_buffer(struct magic_set *ms, php_stream *stream, zend_stat_t *st,
2391 ms->mode = b.st.st_mode;
2400 if ((ms->flags & MAGIC_NO_CHECK_COMPRESS) == 0) {
2401 m = file_zmagic(ms, &b, inname);
2402 if ((ms->flags & MAGIC_DEBUG) != 0)
2404 if (file_printf(ms, "%s", code_mime) == -1)
2422 file_reset(struct magic_set *ms, int checkloaded)
2426 if (ms->o.buf) {
2427 - free(ms->o.buf);
2428 + efree(ms->o.buf);
2429 ms->o.buf = NULL;
2431 if (ms->o.pbuf) {
2432 - free(ms->o.pbuf);
2433 + efree(ms->o.pbuf);
2434 ms->o.pbuf = NULL;
2436 ms->event_flags &= ~EVENT_HAD_ERR;
2441 - if ((pbuf = CAST(char *, realloc(ms->o.pbuf, psize))) == NULL) {
2442 + if ((pbuf = CAST(char *, erealloc(ms->o.pbuf, psize))) == NULL) {
2443 file_oomem(ms, psize);
2447 if (level >= ms->c.len) {
2448 len = (ms->c.len = 20 + level) * sizeof(*ms->c.li);
2449 ms->c.li = CAST(struct level_info *, (ms->c.li == NULL) ?
2451 - realloc(ms->c.li, len));
2453 + erealloc(ms->c.li, len));
2454 if (ms->c.li == NULL) {
2455 file_oomem(ms, len);
2459 file_replace(struct magic_set *ms, const char *pat, const char *rep)
2466 - file_regerror(&rx, rc, ms);
2470 - while (file_regexec(&rx, ms->o.buf, 1, &rm, 0) == 0) {
2471 - ms->o.buf[rm.rm_so] = '\0';
2472 - if (file_printf(ms, "%s%s", rep,
2473 - rm.rm_eo != 0 ? ms->o.buf + rm.rm_eo : "") == -1)
2514 + res = php_pcre_replace_impl(pce, NULL, ms->o.buf, strlen(ms->o.buf), repl, -1, &rep_cnt);
2543 + strncpy(ms->o.buf, ZSTR_VAL(res), ZSTR_LEN(res));
2544 + ms->o.buf[ZSTR_LEN(res)] = '\0';
2547 -file_regerror(file_regex_t *rx, int rc, struct magic_set *ms)
2553 - file_magerror(ms, "regex error %d for `%s', (%s)", rc, rx->pat,
2561 if (ms->event_flags & EVENT_HAD_ERR)
2568 pb->buf = ms->o.buf;
2572 if (ms->event_flags & EVENT_HAD_ERR) {
2581 ms->o.buf = pb->buf;
2582 ms->offset = pb->offset;
2826 return file_apprentice(ms, magicfile, FILE_LOAD);
2834 -magic_load_buffers(struct magic_set *ms, void **bufs, size_t *sizes,
2837 - if (ms == NULL)
2839 - return buffer_apprentice(ms, RCAST(struct magic **, bufs),
2845 magic_compile(struct magic_set *ms, const char *magicfile)
2848 return file_apprentice(ms, magicfile, FILE_LIST);
2853 close_and_restore(const struct magic_set *ms, const char *name, int fd,
2871 if (ms == NULL)
2873 - return file_or_fd(ms, NULL, fd);
2874 + return file_or_stream(ms, NULL, NULL);
2880 if (ms == NULL)
2882 - return file_or_fd(ms, inname, STDIN_FILENO);
2883 + return file_or_stream(ms, inname, NULL);
2887 +magic_stream(struct magic_set *ms, php_stream *stream)
2889 + if (ms == NULL)
2891 + return file_or_stream(ms, NULL, stream);
2895 -file_or_fd(struct magic_set *ms, const char *inname, int fd)
2896 +file_or_stream(struct magic_set *ms, const char *inname, php_stream *stream)
2908 if (file_reset(ms, 1) == -1)
2914 - if ((buf = CAST(unsigned char *, malloc(ms->bytes_max + SLOP))) == NULL)
2915 + if ((buf = CAST(unsigned char *, emalloc(ms->bytes_max + SLOP))) == NULL)
2918 switch (file_fsmagic(ms, inname, &sb)) {
2948 - unreadable_info(ms, sb.st_mode, inname) == -1)
2955 + if (unreadable_info(ms, sb.st_mode, inname) == -1)
2972 + if (ms->flags & MAGIC_ERROR) {
2973 + file_error(ms, errno, "cannot stat `%s'", inname);
2981 * try looking at the first ms->bytes_max bytes
2988 - CAST(size_t, ms->bytes_max - nbytes), 1)) > 0) {
2996 - if (unreadable_info(ms, sb.st_mode, inname) == -1)
3008 - ms->bytes_max;
3011 - file_error(ms, errno, "cannot read fd %d", fd);
3013 - file_error(ms, errno, "cannot read `%s'",
3017 + if ((nbytes = php_stream_read(stream, (char *)buf, ms->bytes_max - nbytes)) < 0) {
3018 + file_error(ms, errno, "cannot read `%s'", inname);
3023 - if (file_buffer(ms, fd, okstat ? &sb : NULL, inname, buf, CAST(size_t, nbytes)) == -1)
3024 + if (file_buffer(ms, stream, &sb, inname, buf, CAST(size_t, nbytes)) == -1)
3032 - close_and_restore(ms, inname, fd, &sb);
3039 return rv == 0 ? file_getbuffer(ms) : NULL;
3044 - if (file_buffer(ms, -1, NULL, NULL, buf, nb) == -1) {
3045 + if (file_buffer(ms, NULL, NULL, NULL, buf, nb) == -1) {
3048 return file_getbuffer(ms);
3053 magic_error(struct magic_set *ms)
3095 file_magwarn(struct magic_set *ms, const char *f, ...)
3104 - if (ms->file)
3105 - (void) fprintf(stderr, "%s, %lu: ", ms->file,
3106 - CAST(unsigned long, ms->line));
3214 - if (!NOTMIME(ms) && root_storage)
3217 + if (!NOTMIME(ms) && root_storage)
3222 if (file_printf(ms, "%s%s",
3231 } else if (ms->flags & MAGIC_MIME_TYPE) {
3232 if (file_printf(ms, "application/CDFV2") == -1)
3237 m = cdf_file_property_info(ms, info, count, root_storage);
3306 check_fmt(struct magic_set *ms, const char *fmt)
3319 - file_regerror(&rx, rc, ms);
3361 varexpand(struct magic_set *ms, char *buf, size_t len, const char *str)
3367 - cp = strndup(RCAST(const char *, ms->search.s),
3368 + cp = estrndup(RCAST(const char *, ms->search.s),
3369 ms->search.rm_len);
3371 - file_oomem(ms, ms->search.rm_len);
3374 rval = file_printf(ms, F(ms, desc, "%s"),
3375 - file_printable(sbuf, sizeof(sbuf), cp, ms->search.rm_len));
3377 + file_printable(sbuf, sizeof(sbuf), cp, ms->search.rm_len));
3402 if ((ms->flags & MAGIC_DEBUG) != 0) {
3414 if ((ms->flags & MAGIC_NODESC) == 0 &&
3415 - file_printf(ms, F(ms, m->desc, "%u"), offset) == -1)
3418 + file_printf(ms, F(ms, m->desc, "%u"), offset) == -1) {
3422 if (file_printf(ms, "%s", rbuf) == -1) {
3493 magiccheck(struct magic_set *ms, struct magic *m)
3506 - if (ms->search.s == NULL)
3515 - file_regerror(&rx, rc, ms);
3529 - size_t slen = ms->search.s_len;
3535 - file_error(ms, errno,
3540 - memcpy(copy, ms->search.s, slen);
3552 + haystack = zend_string_init(ms->search.s, ms->search.s_len, 0);
3578 + ms->search.s += Z_LVAL_P(offset); /* this is where the match starts */
3579 + ms->search.offset += Z_LVAL_P(offset); /* this is where the match starts as size_t */
3580 + ms->search.rm_len = Z_STRLEN_P(match) /* This is the length of the matched pattern */;
3600 - ms->search.s += CAST(int, pmatch.rm_so);
3601 - ms->search.offset += CAST(size_t, pmatch.rm_so);
3602 - ms->search.rm_len = CAST(size_t,
3612 - file_regerror(&rx, rc, ms);
