![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ckufio.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / kermit|
Return to ckufio.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / kermit |
1.1 ! root 1: char *ckzv = "Unix file support, 4C(032) 25 Jul 85"; ! 2: ! 3: /* C K U F I O -- Kermit file system support for Unix systems */ ! 4: ! 5: /* ! 6: Author: Frank da Cruz (SY.FDC@CU20B), ! 7: Columbia University Center for Computing Activities, January 1985. ! 8: Copyright (C) 1985, Trustees of Columbia University in the City of New York. ! 9: Permission is granted to any individual or institution to use, copy, or ! 10: redistribute this software so long as it is not sold for profit, provided this ! 11: copyright notice is retained. ! 12: */ ! 13: /* Includes */ ! 14: ! 15: #include "ckcker.h" /* Kermit definitions */ ! 16: #include "ckcdeb.h" /* Typedefs, debug formats, etc */ ! 17: #include <ctype.h> /* Character types */ ! 18: #include <stdio.h> /* Standard i/o */ ! 19: #include <sys/types.h> /* Data types */ ! 20: #include <sys/dir.h> /* Directory structure */ ! 21: #include <sys/stat.h> /* File status */ ! 22: #include <pwd.h> /* Password file for shell name */ ! 23: ! 24: /* Berkeley Unix Version 4.x */ ! 25: /* 4.1bsd support added by Charles E Brooks, EDN-VAX */ ! 26: ! 27: #ifdef BSD4 ! 28: #ifdef MAXNAMLEN ! 29: #define BSD42 ! 30: char *ckzsys = " 4.2 BSD"; ! 31: #else ! 32: #ifdef FT17 ! 33: #define BSD41 ! 34: char *ckzsys = " For:Pro Fortune 1.7"; ! 35: #else ! 36: #define BSD41 ! 37: char *ckzsys = " 4.1 BSD"; ! 38: #endif ! 39: #endif ! 40: #endif ! 41: ! 42: /* 2.9bsd support contributed by Bradley Smith, UCLA */ ! 43: #ifdef BSD29 ! 44: char *ckzsys = " 2.9 BSD"; ! 45: #endif ! 46: ! 47: /* Version 7 Unix */ ! 48: #ifdef V7 ! 49: char *ckzsys = " Version 7 Unix"; ! 50: #endif ! 51: ! 52: /* DEC Professional-300 series with Venturcom Venix v1 */ ! 53: #ifdef PROVX1 ! 54: char *ckzsys = " DEC Pro-3xx/Venix v1"; ! 55: #endif ! 56: ! 57: /* NCR Tower support contributed by John Bray, Auburn, AL. */ ! 58: /* Tower OS is like Sys III but with BSD features -- mostly follows BSD. */ ! 59: #ifdef TOWER1 ! 60: char *ckzsys = " NCR Tower 1632, OS 1.02"; ! 61: #endif ! 62: ! 63: /* Sys III/V, Xenix, PC/IX,... support by Herm Fischer, Litton Data Systems */ ! 64: #ifdef UXIII ! 65: #ifdef XENIX ! 66: char *ckzsys = " Xenix/286"; ! 67: #else ! 68: #ifdef PCIX ! 69: char *ckzsys = " PC/IX"; ! 70: #else ! 71: #ifdef ISIII ! 72: char *ckzsys = " Interactive Systems Corp, System III"; ! 73: #else ! 74: char *ckzsys = " AT&T System III/System V"; ! 75: #endif ! 76: #endif ! 77: #endif ! 78: #endif ! 79: ! 80: /* Definitions of some Unix system commands */ ! 81: ! 82: char *DIRCMD = "ls -l "; /* For directory listing */ ! 83: char *DELCMD = "rm -f "; /* For file deletion */ ! 84: char *TYPCMD = "cat "; /* For typing a file */ ! 85: char *PWDCMD = "pwd "; /* For saying where I am */ ! 86: ! 87: #ifdef BSD4 ! 88: char *SPACMD = "pwd ; quota ; df ."; /* Space/quota of current directory */ ! 89: #else ! 90: char *SPACMD = "df "; ! 91: #endif ! 92: ! 93: char *SPACM2 = "df "; /* For space in specified directory */ ! 94: ! 95: #ifdef BSD4 ! 96: char *WHOCMD = "finger "; /* For seeing who's logged in */ ! 97: #else ! 98: char *WHOCMD = "who "; /* For seeing who's logged in */ ! 99: #endif ! 100: ! 101: /* ! 102: Functions (n is one of the predefined file numbers from ckermi.h): ! 103: ! 104: zopeni(n,name) -- Opens an existing file for input. ! 105: zopeno(n,name) -- Opens a new file for output. ! 106: zclose(n) -- Closes a file. ! 107: zchin(n,&c) -- Gets the next character from an input file. ! 108: zsout(n,s) -- Write a null-terminated string to output file, buffered. ! 109: zsoutl(n,s) -- Like zsout, but appends a line terminator. ! 110: zsoutx(n,s,x) -- Write x characters to output file, unbuffered. ! 111: zchout(n,c) -- Add a character to an output file, unbuffered. ! 112: zchki(name) -- Check if named file exists and is readable, return size. ! 113: zchko(name) -- Check if named file can be created. ! 114: znewn(name,s) -- Make a new unique file name based on the given name. ! 115: zdelet(name) -- Delete the named file. ! 116: zxpand(string) -- Expands the given wildcard string into a list of files. ! 117: znext(string) -- Returns the next file from the list in "string". ! 118: zxcmd(cmd) -- Execute the command in a lower fork. ! 119: zclosf() -- Close input file associated with zxcmd()'s lower fork. ! 120: zrtol(n1,n2) -- Convert remote filename into local form. ! 121: zltor(n1,n2) -- Convert local filename into remote form. ! 122: zchdir(dirnam) -- Change working directory. ! 123: zhome() -- Return pointer to home directory name string. ! 124: zkself() -- Kill self, log out own job. ! 125: */ ! 126: ! 127: ! 128: #ifdef FT17 ! 129: #define PROVX1 ! 130: #endif ! 131: #ifndef PROVX1 ! 132: #include <sys/file.h> /* File access */ ! 133: #endif ! 134: #ifdef FT17 ! 135: #undef PROVX1 ! 136: #endif ! 137: ! 138: /* Some systems define these in include files, others don't... */ ! 139: #ifndef R_OK ! 140: #define R_OK 4 /* For access */ ! 141: #endif ! 142: ! 143: #ifndef W_OK ! 144: #define W_OK 2 ! 145: #endif ! 146: ! 147: #ifdef PROVX1 ! 148: #define MAXNAMLEN DIRSIZ /* Max file name length */ ! 149: #endif ! 150: ! 151: #ifdef UXIII ! 152: #include <fcntl.h> ! 153: #define MAXNAMLEN DIRSIZ ! 154: #endif ! 155: ! 156: #ifndef O_RDONLY ! 157: #define O_RDONLY 000 ! 158: #endif ! 159: ! 160: #ifndef MAXNAMLEN ! 161: #define MAXNAMLEN 14 /* If still not defined... */ ! 162: #endif ! 163: ! 164: #ifdef PROVX1 ! 165: #define MAXWLD 50 /* Maximum wildcard filenames */ ! 166: #else ! 167: #define MAXWLD 500 ! 168: #endif ! 169: ! 170: /* Declarations */ ! 171: ! 172: FILE *fp[ZNFILS] = { /* File pointers */ ! 173: NULL, NULL, NULL, NULL, NULL, NULL, NULL }; ! 174: ! 175: static int pid; /* pid of child fork */ ! 176: static int fcount; /* Number of files in wild group */ ! 177: static char nambuf[MAXNAMLEN+1]; /* Buffer for a filename */ ! 178: char *malloc(), *getenv(), *strcpy(); /* System functions */ ! 179: extern errno; /* System error code */ ! 180: ! 181: static char *mtchs[MAXWLD], /* Matches found for filename */ ! 182: **mtchptr; /* Pointer to current match */ ! 183: ! 184: /* Z K S E L F -- Kill Self: log out own job, if possible. */ ! 185: ! 186: zkself() { /* For "bye", but no guarantee! */ ! 187: #ifdef PROVX1 ! 188: return(kill(0,9)); ! 189: #else ! 190: #ifdef V7 ! 191: return(kill(0,9)); ! 192: #else ! 193: #ifdef TOWER1 ! 194: return(kill(0,9)); ! 195: #else ! 196: #ifdef FT17 ! 197: return(kill(0,9)); ! 198: #else ! 199: return(kill(getppid(),1)); ! 200: #endif ! 201: #endif ! 202: #endif ! 203: #endif ! 204: } ! 205: ! 206: /* Z O P E N I -- Open an existing file for input. */ ! 207: ! 208: zopeni(n,name) int n; char *name; { ! 209: debug(F111," zopeni",name,n); ! 210: debug(F101," fp","",(int) fp[n]); ! 211: if (chkfn(n) != 0) return(0); ! 212: if (n == ZSYSFN) { /* Input from a system function? */ ! 213: debug(F110," invoking zxcmd",name,0); ! 214: return(zxcmd(name)); /* Try to fork the command */ ! 215: } ! 216: if (n == ZSTDIO) { /* Standard input? */ ! 217: if (isatty(0)) { ! 218: ermsg("Terminal input not allowed"); ! 219: debug(F110,"zopeni: attempts input from unredirected stdin","",0); ! 220: return(0); ! 221: } ! 222: fp[ZIFILE] = stdin; ! 223: return(1); ! 224: } ! 225: fp[n] = fopen(name,"r"); /* Real file. */ ! 226: debug(F111," zopeni", name, (int) fp[n]); ! 227: if (fp[n] == NULL) perror("zopeni"); ! 228: return((fp[n] != NULL) ? 1 : 0); ! 229: } ! 230: ! 231: /* Z O P E N O -- Open a new file for output. */ ! 232: ! 233: zopeno(n,name) int n; char *name; { ! 234: debug(F111," zopeno",name,n); ! 235: if (chkfn(n) != 0) return(0); ! 236: if ((n == ZCTERM) || (n == ZSTDIO)) { /* Terminal or standard output */ ! 237: fp[ZOFILE] = stdout; ! 238: debug(F101," fp[]=stdout", "", (int) fp[n]); ! 239: return(1); ! 240: } ! 241: fp[n] = fopen(name,"w"); /* A real file, try to open */ ! 242: if (fp[n] == NULL) { ! 243: perror("zopeno can't open"); ! 244: } else { ! 245: chown(name, getuid(), getgid()); /* In case set[gu]id */ ! 246: if (n == ZDFILE) setbuf(fp[n],NULL); /* Debugging file unbuffered */ ! 247: } ! 248: debug(F101, " fp[n]", "", (int) fp[n]); ! 249: return((fp[n] != NULL) ? 1 : 0); ! 250: } ! 251: ! 252: /* Z C L O S E -- Close the given file. */ ! 253: ! 254: /* Returns 0 if arg out of range, 1 if successful, -1 if close failed. */ ! 255: ! 256: zclose(n) int n; { ! 257: int x; ! 258: if (chkfn(n) < 1) return(0); /* Check range of n */ ! 259: if ((n == ZIFILE) && fp[ZSYSFN]) { /* If system function */ ! 260: x = zclosf(); /* do it specially */ ! 261: } else { ! 262: if ((fp[n] != stdout) && (fp[n] != stdin)) x = fclose(fp[n]); ! 263: fp[n] = NULL; ! 264: } ! 265: return((x == EOF) ? -1 : 1); ! 266: } ! 267: ! 268: /* Z C H I N -- Get a character from the input file. */ ! 269: ! 270: /* Returns -1 if EOF, 0 otherwise with character returned in argument */ ! 271: ! 272: zchin(n,c) int n; char *c; { ! 273: int a; ! 274: if (chkfn(n) < 1) return(-1); ! 275: a = getc(fp[n]); ! 276: if (a == EOF) return(-1); ! 277: *c = a & 0377; ! 278: return(0); ! 279: } ! 280: ! 281: /* Z S O U T -- Write a string to the given file, buffered. */ ! 282: ! 283: zsout(n,s) int n; char *s; { ! 284: if (chkfn(n) < 1) return(-1); ! 285: fputs(s,fp[n]); ! 286: return(0); ! 287: } ! 288: ! 289: /* Z S O U T L -- Write string to file, with line terminator, buffered */ ! 290: ! 291: zsoutl(n,s) int n; char *s; { ! 292: if (chkfn(n) < 1) return(-1); ! 293: fputs(s,fp[n]); ! 294: fputs("\n",fp[n]); ! 295: return(0); ! 296: } ! 297: ! 298: /* Z S O U T X -- Write x characters to file, unbuffered. */ ! 299: ! 300: zsoutx(n,s,x) int n, x; char *s; { ! 301: if (chkfn(n) < 1) return(-1); ! 302: return(write(fp[n]->_file,s,x)); ! 303: } ! 304: ! 305: ! 306: /* Z C H O U T -- Add a character to the given file. */ ! 307: ! 308: /* Should return 0 or greater on success, -1 on failure (e.g. disk full) */ ! 309: ! 310: zchout(n,c) int n; char c; { ! 311: if (chkfn(n) < 1) return(-1); ! 312: if (n == ZSFILE) ! 313: return(write(fp[n]->_file,&c,1)); /* Use unbuffered for session log */ ! 314: else { /* Buffered for everything else */ ! 315: if (putc(c,fp[n]) == EOF) /* If true, maybe there was an error */ ! 316: return(ferror(fp[n])); /* Check to make sure */ ! 317: else /* Otherwise... */ ! 318: return(0); /* There was no error. */ ! 319: } ! 320: } ! 321: ! 322: /* C H K F N -- Internal function to verify file number is ok */ ! 323: ! 324: /* ! 325: Returns: ! 326: -1: File number n is out of range ! 327: 0: n is in range, but file is not open ! 328: 1: n in range and file is open ! 329: */ ! 330: chkfn(n) int n; { ! 331: switch (n) { ! 332: case ZCTERM: ! 333: case ZSTDIO: ! 334: case ZIFILE: ! 335: case ZOFILE: ! 336: case ZDFILE: ! 337: case ZTFILE: ! 338: case ZPFILE: ! 339: case ZSFILE: ! 340: case ZSYSFN: break; ! 341: default: ! 342: debug(F101,"chkfn: file number out of range","",n); ! 343: fprintf(stderr,"?File number out of range - %d\n",n); ! 344: return(-1); ! 345: } ! 346: return( (fp[n] == NULL) ? 0 : 1 ); ! 347: } ! 348: ! 349: /* Z C H K I -- Check if input file exists and is readable */ ! 350: ! 351: /* ! 352: Returns: ! 353: >= 0 if the file can be read (returns the size). ! 354: -1 if file doesn't exist or can't be accessed, ! 355: -2 if file exists but is not readable (e.g. a directory file). ! 356: -3 if file exists but protected against read access. ! 357: */ ! 358: /* ! 359: For Berkeley Unix, a file must be of type "regular" to be readable. ! 360: Directory files, special files, and symbolic links are not readable. ! 361: */ ! 362: long ! 363: zchki(name) char *name; { ! 364: struct stat buf; ! 365: int x; long y; ! 366: ! 367: x = stat(name,&buf); ! 368: if (x < 0) { ! 369: debug(F111,"zchki stat fails",name,errno); ! 370: return(-1); ! 371: } ! 372: x = buf.st_mode & S_IFMT; /* Isolate file format field */ ! 373: if ((x != 0) && (x != S_IFREG)) { ! 374: debug(F111,"zchki skipping:",name,x); ! 375: return(-2); ! 376: } ! 377: debug(F111,"zchki stat ok:",name,x); ! 378: ! 379: if ((x = access(name,R_OK)) < 0) { /* Is the file accessible? */ ! 380: debug(F111," access failed:",name,x); /* No */ ! 381: return(-3); ! 382: } else { ! 383: y = buf.st_size; ! 384: debug(F111," access ok:",name,(int) y); /* Yes */ ! 385: return( (y > -1) ? y : 0 ); ! 386: } ! 387: } ! 388: ! 389: /* Z C H K O -- Check if output file can be created */ ! 390: ! 391: /* ! 392: Returns -1 if write permission for the file would be denied, 0 otherwise. ! 393: */ ! 394: zchko(name) char *name; { ! 395: int i, x; ! 396: char s[50], *sp; ! 397: ! 398: sp = s; /* Make a copy, get length */ ! 399: x = 0; ! 400: while ((*sp++ = *name++) != '\0') ! 401: x++; ! 402: if (x == 0) return(-1); /* If no filename, fail. */ ! 403: ! 404: debug(F101," length","",x); ! 405: for (i = x; i > 0; i--) /* Strip filename. */ ! 406: if (s[i-1] == '/') break; ! 407: ! 408: debug(F101," i","",i); ! 409: if (i == 0) /* If no path, use current directory */ ! 410: strcpy(s,"./"); ! 411: else /* Otherwise, use given one. */ ! 412: s[i] = '\0'; ! 413: ! 414: x = access(s,W_OK); /* Check access of path. */ ! 415: if (x < 0) { ! 416: debug(F111,"zchko access failed:",s,errno); ! 417: return(-1); ! 418: } else { ! 419: debug(F111,"zchko access ok:",s,x); ! 420: return(0); ! 421: } ! 422: } ! 423: ! 424: /* Z D E L E T -- Delete the named file. */ ! 425: ! 426: zdelet(name) char *name; { ! 427: unlink(name); ! 428: } ! 429: ! 430: ! 431: /* Z R T O L -- Convert remote filename into local form */ ! 432: ! 433: /* For UNIX, this means changing uppercase letters to lowercase. */ ! 434: ! 435: zrtol(name,name2) char *name, *name2; { ! 436: for ( ; *name != '\0'; name++) { ! 437: *name2++ = isupper(*name) ? tolower(*name) : *name; ! 438: } ! 439: *name2 = '\0'; ! 440: debug(F110,"zrtol:",name2,0); ! 441: } ! 442: ! 443: ! 444: /* Z L T O R -- Local TO Remote */ ! 445: ! 446: /* Convert filename from local format to common (remote) form. */ ! 447: ! 448: zltor(name,name2) char *name, *name2; { ! 449: char work[100], *cp, *pp; ! 450: int dc = 0; ! 451: ! 452: debug(F110,"zltor",name,0); ! 453: pp = work; ! 454: for (cp = name; *cp != '\0'; cp++) { /* strip path name */ ! 455: if (*cp == '/') { ! 456: dc = 0; ! 457: pp = work; ! 458: } ! 459: else if (islower(*cp)) *pp++ = toupper(*cp); /* Uppercase letters */ ! 460: else if (*cp == '~') *pp++ = 'X'; /* Change tilde to 'X' */ ! 461: else if (*cp == '#') *pp++ = 'X'; /* Change number sign to 'X' */ ! 462: else if ((*cp == '.') && (++dc > 1)) *pp++ = 'X'; /* & extra dots */ ! 463: else *pp++ = *cp; ! 464: } ! 465: *pp = '\0'; /* Tie it off. */ ! 466: cp = name2; /* If nothing before dot, */ ! 467: if (*work == '.') *cp++ = 'X'; /* insert 'X' */ ! 468: strcpy(cp,work); ! 469: debug(F110," name2",name2,0); ! 470: } ! 471: ! 472: ! 473: /* Z C H D I R -- Change directory */ ! 474: ! 475: zchdir(dirnam) char *dirnam; { ! 476: char *hd; ! 477: if (*dirnam == '\0') hd = getenv("HOME"); ! 478: else hd = dirnam; ! 479: return((chdir(hd) == 0) ? 1 : 0); ! 480: } ! 481: ! 482: ! 483: /* Z H O M E -- Return pointer to user's home directory */ ! 484: ! 485: char * ! 486: zhome() { ! 487: return(getenv("HOME")); ! 488: } ! 489: ! 490: /* Z X C M D -- Run a system command so its output can be read like a file */ ! 491: ! 492: zxcmd(comand) char *comand; { ! 493: int pipes[2]; ! 494: if (pipe(pipes) != 0) return(0); /* can't make pipe, fail */ ! 495: if ((pid = fork()) == 0) { /* child */ ! 496: ! 497: /*#if BSD4*/ /* Code from Dave Tweten@AMES-NAS */ ! 498: /* readapted to use getpwuid to find login shell */ ! 499: /* -- H. Fischer */ ! 500: char *shpath, *shname, *shptr; /* to find desired shell */ ! 501: struct passwd *p; ! 502: extern struct passwd * getpwuid(); ! 503: extern int getuid(); ! 504: char *defShel = "/bin/sh"; /* default shell */ ! 505: /*#endif*/ ! 506: ! 507: close(pipes[0]); /* close input side of pipe */ ! 508: close(0); /* close stdin */ ! 509: if (open("/dev/null",0) < 0) return(0); /* replace input by null */ ! 510: ! 511: #ifndef UXIII ! 512: dup2(pipes[1],1); /* replace stdout & stderr */ ! 513: dup2(pipes[1],2); /* by the pipe */ ! 514: #else ! 515: close(1); /* simulate dup2 */ ! 516: if (dup(pipes[1]) != 1 ) ! 517: conol("trouble duping stdout in routine zxcmd\n"); ! 518: close(2); /* simulate dup2 */ ! 519: if (dup(pipes[1]) != 2 ) ! 520: conol("trouble duping stderr in routine zxcmd\n"); ! 521: #endif ! 522: ! 523: close(pipes[1]); /* get rid of this copy of the pipe */ ! 524: ! 525: /**** shptr = shname = shpath = getenv("SHELL"); /* What shell? */ ! 526: p = getpwuid( getuid() ); /* get login data */ ! 527: if ( p == (struct passwd *) NULL || !*(p->pw_shell) ) shpath = defShel; ! 528: else shpath = p->pw_shell; ! 529: shptr = shname = shpath; ! 530: while (*shptr != '\0') if (*shptr++ == '/') shname = shptr; ! 531: debug(F100,"zxcmd...","",0); ! 532: debug(F110,shpath,shname,0); ! 533: execl(shpath,shname,"-c",comand,0); /* Execute the command */ ! 534: ! 535: /**** execl("/bin/sh","sh","-c",comand,0); /* Execute the command */ ! 536: ! 537: exit(0); /* just punt if it didnt work */ ! 538: } ! 539: close(pipes[1]); /* don't need the output side */ ! 540: fp[ZIFILE] = fdopen(pipes[0],"r"); /* open a stream for it */ ! 541: fp[ZSYSFN] = fp[ZIFILE]; /* Remember. */ ! 542: return(1); ! 543: } ! 544: ! 545: /* Z C L O S F - wait for the child fork to terminate and close the pipe. */ ! 546: ! 547: zclosf() { ! 548: int wstat; ! 549: fclose(fp[ZIFILE]); ! 550: fp[ZIFILE] = fp[ZSYSFN] = NULL; ! 551: while ((wstat = wait(0)) != pid && wstat != -1) ; ! 552: return(1); ! 553: } ! 554: ! 555: /* Z X P A N D -- Expand a wildcard string into an array of strings */ ! 556: /* ! 557: Returns the number of files that match fn1, with data structures set up ! 558: so that first file (if any) will be returned by the next znext() call. ! 559: */ ! 560: zxpand(fn) char *fn; { ! 561: fcount = fgen(fn,mtchs,MAXWLD); /* Look up the file. */ ! 562: if (fcount > 0) { ! 563: mtchptr = mtchs; /* Save pointer for next. */ ! 564: } ! 565: debug(F111,"zxpand",mtchs[0],fcount); ! 566: return(fcount); ! 567: } ! 568: ! 569: ! 570: /* Z N E X T -- Get name of next file from list created by zxpand(). */ ! 571: /* ! 572: Returns >0 if there's another file, with its name copied into the arg string, ! 573: or 0 if no more files in list. ! 574: */ ! 575: znext(fn) char *fn; { ! 576: if (fcount-- > 0) strcpy(fn,*mtchptr++); ! 577: else *fn = '\0'; ! 578: debug(F111,"znext",fn,fcount+1); ! 579: return(fcount+1); ! 580: } ! 581: ! 582: ! 583: /* Z N E W N -- Make a new name for the given file */ ! 584: ! 585: znewn(fn,s) char *fn, **s; { ! 586: static char buf[100]; ! 587: char *bp, *xp; ! 588: int len = 0, n = 0, d = 0, t; ! 589: #ifdef MAXNAMLEN ! 590: int max = MAXNAMLEN; ! 591: #else ! 592: int max = 14; ! 593: #endif ! 594: ! 595: bp = buf; ! 596: while (*fn) { /* Copy name into buf */ ! 597: *bp++ = *fn++; ! 598: len++; ! 599: } ! 600: if (len > max-3) bp -= 3; /* Don't let it get too long */ ! 601: ! 602: *bp++ = '*'; /* Put a star on the end */ ! 603: *bp-- = '\0'; ! 604: ! 605: n = zxpand(buf); /* Expand the resulting wild name */ ! 606: ! 607: while (n-- > 0) { /* Find any existing name~d files */ ! 608: xp = *mtchptr++; ! 609: xp += len; ! 610: if (*xp == '~') { ! 611: t = atoi(xp+1); ! 612: if (t > d) d = t; /* Get maximum d */ ! 613: } ! 614: } ! 615: sprintf(bp,"~%d",d+1); /* Make name~(d+1) */ ! 616: *s = buf; ! 617: } ! 618: ! 619: /* Directory Functions for Unix, written by Jeff Damens, CUCCA, 1984. */ ! 620: ! 621: /* ! 622: * The path structure is used to represent the name to match. ! 623: * Each slash-separated segment of the name is kept in one ! 624: * such structure, and they are linked together, to make ! 625: * traversing the name easier. ! 626: */ ! 627: ! 628: struct path { ! 629: char npart[MAXNAMLEN]; /* name part of path segment */ ! 630: struct path *fwd; /* forward ptr */ ! 631: }; ! 632: ! 633: #ifdef PROVX1 ! 634: #define SSPACE 500 ! 635: #else ! 636: #define SSPACE 2000 /* size of string-generating buffer */ ! 637: #endif ! 638: static char sspace[SSPACE]; /* buffer to generate names in */ ! 639: static char *freeptr,**resptr; /* copies of caller's arguments */ ! 640: static int remlen; /* remaining length in caller's array*/ ! 641: static int numfnd; /* number of matches found */ ! 642: ! 643: /* ! 644: * splitpath: ! 645: * takes a string and splits the slash-separated portions into ! 646: * a list of path structures. Returns the head of the list. The ! 647: * structures are allocated by malloc, so they must be freed. ! 648: * Splitpath is used internally by the filename generator. ! 649: * ! 650: * Input: A string. ! 651: * Returns: A linked list of the slash-separated segments of the input. ! 652: */ ! 653: ! 654: struct path * ! 655: splitpath(p) ! 656: char *p; ! 657: { ! 658: struct path *head,*cur,*prv; ! 659: int i; ! 660: head = prv = NULL; ! 661: if (*p == '/') p++; /* skip leading slash */ ! 662: while (*p != '\0') ! 663: { ! 664: cur = (struct path *) malloc(sizeof (struct path)); ! 665: debug(F101,"splitpath malloc","",cur); ! 666: if (cur == NULL) fatal("malloc fails in splitpath()"); ! 667: cur -> fwd = NULL; ! 668: if (head == NULL) head = cur; ! 669: else prv -> fwd = cur; /* link into chain */ ! 670: prv = cur; ! 671: for (i=0; i < MAXNAMLEN && *p != '/' && *p != '\0'; i++) ! 672: cur -> npart[i] = *p++; ! 673: cur -> npart[i] = '\0'; /* end this segment */ ! 674: if (i >= MAXNAMLEN) while (*p != '/' && *p != '\0') p++; ! 675: if (*p == '/') p++; ! 676: } ! 677: return(head); ! 678: } ! 679: ! 680: /* ! 681: * fgen: ! 682: * This is the actual name generator. It is passed a string, ! 683: * possibly containing wildcards, and an array of character pointers. ! 684: * It finds all the matching filenames and stores them into the array. ! 685: * The returned strings are allocated from a static buffer local to ! 686: * this module (so the caller doesn't have to worry about deallocating ! 687: * them); this means that successive calls to fgen will wipe out ! 688: * the results of previous calls. This isn't a problem here ! 689: * because we process one wildcard string at a time. ! 690: * ! 691: * Input: a wildcard string, an array to write names to, the ! 692: * length of the array. ! 693: * Returns: the number of matches. The array is filled with filenames ! 694: * that matched the pattern. If there wasn't enough room in the ! 695: * array, -1 is returned. ! 696: * By: Jeff Damens, CUCCA, 1984. ! 697: */ ! 698: ! 699: fgen(pat,resarry,len) ! 700: char *pat,*resarry[]; ! 701: int len; ! 702: { ! 703: struct path *head; ! 704: char scratch[100],*sptr; ! 705: head = splitpath(pat); ! 706: if (*pat == '/') ! 707: { ! 708: scratch[0] = '/'; ! 709: sptr = scratch+1; ! 710: } ! 711: else ! 712: { ! 713: strcpy(scratch,"./"); ! 714: sptr = scratch+2; ! 715: } /* init buffer correctly */ ! 716: numfnd = 0; /* none found yet */ ! 717: freeptr = sspace; /* this is where matches are copied */ ! 718: resptr = resarry; /* static copies of these so*/ ! 719: remlen = len; /* recursive calls can alter them */ ! 720: traverse(head,scratch,sptr); /* go walk the directory tree */ ! 721: for (; head != NULL; head = head -> fwd) ! 722: free(head); /* return the path segments */ ! 723: return(numfnd); /* and return the number of matches */ ! 724: } ! 725: ! 726: /* traverse: ! 727: * Walks the directory tree looking for matches to its arguments. ! 728: * The algorithm is, briefly: ! 729: * If the current pattern segment contains no wildcards, that ! 730: * segment is added to what we already have. If the name so far ! 731: * exists, we call ourselves recursively with the next segment ! 732: * in the pattern string; otherwise, we just return. ! 733: * ! 734: * If the current pattern segment contains wildcards, we open the name ! 735: * we've accumulated so far (assuming it is really a directory), then read ! 736: * each filename in it, and, if it matches the wildcard pattern segment, add ! 737: * that filename to what we have so far and call ourselves recursively on the ! 738: * next segment. ! 739: * ! 740: * Finally, when no more pattern segments remain, we add what's accumulated ! 741: * so far to the result array and increment the number of matches. ! 742: * ! 743: * Input: a pattern path list (as generated by splitpath), a string ! 744: * pointer that points to what we've traversed so far (this ! 745: * can be initialized to "/" to start the search at the root ! 746: * directory, or to "./" to start the search at the current ! 747: * directory), and a string pointer to the end of the string ! 748: * in the previous argument. ! 749: * Returns: nothing. ! 750: */ ! 751: traverse(pl,sofar,endcur) ! 752: struct path *pl; ! 753: char *sofar,*endcur; ! 754: { ! 755: #ifdef BSD42 ! 756: DIR *fd, *opendir(); ! 757: struct direct *dirbuf; ! 758: #else ! 759: int fd; ! 760: struct direct dir_entry; ! 761: struct direct *dirbuf = &dir_entry; ! 762: #endif ! 763: struct stat statbuf; ! 764: if (pl == NULL) ! 765: { ! 766: *--endcur = '\0'; /* end string, overwrite trailing / */ ! 767: addresult(sofar); ! 768: return; ! 769: } ! 770: if (!iswild(pl -> npart)) ! 771: { ! 772: strcpy(endcur,pl -> npart); ! 773: endcur += strlen(pl -> npart); ! 774: *endcur = '\0'; /* end current string */ ! 775: if (stat(sofar,&statbuf) == 0) /* if current piece exists */ ! 776: { ! 777: *endcur++ = '/'; /* add slash to end */ ! 778: *endcur = '\0'; /* and end the string */ ! 779: traverse(pl -> fwd,sofar,endcur); ! 780: } ! 781: return; ! 782: } ! 783: /* cont'd... */ ! 784: ! 785: /*...traverse, cont'd */ ! 786: ! 787: /* segment contains wildcards, have to search directory */ ! 788: *endcur = '\0'; /* end current string */ ! 789: if (stat(sofar,&statbuf) == -1) return; /* doesn't exist, forget it */ ! 790: if ((statbuf.st_mode & S_IFDIR) == 0) return; /* not a directory, skip */ ! 791: #ifdef BSD42 /* ==BSD4 */ ! 792: if ((fd = opendir(sofar)) == NULL) return; /* can't open, forget it */ ! 793: while (dirbuf = readdir(fd)) ! 794: #else ! 795: if ((fd = open(sofar,O_RDONLY)) < 0) return; /* can't open, forget it */ ! 796: while ( read(fd,dirbuf,sizeof dir_entry) ) ! 797: #endif ! 798: { ! 799: strncpy(nambuf,dirbuf->d_name,MAXNAMLEN); /* Get a null terminated copy!!! */ ! 800: nambuf[MAXNAMLEN] = '\0'; ! 801: if (dirbuf->d_ino != 0 && match(pl -> npart,nambuf)) { ! 802: char *eos; ! 803: strcpy(endcur,nambuf); ! 804: eos = endcur + strlen(nambuf); ! 805: *eos = '/'; /* end this segment */ ! 806: traverse(pl -> fwd,sofar,eos+1); ! 807: } ! 808: } ! 809: #ifdef BSD42 /* ==BSD4 */ ! 810: closedir(fd); ! 811: #else ! 812: close(fd); ! 813: #endif ! 814: } ! 815: ! 816: /* ! 817: * addresult: ! 818: * Adds a result string to the result array. Increments the number ! 819: * of matches found, copies the found string into our string ! 820: * buffer, and puts a pointer to the buffer into the caller's result ! 821: * array. Our free buffer pointer is updated. If there is no ! 822: * more room in the caller's array, the number of matches is set to -1. ! 823: * Input: a result string. ! 824: * Returns: nothing. ! 825: */ ! 826: ! 827: addresult(str) ! 828: char *str; ! 829: { ! 830: int l; ! 831: if (strncmp(str,"./",2) == 0) str += 2; ! 832: if (--remlen < 0) { ! 833: numfnd = -1; ! 834: return; ! 835: } ! 836: l = strlen(str) + 1; /* size this will take up */ ! 837: if ((freeptr + l) > &sspace[SSPACE]) { ! 838: numfnd = -1; /* do not record if not enough space */ ! 839: return; ! 840: } ! 841: strcpy(freeptr,str); ! 842: *resptr++ = freeptr; ! 843: freeptr += l; ! 844: numfnd++; ! 845: } ! 846: ! 847: iswild(str) ! 848: char *str; ! 849: { ! 850: char c; ! 851: while ((c = *str++) != '\0') ! 852: if (c == '*' || c == '?') return(1); ! 853: return(0); ! 854: } ! 855: ! 856: /* ! 857: * match: ! 858: * pattern matcher. Takes a string and a pattern possibly containing ! 859: * the wildcard characters '*' and '?'. Returns true if the pattern ! 860: * matches the string, false otherwise. ! 861: * by: Jeff Damens, CUCCA ! 862: * ! 863: * Input: a string and a wildcard pattern. ! 864: * Returns: 1 if match, 0 if no match. ! 865: */ ! 866: ! 867: match(pattern,string) char *pattern,*string; { ! 868: char *psave,*ssave; /* back up pointers for failure */ ! 869: psave = ssave = NULL; ! 870: while (1) { ! 871: for (; *pattern == *string; pattern++,string++) /* skip first */ ! 872: if (*string == '\0') return(1); /* end of strings, succeed */ ! 873: if (*string != '\0' && *pattern == '?') { ! 874: pattern++; /* '?', let it match */ ! 875: string++; ! 876: } else if (*pattern == '*') { /* '*' ... */ ! 877: psave = ++pattern; /* remember where we saw it */ ! 878: ssave = string; /* let it match 0 chars */ ! 879: } else if (ssave != NULL && *ssave != '\0') { /* if not at end */ ! 880: /* ...have seen a star */ ! 881: string = ++ssave; /* skip 1 char from string */ ! 882: pattern = psave; /* and back up pattern */ ! 883: } else return(0); /* otherwise just fail */ ! 884: } ! 885: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.