Some formatting updates (ran the code through indent)

 -Erik

1 files changed, 457 insertions, 476 deletions

diff --git a/nfsmount.c b/nfsmount.c
index f2bd2f49c..03ce58447 100644
--- a/nfsmount.c
+++ b/nfsmount.c
@@ -1,3 +1,4 @@
+/* vi: set sw=4 ts=4: */
 /*
  * nfsmount.c -- Linux NFS mount
  * Copyright (C) 1993 Rick Sladkey <jrs@world.std.com>
@@ -53,7 +54,7 @@
 
 #define _
 #define HAVE_inet_aton
-#define MS_REMOUNT	32	/* Alter flags of a mounted FS */
+#define MS_REMOUNT	32			/* Alter flags of a mounted FS */
 #define sloppy 0
 #define EX_FAIL 1
 #define EX_BG 1
@@ -65,8 +66,8 @@ static char *nfs_strerror(int stat);
 
 #define MAKE_VERSION(p,q,r)	(65536*(p) + 256*(q) + (r))
 
-static int
-linux_version_code(void) {
+static int linux_version_code(void)
+{
 	struct utsname my_utsname;
 	int p, q, r;
 
@@ -74,7 +75,7 @@ linux_version_code(void) {
 		p = atoi(strtok(my_utsname.release, "."));
 		q = atoi(strtok(NULL, "."));
 		r = atoi(strtok(NULL, "."));
-		return MAKE_VERSION(p,q,r);
+		return MAKE_VERSION(p, q, r);
 	}
 	return 0;
 }
@@ -95,22 +96,22 @@ static int nfs_mount_version = NFS_MOUNT_VERSION;
  *	NFS_MOUNT_VERSION: these nfsmount sources at compile time
  *	nfs_mount_version: version this source and running kernel can handle
  */
-static void
-find_kernel_nfs_mount_version(void) {
+static void find_kernel_nfs_mount_version(void)
+{
 	int kernel_version = linux_version_code();
 
 	if (kernel_version) {
-	     if (kernel_version < MAKE_VERSION(2,1,32))
-		  nfs_mount_version = 1;
-	     else
-		  nfs_mount_version = 3;
+		if (kernel_version < MAKE_VERSION(2, 1, 32))
+			nfs_mount_version = 1;
+		else
+			nfs_mount_version = 3;
 	}
 	if (nfs_mount_version > NFS_MOUNT_VERSION)
-	     nfs_mount_version = NFS_MOUNT_VERSION;
+		nfs_mount_version = NFS_MOUNT_VERSION;
 }
 
 int nfsmount(const char *spec, const char *node, unsigned long *flags,
-	     char **extra_opts, char **mount_opts, int running_bg)
+			 char **extra_opts, char **mount_opts, int running_bg)
 {
 	static char *prev_bg_host;
 	char hostdir[1024];
@@ -118,7 +119,7 @@ int nfsmount(const char *spec, const char *node, unsigned long *flags,
 	char *hostname;
 	char *dirname;
 	char *old_opts;
-	char *mounthost=NULL;
+	char *mounthost = NULL;
 	char new_opts[1024];
 	fhandle root_fhandle;
 	struct timeval total_timeout;
@@ -161,7 +162,7 @@ int nfsmount(const char *spec, const char *node, unsigned long *flags,
 	mclient = NULL;
 	if (strlen(spec) >= sizeof(hostdir)) {
 		fprintf(stderr, _("mount: "
-			"excessively long host:dir argument\n"));
+						  "excessively long host:dir argument\n"));
 		goto fail;
 	}
 	strcpy(hostdir, spec);
@@ -174,11 +175,11 @@ int nfsmount(const char *spec, const char *node, unsigned long *flags,
 		if ((s = strchr(hostdir, ','))) {
 			*s = '\0';
 			fprintf(stderr, _("mount: warning: "
-				"multiple hostnames not supported\n"));
+							  "multiple hostnames not supported\n"));
 		}
 	} else {
 		fprintf(stderr, _("mount: "
-			"directory to mount not in host:dir format\n"));
+						  "directory to mount not in host:dir format\n"));
 		goto fail;
 	}
 
@@ -189,20 +190,18 @@ int nfsmount(const char *spec, const char *node, unsigned long *flags,
 	{
 		if ((hp = gethostbyname(hostname)) == NULL) {
 			fprintf(stderr, _("mount: can't get address for %s\n"),
-				hostname);
+					hostname);
 			goto fail;
 		} else {
 			if (hp->h_length > sizeof(struct in_addr)) {
-				fprintf(stderr,
-					_("mount: got bad hp->h_length\n"));
+				fprintf(stderr, _("mount: got bad hp->h_length\n"));
 				hp->h_length = sizeof(struct in_addr);
 			}
-			memcpy(&server_addr.sin_addr,
-			       hp->h_addr, hp->h_length);
+			memcpy(&server_addr.sin_addr, hp->h_addr, hp->h_length);
 		}
 	}
 
-	memcpy (&mount_server_addr, &server_addr, sizeof (mount_server_addr));
+	memcpy(&mount_server_addr, &server_addr, sizeof(mount_server_addr));
 
 	/* add IP address to mtab options for use when unmounting */
 
