Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.sbin/amd/amd/util.c	Lines:	0	191	0.0 %
Date:	2017-11-07	Branches:	0	154	0.0 %


/*
 * Copyright (c) 1990 Jan-Simon Pendry
 * Copyright (c) 1990 Imperial College of Science, Technology & Medicine
 * Copyright (c) 1990, 1993
 *	The Regents of the University of California.  All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * Jan-Simon Pendry at Imperial College, London.
 *
 * 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.
 *
 *	from: @(#)util.c	8.1 (Berkeley) 6/6/93
 *	$Id: util.c,v 1.16 2015/12/12 20:06:42 mmcc Exp $
 */

/*
 * Utils
 */

#include "am.h"
#include <ctype.h>
#include <unistd.h>
#include <sys/stat.h>
#include <netdb.h>


char *
strnsave(const char *str, int len)
{
	char *sp = xmalloc(len+1);

	bcopy(str, sp, len);
	sp[len] = 0;

	return sp;
}

/*
 * Concatenate three strings and store in buffer pointed to
 * by p, making p large enough to hold the strings
 */
char *
str3cat(char *p, char *s1, char *s2, char *s3)
{
	size_t l1 = strlen(s1);
	size_t l2 = strlen(s2);
	size_t l3 = strlen(s3);

	if (l1 > SIZE_MAX - l2 || l1 + l2 > SIZE_MAX - l3)
		 xmallocfailure();
	p = xreallocarray(p, l1 + l2 + l3 + 1, 1);
	bcopy(s1, p, l1);
	bcopy(s2, p + l1, l2);
	bcopy(s3, p + l1 + l2, l3 + 1);
	return p;
}

char *
strealloc(char *p, char *s)
{
	size_t len = strlen(s) + 1;

	if (len > SIZE_MAX - 1)
		 xmallocfailure();
	p = xreallocarray(p, len, 1);

	strlcpy(p, s, len);
	return p;
}

char **
strsplit(char *s, int ch, int qc)
{
	char **ivec;
	int ic = 0;
	int done = 0;

	ivec = xreallocarray(NULL, ic + 1, sizeof *ivec);

	while (!done) {
		char *v;
		/*
		 * skip to split char
		 */
		while (*s && (ch == ' ' ?
		    (isascii((unsigned char)*s) && isspace((unsigned char)*s)) :
		    *s == ch))
				*s++ = '\0';

		/*
		 * End of string?
		 */
		if (!*s)
			break;

		/*
		 * remember start of string
		 */
		v = s;

		/*
		 * skip to split char
		 */
		while (*s && !(ch == ' ' ?
		    (isascii((unsigned char)*s) && isspace((unsigned char)*s)) :
		    *s == ch)) {
			if (*s++ == qc) {
				/*
				 * Skip past string.
				 */
				s++;
				while (*s && *s != qc)
					s++;
				if (*s == qc)
					s++;
			}
		}

		if (!*s)
			done = 1;
		*s++ = '\0';

		/*
		 * save string in new ivec slot
		 */
		ivec[ic++] = v;
		ivec = xreallocarray(ivec, ic + 1, sizeof *ivec);
#ifdef DEBUG
		Debug(D_STR)
			plog(XLOG_DEBUG, "strsplit saved \"%s\"", v);
#endif /* DEBUG */
	}

#ifdef DEBUG
	Debug(D_STR)
		plog(XLOG_DEBUG, "strsplit saved a total of %d strings", ic);
#endif /* DEBUG */

	ivec[ic] = 0;

	return ivec;
}

/*
 * Strip off the trailing part of a domain
 * to produce a short-form domain relative
 * to the local host domain.
 * Note that this has no effect if the domain
 * names do not have the same number of
 * components.  If that restriction proves
 * to be a problem then the loop needs recoding
 * to skip from right to left and do partial
 * matches along the way -- ie more expensive.
 */
