home *** CD-ROM | disk | FTP | other *** search
/ Columbia Kermit / kermit.zip / old / ckermit5a190 / cklfio.c < prev    next >
C/C++ Source or Header  |  2020-01-01  |  67KB  |  2,420 lines
  1. #include "ckcsym.h"
  2. char *ckzv = "Stratus VOS File support, 5A(003) 28 Aug 1994";
  3.  
  4. /* C K L F I O  --  Kermit file system support for Stratus VOS */
  5.  
  6. /*
  7.   Author: Frank da Cruz (fdc@columbia.edu, FDCCU@CUVMA.BITNET),
  8.   Columbia University Center for Computing Activities.
  9.   First released January 1985.
  10.   Copyright (C) 1985, 1992, Trustees of Columbia University in the City of New
  11.   York.  Permission is granted to any individual or institution to use this
  12.   software as long as it is not sold for profit.  This copyright notice must be
  13.   retained.  This software may not be included in commercial products without
  14.   written permission of Columbia University.
  15. */
  16.  
  17. /* Include Files */
  18.  
  19. #include "ckcdeb.h"
  20. #include <signal.h>
  21. #include <limits.h>
  22.  
  23. #define DIRSEP       '>'
  24. #define ISDIRSEP(c)  ((c)=='>'||(c)=='<')
  25.  
  26. #include <stdlib.h>
  27. #include <time.h>            /* Need this */
  28. #include <system_io_constants.h>
  29. #include <get_port_info.h>
  30. #include <file_status_info.h>
  31. #include <error_codes.h>
  32.  
  33. extern int binary;            /* We need to know this for open() */
  34.  
  35.  
  36. /*
  37.   Functions (n is one of the predefined file numbers from ckcker.h):
  38.  
  39.    zopeni(n,name)   -- Opens an existing file for input.
  40.    zopeno(n,name,attr,fcb) -- Opens a new file for output.
  41.    zclose(n)        -- Closes a file.
  42.    zchin(n,&c)      -- Gets the next character from an input file.
  43.    zsinl(n,&s,x)    -- Read a line from file n, max len x, into address s.
  44.    zsout(n,s)       -- Write a null-terminated string to output file, buffered.
  45.    zsoutl(n,s)      -- Like zsout, but appends a line terminator.
  46.    zsoutx(n,s,x)    -- Write x characters to output file, unbuffered.
  47.    zchout(n,c)      -- Add a character to an output file, unbuffered.
  48.    zchki(name)      -- Check if named file exists and is readable, return size.
  49.    zchko(name)      -- Check if named file can be created.
  50.    zchkspa(name,n)  -- Check if n bytes available to create new file, name.
  51.    znewn(name,s)    -- Make a new unique file name based on the given name.
  52.    zdelet(name)     -- Delete the named file.
  53.    zxpand(string)   -- Expands the given wildcard string into a list of files.
  54.    znext(string)    -- Returns the next file from the list in "string".
  55.    zxcmd(n,cmd)     -- Execute the command in a lower fork on file number n.
  56.    zclosf()         -- Close input file associated with zxcmd()'s lower fork.
  57.    zrtol(n1,n2)     -- Convert remote filename into local form.
  58.    zltor(n1,n2)     -- Convert local filename into remote form.
  59.    zchdir(dirnam)   -- Change working directory.
  60.    zhome()          -- Return pointer to home directory name string.
  61.    zkself()         -- Kill self, log out own job.
  62.    zsattr(struct zattr *) -- Return attributes for file which is being sent.
  63.    zstime(f, struct zattr *, x) - Set file creation date from attribute packet.
  64.    zrename(old, new) -- Rename a file.
  65.    zmkdir(path)      -- create a directory
  66.    isdir(path)       -- is this path a directory?
  67.    zfseek(offset)    -- position input file to offset (zero-based)
  68.  */
  69.  
  70. /* Kermit-specific includes */
  71. /*
  72.   Definitions here supersede those from system include files.
  73.   ckcdeb.h is included above.
  74. */
  75. #include "ckcker.h"            /* Kermit definitions */
  76. #include "ckucmd.h"            /* For sys-dependent keyword tables */
  77. #include "ckuver.h"            /* Version herald */
  78.  
  79. char *ckzsys = HERALD;
  80.  
  81. /* Definitions of some system commands */
  82.  
  83. char *DELCMD = "!delete_file ";        /* For file deletion */
  84. char *PWDCMD = "!display_current_dir ";    /* For saying where I am */
  85. char *TYPCMD = "!display ";        /* For typing a file */
  86. char *DIRCMD = "!list -full -files -dirs -links ";/* For directory listing */
  87.                     /* For directory listing, no args */
  88. char *DIRCM2 = "!list -full -files -dirs -links ";
  89. char *WHOCMD = "!list_users -process login ";/* Who's there? */
  90. char *SPACMD = "!display_disk_info ";    /* For space on disk */
  91. char *SPACM2 = "!display_disk_info -long ";    /* For space on disk */
  92.  
  93. #ifdef DTILDE                /* For tilde expansion */
  94. _PROTOTYP( char * tilde_expand, (char *) );
  95. #endif /* DTILDE */
  96.  
  97. _PROTOTYP( vostty, (int) );
  98.  
  99. /* Prototypes for VOS s$calls */
  100.  
  101. _PROTOTYP( extern VOID s$attach_default_output, (CV(256) *path,
  102.     short *append, short *status) );
  103.  
  104. _PROTOTYP( extern VOID s$attach_port, (CV(32) *port_name, CV(256)* path,
  105.     short *hold, short *port_id, short *status) );
  106.  
  107. _PROTOTYP( extern VOID s$clone, (short *status, CV(256) *err_msg) );
  108.  
  109. _PROTOTYP( extern VOID s$close, (short *port_id, short *status) );
  110.  
  111. _PROTOTYP( extern VOID s$delete_file_on_close, (CV(256) *path,
  112.     short *status) );
  113.  
  114. _PROTOTYP( extern VOID s$create_dir, (CV(256) *path, short *status) );
  115.  
  116. _PROTOTYP( extern VOID s$cv_to_int_date_time, (CV(32) *src_time,
  117.     time_t *time, short *status) );
  118.  
  119. _PROTOTYP( extern VOID s$detach_default_output, (short *status) );
  120.  
  121. _PROTOTYP( extern VOID s$detach_port, (short *port_id, short *status) );
  122.  
  123. _PROTOTYP( extern VOID s$get_current_dir, (CV(256) *dir) );
  124.  
  125. _PROTOTYP( extern VOID s$get_disk_info, (CV(66) *disk_name, VOID *info,
  126.     short *status) );
  127.  
  128. _PROTOTYP( extern VOID s$get_file_status, (CV(256) *path, VOID *info,
  129.     short *status) );
  130.  
  131. _PROTOTYP( extern VOID s$get_home_dir, (CV(256) *dir) );
  132.  
  133. _PROTOTYP( extern void s$get_object_type, (CV(256) *path, short *chase,
  134.     short *type, short *status) );
  135.  
  136. _PROTOTYP( extern VOID s$get_port_info, (short *port,
  137.     struct get_port_info *pinfo, short *status) );
  138.  
  139. _PROTOTYP( extern VOID s$get_temp_file, (short *organization,
  140.     short *max_rec_len, CV(256) *path, short *status) );
  141.  
  142. _PROTOTYP( extern VOID s$get_user_name, (CV(65) *name) ); 
  143.  
  144. _PROTOTYP( extern VOID s$expand_path, (CV(256) *src_path, CV(32) *suffix,
  145.     CV(256) *dest_path, short *status) ); 
  146.  
  147. _PROTOTYP( extern VOID s$expand_star, (CV(256) *star_name, short *flags,
  148.     short *max_count, short *count, VOID *dest, short *status) );
  149.  
  150. _PROTOTYP( extern VOID s$open, (short *port_id, short *organization,
  151.     short *max_rec_len, short *io_type, short *locking_type,
  152.     short *access_mode, CV(32) *index_name, short *status) );
  153.  
  154. _PROTOTYP( extern VOID s$read_raw, (short *port_id, short *buff_size,
  155.     short *rec_len, void *buffer, short *status) );
  156.  
  157. _PROTOTYP( extern VOID s$seq_open, (CV(256) *path, short *io_type,
  158.     short *port_id, short *status) );
  159.  
  160. _PROTOTYP( extern VOID s$seq_position,  (short *port_id, short *relation,
  161.     long *rec_number, short *status) );
  162.  
  163. _PROTOTYP( extern VOID s$seq_read, (short *port_id, short *buff_size,
  164.     short *rec_len, VOID *buffer, short *status) );
  165.  
  166. _PROTOTYP( extern VOID s$seq_write, (short *port_id, short *rec_length,
  167.     VOID *buffer, short *status) );
  168.  
  169. _PROTOTYP( extern VOID s$seq_write_partial, (short *port_id,
  170.     short *rec_length, VOID *buffer, short *status) );
  171.  
  172. _PROTOTYP( extern VOID s$set_expiration_date, (CV(256) *path_name,
  173.     time_t *date_time, short *status) );
  174.  
  175. _PROTOTYP( extern VOID s$set_object_times, (CV(256) *path_name,
  176.     time_t *time_array, short *status) ); /* four times in array */
  177.  
  178. _PROTOTYP( extern VOID s$write_raw, (short *port_id, short *length,
  179.     void *buffer, short *status) );
  180.  
  181. /* Define maximum length for a file name if not already defined */
  182.  
  183. #ifndef MAXNAMLEN
  184. #define MAXNAMLEN 32
  185. #endif /* MAXNAMLEN */
  186.  
  187. /* Longest pathname */
  188.  
  189. #ifdef MAXPATHLEN
  190. #ifdef MAXPATH
  191. #undef MAXPATH
  192. #endif /* MAXPATH */
  193. #define MAXPATH MAXPATHLEN
  194. #else
  195. #ifdef PATH_MAX
  196. #define MAXPATH PATH_MAX
  197. #else
  198. #define MAXPATH 256
  199. #endif /* PATH_MAX */
  200. #endif /* MAXPATHLEN */
  201.  
  202. /* Maximum number of filenames for wildcard expansion */
  203.  
  204. /* VOS directories can be up to 256 data blocks.  This is about 5000 entries */
  205. /* but it can vary a lot, depending on a number of factors, such as the      */
  206. /* lengths of the names, whether or not Access Control Lists are present,    */
  207. /* and so on.  This is about the most you get, in practice, though.          */
  208.  
  209. #define MAXWLD 5000
  210.  
  211. struct path {
  212.     char npart[MAXNAMLEN+4];        /* name part of path segment */
  213.     struct path *fwd;            /* forward ptr */
  214. };
  215.  
  216. _PROTOTYP( int shxpand, (char *, char *[], int ) );
  217.  
  218.  
  219. /* Declarations */
  220.  
  221. int maxnam = MAXNAMLEN;            /* Available to the outside */
  222. int maxpath = MAXPATH;
  223.  
  224. typedef struct {
  225.     short port;
  226.     short io_type;
  227.     short binary;
  228.     short organization;
  229.     short max_record_len;
  230.     short record_len;
  231.     short buffer_size;
  232.     short buffer_pointer;
  233.     short count;
  234.     short count_invalid;
  235.     char  *buffer;
  236. } VFILE;
  237.  
  238. VFILE *fp[ZNFILS] = {             /* File pointers */
  239.     NULL, NULL, NULL, NULL, NULL, NULL, NULL };
  240.  
  241. /* There is not a Stratus-provided include for this.  I typed it in from
  242.  * the VOS C subroutines manual, R068, under s$get_disk_info.
  243.  */
  244.  
  245. struct disk_info {
  246.     short     version;
  247.     CV(32)     module_name;
  248.     long    file_partition_size;
  249.     long    file_partition_used;
  250.     long    page_partition_size;
  251.     long    page_partition_used;
  252.     CV(32)    disk_type;
  253.     long    disk_size;
  254.     short    reserved1[19];
  255.     long    disk_reads;
  256.     long    disk_writes;
  257.     short    reserved2;
  258.     short    recovery_switches;
  259.     long    reserved3;
  260.     short    number_of_members;
  261.     long    fatal_errors;
  262.     long    reserved4;
  263. };
  264.  
  265. /* Buffers and pointers used in buffered file input and output. */
  266. #ifdef DYNAMIC
  267. extern char *zinbuffer, *zoutbuffer;
  268. #else
  269. extern char zinbuffer[], zoutbuffer[];
  270. #endif /* DYNAMIC */
  271. extern char *zinptr, *zoutptr;
  272. extern int zincnt, zoutcnt;
  273. extern int wildxpand;
  274.  
  275. extern UID_T real_uid();
  276.  
  277. static long iflen = -1L;        /* Input file length */
  278.  
  279. static PID_T pid = 0;            /* pid of child fork */
  280. static int fcount;            /* Number of files in wild group */
  281. static char nambuf[MAXPATH+4];         /* Buffer for a filename */
  282. #ifndef NOFRILLS
  283. static char zmbuf[200];            /* For mail, remote print strings */
  284. #endif /* NOFRILLS */
  285.  
  286. /* static */                /* Not static, must be global now. */
  287. int  oldmtchs;                /* number of matches in last expand */
  288. char *mtchs[MAXWLD],            /* Matches found for filename */
  289.      **mtchptr;                /* Pointer to current match */
  290.  
  291. /*  Z K S E L F  --  Kill Self: log out own job, if possible.  */
  292.  
  293. int
  294. zkself() {                /* For "bye", but no guarantee! */
  295.     debug(F100,"zkself","",0);
  296.     exit(0);
  297.     /*NOTREACHED*/
  298. }
  299.  
  300. /*  Z O P E N I  --  Open an existing file for input. */
  301.  
  302. int
  303. zopeni(n,name) int n; char *name; {
  304.     CV(256) path;
  305.     CV(256) src_path;
  306.     CV(32) suffix;
  307.     FILE_STATUS_STRUCT finfo;
  308.     short status;
  309.  
  310.     debug(F111," zopeni",name,n);
  311.     debug(F101,"  fp","", fp[n]);
  312.     if (chkfn(n) != 0) return(0);
  313.     zincnt = 0;                /* Reset input buffer */
  314.  
  315.     if (fp[n])                /* make sure it's closed */
  316.     zclose(n);
  317.  
  318.  if (n == ZSYSFN) {            /* Input from a system function? */
  319. /*** Note, this function should not be called with ZSYSFN ***/
  320. /*** Always call zxcmd() directly, and give it the real file number ***/
  321. /*** you want to use.  ***/
  322.         debug(F110,"zopeni called with ZSYSFN, failing!",name,0);
  323.     *nambuf = '\0';            /* No filename. */
  324.     return(0);            /* fail. */
  325.     }
  326.     if (n == ZSTDIO) {            /* Standard input? */
  327.     if (vostty(DEFAULT_INPUT_PORT_ID)) {
  328.         fprintf(stderr,"Terminal input not allowed");
  329.         debug(F100,"zopeni: attempts input from unredirected stdin","",0);
  330.         *nambuf = '\0';        /* No filename. */
  331.         return(0);
  332.     }
  333.  
  334.     return(1);
  335.     }
  336.  
  337. #ifdef COMMENT
  338.     *nambuf = '\0';            /* Forget filename */
  339. #endif /* COMMENT */
  340.  
  341.     strcpy (&src_path, name);
  342.     strcpy (&suffix, "");
  343.     s$expand_path (&src_path, &suffix, &path, &status);
  344.     if (status) {
  345.     debug(F101,"  zopeni s$expand_path status","",status);
  346.     return 0;
  347.     }
  348.  
  349.     finfo.version = FILE_STAT_VERSION_5;
  350.     s$get_file_status (&path, &finfo, &status);
  351.     if (status) {
  352.     debug(F101,"zopeni s$get_file_status status","",status);
  353.     return 0;
  354.     }
  355.  
  356.     switch (finfo.file_organization) {
  357.     case SEQUENTIAL_FILE:
  358.     case STREAM_FILE:
  359.         iflen = finfo.last_record_number;
  360.         break;
  361.  
  362.     case FIXED_FILE:
  363.         iflen = finfo.last_record_number * 
  364.         finfo.flags_struct.flags_bits_overlay.max_record_size;
  365.         break;
  366.  
  367.     case RELATIVE_FILE:
  368.         iflen = finfo.last_record_number * 
  369.         (finfo.flags_struct.flags_bits_overlay.max_record_size + 2);
  370.         break;
  371.  
  372.     default:    /* uhhhh.... */
  373.         iflen = -1L;
  374.         break;
  375.     }
  376.  
  377.     fp[n] = calloc (1, sizeof (**fp));
  378.     debug(F111," zopeni allocated", name, fp[n]);
  379.     if (fp[n] == NULL) {
  380.     debug(F101,"  zopeni could not allocate fp","",sizeof **fp);
  381.     perror("zopeni");
  382.     return 0;
  383.     }
  384.  
  385.     /* CANNOT RETURN AFTER HERE WITHOUT FREEING MEMORY */
  386.  
  387.     fp[n]->organization = finfo.file_organization;
  388.     fp[n]->max_record_len
  389.     = finfo.flags_struct.flags_bits_overlay.max_record_size;
  390.  
  391.     fp[n]->buffer_size = fp[n]->max_record_len ? fp[n]->max_record_len : 4096;
  392.     fp[n]->buffer = calloc (1, fp[n]->buffer_size);
  393.  
  394.     if (NULL == fp[n]->buffer) {
  395.     debug(F101,"zopeni cannot allocate buffer","",fp[n]->buffer_size);
  396.     free (fp[n]);
  397.     fp[n] = NULL;
  398.     return 0;
  399.     }
  400.  
  401.     fp[n]->io_type = INPUT_TYPE;
  402.     s$seq_open (&path, &fp[n]->io_type, &fp[n]->port, &status);
  403.     if (status) {
  404.     debug(F101,"zopeni s$seq_open status","",status);
  405.     free (fp[n]);
  406.     fp[n] = NULL;
  407.     free (fp[n]->buffer);
  408.     return 0;
  409.     }
  410.  
  411. #ifdef COMMENT
  412.     strcpy (nambuf, name);        /* save filename */
  413. #endif /* COMMENT */
  414.     fp[n]->binary = binary;         /* remember this */
  415.     fp[n]->count_invalid = 1;        /* have no buffered data yet */
  416.     return(1);
  417. }
  418.  
  419. /*  Z O P E N O  --  Open a new file for output.  */
  420.  
  421. int
  422. zopeno(n,name,zz,fcb)
  423. /* zopeno */  int n; char *name; struct zattr *zz; struct filinfo *fcb; {
  424.     short io_type;
  425.     short org;
  426.     short record_len;
  427.     short port = 0;
  428.     CV(256) path;
  429.     CV(256) src_path;
  430.     CV(32) suffix;
  431.     CV(32) index;
  432.     CV(32) portnam;
  433.     short lockmod;
  434.     short access;
  435.     short hold;
  436.     FILE_STATUS_STRUCT finfo;
  437.     short status;
  438.     int  is_binary = 0;
  439.  
  440. /* As of Version 5A, the attribute structure and the file information */
  441. /* structure are included in the arglist. */
  442.  
  443.     if (n != ZDFILE) {
  444.     debug(F111," zopeno",name,n);
  445.     if (fcb) {
  446.         debug(F101,"zopeno fcb disp","",fcb->dsp);
  447.         debug(F101,"zopeno fcb type","",fcb->typ);
  448.         debug(F101,"zopeno fcb char","",fcb->cs);
  449.     } else {
  450.         debug(F100,"zopeno fcb is NULL","",0);
  451.     }
  452.     }
  453.  
  454.     if (chkfn(n) != 0)
  455.     return(0);
  456.  
  457.     io_type = OUTPUT_TYPE;
  458.  
  459.     if (fcb) {                /* If called with an FCB... */
  460.     if (fcb->typ == XYFT_T)        /* Does it say Text? */
  461.         is_binary = 0;        /* Yes, not binary. */
  462.     else
  463.         is_binary = 1;        /* No, it is binary. */
  464.     }
  465.     else {
  466.     switch (n) {
  467.         case ZOFILE:
  468.         case ZWFILE:
  469.         case ZMFILE:
  470.         is_binary = binary;    /* Use current file mode */
  471.         break;
  472.  
  473.         case ZDFILE:
  474.         case ZTFILE:
  475.         case ZSYSFN:
  476.         case ZCTERM:
  477.         case ZSTDIO:
  478.         is_binary = 0;        /* Always text */
  479.         break;
  480.  
  481.         case ZSFILE:
  482.         is_binary = 1;        /* Always binary */
  483.         break;
  484.  
  485.     }
  486.     }
  487.  
  488.     if ((n != ZCTERM) && (n != ZSTDIO)) {  /* Terminal or standard output */
  489.  
  490.     /* A real file.  Open it in desired mode (create or append). */
  491.  
  492.     if (fcb) {                /* If called with an FCB... */
  493.         if (fcb->dsp == XYFZ_A)        /* Does it say Append? */
  494.           io_type = APPEND_TYPE;    /* Yes. */
  495.     }
  496.  
  497.     strcpy (&src_path, name);
  498.     strcpy (&suffix, "");
  499.     s$expand_path (&src_path, &suffix, &path, &status);
  500.     if (status) {
  501.         if (n != ZDFILE)
  502.         debug(F101,"  zopeno s$expand_path status","",status);
  503.         return 0;
  504.     }
  505.  
  506.     finfo.version = FILE_STAT_VERSION_5;
  507.     s$get_file_status (&path, &finfo, &status);
  508.     if (status) {
  509.         if (status != e$object_not_found) {
  510.         if (n != ZDFILE)
  511.             debug(F101,"zopeno s$get_file_status status","",status);
  512.         return 0;
  513.         }
  514.  
  515.         /* the session log is a stream file, because that reflects */
  516.         /* the "log of data sent back and forth" better            */
  517.  
  518.         org = (is_binary) ? STREAM_FILE : SEQUENTIAL_FILE;
  519.         record_len = 4096;
  520.     }
  521.     else {
  522.         org = finfo.file_organization;
  523.         record_len = finfo.flags_struct.flags_bits_overlay.max_record_size;
  524.     }
  525.     }
  526.     else {    /* it is a "terminal" */
  527.     n = ZOFILE;        /* change to output file */
  528.     org = TERMINAL_TYPE;
  529.     record_len = 4096;
  530.     port = DEFAULT_OUTPUT_PORT_ID;
  531.         debug(F101," zopen terminal, ZOFILE", "", n);
  532.     }
  533.  
  534.     fp[n] = calloc (1, sizeof (**fp));
  535.     if (n != ZDFILE)
  536.     debug(F111," zopeno allocated", name, fp[n]);
  537.     if (fp[n] == NULL) {
  538.     if (n != ZDFILE)
  539.         debug(F101,"  zopeno could not allocate fp","",sizeof **fp);
  540.     perror("zopeno");
  541.     return 0;
  542.     }
  543.  
  544.     /* CANNOT RETURN AFTER HERE WITHOUT FREEING MEMORY */
  545.  
  546.     fp[n]->max_record_len = record_len;
  547.     fp[n]->buffer_size = fp[n]->max_record_len ? fp[n]->max_record_len : 4096;
  548.     fp[n]->buffer = calloc (1, fp[n]->buffer_size);
  549.  
  550.     if (NULL == fp[n]->buffer) {
  551.     if (n != ZDFILE)
  552.         debug(F101,"zopeno cannot allocate buffer","",fp[n]->buffer_size);
  553.     free (fp[n]);
  554.     fp[n] = NULL;
  555.     return 0;
  556.     }
  557.  
  558.     /* save pre-calculated information */
  559.  
  560.     fp[n]->io_type = io_type;
  561.     fp[n]->organization = org;
  562.     fp[n]->port = port;
  563.     fp[n]->binary = is_binary;        /* save this! */
  564.  
  565.     if (0 == fp[n]->port) {  /* not set yet */
  566.     strcpy (&portnam, "");
  567.     hold = DONT_HOLD;
  568.     s$attach_port (&portnam, &path, &hold, &fp[n]->port, &status);
  569.     if (status) {
  570.         if (n != ZDFILE)
  571.         debug(F101,"zopeno s$attach_port status","",status);
  572.         free (fp[n]->buffer);
  573.         free (fp[n]);
  574.         fp[n] = NULL;
  575.         return 0;
  576.     }
  577.  
  578.     lockmod = IMPLICIT_LOCKING;
  579.     access = SEQUENTIAL_MODE;
  580.     strcpy (&index, "");
  581.     s$open (&fp[n]->port, &fp[n]->organization, &fp[n]->max_record_len,
  582.         &fp[n]->io_type, &lockmod, &access, &index, &status);
  583.     if (status) {
  584.         if (n != ZDFILE)
  585.         debug(F101,"zopeno s$open status","",status);
  586.         free (fp[n]->buffer);
  587.         free (fp[n]);
  588.         fp[n] = NULL;
  589.         return 0;
  590.     }
  591.     }
  592.  
  593.     zoutcnt = 0;            /* (PWP) reset output buffer */
  594.     zoutptr = zoutbuffer;
  595.     return((fp[n] != NULL) ? 1 : 0);
  596. }
  597.  
  598. /*  Z C L O S E  --  Close the given file.  */
  599.  
  600. /*  Returns 0 if arg out of range, 1 if successful, -1 if close failed.  */
  601.  
  602. int
  603. zclose(n) int n; {
  604.     int x, x2;
  605.     short status;
  606.  
  607.     if (chkfn(n) < 1) return(0);    /* Check range of n */
  608.  
  609.     debug(F101,"zclose file","",n);
  610.  
  611.     if ((n == ZOFILE) && (zoutcnt > 0))    /* (PWP) output leftovers */
  612.       x2 = zoutdump();
  613.     else
  614.       x2 = 0;
  615.  
  616.     x = 0;                /* Initialize return code */
  617.     if (fp[ZSYSFN]) {            /* If file is really pipe */
  618.         x = zclosf(n);            /* do it specially */
  619.     } else {
  620.     if (fp[n]->port > MAX_RESERVED_PORT_ID) { /* only close user ports */
  621.         s$close (&fp[n]->port, &status);
  622.         x = status ? EOF : 0;
  623.         s$detach_port (&fp[n]->port, &status);
  624.         x = (status || x) ? EOF : 0;
  625.     }
  626.     else
  627.         x = 0;
  628.     free (fp[n]->buffer);
  629.     free (fp[n]);
  630.     fp[n] = NULL;
  631.     }
  632.  
  633.     iflen = -1L;            /* Invalidate file length */
  634.  
  635.     if (x == EOF)            /* if we got a close error */
  636.       return(-1);
  637.     else if (x2 < 0)        /* or an error flushing the last buffer */
  638.       return(-1);        /* then return an error */
  639.     else
  640.       return(1);
  641. }
  642.  
  643. /*  Z C H I N  --  Get a character from the input file.  */
  644.  
  645. /*  Returns -1 if EOF, 0 otherwise with character returned in argument  */
  646.  
  647. int
  648. zchin(n,c) int n; int *c; {
  649.     int a, x;
  650.     register VFILE *vp;
  651.     short status;
  652.     short rbuffsize;
  653.  
  654.     /* (PWP) Just in case this gets called when it shouldn't. */
  655.     if (n == ZIFILE) {
  656.     x = zminchar();
  657.     *c = x;
  658.     return((x < 0) ? -1 : 0);
  659.     }
  660.  
  661.     if (chkfn(n) < 1) return(-1);
  662.     vp = fp[n];
  663.  
  664.     if (vp->count_invalid) {    /* need to read more data */
  665.  
  666.     debug(F101,"zchin reading file","",n);
  667.  
  668.     if (!vp->binary) { /* text mode, add appropriate line separators */
  669.  
  670.         rbuffsize = vp->buffer_size - 1;
  671.         /* leave room for line terminator character(s) */
  672.  
  673. #ifndef NLCHAR
  674.         rbuffsize--;
  675. #endif /* NLCHAR */
  676.  
  677.         s$seq_read (&vp->port, &rbuffsize, &vp->record_len,
  678.         vp->buffer, &status);
  679.  
  680.         if (0 != status) {
  681.         debug(F101,"zchin text s$seq_read status","",status);
  682.         return (-1); /* hope it's end of file... */
  683.         }
  684. #ifdef NLCHAR
  685.         vp->buffer[vp->record_len++] = NLCHAR;
  686. #else
  687.         vp->buffer[vp->record_len++] = '\r';
  688.         vp->buffer[vp->record_len++] = '\n';
  689. #endif /* NLCHAR */
  690.     }
  691.     else {        /* binary */
  692.         if (vp->organization == STREAM_FILE) {
  693.         s$read_raw (&vp->port, &vp->buffer_size, &vp->record_len,
  694.             vp->buffer, &status);
  695.         if (status == e$short_record) /* not buffer_size bytes left */
  696.             status = 0;
  697.         }
  698.         else
  699.         s$seq_read (&vp->port, &vp->buffer_size, &vp->record_len,
  700.             vp->buffer, &status);
  701.  
  702.         if (0 != status) {
  703.         debug(F101,"zchin binary s$...read... status","",status);
  704.         return (-1); /* hope it's end of file... */
  705.         }
  706.         }
  707.     /* set up for character stuff... */
  708.     vp->count = vp->record_len;
  709.     vp->buffer_pointer = 0;
  710.     vp->count_invalid = 0;
  711.     }
  712.     /* count is valid */
  713.  
  714.     x = vp->buffer[vp->buffer_pointer++];
  715.     if (0 >= --(vp->count))
  716.     vp->count_invalid = 1;
  717.  
  718.     *c = x;
  719.     return((x < 0) ? -1 : 0);
  720. }
  721.  
  722. /*  Z S I N L  --  Read a line from a file  */
  723.  
  724. /*
  725.   Writes the line into the address provided by the caller.
  726.   n is the Kermit "channel number".
  727.   Writing terminates when newline is encountered, newline is not copied.
  728.   Writing also terminates upon EOF or if length x is exhausted.
  729.   Returns 0 on success, -1 on EOF or error.
  730. */
  731. int
  732. zsinl(n,s,x) int n, x; char *s; {
  733.     int a, z = 0;            /* z is return code. */
  734.  
  735.     if (chkfn(n) < 1) {            /* Make sure file is open */
  736.     return(-1);
  737.     }
  738.     a = -1;                /* Current character, none yet. */
  739.     while (x--) {            /* Up to given length */
  740. #ifndef NLCHAR
  741.     int old;
  742.     old = a;            /* Previous character */
  743. #endif
  744.     if (zchin(n,&a) < 0) {        /* Read a character from the file */
  745.         debug(F101,"zsinl","",a);
  746.         z = -1;            /* EOF or other error */
  747.         break;
  748.     }
  749. #ifdef NLCHAR
  750.     if (a == (char) NLCHAR) break;    /* Single-character line terminator */
  751. #else
  752.     if (a == '\015') continue;    /* CR, get next character */
  753.     if (old == '\015') {        /* Previous character was CR */
  754.         if (a == '\012') break;    /* This one is LF, so we have a line */
  755.         else *s++ = '\015';        /* Not LF, deposit CR */
  756.     }
  757. #endif /* NLCHAR */
  758.     *s = a;                /* Deposit character */
  759.     s++;
  760.     }
  761.     *s = '\0';                /* Terminate the string */
  762.     return(z);
  763. }
  764.  
  765. /*
  766.  * (PWP) (re)fill the buffered input buffer with data.  All file input
  767.  * should go through this routine, usually by calling the zminchar()
  768.  * macro (in ckcker.h).
  769.  */
  770.  
  771. /*
  772.  * Suggestion: if fread() returns 0, call ferror to find out what the
  773.  * problem was.  If it was not EOF, then return -2 instead of -1.
  774.  * Upper layers (getpkt function in ckcfns.c) should set cxseen flag
  775.  * if it gets -2 return from zminchar macro.
  776.  *
  777.  * This always uses zin* buffering for io, not fp->buffer.
  778.  */
  779. int
  780. zinfill() {
  781.     int x;
  782.     short status;
  783.     short buff_len;
  784.     VFILE *vp = fp[ZIFILE];
  785.  
  786.     errno = 0;
  787.     buff_len = INBUFSIZE;
  788.     
  789.     /* leave room for line terminators in text mode */
  790.     if (0 == vp->binary)
  791. #ifdef NLCHAR
  792.     buff_len -= 1;
  793. #else
  794.     buff_len -= 2;
  795. #endif /* NLCHAR */
  796.  
  797.     if (vp->binary && vp->organization == STREAM_FILE)
  798.     s$read_raw (&vp->port, &buff_len, &vp->record_len, zinbuffer, &status);
  799.     else
  800.     s$seq_read (&vp->port, &buff_len, &vp->record_len, zinbuffer, &status);
  801.  
  802.     zincnt = vp->record_len;
  803.  
  804.     debug(F101,"zinfill zincnt","",zincnt);
  805.     if (status) {
  806.     debug(F101,"zinfill s$...read... status","",status);
  807.     return (status == e$end_of_file) ? (-1) : (-2);
  808.     }
  809.  
  810.     if (0 == vp->binary) { /* text mode, add a NLCHAR to it */
  811. #ifdef NLCHAR
  812.     zinbuffer[zincnt++] = NLCHAR;
  813. #else
  814.     zinbuffer[zincnt++] = '\r';
  815.     zinbuffer[zincnt++] = '\n';
  816. #endif
  817.     }
  818.  
  819.     zinptr = zinbuffer;    /* set pointer to beginning, (== &zinbuffer[0]) */
  820.     zincnt--;        /* one less char in buffer */
  821.     return((int)(*zinptr++) & 0377); /* because we return the first */
  822. }
  823.  
  824. /*  Z S O U T  --  Write a string out to the given file, buffered.  */
  825.  
  826. int
  827. zsout(n,s) int n; char *s; {
  828.     short status;
  829.     int len;
  830.  
  831.     if (chkfn(n) < 1) return(-1); /* Keep this here, prevents memory faults */
  832.     if (n != ZDFILE)
  833.     debug(F111,"zsout writing to file",s,n);
  834.  
  835.     len = strlen (s);
  836.     if ('\n' == s[len-1]) {
  837.     s[--len] = '\0';
  838.     return (zsoutl (n,s));
  839.     }
  840.  
  841.     fp[n]->record_len = (short) strlen(s);
  842.     /* since this never writes an end-of-line, always write partial */
  843.     if (fp[n]->organization == STREAM_FILE && fp[n]->binary)
  844.     s$write_raw (&fp[n]->port, &fp[n]->record_len, s, &status);
  845.     else
  846.     s$seq_write_partial (&fp[n]->port, &fp[n]->record_len, s, &status);
  847.  
  848.     return status ? (-1) : 0;
  849. }
  850.  
  851. /*  Z S O U T L  --  Write string to file, with line terminator, buffered  */
  852.  
  853. int
  854. zsoutl(n,s) int n; char *s; {
  855.     short status;
  856.     int len;
  857.  
  858.     if (chkfn(n) < 1) return(-1);
  859.     if (n != ZDFILE)
  860.     debug(F111,"zsoutl writing to file",s,n);
  861.  
  862.     len = strlen (s);
  863.     if ('\n' == s[len-1])
  864.     len--;
  865.  
  866.     fp[n]->record_len = len;
  867.     /* adding a record terminator, means always use seq_write... */
  868.  
  869.     s$seq_write (&fp[n]->port, &fp[n]->record_len, s, &status);
  870.     return status ? (-1) : 0;
  871. }
  872.  
  873. /*  Z S O U T X  --  Write x characters to file, unbuffered.  
  874.  *  returns -1 on error, or the number of characters written.
  875.  */
  876.  
  877. int
  878. zsoutx(n,s,x) int n, x; char *s; {
  879.     short status;
  880.  
  881.     if (chkfn(n) < 1) return(-1);
  882.     if (n != ZDFILE)
  883.     debug(F101,"zsoutx writing to file","",n);
  884.     fp[n]->record_len = x;
  885.  
  886.     if (fp[n]->binary) {
  887.     if (fp[n]->organization == STREAM_FILE)
  888.         s$write_raw (&fp[n]->port, &fp[n]->record_len, s, &status);
  889.     else
  890.         s$seq_write_partial (&fp[n]->port, &fp[n]->record_len, s, &status);
  891.     }
  892.     else
  893.     s$seq_write (&fp[n]->port, &fp[n]->record_len, s, &status);
  894.  
  895.     return((status == 0) ? x : -1);
  896. }
  897.  
  898.  
  899. /*  Z C H O U T  --  Add a character to the given file.  */
  900.  
  901. /*  Should return 0 or greater on success, -1 on failure (e.g. disk full)  */
  902.  
  903. int
  904. #ifdef CK_ANSIC
  905. zchout(register int n, char c)
  906. #else
  907. zchout(n,c) register int n; char c;
  908. #endif /* CK_ANSIC */
  909. /* zchout() */ {
  910.     short status;
  911.     char  buff[2];
  912.  
  913.     if (chkfn(n) < 1) return(-1);
  914.  
  915.     buff[0] = c;
  916.     buff[1] = '\0';
  917.     if (n != ZDFILE)
  918.     debug(F111,"zchout writing to file",buff,n);
  919.  
  920.     fp[n]->record_len = 1;
  921.  
  922.     if (fp[n]->binary) {
  923.     if (fp[n]->organization == STREAM_FILE)
  924.         s$write_raw (&fp[n]->port, &fp[n]->record_len, &c, &status);
  925.     else
  926.         s$seq_write_partial (&fp[n]->port, &fp[n]->record_len,
  927.         &c, &status);
  928.     }
  929.     else
  930.     s$seq_write (&fp[n]->port, &fp[n]->record_len, &c, &status);
  931.  
  932.     return((status == 0) ? 1 : -1);
  933. }
  934.  
  935. /* (PWP) buffered character output routine to speed up file IO */
  936.  
  937. int
  938. zoutdump() {
  939.     int x;
  940.     VFILE *vp;
  941.     short status = 0;
  942.     int   len;
  943.     register char  *ep;
  944. #ifdef NLCHAR
  945.     char  *cp;
  946. #else
  947.     register int   i;
  948.     static   char  last;
  949. #endif /* NLCHAR */
  950.  
  951.     zoutptr = zoutbuffer;        /* Reset buffer pointer in all cases */
  952.     debug(F101,"zoutdump chars","",zoutcnt);
  953.     if (zoutcnt == 0) {            /* Nothing to output */
  954.     return(0);
  955.     } else if (zoutcnt < 0) {        /* Unexpected negative argument */
  956.     zoutcnt = 0;            /* Reset output buffer count */
  957.     return(-1);            /* and fail. */
  958.     }
  959.  
  960.     vp = fp[ZOFILE];
  961.  
  962.     if (vp->binary) {
  963.     vp->record_len = zoutcnt;
  964.     debug(F101,"zoutdump binary, port","",vp->port);
  965.     if (vp->port == DEFAULT_OUTPUT_PORT_ID) { /* terminal */
  966.         conxo (vp->record_len, zoutbuffer);
  967.     }
  968.     else {
  969.         if (vp->organization == STREAM_FILE)
  970.         s$write_raw (&vp->port, &vp->record_len,
  971.             zoutbuffer, &status);
  972.         else
  973.         s$seq_write_partial (&vp->port, &vp->record_len,
  974.             zoutbuffer, &status);
  975.     }
  976.     }
  977.     else {
  978.     /* need to deblock the data in the output buffer */
  979.  
  980.     debug(F101,"zoutdump text, port","",vp->port);
  981. #ifdef NLCHAR
  982.     cp = zoutbuffer;
  983.  
  984.     do {
  985.         for (ep = cp; *ep != NLCHAR; ep++)
  986.         if (ep > &zoutbuffer[zoutcnt-1]) {
  987.             ep = NULL;
  988.             break;
  989.         }
  990.         if (NULL != ep) {
  991.         len = (int) (ep - cp); /* NOT +1 */
  992.         vp->record_len = len;
  993.         if (vp->port == DEFAULT_OUTPUT_PORT_ID) { /* terminal */
  994.             *ep = '\0'; /* conoll wants ASCIIZ string */
  995.             conoll (cp);
  996.         }
  997.         else
  998.             s$seq_write (&vp->port, &vp->record_len, cp, &status);
  999.         ep++;    /* move past the NLCHAR or NULL */
  1000.         }
  1001.         else if (cp < &zoutbuffer[zoutcnt-1]) {    /* not done it all */
  1002.         /* it's flushing in the middle of a record */
  1003.         len = zoutcnt - (int) (cp - (&zoutbuffer[0]));
  1004.         vp->record_len = len;
  1005.         if (vp->port == DEFAULT_OUTPUT_PORT_ID) { /* terminal */
  1006.             *(cp+len) = '\0'; /* conol wants ASCIIZ string */
  1007.             conol (cp);
  1008.         }
  1009.         else {
  1010.             if (vp->organization == STREAM_FILE)
  1011.             s$write_raw (&vp->port, &vp->record_len,
  1012.                 cp, &status);
  1013.             else
  1014.             s$seq_write_partial (&vp->port, &vp->record_len,
  1015.                 cp, &status);
  1016.         }
  1017.         }
  1018.         cp = ep;
  1019.     } while ((status == 0) && (NULL != cp) &&
  1020.          ((cp < &zoutbuffer[zoutcnt-1])));
  1021. #else
  1022.     /* this is not tested, but it is identical to log code in dpt.pm */
  1023.     ep = zoutbuffer;
  1024.     for (i = 0; i < zoutcnt; i++)
  1025.     {
  1026.         if ((zoutbuffer[i] == '\r') || (zoutbuffer[i] == '\n'))
  1027.         {
  1028.         len = (zoutbuffer + i) - ep;
  1029.         if ((last != '\r') || (buff[i] != '\n')) {
  1030.             if (vp->port == DEFAULT_OUTPUT_PORT_ID) { /* terminal */
  1031.             *(ep + len) = '\0'; /* conoll wants ASCIIZ string */
  1032.             conoll (ep);
  1033.             }
  1034.             else
  1035.             s$seq_write (&vp->port, &len, ep, &status);
  1036.         }
  1037.         ep = &zoutbuffer[i+1];
  1038.         }
  1039.         last = zoutbuffer[i];
  1040.     }
  1041.  
  1042.     if (ep < (zoutbuffer + len)) /* write out the last bit */
  1043.     {
  1044.         len = (zoutbuff + len) - ep;
  1045.         if (vp->port == DEFAULT_OUTPUT_PORT_ID) { /* terminal */
  1046.         *(ep + len) = '\0'; /* conol wants ASCIIZ string */
  1047.         conol (ep);
  1048.         }
  1049.         else {
  1050.         if (vp->organization == STREAM_FILE)
  1051.             s$write_raw (&vp->port, &len, ep, &status);
  1052.         else
  1053.             s$seq_write_partial (&vp->port, &len, ep, &status);
  1054.         }
  1055.     }
  1056.  
  1057. #endif /* NLCHAR */
  1058.  
  1059.     }
  1060.     if (0 == status) {
  1061.     debug(F101,"zoutdump s$...write... ok","",zoutcnt);
  1062.     zoutcnt = 0;            /* Reset output buffer count */
  1063.     return(0);            /* write() worked OK */
  1064.     } else {
  1065.     debug(F101,"zoutdump s$...write... status","",status);
  1066.     zoutcnt = 0;            /* Reset output buffer count */
  1067.     return(-1);            /* s$write_* failed */
  1068.     }
  1069. }
  1070.  
  1071. /*  C H K F N  --  Internal function to verify file number is ok  */
  1072.  
  1073. /*
  1074.  Returns:
  1075.   -1: File number n is out of range
  1076.    0: n is in range, but file is not open
  1077.    1: n in range and file is open
  1078. */
  1079. int
  1080. chkfn(n) int n; {
  1081.     if (n < 0 || n >= ZNFILS) {
  1082.     debug(F101,"chkfn: file number out of range","",n);
  1083.     return(-1);
  1084.     }
  1085.     else return( (fp[n] == NULL) ? 0 : 1 );
  1086. }
  1087.  
  1088. /*  Z C H K I  --  Check if input file exists and is readable  */
  1089.  
  1090. /*
  1091.   Returns:
  1092.    >= 0 if the file can be read (returns the size).
  1093.      -1 if file doesn't exist or can't be accessed,
  1094.      -2 if file exists but is not readable (e.g. a directory file).
  1095.      -3 if file exists but protected against read access.
  1096.  
  1097.  Directory files, special files, and symbolic links are not readable.
  1098. */
  1099. long
  1100. zchki(name) char *name; {
  1101.     CV(256) path;
  1102.     CV(256) src_path;
  1103.     CV(32) suffix;
  1104.     FILE_STATUS_STRUCT finfo;
  1105.     short status;
  1106.     int x;
  1107.     long size;
  1108.  
  1109.     debug(F110,"zchki checking",name,0);
  1110.  
  1111.     if (!name) return (-1);
  1112.  
  1113.     strcpy (&src_path, name);
  1114.     strcpy (&suffix, "");
  1115.     s$expand_path (&src_path, &suffix, &path, &status);
  1116.     if (status) {
  1117.     debug(F101,"zchki s$expand_path status","",status);
  1118.     return -1; /* doesn't exist or cannot be accessed */
  1119.     }
  1120.  
  1121.     finfo.version = FILE_STAT_VERSION_5;
  1122.     s$get_file_status (&path, &finfo, &status);
  1123.     if (status) {
  1124.     debug(F101,"zchki s$get_file_status status","",status);
  1125.     return -1;
  1126.     }
  1127.  
  1128.     switch ((int) finfo.callers_mode) {
  1129.     case 'r':
  1130.     case 'w':
  1131.         break;        /* exists, and we can read it */
  1132.  
  1133.     case 'e':
  1134.     case 'n':
  1135.     case 'u':
  1136.         return (-3);    /* exists, but protected from reading */
  1137.  
  1138.     default:
  1139.         return (-2);    /* not a file */
  1140.     }
  1141.  
  1142.     switch (finfo.file_organization) {
  1143.     case SEQUENTIAL_FILE:
  1144.     case STREAM_FILE:
  1145.         size = finfo.last_record_number;
  1146.         break;
  1147.  
  1148.     case FIXED_FILE:
  1149.         size = finfo.last_record_number * 
  1150.         finfo.flags_struct.flags_bits_overlay.max_record_size;
  1151.         break;
  1152.  
  1153.     case RELATIVE_FILE:
  1154.         size = finfo.last_record_number * 
  1155.         (finfo.flags_struct.flags_bits_overlay.max_record_size + 2);
  1156.         break;
  1157.  
  1158.     default:    /* uhhhh.... */
  1159.         size = 0;
  1160.         break;
  1161.     }
  1162.  
  1163.     strcpy (nambuf,name);        /* remember the name of the file */
  1164.  
  1165.     if (size > (finfo.blocks_used * 4096))
  1166.     size = (finfo.blocks_used * 4096);
  1167.  
  1168.     if (size < 0)
  1169.     size = 0;
  1170.  
  1171.     return (size);
  1172. }
  1173.  
  1174. /*  Z C H K O  --  Check if output file can be created  */
  1175.  
  1176. /*
  1177.  Returns -1 if write permission for the file would be denied, 0 otherwise.
  1178. */
  1179. int
  1180. zchko(name) char *name; {
  1181.     int i, x;
  1182.     char *s;
  1183.  
  1184.     if (!name) return(-1);        /* Watch out for null pointer. */
  1185.     x = (int)strlen(name);        /* Get length of filename */
  1186.     debug(F111,"zchko length",name,x);
  1187.  
  1188.     return (0);
  1189. }
  1190.  
  1191. /*  Z D E L E T  --  Delete the named file.  */
  1192.  
  1193. int
  1194. zdelet(name) char *name; {
  1195.     debug(F110,"zdelet",name,0);
  1196.     return(remove(name));
  1197. }
  1198.  
  1199. /*  Z R T O L  --  Convert remote filename into local form  */
  1200.  
  1201. /*  For VOS as in UNIX, this means changing uppercase letters to lowercase. */
  1202.  
  1203. VOID
  1204. zrtol(name,name2) char *name, *name2; {
  1205.     char *p; int flag = 0;
  1206.     debug(F101,"zrtol name","",name);
  1207.     debug(F101,"zrtol name2","",name2);
  1208.     if (!name || !name2) return;
  1209.     debug(F101,"zrtol input","",name);
  1210.     p = name2;
  1211.     for ( ; *name != '\0'; name++) {
  1212.     if (*name > ' ') flag = 1;    /* Strip leading blanks and controls */
  1213.     if (flag == 0 && *name < '!') continue;
  1214.         *p++ = isupper(*name) ? tolower(*name) : *name;
  1215.     }
  1216.     *p-- = '\0';            /* Terminate */
  1217.     while (*p < '!' && p > name2)    /* Strip trailing blanks & contronls */
  1218.       *p-- = '\0';
  1219.  
  1220.     debug(F110,"zrtol result",name2,0);
  1221. }
  1222.  
  1223.  
  1224. /*  Z S T R I P  --  Strip device & directory name from file specification */
  1225.  
  1226. /*  Strip pathname from filename "name", return pointer to result in name2 */
  1227.  
  1228. static char work[257];
  1229.  
  1230. VOID
  1231. zstrip(name,name2) char *name, **name2; {
  1232.     char *cp, *pp;
  1233.     debug(F110,"zstrip before",name,0);
  1234.     pp = work;
  1235. #ifdef DTILDE
  1236.     if (*name == '~') name++;
  1237. #endif /* DTILDE */
  1238.     for (cp = name; *cp != '\0'; cp++) {
  1239.         if (ISDIRSEP(*cp))
  1240.       pp = work;
  1241.     else
  1242.       *pp++ = *cp;
  1243.     }
  1244.     *pp = '\0';                /* Terminate the string */
  1245.     *name2 = work;
  1246.     debug(F110,"zstrip after",*name2,0);
  1247. }
  1248.  
  1249. /*  Z L T O R  --  Local TO Remote */
  1250.  
  1251. VOID
  1252. zltor(name,name2) char *name, *name2; {
  1253.     char *cp, *pp;
  1254.     int dc = 0;
  1255.  
  1256.     debug(F110,"zltor",name,0);
  1257.     pp = work;
  1258.  
  1259.     for (cp = name; *cp != '\0'; cp++) {    /* strip path name */
  1260.         if (ISDIRSEP(*cp)) {
  1261.         dc = 0;
  1262.         pp = work;
  1263.     }
  1264.     else if (islower(*cp)) *pp++ = toupper(*cp); /* Uppercase letters */
  1265.     /* there are more VOS file name characters that are illegal... */
  1266.     else if (*cp == '~') *pp++ = 'X';    /* Change tilde to 'X' */
  1267.     else if ((*cp == '.') && (++dc > 1)) *pp++ = 'X'; /* & extra dots */
  1268.     else *pp++ = *cp;
  1269.     }
  1270.     *pp = '\0';                /* Tie it off. */
  1271.     cp = name2;                /* If nothing before dot, */
  1272.     if (*work == '.') *cp++ = 'X';    /* insert 'X' */
  1273.     strcpy(cp,work);
  1274.     debug(F110," name2",name2,0);
  1275. }
  1276.  
  1277.  
  1278. /*  Z C H D I R  --  Change directory  */
  1279. /*
  1280.   Call with:
  1281.     dirnam = pointer to name of directory to change to,
  1282.       which may be "" or NULL to indicate user's home directory.
  1283.   Returns:
  1284.     0 on failure
  1285.     1 on success
  1286. */
  1287. int
  1288. zchdir(dirnam) char *dirnam; {
  1289.     char *hd, *sp, *p;
  1290.  
  1291.     debug(F110,"zchdir",dirnam,0);
  1292.     if (dirnam == NULL || dirnam == "" || *dirnam == '\0') /* If arg is null */
  1293.       dirnam = zhome();            /* use user's home directory. */
  1294.     sp = dirnam;
  1295.     debug(F110,"zchdir 2",dirnam,0);
  1296.  
  1297. #ifdef DTILDE
  1298.     hd = tilde_expand(dirnam);        /* Attempt to expand tilde */
  1299.     if (*hd == '\0') hd = dirnam;    /* in directory name. */
  1300. #else
  1301.     hd = dirnam;
  1302. #endif /* DTILDE */
  1303.     debug(F110,"zchdir 3",hd,0);
  1304.  
  1305.     if (chdir(hd) == 0) return(1);    /* Try to cd */
  1306.     p = sp;                /* Failed, lowercase it. */
  1307.     while (*p) {
  1308.     if (isupper(*p)) *p = tolower(*p);
  1309.     p++;
  1310.     }
  1311.     debug(F110,"zchdir 4",hd,0);
  1312. #ifdef DTILDE
  1313.     hd = tilde_expand(sp);        /* Try again to expand tilde */
  1314.     if (*hd == '\0') hd = sp;
  1315. #else
  1316.     hd = sp;                /* Point to result */
  1317. #endif /* DTILDE */
  1318.     debug(F110,"zchdir 5",hd,0);
  1319.     return((chdir(hd) == 0) ? 1 : 0);
  1320. }
  1321.  
  1322. /*  Z H O M E  --  Return pointer to user's home directory  */
  1323.  
  1324. /* This is a royal pain under some operating systems, involving reading    */
  1325. /* the password file, etc.  Under VOS we just ask, since the user is    */
  1326. /* allowed to specify a different home dir at login time, they make it  */
  1327. /* easy to get the answer.                        */
  1328.  
  1329. char *
  1330. zhome() {
  1331.     CV(256) cv_home;
  1332.     static char homebuf[257];
  1333.     char *home;
  1334.  
  1335.     s$get_home_dir (&cv_home);
  1336.     strcpy (homebuf, &cv_home);
  1337.     home = homebuf;
  1338.  
  1339.     return(home ? home : ".");
  1340. }
  1341.  
  1342. /*  Z G T D I R  --  Return pointer to user's current directory  */
  1343.  
  1344. char *
  1345. zgtdir() {
  1346.     char *buf;
  1347.     static char currbuf[257];
  1348.     CV(256) cv_curr;
  1349.  
  1350.     s$get_current_dir (&cv_curr);
  1351.     strcpy (currbuf, &cv_curr);
  1352.     buf = currbuf;
  1353.  
  1354.     return buf;
  1355. }
  1356.  
  1357. /*  Z X C M D -- Run a system command so its output can be read like a file */
  1358.  
  1359. /* return 0 on error, 1 on success, -1 if file number is bad. */
  1360.  
  1361. int
  1362. zxcmd(filnum,comand) int filnum; char *comand; {
  1363.     int out;
  1364.     short organization = SEQUENTIAL_FILE;
  1365.     short max_record_len = 4096;
  1366.     short status;
  1367.     short append_switch = 0;
  1368.     CV(256) temp_path;
  1369.     char c_temp_path[257];
  1370.     int save_binary;
  1371.  
  1372.     debug(F111,"zxcmd called",comand,filnum);
  1373.     if (chkfn(filnum) < 0) return(-1);    /* Need a valid Kermit file number. */
  1374.  
  1375.     if (filnum == ZSTDIO || filnum == ZCTERM) /* But not one of these. */
  1376.       return(0);
  1377.  
  1378.     out = (filnum == ZIFILE || filnum == ZRFILE) ? 0 : 1 ;
  1379.     if (out) {
  1380.       debug(F101,"zxcmd cannot open for output","",filnum);
  1381.       return (0); /* we can't write to the file */
  1382.     }
  1383.  
  1384.     s$get_temp_file (&organization, &max_record_len, &temp_path, &status);
  1385.     if (status) {
  1386.     debug(F101,"zxcmd s$get_temp_file, status","",status);
  1387.     return (0); /* error */
  1388.     }
  1389.     strcpy (c_temp_path, &temp_path);
  1390.     s$attach_default_output (&temp_path, &append_switch, &status);
  1391.     if (status) {
  1392.     debug(F111,"zxcmd s$attach_default_output, status",c_temp_path,status);
  1393.     return (0); /* error */
  1394.     }
  1395.     *nambuf = '\0';        /* forget old name */
  1396.     status = zsyscmd(comand); /* Hope this works. get VOS status back. */ 
  1397.     debug(F111,"zxcmd zsyscmd status",c_temp_path,status);
  1398.     if (status) { /* error */
  1399.     s$detach_default_output (&status); /* ignore this status */
  1400.     s$delete_file_on_close (&temp_path, &status); /* ignore this status */
  1401.     return (0); /* error */
  1402.     }
  1403.     s$detach_default_output (&status);
  1404.     if (status) {
  1405.     debug(F111,"zxcmd s$detach_default_output, status",c_temp_path,status);
  1406.     s$delete_file_on_close (&temp_path, &status); /* ignore this status */
  1407.     return (0); /* error */
  1408.     }
  1409.     save_binary = binary;
  1410.     binary = 0; /* it's a text file */
  1411.     if (0 == zopeni (filnum, c_temp_path)) { /* error? */
  1412.     binary = save_binary;
  1413.     debug(F100,"zxcmd zopeni failed","",0);
  1414.     s$delete_file_on_close (&temp_path, &status); /* ignore this status */
  1415.     return (0); /* error */
  1416.     }
  1417.     binary = save_binary;
  1418.     s$delete_file_on_close (&temp_path, &status); /* will poof at zclosf */
  1419.     if (status) {
  1420.     debug(F111,"zxcmd s$delete_file_on_close, status",c_temp_path,status);
  1421.     /* continue, it will still read, just leaving a loose file around */
  1422.     }
  1423.  
  1424.     return(1); /* Success! */
  1425. }
  1426.  
  1427. /*  Z C L O S F  - wait for the child fork to terminate and close the pipe. */
  1428.  
  1429. int
  1430. zclosf(filnum) int filnum; {
  1431.     debug(F101,"zclosf called","",filnum);
  1432.     return(1);
  1433. }
  1434.  
  1435. /*  Z X P A N D  --  Expand a wildcard string into an array of strings  */
  1436. /*
  1437.   Returns the number of files that match fn1, with data structures set up
  1438.   so  that first file (if any) will be returned by the next znext() call.
  1439.   Depends on external variable wildxpand:  0 means  we  expand  wildcards
  1440.   internally, nonzero means we call the shell to do it. In VOS, we always
  1441.   do it.
  1442. */
  1443.  
  1444. int
  1445. zxpand(fn) char *fn; {
  1446.     char *p;
  1447.  
  1448. #ifdef DTILDE                /* Built with tilde-expansion? */
  1449.     char *tnam;
  1450. #endif /* DTILDE */
  1451.     debug(F111,"zxpand entry",fn,wildxpand);
  1452. #ifdef DTILDE                /* Built with tilde-expansion? */
  1453.     if (*fn == '~') {            /* Starts with tilde? */
  1454.     tnam = tilde_expand(fn);    /* Try to expand it. */
  1455.     if (tnam) fn = tnam;
  1456.     }
  1457.     debug(F110,"zxpand after tilde_x",fn,0);
  1458. #endif /* DTILDE */
  1459.  
  1460.     fcount = shxpand(fn,mtchs,MAXWLD); /* Shell [JUST KIDDING!] */
  1461.  
  1462.     if (fcount > 0) {
  1463.     mtchptr = mtchs;        /* Save pointer for next. */
  1464.     }
  1465.     if (fcount > 0) {
  1466.     debug(F111,"zxpand ok",mtchs[0],fcount);
  1467.     return(fcount);
  1468.     }
  1469.     debug(F111,"zxpand fgen1",fn,fcount); /* Didn't get one, or got too many */
  1470.     p = malloc((int)strlen(fn) + 10);    /* Make space */
  1471.     if (!p) return(0);
  1472.     zrtol(fn,p);            /* Try again, maybe lowercase */
  1473.  
  1474.     fcount = shxpand(p,mtchs,MAXWLD); /* Shell */
  1475.  
  1476.     if (fcount > 0) {            /* Got one? */
  1477.     mtchptr = mtchs;        /* Save pointer for next. */
  1478.     debug(F111,"zxpand fgen2 ok",mtchs[0],fcount);
  1479.     } else debug(F111,"zxpand 2 not ok",p,fcount);
  1480.     free(p);
  1481.     return(fcount);
  1482. }
  1483.  
  1484.  
  1485. /*  Z N E X T  --  Get name of next file from list created by zxpand(). */
  1486. /*
  1487.  Returns >0 if there's another file, with its name copied into the arg string,
  1488.  or 0 if no more files in list.
  1489. */
  1490. int
  1491. znext(fn) char *fn; {
  1492.     if (fcount-- > 0) strcpy(fn,*mtchptr++);
  1493.     else *fn = '\0';
  1494.     debug(F111,"znext",fn,fcount+1);
  1495.     return(fcount+1);
  1496. }
  1497.  
  1498.  
  1499. /*  Z C H K S P A  --  Check if there is enough space to store the file  */
  1500.  
  1501. /*
  1502.  Call with file specification f, size n in bytes.
  1503.  Returns -1 on error, 0 if not enough space, 1 if enough space.
  1504.  
  1505.  On  VOS, we pick up the volume name from first part of the path name, then
  1506.  check to make sure it's valid, then check the amount of space available on
  1507.  that volume.  Also, VOS won't let you use the last 200 blocks of the  file
  1508.  partition  on  the  volume, so we count off for that.  Also, the number of
  1509.  indirect blocks is only  partially  accounted  for.  This  isn't  perfect,
  1510.  because  some  of  the different file organizations can cause the reported
  1511.  size of the file not to match the actual size of the  file,  but  this  is
  1512.  only  a problem with files with a large number of records and certain file
  1513.  orgs.  We don't try to figure this out, instead we let the  transfer  fail
  1514.  when  the  disk gets full, which is what a number of implementations do in
  1515.  all cases.
  1516.  
  1517. */
  1518. int
  1519. #ifdef CK_ANSIC
  1520. zchkspa(char *f, long n)
  1521. #else
  1522. zchkspa(f,n) char *f; long n;
  1523. #endif /* CK_ANSIC */
  1524. /* zchkspa() */ {
  1525.     CV(256) path;
  1526.     CV(256) src_path;
  1527.     char    cpath[257];
  1528.     CV(32) suffix;
  1529.     CV(66) disk_name;
  1530.     short status;
  1531.     int x;
  1532.     struct disk_info dinfo;
  1533.     char *cp;
  1534.     long blocks_left;
  1535.  
  1536.     debug(F111,"zchkspa checking",f,n);
  1537.  
  1538.     if (!f) return (-1);
  1539.  
  1540.     strcpy (&src_path, f);
  1541.     strcpy (&suffix, "");
  1542.     s$expand_path (&src_path, &suffix, &path, &status);
  1543.     if (status) {
  1544.     debug(F101,"zchkspa s$expand_path status","",status);
  1545.     return -1; /* an error occurred */
  1546.     }
  1547.  
  1548.     strcpy (cpath, &path);
  1549.     cp = strchr (cpath, DIRSEP);
  1550.     if (cp)
  1551.     *cp = '\0'; /* cut off the directory name from the disk name */
  1552.  
  1553.     strcpy (&disk_name, cpath);
  1554.     dinfo.version = 1;
  1555.     s$get_disk_info (&disk_name, &dinfo, &status);
  1556.     if (status) {
  1557.     debug(F111,"zchkspa s$get_disk_info status",cpath,status);
  1558.     return -1; /* an error occurred */
  1559.     }
  1560.  
  1561.     blocks_left = dinfo.file_partition_size - dinfo.file_partition_used;
  1562.     blocks_left -= 200; /* can't use last 200 blocks */
  1563.  
  1564.     n /= 4096;
  1565.     n++;
  1566.  
  1567.     /* count some of the indirect blocks */
  1568.     /* I used to know how to count these really... */
  1569.  
  1570.     if (n > 16)
  1571.     n++;
  1572.  
  1573.     if (n > 256)
  1574.     n++;
  1575.  
  1576.     if (n >= blocks_left)
  1577.     return(0);                /* not enough space */
  1578.     else
  1579.     return(1);                /* Okay! */
  1580. }
  1581.  
  1582.  
  1583. /*  Z N E W N  --  Make a new name for the given file  */
  1584.  
  1585. /*
  1586.   Given  the  name,  fn, of a file that already exists, this function builds a
  1587.   new name of the form "<oldname>.~<n>~", where  <oldname>  is  argument  name
  1588.   (fn),  and  <n>  is  a  version number, one higher than any existing version
  1589.   number for that file, up to 9999.  This format is consistent with that  used
  1590.   by GNU EMACS.  If the constructed name is too long for the system's maximum,
  1591.   enough  characters  are  truncated from the end of <fn> to allow the version
  1592.   number to fit.  If no free version numbers  exist  between  1  and  9999,  a
  1593.   version  number  of  "xxxx"  is  used.  Returns a pointer to the new name in
  1594.   argument s.
  1595. */
  1596.  
  1597. VOID
  1598. znewn(fn,s) char *fn, **s; {
  1599. #define ZNEWNBL 255
  1600. #define ZNEWNMD 4
  1601.  
  1602.     static char buf[ZNEWNBL+1];
  1603.     char *bp, *xp, *yp;
  1604. #ifdef OS2
  1605.     char *zp, ch, temp[14];
  1606. #endif /* OS2 */
  1607.     int len = 0, d = 0, n, t, i, j, k, power = 1;
  1608.  
  1609.     int max = MAXNAMLEN;        /* Maximum name length */
  1610.  
  1611.     if (max < 14) max = 14;        /* Make it reasonable */
  1612.     if (max > ZNEWNBL) max = ZNEWNBL;
  1613.     bp = buf;                /* Buffer for building new name */
  1614.     yp = fn;
  1615.     while (*yp) {            /* Copy old name into buffer */
  1616.     *bp++ = *yp++;
  1617.     if (len++ > ZNEWNBL) break;    /* ...up to buffer length */
  1618.     }
  1619.     *s = NULL;
  1620.     for (i = 1; i < ZNEWNMD + 1; i++) {    /* Version numbers up to 10**i - 1 */
  1621.     power *= 10;            /* Next power of 10 */
  1622.     j = max - len;            /* Space left for version number */
  1623.     k = 3 + i;            /* Space needed for it */
  1624.     if (j < k) {            /* Make room if necessary */
  1625.         len -= (k - j);        /* Adjust length of filename */
  1626.         bp = buf + len;        /* Point to new end */
  1627.     }
  1628.     *bp++ = '*';            /* Put a star on the end (UNIX) */
  1629.     *bp-- = '\0';            /* Terminate with null */
  1630.  
  1631.     n = zxpand(buf);        /* Expand the resulting wild name */
  1632.                     /* n is the number of matches */
  1633.     while (n-- > 0) {        /* Find any existing name.~n~ files */
  1634.         xp = *mtchptr++;        /* Point at matching name */
  1635.         xp += len;            /* Look for .~<n>~ at the end of it */
  1636.         if (*xp == '.' && *(xp+1) == '~') {    /* Has a version number */
  1637.         t = atoi(xp+2);                /* Get it */
  1638.         if (t > d) d = t;    /* Save d = highest version number */
  1639.         }
  1640.     }
  1641.     if (d < power-1) {        /* Less than maximum possible? */
  1642.         sprintf(bp,".~%d~",d+1);    /* Yes, make "name.~<d+1>~" */
  1643.         *s = buf;            /* Point to new name */
  1644.         break;            /* Done, return it */
  1645.     }
  1646.     }
  1647.     if (*s == NULL) {
  1648.     sprintf(bp,".~xxxx~");        /* Too many, use xxxx. */
  1649.     *s = buf;
  1650.     }
  1651.  
  1652.     return;
  1653. }
  1654.  
  1655.  
  1656. /*  Z R E N A M E  --  Rename a file  */
  1657.  
  1658. /*  Call with old and new names */
  1659. /*  Returns 0 on success, -1 on failure. */
  1660.  
  1661. int
  1662. zrename(old,new) char *old, *new; {
  1663.    debug(F110,"zrename old",old,0);
  1664.    debug(F110,"        new",new,0);
  1665.    return rename(old, new);
  1666. }
  1667.  
  1668. /*  Z S A T T R */
  1669. /*
  1670.  Fills in a Kermit file attribute structure for the file which is to be sent.
  1671.  Returns 0 on success with the structure filled in, or -1 on failure.
  1672.  If any string member is null, then it should be ignored.
  1673.  If any numeric member is -1, then it should be ignored.
  1674. */
  1675. int
  1676. zsattr(xx) struct zattr *xx; {
  1677.     long k;
  1678.     CV(256) path;
  1679.     CV(256) src_path;
  1680.     CV(32) suffix;
  1681.     FILE_STATUS_STRUCT finfo;
  1682.     short status;
  1683.     int x;
  1684.     char *cp;
  1685.     static char  creator[67];
  1686.     static char  cdate[20];
  1687.     struct tm *tp;
  1688.  
  1689.     k = iflen % 1024L;            /* File length in K */
  1690.     if (k != 0L) k = 1L;
  1691.     xx->lengthk = (iflen / 1024L) + k;
  1692.     xx->type.len = 0;            /* File type can't be filled in here */
  1693.     xx->type.val = "";
  1694.  
  1695.     if (*nambuf) {
  1696.         debug(F110,"zsattr checking",nambuf,0);
  1697.  
  1698.     strcpy (&src_path, nambuf);
  1699.     strcpy (&suffix, "");
  1700.     s$expand_path (&src_path, &suffix, &path, &status);
  1701.     if (status) {
  1702.         debug(F101,"zsattr s$expand_path status","",status);
  1703.         return -1; /* doesn't exist or cannot be accessed */
  1704.     }
  1705.  
  1706.     finfo.version = FILE_STAT_VERSION_5;
  1707.     s$get_file_status (&path, &finfo, &status);
  1708.     if (status) {
  1709.         debug(F101,"zsattr s$get_file_status status","",status);
  1710.         return -1;
  1711.     }
  1712.  
  1713.     tp = localtime ((const time_t *) &finfo.date_time_modified);
  1714.     if (NULL != tp) {
  1715.         sprintf(cdate, "%04d%02d%02d %02d:%02d:%02d", tp->tm_year + 1900,
  1716.         tp->tm_mon + 1, tp->tm_mday, tp->tm_hour, tp->tm_min,
  1717.         tp->tm_sec);
  1718.         xx->date.val = cdate;    /* File creation date */
  1719.         xx->date.len = (int)strlen(xx->date.val);
  1720.     }
  1721.     else {
  1722.         xx->date.val = "";    /* File creation date */
  1723.         xx->date.len = 0;
  1724.     }
  1725.  
  1726.     strcpy (creator, &finfo.author);
  1727.     cp = strchr (creator, '.');
  1728.     *cp++ = '\0';
  1729.  
  1730.     /* (person_name (file_info author)) */
  1731.     xx->creator.val = creator;        /* File creator */
  1732.     xx->creator.len = strlen (creator);
  1733.  
  1734.     /* (group_name (file_info author)) */
  1735.     xx->account.len = strlen (cp);        /* File account */
  1736.     xx->account.val = cp;
  1737.  
  1738.     xx->recfm.len = 0;            /* Record format */
  1739.     xx->recfm.val = "";
  1740.  
  1741.     } else {
  1742.     xx->date.len = 0;
  1743.     xx->date.val = "";
  1744.  
  1745.     xx->creator.len = 0;        /* File creator */
  1746.     xx->creator.val = "";
  1747.  
  1748.     xx->recfm.len = 0;            /* Record format */
  1749.     xx->recfm.val = "";
  1750.  
  1751.     xx->account.len = 0;        /* File account */
  1752.     xx->account.val = "";
  1753.     }
  1754.     xx->area.len = 0;            /* File area */
  1755.     xx->area.val = "";
  1756.     xx->password.len = 0;        /* Area password */
  1757.     xx->password.val = "";
  1758.     xx->blksize = -1L;            /* File blocksize */
  1759.     xx->access.len = 0;            /* File access */
  1760.     xx->access.val = "";
  1761.     xx->encoding.len = 0;        /* Transfer syntax */
  1762.     xx->encoding.val = 0;
  1763.     xx->disp.len = 0;            /* Disposition upon arrival */
  1764.     xx->disp.val = "";
  1765.     xx->lprotect.len = 0;        /* Local protection */
  1766.     xx->lprotect.val = "";
  1767.     xx->gprotect.len = 0;        /* Generic protection */
  1768.     xx->gprotect.val = "";
  1769.     xx->systemid.len = 2;        /* System ID */
  1770.     xx->systemid.val = "MV";        /* MISC, VOS */
  1771.     xx->sysparam.len = 0;        /* System-dependent parameters */
  1772.     xx->sysparam.val = "";
  1773.     xx->length = iflen;            /* Length */
  1774.     return(0);
  1775. }
  1776.  
  1777. /* Z F C D A T  --  Get file creation date */
  1778. /*
  1779.   Call with pointer to filename.
  1780.   On success, returns pointer to creation date in yyyymmdd hh:mm:ss format.
  1781.   On failure, returns pointer to null string.
  1782. */
  1783. char *
  1784. zfcdat(name) char *name; {
  1785.     static char  cdate[20];
  1786.     CV(256) path;
  1787.     CV(256) src_path;
  1788.     CV(32) suffix;
  1789.     FILE_STATUS_STRUCT finfo;
  1790.     short status;
  1791.     struct tm  *tp;
  1792.  
  1793.     debug(F110,"zfcdate called",name,0);
  1794.     strcpy (&src_path, name);
  1795.     strcpy (&suffix, "");
  1796.     s$expand_path (&src_path, &suffix, &path, &status);
  1797.     if (status) {
  1798.     debug(F101,"zfcdate s$expand_path status","",status);
  1799.     return ""; /* error */
  1800.     }
  1801.  
  1802.     finfo.version = FILE_STAT_VERSION_5;
  1803.     s$get_file_status (&path, &finfo, &status);
  1804.     if (status) {
  1805.     debug(F101,"zfcdate s$get_file_status status","",status);
  1806.     return "";
  1807.     }
  1808.  
  1809.     tp = localtime ((const time_t *) &finfo.date_time_modified);
  1810.     if (NULL == tp)
  1811.     return("");
  1812.  
  1813.     sprintf(cdate, "%04d%02d%02d %02d:%02d:%02d", tp->tm_year + 1900,
  1814.     tp->tm_mon + 1, tp->tm_mday, tp->tm_hour, tp->tm_min,
  1815.     tp->tm_sec);
  1816.  
  1817.     return cdate;
  1818. }
  1819.  
  1820. /* Z S T I M E  --  Set creation date for incoming file */
  1821. /*
  1822.  Call with:
  1823.  f  = pointer to name of existing file.
  1824.  yy = pointer to a Kermit file attribute structure in which yy->date.val
  1825.       is a date of the form yyyymmdd hh:mm:ss, e.g. 19900208 13:00:00.
  1826.  x  = is a function code: 0 means to set the file's creation date as given.
  1827.       1 means compare the given date with the file creation date.
  1828.  Returns:
  1829.  -1 on any kind of error.
  1830.   0 if x is 0 and the file date was set successfully.
  1831.   0 if x is 1 and date from attribute structure <= file creation date.
  1832.   1 if x is 1 and date from attribute structure > file creation date.
  1833. */
  1834.  
  1835. int
  1836. zstime(f,yy,x) char *f; struct zattr *yy; int x; {
  1837.     int r = -1;                /* return code */
  1838.     CV(256) path;
  1839.     CV(256) src_path;
  1840.     CV(32) suffix;
  1841.     FILE_STATUS_STRUCT finfo;
  1842.     short status;
  1843.     struct tm  *tp;
  1844.     struct tm  mytm;
  1845.     char fdate[20];
  1846.     char adate[32];
  1847.     CV(32) cvtime;
  1848.     int dlen; /* length of date part */
  1849.     time_t file_times[4]; /* created, used, modified, saved */
  1850.     time_t idate;
  1851.     char *cp;
  1852.     int scanval;
  1853.     time_t now;
  1854.  
  1855.     now = time(NULL);
  1856.     debug(F111,"zstime called, x",f,x);
  1857.     if (NULL == yy) {
  1858.     debug(F100,"zstime called with NULL attr struct","",0);
  1859.     return r;
  1860.     }
  1861.     if (yy->date.len > 17) { /* too long */
  1862.     debug(F111,"zstime bad date",yy->date.val,yy->date.len);
  1863.     return r;
  1864.     }
  1865.     strncpy (adate, yy->date.val, yy->date.len);
  1866.     adate[yy->date.len] = '\0';
  1867.     debug(F111,"zstime attr date",adate,yy->date.len);
  1868.  
  1869.     memset (&mytm, 0, sizeof mytm); /* clear it out initially */
  1870.     
  1871.     /* "normalize" attribute date string */
  1872.     if (NULL != (cp = strchr (adate, ' '))) {    /* is time present? */
  1873.       dlen = (int)(cp - adate);
  1874.     cp++; /* now get time, let sscanf deal with missing seconds */
  1875.     scanval = sscanf(cp,"%2d:%2d:%2d",
  1876.         &mytm.tm_hour, &mytm.tm_min, &mytm.tm_sec);
  1877.         debug(F111,"   sscan time",cp,scanval);
  1878.     if (scanval != 2 && scanval != 3)
  1879.         return (-1);        /* this is an error */
  1880.     }
  1881.     else
  1882.     dlen = strlen (adate);
  1883.  
  1884.     if (dlen == 8) {         /* yyyymmdd */
  1885.     scanval = sscanf(adate,"%4d%2d%2d",
  1886.         &mytm.tm_year, &mytm.tm_mon, &mytm.tm_mday);
  1887.     debug(F111,"   sscan long date",adate,scanval);
  1888.     if (scanval != 3)
  1889.         return (-1);
  1890.     mytm.tm_year -= 1900;
  1891.     }
  1892.     else if (dlen == 6) {    /* yymmdd */
  1893.     sscanf(adate,"%2d%2d%2d",
  1894.         &mytm.tm_year, &mytm.tm_mon, &mytm.tm_mday);
  1895.     debug(F111,"   sscan short date",adate,scanval);
  1896.     if (scanval != 3)
  1897.         return (-1);
  1898.     if (mytm.tm_year < 80)             /* VOS dates start at 1980 */
  1899.         mytm.tm_year += 100;        /* UNIX could be 1975...   */
  1900.     }
  1901.     else {                    /* error */
  1902.     debug(F110,"zstime bad date",adate,0);
  1903.     return (-1);
  1904.     }
  1905.  
  1906.     mytm.tm_mon -= 1;
  1907.  
  1908.     strcpy (&src_path, f);
  1909.     strcpy (&suffix, "");
  1910.     s$expand_path (&src_path, &suffix, &path, &status);
  1911.     if (status) {
  1912.     debug(F101,"zstime s$expand_path status","",status);
  1913.     return (-1); /* error */
  1914.     }
  1915.  
  1916.     finfo.version = FILE_STAT_VERSION_5;
  1917.     s$get_file_status (&path, &finfo, &status);
  1918.     if (status) {
  1919.     debug(F101,"zstime s$get_file_status status","",status);
  1920.     return (-1);
  1921.     }
  1922.  
  1923.     if (1 == x) { /* compare times only */
  1924.     tp = localtime ((const time_t *) &finfo.date_time_modified);
  1925.     if (NULL == tp)
  1926.         return (-1);
  1927.  
  1928.     sprintf(fdate, "%04d%02d%02d %02d:%02d:%02d", tp->tm_year + 1900,
  1929.         tp->tm_mon + 1, tp->tm_mday, tp->tm_hour, tp->tm_min,
  1930.         tp->tm_sec);
  1931.  
  1932.         debug(F111,"zstime file mod date",fdate,finfo.date_time_modified);
  1933.  
  1934.     sprintf(adate, "%04d%02d%02d %02d:%02d:%02d", mytm.tm_year + 1900,
  1935.         mytm.tm_mon + 1, mytm.tm_mday, mytm.tm_hour, mytm.tm_min,
  1936.         mytm.tm_sec);
  1937.  
  1938.         debug(F110,"zstime adate",adate,0);
  1939.  
  1940.     if (strcmp (adate, fdate) > 0)
  1941.         r = 1;
  1942.     else
  1943.         r = 0;
  1944.      debug(F101,"zstime compare","",r);
  1945.     return r;
  1946.     }
  1947.  
  1948.     /* set date on existing file */
  1949.     sprintf (adate,"%02.2ld-%02.2ld-%02.2ld %02.2ld:%02.2ld:%02.2ld",
  1950.     mytm.tm_year, mytm.tm_mon + 1, mytm.tm_mday,
  1951.     mytm.tm_hour, mytm.tm_min, mytm.tm_sec);
  1952.  
  1953.     strcpy (&cvtime, adate);
  1954.     s$cv_to_int_date_time (&cvtime, &idate, &status);
  1955.     if (status) {
  1956.     debug(F111,"zstime s$cv_to_int_date_time status",adate,status);
  1957.     return (-1);
  1958.     }
  1959.  
  1960.     file_times[0] = idate;            /* time created */
  1961.     file_times[1] = now;            /* time used */
  1962.     file_times[2] = idate;            /* time modified */
  1963.     file_times[3] = 0;                /* time saved */
  1964.  
  1965.     s$set_object_times (&path, &file_times, &status);
  1966.     if (status) {
  1967.     debug(F111,"zstime s$set_object_times status",adate,status);
  1968.     return (-1);
  1969.     }
  1970.  
  1971.     s$set_expiration_date (&path, &now, &status);
  1972.     if (status) {
  1973.     debug(F111,"zstime s$set_expiration_date status",adate,status);
  1974.     return (-1);
  1975.     }
  1976.  
  1977.     return(0);
  1978. }
  1979.  
  1980. /* Find initialization file. */
  1981.  
  1982. int
  1983. zkermini() {
  1984. /*  nothing here for VOS.  This function added for benefit of VMS Kermit.  */
  1985. /*  VOS always uses "(home_dir)>start_up.kermit"                */
  1986.     return(0);
  1987. }
  1988.  
  1989. #ifndef NOFRILLS
  1990. int
  1991. zmail(p,f) char *p; char *f; {        /* Send file f as mail to address p */
  1992. /*
  1993.   Returns 0 on success
  1994.    2 if mail delivered but temp file should not be deleted
  1995.   -2 if mail can't be delivered
  1996. */
  1997.     char buff[300];
  1998.     int r;
  1999.     int len;
  2000.  
  2001.     len = sprintf (buff, 
  2002.     "!send_mail '%s' 'Kermit:%s' -priority '%s' -letter_path '%s'",
  2003.     p, f, "normal", f);
  2004.     debug(F110,"zmail",buff,len);
  2005.     r = zsyscmd (buff);
  2006.     if (r != 0) {
  2007.     debug(F101,"zmail call to zsyscmd","",r);
  2008.     return(-2);
  2009.     }
  2010.  
  2011.     return 0;
  2012. }
  2013. #endif /* NOFRILLS */
  2014.  
  2015. #ifndef NOFRILLS
  2016. int
  2017. zprint(p,f) char *p; char *f; {        /* Print file f with options p */
  2018. /*
  2019.   Returns 0 on success
  2020.    3 if file is printed but temp file can't be deleted
  2021.   -3 if file can't be printed
  2022. */
  2023.     char buff[300];
  2024.     int r;
  2025.     int len;
  2026.  
  2027.     len = sprintf (buff, "!print -delete %s %s", f, p);
  2028.     debug(F110,"zprint",buff,len);
  2029.     r = zsyscmd (buff);
  2030.     if (r != 0)
  2031.     return(-3);
  2032.  
  2033.     /* the spooler will delete the file after it is printed */
  2034.     /**/ /* should this be 3? check caller */
  2035.     return 0;
  2036. }
  2037. #endif /* NOFRILLS */
  2038.  
  2039. /* S H X P A N D  -- expand star names appropriate to the user's shell.
  2040.    In VOS, use the s$expand_star command, which is the same as the command
  2041.    processor uses.  It is also much easier than doing it our self.
  2042. */
  2043. int
  2044. shxpand(pat,namlst,len) char *pat, *namlst[]; int len; {
  2045.     char *p, *q;            /* Workers */
  2046.     int i, x, retcode; char c;        /* ... */
  2047.     CV(256) relpath;
  2048.     CV(32)  suffix;
  2049.     CV(256) fullpath;
  2050.     char dirnam[256];
  2051.     short status;
  2052.     struct {
  2053.     short version;
  2054.     struct {
  2055.         CV(32) objnam;
  2056.         short         objtyp;
  2057.     } entries[1];
  2058.     } *expinfo = NULL;
  2059.     short switches;
  2060.     short maxnbr;
  2061.     short nbrmatch;
  2062.     short dummy;
  2063.  
  2064.     for (i = 0; i < oldmtchs; i++)    /* Free previous file list */
  2065.       free(namlst[i]);
  2066.     
  2067.     oldmtchs = 0;
  2068.     strcpy (&relpath, pat);
  2069.     strcpy (&suffix, "");        /* don't append a suffix */
  2070.     s$expand_path (&relpath, &suffix, &fullpath, &status);
  2071.     if (status) {
  2072.     debug(F111,"shxpand expand_path failed",pat,status);
  2073.     return 0;
  2074.     }
  2075.  
  2076.     strcpy (dirnam, &fullpath);
  2077.     *(strrchr (dirnam, DIRSEP) + 1) = '\0'; /* cut it off after last dir */
  2078.  
  2079.     switches = 1; /* FILES, no dirs, no links, don't sort */
  2080.     maxnbr = 0;   /* don't want names, just how many */
  2081.     dummy = 1;      /* looks like expinfo->version, with no data part */
  2082.     s$expand_star (&fullpath, &switches, &maxnbr, &nbrmatch, &dummy, &status);
  2083.     if (status) {
  2084.     debug(F111,"shxpand starmatch 1 failed",pat,status);
  2085.     return 0;
  2086.     }
  2087.  
  2088.     debug(F111,"shxpand found matches",pat,nbrmatch);
  2089.     if (0 == nbrmatch) /* aren't any matches anyway */
  2090.     return 0;
  2091.  
  2092.     nbrmatch += 10; /* add a little bit */
  2093.     if (nbrmatch > MAXWLD)
  2094.       nbrmatch = MAXWLD;
  2095.  
  2096.     expinfo = malloc (sizeof (*expinfo->entries) * (nbrmatch - 1)
  2097.               + sizeof (*expinfo));
  2098.     if (NULL == expinfo) {
  2099.     debug(F101,"shxpand expinfo malloc","",(int)expinfo);
  2100.     return 0;
  2101.     }
  2102.     switches = 9; /* FILES, no dirs, no links, SORT */
  2103.     maxnbr = nbrmatch;
  2104.     expinfo->version = 1;
  2105.     s$expand_star (&fullpath, &switches, &maxnbr, &nbrmatch, expinfo, &status);
  2106.     if (status) {
  2107.     debug(F111,"shxpand starmatch 2 failed",pat,status);
  2108.     free(expinfo);
  2109.     return 0;
  2110.     }
  2111.  
  2112.     strcpy (&relpath, dirnam);    /* set up relnam */
  2113.     for (i = 0; i < nbrmatch; i++) {
  2114.     /* if no dirsep chars, don't put full path in expansion */
  2115.         if ((NULL == strchr(pat,'>')) && (NULL == strchr(pat,'<')))
  2116.         strcpy (&fullpath, &expinfo->entries[i].objnam);
  2117.     else {
  2118.         strcpy (&fullpath, &relpath); /* faster with CV's */
  2119.         strcat (&fullpath, &expinfo->entries[i].objnam);
  2120.     }
  2121.  
  2122.     x = (int)strlen(&fullpath);    /* Yes, get length of name */
  2123.     q = malloc(x+1);        /* Allocate space for it */
  2124.     if (!q) goto shxfin;        /* Fail if space can't be obtained */
  2125.     strcpy(q,&fullpath);        /* Copy name to space */
  2126.  
  2127.     namlst[i] = q;        /* Copy pointer to name into array */
  2128.     if (i >= len) goto shxfin;    /* Fail if too many */
  2129.     }
  2130.     retcode = i;            /* Return number of matching files */
  2131.  
  2132. shxfin:                    /* Common exit point */
  2133.  
  2134.     oldmtchs = i;            /* Remember how many files */
  2135.     free(expinfo);
  2136.     return(retcode);
  2137. }
  2138.  
  2139. /*  W H O A M I  --  Get user's username.  */
  2140.  
  2141. /*
  2142.   Under UNIX, this is hard to do, and different methods are used on
  2143.   different implementations (ATT/BSD/MINIX/etc).  On VOS, it's a gimme.
  2144. */
  2145. static char *
  2146. whoami () {
  2147.     CV(65) uname;
  2148.     char realname[66];    
  2149.  
  2150.     s$get_user_name (&uname);
  2151.     strcpy (realname, &uname);
  2152.     return(realname);
  2153. }
  2154.  
  2155. /*  T I L D E _ E X P A N D  --  expand ~user to the user's home directory. */
  2156.  
  2157. /*  This is not implemented correctly.  If DTILDE is defined, you will get  */
  2158. /*  compilation errors.  Tilde expansion is not a VOS concept.              */
  2159.  
  2160. char *
  2161. tilde_expand(dirname) char *dirname; {
  2162. #ifdef DTILDE
  2163.  
  2164. #define BUFLEN 257
  2165.  
  2166.     struct passwd *user;
  2167.     static char olddir[BUFLEN];
  2168.     static char oldrealdir[BUFLEN];
  2169.     static char temp[BUFLEN];
  2170.     int i, j;
  2171.  
  2172.     debug(F111,"tilde_expand",dirname,dirname[0]);
  2173.  
  2174.     if (dirname[0] != '~')        /* Not a tilde...return param */
  2175.       return(dirname);
  2176.     if (!strcmp(olddir,dirname)) {    /* Same as last time */
  2177.       return(oldrealdir);        /* so return old answer. */
  2178.     } else {
  2179.     j = (int)strlen(dirname);
  2180.     for (i = 0; i < j; i++)        /* find username part of string */
  2181.       if (!ISDIRSEP(dirname[i]))
  2182.         temp[i] = dirname[i];
  2183.       else break;
  2184.     temp[i] = '\0';            /* tie off with a NULL */
  2185.     if (i == 1) {            /* if just a "~" */
  2186.         user = getpwnam(whoami());    /*  get info on current user */
  2187.     } else {
  2188.         user = getpwnam(&temp[1]);    /* otherwise on the specified user */
  2189.     }
  2190.     }
  2191.     if (user != NULL) {            /* valid user? */
  2192.     strcpy(olddir, dirname);    /* remember the directory */
  2193.     strcpy(oldrealdir,user->pw_dir); /* and their home directory */
  2194.     strcat(oldrealdir,&dirname[i]);
  2195.     return(oldrealdir);
  2196.     } else {                /* invalid? */
  2197.     strcpy(olddir, dirname);    /* remember for next time */
  2198.     strcpy(oldrealdir, dirname);
  2199.     return(oldrealdir);
  2200.     }
  2201. #else
  2202.     return(NULL);
  2203. #endif /* DTILDE */
  2204. }
  2205.  
  2206. /*
  2207.   Functions for executing system commands.
  2208.  
  2209.   zsyscmd() executes the system command in the normal, default way for
  2210.   the system.  In UNIX, it does what system() does.  Thus, its results
  2211.   are  always  predictable;  in  VOS, it uses system(), so it is NEVER
  2212.   predictable, because system() is one of the weirdest  parts  of  the
  2213.   c-runtime.
  2214.  
  2215.   zshcmd()  executes  the  command "using the user's preferred shell,"
  2216.   which is a meaningless concept under VOS,  so  we  use  zsyscmd  for
  2217.   consistency.
  2218. */
  2219. int
  2220. zsyscmd(s) char *s; {
  2221.     int r;
  2222.     short status;
  2223.     CV(256) msgtext;
  2224.     char msg[257];
  2225.  
  2226.     debug(F110,"zsyscmd",s,0);
  2227.     if (strcmp (s, "login") && 0 != strlen (s)) {
  2228.     r = system(s);
  2229.     if (0 != r) {
  2230.         debug(F101,"system() returned status","",r);
  2231.     }
  2232.     }
  2233.     else {
  2234.     strcpy (&msgtext, "");
  2235.     s$clone (&status, &msgtext);
  2236.     r = status;
  2237.         if (0 != r) {
  2238.         strcpy (msg, &msgtext);
  2239.         debug(F111,"s$clone status",msg,status);
  2240.     }
  2241.     }
  2242.  
  2243. #ifdef COMMENT
  2244.     /* changed in edit 002 */
  2245.     /* 0 == failure, 1 == success */
  2246.     return (0 == r);
  2247. #else
  2248.     return r;
  2249. #endif /* COMMENT */
  2250. }
  2251.  
  2252. int
  2253. zshcmd(s) char *s; {
  2254.     debug(F110,"zshcmd",s,0);
  2255.     return(zsyscmd(s));
  2256. }
  2257.  
  2258. /*  I S W I L D  --  Check if filespec is "wild"  */
  2259.  
  2260. /*
  2261.   Returns 0 if it is a single file, 1 if it contains wildcard characters.
  2262.   Note: must match the algorithm used by match(), hence no [a-z], etc.
  2263. */
  2264. int
  2265. iswild(filespec) char *filespec; {
  2266.     char c; int x; char *p;
  2267.     if (wildxpand) {
  2268.     if ((x = zxpand(filespec)) > 1) return(1);
  2269.     if (x == 0) return(0);        /* File does not exist */
  2270.     p = malloc(MAXNAMLEN + 20);
  2271.     znext(p);
  2272.     x = (strcmp(filespec,p) != 0);
  2273.     free(p);
  2274.     return(x);
  2275.     } else {
  2276.     while ((c = *filespec++) != '\0')
  2277.       if (c == '*') return(1); /* only '*' allowed in VOS star-names */
  2278.     return(0);
  2279.     }
  2280. }
  2281.  
  2282. /*
  2283.    Tell if string pointer s is the name of a directory.
  2284.    Returns 1 if directory, 0 if not a directory.
  2285. */
  2286. int
  2287. isdir(s) char *s; {
  2288.     int x;
  2289.     CV(256) relpath;
  2290.     CV(32)  suffix;
  2291.     CV(256) fullpath;
  2292.     short   status;
  2293.     short   type;
  2294.     short   chase = 1;
  2295.  
  2296.     if (!s) return(0);
  2297.     if (!*s) return(0);
  2298.  
  2299.     strcpy (&relpath, s);
  2300.     strcpy (&suffix, "");        /* don't append a suffix */
  2301.     s$expand_path (&relpath, &suffix, &fullpath, &status);
  2302.     if (status) {
  2303.     debug(F111,"isdir expand_path failed",s,status);
  2304.     return 0;
  2305.     }
  2306.  
  2307.     s$get_object_type (&fullpath, &chase, &type, &status);
  2308.     
  2309.     debug(F101,"isdir type",s,type);
  2310.     return( (type == 2) ? 1 : 0 );  /* 1=File, 2=Dir, 3=Link */
  2311. }
  2312.  
  2313. #ifdef CK_MKDIR
  2314. /* Some systems don't have mkdir(), e.g. Tandy Xenix 3.2.. */
  2315.  
  2316. /* Z M K D I R  --  Create directory(s) if necessary */
  2317. /*
  2318.    Call with:
  2319.     A pointer to a file specification that might contain directory
  2320.     information.  The filename is expected to be included.
  2321.     If the file specification does not include any directory separators,
  2322.     then it is assumed to be a plain file.
  2323.     If one or more directories are included in the file specification,
  2324.     this routine tries to create them if they don't already exist.
  2325.    Returns:
  2326.     0 on success, i.e. the directory was created
  2327.    -1 on failure to create the directory
  2328. */
  2329. int
  2330. zmkdir(path) char *path; {
  2331.     char *xp, *tp, c;
  2332.     int x;
  2333.     CV(256) cv_path;
  2334.     short   status;
  2335.  
  2336.     x = strlen(path);
  2337.     debug(F111,"zmkdir",path,x);
  2338.     if (x < 1 || x > MAXPATH)        /* Check length */
  2339.       return(-1);
  2340.     if (!(tp = malloc(x+1)))        /* Make a temporary copy */
  2341.       return(-1);
  2342.     strcpy(tp,path);
  2343.  
  2344.     xp = tp;
  2345.     if (ISDIRSEP(*xp))            /* Don't create root directory! */
  2346.       xp++;
  2347.  
  2348.     /* Go thru filespec from left to right... */
  2349.  
  2350.     for (; *xp; xp++) {            /* Create parts that don't exist */
  2351.     if (!ISDIRSEP(*xp))        /* Find next directory separator */
  2352.       continue;
  2353.     c = *xp;            /* Got one. */
  2354.     *xp = '\0';            /* Make this the end of the string. */
  2355.     if (!isdir(tp)) {        /* This directory exists already? */
  2356.         debug(F110,"zmkdir making",tp,0);
  2357.         strcpy (&cv_path, tp);
  2358.         s$create_dir (&cv_path, &status);
  2359.     
  2360.         if (status != 0) {
  2361.         debug(F101,"zmkdir failed, status","",status);
  2362.         free(tp);        /* Free temporary buffer. */
  2363.         return(-1);        /* Freturn failure code. */
  2364.         }
  2365.     }
  2366.     *xp = c;            /* Replace the separator. */
  2367.     }
  2368.     free(tp);                /* Free temporary buffer. */
  2369.     return(0);                /* Return success code. */
  2370. }
  2371. #endif /* CK_MKDIR */
  2372.  
  2373. /* Z F S E E K  --  Position input file pointer */
  2374. /*
  2375.    Call with:
  2376.     Long int, 0-based, indicating desired position.
  2377.    Returns:
  2378.     0 on success.
  2379.    -1 on failure.
  2380. */
  2381. #ifndef NORESEND
  2382. int
  2383. #ifdef CK_ANSIC
  2384. zfseek(long pos)
  2385. #else
  2386. zfseek(pos) long pos;
  2387. #endif /* CK_ANSIC */
  2388. /* zfseek */ {
  2389.     short port;
  2390.     short position_control;
  2391.     short status;
  2392.     long  nbr_records;
  2393.     int   rv; /* return value */
  2394.     VFILE *vp = fp[ZIFILE];
  2395.  
  2396.     debug(F101,"zfseek","",pos);
  2397.     if (NULL != vp) {
  2398.     port = vp->port;
  2399.     position_control = POS_BEGINNING_OF_FILE;
  2400.     nbr_records = 0;
  2401.     status = 0;
  2402.  
  2403.     s$seq_position (&port, &position_control, &nbr_records, &status);
  2404.     if (status == 0) {
  2405.         port = vp->port;
  2406.         position_control = POS_NUM_BYTES_FORWARD;
  2407.         nbr_records = pos;
  2408.         status = 0;
  2409.  
  2410.         s$seq_position (&port, &position_control, &nbr_records, &status);
  2411.     }
  2412.     } else {
  2413.         status = 1;
  2414.     }
  2415.  
  2416.     rv = (status == 0) ? 0 : -1;
  2417.     return(rv);
  2418. }
  2419. #endif /* NORESEND */
  2420.