@@ -211,12 +210,10 @@ int nfsmount(const char *spec, const char *node, unsigned long *flags,
 	if (!old_opts)
 		old_opts = "";
 	if (strlen(old_opts) + strlen(s) + 10 >= sizeof(new_opts)) {
-		fprintf(stderr, _("mount: "
-			"excessively long option argument\n"));
+		fprintf(stderr, _("mount: " "excessively long option argument\n"));
 		goto fail;
 	}
-	sprintf(new_opts, "%s%saddr=%s",
-		old_opts, *old_opts ? "," : "", s);
+	sprintf(new_opts, "%s%saddr=%s", old_opts, *old_opts ? "," : "", s);
 	*extra_opts = xstrdup(new_opts);
 
 	/* Set default options.
@@ -224,13 +221,13 @@ int nfsmount(const char *spec, const char *node, unsigned long *flags,
 	 * let the kernel decide.
 	 * timeo is filled in after we know whether it'll be TCP or UDP. */
 	memset(&data, 0, sizeof(data));
-	data.retrans	= 3;
-	data.acregmin	= 3;
-	data.acregmax	= 60;
-	data.acdirmin	= 30;
-	data.acdirmax	= 60;
+	data.retrans = 3;
+	data.acregmin = 3;
+	data.acregmax = 60;
+	data.acdirmin = 30;
+	data.acdirmax = 60;
 #if NFS_MOUNT_VERSION >= 2
-	data.namlen	= NAME_MAX;
+	data.namlen = NAME_MAX;
 #endif
 
 	bg = 0;
@@ -240,7 +237,7 @@ int nfsmount(const char *spec, const char *node, unsigned long *flags,
 	nocto = 0;
 	nolock = 0;
 	noac = 0;
-	retry = 10000;		/* 10000 minutes ~ 1 week */
+	retry = 10000;				/* 10000 minutes ~ 1 week */
 	tcp = 0;
 
 	mountprog = MOUNTPROG;
@@ -254,7 +251,7 @@ int nfsmount(const char *spec, const char *node, unsigned long *flags,
 
 	for (opt = strtok(old_opts, ","); opt; opt = strtok(NULL, ",")) {
 		if ((opteq = strchr(opt, '='))) {
-			val = atoi(opteq + 1);	
+			val = atoi(opteq + 1);
 			*opteq = '\0';
 			if (!strcmp(opt, "rsize"))
 				data.rsize = val;
@@ -277,29 +274,27 @@ int nfsmount(const char *spec, const char *node, unsigned long *flags,
 				data.acregmax = val;
 				data.acdirmin = val;
 				data.acdirmax = val;
-			}
-			else if (!strcmp(opt, "retry"))
+			} else if (!strcmp(opt, "retry"))
 				retry = val;
 			else if (!strcmp(opt, "port"))
 				port = val;
 			else if (!strcmp(opt, "mountport"))
-			        mountport = val;
+				mountport = val;
 			else if (!strcmp(opt, "mounthost"))
-			        mounthost=xstrndup(opteq+1,
-						  strcspn(opteq+1," \t\n\r,"));
+				mounthost = xstrndup(opteq + 1,
+									 strcspn(opteq + 1, " \t\n\r,"));
 			else if (!strcmp(opt, "mountprog"))
 				mountprog = val;
 			else if (!strcmp(opt, "mountvers"))
 				mountvers = val;
 			else if (!strcmp(opt, "nfsprog"))
 				nfsprog = val;
-			else if (!strcmp(opt, "nfsvers") ||
-				 !strcmp(opt, "vers"))
+			else if (!strcmp(opt, "nfsvers") || !strcmp(opt, "vers"))
 				nfsvers = val;
 			else if (!strcmp(opt, "proto")) {
-				if (!strncmp(opteq+1, "tcp", 3))
+				if (!strncmp(opteq + 1, "tcp", 3))
 					tcp = 1;
-				else if (!strncmp(opteq+1, "udp", 3))
+				else if (!strncmp(opteq + 1, "udp", 3))
 					tcp = 0;
 				else
 					printf(_("Warning: Unrecognized proto= option.\n"));
@@ -309,24 +304,24 @@ int nfsmount(const char *spec, const char *node, unsigned long *flags,
 					data.namlen = val;
 				else
 #endif
-				printf(_("Warning: Option namlen is not supported.\n"));
+					printf(_
+						   ("Warning: Option namlen is not supported.\n"));
 			} else if (!strcmp(opt, "addr"))
-				/* ignore */;
+				/* ignore */ ;
 			else {
 				printf(_("unknown nfs mount parameter: "
-				       "%s=%d\n"), opt, val);
+						 "%s=%d\n"), opt, val);
 				goto fail;
 			}
-		}
-		else {
+		} else {
 			val = 1;
 			if (!strncmp(opt, "no", 2)) {
 				val = 0;
 				opt += 2;
 			}
-			if (!strcmp(opt, "bg")) 
+			if (!strcmp(opt, "bg"))
 				bg = val;
-			else if (!strcmp(opt, "fg")) 
+			else if (!strcmp(opt, "fg"))
 				bg = !val;
 			else if (!strcmp(opt, "soft"))
 				soft = val;
@@ -348,11 +343,12 @@ int nfsmount(const char *spec, const char *node, unsigned long *flags,
 				if (nfs_mount_version >= 3)
 					nolock = !val;
 				else
-					printf(_("Warning: option nolock is not supported.\n"));
+					printf(_
+						   ("Warning: option nolock is not supported.\n"));
 			} else {
 				if (!sloppy) {
 					printf(_("unknown nfs mount option: "
-					       "%s%s\n"), val ? "" : "no", opt);
+							 "%s%s\n"), val ? "" : "no", opt);
 					goto fail;
 				}
 			}
@@ -378,22 +374,21 @@ int nfsmount(const char *spec, const char *node, unsigned long *flags,
 
 #ifdef NFS_MOUNT_DEBUG
 	printf("rsize = %d, wsize = %d, timeo = %d, retrans = %d\n",
-		data.rsize, data.wsize, data.timeo, data.retrans);
+		   data.rsize, data.wsize, data.timeo, data.retrans);
 	printf("acreg (min, max) = (%d, %d), acdir (min, max) = (%d, %d)\n",
-		data.acregmin, data.acregmax, data.acdirmin, data.acdirmax);
+		   data.acregmin, data.acregmax, data.acdirmin, data.acdirmax);
 	printf("port = %d, bg = %d, retry = %d, flags = %.8x\n",
-		port, bg, retry, data.flags);
+		   port, bg, retry, data.flags);
 	printf("mountprog = %d, mountvers = %d, nfsprog = %d, nfsvers = %d\n",
-		mountprog, mountvers, nfsprog, nfsvers);
+		   mountprog, mountvers, nfsprog, nfsvers);
 	printf("soft = %d, intr = %d, posix = %d, nocto = %d, noac = %d\n",
-		(data.flags & NFS_MOUNT_SOFT) != 0,
-		(data.flags & NFS_MOUNT_INTR) != 0,
-		(data.flags & NFS_MOUNT_POSIX) != 0,
-		(data.flags & NFS_MOUNT_NOCTO) != 0,
-		(data.flags & NFS_MOUNT_NOAC) != 0);
+		   (data.flags & NFS_MOUNT_SOFT) != 0,
+		   (data.flags & NFS_MOUNT_INTR) != 0,
+		   (data.flags & NFS_MOUNT_POSIX) != 0,
+		   (data.flags & NFS_MOUNT_NOCTO) != 0,
+		   (data.flags & NFS_MOUNT_NOAC) != 0);
 #if NFS_MOUNT_VERSION >= 2
-	printf("tcp = %d\n",
-		(data.flags & NFS_MOUNT_TCP) != 0);
+	printf("tcp = %d\n", (data.flags & NFS_MOUNT_TCP) != 0);
 #endif
 #endif
 
