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