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