home *** CD-ROM | disk | FTP | other *** search
/ Windoware / WINDOWARE_1_6.iso / source / wzun11sr / misc.c < prev    next >
Text File  |  1991-10-16  |  18KB  |  477 lines
  1. /*---------------------------------------------------------------------------
  2.  
  3.   misc.c
  4.  
  5.   This file contains a number of useful but not particularly closely related
  6.   functions; their main claim to fame is that they don't change much, so
  7.   this file should rarely need to be recompiled.  The CRC-32 stuff is from
  8.   crc32.c; do_string() is from nunzip.c; a_to_e() is from ascebc.c; makeword/
  9.   makelong() are from unzip.c; and memset() and memcpy() are from zmemset.c
  10.   and zmemcpy.c, respectively.  Lumped together here to cut down on the size
  11.   of unzip.c and the number of associated files floating around.
  12.  
  13.   ---------------------------------------------------------------------------
  14.  
  15.   Contributions by C. Mascott, Allan Bjorklund, Bill Davidsen, Bo Kullmar,
  16.   Warner Losh, Greg Roelofs, Larry Jones, Mark Edwards, Antoine Verheijen,
  17.   and probably many others.
  18.  
  19.   ---------------------------------------------------------------------------
  20.  
  21.   Copyright, applying to UpdateCRC() and crc_32_tab[]:
  22.  
  23.      COPYRIGHT (C) 1986 Gary S. Brown.  You may use this program, or code
  24.      or tables extracted from it, as desired without restriction.
  25.  
  26.   ---------------------------------------------------------------------------*/
  27.  
  28.  
  29. #include "unzip.h"
  30. #ifdef MSWIN
  31. #include <windows.h>
  32. #include "wizunzip.h"
  33. #endif
  34.  
  35.  
  36.  
  37. #ifndef ZIPINFO   /* no need to calculate CRCs */
  38.  
  39. /**************************/
  40. /*  Function UpdateCRC()  */
  41. /**************************/
  42.  
  43.  /*--------------------------------------------------------------------
  44.  
  45.    First, the polynomial itself and its table of feedback terms.  The
  46.    polynomial is
  47.    X^32+X^26+X^23+X^22+X^16+X^12+X^11+X^10+X^8+X^7+X^5+X^4+X^2+X^1+X^0
  48.  
  49.    Note that we take it "backwards" and put the highest-order term in
  50.    the lowest-order bit.  The X^32 term is "implied"; the LSB is the
  51.    X^31 term, etc.  The X^0 term (usually shown as "+1") results in
  52.    the MSB being 1.
  53.  
  54.    Note that the usual hardware shift register implementation, which
  55.    is what we're using (we're merely optimizing it by doing eight-bit
  56.    chunks at a time) shifts bits into the lowest-order term.  In our
  57.    implementation, that means shifting towards the right.  Why do we
  58.    do it this way?  Because the calculated CRC must be transmitted in
  59.    order from highest-order term to lowest-order term.  UARTs transmit
  60.    characters in order from LSB to MSB.  By storing the CRC this way,
  61.    we hand it to the UART in the order low-byte to high-byte; the UART
  62.    sends each low-bit to hight-bit; and the result is transmission bit
  63.    by bit from highest- to lowest-order term without requiring any bit
  64.    shuffling on our part.  Reception works similarly.
  65.  
  66.    The feedback terms table consists of 256, 32-bit entries.  Notes:
  67.  
  68.        The table can be generated at runtime if desired; code to do so
  69.        is shown later.  It might not be obvious, but the feedback
  70.        terms simply represent the results of eight shift/xor opera-
  71.        tions for all combinations of data and CRC register values.
  72.  
  73.        The values must be right-shifted by eight bits by the "updcrc"
  74.        logic; the shift must be unsigned (bring in zeroes).  On some
  75.        hardware you could probably optimize the shift in assembler by
  76.        using byte-swap instructions.
  77.        polynomial $edb88320
  78.  
  79.    --------------------------------------------------------------------*/
  80.  
  81. ULONG crc_32_tab[] =
  82. {
  83.     0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L,
  84.     0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L,
  85.     0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L,
  86.     0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL,
  87.     0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L,
  88.     0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L,
  89.     0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L,
  90.     0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL,
  91.     0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L,
  92.     0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL,
  93.     0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L,
  94.     0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L,
  95.     0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L,
  96.     0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL,
  97.     0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL,
  98.     0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L,
  99.     0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL,
  100.     0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L,
  101.     0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L,
  102.     0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L,
  103.     0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL,
  104.     0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L,
  105.     0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L,
  106.     0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL,
  107.     0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L,
  108.     0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L,
  109.     0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L,
  110.     0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L,
  111.     0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L,
  112.     0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL,
  113.     0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL,
  114.     0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L,
  115.     0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L,
  116.     0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL,
  117.     0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL,
  118.     0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L,
  119.     0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL,
  120.     0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L,
  121.     0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL,
  122.     0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L,
  123.     0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL,
  124.     0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L,
  125.     0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L,
  126.     0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL,
  127.     0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L,
  128.     0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L,
  129.     0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L,
  130.     0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L,
  131.     0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L,
  132.     0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L,
  133.     0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL,
  134.     0x2d02ef8dL
  135. };
  136.  
  137.  
  138. void UpdateCRC(s, len)
  139. register byte *s;
  140. register int len;
  141.  /* update running CRC calculation with contents of a buffer */
  142. {
  143.     register ULONG crcval = crc32val;
  144.  
  145.  
  146.     while (len--)
  147.         crcval = crc_32_tab[((byte) crcval ^ (*s++)) & 0xff] ^ (crcval >> 8);
  148.     crc32val = crcval;
  149. }
  150.  
  151. #endif /* !ZIPINFO */
  152.  
  153.  
  154.  
  155.  
  156.  
  157. /**************************/
  158. /*  Function do_string()  */
  159. /**************************/
  160.  
  161. int do_string(len, option)      /* return PK-type error code */
  162. unsigned int len;               /* without prototype, UWORD converted to this */
  163. int option;
  164. {
  165.     int block_length, error = 0;
  166.     UWORD comment_bytes_left, extra_len;
  167.  
  168.  
  169.  
  170. /*---------------------------------------------------------------------------
  171.     This function processes arbitrary-length (well, usually) strings.  Three
  172.     options are allowed:  SKIP, wherein the string is skipped pretty logical,
  173.     eh?); DISPLAY, wherein the string is printed to standard output after un-
  174.     dergoing any necessary or unnecessary character conversions; and FILENAME,
  175.     wherein the string is put into the filename[] array after undergoing ap-
  176.     propriate conversions (including case-conversion, if that is indicated:
  177.     see the global variable lcflag).  The latter option should be OK, since
  178.     filename is now dimensioned at 1025, but we check anyway.
  179.  
  180.     The string, by the way, is assumed to start at the current file-pointer
  181.     position; its length is given by len.  So start off by checking length
  182.     of string:  if zero, we're already set.
  183.   ---------------------------------------------------------------------------*/
  184.  
  185.     if (!len)
  186.         return (0);             /* 0:  no error */
  187.  
  188.     switch (option) {
  189.  
  190.     /*
  191.      * First case:  print string on standard output.  First set loop vari-
  192.      * ables, then loop through the comment in chunks of OUTBUFSIZ bytes,
  193.      * converting formats and printing as we go.  The second half of the
  194.      * loop conditional was added because the file might be truncated, in
  195.      * which case comment_bytes_left will remain at some non-zero value for
  196.      * all time.  outbuf is used as a scratch buffer because it is avail-
  197.      * able (we should be either before or in between any file processing).
  198.      * [The typecast in front of the min() macro was added because of the
  199.      * new promotion rules under ANSI C; readbuf() wants an int, but min()
  200.      * returns a signed long, if I understand things correctly.  The proto-
  201.      * type should handle it, but just in case...]
  202.      */
  203.  
  204.     case DISPLAY:
  205.         comment_bytes_left = len;
  206.         block_length = OUTBUFSIZ;    /* for the while statement, first time */
  207.         while (comment_bytes_left > 0 && block_length > 0) {
  208.             if ((block_length = readbuf((char *) outbuf,
  209.                          (int) min(OUTBUFSIZ, comment_bytes_left))) <= 0)
  210.                 return (51);    /* 51:  unexpected EOF */
  211.             comment_bytes_left -= block_length;
  212.             NUKE_CRs(outbuf, block_length);     /* (modifies block_length) */
  213.  
  214.             /*  this is why we allocated an extra byte for outbuf: */
  215.             outbuf[block_length] = '\0';        /* terminate w/zero:  ASCIIZ */
  216.  
  217.             A_TO_N(outbuf);     /* translate string to native */
  218.  
  219. #ifdef MSWIN
  220.             WriteStringToMsgWin(outbuf, bRealTimeMsgUpdate); /* ran out of local mem -- had to cheat */
  221. #else
  222.             printf("%s", outbuf);
  223. #endif
  224.         }
  225.         printf("\n", outbuf);   /* assume no newline at end */
  226.         break;
  227.  
  228.     /*
  229.      * Second case:  read string into filename[] array.  The filename should
  230.      * never ever be longer than FILNAMSIZ-1 (1024), but for now we'll check,
  231.      * just to be sure.
  232.      */
  233.  
  234.     case FILENAME:
  235.         extra_len = 0;
  236.         if (len >= FILNAMSIZ) {
  237.             fprintf(stderr, "warning:  filename too long--truncating.\n");
  238.             error = 1;          /* 1:  warning error */
  239.             extra_len = len - FILNAMSIZ + 1;
  240.             len = FILNAMSIZ - 1;
  241.         }
  242.         if (readbuf(filename, len) <= 0)
  243.             return (51);        /* 51:  unexpected EOF */
  244.         filename[len] = '\0';   /* terminate w/zero:  ASCIIZ */
  245.  
  246.         A_TO_N(filename);       /* translate string to native */
  247.  
  248. #ifndef ZIPINFO
  249.         if (lcflag)
  250.             TOLOWER(filename, filename);        /* replace with lowercase fn. */
  251. #endif
  252.  
  253.         if (!extra_len)         /* we're done here */
  254.             break;
  255.  
  256.         /*
  257.          * We truncated the filename, so print what's left and then fall
  258.          * through to the SKIP routine.
  259.          */
  260.         fprintf(stderr, "[ %s ]\n", filename);
  261.         len = extra_len;
  262.         /*  FALL THROUGH...  */
  263.  
  264.     /*
  265.      * Third case:  skip string, adjusting readbuf's internal variables
  266.      * as necessary (and possibly skipping to and reading a new block of
  267.      * data).
  268.      */
  269.  
  270.     case SKIP:
  271.         LSEEK(cur_zipfile_bufstart + (inptr-inbuf) + len)
  272.         break;
  273.  
  274.     }                           /* end switch (option) */
  275.  
  276.     return (error);
  277.  
  278. }                               /* end function do_string() */
  279.  
  280.  
  281.  
  282.  
  283.  
  284. #ifdef EBCDIC
  285.  
  286. /*
  287.  * This is the MTS ASCII->EBCDIC translation table. It provides a 1-1
  288.  * translation from ISO 8859/1 8-bit ASCII to IBM Code Page 37 EBCDIC.
  289.  */
  290.  
  291. unsigned char ebcdic[] =
  292. {
  293.     0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
  294.     0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
  295.     0x40, 0x5a, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
  296.     0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
  297.     0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
  298.     0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xba, 0xe0, 0xbb, 0xb0, 0x6d,
  299.     0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
  300.     0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x4f, 0xd0, 0xa1, 0x07,
  301.     0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
  302.     0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xff,
  303.     0x41, 0xaa, 0x4a, 0xb1, 0x9f, 0xb2, 0x6a, 0xb5, 0xbd, 0xb4, 0x9a, 0x8a, 0x5f, 0xca, 0xaf, 0xbc,
  304.     0x90, 0x8f, 0xea, 0xfa, 0xbe, 0xa0, 0xb6, 0xb3, 0x9d, 0xda, 0x9b, 0x8b, 0xb7, 0xb8, 0xb9, 0xab,
  305.     0x64, 0x65, 0x62, 0x66, 0x63, 0x67, 0x9e, 0x68, 0x74, 0x71, 0x72, 0x73, 0x78, 0x75, 0x76, 0x77,
  306.     0xac, 0x69, 0xed, 0xee, 0xeb, 0xef, 0xec, 0xbf, 0x80, 0xfd, 0xfe, 0xfb, 0xfc, 0xad, 0xae, 0x59,
  307.     0x44, 0x45, 0x42, 0x46, 0x43, 0x47, 0x9c, 0x48, 0x54, 0x51, 0x52, 0x53, 0x58, 0x55, 0x56, 0x57,
  308.     0x8c, 0x49, 0xcd, 0xce, 0xcb, 0xcf, 0xcc, 0xe1, 0x70, 0xdd, 0xde, 0xdb, 0xdc, 0x8d, 0x8e, 0xdf
  309. };
  310.  
  311. #endif                          /* EBCDIC */
  312.  
  313.  
  314.  
  315.  
  316.  
  317. #ifdef NOTINT16
  318.  
  319. /*************************/
  320. /*  Function makeword()  */
  321. /*************************/
  322.  
  323. UWORD makeword(b)
  324. byte *b;
  325.  /*
  326.   * Convert Intel style 'short' integer to non-Intel non-16-bit
  327.   * host format.  This routine also takes care of byte-ordering.
  328.   */
  329. {
  330. /*
  331.     return  ( ((UWORD)(b[1]) << 8)  |  (UWORD)(b[0]) );
  332.  */
  333.     return ((b[1] << 8) | b[0]);
  334. }
  335.  
  336.  
  337.  
  338.  
  339.  
  340. /*************************/
  341. /*  Function makelong()  */
  342. /*************************/
  343.  
  344. ULONG makelong(sig)
  345. byte *sig;
  346.  /*
  347.   * Convert intel style 'long' variable to non-Intel non-16-bit
  348.   * host format.  This routine also takes care of byte-ordering.
  349.   */
  350. {
  351.     return (((ULONG) sig[3]) << 24)
  352.         + (((ULONG) sig[2]) << 16)
  353.         + (((ULONG) sig[1]) << 8)
  354.         + ((ULONG) sig[0]);
  355. }
  356.  
  357. #endif                          /* !NOTINT16 */
  358.  
  359.  
  360.  
  361.  
  362.  
  363. #ifdef VMS
  364.  
  365. /***************************/
  366. /*  Function return_VMS()  */
  367. /***************************/
  368.  
  369. void return_VMS(zip_error)
  370. int zip_error;
  371. {
  372. #ifdef RETURN_CODES
  373. /*---------------------------------------------------------------------------
  374.     Do our own, explicit processing of error codes and print message, since
  375.     VMS misinterprets return codes as rather obnoxious system errors ("access
  376.     violation," for example).
  377.   ---------------------------------------------------------------------------*/
  378.  
  379.     switch (zip_error) {
  380.  
  381.     case 0:
  382.         break;                  /* life is fine... */
  383.     case 1:
  384.         fprintf(stderr, "\n[return-code 1:  warning error \
  385. (e.g., failed CRC or unknown compression method)]\n");
  386.         break;
  387.     case 2:
  388.     case 3:
  389.         fprintf(stderr, "\n[return-code %d:  error in zipfile \
  390. (e.g., can't find local file header sig)]\n",
  391.                 zip_error);
  392.         break;
  393.     case 4:
  394.     case 5:
  395.     case 6:
  396.     case 7:
  397.     case 8:
  398.         fprintf(stderr, "\n[return-code %d:  insufficient memory]\n",
  399.                 zip_error);
  400.         break;
  401.     case 9:
  402.         fprintf(stderr, "\n[return-code 9:  zipfile not found]\n");
  403.         break;
  404.     case 10:                    /* this is the one that gives "access violation," I think */
  405.         fprintf(stderr, "\n[return-code 10:  bad or illegal parameters \
  406. specified on command line]\n");
  407.         break;
  408.     case 11:                    /* I'm not sure this one is implemented, but maybe soon? */
  409.         fprintf(stderr, "\n[return-code 11:  no files found to \
  410. extract/view/etc.]\n");
  411.         break;
  412.     case 50:
  413.         fprintf(stderr, "\n[return-code 50:  disk full \
  414. (or otherwise unable to open output file)]\n");
  415.         break;
  416.     case 51:
  417.         fprintf(stderr, "\n[return-code 51:  unexpected EOF in zipfile \
  418. (i.e., truncated)]\n");
  419.         break;
  420.     default:
  421.         fprintf(stderr, "\n[return-code %d:  unknown return-code \
  422. (who put this one in?  Wasn't me...)]\n",
  423.                 zip_error);
  424.         break;
  425.     }
  426. #endif                          /* RETURN_CODES */
  427.  
  428.     exit(0);                    /* everything okey-dokey as far as VMS concerned */
  429. }
  430.  
  431. #endif                          /* VMS */
  432.  
  433.  
  434.  
  435.  
  436.  
  437. #ifdef ZMEM                     /* memset, memcpy for systems without them */
  438.  
  439. /************************/
  440. /*  Function zmemset()  */
  441. /************************/
  442.  
  443. char *memset(buf, init, len)
  444. register char *buf, init;       /* buffer loc and initializer */
  445. register unsigned int len;      /* length of the buffer */
  446. {
  447.     char *start;
  448.  
  449.     start = buf;
  450.     while (len--)
  451.         *(buf++) = init;
  452.     return (start);
  453. }
  454.  
  455.  
  456.  
  457.  
  458.  
  459. /************************/
  460. /*  Function zmemcpy()  */
  461. /************************/
  462.  
  463. char *memcpy(dst, src, len)
  464. register char *dst, *src;
  465. register unsigned int len;
  466. {
  467.     char *start;
  468.  
  469.     start = dst;
  470.     while (len-- > 0)
  471.         *dst++ = *src++;
  472.     return (start);
  473. }
  474.  
  475. #endif                          /* ZMEM */
  476. 
  477.