@@ -409,7 +404,7 @@ int nfsmount(const char *spec, const char *node, unsigned long *flags,
 	 * give up immediately, to avoid the initial timeout.
 	 */
 	if (bg && !running_bg &&
-	    prev_bg_host && strcmp(hostname, prev_bg_host) == 0) {
+		prev_bg_host && strcmp(hostname, prev_bg_host) == 0) {
 		if (retry > 0)
 			retval = EX_BG;
 		return retval;
@@ -418,25 +413,24 @@ int nfsmount(const char *spec, const char *node, unsigned long *flags,
 	/* create mount deamon client */
 	/* See if the nfs host = mount host. */
 	if (mounthost) {
-	  if (mounthost[0] >= '0' && mounthost[0] <= '9') {
-	    mount_server_addr.sin_family = AF_INET;
-	    mount_server_addr.sin_addr.s_addr = inet_addr(hostname);
-	  } else {
-		  if ((hp = gethostbyname(mounthost)) == NULL) {
-			  fprintf(stderr, _("mount: can't get address for %s\n"),
-				  hostname);
-			  goto fail;
-		  } else {
-			  if (hp->h_length > sizeof(struct in_addr)) {
-				  fprintf(stderr,
-					  _("mount: got bad hp->h_length?\n"));
-				  hp->h_length = sizeof(struct in_addr);
-			  }
-			  mount_server_addr.sin_family = AF_INET;
-			  memcpy(&mount_server_addr.sin_addr,
-				 hp->h_addr, hp->h_length);
-		  }
-	  }
+		if (mounthost[0] >= '0' && mounthost[0] <= '9') {
+			mount_server_addr.sin_family = AF_INET;
+			mount_server_addr.sin_addr.s_addr = inet_addr(hostname);
+		} else {
+			if ((hp = gethostbyname(mounthost)) == NULL) {
+				fprintf(stderr, _("mount: can't get address for %s\n"),
+						hostname);
+				goto fail;
+			} else {
+				if (hp->h_length > sizeof(struct in_addr)) {
+					fprintf(stderr, _("mount: got bad hp->h_length?\n"));
+					hp->h_length = sizeof(struct in_addr);
+				}
+				mount_server_addr.sin_family = AF_INET;
+				memcpy(&mount_server_addr.sin_addr,
+					   hp->h_addr, hp->h_length);
+			}
+		}
 	}
 
 	/*
@@ -466,7 +460,7 @@ int nfsmount(const char *spec, const char *node, unsigned long *flags,
 	for (;;) {
 		if (bg && stat(node, &statbuf) == -1) {
 			if (running_bg) {
-				sleep(val);	/* 1, 2, 4, 8, 16, 30, ... */
+				sleep(val);		/* 1, 2, 4, 8, 16, 30, ... */
 				val *= 2;
 				if (val > 30)
 					val = 30;
@@ -480,24 +474,24 @@ int nfsmount(const char *spec, const char *node, unsigned long *flags,
 			mount_server_addr.sin_port = htons(mountport);
 			msock = RPC_ANYSOCK;
 			mclient = clnttcp_create(&mount_server_addr,
-						 mountprog, mountvers,
-						 &msock, 0, 0);
+									 mountprog, mountvers, &msock, 0, 0);
 
 			/* if this fails, contact the mount daemon via UDP */
 			if (!mclient) {
 				mount_server_addr.sin_port = htons(mountport);
 				msock = RPC_ANYSOCK;
 				mclient = clntudp_create(&mount_server_addr,
-							 mountprog, mountvers,
-							 retry_timeout, &msock);
+										 mountprog, mountvers,
+										 retry_timeout, &msock);
 			}
 			if (mclient) {
 				/* try to mount hostname:dirname */
 				mclient->cl_auth = authunix_create_default();
 				clnt_stat = clnt_call(mclient, MOUNTPROC_MNT,
-					(xdrproc_t) xdr_dirpath, (caddr_t) &dirname,
-					(xdrproc_t) xdr_fhstatus, (caddr_t) &status,
-					total_timeout);
+									  (xdrproc_t) xdr_dirpath,
+									  (caddr_t) & dirname,
+									  (xdrproc_t) xdr_fhstatus,
+									  (caddr_t) & status, total_timeout);
 				if (clnt_stat == RPC_SUCCESS)
 					break;		/* we're done */
 				if (errno != ECONNREFUSED) {
@@ -517,7 +511,7 @@ int nfsmount(const char *spec, const char *node, unsigned long *flags,
 			prevt = t;
 		}
 		if (!bg)
-		        goto fail;
+			goto fail;
 		if (!running_bg) {
 			prev_bg_host = xstrdup(hostname);
 			if (retry > 0)
@@ -531,18 +525,18 @@ int nfsmount(const char *spec, const char *node, unsigned long *flags,
 
 	if (status.fhs_status != 0) {
 		fprintf(stderr,
-			_("mount: %s:%s failed, reason given by server: %s\n"),
-			hostname, dirname, nfs_strerror(status.fhs_status));
+				_("mount: %s:%s failed, reason given by server: %s\n"),
+				hostname, dirname, nfs_strerror(status.fhs_status));
 		goto fail;
 	}
 	memcpy((char *) &root_fhandle, (char *) status.fhstatus_u.fhs_fhandle,
-		sizeof (root_fhandle));
+		   sizeof(root_fhandle));
 
 	/* create nfs socket for kernel */
 
 	if (tcp) {
 		if (nfs_mount_version < 3) {
-	     		printf(_("NFS over TCP is not supported.\n"));
+			printf(_("NFS over TCP is not supported.\n"));
 			goto fail;
 		}
 		fsock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
@@ -559,7 +553,7 @@ int nfsmount(const char *spec, const char *node, unsigned long *flags,
 	if (port == 0) {
 		server_addr.sin_port = PMAPPORT;
 		port = pmap_getport(&server_addr, nfsprog, nfsvers,
-			tcp ? IPPROTO_TCP : IPPROTO_UDP);
+							tcp ? IPPROTO_TCP : IPPROTO_UDP);
 		if (port == 0)
 			port = NFS_PORT;
 #ifdef NFS_MOUNT_DEBUG
@@ -571,14 +565,14 @@ int nfsmount(const char *spec, const char *node, unsigned long *flags,
 	printf(_("using port %d for nfs deamon\n"), port);
 #endif
 	server_addr.sin_port = htons(port);
-	 /*
-	  * connect() the socket for kernels 1.3.10 and below only,
-	  * to avoid problems with multihomed hosts.
-	  * --Swen
-	  */
+	/*
+	 * connect() the socket for kernels 1.3.10 and below only,
+	 * to avoid problems with multihomed hosts.
+	 * --Swen
+	 */
 	if (linux_version_code() <= 66314
-	    && connect(fsock, (struct sockaddr *) &server_addr,
-		       sizeof (server_addr)) < 0) {
+		&& connect(fsock, (struct sockaddr *) &server_addr,
+				   sizeof(server_addr)) < 0) {
 		perror(_("nfs connect"));
 		goto fail;
 	}
@@ -587,7 +581,7 @@ int nfsmount(const char *spec, const char *node, unsigned long *flags,
 
 	data.fd = fsock;
 	memcpy((char *) &data.root, (char *) &root_fhandle,
-		sizeof (root_fhandle));
+		   sizeof(root_fhandle));
 	memcpy((char *) &data.addr, (char *) &server_addr, sizeof(data.addr));
 	strncpy(data.hostname, hostname, sizeof(data.hostname));
 
@@ -600,7 +594,7 @@ int nfsmount(const char *spec, const char *node, unsigned long *flags,
 
 	/* abort */
 
-fail:
+  fail:
 	if (msock != -1) {
 		if (mclient) {
 			auth_destroy(mclient->cl_auth);
@@ -611,7 +605,7 @@ fail:
 	if (fsock != -1)
 		close(fsock);
 	return retval;
-}	
+}
 
 /*
  * We need to translate between nfs status return values and
@@ -630,33 +624,37 @@ static struct {
 	enum nfs_stat stat;
 	int errnum;
 } nfs_errtbl[] = {
-	{ NFS_OK,		0		},
-	{ NFSERR_PERM,		EPERM		},
-	{ NFSERR_NOENT,		ENOENT		},
-	{ NFSERR_IO,		EIO		},
-	{ NFSERR_NXIO,		ENXIO		},
-	{ NFSERR_ACCES,		EACCES		},
-	{ NFSERR_EXIST,		EEXIST		},
-	{ NFSERR_NODEV,		ENODEV		},
-	{ NFSERR_NOTDIR,	ENOTDIR		},
-	{ NFSERR_ISDIR,		EISDIR		},
+	{
+	NFS_OK, 0}, {
+	NFSERR_PERM, EPERM}, {
+	NFSERR_NOENT, ENOENT}, {
+	NFSERR_IO, EIO}, {
+	NFSERR_NXIO, ENXIO}, {
+	NFSERR_ACCES, EACCES}, {
+	NFSERR_EXIST, EEXIST}, {
+	NFSERR_NODEV, ENODEV}, {
+	NFSERR_NOTDIR, ENOTDIR}, {
+	NFSERR_ISDIR, EISDIR},
 #ifdef NFSERR_INVAL
-	{ NFSERR_INVAL,		EINVAL		},	/* that Sun forgot */
+	{
+	NFSERR_INVAL, EINVAL},		/* that Sun forgot */
 #endif
-	{ NFSERR_FBIG,		EFBIG		},
-	{ NFSERR_NOSPC,		ENOSPC		},
-	{ NFSERR_ROFS,		EROFS		},
-	{ NFSERR_NAMETOOLONG,	ENAMETOOLONG	},
-	{ NFSERR_NOTEMPTY,	ENOTEMPTY	},
-	{ NFSERR_DQUOT,		EDQUOT		},
-	{ NFSERR_STALE,		ESTALE		},
+	{
+	NFSERR_FBIG, EFBIG}, {
+	NFSERR_NOSPC, ENOSPC}, {
+	NFSERR_ROFS, EROFS}, {
+	NFSERR_NAMETOOLONG, ENAMETOOLONG}, {
+	NFSERR_NOTEMPTY, ENOTEMPTY}, {
+	NFSERR_DQUOT, EDQUOT}, {
+	NFSERR_STALE, ESTALE},
 #ifdef EWFLUSH
-	{ NFSERR_WFLUSH,	EWFLUSH		},
+	{
+	NFSERR_WFLUSH, EWFLUSH},
 #endif
-	/* Throw in some NFSv3 values for even more fun (HP returns these) */
-	{ 71,			EREMOTE		},
-
-	{ -1,			EIO		}
+		/* Throw in some NFSv3 values for even more fun (HP returns these) */
+	{
+	71, EREMOTE}, {
+	-1, EIO}
 };
 
 static char *nfs_strerror(int stat)
@@ -673,33 +671,32 @@ static char *nfs_strerror(int stat)
 }
 
 #if 0
-int
-my_getport(struct in_addr server, struct timeval *timeo, ...)
+int my_getport(struct in_addr server, struct timeval *timeo, ...)
 {
-        struct sockaddr_in sin;
-        struct pmap     pmap;
-        CLIENT          *clnt;
-        int             sock = RPC_ANYSOCK, port;
-
-        pmap.pm_prog = prog;
-        pmap.pm_vers = vers;
-        pmap.pm_prot = prot;
-        pmap.pm_port = 0;
-        sin.sin_family = AF_INET;
-        sin.sin_addr = server;
-        sin.sin_port = htons(111);
-        clnt = clntudp_create(&sin, 100000, 2, *timeo, &sock);
-        status = clnt_call(clnt, PMAP_GETPORT,
-                                &pmap, (xdrproc_t) xdr_pmap,
-                                &port, (xdrproc_t) xdr_uint);
-        if (status != SUCCESS) {
-	     /* natter */
-                port = 0;
-        }
-
-        clnt_destroy(clnt);
-        close(sock);
-        return port;
+	struct sockaddr_in sin;
+	struct pmap pmap;
+	CLIENT *clnt;
+	int sock = RPC_ANYSOCK, port;
+
+	pmap.pm_prog = prog;
+	pmap.pm_vers = vers;
+	pmap.pm_prot = prot;
+	pmap.pm_port = 0;
+	sin.sin_family = AF_INET;
+	sin.sin_addr = server;
+	sin.sin_port = htons(111);
+	clnt = clntudp_create(&sin, 100000, 2, *timeo, &sock);
+	status = clnt_call(clnt, PMAP_GETPORT,
+					   &pmap, (xdrproc_t) xdr_pmap,
+					   &port, (xdrproc_t) xdr_uint);
+	if (status != SUCCESS) {
+		/* natter */
+		port = 0;
+	}
+
+	clnt_destroy(clnt);
+	close(sock);
+	return port;
 }
 #endif
 
@@ -756,28 +753,26 @@ my_getport(struct in_addr server, struct timeval *timeo, ...)
 
 /* from @(#)mount.x	1.3 91/03/11 TIRPC 1.0 */
 
-bool_t
-xdr_fhandle(XDR *xdrs, fhandle objp)
+bool_t xdr_fhandle(XDR * xdrs, fhandle objp)
 {
 
-	 if (!xdr_opaque(xdrs, objp, FHSIZE)) {
-		 return (FALSE);
-	 }
+	if (!xdr_opaque(xdrs, objp, FHSIZE)) {
+		return (FALSE);
+	}
 	return (TRUE);
 }
 
-bool_t
-xdr_fhstatus(XDR *xdrs, fhstatus *objp)
+bool_t xdr_fhstatus(XDR * xdrs, fhstatus * objp)
 {
 
-	 if (!xdr_u_int(xdrs, &objp->fhs_status)) {
-		 return (FALSE);
-	 }
+	if (!xdr_u_int(xdrs, &objp->fhs_status)) {
+		return (FALSE);
+	}
 	switch (objp->fhs_status) {
 	case 0:
-		 if (!xdr_fhandle(xdrs, objp->fhstatus_u.fhs_fhandle)) {
-			 return (FALSE);
-		 }
+		if (!xdr_fhandle(xdrs, objp->fhstatus_u.fhs_fhandle)) {
+			return (FALSE);
+		}
 		break;
 	default:
 		break;
@@ -785,245 +780,246 @@ xdr_fhstatus(XDR *xdrs, fhstatus *objp)
 	return (TRUE);
 }
 
-bool_t
-xdr_dirpath(XDR *xdrs, dirpath *objp)
+bool_t xdr_dirpath(XDR * xdrs, dirpath * objp)
 {
 
-	 if (!xdr_string(xdrs, objp, MNTPATHLEN)) {
-		 return (FALSE);
-	 }
+	if (!xdr_string(xdrs, objp, MNTPATHLEN)) {
+		return (FALSE);
+	}
 	return (TRUE);
 }
 
-bool_t
-xdr_name(XDR *xdrs, name *objp)
+bool_t xdr_name(XDR * xdrs, name * objp)
 {
 
-	 if (!xdr_string(xdrs, objp, MNTNAMLEN)) {
-		 return (FALSE);
-	 }
+	if (!xdr_string(xdrs, objp, MNTNAMLEN)) {
+		return (FALSE);
+	}
 	return (TRUE);
 }
 
-bool_t
-xdr_mountlist(XDR *xdrs, mountlist *objp)
+bool_t xdr_mountlist(XDR * xdrs, mountlist * objp)
 {
 
-	 if (!xdr_pointer(xdrs, (char **)objp, sizeof(struct mountbody), (xdrproc_t)xdr_mountbody)) {
-		 return (FALSE);
-	 }
+	if (!xdr_pointer
+		(xdrs, (char **) objp, sizeof(struct mountbody),
+		 (xdrproc_t) xdr_mountbody)) {
+		return (FALSE);
+	}
 	return (TRUE);
 }
 
-bool_t
-xdr_mountbody(XDR *xdrs, mountbody *objp)
+bool_t xdr_mountbody(XDR * xdrs, mountbody * objp)
 {
 
-	 if (!xdr_name(xdrs, &objp->ml_hostname)) {
-		 return (FALSE);
-	 }
-	 if (!xdr_dirpath(xdrs, &objp->ml_directory)) {
-		 return (FALSE);
-	 }
-	 if (!xdr_mountlist(xdrs, &objp->ml_next)) {
-		 return (FALSE);
-	 }
+	if (!xdr_name(xdrs, &objp->ml_hostname)) {
+		return (FALSE);
+	}
+	if (!xdr_dirpath(xdrs, &objp->ml_directory)) {
+		return (FALSE);
+	}
+	if (!xdr_mountlist(xdrs, &objp->ml_next)) {
+		return (FALSE);
+	}
 	return (TRUE);
 }
 
-bool_t
-xdr_groups(XDR *xdrs, groups *objp)
+bool_t xdr_groups(XDR * xdrs, groups * objp)
 {
 
-	 if (!xdr_pointer(xdrs, (char **)objp, sizeof(struct groupnode), (xdrproc_t)xdr_groupnode)) {
-		 return (FALSE);
-	 }
+	if (!xdr_pointer
+		(xdrs, (char **) objp, sizeof(struct groupnode),
+		 (xdrproc_t) xdr_groupnode)) {
+		return (FALSE);
+	}
 	return (TRUE);
 }
 
-bool_t
-xdr_groupnode(XDR *xdrs, groupnode *objp)
+bool_t xdr_groupnode(XDR * xdrs, groupnode * objp)
 {
 
-	 if (!xdr_name(xdrs, &objp->gr_name)) {
-		 return (FALSE);
-	 }
-	 if (!xdr_groups(xdrs, &objp->gr_next)) {
-		 return (FALSE);
-	 }
+	if (!xdr_name(xdrs, &objp->gr_name)) {
+		return (FALSE);
+	}
+	if (!xdr_groups(xdrs, &objp->gr_next)) {
+		return (FALSE);
+	}
 	return (TRUE);
 }
 
-bool_t
-xdr_exports(XDR *xdrs, exports *objp)
+bool_t xdr_exports(XDR * xdrs, exports * objp)
 {
 
-	 if (!xdr_pointer(xdrs, (char **)objp, sizeof(struct exportnode), (xdrproc_t)xdr_exportnode)) {
-		 return (FALSE);
-	 }
+	if (!xdr_pointer
+		(xdrs, (char **) objp, sizeof(struct exportnode),
+		 (xdrproc_t) xdr_exportnode)) {
+		return (FALSE);
+	}
 	return (TRUE);
 }
 
-bool_t
-xdr_exportnode(XDR *xdrs, exportnode *objp)
+bool_t xdr_exportnode(XDR * xdrs, exportnode * objp)
 {
 
-	 if (!xdr_dirpath(xdrs, &objp->ex_dir)) {
-		 return (FALSE);
-	 }
-	 if (!xdr_groups(xdrs, &objp->ex_groups)) {
-		 return (FALSE);
-	 }
-	 if (!xdr_exports(xdrs, &objp->ex_next)) {
-		 return (FALSE);
-	 }
+	if (!xdr_dirpath(xdrs, &objp->ex_dir)) {
+		return (FALSE);
+	}
+	if (!xdr_groups(xdrs, &objp->ex_groups)) {
+		return (FALSE);
+	}
+	if (!xdr_exports(xdrs, &objp->ex_next)) {
+		return (FALSE);
+	}
 	return (TRUE);
 }
 
-bool_t
-xdr_ppathcnf(XDR *xdrs, ppathcnf *objp)
+bool_t xdr_ppathcnf(XDR * xdrs, ppathcnf * objp)
 {
 
-	 register long *buf;
-
-	 int i;
-
-	 if (xdrs->x_op == XDR_ENCODE) {
-	 buf = (long*)XDR_INLINE(xdrs,6 * BYTES_PER_XDR_UNIT);
-	   if (buf == NULL) {
-		 if (!xdr_int(xdrs, &objp->pc_link_max)) {
-			 return (FALSE);
-		 }
-		 if (!xdr_short(xdrs, &objp->pc_max_canon)) {
-			 return (FALSE);
-		 }
-		 if (!xdr_short(xdrs, &objp->pc_max_input)) {
-			 return (FALSE);
-		 }
-		 if (!xdr_short(xdrs, &objp->pc_name_max)) {
-			 return (FALSE);
-		 }
-		 if (!xdr_short(xdrs, &objp->pc_path_max)) {
-			 return (FALSE);
-		 }
-		 if (!xdr_short(xdrs, &objp->pc_pipe_buf)) {
-			 return (FALSE);
-		 }
-
-	  }
-	  else {
-		 IXDR_PUT_LONG(buf,objp->pc_link_max);
-		 IXDR_PUT_SHORT(buf,objp->pc_max_canon);
-		 IXDR_PUT_SHORT(buf,objp->pc_max_input);
-		 IXDR_PUT_SHORT(buf,objp->pc_name_max);
-		 IXDR_PUT_SHORT(buf,objp->pc_path_max);
-		 IXDR_PUT_SHORT(buf,objp->pc_pipe_buf);
-	  }
-	 if (!xdr_u_char(xdrs, &objp->pc_vdisable)) {
-		 return (FALSE);
-	 }
-	 if (!xdr_char(xdrs, &objp->pc_xxx)) {
-		 return (FALSE);
-	 }
-		buf = (long*)XDR_INLINE(xdrs,   2  * BYTES_PER_XDR_UNIT);
+	register long *buf;
+
+	int i;
+
+	if (xdrs->x_op == XDR_ENCODE) {
+		buf = (long *) XDR_INLINE(xdrs, 6 * BYTES_PER_XDR_UNIT);
 		if (buf == NULL) {
-		 if (!xdr_vector(xdrs, (char *)objp->pc_mask, 2, sizeof(short), (xdrproc_t)xdr_short)) {
-			 return (FALSE);
-		 }
-
-	  }
-	  else {
-		{ register short *genp; 
-		  for ( i = 0,genp=objp->pc_mask;
- 			i < 2; i++){
-				 IXDR_PUT_SHORT(buf,*genp++);
-		   }
-		 };
-	  }
-
- 	 return (TRUE);
+			if (!xdr_int(xdrs, &objp->pc_link_max)) {
+				return (FALSE);
+			}
+			if (!xdr_short(xdrs, &objp->pc_max_canon)) {
+				return (FALSE);
+			}
+			if (!xdr_short(xdrs, &objp->pc_max_input)) {
+				return (FALSE);
+			}
+			if (!xdr_short(xdrs, &objp->pc_name_max)) {
+				return (FALSE);
+			}
+			if (!xdr_short(xdrs, &objp->pc_path_max)) {
+				return (FALSE);
+			}
+			if (!xdr_short(xdrs, &objp->pc_pipe_buf)) {
+				return (FALSE);
+			}
+
+		} else {
+			IXDR_PUT_LONG(buf, objp->pc_link_max);
+			IXDR_PUT_SHORT(buf, objp->pc_max_canon);
+			IXDR_PUT_SHORT(buf, objp->pc_max_input);
+			IXDR_PUT_SHORT(buf, objp->pc_name_max);
+			IXDR_PUT_SHORT(buf, objp->pc_path_max);
+			IXDR_PUT_SHORT(buf, objp->pc_pipe_buf);
+		}
+		if (!xdr_u_char(xdrs, &objp->pc_vdisable)) {
+			return (FALSE);
+		}
+		if (!xdr_char(xdrs, &objp->pc_xxx)) {
+			return (FALSE);
+		}
+		buf = (long *) XDR_INLINE(xdrs, 2 * BYTES_PER_XDR_UNIT);
+		if (buf == NULL) {
+			if (!xdr_vector
+				(xdrs, (char *) objp->pc_mask, 2, sizeof(short),
+				 (xdrproc_t) xdr_short)) {
+				return (FALSE);
+			}
+
+		} else {
+			{
+				register short *genp;
+
+				for (i = 0, genp = objp->pc_mask; i < 2; i++) {
+					IXDR_PUT_SHORT(buf, *genp++);
+				}
+			};
+		}
+
+		return (TRUE);
 	} else if (xdrs->x_op == XDR_DECODE) {
-	 buf = (long*)XDR_INLINE(xdrs,6 * BYTES_PER_XDR_UNIT);
-	   if (buf == NULL) {
-		 if (!xdr_int(xdrs, &objp->pc_link_max)) {
-			 return (FALSE);
-		 }
-		 if (!xdr_short(xdrs, &objp->pc_max_canon)) {
-			 return (FALSE);
-		 }
-		 if (!xdr_short(xdrs, &objp->pc_max_input)) {
-			 return (FALSE);
-		 }
-		 if (!xdr_short(xdrs, &objp->pc_name_max)) {
-			 return (FALSE);
-		 }
-		 if (!xdr_short(xdrs, &objp->pc_path_max)) {
-			 return (FALSE);
-		 }
-		 if (!xdr_short(xdrs, &objp->pc_pipe_buf)) {
-			 return (FALSE);
-		 }
-
-	  }
-	  else {
-		 objp->pc_link_max = IXDR_GET_LONG(buf);
-		 objp->pc_max_canon = IXDR_GET_SHORT(buf);
-		 objp->pc_max_input = IXDR_GET_SHORT(buf);
-		 objp->pc_name_max = IXDR_GET_SHORT(buf);
-		 objp->pc_path_max = IXDR_GET_SHORT(buf);
-		 objp->pc_pipe_buf = IXDR_GET_SHORT(buf);
-	  }
-	 if (!xdr_u_char(xdrs, &objp->pc_vdisable)) {
-		 return (FALSE);
-	 }
-	 if (!xdr_char(xdrs, &objp->pc_xxx)) {
-		 return (FALSE);
-	 }
-		buf = (long*)XDR_INLINE(xdrs,   2  * BYTES_PER_XDR_UNIT);
+		buf = (long *) XDR_INLINE(xdrs, 6 * BYTES_PER_XDR_UNIT);
+		if (buf == NULL) {
+			if (!xdr_int(xdrs, &objp->pc_link_max)) {
+				return (FALSE);
+			}
+			if (!xdr_short(xdrs, &objp->pc_max_canon)) {
+				return (FALSE);
+			}
+			if (!xdr_short(xdrs, &objp->pc_max_input)) {
+				return (FALSE);
+			}
+			if (!xdr_short(xdrs, &objp->pc_name_max)) {
+				return (FALSE);
+			}
+			if (!xdr_short(xdrs, &objp->pc_path_max)) {
+				return (FALSE);
+			}
+			if (!xdr_short(xdrs, &objp->pc_pipe_buf)) {
+				return (FALSE);
+			}
+
+		} else {
+			objp->pc_link_max = IXDR_GET_LONG(buf);
+			objp->pc_max_canon = IXDR_GET_SHORT(buf);
+			objp->pc_max_input = IXDR_GET_SHORT(buf);
+			objp->pc_name_max = IXDR_GET_SHORT(buf);
+			objp->pc_path_max = IXDR_GET_SHORT(buf);
+			objp->pc_pipe_buf = IXDR_GET_SHORT(buf);
+		}
+		if (!xdr_u_char(xdrs, &objp->pc_vdisable)) {
+			return (FALSE);
+		}
+		if (!xdr_char(xdrs, &objp->pc_xxx)) {
+			return (FALSE);
+		}
+		buf = (long *) XDR_INLINE(xdrs, 2 * BYTES_PER_XDR_UNIT);
 		if (buf == NULL) {
-		 if (!xdr_vector(xdrs, (char *)objp->pc_mask, 2, sizeof(short), (xdrproc_t)xdr_short)) {
-			 return (FALSE);
-		 }
-
-	  }
-	  else {
-		{ register short *genp; 
-		  for ( i = 0,genp=objp->pc_mask;
- 			i < 2; i++){
-				 *genp++ = IXDR_GET_SHORT(buf);
-		   }
-		 };
-	  }
-	 return(TRUE);
+			if (!xdr_vector
+				(xdrs, (char *) objp->pc_mask, 2, sizeof(short),
+				 (xdrproc_t) xdr_short)) {
+				return (FALSE);
+			}
+
+		} else {
+			{
+				register short *genp;
+
+				for (i = 0, genp = objp->pc_mask; i < 2; i++) {
+					*genp++ = IXDR_GET_SHORT(buf);
+				}
+			};
+		}
+		return (TRUE);
 	}
 
-	 if (!xdr_int(xdrs, &objp->pc_link_max)) {
-		 return (FALSE);
-	 }
-	 if (!xdr_short(xdrs, &objp->pc_max_canon)) {
-		 return (FALSE);
-	 }
-	 if (!xdr_short(xdrs, &objp->pc_max_input)) {
-		 return (FALSE);
-	 }
-	 if (!xdr_short(xdrs, &objp->pc_name_max)) {
-		 return (FALSE);
-	 }
-	 if (!xdr_short(xdrs, &objp->pc_path_max)) {
-		 return (FALSE);
-	 }
-	 if (!xdr_short(xdrs, &objp->pc_pipe_buf)) {
-		 return (FALSE);
-	 }
-	 if (!xdr_u_char(xdrs, &objp->pc_vdisable)) {
-		 return (FALSE);
-	 }
-	 if (!xdr_char(xdrs, &objp->pc_xxx)) {
-		 return (FALSE);
-	 }
-	 if (!xdr_vector(xdrs, (char *)objp->pc_mask, 2, sizeof(short), (xdrproc_t)xdr_short)) {
-		 return (FALSE);
-	 }
+	if (!xdr_int(xdrs, &objp->pc_link_max)) {
+		return (FALSE);
+	}
+	if (!xdr_short(xdrs, &objp->pc_max_canon)) {
+		return (FALSE);
+	}
+	if (!xdr_short(xdrs, &objp->pc_max_input)) {
+		return (FALSE);
+	}
+	if (!xdr_short(xdrs, &objp->pc_name_max)) {
+		return (FALSE);
+	}
+	if (!xdr_short(xdrs, &objp->pc_path_max)) {
+		return (FALSE);
+	}
+	if (!xdr_short(xdrs, &objp->pc_pipe_buf)) {
+		return (FALSE);
+	}
+	if (!xdr_u_char(xdrs, &objp->pc_vdisable)) {
+		return (FALSE);
+	}
+	if (!xdr_char(xdrs, &objp->pc_xxx)) {
+		return (FALSE);
+	}
+	if (!xdr_vector
+		(xdrs, (char *) objp->pc_mask, 2, sizeof(short),
+		 (xdrproc_t) xdr_short)) {
+		return (FALSE);
+	}
 	return (TRUE);
 }
 
@@ -1063,247 +1059,232 @@ xdr_ppathcnf(XDR *xdrs, ppathcnf *objp)
 
 /* from @(#)mount.x	1.3 91/03/11 TIRPC 1.0 */
 
-#include <string.h>            /* for memset() */
+#include <string.h>				/* for memset() */
 
 /* Default timeout can be changed using clnt_control() */
 static struct timeval TIMEOUT = { 25, 0 };
 
-void *
-mountproc_null_1(argp, clnt)
-	void *argp;
-	CLIENT *clnt;
+void *mountproc_null_1(argp, clnt)
+void *argp;
+CLIENT *clnt;
 {
 	static char clnt_res;
 
-	memset((char *)&clnt_res, 0, sizeof(clnt_res));
-	if (clnt_call(clnt, MOUNTPROC_NULL, (xdrproc_t) xdr_void, argp, (xdrproc_t) xdr_void, &clnt_res, TIMEOUT) != RPC_SUCCESS) {
+	memset((char *) &clnt_res, 0, sizeof(clnt_res));
+	if (clnt_call
+		(clnt, MOUNTPROC_NULL, (xdrproc_t) xdr_void, argp,
+		 (xdrproc_t) xdr_void, &clnt_res, TIMEOUT) != RPC_SUCCESS) {
 		return (NULL);
 	}
-	return ((void *)&clnt_res);
+	return ((void *) &clnt_res);
 }
 
-fhstatus *
-mountproc_mnt_1(argp, clnt)
-	dirpath *argp;
-	CLIENT *clnt;
+fhstatus *mountproc_mnt_1(argp, clnt)
+dirpath *argp;
+CLIENT *clnt;
 {
 	static fhstatus clnt_res;
 
-	memset((char *)&clnt_res, 0, sizeof(clnt_res));
+	memset((char *) &clnt_res, 0, sizeof(clnt_res));
 	if (clnt_call(clnt, MOUNTPROC_MNT, (xdrproc_t) xdr_dirpath,
-		      (caddr_t) argp, (xdrproc_t) xdr_fhstatus,
-		      (caddr_t) &clnt_res, TIMEOUT) != RPC_SUCCESS) {
+				  (caddr_t) argp, (xdrproc_t) xdr_fhstatus,
+				  (caddr_t) & clnt_res, TIMEOUT) != RPC_SUCCESS) {
 		return (NULL);
 	}
 	return (&clnt_res);
 }
 
-mountlist *
-mountproc_dump_1(argp, clnt)
-	void *argp;
-	CLIENT *clnt;
+mountlist *mountproc_dump_1(argp, clnt)
+void *argp;
+CLIENT *clnt;
 {
 	static mountlist clnt_res;
 
-	memset((char *)&clnt_res, 0, sizeof(clnt_res));
+	memset((char *) &clnt_res, 0, sizeof(clnt_res));
 	if (clnt_call(clnt, MOUNTPROC_DUMP, (xdrproc_t) xdr_void,
-		      (caddr_t) argp, (xdrproc_t) xdr_mountlist,
-		      (caddr_t) &clnt_res, TIMEOUT) != RPC_SUCCESS) {
+				  (caddr_t) argp, (xdrproc_t) xdr_mountlist,
+				  (caddr_t) & clnt_res, TIMEOUT) != RPC_SUCCESS) {
 		return (NULL);
 	}
 	return (&clnt_res);
 }
 
-void *
-mountproc_umnt_1(argp, clnt)
-	dirpath *argp;
-	CLIENT *clnt;
+void *mountproc_umnt_1(argp, clnt)
+dirpath *argp;
+CLIENT *clnt;
 {
 	static char clnt_res;
 
-	memset((char *)&clnt_res, 0, sizeof(clnt_res));
+	memset((char *) &clnt_res, 0, sizeof(clnt_res));
 	if (clnt_call(clnt, MOUNTPROC_UMNT, (xdrproc_t) xdr_dirpath,
-		      (caddr_t) argp, (xdrproc_t) xdr_void,
-		      (caddr_t) &clnt_res, TIMEOUT) != RPC_SUCCESS) {
+				  (caddr_t) argp, (xdrproc_t) xdr_void,
+				  (caddr_t) & clnt_res, TIMEOUT) != RPC_SUCCESS) {
 		return (NULL);
 	}
-	return ((void *)&clnt_res);
+	return ((void *) &clnt_res);
 }
 
-void *
-mountproc_umntall_1(argp, clnt)
-	void *argp;
-	CLIENT *clnt;
+void *mountproc_umntall_1(argp, clnt)
+void *argp;
+CLIENT *clnt;
 {
 	static char clnt_res;
 
-	memset((char *)&clnt_res, 0, sizeof(clnt_res));
+	memset((char *) &clnt_res, 0, sizeof(clnt_res));
 	if (clnt_call(clnt, MOUNTPROC_UMNTALL, (xdrproc_t) xdr_void,
-		      (caddr_t) argp, (xdrproc_t) xdr_void,
-		      (caddr_t) &clnt_res, TIMEOUT) != RPC_SUCCESS) {
+				  (caddr_t) argp, (xdrproc_t) xdr_void,
+				  (caddr_t) & clnt_res, TIMEOUT) != RPC_SUCCESS) {
 		return (NULL);
 	}
-	return ((void *)&clnt_res);
+	return ((void *) &clnt_res);
 }
 
-exports *
-mountproc_export_1(argp, clnt)
-	void *argp;
-	CLIENT *clnt;
+exports *mountproc_export_1(argp, clnt)
+void *argp;
+CLIENT *clnt;
 {
 	static exports clnt_res;
 
-	memset((char *)&clnt_res, 0, sizeof(clnt_res));
+	memset((char *) &clnt_res, 0, sizeof(clnt_res));
 	if (clnt_call(clnt, MOUNTPROC_EXPORT, (xdrproc_t) xdr_void,
-		      (caddr_t) argp, (xdrproc_t) xdr_exports,
-		      (caddr_t) &clnt_res, TIMEOUT) != RPC_SUCCESS) {
+				  (caddr_t) argp, (xdrproc_t) xdr_exports,
+				  (caddr_t) & clnt_res, TIMEOUT) != RPC_SUCCESS) {
 		return (NULL);
 	}
 	return (&clnt_res);
 }
 
-exports *
-mountproc_exportall_1(argp, clnt)
-	void *argp;
-	CLIENT *clnt;
+exports *mountproc_exportall_1(argp, clnt)
+void *argp;
+CLIENT *clnt;
 {
 	static exports clnt_res;
 
-	memset((char *)&clnt_res, 0, sizeof(clnt_res));
+	memset((char *) &clnt_res, 0, sizeof(clnt_res));
 	if (clnt_call(clnt, MOUNTPROC_EXPORTALL, (xdrproc_t) xdr_void,
-		      (caddr_t) argp, (xdrproc_t) xdr_exports,
-		      (caddr_t) &clnt_res, TIMEOUT) != RPC_SUCCESS) {
-	  return (NULL);
+				  (caddr_t) argp, (xdrproc_t) xdr_exports,
+				  (caddr_t) & clnt_res, TIMEOUT) != RPC_SUCCESS) {
+		return (NULL);
 	}
 	return (&clnt_res);
 }
 
