utils/Install/packzip/api.c

   1 /*---------------------------------------------------------------------------
   2
   3   api.c
   4
   5   This module supplies an UnZip engine for use directly from C/C++
   6   programs.  The functions are:
   7
   8     UzpVer *UzpVersion(void);
   9     void UzpVersion2(UzpVer2 *version)
  10     int UzpMain(int argc, char *argv[]);
  11     int UzpAltMain(int argc, char *argv[], UzpInit *init);
  12     int UzpValidate(char *archive, int AllCodes);
  13     void UzpFreeMemBuffer(UzpBuffer *retstr);
  14     int UzpUnzipToMemory(char *zip, char *file, UzpOpts *optflgs,
  15                          UzpCB *UsrFuncts, UzpBuffer *retstr);
  16
  17   non-WINDLL only (a special WINDLL variant is defined in windll/windll.c):
  18     int UzpGrep(char *archive, char *file, char *pattern, int cmd, int SkipBin,
  19                 UzpCB *UsrFuncts);
  20
  21   OS/2 only (for now):
  22     int UzpFileTree(char *name, cbList(callBack), char *cpInclude[],
  23           char *cpExclude[]);
  24
  25   You must define `DLL' in order to include the API extensions.
  26
  27   ---------------------------------------------------------------------------*/
  28
  29
  30 #ifdef OS2
  31 #  define  INCL_DOSMEMMGR
  32 #  include <os2.h>
  33 #endif
  34 #include <setjmp.h>
  35
  36 #define UNZIP_INTERNAL
  37 #include "unzip.h"
  38 #include "version.h"
  39 #ifdef WINDLL
  40 #  include "windll/windll.h"
  41 #endif
  42
  43 #ifdef DLL      /* This source file supplies DLL-only interface code. */
  44
  45 jmp_buf dll_error_return;
  46
  47 /*---------------------------------------------------------------------------
  48     Documented API entry points
  49   ---------------------------------------------------------------------------*/
  50
  51
  52 UzpVer * UZ_EXP UzpVersion()   /* should be pointer to const struct */
  53 {
  54     static UzpVer version;     /* doesn't change between calls */
  55
  56
  57     version.structlen = UZPVER_LEN;
  58
  59 #ifdef BETA
  60     version.flag = 1;
  61 #else
  62     version.flag = 0;
  63 #endif
  64     version.betalevel = BETALEVEL;
  65     version.date = VERSION_DATE;
  66
  67 #ifdef ZLIB_VERSION
  68     version.zlib_version = ZLIB_VERSION;
  69     version.flag |= 2;
  70 #else
  71     version.zlib_version = NULL;
  72 #endif
  73
  74     /* someday each of these may have a separate patchlevel: */
  75     version.unzip.major = UZ_MAJORVER;
  76     version.unzip.minor = UZ_MINORVER;
  77     version.unzip.patchlevel = PATCHLEVEL;
  78
  79     version.zipinfo.major = ZI_MAJORVER;
  80     version.zipinfo.minor = ZI_MINORVER;
  81     version.zipinfo.patchlevel = PATCHLEVEL;
  82
  83     /* these are retained for backward compatibility only: */
  84     version.os2dll.major = UZ_MAJORVER;
  85     version.os2dll.minor = UZ_MINORVER;
  86     version.os2dll.patchlevel = PATCHLEVEL;
  87
  88     version.windll.major = UZ_MAJORVER;
  89     version.windll.minor = UZ_MINORVER;
  90     version.windll.patchlevel = PATCHLEVEL;
  91
  92     return &version;
  93 }
  94
  95 void UZ_EXP UzpVersion2(UzpVer2 *version)
  96 {
  97
  98     version->structlen = UZPVER_LEN;
  99
 100 #ifdef BETA
 101     version->flag = 1;
 102 #else
 103     version->flag = 0;
 104 #endif
 105     strcpy(version->betalevel, BETALEVEL);
 106     strcpy(version->date, VERSION_DATE);
 107
 108 #ifdef ZLIB_VERSION
 109     strcpy(version->zlib_version, ZLIB_VERSION);
 110     version->flag |= 2;
 111 #else
 112     version->zlib_version[0] = '\0';
 113 #endif
 114
 115     /* someday each of these may have a separate patchlevel: */
 116     version->unzip.major = UZ_MAJORVER;
 117     version->unzip.minor = UZ_MINORVER;
 118     version->unzip.patchlevel = PATCHLEVEL;
 119
 120     version->zipinfo.major = ZI_MAJORVER;
 121     version->zipinfo.minor = ZI_MINORVER;
 122     version->zipinfo.patchlevel = PATCHLEVEL;
 123
 124     /* these are retained for backward compatibility only: */
 125     version->os2dll.major = UZ_MAJORVER;
 126     version->os2dll.minor = UZ_MINORVER;
 127     version->os2dll.patchlevel = PATCHLEVEL;
 128
 129     version->windll.major = UZ_MAJORVER;
 130     version->windll.minor = UZ_MINORVER;
 131     version->windll.patchlevel = PATCHLEVEL;
 132 }
 133
 134
 135
 136
 137
 138 #ifndef WINDLL
 139
 140 int UZ_EXP UzpAltMain(int argc, char *argv[], UzpInit *init)
 141 {
 142     int r, (*dummyfn)();
 143
 144
 145     CONSTRUCTGLOBALS();
 146
 147     if (init->structlen >= (sizeof(ulg) + sizeof(dummyfn)) && init->msgfn)
 148         G.message = init->msgfn;
 149
 150     if (init->structlen >= (sizeof(ulg) + 2*sizeof(dummyfn)) && init->inputfn)
 151         G.input = init->inputfn;
 152
 153     if (init->structlen >= (sizeof(ulg) + 3*sizeof(dummyfn)) && init->pausefn)
 154         G.mpause = init->pausefn;
 155
 156     if (init->structlen >= (sizeof(ulg) + 4*sizeof(dummyfn)) && init->userfn)
 157         (*init->userfn)();    /* allow void* arg? */
 158
 159     r = unzip(__G__ argc, argv);
 160     DESTROYGLOBALS()
 161     RETURN(r);
 162 }
 163
 164 #endif /* !WINDLL */
 165
 166
 167
 168
 169 #ifndef __16BIT__
 170
 171 void UZ_EXP UzpFreeMemBuffer(UzpBuffer *retstr)
 172 {
 173     if (retstr->strptr != NULL) {
 174         free(retstr->strptr);
 175         retstr->strptr = NULL;
 176     }
 177 }
 178
 179
 180
 181
 182 #ifndef WINDLL
 183
 184 static int UzpDLL_Init OF((zvoid *pG, UzpCB *UsrFuncts));
 185
 186 static int UzpDLL_Init(pG, UsrFuncts)
 187 zvoid *pG;
 188 UzpCB *UsrFuncts;
 189 {
 190     int (*dummyfn)();
 191
 192     if (UsrFuncts->structlen >= (sizeof(ulg) + sizeof(dummyfn)) &&
 193         UsrFuncts->msgfn)
 194         ((Uz_Globs *)pG)->message = UsrFuncts->msgfn;
 195     else
 196         return FALSE;
 197
 198     if (UsrFuncts->structlen >= (sizeof(ulg) + 2*sizeof(dummyfn)) &&
 199         UsrFuncts->inputfn)
 200         ((Uz_Globs *)pG)->input = UsrFuncts->inputfn;
 201
 202     if (UsrFuncts->structlen >= (sizeof(ulg) + 3*sizeof(dummyfn)) &&
 203         UsrFuncts->pausefn)
 204         ((Uz_Globs *)pG)->mpause = UsrFuncts->pausefn;
 205
 206     if (UsrFuncts->structlen >= (sizeof(ulg) + 4*sizeof(dummyfn)) &&
 207         UsrFuncts->passwdfn)
 208         ((Uz_Globs *)pG)->decr_passwd = UsrFuncts->passwdfn;
 209
 210     if (UsrFuncts->structlen >= (sizeof(ulg) + 5*sizeof(dummyfn)) &&
 211         UsrFuncts->statrepfn)
 212         ((Uz_Globs *)pG)->statreportcb = UsrFuncts->statrepfn;
 213
 214     return TRUE;
 215 }
 216
 217
 218 int UZ_EXP UzpUnzipToMemory(char *zip, char *file, UzpOpts *optflgs,
 219     UzpCB *UsrFuncts, UzpBuffer *retstr)
 220 {
 221     int r;
 222 #if (defined(WINDLL) && !defined(CRTL_CP_IS_ISO))
 223     char *intern_zip, *intern_file;
 224 #endif
 225
 226     CONSTRUCTGLOBALS();
 227 #if (defined(WINDLL) && !defined(CRTL_CP_IS_ISO))
 228     intern_zip = (char *)malloc(strlen(zip)+1);
 229     if (intern_zip == NULL) {
 230        DESTROYGLOBALS()
 231        return PK_MEM;
 232     }
 233     intern_file = (char *)malloc(strlen(file)+1);
 234     if (intern_file == NULL) {
 235        DESTROYGLOBALS()
 236        free(intern_zip);
 237        return PK_MEM;
 238     }
 239     ISO_TO_INTERN(zip, intern_zip);
 240     ISO_TO_INTERN(file, intern_file);
 241 #   define zip intern_zip
 242 #   define file intern_file
 243 #endif
 244     /* Copy those options that are meaningful for UzpUnzipToMemory, instead of
 245      * a simple "memcpy(G.UzO, optflgs, sizeof(UzpOpts));"
 246      */
 247     uO.pwdarg = optflgs->pwdarg;
 248     uO.aflag = optflgs->aflag;
 249     uO.C_flag = optflgs->C_flag;
 250     uO.qflag = optflgs->qflag;  /* currently,  overridden in unzipToMemory */
 251
 252     if (!UzpDLL_Init((zvoid *)&G, UsrFuncts)) {
 253        DESTROYGLOBALS();
 254        return PK_BADERR;
 255     }
 256     G.redirect_data = 1;
 257
 258     r = (unzipToMemory(__G__ zip, file, retstr) <= PK_WARN);
 259
 260     DESTROYGLOBALS()
 261 #if (defined(WINDLL) && !defined(CRTL_CP_IS_ISO))
 262 #  undef file
 263 #  undef zip
 264     free(intern_file);
 265     free(intern_zip);
 266 #endif
 267     if (!r && retstr->strlength) {
 268        free(retstr->strptr);
 269        retstr->strptr = NULL;
 270     }
 271     return r;
 272 }
 273 #endif /* !WINDLL */
 274 #endif /* !__16BIT__ */
 275
 276
 277
 278
 279
 280 #ifdef OS2DLL
 281
 282 int UZ_EXP UzpFileTree(char *name, cbList(callBack), char *cpInclude[],
 283                 char *cpExclude[])
 284 {
 285     int r;
 286
 287     CONSTRUCTGLOBALS();
 288     uO.qflag = 2;
 289     uO.vflag = 1;
 290     uO.C_flag = 1;
 291     G.wildzipfn = name;
 292     G.process_all_files = TRUE;
 293     if (cpInclude) {
 294         char **ptr = cpInclude;
 295
 296         while (*ptr != NULL) ptr++;
 297         G.filespecs = ptr - cpInclude;
 298         G.pfnames = cpInclude, G.process_all_files = FALSE;
 299     }
 300     if (cpExclude) {
 301         char **ptr = cpExclude;
 302
 303         while (*ptr != NULL) ptr++;
 304         G.xfilespecs = ptr - cpExclude;
 305         G.pxnames = cpExclude, G.process_all_files = FALSE;
 306     }
 307
 308     G.processExternally = callBack;
 309     r = process_zipfiles(__G)==0;
 310     DESTROYGLOBALS()
 311     return r;
 312 }
 313
 314 #endif /* OS2DLL */
 315
 316
 317
 318
 319 /*---------------------------------------------------------------------------
 320     Helper functions
 321   ---------------------------------------------------------------------------*/
 322
 323
 324 void setFileNotFound(__G)
 325     __GDEF
 326 {
 327     G.filenotfound++;
 328 }
 329
 330
 331
 332 int unzipToMemory(__GPRO__ char *zip, char *file, UzpBuffer *retstr)
 333 {
 334     int r;
 335     char *incname[2];
 336
 337     G.process_all_files = FALSE;
 338     G.extract_flag = TRUE;
 339     uO.qflag = 2;
 340     G.wildzipfn = zip;
 341
 342     G.pfnames = incname;
 343     incname[0] = file;
 344     incname[1] = NULL;
 345     G.filespecs = 1;
 346
 347     r = process_zipfiles(__G);
 348     if (retstr) {
 349         retstr->strptr = (char *)G.redirect_buffer;
 350         retstr->strlength = G.redirect_size;
 351     }
 352     return r;                   /* returns `PK_???' error values */
 353 }
 354
 355
 356
 357 int redirect_outfile(__G)
 358      __GDEF
 359 {
 360     if (G.redirect_size != 0 || G.redirect_buffer != NULL)
 361         return FALSE;
 362
 363 #ifndef NO_SLIDE_REDIR
 364     G.redirect_slide = !G.pInfo->textmode;
 365 #endif
 366     G.redirect_size = (G.pInfo->textmode ?
 367                        G.lrec.ucsize * lenEOL : G.lrec.ucsize);
 368 #ifdef OS2
 369     DosAllocMem((void **)&G.redirect_buffer, G.redirect_size+1,
 370       PAG_READ|PAG_WRITE|PAG_COMMIT);
 371     G.redirect_pointer = G.redirect_buffer;
 372 #else
 373 #ifdef __16BIT__
 374     if ((ulg)((extent)G.redirect_size) != G.redirect_size)
 375         return FALSE;
 376 #endif
 377     G.redirect_pointer = G.redirect_buffer = malloc(G.redirect_size+1);
 378 #endif
 379     if (!G.redirect_buffer)
 380         return FALSE;
 381     G.redirect_pointer[G.redirect_size] = '\0';
 382     return TRUE;
 383 }
 384
 385
 386
 387 int writeToMemory(__GPRO__ uch *rawbuf, ulg size)
 388 {
 389     if (rawbuf != G.redirect_pointer)
 390         memcpy(G.redirect_pointer,rawbuf,size);
 391     G.redirect_pointer += size;
 392     return 0;
 393 }
 394
 395
 396
 397
 398 int close_redirect(__G)
 399      __GDEF
 400 {
 401     if (G.pInfo->textmode) {
 402         *G.redirect_pointer = '\0';
 403         G.redirect_size = G.redirect_pointer - G.redirect_buffer;
 404         if ((G.redirect_buffer =
 405              realloc(G.redirect_buffer, G.redirect_size + 1)) == NULL) {
 406             G.redirect_size = 0;
 407             return EOF;
 408         }
 409     }
 410     return 0;
 411 }
 412
 413
 414
 415
 416 #ifndef __16BIT__
 417 #ifndef WINDLL
 418
 419 /* Purpose: Determine if file in archive contains the string szSearch
 420
 421    Parameters: archive  = archive name
 422                file     = file contained in the archive. This cannot be
 423                           a wild card to be meaningful
 424                pattern  = string to search for
 425                cmd      = 0 - case-insensitive search
 426                           1 - case-sensitve search
 427                           2 - case-insensitive, whole words only
 428                           3 - case-sensitive, whole words only
 429                SkipBin  = if true, skip any files that have control
 430                           characters other than CR, LF, or tab in the first
 431                           100 characters.
 432
 433    Returns:    TRUE if a match is found
 434                FALSE if no match is found
 435                -1 on error
 436
 437    Comments: This does not pretend to be as useful as the standard
 438              Unix grep, which returns the strings associated with a
 439              particular pattern, nor does it search past the first
 440              matching occurrence of the pattern.
 441  */
 442
 443 int UZ_EXP UzpGrep(char *archive, char *file, char *pattern, int cmd,
 444                    int SkipBin, UzpCB *UsrFuncts)
 445 {
 446     int retcode = FALSE, compare;
 447     ulg i, j, patternLen, buflen;
 448     char * sz, *p;
 449     UzpOpts flgopts;
 450     UzpBuffer retstr;
 451
 452     memzero(&flgopts, sizeof(UzpOpts));         /* no special options */
 453
 454     if (!UzpUnzipToMemory(archive, file, &flgopts, UsrFuncts, &retstr)) {
 455        return -1;   /* not enough memory, file not found, or other error */
 456     }
 457
 458     if (SkipBin) {
 459         if (retstr.strlength < 100)
 460             buflen = retstr.strlength;
 461         else
 462             buflen = 100;
 463         for (i = 0; i < buflen; i++) {
 464             if (iscntrl(retstr.strptr[i])) {
 465                 if ((retstr.strptr[i] != 0x0A) &&
 466                     (retstr.strptr[i] != 0x0D) &&
 467                     (retstr.strptr[i] != 0x09))
 468                 {
 469                     /* OK, we now think we have a binary file of some sort */
 470                     free(retstr.strptr);
 471                     return FALSE;
 472                 }
 473             }
 474         }
 475     }
 476
 477     patternLen = strlen(pattern);
 478
 479     if (retstr.strlength < patternLen) {
 480         free(retstr.strptr);
 481         return FALSE;
 482     }
 483
 484     sz = malloc(patternLen + 3); /* add two in case doing whole words only */
 485     if (cmd > 1) {
 486         strcpy(sz, " ");
 487         strcat(sz, pattern);
 488         strcat(sz, " ");
 489     } else
 490         strcpy(sz, pattern);
 491
 492     if ((cmd == 0) || (cmd == 2)) {
 493         for (i = 0; i < strlen(sz); i++)
 494             sz[i] = toupper(sz[i]);
 495         for (i = 0; i < retstr.strlength; i++)
 496             retstr.strptr[i] = toupper(retstr.strptr[i]);
 497     }
 498
 499     for (i = 0; i < (retstr.strlength - patternLen); i++) {
 500         p = &retstr.strptr[i];
 501         compare = TRUE;
 502         for (j = 0; j < patternLen; j++) {
 503             /* We cannot do strncmp here, as we may be dealing with a
 504              * "binary" file, such as a word processing file, or perhaps
 505              * even a true executable of some sort. */
 506             if (p[j] != sz[j]) {
 507                 compare = FALSE;
 508                 break;
 509             }
 510         }
 511         if (compare == TRUE) {
 512             retcode = TRUE;
 513             break;
 514         }
 515     }
 516
 517     free(sz);
 518     free(retstr.strptr);
 519
 520     return retcode;
 521 }
 522 #endif /* !WINDLL */
 523 #endif /* !__16BIT__ */
 524
 525
 526
 527
 528 int UZ_EXP UzpValidate(char *archive, int AllCodes)
 529 {
 530     int retcode;
 531     CONSTRUCTGLOBALS();
 532
 533     uO.jflag = 1;
 534     uO.tflag = 1;
 535     uO.overwrite_none = 0;
 536     G.extract_flag = (!uO.zipinfo_mode &&
 537                       !uO.cflag && !uO.tflag && !uO.vflag && !uO.zflag
 538 #ifdef TIMESTAMP
 539                       && !uO.T_flag
 540 #endif
 541                      );
 542
 543     uO.qflag = 2;                        /* turn off all messages */
 544     G.fValidate = TRUE;
 545     G.pfnames = (char **)&fnames[0];    /* assign default filename vector */
 546 #ifdef WINDLL
 547     Wiz_NoPrinting(TRUE);
 548 #endif
 549
 550     if (archive == NULL) {      /* something is screwed up:  no filename */
 551         DESTROYGLOBALS();
 552         return PK_NOZIP;
 553     }
 554
 555     G.wildzipfn = (char *)malloc(FILNAMSIZ + 1);
 556     strcpy(G.wildzipfn, archive);
 557 #if (defined(WINDLL) && !defined(CRTL_CP_IS_ISO))
 558     _ISO_INTERN(G.wildzipfn);
 559 #endif
 560
 561     G.process_all_files = TRUE;         /* for speed */
 562
 563     retcode = setjmp(dll_error_return);
 564
 565     if (retcode) {
 566 #ifdef WINDLL
 567         Wiz_NoPrinting(FALSE);
 568 #endif
 569         free(G.wildzipfn);
 570         DESTROYGLOBALS();
 571         return PK_BADERR;
 572     }
 573
 574     retcode = process_zipfiles(__G);
 575
 576     free(G.wildzipfn);
 577 #ifdef WINDLL
 578     Wiz_NoPrinting(FALSE);
 579 #endif
 580     DESTROYGLOBALS();
 581
 582     /* PK_WARN == 1 and PK_FIND == 11. When we are just looking at an
 583        archive, we should still be able to see the files inside it,
 584        even if we can't decode them for some reason.
 585
 586        We also still want to be able to get at files even if there is
 587        something odd about the zip archive, hence allow PK_WARN,
 588        PK_FIND, IZ_UNSUP as well as PK_ERR
 589      */
 590
 591     if (AllCodes)
 592         return retcode;
 593
 594     if ((retcode == PK_OK) || (retcode == PK_WARN) || (retcode == PK_ERR) ||
 595         (retcode == IZ_UNSUP) || (retcode == PK_FIND))
 596         return TRUE;
 597     else
 598         return FALSE;
 599 }
 600
 601 #endif /* DLL */