projects / unix-history / blobdiff
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
new subnets, interface addressing
[unix-history] / usr / src / usr.bin / sccs / sccs.c
diff --git a/usr/src/usr.bin/sccs/sccs.c b/usr/src/usr.bin/sccs/sccs.c
index b55043f..8f3a613 100644 (file)
--- a/usr/src/usr.bin/sccs/sccs.c
+++ b/usr/src/usr.bin/sccs/sccs.c
@@ -1,9 +1,27 @@
+/*
+ * Copyright (c) 1980 Regents of the University of California.
+ * All rights reserved.  The Berkeley software License Agreement
+ * specifies the terms and conditions for redistribution.
+ */
+
+#ifndef lint
+char copyright[] =
+"@(#) Copyright (c) 1980 Regents of the University of California.\n\
+ All rights reserved.\n";
+#endif not lint
+
+#ifndef lint
+static char sccsid[] = "@(#)sccs.c     5.1 (Berkeley) %G%";
+#endif not lint
+
 # include <stdio.h>
 # include <stdio.h>
-# include <sys/types.h>
+# include <sys/param.h>
 # include <sys/stat.h>
 # include <sys/dir.h>
 # include <sys/stat.h>
 # include <sys/dir.h>
+# include <errno.h>
+# include <signal.h>
 # include <sysexits.h>
 # include <sysexits.h>
-# include <whoami.h>
+# include <pwd.h>
 
 /*
 **  SCCS.C -- human-oriented front end to the SCCS system.
 
 /*
 **  SCCS.C -- human-oriented front end to the SCCS system.
@@ -72,34 +90,46 @@
 **             UIDUSER -- determine who the user is by looking at the
 **                     uid rather than the login name -- for machines
 **                     where SCCS gets the user in this way.
 **             UIDUSER -- determine who the user is by looking at the
 **                     uid rather than the login name -- for machines
 **                     where SCCS gets the user in this way.
-**             SRCDIR -- if defined, forces the -d flag to take on
+**             SCCSDIR -- if defined, forces the -d flag to take on
 **                     this value.  This is so that the setuid
 **                     aspects of this program cannot be abused.
 **                     this value.  This is so that the setuid
 **                     aspects of this program cannot be abused.
+**                     This flag also disables the -p flag.
+**             SCCSPATH -- the default for the -p flag.
+**             MYNAME -- the title this program should print when it
+**                     gives error messages.
 **
 **     Compilation Instructions:
 **             cc -O -n -s sccs.c
 **
 **     Compilation Instructions:
 **             cc -O -n -s sccs.c
+**             The flags listed above can be -D defined to simplify
+**                     recompilation for variant versions.
 **
 **     Author:
 **             Eric Allman, UCB/INGRES
 **
 **     Author:
 **             Eric Allman, UCB/INGRES
+**             Copyright 1980 Regents of the University of California
 */
 
 */
 
-# ifdef CSVAX
-# define UIDUSER
-# endif
+\f
+/*******************  Configuration Information  ********************/
 
 
-static char SccsId[] = "@(#)sccs.c     1.28 %G%";
+# ifndef SCCSPATH
+# define SCCSPATH      "SCCS"  /* pathname in which to find s-files */
+# endif NOT SCCSPATH
 
 
-# define bitset(bit, word)     ((bit) & (word))
+# ifndef MYNAME
+# define MYNAME                "sccs"  /* name used for printing errors */
+# endif NOT MYNAME
 
 
+# ifndef PROGPATH
+# define PROGPATH(name)        "/usr/local/name"       /* place to find binaries */
+# endif PROGPATH
+
+/****************  End of Configuration Information  ****************/
+\f
 typedef char   bool;
 # define TRUE  1
 # define FALSE 0
 
 typedef char   bool;
 # define TRUE  1
 # define FALSE 0
 
