![[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 [MW Coherent from dump] / coherent / e / bin / cku179|
Return to ckufio.c CVS log | Up to [MW Coherent from dump] / coherent / e / bin / cku179 |
1.1 root 1: char *ckzv = "File support, 5A(058) 21 Jan 92";
2:
3: /* C K U F I O -- Kermit file system support for UNIX, OS/2, and Aegis */
4:
5: /*
6: Author: Frank da Cruz ([email protected], [email protected]),
7: Columbia University Center for Computing Activities. Many other contributors.
8: First released January 1985.
9: Copyright (C) 1985, 1992, Trustees of Columbia University in the City of New
10: York. Permission is granted to any individual or institution to use, copy, or
11: redistribute this software so long as it is not sold for profit, provided this
12: copyright notice is retained.
13: */
14:
15: /* Include Files */
16:
17: #include "ckcdeb.h"
18:
19: #include <signal.h>
20: #ifdef MINIX
21: #include <limits.h>
22: #endif /* MINIX */
23: #ifdef POSIX
24: #include <limits.h>
25: #endif /* POSIX */
26:
27: /* Directory structure header file */
28:
29: #ifdef OS2
30: /*
31: C-Kermit's OS/2 support originally by Chris Adie <[email protected]>
32: for C-Kermit 4F, Copyright (C) 1988 Edinburgh University Computing Service,
33: Scotland. Permission is granted to any individual or institution to use,
34: copy, or redistribute this software so long as it is not sold for profit,
35: provided this copyright notice is retained.
36:
37: Adapted to C-Kermit 5A and integrated into the UNIX support module
38: by Kai Uwe Rommel <[email protected]>, Muenchen, Germany,
39: December 1991.
40: */
41:
42: /*
43: Directory Separator macros, to allow this module to work with both UNIX and
44: OS/2: Because of ambiguity with the command line editor escape \ character,
45: the directory separator is currently left as / for OS/2 too, because the
46: OS/2 kernel accepts / as directory separatore too. But this is subject to
47: change in future versions to conform with the normal OS/2 style.
48: */
49: #define DIRSEP '/'
50: /* #define DIRSEP '\\' */
51: #define ISDIRSEP(c) ((c)=='/'||(c)=='\\')
52: #else /* not OS2 */
53: #define DIRSEP '/'
54: #define ISDIRSEP(c) ((c)=='/')
55: #endif /* OS2 */
56:
57: #ifdef SDIRENT
58: #define DIRENT
59: #endif /* SDIRENT */
60:
61: #ifdef XNDIR
62: #include <sys/ndir.h>
63: #else /* !XNDIR */
64: #ifdef NDIR
65: #include <ndir.h>
66: #else /* !NDIR, !XNDIR */
67: #ifdef RTU
68: #include "/usr/lib/ndir.h"
69: #else /* !RTU, !NDIR, !XNDIR */
70: #ifdef DIRENT
71: #ifdef SDIRENT
72: #include <sys/dirent.h>
73: #else
74: #include <dirent.h>
75: #endif /* SDIRENT */
76: #else
77: #ifdef OS2
78: #define OPENDIR
79: #define DIRENT
80: #include "ckodir.h"
81: #else/* !RTU, !NDIR, !XNDIR, !DIRENT, !OS2, i.e. all others */
82: #include <sys/dir.h>
83: #endif /* OS2 */
84: #endif /* DIRENT */
85: #endif /* RTU */
86: #endif /* NDIR */
87: #endif /* XNDIR */
88:
89: #ifdef OS2 /* OS/2 file system interface */
90: #define BSD4 /* is like Berkeley UNIX */
91: #define NOFILEH /* with no <file.h> */
92: #include <sys/utime.h>
93: #include <stdlib.h>
94: #include <process.h>
95: extern int binary; /* We need to know this for open() */
96: #define popen _popen
97: #define pclose _pclose
98: #else
99: #include <pwd.h> /* Password file for shell name */
100: #endif /* OS2 */
101:
102: #ifdef BSD4 /* BSD 4.x */
103: #define TIMESTAMP /* Can do file dates */
104: #include <time.h> /* Need this */
105: #include <sys/timeb.h> /* Need this if really BSD */
106: #endif /* BSD4 */
107:
108: #ifdef ATTSV
109: #define TIMESTAMP
110: #include <time.h>
111: /* void tzset(); (the "void" type upsets some compilers) */
112: #ifndef ultrix
113: extern long timezone;
114: #endif /* ultrix */
115: #endif /* ATTSV */
116:
117: /* Is `y' a leap year? */
118: #define leap(y) (((y) % 4 == 0 && (y) % 100 != 0) || (y) % 400 == 0)
119:
120: /* Number of leap years from 1970 to `y' (not including `y' itself). */
121: #define nleap(y) (((y) - 1969) / 4 - ((y) - 1901) / 100 + ((y) - 1601) / 400)
122:
123: #ifdef COMMENT /* not used */
124: /* Number of days in each month of the year. */
125: static char monlens[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
126: #endif /* COMMENT */
127:
128: #ifdef CIE
129: #include <stat.h> /* File status */
130: #else
131: #include <sys/stat.h>
132: #ifdef OS2
133: #include <sys/types.h>
134: /* because standard stat has trouble with trailing /'s we have to wrap it */
135: int os2stat(char *, struct stat *);
136: #define stat(path, buf) os2stat(path, buf)
137: #endif /* OS2 */
138: #endif /* CIE */
139:
140: /*
141: Functions (n is one of the predefined file numbers from ckcker.h):
142:
143: zopeni(n,name) -- Opens an existing file for input.
144: zopeno(n,name,attr,fcb) -- Opens a new file for output.
145: zclose(n) -- Closes a file.
146: zchin(n,&c) -- Gets the next character from an input file.
147: zsinl(n,&s,x) -- Read a line from file n, max len x, into address s.
148: zsout(n,s) -- Write a null-terminated string to output file, buffered.
149: zsoutl(n,s) -- Like zsout, but appends a line terminator.
150: zsoutx(n,s,x) -- Write x characters to output file, unbuffered.
151: zchout(n,c) -- Add a character to an output file, unbuffered.
152: zchki(name) -- Check if named file exists and is readable, return size.
153: zchko(name) -- Check if named file can be created.
154: zchkspa(name,n) -- Check if n bytes available to create new file, name.
155: znewn(name,s) -- Make a new unique file name based on the given name.
156: zdelet(name) -- Delete the named file.
157: zxpand(string) -- Expands the given wildcard string into a list of files.
158: znext(string) -- Returns the next file from the list in "string".
159: zxcmd(n,cmd) -- Execute the command in a lower fork on file number n.
160: zclosf() -- Close input file associated with zxcmd()'s lower fork.
161: zrtol(n1,n2) -- Convert remote filename into local form.
162: zltor(n1,n2) -- Convert local filename into remote form.
163: zchdir(dirnam) -- Change working directory.
164: zhome() -- Return pointer to home directory name string.
165: zkself() -- Kill self, log out own job.
166: zsattr(struct zattr *) -- Return attributes for file which is being sent.
167: zstime(f, struct zattr *, x) - Set file creation date from attribute packet.
168: zrename(old, new) -- Rename a file.
169: */
170:
171: /* Kermit-specific includes */
172: /*
173: Definitions here supersede those from system include files.
174: ckcdeb.h is included above.
175: */
176: #include "ckcker.h" /* Kermit definitions */
177: #include "ckucmd.h" /* For sys-dependent keyword tables */
178: #include "ckuver.h" /* Version herald */
179:
180: char *ckzsys = HERALD;
181:
182: /* Support for tilde-expansion in file and directory names */
183:
184: #ifdef POSIX
185: #define NAMEENV "LOGNAME"
186: #endif /* POSIX */
187:
188: #ifdef BSD4
189: #define NAMEENV "USER"
190: #endif /* BSD4 */
191:
192: #ifdef ATTSV
193: #define NAMEENV "LOGNAME"
194: #endif /* ATTSV */
195:
196: /* Berkeley Unix Version 4.x */
197: /* 4.1bsd support from Charles E Brooks, EDN-VAX */
198:
199: #ifdef BSD4
200: #ifdef MAXNAMLEN
201: #define BSD42
202: #endif /* MAXNAMLEN */
203: #endif /* BSD4 */
204:
205: /* Definitions of some system commands */
206:
207: #ifdef OS2
208: char *DELCMD = "del "; /* For file deletion */
209: char *PWDCMD = "chdir "; /* For saying where I am */
210: char *TYPCMD = "type "; /* For typing a file */
211: char *DIRCMD = "dir "; /* For directory listing */
212: char *DIRCM2 = "dir "; /* For directory listing, no args */
213: char *WHOCMD = ""; /* Who's there? */
214: char *SPACMD = "chkdsk "; /* For space on disk */
215: char *SPACM2 = "chkdsk "; /* For space on disk */
216: #else
217: char *DELCMD = "rm -f "; /* For file deletion */
218: char *PWDCMD = "pwd "; /* For saying where I am */
219: #ifdef COMMENT
220: char *DIRCMD = "/bin/ls -ld "; /* For directory listing */
221: char *DIRCM2 = "/bin/ls -ld *"; /* For directory listing, no args */
222: #else
223: char *DIRCMD = "/bin/ls -l "; /* For directory listing */
224: char *DIRCM2 = "/bin/ls -l "; /* For directory listing, no args */
225: #endif
226: char *TYPCMD = "cat "; /* For typing a file */
227:
228: #ifdef FT18 /* Fortune For:Pro 1.8 */
229: #undef BSD4
230: #endif /* FT18 */
231:
232: #ifdef BSD4
233: char *SPACMD = "pwd ; df ."; /* Space in current directory */
234: #else
235: #ifdef FT18
236: char *SPACMD = "pwd ; du ; df .";
237: #else
238: char *SPACMD = "df ";
239: #endif /* FT18 */
240: #endif /* BSD4 */
241:
242: char *SPACM2 = "df "; /* For space in specified directory */
243:
244: #ifdef FT18
245: #define BSD4
246: #endif /* FT18 */
247:
248: #ifdef BSD4
249: char *WHOCMD = "finger "; /* For seeing who's logged in */
250: #else
251: char *WHOCMD = "who "; /* For seeing who's logged in */
252: #endif /* BSD4 */
253: #endif /* OS2 */
254:
255: #ifdef DTILDE /* For tilde expansion */
256: _PROTOTYP( char * tilde_expand, (char *) );
257: #endif /* DTILDE */
258:
259: /* More system-dependent includes, which depend on symbols defined */
260: /* in the Kermit-specific includes. Oh what a tangled web we weave... */
261:
262: #ifdef COHERENT
263: #define NOFILEH
264: #endif /* COHERENT */
265:
266: #ifdef MINIX
267: #define NOFILEH
268: #endif /* MINIX */
269:
270: #ifdef aegis /* <sys/file.h> */
271: #define NOFILEH
272: #endif /* aegis */
273:
274: #ifdef unos
275: #define NOFILEH
276: #endif /* unos */
277:
278: #ifndef NOFILEH
279: #include <sys/file.h>
280: #endif /* NOFILEH */
281:
282:
283: #ifndef is68k /* Whether to include <fcntl.h> */
284: #ifndef BSD41 /* All but a couple UNIXes have it. */
285: #ifndef FT18
286: #include <fcntl.h>
287: #endif /* FT18 */
288: #endif /* BSD41 */
289: #endif /* not is68k */
290:
291: #ifndef _POSIX_SOURCE
292: #ifndef NEXT
293: #ifndef SVR4
294: /* POSIX <pwd.h> already gave prototypes for these. */
295: #ifdef IRIX40
296: _PROTOTYP( struct passwd * getpwnam, (const char *) );
297: #else
298: _PROTOTYP( struct passwd * getpwnam, (char *) );
299: #endif /* IRIX40 */
300: _PROTOTYP( struct passwd * getpwuid, (PWID_T) );
301: _PROTOTYP( struct passwd * getpwent, (void) );
302: #endif /* SVR4 */
303: #endif /* NEXT */
304: #endif /* _POSIX_SOURCE */
305:
306: /* Define macros for getting file type */
307:
308: #ifdef OXOS
309: /*
310: Olivetti X/OS 2.3 has S_ISREG and S_ISDIR defined
311: incorrectly, so we force their redefinition.
312: */
313: #undef S_ISREG
314: #undef S_ISDIR
315: #endif /* OXOS */
316:
317: #ifdef UTSV /* Same deal for Amdah UTSV */
318: #undef S_ISREG
319: #undef S_ISDIR
320: #endif /* UTSV */
321:
322: #ifndef S_ISREG
323: #define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
324: #endif /* S_ISREG */
325: #ifndef S_ISDIR
326: #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
327: #endif /* S_ISDIR */
328:
329: /* Define maximum length for a file name if not already defined */
330:
331: #ifndef MAXNAMLEN
332: #ifdef sun
333: #define MAXNAMLEN 255
334: #else
335: #ifdef FILENAME_MAX
336: #define MAXNAMLEN FILENAME_MAX
337: #else
338: #ifdef NAME_MAX
339: #define MAXNAMLEN NAME_MAX
340: #else
341: #ifdef _POSIX_NAME_MAX
342: #define MAXNAMLEN _POSIX_NAME_MAX
343: #else
344: #ifdef _D_NAME_MAX
345: #define MAXNAMLEN _D_NAME_MAX
346: #else
347: #ifdef DIRSIZ
348: #define MAXNAMLEN DIRSIZ
349: #else
350: #define MAXNAMLEN 14
351: #endif /* DIRSIZ */
352: #endif /* _D_NAME_MAX */
353: #endif /* _POSIX_NAME_MAX */
354: #endif /* NAME_MAX */
355: #endif /* FILENAME_MAX */
356: #endif /* sun */
357: #endif /* MAXNAMLEN */
358:
359: /* Longest pathname */
360:
361: #ifdef MAXPATHLEN
362: #ifdef MAXPATH
363: #undef MAXPATH
364: #endif /* MAXPATH */
365: #define MAXPATH MAXPATHLEN
366: #else
367: #ifdef PATH_MAX
368: #define MAXPATH PATH_MAX
369: #else
370: #ifdef _POSIX_PATH_MAX
371: #define MAXPATH _POSIX_PATH_MAX
372: #else
373: #ifdef BSD42
374: #define MAXPATH 1024
375: #else
376: #define MAXPATH 255
377: #endif /* BSD42 */
378: #endif /* _POSIX_PATH_MAX */
379: #endif /* PATH_MAX */
380: #endif /* MAXPATHLEN */
381:
382: /* Maximum number of filenames for wildcard expansion */
383:
384: #ifdef PROVX1
385: #define MAXWLD 50
386: #else
387: #ifdef BSD29
388: #define MAXWLD 50
389: #else
390: #ifdef pdp11
391: #define MAXWLD 50
392: #else
393: #define MAXWLD 1000
394: #endif /* pdp11 */
395: #endif /* BSD29 */
396: #endif /* PROVX1 */
397:
398: /* More internal function prototypes */
399: /*
400: * The path structure is used to represent the name to match.
401: * Each slash-separated segment of the name is kept in one
402: * such structure, and they are linked together, to make
403: * traversing the name easier.
404: */
405: struct path {
406: char npart[MAXNAMLEN+4]; /* name part of path segment */
407: struct path *fwd; /* forward ptr */
408: };
409: _PROTOTYP( int shxpand, (char *, char **, int ) );
410: _PROTOTYP( static int fgen, (char *, char **, int ) );
411: _PROTOTYP( static VOID traverse, (struct path *, char *, char *) );
412: _PROTOTYP( static VOID addresult, (char *) );
413: _PROTOTYP( static int match, (char *, char *) );
414: _PROTOTYP( static char * whoami, (void) );
415: _PROTOTYP( char * xindex, (char *, char) );
416: _PROTOTYP( UID_T real_uid, (void) );
417: _PROTOTYP( struct path *splitpath, (char *p) );
418:
419: /* Some systems define these symbols in include files, others don't... */
420:
421: #ifndef R_OK
422: #define R_OK 4 /* For access */
423: #endif
424:
425: #ifndef W_OK
426: #define W_OK 2
427: #endif
428:
429: #ifndef O_RDONLY
430: #define O_RDONLY 000
431: #endif
432:
433: /* Declarations */
434:
435: int maxnam = MAXNAMLEN; /* Available to the outside */
436: int maxpath = MAXPATH;
437:
438: FILE *fp[ZNFILS] = { /* File pointers */
439: NULL, NULL, NULL, NULL, NULL, NULL, NULL };
440: #ifdef OS2
441: int ispipe[ZNFILS]; /* Flag for file is a pipe */
442: #endif /* OS2 */
443:
444: /* Buffers and pointers used in buffered file input and output. */
445: #ifdef DYNAMIC
446: extern char *zinbuffer, *zoutbuffer;
447: #else
448: extern char zinbuffer[], zoutbuffer[];
449: #endif /* DYNAMIC */
450: extern char *zinptr, *zoutptr;
451: extern int zincnt, zoutcnt;
452: extern int wildxpand;
453:
454: extern UID_T real_uid();
455:
456: static long iflen = -1L; /* Input file length */
457:
458: static PID_T pid = 0; /* pid of child fork */
459: static int fcount; /* Number of files in wild group */
460: static char nambuf[MAXNAMLEN+4]; /* Buffer for a filename */
461: static char zmbuf[200]; /* For mail, remote print strings */
462:
463: /* static */ /* Not static, must be global now. */
464: char *mtchs[MAXWLD], /* Matches found for filename */
465: **mtchptr; /* Pointer to current match */
466:
467: /* Z K S E L F -- Kill Self: log out own job, if possible. */
468:
469: /* Note, should get current pid, but if your system doesn't have */
470: /* getppid(), then just kill(0,9)... */
471:
472: #ifndef SVR3
473: #ifndef POSIX
474: /* Already declared in unistd.h for SVR3 and POSIX */
475: #ifdef CK_ANSIC
476: extern PID_T getppid(void);
477: #else
478: #ifndef PS2AIX10
479: extern PID_T getppid();
480: #endif /* PS2AIX10 */
481: #endif /* CK_ANSIC */
482: #endif /* POSIX */
483: #endif /* SVR3 */
484: int
485: zkself() { /* For "bye", but no guarantee! */
486: #ifdef PROVX1
487: return(kill(0,9));
488: #else
489: #ifdef V7
490: return(kill(0,9));
491: #else
492: #ifdef TOWER1
493: return(kill(0,9));
494: #else
495: #ifdef FT18
496: return(kill(0,9));
497: #else
498: #ifdef aegis
499: return(kill(0,9));
500: #else
501: #ifdef COHERENT
502: return(kill(getpid(),1));
503: #else
504: #ifdef OS2
505: exit(3);
506: #else
507: exit(kill(getppid(),1));
508: #endif
509: #endif
510: #endif
511: #endif
512: #endif
513: #endif
514: #endif
515: }
516:
517: /* Z O P E N I -- Open an existing file for input. */
518:
519: int
520: zopeni(n,name) int n; char *name; {
521: debug(F111," zopeni",name,n);
522: debug(F101," fp","", fp[n]);
523: if (chkfn(n) != 0) return(0);
524: zincnt = 0; /* Reset input buffer */
525: if (n == ZSYSFN) { /* Input from a system function? */
526: /*** Note, this function should not be called with ZSYSFN ***/
527: /*** Always call zxcmd() directly, and give it the real file number ***/
528: /*** you want to use. ***/
529: debug(F110,"zopeni called with ZSYSFN, failing!",name,0);
530: *nambuf = '\0'; /* No filename. */
531: return(0); /* fail. */
532: #ifdef COMMENT
533: return(zxcmd(n,name)); /* Try to fork the command */
534: #endif
535: }
536: if (n == ZSTDIO) { /* Standard input? */
537: if (isatty(0)) {
538: fprintf(stderr,"Terminal input not allowed");
539: debug(F110,"zopeni: attempts input from unredirected stdin","",0);
540: return(0);
541: }
542: fp[ZIFILE] = stdin;
543: #ifdef OS2
544: setmode(fileno(stdin),O_BINARY);
545: #endif /* OS2 */
546: return(1);
547: }
548: #ifdef OS2
549: if (n == ZIFILE)
550: fp[n] = fopen(name,"rb"); /* Binary mode */
551: else
552: #endif /* OS2 */
553: fp[n] = fopen(name,"r"); /* Real file, open it. */
554: debug(F111," zopeni", name, fp[n]);
555: if (fp[n] == NULL) perror("zopeni");
556: return((fp[n] != NULL) ? 1 : 0);
557: }
558:
559: /* Z O P E N O -- Open a new file for output. */
560:
561: int
562: zopeno(n,name,zz,fcb)
563: /* zopeno */ int n; char *name; struct zattr *zz; struct filinfo *fcb; {
564:
565: char p[8]; /* (===OS2 change===) */
566: /* char *p; */ /* Local-use pointer */
567:
568: /* As of Version 5A, the attribute structure and the file information */
569: /* structure are included in the arglist. */
570:
571: debug(F111,"zopeno",name,n);
572: if (fcb) {
573: debug(F101,"zopeno fcb disp","",fcb->dsp);
574: debug(F101,"zopeno fcb type","",fcb->typ);
575: debug(F101,"zopeno fcb char","",fcb->cs);
576: } else {
577: debug(F100,"zopeno fcb is NULL","",0);
578: }
579: if (n != ZDFILE)
580: debug(F111," zopeno",name,n);
581: if (chkfn(n) != 0) return(0);
582: if ((n == ZCTERM) || (n == ZSTDIO)) { /* Terminal or standard output */
583: fp[ZOFILE] = stdout;
584: if (n != ZDFILE)
585: debug(F101," fp[]=stdout", "", fp[n]);
586: zoutcnt = 0;
587: zoutptr = zoutbuffer;
588: return(1);
589: }
590:
591: /* A real file. Open it in desired mode (create or append). */
592:
593: strcpy(p,"w"); /* Assume write/create mode */
594: if (fcb) { /* If called with an FCB... */
595: if (fcb->dsp == XYFZ_A) /* Does it say Append? */
596: strcpy(p,"a"); /* Yes. */
597: }
598: #ifdef OS2
599: if (n == ZOFILE) strcat(p,"b"); /* Binary mode */
600: #endif /* OS2 */
601: fp[n] = fopen(name,p); /* Open the file */
602:
603: if (fp[n] == NULL) {
604: perror("zopeno can't open");
605: } else {
606: if (n == ZDFILE) setbuf(fp[n],NULL); /* Debugging file unbuffered */
607: }
608: zoutcnt = 0; /* (PWP) reset output buffer */
609: zoutptr = zoutbuffer;
610: if (n != ZDFILE)
611: debug(F101, " fp[n]", "", fp[n]);
612: return((fp[n] != NULL) ? 1 : 0);
613: }
614:
615: /* Z C L O S E -- Close the given file. */
616:
617: /* Returns 0 if arg out of range, 1 if successful, -1 if close failed. */
618:
619: int
620: zclose(n) int n; {
621: int x, x2;
622: if (chkfn(n) < 1) return(0); /* Check range of n */
623:
624: if ((n == ZOFILE) && (zoutcnt > 0)) /* (PWP) output leftovers */
625: x2 = zoutdump();
626: else
627: x2 = 0;
628:
629: x = 0; /* Initialize return code */
630: if (fp[ZSYSFN]) { /* If file is really pipe */
631: x = zclosf(n); /* do it specially */
632: } else {
633: if ((fp[n] != stdout) && (fp[n] != stdin)) x = fclose(fp[n]);
634: fp[n] = NULL;
635: }
636: iflen = -1L; /* Invalidate file length */
637: if (x == EOF) /* if we got a close error */
638: return (-1);
639: else if (x2 < 0) /* or an error flushing the last buffer */
640: return (-1); /* then return an error */
641: else
642: return (1);
643: }
644:
645: /* Z C H I N -- Get a character from the input file. */
646:
647: /* Returns -1 if EOF, 0 otherwise with character returned in argument */
648:
649: int
650: zchin(n,c) int n; int *c; {
651: int a, x;
652:
653: /* (PWP) Just in case this gets called when it shouldn't. */
654: if (n == ZIFILE) {
655: x = zminchar();
656: *c = x;
657: return(x);
658: }
659: /* if (chkfn(n) < 1) return(-1); */
660: a = getc(fp[n]);
661: if (a == EOF) return(-1);
662: #ifdef OS2
663: if (!binary && a == 0x1A) /* Ctrl-Z marks EOF for text mode*/
664: return(-1);
665: #endif
666: *c = (CHAR) a & 0377;
667: return(0);
668: }
669:
670: /* Z S I N L -- Read a line from a file */
671:
672: /*
673: Writes the line into the address provided by the caller.
674: n is the Kermit "channel number".
675: Writing terminates when newline is encountered, newline is not copied.
676: Writing also terminates upon EOF or if length x is exhausted.
677: Returns 0 on success, -1 on EOF or error.
678: */
679: int
680: zsinl(n,s,x) int n, x; char *s; {
681: int a, z = 0;
682:
683: if (chkfn(n) < 1) { /* Make sure file is open */
684: return(-1);
685: }
686: a = -1;
687: while (x--) {
688: #ifndef NLCHAR
689: int old;
690: old = a; /* Previous character */
691: #endif
692: if (zchin(n,&a) < 0) { /* Read a character from the file */
693: z = -1;
694: break;
695: }
696: #ifdef NLCHAR
697: if (a == (char) NLCHAR) break; /* Single-character line terminator */
698: #else
699: if (a == '\r') continue; /* CRLF line terminator */
700: if (old == '\r') {
701: if (a == '\n') break;
702: else *s++ = '\r';
703: }
704: #endif /* NLCHAR */
705: *s = a;
706: s++;
707: }
708: *s = '\0';
709: return(z);
710: }
711:
712: /*
713: * (PWP) (re)fill the buffered input buffer with data. All file input
714: * should go through this routine, usually by calling the zminchar()
715: * macro (in ckcker.h).
716: */
717:
718: /*
719: * Suggestion: if fread() returns 0, call ferror to find out what the
720: * problem was. If it was not EOF, then return -2 instead of -1.
721: * Upper layers (getpkt function in ckcfns.c) should set cxseen flag
722: * if it gets -2 return from zminchar macro.
723: */
724: int
725: zinfill() {
726: int x;
727:
728: errno = 0;
729: zincnt = fread(zinbuffer, sizeof (char), INBUFSIZE, fp[ZIFILE]);
730: #ifdef COMMENT
731: debug(F101,"zinfill fp","",fp[ZIFILE]);
732: debug(F101,"zinfill zincnt","",zincnt);
733: #endif
734: if (zincnt == 0) {
735: #ifndef UTEK
736: #ifdef ferror
737: x = ferror(fp[ZIFILE]);
738: debug(F101,"zinfill errno","",errno);
739: debug(F101,"zinfill ferror","",x);
740: if (x) return(-2);
741: #endif /* ferror */
742: #else
743: x = feof(fp[ZIFILE]);
744: debug(F101,"zinfill errno","",errno);
745: debug(F101,"zinfill feof","",x);
746: if (!x && ferror(fp[ZIFILE])) return(-2);
747: #endif /* UTEK */
748: return(-1);
749: }
750: zinptr = zinbuffer; /* set pointer to beginning, (== &zinbuffer[0]) */
751: zincnt--; /* one less char in buffer */
752: return((int)(*zinptr++) & 0377); /* because we return the first */
753: }
754:
755: /* Z S O U T -- Write a string out to the given file, buffered. */
756:
757: int
758: zsout(n,s) int n; char *s; {
759: if (chkfn(n) < 1) return(-1); /* Keep this here, prevents memory faults */
760: #ifdef COMMENT
761: while (*s) { /* (unbuffered for debugging) */
762: write(fileno(fp[n]),s,1); ++s;
763: }
764: #endif
765: #ifdef COMMENT
766: return(fputs(s,fp[n]) == EOF ? -1 : 0);
767: #else
768: if (n == ZSFILE)
769: return(write(fileno(fp[n]),s,(int)strlen(s)));
770: else
771: return(fputs(s,fp[n]) == EOF ? -1 : 0);
772: #endif
773: }
774:
775: /* Z S O U T L -- Write string to file, with line terminator, buffered */
776:
777: int
778: zsoutl(n,s) int n; char *s; {
779: /* if (chkfn(n) < 1) return(-1); */
780: if (fputs(s,fp[n]) == EOF) return(-1);
781: if (fputs("\n",fp[n]) == EOF) return(-1); /* (===OS2 ? \r\n) */
782: return(0);
783: }
784:
785: /* Z S O U T X -- Write x characters to file, unbuffered. */
786:
787: int
788: zsoutx(n,s,x) int n, x; char *s; {
789: #ifdef COMMENT
790: if (chkfn(n) < 1) return(-1);
791: return(write(fp[n]->_file,s,x));
792: #endif
793: return(write(fileno(fp[n]),s,x) == x ? x : -1);
794: }
795:
796:
797: /* Z C H O U T -- Add a character to the given file. */
798:
799: /* Should return 0 or greater on success, -1 on failure (e.g. disk full) */
800:
801: int
802: #ifdef CK_ANSIC
803: zchout(register int n, char c)
804: #else
805: zchout(n,c) register int n; char c;
806: #endif /* CK_ANSIC */
807: /* zchout() */ {
808: /* if (chkfn(n) < 1) return(-1); */
809: if (n == ZSFILE) { /* Use unbuffered for session log */
810: return(write(fileno(fp[n]),&c,1) == 1 ? 0 : -1);
811: } else { /* Buffered for everything else */
812: if (putc(c,fp[n]) == EOF) /* If true, maybe there was an error */
813: return(ferror(fp[n])?-1:0); /* Check to make sure */
814: else /* Otherwise... */
815: return(0); /* There was no error. */
816: }
817: }
818:
819: /* (PWP) buffered character output routine to speed up file IO */
820:
821: int
822: zoutdump() {
823: int x;
824: zoutptr = zoutbuffer; /* Reset buffer pointer in all cases */
825: debug(F101,"zoutdump chars","",zoutcnt);
826: if (zoutcnt == 0) { /* Nothing to output */
827: return(0);
828: } else if (zoutcnt < 0) { /* Unexpected negative argument */
829: zoutcnt = 0; /* Reset output buffer count */
830: return(-1); /* and fail. */
831: }
832:
833: /* Frank Prindle suggested that replacing this fwrite() by an fflush() */
834: /* followed by a write() would improve the efficiency, especially when */
835: /* writing to stdout. Subsequent tests showed a 5-fold improvement! */
836: /* if (x = fwrite(zoutbuffer, 1, zoutcnt, fp[ZOFILE])) { */
837:
838: fflush(fp[ZOFILE]);
839: if ((x = write(fileno(fp[ZOFILE]),zoutbuffer,zoutcnt)) == zoutcnt) {
840: debug(F101,"zoutdump write ok","",zoutcnt);
841: zoutcnt = 0; /* Reset output buffer count */
842: return(0); /* write() worked OK */
843: } else {
844: debug(F101,"zoutdump write error","",errno);
845: debug(F101,"zoutdump write returns","",x);
846: zoutcnt = 0; /* Reset output buffer count */
847: return(-1); /* write() failed */
848: }
849: }
850:
851: /* C H K F N -- Internal function to verify file number is ok */
852:
853: /*
854: Returns:
855: -1: File number n is out of range
856: 0: n is in range, but file is not open
857: 1: n in range and file is open
858: */
859: int
860: chkfn(n) int n; {
861: switch (n) {
862: case ZCTERM:
863: case ZSTDIO:
864: case ZIFILE:
865: case ZOFILE:
866: case ZDFILE:
867: case ZTFILE:
868: case ZPFILE:
869: case ZSFILE:
870: case ZSYSFN:
871: case ZRFILE:
872: case ZWFILE: break;
873: default:
874: debug(F101,"chkfn: file number out of range","",n);
875: fprintf(stderr,"?File number out of range - %d\n",n);
876: return(-1);
877: }
878: return( (fp[n] == NULL) ? 0 : 1 );
879: }
880:
881: /* Z C H K I -- Check if input file exists and is readable */
882:
883: /*
884: Returns:
885: >= 0 if the file can be read (returns the size).
886: -1 if file doesn't exist or can't be accessed,
887: -2 if file exists but is not readable (e.g. a directory file).
888: -3 if file exists but protected against read access.
889: */
890: /*
891: For Berkeley Unix, a file must be of type "regular" to be readable.
892: Directory files, special files, and symbolic links are not readable.
893: */
894: long
895: zchki(name) char *name; {
896: struct stat buf;
897: int x;
898:
899: x = stat(name,&buf);
900: if (x < 0) {
901: debug(F111,"zchki stat fails",name,errno);
902: return(-1);
903: }
904: if (!S_ISREG (buf.st_mode)) { /* Must be regular file */
905: debug(F111,"zchki skipping:",name,x);
906: return(-2);
907: }
908: debug(F111,"zchki stat ok:",name,x);
909:
910: if ((x = access(name,R_OK)) < 0) { /* Is the file accessible? */
911: debug(F111," access failed:",name,x); /* No */
912: return(-3);
913: } else {
914: iflen = buf.st_size; /* Yes, remember size */
915: strncpy(nambuf,name,MAXNAMLEN); /* and name globally. */
916: debug(F111," access ok:",name,(int) iflen);
917: return( (iflen > -1L) ? iflen : 0L );
918: }
919: }
920:
921: /* Z C H K O -- Check if output file can be created */
922:
923: /*
924: Returns -1 if write permission for the file would be denied, 0 otherwise.
925: */
926: int
927: zchko(name) char *name; {
928: int i, x;
929: char *s;
930:
931: if (!name) return(-1); /* Watch out for null pointer. */
932: x = (int)strlen(name); /* Get length of filename */
933: debug(F101," length","",x);
934: s = malloc(x+3); /* Must copy because we can't */
935: if (!s) { /* write into our argument. */
936: fprintf(stderr,"Malloc error 46\n");
937: return(-1);
938: }
939: strcpy(s,name);
940:
941: for (i = x; i > 0; i--) /* Strip filename from right. */
942: if (ISDIRSEP(s[i-1])) break;
943: debug(F101," i","",i);
944:
945: #ifdef COMMENT
946: /* X/OPEN XPG3-compliant systems fail if argument ends with "/"... */
947: if (i == 0) /* If no path, use current directory */
948: strcpy(s,"./");
949: else /* Otherwise, use given one. */
950: s[i] = '\0';
951: #else
952: /* So now we use "path/." if path given, or "." if no path given. */
953: s[i++] = '.'; /* Append "." to path. */
954: s[i] = '\0';
955: #endif /* COMMENT */
956:
957: x = access(s,W_OK); /* Check access of path. */
958: if (x < 0)
959: debug(F111,"zchko access failed:",s,errno);
960: else
961: debug(F111,"zchko access ok:",s,x);
962: free(s); /* Free temporary storage */
963: return((x < 0) ? -1 : 0); /* and return. */
964: }
965:
966: /* Z D E L E T -- Delete the named file. */
967:
968: int
969: zdelet(name) char *name; {
970: return(unlink(name));
971: }
972:
973:
974: /* Z R T O L -- Convert remote filename into local form */
975:
976: /* For UNIX, this means changing uppercase letters to lowercase. */
977:
978: VOID
979: zrtol(name,name2) char *name, *name2; {
980: for ( ; *name != '\0'; name++) {
981: *name2++ = isupper(*name) ? tolower(*name) : *name;
982: }
983: *name2 = '\0';
984: debug(F110,"zrtol:",name2,0);
985: }
986:
987:
988: /* Z S T R I P -- Strip device & directory name from file specification */
989:
990: /* Strip pathname from filename "name", return pointer to result in name2 */
991:
992: static char work[257]; /* buffer for use by zstrip and zltor */
993:
994: VOID
995: zstrip(name,name2) char *name, **name2; {
996: char *cp, *pp;
997: debug(F110,"zstrip before",name,0);
998: pp = work;
999: #ifdef DTILDE
1000: if (*name == '~') name++;
1001: #endif /* DTILDE */
1002: for (cp = name; *cp != '\0'; cp++) {
1003: if (ISDIRSEP(*cp))
1004: pp = work;
1005: else
1006: *pp++ = *cp;
1007: }
1008: *pp = '\0'; /* Terminate the string */
1009: *name2 = work;
1010: debug(F110,"zstrip after",*name2,0);
1011: }
1012:
1013: /* Z L T O R -- Local TO Remote */
1014:
1015: VOID
1016: zltor(name,name2) char *name, *name2; {
1017: char *cp, *pp;
1018: int dc = 0;
1019: #ifdef aegis
1020: char *namechars;
1021: int tilde = 0, bslash = 0;
1022:
1023: if ((namechars = getenv("NAMECHARS")) != NULL) {
1024: if (xindex(namechars, '~' ) != NULL) tilde = '~';
1025: if (xindex(namechars, '\\') != NULL) bslash = '\\';
1026: } else {
1027: tilde = '~';
1028: bslash = '\\';
1029: }
1030: #endif /* aegis */
1031:
1032: debug(F110,"zltor",name,0);
1033: pp = work;
1034: #ifdef aegis
1035: cp = name;
1036: if (tilde && *cp == tilde)
1037: ++cp;
1038: for (; *cp != '\0'; cp++) {
1039: if (*cp == '/' || *cp == bslash) { /* strip path name */
1040: #else
1041: for (cp = name; *cp != '\0'; cp++) { /* strip path name */
1042: if (ISDIRSEP(*cp)) {
1043: #endif /* aegis */
1044: dc = 0;
1045: pp = work;
1046: }
1047: else if (islower(*cp)) *pp++ = toupper(*cp); /* Uppercase letters */
1048: else if (*cp == '~') *pp++ = 'X'; /* Change tilde to 'X' */
1049: else if (*cp == '#') *pp++ = 'X'; /* Change number sign to 'X' */
1050: else if ((*cp == '.') && (++dc > 1)) *pp++ = 'X'; /* & extra dots */
1051: else *pp++ = *cp;
1052: }
1053: *pp = '\0'; /* Tie it off. */
1054: cp = name2; /* If nothing before dot, */
1055: if (*work == '.') *cp++ = 'X'; /* insert 'X' */
1056: strcpy(cp,work);
1057: debug(F110," name2",name2,0);
1058: }
1059:
1060:
1061: /* Z C H D I R -- Change directory */
1062: /*
1063: Call with:
1064: dirnam = pointer to name of directory to change to,
1065: which may be "" or NULL to indicate user's home directory.
1066: Returns:
1067: 0 on failure
1068: 1 on success
1069: */
1070: int
1071: zchdir(dirnam) char *dirnam; {
1072: char *hd, *sp, *p;
1073:
1074: debug(F110,"zchdir",dirnam,0);
1075: if (dirnam == NULL || dirnam == "" || *dirnam == '\0') /* If arg is null */
1076: dirnam = getenv("HOME"); /* use user's home directory. */
1077: sp = dirnam;
1078: debug(F110,"zchdir 2",dirnam,0);
1079:
1080: #ifdef DTILDE
1081: hd = tilde_expand(dirnam); /* Attempt to expand tilde */
1082: if (*hd == '\0') hd = dirnam; /* in directory name. */
1083: #else
1084: hd = dirnam;
1085: #endif /* DTILDE */
1086: debug(F110,"zchdir 3",hd,0);
1087: if (chdir(hd) == 0) return(1); /* Try to cd */ /* (===OS2===) */
1088: p = sp; /* Failed, lowercase it. */
1089: while (*p) {
1090: if (isupper(*p)) *p = tolower(*p);
1091: p++;
1092: }
1093: debug(F110,"zchdir 4",hd,0);
1094: #ifdef DTILDE
1095: hd = tilde_expand(sp); /* Try again to expand tilde */
1096: if (*hd == '\0') hd = sp;
1097: #else
1098: hd = sp; /* Point to result */
1099: #endif
1100: debug(F110,"zchdir 5",hd,0);
1101: /* return((chdir(hd) > -1) ? 1 : 0); (===OS2===) */
1102: return((chdir(hd) == 0) ? 1 : 0);
1103: }
1104:
1105:
1106: /* Z H O M E -- Return pointer to user's home directory */
1107:
1108: char *
1109: zhome() {
1110: char *home = NULL;
1111: home = getenv("HOME");
1112: return(home ? home : "."); /* (===OS2===) */
1113: }
1114:
1115: /* Z G T D I R -- Return pointer to user's current directory */
1116:
1117: #ifdef MAXPATHLEN
1118: #define CWDBL MAXPATHLEN
1119: #else
1120: #define CWDBL 100
1121: #endif
1122: static char cwdbuf[CWDBL+1];
1123:
1124: char *
1125: zgtdir() {
1126: char *buf;
1127:
1128: #ifdef SVORPOSIX
1129: extern char *getcwd();
1130: buf = cwdbuf;
1131: return(getcwd(buf,CWDBL));
1132: #else
1133: #ifdef OS2
1134: extern char *getcwd();
1135: buf = cwdbuf;
1136: return(getcwd(buf,CWDBL));
1137: #else
1138: #ifdef BSD4
1139: extern char *getwd();
1140: buf = cwdbuf;
1141: return(getwd(buf));
1142: #else
1143: return("directory unknown");
1144: #endif /* BSD4 */
1145: #endif /* OS2 */
1146: #endif /* SYSVORPOSIX */
1147: }
1148:
1149: /* Z X C M D -- Run a system command so its output can be read like a file */
1150:
1151: int
1152: zxcmd(filnum,comand) int filnum; char *comand; {
1153: #ifdef OS2
1154: if (chkfn(filnum) < 0) return(-1); /* Need a valid Kermit file number. */
1155: if (filnum == ZSTDIO || filnum == ZCTERM) /* But not one of these. */
1156: return(0);
1157: if (filnum == ZIFILE || filnum == ZRFILE) { /* Input from a command */
1158: if (priv_chk() || ((fp[filnum] = popen(comand,"r")) == NULL))
1159: return(0);
1160: } else { /* Output to a command */
1161: if (priv_chk() || ((fp[filnum] = popen(comand,"w")) == NULL))
1162: return(0);
1163: }
1164: ispipe[filnum] = 1;
1165: return(1);
1166: #else /* Not OS2 */
1167: int pipes[2];
1168: int out;
1169:
1170: if (chkfn(filnum) < 0) return(-1); /* Need a valid Kermit file number. */
1171: if (filnum == ZSTDIO || filnum == ZCTERM) /* But not one of these. */
1172: return(0);
1173:
1174: out = (filnum == ZIFILE || filnum == ZRFILE) ? 0 : 1 ;
1175:
1176: /* Output to a command */
1177:
1178: if (out) { /* Need popen() to do this. */
1179: #ifdef NOPOPEN
1180: return(0); /* no popen(), fail. */
1181: #else
1182: /* Use popen() to run the command. */
1183:
1184: #ifdef _POSIX_SOURCE
1185: /* Strictly speaking, popen() is not available in POSIX.1 */
1186: #define DCLPOPEN
1187: #endif /* _POSIX_SOURCE */
1188:
1189: #ifdef DCLPOPEN
1190: /* popen() needs declaring because it's not declared in <stdio.h> */
1191: FILE *popen();
1192: #endif /* DCLPOPEN */
1193:
1194: if (priv_chk() || ((fp[filnum] = popen(comand,"w")) == NULL))
1195: return(0);
1196: else return(1);
1197: #endif /* NOPOPEN */
1198: }
1199:
1200: /* Input from a command */
1201:
1202: if (pipe(pipes) != 0) {
1203: debug(F100,"zxcmd pipe failure","",0);
1204: return(0); /* can't make pipe, fail */
1205: }
1206:
1207: /* Create a fork in which to run the named process */
1208:
1209: #ifdef aegis
1210: if ((pid = vfork()) == 0) { /* child */
1211: #else
1212: if ((pid = fork()) == 0) { /* child */
1213: #endif
1214:
1215: /* We're in the fork. */
1216:
1217: char *shpath, *shname, *shptr; /* Find user's preferred shell */
1218: #ifndef aegis
1219: struct passwd *p;
1220: char *defshell = "/bin/sh"; /* default shell */
1221: #endif /* aegis */
1222: if (priv_can()) exit(1); /* Turn off any privileges! */
1223: debug(F101,"zxcmd pid","",pid);
1224: close(pipes[0]); /* close input side of pipe */
1225: close(0); /* close stdin */
1226: if (open("/dev/null",0) < 0) return(0); /* replace input by null */
1227: #ifndef SVORPOSIX
1228: dup2(pipes[1],1); /* BSD: replace stdout & stderr */
1229: dup2(pipes[1],2); /* by the pipe */
1230: #else
1231: close(1); /* AT&T: close stdout */
1232: if ( dup(pipes[1]) != 1 ) /* Send stdout to the pipe */
1233: return(0);
1234: close(2); /* Send stderr to the pipe */
1235: if ( dup(pipes[1]) != 2 )
1236: return(0);
1237: #endif /* SVORPOSIX */
1238: close(pipes[1]); /* Don't need this any more. */
1239:
1240: #ifdef aegis
1241: if ((shpath = getenv("SERVERSHELL")) == NULL) shpath = "/bin/sh";
1242: #else
1243: shpath = getenv("SHELL"); /* What shell? */
1244: if (shpath == NULL) {
1245: p = getpwuid( real_uid() ); /* Get login data */
1246: if (p == (struct passwd *)NULL || !*(p->pw_shell))
1247: shpath = defshell;
1248: else shpath = p->pw_shell;
1249: }
1250: #endif /* aegis */
1251: shptr = shname = shpath;
1252: while (*shptr != '\0')
1253: if (*shptr++ == '/')
1254: shname = shptr;
1255: debug(F100,"zxcmd...","",0);
1256: debug(F110,shpath,shname,0);
1257:
1258: execl(shpath,shname,"-c",comand,(char *)NULL); /* Execute the cmd */
1259: exit(0); /* just punt if it failed. */
1260: } else if (pid == -1) {
1261: debug(F100,"zxcmd fork failure","",0);
1262: return(0);
1263: }
1264: debug(F101,"zxcmd pid","",pid);
1265: if (out) {
1266: close(pipes[0]); /* Don't need the input side */
1267: fp[filnum] = fdopen(pipes[1],"w"); /* Open a stream for output. */
1268: fp[ZSYSFN] = fp[filnum]; /* Remember. */
1269: zoutcnt = 0; /* (PWP) reset input buffer */
1270: zoutptr = zoutbuffer;
1271: } else {
1272: close(pipes[1]); /* Don't need the output side */
1273: fp[filnum] = fdopen(pipes[0],"r"); /* Open a stream for input. */
1274: fp[ZSYSFN] = fp[filnum]; /* Remember. */
1275: zincnt = 0; /* (PWP) reset input buffer */
1276: zinptr = zinbuffer;
1277: }
1278: return(1);
1279: #endif /* OS2 */
1280: }
1281:
1282: /* Z C L O S F - wait for the child fork to terminate and close the pipe. */
1283:
1284: int
1285: zclosf(filnum) int filnum; {
1286: int wstat;
1287: debug(F101,"zclosf filnum","",filnum);
1288: #ifndef NOPOPEN
1289: #ifdef OS2
1290: if (ispipe[filnum]) {
1291: int x;
1292: x = pclose(fp[filnum]);
1293: fp[filnum] = NULL;
1294: ispipe[filnum] = 0;
1295: #else
1296: if (filnum == ZWFILE) {
1297: int x;
1298: x = pclose(fp[filnum]);
1299: fp[filnum] = fp[ZSYSFN] = NULL;
1300: #endif /* OS2 */
1301: return((x < 0) ? 0 : 1);
1302: }
1303: #endif /* NOPOPEN */
1304: debug(F101,"zclosf fp[filnum]","", fp[filnum]);
1305: debug(F101,"zclosf fp[ZSYSFN]","", fp[ZSYSFN]);
1306: #ifdef OS2
1307: fclose(fp[filnum]);
1308: fp[filnum] = NULL;
1309: #else
1310: if (pid != 0) {
1311: debug(F101,"zclosf killing pid","",pid);
1312: kill(pid,9);
1313: while ((wstat = wait((WAIT_T *)0)) != pid && wstat != -1) ;
1314: pid = 0;
1315: }
1316: fclose(fp[filnum]);
1317: fp[filnum] = fp[ZSYSFN] = NULL;
1318: #endif /* OS2 */
1319: return(1);
1320: }
1321:
1322: /* Z X P A N D -- Expand a wildcard string into an array of strings */
1323: /*
1324: Returns the number of files that match fn1, with data structures set up
1325: so that first file (if any) will be returned by the next znext() call.
1326: Depends on external variable wildxpand: 0 means we expand wildcards
1327: internally, nonzero means we call the shell to do it.
1328: */
1329:
1330: int
1331: zxpand(fn) char *fn; {
1332: char *p;
1333:
1334: #ifdef DTILDE /* Built with tilde-expansion? */
1335: char *tnam;
1336: #endif /* DTILDE */
1337: debug(F111,"zxpand entry",fn,wildxpand);
1338: #ifdef DTILDE /* Built with tilde-expansion? */
1339: if (*fn == '~') { /* Starts with tilde? */
1340: tnam = tilde_expand(fn); /* Try to expand it. */
1341: if (tnam) fn = tnam;
1342: }
1343: debug(F110,"zxpand after tilde_x",fn,0);
1344: #endif /* DTILDE */
1345: #ifndef OS2
1346: if (wildxpand) /* Who is expanding wildcards? */
1347: fcount = shxpand(fn,mtchs,MAXWLD); /* Shell */
1348: else
1349: #endif /* OS2 */
1350: fcount = fgen(fn,mtchs,MAXWLD); /* Kermit */
1351: if (fcount > 0) {
1352: mtchptr = mtchs; /* Save pointer for next. */
1353: }
1354: if (fcount > 0) {
1355: debug(F111,"zxpand ok",mtchs[0],fcount);
1356: return(fcount);
1357: }
1358: debug(F111,"zxpand fgen1",fn,fcount); /* Didn't get one, or got too many */
1359: p = malloc((int)strlen(fn) + 10); /* Make space */
1360: if (!p) return(0);
1361: zrtol(fn,p); /* Try again, maybe lowercase */
1362: #ifndef OS2
1363: if (wildxpand)
1364: fcount = shxpand(p,mtchs,MAXWLD); /* Shell */
1365: else
1366: #endif /* OS2 */
1367: fcount = fgen(p,mtchs,MAXWLD); /* Kermit */
1368: if (fcount > 0) { /* Got one? */
1369: mtchptr = mtchs; /* Save pointer for next. */
1370: debug(F111,"zxpand fgen2 ok",mtchs[0],fcount);
1371: } else debug(F111,"zxpand 2 not ok",p,fcount);
1372: free(p);
1373: return(fcount);
1374: }
1375:
1376:
1377: /* Z N E X T -- Get name of next file from list created by zxpand(). */
1378: /*
1379: Returns >0 if there's another file, with its name copied into the arg string,
1380: or 0 if no more files in list.
1381: */
1382: int
1383: znext(fn) char *fn; {
1384: if (fcount-- > 0) strcpy(fn,*mtchptr++);
1385: else *fn = '\0';
1386: debug(F111,"znext",fn,fcount+1);
1387: return(fcount+1);
1388: }
1389:
1390:
1391: /* Z C H K S P A -- Check if there is enough space to store the file */
1392:
1393: /*
1394: Call with file specification f, size n in bytes.
1395: Returns -1 on error, 0 if not enough space, 1 if enough space.
1396: */
1397: int
1398: zchkspa(f,n) char *f; long n; { /* Just dummy for now. */
1399: return(1); /* Always say OK. */
1400: }
1401:
1402:
1403: /* Z N E W N -- Make a new name for the given file */
1404:
1405: /*
1406: Given the name, fn, of a file that already exists, this function builds a
1407: new name of the form "<oldname>.~<n>~", where <oldname> is argument name
1408: (fn), and <n> is a version number, one higher than any existing version
1409: number for that file, up to 9999. This format is consistent with that used
1410: by GNU EMACS. If the constructed name is too long for the system's maximum,
1411: enough characters are truncated from the end of <fn> to allow the version
1412: number to fit. If no free version numbers exist between 1 and 9999, a
1413: version number of "xxxx" is used. Returns a pointer to the new name in
1414: argument s.
1415: */
1416:
1417: VOID
1418: znewn(fn,s) char *fn, **s; {
1419: #define ZNEWNBL 255 /* Name buffer length */
1420: #define ZNEWNMD 4 /* Max digits for version number */
1421: static char buf[ZNEWNBL+1];
1422: #ifdef OS2
1423: /*
1424: Well, OS/2 should be able to handle 8.3 FAT names still,
1425: although HPFS is so much easier to live with ...
1426: This code should be checked out with long names.
1427: */
1428: char *bp, *xp, *yp, *zp, ch, temp[14];
1429: int d, i, n;
1430: xp = bp = buf;
1431: while (*fn) { /* Copy name into buf */
1432: ch = *bp++ = *fn++;
1433: if (ISDIRSEP(ch) || (ch == ':')) xp=bp;
1434: }
1435: *bp = '\0';
1436: yp = xp;
1437: i = 1;
1438: while (*yp && (*yp != '.')) {
1439: yp++;
1440: if (++i<=6) zp=yp;
1441: }
1442: /* zp points to 6th character in name, or yp, whichever occurs first. */
1443: strcpy(temp,yp); /* Copy extension, if any */
1444: while (zp != xp+8) {
1445: if ( zp < xp+5 ) *zp++='0';
1446: else *zp++='?'; /* Pad out with wild cards */
1447: }
1448: strcpy(zp,temp); /* Get the extension back */
1449: n = zxpand(buf); /* Expand the resulting wild name */
1450: d = 0; /* Index number */
1451: while (znext(temp)) {
1452: i = atoi(temp+5);
1453: if (i > d) d = i;
1454: }
1455: sprintf(temp,"%03d",d+1); /* get the number into a string */
1456: memcpy(xp+5, temp, 3);
1457: #else /* Not OS2 */
1458: char *bp, *xp;
1459: int len = 0, d = 0, n, t, i, j, k, power = 1;
1460:
1461: int max = MAXNAMLEN; /* Maximum name length */
1462:
1463: if (max < 14) max = 14; /* Make it reasonable */
1464: if (max > ZNEWNBL) max = ZNEWNBL;
1465: bp = buf; /* Buffer for building new name */
1466: while (*fn) { /* Copy old name into buffer */
1467: *bp++ = *fn++;
1468: if (len++ > ZNEWNBL) break; /* ...up to buffer length */
1469: }
1470: for (i = 1; i < ZNEWNMD + 1; i++) { /* Version numbers up to 10**i - 1 */
1471: power *= 10; /* Next power of 10 */
1472: j = max - len; /* Space left for version number */
1473: k = 3 + i; /* Space needed for it */
1474: if (j < k) { /* Make room if necessary */
1475: len -= (k - j); /* Adjust length of filename */
1476: bp = buf + len; /* Point to new end */
1477: }
1478: *bp++ = '*'; /* Put a star on the end (UNIX) */
1479: *bp-- = '\0'; /* Terminate with null */
1480:
1481: n = zxpand(buf); /* Expand the resulting wild name */
1482: /* n is the number of matches */
1483: while (n-- > 0) { /* Find any existing name.~n~ files */
1484: xp = *mtchptr++; /* Point at matching name */
1485: xp += len; /* Look for .~<n>~ at the end of it */
1486: if (*xp == '.' && *(xp+1) == '~') { /* Has a version number */
1487: t = atoi(xp+2); /* Get it */
1488: if (t > d) d = t; /* Save d = highest version number */
1489: }
1490: }
1491: if (d < power-1) { /* Less than maximum possible? */
1492: sprintf(bp,".~%d~",d+1); /* Yes, make "name.~<d+1>~" */
1493: *s = buf; /* Point to new name */
1494: return; /* Done, return it */
1495: }
1496: }
1497: sprintf(bp,".~xxxx~"); /* Too many, use xxxx. */
1498: #endif /* OS2 */
1499: *s = buf;
1500: return;
1501: }
1502:
1503: /* Z R E N A M E -- Rename a file */
1504:
1505: /* Note, link() and unlink() are used because rename() is not available */
1506: /* in some versions of UNIX. */
1507: /* Call with old and new names */
1508: /* Returns 0 on success, -1 on failure. */
1509:
1510: int
1511: zrename(old,new) char *old, *new; {
1512: #ifdef OS2
1513: return rename(old, new);
1514: #else
1515: if (link(old,new) < 0) { /* Make a link with the new name. */
1516: debug(F110," link fails",old,0);
1517: return(-1);
1518: }
1519: if (unlink(old) < 0) { /* Unlink the old name. */
1520: debug(F110," link fails",old,0);
1521: return(-1);
1522: }
1523: return(0);
1524: #endif /* OS2 */
1525: }
1526:
1527: /* Z S A T T R */
1528: /*
1529: Fills in a Kermit file attribute structure for the file which is to be sent.
1530: Returns 0 on success with the structure filled in, or -1 on failure.
1531: If any string member is null, then it should be ignored.
1532: If any numeric member is -1, then it should be ignored.
1533: */
1534: int
1535: zsattr(xx) struct zattr *xx; {
1536: long k;
1537:
1538: k = iflen % 1024L; /* File length in K */
1539: if (k != 0L) k = 1L;
1540: xx->lengthk = (iflen / 1024L) + k;
1541: xx->type.len = 0; /* File type can't be filled in here */
1542: xx->type.val = "";
1543: if (*nambuf) {
1544: xx->date.val = zfcdat(nambuf); /* File creation date */
1545: xx->date.len = (int)strlen(xx->date.val);
1546: } else {
1547: xx->date.len = 0;
1548: xx->date.val = "";
1549: }
1550: xx->creator.len = 0; /* File creator */
1551: xx->creator.val = "";
1552: xx->account.len = 0; /* File account */
1553: xx->account.val = "";
1554: xx->area.len = 0; /* File area */
1555: xx->area.val = "";
1556: xx->passwd.len = 0; /* Area password */
1557: xx->passwd.val = "";
1558: xx->blksize = -1L; /* File blocksize */
1559: xx->access.len = 0; /* File access */
1560: xx->access.val = "";
1561: xx->encoding.len = 0; /* Transfer syntax */
1562: xx->encoding.val = 0;
1563: xx->disp.len = 0; /* Disposition upon arrival */
1564: xx->disp.val = "";
1565: xx->lprotect.len = 0; /* Local protection */
1566: xx->lprotect.val = "";
1567: xx->gprotect.len = 0; /* Generic protection */
1568: xx->gprotect.val = "";
1569: xx->systemid.len = 2; /* System ID */
1570: xx->systemid.val = "U1";
1571: xx->recfm.len = 0; /* Record format */
1572: xx->recfm.val = "";
1573: xx->sysparam.len = 0; /* System-dependent parameters */
1574: xx->sysparam.val = "";
1575: xx->length = iflen; /* Length */
1576: return(0);
1577: }
1578:
1579: #ifdef COMMENT
1580: int
1581: zfree(f) char *f; { /* Check free space */
1582: /* How??? */
1583: return(0);
1584: }
1585: #endif /* COMMENT */
1586:
1587: /* Z F C D A T -- Get file creation date */
1588: /*
1589: Call with pointer to filename.
1590: On success, returns pointer to creation date in yyyymmdd hh:mm:ss format.
1591: On failure, returns pointer to null string.
1592: */
1593: static char datbuf[40];
1594:
1595: /* static */ /* (===OS2 change===) */
1596: char *
1597: zfcdat(name) char *name; {
1598:
1599: #ifdef TIMESTAMP
1600: struct stat buffer;
1601: struct tm *time_stamp, *localtime();
1602: int yy, ss;
1603:
1604: datbuf[0] = '\0';
1605: if(stat(name,&buffer) != 0) {
1606: debug(F110,"zfcdat stat failed",name,0);
1607: return("");
1608: }
1609: time_stamp = localtime(&(buffer.st_mtime));
1610: yy = time_stamp->tm_year;
1611: if (yy < 100) /* In case it returns 2-digit year? */
1612: yy += 1900;
1613: if (yy < 0 || yy > 9999) { /* Make sure year is ok */
1614: debug(F110,"zfcdat date failed",name,0);
1615: return("");
1616: }
1617: if (time_stamp->tm_mon < 0 || time_stamp->tm_mon > 11)
1618: return("");
1619: if (time_stamp->tm_mday < 0 || time_stamp->tm_mday > 31)
1620: return("");
1621: if (time_stamp->tm_hour < 0 || time_stamp->tm_hour > 23)
1622: return("");
1623: if (time_stamp->tm_min < 0 || time_stamp->tm_min > 59)
1624: return("");
1625: ss = time_stamp->tm_sec; /* Seconds */
1626: if (ss < 0 || ss > 59) /* Some systems give a BIG number */
1627: ss = 0;
1628: sprintf(datbuf,
1629: #ifdef pdp11
1630: /* For some reason, 2.1x BSD sprintf gets the last field wrong. */
1631: "%04d%02d%02d %02d:%02d:00",
1632: #else
1633: "%04d%02d%02d %02d:%02d:%02d",
1634: #endif /* pdp11 */
1635: yy,
1636: time_stamp->tm_mon + 1,
1637: time_stamp->tm_mday,
1638: time_stamp->tm_hour,
1639: time_stamp->tm_min
1640: #ifndef pdp11
1641: , ss
1642: #endif /* pdp11 */
1643: );
1644: yy = (int)strlen(datbuf);
1645: debug(F111,"zfcdat",datbuf,yy);
1646: if (yy > 17) datbuf[17] = '\0';
1647: return(datbuf);
1648: #else
1649: return("");
1650: #endif /* timestamp */
1651: }
1652:
1653: /* Z S T I M E -- Set creation date for incoming file */
1654: /*
1655: Call with:
1656: f = pointer to name of existing file.
1657: yy = pointer to a Kermit file attribute structure in which yy->date.val
1658: is a date of the form yyyymmdd hh:mm:ss, e.g. 19900208 13:00:00.
1659: x = is a function code: 0 means to set the file's creation date as given.
1660: 1 means compare the given date with the file creation date.
1661: Returns:
1662: -1 on any kind of error.
1663: 0 if x is 0 and the file date was set successfully.
1664: 0 if x is 1 and date from attribute structure <= file creation date.
1665: 1 if x is 1 and date from attribute structure > file creation date.
1666: */
1667: int
1668: zstime(f,yy,x) char *f; struct zattr *yy; int x; {
1669: int r = -1; /* return code */
1670: /*
1671: It is ifdef'd TIMESTAMP because it might not work on V7. [email protected].
1672: */
1673: #ifdef TIMESTAMP
1674: /*
1675: To do: adapt code from OS-9 Kermit's ck9fio.c zstime function, which
1676: is more flexible, allowing [yy]yymmdd[ hh:mm[:ss]].
1677: */
1678: #ifndef OS2
1679: extern int ftime(), stat(), utime();
1680: /* at least, the declarations for int functions are not needed anyway */
1681: extern struct tm *localtime();
1682: /* and this should have been declared always through a header file */
1683: #endif /* OS2 */
1684: long tm, days;
1685: int i, n, isleapyear;
1686: /* J F M A M J J A S O N D */
1687: /* 31 28 31 30 31 30 31 31 30 31 30 31 */
1688: static
1689: int monthdays [13] = { 0,0,31,59,90,120,151,181,212,243,273,304,334 };
1690: char s[5];
1691: struct stat sb;
1692: #ifdef OS2
1693: struct utimbuf tp;
1694: #else
1695: #ifdef V7
1696: struct utimbuf {
1697: time_t timep[2]; /* New access and modificaton time */
1698: } tp;
1699: char *tz;
1700: long timezone; /* In case timezone not defined in .h file */
1701: #else
1702: struct utimbuf {
1703: time_t atime; /* New access time */
1704: time_t mtime; /* New modification time */
1705: } tp;
1706: #endif /* V7 */
1707: #endif /* OS2 */
1708:
1709: #ifdef ANYBSD
1710: long timezone;
1711: static struct timeb tbp;
1712: #endif
1713:
1714: debug(F110,"zstime",f,0);
1715:
1716: if ((yy->date.len == 0)
1717: || (yy->date.len != 17)
1718: || (yy->date.val[8] != ' ')
1719: || (yy->date.val[11] != ':')
1720: || (yy->date.val[14] != ':') ) {
1721: debug(F111,"Bad creation date ",yy->date.val,yy->date.len);
1722: return(-1);
1723: }
1724: debug(F111,"zstime date check 1",yy->date.val,yy->date.len);
1725: for(i = 0; i < 8; i++) {
1726: if (!isdigit(yy->date.val[i])) {
1727: debug(F111,"Bad creation date ",yy->date.val,yy->date.len);
1728: return(-1);
1729: }
1730: }
1731: debug(F111,"zstime date check 2",yy->date.val,yy->date.len);
1732: i++;
1733:
1734: for (; i < 16; i += 3) {
1735: if ((!isdigit(yy->date.val[i])) || (!isdigit(yy->date.val[i + 1]))) {
1736: debug(F111,"Bad creation date ",yy->date.val,yy->date.len);
1737: return(-1);
1738: }
1739: }
1740: debug(F111,"zstime date check 3",yy->date.val,yy->date.len);
1741:
1742: #ifdef ANYBSD
1743: debug(F100,"ztime BSD calling ftime","",0);
1744: ftime(&tbp);
1745: debug(F100,"ztime BSD back from ftime","",0);
1746: timezone = tbp.timezone * 60L;
1747: debug(F101,"ztime BSD timezone","",timezone);
1748: #endif
1749:
1750: #ifdef ATTSV
1751: tzset(); /* Set `timezone'. */
1752: #endif /* ATTSV */
1753:
1754: #ifdef V7
1755: if ((tz = getenv("TZ")) == NULL)
1756: timezone = 0; /* UTC/GMT */
1757: else
1758: timezone = atoi(&tz[3]); /* Set 'timezone'. */
1759: timezone *= 60L;
1760: #endif
1761:
1762: debug(F100,"zstime so far so good","",0);
1763:
1764: s[4] = '\0';
1765: for (i = 0; i < 4; i++) /* Fix the year */
1766: s[i] = yy->date.val[i];
1767:
1768: debug(F110,"zstime year",s,0);
1769:
1770: n = atoi(s);
1771:
1772: debug(F111,"zstime year",s,n);
1773:
1774: /* Previous year's leap days. This won't work after year 2100, */
1775: /* I don't care about that! */
1776: isleapyear = (( n % 4 == 0 && n % 100 !=0) || n % 400 == 0);
1777: days = (long) (n - 1970) * 365;
1778: days += (n - 1968 - 1) / 4 - (n - 1900 - 1) / 100 + (n - 1600 - 1) / 400;
1779:
1780: s[2] = '\0';
1781:
1782: for (i = 4 ; i < 16; i += 2) {
1783: s[0] = yy->date.val[i];
1784: s[1] = yy->date.val[i + 1];
1785: n = atoi(s);
1786: debug(F110,"zstime entering switch",s,0);
1787: switch (i) {
1788: case 4: /* MM: month */
1789: if ((n < 1 ) || ( n > 12)) {
1790: debug(F111,"Bad creation date ",yy->date.val,yy->date.len);
1791: return(-1);
1792: }
1793: days += monthdays [n];
1794: if (isleapyear && n > 2)
1795: ++days;
1796: continue;
1797:
1798: case 6: /* DD: day */
1799: if ((n < 1 ) || ( n > 31)) {
1800: debug(F111,"Bad creation date ",yy->date.val,yy->date.len);
1801: return(-1);
1802: }
1803: tm = (days + n - 1) * 24L * 60L * 60L;
1804: i++; /* Skip the space */
1805: continue;
1806:
1807: case 9: /* hh: hour */
1808: if ((n < 0 ) || ( n > 23)) {
1809: debug(F111,"Bad creation date ",yy->date.val,yy->date.len);
1810: return(-1);
1811: }
1812: tm += n * 60L * 60L;
1813: i++; /* Skip the colon */
1814: continue;
1815:
1816: case 12: /* mm: minute */
1817: if ((n < 0 ) || ( n > 59)) {
1818: debug(F111,"Bad creation date ",yy->date.val,yy->date.len);
1819: return(-1);
1820: }
1821: #ifdef ANYBSD /* Correct for time zone */
1822: tm += timezone;
1823: #else
1824: #ifdef ultrix
1825: tm += (long) timezone;
1826: #else
1827: tm += timezone;
1828: #endif /* ultrix */
1829: #endif /* ANYBSD */
1830: tm += n * 60L;
1831: i++; /* Skip the colon */
1832: continue;
1833:
1834: case 15: /* ss: second */
1835: if ((n < 0 ) || ( n > 59)) {
1836: debug(F111,"Bad creation date ",yy->date.val,yy->date.len);
1837: return(-1);
1838: }
1839: tm += n;
1840: }
1841:
1842: if (localtime(&tm)->tm_isdst)
1843: tm -= 60L * 60L; /* Adjust for daylight savings time */
1844: }
1845:
1846: debug(F111,"Attribute creation date ok ",yy->date.val,yy->date.len);
1847:
1848: if (stat(f,&sb)) { /* Get the time for the file */
1849: debug(F110,"Can't stat file:",f,0);
1850: return(-1);
1851: }
1852: #ifdef OS2
1853: tp.modtime = tm; /* Set modif. time to creation date */
1854: tp.actime = sb.st_atime; /* Don't change the access time */
1855: #else
1856: #ifdef V7
1857: tp.timep[0] = tm; /* Set modif. time to creation date */
1858: tp.timep[1] = sb.st_atime; /* Don't change the access time */
1859: #else
1860: tp.mtime = tm; /* Set modif. time to creation date */
1861: tp.atime = sb.st_atime; /* Don't change the access time */
1862: #endif /* V7 */
1863: #endif /* OS2 */
1864:
1865: switch (x) { /* Execute desired function */
1866: case 0: /* Set the creation date of the file */
1867: if (utime(f,&tp)) { /* Fix modification time */
1868: debug(F110,"Can't set modification time for file: ",f,0);
1869: r = -1;
1870: } else {
1871: debug(F110,"Modification time is set for file: ",f,0);
1872: r = 0;
1873: }
1874: break;
1875: case 1: /* Compare the dates */
1876: debug(F111,"zstime compare",f,sb.st_atime);
1877: debug(F111,"zstime compare","packet",tm);
1878: if (sb.st_atime < tm) r = 0; else r = 1;
1879: break;
1880: default: /* Error */
1881: r = -1;
1882: }
1883: #endif /* TIMESTAMP */
1884: return(r);
1885: }
1886:
1887: /* Find initialization file. */
1888:
1889: #ifdef NOTUSED
1890: int
1891: zkermini() {
1892: /* nothing here for Unix. This function added for benefit of VMS Kermit. */
1893: return(0);
1894: }
1895: #endif /* NOTUSED */
1896:
1897: #ifndef NOFRILLS
1898: int
1899: zmail(p,f) char *p; char *f; { /* Send file f as mail to address p */
1900: /*
1901: Returns 0 on success
1902: 2 if mail delivered but temp file can't be deleted
1903: -2 if mail can't be delivered
1904: The UNIX version always returns 0 because it can't get a good return
1905: code from zsyscmd.
1906: */
1907: #ifdef BSD4
1908: /* The idea is to use /usr/ucb/mail, rather than regular mail, so that */
1909: /* a subject line can be included with -s. Since we can't depend on the */
1910: /* user's path, we use the convention that /usr/ucb/Mail = /usr/ucb/mail */
1911: /* and even if Mail has been moved to somewhere else, this should still */
1912: /* find it... The search could be made more reliable by actually using */
1913: /* access() to see if /usr/ucb/Mail exists. */
1914:
1915: /* Should also make some check on zmbuf overflow... */
1916:
1917: #ifdef OXOS
1918: sprintf(zmbuf,"mailx -s %c%s%c %s < %s", '"', f, '"', p, f);
1919: #else
1920: sprintf(zmbuf,"Mail -s %c%s%c %s < %s", '"', f, '"', p, f);
1921: #endif /* OXOS */
1922: zsyscmd(zmbuf);
1923: #else
1924: #ifdef SVORPOSIX
1925: sprintf(zmbuf,"mail %s < %s", p, f);
1926: zsyscmd(zmbuf);
1927: #else
1928: *zmbuf = '\0';
1929: #endif
1930: #endif
1931: return(0);
1932: }
1933: #endif /* NOFRILLS */
1934:
1935: #ifndef NOFRILLS
1936: int
1937: zprint(p,f) char *p; char *f; { /* Print file f with options p */
1938:
1939: #ifdef OS2
1940: sprintf(zmbuf,"print %s %s", p, f); /* Construct print command */
1941: zsyscmd(zmbuf);
1942: #else
1943: #ifdef UNIX
1944: #ifdef ANYBSD /* BSD uses lpr to spool */
1945: #ifndef OXOS /* Except Olivetti... */
1946: #define SPOOLER "lpr"
1947: #else
1948: #define SPOOLER "lp"
1949: #endif /* OXOS */
1950: #else /* Sys V uses lp */
1951: #ifdef TRS16 /* except for Tandy-16/6000... */
1952: #define SPOOLER "lpr"
1953: #else
1954: #define SPOOLER "lp"
1955: #endif
1956: #endif
1957: /*
1958: Note use of standard input redirection. In some systems, lp[r] runs
1959: setuid to lp (or ...?), so if user has sent a file into a directory
1960: that lp does not have read access to, it can't be printed unless it is
1961: feed to lp[r] as standard input.
1962: */
1963: sprintf(zmbuf,"%s %s < %s", SPOOLER, p, f); /* Construct print command */
1964: zsyscmd(zmbuf);
1965: #else /* Not UNIX */
1966: *zmbuf = '\0';
1967: #endif /* UNIX */
1968: #endif /* OS2 */
1969: return(0);
1970: }
1971: #endif /* NOFRILLS */
1972:
1973: /*
1974: Wildcard expansion functions. C-Kermit used to do this itself (see #else
1975: part...). New code (version 5A, 1990-91) just asks UNIX to do it.
1976: This lets users use the wildcard expansion features of their favorite shell.
1977: Operation is slower because of the forking & piping, but flexibility is
1978: greater and program is smaller. For OS/2, C-Kermit still does this itself.
1979: */
1980:
1981: static char scratch[MAXPATH+4]; /* Used by both methods */
1982:
1983: #ifndef OS2
1984: static int oldmtchs = 0; /* Let shell (ls) expand them. */
1985: #ifdef COMMENT
1986: static char *lscmd = "/bin/ls -d"; /* Command to use. */
1987: #else
1988: static char *lscmd = "echo"; /* Command to use. */
1989: #endif /* COMMENT */
1990:
1991: int
1992: shxpand(pat,namlst,len) char *pat, *namlst[]; int len; {
1993: char *fgbuf = NULL; /* Buffer for forming ls command */
1994: char *p, *q; /* Workers */
1995: int i, x, retcode; char c; /* ... */
1996:
1997: x = (int)strlen(pat) + (int)strlen(lscmd) + 3; /* Length of ls command */
1998: for (i = 0; i < oldmtchs; i++) /* Free previous file list */
1999: free(namlst[i]);
2000: fgbuf = malloc(x); /* Get buffer for command */
2001: if (!fgbuf) return(-1); /* Fail if cannot */
2002: sprintf(fgbuf,"%s %s",lscmd,pat); /* Form the command */
2003: zxcmd(ZIFILE,fgbuf); /* Start the command */
2004: i = 0; /* File counter */
2005: p = scratch; /* Point to scratch area */
2006: retcode = -1; /* Assume failure */
2007: while ((x = zminchar()) != -1) { /* Read characters from command */
2008: c = (char) x;
2009: if (c == ' ' || c == '\n') { /* Got newline or space? */
2010: *p = '\0'; /* Yes, terminate string */
2011: p = scratch; /* Point back to beginning */
2012: if (zchki(p) == -1) /* Does file exist? */
2013: continue; /* No, continue */
2014: x = (int)strlen(p); /* Yes, get length of name */
2015: q = malloc(x+1); /* Allocate space for it */
2016: if (!q) goto shxfin; /* Fail if space can't be obtained */
2017: strcpy(q,scratch); /* Copy name to space */
2018: namlst[i++] = q; /* Copy pointer to name into array */
2019: if (i > len) goto shxfin; /* Fail if too many */
2020: } else { /* Regular character */
2021: *p++ = c; /* Copy it into scratch area */
2022: }
2023: }
2024: retcode = i; /* Return number of matching files */
2025: shxfin: /* Common exit point */
2026: free(fgbuf); /* Free command buffer */
2027: zclosf(ZIFILE); /* Delete the command fork. */
2028: oldmtchs = i; /* Remember how many files */
2029: return(retcode);
2030: }
2031: #endif /* OS2 */
2032:
2033: /* Directory Functions for Unix, written by Jeff Damens, CUCCA, 1984. */
2034:
2035: /* Define the size of the string space for filename expansion. */
2036:
2037: #ifndef DYNAMIC
2038: #ifdef PROVX1
2039: #define SSPACE 500
2040: #else
2041: #ifdef BSD29
2042: #define SSPACE 500
2043: #else
2044: #ifdef pdp11
2045: #define SSPACE 500
2046: #else
2047: #ifdef aegis
2048: #define SSPACE 10000 /* size of string-generating buffer */
2049: static char bslash; /* backslash character if active */
2050: #else /* Default static buffer size */
2051: #define SSPACE 2000 /* size of string-generating buffer */
2052: #endif /* aegis */
2053: #endif /* pdp11 */
2054: #endif /* BSD29 */
2055: #endif /* PROVX1 */
2056: static char sspace[SSPACE]; /* buffer for generating filenames */
2057: #else /* DYNAMIC */
2058: #define SSPACE 10000
2059: static char *sspace = (char *)0;
2060: #endif /* DYNAMIC */
2061: static int ssplen = SSPACE; /* length of string space buffer */
2062:
2063: static char *freeptr,**resptr; /* copies of caller's arguments */
2064: static int remlen; /* remaining length in caller's array*/
2065: static int numfnd; /* number of matches found */
2066:
2067: /*
2068: * splitpath:
2069: * takes a string and splits the slash-separated portions into
2070: * a list of path structures. Returns the head of the list. The
2071: * structures are allocated by malloc, so they must be freed.
2072: * Splitpath is used internally by the filename generator.
2073: *
2074: * Input: A string.
2075: * Returns: A linked list of the slash-separated segments of the input.
2076: */
2077:
2078: struct path *
2079: splitpath(p) char *p; {
2080: struct path *head,*cur,*prv;
2081: int i;
2082:
2083: debug(F110,"splitpath",p,0);
2084:
2085: head = prv = NULL;
2086: if (ISDIRSEP(*p)) p++; /* skip leading slash */
2087: while (*p != '\0') {
2088: cur = (struct path *) malloc(sizeof (struct path));
2089: debug(F101,"splitpath malloc","",cur);
2090: if (cur == NULL)
2091: fatal("malloc fails in splitpath()");
2092: cur -> fwd = NULL;
2093: if (head == NULL)
2094: head = cur;
2095: else
2096: prv -> fwd = cur; /* link into chain */
2097: prv = cur;
2098: #ifdef aegis
2099: /* treat backslash as "../" */
2100: if (bslash && *p == bslash) {
2101: strcpy(cur->npart, "..");
2102: ++p;
2103: } else {
2104: for (i=0; i < MAXNAMLEN && *p && *p != '/' && *p != bslash; i++)
2105: cur -> npart[i] = *p++;
2106: cur -> npart[i] = '\0'; /* end this segment */
2107: if (i >= MAXNAMLEN)
2108: while (*p && *p != '/' && *p != bslash)
2109: p++;
2110: }
2111: if (*p == '/') p++;
2112: #else
2113: #ifdef OS2
2114: for (i = 0;
2115: i < MAXNAMLEN && !ISDIRSEP(*p) && *p != ':' && *p != '\0';
2116: i++ )
2117: cur -> npart[i] = *p++;
2118: if ( *p == ':' ) {
2119: cur -> npart[i++] = *p++;
2120: if ( !ISDIRSEP(*p) )
2121: cur -> npart[i++] = '.';
2122: }
2123: #else
2124: for (i=0; i < MAXNAMLEN && !ISDIRSEP(*p) && *p != '\0'; i++) {
2125: cur -> npart[i] = *p++;
2126: }
2127: #endif /* OS2 */
2128: cur -> npart[i] = '\0'; /* end this segment */
2129: if (i >= MAXNAMLEN)
2130: while (!ISDIRSEP(*p) && *p != '\0') p++;
2131: if (ISDIRSEP(*p))
2132: p++;
2133:
2134: #endif /* aegis */
2135: }
2136: return(head);
2137: }
2138:
2139: /*
2140: * fgen:
2141: * This is the actual name generator. It is passed a string,
2142: * possibly containing wildcards, and an array of character pointers.
2143: * It finds all the matching filenames and stores them into the array.
2144: * The returned strings are allocated from a static buffer local to
2145: * this module (so the caller doesn't have to worry about deallocating
2146: * them); this means that successive calls to fgen will wipe out
2147: * the results of previous calls. This isn't a problem here
2148: * because we process one wildcard string at a time.
2149: *
2150: * Input: a wildcard string, an array to write names to, the
2151: * length of the array.
2152: * Returns: the number of matches. The array is filled with filenames
2153: * that matched the pattern. If there wasn't enough room in the
2154: * array, -1 is returned.
2155: * By: Jeff Damens, CUCCA, 1984.
2156: */
2157: static int
2158: fgen(pat,resarry,len) char *pat,*resarry[]; int len; {
2159: struct path *head;
2160: char *sptr;
2161: #ifdef aegis
2162: char *namechars;
2163: int tilde = 0, bquote = 0;
2164:
2165: if ((namechars = getenv("NAMECHARS")) != NULL) {
2166: if (xindex(namechars, '~' ) != NULL) tilde = '~';
2167: if (xindex(namechars, '\\') != NULL) bslash = '\\';
2168: if (xindex(namechars, '`' ) != NULL) bquote = '`';
2169: } else {
2170: tilde = '~'; bslash = '\\'; bquote = '`';
2171: }
2172:
2173: sptr = scratch;
2174:
2175: /* copy "`node_data", etc. anchors */
2176: if (bquote && *pat == bquote)
2177: while (*pat && *pat != '/' && *pat != bslash)
2178: *sptr++ = *pat++;
2179: else if (tilde && *pat == tilde)
2180: *sptr++ = *pat++;
2181: while (*pat == '/')
2182: *sptr++ = *pat++;
2183: if (sptr == scratch) {
2184: strcpy(scratch,"./");
2185: sptr = scratch+2;
2186: } /* init buffer correctly */
2187: head = splitpath(pat);
2188: #else /* not aegis */
2189: debug(F110,"fgen pat",pat,0);
2190: head = splitpath(pat);
2191: sptr = scratch;
2192: if (!ISDIRSEP(*pat))
2193: *sptr++ = '.'; /* init buffer correctly */
2194: *sptr++ = DIRSEP;
2195: #ifdef OS2
2196: if (isalpha(pat[0]) && pat[1] == ':')
2197: sptr = scratch; /* reset in case of leading drive: */
2198: #endif
2199: #endif /* aegis */
2200: numfnd = 0; /* none found yet */
2201: #ifdef DYNAMIC
2202: if (!sspace) { /* Need to allocate string space? */
2203: while (ssplen > 50) {
2204: if ((sspace = malloc(ssplen+2))) { /* Got it. */
2205: debug(F101,"fgen string space","",ssplen);
2206: break;
2207: }
2208: ssplen = (ssplen / 2) + (ssplen / 4); /* Didn't, reduce by 3/4 */
2209: }
2210: if (ssplen < 50) { /* Did we get it? */
2211: fprintf(stderr,"fgen can't malloc string space\n");
2212: return(-1);
2213: }
2214: }
2215: #endif /* DYNAMIC */
2216: freeptr = sspace; /* this is where matches are copied */
2217: resptr = resarry; /* static copies of these so */
2218: remlen = len; /* recursive calls can alter them */
2219: traverse(head,scratch,sptr); /* go walk the directory tree */
2220: #ifdef COMMENT
2221: /*
2222: This code, circa 1984, has never worked right - it references the head
2223: pointer after it has already been freed. Lord knows what might have been
2224: happening because of this. Thanks to Steve Walton for finding & fixing this
2225: bug.
2226: */
2227: for (; head != NULL; head = head -> fwd)
2228: free(head); /* return the path segments */
2229: #else
2230: while (head != NULL) {
2231: struct path *next = head -> fwd;
2232: free(head);
2233: head = next;
2234: }
2235: #endif /* COMMENT */
2236: return(numfnd); /* and return the number of matches */
2237: }
2238:
2239: /* traverse:
2240: * Walks the directory tree looking for matches to its arguments.
2241: * The algorithm is, briefly:
2242: * If the current pattern segment contains no wildcards, that
2243: * segment is added to what we already have. If the name so far
2244: * exists, we call ourselves recursively with the next segment
2245: * in the pattern string; otherwise, we just return.
2246: *
2247: * If the current pattern segment contains wildcards, we open the name
2248: * we've accumulated so far (assuming it is really a directory), then read
2249: * each filename in it, and, if it matches the wildcard pattern segment, add
2250: * that filename to what we have so far and call ourselves recursively on the
2251: * next segment.
2252: *
2253: * Finally, when no more pattern segments remain, we add what's accumulated
2254: * so far to the result array and increment the number of matches.
2255: *
2256: * Input: a pattern path list (as generated by splitpath), a string
2257: * pointer that points to what we've traversed so far (this
2258: * can be initialized to "/" to start the search at the root
2259: * directory, or to "./" to start the search at the current
2260: * directory), and a string pointer to the end of the string
2261: * in the previous argument.
2262: * Returns: nothing.
2263: */
2264: static VOID
2265: traverse(pl,sofar,endcur) struct path *pl; char *sofar, *endcur; {
2266:
2267: /* Define LONGFN (long file names) automatically for BSD 2.9 and 4.2 */
2268: /* LONGFN can also be defined on the cc command line. */
2269:
2270: #ifdef BSD29
2271: #ifndef LONGFN
2272: #define LONGFN
2273: #endif
2274: #endif
2275:
2276: #ifdef BSD42
2277: #ifndef LONGFN
2278: #define LONGFN
2279: #endif
2280: #endif
2281:
2282: /* Appropriate declarations for directory routines and structures */
2283: /* #define OPENDIR means to use opendir(), readdir(), closedir() */
2284: /* If OPENDIR not defined, we use open(), read(), close() */
2285:
2286: #ifdef DIRENT /* New way, <dirent.h> */
2287: #define OPENDIR
2288: DIR *fd, *opendir();
2289: struct dirent *dirbuf;
2290: struct dirent *readdir();
2291: #else /* !DIRENT */
2292: #ifdef LONGFN /* Old way, <dir.h> with opendir() */
2293: #define OPENDIR
2294: DIR *fd, *opendir();
2295: struct direct *dirbuf;
2296: #else /* !LONGFN */
2297: int fd; /* Old way, <dir.h> with open() */
2298: struct direct dir_entry;
2299: struct direct *dirbuf = &dir_entry;
2300: #endif /* LONGFN */
2301: #endif /* DIRENT */
2302:
2303: struct stat statbuf; /* for file info */
2304:
2305: if (pl == NULL) {
2306: *--endcur = '\0'; /* end string, overwrite trailing / */
2307: addresult(sofar);
2308: return;
2309: }
2310: if (!iswild(pl -> npart)) {
2311: strcpy(endcur,pl -> npart);
2312: endcur += (int)strlen(pl -> npart);
2313: *endcur = '\0'; /* end current string */
2314: if (stat(sofar,&statbuf) == 0) { /* if current piece exists */
2315: #ifdef OS2
2316: if (endcur - sofar == 3 && endcur[-1] == '.' && endcur[-2] == ':')
2317: endcur--;
2318: else
2319: #endif /* OS2 */
2320: *endcur++ = DIRSEP; /* add slash to end */
2321: *endcur = '\0'; /* and end the string */
2322: traverse(pl -> fwd,sofar,endcur);
2323: }
2324: return;
2325: }
2326:
2327: /* Segment contains wildcards, have to search directory */
2328:
2329: *endcur = '\0'; /* end current string */
2330: if (stat(sofar,&statbuf) == -1) return; /* doesn't exist, forget it */
2331: if (!S_ISDIR (statbuf.st_mode)) return; /* not a directory, skip */
2332:
2333: #ifdef OPENDIR
2334: if ((fd = opendir(sofar)) == NULL) return; /* Can't open, fail. */
2335: while (dirbuf = readdir(fd))
2336: #else /* !OPENDIR */
2337: if ((fd = open(sofar,O_RDONLY)) < 0) return; /* Can't open, fail. */
2338: while (read(fd, (char *)dirbuf, sizeof dir_entry))
2339: #endif /* OPENDIR */
2340: {
2341: /* Get null-terminated copy!!! */
2342: strncpy(nambuf,dirbuf->d_name,MAXNAMLEN);
2343: nambuf[MAXNAMLEN] = '\0';
2344: #ifdef unos
2345: if (dirbuf->d_ino != -1 && match(pl -> npart,nambuf))
2346: #else
2347: /* #ifdef _POSIX_SOURCE */
2348: /*
2349: This is not specified in POSIX.1. In POSIX.2, there will be
2350: some kind of filename matching facility, but it will not be done this way.
2351: Therefore, we should not even be looking in the directory at all.
2352: Maybe POSIX implementations should force "set wildcard shell"?
2353: */
2354:
2355: #ifdef sun
2356: if (dirbuf->d_fileno != 0 && match(pl -> npart,nambuf))
2357: #else
2358: #ifdef ultrix
2359: if (dirbuf->gd_ino != 0 && match(pl -> npart,nambuf))
2360: #else
2361: if (dirbuf->d_ino != 0 && match(pl -> npart,nambuf))
2362: #endif /* ultrix */
2363: #endif /* sun */
2364:
2365: /* #else */ /* not _POSIX_SOURCE */
2366: /* if (dirbuf->d_ino != 0 && match(pl -> npart,nambuf)) */
2367: /* #endif */ /* _POSIX_SOURCE */
2368:
2369: #endif /* unos */
2370: {
2371: char *eos;
2372: strcpy(endcur,nambuf);
2373: eos = endcur + (int)strlen(nambuf);
2374: *eos++ = DIRSEP; /* end this segment */
2375: traverse(pl -> fwd,sofar,eos);
2376: }
2377: }
2378: #ifdef OPENDIR
2379: closedir(fd);
2380: #else /* !OPENDIR */
2381: close(fd);
2382: #endif /* OPENDIR */
2383: }
2384:
2385: /*
2386: * addresult:
2387: * Adds a result string to the result array. Increments the number
2388: * of matches found, copies the found string into our string
2389: * buffer, and puts a pointer to the buffer into the caller's result
2390: * array. Our free buffer pointer is updated. If there is no
2391: * more room in the caller's array, the number of matches is set to -1.
2392: * Input: a result string.
2393: * Returns: nothing.
2394: */
2395: static VOID
2396: addresult(str) char *str; {
2397: int l;
2398: debug(F111,"addresult",str,remlen);
2399: if (str[0] == '.' && ISDIRSEP(str[1])) str += 2; /* (===OS2 change===) */
2400: if (--remlen < 0) {
2401: numfnd = -1;
2402: return;
2403: }
2404: l = (int)strlen(str) + 1; /* size this will take up */
2405: if ((freeptr + l) > (sspace + ssplen)) {
2406: numfnd = -1; /* do not record if not enough space */
2407: return;
2408: }
2409: strcpy(freeptr,str);
2410: *resptr++ = freeptr;
2411: freeptr += l;
2412: numfnd++;
2413: }
2414:
2415: /*
2416: * match:
2417: * pattern matcher. Takes a string and a pattern possibly containing
2418: * the wildcard characters '*' and '?'. Returns true if the pattern
2419: * matches the string, false otherwise.
2420: * by: Jeff Damens, CUCCA, 1984
2421: * skipping over dot files and backslash quoting added by fdc, 1990.
2422: *
2423: * Input: a string and a wildcard pattern.
2424: * Returns: 1 if match, 0 if no match.
2425: */
2426: static int
2427: match(pattern,string) char *pattern,*string; {
2428: char *psave,*ssave; /* back up pointers for failure */
2429: int q = 0; /* quote flag */
2430:
2431: debug(F110,"match str",string,0);
2432: psave = ssave = NULL;
2433: #ifndef MATCHDOT
2434: if (*string == '.' && *pattern != '.') {
2435: debug(F110,"match skip",string,0);
2436: return(0);
2437: }
2438: #endif
2439: while (1) {
2440: for (; *pattern == *string; pattern++,string++) /* skip first */
2441: if (*string == '\0') return(1); /* end of strings, succeed */
2442:
2443: if (*pattern == '\\' && q == 0) { /* Watch out for quoted */
2444: q = 1; /* metacharacters */
2445: pattern++; /* advance past quote */
2446: if (*pattern != *string) return(0);
2447: continue;
2448: } else q = 0;
2449:
2450: if (q) {
2451: return(0);
2452: } else {
2453: if (*string != '\0' && *pattern == '?') {
2454: pattern++; /* '?', let it match */
2455: string++;
2456: } else if (*pattern == '*') { /* '*' ... */
2457: psave = ++pattern; /* remember where we saw it */
2458: ssave = string; /* let it match 0 chars */
2459: } else if (ssave != NULL && *ssave != '\0') { /* if not at end */
2460: /* ...have seen a star */
2461: string = ++ssave; /* skip 1 char from string */
2462: pattern = psave; /* and back up pattern */
2463: } else return(0); /* otherwise just fail */
2464: }
2465: }
2466: }
2467:
2468: /*
2469: The following two functions are for expanding tilde in filenames
2470: Contributed by Howie Kaye, CUCCA, developed for CCMD package.
2471: */
2472:
2473: /* W H O A M I -- Get user's username. */
2474:
2475: /*
2476: 1) Get real uid
2477: 2) See if the $USER environment variable is set ($LOGNAME on AT&T)
2478: 3) If $USER's uid is the same as ruid, realname is $USER
2479: 4) Otherwise get logged in user's name
2480: 5) If that name has the same uid as the real uid realname is loginname
2481: 6) Otherwise, get a name for ruid from /etc/passwd
2482: */
2483: static char *
2484: whoami () {
2485: #ifdef DTILDE
2486: static char realname[256]; /* user's name */
2487: static int ruid = -1; /* user's real uid */
2488: char loginname[256], envname[256]; /* temp storage */
2489: char *c;
2490: struct passwd *p;
2491: _PROTOTYP(extern char * getlogin, (void) );
2492:
2493: if (ruid != -1)
2494: return(realname);
2495:
2496: ruid = real_uid(); /* get our uid */
2497:
2498: /* how about $USER or $LOGNAME? */
2499: if ((c = getenv(NAMEENV)) != NULL) { /* check the env variable */
2500: strcpy (envname, c);
2501: p = getpwnam(envname);
2502: if (p->pw_uid == ruid) { /* get passwd entry for envname */
2503: strcpy (realname, envname); /* if the uid's are the same */
2504: return(realname);
2505: }
2506: }
2507:
2508: /* can we use loginname() ? */
2509:
2510: if ((c = getlogin()) != NULL) { /* name from utmp file */
2511: strcpy (loginname, c);
2512: if ((p = getpwnam(loginname)) != NULL) /* get passwd entry */
2513: if (p->pw_uid == ruid) { /* for loginname */
2514: strcpy (realname, loginname); /* if the uid's are the same */
2515: return(realname);
2516: }
2517: }
2518:
2519: /* Use first name we get for ruid */
2520:
2521: if ((p = getpwuid(ruid)) == NULL) { /* name for uid */
2522: realname[0] = '\0'; /* no user name */
2523: ruid = -1;
2524: return(NULL);
2525: }
2526: strcpy (realname, p->pw_name);
2527: return(realname);
2528: #else
2529: return(NULL);
2530: #endif /* DTILDE */
2531: }
2532:
2533: /* T I L D E _ E X P A N D -- expand ~user to the user's home directory. */
2534:
2535: char *
2536: tilde_expand(dirname) char *dirname; {
2537: #define BUFLEN 256
2538: #ifdef DTILDE
2539: struct passwd *user;
2540: static char olddir[BUFLEN];
2541: static char oldrealdir[BUFLEN];
2542: static char temp[BUFLEN];
2543: int i, j;
2544:
2545: debug(F111,"tilde_expand",dirname,dirname[0]);
2546:
2547: if (dirname[0] != '~') /* Not a tilde...return param */
2548: return(dirname);
2549: if (!strcmp(olddir,dirname)) { /* Same as last time */
2550: return(oldrealdir); /* so return old answer. */
2551: } else {
2552: j = (int)strlen(dirname);
2553: for (i = 0; i < j; i++) /* find username part of string */
2554: if (!ISDIRSEP(dirname[i]))
2555: temp[i] = dirname[i];
2556: else break;
2557: temp[i] = '\0'; /* tie off with a NULL */
2558: if (i == 1) { /* if just a "~" */
2559: user = getpwnam(whoami()); /* get info on current user */
2560: } else {
2561: user = getpwnam(&temp[1]); /* otherwise on the specified user */
2562: }
2563: }
2564: if (user != NULL) { /* valid user? */
2565: strcpy(olddir, dirname); /* remember the directory */
2566: strcpy(oldrealdir,user->pw_dir); /* and their home directory */
2567: strcat(oldrealdir,&dirname[i]);
2568: return(oldrealdir);
2569: } else { /* invalid? */
2570: strcpy(olddir, dirname); /* remember for next time */
2571: strcpy(oldrealdir, dirname);
2572: return(oldrealdir);
2573: }
2574: #else
2575: return(NULL);
2576: #endif /* DTILDE */
2577: }
2578:
2579: /*
2580: Functions for executing system commands.
2581: zsyscmd() executes the system command in the normal, default way for
2582: the system. In UNIX, it does what system() does. Thus, its results
2583: are always predictable.
2584: zshcmd() executes the command using the user's preferred shell.
2585: */
2586: int
2587: zsyscmd(s) char *s; {
2588: #ifdef OS2
2589: if (!priv_chk()) system(s);
2590: #else
2591: PID_T shpid;
2592: #ifdef COMMENT
2593: /* This doesn't work... */
2594: WAIT_T status;
2595: #else
2596: int status;
2597: #endif /* COMMENT */
2598:
2599: if (shpid = fork()) {
2600: if (shpid < (PID_T)0) return(-1); /* Parent */
2601: while (shpid != (PID_T) wait(&status))
2602: ;
2603: return(status);
2604: }
2605: if (priv_can()) { /* Child: cancel any priv's */
2606: printf("?Privilege cancellation failure\n");
2607: _exit(255);
2608: }
2609: execl("/bin/sh","sh","-c",s,NULL);
2610: perror("/bin/sh");
2611: _exit(255);
2612: return(0); /* Shut up ANSI compilers. */
2613: #endif /* OS2 */
2614: }
2615:
2616: /*
2617: UNIX code by H. Fischer; copyright rights assigned to Columbia Univ.
2618: Adapted to use getpwuid to find login shell because many systems do not
2619: have SHELL in environment, and to use direct calling of shell rather
2620: than intermediate system() call. -- H. Fischer
2621: Call with s pointing to command to execute.
2622: */
2623:
2624: int
2625: zshcmd(s) char *s; {
2626: PID_T pid;
2627:
2628: #ifdef OS2
2629: char *shell = getenv("COMSPEC");
2630: if (!priv_chk())
2631: if (*s == '\0')
2632: spawnl(P_WAIT, shell, shell, NULL);
2633: else
2634: system(s);
2635: #else
2636: #ifdef AMIGA
2637: if (!priv_chk()) system(s);
2638: #else
2639: #ifdef datageneral
2640: if (priv_chk) return(1);
2641: if (*s == '\0') /* Interactive shell requested? */
2642: #ifdef mvux
2643: system("/bin/sh ");
2644: #else
2645: system("x :cli prefix Kermit_Baby:");
2646: #endif /* mvux */
2647: else /* Otherwise, */
2648: system(s); /* Best for aos/vs?? */
2649:
2650: #else
2651: #ifdef aegis
2652: if ((pid = vfork()) == 0) { /* Make child quickly */
2653: char *shpath, *shname, *shptr; /* For finding desired shell */
2654:
2655: if (priv_can()) exit(1); /* Turn off privs. */
2656: if ((shpath = getenv("SHELL")) == NULL) shpath = "/com/sh";
2657:
2658: #else /* All Unix systems */
2659: if ((pid = fork()) == 0) { /* Make child */
2660: char *shpath, *shname, *shptr; /* For finding desired shell */
2661: struct passwd *p;
2662: char *defshell = "/bin/sh"; /* Default */
2663:
2664: if (priv_can()) exit(1); /* Turn off privs. */
2665: p = getpwuid(real_uid()); /* Get login data */
2666: if (p == (struct passwd *) NULL || !*(p->pw_shell))
2667: shpath = defshell;
2668: else
2669: shpath = p->pw_shell;
2670: #endif /* aegis */
2671: shptr = shname = shpath;
2672: while (*shptr != '\0')
2673: if (*shptr++ == DIRSEP)
2674: shname = shptr;
2675: if (s == NULL || *s == '\0') { /* Interactive shell requested? */
2676: execl(shpath,shname,"-i",NULL); /* Yes, do that */
2677: } else { /* Otherwise, */
2678: execl(shpath,shname,"-c",s,NULL); /* exec the given command */
2679: } /* If execl() failed, */
2680: exit(BAD_EXIT); /* return bad return code. */
2681:
2682: } else { /* Parent */
2683:
2684: int wstat; /* ... must wait for child */
2685: SIGTYP (*istat)(), (*qstat)();
2686:
2687: if (pid == -1) return(0); /* fork() failed? */
2688:
2689: istat = signal(SIGINT,SIG_IGN); /* Let the fork handle keyboard */
2690: qstat = signal(SIGQUIT,SIG_IGN); /* interrupts itself... */
2691:
2692: while (((wstat = wait((WAIT_T *)0)) != pid) && (wstat != -1))
2693: ; /* Wait for fork */
2694: signal(SIGINT,istat); /* Restore interrupts */
2695: signal(SIGQUIT,qstat);
2696: }
2697: #endif
2698: #endif
2699: #endif
2700: return(1);
2701: }
2702:
2703: #ifdef aegis
2704: /*
2705: Replacement for strchr() and index(), neither of which seem to be universal.
2706: */
2707:
2708: static char *
2709: #ifdef CK_ANSIC
2710: xindex(char * s, char c)
2711: #else
2712: xindex(s,c) char *s, c;
2713: #endif /* CK_ANSIC */
2714: /* xindex */ {
2715: while (*s != '\0' && *s != c) s++;
2716: if (*s == c) return(s); else return(NULL);
2717: }
2718: #endif /* aegis */
2719:
2720: /* I S W I L D -- Check if filespec is "wild" */
2721:
2722: /*
2723: Returns 0 if it is a single file, 1 if it contains wildcard characters.
2724: Note: must match the algorithm used by match(), hence no [a-z], etc.
2725: */
2726: int
2727: iswild(filespec) char *filespec; {
2728: char c; int x; char *p;
2729: if (wildxpand) {
2730: if ((x = zxpand(filespec)) > 1) return(1);
2731: p = malloc(MAXNAMLEN + 20);
2732: znext(p);
2733: x = (strcmp(filespec,p) != 0);
2734: free(p);
2735: return(x);
2736: } else {
2737: while ((c = *filespec++) != '\0')
2738: if (c == '*' || c == '?') return(1);
2739: return(0);
2740: }
2741: }
2742:
2743: #ifdef OS2
2744:
2745: /* Z C H D S K -- Change currently selected disk device */
2746:
2747: /* Returns -1 if error, otherwise 0 */
2748:
2749: zchdsk(c) char c; {
2750: int i = toupper(c) - 64;
2751: return( _chdrive(i) ? 0 : -1 );
2752: }
2753:
2754: #undef stat
2755:
2756: os2stat(char *path, struct stat *st) {
2757: char local[MAXPATHLEN];
2758: int len;
2759:
2760: strcpy(local, path);
2761: len = strlen(local);
2762:
2763: if ( len == 2 && local[1] == ':' )
2764: local[2] = DIRSEP, local[3] = 0; /* if drive only, append / */
2765: else if ( len == 0 )
2766: local[0] = DIRSEP, local[1] = 0; /* if empty path, take / instead */
2767: else if ( len > 1 && ISDIRSEP(local[len - 1]) && local[len - 2] != ':' )
2768: local[len - 1] = 0; /* strip trailing / except after d: */
2769:
2770: return stat(local, st);
2771: }
2772:
2773: #endif /* OS2 */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.