![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to rcsfnms.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / rcs / src|
Return to rcsfnms.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / rcs / src |
1.1 root 1: /*
2: * RCS file name handling
3: */
4: static char rcsid[]=
5: "$Header: rcsfnms.c,v 3.9 86/05/15 02:24:55 lepreau Exp $ Purdue CS";
6: /****************************************************************************
7: * creation and deletion of semaphorefile,
8: * creation of temporary filenames and cleanup()
9: * pairing of RCS file names and working file names.
10: * Testprogram: define PAIRTEST
11: ****************************************************************************
12: *
13: * Copyright (C) 1982 by Walter F. Tichy
14: * Purdue University
15: * Computer Science Department
16: * West Lafayette, IN 47907
17: *
18: * All rights reserved. No part of this software may be sold or distributed
19: * in any form or by any means without the prior written permission of the
20: * author.
21: * Report problems and direct all inquiries to Tichy@purdue (ARPA net).
22: */
23:
24:
25: /* $Log: rcsfnms.c,v $
26: * Revision 3.9 86/05/15 02:24:55 lepreau
27: * add suffix .el for gnulisp
28: *
29: * Revision 3.8 86/01/12 01:20:29 lepreau
30: * add suffixes csh,cl,sl,red for csh, common lisp,
31: * psl, and rlisp respectively.
32: *
33: * Revision 3.7 83/05/11 15:01:58 wft
34: * *** empty log message ***
35: *
36: * Revision 3.7 83/05/11 15:01:58 wft
37: * Added comtable[] which pairs file name suffixes with comment leaders;
38: * updated InitAdmin() accordingly.
39: *
40: * Revision 3.6 83/04/05 14:47:36 wft
41: * fixed Suffix in InitAdmin().
42: *
43: * Revision 3.5 83/01/17 18:01:04 wft
44: * Added getwd() and rename(); these can be removed by defining
45: * V4_2BSD, since they are not needed in 4.2 bsd.
46: * Changed sys/param.h to sys/types.h.
47: *
48: * Revision 3.4 82/12/08 21:55:20 wft
49: * removed unused variable.
50: *
51: * Revision 3.3 82/11/28 20:31:37 wft
52: * Changed mktempfile() to store the generated file names.
53: * Changed getfullRCSname() to store the file and pathname, and to
54: * delete leading "../" and "./".
55: *
56: * Revision 3.2 82/11/12 14:29:40 wft
57: * changed pairfilenames() to handle file.sfx,v; also deleted checkpathnosfx(),
58: * checksuffix(), checkfullpath(). Semaphore name generation updated.
59: * mktempfile() now checks for nil path; lastfilename initialized properly.
60: * Added Suffix .h to InitAdmin. Added testprogram PAIRTEST.
61: * Moved rmsema, trysema, trydiraccess, getfullRCSname from rcsutil.c to here.
62: *
63: * Revision 3.1 82/10/18 14:51:28 wft
64: * InitAdmin() now initializes StrictLocks=STRICT_LOCKING (def. in rcsbase.h).
65: * renamed checkpath() to checkfullpath().
66: */
67:
68:
69: #include "rcsbase.h"
70: extern char * rindex();
71: extern char * mktemp();
72: extern char * malloc();
73: extern FILE * fopen();
74: extern char * getwd(); /* get working directory; forward decl */
75:
76: extern FILE * finptr; /* RCS input file descriptor */
77: extern FILE * frewrite; /* New RCS file descriptor */
78: extern char * RCSfilename, * workfilename; /* filenames */
79:
80:
81:
82: char tempfilename [NCPFN+10]; /* used for derived file names */
83: char subfilename [NCPFN+14]; /* used for files RCS/file.sfx,v */
84: char semafilename [NCPPN]; /* name of semaphore file */
85: int madesema; /* indicates whether a semaphore file has been set */
86: char * tfnames[10] = /* temp. file names to be unlinked when finished */
87: {nil,nil,nil,nil,nil,nil,nil,nil,nil,nil};
88: int lastfilename = -1;/* index of last file name in tfnames[] */
89:
90:
91: struct compair {
92: char * suffix, * comlead;
93: };
94:
95: struct compair comtable[] = {
96: /* comtable pairs each filename suffix with a comment leader. The comment */
97: /* leader is placed before each line generated by the $Log keyword. This */
98: /* table is used to guess the proper comment leader from the working file's */
99: /* suffix during initial ci (see InitAdmin()). Comment leaders are needed */
100: /* for languages without multiline comments; for others they are optional. */
101: "c", " * ", /* C */
102: "h", " * ", /* C-header */
103: "p", " * ", /* pascal */
104: "sh", "# ", /* shell */
105: "csh", "# ", /* shell */
106: "s", "# ", /* assembler */
107: "sl", "% ", /* psl */
108: "red", "% ", /* psl/rlisp */
109: "cl", ";;; ", /* common lisp */
110: "r", "# ", /* ratfor */
111: "e", "# ", /* efl */
112: "l", " * ", /* lex NOTE: conflict between lex and franzlisp*/
113: "y", " * ", /* yacc */
114: "yr", " * ", /* yacc-ratfor */
115: "ye", " * ", /* yacc-efl */
116: "ml", "; ", /* mocklisp */
117: "el", "; ", /* gnulisp */
118: "mac", "; ", /* macro vms or dec-20 or pdp-11 macro */
119: "f", "c ", /* fortran */
120: "ms", "\\\" ", /* ms-macros t/nroff*/
121: "me", "\\\" ", /* me-macros t/nroff*/
122: "", "# ", /* default for empty suffix */
123: nil, "" /* default for unknown suffix; must always be last */
124: };
125:
126:
127:
128: ffclose(fptr)
129: FILE * fptr;
130: /* Function: checks ferror(fptr) and aborts the program if there were
131: * errors; otherwise closes fptr.
132: */
133: { if (ferror(fptr) || fclose(fptr)==EOF)
134: faterror("File read or write error; file system full?");
135: }
136:
137:
138:
139: int trysema(RCSfilename,makesema)
140: char * RCSfilename; int makesema;
141: /* Function: Checks whether a semaphore file exists for RCSfilename. If yes,
142: * returns false. If not, creates one if makesema==true and returns true
143: * if successful. If a semaphore file was created, madesema is set to true.
144: * The name of the semaphore file is put into variable semafilename.
145: */
146: {
147: register char * tp, *sp, *lp;
148: int fdesc;
149:
150: sp=RCSfilename;
151: lp = rindex(sp,'/');
152: if (lp==0) {
153: semafilename[0]='.'; semafilename[1]='/';
154: tp= &semafilename[2];
155: } else {
156: /* copy path */
157: tp=semafilename;
158: do *tp++ = *sp++; while (sp<=lp);
159: }
160: /*now insert `,' and append file name */
161: *tp++ = ',';
162: lp = rindex(sp, RCSSEP);
163: while (sp<lp) *tp++ = *sp++;
164: *tp++ = ','; *tp++ = '\0'; /* will be the same length as RCSfilename*/
165:
166: madesema = false;
167: if (access(semafilename, 0) == 0) {
168: error("RCS file %s is in use",RCSfilename);
169: return false;
170: }
171: if (makesema) {
172: if ((fdesc=creat(semafilename, 000)) == -1) {
173: error("Can't create semaphore file for RCS file %s",RCSfilename);
174: return false;
175: } else
176: close(fdesc);
177: madesema=true;
178: }
179: return true;
180: }
181:
182:
183: int rmsema()
184: /* Function: delete the semaphore file if madeseam==true;
185: * sets madesema to false.
186: */
187: {
188: if (madesema) {
189: madesema=false;
190: if (unlink(semafilename) == -1) {
191: error("Can't find semaphore file %s",semafilename);
192: return false;
193: }
194: }
195: return true;
196: }
197:
198:
199:
200: InitCleanup()
201: { lastfilename = -1; /* initialize pointer */
202: }
203:
204:
205: cleanup()
206: /* Function: closes input file and rewrite file.
207: * Unlinks files in tfnames[], deletes semaphore file.
208: */
209: {
210: register int i;
211:
212: if (finptr!=NULL) fclose(finptr);
213: if (frewrite!=NULL) fclose(frewrite);
214: for (i=0; i<=lastfilename; i++) {
215: if (tfnames[i][0]!='\0') unlink(tfnames[i]);
216: }
217: InitCleanup();
218: return (rmsema());
219: }
220:
221:
222: char * mktempfile(fullpath,filename)
223: register char * fullpath, * filename;
224: /* Function: Creates a unique filename using the process id and stores it
225: * into a free slot in tfnames. The filename consists of the path contained
226: * in fullpath concatenated with filename. filename should end in "XXXXXX".
227: * Because of storage in tfnames, cleanup() can unlink the file later.
228: * lastfilename indicates the highest occupied slot in tfnames.
229: * Returns a pointer to the filename created.
230: * Example use: mktempfile("/tmp/", somefilename)
231: */
232: {
233: register char * lastslash, *tp;
234: lastfilename++;
235: if ((tp=tfnames[lastfilename])==nil)
236: tp=tfnames[lastfilename] = malloc(NCPPN);
237: if (fullpath!=nil && (lastslash=rindex(fullpath,'/'))!=0) {
238: /* copy path */
239: while (fullpath<=lastslash) *tp++ = *fullpath++;
240: }
241: while (*tp++ = *filename++);
242: return (mktemp(tfnames[lastfilename]));
243: }
244:
245:
246:
247:
248: char * bindex(sp,c)
249: register char * sp, c;
250: /* Function: Finds the last occurrence of character c in string sp
251: * and returns a pointer to the character just beyond it. If the
252: * character doesn't occur in the string, sp is returned.
253: */
254: { register char * r;
255: r = sp;
256: while (*sp) {
257: if (*sp++ == c) r=sp;
258: }
259: return r;
260: }
261:
262:
263:
264: InitAdmin()
265: /* function: initializes an admin node */
266: { register char * Suffix;
267: register int i;
268:
269: Head=nil; AccessList=nil; Symbols=nil; Locks=nil;
270: StrictLocks=STRICT_LOCKING;
271:
272: /* guess the comment leader from the suffix*/
273: Suffix=bindex(workfilename, '.');
274: if (Suffix==workfilename) Suffix= ""; /* empty suffix; will get default*/
275: for (i=0;;i++) {
276: if (comtable[i].suffix==nil) {
277: Comment=comtable[i].comlead; /*default*/
278: break;
279: } elsif (strcmp(Suffix,comtable[i].suffix)==0) {
280: Comment=comtable[i].comlead; /*default*/
281: break;
282: }
283: }
284: Lexinit(); /* Note: if finptr==NULL, reads nothing; only initializes*/
285: }
286:
287:
288:
289:
290:
291:
292:
293: char * findpairfile(argc, argv, fname)
294: int argc; char * argv[], *fname;
295: /* Function: Given a filename fname, findpairfile scans argv for a pathname
296: * ending in fname. If found, returns a pointer to the pathname, and sets
297: * the corresponding pointer in argv to nil. Otherwise returns fname.
298: * argc indicates the number of entries in argv. Some of them may be nil.
299: */
300: {
301: register char * * next, * match;
302: register int count;
303:
304: for (next = argv, count = argc; count>0; next++,count--) {
305: if ((*next != nil) && strcmp(bindex(*next,'/'),fname)==0) {
306: /* bindex finds the beginning of the file name stem */
307: match= *next;
308: *next=nil;
309: return match;
310: }
311: }
312: return fname;
313: }
314:
315:
316: int pairfilenames(argc, argv, mustread, tostdout)
317: int argc; char ** argv; int mustread, tostdout;
318: /* Function: Pairs the filenames pointed to by argv; argc indicates
319: * how many there are.
320: * Places a pointer to the RCS filename into RCSfilename,
321: * and a pointer to the name of the working file into workfilename.
322: * If both the workfilename and the RCS filename are given, and tostdout
323: * is true, a warning is printed.
324: *
325: * If the RCS file exists, it is opened for reading, the file pointer
326: * is placed into finptr, and the admin-node is read in; returns 1.
327: * If the RCS file does not exist and mustread==true, an error is printed
328: * and 0 returned.
329: * If the RCS file does not exist and mustread==false, the admin node
330: * is initialized to empty (Head, AccessList, Locks, Symbols, StrictLocks),
331: * and -1 returned.
332: *
333: * 0 is returned on all errors.
334: * Also calls InitCleanup();
335: */
336: {
337: register char * sp, * tp;
338: char * lastsep, * purefname, * pureRCSname;
339: int opened, returncode;
340: char * RCS1;
341:
342: if (*argv == nil) return 0; /* already paired filename */
343:
344: InitCleanup();
345:
346: /* first check suffix to see whether it is an RCS file or not */
347: purefname=bindex(*argv, '/'); /* skip path */
348: lastsep=rindex(purefname, RCSSEP);
349: if (lastsep!= 0 && *(lastsep+1)==RCSSUF && *(lastsep+2)=='\0') {
350: /* RCS file name given*/
351: RCS1=(*argv); pureRCSname=purefname;
352: /* derive workfilename*/
353: sp = purefname; tp=tempfilename;
354: while (sp<lastsep) *tp++ = *sp++; *tp='\0';
355: /* try to find workfile name among arguments */
356: workfilename=findpairfile(argc-1,argv+1,tempfilename);
357: if (strlen(pureRCSname)>NCPFN) {
358: error("RCS file name %s too long",RCS1);
359: return 0;
360: }
361: } else {
362: /* working file given; now try to find RCS file */
363: workfilename= *argv;
364: /* derive RCS file name*/
365: sp=purefname; tp=tempfilename;
366: while (*tp++ = *sp++);
367: *(tp-1)=RCSSEP; *tp++=RCSSUF; *tp++='\0';
368: /* Try to find RCS file name among arguments*/
369: RCS1=findpairfile(argc-1,argv+1,tempfilename);
370: pureRCSname=bindex(RCS1, '/');
371: if (strlen(pureRCSname)>NCPFN) {
372: error("working file name %s too long",workfilename);
373: return 0;
374: }
375: }
376: /* now we have a (tentative) RCS filename in RCS1 and workfilename */
377:
378: if (pureRCSname!=RCS1) {
379: /* a path for RCSfile is given; single RCS file to look for */
380: finptr=fopen(RCSfilename=RCS1, "r");
381: if (finptr!=NULL) {
382: Lexinit(); getadmin();
383: returncode=1;
384: } else { /* could not open */
385: if (access(RCSfilename,0)==0) {
386: error("Can't open existing %s", RCSfilename);
387: return 0;
388: }
389: if (mustread) {
390: error("Can't find %s", RCSfilename);
391: return 0;
392: } else {
393: /* initialize if not mustread */
394: InitAdmin();
395: returncode = -1;
396: }
397: }
398: } else {
399: /* build second RCS file name by prefixing it with RCSDIR*/
400: /* then try to open one of them */
401: strcpy(subfilename,RCSDIR); strcat(subfilename,RCS1);
402: opened=(
403: ((finptr=fopen(RCSfilename=subfilename, "r"))!=NULL) ||
404: ((finptr=fopen(RCSfilename=RCS1,"r"))!=NULL) );
405:
406: if (opened) {
407: /* open succeeded */
408: Lexinit(); getadmin();
409: returncode=1;
410: } else {
411: /* open failed; may be read protected */
412: if ((access(RCSfilename=subfilename,0)==0) ||
413: (access(RCSfilename=RCS1,0)==0)) {
414: error("Can't open existing %s",RCSfilename);
415: return 0;
416: }
417: if (mustread) {
418: error("Can't find %s nor %s",subfilename,RCS1);
419: return 0;
420: } else {
421: /* initialize new file. Put into ./RCS if possible, strip off suffix*/
422: RCSfilename= (access(RCSDIR,0)==0)?subfilename:RCS1;
423: InitAdmin();
424: returncode= -1;
425: }
426: }
427: }
428: if (tostdout&&
429: !(RCS1==tempfilename||workfilename==tempfilename))
430: /*The last term determines whether a pair of */
431: /* file names was given in the argument list */
432: warn("Option -p is set; ignoring output file %s",workfilename);
433:
434: return returncode;
435: }
436:
437:
438: char * getfullRCSname()
439: /* Function: returns a pointer to the full path name of the RCS file.
440: * Calls getwd(), but only once.
441: * removes leading "../" and "./".
442: */
443: { static char pathbuf[NCPPN];
444: static char namebuf[NCPPN];
445: static int pathlength =0;
446:
447: register char * realname, * lastpathchar;
448: register int dotdotcounter, realpathlength;
449:
450: if (*RCSfilename=='/') {
451: return(RCSfilename);
452: } else {
453: if (pathlength==0) { /*call curdir for the first time*/
454: if (getwd(pathbuf)==NULL)
455: faterror("Can't build current directory path");
456: pathlength=strlen(pathbuf);
457: if (!((pathlength==1) && (pathbuf[0]=='/'))) {
458: pathbuf[pathlength++]='/';
459: /* Check needed because some getwd implementations */
460: /* generate "/" for the root. */
461: }
462: }
463: /*the following must be redone since RCSfilename may change*/
464: /* find how many ../ to remvove from RCSfilename */
465: dotdotcounter =0;
466: realname = RCSfilename;
467: while( realname[0]=='.' &&
468: (realname[1]=='/'||(realname[1]=='.'&&realname[2]=='/'))){
469: if (realname[1]=='/') {
470: /* drop leading ./ */
471: realname += 2;
472: } else {
473: /* drop leading ../ and remember */
474: dotdotcounter++;
475: realname += 3;
476: }
477: }
478: /* now remove dotdotcounter trailing directories from pathbuf*/
479: lastpathchar=pathbuf + pathlength-1;
480: while (dotdotcounter>0 && lastpathchar>pathbuf) {
481: /* move pointer backwards over trailing directory */
482: lastpathchar--;
483: if (*lastpathchar=='/') {
484: dotdotcounter--;
485: }
486: }
487: if (dotdotcounter>0) {
488: error("Can't generate full path name for RCS file");
489: return RCSfilename;
490: } else {
491: /* build full path name */
492: realpathlength=lastpathchar-pathbuf+1;
493: strncpy(namebuf,pathbuf,realpathlength);
494: strcpy(&namebuf[realpathlength],realname);
495: return(namebuf);
496: }
497: }
498: }
499:
500:
501:
502: int trydiraccess(filename)
503: char * filename;
504: /* checks write permission in directory of filename and returns
505: * true if writable, false otherwise
506: */
507: {
508: char pathname[NCPPN];
509: register char * tp, *sp, *lp;
510: lp = rindex(filename,'/');
511: if (lp==0) {
512: /* check current directory */
513: if (access(".",2)==0)
514: return true;
515: else {
516: error("Current directory not writable");
517: return false;
518: }
519: }
520: /* copy path */
521: sp=filename;
522: tp=pathname;
523: do *tp++ = *sp++; while (sp<=lp);
524: *tp='\0';
525: if (access(pathname,2)==0)
526: return true;
527: else {
528: error("Directory %s not writable", pathname);
529: return false;
530: }
531: }
532:
533:
534:
535: #ifndef V4_2BSD
536: /* rename() and getwd() will be provided in bsd 4.2 */
537:
538:
539: int rename(from, to)
540: char * from, *to;
541: /* Function: renames a file with the name given by from to the name given by to.
542: * unlinks the to-file if it already exists. returns -1 on error, 0 otherwise.
543: */
544: { unlink(to); /* no need to check return code; will be caught by link*/
545: /* no harm done if file "to" does not exist */
546: if (link(from,to)<0) return -1;
547: return(unlink(from));
548: }
549:
550:
551:
552: #include <sys/types.h>
553: #include <sys/stat.h>
554: #include <sys/dir.h>
555: #define dot "."
556: #define dotdot ".."
557:
558:
559:
560: char * getwd(name)
561: char * name;
562: /* Function: places full pathname of current working directory into name and
563: * returns name on success, NULL on failure.
564: * getwd is an adaptation of pwd. May not return to the current directory on
565: * failure.
566: */
567: {
568: FILE *file;
569: struct stat d, dd;
570: char buf[2]; /* to NUL-terminate dir.d_name */
571: struct direct dir;
572:
573: int rdev, rino;
574: int off;
575: register i,j;
576:
577: name[off= 0] = '/';
578: name[1] = '\0';
579: buf[0] = '\0';
580: stat("/", &d);
581: rdev = d.st_dev;
582: rino = d.st_ino;
583: for (;;) {
584: if (stat(dot, &d)<0) return NULL;
585: if (d.st_ino==rino && d.st_dev==rdev) {
586: if (name[off] == '/') name[off] = '\0';
587: chdir(name); /*change back to current directory*/
588: return name;
589: }
590: if ((file = fopen(dotdot,"r")) == NULL) return NULL;
591: if (fstat(fileno(file), &dd)<0) goto fail;
592: chdir(dotdot);
593: if(d.st_dev == dd.st_dev) {
594: if(d.st_ino == dd.st_ino) {
595: if (name[off] == '/') name[off] = '\0';
596: chdir(name); /*change back to current directory*/
597: fclose(file);
598: return name;
599: }
600: do {
601: if (fread((char *)&dir, sizeof(dir), 1, file) !=1)
602: goto fail;
603: } while (dir.d_ino != d.st_ino);
604: }
605: else do {
606: if(fread((char *)&dir, sizeof(dir), 1, file) != 1) {
607: goto fail;
608: }
609: stat(dir.d_name, &dd);
610: } while(dd.st_ino != d.st_ino || dd.st_dev != d.st_dev);
611: fclose(file);
612:
613: /* concatenate file name */
614: i = -1;
615: while (dir.d_name[++i] != 0);
616: for(j=off+1; j>0; --j)
617: name[j+i+1] = name[j];
618: off=i+off+1;
619: name[i+1] = '/';
620: for(--i; i>=0; --i)
621: name[i+1] = dir.d_name[i];
622: } /* end for */
623:
624: fail: fclose(file);
625: return NULL;
626: }
627:
628:
629: #endif
630:
631:
632: #ifdef PAIRTEST
633: /* test program for pairfilenames() and getfullRCSname() */
634: char * workfilename, *RCSfilename;
635:
636: main(argc, argv)
637: int argc; char *argv[];
638: {
639: int result;
640: int initflag,tostdout;
641: tostdout=initflag=false;
642: cmdid="pair";
643:
644: while(--argc, ++argv, argc>=1 && ((*argv)[0] == '-')) {
645: switch ((*argv)[1]) {
646:
647: case 'p': tostdout=true;
648: break;
649: case 'i': initflag=true;
650: break;
651: }
652: }
653:
654: do {
655: RCSfilename=workfilename=nil;
656: result=pairfilenames(argc,argv,!initflag,tostdout);
657: if (result!=0) {
658: diagnose("RCSfile: %s; working file: %s",RCSfilename,workfilename);
659: diagnose("Full RCS file name: %s", getfullRCSname());
660: }
661: switch (result) {
662: case 0: continue; /* already paired file */
663:
664: case 1: if (initflag) {
665: error("RCS file exists already");
666: continue;
667: } else {
668: diagnose("RCS file exists");
669: }
670: break;
671:
672: case -1:diagnose("RCS file does not exist");
673: break;
674: }
675:
676: } while (++argv, --argc>=1);
677:
678: }
679: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.