-# ifdef UIDUSER
-# include <pwd.h>
-# endif UIDUSER
-
-char   MyName[] = "sccs";
+# define bitset(bit, word)     ((bool) ((bit) & (word)))
 
 struct sccsprog
 {
 
 struct sccsprog
 {
@@ -115,6 +145,10 @@ struct sccsprog
 # define FIX           2       /* fix a delta */
 # define CLEAN         3       /* clean out recreatable files */
 # define UNEDIT                4       /* unedit a file */
 # define FIX           2       /* fix a delta */
 # define CLEAN         3       /* clean out recreatable files */
 # define UNEDIT                4       /* unedit a file */
+# define SHELL         5       /* call a shell file (like PROG) */
+# define DIFFS         6       /* diff between sccs & file out */
+# define DODIFF                7       /* internal call to diff program */
+# define ENTER         8       /* enter new files */
 
 /* bits for sccsflags */
 # define NO_SDOT       0001    /* no s. on front of args */
 
 /* bits for sccsflags */
 # define NO_SDOT       0001    /* no s. on front of args */
@@ -124,14 +158,16 @@ struct sccsprog
 # define CLEANC                0       /* clean command */
 # define INFOC         1       /* info command */
 # define CHECKC                2       /* check command */
 # define CLEANC                0       /* clean command */
 # define INFOC         1       /* info command */
 # define CHECKC                2       /* check command */
+# define TELLC         3       /* give list of files being edited */
 
 
-# ifdef CSVAX
-# define PROGPATH(name)        "/usr/local/name"
-# endif CSVAX
-
-# ifndef PROGPATH
-# define PROGPATH(name)        "/usr/sccs/name"
-# endif PROGPATH
+/*
+**  Description of commands known to this program.
+**     First argument puts the command into a class.  Second arg is
+**     info regarding treatment of this command.  Third arg is a
+**     list of flags this command accepts from macros, etc.  Fourth
+**     arg is the pathname of the implementing program, or the
+**     macro definition, or the arg to a sub-algorithm.
+*/
 
 struct sccsprog SccsProg[] =
 {
 
 struct sccsprog SccsProg[] =
 {
@@ -141,20 +177,32 @@ struct sccsprog SccsProg[] =
        "delta",        PROG,   0,                      PROGPATH(delta),
        "get",          PROG,   0,                      PROGPATH(get),
        "help",         PROG,   NO_SDOT,                PROGPATH(help),
        "delta",        PROG,   0,                      PROGPATH(delta),
        "get",          PROG,   0,                      PROGPATH(get),
        "help",         PROG,   NO_SDOT,                PROGPATH(help),
+       "prs",          PROG,   0,                      PROGPATH(prs),
        "prt",          PROG,   0,                      PROGPATH(prt),
        "rmdel",        PROG,   REALUSER,               PROGPATH(rmdel),
        "prt",          PROG,   0,                      PROGPATH(prt),
        "rmdel",        PROG,   REALUSER,               PROGPATH(rmdel),
+       "val",          PROG,   0,                      PROGPATH(val),
        "what",         PROG,   NO_SDOT,                PROGPATH(what),
        "what",         PROG,   NO_SDOT,                PROGPATH(what),
-       "edit",         CMACRO, 0,                      "get -e",
-       "delget",       CMACRO, 0,                      "delta/get",
-       "deledit",      CMACRO, 0,                      "delta/get -e",
-       "fix",          FIX,    0,                      NULL,
-       "clean",        CLEAN,  REALUSER,               (char *) CLEANC,
-       "info",         CLEAN,  REALUSER,               (char *) INFOC,
-       "check",        CLEAN,  REALUSER,               (char *) CHECKC,
-       "unedit",       UNEDIT, 0,                      NULL,
+       "sccsdiff",     SHELL,  REALUSER,               PROGPATH(sccsdiff),
+       "edit",         CMACRO, NO_SDOT,                "get -e",
+       "delget",       CMACRO, NO_SDOT,                "delta:mysrp/get:ixbeskcl -t",
+       "deledit",      CMACRO, NO_SDOT,                "delta:mysrp -n/get:ixbskcl -e -t -g",
+       "fix",          FIX,    NO_SDOT,                NULL,
+       "clean",        CLEAN,  REALUSER|NO_SDOT,       (char *) CLEANC,
+       "info",         CLEAN,  REALUSER|NO_SDOT,       (char *) INFOC,
+       "check",        CLEAN,  REALUSER|NO_SDOT,       (char *) CHECKC,
+       "tell",         CLEAN,  REALUSER|NO_SDOT,       (char *) TELLC,
+       "unedit",       UNEDIT, NO_SDOT,                NULL,
+       "diffs",        DIFFS,  NO_SDOT|REALUSER,       NULL,
+       "-diff",        DODIFF, NO_SDOT|REALUSER,       PROGPATH(bdiff),
+       "print",        CMACRO, 0,                      "prt -e/get -p -m -s",
+       "branch",       CMACRO, NO_SDOT,
+               "get:ixrc -e -b/delta: -s -n -ybranch-place-holder/get:pl -e -t -g",
+       "enter",        ENTER,  NO_SDOT,                NULL,
+       "create",       CMACRO, NO_SDOT,                "enter/get:ixbeskcl -t",
        NULL,           -1,     0,                      NULL
 };
 
        NULL,           -1,     0,                      NULL
 };
 
+/* one line from a p-file */
 struct pfile
 {
        char    *p_osid;        /* old SID */
 struct pfile
 {
        char    *p_osid;        /* old SID */
@@ -162,25 +210,75 @@ struct pfile
        char    *p_user;        /* user who did edit */
        char    *p_date;        /* date of get */
        char    *p_time;        /* time of get */
        char    *p_user;        /* user who did edit */
        char    *p_date;        /* date of get */
        char    *p_time;        /* time of get */
+       char    *p_aux;         /* extra info at end */
 };
 
 };
 
-char   *SccsPath = "SCCS";     /* pathname of SCCS files */
-# ifdef SRCDIR
-char   *SccsDir = SRCDIR;      /* directory to begin search from */
+char   *SccsPath = SCCSPATH;   /* pathname of SCCS files */
+# ifdef SCCSDIR
+char   *SccsDir = SCCSDIR;     /* directory to begin search from */
 # else
 # else
-char   *SccsDir = "";          /* directory to begin search from */
+char   *SccsDir = "";
 # endif
 # endif
+char   MyName[] = MYNAME;      /* name used in messages */
+int    OutFile = -1;           /* override output file for commands */
 bool   RealUser;               /* if set, running as real user */
 # ifdef DEBUG
 bool   Debug;                  /* turn on tracing */
 # endif
 bool   RealUser;               /* if set, running as real user */
 # ifdef DEBUG
 bool   Debug;                  /* turn on tracing */
 # endif
-
+# ifndef V6
+extern char    *getenv();
+# endif V6
+
+char *gstrcat(), *strcat();
+char *gstrncat(), *strncat();
+char *gstrcpy(), *strcpy();
+#define        FBUFSIZ BUFSIZ
+#define        PFILELG 120
+\f
 main(argc, argv)
        int argc;
        char **argv;
 {
        register char *p;
        extern struct sccsprog *lookup();
 main(argc, argv)
        int argc;
        char **argv;
 {
        register char *p;
        extern struct sccsprog *lookup();
+       register int i;
+# ifndef V6
+# ifndef SCCSDIR
+       register struct passwd *pw;
+       extern struct passwd *getpwnam();
+       char buf[FBUFSIZ];
+
+       /* pull "SccsDir" out of the environment (possibly) */
+       p = getenv("PROJECTDIR");
+       if (p != NULL && p[0] != '\0')
+       {
+               if (p[0] == '/')
+                       SccsDir = p;
+               else
+               {
+                       pw = getpwnam(p);
+                       if (pw == NULL)
+                       {
+                               usrerr("user %s does not exist", p);
+                               exit(EX_USAGE);
+                       }
+                       gstrcpy(buf, pw->pw_dir, sizeof(buf));
+                       gstrcat(buf, "/src", sizeof(buf));
+                       if (access(buf, 0) < 0)
+                       {
+                               gstrcpy(buf, pw->pw_dir, sizeof(buf));
+                               gstrcat(buf, "/source", sizeof(buf));
+                               if (access(buf, 0) < 0)
+                               {
+                                       usrerr("project %s has no source!", p);
+                                       exit(EX_USAGE);
+                               }
+                       }
+                       SccsDir = buf;
+               }
+       }
+# endif SCCSDIR
+# endif V6
 
        /*
        **  Detect and decode flags intended for this program.
 
        /*
        **  Detect and decode flags intended for this program.
@@ -206,13 +304,17 @@ main(argc, argv)
                                RealUser++;
                                break;
 
                                RealUser++;
                                break;
 
-# ifndef SRCDIR
+# ifndef SCCSDIR
                          case 'p':             /* path of sccs files */
                                SccsPath = ++p;
                          case 'p':             /* path of sccs files */
                                SccsPath = ++p;
+                               if (SccsPath[0] == '\0' && argv[1] != NULL)
+                                       SccsPath = *++argv;
                                break;
 
                          case 'd':             /* directory to search from */
                                SccsDir = ++p;
                                break;
 
                          case 'd':             /* directory to search from */
                                SccsDir = ++p;
+                               if (SccsDir[0] == '\0' && argv[1] != NULL)
+                                       SccsDir = *++argv;
                                break;
 # endif
 
                                break;
 # endif
 
@@ -231,112 +333,273 @@ main(argc, argv)
                        SccsPath = ".";
        }
 
                        SccsPath = ".";
        }
 
-       command(argv, FALSE);
-       exit(EX_OK);
+       i = command(argv, FALSE, "");
+       exit(i);
 }
 }
