static TACommandVerdict get_crc_table_cmd(TAThread thread,TAInputStream stream) { const uLongf* res; START_TARGET_OPERATION(thread); res = get_crc_table(); END_TARGET_OPERATION(thread); // Response writeULongList(thread, res, 256); sendResponse(thread); return taDefaultVerdict; }
ZIP_EXTERN struct zip_source * zip_source_pkware(struct zip *za, struct zip_source *src, zip_uint16_t em, int flags, const char *password) { struct trad_pkware *ctx; struct zip_source *s2; if (password == NULL || src == NULL || em != ZIP_EM_TRAD_PKWARE) { _zip_error_set(&za->error, ZIP_ER_INVAL, 0); return NULL; } if (flags & ZIP_CODEC_ENCODE) { _zip_error_set(&za->error, ZIP_ER_ENCRNOTSUPP, 0); return NULL; } if (crc == NULL) crc = get_crc_table(); if ((ctx=(struct trad_pkware *)malloc(sizeof(*ctx))) == NULL) { _zip_error_set(&za->error, ZIP_ER_MEMORY, 0); return NULL; } ctx->e[0] = ctx->e[1] = 0; ctx->key[0] = KEY0; ctx->key[1] = KEY1; ctx->key[2] = KEY2; decrypt(ctx, NULL, (const zip_uint8_t *)password, strlen(password), 1); if ((s2=zip_source_layered(za, src, pkware_decrypt, ctx)) == NULL) { pkware_free(ctx); return NULL; } return s2; }
extern MINIZIP_EXPORT int zipOpenNewFileInZip3 (zipFile file,const char* filename,const zip_fileinfo* zipfi, const void* extrafield_local,uInt size_extrafield_local, const void* extrafield_global,uInt size_extrafield_global, const char* comment,int method,int level,int raw, int windowBits,int memLevel,int strategy, const char* password,uLong crcForCrypting) { zip_internal* zi; uInt size_filename; uInt size_comment; uInt i; int err = ZIP_OK; # ifdef NOCRYPT if (password != 0) return ZIP_PARAMERROR; # endif if (file == 0) return ZIP_PARAMERROR; if ((method!=0) && (method!=Z_DEFLATED)) return ZIP_PARAMERROR; zi = (zip_internal*)file; if (zi->in_opened_file_inzip == 1) { err = zipCloseFileInZip (file); if (err != ZIP_OK) return err; } if (filename==0) filename="-"; if (comment==0) size_comment = 0; else size_comment = (uInt)strlen(comment); size_filename = (uInt)strlen(filename); if (zipfi == 0) zi->ci.dosDate = 0; else { if (zipfi->dosDate != 0) zi->ci.dosDate = zipfi->dosDate; else zi->ci.dosDate = ziplocal_TmzDateToDosDate(&zipfi->tmz_date,zipfi->dosDate); } zi->ci.flag = 0; if ((level==8) || (level==9)) zi->ci.flag |= 2; if ((level==2)) zi->ci.flag |= 4; if ((level==1)) zi->ci.flag |= 6; if (password != 0) zi->ci.flag |= 1; zi->ci.crc32 = 0; zi->ci.method = method; zi->ci.encrypt = 0; zi->ci.stream_initialised = 0; zi->ci.pos_in_buffered_data = 0; zi->ci.raw = raw; zi->ci.pos_local_header = ZTELL(zi->z_filefunc,zi->filestream) ; zi->ci.size_centralheader = SIZECENTRALHEADER + size_filename + size_extrafield_global + size_comment; zi->ci.central_header = (char*)ALLOC((uInt)zi->ci.size_centralheader); ziplocal_putValue_inmemory(zi->ci.central_header,(uLong)CENTRALHEADERMAGIC,4); /* version info */ ziplocal_putValue_inmemory(zi->ci.central_header+4,(uLong)VERSIONMADEBY,2); ziplocal_putValue_inmemory(zi->ci.central_header+6,(uLong)20,2); ziplocal_putValue_inmemory(zi->ci.central_header+8,(uLong)zi->ci.flag,2); ziplocal_putValue_inmemory(zi->ci.central_header+10,(uLong)zi->ci.method,2); ziplocal_putValue_inmemory(zi->ci.central_header+12,(uLong)zi->ci.dosDate,4); ziplocal_putValue_inmemory(zi->ci.central_header+16,(uLong)0,4); /*crc*/ ziplocal_putValue_inmemory(zi->ci.central_header+20,(uLong)0,4); /*compr size*/ ziplocal_putValue_inmemory(zi->ci.central_header+24,(uLong)0,4); /*uncompr size*/ ziplocal_putValue_inmemory(zi->ci.central_header+28,(uLong)size_filename,2); ziplocal_putValue_inmemory(zi->ci.central_header+30,(uLong)size_extrafield_global,2); ziplocal_putValue_inmemory(zi->ci.central_header+32,(uLong)size_comment,2); ziplocal_putValue_inmemory(zi->ci.central_header+34,(uLong)0,2); /*disk nm start*/ if (zipfi==0) ziplocal_putValue_inmemory(zi->ci.central_header+36,(uLong)0,2); else ziplocal_putValue_inmemory(zi->ci.central_header+36,(uLong)zipfi->internal_fa,2); if (zipfi==0) ziplocal_putValue_inmemory(zi->ci.central_header+38,(uLong)0,4); else ziplocal_putValue_inmemory(zi->ci.central_header+38,(uLong)zipfi->external_fa,4); ziplocal_putValue_inmemory(zi->ci.central_header+42,(uLong)zi->ci.pos_local_header- zi->add_position_when_writting_offset,4); for (i=0;i<size_filename;i++) *(zi->ci.central_header+SIZECENTRALHEADER+i) = *(filename+i); for (i=0;i<size_extrafield_global;i++) *(zi->ci.central_header+SIZECENTRALHEADER+size_filename+i) = *(((const char*)extrafield_global)+i); for (i=0;i<size_comment;i++) *(zi->ci.central_header+SIZECENTRALHEADER+size_filename+ size_extrafield_global+i) = *(comment+i); if (zi->ci.central_header == 0) return ZIP_INTERNALERROR; /* write the local header */ err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)LOCALHEADERMAGIC,4); if (err==ZIP_OK) err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)20,2);/* version needed to extract */ if (err==ZIP_OK) err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.flag,2); if (err==ZIP_OK) err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.method,2); if (err==ZIP_OK) err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.dosDate,4); if (err==ZIP_OK) err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* crc 32, unknown */ if (err==ZIP_OK) err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* compressed size, unknown */ if (err==ZIP_OK) err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* uncompressed size, unknown */ if (err==ZIP_OK) err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_filename,2); if (err==ZIP_OK) err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_extrafield_local,2); if ((err==ZIP_OK) && (size_filename>0)) if (ZWRITE(zi->z_filefunc,zi->filestream,filename,size_filename)!=size_filename) err = ZIP_ERRNO; if ((err==ZIP_OK) && (size_extrafield_local>0)) if (ZWRITE(zi->z_filefunc,zi->filestream,extrafield_local,size_extrafield_local) !=size_extrafield_local) err = ZIP_ERRNO; zi->ci.stream.avail_in = (uInt)0; zi->ci.stream.avail_out = (uInt)Z_BUFSIZE; zi->ci.stream.next_out = zi->ci.buffered_data; zi->ci.stream.total_in = 0; zi->ci.stream.total_out = 0; if ((err==ZIP_OK) && (zi->ci.method == Z_DEFLATED) && (!zi->ci.raw)) { zi->ci.stream.zalloc = (alloc_func)0; zi->ci.stream.zfree = (free_func)0; zi->ci.stream.opaque = (voidpf)0; if (windowBits>0) windowBits = -windowBits; err = deflateInit2(&zi->ci.stream, level, Z_DEFLATED, windowBits, memLevel, strategy); if (err==Z_OK) zi->ci.stream_initialised = 1; } # ifndef NOCRYPT zi->ci.crypt_header_size = 0; if ((err==Z_OK) && (password != 0)) { unsigned char bufHead[RAND_HEAD_LEN]; unsigned int sizeHead; zi->ci.encrypt = 1; zi->ci.pcrc_32_tab = get_crc_table(); /*init_keys(password,zi->ci.keys,zi->ci.pcrc_32_tab);*/ sizeHead=crypthead(password,bufHead,RAND_HEAD_LEN,zi->ci.keys,zi->ci.pcrc_32_tab,crcForCrypting); zi->ci.crypt_header_size = sizeHead; if (ZWRITE(zi->z_filefunc,zi->filestream,bufHead,sizeHead) != sizeHead) err = ZIP_ERRNO; } # endif if (err==Z_OK) zi->in_opened_file_inzip = 1; return err; }
static blargg_err_t init_zip() { get_crc_table(); // initialize zlib's CRC-32 tables return blargg_ok; }
static int ZipOpenCurrentFile(Zip* file, const char *password) { int err = _ZIP_OK; int store; unsigned int isizevar; _zip* s; zipFileInfoInternal* pfileinzipreadinfo; unsigned long localextrafieldoffset; unsigned int localextrafieldsize; char source[12]; if(file == NULL) return _ZIP_PARAM_ERROR; s = (_zip*)file; if(!s->currentfileok) return _ZIP_PARAM_ERROR; if(s->currentzipfileinfo != NULL) ZipCloseCurrentFile(file); if(ZipCheckCurrentFileCoherencyHeader(s, &isizevar, &localextrafieldoffset, &localextrafieldsize) != _ZIP_OK) return _ZIP_BAD_FILE; pfileinzipreadinfo = (zipFileInfoInternal*) MallocPatch(sizeof(zipFileInfoInternal)); if(pfileinzipreadinfo == NULL) return _ZIP_INTERNAL_ERROR; pfileinzipreadinfo->buffer = (char*)MallocPatch(_ZIP_BUFFER_SIZE); pfileinzipreadinfo->localextrafieldoffset = localextrafieldoffset; pfileinzipreadinfo->localextrafieldsize = localextrafieldsize; pfileinzipreadinfo->localextrafieldpos = 0; if(pfileinzipreadinfo->buffer == NULL) { FreePatch(pfileinzipreadinfo); return _ZIP_INTERNAL_ERROR; } pfileinzipreadinfo->streaminitialised = 0; if((s->currentfileinfo.compressionmethod != 0) && (s->currentfileinfo.compressionmethod != Z_DEFLATED)) err = _ZIP_BAD_FILE; store = s->currentfileinfo.compressionmethod == 0; pfileinzipreadinfo->crc32wait = s->currentfileinfo.crc; pfileinzipreadinfo->crc32 = 0; pfileinzipreadinfo->compressionmethod = s->currentfileinfo.compressionmethod; pfileinzipreadinfo->file = s->file; pfileinzipreadinfo->bytebeforezip = s->bytebeforezip; pfileinzipreadinfo->stream.total_out = 0; if(!store) { pfileinzipreadinfo->stream.zalloc = (alloc_func)0; pfileinzipreadinfo->stream.zfree = (free_func)0; pfileinzipreadinfo->stream.opaque = (voidpf)0; err = inflateInit2(&pfileinzipreadinfo->stream, -MAX_WBITS); if(err == Z_OK) pfileinzipreadinfo->streaminitialised = 1; } pfileinzipreadinfo->restreadcompressed = s->currentfileinfo.compressedsize; pfileinzipreadinfo->restreaduncompressed = s->currentfileinfo.uncompressedsize; pfileinzipreadinfo->posinzip = s->currentfileinfointernal.currentfileoffset + _ZIP_LOCALHEADER_SIZE + isizevar; pfileinzipreadinfo->stream.avail_in = (unsigned int)0; s->currentzipfileinfo = pfileinzipreadinfo; if(password != NULL) { int i; s->crc32tab = get_crc_table(); ZipInitKeys(password, s->keys, s->crc32tab); if(fseek(pfileinzipreadinfo->file, s->currentzipfileinfo->posinzip + s->currentzipfileinfo->bytebeforezip, SEEK_SET) != 0) { FreePatch(pfileinzipreadinfo->buffer); FreePatch(pfileinzipreadinfo); return _ZIP_INTERNAL_ERROR; } if(fread(source, 1, 12, pfileinzipreadinfo->file) < 12) { FreePatch(pfileinzipreadinfo->buffer); FreePatch(pfileinzipreadinfo); return _ZIP_INTERNAL_ERROR; } for(i = 0; i < 12; i++) zdecode(s->keys, s->crc32tab, source[i]); s->currentzipfileinfo->posinzip += 12; s->encrypted = 1; } return _ZIP_OK; }
/* Open for reading data the current file in the zipfile. If there is no error and the file is opened, the return value is UNZ_OK. */ int ZEXPORT unzOpenCurrentFile3 ( unzFile file, int* method, int* level, int raw, const char* password) { int err=UNZ_OK; uInt iSizeVar; unz_s* s; file_in_zip_read_info_s* pfile_in_zip_read_info; uLong offset_local_extrafield; /* offset of the local extra field */ uInt size_local_extrafield; /* size of the local extra field */ # ifndef NOUNCRYPT char source[12]; # else if (password != NULL) return UNZ_PARAMERROR; # endif if (file==NULL) return UNZ_PARAMERROR; s=(unz_s*)file; if (!s->current_file_ok) return UNZ_PARAMERROR; if (s->pfile_in_zip_read != NULL) unzCloseCurrentFile(file); if (unzlocal_CheckCurrentFileCoherencyHeader(s,&iSizeVar, &offset_local_extrafield,&size_local_extrafield)!=UNZ_OK) return UNZ_BADZIPFILE; pfile_in_zip_read_info = (file_in_zip_read_info_s*) ALLOC(sizeof(file_in_zip_read_info_s)); if (pfile_in_zip_read_info==NULL) return UNZ_INTERNALERROR; pfile_in_zip_read_info->read_buffer=(char*)ALLOC(UNZ_BUFSIZE); pfile_in_zip_read_info->offset_local_extrafield = offset_local_extrafield; pfile_in_zip_read_info->size_local_extrafield = size_local_extrafield; pfile_in_zip_read_info->pos_local_extrafield=0; pfile_in_zip_read_info->raw=raw; if (pfile_in_zip_read_info->read_buffer==NULL) { TRYFREE(pfile_in_zip_read_info); return UNZ_INTERNALERROR; } pfile_in_zip_read_info->stream_initialised=0; if (method!=NULL) *method = (int)s->cur_file_info.compression_method; if (level!=NULL) { *level = 6; switch (s->cur_file_info.flag & 0x06) { case 6 : *level = 1; break; case 4 : *level = 2; break; case 2 : *level = 9; break; } } if ((s->cur_file_info.compression_method!=0) && (s->cur_file_info.compression_method!=Z_DEFLATED)) err=UNZ_BADZIPFILE; pfile_in_zip_read_info->crc32_wait=s->cur_file_info.crc; pfile_in_zip_read_info->crc32=0; pfile_in_zip_read_info->compression_method = s->cur_file_info.compression_method; pfile_in_zip_read_info->filestream=s->filestream; pfile_in_zip_read_info->z_filefunc=s->z_filefunc; pfile_in_zip_read_info->byte_before_the_zipfile=s->byte_before_the_zipfile; pfile_in_zip_read_info->stream.total_out = 0; if ((s->cur_file_info.compression_method==Z_DEFLATED) && (!raw)) { pfile_in_zip_read_info->stream.zalloc = (alloc_func)0; pfile_in_zip_read_info->stream.zfree = (free_func)0; pfile_in_zip_read_info->stream.opaque = (voidpf)0; pfile_in_zip_read_info->stream.next_in = (Bytef*)0; pfile_in_zip_read_info->stream.avail_in = 0; err=inflateInit2(&pfile_in_zip_read_info->stream, -MAX_WBITS); if (err == Z_OK) pfile_in_zip_read_info->stream_initialised=1; else { TRYFREE(pfile_in_zip_read_info); return err; } /* windowBits is passed < 0 to tell that there is no zlib header. * Note that in this case inflate *requires* an extra "dummy" byte * after the compressed stream in order to complete decompression and * return Z_STREAM_END. * In unzip, i don't wait absolutely Z_STREAM_END because I known the * size of both compressed and uncompressed data */ } pfile_in_zip_read_info->rest_read_compressed = s->cur_file_info.compressed_size ; pfile_in_zip_read_info->rest_read_uncompressed = s->cur_file_info.uncompressed_size ; pfile_in_zip_read_info->pos_in_zipfile = s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER + iSizeVar; pfile_in_zip_read_info->stream.avail_in = (uInt)0; s->pfile_in_zip_read = pfile_in_zip_read_info; # ifndef NOUNCRYPT if (password != NULL) { int i; s->pcrc_32_tab = get_crc_table(); init_keys(password,s->keys,s->pcrc_32_tab); if (ZSEEK(s->z_filefunc, s->filestream, s->pfile_in_zip_read->pos_in_zipfile + s->pfile_in_zip_read->byte_before_the_zipfile, SEEK_SET)!=0) return UNZ_INTERNALERROR; if(ZREAD(s->z_filefunc, s->filestream,source, 12)<12) return UNZ_INTERNALERROR; for (i = 0; i<12; i++) zdecode(s->keys,s->pcrc_32_tab,source[i]); s->pfile_in_zip_read->pos_in_zipfile+=12; s->encrypted=1; } # endif return UNZ_OK; }
/* =========================================================================== * Function do_seekable() * return PK-type error code */ static int do_seekable( struct Globals *pG, int lastchance ) { /* static int no_ecrec = FALSE; SKM: moved to globals.h */ int maybe_exe = false; int too_weird_to_continue = false; int error = 0, error_in_archive; diag( pG, "starting do_seekable" ); /*--------------------------------------------------------------------------- * Open the zipfile for reading in BINARY mode to prevent CR/LF translation, * which would corrupt the bit streams. *---------------------------------------------------------------------------*/ if ( stat( pG->zipfn, &pG->statbuf ) || (error = S_ISDIR( pG->statbuf.st_mode )) != 0 ) { if ( lastchance ) if ( pG->no_ecrec ) printf( "can't find zip file dir" ); else printf( "can't find either zip file" ); return error ? IZ_DIR : PK_NOZIP; } pG->ziplen = pG->statbuf.st_size; if ( pG->statbuf.st_mode & S_IEXEC ) maybe_exe = true; /* might find unzip, not unzip.zip; etc. */ diag( pG, "do_seekable, loc 2" ); if ( open_input_file( pG ) ) /* this should never happen, given */ return PK_NOZIP; /* the stat() test above, but... */ diag( pG, "do_seekable, loc 3" ); /*--------------------------------------------------------------------------- * Find and process the end-of-central-directory header. UnZip need only * check last 65557 bytes of zipfile: comment may be up to 65535, end-of- * central-directory record is 18 bytes, and signature itself is 4 bytes; * add some to allow for appended garbage. *---------------------------------------------------------------------------*/ /* initialize the CRC table pointer (once) */ // EWE: This "get" of CRC table will be done again by crc32.c. // I have used a statically allocated table, so it doesn't matter. if ( CRC_32_TAB == NULL ) { if ( (CRC_32_TAB = (ulg *)get_crc_table()) == NULL ) return PK_MEM2; } pG->cur_zipfile_bufstart = 0; pG->inptr = pG->inbuf; #ifdef TIMESTAMP if ( !pG->qflag && !pG->T_flag && !pG->zipinfo_mode ) #else if ( !pG->qflag && !pG->zipinfo_mode ) #endif printf( "Archive: %s", pG->zipfn ); diag( pG, "do_seekable, loc 4" ); if ( ( ((error_in_archive = find_ecrec( pG, MIN( pG->ziplen, 66000L ))) != 0 || (error_in_archive = uz_end_central( pG )) > PK_WARN)) ) { close( pG->zipfd ); pG->zipfd = 0; /* RCV added 29-1-99 */ if ( maybe_exe ) printf( "maybe an EXE file: %s", pG->zipfn ); if ( lastchance ) return error_in_archive; else { pG->no_ecrec = true; /* assume we found wrong file: e.g., */ return PK_NOZIP; /* unzip instead of unzip.zip */ } } diag( pG, "do_seekable, loc 5" ); if ( pG->zflag > 0 && !pG->zipinfo_mode ) { /* unzip: zflag = comment ONLY */ close( pG->zipfd ); pG->zipfd = 0; /* RCV added 29-1-99 */ return error_in_archive; } /*--------------------------------------------------------------------------- * Test the end-of-central-directory info for incompatibilities (multi-disk * archives) or inconsistencies (missing or extra bytes in zipfile). *---------------------------------------------------------------------------*/ #ifdef NO_MULTIPART error = !pG->zipinfo_mode && (pG->ecrec.number_this_disk == 1) && (pG->ecrec.num_disk_start_cdir == 1); #else error = !pG->zipinfo_mode && (pG->ecrec.number_this_disk != 0); #endif if ( pG->zipinfo_mode && pG->ecrec.number_this_disk != pG->ecrec.num_disk_start_cdir ) { if ( pG->ecrec.number_this_disk > pG->ecrec.num_disk_start_cdir ) { UnzErr( pG, UEN_MISC01 ); error_in_archive = PK_FIND; too_weird_to_continue = true; } else { printf( "Central dir bogus" ); error_in_archive = PK_WARN; } #ifdef NO_MULTIPART /* concatenation of multiple parts works in some cases */ } else if ( !pG->zipinfo_mode && !error && pG->ecrec.number_this_disk != 0 ) { UnzErr( pG, UEN_MISC02 ); error_in_archive = PK_FIND; too_weird_to_continue = true; #endif } diag( pG, "do_seekable, loc 6" ); if ( !too_weird_to_continue ) { /* (relatively) normal zipfile: go for it */ if ( error ) { printf( "maybe a pak bug in %s", pG->zipfn ); error_in_archive = PK_WARN; } if ( (pG->extra_bytes = pG->real_ecrec_offset - pG->expect_ecrec_offset) < 0L ) { printf( "missing bytes in zipfile" ); error_in_archive = PK_ERR; } else if ( pG->extra_bytes > 0 ) { if ( (pG->ecrec.offset_start_central_directory == 0) && (pG->ecrec.size_central_directory != 0) ) { /* zip 1.5 -go bug */ printf( "NULL central dir" ); pG->ecrec.offset_start_central_directory = pG->extra_bytes; pG->extra_bytes = 0; error_in_archive = PK_ERR; } else { printf( "Warning: extra bytes at start of zipfile" ); error_in_archive = PK_WARN; } } /*----------------------------------------------------------------------- * Check for empty zipfile and exit now if so. *-----------------------------------------------------------------------*/ diag( pG, "do_seekable, loc 7" ); if ( pG->expect_ecrec_offset == 0L && pG->ecrec.size_central_directory == 0 ) { printf( "Empty zipfile" ); close( pG->zipfd ); pG->zipfd = 0; /* RCV added 29-1-99 */ return (error_in_archive > PK_WARN) ? error_in_archive : PK_WARN; } /*----------------------------------------------------------------------- * Compensate for missing or extra bytes, and seek to where the start * of central directory should be. If header not found, uncompensate * and try again (necessary for at least some Atari archives created * with STZip, as well as archives created by J.H. Holm's ZIPSPLIT 1.1). *-----------------------------------------------------------------------*/ ZLSEEK( pG->ecrec.offset_start_central_directory ) #ifdef OLD_SEEK_TEST if ( readbuf( pG->sig, 4 ) == 0 ) { close( pG->zipfd ); pG->zipfd = 0; /* RCV added 29-1-99 */ return PK_ERR; /* file may be locked, or possibly disk error(?) */ } if ( strncmp( pG->sig, pG->central_hdr_sig, 4 ) ) #else if ( (readbuf( pG, pG->sig, 4 ) == 0) || strncmp( pG->sig, pG->central_hdr_sig, 4 ) ) #endif { // long tmp = pG->extra_bytes; diag( pG, "central dir found" ); pG->extra_bytes = 0; ZLSEEK( pG->ecrec.offset_start_central_directory ) if ( (readbuf( pG, pG->sig, 4 ) == 0 ) || strncmp( pG->sig, pG->central_hdr_sig, 4 ) ) { UnzErr( pG, UEN_FORM18 ); close( pG->zipfd ); pG->zipfd = 0; /* RCV added 29-1-99 */ return PK_BADERR; } printf( "central dir too long" ); error_in_archive = PK_ERR; } /*----------------------------------------------------------------------- * Seek to the start of the central directory one last time, since we * have just read the first entry's signature bytes; then list, extract * or test member files as instructed, and close the zipfile. *-----------------------------------------------------------------------*/ Trace( (pG, "about to extract/list files (error = %d)\n", error_in_archive) ); ZLSEEK( pG->ecrec.offset_start_central_directory ) #ifdef TIMESTAMP // EWE do some work here??? // How can you timestamp a file before you extract it? // if ( pG->T_flag ) // error = time_stamp( pG ); /* TIME-STAMP 'EM */ // else #endif // if ( pG->vflag && !pG->tflag && !pG->cflag ) // error = //list_files( pG ); /* LIST 'EM */ // else // GO DO EXTRACT OR TEST error = extract_or_test_files( pG ); /* EXTRACT OR TEST 'EM */ Trace( (pG, "Done with extract/list files (error = %d)\n", error) ); if ( error > error_in_archive ) /* don't overwrite stronger error */ error_in_archive = error; /* with (for example) a warning */ } /* end if (!too_weird_to_continue) */