-void *
-mountproc_null_2(argp, clnt)
-	void *argp;
-	CLIENT *clnt;
+void *mountproc_null_2(argp, clnt)
+void *argp;
+CLIENT *clnt;
 {
 	static char clnt_res;
 
-	memset((char *)&clnt_res, 0, sizeof(clnt_res));
-	if (clnt_call(clnt, MOUNTPROC_NULL, (xdrproc_t) xdr_void, argp, (xdrproc_t) xdr_void, &clnt_res, TIMEOUT) != RPC_SUCCESS) {
+	memset((char *) &clnt_res, 0, sizeof(clnt_res));
+	if (clnt_call
+		(clnt, MOUNTPROC_NULL, (xdrproc_t) xdr_void, argp,
+		 (xdrproc_t) xdr_void, &clnt_res, TIMEOUT) != RPC_SUCCESS) {
 		return (NULL);
 	}
-	return ((void *)&clnt_res);
+	return ((void *) &clnt_res);
 }
 
-fhstatus *
-mountproc_mnt_2(argp, clnt)
-	dirpath *argp;
-	CLIENT *clnt;
+fhstatus *mountproc_mnt_2(argp, clnt)
+dirpath *argp;
+CLIENT *clnt;
 {
 	static fhstatus clnt_res;
 
-	memset((char *)&clnt_res, 0, sizeof(clnt_res));
+	memset((char *) &clnt_res, 0, sizeof(clnt_res));
 	if (clnt_call(clnt, MOUNTPROC_MNT, (xdrproc_t) xdr_dirpath,
-		      (caddr_t) argp, (xdrproc_t) xdr_fhstatus,
-		      (caddr_t) &clnt_res, TIMEOUT) != RPC_SUCCESS) {
+				  (caddr_t) argp, (xdrproc_t) xdr_fhstatus,
+				  (caddr_t) & clnt_res, TIMEOUT) != RPC_SUCCESS) {
 		return (NULL);
 	}
 	return (&clnt_res);
 }
 