+\f
+/*
+**  COMMAND -- look up and perform a command
+**
+**     This routine is the guts of this program.  Given an
+**     argument vector, it looks up the "command" (argv[0])
+**     in the configuration table and does the necessary stuff.
+**
+**     Parameters:
+**             argv -- an argument vector to process.
+**             forkflag -- if set, fork before executing the command.
+**             editflag -- if set, only include flags listed in the
+**                     sccsklets field of the command descriptor.
+**             arg0 -- a space-seperated list of arguments to insert
+**                     before argv.
+**
+**     Returns:
+**             zero -- command executed ok.
+**             else -- error status.
+**
+**     Side Effects:
+**             none.
+*/
 
 
-command(argv, forkflag)
+command(argv, forkflag, arg0)
        char **argv;
        bool forkflag;
        char **argv;
        bool forkflag;
+       char *arg0;
 {
        register struct sccsprog *cmd;
        register char *p;
 {
        register struct sccsprog *cmd;
        register char *p;
-       register char *q;
-       char buf[40];
+       char buf[FBUFSIZ];
        extern struct sccsprog *lookup();
        extern struct sccsprog *lookup();
-       char *nav[200];
-       char **avp;
+       char *nav[1000];
+       char **np;
+       register char **ap;
        register int i;
        register int i;
+       register char *q;
        extern bool unedit();
        extern bool unedit();
+       int rval = 0;
+       extern char *index();
+       extern char *makefile();
+       char *editchs;
+       extern char *tail();
 
 # ifdef DEBUG
        if (Debug)
        {
 
 # ifdef DEBUG
        if (Debug)
        {
-               printf("command:\n");
-               for (avp = argv; *avp != NULL; avp++)
-                       printf("    \"%s\"\n", *avp);
+               printf("command:\n\t\"%s\"\n", arg0);
+               for (np = argv; *np != NULL; np++)
+                       printf("\t\"%s\"\n", *np);
        }
 # endif
 
        }
 # endif
 
+       /*
+       **  Copy arguments.
+       **      Copy from arg0 & if necessary at most one arg
+       **      from argv[0].
+       */
+
+       np = ap = &nav[1];
+       editchs = NULL;
+       for (p = arg0, q = buf; *p != '\0' && *p != '/'; )
+       {
+               *np++ = q;
+               while (*p == ' ')
+                       p++;
+               while (*p != ' ' && *p != '\0' && *p != '/' && *p != ':')
+                       *q++ = *p++;
+               *q++ = '\0';
+               if (*p == ':')
+               {
+                       editchs = q;
+                       while (*++p != '\0' && *p != '/' && *p != ' ')
+                               *q++ = *p;
+                       *q++ = '\0';
+               }
+       }
+       *np = NULL;
+       if (*ap == NULL)
+               *np++ = *argv++;
+
        /*
        **  Look up command.
        /*
        **  Look up command.
-       **      At this point, argv points to the command name.
+       **      At this point, *ap is the command name.
        */
 
        */
 
-       cmd = lookup(argv[0]);
+       cmd = lookup(*ap);
        if (cmd == NULL)
        {
        if (cmd == NULL)
        {
-               usrerr("Unknown command \"%s\"", argv[0]);
-               exit(EX_USAGE);
+               usrerr("Unknown command \"%s\"", *ap);
+               return (EX_USAGE);
        }
 
        }
 
+       /*
+       **  Copy remaining arguments doing editing as appropriate.
+       */
+
+       for (; *argv != NULL; argv++)
+       {
+               p = *argv;
+               if (*p == '-')
+               {
+                       if (p[1] == '\0' || editchs == NULL || index(editchs, p[1]) != NULL)
+                               *np++ = p;
+               }
+               else
+               {
+                       if (!bitset(NO_SDOT, cmd->sccsflags))
+                               p = makefile(p);
+                       if (p != NULL)
+                               *np++ = p;
+               }
+       }
+       *np = NULL;
+
        /*
        **  Interpret operation associated with this command.
        */
 
        switch (cmd->sccsoper)
        {
        /*
        **  Interpret operation associated with this command.
        */
 
        switch (cmd->sccsoper)
        {
+         case SHELL:           /* call a shell file */
+               *ap = cmd->sccspath;
+               *--ap = "sh";
+               rval = callprog("/bin/sh", cmd->sccsflags, ap, forkflag);
+               break;
+
          case PROG:            /* call an sccs prog */
          case PROG:            /* call an sccs prog */
-               callprog(cmd->sccspath, cmd->sccsflags, argv, forkflag);
+               rval = callprog(cmd->sccspath, cmd->sccsflags, ap, forkflag);
                break;
 
          case CMACRO:          /* command macro */
                break;
 
          case CMACRO:          /* command macro */
+               /* step through & execute each part of the macro */
                for (p = cmd->sccspath; *p != '\0'; p++)
                {
                for (p = cmd->sccspath; *p != '\0'; p++)
                {
-                       avp = nav;
-                       *avp++ = buf;
-                       for (q = buf; *p != '/' && *p != '\0'; p++, q++)
-                       {
-                               if (*p == ' ')
-                               {
-                                       *q = '\0';
-                                       *avp++ = &q[1];
-                               }
-                               else
-                                       *q = *p;
-                       }
-                       *q = '\0';
-                       *avp = NULL;
-                       xcommand(&argv[1], *p != '\0', nav[0], nav[1], nav[2],
-                                nav[3], nav[4], nav[5], nav[6]);
+                       q = p;
+                       while (*p != '\0' && *p != '/')
+                               p++;
+                       rval = command(&ap[1], *p != '\0', q);
+                       if (rval != 0)
+                               break;
                }
                }
-               syserr("internal error: CMACRO");
-               exit(EX_SOFTWARE);
+               break;
 
          case FIX:             /* fix a delta */
 
          case FIX:             /* fix a delta */
-               if (strncmp(argv[1], "-r", 2) != 0)
+               if (strncmp(ap[1], "-r", 2) != 0)
                {
                        usrerr("-r flag needed for fix command");
                {
                        usrerr("-r flag needed for fix command");
+                       rval = EX_USAGE;
                        break;
                }
                        break;
                }
-               xcommand(&argv[1], TRUE, "get", "-k", NULL);
-               xcommand(&argv[1], TRUE, "rmdel", NULL);
-               xcommand(&argv[2], FALSE, "get", "-e", "-g", NULL);
-               syserr("FIX");
-               exit(EX_SOFTWARE);
+
+               /* get the version with all changes */
+               rval = command(&ap[1], TRUE, "get -k");
+
+               /* now remove that version from the s-file */
+               if (rval == 0)
+                       rval = command(&ap[1], TRUE, "rmdel:r");
+
+               /* and edit the old version (but don't clobber new vers) */
+               if (rval == 0)
+                       rval = command(&ap[2], FALSE, "get -e -g");
+               break;
 
          case CLEAN:
 
          case CLEAN:
-               clean((int) cmd->sccspath);
+               rval = clean((int) cmd->sccspath, ap);
                break;
 
          case UNEDIT:
                break;
 
          case UNEDIT:
-               i = 0;
-               for (avp = &argv[1]; *avp != NULL; avp++)
+               for (argv = np = &ap[1]; *argv != NULL; argv++)
                {
                {
-                       if (unedit(*avp))
-                               nav[i++] = *avp;
+                       if (unedit(*argv))
+                               *np++ = *argv;
+               }
+               *np = NULL;
+
+               /* get all the files that we unedited successfully */
+               if (np > &ap[1])
+                       rval = command(&ap[1], FALSE, "get");
+               break;
+
+         case DIFFS:           /* diff between s-file & edit file */
+               /* find the end of the flag arguments */
+               for (np = &ap[1]; *np != NULL && **np == '-'; np++)
+                       continue;
+               argv = np;
+
+               /* for each file, do the diff */
+               p = argv[1];
+               while (*np != NULL)
+               {
+                       /* messy, but we need a null terminated argv */
+                       *argv = *np++;
+                       argv[1] = NULL;
+                       i = dodiff(ap, tail(*argv));
+                       if (rval == 0)
+                               rval = i;
+                       argv[1] = p;
+               }
+               break;
+
+         case DODIFF:          /* internal diff call */
+               setuid(getuid());
+               for (np = ap; *np != NULL; np++)
+               {
+                       if ((*np)[0] == '-' && (*np)[1] == 'C')
+                               (*np)[1] = 'c';
+               }
+
+               /* insert "-" argument */
+               np[1] = NULL;
+               np[0] = np[-1];
+               np[-1] = "-";
+
+               /* execute the diff program of choice */
+# ifndef V6
+               execvp("diff", ap);
+# endif
+               execv(cmd->sccspath, argv);
+               syserr("cannot exec %s", cmd->sccspath);
+               exit(EX_OSERR);
+
+         case ENTER:           /* enter new sccs files */
+               /* skip over flag arguments */
+               for (np = &ap[1]; *np != NULL && **np == '-'; np++)
+                       continue;
+               argv = np;
+
+               /* do an admin for each file */
+               p = argv[1];
+               while (*np != NULL)
+               {
+                       printf("\n%s:\n", *np);
+                       strcpy(buf, "-i");
+                       gstrcat(buf, *np, sizeof(buf));
+                       ap[0] = buf;
+                       argv[0] = tail(*np);
+                       argv[1] = NULL;
+                       rval = command(ap, TRUE, "admin");
+                       argv[1] = p;
+                       if (rval == 0)
+                       {
+                               strcpy(buf, ",");
+                               gstrcat(buf, tail(*np), sizeof(buf));
+                               if (link(*np, buf) >= 0)
+                                       unlink(*np);
+                       }
+                       np++;
                }
                }
-               nav[i] = NULL;
-               if (i > 0)
-                       xcommand(nav, FALSE, "get", NULL);
                break;
 
          default:
                syserr("oper %d", cmd->sccsoper);
                exit(EX_SOFTWARE);
        }
                break;
 
          default:
                syserr("oper %d", cmd->sccsoper);
                exit(EX_SOFTWARE);
        }
+# ifdef DEBUG
+       if (Debug)
+               printf("command: rval=%d\n", rval);
+# endif
+       return (rval);
 }
 }
