Context Navigation

source: trunk/third/kermit/ckufio.c @ 10780

Visit:

Revision 10780, 134.3 KB checked in by brlewis, 27 years ago (diff)
This commit was generated by cvs2svn to compensate for changes in r10779, which included commits to RCS files with non-trunk default branches.

Line
1	#ifdef OS2
2	#ifdef NT
3	char *ckzv = "Win32 File support, 6.0.115 19 Nov 96";
4	#else /* NT */
5	char *ckzv = "OS/2 File support, 6.0.115 19 Nov 96";
6	#endif /* NT */
7	#else
8	#ifdef aegis
9	char *ckzv = "Aegis File support, 6.0.115 6 Sep 96";
10	#else
11	#ifdef Plan9
12	char *ckzv = "Plan 9 File support, 6.0.115 6 Sep 96";
13	#else
14	char *ckzv = "UNIX File support, 6.0.115 6 Sep 96";
15	#endif /* Plan9 */
16	#endif /* aegis */
17	#endif /* OS2 */
18
19	/* C K U F I O -- Kermit file system support for UNIX, OS/2, and Aegis */
20
21
22	/*
23	NOTE TO CONTRIBUTORS: This file, and all the other C-Kermit files, must be
24	compatible with C preprocessors that support only #ifdef, #else, #endif,
25	#define, and #undef. Please do not use #if, logical operators, or other
26	preprocessor features in any of the portable C-Kermit modules. You can,
27	of course, use these constructions in system-specific modules when you they
28	are supported.
29	*/
30
31	/*
32	Author: Frank da Cruz (fdc@columbia.edu),
33	Columbia University Academic Information Systems, New York City,
34	and others noted below.
35
36	Copyright (C) 1985, 1996, Trustees of Columbia University in the City of New
37	York. All rights reserved.
38	*/
39
40	/* Include Files */
41
42	#include "ckcsym.h"
43	#include "ckcdeb.h"
44	#include "ckcasc.h"
45	#ifdef OS2
46	#include "ckuusr.h"
47	#include <stdio.h>
48	_PROTOTYP( int os2settitle, (char *, int) );
49	extern int priority;
50	#ifdef NT
51	#define timezone _timezone
52	#define write _write
53	#define fileno _fileno
54	#ifndef SEM_INDEFINITE_WAIT
55	#define SEM_INDEFINITE_WAIT INFINITE
56	#endif /* SEM_INDEFINITE_WAIT */
57	#endif /* NT */
58	#endif /* OS2 */
59	#include <signal.h>
60
61	#ifdef MINIX
62	#include <limits.h>
63	#else
64	#ifdef POSIX
65	#include <limits.h>
66	#else
67	#ifdef SVR3
68	#include <limits.h>
69	#endif /* SVR3 */
70	#endif /* POSIX */
71	#endif /* MINIX */
72
73	/* Directory structure header file */
74
75	#ifdef OS2
76	/*
77
78	C-Kermit's OS/2 support originally by Chris Adie <C.Adie@uk.ac.edinburgh>
79	Edinburgh University Computing Service, Scotland, for C-Kermit 4F. Adapted
80	to C-Kermit 5A and integrated into the UNIX support module by Kai Uwe Rommel
81	<rommel@informatik.tu-muenchen.de>, Muenchen, Germany, December 1991.
82	*/
83
84	/*
85	Directory Separator macros, to allow this module to work with both UNIX and
86	OS/2: Because of ambiguity with the command line editor escape \ character,
87	the directory separator is currently left as / for OS/2 too, because the
88	OS/2 kernel also accepts / as directory separator. But this is subject to
89	change in future versions to conform to the normal OS/2 style.
90	*/
91	#define DIRSEP '/'
92	/* #define DIRSEP '\\' */
93	#define ISDIRSEP(c) ((c)=='/'\|\|(c)=='\\')
94	#else /* not OS2 */
95	#define DIRSEP '/'
96	#define ISDIRSEP(c) ((c)=='/')
97	#endif /* OS2 */
98
99	#ifdef SDIRENT
100	#define DIRENT
101	#endif /* SDIRENT */
102
103	#ifdef XNDIR
104	#include <sys/ndir.h>
105	#else /* !XNDIR */
106	#ifdef NDIR
107	#include <ndir.h>
108	#else /* !NDIR, !XNDIR */
109	#ifdef RTU
110	#include "/usr/lib/ndir.h"
111	#else /* !RTU, !NDIR, !XNDIR */
112	#ifdef DIRENT
113	#ifdef SDIRENT
114	#include <sys/dirent.h>
115	#else
116	#include <dirent.h>
117	#endif /* SDIRENT */
118	#else
119	#ifdef OS2
120	#define OPENDIR
121	#define DIRENT
122	#include "ckodir.h"
123	#else/* !RTU, !NDIR, !XNDIR, !DIRENT, !OS2, i.e. all others */
124	#include <sys/dir.h>
125	#endif /* OS2 */
126	#endif /* DIRENT */
127	#endif /* RTU */
128	#endif /* NDIR */
129	#endif /* XNDIR */
130
131	#ifdef OS2 /* OS/2 file system interface */
132	#define BSD4 /* is like Berkeley UNIX */
133	#define NOFILEH /* with no <file.h> */
134	#include <sys/utime.h>
135	#include <stdlib.h>
136	#include <process.h>
137	#include <share.h>
138	extern int binary; /* We need to know this for open() */
139	extern int fncact; /* Need this for zchkspa() */
140	extern int tlevel, cmdlvl ; /* Need this for external commands */
141	#ifdef __IBMC__
142	extern FILE popen(char , char *);
143	extern int pclose(FILE *);
144	#else
145	#ifndef __EMX__
146	#define popen _popen
147	#define pclose _pclose
148	#define fopen(n, m) _fsopen(n, m, SH_DENYWR)
149	#endif /* __EMX__ */
150	#endif /* __IBMC__ */
151	#ifdef NT
152	#include <io.h>
153	#endif /* NT */
154	#else /* OS2 */
155	#include <pwd.h> /* Password file for shell name */
156	#endif /* OS2 */
157
158	#ifdef POSIX
159	#define UTIMEH
160	#endif /* POSIX */
161
162	#ifndef OS2
163	#ifdef SYSUTIMEH /* <sys/utime.h> if requested, */
164	#include <sys/utime.h> /* for extra fields required by */
165	#else /* 88Open spec. */
166	#ifdef UTIMEH /* or <utime.h> if requested */
167	#include <utime.h> /* (SVR4, POSIX) */
168	#define SYSUTIMEH /* Use this for both cases. */
169	#endif /* UTIMEH */
170	#endif /* SYSUTIMEH */
171	#endif /* OS2 */
172
173	#ifdef POSIX
174	#define TIMESTAMP
175	#endif /* POSIX */
176
177	#ifdef BSD44 /* BSD 4.4 */
178	#ifndef TIMESTAMP
179	#define TIMESTAMP /* Can do file dates */
180	#endif /* TIMESTAMP */
181	#include <sys/time.h>
182	#include <sys/timeb.h>
183
184	#else /* Not BSD44 */
185
186	#ifdef BSD4 /* BSD 4.3 and below */
187	#define TIMESTAMP /* Can do file dates */
188	#include <time.h> /* Need this */
189	#include <sys/timeb.h> /* Need this if really BSD */
190
191	#else /* Not BSD 4.3 and below */
192
193	#ifdef SVORPOSIX /* System V or POSIX */
194	#ifndef TIMESTAMP
195	#define TIMESTAMP
196	#endif /* TIMESTAMP */
197	#include <time.h>
198
199	/* void tzset(); (the "void" type upsets some compilers) */
200	#ifndef IRIX60
201	#ifndef ultrix
202	#ifndef CONVEX9
203	/* ConvexOS 9.0, supposedly POSIX, has extern char timezone(int,int) /
204	#ifndef Plan9
205	extern long timezone;
206	#endif /* Plan9 */
207	#endif /* CONVEX9 */
208	#endif /* ultrix */
209	#endif /* IRIX60 */
210	#endif /* SVORPOSIX */
211	#endif /* BSD4 */
212	#endif /* BSD44 */
213
214	/* Is `y' a leap year? */
215	#define leap(y) (((y) % 4 == 0 && (y) % 100 != 0) \|\| (y) % 400 == 0)
216
217	/* Number of leap years from 1970 to `y' (not including `y' itself). */
218	#define nleap(y) (((y) - 1969) / 4 - ((y) - 1901) / 100 + ((y) - 1601) / 400)
219
220	#ifdef CIE
221	#include <stat.h> /* File status */
222	#else
223	#include <sys/stat.h>
224
225	#ifdef OS2
226	#include <sys/types.h>
227
228	/* Because standard stat has trouble with trailing /'s we have to wrap it */
229
230	#ifdef NT
231	int os2stat(char , struct _stat );
232	#else /* NT */
233	int os2stat(char , struct stat );
234	#endif /* NT */
235
236	#ifdef __IBMC__
237	#ifdef system
238	#undef system
239	#endif
240	#ifdef stat
241	#undef stat
242	#define __IBMC__STAT
243	#endif
244	#endif
245	#define stat(path, buf) os2stat(path, buf)
246	#endif /* OS2 */
247	#endif /* CIE */
248
249	/*
250	Functions (n is one of the predefined file numbers from ckcker.h):
251
252	zopeni(n,name) -- Opens an existing file for input.
253	zopeno(n,name,attr,fcb) -- Opens a new file for output.
254	zclose(n) -- Closes a file.
255	zchin(n,&c) -- Gets the next character from an input file.
256	zsinl(n,&s,x) -- Read a line from file n, max len x, into address s.
257	zsout(n,s) -- Write a null-terminated string to output file, buffered.
258	zsoutl(n,s) -- Like zsout, but appends a line terminator.
259	zsoutx(n,s,x) -- Write x characters to output file, unbuffered.
260	zchout(n,c) -- Add a character to an output file, unbuffered.
261	zchki(name) -- Check if named file exists and is readable, return size.
262	zchko(name) -- Check if named file can be created.
263	zchkspa(name,n) -- Check if n bytes available to create new file, name.
264	znewn(name,s) -- Make a new unique file name based on the given name.
265	zdelet(name) -- Delete the named file.
266	zxpand(string) -- Expands the given wildcard string into a list of files.
267	znext(string) -- Returns the next file from the list in "string".
268	zxcmd(n,cmd) -- Execute the command in a lower fork on file number n.
269	zclosf() -- Close input file associated with zxcmd()'s lower fork.
270	zrtol(n1,n2) -- Convert remote filename into local form.
271	zltor(n1,n2) -- Convert local filename into remote form.
272	zchdir(dirnam) -- Change working directory.
273	zhome() -- Return pointer to home directory name string.
274	zkself() -- Kill self, log out own job.
275	zsattr(struct zattr *) -- Return attributes for file which is being sent.
276	zstime(f, struct zattr *, x) - Set file creation date from attribute packet.
277	zrename(old, new) -- Rename a file.
278	zcopy(source,destination) -- Copy a file.
279	zmkdir(path) -- Create the directory path if possible
280	zfnqfp(fname,len,fullpath) - Determine full path for file name.
281	*/
282
283	/* Kermit-specific includes */
284	/*
285	Definitions here supersede those from system include files.
286	ckcdeb.h is included above.
287	*/
288	#include "ckcker.h" /* Kermit definitions */
289	#include "ckucmd.h" /* For sys-dependent keyword tables */
290	#include "ckuver.h" /* Version herald */
291
292	char *ckzsys = HERALD;
293
294	/*
295	File access checking ... There are two calls to access() in this module.
296	If this program is installed setuid or setgid on a Berkeley-based UNIX
297	system that does NOT incorporate the saved-original-effective-uid/gid
298	feature, then, when we have swapped the effective and original uid/gid,
299	access() fails because it uses what it thinks are the REAL ids, but we have
300	swapped them. This occurs on systems where ANYBSD is defined, NOSETREU
301	is NOT defined, and SAVEDUID is NOT defined. So, in theory, we should take
302	care of this situation like so:
303
304	ifdef ANYBSD
305	ifndef NOSETREU
306	ifndef SAVEDUID
307	define SW_ACC_ID
308	endif
309	endif
310	endif
311
312	But we can't test such a general scheme everywhere, so let's only do this
313	when we know we have to...
314	*/
315	#ifdef NEXT /* NeXTSTEP 1.0-3.0 */
316	#define SW_ACC_ID
317	#endif /* NEXT */
318
319	/* Support for tilde-expansion in file and directory names */
320
321	#ifdef POSIX
322	#define NAMEENV "LOGNAME"
323	#endif /* POSIX */
324
325	#ifdef BSD4
326	#define NAMEENV "USER"
327	#endif /* BSD4 */
328
329	#ifdef ATTSV
330	#define NAMEENV "LOGNAME"
331	#endif /* ATTSV */
332
333	/* Berkeley Unix Version 4.x */
334	/* 4.1bsd support from Charles E Brooks, EDN-VAX */
335
336	#ifdef BSD4
337	#ifdef MAXNAMLEN
338	#define BSD42
339	#endif /* MAXNAMLEN */
340	#endif /* BSD4 */
341
342	/* Definitions of some system commands */
343
344	#ifdef OS2
345	char CPYCMD = "copy "; / For file copy */
346	char DELCMD = "del "; / For file deletion */
347	char RENCMD = "rename "; / For file rename */
348	char PWDCMD = "chdir "; / For saying where I am */
349	char TYPCMD = "type "; / For typing a file */
350	char DIRCMD = "dir "; / For directory listing */
351	char DIRCM2 = "dir "; / For directory listing, no args */
352	#ifdef NT
353	char WHOCMD = "@echo Kermit 95 Server"; / Who's there? */
354	#else /* NT */
355	char WHOCMD = "@echo K/2 Server"; / Who's there? */
356	#endif /* NT */
357	char SPACMD = "dir \| find \"bytes free\""; / For space on disk */
358	char SPACM2 = "dir \| find \"bytes free\""; / For space on disk */
359
360	#else /* Not OS2, ergo UNIX (or Aegis) */
361
362	char DELCMD = "rm -f "; / For file deletion */
363	char CPYCMD = "cp "; / For file copy */
364	char RENCMD = "mv "; / For file rename */
365	char PWDCMD = "pwd "; / For saying where I am */
366
367	#ifdef COMMENT
368	#ifdef HPUX10
369	char DIRCMD = "/usr/bin/ls -l "; / For directory listing */
370	char DIRCM2 = "/usr/bin/ls -l "; / For directory listing, no args */
371	#else
372	char DIRCMD = "/bin/ls -l "; / For directory listing */
373	char DIRCM2 = "/bin/ls -l "; / For directory listing, no args */
374	#endif /* HPUX10 */
375	#else
376	char DIRCMD = "ls -l "; / For directory listing */
377	char DIRCM2 = "ls -l "; / For directory listing, no args */
378	#endif /* COMMENT */
379
380	char TYPCMD = "cat "; / For typing a file */
381
382	#ifdef FT18 /* Fortune For:Pro 1.8 */
383	#undef BSD4
384	#endif /* FT18 */
385
386	#ifdef BSD4
387	char SPACMD = "pwd ; df ."; / Space in current directory */
388	#else
389	#ifdef FT18
390	char *SPACMD = "pwd ; du ; df .";
391	#else
392	char *SPACMD = "df ";
393	#endif /* FT18 */
394	#endif /* BSD4 */
395
396	char SPACM2 = "df "; / For space in specified directory */
397
398	#ifdef FT18
399	#define BSD4
400	#endif /* FT18 */
401
402	#ifdef BSD4
403	char *WHOCMD = "finger ";
404	#else
405	char *WHOCMD = "who ";
406	#endif /* BSD4 */
407
408	#endif /* OS2 */
409
410	#ifdef DTILDE /* For tilde expansion */
411	_PROTOTYP( char * tilde_expand, (char *) );
412	#endif /* DTILDE */
413
414	/* More system-dependent includes, which depend on symbols defined */
415	/* in the Kermit-specific includes. Oh what a tangled web we weave... */
416
417	#ifdef COHERENT /* <sys/file.h> */
418	#define NOFILEH
419	#endif /* COHERENT */
420
421	#ifdef MINIX
422	#define NOFILEH
423	#endif /* MINIX */
424
425	#ifdef aegis
426	#define NOFILEH
427	#endif /* aegis */
428
429	#ifdef unos
430	#define NOFILEH
431	#endif /* unos */
432
433	#ifndef NOFILEH
434	#include <sys/file.h>
435	#endif /* NOFILEH */
436
437	#ifndef is68k /* Whether to include <fcntl.h> */
438	#ifndef BSD41 /* All but a couple UNIXes have it. */
439	#ifndef FT18
440	#ifndef COHERENT
441	#include <fcntl.h>
442	#endif /* COHERENT */
443	#endif /* FT18 */
444	#endif /* BSD41 */
445	#endif /* not is68k */
446
447	#ifdef COHERENT
448	#ifdef _I386
449	#include <fcntl.h>
450	#else
451	#include <sys/fcntl.h>
452	#endif /* _I386 */
453	#endif /* COHERENT */
454
455	/*
456	Change argument to "(const char *)" if this causes trouble.
457	Or... if it causes trouble, then maybe it was already declared
458	in a header file after all, so you can remove this prototype.
459	*/
460	#ifndef NDGPWNAM /* If not defined No Declare getpwnam... */
461	#ifndef _POSIX_SOURCE
462	#ifndef NEXT
463	#ifndef SVR4
464	/* POSIX <pwd.h> already gave prototypes for these. */
465	#ifdef IRIX40
466	_PROTOTYP( struct passwd * getpwnam, (const char *) );
467	#else
468	#ifdef IRIX51
469	_PROTOTYP( struct passwd * getpwnam, (const char *) );
470	#else
471	#ifdef M_UNIX
472	_PROTOTYP( struct passwd * getpwnam, (const char *) );
473	#else
474	#ifdef HPUX9
475	_PROTOTYP( struct passwd * getpwnam, (const char *) );
476	#else
477	#ifdef HPUX10
478	_PROTOTYP( struct passwd * getpwnam, (const char *) );
479	#else
480	#ifdef DCGPWNAM
481	_PROTOTYP( struct passwd * getpwnam, (const char *) );
482	#else
483	_PROTOTYP( struct passwd * getpwnam, (char *) );
484	#endif /* DCGPWNAM */
485	#endif /* HPUX10 */
486	#endif /* HPUX9 */
487	#endif /* M_UNIX */
488	#endif /* IRIX51 */
489	#endif /* IRIX40 */
490	#ifndef SUNOS4
491	#ifndef HPUX9
492	#ifndef HPUX10
493	#ifndef _SCO_DS
494	_PROTOTYP( struct passwd * getpwuid, (PWID_T) );
495	#endif /* _SCO_DS */
496	#endif /* HPUX10 */
497	#endif /* HPUX9 */
498	#endif /* SUNOS4 */
499	_PROTOTYP( struct passwd * getpwent, (void) );
500	#endif /* SVR4 */
501	#endif /* NEXT */
502	#endif /* _POSIX_SOURCE */
503	#endif /* NDGPWNAM */
504
505	/* Define macros for getting file type */
506
507	#ifdef OXOS
508	/*
509	Olivetti X/OS 2.3 has S_ISREG and S_ISDIR defined
510	incorrectly, so we force their redefinition.
511	*/
512	#undef S_ISREG
513	#undef S_ISDIR
514	#endif /* OXOS */
515
516	#ifdef UTSV /* Same deal for Amdahl UTSV */
517	#undef S_ISREG
518	#undef S_ISDIR
519	#endif /* UTSV */
520
521	#ifdef UNISYS52 /* And for UNISYS UTS V 5.2 */
522	#undef S_ISREG
523	#undef S_ISDIR
524	#endif /* UNISYS52 */
525
526	#ifdef ICLSVR3 /* And for old ICL versions */
527	#undef S_ISREG
528	#undef S_ISDIR
529	#endif /* ICLSVR3 */
530
531	#ifdef ISDIRBUG /* Also allow this from command line */
532	#ifdef S_ISREG
533	#undef S_ISREG
534	#endif /* S_ISREG */
535	#ifdef S_ISDIR
536	#undef S_ISDIR
537	#endif /* S_ISDIR */
538	#endif /* ISDIRBUG */
539
540	#ifndef S_ISREG
541	#define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
542	#endif /* S_ISREG */
543	#ifndef S_ISDIR
544	#define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
545	#endif /* S_ISDIR */
546
547	/* Define maximum length for a file name if not already defined */
548
549	#ifdef QNX
550	#ifdef _MAX_FNAME
551	#define MAXNAMLEN _MAX_FNAME
552	#else
553	#define MAXNAMLEN 48
554	#endif /* _MAX_FNAME */
555	#else
556	#ifndef MAXNAMLEN
557	#ifdef sun
558	#define MAXNAMLEN 255
559	#else
560	#ifdef FILENAME_MAX
561	#define MAXNAMLEN FILENAME_MAX
562	#else
563	#ifdef NAME_MAX
564	#define MAXNAMLEN NAME_MAX
565	#else
566	#ifdef _POSIX_NAME_MAX
567	#define MAXNAMLEN _POSIX_NAME_MAX
568	#else
569	#ifdef _D_NAME_MAX
570	#define MAXNAMLEN _D_NAME_MAX
571	#else
572	#ifdef DIRSIZ
573	#define MAXNAMLEN DIRSIZ
574	#else
575	#define MAXNAMLEN 14
576	#endif /* DIRSIZ */
577	#endif /* _D_NAME_MAX */
578	#endif /* _POSIX_NAME_MAX */
579	#endif /* NAME_MAX */
580	#endif /* FILENAME_MAX */
581	#endif /* sun */
582	#endif /* MAXNAMLEN */
583	#endif /* QNX */
584
585	/* Longest pathname ... */
586	/*
587	Beware: MAXPATHLEN is one of UNIX's dirty little secrets. Where is it
588	defined? Who knows... <param.h>, <mod.h>, <unistd.h>, <limits.h>, ...
589	There is not necessarily even a definition for it anywhere, or it might have
590	another name. If you get it wrong, bad things happen with getcwd() and/or
591	getwd(). If you allocate a buffer that is too short, getwd() might write
592	over memory and getcwd() will fail with ERANGE. The definitions of these
593	functions (e.g. in SVID or POSIX.1) do not tell you how to determine the
594	maximum path length in order to allocate a buffer that is the right size.
595	*/
596	#ifdef BSD44
597	#include <sys/param.h> /* For MAXPATHLEN */
598	#endif /* BSD44 */
599
600	#ifdef COHERENT
601	#include <sys/param.h> /* for MAXPATHLEN, needed for -DDIRENT */
602	#endif /* COHERENT */
603
604	#ifdef MAXPATHLEN
605	#ifdef MAXPATH
606	#undef MAXPATH
607	#endif /* MAXPATH */
608	#define MAXPATH MAXPATHLEN
609	#else
610	#ifdef PATH_MAX
611	#define MAXPATH PATH_MAX
612	#else
613	#ifdef _POSIX_PATH_MAX
614	#define MAXPATH _POSIX_PATH_MAX
615	#else
616	#ifdef BSD42
617	#define MAXPATH 1024
618	#else
619	#ifdef SVR4
620	#define MAXPATH 1024
621	#else
622	#define MAXPATH 255
623	#endif /* SVR4 */
624	#endif /* BSD42 */
625	#endif /* _POSIX_PATH_MAX */
626	#endif /* PATH_MAX */
627	#endif /* MAXPATHLEN */
628
629	/* Maximum number of filenames for wildcard expansion */
630
631	#ifdef PROVX1
632	#define MAXWLD 50
633	#else
634	#ifdef pdp11
635	#define MAXWLD 50
636	#else
637	#ifdef BIGBUFOK
638	#define MAXWLD 4096
639	#else
640	#define MAXWLD 1000
641	#endif /* BIGBUFOK */
642	#endif /* pdp11 */
643	#endif /* PROVX1 */
644
645	/* More internal function prototypes */
646	/*
647	* The path structure is used to represent the name to match.
648	* Each slash-separated segment of the name is kept in one
649	* such structure, and they are linked together, to make
650	* traversing the name easier.
651	*/
652	struct path {
653	char npart[MAXNAMLEN+4]; /* name part of path segment */
654	struct path fwd; / forward ptr */
655	};
656	#ifndef NOPUSH
657	_PROTOTYP( int shxpand, (char , char [], int ) );
658	extern int nopush;
659	#endif /* NOPUSH */
660	_PROTOTYP( static int fgen, (char , char [], int ) );
661	_PROTOTYP( static VOID traverse, (struct path , char , char *) );
662	_PROTOTYP( static VOID addresult, (char *) );
663	_PROTOTYP( static int match, (char , char ) );
664	_PROTOTYP( static char * whoami, (void) );
665	#ifdef aegis
666	_PROTOTYP( static char * xindex, (char *, char) );
667	#endif /* aegis */
668	_PROTOTYP( UID_T real_uid, (void) );
669	_PROTOTYP( struct path splitpath, (char p) );
670	_PROTOTYP( char * zdtstr, (time_t) );
671	_PROTOTYP( time_t zstrdt, (char *, int) );
672
673	/* Some systems define these symbols in include files, others don't... */
674
675	#ifndef R_OK
676	#define R_OK 4 /* For access */
677	#endif /* R_OK */
678
679	#ifndef W_OK
680	#define W_OK 2
681	#endif /* W_OK */
682
683	#ifndef O_RDONLY
684	#define O_RDONLY 000
685	#endif /* O_RDONLY */
686
687	/* Declarations */
688
689	int maxnam = MAXNAMLEN; /* Available to the outside */
690	int maxpath = MAXPATH;
691	int ck_znewn = -1;
692
693	FILE fp[ZNFILS] = { / File pointers */
694	NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL };
695	#ifdef OS2
696	int ispipe[ZNFILS]; /* Flag for file is a pipe */
697	#endif /* OS2 */
698
699	/* Buffers and pointers used in buffered file input and output. */
700	#ifdef DYNAMIC
701	extern char zinbuffer, zoutbuffer;
702	#else
703	extern char zinbuffer[], zoutbuffer[];
704	#endif /* DYNAMIC */
705	extern char zinptr, zoutptr;
706	extern int zincnt, zoutcnt;
707	extern int wildxpand;
708
709	extern UID_T real_uid();
710
711	static long iflen = -1L; /* Input file length */
712
713	static PID_T pid = 0; /* pid of child fork */
714	static int fcount; /* Number of files in wild group */
715	static char nambuf[MAXNAMLEN+4]; /* Buffer for a filename */
716	#ifndef NOFRILLS
717	static char zmbuf[200]; /* For mail, remote print strings */
718	#endif /* NOFRILLS */
719
720	#ifndef OS2
721	/* static / / Not static, must be global now. */
722	char *mtchs = NULL; / Matches found for filename */
723	char *mtchptr = NULL; / Pointer to current match */
724	#endif /* OS2 */
725
726	#ifdef OS2
727	#ifndef NT
728	#define INCL_KBD
729	#define INCL_DOSERRORS
730	#define INCL_DOSFILEMGR
731	#define INCL_DOSPROCESS
732	#define INCL_DOSSEMAPHORES
733	#include <os2.h>
734	typedef unsigned short WORD;
735	#undef COMMENT
736
737	/* Get/Set All Extended Attributes support */
738
739	#define FreeMem(p) DosFreeMem(p)
740
741	#define MAX_GEA 500L /* Max size for a GEA List */
742	#define MAXEACOUNT 128 /* Max number of EA's supported */
743	#define Ref_ASCIIZ 1 /* Reference type for DosEnumAttribute */
744
745	/* Definition of level specifiers, required for File Info */
746
747	#define GetInfoLevel1 1 /* Get info from SFT */
748	#define GetInfoLevel2 2 /* Get size of FEAlist */
749	#define GetInfoLevel3 3 /* Get FEAlist given the GEAlist */
750	#define GetInfoLevel4 4 /* Get whole FEAlist */
751	#define GetInfoLevel5 5 /* Get FSDname */
752
753	#define SetInfoLevel1 1 /* Set info in SFT */
754	#define SetInfoLevel2 2 /* Set FEAlist */
755
756	FEA2LIST pFEAList = 0; / Pointer to buffer containing all EA information */
757	ULONG os2attrs = FILE_NORMAL;
758	extern unsigned int lf_opts;
759
760	#else /* NT */
761
762	#include <windows.h>
763	#endif /* NT */
764	char os2filename[MAXPATH];
765	#endif /* OS2 */
766
767	/* Z K S E L F -- Kill Self: log out own job, if possible. */
768
769	/* Note, should get current pid, but if your system doesn't have */
770	/* getppid(), then just kill(0,9)... */
771
772	#ifndef SVR3
773	#ifndef POSIX
774	#ifndef OSFPC
775	/* Already declared in unistd.h for SVR3 and POSIX */
776	#ifdef CK_ANSIC
777	extern PID_T getppid(void);
778	#else
779	#ifndef PS2AIX10
780	extern PID_T getppid();
781	#endif /* PS2AIX10 */
782	#endif /* CK_ANSIC */
783	#endif /* OSFPC */
784	#endif /* POSIX */
785	#endif /* SVR3 */
786
787	int
788	zkself() { /* For "bye", but no guarantee! */
789	#ifdef PROVX1
790	return(kill(0,9));
791	#else
792	#ifdef V7
793	return(kill(0,9));
794	#else
795	#ifdef TOWER1
796	return(kill(0,9));
797	#else
798	#ifdef FT18
799	return(kill(0,9));
800	#else
801	#ifdef aegis
802	return(kill(0,9));
803	#else
804	#ifdef COHERENT
805	return(kill((PID_T)getpid(),1));
806	#else
807	#ifdef OS2
808	exit(3);
809	return(0);
810	#else
811	#ifdef PID_T
812	exit(kill((PID_T)getppid(),1));
813	return(0);
814	#else
815	exit(kill(getppid(),1));
816	return(0);
817	#endif
818	#endif
819	#endif
820	#endif
821	#endif
822	#endif
823	#endif
824	#endif
825	}
826
827	/* Z O P E N I -- Open an existing file for input. */
828
829	int
830	zopeni(n,name) int n; char *name; {
831	int x, y;
832
833	debug(F111," zopeni",name,n);
834	debug(F101," fp","", fp[n]);
835	if (chkfn(n) != 0) return(0);
836	zincnt = 0; /* Reset input buffer */
837	if (n == ZSYSFN) { /* Input from a system function? */
838	/* Note, this function should not be called with ZSYSFN */
839	/* Always call zxcmd() directly, and give it the real file number */
840	/* you want to use. */
841	debug(F110,"zopeni called with ZSYSFN, failing!",name,0);
842	nambuf = '\0'; / No filename. */
843	return(0); /* fail. */
844	#ifdef COMMENT
845	return(zxcmd(n,name)); /* Try to fork the command */
846	#endif
847	}
848	if (n == ZSTDIO) { /* Standard input? */
849	if (is_a_tty(0)) {
850	fprintf(stderr,"Terminal input not allowed");
851	debug(F110,"zopeni: attempts input from unredirected stdin","",0);
852	return(0);
853	}
854	fp[ZIFILE] = stdin;
855	#ifdef OS2
856	#ifdef NT
857	_setmode(_fileno(stdin),O_BINARY);
858	#else
859	setmode(fileno(stdin),O_BINARY);
860	#endif /* NT */
861	#endif /* OS2 */
862	return(1);
863	}
864	#ifdef OS2
865	if (n == ZIFILE \|\| n == ZRFILE) {
866	strncpy( os2filename, name, MAXPATH ) ;
867	errno = 0;
868	#ifdef NT
869	fp[n] = _fsopen(name,"rb",_SH_DENYWR); /* Binary mode */
870	#else
871	fp[n] = fopen(name,"rb");/* Binary mode */
872	#endif /* NT */
873	if (fp[ZIFILE]) {
874	x = ferror(fp[ZIFILE]);
875	#ifdef ZDEBUG
876	printf("ZOPENI errno=%d\n",errno);
877	printf("ZOPENI ferror=%d\n",x);
878	#endif /* ZDEBUG */
879	}
880	#ifdef CK_LABELED
881	if (binary == XYFT_L) {
882	os2getattr(name);
883	os2geteas(name);
884	}
885	#endif /* CK_LABELED */
886	} else
887	#ifdef NT
888	fp[n] = _fsopen(name,"rb",_SH_DENYWR); /* Real file, open it. */
889	#else
890	fp[n] = fopen(name,"rb");/* Real file, open it. */
891	#endif /* NT */
892	#else /* OS2 */
893	fp[n] = fopen(name,"r"); /* Real file, open it. */
894	#endif /* OS2 */
895	debug(F111," zopeni", name, fp[n]);
896	#ifdef ZDEBUG
897	printf("ZOPENI fp[%d]=%ld\n",n,fp[n]);
898	#endif /* ZDEBUG */
899	if (fp[n] == NULL)
900	perror("zopeni");
901	else
902	clearerr(fp[n]);
903	return((fp[n] != NULL) ? 1 : 0);
904	}
905
906	/* Z O P E N O -- Open a new file for output. */
907
908	int
909	zopeno(n,name,zz,fcb)
910	/* zopeno / int n; char name; struct zattr zz; struct filinfo fcb; {
911
912	char p[8]; /* (===OS2 change===) */
913
914	/* As of Version 5A, the attribute structure and the file information */
915	/* structure are included in the arglist. */
916
917	#ifdef DEBUG
918	debug(F111,"zopeno",name,n);
919	if (fcb) {
920	debug(F101,"zopeno fcb disp","",fcb->dsp);
921	debug(F101,"zopeno fcb type","",fcb->typ);
922	debug(F101,"zopeno fcb char","",fcb->cs);
923	} else {
924	debug(F100,"zopeno fcb is NULL","",0);
925	}
926	if (n != ZDFILE)
927	debug(F111," zopeno",name,n);
928	#endif /* DEBUG */
929
930	if (chkfn(n) != 0) /* Already open? */
931	return(0); /* Nothing to do. */
932
933	if ((n == ZCTERM) \|\| (n == ZSTDIO)) { /* Terminal or standard output */
934	fp[ZOFILE] = stdout;
935	#ifdef DEBUG
936	if (n != ZDFILE)
937	debug(F101," fp[]=stdout", "", fp[n]);
938	#endif /* DEBUG */
939	zoutcnt = 0;
940	zoutptr = zoutbuffer;
941	return(1);
942	}
943
944	/* A real file. Open it in desired mode (create or append). */
945
946	strcpy(p,"w"); /* Assume write/create mode */
947	if (fcb) { /* If called with an FCB... */
948	if (fcb->dsp == XYFZ_A) { /* Does it say Append? */
949	strcpy(p,"a"); /* Yes. */
950	debug(F100,"zopeno append","",0);
951	}
952	}
953	#ifdef OS2
954	if (n == ZOFILE \|\| n == ZSFILE) { /* OS/2 binary mode */
955	strncpy( os2filename, name, MAXPATH ) ;
956	strcat(p,"b");
957	}
958	#endif /* OS2 */
959	debug(F110,"zopeno fopen arg",p,0);
960	fp[n] = fopen(name,p); /* Try to open the file */
961
962	#ifdef ZDEBUG
963	printf("ZOPENO fp[%d]=%ld\n",n,fp[n]);
964	#endif /* ZDEBUG */
965
966	if (fp[n] == NULL) { /* Failed */
967	debug(F101,"zopeno failed errno","",errno);
968	#ifdef COMMENT /* Let upper levels print message. */
969	perror("Can't open output file");
970	#endif /* COMMENT */
971	} else { /* Succeeded */
972	if (n == ZDFILE) /* If it's the debug log */
973	setbuf(fp[n],NULL); /* make it unbuffered */
974	else
975	debug(F100, "zopeno ok", "", 0);
976	}
977	zoutcnt = 0; /* (PWP) reset output buffer */
978	zoutptr = zoutbuffer;
979	return((fp[n] != NULL) ? 1 : 0);
980	}
981
982	/* Z C L O S E -- Close the given file. */
983
984	/* Returns 0 if arg out of range, 1 if successful, -1 if close failed. */
985
986	int
987	zclose(n) int n; {
988	int x, x2;
989	if (chkfn(n) < 1) return(0); /* Check range of n */
990
991	if ((n == ZOFILE) && (zoutcnt > 0)) /* (PWP) output leftovers */
992	x2 = zoutdump();
993	else
994	x2 = 0;
995
996	x = 0; /* Initialize return code */
997	if (fp[ZSYSFN]
998	#ifdef OS2
999	\|\| ispipe[n] /* If file is really pipe */
1000	#endif /* OS2 */
1001	) {
1002	x = zclosf(n); /* do it specially */
1003	} else {
1004	if ((fp[n] != stdout) && (fp[n] != stdin))
1005	x = fclose(fp[n]);
1006	fp[n] = NULL;
1007	#ifdef OS2
1008	#ifdef CK_LABELED
1009	if (binary == XYFT_L) {
1010	debug(F111,"zclose LABELED","file number",n);
1011	if (n == ZOFILE) {
1012	debug(F111,"zclose LABELED",
1013	"lf_opts && LBL_EXT",
1014	lf_opts && LBL_EXT
1015	);
1016	if (lf_opts && LBL_EXT)
1017	os2seteas(os2filename);
1018	os2setattr(os2filename);
1019	} else if (n == ZIFILE && pFEAList) {
1020	FreeMem(pFEAList);
1021	pFEAList = 0;
1022	}
1023	}
1024	#endif /* CK_LABELED */
1025	#endif /* OS2 */
1026	}
1027	iflen = -1L; /* Invalidate file length */
1028	if (x == EOF) { /* if we got a close error */
1029	debug(F101,"zclose fclose fails","",x);
1030	return(-1);
1031	} else if (x2 < 0) { /* or error flushing last buffer */
1032	debug(F101,"zclose error flushing last buffer","",x2);
1033	return(-1); /* then return an error */
1034	} else {
1035	debug(F101,"zclose success","",1);
1036	return(1);
1037	}
1038	}
1039
1040	/* Z C H I N -- Get a character from the input file. */
1041
1042	/* Returns -1 if EOF, 0 otherwise with character returned in argument */
1043
1044	int
1045	zchin(n,c) int n; int *c; {
1046	int a, x;
1047
1048	/* (PWP) Just in case this gets called when it shouldn't. */
1049	if (n == ZIFILE) {
1050	x = zminchar();
1051	*c = x;
1052	return(x);
1053	}
1054	/* if (chkfn(n) < 1) return(-1); */
1055	a = getc(fp[n]);
1056	if (a == EOF) return(-1);
1057	#ifdef OS2
1058	if (!binary && a == 0x1A) /* Ctrl-Z marks EOF for text mode*/
1059	return(-1);
1060	#endif
1061	*c = (CHAR) a & 0377;
1062	return(0);
1063	}
1064
1065	/* Z S I N L -- Read a line from a file */
1066
1067	/*
1068	Writes the line into the address provided by the caller.
1069	n is the Kermit "channel number".
1070	Writing terminates when newline is encountered, newline is not copied.
1071	Writing also terminates upon EOF or if length x is exhausted.
1072	Returns 0 on success, -1 on EOF or error.
1073	*/
1074	int
1075	zsinl(n,s,x) int n, x; char *s; {
1076	int a, z = 0; /* z is return code. */
1077	extern CHAR feol; /* Line terminator */
1078
1079	if (chkfn(n) < 1) { /* Make sure file is open */
1080	return(-1);
1081	}
1082	a = -1; /* Current character, none yet. */
1083	while (x--) { /* Up to given length */
1084	int old;
1085	if (feol) old = a; /* Previous character */
1086
1087	if (zchin(n,&a) < 0) { /* Read a character from the file */
1088	debug(F101,"zsinl","",a);
1089	z = -1; /* EOF or other error */
1090	break;
1091	}
1092
1093	if (feol) { /* Single-character line terminator */
1094	if (a == feol)
1095	break;
1096	} else { /* CRLF line terminator */
1097	if (a == '\015') /* CR, get next character */
1098	continue;
1099	if (old == '\015') { /* Previous character was CR */
1100	if (a == '\012') /* This one is LF, so we have a line */
1101	break;
1102	else /* Not LF, deposit CR */
1103	*s++ = '\015';
1104	}
1105	#ifdef OS2
1106	if (a == '\012') break; /* Here break on single LF too */
1107	#endif /* OS2 */
1108	}
1109	s = a; / Deposit character */
1110	s++;
1111	}
1112	s = '\0'; / Terminate the string */
1113	return(z);
1114	}
1115
1116	/* Z X I N -- Read x bytes from a file */
1117
1118	/*
1119	Reads x bytes (or less) from channel n and writes them
1120	to the address provided by the caller.
1121	Returns number of bytes read on success, 0 on EOF or error.
1122	*/
1123	int
1124	zxin(n,s,x) int n, x; char *s; {
1125	return(fread(s, sizeof (char), x, fp[n]));
1126	}
1127
1128	/*
1129	Z I N F I L L -- Buffered file input.
1130
1131	(re)fill the file input buffer with data. All file input
1132	should go through this routine, usually by calling the zminchar()
1133	macro defined in ckcker.h. Returns:
1134
1135	Value 0..255 on success, the character that was read.
1136	-1 on end of file.
1137	-2 on any kind of error other than end of file.
1138	*/
1139	int
1140	zinfill() {
1141	int x;
1142
1143	errno = 0;
1144
1145	#ifdef ZDEBUG
1146	printf("ZINFILL fp[%d]=%ld\n",ZIFILE,fp[ZIFILE]);
1147	#endif /* ZDEBUG */
1148
1149	#ifdef OS2
1150	#ifdef CK_LABELED
1151	debug(F101,"zinfill: binary","",binary);
1152	debug(F101,"zinfill: pFEAList","",pFEAList);
1153	if ( binary == XYFT_L && pFEAList ) {
1154	zinptr = zinbuffer ;
1155	do_label_send(os2filename) ;
1156	if (feof(fp[ZIFILE]))
1157	return(-1);
1158	clearerr(fp[ZIFILE]);
1159	zincnt += fread(zinptr, sizeof (char), INBUFSIZE - zincnt, fp[ZIFILE]);
1160	} else {
1161	#endif /* CK_LABELED */
1162	#endif /* OS2 */
1163
1164	if (feof(fp[ZIFILE])) {
1165	debug(F100,"ZINFILL feof","",0);
1166	#ifdef ZDEBUG
1167	printf("ZINFILL EOF\n");
1168	#endif /* ZDEBUG */
1169	return(-1);
1170	}
1171	clearerr(fp[ZIFILE]);
1172	zincnt = fread(zinbuffer, sizeof (char), INBUFSIZE, fp[ZIFILE]);
1173	debug(F101,"ZINFILL fread","",zincnt);
1174	#ifdef ZDEBUG
1175	printf("FREAD=%d\n",zincnt);
1176	#endif /* ZDEBUG */
1177	#ifdef OS2
1178	#ifdef CK_LABELED
1179	}
1180	#endif /* CK_LABELED */
1181	#endif /* OS2 */
1182
1183	if (ferror(fp[ZIFILE])) {
1184	debug(F100,"ZINFILL ferror","",0);
1185	debug(F100,"ZINFILL errno","",errno);
1186	#ifdef ZDEBUG
1187	printf("ZINFILL errno=%d\n",errno);
1188	#endif /* ZDEBUG */
1189	return(-2);
1190	}
1191	/* In case feof() didn't work just above -- sometimes it doesn't... */
1192	if (zincnt == 0) {
1193	if (feof(fp[ZIFILE]) ) {
1194	debug(F100,"ZINFILL count 0 EOF return -1","",0);
1195	return (-1);
1196	} else {
1197	debug(F100,"ZINFILL count 0 not EOF return -2","",0);
1198	return(-2);
1199	}
1200	}
1201	zinptr = zinbuffer; /* set pointer to beginning, (== &zinbuffer[0]) */
1202	zincnt--; /* One less char in buffer */
1203	return((int)(zinptr++) & 0377); / because we return the first */
1204	}
1205
1206	/* Z S O U T -- Write a string out to the given file, buffered. */
1207
1208	int
1209	zsout(n,s) int n; char *s; {
1210	if (chkfn(n) < 1) return(-1); /* Keep this, prevents memory faults */
1211	if (!s) return(0); /* Null pointer, do nothing, succeed */
1212	if (!s) return(0); / empty string, ditto */
1213	#ifdef OS2
1214	if (n == ZCTERM)
1215	return(Vscrnprintf(s));
1216	#endif /* OS2 */
1217	if (n == ZSFILE)
1218	return(write(fileno(fp[n]),s,(int)strlen(s)));
1219	return(fputs(s,fp[n]) == EOF ? -1 : 0);
1220	}
1221
1222	/* Z S O U T L -- Write string to file, with line terminator, buffered */
1223
1224	int
1225	zsoutl(n,s) int n; char *s; {
1226	if (zsout(n,s) < 0)
1227	return(-1);
1228	#ifdef OS2
1229	if (n == ZCTERM)
1230	return(Vscrnprintf("\n"));
1231	#endif /* OS2 */
1232	if (n == ZSFILE) /* But session log is unbuffered */
1233	return(write(fileno(fp[n]),"\n",1));
1234	if (fputs("\n",fp[n]) == EOF)
1235	return(-1); /* (===OS2 ? \r\n) */
1236	return(0);
1237	}
1238
1239	/* Z S O U T X -- Write x characters to file, unbuffered. */
1240
1241	int
1242	zsoutx(n,s,x) int n, x; char *s; {
1243	#ifdef COMMENT
1244	if (chkfn(n) < 1) return(-1);
1245	return(write(fp[n]->_file,s,x));
1246	#endif /* COMMENT */
1247
1248	#ifdef OS2
1249	if (n == ZCTERM) {
1250	int i;
1251	for (i = 0; i < x; i++)
1252	if (!Vscrnprintf("%c",s[i]))
1253	return(-1);
1254	return(x);
1255	}
1256	#endif /* OS2 */
1257	return(write(fileno(fp[n]),s,x) == x ? x : -1);
1258	}
1259
1260	/* Z C H O U T -- Add a character to the given file. */
1261
1262	/* Should return 0 or greater on success, -1 on failure (e.g. disk full) */
1263
1264	int
1265	#ifdef CK_ANSIC
1266	zchout(register int n, char c)
1267	#else
1268	zchout(n,c) register int n; char c;
1269	#endif /* CK_ANSIC */
1270	/* zchout() */ {
1271	/* if (chkfn(n) < 1) return(-1); */
1272	#ifdef OS2
1273	if ( n==ZCTERM )
1274	return(Vscrnprintf("%c",c));
1275	#endif /* OS2 */
1276	if (n == ZSFILE) /* Use unbuffered for session log */
1277	return(write(fileno(fp[n]),&c,1) == 1 ? 0 : -1);
1278	/* Buffered for everything else */
1279	if (putc(c,fp[n]) == EOF) /* If true, maybe there was an error */
1280	return(ferror(fp[n])?-1:0); /* Check to make sure */
1281	else /* Otherwise... */
1282	return(0); /* There was no error. */
1283	}
1284
1285	/* (PWP) buffered character output routine to speed up file IO */
1286
1287	int
1288	zoutdump() {
1289	int x;
1290	zoutptr = zoutbuffer; /* Reset buffer pointer in all cases */
1291	debug(F101,"zoutdump chars","",zoutcnt);
1292	if (zoutcnt == 0) { /* Nothing to output */
1293	return(0);
1294	} else if (zoutcnt < 0) { /* Unexpected negative argument */
1295	zoutcnt = 0; /* Reset output buffer count */
1296	return(-1); /* and fail. */
1297	}
1298
1299	#ifdef CK_LABELED
1300	if (binary == XYFT_L ) {
1301	x = do_label_recv() ;
1302	if ( x > 0 ) { /* more room in the buffer */
1303	debug(F101,"zoutdump do_label_recv unfilled buffer","",zoutcnt);
1304	return 0 ;
1305	} else if ( x < 0 ) {
1306	debug(F101,"zoutdump do_label_recv error","",x);
1307	return -1 ;
1308	}
1309	}
1310	#endif /* CK_LABELED */
1311	/* Frank Prindle suggested that replacing this fwrite() by an fflush() */
1312	/* followed by a write() would improve the efficiency, especially when */
1313	/* writing to stdout. Subsequent tests showed a 5-fold improvement! */
1314	/* if (x = fwrite(zoutbuffer, 1, zoutcnt, fp[ZOFILE])) { */
1315
1316	fflush(fp[ZOFILE]);
1317	if ((x = write(fileno(fp[ZOFILE]),zoutbuffer,zoutcnt)) == zoutcnt) {
1318	debug(F101,"zoutdump write ok","",zoutcnt);
1319	zoutcnt = 0; /* Reset output buffer count */
1320	return(0); /* write() worked OK */
1321	} else {
1322	debug(F101,"zoutdump write error","",errno);
1323	debug(F101,"zoutdump write returns","",x);
1324	zoutcnt = 0; /* Reset output buffer count */
1325	return(-1); /* write() failed */
1326	}
1327	}
1328
1329	/* C H K F N -- Internal function to verify file number is ok */
1330
1331	/*
1332	Returns:
1333	-1: File number n is out of range
1334	0: n is in range, but file is not open
1335	1: n in range and file is open
1336	*/
1337	int
1338	chkfn(n) int n; {
1339	#ifdef COMMENT /* Save some stack space */
1340	switch (n) {
1341	case ZCTERM:
1342	case ZSTDIO:
1343	case ZIFILE:
1344	case ZOFILE:
1345	case ZDFILE:
1346	case ZTFILE:
1347	case ZPFILE:
1348	case ZSFILE:
1349	case ZSYSFN:
1350	case ZRFILE:
1351	case ZWFILE:
1352	#ifdef OS2
1353	case ZPRINT:
1354	#endif /* OS2 */
1355	break;
1356	default:
1357	debug(F101,"chkfn: file number out of range","",n);
1358	fprintf(stderr,"?File number out of range - %d\n",n);
1359	return(-1);
1360	}
1361	return( (fp[n] == NULL) ? 0 : 1 );
1362	#else
1363	if (n < 0 \|\| n >= ZNFILS)
1364	return(-1);
1365	else return( (fp[n] == NULL) ? 0 : 1 );
1366	#endif /* COMMENT */
1367	}
1368
1369	/* Z C H K I -- Check if input file exists and is readable */
1370
1371	/*
1372	Returns:
1373	>= 0 if the file can be read (returns the size).
1374	-1 if file doesn't exist or can't be accessed,
1375	-2 if file exists but is not readable (e.g. a directory file).
1376	-3 if file exists but protected against read access.
1377	*/
1378	/*
1379	For Berkeley Unix, a file must be of type "regular" to be readable.
1380	Directory files, special files, and symbolic links are not readable.
1381	*/
1382	long
1383	zchki(name) char *name; {
1384	#ifdef NT
1385	struct _stat buf;
1386	#else
1387	struct stat buf;
1388	#endif /* NT */
1389	int x;
1390
1391	#ifdef UNIX
1392	x = strlen(name);
1393	if (x == 9 && !strcmp(name,"/dev/null"))
1394	return(0);
1395	#endif /* UNIX */
1396
1397	x = stat(name,&buf);
1398	if (x < 0) {
1399	debug(F111,"zchki stat fails",name,errno);
1400	return(-1);
1401	}
1402	if (!S_ISREG (buf.st_mode) /* Must be regular file */
1403	#ifdef S_ISFIFO
1404	&& !S_ISFIFO (buf.st_mode) /* or FIFO */
1405	#endif /* S_ISFIFO */
1406	) {
1407	debug(F111,"zchki skipping:",name,x);
1408	return(-2);
1409	}
1410	debug(F111,"zchki stat ok:",name,x);
1411
1412	#ifdef SW_ACC_ID
1413	debug(F100,"zchki swapping ids for access()","",0);
1414	priv_on();
1415	#endif /* SW_ACC_ID */
1416	#ifdef NT
1417	x = _access(name,R_OK);
1418	#else
1419	x = access(name,R_OK);
1420	#endif /* NT */
1421	#ifdef SW_ACC_ID
1422	priv_off();
1423	debug(F100,"zchki swapped ids restored","",0);
1424	#endif /* SW_ACC_ID */
1425	if (x < 0) { /* Is the file accessible? */
1426	debug(F111," access failed:",name,x); /* No */
1427	return(-3);
1428	} else {
1429	iflen = buf.st_size; /* Yes, remember size */
1430	strncpy(nambuf,name,MAXNAMLEN); /* and name globally. */
1431	debug(F111," access ok:",name,(int) iflen);
1432	return( (iflen > -1L) ? iflen : 0L );
1433	}
1434	}
1435
1436	/* Z C H K O -- Check if output file can be created */
1437
1438	/*
1439	Returns -1 if write permission for the file would be denied, 0 otherwise.
1440	*/
1441	int
1442	zchko(name) char *name; {
1443	int i, x;
1444	char *s;
1445
1446	if (!name) return(-1); /* Watch out for null pointer. */
1447	x = (int)strlen(name); /* Get length of filename */
1448	debug(F101," length","",x);
1449
1450	#ifdef UNIX
1451	/*
1452	Writing to null device is OK.
1453	*/
1454	if (x == 9 && !strcmp(name,"/dev/null"))
1455	return(0);
1456	#endif /* UNIX */
1457
1458	if (isdir(name)) /* Directories are not writeable */
1459	return(-1);
1460
1461	s = malloc(x+3); /* Must copy because we can't */
1462	if (!s) { /* write into our argument. */
1463	fprintf(stderr,"Malloc error 46\n");
1464	return(-1);
1465	}
1466	strcpy(s,name);
1467
1468	for (i = x; i > 0; i--) /* Strip filename from right. */
1469	if (ISDIRSEP(s[i-1])) break;
1470	debug(F101," i","",i);
1471
1472	#ifdef COMMENT
1473	/* X/OPEN XPG3-compliant systems fail if argument ends with "/"... */
1474	if (i == 0) /* If no path, use current directory */
1475	strcpy(s,"./");
1476	else /* Otherwise, use given one. */
1477	s[i] = '\0';
1478	#else
1479	/* So now we use "path/." if path given, or "." if no path given. */
1480	s[i++] = '.'; /* Append "." to path. */
1481	s[i] = '\0';
1482	#endif /* COMMENT */
1483
1484	#ifdef SW_ACC_ID
1485	debug(F100,"zchko swapping ids for access()","",0);
1486	priv_on();
1487	#endif /* SW_ACC_ID */
1488	#ifdef OS2 /* No unwritable directories in OS/2 */
1489	x = 0;
1490	#else
1491	#ifdef NT
1492	x = _access(s,W_OK); /* Check access of path. */
1493	#else
1494	x = access(s,W_OK); /* Check access of path. */
1495	#endif /* NT */
1496	#endif /* OS2 */
1497	#ifdef SW_ACC_ID
1498	priv_off();
1499	debug(F100,"zchko swapped ids restored","",0);
1500	#endif /* SW_ACC_ID */
1501	if (x < 0)
1502	debug(F111,"zchko access failed:",s,errno);
1503	else
1504	debug(F111,"zchko access ok:",s,x);
1505	free(s); /* Free temporary storage */
1506	return((x < 0) ? -1 : 0); /* and return. */
1507	}
1508
1509	/* Z D E L E T -- Delete the named file. */
1510
1511	int
1512	zdelet(name) char *name; {
1513	#ifdef NT
1514	return(_unlink(name));
1515	#else /* NT */
1516	return(unlink(name));
1517	#endif /* NT */
1518	}
1519
1520	/* Z R T O L -- Convert remote filename into local form */
1521
1522	VOID
1523	zrtol(name,name2) char name, name2; {
1524	char *p; int flag = 0, n = 0;
1525	int acase = 0;
1526	if (!name \|\| !name2) return;
1527	debug(F101,"zrtol original name","",name);
1528	p = name2;
1529	for ( ; *name != '\0' && n < maxnam; name++) {
1530	if (name > ' ') flag = 1; / Strip leading blanks and controls */
1531	if (flag == 0 && *name < '!')
1532	continue;
1533	if (isupper(name)) / Check for mixed case */
1534	acase \|= 1;
1535	else if (islower(*name))
1536	acase \|= 2;
1537	p++ = name;
1538	n++;
1539	}
1540	p-- = '\0'; / Terminate */
1541	while (p < '!' && p > name2) / Strip trailing blanks & controls */
1542	*p-- = '\0';
1543
1544	if (name2 == '\0') { / Nothing left? */
1545	strcpy(name2,"NONAME"); /* do this... */
1546	} else if (acase == 1) { /* All uppercase? */
1547	p = name2; /* So convert all letters to lower */
1548	while (*p) {
1549	if (isupper(*p))
1550	p = tolower(p);
1551	p++;
1552	}
1553	}
1554	#ifdef OS2
1555	if (!IsFileNameValid(name2))
1556	ChangeNameForFAT(name2);
1557	#endif /* OS2 */
1558	debug(F110,"zrtol new name",name2,0);
1559	}
1560
1561
1562	/* Z S T R I P -- Strip device & directory name from file specification */
1563
1564	/* Strip pathname from filename "name", return pointer to result in name2 */
1565
1566	#ifdef pdp11
1567	#define ZSTRPLEN 64
1568	#else
1569	#define ZSTRPLEN MAXPATH
1570	#endif /* pdp11 */
1571	static char work[ZSTRPLEN+1];
1572
1573	VOID
1574	zstrip(name,name2) char name, *name2; {
1575	char cp, pp;
1576	int n = 0;
1577	debug(F110,"zstrip before",name,0);
1578	if (!name) { *name2 = ""; return; }
1579	pp = work;
1580	#ifdef DTILDE
1581	/* Strip leading tilde */
1582	if (*name == '~') name++;
1583	debug(F110,"zstrip after tilde-stripping",name,0);
1584	#else
1585	#ifdef OS2
1586	/* Strip disk letter and colon */
1587	if (isalpha(name) && ((name+1) == ':')) name += 2;
1588	debug(F110,"zstrip after disk-stripping",name,0);
1589	#endif /* OS2 */
1590	#endif /* DTILDE */
1591	for (cp = name; *cp; cp++) {
1592	if (ISDIRSEP(*cp)) {
1593	pp = work;
1594	n = 0;
1595	} else {
1596	pp++ = cp;
1597	if (n++ >= ZSTRPLEN)
1598	break;
1599	}
1600	}
1601	pp = '\0'; / Terminate the string */
1602	*name2 = work;
1603	debug(F110,"zstrip after",*name2,0);
1604	}
1605
1606	/* Z L T O R -- Local TO Remote */
1607
1608	VOID
1609	zltor(name,name2) char name, name2; {
1610	char cp, pp;
1611	int dc = 0;
1612	char *dotp = NULL;
1613	#ifdef aegis
1614	char *namechars;
1615	int tilde = 0, bslash = 0;
1616
1617	if ((namechars = getenv("NAMECHARS")) != NULL) {
1618	if (xindex(namechars, '~' ) != NULL) tilde = '~';
1619	if (xindex(namechars, '\\') != NULL) bslash = '\\';
1620	} else {
1621	tilde = '~';
1622	bslash = '\\';
1623	}
1624	#endif /* aegis */
1625
1626	debug(F110,"zltor",name,0);
1627	pp = work;
1628	#ifdef OS2
1629	if (isalpha(name) && ((name+1) == ':')) /* Strip disk name */
1630	name += 2;
1631	#endif /* OS2 */
1632	for (cp = name; cp; cp++) { / Strip path name */
1633	if (ISDIRSEP(*cp)) {
1634	dc = 0; /* Start over... */
1635	dotp = NULL;
1636	pp = work;
1637	} else if (islower(cp)) / Uppercase letters */
1638	pp++ = toupper(cp); /* Change tilde to 'X' */
1639	else if (*cp == '~')
1640	*pp++ = 'X';
1641	else if (cp == '#') / Change number sign to 'X' */
1642	*pp++ = 'X';
1643	else if (cp == '.') { / Change dot to underscore */
1644	dotp = pp; /* Remember where we last did this */
1645	*pp++ = '_';
1646	} else
1647	pp++ = cp;
1648	}
1649	pp = NUL; / Tie it off. */
1650	if (dotp) dotp = '.'; / Restore last dot (if any) */
1651	cp = name2; /* If nothing before dot, */
1652	if (work == '.') cp++ = 'X'; /* insert 'X' */
1653	strcpy(cp,work);
1654	debug(F110," name2",name2,0);
1655	}
1656
1657
1658	/* Z C H D I R -- Change directory */
1659	/*
1660	Call with:
1661	dirnam = pointer to name of directory to change to,
1662	which may be "" or NULL to indicate user's home directory.
1663	Returns:
1664	0 on failure
1665	1 on success
1666	*/
1667	int
1668	zchdir(dirnam) char *dirnam; {
1669	char hd, sp, *p;
1670
1671	debug(F110,"zchdir",dirnam,0);
1672	if (dirnam == NULL \|\| dirnam == "" \|\| dirnam == '\0') / If arg is null */
1673	dirnam = zhome(); /* use user's home directory. */
1674	sp = dirnam;
1675	debug(F110,"zchdir 2",dirnam,0);
1676
1677	#ifdef DTILDE
1678	hd = tilde_expand(dirnam); /* Attempt to expand tilde */
1679	if (hd == '\0') hd = dirnam; / in directory name. */
1680	#else
1681	hd = dirnam;
1682	#endif /* DTILDE */
1683	debug(F110,"zchdir 3",hd,0);
1684	#ifdef pdp11
1685	/* Just to save some space */
1686	return((
1687	#ifdef NT
1688	_chdir(hd)
1689	#else
1690	chdir(hd)
1691	#endif /* NT */
1692	== 0) ? 1 : 0);
1693	#else
1694	#ifdef OS2
1695	if (isalpha(hd[0]) && hd[1] == ':') {
1696	if (zchdsk(hd[0]))
1697	return(0);
1698	if (hd[2] == 0)
1699	return(1); /* Handle drive-only case */
1700	}
1701	{
1702	/* strip trailing DIRSEP except after d:; chdir() doesn't like it */
1703	int len = strlen(hd) ;
1704	if ( len > 1 && ISDIRSEP(hd[len - 1]) && hd[len - 2] != ':' )
1705	hd[len - 1] = 0;
1706	}
1707	#endif /* OS2 */
1708	if (
1709	#ifdef NT
1710	_chdir(hd)
1711	#else
1712	chdir(hd)
1713	#endif /* NT */
1714	== 0) return(1); /* Try to cd */
1715	else return(0);
1716
1717	#ifdef COMMENT
1718	/* This doesn't help in Windows or OS/2, and it's wrong in UNIX */
1719	p = sp; /* Failed, lowercase it. */
1720	while (*p) {
1721	if (isupper(p)) p = tolower(*p);
1722	p++;
1723	}
1724	debug(F110,"zchdir 4",hd,0);
1725	#ifdef DTILDE
1726	hd = tilde_expand(sp); /* Try again to expand tilde */
1727	if (*hd == '\0') hd = sp;
1728	#else
1729	hd = sp; /* Point to result */
1730	#endif /* DTILDE */
1731	debug(F110,"zchdir 5",hd,0);
1732	return((
1733	#ifdef NT
1734	_chdir(hd)
1735	#else
1736	chdir(hd)
1737	#endif /* NT */
1738	== 0) ? 1 : 0);
1739	#endif /* COMMENT */
1740
1741	#endif /* pdp11 */
1742	}
1743
1744	/* Z H O M E -- Return pointer to user's home directory */
1745
1746	char *
1747	zhome() {
1748	#ifdef Plan9
1749	char *home = getenv("home");
1750	#else
1751	char *home = getenv("HOME");
1752	#endif /* Plan9 */
1753	#ifdef OS2
1754	extern char startupdir[];
1755	return(home ? home : startupdir);
1756	#else
1757	return(home ? home : ".");
1758	#endif /* OS2 */
1759	}
1760
1761	/* Z G T D I R -- Return pointer to user's current directory */
1762
1763	#ifdef pdp11
1764	#define CWDBL 80 /* Save every byte we can... */
1765	#else
1766	#define CWDBL MAXPATH
1767	#endif /* pdp11 */
1768	static char cwdbuf[CWDBL+1];
1769
1770	char *
1771	zgtdir() {
1772	char *buf;
1773
1774	#ifdef BSD44
1775	extern char *getcwd();
1776	buf = cwdbuf;
1777	debug(F101,"zgtdir CWDBL","",CWDBL);
1778	return(getcwd(buf,CWDBL));
1779	#else
1780	#ifdef SVORPOSIX
1781	extern char *getcwd();
1782	buf = cwdbuf;
1783	debug(F101,"zgtdir CWDBL","",CWDBL);
1784	return(getcwd(buf,CWDBL));
1785	#else
1786	#ifdef COHERENT
1787	#ifdef _I386
1788	extern char *getcwd();
1789	buf = cwdbuf;
1790	debug(F101,"zgtdir CWDBL","",CWDBL);
1791	return(getcwd(buf,CWDBL));
1792	#else
1793	extern char *getwd();
1794	buf = cwdbuf;
1795	debug(F101,"zgtdir CWDBL","",CWDBL);
1796	return(getwd(buf));
1797	#endif /* _I386 */
1798	#else
1799	#ifdef OS2
1800	#ifndef __IBMC__ /* which has a macro for this */
1801	extern char *getcwd();
1802	#endif /* __IBMC__ */
1803	buf = cwdbuf;
1804	debug(F101,"zgtdir CWDBL","",CWDBL);
1805	#ifdef NT
1806	_getcwd(buf,CWDBL);
1807	#else
1808	getcwd(buf,CWDBL);
1809	#endif /* NT */
1810	return(buf);
1811	#else /* OS2 */
1812	#ifdef BSD4
1813	extern char *getwd();
1814	buf = cwdbuf;
1815	debug(F100,"zgtdir getwd()","",0);
1816	return(getwd(buf));
1817	#else
1818	return("directory unknown");
1819	#endif /* BSD4 */
1820	#endif /* OS2 */
1821	#endif /* COHERENT */
1822	#endif /* SYSVORPOSIX */
1823	#endif /* BSD44 */
1824	}
1825
1826	/* Z X C M D -- Run a system command so its output can be read like a file */
1827
1828	#ifdef NT
1829	_PROTOTYP( FILE * win95popen, (char cmd, char mode) );
1830	_PROTOTYP( int win95pclose, (FILE *pipe) );
1831	#endif /* NT */
1832
1833	int
1834	zxcmd(filnum,comand) int filnum; char *comand; {
1835	#ifdef OS2
1836	if (chkfn(filnum) < 0) return(-1); /* Need a valid Kermit file number. */
1837	if (filnum == ZSTDIO \|\| filnum == ZCTERM) /* But not one of these. */
1838	return(0);
1839	if (filnum == ZIFILE \|\| filnum == ZRFILE) { /* Input from a command */
1840	if (priv_chk() \|\|
1841	#ifdef NT
1842	isWin95() ?
1843	((fp[filnum] = win95popen(comand,"rb")) == NULL) :
1844	#endif /* NT */
1845	((fp[filnum] = popen(comand,"rb")) == NULL)
1846	)
1847	return(0);
1848	} else { /* Output to a command */
1849	if (priv_chk() \|\|
1850	#ifdef NT
1851	isWin95() ?
1852	((fp[filnum] = win95popen(comand,"w")) == NULL) :
1853	#endif /* NT */
1854	((fp[filnum] = popen(comand,"w")) == NULL)
1855	)
1856	return(0);
1857	}
1858	fp[ZSYSFN] = fp[filnum]; /* remember the pipe handle */
1859	ispipe[filnum] = 1;
1860	return(1);
1861	#else /* Not OS2 */
1862	int pipes[2];
1863	int out;
1864
1865	if (chkfn(filnum) < 0) return(-1); /* Need a valid Kermit file number. */
1866	if (filnum == ZSTDIO \|\| filnum == ZCTERM) /* But not one of these. */
1867	return(0);
1868
1869	out = (filnum == ZIFILE \|\| filnum == ZRFILE) ? 0 : 1 ;
1870
1871	/* Output to a command */
1872
1873	if (out) { /* Need popen() to do this. */
1874	#ifdef NOPOPEN
1875	return(0); /* no popen(), fail. */
1876	#else
1877	/* Use popen() to run the command. */
1878
1879	#ifdef _POSIX_SOURCE
1880	/* Strictly speaking, popen() is not available in POSIX.1 */
1881	#define DCLPOPEN
1882	#endif /* _POSIX_SOURCE */
1883
1884	#ifdef COHERENT
1885	#define DCLPOPEN
1886	FILE * fdopen();
1887	#endif /* COHERENT */
1888
1889	#ifdef DCLPOPEN
1890	/* popen() needs declaring because it's not declared in <stdio.h> */
1891	FILE *popen();
1892	#endif /* DCLPOPEN */
1893
1894	if (priv_chk() \|\| ((fp[filnum] = popen(comand,"w")) == NULL))
1895	return(0);
1896	else return(1);
1897	#endif /* NOPOPEN */
1898	}
1899
1900	/* Input from a command */
1901
1902	if (pipe(pipes) != 0) {
1903	debug(F100,"zxcmd pipe failure","",0);
1904	return(0); /* can't make pipe, fail */
1905	}
1906
1907	/* Create a fork in which to run the named process */
1908
1909	if ((
1910	#ifdef aegis
1911	pid = vfork() /* child */
1912	#else
1913	pid = fork() /* child */
1914	#endif /* aegis */
1915	) == 0) {
1916
1917	/* We're in the fork. */
1918
1919	char shpath, shname, shptr; / Find user's preferred shell */
1920	#ifndef aegis
1921	struct passwd *p;
1922	char *defshell;
1923	#ifdef HPUX10 /* Default shell */
1924	defshell = "/usr/bin/sh";
1925	#else
1926	#ifdef Plan9
1927	defshell = "/bin/rc";
1928	#else
1929	defshell = "/bin/sh";
1930	#endif /* Plan9 */
1931	#endif /* HPUX10 */
1932	#endif /* aegis */
1933	if (priv_can()) exit(1); /* Turn off any privileges! */
1934	debug(F101,"zxcmd pid","",pid);
1935	close(pipes[0]); /* close input side of pipe */
1936	close(0); /* close stdin */
1937	if (open("/dev/null",0) < 0) return(0); /* replace input by null */
1938	#ifndef OXOS
1939	#ifndef SVORPOSIX
1940	dup2(pipes[1],1); /* BSD: replace stdout & stderr */
1941	dup2(pipes[1],2); /* by the pipe */
1942	#else
1943	close(1); /* AT&T: close stdout */
1944	if ( dup(pipes[1]) != 1 ) /* Send stdout to the pipe */
1945	return(0);
1946	close(2); /* Send stderr to the pipe */
1947	if ( dup(pipes[1]) != 2 )
1948	return(0);
1949	#endif /* SVORPOSIX */
1950	#else /* OXOS */
1951	dup2(pipes[1],1);
1952	dup2(pipes[1],2);
1953	#endif /* OXOS */
1954	close(pipes[1]); /* Don't need this any more. */
1955
1956	#ifdef aegis
1957	if ((shpath = getenv("SERVERSHELL")) == NULL)
1958	shpath = "/bin/sh";
1959	#else
1960	shpath = getenv("SHELL"); /* What shell? */
1961	if (shpath == NULL) {
1962	p = getpwuid( real_uid() ); /* Get login data */
1963	if (p == (struct passwd )NULL \|\| !(p->pw_shell))
1964	shpath = defshell;
1965	else shpath = p->pw_shell;
1966	}
1967	#endif /* aegis */
1968	shptr = shname = shpath;
1969	while (*shptr != '\0')
1970	if (*shptr++ == '/')
1971	shname = shptr;
1972	debug(F100,"zxcmd...","",0);
1973	debug(F110,shpath,shname,0);
1974
1975	execl(shpath,shname,"-c",comand,(char )NULL); / Execute the cmd */
1976	exit(0); /* just punt if it failed. */
1977	} else if (pid == (PID_T) -1) {
1978	debug(F100,"zxcmd fork failure","",0);
1979	return(0);
1980	}
1981	debug(F101,"zxcmd pid","",pid);
1982	if (out) {
1983	close(pipes[0]); /* Don't need the input side */
1984	fp[filnum] = fdopen(pipes[1],"w"); /* Open a stream for output. */
1985	fp[ZSYSFN] = fp[filnum]; /* Remember. */
1986	zoutcnt = 0; /* (PWP) reset input buffer */
1987	zoutptr = zoutbuffer;
1988	} else {
1989	close(pipes[1]); /* Don't need the output side */
1990	fp[filnum] = fdopen(pipes[0],"r"); /* Open a stream for input. */
1991	fp[ZSYSFN] = fp[filnum]; /* Remember. */
1992	zincnt = 0; /* (PWP) reset input buffer */
1993	zinptr = zinbuffer;
1994	}
1995	return(1);
1996	#endif /* OS2 */
1997	} /* zxcmd */
1998
1999	/* Z C L O S F - wait for the child fork to terminate and close the pipe. */
2000
2001	int
2002	zclosf(filnum) int filnum; {
2003	int wstat;
2004	debug(F101,"zclosf filnum","",filnum);
2005	#ifndef NOPOPEN
2006	#ifdef OS2
2007	if (ispipe[filnum]) {
2008	int x;
2009	#ifdef NT
2010	x = isWin95() ? win95pclose(fp[filnum]) : pclose(fp[filnum]) ;
2011	#else /* NT */
2012	x = pclose(fp[filnum]);
2013	#endif /* NT */
2014	fp[filnum] = NULL;
2015	ispipe[filnum] = 0;
2016	#else
2017	if (filnum == ZWFILE) {
2018	int x;
2019	x = pclose(fp[filnum]);
2020	fp[filnum] = fp[ZSYSFN] = NULL;
2021	#endif /* OS2 */
2022	return((x < 0) ? 0 : 1);
2023	}
2024	#endif /* NOPOPEN */
2025	debug(F101,"zclosf fp[filnum]","", fp[filnum]);
2026	debug(F101,"zclosf fp[ZSYSFN]","", fp[ZSYSFN]);
2027	#ifdef OS2
2028	fclose(fp[filnum]);
2029	fp[filnum] = NULL;
2030	#else
2031	if (pid != (PID_T) 0) {
2032	debug(F101,"zclosf killing pid","",pid);
2033	#ifdef Plan9
2034	kill(pid, SIGKILL);
2035	#else
2036	kill(pid,9);
2037	#endif /* Plan9 */
2038	while ((wstat = wait((WAIT_T *)0)) != pid && wstat != -1) ;
2039	pid = 0;
2040	}
2041	fclose(fp[filnum]);
2042	fp[filnum] = fp[ZSYSFN] = NULL;
2043	#endif /* OS2 */
2044	return(1);
2045	}
2046
2047	/* Z X P A N D -- Expand a wildcard string into an array of strings */
2048	/*
2049	Returns the number of files that match fn1, with data structures set up
2050	so that first file (if any) will be returned by the next znext() call.
2051	Depends on external variable wildxpand: 0 means we expand wildcards
2052	internally, nonzero means we call the shell to do it.
2053	*/
2054
2055	#ifdef OS2
2056	/* Z X P A N D -- Expand a wildcard string into an array of strings */
2057	/*
2058	Returns the number of files that match fn1, with data structures set up
2059	so that first file (if any) will be returned by the next znext() call.
2060	Depends on external variable wildxpand: 0 means we expand wildcards
2061	internally, nonzero means we call the shell to do it.
2062	*/
2063
2064	char findpath[MAXPATH];
2065	#ifdef NT
2066	WIN32_FIND_DATA finddata;
2067	HANDLE findhandle = INVALID_HANDLE_VALUE;
2068	#else /* NT */
2069	FILEFINDBUF3 finddata;
2070	HDIR findhandle = HDIR_CREATE;
2071	ULONG findcount;
2072	#endif /* NT */
2073
2074	int
2075	zxpand(fn) char *fn; {
2076	int i, lasterror = 0;
2077	char localfn[MAXPATH];
2078
2079	if ( !fn \|\| !(*fn) )
2080	return(0);
2081
2082	debug(F110,"zxpand fn",fn,0);
2083	#ifdef NT
2084	if (findhandle != INVALID_HANDLE_VALUE) {
2085	FindClose(findhandle);
2086	findhandle = INVALID_HANDLE_VALUE;
2087	}
2088	#else
2089	if (findhandle != HDIR_CREATE) {
2090	DosFindClose(findhandle);
2091	findhandle = HDIR_CREATE;
2092	}
2093	#endif /* NT */
2094
2095	fcount = 0;
2096	strcpy(findpath, fn);
2097	strcpy(localfn, fn);
2098	for (i = strlen(findpath); i >= 0; i--) {
2099	if (ISDIRSEP(findpath[i])
2100	\|\| findpath[i] == ':'
2101	) {
2102	if (!findpath[i+1])
2103	strcat(localfn, "*");
2104	else
2105	findpath[i+1] = '\0';
2106	break;
2107	}
2108	if (findpath[i] == ':') {
2109	if (!findpath[i+1]) {
2110	strcat(localfn, "*");
2111	break;
2112	}
2113	}
2114	}
2115	if (i < 0)
2116	if (zchki(localfn) == -2) {
2117	if ( strlen(localfn) == 2 && localfn[1] == ':' ) {
2118	strcat(localfn, "./*");
2119	} else {
2120	strcat(findpath, "/");
2121	strcat(localfn, "/*");
2122	}
2123	} else if (!ISDIRSEP(localfn[0]) && localfn[1] != ':') {
2124	findpath[0] = '\0';
2125	strcpy(nambuf, "./");
2126	strcat(nambuf, localfn);
2127	strcpy(localfn, nambuf);
2128	}
2129
2130	debug(F100,"zxpand about to FindFirst","",0);
2131	#ifdef NT
2132	findhandle = FindFirstFile( localfn, &finddata );
2133	if ( findhandle == INVALID_HANDLE_VALUE )
2134	#else /* NT */
2135	findcount = 1;
2136	DosFindFirst(localfn,
2137	&findhandle,
2138	(ULONG) FILE_NORMAL \| FILE_ARCHIVED \| FILE_DIRECTORY \|
2139	FILE_HIDDEN \| FILE_SYSTEM \| FILE_READONLY,
2140	(PVOID) &finddata, (ULONG) sizeof(finddata),
2141	&findcount,
2142	FIL_STANDARD
2143	);
2144	if (findcount != 1)
2145	#endif /* NT */
2146	return(fcount);
2147
2148	fcount = 1;
2149	while (
2150	#ifdef NT
2151	FindNextFile( findhandle, &finddata )
2152	#else /* NT */
2153	!(lasterror = DosFindNext(findhandle,
2154	(PVOID) &finddata,
2155	(ULONG) sizeof(finddata),
2156	&findcount)) &&
2157	findcount == 1
2158	#endif /* NT */
2159	)
2160	fcount++;
2161
2162	#ifdef NT
2163	lasterror = GetLastError();
2164	FindClose( findhandle );
2165	findhandle = INVALID_HANDLE_VALUE;
2166	#else
2167	DosFindClose( findhandle );
2168	findhandle = HDIR_CREATE;
2169	#endif /* NT */
2170
2171	if (lasterror != ERROR_NO_MORE_FILES) {
2172	fcount = 0;
2173	return (fcount);
2174	}
2175
2176	debug(F111,"zxpand","fcount",fcount);
2177
2178	#ifdef NT
2179	findhandle = FindFirstFile( localfn, &finddata );
2180	#else /* NT */
2181	findcount = 1;
2182	DosFindFirst(localfn,
2183	&findhandle,
2184	(ULONG) FILE_NORMAL \| FILE_ARCHIVED \| FILE_DIRECTORY \|
2185	FILE_HIDDEN \| FILE_SYSTEM \| FILE_READONLY,
2186	(PVOID) &finddata,
2187	(ULONG) sizeof(finddata),
2188	&findcount,
2189	FIL_STANDARD
2190	);
2191	#endif /* NT */
2192	return(fcount);
2193	}
2194
2195	/* Z N E X T -- Get name of next file from list created by zxpand(). */
2196	/*
2197	Returns > 0 if there's another file, with its name copied into the argument
2198	string, or 0 if no more files in list.
2199	*/
2200	int
2201	znext(fn) char *fn; {
2202	int lasterror = 0;
2203
2204	if (fcount-- > 0
2205	#ifdef NT
2206	&& findhandle != INVALID_HANDLE_VALUE
2207	#else
2208	&& findhandle != HDIR_CREATE
2209	#endif /* NT */
2210	) {
2211	strcpy(fn,findpath);
2212	#ifdef NT
2213	strcat(fn,finddata.cFileName);
2214	if (!FindNextFile( findhandle, &finddata)) {
2215	FindClose( findhandle );
2216	findhandle = INVALID_HANDLE_VALUE;
2217	fcount = 0;
2218	}
2219	#else /* NT */
2220	strcat(fn,finddata.achName );
2221	findcount = 1;
2222	lasterror = DosFindNext(findhandle,
2223	(PVOID) &finddata,
2224	(ULONG) sizeof(finddata),
2225	&findcount
2226	);
2227	if (lasterror \|\| findcount != 1) {
2228	DosFindClose(findhandle);
2229	findhandle = HDIR_CREATE;
2230	fcount = 0;
2231	}
2232	#endif /* NT */
2233	} else {
2234	*fn = '\0';
2235	fcount = -1;
2236	}
2237	debug(F111,"znext",fn,fcount+1);
2238	return(fcount+1);
2239	}
2240
2241	#else /* Not OS2 */
2242
2243	int
2244	zxpand(fn) char *fn; {
2245	char *p;
2246	#ifdef DTILDE /* Built with tilde-expansion? */
2247	char *tnam;
2248	#endif /* DTILDE */
2249	debug(F111,"zxpand entry",fn,wildxpand);
2250	if ( !fn \|\| !(fn) ) / If no argument provided */
2251	return(0); /* Return zero files found */
2252
2253	#ifdef DTILDE /* Built with tilde-expansion? */
2254	if (fn == '~') { / Starts with tilde? */
2255	tnam = tilde_expand(fn); /* Try to expand it. */
2256	if (tnam) fn = tnam;
2257	}
2258	debug(F110,"zxpand after tilde_x",fn,0);
2259	#endif /* DTILDE */
2260	#ifndef NOPUSH
2261	if (!nopush && wildxpand) /* Who is expanding wildcards? */
2262	fcount = shxpand(fn,mtchs,MAXWLD); /* Shell */
2263	else
2264	#endif /* NOPUSH */
2265	fcount = (mtchs == NULL && /* Kermit */
2266	(mtchs = (char *)malloc(MAXWLD sizeof(*mtchs))) == NULL)
2267	? 0
2268	: fgen(fn,mtchs,MAXWLD); /* Look up the file. */
2269
2270	if (fcount > 0) {
2271	mtchptr = mtchs; /* Save pointer for next. */
2272	debug(F111,"zxpand ok",mtchs[0],fcount);
2273	return(fcount);
2274	}
2275	debug(F111,"zxpand fgen1",fn,fcount); /* Didn't get one, or got too many */
2276	p = malloc((int)strlen(fn) + 10); /* Make space */
2277	if (!p) return(0);
2278	zrtol(fn,p); /* Try again, maybe lowercase */
2279
2280	#ifndef NOPUSH
2281	if (!nopush && wildxpand)
2282	fcount = shxpand(p,mtchs,MAXWLD); /* Shell */
2283	else
2284	#endif /* NOPUSH */
2285	fcount = fgen(p,mtchs,MAXWLD); /* Kermit */
2286	if (fcount > 0) { /* Got at least one? */
2287	mtchptr = mtchs; /* Save pointer for next. */
2288	debug(F111,"zxpand fgen2 ok",mtchs[0],fcount);
2289	} else debug(F111,"zxpand 2 not ok",p,fcount);
2290	free(p);
2291	return(fcount);
2292	}
2293
2294
2295	/* Z N E X T -- Get name of next file from list created by zxpand(). */
2296	/*
2297	Returns >0 if there's another file, with its name copied into the arg string,
2298	or 0 if no more files in list.
2299	*/
2300	int
2301	znext(fn) char *fn; {
2302	if (fcount-- > 0) strcpy(fn,*mtchptr++);
2303	else *fn = '\0';
2304	debug(F111,"znext",fn,fcount+1);
2305	return(fcount+1);
2306	}
2307	#endif /* OS2 */
2308
2309	/* Z C H K S P A -- Check if there is enough space to store the file */
2310
2311	/*
2312	Call with file specification f, size n in bytes.
2313	Returns -1 on error, 0 if not enough space, 1 if enough space.
2314	*/
2315	int
2316	#ifdef CK_ANSIC
2317	zchkspa(char *f, long n)
2318	#else
2319	zchkspa(f,n) char *f; long n;
2320	#endif /* CK_ANSIC */
2321	/* zchkspa() */ {
2322	#ifdef OS2
2323	/* OS/2 gives us an easy way to do this. */
2324	unsigned long x, filesize = 0L;
2325	debug(F111,"zchkspa",f,n);
2326	if (isalpha(f[0]) && f[1] == ':') {
2327	x = zdskspace(toupper(f[0]) - 'A' + 1);
2328	debug(F101,"zchkspa disk: size","",x);
2329	} else {
2330	x = zdskspace(0);
2331	debug(F101,"zchkspa no disk size","",x);
2332	}
2333	if (fncact == XYFX_U \|\| fncact == XYFX_X) /* Update or Replace */
2334	filesize = zchki(f);
2335
2336	return((x+filesize >= n) ? 1 : 0);
2337	#else
2338	/* In UNIX there is no good (and portable) way. */
2339	return(1); /* Always say OK. */
2340	#endif /* OS2 */
2341	}
2342
2343
2344	/* Z N E W N -- Make a new name for the given file */
2345
2346	/*
2347	Given the name, fn, of a file that already exists, this function builds a
2348	new name of the form "<oldname>.~<n>~", where <oldname> is argument name
2349	(fn), and <n> is a version number, one higher than any existing version
2350	number for that file, up to 9999. This format is consistent with that used
2351	by GNU EMACS. If the constructed name is too long for the system's maximum,
2352	enough characters are truncated from the end of <fn> to allow the version
2353	number to fit. If no free version numbers exist between 1 and 9999, a
2354	version number of "xxxx" is used. Returns a pointer to the new name in
2355	argument s.
2356	*/
2357
2358	VOID
2359	znewn(fn,s) char fn, *s; {
2360	#ifdef pdp11
2361	#define ZNEWNBL 63 /* Name buffer length */
2362	#define ZNEWNMD 3 /* Max digits for version number */
2363	#else
2364	#define ZNEWNBL 255
2365	#define ZNEWNMD 4
2366	#endif /* pdp11 */
2367
2368	static char buf[ZNEWNBL+1];
2369	char bp, xp, *yp;
2370	#ifdef OS2
2371	static char localfn[MAXPATH+1];
2372	char tp=NULL, zp=NULL, ch, temp[14];
2373	#endif /* OS2 */
2374	int len = 0, d = 0, n, t, i, j, k, power = 1;
2375
2376	int max = MAXNAMLEN; /* Maximum name length */
2377
2378	if (max < 14) max = 14; /* Make it reasonable */
2379	if (max > ZNEWNBL) max = ZNEWNBL;
2380	bp = buf; /* Buffer for building new name */
2381	yp = fn;
2382	while (yp) { / Copy old name into buffer */
2383	bp++ = yp++;
2384	if (len++ > ZNEWNBL) break; /* ...up to buffer length */
2385	}
2386	*s = NULL;
2387	for (i = 1; i < ZNEWNMD + 1; i++) { /* Version numbers up to 10*i - 1 /
2388	power = 10; / Next power of 10 */
2389	j = max - len; /* Space left for version number */
2390	k = 3 + i; /* Space needed for it */
2391	if (j < k) { /* Make room if necessary */
2392	len -= (k - j); /* Adjust length of filename */
2393	bp = buf + len; /* Point to new end */
2394	}
2395	bp++ = ''; /* Put a star on the end (UNIX) */
2396	bp-- = '\0'; / Terminate with null */
2397
2398	debug(F110,"znewn: about to expand",buf,0);
2399	n = zxpand(buf); /* Expand the resulting wild name */
2400	/* n is the number of matches */
2401	debug(F101,"znewn matches","",n);
2402	while (n-- > 0) { /* Find any existing name.~n~ files */
2403	#ifdef OS2
2404	znext(localfn);
2405	xp = localfn;
2406	#else /* OS2 */
2407	xp = mtchptr++; / Point at matching name */
2408	#endif /* OS2 */
2409	xp += len; /* Look for .~<n>~ at the end of it */
2410	if (xp == '.' && (xp+1) == '~') { /* Has a version number */
2411	t = atoi(xp+2); /* Get it */
2412	if (t > d) d = t; /* Save d = highest version number */
2413	}
2414	}
2415	if (d < power-1) { /* Less than maximum possible? */
2416	debug(F110,"znewn number ok",buf,0);
2417	sprintf(bp,".~%d~",d+1); /* Yes, make "name.~<d+1>~" */
2418	s = buf; / Point to new name */
2419	ck_znewn = d+1; /* Also make it available globally */
2420	break; /* Done, return it */
2421	}
2422	}
2423	if (*s == NULL) {
2424	debug(F110,"znewn: too many names",buf,0);
2425	sprintf(bp,".~xxxx~"); /* Too many, use xxxx. */
2426	ck_znewn = -1; /* Also make it available globally */
2427	*s = buf;
2428	}
2429	#ifdef OS2
2430	if (IsFileNameValid(buf)) {
2431	debug(F110,"znewn: os2 filename valid",buf,0);
2432	return; /* HPFS */
2433	}
2434	/* otherwise make FAT 8.3 name */
2435	debug(F110,"znewn: os2 filename invalid",buf,0);
2436	xp = bp = buf;
2437	yp = fn;
2438	while (yp) { / Copy name into buf */
2439	ch = bp++ = yp++;
2440	if (ISDIRSEP(ch) \|\| (ch == ':')) xp=bp;
2441	}
2442	*bp = '\0';
2443	yp = xp;
2444	i = 1;
2445	while (yp && (yp != '.')) {
2446	yp++;
2447	if (++i<=6)
2448	zp=yp;
2449	}
2450	/* zp points to 6th character in name, or yp, whichever occurs first. */
2451	strcpy(temp,yp); /* Copy extension, if any */
2452	while (zp != xp+8) {
2453	if ( zp < xp+5 ) *zp++='0';
2454	else zp++='?'; / Pad out with wild cards */
2455	}
2456	strcpy(zp,temp); /* Get the extension back */
2457	debug(F110,"znewn: about to expand",buf,0);
2458	n = zxpand(buf); /* Expand the resulting wild name */
2459	debug(F101,"znewn: matches","",n);
2460	d = 0; /* Index number */
2461	debug(F110,"znewn: temp",temp,0);
2462	while (znext(temp)) {
2463	#ifdef COMMENT
2464	i = atoi(temp+5);
2465	if (i > d) d = i;
2466	#else
2467	if ( tp = strrchr( temp, '/' ) )
2468	tp++;
2469	else
2470	tp = temp;
2471	i = atoi(tp+5);
2472	debug(F111,"znewn: tp=atoi(tp+5)",tp,i);
2473	if (i > d) d = i;
2474	debug(F101,"znewn: d","",d);
2475	#endif /* COMMENT */
2476	}
2477	sprintf(temp,"%03d",d+1); /* Get the number into a string */
2478	ck_znewn = d+1;
2479	memcpy(xp+5, temp, 3);
2480	debug(F110,"znewn: os2 file name is FAT",buf,0);
2481	#endif /* OS2 */
2482	return;
2483	}
2484
2485	/* Z R E N A M E -- Rename a file */
2486	/*
2487	Call with old and new names.
2488	If new name is the name of a directory, the 'old' file is moved to
2489	that directory.
2490	Returns 0 on success, -1 on failure.
2491	*/
2492	int
2493	zrename(old,new) char old, new; {
2494	char p = NULL, s = new;
2495	int x;
2496
2497	debug(F110,"zrename old",old,0);
2498	debug(F110,"zrename new",s,0);
2499	if (isdir(new)) {
2500	char *q = NULL;
2501	x = strlen(new);
2502	if (!(p = malloc(strlen(new) + strlen(old) + 2)))
2503	return(-1);
2504	strcpy(p,new); /* Directory part */
2505	if (!ISDIRSEP((new+x-1))) / Separator, if needed */
2506	strcat(p,"/");
2507	zstrip(old,&q); /* Strip path part from old name */
2508	strcat(p,q); /* Concatenate to new directory */
2509	s = p;
2510	debug(F110,"zrename dir",s,0);
2511	} else debug(F110,"zrename no dir",s,0);
2512	#ifdef RENAME
2513	/*
2514	Atomic, preferred, uses a single system call, rename(), if available.
2515	OS/2 rename() returns nonzero, but not necessarily -1 (?), on failure.
2516	*/
2517	x = rename(old,s);
2518	if (p) free(p);
2519	return(x ? -1 : 0);
2520	#else /* !RENAME */
2521	/*
2522	This way has a window of vulnerability.
2523	*/
2524	x = -1; /* Return code. */
2525	if (link(old,s) < 0) { /* Make a link with the new name. */
2526	debug(F111,"zrename link fails, errno",old,errno);
2527	} else if (
2528	#ifdef NT
2529	_unlink(old)
2530	#else
2531	unlink(old)
2532	#endif /* NT */
2533	< 0) { /* Unlink the old name. */
2534	debug(F111,"zrename unlink fails, errno",old,errno);
2535	} else x = 0;
2536	if (p) free(p);
2537	return(x);
2538	#endif /* RENAME */
2539	}
2540
2541	/* Z C O P Y -- Copy a file */
2542	/*
2543	Call with source and destination names.
2544	If destination name is the name of a directory, the source file is
2545	copied to that directory with the original name.
2546	Returns 0 on success, -1 on failure.
2547	*/
2548	int
2549	zcopy(source,destination) char source, destination; {
2550	char p = NULL, s = destination;
2551	int x;
2552
2553	debug(F110,"zcopy source",source,0);
2554	debug(F110,"zcopy destination",s,0);
2555	if (isdir(destination)) {
2556	char *q = NULL;
2557	x = strlen(destination);
2558	if (!(p = malloc(strlen(destination) + strlen(source) + 2)))
2559	return(-1);
2560	strcpy(p,destination); /* Directory part */
2561	if (!ISDIRSEP((destination+x-1))) / Separator, if needed */
2562	strcat(p,"/");
2563	zstrip(source,&q); /* Strip path part from old name */
2564	strcat(p,q); /* Concatenate to new directory */
2565	s = p;
2566	debug(F110,"zcopy dir",s,0);
2567	} else debug(F110,"zcopy no dir",s,0);
2568	#ifdef OS2
2569	#ifndef NT
2570	x = (DosCopy( source, destination, DCPY_FAILEAS ) ? -1 : 0);
2571	#else /* NT */
2572	x = (CopyFile( source, destination, FALSE ) ? 0 : -1 );
2573	#endif /* NT */
2574	#else
2575	/* not yet implemented */
2576	x = -1;
2577	#endif
2578	return x;
2579	}
2580
2581	/* Z S A T T R */
2582	/*
2583	Fills in a Kermit file attribute structure for the file which is to be sent.
2584	Returns 0 on success with the structure filled in, or -1 on failure.
2585	If any string member is null, then it should be ignored.
2586	If any numeric member is -1, then it should be ignored.
2587	*/
2588	int
2589	zsattr(xx) struct zattr *xx; {
2590	long k;
2591
2592	k = iflen % 1024L; /* File length in K */
2593	if (k != 0L) k = 1L;
2594	xx->lengthk = (iflen / 1024L) + k;
2595	xx->type.len = 0; /* File type can't be filled in here */
2596	xx->type.val = "";
2597	if (*nambuf) {
2598	xx->date.val = zfcdat(nambuf); /* File creation date */
2599	xx->date.len = (int)strlen(xx->date.val);
2600	} else {
2601	xx->date.len = 0;
2602	xx->date.val = "";
2603	}
2604	xx->creator.len = 0; /* File creator */
2605	xx->creator.val = "";
2606	xx->account.len = 0; /* File account */
2607	xx->account.val = "";
2608	xx->area.len = 0; /* File area */
2609	xx->area.val = "";
2610	xx->password.len = 0; /* Area password */
2611	xx->password.val = "";
2612	xx->blksize = -1L; /* File blocksize */
2613	xx->xaccess.len = 0; /* File access */
2614	xx->xaccess.val = "";
2615	xx->encoding.len = 0; /* Transfer syntax */
2616	xx->encoding.val = 0;
2617	xx->disp.len = 0; /* Disposition upon arrival */
2618	xx->disp.val = "";
2619	xx->lprotect.len = 0; /* Local protection */
2620	xx->lprotect.val = "";
2621	xx->gprotect.len = 0; /* Generic protection */
2622	xx->gprotect.val = "";
2623	xx->systemid.len = 2; /* System ID */
2624	#ifdef OS2
2625	xx->systemid.val = "UO"; /* UO = OS/2 */
2626	#else
2627	xx->systemid.val = "U1"; /* U1 = UNIX */
2628	#endif /* OS2 */
2629	xx->recfm.len = 0; /* Record format */
2630	xx->recfm.val = "";
2631	xx->sysparam.len = 0; /* System-dependent parameters */
2632	xx->sysparam.val = "";
2633	xx->length = iflen; /* Length */
2634	return(0);
2635	}
2636
2637	/* Z F C D A T -- Get file creation date */
2638	/*
2639	Call with pointer to filename.
2640	On success, returns pointer to modification date in yyyymmdd hh:mm:ss format.
2641	On failure, returns pointer to null string.
2642	*/
2643	static char datbuf[40];
2644
2645	char *
2646	zdtstr(time) time_t time; {
2647	struct tm * time_stamp;
2648	struct tm * localtime();
2649	int yy, ss;
2650
2651	debug(F101,"zdatstr time","",time);
2652	if (time < 0)
2653	return("");
2654	time_stamp = localtime(&(time));
2655	if (!time_stamp) {
2656	debug(F100,"localtime returns null","",0);
2657	return("");
2658	}
2659	yy = time_stamp->tm_year; /* Year - 1900 */
2660	yy += 1900;
2661	debug(F101,"zdatstr year","",yy);
2662	if (yy < 1970) /* By definition of C library */
2663	return("");
2664
2665	if (time_stamp->tm_mon < 0 \|\| time_stamp->tm_mon > 11)
2666	return("");
2667	if (time_stamp->tm_mday < 0 \|\| time_stamp->tm_mday > 31)
2668	return("");
2669	if (time_stamp->tm_hour < 0 \|\| time_stamp->tm_hour > 23)
2670	return("");
2671	if (time_stamp->tm_min < 0 \|\| time_stamp->tm_min > 59)
2672	return("");
2673	ss = time_stamp->tm_sec; /* Seconds */
2674	if (ss < 0 \|\| ss > 59) /* Some systems give a BIG number */
2675	ss = 0;
2676	sprintf(datbuf,
2677	#ifdef pdp11
2678	/* For some reason, 2.1x BSD sprintf gets the last field wrong. */
2679	"%04d%02d%02d %02d:%02d:00",
2680	#else
2681	"%04d%02d%02d %02d:%02d:%02d",
2682	#endif /* pdp11 */
2683	yy,
2684	time_stamp->tm_mon + 1,
2685	time_stamp->tm_mday,
2686	time_stamp->tm_hour,
2687	time_stamp->tm_min
2688	#ifndef pdp11
2689	, ss
2690	#endif /* pdp11 */
2691	);
2692	yy = (int)strlen(datbuf);
2693	debug(F111,"zdatstr",datbuf,yy);
2694	if (yy > 17) datbuf[17] = '\0';
2695	return(datbuf);
2696	}
2697
2698	char *
2699	zfcdat(name) char *name; {
2700
2701	#ifdef TIMESTAMP
2702	#ifdef NT
2703	struct _stat buffer;
2704	#else /* NT */
2705	struct stat buffer;
2706	#endif /* NT */
2707
2708	datbuf[0] = '\0';
2709	if (stat(name,&buffer) != 0) {
2710	debug(F110,"zfcdat stat failed",name,0);
2711	return("");
2712	}
2713	return(zdtstr(buffer.st_mtime));
2714	#else
2715	return("");
2716	#endif /* TIMESTAMP */
2717	}
2718
2719	time_t
2720	zstrdt(date,len) char * date; int len; {
2721	/*
2722	To do: adapt code from OS-9 Kermit's ck9fio.c zstime function, which
2723	is more flexible, allowing [yy]yymmdd[ hh:mm[:ss]].
2724	*/
2725	#ifndef OS2
2726	#ifdef M_UNIX
2727	/*
2728	SCO UNIX 3.2v2.0 and ODT 2.0 lack prototypes for ftime().
2729	ODT 3.0 (3.2v4.2 OS) has a prototype, which may vary in
2730	dependence on the XPG4 supplement presence. So always use
2731	what the system header file supplies in ODT 3.0...
2732	*/
2733	#ifndef ODT30
2734	#ifndef _SCO_DS
2735	extern void ftime(); /* extern void ftime(struct timeb ) /
2736	#endif /* _SCO_DS */
2737	#endif /* ODT30 */
2738	#else
2739	extern int ftime();
2740	#endif /* M_UNIX */
2741	extern int stat();
2742	extern struct tm * localtime();
2743
2744	/* and this should have been declared always through a header file */
2745	#endif /* OS2 */
2746	long tmx, days;
2747	int i, n, isleapyear;
2748	/* J F M A M J J A S O N D */
2749	/* 31 28 31 30 31 30 31 31 30 31 30 31 */
2750	static
2751	int monthdays [13] = { 0,0,31,59,90,120,151,181,212,243,273,304,334 };
2752	char s[5];
2753	struct tm *time_stamp;
2754
2755	#ifdef BSD44
2756	struct timeval tp[2];
2757	long xtimezone;
2758	#else
2759	#ifdef OS2
2760
2761	#ifdef NT
2762	struct _utimbuf tp;
2763	#else /* NT */
2764	struct utimbuf tp;
2765	#endif /* NT */
2766
2767	#ifdef __EMX__
2768	long timezone;
2769	struct timeb tbp;
2770	#endif /* __EMX__ */
2771	#else
2772	#ifdef V7
2773	struct utimbuf {
2774	time_t timep[2]; /* New access and modificaton time */
2775	} tp;
2776	char *tz;
2777	long timezone; /* In case timezone not defined in .h file */
2778	#else
2779	#ifdef SYSUTIMEH
2780	struct utimbuf tp;
2781	#else
2782	struct utimbuf {
2783	time_t atime;
2784	time_t mtime;
2785	} tp;
2786	#endif /* SYSUTIMEH */
2787	#endif /* V7 */
2788	#endif /* OS2 */
2789	#endif /* BSD44 */
2790
2791	#ifdef ANYBSD
2792	long timezone = 0L;
2793	static struct timeb tbp;
2794	#endif /* ANYBSD */
2795
2796	#ifdef BEBOX
2797	long timezone = 0L;
2798	#endif /* BEBOX */
2799
2800	debug(F111,"zstrdt",date,len);
2801
2802	if ((len == 0)
2803	\|\| (len != 17)
2804	\|\| (date[8] != ' ')
2805	\|\| (date[11] != ':')
2806	\|\| (date[14] != ':') ) {
2807	debug(F111,"Bad creation date ",date,len);
2808	return(-1);
2809	}
2810	debug(F111,"zstime date check 1",date,len);
2811	for(i = 0; i < 8; i++) {
2812	if (!isdigit(date[i])) {
2813	debug(F111,"Bad creation date ",date,len);
2814	return(-1);
2815	}
2816	}
2817	debug(F111,"zstime date check 2",date,len);
2818	i++;
2819
2820	for (; i < 16; i += 3) {
2821	if ((!isdigit(date[i])) \|\| (!isdigit(date[i + 1]))) {
2822	debug(F111,"Bad creation date ",date,len);
2823	return(-1);
2824	}
2825	}
2826	debug(F111,"zstime date check 3",date,len);
2827
2828	#ifdef BSD44
2829	{
2830	int x;
2831	struct timezone tzp;
2832	x = gettimeofday(NULL, &tzp);
2833	debug(F101,"zstime BSD44 gettimeofday","",x);
2834	if (x > -1)
2835	xtimezone = tzp.tz_minuteswest * 60L;
2836	else
2837	xtimezone = 0L;
2838	debug(F101,"zstime BSD44 timezone","",xtimezone);
2839	}
2840	#else
2841	#ifdef ANYBSD
2842	debug(F100,"zstime BSD calling ftime","",0);
2843	ftime(&tbp);
2844	debug(F100,"zstime BSD back from ftime","",0);
2845	timezone = tbp.timezone * 60L;
2846	debug(F101,"zstime BSD timezone","",timezone);
2847	#else
2848	#ifdef OS2
2849	#ifdef __EMX__
2850	ftime(&tbp);
2851	timezone = tbp.timezone * 60L;
2852	#endif /* __EMX__ */
2853	#else
2854	#ifdef SVORPOSIX
2855	tzset(); /* Set timezone */
2856	#else
2857	#ifdef V7
2858	if ((tz = getenv("TZ")) == NULL)
2859	timezone = 0; /* UTC/GMT */
2860	else
2861	timezone = atoi(&tz[3]); /* Set 'timezone'. */
2862	timezone *= 60L;
2863	#endif /* V7 */
2864	#endif /* SVORPOSIX */
2865	#endif /* OS2 */
2866	#endif /* ANYBSD */
2867	#endif /* BSD44 */
2868
2869	debug(F100,"zstime so far so good","",0);
2870
2871	s[4] = '\0';
2872	for (i = 0; i < 4; i++) /* Fix the year */
2873	s[i] = date[i];
2874
2875	n = atoi(s);
2876	debug(F111,"zstime year",s,n);
2877	if (n < 1970) {
2878	debug(F100,"zstime fails - year","",n);
2879	return(-1);
2880	}
2881
2882	/* Previous year's leap days. This won't work after year 2100. */
2883
2884	isleapyear = (( n % 4 == 0 && n % 100 !=0) \|\| n % 400 == 0);
2885	days = (long) (n - 1970) * 365;
2886	days += (n - 1968 - 1) / 4 - (n - 1900 - 1) / 100 + (n - 1600 - 1) / 400;
2887
2888	s[2] = '\0';
2889
2890	for (i = 4; i < 16; i += 2) {
2891	s[0] = date[i];
2892	s[1] = date[i + 1];
2893	n = atoi(s);
2894	switch (i) {
2895	case 4: /* MM: month */
2896	if ((n < 1 ) \|\| ( n > 12)) {
2897	debug(F111,"zstime 4 bad date ",date,len);
2898	return(-1);
2899	}
2900	days += monthdays [n];
2901	if (isleapyear && n > 2)
2902	++days;
2903	continue;
2904
2905	case 6: /* DD: day */
2906	if ((n < 1 ) \|\| ( n > 31)) {
2907	debug(F111,"zstime 6 bad date ",date,len);
2908	return(-1);
2909	}
2910	tmx = (days + n - 1) * 24L * 60L * 60L;
2911	i++; /* Skip the space */
2912	continue;
2913
2914	case 9: /* hh: hour */
2915	if ((n < 0 ) \|\| ( n > 23)) {
2916	debug(F111,"zstime 9 bad date ",date,len);
2917	return(-1);
2918	}
2919	tmx += n * 60L * 60L;
2920	i++; /* Skip the colon */
2921	continue;
2922
2923	case 12: /* mm: minute */
2924	if ((n < 0 ) \|\| ( n > 59)) {
2925	debug(F111,"zstime 12 bad date ",date,len);
2926	return(-1);
2927	}
2928	#ifdef BSD44 /* Correct for time zone */
2929	tmx += xtimezone;
2930	debug(F101,"zstime BSD44 tmx","",tmx);
2931	#else
2932	#ifdef ANYBSD
2933	tmx += timezone;
2934	#else
2935	#ifndef CONVEX9 /* Don't yet know how to do this here */
2936	#ifdef ultrix
2937	tmx += (long) timezone;
2938	#else
2939	#ifdef Plan9
2940	{
2941	extern time_t tzoffset;
2942	tmx += tzoffset;
2943	}
2944	#else
2945	tmx += timezone;
2946	#endif /* Plan9 */
2947	#endif /* ultrix */
2948	#endif /* CONVEX9 */
2949	#endif /* BSD44 */
2950	#endif /* ANYBSD */
2951	tmx += n * 60L;
2952	i++; /* Skip the colon */
2953	continue;
2954
2955	case 15: /* ss: second */
2956	if ((n < 0 ) \|\| ( n > 59)) {
2957	debug(F111,"zstime 15 bad date ",date,len);
2958	return(-1);
2959	}
2960	tmx += n;
2961	}
2962	time_stamp = localtime(&tmx);
2963	if (!time_stamp)
2964	return(-1);
2965	if (localtime(&tmx)->tm_isdst)
2966	tmx -= 60L * 60L; /* Adjust for daylight savings time */
2967	}
2968	return(tmx);
2969	}
2970
2971	/* Z S T I M E -- Set creation date for incoming file */
2972	/*
2973	Call with:
2974	f = pointer to name of existing file.
2975	yy = pointer to a Kermit file attribute structure in which yy->date.val
2976	is a date of the form yyyymmdd hh:mm:ss, e.g. 19900208 13:00:00.
2977	x = is a function code: 0 means to set the file's creation date as given.
2978	1 means compare the given date with the file creation date.
2979	Returns:
2980	-1 on any kind of error.
2981	0 if x is 0 and the file date was set successfully.
2982	0 if x is 1 and date from attribute structure <= file creation date.
2983	1 if x is 1 and date from attribute structure > file creation date.
2984	*/
2985	int
2986	zstime(f,yy,x)
2987	#ifdef HPUX10
2988	#ifdef CK_ANSIC
2989	const
2990	#endif /* CK_ANSIC */
2991	#endif /* HPUX10 */
2992	char f; struct zattr yy; int x;
2993	/* zstime */ {
2994	int r = -1; /* Return code */
2995
2996	/* It is ifdef'd TIMESTAMP because it might not work on V7. bk@kullmar.se. */
2997
2998	#ifdef TIMESTAMP
2999	#ifndef OS2
3000	#ifdef BSD44
3001	extern int utimes();
3002	#else
3003	extern int utime();
3004	#endif /* BSD44 */
3005	#endif /* OS2 */
3006
3007	/* At least, the declarations for int functions are not needed anyway */
3008
3009	#ifdef NT
3010	struct _stat sb;
3011	#else /* NT */
3012	struct stat sb;
3013	#endif /* NT */
3014
3015	#ifdef BSD44
3016	struct timeval tp[2];
3017	long xtimezone;
3018	#else
3019	#ifdef OS2
3020
3021	#ifdef NT
3022	struct _utimbuf tp;
3023	#else /* NT */
3024	struct utimbuf tp;
3025	#endif /* NT */
3026
3027	#ifdef __EMX__
3028	long timezone;
3029	struct timeb tbp;
3030	#endif /* __EMX__ */
3031	#else
3032	#ifdef V7
3033	struct utimbuf {
3034	time_t timep[2]; /* New access and modificaton time */
3035	} tp;
3036	char *tz;
3037	long timezone; /* In case not defined in .h file */
3038	#else
3039	#ifdef SYSUTIMEH
3040	struct utimbuf tp;
3041	#else
3042	struct utimbuf {
3043	time_t atime;
3044	time_t mtime;
3045	} tp;
3046	#endif /* SYSUTIMEH */
3047	#endif /* V7 */
3048	#endif /* OS2 */
3049	#endif /* BSD44 */
3050
3051	long tm;
3052
3053	debug(F110,"zstime",f,0);
3054	debug(F111,"zstime",yy->date.val,yy->date.len);
3055	if ((tm = zstrdt(yy->date.val,yy->date.len)) < 0) {
3056	debug(F101,"zstime: zstrdt fails","",0);
3057	return(-1);
3058	}
3059	debug(F101,"zstime: tm","",tm);
3060	debug(F111,"zstime: A-pkt date ok ",yy->date.val,yy->date.len);
3061
3062	if (stat(f,&sb)) { /* Get the time for the file */
3063	debug(F110,"zstime: Can't stat file:",f,0);
3064	return(-1);
3065	}
3066	debug(F101,"zstime: sb.st_atime","",sb.st_atime);
3067
3068	#ifdef OS2
3069	tp.modtime = tm; /* Set modif. time to creation date */
3070	tp.actime = sb.st_atime; /* Don't change the access time */
3071	#else
3072	#ifdef SYSUTIMEH
3073	tp.modtime = tm; /* Set modif. time to creation date */
3074	tp.actime = sb.st_atime; /* Don't change the access time */
3075	#else
3076	#ifdef V7
3077	tp.timep[0] = tm; /* Set modif. time to creation date */
3078	tp.timep[1] = sb.st_atime; /* Don't change the access time */
3079	#else
3080	#ifdef BSD44
3081	tp[0].tv_sec = sb.st_atime; /* Access time first */
3082	tp[1].tv_sec = tm; /* Update time second */
3083	#else
3084	tp.mtime = tm; /* Set modif. time to creation date */
3085	tp.atime = sb.st_atime; /* Don't change the access time */
3086	#endif /* BSD44 */
3087	#endif /* V7 */
3088	#endif /* SYSUTIMEH */
3089	#endif /* OS2 */
3090
3091	switch (x) { /* Execute desired function */
3092	case 0: /* Set the creation date of the file */
3093	if (
3094	#ifdef BSD44
3095	utimes(f,tp)
3096	#else
3097	#ifdef NT
3098	_utime(f,&tp)
3099	#else /* NT */
3100	utime(f,&tp)
3101	#endif /* NT */
3102	#endif /* BSD44 */
3103	) { /* Fix modification time */
3104	debug(F110,"zstime 0: can't set modtime for file",f,0);
3105	r = -1;
3106	} else {
3107	debug(F110,"zstime 0: modtime set for file",f,0);
3108	r = 0;
3109	}
3110	break;
3111	case 1: /* Compare the dates */
3112	/*
3113	This was st_atime, which was wrong. We want the file-data modification
3114	time, st_mtime.
3115	*/
3116	debug(F111,"zstime 1: compare",f,sb.st_mtime);
3117	debug(F111,"zstime 1: compare","packet",tm);
3118	#ifdef OS2
3119	/*
3120	In OS/2, sb.st_mtime, at least on a FAT file system, is always even.
3121	In that case, if the incoming file is only one second newer than the
3122	local file, consider them the same. (THERE MUST BE A BETTER FIX FOR THIS!)
3123	*/
3124	if ((sb.st_mtime & 1) == 0)
3125	if ((tm - sb.st_mtime) == 1)
3126	tm--;
3127	#endif /* OS2 */
3128	r = (sb.st_mtime < tm) ? 0 : 1;
3129	break;
3130
3131	default: /* Error */
3132	r = -1;
3133	}
3134	#endif /* TIMESTAMP */
3135	return(r);
3136	}
3137
3138	/* Find initialization file. */
3139
3140	#ifdef NOTUSED
3141	int
3142	zkermini() {
3143	/* nothing here for Unix. This function added for benefit of VMS Kermit. */
3144	return(0);
3145	}
3146	#endif /* NOTUSED */
3147
3148	#ifndef NOFRILLS
3149	int
3150	zmail(p,f) char p; char f; { /* Send file f as mail to address p */
3151	/*
3152	Returns 0 on success
3153	2 if mail delivered but temp file can't be deleted
3154	-2 if mail can't be delivered
3155	The UNIX version always returns 0 because it can't get a good return
3156	code from zsyscmd.
3157	*/
3158	#ifdef BSD4
3159	/* The idea is to use /usr/ucb/mail, rather than regular mail, so that */
3160	/* a subject line can be included with -s. Since we can't depend on the */
3161	/* user's path, we use the convention that /usr/ucb/Mail = /usr/ucb/mail */
3162	/* and even if Mail has been moved to somewhere else, this should still */
3163	/* find it... The search could be made more reliable by actually using */
3164	/* access() to see if /usr/ucb/Mail exists. */
3165
3166	/* Should also make some check on zmbuf overflow... */
3167
3168	#ifdef DGUX540
3169	sprintf(zmbuf,"mailx -s %c%s%c %s < %s", '"', f, '"', p, f);
3170	#else
3171	sprintf(zmbuf,"Mail -s %c%s%c %s < %s", '"', f, '"', p, f);
3172	#endif /* DGUX540 */
3173	zsyscmd(zmbuf);
3174	#else
3175	#ifdef SVORPOSIX
3176	#ifndef OXOS
3177	sprintf(zmbuf,"mail %s < %s", p, f);
3178	#else /* OXOS */
3179	sprintf(zmbuf,"mailx -s %c%s%c %s < %s", '"', f, '"', p, f);
3180	#endif /* OXOS */
3181	zsyscmd(zmbuf);
3182	#else
3183	*zmbuf = '\0';
3184	#endif
3185	#endif
3186	return(0);
3187	}
3188	#endif /* NOFRILLS */
3189
3190	#ifndef NOFRILLS
3191	int
3192	zprint(p,f) char p; char f; { /* Print file f with options p */
3193	extern char * printfile; /* From ckuus3.c */
3194	extern int printpipe;
3195
3196	debug(F110,"zprint file",f,0);
3197	debug(F110,"zprint flags",p,0);
3198	debug(F110,"zprint printfile",printfile,0);
3199	debug(F101,"zprint printpipe","",printpipe);
3200
3201	#ifdef NT
3202	if (printfile) {
3203	if (printpipe)
3204	sprintf(zmbuf,"COPY /B %s \| %s", f, printfile);
3205	else
3206	sprintf(zmbuf,"COPY /B %s %s", f, printfile);
3207	} else {
3208	sprintf(zmbuf,"COPY /B %s PRN", f);
3209	}
3210	debug(F110,"zprint command",zmbuf,0);
3211	zsyscmd(zmbuf);
3212	#else
3213	#ifdef OS2
3214	if (printfile) {
3215	if (printpipe)
3216	sprintf(zmbuf,"COPY /B %s \| %s", f, printfile);
3217	else
3218	sprintf(zmbuf,"COPY /B %s %s", f, printfile);
3219	} else {
3220	sprintf(zmbuf,"print %s %s", p, f); /* Construct print command */
3221	}
3222	debug(F110,"zprint command",zmbuf,0);
3223	zsyscmd(zmbuf);
3224	#else
3225	#ifdef UNIX
3226	#ifdef ANYBSD /* BSD uses lpr to spool */
3227	#ifdef DGUX540 /* And DG/UX */
3228	#define SPOOLER "lp"
3229	#else
3230	#define SPOOLER "lpr"
3231	#endif /* DGUX540 */
3232	#else /* Sys V uses lp */
3233	#ifdef TRS16 /* except for Tandy-16/6000... */
3234	#define SPOOLER "lpr"
3235	#else
3236	#define SPOOLER "lp"
3237	#endif
3238	#endif
3239	/*
3240	Note use of standard input redirection. In some systems, lp[r] runs
3241	setuid to lp (or ...?), so if user has sent a file into a directory
3242	that lp does not have read access to, it can't be printed unless it is
3243	fed to lp[r] as standard input.
3244	*/
3245	if (printpipe && printfile) {
3246	sprintf(zmbuf,"cat %s \| %s", f, printfile);
3247	} else if (printfile) {
3248	sprintf(zmbuf,"cat %s >> %s", f, printfile);
3249	} else {
3250	sprintf(zmbuf,"%s %s < %s", SPOOLER, p, f);
3251	}
3252	debug(F110,"zprint command",zmbuf,0);
3253	zsyscmd(zmbuf);
3254	#else /* Not UNIX */
3255	*zmbuf = '\0';
3256	#endif /* UNIX */
3257	#endif /* OS2 */
3258	#endif /* NT */
3259	return(0);
3260	}
3261	#endif /* NOFRILLS */
3262
3263	/*
3264	Wildcard expansion functions. C-Kermit used to insist on doing this itself
3265	New code (version 5A, 1990-91) gives user option to ask UNIX to do it.
3266	This lets users use the wildcard expansion features of their favorite shell.
3267	Operation is slower because of the forking & piping, but flexibility is
3268	greater and program is smaller. For OS/2, C-Kermit still does this itself.
3269	*/
3270	static char scratch[MAXPATH+4]; /* Used by both methods */
3271
3272	#ifndef OS2
3273	static int oldmtchs = 0; /* Let shell (ls) expand them. */
3274	#ifdef COMMENT
3275	static char lscmd = "/bin/ls -d"; / Command to use. */
3276	#else
3277	static char lscmd = "echo"; / Command to use. */
3278	#endif /* COMMENT */
3279
3280	#ifndef NOPUSH
3281	int
3282	shxpand(pat,namlst,len) char pat, namlst[]; int len; {
3283	char fgbuf = NULL; / Buffer for forming ls command */
3284	char p, q; /* Workers */
3285	int i, x, retcode; char c; /* ... */
3286
3287	x = (int)strlen(pat) + (int)strlen(lscmd) + 3; /* Length of ls command */
3288	for (i = 0; i < oldmtchs; i++) { /* Free previous file list */
3289	if (namlst[i] ) { /* If memory is allocated */
3290	free(namlst[i]); /* Free the memory */
3291	namlst[i] = NULL ; /* Remember no memory is allocated */
3292	}
3293	}
3294	oldmtchs = 0 ; /* Remember there are no matches */
3295	fgbuf = malloc(x); /* Get buffer for command */
3296	if (!fgbuf) return(-1); /* Fail if cannot */
3297	sprintf(fgbuf,"%s %s",lscmd,pat); /* Form the command */
3298	zxcmd(ZIFILE,fgbuf); /* Start the command */
3299	i = 0; /* File counter */
3300	p = scratch; /* Point to scratch area */
3301	retcode = -1; /* Assume failure */
3302	while ((x = zminchar()) != -1) { /* Read characters from command */
3303	c = (char) x;
3304	if (c == ' ' \|\| c == '\n') { /* Got newline or space? */
3305	p = '\0'; / Yes, terminate string */
3306	p = scratch; /* Point back to beginning */
3307	if (zchki(p) == -1) /* Does file exist? */
3308	continue; /* No, continue */
3309	x = (int)strlen(p); /* Yes, get length of name */
3310	q = malloc(x+1); /* Allocate space for it */
3311	if (!q) goto shxfin; /* Fail if space can't be obtained */
3312	strcpy(q,scratch); /* Copy name to space */
3313	namlst[i++] = q; /* Copy pointer to name into array */
3314	if (i >= len) goto shxfin; /* Fail if too many */
3315	} else { /* Regular character */
3316	p++ = c; / Copy it into scratch area */
3317	}
3318	}
3319	retcode = i; /* Return number of matching files */
3320	shxfin: /* Common exit point */
3321	free(fgbuf); /* Free command buffer */
3322	fgbuf = NULL;
3323	zclosf(ZIFILE); /* Delete the command fork. */
3324	oldmtchs = i; /* Remember how many files */
3325	return(retcode);
3326	}
3327	#endif /* NOPUSH */
3328	#endif /* OS2 */
3329
3330	/* Directory Functions for Unix, written by Jeff Damens, CUCCA, 1984. */
3331
3332	/* Define the size of the string space for filename expansion. */
3333
3334	#ifndef DYNAMIC
3335	#ifdef PROVX1
3336	#define SSPACE 500
3337	#else
3338	#ifdef BSD29
3339	#define SSPACE 500
3340	#else
3341	#ifdef pdp11
3342	#define SSPACE 500
3343	#else
3344	#ifdef aegis
3345	#define SSPACE 10000 /* size of string-generating buffer */
3346	#else /* Default static buffer size */
3347	#ifdef BIGBUFOK
3348	#define SSPACE 32768 /* size of string-generating buffer */
3349	#else
3350	#define SSPACE 2000 /* size of string-generating buffer */
3351	#endif /* BIGBUFOK */
3352	#endif /* aegis */
3353	#endif /* pdp11 */
3354	#endif /* BSD29 */
3355	#endif /* PROVX1 */
3356	static char sspace[SSPACE]; /* Buffer for generating filenames */
3357	#else /* is DYNAMIC */
3358	#ifdef BIGBUFOK
3359	#define SSPACE 32768
3360	#else
3361	#define SSPACE 10000
3362	#endif /* BIGBUFOK */
3363	static char sspace = (char )0;
3364	#endif /* DYNAMIC */
3365	static int ssplen = SSPACE; /* Length of string space buffer */
3366
3367	static char freeptr, resptr; / copies of caller's arguments */
3368	static int remlen; /* remaining length in caller's array*/
3369	static int numfnd; /* number of matches found */
3370
3371	#ifdef aegis
3372	static char bslash;
3373	#endif /* aegis */
3374
3375	/*
3376	* splitpath:
3377	* takes a string and splits the slash-separated portions into
3378	* a list of path structures. Returns the head of the list. The
3379	* structures are allocated by malloc, so they must be freed.
3380	* Splitpath is used internally by the filename generator.
3381	*
3382	* Input: A string.
3383	* Returns: A linked list of the slash-separated segments of the input.
3384	*/
3385
3386	struct path *
3387	splitpath(p) char *p; {
3388	struct path head,cur,*prv;
3389	int i;
3390
3391	debug(F110,"splitpath",p,0);
3392
3393	head = prv = NULL;
3394	if (ISDIRSEP(p)) p++; / skip leading slash */
3395	#ifdef OS2
3396	if ( p == '\0' ) { / the user wants the root directory */
3397	cur = (struct path *) malloc(sizeof(struct path));
3398	debug(F101,"splitpath malloc","",cur);
3399	if (cur == NULL) {
3400	debug(F100,"splitpath malloc failure","",0);
3401	return((struct path *)NULL);
3402	}
3403	cur->fwd = NULL;
3404	cur->npart[0] = '.';
3405	cur->npart[1] = '\0';
3406	head = cur;
3407	return head;
3408	}
3409	#endif /* OS2 */
3410	while (*p != '\0') {
3411	cur = (struct path *) malloc(sizeof (struct path));
3412	debug(F101,"splitpath malloc","",cur);
3413	if (cur == NULL) {
3414	debug(F100,"splitpath malloc failure","",0);
3415	return((struct path *)NULL);
3416	}
3417	cur -> fwd = NULL;
3418	if (head == NULL)
3419	head = cur;
3420	else
3421	prv -> fwd = cur; /* link into chain */
3422	prv = cur;
3423	#ifdef aegis
3424	/* treat backslash as "../" */
3425	if (bslash && *p == bslash) {
3426	strcpy(cur->npart, "..");
3427	++p;
3428	} else {
3429	for (i=0; i < MAXNAMLEN && p && p != '/' && *p != bslash; i++)
3430	cur -> npart[i] = *p++;
3431	cur -> npart[i] = '\0'; /* end this segment */
3432	if (i >= MAXNAMLEN)
3433	while (p && p != '/' && *p != bslash)
3434	p++;
3435	}
3436	if (*p == '/') p++;
3437	#else
3438	#ifdef OS2
3439	for (i = 0;
3440	i < MAXNAMLEN && !ISDIRSEP(p) && p != ':' && *p != '\0';
3441	i++ )
3442	cur -> npart[i] = *p++;
3443	if ( *p == ':' ) {
3444	cur -> npart[i++] = *p++;
3445	if ( !ISDIRSEP(*p) )
3446	cur -> npart[i++] = '.';
3447	}
3448	#else
3449	for (i=0; i < MAXNAMLEN && !ISDIRSEP(p) && p != '\0'; i++) {
3450	cur -> npart[i] = *p++;
3451	}
3452	#endif /* OS2 */
3453	cur -> npart[i] = '\0'; /* end this segment */
3454	if (i >= MAXNAMLEN)
3455	while (!ISDIRSEP(p) && p != '\0') p++;
3456	if (ISDIRSEP(*p))
3457	p++;
3458
3459	#endif /* aegis */
3460	}
3461	return(head);
3462	}
3463
3464	/*
3465	* fgen:
3466	* This is the actual name generator. It is passed a string,
3467	* possibly containing wildcards, and an array of character pointers.
3468	* It finds all the matching filenames and stores pointers to them in the
3469	* array. The returned strings are allocated from a static buffer local to
3470	* this module (so the caller doesn't have to worry about deallocating
3471	* them); this means that successive calls to fgen will wipe out
3472	* the results of previous calls. This isn't a problem here
3473	* because we process one wildcard string at a time.
3474	*
3475	* Input: a wildcard string, an array to write names to, the
3476	* length of the array.
3477	* Returns: the number of matches. The array is filled with filenames
3478	* that matched the pattern. If there wasn't enough room in the
3479	* array, -1 is returned.
3480	* Originally by: Jeff Damens, CUCCA, 1984. Many changes since then.
3481	*/
3482	static int
3483	fgen(pat,resarry,len) char pat,resarry[]; int len; {
3484	struct path *head;
3485	char *sptr;
3486	#ifdef aegis
3487	char *namechars;
3488	int tilde = 0, bquote = 0;
3489
3490	if ((namechars = getenv("NAMECHARS")) != NULL) {
3491	if (xindex(namechars, '~' ) != NULL) tilde = '~';
3492	if (xindex(namechars, '\\') != NULL) bslash = '\\';
3493	if (xindex(namechars, '`' ) != NULL) bquote = '`';
3494	} else {
3495	tilde = '~'; bslash = '\\'; bquote = '`';
3496	}
3497	sptr = scratch;
3498
3499	/* copy "`node_data", etc. anchors */
3500	if (bquote && *pat == bquote)
3501	while (pat && pat != '/' && *pat != bslash)
3502	sptr++ = pat++;
3503	else if (tilde && *pat == tilde)
3504	sptr++ = pat++;
3505	while (*pat == '/')
3506	sptr++ = pat++;
3507	if (sptr == scratch) {
3508	strcpy(scratch,"./");
3509	sptr = scratch+2;
3510	} /* init buffer correctly */
3511	if (!(head = splitpath(pat))) return(-1);
3512	#else /* not aegis */
3513	debug(F110,"fgen pat",pat,0);
3514	#ifdef OS2
3515	head = splitpath(pat);
3516	#else /* not OS2 */
3517	if (!(head = splitpath(pat))) return(-1);
3518	#endif /* OS2 */
3519	sptr = scratch;
3520	if (!ISDIRSEP(*pat))
3521	sptr++ = '.'; / init buffer correctly */
3522	*sptr++ = DIRSEP;
3523	#ifdef OS2
3524	if (isalpha(pat[0]) && pat[1] == ':')
3525	sptr = scratch; /* reset in case of leading drive: */
3526	#endif /* OS2 */
3527	#endif /* aegis */
3528	numfnd = 0; /* none found yet */
3529	#ifdef DYNAMIC
3530	if (!sspace) { /* Need to allocate string space? */
3531	while (ssplen > 50) {
3532	if ((sspace = malloc(ssplen+2))) { /* Got it. */
3533	debug(F101,"fgen string space","",ssplen);
3534	break;
3535	}
3536	ssplen = (ssplen / 2) + (ssplen / 4); /* Didn't, reduce by 3/4 */
3537	}
3538	if (ssplen <= 50) { /* Did we get it? */
3539	fprintf(stderr,"fgen can't malloc string space\n");
3540	return(-1);
3541	}
3542	}
3543	#endif /* DYNAMIC */
3544	freeptr = sspace; /* this is where matches are copied */
3545	resptr = resarry; /* static copies of these so */
3546	remlen = len; /* recursive calls can alter them */
3547	traverse(head,scratch,sptr); /* go walk the directory tree */
3548	#ifdef COMMENT
3549	/*
3550	This code, circa 1984, has never worked right - it references the head
3551	pointer after it has already been freed. Lord knows what might have been
3552	happening because of this. Thanks to Steve Walton for finding & fixing
3553	this bug.
3554	*/
3555	for (; head != NULL; head = head -> fwd) {
3556	free(head); /* return the path segments */
3557	head = NULL;
3558	}
3559	#else
3560	while (head != NULL) {
3561	struct path *next = head -> fwd;
3562	free(head);
3563	head = next;
3564	}
3565	#endif /* COMMENT */
3566	return(numfnd); /* and return the number of matches */
3567	}
3568
3569	/* traverse:
3570	* Walks the directory tree looking for matches to its arguments.
3571	* The algorithm is, briefly:
3572	* If the current pattern segment contains no wildcards, that
3573	* segment is added to what we already have. If the name so far
3574	* exists, we call ourselves recursively with the next segment
3575	* in the pattern string; otherwise, we just return.
3576	*
3577	* If the current pattern segment contains wildcards, we open the name
3578	* we've accumulated so far (assuming it is really a directory), then read
3579	* each filename in it, and, if it matches the wildcard pattern segment, add
3580	* that filename to what we have so far and call ourselves recursively on the
3581	* next segment.
3582	*
3583	* Finally, when no more pattern segments remain, we add what's accumulated
3584	* so far to the result array and increment the number of matches.
3585	*
3586	* Input: a pattern path list (as generated by splitpath), a string
3587	* pointer that points to what we've traversed so far (this
3588	* can be initialized to "/" to start the search at the root
3589	* directory, or to "./" to start the search at the current
3590	* directory), and a string pointer to the end of the string
3591	* in the previous argument.
3592	* Returns: nothing.
3593	*/
3594	static VOID
3595	traverse(pl,sofar,endcur) struct path pl; char sofar, *endcur; {
3596
3597	/* Define LONGFN (long file names) automatically for BSD 2.9 and 4.2 */
3598	/* LONGFN can also be defined on the cc command line. */
3599
3600	#ifdef BSD29
3601	#ifndef LONGFN
3602	#define LONGFN
3603	#endif
3604	#endif
3605
3606	#ifdef BSD42
3607	#ifndef LONGFN
3608	#define LONGFN
3609	#endif
3610	#endif
3611
3612	/* Appropriate declarations for directory routines and structures */
3613	/* #define OPENDIR means to use opendir(), readdir(), closedir() */
3614	/* If OPENDIR not defined, we use open(), read(), close() */
3615
3616	#ifdef DIRENT /* New way, <dirent.h> */
3617	#define OPENDIR
3618	DIR fd, opendir();
3619	struct dirent *dirbuf;
3620	struct dirent *readdir();
3621	#else /* !DIRENT */
3622	#ifdef LONGFN /* Old way, <dir.h> with opendir() */
3623	#define OPENDIR
3624	DIR fd, opendir();
3625	struct direct *dirbuf;
3626	#else /* !LONGFN */
3627	int fd; /* Old way, <dir.h> with open() */
3628	struct direct dir_entry;
3629	struct direct *dirbuf = &dir_entry;
3630	#endif /* LONGFN */
3631	#endif /* DIRENT */
3632
3633	#ifdef NT
3634	struct _stat statbuf; /* for file info */
3635	#else /* NT */
3636	struct stat statbuf; /* for file info */
3637	#endif /* NT */
3638
3639	if (pl == NULL) {
3640	--endcur = '\0'; / end string, overwrite trailing / */
3641	addresult(sofar);
3642	return;
3643	}
3644	if (!iswild(pl -> npart)) {
3645	strcpy(endcur,pl -> npart);
3646	endcur += (int)strlen(pl -> npart);
3647	endcur = '\0'; / end current string */
3648	if (stat(sofar,&statbuf) == 0) { /* if current piece exists */
3649	#ifdef OS2
3650	if (endcur - sofar == 3 && endcur[-1] == '.' && endcur[-2] == ':')
3651	endcur--;
3652	else
3653	#endif /* OS2 */
3654	endcur++ = DIRSEP; / add slash to end */
3655	endcur = '\0'; / and end the string */
3656	traverse(pl -> fwd,sofar,endcur);
3657	}
3658	return;
3659	}
3660
3661	/* Segment contains wildcards, have to search directory */
3662
3663	endcur = '\0'; / end current string */
3664	if (stat(sofar,&statbuf) == -1) return; /* doesn't exist, forget it */
3665	if (!S_ISDIR (statbuf.st_mode)) return; /* not a directory, skip */
3666
3667	#ifdef OPENDIR
3668	if ((fd = opendir(sofar)) == NULL) return; /* Can't open, fail. */
3669	while (dirbuf = readdir(fd))
3670	#else /* !OPENDIR */
3671	if ((fd = open(sofar,O_RDONLY)) < 0) return; /* Can't open, fail. */
3672	while (read(fd, (char *)dirbuf, sizeof dir_entry))
3673	#endif /* OPENDIR */
3674	{
3675	/* Get null-terminated copy!!! */
3676	strncpy(nambuf,dirbuf->d_name,MAXNAMLEN);
3677	nambuf[MAXNAMLEN] = '\0';
3678	#ifdef unos
3679	if (dirbuf->d_ino != -1 && match(pl -> npart,nambuf))
3680	#else
3681	/* #ifdef _POSIX_SOURCE */
3682	/*
3683	Directory reading is not specified in POSIX.1. POSIX.2 gives us glob() and
3684	fnmatch(), which are not yet supported by C-Kermit. Meanwhile, maybe POSIX
3685	implementations should force "set wildcard shell" and remove all of this
3686	code.
3687	*/
3688	#ifdef QNX
3689	if (dirbuf->d_stat.st_ino != 0 && match(pl -> npart,nambuf))
3690	#else
3691	#ifdef SOLARIS
3692	if (dirbuf->d_ino != 0 && match(pl -> npart,nambuf))
3693	#else
3694	#ifdef sun
3695	if (dirbuf->d_fileno != 0 && match(pl -> npart,nambuf))
3696	#else
3697	#ifdef bsdi
3698	if (dirbuf->d_fileno != 0 && match(pl -> npart,nambuf))
3699	#else
3700	#ifdef __386BSD__
3701	if (dirbuf->d_fileno != 0 && match(pl -> npart,nambuf))
3702	#else
3703	#ifdef __FreeBSD__
3704	if (dirbuf->d_fileno != 0 && match(pl -> npart,nambuf))
3705	#else
3706	#ifdef ultrix
3707	if (dirbuf->gd_ino != 0 && match(pl -> npart,nambuf))
3708	#else
3709	#ifdef Plan9
3710	if (match(pl->npart,nambuf))
3711	#else
3712	if (dirbuf->d_ino != 0 && match(pl -> npart,nambuf))
3713	#endif /* Plan9 */
3714	#endif /* ultrix */
3715	#endif /* __FreeBSD__ */
3716	#endif /* __386BSD__ */
3717	#endif /* bsdi */
3718	#endif /* sun */
3719	#endif /* SOLARIS */
3720	#endif /* QNX */
3721
3722	/* #else / / not _POSIX_SOURCE */
3723	/* if (dirbuf->d_ino != 0 && match(pl -> npart,nambuf)) */
3724	/* #endif / / _POSIX_SOURCE */
3725
3726	#endif /* unos */
3727	{
3728	char *eos;
3729	strcpy(endcur,nambuf);
3730	eos = endcur + (int)strlen(nambuf);
3731	eos++ = DIRSEP; / end this segment */
3732	traverse(pl -> fwd,sofar,eos);
3733	}
3734	}
3735	#ifdef OPENDIR
3736	closedir(fd);
3737	#else /* !OPENDIR */
3738	close(fd);
3739	#endif /* OPENDIR */
3740	}
3741
3742	/*
3743	* addresult:
3744	* Adds a result string to the result array. Increments the number
3745	* of matches found, copies the found string into our string
3746	* buffer, and puts a pointer to the buffer into the caller's result
3747	* array. Our free buffer pointer is updated. If there is no
3748	* more room in the caller's array, the number of matches is set to -1.
3749	* Input: a result string.
3750	* Returns: nothing.
3751	*/
3752	static VOID
3753	addresult(str) char *str; {
3754	int l;
3755	debug(F111,"addresult",str,remlen);
3756	if (str[0] == '.' && ISDIRSEP(str[1])) str += 2; /* (===OS2 change===) */
3757	if (--remlen < 0) {
3758	numfnd = -1;
3759	return;
3760	}
3761	l = (int)strlen(str) + 1; /* size this will take up */
3762	if ((freeptr + l) > (sspace + ssplen)) {
3763	numfnd = -1; /* do not record if not enough space */
3764	return;
3765	}
3766	strcpy(freeptr,str);
3767	*resptr++ = freeptr;
3768	freeptr += l;
3769	numfnd++;
3770	}
3771
3772	/*
3773	* match:
3774	* pattern matcher. Takes a string and a pattern possibly containing
3775	* the wildcard characters '*' and '?'. Returns true if the pattern
3776	* matches the string, false otherwise.
3777	* by: Jeff Damens, CUCCA, 1984
3778	* skipping over dot files and backslash quoting added by fdc, 1990.
3779	*
3780	* Input: a string and a wildcard pattern.
3781	* Returns: 1 if match, 0 if no match.
3782	*/
3783	static int
3784	match(pattern,string) char pattern,string; {
3785	char psave,ssave; /* back up pointers for failure */
3786	int q = 0; /* quote flag */
3787
3788	debug(F110,"match str",string,0);
3789	psave = ssave = NULL;
3790	#ifndef MATCHDOT
3791	if (string == '.' && pattern != '.') {
3792	debug(F110,"match skip",string,0);
3793	return(0);
3794	}
3795	#endif
3796	while (1) {
3797	#ifdef OS2
3798	for (; tolower(pattern) == tolower(string); pattern++,string++)
3799	#else
3800	for (; pattern == string; pattern++,string++) /* skip first */
3801	#endif /* OS2 */
3802	if (string == '\0') return(1); / end of strings, succeed */
3803
3804	if (pattern == '\\' && q == 0) { / Watch out for quoted */
3805	q = 1; /* metacharacters */
3806	pattern++; /* advance past quote */
3807	if (pattern != string) return(0);
3808	continue;
3809	} else q = 0;
3810
3811	if (q) {
3812	return(0);
3813	} else {
3814	if (string != '\0' && pattern == '?') {
3815	pattern++; /* '?', let it match */
3816	string++;
3817	} else if (pattern == '') { /* '' ... /
3818	psave = ++pattern; /* remember where we saw it */
3819	ssave = string; /* let it match 0 chars */
3820	} else if (ssave != NULL && ssave != '\0') { / if not at end */
3821	/* ...have seen a star */
3822	string = ++ssave; /* skip 1 char from string */
3823	pattern = psave; /* and back up pattern */
3824	} else return(0); /* otherwise just fail */
3825	}
3826	}
3827	}
3828
3829	/*
3830	The following two functions are for expanding tilde in filenames
3831	Contributed by Howie Kaye, CUCCA, developed for CCMD package.
3832	*/
3833
3834	/* W H O A M I -- Get user's username. */
3835
3836	/*
3837	1) Get real uid
3838	2) See if the $USER environment variable is set ($LOGNAME on AT&T)
3839	3) If $USER's uid is the same as ruid, realname is $USER
3840	4) Otherwise get logged in user's name
3841	5) If that name has the same uid as the real uid realname is loginname
3842	6) Otherwise, get a name for ruid from /etc/passwd
3843	*/
3844	static char *
3845	whoami () {
3846	#ifdef DTILDE
3847	#ifdef pdp11
3848	#define WHOLEN 100
3849	#else
3850	#define WHOLEN 257
3851	#endif /* pdp11 */
3852	static char realname[256]; /* user's name */
3853	static int ruid = -1; /* user's real uid */
3854	char loginname[256], envname[256]; /* temp storage */
3855	char *c;
3856	struct passwd *p;
3857	_PROTOTYP(extern char * getlogin, (void) );
3858
3859	if (ruid != -1)
3860	return(realname);
3861
3862	ruid = real_uid(); /* get our uid */
3863
3864	/* how about $USER or $LOGNAME? */
3865	if ((c = getenv(NAMEENV)) != NULL) { /* check the env variable */
3866	strcpy (envname, c);
3867	if ((p = getpwnam(envname)) != NULL) {
3868	if (p->pw_uid == ruid) { /* get passwd entry for envname */
3869	strcpy (realname, envname); /* if the uid's are the same */
3870	return(realname);
3871	}
3872	}
3873	}
3874
3875	/* can we use loginname() ? */
3876
3877	if ((c = getlogin()) != NULL) { /* name from utmp file */
3878	strcpy (loginname, c);
3879	if ((p = getpwnam(loginname)) != NULL) /* get passwd entry */
3880	if (p->pw_uid == ruid) { /* for loginname */
3881	strcpy (realname, loginname); /* if the uid's are the same */
3882	return(realname);
3883	}
3884	}
3885
3886	/* Use first name we get for ruid */
3887
3888	if ((p = getpwuid(ruid)) == NULL) { /* name for uid */
3889	realname[0] = '\0'; /* no user name */
3890	ruid = -1;
3891	return(NULL);
3892	}
3893	strcpy (realname, p->pw_name);
3894	return(realname);
3895	#else
3896	return(NULL);
3897	#endif /* DTILDE */
3898	}
3899
3900	/* T I L D E _ E X P A N D -- expand ~user to the user's home directory. */
3901
3902	char *
3903	tilde_expand(dirname) char *dirname; {
3904	#ifdef DTILDE
3905	#ifdef pdp11
3906	#define BUFLEN 100
3907	#else
3908	#define BUFLEN 257
3909	#endif /* pdp11 */
3910	struct passwd *user;
3911	static char olddir[BUFLEN];
3912	static char oldrealdir[BUFLEN];
3913	static char temp[BUFLEN];
3914	int i, j;
3915
3916	debug(F111,"tilde_expand",dirname,dirname[0]);
3917
3918	if (dirname[0] != '~') /* Not a tilde...return param */
3919	return(dirname);
3920	if (!strcmp(olddir,dirname)) { /* Same as last time */
3921	return(oldrealdir); /* so return old answer. */
3922	} else {
3923	j = (int)strlen(dirname);
3924	for (i = 0; i < j; i++) /* find username part of string */
3925	if (!ISDIRSEP(dirname[i]))
3926	temp[i] = dirname[i];
3927	else break;
3928	temp[i] = '\0'; /* tie off with a NULL */
3929	if (i == 1) { /* if just a "~" */
3930	user = getpwnam(whoami()); /* get info on current user */
3931	} else {
3932	user = getpwnam(&temp[1]); /* otherwise on the specified user */
3933	}
3934	}
3935	if (user != NULL) { /* valid user? */
3936	strcpy(olddir, dirname); /* remember the directory */
3937	strcpy(oldrealdir,user->pw_dir); /* and their home directory */
3938	strcat(oldrealdir,&dirname[i]);
3939	return(oldrealdir);
3940	} else { /* invalid? */
3941	strcpy(olddir, dirname); /* remember for next time */
3942	strcpy(oldrealdir, dirname);
3943	return(oldrealdir);
3944	}
3945	#else
3946	return(NULL);
3947	#endif /* DTILDE */
3948	}
3949
3950	/*
3951	Functions for executing system commands.
3952	zsyscmd() executes the system command in the normal, default way for
3953	the system. In UNIX, it does what system() does. Thus, its results
3954	are always predictable.
3955	zshcmd() executes the command using the user's preferred shell.
3956	*/
3957	int
3958	zsyscmd(s) char *s; {
3959	#ifdef aegis
3960	if (!priv_chk()) return(system(s));
3961	#else
3962	#ifdef OS2
3963	/*
3964	We must set the priority back to normal. Otherwise all of children
3965	processes are going to inherit our FOREGROUNDSERVER priority
3966	and that would not be good for the system or ourselves.
3967	*/
3968
3969	if (!priv_chk()) {
3970	ULONG rc = 0;
3971	#ifndef KUI
3972	char title[80];
3973	title[0] = '\0';
3974	os2gettitle( title, 80 );
3975	RequestScreenMutex(SEM_INDEFINITE_WAIT);
3976	#endif /* KUI */
3977	KbdHandlerCleanup();
3978	ResetThreadPrty();
3979	rc = system(s);
3980	SetThreadPrty(priority,15);
3981	KbdHandlerInit();
3982	#ifndef KUI
3983	if (
3984	#ifndef NOSPL
3985	cmdlvl == 0
3986	#else
3987	tlevel < 0
3988	#endif /* NOSPL */
3989	)
3990	OS2WaitForKey();
3991	ReleaseScreenMutex();
3992	os2settitle( title, FALSE );
3993	#endif /* KUI */
3994	return rc;
3995	}
3996	return 0;
3997	#else
3998	PID_T shpid;
3999	#ifdef COMMENT
4000	/* This doesn't work... */
4001	WAIT_T status;
4002	#else
4003	int status;
4004	#endif /* COMMENT */
4005
4006	if (shpid = fork()) {
4007	if (shpid < (PID_T)0) return(-1); /* Parent */
4008	while (shpid != (PID_T) wait(&status))
4009	;
4010	return(status);
4011	}
4012	if (priv_can()) { /* Child: cancel any priv's */
4013	printf("?Privilege cancellation failure\n");
4014	_exit(255);
4015	}
4016	#ifdef HPUX10
4017	execl("/usr/bin/sh","sh","-c",s,NULL);
4018	perror("/usr/bin/sh");
4019	#else
4020	#ifdef Plan9
4021	execl("/bin/rc", "rc", "-c", s, NULL);
4022	perror("/bin/rc");
4023	#else
4024	execl("/bin/sh","sh","-c",s,NULL);
4025	perror("/bin/sh");
4026	#endif /* Plan9 */
4027	#endif /* HPUX10 */
4028	_exit(255);
4029	return(0); /* Shut up ANSI compilers. */
4030	#endif /* OS2 */
4031	#endif /* aegis */
4032	}
4033
4034	/*
4035	UNIX code by H. Fischer; copyright rights assigned to Columbia Univ.
4036	Adapted to use getpwuid to find login shell because many systems do not
4037	have SHELL in environment, and to use direct calling of shell rather
4038	than intermediate system() call. -- H. Fischer
4039	Call with s pointing to command to execute.
4040	*/
4041
4042	int
4043	zshcmd(s) char *s; {
4044	PID_T pid;
4045
4046	#ifdef OS2
4047	int rc;
4048	char title[80];
4049	#ifdef NT
4050	SIGTYP (* savint)(int);
4051	#endif /* NT */
4052	char *shell = getenv("SHELL");
4053	if ( !shell )
4054	shell = getenv("COMSPEC");
4055
4056	if (!priv_chk()) {
4057	#ifndef KUI
4058	os2gettitle( title, 80 );
4059	RequestScreenMutex(SEM_INDEFINITE_WAIT);
4060	#endif /* KUI */
4061	KbdHandlerCleanup();
4062	ResetThreadPrty();
4063	#ifdef NT
4064	savint = signal( SIGINT, SIG_IGN );
4065	#endif /* NT */
4066
4067	if (!s \|\| *s == '\0')
4068	rc = system(shell) == 0; /* was _spawnlp(P_WAIT, shell, NULL) */
4069	else
4070	rc = system(s) == 0;
4071	#ifdef NT
4072	signal( SIGINT, savint );
4073	#endif /* NT */
4074
4075	SetThreadPrty(priority,15);
4076	KbdHandlerInit();
4077	#ifndef KUI
4078	if (
4079	#ifndef NOSPL
4080	cmdlvl == 0
4081	#else /* NOSPL */
4082	tlevel < 0
4083	#endif /* NOSPL */
4084	)
4085	OS2WaitForKey();
4086	ReleaseScreenMutex();
4087	os2settitle( title, FALSE );
4088	#endif /* KUI */
4089	return(rc);
4090	}
4091	return(0);
4092	#else /* OS2 */
4093	#ifdef AMIGA
4094	if (!priv_chk()) system(s);
4095	#else
4096	#ifdef datageneral
4097	if (priv_chk) return(1);
4098	if (s == '\0') / Interactive shell requested? */
4099	#ifdef mvux
4100	system("/bin/sh ");
4101	#else
4102	system("x :cli prefix Kermit_Baby:");
4103	#endif /* mvux */
4104	else /* Otherwise, */
4105	system(s); /* Best for aos/vs?? */
4106
4107	#else
4108	#ifdef aegis
4109	if ((pid = vfork()) == 0) { /* Make child quickly */
4110	char shpath, shname, shptr; / For finding desired shell */
4111
4112	if (priv_can()) exit(1); /* Turn off privs. */
4113	if ((shpath = getenv("SHELL")) == NULL) shpath = "/com/sh";
4114
4115	#else /* All Unix systems */
4116	if ((pid = fork()) == 0) { /* Make child */
4117	char shpath, shname, shptr; / For finding desired shell */
4118	struct passwd *p;
4119	#ifdef HPUX10 /* Default */
4120	char *defshell = "/usr/bin/sh";
4121	#else
4122	#ifdef Plan9
4123	char *defshell = "/bin/rc";
4124	#else
4125	char *defshell = "/bin/sh";
4126	#endif /* Plan9 */
4127	#endif /* HPUX10 */
4128	if (priv_can()) exit(1); /* Turn off privs. */
4129	#ifdef COMMENT
4130	/* Old way always used /etc/passwd shell */
4131	p = getpwuid(real_uid()); /* Get login data */
4132	if (p == (struct passwd ) NULL \|\| !(p->pw_shell))
4133	shpath = defshell;
4134	else
4135	shpath = p->pw_shell;
4136	#else
4137	/* New way lets user override with SHELL variable, but does not rely on it. */
4138	/* This allows user to specify a different shell. */
4139	shpath = getenv("SHELL"); /* What shell? */
4140	if (shpath == NULL) {
4141	p = getpwuid( real_uid() ); /* Get login data */
4142	if (p == (struct passwd )NULL \|\| !(p->pw_shell))
4143	shpath = defshell;
4144	else shpath = p->pw_shell;
4145	}
4146	#endif /* COMMENT */
4147	#endif /* aegis */
4148	shptr = shname = shpath;
4149	while (*shptr != '\0')
4150	if (*shptr++ == DIRSEP)
4151	shname = shptr;
4152	if (s == NULL \|\| s == '\0') { / Interactive shell requested? */
4153	execl(shpath,shname,"-i",NULL); /* Yes, do that */
4154	} else { /* Otherwise, */
4155	execl(shpath,shname,"-c",s,NULL); /* exec the given command */
4156	} /* If execl() failed, */
4157	exit(BAD_EXIT); /* return bad return code. */
4158
4159	} else { /* Parent */
4160
4161	int wstat; /* ... must wait for child */
4162	int child; /* Child's exit status */
4163	SIGTYP (istat)(), (qstat)();
4164
4165	if (pid == (PID_T) -1) return(-1); /* fork() failed? */
4166
4167	istat = signal(SIGINT,SIG_IGN); /* Let the fork handle keyboard */
4168	qstat = signal(SIGQUIT,SIG_IGN); /* interrupts itself... */
4169
4170	#ifdef UNIX
4171	#define CK_CHILD /* Assume this is safe in UNIX */
4172	#endif /* UNIX */
4173
4174	#ifdef CK_CHILD
4175	while (((wstat = wait(&child)) != pid) && (wstat != -1))
4176	#else
4177	while (((wstat = wait((WAIT_T *)0)) != pid) && (wstat != -1))
4178	#endif /* CK_CHILD */
4179	; /* Wait for fork */
4180	signal(SIGINT,istat); /* Restore interrupts */
4181	signal(SIGQUIT,qstat);
4182	#ifdef CK_CHILD
4183	return(child == 0 ? 1 : 0); /* Return child's status */
4184	#endif /* CK_CHILD */
4185	}
4186	#endif
4187	#endif
4188	#endif /* OS2 */
4189	return(1);
4190	}
4191
4192	#ifdef aegis
4193	/*
4194	Replacement for strchr() and index(), neither of which seem to be universal.
4195	*/
4196	static char *
4197	#ifdef CK_ANSIC
4198	xindex(char * s, char c)
4199	#else
4200	xindex(s,c) char *s, c;
4201	#endif /* CK_ANSIC */
4202	/* xindex */ {
4203	while (s != '\0' && s != c) s++;
4204	if (*s == c) return(s); else return(NULL);
4205	}
4206	#endif /* aegis */
4207
4208	/* I S W I L D -- Check if filespec is "wild" */
4209
4210	/*
4211	Returns 0 if it is a single file, 1 if it contains wildcard characters.
4212	Note: must match the algorithm used by match(), hence no [a-z], etc.
4213	*/
4214	int
4215	iswild(filespec) char *filespec; {
4216	char c; int x; char *p;
4217	if (wildxpand) {
4218	if ((x = zxpand(filespec)) > 1) return(1);
4219	if (x == 0) return(0); /* File does not exist */
4220	p = malloc(MAXNAMLEN + 20);
4221	znext(p);
4222	#ifdef OS2
4223	x = (
4224	#ifdef NT
4225	_stricmp(filespec,p)
4226	#else
4227	stricmp(filespec,p)
4228	#endif /* NT */
4229	!= 0);
4230	#else
4231	x = (strcmp(filespec,p) != 0);
4232	#endif /* OS2 */
4233	free(p);
4234	p = NULL;
4235	return(x);
4236	} else {
4237	while ((c = *filespec++) != '\0')
4238	if (c == '*' \|\| c == '?') return(1);
4239	return(0);
4240	}
4241	}
4242
4243	/*
4244	Tell if string pointer s is the name of an existing directory.
4245	Returns 1 if directory, 0 if not a directory.
4246	*/
4247	int
4248	isdir(s) char *s; {
4249	int x;
4250	#ifdef NT
4251	struct _stat statbuf;
4252	#else /* NT */
4253	struct stat statbuf;
4254	#endif /* NT */
4255
4256
4257	if (!s) return(0);
4258	if (!*s) return(0);
4259
4260	#ifdef OS2
4261	/* Disk letter like A: is top-level directory on a disk */
4262	if (((int)strlen(s) == 2) && (isalpha(s)) && ((s+1) == ':'))
4263	return(1);
4264	#endif /* OS2 */
4265	x = stat(s,&statbuf);
4266	debug(F111,"isdir stat",s,x);
4267	if (x == -1) {
4268	debug(F101,"isdir errno","",errno);
4269	return(0);
4270	} else {
4271	debug(F101,"isdir statbuf.st_mode","",statbuf.st_mode);
4272	return( S_ISDIR (statbuf.st_mode) ? 1 : 0 );
4273	}
4274	}
4275
4276	#ifdef CK_MKDIR
4277	/* Some systems don't have mkdir(), e.g. Tandy Xenix 3.2.. */
4278
4279	/* Z M K D I R -- Create directory(s) if necessary */
4280	/*
4281	Call with:
4282	A pointer to a file specification that might contain directory
4283	information. The filename is expected to be included.
4284	If the file specification does not include any directory separators,
4285	then it is assumed to be a plain file.
4286	If one or more directories are included in the file specification,
4287	this routine tries to create them if they don't already exist.
4288	Returns:
4289	0 on success, i.e. the directory was created
4290	-1 on failure to create the directory
4291	*/
4292	int
4293	zmkdir(path) char *path; {
4294	char xp, tp, c;
4295	int x;
4296
4297	x = strlen(path);
4298	debug(F111,"zmkdir",path,x);
4299	if (x < 1 \|\| x > MAXPATH) /* Check length */
4300	return(-1);
4301	if (!(tp = malloc(x+1))) /* Make a temporary copy */
4302	return(-1);
4303	strcpy(tp,path);
4304	#ifdef DTILDE
4305	if (tp == '~') { / Starts with tilde? */
4306	xp = tilde_expand(tp); /* Attempt to expand tilde */
4307	if (*xp) {
4308	char *zp;
4309	debug(F110,"zmkdir tilde_expand",xp,0);
4310	if (!(zp = malloc(strlen(xp) + 1))) { /* Make a place for it */
4311	free(tp);
4312	tp = NULL;
4313	return(-1);
4314	}
4315	free(tp); /* Free previous buffer */
4316	tp = zp; /* Point to new one */
4317	strcpy(tp,xp); /* Copy expanded name to new buffer */
4318	}
4319	debug(F110,"zmkdir tp after tilde_expansion",tp,0);
4320	}
4321	#endif /* DTILDE */
4322	xp = tp;
4323	if (ISDIRSEP(xp)) / Don't create root directory! */
4324	xp++;
4325
4326	/* Go thru filespec from left to right... */
4327
4328	for (; xp; xp++) { / Create parts that don't exist */
4329	if (!ISDIRSEP(xp)) / Find next directory separator */
4330	continue;
4331	c = xp; / Got one. */
4332	xp = NUL; / Make this the end of the string. */
4333	if (!isdir(tp)) { /* This directory exists already? */
4334	debug(F110,"zmkdir making",tp,0);
4335	x = /* No, try to create it */
4336	#ifdef NOMKDIR
4337	-1 /* Systems without mkdir() */
4338	#else
4339	#ifdef OS2 /* OS/2 */
4340	_mkdir(tp) /* The IBM way */
4341	#else
4342	mkdir(tp,0777) /* UNIX */
4343	#endif /* OS2 */
4344	#endif /* NOMKDIR */
4345	;
4346	if (x < 0) {
4347	debug(F101,"zmkdir failed, errno","",errno);
4348	free(tp); /* Free temporary buffer. */
4349	tp = NULL;
4350	return(-1); /* Freturn failure code. */
4351	}
4352	}
4353	xp = c; / Replace the separator. */
4354	}
4355	free(tp); /* Free temporary buffer. */
4356	return(0); /* Return success code. */
4357	}
4358	#endif /* CK_MKDIR */
4359
4360	/* Z F S E E K -- Position input file pointer */
4361	/*
4362	Call with:
4363	Long int, 0-based, indicating desired position.
4364	Returns:
4365	0 on success.
4366	-1 on failure.
4367	*/
4368	#ifndef NORESEND
4369	int
4370	#ifdef CK_ANSIC
4371	zfseek(long pos)
4372	#else
4373	zfseek(pos) long pos;
4374	#endif /* CK_ANSIC */
4375	/* zfseek */ {
4376	#ifdef NT
4377	fpos_t fpos = pos ;
4378	#endif /* NT */
4379
4380	zincnt = -1 ; /* must empty the input buffer */
4381
4382	debug(F101,"zfseek","",pos);
4383	#ifdef NT
4384	return(fsetpos(fp[ZIFILE], &fpos)?-1:0);
4385	#else
4386	return(fseek(fp[ZIFILE], pos, 0)?-1:0);
4387	#endif
4388	}
4389	#endif /* NORESEND */
4390
4391	struct zfnfp *
4392	zfnqfp(fname, buflen, buf) char * fname; int buflen; char * buf; {
4393	int x = 0, y = 0;
4394	char * xp;
4395	static struct zfnfp fnfp;
4396
4397	if (!fname)
4398	return(NULL);
4399
4400	/* initialize the data structure */
4401	fnfp.len = buflen;
4402	fnfp.fpath = buf;
4403	fnfp.fname = NULL;
4404
4405	#ifdef OS2
4406	#ifdef NT
4407	if ( GetFullPathName( fname, buflen, fnfp.fpath, &fnfp.fname ) )
4408	return(&fnfp);
4409	else
4410	#else /* NT */
4411	if (!DosQueryPathInfo(fname,5 /* Full Path Info */, fnfp.fpath,buflen)) {
4412	x = strlen(fnfp.fpath);
4413	for (x = x + 1; x >= 0; x--) /* Find where the filename starts */
4414	if (fnfp.fpath[x] == '/'
4415	\|\| fnfp.fpath[x] == '\\'
4416	) /* There is guaranteed to be one */
4417	fnfp.fname = fnfp.fpath + x; /* Got it, set pointer */
4418	return(&fnfp); /* and return. */
4419	} else
4420	#endif /* NT */
4421	#else /* OS2 */
4422
4423	#ifdef DTILDE
4424	if (fname == '~') { / Starts with tilde? */
4425	xp = tilde_expand(fname); /* Attempt to expand tilde */
4426	if (*xp)
4427	fname = xp;
4428	}
4429	#endif /* DTILDE */
4430
4431	if (*fname == '/'
4432	) { /* Pathname is absolute */
4433	strncpy(buf,fname,buflen);
4434	x = strlen(buf);
4435	y = 0;
4436	} else { /* Pathname is relative */
4437	char * p;
4438	if (p = zgtdir()) { /* So get current directory */
4439	strncpy(buf,p,buflen);
4440	x = strlen(buf);
4441	buf[x++] = '/';
4442	buflen -= x; /* How much room left in buffer */
4443	if ((y = (int)strlen(fname)) > buflen) /* If enough room... */
4444	return(NULL);
4445	strncpy(buf+x,fname,buflen); /* ... append the filename */
4446	} else {
4447	return(NULL);
4448	}
4449	}
4450
4451	for (x = x + y - 1; x > -1; x--) /* Find where the filename starts */
4452	if (buf[x] == '/'
4453	) { /* There is guaranteed to be one */
4454	fnfp.fname = buf + x; /* Got it, set pointer */
4455	return(&fnfp); /* and return. */
4456	}
4457	#endif /* OS2 */
4458	return(NULL);
4459	}
4460
4461	#ifdef OS2
4462
4463	/* Z C H D S K -- Change currently selected disk device */
4464
4465	/* Returns -1 if error, otherwise 0 */
4466
4467	zchdsk(c) int c; {
4468	int i = toupper(c) - 64;
4469	return( _chdrive(i));
4470	}
4471
4472	#undef stat
4473	#ifdef __IBMC__STAT
4474	#define stat(p, s) _stat(p, s)
4475	#endif /* __IBMC__STAT */
4476
4477	os2stat(char *path,
4478	#ifdef NT
4479	struct _stat *st
4480	#else
4481	struct stat *st
4482	#endif /* NT */
4483	) {
4484	char local[MAXPATH];
4485	int len;
4486
4487	strcpy(local, path);
4488	len = strlen(local);
4489
4490	if ( len == 2 && local[1] == ':' )
4491	local[2] = DIRSEP, local[3] = 0; /* if drive only, append / */
4492	else if ( len == 0 )
4493	local[0] = DIRSEP, local[1] = 0; /* if empty path, take / instead */
4494	else if ( len > 1 && ISDIRSEP(local[len - 1]) && local[len - 2] != ':' )
4495	local[len - 1] = 0; /* strip trailing / except after d: */
4496
4497	#ifdef NT
4498	return _stat(local, st);
4499	#else /* NT */
4500	return stat(local, st);
4501	#endif /* NT */
4502	}
4503
4504	#ifdef CK_LABELED
4505	/* O S 2 S E T L O N G N A M E -- Set .LONGNAME Extended Attribute */
4506
4507	/* Returns -1 if error, otherwise 0 */
4508
4509	int
4510	os2setlongname( char * fn, char * ln ) {
4511	EAOP2 FileInfoBuf;
4512	ULONG FileInfoSize;
4513	ULONG PathInfoFlags;
4514	APIRET rc;
4515	char FEA2List[1024];
4516	FEA2 * pfea2;
4517	WORD * pEAdata;
4518
4519	debug(F110,"os2setlongname: filename is",fn,0);
4520	debug(F110,"os2setlongname: longname is",ln,0);
4521
4522	FileInfoSize = sizeof( EAOP2 );
4523	PathInfoFlags = DSPI_WRTTHRU; /* complete write operation before return */
4524
4525	FileInfoBuf.fpGEA2List = 0;
4526	FileInfoBuf.fpFEA2List = (PFEA2LIST) &FEA2List;
4527	pfea2 = FileInfoBuf.fpFEA2List->list;
4528
4529	pfea2->oNextEntryOffset = 0;
4530	pfea2->fEA = 0;
4531	pfea2->cbName = 9; /* length of ".LONGNAME" without \0 */
4532	pfea2->cbValue = strlen( ln ) + 2 * sizeof( WORD );
4533	strcpy( pfea2->szName, ".LONGNAME" );
4534
4535	pEAdata = (WORD *) pfea2->szName + 10/sizeof(WORD);
4536	*pEAdata = EAT_ASCII;
4537	pEAdata++;
4538	*pEAdata = strlen( ln );
4539	pEAdata++;
4540	strcpy( (char *) pEAdata, ln );
4541	pEAdata += (strlen( ln )+1)/sizeof(WORD);
4542
4543	FileInfoBuf.fpFEA2List->cbList = (char *) pEAdata -
4544	(char *) FileInfoBuf.fpFEA2List;
4545
4546	rc = DosSetPathInfo( fn, 2, &FileInfoBuf, FileInfoSize, PathInfoFlags );
4547	debug(F101,"os2setlongname: rc=","",rc);
4548	if ( !rc )
4549	return 0;
4550	else
4551	return -1;
4552	}
4553
4554	/* O S 2 G E T L O N G N A M E -- Get .LONGNAME Extended Attribute */
4555
4556	/* Returns -1 if error, otherwise 0 */
4557
4558	int
4559	os2getlongname( char * fn, char ** ln ) {
4560	static char * LongNameBuf = 0;
4561	EAOP2 FileInfoBuf;
4562	ULONG FileInfoSize;
4563	ULONG PathInfoFlags;
4564	APIRET rc;
4565	char FEA2List[1024];
4566	FEA2 * pfea2;
4567	char GEA2List[1024];
4568	GEA2 * pgea2;
4569	WORD * pEAdata;
4570	WORD LongNameLength;
4571
4572	*ln = 0;
4573	if ( !LongNameBuf )
4574	LongNameBuf = strdup( "Initialization of LongNameBuf" );
4575	debug(F110,"os2getlongname: filename is",fn,0);
4576
4577	FileInfoSize = sizeof( EAOP2 );
4578	PathInfoFlags = DSPI_WRTTHRU; /* Complete write operation before return */
4579
4580	FileInfoBuf.fpGEA2List = (PGEA2LIST) &GEA2List;
4581	FileInfoBuf.fpFEA2List = (PFEA2LIST) &FEA2List;
4582	pgea2 = FileInfoBuf.fpGEA2List->list;
4583	pfea2 = FileInfoBuf.fpFEA2List->list;
4584
4585	pfea2->oNextEntryOffset = 0;
4586	pfea2->fEA = 0;
4587	pfea2->cbName = 9; /* Length of ".LONGNAME" without \0 */
4588	pfea2->cbValue = MAXPATH;
4589	strcpy( pfea2->szName, ".LONGNAME" );
4590
4591	FileInfoBuf.fpGEA2List->cbList = sizeof(GEA2LIST)
4592	+ pgea2->cbName + 1;
4593	pgea2->oNextEntryOffset = 0;
4594	pgea2->cbName = pfea2->cbName;
4595	strcpy(pgea2->szName,pfea2->szName);
4596
4597	FileInfoBuf.fpFEA2List->cbList = 1024;
4598
4599	rc = DosQueryPathInfo(fn,FIL_QUERYEASFROMLIST,&FileInfoBuf,FileInfoSize );
4600	LongNameLength =
4601	(WORD )((char *)pfea2 + sizeof(FEA2) + pfea2->cbName + sizeof(WORD));
4602	debug(F101,"os2getlongname: rc=","",rc);
4603	debug(F101," cbValue:","",pfea2->cbValue);
4604	debug(F101," cbName:","",pfea2->cbName);
4605	debug(F101," EA Value Length:","",LongNameLength );
4606	debug(F110," EA Value:",(char *)pfea2 + sizeof(FEA2)
4607	+ pfea2->cbName + (2 * sizeof(WORD)),0 );
4608	if ( rc ) {
4609	return -1;
4610	} else if ( pfea2->cbValue ) {
4611	if (LongNameBuf) {
4612	free(LongNameBuf);
4613	LongNameBuf = NULL;
4614	}
4615	LongNameBuf = (char *) malloc( LongNameLength + 1 );
4616	if (LongNameBuf) {
4617	strncpy(LongNameBuf, (char *)pfea2 + sizeof(FEA2)
4618	+ pfea2->cbName + (2 * sizeof(WORD)),
4619	LongNameLength
4620	);
4621	LongNameBuf[LongNameLength] = '\0';
4622	debug(F110,"os2getlongname: longname is",LongNameBuf,0);
4623	} else
4624	debug(F100,"os2getlongname: malloc failed","",0);
4625	} else {
4626	if ( LongNameBuf )
4627	free( LongNameBuf );
4628	LongNameBuf = strdup( "" );
4629	debug(F110,
4630	"os2getlongname: there is no longname attribute",
4631	LongNameBuf,
4632	0
4633	);
4634	}
4635	*ln = LongNameBuf;
4636	return 0;
4637	}
4638
4639
4640	_PROTOTYP( VOID GetMem, (PVOID *, ULONG) );
4641
4642	/* O S 2 G E T E A S - Get all OS/2 Extended Attributes */
4643
4644	/* Returns 0 on success, -1 on failure */
4645
4646	int
4647	os2geteas( char * name ) {
4648	CHAR pAllocc=NULL; / Holds the FEA struct returned by DosEnumAttribute */
4649	/* used to create the GEA2LIST for DosQueryPathInfo */
4650
4651	ULONG ulEntryNum = 1; /* count of current EA to read (1-relative) */
4652	ULONG ulEnumCnt; /* Number of EAs for Enum to return, always 1 */
4653
4654	ULONG FEAListSize = sizeof(ULONG);/* starting size of buffer necessary to
4655	hold all FEA blocks */
4656	ULONG GEAListSize = MAXEACOUNT * sizeof(GEA2) + sizeof(ULONG);
4657
4658	FEA2 pFEA; / Used to read from Enum's return buffer */
4659	GEA2 pGEA, pLastGEAIn; /* Used to write to pGEAList buffer */
4660	GEA2LIST pGEAList;/Ptr used to set up buffer for DosQueryPathInfo call */
4661	EAOP2 eaopGet; /* Used to call DosQueryPathInfo */
4662	APIRET rc;
4663	int offset;
4664
4665	/* Allocate enough room for any GEA List */
4666	GetMem((PPVOID)&pAllocc, MAX_GEA);
4667	pFEA = (FEA2 ) pAllocc; / pFEA always uses pAlloc buffer */
4668
4669	GetMem((PPVOID)&pGEAList, GEAListSize ); /* alloc buffer for GEA2 list */
4670	pGEAList->cbList = GEAListSize;
4671	pGEA = pGEAList->list;
4672	pLastGEAIn = 0;
4673
4674	if ( !pAllocc \|\| ! pGEAList ) {
4675	FreeMem( pAllocc );
4676	FreeMem( pGEAList );
4677	return -1;
4678	}
4679	if ( pFEAList ) {
4680	FreeMem( pFEAList );
4681	pFEAList = 0;
4682	}
4683	while(TRUE) { /* Loop continues until there are no more EAs */
4684	ulEnumCnt = 1; /* Only want to get one EA at a time */
4685	if(DosEnumAttribute(Ref_ASCIIZ, /* Read into pAlloc Buffer */
4686	name, /* Note that this does not */
4687	ulEntryNum, /* get the aValue field, */
4688	pAllocc, /* so DosQueryPathInfo must*/
4689	MAX_GEA, /* be called to get it. */
4690	&ulEnumCnt,
4691	(LONG) GetInfoLevel1)) {
4692	FreeMem(pGEAList); /* There was some sort of error */
4693	FreeMem(pAllocc);
4694	return (-1);
4695	}
4696	if(ulEnumCnt != 1) /* All the EAs have been read */
4697	break;
4698
4699	ulEntryNum++;
4700	FEAListSize += sizeof(FEA2LIST) + pFEA->cbName+1 +
4701	pFEA->cbValue + 4;
4702
4703	if (pLastGEAIn)
4704	pLastGEAIn->oNextEntryOffset = (BYTE )pGEA - (BYTE )pLastGEAIn;
4705	pLastGEAIn = pGEA;
4706
4707	pGEA->oNextEntryOffset = 0L;
4708	pGEA->cbName = pFEA->cbName;
4709	strcpy(pGEA->szName, pFEA->szName);
4710
4711	/* must align GEA2 blocks on double word boundaries */
4712	offset = sizeof(GEA2) + pGEA->cbName + 1;
4713	offset += ( offset % 4 ? (4 - offset % 4) : 0 );
4714	pGEA = (GEA2 ) ((BYTE ) pGEA + offset);
4715	}
4716	debug(F111,"os2geteas: EA count",name,ulEntryNum-1);
4717	GetMem( (PPVOID) &pFEAList, FEAListSize );
4718	pFEAList->cbList = FEAListSize;
4719
4720	eaopGet.fpGEA2List = pGEAList;
4721	eaopGet.fpFEA2List = pFEAList;
4722
4723	rc = DosQueryPathInfo(name, /* Get the complete EA info */
4724	GetInfoLevel3,
4725	(PVOID) &eaopGet,
4726	sizeof(EAOP2));
4727
4728	debug(F111,"os2geteas: DosQueryPathInfo",name,rc);
4729	FreeMem( pGEAList );
4730	FreeMem( pAllocc );
4731	return ( rc ? -1 : 0 );
4732	}
4733
4734	/* O S 2 S E T E A S - Set all OS/2 Extended Attributes */
4735
4736	/* Returns 0 on success, -1 on failure */
4737
4738	int
4739	os2seteas( char * name ) {
4740	EAOP2 eaopSet; /* Used to call DosSetPathInfo */
4741	APIRET rc;
4742
4743	if ( !pFEAList ) {
4744	debug(F100,"os2seteas: EA List is empty","",0);
4745	return 0;
4746	}
4747	eaopSet.fpGEA2List = 0;
4748	eaopSet.fpFEA2List = pFEAList;
4749
4750	rc = DosSetPathInfo(name, /* Set the EA info */
4751	SetInfoLevel2,
4752	(PVOID) &eaopSet,
4753	sizeof(EAOP2),
4754	DSPI_WRTTHRU);
4755	debug(F111,"os2seteas: DosSetPathInfo",name,rc);
4756
4757	if ( !rc ) {
4758	FreeMem( pFEAList );
4759	pFEAList = 0;
4760	}
4761	return ( rc ? -1 : 0 );
4762	}
4763
4764	/* O S 2 G E T A T T R - Get all OS/2 Normal Attributes */
4765
4766	/* Returns 0 on success, -1 on failure */
4767
4768	int
4769	os2getattr( char * name ) {
4770	FILESTATUS3 FileInfoBuf;
4771	APIRET rc;
4772
4773	rc = DosQueryPathInfo(name, /* Get the complete EA info */
4774	GetInfoLevel1,
4775	(PVOID) &FileInfoBuf,
4776	sizeof(FILESTATUS3));
4777
4778	if ( !rc ) {
4779	os2attrs = FileInfoBuf.attrFile;
4780	return 0;
4781	}
4782	else {
4783	os2attrs = FILE_NORMAL;
4784	return -1;
4785	}
4786	}
4787
4788	/* O S 2 S E T A T T R - Set all OS/2 Normal Attributes */
4789
4790	/* Returns 0 on success, -1 on failure */
4791
4792	int
4793	os2setattr( char * name ) {
4794	FILESTATUS3 FileInfoBuf;
4795	APIRET rc;
4796
4797	rc = DosQueryPathInfo(name, /* Get the complete EA info */
4798	GetInfoLevel1,
4799	(PVOID) &FileInfoBuf,
4800	sizeof(FILESTATUS3));
4801
4802	if ( !rc ) {
4803	FileInfoBuf.attrFile = lf_opts & os2attrs;
4804	rc = DosSetPathInfo( name,
4805	GetInfoLevel1,
4806	(PVOID) &FileInfoBuf,
4807	sizeof(FILESTATUS3),
4808	0);
4809	if ( !rc )
4810	return 0;
4811	}
4812	return -1;
4813	}
4814
4815	/****************************************************************\
4816	* *
4817	* Name: GetMem (ppv, cb) *
4818	* *
4819	* Purpose: This routine returns a pointer to a available* *
4820	* memory space. *
4821	* *
4822	* Usage : *
4823	* Method : Routine should be bullet proof as it does its own *
4824	* error checking. It assumes that hwnd points to the *
4825	* correct window with the name listbox in it. *
4826	* *
4827	* Returns: The current EA as determined by querying the l-box *
4828	* selector. *
4829	* *
4830	\****************************************************************/
4831	VOID GetMem (PVOID *ppv, ULONG cb) {
4832	BOOL f;
4833
4834	f =(BOOL) DosAllocMem(ppv, cb, fPERM\|PAG_COMMIT);
4835	if (f) {
4836	*ppv = NULL;
4837	return;
4838	}
4839	return;
4840	}
4841
4842	extern CHAR os2version[50];
4843	extern long vernum;
4844
4845	/* D O _ L A B E L _ S E N D - Generate Label Header from EA List */
4846
4847	/* Return 0 on success, -1 on failure */
4848
4849	int
4850	do_label_send(char * name) {
4851	char scratch[100];
4852	long buffreespace = INBUFSIZE;
4853	long easleft = 0;
4854	long memtocpy = 0;
4855	static BYTE * p = 0;
4856
4857	debug(F110,"do_label_send",name,0);
4858	if ( !pFEAList ) {
4859	debug(F101," no EA list","",pFEAList);
4860	return 0;
4861	}
4862
4863	if ( !p ) {
4864	debug(F100,"do_label_send: generate header","",0);
4865	zinptr += sprintf(zinptr,"KERMIT LABELED FILE:02UO04VERS");
4866
4867	sprintf(scratch,"%d",strlen(get_os2_vers()));
4868	zinptr += sprintf(zinptr,"%02d%d%s",
4869	strlen(scratch),
4870	strlen(get_os2_vers()),
4871	get_os2_vers());
4872
4873	sprintf(scratch,"%d",vernum);
4874	zinptr += sprintf(zinptr,"05KVERS02%02d%d", strlen(scratch), vernum);
4875
4876	sprintf(scratch,"%d",strlen(name));
4877	zinptr += sprintf(zinptr,"08FILENAME%02d%d%s", strlen(scratch),
4878	strlen(name), name);
4879
4880	zinptr += sprintf(zinptr,"04ATTR%02d",sizeof(ULONG));
4881	memcpy( zinptr, (BYTE *) &os2attrs, sizeof(ULONG) );
4882	zinptr += sizeof(ULONG);
4883
4884	sprintf( scratch, "%d", pFEAList->cbList );
4885	zinptr += sprintf(zinptr,"09EABUFSIZE%02d%ld", strlen(scratch),
4886	pFEAList->cbList);
4887	p = (BYTE *) pFEAList;
4888	buffreespace -= (BYTE ) zinptr - (BYTE ) zinbuffer;
4889	}
4890
4891	easleft = pFEAList->cbList - ( (BYTE ) p - (BYTE ) pFEAList );
4892	memtocpy = buffreespace > easleft ? easleft : buffreespace;
4893	memcpy( zinptr, p, memtocpy );
4894	zinptr = (BYTE *) zinptr + memtocpy;
4895	p = (BYTE *) p + memtocpy;
4896	buffreespace -= memtocpy;
4897
4898	if ( buffreespace > 0 ) {
4899	p = 0;
4900	FreeMem( pFEAList );
4901	pFEAList = 0;
4902	debug(F100,"do_label_send: terminate header","",0);
4903	}
4904	zincnt = (zinptr - zinbuffer); /* Size of this beast */
4905	return(0);
4906	}
4907
4908	/* D O _ L A B E L _ R E C V - Receive label info and create EA List */
4909
4910	/* Return 0 on success, -1 on failure */
4911
4912	int
4913	do_label_recv() {
4914	char *recv_ptr = zoutbuffer;
4915	int lblen;
4916	char buffer[16];
4917	size_t memtocpy, lefttocpy;
4918	static BYTE * pFEA = 0;
4919
4920	if ( !pFEAList
4921	&& strncmp(zoutbuffer,"KERMIT LABELED FILE:02UO04VERS",30) != 0) {
4922	debug(F100,"do_label_recv: not a labeled file","",0);
4923	return(0); /* Just continue if unlabeled */
4924	}
4925
4926	if ( !pFEAList ) {
4927	recv_ptr += 30; /* start at front of buffer */
4928	zoutcnt -= 30;
4929
4930	/* get length of length of OS/2 version */
4931	memcpy(buffer, recv_ptr, 2);
4932	recv_ptr += 2;
4933	zoutcnt -= 2;
4934	buffer[2] = '\0';
4935	lblen = atoi(buffer);
4936
4937	/* get length of OS/2 version */
4938	memcpy(buffer, recv_ptr, lblen);
4939	recv_ptr += lblen;
4940	zoutcnt -= lblen;
4941	buffer[lblen] = '\0';
4942	lblen = atoi(buffer);
4943
4944	/* get os2 version */
4945	memcpy(buffer, recv_ptr, lblen);
4946	recv_ptr += lblen;
4947	zoutcnt -= lblen;
4948	buffer[lblen] = '\0';
4949	debug(F111," file created under OS/2: ",buffer,lblen);
4950
4951	/* check sync with Kermit Version */
4952	memcpy(buffer, recv_ptr, 7);
4953	recv_ptr += 7;
4954	zoutcnt -= 7;
4955	if (strncmp(buffer, "05KVERS", 7) != 0) {
4956	debug(F111," lost sync at KVERS",recv_ptr-7,zoutcnt+7);
4957	return(-1);
4958	}
4959
4960	/* get length of length of C-Kermit version */
4961	memcpy(buffer, recv_ptr, 2);
4962	recv_ptr += 2;
4963	zoutcnt -= 2;
4964	buffer[2] = '\0';
4965	lblen = atoi(buffer);
4966
4967	/* get length of C-Kermit version */
4968	memcpy(buffer, recv_ptr, lblen);
4969	recv_ptr += lblen;
4970	zoutcnt -= lblen;
4971	buffer[lblen] = '\0';
4972	lblen = atoi(buffer);
4973
4974	/* get C-Kermit version */
4975	memcpy(buffer, recv_ptr, lblen);
4976	recv_ptr += lblen;
4977	zoutcnt -= lblen;
4978	buffer[lblen] = '\0';
4979	debug(F111," file created with OS/2 C-Kermit: ",buffer,lblen);
4980
4981	/* check sync with FILENAME */
4982	memcpy(buffer, recv_ptr, 10);
4983	recv_ptr += 10;
4984	zoutcnt -= 10;
4985	if (strncmp(buffer, "08FILENAME", 10) != 0) {
4986	debug(F111," lost sync at FILENAME",recv_ptr-10,zoutcnt+10);
4987	return(-1);
4988	}
4989
4990	/* get length of length of Filename */
4991	memcpy(buffer, recv_ptr, 2);
4992	recv_ptr += 2;
4993	zoutcnt -= 2;
4994	buffer[2] = '\0';
4995	lblen = atoi(buffer);
4996
4997	/* get length of File Name */
4998	memcpy(buffer, recv_ptr, lblen);
4999	recv_ptr += lblen;
5000	zoutcnt -= lblen;
5001	buffer[lblen] = '\0';
5002	lblen = atoi(buffer);
5003
5004	/* get File Name */
5005	memcpy(buffer, recv_ptr, lblen);
5006	recv_ptr += lblen;
5007	zoutcnt -= lblen;
5008	buffer[lblen] = '\0';
5009	debug(F111," file sent with name: ",buffer,lblen);
5010
5011	/* check sync with ATTR */
5012	memcpy(buffer, recv_ptr, 6);
5013	recv_ptr += 6;
5014	zoutcnt -= 6;
5015	if (strncmp(buffer, "04ATTR", 6) != 0) {
5016	debug(F111," lost sync at ATTR",recv_ptr-6,zoutcnt+6);
5017	return(-1);
5018	}
5019
5020	/* get length of attributes - should be sizeof(ULONG) */
5021	memcpy(buffer, recv_ptr, 2);
5022	recv_ptr += 2;
5023	zoutcnt -= 2;
5024	buffer[2] = '\0';
5025	lblen = atoi(buffer);
5026	if ( lblen != sizeof(ULONG) ) {
5027	debug(F101," Attributes have wrong length","",lblen);
5028	return(-1);
5029	}
5030
5031	/* get attributes */
5032	memcpy(&os2attrs, recv_ptr, sizeof(ULONG));
5033	recv_ptr += sizeof(ULONG);
5034	zoutcnt -= sizeof(ULONG);
5035
5036	/* check sync with EABUFSIZE */
5037	memcpy(buffer, recv_ptr, 11);
5038	recv_ptr += 11;
5039	zoutcnt -= 11;
5040	if (strncmp(buffer, "09EABUFSIZE", 11) != 0) {
5041	debug(F111," lost sync at EABUFSIZE",recv_ptr-11,zoutcnt+11);
5042	return(-1);
5043	}
5044
5045	/* get length of length of EA Buffer Size */
5046	memcpy(buffer, recv_ptr, 2);
5047	recv_ptr += 2;
5048	zoutcnt -= 2;
5049	buffer[2] = '\0';
5050	lblen = atoi(buffer);
5051
5052	/* get length of EA Buffer Size */
5053	memcpy(buffer, recv_ptr, lblen);
5054	recv_ptr += lblen;
5055	zoutcnt -= lblen;
5056	buffer[lblen] = '\0';
5057	lblen = atoi(buffer);
5058	debug(F101," EA Buffer Size:","",lblen);
5059
5060	GetMem( (PPVOID) &pFEAList, (ULONG) lblen );
5061	if ( !pFEAList ) {
5062	debug(F101," pFEAList","",pFEAList);
5063	return -1;
5064	}
5065	pFEAList->cbList = lblen;
5066	pFEA = (BYTE *) pFEAList;
5067	}
5068
5069	if ( pFEAList && pFEA ) {
5070	/* get EA Buffer */
5071	lefttocpy = pFEAList->cbList - ( (BYTE ) pFEA - (BYTE ) pFEAList );
5072	memtocpy = ( zoutcnt < lefttocpy ? zoutcnt : lefttocpy );
5073	memcpy(pFEA, recv_ptr, memtocpy);
5074	recv_ptr += memtocpy;
5075	zoutcnt -= memtocpy;
5076	pFEA += memtocpy;
5077	debug(F101," memtocpy","",memtocpy);
5078	debug(F101," zoutcnt","",zoutcnt);
5079
5080	if ( pFEA == ( (BYTE *) pFEAList + pFEAList->cbList ) ) {
5081	pFEA = 0; /* we are done copying the EA's to the EA List */
5082	debug(F100," done copying EA's","",0);
5083	}
5084	}
5085
5086	/* if we have processed some of the data in the output buffer */
5087	/* then move the data in the buffer so that it is properly */
5088	/* aligned with the beginning of the buffer and reset the ptr */
5089	if ( recv_ptr != zoutbuffer ) {
5090	memmove(zoutbuffer, recv_ptr, zoutcnt);
5091	if ( pFEA ) {
5092	zoutptr = zoutbuffer + zoutcnt ;
5093	return(1); /* Go fill some more */
5094	}
5095	}
5096	return (0);
5097	}
5098	#endif /* CK_LABELED */
5099
5100	#endif /* OS2 */

Note: See TracBrowser for help on using the repository browser.

Download in other formats: