From nobody Thu Oct 27 07:17:59 2022 X-Original-To: dev-commits-src-all@mlmmj.nyi.freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2610:1c1:1:606c::19:1]) by mlmmj.nyi.freebsd.org (Postfix) with ESMTP id 4MycTM4VJsz4gSLf; Thu, 27 Oct 2022 07:17:59 +0000 (UTC) (envelope-from git@FreeBSD.org) Received: from mxrelay.nyi.freebsd.org (mxrelay.nyi.freebsd.org [IPv6:2610:1c1:1:606c::19:3]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256 client-signature RSA-PSS (4096 bits) client-digest SHA256) (Client CN "mxrelay.nyi.freebsd.org", Issuer "R3" (verified OK)) by mx1.freebsd.org (Postfix) with ESMTPS id 4MycTM4FSzz3h1d; Thu, 27 Oct 2022 07:17:59 +0000 (UTC) (envelope-from git@FreeBSD.org) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=freebsd.org; s=dkim; t=1666855079; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding; bh=7vSJwnfR1DIA46vc6SCnItYh00hc8BOgpUE5aFGyXio=; b=xBJ3iH3NsXd/ZsJKT4wDczbLrlX7+euWcqp+4L3WxrdAW1zF66yCOXhX94KSmUlkd5uleR 8fy1//FiGbcVGesUfKbHRhaHovwBBtxOYD7IDpDjZ+xBf4jM1T1yemhj5LpAXjVrlyWam/ JoTnLWagwYotnLk3CspRaReyWcr6yYjIY76UxYWaYLKTf6YqbThf4WRlf0hCYrkr6bKqUl hDfQylx9xcgPAqNe9NHTitguu9klbxOEJbfDzGutDIy/nJOIYavYfpLyVx0pTedAd/rad6 JHsWl6hcZcKsu/9tHH0nm8b5joHYMXkQDrVln7LnKKp6ZbRE2mA1lFyqoLn2/g== Received: from gitrepo.freebsd.org (gitrepo.freebsd.org [IPv6:2610:1c1:1:6068::e6a:5]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (Client did not present a certificate) by mxrelay.nyi.freebsd.org (Postfix) with ESMTPS id 4MycTM3J88zpVZ; Thu, 27 Oct 2022 07:17:59 +0000 (UTC) (envelope-from git@FreeBSD.org) Received: from gitrepo.freebsd.org ([127.0.1.44]) by gitrepo.freebsd.org (8.16.1/8.16.1) with ESMTP id 29R7Hxpj012711; Thu, 27 Oct 2022 07:17:59 GMT (envelope-from git@gitrepo.freebsd.org) Received: (from git@localhost) by gitrepo.freebsd.org (8.16.1/8.16.1/Submit) id 29R7Hx8f012710; Thu, 27 Oct 2022 07:17:59 GMT (envelope-from git) Date: Thu, 27 Oct 2022 07:17:59 GMT Message-Id: <202210270717.29R7Hx8f012710@gitrepo.freebsd.org> To: src-committers@FreeBSD.org, dev-commits-src-all@FreeBSD.org, dev-commits-src-main@FreeBSD.org From: Xin LI Subject: git: 07dfb236c814 - main - MFV: Restore the ability to process files from stdin immediately. List-Id: Commit messages for all branches of the src repository List-Archive: https://lists.freebsd.org/archives/dev-commits-src-all List-Help: List-Post: List-Subscribe: List-Unsubscribe: Sender: owner-dev-commits-src-all@freebsd.org X-BeenThere: dev-commits-src-all@freebsd.org MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 8bit X-Git-Committer: delphij X-Git-Repository: src X-Git-Refname: refs/heads/main X-Git-Reftype: branch X-Git-Commit: 07dfb236c81483c2f08a3976f6d44ce307f4ceaf Auto-Submitted: auto-generated ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=freebsd.org; s=dkim; t=1666855079; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding; bh=7vSJwnfR1DIA46vc6SCnItYh00hc8BOgpUE5aFGyXio=; b=hO0fi+MZbOZt2obriBgjg/Qji/5E0yhLNsOTqdg+aN5rp1Q0SCHprlNZiR2iwIcAYt1eHe A2RCya0UkekR+7RrIjBOsBf3quIzVelR1Al04ZJV7FOFBpdGgK9ETzx85ZkEcyHZbwXzOj 9qxqs9w/udALM2wDxRa1P3rZvapD7cTgPPUFZOz6Z7WYafijqfS83rHRX+mpNPSDRtrfZj OyOStIxfDDiFfc86DICsz/sPjoNS2MWGmjdryW0s3Lkg13ik7GhZAyeDvcBYqT6gfiINgm 4S3wRYIBH4RMfgm4NbH2KJot/A4djDGTuZaMuL+VpxQmEsW4FwaPBmWrsAmQqw== ARC-Seal: i=1; s=dkim; d=freebsd.org; t=1666855079; a=rsa-sha256; cv=none; b=eMGtNeqYrQot2GprBu3OCuqsXQbqwkotV/fZE4UUcFO55JG9DiufTqtw6+JgMFsrQUVxb2 j27eS3LWDIk2JdUcNF/LB/c8p37wJvJnLkax2Zqn84TzcZxGOXmJn7LOVa+ssZ8xQyuYZ6 FvAGFcDaCMndILf3n19JfD8T4AE9cpfteFM3MVekxsWwSdZfyCahvkxP9w2Es8ta8hq7hi jNLqfABLLy1IgQxt/1/cOnA/R82X/mz5+O7hhq4qzJs5bv7qHFkTwEmFLgM7xv61L8kwsW VxDZ4u8kuEjexUbPvg+POX+ArZxpQB719nHMbTOuf//kKrVJEum1/wxeQ3mX8Q== ARC-Authentication-Results: i=1; mx1.freebsd.org; none X-ThisMailContainsUnwantedMimeParts: N The branch main has been updated by delphij: URL: https://cgit.FreeBSD.org/src/commit/?id=07dfb236c81483c2f08a3976f6d44ce307f4ceaf commit 07dfb236c81483c2f08a3976f6d44ce307f4ceaf Merge: 866beaa0aa95 5d5531f83be2 Author: Xin LI AuthorDate: 2022-10-27 07:12:53 +0000 Commit: Xin LI CommitDate: 2022-10-27 07:12:53 +0000 MFV: Restore the ability to process files from stdin immediately. PR: bin/267221 MFC after: 3 days contrib/file/doc/file.man | 4 ++-- contrib/file/src/file.c | 36 ++++++++++++++++++++++-------------- contrib/file/src/file_opts.h | 2 +- 3 files changed, 25 insertions(+), 17 deletions(-) diff --cc contrib/file/src/file.c index 0efbb92cd520,000000000000..46b4256a0c24 mode 100644,000000..100644 --- a/contrib/file/src/file.c +++ b/contrib/file/src/file.c @@@ -1,846 -1,0 +1,854 @@@ +/* + * Copyright (c) Ian F. Darwin 1986-1995. + * Software written by Ian F. Darwin and others; + * maintained 1995-present by Christos Zoulas and others. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice immediately at the beginning of the file, without modification, + * this list of conditions, and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ +/* + * file - find type of a file or files - main program. + */ + +#include "file.h" + +#ifndef lint +FILE_RCSID("@(#)$File: file.c,v 1.204 2022/09/13 18:46:07 christos Exp $") +#endif /* lint */ + +#include "magic.h" + +#include +#include +#include +#ifdef RESTORE_TIME +# if (__COHERENT__ >= 0x420) +# include +# else +# ifdef USE_UTIMES +# include +# else +# include +# endif +# endif +#endif +#ifdef HAVE_UNISTD_H +#include /* for read() */ +#endif +#ifdef HAVE_WCHAR_H +#include +#endif +#ifdef HAVE_WCTYPE_H +#include +#endif +#if defined(HAVE_WCHAR_H) && defined(HAVE_MBRTOWC) && defined(HAVE_WCWIDTH) && \ + defined(HAVE_WCTYPE_H) +#define FILE_WIDE_SUPPORT +#else +#include +#endif + +#if defined(HAVE_GETOPT_H) && defined(HAVE_STRUCT_OPTION) +# include +# ifndef HAVE_GETOPT_LONG +int getopt_long(int, char * const *, const char *, + const struct option *, int *); +# endif +# else +# include "mygetopt.h" +#endif + +#ifdef S_IFLNK +# define IFLNK_h "h" +# define IFLNK_L "L" +#else +# define IFLNK_h "" +# define IFLNK_L "" +#endif + +#define FILE_FLAGS "bcCdE" IFLNK_h "ik" IFLNK_L "lNnprsSvzZ0" +#define OPTSTRING "bcCde:Ef:F:hiklLm:nNpP:rsSvzZ0" + +# define USAGE \ + "Usage: %s [-" FILE_FLAGS "] [--apple] [--extension] [--mime-encoding]\n" \ + " [--mime-type] [-e ] [-F ] " \ + " [-f ]\n" \ + " [-m ] [-P ] [--exclude-quiet]\n" \ + " ...\n" \ + " %s -C [-m ]\n" \ + " %s [--help]\n" + +private int /* Global command-line options */ + bflag = 0, /* brief output format */ + nopad = 0, /* Don't pad output */ + nobuffer = 0, /* Do not buffer stdout */ + nulsep = 0; /* Append '\0' to the separator */ + +private const char *separator = ":"; /* Default field separator */ +private const struct option long_options[] = { +#define OPT_HELP 1 +#define OPT_APPLE 2 +#define OPT_EXTENSIONS 3 +#define OPT_MIME_TYPE 4 +#define OPT_MIME_ENCODING 5 +#define OPT_EXCLUDE_QUIET 6 +#define OPT(shortname, longname, opt, def, doc) \ + {longname, opt, NULL, shortname}, +#define OPT_LONGONLY(longname, opt, def, doc, id) \ + {longname, opt, NULL, id}, +#include "file_opts.h" +#undef OPT +#undef OPT_LONGONLY + {0, 0, NULL, 0} + }; + +private const struct { + const char *name; + int value; +} nv[] = { + { "apptype", MAGIC_NO_CHECK_APPTYPE }, + { "ascii", MAGIC_NO_CHECK_ASCII }, + { "cdf", MAGIC_NO_CHECK_CDF }, + { "compress", MAGIC_NO_CHECK_COMPRESS }, + { "csv", MAGIC_NO_CHECK_CSV }, + { "elf", MAGIC_NO_CHECK_ELF }, + { "encoding", MAGIC_NO_CHECK_ENCODING }, + { "soft", MAGIC_NO_CHECK_SOFT }, + { "tar", MAGIC_NO_CHECK_TAR }, + { "json", MAGIC_NO_CHECK_JSON }, + { "text", MAGIC_NO_CHECK_TEXT }, /* synonym for ascii */ + { "tokens", MAGIC_NO_CHECK_TOKENS }, /* OBSOLETE: ignored for backwards compatibility */ +}; + +private struct { + const char *name; + size_t value; + size_t def; + const char *desc; + int tag; + int set; +} pm[] = { + { "bytes", 0, FILE_BYTES_MAX, "max bytes to look inside file", + MAGIC_PARAM_BYTES_MAX, 0 }, + { "elf_notes", 0, FILE_ELF_NOTES_MAX, "max ELF notes processed", + MAGIC_PARAM_ELF_NOTES_MAX, 0 }, + { "elf_phnum", 0, FILE_ELF_PHNUM_MAX, "max ELF prog sections processed", + MAGIC_PARAM_ELF_PHNUM_MAX, 0 }, + { "elf_shnum", 0, FILE_ELF_SHNUM_MAX, "max ELF sections processed", + MAGIC_PARAM_ELF_SHNUM_MAX, 0 }, + { "encoding", 0, FILE_ENCODING_MAX, "max bytes to scan for encoding", + MAGIC_PARAM_ENCODING_MAX, 0 }, + { "indir", 0, FILE_INDIR_MAX, "recursion limit for indirection", + MAGIC_PARAM_INDIR_MAX, 0 }, + { "name", 0, FILE_NAME_MAX, "use limit for name/use magic", + MAGIC_PARAM_NAME_MAX, 0 }, + { "regex", 0, FILE_REGEX_MAX, "length limit for REGEX searches", + MAGIC_PARAM_REGEX_MAX, 0 }, +}; + +private int posixly; + +#ifdef __dead +__dead +#endif +private void usage(void); +private void docprint(const char *, int); +#ifdef __dead +__dead +#endif +private void help(void); + +private int unwrap(struct magic_set *, const char *); +private int process(struct magic_set *ms, const char *, int); +private struct magic_set *load(const char *, int); +private void setparam(const char *); +private void applyparam(magic_t); + + +/* + * main - parse arguments and handle options + */ +int +main(int argc, char *argv[]) +{ + int c; + size_t i, j, wid, nw; + int action = 0, didsomefiles = 0, errflg = 0; + int flags = 0, e = 0; +#ifdef HAVE_LIBSECCOMP + int sandbox = 1; +#endif + struct magic_set *magic = NULL; + int longindex; + const char *magicfile = NULL; /* where the magic is */ + char *progname; + + /* makes islower etc work for other langs */ + (void)setlocale(LC_CTYPE, ""); + +#ifdef __EMX__ + /* sh-like wildcard expansion! Shouldn't hurt at least ... */ + _wildcard(&argc, &argv); +#endif + + if ((progname = strrchr(argv[0], '/')) != NULL) + progname++; + else + progname = argv[0]; + + file_setprogname(progname); + + +#ifdef S_IFLNK + posixly = getenv("POSIXLY_CORRECT") != NULL; + flags |= posixly ? MAGIC_SYMLINK : 0; +#endif + while ((c = getopt_long(argc, argv, OPTSTRING, long_options, + &longindex)) != -1) + switch (c) { + case OPT_HELP: + help(); + break; + case OPT_APPLE: + flags |= MAGIC_APPLE; + break; + case OPT_EXTENSIONS: + flags |= MAGIC_EXTENSION; + break; + case OPT_MIME_TYPE: + flags |= MAGIC_MIME_TYPE; + break; + case OPT_MIME_ENCODING: + flags |= MAGIC_MIME_ENCODING; + break; + case '0': + nulsep++; + break; + case 'b': + bflag++; + break; + case 'c': + action = FILE_CHECK; + break; + case 'C': + action = FILE_COMPILE; + break; + case 'd': + flags |= MAGIC_DEBUG|MAGIC_CHECK; + break; + case 'E': + flags |= MAGIC_ERROR; + break; + case 'e': + case OPT_EXCLUDE_QUIET: + for (i = 0; i < __arraycount(nv); i++) + if (strcmp(nv[i].name, optarg) == 0) + break; + + if (i == __arraycount(nv)) { + if (c != OPT_EXCLUDE_QUIET) + errflg++; + } else + flags |= nv[i].value; + break; + + case 'f': + if(action) + usage(); + if (magic == NULL) + if ((magic = load(magicfile, flags)) == NULL) + return 1; + applyparam(magic); + e |= unwrap(magic, optarg); + ++didsomefiles; + break; + case 'F': + separator = optarg; + break; + case 'i': + flags |= MAGIC_MIME; + break; + case 'k': + flags |= MAGIC_CONTINUE; + break; + case 'l': + action = FILE_LIST; + break; + case 'm': + magicfile = optarg; + break; + case 'n': + ++nobuffer; + break; + case 'N': + ++nopad; + break; +#if defined(HAVE_UTIME) || defined(HAVE_UTIMES) + case 'p': + flags |= MAGIC_PRESERVE_ATIME; + break; +#endif + case 'P': + setparam(optarg); + break; + case 'r': + flags |= MAGIC_RAW; + break; + case 's': + flags |= MAGIC_DEVICES; + break; + case 'S': +#ifdef HAVE_LIBSECCOMP + sandbox = 0; +#endif + break; + case 'v': + if (magicfile == NULL) + magicfile = magic_getpath(magicfile, action); + (void)fprintf(stdout, "%s-%s\n", file_getprogname(), + VERSION); + (void)fprintf(stdout, "magic file from %s\n", + magicfile); +#ifdef HAVE_LIBSECCOMP + (void)fprintf(stdout, "seccomp support included\n"); +#endif + return 0; + case 'z': + flags |= MAGIC_COMPRESS; + break; + + case 'Z': + flags |= MAGIC_COMPRESS|MAGIC_COMPRESS_TRANSP; + break; +#ifdef S_IFLNK + case 'L': + flags |= MAGIC_SYMLINK; + break; + case 'h': + flags &= ~MAGIC_SYMLINK; + break; +#endif + case '?': + default: + errflg++; + break; + } + + if (errflg) { + usage(); + } + if (e) + return e; + +#ifdef HAVE_LIBSECCOMP +#if 0 + if (sandbox && enable_sandbox_basic() == -1) +#else + if (sandbox && enable_sandbox_full() == -1) +#endif + file_err(EXIT_FAILURE, "SECCOMP initialisation failed"); +#endif /* HAVE_LIBSECCOMP */ + + if (MAGIC_VERSION != magic_version()) + file_warnx("Compiled magic version [%d] " + "does not match with shared library magic version [%d]\n", + MAGIC_VERSION, magic_version()); + + switch(action) { + case FILE_CHECK: + case FILE_COMPILE: + case FILE_LIST: + /* + * Don't try to check/compile ~/.magic unless we explicitly + * ask for it. + */ + magic = magic_open(flags|MAGIC_CHECK); + if (magic == NULL) { + file_warn("Can't create magic"); + return 1; + } + + + switch(action) { + case FILE_CHECK: + c = magic_check(magic, magicfile); + break; + case FILE_COMPILE: + c = magic_compile(magic, magicfile); + break; + case FILE_LIST: + c = magic_list(magic, magicfile); + break; + default: + abort(); + } + if (c == -1) { + file_warnx("%s", magic_error(magic)); + e = 1; + goto out; + } + goto out; + default: + if (magic == NULL) + if ((magic = load(magicfile, flags)) == NULL) + return 1; + applyparam(magic); + } + + if (optind == argc) { + if (!didsomefiles) + usage(); + goto out; + } + + for (wid = 0, j = CAST(size_t, optind); j < CAST(size_t, argc); + j++) { + nw = file_mbswidth(magic, argv[j]); + if (nw > wid) + wid = nw; + } + + /* + * If bflag is only set twice, set it depending on + * number of files [this is undocumented, and subject to change] + */ + if (bflag == 2) { + bflag = optind >= argc - 1; + } + for (; optind < argc; optind++) + e |= process(magic, argv[optind], wid); + +out: + if (!nobuffer) + e |= fflush(stdout) != 0; + + if (magic) + magic_close(magic); + return e; +} + +private void +applyparam(magic_t magic) +{ + size_t i; + + for (i = 0; i < __arraycount(pm); i++) { + if (!pm[i].set) + continue; + if (magic_setparam(magic, pm[i].tag, &pm[i].value) == -1) + file_err(EXIT_FAILURE, "Can't set %s", pm[i].name); + } +} + +private void +setparam(const char *p) +{ + size_t i; + char *s; + + if ((s = CCAST(char *, strchr(p, '='))) == NULL) + goto badparm; + + for (i = 0; i < __arraycount(pm); i++) { + if (strncmp(p, pm[i].name, s - p) != 0) + continue; + pm[i].value = atoi(s + 1); + pm[i].set = 1; + return; + } +badparm: + file_errx(EXIT_FAILURE, "Unknown param %s", p); +} + +private struct magic_set * +/*ARGSUSED*/ +load(const char *magicfile, int flags) +{ + struct magic_set *magic = magic_open(flags); + const char *e; + + if (magic == NULL) { + file_warn("Can't create magic"); + return NULL; + } + if (magic_load(magic, magicfile) == -1) { + file_warn("%s", magic_error(magic)); + magic_close(magic); + return NULL; + } + if ((e = magic_error(magic)) != NULL) + file_warn("%s", e); + return magic; +} + +/* + * unwrap -- read a file of filenames, do each one. + */ +private int +unwrap(struct magic_set *ms, const char *fn) +{ + FILE *f; + ssize_t len; + char *line = NULL; + size_t llen = 0; + int wid = 0, cwid; + int e = 0; - size_t fi = 0, fimax = 100; - char **flist = CAST(char **, malloc(sizeof(*flist) * fimax)); - - if (flist == NULL) - out: file_err(EXIT_FAILURE, "Cannot allocate memory for file list"); ++ size_t fi = 0, fimax = 0; ++ char **flist = NULL; + + if (strcmp("-", fn) == 0) + f = stdin; + else { + if ((f = fopen(fn, "r")) == NULL) { + file_warn("Cannot open `%s'", fn); + return 1; + } + } + + while ((len = getline(&line, &llen, f)) > 0) { + if (line[len - 1] == '\n') + line[len - 1] = '\0'; ++ cwid = file_mbswidth(ms, line); ++ if (nobuffer) { ++ e |= process(ms, line, cwid); ++ free(line); ++ line = NULL; ++ llen = 0; ++ continue; ++ } ++ if (cwid > wid) ++ wid = cwid; + if (fi >= fimax) { + fimax += 100; + char **nf = CAST(char **, + realloc(flist, fimax * sizeof(*flist))); - if (nf == NULL) - goto out; ++ if (nf == NULL) { ++ file_err(EXIT_FAILURE, ++ "Cannot allocate memory for file list"); ++ } + flist = nf; + } + flist[fi++] = line; - cwid = file_mbswidth(ms, line); - if (cwid > wid) - wid = cwid; + line = NULL; + llen = 0; + } + - fimax = fi; - for (fi = 0; fi < fimax; fi++) { - e |= process(ms, flist[fi], wid); - free(flist[fi]); ++ if (!nobuffer) { ++ fimax = fi; ++ for (fi = 0; fi < fimax; fi++) { ++ e |= process(ms, flist[fi], wid); ++ free(flist[fi]); ++ } + } + free(flist); + + if (f != stdin) + (void)fclose(f); + return e; +} + +private void +file_octal(unsigned char c) +{ + putc('\\', stdout); + putc(((c >> 6) & 7) + '0', stdout); + putc(((c >> 3) & 7) + '0', stdout); + putc(((c >> 0) & 7) + '0', stdout); +} + +private void +fname_print(const char *inname) +{ + size_t n = strlen(inname); +#ifdef FILE_WIDE_SUPPORT + mbstate_t state; + wchar_t nextchar; + size_t bytesconsumed; + + + (void)memset(&state, 0, sizeof(state)); + while (n > 0) { + bytesconsumed = mbrtowc(&nextchar, inname, n, &state); + if (bytesconsumed == CAST(size_t, -1) || + bytesconsumed == CAST(size_t, -2)) { + nextchar = *inname++; + n--; + (void)memset(&state, 0, sizeof(state)); + file_octal(CAST(unsigned char, nextchar)); + continue; + } + inname += bytesconsumed; + n -= bytesconsumed; + if (iswprint(nextchar)) { + printf("%lc", (wint_t)nextchar); + continue; + } + /* XXX: What if it is > 255? */ + file_octal(CAST(unsigned char, nextchar)); + } +#else + size_t i; + for (i = 0; i < n; i++) { + unsigned char c = CAST(unsigned char, inname[i]); + if (isprint(c)) { + putc(c); + continue; + } + file_octal(c); + } +#endif +} + +/* + * Called for each input file on the command line (or in a list of files) + */ +private int +process(struct magic_set *ms, const char *inname, int wid) +{ + const char *type, c = nulsep > 1 ? '\0' : '\n'; + int std_in = strcmp(inname, "-") == 0; + int haderror = 0; + + if (wid > 0 && !bflag) { + const char *pname = std_in ? "/dev/stdin" : inname; + if ((ms->flags & MAGIC_RAW) == 0) + fname_print(pname); + else + (void)printf("%s", pname); + if (nulsep) + (void)putc('\0', stdout); + if (nulsep < 2) { + (void)printf("%s", separator); + (void)printf("%*s ", CAST(int, nopad ? 0 + : (wid - file_mbswidth(ms, inname))), ""); + } + } + + type = magic_file(ms, std_in ? NULL : inname); + + if (type == NULL) { + haderror |= printf("ERROR: %s%c", magic_error(ms), c); + } else { + haderror |= printf("%s%c", type, c) < 0; + } + if (nobuffer) + haderror |= fflush(stdout) != 0; + return haderror || type == NULL; +} + +protected size_t +file_mbswidth(struct magic_set *ms, const char *s) +{ + size_t width = 0; +#ifdef FILE_WIDE_SUPPORT + size_t bytesconsumed, n; + mbstate_t state; + wchar_t nextchar; + + (void)memset(&state, 0, sizeof(state)); + n = strlen(s); + + while (n > 0) { + bytesconsumed = mbrtowc(&nextchar, s, n, &state); + if (bytesconsumed == CAST(size_t, -1) || + bytesconsumed == CAST(size_t, -2)) { + nextchar = *s; + bytesconsumed = 1; + (void)memset(&state, 0, sizeof(state)); + width += 4; + } else { + int w = wcwidth(nextchar); + width += ((ms->flags & MAGIC_RAW) != 0 + || iswprint(nextchar)) ? (w > 0 ? w : 1) : 4; + } + + s += bytesconsumed, n -= bytesconsumed; + } +#else + for (; *s; s++) { + width += (ms->flags & MAGIC_RAW) != 0 + || isprint(CAST(unsigned char, *s)) ? 1 : 4; + } +#endif + return width; +} + +private void +usage(void) +{ + const char *pn = file_getprogname(); + (void)fprintf(stderr, USAGE, pn, pn, pn); + exit(EXIT_FAILURE); +} + +private void +defprint(int def) +{ + if (!def) + return; + if (((def & 1) && posixly) || ((def & 2) && !posixly)) + fprintf(stdout, " (default)"); + fputc('\n', stdout); +} + +private void +docprint(const char *opts, int def) +{ + size_t i; + int comma, pad; + char *sp, *p; + + p = CCAST(char *, strchr(opts, '%')); + if (p == NULL) { + fprintf(stdout, "%s", opts); + defprint(def); + return; + } + + for (sp = p - 1; sp > opts && *sp == ' '; sp--) + continue; + + fprintf(stdout, "%.*s", CAST(int, p - opts), opts); + pad = (int)CAST(int, p - sp - 1); + + switch (*++p) { + case 'e': + comma = 0; + for (i = 0; i < __arraycount(nv); i++) { + fprintf(stdout, "%s%s", comma++ ? ", " : "", nv[i].name); + if (i && i % 5 == 0 && i != __arraycount(nv) - 1) { + fprintf(stdout, ",\n%*s", pad, ""); + comma = 0; + } + } + break; + case 'P': + for (i = 0; i < __arraycount(pm); i++) { + fprintf(stdout, "%9s %7zu %s", pm[i].name, pm[i].def, + pm[i].desc); + if (i != __arraycount(pm) - 1) + fprintf(stdout, "\n%*s", pad, ""); + } + break; + default: + file_errx(EXIT_FAILURE, "Unknown escape `%c' in long options", + *p); + break; + } + fprintf(stdout, "%s", opts + (p - opts) + 1); + +} + +private void +help(void) +{ + (void)fputs( +"Usage: file [OPTION...] [FILE...]\n" +"Determine type of FILEs.\n" +"\n", stdout); +#define OPT(shortname, longname, opt, def, doc) \ + fprintf(stdout, " -%c, --" longname, shortname), \ + docprint(doc, def); +#define OPT_LONGONLY(longname, opt, def, doc, id) \ + fprintf(stdout, " --" longname), \ + docprint(doc, def); +#include "file_opts.h" +#undef OPT +#undef OPT_LONGONLY + fprintf(stdout, "\nReport bugs to https://bugs.astron.com/\n"); + exit(EXIT_SUCCESS); +} + +private const char *file_progname; + +protected void +file_setprogname(const char *progname) +{ + file_progname = progname; +} + +protected const char * +file_getprogname(void) +{ + return file_progname; +} + +protected void +file_err(int e, const char *fmt, ...) +{ + va_list ap; + int se = errno; + + va_start(ap, fmt); + fprintf(stderr, "%s: ", file_progname); + vfprintf(stderr, fmt, ap); + va_end(ap); + if (se) + fprintf(stderr, " (%s)\n", strerror(se)); + else + fputc('\n', stderr); + exit(e); +} + +protected void +file_errx(int e, const char *fmt, ...) +{ + va_list ap; + + va_start(ap, fmt); + fprintf(stderr, "%s: ", file_progname); + vfprintf(stderr, fmt, ap); + va_end(ap); + fprintf(stderr, "\n"); + exit(e); +} + +protected void +file_warn(const char *fmt, ...) +{ + va_list ap; + int se = errno; + + va_start(ap, fmt); + fprintf(stderr, "%s: ", file_progname); + vfprintf(stderr, fmt, ap); + va_end(ap); + if (se) + fprintf(stderr, " (%s)\n", strerror(se)); + else + fputc('\n', stderr); + errno = se; +} + +protected void +file_warnx(const char *fmt, ...) +{ + va_list ap; + int se = errno; + + va_start(ap, fmt); + fprintf(stderr, "%s: ", file_progname); + vfprintf(stderr, fmt, ap); + va_end(ap); + fprintf(stderr, "\n"); + errno = se; +}