-mountlist *
-mountproc_dump_2(argp, clnt)
-	void *argp;
-	CLIENT *clnt;
+mountlist *mountproc_dump_2(argp, clnt)
+void *argp;
+CLIENT *clnt;
 {
 	static mountlist clnt_res;
 
-	memset((char *)&clnt_res, 0, sizeof(clnt_res));
+	memset((char *) &clnt_res, 0, sizeof(clnt_res));
 	if (clnt_call(clnt, MOUNTPROC_DUMP, (xdrproc_t) xdr_void, argp,
-		      (xdrproc_t) xdr_mountlist, (caddr_t) &clnt_res,
-		      TIMEOUT) != RPC_SUCCESS) {
+				  (xdrproc_t) xdr_mountlist, (caddr_t) & clnt_res,
+				  TIMEOUT) != RPC_SUCCESS) {
 		return (NULL);
 	}
 	return (&clnt_res);
 }
 
-void *
-mountproc_umnt_2(argp, clnt)
-	dirpath *argp;
-	CLIENT *clnt;
+void *mountproc_umnt_2(argp, clnt)
+dirpath *argp;
+CLIENT *clnt;
 {
 	static char clnt_res;
 
-	memset((char *)&clnt_res, 0, sizeof(clnt_res));
+	memset((char *) &clnt_res, 0, sizeof(clnt_res));
 	if (clnt_call(clnt, MOUNTPROC_UMNT, (xdrproc_t) xdr_dirpath,
-		      (caddr_t) argp, (xdrproc_t) xdr_void,
-		      (caddr_t) &clnt_res, TIMEOUT) != RPC_SUCCESS) {
+				  (caddr_t) argp, (xdrproc_t) xdr_void,
+				  (caddr_t) & clnt_res, TIMEOUT) != RPC_SUCCESS) {
 		return (NULL);
 	}
