Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	sbin/fsck_msdos/../fsck/fsutil.c	Lines:	0	104	0.0 %
Date:	2017-11-07	Branches:	0	44	0.0 %


/*	$OpenBSD: fsutil.c,v 1.22 2015/09/27 05:25:00 guenther Exp $	*/
/*	$NetBSD: fsutil.c,v 1.2 1996/10/03 20:06:31 christos Exp $	*/

/*
 * Copyright (c) 1990, 1993
 *	The Regents of the University of California.  All rights reserved.
 *
 * 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, 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.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
 */

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdarg.h>
#include <errno.h>
#include <fstab.h>
#include <limits.h>
#include <err.h>

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

#include "fsutil.h"

static const char *dev = NULL;
static const char *origdev = NULL;
static int hot = 0;
static int preen = 0;

extern char *__progname;

static void vmsg(int, const char *, va_list);

void
setcdevname(const char *cd, const char *ocd, int pr)
{
	dev = cd;
	origdev = ocd;
	preen = pr;
}

const char *
cdevname(void)
{
	return dev;
}

int
hotroot(void)
{
	return hot;
}

void
errexit(const char *fmt, ...)
{
	va_list ap;

	va_start(ap, fmt);
	(void) vfprintf(stderr, fmt, ap);
	va_end(ap);
	exit(8);
}

static void
vmsg(int fatal, const char *fmt, va_list ap)
{
	if (!fatal && preen) {
		if (origdev)
			printf("%s (%s): ", dev, origdev);
		else
			printf("%s: ", dev);
	}

	(void) vprintf(fmt, ap);

	if (fatal && preen) {
		printf("\n");
		if (origdev)
			printf("%s (%s): ", dev, origdev);
		else
			printf("%s: ", dev);
		printf("UNEXPECTED INCONSISTENCY; RUN %s MANUALLY.\n",
		    __progname);
		exit(8);
	}
}

void
pfatal(const char *fmt, ...)
{
	va_list ap;

	va_start(ap, fmt);
	vmsg(1, fmt, ap);
	va_end(ap);
}

void
pwarn(const char *fmt, ...)
{
	va_list ap;

	va_start(ap, fmt);
	vmsg(0, fmt, ap);
	va_end(ap);
}

void
xperror(const char *s)
{
	pfatal("%s (%s)", s, strerror(errno));
}

void
panic(const char *fmt, ...)
{
	va_list ap;

	va_start(ap, fmt);
	vmsg(1, fmt, ap);
	va_end(ap);
	exit(8);
}

char *
unrawname(char *name)
{
	char *dp;
	struct stat stb;

	if ((dp = strrchr(name, '/')) == NULL)
		return (name);
	if (stat(name, &stb) < 0)
		return (name);
	if (!S_ISCHR(stb.st_mode))
		return (name);
	if (dp[1] != 'r')
		return (name);
	(void)memmove(&dp[1], &dp[2], strlen(&dp[2]) + 1);
	return (name);
}

char *
rawname(char *name)
{
	static char rawbuf[PATH_MAX];
	char *dp;

	if ((dp = strrchr(name, '/')) == NULL)
		return (0);
	*dp = 0;
	(void)strlcpy(rawbuf, name, sizeof rawbuf);
	*dp = '/';
	(void)strlcat(rawbuf, "/r", sizeof rawbuf);
	(void)strlcat(rawbuf, &dp[1], sizeof rawbuf);
	return (rawbuf);
}

char *
blockcheck(char *origname)
{
	struct stat stslash, stblock, stchar;
	char *newname, *raw;
	struct fstab *fsp;
	int retried = 0;

	hot = 0;
	if (stat("/", &stslash) < 0) {
		xperror("/");
		printf("Can't stat root\n");
		return (origname);
	}
	newname = origname;
retry:
	if (stat(newname, &stblock) < 0)
		return (origname);

	if (S_ISBLK(stblock.st_mode)) {
		if (stslash.st_dev == stblock.st_rdev)
			hot++;
		raw = rawname(newname);
		if (stat(raw, &stchar) < 0) {
			xperror(raw);
			printf("Can't stat %s\n", raw);
			return (origname);
		}
		if (S_ISCHR(stchar.st_mode)) {
			return (raw);
		} else {
			printf("%s is not a character device\n", raw);
			return (origname);
		}
	} else if (S_ISCHR(stblock.st_mode) && !retried) {
		newname = unrawname(newname);
		retried++;
		goto retry;
	} else if ((fsp = getfsfile(newname)) != 0 && !retried) {
		newname = fsp->fs_spec;
		retried++;
		goto retry;
	}
	/*
	 * Not a block or character device, just return name and
	 * let the user decide whether to use it.
	 */
	return (origname);
}


