[unix-history] / usr / src / usr.bin / showmount / showmount.c

/*
* Copyright (c) 1989, 1993, 1995
*      The Regents of the University of California.  All rights reserved.
*
* This code is derived from software contributed to Berkeley by
* Rick Macklem at The University of Guelph.
*
* %sccs.include.redist.c%
*/

#ifndef lint
static char copyright[] =
"@(#) Copyright (c) 1989, 1993, 1995\n\
       The Regents of the University of California.  All rights reserved.\n";
#endif not lint

#ifndef lint
static char sccsid[] = "@(#)showmount.c 8.2 (Berkeley) %G%";
#endif not lint

#include <sys/types.h>
#include <sys/file.h>
#include <sys/socket.h>
#include <sys/socketvar.h>

#include <netdb.h>
#include <rpc/rpc.h>
#include <rpc/pmap_clnt.h>
#include <rpc/pmap_prot.h>
#include <nfs/rpcv2.h>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

/* Constant defs */
#define ALL     1
#define DIRS    2

#define DODUMP          0x1
#define DOEXPORTS       0x2

struct mountlist {
       struct mountlist *ml_left;
       struct mountlist *ml_right;
       char    ml_host[RPCMNT_NAMELEN+1];
       char    ml_dirp[RPCMNT_PATHLEN+1];
};

struct grouplist {
       struct grouplist *gr_next;
       char    gr_name[RPCMNT_NAMELEN+1];
};

struct exportslist {
       struct exportslist *ex_next;
       struct grouplist *ex_groups;
       char    ex_dirp[RPCMNT_PATHLEN+1];
};

static struct mountlist *mntdump;
static struct exportslist *exports;
static int type = 0;

void    print_dump __P((struct mountlist *));
void    usage __P((void));
int     xdr_mntdump __P((XDR *, struct mountlist **));
int     xdr_exports __P((XDR *, struct exportslist **));

/*
* This command queries the NFS mount daemon for it's mount list and/or
* it's exports list and prints them out.
* See "NFS: Network File System Protocol Specification, RFC1094, Appendix A"
* for detailed information on the protocol.
*/
int
main(argc, argv)
       int argc;
       char **argv;
{
       struct exportslist *exp;
       struct grouplist *grp;
       int estat, rpcs = 0;
       char ch, *host;

       while ((ch = getopt(argc, argv, "ade")) != EOF)
               switch((char)ch) {
               case 'a':
                       if (type == 0) {
                               type = ALL;
                               rpcs |= DODUMP;
                       } else
                               usage();
                       break;
               case 'd':
                       if (type == 0) {
                               type = DIRS;
                               rpcs |= DODUMP;
                       } else
                               usage();
                       break;
               case 'e':
                       rpcs |= DOEXPORTS;
                       break;
               case '?':
               default:
                       usage();
               }
       argc -= optind;
       argv += optind;

       if (argc > 0)
               host = *argv;
       else
               host = "localhost";

       if (rpcs == 0)
               rpcs = DODUMP;

       if (rpcs & DODUMP)
               if ((estat = callrpc(host, RPCPROG_MNT, RPCMNT_VER1,
                       RPCMNT_DUMP, xdr_void, (char *)0,
                       xdr_mntdump, (char *)&mntdump)) != 0) {
                       clnt_perrno(estat);
                       fprintf(stderr, ": Can't do Mountdump rpc\n");
                       exit(1);
               }
       if (rpcs & DOEXPORTS)
               if ((estat = callrpc(host, RPCPROG_MNT, RPCMNT_VER1,
                       RPCMNT_EXPORT, xdr_void, (char *)0,
                       xdr_exports, (char *)&exports)) != 0) {
                       clnt_perrno(estat);
                       fprintf(stderr, ": Can't do Exports rpc\n");
                       exit(1);
               }

       /* Now just print out the results */
       if (rpcs & DODUMP) {
               switch (type) {
               case ALL:
                       printf("All mount points on %s:\n", host);
                       break;
               case DIRS:
                       printf("Directories on %s:\n", host);
                       break;
               default:
                       printf("Hosts on %s:\n", host);
                       break;
               };
               print_dump(mntdump);
       }
       if (rpcs & DOEXPORTS) {
               printf("Exports list on %s:\n", host);
               exp = exports;
               while (exp) {
                       printf("%-35s", exp->ex_dirp);
                       grp = exp->ex_groups;
                       if (grp == NULL) {
                               printf("Everyone\n");
                       } else {
                               while (grp) {
                                       printf("%s ", grp->gr_name);
                                       grp = grp->gr_next;
                               }
                               printf("\n");
                       }
                       exp = exp->ex_next;
               }
       }

       exit(0);
}