-\f/*
+\f
+/*
 **  LOOKUP -- look up an SCCS command name.
 **
 **     Parameters:
 **  LOOKUP -- look up an SCCS command name.
 **
 **     Parameters:
@@ -363,25 +626,26 @@ lookup(name)
        }
        return (NULL);
 }
        }
        return (NULL);
 }
-
-
-xcommand(argv, forkflag, arg0)
-       char **argv;
-       bool forkflag;
-       char *arg0;
-{
-       register char **av;
-       char *newargv[1000];
-       register char **np;
-
-       np = newargv;
-       for (av = &arg0; *av != NULL; av++)
-               *np++ = *av;
-       for (av = argv; *av != NULL; av++)
-               *np++ = *av;
-       *np = NULL;
-       command(newargv, forkflag);
-}
+\f
+/*
+**  CALLPROG -- call a program
+**
+**     Used to call the SCCS programs.
+**
+**     Parameters:
+**             progpath -- pathname of the program to call.
+**             flags -- status flags from the command descriptors.
+**             argv -- an argument vector to pass to the program.
+**             forkflag -- if true, fork before calling, else just
+**                     exec.
+**
+**     Returns:
+**             The exit status of the program.
+**             Nothing if forkflag == FALSE.
+**
+**     Side Effects:
+**             Can exit if forkflag == FALSE.
+*/
 
 callprog(progpath, flags, argv, forkflag)
        char *progpath;
 
 callprog(progpath, flags, argv, forkflag)
        char *progpath;
@@ -389,12 +653,17 @@ callprog(progpath, flags, argv, forkflag)
        char **argv;
        bool forkflag;
 {
        char **argv;
        bool forkflag;
 {
-       register char *p;
-       register char **av;
-       extern char *makefile();
        register int i;
        auto int st;
        register int i;
        auto int st;
-       register char **nav;
+
+# ifdef DEBUG
+       if (Debug)
+       {
+               printf("callprog:\n");
+               for (i = 0; argv[i] != NULL; i++)
+                       printf("\t\"%s\"\n", argv[i]);
+       }
+# endif
 
        if (*argv == NULL)
                return (-1);
 
        if (*argv == NULL)
                return (-1);
@@ -418,44 +687,42 @@ callprog(progpath, flags, argv, forkflag)
                else if (i > 0)
                {
                        wait(&st);
                else if (i > 0)
                {
                        wait(&st);
+                       if ((st & 0377) == 0)
+                               st = (st >> 8) & 0377;
+                       if (OutFile >= 0)
+                       {
+                               close(OutFile);
+                               OutFile = -1;
+                       }
                        return (st);
                }
        }
                        return (st);
                }
        }
