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