void *
emalloc(size_t s)
{
	void *p;

	if (s == 0)
		err(1, "malloc failed");
	p = malloc(s);
	if (p == NULL)
		err(1, "malloc failed");
	return p;
}


void *
ereallocarray(void *p, size_t n, size_t s)
{
	void *newp;

	if (n == 0 || s == 0) {
		free(p);
		err(1, "realloc failed");
	}
	newp = reallocarray(p, n, s);
	if (newp == NULL) {
		free(p);
		err(1, "realloc failed");
	}
	return newp;
}


char *
estrdup(const char *s)
{
	char *p = strdup(s);
	if (p == NULL)
		err(1, "strdup failed");
	return p;
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: fsutil.c,v 1.22 2015/09/27 05:25:00 guenther Exp $ */
2			/* $NetBSD: fsutil.c,v 1.2 1996/10/03 20:06:31 christos Exp $ */
3
4			/*
5			* Copyright (c) 1990, 1993
6			* The Regents of the University of California. All rights reserved.
7			*
8			* Redistribution and use in source and binary forms, with or without
9			* modification, are permitted provided that the following conditions
10			* are met:
11			* 1. Redistributions of source code must retain the above copyright
12			* notice, this list of conditions and the following disclaimer.
13			* 2. Redistributions in binary form must reproduce the above copyright
14			* notice, this list of conditions and the following disclaimer in the
15			* documentation and/or other materials provided with the distribution.
16			* 3. Neither the name of the University nor the names of its contributors
17			* may be used to endorse or promote products derived from this software
18			* without specific prior written permission.
19			*
20			* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
21			* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22			* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23			* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
24			* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25			* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26			* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27			* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28			* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29			* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30			* SUCH DAMAGE.
31			*/
32
33			#include <stdio.h>
34			#include <string.h>
35			#include <stdlib.h>
36			#include <stdarg.h>
37			#include <errno.h>
38			#include <fstab.h>
39			#include <limits.h>
40			#include <err.h>
41
42			#include <sys/types.h>
43			#include <sys/stat.h>
44
45			#include "fsutil.h"
46
47			static const char *dev = NULL;
48			static const char *origdev = NULL;
49			static int hot = 0;
50			static int preen = 0;
51
52			extern char *__progname;
53
54			static void vmsg(int, const char *, va_list);
55
56			void
57			setcdevname(const char cd, const char ocd, int pr)
58			{
59			dev = cd;
60			origdev = ocd;
61			preen = pr;
62			}
63
64			const char *
65			cdevname(void)
66			{
67			return dev;
68			}
69
70			int
71			hotroot(void)
72			{
73			return hot;
74			}
75
76			void
77			errexit(const char *fmt, ...)
78			{
79			va_list ap;
80
81			va_start(ap, fmt);
82			(void) vfprintf(stderr, fmt, ap);
83			va_end(ap);
84			exit(8);
85			}
86
87			static void
88			vmsg(int fatal, const char *fmt, va_list ap)
89			{
90			if (!fatal && preen) {
91			if (origdev)
92			printf("%s (%s): ", dev, origdev);
93			else
94			printf("%s: ", dev);
95			}
96
97			(void) vprintf(fmt, ap);
98
99			if (fatal && preen) {
100			printf("\n");
101			if (origdev)
102			printf("%s (%s): ", dev, origdev);
103			else
104			printf("%s: ", dev);
105			printf("UNEXPECTED INCONSISTENCY; RUN %s MANUALLY.\n",
106			__progname);
107			exit(8);
108			}
109			}
110
111			void
112			pfatal(const char *fmt, ...)
113			{
114			va_list ap;
115
116			va_start(ap, fmt);
117			vmsg(1, fmt, ap);
118			va_end(ap);
119			}
120
121			void
122			pwarn(const char *fmt, ...)
123			{
124			va_list ap;
125
126			va_start(ap, fmt);
127			vmsg(0, fmt, ap);
128			va_end(ap);
129			}
130
131			void
132			xperror(const char *s)
133			{
134			pfatal("%s (%s)", s, strerror(errno));
135			}
136
137			void
138			panic(const char *fmt, ...)
139			{
140			va_list ap;
141
142			va_start(ap, fmt);
143			vmsg(1, fmt, ap);
144			va_end(ap);
145			exit(8);
146			}
147
148			char *
149			unrawname(char *name)
150			{
151			char *dp;
152			struct stat stb;
153
154			if ((dp = strrchr(name, '/')) == NULL)
155			return (name);
156			if (stat(name, &stb) < 0)
157			return (name);
158			if (!S_ISCHR(stb.st_mode))
159			return (name);
160			if (dp[1] != 'r')
161			return (name);
162			(void)memmove(&dp[1], &dp[2], strlen(&dp[2]) + 1);
163			return (name);
164			}
165
166			char *
167			rawname(char *name)
168			{
169			static char rawbuf[PATH_MAX];
170			char *dp;
171
172			if ((dp = strrchr(name, '/')) == NULL)
173			return (0);
174			*dp = 0;
175			(void)strlcpy(rawbuf, name, sizeof rawbuf);
176			*dp = '/';
177			(void)strlcat(rawbuf, "/r", sizeof rawbuf);
178			(void)strlcat(rawbuf, &dp[1], sizeof rawbuf);
179			return (rawbuf);
180			}
181
182			char *
183			blockcheck(char *origname)
184			{
185			struct stat stslash, stblock, stchar;
186			char newname, raw;
187			struct fstab *fsp;
188			int retried = 0;
189
190			hot = 0;
191			if (stat("/", &stslash) < 0) {
192			xperror("/");
193			printf("Can't stat root\n");
194			return (origname);
195			}
196			newname = origname;
197			retry:
198			if (stat(newname, &stblock) < 0)
199			return (origname);
200
201			if (S_ISBLK(stblock.st_mode)) {
202			if (stslash.st_dev == stblock.st_rdev)
203			hot++;
204			raw = rawname(newname);
205			if (stat(raw, &stchar) < 0) {
206			xperror(raw);
207			printf("Can't stat %s\n", raw);
208			return (origname);
209			}
210			if (S_ISCHR(stchar.st_mode)) {
211			return (raw);
212			} else {
213			printf("%s is not a character device\n", raw);
214			return (origname);
215			}
216			} else if (S_ISCHR(stblock.st_mode) && !retried) {
217			newname = unrawname(newname);
218			retried++;
219			goto retry;
220			} else if ((fsp = getfsfile(newname)) != 0 && !retried) {
221			newname = fsp->fs_spec;
222			retried++;
223			goto retry;
224			}
225			/*
226			* Not a block or character device, just return name and
227			* let the user decide whether to use it.
228			*/
229			return (origname);
230			}
231
232
233			void *
234			emalloc(size_t s)
235			{
236			void *p;
237
238			if (s == 0)
239			err(1, "malloc failed");
240			p = malloc(s);
241			if (p == NULL)
242			err(1, "malloc failed");
243			return p;
244			}
245
246
247			void *
248			ereallocarray(void *p, size_t n, size_t s)
249			{
250			void *newp;
251
252			if (n == 0 \|\| s == 0) {
253			free(p);
254			err(1, "realloc failed");
255			}
256			newp = reallocarray(p, n, s);
257			if (newp == NULL) {
258			free(p);
259			err(1, "realloc failed");
260			}
261			return newp;
262			}
263
264
265			char *
266			estrdup(const char *s)
267			{
268			char *p = strdup(s);
269			if (p == NULL)
270			err(1, "strdup failed");
271			return p;
272			}