-	return ((void *)&clnt_res);
+	return ((void *) &clnt_res);
 }
 
-void *
-mountproc_umntall_2(argp, clnt)
-	void *argp;
-	CLIENT *clnt;
+void *mountproc_umntall_2(argp, clnt)
+void *argp;
+CLIENT *clnt;
 {
 	static char clnt_res;
 
-	memset((char *)&clnt_res, 0, sizeof(clnt_res));
+	memset((char *) &clnt_res, 0, sizeof(clnt_res));
 	if (clnt_call(clnt, MOUNTPROC_UMNTALL, (xdrproc_t) xdr_void,
-		      (caddr_t) argp, (xdrproc_t) xdr_void,
-		      (caddr_t) &clnt_res, TIMEOUT) != RPC_SUCCESS) {
+				  (caddr_t) argp, (xdrproc_t) xdr_void,
+				  (caddr_t) & clnt_res, TIMEOUT) != RPC_SUCCESS) {
 		return (NULL);
 	}
-	return ((void *)&clnt_res);
+	return ((void *) &clnt_res);
 }
 
-exports *
-mountproc_export_2(argp, clnt)
-	void *argp;
-	CLIENT *clnt;
+exports *mountproc_export_2(argp, clnt)
+void *argp;
+CLIENT *clnt;
 {
 	static exports clnt_res;
 
-	memset((char *)&clnt_res, 0, sizeof(clnt_res));
+	memset((char *) &clnt_res, 0, sizeof(clnt_res));
 	if (clnt_call(clnt, MOUNTPROC_EXPORT, (xdrproc_t) xdr_void,
-		      argp, (xdrproc_t) xdr_exports, (caddr_t) &clnt_res,
-		      TIMEOUT) != RPC_SUCCESS) {
+				  argp, (xdrproc_t) xdr_exports, (caddr_t) & clnt_res,
+				  TIMEOUT) != RPC_SUCCESS) {
 		return (NULL);
 	}
 	return (&clnt_res);
 }
 