/*
* Xdr routine for retrieving the mount dump list
*/
int
xdr_mntdump(xdrsp, mlp)
       XDR *xdrsp;
       struct mountlist **mlp;
{
       struct mountlist *mp, **otp, *tp;
       int bool, val, val2;
       char *strp;

       *mlp = (struct mountlist *)0;
       if (!xdr_bool(xdrsp, &bool))
               return (0);
       while (bool) {
               mp = (struct mountlist *)malloc(sizeof(struct mountlist));
               if (mp == NULL)
                       return (0);
               mp->ml_left = mp->ml_right = (struct mountlist *)0;
               strp = mp->ml_host;
               if (!xdr_string(xdrsp, &strp, RPCMNT_NAMELEN))
                       return (0);
               strp = mp->ml_dirp;
               if (!xdr_string(xdrsp, &strp, RPCMNT_PATHLEN))
                       return (0);

               /*
                * Build a binary tree on sorted order of either host or dirp.
                * Drop any duplications.
                */
               if (*mlp == NULL) {
                       *mlp = mp;
               } else {
                       tp = *mlp;
                       while (tp) {
                               val = strcmp(mp->ml_host, tp->ml_host);
                               val2 = strcmp(mp->ml_dirp, tp->ml_dirp);
                               switch (type) {
                               case ALL:
                                       if (val == 0) {
                                               if (val2 == 0) {
                                                       free((caddr_t)mp);
                                                       goto next;
                                               }
                                               val = val2;
                                       }
                                       break;
                               case DIRS:
                                       if (val2 == 0) {
                                               free((caddr_t)mp);
                                               goto next;
                                       }
                                       val = val2;
                                       break;
                               default:
                                       if (val == 0) {
                                               free((caddr_t)mp);
                                               goto next;
                                       }
                                       break;
                               };
                               if (val < 0) {
                                       otp = &tp->ml_left;
                                       tp = tp->ml_left;
                               } else {
                                       otp = &tp->ml_right;
                                       tp = tp->ml_right;
                               }
                       }
                       *otp = mp;
               }
next:
               if (!xdr_bool(xdrsp, &bool))
                       return (0);
       }
       return (1);
}

/*
* Xdr routine to retrieve exports list
*/
int
xdr_exports(xdrsp, exp)
       XDR *xdrsp;
       struct exportslist **exp;
{
       struct exportslist *ep;
       struct grouplist *gp;
       int bool, grpbool;
       char *strp;

       *exp = (struct exportslist *)0;
       if (!xdr_bool(xdrsp, &bool))
               return (0);
       while (bool) {
               ep = (struct exportslist *)malloc(sizeof(struct exportslist));
               if (ep == NULL)
                       return (0);
               ep->ex_groups = (struct grouplist *)0;
               strp = ep->ex_dirp;
               if (!xdr_string(xdrsp, &strp, RPCMNT_PATHLEN))
                       return (0);
               if (!xdr_bool(xdrsp, &grpbool))
                       return (0);
               while (grpbool) {
                       gp = (struct grouplist *)malloc(sizeof(struct grouplist));
                       if (gp == NULL)
                               return (0);
                       strp = gp->gr_name;
                       if (!xdr_string(xdrsp, &strp, RPCMNT_NAMELEN))
                               return (0);
                       gp->gr_next = ep->ex_groups;
                       ep->ex_groups = gp;
                       if (!xdr_bool(xdrsp, &grpbool))
                               return (0);
               }
               ep->ex_next = *exp;
               *exp = ep;
               if (!xdr_bool(xdrsp, &bool))
                       return (0);
       }
       return (1);
}

void
usage()
{

       fprintf(stderr, "usage: showmount [-ade] host\n");
       exit(1);
}

/*
* Print the binary tree in inorder so that output is sorted.
*/
void
print_dump(mp)
       struct mountlist *mp;
{

       if (mp == NULL)
               return;
       if (mp->ml_left)
               print_dump(mp->ml_left);
       switch (type) {
       case ALL:
               printf("%s:%s\n", mp->ml_host, mp->ml_dirp);
               break;
       case DIRS:
               printf("%s\n", mp->ml_dirp);
               break;
       default:
               printf("%s\n", mp->ml_host);
               break;
       };
       if (mp->ml_right)
               print_dump(mp->ml_right);
}