-
-       /*
-       **  Build new argument vector.
-       */
-
-       /* copy program filename arguments and flags */
-       nav = &argv[1];
-       av = argv;
-       while ((p = *++av) != NULL)
+       else if (OutFile >= 0)
        {
        {
-               if (!bitset(NO_SDOT, flags) && *p != '-')
-                       *nav = makefile(p);
-               else
-                       *nav = p;
-               if (*nav != NULL)
-                       nav++;
+               syserr("callprog: setting stdout w/o forking");
+               exit(EX_SOFTWARE);
        }
        }
-       *nav = NULL;
-
-       /*
-       **  Set protection as appropriate.
-       */
 
 
+       /* set protection as appropriate */
        if (bitset(REALUSER, flags))
                setuid(getuid());
        if (bitset(REALUSER, flags))
                setuid(getuid());
-       
-       /*
-       **  Call real SCCS program.
-       */
 
 
+       /* change standard input & output if needed */
+       if (OutFile >= 0)
+       {
+               close(1);
+               dup(OutFile);
+               close(OutFile);
+       }
+       
+       /* call real SCCS program */
        execv(progpath, argv);
        syserr("cannot execute %s", progpath);
        exit(EX_UNAVAILABLE);
        execv(progpath, argv);
        syserr("cannot execute %s", progpath);
        exit(EX_UNAVAILABLE);
+       /*NOTREACHED*/
 }
 }
-\f/*
+\f
+/*
 **  MAKEFILE -- make filename of SCCS file
 **
 **     If the name passed is already the name of an SCCS file,
 **  MAKEFILE -- make filename of SCCS file
 **
 **     If the name passed is already the name of an SCCS file,
@@ -486,8 +753,7 @@ makefile(name)
        char *name;
 {
        register char *p;
        char *name;
 {
        register char *p;
-       register char c;
-       char buf[512];
+       char buf[3*FBUFSIZ];
        extern char *malloc();
        extern char *rindex();
        extern bool isdir();
        extern char *malloc();
        extern char *rindex();
        extern bool isdir();
@@ -515,23 +781,30 @@ makefile(name)
        **  Create the actual pathname.
        */
 
        **  Create the actual pathname.
        */
 
+       /* first the directory part */
        if (name[0] != '/')
        {
        if (name[0] != '/')
        {
-               strcpy(buf, SccsDir);
-               strcat(buf, "/");
+               gstrcpy(buf, SccsDir, sizeof(buf));
+               gstrcat(buf, "/", sizeof(buf));
        }
        else
        }
        else
-               strcpy(buf, "");
+               gstrcpy(buf, "", sizeof(buf));
+       
+       /* then the head of the pathname */
        strncat(buf, name, p - name);
        q = &buf[strlen(buf)];
        strcpy(q, p);
        if (strncmp(p, "s.", 2) != 0 && !isdir(buf))
        {
        strncat(buf, name, p - name);
        q = &buf[strlen(buf)];
        strcpy(q, p);
        if (strncmp(p, "s.", 2) != 0 && !isdir(buf))
        {
-               strcpy(q, SccsPath);
-               strcat(buf, "/s.");
-               strcat(buf, p);
+               /* sorry, no; copy the SCCS pathname & the "s." */
+               gstrcpy(q, SccsPath, sizeof(buf));
+               gstrcat(buf, "/s.", sizeof(buf));
+
+               /* and now the end of the name */
+               gstrcat(buf, p, sizeof(buf));
        }
 
        }
 
+       /* if i haven't changed it, why did I do all this? */
        if (strcmp(buf, name) == 0)
                p = name;
 
        if (strcmp(buf, name) == 0)
                p = name;
 
@@ -558,7 +831,8 @@ isdir(name)
 
        return (stat(name, &stbuf) >= 0 && (stbuf.st_mode & S_IFMT) == S_IFDIR);
 }
 
        return (stat(name, &stbuf) >= 0 && (stbuf.st_mode & S_IFMT) == S_IFDIR);
 }
-\f/*
+\f
+/*
 **  SAFEPATH -- determine whether a pathname is "safe"
 **
 **     "Safe" pathnames only allow you to get deeper into the
 **  SAFEPATH -- determine whether a pathname is "safe"
 **
 **     "Safe" pathnames only allow you to get deeper into the
@@ -596,15 +870,17 @@ safepath(p)
        printf("You may not use full pathnames or \"..\"\n");
        return (FALSE);
 }
        printf("You may not use full pathnames or \"..\"\n");
        return (FALSE);
 }
-\f/*
+\f
+/*
 **  CLEAN -- clean out recreatable files
 **
 **     Any file for which an "s." file exists but no "p." file
 **     exists in the current directory is purged.
 **
 **     Parameters:
 **  CLEAN -- clean out recreatable files
 **
 **     Any file for which an "s." file exists but no "p." file
 **     exists in the current directory is purged.
 **
 **     Parameters:
-**             tells whether this came from a "clean", "info", or
-**             "check" command.
+**             mode -- tells whether this came from a "clean", "info", or
+**                     "check" command.
+**             argv -- the rest of the argument vector.
 **
 **     Returns:
 **             none.
 **
 **     Returns:
 **             none.
@@ -615,74 +891,188 @@ safepath(p)
 **             Exits if a "check" command.
 */
 
 **             Exits if a "check" command.
 */
 
-clean(mode)
+clean(mode, argv)
        int mode;
        int mode;