-exports *
-mountproc_exportall_2(argp, clnt)
-	void *argp;
-	CLIENT *clnt;
+exports *mountproc_exportall_2(argp, clnt)
+void *argp;
+CLIENT *clnt;
 {
 	static exports clnt_res;
 
-	memset((char *)&clnt_res, 0, sizeof(clnt_res));
+	memset((char *) &clnt_res, 0, sizeof(clnt_res));
 	if (clnt_call(clnt, MOUNTPROC_EXPORTALL, (xdrproc_t) xdr_void, argp,
-		      (xdrproc_t) xdr_exports, (caddr_t) &clnt_res,
-		      TIMEOUT) != RPC_SUCCESS) {
+				  (xdrproc_t) xdr_exports, (caddr_t) & clnt_res,
+				  TIMEOUT) != RPC_SUCCESS) {
 		return (NULL);
 	}
 	return (&clnt_res);
 }
 
-ppathcnf *
-mountproc_pathconf_2(argp, clnt)
-	dirpath *argp;
-	CLIENT *clnt;
+ppathcnf *mountproc_pathconf_2(argp, clnt)
+dirpath *argp;
+CLIENT *clnt;
 {
 	static ppathcnf clnt_res;
 
-	memset((char *)&clnt_res, 0, sizeof(clnt_res));
+	memset((char *) &clnt_res, 0, sizeof(clnt_res));
 	if (clnt_call(clnt, MOUNTPROC_PATHCONF, (xdrproc_t) xdr_dirpath,
-		      (caddr_t) argp, (xdrproc_t) xdr_ppathcnf,
-		      (caddr_t) &clnt_res, TIMEOUT) != RPC_SUCCESS) {
+				  (caddr_t) argp, (xdrproc_t) xdr_ppathcnf,
+				  (caddr_t) & clnt_res, TIMEOUT) != RPC_SUCCESS) {
 		return (NULL);
 	}
 	return (&clnt_res);
 }
-
-
-
-