![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sccs.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / ucb|
Return to sccs.c CVS log | Up to [CSRG BSD Unix] / 43BSD / ucb |
1.1 root 1: /*
2: * Copyright (c) 1980 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: */
6:
7: #ifndef lint
8: char copyright[] =
9: "@(#) Copyright (c) 1980 Regents of the University of California.\n\
10: All rights reserved.\n";
11: #endif not lint
12:
13: #ifndef lint
14: static char sccsid[] = "@(#)sccs.c 5.1 (Berkeley) 5/31/85";
15: #endif not lint
16:
17: # include <stdio.h>
18: # include <sys/param.h>
19: # include <sys/stat.h>
20: # include <sys/dir.h>
21: # include <errno.h>
22: # include <signal.h>
23: # include <sysexits.h>
24: # include <pwd.h>
25:
26: /*
27: ** SCCS.C -- human-oriented front end to the SCCS system.
28: **
29: ** Without trying to add any functionality to speak of, this
30: ** program tries to make SCCS a little more accessible to human
31: ** types. The main thing it does is automatically put the
32: ** string "SCCS/s." on the front of names. Also, it has a
33: ** couple of things that are designed to shorten frequent
34: ** combinations, e.g., "delget" which expands to a "delta"
35: ** and a "get".
36: **
37: ** This program can also function as a setuid front end.
38: ** To do this, you should copy the source, renaming it to
39: ** whatever you want, e.g., "syssccs". Change any defaults
40: ** in the program (e.g., syssccs might default -d to
41: ** "/usr/src/sys"). Then recompile and put the result
42: ** as setuid to whomever you want. In this mode, sccs
43: ** knows to not run setuid for certain programs in order
44: ** to preserve security, and so forth.
45: **
46: ** Usage:
47: ** sccs [flags] command [args]
48: **
49: ** Flags:
50: ** -d<dir> <dir> represents a directory to search
51: ** out of. It should be a full pathname
52: ** for general usage. E.g., if <dir> is
53: ** "/usr/src/sys", then a reference to the
54: ** file "dev/bio.c" becomes a reference to
55: ** "/usr/src/sys/dev/bio.c".
56: ** -p<path> prepends <path> to the final component
57: ** of the pathname. By default, this is
58: ** "SCCS". For example, in the -d example
59: ** above, the path then gets modified to
60: ** "/usr/src/sys/dev/SCCS/s.bio.c". In
61: ** more common usage (without the -d flag),
62: ** "prog.c" would get modified to
63: ** "SCCS/s.prog.c". In both cases, the
64: ** "s." gets automatically prepended.
65: ** -r run as the real user.
66: **
67: ** Commands:
68: ** admin,
69: ** get,
70: ** delta,
71: ** rmdel,
72: ** chghist,
73: ** etc. Straight out of SCCS; only difference
74: ** is that pathnames get modified as
75: ** described above.
76: ** edit Macro for "get -e".
77: ** unedit Removes a file being edited, knowing
78: ** about p-files, etc.
79: ** delget Macro for "delta" followed by "get".
80: ** deledit Macro for "delta" followed by "get -e".
81: ** info Tell what files being edited.
82: ** clean Remove all files that can be
83: ** regenerated from SCCS files.
84: ** check Like info, but return exit status, for
85: ** use in makefiles.
86: ** fix Remove a top delta & reedit, but save
87: ** the previous changes in that delta.
88: **
89: ** Compilation Flags:
90: ** UIDUSER -- determine who the user is by looking at the
91: ** uid rather than the login name -- for machines
92: ** where SCCS gets the user in this way.
93: ** SCCSDIR -- if defined, forces the -d flag to take on
94: ** this value. This is so that the setuid
95: ** aspects of this program cannot be abused.
96: ** This flag also disables the -p flag.
97: ** SCCSPATH -- the default for the -p flag.
98: ** MYNAME -- the title this program should print when it
99: ** gives error messages.
100: **
101: ** Compilation Instructions:
102: ** cc -O -n -s sccs.c
103: ** The flags listed above can be -D defined to simplify
104: ** recompilation for variant versions.
105: **
106: ** Author:
107: ** Eric Allman, UCB/INGRES
108: ** Copyright 1980 Regents of the University of California
109: */
110:
111:
112: /******************* Configuration Information ********************/
113:
114: # ifndef SCCSPATH
115: # define SCCSPATH "SCCS" /* pathname in which to find s-files */
116: # endif NOT SCCSPATH
117:
118: # ifndef MYNAME
119: # define MYNAME "sccs" /* name used for printing errors */
120: # endif NOT MYNAME
121:
122: # ifndef PROGPATH
123: # define PROGPATH(name) "/usr/local/name" /* place to find binaries */
124: # endif PROGPATH
125:
126: /**************** End of Configuration Information ****************/
127:
128: typedef char bool;
129: # define TRUE 1
130: # define FALSE 0
131:
132: # define bitset(bit, word) ((bool) ((bit) & (word)))
133:
134: struct sccsprog
135: {
136: char *sccsname; /* name of SCCS routine */
137: short sccsoper; /* opcode, see below */
138: short sccsflags; /* flags, see below */
139: char *sccspath; /* pathname of binary implementing */
140: };
141:
142: /* values for sccsoper */
143: # define PROG 0 /* call a program */
144: # define CMACRO 1 /* command substitution macro */
145: # define FIX 2 /* fix a delta */
146: # define CLEAN 3 /* clean out recreatable files */
147: # define UNEDIT 4 /* unedit a file */
148: # define SHELL 5 /* call a shell file (like PROG) */
149: # define DIFFS 6 /* diff between sccs & file out */
150: # define DODIFF 7 /* internal call to diff program */
151: # define ENTER 8 /* enter new files */
152:
153: /* bits for sccsflags */
154: # define NO_SDOT 0001 /* no s. on front of args */
155: # define REALUSER 0002 /* protected (e.g., admin) */
156:
157: /* modes for the "clean", "info", "check" ops */
158: # define CLEANC 0 /* clean command */
159: # define INFOC 1 /* info command */
160: # define CHECKC 2 /* check command */
161: # define TELLC 3 /* give list of files being edited */
162:
163: /*
164: ** Description of commands known to this program.
165: ** First argument puts the command into a class. Second arg is
166: ** info regarding treatment of this command. Third arg is a
167: ** list of flags this command accepts from macros, etc. Fourth
168: ** arg is the pathname of the implementing program, or the
169: ** macro definition, or the arg to a sub-algorithm.
170: */
171:
172: struct sccsprog SccsProg[] =
173: {
174: "admin", PROG, REALUSER, PROGPATH(admin),
175: "chghist", PROG, 0, PROGPATH(rmdel),
176: "comb", PROG, 0, PROGPATH(comb),
177: "delta", PROG, 0, PROGPATH(delta),
178: "get", PROG, 0, PROGPATH(get),
179: "help", PROG, NO_SDOT, PROGPATH(help),
180: "prs", PROG, 0, PROGPATH(prs),
181: "prt", PROG, 0, PROGPATH(prt),
182: "rmdel", PROG, REALUSER, PROGPATH(rmdel),
183: "val", PROG, 0, PROGPATH(val),
184: "what", PROG, NO_SDOT, PROGPATH(what),
185: "sccsdiff", SHELL, REALUSER, PROGPATH(sccsdiff),
186: "edit", CMACRO, NO_SDOT, "get -e",
187: "delget", CMACRO, NO_SDOT, "delta:mysrp/get:ixbeskcl -t",
188: "deledit", CMACRO, NO_SDOT, "delta:mysrp -n/get:ixbskcl -e -t -g",
189: "fix", FIX, NO_SDOT, NULL,
190: "clean", CLEAN, REALUSER|NO_SDOT, (char *) CLEANC,
191: "info", CLEAN, REALUSER|NO_SDOT, (char *) INFOC,
192: "check", CLEAN, REALUSER|NO_SDOT, (char *) CHECKC,
193: "tell", CLEAN, REALUSER|NO_SDOT, (char *) TELLC,
194: "unedit", UNEDIT, NO_SDOT, NULL,
195: "diffs", DIFFS, NO_SDOT|REALUSER, NULL,
196: "-diff", DODIFF, NO_SDOT|REALUSER, PROGPATH(bdiff),
197: "print", CMACRO, 0, "prt -e/get -p -m -s",
198: "branch", CMACRO, NO_SDOT,
199: "get:ixrc -e -b/delta: -s -n -ybranch-place-holder/get:pl -e -t -g",
200: "enter", ENTER, NO_SDOT, NULL,
201: "create", CMACRO, NO_SDOT, "enter/get:ixbeskcl -t",
202: NULL, -1, 0, NULL
203: };
204:
205: /* one line from a p-file */
206: struct pfile
207: {
208: char *p_osid; /* old SID */
209: char *p_nsid; /* new SID */
210: char *p_user; /* user who did edit */
211: char *p_date; /* date of get */
212: char *p_time; /* time of get */
213: char *p_aux; /* extra info at end */
214: };
215:
216: char *SccsPath = SCCSPATH; /* pathname of SCCS files */
217: # ifdef SCCSDIR
218: char *SccsDir = SCCSDIR; /* directory to begin search from */
219: # else
220: char *SccsDir = "";
221: # endif
222: char MyName[] = MYNAME; /* name used in messages */
223: int OutFile = -1; /* override output file for commands */
224: bool RealUser; /* if set, running as real user */
225: # ifdef DEBUG
226: bool Debug; /* turn on tracing */
227: # endif
228: # ifndef V6
229: extern char *getenv();
230: # endif V6
231:
232: char *gstrcat(), *strcat();
233: char *gstrncat(), *strncat();
234: char *gstrcpy(), *strcpy();
235: #define FBUFSIZ BUFSIZ
236: #define PFILELG 120
237:
238: main(argc, argv)
239: int argc;
240: char **argv;
241: {
242: register char *p;
243: extern struct sccsprog *lookup();
244: register int i;
245: # ifndef V6
246: # ifndef SCCSDIR
247: register struct passwd *pw;
248: extern struct passwd *getpwnam();
249: char buf[FBUFSIZ];
250:
251: /* pull "SccsDir" out of the environment (possibly) */
252: p = getenv("PROJECTDIR");
253: if (p != NULL && p[0] != '\0')
254: {
255: if (p[0] == '/')
256: SccsDir = p;
257: else
258: {
259: pw = getpwnam(p);
260: if (pw == NULL)
261: {
262: usrerr("user %s does not exist", p);
263: exit(EX_USAGE);
264: }
265: gstrcpy(buf, pw->pw_dir, sizeof(buf));
266: gstrcat(buf, "/src", sizeof(buf));
267: if (access(buf, 0) < 0)
268: {
269: gstrcpy(buf, pw->pw_dir, sizeof(buf));
270: gstrcat(buf, "/source", sizeof(buf));
271: if (access(buf, 0) < 0)
272: {
273: usrerr("project %s has no source!", p);
274: exit(EX_USAGE);
275: }
276: }
277: SccsDir = buf;
278: }
279: }
280: # endif SCCSDIR
281: # endif V6
282:
283: /*
284: ** Detect and decode flags intended for this program.
285: */
286:
287: if (argc < 2)
288: {
289: fprintf(stderr, "Usage: %s [flags] command [flags]\n", MyName);
290: exit(EX_USAGE);
291: }
292: argv[argc] = NULL;
293:
294: if (lookup(argv[0]) == NULL)
295: {
296: while ((p = *++argv) != NULL)
297: {
298: if (*p != '-')
299: break;
300: switch (*++p)
301: {
302: case 'r': /* run as real user */
303: setuid(getuid());
304: RealUser++;
305: break;
306:
307: # ifndef SCCSDIR
308: case 'p': /* path of sccs files */
309: SccsPath = ++p;
310: if (SccsPath[0] == '\0' && argv[1] != NULL)
311: SccsPath = *++argv;
312: break;
313:
314: case 'd': /* directory to search from */
315: SccsDir = ++p;
316: if (SccsDir[0] == '\0' && argv[1] != NULL)
317: SccsDir = *++argv;
318: break;
319: # endif
320:
321: # ifdef DEBUG
322: case 'T': /* trace */
323: Debug++;
324: break;
325: # endif
326:
327: default:
328: usrerr("unknown option -%s", p);
329: break;
330: }
331: }
332: if (SccsPath[0] == '\0')
333: SccsPath = ".";
334: }
335:
336: i = command(argv, FALSE, "");
337: exit(i);
338: }
339:
340: /*
341: ** COMMAND -- look up and perform a command
342: **
343: ** This routine is the guts of this program. Given an
344: ** argument vector, it looks up the "command" (argv[0])
345: ** in the configuration table and does the necessary stuff.
346: **
347: ** Parameters:
348: ** argv -- an argument vector to process.
349: ** forkflag -- if set, fork before executing the command.
350: ** editflag -- if set, only include flags listed in the
351: ** sccsklets field of the command descriptor.
352: ** arg0 -- a space-seperated list of arguments to insert
353: ** before argv.
354: **
355: ** Returns:
356: ** zero -- command executed ok.
357: ** else -- error status.
358: **
359: ** Side Effects:
360: ** none.
361: */
362:
363: command(argv, forkflag, arg0)
364: char **argv;
365: bool forkflag;
366: char *arg0;
367: {
368: register struct sccsprog *cmd;
369: register char *p;
370: char buf[FBUFSIZ];
371: extern struct sccsprog *lookup();
372: char *nav[1000];
373: char **np;
374: register char **ap;
375: register int i;
376: register char *q;
377: extern bool unedit();
378: int rval = 0;
379: extern char *index();
380: extern char *makefile();
381: char *editchs;
382: extern char *tail();
383:
384: # ifdef DEBUG
385: if (Debug)
386: {
387: printf("command:\n\t\"%s\"\n", arg0);
388: for (np = argv; *np != NULL; np++)
389: printf("\t\"%s\"\n", *np);
390: }
391: # endif
392:
393: /*
394: ** Copy arguments.
395: ** Copy from arg0 & if necessary at most one arg
396: ** from argv[0].
397: */
398:
399: np = ap = &nav[1];
400: editchs = NULL;
401: for (p = arg0, q = buf; *p != '\0' && *p != '/'; )
402: {
403: *np++ = q;
404: while (*p == ' ')
405: p++;
406: while (*p != ' ' && *p != '\0' && *p != '/' && *p != ':')
407: *q++ = *p++;
408: *q++ = '\0';
409: if (*p == ':')
410: {
411: editchs = q;
412: while (*++p != '\0' && *p != '/' && *p != ' ')
413: *q++ = *p;
414: *q++ = '\0';
415: }
416: }
417: *np = NULL;
418: if (*ap == NULL)
419: *np++ = *argv++;
420:
421: /*
422: ** Look up command.
423: ** At this point, *ap is the command name.
424: */
425:
426: cmd = lookup(*ap);
427: if (cmd == NULL)
428: {
429: usrerr("Unknown command \"%s\"", *ap);
430: return (EX_USAGE);
431: }
432:
433: /*
434: ** Copy remaining arguments doing editing as appropriate.
435: */
436:
437: for (; *argv != NULL; argv++)
438: {
439: p = *argv;
440: if (*p == '-')
441: {
442: if (p[1] == '\0' || editchs == NULL || index(editchs, p[1]) != NULL)
443: *np++ = p;
444: }
445: else
446: {
447: if (!bitset(NO_SDOT, cmd->sccsflags))
448: p = makefile(p);
449: if (p != NULL)
450: *np++ = p;
451: }
452: }
453: *np = NULL;
454:
455: /*
456: ** Interpret operation associated with this command.
457: */
458:
459: switch (cmd->sccsoper)
460: {
461: case SHELL: /* call a shell file */
462: *ap = cmd->sccspath;
463: *--ap = "sh";
464: rval = callprog("/bin/sh", cmd->sccsflags, ap, forkflag);
465: break;
466:
467: case PROG: /* call an sccs prog */
468: rval = callprog(cmd->sccspath, cmd->sccsflags, ap, forkflag);
469: break;
470:
471: case CMACRO: /* command macro */
472: /* step through & execute each part of the macro */
473: for (p = cmd->sccspath; *p != '\0'; p++)
474: {
475: q = p;
476: while (*p != '\0' && *p != '/')
477: p++;
478: rval = command(&ap[1], *p != '\0', q);
479: if (rval != 0)
480: break;
481: }
482: break;
483:
484: case FIX: /* fix a delta */
485: if (strncmp(ap[1], "-r", 2) != 0)
486: {
487: usrerr("-r flag needed for fix command");
488: rval = EX_USAGE;
489: break;
490: }
491:
492: /* get the version with all changes */
493: rval = command(&ap[1], TRUE, "get -k");
494:
495: /* now remove that version from the s-file */
496: if (rval == 0)
497: rval = command(&ap[1], TRUE, "rmdel:r");
498:
499: /* and edit the old version (but don't clobber new vers) */
500: if (rval == 0)
501: rval = command(&ap[2], FALSE, "get -e -g");
502: break;
503:
504: case CLEAN:
505: rval = clean((int) cmd->sccspath, ap);
506: break;
507:
508: case UNEDIT:
509: for (argv = np = &ap[1]; *argv != NULL; argv++)
510: {
511: if (unedit(*argv))
512: *np++ = *argv;
513: }
514: *np = NULL;
515:
516: /* get all the files that we unedited successfully */
517: if (np > &ap[1])
518: rval = command(&ap[1], FALSE, "get");
519: break;
520:
521: case DIFFS: /* diff between s-file & edit file */
522: /* find the end of the flag arguments */
523: for (np = &ap[1]; *np != NULL && **np == '-'; np++)
524: continue;
525: argv = np;
526:
527: /* for each file, do the diff */
528: p = argv[1];
529: while (*np != NULL)
530: {
531: /* messy, but we need a null terminated argv */
532: *argv = *np++;
533: argv[1] = NULL;
534: i = dodiff(ap, tail(*argv));
535: if (rval == 0)
536: rval = i;
537: argv[1] = p;
538: }
539: break;
540:
541: case DODIFF: /* internal diff call */
542: setuid(getuid());
543: for (np = ap; *np != NULL; np++)
544: {
545: if ((*np)[0] == '-' && (*np)[1] == 'C')
546: (*np)[1] = 'c';
547: }
548:
549: /* insert "-" argument */
550: np[1] = NULL;
551: np[0] = np[-1];
552: np[-1] = "-";
553:
554: /* execute the diff program of choice */
555: # ifndef V6
556: execvp("diff", ap);
557: # endif
558: execv(cmd->sccspath, argv);
559: syserr("cannot exec %s", cmd->sccspath);
560: exit(EX_OSERR);
561:
562: case ENTER: /* enter new sccs files */
563: /* skip over flag arguments */
564: for (np = &ap[1]; *np != NULL && **np == '-'; np++)
565: continue;
566: argv = np;
567:
568: /* do an admin for each file */
569: p = argv[1];
570: while (*np != NULL)
571: {
572: printf("\n%s:\n", *np);
573: strcpy(buf, "-i");
574: gstrcat(buf, *np, sizeof(buf));
575: ap[0] = buf;
576: argv[0] = tail(*np);
577: argv[1] = NULL;
578: rval = command(ap, TRUE, "admin");
579: argv[1] = p;
580: if (rval == 0)
581: {
582: strcpy(buf, ",");
583: gstrcat(buf, tail(*np), sizeof(buf));
584: if (link(*np, buf) >= 0)
585: unlink(*np);
586: }
587: np++;
588: }
589: break;
590:
591: default:
592: syserr("oper %d", cmd->sccsoper);
593: exit(EX_SOFTWARE);
594: }
595: # ifdef DEBUG
596: if (Debug)
597: printf("command: rval=%d\n", rval);
598: # endif
599: return (rval);
600: }
601:
602: /*
603: ** LOOKUP -- look up an SCCS command name.
604: **
605: ** Parameters:
606: ** name -- the name of the command to look up.
607: **
608: ** Returns:
609: ** ptr to command descriptor for this command.
610: ** NULL if no such entry.
611: **
612: ** Side Effects:
613: ** none.
614: */
615:
616: struct sccsprog *
617: lookup(name)
618: char *name;
619: {
620: register struct sccsprog *cmd;
621:
622: for (cmd = SccsProg; cmd->sccsname != NULL; cmd++)
623: {
624: if (strcmp(cmd->sccsname, name) == 0)
625: return (cmd);
626: }
627: return (NULL);
628: }
629:
630: /*
631: ** CALLPROG -- call a program
632: **
633: ** Used to call the SCCS programs.
634: **
635: ** Parameters:
636: ** progpath -- pathname of the program to call.
637: ** flags -- status flags from the command descriptors.
638: ** argv -- an argument vector to pass to the program.
639: ** forkflag -- if true, fork before calling, else just
640: ** exec.
641: **
642: ** Returns:
643: ** The exit status of the program.
644: ** Nothing if forkflag == FALSE.
645: **
646: ** Side Effects:
647: ** Can exit if forkflag == FALSE.
648: */
649:
650: callprog(progpath, flags, argv, forkflag)
651: char *progpath;
652: short flags;
653: char **argv;
654: bool forkflag;
655: {
656: register int i;
657: auto int st;
658:
659: # ifdef DEBUG
660: if (Debug)
661: {
662: printf("callprog:\n");
663: for (i = 0; argv[i] != NULL; i++)
664: printf("\t\"%s\"\n", argv[i]);
665: }
666: # endif
667:
668: if (*argv == NULL)
669: return (-1);
670:
671: /*
672: ** Fork if appropriate.
673: */
674:
675: if (forkflag)
676: {
677: # ifdef DEBUG
678: if (Debug)
679: printf("Forking\n");
680: # endif
681: i = fork();
682: if (i < 0)
683: {
684: syserr("cannot fork");
685: exit(EX_OSERR);
686: }
687: else if (i > 0)
688: {
689: wait(&st);
690: if ((st & 0377) == 0)
691: st = (st >> 8) & 0377;
692: if (OutFile >= 0)
693: {
694: close(OutFile);
695: OutFile = -1;
696: }
697: return (st);
698: }
699: }
700: else if (OutFile >= 0)
701: {
702: syserr("callprog: setting stdout w/o forking");
703: exit(EX_SOFTWARE);
704: }
705:
706: /* set protection as appropriate */
707: if (bitset(REALUSER, flags))
708: setuid(getuid());
709:
710: /* change standard input & output if needed */
711: if (OutFile >= 0)
712: {
713: close(1);
714: dup(OutFile);
715: close(OutFile);
716: }
717:
718: /* call real SCCS program */
719: execv(progpath, argv);
720: syserr("cannot execute %s", progpath);
721: exit(EX_UNAVAILABLE);
722: /*NOTREACHED*/
723: }
724:
725: /*
726: ** MAKEFILE -- make filename of SCCS file
727: **
728: ** If the name passed is already the name of an SCCS file,
729: ** just return it. Otherwise, munge the name into the name
730: ** of the actual SCCS file.
731: **
732: ** There are cases when it is not clear what you want to
733: ** do. For example, if SccsPath is an absolute pathname
734: ** and the name given is also an absolute pathname, we go
735: ** for SccsPath (& only use the last component of the name
736: ** passed) -- this is important for security reasons (if
737: ** sccs is being used as a setuid front end), but not
738: ** particularly intuitive.
739: **
740: ** Parameters:
741: ** name -- the file name to be munged.
742: **
743: ** Returns:
744: ** The pathname of the sccs file.
745: ** NULL on error.
746: **
747: ** Side Effects:
748: ** none.
749: */
750:
751: char *
752: makefile(name)
753: char *name;
754: {
755: register char *p;
756: char buf[3*FBUFSIZ];
757: extern char *malloc();
758: extern char *rindex();
759: extern bool safepath();
760: extern bool isdir();
761: register char *q;
762:
763: p = rindex(name, '/');
764: if (p == NULL)
765: p = name;
766: else
767: p++;
768:
769: /*
770: ** Check to see that the path is "safe", i.e., that we
771: ** are not letting some nasty person use the setuid part
772: ** of this program to look at or munge some presumably
773: ** hidden files.
774: */
775:
776: if (SccsDir[0] == '/' && !safepath(name))
777: return (NULL);
778:
779: /*
780: ** Create the base pathname.
781: */
782:
783: /* first the directory part */
784: if (SccsDir[0] != '\0' && name[0] != '/' && strncmp(name, "./", 2) != 0)
785: {
786: gstrcpy(buf, SccsDir, sizeof(buf));
787: gstrcat(buf, "/", sizeof(buf));
788: }
789: else
790: gstrcpy(buf, "", sizeof(buf));
791:
792: /* then the head of the pathname */
793: gstrncat(buf, name, p - name, sizeof(buf));
794: q = &buf[strlen(buf)];
795:
796: /* now copy the final part of the name, in case useful */
797: gstrcpy(q, p, sizeof(buf));
798:
799: /* so is it useful? */
800: if (strncmp(p, "s.", 2) != 0 && !isdir(buf))
801: {
802: /* sorry, no; copy the SCCS pathname & the "s." */
803: gstrcpy(q, SccsPath, sizeof(buf));
804: gstrcat(buf, "/s.", sizeof(buf));
805:
806: /* and now the end of the name */
807: gstrcat(buf, p, sizeof(buf));
808: }
809:
810: /* if i haven't changed it, why did I do all this? */
811: if (strcmp(buf, name) == 0)
812: p = name;
813: else
814: {
815: /* but if I have, squirrel it away */
816: p = malloc(strlen(buf) + 1);
817: if (p == NULL)
818: {
819: perror("Sccs: no mem");
820: exit(EX_OSERR);
821: }
822: strcpy(p, buf);
823: }
824:
825: return (p);
826: }
827:
828: /*
829: ** ISDIR -- return true if the argument is a directory.
830: **
831: ** Parameters:
832: ** name -- the pathname of the file to check.
833: **
834: ** Returns:
835: ** TRUE if 'name' is a directory, FALSE otherwise.
836: **
837: ** Side Effects:
838: ** none.
839: */
840:
841: bool
842: isdir(name)
843: char *name;
844: {
845: struct stat stbuf;
846:
847: return (stat(name, &stbuf) >= 0 && (stbuf.st_mode & S_IFMT) == S_IFDIR);
848: }
849:
850: /*
851: ** SAFEPATH -- determine whether a pathname is "safe"
852: **
853: ** "Safe" pathnames only allow you to get deeper into the
854: ** directory structure, i.e., full pathnames and ".." are
855: ** not allowed.
856: **
857: ** Parameters:
858: ** p -- the name to check.
859: **
860: ** Returns:
861: ** TRUE -- if the path is safe.
862: ** FALSE -- if the path is not safe.
863: **
864: ** Side Effects:
865: ** Prints a message if the path is not safe.
866: */
867:
868: bool
869: safepath(p)
870: register char *p;
871: {
872: extern char *index();
873:
874: if (*p != '/')
875: {
876: while (strncmp(p, "../", 3) != 0 && strcmp(p, "..") != 0)
877: {
878: p = index(p, '/');
879: if (p == NULL)
880: return (TRUE);
881: p++;
882: }
883: }
884:
885: printf("You may not use full pathnames or \"..\"\n");
886: return (FALSE);
887: }
888:
889: /*
890: ** CLEAN -- clean out recreatable files
891: **
892: ** Any file for which an "s." file exists but no "p." file
893: ** exists in the current directory is purged.
894: **
895: ** Parameters:
896: ** mode -- tells whether this came from a "clean", "info", or
897: ** "check" command.
898: ** argv -- the rest of the argument vector.
899: **
900: ** Returns:
901: ** none.
902: **
903: ** Side Effects:
904: ** Removes files in the current directory.
905: ** Prints information regarding files being edited.
906: ** Exits if a "check" command.
907: */
908:
909: clean(mode, argv)
910: int mode;
911: char **argv;
912: {
913: struct direct *dir;
914: char buf[FBUFSIZ];
915: char *bufend;
916: register DIR *dirfd;
917: register char *basefile;
918: bool gotedit;
919: bool gotpfent;
920: FILE *pfp;
921: bool nobranch = FALSE;
922: extern struct pfile *getpfent();
923: register struct pfile *pf;
924: register char **ap;
925: extern char *username();
926: char *usernm = NULL;
927: char *subdir = NULL;
928: char *cmdname;
929:
930: /*
931: ** Process the argv
932: */
933:
934: cmdname = *argv;
935: for (ap = argv; *++ap != NULL; )
936: {
937: if (**ap == '-')
938: {
939: /* we have a flag */
940: switch ((*ap)[1])
941: {
942: case 'b':
943: nobranch = TRUE;
944: break;
945:
946: case 'u':
947: if ((*ap)[2] != '\0')
948: usernm = &(*ap)[2];
949: else if (ap[1] != NULL && ap[1][0] != '-')
950: usernm = *++ap;
951: else
952: usernm = username();
953: break;
954: }
955: }
956: else
957: {
958: if (subdir != NULL)
959: usrerr("too many args");
960: else
961: subdir = *ap;
962: }
963: }
964:
965: /*
966: ** Find and open the SCCS directory.
967: */
968:
969: gstrcpy(buf, SccsDir, sizeof(buf));
970: if (buf[0] != '\0')
971: gstrcat(buf, "/", sizeof(buf));
972: if (subdir != NULL)
973: {
974: gstrcat(buf, subdir, sizeof(buf));
975: gstrcat(buf, "/", sizeof(buf));
976: }
977: gstrcat(buf, SccsPath, sizeof(buf));
978: bufend = &buf[strlen(buf)];
979:
980: dirfd = opendir(buf);
981: if (dirfd == NULL)
982: {
983: usrerr("cannot open %s", buf);
984: return (EX_NOINPUT);
985: }
986:
987: /*
988: ** Scan the SCCS directory looking for s. files.
989: ** gotedit tells whether we have tried to clean any
990: ** files that are being edited.
991: */
992:
993: gotedit = FALSE;
994: while (dir = readdir(dirfd)) {
995: if (strncmp(dir->d_name, "s.", 2) != 0)
996: continue;
997:
998: /* got an s. file -- see if the p. file exists */
999: gstrcpy(bufend, "/p.", sizeof(buf));
1000: basefile = bufend + 3;
1001: gstrcpy(basefile, &dir->d_name[2], sizeof(buf));
1002:
1003: /*
1004: ** open and scan the p-file.
1005: ** 'gotpfent' tells if we have found a valid p-file
1006: ** entry.
1007: */
1008:
1009: pfp = fopen(buf, "r");
1010: gotpfent = FALSE;
1011: if (pfp != NULL)
1012: {
1013: /* the file exists -- report it's contents */
1014: while ((pf = getpfent(pfp)) != NULL)
1015: {
1016: if (nobranch && isbranch(pf->p_nsid))
1017: continue;
1018: if (usernm != NULL && strcmp(usernm, pf->p_user) != 0 && mode != CLEANC)
1019: continue;
1020: gotedit = TRUE;
1021: gotpfent = TRUE;
1022: if (mode == TELLC)
1023: {
1024: printf("%s\n", basefile);
1025: break;
1026: }
1027: printf("%12s: being edited: ", basefile);
1028: putpfent(pf, stdout);
1029: }
1030: fclose(pfp);
1031: }
1032:
1033: /* the s. file exists and no p. file exists -- unlink the g-file */
1034: if (mode == CLEANC && !gotpfent)
1035: {
1036: char unlinkbuf[FBUFSIZ];
1037: gstrcpy(unlinkbuf, &dir->d_name[2], sizeof(unlinkbuf));
1038: unlink(unlinkbuf);
1039: }
1040: }
1041:
1042: /* cleanup & report results */
1043: closedir(dirfd);
1044: if (!gotedit && mode == INFOC)
1045: {
1046: printf("Nothing being edited");
1047: if (nobranch)
1048: printf(" (on trunk)");
1049: if (usernm == NULL)
1050: printf("\n");
1051: else
1052: printf(" by %s\n", usernm);
1053: }
1054: if (mode == CHECKC)
1055: exit(gotedit);
1056: return (EX_OK);
1057: }
1058:
1059: /*
1060: ** ISBRANCH -- is the SID a branch?
1061: **
1062: ** Parameters:
1063: ** sid -- the sid to check.
1064: **
1065: ** Returns:
1066: ** TRUE if the sid represents a branch.
1067: ** FALSE otherwise.
1068: **
1069: ** Side Effects:
1070: ** none.
1071: */
1072:
1073: isbranch(sid)
1074: char *sid;
1075: {
1076: register char *p;
1077: int dots;
1078:
1079: dots = 0;
1080: for (p = sid; *p != '\0'; p++)
1081: {
1082: if (*p == '.')
1083: dots++;
1084: if (dots > 1)
1085: return (TRUE);
1086: }
1087: return (FALSE);
1088: }
1089:
1090: /*
1091: ** UNEDIT -- unedit a file
1092: **
1093: ** Checks to see that the current user is actually editting
1094: ** the file and arranges that s/he is not editting it.
1095: **
1096: ** Parameters:
1097: ** fn -- the name of the file to be unedited.
1098: **
1099: ** Returns:
1100: ** TRUE -- if the file was successfully unedited.
1101: ** FALSE -- if the file was not unedited for some
1102: ** reason.
1103: **
1104: ** Side Effects:
1105: ** fn is removed
1106: ** entries are removed from pfile.
1107: */
1108:
1109: bool
1110: unedit(fn)
1111: char *fn;
1112: {
1113: register FILE *pfp;
1114: char *cp, *pfn;
1115: static char tfn[] = "/tmp/sccsXXXXX";
1116: FILE *tfp;
1117: register char *q;
1118: bool delete = FALSE;
1119: bool others = FALSE;
1120: char *myname;
1121: extern char *username();
1122: struct pfile *pent;
1123: extern struct pfile *getpfent();
1124: char buf[PFILELG];
1125: extern char *makefile();
1126:
1127: /* make "s." filename & find the trailing component */
1128: pfn = makefile(fn);
1129: if (pfn == NULL)
1130: return (FALSE);
1131: q = rindex(pfn, '/');
1132: if (q == NULL)
1133: q = &pfn[-1];
1134: if (q[1] != 's' || q[2] != '.')
1135: {
1136: usrerr("bad file name \"%s\"", fn);
1137: return (FALSE);
1138: }
1139:
1140: /* turn "s." into "p." & try to open it */
1141: *++q = 'p';
1142:
1143: pfp = fopen(pfn, "r");
1144: if (pfp == NULL)
1145: {
1146: printf("%12s: not being edited\n", fn);
1147: return (FALSE);
1148: }
1149:
1150: /* create temp file for editing p-file */
1151: mktemp(tfn);
1152: tfp = fopen(tfn, "w");
1153: if (tfp == NULL)
1154: {
1155: usrerr("cannot create \"%s\"", tfn);
1156: exit(EX_OSERR);
1157: }
1158:
1159: /* figure out who I am */
1160: myname = username();
1161:
1162: /*
1163: ** Copy p-file to temp file, doing deletions as needed.
1164: */
1165:
1166: while ((pent = getpfent(pfp)) != NULL)
1167: {
1168: if (strcmp(pent->p_user, myname) == 0)
1169: {
1170: /* a match */
1171: delete++;
1172: }
1173: else
1174: {
1175: /* output it again */
1176: putpfent(pent, tfp);
1177: others++;
1178: }
1179: }
1180:
1181: /*
1182: * Before changing anything, make sure we can remove
1183: * the file in question (assuming it exists).
1184: */
1185: if (delete) {
1186: extern int errno;
1187:
1188: cp = tail(fn);
1189: errno = 0;
1190: if (access(cp, 0) < 0 && errno != ENOENT)
1191: goto bad;
1192: if (errno == 0)
1193: /*
1194: * This is wrong, but the rest of the program
1195: * has built in assumptions about "." as well,
1196: * so why make unedit a special case?
1197: */
1198: if (access(".", 2) < 0) {
1199: bad:
1200: printf("%12s: can't remove\n", cp);
1201: fclose(tfp);
1202: fclose(pfp);
1203: unlink(tfn);
1204: return (FALSE);
1205: }
1206: }
1207: /* do final cleanup */
1208: if (others)
1209: {
1210: /* copy it back (perhaps it should be linked?) */
1211: if (freopen(tfn, "r", tfp) == NULL)
1212: {
1213: syserr("cannot reopen \"%s\"", tfn);
1214: exit(EX_OSERR);
1215: }
1216: if (freopen(pfn, "w", pfp) == NULL)
1217: {
1218: usrerr("cannot create \"%s\"", pfn);
1219: return (FALSE);
1220: }
1221: while (fgets(buf, sizeof buf, tfp) != NULL)
1222: fputs(buf, pfp);
1223: }
1224: else
1225: {
1226: /* it's empty -- remove it */
1227: unlink(pfn);
1228: }
1229: fclose(tfp);
1230: fclose(pfp);
1231: unlink(tfn);
1232:
1233: /* actually remove the g-file */
1234: if (delete)
1235: {
1236: /*
1237: * Since we've checked above, we can
1238: * use the return from unlink to
1239: * determine if the file existed or not.
1240: */
1241: if (unlink(cp) >= 0)
1242: printf("%12s: removed\n", cp);
1243: return (TRUE);
1244: }
1245: else
1246: {
1247: printf("%12s: not being edited by you\n", fn);
1248: return (FALSE);
1249: }
1250: }
1251:
1252: /*
1253: ** DODIFF -- diff an s-file against a g-file
1254: **
1255: ** Parameters:
1256: ** getv -- argv for the 'get' command.
1257: ** gfile -- name of the g-file to diff against.
1258: **
1259: ** Returns:
1260: ** Result of get.
1261: **
1262: ** Side Effects:
1263: ** none.
1264: */
1265:
1266: dodiff(getv, gfile)
1267: char **getv;
1268: char *gfile;
1269: {
1270: int pipev[2];
1271: int rval;
1272: register int i;
1273: register int pid;
1274: auto int st;
1275: extern int errno;
1276: int (*osig)();
1277:
1278: printf("\n------- %s -------\n", gfile);
1279: fflush(stdout);
1280:
1281: /* create context for diff to run in */
1282: if (pipe(pipev) < 0)
1283: {
1284: syserr("dodiff: pipe failed");
1285: exit(EX_OSERR);
1286: }
1287: if ((pid = fork()) < 0)
1288: {
1289: syserr("dodiff: fork failed");
1290: exit(EX_OSERR);
1291: }
1292: else if (pid > 0)
1293: {
1294: /* in parent; run get */
1295: OutFile = pipev[1];
1296: close(pipev[0]);
1297: rval = command(&getv[1], TRUE, "get:rcixt -s -k -p");
1298: osig = signal(SIGINT, SIG_IGN);
1299: while (((i = wait(&st)) >= 0 && i != pid) || errno == EINTR)
1300: errno = 0;
1301: signal(SIGINT, osig);
1302: /* ignore result of diff */
1303: }
1304: else
1305: {
1306: /* in child, run diff */
1307: if (close(pipev[1]) < 0 || close(0) < 0 ||
1308: dup(pipev[0]) != 0 || close(pipev[0]) < 0)
1309: {
1310: syserr("dodiff: magic failed");
1311: exit(EX_OSERR);
1312: }
1313: command(&getv[1], FALSE, "-diff:elsfhbC");
1314: }
1315: return (rval);
1316: }
1317:
1318: /*
1319: ** TAIL -- return tail of filename.
1320: **
1321: ** Parameters:
1322: ** fn -- the filename.
1323: **
1324: ** Returns:
1325: ** a pointer to the tail of the filename; e.g., given
1326: ** "cmd/ls.c", "ls.c" is returned.
1327: **
1328: ** Side Effects:
1329: ** none.
1330: */
1331:
1332: char *
1333: tail(fn)
1334: register char *fn;
1335: {
1336: register char *p;
1337:
1338: for (p = fn; *p != 0; p++)
1339: if (*p == '/' && p[1] != '\0' && p[1] != '/')
1340: fn = &p[1];
1341: return (fn);
1342: }
1343:
1344: /*
1345: ** GETPFENT -- get an entry from the p-file
1346: **
1347: ** Parameters:
1348: ** pfp -- p-file file pointer
1349: **
1350: ** Returns:
1351: ** pointer to p-file struct for next entry
1352: ** NULL on EOF or error
1353: **
1354: ** Side Effects:
1355: ** Each call wipes out results of previous call.
1356: */
1357:
1358: struct pfile *
1359: getpfent(pfp)
1360: FILE *pfp;
1361: {
1362: static struct pfile ent;
1363: static char buf[PFILELG];
1364: register char *p;
1365: extern char *nextfield();
1366:
1367: if (fgets(buf, sizeof buf, pfp) == NULL)
1368: return (NULL);
1369:
1370: ent.p_osid = p = buf;
1371: ent.p_nsid = p = nextfield(p);
1372: ent.p_user = p = nextfield(p);
1373: ent.p_date = p = nextfield(p);
1374: ent.p_time = p = nextfield(p);
1375: ent.p_aux = p = nextfield(p);
1376:
1377: return (&ent);
1378: }
1379:
1380:
1381: char *
1382: nextfield(p)
1383: register char *p;
1384: {
1385: if (p == NULL || *p == '\0')
1386: return (NULL);
1387: while (*p != ' ' && *p != '\n' && *p != '\0')
1388: p++;
1389: if (*p == '\n' || *p == '\0')
1390: {
1391: *p = '\0';
1392: return (NULL);
1393: }
1394: *p++ = '\0';
1395: return (p);
1396: }
1397: /*
1398: ** PUTPFENT -- output a p-file entry to a file
1399: **
1400: ** Parameters:
1401: ** pf -- the p-file entry
1402: ** f -- the file to put it on.
1403: **
1404: ** Returns:
1405: ** none.
1406: **
1407: ** Side Effects:
1408: ** pf is written onto file f.
1409: */
1410:
1411: putpfent(pf, f)
1412: register struct pfile *pf;
1413: register FILE *f;
1414: {
1415: fprintf(f, "%s %s %s %s %s", pf->p_osid, pf->p_nsid,
1416: pf->p_user, pf->p_date, pf->p_time);
1417: if (pf->p_aux != NULL)
1418: fprintf(f, " %s", pf->p_aux);
1419: else
1420: fprintf(f, "\n");
1421: }
1422:
1423: /*
1424: ** USRERR -- issue user-level error
1425: **
1426: ** Parameters:
1427: ** f -- format string.
1428: ** p1-p3 -- parameters to a printf.
1429: **
1430: ** Returns:
1431: ** -1
1432: **
1433: ** Side Effects:
1434: ** none.
1435: */
1436:
1437: /*VARARGS1*/
1438: usrerr(f, p1, p2, p3)
1439: char *f;
1440: {
1441: fprintf(stderr, "\n%s: ", MyName);
1442: fprintf(stderr, f, p1, p2, p3);
1443: fprintf(stderr, "\n");
1444:
1445: return (-1);
1446: }
1447:
1448: /*
1449: ** SYSERR -- print system-generated error.
1450: **
1451: ** Parameters:
1452: ** f -- format string to a printf.
1453: ** p1, p2, p3 -- parameters to f.
1454: **
1455: ** Returns:
1456: ** never.
1457: **
1458: ** Side Effects:
1459: ** none.
1460: */
1461:
1462: /*VARARGS1*/
1463: syserr(f, p1, p2, p3)
1464: char *f;
1465: {
1466: extern int errno;
1467:
1468: fprintf(stderr, "\n%s SYSERR: ", MyName);
1469: fprintf(stderr, f, p1, p2, p3);
1470: fprintf(stderr, "\n");
1471: if (errno == 0)
1472: exit(EX_SOFTWARE);
1473: else
1474: {
1475: perror(NULL);
1476: exit(EX_OSERR);
1477: }
1478: }
1479: /*
1480: ** USERNAME -- return name of the current user
1481: **
1482: ** Parameters:
1483: ** none
1484: **
1485: ** Returns:
1486: ** name of current user
1487: **
1488: ** Side Effects:
1489: ** none
1490: */
1491:
1492: char *
1493: username()
1494: {
1495: # ifdef UIDUSER
1496: extern struct passwd *getpwuid();
1497: register struct passwd *pw;
1498:
1499: pw = getpwuid(getuid());
1500: if (pw == NULL)
1501: {
1502: syserr("who are you? (uid=%d)", getuid());
1503: exit(EX_OSERR);
1504: }
1505: return (pw->pw_name);
1506: # else
1507: extern char *getlogin();
1508: extern char *getenv();
1509: register char *p;
1510:
1511: p = getenv("USER");
1512: if (p == NULL || p[0] == '\0')
1513: p = getlogin();
1514: return (p);
1515: # endif UIDUSER
1516: }
1517:
1518: /*
1519: ** Guarded string manipulation routines; the last argument
1520: ** is the length of the buffer into which the strcpy or strcat
1521: ** is to be done.
1522: */
1523: char *gstrcat(to, from, length)
1524: char *to, *from;
1525: int length;
1526: {
1527: if (strlen(from) + strlen(to) >= length) {
1528: gstrbotch(to, from);
1529: }
1530: return(strcat(to, from));
1531: }
1532:
1533: char *gstrncat(to, from, n, length)
1534: char *to, *from;
1535: int n;
1536: int length;
1537: {
1538: if (n + strlen(to) >= length) {
1539: gstrbotch(to, from);
1540: }
1541: return(strncat(to, from, n));
1542: }
1543:
1544: char *gstrcpy(to, from, length)
1545: char *to, *from;
1546: int length;
1547: {
1548: if (strlen(from) >= length) {
1549: gstrbotch(from, (char *)0);
1550: }
1551: return(strcpy(to, from));
1552: }
1553: gstrbotch(str1, str2)
1554: char *str1, *str2;
1555: {
1556: usrerr("Filename(s) too long: %s %s", str1, str2);
1557: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.