+       char **argv;
 {
 {
-       struct direct dir;
-       struct stat stbuf;
-       char buf[100];
-       char pline[120];
-       register FILE *dirfd;
+       struct direct *dir;
+       char buf[FBUFSIZ];
+       char *bufend;
+       register DIR *dirfd;
        register char *basefile;
        bool gotedit;
        register char *basefile;
        bool gotedit;
+       bool gotpfent;
        FILE *pfp;
        FILE *pfp;
+       bool nobranch = FALSE;
+       extern struct pfile *getpfent();
+       register struct pfile *pf;
+       register char **ap;
+       extern char *username();
+       char *usernm = NULL;
+       char *subdir = NULL;
+       char *cmdname;
+
+       /*
+       **  Process the argv
+       */
+
+       cmdname = *argv;
+       for (ap = argv; *++ap != NULL; )
+       {
+               if (**ap == '-')
+               {
+                       /* we have a flag */
+                       switch ((*ap)[1])
+                       {
+                         case 'b':
+                               nobranch = TRUE;
+                               break;
+
+                         case 'u':
+                               if ((*ap)[2] != '\0')
+                                       usernm = &(*ap)[2];
+                               else if (ap[1] != NULL && ap[1][0] != '-')
+                                       usernm = *++ap;
+                               else
+                                       usernm = username();
+                               break;
+                       }
+               }
+               else
+               {
+                       if (subdir != NULL)
+                               usrerr("too many args");
+                       else
+                               subdir = *ap;
+               }
+       }
+
+       /*
+       **  Find and open the SCCS directory.
+       */
 
 
-       strcpy(buf, SccsDir);
+       gstrcpy(buf, SccsDir, sizeof(buf));
        if (buf[0] != '\0')
        if (buf[0] != '\0')
-               strcat(buf, "/");
-       strcat(buf, SccsPath);
-       dirfd = fopen(buf, "r");
+               gstrcat(buf, "/", sizeof(buf));
+       if (subdir != NULL)
+       {
+               gstrcat(buf, subdir, sizeof(buf));
+               gstrcat(buf, "/", sizeof(buf));
+       }
+       gstrcat(buf, SccsPath, sizeof(buf));
+       bufend = &buf[strlen(buf)];
+
+       dirfd = opendir(buf);
        if (dirfd == NULL)
        {
                usrerr("cannot open %s", buf);
        if (dirfd == NULL)
        {
                usrerr("cannot open %s", buf);
-               return;
+               return (EX_NOINPUT);
        }
 
        /*
        **  Scan the SCCS directory looking for s. files.
        }
 
        /*
        **  Scan the SCCS directory looking for s. files.
+       **      gotedit tells whether we have tried to clean any
+       **              files that are being edited.
        */
 
        gotedit = FALSE;
        */
 
        gotedit = FALSE;
-       while (fread(&dir, sizeof dir, 1, dirfd) != NULL)
-       {
-               if (dir.d_ino == 0 || strncmp(dir.d_name, "s.", 2) != 0)
+       while (dir = readdir(dirfd)) {
+               if (strncmp(dir->d_name, "s.", 2) != 0)
                        continue;
                
                /* got an s. file -- see if the p. file exists */
                        continue;
                
                /* got an s. file -- see if the p. file exists */
-               strcpy(buf, SccsDir);
-               if (buf[0] != '\0')
-                       strcat(buf, "/");
-               strcat(buf, SccsPath);
-               strcat(buf, "/p.");
-               basefile = &buf[strlen(buf)];
-               strncpy(basefile, &dir.d_name[2], sizeof dir.d_name - 2);
-               basefile[sizeof dir.d_name - 2] = '\0';
+               gstrcpy(bufend, "/p.", sizeof(buf));
+               basefile = bufend + 3;
+               gstrcpy(basefile, &dir->d_name[2], sizeof(buf));
+
+               /*
+               **  open and scan the p-file.
+               **      'gotpfent' tells if we have found a valid p-file
+               **              entry.
+               */
+
                pfp = fopen(buf, "r");
                pfp = fopen(buf, "r");
+               gotpfent = FALSE;
                if (pfp != NULL)
                {
                if (pfp != NULL)
                {
-                       while (fgets(pline, sizeof pline, pfp) != NULL)
-                               printf("%12s: being edited: %s", basefile, pline);
+                       /* the file exists -- report it's contents */
+                       while ((pf = getpfent(pfp)) != NULL)
+                       {
+                               if (nobranch && isbranch(pf->p_nsid))
+                                       continue;
+                               if (usernm != NULL && strcmp(usernm, pf->p_user) != 0 && mode != CLEANC)
+                                       continue;
+                               gotedit = TRUE;
+                               gotpfent = TRUE;
+                               if (mode == TELLC)
+                               {
+                                       printf("%s\n", basefile);
+                                       break;
+                               }
+                               printf("%12s: being edited: ", basefile);
+                               putpfent(pf, stdout);
+                       }
                        fclose(pfp);
                        fclose(pfp);
-                       gotedit = TRUE;
-                       continue;
                }
                
                /* the s. file exists and no p. file exists -- unlink the g-file */
                }
                
                /* the s. file exists and no p. file exists -- unlink the g-file */
-               if (mode == CLEANC)
+               if (mode == CLEANC && !gotpfent)
                {
                {
-                       strncpy(buf, &dir.d_name[2], sizeof dir.d_name - 2);
-                       buf[sizeof dir.d_name - 2] = '\0';
-                       unlink(buf);
+                       char    unlinkbuf[FBUFSIZ];
+                       gstrcpy(unlinkbuf, &dir->d_name[2], sizeof(unlinkbuf));
+                       unlink(unlinkbuf);
                }
        }
 
                }
        }
 
-       fclose(dirfd);
+       /* cleanup & report results */
+       closedir(dirfd);
        if (!gotedit && mode == INFOC)
        if (!gotedit && mode == INFOC)
-               printf("Nothing being edited\n");
+       {
+               printf("Nothing being edited");
+               if (nobranch)
+                       printf(" (on trunk)");
+               if (usernm == NULL)
+                       printf("\n");
+               else
+                       printf(" by %s\n", usernm);
+       }
        if (mode == CHECKC)
                exit(gotedit);
        if (mode == CHECKC)
                exit(gotedit);
+       return (EX_OK);
 }
 }
-\f/*
+\f
+/*
+**  ISBRANCH -- is the SID a branch?
+**
+**     Parameters:
+**             sid -- the sid to check.
+**
+**     Returns:
+**             TRUE if the sid represents a branch.
+**             FALSE otherwise.
+**
+**     Side Effects:
+**             none.
+*/
+
+isbranch(sid)
+       char *sid;
+{
+       register char *p;
+       int dots;
+
+       dots = 0;
+       for (p = sid; *p != '\0'; p++)
+       {
+               if (*p == '.')
+                       dots++;
+               if (dots > 1)
+                       return (TRUE);
+       }
+       return (FALSE);
+}
+\f
+/*
 **  UNEDIT -- unedit a file
 **
 **     Checks to see that the current user is actually editting
 **  UNEDIT -- unedit a file
 **
 **     Checks to see that the current user is actually editting
@@ -706,22 +1096,18 @@ unedit(fn)
        char *fn;
 {
        register FILE *pfp;
        char *fn;
 {
        register FILE *pfp;
-       char *pfn;
+       char *cp, *pfn;
        static char tfn[] = "/tmp/sccsXXXXX";
        FILE *tfp;
        static char tfn[] = "/tmp/sccsXXXXX";
        FILE *tfp;
-       register char *p;
        register char *q;
        bool delete = FALSE;
        bool others = FALSE;
        char *myname;
        register char *q;
        bool delete = FALSE;
        bool others = FALSE;
        char *myname;
-       extern char *getlogin();
+       extern char *username();
        struct pfile *pent;
        struct pfile *pent;
-       extern struct pfile *getpfile();
-       char buf[120];
-# ifdef UIDUSER
-       struct passwd *pw;
-       extern struct passwd *getpwuid();
-# endif UIDUSER
+       extern struct pfile *getpfent();
+       char buf[PFILELG];
+       extern char *makefile();
 
        /* make "s." filename & find the trailing component */
        pfn = makefile(fn);
 
        /* make "s." filename & find the trailing component */
        pfn = makefile(fn);
@@ -736,7 +1122,7 @@ unedit(fn)
                return (FALSE);
        }
 
                return (FALSE);
        }
 
