Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.bin/file/file.c	Lines:	0	267	0.0 %
Date:	2017-11-07	Branches:	0	212	0.0 %


/* $OpenBSD: file.c,v 1.64 2017/07/01 21:07:13 brynet Exp $ */

/*
 * Copyright (c) 2015 Nicholas Marriott <nicm@openbsd.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
 * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/types.h>
#include <sys/mman.h>
#include <sys/stat.h>

#include <err.h>
#include <errno.h>
#include <fcntl.h>
#include <getopt.h>
#include <libgen.h>
#include <limits.h>
#include <pwd.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>

#include "file.h"
#include "magic.h"
#include "xmalloc.h"

struct input_file {
	struct magic	*m;

	const char	*path;
	struct stat	 sb;
	int		 fd;
	int		 error;

	char		 link_path[PATH_MAX];
	int		 link_error;
	int		 link_target;

	void		*base;
	size_t		 size;
	int		 mapped;
	char		*result;
};

extern char	*__progname;

__dead void	 usage(void);

static void	 prepare_input(struct input_file *, const char *);

static void	 read_link(struct input_file *, const char *);

static void	 test_file(struct input_file *, size_t);

static int	 try_stat(struct input_file *);
static int	 try_empty(struct input_file *);
static int	 try_access(struct input_file *);
static int	 try_text(struct input_file *);
static int	 try_magic(struct input_file *);
static int	 try_unknown(struct input_file *);

static int	 bflag;
static int	 cflag;
static int	 iflag;
static int	 Lflag;
static int	 sflag;
static int	 Wflag;

static struct option longopts[] = {
	{ "brief",       no_argument, NULL, 'b' },
	{ "dereference", no_argument, NULL, 'L' },
	{ "mime",        no_argument, NULL, 'i' },
	{ "mime-type",   no_argument, NULL, 'i' },
	{ NULL,          0,           NULL, 0   }
};

__dead void
usage(void)
{
	fprintf(stderr, "usage: %s [-bchiLsW] file ...\n", __progname);
	exit(1);
}

int
main(int argc, char **argv)
{
	int			 opt, idx;
	char			*home, *magicpath;
	struct passwd		*pw;
	FILE			*magicfp = NULL;
	struct magic		*m;
	struct input_file	*inf = NULL;
	size_t			 len, width = 0;

	if (pledge("stdio rpath getpw id flock cpath wpath", NULL) == -1)
		err(1, "pledge");

	for (;;) {
		opt = getopt_long(argc, argv, "bchiLsW", longopts, NULL);
		if (opt == -1)
			break;
		switch (opt) {
		case 'b':
			bflag = 1;
			break;
		case 'c':
			cflag = 1;
			break;
		case 'h':
			Lflag = 0;
			break;
		case 'i':
			iflag = 1;
			break;
		case 'L':
			Lflag = 1;
			break;
		case 's':
			sflag = 1;
			break;
		case 'W':
			Wflag = 1;
			break;
		default:
			usage();
		}
	}
	argc -= optind;
	argv += optind;
	if (cflag) {
		if (argc != 0)
			usage();
	} else if (argc == 0)
		usage();

	if (geteuid() != 0 && !issetugid()) {
		home = getenv("HOME");
		if (home == NULL || *home == '\0') {
			pw = getpwuid(getuid());
			if (pw != NULL)
				home = pw->pw_dir;
			else
				home = NULL;
		}
		if (home != NULL) {
			xasprintf(&magicpath, "%s/.magic", home);
			magicfp = fopen(magicpath, "r");
			if (magicfp == NULL)
				free(magicpath);
		}
	}
	if (magicfp == NULL) {
		magicpath = xstrdup("/etc/magic");
		magicfp = fopen(magicpath, "r");
	}
	if (magicfp == NULL)
		err(1, "%s", magicpath);

	if (!cflag) {
		inf = xcalloc(argc, sizeof *inf);
		for (idx = 0; idx < argc; idx++) {
			len = strlen(argv[idx]) + 1;
			if (len > width)
				width = len;
			prepare_input(&inf[idx], argv[idx]);
		}
	}

	tzset();

	if (pledge("stdio getpw id flock rpath cpath wpath", NULL) == -1)
		err(1, "pledge");

	if (geteuid() == 0) {
		pw = getpwnam(FILE_USER);
		if (pw == NULL)
			errx(1, "unknown user %s", FILE_USER);
		if (setgroups(1, &pw->pw_gid) != 0)
			err(1, "setgroups");
		if (setresgid(pw->pw_gid, pw->pw_gid, pw->pw_gid) != 0)
			err(1, "setresgid");
		if (setresuid(pw->pw_uid, pw->pw_uid, pw->pw_uid) != 0)
			err(1, "setresuid");
	}

	if (pledge("stdio flock rpath cpath wpath", NULL) == -1)
		err(1, "pledge");

	m = magic_load(magicfp, magicpath, cflag || Wflag);
	if (cflag) {
		magic_dump(m);
		exit(0);
	}
	fclose(magicfp);

	for (idx = 0; idx < argc; idx++) {
		inf[idx].m = m;
		test_file(&inf[idx], width);
		if (inf[idx].fd != -1 && inf[idx].fd != STDIN_FILENO)
			close(inf[idx].fd);
	}
	exit(0);
}

static void
prepare_input(struct input_file *inf, const char *path)
{
	int	fd, mode, error;

	inf->path = path;

	if (strcmp(path, "-") == 0) {
		if (fstat(STDIN_FILENO, &inf->sb) == -1) {
			inf->error = errno;
			inf->fd = -1;
			return;
		}
		inf->fd = STDIN_FILENO;
		return;
	}

	if (Lflag)
		error = stat(path, &inf->sb);
	else
		error = lstat(path, &inf->sb);
	if (error == -1) {
		inf->error = errno;
		inf->fd = -1;
		return;
	}

	/* We don't need them, so don't open directories or symlinks. */
	mode = inf->sb.st_mode;
	if (!S_ISDIR(mode) && !S_ISLNK(mode)) {
		fd = open(path, O_RDONLY|O_NONBLOCK);
		if (fd == -1 && (errno == ENFILE || errno == EMFILE))
			err(1, "open");
	} else
		fd = -1;
	if (S_ISLNK(mode))
		read_link(inf, path);
	inf->fd = fd;
}

