Usenet 1994 January

home *** CD-ROM | disk | FTP | other *** search

/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume3 / rfs / part3 < prev next >

Wrap

Internet Message Format | 1986-11-30 | 62.2 KB

Subject: RFS: remote file system (part 3 of 7) Newsgroups: mod.sources Approved: jpn@panda.UUCP Mod.sources: Volume 3, Issue 79 Submitted by: tektronix!tekcrl!toddb #!/bin/sh # # RFS, a kernel-resident remote file system. Shar 3 of 7 # # # This is a shell archive, meaning: # 1. Remove everything above the #!/bin/sh line. # 2. Save the resulting text in a file. # 3. Execute the file with /bin/sh (not csh) to create the files: # remote/list.c # remote/make.base # remote/make.base.M68 # remote/make.base.magnolia # remote/make.base.pyramid # remote/make.base.vax # remote/make.base.vaxnorfs # remote/new.c # remote/newinit.c # remote/rhost.c # remote/rmtmnt.c # remote/route.c # remote/server.h # remote/serverdata.c # remote/serverdir.c # # remote/list.c # if [ -f remote/list.c ]; then echo -n 'Hit <return> to overwrite remote/list.c or ^C to quit' read ans rm -f remote/list.c fi sed -e 's/^.//' << \SHAREOF > remote/list.c X/* X * Copyright 1985, Todd Brunhoff. X * X * This software was written at Tektronix Computer Research Laboratories X * as partial fulfillment of a Master's degree at the University of Denver. X * This is not Tektronix proprietary software and should not be X * confused with any software product sold by Tektronix. No warranty is X * expressed or implied on the reliability of this software; the author, X * the University of Denver, and Tektronix, inc. accept no liability for X * any damage done directly or indirectly by this software. This software X * may be copied, modified or used in any way, without fee, provided this X * notice remains an unaltered part of the software. X * X * $Log: list.c,v $ X * Revision 2.0 85/12/07 18:21:44 toddb X * First public release. X * X */ Xstatic char *rcsid = "$Header: list.c,v 2.0 85/12/07 18:21:44 toddb Rel $"; X#include "server.h" X#include <stdio.h> X X/* X * Stick a new item of any type on top of the list. X */ Xl_list *addlist(list, item) X register l_list **list; X register l_list *item; X{ X item->l_next = *list; X if (*list) X { X item->l_prev = (*list)->l_prev; X (*list)->l_prev = item; X } X else X item->l_prev = item; X *list = item; X return(item); X} X X/* X * delete an item from a list. The item itself is left intact. It is X * the responsibility of the caller to deal with the deleted item. X */ Xl_list *deletelist(list, item) X register l_list **list; X register l_list *item; X{ X if (item == *list) X { X if (item->l_next == NULL) X *list = NULL; X else X { X *list = item->l_next; X item->l_next->l_prev = item->l_next; X } X } X else X { X item->l_prev->l_next = item->l_next; X if (item->l_next != NULL) X item->l_next->l_prev = item->l_prev; X } X return (*list); X} X X/* X * stick 'item' at the top of the 'list' ( if it isn't there X * already. X */ Xl_list *toplist(list, item) X register l_list **list; X register l_list *item; X{ X if (item == *list) X return; X item->l_prev->l_next = item->l_next; X if (item->l_next) X item->l_next->l_prev = item->l_prev; X item->l_next = (*list); X /* X * if our target is the last on the list, then X * be careful that we don't make a cycle. Since X * we want the head of the list's l_prev pointer X * to point to the last in the list, we don't X * have to do anything. X */ X if (item != (*list)->l_prev) /* NOT last on list */ X item->l_prev = (*list)->l_prev; X (*list)->l_prev = item; X *list = item; X} SHAREOF chmod 444 remote/list.c # # remote/make.base # if [ -f remote/make.base ]; then echo -n 'Hit <return> to overwrite remote/make.base or ^C to quit' read ans rm -f remote/make.base fi sed -e 's/^.//' << \SHAREOF > remote/make.base XSOBJS = change.$O file.$O fileserver.$O find.$O \ X info.$O init.$O list.$O new.$O \ X rhost.$O route.$O serverdata.$O serverdir.$O serverio.$O \ X serversyscall.$O XCFILES = change.c file.c fileserver.c find.c \ X info.c init.c list.c new.c \ X rhost.c route.c serverdata.c serverdir.c serverio.c \ X serversyscall.c X Xall: $(ALL) X X$(RFS_SERVER): $(SOBJS) X $(CC) -o $@ $(SOBJS) $(LDFLAGS) X $(XINU) $(RFS_SERVER) X$(RMTMNT): rmtmnt.$O X $(CC) -o $@ rmtmnt.$O $(LDFLAGS) X $(XINU) $(RMTMNT) X$(DEBUG): debug.$O X $(CC) -o $@ debug.$O $(LDFLAGS) X $(XINU) $(DEBUG) Xtags: $(CFILES) X ctags $(CFILES) $(INCLUDE) X$(SOBJS): $(INCLUDE) X Xinstall: all X $(INSTALL) -c -m 755 $(RFS_SERVER) $(DEST)/etc/rfs_server X $(INSTALL_RMTMNT) -c -m 0755 $(RMTMNT) $(DEST)/etc/rmtmnt SHAREOF chmod 664 remote/make.base # # remote/make.base.M68 # if [ -f remote/make.base.M68 ]; then echo -n 'Hit <return> to overwrite remote/make.base.M68 or ^C to quit' read ans rm -f remote/make.base.M68 fi sed -e 's/^.//' << \SHAREOF > remote/make.base.M68 XDEST = /usr3/mag XHOST = XINCLUDE = $(DEST)/usr/include/remote/remotefs.h server.h XCFLAGS = -G$(HOST) -O -DRFSDEBUG -DCANREMOTE -DBYTEORDER=3,2,1,0 -DREMOTEFS -DMACHTYPE=magnolia XLDFLAGS = -z XCC = cc68 XO = b XRFS_SERVER = rfs_server.x XRMTMNT = rmtmnt.x XDEBUG = debug.x XINSTALL_RMTMNT = install68 XINSTALL = install68 XALL = $(RFS_SERVER) $(RMTMNT) XXINU = xinu68 X X.SUFFIXES: X.SUFFIXES: .b .c X X.c.b: X $(CC) $(CFLAGS) $< -c SHAREOF chmod 664 remote/make.base.M68 # # remote/make.base.magnolia # if [ -f remote/make.base.magnolia ]; then echo -n 'Hit <return> to overwrite remote/make.base.magnolia or ^C to quit' read ans rm -f remote/make.base.magnolia fi sed -e 's/^.//' << \SHAREOF > remote/make.base.magnolia XHOST = tekcrl XINCLUDE = /usr/include/remote/remotefs.h server.h XO = o XCFLAGS = -G$(HOST) -O -DRFSDEBUG -DCANREMOTE -DBYTEORDER=3,2,1,0 -DREMOTEFS XLDFLAGS = -z XRFS_SERVER = rfs_server XRMTMNT = rmtmnt XDEBUG = debug XINSTALL = install68 XINSTALL_RMTMNT = install68 XDEST = XCC = cc XALL = $(RFS_SERVER) $(RMTMNT) XXINU = : SHAREOF chmod 664 remote/make.base.magnolia # # remote/make.base.pyramid # if [ -f remote/make.base.pyramid ]; then echo -n 'Hit <return> to overwrite remote/make.base.pyramid or ^C to quit' read ans rm -f remote/make.base.pyramid fi sed -e 's/^.//' << \SHAREOF > remote/make.base.pyramid XINCLUDE = ../usr.include/remote/remotefs.h server.h XO = o XLDFLAGS = -z XRFS_SERVER = rfs_server XINS_RFS_SERVER = rfs_server XRMTMNT = rmtmnt XDEBUG = debug XINSTALL_RMTMNT = install XINSTALL = install XDEST = XCC = cc XALL = $(RFS_SERVER) $(RMTMNT) XXINU = : XDEFINES = -DRFSDEBUG -DCANREMOTE -DBYTEORDER=3,2,1,0 -DREMOTEFS -I/usr/include/sys XCFLAGS = -O ${DEFINES} -I../usr.include SHAREOF chmod 644 remote/make.base.pyramid # # remote/make.base.vax # if [ -f remote/make.base.vax ]; then echo -n 'Hit <return> to overwrite remote/make.base.vax or ^C to quit' read ans rm -f remote/make.base.vax fi sed -e 's/^.//' << \SHAREOF > remote/make.base.vax XINCLUDE = ../usr.include/remote/remotefs.h server.h XO = o XLDFLAGS = -z XRFS_SERVER = rfs_server XINS_RFS_SERVER = rfs_server XRMTMNT = rmtmnt XDEBUG = debug XINSTALL_RMTMNT = install XINSTALL = install XDEST = XCC = cc XALL = $(RFS_SERVER) $(RMTMNT) XXINU = : XDEFINES = -DRFSDEBUG -DCANREMOTE -DBYTEORDER=0,1,2,3 -DREMOTEFS XCFLAGS = -O ${DEFINES} -I../usr.include SHAREOF chmod 664 remote/make.base.vax # # remote/make.base.vaxnorfs # if [ -f remote/make.base.vaxnorfs ]; then echo -n 'Hit <return> to overwrite remote/make.base.vaxnorfs or ^C to quit' read ans rm -f remote/make.base.vaxnorfs fi sed -e 's/^.//' << \SHAREOF > remote/make.base.vaxnorfs XINCLUDE = ../usr.include/remote/remotefs.h server.h XO = o XLDFLAGS = -z XRFS_SERVER = rfs_server XINS_RFS_SERVER = rfs_server XRMTMNT = rmtmnt XDEBUG = debug XINSTALL_RMTMNT = : XINSTALL = install XDEST = XCC = cc XALL = $(RFS_SERVER) XXINU = : XCFLAGS = -O -DRFSDEBUG -DBYTEORDER=0,1,2,3 -DNREMOTE=1 -I../usr.include SHAREOF chmod 664 remote/make.base.vaxnorfs # # remote/new.c # if [ -f remote/new.c ]; then echo -n 'Hit <return> to overwrite remote/new.c or ^C to quit' read ans rm -f remote/new.c fi sed -e 's/^.//' << \SHAREOF > remote/new.c X/* X * Copyright 1985, Todd Brunhoff. X * X * This software was written at Tektronix Computer Research Laboratories X * as partial fulfillment of a Master's degree at the University of Denver. X * This is not Tektronix proprietary software and should not be X * confused with any software product sold by Tektronix. No warranty is X * expressed or implied on the reliability of this software; the author, X * the University of Denver, and Tektronix, inc. accept no liability for X * any damage done directly or indirectly by this software. This software X * may be copied, modified or used in any way, without fee, provided this X * notice remains an unaltered part of the software. X * X * $Log: new.c,v $ X * Revision 2.0 85/12/07 18:21:48 toddb X * First public release. X * X */ Xstatic char *rcsid = "$Header: new.c,v 2.0 85/12/07 18:21:48 toddb Rel $"; X#include "server.h" X#include <stdio.h> X Xextern short current_pid; Xextern hosts *host; X Xusers *newuser() X{ X register users *user; X X user = (users *)malloc(sizeof(users)); X if (user == NULL) X log_fatal("cannot allocate space\n"); X bzero(user, sizeof(users)); X return(user); X} X Xhosts *newhost() X{ X register hosts *h; X X h = (hosts *)malloc(sizeof(hosts)); X if (h == NULL) X log_fatal("cannot allocate space\n"); X bzero(h, sizeof(hosts)); X h->h_cmdfd = -1; X return(h); X} X Xrusers *newruser() X{ X register rusers *ruser; X X ruser = (rusers *)malloc(sizeof(rusers)); X if (ruser == NULL) X log_fatal("cannot allocate space\n"); X bzero(ruser, sizeof(rusers)); X return(ruser); X} X Xprocess *newprocess() X{ X register process *p; X X p = (process *)malloc(sizeof(process)); X if (p == NULL) X log_fatal("cannot allocate space\n"); X bzero(p, sizeof(process)); X return(p); X} X Xfreeproc(p) X register process *p; X{ X if (p->p_execfd >= 0) X close(p->p_execfd); X free(p); X} X Xchar **newname(namelist, name) X register char **namelist; X register char *name; X{ X register long i = 0; X X if (namelist == NULL) X namelist = (char **)malloc(sizeof(char *) * 2); X else X { X /* X * count the elements in the list now. X */ X for (i=0; namelist && namelist[i]; i++) ; X X namelist = (char **)realloc(namelist, sizeof(char *) * (i+2)); X } X namelist[ i++ ] = copy(name); X namelist[ i ] = NULL; X return(namelist); X} X X/* X * Add a group to 'user' unless he has exceeded the limit or the group X * is already in his domain. X */ Xaddgroup(user, gid) X register users *user; X register short gid; X{ X register long i = 0, X *gr = user->u_local_groups; X X for (i=0; i < user->u_numgroups; i++) X if (gr[ i ] == gid) X return; X if (i >= NGROUPS) X return; X gr[ user->u_numgroups++ ] = gid; X} X Xprocess *add_new_process(uid, pid) X register short uid, pid; X{ X register process *p; X register long i; X X debug0("allocate new proc: pid=%d uid=%d host=%s\n", X pid, uid, host->h_names[0]); X setup_proc(p = newprocess(), uid, pid); X addlist(&host->h_proclist, p); X X /* X * Initialize the file descriptors for this process. X */ X for(i=0; i<NOFILE; i++) X p->p_fds[ i ] = 0x80; /* -128 */ X X return(p); X} X Xsetup_proc(proc, uid, pid) X register process *proc; X register short uid, pid; X{ X register rusers *ruser; X X proc->p_pid = pid; X proc->p_uid = uid; X proc->p_handler = current_pid; X proc->p_returnval = 0; X proc->p_execfd = -1; X if (ruser = findremuid(&host->h_rusers, uid)) X proc->p_ruser = ruser; X else X proc->p_ruser = host->h_default_ruser; X} SHAREOF chmod 444 remote/new.c # # remote/newinit.c # if [ -f remote/newinit.c ]; then echo -n 'Hit <return> to overwrite remote/newinit.c or ^C to quit' read ans rm -f remote/newinit.c fi sed -e 's/^.//' << \SHAREOF > remote/newinit.c X/* X * Copyright 1985, Todd Brunhoff. X * X * This software was written at Tektronix Computer Research Laboratories X * as partial fulfillment of a Master's degree at the University of Denver. X * This is not Tektronix proprietary software and should not be X * confused with any software product sold by Tektronix. No warranty is X * expressed or implied on the reliability of this software; the author, X * the University of Denver, and Tektronix, inc. accept no liability for X * any damage done directly or indirectly by this software. This software X * may be copied, modified or used in any way, without fee, provided this X * notice remains an unaltered part of the software. X * X * $Log: init.c,v $ X * Revision 2.0 85/12/07 18:21:37 toddb X * First public release. X * X */ Xstatic char *rcsid = "$Header: init.c,v 2.0 85/12/07 18:21:37 toddb Rel $"; X#include "server.h" X#include <stdio.h> X#include <pwd.h> X#include <grp.h> X#include <netdb.h> X#include <fcntl.h> X#include <sys/dir.h> X#include <sys/user.h> X#include <sys/signal.h> X#include <sys/ioctl.h> X Xextern hosts *hostlist; Xextern hosts *thishost; Xextern users *userlist; Xextern users *default_user; Xextern char hostname[]; Xextern char *service; Xextern short current_uid; Xextern short current_pid; Xextern process *wildcard; Xextern struct sigvec sig_vec; Xextern struct sigvec sig_name; Xextern struct sigvec sig_alarm; Xextern struct sigvec sig_ignore; Xextern struct sigvec sig_continue; X#ifdef RFSDEBUG Xextern struct sigvec sig_debug; X#endif Xextern struct stat root; X X/* X * Initialize the host tables and user tables. X */ Xinit() X{ X long tt; X struct hostent *gethostent(); X struct passwd *getpwent(); X struct group *getgrent(); X X /* X * catch signals. X */ X sigvec(SIGHUP, &sig_ignore, (struct sigvec *)0); X sigvec(SIGINT, &sig_vec, (struct sigvec *)0); X sigvec(SIGQUIT, &sig_vec, (struct sigvec *)0); X sigvec(SIGILL, &sig_vec, (struct sigvec *)0); X#ifdef RFSDEBUG X sigvec(SIGTRAP, &sig_debug, (struct sigvec *)0); X#endif RFSDEBUG X /* SIGIOT */ X /* SIGEMT */ X /* SIGFPE */ X /* SIGKILL */ X sigvec(SIGBUS, &sig_vec, (struct sigvec *)0); X sigvec(SIGSEGV, &sig_vec, (struct sigvec *)0); X sigvec(SIGSYS, &sig_vec, (struct sigvec *)0); X sigvec(SIGPIPE, &sig_vec, (struct sigvec *)0); X sigvec(SIGALRM, &sig_alarm, (struct sigvec *)0); X sigvec(SIGTERM, &sig_vec, (struct sigvec *)0); X sigvec(SIGURG, &sig_name, (struct sigvec *)0); X /* SIGSTOP */ X /* SIGTSTP */ X /* SIGCONT */ X /* SIGCHLD */ X sigvec(SIGTTIN, &sig_vec, (struct sigvec *)0); X sigvec(SIGTTOU, &sig_vec, (struct sigvec *)0); X sigvec(SIGIO, &sig_continue, (struct sigvec *)0); X sigvec(SIGXCPU, &sig_vec, (struct sigvec *)0); X sigvec(SIGXFSZ, &sig_vec, (struct sigvec *)0); X sigvec(SIGVTALRM, &sig_vec, (struct sigvec *)0); X /* SIGPROF */ X X /* X * set up some important global values, including uid, pid, X * the pipe file descriptors for messages to and from the gateway X * server. Register as the nameserver. Get host name. Get service. X * Get root stat info. X */ X if (chdir("/") == -1) X log_fatal("cannot chdir(\"/\")\n"); X wildcard = newprocess(); X fcntl(2, F_SETFL, FAPPEND); X close(0); X close(1); X change_to_uid(0); X if (gethostname(hostname, HOSTNAMELEN) < 0 || *hostname == '\0') X log_fatal("host name not set!\n"); X if (stat("/", &root) < 0) X log_fatal("cannot stat /\n"); X#ifdef CANREMOTE X if (remotename(NM_SERVER, 0, 0, 0) < 0) X log("cannot register as nameserver\n"); X /* X * Turn off remote access, if we have any. X */ X remoteoff(NULL); X#endif X tt = open("/dev/tty", 2); X X if (tt >= 0) X { X ioctl(tt, TIOCNOTTY, 0); X close(tt); X } X setpgrp(0,0); X X initusers(); X initgroups(); X inithosts(); X initrhosts(); X} X X/* X * build the list of users on this host (where the server runs). X */ Xinitusers() X{ X register struct passwd *pw; X register users *user; X char buf[ BUFSIZ ]; X register char *pbuf = buf; X X while(pw = getpwent()) X { X if (*pw->pw_dir == '\0' || *pw->pw_name == '\0') X { X log("login \"%s\" has problems, dir=\"%s\"\n", X pw->pw_name, pw->pw_dir); X continue; X } X user = newuser(); X user->u_local_uid = pw->pw_uid; X user->u_name = copy( pw->pw_name ); X addgroup(user, pw->pw_gid); X user->u_dir = copy( pw->pw_dir ); X sprintf(pbuf, "%s/.rhosts", pw->pw_dir); X user->u_rhosts = copy( pbuf ); X addlist(&userlist, user); X } X endpwent(); X if (user = findusername(DEFAULTUSER)) X default_user = user; X else X log_fatal("The user \"%s\" must be in /etc/passwd (%s)\n", X DEFAULTUSER, "for default permissions"); X} X X/* X * Build the list of groups that each user belongs to. X */ Xinitgroups() X{ X register struct group *gr; X register users *user; X register char **p; X X X while(gr = getgrent()) X { X for (p = gr->gr_mem; *p; p++) X if (user = findusername(*p)) X addgroup(user, gr->gr_gid); X else X log("group %s: bad user=%s\n", X gr->gr_name, *p); X } X endgrent(); X} X X/* X * Then build the list of all hosts. X */ Xinithosts() X{ X register struct hostent *h; X register rusers *ruser; X register hosts *hst; X register users *user; X register long i; X boolean duplicate; X X while (h = gethostent()) X { X /* X * One physical host may have more than one physical X * address each having a unique host name associated X * with it. If we find any entry having one of its aliases X * match a previous alias, then simply fold all aliases X * into it, and continue. X */ X duplicate = FALSE; X for (i = -1; i < 0 || h->h_aliases[ i ]; i++) X { X if (i < 0) X hst = findhost(h->h_name); X else X hst = findhost(h->h_aliases[i]); X if (hst) X { X duplicate = TRUE; X break; X } X } X X /* X * If we have a redundant host... add all the names X * in; newname will remove redundant copies. X */ X if (!duplicate) X hst = newhost(); X hst->h_names = newname(hst->h_names, h->h_name); X for (i=0; h->h_aliases[ i ]; i++) X hst->h_names = newname(hst->h_names, X h->h_aliases[ i ]); X if (duplicate) X X hst->h_addr = *((struct in_addr *)(h->h_addr)); X addlist(&hostlist, hst); X X /* X * now if there exists a user on this machine having X * the same name as the name of this host (NOT AN X * ALIAS!), then that will be our defaut local user X * to map to. Be sure that we don't allow a machine X * to be mapped onto a user if the uid is real small: X * e.g. a machine named root, where all its user ids X * become root using the remote fs! X */ X user = findusername(hst->h_names[ 0 ]); X if (user && user->u_local_uid <= UID_TOO_LOW) X { X log("host/user %s: uid %d too low for alias\n", X hst->h_names[ 0 ], user->u_local_uid); X user = NULL; X } X else if (user) X { X hst->h_default_user = user; X debug2("default user for host %s (%s) is %s\n", X hst->h_names[ 0 ], X inet_ntoa(hst->h_addr), user->u_name); X } X ruser = hst->h_default_ruser = newruser(); X if (user) X ruser->r_user = user; X else X ruser->r_user = default_user; X ruser->r_uid = -1; X ruser->r_name = copy(BOGUSUSER); X } X endhostent(); X if ((thishost = findhostname(hostname)) == NULL) X log_fatal("this host (\"%s\") is not in host file\n", X hostname); X} X X/* X * Now for each user that has a .rhosts file, assemble the X * references and attach them to the appropriate host. X */ Xinitrhosts() X{ X register hosts *hst; X register rhost *rh; X register users *user; X char buf[ BUFSIZ ]; X register char *pbuf = buf; X X for (user=userlist; user; user=user->u_next) X { X setrhost(user->u_rhosts); X while (rh = getrhostent(pbuf)) X if (hst = findhostname(rh->rh_host)) X addremoteuser(hst, user, rh->rh_user); X endrhost(); X } X} X Xchar *copy(string) X register char *string; X{ X register char *ret = malloc( strlen(string)+1 ); X X if (ret == NULL) X log_fatal("cannot allocate space\n"); X strcpy(ret, string); X return(ret); X} X X/* X * Add a remote user to those recognized on a certain host. X */ Xaddremoteuser(h, user, remoteuser) X register hosts *h; X register users *user; X register char *remoteuser; X{ X register rusers *ruser; X register long old = FALSE; X X debug2("\t%s!%s --> %s ", *h->h_names, remoteuser, user->u_name); X if ((ruser = findrusername(&h->h_rusers, remoteuser)) == NULL) X { X debug2("\n"); X ruser = newruser(); X } X else X { X old = TRUE; X if (strcmp(remoteuser, user->u_name) != 0) X { X debug2("(old, ignored)\n"); X return; X } X else X debug2("(old)\n"); X } X ruser->r_name = copy(remoteuser); X ruser->r_uid = -1; X ruser->r_user = user; X if (! old) X addlist(&h->h_rusers, ruser); X} SHAREOF chmod 664 remote/newinit.c # # remote/rhost.c # if [ -f remote/rhost.c ]; then echo -n 'Hit <return> to overwrite remote/rhost.c or ^C to quit' read ans rm -f remote/rhost.c fi sed -e 's/^.//' << \SHAREOF > remote/rhost.c X/* X * Copyright 1985, Todd Brunhoff. X * X * This software was written at Tektronix Computer Research Laboratories X * as partial fulfillment of a Master's degree at the University of Denver. X * This is not Tektronix proprietary software and should not be X * confused with any software product sold by Tektronix. No warranty is X * expressed or implied on the reliability of this software; the author, X * the University of Denver, and Tektronix, inc. accept no liability for X * any damage done directly or indirectly by this software. This software X * may be copied, modified or used in any way, without fee, provided this X * notice remains an unaltered part of the software. X * X * $Log: rhost.c,v $ X * Revision 2.0 85/12/07 18:21:52 toddb X * First public release. X * X */ Xstatic char *rcsid = "$Header: rhost.c,v 2.0 85/12/07 18:21:52 toddb Rel $"; X#include <stdio.h> X#include "server.h" X Xstatic char *rhostpath; Xstatic FILE *fd; Xstatic rhost rh; X Xsetrhost(path) X register char *path; X{ X extern int errno; X X if ((fd = fopen(path, "r")) != 0) X debug2("rhost %s\n", path); X errno = 0; X} X Xrhost *getrhostent(buf) X register char *buf; X{ X register char *p; X X while (1) X { X if (fd == NULL || fgets(buf, BUFSIZ, fd) == NULL) X return(NULL); X X /* X * assign the first token to rh_host and then look for the X * second token on the line. If there is none, then X * don't return this entry because we can never map X * a remote user id name of "" to anything meaningful. X */ X rh.rh_host = buf; X for (p=buf; *p && *p != ' ' && *p != '\n'; p++) ; X if (*p == '\n' || *p == '\0') X continue; X X /* X * remove the newline on the end X */ X rh.rh_user = p+1; X *p = '\0'; X for (p++; *p && *p != ' ' && *p != '\n'; p++) ; X *p = '\0'; X break; X } X return(&rh); X} X Xendrhost() X{ X if (fd) X { X fclose(fd); X fd = NULL; X } X} SHAREOF chmod 444 remote/rhost.c # # remote/rmtmnt.c # if [ -f remote/rmtmnt.c ]; then echo -n 'Hit <return> to overwrite remote/rmtmnt.c or ^C to quit' read ans rm -f remote/rmtmnt.c fi sed -e 's/^.//' << \SHAREOF > remote/rmtmnt.c X/* X * Copyright 1985, Todd Brunhoff. X * X * This software was written at Tektronix Computer Research Laboratories X * as partial fulfillment of a Master's degree at the University of Denver. X * This is not Tektronix proprietary software and should not be X * confused with any software product sold by Tektronix. No warranty is X * expressed or implied on the reliability of this software; the author, X * the University of Denver, and Tektronix, inc. accept no liability for X * any damage done directly or indirectly by this software. This software X * may be copied, modified or used in any way, without fee, provided this X * notice remains an unaltered part of the software. X * X * $Log: rmtmnt.c,v $ X * Revision 2.0 85/12/07 18:21:56 toddb X * First public release. X * X */ Xstatic char *rcsid = "$Header: rmtmnt.c,v 2.0 85/12/07 18:21:56 toddb Rel $"; X#include "server.h" X#include <stdio.h> X#include <sys/file.h> X#include <netdb.h> X#include <signal.h> X#include <setjmp.h> X#include <nlist.h> X Xextern int errno; /* for errors */ Xchar *service; /* service name */ Xchar byteorder[4] = { BYTEORDER }; X X/* X * for slow or dead remote hosts, we catch alarms. X */ Xint onalrm(); Xstruct sigvec vec = { onalrm, 0, 0 }; X X/* X * Displaying current mount points requires that we read kernel space. X */ Xstruct nlist nl[] = { X#ifdef magnolia X { "remote_info" }, X#else X { "_remote_info" }, X#endif X { "" }, X}; X#ifdef magnolia Xchar *kernel = "/magix"; X#else Xchar *kernel = "/vmunix"; X#endif X Xmain(argc, argv) X int argc; X char **argv; X{ X long generic = FALSE, X unmount = FALSE; X char *mntpt = NULL, X *host = NULL; X X /* X * Parse the args. X */ X for (argv++, argc--; argc; argv++, argc--) X { X if (**argv != '-') X break; X switch(argv[0][1]) { X case 's': /* service name */ X if (argv[0][2]) X service = argv[0]+2; X else X argv++, argc--, service = argv[0]; X break; X case 'g': /* Make this a generic mount point */ X generic = TRUE; X break; X case 'u': /* unmount this mount point */ X unmount = TRUE; X break; X default: X fprintf(stderr, "unknown option = %s\n", *argv); X usage(); X exit(1); X } X } X X if (! generic && ! unmount && argc-- > 0) X host = *argv++; X if (argc-- > 0) X { X mntpt = *argv++; X if (*mntpt != '/') X { X fprintf(stderr, "mount point must begin with '/'\n"); X mntpt = NULL; X } X } X else X { X show(); X exit(0); X } X X if (argc > 0 X || (generic && unmount) X || (mntpt == NULL)) X usage(); X X if (unmount) X turnoff(mntpt); X else X turnon(mntpt, host); X} X X/* X * Display the current mount points in the kernal. X */ Xshow() X{ X long index = 0, X diff, X now, X kfd; X char buf[BUFSIZ], X *p; X struct sockaddr_in hostaddr; X struct sockaddr_in *sys; X struct servent *servp; X struct hostent *hostent; X struct remoteinfo rinfo[ R_MAXSYS ], X *rp; X struct mbuf bufs[ R_MAXSYS ], X *m; X X servp = getservbyname(REMOTE_FS_SERVER, "tcp"); X /* X * Get the address of the remote mount point information X * and read kernel memory. X */ X nlist(kernel, nl); X if(nl[0].n_type == 0) X log_fatal("no %s for namelist\n", kernel); X kfd = open("/dev/kmem", 0); X if(kfd < 0) X log_fatal("cannot open /dev/kmem\n"); X lseek(kfd, (long)nl[0].n_value, 0); X read(kfd, rinfo, sizeof(struct remoteinfo) * R_MAXSYS); X X /* X * Now get the mbufs on each mount point. X */ X m = bufs; X time(&now); X for (index=0, rp = rinfo; rp < rinfo+R_MAXSYS; rp++, index++) X { X buf[0] = '\0'; X if (rp->r_name || rp->r_mntpt) X printf("%d: ", index); X else X continue; X if (rp->r_name) X { X lseek(kfd, (long)rp->r_name, 0); X read(kfd, m, sizeof(struct mbuf)); X rp->r_name = m++; X sys = mtod(rp->r_name, struct sockaddr_in *); X hostent = gethostbyaddr(&sys->sin_addr, X sizeof (struct in_addr), sys->sin_family); X if (hostent == NULL) X { X log("no host entry for %s\n", X inet_ntoa(sys->sin_addr)); X continue; X } X bprintf(buf, "%s(%s) on ", X hostent->h_name, inet_ntoa(sys->sin_addr)); X } X else X bprintf(buf, "generic mount point "); X bprintf(buf, "%s", rp->r_mntpath); X if (rp->r_mntpt == NULL) X bprintf(buf, ", implied"); X if (rp->r_name && sys->sin_port != servp->s_port) X bprintf(buf, ", port %d", sys->sin_port); X if (rp->r_sock) X bprintf(buf, ", connected"); X if (rp->r_close) X bprintf(buf, ", closing"); X if (rp->r_users) X bprintf(buf, ", %d process%s", X rp->r_users, rp->r_users > 1 ? "es" : ""); X if (rp->r_nfile) X bprintf(buf, ", %d open file%s", X rp->r_nfile, rp->r_nfile > 1 ? "s" : ""); X if (rp->r_nchdir) X bprintf(buf, ", %d chdir%s", X rp->r_nchdir, rp->r_nchdir > 1 ? "'s" : ""); X if (rp->r_opening) X bprintf(buf, ", opening"); X if (rp->r_failed) X { X bprintf(buf, ", connect failed, retry "); X diff = rp->r_age - now; X if (diff <= 0) X bprintf(buf, "time reached"); X else X { X bprintf(buf, "in "); X if (diff / 60) X bprintf(buf, "%d minute%s", diff/60, X (diff/60) > 1 ? "s" : ""); X if (diff / 60 && diff % 60) X bprintf(buf, " and "); X if (diff % 60) X bprintf(buf, "%d second%s", diff%60, X (diff%60) > 1 ? "s" : ""); X } X } X else if(rp->r_sock == NULL && rp->r_age) X { X bprintf(buf, ", last closed %s", X ctime(&rp->r_age)); X buf[ strlen(buf)-1 ] = '\0'; /* remove newline */ X } X printf("%s\n", buf); X } X} X X/* X * buffer printf. i.e. do a printf into a buffer, appending to whatever X * is there. Split long lines. X */ Xbprintf(buf, x0,x1,x2,x3,x4,x5,x6,x7,x8,x9) X char *buf; X{ X char xbuf[ BUFSIZ ], X *pfrom, *pto, c; X long col; X X sprintf(xbuf, x0,x1,x2,x3,x4,x5,x6,x7,x8,x9); X for (pto = buf; *pto; pto++) ; X for (pfrom = xbuf, col=0; *pfrom; pfrom++, col++) X { X c = *pfrom; X *pto++ = c; X if (c == '\n') X col = -1; X else if (c == ' ' && col > 50) X { X *pto++ = '\n'; X *pto++ = '\t'; X col = 7; X } X } X *pto = '\0'; X} X X/* X * Do a mount. X */ Xturnon(mntpt, host) X char *mntpt, *host; X{ X int index, ret, fdout, fdin; X struct message msgbuf, *msg = &msgbuf; X struct sockaddr_in sys; X char buf[ BUFSIZ ]; X X if (strlen(mntpt) >= R_MNTPATHLEN) X log_fatal("mount point must be < %d chars\n", R_MNTPATHLEN); X X /* X * Connect to the machine and send it our byte order and X * password file. X */ X if (host) X { X if ((fdout = tcpname(&sys, host)) < 0) X log("system unreachable now..."); X index = remoteon(mntpt, strlen(mntpt)+1, X &sys, sizeof(struct sockaddr_in)); X } X else X index = remoteon(mntpt, strlen(mntpt), 0, 0); X if (index == -1) X log_fatal("cant mount remote fs\n"); X else if (host && fdout < 0) X log(" system mounted anyway\n"); X if (host == NULL) X return; X if ((fdin = open("/etc/passwd", O_RDONLY)) == -1) X log_fatal("can't open /etc/passwd\n"); X msg->m_syscall = htons(RSYS_nosys); X msg->m_hdlen = htons(R_MINRMSG + sizeof(long)); X msg->m_totlen = htonl(R_MINRMSG + sizeof(long)); X msg->m_args[0] = htonl(CMD_MOUNT); X write(fdout, msg, R_MINRMSG + sizeof(long)); X write(fdout, byteorder, 4); X while ((ret = read(fdin, buf, BUFSIZ)) > 0) X write(fdout, buf, ret); X close(fdout); X close(fdin); X return; X} X Xturnoff(mntpt) X char *mntpt; X{ X int index, fd; X X index = remoteoff(mntpt); X if (index == -1) X log_fatal("can't unmount remote fs\n"); X close(fd); X} X Xusage() X{ X fprintf(stderr, "Usage:\t%s\n\t%s\n\t%s\n", X "rmtmnt [-sservicename] -g path", X "rmtmnt [-sservicename] host path", X "rmtmnt"); X exit(1); X} X Xtcpname(sin, host) X struct sockaddr_in *sin; X char *host; X{ X struct servent *servp; X struct hostent *hostp; X int s; X X servp = getservbyname(service ? service : REMOTE_FS_SERVER, "tcp"); X X if (servp == NULL) { X fprintf(stderr, "%s: unknown service\n", REMOTE_FS_SERVER); X exit(1); X } X X hostp = gethostbyname(host); X if (hostp == NULL) { X fprintf(stderr, "%s: unknown host\en", host); X exit(1); X } X bzero((char *)sin, sizeof (struct sockaddr_in)); X bcopy(hostp->h_addr, (char *)&sin->sin_addr, hostp->h_length); X sin->sin_family = hostp->h_addrtype; X sin->sin_port = servp->s_port; X X /* X * Ok, now make sure that the connection will work X */ X if (sigvec(SIGALRM, &vec, (struct sigvec *)0) == -1) { X perror("signals"); X return(-1); X } X s = socket(AF_INET, SOCK_STREAM, 0); X if (s < 0) X return(-1); X alarm(5); X if(connect(s, sin, sizeof(struct sockaddr_in)) < 0) { X alarm(0); X return(-1); X } X alarm(0); X return(s); X} X Xonalrm(sig) X{ X fprintf(stderr, "timeout: "); X} X Xlog_fatal(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9) X{ X log(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9); X exit(1); X} X Xlog(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9) X{ X if (errno) X perror("rmtmnt"); X errno = 0; X fprintf(stderr, x0,x1,x2,x3,x4,x5,x6,x7,x8,x9); X} SHAREOF chmod 444 remote/rmtmnt.c # # remote/route.c # if [ -f remote/route.c ]; then echo -n 'Hit <return> to overwrite remote/route.c or ^C to quit' read ans rm -f remote/route.c fi sed -e 's/^.//' << \SHAREOF > remote/route.c X/* X * Copyright 1985, Todd Brunhoff. X * X * This software was written at Tektronix Computer Research Laboratories X * as partial fulfillment of a Master's degree at the University of Denver. X * This is not Tektronix proprietary software and should not be X * confused with any software product sold by Tektronix. No warranty is X * expressed or implied on the reliability of this software; the author, X * the University of Denver, and Tektronix, inc. accept no liability for X * any damage done directly or indirectly by this software. This software X * may be copied, modified or used in any way, without fee, provided this X * notice remains an unaltered part of the software. X * X * $Log: route.c,v $ X * Revision 2.2 86/01/05 18:14:47 toddb X * Added a forgotten case to gateway_listen(): S_CORRUPTED. X * X * Revision 2.1 85/12/19 15:53:23 toddb X * Changed declaration of a local variable (sigmask) because it conflicts X * with a 4.3 define. X * X * Revision 2.0 85/12/07 18:22:04 toddb X * First public release. X * X */ Xstatic char *rcsid = "$Header: route.c,v 2.2 86/01/05 18:14:47 toddb Exp $"; X#include "server.h" X#include <sys/file.h> X#include <sys/time.h> X#include <setjmp.h> X#include <errno.h> X Xextern short current_pid; Xextern short current_ppid; Xextern short gateway_server; Xextern short current_server; Xextern long blocking_servers; Xextern long to_gateway; Xextern long from_servers; Xextern long errno; Xextern boolean i_am_gateway; Xextern boolean i_have_control; Xextern boolean gateway_needs_control; Xextern boolean route_to_gateway; Xextern boolean watch_for_lock; Xextern boolean i_am_asleep; Xextern hosts *host; X X/* X * Reroute to the server whose pid is 'pid'. X */ Xreroute(pid, msg) X register short pid; X register struct message *msg; X{ X if (route_to_gateway) X { X debug5("routing changed from server %d to gateway\n", pid); X route_to_gateway = FALSE; X pid = gateway_server; X } X watch_for_lock = gateway_needs_control = FALSE; X dont_gobble_msg(msg); X X if (pid == current_pid) X log_fatal("reroute myself???\n"); X debug5("%d waking up %d\n", current_pid, pid); X X /* X * If we are the gateway, there may be some servers that are blocking X * on a request. If so, then we lock file descriptor 2 with an X * shared lock. This tells the server to always check to see if X * the lock goes up to an exclusive lock. If so, then the server X * must then return control to the gateway. X */ X if (i_am_gateway) X { X set_label("reading messages"); X i_have_control = FALSE; X if (blocking_servers) X if (flock(2, LOCK_NB | LOCK_SH) < 0) X log_fatal("cannot lock fd 2\n"); X } X X i_am_asleep = TRUE; X if (pid == gateway_server) X say_something(S_THIS_IS_YOURS, gateway_server); X else X wake_up(pid); X slumber(FALSE); X if (! i_am_gateway) X { X /* X * Check for the lock on fd 2. But even if the gateway wants X * control, go ahead an serve this request. X */ X if (flock(2, LOCK_NB | LOCK_EX) < 0) X if (flock(2, LOCK_NB | LOCK_SH) >= 0) X { X debug5("watch for lock on each request\n"); X watch_for_lock = TRUE; X flock(2, LOCK_UN); X } X else X { X debug5("Gateway wants control\n"); X gateway_needs_control = TRUE; X } X else X flock(2, LOCK_UN); X } X} X X X/* X * Tell the gateway something. X */ Xsay_something(cmd, arg) X register long cmd, arg; X{ X gtmsgs gmsg[2]; X register gtmsgs *g = gmsg; X register long len = sizeof(gtmsgs); X X X if (cmd == S_NEWSERVER) /* actually 2 messages */ X { X g->g_server = current_ppid; X g->g_cmd = cmd; X g->g_pid = current_pid; X cmd = S_NEWPROCESS; X g++; X len += sizeof(gtmsgs); X } X g->g_server = current_pid; X g->g_cmd = cmd; X g->g_pid = arg; X X debug5("say: cmd=%d, arg=%d\n", cmd, arg); X if (write(to_gateway, gmsg, len) != len) X log_fatal("pid %d: can't write to gateway!!\n", X current_pid); X} X X/* X * Read message from servers. We do the allocation of space and maintain it. X */ Xgtmsgs *read_gtmsgs() X{ X static gtmsgs *msgs; X static long current_len, X len_needed = 10; X register long red; X register gtmsgs *g; X X /* X * Allocate space for the current read. X */ X if (current_len < len_needed) X { X if (msgs) X msgs = (gtmsgs *)realloc(msgs, X len_needed * sizeof(gtmsgs)); X else X msgs = (gtmsgs *)malloc(len_needed * sizeof(gtmsgs)); X current_len = len_needed; X } X X /* X * Now read the messages. X */ X red = read(from_servers, msgs, (current_len-1) * sizeof(gtmsgs)); X if (red % sizeof(gtmsgs) != 0) X log_fatal("partial message on read = %d\n", red); X red /= sizeof(gtmsgs); X if (red == current_len-1) X len_needed++; X msgs[ red ].g_server = 0; X#ifdef RFSDEBUG X for (g=msgs; g->g_server; g++) X debug14("red: server %d, cmd %d, pid=%d\n", X g->g_server, g->g_cmd, g->g_pid); X#endif RFSDEBUG X return(msgs); X} X X/* X * This process is called to gather incomming messages from servers out X * there with something interesting to say. We return TRUE if we have X * read a message from a process that is relinquishing control, FALSE X * otherwise. X */ Xgateway_listen() X{ X register process *proc; X register gtmsgs *msgs, *g; X short dequeue(); X register short cmd, i, pid, server; X X msgs = read_gtmsgs(); X X errno = 0; X for (g=msgs; g->g_server; g++) X { X pid = g->g_pid; X server = g->g_server; X cmd = g->g_cmd; X X switch(cmd) { X case S_NEWSERVER: /* a new server forked by another server */ X debug5("hear: %d forks new server %d\n", server, pid); X break; X case S_NEWPROCESS: /* a new process is being served */ X proc = add_new_process(0, pid); X proc->p_handler = server; X debug5("hear: pid %d serving pid %d\n", server, pid); X break; X case S_PROCEXIT: /* some server's client did an exit() call */ X debug5("hear: proc exit from server %d: pid=%d\n", X server, pid); X if ((proc = findprocess(pid, -1)) == NULL) X log("can't find pid %d!\n", pid); X else X { X deletelist(&host->h_proclist, proc); X freeproc(proc); X } X break; X case S_I_WOULD_BLOCK: /* server will block on I/O */ X debug5("hear: server %d blocks\n", server); X blocking_servers++; X goto gateway_control; X case S_ALLDONE: /* an existing server is ready to die */ X case S_EOF: /* a server got eof on command socket */ X mourne(); X debug5("hear: server %d %s... ", server, X cmd == S_ALLDONE ? "dead" : "got eof"); X for (proc=host->h_proclist; proc; proc=proc->p_next) X if (proc->p_handler == server) X { X debug5("free proc %d...", proc->p_pid); X deletelist(&host->h_proclist, proc); X freeproc(proc); X } X debug5("\n"); X /* fall through */ X case S_THIS_IS_YOURS: /* just relinquish control */ X gateway_control: X /* X * Always unlock when we have control. X */ X flock(2, LOCK_UN); X if (cmd == S_THIS_IS_YOURS) X debug5("hear: server %d gives us control\n", X server); X /* X * Now that we have control, see about dequeing X * a server that is ready to go. If there is one, X * Then change this message so that it looks like X * a message from ourself saying to reroute to X * 'server'. X */ X server = dequeue(); X if (server > 0) X { X debug5("server %d ready to go\n", server); X wake_up(server); X } X else X { X debug5("gateway pid %d continuing\n", X current_pid); X set_label("active"); X i_have_control = TRUE; X } X break; X case S_I_AM_READY: X debug5("hear: server %d ready\n", server); X blocking_servers--; X if (flock(2, LOCK_EX) < 0) X log_fatal("cannot lock fd 2\n"); X queue(server); X break; X case S_CORRUPTED: X log_fatal("corrupted input stream\n"); X break; X default: X log("unknown message from %d = %d\n", server, cmd); X break; X } X } X X return(FALSE); X} X Xwake_up(pid) X long pid; X{ X sendsig(pid, SIGIO); X} X Xsendsig(pid, sig) X long pid, X sig; X{ X register func logger; X extern long log(), log_fatal(); X X change_to_uid(0); X if (kill(pid, sig) < 0) X { X if (errno == ESRCH) X logger = log; X else X logger = log_fatal; X logger("couldn't signal %d w/ sig=%d\n", pid, sig); X return(FALSE); X } X return(TRUE); X} X Xstatic short *server_queue; Xstatic short server_len; Xstatic short last_server; X/* X * Put a server on a queue to be run again. Fifo queue. X */ Xqueue(pid) X register short pid; X{ X if (++last_server > server_len) X { X server_len++; X if (server_queue == NULL) X server_queue = (short *)malloc(sizeof(short)); X else X server_queue = (short *)realloc(server_queue, X server_len*sizeof(short)); X } X server_queue[ last_server - 1 ] = pid; X} X X/* X * Get the first server off the queue. Blech! We have to copy all the X * queue back one. X */ Xshort dequeue() X{ X register short retval, i; X X if (last_server == 0) X return(0); X retval = server_queue[ 0 ]; X for (i=1; i<last_server; i++) X server_queue[ i-1 ] = server_queue[ i ]; X last_server--; X return( retval ); X} X X/* X * Go to sleep awaiting a wakup call. Do not return until we receive it. X * However, if we are the gateway, we, of course MUST return and go X * on reading messages. X * X * Since there is a window between testing the i_am_asleep flag and doing X * the pause, in which we could be awakened, we must always jump around X * this loop using longjmp() from the interrupt routine. X */ Xslumber(forked) X boolean forked; X{ X register long signalmask; X X if (i_am_gateway) X { X set_label("reading messages"); X i_have_control = FALSE; X return; X } X set_label("asleep"); X signalmask = sigblock(1<<(SIGIO-1)); X while (i_am_asleep) X sigpause(signalmask); X sigsetmask(signalmask); X X debug5("pid %d continuing%s\n", X current_pid, forked ? "after fork" : ""); X set_label("active"); X mourne(); X} SHAREOF chmod 444 remote/route.c # # remote/server.h # if [ -f remote/server.h ]; then echo -n 'Hit <return> to overwrite remote/server.h or ^C to quit' read ans rm -f remote/server.h fi sed -e 's/^.//' << \SHAREOF > remote/server.h X/* X * Copyright 1985, Todd Brunhoff. X * X * This software was written at Tektronix Computer Research Laboratories X * as partial fulfillment of a Master's degree at the University of Denver. X * This is not Tektronix proprietary software and should not be X * confused with any software product sold by Tektronix. No warranty is X * expressed or implied on the reliability of this software; the author, X * the University of Denver, and Tektronix, inc. accept no liability for X * any damage done directly or indirectly by this software. This software X * may be copied, modified or used in any way, without fee, provided this X * notice remains an unaltered part of the software. X * X * $Header: server.h,v 2.0 85/12/07 18:22:12 toddb Rel $ X * X * $Log: server.h,v $ X * Revision 2.0 85/12/07 18:22:12 toddb X * First public release. X * X */ X#include <sys/param.h> X#include <sys/mbuf.h> X#include <sys/socket.h> X#include <netinet/in.h> X#include <remote/remotefs.h> X Xtypedef unsigned char boolean; X X/* X * The maximum number of longs in a message that we accept X */ X#define MAXMSGS ((R_MAXMBUFS*MLEN)/sizeof(long)) X/* X * The name of a host for which we have no record. And the name of the user X * to use if we don't recognize the user on the remote host. X */ X#define BOGUSHOST "unknown host" X#define BOGUSUSER "unknown user" X#define DEFAULTUSER "guest" X X/* X * The uid number below which we reserve for privilaged users. X */ X#define UID_TOO_LOW 20 X X/* X * This is to make the debug? macro work for the server. X * X * The bits and what they turn on are as follows X * 0x00000001 process switching X * 0x00000002 system calls X * 0x00000004 setuid/setgid, umask X * 0x00000008 file descriptor allocation X * 0x00000010 connections X * 0x00000020 server switching X * 0x00000040 nameserver X * 0x00000080 directory nuxi X * 0x00000100 message in and out X * 0x00000200 don't fork child for gateway (good for adb) X * 0x00000400 local/remote file decisions X * 0x00000800 don't remove log file on exit (except exit on error) X * 0x00001000 exec information X * 0x00002000 auto debug for 0x20 (server switching) X * 0x00004000 parsing messages to gateway X */ X#define rmt_debug log X#ifndef RFSDEBUG X#define dumphost() X#endif RFSDEBUG X X/* X * The size of the initial allocation for internal io buffers. X */ X#define BIGBUF (8*1024) X X/* X * other Manifest constants... X */ X#define HOSTNAMELEN 255 X X/* X * Map a file descriptor from the user's fd to our own internal fd. X */ X#define MAPFD(fd, proc) \ X (((unsigned)fd > NOFILE) ? -1 : (proc)->p_fds[ fd ] ) X/* X * requirements for different system calls. X */ X#define NEED_ZIP 0x000 /* don't need anything special */ X#define NEED_CWD 0x001 /* need the current working directory set */ X#define NEED_PERM 0x002 /* need the user and group ids set */ X#define NEED_FD 0x004 /* need a file descriptor allocated */ X#define NEED_2PATH 0x010 /* uses two paths */ X#define NEED_MYSERVER 0x020 /* must be run by the assigned server */ X#define NEED_2REMOTE 0x040 /* both paths must be remote */ X X/* X * Commands to the server sent by external programs (like rmtmnt, to mount X * a remote system. X */ X#define CMD_SERVICE 1 X#define CMD_MOUNT 2 /* here is mount information */ X#define CMD_NEEDMOUNT 3 /* give me mount information */ X#define CMD_WHOAMI 4 /* what uid am I on your host */ X X/* X * Finally, some commands that are sent to the gateway server by other X * servers. X */ X#define S_NEWSERVER 0 X#define S_NEWPROCESS 1 X#define S_ALLDONE 2 X#define S_THIS_IS_YOURS 3 X#define S_PROCEXIT 4 X#define S_EOF 5 X#define S_I_WOULD_BLOCK 6 X#define S_I_AM_READY 7 X#define S_CORRUPTED 8 X X/* X * Macros for getting the address of the paths out of the incomming message. X * Note that path1addr is for system calls that deal with only one path, X * and twopath1addr() and twopath2addr() are for system calls that have X * two paths (in the latter cases, path2 appears in the same position X * as path1 does for single path system calls). X */ X#define path1addr(msg) ((char *)&(msg)->m_args[R_PATHSTART]) X#define twopath1addr(msg) ((char *)(msg) + (msg)->m_args[R_PATHOFF]) X#define twopath2addr(msg) ((char *)&(msg)->m_args[R_PATHSTART]) X X/* X * Macro for preventing getmsg(), and thereby gobble_last_msg() from X * reading the last message. This is used when control is being passed X * from one server to another. X */ X#define dont_gobble_msg(msg) (msg)->m_totlen = 0 X X/* X * Macro for determining whether a stat structure reflects the root inode X * of our machine or not. X */ X#define isroot(p) (p->st_ino == root.st_ino && p->st_dev == root.st_dev) X X/* X * This structure is one-to-one with each local user where the server runs. X * Note that the u_next and u_prev pointers must be located X * in the first and second spots of the structure, respectively so that X * they can be modified by the linked-list routines. X */ Xtypedef struct users_type users; Xstruct users_type { X users *u_next; /* pointers for linked list, both forward... */ X users *u_prev; /* ... and back. */ X char *u_name; /* The ascii name of same. */ X char *u_dir; /* login directory for same */ X char *u_rhosts; /* path of the user's rhost file */ X short u_local_uid; /* A user id number on the local host */ X long u_local_groups[NGROUPS];/* The groups this user belongs to */ X char u_numgroups; /* The number of groups in u_local_groups */ X}; X X/* X * Remote user specification. X */ Xtypedef struct ruser_type rusers; Xstruct ruser_type { X rusers *r_next; X rusers *r_prev; X short r_uid; /* Uid number on remote host ... */ X char *r_name; /* Uid name on remote host ... */ X users *r_user; /* corresponding local user */ X}; X X/* X * This is the important stuff. There is one of these structures for X * each pid that we are providing service to. X */ Xtypedef struct process_type process; Xstruct process_type { X process *p_next; X process *p_prev; X long p_returnval; /* return value from last syscall */ X rusers *p_ruser; /* info about the owner of this pid */ X short p_pid; /* process id number on remote host */ X short p_uid; /* remote uid that was last known */ X short p_handler; /* the handler for this process */ X short p_errno; /* errno for the system call */ X char p_execfd; /* file descriptor of exec file */ X boolean p_execstarted; /* whether we have done first read */ X char p_fds[ NOFILE ];/* fd's assoc. with this pid */ X}; X X/* X * This structure keeps track of the possible hosts that may make a connection X * the the remote fs server. Note that the h_next and hprev pointers must be X * located in the first and second spots of the structure, respectively, X * so that they can be modified by the linked-list routines. X */ Xtypedef struct hosts_type hosts; Xstruct hosts_type { X hosts *h_next; X hosts *h_prev; X char **h_names; /* name (and aliases) of a host */ X rusers *h_rusers; /* the user list for this host */ X users *h_default_user;/* default local user (if defined */ X rusers *h_default_ruser;/* default when the remote user is unknown */ X long h_portnum; /* port number that we connected on */ X char *h_mntpt; /* mount point for this machine */ X process *h_proclist; /* processes we know about on this host */ X struct in_addr h_addr; /* network address */ X union h_bytes { X long hu_mounted; /* non-zero if host has been mounted */ X u_char hu_byteorder[4]; /* byte order for this host */ X } h_bytes; X#define h_mounted h_bytes.hu_mounted X#define h_byteorder h_bytes.hu_byteorder X char h_cmdfd; /* file descriptor for commands */ X boolean h_byteorderok; /* true if byte order same as ours */ X short h_serverpid; /* gateway server for this host */ X}; X X/* X * This structure is the mask structure that the linked list routines use X * to modify any linked-list type of structure. Note that l_next and l_prev X * must be in the first and second spots. X */ Xtypedef struct l_list_type l_list; Xstruct l_list_type { X l_list *l_next; X l_list *l_prev; X long l_data; /* never used */ X}; X X/* X * This structure is for convenience: it simply defines an easy way of X * storing the host/user line found in a .rhost file. X */ Xtypedef struct rhost_type rhost; Xstruct rhost_type { X char *rh_host; X char *rh_user; X}; X X/* X * Each message from the servers to the gateway, is placed into this X * structure, the "gateway message". X */ Xtypedef struct gtmsg_type gtmsgs; Xstruct gtmsg_type { X short g_server; /* server that sent the message. */ X short g_pid; /* pid of whom this message is about */ X short g_cmd; /* what this message is about */ X}; X X/* X * Finally, this is the way we keep database info on the system calls X * themselves. X */ Xtypedef struct syscallmap syscallmap; Xstruct syscallmap { X func s_server; X func s_syscall; X char s_type; X}; X Xrhost *getrhostent(); Xhosts *tcpaccept(); Xhosts *findhostaddr(); Xhosts *findhostname(); Xhosts *newhost(); Xl_list *toplist(); Xl_list *bottomlist(); Xl_list *addlist(); Xl_list *deletelist(); Xprocess *newprocess(); Xprocess *findprocess(); Xprocess *change_to_proc(); Xprocess *add_new_process(); Xusers *finduid(); Xusers *findusername(); Xusers *newuser(); Xrusers *findremuid(); Xrusers *findrusername(); Xrusers *newruser(); Xchar **newname(); Xchar *copy(); Xchar *malloc(); Xchar *realloc(); Xchar *get_data_buf(); Xshort *newshortlist(); SHAREOF chmod 444 remote/server.h # # remote/serverdata.c # if [ -f remote/serverdata.c ]; then echo -n 'Hit <return> to overwrite remote/serverdata.c or ^C to quit' read ans rm -f remote/serverdata.c fi sed -e 's/^.//' << \SHAREOF > remote/serverdata.c X/* X * Copyright 1985, Todd Brunhoff. X * X * This software was written at Tektronix Computer Research Laboratories X * as partial fulfillment of a Master's degree at the University of Denver. X * This is not Tektronix proprietary software and should not be X * confused with any software product sold by Tektronix. No warranty is X * expressed or implied on the reliability of this software; the author, X * the University of Denver, and Tektronix, inc. accept no liability for X * any damage done directly or indirectly by this software. This software X * may be copied, modified or used in any way, without fee, provided this X * notice remains an unaltered part of the software. X * X * $Log: serverdata.c,v $ X * Revision 2.0 85/12/07 18:22:20 toddb X * First public release. X * X */ Xstatic char *rcsid = "$Header: serverdata.c,v 2.0 85/12/07 18:22:20 toddb Rel $"; X#include "server.h" X#include <nlist.h> X#include <signal.h> X#include <netdb.h> X#include <sys/stat.h> X X/* X * system calls. X */ Xlong access(), chdir(), chmod(), chown(), close(), dup(), execve(), X fchmod(), fchown(), fcntl(), flock(), fork(), fstat(), fsync(), X ftruncate(), ioctl(), link(), lseek(), lstat(), mkdir(), X mknod(), open(), read(), readlink(), rename(), rmdir(), X stat(), symlink(), truncate(), unlink(), utimes(), X write(), X/* X * ...and our own routines to set up for the system calls. X */ X noop(), s_access(), s_dup(), s_execinfo(), s_execread(), s_exit(), X s_fcntl(), s_fd1(), s_fd1_plus(), s_fork(), s_ioctl(), s_lseek(), X s_open(), s_path1(), s_path1_plus(), s_path2(), s_read(), X s_readlink(), s_stat(), s_utimes(), s_write(); X Xsyscallmap smap[] = { X s_fork, noop, NEED_ZIP, /* RSYS_fork */ X s_read, read, NEED_ZIP, /* RSYS_read */ X s_write, write, NEED_ZIP, /* RSYS_write */ X s_open, open, NEED_CWD X |NEED_MYSERVER X |NEED_PERM X |NEED_FD, /* RSYS_open */ X s_fd1, close, NEED_ZIP, /* RSYS_close */ X noop, noop, NEED_CWD X |NEED_PERM X |NEED_FD, /* RSYS_creat */ X s_path2, link, NEED_CWD X |NEED_MYSERVER X |NEED_2PATH X |NEED_2REMOTE X |NEED_PERM, /* RSYS_link */ X s_path1, unlink, NEED_CWD|NEED_PERM, /* RSYS_unlink */ X s_path1, chdir, NEED_MYSERVER X |NEED_CWD X |NEED_PERM X |NEED_MYSERVER, /* RSYS_chdir */ X s_path1_plus, mknod, NEED_CWD|NEED_PERM, /* RSYS_mknod */ X s_path1_plus, chmod, NEED_CWD|NEED_PERM, /* RSYS_chmod */ X s_path1_plus, chown, NEED_CWD|NEED_PERM, /* RSYS_chown */ X s_stat, stat, NEED_CWD|NEED_PERM, /* RSYS_stat */ X s_lseek, lseek, NEED_ZIP, /* RSYS_lseek */ X s_access, access, NEED_CWD|NEED_PERM, /* RSYS_access */ X s_stat, lstat, NEED_CWD|NEED_PERM, /* RSYS_lstat */ X s_dup, dup, NEED_FD, /* RSYS_dup */ X s_ioctl, ioctl, NEED_ZIP, /* RSYS_ioctl */ X s_path2, symlink, NEED_CWD X |NEED_2PATH X |NEED_PERM, /* RSYS_symlink */ X s_readlink, readlink, NEED_CWD|NEED_PERM, /* RSYS_readlink */ X s_stat, fstat, NEED_ZIP, /* RSYS_fstat */ X s_dup, dup, NEED_FD, /* RSYS_dup2 */ X s_fd1_plus, fcntl, NEED_ZIP, /* RSYS_fcntl */ X s_fd1, fsync, NEED_ZIP, /* RSYS_fsync */ X noop, noop, NEED_ZIP, /* RSYS_readv */ X noop, noop, NEED_ZIP, /* RSYS_writev */ X s_fd1_plus, fchown, NEED_PERM, /* RSYS_fchown */ X s_fd1_plus, fchmod, NEED_PERM, /* RSYS_fchmod */ X s_path2, rename, NEED_MYSERVER X |NEED_2REMOTE X |NEED_CWD X |NEED_2PATH X |NEED_PERM, /* RSYS_rename */ X s_path1_plus, truncate, NEED_CWD|NEED_PERM, /* RSYS_truncate */ X s_fd1_plus, ftruncate,NEED_ZIP, /* RSYS_ftruncate */ X s_fd1_plus, flock, NEED_ZIP, /* RSYS_flock */ X s_path1_plus, mkdir, NEED_CWD|NEED_PERM, /* RSYS_mkdir */ X s_path1, rmdir, NEED_CWD|NEED_PERM, /* RSYS_rmdir */ X s_utimes, utimes, NEED_CWD|NEED_PERM, /* RSYS_utimes */ X s_exit, noop, NEED_ZIP, /* RSYS_exit */ X s_fork, noop, NEED_ZIP, /* RSYS_Vfork */ X s_execinfo, noop, NEED_MYSERVER X |NEED_CWD X |NEED_PERM, /* RSYS_execinfo */ X s_execread, noop, NEED_PERM, /* RSYS_execread */ X noop, noop, NEED_ZIP, /* RSYS_execve */ X noop, noop, NEED_ZIP, /* RSYS_nosys */ X s_lseek, lseek, NEED_ZIP, /* RSYS_qlseek */ X}; X Xchar *syscallnames[] = { X "fork", X "read", X "write", X "open", X "close", X "creat", X "link", X "unlink", X "chdir", X "mknod", X "chmod", X "chown", X "stat", X "lseek", X "access", X "lstat", X "dup", X "ioctl", X "symlink", X "readlink", X "fstat", X "dup2", X "fcntl", X "fsync", X "readv", X "writev", X "fchown", X "fchmod", X "rename", X "truncate", X "ftruncate", X "flock", X "mkdir", X "rmdir", X "utimes", X "exit", X "vfork", X "execinfo", X "execread", X "execve", X "nosys", X "quick lseek" X}; X Xchar hostname[ HOSTNAMELEN ];/* our host name */ Xchar mntpt[ MAXPATHLEN ]; /* mount point for client */ Xchar *program; /* name of this program */ Xchar *last_argaddr; /* last address that we can scribble on */ Xchar *service = REMOTE_FS_SERVER; /* name of alternate internet service */ Xchar *stdlogfile = "/usr/tmp/rfs_log"; /* log file for server */ Xchar *logfile; Xlong serviceport; /* port number for service */ Xlong remote_debug; /* level of debug output */ Xshort current_uid; /* whatever uid we are, right now */ Xshort current_pid; /* whatever pid we are, right now */ Xshort current_ppid; /* our parent server */ Xshort current_umask; /* whatever umask we have, right now */ Xshort current_server; /* server that has control right now */ Xshort gateway_server; /* pid of our gateway */ Xshort last_sentry; /* previous sentry server (if non-zero) */ Xlong fds_in_use; /* number of total file descriptors open */ Xlong to_gateway; /* file descriptor for messages to gateway */ Xlong so_listen; /* socket for listening for connections */ Xlong from_servers; /* file descriptor for messages from servers */ Xlong blocking_servers; /* number of servers waiting for I/O */ Xhosts *hostlist; /* all the hosts we know of */ Xhosts *host; /* the current host that we talk to */ Xhosts *thishost; /* host pointer for this machine */ Xusers *userlist; /* all the users on this host we know of */ Xusers *default_user; /* default user to map unknown clients to */ Xprocess *wildcard; /* wildcard process for easy requests */ Xboolean i_am_gateway = TRUE; /* whether we are the gateway server */ Xboolean i_have_control = TRUE; /* whether the gateway server has control of */ X /* the command socket */ Xboolean i_am_asleep; /* whether we are sleeping or not */ Xboolean gateway_needs_control; /* True if gateway wants control back */ Xboolean watch_for_lock; /* True if we need to watch for lock on fd 2 */ Xboolean route_to_gateway; /* True if we should route to gateway */ Xboolean in_root_directory = TRUE;/* whether we are at root directory or not */ Xstruct stat filetypes[ NOFILE ]; /* file types for open files */ X Xchar byteorder[4] = { BYTEORDER }; Xlong catch(), X nameserver(), X wakeup_call(), X alarmsig(); X Xstruct sigvec sig_continue = { X wakeup_call, X 1<<(SIGIO -1), X 0 X}; X Xstruct sigvec sig_ignore = { X (int (*)())SIG_IGN, X 1<<(SIGHUP -1), X 0 X}; X Xstruct sigvec sig_alarm = { X alarmsig, X 1<<(SIGALRM -1), X 0 X}; X Xstruct sigvec sig_name = { X nameserver, X 1<<(SIGURG -1), X 0 X}; X Xstruct sigvec sig_vec = { X catch, X (1<<(SIGINT -1)) X |(1<<(SIGQUIT-1)) X |(1<<(SIGBUS-1)) X |(1<<(SIGILL-1)) X |(1<<(SIGSEGV-1)) X |(1<<(SIGPIPE-1)) X |(1<<(SIGSYS-1)) X |(1<<(SIGTERM-1)) X |(1<<(SIGTTIN-1)) X |(1<<(SIGTTOU-1)) X |(1<<(SIGXCPU-1)) X |(1<<(SIGXFSZ-1)) X |(1<<(SIGVTALRM-1)), X 0 X}; X X#ifdef RFSDEBUG X Xlong newdebug(); X Xstruct sigvec sig_debug = { X newdebug, X (1<<(SIGTRAP -1)), X 0 X}; X#endif RFSDEBUG X Xstruct stat root; /* stat info for root directory */ SHAREOF chmod 444 remote/serverdata.c # # remote/serverdir.c # if [ -f remote/serverdir.c ]; then echo -n 'Hit <return> to overwrite remote/serverdir.c or ^C to quit' read ans rm -f remote/serverdir.c fi sed -e 's/^.//' << \SHAREOF > remote/serverdir.c X/* X * Copyright 1985, Todd Brunhoff. X * X * This software was written at Tektronix Computer Research Laboratories X * as partial fulfillment of a Master's degree at the University of Denver. X * This is not Tektronix proprietary software and should not be X * confused with any software product sold by Tektronix. No warranty is X * expressed or implied on the reliability of this software; the author, X * the University of Denver, and Tektronix, inc. accept no liability for X * any damage done directly or indirectly by this software. This software X * may be copied, modified or used in any way, without fee, provided this X * notice remains an unaltered part of the software. X * X * $Log: serverdir.c,v $ X * Revision 2.0 85/12/07 18:22:28 toddb X * First public release. X * X */ Xstatic char *rcsid = "$Header: serverdir.c,v 2.0 85/12/07 18:22:28 toddb Rel $"; X#include "server.h" X#include <sys/dir.h> X#include <sys/stat.h> X#include <errno.h> X Xextern hosts *host; Xextern long errno; Xextern char byteorder[]; Xextern struct stat filetypes[]; X X/* X * Check to see type open file type... we may have to massage input X * it if the user wants to read this file descriptor and it is a directory. X */ Xcheckfiletype(fd) X register int fd; X{ X struct stat statb, *statp = &statb; X X if (fd < 0) X return; X fstat(fd, statp); X filetypes[ fd ] = statb; X} X X/* X * If byte-ordering is different between this machine and our client, X * the directories must be massaged into the right byte order. X */ Xfixdir(fd, buf, size) X register long size, X fd; X register char *buf; X{ X register struct direct *dirp; X register char *next, *last; X register u_char *clientorder = host->h_byteorder; X short fixshort(); X X if (size < 0) X return(errno); X if (fd >= NOFILE || (filetypes[fd].st_mode & S_IFDIR) == 0) X return(0); X X /* X * we don't know this client's byteorder... can't do it right X */ X if (!host->h_mounted) X return(EIO); X dirp = (struct direct *)buf; X last = buf; X debug7("nuxi directory entry buf=0%x, size=%d, end @%x\n", X buf, size, buf+size); X while(last < buf + size && dirp->d_reclen) X { X dirp = (struct direct *)last; X next = last + dirp->d_reclen; X X debug7("dir @0x%x (next+%d @0x%x): %x %x %x %s -->", X last, dirp->d_reclen, next, X dirp->d_ino, X (unsigned)dirp->d_reclen, X (unsigned)dirp->d_namlen, X dirp->d_name); X dirp->d_ino = fixlong(clientorder, &dirp->d_ino); X dirp->d_reclen = fixshort(clientorder, &dirp->d_reclen); X dirp->d_namlen = fixshort(clientorder, &dirp->d_namlen); X debug7(" %x %x %x %s\n", X dirp->d_ino, X (unsigned)dirp->d_reclen, X (unsigned)dirp->d_namlen, X dirp->d_name); X last = next; X } X return(0); X} X Xfixlong(clto, from) X register char *clto, /* clients byte order */ X *from; /* data to be fixed */ X{ X register char *srvo, /* server's byte order */ X *to; X long result; X X to = (char *)&result; X srvo = byteorder; X to[ clto[0] ] = from[ srvo[0] ]; X to[ clto[1] ] = from[ srvo[1] ]; X to[ clto[2] ] = from[ srvo[2] ]; X to[ clto[3] ] = from[ srvo[3] ]; X return(result); X} X Xshort fixshort(clto, from) X register char *clto, /* clients byte order */ X *from; /* data to be fixed */ X{ X register char *srvo, /* server's byte order */ X *to; X short result; X X to = (char *)&result; X srvo = byteorder; X to[ clto[0]&0x1 ] = from[ srvo[0]&0x1 ]; X to[ clto[1]&0x1 ] = from[ srvo[1]&0x1 ]; X return(result); X} SHAREOF chmod 444 remote/serverdir.c