-       /* turn "s." into "p." */
+       /* turn "s." into "p." & try to open it */
        *++q = 'p';
 
        pfp = fopen(pfn, "r");
        *++q = 'p';
 
        pfp = fopen(pfn, "r");
@@ -746,10 +1132,7 @@ unedit(fn)
                return (FALSE);
        }
 
                return (FALSE);
        }
 
-       /*
-       **  Copy p-file to temp file, doing deletions as needed.
-       */
-
+       /* create temp file for editing p-file */
        mktemp(tfn);
        tfp = fopen(tfn, "w");
        if (tfp == NULL)
        mktemp(tfn);
        tfp = fopen(tfn, "w");
        if (tfp == NULL)
@@ -758,18 +1141,14 @@ unedit(fn)
                exit(EX_OSERR);
        }
 
                exit(EX_OSERR);
        }
 
-# ifdef UIDUSER
-       pw = getpwuid(getuid());
-       if (pw == NULL)
-       {
-               syserr("who are you? (uid=%d)", getuid());
-               exit(EX_OSERR);
-       }
-       myname = pw->pw_name;
-# else
-       myname = getlogin();
-# endif UIDUSER
-       while ((pent = getpfile(pfp)) != NULL)
+       /* figure out who I am */
+       myname = username();
+
+       /*
+       **  Copy p-file to temp file, doing deletions as needed.
+       */
+
+       while ((pent = getpfent(pfp)) != NULL)
        {
                if (strcmp(pent->p_user, myname) == 0)
                {
        {
                if (strcmp(pent->p_user, myname) == 0)
                {
@@ -778,16 +1157,42 @@ unedit(fn)
                }
                else
                {
                }
                else
                {
-                       fprintf(tfp, "%s %s %s %s %s\n", pent->p_osid,
-                           pent->p_nsid, pent->p_user, pent->p_date,
-                           pent->p_time);
+                       /* output it again */
+                       putpfent(pent, tfp);
                        others++;
                }
        }
 
                        others++;
                }
        }
 
+       /*
+        * Before changing anything, make sure we can remove
+        * the file in question (assuming it exists).
+        */
+       if (delete) {
+               extern int errno;
+
+               cp = tail(fn);
+               errno = 0;
+               if (access(cp, 0) < 0 && errno != ENOENT)
+                       goto bad;
+               if (errno == 0)
+                       /*
+                        * This is wrong, but the rest of the program
+                        * has built in assumptions about "." as well,
+                        * so why make unedit a special case?
+                        */
+                       if (access(".", 2) < 0) {
+       bad:
+                               printf("%12s: can't remove\n", cp);
+                               fclose(tfp);
+                               fclose(pfp);
+                               unlink(tfn);
+                               return (FALSE);
+                       }
+       }
        /* do final cleanup */
        if (others)
        {
        /* do final cleanup */
        if (others)
        {
+               /* copy it back (perhaps it should be linked?) */
                if (freopen(tfn, "r", tfp) == NULL)
                {
                        syserr("cannot reopen \"%s\"", tfn);
                if (freopen(tfn, "r", tfp) == NULL)
                {
                        syserr("cannot reopen \"%s\"", tfn);
@@ -803,16 +1208,23 @@ unedit(fn)
        }
        else
        {
        }
        else
        {
+               /* it's empty -- remove it */
                unlink(pfn);
        }
        fclose(tfp);
        fclose(pfp);
        unlink(tfn);
 
                unlink(pfn);
        }
        fclose(tfp);
        fclose(pfp);
        unlink(tfn);
 
+       /* actually remove the g-file */
        if (delete)
        {
        if (delete)
        {
-               unlink(fn);
-               printf("%12s: removed\n", fn);
+               /*
+                * Since we've checked above, we can
+                * use the return from unlink to
+                * determine if the file existed or not.
+                */
+               if (unlink(cp) >= 0)
+                       printf("%12s: removed\n", cp);
                return (TRUE);
        }
        else
                return (TRUE);
        }
        else
@@ -821,8 +1233,134 @@ unedit(fn)
                return (FALSE);
        }
 }
                return (FALSE);
        }
 }
-\f/*
-**  GETPFILE -- get an entry from the p-file
+\f
+/*
+**  DODIFF -- diff an s-file against a g-file
+**
+**     Parameters:
+**             getv -- argv for the 'get' command.
+**             gfile -- name of the g-file to diff against.
+**
+**     Returns:
+**             Result of get.
+**
+**     Side Effects:
+**             none.
+*/
+
+dodiff(getv, gfile)
+       char **getv;
+       char *gfile;
+{
+       int pipev[2];
+       int rval;
+       register int i;
+       register int pid;
+       auto int st;
+       extern int errno;
+       int (*osig)();
+       register char *p;
+       register char **ap;
+       bool makescript = FALSE;
+
+       for (ap = getv; *ap != NULL; ap++)
+       {
+               p = *ap;
+               if (p[0] == '-')
+               {
+                       switch (p[1])
+                       {
+                         case 'E':
+                               p[1] = 'e';
+                               makescript = TRUE;
+                               break;
+                       }
+               }
+       }
+
+       if (makescript)
+       {
+               printf("sccs edit %s\n", gfile);
+               printf("ed - %s << 'xxEOFxx'\n", gfile);
+       }
+       else
+               printf("\n------- %s -------\n", gfile);
+       fflush(stdout);
+
+       /* create context for diff to run in */
+       if (pipe(pipev) < 0)
+       {
+               syserr("dodiff: pipe failed");
+               exit(EX_OSERR);
+       }
+       if ((pid = fork()) < 0)
+       {
+               syserr("dodiff: fork failed");
+               exit(EX_OSERR);
+       }
+       else if (pid > 0)
+       {
+               /* in parent; run get */
+               OutFile = pipev[1];
+               close(pipev[0]);
+               rval = command(&getv[1], TRUE, "get:rcixt -s -k -p");
+               osig = signal(SIGINT, SIG_IGN);
+               while (((i = wait(&st)) >= 0 && i != pid) || errno == EINTR)
+                       errno = 0;
+               signal(SIGINT, osig);
+               /* ignore result of diff */
+       }
+       else
+       {
+               /* in child, run diff */
+               if (close(pipev[1]) < 0 || close(0) < 0 ||
+                   dup(pipev[0]) != 0 || close(pipev[0]) < 0)
+               {
+                       syserr("dodiff: magic failed");
+                       exit(EX_OSERR);
+               }
+               command(&getv[1], FALSE, "-diff:elsfhbC");
+       }
+
+       if (makescript)
+       {
+               printf("w\n");
+               printf("q\n");
+               printf("'xxEOFxx'\n");
+               printf("sccs delta %s\n", gfile);
+       }
+
+       return (rval);
+}
+\f
+/*
+**  TAIL -- return tail of filename.
+**
+**     Parameters:
+**             fn -- the filename.
+**
+**     Returns:
+**             a pointer to the tail of the filename; e.g., given
+**             "cmd/ls.c", "ls.c" is returned.
+**
+**     Side Effects:
+**             none.
+*/
+
+char *
+tail(fn)
+       register char *fn;
+{
+       register char *p;
+
+       for (p = fn; *p != 0; p++)
+               if (*p == '/' && p[1] != '\0' && p[1] != '/')
+                       fn = &p[1];
+       return (fn);
+}
+\f
+/*
+**  GETPFENT -- get an entry from the p-file
 **
 **     Parameters:
 **             pfp -- p-file file pointer
 **
 **     Parameters:
 **             pfp -- p-file file pointer
@@ -836,11 +1374,11 @@ unedit(fn)
 */
 
 struct pfile *
 */
 
 struct pfile *