static void
read_link(struct input_file *inf, const char *path)
{
	struct stat	 sb;
	char		 lpath[PATH_MAX];
	char		*copy, *root;
	int		 used;
	ssize_t		 size;

	size = readlink(path, lpath, sizeof lpath - 1);
	if (size == -1) {
		inf->link_error = errno;
		return;
	}
	lpath[size] = '\0';

	if (*lpath == '/')
		strlcpy(inf->link_path, lpath, sizeof inf->link_path);
	else {
		copy = xstrdup(path);

		root = dirname(copy);
		if (*root == '\0' || strcmp(root, ".") == 0 ||
		    strcmp (root, "/") == 0)
			strlcpy(inf->link_path, lpath, sizeof inf->link_path);
		else {
			used = snprintf(inf->link_path, sizeof inf->link_path,
			    "%s/%s", root, lpath);
			if (used < 0 || (size_t)used >= sizeof inf->link_path) {
				inf->link_error = ENAMETOOLONG;
				free(copy);
				return;
			}
		}

		free(copy);
	}

	if (!Lflag && stat(path, &sb) == -1)
		inf->link_target = errno;
}

static void *
fill_buffer(int fd, size_t size, size_t *used)
{
	static void	*buffer;
	ssize_t		 got;
	size_t		 left;
	void		*next;

	if (buffer == NULL)
		buffer = xmalloc(FILE_READ_SIZE);

	next = buffer;
	left = size;
	while (left != 0) {
		got = read(fd, next, left);
		if (got == -1) {
			if (errno == EINTR)
				continue;
			return (NULL);
		}
		if (got == 0)
			break;
		next = (char *)next + got;
		left -= got;
	}
	*used = size - left;
	return (buffer);
}