static void
domain_strip(char *otherdom, char *localdom)
{
#ifdef PARTIAL_DOMAINS
        char *p1 = otherdom-1;
	char *p2 = localdom-1;

        do {
                if (p1 = strchr(p1+1, '.'))
                if (p2 = strchr(p2+1, '.'))
                if (strcmp(p1+1, p2+1) == 0) {
                        *p1 = '\0';
                        break;
                }
        } while (p1 && p2);
#else
	char *p1, *p2;

	if ((p1 = strchr(otherdom, '.')) &&
			(p2 = strchr(localdom, '.')) &&
			(strcmp(p1+1, p2+1) == 0))
		*p1 = '\0';
#endif /* PARTIAL_DOMAINS */
}

/*
 * Normalize a host name
 */
void
host_normalize(char **chp)
{
	/*
	 * Normalize hosts is used to resolve host name aliases
	 * and replace them with the standard-form name.
	 * Invoked with "-n" command line option.
	 */
	if (normalize_hosts) {
		struct hostent *hp;
		clock_valid = 0;
		hp = gethostbyname(*chp);
		if (hp && hp->h_addrtype == AF_INET) {
#ifdef DEBUG
			dlog("Hostname %s normalized to %s", *chp, hp->h_name);
#endif /* DEBUG */
			*chp = strealloc(*chp, hp->h_name);
		}
	}
	domain_strip(*chp, hostd);
}

/*
 * Make a dotted quad from a 32bit IP address
 * addr is in network byte order.
 * sizeof(buf) needs to be at least 16.
 */
char *
inet_dquad(char *buf, size_t buflen, u_int32_t addr)
{
	addr = ntohl(addr);
	snprintf(buf, buflen, "%d.%d.%d.%d",
		((addr >> 24) & 0xff),
		((addr >> 16) & 0xff),
		((addr >> 8) & 0xff),
		((addr >> 0) & 0xff));
	return buf;
}

/*
 * Keys are not allowed to contain " ' ! or ; to avoid
 * problems with macro expansions.
 */
static char invalid_keys[] = "\"'!;@ \t\n";
int
valid_key(char *key)
{
	while (*key)
		if (strchr(invalid_keys, *key++))
			return FALSE;
	return TRUE;
}

void
going_down(int rc)
{
	if (foreground) {
		if (amd_state != Start) {
			if (amd_state != Done)
				return;
			unregister_amq();
		}
	}
	if (foreground) {
		plog(XLOG_INFO, "Finishing with status %d", rc);
	} else {
#ifdef DEBUG
		dlog("background process exiting with status %d", rc);
#endif /* DEBUG */
	}

	exit(rc);
}


int
bind_resv_port(int so, u_short *pp)
{
	struct sockaddr_in sin;
	int rc;

	bzero(&sin, sizeof(sin));
	sin.sin_family = AF_INET;

	rc = bindresvport(so, &sin);
	if (pp && rc == 0)
		*pp = ntohs(sin.sin_port);
	return rc;
}

void
forcibly_timeout_mp(am_node *mp)
{
	mntfs *mf = mp->am_mnt;
	/*
	 * Arrange to timeout this node
	 */
	if (mf && ((mp->am_flags & AMF_ROOT) ||
		(mf->mf_flags & (MFF_MOUNTING|MFF_UNMOUNTING)))) {
		if (!(mf->mf_flags & MFF_UNMOUNTING))
			plog(XLOG_WARNING, "ignoring timeout request for active node %s", mp->am_path);
	} else {
		plog(XLOG_INFO, "\"%s\" forcibly timed out", mp->am_path);
		mp->am_flags &= ~AMF_NOTIMEOUT;
		mp->am_ttl = clocktime();
		reschedule_timeout_mp();
	}
}

void
mf_mounted(mntfs *mf)
{
	int quoted;
	int wasmounted = mf->mf_flags & MFF_MOUNTED;

	if (!wasmounted) {
		/*
		 * If this is a freshly mounted
		 * filesystem then update the
		 * mntfs structure...
		 */
		mf->mf_flags |= MFF_MOUNTED;
		mf->mf_error = 0;

		/*
		 * Do mounted callback
		 */
		if (mf->mf_ops->mounted)
			(*mf->mf_ops->mounted)(mf);

		mf->mf_fo = 0;
	}

	/*
	 * Log message
	 */
	quoted = strchr(mf->mf_info, ' ') != 0;
	plog(XLOG_INFO, "%s%s%s %s fstype %s on %s",
		quoted ? "\"" : "",
		mf->mf_info,
		quoted ? "\"" : "",
		wasmounted ? "referenced" : "mounted",
		mf->mf_ops->fs_type, mf->mf_mount);
}

void
am_mounted(am_node *mp)
{
	mntfs *mf = mp->am_mnt;

	mf_mounted(mf);

	/*
	 * Patch up path for direct mounts
	 */
	if (mp->am_parent && mp->am_parent->am_mnt->mf_ops == &dfs_ops)
		mp->am_path = str3cat(mp->am_path, mp->am_parent->am_path, "/", ".");

	/*
	 * Check whether this mount should be cached permanently
	 */
	if (mf->mf_ops->fs_flags & FS_NOTIMEOUT) {
		mp->am_flags |= AMF_NOTIMEOUT;
	} else if (mf->mf_mount[1] == '\0' && mf->mf_mount[0] == '/') {
		mp->am_flags |= AMF_NOTIMEOUT;
	} else {
		struct mntent mnt;
		if (mf->mf_mopts) {
			mnt.mnt_opts = mf->mf_mopts;
			if (hasmntopt(&mnt, "nounmount"))
				mp->am_flags |= AMF_NOTIMEOUT;
			if ((mp->am_timeo = hasmntval(&mnt, "utimeout")) == 0)
				mp->am_timeo = am_timeo;
		}
	}

	/*
	 * If this node is a symlink then
	 * compute the length of the returned string.
	 */
	if (mp->am_fattr.type == NFLNK)
		mp->am_fattr.size = strlen(mp->am_link ? mp->am_link : mp->am_mnt->mf_mount);

	/*
	 * Record mount time
	 */
	mp->am_fattr.mtime.seconds = mp->am_stats.s_mtime = clocktime();
	new_ttl(mp);
	/*
	 * Update mtime of parent node
	 */
	if (mp->am_parent && mp->am_parent->am_mnt)
		mp->am_parent->am_fattr.mtime.seconds = mp->am_stats.s_mtime;


	/*
	 * Update stats
	 */
	amd_stats.d_mok++;
}

int
mount_node(am_node *mp)
{
	mntfs *mf = mp->am_mnt;
	int error;

	mf->mf_flags |= MFF_MOUNTING;
	error = (*mf->mf_ops->mount_fs)(mp);
	mf = mp->am_mnt;
	if (error >= 0)
		mf->mf_flags &= ~MFF_MOUNTING;
	if (!error && !(mf->mf_ops->fs_flags & FS_MBACKGROUND)) {
		/* ...but see ifs_mount */
		am_mounted(mp);
	}

	return error;
}

void
am_unmounted(am_node *mp)
{
	mntfs *mf = mp->am_mnt;

	if (!foreground) /* firewall - should never happen */
		return;

#ifdef DEBUG
	/*dlog("in am_unmounted(), foreground = %d", foreground);*/
#endif /* DEBUG */

	/*
	 * Do unmounted callback
	 */
	if (mf->mf_ops->umounted)
		(*mf->mf_ops->umounted)(mp);

	/*
	 * Update mtime of parent node
	 */
	if (mp->am_parent && mp->am_parent->am_mnt)
		mp->am_parent->am_fattr.mtime.seconds = clocktime();

	free_map(mp);
}

int
auto_fmount(am_node *mp)
{
	mntfs *mf = mp->am_mnt;
	return (*mf->mf_ops->fmount_fs)(mf);
}

int
auto_fumount(am_node *mp)
{
	mntfs *mf = mp->am_mnt;
	return (*mf->mf_ops->fumount_fs)(mf);
}

