home *** CD-ROM | disk | FTP | other *** search
/ Columbia Kermit / kermit.zip / c-kermit / ckufio.c < prev    next >
C/C++ Source or Header  |  2020-01-01  |  252KB  |  8,546 lines
  1. /* C K U F I O  --  Kermit file system support for UNIX, Aegis, and Plan 9 */
  2.  
  3. #define CK_NONBLOCK                     /* See zoutdump() */
  4.  
  5. #ifdef aegis
  6. char *ckzv = "Aegis File support, 9.0.216, 20 Aug 2011";
  7. #else
  8. #ifdef Plan9
  9. char *ckzv = "Plan 9 File support, 9.0.216, 20 Aug 2011";
  10. #else
  11. char *ckzv = "UNIX File support, 9.0.216, 20 Aug 2011";
  12. #endif /* Plan9 */
  13. #endif /* aegis */
  14. /*
  15.   Author: Frank da Cruz <fdc@columbia.edu>,
  16.   Columbia University Academic Information Systems, New York City,
  17.   and others noted in the comments below.  Note: CUCCA = Previous name of
  18.   Columbia University Academic Information Systems.  Note: AcIS = Previous
  19.   of Columbia University Information Technology.
  20.  
  21.   Copyright (C) 1985, 2011,
  22.     Trustees of Columbia University in the City of New York.
  23.     All rights reserved.  See the C-Kermit COPYING.TXT file or the
  24.     copyright text in the ckcmai.c module for disclaimer and permissions.
  25. */
  26.  
  27. /*
  28.   NOTE TO CONTRIBUTORS: This file, and all the other C-Kermit files, must be
  29.   compatible with C preprocessors that support only #ifdef, #else, #endif,
  30.   #define, and #undef.  Please do not use #if, logical operators, or other
  31.   preprocessor features in any of the portable C-Kermit modules.  You can,
  32.   of course, use these constructions in platform-specific modules where you
  33.   know they are supported.
  34. */
  35. /* Include Files */
  36.  
  37. #ifdef MINIX2
  38. #define _MINIX
  39. #endif /* MINIX2 */
  40.  
  41. #include "ckcsym.h"
  42. #include "ckcdeb.h"
  43. #include "ckcasc.h"
  44.  
  45. #ifndef NOCSETS
  46. #include "ckcxla.h"
  47. #endif /* NOCSETS */
  48.  
  49. /* To avoid pulling in all of ckuusr.h so we copy the few needed prototypes */
  50.  
  51. struct mtab {                /* Macro table, like keyword table */
  52.     char *kwd;                /* But with pointers for vals */
  53.     char *mval;                /* instead of ints. */
  54.     short flgs;
  55. };
  56. _PROTOTYP( int mlook, (struct mtab [], char *, int) );
  57. _PROTOTYP( int dodo, (int, char *, int) );
  58. _PROTOTYP( int parser, ( int ) );
  59.  
  60. #ifdef COMMENT
  61. /* This causes trouble in C-Kermit 8.0.  I don't remember the original */
  62. /* reason for this being here but it must have been needed at the time... */
  63. #ifdef OSF13
  64. #ifdef CK_ANSIC
  65. #ifdef _NO_PROTO
  66. #undef _NO_PROTO
  67. #endif /* _NO_PROTO */
  68. #endif /* CK_ANSIC */
  69. #endif /* OSF13 */
  70. #endif /* COMMENT */
  71.  
  72. #ifndef HPUXPRE65
  73. #include <errno.h>            /* Error number symbols */
  74. #else
  75. #ifndef ERRNO_INCLUDED
  76. #include <errno.h>            /* Error number symbols */
  77. #endif    /* ERRNO_INCLUDED */
  78. #endif    /* HPUXPRE65 */
  79.  
  80. #include <signal.h>
  81.  
  82. #ifdef MINIX2
  83. #undef MINIX
  84. #undef CKSYSLOG
  85. #include <limits.h>
  86. #include <time.h>
  87. #define NOFILEH
  88. #endif /* MINIX2 */
  89.  
  90. #ifdef MINIX
  91. #include <limits.h>
  92. #include <sys/types.h>
  93. #include <time.h>
  94. #else
  95. #ifdef POSIX
  96. #include <limits.h>
  97. #else
  98. #ifdef SVR3
  99. #include <limits.h>
  100. #endif /* SVR3 */
  101. #endif /* POSIX */
  102. #endif /* MINIX */
  103. /*
  104.   Directory Separator macros, to allow this module to work with both UNIX and
  105.   OS/2: Because of ambiguity with the command line editor escape \ character,
  106.   the directory separator is currently left as / for OS/2 too, because the
  107.   OS/2 kernel also accepts / as directory separator.  But this is subject to
  108.   change in future versions to conform to the normal OS/2 style.
  109. */
  110. #ifndef DIRSEP
  111. #define DIRSEP       '/'
  112. #endif /* DIRSEP */
  113. #ifndef ISDIRSEP
  114. #define ISDIRSEP(c)  ((c)=='/')
  115. #endif /* ISDIRSEP */
  116.  
  117. #ifdef SDIRENT
  118. #define DIRENT
  119. #endif /* SDIRENT */
  120.  
  121. #ifdef XNDIR
  122. #include <sys/ndir.h>
  123. #else /* !XNDIR */
  124. #ifdef NDIR
  125. #include <ndir.h>
  126. #else /* !NDIR, !XNDIR */
  127. #ifdef RTU
  128. #include "/usr/lib/ndir.h"
  129. #else /* !RTU, !NDIR, !XNDIR */
  130. #ifdef DIRENT
  131. #ifdef SDIRENT
  132. #include <sys/dirent.h>
  133. #else
  134. #include <dirent.h>
  135. #endif /* SDIRENT */
  136. #else
  137. #include <sys/dir.h>
  138. #endif /* DIRENT */
  139. #endif /* RTU */
  140. #endif /* NDIR */
  141. #endif /* XNDIR */
  142.  
  143. #ifdef UNIX                             /* Pointer arg to wait() allowed */
  144. #define CK_CHILD                        /* Assume this is safe in all UNIX */
  145. #endif /* UNIX */
  146.  
  147. extern int binary, recursive, stathack;
  148. #ifdef CK_CTRLZ
  149. extern int eofmethod;
  150. #endif /* CK_CTRLZ */
  151.  
  152. #include <pwd.h>                        /* Password file for shell name */
  153. #ifdef CK_SRP
  154. #include <t_pwd.h>                      /* SRP Password file */
  155. #endif /* CK_SRP */
  156.  
  157. #ifdef HPUX10_TRUSTED
  158. #include <hpsecurity.h>
  159. #include <prot.h>
  160. #endif /* HPUX10_TRUSTED */
  161.  
  162. #ifdef COMMENT
  163. /* Moved to ckcdeb.h */
  164. #ifdef POSIX
  165. #define UTIMEH
  166. #else
  167. #ifdef HPUX9
  168. #define UTIMEH
  169. #endif /* HPUX9 */
  170. #endif /* POSIX */
  171. #endif /* COMMENT */
  172.  
  173. #ifdef SYSUTIMEH                        /* <sys/utime.h> if requested,  */
  174. #include <sys/utime.h>                  /* for extra fields required by */
  175. #else                                   /* 88Open spec. */
  176. #ifdef UTIMEH                           /* or <utime.h> if requested */
  177. #include <utime.h>                      /* (SVR4, POSIX) */
  178. #ifndef BSD44
  179. #ifndef V7
  180. /* Not sure why this is here.  What it implies is that the code bracketed
  181.    by SYSUTIMEH is valid on all platforms on which we support time 
  182.    functionality.  But we know that is not true because the BSD44 and V7
  183.    platforms do not support sys/utime.h and the data structures which
  184.    are defined in them.  Now this worked before because prior to today's
  185.    changes the UTIMEH definition for BSD44 and V7 did not take place
  186.    until after SYSUTIMEH was defined.  It also would not have been a 
  187.    problem if the ordering of all the time blocks was consistent.  All but
  188.    one of the blocks were BSD44, V7, SYSUTIMEH, <OTHER>.  That one case
  189.    is where this problem was triggered.
  190. */
  191. #define SYSUTIMEH                       /* Use this for both cases. */
  192. #endif /* V7 */
  193. #endif /* BSD44 */
  194. #endif /* UTIMEH */
  195. #endif /* SYSUTIMEH */
  196.  
  197. #ifndef NOTIMESTAMP
  198. #ifdef POSIX
  199. #ifndef AS400
  200. #define TIMESTAMP
  201. #endif /* AS400 */
  202. #endif /* POSIX */
  203.  
  204. #ifdef BSD44                            /* BSD 4.4 */
  205. #ifndef TIMESTAMP
  206. #define TIMESTAMP                       /* Can do file dates */
  207. #endif /* TIMESTAMP */
  208. #include <sys/time.h>
  209. #include <sys/timeb.h>
  210.  
  211. #else  /* Not BSD44 */
  212.  
  213. #ifdef BSD4                             /* BSD 4.3 and below */
  214. #define TIMESTAMP                       /* Can do file dates */
  215. #include <time.h>                       /* Need this */
  216. #include <sys/timeb.h>                  /* Need this if really BSD */
  217.  
  218. #else  /* Not BSD 4.3 and below */
  219.  
  220. #ifdef SVORPOSIX                        /* System V or POSIX */
  221. #ifndef TIMESTAMP
  222. #define TIMESTAMP
  223. #endif /* TIMESTAMP */
  224. #include <time.h>
  225.  
  226. /* void tzset(); (the "void" type upsets some compilers) */
  227. #ifndef IRIX60
  228. #ifndef ultrix
  229. #ifndef CONVEX9
  230. /* ConvexOS 9.0, supposedly POSIX, has extern char *timezone(int,int) */
  231. #ifndef Plan9
  232. extern long timezone;
  233. #endif /* Plan9 */
  234. #endif /* CONVEX9 */
  235. #endif /* ultrix */
  236. #endif /* IRIX60 */
  237. #endif /* SVORPOSIX */
  238. #endif /* BSD4 */
  239. #endif /* BSD44 */
  240.  
  241. #ifdef COHERENT
  242. #include <time.h>
  243. #endif /* COHERENT */
  244.  
  245. /* Is `y' a leap year? */
  246. #define leap(y) (((y) % 4 == 0 && (y) % 100 != 0) || (y) % 400 == 0)
  247.  
  248. /* Number of leap years from 1970 to `y' (not including `y' itself). */
  249. #define nleap(y) (((y) - 1969) / 4 - ((y) - 1901) / 100 + ((y) - 1601) / 400)
  250.  
  251. #endif /* NOTIMESTAMP */
  252.  
  253. #ifdef CIE
  254. #include <stat.h>                       /* File status */
  255. #else
  256. #include <sys/stat.h>
  257. #endif /* CIE */
  258.  
  259.  
  260.  
  261. /* Macro to alleviate isdir() calls internal to this module */
  262.  
  263. static struct stat STATBUF;
  264. #define xisdir(a) ((stat(a,&STATBUF)==-1)?0:(S_ISDIR(STATBUF.st_mode)?1:0))
  265.  
  266. extern char uidbuf[];
  267. extern int xferlog;
  268. extern char * xferfile;
  269. int iklogopen = 0;
  270. static time_t timenow;
  271.  
  272. #define IKSDMSGLEN CKMAXPATH+512
  273.  
  274. static char iksdmsg[IKSDMSGLEN];
  275.  
  276. extern int local;
  277.  
  278. extern int server, en_mkd, en_cwd, en_del;
  279.  
  280. /*
  281.   Functions (n is one of the predefined file numbers from ckcker.h):
  282.  
  283.    zopeni(n,name)   -- Opens an existing file for input.
  284.    zopeno(n,name,attr,fcb) -- Opens a new file for output.
  285.    zclose(n)        -- Closes a file.
  286.    zchin(n,&c)      -- Gets the next character from an input file.
  287.    zsinl(n,&s,x)    -- Read a line from file n, max len x, into address s.
  288.    zsout(n,s)       -- Write a null-terminated string to output file, buffered.
  289.    zsoutl(n,s)      -- Like zsout, but appends a line terminator.
  290.    zsoutx(n,s,x)    -- Write x characters to output file, unbuffered.
  291.    zchout(n,c)      -- Add a character to an output file, unbuffered.
  292.    zchki(name)      -- Check if named file exists and is readable, return size.
  293.    zchko(name)      -- Check if named file can be created.
  294.    zchkspa(name,n)  -- Check if n bytes available to create new file, name.
  295.    znewn(name,s)    -- Make a new unique file name based on the given name.
  296.    zdelet(name)     -- Delete the named file.
  297.    zxpand(string)   -- Expands the given wildcard string into a list of files.
  298.    znext(string)    -- Returns the next file from the list in "string".
  299.    zxrewind()       -- Rewind zxpand list.
  300.    zxcmd(n,cmd)     -- Execute the command in a lower fork on file number n.
  301.    zclosf()         -- Close input file associated with zxcmd()'s lower fork.
  302.    zrtol(n1,n2)     -- Convert remote filename into local form.
  303.    zltor(n1,n2)     -- Convert local filename into remote form.
  304.    zchdir(dirnam)   -- Change working directory.
  305.    zhome()          -- Return pointer to home directory name string.
  306.    zkself()         -- Kill self, log out own job.
  307.    zsattr(struct zattr *) -- Return attributes for file which is being sent.
  308.    zstime(f, struct zattr *, x) - Set file creation date from attribute packet.
  309.    zrename(old, new) -- Rename a file.
  310.    zcopy(source,destination) -- Copy a file.
  311.    zmkdir(path)       -- Create the directory path if possible
  312.    zfnqfp(fname,len,fullpath) - Determine full path for file name.
  313.    zgetfs(name)     -- return file size regardless of accessibility
  314.    zchkpid(pid)     -- tell if PID is valid and active
  315. */
  316.  
  317. /* Kermit-specific includes */
  318. /*
  319.   Definitions here supersede those from system include files.
  320.   ckcdeb.h is included above.
  321. */
  322. #include "ckcker.h"                     /* Kermit definitions */
  323. #include "ckucmd.h"                     /* For keyword tables */
  324. #include "ckuver.h"                     /* Version herald */
  325.  
  326. char *ckzsys = HERALD;
  327.  
  328. /*
  329.   File access checking ...  There are two calls to access() in this module.
  330.   If this program is installed setuid or setgid on a Berkeley-based UNIX
  331.   system that does NOT incorporate the saved-original-effective-uid/gid
  332.   feature, then, when we have swapped the effective and original uid/gid,
  333.   access() fails because it uses what it thinks are the REAL ids, but we have
  334.   swapped them.  This occurs on systems where ANYBSD is defined, NOSETREU
  335.   is NOT defined, and SAVEDUID is NOT defined.  So, in theory, we should take
  336.   care of this situation like so:
  337.  
  338.     ifdef ANYBSD
  339.     ifndef NOSETREU
  340.     ifndef SAVEDUID
  341.     define SW_ACC_ID
  342.     endif
  343.     endif
  344.     endif
  345.  
  346.   But we can't test such a general scheme everywhere, so let's only do this
  347.   when we know we have to...
  348. */
  349. #ifdef NEXT                             /* NeXTSTEP 1.0-3.0 */
  350. #define SW_ACC_ID
  351. #endif /* NEXT */
  352.  
  353. /* Support for tilde-expansion in file and directory names */
  354.  
  355. #ifdef POSIX
  356. #define NAMEENV "LOGNAME"
  357. #else
  358. #ifdef BSD4
  359. #define NAMEENV "USER"
  360. #else
  361. #ifdef ATTSV
  362. #define NAMEENV "LOGNAME"
  363. #endif /* ATTSV */
  364. #endif /* BSD4 */
  365. #endif /* POSIX */
  366.  
  367. /* Berkeley Unix Version 4.x */
  368. /* 4.1bsd support from Charles E Brooks, EDN-VAX */
  369.  
  370. #ifdef BSD4
  371. #ifdef MAXNAMLEN
  372. #define BSD42
  373. #endif /* MAXNAMLEN */
  374. #endif /* BSD4 */
  375.  
  376. /* Definitions of some system commands */
  377.  
  378. char *DELCMD = "rm -f ";                /* For file deletion */
  379. char *CPYCMD = "cp ";                   /* For file copy */
  380. char *RENCMD = "mv ";                   /* For file rename */
  381. char *PWDCMD = "pwd ";                  /* For saying where I am */
  382.  
  383. #ifdef COMMENT
  384. #ifdef HPUX10
  385. char *DIRCMD = "/usr/bin/ls -l ";       /* For directory listing */
  386. char *DIRCM2 = "/usr/bin/ls -l ";       /* For directory listing, no args */
  387. #else
  388. char *DIRCMD = "/bin/ls -l ";           /* For directory listing */
  389. char *DIRCM2 = "/bin/ls -l ";           /* For directory listing, no args */
  390. #endif /* HPUX10 */
  391. #else
  392. char *DIRCMD = "ls -l ";                /* For directory listing */
  393. char *DIRCM2 = "ls -l ";                /* For directory listing, no args */
  394. #endif /* COMMENT */
  395.  
  396. char *TYPCMD = "cat ";                  /* For typing a file */
  397.  
  398. #ifdef HPUX
  399. char *MAILCMD = "mailx";                /* For sending mail */
  400. #else
  401. #ifdef DGUX540
  402. char *MAILCMD = "mailx";
  403. #else
  404. #ifdef UNIX
  405. #ifdef CK_MAILCMD
  406. char *MAILCMD = CK_MAILCMD;        /* CFLAGS override */
  407. #else
  408. char *MAILCMD = "Mail";            /* Default */
  409. #endif /* CK_MAILCMD */
  410. #else
  411. char *MAILCMD = "";
  412. #endif /* UNIX */
  413. #endif /* HPUX */
  414. #endif /* DGUX40 */
  415.  
  416. #ifdef UNIX
  417. #ifdef ANYBSD                           /* BSD uses lpr to spool */
  418. #ifdef DGUX540                          /* And DG/UX */
  419. char * PRINTCMD = "lp";
  420. #else
  421. char * PRINTCMD = "lpr";
  422. #endif /* DGUX540 */
  423. #else                                   /* Sys V uses lp */
  424. #ifdef TRS16                            /* except for Tandy-16/6000... */
  425. char * PRINTCMD = "lpr";
  426. #else
  427. char * PRINTCMD = "lp";
  428. #endif /* TRS16 */
  429. #endif /* ANYBSD */
  430. #else  /* Not UNIX */
  431. #define PRINTCMD ""
  432. #endif /* UNIX */
  433.  
  434. #ifdef FT18                             /* Fortune For:Pro 1.8 */
  435. #undef BSD4
  436. #endif /* FT18 */
  437.  
  438. #ifdef BSD4
  439. char *SPACMD = "pwd ; df .";            /* Space in current directory */
  440. #else
  441. #ifdef FT18
  442. char *SPACMD = "pwd ; du ; df .";
  443. #else
  444. char *SPACMD = "df ";
  445. #endif /* FT18 */
  446. #endif /* BSD4 */
  447.  
  448. char *SPACM2 = "df ";                   /* For space in specified directory */
  449.  
  450. #ifdef FT18
  451. #define BSD4
  452. #endif /* FT18 */
  453.  
  454. #ifdef BSD4
  455. char *WHOCMD = "finger ";
  456. #else
  457. char *WHOCMD = "who ";
  458. #endif /* BSD4 */
  459.  
  460. /* More system-dependent includes, which depend on symbols defined */
  461. /* in the Kermit-specific includes.  Oh what a tangled web we weave... */
  462.  
  463. #ifdef COHERENT                         /* <sys/file.h> */
  464. #define NOFILEH
  465. #endif /* COHERENT */
  466.  
  467. #ifdef MINIX
  468. #define NOFILEH
  469. #endif /* MINIX */
  470.  
  471. #ifdef aegis
  472. #define NOFILEH
  473. #endif /* aegis */
  474.  
  475. #ifdef unos
  476. #define NOFILEH
  477. #endif /* unos */
  478.  
  479. #ifndef NOFILEH
  480. #include <sys/file.h>
  481. #endif /* NOFILEH */
  482.  
  483. #ifndef is68k                           /* Whether to include <fcntl.h> */
  484. #ifndef BSD41                           /* All but a couple UNIXes have it. */
  485. #ifndef FT18
  486. #ifndef COHERENT
  487. #include <fcntl.h>
  488. #endif /* COHERENT */
  489. #endif /* FT18  */
  490. #endif /* BSD41 */
  491. #endif /* is68k */
  492.  
  493. #ifdef COHERENT
  494. #ifdef _I386
  495. #include <fcntl.h>
  496. #else
  497. #include <sys/fcntl.h>
  498. #endif /* _I386 */
  499. #endif /* COHERENT */
  500.  
  501. extern int inserver;            /* I am IKSD */
  502. int guest = 0;                          /* Anonymous user */
  503.  
  504. #ifdef IKSD
  505. extern int isguest;
  506. extern char * anonroot;
  507. #endif /* IKSD */
  508.  
  509. #ifdef CK_LOGIN
  510. #define GUESTPASS 256
  511. static char guestpass[GUESTPASS] = { NUL, NUL }; /* Anonymous "password" */
  512. static int logged_in = 0;               /* Set when user is logged in */
  513. static int askpasswd = 0;               /* Have OK user, must ask for passwd */
  514. #ifdef CK_PAM
  515. extern int gotemptypasswd;
  516. #endif /* CK_PAM */
  517. #endif /* CK_LOGIN */
  518.  
  519. #ifdef CKROOT
  520. static char ckroot[CKMAXPATH+1] = { NUL, NUL };
  521. static int ckrootset = 0;
  522. int ckrooterr = 0;
  523. #endif /* CKROOT */
  524.  
  525. _PROTOTYP( VOID ignorsigs, (void) );
  526. _PROTOTYP( VOID restorsigs, (void) );
  527. #ifdef SELECT
  528. _PROTOTYP( int ttwait, (int, int) );    /* ckutio.c */
  529. #endif    /* SELECT */
  530.  
  531. /*
  532.   Change argument to "(const char *)" if this causes trouble.
  533.   Or... if it causes trouble, then maybe it was already declared
  534.   in a header file after all, so you can remove this prototype.
  535. */
  536. #ifndef NDGPWNAM /* If not defined No Declare getpwnam... */
  537. #ifndef _POSIX_SOURCE
  538. #ifndef NEXT
  539. #ifndef SVR4
  540. /* POSIX <pwd.h> already gave prototypes for these. */
  541. #ifdef IRIX40
  542. _PROTOTYP( struct passwd * getpwnam, (const char *) );
  543. #else
  544. #ifdef IRIX51
  545. _PROTOTYP( struct passwd * getpwnam, (const char *) );
  546. #else
  547. #ifdef M_UNIX
  548. _PROTOTYP( struct passwd * getpwnam, (const char *) );
  549. #else
  550. #ifdef HPUX9
  551. _PROTOTYP( struct passwd * getpwnam, (const char *) );
  552. #else
  553. #ifdef HPUX10
  554. _PROTOTYP( struct passwd * getpwnam, (const char *) );
  555. #else
  556. #ifdef DCGPWNAM
  557. _PROTOTYP( struct passwd * getpwnam, (const char *) );
  558. #else
  559. _PROTOTYP( struct passwd * getpwnam, (char *) );
  560. #endif /* DCGPWNAM */
  561. #endif /* HPUX10 */
  562. #endif /* HPUX9 */
  563. #endif /* M_UNIX */
  564. #endif /* IRIX51 */
  565. #endif /* IRIX40 */
  566. #ifndef SUNOS4
  567. #ifndef HPUX9
  568. #ifndef HPUX10
  569. #ifndef _SCO_DS
  570. _PROTOTYP( struct passwd * getpwuid, (PWID_T) );
  571. #endif /* _SCO_DS */
  572. #endif /* HPUX10 */
  573. #endif /* HPUX9 */
  574. #endif /* SUNOS4 */
  575. _PROTOTYP( struct passwd * getpwent, (void) );
  576. #endif /* SVR4 */
  577. #endif /* NEXT */
  578. #endif /* _POSIX_SOURCE */
  579. #endif /* NDGPWNAM */
  580.  
  581. #ifdef CK_SHADOW                        /* Shadow Passwords... */
  582. #include <shadow.h>
  583. #endif /* CK_SHADOW */
  584. #ifdef CK_PAM                           /* PAM... */
  585. #ifdef MACOSX
  586. #include <pam/pam_appl.h>
  587. #else /* MACOSX */
  588. #include <security/pam_appl.h>
  589. #endif /* MACOSX */
  590. #ifndef PAM_SERVICE_TYPE                /* Defines which PAM service we are */
  591. #define PAM_SERVICE_TYPE "kermit"
  592. #endif /* PAM_SERVICE_TYPE */
  593.  
  594. #ifdef SOLARIS
  595. #define PAM_CONST 
  596. #else /* SOLARIS */
  597. #define PAM_CONST CONST
  598. #endif 
  599.  
  600. static char * pam_pw = NULL;
  601.  
  602. int
  603. #ifdef CK_ANSIC
  604. pam_cb(int num_msg,
  605.        PAM_CONST struct pam_message **msg,
  606.        struct pam_response **resp,
  607.        void *appdata_ptr
  608.        )
  609. #else /* CK_ANSIC */
  610. pam_cb(num_msg, msg, resp, appdata_ptr)
  611.     int num_msg;
  612.     PAM_CONST struct pam_message **msg;
  613.     struct pam_response **resp;
  614.     void *appdata_ptr;
  615. #endif /* CK_ANSIC */
  616. {
  617.     int i;
  618.  
  619.     debug(F111,"pam_cb","num_msg",num_msg);
  620.  
  621.     for (i = 0; i < num_msg; i++) {
  622.         char message[PAM_MAX_MSG_SIZE];
  623.  
  624.         /* Issue prompt and get response */
  625.         debug(F111,"pam_cb","Message",i);
  626.         debug(F111,"pam_cb",msg[i]->msg,msg[i]->msg_style);
  627.         if (msg[i]->msg_style == PAM_ERROR_MSG) {
  628.             debug(F111,"pam_cb","PAM ERROR",0);
  629.             fprintf(stdout,"%s\n", msg[i]->msg);
  630.             return(0);
  631.         } else if (msg[i]->msg_style == PAM_TEXT_INFO) {
  632.             debug(F111,"pam_cb","PAM TEXT INFO",0);
  633.             fprintf(stdout,"%s\n", msg[i]->msg);
  634.             return(0);
  635.         } else if (msg[i]->msg_style == PAM_PROMPT_ECHO_OFF) {
  636.             debug(F111,"pam_cb","Reading response, no echo",0);
  637.             /* Ugly hack.  We check to see if a password has been pushed */
  638.             /* into zvpasswd().  This would be true if the password was  */
  639.             /* received by REMOTE LOGIN.                                 */
  640.             if (pam_pw) {
  641.                 ckstrncpy(message,pam_pw,PAM_MAX_MSG_SIZE);
  642.             } else
  643.                 readpass((char *)msg[i]->msg,message,PAM_MAX_MSG_SIZE);
  644.         } else if (msg[i]->msg_style == PAM_PROMPT_ECHO_ON) {
  645.             debug(F111,"pam_cb","Reading response, with echo",0);
  646.             readtext((char *)msg[i]->msg,message,PAM_MAX_MSG_SIZE);
  647.         } else {
  648.             debug(F111,"pam_cb","unknown style",0);
  649.             return(0);
  650.         }
  651.  
  652.         /* Allocate space for this message's response structure */
  653.         resp[i] = (struct pam_response *) malloc(sizeof (struct pam_response));
  654.         if (!resp[i]) {
  655.             int j;
  656.             debug(F110,"pam_cb","malloc failure",0);
  657.             for (j = 0; j < i; j++) {
  658.                 free(resp[j]->resp);
  659.                 free(resp[j]);
  660.             }
  661.             return(0);
  662.         }
  663.  
  664.         /* Allocate a buffer for the response */
  665.         resp[i]->resp = (char *) malloc((int)strlen(message) + 1);
  666.         if (!resp[i]->resp) {
  667.             int j;
  668.             debug(F110,"pam_cb","malloc failure",0);
  669.             for (j = 0; j < i; j++) {
  670.                 free(resp[j]->resp);
  671.                 free(resp[j]);
  672.             }
  673.             free(resp[i]);
  674.             return(0);
  675.         }
  676.         /* Return the results back to PAM */
  677.         strcpy(resp[i]->resp, message);    /* safe (prechecked) */
  678.         resp[i]->resp_retcode = 0;
  679.     }
  680.     debug(F110,"pam_cb","Exiting",0);
  681.     return(0);
  682. }
  683. #endif /* CK_PAM */
  684.  
  685. /* Define macros for getting file type */
  686.  
  687. #ifdef OXOS
  688. /*
  689.   Olivetti X/OS 2.3 has S_ISREG and S_ISDIR defined
  690.   incorrectly, so we force their redefinition.
  691. */
  692. #undef S_ISREG
  693. #undef S_ISDIR
  694. #endif /* OXOS */
  695.  
  696. #ifdef UTSV                             /* Same deal for Amdahl UTSV */
  697. #undef S_ISREG
  698. #undef S_ISDIR
  699. #endif /* UTSV */
  700.  
  701. #ifdef UNISYS52                         /* And for UNISYS UTS V 5.2 */
  702. #undef S_ISREG
  703. #undef S_ISDIR
  704. #endif /* UNISYS52 */
  705.  
  706. #ifdef ICLSVR3                          /* And for old ICL versions */
  707. #undef S_ISREG
  708. #undef S_ISDIR
  709. #endif /* ICLSVR3 */
  710.  
  711. #ifdef ISDIRBUG                         /* Also allow this from command line */
  712. #ifdef S_ISREG
  713. #undef S_ISREG
  714. #endif /* S_ISREG */
  715. #ifdef S_ISDIR
  716. #undef S_ISDIR
  717. #endif /*  S_ISDIR */
  718. #endif /* ISDIRBUG */
  719.  
  720. #ifndef _IFMT
  721. #ifdef S_IFMT
  722. #define _IFMT S_IFMT
  723. #else
  724. #define _IFMT 0170000
  725. #endif /* S_IFMT */
  726. #endif /* _IFMT */
  727.  
  728. #ifndef S_ISREG
  729. #define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
  730. #endif /* S_ISREG */
  731. #ifndef S_ISDIR
  732. #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
  733. #endif /* S_ISDIR */
  734.  
  735. /* The following mainly for NeXTSTEP... */
  736.  
  737. #ifndef S_IWUSR
  738. #define S_IWUSR 0000200
  739. #endif /* S_IWUSR */
  740.  
  741. #ifndef S_IRGRP
  742. #define S_IRGRP 0000040
  743. #endif /* S_IRGRP */
  744.  
  745. #ifndef S_IWGRP
  746. #define S_IWGRP 0000020
  747. #endif /* S_IWGRP */
  748.  
  749. #ifndef S_IXGRP
  750. #define S_IXGRP 0000010
  751. #endif /* S_IXGRP */
  752.  
  753. #ifndef S_IROTH
  754. #define S_IROTH 0000004
  755. #endif /* S_IROTH */
  756.  
  757. #ifndef S_IWOTH
  758. #define S_IWOTH 0000002
  759. #endif /* S_IWOTH */
  760.  
  761. #ifndef S_IXOTH
  762. #define S_IXOTH 0000001
  763. #endif /* S_IXOTH */
  764. /*
  765.   Define maximum length for a file name if not already defined.
  766.   NOTE: This applies to a path segment (directory or file name),
  767.   not the entire path string, which can be CKMAXPATH bytes long.
  768. */
  769. #ifdef QNX
  770. #ifdef _MAX_FNAME
  771. #define MAXNAMLEN _MAX_FNAME
  772. #else
  773. #define MAXNAMLEN 48
  774. #endif /* _MAX_FNAME */
  775. #else
  776. #ifndef MAXNAMLEN
  777. #ifdef sun
  778. #define MAXNAMLEN 255
  779. #else
  780. #ifdef FILENAME_MAX
  781. #define MAXNAMLEN FILENAME_MAX
  782. #else
  783. #ifdef NAME_MAX
  784. #define MAXNAMLEN NAME_MAX
  785. #else
  786. #ifdef _POSIX_NAME_MAX
  787. #define MAXNAMLEN _POSIX_NAME_MAX
  788. #else
  789. #ifdef _D_NAME_MAX
  790. #define MAXNAMLEN _D_NAME_MAX
  791. #else
  792. #ifdef DIRSIZ
  793. #define MAXNAMLEN DIRSIZ
  794. #else
  795. #define MAXNAMLEN 14
  796. #endif /* DIRSIZ */
  797. #endif /* _D_NAME_MAX */
  798. #endif /* _POSIX_NAME_MAX */
  799. #endif /* NAME_MAX */
  800. #endif /* FILENAME_MAX */
  801. #endif /* sun */
  802. #endif /* MAXNAMLEN */
  803. #endif /* QNX */
  804.  
  805. #ifdef COMMENT
  806. /* As of 2001-11-03 this is handled in ckcdeb.h */
  807. /* Longest pathname ... */
  808. /*
  809.   Beware: MAXPATHLEN is one of UNIX's dirty little secrets.  Where is it
  810.   defined?  Who knows...  <param.h>, <mod.h>, <unistd.h>, <limits.h>, ...
  811.   There is not necessarily even a definition for it anywhere, or it might have
  812.   another name.  If you get it wrong, bad things happen with getcwd() and/or
  813.   getwd().  If you allocate a buffer that is too short, getwd() might write
  814.   over memory and getcwd() will fail with ERANGE.  The definitions of these
  815.   functions (e.g. in SVID or POSIX.1) do not tell you how to determine the
  816.   maximum path length in order to allocate a buffer that is the right size.
  817. */
  818. #ifdef BSD44
  819. #include <sys/param.h>                  /* For MAXPATHLEN */
  820. #endif /* BSD44 */
  821. #ifdef COHERENT
  822. #include <sys/param.h>  /* for MAXPATHLEN, needed for -DDIRENT */
  823. #endif /* COHERENT */
  824. #endif /* COMMENT */
  825.  
  826. #ifdef MAXPATHLEN
  827. #ifdef MAXPATH
  828. #undef MAXPATH
  829. #endif /* MAXPATH */
  830. #define MAXPATH MAXPATHLEN
  831. #else
  832. #ifdef PATH_MAX
  833. #define MAXPATH PATH_MAX
  834. #else
  835. #ifdef _POSIX_PATH_MAX
  836. #define MAXPATH _POSIX_PATH_MAX
  837. #else
  838. #ifdef BSD42
  839. #define MAXPATH 1024
  840. #else
  841. #ifdef SVR4
  842. #define MAXPATH 1024
  843. #else
  844. #define MAXPATH 255
  845. #endif /* SVR4 */
  846. #endif /* BSD42 */
  847. #endif /* _POSIX_PATH_MAX */
  848. #endif /* PATH_MAX */
  849. #endif /* MAXPATHLEN */
  850.  
  851. /* Maximum number of filenames for wildcard expansion */
  852.  
  853. #ifndef MAXWLD
  854. /* Already defined in ckcdeb.h so the following is superfluous. */
  855. /* Don't expect changing them to have any effect. */
  856. #ifdef CK_SMALL
  857. #define MAXWLD 50
  858. #else
  859. #ifdef BIGBUFOK
  860. #define MAXWLD 102400
  861. #else
  862. #define MAXWLD 8192
  863. #endif /* BIGBUFOK */
  864. #endif /* CK_SMALL */
  865. #endif /* MAXWLD */
  866.  
  867. static int maxnames = MAXWLD;
  868.  
  869. /* Define the size of the string space for filename expansion. */
  870.  
  871. #ifndef DYNAMIC
  872. #ifdef PROVX1
  873. #define SSPACE 500
  874. #else
  875. #ifdef BSD29
  876. #define SSPACE 500
  877. #else
  878. #ifdef pdp11
  879. #define SSPACE 500
  880. #else
  881. #ifdef aegis
  882. #define SSPACE 10000                    /* Size of string-generating buffer */
  883. #else                                   /* Default static buffer size */
  884. #ifdef BIGBUFOK
  885. #define SSPACE 65000                    /* Size of string-generating buffer */
  886. #else
  887. #define SSPACE 2000                     /* size of string-generating buffer */
  888. #endif /* BIGBUFOK */
  889. #endif /* aegis */
  890. #endif /* pdp11 */
  891. #endif /* BSD29 */
  892. #endif /* PROVX1 */
  893. static char sspace[SSPACE];             /* Buffer for generating filenames */
  894. #else /* is DYNAMIC */
  895. #ifdef CK_64BIT
  896. #define SSPACE 2000000000        /* Two billion bytes */
  897. #else
  898. #ifdef BIGBUFOK
  899. #define SSPACE 10000000            /* Ten million */
  900. #else
  901. #define SSPACE 10000            /* Ten thousand */
  902. #endif /* BIGBUFOK */
  903. #endif    /* CK_64BIT */
  904. char *sspace = (char *)0;
  905. #endif /* DYNAMIC */
  906. static int ssplen = SSPACE;        /* Length of string space buffer */
  907.  
  908. #ifdef DCLFDOPEN
  909. /* fdopen() needs declaring because it's not declared in <stdio.h> */
  910. _PROTOTYP( FILE * fdopen, (int, char *) );
  911. #endif /* DCLFDOPEN */
  912.  
  913. #ifdef DCLPOPEN
  914. /* popen() needs declaring because it's not declared in <stdio.h> */
  915. _PROTOTYP( FILE * popen, (char *, char *) );
  916. #endif /* DCLPOPEN */
  917.  
  918. extern int nopush;
  919.  
  920. /* More internal function prototypes */
  921. /*
  922.  * The path structure is used to represent the name to match.
  923.  * Each slash-separated segment of the name is kept in one
  924.  * such structure, and they are linked together, to make
  925.  * traversing the name easier.
  926.  */
  927. struct path {
  928.     char npart[MAXNAMLEN+4];            /* name part of path segment */
  929.     struct path *fwd;                   /* forward ptr */
  930. };
  931. #ifndef NOPUSH
  932. _PROTOTYP( int shxpand, (char *, char *[], int ) );
  933. #endif /* NOPUSH */
  934. _PROTOTYP( static int fgen, (char *, char *[], int ) );
  935. _PROTOTYP( static VOID traverse, (struct path *, char *, char *) );
  936. _PROTOTYP( static VOID addresult, (char *, int) );
  937. #ifdef COMMENT
  938. /* Replaced by ckmatch() */
  939. _PROTOTYP( static int match, (char *, char *) );
  940. #endif /* COMMENT */
  941. _PROTOTYP( char * whoami, (void) );
  942. _PROTOTYP( UID_T real_uid, (void) );
  943. _PROTOTYP( static struct path *splitpath, (char *p) );
  944. _PROTOTYP( char * zdtstr, (time_t) );
  945. _PROTOTYP( time_t zstrdt, (char *, int) );
  946.  
  947. /* Some systems define these symbols in include files, others don't... */
  948.  
  949. #ifndef R_OK
  950. #define R_OK 4                          /* For access */
  951. #endif /* R_OK */
  952.  
  953. #ifndef W_OK
  954. #define W_OK 2
  955. #endif /* W_OK */
  956.  
  957. #ifndef X_OK
  958. #define X_OK 1
  959. #endif /* X_OK */
  960.  
  961. #ifndef O_RDONLY
  962. #define O_RDONLY 000
  963. #endif /* O_RDONLY */
  964.  
  965. /* syslog and wtmp items for Internet Kermit Service */
  966.  
  967. extern char * clienthost;               /* From ckcmai.c. */
  968.  
  969. static char fullname[CKMAXPATH+1];
  970. static char tmp2[CKMAXPATH+1];
  971.  
  972. extern int ckxlogging;
  973.  
  974. #ifdef CKXPRINTF                        /* Our printf macro conflicts with */
  975. #undef printf                           /* use of "printf" in syslog.h */
  976. #endif /* CKXPRINTF */
  977. #ifdef CKSYSLOG
  978. #ifdef RTAIX
  979. #include <sys/syslog.h>
  980. #else  /* RTAIX */
  981. #include <syslog.h>
  982. #endif /* RTAIX */
  983. #endif /* CKSYSLOG */
  984. #ifdef CKXPRINTF
  985. #define printf ckxprintf
  986. #endif /* CKXPRINTF */
  987.  
  988. int ckxanon = 1;                        /* Anonymous login ok */
  989. int ckxperms = 0040;                    /* Anonymous file permissions */
  990. int ckxpriv = 1;            /* Priv'd login ok */
  991.  
  992. #ifndef XFERFILE
  993. #define XFERFILE "/var/log/iksd.log"
  994. #endif /* XFERFILE */
  995.  
  996. /* wtmp logging for IKSD... */
  997.  
  998. #ifndef CKWTMP                          /* wtmp logging not selected */
  999. int ckxwtmp = 0;                        /* Know this at runtime */
  1000. #else                                   /* wtmp file details */
  1001. int ckxwtmp = 1;
  1002. #ifdef UTMPBUG                          /* Unfortunately... */
  1003. /*
  1004.   Some versions of Linux have a <utmp.h> file that contains
  1005.   "enum utlogin { local, telnet, rlogin, screen, ... };"  This clobbers
  1006.   any program that uses any of these words as variable names, function
  1007.   names, macro names, etc.  (Other versions of Linux have this declaration
  1008.   within #if 0 ... #endif.)  There is nothing we can do about this other
  1009.   than to not include the stupid file.  But we need stuff from it, so...
  1010. */
  1011. #include <features.h>
  1012. #include <sys/types.h>
  1013. #define UT_LINESIZE     32
  1014. #define UT_NAMESIZE     32
  1015. #define UT_HOSTSIZE     256
  1016.  
  1017. struct timeval {
  1018.   time_t tv_sec;
  1019.   time_t tv_usec;
  1020. };
  1021.  
  1022. struct exit_status {
  1023.   short int e_termination;      /* Process termination status.  */
  1024.   short int e_exit;             /* Process exit status.  */
  1025. };
  1026.  
  1027. struct utmp {
  1028.   short int ut_type;                    /* Type of login */
  1029.   pid_t ut_pid;                         /* Pid of login process */
  1030.   char ut_line[UT_LINESIZE];            /* NUL-terminated devicename of tty */
  1031.   char ut_id[4];                        /* Inittab id */
  1032.   char ut_user[UT_NAMESIZE];            /* Username (not NUL terminated) */
  1033.  
  1034.   char ut_host[UT_HOSTSIZE];            /* Hostname for remote login */
  1035.   struct exit_status ut_exit;           /* Exit status */
  1036.   long ut_session;                      /* Session ID, used for windowing */
  1037.   struct timeval ut_tv;                 /* Time entry was made */
  1038.   int32_t ut_addr_v6[4];                /* Internet address of remote host */
  1039.   char pad[20];                         /* Reserved */
  1040. };
  1041.  
  1042. #define ut_time ut_tv.tv_sec    /* Why should Linux be like anything else? */
  1043. #define ut_name ut_user         /* ... */
  1044.  
  1045. extern void
  1046. logwtmp __P ((__const char *__ut_line, __const char *__ut_name,
  1047.                           __const char *__ut_host));
  1048.  
  1049. #else  /* Not UTMPBUG */
  1050.  
  1051. #ifndef HAVEUTMPX                       /* Who has <utmpx.h> */
  1052. #ifdef SOLARIS
  1053. #define HAVEUTMPX
  1054. #else
  1055. #ifdef IRIX60
  1056. #define HAVEUTMPX
  1057. #else
  1058. #ifdef CK_SCOV5
  1059. #define HAVEUTMPX
  1060. #else
  1061. #ifdef HPUX100
  1062. #define HAVEUTMPX
  1063. #else
  1064. #ifdef UNIXWARE
  1065. #define HAVEUTMPX
  1066. #endif /* UNIXWARE */
  1067. #endif /* HPUX100 */
  1068. #endif /* CK_SCOV5 */
  1069. #endif /* IRIX60 */
  1070. #endif /* SOLARIS */
  1071. #endif /* HAVEUTMPX */
  1072.  
  1073. #ifdef HAVEUTMPX
  1074. #include <utmpx.h>
  1075. #else
  1076. #ifdef OSF50
  1077. /* Because the time_t in the utmp struct is 64 bits but time() wants 32 */
  1078. #define __V40_OBJ_COMPAT 1
  1079. #endif /* OSF50 */
  1080. #include <utmp.h>
  1081. #ifdef OSF50
  1082. #undef __V40_OBJ_COMPAT
  1083. #endif /* OSF50 */
  1084. #endif /* HAVEUTMPX */
  1085. #endif /* UTMPBUG */
  1086.  
  1087. #ifdef HAVEUTMPX
  1088. #define UTMPSTRUCT utmpx
  1089. #else
  1090. #define UTMPSTRUCT utmp
  1091. #endif    /* HAVEUTMPX */
  1092.  
  1093. #ifndef WTMPFILE
  1094. #ifdef QNX
  1095. #define WTMPFILE "/usr/adm/wtmp.1"
  1096. #else
  1097. #ifdef LINUX
  1098. #define WTMPFILE "/var/log/wtmp"
  1099. #else
  1100. #define WTMPFILE "/usr/adm/wtmp"
  1101. #endif /* QNX */
  1102. #endif /* LINUX */
  1103. #endif /* WTMPFILE */
  1104. char * wtmpfile = NULL;
  1105.  
  1106. static int wtmpfd = 0;
  1107. static char cksysline[32] = { NUL, NUL };
  1108.  
  1109. #ifndef HAVEUTHOST                      /* Does utmp include ut_host[]? */
  1110. #ifdef HAVEUTMPX                        /* utmpx always does */
  1111. #define HAVEUTHOST
  1112. #else
  1113. #ifdef LINUX                            /* Linux does */
  1114. #define HAVEUTHOST
  1115. #else
  1116. #ifdef SUNOS4                           /* SunOS does */
  1117. #define HAVEUTHOST
  1118. #else
  1119. #ifdef AIX41                            /* AIX 4.1 and later do */
  1120. #define HAVEUTHOST
  1121. #endif /* AIX41 */
  1122. #endif /* SUNOS4 */
  1123. #endif /* LINUX */
  1124. #endif /* HAVEUTMPX */
  1125. #endif /* HAVEUTHOST */
  1126.  
  1127. #ifdef UW200
  1128. PID_T _vfork() {                        /* To satisfy a library foulup */
  1129.     return(fork());                     /* in Unixware 2.0.x */
  1130. }
  1131. #endif /* UW200 */
  1132.  
  1133. VOID
  1134. #ifdef CK_ANSIC
  1135. logwtmp(const char * line, const char * name, const char * host)
  1136. #else
  1137. logwtmp(line, name, host) char *line, *name, *host;
  1138. #endif /* CK_ANSIC */
  1139. /* logwtmp */ {
  1140.     struct UTMPSTRUCT ut;
  1141.     struct stat buf;
  1142.     /* time_t time(); */
  1143.  
  1144.     if (!ckxwtmp)
  1145.       return;
  1146.  
  1147.     if (!wtmpfile)
  1148.       makestr(&wtmpfile,WTMPFILE);
  1149.  
  1150.     if (!line) line = "";
  1151.     if (!name) name = "";
  1152.     if (!host) host = "";
  1153.  
  1154.     if (!wtmpfd && (wtmpfd = open(wtmpfile, O_WRONLY|O_APPEND, 0)) < 0) {
  1155.         ckxwtmp = 0;
  1156.         debug(F110,"WTMP open failed",line,0);
  1157.         return;
  1158.     }
  1159.     if (!fstat(wtmpfd, &buf)) {
  1160.         ckstrncpy(ut.ut_line, line, sizeof(ut.ut_line));
  1161. #ifdef FREEBSD9
  1162.         ckstrncpy(ut.ut_user, name, sizeof(ut.ut_user));
  1163. #else
  1164.         ckstrncpy(ut.ut_name, name, sizeof(ut.ut_name));
  1165. #endif    /* FREEBSD9 */
  1166. #ifdef HAVEUTHOST
  1167.         /* Not portable */
  1168.         ckstrncpy(ut.ut_host, host, sizeof(ut.ut_host));
  1169. #endif /* HAVEUTHOST */
  1170. #ifdef HAVEUTMPX
  1171.         time(&ut.ut_tv.tv_sec);
  1172. #else
  1173. #ifdef LINUX
  1174. /* In light of the following comment perhaps the previous line should */
  1175. /* be "#ifndef COMMENT". */
  1176.         {
  1177.             /*
  1178.              * On 64-bit platforms sizeof(time_t) and sizeof(ut.ut_time)
  1179.              * are not the same and attempt to use an address of
  1180.              * ut.ut_time as an argument to time() call may cause
  1181.              * "unaligned access" trap.
  1182.              */
  1183.             time_t zz;
  1184.             time(&zz);
  1185.             ut.ut_time = zz;
  1186.         }
  1187. #else
  1188. #ifdef CK_64BIT
  1189.         {
  1190.         /* Now (Jan 2006) we can do this for any 64-bit build */
  1191.             time_t zz;
  1192.             time(&zz);
  1193.             ut.ut_time = zz;
  1194.         }
  1195. #else
  1196.         time(&ut.ut_time);
  1197. #endif    /* CK_64BIT */
  1198. #endif /* LINUX */
  1199. #endif /* HAVEUTMPX */
  1200.         if (write(wtmpfd, (char *)&ut, sizeof(struct UTMPSTRUCT)) !=
  1201.             sizeof(struct UTMPSTRUCT)) {
  1202. #ifndef NOFTRUNCATE
  1203. #ifndef COHERENT
  1204.             ftruncate(wtmpfd, buf.st_size); /* Error, undo any partial write */
  1205. #else
  1206.             chsize(wtmpfd, buf.st_size); /* Error, undo any partial write */
  1207. #endif /* COHERENT */
  1208. #endif /* NOFTRUNCATE */
  1209.             debug(F110,"WTMP write error",line,0);
  1210.         } else {
  1211.             debug(F110,"WTMP record OK",line,0);
  1212.             return;
  1213.         }
  1214.     }
  1215. }
  1216. #endif /* CKWTMP */
  1217.  
  1218. #ifdef CKSYSLOG
  1219. /*
  1220.   C K S Y S L O G  --  C-Kermit system logging function,
  1221.  
  1222.   For use by other modules.
  1223.   This module can, but doesn't have to, use it.
  1224.   Call with:
  1225.     n = SYSLG_xx values defined in ckcdeb.h
  1226.     s1, s2, s3: strings.
  1227. */
  1228. VOID
  1229. cksyslog(n, m, s1, s2, s3) int n, m; char * s1, * s2, * s3; {
  1230.     int level;
  1231.  
  1232.     if (!ckxlogging)                    /* syslogging */
  1233.       return;
  1234.     if (!s1) s1 = "";                   /* Fix null args */
  1235.     if (!s2) s2 = "";
  1236.     if (!s3) s3 = "";
  1237.     switch (n) {                        /* Translate Kermit level */
  1238.       case SYSLG_DB:                    /* to syslog level */
  1239.         level = LOG_DEBUG;
  1240.         break;
  1241.       default:
  1242.         level = m ? LOG_INFO : LOG_ERR;
  1243.     }
  1244.     debug(F110,"cksyslog s1",s1,0);
  1245.     debug(F110,"cksyslog s2",s2,0);
  1246.     debug(F110,"cksyslog s3",s3,0);
  1247.     errno = 0;
  1248.     syslog(level, "%s: %s %s", s1, s2, s3); /* Write syslog record */
  1249.     debug(F101,"cksyslog errno","",errno);
  1250. }
  1251. #endif /* CKSYSLOG */
  1252.  
  1253.  
  1254. /* Declarations */
  1255.  
  1256. int maxnam = MAXNAMLEN;                 /* Available to the outside */
  1257. int maxpath = MAXPATH;
  1258. int ck_znewn = -1;
  1259.  
  1260. #ifdef UNIX
  1261. char startupdir[MAXPATH+1];
  1262. #endif /* UNIX */
  1263.  
  1264. int pexitstat = -2;                     /* Process exit status */
  1265.  
  1266. FILE *fp[ZNFILS] = {                    /* File pointers */
  1267.    NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL
  1268. };
  1269.  
  1270. /* Flags for each file indicating whether it was opened with popen() */
  1271. int ispipe[ZNFILS] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
  1272.  
  1273. /* Buffers and pointers used in buffered file input and output. */
  1274. #ifdef DYNAMIC
  1275. extern char *zinbuffer, *zoutbuffer;
  1276. #else
  1277. extern char zinbuffer[], zoutbuffer[];
  1278. #endif /* DYNAMIC */
  1279. extern char *zinptr, *zoutptr;
  1280. extern int zincnt, zoutcnt;
  1281. extern int wildxpand, wildena;        /* Wildcard handling */
  1282.  
  1283. static CK_OFF_T iflen = (CK_OFF_T)-1;    /* Input file length */
  1284.  
  1285. static PID_T pid = 0;                   /* pid of child fork */
  1286. static int fcount = 0;                  /* Number of files in wild group */
  1287. static int nxpand = 0;                  /* Copy of fcount */
  1288. static char nambuf[CKMAXPATH+4];        /* Buffer for a pathname */
  1289.  
  1290. #ifndef NOFRILLS
  1291. #define ZMBUFLEN 200
  1292. static char zmbuf[ZMBUFLEN];        /* For mail, remote print strings */
  1293. #endif /* NOFRILLS */
  1294.  
  1295. char **mtchs = NULL;                    /* Matches found for filename */
  1296. char **mtchptr = NULL;                  /* Pointer to current match */
  1297.  
  1298. /*  Z K S E L F  --  Kill Self: log out own job, if possible.  */
  1299.  
  1300. /* Note, should get current pid, but if your system doesn't have */
  1301. /* getppid(), then just kill(0,9)...  */
  1302.  
  1303. #ifndef SVR3
  1304. #ifndef POSIX
  1305. #ifndef OSFPC
  1306. /* Already declared in unistd.h for SVR3 and POSIX */
  1307. #ifdef CK_ANSIC
  1308. extern PID_T getppid(void);
  1309. #else
  1310. #ifndef PS2AIX10
  1311. #ifndef COHERENT
  1312. extern PID_T getppid();
  1313. #endif /* COHERENT */
  1314. #endif /* PS2AIX10 */
  1315. #endif /* CK_ANSIC */
  1316. #endif /* OSFPC */
  1317. #endif /* POSIX */
  1318. #endif /* SVR3 */
  1319.  
  1320. int
  1321. zkself() {                              /* For "bye", but no guarantee! */
  1322. #ifdef PROVX1
  1323.     return(kill(0,9));
  1324. #else
  1325. #ifdef V7
  1326.     return(kill(0,9));
  1327. #else
  1328. #ifdef TOWER1
  1329.     return(kill(0,9));
  1330. #else
  1331. #ifdef FT18
  1332.     return(kill(0,9));
  1333. #else
  1334. #ifdef aegis
  1335.     return(kill(0,9));
  1336. #else
  1337. #ifdef COHERENT
  1338.     return(kill((PID_T)getpid(),1));
  1339. #else
  1340. #ifdef PID_T
  1341.     exit(kill((PID_T)getppid(),1));
  1342.     return(0);
  1343. #else
  1344.     exit(kill(getppid(),1));
  1345.     return(0);
  1346. #endif
  1347. #endif
  1348. #endif
  1349. #endif
  1350. #endif
  1351. #endif
  1352. #endif
  1353. }
  1354.  
  1355. static VOID
  1356. getfullname(name) char * name; {
  1357.     char *p = (char *)fullname;
  1358.     int len = 0;
  1359.     fullname[0] = '\0';
  1360.     /* If necessary we could also chase down symlinks here... */
  1361. #ifdef COMMENT
  1362.     /* This works but is incompatible with wuftpd */
  1363.     if (isguest && anonroot) {
  1364.         ckstrncpy(fullname,anonroot,CKMAXPATH);
  1365.         len = strlen(fullname);
  1366.         if (len > 0)
  1367.           if (fullname[len-1] == '/')
  1368.             len--;
  1369.     }
  1370.     p += len;
  1371. #endif /* COMMENT */
  1372.     zfnqfp(name, CKMAXPATH - len, p);
  1373.     while (*p) {
  1374.         if (*p < '!') *p = '_';
  1375.         p++;
  1376.     }
  1377. }
  1378.  
  1379. /*  D O I K L O G  --  Open Kermit-specific ftp-like transfer log. */
  1380.  
  1381. VOID                                    /* Called in ckcmai.c */
  1382. doiklog() {
  1383.     if (iklogopen)                      /* Already open? */
  1384.       return;
  1385.     if (xferlog) {                      /* Open iksd log if requested */
  1386.         if (!xferfile)                  /* If no pathname given */
  1387.           makestr(&xferfile,XFERFILE);    /* use this default */
  1388.         if (*xferfile) {
  1389.             xferlog = open(xferfile, O_WRONLY | O_APPEND | O_CREAT, 0660);
  1390.             debug(F101,"doiklog open","",xferlog);
  1391.             if (xferlog < 0) {
  1392. #ifdef CKSYSLOG
  1393.                 syslog(LOG_ERR, "xferlog open failure %s: %m", xferfile);
  1394. #endif /* CKSYSLOG */
  1395.                 debug(F101,"doiklog open errno","",errno);
  1396.                 xferlog = 0;
  1397.             } else
  1398.               iklogopen = 1;
  1399.         } else
  1400.           xferlog = 0;
  1401. #ifdef CKSYSLOG
  1402.         if (xferlog && ckxlogging)
  1403.           syslog(LOG_INFO, "xferlog: %s open ok", xferfile);
  1404. #endif /* CKSYSLOG */
  1405.     }
  1406. }
  1407.  
  1408. /*  Z O P E N I  --  Open an existing file for input. */
  1409.  
  1410. /* Returns 1 on success, 0 on failure */
  1411.  
  1412. int
  1413. zopeni(n,name) int n; char *name; {
  1414.     int x;
  1415.  
  1416.     debug(F111,"zopeni",name,n);
  1417.     if ((x = chkfn(n)) != 0) {
  1418.     debug(F111,"zopeni chkfn",ckitoa(n),x);
  1419.     return(0);
  1420.     }
  1421.     zincnt = 0;                         /* Reset input buffer */
  1422.     if (n == ZSYSFN) {                  /* Input from a system function? */
  1423. #ifdef COMMENT
  1424. /*** Note, this function should not be called with ZSYSFN ***/
  1425. /*** Always call zxcmd() directly, and give it the real file number ***/
  1426. /*** you want to use.  ***/
  1427.         return(zxcmd(n,name));          /* Try to fork the command */
  1428. #else
  1429.         debug(F110,"zopeni called with ZSYSFN, failing!",name,0);
  1430.         *nambuf = '\0';                 /* No filename. */
  1431.         return(0);                      /* fail. */
  1432. #endif /* COMMENT */
  1433.     }
  1434.     if (n == ZSTDIO) {                  /* Standard input? */
  1435.         if (is_a_tty(0)) {
  1436.             fprintf(stderr,"Terminal input not allowed");
  1437.             debug(F110,"zopeni: attempts input from unredirected stdin","",0);
  1438.             return(0);
  1439.         }
  1440.         fp[ZIFILE] = stdin;
  1441.         ispipe[ZIFILE] = 0;
  1442.         return(1);
  1443.     }
  1444. #ifdef CKROOT
  1445.     debug(F111,"zopeni setroot",ckroot,ckrootset);
  1446.     if (ckrootset) if (!zinroot(name)) {
  1447.     debug(F110,"zopeni setroot violation",name,0);
  1448.     return(0);
  1449.     }
  1450. #endif /* CKROOT */
  1451.     fp[n] = fopen(name,"r");            /* Real file, open it. */
  1452.     /* debug(F111,"zopeni fopen", name, fp[n]); */
  1453. #ifdef ZDEBUG
  1454.     /* printf("ZOPENI fp[%d]=%ld\n",n,fp[n]); */
  1455. #endif /* ZDEBUG */
  1456.     ispipe[n] = 0;
  1457.  
  1458.     if (xferlog
  1459. #ifdef CKSYSLOG
  1460.         || ((ckxsyslog >= SYSLG_FA) && ckxlogging)
  1461. #endif /* CKSYSLOG */
  1462.         ) {
  1463.         getfullname(name);
  1464.         debug(F110,"zopeni fullname",fullname,0);
  1465.     }
  1466.     if (fp[n] == NULL) {
  1467. #ifdef CKSYSLOG
  1468.         if (ckxsyslog >= SYSLG_FA && ckxlogging) {
  1469.         syslog(LOG_INFO, "file[%d] %s: open failed (%m)", n, fullname);
  1470.         perror(fullname);
  1471.     } else
  1472. #endif /* CKSYSLOG */
  1473.       perror(name);
  1474.         return(0);
  1475.     } else {
  1476. #ifdef CKSYSLOG
  1477.         if (ckxsyslog >= SYSLG_FA && ckxlogging)
  1478.           syslog(LOG_INFO, "file[%d] %s: open read ok", n, fullname);
  1479. #endif /* CKSYSLOG */
  1480.         clearerr(fp[n]);
  1481.         return(1);
  1482.     }
  1483. }
  1484.  
  1485. #ifdef QNX
  1486. #define DONDELAY
  1487. #else
  1488. #ifdef O_NDELAY
  1489. #define DONDELAY
  1490. #endif /* O_NDELAY */
  1491. #endif /* QNX */
  1492.  
  1493. /*  Z O P E N O  --  Open a new file for output.  */
  1494.  
  1495. /*ARGSUSED*/    /* zz not used */
  1496. int
  1497. zopeno(n,name,zz,fcb)
  1498. /* zopeno */  int n; char *name; struct zattr *zz; struct filinfo *fcb; {
  1499.  
  1500.     char p[8];
  1501.     int append = 0;
  1502.     int istty = 0, filefd = 0;
  1503.  
  1504. /* As of Version 5A, the attribute structure and the file information */
  1505. /* structure are included in the arglist. */
  1506.  
  1507. #ifdef DEBUG
  1508.     debug(F111,"zopeno",name,n);
  1509.     if (fcb) {
  1510.         debug(F101,"zopeno fcb disp","",fcb->dsp);
  1511.         debug(F101,"zopeno fcb type","",fcb->typ);
  1512.         debug(F101,"zopeno fcb char","",fcb->cs);
  1513.     } else {
  1514.         debug(F100,"zopeno fcb is NULL","",0);
  1515.     }
  1516. #endif /* DEBUG */
  1517.  
  1518.     if (chkfn(n) != 0)                  /* Already open? */
  1519.       return(0);                        /* Nothing to do. */
  1520.  
  1521.     if ((n == ZCTERM) || (n == ZSTDIO)) { /* Terminal or standard output */
  1522.         fp[ZOFILE] = stdout;
  1523.         ispipe[ZOFILE] = 0;
  1524. #ifdef COMMENT
  1525.     /* This seems right but it breaks client server ops */
  1526.     fp[n] = stdout;
  1527.         ispipe[n] = 0;
  1528. #endif /* COMMENT */
  1529. #ifdef COMMENT
  1530. #ifdef DEBUG
  1531.         if (n != ZDFILE)
  1532.           debug(F101,"zopeno fp[n]=stdout","",fp[n]);
  1533. #endif /* DEBUG */
  1534. #endif    /* COMMENT */
  1535.         zoutcnt = 0;
  1536.         zoutptr = zoutbuffer;
  1537.         return(1);
  1538.     }
  1539.  
  1540. /* A real file.  Open it in desired mode (create or append). */
  1541.  
  1542. #ifdef CKROOT
  1543.     debug(F111,"zopeno setroot",ckroot,ckrootset);
  1544.     if (ckrootset) if (!zinroot(name)) {
  1545.     debug(F110,"zopeno setroot violation",name,0);
  1546.     return(0);
  1547.     }
  1548. #endif /* CKROOT */
  1549.  
  1550.     ckstrncpy(p,"w",8);            /* Assume write/create mode */
  1551.     if (fcb) {                          /* If called with an FCB... */
  1552.         if (fcb->dsp == XYFZ_A) {       /* Does it say Append? */
  1553.             ckstrncpy(p,"a",8);        /* Yes. */
  1554.             debug(F100,"zopeno append","",0);
  1555.             append = 1;
  1556.         }
  1557.     }
  1558.     if (xferlog
  1559. #ifdef CKSYSLOG
  1560.         || ((ckxsyslog >= SYSLG_FC) && ckxlogging)
  1561. #endif /* CKSYSLOG */
  1562.         ) {
  1563.         getfullname(name);
  1564.         debug(F110,"zopeno fullname",fullname,0);
  1565.     }
  1566.     {
  1567.     /* Allow tty devices to opened as output files 2009/10/20 */
  1568.     int fd, mode = 0;
  1569.     debug(F110,"zopeno attempting to open",name,0);
  1570. #ifdef O_NONBLOCK
  1571.     mode = O_NONBLOCK;
  1572. #else
  1573. #ifdef O_NDELAY
  1574.     mode = O_NDELAY;
  1575. #else
  1576. #ifdef FNDELAY
  1577.     mode = FNDELAY;
  1578. #endif /* FNDELAY */
  1579. #endif    /* O_NDELAY */
  1580. #endif    /* O_NONBLOCK */
  1581.     debug(F111,"zopeno open mode",name,mode);
  1582.     fd = open(name,O_WRONLY,mode);
  1583.     debug(F111,"zopeno open",name,fd); 
  1584.     if (fd > -1) {
  1585.         if (isatty(fd)) {
  1586.         filefd = fd;
  1587.         istty++;
  1588.         }
  1589.     }
  1590.     }
  1591.     debug(F111,"zopeno istty",name,istty);
  1592.     debug(F110,"zopeno fopen arg",p,0);
  1593.     if (istty)
  1594.       fp[n] = fdopen(filefd,p);
  1595.     else
  1596.       fp[n] = fopen(name,p);        /* Try to open the file */
  1597.     ispipe[ZIFILE] = 0;
  1598.  
  1599. #ifdef ZDEBUG
  1600.     printf("ZOPENO fp[%d]=%ld\n",n,fp[n]);
  1601. #endif /* ZDEBUG */
  1602.  
  1603.     if (fp[n] == NULL) {                /* Failed */
  1604.         debug(F101,"zopeno failed errno","",errno);
  1605.     if (istty) close(filefd);
  1606. #ifdef CKSYSLOG
  1607.         if (ckxsyslog >= SYSLG_FC && ckxlogging)
  1608.           syslog(LOG_INFO, "file[%d] %s: %s failed (%m)",
  1609.                  n,
  1610.                  fullname,
  1611.                  append ? "append" : "create"
  1612.                  );
  1613. #endif /* CKSYSLOG */
  1614. #ifdef COMMENT                          /* Let upper levels print message. */
  1615.         perror("Can't open output file");
  1616. #endif /* COMMENT */
  1617.     } else {                            /* Succeeded */
  1618.         extern int zofbuffer, zofblock, zobufsize;
  1619.         debug(F101, "zopeno zobufsize", "", zobufsize);
  1620.         if (n == ZDFILE || n == ZTFILE) { /* If debug or transaction log */
  1621.             setbuf(fp[n],NULL);           /* make it unbuffered. */
  1622. #ifdef DONDELAY
  1623.         } else if (n == ZOFILE && !zofblock) { /* blocking or nonblocking */
  1624.             int flags;
  1625.             if ((flags = fcntl(fileno(fp[n]),F_GETFL,0)) > -1)
  1626.               fcntl(fileno(fp[n]),F_SETFL, flags |
  1627. #ifdef QNX
  1628.                     O_NONBLOCK
  1629. #else
  1630.                     O_NDELAY
  1631. #endif /* QNX */
  1632.                     );
  1633.             debug(F100,"zopeno ZOFILE nonblocking","",0);
  1634. #endif /* DONDELAY */
  1635.         } else if (n == ZOFILE && !zofbuffer) { /* buffered or unbuffered */
  1636.             setbuf(fp[n],NULL);
  1637.             debug(F100,"zopeno ZOFILE unbuffered","",0);
  1638.         }
  1639.  
  1640. #ifdef CK_LOGIN
  1641.         /* Enforce anonymous file-creation permission */
  1642.         if (isguest)
  1643.           if (n == ZWFILE || n == ZMFILE ||
  1644.               n == ZOFILE || n == ZDFILE ||
  1645.               n == ZTFILE || n == ZPFILE ||
  1646.               n == ZSFILE)
  1647.             chmod(name,ckxperms);
  1648. #endif /* CK_LOGIN */
  1649. #ifdef CKSYSLOG
  1650.         if (ckxsyslog >= SYSLG_FC && ckxlogging)
  1651.           syslog(LOG_INFO, "file[%d] %s: %s ok",
  1652.                  n,
  1653.                  fullname,
  1654.                  append ? "append" : "create"
  1655.                  );
  1656. #endif /* CKSYSLOG */
  1657.         debug(F100, "zopeno ok", "", 0);
  1658.     }
  1659.     zoutcnt = 0;                        /* (PWP) reset output buffer */
  1660.     zoutptr = zoutbuffer;
  1661.     return((fp[n] != NULL) ? 1 : 0);
  1662. }
  1663.  
  1664. /*  Z C L O S E  --  Close the given file.  */
  1665.  
  1666. /*  Returns 0 if arg out of range, 1 if successful, -1 if close failed.  */
  1667.  
  1668. int
  1669. zclose(n) int n; {
  1670.     int x = 0, x2 = 0;
  1671.     extern CK_OFF_T ffc;
  1672.  
  1673.     debug(F101,"zclose file number","",n);
  1674.     if (chkfn(n) < 1) return(0);        /* Check range of n */
  1675.     if ((n == ZOFILE) && (zoutcnt > 0)) /* (PWP) output leftovers */
  1676.       x2 = zoutdump();
  1677.  
  1678.     if (fp[ZSYSFN] || ispipe[n]) {      /* If file is really pipe */
  1679. #ifndef NOPUSH
  1680.         x = zclosf(n);                  /* do it specially */
  1681. #else
  1682.         x = EOF;
  1683. #endif /* NOPUSH */
  1684.         debug(F101,"zclose zclosf","",x);
  1685.         /* debug(F101,"zclose zclosf fp[n]","",fp[n]); */
  1686.     } else {
  1687.         if ((fp[n] != stdout) && (fp[n] != stdin))
  1688.           x = fclose(fp[n]);
  1689.         fp[n] = NULL;
  1690. #ifdef COMMENT
  1691.     if (n == ZCTERM || n == ZSTDIO)    /* See zopeno() */
  1692.       if (fp[ZOFILE] == stdout)
  1693.         fp[ZOFILE] = NULL;
  1694. #endif /* COMMENT */
  1695.     }
  1696.     iflen = -1L;                        /* Invalidate file length */
  1697.     if (x == EOF) {                     /* if we got a close error */
  1698.         debug(F101,"zclose fclose fails","",x);
  1699.         return(-1);
  1700.     } else if (x2 < 0) {                /* or error flushing last buffer */
  1701.         debug(F101,"zclose error flushing last buffer","",x2);
  1702.         return(-1);                     /* then return an error */
  1703.     } else {
  1704.         /* Print log record compatible with wu-ftpd */
  1705.         if (xferlog && (n == ZIFILE || n == ZOFILE)) {
  1706.             char * s, *p;
  1707.             extern char ttname[];
  1708.             if (!iklogopen) (VOID) doiklog(); /* Open log if necessary */
  1709.             debug(F101,"zclose iklogopen","",iklogopen);
  1710.             if (iklogopen) {
  1711.         int len;
  1712.         char * fnam;
  1713.  
  1714.                 timenow = time(NULL);
  1715. #ifdef CK_LOGIN
  1716.                 if (logged_in)
  1717.                   s = clienthost;
  1718.                 else
  1719. #endif /* CK_LOGIN */
  1720.                   s = (char *)ttname;
  1721.                 if (!s) s = "";
  1722.                 if (!*s) s = "*";
  1723. #ifdef CK_LOGIN
  1724.                 if (logged_in) {
  1725.                     p = guestpass;
  1726.                     if (!*p) p = "*";
  1727.                 } else
  1728. #endif /* CK_LOGIN */
  1729.                   p = whoami();
  1730.  
  1731.         len = 24 + 12 + (int)strlen(s) + 16
  1732.           + (int)strlen(fullname) + 1 + 1 + 1 + 1
  1733.             + (int)strlen(p) + 6 + 2 + 12;
  1734.         fnam = fullname;
  1735.         if (!*fnam) fnam = "(pipe)";
  1736.  
  1737.         if (len > IKSDMSGLEN)
  1738.           sprintf(iksdmsg,    /* SAFE */
  1739.                         "%.24s [BUFFER WOULD OVERFLOW]\n",ctime(&timenow));
  1740.         else
  1741.           sprintf(iksdmsg,    /* SAFE */
  1742.                         "%.24s %d %s %s %s %c %s %c %c %s %s %d %s\n",
  1743.                         ctime(&timenow),        /* date/time */
  1744.                         gtimer(),               /* elapsed secs */
  1745.                         s,                      /* peer name */
  1746.             ckfstoa(ffc),            /* byte count */
  1747.                         fnam,            /* full pathname of file */
  1748.                         (binary ? 'b' : 'a'),   /* binary or ascii */
  1749.                         "_",                    /* options = none */
  1750.                         n == ZIFILE ? 'o' : 'i', /* in/out */
  1751. #ifdef CK_LOGIN
  1752.                         (isguest ? 'a' : 'r'),  /* User type */
  1753. #else
  1754.                         'r',
  1755. #endif /* CK_LOGIN */
  1756.                         p,                      /* Username or guest passwd */
  1757. #ifdef CK_LOGIN
  1758.                         logged_in ? "iks" : "kermit", /* Record ID */
  1759. #else
  1760.                         "kermit",
  1761. #endif /* CK_LOGIN */
  1762.                         0,              /* User ID on client system unknown */
  1763.                         "*"             /* Ditto */
  1764.                         );
  1765.                 debug(F110,"zclose iksdmsg",iksdmsg,0);
  1766.                 write(xferlog, iksdmsg, (int)strlen(iksdmsg));
  1767.             }
  1768.         }
  1769.         debug(F101,"zclose returns","",1);
  1770.         return(1);
  1771.     }
  1772. }
  1773.  
  1774. /*  Z C H I N  --  Get a character from the input file.  */
  1775.  
  1776. /*  Returns -1 if EOF, 0 otherwise with character returned in argument  */
  1777.  
  1778. int
  1779. zchin(n,c) int n; int *c; {
  1780.     int a;
  1781.  
  1782. #ifdef IKSD
  1783.     if (inserver && !local && (n == ZCTERM || n == ZSTDIO)) {
  1784.         a = coninc(0);
  1785.         if (*c < 0)
  1786.           return(-1);
  1787.     } else
  1788. #endif /* IKSD */
  1789.     /* (PWP) Just in case this gets called when it shouldn't. */
  1790.     if (n == ZIFILE) {
  1791.         a = zminchar();            /* Note: this catches Ctrl-Z */
  1792.         if (a < 0)            /* (See zinfill()...) */
  1793.       return(-1);
  1794.     } else {
  1795.     a = getc(fp[n]);
  1796.     if (a == EOF) return(-1);
  1797. #ifdef CK_CTRLZ
  1798.     /* If SET FILE EOF CTRL-Z, first Ctrl-Z marks EOF */
  1799.     if (!binary && a == 0x1A && eofmethod == XYEOF_Z)
  1800.       return(-1);
  1801. #endif /* CK_CTRLZ */
  1802.     }
  1803.     *c = (CHAR) a & 0377;
  1804.     return(0);
  1805. }
  1806.  
  1807. /*  Z S I N L  --  Read a line from a file  */
  1808.  
  1809. /*
  1810.   Writes the line into the address provided by the caller.
  1811.   n is the Kermit "channel number".
  1812.   Writing terminates when newline is encountered, newline is not copied.
  1813.   Writing also terminates upon EOF or if length x is exhausted.
  1814.   Returns 0 on success, -1 on EOF or error.
  1815. */
  1816. int
  1817. zsinl(n,s,x) int n, x; char *s; {
  1818.     int a, z = 0;                       /* z is return code. */
  1819.     int count = 0;
  1820.     int len = 0;
  1821.     char *buf;
  1822.     extern CHAR feol;                   /* Line terminator */
  1823.  
  1824.     if (!s || chkfn(n) < 1)             /* Make sure file is open, etc */
  1825.       return(-1);
  1826.     buf = s;
  1827.     s[0] = '\0';                        /* Don't return junk */
  1828.  
  1829.     a = -1;                             /* Current character, none yet. */
  1830.     while (x--) {                       /* Up to given length */
  1831.         int old = 0;
  1832.         if (feol)                       /* Previous character */
  1833.           old = a;
  1834.         if (zchin(n,&a) < 0) {          /* Read a character from the file */
  1835.             debug(F101,"zsinl zchin fail","",count);
  1836.             if (count == 0)
  1837.               z = -1;                   /* EOF or other error */
  1838.             break;
  1839.         } else
  1840.           count++;
  1841.         if (feol) {                     /* Single-character line terminator */
  1842.             if (a == feol)
  1843.               break;
  1844.         } else {                        /* CRLF line terminator */
  1845.             if (a == '\015')            /* CR, get next character */
  1846.               continue;
  1847.             if (old == '\015') {        /* Previous character was CR */
  1848.                 if (a == '\012') {      /* This one is LF, so we have a line */
  1849.                     break;
  1850.                 } else {                /* Not LF, deposit CR */
  1851.                     *s++ = '\015';
  1852.                     x--;
  1853.                     len++;
  1854.                 }
  1855.             }
  1856.         }
  1857.         *s = a;                         /* Deposit character */
  1858.         s++;
  1859.         len++;
  1860.     }
  1861.     *s = '\0';                          /* Terminate the string */
  1862.     debug(F011,"zsinl",buf,len);
  1863.     return(z);
  1864. }
  1865.  
  1866. /*  Z X I N  --  Read x bytes from a file  */
  1867.  
  1868. /*
  1869.   Reads x bytes (or less) from channel n and writes them
  1870.   to the address provided by the caller.
  1871.   Returns number of bytes read on success, 0 on EOF or error.
  1872. */
  1873. int
  1874. zxin(n,s,x) int n, x; char *s; {
  1875. #ifdef IKSD
  1876.     if (inserver && !local && (n == ZCTERM || n == ZSTDIO)) {
  1877.         int a, i;
  1878.         a = ttchk();
  1879.         if (a < 1) return(0);
  1880.         for (i = 0; i < a && i < x; i++)
  1881.           s[i] = coninc(0);
  1882.         return(i);
  1883.     }
  1884. #endif /* IKSD */
  1885.  
  1886.     return(fread(s, sizeof (char), x, fp[n]));
  1887. }
  1888.  
  1889. /*
  1890.   Z I N F I L L  --  Buffered file input.
  1891.  
  1892.   (re)fill the file input buffer with data.  All file input
  1893.   should go through this routine, usually by calling the zminchar()
  1894.   macro defined in ckcker.h.  Returns:
  1895.  
  1896.   Value 0..255 on success, the character that was read.
  1897.   -1 on end of file.
  1898.   -2 on any kind of error other than end of file.
  1899.   -3 timeout when reading from pipe (Kermit packet mode only).
  1900. */
  1901. int
  1902. zinfill() {
  1903.     extern int kactive, srvping;
  1904.     errno = 0;
  1905.  
  1906. #ifdef ZDEBUG
  1907.     printf("ZINFILL fp[%d]=%ld\n",ZIFILE,fp[ZIFILE]);
  1908. #endif /* ZDEBUG */
  1909.  
  1910. #ifdef IKSD
  1911.     if (inserver && !local && fp[ZIFILE] == stdin) {
  1912.         int a, i;
  1913.         a = ttchk();
  1914.         if (a < 0) return(-2);
  1915.         for (i = 0; i < a && i < INBUFSIZE; i++) {
  1916.             zinbuffer[i] = coninc(0);
  1917.         }
  1918.         zincnt = i;
  1919.         /* set pointer to beginning, (== &zinbuffer[0]) */
  1920.         zinptr = zinbuffer;
  1921.         if (zincnt == 0) return(-1);
  1922.         zincnt--;                       /* One less char in buffer */
  1923.         return((int)(*zinptr++) & 0377); /* because we return the first */
  1924.     }
  1925. #endif /* IKSD */
  1926.  
  1927.     debug(F101,"zinfill kactive","",kactive);
  1928.  
  1929.     if (!(kactive && ispipe[ZIFILE])) {
  1930.         if (feof(fp[ZIFILE])) {
  1931.             debug(F100,"ZINFILL feof","",0);
  1932. #ifdef ZDEBUG
  1933.             printf("ZINFILL EOF\n");
  1934. #endif /* ZDEBUG */
  1935.             return(-1);
  1936.         }
  1937.     }
  1938.     clearerr(fp[ZIFILE]);
  1939.  
  1940. #ifdef SELECT
  1941.     /* Here we can call select() to get a timeout... */
  1942.     if (kactive && ispipe[ZIFILE]) {
  1943.         int secs, z = 0;
  1944. #ifndef NOXFER
  1945.         if (srvping) {
  1946.             secs = 1;
  1947.             debug(F101,"zinfill calling ttwait","",secs);
  1948.             z = ttwait(fileno(fp[ZIFILE]),secs);
  1949.             debug(F101,"zinfill ttwait","",z);
  1950.         }
  1951. #endif /* NOXFER */
  1952.         if (z == 0)
  1953.           return(-3);
  1954.     }
  1955. #endif /* SELECT */
  1956.  
  1957. #ifdef DEBUG
  1958.     if (deblog) {
  1959.         int i;
  1960.         debug(F101,"ZINFILL INBUFSIZE","",INBUFSIZE);
  1961. #ifdef USE_MEMCPY
  1962.         memset(zinbuffer, 0xFF, INBUFSIZE);
  1963. #else
  1964.         for (i = 0; i < INBUFSIZE; i++) {
  1965.             zinbuffer[i] = 0xFF;
  1966. #ifdef COMMENT                /* Too much! */
  1967.             debug(F101,"ZINFILL zinbuffer[i]","",i);
  1968. #endif /* COMMENT */
  1969.         }
  1970. #endif /* USE_MEMCPY */
  1971.     ckstrncpy(zinbuffer,"zinbuffer is a valid buffer",INBUFSIZE);
  1972.     /* debug(F111,"ZINFILL about to call fread",zinbuffer,zinbuffer); */
  1973.     }
  1974. #endif /* DEBUG */
  1975.  
  1976. /*
  1977.   Note: The following read MUST be nonblocking when reading from a pipe
  1978.   and we want timeouts to work.  See zxcmd().
  1979. */
  1980.     zincnt = fread(zinbuffer, sizeof (char), INBUFSIZE, fp[ZIFILE]);
  1981.     debug(F101,"ZINFILL fread","",zincnt); /* Just the size */
  1982. #ifdef ZDEBUG
  1983.     printf("FREAD=%d\n",zincnt);
  1984. #endif /* ZDEBUG */
  1985. #ifdef CK_CTRLZ
  1986.     /* If SET FILE EOF CTRL-Z, first Ctrl-Z marks EOF */
  1987.     if (zincnt > 0 && !binary && eofmethod == XYEOF_Z) {
  1988.     register int i;
  1989.     for (i = 0; i < zincnt; i++) {
  1990.         if (zinbuffer[i] == SUB) {
  1991.         zincnt = i;        /* Stop at first Ctrl-Z */
  1992.         if (i == 0)
  1993.           return(-1);
  1994.         break;
  1995.         }
  1996.         }
  1997.     }
  1998. #endif /* CK_CTRLZ */
  1999.  
  2000.     if (zincnt == 0) {                  /* Got nothing? */
  2001.         if (ferror(fp[ZIFILE])) {
  2002.             debug(F100,"ZINFILL ferror","",0);
  2003.             debug(F101,"ZINFILL errno","",errno);
  2004. #ifdef ZDEBUG
  2005.             printf("ZINFILL errno=%d\n",errno);
  2006. #endif /* ZDEBUG */
  2007. #ifdef EWOULDBLOCK
  2008.             return((errno == EWOULDBLOCK) ? -3 : -2);
  2009. #else
  2010.             return(-2);
  2011. #endif /* EWOULDBLOCK */
  2012.         }
  2013.  
  2014.     /* In case feof() didn't work just above -- sometimes it doesn't... */
  2015.  
  2016.         if (feof(fp[ZIFILE]) ) {
  2017.             debug(F100,"ZINFILL count 0 EOF return -1","",0);
  2018.             return (-1);
  2019.         } else {
  2020.             debug(F100,"ZINFILL count 0 not EOF return -2","",0);
  2021.             return(-2);
  2022.         }
  2023.     }
  2024.     zinptr = zinbuffer;    /* set pointer to beginning, (== &zinbuffer[0]) */
  2025.     zincnt--;                           /* One less char in buffer */
  2026.     return((int)(*zinptr++) & 0377);    /* because we return the first */
  2027. }
  2028.  
  2029. /*  Z S O U T  --  Write a string out to the given file, buffered.  */
  2030.  
  2031. /*  Returns 0 on success, -1 on failure */
  2032.  
  2033. int
  2034. zsout(n,s) int n; char *s; {
  2035.     int rc = 0;
  2036.     rc = chkfn(n);
  2037.     if (rc < 1) return(-1);             /* Keep this, prevents memory faults */
  2038.     if (!s) return(0);                  /* Null pointer, do nothing, succeed */
  2039.     if (!*s) return(0);                 /* empty string, ditto */
  2040.  
  2041. #ifdef IKSD
  2042.     /*
  2043.       This happens with client-side Kermit server when a REMOTE command
  2044.       was sent from the server to the client and the server is supposed to
  2045.       display the text, but of course there is no place to display it
  2046.       since it is in remote mode executing Kermit protocol.
  2047.     */
  2048.     if (inserver && !local && (n == ZCTERM || n == ZSTDIO)) {
  2049. #ifdef COMMENT
  2050.         return(ttol(s,((int)strlen(s)) < 0) ? -1 : 0);
  2051. #else
  2052.         return(0);
  2053. #endif /* COMMENT */
  2054.     }
  2055. #endif /* IKSD */
  2056.  
  2057.     if (n == ZSFILE) {
  2058.     int k;
  2059.     k = strlen(s);
  2060.     rc = write(fileno(fp[n]),s,k);
  2061.     return((rc == k) ? 0 : -1);
  2062.     }
  2063.     rc = fputs(s,fp[n]) == EOF ? -1 : 0;
  2064.     if (n == ZWFILE)
  2065.       fflush(fp[n]);
  2066.     return(rc);
  2067. }
  2068.  
  2069. /*  Z S O U T L  --  Write string to file, with line terminator, buffered  */
  2070.  
  2071. /*  Returns 0 on success, -1 on failure */
  2072.  
  2073. int
  2074. zsoutl(n,s) int n; char *s; {
  2075.     if (zsout(n,s) < 0)
  2076.         return(-1);
  2077.  
  2078. #ifdef IKSD
  2079.     if (inserver && !local && (n == ZCTERM || n == ZSTDIO)) {
  2080. #ifdef COMMENT
  2081.         return(ttoc(LF));
  2082. #else
  2083.         return(0);                      /* See comments in zsout() */
  2084. #endif /* COMMENT */
  2085.     }
  2086. #endif /* IKSD */
  2087.  
  2088.     if (n == ZSFILE)                    /* Session log is unbuffered */
  2089.       return(write(fileno(fp[n]),"\n",1) == 1 ? 0 : -1);
  2090.     else if (fputs("\n",fp[n]) == EOF)
  2091.       return(-1);
  2092.     if (n == ZDIFIL || n == ZWFILE)     /* Flush connection log records */
  2093.       fflush(fp[n]);
  2094.     return(0);
  2095. }
  2096.  
  2097. /*  Z S O U T X  --  Write x characters to file, unbuffered.  */
  2098.  
  2099. /*  Returns number of characters written on success, -1 on failure */
  2100.  
  2101. int
  2102. zsoutx(n,s,x) int n, x; char *s; {
  2103.     int k;
  2104.     if (!s) return(0);
  2105.     if (!*s) return(0);
  2106.  
  2107. #ifdef IKSD
  2108.     if (inserver && !local && (n == ZCTERM || n == ZSTDIO)) {
  2109. #ifdef COMMENT
  2110.         return(ttol(s,x));              /* See comments in zsout() */
  2111. #else
  2112.         return(x);
  2113. #endif /* COMMENT */
  2114.     }
  2115. #endif /* IKSD */
  2116.  
  2117.     if ((k = (int)strlen(s)) > x) x = k; /* Nothing else would make sense */
  2118. #ifdef COMMENT
  2119.     if (chkfn(n) < 1) return(-1);
  2120.     return(write(fp[n]->_file,s,x));
  2121. #endif /* COMMENT */
  2122.     return(write(fileno(fp[n]),s,x) == x ? x : -1);
  2123. }
  2124.  
  2125. /*  Z C H O U T  --  Add a character to the given file.  */
  2126.  
  2127. /*  Should return 0 or greater on success, -1 on failure (e.g. disk full)  */
  2128.  
  2129. int
  2130. #ifdef CK_ANSIC
  2131. zchout(register int n, char c)
  2132. #else
  2133. zchout(n,c) register int n; char c;
  2134. #endif /* CK_ANSIC */
  2135. /* zchout() */ {
  2136.     /* if (chkfn(n) < 1) return(-1); */
  2137.  
  2138. #ifdef IKSD
  2139.     if (inserver && !local && (n == ZCTERM || n == ZSTDIO)) {
  2140. #ifdef COMMENT
  2141.         return(ttoc(c));
  2142. #else
  2143.         return(0);                      /* See comments in zsout() */
  2144. #endif /* COMMENT */
  2145.     }
  2146. #endif /* IKSD */
  2147.  
  2148.     if (n == ZSFILE)                    /* Use unbuffered for session log */
  2149.       return(write(fileno(fp[n]),&c,1) == 1 ? 0 : -1);
  2150.                                 /* Buffered for everything else */
  2151.     if (putc(c,fp[n]) == EOF)   /* If true, maybe there was an error */
  2152.       return(ferror(fp[n])?-1:0);       /* Check to make sure */
  2153.     else                                /* Otherwise... */
  2154.       return(0);                        /* There was no error. */
  2155. }
  2156.  
  2157. /* (PWP) buffered character output routine to speed up file IO */
  2158.  
  2159. int
  2160. zoutdump() {
  2161.     int x;
  2162.     char * zp;
  2163.     zoutptr = zoutbuffer;               /* Reset buffer pointer in all cases */
  2164. #ifdef DEBUG
  2165.     if (deblog)
  2166.       debug(F101,"zoutdump zoutcnt","",zoutcnt);
  2167. #endif /* DEBUG */
  2168.     if (zoutcnt == 0) {                 /* Nothing to output */
  2169.         return(0);
  2170.     } else if (zoutcnt < 0) {           /* Unexpected negative argument */
  2171.         zoutcnt = 0;                    /* Reset output buffer count */
  2172.         return(-1);                     /* and fail. */
  2173.     }
  2174.  
  2175. #ifdef IKSD
  2176.     if (inserver && !local && fp[ZOFILE] == stdout) {
  2177. #ifdef COMMENT
  2178.         x = ttol(zoutbuffer,zoutcnt);
  2179. #else
  2180.         x = 1;                          /* See comments in zsout() */
  2181. #endif /* COMMENT */
  2182.         zoutcnt = 0;
  2183.         return(x > 0 ? 0 : -1);
  2184.     }
  2185. #endif /* IKSD */
  2186.  
  2187. /*
  2188.   Frank Prindle suggested that replacing this fwrite() by an fflush()
  2189.   followed by a write() would improve the efficiency, especially when
  2190.   writing to stdout.  Subsequent tests showed a 5-fold improvement.
  2191. */
  2192. #ifdef COMMENT
  2193.     if (x = fwrite(zoutbuffer, 1, zoutcnt, fp[ZOFILE])) ...
  2194. #endif /* COMMENT */
  2195.  
  2196. #ifndef CK_NONBLOCK
  2197.     fflush(fp[ZOFILE]);
  2198. #endif /* CK_NONBLOCK */
  2199.     zp = zoutbuffer;
  2200.     while (zoutcnt > 0) {
  2201.         if ((x = write(fileno(fp[ZOFILE]),zp,zoutcnt)) > -1) {
  2202. #ifdef DEBUG
  2203.             if (deblog)                 /* Save a function call... */
  2204.               debug(F101,"zoutdump wrote","",x);
  2205. #endif /* DEBUG */
  2206.             zoutcnt -= x;               /* Adjust output buffer count */
  2207.             zp += x;                    /* and pointer */
  2208.         } else {
  2209. #ifdef DEBUG
  2210.             if (deblog) {
  2211.                 debug(F101,"zoutdump write error","",errno);
  2212.                 debug(F101,"zoutdump write returns","",x);
  2213.             }
  2214. #endif /* DEBUG */
  2215.             zoutcnt = 0;                /* Reset output buffer count */
  2216.             return(-1);                 /* write() failed */
  2217.         }
  2218.     }
  2219.     return(0);
  2220. }
  2221.  
  2222. /*  C H K F N  --  Internal function to verify file number is ok  */
  2223.  
  2224. /*
  2225.  Returns:
  2226.   -1: File number n is out of range
  2227.    0: n is in range, but file is not open
  2228.    1: n in range and file is open
  2229. */
  2230. int
  2231. chkfn(n) int n; {
  2232.     /* if (n != ZDFILE) debug(F101,"chkfn","",n); */
  2233.     if (n < 0 || n >= ZNFILS) {
  2234.         if (n != ZDFILE) debug(F101,"chkfn out of range","",n);
  2235.         return(-1);
  2236.     } else {
  2237.         /* if (n != ZDFILE) debug(F101,"chkfn fp[n]","",fp[n]); */
  2238.         return((fp[n] == NULL) ? 0 : 1);
  2239.     }
  2240. }
  2241.  
  2242. /*  Z G E T F S -- Return file size regardless of accessibility */
  2243. /*
  2244.   Used for directory listings, etc.
  2245.   Returns:
  2246.     The size of the file in bytes, 0 or greater, if the size can be learned.
  2247.     -1 if the file size can not be obtained.
  2248.   Also (and this is a hack just for UNIX):
  2249.     If the argument is the name of a symbolic link,
  2250.     the global variable issymlink is set to 1,
  2251.     and the global buffer linkname[] gets the link value.
  2252.     And it sets zgfs_dir to 1 if it's a directory, otherwise 0.
  2253.   This lets us avoid numerous redundant calls to stat().
  2254. */
  2255. int zgfs_link = 0;
  2256. int zgfs_dir = 0;
  2257. time_t zgfs_mtime = 0;
  2258. unsigned int zgfs_mode = 0;
  2259.  
  2260. #ifdef CKSYMLINK
  2261. char linkname[CKMAXPATH+1];
  2262. #ifndef _IFLNK
  2263. #define _IFLNK 0120000
  2264. #endif /* _IFLNK */
  2265. #endif /* CKSYMLINK */
  2266.  
  2267. CK_OFF_T
  2268. zgetfs(name) char *name; {
  2269.     struct stat buf;
  2270.     char fnam[CKMAXPATH+4];
  2271.     CK_OFF_T size = (CK_OFF_T)-1;
  2272.     int x;
  2273.     int needrlink = 0;
  2274.     char * s;
  2275.  
  2276.     if (!name) name = "";
  2277.     if (!*name) return(-1);
  2278.  
  2279. #ifdef UNIX
  2280.     x = strlen(name);
  2281.     if (x == 9 && !strcmp(name,"/dev/null"))
  2282.       return(0);
  2283. #endif /* UNIX */
  2284.  
  2285.     s = name;
  2286. #ifdef DTILDE
  2287.     if (*s == '~') {
  2288.         s = tilde_expand(s);
  2289.         if (!s) s = "";
  2290.         if (!*s) s = name;
  2291.     }
  2292. #endif /* DTILDE */
  2293.     x = ckstrncpy(fnam,s,CKMAXPATH);
  2294.     s = fnam;
  2295.     debug(F111,"zgetfs fnam",s,x);
  2296.     if (x > 0 && s[x-1] == '/')
  2297.       s[x-1] = '\0';
  2298.  
  2299.     zgfs_dir = 0;                       /* Assume it's not a directory */
  2300.     zgfs_link = 0;                      /* Assume it's not a symlink */
  2301.     zgfs_mtime = 0;            /* No time yet */
  2302.     zgfs_mode = 0;            /* No permission bits yet */
  2303.  
  2304. #ifdef CKSYMLINK                        /* We're doing symlinks? */
  2305. #ifdef USE_LSTAT                        /* OK to use lstat()? */
  2306.     x = lstat(s,&buf);
  2307.     debug(F101,"STAT","",1);
  2308.     if (x < 0)                          /* stat() failed */
  2309.       return(-1);
  2310.     if (                                /* Now see if it's a symlink */
  2311. #ifdef S_ISLNK
  2312.         S_ISLNK(buf.st_mode)
  2313. #else
  2314. #ifdef _IFLNK
  2315.         ((_IFMT & buf.st_mode) == _IFLNK)
  2316. #endif /* _IFLNK */
  2317. #endif /* S_ISLNK */
  2318.         ) {
  2319.         zgfs_link = 1;                  /* It's a symlink */
  2320.         linkname[0] = '\0';             /* Get the name */
  2321.         x = readlink(s,linkname,CKMAXPATH);
  2322.         debug(F101,"zgetfs readlink",s,x);
  2323.         if (x > -1 && x < CKMAXPATH) {  /* It's a link */
  2324.             linkname[x] = '\0';
  2325.             size = buf.st_size;         /* Remember size of link */
  2326.             x = stat(s,&buf);           /* Now stat the linked-to file */
  2327.         debug(F101,"STAT","",2);
  2328.             if (x < 0)                  /* so we can see if it's a directory */
  2329.               return(-1);
  2330.         } else {
  2331.             ckstrncpy(linkname,"(lookup failed)",CKMAXPATH);
  2332.         }
  2333.     }
  2334. #else  /* !USE_LSTAT */
  2335.     x = stat(s,&buf);                   /* No lstat(), use stat() instead */
  2336.     debug(F101,"STAT","",3);
  2337.     if (x < 0)
  2338.       return(-1);
  2339. #endif /* USE_LSTAT */
  2340.  
  2341.     /* Do we need to call readlink()? */
  2342.  
  2343. #ifdef NOLINKBITS
  2344. /*
  2345.   lstat() does not work in SCO operating systems.  From "man NS lstat":
  2346.  
  2347.   lstat obtains information about the file named by path. In the case of a
  2348.   symbolic link, lstat returns information about the link, and not the file
  2349.   named by the link. It is only used by the NFS automount daemon and should
  2350.   not be utilized by users.
  2351. */
  2352.     needrlink = 1;
  2353.     debug(F101,"zgetfs forced needrlink","",needrlink);
  2354. #else
  2355. #ifdef S_ISLNK
  2356.     needrlink = S_ISLNK(buf.st_mode);
  2357.     debug(F101,"zgetfs S_ISLNK needrlink","",needrlink);
  2358. #else
  2359. #ifdef _IFLNK
  2360.     needrlink = (_IFMT & buf.st_mode) == _IFLNK;
  2361.     debug(F101,"zgetfs _IFLNK needrlink","",needrlink);
  2362. #else
  2363.     needrlink = 1;
  2364.     debug(F101,"zgetfs default needrlink","",needrlink);
  2365. #endif /* _IFLNK */
  2366. #endif /* S_ISLNK */
  2367. #endif /* NOLINKBITS */
  2368.  
  2369.     if (needrlink) {
  2370.         linkname[0] = '\0';
  2371.         errno = 0;
  2372.         x = readlink(s,linkname,CKMAXPATH);
  2373. #ifdef DEBUG
  2374.         debug(F111,"zgetfs readlink",s,x);
  2375.         if (x < 0)
  2376.           debug(F101,"zgetfs readlink errno","",errno);
  2377.         else
  2378.           debug(F110,"zgetfs readlink result",linkname,0);
  2379. #endif /* DEBUG */
  2380.         if (x > -1 && x < CKMAXPATH) {
  2381.             zgfs_link = 1;
  2382.             linkname[x] = '\0';
  2383.         }
  2384.     }
  2385. #else  /* !CKSYMLINK */
  2386.     x = stat(s,&buf);                   /* Just stat the file */
  2387.     debug(F111,"zgetfs stat",s,x);
  2388.     if (x < 0)                          /* and get the size */
  2389.       return(-1);
  2390. #endif /* CKSYMLINK */
  2391.  
  2392.     zgfs_mtime = buf.st_mtime;
  2393.     zgfs_mode = buf.st_mode;
  2394.     zgfs_dir = (S_ISDIR(buf.st_mode)) ? 1 : 0; /* Set "is directory" flag */
  2395.     debug(F111,"zgetfs size",s,size);
  2396.     debug(F111,"zgetfs st_size",s,buf.st_size);
  2397.     return((size < 0L) ? buf.st_size : size); /* Return the size */
  2398. }
  2399.  
  2400.  
  2401. /*  Z C H K I  --  Check if input file exists and is readable  */
  2402.  
  2403. /*
  2404.   Returns:
  2405.    >= 0 if the file can be read (returns the size).
  2406.      -1 if file doesn't exist or can't be accessed,
  2407.      -2 if file exists but is not readable (e.g. a directory file).
  2408.      -3 if file exists but protected against read access.
  2409.  
  2410.   For Berkeley Unix, a file must be of type "regular" to be readable.
  2411.   Directory files, special files, and symbolic links are not readable.
  2412. */
  2413. CK_OFF_T
  2414. zchki(name) char *name; {
  2415.     struct stat buf;
  2416.     char * s;
  2417.     int x, itsadir = 0;
  2418.     extern int zchkid, diractive, matchfifo;
  2419.  
  2420.     if (!name)
  2421.       return(-1);
  2422.     x = strlen(name);
  2423.     if (x < 1)
  2424.       return(-1);
  2425.     s = name;
  2426.  
  2427. #ifdef UNIX
  2428.     if (x == 9 && !strcmp(s,"/dev/null"))
  2429.       return(0);
  2430.     if (x == 8 && !strcmp(s,"/dev/tty"))
  2431.       return(0);
  2432. #endif /* UNIX */
  2433.  
  2434. #ifdef DTILDE
  2435.     if (*s == '~') {
  2436.         s = tilde_expand(s);
  2437.         if (!s) s = "";
  2438.         if (!*s) s = name;
  2439.     }
  2440. #endif /* DTILDE */
  2441.  
  2442. #ifdef CKROOT
  2443.     debug(F111,"zchki setroot",ckroot,ckrootset);
  2444.     if (ckrootset) if (!zinroot(name)) {
  2445.     debug(F110,"zchki setroot violation",name,0);
  2446.     return(-1);
  2447.     }
  2448. #endif /* CKROOT */
  2449.  
  2450.     x = stat(s,&buf);
  2451.     debug(F101,"STAT","",5);
  2452.     if (x < 0) {
  2453.         debug(F111,"zchki stat fails",s,errno);
  2454.         return(-1);
  2455.     }
  2456.     if (S_ISDIR (buf.st_mode))
  2457.       itsadir = 1;
  2458.  
  2459.     if (!(itsadir && zchkid)) {         /* Unless this... */
  2460.         if (!S_ISREG (buf.st_mode)      /* Must be regular file */
  2461. #ifdef S_ISFIFO
  2462.             && (!matchfifo || !S_ISFIFO (buf.st_mode))  /* or FIFO */
  2463. #endif /* S_ISFIFO */
  2464.             ) {
  2465.             debug(F111,"zchki not regular file (or fifo)",s,matchfifo);
  2466.             return(-2);
  2467.         }
  2468.     }
  2469.     debug(F111,"zchki stat ok:",s,x);
  2470.  
  2471.     if (diractive) {            /* If listing don't check access */
  2472.     x = 1;
  2473.     } else {
  2474. #ifdef SW_ACC_ID
  2475.     debug(F100,"zchki swapping ids for access()","",0);
  2476.     priv_on();
  2477. #endif /* SW_ACC_ID */
  2478.     if ((x = access(s,R_OK)) < 0)
  2479.       x = access(s,X_OK);        /* For RUN-class commands */
  2480. #ifdef SW_ACC_ID
  2481.     priv_off();
  2482.     debug(F100,"zchki swapped ids restored","",0);
  2483. #endif /* SW_ACC_ID */
  2484.     }
  2485.     if (x < 0) {            /* Is the file accessible? */
  2486.         debug(F111,"zchki access failed:",s,x); /* No */
  2487.         return(-3);
  2488.     } else {
  2489.         iflen = buf.st_size;            /* Yes, remember size */
  2490.         ckstrncpy(nambuf,s,CKMAXPATH);  /* and name globally. */
  2491.         debug(F111,"zchki access ok:",s,iflen);
  2492.         return((iflen > -1L) ? iflen : 0L);
  2493.     }
  2494. }
  2495.  
  2496. /*  Z C H K O  --  Check if output file can be created  */
  2497.  
  2498. /*
  2499.   Returns -1 if write permission for the file would be denied, 0 otherwise.
  2500.  
  2501.   NOTE: The design is flawed.  There is no distinction among:
  2502.    . Can I overwrite an existing file?
  2503.    . Can I create a file (or directory) in an existing directory?
  2504.    . Can I create a file (or directory) and its parent(s)?
  2505. */
  2506. int
  2507. zchko(name) char *name; {
  2508.     int i, x, itsadir = 0;
  2509.     char *s = NULL;
  2510.     char * oname;
  2511.     extern int zchkod;                  /* Used by IF WRITEABLE */
  2512.  
  2513.     debug(F110,"zchko entry",name,0);
  2514.  
  2515.     if (!name) return(-1);              /* Watch out for null pointer. */
  2516.  
  2517.     oname = name;
  2518.  
  2519. #ifdef CKROOT
  2520.     debug(F111,"zchko setroot",ckroot,ckrootset);
  2521.     if (ckrootset) if (!zinroot(name)) {
  2522.     debug(F110,"zchko setroot violation",name,0);
  2523.     errno = EACCES;
  2524.     return(-1);
  2525.     }
  2526. #endif /* CKROOT */
  2527.  
  2528.     x = (int)strlen(name);              /* Get length of filename */
  2529.     debug(F111,"zchko len",name,x);
  2530.     debug(F111,"zchko zchkod",name,zchkod);
  2531.  
  2532. #ifdef UNIX
  2533. /*
  2534.   Writing to null device is OK.
  2535. */
  2536.     if (x == 9 && !strcmp(name,"/dev/null"))
  2537.       return(0);
  2538.     if (x == 8 && !strcmp(name,"/dev/tty"))
  2539.       return(0);
  2540. #endif /* UNIX */
  2541.  
  2542.     s = name;
  2543. #ifdef DTILDE
  2544.     if (*s == '~') {
  2545.         s = tilde_expand(s);
  2546.         if (!s) s = "";
  2547.         if (!*s) s = name;
  2548.     x = strlen(s);
  2549.     }
  2550. #endif /* DTILDE */
  2551.     name = s;
  2552.     s = NULL;
  2553. /*
  2554.   zchkod is a global flag meaning we're checking not to see if the directory
  2555.   file is writeable, but if it's OK to create files IN the directory.
  2556. */
  2557.     if (!zchkod && isdir(name)) {    /* Directories are not writeable */
  2558.     debug(F111,"zchko isdir",name,1);
  2559.     return(-1);
  2560.     }
  2561.     s = malloc(x+3);                    /* Must copy because we can't */
  2562.     if (!s) {                           /* write into our argument. */
  2563.         fprintf(stderr,"zchko: Malloc error 46\n");
  2564.         return(-1);
  2565.     }
  2566.     ckstrncpy(s,name,x+3);
  2567. #ifdef UNIX
  2568. #ifdef NOUUCP
  2569.     {                    /* 2009/10/20 */
  2570.     /* Allow tty devices to opened as output files */
  2571.     int fd, istty = 0, mode = 0;
  2572.     debug(F110,"zchko attempting to open",name,0);
  2573.     /* Don't block on lack of Carrier or other modem signals */
  2574. #ifdef O_NONBLOCK
  2575.     mode = O_NONBLOCK;
  2576. #else
  2577. #ifdef O_NDELAY
  2578.     mode = O_NDELAY;
  2579. #else
  2580. #ifdef FNDELAY
  2581.     mode = FNDELAY;
  2582. #endif /* FNDELAY */
  2583. #endif    /* O_NDELAY */
  2584. #endif    /* O_NONBLOCK */
  2585.     debug(F111,"zchko open mode",name,mode);
  2586.     fd = open(name,O_WRONLY,mode);    /* Must attempt to open it */
  2587.     debug(F111,"zchko open",name,fd); 
  2588.     if (fd > -1) {            /* to get a file descriptor */
  2589.         if (isatty(fd))        /* for isatty() */
  2590.           istty++;
  2591.         debug(F111,"zchko isatty",name,istty);
  2592.         fd = close(fd);
  2593.         if (istty) {
  2594.         goto doaccess;
  2595.         }
  2596.     } else {
  2597.         debug(F101,"zchko open errno","",errno); 
  2598.         x = -1;
  2599.     }
  2600.     }
  2601. #endif    /* NOUUCP */
  2602. #endif    /* UNIX */
  2603.     for (i = x; i > 0; i--) {           /* Strip filename from right. */
  2604.         if (ISDIRSEP(s[i-1])) {
  2605.             itsadir = 1;
  2606.             break;
  2607.         }
  2608.     }
  2609.     debug(F101,"zchko i","",i);
  2610.     debug(F101,"zchko itsadir","",itsadir);
  2611.  
  2612. #ifdef COMMENT
  2613. /* X/OPEN XPG3-compliant systems fail if argument ends with "/"...  */
  2614.     if (i == 0)                         /* If no path, use current directory */
  2615.       strcpy(s,"./");
  2616.     else                                /* Otherwise, use given one. */
  2617.       s[i] = '\0';
  2618. #else
  2619. #ifdef COMMENT
  2620. /*
  2621.   The following does not work for "foo/bar" where the foo directory does
  2622.   not exist even though we could create it: access("foo/.") fails, but
  2623.   access("foo") works OK.
  2624. */
  2625. /* So now we use "path/." if path given, or "." if no path given. */
  2626.     s[i++] = '.';                       /* Append "." to path. */
  2627.     s[i] = '\0';
  2628. #else
  2629. /* So NOW we strip path segments from the right as long as they don't */
  2630. /* exist -- we only call access() for path segments that *do* exist.. */
  2631. /* (But this isn't quite right either since now zchko(/foo/bar/baz/xxx) */
  2632. /* succeeds when I have write access to foo and bar but baz doesn't exit.) */
  2633.  
  2634.     if (itsadir && i > 0) {
  2635.         s[i-1] = '\0';
  2636.         while (s[0] && !isdir(s)) {
  2637.             for (i = (int)strlen(s); i > 0; i--) {
  2638.                 if (ISDIRSEP(s[i-1])) {
  2639.                     s[i-1] = '\0';
  2640.                     break;
  2641.                 }
  2642.             }
  2643.             if (i == 0)
  2644.               s[0] = '\0';
  2645.         }
  2646.     } else {
  2647.         s[i++] = '.';                   /* Append "." to path. */
  2648.         s[i] = '\0';
  2649.     }
  2650. #endif /* COMMENT */
  2651. #endif /* COMMENT */
  2652.  
  2653.     if (!s[0])
  2654.       ckstrncpy(s,".",x+3);
  2655.  
  2656.   doaccess:
  2657.  
  2658. #ifdef SW_ACC_ID
  2659.     debug(F100,"zchko swapping ids for access()","",0);
  2660.     priv_on();
  2661. #endif /* SW_ACC_ID */
  2662.  
  2663.     x = access(s,W_OK);                 /* Check access of path. */
  2664.  
  2665. #ifdef SW_ACC_ID
  2666.     priv_off();
  2667.     debug(F100,"zchko swapped ids restored","",0);
  2668. #endif /* SW_ACC_ID */
  2669.  
  2670.     if (x < 0)
  2671.       debug(F111,"zchko access failed:",s,errno);
  2672.     else
  2673.       debug(F111,"zchko access ok:",s,x);
  2674.     if (s) free(s);            /* Free temporary storage */
  2675.  
  2676.     return((x < 0) ? -1 : 0);           /* and return. */
  2677. }
  2678.  
  2679. /*  Z D E L E T  --  Delete the named file.  */
  2680.  
  2681. /* Returns: -1 on error, 0 on success */
  2682.  
  2683. int
  2684. zdelet(name) char *name; {
  2685.     int x;
  2686. #ifdef CK_LOGIN
  2687.     if (isguest)
  2688.       return(-1);
  2689. #endif /* CK_LOGIN */
  2690.  
  2691. #ifdef CKROOT
  2692.     debug(F111,"zdelet setroot",ckroot,ckrootset);
  2693.     if (ckrootset) if (!zinroot(name)) {
  2694.     debug(F110,"zdelet setroot violation",name,0);
  2695.     return(-1);
  2696.     }
  2697. #endif /* CKROOT */
  2698.  
  2699.     x = unlink(name);
  2700.     debug(F111,"zdelet",name,x);
  2701. #ifdef CKSYSLOG
  2702.     if (ckxsyslog >= SYSLG_FC && ckxlogging) {
  2703.         fullname[0] = '\0';
  2704.         zfnqfp(name,CKMAXPATH,fullname);
  2705.         debug(F110,"zdelet fullname",fullname,0);
  2706.         if (x < 0)
  2707.           syslog(LOG_INFO, "file[] %s: delete failed (%m)", fullname);
  2708.         else
  2709.           syslog(LOG_INFO, "file[] %s: delete ok", fullname);
  2710.     }
  2711. #endif /* CKSYSLOG */
  2712.     return(x);
  2713. }
  2714.  
  2715. /*  Z R T O L  --  Convert remote filename into local form  */
  2716.  
  2717. VOID
  2718. zrtol(name,name2) char *name, *name2; {
  2719.     nzrtol(name,name2,1,0,CKMAXPATH);
  2720. }
  2721.  
  2722. VOID
  2723. nzrtol(name,name2,fncnv,fnrpath,max)
  2724.     char *name, *name2; int fncnv, fnrpath, max;
  2725. { /* nzrtol */
  2726.     char *s, *p;
  2727.     int flag = 0, n = 0;
  2728.     char fullname[CKMAXPATH+1];
  2729.     int devnull = 0;
  2730.     int acase = 0;
  2731.     if (!name2) return;
  2732.     if (!name) name = "";
  2733.  
  2734.     debug(F111,"nzrtol name",name,fncnv);
  2735.  
  2736. #ifdef DTILDE
  2737.     s = name;
  2738.     if (*s == '~') {
  2739.         s = tilde_expand(s);
  2740.         if (!s) s = "";
  2741.         if (*s) name = s;
  2742.     }
  2743. #endif /* DTILDE */
  2744.  
  2745.     /* Handle the path -- we don't have to convert its format, since */
  2746.     /* the standard path format and our (UNIX) format are the same. */
  2747.  
  2748.     fullname[0] = NUL;
  2749.     devnull = !strcmp(name,"/dev/null");
  2750.  
  2751.     if (!devnull && fnrpath == PATH_OFF) { /* RECEIVE PATHNAMES OFF */
  2752.         zstrip(name,&p);
  2753.         strncpy(fullname,p,CKMAXPATH);
  2754.     } else if (!devnull && fnrpath == PATH_ABS) { /* REC PATHNAMES ABSOLUTE */
  2755.         strncpy(fullname,name,CKMAXPATH);
  2756.     } else if (!devnull && isabsolute(name)) { /* RECEIVE PATHNAMES RELATIVE */
  2757.     ckmakmsg(fullname,CKMAXPATH,".",name,NULL,NULL);
  2758.     } else {                            /* Ditto */
  2759.         ckstrncpy(fullname,name,CKMAXPATH);
  2760.     }
  2761.     fullname[CKMAXPATH] = NUL;
  2762.     debug(F110,"nzrtol fullname",fullname,0);
  2763.  
  2764. #ifndef NOTRUNCATE
  2765. /*
  2766.   The maximum length for any segment of a filename is MAXNAMLEN, defined
  2767.   above.  On some platforms (at least QNX) if a segment exceeds this limit,
  2768.   the open fails with ENAMETOOLONG, so we must prevent it by truncating each
  2769.   overlong name segment to the maximum segment length before passing the
  2770.   name to open().  This must be done even when file names are literal, so as
  2771.   not to halt a file transfer unnecessarily.
  2772. */
  2773.     {
  2774.         char buf[CKMAXPATH+1];          /* New temporary buffer on stack */
  2775.         char *p = fullname;             /* Source and  */
  2776.         char *s = buf;                  /* destination pointers */
  2777.         int i = 0, n = 0;
  2778.         debug(F101,"nzrtol sizing MAXNAMLEN","",MAXNAMLEN);
  2779.         while (*p && n < CKMAXPATH) {   /* Copy name to new buffer */
  2780.             if (++i > MAXNAMLEN) {      /* If this segment too long */
  2781.                 while (*p && *p != '/') /* skip past the rest... */
  2782.                   p++;
  2783.                 i = 0;                  /* and reset counter. */
  2784.             } else if (*p == '/') {     /* End of this segment. */
  2785.                 i = 0;                  /* Reset counter. */
  2786.             }
  2787.             *s++ = *p++;                /* Copy this character. */
  2788.             n++;
  2789.         }
  2790.         *s = NUL;
  2791.         ckstrncpy(fullname,buf,CKMAXPATH); /* Copy back to original buffer. */
  2792.         debug(F111,"nzrtol sizing",fullname,n);
  2793.     }
  2794. #endif /* NOTRUNCATE */
  2795.  
  2796.     if (!fncnv || devnull) {            /* Not converting */
  2797.         ckstrncpy(name2,fullname,max);  /* We're done. */
  2798.         return;
  2799.     }
  2800.     name = fullname;                    /* Converting */
  2801.  
  2802.     p = name2;
  2803.     for (; *name != '\0' && n < maxnam; name++) {
  2804.         if (*name > SP) flag = 1;       /* Strip leading blanks and controls */
  2805.         if (flag == 0 && *name < '!')
  2806.           continue;
  2807.     if (fncnv > 0) {
  2808.         if (*name == SP) {
  2809.         *p++ = '_';
  2810.         n++;
  2811.         continue;
  2812.         }
  2813.         if (isupper(*name))        /* Check for mixed case */
  2814.           acase |= 1;
  2815.         else if (islower(*name))
  2816.           acase |= 2;
  2817.     }
  2818.         *p++ = *name;
  2819.         n++;
  2820.     }
  2821.     *p-- = '\0';                        /* Terminate */
  2822.     while (*p < '!' && p > name2)       /* Strip trailing blanks & controls */
  2823.       *p-- = '\0';
  2824.  
  2825.     if (*name2 == '\0') {               /* Nothing left? */
  2826.         ckstrncpy(name2,"NONAME",max);    /* do this... */
  2827.     } else if (acase == 1) {            /* All uppercase? */
  2828.         p = name2;                      /* So convert all letters to lower */
  2829.         while (*p) {
  2830.             if (isupper(*p))
  2831.               *p = tolower(*p);
  2832.             p++;
  2833.         }
  2834.     }
  2835.     debug(F110,"nzrtol new name",name2,0);
  2836. }
  2837.  
  2838.  
  2839. /*  Z S T R I P  --  Strip device & directory name from file specification */
  2840.  
  2841. /*  Strip pathname from filename "name", return pointer to result in name2 */
  2842.  
  2843. static char work[CKMAXPATH+1];
  2844.  
  2845. VOID
  2846. zstrip(name,name2) char *name, **name2; {
  2847.     char *cp, *pp;
  2848.     int n = 0;
  2849.  
  2850.     debug(F110,"zstrip before",name,0);
  2851.     if (!name) { *name2 = ""; return; }
  2852.     pp = work;
  2853. #ifdef DTILDE
  2854.     /* Strip leading tilde */
  2855.     if (*name == '~') name++;
  2856.     debug(F110,"zstrip after tilde-stripping",name,0);
  2857. #endif /* DTILDE */
  2858.     for (cp = name; *cp; cp++) {
  2859.         if (ISDIRSEP(*cp)) {
  2860.             pp = work;
  2861.             n = 0;
  2862.         } else {
  2863.             *pp++ = *cp;
  2864.             if (n++ >= CKMAXPATH)
  2865.               break;
  2866.         }
  2867.     }
  2868.     *pp = '\0';                         /* Terminate the string */
  2869.     *name2 = work;
  2870.     debug(F110,"zstrip after",*name2,0);
  2871. }
  2872.  
  2873. /*  Z L T O R  --  Local TO Remote */
  2874.  
  2875. VOID
  2876. zltor(name,name2) char *name, *name2; {
  2877.     nzltor(name,name2,1,0,CKMAXPATH);
  2878. }
  2879.  
  2880. /*  N Z L T O R  --  New Local TO Remote */
  2881.  
  2882. /*
  2883.   fncnv = 0 for no conversion, > 0 for regular conversion, < 0 for minimal.
  2884. */
  2885. VOID
  2886. nzltor(name,name2,fncnv,fnspath,max)
  2887.     char *name, *name2; int fncnv, fnspath, max;
  2888. { /* nzltor */
  2889.     char *cp, *pp;
  2890. #ifdef COMMENT
  2891.     int dc = 0;
  2892. #endif /* COMMENT */
  2893.     int n = 0;
  2894.     char *dotp = NULL;
  2895.     char *dirp = NULL;
  2896.     char fullname[CKMAXPATH+1];
  2897.     char *p;
  2898.     CHAR c;
  2899.  
  2900. #ifndef NOCSETS
  2901.     extern int fcharset, /* tcharset, */ language;
  2902.     int langsv;
  2903.     _PROTOTYP ( CHAR (*sxo), (CHAR) ) = NULL; /* Translation functions */
  2904. #ifdef CK_ANSIC
  2905.     extern CHAR (*xls[MAXTCSETS+1][MAXFCSETS+1])(CHAR);
  2906. #else
  2907.     extern CHAR (*xls[MAXTCSETS+1][MAXFCSETS+1])();
  2908. #endif /* CK_ANSIC */
  2909.     langsv = language;
  2910.     language = L_USASCII;
  2911. #ifdef COMMENT
  2912.     /* Proper translation of filenames must be done elsewhere */
  2913.     n = tcharset ? tcharset : TC_USASCII;
  2914.     sxo = xls[n][fcharset];
  2915. #else
  2916.     sxo = xls[TC_USASCII][fcharset];
  2917. #endif /* COMMENT */
  2918. #endif /* NOCSETS */
  2919.  
  2920.     debug(F110,"nzltor name",name,0);
  2921.  
  2922.     /* Handle pathname */
  2923.  
  2924.     fullname[0] = NUL;
  2925.     if (fnspath == PATH_OFF) {          /* PATHNAMES OFF */
  2926.         zstrip(name,&p);
  2927.         ckstrncpy(fullname,p,CKMAXPATH);
  2928.     } else {                            /* PATHNAMES RELATIVE or ABSOLUTE */
  2929.         char * p = name;
  2930.         while (1) {
  2931.             if (!strncmp(p,"../",3))
  2932.               p += 3;
  2933.             else if (!strncmp(p,"./",2))
  2934.               p += 2;
  2935.             else
  2936.               break;
  2937.         }
  2938.         if (fnspath == PATH_ABS) {      /* ABSOLUTE */
  2939.             zfnqfp(p,CKMAXPATH,fullname);
  2940.         } else {                        /* RELATIVE */
  2941.             ckstrncpy(fullname,p,CKMAXPATH);
  2942.         }
  2943.     }
  2944.     debug(F110,"nzltor fullname",fullname,0);
  2945.  
  2946.     if (!fncnv) {                       /* Not converting */
  2947.         ckstrncpy(name2,fullname,max);  /* We're done. */
  2948. #ifndef NOCSETS
  2949.         langsv = language;
  2950. #endif /* NOCSETS */
  2951.         return;
  2952.     }
  2953.     name = fullname;                    /* Converting */
  2954.  
  2955. #ifdef aegis
  2956.     char *namechars;
  2957.     int tilde = 0, bslash = 0;
  2958.  
  2959.     if ((namechars = getenv("NAMECHARS")) != NULL) {
  2960.         if (ckstrchr(namechars, '~' ) != NULL) tilde  = '~';
  2961.         if (ckstrchr(namechars, '\\') != NULL) bslash = '\\';
  2962.     } else {
  2963.         tilde = '~';
  2964.         bslash = '\\';
  2965.     }
  2966. #endif /* aegis */
  2967.  
  2968.     pp = work;                          /* Output buffer */
  2969.     for (cp = name, n = 0; *cp && n < max; cp++,n++) { /* Convert name chars */
  2970.         c = *cp;
  2971. #ifndef NOCSETS
  2972.         if (sxo) c = (*sxo)(c);         /* Convert to ASCII */
  2973. #endif /* NOCSETS */
  2974.         if (fncnv > 0 && islower(c))    /* Uppercase letters */
  2975.           *pp++ = toupper(c);           /* Change tilde to hyphen */
  2976.         else if (c == '~')
  2977.           *pp++ = '-';
  2978.         else if (fncnv > 0 && c == '#')    /* Change number sign to 'X' */
  2979.           *pp++ = 'X';
  2980.         else if (c == '*' || c == '?')  /* Change wildcard chars to 'X' */
  2981.           *pp++ = 'X';
  2982.         else if (c == ' ')              /* Change space to underscore */
  2983.           *pp++ = '_';
  2984.         else if (c < ' ')               /* Change controls to 'X' */
  2985.           *pp++ = 'X';
  2986.         else if (fncnv > 0 && c == '.') { /* Change dot to underscore */
  2987.             dotp = pp;                  /* Remember where we last did this */
  2988.             *pp++ = '_';
  2989.         } else {
  2990.             if (c == '/')
  2991.               dirp = pp;
  2992.             *pp++ = c;
  2993.         }
  2994.     }
  2995.     *pp = NUL;                          /* Tie it off. */
  2996. #ifdef COMMENT
  2997.     if (dotp) *dotp = '.';              /* Restore last dot (if any) */
  2998. #else
  2999.     if (dotp > dirp) *dotp = '.';       /* Restore last dot in file name */
  3000. #endif /* COMMENT */
  3001.     cp = name2;                         /* If nothing before dot, */
  3002.     if (*work == '.') *cp++ = 'X';      /* insert 'X' */
  3003.     ckstrncpy(cp,work,max);
  3004. #ifndef NOCSETS
  3005.     language = langsv;
  3006. #endif /* NOCSETS */
  3007.     debug(F110,"nzltor name2",name2,0);
  3008. }
  3009.  
  3010.  
  3011. /*  Z C H D I R  --  Change directory  */
  3012. /*
  3013.   Call with:
  3014.     dirnam = pointer to name of directory to change to,
  3015.       which may be "" or NULL to indicate user's home directory.
  3016.   Returns:
  3017.     0 on failure
  3018.     1 on success
  3019. */
  3020. int
  3021. zchdir(dirnam) char *dirnam; {
  3022.     char *hd, *sp;
  3023. #ifdef IKSDB
  3024.     _PROTOTYP (int slotdir,(char *,char *));
  3025. #endif /* IKSDB */
  3026. #ifndef NOSPL
  3027.     extern struct mtab *mactab;             /* Main macro table */
  3028.     extern int nmac;                        /* Number of macros */
  3029. #endif /* NOSPL */
  3030.  
  3031.     debug(F110,"zchdir",dirnam,0);
  3032.     if (!dirnam) dirnam = "";
  3033.     if (!*dirnam)                       /* If argument is null or empty, */
  3034.       dirnam = zhome();                 /* use user's home directory. */
  3035.     sp = dirnam;
  3036.     debug(F110,"zchdir 2",dirnam,0);
  3037.  
  3038. #ifdef DTILDE
  3039.     hd = tilde_expand(dirnam);          /* Attempt to expand tilde */
  3040.     if (!hd) hd = "";
  3041.     if (*hd == '\0') hd = dirnam;       /* in directory name. */
  3042. #else
  3043.     hd = dirnam;
  3044. #endif /* DTILDE */
  3045.     debug(F110,"zchdir 3",hd,0);
  3046.  
  3047. #ifdef CKROOT
  3048.     debug(F111,"zchdir setroot",ckroot,ckrootset);
  3049.     if (ckrootset) if (!zinroot(hd)) {
  3050.     debug(F110,"zchdir setroot violation",hd,0);
  3051.     return(0);
  3052.     }
  3053. #endif /* CKROOT */
  3054.  
  3055. #ifdef pdp11
  3056.     /* Just to save some space */
  3057.     return((chdir(hd) == 0) ? 1 : 0);
  3058. #else
  3059.     if (chdir(hd) == 0) {                       /* Try to cd */
  3060. #ifdef IKSDB
  3061. #ifdef CK_LOGIN
  3062.         if (inserver && ikdbopen)
  3063.           slotdir(isguest ? anonroot : "", zgtdir());
  3064. #endif /* CK_LOGIN */
  3065. #endif /* IKSDB */
  3066.  
  3067. #ifndef NOSPL
  3068.         if (nmac) {            /* Any macros defined? */
  3069.             int k;            /* Yes */
  3070.             static int on_cd = 0;
  3071.             if (!on_cd) {
  3072.                 on_cd = 1;
  3073.                 k = mlook(mactab,"on_cd",nmac);   /* Look this up */
  3074.                 if (k >= 0) {                     /* If found, */
  3075.                     if (dodo(k,zgtdir(),0) > -1)  /* set it up, */
  3076.               parser(1);                  /* and execute it */
  3077.                 }
  3078.                 on_cd = 0;
  3079.             }
  3080.         }
  3081. #endif /* NOSPL */
  3082.         return(1);
  3083.     }
  3084.     return(0);
  3085. #endif /* pdp11 */
  3086. }
  3087.  
  3088. int
  3089. #ifdef CK_ANSIC
  3090. zchkpid(unsigned long xpid)
  3091. #else
  3092. zchkpid(xpid) unsigned long xpid;
  3093. #endif /* CK_ANSIC */
  3094. {
  3095.     return((kill((PID_T)xpid,0) < 0) ? 0 : 1);
  3096. }
  3097.  
  3098.  
  3099. /*  Z H O M E  --  Return pointer to user's home directory  */
  3100.  
  3101. static char * zhomdir = NULL;
  3102.  
  3103. char *
  3104. zhome() {
  3105.     char * home;
  3106.  
  3107. #ifdef CKROOT
  3108.     if (ckrootset)
  3109.       return((char *)ckroot);
  3110. #endif /* CKROOT */
  3111.  
  3112. #ifdef Plan9
  3113.     home = getenv("home");
  3114. #else
  3115.     home = getenv("HOME");
  3116. #endif /* Plan9 */
  3117.     makestr(&zhomdir,home);
  3118.     return(home ? zhomdir : ".");
  3119. }
  3120.  
  3121. /*  Z G T D I R  --  Returns a pointer to the current directory  */
  3122.  
  3123. /*
  3124.   The "preferred" interface for getting the current directory in modern UNIX
  3125.   is getcwd() [POSIX 1003.1 5.2.2].  However, on certain platforms (such as
  3126.   SunOS), it is implemented by forking a shell, feeding it the pwd command,
  3127.   and returning the result, which is not only inefficient but also can result
  3128.   in stray messages to the terminal.  In such cases -- as well as when
  3129.   getcwd() is not available at all -- getwd() can be used instead by defining
  3130.   USE_GETWD.  However, note that getwd() provides no buffer-length argument
  3131.   and therefore no safeguard against memory leaks.
  3132. */
  3133. #ifndef USE_GETWD
  3134. #ifdef BSD42
  3135. #define USE_GETWD
  3136. #else
  3137. #ifdef SUNOS4
  3138. #define USE_GETWD
  3139. #endif /* SUNOS4 */
  3140. #endif /* BSD42 */
  3141. #endif /* USE_GETWD */
  3142.  
  3143. #ifdef pdp11
  3144. #define CWDBL 80                        /* Save every byte we can... */
  3145. #else
  3146. #define CWDBL CKMAXPATH
  3147. #endif /* pdp11 */
  3148. static char cwdbuf[CWDBL+2];
  3149. /*
  3150.   NOTE: The getcwd() prototypes are commented out on purpose.  If you get
  3151.   compile-time warnings, search through your system's header files to see
  3152.   which one has the needed prototype, and #include it.  Usually it is
  3153.   <unistd.h>.  See the section for including <unistd.h> in ckcdeb.h and
  3154.   make any needed adjustments there (and report them).
  3155. */
  3156. char *
  3157. zgtdir() {
  3158.     char * buf = cwdbuf;
  3159.     char * s;
  3160.  
  3161. #ifdef USE_GETWD
  3162.     extern char *getwd();
  3163.     s = getwd(buf);
  3164.     debug(F110,"zgtdir BSD4 getwd()",s,0);
  3165.     if (!s) s = "./";
  3166.     return(s);
  3167. #else
  3168. #ifdef BSD44
  3169. #ifdef DCLGETCWD
  3170. _PROTOTYP( char * getcwd, (char *, SIZE_T) );
  3171. #endif /* DCLGETCWD */
  3172.     debug(F101,"zgtdir BSD44 CWDBL","",CWDBL);
  3173.     s = getcwd(buf,CWDBL);
  3174.     if (!s) s = "./";
  3175.     return(s);
  3176. #else
  3177. #ifdef MINIX2
  3178. #ifdef DCLGETCWD
  3179.     _PROTOTYP( char * getcwd, (char *, SIZE_T) );
  3180. #endif /* DCLGETCWD */
  3181.     debug(F101,"zgtdir MINIX2 CWDBL","",CWDBL);
  3182.     s = getcwd(buf,CWDBL);
  3183.     if (!s) s = "./";
  3184.     return(s);
  3185. #else
  3186. #ifdef SVORPOSIX
  3187. #ifdef COMMENT
  3188. /* This non-ANSI prototype can be fatal at runtime! (e.g. in SCO3.2v5.0.5). */
  3189. /* Anyway it's already prototyped in some header file that we have included. */
  3190.     extern char *getcwd();
  3191. #else
  3192. #ifdef DCLGETCWD
  3193.     _PROTOTYP( char * getcwd, (char *, SIZE_T) );
  3194. #endif /* DCLGETCWD */
  3195. #endif /* COMMENT */
  3196.     debug(F101,"zgtdir SVORPOSIX CWDBL","",CWDBL);
  3197.     s = getcwd(buf,CWDBL);
  3198.     if (!s) s = "./";
  3199.     return(s);
  3200. #else
  3201. #ifdef COHERENT
  3202. #ifdef _I386
  3203. #ifdef DCLGETCWD
  3204.     extern char *getcwd();
  3205. #endif /* DCLGETCWD */
  3206.     debug(F101,"zgtdir COHERENT _I386 CWDBL","",CWDBL);
  3207.     s = getcwd(buf,CWDBL);
  3208.     if (!s) s = "./";
  3209.     return(s);
  3210. #else
  3211.     extern char *getwd();
  3212.     debug(F101,"zgtdir COHERENT CWDBL","",CWDBL);
  3213.     s = getwd(buf);
  3214.     if (!s) s = "./";
  3215.     return(s);
  3216. #endif /* _I386 */
  3217. #else
  3218. #ifdef SUNOS4
  3219.     debug(F101,"zgtdir SUNOS CWDBL","",CWDBL);
  3220.     s = getcwd(buf,CWDBL);
  3221.     if (!s) s = "./";
  3222.     return(s);
  3223. #else
  3224.     return("./");
  3225. #endif /* SUNOS4 */
  3226. #endif /* COHERENT */
  3227. #endif /* SYSVORPOSIX */
  3228. #endif /* MINIX2 */
  3229. #endif /* BSD44 */
  3230. #endif /* USE_GETWD */
  3231. }
  3232.  
  3233. /*  Z X C M D -- Run a system command so its output can be read like a file */
  3234.  
  3235. #ifndef NOPUSH
  3236. int
  3237. zxcmd(filnum,comand) int filnum; char *comand; {
  3238.     int out;
  3239.     int pipes[2];
  3240.     extern int kactive;                 /* From ckcpro.w and ckcmai.c */
  3241.  
  3242.     if (nopush) {
  3243.         debug(F100,"zxcmd fails: nopush","",0);
  3244.         return(-1);
  3245.     }
  3246.     debug(F111,"zxcmd",comand,filnum);
  3247.     if (chkfn(filnum) < 0) return(-1);  /* Need a valid Kermit file number. */
  3248.     if (filnum == ZSTDIO || filnum == ZCTERM) /* But not one of these. */
  3249.       return(0);
  3250.  
  3251.     out = (filnum == ZIFILE || filnum == ZRFILE) ? 0 : 1 ;
  3252.     debug(F101,"zxcmd out",comand,out);
  3253.  
  3254. /* Output to a command */
  3255.  
  3256.     if (out) {                          /* Need popen() to do this. */
  3257.     ckstrncpy(fullname,"(pipe)",CKMAXPATH);
  3258. #ifdef NOPOPEN
  3259.         return(0);                      /* no popen(), fail. */
  3260. #else
  3261. /* Use popen() to run the command. */
  3262.  
  3263. #ifdef _POSIX_SOURCE
  3264. /* Strictly speaking, popen() is not available in POSIX.1 */
  3265. #define DCLPOPEN
  3266. #endif /* _POSIX_SOURCE */
  3267.  
  3268.     debug(F110,"zxcmd out",comand,0);
  3269.  
  3270.         if (priv_chk()) {
  3271.         debug(F100,"zxcmd priv_chk failed","",0);
  3272.             return(0);
  3273.     }    
  3274.     errno = 0;
  3275.         fp[filnum] = popen(comand,"w");
  3276.     debug(F111,"zxcmd popen",fp[filnum] ? "OK" : "Failed", errno);
  3277.     if (fp[filnum] == NULL)
  3278.       return(0);
  3279. #ifdef COMMENT
  3280. /* I wonder what this is all about... */
  3281.     close(pipes[0]);        /* Don't need the input side */
  3282.     fp[filnum] = fdopen(pipes[1],"w"); /* Open output stream. */
  3283.     fp[ZSYSFN] = fp[filnum];           /* Remember. */
  3284. #endif /* COMMENT */
  3285.     ispipe[filnum] = 1;
  3286.     zoutcnt = 0;            /* (PWP) reset input buffer */
  3287.     zoutptr = zoutbuffer;
  3288.     return(1);
  3289. #endif /* NOPOPEN */
  3290.     }
  3291.  
  3292. /* Input from a command */
  3293.  
  3294. #ifdef SNI541
  3295.     /* SINIX-L 5.41 does not like fdopen() */
  3296.     return(0);
  3297. #else
  3298.     if (pipe(pipes) != 0) {
  3299.         debug(F100,"zxcmd pipe failure","",0);
  3300.         return(0);                      /* can't make pipe, fail */
  3301.     }
  3302.  
  3303. /* Create a fork in which to run the named process */
  3304.  
  3305.     if ((
  3306. #ifdef aegis
  3307.          pid = vfork()                  /* child */
  3308. #else
  3309.          pid = fork()                   /* child */
  3310. #endif /* aegis */
  3311.          ) == 0) {
  3312.  
  3313. /* We're in the fork. */
  3314.  
  3315.         char *shpath, *shname, *shptr;  /* Find user's preferred shell */
  3316. #ifndef aegis
  3317.         struct passwd *p;
  3318.         char *defshell;
  3319. #ifdef HPUX10                           /* Default shell */
  3320.         defshell = "/usr/bin/sh";
  3321. #else
  3322. #ifdef Plan9
  3323.         defshell = "/bin/rc";
  3324. #else
  3325.         defshell = "/bin/sh";
  3326. #endif /* Plan9 */
  3327. #endif /* HPUX10 */
  3328. #endif /* aegis */
  3329.         if (priv_can()) exit(1);        /* Turn off any privileges! */
  3330.         debug(F101,"zxcmd pid","",pid);
  3331.         close(pipes[0]);                /* close input side of pipe */
  3332.         close(0);                       /* close stdin */
  3333.         if (open("/dev/null",0) < 0) return(0); /* replace input by null */
  3334. #ifndef OXOS
  3335. #ifndef SVORPOSIX
  3336.         dup2(pipes[1],1);               /* BSD: replace stdout & stderr */
  3337.         dup2(pipes[1],2);               /* by the pipe */
  3338. #else
  3339.         close(1);                       /* AT&T: close stdout */
  3340.         if (dup(pipes[1]) != 1)         /* Send stdout to the pipe */
  3341.           return(0);
  3342.         close(2);                       /* Send stderr to the pipe */
  3343.         if (dup(pipes[1]) != 2)
  3344.           return(0);
  3345. #endif /* SVORPOSIX */
  3346. #else /* OXOS */
  3347.         dup2(pipes[1],1);
  3348.         dup2(pipes[1],2);
  3349. #endif /* OXOS */
  3350.         close(pipes[1]);                /* Don't need this any more. */
  3351.  
  3352. #ifdef aegis
  3353.         if ((shpath = getenv("SERVERSHELL")) == NULL)
  3354.           shpath = "/bin/sh";
  3355. #else
  3356.         shpath = getenv("SHELL");       /* What shell? */
  3357.         if (shpath == NULL) {
  3358.             p = getpwuid( real_uid() ); /* Get login data */
  3359.             /* debug(F111,"zxcmd shpath","getpwuid()",p); */
  3360.             if (p == (struct passwd *)NULL || !*(p->pw_shell))
  3361.               shpath = defshell;
  3362.             else shpath = p->pw_shell;
  3363.         }
  3364. #endif /* aegis */
  3365.         shptr = shname = shpath;
  3366.         while (*shptr != '\0')
  3367.           if (*shptr++ == '/')
  3368.             shname = shptr;
  3369.         debug(F110,shpath,shname,0);
  3370.     restorsigs();            /* Restore ignored signals */
  3371.         execl(shpath,shname,"-c",comand,(char *)NULL); /* Execute the cmd */
  3372.         exit(0);                        /* just punt if it failed. */
  3373.     } else if (pid == (PID_T) -1) {
  3374.         debug(F100,"zxcmd fork failure","",0);
  3375.         return(0);
  3376.     }
  3377.     debug(F101,"zxcmd pid","",pid);
  3378.     close(pipes[1]);                    /* Don't need the output side */
  3379.     ispipe[filnum] = 1;                 /* Remember it's a pipe */
  3380.     fp[filnum] = fdopen(pipes[0],"r");    /* Open a stream for input. */
  3381.  
  3382. #ifdef DONDELAY
  3383. #ifdef SELECT
  3384.     if (filnum == ZIFILE && kactive) {  /* Make pipe reads nonblocking */
  3385.         int flags, x;
  3386.         if ((flags = fcntl(fileno(fp[filnum]),F_GETFL,0)) > -1) {
  3387.             debug(F101,"zxcmd fcntl 1 pipe flags","",flags);
  3388.             x = fcntl(fileno(fp[filnum]),F_SETFL, flags |
  3389. #ifdef QNX
  3390.                   O_NONBLOCK
  3391. #else
  3392.                   O_NDELAY
  3393. #endif /* QNX */
  3394.                   );
  3395.             debug(F101,"zxcmd fcntl 2 result","",x);
  3396.         }
  3397.     }
  3398. #endif /* SELECT */
  3399. #endif /* DONDELAY */
  3400. #endif /* SNI541 */
  3401.     fp[ZSYSFN] = fp[filnum];            /* Remember. */
  3402.     zincnt = 0;                         /* (PWP) reset input buffer */
  3403.     zinptr = zinbuffer;
  3404.     fullname[0] = '\0';
  3405.     return(1);
  3406. } /* zxcmd */
  3407.  
  3408. /*  Z C L O S F  - wait for the child fork to terminate and close the pipe. */
  3409.  
  3410. /*  Used internally by zclose - returns -1 on failure, 1 on success. */
  3411.  
  3412. int
  3413. zclosf(filnum) int filnum; {
  3414.     int wstat, out;
  3415.     int statusp;
  3416.  
  3417.     debug(F101,"zclosf filnum","",filnum);
  3418.     out = (filnum == ZIFILE || filnum == ZRFILE) ? 0 : 1 ;
  3419.     debug(F101,"zclosf out","",out);
  3420.  
  3421. #ifndef NOPOPEN
  3422.     if (ispipe[filnum]
  3423.         /* In UNIX we use popen() only for output files */
  3424.         && out
  3425.         ) {
  3426.         int x;
  3427.         x = pclose(fp[filnum]);
  3428.         pexitstat = x >> 8;
  3429.         debug(F101,"zclosf pclose","",x);
  3430.         debug(F101,"zclosf pexitstat","",pexitstat);
  3431.         fp[filnum] = fp[ZSYSFN] = NULL;
  3432.         ispipe[filnum] = 0;
  3433.         return((x != 0) ? -1 : 1);
  3434.     }
  3435. #endif /* NOPOPEN */
  3436.     /* debug(F101,"zclosf fp[filnum]","", fp[filnum]); */
  3437.     /* debug(F101,"zclosf fp[ZSYSFN]","", fp[ZSYSFN]); */
  3438.  
  3439.     if (pid != (PID_T) 0) {
  3440.         debug(F101,"zclosf killing pid","",pid);
  3441. #ifdef Plan9
  3442.         kill(pid, SIGKILL);
  3443. #else
  3444.         kill(pid,9);
  3445. #endif /* Plan9 */
  3446.  
  3447. #ifndef CK_CHILD
  3448. /*
  3449.   This is the original code (before 20 April 1997) and has proven totally
  3450.   portable.  But it does not give us the process's return code.
  3451. */
  3452.         while ((wstat = wait((WAIT_T *)0)) != pid && wstat != -1) ;
  3453. #else
  3454. /* Here we try to get the return code.  Let's hope this is portable too. */
  3455.         while ((wstat = wait(&statusp)) != pid && wstat != -1) ;
  3456.         pexitstat = (statusp & 0xff) ? statusp : statusp >> 8;
  3457.         debug(F101,"zclosf wait statusp","",statusp);
  3458.         debug(F101,"zclosf wait pexitstat","",pexitstat);
  3459. #endif /* CK_CHILD */
  3460.         pid = 0;
  3461.     }
  3462.     fclose(fp[filnum]);
  3463.     fp[filnum] = fp[ZSYSFN] = NULL;
  3464.  
  3465.     ispipe[filnum] = 0;
  3466.     /* debug(F101,"zclosf fp[filnum]","",fp[filnum]); */
  3467. #ifdef CK_CHILD
  3468.     return(pexitstat == 0 ? 1 : -1);
  3469. #else
  3470.     return(1);
  3471. #endif /* CK_CHILD */
  3472. }
  3473.  
  3474. #else  /* NOPUSH */
  3475.  
  3476. int
  3477. zxcmd(filnum,comand) int filnum; char *comand; {
  3478.     return(0);
  3479. }
  3480. int
  3481. zclosf(filnum) int filnum; {
  3482.     return(EOF);
  3483. }
  3484. #endif /* NOPUSH */
  3485.  
  3486.  
  3487. /*  Z X P A N D  --  Expand a wildcard string into an array of strings  */
  3488. /*
  3489.   As of C-Kermit 7.0, this API is obsolete, replaced by nzxpand(), and this
  3490.   function is only used internally.  See nzxpand() below.
  3491.  
  3492.   Returns the number of files that match fnarg, with data structures set up
  3493.   so that first file (if any) will be returned by the next znext() call.
  3494.  
  3495.   Depends on external variable wildxpand: 0 means we expand wildcards
  3496.   internally, nonzero means we call the shell to do it.
  3497.   
  3498.   AND in C-Kermit 8.0.212 and later, on extern wildena: 1 means wildcards
  3499.   are enabled, 0 means disabled, the characters are taken literally.
  3500. */
  3501. static int xdironly = 0;
  3502. static int xfilonly = 0;
  3503. static int xmatchdot = 0;
  3504. static int xrecursive = 0;
  3505. static int xnobackup = 0;
  3506. static int xnolinks = 0;
  3507.  
  3508. static char *freeptr = NULL, **resptr = NULL; /* Copies of caller's args */
  3509. static int remlen;                      /* Remaining space in caller's array */
  3510. static int numfnd = 0;            /* Number of matches found */
  3511.  
  3512. #define MINSPACE 1024
  3513.  
  3514. static int
  3515. initspace(resarry,len) char * resarry[]; int len; {
  3516. #ifdef DYNAMIC
  3517.     if (len < MINSPACE) len = MINSPACE;
  3518.     if (!sspace) {                      /* Need to allocate string space? */
  3519.         while (len >= MINSPACE) {
  3520.             if ((sspace = malloc(len+2))) { /* Got it. */
  3521.                 debug(F101,"fgen string space","",len);
  3522.                 break;
  3523.             }
  3524.             len = (len / 2) + (len / 4); /* Didn't, reduce by 3/4 */
  3525.         }
  3526.         if (len <= MINSPACE) {        /* Did we get it? */
  3527.             fprintf(stderr,"fgen can't malloc string space\n");
  3528.             return(-1);
  3529.         }
  3530.     ssplen = len;
  3531.     }
  3532. #endif /* DYNAMIC */
  3533.  
  3534.     freeptr = sspace;                   /* This is where matches are copied. */
  3535.     resptr = resarry;            /* Static copies of these so */
  3536.     remlen = len;                       /* recursive calls can alter them. */
  3537.     debug(F101,"initspace ssplen","",ssplen);
  3538.     return(0);
  3539. }
  3540.  
  3541. /*
  3542.   Z S E T F I L  --  Query or change the size of file list buffers.
  3543.  
  3544.   fc = 1: Change current string space to n, return new size.
  3545.   fc = 2: Return current string space size.
  3546.   fc = 3: Change current maxnames to n, return new maxnames.
  3547.   fc = 4: Return current maxnames.
  3548.   Returns < 0 on error.
  3549. */
  3550. int
  3551. zsetfil(n, fc) int n, fc; {
  3552. #ifdef DYNAMIC
  3553.     switch (fc) {
  3554.       case 1:                /* Stringspace */
  3555.     if (sspace) {
  3556.         free(sspace);
  3557.         sspace = NULL;
  3558.     }
  3559.     if (initspace(mtchs,n) < 0)
  3560.       return(-1);
  3561.       case 2:                /* Fall thru deliberately */
  3562.     return(ssplen);
  3563.       case 3:                /* Listsize */
  3564.     if (mtchs) {
  3565.         free((char *)mtchs);
  3566.         mtchs = NULL;
  3567.     }
  3568.     mtchs = (char **)malloc(n * sizeof(char *));
  3569.     if (!mtchs)
  3570.       return(-1);
  3571.     maxnames = n;
  3572.       case 4:                /* Fall thru deliberately */
  3573.     return(maxnames);
  3574.     }
  3575. #endif /* DYNAMIC */
  3576.     return(-1);
  3577. }
  3578.  
  3579.  
  3580.  
  3581. #ifndef NONZXPAND
  3582. #ifndef pdp11
  3583. static
  3584. #endif /* pdp11 */
  3585. #endif /* NONZXPAND */
  3586. int
  3587. zxpand(fnarg) char *fnarg; {
  3588.     extern int diractive;
  3589.     char fnbuf[CKMAXPATH+8], * fn, * p;
  3590.  
  3591. #ifdef DTILDE                           /* Built with tilde-expansion? */
  3592.     char *tnam;
  3593. #endif /* DTILDE */
  3594.     int x;
  3595.     int haveonedir = 0;
  3596.  
  3597.     if (!fnarg) {                       /* If no argument provided */
  3598.     nxpand = fcount = 0;
  3599.     return(0);            /* Return zero files found */
  3600.     }
  3601.     debug(F110,"zxpand entry",fnarg,0);
  3602.     debug(F101,"zxpand xdironly","",xdironly);
  3603.     debug(F101,"zxpand xfilonly","",xfilonly);
  3604.  
  3605.     if (!*fnarg) {            /* If no argument provided */
  3606.     nxpand = fcount = 0;
  3607.     return(0);            /* Return zero files found */
  3608.     }
  3609.  
  3610. #ifdef CKROOT
  3611.     debug(F111,"zxpand setroot",ckroot,ckrootset);
  3612.     if (ckrootset) if (!zinroot(fnarg)) {
  3613.     debug(F110,"zxpand setroot violation",fnarg,0);
  3614.     nxpand = fcount = 0;
  3615.     return(0);
  3616.     }
  3617. #endif /* CKROOT */
  3618.  
  3619. #ifdef COMMENT
  3620. /*
  3621.   This would have been perfect, except it makes us return fully qualified
  3622.   pathnames for all files.
  3623. */
  3624.     zfnqfp(fnarg,CKMAXPATH,fnbuf);
  3625.     debug(F110,"zxpand zfnqfp",fnbuf,0);
  3626.     s = zgtdir();
  3627.     debug(F110,"zxpand zgtdir",s,0);
  3628.     p = fnbuf;
  3629.     while (*p && *s)                    /* Make it relative */
  3630.       if (*s++ != *p++)
  3631.         break;
  3632.     fn = (*s) ? fnbuf : p;
  3633.     debug(F110,"zxpand fn 0",fn,0);
  3634.     if (!*fn) {
  3635.         fn = fnbuf;
  3636.         fnbuf[0] = '*';
  3637.         fnbuf[1] = '\0';
  3638.     }
  3639.     debug(F110,"zxpand fn 0.5",fn,0);
  3640. #else
  3641. #ifdef DTILDE                           /* Built with tilde-expansion? */
  3642.     if (*fnarg == '~') {                /* Starts with tilde? */
  3643.         tnam = tilde_expand(fnarg);     /* Try to expand it. */
  3644.         ckstrncpy(fnbuf,tnam,CKMAXPATH);
  3645.     } else
  3646. #endif /* DTILDE */
  3647.       ckstrncpy(fnbuf,fnarg,CKMAXPATH);
  3648.     fn = fnbuf;                         /* Point to what we'll work with */
  3649. #endif /* COMMENT */
  3650.     debug(F110,"zxpand fn 1",fn,0);
  3651.  
  3652.     if (!*fn)                           /* But make sure something is there */
  3653.       return(0);
  3654.  
  3655.     p = fn + (int)strlen(fn) - 1;
  3656.     if (*p == '/') {                    /* If last char = / it must be a dir */
  3657.     if (!xfilonly && !iswild(p)) haveonedir++;
  3658.         ckstrncat(fn, "*", CKMAXPATH+8); /* so append '*' */
  3659.     } else if (p > fn) {                /* If ends in "/." */
  3660.         if (*(p-1) == '/' && *p == '.') /* change '.' to '*' */
  3661.           *p = '*';
  3662.     } else if (p == fn) {               /* If it's '.' alone */
  3663.         if (*p == '.')                  /* change '.' to '*' */
  3664.           *p = '*';
  3665.     }
  3666.     debug(F110,"zxpand fn 2",fn,0);
  3667.     x = isdir(fn);                      /* Is it a directory? */
  3668.     debug(F111,"zxpand isdir 1",fn,x);
  3669.     if (x) {                            /* If so, make it into a wildcard */
  3670.     if (!xfilonly && !iswild(p))
  3671.       haveonedir++;
  3672.         if ((x = strlen(fn)) > 0) {
  3673.             if (!ISDIRSEP(fn[x-1]))
  3674.               fn[x++] = DIRSEP;
  3675.             fn[x++] = '*';
  3676.             fn[x] = '\0';
  3677.         }
  3678.     }
  3679.     debug(F111,"zxpand fn 3 haveonedir",fn,haveonedir);
  3680. /*
  3681.   The following allows us to parse a single directory name without opening
  3682.   the directory and looking at its contents.  The diractive flag is a horrible
  3683.   hack (especially since DIR /NORECURSIVE turns it off), but otherwise we'd
  3684.   have to change the API.
  3685. */
  3686.     debug(F111,"zxpand fn 3 diractive",fn,diractive);
  3687.     if (!diractive && haveonedir) {
  3688.     fcount = 0;
  3689.     if (!mtchs) {
  3690.         mtchs = (char **)malloc(maxnames * sizeof(*mtchs));
  3691.         if (!mtchs)
  3692.           return(nxpand = fcount);
  3693.     }
  3694.     fcount = 1;
  3695.     debug(F110,"zxpand haveonedir A1",fnarg,0);
  3696.     initspace(mtchs,ssplen);
  3697.     addresult(fnarg,1);
  3698.     if (numfnd < 0) return(-1);
  3699.     mtchptr = mtchs;        /* Save pointer for next. */
  3700.     debug(F111,"zxpand haveonedir A2",*mtchptr,numfnd);
  3701.     return(nxpand = fcount);
  3702.     }
  3703.  
  3704. #ifndef NOPUSH
  3705.     if (!nopush && wildxpand)           /* Who is expanding wildcards? */
  3706.       fcount = (mtchs == NULL &&        /* Shell */
  3707.                 (mtchs = (char **)malloc(maxnames * sizeof(*mtchs))) == NULL)
  3708.         ? 0
  3709.           :  shxpand(fn,mtchs,maxnames);
  3710.     else
  3711. #endif /* NOPUSH */
  3712.       fcount = (mtchs == NULL &&        /* Kermit */
  3713.                 (mtchs = (char **)malloc(maxnames * sizeof(*mtchs))) == NULL)
  3714.         ? 0
  3715.           : fgen(fn,mtchs,maxnames);      /* Look up the file. */
  3716.  
  3717.     if (fcount == 0 && haveonedir) {
  3718.     fcount = 1;
  3719.     debug(F110,"zxpand haveonedir B",fnarg,0);
  3720.     addresult(fnarg,1);
  3721.     if (numfnd < 0) return(-1);
  3722.     }
  3723.     mtchptr = mtchs;                    /* Save pointer for next. */
  3724.     nxpand = fcount;
  3725.  
  3726. #ifdef DEBUG
  3727.     if (deblog) {
  3728.         if (fcount > 1)
  3729.           debug(F111,"zxpand ok",mtchs[0],fcount);
  3730.         else
  3731.           debug(F101,"zxpand fcount","",fcount);
  3732.     }
  3733. #endif /* DEBUG */
  3734.     return(fcount);
  3735. }
  3736.  
  3737. #ifndef NONZXPAND
  3738. /*  N Z X P A N D  --  Expand a file list, with options.  */
  3739. /*
  3740.   Call with:
  3741.    s = pointer to filename or pattern.
  3742.    flags = option bits:
  3743.  
  3744.      flags & ZX_FILONLY   Match regular files
  3745.      flags & ZX_DIRONLY   Match directories
  3746.      flags & ZX_RECURSE   Descend through directory tree
  3747.      flags & ZX_MATCHDOT  Match "dot files"
  3748.      flags & ZX_NOBACKUP  Don't match "backup files"
  3749.      flags & ZX_NOLINKS   Don't follow symlinks.
  3750.  
  3751.    Returns the number of files that match s, with data structures set up
  3752.    so that first file (if any) will be returned by the next znext() call.
  3753. */
  3754. int
  3755. nzxpand(s,flags) char * s; int flags; {
  3756.     char * p;
  3757.     int x;
  3758.  
  3759.     debug(F111,"nzxpand",s,flags);
  3760.     x = flags & (ZX_DIRONLY|ZX_FILONLY);
  3761.     xdironly = (x == ZX_DIRONLY);
  3762.     xfilonly = (x == ZX_FILONLY);
  3763.     if (xdironly && xfilonly) {
  3764.         xdironly = 0;
  3765.         xfilonly = 0;
  3766.     }
  3767.     xmatchdot  = (flags & ZX_MATCHDOT);
  3768.     debug(F111,"nzxpand xmatchdot 1",s,xmatchdot);
  3769.     /* If xmatchdot not set by caller but pattern implies it, set it anyway */
  3770.     if (!xmatchdot && ((p = ckstrchr(s,'.')))) {
  3771.     if (p == s && p[1] != '/') {
  3772.         xmatchdot = 1;
  3773.         debug(F111,"nzxpand xmatchdot 2",s,xmatchdot);
  3774.     } else if (p > s) {
  3775.         xmatchdot = (*(p-1) == ',') || (*(p-1) == '{') || (*(p-1) == '/');
  3776.         debug(F111,"nzxpand xmatchdot 3",s,xmatchdot);
  3777.     }
  3778.     }
  3779.     xrecursive = (flags & ZX_RECURSE);
  3780.     xnobackup  = (flags & ZX_NOBACKUP);
  3781.     xnolinks   = (flags & ZX_NOLINKS);
  3782.  
  3783. #ifdef DEBUG
  3784.     if (deblog) {
  3785.     debug(F101,"nzxpand xdironly","",xdironly);
  3786.     debug(F101,"nzxpand xfilonly","",xfilonly);
  3787.     debug(F101,"nzxpand xmatchdot","",xmatchdot);
  3788.     debug(F101,"nzxpand xrecursive","",xrecursive);
  3789.     debug(F101,"nzxpand xnobackup","",xnobackup);
  3790.     debug(F101,"nzxpand xnolinks","",xnolinks);
  3791.     }
  3792. #endif /* DEBUG */
  3793.  
  3794.     x = zxpand(s);
  3795.     if (x > 1)
  3796.       sh_sort(mtchs,NULL,x,0,0,1);    /* Alphabetize the list */
  3797.     xdironly = 0;
  3798.     xfilonly = 0;
  3799.     xmatchdot = 0;
  3800.     xrecursive = 0;
  3801.     xnobackup = 0;
  3802.     xnolinks = 0;
  3803.     return(x);
  3804. }
  3805. #endif /* NONZXPAND */
  3806.  
  3807. #ifndef NOZXREWIND
  3808. /*  Z X R E W I N D  --  Rewinds the zxpand() list */
  3809.  
  3810. int
  3811. zxrewind() {
  3812.     /* if (!mtchs) return(-1); */
  3813.     fcount = nxpand;
  3814.     mtchptr = mtchs;
  3815.     return(nxpand);
  3816. }
  3817. #endif /* NOZXREWIND */
  3818.  
  3819. /*  Z N E X T  --  Get name of next file from list created by zxpand(). */
  3820. /*
  3821.   Returns >0 if there's another file, with its name copied into the arg string,
  3822.   or 0 if no more files in list.
  3823. */
  3824. int
  3825. znext(fn) char *fn; {
  3826.     if (fcount-- > 0) {
  3827.         ckstrncpy(fn,*mtchptr++,CKMAXPATH);
  3828.     } else {
  3829.         fn[0] = '\0';
  3830.     }
  3831. #ifndef COMMENT
  3832.     debug(F111,"znext",fn,fcount+1);
  3833.     return(fcount+1);
  3834. #else
  3835.     debug(F111,"znext",fn,fcount);      /* Return 0 if no filename to return */
  3836.     return(fcount);
  3837. #endif /* COMMENT */
  3838. }
  3839.  
  3840. /*  Z C H K S P A  --  Check if there is enough space to store the file  */
  3841.  
  3842. /*
  3843.  Call with file specification f, size n in bytes.
  3844.  Returns -1 on error, 0 if not enough space, 1 if enough space.
  3845. */
  3846. /*ARGSUSED*/
  3847. int
  3848. #ifdef CK_ANSIC
  3849. zchkspa(char *f, CK_OFF_T n)
  3850. #else
  3851. zchkspa(f,n) char *f; CK_OFF_T n;
  3852. #endif /* CK_ANSIC */
  3853. /* zchkspa() */ {
  3854.     /* In UNIX there is no good (and portable) way. */
  3855.     return(1);                          /* Always say OK. */
  3856. }
  3857.  
  3858. #ifdef COMMENT                /* (not used) */
  3859.  
  3860. /*  I S B A C K U P  --  Tells if given file has a backup suffix  */
  3861. /*
  3862.    Returns:
  3863.    -1: Invalid argument
  3864.     0: File does not have a backup suffix
  3865.    >0: Backup suffix number
  3866. */
  3867. int
  3868. isbackup(fn) char * fn; {        /* Get backup suffix number */
  3869.     int i, j, k, x, state, flag;
  3870.  
  3871.     if (!fn)                /* Watch out for null pointers. */
  3872.       return(-1);
  3873.     if (!*fn)                /* And empty names. */
  3874.       return(-1);
  3875.  
  3876.     flag = state = 0;
  3877.     for (i = (int)strlen(fn) - 1; (!flag && (i > 0)); i--) {
  3878.     switch (state) {
  3879.       case 0:            /* State 0 - final char */
  3880.         if (fn[i] == '~')        /* Is tilde */
  3881.           state = 1;        /* Switch to next state */
  3882.         else            /* Otherwise */
  3883.           flag = 1;            /* Quit - no backup suffix. */
  3884.         break;
  3885.       case 1:            /* State 1 - digits */
  3886.         if (fn[i] == '~'  && fn[i-1] == '.') { /* Have suffix */
  3887.         return(atoi(&fn[i+1]));
  3888.         } else if (fn[i] >= '0' && fn[i] <= '9') { /* In number part */
  3889.         continue;        /* Keep going */
  3890.         } else {            /* Something else */
  3891.         flag = 1;        /* Not a backup suffix - quit. */
  3892.         }
  3893.         break;
  3894.     }
  3895.     }
  3896.     return(0);
  3897. }
  3898. #endif /* COMMENT */
  3899.  
  3900.  
  3901. /*  Z N E W N  --  Make a new name for the given file  */
  3902.  
  3903. /*
  3904.   Given the name, fn, of a file that already exists, this function builds a
  3905.   new name of the form "<oldname>.~<n>~", where <oldname> is argument name
  3906.   (fn), and <n> is a version number, one higher than any existing version
  3907.   number for that file, up to 99999.  This format is consistent with that used
  3908.   by GNU EMACS.  If the constructed name is too long for the system's maximum,
  3909.   enough characters are truncated from the end of <fn> to allow the version
  3910.   number to fit.  If no free version numbers exist between 1 and 99999, a
  3911.   version number of "xxxx" is used.  Returns a pointer to the new name in
  3912.   argument s.
  3913. */
  3914. #ifdef pdp11
  3915. #define ZNEWNBL 63                      /* Name buffer length */
  3916. #define ZNEWNMD 3                       /* Max digits for version number */
  3917. #else
  3918. #define ZNEWNBL CKMAXPATH
  3919. #define ZNEWNMD 4
  3920. #endif /* pdp11 */
  3921.  
  3922. #define MAXBUDIGITS 5
  3923.  
  3924. static char znewbuf[ZNEWNBL+12];
  3925.  
  3926. VOID
  3927. znewn(fn,s) char *fn, **s; {
  3928.     char * buf;                /* Pointer to buffer for new name */
  3929.     char * xp, * namepart = NULL;       /* Pointer to filename part */
  3930.     struct zfnfp * fnfp;                /* znfqfp() result struct pointer */
  3931.     int d = 0, t, fnlen, buflen;
  3932.     int n, i, k, flag, state;
  3933.     int max = MAXNAMLEN;                /* Maximum name length */
  3934.     char * dname = NULL;
  3935.  
  3936.     buf = znewbuf;
  3937.     *s = NULL;                          /* Initialize return value */
  3938.     if (!fn) fn = "";                   /* Check filename argument */
  3939.     i = strlen(fn);
  3940.  
  3941. /* If incoming file already has a backup suffix, remove it. */
  3942. /* Then we'll tack a new on later, which will be the highest for this file. */
  3943.  
  3944.     if (i <= max && i > 0 && fn[i-1] == '~') {
  3945.     char * p;
  3946.     i--;
  3947.     debug(F111,"znewn suffix removal",fn,i);
  3948.     if ((dname = (char *)malloc(i+1))) {
  3949.         ckstrncpy(dname,fn,i+1);
  3950.         p = dname;
  3951.         for (flag = state = 0; (!flag && (i > 0)); i--) {
  3952.         switch (state) {
  3953.           case 0:        /* State 0 - final char */
  3954.             if (p[i] == '~')    /* Is tilde */
  3955.               state = 1;    /* Switch to next state */
  3956.             else        /* Otherwise */
  3957.               flag = 1;        /* Quit - no backup suffix. */
  3958.             break;
  3959.           case 1:        /* State 1 - digits */
  3960.             if (p[i] == '~'  && p[i-1] == '.') { /* Have suffix */
  3961.             p[i-1] = NUL;    /* Trim it */
  3962.             fn = dname;
  3963.             debug(F111,"znewn suffix removal 2",fn,i);
  3964.             flag = 1;    /* done */
  3965.             } else if (p[i] >= '0' && p[i] <= '9') { /* Number part */
  3966.             continue;    /* Keep going */
  3967.             } else {        /* Something else */
  3968.             flag = 1;    /* Not a backup suffix - quit. */
  3969.             }
  3970.             break;
  3971.         }
  3972.         }
  3973.     }
  3974.     }
  3975.     if ((fnlen = strlen(fn)) < 1) {    /* Get length */
  3976.     if (dname) free(dname);
  3977.     return;
  3978.     }
  3979.     debug(F111,"znewn",fn,fnlen);
  3980.  
  3981.     debug(F101,"znewn max 1","",max);
  3982.     if (max < 14) max = 14;             /* Make max reasonable for any UNIX */
  3983.     if (max > ZNEWNBL) max = ZNEWNBL;
  3984.     debug(F101,"znewn max 2","",max);
  3985.  
  3986.     if ((fnfp = zfnqfp(fn, ZNEWNBL, buf))) { /* Get fully qualified name */
  3987.         namepart = fnfp->fname;         /* Isolate the filename */
  3988.         k = strlen(fn);                 /* Length of name part */
  3989.         debug(F111,"znewn namepart",namepart,k);
  3990.     } else {
  3991.     if (dname) free(dname);
  3992.     return;
  3993.     }
  3994.     buflen = fnfp->len;                 /* Length of fully qualified name */
  3995.     debug(F111,"znewn len",buf,buflen);
  3996.  
  3997.     if (k + MAXBUDIGITS + 3 < max) {    /* Backup name fits - no overflow */
  3998.     /* Make pattern for backup names */
  3999.         ckstrncpy(buf+buflen,".~*~",ZNEWNBL+12-buflen);
  4000.         n = nzxpand(buf,ZX_FILONLY);    /* Expand the pattern */
  4001.         debug(F111,"znewn A matches",buf,n);
  4002.         while (n-- > 0) {               /* Find any existing name.~n~ files */
  4003.             xp = *mtchptr++;            /* Point at matching name */
  4004.             t = atoi(xp+buflen+2);      /* Get number */
  4005.             if (t > d) d = t;           /* Save d = highest version number */
  4006.         }
  4007.         sprintf(buf+buflen,".~%d~",d+1); /* Yes, make "name.~<d+1>~" */
  4008.         debug(F110,"znewn A newname",buf,0);
  4009.     } else {                            /* Backup name would be too long */
  4010.         int xlen;                       /* So we have to eat back into it */
  4011.         int delta;
  4012.         char buf2[ZNEWNBL+12];
  4013.  
  4014.         delta = max - k;
  4015.         debug(F101,"znewn B delta","",delta);
  4016.  
  4017.         for (i = MAXBUDIGITS; i > 0; i--) { /* In this case the format of */
  4018.             ckstrncpy(buf2,buf,ZNEWNBL+12); /* the backup name depends on */
  4019.             xlen = buflen - i - 3 + delta;  /* how many digits are in the */
  4020.             ckstrncpy(buf2+xlen,".~*~",ZNEWNBL+12-xlen); /* backup number */
  4021.             n = nzxpand(buf2,ZX_FILONLY);
  4022.             debug(F111,"znewn B matches",buf2,n);
  4023.             if (n > 0)
  4024.               break;
  4025.         }
  4026.         while (n-- > 0) {               /* Find any existing name.~n~ files */
  4027.             xp = *mtchptr++;            /* Point at matching name */
  4028.             t = atoi(xp+xlen+2);        /* Get number */
  4029.             if (t > d) d = t;           /* Save d = highest version number */
  4030.         }
  4031.         if (d > 0)                      /* If the odometer turned over... */
  4032.           if ((d % 10) == 9)            /* back up one space. */
  4033.             xlen--;
  4034.         sprintf(buf2+xlen,".~%d~",d+1); /* This just fits */
  4035.         ckstrncpy(buf,buf2,ZNEWNBL+12);    /* (we could be more clever here...) */
  4036.         debug(F110,"znewn B new name",buf,0);
  4037.     }
  4038.     *s = buf;                           /* Point to new name */
  4039.     ck_znewn = d+1;                     /* Also make it available globally */
  4040.     if (dname) free(dname);
  4041.     return;
  4042. }
  4043.  
  4044. /*  Z R E N A M E  --  Rename a file  */
  4045. /*
  4046.    Call with old and new names.
  4047.    If new name is the name of a directory, the 'old' file is moved to
  4048.    that directory.
  4049.    Returns 0 on success, -1 on failure.
  4050. */
  4051. int
  4052. zrename(old,new) char *old, *new; {
  4053.     char *p, *s;
  4054.     int x;
  4055.  
  4056.     if (!old) old = "";
  4057.     if (!new) new = "";
  4058.     debug(F110,"zrename old",old,0);
  4059.     debug(F110,"zrename new",new,0);
  4060.     if (!*old) return(-1);
  4061.     if (!*new) return(-1);
  4062.  
  4063. #ifdef IKSD
  4064. #ifdef CK_LOGIN
  4065.     if (inserver && isguest)
  4066.       return(-1);
  4067. #endif /* CK_LOGIN */
  4068. #endif /* IKSD */
  4069.  
  4070. #ifdef CKROOT
  4071.     debug(F111,"zrename setroot",ckroot,ckrootset);
  4072.     if (ckrootset) {
  4073.     if (!zinroot(old)) {
  4074.         debug(F110,"zrename old: setroot violation",old,0);
  4075.         return(-1);
  4076.     }
  4077.     if (!zinroot(new)) {
  4078.         debug(F110,"zrename new: setroot violation",new,0);
  4079.         return(-1);
  4080.     }
  4081.     }
  4082. #endif /* CKROOT */
  4083.  
  4084.     p = NULL;
  4085.     s = new;
  4086.  
  4087.     if (isdir(new)) {
  4088.         char *q = NULL;
  4089.         x = strlen(new);
  4090.         if (!(p = malloc(strlen(new) + strlen(old) + 2)))
  4091.           return(-1);
  4092.         strcpy(p,new);                  /* (safe) Directory part */
  4093.         if (!ISDIRSEP(*(new+x-1)))      /* Separator, if needed */
  4094.           strcat(p,"/");        /* (safe) */
  4095.         zstrip(old,&q);                 /* Strip path part from old name */
  4096.         strcat(p,q);                    /* cat to new directory (safe) */
  4097.         s = p;
  4098.         debug(F110,"zrename dir",s,0);
  4099.     }
  4100. #ifdef DEBUG
  4101.     else debug(F110,"zrename no dir",s,0);
  4102. #endif /* DEBUG */
  4103.  
  4104. #ifdef IKSD
  4105.     if (inserver && (!ENABLED(en_del))) {
  4106.     if (zchki(s) > -1)        /* Destination file exists? */
  4107.       return(-1);
  4108.     }
  4109. #endif /* IKSD */
  4110.  
  4111.     x = -1;                             /* Return code. */
  4112. #ifdef RENAME
  4113. /* Atomic, preferred, uses a single system call, rename(), if available. */
  4114.     x = rename(old,s);
  4115.     debug(F111,"zrename rename()",old,x);
  4116.     if (x) x = -1;
  4117. #endif /* RENAME */
  4118.  
  4119.     /* If rename() failed or not available try link()/unlink() */
  4120.  
  4121.     if (x < 0) {
  4122.     if (zchko(old) > -1) {        /* Requires write access to orignal */
  4123.         x = link(old,s);
  4124.         debug(F111,"zrename link()",old,x);
  4125.         if (x > -1) {        /* Make a link with the new name. */
  4126.         x = unlink(old);
  4127.         debug(F111,"zrename unlink()",old,x);
  4128.         }
  4129.         /* If link/unlink failed copy and delete */
  4130.         if (x < 0) {
  4131.         x = zcopy(old,s);
  4132.         debug(F111,"zrename zcopy()",old,x);
  4133.         if (x > -1) {
  4134.             x = zdelet(old);
  4135.             debug(F111,"zrename zdelet()",old,x);
  4136.         }
  4137.         }
  4138.     }
  4139.     }
  4140.     fullname[0] = '\0';            /* Clear this out for next time. */
  4141.  
  4142. #ifdef CKSYSLOG
  4143.     if (ckxsyslog >= SYSLG_FC && ckxlogging) {
  4144.         zfnqfp(old,CKMAXPATH,fullname);
  4145.         tmp2[0] = '\0';
  4146.         zfnqfp(s,CKMAXPATH,tmp2);
  4147.         if (x > -1)
  4148.           syslog(LOG_INFO,"file[] %s: renamed to %s ok", fullname, tmp2);
  4149.         else
  4150.           syslog(LOG_INFO,"file[] %s: rename to %s failed (%m)",fullname,tmp2);
  4151.     }
  4152. #endif /* CKSYSLOG */
  4153.  
  4154.     if (p) free(p);
  4155.     return(x);
  4156. }
  4157.  
  4158. /*  Z C O P Y  --  Copy a single file. */
  4159. /*
  4160.   Call with source and destination names.
  4161.   If destination is a directory, the source file is
  4162.   copied to that directory with its original name.
  4163.   Returns:
  4164.    0 on success.
  4165.   <0 on failure:
  4166.   -2 = source file is not a regular file.
  4167.   -3 = source file not found.
  4168.   -4 = permission denied.
  4169.   -5 = source and destination are the same file.
  4170.   -6 = i/o error.
  4171.   -1 = other error.
  4172. */
  4173. int
  4174. zcopy(source,destination) char *source, *destination; {
  4175.     char *src, *dst;            /* Local pointers to filenames */
  4176.     int x, y, rc;                       /* Workers */
  4177.     int in = -1, out = -1;              /* i/o file descriptors */
  4178.     struct stat srcbuf;                 /* Source file info buffer */
  4179.     int perms;                          /* Output file permissions */
  4180.     char buf[1024];                     /* File copying buffer */
  4181.  
  4182.     if (!source) source = "";
  4183.     if (!destination) destination = "";
  4184.  
  4185.     debug(F110,"zcopy src arg",source,0);
  4186.     debug(F110,"zcopy dst arg",destination,0);
  4187.  
  4188.     if (!*source) return(-1);
  4189.     if (!*destination) return(-1);
  4190.  
  4191. #ifdef IKSD
  4192. #ifdef CK_LOGIN
  4193.     if (inserver && isguest)
  4194.       return(-4);
  4195. #endif /* CK_LOGIN */
  4196. #endif /* IKSD */
  4197.  
  4198. #ifdef CKROOT
  4199.     debug(F111,"zcopy setroot",ckroot,ckrootset);
  4200.     if (ckrootset) {
  4201.     if (!zinroot(source)) {
  4202.         debug(F110,"zcopy source: setroot violation",source,0);
  4203.         return(-1);
  4204.     }
  4205.     if (!zinroot(destination)) {
  4206.         debug(F110,"zcopy destination: setroot violation",destination,0);
  4207.         return(-1);
  4208.     }
  4209.     }
  4210. #endif /* CKROOT */
  4211.  
  4212.     src = source;
  4213.     dst = destination;
  4214.  
  4215.     if (stat(src,&srcbuf) == 0) {       /* Get source file info */
  4216.         struct stat dstbuf;             /* Destination file info buffer */
  4217.     debug(F101,"STAT","",6);
  4218.         if (stat(dst,&dstbuf) == 0) {
  4219.         debug(F101,"STAT","",7);
  4220.             if (srcbuf.st_dev == dstbuf.st_dev)
  4221.               if (srcbuf.st_ino == dstbuf.st_ino) {
  4222.                   debug(F100,"zcopy files identical: stat()","",0);
  4223.                   return(-5);
  4224.               }
  4225.         }
  4226.     } else {                            /* stat() failed... */
  4227.     debug(F101,"STAT","",8);
  4228.         debug(F111,"source file not found",src,errno);
  4229.         return(-3);
  4230.     }
  4231.     fullname[0] = '\0';                 /* Get full pathnames */
  4232.     if (zfnqfp(source,CKMAXPATH,fullname))
  4233.       src = fullname;
  4234.     debug(F110,"zcopy src",src,0);
  4235.     tmp2[0] = '\0';
  4236.     if (zfnqfp(destination,CKMAXPATH,tmp2))
  4237.       dst = tmp2;
  4238.     debug(F110,"zcopy dst 1",dst,0);
  4239.     if (!strcmp(src,dst)) {             /* Src and dst are same file? */
  4240.         debug(F100,"zcopy files identical: strcmp()","",0); /* This... */
  4241.         return(-5);                     /* should not happen. */
  4242.     }
  4243.     if (isdir(src)) {                   /* Source file is a directory? */
  4244.         debug(F110,"zcopy source is directory",src,0);
  4245.         return(-2);                     /* Fail */
  4246.     }
  4247.     if (isdir(dst)) {                   /* Destination is a directory? */
  4248.         char *q = NULL;                 /* Yes, add filename to it. */
  4249.         x = strlen(dst);
  4250.     if (x < 1) return(-1);
  4251.         if (!ISDIRSEP(*(dst+x-1))) {    /* Add separator if needed */
  4252.             tmp2[x++] = '/';
  4253.             tmp2[x] = '\0';
  4254.         }
  4255.     debug(F111,"zcopy dst 2",dst,x);
  4256.         zstrip(src,&q);                 /* Strip path part from old name */
  4257.         ckstrncpy(tmp2+x,q,CKMAXPATH-x); /* Concatenate it to new name */
  4258.     }
  4259.     debug(F110,"zcopy dst 3",dst,0);
  4260.  
  4261. #ifdef IKSD
  4262.     if (inserver && (!ENABLED(en_del))) {
  4263.     if (zchki(dst) > -1)        /* Destination file exists? */
  4264.       return(-4);
  4265.     }
  4266. #endif /* IKSD */
  4267.  
  4268.     perms = umask(0);                   /* Get user's umask */
  4269.     umask(perms);            /* Put it back! */
  4270.     perms ^= 0777;                      /* Flip the bits */
  4271.     perms &= 0666;                      /* Zero execute bits from umask */
  4272.     perms |= (srcbuf.st_mode & 0111);   /* OR in source file's execute bits */
  4273.     rc = -1;                            /* Default return code */
  4274.     errno = 0;                          /* Reset errno */
  4275.     in = open(src, O_RDONLY, 0);        /* Open source file */
  4276.     debug(F111,"zcopy open source",src,in);
  4277.     if (in > -1) {                      /* If open... */
  4278.     /* Open destination file */
  4279. #ifdef O_TRUNC
  4280.         out = open(dst, O_WRONLY|O_CREAT|O_TRUNC, perms);
  4281. #else
  4282.         out = open(dst, O_WRONLY|O_CREAT, perms);
  4283. #endif /* O_TRUNC */
  4284.         debug(F111,"zcopy open dest",dst,out);
  4285.         if (out > -1) {                 /* If open... */
  4286.             while ((x = read(in,buf,1024)) > 0) { /* Copy in 1K blocks */
  4287.                 y = write(out,buf,x);
  4288.                 if (y < 0) {            /* On write failure */
  4289.                     x = -1;
  4290.                     rc = -6;            /* Indicate i/o error */
  4291.                     break;
  4292.                 }
  4293.             }
  4294.             debug(F101,"zcopy final read","",x);
  4295.             debug(F101,"zcopy errno","",errno);
  4296.             rc = (x == 0) ? 0 : -6;     /* In case of read failure */
  4297.         }
  4298.     }
  4299.     if (in > -1) close(in);             /* Close files */
  4300.     if (out > -1) close(out);
  4301.     if (rc == -1) {                     /* Set return code */
  4302.         switch (errno) {
  4303.           case ENOENT: rc = -3; break;
  4304.           case EACCES: rc = -4; break;
  4305.           case EIO:    rc = -6;
  4306.         }
  4307.     }
  4308.  
  4309. #ifdef CKSYSLOG
  4310.     if (rc > -1 && ckxsyslog >= SYSLG_FC && ckxlogging) {
  4311.         if (rc)
  4312.           syslog(LOG_INFO,"file[] %s: copy to %s failed (%m)", fullname, tmp2);
  4313.         else
  4314.           syslog(LOG_INFO,"file[] %s: copy to %s ok", fullname, tmp2);
  4315.     }
  4316. #endif /* CKSYSLOG */
  4317.  
  4318.     return(rc);
  4319. }
  4320.  
  4321. /*  Z S A T T R */
  4322. /*
  4323.  Fills in a Kermit file attribute structure for the file which is to be sent.
  4324.  Returns 0 on success with the structure filled in, or -1 on failure.
  4325.  If any string member is null, then it should be ignored.
  4326.  If any numeric member is -1, then it should be ignored.
  4327. */
  4328. #ifdef CK_PERMS
  4329.  
  4330. #ifdef CK_GPERMS
  4331. #undef CK_GPERMS
  4332. #endif /* CK_GPERMS */
  4333.  
  4334. #ifdef UNIX
  4335. #ifndef S_IRUSR
  4336. #define S_IRUSR 0400
  4337. #endif /* S_IRUSR */
  4338. #ifndef S_IWUSR
  4339. #define S_IXUSR 0200
  4340. #endif /* S_IWUSR */
  4341. #ifndef S_IXUSR
  4342. #define S_IXUSR 0100
  4343. #endif /* S_IXUSR */
  4344. #endif /* UNIX */
  4345.  
  4346. #ifdef S_IRUSR
  4347. #ifdef S_IWUSR
  4348. #ifdef S_IXUSR
  4349. #define CK_GPERMS
  4350. #endif /* S_IXUSR */
  4351. #endif /* S_IWUSR */
  4352. #endif /* S_IRUSR */
  4353.  
  4354. static char gperms[2];
  4355.  
  4356. #endif /* CK_GPERMS */
  4357.  
  4358. static char lperms[24];
  4359.  
  4360. #ifdef CK_PERMS
  4361. static char xlperms[24];
  4362.  
  4363. /*  Z S E T P E R M  --  Set permissions of a file  */
  4364.  
  4365. int
  4366. zsetperm(f,code) char * f; int code; {
  4367.     int x;
  4368. #ifdef CK_SCO32V4
  4369.     mode_t mask;
  4370. #else
  4371.     int mask;
  4372. #endif /* CK_SCO32V4 */
  4373.     mask = code;
  4374.     if (inserver && guest) {
  4375.     debug(F110,"zsetperm guest",f,0);
  4376.     return(0);
  4377.     }
  4378.     x = chmod(f,mask);
  4379.     if (x < 0) {
  4380.     debug(F111,"zsetperm error",f,errno);
  4381.     return(0);
  4382.     }
  4383.     debug(F111,"zsetperm ok",f,mask);
  4384.     return(1);
  4385. }
  4386.  
  4387. /*  Z G P E R M  --  Get permissions of a file as an octal string  */
  4388.  
  4389. char *
  4390. zgperm(f) char *f; {
  4391.     extern int diractive;
  4392.     int x; char *s = (char *)xlperms;
  4393.     struct stat buf;
  4394.     debug(F110,"zgperm",f,0);
  4395.     if (!f) return("----------");
  4396.     if (!*f) return("----------");
  4397.  
  4398. #ifdef CKROOT
  4399.     debug(F111,"zgperm setroot",ckroot,ckrootset);
  4400.     if (ckrootset) if (!zinroot(f)) {
  4401.     debug(F110,"zgperm setroot violation",f,0);
  4402.     return("----------");
  4403.     }
  4404. #endif /* CKROOT */
  4405.  
  4406. #ifdef USE_LSTAT
  4407.     if (diractive)
  4408.       x = lstat(f,&buf);
  4409.     else
  4410. #endif /* USE_LSTAT */
  4411.       x = stat(f,&buf);
  4412.     debug(F101,"STAT","",9);
  4413.     if (x < 0)
  4414.       return("----------");
  4415.     sprintf(s,"%o",buf.st_mode);
  4416.     debug(F110,"zgperm",s,0);
  4417.     return(s);
  4418. }
  4419.  
  4420. /* Like zgperm() but returns permissions in "ls -l" string format */
  4421.  
  4422. static char xsperms[24];
  4423.  
  4424. char *
  4425. ziperm(f) char * f; {
  4426.     extern int diractive;
  4427.     int x; char *s = (char *)xsperms;
  4428.     struct stat buf;
  4429.     unsigned int perms = 0;
  4430.  
  4431.     debug(F110,"ziperm",f,0);
  4432.  
  4433.     if (!f) return(NULL);
  4434.     if (!*f) return(NULL);
  4435.  
  4436.     if (diractive && zgfs_mode != 0) {
  4437.     perms = zgfs_mode;        /* zgetfs() already got them */
  4438.     } else {
  4439. #ifdef USE_LSTAT
  4440.     if (diractive)
  4441.       x = lstat(f,&buf);
  4442.     else
  4443. #endif /* USE_LSTAT */
  4444.       x = stat(f,&buf);
  4445.     debug(F101,"STAT","",10);
  4446.     if (x < 0)
  4447.       return("----------");
  4448.     perms = buf.st_mode;
  4449.     }
  4450.     switch (perms & S_IFMT) {
  4451.       case S_IFDIR:
  4452.         *s++ = 'd';
  4453.         break;
  4454.       case S_IFCHR:                     /* Character special */
  4455.         *s++ = 'c';
  4456.         break;
  4457.       case S_IFBLK:                     /* Block special */
  4458.         *s++ = 'b';
  4459.         break;
  4460.       case S_IFREG:                     /* Regular */
  4461.         *s++ = '-';
  4462.         break;
  4463. #ifdef S_IFLNK
  4464.       case S_IFLNK:                     /* Symbolic link */
  4465.         *s++ = 'l';
  4466.         break;
  4467. #endif /* S_IFLNK */
  4468. #ifdef S_IFSOCK
  4469.       case S_IFSOCK:                    /* Socket */
  4470.         *s++ = 's';
  4471.         break;
  4472. #endif /* S_IFSOCK */
  4473. #ifdef S_IFIFO
  4474. #ifndef Plan9
  4475. #ifndef COHERENT
  4476.       case S_IFIFO:                     /* FIFO */
  4477.         *s++ = 'p';
  4478.         break;
  4479. #endif /* COHERENT */
  4480. #endif /* Plan9 */
  4481. #endif /* S_IFIFO */
  4482. #ifdef S_IFWHT
  4483.       case S_IFWHT:                     /* Whiteout */
  4484.         *s++ = 'w';
  4485.         break;
  4486. #endif /* S_IFWHT */
  4487.       default:                          /* Unknown */
  4488.         *s++ = '?';
  4489.         break;
  4490.     }
  4491.     if (perms & S_IRUSR)          /* Owner's permissions */
  4492.       *s++ = 'r';
  4493.     else
  4494.       *s++ = '-';
  4495.     if (perms & S_IWUSR)
  4496.       *s++ = 'w';
  4497.     else
  4498.       *s++ = '-';
  4499.     switch (perms & (S_IXUSR | S_ISUID)) {
  4500.       case 0:
  4501.         *s++ = '-';
  4502.         break;
  4503.       case S_IXUSR:
  4504.         *s++ = 'x';
  4505.         break;
  4506.       case S_ISUID:
  4507.         *s++ = 'S';
  4508.         break;
  4509.       case S_IXUSR | S_ISUID:
  4510.         *s++ = 's';
  4511.         break;
  4512.     }
  4513.     if (perms & S_IRGRP)          /* Group permissions */
  4514.       *s++ = 'r';
  4515.     else
  4516.       *s++ = '-';
  4517.     if (perms & S_IWGRP)
  4518.       *s++ = 'w';
  4519.     else
  4520.       *s++ = '-';
  4521.     switch (perms & (S_IXGRP | S_ISGID)) {
  4522.       case 0:
  4523.         *s++ = '-';
  4524.         break;
  4525.       case S_IXGRP:
  4526.         *s++ = 'x';
  4527.         break;
  4528.       case S_ISGID:
  4529.         *s++ = 'S';
  4530.         break;
  4531.       case S_IXGRP | S_ISGID:
  4532.         *s++ = 's';
  4533.         break;
  4534.     }
  4535.     if (perms & S_IROTH)          /* World permissions */
  4536.       *s++ = 'r';
  4537.     else
  4538.       *s++ = '-';
  4539.     if (perms & S_IWOTH)
  4540.       *s++ = 'w';
  4541.     else
  4542.       *s++ = '-';
  4543.     switch (
  4544. #ifdef Plan9
  4545.             perms & (S_IXOTH)
  4546. #else
  4547.             perms & (S_IXOTH | S_ISVTX)
  4548. #endif
  4549.             ) {
  4550.       case 0:
  4551.         *s++ = '-';
  4552.         break;
  4553.       case S_IXOTH:
  4554.         *s++ = 'x';
  4555.         break;
  4556. #ifndef Plan9
  4557.       case S_ISVTX:
  4558.         *s++ = 'T';
  4559.         break;
  4560.       case S_IXOTH | S_ISVTX:
  4561.         *s++ = 't';
  4562.         break;
  4563. #endif /* Plan9 */
  4564.     }
  4565.     *s = '\0';
  4566.     debug(F110,"ziperm",xsperms,0);
  4567.     return((char *)xsperms);
  4568. }
  4569.  
  4570. #else
  4571.  
  4572. char *
  4573. zgperm(f) char *f; {
  4574.     return("----------");
  4575. }
  4576. char *
  4577. ziperms(f) char *f; {
  4578.     return("----------");
  4579. }
  4580. #endif /* CK_PERMS */
  4581.  
  4582. int
  4583. zsattr(xx) struct zattr *xx; {
  4584.     CK_OFF_T k; int x;
  4585.     struct stat buf;
  4586.  
  4587.     k = iflen % 1024;            /* File length in K */
  4588.     if (k) k = 1L;
  4589.     xx->lengthk = (iflen / 1024) + k;
  4590.     xx->type.len = 0;                   /* File type can't be filled in here */
  4591.     xx->type.val = "";
  4592.     if (*nambuf) {
  4593.         xx->date.val = zfcdat(nambuf);  /* File creation date */
  4594.         xx->date.len = (int)strlen(xx->date.val);
  4595.     } else {
  4596.         xx->date.len = 0;
  4597.         xx->date.val = "";
  4598.     }
  4599.     xx->creator.len = 0;                /* File creator */
  4600.     xx->creator.val = "";
  4601.     xx->account.len = 0;                /* File account */
  4602.     xx->account.val = "";
  4603.     xx->area.len = 0;                   /* File area */
  4604.     xx->area.val = "";
  4605.     xx->password.len = 0;               /* Area password */
  4606.     xx->password.val = "";
  4607.     xx->blksize = -1L;                  /* File blocksize */
  4608.     xx->xaccess.len = 0;                /* File access */
  4609.     xx->xaccess.val = "";
  4610.     xx->encoding.len = 0;               /* Transfer syntax */
  4611.     xx->encoding.val = 0;
  4612.     xx->disp.len = 0;                   /* Disposition upon arrival */
  4613.     xx->disp.val = "";
  4614.     xx->lprotect.len = 0;               /* Local protection */
  4615.     xx->lprotect.val = "";
  4616.     xx->gprotect.len = 0;               /* Generic protection */
  4617.     xx->gprotect.val = "";
  4618.     x = -1;
  4619.     if (*nambuf) x = stat(nambuf,&buf);
  4620.     debug(F101,"STAT","",11);
  4621.     if (x >= 0) {
  4622.         debug(F111,"zsattr buf.st_mode & 0777",nambuf,buf.st_mode & 0777);
  4623.         /* UNIX filemode as an octal string without filetype bits */
  4624.         sprintf(lperms,"%o",buf.st_mode & 0777);
  4625.         xx->lprotect.len = (int)strlen(lperms);
  4626.         xx->lprotect.val = (char *)lperms;
  4627.         x = 0;
  4628. #ifdef CK_GPERMS
  4629.         /* Generic permissions only if we have stat.h symbols defined */
  4630.         if (buf.st_mode & S_IRUSR) x |= 1;      /* Read */
  4631.         if (buf.st_mode & S_IWUSR) x |= (2+16); /* Write and Delete */
  4632.         if (buf.st_mode & S_IXUSR) x |= 4;      /* Execute */
  4633.         gperms[0] = tochar(x);
  4634.         gperms[1] = NUL;
  4635.         xx->gprotect.len = 1;
  4636.         xx->gprotect.val = (char *)gperms;
  4637. #endif /* CK_GPERMS */
  4638.     }
  4639.     debug(F111,"zsattr lperms",xx->lprotect.val,xx->lprotect.len);
  4640.     debug(F111,"zsattr gperms",xx->gprotect.val,xx->gprotect.len);
  4641.     xx->systemid.val = "U1";            /* U1 = UNIX */
  4642.     xx->systemid.len = 2;               /* System ID */
  4643.     xx->recfm.len = 0;                  /* Record format */
  4644.     xx->recfm.val = "";
  4645.     xx->sysparam.len = 0;               /* System-dependent parameters */
  4646.     xx->sysparam.val = "";
  4647.     xx->length = iflen;                 /* Length */
  4648.     return(0);
  4649. }
  4650.  
  4651. /* Z F C D A T  --  Get file creation date */
  4652. /*
  4653.   Call with pointer to filename.
  4654.   On success, returns pointer to modification date in yyyymmdd hh:mm:ss format.
  4655.   On failure, returns pointer to null string.
  4656. */
  4657. static char datbuf[40];
  4658.  
  4659. char *
  4660. #ifdef CK_ANSIC
  4661. zdtstr(time_t timearg)
  4662. #else
  4663. zdtstr(timearg) time_t timearg;
  4664. #endif /* CK_ANSIC */
  4665. /* zdtstr */ {
  4666. #ifndef TIMESTAMP
  4667.     return("");
  4668. #else
  4669.     struct tm * time_stamp;
  4670.     struct tm * localtime();
  4671.     int yy, ss;
  4672.  
  4673.     debug(F101,"zdtstr timearg","",timearg);
  4674.     if (timearg < 0)
  4675.       return("");
  4676.     time_stamp = localtime(&(timearg));
  4677.     if (!time_stamp) {
  4678.         debug(F100,"localtime returns null","",0);
  4679.         return("");
  4680.     }
  4681. /*
  4682.   We assume that tm_year is ALWAYS years since 1900.
  4683.   Any platform where this is not the case will have problems
  4684.   starting in 2000.
  4685. */
  4686.     yy = time_stamp->tm_year;           /* Year - 1900 */
  4687.     debug(F101,"zdtstr tm_year","",time_stamp->tm_year);
  4688.     if (yy > 1000) {
  4689.         debug(F101,"zstrdt YEAR-2000 ALERT 1: localtime year","",yy);
  4690.     }
  4691.     yy += 1900;
  4692.     debug(F101,"zdatstr year","",yy);
  4693.  
  4694.     if (time_stamp->tm_mon  < 0 || time_stamp->tm_mon  > 11)
  4695.       return("");
  4696.     if (time_stamp->tm_mday < 0 || time_stamp->tm_mday > 31)
  4697.       return("");
  4698.     if (time_stamp->tm_hour < 0 || time_stamp->tm_hour > 23)
  4699.       return("");
  4700.     if (time_stamp->tm_min  < 0 || time_stamp->tm_min  > 59)
  4701.       return("");
  4702.     ss = time_stamp->tm_sec;            /* Seconds */
  4703.     if (ss < 0 || ss  > 59)             /* Some systems give a BIG number */
  4704.       ss = 0;
  4705.     sprintf(datbuf,
  4706. #ifdef pdp11
  4707. /* For some reason, 2.1x BSD sprintf gets the last field wrong. */
  4708.             "%04d%02d%02d %02d:%02d:00",
  4709. #else
  4710.             "%04d%02d%02d %02d:%02d:%02d",
  4711. #endif /* pdp11 */
  4712.             yy,
  4713.             time_stamp->tm_mon + 1,
  4714.             time_stamp->tm_mday,
  4715.             time_stamp->tm_hour,
  4716.             time_stamp->tm_min
  4717. #ifndef pdp11
  4718.             , ss
  4719. #endif /* pdp11 */
  4720.             );
  4721.     yy = (int)strlen(datbuf);
  4722.     debug(F111,"zdatstr",datbuf,yy);
  4723.     if (yy > 17) datbuf[17] = '\0';
  4724.     return(datbuf);
  4725. #endif /* TIMESTAMP */
  4726. }
  4727.  
  4728. char *
  4729. zfcdat(name) char *name; {
  4730. #ifdef TIMESTAMP
  4731.     struct stat buffer;
  4732.     extern int diractive;
  4733.     unsigned int mtime;
  4734.     int x;
  4735.     char * s;
  4736.  
  4737.     if (!name)
  4738.       return("");
  4739.     s = name;
  4740.     if (!*s)
  4741.       return("");
  4742.  
  4743. #ifdef CKROOT
  4744.     debug(F111,"zfcdat setroot",ckroot,ckrootset);
  4745.     if (ckrootset) if (!zinroot(name)) {
  4746.     debug(F110,"zfcdat setroot violation",name,0);
  4747.     return("");
  4748.     }
  4749. #endif /* CKROOT */
  4750.  
  4751. #ifdef DTILDE
  4752.     if (*s == '~') {
  4753.         s = tilde_expand(s);
  4754.         if (!s) s = "";
  4755.         if (!*s) s = name;
  4756.     }
  4757. #endif /* DTILDE */
  4758.  
  4759.     datbuf[0] = '\0';
  4760.     x = 0;
  4761.     debug(F111,"zfcdat",s,diractive);
  4762.  
  4763.     if (diractive && zgfs_mtime) {
  4764.     mtime = zgfs_mtime;
  4765.     } else {
  4766. #ifdef USE_LSTAT
  4767.     if (diractive) {
  4768.         x = lstat(s,&buffer);
  4769.         debug(F101,"STAT","",12);
  4770.         debug(F101,"zfcdat lstat","",x);
  4771.     } else {
  4772. #endif /* USE_LSTAT */
  4773.         x = stat(s,&buffer);
  4774.         debug(F101,"STAT","",13);
  4775.         debug(F101,"zfcdat stat","",x);
  4776. #ifdef USE_LSTAT
  4777.     }
  4778. #endif /* USE_LSTAT */
  4779.     if (x != 0) {
  4780. #ifdef USE_LSTAT
  4781.         debug(F111,"zfcdat stat failed",s,errno);
  4782. #else
  4783.         debug(F111,"zfcdat lstat failed",s,errno);
  4784. #endif /* USE_LSTAT */
  4785.         return("");
  4786.     }
  4787.     debug(F101,"zfcdat buffer.st_mtime","",buffer.st_mtime);
  4788.     mtime = buffer.st_mtime;
  4789.     }
  4790.     return(zdtstr(mtime));
  4791. #else
  4792.     return("");
  4793. #endif /* TIMESTAMP */
  4794. }
  4795.  
  4796. #ifndef NOTIMESTAMP
  4797.  
  4798. /* Z S T R D T  --  Converts local date string to internal representation */
  4799. /*
  4800.   In our case (UNIX) this is seconds since midnite 1 Jan 1970 UTC,
  4801.   suitable for comparison with UNIX file dates.  As far as I know, there is
  4802.   no library or system call -- at least nothing reasonably portable -- to
  4803.   convert local time to UTC.
  4804. */
  4805. time_t
  4806. zstrdt(date,len) char * date; int len; {
  4807. #ifdef M_UNIX
  4808. /*
  4809.   SCO UNIX 3.2v2.0 and ODT 2.0 lack prototypes for ftime().
  4810.   ODT 3.0 (3.2v4.2 OS) has a prototype, which may vary in
  4811.   dependence on the XPG4 supplement presence.  So always use
  4812.   what the system header file supplies in ODT 3.0...
  4813. */
  4814. #ifndef ODT30
  4815. #ifndef _SCO_DS
  4816.     extern void ftime();  /* extern void ftime(struct timeb *) */
  4817. #endif /* _SCO_DS */
  4818. #endif /* ODT30 */
  4819. #else
  4820. #ifndef M_XENIX
  4821.     extern int ftime();
  4822. #endif /* M_XENIX */
  4823. #endif /* M_UNIX */
  4824.     extern struct tm * localtime();
  4825.  
  4826.     /* And this should have been declared always through a header file */
  4827. #ifdef HPUX10
  4828.     time_t tmx;
  4829.     long days;
  4830. #else
  4831. #ifdef BSD44
  4832.     time_t tmx;
  4833.     long days;
  4834. #else
  4835.     long tmx, days;
  4836. #endif /* BSD44 */
  4837. #endif /* HPUX10 */
  4838.     int i, n, isleapyear;
  4839.                    /*       J  F  M  A   M   J   J   A   S   O   N   D   */
  4840.                    /*      31 28 31 30  31  30  31  31  30  31  30  31   */
  4841.     static
  4842.     int monthdays [13] = {  0,0,31,59,90,120,151,181,212,243,273,304,334 };
  4843.     char s[5];
  4844.     struct tm *time_stamp;
  4845.  
  4846. #ifdef BSD44
  4847.     struct timeval tp[2];
  4848.     long xtimezone = 0L;
  4849. #else
  4850. #ifdef V7
  4851.     struct utimbuf {
  4852.       time_t timep[2];          /* New access and modificaton time */
  4853.     } tp;
  4854.     char *tz;
  4855.     long timezone;              /* In case timezone not defined in .h file */
  4856. #else
  4857. #ifdef SYSUTIMEH
  4858.     struct utimbuf tp;
  4859. #else
  4860.     struct utimbuf {
  4861.         time_t atime;
  4862.         time_t mtime;
  4863.     } tp;
  4864. #endif /* SYSUTIMEH */
  4865. #endif /* V7 */
  4866. #endif /* BSD44 */
  4867.  
  4868. #ifdef ANYBSD
  4869.     long timezone = 0L;
  4870.     static struct timeb tbp;
  4871. #endif /* ANYBSD */
  4872.  
  4873. #ifdef BEBOX
  4874.     long timezone = 0L;
  4875. #endif /* BEBOX */
  4876.  
  4877.     debug(F111,"zstrdt",date,len);
  4878.  
  4879.     if ((len == 0)
  4880.         || (len != 17)
  4881.         || (date[8] != ' ')
  4882.         || (date[11] != ':')
  4883.         || (date[14] != ':') ) {
  4884.         debug(F111,"Bad creation date ",date,len);
  4885.         return(-1);
  4886.     }
  4887.     debug(F111,"zstrdt date check 1",date,len);
  4888.     for(i = 0; i < 8; i++) {
  4889.         if (!isdigit(date[i])) {
  4890.             debug(F111,"Bad creation date ",date,len);
  4891.             return(-1);
  4892.         }
  4893.     }
  4894.     debug(F111,"zstrdt date check 2",date,len);
  4895.     i++;
  4896.  
  4897.     for (; i < 16; i += 3) {
  4898.         if ((!isdigit(date[i])) || (!isdigit(date[i + 1]))) {
  4899.             debug(F111,"Bad creation date ",date,len);
  4900.             return(-1);
  4901.         }
  4902.     }
  4903.     debug(F111,"zstrdt date check 3",date,len);
  4904.  
  4905.  
  4906. #ifdef COMMENT /* was BSD44 */
  4907. /*
  4908.    man gettimeofday on BSDI 3.1 says:
  4909.    "The timezone field is no longer used; timezone information is stored out-
  4910.      side the kernel.  See ctime(3) for more information."  So this chunk of
  4911.    code is effectively a no-op, at least in BSDI 3.x.
  4912. */
  4913.     {
  4914.         int x;
  4915.         struct timezone tzp;
  4916.         x = gettimeofday(NULL, &tzp);
  4917.         debug(F101,"zstrdt BSD44 gettimeofday","",x);
  4918.         if (x > -1)
  4919.           xtimezone = tzp.tz_minuteswest * 60L;
  4920.         else
  4921.           xtimezone = 0L;
  4922.         debug(F101,"zstrdt BSD44 timezone","",xtimezone);
  4923.     }
  4924. #else
  4925. #ifdef ANYBSD
  4926.     debug(F100,"zstrdt BSD calling ftime","",0);
  4927.     ftime(&tbp);
  4928.     debug(F100,"zstrdt BSD back from ftime","",0);
  4929.     timezone = tbp.timezone * 60L;
  4930.     debug(F101,"zstrdt BSD timezone","",timezone);
  4931. #else
  4932. #ifdef SVORPOSIX
  4933.     tzset();                            /* Set timezone */
  4934. #else
  4935. #ifdef V7
  4936.     if ((tz = getenv("TZ")) == NULL)
  4937.       timezone = 0;                     /* UTC/GMT */
  4938.     else
  4939.       timezone = atoi(&tz[3]);          /* Set 'timezone'. */
  4940.     timezone *= 60L;
  4941. #endif /* V7 */
  4942. #endif /* SVORPOSIX */
  4943. #endif /* ANYBSD */
  4944. #endif /* COMMENT (was BSD44) */
  4945.  
  4946.     debug(F100,"zstrdt so far so good","",0);
  4947.  
  4948.     s[4] = '\0';
  4949.     for (i = 0; i < 4; i++)             /* Fix the year */
  4950.       s[i] = date[i];
  4951.  
  4952.     n = atoi(s);
  4953.     debug(F111,"zstrdt year",s,n);
  4954.     if (n < 1970) {
  4955.         debug(F100,"zstrdt fails - year","",n);
  4956.         return(-1);
  4957.     }
  4958.  
  4959. /*  Previous year's leap days.  This won't work after year 2100. */
  4960.  
  4961.     isleapyear = (( n % 4 == 0 && n % 100 !=0) || n % 400 == 0);
  4962.     days = (long) (n - 1970) * 365;
  4963.     days += (n - 1968 - 1) / 4 - (n - 1900 - 1) / 100 + (n - 1600 - 1) / 400;
  4964.  
  4965.     s[2] = '\0';
  4966.  
  4967.     for (i = 4; i < 16; i += 2) {
  4968.         s[0] = date[i];
  4969.         s[1] = date[i + 1];
  4970.         n = atoi(s);
  4971.         switch (i) {
  4972.           case 4:                       /* MM: month */
  4973.             if ((n < 1 ) || ( n > 12)) {
  4974.                 debug(F111,"zstrdt 4 bad date ",date,len);
  4975.                 return(-1);
  4976.             }
  4977.             days += monthdays [n];
  4978.             if (isleapyear && n > 2)
  4979.               ++days;
  4980.             continue;
  4981.  
  4982.           case 6:                       /* DD: day */
  4983.             if ((n < 1 ) || ( n > 31)) {
  4984.                 debug(F111,"zstrdt 6 bad date ",date,len);
  4985.                 return(-1);
  4986.             }
  4987.             tmx = (days + n - 1) * 24L * 60L * 60L;
  4988.             i++;                        /* Skip the space */
  4989.             continue;
  4990.  
  4991.           case 9:                       /* hh: hour */
  4992.             if ((n < 0 ) || ( n > 23)) {
  4993.                 debug(F111,"zstrdt 9 bad date ",date,len);
  4994.                 return(-1);
  4995.             }
  4996.             tmx += n * 60L * 60L;
  4997.             i++;                        /* Skip the colon */
  4998.             continue;
  4999.  
  5000.           case 12:                      /* mm: minute */
  5001.             if ((n < 0 ) || ( n > 59)) {
  5002.                 debug(F111,"zstrdt 12 bad date ",date,len);
  5003.                 return(-1);
  5004.             }
  5005. #ifdef COMMENT /* (was BSD44) */        /* Correct for time zone */
  5006.             tmx += xtimezone;
  5007.             debug(F101,"zstrdt BSD44 tmx","",tmx);
  5008. #else
  5009. #ifdef ANYBSD
  5010.             tmx += timezone;
  5011. #else
  5012. #ifndef CONVEX9 /* Don't yet know how to do this here */
  5013. #ifdef ultrix
  5014.             tmx += (long) timezone;
  5015. #else
  5016. #ifdef Plan9
  5017.             {
  5018.                 extern time_t tzoffset;
  5019.                 tmx += tzoffset;
  5020.             }
  5021. #else
  5022. #ifndef BSD44
  5023. #ifndef NOTIMEZONE
  5024.             tmx += timezone;
  5025. #endif    /* NOTIMEZONE */
  5026. #endif /* BSD44 */
  5027. #endif /* Plan9 */
  5028. #endif /* ultrix */
  5029. #endif /* CONVEX9 */
  5030. #endif /* ANYBSD */
  5031. #endif /* COMMENT (was BSD44) */
  5032.             tmx += n * 60L;
  5033.             i++;                        /* Skip the colon */
  5034.             continue;
  5035.  
  5036.           case 15:                      /* ss: second */
  5037.             if ((n < 0 ) || ( n > 59)) {
  5038.                 debug(F111,"zstrdt 15 bad date ",date,len);
  5039.                 return(-1);
  5040.             }
  5041.             tmx += n;
  5042.         }
  5043.         time_stamp = localtime(&tmx);
  5044.         debug(F101,"zstrdt tmx 1","",tmx);
  5045.         if (!time_stamp)
  5046.           return(-1);
  5047. #ifdef COMMENT
  5048.         /* Why was this here? */
  5049.         time_stamp = localtime(&tmx);
  5050.         debug(F101,"zstrdt tmx 2","",tmx);
  5051. #endif /* COMMENT */
  5052. #ifdef BSD44
  5053.         {   /* New to 7.0 - Works in at at least BSDI 3.1 and FreeBSD 2.2.7 */
  5054.             long zz;
  5055.             zz = time_stamp->tm_gmtoff; /* Seconds away from Zero Meridian */
  5056.             debug(F101,"zstrdt BSD44 tm_gmtoff","",zz);
  5057.             tmx -= zz;
  5058.             debug(F101,"zstrdt BSD44 tmx 3 (GMT)","",tmx);
  5059.         }
  5060. #else
  5061.         /*
  5062.            Daylight Savings Time adjustment.
  5063.            Do this everywhere BUT in BSD44 because in BSD44,
  5064.            tm_gmtoff also includes the DST adjustment.
  5065.         */
  5066.         if (time_stamp->tm_isdst) {
  5067.             tmx -= 60L * 60L;
  5068.             debug(F101,"zstrdt tmx 3 (DST)","",tmx);
  5069.         }
  5070. #endif /* BSD44 */
  5071.         n = time_stamp->tm_year;
  5072.         if (n < 300) {
  5073.             n += 1900;
  5074.         }
  5075.     }
  5076.     return(tmx);
  5077. }
  5078.  
  5079.  
  5080. #ifdef ZLOCALTIME
  5081. /* Z L O C A L T I M E  --  GMT/UTC time string to local time string */
  5082.  
  5083. /*
  5084.    Call with: "yyyymmdd hh:mm:ss" GMT/UTC date-time.
  5085.    Returns:   "yyyymmdd hh:mm:ss" local date-time on success, NULL on failure.
  5086. */
  5087. static char zltimbuf[64];
  5088.  
  5089. char *
  5090. zlocaltime(gmtstring) char * gmtstring; {
  5091. #ifdef M_UNIX
  5092. /*
  5093.   SCO UNIX 3.2v2.0 and ODT 2.0 lack prototypes for ftime().
  5094.   ODT 3.0 (3.2v4.2 OS) has a prototype, which may vary in
  5095.   dependence on the XPG4 supplement presence.  So always use
  5096.   what the system header file supplies in ODT 3.0...
  5097. */
  5098. #ifndef ODT30
  5099. #ifndef _SCO_DS
  5100.     extern void ftime();  /* extern void ftime(struct timeb *) */
  5101. #endif /* _SCO_DS */
  5102. #endif /* ODT30 */
  5103. #else
  5104. #ifndef M_XENIX
  5105.     extern int ftime();
  5106. #endif /* M_XENIX */
  5107. #endif /* M_UNIX */
  5108.     extern struct tm * localtime();
  5109.  
  5110.     /* And this should have been declared always through a header file */
  5111. #ifdef HPUX10
  5112.     time_t tmx;
  5113.     long days;
  5114. #else
  5115. #ifdef BSD44
  5116.     time_t tmx;
  5117.     long days;
  5118. #else
  5119.     long tmx, days;
  5120. #endif /* BSD44 */
  5121. #endif /* HPUX10 */
  5122.     int i, n, x, isleapyear;
  5123.                    /*       J  F  M  A   M   J   J   A   S   O   N   D   */
  5124.                    /*      31 28 31 30  31  30  31  31  30  31  30  31   */
  5125.     static
  5126.     int monthdays [13] = {  0,0,31,59,90,120,151,181,212,243,273,304,334 };
  5127.     char s[5];
  5128.     struct tm *time_stamp;
  5129.  
  5130. #ifdef BSD44
  5131.     struct timeval tp[2];
  5132. #else
  5133. #ifdef V7
  5134.     struct utimbuf {
  5135.       time_t timep[2];          /* New access and modificaton time */
  5136.     } tp;
  5137. #else
  5138. #ifdef SYSUTIMEH
  5139.     struct utimbuf tp;
  5140. #else
  5141.     struct utimbuf {
  5142.         time_t atime;
  5143.         time_t mtime;
  5144.     } tp;
  5145. #endif /* SYSUTIMEH */
  5146. #endif /* V7 */
  5147. #endif /* BSD44 */
  5148.  
  5149. #ifdef ANYBSD
  5150.     static struct timeb tbp;
  5151. #endif /* ANYBSD */
  5152.  
  5153.     char * date = gmtstring;
  5154.     int len;
  5155.  
  5156.     len = strlen(date);
  5157.     debug(F111,"zlocaltime",date,len);
  5158.  
  5159.     if ((len == 0)
  5160.         || (len != 17)
  5161.         || (date[8] != ' ')
  5162.         || (date[11] != ':')
  5163.         || (date[14] != ':') ) {
  5164.         debug(F111,"Bad creation date ",date,len);
  5165.         return(NULL);
  5166.     }
  5167.     debug(F111,"zlocaltime date check 1",date,len);
  5168.     for(i = 0; i < 8; i++) {
  5169.         if (!isdigit(date[i])) {
  5170.             debug(F111,"Bad creation date ",date,len);
  5171.             return(NULL);
  5172.         }
  5173.     }
  5174.     debug(F111,"zlocaltime date check 2",date,len);
  5175.     i++;
  5176.  
  5177.     for (; i < 16; i += 3) {
  5178.         if ((!isdigit(date[i])) || (!isdigit(date[i + 1]))) {
  5179.             debug(F111,"Bad creation date ",date,len);
  5180.         return(NULL);
  5181.         }
  5182.     }
  5183.     debug(F111,"zlocaltime date check 3",date,len);
  5184.  
  5185.     debug(F100,"zlocaltime so far so good","",0);
  5186.  
  5187.     s[4] = '\0';
  5188.     for (i = 0; i < 4; i++)             /* Fix the year */
  5189.       s[i] = date[i];
  5190.  
  5191.     n = atoi(s);
  5192.     debug(F111,"zlocaltime year",s,n);
  5193.     if (n < 1970) {
  5194.         debug(F100,"zlocaltime fails - year","",n);
  5195.         return(NULL);
  5196.     }
  5197.  
  5198. /*  Previous year's leap days.  This won't work after year 2100. */
  5199.  
  5200.     isleapyear = (( n % 4 == 0 && n % 100 !=0) || n % 400 == 0);
  5201.     days = (long) (n - 1970) * 365;
  5202.     days += (n - 1968 - 1) / 4 - (n - 1900 - 1) / 100 + (n - 1600 - 1) / 400;
  5203.  
  5204.     s[2] = '\0';
  5205.  
  5206.     for (i = 4; i < 16; i += 2) {
  5207.         s[0] = date[i];
  5208.         s[1] = date[i + 1];
  5209.         n = atoi(s);
  5210.         switch (i) {
  5211.           case 4:                       /* MM: month */
  5212.             if ((n < 1 ) || ( n > 12)) {
  5213.                 debug(F111,"zlocaltime 4 bad date ",date,len);
  5214.                 return(NULL);
  5215.             }
  5216.             days += monthdays [n];
  5217.             if (isleapyear && n > 2)
  5218.               ++days;
  5219.             continue;
  5220.  
  5221.           case 6:                       /* DD: day */
  5222.             if ((n < 1 ) || ( n > 31)) {
  5223.                 debug(F111,"zlocaltime 6 bad date ",date,len);
  5224.                 return(NULL);
  5225.             }
  5226.             tmx = (days + n - 1) * 24L * 60L * 60L;
  5227.             i++;                        /* Skip the space */
  5228.             continue;
  5229.  
  5230.           case 9:                       /* hh: hour */
  5231.             if ((n < 0 ) || ( n > 23)) {
  5232.                 debug(F111,"zlocaltime 9 bad date ",date,len);
  5233.                 return(NULL);
  5234.             }
  5235.             tmx += n * 60L * 60L;
  5236.             i++;                        /* Skip the colon */
  5237.             continue;
  5238.  
  5239.           case 12:                      /* mm: minute */
  5240.             if ((n < 0 ) || ( n > 59)) {
  5241.                 debug(F111,"zlocaltime 12 bad date ",date,len);
  5242.                 return(NULL);
  5243.             }
  5244.             tmx += n * 60L;
  5245.             i++;                        /* Skip the colon */
  5246.             continue;
  5247.  
  5248.           case 15:                      /* ss: second */
  5249.             if ((n < 0 ) || ( n > 59)) {
  5250.                 debug(F111,"zlocaltime 15 bad date ",date,len);
  5251.                 return(NULL);
  5252.             }
  5253.             tmx += n;
  5254.         }
  5255.  
  5256. /*
  5257.   At this point tmx is the time_t representation of the argument date-time
  5258.   string without any timezone or DST adjustments.  Therefore it should be
  5259.   the same as the time_t representation of the GMT/UTC time.  Now we should
  5260.   be able to feed it to localtime() and have it converted to a struct tm
  5261.   representing the local time equivalent of the given UTC time.
  5262. */
  5263.         time_stamp = localtime(&tmx);
  5264.         if (!time_stamp)
  5265.           return(NULL);
  5266.     }
  5267.  
  5268. /* Now we simply reformat the struct tm to a string */
  5269.  
  5270.     x = time_stamp->tm_year;
  5271.     if (time_stamp->tm_year < 70 || time_stamp->tm_year > 8099)
  5272.       return(NULL);
  5273.     if (time_stamp->tm_mon < 0 || time_stamp->tm_mon > 11)
  5274.       return(NULL);
  5275.     if (time_stamp->tm_mday < 1 || time_stamp->tm_mday > 31)
  5276.       return(NULL);
  5277.     if (time_stamp->tm_hour < 0 || time_stamp->tm_hour > 24)
  5278.       return(NULL);
  5279.     if (time_stamp->tm_min < 0 || time_stamp->tm_min > 60)
  5280.       return(NULL);
  5281.     if (time_stamp->tm_sec < 0 || time_stamp->tm_sec > 60)
  5282.       return(NULL);
  5283.     sprintf(zltimbuf,"%04d%02d%02d %02d:%02d:%02d",
  5284.         time_stamp->tm_year + 1900,
  5285.         time_stamp->tm_mon + 1,
  5286.         time_stamp->tm_mday,
  5287.         time_stamp->tm_hour,
  5288.         time_stamp->tm_min,
  5289.         time_stamp->tm_sec
  5290.         );
  5291.     return((char *)zltimbuf);
  5292. }
  5293. #endif /* ZLOCALTIME */
  5294. #endif /* NOTIMESTAMP */
  5295.  
  5296. /* Z S T I M E  --  Set modification date/time+permissions for incoming file */
  5297. /*
  5298.  Call with:
  5299.  f  = pointer to name of existing file.
  5300.  yy = pointer to a Kermit file attribute structure in which yy->date.val
  5301.       is a date of the form yyyymmdd hh:mm:ss, e.g. 19900208 13:00:00.
  5302.       yy->lprotect.val & yy->gprotect.val are permission/protection values.
  5303.  x  = is a function code: 0 means to set the file's attributes as given.
  5304.       1 means compare the date in struct yy with the file creation date.
  5305.  Returns:
  5306.  -1 on any kind of error.
  5307.   0 if x is 0 and the attributes were set successfully.
  5308.   0 if x is 1 and date from attribute structure <= file creation date.
  5309.   1 if x is 1 and date from attribute structure > file creation date.
  5310. */
  5311. int
  5312. zstime(f,yy,x)
  5313.     char *f; struct zattr *yy; int x;
  5314. /* zstime */ {
  5315.     int r = -1;                         /* Return code */
  5316. #ifdef CK_PERMS
  5317.     int setperms = 0;
  5318. #endif /* CK_PERMS */
  5319.     int setdate = 0;
  5320.  
  5321. /* It is ifdef'd TIMESTAMP because it might not work on V7. bk@kullmar.se.  */
  5322.  
  5323. #ifdef TIMESTAMP
  5324. #ifdef BSD44
  5325.     extern int utimes();
  5326. #else
  5327.     extern int utime();
  5328. #endif /* BSD44 */
  5329.  
  5330.     struct stat sb;
  5331.  
  5332. /* At least, the declarations for int functions are not needed anyway */
  5333.  
  5334. #ifdef BSD44
  5335.     struct timeval tp[2];
  5336.     long xtimezone;
  5337. #else
  5338. #ifdef V7
  5339.     struct utimbuf {
  5340.     time_t timep[2];        /* New access and modificaton time */
  5341.     } tp;
  5342.     char *tz;
  5343.     long timezone;                      /* In case not defined in .h file */
  5344. #else
  5345. #ifdef SYSUTIMEH
  5346.     struct utimbuf tp;
  5347. #else
  5348.     struct utimbuf {
  5349.         time_t atime;
  5350.         time_t mtime;
  5351.     } tp;
  5352. #endif /* SYSUTIMEH */
  5353. #endif /* V7 */
  5354. #endif /* BSD44 */
  5355.  
  5356.     long tm = 0L;
  5357.  
  5358.     if (!f) f = "";
  5359.     if (!*f) return(-1);
  5360.     if (!yy) return(-1);
  5361.  
  5362. #ifdef CKROOT
  5363.     debug(F111,"zstime setroot",ckroot,ckrootset);
  5364.     if (ckrootset) if (!zinroot(f)) {
  5365.     debug(F110,"zstime setroot violation",f,0);
  5366.     return(0);
  5367.     }
  5368. #endif /* CKROOT */
  5369.  
  5370.     if (yy->date.len == 0) {            /* No date in struct */
  5371.         if (yy->lprotect.len != 0) {    /* So go do permissions */
  5372.             goto zsperms;
  5373.         } else {
  5374.             debug(F100,"zstime: nothing to do","",0);
  5375.             return(0);
  5376.         }
  5377.     }
  5378.     if ((tm = zstrdt(yy->date.val,yy->date.len)) < 0) {
  5379.         debug(F101,"zstime: zstrdt fails","",0);
  5380.         return(-1);
  5381.     }
  5382.     debug(F101,"zstime: tm","",tm);
  5383.     debug(F111,"zstime: A-pkt date ok ",yy->date.val,yy->date.len);
  5384.  
  5385.     if (stat(f,&sb)) {                  /* Get the time for the file */
  5386.     debug(F101,"STAT","",14);
  5387.         debug(F111,"zstime: Can't stat file:",f,errno);
  5388.         return(-1);
  5389.     }
  5390.     debug(F101,"STAT","",15);
  5391.     setdate = 1;
  5392.  
  5393.   zsperms:
  5394. #ifdef CK_PERMS
  5395.     {
  5396.         int i, x = 0, xx, flag = 0;
  5397.         char * s;
  5398. #ifdef DEBUG
  5399.         char obuf[24];
  5400.         if (deblog) {
  5401.             debug(F111,"zstime lperms",yy->lprotect.val,yy->lprotect.len);
  5402.             debug(F111,"zstime gperms",yy->gprotect.val,yy->gprotect.len);
  5403.             debug(F110,"zstime system id",yy->systemid.val,0);
  5404.             sprintf(obuf,"%o",sb.st_mode);
  5405.             debug(F110,"zstime file perms before",obuf,0);
  5406.         }
  5407. #endif /* DEBUG */
  5408.  
  5409. #ifdef CK_LOGIN
  5410.         debug(F101,"zstime isguest","",isguest);
  5411.         debug(F101,"zstime ckxperms","",ckxperms);
  5412.         if (isguest) {
  5413. #ifdef COMMENT
  5414.             /* Clear owner permissions */
  5415.             sb.st_mode &= (unsigned) 0177077; /* (16 bits) */
  5416. #else
  5417.             /* Set permissions from ckxperms variable */
  5418.             sb.st_mode = ckxperms;
  5419. #endif /* COMMENT */
  5420.             debug(F101,"zstime isguest sb.st_mode","",sb.st_mode);
  5421. #ifdef COMMENT
  5422.             /* We already set them in zopeno() */
  5423.             setperms = 1;
  5424. #endif /* COMMENT */
  5425.             flag = 0;
  5426.         } else
  5427. #endif /* CK_LOGIN */
  5428.           if ((yy->lprotect.len > 0 &&  /* Have local-format permissions */
  5429.             yy->systemid.len > 0 &&     /* from A-packet... */
  5430. #ifdef UNIX
  5431.             !strcmp(yy->systemid.val,"U1") /* AND you are same as me */
  5432. #else
  5433.             0
  5434. #endif /* UNIX */
  5435.              ) || (yy->lprotect.len < 0) /* OR by inheritance from old file */
  5436.             ) {
  5437.             flag = 1;
  5438.             s = yy->lprotect.val;       /* UNIX filemode */
  5439.             xx = yy->lprotect.len;
  5440.             if (xx < 0)                 /* len < 0 means inheritance */
  5441.               xx = 0 - xx;
  5442.             for (i = 0; i < xx; i++) {  /* Decode octal string */
  5443.                 if (*s <= '7' && *s >= '0') {
  5444.                     x = 8 * x + (int)(*s) - '0';
  5445.                 } else {
  5446.                     flag = 0;
  5447.                     break;
  5448.                 }
  5449.                 s++;
  5450.             }
  5451. #ifdef DEBUG
  5452.             sprintf(obuf,"%o",x);
  5453.             debug(F110,"zstime octal lperm",obuf,0);
  5454. #endif /* DEBUG */
  5455.         } else if (!flag && yy->gprotect.len > 0) {
  5456.             int g;
  5457. #ifdef CK_SCO32V4
  5458.             mode_t mask;
  5459. #else
  5460.             int mask;
  5461. #endif /* CK_SCO32V4 */
  5462.             mask = umask(0);            /* Get umask */
  5463.             debug(F101,"zstime mask 1","",mask);
  5464.             umask(mask);                /* Put it back */
  5465.             mask ^= 0777;               /* Flip the bits */
  5466.             debug(F101,"zstime mask 2","",mask);
  5467.             g = xunchar(*(yy->gprotect.val)); /* Decode generic protection */
  5468.             debug(F101,"zstime gprotect","",g);
  5469. #ifdef S_IRUSR
  5470.             debug(F100,"zstime S_IRUSR","",0);
  5471.             if (g & 1) x |= S_IRUSR;    /* Read permission */
  5472.             flag = 1;
  5473. #endif /* S_IRUSR */
  5474. #ifdef S_IWUSR
  5475.             debug(F100,"zstime S_IWUSR","",0);
  5476.             if (g & 2) x |= S_IWUSR;    /* Write permission */
  5477.             if (g & 16) x |= S_IWUSR;   /* Delete permission */
  5478.             flag = 1;
  5479. #endif /* S_IWUSR */
  5480. #ifdef S_IXUSR
  5481.             debug(F100,"zstime S_IXUSR","",0);
  5482.             if (g & 4)                  /* Has execute permission bit */
  5483.               x |= S_IXUSR;
  5484.             else                        /* Doesn't have it */
  5485.               mask &= 0666;             /* so also clear it out of mask */
  5486.             flag = 1;
  5487. #endif /* S_IXUSR */
  5488.             debug(F101,"zstime mask x","",x);
  5489.             x |= mask;
  5490.             debug(F101,"zstime mask x|mask","",x);
  5491.         }
  5492.         debug(F101,"zstime flag","",flag);
  5493.         if (flag) {
  5494. #ifdef S_IFMT
  5495.             debug(F101,"zstime S_IFMT x","",x);
  5496.             sb.st_mode = (sb.st_mode & S_IFMT) | x;
  5497.             setperms = 1;
  5498. #else
  5499. #ifdef _IFMT
  5500.             debug(F101,"zstime _IFMT x","",x);
  5501.             sb.st_mode = (sb.st_mode & _IFMT) | x;
  5502.             setperms = 1;
  5503. #endif /* _IFMT */
  5504. #endif /* S_IFMT */
  5505.         }
  5506. #ifdef DEBUG
  5507.         sprintf(obuf,"%04o",sb.st_mode);
  5508.         debug(F111,"zstime file perms after",obuf,setperms);
  5509. #endif /* DEBUG */
  5510.     }
  5511. #endif /* CK_PERMS */
  5512.  
  5513.     debug(F101,"zstime: sb.st_atime","",sb.st_atime);
  5514.  
  5515. #ifdef BSD44
  5516.     tp[0].tv_sec = sb.st_atime;         /* Access time first */
  5517.     tp[1].tv_sec = tm;                  /* Update time second */
  5518.     debug(F100,"zstime: BSD44 modtime","",0);
  5519. #else
  5520. #ifdef V7
  5521.     tp.timep[0] = tm;                   /* Set modif. time to creation date */
  5522.     tp.timep[1] = sb.st_atime;          /* Don't change the access time */
  5523.     debug(F100,"zstime: V7 modtime","",0);
  5524. #else
  5525. #ifdef SYSUTIMEH
  5526.     tp.modtime = tm;                    /* Set modif. time to creation date */
  5527.     tp.actime = sb.st_atime;            /* Don't change the access time */
  5528.     debug(F100,"zstime: SYSUTIMEH modtime","",0);
  5529. #else
  5530.     tp.mtime = tm;                      /* Set modif. time to creation date */
  5531.     tp.atime = sb.st_atime;             /* Don't change the access time */
  5532.     debug(F100,"zstime: default modtime","",0);
  5533. #endif /* SYSUTIMEH */
  5534. #endif /* V7 */
  5535. #endif /* BSD44 */
  5536.  
  5537.     switch (x) {                        /* Execute desired function */
  5538.       case 0:                           /* Set the creation date of the file */
  5539. #ifdef CK_PERMS                         /* And permissions */
  5540. /*
  5541.   NOTE: If we are inheriting permissions from a previous file, and the
  5542.   previous file was a directory, this would turn the new file into a directory
  5543.   too, but it's not, so we try to unset the right bit.  Luckily, this code
  5544.   will probably never be executed since the upper level modules do not allow
  5545.   reception of a file that has the same name as a directory.
  5546.  
  5547.   NOTE 2: We change the permissions *before* we change the modification time,
  5548.   otherwise changing the permissions would set the mod time to the present
  5549.   time.
  5550. */
  5551.         {
  5552.             int x;
  5553.             debug(F101,"zstime setperms","",setperms);
  5554.             if (S_ISDIR(sb.st_mode)) {
  5555.                 debug(F101,"zstime DIRECTORY bit on","",sb.st_mode);
  5556.                 sb.st_mode ^= 0040000;
  5557.                 debug(F101,"zstime DIRECTORY bit off","",sb.st_mode);
  5558.             }
  5559.             if (setperms) {
  5560.                 x = chmod(f,sb.st_mode);
  5561.                 debug(F101,"zstime chmod","",x);
  5562.             }
  5563.         }
  5564.         if (x < 0) return(-1);
  5565. #endif /* CK_PERMS */
  5566.  
  5567.         if (!setdate)                   /* We don't have a date */
  5568.           return(0);                    /* so skip the following... */
  5569.  
  5570.         if (
  5571. #ifdef BSD44
  5572.             utimes(f,tp)
  5573. #else
  5574.             utime(f,&tp)
  5575. #endif /* BSD44 */
  5576.             ) {                         /* Fix modification time */
  5577.             debug(F111,"zstime 0: can't set modtime for file",f,errno);
  5578.             r = -1;
  5579.         } else  {
  5580.         /* Including the modtime here is not portable */
  5581.             debug(F110,"zstime 0: modtime set for file",f,0);
  5582.             r = 0;
  5583.         }
  5584.         break;
  5585.  
  5586.       case 1:                           /* Compare the dates */
  5587. /*
  5588.   This was st_atime, which was wrong.  We want the file-data modification
  5589.   time, st_mtime.
  5590. */
  5591.         debug(F111,"zstime 1: compare",f,sb.st_mtime);
  5592.         debug(F111,"zstime 1: compare","packet",tm);
  5593.  
  5594.         r = (sb.st_mtime < tm) ? 0 : 1;
  5595.         break;
  5596.  
  5597.       default:                          /* Error */
  5598.         r = -1;
  5599.     }
  5600. #endif /* TIMESTAMP */
  5601.     return(r);
  5602. }
  5603.  
  5604. /* Find initialization file. */
  5605.  
  5606. #ifdef NOTUSED
  5607. int
  5608. zkermini() {
  5609. /*  nothing here for Unix.  This function added for benefit of VMS Kermit.  */
  5610.     return(0);
  5611. }
  5612. #endif /* NOTUSED */
  5613.  
  5614. #ifndef UNIX
  5615. /* Historical -- not used in Unix any more (2001-11-03) */
  5616. #ifndef NOFRILLS
  5617. int
  5618. zmail(p,f) char *p; char *f; {          /* Send file f as mail to address p */
  5619. /*
  5620.   Returns 0 on success
  5621.    2 if mail delivered but temp file can't be deleted
  5622.   -2 if mail can't be delivered
  5623.   -1 on file access error
  5624.   The UNIX version always returns 0 because it can't get a good return
  5625.   code from zsyscmd.
  5626. */
  5627.     int n;
  5628.  
  5629. #ifdef CK_LOGIN
  5630.     if (isguest)
  5631.       return(-2);
  5632. #endif /* CK_LOGIN */
  5633.  
  5634.     if (!f) f = "";
  5635.     if (!*f) return(-1);
  5636.  
  5637. #ifdef CKROOT
  5638.     debug(F111,"zmail setroot",ckroot,ckrootset);
  5639.     if (ckrootset) if (!zinroot(f)) {
  5640.     debug(F110,"zmail setroot violation",f,0);
  5641.     return(-1);
  5642.     }
  5643. #endif /* CKROOT */
  5644.  
  5645. #ifdef BSD4
  5646. /* The idea is to use /usr/ucb/mail, rather than regular mail, so that   */
  5647. /* a subject line can be included with -s.  Since we can't depend on the */
  5648. /* user's path, we use the convention that /usr/ucb/Mail = /usr/ucb/mail */
  5649. /* and even if Mail has been moved to somewhere else, this should still  */
  5650. /* find it...  The search could be made more reliable by actually using  */
  5651. /* access() to see if /usr/ucb/Mail exists. */
  5652.  
  5653.     n = strlen(f);
  5654.     n = n + n + 15 + (int)strlen(p);
  5655.  
  5656.     if (n > ZMBUFLEN)
  5657.       return(-2);
  5658.  
  5659. #ifdef DGUX540
  5660.     sprintf(zmbuf,"mailx -s %c%s%c %s < %s", '"', f, '"', p, f);
  5661. #else
  5662.     sprintf(zmbuf,"Mail -s %c%s%c %s < %s", '"', f, '"', p, f);
  5663. #endif /* DGUX540 */
  5664.     zsyscmd(zmbuf);
  5665. #else
  5666. #ifdef SVORPOSIX
  5667. #ifndef OXOS
  5668.     sprintf(zmbuf,"mail %s < %s", p, f);
  5669. #else /* OXOS */
  5670.     sprintf(zmbuf,"mailx -s %c%s%c %s < %s", '"', f, '"', p, f);
  5671. #endif /* OXOS */
  5672.     zsyscmd(zmbuf);
  5673. #else
  5674.     *zmbuf = '\0';
  5675. #endif
  5676. #endif
  5677.     return(0);
  5678. }
  5679. #endif /* NOFRILLS */
  5680. #endif /* UNIX */
  5681.  
  5682. #ifndef NOFRILLS
  5683. int
  5684. zprint(p,f) char *p; char *f; {         /* Print file f with options p */
  5685.     extern char * printername;          /* From ckuus3.c */
  5686.     extern int printpipe;
  5687.     int n;
  5688.  
  5689. #ifdef CK_LOGIN
  5690.     if (isguest)
  5691.       return(-2);
  5692. #endif /* CK_LOGIN */
  5693.  
  5694.     if (!f) f = "";
  5695.     if (!*f) return(-1);
  5696.  
  5697. #ifdef CKROOT
  5698.     debug(F111,"zprint setroot",ckroot,ckrootset);
  5699.     if (ckrootset) if (!zinroot(f)) {
  5700.     debug(F110,"zprint setroot violation",f,0);
  5701.     return(-1);
  5702.     }
  5703. #endif /* CKROOT */
  5704.  
  5705.     debug(F110,"zprint file",f,0);
  5706.     debug(F110,"zprint flags",p,0);
  5707.     debug(F110,"zprint printername",printername,0);
  5708.     debug(F101,"zprint printpipe","",printpipe);
  5709.  
  5710. #ifdef UNIX
  5711. /*
  5712.   Note use of standard input redirection.  In some systems, lp[r] runs
  5713.   setuid to lp (or ...?), so if user has sent a file into a directory
  5714.   that lp does not have read access to, it can't be printed unless it is
  5715.   fed to lp[r] as standard input.
  5716. */
  5717.     if (printpipe && printername) {
  5718.     n = 8 + (int)strlen(f) + (int)strlen(printername);
  5719.     if (n > ZMBUFLEN)
  5720.       return(-2);
  5721.         sprintf(zmbuf,"cat %s | %s", f, printername);
  5722.     } else if (printername) {
  5723.     n = 8 + (int)strlen(f) + (int)strlen(printername);
  5724.     if (n > ZMBUFLEN)
  5725.       return(-2);
  5726.         sprintf(zmbuf,"cat %s >> %s", f, printername);
  5727.     } else {
  5728.     n = 4 + (int)strlen(PRINTCMD) + (int)strlen(p) + (int)strlen(f);
  5729.     if (n > ZMBUFLEN)
  5730.       return(-2);
  5731.         sprintf(zmbuf,"%s %s < %s", PRINTCMD, p, f);
  5732.     }
  5733.     debug(F110,"zprint command",zmbuf,0);
  5734.     zsyscmd(zmbuf);
  5735. #else /* Not UNIX */
  5736.     *zmbuf = '\0';
  5737. #endif /* UNIX */
  5738.     return(0);
  5739. }
  5740. #endif /* NOFRILLS */
  5741.  
  5742. /*  Wildcard expansion functions...  */
  5743.  
  5744. static char scratch[MAXPATH+4];         /* Used by both methods */
  5745.  
  5746. static int oldmtchs = 0;                /* Let shell (ls) expand them. */
  5747. #ifdef COMMENT
  5748. static char *lscmd = "/bin/ls -d";      /* Command to use. */
  5749. #else
  5750. static char *lscmd = "echo";            /* Command to use. */
  5751. #endif /* COMMENT */
  5752.  
  5753. #ifndef NOPUSH
  5754. int
  5755. shxpand(pat,namlst,len) char *pat, *namlst[]; int len; {
  5756.     char *fgbuf = NULL;                 /* Buffer for forming ls command */
  5757.     char *p, *q;                        /* Workers */
  5758.  
  5759.     int i, x, retcode, itsadir;
  5760.     char c;
  5761.  
  5762.     x = (int)strlen(pat) + (int)strlen(lscmd) + 3; /* Length of ls command */
  5763.     for (i = 0; i < oldmtchs; i++) {    /* Free previous file list */
  5764.         if (namlst[i] ) {               /* If memory is allocated  */
  5765.             free(namlst[i]);            /* Free the memory         */
  5766.             namlst[i] = NULL ;          /* Remember no memory is allocated */
  5767.         }
  5768.     }
  5769.     oldmtchs = 0 ;                      /* Remember there are no matches */
  5770.     fgbuf = malloc(x);                  /* Get buffer for command */
  5771.     if (!fgbuf) return(-1);             /* Fail if cannot */
  5772.     ckmakmsg(fgbuf,x,lscmd," ",pat,NULL); /* Form the command */
  5773.     zxcmd(ZIFILE,fgbuf);                /* Start the command */
  5774.     i = 0;                              /* File counter */
  5775.     p = scratch;                        /* Point to scratch area */
  5776.     retcode = -1;                       /* Assume failure */
  5777.     while ((x = zminchar()) != -1) {    /* Read characters from command */
  5778.         c = (char) x;
  5779.         if (c == ' ' || c == '\n') {    /* Got newline or space? */
  5780.             *p = '\0';                  /* Yes, terminate string */
  5781.             p = scratch;                /* Point back to beginning */
  5782.             if (zchki(p) == -1)         /* Does file exist? */
  5783.               continue;                 /* No, continue */
  5784.             itsadir = isdir(p);         /* Yes, is it a directory? */
  5785.             if (xdironly && !itsadir)   /* Want only dirs but this isn't */
  5786.               continue;                 /* so skip. */
  5787.             if (xfilonly && itsadir)    /* It's a dir but want only files */
  5788.               continue;                 /* so skip. */
  5789.             x = (int)strlen(p);         /* Keep - get length of name */
  5790.             q = malloc(x+1);            /* Allocate space for it */
  5791.             if (!q) goto shxfin;        /* Fail if space can't be obtained */
  5792.             strcpy(q,scratch);          /* (safe) Copy name to space */
  5793.             namlst[i++] = q;            /* Copy pointer to name into array */
  5794.             if (i >= len) goto shxfin;  /* Fail if too many */
  5795.         } else {                        /* Regular character */
  5796.             *p++ = c;                   /* Copy it into scratch area */
  5797.         }
  5798.     }
  5799.     retcode = i;                        /* Return number of matching files */
  5800. shxfin:                                 /* Common exit point */
  5801.     free(fgbuf);                        /* Free command buffer */
  5802.     fgbuf = NULL;
  5803.     zclosf(ZIFILE);                     /* Delete the command fork. */
  5804.     oldmtchs = i;                       /* Remember how many files */
  5805.     return(retcode);
  5806. }
  5807. #endif /* NOPUSH */
  5808.  
  5809. /*
  5810.   Directory-reading functions for UNIX originally written for C-Kermit 4.0
  5811.   by Jeff Damens, CUCCA, 1984.
  5812. */
  5813. static char * xpat = NULL;              /* Global copy of fgen() pattern */
  5814. static char * xpatlast = NULL;          /* Rightmost segment of pattern*/
  5815. static int xpatslash = 0;               /* Slash count in pattern */
  5816. static int xpatwild = 0;                /* Original pattern is wild */
  5817. static int xleafwild = 0;               /* Last segment of pattern is wild */
  5818. static int xpatabsolute = 0;
  5819.  
  5820. #ifdef aegis
  5821. static char bslash;
  5822. #endif /* aegis */
  5823.  
  5824.  
  5825. /*  S P L I T P A T H  */
  5826.  
  5827. /*
  5828.   Splits the slash-separated portions of the argument string into
  5829.   a list of path structures.  Returns the head of the list.  The
  5830.   structures are allocated by malloc, so they must be freed.
  5831.   Splitpath is used internally by the filename generator.
  5832.  
  5833.   Input:
  5834.     A path string.
  5835.  
  5836.   Returns:
  5837.     A linked list of the slash-separated segments of the input.
  5838. */
  5839. static struct path *
  5840. splitpath(p) char *p; {
  5841.     struct path *head,*cur,*prv;
  5842.     int i;
  5843.  
  5844.     debug(F111,"splitpath",p,xrecursive);
  5845.     head = prv = NULL;
  5846.  
  5847.     if (!p) return(NULL);
  5848.     if (!*p) return(NULL);
  5849.  
  5850.     if (!strcmp(p,"**")) {              /* Fix this */
  5851.         p = "*";
  5852.     }
  5853.     if (ISDIRSEP(*p)) p++;              /* Skip leading slash if any */
  5854.  
  5855.     /* Make linked list of path segments from pattern */
  5856.  
  5857.     while (*p) {
  5858.         cur = (struct path *) malloc(sizeof (struct path));
  5859.         /* debug(F101,"splitpath malloc","",cur); */
  5860.         if (cur == NULL) {
  5861.             debug(F100,"splitpath malloc failure","",0);
  5862.             prv -> fwd = NULL;
  5863.             return((struct path *)NULL);
  5864.         }
  5865.         cur -> fwd = NULL;
  5866.         if (head == NULL)               /* First, make list head */
  5867.           head = cur;
  5868.         else                            /* Not first, link into chain */
  5869.           prv -> fwd = cur;
  5870.         prv = cur;                      /* Link from previous to this one */
  5871.  
  5872. #ifdef aegis
  5873.         /* treat backslash as "../" */
  5874.         if (bslash && *p == bslash) {
  5875.             strcpy(cur->npart, "..");    /* safe */
  5876.             ++p;
  5877.         } else {
  5878.             for (i=0; i < MAXNAMLEN && *p && *p != '/' && *p != bslash; i++)
  5879.               cur -> npart[i] = *p++;
  5880.             cur -> npart[i] = '\0';     /* end this segment */
  5881.             if (i >= MAXNAMLEN)
  5882.               while (*p && *p != '/' && *p != bslash)
  5883.                 p++;
  5884.         }
  5885.         if (*p == '/') p++;
  5886. #else
  5887.         /* General case (UNIX) */
  5888.         for (i = 0; i < MAXNAMLEN && !ISDIRSEP(*p) && *p != '\0'; i++) {
  5889.             cur -> npart[i] = *p++;
  5890.         }
  5891.  
  5892.         cur -> npart[i] = '\0';         /* End this path segment */
  5893.         if (i >= MAXNAMLEN)
  5894.           while (!ISDIRSEP(*p) && *p != '\0') p++;
  5895.         if (ISDIRSEP(*p))
  5896.           p++;
  5897.  
  5898. #endif /* aegis */
  5899.     }
  5900.     if (prv) {
  5901.         makestr(&xpatlast,prv -> npart);
  5902.         debug(F110,"splitpath xpatlast",xpatlast,0);
  5903.     }
  5904. #ifdef DEBUG
  5905.     /* Show original path list */
  5906.     if (deblog) {
  5907.         for (i = 0, cur = head; cur; i++) {
  5908.             debug(F111,"SPLITPATH",cur -> npart, i);
  5909.             cur = cur -> fwd;
  5910.         }
  5911.     }
  5912. #endif /* DEBUG */
  5913.     return(head);
  5914. }
  5915.  
  5916. /*  F G E N  --  Generate File List  */
  5917.  
  5918. /*
  5919.   File name generator.  It is passed a string, possibly containing wildcards,
  5920.   and an array of character pointers.  It finds all the matching filenames and
  5921.   stores pointers to them in the array.  The returned strings are allocated
  5922.   from a static buffer local to this module (so the caller doesn't have to
  5923.   worry about deallocating them); this means that successive calls to fgen
  5924.   will wipe out the results of previous calls.
  5925.  
  5926.   Input:
  5927.     A wildcard string, an array to write names to, the length of the array.
  5928.  
  5929.   Returns:
  5930.     The number of matches.
  5931.     The array is filled with filenames that matched the pattern.
  5932.     If there wasn't enough room in the array, -1 is returned.
  5933.  
  5934.   Originally by: Jeff Damens, CUCCA, 1984.  Many changes since then.
  5935. */
  5936. static int
  5937. fgen(pat,resarry,len) char *pat,*resarry[]; int len; {
  5938.     struct path *head;
  5939.     char *sptr, *s;
  5940.     int n;
  5941.  
  5942. #ifdef aegis
  5943.     char *namechars;
  5944.     int tilde = 0, bquote = 0;
  5945.  
  5946.     if ((namechars = getenv("NAMECHARS")) != NULL) {
  5947.         if (ckstrchr(namechars, '~' ) != NULL) tilde  = '~';
  5948.         if (ckstrchr(namechars, '\\') != NULL) bslash = '\\';
  5949.         if (ckstrchr(namechars, '`' ) != NULL) bquote = '`';
  5950.     } else {
  5951.         tilde = '~'; bslash = '\\'; bquote = '`';
  5952.     }
  5953.     sptr = scratch;
  5954.  
  5955.     /* copy "`node_data", etc. anchors */
  5956.     if (bquote && *pat == bquote)
  5957.       while (*pat && *pat != '/' && *pat != bslash)
  5958.         *sptr++ = *pat++;
  5959.     else if (tilde && *pat == tilde)
  5960.       *sptr++ = *pat++;
  5961.     while (*pat == '/')
  5962.       *sptr++ = *pat++;
  5963.     if (sptr == scratch) {
  5964.         strcpy(scratch,"./");        /* safe */
  5965.         sptr = scratch+2;
  5966.     }
  5967.     if (!(head = splitpath(pat))) return(-1);
  5968.  
  5969. #else /* not aegis */
  5970.  
  5971.     debug(F111,"fgen pat",pat,len);
  5972.     debug(F110,"fgen current directory",zgtdir(),0);
  5973.     debug(F101,"fgen stathack","",stathack);
  5974.  
  5975.     scratch[0] = '\0';
  5976.     xpatwild = 0;
  5977.     xleafwild = 0;
  5978.     xpatabsolute = 0;
  5979.  
  5980.     if (!(head = splitpath(pat)))       /* Make the path segment list */
  5981.     return(-1);
  5982.  
  5983.     sptr = scratch;
  5984.  
  5985. #ifdef COMMENT
  5986.     if (strncmp(pat,"./",2) && strncmp(pat,"../",3)) {
  5987. #endif /* COMMENT */
  5988.     if (!ISDIRSEP(*pat))        /* If name is not absolute */
  5989.       *sptr++ = '.';        /* put "./" in front. */
  5990.     *sptr++ = DIRSEP;
  5991. #ifdef COMMENT
  5992.     }
  5993. #endif /* COMMENT */
  5994.     *sptr = '\0';
  5995. #endif /* aegis */
  5996.  
  5997.     makestr(&xpat,pat);                 /* Save copy of original pattern */
  5998.     debug(F110,"fgen scratch",scratch,0);
  5999.  
  6000.     for (n = 0, s = xpat; *s; s++)      /* How many slashes in the pattern */
  6001.       if (*s == DIRSEP)                 /* since these are fences for */
  6002.         n++;                            /* pattern matching */
  6003.     xpatslash = n;
  6004.     debug(F101,"fgen xpatslash","",xpatslash);
  6005.  
  6006.     numfnd = 0;                         /* None found yet */
  6007.  
  6008.     if (initspace(resarry,ssplen) < 0)
  6009.       return(-1);
  6010.  
  6011.     xpatwild = iswild(xpat);        /* Original pattern is wild? */
  6012.     xpatabsolute = isabsolute(xpat);
  6013.     xleafwild = iswild(xpatlast);
  6014.  
  6015.     debug(F111,"fgen xpat",xpat,xpatwild);
  6016.     debug(F111,"fgen xpatlast",xpatlast,xleafwild);
  6017.     debug(F101,"fgen xpatabsolute","",xpatabsolute);
  6018.  
  6019.     traverse(head,scratch,sptr);        /* Go walk the directory tree. */
  6020.     while (head != NULL) {              /* Done - free path segment list. */
  6021.         struct path *next = head -> fwd;
  6022.         free((char *)head);
  6023.         head = next;
  6024.     }
  6025.     debug(F101,"fgen","",numfnd);
  6026.     return(numfnd);                     /* Return the number of matches */
  6027. }
  6028.  
  6029. /* Define LONGFN (long file names) automatically for BSD 2.9 and 4.2 */
  6030. /* LONGFN can also be defined on the cc command line. */
  6031.  
  6032. #ifdef BSD29
  6033. #ifndef LONGFN
  6034. #define LONGFN
  6035. #endif
  6036. #endif
  6037.  
  6038. #ifdef BSD42
  6039. #ifndef LONGFN
  6040. #define LONGFN
  6041. #endif
  6042. #endif
  6043.  
  6044. /*
  6045.    T R A V E R S E  --  Traverse a directory tree.
  6046.  
  6047.    Walks the directory tree looking for matches to its arguments.
  6048.    The algorithm is, briefly:
  6049.  
  6050.     If the current pattern segment contains no wildcards, that
  6051.     segment is added to what we already have.  If the name so far
  6052.     exists, we call ourselves recursively with the next segment
  6053.     in the pattern string; otherwise, we just return.
  6054.  
  6055.     If the current pattern segment contains wildcards, we open the name
  6056.     we've accumulated so far (assuming it is really a directory), then read
  6057.     each filename in it, and, if it matches the wildcard pattern segment, add
  6058.     that filename to what we have so far and call ourselves recursively on
  6059.     the next segment.
  6060.  
  6061.     Finally, when no more pattern segments remain, we add what's accumulated
  6062.     so far to the result array and increment the number of matches.
  6063.  
  6064.   Inputs:
  6065.     A pattern path list (as generated by splitpath), a string pointer that
  6066.     points to what we've traversed so far (this can be initialized to "/"
  6067.     to start the search at the root directory, or to "./" to start the
  6068.     search at the current directory), and a string pointer to the end of
  6069.     the string in the previous argument, plus the global "recursive",
  6070.     "xmatchdot", and "xdironly" flags.
  6071.  
  6072.   Returns: void, with:
  6073.     mtchs[] containing the array of filename string pointers, and:
  6074.     numfnd containing the number of filenames.
  6075.  
  6076.   Although it might be poor practice, the mtchs[] array is revealed to the
  6077.   outside in case it needs it; for example, to be sorted prior to use.
  6078.   (It is poor practice because not all platforms implement file lists the
  6079.   same way; some don't use an array at all.)
  6080.  
  6081.   Note that addresult() acts as a second-level filter; due to selection
  6082.   criteria outside of the pattern, it might decline to add files that
  6083.   this routine asks it to, e.g. because we are collecting only directory
  6084.   names but not the names of regular files.
  6085.  
  6086.   WARNING: In the course of C-Kermit 7.0 development, this routine became
  6087.   ridiculously complex, in order to meet approximately sixty specific
  6088.   requirements.  DON'T EVEN THINK ABOUT MODIFYING THIS ROUTINE!  Trust me;
  6089.   it is not possible to fix anything in it without breaking something else.
  6090.   This routine badly needs a total redesign and rewrite.  Note: There may
  6091.   be some good applications for realpath() and/or scandir() and/or fts_blah()
  6092.   here, on platforms where they are available.
  6093. */
  6094. static VOID
  6095. traverse(pl,sofar,endcur) struct path *pl; char *sofar, *endcur; {
  6096.  
  6097. /* Appropriate declarations for directory routines and structures */
  6098. /* #define OPENDIR means to use opendir(), readdir(), closedir()  */
  6099. /* If OPENDIR not defined, we use open(), read(), close() */
  6100.  
  6101. #ifdef DIRENT                           /* New way, <dirent.h> */
  6102. #define OPENDIR
  6103.     DIR *fd, *opendir();
  6104.     struct dirent *dirbuf;
  6105.     struct dirent *readdir();
  6106. #else /* !DIRENT */
  6107. #ifdef LONGFN                           /* Old way, <dir.h> with opendir() */
  6108. #define OPENDIR
  6109.     DIR *fd, *opendir();
  6110.     struct direct *dirbuf;
  6111. #else /* !LONGFN */
  6112.     int fd;                             /* Old way, <dir.h> with open() */
  6113.     struct direct dir_entry;
  6114.     struct direct *dirbuf = &dir_entry;
  6115. #endif /* LONGFN */
  6116. #endif /* DIRENT */
  6117.     int mopts = 0;            /* ckmatch() opts */
  6118.     int depth = 0;            /* Directory tree depth */
  6119.  
  6120.     char nambuf[MAXNAMLEN+4];           /* Buffer for a filename */
  6121.     int itsadir = 0, segisdir = 0, itswild = 0, mresult, n, x /* , y */ ;
  6122.     struct stat statbuf;                /* For file info. */
  6123.  
  6124.     debug(F101,"STAT","",16);
  6125.     if (pl == NULL) {                   /* End of path-segment list */
  6126.         *--endcur = '\0'; /* Terminate string, overwrite trailing slash */
  6127.         debug(F110,"traverse add: end of path segment",sofar,0);
  6128.         addresult(sofar,-1);
  6129.         return;
  6130.     }
  6131.     if (stathack) {
  6132.     /* This speeds up the search a lot and we still get good results */
  6133.     /* but it breaks the tagging of directory names done in addresult */
  6134.     if (xrecursive || xfilonly || xdironly || xpatslash) {
  6135.         itsadir = xisdir(sofar);
  6136.         debug(F101,"STAT","",17);
  6137.     } else
  6138.       itsadir = (strncmp(sofar,"./",2) == 0);
  6139.     } else {
  6140.     itsadir = xisdir(sofar);
  6141.     debug(F101,"STAT","",18);
  6142.     }
  6143.     debug(F111,"traverse entry sofar",sofar,itsadir);
  6144.  
  6145. #ifdef CKSYMLINK                        /* We're doing symlinks? */
  6146. #ifdef USE_LSTAT                        /* OK to use lstat()? */
  6147.     if (itsadir && xnolinks) {        /* If not following symlinks */
  6148.     int x;
  6149.     struct stat buf;
  6150.     x = lstat(sofar,&buf);
  6151.     debug(F111,"traverse lstat 1",sofar,x);
  6152.     if (x > -1 &&
  6153. #ifdef S_ISLNK
  6154.         S_ISLNK(buf.st_mode)
  6155. #else
  6156. #ifdef _IFLNK
  6157.         ((_IFMT & buf.st_mode) == _IFLNK)
  6158. #endif /* _IFLNK */
  6159. #endif /* S_ISLNK */
  6160.         )
  6161.       itsadir = 0;
  6162.     }
  6163. #endif /* USE_LSTAT */
  6164. #endif /* CKSYMLINK */
  6165.  
  6166.     if (!xmatchdot && xpatlast[0] == '.')
  6167.       xmatchdot = 1;
  6168.     if (!xmatchdot && xpat[0] == '.' && xpat[1] != '/' && xpat[1] != '.')
  6169.       xmatchdot = 1;
  6170.  
  6171.     /* ckmatch() options */
  6172.  
  6173.     if (xmatchdot)   mopts |= 1;    /* Match dot */
  6174.     if (!xrecursive) mopts |= 2;    /* Dirsep is fence */
  6175.  
  6176.     debug(F111,"traverse entry xpat",xpat,xpatslash);
  6177.     debug(F111,"traverse entry xpatlast",xpatlast,xmatchdot);
  6178.     debug(F110,"traverse entry pl -> npart",pl -> npart,0);
  6179.  
  6180. #ifdef RECURSIVE
  6181.     if (xrecursive > 0 && !itsadir) {
  6182.         char * s;         /* Recursive descent and this is a regular file */
  6183.         *--endcur = '\0'; /* Terminate string, overwrite trailing slash */
  6184.  
  6185.         /* Find the nth slash from the right and match from there... */
  6186.         /* (n == the number of slashes in the original pattern - see fgen) */
  6187.         if (*sofar == '/') {
  6188.             debug(F110,"traverse xpatslash absolute",sofar,0);
  6189.             s = sofar;
  6190.         } else {
  6191.             debug(F111,"traverse xpatslash relative",sofar,xpatslash);
  6192.             for (s = endcur - 1, n = 0; s >= sofar; s--) {
  6193.                 if (*s == '/') {
  6194.                     if (++n >= xpatslash) {
  6195.                         s++;
  6196.                         break;
  6197.                     }
  6198.                 }
  6199.             }
  6200.         }
  6201. #ifndef NOSKIPMATCH
  6202.     /* This speeds things up a bit. */
  6203.     /* If it causes trouble define NOSKIPMATCH and rebuild. */
  6204.     if (xpat[0] == '*' && !xpat[1])
  6205.       x = xmatchdot ? 1 : (s[0] != '.');
  6206.     else
  6207. #endif /* NOSKIPMATCH */
  6208.       x = ckmatch(xpat, s, 1, mopts); /* Match with original pattern */
  6209.         debug(F111,"traverse xpatslash ckmatch",s,x);
  6210.         if (x > 0) {
  6211.             debug(F110,"traverse add: recursive, match, && !isdir",sofar,0);
  6212.             addresult(sofar,itsadir);
  6213.         }
  6214.         return;
  6215.     }
  6216. #endif /* RECURSIVE */
  6217.  
  6218.     debug(F111,"traverse sofar 2",sofar,0);
  6219.  
  6220.     segisdir = ((pl -> fwd) == NULL) ? 0 : 1;
  6221.     itswild = wildena ? (iswild(pl -> npart)) : 0; /* 15 Jun 2005 */
  6222.  
  6223.     debug(F111,"traverse segisdir",sofar,segisdir);
  6224.     debug(F111,"traverse itswild ",pl -> npart,itswild);
  6225.  
  6226. #ifdef RECURSIVE
  6227.     if (xrecursive > 0) {               /* If recursing and... */
  6228.         if (segisdir && itswild)        /* this is a dir and npart is wild */
  6229.           goto blah;                    /* or... */
  6230.         else if (!xpatabsolute && !xpatwild) /* search object is nonwild */
  6231.           goto blah;                    /* then go recurse */
  6232.     }
  6233. #endif /* RECURSIVE */
  6234.  
  6235.     if (!itswild) {                     /* This path segment not wild? */
  6236. #ifdef COMMENT
  6237.         strcpy(endcur,pl -> npart);     /* (safe) Append next part. */
  6238.         endcur += (int)strlen(pl -> npart); /* Advance end pointer */
  6239. #else
  6240. /*
  6241.   strcpy() does not account for quoted metacharacters.
  6242.   We must remove the quotes before doing the stat().
  6243. */
  6244.     {
  6245.         int quote = 0;
  6246.         char c, * s;
  6247.         s = pl -> npart;
  6248.         while ((c = *s++)) {
  6249.         if (!quote) {
  6250.             if (c == CMDQ) {
  6251.             quote = 1;
  6252.             continue;
  6253.             }
  6254.         }
  6255.         *endcur++ = c;
  6256.         quote = 0;
  6257.         }
  6258.     }
  6259. #endif /* COMMENT */
  6260.         *endcur = '\0';                 /* End new current string. */
  6261.  
  6262.         if (stat(sofar,&statbuf) == 0) { /* If this piece exists... */
  6263.             debug(F110,"traverse exists",sofar,0);
  6264.             *endcur++ = DIRSEP;         /* add slash to end */
  6265.             *endcur = '\0';             /* and end the string again. */
  6266.             traverse(pl -> fwd, sofar, endcur);
  6267.         }
  6268. #ifdef DEBUG
  6269.         else debug(F110,"traverse not found", sofar, 0);
  6270. #endif /* DEBUG */
  6271.         return;
  6272.     }
  6273.  
  6274.     *endcur = '\0';                     /* End current string */
  6275.     debug(F111,"traverse sofar 3",sofar,0);
  6276.  
  6277.     if (!itsadir)
  6278.       return;
  6279.  
  6280.     /* Search is recursive or ... */
  6281.     /* path segment contains wildcards, have to open and search directory. */
  6282.  
  6283.   blah:
  6284.  
  6285.     debug(F110,"traverse opening directory", sofar, 0);
  6286.  
  6287. #ifdef OPENDIR
  6288.     debug(F110,"traverse opendir()",sofar,0);
  6289.     if ((fd = opendir(sofar)) == NULL) {        /* Can't open, fail. */
  6290.         debug(F101,"traverse opendir() failed","",errno);
  6291.         return;
  6292.     }
  6293.     while ((dirbuf = readdir(fd)))
  6294. #else /* !OPENDIR */
  6295.     debug(F110,"traverse directory open()",sofar,0);
  6296.     if ((fd = open(sofar,O_RDONLY)) < 0) {
  6297.         debug(F101,"traverse directory open() failed","",errno);
  6298.         return;
  6299.     }
  6300.     while (read(fd, (char *)dirbuf, sizeof dir_entry) > 0)
  6301. #endif /* OPENDIR */
  6302.       {                         /* Read each entry in this directory */
  6303.           int exists;
  6304.           char *eos, *s;
  6305.           exists = 0;
  6306.  
  6307.           /* On some platforms, the read[dir]() can return deleted files, */
  6308.           /* e.g. HP-UX 5.00.  There is no point in grinding through this */
  6309.           /* routine when the file doesn't exist... */
  6310.  
  6311.           if (          /* There  actually is an inode... */
  6312. #ifdef BSD42
  6313.                          dirbuf->d_ino != -1
  6314. #else
  6315. #ifdef unos
  6316.                          dirbuf->d_ino != -1
  6317. #else
  6318. #ifdef QNX
  6319.                          dirbuf->d_stat.st_ino != 0
  6320. #else
  6321. #ifdef SOLARIS
  6322.                          dirbuf->d_ino != 0
  6323. #else
  6324. #ifdef sun
  6325.                          dirbuf->d_fileno != 0
  6326. #else
  6327. #ifdef bsdi
  6328.                          dirbuf->d_fileno != 0
  6329. #else
  6330. #ifdef __386BSD__
  6331.                          dirbuf->d_fileno != 0
  6332. #else
  6333. #ifdef __FreeBSD__
  6334.                          dirbuf->d_fileno != 0
  6335. #else
  6336. #ifdef ultrix
  6337.                          dirbuf->gd_ino != 0
  6338. #else
  6339. #ifdef Plan9
  6340.                          1
  6341. #else
  6342.                          dirbuf->d_ino != 0
  6343. #endif /* Plan9 */
  6344. #endif /* ultrix */
  6345. #endif /* __FreeBSD__ */
  6346. #endif /* __386BSD__ */
  6347. #endif /* bsdi */
  6348. #endif /* sun */
  6349. #endif /* SOLARIS */
  6350. #endif /* QNX */
  6351. #endif /* unos */
  6352. #endif /* BSD42 */
  6353.               )
  6354.             exists = 1;
  6355.           if (!exists)
  6356.             continue;
  6357.  
  6358.           ckstrncpy(nambuf,             /* Copy the name */
  6359.                   dirbuf->d_name,
  6360.                   MAXNAMLEN
  6361.                   );
  6362.           if (nambuf[0] == '.') {
  6363.               if (!nambuf[1] || (nambuf[1] == '.' && !nambuf[2])) {
  6364.                   debug(F110,"traverse skipping",nambuf,0);
  6365.                   continue;             /* skip "." and ".." */
  6366.               }
  6367.           }
  6368.           s = nambuf;                   /* Copy name to end of sofar */
  6369.           eos = endcur;
  6370.           while ((*eos = *s)) {
  6371.               s++;
  6372.               eos++;
  6373.           }
  6374. /*
  6375.   Now we check the file for (a) whether it is a directory, and (b) whether
  6376.   its name matches our pattern.  If it is a directory, and if we have been
  6377.   told to build a recursive list, then we must descend regardless of whether
  6378.   it matches the pattern.  If it is not a directory and it does not match
  6379.   our pattern, we skip it.  Note: sofar is the full pathname, nambuf is
  6380.   the name only.
  6381. */
  6382.           /* Do this first to save pointless function calls */
  6383.           if (nambuf[0] == '.' && !xmatchdot) /* Dir name starts with '.' */
  6384.             continue;
  6385.       if (stathack) {
  6386.           if (xrecursive || xfilonly || xdironly || xpatslash) {
  6387.           itsadir = xisdir(sofar); /* See if it's a directory */
  6388.           debug(F101,"STAT","",19);
  6389.           } else {
  6390.           itsadir = 0;
  6391.           }
  6392.       } else {
  6393.           itsadir = xisdir(sofar);
  6394.           debug(F101,"STAT","",20);
  6395.       }
  6396.  
  6397. #ifdef CKSYMLINK
  6398. #ifdef USE_LSTAT
  6399.       if (itsadir && xnolinks) {        /* If not following symlinks */
  6400.           int x;
  6401.           struct stat buf;
  6402.           x = lstat(sofar,&buf);
  6403.           debug(F111,"traverse lstat 2",sofar,x);
  6404.           if (x > -1 &&
  6405. #ifdef S_ISLNK
  6406.           S_ISLNK(buf.st_mode)
  6407. #else
  6408. #ifdef _IFLNK
  6409.           ((_IFMT & buf.st_mode) == _IFLNK)
  6410. #endif /* _IFLNK */
  6411. #endif /* S_ISLNK */
  6412.           )
  6413.         itsadir = 0;
  6414.       }
  6415. #endif /* USE_LSTAT */
  6416. #endif /* CKSYMLINK */
  6417.  
  6418. #ifdef RECURSIVE
  6419.           if (xrecursive > 0 && itsadir &&
  6420.               (xpatlast[0] == '*') && !xpatlast[1]
  6421.               ) {
  6422.               debug(F110,
  6423.                     "traverse add: recursive && isdir && segisdir or match",
  6424.                     sofar,
  6425.                     segisdir
  6426.                     );
  6427.           addresult(sofar,itsadir);
  6428.           if (numfnd < 0) return;
  6429.           }
  6430. #endif /* RECURSIVE */
  6431.  
  6432.           debug(F111,"traverse mresult xpat",xpat,xrecursive);
  6433.           debug(F111,"traverse mresult pl -> npart",
  6434.                 pl -> npart,
  6435.                 ((pl -> fwd) ? 9999 : 0)
  6436.                 );
  6437.           debug(F111,"traverse mresult sofar segisdir",sofar,segisdir);
  6438.           debug(F111,"traverse mresult sofar itsadir",sofar,itsadir);
  6439.           debug(F101,"traverse mresult xmatchdot","",xmatchdot);
  6440. /*
  6441.   Match the path so far with the pattern after stripping any leading "./"
  6442.   from either or both.  The pattern chosen is the full original pattern if
  6443.   the match candidate (sofar) is not a directory, or else just the name part
  6444.   (pl->npart) if it is.
  6445. */
  6446.       {
  6447.           char * s1;        /* The pattern */
  6448.           char * s2 = sofar;    /* The path so far */
  6449.           char * s3;        /* Worker */
  6450.           int opts;            /* Match options */
  6451.  
  6452.           s1 = itsadir ? pl->npart : xpat;
  6453.  
  6454. #ifndef COMMENT
  6455.           /* I can't explain this but it unbreaks "cd blah/sub<Esc>" */
  6456.           if (itsadir && !xrecursive && xpatslash > 0 &&
  6457.           segisdir == 0 && itswild) {
  6458.           s1 = xpat;
  6459.           debug(F110,"traverse mresult s1 kludge",s1,0);
  6460.           }
  6461. #endif /* COMMENT */
  6462.  
  6463.           if (xrecursive && xpatslash == 0)
  6464.         s2 = nambuf;
  6465.           while ((s1[0] == '.') && (s1[1] == '/')) /* Strip "./" */
  6466.         s1 += 2;
  6467.           while ((s2[0] == '.') && (s2[1] == '/')) /* Ditto */
  6468.         s2 += 2;
  6469.           opts = mopts;        /* Match options */
  6470.           if (itsadir)         /* Current segment is a directory */
  6471.         opts = mopts & 1;    /* No fences */
  6472.           s3 = s2;            /* Get segment depth */
  6473.           depth = 0;
  6474.           while (*s3) { if (*s3++ == '/') depth++; }
  6475. #ifndef NOSKIPMATCH
  6476.           /* This speeds things up a bit. */
  6477.           /* If it causes trouble define NOSKIPMATCH and rebuild. */
  6478.           if (depth == 0 && (s1[0] == '*') && !s1[1])
  6479.         mresult = xmatchdot ? 1 : (s2[0] != '.');
  6480.           else
  6481. #endif /* NOSKIPMATCH */
  6482.         mresult = ckmatch(s1,s2,1,opts); /* Match */
  6483.       }
  6484. #ifdef DEBUG
  6485.       if (deblog) {
  6486.           debug(F111,"traverse mresult depth",sofar,depth);
  6487.           debug(F101,"traverse mresult xpatslash","",xpatslash);
  6488.           debug(F111,"traverse mresult nambuf",nambuf,mresult);
  6489.           debug(F111,"traverse mresult itswild",pl -> npart,itswild);
  6490.           debug(F111,"traverse mresult segisdir",pl -> npart,segisdir);
  6491.       }
  6492. #endif /* DEBUG */
  6493.           if (mresult ||        /* If match succeeded */
  6494.           xrecursive ||        /* Or search is recursive */
  6495.           depth < xpatslash        /* Or not deep enough to match... */
  6496.           ) {
  6497.               if (                      /* If it's not a directory... */
  6498. /*
  6499.   The problem here is that segisdir is apparently not set appropriately.
  6500.   If I leave in the !segisdir test, then "dir /recursive blah" (where blah is
  6501.   a directory name) misses some regular files because sometimes segisdir
  6502.   is set and sometimes it's not.  But if I comment it out, then
  6503.   "dir <star>/<star>.txt lists every file in * and does not even open up the
  6504.   subdirectories.  However, "dir /rec <star>/<star>.txt" works right.
  6505. */
  6506. #ifdef COMMENT
  6507.                   mresult && (!itsadir && !segisdir)
  6508. #else
  6509.                   mresult &&        /* Matched */
  6510.                   !itsadir &&        /* sofar is not a directory */
  6511.                   ((!xrecursive && !segisdir) || xrecursive)
  6512. #endif /* COMMENT */
  6513.                   ) {
  6514.           debug(F110,
  6515.             "traverse add: match && !itsadir",sofar,0);
  6516.           addresult(sofar,itsadir);
  6517.           if (numfnd < 0) return;
  6518.               } else if (itsadir && (xrecursive || mresult)) {
  6519.                   struct path * xx = NULL;
  6520.                   *eos++ = DIRSEP;      /* Add directory separator */
  6521.                   *eos = '\0';          /* to end of segment */
  6522. #ifdef RECURSIVE
  6523.                   /* Copy previous pattern segment to this new directory */
  6524.  
  6525.                   if (xrecursive > 0 && !(pl -> fwd)) {
  6526.                       xx = (struct path *) malloc(sizeof (struct path));
  6527.                       pl -> fwd = xx;
  6528.                       if (xx) {
  6529.                           xx -> fwd = NULL;
  6530.                           strcpy(xx -> npart, pl -> npart); /* safe */
  6531.                       }
  6532.                   }
  6533. #endif /* RECURSIVE */
  6534.                   traverse(pl -> fwd, sofar, eos); /* Traverse new directory */
  6535.               }
  6536.           }
  6537.       }
  6538. #ifdef OPENDIR
  6539.     closedir(fd);
  6540. #else /* !OPENDIR */
  6541.     close(fd);
  6542. #endif /* OPENDIR */
  6543. }
  6544.  
  6545. /*
  6546.  * addresult:
  6547.  *  Adds a result string to the result array.  Increments the number
  6548.  *  of matches found, copies the found string into our string
  6549.  *  buffer, and puts a pointer to the buffer into the caller's result
  6550.  *  array.  Our free buffer pointer is updated.  If there is no
  6551.  *  more room in the caller's array, the number of matches is set to -1.
  6552.  * Input: a result string.
  6553.  * Returns: nothing.
  6554.  */
  6555. static VOID
  6556. addresult(str,itsadir) char *str; int itsadir; {
  6557.     int len;
  6558.  
  6559.     if (!freeptr) {
  6560.     debug(F100,"addresult string space not init'd","",0);
  6561.     initspace(mtchs,ssplen);
  6562.     }
  6563.     if (!str) str = "";
  6564.     debug(F111,"addresult",str,itsadir);
  6565.     if (!*str)
  6566.       return;
  6567.  
  6568.     if (itsadir < 0) {
  6569.     itsadir = xisdir(str);
  6570.     }
  6571.     if ((xdironly && !itsadir) || (xfilonly && itsadir)) {
  6572.         debug(F111,"addresult skip",str,itsadir);
  6573.         return;
  6574.     }
  6575.     while (str[0] == '.' && ISDIRSEP(str[1])) /* Strip all "./" from front */
  6576.       str += 2;
  6577.     if (--remlen < 0) {                 /* Elements left in array of names */
  6578.         debug(F111,"addresult ARRAY FULL",str,numfnd);
  6579.         numfnd = -1;
  6580.         return;
  6581.     }
  6582.     len = (int)strlen(str);        /* Space this will use */
  6583.     debug(F111,"addresult len",str,len);
  6584.  
  6585.     if (len < 1)
  6586.       return;
  6587.  
  6588.     if ((freeptr + len + itsadir + 1) > (sspace + ssplen)) {
  6589.         debug(F111,"addresult OUT OF SPACE",str,numfnd);
  6590. #ifdef DYNAMIC
  6591.     printf(
  6592. "?String space %d exhausted - use SET FILE STRINGSPACE to increase\n",ssplen);
  6593. #else
  6594.     printf("?String space %d exhausted\n",ssplen);
  6595. #endif /* DYNAMIC */
  6596.         numfnd = -1;                    /* Do not record if not enough space */
  6597.         return;
  6598.     }
  6599.     strcpy(freeptr,str);        /* safe */
  6600.  
  6601.     /* Tag directory names by putting '/' at the end */
  6602.  
  6603.     if (itsadir && (freeptr[len-1] == '/')) {
  6604.         freeptr[len++] = DIRSEP;
  6605.         freeptr[len] = '\0';
  6606.     }
  6607.     if (numfnd >= maxnames) {
  6608. #ifdef DYNAMIC
  6609.     printf(
  6610. "?Too many files (%d max) - use SET FILE LISTSIZE to increase\n",maxnames);
  6611. #else
  6612.     printf("?Too many files - %d max\n",maxnames);
  6613. #endif /* DYNAMIC */
  6614.         numfnd = -1;
  6615.         return;
  6616.     }
  6617.     str = freeptr;
  6618.     *resptr++ = freeptr;
  6619.     freeptr += (len + 1);
  6620.     numfnd++;
  6621.     debug(F111,"addresult ADD",str,numfnd);
  6622. }
  6623.  
  6624. #ifdef COMMENT
  6625. /*
  6626.  * match(pattern,string):
  6627.  *  pattern matcher.  Takes a string and a pattern possibly containing
  6628.  *  the wildcard characters '*' and '?'.  Returns true if the pattern
  6629.  *  matches the string, false otherwise.
  6630.  * Orignally by: Jeff Damens, CUCCA, 1984
  6631.  * No longer used as of C-Kermit 7.0, now we use ckmatch() instead (ckclib.c).
  6632.  *
  6633.  * Input: a string and a wildcard pattern.
  6634.  * Returns: 1 if match, 0 if no match.
  6635.  */
  6636. static int
  6637. match(pattern, string) char *pattern, *string; {
  6638.     char *psave = NULL, *ssave = NULL;  /* Backup pointers for failure */
  6639.     int q = 0;                          /* Quote flag */
  6640.  
  6641.     if (*string == '.' && *pattern != '.' && !xmatchdot) {
  6642.         debug(F110,"match skip",string,0);
  6643.         return(0);
  6644.     }
  6645.     while (1) {
  6646.         for (; *pattern == *string; pattern++,string++) /* Skip first */
  6647.           if (*string == '\0') return(1); /* End of strings, succeed */
  6648.  
  6649.         if (*pattern == '\\' && q == 0) { /* Watch out for quoted */
  6650.             q = 1;                      /* metacharacters */
  6651.             pattern++;                  /* advance past quote */
  6652.             if (*pattern != *string) return(0);
  6653.             continue;
  6654.         } else q = 0;
  6655.  
  6656.         if (q) {
  6657.             return(0);
  6658.         } else {
  6659.             if (*string != '\0' && *pattern == '?') {
  6660.                 pattern++;              /* '?', let it match */
  6661.                 string++;
  6662.             } else if (*pattern == '*') { /* '*' ... */
  6663.                 psave = ++pattern;      /* remember where we saw it */
  6664.                 ssave = string;         /* let it match 0 chars */
  6665.             } else if (ssave != NULL && *ssave != '\0') { /* if not at end  */
  6666.                                         /* ...have seen a star */
  6667.                 string = ++ssave;       /* skip 1 char from string */
  6668.                 pattern = psave;        /* and back up pattern */
  6669.             } else return(0);           /* otherwise just fail */
  6670.         }
  6671.     }
  6672. }
  6673. #endif /* COMMENT */
  6674.  
  6675. /*
  6676.   The following two functions are for expanding tilde in filenames
  6677.   Contributed by Howie Kaye, CUCCA, developed for CCMD package.
  6678. */
  6679.  
  6680. /*  W H O A M I  --  Get user's username.  */
  6681.  
  6682. /*
  6683.   1) Get real uid
  6684.   2) See if the $USER environment variable is set ($LOGNAME on AT&T)
  6685.   3) If $USER's uid is the same as ruid, realname is $USER
  6686.   4) Otherwise get logged in user's name
  6687.   5) If that name has the same uid as the real uid realname is loginname
  6688.   6) Otherwise, get a name for ruid from /etc/passwd
  6689. */
  6690. char *
  6691. whoami() {
  6692. #ifdef DTILDE
  6693. #ifdef pdp11
  6694. #define WHOLEN 100
  6695. #else
  6696. #define WHOLEN 257
  6697. #endif /* pdp11 */
  6698.     static char realname[UIDBUFLEN+1];  /* user's name */
  6699.     static int ruid = -1;               /* user's real uid */
  6700.     char loginname[UIDBUFLEN+1], envname[256]; /* temp storage */
  6701.     char *c;
  6702.     struct passwd *p;
  6703.     _PROTOTYP(extern char * getlogin, (void) );
  6704.  
  6705.     debug(F111,"whoami ruid A",realname,ruid);
  6706.  
  6707.     if (ruid != -1)
  6708.       return(realname);
  6709.  
  6710.     ruid = real_uid();                  /* get our uid */
  6711.     debug(F101,"whoami ruid B","",ruid);
  6712.     if (ruid < 0) ruid = getuid();
  6713.     debug(F101,"whoami ruid C","",ruid);
  6714.  
  6715.   /* how about $USER or $LOGNAME? */
  6716.     if ((c = getenv(NAMEENV)) != NULL) { /* check the env variable */
  6717.         ckstrncpy(envname, c, 255);
  6718.     debug(F110,"whoami envname",envname,0);
  6719.         if ((p = getpwnam(envname)) != NULL) {
  6720.             if (p->pw_uid == ruid) {    /* get passwd entry for envname */
  6721.                 ckstrncpy(realname, envname, UIDBUFLEN); /* uid's are same */
  6722.         debug(F110,"whoami realname",realname,0);
  6723.                 return(realname);
  6724.             }
  6725.         }
  6726.     }
  6727.  
  6728.   /* can we use loginname() ? */
  6729.  
  6730.     if ((c =  getlogin()) != NULL) {    /* name from utmp file */
  6731.         ckstrncpy (loginname, c, UIDBUFLEN);
  6732.     debug(F110,"whoami loginname",loginname,0); 
  6733.         if ((p = getpwnam(loginname)) != NULL) /* get passwd entry */
  6734.           if (p->pw_uid == ruid)        /* for loginname */
  6735.             ckstrncpy(realname, envname, UIDBUFLEN); /* if uid's are same */
  6736.     }
  6737.  
  6738.   /* Use first name we get for ruid */
  6739.  
  6740.     if ((p = getpwuid(ruid)) == NULL) { /* name for uid */
  6741.     debug(F101,"whoami no username for ruid","",ruid); 
  6742.         realname[0] = '\0';             /* no user name */
  6743.         ruid = -1;
  6744.         return(NULL);
  6745.     }
  6746.     ckstrncpy(realname, p->pw_name, UIDBUFLEN);
  6747.     debug(F110,"whoami realname from getpwuid",realname,0);
  6748.     return(realname);
  6749. #else
  6750.     return(NULL);
  6751. #endif /* DTILDE */
  6752. }
  6753.  
  6754. /*  T I L D E _ E X P A N D  --  expand ~user to the user's home directory. */
  6755.  
  6756. char *
  6757. tilde_expand(dirname) char *dirname; {
  6758. #ifdef DTILDE
  6759. #ifdef pdp11
  6760. #define BUFLEN 100
  6761. #else
  6762. #define BUFLEN 257
  6763. #endif /* pdp11 */
  6764.     struct passwd *user;
  6765.     static char olddir[BUFLEN+1];
  6766.     static char oldrealdir[BUFLEN+1];
  6767.     static char temp[BUFLEN+1];
  6768.     int i, j;
  6769.  
  6770.     debug(F111,"tilde_expand",dirname,dirname[0]);
  6771.  
  6772.     if (dirname[0] != '~') {              /* Not a tilde...return param */
  6773.     debug(F000,"tilde_expand NOT TILDE","",dirname[0]);
  6774.     return(dirname);
  6775.     }
  6776.     if (!strcmp(olddir,dirname)) {      /* Same as last time */
  6777.     debug(F110,"tilde_expand same as previous",oldrealdir,0);
  6778.     return(oldrealdir);               /* so return old answer. */
  6779.     } else {
  6780.     debug(F110,"tilde_expand working...","",0);
  6781.         j = (int)strlen(dirname);
  6782.         for (i = 0; i < j; i++)         /* find username part of string */
  6783.           if (!ISDIRSEP(dirname[i]))
  6784.             temp[i] = dirname[i];
  6785.           else break;
  6786.         temp[i] = '\0';                 /* tie off with a NULL */
  6787.     debug(F111,"tilde_expand first part",temp,i);
  6788.         if (i == 1) {                   /* if just a "~" */
  6789. #ifdef IKSD
  6790.             if (inserver)
  6791.               user = getpwnam(uidbuf);  /* Get info on current user */
  6792.             else
  6793. #endif /* IKSD */
  6794.             {
  6795.                 char * p = whoami();
  6796.         debug(F110,"tilde_expand p",p,0);
  6797.                 if (p) {
  6798.             user = getpwnam(p);
  6799.             debug(F110,"tilde_expand getpwpam ~",user,0);
  6800.         } else {
  6801.             user = NULL;
  6802.         }
  6803.             }
  6804.         } else {
  6805.         debug(F110,"tilde_expand ~user",&temp[1],0);
  6806.             user = getpwnam(&temp[1]);  /* otherwise on the specified user */
  6807.         debug(F110,"tilde_expand getpwpam user",user,0);
  6808.         }
  6809.  
  6810.     }
  6811.     if (user != NULL) {                 /* valid user? */
  6812.         ckstrncpy(olddir, dirname, BUFLEN); /* remember the directory */
  6813.         ckstrncpy(oldrealdir,user->pw_dir, BUFLEN); /* and home directory */
  6814.         ckstrncat(oldrealdir,&dirname[i], BUFLEN);
  6815.         oldrealdir[BUFLEN] = '\0';
  6816.         return(oldrealdir);
  6817.     } else {                            /* invalid? */
  6818.         ckstrncpy(olddir, dirname, BUFLEN); /* remember for next time */
  6819.         ckstrncpy(oldrealdir, dirname, BUFLEN);
  6820.         return(oldrealdir);
  6821.     }
  6822. #else
  6823.     return(NULL);
  6824. #endif /* DTILDE */
  6825. }
  6826.  
  6827. /*
  6828.   Functions for executing system commands.
  6829.   zsyscmd() executes the system command in the normal, default way for
  6830.   the system.  In UNIX, it does what system() does.  Thus, its results
  6831.   are always predictable.
  6832.   zshcmd() executes the command using the user's preferred shell.
  6833. */
  6834. int
  6835. zsyscmd(s) char *s; {
  6836. #ifdef aegis
  6837.     if (nopush) return(-1);
  6838.     if (!priv_chk()) return(system(s));
  6839. #else
  6840.     PID_T shpid;
  6841. #ifdef COMMENT
  6842. /* This doesn't work... */
  6843.     WAIT_T status;
  6844. #else
  6845.     int status;
  6846. #endif /* COMMENT */
  6847.  
  6848.     if (nopush) return(-1);
  6849.     if ((shpid = fork())) {
  6850.         if (shpid < (PID_T)0) return(-1); /* Parent */
  6851.         while (shpid != (PID_T) wait(&status))
  6852.          ;
  6853.         return(status);
  6854.     }
  6855.     if (priv_can()) {                   /* Child: cancel any priv's */
  6856.         printf("?Privilege cancellation failure\n");
  6857.         _exit(255);
  6858.     }
  6859.     restorsigs();            /* Restore ignored signals */
  6860. #ifdef HPUX10
  6861.     execl("/usr/bin/sh","sh","-c",s,NULL);
  6862.     perror("/usr/bin/sh");
  6863. #else
  6864. #ifdef Plan9
  6865.     execl("/bin/rc", "rc", "-c", s, NULL);
  6866.     perror("/bin/rc");
  6867. #else
  6868.     execl("/bin/sh","sh","-c",s,NULL);
  6869.     perror("/bin/sh");
  6870. #endif /* Plan9 */
  6871. #endif /* HPUX10 */
  6872.     _exit(255);
  6873.     return(0);                          /* Shut up ANSI compilers. */
  6874. #endif /* aegis */
  6875. }
  6876.  
  6877.  
  6878. /*  Z _ E X E C  --  Overlay ourselves with another program  */
  6879.  
  6880. #ifndef NOZEXEC
  6881. #ifdef HPUX5
  6882. #define NOZEXEC
  6883. #else
  6884. #ifdef ATT7300
  6885. #define NOZEXEC
  6886. #endif /* ATT7300 */
  6887. #endif /* HPUX5 */
  6888. #endif /* NOZEXEC */
  6889.  
  6890. VOID
  6891. z_exec(p,s,t) char * p, ** s; int t; {  /* Overlay ourselves with "p s..." */
  6892. #ifdef NOZEXEC
  6893.     printf("EXEC /REDIRECT NOT IMPLEMENTED IN THIS VERSION OF C-KERMIT\n");
  6894.     debug(F110,"z_exec NOT IMPLEMENTED",p,0);
  6895. #else
  6896.     int x;
  6897.     extern int ttyfd;
  6898.     debug(F110,"z_exec command",p,0);
  6899.     debug(F110,"z_exec arg 0",s[0],0);
  6900.     debug(F110,"z_exec arg 1",s[1],0);
  6901.     debug(F101,"z_exec t","",t);
  6902.     errno = 0;
  6903.     if (t) {
  6904.         if (ttyfd > 2) {
  6905.             dup2(ttyfd, 0);
  6906.             dup2(ttyfd, 1);
  6907.             /* dup2(ttyfd, 2); */
  6908.             close(ttyfd);
  6909.         }
  6910.     }
  6911.     restorsigs();            /* Restore ignored signals */
  6912.     x = execvp(p,s);
  6913.     if (x < 0) debug(F101,"z_exec errno","",errno);
  6914. #endif /* NOZEXEC */
  6915. }
  6916.  
  6917. /*
  6918.   Z S H C M D  --  Execute a shell command (or program thru the shell).
  6919.  
  6920.   Original UNIX code by H. Fischer; copyright rights assigned to Columbia U.
  6921.   Adapted to use getpwuid to find login shell because many systems do not
  6922.   have SHELL in environment, and to use direct calling of shell rather
  6923.   than intermediate system() call. -- H. Fischer (1985); many changes since
  6924.   then.  Call with s pointing to command to execute.  Returns:
  6925.    -1 on failure to start the command (can't find, can't fork, can't run).
  6926.     1 if command ran and gave an exit status of 0.
  6927.     0 if command ran and gave a nonzero exit status.
  6928.   with pexitstatus containing the command's exit status.
  6929. */
  6930. int
  6931. zshcmd(s) char *s; {
  6932.     PID_T pid;
  6933.  
  6934. #ifdef NOPUSH
  6935.     return(0);
  6936. #else
  6937.     if (nopush) return(-1);
  6938.     if (!s) return(-1);
  6939.     while (*s == ' ') s++;
  6940.  
  6941.     debug(F110,"zshcmd command",s,0);
  6942.  
  6943. #ifdef aegis
  6944.     if ((pid = vfork()) == 0) {         /* Make child quickly */
  6945.         char *shpath, *shname, *shptr;  /* For finding desired shell */
  6946.  
  6947.         if (priv_can()) exit(1);        /* Turn off privs. */
  6948.         if ((shpath = getenv("SHELL")) == NULL) shpath = "/com/sh";
  6949.  
  6950. #else                                   /* All Unix systems */
  6951.     if ((pid = fork()) == 0) {          /* Make child */
  6952.         char *shpath, *shname, *shptr;  /* For finding desired shell */
  6953.         struct passwd *p;
  6954. #ifdef HPUX10                           /* Default */
  6955.         char *defshell = "/usr/bin/sh";
  6956. #else
  6957. #ifdef Plan9
  6958.         char *defshell = "/bin/rc";
  6959. #else
  6960.         char *defshell = "/bin/sh";
  6961. #endif /* Plan9 */
  6962. #endif /* HPUX10 */
  6963.         if (priv_can()) exit(1);        /* Turn off privs. */
  6964. #ifdef COMMENT
  6965. /* Old way always used /etc/passwd shell */
  6966.         p = getpwuid(real_uid());       /* Get login data */
  6967.         if (p == (struct passwd *) NULL || !*(p->pw_shell))
  6968.           shpath = defshell;
  6969.         else
  6970.           shpath = p->pw_shell;
  6971. #else
  6972. /* New way lets user override with SHELL variable, but does not rely on it. */
  6973. /* This allows user to specify a different shell. */
  6974.         shpath = getenv("SHELL");       /* What shell? */
  6975.     debug(F110,"zshcmd SHELL",shpath,0);
  6976.     {
  6977.         int x = 0;
  6978.         if (!shpath) {
  6979.         x++;
  6980.         } else if (!*shpath) {
  6981.         x++;
  6982.         }
  6983.         if (x) {
  6984.         debug(F100,"zshcmd SHELL not defined","",0);
  6985.         p = getpwuid( real_uid() ); /* Get login data */
  6986.         if (p == (struct passwd *)NULL || !*(p->pw_shell)) {
  6987.             shpath = defshell;
  6988.         } else {
  6989.             shpath = p->pw_shell;
  6990.         }
  6991.         debug(F110,"zshcmd shpath from getpwuid",shpath,0);
  6992.         }
  6993.         }
  6994. #endif /* COMMENT */
  6995. #endif /* aegis */
  6996.         shptr = shname = shpath;
  6997.         while (*shptr != '\0')
  6998.           if (*shptr++ == DIRSEP)
  6999.             shname = shptr;
  7000.     restorsigs();            /* Restore ignored signals */
  7001.     debug(F110,"zshcmd execl shpath",shpath,0);
  7002.     debug(F110,"zshcmd execl shname",shname,0);
  7003.         if (s == NULL || *s == '\0') {  /* Interactive shell requested? */
  7004.         debug(F100,"zshcmd execl interactive","",0);
  7005.             execl(shpath,shname,"-i",NULL); /* Yes, do that */
  7006.         } else {                        /* Otherwise, */
  7007.         debug(F110,"zshcmd execl command",s,0);
  7008.             execl(shpath,shname,"-c",s,NULL); /* exec the given command */
  7009.         }                               /* If execl() failed, */
  7010.         debug(F101,"zshcmd errno","",errno);
  7011.     perror(shpath);            /* print reason and */
  7012.         exit(BAD_EXIT);                 /* return bad return code. */
  7013.  
  7014.     } else {                            /* Parent */
  7015.  
  7016.         int wstat;                      /* ... must wait for child */
  7017. #ifdef CK_CHILD
  7018.         int child;                      /* Child's exit status */
  7019. #endif /* CK_CHILD */
  7020.         SIGTYP (*istat)(), (*qstat)();
  7021.  
  7022.         if (pid == (PID_T) -1) return(-1); /* fork() failed? */
  7023.  
  7024.         istat = signal(SIGINT,SIG_IGN); /* Let the fork handle keyboard */
  7025.         qstat = signal(SIGQUIT,SIG_IGN); /* interrupts itself... */
  7026.  
  7027.     debug(F110,"zshcmd parent waiting for child",s,0);
  7028. #ifdef CK_CHILD
  7029.         while (((wstat = wait(&child)) != pid) && (wstat != -1))
  7030. #else
  7031.         while (((wstat = wait((WAIT_T *)0)) != pid) && (wstat != -1))
  7032. #endif /* CK_CHILD */
  7033.           ;                             /* Wait for fork */
  7034.         signal(SIGINT,istat);           /* Restore interrupts */
  7035.         signal(SIGQUIT,qstat);
  7036. #ifdef CK_CHILD
  7037.         pexitstat = (child & 0xff) ? child : child >> 8;
  7038.     debug(F101,"zshcmd exit status","",pexitstat);
  7039.         return(child == 0 ? 1 : 0);     /* Return child's status */
  7040. #endif /* CK_CHILD */
  7041.     }
  7042.     return(1);
  7043. #endif /* NOPUSH */
  7044. }
  7045.  
  7046. /*  I S W I L D  --  Check if filespec is "wild"  */
  7047.  
  7048. /*
  7049.   Returns:
  7050.     0 wildcards disabled or argument is empty or is the name of a single file;
  7051.     1 if it contains wildcard characters.
  7052.   Note: must match the algorithm used by match(), hence no [a-z], etc.
  7053. */
  7054. int
  7055. iswild(filespec) char *filespec; {
  7056.     char c, *p, *f; int x;
  7057.     int quo = 0;
  7058.     if (!filespec)            /* Safety */
  7059.       return(0);
  7060.     if (!wildena)            /* Wildcards disabled - 12 Jun 2005 */
  7061.       return(0);
  7062.     f = filespec;
  7063.     if (wildxpand) {            /* Shell handles wildcarding */
  7064.         if ((x = nzxpand(filespec,0)) > 1)
  7065.           return(1);
  7066.         if (x == 0) return(0);          /* File does not exist */
  7067.         p = malloc(MAXNAMLEN + 20);
  7068.         znext(p);
  7069.         x = (strcmp(filespec,p) != 0);
  7070.         free(p);
  7071.         p = NULL;
  7072.         return(x);
  7073.     } else {                /* We do it ourselves */
  7074.         while ((c = *filespec++) != '\0') {
  7075.             if (c == '\\' && quo == 0) {
  7076.                 quo = 1;
  7077.                 continue;
  7078.             }
  7079.             if (!quo && (c == '*' || c == '?'
  7080. #ifdef CKREGEX
  7081. #ifndef VMS
  7082.                          || c == '['
  7083. #endif /* VMS */
  7084.              || c == '{'
  7085. #endif /* CKREGEX */
  7086.                          )) {
  7087.         debug(F111,"iswild",f,1);
  7088.         return(1);
  7089.         }
  7090.             quo = 0;
  7091.         }
  7092.     debug(F111,"iswild",f,0);
  7093.         return(0);
  7094.     }
  7095. }
  7096.  
  7097. /*
  7098.   I S D I R  --  Is a Directory.
  7099.  
  7100.   Tell if string pointer s is the name of an existing directory.  Returns 1 if
  7101.   directory, 0 if not a directory.
  7102.  
  7103.   The following no longer applies:
  7104.  
  7105.   If the file is a symlink, we return 1 if
  7106.   it is a directory OR if it is a link to a directory and the "xrecursive" flag
  7107.   is NOT set.  This is to allow parsing a link to a directory as if it were a
  7108.   directory (e.g. in the CD or IF DIRECTORY command) but still prevent
  7109.   recursive traversal from visiting the same directory twice.
  7110. */
  7111.  
  7112. #ifdef ISDIRCACHE
  7113. /* This turns out to be unsafe and gives little benefit anyway. */
  7114. /* See notes 28 Sep 2003.  Thus ISDIRCACHE is not defined. */
  7115.  
  7116. static char prevpath[CKMAXPATH+4] = { '\0', '\0' };
  7117. static int prevstat = -1;
  7118. int
  7119. clrdircache() {
  7120.     debug(F100,"CLEAR ISDIR CACHE","",0);
  7121.     prevstat = -1;
  7122.     prevpath[0] = NUL;
  7123. }
  7124. #endif /* ISDIRCACHE */
  7125.  
  7126. int
  7127. isalink(s) char *s; {
  7128. #ifndef CKSYMLINK
  7129.     return(0);
  7130. #else
  7131.     int r = 0;
  7132.     char filbuf[CKMAXPATH+4];
  7133.     if (readlink(s,filbuf,CKMAXPATH) > -1)
  7134.       r = 1;
  7135.     debug(F110,"isalink readlink",s,r);
  7136.     return(r);
  7137. #endif    /* CKSYMLINK */
  7138. }
  7139.  
  7140. int
  7141. isdir(s) char *s; {
  7142.     int x, needrlink = 0, islink = 0;
  7143.     struct stat statbuf;
  7144.     char fnam[CKMAXPATH+4];
  7145.  
  7146.     if (!s) return(0);
  7147.     debug(F110,"isdir entry",s,0);
  7148. #ifdef DTILDE                /* 2005-08-13 */
  7149.     if (*s == '~') {            /* Starts with tilde? */
  7150.         s = tilde_expand(s);        /* Attempt to expand tilde */
  7151.         if (!s) s = "";
  7152.     debug(F110,"isdir tilde_expand",s,0);
  7153.     }
  7154. #endif /* DTILDE */
  7155.     if (!*s) return(0);
  7156.  
  7157. #ifdef ISDIRCACHE
  7158.     if (prevstat > -1) {
  7159.     if (s[0] == prevpath[0]) {
  7160.         if (!strcmp(s,prevpath)) {
  7161.         debug(F111,"isdir cache hit",s,prevstat);
  7162.         return(prevstat);
  7163.         }
  7164.     }
  7165.     }
  7166. #endif /* ISDIRCACHE */
  7167.  
  7168. #ifdef CKSYMLINK
  7169. #ifdef COMMENT
  7170. /*
  7171.   The following over-clever bit has been commented out because it presumes
  7172.   to know when a symlink might be redundant, which it can't possibly know.
  7173.   Using plain old stat() gives Kermit the same results as ls and ls -R, which
  7174.   is just fine: no surprises.
  7175. */
  7176. #ifdef USE_LSTAT
  7177.     if (xrecursive) {
  7178.         x = lstat(s,&statbuf);
  7179.         debug(F111,"isdir lstat",s,x);
  7180.     } else {
  7181. #endif /* USE_LSTAT */
  7182.         x = stat(s,&statbuf);
  7183.         debug(F111,"isdir stat",s,x);
  7184. #ifdef USE_LSTAT
  7185.     }
  7186. #endif /* USE_LSTAT */
  7187. #else
  7188.     x = stat(s,&statbuf);
  7189.     debug(F111,"isdir stat",s,x);
  7190. #endif /* COMMENT */
  7191.     if (x == -1) {
  7192.         debug(F101,"isdir errno","",errno);
  7193.         return(0);
  7194.     }
  7195.     islink = 0;
  7196.     if (xrecursive) {
  7197. #ifdef NOLINKBITS
  7198.         needrlink = 1;
  7199. #else
  7200. #ifdef S_ISLNK
  7201.         islink = S_ISLNK(statbuf.st_mode);
  7202.         debug(F101,"isdir S_ISLNK islink","",islink);
  7203. #else
  7204. #ifdef _IFLNK
  7205.         islink = (_IFMT & statbuf.st_mode) == _IFLNK;
  7206.         debug(F101,"isdir _IFLNK islink","",islink);
  7207. #endif /* _IFLNK */
  7208. #endif /* S_ISLNK */
  7209. #endif /* NOLINKBITS */
  7210.         if (needrlink) {
  7211.             if (readlink(s,fnam,CKMAXPATH) > -1)
  7212.               islink = 1;
  7213.         }
  7214.     }
  7215. #else
  7216.     x = stat(s,&statbuf);
  7217.     if (x == -1) {
  7218.         debug(F101,"isdir errno","",errno);
  7219.         return(0);
  7220.     }
  7221.     debug(F111,"isdir stat",s,x);
  7222. #endif /* CKSYMLINK */
  7223.     debug(F101,"isdir islink","",islink);
  7224.     debug(F101,"isdir statbuf.st_mode","",statbuf.st_mode);
  7225.     x = islink ? 0 : (S_ISDIR (statbuf.st_mode) ? 1 : 0);
  7226. #ifdef ISDIRCACHE
  7227.     prevstat = x;
  7228.     ckstrncpy(prevpath,s,CKMAXPATH+1);
  7229. #endif /* ISDIRCACHE */
  7230.     return(x);
  7231. }
  7232.  
  7233. #ifdef CK_MKDIR
  7234. /* Some systems don't have mkdir(), e.g. Tandy Xenix 3.2.. */
  7235.  
  7236. /* Z M K D I R  --  Create directory(s) if necessary */
  7237. /*
  7238.    Call with:
  7239.     A pointer to a file specification that might contain directory
  7240.     information.  The filename is expected to be included.
  7241.     If the file specification does not include any directory separators,
  7242.     then it is assumed to be a plain file.
  7243.     If one or more directories are included in the file specification,
  7244.     this routine tries to create them if they don't already exist.
  7245.    Returns:
  7246.     0 or greater on success, i.e. the number of directories created.
  7247.    -1 on failure to create the directory
  7248. */
  7249. int
  7250. zmkdir(path) char *path; {
  7251.     char *xp, *tp, c;
  7252.     int x, count = 0;
  7253.  
  7254.     if (!path) path = "";
  7255.     if (!*path) return(-1);
  7256.  
  7257. #ifdef CKROOT
  7258.     debug(F111,"zmkdir setroot",ckroot,ckrootset);
  7259.     if (ckrootset) if (!zinroot(path)) {
  7260.     debug(F110,"zmkdir setroot violation",path,0);
  7261.     return(-1);
  7262.     }
  7263. #endif /* CKROOT */
  7264.  
  7265.     x = strlen(path);
  7266.     debug(F111,"zmkdir",path,x);
  7267.     if (x < 1 || x > MAXPATH)           /* Check length */
  7268.       return(-1);
  7269.     if (!(tp = malloc(x+1)))            /* Make a temporary copy */
  7270.       return(-1);
  7271.     strcpy(tp,path);            /* safe (prechecked) */
  7272. #ifdef DTILDE
  7273.     if (*tp == '~') {                   /* Starts with tilde? */
  7274.         xp = tilde_expand(tp);          /* Attempt to expand tilde */
  7275.         if (!xp) xp = "";
  7276.         if (*xp) {
  7277.             char *zp;
  7278.             debug(F110,"zmkdir tilde_expand",xp,0);
  7279.             if (!(zp = malloc(strlen(xp) + 1))) { /* Make a place for it */
  7280.                 free(tp);
  7281.                 tp = NULL;
  7282.                 return(-1);
  7283.             }
  7284.             free(tp);                   /* Free previous buffer */
  7285.             tp = zp;                    /* Point to new one */
  7286.             strcpy(tp,xp);              /* Copy expanded name to new buffer */
  7287.         }
  7288.     }
  7289. #endif /* DTILDE */
  7290.     debug(F110,"zmkdir tp after tilde_expansion",tp,0);
  7291.     xp = tp;
  7292.     if (ISDIRSEP(*xp))                  /* Don't create root directory! */
  7293.       xp++;
  7294.  
  7295.     /* Go thru filespec from left to right... */
  7296.  
  7297.     for (; *xp; xp++) {                 /* Create parts that don't exist */
  7298.         if (!ISDIRSEP(*xp))             /* Find next directory separator */
  7299.           continue;
  7300.         c = *xp;                        /* Got one. */
  7301.         *xp = NUL;                      /* Make this the end of the string. */
  7302.         if (!isdir(tp)) {               /* This directory exists already? */
  7303. #ifdef CK_LOGIN
  7304.             if (isguest)                    /* Not allowed for guests */
  7305.           return(-1);
  7306. #ifndef NOXFER
  7307.             /* Nor if MKDIR and/or CD are disabled */
  7308.             else
  7309. #endif /* CK_LOGIN */
  7310.           if ((server
  7311. #ifdef IKSD
  7312.            || inserver
  7313. #endif /* IKSD */
  7314.            ) && (!ENABLED(en_mkd) || !ENABLED(en_cwd)))
  7315.         return(-1);
  7316. #endif /* IKSD */
  7317.  
  7318.             debug(F110,"zmkdir making",tp,0);
  7319.             x =                         /* No, try to create it */
  7320. #ifdef NOMKDIR
  7321.                -1                       /* Systems without mkdir() */
  7322. #else
  7323.                mkdir(tp,0777)           /* UNIX */
  7324. #endif /* NOMKDIR */
  7325.                  ;
  7326.             if (x < 0) {
  7327.                 debug(F101,"zmkdir failed, errno","",errno);
  7328.                 free(tp);               /* Free temporary buffer. */
  7329.                 tp = NULL;
  7330.                 return(-1);             /* Return failure code. */
  7331.             } else
  7332.               count++;
  7333.         }
  7334.         *xp = c;                        /* Replace the separator. */
  7335.     }
  7336.     free(tp);                           /* Free temporary buffer. */
  7337.     return(count);                      /* Return success code. */
  7338. }
  7339. #endif /* CK_MKDIR */
  7340.  
  7341. int
  7342. zrmdir(path) char *path; {
  7343. #ifdef CK_LOGIN
  7344.     if (isguest)
  7345.       return(-1);
  7346. #endif /* CK_LOGIN */
  7347.  
  7348.     if (!path) path = "";
  7349.     if (!*path) return(-1);
  7350.  
  7351. #ifdef CKROOT
  7352.     debug(F111,"zrmdir setroot",ckroot,ckrootset);
  7353.     if (ckrootset) if (!zinroot(path)) {
  7354.     debug(F110,"zrmdir setroot violation",path,0);
  7355.     return(-1);
  7356.     }
  7357. #endif /* CKROOT */
  7358.  
  7359. #ifndef NOMKDIR
  7360.     return(rmdir(path));
  7361. #else
  7362.     return(-1);
  7363. #endif /* NOMKDIR */
  7364. }
  7365.  
  7366. /* Z F S E E K  --  Position input file pointer */
  7367. /*
  7368.    Call with:
  7369.     CK_OFF_T (32 or 64 bits), 0-based, indicating desired position.
  7370.    Returns:
  7371.     0 on success.
  7372.    -1 on failure.
  7373. */
  7374. #ifndef NORESEND
  7375. int
  7376. #ifdef CK_ANSIC
  7377. zfseek(CK_OFF_T pos)
  7378. #else
  7379. zfseek(pos) CK_OFF_T pos;
  7380. #endif /* CK_ANSIC */
  7381. /* zfseek */ {
  7382.     zincnt = -1;                        /* Must empty the input buffer */
  7383.     debug(F101,"zfseek","",pos);
  7384.     return(CKFSEEK(fp[ZIFILE], pos, 0)?-1:0);
  7385. }
  7386. #endif /* NORESEND */
  7387.  
  7388. /*  Z F N Q F P  --  Convert filename to fully qualified absolute pathname */
  7389.  
  7390. /*
  7391.   Given a possibly unqualified or relative file specification fn, zfnqfp()
  7392.   returns the fully qualified filespec for the same file, returning a struct
  7393.   that contains the length (len) of the result, a pointer (fpath) to the
  7394.   whole result, and a pointer (fname) to where the filename starts.
  7395. */
  7396. static struct zfnfp fnfp = { 0, NULL, NULL };
  7397.  
  7398. struct zfnfp *
  7399. zfnqfp(fname, buflen, buf)  char * fname; int buflen; char * buf; {
  7400.     char * s;
  7401.     int len;
  7402. #ifdef MAXPATHLEN
  7403.     char zfntmp[MAXPATHLEN+4];
  7404. #else
  7405.     char zfntmp[CKMAXPATH+4];
  7406. #endif /* MAXPATHLEN */
  7407.  
  7408.     char sb[32], * tmp;
  7409.     int i = 0, j = 0, k = 0, x = 0, y = 0;
  7410.     int itsadir = 0;
  7411.  
  7412.     s = fname;
  7413.     if (!s)
  7414.       return(NULL);
  7415.     if (!*s)
  7416.       return(NULL);
  7417.     if (!buf)
  7418.       return(NULL);
  7419.  
  7420.     /* Initialize the data structure */
  7421.  
  7422.     fnfp.len = ckstrncpy(buf,fname,buflen);
  7423.     fnfp.fpath = buf;
  7424.     fnfp.fname = NULL;
  7425.     len = buflen;
  7426.     debug(F111,"zfnqfp fname",fname,len);
  7427.  
  7428. #ifdef DTILDE
  7429.     if (*s == '~') {                    /* Starts with tilde? */
  7430.         char * xp;
  7431.         xp = tilde_expand(s);           /* Attempt to expand tilde */
  7432.         debug(F110,"zfnqfp xp",xp,0);   /* (realpath() doesn't do this) */
  7433.         if (!xp) xp = "";
  7434.         if (*xp)
  7435.           s = xp;
  7436.     }
  7437. #endif /* DTILDE */
  7438.  
  7439. #ifdef CKREALPATH
  7440.  
  7441. /* N.B.: The realpath() result buffer MUST be MAXPATHLEN bytes long */
  7442. /* otherwise we write over memory. */
  7443.  
  7444.     if (!realpath(s,zfntmp)) {
  7445.         debug(F111,"zfnqfp realpath fails",s,errno);
  7446. #ifdef COMMENT
  7447.     if (errno != ENOENT)
  7448.       return(NULL);
  7449. #else
  7450.     /* If realpath() fails use the do-it-yourself method */
  7451.     /* 16 Jan 2002 */
  7452.     goto norealpath;
  7453. #endif /* COMMENT */
  7454.     }
  7455.     len = strlen(zfntmp);
  7456.     if (len > buflen) {
  7457.     debug(F111,"zfnqfp result too long",ckitoa(buflen),len);
  7458.     return(NULL);
  7459.     } else {
  7460.     ckstrncpy(buf,zfntmp,buflen);
  7461.     }
  7462.     if (buf[len-1] != '/') {
  7463.     if ((itsadir = isdir(buf)) && len < (buflen - 1)) {
  7464.         buf[len++] = '/';
  7465.         buf[len] = NUL;
  7466.     }
  7467.     }
  7468.     fnfp.len = len;
  7469.     fnfp.fpath = buf;
  7470.     debug(F110,"zfnqfp realpath path",fnfp.fpath,0);
  7471.     tmp = buf + fnfp.len - 1;
  7472.     if (!itsadir) {
  7473.     while (tmp >= buf) {
  7474.         if (*tmp == '/') {
  7475.         fnfp.fname = tmp + 1;
  7476.         debug(F110,"zfnqfp realpath name",fnfp.fname,0);
  7477.         break;
  7478.         }
  7479.         tmp--;
  7480.     }
  7481.     }
  7482.     return(&fnfp);
  7483.  
  7484. #endif /* CKREALPATH */
  7485.  
  7486.   norealpath:
  7487.  
  7488.     tmp = zfntmp;
  7489.     while (*s) {                        /* Remove leading "./" (0 or more) */
  7490.         debug(F110,"zfnqfp while *s",s,0);
  7491.         if (*s == '.' && *(s+1) == '/') {
  7492.             s += 2;
  7493.             while (*s == '/') s++;
  7494.         } else
  7495.           break;
  7496.     }
  7497.     if (!*s) return(NULL);
  7498.     if (*s == '/') {                    /* Pathname is absolute */
  7499.         ckstrncpy(buf,s,len);
  7500.         x = strlen(buf);
  7501.         y = 0;
  7502.     } else {                            /* Pathname is relative */
  7503.         char * p;
  7504.         if (p = zgtdir()) {             /* So get current directory */
  7505.             debug(F110,"zfnqfp zgtdir",p,0);
  7506.             x = ckstrncpy(buf,p,len);
  7507.             buf[x++] = '/';
  7508.             debug(F110,"zfnqfp buf 1",buf,0);
  7509.             len -= x;                   /* How much room left in buffer */
  7510.             if ((y = (int)strlen(s)) > len) /* If enough room... */
  7511.               return(NULL);
  7512.             ckstrncpy(buf+x,s,len);     /* ... append the filename */
  7513.             debug(F110,"zfnqfp buf 2",buf,0);
  7514.         } else {
  7515.             return(NULL);
  7516.         }
  7517.     }
  7518.  
  7519.     /* Buf now holds full path but maybe containing some . or .. tricks */
  7520.  
  7521.     j = x + y;                          /* Length of what's in buf */
  7522.     len = j;
  7523.     debug(F101,"zfnqfp len","",len);
  7524.  
  7525.     /* Catch dangling "/." or "/.." */
  7526.     if ((j > 1 && buf[j-1] == '.' && buf[j-2] == '/') ||
  7527.         (j > 2 && buf[j-1] == '.' && buf[j-2] == '.' && buf[j-3] == '/')) {
  7528.         if (j < buflen - 2) {
  7529.             buf[j] = '/';
  7530.             buf[j+1] = NUL;
  7531.         }
  7532.     }
  7533.     j = -1;                             /* j = position of rightmost "/" */
  7534.     i = 0;                              /* i = destination index */
  7535.     tmp[i] = NUL;                       /* destination is temporary buffer  */
  7536.  
  7537.     for (x = 0; x < len; x++) {         /* x = source index */
  7538.         if (buf[x] == '/') {
  7539.             for (k = 0; k < 4; k++) {
  7540.                 sb[k] = buf[x+k];
  7541.                 sb[k+1] = '\0';
  7542.                 if (!sb[k]) break;
  7543.             }
  7544.             if (!strncmp(sb,"/./",3)) { /* Eliminate "./" in "/./" */
  7545.                 x += 1;
  7546.                 continue;
  7547.             } else if (!strncmp(sb,"//",2)) { /* Change "//" to "/" */
  7548.                 continue;
  7549.             } else if (!strncmp(sb,"/../",4)) { /* ".." in path */
  7550.                 for (k = i - 1; k >= 0; k--) { /* Back up one level */
  7551.                     if (tmp[k] == '/') {
  7552.                         i = k;
  7553.                         tmp[i] = NUL;
  7554.                         break;
  7555.                     }
  7556.                 }
  7557.                 x += 2;
  7558.                 continue;
  7559.             }
  7560.         }
  7561.         if (i >= (buflen - 1)) {
  7562.             debug(F111,"zfnqfp overflow",tmp,i);
  7563.             return(NULL);
  7564.         }
  7565.         tmp[i++] = buf[x];              /* Regular character, copy */
  7566.         tmp[i] = NUL;
  7567.         if (buf[x] == '/')              /* Remember rightmost "/" */
  7568.           j = i;
  7569.     }
  7570.     ckstrncpy(buf,tmp,buflen-1);        /* Copy the result back */
  7571.  
  7572.     buf[buflen-1] = NUL;
  7573.     if (!buf[0]) {                      /* If empty, say root */
  7574.         buf[0] = '/';
  7575.         buf[2] = NUL;
  7576.         j = 0;
  7577.         i = 1;
  7578.     }
  7579.     if ((itsadir = isdir(buf))) {
  7580.     if (buf[i-1] != '/' && i < (buflen - 1)) {
  7581.         buf[i++] = '/';
  7582.         buf[i] = NUL;
  7583.     }
  7584.     }
  7585.     if (!itsadir && (j > -1)) {        /* Set pointer to basename */
  7586.         fnfp.fname = (char *)(buf + j);
  7587.         fnfp.fpath = (char *)buf;
  7588.         fnfp.len = i;
  7589.         debug(F111,"zfnqfp path",fnfp.fpath,i);
  7590.         debug(F110,"zfnqfp name",fnfp.fname,0);
  7591.         return(&fnfp);
  7592.     }
  7593.     return(NULL);
  7594. }
  7595.  
  7596. /*  Z C M P F N  --  Compare two filenames  */
  7597.  
  7598. /*  Returns 1 if the two names refer to the same existing file, 0 otherwise. */
  7599.  
  7600. int
  7601. zcmpfn(s1,s2) char * s1, * s2; {
  7602.     char buf1[CKMAXPATH+1];
  7603.     char buf2[CKMAXPATH+1];
  7604.  
  7605. #ifdef USE_LSTAT
  7606.     char linkname[CKMAXPATH+1];
  7607.     struct stat buf;
  7608. #endif /* USE_LSTAT */
  7609.     int x, rc = 0;
  7610.  
  7611.     if (!s1) s1 = "";
  7612.     if (!s2) s2 = "";
  7613.     if (!*s1 || !*s2) return(0);
  7614.  
  7615. #ifdef CKSYMLINK                        /* We're doing symlinks? */
  7616. #ifdef USE_LSTAT                        /* OK to use lstat()? */
  7617.     x = lstat(s1,&buf);
  7618.     if (x > -1 &&            /* Now see if it's a symlink */
  7619. #ifdef S_ISLNK
  7620.         S_ISLNK(buf.st_mode)
  7621. #else
  7622. #ifdef _IFLNK
  7623.         ((_IFMT & buf.st_mode) == _IFLNK)
  7624. #endif /* _IFLNK */
  7625. #endif /* S_ISLNK */
  7626.         ) {
  7627.         linkname[0] = '\0';             /* Get the name */
  7628.         x = readlink(s1,linkname,CKMAXPATH);
  7629.         if (x > -1 && x < CKMAXPATH) {  /* It's a link */
  7630.             linkname[x] = '\0';
  7631.         s1 = linkname;
  7632.         }
  7633.     }
  7634. #endif /* USE_LSTAT */
  7635. #endif /* CKSYMLINK */
  7636.  
  7637.     if (zfnqfp(s1,CKMAXPATH,buf1)) {    /* Convert to full pathname */
  7638.  
  7639. #ifdef CKSYMLINK            /* Same deal for second name... */
  7640. #ifdef USE_LSTAT
  7641.     x = lstat(s2,&buf);
  7642.     if (x > -1 &&
  7643. #ifdef S_ISLNK
  7644.         S_ISLNK(buf.st_mode)
  7645. #else
  7646. #ifdef _IFLNK
  7647.         ((_IFMT & buf.st_mode) == _IFLNK)
  7648. #endif /* _IFLNK */
  7649. #endif /* S_ISLNK */
  7650.         ) {
  7651.         linkname[0] = '\0';
  7652.         x = readlink(s2,linkname,CKMAXPATH);
  7653.         if (x > -1 && x < CKMAXPATH) {
  7654.         linkname[x] = '\0';
  7655.         s2 = linkname;
  7656.         }
  7657.     }
  7658. #endif /* USE_LSTAT */
  7659. #endif /* CKSYMLINK */
  7660.     if (zfnqfp(s2,CKMAXPATH,buf2)) {
  7661.         debug(F110,"zcmpfn s1",buf1,0);
  7662.         debug(F110,"zcmpfn s2",buf2,0);
  7663.         if (!strncmp(buf1,buf2,CKMAXPATH))
  7664.           rc = 1;
  7665.     }
  7666.     }
  7667.     debug(F101,"zcmpfn result","",rc);
  7668.     return(rc);
  7669. }
  7670.  
  7671. #ifdef CKROOT
  7672.  
  7673. /* User-mode chroot() implementation */
  7674.  
  7675. int
  7676. zsetroot(s) char * s; {            /* Sets the root */
  7677.     char buf[CKMAXPATH+1];
  7678.     if (!s) return(-1);
  7679.     if (!*s) return(-1);
  7680.     debug(F110,"zsetroot",s,0);
  7681.     if (!isdir(s)) return(-2);
  7682.     if (!zfnqfp(s,CKMAXPATH,buf))    /* Get full, real path */
  7683.       return(-3);
  7684.     if (access(buf,R_OK) < 0) {        /* Check access */
  7685.     debug(F110,"zsetroot access denied",buf,0);
  7686.     return(-4);
  7687.     }
  7688.     s = buf;
  7689.     if (ckrootset) {            /* If root already set */
  7690.     if (!zinroot(s)) {        /* make sure new root is in it */
  7691.         debug(F110,"zsetroot new root not in root",ckroot,0);
  7692.         return(-5);
  7693.     }
  7694.     }
  7695.     if (zchdir(buf) < 1) return(-4);    /* Change directory to new root */
  7696.     ckrootset = ckstrncpy(ckroot,buf,CKMAXPATH); /* Now set the new root */
  7697.     if (ckroot[ckrootset-1] != '/') {
  7698.     ckroot[ckrootset++] = '/';
  7699.     ckroot[ckrootset] = '\0';
  7700.     }
  7701.     debug(F111,"zsetroot rootset",ckroot,ckrootset);
  7702.     ckrooterr = 0;            /* Reset error flag */
  7703.     return(1);
  7704. }
  7705.  
  7706. char *
  7707. zgetroot() {                /* Returns the root */
  7708.     if (!ckrootset)
  7709.       return(NULL);
  7710.     return((char *)ckroot);
  7711. }
  7712.  
  7713. int
  7714. zinroot(s) char * s; {            /* Checks if file s is in the root */
  7715.     int x, n;
  7716.     struct zfnfp * f = NULL;
  7717.     char buf[CKMAXPATH+2];
  7718.  
  7719.     debug(F111,"zinroot setroot",ckroot,ckrootset);
  7720.     ckrooterr = 0;            /* Reset global error flag */
  7721.     if (!ckrootset)            /* Root not set */
  7722.       return(1);            /* so it's ok - no need to check */
  7723.     if (!(f = zfnqfp(s,CKMAXPATH,buf)))    /* Get full and real pathname */
  7724.       return(0);            /* Fail if we can't  */
  7725.     n = f->len;                /* Length of full pathname */
  7726.     debug(F111,"zinroot n",buf,n);
  7727.     if (n < (ckrootset - 1) || n > CKMAXPATH) {    /* Bad length */
  7728.     ckrooterr = 1;                    /* Fail */
  7729.     return(0);
  7730.     }
  7731.     if (isdir(buf) && buf[n-1] != '/') {  /* If it's a directory name */
  7732.     buf[n++] = '/';              /* make sure it ends with '/' */
  7733.     buf[n] = '\0';
  7734.     }
  7735.     x = strncmp(buf,ckroot,ckrootset);    /* Compare, case-sensitive */
  7736.     debug(F111,"zinroot checked",buf,x);
  7737.     if (x == 0)                /* OK */
  7738.       return(1);
  7739.     ckrooterr = 1;            /* Not OK */
  7740.     return(0);
  7741. }
  7742. #endif /* CKROOT */
  7743.  
  7744. #ifdef CK_LOGIN
  7745. /*
  7746.   The following code provides support for user login and logout
  7747.   including anonymous accounts.  If this feature is to be supported
  7748.   outside of UNIX, it should be spread out among the ck?fio.c modules...
  7749. */
  7750. #ifndef _PATH_BSHELL
  7751. #define _PATH_BSHELL    "/usr/bin/bash"
  7752. #endif /* _PATH_BSHELL */
  7753. #ifndef _PATH_FTPUSERS
  7754. #define _PATH_FTPUSERS  "/etc/ftpusers"
  7755. #endif /* _PATH_FTPUSERS */
  7756.  
  7757. /*
  7758.  * Helper function for sgetpwnam().
  7759.  */
  7760. char *
  7761. sgetsave(s) char *s; {
  7762.     char *new = malloc((unsigned) strlen(s) + 1);
  7763.     if (new == NULL) {
  7764.         printf("?Local resource failure: malloc\n");
  7765.         exit(1);
  7766.         /* NOTREACHED */
  7767.     }
  7768.     (void) strcpy(new, s);        /* safe */
  7769.     return (new);
  7770. }
  7771.  
  7772. /*
  7773.  * Save the result of getpwnam().  Used for USER command, since
  7774.  * the data returned must not be clobbered by any other command
  7775.  * (e.g., globbing).
  7776.  */
  7777. struct passwd *
  7778. sgetpwnam(name) char *name; {
  7779.     static struct passwd save;
  7780.     register struct passwd *p;
  7781. #ifdef CK_SHADOW
  7782.     register struct spwd *sp;
  7783. #endif /* CK_SHADOW */
  7784.     char *sgetsave();
  7785.  
  7786. #ifdef HPUX10_TRUSTED
  7787.     struct pr_passwd *pr;
  7788. #endif /* HPUX10_TRUSTED */
  7789.  
  7790. #ifdef CK_SHADOW
  7791.     sp = getspnam(name);
  7792.     if (sp == NULL) {
  7793.         debug(F110,"sgetpwnam","getspnam() fails",0);
  7794.     return (NULL);
  7795.     }
  7796. #endif /* CK_SHADOW */
  7797.  
  7798. #ifdef HPUX10_TRUSTED
  7799.     if ((pr = getprpwnam(name)) == NULL)
  7800.       return(NULL);
  7801. #endif /* HPUX10_TRUSTED */
  7802.  
  7803.     p = getpwnam(name);
  7804.     /* debug(F111,"sgetpwnam","getpwnam()",p); */
  7805.     if (p == NULL)
  7806.       return(NULL);
  7807.     if (save.pw_name) {
  7808.         free(save.pw_name);
  7809.         free(save.pw_passwd);
  7810.         free(save.pw_gecos);
  7811.         free(save.pw_dir);
  7812.         free(save.pw_shell);
  7813.     }
  7814.     save = *p;
  7815.     save.pw_name = sgetsave(p->pw_name);
  7816. #ifdef CK_SHADOW
  7817.     save.pw_passwd = sgetsave(sp->sp_pwdp);
  7818. #else /* CK_SHADOW */
  7819. #ifdef HPUX10_TRUSTED
  7820.     if (pr->uflg.fg_encrypt && pr->ufld.fd_encrypt && *pr->ufld.fd_encrypt)
  7821.       save.pw_passwd = sgetsave(pr->ufld.fd_encrypt);
  7822.     else
  7823.       save.pw_passwd = sgetsave("");
  7824. #else /* HPUX10_TRUSTED */
  7825.     save.pw_passwd = sgetsave(p->pw_passwd);
  7826. #endif /* HPUX10_TRUSTED */
  7827. #endif /* CK_SHADOW */
  7828.     save.pw_gecos = sgetsave(p->pw_gecos);
  7829.     save.pw_dir = sgetsave(p->pw_dir);
  7830.     save.pw_shell = sgetsave(p->pw_shell);
  7831.     return(&save);
  7832. }
  7833.  
  7834. #define CKXLOGBSIZ 256
  7835.  
  7836. struct passwd * pw = NULL;
  7837. char * home = NULL;                     /* Home directory pointer for glob */
  7838. #ifdef CMASK
  7839. #undef CMASK
  7840. #endif /* CMASK */
  7841.  
  7842. #define CMASK 027
  7843.  
  7844. int defumask = CMASK;                   /* Default umask value */
  7845.  
  7846. /*  Z V U S E R  --  Verify user, Returns 1 if user OK, 0 otherwise.  */
  7847.  
  7848. /* Sets global passwd pointer pw if named account exists and is acceptable;
  7849.  * sets askpasswd if a PASS command is expected.  If logged in previously,
  7850.  * need to reset state.  If name is "ftp" or "anonymous", the name is not in
  7851.  * _PATH_FTPUSERS, and ftp account exists, set guest and pw, then just return.
  7852.  * If account doesn't exist, ask for passwd anyway.  Otherwise, check user
  7853.  * requesting login privileges.  Disallow anyone who does not have a standard
  7854.  * shell as returned by getusershell().  Disallow anyone mentioned in the file
  7855.  * _PATH_FTPUSERS to allow people such as root and uucp to be avoided.
  7856.  */
  7857. _PROTOTYP(static int checkuser, (char *) );
  7858.  
  7859. char zvuname[64] = { NUL, NUL };
  7860. char zvhome[CKMAXPATH+1] = { NUL, NUL };
  7861. #define ZENVUSER 70
  7862. #define ZENVHOME CKMAXPATH+12
  7863. #define ZENVLOGNAME 74
  7864. static char zenvuser[ZENVUSER];
  7865. static char zenvhome[ZENVHOME];
  7866. static char zenvlogname[ZENVLOGNAME];
  7867.  
  7868. #ifdef CK_PAM
  7869. static char pam_data[500];
  7870. struct pam_conv pam_conv = {pam_cb, pam_data}; /* PAM structure */
  7871. struct pam_handle * pamh = NULL;               /* PAM reference handle */
  7872. #endif /* CK_PAM */
  7873.  
  7874. int
  7875. zvuser(name) char *name; {
  7876.     register char *cp = NULL;
  7877.     int x;
  7878.     char *shell;
  7879. #ifdef GETUSERSHELL
  7880. _PROTOTYP(char * getusershell, (void) );
  7881. #endif /* GETUSERSHELL */
  7882. #ifndef NODCLENDUSERSHELL
  7883. _PROTOTYP(VOID endusershell, (void) );
  7884. #endif    /* NODCLENDUSERSHELL */
  7885.  
  7886. #ifdef CK_PAM
  7887.     int pam_status;
  7888.     const char * reply = NULL;
  7889. #endif /* CK_PAM */
  7890.  
  7891.     debug(F111,"user",name,logged_in);
  7892.  
  7893.     if (!name) name = "";
  7894.     zvuname[0] = NUL;
  7895.  
  7896.     debug(F101,"zvuser ckxsyslog","",ckxsyslog);
  7897.  
  7898. #ifdef CKSYSLOG
  7899.     debug(F100,"zvuser CKSYSLOG defined","",0);
  7900. #endif /* CKSYSLOG */
  7901.  
  7902.     if (logged_in)                      /* Should not be called if logged in */
  7903.       return(0);
  7904.  
  7905. #ifdef CKSYSLOG
  7906.     if (ckxsyslog && ckxlogging) {
  7907.         syslog(LOG_INFO,
  7908.                 "login: user %s",name
  7909.                 );
  7910.     }
  7911. #endif /* CKSYSLOG */
  7912.  
  7913.     guest = 0;                          /* Assume not guest */
  7914.     askpasswd = 0;
  7915.  
  7916.     if (strcmp(name, "ftp") == 0 || strcmp(name, "anonymous") == 0) {
  7917.         debug(F101,"zvuser anonymous ckxanon","",ckxanon);
  7918.         if (!ckxanon) {                 /* Anonymous login not allowed */
  7919. #ifdef CKSYSLOG
  7920.             if (ckxsyslog && ckxlogging) {
  7921.                 syslog(LOG_INFO,
  7922.                        "login: anonymous login not allowed: %s",
  7923.                        clienthost ? clienthost : "(unknown host)"
  7924.                        );
  7925.             }
  7926. #endif /* CKSYSLOG */
  7927.             return(0);
  7928.         }
  7929.         if (checkuser("ftp") || checkuser("anonymous")) {
  7930.             debug(F100,"zvuser anon forbidden by ftpusers file","",0);
  7931. #ifdef CKSYSLOG
  7932.             if (ckxsyslog && ckxlogging) {
  7933.                 syslog(LOG_INFO,
  7934.                        "login: anonymous login forbidden by ftpusers file: %s",
  7935.                        clienthost ? clienthost : "(unknown host)"
  7936.                        );
  7937.             }
  7938. #endif /* CKSYSLOG */
  7939.             return(0);
  7940.     } else if ((pw = sgetpwnam("ftp")) != NULL) {
  7941.             debug(F100,"zvuser anon sgetpwnam(ftp) OK","",0);
  7942.             guest = 1;
  7943.             askpasswd = 1;
  7944.             ckstrncpy(zvuname,"anonymous",64);
  7945.             return(1);
  7946.         } else {
  7947.             debug(F100,"zvuser anon sgetpwnam(ftp) FAILED","",0);
  7948. #ifdef CKSYSLOG
  7949.             if (ckxsyslog && ckxlogging) {
  7950.                 syslog(LOG_INFO,
  7951.                        "login: anonymous getpwnam(ftp) failed: %s",
  7952.                        clienthost ? clienthost : "(unknown host)"
  7953.                        );
  7954.             }
  7955. #endif /* CKSYSLOG */
  7956.             return(0);
  7957.         }
  7958.     }
  7959.     pw = sgetpwnam(name);
  7960.     if (pw) {
  7961. /*
  7962.   Of course some UNIX platforms (like AIX) don't have getusershell().
  7963.   In that case we can't check if the user's account has been "turned off"
  7964.   or somesuch, e.g. by setting their shell to "/etc/nologin" or somesuch,
  7965.   which runs (usually just printing a message and exiting), but which is
  7966.   not listed in /etc/shells.  For that matter, if getusershell() is not
  7967.   available, then probably neither is /etc/shells.
  7968. */
  7969.         debug(F100,"zvuser sgetpwnam ok","",0);
  7970.         shell = pw->pw_shell;
  7971.         if (!shell) shell = "";
  7972.         if (!*shell)
  7973.           shell = _PATH_BSHELL;
  7974.         debug(F110,"zvuser shell",shell,0);
  7975. #ifdef GETUSERSHELL
  7976.         while ((cp = getusershell()) != NULL) {
  7977.             debug(F110,"zvuser getusershell",cp,0);
  7978.             if ((int)strcmp(cp, shell) == 0)
  7979.               break;
  7980.         }
  7981.         debug(F100,"zvuser endusershell 1","",0);
  7982. #ifndef NODCLENDUSERSHELL
  7983.         (VOID) endusershell();
  7984. #else
  7985.         endusershell();
  7986. #endif    /* NODCLENDUSERSHELL */
  7987.         debug(F100,"zvuser endusershell 2","",0);
  7988. #else /* GETUSERSHELL */
  7989.         cp = "";                        /* Do not refuse if we cannot check */
  7990. #endif /* GETUSERSHELL */
  7991.         x = checkuser(name);
  7992.         debug(F101,"zvuser checkuser","",x);
  7993.         if (cp == NULL) {
  7994.             debug(F100,"zvuser refused 1","",0);
  7995.             pw = (struct passwd *) NULL;
  7996. #ifdef CKSYSLOG
  7997.             if (ckxsyslog && ckxlogging) {
  7998.                 syslog(LOG_INFO,
  7999.                        "login: invalid shell %s for %s %s",shell, name,
  8000.                        clienthost ? clienthost : "(unknown host)"
  8001.                        );
  8002.             }
  8003. #endif /* CKSYSLOG */
  8004.             return(0);
  8005.         } else if (x) {
  8006.             debug(F100,"zvuser refused 2","",0);
  8007.             pw = (struct passwd *) NULL;
  8008. #ifdef CKSYSLOG
  8009.             if (ckxsyslog && ckxlogging) {
  8010.                 syslog(LOG_INFO,
  8011.                        "login: %s login forbidden by ftpusers file: %s",
  8012.                        name, clienthost ? clienthost : "(unknown host)"
  8013.                        );
  8014.             }
  8015. #endif /* CKSYSLOG */
  8016.             return(0);
  8017.         } else {
  8018.             x = 0;
  8019. #ifdef CK_PAM
  8020.             /* Get PAM authentication details */
  8021.             debug(F110,"zvuser","calling pam_start",0);
  8022.             if ((pam_status =
  8023.                  pam_start(PAM_SERVICE_TYPE,name,&pam_conv,&pamh))
  8024.                 != PAM_SUCCESS) {
  8025.                 reply = pam_strerror(NULL, pam_status);
  8026.                 debug(F110,"zvuser PAM failure",reply,0);
  8027.                 printf("%s\n",reply);
  8028. #ifdef CKSYSLOG
  8029.                 if (ckxsyslog && ckxlogging) {
  8030.                     syslog(LOG_INFO,
  8031.                            "login: %s refused by PAM \"%s\": %s",
  8032.                            name,reply,
  8033.                            clienthost ? clienthost : "(unknown host)"
  8034.                            );
  8035.                 }
  8036. #endif /* CKSYSLOG */
  8037.                 return(0);
  8038.             }
  8039. #endif /* CK_PAM */
  8040.             askpasswd = 1;
  8041.             ckstrncpy(zvuname,name,64);
  8042.             return(1);
  8043.         }
  8044.     } else {
  8045.         x = 0;
  8046.         debug(F100,"zvuser sgetpwnam NULL","",0);
  8047. #ifdef CKSYSLOG
  8048.         if (ckxsyslog && ckxlogging) {
  8049.             syslog(LOG_INFO,
  8050.                    "login: getpwnam(%s) failed: %s",name,
  8051.                    clienthost ? clienthost : "(unknown host)"
  8052.                    );
  8053.         }
  8054. #endif /* CKSYSLOG */
  8055.         return(0);
  8056.     }
  8057.  
  8058. #ifdef FTP_KERBEROS
  8059.     if (auth_type && strcmp(auth_type, "KERBEROS_V4") == 0) {
  8060. #ifdef COMMENT
  8061.     /* Why sprintf and then printf? */
  8062.     /* Also, what is kerb_ok?  And is the test on it right? */
  8063.         char buf[CKXLOGBSIZ];
  8064.         sprintf(buf, "Kerberos user %s%s%s@%s is%s authorized as %s%s",
  8065.                  kdata.pname, *kdata.pinst ? "." : "",
  8066.                  kdata.pinst, kdata.prealm,
  8067.                  (kerb_ok = kuserok(&kdata,name) == 0) ? "" : " not",
  8068.                  name, kerb_ok ? "" : "; Password required.");
  8069.         printf("%s", buf);
  8070. #else
  8071.         printf("Kerberos user %s%s%s@%s is%s authorized as %s%s",
  8072.                  kdata.pname, *kdata.pinst ? "." : "",
  8073.                  kdata.pinst, kdata.prealm,
  8074.                  (kerb_ok = kuserok(&kdata,name) == 0) ? "" : " not",
  8075.                  name, kerb_ok ? "" : "; Password required.");
  8076. #endif /* COMMENT */
  8077.         if (kerb_ok) return(1);
  8078.     } else
  8079.       return(0);
  8080. #endif /* FTP_KERBEROS */
  8081. }
  8082.  
  8083. /* Check if the given user is in the forbidden-user file */
  8084.  
  8085. static int
  8086. checkuser(name) char *name; {
  8087.     extern char * userfile;
  8088.     FILE *fd;
  8089.     int i;
  8090.     char line[CKXLOGBSIZ+1];
  8091.  
  8092.     if (!name)
  8093.       name = "";
  8094.     i = strlen(name);
  8095.     debug(F111,"checkuser name",name,i);
  8096.     if (!*name)
  8097.       return(1);
  8098.  
  8099.     fd = fopen(userfile ? userfile : _PATH_FTPUSERS, "r");
  8100.     /* debug(F111,"checkuser userfile",userfile,fd); */
  8101.     if (fd) {
  8102.         line[0] = '\0';
  8103.         while (fgets(line, sizeof(line), fd)) {
  8104.             debug(F110,"checkuser line",line,0);
  8105.             if (line[0] <= '#')
  8106.               continue;
  8107.             if (strncmp(line, name, i) == 0) {
  8108.                 debug(F110,"checkuser REFUSED",name,0);
  8109.                 return(1);
  8110.             }
  8111.             line[0] = '\0';
  8112.         }
  8113.         (VOID) fclose(fd);
  8114.     }
  8115.     debug(F110,"checkuser OK",name,0);
  8116.     return(0);
  8117. }
  8118.  
  8119. /*  Z V L O G O U T  --  Log out from Internet Kermit Service  */
  8120.  
  8121. VOID
  8122. zvlogout() {
  8123. #ifdef COMMENT
  8124.     /* This could be dangerous */
  8125.     if (setuid((UID_T)0) < 0) {
  8126.         debug(F100,"zvlogout setuid FAILED","",0);
  8127.         goto bad;
  8128.     }
  8129.     debug(F100,"zvlogout setuid OK","",0);
  8130. #endif /* COMMENT */
  8131. #ifdef CKSYSLOG
  8132.     if (ckxsyslog >= SYSLG_LI && ckxlogging) {
  8133.         cksyslog(SYSLG_LI, 1, "logout",(char *) uidbuf, clienthost);
  8134.     }
  8135. #endif /* CKSYSLOG */
  8136. #ifdef CKWTMP
  8137.     debug(F110,"WTMP logout",cksysline,logged_in);
  8138.     if (logged_in)
  8139.       logwtmp(cksysline, "", "");
  8140. #endif /* CKWTMP */
  8141.     pw = NULL;
  8142.     logged_in = 0;
  8143.     guest = 0;
  8144.     isguest = 0;
  8145. }
  8146.  
  8147. #ifdef FTP_KERBEROS
  8148. kpass(name, p) char *name, *p; {
  8149.     char instance[INST_SZ];
  8150.     char realm[REALM_SZ];
  8151.     char tkt_file[20];
  8152.     KTEXT_ST ticket;
  8153.     AUTH_DAT authdata;
  8154.     unsigned long faddr;
  8155.     struct hostent *hp;
  8156.  
  8157.     if (krb_get_lrealm(realm, 1) != KSUCCESS)
  8158.       return(0);
  8159.  
  8160.     ckstrncpy(tkt_file, TKT_ROOT, 20);
  8161.     ckstrncat(tkt_file, "_ftpdXXXXXX", 20);
  8162.     krb_set_tkt_string(mktemp(tkt_file));
  8163.  
  8164.     (VOID) ckstrncpy(instance, krb_get_phost(hostname), sizeof(instance));
  8165.  
  8166.     if ((hp = gethostbyname(instance)) == NULL)
  8167.       return(0);
  8168.  
  8169. #ifdef HADDRLIST
  8170.     hp = ck_copyhostent(hp);        /* safe copy that won't change */
  8171. #endif /* HADDRLIST */
  8172.     bcopy((char *)hp->h_addr, (char *) &faddr, sizeof(faddr));
  8173.  
  8174.     if (krb_get_pw_in_tkt(name, "", realm, "krbtgt", realm, 1, p) ||
  8175.         krb_mk_req(&ticket, "rcmd", instance, realm, 33) ||
  8176.         krb_rd_req(&ticket, "rcmd", instance, faddr, &authdata, "") ||
  8177.         kuserok(&authdata, name)) {
  8178.         dest_tkt();
  8179.         return(0);
  8180.     }
  8181.     dest_tkt();
  8182.     return(1);
  8183. }
  8184. #endif /* FTP_KERBEROS */
  8185.  
  8186. VOID
  8187. zsyslog() {
  8188. #ifdef CKSYSLOG
  8189.     if (ckxsyslog && !ckxlogging) {
  8190. #ifdef LOG_DAEMON
  8191.         openlog(inserver ? "iksd" : "ckermit", LOG_PID, LOG_DAEMON);
  8192. #else
  8193.         openlog(inserver ? "iksd" : "ckermit", LOG_PID);
  8194. #endif /* LOG_DAEMON */
  8195.         ckxlogging = 1;
  8196.         debug(F100,"zsyslog syslog opened","",0);
  8197.     }
  8198. #endif /* CKSYSLOG */
  8199. }
  8200.  
  8201. /*  Z V P A S S  --  Verify password; returns 1 if OK, 0 otherwise  */
  8202.  
  8203. #ifndef AUTH_USER
  8204. #define AUTH_USER 3
  8205. #endif /* AUTH_USER */
  8206. #ifndef AUTH_VALID
  8207. #define AUTH_VALID 4
  8208. #endif /* AUTH_VALID */
  8209.  
  8210. #ifdef __FreeBSD__            /* 299 This was necessary in */
  8211. #ifndef NODCLINITGROUPS            /* FreeBSD 4.4, don't know */
  8212. #define NODCLINITGROUPS            /* about other versions... */
  8213. #endif    /* NODCLINITGROUPS */            
  8214. #endif    /*  __FreeBSD__ */
  8215.  
  8216. int
  8217. zvpass(p) char *p; {
  8218. #ifndef NODCLINITGROUPS
  8219. _PROTOTYP(int initgroups, (const char *, gid_t) );
  8220. #endif    /* NODCLINITGROUPS */
  8221.  
  8222.     char *xpasswd, *salt;
  8223.     char * dir = NULL;
  8224. #ifdef CK_PAM
  8225.     int pam_status;
  8226.     const char * reply = NULL;
  8227. #endif /* CK_PAM */
  8228.  
  8229.     if (logged_in || askpasswd == 0) {
  8230.         return(0);
  8231.     }
  8232.     debug(F111,"zvpass",p ? (guest ? p : "xxxxxx") : "(null)",guest);
  8233.     if (!p) p = "";
  8234.     askpasswd = 0;
  8235.     if (guest && !*p) {                 /* Guests must specify a password */
  8236. #ifdef CKSYSLOG
  8237.         if (ckxsyslog && ckxlogging) {
  8238.             syslog(LOG_INFO,
  8239.                    "login: anonymous guests must specify a password"
  8240.                    );
  8241.         }
  8242. #endif /* CKSYSLOG */
  8243.         return(0);
  8244.     }
  8245.     if (!guest
  8246. #ifdef CK_AUTHENTICATION
  8247.         && ck_tn_auth_valid() != AUTH_VALID
  8248. #endif /* CK_AUTHENTICATION */
  8249.         ) {                     /* "ftp" is only account allowed no password */
  8250. #ifdef CK_PAM
  8251.         debug(F110,"zvpass","calling pam_set_item(AUTHTOK)",0);
  8252.         if ((pam_status = pam_set_item(pamh,PAM_AUTHTOK,p)) != PAM_SUCCESS) {
  8253.             reply = pam_strerror(pamh, pam_status);
  8254.             debug(F110,"zvpass PAM failure",reply,0);
  8255.             /* if no password given treat as non-fatal error */
  8256.             /* pam will prompt for password in pam_authenticate() */
  8257.             if (!p) {
  8258.                 printf("%s\n",reply);
  8259.                 pam_end(pamh, 0);
  8260.                 debug(F100,"zvpass denied","",0);
  8261.                 pw = NULL;
  8262.                 zvuname[0] = NUL;
  8263.                 return(0);
  8264.             }
  8265.         }
  8266.         debug(F110,"zvpass","calling pam_authenticate",0);
  8267. #ifdef COMMENT
  8268.         if (*p)
  8269.       pam_pw = p;
  8270. #else
  8271. /*
  8272.   Make IKSD authentication (using PAM) ask for a password when an
  8273.   invalid username has been given, to avoid disclosing which account
  8274.   names are valid. See #417247 (Debian).
  8275. */
  8276.         if (*p
  8277. #ifdef CK_LOGIN
  8278.         || gotemptypasswd
  8279. #endif /* CK_LOGIN */
  8280.         )
  8281.         pam_pw = p;
  8282. #endif    /* COMMENT */
  8283.         if ((pam_status = pam_authenticate(pamh, 0)) != PAM_SUCCESS) {
  8284.             reply = pam_strerror(pamh, pam_status);
  8285.             debug(F110,"zvpass PAM failure",reply,0);
  8286.             printf("%s\n",reply);
  8287.             pam_end(pamh, 0);
  8288.             debug(F100,"zvpass denied","",0);
  8289.             pam_pw = NULL;
  8290.             pw = NULL;
  8291.             zvuname[0] = NUL;
  8292.             return(0);
  8293.         }
  8294.         pam_pw = NULL;
  8295.         debug(F110,"zvpass","calling pam_acct_mgmt",0);
  8296.         if ((pam_status = pam_acct_mgmt(pamh, 0)) != PAM_SUCCESS) {
  8297.             reply = pam_strerror(pamh, pam_status);
  8298.             debug(F110,"zvpass PAM failure",reply,0);
  8299.             printf("%s\n",reply);
  8300.             pam_end(pamh, 0);
  8301.             debug(F100,"zvpass denied","",0);
  8302.             pw = NULL;
  8303.             zvuname[0] = NUL;
  8304.             return(0);
  8305.         }
  8306.         debug(F110,"zvpass","PAM validates OK",0);
  8307.         pam_end(pamh,0);
  8308. #else /* CK_PAM */
  8309.         if (pw == NULL)
  8310.           salt = "xx";
  8311.         else
  8312.           salt = pw->pw_passwd;
  8313.  
  8314. #ifdef HPUX10_TRUSTED
  8315.         xpasswd = bigcrypt(p, salt);
  8316. #else
  8317. /*
  8318.   On 64-bit platforms this can give "cast to pointer from integer of
  8319.   different size" warning, but I'm not sure what the effect is at runtime,
  8320.   or what to do about it.
  8321.  */
  8322.         xpasswd = (char *)crypt(p, salt);
  8323. #endif /* HPUX10_TRUSTED */
  8324.  
  8325.         if (
  8326. #ifdef FTP_KERBEROS
  8327.             /* null pw_passwd ok if Kerberos password ok */
  8328.             pw == NULL ||
  8329.             ((*pw->pw_passwd != '\0' ||
  8330.               strcmp(xpasswd, pw->pw_passwd))
  8331.              && !kpass(pw->pw_name, p))
  8332. #else
  8333. #ifdef CK_SRP
  8334.             /* check with tpasswd first if there */
  8335.             pw == NULL || *pw->pw_passwd == '\0' ||
  8336.             t_verifypw (pw->pw_name, p) == 0 ||
  8337.             (t_verifypw (pw->pw_name, p) < 0 &&
  8338.             strcmp (xpasswd, pw->pw_passwd))
  8339. #else /* CK_SRP */
  8340.             /* The strcmp does not catch null passwords! */
  8341.             (pw == NULL) || (*pw->pw_passwd == '\0') ||
  8342.             strcmp(xpasswd, pw->pw_passwd)
  8343. #endif /* CK_SRP */
  8344. #endif /* FTP_KERBEROS */
  8345.             ) {
  8346.             debug(F100,"zvpass denied","",0);
  8347.             pw = NULL;
  8348.             zvuname[0] = NUL;
  8349.             return(0);
  8350.         }
  8351. #endif /* CK_PAM */
  8352.     }
  8353.  
  8354.     (VOID) setgid((GID_T)pw->pw_gid);   /* Set group ID */
  8355.  
  8356. #ifndef NOINITGROUPS
  8357.     (VOID) initgroups(pw->pw_name, pw->pw_gid);
  8358. #endif /* NOINITGROUPS */
  8359.  
  8360.     logged_in = 1;
  8361.     dir = pw->pw_dir;
  8362.  
  8363. #ifdef CKWTMP
  8364.     /* Open wtmp before chroot */
  8365.     if (ckxwtmp) {
  8366.         sprintf(cksysline,"iks_%04x", getpid()); /* safe */
  8367.         logwtmp(cksysline, pw->pw_name,
  8368.                  clienthost ? clienthost : "(unknown host)"
  8369.                 );
  8370.         debug(F110,"WTMP login",cksysline,logged_in);
  8371.     }
  8372. #endif /* CKWTMP */
  8373. /*
  8374.   For anonymous users, we chroot to user ftp's home directory unless
  8375.   started with --anonroot:xxx, in which case we chroot to xxx.  We must
  8376.   immediately chdir() to the same directory we chroot() to or else the
  8377.   old current directory remains accessible as "." outside the new root.
  8378. */
  8379.     if (guest) {
  8380.         if (anonroot)                   /* Non-default anonymous root */
  8381.           dir = anonroot;
  8382.         else
  8383.           makestr(&anonroot,dir);
  8384.         errno = 0;
  8385.         debug(F110,"zvpass anon chroot",dir,0);
  8386.         if (chroot(dir) < 0) {
  8387.             debug(F111,"zvpass anon chroot FAILED",dir,errno);
  8388.             goto bad;
  8389.         }
  8390.         errno = 0;
  8391.         if (chdir("/") < 0) {
  8392.             debug(F111,"zvpass anon chdir FAILED",dir,errno);
  8393.             goto bad;
  8394.         }
  8395.         debug(F110,"zvpass anon chroot/chdir OK",dir,0);
  8396.     } else if (chdir(dir) < 0) {        /* Not guest */
  8397. #ifdef COMMENT
  8398.         if (chdir("/") < 0) {
  8399.             debug(F110,"Non-guest chdir FAILED",dir,0);
  8400.             goto bad;
  8401.         } else
  8402.           printf("?No directory! Logging in with home=/\n");
  8403. #else
  8404.         debug(F110,"zvpass non-guest chdir FAILED",dir,0);
  8405.         goto bad;                       /* Be conservative at first */
  8406. #endif /* COMMENT */
  8407.     }
  8408.     debug(F110,"zvpass non-guest chdir OK",dir,0);
  8409.     if (setuid((UID_T)pw->pw_uid) < 0) {
  8410.         debug(F101,"zvpass setuid FAILED","",pw->pw_uid);
  8411.         goto bad;
  8412.     }
  8413.     debug(F101,"zvpass setuid OK","",pw->pw_uid);
  8414.  
  8415.     guestpass[0] = '\0';
  8416.     if (guest) {
  8417.         extern int fncact;
  8418.         isguest = 1;
  8419.         fncact = XYFX_R;                /* FILE COLLISION = RENAME */
  8420.         debug(F110,"GUEST fncact=R",p,0);
  8421.         lset(guestpass,"anonymous:",10,32);
  8422.         ckstrncpy(&guestpass[10],p,GUESTPASS-10);
  8423.         home = "/";
  8424.         printf("Anonymous login.\r\n");
  8425.  
  8426. #ifdef SETPROCTITLE
  8427.     /* proctitle declared where?  Obviously this code is never compiled. */
  8428.         sprintf(proctitle, "%s: anonymous/%.*s",
  8429.                 clienthost ? clienthost : "(unk)",
  8430.                 sizeof(proctitle) - sizeof(clienthost) -
  8431.                 sizeof(": anonymous/"), p);
  8432.         setproctitle(proctitle);
  8433. #endif /* SETPROCTITLE */
  8434.  
  8435. #ifdef CKSYSLOG
  8436.         if (ckxsyslog && ckxlogging) {
  8437.             syslog(LOG_INFO,
  8438.                    "login: anonymous %s %s",
  8439.                    clienthost ? clienthost : "(unknown host)",
  8440.                    p
  8441.                    );
  8442.         }
  8443. #endif /* CKSYSLOG */
  8444.  
  8445.     } else {                            /* Real user */
  8446.         isguest = 0;
  8447.         home = dir;
  8448.         ckstrncpy(guestpass,zvuname,GUESTPASS);
  8449.  
  8450.         printf("User %s logged in.\r\n", pw->pw_name);
  8451. #ifdef SETPROCTITLE
  8452.     /* not used */
  8453.         sprintf(proctitle, "%s: %s",
  8454.                 clienthost ? clienthost : "(unk)",
  8455.                 pw->pw_name
  8456.                 );
  8457.         setproctitle(proctitle);
  8458. #endif /* SETPROCTITLE */
  8459.  
  8460. #ifdef CKSYSLOG
  8461.         if (ckxsyslog && ckxlogging)
  8462.           syslog(LOG_INFO, "login: %s %s",
  8463.                  pw->pw_name,
  8464.                  clienthost ? clienthost : "(unknown host)"
  8465.                  );
  8466. #endif /* CKSYSLOG */
  8467.     }
  8468.     ckstrncpy(zvhome,home,CKMAXPATH);   /* Set environment variables */
  8469. #ifndef NOPUTENV
  8470.  
  8471.     ckmakmsg(zenvuser,ZENVUSER,"USER=",zvuname,NULL,NULL);
  8472.     putenv((char *)zenvuser);
  8473.     ckmakmsg(zenvlogname,ZENVLOGNAME,"LOGNAME=",zvuname,NULL,NULL);
  8474.     putenv((char *)zenvlogname);
  8475.     ckmakmsg(zenvhome,ZENVHOME,"HOME=",zvhome,NULL,NULL);
  8476.     putenv((char *)zenvhome);
  8477. #endif /* NOPUTENV */
  8478.     /* homdir = (char *)zvhome; */
  8479.     ckstrncpy((char *)uidbuf,(char *)zvuname,64);
  8480.     (VOID) umask(defumask);
  8481. #ifdef IKSDB
  8482.     if (ikdbopen) {
  8483.         char * p2;
  8484.         int k;
  8485.         extern char dbrec[];
  8486.         extern unsigned long myflags;
  8487.         extern unsigned int mydbslot;
  8488.         extern struct iksdbfld dbfld[];
  8489. #ifdef CK_AUTHENTICATION
  8490.         extern unsigned long myamode, myatype;
  8491. #endif /* CK_AUTHENTICATION */
  8492.         myflags |= DBF_LOGGED;
  8493. #ifdef DEBUG
  8494.     if (deblog) {
  8495.         debug(F101,"zvpass guest","",guest);
  8496.         debug(F111,"zvpass zvuname",zvuname,0);
  8497.         debug(F110,"zvpass guestpass",guestpass,0);
  8498.         debug(F110,"zvpass dir",dir,0);
  8499.         debug(F110,"zvpass home",home,0);
  8500.         debug(F110,"zvpass anonroot",anonroot,0);
  8501.     }
  8502. #endif /* DEBUG */
  8503.         p2 = guest ? guestpass : zvuname;
  8504.         if (guest) {
  8505.             p2 = (char *)guestpass;
  8506.             myflags &= ~DBF_USER;
  8507.         } else {
  8508.             p2 = (char *)zvuname;
  8509.             myflags |= DBF_USER;
  8510.         }
  8511.         k = strlen(p2);
  8512.         strncpy(&dbrec[DB_ULEN],ulongtohex((unsigned long)k,4),4);
  8513.         lset(&dbrec[dbfld[db_USER].off],p2,1024,32);
  8514.         strncpy(&dbrec[DB_FLAGS],ulongtohex(myflags,4),4);
  8515. #ifdef CK_AUTHENTICATION
  8516.         myamode = ck_tn_auth_valid();
  8517.         strncpy(&dbrec[DB_AMODE],ulongtohex(myamode,4),4);
  8518.         myatype = ck_tn_authenticated();
  8519.         strncpy(&dbrec[DB_ATYPE],ulongtohex(myatype,4),4);
  8520. #endif /* CK_AUTHENTICATION */
  8521.         if (guest) {
  8522.             p2 = dir;
  8523.         } else {
  8524.             p2 = zgtdir();
  8525.             if (!p2) p2 = "";
  8526.             if (!*p2) p2 = home;
  8527.         }
  8528.         strncpy(&dbrec[DB_DLEN],
  8529.                 ulongtohex((unsigned long)strlen(p2),4),
  8530.                 4
  8531.                 );
  8532.         lset(&dbrec[dbfld[db_DIR].off],p2,1024,32);
  8533.         updslot(mydbslot);
  8534.     }
  8535. #endif /* IKSDB */
  8536.     return(1);
  8537.  
  8538. bad:                                    /* Common failure exit */
  8539.     zvuname[0] = NUL;
  8540.     zvlogout();
  8541.     return(0);
  8542. }
  8543. #endif /* CK_LOGIN */
  8544.  
  8545. /* Buggy Xenix 2.3.4 cc needs this line after the endif */
  8546.