utils/Install/sfxzip/fileio.c

   1 /*---------------------------------------------------------------------------
   2
   3   fileio.c
   4
   5   This file contains routines for doing direct but relatively generic input/
   6   output, file-related sorts of things, plus some miscellaneous stuff.  Most
   7   of the stuff has to do with opening, closing, reading and/or writing files.
   8
   9   Contains:  open_input_file()
  10              open_outfile()           (non-VMS, non-AOS/VS, non-CMS_MVS)
  11              undefer_input()
  12              defer_leftover_input()
  13              readbuf()
  14              readbyte()
  15              fillinbuf()
  16              flush()                  (non-VMS)
  17              disk_error()             (non-VMS)
  18              UzpMessagePrnt()
  19              UzpMessageNull()         (DLL only)
  20              UzpInput()
  21              UzpMorePause()
  22              UzpPassword()            (non-WINDLL)
  23              handler()
  24              dos_to_unix_time()       (non-VMS, non-VM/CMS, non-MVS)
  25              check_for_newer()        (non-VMS, non-OS/2, non-VM/CMS, non-MVS)
  26              do_string()
  27              makeword()
  28              makelong()
  29              str2iso()                (CRYPT && NEED_STR2ISO, only)
  30              str2oem()                (CRYPT && NEED_STR2OEM, only)
  31              memset()                 (ZMEM only)
  32              memcpy()                 (ZMEM only)
  33              zstrnicmp()
  34              zstat()                  (REGULUS only)
  35              fLoadFarString()         (SMALL_MEM only)
  36              fLoadFarStringSmall()    (SMALL_MEM only)
  37              fLoadFarStringSmall2()   (SMALL_MEM only)
  38              zfstrcpy()               (SMALL_MEM only)
  39
  40   ---------------------------------------------------------------------------*/
  41
  42
  43 #define FILEIO_C
  44 #define UNZIP_INTERNAL
  45 #include "unzip.h"
  46 #ifdef WINDLL
  47 #  include "windll/windll.h"
  48 #  include <setjmp.h>
  49 #endif
  50 #include "crypt.h"
  51 #include "ttyio.h"
  52
  53 off_t acelseek(off_t offset, int whence);
  54 int aceread(void *buf, size_t count);
  55 int aceopen(const char *path, int flags);
  56 int aceclose(int fd);
  57 int acesize(void);
  58 int acetell(int fd);
  59 char *replacestr(char *str1, char *str2, char *str3);
  60
  61 /* setup of codepage conversion for decryption passwords */
  62 #if CRYPT
  63 #  if (defined(CRYP_USES_ISO2OEM) && !defined(IZ_ISO2OEM_ARRAY))
  64 #    define IZ_ISO2OEM_ARRAY            /* pull in iso2oem[] table */
  65 #  endif
  66 #  if (defined(CRYP_USES_OEM2ISO) && !defined(IZ_OEM2ISO_ARRAY))
  67 #    define IZ_OEM2ISO_ARRAY            /* pull in oem2iso[] table */
  68 #  endif
  69 #endif
  70 #include "ebcdic.h"   /* definition/initialization of ebcdic[] */
  71
  72
  73 /*
  74    Note: Under Windows, the maximum size of the buffer that can be used
  75    with any of the *printf calls is 16,384, so win_fprintf was used to
  76    feed the fprintf clone no more than 16K chunks at a time. This should
  77    be valid for anything up to 64K (and probably beyond, assuming your
  78    buffers are that big).
  79 */
  80 #ifdef WINDLL
  81 #  define WriteError(buf,len,strm) \
  82    (win_fprintf(pG, strm, (extent)len, (char far *)buf) != (int)(len))
  83 #else /* !WINDLL */
  84 #  ifdef USE_FWRITE
  85 #    define WriteError(buf,len,strm) \
  86      ((extent)fwrite((char *)(buf),1,(extent)(len),strm) != (extent)(len))
  87 #  else
  88 #    define WriteError(buf,len,strm) \
  89      ((extent)write(fileno(strm),(char *)(buf),(extent)(len)) != (extent)(len))
  90 #  endif
  91 #endif /* ?WINDLL */
  92
  93 static int disk_error OF((__GPRO));
  94
  95
  96 /****************************/
  97 /* Strings used in fileio.c */
  98 /****************************/
  99
 100 #if (defined(UNIX) || defined(DOS_FLX_OS2_W32) || defined(__BEOS__))
 101    static ZCONST char Far CannotDeleteOldFile[] =
 102      "error:  cannot delete old %s\n";
 103 #ifdef UNIXBACKUP
 104    static ZCONST char Far CannotRenameOldFile[] =
 105      "error:  cannot rename old %s\n";
 106    static ZCONST char Far BackupSuffix[] = "~";
 107 #endif
 108 #endif /* UNIX || DOS_FLX_OS2_W32 || __BEOS__ */
 109
 110 static ZCONST char Far CannotOpenZipfile[] =
 111   "error:  cannot open zipfile [ %s ]\n";
 112 #if (!defined(VMS) && !defined(AOS_VS) && !defined(CMS_MVS) && !defined(MACOS))
 113    static ZCONST char Far CannotCreateFile[] = "error:  cannot create %s\n";
 114 #endif
 115 #ifdef NOVELL_BUG_FAILSAFE
 116    static ZCONST char Far NovellBug[] =
 117      "error:  %s: stat() says does not exist, but fopen() found anyway\n";
 118 #endif
 119 static ZCONST char Far ReadError[] = "error:  zipfile read error\n";
 120 static ZCONST char Far FilenameTooLongTrunc[] =
 121   "warning:  filename too long--truncating.\n";
 122 static ZCONST char Far ExtraFieldTooLong[] =
 123   "warning:  extra field too long (%d).  Ignoring...\n";
 124
 125 #ifdef WINDLL
 126    static ZCONST char Far DiskFullQuery[] =
 127      "%s:  write error (disk full?).\n";
 128 #else
 129    static ZCONST char Far DiskFullQuery[] =
 130      "%s:  write error (disk full?).  Continue? (y/n/^C) ";
 131    static ZCONST char Far ZipfileCorrupt[] =
 132      "error:  zipfile probably corrupt (%s)\n";
 133 #  ifdef SYMLINKS
 134      static ZCONST char Far FileIsSymLink[] =
 135        "%s exists and is a symbolic link%s.\n";
 136 #  endif
 137 #  ifdef MORE
 138      static ZCONST char Far MorePrompt[] = "--More--(%lu)";
 139 #  endif
 140    static ZCONST char Far QuitPrompt[] =
 141      "--- Press `Q' to quit, or any other key to continue ---";
 142    static ZCONST char Far HidePrompt[] = /* "\r                       \r"; */
 143      "\r                                                         \r";
 144 #  if CRYPT
 145 #    ifdef MACOS
 146        /* SPC: are names on MacOS REALLY so much longer than elsewhere ??? */
 147        static ZCONST char Far PasswPrompt[] = "[%s]\n %s password: ";
 148 #    else
 149        static ZCONST char Far PasswPrompt[] = "[%s] %s password: ";
 150 #    endif
 151      static ZCONST char Far PasswPrompt2[] = "Enter password: ";
 152      static ZCONST char Far PasswRetry[] = "password incorrect--reenter: ";
 153 #  endif /* CRYPT */
 154 #endif /* !WINDLL */
 155
 156
 157
 158
 159
 160 /******************************/
 161 /* Function open_input_file() */
 162 /******************************/
 163
 164 int open_input_file(__G)    /* return 1 if open failed */
 165     __GDEF
 166 {
 167     /*
 168      *  open the zipfile for reading and in BINARY mode to prevent cr/lf
 169      *  translation, which would corrupt the bitstreams
 170      */
 171
 172 #if (defined(UNIX) || defined(TOPS20) || defined(AOS_VS) || defined(__BEOS__))
 173     G.zipfd = aceopen(G.zipfn, O_RDONLY);
 174 #else /* !(UNIX || TOPS20 || AOS_VS || __BEOS__) */
 175 #ifdef VMS
 176     G.zipfd = open(G.zipfn, O_RDONLY, 0, "ctx=stm");
 177 #else /* !VMS */
 178 #ifdef MACOS
 179     G.zipfd = aceopen(G.zipfn, 0);
 180 #else /* !MACOS */
 181 #ifdef RISCOS
 182     G.zipfd = fopen(G.zipfn, "rb");
 183 #else /* !RISCOS */
 184 #ifdef CMS_MVS
 185     G.zipfd = vmmvs_open_infile(__G);
 186 #else /* !CMS_MVS */
 187     G.zipfd = aceopen(G.zipfn, O_RDONLY | O_BINARY);
 188 #endif /* ?CMS_MVS */
 189 #endif /* ?RISCOS */
 190 #endif /* ?MACOS */
 191 #endif /* ?VMS */
 192 #endif /* ?(UNIX || TOPS20 || AOS_VS || __BEOS__) */
 193
 194 #ifdef USE_STRM_INPUT
 195     if (G.zipfd == NULL)
 196 #else
 197     /* if (G.zipfd < 0) */  /* no good for Windows CE port */
 198     if (G.zipfd == -1)
 199 #endif
 200     {
 201         Info(slide, 0x401, ((char *)slide, LoadFarString(CannotOpenZipfile),
 202           G.zipfn));
 203         return 1;
 204     }
 205     return 0;
 206
 207 } /* end function open_input_file() */
 208
 209
 210
 211
 212 #if (!defined(VMS) && !defined(AOS_VS) && !defined(CMS_MVS) && !defined(MACOS))
 213
 214 /***************************/
 215 /* Function open_outfile() */
 216 /***************************/
 217
 218 int open_outfile(__G)         /* return 1 if fail */
 219     __GDEF
 220 {
 221 #ifdef DLL
 222     if (G.redirect_data)
 223         return (redirect_outfile(__G) == FALSE);
 224 #endif
 225 #ifdef QDOS
 226     QFilename(__G__ G.filename);
 227 #endif
 228 #if (defined(DOS_FLX_OS2_W32) || defined(UNIX) || defined(__BEOS__))
 229 #ifdef BORLAND_STAT_BUG
 230     /* Borland 5.0's stat() barfs if the filename has no extension and the
 231      * file doesn't exist. */
 232     if (access(G.filename, 0) == -1) {
 233         FILE *tmp = fopen(G.filename, "wb+");
 234
 235         /* file doesn't exist, so create a dummy file to keep stat() from
 236          * failing (will be over-written anyway) */
 237         fputc('0', tmp);  /* just to have something in the file */
 238         fclose(tmp);
 239     }
 240 #endif /* BORLAND_STAT_BUG */
 241 #ifdef SYMLINKS
 242     if (SSTAT(G.filename, &G.statbuf) == 0 || lstat(G.filename,&G.statbuf) == 0)
 243 #else
 244     if (SSTAT(G.filename, &G.statbuf) == 0)
 245 #endif /* ?SYMLINKS */
 246     {
 247         Trace((stderr, "open_outfile:  stat(%s) returns 0:  file exists\n",
 248           FnFilter1(G.filename)));
 249 #ifdef UNIXBACKUP
 250         if (uO.B_flag) {    /* do backup */
 251             char *tname;
 252             int blen, flen, tlen;
 253
 254             blen = strlen(BackupSuffix);
 255             flen = strlen(G.filename);
 256             tlen = flen + blen + 1;
 257             if (tlen >= FILNAMSIZ) {   /* in case name is too long, truncate */
 258                 tname = (char *)malloc(FILNAMSIZ);
 259                 if (tname == NULL)
 260                     return 1;                 /* in case we run out of space */
 261                 tlen = FILNAMSIZ - 1 - blen;
 262                 strcpy(tname, G.filename);    /* make backup name */
 263                 tname[tlen] = '\0';
 264             } else {
 265                 tname = (char *)malloc(tlen);
 266                 if (tname == NULL)
 267                     return 1;                 /* in case we run out of space */
 268                 strcpy(tname, G.filename);    /* make backup name */
 269             }
 270             strcpy(tname+flen, BackupSuffix);
 271
 272             /* GRR:  should check if backup file exists, apply -n/-o to that */
 273             if (rename(G.filename, tname) < 0) {   /* move file */
 274                 Info(slide, 0x401, ((char *)slide,
 275                   LoadFarString(CannotRenameOldFile), FnFilter1(G.filename)));
 276                 free(tname);
 277                 return 1;
 278             }
 279             free(tname);
 280         } else
 281 #endif /* UNIXBACKUP */
 282 #ifdef DOS_FLX_OS2_W32
 283         if (!(G.statbuf.st_mode & S_IWRITE)) {
 284             Trace((stderr, "open_outfile:  existing file %s is read-only\n",
 285               FnFilter1(G.filename)));
 286             chmod(G.filename, S_IREAD | S_IWRITE);
 287             Trace((stderr, "open_outfile:  %s now writable\n",
 288               FnFilter1(G.filename)));
 289         }
 290 #endif /* DOS_FLX_OS2_W32 */
 291         if (unlink(G.filename) != 0) {
 292             Info(slide, 0x401, ((char *)slide,
 293               LoadFarString(CannotDeleteOldFile), FnFilter1(G.filename)));
 294             return 1;
 295         }
 296         Trace((stderr, "open_outfile:  %s now deleted\n",
 297           FnFilter1(G.filename)));
 298     }
 299 #endif /* DOS_FLX_OS2_W32 || UNIX || __BEOS__ */
 300 #ifdef RISCOS
 301     if (SWI_OS_File_7(G.filename,0xDEADDEAD,0xDEADDEAD,G.lrec.ucsize)!=NULL) {
 302         Info(slide, 1, ((char *)slide, LoadFarString(CannotCreateFile),
 303           FnFilter1(G.filename)));
 304         return 1;
 305     }
 306 #endif /* RISCOS */
 307 #ifdef TOPS20
 308     char *tfilnam;
 309
 310     if ((tfilnam = (char *)malloc(2*strlen(G.filename)+1)) == (char *)NULL)
 311         return 1;
 312     strcpy(tfilnam, G.filename);
 313     upper(tfilnam);
 314     enquote(tfilnam);
 315     if ((G.outfile = fopen(tfilnam, FOPW)) == (FILE *)NULL) {
 316         Info(slide, 1, ((char *)slide, LoadFarString(CannotCreateFile),
 317           tfilnam));
 318         free(tfilnam);
 319         return 1;
 320     }
 321     free(tfilnam);
 322 #else /* !TOPS20 */
 323 #ifdef MTS
 324     if (uO.aflag)
 325         G.outfile = fopen(G.filename, FOPWT);
 326     else
 327         G.outfile = fopen(G.filename, FOPW);
 328     if (G.outfile == (FILE *)NULL) {
 329         Info(slide, 1, ((char *)slide, LoadFarString(CannotCreateFile),
 330           FnFilter1(G.filename)));
 331         return 1;
 332     }
 333 #else /* !MTS */
 334 #ifdef TANDEM
 335     if (SSTAT(G.filename, &G.statbuf) == 0) {
 336         Trace((stderr, "open_outfile:  stat(%s) returns 0 (file exists)\n",
 337           FnFilter1(G.filename)));
 338         if (unlink(G.filename) != 0) {
 339             Trace((stderr, "open_outfile:  existing file %s is read-only\n",
 340               FnFilter1(G.filename)));
 341             chmod(G.filename, S_IRUSR | S_IWUSR);
 342             Trace((stderr, "open_outfile:  %s now writable\n",
 343               FnFilter1(G.filename)));
 344             if (unlink(G.filename) != 0)
 345                 return 1;
 346         }
 347         Trace((stderr, "open_outfile:  %s now deleted\n",
 348           FnFilter1(G.filename)));
 349     }
 350     if (G.pInfo->textmode)
 351         G.outfile = fopen(G.filename, FOPWT);
 352     else
 353         G.outfile = fopen(G.filename, FOPW);
 354     if (G.outfile == (FILE *)NULL) {
 355         Info(slide, 1, ((char *)slide, LoadFarString(CannotCreateFile),
 356           FnFilter1(G.filename)));
 357         return 1;
 358     }
 359 #else /* !TANDEM */
 360 #ifdef DEBUG
 361     Info(slide, 1, ((char *)slide,
 362       "open_outfile:  doing fopen(%s) for reading\n", FnFilter1(G.filename)));
 363     if ((G.outfile = fopen(G.filename, FOPR)) == (FILE *)NULL)
 364         Info(slide, 1, ((char *)slide,
 365           "open_outfile:  fopen(%s) for reading failed:  does not exist\n",
 366           FnFilter1(G.filename)));
 367     else {
 368         Info(slide, 1, ((char *)slide,
 369           "open_outfile:  fopen(%s) for reading succeeded:  file exists\n",
 370           FnFilter1(G.filename)));
 371         fclose(G.outfile);
 372     }
 373 #endif /* DEBUG */
 374 #ifdef NOVELL_BUG_FAILSAFE
 375     if (G.dne && ((G.outfile = fopen(G.filename, FOPR)) != (FILE *)NULL)) {
 376         Info(slide, 0x401, ((char *)slide, LoadFarString(NovellBug),
 377           FnFilter1(G.filename)));
 378         fclose(G.outfile);
 379         return 1;   /* with "./" fix in checkdir(), should never reach here */
 380     }
 381 #endif /* NOVELL_BUG_FAILSAFE */
 382     Trace((stderr, "open_outfile:  doing fopen(%s) for writing\n",
 383       FnFilter1(G.filename)));
 384     if ((G.outfile = fopen(G.filename, FOPW)) == (FILE *)NULL) {
 385         Info(slide, 0x401, ((char *)slide, LoadFarString(CannotCreateFile),
 386           FnFilter1(G.filename)));
 387         return 1;
 388     }
 389     Trace((stderr, "open_outfile:  fopen(%s) for writing succeeded\n",
 390       FnFilter1(G.filename)));
 391 #endif /* !TANDEM */
 392 #endif /* !MTS */
 393 #endif /* !TOPS20 */
 394
 395 #ifdef USE_FWRITE
 396 #ifdef DOS_OS2_W32
 397     /* 16-bit MSC: buffer size must be strictly LESS than 32K (WSIZE):  bogus */
 398     setbuf(G.outfile, (char *)NULL);   /* make output unbuffered */
 399 #else /* !DOS_OS2_W32 */
 400 #ifndef RISCOS
 401 #ifdef _IOFBF  /* make output fully buffered (works just about like write()) */
 402     setvbuf(G.outfile, (char *)slide, _IOFBF, WSIZE);
 403 #else
 404     setbuf(G.outfile, (char *)slide);
 405 #endif
 406 #endif /* !RISCOS */
 407 #endif /* ?DOS_OS2_W32 */
 408 #endif /* USE_FWRITE */
 409     return 0;
 410
 411 } /* end function open_outfile() */
 412
 413 #endif /* !VMS && !AOS_VS && !CMS_MVS && !MACOS */
 414
 415
 416
 417
 418
 419 /*
 420  * These functions allow NEXTBYTE to function without needing two bounds
 421  * checks.  Call defer_leftover_input() if you ever have filled G.inbuf
 422  * by some means other than readbyte(), and you then want to start using
 423  * NEXTBYTE.  When going back to processing bytes without NEXTBYTE, call
 424  * undefer_input().  For example, extract_or_test_member brackets its
 425  * central section that does the decompression with these two functions.
 426  * If you need to check the number of bytes remaining in the current
 427  * file while using NEXTBYTE, check (G.csize + G.incnt), not G.csize.
 428  */
 429
 430 /****************************/
 431 /* function undefer_input() */
 432 /****************************/
 433
 434 void undefer_input(__G)
 435     __GDEF
 436 {
 437     if (G.incnt > 0)
 438         G.csize += G.incnt;
 439     if (G.incnt_leftover > 0) {
 440         /* We know that "(G.csize < MAXINT)" so we can cast G.csize to int:
 441          * This condition was checked when G.incnt_leftover was set > 0 in
 442          * defer_leftover_input(), and it is NOT allowed to touch G.csize
 443          * before calling undefer_input() when (G.incnt_leftover > 0)
 444          * (single exception: see read_byte()'s  "G.csize <= 0" handling) !!
 445          */
 446         G.incnt = G.incnt_leftover + (int)G.csize;
 447         G.inptr = G.inptr_leftover - (int)G.csize;
 448         G.incnt_leftover = 0;
 449     } else if (G.incnt < 0)
 450         G.incnt = 0;
 451 } /* end function undefer_input() */
 452
 453
 454
 455
 456
 457 /***********************************/
 458 /* function defer_leftover_input() */
 459 /***********************************/
 460
 461 void defer_leftover_input(__G)
 462     __GDEF
 463 {
 464     if ((long)G.incnt > G.csize) {
 465         /* (G.csize < MAXINT), we can safely cast it to int !! */
 466         if (G.csize < 0L)
 467             G.csize = 0L;
 468         G.inptr_leftover = G.inptr + (int)G.csize;
 469         G.incnt_leftover = G.incnt - (int)G.csize;
 470         G.incnt = (int)G.csize;
 471     } else
 472         G.incnt_leftover = 0;
 473     G.csize -= G.incnt;
 474 } /* end function defer_leftover_input() */
 475
 476
 477
 478
 479
 480 /**********************/
 481 /* Function readbuf() */
 482 /**********************/
 483
 484 unsigned readbuf(__G__ buf, size)   /* return number of bytes read into buf */
 485     __GDEF
 486     char *buf;
 487     register unsigned size;
 488 {
 489     register unsigned count;
 490     unsigned n;
 491
 492     n = size;
 493     while (size) {
 494         if (G.incnt <= 0) {
 495             if ((G.incnt = aceread((char *)G.inbuf, INBUFSIZ)) == 0)
 496                 return (n-size);
 497             else if (G.incnt < 0) {
 498                 /* another hack, but no real harm copying same thing twice */
 499                 (*G.message)((zvoid *)&G,
 500                   (uch *)LoadFarString(ReadError),  /* CANNOT use slide */
 501                   (ulg)strlen(LoadFarString(ReadError)), 0x401);
 502                 return 0;  /* discarding some data; better than lock-up */
 503             }
 504             /* buffer ALWAYS starts on a block boundary:  */
 505             G.cur_zipfile_bufstart += INBUFSIZ;
 506             G.inptr = G.inbuf;
 507         }
 508         count = MIN(size, (unsigned)G.incnt);
 509         memcpy(buf, G.inptr, count);
 510         buf += count;
 511         G.inptr += count;
 512         G.incnt -= count;
 513         size -= count;
 514     }
 515     return n;
 516
 517 } /* end function readbuf() */
 518
 519
 520
 521
 522
 523 /***********************/
 524 /* Function readbyte() */
 525 /***********************/
 526
 527 int readbyte(__G)   /* refill inbuf and return a byte if available, else EOF */
 528     __GDEF
 529 {
 530     if (G.mem_mode)
 531         return EOF;
 532     if (G.csize <= 0) {
 533         G.csize--;             /* for tests done after exploding */
 534         G.incnt = 0;
 535         return EOF;
 536     }
 537     if (G.incnt <= 0) {
 538         if ((G.incnt = aceread((char *)G.inbuf, INBUFSIZ)) == 0) {
 539             G.incnt = 0;       /* do not allow negative value to affect stuff */
 540             return EOF;
 541         } else if (G.incnt < 0) {  /* "fail" (abort, retry, ...) returns this */
 542             /* another hack, but no real harm copying same thing twice */
 543             (*G.message)((zvoid *)&G,
 544               (uch *)LoadFarString(ReadError),
 545               (ulg)strlen(LoadFarString(ReadError)), 0x401);
 546             echon();
 547 #ifdef WINDLL
 548             longjmp(dll_error_return, 1);
 549 #else
 550             DESTROYGLOBALS()
 551             EXIT(PK_BADERR);    /* totally bailing; better than lock-up */
 552 #endif
 553         }
 554         G.cur_zipfile_bufstart += INBUFSIZ; /* always starts on block bndry */
 555         G.inptr = G.inbuf;
 556         defer_leftover_input(__G);           /* decrements G.csize */
 557     }
 558
 559 #if CRYPT
 560     if (G.pInfo->encrypted) {
 561         uch *p;
 562         int n;
 563
 564         /* This was previously set to decrypt one byte beyond G.csize, when
 565          * incnt reached that far.  GRR said, "but it's required:  why?"  This
 566          * was a bug in fillinbuf() -- was it also a bug here?
 567          */
 568         for (n = G.incnt, p = G.inptr;  n--;  p++)
 569             zdecode(*p);
 570     }
 571 #endif /* CRYPT */
 572
 573     --G.incnt;
 574     return *G.inptr++;
 575
 576 } /* end function readbyte() */
 577
 578
 579
 580
 581
 582 #ifdef USE_ZLIB
 583
 584 /************************/
 585 /* Function fillinbuf() */
 586 /************************/
 587
 588 int fillinbuf(__G) /* like readbyte() except returns number of bytes in inbuf */
 589     __GDEF
 590 {
 591     if (G.mem_mode ||
 592                   (G.incnt = aceread((char *)G.inbuf, INBUFSIZ)) <= 0)
 593         return 0;
 594     G.cur_zipfile_bufstart += INBUFSIZ;  /* always starts on a block boundary */
 595     G.inptr = G.inbuf;
 596     defer_leftover_input(__G);           /* decrements G.csize */
 597
 598 #if CRYPT
 599     if (G.pInfo->encrypted) {
 600         uch *p;
 601         int n;
 602
 603         for (n = G.incnt, p = G.inptr;  n--;  p++)
 604             zdecode(*p);
 605     }
 606 #endif /* CRYPT */
 607
 608     return G.incnt;
 609
 610 } /* end function fillinbuf() */
 611
 612 #endif /* USE_ZLIB */
 613
 614
 615
 616
 617
 618 #ifndef VMS  /* for VMS use code in vms.c */
 619
 620 /********************/
 621 /* Function flush() */   /* returns PK error codes: */
 622 /********************/   /* if cflag => always 0; PK_DISK if write error */
 623
 624 int flush(__G__ rawbuf, size, unshrink)
 625     __GDEF
 626     uch *rawbuf;
 627     ulg size;
 628     int unshrink;
 629 {
 630     register uch *p, *q;
 631     uch *transbuf;
 632 #if (defined(SMALL_MEM) || defined(MED_MEM) || defined(VMS_TEXT_CONV))
 633     ulg transbufsiz;
 634 #endif
 635     /* static int didCRlast = FALSE;    moved to globals.h */
 636
 637
 638 /*---------------------------------------------------------------------------
 639     Compute the CRC first; if testing or if disk is full, that's it.
 640   ---------------------------------------------------------------------------*/
 641
 642     G.crc32val = crc32(G.crc32val, rawbuf, (extent)size);
 643
 644 #ifdef DLL
 645     if ((G.statreportcb != NULL) &&
 646         (*G.statreportcb)(__G__ UZ_ST_IN_PROGRESS, G.zipfn, G.filename, NULL))
 647         return IZ_CTRLC;        /* cancel operation by user request */
 648 #endif
 649
 650     if (uO.tflag || size == 0L)  /* testing or nothing to write:  all done */
 651         return PK_OK;
 652
 653     if (G.disk_full)
 654         return PK_DISK;         /* disk already full:  ignore rest of file */
 655
 656 /*---------------------------------------------------------------------------
 657     Write the bytes rawbuf[0..size-1] to the output device, first converting
 658     end-of-lines and ASCII/EBCDIC as needed.  If SMALL_MEM or MED_MEM are NOT
 659     defined, outbuf is assumed to be at least as large as rawbuf and is not
 660     necessarily checked for overflow.
 661   ---------------------------------------------------------------------------*/
 662
 663     if (!G.pInfo->textmode) {   /* write raw binary data */
 664         /* GRR:  note that for standard MS-DOS compilers, size argument to
 665          * fwrite() can never be more than 65534, so WriteError macro will
 666          * have to be rewritten if size can ever be that large.  For now,
 667          * never more than 32K.  Also note that write() returns an int, which
 668          * doesn't necessarily limit size to 32767 bytes if write() is used
 669          * on 16-bit systems but does make it more of a pain; however, because
 670          * at least MSC 5.1 has a lousy implementation of fwrite() (as does
 671          * DEC Ultrix cc), write() is used anyway.
 672          */
 673 #ifdef DLL
 674         if (G.redirect_data)
 675             writeToMemory(__G__ rawbuf, size);
 676         else
 677 #endif
 678         if (!uO.cflag && WriteError(rawbuf, size, G.outfile))
 679             return disk_error(__G);
 680         else if (uO.cflag && (*G.message)((zvoid *)&G, rawbuf, size, 0))
 681             return 0;
 682     } else {   /* textmode:  aflag is true */
 683         if (unshrink) {
 684             /* rawbuf = outbuf */
 685             transbuf = G.outbuf2;
 686 #if (defined(SMALL_MEM) || defined(MED_MEM) || defined(VMS_TEXT_CONV))
 687             transbufsiz = TRANSBUFSIZ;
 688 #endif
 689         } else {
 690             /* rawbuf = slide */
 691             transbuf = G.outbuf;
 692 #if (defined(SMALL_MEM) || defined(MED_MEM) || defined(VMS_TEXT_CONV))
 693             transbufsiz = OUTBUFSIZ;
 694             Trace((stderr, "\ntransbufsiz = OUTBUFSIZ = %u\n", OUTBUFSIZ));
 695 #endif
 696         }
 697         if (G.newfile) {
 698 #ifdef VMS_TEXT_CONV
 699             /* GRR: really want to check if -aa (or -aaa?) was given... */
 700             if (rawbuf[1]) {       /* first line is more than 255 chars long */
 701                 Trace((stderr,
 702       "\nfirst line of VMS `text' too long; switching to normal extraction\n"));
 703                 G.VMS_line_state = -1;   /* -1: don't treat as VMS text */
 704             } else
 705                 G.VMS_line_state = 0;    /* 0: ready to read line length */
 706 #endif
 707             G.didCRlast = FALSE;         /* no previous buffers written */
 708             G.newfile = FALSE;
 709         }
 710
 711 #ifdef VMS_TEXT_CONV
 712         if (G.pInfo->hostnum == VMS_ && G.extra_field && G.VMS_line_state >= 0)
 713         {
 714             /* GRR: really want to check for actual VMS extra field, and
 715              *      ideally for variable-length record format */
 716 /*
 717             printf("\n>>>>>> GRR:  file is VMS text and has an extra field\n");
 718  */
 719
 720             p = rawbuf;
 721             q = transbuf;
 722             while(p < rawbuf+(unsigned)size) {
 723                 switch (G.VMS_line_state) {
 724
 725                     /* 0: ready to read line length */
 726                     case 0:
 727                         G.VMS_line_length = 0;
 728                         G.VMS_line_pad = 0;
 729                         if (p == rawbuf+(unsigned)size-1) {    /* last char */
 730                             G.VMS_line_length = (int)((uch)(*p++));
 731                             G.VMS_line_state = 1;
 732                         } else {
 733                             G.VMS_line_length = makeword(p);
 734                             p += 2;
 735                             G.VMS_line_state = 2;
 736                         }
 737                         if (G.VMS_line_length & 1)   /* odd */
 738                             G.VMS_line_pad = 1;
 739                         break;
 740
 741                     /* 1: read one byte of length, need second */
 742                     case 1:
 743                         G.VMS_line_length += ((int)((uch)(*p++)) << 8);
 744                         G.VMS_line_state = 2;
 745                         break;
 746
 747                     /* 2: ready to read VMS_line_length chars */
 748                     case 2:
 749                         if (G.VMS_line_length < rawbuf+(unsigned)size-p) {
 750                             if (G.VMS_line_length >=
 751                                 transbuf+(unsigned)transbufsiz-q)
 752                             {
 753                                 int outroom = transbuf+(unsigned)transbufsiz-q;
 754
 755 /* GRR:  need to change this to *q++ = native(*p++); loop or something */
 756                                 memcpy(q, p, outroom);
 757 #ifdef DLL
 758                                 if (G.redirect_data)
 759                                     writeToMemory(__G__ transbuf,
 760                                       (unsigned)outroom);
 761                                 else
 762 #endif
 763                                 if (!uO.cflag && WriteError(transbuf,
 764                                     (unsigned)outroom, G.outfile))
 765                                     return disk_error(__G);
 766                                 else if (uO.cflag && (*G.message)((zvoid *)&G,
 767                                          transbuf, (ulg)outroom, 0))
 768                                     return 0;
 769                                 q = transbuf;
 770                                 p += outroom;
 771                                 G.VMS_line_length -= outroom;
 772                                 /* fall through to normal case */
 773                             }
 774 /* GRR:  need to change this to *q++ = native(*p++); loop or something */
 775                             memcpy(q, p, G.VMS_line_length);
 776                             q += G.VMS_line_length;
 777                             p += G.VMS_line_length;
 778                             G.VMS_line_length = 0;   /* necessary?? */
 779                             G.VMS_line_state = 3;
 780
 781                         } else {  /* remaining input is less than full line */
 782                             int remaining = rawbuf+(unsigned)size-p;
 783
 784                             if (remaining <
 785                                 transbuf+(unsigned)transbufsiz-q)
 786                             {
 787                                 int outroom = transbuf+(unsigned)transbufsiz-q;
 788
 789 /* GRR:  need to change this to *q++ = native(*p++); loop or something */
 790                                 memcpy(q, p, outroom);
 791 #ifdef DLL
 792                                 if (G.redirect_data)
 793                                     writeToMemory(__G__ transbuf,
 794                                       (unsigned)(outroom));
 795                                 else
 796 #endif
 797                                 if (!uO.cflag && WriteError(transbuf,
 798                                     (unsigned)outroom, G.outfile))
 799                                     return disk_error(__G);
 800                                 else if (uO.cflag && (*G.message)((zvoid *)&G,
 801                                          transbuf, (ulg)outroom, 0))
 802                                     return 0;
 803                                 q = transbuf;
 804                                 p += outroom;
 805                                 remaining -= outroom;
 806                             }
 807 /* GRR:  need to change this to *q++ = native(*p++); loop or something */
 808                             memcpy(q, p, remaining);
 809                             q += remaining;
 810                             p += remaining;
 811                             G.VMS_line_length -= remaining;
 812                             /* no change in G.VMS_line_state */
 813                         }
 814                         break;
 815
 816                     /* 3: ready to PutNativeEOL */
 817                     case 3:
 818                         if (q > transbuf+(unsigned)transbufsiz-lenEOL) {
 819 #ifdef DLL
 820                             if (G.redirect_data)
 821                                 writeToMemory(__G__ transbuf,
 822                                   (unsigned)(q-transbuf));
 823                             else
 824 #endif
 825                             if (!uO.cflag &&
 826                                 WriteError(transbuf, (unsigned)(q-transbuf),
 827                                   G.outfile))
 828                                 return disk_error(__G);
 829                             else if (uO.cflag && (*G.message)((zvoid *)&G,
 830                                      transbuf, (ulg)(q-transbuf), 0))
 831                                 return 0;
 832                             q = transbuf;
 833                         }
 834                         PutNativeEOL
 835                         if (G.VMS_line_pad)
 836                             if (p < rawbuf+(unsigned)size) {
 837                                 ++p;
 838                                 G.VMS_line_state = 0;
 839                             } else
 840                                 G.VMS_line_state = 4;
 841                         else
 842                             G.VMS_line_state = 0;
 843                         break;
 844
 845                     /* 4: ready to read pad byte */
 846                     case 4:
 847                         ++p;
 848                         G.VMS_line_state = 0;
 849                         break;
 850                 }
 851             } /* end while */
 852
 853         } else
 854 #endif /* VMS_TEXT_CONV */
 855
 856     /*-----------------------------------------------------------------------
 857         Algorithm:  CR/LF => native; lone CR => native; lone LF => native.
 858         This routine is only for non-raw-VMS, non-raw-VM/CMS files (i.e.,
 859         stream-oriented files, not record-oriented).
 860       -----------------------------------------------------------------------*/
 861
 862         /* else not VMS text */ {
 863             p = rawbuf;
 864             if (*p == LF && G.didCRlast)
 865                 ++p;
 866             G.didCRlast = FALSE;
 867             for (q = transbuf;  p < rawbuf+(unsigned)size;  ++p) {
 868                 if (*p == CR) {           /* lone CR or CR/LF: EOL either way */
 869                     PutNativeEOL
 870                     if (p == rawbuf+(unsigned)size-1)  /* last char in buffer */
 871                         G.didCRlast = TRUE;
 872                     else if (p[1] == LF)  /* get rid of accompanying LF */
 873                         ++p;
 874                 } else if (*p == LF)      /* lone LF */
 875                     PutNativeEOL
 876                 else
 877 #ifndef DOS_FLX_OS2_W32
 878                 if (*p != CTRLZ)          /* lose all ^Z's */
 879 #endif
 880                     *q++ = native(*p);
 881
 882 #if (defined(SMALL_MEM) || defined(MED_MEM))
 883 # if (lenEOL == 1)   /* don't check unshrink:  both buffers small but equal */
 884                 if (!unshrink)
 885 # endif
 886                     /* check for danger of buffer overflow and flush */
 887                     if (q > transbuf+(unsigned)transbufsiz-lenEOL) {
 888                         Trace((stderr,
 889                           "p - rawbuf = %u   q-transbuf = %u   size = %lu\n",
 890                           (unsigned)(p-rawbuf), (unsigned)(q-transbuf), size));
 891                         if (!uO.cflag && WriteError(transbuf,
 892                             (unsigned)(q-transbuf), G.outfile))
 893                             return disk_error(__G);
 894                         else if (uO.cflag && (*G.message)((zvoid *)&G,
 895                                  transbuf, (ulg)(q-transbuf), 0))
 896                             return 0;
 897                         q = transbuf;
 898                         continue;
 899                     }
 900 #endif /* SMALL_MEM || MED_MEM */
 901             }
 902         }
 903
 904     /*-----------------------------------------------------------------------
 905         Done translating:  write whatever we've got to file (or screen).
 906       -----------------------------------------------------------------------*/
 907
 908         Trace((stderr, "p - rawbuf = %u   q-transbuf = %u   size = %lu\n",
 909           (unsigned)(p-rawbuf), (unsigned)(q-transbuf), size));
 910         if (q > transbuf) {
 911 #ifdef DLL
 912             if (G.redirect_data)
 913                 writeToMemory(__G__ transbuf, (unsigned)(q-transbuf));
 914             else
 915 #endif
 916             if (!uO.cflag && WriteError(transbuf, (unsigned)(q-transbuf),
 917                 G.outfile))
 918                 return disk_error(__G);
 919             else if (uO.cflag && (*G.message)((zvoid *)&G, transbuf,
 920                 (ulg)(q-transbuf), 0))
 921                 return 0;
 922         }
 923     }
 924
 925     return 0;
 926
 927 } /* end function flush() */
 928
 929
 930
 931
 932
 933 /*************************/
 934 /* Function disk_error() */
 935 /*************************/
 936
 937 static int disk_error(__G)
 938     __GDEF
 939 {
 940     /* OK to use slide[] here because this file is finished regardless */
 941     Info(slide, 0x4a1, ((char *)slide, LoadFarString(DiskFullQuery),
 942       FnFilter1(G.filename)));
 943
 944 #ifndef WINDLL
 945     fgets(G.answerbuf, 9, stdin);
 946     if (*G.answerbuf == 'y')   /* stop writing to this file */
 947         G.disk_full = 1;       /*  (outfile bad?), but new OK */
 948     else
 949 #endif
 950         G.disk_full = 2;       /* no:  exit program */
 951
 952     return PK_DISK;
 953
 954 } /* end function disk_error() */
 955
 956 #endif /* !VMS */
 957
 958
 959
 960
 961
 962 /*****************************/
 963 /* Function UzpMessagePrnt() */
 964 /*****************************/
 965
 966 int UZ_EXP UzpMessagePrnt(pG, buf, size, flag)
 967     zvoid *pG;   /* globals struct:  always passed */
 968     uch *buf;    /* preformatted string to be printed */
 969     ulg size;    /* length of string (may include nulls) */
 970     int flag;    /* flag bits */
 971 {
 972     /* IMPORTANT NOTE:
 973      *    The name of the first parameter of UzpMessagePrnt(), which passes
 974      *    the "Uz_Globs" address, >>> MUST <<< be identical to the string
 975      *    expansion of the __G__ macro in the REENTRANT case (see globals.h).
 976      *    This name identity is mandatory for the LoadFarString() macro
 977      *    (in the SMALL_MEM case) !!!
 978      */
 979     int error;
 980     uch *q=buf, *endbuf=buf+(unsigned)size;
 981 #ifdef MORE
 982     uch *p=buf-1;
 983 #endif
 984     FILE *outfp;
 985
 986
 987 /*---------------------------------------------------------------------------
 988     These tests are here to allow fine-tuning of UnZip's output messages,
 989     but none of them will do anything without setting the appropriate bit
 990     in the flag argument of every Info() statement which is to be turned
 991     *off*.  That is, all messages are currently turned on for all ports.
 992     To turn off *all* messages, use the UzpMessageNull() function instead
 993     of this one.
 994   ---------------------------------------------------------------------------*/
 995
 996 #if (defined(OS2) && defined(DLL))
 997     if (MSG_NO_DLL2(flag))  /* if OS/2 DLL bit is set, do NOT print this msg */
 998         return 0;
 999 #endif
1000 #ifdef WINDLL
1001     if (MSG_NO_WDLL(flag))
1002         return 0;
1003 #endif
1004 #ifdef WINDLL
1005     if (MSG_NO_WGUI(flag))
1006         return 0;
1007 #endif
1008 /*
1009 #ifdef ACORN_GUI
1010     if (MSG_NO_AGUI(flag))
1011         return 0;
1012 #endif
1013  */
1014 #ifdef DLL                 /* don't display message if data is redirected */
1015     if (((Uz_Globs *)pG)->redirect_data &&
1016         !((Uz_Globs *)pG)->redirect_text)
1017         return 0;
1018 #endif
1019
1020     if (MSG_STDERR(flag) && !((Uz_Globs *)pG)->UzO.tflag)
1021         outfp = (FILE *)stderr;
1022     else
1023         outfp = (FILE *)stdout;
1024
1025 #ifdef QUERY_TRNEWLN
1026     /* some systems require termination of query prompts with '\n' to force
1027      * immediate display */
1028     if (MSG_MNEWLN(flag)) {   /* assumes writable buffer (e.g., slide[]) */
1029         *endbuf++ = '\n';     /*  with room for one more char at end of buf */
1030         ++size;               /*  (safe assumption:  only used for four */
1031     }                         /*  short queries in extract.c and fileio.c) */
1032 #endif
1033
1034     if (MSG_TNEWLN(flag)) {   /* again assumes writable buffer:  fragile... */
1035         if ((!size && !((Uz_Globs *)pG)->sol) ||
1036             (size && (endbuf[-1] != '\n')))
1037         {
1038             *endbuf++ = '\n';
1039             ++size;
1040         }
1041     }
1042
1043 #ifdef MORE
1044     /* room for --More-- and one line of overlap: */
1045     ((Uz_Globs *)pG)->height = SCREENLINES - 2;
1046 #endif
1047
1048     if (MSG_LNEWLN(flag) && !((Uz_Globs *)pG)->sol) {
1049         /* not at start of line:  want newline */
1050 #ifdef OS2DLL
1051         if (!((Uz_Globs *)pG)->redirect_text) {
1052 #endif
1053             putc('\n', outfp);
1054             fflush(outfp);
1055 #ifdef MORE
1056             if (((Uz_Globs *)pG)->M_flag)
1057             {
1058                 ++((Uz_Globs *)pG)->numlines;
1059                 if (((Uz_Globs *)pG)->numlines %
1060                     ((Uz_Globs *)pG)->height == 0L)    /* GRR: fix */
1061                     (*((Uz_Globs *)pG)->mpause)((zvoid *)pG,
1062                       LoadFarString(MorePrompt), 1);
1063             }
1064 #endif /* MORE */
1065             if (MSG_STDERR(flag) && ((Uz_Globs *)pG)->UzO.tflag &&
1066                 !isatty(1) && isatty(2))
1067             {
1068                 /* error output from testing redirected:  also send to stderr */
1069                 putc('\n', stderr);
1070                 fflush(stderr);
1071             }
1072 #ifdef OS2DLL
1073         } else
1074            REDIRECTC('\n');
1075 #endif
1076         ((Uz_Globs *)pG)->sol = TRUE;
1077     }
1078
1079     /* put zipfile name, filename and/or error/warning keywords here */
1080
1081 #ifdef MORE
1082     if (((Uz_Globs *)pG)->M_flag
1083 #ifdef OS2DLL
1084          && !((Uz_Globs *)pG)->redirect_text
1085 #endif
1086                                                  )
1087     {
1088         while (++p < endbuf) {
1089             if (*p == '\n') {
1090                 ++((Uz_Globs *)pG)->numlines;
1091                 if (((Uz_Globs *)pG)->numlines %
1092                     ((Uz_Globs *)pG)->height == 0L)    /* GRR: fix */
1093                 {
1094                     if ((error = WriteError(q, p-q+1, outfp)) != 0)
1095                         return error;
1096                     fflush(outfp);
1097                     ((Uz_Globs *)pG)->sol = TRUE;
1098                     q = p + 1;
1099                     (*((Uz_Globs *)pG)->mpause)((zvoid *)pG,
1100                       LoadFarString(MorePrompt), 1);
1101                 }
1102             }
1103         } /* end while */
1104         size = (ulg)(p - q);   /* remaining text */
1105     }
1106 #endif /* MORE */
1107
1108     if (size) {
1109 #ifdef OS2DLL
1110         if (!((Uz_Globs *)pG)->redirect_text) {
1111 #endif
1112             if ((error = WriteError(q, size, outfp)) != 0)
1113                 return error;
1114             fflush(outfp);
1115             if (MSG_STDERR(flag) && ((Uz_Globs *)pG)->UzO.tflag &&
1116                 !isatty(1) && isatty(2))
1117             {
1118                 /* error output from testing redirected:  also send to stderr */
1119                 if ((error = WriteError(q, size, stderr)) != 0)
1120                     return error;
1121                 fflush(stderr);
1122             }
1123 #ifdef OS2DLL
1124         } else {                /* GRR:  this is ugly:  hide with macro */
1125             if ((error = REDIRECTPRINT(q, size)) != 0)
1126                 return error;
1127         }
1128 #endif
1129         ((Uz_Globs *)pG)->sol = (endbuf[-1] == '\n');
1130     }
1131     return 0;
1132
1133 } /* end function UzpMessagePrnt() */
1134
1135
1136
1137
1138
1139 #ifdef DLL
1140
1141 /*****************************/
1142 /* Function UzpMessageNull() */  /* convenience routine for no output at all */
1143 /*****************************/
1144
1145 int UZ_EXP UzpMessageNull(pG, buf, size, flag)
1146     zvoid *pG;    /* globals struct:  always passed */
1147     uch *buf;     /* preformatted string to be printed */
1148     ulg size;     /* length of string (may include nulls) */
1149     int flag;     /* flag bits */
1150 {
1151     return 0;
1152
1153 } /* end function UzpMessageNull() */
1154
1155 #endif /* DLL */
1156
1157
1158
1159
1160
1161 /***********************/
1162 /* Function UzpInput() */   /* GRR:  this is a placeholder for now */
1163 /***********************/
1164
1165 int UZ_EXP UzpInput(pG, buf, size, flag)
1166     zvoid *pG;    /* globals struct:  always passed */
1167     uch *buf;     /* preformatted string to be printed */
1168     int *size;    /* (address of) size of buf and of returned string */
1169     int flag;     /* flag bits (bit 0: no echo) */
1170 {
1171     /* tell picky compilers to shut up about "unused variable" warnings */
1172     pG = pG; buf = buf; flag = flag;
1173
1174     *size = 0;
1175     return 0;
1176
1177 } /* end function UzpInput() */
1178
1179
1180
1181
1182
1183 #if (!defined(WINDLL) && !defined(MACOS))
1184
1185 /***************************/
1186 /* Function UzpMorePause() */
1187 /***************************/
1188
1189 void UZ_EXP UzpMorePause(pG, prompt, flag)
1190     zvoid *pG;            /* globals struct:  always passed */
1191     ZCONST char *prompt;  /* "--More--" prompt */
1192     int flag;             /* 0 = any char OK; 1 = accept only '\n', ' ', q */
1193         {
1194 #if 0
1195     uch c;
1196
1197 /*---------------------------------------------------------------------------
1198     Print a prompt and wait for the user to press a key, then erase prompt
1199     if possible.
1200   ---------------------------------------------------------------------------*/
1201
1202     if (!((Uz_Globs *)pG)->sol)
1203         fprintf(stderr, "\n");
1204     /* numlines may or may not be used: */
1205     fprintf(stderr, prompt, ((Uz_Globs *)pG)->numlines);
1206     fflush(stderr);
1207     if (flag & 1) {
1208         do {
1209             c = (uch)FGETCH(0);
1210         } while (c != '\r' && c != '\n' && c != ' ' && c != 'q' && c != 'Q');
1211     } else
1212         c = (uch)FGETCH(0);
1213
1214     /* newline was not echoed, so cover up prompt line */
1215     fprintf(stderr, LoadFarString(HidePrompt));
1216     fflush(stderr);
1217
1218     if (ToLower(c) == 'q') {
1219         DESTROYGLOBALS()
1220         EXIT(PK_COOL);
1221     }
1222
1223     ((Uz_Globs *)pG)->sol = TRUE;
1224
1225 #endif
1226 } /* end function UzpMorePause() */
1227
1228 #endif /* !WINDLL && !MACOS */
1229
1230
1231
1232
1233 #ifndef WINDLL
1234
1235 /**************************/
1236 /* Function UzpPassword() */
1237 /**************************/
1238
1239 int UZ_EXP UzpPassword (pG, rcnt, pwbuf, size, zfn, efn)
1240     zvoid *pG;         /* pointer to UnZip's internal global vars */
1241     int *rcnt;         /* retry counter */
1242     char *pwbuf;       /* buffer for password */
1243     int size;          /* size of password buffer */
1244     ZCONST char *zfn;  /* name of zip archive */
1245     ZCONST char *efn;  /* name of archive entry being processed */
1246         {
1247 #if CRYPT
1248     int r = IZ_PW_ENTERED;
1249     char *m;
1250     char *prompt;
1251
1252 #ifndef REENTRANT
1253     /* tell picky compilers to shut up about "unused variable" warnings */
1254     pG = pG;
1255 #endif
1256
1257     if (*rcnt == 0) {           /* First call for current entry */
1258         *rcnt = 2;
1259         if ((prompt = (char *)malloc(2*FILNAMSIZ + 15)) != (char *)NULL) {
1260             sprintf(prompt, LoadFarString(PasswPrompt),
1261                     FnFilter1(zfn), FnFilter2(efn));
1262             m = prompt;
1263         } else
1264             m = (char *)LoadFarString(PasswPrompt2);
1265     } else {                    /* Retry call, previous password was wrong */
1266         (*rcnt)--;
1267         prompt = NULL;
1268         m = (char *)LoadFarString(PasswRetry);
1269     }
1270
1271     m = getp(__G__ m, pwbuf, size);
1272     if (prompt != (char *)NULL) {
1273         free(prompt);
1274     }
1275     if (m == (char *)NULL) {
1276         r = IZ_PW_ERROR;
1277     }
1278     else if (*pwbuf == '\0') {
1279         r = IZ_PW_CANCELALL;
1280     }
1281     return r;
1282
1283 #else /* !CRYPT */
1284     /* tell picky compilers to shut up about "unused variable" warnings */
1285     pG = pG; rcnt = rcnt; pwbuf = pwbuf; size = size; zfn = zfn; efn = efn;
1286
1287     return IZ_PW_ERROR;  /* internal error; function should never get called */
1288 #endif /* ?CRYPT */
1289
1290 } /* end function UzpPassword() */
1291
1292
1293
1294
1295
1296 /**********************/
1297 /* Function handler() */
1298 /**********************/
1299
1300 void handler(signal)   /* upon interrupt, turn on echo and exit cleanly */
1301     int signal;
1302 {
1303     GETGLOBALS();
1304
1305 #if !(defined(SIGBUS) || defined(SIGSEGV))      /* add a newline if not at */
1306     (*G.message)((zvoid *)&G, slide, 0L, 0x41); /*  start of line (to stderr; */
1307 #endif                                          /*  slide[] should be safe) */
1308
1309     echon();
1310
1311 #ifdef SIGBUS
1312     if (signal == SIGBUS) {
1313         Info(slide, 0x421, ((char *)slide, LoadFarString(ZipfileCorrupt),
1314           "bus error"));
1315         DESTROYGLOBALS()
1316         EXIT(PK_BADERR);
1317     }
1318 #endif /* SIGBUS */
1319
1320 #ifdef SIGSEGV
1321     if (signal == SIGSEGV) {
1322         Info(slide, 0x421, ((char *)slide, LoadFarString(ZipfileCorrupt),
1323           "segmentation violation"));
1324         DESTROYGLOBALS()
1325         EXIT(PK_BADERR);
1326     }
1327 #endif /* SIGSEGV */
1328
1329     /* probably ctrl-C */
1330     DESTROYGLOBALS()
1331 #if defined(AMIGA) && defined(__SASC)
1332     _abort();
1333 #endif
1334     EXIT(IZ_CTRLC);       /* was EXIT(0), then EXIT(PK_ERR) */
1335 }
1336
1337 #endif /* !WINDLL */
1338
1339
1340
1341
1342 #if (!defined(VMS) && !defined(CMS_MVS))
1343 #if (!defined(OS2) || defined(TIMESTAMP))
1344
1345 #if (!defined(HAVE_MKTIME) || defined(AMIGA) || defined(WIN32))
1346 /* also used in amiga/filedate.c and win32/win32.c */
1347 ZCONST ush ydays[] =
1348     { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 };
1349 #endif
1350
1351 /*******************************/
1352 /* Function dos_to_unix_time() */ /* used for freshening/updating/timestamps */
1353 /*******************************/
1354
1355 time_t dos_to_unix_time(dosdatetime)
1356     ulg dosdatetime;
1357 {
1358     time_t m_time;
1359
1360 #ifdef HAVE_MKTIME
1361
1362     ZCONST time_t now = time(NULL);
1363     struct tm *tm;
1364 #   define YRBASE  1900
1365
1366     tm = localtime(&now);
1367     tm->tm_isdst = -1;          /* let mktime determine if DST is in effect */
1368
1369     /* dissect date */
1370     tm->tm_year = ((int)(dosdatetime >> 25) & 0x7f) + (1980 - YRBASE);
1371     tm->tm_mon  = ((int)(dosdatetime >> 21) & 0x0f) - 1;
1372     tm->tm_mday = ((int)(dosdatetime >> 16) & 0x1f);
1373
1374     /* dissect time */
1375     tm->tm_hour = (int)((unsigned)dosdatetime >> 11) & 0x1f;
1376     tm->tm_min  = (int)((unsigned)dosdatetime >> 5) & 0x3f;
1377     tm->tm_sec  = (int)((unsigned)dosdatetime << 1) & 0x3e;
1378
1379     m_time = mktime(tm);
1380     NATIVE_TO_TIMET(m_time)     /* NOP unless MSC 7.0 or Macintosh */
1381     TTrace((stderr, "  final m_time  =       %lu\n", (ulg)m_time));
1382
1383 #else /* !HAVE_MKTIME */
1384
1385     int yr, mo, dy, hh, mm, ss;
1386 #ifdef TOPS20
1387 #   define YRBASE  1900
1388     struct tmx *tmx;
1389     char temp[20];
1390 #else /* !TOPS20 */
1391 #   define YRBASE  1970
1392     int leap;
1393     unsigned days;
1394     struct tm *tm;
1395 #if (!defined(MACOS) && !defined(RISCOS) && !defined(QDOS) && !defined(TANDEM))
1396 #ifdef WIN32
1397     TIME_ZONE_INFORMATION tzinfo;
1398     DWORD res;
1399 #else /* ! WIN32 */
1400 #ifndef BSD4_4   /* GRR:  change to !defined(MODERN) ? */
1401 #if (defined(BSD) || defined(MTS) || defined(__GO32__))
1402     struct timeb tbp;
1403 #else /* !(BSD || MTS || __GO32__) */
1404 #ifdef DECLARE_TIMEZONE
1405     extern time_t timezone;
1406 #endif
1407 #endif /* ?(BSD || MTS || __GO32__) */
1408 #endif /* !BSD4_4 */
1409 #endif /* ?WIN32 */
1410 #endif /* !MACOS && !RISCOS && !QDOS && !TANDEM */
1411 #endif /* ?TOPS20 */
1412
1413
1414     /* dissect date */
1415     yr = ((int)(dosdatetime >> 25) & 0x7f) + (1980 - YRBASE);
1416     mo = ((int)(dosdatetime >> 21) & 0x0f) - 1;
1417     dy = ((int)(dosdatetime >> 16) & 0x1f) - 1;
1418
1419     /* dissect time */
1420     hh = (int)((unsigned)dosdatetime >> 11) & 0x1f;
1421     mm = (int)((unsigned)dosdatetime >> 5) & 0x3f;
1422     ss = (int)((unsigned)dosdatetime & 0x1f) * 2;
1423
1424 #ifdef TOPS20
1425     tmx = (struct tmx *)malloc(sizeof(struct tmx));
1426     sprintf (temp, "%02d/%02d/%02d %02d:%02d:%02d", mo+1, dy+1, yr, hh, mm, ss);
1427     time_parse(temp, tmx, (char *)0);
1428     m_time = time_make(tmx);
1429     free(tmx);
1430
1431 #else /* !TOPS20 */
1432
1433 /*---------------------------------------------------------------------------
1434     Calculate the number of seconds since the epoch, usually 1 January 1970.
1435   ---------------------------------------------------------------------------*/
1436
1437     /* leap = # of leap yrs from YRBASE up to but not including current year */
1438     leap = ((yr + YRBASE - 1) / 4);   /* leap year base factor */
1439
1440     /* calculate days from BASE to this year and add expired days this year */
1441     days = (yr * 365) + (leap - 492) + ydays[mo];
1442
1443     /* if year is a leap year and month is after February, add another day */
1444     if ((mo > 1) && ((yr+YRBASE)%4 == 0) && ((yr+YRBASE) != 2100))
1445         ++days;                 /* OK through 2199 */
1446
1447     /* convert date & time to seconds relative to 00:00:00, 01/01/YRBASE */
1448     m_time = (time_t)((unsigned long)(days + dy) * 86400L +
1449                       (unsigned long)hh * 3600L +
1450                       (unsigned long)(mm * 60 + ss));
1451       /* - 1;   MS-DOS times always rounded up to nearest even second */
1452     TTrace((stderr, "dos_to_unix_time:\n"));
1453     TTrace((stderr, "  m_time before timezone = %lu\n", (ulg)m_time));
1454
1455 /*---------------------------------------------------------------------------
1456     Adjust for local standard timezone offset.
1457   ---------------------------------------------------------------------------*/
1458
1459 #if (!defined(MACOS) && !defined(RISCOS) && !defined(QDOS) && !defined(TANDEM))
1460 #ifdef WIN32
1461     /* account for timezone differences */
1462     res = GetTimeZoneInformation(&tzinfo);
1463     if (res != TIME_ZONE_ID_UNKNOWN)
1464     {
1465     m_time += 60*(tzinfo.Bias);
1466 #else /* !WIN32 */
1467 #if (defined(BSD) || defined(MTS) || defined(__GO32__))
1468 #ifdef BSD4_4
1469     if ( (dosdatetime >= DOSTIME_2038_01_18) &&
1470          (m_time < (time_t)0x70000000L) )
1471         m_time = U_TIME_T_MAX;  /* saturate in case of (unsigned) overflow */
1472     if (m_time < (time_t)0L)    /* a converted DOS time cannot be negative */
1473         m_time = S_TIME_T_MAX;  /*  -> saturate at max signed time_t value */
1474     if ((tm = localtime(&m_time)) != (struct tm *)NULL)
1475         m_time -= tm->tm_gmtoff;                /* sec. EAST of GMT: subtr. */
1476 #else /* !(BSD4_4 */
1477     ftime(&tbp);                                /* get `timezone' */
1478     m_time += tbp.timezone * 60L;               /* seconds WEST of GMT:  add */
1479 #endif /* ?(BSD4_4 || __EMX__) */
1480 #else /* !(BSD || MTS || __GO32__) */
1481     /* tzset was already called at start of process_zipfiles() */
1482     /* tzset(); */              /* set `timezone' variable */
1483 #ifndef __BEOS__                /* BeOS DR8 has no timezones... */
1484     m_time += timezone;         /* seconds WEST of GMT:  add */
1485 #endif
1486 #endif /* ?(BSD || MTS || __GO32__) */
1487 #endif /* ?WIN32 */
1488     TTrace((stderr, "  m_time after timezone =  %lu\n", (ulg)m_time));
1489
1490 /*---------------------------------------------------------------------------
1491     Adjust for local daylight savings (summer) time.
1492   ---------------------------------------------------------------------------*/
1493
1494 #ifndef BSD4_4  /* (DST already added to tm_gmtoff, so skip tm_isdst) */
1495     if ( (dosdatetime >= DOSTIME_2038_01_18) &&
1496          (m_time < (time_t)0x70000000L) )
1497         m_time = U_TIME_T_MAX;  /* saturate in case of (unsigned) overflow */
1498     if (m_time < (time_t)0L)    /* a converted DOS time cannot be negative */
1499         m_time = S_TIME_T_MAX;  /*  -> saturate at max signed time_t value */
1500     TIMET_TO_NATIVE(m_time)     /* NOP unless MSC 7.0 or Macintosh */
1501     if (((tm = localtime((time_t *)&m_time)) != NULL) && tm->tm_isdst)
1502 #ifdef WIN32
1503         m_time += 60L * tzinfo.DaylightBias;    /* adjust with DST bias */
1504     else
1505         m_time += 60L * tzinfo.StandardBias;    /* add StdBias (normally 0) */
1506 #else
1507         m_time -= 60L * 60L;    /* adjust for daylight savings time */
1508 #endif
1509     NATIVE_TO_TIMET(m_time)     /* NOP unless MSC 7.0 or Macintosh */
1510     TTrace((stderr, "  m_time after DST =       %lu\n", (ulg)m_time));
1511 #endif /* !BSD4_4 */
1512 #ifdef WIN32
1513     }
1514 #endif
1515 #endif /* !MACOS && !RISCOS && !QDOS && !TANDEM */
1516 #endif /* ?TOPS20 */
1517
1518 #endif /* ?HAVE_MKTIME */
1519
1520     if ( (dosdatetime >= DOSTIME_2038_01_18) &&
1521          (m_time < (time_t)0x70000000L) )
1522         m_time = U_TIME_T_MAX;  /* saturate in case of (unsigned) overflow */
1523     if (m_time < (time_t)0L)    /* a converted DOS time cannot be negative */
1524         m_time = S_TIME_T_MAX;  /*  -> saturate at max signed time_t value */
1525
1526     return m_time;
1527
1528 } /* end function dos_to_unix_time() */
1529
1530 #endif /* !OS2 || TIMESTAMP */
1531 #endif /* !VMS && !CMS_MVS */
1532
1533
1534
1535 #if (!defined(VMS) && !defined(OS2) && !defined(CMS_MVS))
1536
1537 /******************************/
1538 /* Function check_for_newer() */  /* used for overwriting/freshening/updating */
1539 /******************************/
1540
1541 int check_for_newer(__G__ filename)  /* return 1 if existing file is newer */
1542     __GDEF                           /*  or equal; 0 if older; -1 if doesn't */
1543     char *filename;                  /*  exist yet */
1544 {
1545     time_t existing, archive;
1546 #ifdef USE_EF_UT_TIME
1547     iztimes z_utime;
1548 #endif
1549 #ifdef AOS_VS
1550     long    dyy, dmm, ddd, dhh, dmin, dss;
1551
1552
1553     dyy = (lrec.last_mod_dos_datetime >> 25) + 1980;
1554     dmm = (lrec.last_mod_dos_datetime >> 21) & 0x0f;
1555     ddd = (lrec.last_mod_dos_datetime >> 16) & 0x1f;
1556     dhh = (lrec.last_mod_dos_datetime >> 11) & 0x1f;
1557     dmin = (lrec.last_mod_dos_datetime >> 5) & 0x3f;
1558     dss = (lrec.last_mod_dos_datetime & 0x1f) * 2;
1559
1560     /* under AOS/VS, file times can only be set at creation time,
1561      * with the info in a special DG format.  Make sure we can create
1562      * it here - we delete it later & re-create it, whether or not
1563      * it exists now.
1564      */
1565     if (!zvs_create(filename, (((ulg)dgdate(dmm, ddd, dyy)) << 16) |
1566         (dhh*1800L + dmin*30L + dss/2L), -1L, -1L, (char *) -1, -1, -1, -1))
1567         return DOES_NOT_EXIST;
1568 #endif /* AOS_VS */
1569
1570     Trace((stderr, "check_for_newer:  doing stat(%s)\n", FnFilter1(filename)));
1571     if (SSTAT(filename, &G.statbuf)) {
1572         Trace((stderr,
1573           "check_for_newer:  stat(%s) returns %d:  file does not exist\n",
1574           FnFilter1(filename), SSTAT(filename, &G.statbuf)));
1575 #ifdef SYMLINKS
1576         Trace((stderr, "check_for_newer:  doing lstat(%s)\n",
1577           FnFilter1(filename)));
1578         /* GRR OPTION:  could instead do this test ONLY if G.symlnk is true */
1579         if (lstat(filename, &G.statbuf) == 0) {
1580             Trace((stderr,
1581               "check_for_newer:  lstat(%s) returns 0:  symlink does exist\n",
1582               FnFilter1(filename)));
1583             if (QCOND2 && !uO.overwrite_all)
1584                 Info(slide, 0, ((char *)slide, LoadFarString(FileIsSymLink),
1585                   FnFilter1(filename), " with no real file"));
1586             return EXISTS_AND_OLDER;   /* symlink dates are meaningless */
1587         }
1588 #endif /* SYMLINKS */
1589         return DOES_NOT_EXIST;
1590     }
1591     Trace((stderr, "check_for_newer:  stat(%s) returns 0:  file exists\n",
1592       FnFilter1(filename)));
1593
1594 #ifdef SYMLINKS
1595     /* GRR OPTION:  could instead do this test ONLY if G.symlnk is true */
1596     if (lstat(filename, &G.statbuf) == 0 && S_ISLNK(G.statbuf.st_mode)) {
1597         Trace((stderr, "check_for_newer:  %s is a symbolic link\n",
1598           FnFilter1(filename)));
1599         if (QCOND2 && !uO.overwrite_all)
1600             Info(slide, 0, ((char *)slide, LoadFarString(FileIsSymLink),
1601               FnFilter1(filename), ""));
1602         return EXISTS_AND_OLDER;   /* symlink dates are meaningless */
1603     }
1604 #endif /* SYMLINKS */
1605
1606     NATIVE_TO_TIMET(G.statbuf.st_mtime)   /* NOP unless MSC 7.0 or Macintosh */
1607
1608 #ifdef USE_EF_UT_TIME
1609     /* The `Unix extra field mtime' should be used for comparison with the
1610      * time stamp of the existing file >>>ONLY<<< when the EF info is also
1611      * used to set the modification time of the extracted file.
1612      */
1613     if (G.extra_field &&
1614 #ifdef IZ_CHECK_TZ
1615         G.tz_is_valid &&
1616 #endif
1617         (ef_scan_for_izux(G.extra_field, G.lrec.extra_field_length, 0,
1618                           G.lrec.last_mod_dos_datetime, &z_utime, NULL)
1619          & EB_UT_FL_MTIME))
1620     {
1621         TTrace((stderr, "check_for_newer:  using Unix extra field mtime\n"));
1622         existing = G.statbuf.st_mtime;
1623         archive  = z_utime.mtime;
1624     } else {
1625         /* round up existing filetime to nearest 2 seconds for comparison,
1626          * but saturate in case of arithmetic overflow
1627          */
1628         existing = ((G.statbuf.st_mtime & 1) &&
1629                     (G.statbuf.st_mtime + 1 > G.statbuf.st_mtime)) ?
1630                    G.statbuf.st_mtime + 1 : G.statbuf.st_mtime;
1631         archive  = dos_to_unix_time(G.lrec.last_mod_dos_datetime);
1632     }
1633 #else /* !USE_EF_UT_TIME */
1634     /* round up existing filetime to nearest 2 seconds for comparison,
1635      * but saturate in case of arithmetic overflow
1636      */
1637     existing = ((G.statbuf.st_mtime & 1) &&
1638                 (G.statbuf.st_mtime + 1 > G.statbuf.st_mtime)) ?
1639                G.statbuf.st_mtime + 1 : G.statbuf.st_mtime;
1640     archive  = dos_to_unix_time(G.lrec.last_mod_dos_datetime);
1641 #endif /* ?USE_EF_UT_TIME */
1642
1643     TTrace((stderr, "check_for_newer:  existing %lu, archive %lu, e-a %ld\n",
1644       (ulg)existing, (ulg)archive, (long)(existing-archive)));
1645
1646     return (existing >= archive);
1647
1648 } /* end function check_for_newer() */
1649
1650 #endif /* !VMS && !OS2 && !CMS_MVS */
1651
1652
1653
1654
1655
1656 /************************/
1657 /* Function do_string() */
1658 /************************/
1659
1660 int do_string(__G__ len, option)      /* return PK-type error code */
1661     __GDEF
1662     unsigned int len;           /* without prototype, ush converted to this */
1663     int option;
1664 {
1665     long comment_bytes_left, block_length;
1666     int error=PK_OK;
1667     ush extra_len;
1668 #ifdef AMIGA
1669     char tmp_fnote[2 * AMIGA_FILENOTELEN];   /* extra room for squozen chars */
1670 #endif
1671
1672
1673 /*---------------------------------------------------------------------------
1674     This function processes arbitrary-length (well, usually) strings.  Four
1675     options are allowed:  SKIP, wherein the string is skipped (pretty logical,
1676     eh?); DISPLAY, wherein the string is printed to standard output after un-
1677     dergoing any necessary or unnecessary character conversions; DS_FN,
1678     wherein the string is put into the filename[] array after undergoing ap-
1679     propriate conversions (including case-conversion, if that is indicated:
1680     see the global variable pInfo->lcflag); and EXTRA_FIELD, wherein the
1681     `string' is assumed to be an extra field and is copied to the (freshly
1682     malloced) buffer G.extra_field.  The third option should be OK since
1683     filename is dimensioned at 1025, but we check anyway.
1684
1685     The string, by the way, is assumed to start at the current file-pointer
1686     position; its length is given by len.  So start off by checking length
1687     of string:  if zero, we're already done.
1688   ---------------------------------------------------------------------------*/
1689
1690     if (!len)
1691         return PK_COOL;
1692
1693     switch (option) {
1694
1695     /*
1696      * First case:  print string on standard output.  First set loop vari-
1697      * ables, then loop through the comment in chunks of OUTBUFSIZ bytes,
1698      * converting formats and printing as we go.  The second half of the
1699      * loop conditional was added because the file might be truncated, in
1700      * which case comment_bytes_left will remain at some non-zero value for
1701      * all time.  outbuf and slide are used as scratch buffers because they
1702      * are available (we should be either before or in between any file pro-
1703      * cessing).
1704      */
1705
1706     case DISPLAY:
1707     case DISPL_8:
1708         comment_bytes_left = len;
1709         block_length = OUTBUFSIZ;    /* for the while statement, first time */
1710         while (comment_bytes_left > 0 && block_length > 0) {
1711             register uch *p = G.outbuf;
1712             register uch *q = G.outbuf;
1713
1714             if ((block_length = readbuf(__G__ (char *)G.outbuf,
1715                    (unsigned) MIN((long)OUTBUFSIZ, comment_bytes_left))) == 0)
1716                 return PK_EOF;
1717             comment_bytes_left -= block_length;
1718
1719             /* this is why we allocated an extra byte for outbuf:  terminate
1720              *  with zero (ASCIIZ) */
1721             G.outbuf[(unsigned)block_length] = '\0';
1722
1723             /* remove all ASCII carriage returns from comment before printing
1724              * (since used before A_TO_N(), check for CR instead of '\r')
1725              */
1726             while (*p) {
1727                 while (*p == CR)
1728                     ++p;
1729                 *q++ = *p++;
1730             }
1731             /* could check whether (p - outbuf) == block_length here */
1732             *q = '\0';
1733
1734             if (option == DISPL_8) {
1735                 /* translate the text coded in the entry's host-dependent
1736                    "extended ASCII" charset into the compiler's (system's)
1737                    internal text code page */
1738                 Ext_ASCII_TO_Native((char *)G.outbuf, G.pInfo->hostnum,
1739                                     G.crec.version_made_by[0]);
1740 #ifdef WINDLL
1741                 /* translate to ANSI (RTL internal codepage may be OEM) */
1742                 INTERN_TO_ISO((char *)G.outbuf, (char *)G.outbuf);
1743 #else /* !WINDLL */
1744 #ifdef WIN32
1745                 /* Win9x console always uses OEM character coding, and
1746                    WinNT console is set to OEM charset by default, too */
1747                 INTERN_TO_OEM((char *)G.outbuf, (char *)G.outbuf);
1748 #endif /* WIN32 */
1749 #endif /* ?WINDLL */
1750             } else {
1751                 A_TO_N(G.outbuf);   /* translate string to native */
1752             }
1753
1754 #ifdef WINDLL
1755             /* ran out of local mem -- had to cheat */
1756             win_fprintf((zvoid *)&G, stdout, len, (char *)G.outbuf);
1757             win_fprintf((zvoid *)&G, stdout, 2, (char *)"\n\n");
1758 #else /* !WINDLL */
1759 #ifdef NOANSIFILT       /* GRR:  can ANSI be used with EBCDIC? */
1760             (*G.message)((zvoid *)&G, G.outbuf, (ulg)(q-G.outbuf), 0);
1761 #else /* ASCII, filter out ANSI escape sequences and handle ^S (pause) */
1762             p = G.outbuf - 1;
1763             q = slide;
1764             while (*++p) {
1765                 int pause = FALSE;
1766
1767                 if (*p == 0x1B) {          /* ASCII escape char */
1768                     *q++ = '^';
1769                     *q++ = '[';
1770                 } else if (*p == 0x13) {   /* ASCII ^S (pause) */
1771                     pause = TRUE;
1772                     if (p[1] == LF)        /* ASCII LF */
1773                         *q++ = *++p;
1774                     else if (p[1] == CR && p[2] == LF) {  /* ASCII CR LF */
1775                         *q++ = *++p;
1776                         *q++ = *++p;
1777                     }
1778                 } else
1779                     *q++ = *p;
1780                 if ((unsigned)(q-slide) > WSIZE-3 || pause) {   /* flush */
1781                     (*G.message)((zvoid *)&G, slide, (ulg)(q-slide), 0);
1782                     q = slide;
1783                     if (pause && G.extract_flag) /* don't pause for list/test */
1784                         (*G.mpause)((zvoid *)&G, LoadFarString(QuitPrompt), 0);
1785                 }
1786             }
1787             (*G.message)((zvoid *)&G, slide, (ulg)(q-slide), 0);
1788 #endif /* ?NOANSIFILT */
1789 #endif /* ?WINDLL */
1790         }
1791         /* add '\n' if not at start of line */
1792         (*G.message)((zvoid *)&G, slide, 0L, 0x40);
1793         break;
1794
1795     /*
1796      * Second case:  read string into filename[] array.  The filename should
1797      * never ever be longer than FILNAMSIZ-1 (1024), but for now we'll check,
1798      * just to be sure.
1799      */
1800
1801     case DS_FN:
1802         extra_len = 0;
1803         if (len >= FILNAMSIZ) {
1804             Info(slide, 0x401, ((char *)slide,
1805               LoadFarString(FilenameTooLongTrunc)));
1806             error = PK_WARN;
1807             extra_len = (ush)(len - FILNAMSIZ + 1);
1808             len = FILNAMSIZ - 1;
1809         }
1810         if (readbuf(__G__  G.filename, len) == 0)
1811             return PK_EOF;
1812         G.filename[len] = '\0';   /* terminate w/zero:  ASCIIZ */
1813
1814         /* translate the Zip entry filename coded in host-dependent "extended
1815            ASCII" into the compiler's (system's) internal text code page */
1816         Ext_ASCII_TO_Native(G.filename, G.pInfo->hostnum,
1817                             G.crec.version_made_by[0]);
1818
1819         if (G.pInfo->lcflag)      /* replace with lowercase filename */
1820             TOLOWER(G.filename, G.filename);
1821
1822         if (G.pInfo->vollabel && len > 8 && G.filename[8] == '.') {
1823             char *p = G.filename+8;
1824             while (*p++)
1825                 p[-1] = *p;  /* disk label, and 8th char is dot:  remove dot */
1826         }
1827
1828         if (!extra_len)         /* we're done here */
1829             break;
1830
1831         /*
1832          * We truncated the filename, so print what's left and then fall
1833          * through to the SKIP routine.
1834          */
1835         Info(slide, 0x401, ((char *)slide, "[ %s ]\n", FnFilter1(G.filename)));
1836         len = extra_len;
1837         /*  FALL THROUGH...  */
1838
1839     /*
1840      * Third case:  skip string, adjusting readbuf's internal variables
1841      * as necessary (and possibly skipping to and reading a new block of
1842      * data).
1843      */
1844
1845     case SKIP:
1846         /* cur_zipfile_bufstart already takes account of extra_bytes, so don't
1847          * correct for it twice: */
1848         ZLSEEK(G.cur_zipfile_bufstart - G.extra_bytes +
1849                (G.inptr-G.inbuf) + len)
1850         break;
1851
1852     /*
1853      * Fourth case:  assume we're at the start of an "extra field"; malloc
1854      * storage for it and read data into the allocated space.
1855      */
1856
1857     case EXTRA_FIELD:
1858         if (G.extra_field != (uch *)NULL)
1859             free(G.extra_field);
1860         if ((G.extra_field = (uch *)malloc(len)) == (uch *)NULL) {
1861             Info(slide, 0x401, ((char *)slide, LoadFarString(ExtraFieldTooLong),
1862               len));
1863             /* cur_zipfile_bufstart already takes account of extra_bytes,
1864              * so don't correct for it twice: */
1865             ZLSEEK(G.cur_zipfile_bufstart - G.extra_bytes +
1866                    (G.inptr-G.inbuf) + len)
1867         } else
1868             if (readbuf(__G__  (char *)G.extra_field, len) == 0)
1869                 return PK_EOF;
1870         break;
1871
1872 #ifdef AMIGA
1873     /*
1874      * Fifth case, for the Amiga only:  take the comment that would ordinarily
1875      * be skipped over, and turn it into a 79 character string that will be
1876      * attached to the file as a "filenote" after it is extracted.
1877      */
1878
1879     case FILENOTE:
1880         if ((extra_len = readbuf(__G__ tmp_fnote, (unsigned)
1881                                  MIN(len, 2 * AMIGA_FILENOTELEN - 1))) == 0)
1882             return PK_EOF;
1883         if ((len -= extra_len) > 0)     /* treat remainder as in case SKIP: */
1884             ZLSEEK(G.cur_zipfile_bufstart - G.extra_bytes
1885                    + (G.inptr - G.inbuf) + len)
1886         /* convert multi-line text into single line with no ctl-chars: */
1887         tmp_fnote[extra_len] = '\0';
1888         while ((short int) --extra_len >= 0)
1889             if ((unsigned) tmp_fnote[extra_len] < ' ')
1890                 if (tmp_fnote[extra_len+1] == ' ')     /* no excess */
1891                     strcpy(tmp_fnote+extra_len, tmp_fnote+extra_len+1);
1892                 else
1893                     tmp_fnote[extra_len] = ' ';
1894         tmp_fnote[AMIGA_FILENOTELEN - 1] = '\0';
1895         if (G.filenotes[G.filenote_slot])
1896             free(G.filenotes[G.filenote_slot]);     /* should not happen */
1897         G.filenotes[G.filenote_slot] = NULL;
1898         if (tmp_fnote[0]) {
1899             if (!(G.filenotes[G.filenote_slot] = malloc(strlen(tmp_fnote)+1)))
1900                 return PK_MEM;
1901             strcpy(G.filenotes[G.filenote_slot], tmp_fnote);
1902         }
1903         break;
1904 #endif /* AMIGA */
1905
1906     } /* end switch (option) */
1907
1908     return error;
1909
1910 } /* end function do_string() */
1911
1912
1913
1914
1915
1916 /***********************/
1917 /* Function makeword() */
1918 /***********************/
1919
1920 ush makeword(b)
1921     ZCONST uch *b;
1922 {
1923     /*
1924      * Convert Intel style 'short' integer to non-Intel non-16-bit
1925      * host format.  This routine also takes care of byte-ordering.
1926      */
1927     return (ush)((b[1] << 8) | b[0]);
1928 }
1929
1930
1931
1932
1933
1934 /***********************/
1935 /* Function makelong() */
1936 /***********************/
1937
1938 ulg makelong(sig)
1939     ZCONST uch *sig;
1940 {
1941     /*
1942      * Convert intel style 'long' variable to non-Intel non-16-bit
1943      * host format.  This routine also takes care of byte-ordering.
1944      */
1945     return (((ulg)sig[3]) << 24)
1946         + (((ulg)sig[2]) << 16)
1947         + (((ulg)sig[1]) << 8)
1948         + ((ulg)sig[0]);
1949 }
1950
1951
1952
1953 #if CRYPT
1954
1955 #ifdef NEED_STR2ISO
1956 /**********************/
1957 /* Function str2iso() */
1958 /**********************/
1959
1960 char *str2iso(dst, src)
1961     char *dst;                          /* destination buffer */
1962     register ZCONST char *src;          /* source string */
1963 {
1964 #ifdef INTERN_TO_ISO
1965     INTERN_TO_ISO(src, dst);
1966 #else
1967     register uch c;
1968     register char *dstp = dst;
1969
1970     do {
1971         c = (uch)foreign(*src++);
1972         *dstp++ = (char)ASCII2ISO(c);
1973     } while (c != '\0');
1974 #endif
1975
1976     return dst;
1977 }
1978 #endif /* NEED_STR2ISO */
1979
1980
1981 #ifdef NEED_STR2OEM
1982 /**********************/
1983 /* Function str2oem() */
1984 /**********************/
1985
1986 char *str2oem(dst, src)
1987     char *dst;                          /* destination buffer */
1988     register ZCONST char *src;          /* source string */
1989 {
1990 #ifdef INTERN_TO_OEM
1991     INTERN_TO_OEM(src, dst);
1992 #else
1993     register uch c;
1994     register char *dstp = dst;
1995
1996     do {
1997         c = (uch)foreign(*src++);
1998         *dstp++ = (char)ASCII2OEM(c);
1999     } while (c != '\0');
2000 #endif
2001
2002     return dst;
2003 }
2004 #endif /* NEED_STR2OEM */
2005
2006 #endif /* CRYPT */
2007
2008
2009 #ifdef ZMEM  /* memset/memcmp/memcpy for systems without either them or */
2010              /* bzero/bcmp/bcopy */
2011              /* (no known systems as of 960211) */
2012
2013 /*********************/
2014 /* Function memset() */
2015 /*********************/
2016
2017 zvoid *memset(buf, init, len)
2018     register zvoid *buf;        /* buffer location */
2019     register int init;          /* initializer character */
2020     register unsigned int len;  /* length of the buffer */
2021 {
2022     zvoid *start;
2023
2024     start = buf;
2025     while (len--)
2026         *((char *)buf++) = (char)init;
2027     return start;
2028 }
2029
2030
2031
2032 /*********************/
2033 /* Function memcmp() */
2034 /*********************/
2035
2036 int memcmp(b1, b2, len)
2037     register ZCONST zvoid *b1;
2038     register ZCONST zvoid *b2;
2039     register unsigned int len;
2040 {
2041     register int c;
2042
2043     if (len > 0) do {
2044         if ((c = (int)(*((ZCONST unsigned char *)b1)++) -
2045                  (int)(*((ZCONST unsigned char *)b2)++)) != 0)
2046            return c;
2047     } while (--len > 0)
2048     return 0;
2049 }
2050
2051
2052
2053 /*********************/
2054 /* Function memcpy() */
2055 /*********************/
2056
2057 zvoid *memcpy(dst, src, len)
2058     register zvoid *dst;
2059     register ZCONST zvoid *src;
2060     register unsigned int len;
2061 {
2062     zvoid *start;
2063
2064     start = dst;
2065     while (len-- > 0)
2066         *((char *)dst)++ = *((ZCONST char *)src)++;
2067     return start;
2068 }
2069
2070 #endif /* ZMEM */
2071
2072
2073
2074
2075
2076 /************************/
2077 /* Function zstrnicmp() */
2078 /************************/
2079
2080 int zstrnicmp(s1, s2, n)
2081     register ZCONST char *s1, *s2;
2082     register unsigned n;
2083 {
2084     for (; n > 0;  --n, ++s1, ++s2) {
2085
2086         if (ToLower(*s1) != ToLower(*s2))
2087             /* test includes early termination of one string */
2088             return (ToLower(*s1) < ToLower(*s2))? -1 : 1;
2089
2090         if (*s1 == '\0')   /* both strings terminate early */
2091             return 0;
2092     }
2093     return 0;
2094 }
2095
2096
2097
2098
2099
2100 #ifdef REGULUS  /* returns the inode number on success(!)...argh argh argh */
2101 #  undef stat
2102
2103 /********************/
2104 /* Function zstat() */
2105 /********************/
2106
2107 int zstat(p, s)
2108     char *p;
2109     struct stat *s;
2110 {
2111     return (stat(p,s) >= 0? 0 : (-1));
2112 }
2113
2114 #endif /* REGULUS */
2115
2116
2117
2118
2119
2120 #ifdef SMALL_MEM
2121
2122 /*******************************/
2123 /*  Function fLoadFarString()  */   /* (and friends...) */
2124 /*******************************/
2125
2126 char *fLoadFarString(__GPRO__ const char Far *sz)
2127 {
2128     (void)zfstrcpy(G.rgchBigBuffer, sz);
2129     return G.rgchBigBuffer;
2130 }
2131
2132 char *fLoadFarStringSmall(__GPRO__ const char Far *sz)
2133 {
2134     (void)zfstrcpy(G.rgchSmallBuffer, sz);
2135     return G.rgchSmallBuffer;
2136 }
2137
2138 char *fLoadFarStringSmall2(__GPRO__ const char Far *sz)
2139 {
2140     (void)zfstrcpy(G.rgchSmallBuffer2, sz);
2141     return G.rgchSmallBuffer2;
2142 }
2143
2144
2145
2146
2147 #if (!defined(_MSC_VER) || (_MSC_VER < 600))
2148 /*************************/
2149 /*  Function zfstrcpy()  */   /* portable clone of _fstrcpy() */
2150 /*************************/
2151
2152 char Far * Far zfstrcpy(char Far *s1, const char Far *s2)
2153 {
2154     char Far *p = s1;
2155
2156     while ((*s1++ = *s2++) != '\0');
2157     return p;
2158 }
2159 #endif /* !_MSC_VER || (_MSC_VER < 600) */
2160
2161 #endif /* SMALL_MEM */