/*
 * Fork the automounter
 *
 * TODO: Need a better strategy for handling errors
 */
static pid_t
dofork(void)
{
	pid_t pid;
top:
	pid = fork();

	if (pid < 0) {
		sleep(1);
		goto top;
	}

	if (pid == 0) {
		mypid = getpid();
		foreground = 0;
	}

	return pid;
}

pid_t
background(void)
{
	pid_t pid = dofork();
	if (pid == 0) {
#ifdef DEBUG
		dlog("backgrounded");
#endif
		foreground = 0;
	}

	return pid;
}

/*
 * Make all the directories in the path.
 */
int
mkdirs(char *path, int mode)
{
	/*
	 * take a copy in case path is in readonly store
	 */
	char *p2 = strdup(path);
	char *sp = p2;
	struct stat stb;
	int error_so_far = 0;

	/*
	 * Skip through the string make the directories.
	 * Mostly ignore errors - the result is tested at the end.
	 *
	 * This assumes we are root so that we can do mkdir in a
	 * mode 555 directory...
	 */
	while ((sp = strchr(sp+1, '/'))) {
		*sp = '\0';
		if (mkdir(p2, mode) < 0) {
			error_so_far = errno;
		} else {
#ifdef DEBUG
			dlog("mkdir(%s)", p2);
#endif
		}
		*sp = '/';
	}

	if (mkdir(p2, mode) < 0) {
		error_so_far = errno;
	} else {
#ifdef DEBUG
		dlog("mkdir(%s)", p2);
#endif
	}


	free(p2);

	return stat(path, &stb) == 0 &&
		(stb.st_mode & S_IFMT) == S_IFDIR ? 0 : error_so_far;
}

/*
 * Remove as many directories in the path as possible.
 * Give up if the directory doesn't appear to have
 * been created by Amd (not mode dr-x) or an rmdir
 * fails for any reason.
 */
void
rmdirs(char *dir)
{
	char *xdp = strdup(dir);
	char *dp;

	do {
		struct stat stb;
		/*
		 * Try to find out whether this was
		 * created by amd.  Do this by checking
		 * for owner write permission.
		 */
		if (stat(xdp, &stb) == 0 && (stb.st_mode & 0200) == 0) {
			if (rmdir(xdp) < 0) {
				if (errno != ENOTEMPTY &&
				    errno != EBUSY &&
				    errno != EEXIST &&
				    errno != EINVAL)
					plog(XLOG_ERROR, "rmdir(%s): %m", xdp);
				break;
			} else {
#ifdef DEBUG
				dlog("rmdir(%s)", xdp);
#endif
			}
		} else {
			break;
		}
		dp = strrchr(xdp, '/');
		if (dp)
			*dp = '\0';
	} while (dp && dp > xdp);
	free(xdp);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/*
2			* Copyright (c) 1990 Jan-Simon Pendry
3			* Copyright (c) 1990 Imperial College of Science, Technology & Medicine
4			* Copyright (c) 1990, 1993
5			* The Regents of the University of California. All rights reserved.
6			*
7			* This code is derived from software contributed to Berkeley by
8			* Jan-Simon Pendry at Imperial College, London.
9			*
10			* Redistribution and use in source and binary forms, with or without
11			* modification, are permitted provided that the following conditions
12			* are met:
13			* 1. Redistributions of source code must retain the above copyright
14			* notice, this list of conditions and the following disclaimer.
15			* 2. Redistributions in binary form must reproduce the above copyright
16			* notice, this list of conditions and the following disclaimer in the
17			* documentation and/or other materials provided with the distribution.
18			* 3. Neither the name of the University nor the names of its contributors
19			* may be used to endorse or promote products derived from this software
20			* without specific prior written permission.
21			*
22			* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23			* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24			* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25			* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26			* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27			* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28			* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29			* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30			* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31			* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32			* SUCH DAMAGE.
33			*
34			* from: @(#)util.c 8.1 (Berkeley) 6/6/93
35			* $Id: util.c,v 1.16 2015/12/12 20:06:42 mmcc Exp $
36			*/
37
38			/*
39			* Utils
40			*/
41
42			#include "am.h"
43			#include <ctype.h>
44			#include <unistd.h>
45			#include <sys/stat.h>
46			#include <netdb.h>
47
48
49			char *
50			strnsave(const char *str, int len)
51			{
52			char *sp = xmalloc(len+1);
53
54			bcopy(str, sp, len);
55			sp[len] = 0;
56
57			return sp;
58			}
59
60			/*
61			* Concatenate three strings and store in buffer pointed to
62			* by p, making p large enough to hold the strings
63			*/
64			char *
65			str3cat(char p, char s1, char s2, char s3)
66			{
67			size_t l1 = strlen(s1);
68			size_t l2 = strlen(s2);
69			size_t l3 = strlen(s3);
70
71			if (l1 > SIZE_MAX - l2 \|\| l1 + l2 > SIZE_MAX - l3)
72			xmallocfailure();
73			p = xreallocarray(p, l1 + l2 + l3 + 1, 1);
74			bcopy(s1, p, l1);
75			bcopy(s2, p + l1, l2);
76			bcopy(s3, p + l1 + l2, l3 + 1);
77			return p;
78			}
79
80			char *
81			strealloc(char p, char s)
82			{
83			size_t len = strlen(s) + 1;
84
85			if (len > SIZE_MAX - 1)
86			xmallocfailure();
87			p = xreallocarray(p, len, 1);
88
89			strlcpy(p, s, len);
90			return p;
91			}
92
93			char **
94			strsplit(char *s, int ch, int qc)
95			{
96			char **ivec;
97			int ic = 0;
98			int done = 0;
99
100			ivec = xreallocarray(NULL, ic + 1, sizeof *ivec);
101
102			while (!done) {
103			char *v;
104			/*
105			* skip to split char
106			*/
107			while (*s && (ch == ' ' ?
108			(isascii((unsigned char)s) && isspace((unsigned char)s)) :
109			*s == ch))
110			*s++ = '\0';
111
112			/*
113			* End of string?
114			*/
115			if (!*s)
116			break;
117
118			/*
119			* remember start of string
120			*/
121			v = s;
122
123			/*
124			* skip to split char
125			*/
126			while (*s && !(ch == ' ' ?
127			(isascii((unsigned char)s) && isspace((unsigned char)s)) :
128			*s == ch)) {
129			if (*s++ == qc) {
130			/*
131			* Skip past string.
132			*/
133			s++;
134			while (s && s != qc)
135			s++;
136			if (*s == qc)
137			s++;
138			}
139			}
140
141			if (!*s)
142			done = 1;
143			*s++ = '\0';
144
145			/*
146			* save string in new ivec slot
147			*/
148			ivec[ic++] = v;
149			ivec = xreallocarray(ivec, ic + 1, sizeof *ivec);
150			#ifdef DEBUG
151			Debug(D_STR)
152			plog(XLOG_DEBUG, "strsplit saved \"%s\"", v);
153			#endif /* DEBUG */
154			}
155
156			#ifdef DEBUG
157			Debug(D_STR)
158			plog(XLOG_DEBUG, "strsplit saved a total of %d strings", ic);
159			#endif /* DEBUG */
160
161			ivec[ic] = 0;
162
163			return ivec;
164			}
165
166			/*
167			* Strip off the trailing part of a domain
168			* to produce a short-form domain relative
169			* to the local host domain.
170			* Note that this has no effect if the domain
171			* names do not have the same number of
172			* components. If that restriction proves
173			* to be a problem then the loop needs recoding
174			* to skip from right to left and do partial
175			* matches along the way -- ie more expensive.
176			*/
177			static void
178			domain_strip(char otherdom, char localdom)
179			{
180			#ifdef PARTIAL_DOMAINS
181			char *p1 = otherdom-1;
182			char *p2 = localdom-1;
183
184			do {
185			if (p1 = strchr(p1+1, '.'))
186			if (p2 = strchr(p2+1, '.'))
187			if (strcmp(p1+1, p2+1) == 0) {
188			*p1 = '\0';
189			break;
190			}
191			} while (p1 && p2);
192			#else
193			char p1, p2;
194
195			if ((p1 = strchr(otherdom, '.')) &&
196			(p2 = strchr(localdom, '.')) &&
197			(strcmp(p1+1, p2+1) == 0))
198			*p1 = '\0';
199			#endif /* PARTIAL_DOMAINS */
200			}
201
202			/*
203			* Normalize a host name
204			*/
205			void
206			host_normalize(char **chp)
207			{
208			/*
209			* Normalize hosts is used to resolve host name aliases
210			* and replace them with the standard-form name.
211			* Invoked with "-n" command line option.
212			*/
213			if (normalize_hosts) {
214			struct hostent *hp;
215			clock_valid = 0;
216			hp = gethostbyname(*chp);
217			if (hp && hp->h_addrtype == AF_INET) {
218			#ifdef DEBUG
219			dlog("Hostname %s normalized to %s", *chp, hp->h_name);
220			#endif /* DEBUG */
221			chp = strealloc(chp, hp->h_name);
222			}
223			}
224			domain_strip(*chp, hostd);
225			}
226
227			/*
228			* Make a dotted quad from a 32bit IP address
229			* addr is in network byte order.
230			* sizeof(buf) needs to be at least 16.
231			*/
232			char *
233			inet_dquad(char *buf, size_t buflen, u_int32_t addr)
234			{
235			addr = ntohl(addr);
236			snprintf(buf, buflen, "%d.%d.%d.%d",
237			((addr >> 24) & 0xff),
238			((addr >> 16) & 0xff),
239			((addr >> 8) & 0xff),
240			((addr >> 0) & 0xff));
241			return buf;
242			}
243
244			/*
245			* Keys are not allowed to contain " ' ! or ; to avoid
246			* problems with macro expansions.
247			*/
248			static char invalid_keys[] = "\"'!;@ \t\n";
249			int
250			valid_key(char *key)
251			{
252			while (*key)
253			if (strchr(invalid_keys, *key++))
254			return FALSE;
255			return TRUE;
256			}
257
258			void
259			going_down(int rc)
260			{
261			if (foreground) {
262			if (amd_state != Start) {
263			if (amd_state != Done)
264			return;
265			unregister_amq();
266			}
267			}
268			if (foreground) {
269			plog(XLOG_INFO, "Finishing with status %d", rc);
270			} else {
271			#ifdef DEBUG
272			dlog("background process exiting with status %d", rc);
273			#endif /* DEBUG */
274			}
275
276			exit(rc);
277			}
278
279
280			int
281			bind_resv_port(int so, u_short *pp)
282			{
283			struct sockaddr_in sin;
284			int rc;
285
286			bzero(&sin, sizeof(sin));
287			sin.sin_family = AF_INET;
288
289			rc = bindresvport(so, &sin);
290			if (pp && rc == 0)
291			*pp = ntohs(sin.sin_port);
292			return rc;
293			}
294
295			void
296			forcibly_timeout_mp(am_node *mp)
297			{
298			mntfs *mf = mp->am_mnt;
299			/*
300			* Arrange to timeout this node
301			*/
302			if (mf && ((mp->am_flags & AMF_ROOT) \|\|
303			(mf->mf_flags & (MFF_MOUNTING\|MFF_UNMOUNTING)))) {
304			if (!(mf->mf_flags & MFF_UNMOUNTING))
305			plog(XLOG_WARNING, "ignoring timeout request for active node %s", mp->am_path);
306			} else {
307			plog(XLOG_INFO, "\"%s\" forcibly timed out", mp->am_path);
308			mp->am_flags &= ~AMF_NOTIMEOUT;
309			mp->am_ttl = clocktime();
310			reschedule_timeout_mp();
311			}
312			}
313
314			void
315			mf_mounted(mntfs *mf)
316			{
317			int quoted;
318			int wasmounted = mf->mf_flags & MFF_MOUNTED;
319
320			if (!wasmounted) {
321			/*
322			* If this is a freshly mounted
323			* filesystem then update the
324			* mntfs structure...
325			*/
326			mf->mf_flags \|= MFF_MOUNTED;
327			mf->mf_error = 0;
328
329			/*
330			* Do mounted callback
331			*/
332			if (mf->mf_ops->mounted)
333			(*mf->mf_ops->mounted)(mf);
334
335			mf->mf_fo = 0;
336			}
337
338			/*
339			* Log message
340			*/
341			quoted = strchr(mf->mf_info, ' ') != 0;
342			plog(XLOG_INFO, "%s%s%s %s fstype %s on %s",
343			quoted ? "\"" : "",
344			mf->mf_info,
345			quoted ? "\"" : "",
346			wasmounted ? "referenced" : "mounted",
347			mf->mf_ops->fs_type, mf->mf_mount);
348			}
349
350			void
351			am_mounted(am_node *mp)
352			{
353			mntfs *mf = mp->am_mnt;
354
355			mf_mounted(mf);
356
357			/*
358			* Patch up path for direct mounts
359			*/
360			if (mp->am_parent && mp->am_parent->am_mnt->mf_ops == &dfs_ops)
361			mp->am_path = str3cat(mp->am_path, mp->am_parent->am_path, "/", ".");
362
363			/*
364			* Check whether this mount should be cached permanently
365			*/
366			if (mf->mf_ops->fs_flags & FS_NOTIMEOUT) {
367			mp->am_flags \|= AMF_NOTIMEOUT;
368			} else if (mf->mf_mount[1] == '\0' && mf->mf_mount[0] == '/') {
369			mp->am_flags \|= AMF_NOTIMEOUT;
370			} else {
371			struct mntent mnt;
372			if (mf->mf_mopts) {
373			mnt.mnt_opts = mf->mf_mopts;
374			if (hasmntopt(&mnt, "nounmount"))
375			mp->am_flags \|= AMF_NOTIMEOUT;
376			if ((mp->am_timeo = hasmntval(&mnt, "utimeout")) == 0)
377			mp->am_timeo = am_timeo;
378			}
379			}
380
381			/*
382			* If this node is a symlink then
383			* compute the length of the returned string.
384			*/
385			if (mp->am_fattr.type == NFLNK)
386			mp->am_fattr.size = strlen(mp->am_link ? mp->am_link : mp->am_mnt->mf_mount);
387
388			/*
389			* Record mount time
390			*/
391			mp->am_fattr.mtime.seconds = mp->am_stats.s_mtime = clocktime();
392			new_ttl(mp);
393			/*
394			* Update mtime of parent node
395			*/
396			if (mp->am_parent && mp->am_parent->am_mnt)
397			mp->am_parent->am_fattr.mtime.seconds = mp->am_stats.s_mtime;
398
399
400			/*
401			* Update stats
402			*/
403			amd_stats.d_mok++;
404			}
405
406			int
407			mount_node(am_node *mp)
408			{
409			mntfs *mf = mp->am_mnt;
410			int error;
411
412			mf->mf_flags \|= MFF_MOUNTING;
413			error = (*mf->mf_ops->mount_fs)(mp);
414			mf = mp->am_mnt;
415			if (error >= 0)
416			mf->mf_flags &= ~MFF_MOUNTING;
417			if (!error && !(mf->mf_ops->fs_flags & FS_MBACKGROUND)) {
418			/* ...but see ifs_mount */
419			am_mounted(mp);
420			}
421
422			return error;
423			}
424
425			void
426			am_unmounted(am_node *mp)
427			{
428			mntfs *mf = mp->am_mnt;
429
430			if (!foreground) /* firewall - should never happen */
431			return;
432
433			#ifdef DEBUG
434			/dlog("in am_unmounted(), foreground = %d", foreground);/
435			#endif /* DEBUG */
436
437			/*
438			* Do unmounted callback
439			*/
440			if (mf->mf_ops->umounted)
441			(*mf->mf_ops->umounted)(mp);
442
443			/*
444			* Update mtime of parent node
445			*/
446			if (mp->am_parent && mp->am_parent->am_mnt)
447			mp->am_parent->am_fattr.mtime.seconds = clocktime();
448
449			free_map(mp);
450			}
451
452			int
453			auto_fmount(am_node *mp)
454			{
455			mntfs *mf = mp->am_mnt;
456			return (*mf->mf_ops->fmount_fs)(mf);
457			}
458
459			int
460			auto_fumount(am_node *mp)
461			{
462			mntfs *mf = mp->am_mnt;
463			return (*mf->mf_ops->fumount_fs)(mf);
464			}
465
466			/*
467			* Fork the automounter
468			*
469			* TODO: Need a better strategy for handling errors
470			*/
471			static pid_t
472			dofork(void)
473			{
474			pid_t pid;
475			top:
476			pid = fork();
477
478			if (pid < 0) {
479			sleep(1);
480			goto top;
481			}
482
483			if (pid == 0) {
484			mypid = getpid();
485			foreground = 0;
486			}
487
488			return pid;
489			}
490
491			pid_t
492			background(void)
493			{
494			pid_t pid = dofork();
495			if (pid == 0) {
496			#ifdef DEBUG
497			dlog("backgrounded");
498			#endif
499			foreground = 0;
500			}
501
502			return pid;
503			}
504
505			/*
506			* Make all the directories in the path.
507			*/
508			int
509			mkdirs(char *path, int mode)
510			{
511			/*
512			* take a copy in case path is in readonly store
513			*/
514			char *p2 = strdup(path);
515			char *sp = p2;
516			struct stat stb;
517			int error_so_far = 0;
518
519			/*
520			* Skip through the string make the directories.
521			* Mostly ignore errors - the result is tested at the end.
522			*
523			* This assumes we are root so that we can do mkdir in a
524			* mode 555 directory...
525			*/
526			while ((sp = strchr(sp+1, '/'))) {
527			*sp = '\0';
528			if (mkdir(p2, mode) < 0) {
529			error_so_far = errno;
530			} else {
531			#ifdef DEBUG
532			dlog("mkdir(%s)", p2);
533			#endif
534			}
535			*sp = '/';
536			}
537
538			if (mkdir(p2, mode) < 0) {
539			error_so_far = errno;
540			} else {
541			#ifdef DEBUG
542			dlog("mkdir(%s)", p2);
543			#endif
544			}
545
546
547			free(p2);
548
549			return stat(path, &stb) == 0 &&
550			(stb.st_mode & S_IFMT) == S_IFDIR ? 0 : error_so_far;
551			}
552
553			/*
554			* Remove as many directories in the path as possible.
555			* Give up if the directory doesn't appear to have
556			* been created by Amd (not mode dr-x) or an rmdir
557			* fails for any reason.
558			*/
559			void
560			rmdirs(char *dir)
561			{
562			char *xdp = strdup(dir);
563			char *dp;
564
565			do {
566			struct stat stb;
567			/*
568			* Try to find out whether this was
569			* created by amd. Do this by checking
570			* for owner write permission.
571			*/
572			if (stat(xdp, &stb) == 0 && (stb.st_mode & 0200) == 0) {
573			if (rmdir(xdp) < 0) {
574			if (errno != ENOTEMPTY &&
575			errno != EBUSY &&
576			errno != EEXIST &&
577			errno != EINVAL)
578			plog(XLOG_ERROR, "rmdir(%s): %m", xdp);
579			break;
580			} else {
581			#ifdef DEBUG
582			dlog("rmdir(%s)", xdp);
583			#endif
584			}
585			} else {
586			break;
587			}
588			dp = strrchr(xdp, '/');
589			if (dp)
590			*dp = '\0';
591			} while (dp && dp > xdp);
592			free(xdp);
593			}