static int
load_file(struct input_file *inf)
{
	size_t	used;

	if (inf->sb.st_size == 0 && S_ISREG(inf->sb.st_mode))
		return (0); /* empty file */
	if (inf->sb.st_size == 0 || inf->sb.st_size > FILE_READ_SIZE)
		inf->size = FILE_READ_SIZE;
	else
		inf->size = inf->sb.st_size;

	if (!S_ISREG(inf->sb.st_mode))
		goto try_read;

	inf->base = mmap(NULL, inf->size, PROT_READ, MAP_PRIVATE, inf->fd, 0);
	if (inf->base == MAP_FAILED)
		goto try_read;
	inf->mapped = 1;
	return (0);

try_read:
	inf->base = fill_buffer(inf->fd, inf->size, &used);
	if (inf->base == NULL) {
		xasprintf(&inf->result, "cannot read '%s' (%s)", inf->path,
		    strerror(errno));
		return (1);
	}
	inf->size = used;
	return (0);
}

static int
try_stat(struct input_file *inf)
{
	if (inf->error != 0) {
		xasprintf(&inf->result, "cannot stat '%s' (%s)", inf->path,
		    strerror(inf->error));
		return (1);
	}
	if (sflag || strcmp(inf->path, "-") == 0) {
		switch (inf->sb.st_mode & S_IFMT) {
		case S_IFIFO:
			if (strcmp(inf->path, "-") != 0)
				break;
		case S_IFBLK:
		case S_IFCHR:
		case S_IFREG:
			return (0);
		}
	}

	if (iflag && (inf->sb.st_mode & S_IFMT) != S_IFREG) {
		xasprintf(&inf->result, "application/x-not-regular-file");
		return (1);
	}

	switch (inf->sb.st_mode & S_IFMT) {
	case S_IFDIR:
		xasprintf(&inf->result, "directory");
		return (1);
	case S_IFLNK:
		if (inf->link_error != 0) {
			xasprintf(&inf->result, "unreadable symlink '%s' (%s)",
			    inf->path, strerror(inf->link_error));
			return (1);
		}
		if (inf->link_target == ELOOP)
			xasprintf(&inf->result, "symbolic link in a loop");
		else if (inf->link_target != 0) {
			xasprintf(&inf->result, "broken symbolic link to '%s'",
			    inf->link_path);
		} else {
			xasprintf(&inf->result, "symbolic link to '%s'",
			    inf->link_path);
		}
		return (1);
	case S_IFSOCK:
		xasprintf(&inf->result, "socket");
		return (1);
	case S_IFBLK:
		xasprintf(&inf->result, "block special (%ld/%ld)",
		    (long)major(inf->sb.st_rdev),
		    (long)minor(inf->sb.st_rdev));
		return (1);
	case S_IFCHR:
		xasprintf(&inf->result, "character special (%ld/%ld)",
		    (long)major(inf->sb.st_rdev),
		    (long)minor(inf->sb.st_rdev));
		return (1);
	case S_IFIFO:
		xasprintf(&inf->result, "fifo (named pipe)");
		return (1);
	}
	return (0);
}

static int
try_empty(struct input_file *inf)
{
	if (inf->size != 0)
		return (0);

	if (iflag)
		xasprintf(&inf->result, "application/x-empty");
	else
		xasprintf(&inf->result, "empty");
	return (1);
}