-getpfile(pfp)
+getpfent(pfp)
        FILE *pfp;
 {
        static struct pfile ent;
        FILE *pfp;
 {
        static struct pfile ent;
-       static char buf[120];
+       static char buf[PFILELG];
        register char *p;
        extern char *nextfield();
 
        register char *p;
        extern char *nextfield();
 
@@ -852,8 +1390,7 @@ getpfile(pfp)
        ent.p_user = p = nextfield(p);
        ent.p_date = p = nextfield(p);
        ent.p_time = p = nextfield(p);
        ent.p_user = p = nextfield(p);
        ent.p_date = p = nextfield(p);
        ent.p_time = p = nextfield(p);
-       if (p == NULL || nextfield(p) != NULL)
-               return (NULL);
+       ent.p_aux = p = nextfield(p);
 
        return (&ent);
 }
 
        return (&ent);
 }
@@ -876,6 +1413,32 @@ nextfield(p)
        return (p);
 }
 \f/*
        return (p);
 }
 \f/*
+**  PUTPFENT -- output a p-file entry to a file
+**
+**     Parameters:
+**             pf -- the p-file entry
+**             f -- the file to put it on.
+**
+**     Returns:
+**             none.
+**
+**     Side Effects:
+**             pf is written onto file f.
+*/
+
+putpfent(pf, f)
+       register struct pfile *pf;
+       register FILE *f;
+{
+       fprintf(f, "%s %s %s %s %s", pf->p_osid, pf->p_nsid,
+               pf->p_user, pf->p_date, pf->p_time);
+       if (pf->p_aux != NULL)
+               fprintf(f, " %s", pf->p_aux);
+       else
+               fprintf(f, "\n");
+}
+\f
+/*
 **  USRERR -- issue user-level error
 **
 **     Parameters:
 **  USRERR -- issue user-level error
 **
 **     Parameters:
@@ -889,6 +1452,7 @@ nextfield(p)
 **             none.
 */
 
 **             none.
 */
 
+/*VARARGS1*/
 usrerr(f, p1, p2, p3)
        char *f;
 {
 usrerr(f, p1, p2, p3)
        char *f;
 {
@@ -898,7 +1462,8 @@ usrerr(f, p1, p2, p3)
 
        return (-1);
 }
 
        return (-1);
 }
-\f/*
+\f
+/*
 **  SYSERR -- print system-generated error.
 **
 **     Parameters:
 **  SYSERR -- print system-generated error.
 **
 **     Parameters:
@@ -912,6 +1477,7 @@ usrerr(f, p1, p2, p3)
 **             none.
 */
 
 **             none.
 */
 
+/*VARARGS1*/
 syserr(f, p1, p2, p3)
        char *f;
 {
 syserr(f, p1, p2, p3)
        char *f;
 {
@@ -924,7 +1490,86 @@ syserr(f, p1, p2, p3)
                exit(EX_SOFTWARE);
        else
        {
                exit(EX_SOFTWARE);
        else
        {
-               perror(0);
+               perror(NULL);
                exit(EX_OSERR);
        }
 }
                exit(EX_OSERR);
        }
 }
+\f/*
+**  USERNAME -- return name of the current user
+**
+**     Parameters:
+**             none
+**
+**     Returns:
+**             name of current user
+**
+**     Side Effects:
+**             none
+*/
+
+char *
+username()
+{
+# ifdef UIDUSER
+       extern struct passwd *getpwuid();
+       register struct passwd *pw;
+
+       pw = getpwuid(getuid());
+       if (pw == NULL)
+       {
+               syserr("who are you? (uid=%d)", getuid());
+               exit(EX_OSERR);
+       }
+       return (pw->pw_name);
+# else
+       extern char *getlogin();
+       extern char *getenv();
+       register char *p;
+
+       p = getenv("USER");
+       if (p == NULL || p[0] == '\0')
+               p = getlogin();
+       return (p);
+# endif UIDUSER
+}
+\f
+/*
+**     Guarded string manipulation routines; the last argument
+**     is the length of the buffer into which the strcpy or strcat
+**     is to be done.
+*/
+char *gstrcat(to, from, length)
+       char    *to, *from;
+       int     length;
+{
+       if (strlen(from) + strlen(to) >= length) {
+               gstrbotch(to, from);
+       }
+       return(strcat(to, from));
+}
+
+char *gstrncat(to, from, n, length)
+       char    *to, *from;
+       int     n;
+       int     length;
+{
+       if (n + strlen(to) >= length) {
+               gstrbotch(to, from);
+       }
+       return(strncat(to, from, n));
+}
+
+char *gstrcpy(to, from, length)
+       char    *to, *from;
+       int     length;
+{
+       if (strlen(from) >= length) {
+               gstrbotch(from, (char *)0);
+       }
+       return(strcpy(to, from));
+}
+gstrbotch(str1, str2)
+       char    *str1, *str2;
+{
+       usrerr("Filename(s) too long: %s %s", str1, str2);
+}
Continuous source code history from original PDP-7 UNIX to FreeBSD 2, the first fully unencumbered FreeBSD release.