开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 压缩解压 > 查看源码
aosvs.c
资源名称：unzip540.zip　[点击查看]
上传用户：andy_li
上传日期：2007-01-06
资源大小：1019k
文件大小：45k
源码类别：

压缩解压

开发平台：

MultiPlatform

aosvs.c：源码内容
  1. /*---------------------------------------------------------------------------
  3.   aosvs.c
  5.   AOS/VS-specific routines for use with Info-ZIP's UnZip 5.2 and later.
  6. [GRR:  copied from unix.c -> undoubtedly has unnecessary stuff: delete at will]
  8.   Contains:  readdir()
  9.              do_wild()
  10.              open_outfile()
  11.              mapattr()
  12.              mapname()
  13.              checkdir()
  14.              screenlines()
  15.              close_outfile()
  16.              version()             <-- GRR:  needs work!  (Unix, not AOS/VS)
  17.              zvs_create()
  18.              zvs_credir()
  19.              ux_to_vs_name()
  20.              dgdate()
  22.   ---------------------------------------------------------------------------*/
  25. #define UNZIP_INTERNAL
  26. #include "unzip.h"
  27. #include "aosvs/aosvs.h"
  28. #include <packets/create.h>
  29. #include <sys_calls.h>
  30. #include <paru.h>
  32. #define symlink(resname,linkname) 
  33.   zvs_create(linkname,-1L,-1L,-1L,ux_to_vs_name(vs_resname,resname),$FLNK,-1,-1)
  34.                                              *  file type */
  36. #ifdef DIRENT
  37. #  include <dirent.h>
  38. #else
  39. #  ifdef SYSV
  40. #    ifdef SYSNDIR
  41. #      include <sys/ndir.h>
  42. #    else
  43. #      include <ndir.h>
  44. #    endif
  45. #  else /* !SYSV */
  46. #    ifndef NO_SYSDIR
  47. #      include <sys/dir.h>
  48. #    endif
  49. #  endif /* ?SYSV */
  50. #  ifndef dirent
  51. #    define dirent direct
  52. #  endif
  53. #endif /* ?DIRENT */
  55. static int            created_dir;          /* used in mapname(), checkdir() */
  56. static int            renamed_fullpath;     /* ditto */
  58. static ZEXTRAFLD      zzextrafld;           /* buffer for extra field containing
  59.                                              *  ?FSTAT packet & ACL buffer */
  60. static char           vs_resname[2*$MXPL];
  61. static char           vs_path[2*$MXPL];     /* buf for AOS/VS pathname */
  62. static char           Vs_path[512];         /* should be big enough [GRR: ?] */
  63. static P_CTIM         zztimeblock;          /* time block for file creation */
  64. static ZVSCREATE_STRU zzcreatepacket;       /* packet for sys_create(), any
  67. /***************************/
  68. /* Strings used in aosvs.c */
  69. /***************************/
  71. static ZCONST char Far CannotDeleteOldFile[] =
  72.   "error:  cannot delete old %sn";
  73. static ZCONST char Far CannotCreateFile[] = "error:  cannot create %sn";
  76. #ifndef SFX
  77. #ifdef NO_DIR                  /* for AT&T 3B1 */
  79. #define opendir(path) fopen(path,"r")
  80. #define closedir(dir) fclose(dir)
  81. typedef FILE DIR;
  83. /*
  84.  *  Apparently originally by Rich Salz.
  85.  *  Cleaned up and modified by James W. Birdsall.
  86.  */
  87. struct dirent *readdir(dirp)
  88.     DIR *dirp;
  89. {
  90.     static struct dirent entry;
  92.     if (dirp == NULL)
  93.         return NULL;
  95.     for (;;)
  96.         if (fread(&entry, sizeof (struct dirent), 1, dirp) == 0)
  97.             return (struct dirent *)NULL;
  98.         else if (entry.d_ino)
  99.             return &entry;
  101. } /* end function readdir() */
  103. #endif /* NO_DIR */
  106. /**********************/
  107. /* Function do_wild() */   /* for porting:  dir separator; match(ignore_case) */
  108. /**********************/
  110. char *do_wild(__G__ wildspec)
  111.     __GDEF
  112.     char *wildspec;         /* only used first time on a given dir */
  113. {
  114.     static DIR *dir = (DIR *)NULL;
  115.     static char *dirname, *wildname, matchname[FILNAMSIZ];
  116.     static int firstcall=TRUE, have_dirname, dirnamelen;
  117.     struct dirent *file;
  120.     /* Even when we're just returning wildspec, we *always* do so in
  121.      * matchname[]--calling routine is allowed to append four characters
  122.      * to the returned string, and wildspec may be a pointer to argv[].
  123.      */
  124.     if (firstcall) {        /* first call:  must initialize everything */
  125.         firstcall = FALSE;
  127.         if (!iswild(wildspec)) {
  128.             strcpy(matchname, wildspec);
  129.             have_dirname = FALSE;
  130.             dir = NULL;
  131.             return matchname;
  132.         }
  134.         /* break the wildspec into a directory part and a wildcard filename */
  135.         if ((wildname = strrchr(wildspec, '/')) == (char *)NULL) {
  136.             dirname = ".";
  137.             dirnamelen = 1;
  138.             have_dirname = FALSE;
  139.             wildname = wildspec;
  140.         } else {
  141.             ++wildname;     /* point at character after '/' */
  142.             dirnamelen = wildname - wildspec;
  143.             if ((dirname = (char *)malloc(dirnamelen+1)) == (char *)NULL) {
  144.                 Info(slide, 0x201, ((char *)slide,
  145.                   "warning:  cannot allocate wildcard buffersn"));
  146.                 strcpy(matchname, wildspec);
  147.                 return matchname;   /* but maybe filespec was not a wildcard */
  148.             }
  149.             strncpy(dirname, wildspec, dirnamelen);
  150.             dirname[dirnamelen] = '';   /* terminate for strcpy below */
  151.             have_dirname = TRUE;
  152.         }
  154.         if ((dir = opendir(dirname)) != (DIR *)NULL) {
  155.             while ((file = readdir(dir)) != (struct dirent *)NULL) {
  156.                 Trace((stderr, "do_wild:  readdir returns %sn", file->d_name));
  157.                 if (file->d_name[0] == '.' && wildname[0] != '.')
  158.                     continue;  /* Unix:  '*' and '?' do not match leading dot */
  159.                 if (match(file->d_name, wildname, 0) &&  /* 0 == case sens. */
  160.                     /* skip "." and ".." directory entries */
  161.                     strcmp(file->d_name, ".") && strcmp(file->d_name, "..")) {
  162.                     Trace((stderr, "do_wild:  match() succeedsn"));
  163.                     if (have_dirname) {
  164.                         strcpy(matchname, dirname);
  165.                         strcpy(matchname+dirnamelen, file->d_name);
  166.                     } else
  167.                         strcpy(matchname, file->d_name);
  168.                     return matchname;
  169.                 }
  170.             }
  171.             /* if we get to here directory is exhausted, so close it */
  172.             closedir(dir);
  173.             dir = (DIR *)NULL;
  174.         }
  176.         /* return the raw wildspec in case that works (e.g., directory not
  177.          * searchable, but filespec was not wild and file is readable) */
  178.         strcpy(matchname, wildspec);
  179.         return matchname;
  180.     }
  182.     /* last time through, might have failed opendir but returned raw wildspec */
  183.     if (dir == (DIR *)NULL) {
  184.         firstcall = TRUE;  /* nothing left to try--reset for new wildspec */
  185.         if (have_dirname)
  186.             free(dirname);
  187.         return (char *)NULL;
  188.     }
  190.     /* If we've gotten this far, we've read and matched at least one entry
  191.      * successfully (in a previous call), so dirname has been copied into
  192.      * matchname already.
  193.      */
  194.     while ((file = readdir(dir)) != (struct dirent *)NULL) {
  195.         Trace((stderr, "do_wild:  readdir returns %sn", file->d_name));
  196.         if (file->d_name[0] == '.' && wildname[0] != '.')
  197.             continue;   /* Unix:  '*' and '?' do not match leading dot */
  198.         if (match(file->d_name, wildname, 0)) {   /* 0 == don't ignore case */
  199.             Trace((stderr, "do_wild:  match() succeedsn"));
  200.             if (have_dirname) {
  201.                 /* strcpy(matchname, dirname); */
  202.                 strcpy(matchname+dirnamelen, file->d_name);
  203.             } else
  204.                 strcpy(matchname, file->d_name);
  205.             return matchname;
  206.         }
  207.     }
  209.     closedir(dir);     /* have read at least one dir entry; nothing left */
  210.     dir = (DIR *)NULL;
  211.     firstcall = TRUE;  /* reset for new wildspec */
  212.     if (have_dirname)
  213.         free(dirname);
  214.     return (char *)NULL;
  216. } /* end function do_wild() */
  218. #endif /* !SFX */
  224. /***************************/
  225. /* Function open_outfile() */
  226. /***************************/
  228. int open_outfile(__G)         /* return 1 if fail */
  229.     __GDEF
  230. {
  231.     int errc = 1;    /* init to show no success with AOS/VS info */
  232.     long dmm, ddd, dyy, dhh, dmin, dss;
  235. #ifdef DLL
  236.     if (G.redirect_data)
  237.         return redirect_outfile(__G)==FALSE;
  238. #endif
  240.     if (stat(G.filename, &G.statbuf) == 0 && unlink(G.filename) < 0) {
  241.         Info(slide, 0x401, ((char *)slide, LoadFarString(CannotDeleteOldFile),
  242.           G.filename));
  243.         return 1;
  244.     }
  246. /*---------------------------------------------------------------------------
  247.     If the file didn't already exist, we created it earlier.  But we just
  248.     deleted it, which we still had to do in case we are overwriting an exis-
  249.     ting file.  So we must create it now, again, to set the creation time
  250.     properly.  (The creation time is the best functional approximation of
  251.     the Unix mtime.  Really!)
  253.     If we stored this with an AOS/VS Zip that set the extra field to contain
  254.     the ?FSTAT packet and the ACL, we should use info from the ?FSTAT call
  255.     now.  Otherwise (or if that fails), we should create anyway as best we
  256.     can from the normal Zip info.
  258.     In theory, we should look through an entire series of extra fields that
  259.     might exist for the same file, but we're not going to bother.  If we set
  260.     up other types of extra fields, or if other environments we run into may
  261.     add their own stuff to existing entries in Zip files, we'll have to.
  263.     Note that all the packet types for sys_fstat() are the same size & mostly
  264.     have the same structure, with some fields being unused, etc.  Ditto for
  265.     sys_create().  Thus, we assume a normal one here, not a dir/cpd or device
  266.     or IPC file, & make little adjustments as necessary.  We will set ACLs
  267.     later (to reduce the chance of lacking access to what we create now); note
  268.     that for links the resolution name should be stored in the ACL field (once
  269.     we get Zip recognizing links OK).
  270.   ---------------------------------------------------------------------------*/
  272.     if (G.extra_field != NULL) {
  273.         memcpy((char *) &zzextrafld, G.extra_field, sizeof(zzextrafld));
  274.         if (!memcmp(ZEXTRA_HEADID, zzextrafld.extra_header_id,
  275.                     sizeof(zzextrafld.extra_header_id))  &&
  276.             !memcmp(ZEXTRA_SENTINEL, zzextrafld.extra_sentinel),
  277.                     sizeof(zzextrafld.extra_sentinel))
  278.         {
  279.             zzcreatepacket.norm_create_packet.cftyp_format =
  280.               zzextrafld.fstat_packet.norm_fstat_packet.styp_format;
  281.             zzcreatepacket.norm_create_packet.cftyp_entry =
  282.               zzextrafld.fstat_packet.norm_fstat_packet.styp_type;
  284.             /* for DIRS/CPDs, the next one will give the hash frame size; for
  285.              * IPCs it will give the port number */
  286.             zzcreatepacket.norm_create_packet.ccps =
  287.               zzextrafld.fstat_packet.norm_fstat_packet.scps;
  289.             zzcreatepacket.norm_create_packet.ctim = &zztimeblock;
  290.             zztimeblock.tcth = zzextrafld.fstat_packet.norm_fstat_packet.stch;
  292.             /* access & modification times default to current */
  293.             zztimeblock.tath.long_time = zztimeblock.tmth.long_time = -1;
  295.             /* give it current process's ACL unless link; then give it
  296.              * resolution name */
  297.             zzcreatepacket.norm_create_packet.cacp = (char *)(-1);
  299.             if (zzcreatepacket.norm_create_packet.cftyp_entry == $FLNK)
  300.                 zzcreatepacket.norm_create_packet.cacp = zzextrafld.aclbuf;
  302.             zzcreatepacket.dir_create_packet.cmsh =
  303.               zzextrafld.fstat_packet.dir_fstat_packet.scsh;
  304.             if (zzcreatepacket.norm_create_packet.cftyp_entry != $FCPD) {
  305.                 /* element size for normal files */
  306.                 zzcreatepacket.norm_create_packet.cdel =
  307.                   zzextrafld.fstat_packet.norm_fstat_packet.sdeh;
  308.             }
  309.             zzcreatepacket.norm_create_packet.cmil =
  310.               zzextrafld.fstat_packet.norm_fstat_packet.smil;
  312.             if ((errc = sys_create(ux_to_vs_name(vs_path, G.filename),
  313.                  &zzcreatepacket)) != 0)
  314.                 Info(slide, 0x201, ((char *)slide,
  315.                   "error creating %s with AOS/VS info -n
  316.                   will try again with ordinary Zip infon", G.filename));
  317.         }
  318.     }
  320.     /* do it the hard way if no AOS/VS info was stored or if we had problems */
  321.     if (errc) {
  322.         dyy = (G.lrec.last_mod_dos_datetime >> 25) + 1980;
  323.         dmm = (G.lrec.last_mod_dos_datetime >> 21) & 0x0f;
  324.         ddd = (G.lrec.last_mod_dos_datetime >> 16) & 0x1f;
  325.         dhh = (G.lrec.last_mod_dos_datetime >> 11) & 0x1f;
  326.         dmin = (G.lrec.last_mod_dos_datetime >> 5) & 0x3f;
  327.         dss = (G.lrec.last_mod_dos_datetime << 1) & 0x3e;
  329.         if (zvs_create(G.filename, (((ulg)dgdate(dmm, ddd, dyy)) << 16) |
  330.             (dhh*1800L + dmin*30L + dss/2L), -1L, -1L, (char *) -1, -1, -1, -1))
  331.         {
  332.             Info(slide, 0x201, ((char *)slide, "error: %s: cannot createn",
  333.               G.filename));
  334.             return 1;
  335.         }
  336.     }
  338.     Trace((stderr, "open_outfile:  doing fopen(%s) for writingn", G.filename));
  339.     if ((G.outfile = fopen(G.filename, FOPW)) == (FILE *)NULL) {
  340.         Info(slide, 0x401, ((char *)slide, LoadFarString(CannotCreateFile),
  341.           G.filename));
  342.         return 1;
  343.     }
  344.     Trace((stderr, "open_outfile:  fopen(%s) for writing succeededn",
  345.       G.filename));
  347. #ifdef USE_FWRITE
  348. #ifdef _IOFBF  /* make output fully buffered (works just about like write()) */
  349.     setvbuf(G.outfile, (char *)slide, _IOFBF, WSIZE);
  350. #else
  351.     setbuf(G.outfile, (char *)slide);
  352. #endif
  353. #endif /* USE_FWRITE */
  354.     return 0;
  356. } /* end function open_outfile() */
  362. /**********************/
  363. /* Function mapattr() */
  364. /**********************/
  366. int mapattr(__G)
  367.     __GDEF
  368. {
  369.     ulg tmp = G.crec.external_file_attributes;
  371.     switch (G.pInfo->hostnum) {
  372.         case UNIX_:
  373.         case VMS_:
  374.         case ACORN_:
  375.         case ATARI_:
  376.         case BEOS_:
  377.         case QDOS_:
  378.             G.pInfo->file_attr = (unsigned)(tmp >> 16);
  379.             return 0;
  380.         case AMIGA_:
  381.             tmp = (unsigned)(tmp>>17 & 7);   /* Amiga RWE bits */
  382.             G.pInfo->file_attr = (unsigned)(tmp<<6 | tmp<<3 | tmp);
  383.             break;
  384.         /* all remaining cases:  expand MSDOS read-only bit into write perms */
  385.         case FS_FAT_:
  386.         case FS_HPFS_:
  387.         case FS_NTFS_:
  388.         case MAC_:
  389.         case TOPS20_:
  390.         default:
  391.             tmp = !(tmp & 1) << 1;   /* read-only bit --> write perms bits */
  392.             G.pInfo->file_attr = (unsigned)(0444 | tmp<<6 | tmp<<3 | tmp);
  393.             break;
  394.     } /* end switch (host-OS-created-by) */
  396.     /* for originating systems with no concept of "group," "other," "system": */
  397.     umask( (int)(tmp=umask(0)) );    /* apply mask to expanded r/w(/x) perms */
  398.     G.pInfo->file_attr &= ~tmp;
  400.     return 0;
  402. } /* end function mapattr() */
  408. /************************/
  409. /*  Function mapname()  */
  410. /************************/
  411.                              /* return 0 if no error, 1 if caution (filename */
  412. int mapname(__G__ renamed)   /*  truncated), 2 if warning (skip file because */
  413.     __GDEF                   /*  dir doesn't exist), 3 if error (skip file), */
  414.     int renamed;             /*  or 10 if out of memory (skip file) */
  415. {                            /*  [also IZ_VOL_LABEL, IZ_CREATED_DIR] */
  416.     char pathcomp[FILNAMSIZ];    /* path-component buffer */
  417.     char *pp, *cp=(char *)NULL;  /* character pointers */
  418.     char *lastsemi=(char *)NULL; /* pointer to last semi-colon in pathcomp */
  419.     int quote = FALSE;           /* flags */
  420.     int error = 0;
  421.     register unsigned workch;    /* hold the character being tested */
  424. /*---------------------------------------------------------------------------
  425.     Initialize various pointers and counters and stuff.
  426.   ---------------------------------------------------------------------------*/
  428.     if (G.pInfo->vollabel)
  429.         return IZ_VOL_LABEL;    /* can't set disk volume labels in Unix */
  431.     /* can create path as long as not just freshening, or if user told us */
  432.     G.create_dirs = (!uO.fflag || renamed);
  434.     created_dir = FALSE;        /* not yet */
  436.     /* user gave full pathname:  don't prepend rootpath */
  437.     renamed_fullpath = (renamed && (*G.filename == '/'));
  439.     if (checkdir(__G__ (char *)NULL, INIT) == 10)
  440.         return 10;              /* initialize path buffer, unless no memory */
  442.     *pathcomp = '';           /* initialize translation buffer */
  443.     pp = pathcomp;              /* point to translation buffer */
  444.     if (uO.jflag)               /* junking directories */
  445.         cp = (char *)strrchr(G.filename, '/');
  446.     if (cp == (char *)NULL)     /* no '/' or not junking dirs */
  447.         cp = G.filename;        /* point to internal zipfile-member pathname */
  448.     else
  449.         ++cp;                   /* point to start of last component of path */
  451. /*---------------------------------------------------------------------------
  452.     Begin main loop through characters in filename.
  453.   ---------------------------------------------------------------------------*/
  455.     while ((workch = (uch)*cp++) != 0) {
  457.         if (quote) {                 /* if character quoted, */
  458.             *pp++ = (char)workch;    /*  include it literally */
  459.             quote = FALSE;
  460.         } else
  461.             switch (workch) {
  462.             case '/':             /* can assume -j flag not given */
  463.                 *pp = '';
  464.                 if ((error = checkdir(__G__ pathcomp, APPEND_DIR)) > 1)
  465.                     return error;
  466.                 pp = pathcomp;    /* reset conversion buffer for next piece */
  467.                 lastsemi = (char *)NULL; /* leave directory semi-colons alone */
  468.                 break;
  470.             case ';':             /* VMS version (or DEC-20 attrib?) */
  471.                 lastsemi = pp;
  472.                 *pp++ = ';';      /* keep for now; remove VMS ";##" */
  473.                 break;            /*  later, if requested */
  475.             case '26':          /* control-V quote for special chars */
  476.                 quote = TRUE;     /* set flag for next character */
  477.                 break;
  479. #ifdef MTS
  480.             case ' ':             /* change spaces to underscore under */
  481.                 *pp++ = '_';      /*  MTS; leave as spaces under Unix */
  482.                 break;
  483. #endif
  485.             default:
  486.                 /* allow European characters in filenames: */
  487.                 if (isprint(workch) || (128 <= workch && workch <= 254))
  488.                     *pp++ = (char)workch;
  489.             } /* end switch */
  491.     } /* end while loop */
  493.     *pp = '';                   /* done with pathcomp:  terminate it */
  495.     /* if not saving them, remove VMS version numbers (appended ";###") */
  496.     if (!uO.V_flag && lastsemi) {
  497.         pp = lastsemi + 1;
  498.         while (isdigit((uch)(*pp)))
  499.             ++pp;
  500.         if (*pp == '')          /* only digits between ';' and end:  nuke */
  501.             *lastsemi = '';
  502.     }
  504. /*---------------------------------------------------------------------------
  505.     Report if directory was created (and no file to create:  filename ended
  506.     in '/'), check name to be sure it exists, and combine path and name be-
  507.     fore exiting.
  508.   ---------------------------------------------------------------------------*/
  510.     if (G.filename[strlen(G.filename) - 1] == '/') {
  511.         checkdir(__G__ G.filename, GETPATH);
  512.         if (created_dir) {
  513.             if (QCOND2) {
  514.                 Info(slide, 0, ((char *)slide, "   creating: %sn",
  515.                   G.filename));
  516.             }
  517.             return IZ_CREATED_DIR;   /* set dir time (note trailing '/') */
  518.         }
  519.         return 2;   /* dir existed already; don't look for data to extract */
  520.     }
  522.     if (*pathcomp == '') {
  523.         Info(slide, 1, ((char *)slide, "mapname:  conversion of %s failedn",
  524.           G.filename));
  525.         return 3;
  526.     }
  528.     checkdir(__G__ pathcomp, APPEND_NAME);  /* returns 1 if truncated: care? */
  529.     checkdir(__G__ G.filename, GETPATH);
  531.     return error;
  533. } /* end function mapname() */
  538. #if 0  /*========== NOTES ==========*/
  540.   extract-to dir:      a:path/
  541.   buildpath:           path1/path2/ ...   (NULL-terminated)
  542.   pathcomp:                filename
  544.   mapname():
  545.     loop over chars in zipfile member name
  546.       checkdir(path component, COMPONENT | CREATEDIR) --> map as required?
  547.         (d:/tmp/unzip/)                    (disk:[tmp.unzip.)
  548.         (d:/tmp/unzip/jj/)                 (disk:[tmp.unzip.jj.)
  549.         (d:/tmp/unzip/jj/temp/)            (disk:[tmp.unzip.jj.temp.)
  550.     finally add filename itself and check for existence? (could use with rename)
  551.         (d:/tmp/unzip/jj/temp/msg.outdir)  (disk:[tmp.unzip.jj.temp]msg.outdir)
  552.     checkdir(name, GETPATH)     -->  copy path to name and free space
  554. #endif /* 0 */
  559. /***********************/
  560. /* Function checkdir() */
  561. /***********************/
  563. int checkdir(__G__ pathcomp, flag)
  564.     __GDEF
  565.     char *pathcomp;
  566.     int flag;
  567. /*
  568.  * returns:  1 - (on APPEND_NAME) truncated filename
  569.  *           2 - path doesn't exist, not allowed to create
  570.  *           3 - path doesn't exist, tried to create and failed; or
  571.  *               path exists and is not a directory, but is supposed to be
  572.  *           4 - path is too long
  573.  *          10 - can't allocate memory for filename buffers
  574.  */
  575. {
  576.     static int rootlen = 0;   /* length of rootpath */
  577.     static char *rootpath;    /* user's "extract-to" directory */
  578.     static char *buildpath;   /* full path (so far) to extracted file */
  579.     static char *end;         /* pointer to end of buildpath ('') */
  581. #   define FN_MASK   7
  582. #   define FUNCTION  (flag & FN_MASK)
  586. /*---------------------------------------------------------------------------
  587.     APPEND_DIR:  append the path component to the path being built and check
  588.     for its existence.  If doesn't exist and we are creating directories, do
  589.     so for this one; else signal success or error as appropriate.
  590.   ---------------------------------------------------------------------------*/
  592.     if (FUNCTION == APPEND_DIR) {
  593.         int too_long = FALSE;
  594. #ifdef SHORT_NAMES
  595.         char *old_end = end;
  596. #endif
  598.         Trace((stderr, "appending dir segment [%s]n", pathcomp));
  599.         while ((*end = *pathcomp++) != '')
  600.             ++end;
  601. #ifdef SHORT_NAMES   /* path components restricted to 14 chars, typically */
  602.         if ((end-old_end) > FILENAME_MAX)  /* GRR:  proper constant? */
  603.             *(end = old_end + FILENAME_MAX) = '';
  604. #endif
  606.         /* GRR:  could do better check, see if overrunning buffer as we go:
  607.          * check end-buildpath after each append, set warning variable if
  608.          * within 20 of FILNAMSIZ; then if var set, do careful check when
  609.          * appending.  Clear variable when begin new path. */
  611.         if ((end-buildpath) > FILNAMSIZ-3)  /* need '/', one-char name, '' */
  612.             too_long = TRUE;                /* check if extracting directory? */
  613.         /* for AOS/VS, try to create so as to not use searchlist: */
  614.         if ( /*stat(buildpath, &G.statbuf)*/ 1) {
  615.             if (!G.create_dirs) { /* told not to create (freshening) */
  616.                 free(buildpath);
  617.                 return 2;         /* path doesn't exist:  nothing to do */
  618.             }
  619.             if (too_long) {
  620.                 Info(slide, 1, ((char *)slide,
  621.                   "checkdir error:  path too long: %sn", buildpath));
  622.                 free(buildpath);
  623.                 return 4;         /* no room for filenames:  fatal */
  624.             }
  625.             /* create the directory */
  626.             if (zvs_credir(buildpath,-1L,-1L,-1L,(char *) -1,-1,0L,-1,-1) == -1)
  627.             {
  628.                 Info(slide, 1, ((char *)slide,
  629.                   "checkdir error:  cannot create %sn
  630.                  unable to process %s.n", buildpath, G.filename));
  631.                 free(buildpath);
  632.                 return 3;      /* path didn't exist, tried to create, failed */
  633.             }
  634.             created_dir = TRUE;
  635.         } else if (!S_ISDIR(G.statbuf.st_mode)) {
  636.             Info(slide, 1, ((char *)slide, "checkdir error:  %s exists but is not directoryn
  637.                  unable to process %s.n", buildpath, G.filename));
  638.             free(buildpath);
  639.             return 3;          /* path existed but wasn't dir */
  640.         }
  641.         if (too_long) {
  642.             Info(slide, 1, ((char *)slide,
  643.               "checkdir error:  path too long: %sn", buildpath));
  644.             free(buildpath);
  645.             return 4;         /* no room for filenames:  fatal */
  646.         }
  647.         *end++ = '/';
  648.         *end = '';
  649.         Trace((stderr, "buildpath now = [%s]n", buildpath));
  650.         return 0;
  652.     } /* end if (FUNCTION == APPEND_DIR) */
  654. /*---------------------------------------------------------------------------
  655.     GETPATH:  copy full path to the string pointed at by pathcomp, and free
  656.     buildpath.
  657.   ---------------------------------------------------------------------------*/
  659.     if (FUNCTION == GETPATH) {
  660.         strcpy(pathcomp, buildpath);
  661.         Trace((stderr, "getting and freeing path [%s]n", pathcomp));
  662.         free(buildpath);
  663.         buildpath = end = (char *)NULL;
  664.         return 0;
  665.     }
  667. /*---------------------------------------------------------------------------
  668.     APPEND_NAME:  assume the path component is the filename; append it and
  669.     return without checking for existence.
  670.   ---------------------------------------------------------------------------*/
  672.     if (FUNCTION == APPEND_NAME) {
  673. #ifdef SHORT_NAMES
  674.         char *old_end = end;
  675. #endif
  677.         Trace((stderr, "appending filename [%s]n", pathcomp));
  678.         while ((*end = *pathcomp++) != '') {
  679.             ++end;
  680. #ifdef SHORT_NAMES  /* truncate name at 14 characters, typically */
  681.             if ((end-old_end) > FILENAME_MAX)      /* GRR:  proper constant? */
  682.                 *(end = old_end + FILENAME_MAX) = '';
  683. #endif
  684.             if ((end-buildpath) >= FILNAMSIZ) {
  685.                 *--end = '';
  686.                 Info(slide, 1, ((char *)slide,
  687.                   "checkdir warning:  path too long; truncatingn
  688.                    %sn                -> %sn", G.filename, buildpath));
  689.                 return 1;   /* filename truncated */
  690.             }
  691.         }
  692.         Trace((stderr, "buildpath now = [%s]n", buildpath));
  693.         return 0;  /* could check for existence here, prompt for new name... */
  694.     }
  696. /*---------------------------------------------------------------------------
  697.     INIT:  allocate and initialize buffer space for the file currently being
  698.     extracted.  If file was renamed with an absolute path, don't prepend the
  699.     extract-to path.
  700.   ---------------------------------------------------------------------------*/
  702. /* GRR:  for VMS and TOPS-20, add up to 13 to strlen */
  704.     if (FUNCTION == INIT) {
  705.         Trace((stderr, "initializing buildpath to "));
  706.         if ((buildpath = (char *)malloc(strlen(G.filename)+rootlen+1)) ==
  707.             (char *)NULL)
  708.             return 10;
  709.         if ((rootlen > 0) && !renamed_fullpath) {
  710.             strcpy(buildpath, rootpath);
  711.             end = buildpath + rootlen;
  712.         } else {
  713.             *buildpath = '';
  714.             end = buildpath;
  715.         }
  716.         Trace((stderr, "[%s]n", buildpath));
  717.         return 0;
  718.     }
  720. /*---------------------------------------------------------------------------
  721.     ROOT:  if appropriate, store the path in rootpath and create it if neces-
  722.     sary; else assume it's a zipfile member and return.  This path segment
  723.     gets used in extracting all members from every zipfile specified on the
  724.     command line.
  725.   ---------------------------------------------------------------------------*/
  727. #if (!defined(SFX) || defined(SFX_EXDIR))
  728.     if (FUNCTION == ROOT) {
  729.         Trace((stderr, "initializing root path to [%s]n", pathcomp));
  730.         if (pathcomp == (char *)NULL) {
  731.             rootlen = 0;
  732.             return 0;
  733.         }
  734.         if ((rootlen = strlen(pathcomp)) > 0) {
  735.             if (pathcomp[rootlen-1] == '/') {
  736.                 pathcomp[--rootlen] = '';
  737.             }
  738.             if (rootlen > 0 && (stat(pathcomp, &G.statbuf) ||
  739.                 !S_ISDIR(G.statbuf.st_mode)))       /* path does not exist */
  740.             {
  741.                 if (!G.create_dirs /* || iswild(pathcomp) */ ) {
  742.                     rootlen = 0;
  743.                     return 2;   /* skip (or treat as stored file) */
  744.                 }
  745.                 /* create the directory (could add loop here to scan pathcomp
  746.                  * and create more than one level, but why really necessary?) */
  747.                 if (zvs_credir(pathcomp,-1L,-1L,-1L,(char *) -1,-1,0L,-1,-1)
  748.                     == -1)
  749.                 {
  750.                     Info(slide, 1, ((char *)slide,
  751.                       "checkdir:  cannot create extraction directory: %sn",
  752.                       pathcomp));
  753.                     rootlen = 0;   /* path didn't exist, tried to create, and */
  754.                     return 3;  /* failed:  file exists, or 2+ levels required */
  755.                 }
  756.             }
  757.             if ((rootpath = (char *)malloc(rootlen+2)) == (char *)NULL) {
  758.                 rootlen = 0;
  759.                 return 10;
  760.             }
  761.             strcpy(rootpath, pathcomp);
  762.             rootpath[rootlen++] = '/';
  763.             rootpath[rootlen] = '';
  764.             Trace((stderr, "rootpath now = [%s]n", rootpath));
  765.         }
  766.         return 0;
  767.     }
  768. #endif /* !SFX || SFX_EXDIR */
  770. /*---------------------------------------------------------------------------
  771.     END:  free rootpath, immediately prior to program exit.
  772.   ---------------------------------------------------------------------------*/
  774.     if (FUNCTION == END) {
  775.         Trace((stderr, "freeing rootpathn"));
  776.         if (rootlen > 0) {
  777.             free(rootpath);
  778.             rootlen = 0;
  779.         }
  780.         return 0;
  781.     }
  783.     return 99;  /* should never reach */
  785. } /* end function checkdir() */
  791. #ifdef MORE
  793. /**************************/
  794. /* Function screenlines() */
  795. /**************************/
  797. int screenlines()
  798. {
  799.     char *envptr, *getenv();
  800.     int n;
  802.     /* GRR:  this is overly simplistic; should use winsize struct and
  803.      * appropriate TIOCGWINSZ ioctl(), assuming exists on enough systems
  804.      */
  805.     envptr = getenv("LINES");
  806.     if (envptr == (char *)NULL || (n = atoi(envptr)) < 5)
  807.         return 24;   /* VT-100 assumed to be minimal hardware */
  808.     else
  809.         return n;
  810. }
  812. #endif /* MORE */
  818. /****************************/
  819. /* Function close_outfile() */
  820. /****************************/
  822. void close_outfile(__G)    /* GRR: change to return PK-style warning level */
  823.     __GDEF
  824. {
  826. /*---------------------------------------------------------------------------
  827.     If symbolic links are supported, allocate a storage area, put the uncom-
  828.     pressed "data" in it, and create the link.  Since we know it's a symbolic
  829.     link to start with, we shouldn't have to worry about overflowing unsigned
  830.     ints with unsigned longs.
  831.   ---------------------------------------------------------------------------*/
  833. #ifdef SYMLINKS
  834.     if (G.symlnk) {
  835.         unsigned ucsize = (unsigned)G.lrec.ucsize;
  836.         char *linktarget = (char *)malloc((unsigned)G.lrec.ucsize+1);
  838.         fclose(G.outfile);                      /* close "data" file... */
  839.         G.outfile = fopen(G.filename, FOPR);    /* ...and reopen for reading */
  840.         if (!linktarget || fread(linktarget, 1, ucsize, G.outfile) !=
  841.                            (int)ucsize)
  842.         {
  843.             Info(slide, 0x201, ((char *)slide,
  844.               "warning:  symbolic link (%s) failedn", G.filename));
  845.             if (linktarget)
  846.                 free(linktarget);
  847.             fclose(G.outfile);
  848.             return;
  849.         }
  850.         fclose(G.outfile);                  /* close "data" file for good... */
  851.         unlink(G.filename);                 /* ...and delete it */
  852.         linktarget[ucsize] = '';
  853.         if (QCOND2)
  854.             Info(slide, 0, ((char *)slide, "-> %s ", linktarget));
  855.         if (symlink(linktarget, G.filename))  /* create the real link */
  856.             perror("symlink error");
  857.         free(linktarget);
  858.         return;                             /* can't set time on symlinks */
  859.     }
  860. #endif /* SYMLINKS */
  862.     fclose(G.outfile);
  864. /*---------------------------------------------------------------------------
  865.     Change the file permissions from default ones to those stored in the
  866.     zipfile.
  867.   ---------------------------------------------------------------------------*/
  869. #ifndef NO_CHMOD
  870.     if (chmod(G.filename, 0xffff & G.pInfo->file_attr))
  871.         perror("chmod (file attributes) error");
  872. #endif
  874. /*---------------------------------------------------------------------------
  875.     AOS/VS only allows setting file times at creation but has its own permis-
  876.     sions scheme which is better invoked here if the necessary information
  877.     was in fact stored.  In theory, we should look through an entire series
  878.     of extra fields that might exist for the same file, but we're not going
  879.     to bother.  If we set up other types of extra fields, or if we run into
  880.     other environments that add their own stuff to existing entries in ZIP
  881.     files, we'll have to.  NOTE:  already copied extra-field stuff into
  882.     zzextrafld structure when file was created.
  883.   ---------------------------------------------------------------------------*/
  885.     if (G.extra_field != NULL) {
  886.         if (!memcmp(ZEXTRA_HEADID, zzextrafld.extra_header_id,
  887.                     sizeof(zzextrafld.extra_header_id))  &&
  888.             !memcmp(ZEXTRA_SENTINEL, zzextrafld.extra_sentinel,
  889.                     sizeof(zzextrafld.extra_sentinel))  &&
  890.             zzextrafld.fstat_packet.norm_fstat_packet.styp_type != $FLNK)
  891.             /* (AOS/VS links don't have ACLs) */
  892.         {
  893.             /* vs_path was set (in this case) when we created the file */
  894.             if (sys_sacl(vs_path, zzextrafld.aclbuf)) {
  895.                 Info(slide, 0x201, ((char *)slide,
  896.                   "error: cannot set ACL for %sn", G.filename));
  897.                 perror("sys_sacl()");
  898.             }
  899.         }
  900.     }
  901. } /* end function close_outfile() */
  906. #ifndef SFX
  908. /************************/
  909. /*  Function version()  */
  910. /************************/
  912. void version(__G)
  913.     __GDEF
  914. {
  915. #if defined(CRAY) || defined(NX_CURRENT_COMPILER_RELEASE) || defined(NetBSD)
  916.     char buf1[40];
  917. #if defined(CRAY) || defined(NX_CURRENT_COMPILER_RELEASE)
  918.     char buf2[40];
  919. #endif
  920. #endif
  922.     /* Pyramid, NeXT have problems with huge macro expansion, too:  no Info() */
  923.     sprintf((char *)slide, LoadFarString(CompiledWith),
  925. #ifdef __GNUC__
  926. #  ifdef NX_CURRENT_COMPILER_RELEASE
  927.       (sprintf(buf1, "NeXT DevKit %d.%02d ", NX_CURRENT_COMPILER_RELEASE/100,
  928.         NX_CURRENT_COMPILER_RELEASE%100), buf1),
  929.       (strlen(__VERSION__) > 8)? "(gcc)" :
  930.         (sprintf(buf2, "(gcc %s)", __VERSION__), buf2),
  931. #  else
  932.       "gcc ", __VERSION__,
  933. #  endif
  934. #else
  935. #  if defined(CRAY) && defined(_RELEASE)
  936.       "cc ", (sprintf(buf1, "version %d", _RELEASE), buf1),
  937. #  else
  938. #  ifdef __VERSION__
  939.       "cc ", __VERSION__,
  940. #  else
  941.       "cc", "",
  942. #  endif
  943. #  endif
  944. #endif
  946.       "Unix",
  948. #if defined(sgi) || defined(__sgi)
  949.       " (Silicon Graphics IRIX)",
  950. #else
  951. #ifdef sun
  952. #  ifdef sparc
  953. #    ifdef __SVR4
  954.       " (Sun Sparc/Solaris)",
  955. #    else /* may or may not be SunOS */
  956.       " (Sun Sparc)",
  957. #    endif
  958. #  else
  959. #  if defined(sun386) || defined(i386)
  960.       " (Sun 386i)",
  961. #  else
  962. #  if defined(mc68020) || defined(__mc68020__)
  963.       " (Sun 3)",
  964. #  else /* mc68010 or mc68000:  Sun 2 or earlier */
  965.       " (Sun 2)",
  966. #  endif
  967. #  endif
  968. #  endif
  969. #else
  970. #ifdef __hpux
  971.       " (HP/UX)",
  972. #else
  973. #ifdef __osf__
  974.       " (DEC OSF/1)",
  975. #else
  976. #ifdef _AIX
  977.       " (IBM AIX)",
  978. #else
  979. #ifdef aiws
  980.       " (IBM RT/AIX)",
  981. #else
  982. #if defined(CRAY) || defined(cray)
  983. #  ifdef _UNICOS
  984.       (sprintf(buf2, " (Cray UNICOS release %d)", _UNICOS), buf2),
  985. #  else
  986.       " (Cray UNICOS)",
  987. #  endif
  988. #else
  989. #if defined(uts) || defined(UTS)
  990.       " (Amdahl UTS)",
  991. #else
  992. #ifdef NeXT
  993. #  ifdef mc68000
  994.       " (NeXTStep/black)",
  995. #  else
  996.       " (NeXTStep for Intel)",
  997. #  endif
  998. #else              /* the next dozen or so are somewhat order-dependent */
  999. #ifdef LINUX
  1000. #  ifdef __ELF__
  1001.       " (Linux ELF)",
  1002. #  else
  1003.       " (Linux a.out)",
  1004. #  endif
  1005. #else
  1006. #ifdef MINIX
  1007.       " (Minix)",
  1008. #else
  1009. #ifdef M_UNIX
  1010.       " (SCO Unix)",
  1011. #else
  1012. #ifdef M_XENIX
  1013.       " (SCO Xenix)",
  1014. #else
  1015. #ifdef __NetBSD__
  1016. #  ifdef NetBSD0_8
  1017.       (sprintf(buf1, " (NetBSD 0.8%c)", (char)(NetBSD0_8 - 1 + 'A')), buf1),
  1018. #  else
  1019. #  ifdef NetBSD0_9
  1020.       (sprintf(buf1, " (NetBSD 0.9%c)", (char)(NetBSD0_9 - 1 + 'A')), buf1),
  1021. #  else
  1022. #  ifdef NetBSD1_0
  1023.       (sprintf(buf1, " (NetBSD 1.0%c)", (char)(NetBSD1_0 - 1 + 'A')), buf1),
  1024. #  else
  1025.       (BSD4_4 == 0.5)? " (NetBSD before 0.9)" : " (NetBSD 1.1 or later)",
  1026. #  endif
  1027. #  endif
  1028. #  endif
  1029. #else
  1030. #ifdef __FreeBSD__
  1031.       (BSD4_4 == 0.5)? " (FreeBSD 1.x)" : " (FreeBSD 2.0 or later)",
  1032. #else
  1033. #ifdef __bsdi__
  1034.       (BSD4_4 == 0.5)? " (BSD/386 1.0)" : " (BSD/386 1.1 or later)",
  1035. #else
  1036. #ifdef __386BSD__
  1037.       (BSD4_4 == 1)? " (386BSD, post-4.4 release)" : " (386BSD)",
  1038. #else
  1039. #if defined(i486) || defined(__i486) || defined(__i486__)
  1040.       " (Intel 486)",
  1041. #else
  1042. #if defined(i386) || defined(__i386) || defined(__i386__)
  1043.       " (Intel 386)",
  1044. #else
  1045. #ifdef pyr
  1046.       " (Pyramid)",
  1047. #else
  1048. #ifdef ultrix
  1049. #  ifdef mips
  1050.       " (DEC/MIPS)",
  1051. #  else
  1052. #  ifdef vax
  1053.       " (DEC/VAX)",
  1054. #  else /* __alpha? */
  1055.       " (DEC/Alpha)",
  1056. #  endif
  1057. #  endif
  1058. #else
  1059. #ifdef gould
  1060.       " (Gould)",
  1061. #else
  1062. #ifdef MTS
  1063.       " (MTS)",
  1064. #else
  1065. #ifdef __convexc__
  1066.       " (Convex)",
  1067. #else
  1068.       "",
  1069. #endif /* Convex */
  1070. #endif /* MTS */
  1071. #endif /* Gould */
  1072. #endif /* DEC */
  1073. #endif /* Pyramid */
  1074. #endif /* 386 */
  1075. #endif /* 486 */
  1076. #endif /* 386BSD */
  1077. #endif /* BSDI BSD/386 */
  1078. #endif /* NetBSD */
  1079. #endif /* FreeBSD */
  1080. #endif /* SCO Xenix */
  1081. #endif /* SCO Unix */
  1082. #endif /* Minix */
  1083. #endif /* Linux */
  1084. #endif /* NeXT */
  1085. #endif /* Amdahl */
  1086. #endif /* Cray */
  1087. #endif /* RT/AIX */
  1088. #endif /* AIX */
  1089. #endif /* OSF/1 */
  1090. #endif /* HP/UX */
  1091. #endif /* Sun */
  1092. #endif /* SGI */
  1094. #ifdef __DATE__
  1095.       " on ", __DATE__
  1096. #else
  1097.       "", ""
  1098. #endif
  1099.     );
  1101.     (*G.message)((zvoid *)&G, slide, (ulg)strlen((char *)slide), 0);
  1103. } /* end function version() */
  1105. #endif /* !SFX */
  1111. /* ===================================================================
  1112.  * ZVS_CREATE()
  1113.  * Function to create a file with specified times.  The times should be sent
  1114.  * as long ints in DG time format; use -1 to set to the current times.  You
  1115.  * may also specify a pointer to the ACL, the file type (see PARU.H, and do
  1116.  * not specify dirs or links), the element size, and the max index level.
  1117.  * For all of these parameters you may use -1 to specify the default.
  1118.  *
  1119.  * Returns 0 if no error, or the error code returned by ?CREATE.
  1120.  *
  1121.  *    HISTORY:
  1122.  *        15-dec-93 dbl
  1123.  *        31-may-94 dbl: added call to convert pathname to AOS/VS
  1124.  *
  1125.  *
  1126.  */
  1128. int zvs_create(ZCONST char *fname, long cretim, long modtim, long acctim,
  1129.                char *pacl, int ftyp, int eltsize, int maxindlev)
  1130. {
  1131.     P_CREATE    pcr_stru;
  1132.     P_CTIM      pct_stru;
  1134.     pcr_stru.cftyp_format = 0;           /* unspecified record format */
  1135.     if (ftyp == -1)                      /* default file type to UNX */
  1136.         pcr_stru.cftyp_entry = $FUNX;
  1137.     else
  1138.         pcr_stru.cftyp_entry = ftyp;
  1139.     pcr_stru.ctim = &pct_stru;
  1140.     pcr_stru.cacp = pacl;
  1141.     pcr_stru.cdel = eltsize;
  1142.     pcr_stru.cmil = maxindlev;
  1144.     pct_stru.tcth.long_time = cretim;
  1145.     pct_stru.tath.long_time = acctim;
  1146.     pct_stru.tmth.long_time = modtim;
  1148.     return (sys_create(ux_to_vs_name(Vs_path, fname), &pcr_stru));
  1150. } /* end zvs_create() */
  1154. /* ===================================================================
  1155.  * ZVS_CREDIR()
  1156.  * Function to create a dir as specified.  The times should be sent
  1157.  * as long ints in DG time format; use -1 to set to the current times.  You
  1158.  * may also specify a pointer to the ACL, the file type (either $FDIR or $FCPD; see PARU.H),
  1159.  * the max # blocks (if a CPD), the hash frame size, and the max index level.
  1160.  * For all of these parameters (except for the CPD's maximum blocks),
  1161.  * you may use -1 to specify the default.
  1162.  *
  1163.  * (The System Call Dictionary says both that you may specify a
  1164.  * maximum-index-level value up to the maximum, with 0 for a contiguous
  1165.  * directory, and that 3 is always used for this whatever you specify.)
  1166.  *
  1167.  * If you specify anything other than CPD for the file type, DIR will
  1168.  * be used.
  1169.  *
  1170.  * Returns 0 if no error, or the error code returned by ?CREATE.
  1171.  *
  1172.  *    HISTORY:
  1173.  *        1-jun-94 dbl
  1174.  *
  1175.  *
  1176.  */
  1178. int zvs_credir(ZCONST char *dname, long cretim, long modtim, long acctim,
  1179.                char *pacl, int ftyp, long maxblocks, int hashfsize,
  1180.                int maxindlev)
  1181. {
  1182.     P_CREATE_DIR    pcr_stru;
  1183.     P_CTIM          pct_stru;
  1185.     if (ftyp != $FCPD)                      /* default file type to UNX */
  1186.         pcr_stru.cftyp_entry = $FDIR;
  1187.     else
  1188.     {
  1189.         pcr_stru.cftyp_entry = ftyp;
  1190.         pcr_stru.cmsh = maxblocks;
  1191.     }
  1193.     pcr_stru.ctim = &pct_stru;
  1194.     pcr_stru.cacp = pacl;
  1195.     pcr_stru.chfs = hashfsize;
  1196.     pcr_stru.cmil = maxindlev;
  1198.     pct_stru.tcth.long_time = cretim;
  1199.     pct_stru.tath.long_time = acctim;
  1200.     pct_stru.tmth.long_time = modtim;
  1202.     return (sys_create(ux_to_vs_name(Vs_path, dname), &pcr_stru));
  1204. } /* end zvs_credir() */
  1208. /* ===================================================================
  1209.  * UX_TO_VS_NAME() - makes a somewhat dumb pass at converting a Unix
  1210.  *           filename to an AOS/VS filename.  This should
  1211.  *           be just about adequate to handle the results
  1212.  *           of similarly-simple AOS/VS-to-Unix conversions
  1213.  *           in the ZIP program.  It does not guarantee a
  1214.  *           legal AOS/VS filename for every Unix filename;
  1215.  *           conspicuous examples would be names with
  1216.  *           embedded ./ and ../ (which will receive no
  1217.  *           special treatment).
  1218.  *
  1219.  *       RETURNS: pointer to the result (which is an input parameter)
  1220.  *
  1221.  *       NOTE: calling code is responsible for making sure
  1222.  *           the output buffer is big enough!
  1223.  *
  1224.  *       HISTORY:
  1225.  *           31-may-94 dbl
  1226.  *
  1227.  */
  1228. char *ux_to_vs_name(char *outname, ZCONST char *inname)
  1229. {
  1230.     ZCONST char *ip=inname, *op=outname;
  1233.     if (ip[0] == '.') {
  1234.         if (ip[1] == '/') {
  1235.             *(op++) = '=';
  1236.             ip += 2;
  1237.         } else if (ip[1] == '.'  &&  ip[2] == '/') {
  1238.             *(op++) = '^';
  1239.             ip += 3;
  1240.         }
  1241.     }
  1243.     do {
  1244.         if (*ip == '/')
  1245.             *(op++) = ':';
  1246.         else if (strchr(
  1247.            "0123456789_$?.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",
  1248.            *ip) != NULL)
  1249.         {
  1250.             *(op++) = *ip;
  1251.         } else
  1252.             *(op++) = '?';
  1254.     } while (*(ip++) != '');
  1256.     return outname;
  1258. } /* end ux_to_vs_name() */
  1262. /* =================================================================== */
  1264. /* DGDATE
  1265.    Two functions do encode/decode dates in DG system format.
  1267.    Usage:
  1268.     long value,year,month,day;
  1270.     value=dgdate(month,day,year);
  1271.     undgdate(value,&month,&day,&year);   [GRR:  not used in UnZip: removed]
  1273.    Notes:
  1275.    1. DG date functions only work on dates within the range
  1276.       Jan 1, 1968 through Dec 31, 2099.  I have tested these
  1277.       functions through the same range with exact agreement.
  1278.       For dates outside of that range, the DG system calls
  1279.       may return different values than these functions.
  1281.    2. dgundate() accepts values between 0 and 48213 inclusive.
  1282.       These correspond to 12/31/1967 and 12/31/2099.
  1284.    3. Both functions assume the data is in the native OS byte
  1285.       order.  So if you're reading or writing these fields from
  1286.       a file that has been passed between AOS/VS and PC-DOS you
  1287.       will need to swap byte order.
  1289.    4. With reference to byte order, the entire range of values
  1290.       supported by these functions will fit into an unsigned
  1291.       short int.  In most cases the input or output will be
  1292.       in that variable type.  You are better off casting the
  1293.       value to/from unsigned short so you only need to concern
  1294.       yourself with swapping two bytes instead of four.
  1296.   Written by: Stanley J. Gula
  1297.               US&T, Inc.
  1298.               529 Main Street, Suite 1
  1299.               Indian Orchard, MA 01151
  1300.               (413)-543-3672
  1301.               Copyright (c) 1990 US&T, Inc.
  1302.               All rights reserved.
  1304.               I hereby release these functions into the public
  1305.               domain.  You may use these routines freely as long
  1306.               as the US&T copyright remains intact in the source
  1307.               code.
  1309.               Stanley J. Gula     July 24, 1990
  1310. */
  1312. long motable[13]={0,31,59,90,120,151,181,212,243,273,304,334,365};
  1314. long yrtable[132]={
  1315.       366,  731, 1096, 1461, 1827, 2192, 2557, 2922, 3288, 3653,
  1316.      4018, 4383, 4749, 5114, 5479, 5844, 6210, 6575, 6940, 7305,
  1317.      7671, 8036, 8401, 8766, 9132, 9497, 9862,10227,10593,10958,
  1318.     11323,11688,12054,12419,12784,13149,13515,13880,14245,14610,
  1319.     14976,15341,15706,16071,16437,16802,17167,17532,17898,18263,
  1320.     18628,18993,19359,19724,20089,20454,20820,21185,21550,21915,
  1321.     22281,22646,23011,23376,23742,24107,24472,24837,25203,25568,
  1322.     25933,26298,26664,27029,27394,27759,28125,28490,28855,29220,
  1323.     29586,29951,30316,30681,31047,31412,31777,32142,32508,32873,
  1324.     33238,33603,33969,34334,34699,35064,35430,35795,36160,36525,
  1325.     36891,37256,37621,37986,38352,38717,39082,39447,39813,40178,
  1326.     40543,40908,41274,41639,42004,42369,42735,43100,43465,43830,
  1327.     44196,44561,44926,45291,45657,46022,46387,46752,47118,47483,
  1328.     47848,48213};
  1330. /* Given y,m,d return # of days since 12/31/67 */
  1331. long int dgdate(short mm, short dd, short yy)
  1332. {
  1333.     long int temp;
  1334.     short ytmp;
  1336.     if (mm<1 || mm>12 || dd<1 || dd>31 || yy<1968 || yy>2099)
  1337.         return 0L;
  1339.     /* Figure in whole years since 1968 + whole months plus days */
  1340.     temp=365L*(long)(yy-1968) + motable[mm-1] + (long)dd;
  1342.     /* Adjust for leap years - note we don't account for skipped leap
  1343.        year in years divisible by 1000 but not by 4000.  We're correct
  1344.        through the year 2099 */
  1345.     temp+=(yy-1965)/4;
  1347.     /* Correct for this year */
  1348.     /* In leap years, if date is 3/1 or later, bump */
  1349.     if ((yy%4==0) && (mm>2))
  1350.         temp++;
  1352.     return temp;
  1353. }