static int
try_access(struct input_file *inf)
{
	char tmp[256] = "";

	if (inf->sb.st_size == 0 && S_ISREG(inf->sb.st_mode))
		return (0); /* empty file */
	if (inf->fd != -1)
		return (0);

	if (inf->sb.st_mode & (S_IWUSR|S_IWGRP|S_IWOTH))
		strlcat(tmp, "writable, ", sizeof tmp);
	if (inf->sb.st_mode & (S_IXUSR|S_IXGRP|S_IXOTH))
		strlcat(tmp, "executable, ", sizeof tmp);
	if (S_ISREG(inf->sb.st_mode))
		strlcat(tmp, "regular file, ", sizeof tmp);
	strlcat(tmp, "no read permission", sizeof tmp);

	inf->result = xstrdup(tmp);
	return (1);
}

static int
try_text(struct input_file *inf)
{
	const char	*type, *s;
	int		 flags;

	flags = MAGIC_TEST_TEXT;
	if (iflag)
		flags |= MAGIC_TEST_MIME;

	type = text_get_type(inf->base, inf->size);
	if (type == NULL)
		return (0);

	s = magic_test(inf->m, inf->base, inf->size, flags);
	if (s != NULL) {
		inf->result = xstrdup(s);
		return (1);
	}

	s = text_try_words(inf->base, inf->size, flags);
	if (s != NULL) {
		if (iflag)
			inf->result = xstrdup(s);
		else
			xasprintf(&inf->result, "%s %s text", type, s);
		return (1);
	}

	if (iflag)
		inf->result = xstrdup("text/plain");
	else
		xasprintf(&inf->result, "%s text", type);
	return (1);
}

static int
try_magic(struct input_file *inf)
{
	const char	*s;
	int		 flags;

	flags = 0;
	if (iflag)
		flags |= MAGIC_TEST_MIME;

	s = magic_test(inf->m, inf->base, inf->size, flags);
	if (s != NULL) {
		inf->result = xstrdup(s);
		return (1);
	}
	return (0);
}

static int
try_unknown(struct input_file *inf)
{
	if (iflag)
		xasprintf(&inf->result, "application/x-not-regular-file");
	else
		xasprintf(&inf->result, "data");
	return (1);
}

static void
test_file(struct input_file *inf, size_t width)
{
	char	*label;
	int	 stop;

	stop = 0;
	if (!stop)
		stop = try_stat(inf);
	if (!stop)
		stop = try_access(inf);
	if (!stop)
		stop = load_file(inf);
	if (!stop)
		stop = try_empty(inf);
	if (!stop)
		stop = try_magic(inf);
	if (!stop)
		stop = try_text(inf);
	if (!stop)
		stop = try_unknown(inf);

	if (bflag)
		printf("%s\n", inf->result);
	else {
		if (strcmp(inf->path, "-") == 0)
			xasprintf(&label, "/dev/stdin:");
		else
			xasprintf(&label, "%s:", inf->path);
		printf("%-*s %s\n", (int)width, label, inf->result);
		free(label);
	}
	free(inf->result);

	if (inf->mapped && inf->base != NULL)
		munmap(inf->base, inf->size);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: file.c,v 1.64 2017/07/01 21:07:13 brynet Exp $ */
2
3			/*
4			* Copyright (c) 2015 Nicholas Marriott <nicm@openbsd.org>
5			*
6			* Permission to use, copy, modify, and distribute this software for any
7			* purpose with or without fee is hereby granted, provided that the above
8			* copyright notice and this permission notice appear in all copies.
9			*
10			* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11			* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12			* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13			* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14			* WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
15			* IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
16			* OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17			*/
18
19			#include <sys/types.h>
20			#include <sys/mman.h>
21			#include <sys/stat.h>
22
23			#include <err.h>
24			#include <errno.h>
25			#include <fcntl.h>
26			#include <getopt.h>
27			#include <libgen.h>
28			#include <limits.h>
29			#include <pwd.h>
30			#include <stdlib.h>
31			#include <string.h>
32			#include <time.h>
33			#include <unistd.h>
34
35			#include "file.h"
36			#include "magic.h"
37			#include "xmalloc.h"
38
39			struct input_file {
40			struct magic *m;
41
42			const char *path;
43			struct stat sb;
44			int fd;
45			int error;
46
47			char link_path[PATH_MAX];
48			int link_error;
49			int link_target;
50
51			void *base;
52			size_t size;
53			int mapped;
54			char *result;
55			};
56
57			extern char *__progname;
58
59			__dead void usage(void);
60
61			static void prepare_input(struct input_file , const char );
62
63			static void read_link(struct input_file , const char );
64
65			static void test_file(struct input_file *, size_t);
66
67			static int try_stat(struct input_file *);
68			static int try_empty(struct input_file *);
69			static int try_access(struct input_file *);
70			static int try_text(struct input_file *);
71			static int try_magic(struct input_file *);
72			static int try_unknown(struct input_file *);
73
74			static int bflag;
75			static int cflag;
76			static int iflag;
77			static int Lflag;
78			static int sflag;
79			static int Wflag;
80
81			static struct option longopts[] = {
82			{ "brief", no_argument, NULL, 'b' },
83			{ "dereference", no_argument, NULL, 'L' },
84			{ "mime", no_argument, NULL, 'i' },
85			{ "mime-type", no_argument, NULL, 'i' },
86			{ NULL, 0, NULL, 0 }
87			};
88
89			__dead void
90			usage(void)
91			{
92			fprintf(stderr, "usage: %s [-bchiLsW] file ...\n", __progname);
93			exit(1);
94			}
95
96			int
97			main(int argc, char **argv)
98			{
99			int opt, idx;
100			char home, magicpath;
101			struct passwd *pw;
102			FILE *magicfp = NULL;
103			struct magic *m;
104			struct input_file *inf = NULL;
105			size_t len, width = 0;
106
107			if (pledge("stdio rpath getpw id flock cpath wpath", NULL) == -1)
108			err(1, "pledge");
109
110			for (;;) {
111			opt = getopt_long(argc, argv, "bchiLsW", longopts, NULL);
112			if (opt == -1)
113			break;
114			switch (opt) {
115			case 'b':
116			bflag = 1;
117			break;
118			case 'c':
119			cflag = 1;
120			break;
121			case 'h':
122			Lflag = 0;
123			break;
124			case 'i':
125			iflag = 1;
126			break;
127			case 'L':
128			Lflag = 1;
129			break;
130			case 's':
131			sflag = 1;
132			break;
133			case 'W':
134			Wflag = 1;
135			break;
136			default:
137			usage();
138			}
139			}
140			argc -= optind;
141			argv += optind;
142			if (cflag) {
143			if (argc != 0)
144			usage();
145			} else if (argc == 0)
146			usage();
147
148			if (geteuid() != 0 && !issetugid()) {
149			home = getenv("HOME");
150			if (home == NULL \|\| *home == '\0') {
151			pw = getpwuid(getuid());
152			if (pw != NULL)
153			home = pw->pw_dir;
154			else
155			home = NULL;
156			}
157			if (home != NULL) {
158			xasprintf(&magicpath, "%s/.magic", home);
159			magicfp = fopen(magicpath, "r");
160			if (magicfp == NULL)
161			free(magicpath);
162			}
163			}
164			if (magicfp == NULL) {
165			magicpath = xstrdup("/etc/magic");
166			magicfp = fopen(magicpath, "r");
167			}
168			if (magicfp == NULL)
169			err(1, "%s", magicpath);
170
171			if (!cflag) {
172			inf = xcalloc(argc, sizeof *inf);
173			for (idx = 0; idx < argc; idx++) {
174			len = strlen(argv[idx]) + 1;
175			if (len > width)
176			width = len;
177			prepare_input(&inf[idx], argv[idx]);
178			}
179			}
180
181			tzset();
182
183			if (pledge("stdio getpw id flock rpath cpath wpath", NULL) == -1)
184			err(1, "pledge");
185
186			if (geteuid() == 0) {
187			pw = getpwnam(FILE_USER);
188			if (pw == NULL)
189			errx(1, "unknown user %s", FILE_USER);
190			if (setgroups(1, &pw->pw_gid) != 0)
191			err(1, "setgroups");
192			if (setresgid(pw->pw_gid, pw->pw_gid, pw->pw_gid) != 0)
193			err(1, "setresgid");
194			if (setresuid(pw->pw_uid, pw->pw_uid, pw->pw_uid) != 0)
195			err(1, "setresuid");
196			}
197
198			if (pledge("stdio flock rpath cpath wpath", NULL) == -1)
199			err(1, "pledge");
200
201			m = magic_load(magicfp, magicpath, cflag \|\| Wflag);
202			if (cflag) {
203			magic_dump(m);
204			exit(0);
205			}
206			fclose(magicfp);
207
208			for (idx = 0; idx < argc; idx++) {
209			inf[idx].m = m;
210			test_file(&inf[idx], width);
211			if (inf[idx].fd != -1 && inf[idx].fd != STDIN_FILENO)
212			close(inf[idx].fd);
213			}
214			exit(0);
215			}
216
217			static void
218			prepare_input(struct input_file inf, const char path)
219			{
220			int fd, mode, error;
221
222			inf->path = path;
223
224			if (strcmp(path, "-") == 0) {
225			if (fstat(STDIN_FILENO, &inf->sb) == -1) {
226			inf->error = errno;
227			inf->fd = -1;
228			return;
229			}
230			inf->fd = STDIN_FILENO;
231			return;
232			}
233
234			if (Lflag)
235			error = stat(path, &inf->sb);
236			else
237			error = lstat(path, &inf->sb);
238			if (error == -1) {
239			inf->error = errno;
240			inf->fd = -1;
241			return;
242			}
243
244			/* We don't need them, so don't open directories or symlinks. */
245			mode = inf->sb.st_mode;
246			if (!S_ISDIR(mode) && !S_ISLNK(mode)) {
247			fd = open(path, O_RDONLY\|O_NONBLOCK);
248			if (fd == -1 && (errno == ENFILE \|\| errno == EMFILE))
249			err(1, "open");
250			} else
251			fd = -1;
252			if (S_ISLNK(mode))
253			read_link(inf, path);
254			inf->fd = fd;
255			}
256
257			static void
258			read_link(struct input_file inf, const char path)
259			{
260			struct stat sb;
261			char lpath[PATH_MAX];
262			char copy, root;
263			int used;
264			ssize_t size;
265
266			size = readlink(path, lpath, sizeof lpath - 1);
267			if (size == -1) {
268			inf->link_error = errno;
269			return;
270			}
271			lpath[size] = '\0';
272
273			if (*lpath == '/')
274			strlcpy(inf->link_path, lpath, sizeof inf->link_path);
275			else {
276			copy = xstrdup(path);
277
278			root = dirname(copy);
279			if (*root == '\0' \|\| strcmp(root, ".") == 0 \|\|
280			strcmp (root, "/") == 0)
281			strlcpy(inf->link_path, lpath, sizeof inf->link_path);
282			else {
283			used = snprintf(inf->link_path, sizeof inf->link_path,
284			"%s/%s", root, lpath);
285			if (used < 0 \|\| (size_t)used >= sizeof inf->link_path) {
286			inf->link_error = ENAMETOOLONG;
287			free(copy);
288			return;
289			}
290			}
291
292			free(copy);
293			}
294
295			if (!Lflag && stat(path, &sb) == -1)
296			inf->link_target = errno;
297			}
298
299			static void *
300			fill_buffer(int fd, size_t size, size_t *used)
301			{
302			static void *buffer;
303			ssize_t got;
304			size_t left;
305			void *next;
306
307			if (buffer == NULL)
308			buffer = xmalloc(FILE_READ_SIZE);
309
310			next = buffer;
311			left = size;
312			while (left != 0) {
313			got = read(fd, next, left);
314			if (got == -1) {
315			if (errno == EINTR)
316			continue;
317			return (NULL);
318			}
319			if (got == 0)
320			break;
321			next = (char *)next + got;
322			left -= got;
323			}
324			*used = size - left;
325			return (buffer);
326			}
327
328			static int
329			load_file(struct input_file *inf)
330			{
331			size_t used;
332
333			if (inf->sb.st_size == 0 && S_ISREG(inf->sb.st_mode))
334			return (0); /* empty file */
335			if (inf->sb.st_size == 0 \|\| inf->sb.st_size > FILE_READ_SIZE)
336			inf->size = FILE_READ_SIZE;
337			else
338			inf->size = inf->sb.st_size;
339
340			if (!S_ISREG(inf->sb.st_mode))
341			goto try_read;
342
343			inf->base = mmap(NULL, inf->size, PROT_READ, MAP_PRIVATE, inf->fd, 0);
344			if (inf->base == MAP_FAILED)
345			goto try_read;
346			inf->mapped = 1;
347			return (0);
348
349			try_read:
350			inf->base = fill_buffer(inf->fd, inf->size, &used);
351			if (inf->base == NULL) {
352			xasprintf(&inf->result, "cannot read '%s' (%s)", inf->path,
353			strerror(errno));
354			return (1);
355			}
356			inf->size = used;
357			return (0);
358			}
359
360			static int
361			try_stat(struct input_file *inf)
362			{
363			if (inf->error != 0) {
364			xasprintf(&inf->result, "cannot stat '%s' (%s)", inf->path,
365			strerror(inf->error));
366			return (1);
367			}
368			if (sflag \|\| strcmp(inf->path, "-") == 0) {
369			switch (inf->sb.st_mode & S_IFMT) {
370			case S_IFIFO:
371			if (strcmp(inf->path, "-") != 0)
372			break;
373			case S_IFBLK:
374			case S_IFCHR:
375			case S_IFREG:
376			return (0);
377			}
378			}
379
380			if (iflag && (inf->sb.st_mode & S_IFMT) != S_IFREG) {
381			xasprintf(&inf->result, "application/x-not-regular-file");
382			return (1);
383			}
384
385			switch (inf->sb.st_mode & S_IFMT) {
386			case S_IFDIR:
387			xasprintf(&inf->result, "directory");
388			return (1);
389			case S_IFLNK:
390			if (inf->link_error != 0) {
391			xasprintf(&inf->result, "unreadable symlink '%s' (%s)",
392			inf->path, strerror(inf->link_error));
393			return (1);
394			}
395			if (inf->link_target == ELOOP)
396			xasprintf(&inf->result, "symbolic link in a loop");
397			else if (inf->link_target != 0) {
398			xasprintf(&inf->result, "broken symbolic link to '%s'",
399			inf->link_path);
400			} else {
401			xasprintf(&inf->result, "symbolic link to '%s'",
402			inf->link_path);
403			}
404			return (1);
405			case S_IFSOCK:
406			xasprintf(&inf->result, "socket");
407			return (1);
408			case S_IFBLK:
409			xasprintf(&inf->result, "block special (%ld/%ld)",
410			(long)major(inf->sb.st_rdev),
411			(long)minor(inf->sb.st_rdev));
412			return (1);
413			case S_IFCHR:
414			xasprintf(&inf->result, "character special (%ld/%ld)",
415			(long)major(inf->sb.st_rdev),
416			(long)minor(inf->sb.st_rdev));
417			return (1);
418			case S_IFIFO:
419			xasprintf(&inf->result, "fifo (named pipe)");
420			return (1);
421			}
422			return (0);
423			}
424
425			static int
426			try_empty(struct input_file *inf)
427			{
428			if (inf->size != 0)
429			return (0);
430
431			if (iflag)
432			xasprintf(&inf->result, "application/x-empty");
433			else
434			xasprintf(&inf->result, "empty");
435			return (1);
436			}
437
438			static int
439			try_access(struct input_file *inf)
440			{
441			char tmp[256] = "";
442
443			if (inf->sb.st_size == 0 && S_ISREG(inf->sb.st_mode))
444			return (0); /* empty file */
445			if (inf->fd != -1)
446			return (0);
447
448			if (inf->sb.st_mode & (S_IWUSR\|S_IWGRP\|S_IWOTH))
449			strlcat(tmp, "writable, ", sizeof tmp);
450			if (inf->sb.st_mode & (S_IXUSR\|S_IXGRP\|S_IXOTH))
451			strlcat(tmp, "executable, ", sizeof tmp);
452			if (S_ISREG(inf->sb.st_mode))
453			strlcat(tmp, "regular file, ", sizeof tmp);
454			strlcat(tmp, "no read permission", sizeof tmp);
455
456			inf->result = xstrdup(tmp);
457			return (1);
458			}
459
460			static int
461			try_text(struct input_file *inf)
462			{
463			const char type, s;
464			int flags;
465
466			flags = MAGIC_TEST_TEXT;
467			if (iflag)
468			flags \|= MAGIC_TEST_MIME;
469
470			type = text_get_type(inf->base, inf->size);
471			if (type == NULL)
472			return (0);
473
474			s = magic_test(inf->m, inf->base, inf->size, flags);
475			if (s != NULL) {
476			inf->result = xstrdup(s);
477			return (1);
478			}
479
480			s = text_try_words(inf->base, inf->size, flags);
481			if (s != NULL) {
482			if (iflag)
483			inf->result = xstrdup(s);
484			else
485			xasprintf(&inf->result, "%s %s text", type, s);
486			return (1);
487			}
488
489			if (iflag)
490			inf->result = xstrdup("text/plain");
491			else
492			xasprintf(&inf->result, "%s text", type);
493			return (1);
494			}
495
496			static int
497			try_magic(struct input_file *inf)
498			{
499			const char *s;
500			int flags;
501
502			flags = 0;
503			if (iflag)
504			flags \|= MAGIC_TEST_MIME;
505
506			s = magic_test(inf->m, inf->base, inf->size, flags);
507			if (s != NULL) {
508			inf->result = xstrdup(s);
509			return (1);
510			}
511			return (0);
512			}
513
514			static int
515			try_unknown(struct input_file *inf)
516			{
517			if (iflag)
518			xasprintf(&inf->result, "application/x-not-regular-file");
519			else
520			xasprintf(&inf->result, "data");
521			return (1);
522			}
523
524			static void
525			test_file(struct input_file *inf, size_t width)
526			{
527			char *label;
528			int stop;
529
530			stop = 0;
531			if (!stop)
532			stop = try_stat(inf);
533			if (!stop)
534			stop = try_access(inf);
535			if (!stop)
536			stop = load_file(inf);
537			if (!stop)
538			stop = try_empty(inf);
539			if (!stop)
540			stop = try_magic(inf);
541			if (!stop)
542			stop = try_text(inf);
543			if (!stop)
544			stop = try_unknown(inf);
545
546			if (bflag)
547			printf("%s\n", inf->result);
548			else {
549			if (strcmp(inf->path, "-") == 0)
550			xasprintf(&label, "/dev/stdin:");
551			else
552			xasprintf(&label, "%s:", inf->path);
553			printf("%-*s %s\n", (int)width, label, inf->result);
554			free(label);
555			}
556			free(inf->result);
557
558			if (inf->mapped && inf->base != NULL)
559			munmap(inf->base, inf->size);
560			}