跨平台的zip文件压缩处理，支持压缩解压文件夹

  1 /*
  2 minizip.c
  3 Version 1.1, February 14h, 2010
  4 sample part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
  5 
  6 Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
  7 
  8 Modifications of Unzip for Zip64
  9 Copyright (C) 2007-2008 Even Rouault
 10 
 11 Modifications for Zip64 support on both zip and unzip
 12 Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
 13 */
 14 
 15 #ifdef _DEBUG
 16 #pragma comment(lib, "../../lib/win32/libzd.lib")
 17 #else
 18 #pragma comment(lib, "../../lib/win32/libz.lib")
 19 #endif
 20 
 21 #ifndef _WIN32
 22 #ifndef __USE_FILE_OFFSET64
 23 #define __USE_FILE_OFFSET64
 24 #endif
 25 #ifndef __USE_LARGEFILE64
 26 #define __USE_LARGEFILE64
 27 #endif
 28 #ifndef _LARGEFILE64_SOURCE
 29 #define _LARGEFILE64_SOURCE
 30 #endif
 31 #ifndef _FILE_OFFSET_BIT
 32 #define _FILE_OFFSET_BIT 64
 33 #endif
 34 #endif
 35 
 36 #include <stdio.h>
 37 #include <stdlib.h>
 38 #include <string.h>
 39 #include <time.h>
 40 #include <errno.h>
 41 #include <fcntl.h>
 42 
 43 #ifdef _LINUX
 44 # include <utime.h>
 45 # include <sys/types.h>
 46 # include <sys/stat.h>
 47 # include <unistd.h>
 48 #include <dirent.h>
 49 #else
 50 # include <direct.h>
 51 # include <io.h>
 52 #endif
 53 
 54 #include "zip.h"
 55 #include "stdstring.h"
 56 #include <vector>
 57 #include "comfun.h"
 58 
 59 using namespace std;
 60 
 61 // #ifdef _WIN32
 62 // #define USEWIN32IOAPI
 63 // #include "iowin32.h"
 64 // #endif
 65 
 66 
 67 
 68 #define WRITEBUFFERSIZE (16384)
 69 #define MAXFILENAME (256)
 70 
 71 #ifdef _WIN32
 72 static uLong filetime(const char *f, tm_zip *tmzip, uLong *dt)
 73 /*char *f;                 name of file to get info on */
 74  /* tm_zip *tmzip;            return value: access, modific. and creation times */
 75  /*uLong *dt;             dostime */
 76 {
 77     int ret = 0;
 78     {
 79         FILETIME ftLocal;
 80         HANDLE hFind;
 81         WIN32_FIND_DATAA ff32;
 82 
 83         hFind = FindFirstFileA(f,&ff32);
 84         if (hFind != INVALID_HANDLE_VALUE)
 85         {
 86             FileTimeToLocalFileTime(&(ff32.ftLastWriteTime),&ftLocal);
 87             FileTimeToDosDateTime(&ftLocal,((LPWORD)dt)+1,((LPWORD)dt)+0);
 88             FindClose(hFind);
 89             ret = 1;
 90         }
 91     }
 92     return ret;
 93 }
 94 #else
 95 #ifdef _LINUX
 96 static uLong filetime(const char *f, tm_zip *tmzip, uLong *dt)
 97  /*char *f;               name of file to get info on */
 98 /*tm_zip *tmzip;          return value: access, modific. and creation times */
 99 /*uLong *dt;              dostime */
100 {
101     int ret=0;
102     struct stat s;        /* results of stat() */
103     struct tm* filedate;
104     time_t tm_t=0;
105 
106     if (strcmp(f,"-")!=0)
107     {
108         char name[MAXFILENAME+1];
109         int len = strlen(f);
110         if (len > MAXFILENAME)
111             len = MAXFILENAME;
112 
113         strncpy(name, f,MAXFILENAME-1);
114         /* strncpy doesnt append the trailing NULL, of the string is too long. */
115         name[ MAXFILENAME ] = ‘\0‘;
116 
117         if (name[len - 1] == ‘/‘)
118             name[len - 1] = ‘\0‘;
119         /* not all systems allow stat‘ing a file with / appended */
120         if (stat(name,&s)==0)
121         {
122             tm_t = s.st_mtime;
123             ret = 1;
124         }
125     }
126     filedate = localtime(&tm_t);
127 
128     tmzip->tm_sec  = filedate->tm_sec;
129     tmzip->tm_min  = filedate->tm_min;
130     tmzip->tm_hour = filedate->tm_hour;
131     tmzip->tm_mday = filedate->tm_mday;
132     tmzip->tm_mon  = filedate->tm_mon ;
133     tmzip->tm_year = filedate->tm_year;
134 
135     return ret;
136 }
137 #else
138 uLong filetime(char *f, tm_zip *tmzip, uLong *dt)
139 {
140     return 0;
141 }
142 #endif
143 #endif
144 
145 static int check_exist_file(const char* filename)
146 {
147     FILE* ftestexist;
148     int ret = 1;
149     ftestexist = fopen64(filename,"rb");
150     if (ftestexist==NULL)
151         ret = 0;
152     else
153         fclose(ftestexist);
154 
155     return ret;
156 }
157 
158 static int isLargeFile(const char* filename)
159 {
160     int largeFile = 0;
161     ZPOS64_T pos = 0;
162     FILE* pFile = fopen64(filename, "rb");
163 
164     if(pFile != NULL)
165     {
166         int n = fseeko64(pFile, 0, SEEK_END);
167 
168         pos = ftello64(pFile);
169 
170         if(pos >= 0xffffffff)
171             largeFile = 1;
172 
173         fclose(pFile);
174     }
175 
176     return largeFile;
177 }
178 
179 static int DoZipFile(zipFile zf, const char* srcFile, const char* dstLevel)
180 {
181     if(zf == NULL || srcFile == NULL) return __LINE__;
182 
183     int err=0;
184     int size_buf=0;
185     void* buf=NULL;
186     FILE * fin;
187     int size_read;
188     const char* filenameinzip = srcFile;
189     const char *savefilenameinzip;
190     zip_fileinfo zi;
191     int zip64 = 0;
192 
193     zi.tmz_date.tm_sec = zi.tmz_date.tm_min = zi.tmz_date.tm_hour =
194         zi.tmz_date.tm_mday = zi.tmz_date.tm_mon = zi.tmz_date.tm_year = 0;
195     zi.dosDate = 0;
196     zi.internal_fa = 0;
197     zi.external_fa = 0;
198     filetime(filenameinzip,&zi.tmz_date,&zi.dosDate);
199 
200     zip64 = isLargeFile(filenameinzip);
201 
202     /* The path name saved, should not include a leading slash. */
203     /*if it did, windows/xp and dynazip couldn‘t read the zip file. */
204     savefilenameinzip = dstLevel;
205     while( savefilenameinzip[0] == ‘\\‘ || savefilenameinzip[0] == ‘/‘ )
206     {
207         savefilenameinzip++;
208     }
209 
210     err = zipOpenNewFileInZip3_64(zf, savefilenameinzip, &zi,
211         NULL, 0, NULL, 0, NULL /* comment*/,
212         Z_DEFLATED,
213         Z_DEFAULT_COMPRESSION,0,
214         -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
215         NULL, 0, zip64);
216 
217     if (err != ZIP_OK)
218         printf("error in opening %s in zipfile\n",filenameinzip);
219     else
220     {
221         fin = fopen64(filenameinzip,"rb");
222         if (fin==NULL)
223         {
224             err=ZIP_ERRNO;
225             printf("error in opening %s for reading\n",filenameinzip);
226         }
227     }
228 
229     if (err == ZIP_OK)
230     {
231         size_buf = WRITEBUFFERSIZE;
232         buf = (void*)malloc(size_buf);
233         if (buf==NULL)
234         {
235             printf("Error allocating memory\n");
236             err = ZIP_INTERNALERROR;
237         }
238         else
239         {
240             do
241             {
242                 err = ZIP_OK;
243                 size_read = (int)fread(buf,1,size_buf,fin);
244                 if (size_read < size_buf)
245                     if (feof(fin)==0)
246                     {
247                         printf("error in reading %s\n",filenameinzip);
248                         err = ZIP_ERRNO;
249                     }
250 
251                     if (size_read>0)
252                     {
253                         err = zipWriteInFileInZip (zf,buf,size_read);
254                         if (err<0)
255                         {
256                             printf("error in writing %s in the zipfile\n",
257                                 filenameinzip);
258                         }
259 
260                     }
261             } while ((err == ZIP_OK) && (size_read>0));
262 
263             free(buf);
264         }
265     }
266 
267     if (fin)
268         fclose(fin);
269 
270     if (err<0)
271         err=ZIP_ERRNO;
272     else
273     {
274         err = zipCloseFileInZip(zf);
275         if (err!=ZIP_OK)
276             printf("error in closing %s in the zipfile\n",
277             filenameinzip);
278     }
279 
280     return 0;
281 }
282 
283 int DoZipFile(const char* strFile, const char* dstLevel, const char* strZipFile, int replaceFlag)
284 {
285     int openMode = APPEND_STATUS_CREATE;
286     if (check_exist_file(strZipFile))
287     {
288         if (replaceFlag == RG_ZIP_FILE_APPEND)
289         {
290             openMode = APPEND_STATUS_ADDINZIP;
291         }
292         else
293         {
294             openMode = APPEND_STATUS_CREATE;
295         }
296     }
297 
298     zipFile zf;
299     zf = zipOpen64(strZipFile, openMode);
300     if (zf)
301     {
302         CStdString strDstLevel;
303         if(dstLevel) strDstLevel = dstLevel;
304         strDstLevel.Trim();
305         if(strDstLevel.IsEmpty())
306         {
307             strDstLevel = strFile;
308             if(strDstLevel.Right(1) == "\\" || strDstLevel.Right(1) == "/")
309                 strDstLevel = strDstLevel.Left(strDstLevel.GetLength() - 1);
310             int nFind = strDstLevel.ReverseFind(‘\\‘);
311             if(nFind == -1) nFind = strDstLevel.ReverseFind(‘/‘);
312             if(nFind != -1) 
313                 strDstLevel = strDstLevel.Mid(nFind);
314         }
315 
316         if (strDstLevel.Left(1) == "\\" || strDstLevel.Left(1) == "/") 
317             strDstLevel = strDstLevel.Right(strDstLevel.GetLength() - 1);
318 
319         DoZipFile(zf, strFile, strDstLevel.c_str());
320         zipClose(zf, NULL);
321         return 0;
322     }
323 
324     return 0;
325 }
326 
327 static int GetFilesFromDir(const char* strDir, vector<CStdString> &_fileInfo)
328 {
329 
330 #ifdef _WIN32
331     CStdString strFind = strDir;
332     CStdString strPath;
333     if (strFind.Right(1) != "\\")
334     {
335         strFind += "\\";
336     }
337     strPath = strFind;
338     strFind += "*.*";
339     
340     WIN32_FIND_DATA wfd;
341     HANDLE hFind = FindFirstFile(strFind, &wfd);
342     if (hFind != INVALID_HANDLE_VALUE)
343     {
344         while(FindNextFile(hFind, &wfd))
345         {
346             if (strcmp(wfd.cFileName, ".") == 0 || strcmp(wfd.cFileName, "..") == 0)
347             {
348                 continue;
349             }
350             CStdString strFilePath = strPath + wfd.cFileName;
351             if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
352             {
353                 GetFilesFromDir(strFilePath.c_str(), _fileInfo);
354             }
355             else
356             {
357                 _fileInfo.push_back(strFilePath);
358             }
359         }
360         FindClose(hFind);
361         return 0;
362     }
363     
364     return __LINE__;
365 #else
366     struct stat     statbuf;
367     struct dirent    *dirp;
368     DIR                *dp;
369     const char* szPath = strDir;
370 
371     if(lstat(szPath, &statbuf) < 0)
372     {
373         perror("lstat");
374         return __LINE__;
375     }
376     if(S_ISDIR(statbuf.st_mode) == 0)
377     {
378         _fileInfo.push_back(szPath);
379         return 0;
380     }
381 
382     if((dp = opendir(szPath)) == NULL)
383     {
384         perror("opendir");
385         return __LINE__;
386     }
387 
388     while((dirp = readdir(dp)) != NULL)
389     {
390         if(strcmp(dirp->d_name, ".") == 0 ||
391             strcmp(dirp->d_name, "..") == 0)
392             continue;
393 
394         std::string subDir = string(szPath) + "/";
395         subDir += dirp->d_name;
396         if(dirp->d_type == DT_REG)
397         {
398             _fileInfo.push_back(subDir);
399         }
400         else if(dirp->d_type == DT_DIR)    
401         {
402             GetFilesFromDir(subDir.c_str(), _fileInfo);
403         }
404     }
405 
406     closedir(dp);
407 #endif
408 }
409 
410 int DoZipDir(const char* strDir, const char* dstLevel, const char* strZipFile, int replaceFlag)
411 {
412     int openMode = APPEND_STATUS_CREATE;
413     if(check_exist_file(strZipFile))
414     {
415         if (replaceFlag == RG_ZIP_FILE_APPEND)
416         {
417             openMode = APPEND_STATUS_ADDINZIP;
418         }
419         else
420         {
421             remove(strZipFile);
422             openMode = APPEND_STATUS_CREATE;
423         }
424     }
425 
426     CStdString strDstLevel;
427     if(dstLevel) strDstLevel= dstLevel;
428     strDstLevel.Trim();
429     if(strDstLevel.IsEmpty()) {    //use current dir path as zip file path level 
430         strDstLevel = strDir;
431         if(strDstLevel.Right(1) == "/" || strDstLevel.Right(1) == "\\")    //remove the last slash
432             strDstLevel = strDstLevel.Left(strDstLevel.GetLength() - 1);
433 
434         int nFind = strDstLevel.ReverseFind(‘\\‘);    //now get the dst level in zip file
435         if(nFind == -1) nFind = strDstLevel.ReverseFind(‘/‘);
436         if(nFind != -1) strDstLevel = strDstLevel.Mid(nFind); 
437     }
438 
439     //add pending slash
440 #ifdef _WIN32
441     if(strDstLevel.Right(1) != "\\") strDstLevel += "\\";    
442 #else
443     if(strDstLevel.Right(1) != "/") strDstLevel += "/";
444 #endif
445 
446     //remove slash at the beginning of the string
447     if (strDstLevel.Left(1) == "\\" || strDstLevel.Left(1) == "/") 
448         strDstLevel = strDstLevel.Right(strDstLevel.GetLength() - 1);
449 
450     zipFile zf;
451     zf = zipOpen64(strZipFile, openMode);
452     if (zf)
453     {
454         vector<CStdString> _fileInfo;
455         GetFilesFromDir(strDir, _fileInfo);
456         for (size_t i = 0; i < _fileInfo.size(); ++i)
457         {
458             CStdString strFilePath = _fileInfo[i];
459             CStdString strFileLevel;
460             int nFind = strFilePath.Find(strDir);
461             if(nFind != -1) strFileLevel = strFilePath.Mid(strlen(strDir));
462 
463             if (strFileLevel.Left(1) == "\\" || strFileLevel.Left(1) == "/") 
464                 strFileLevel = strFileLevel.Right(strFileLevel.GetLength() - 1);
465                 
466             strFileLevel = strDstLevel + strFileLevel;
467             strFileLevel.Replace("\\", "/");
468 
469             DoZipFile(zf, strFilePath.c_str(), strFileLevel.c_str());
470 //            printf("%s\n%s\n", strFilePath.c_str(), strFileLevel.c_str());
471         }
472         
473         zipClose(zf, NULL);
474         return 0;
475     }
476     
477     return __LINE__;
478 }
479 
480 #ifdef _TESTZIP
481 int main(int argc, char* argv[])
482 {
483     if(argc < 2)
484     {
485         printf("Usage: %s zipfile filetozip\n", argv[0]);
486         getchar();
487         return 1;
488     }
489     const char* szZipFile = argv[1];
490     bool bFirst = true;
491     for(int i = 2; i < argc; ++i)
492     {
493         const char* filetozip = argv[i];
494         DWORD dwAttr = GetFileAttributes(filetozip);
495         if(dwAttr == INVALID_FILE_ATTRIBUTES)
496         {
497             printf("invalid file name: %s\n", filetozip);
498             continue;
499         }
500         if(dwAttr & FILE_ATTRIBUTE_DIRECTORY)
501         {
502             DoZipDir(filetozip, "", szZipFile, 
503                     bFirst ? RG_ZIP_FILE_REPLACE : RG_ZIP_FILE_APPEND);
504             bFirst = false;
505         }
506         else if(dwAttr & FILE_ATTRIBUTE_NORMAL)
507         {
508             DoZipFile(filetozip, "", szZipFile, 
509                     bFirst ? RG_ZIP_FILE_REPLACE : RG_ZIP_FILE_APPEND);
510             bFirst = false;
511         }
512     }
513 
514     getchar();
515 
516     return 0;
517 }
518 
519 #endif

  1 /*
  2 miniunz.c
  3 Version 1.1, February 14h, 2010
  4 sample part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
  5 
  6 Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
  7 
  8 Modifications of Unzip for Zip64
  9 Copyright (C) 2007-2008 Even Rouault
 10 
 11 Modifications for Zip64 support on both zip and unzip
 12 Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
 13 */
 14 
 15 #ifndef _WIN32
 16 #ifndef __USE_FILE_OFFSET64
 17 #define __USE_FILE_OFFSET64
 18 #endif
 19 #ifndef __USE_LARGEFILE64
 20 #define __USE_LARGEFILE64
 21 #endif
 22 #ifndef _LARGEFILE64_SOURCE
 23 #define _LARGEFILE64_SOURCE
 24 #endif
 25 #ifndef _FILE_OFFSET_BIT
 26 #define _FILE_OFFSET_BIT 64
 27 #endif
 28 #endif
 29 
 30 #include <stdio.h>
 31 #include <stdlib.h>
 32 #include <string.h>
 33 #include <time.h>
 34 #include <errno.h>
 35 #include <fcntl.h>
 36 
 37 #ifdef _LINUX
 38 #include <unistd.h>
 39 #include <utime.h>
 40 #include <sys/stat.h>
 41 #include <sys/types.h>
 42 #else
 43 #include <direct.h>
 44 #include <io.h>
 45 #include <Windows.h>
 46 #endif
 47 
 48 #include "unzip.h"
 49 #include "stdstring.h"
 50 
 51 #define CASESENSITIVITY (0)
 52 #define WRITEBUFFERSIZE (8192)
 53 #define MAXFILENAME (256)
 54 
 55 /*
 56 #ifdef _WIN32
 57 #define USEWIN32IOAPI
 58 #include "iowin32.h"
 59 #endif
 60 */
 61 /*
 62 mini unzip, demo of unzip package
 63 
 64 usage :
 65 Usage : miniunz [-exvlo] file.zip [file_to_extract] [-d extractdir]
 66 
 67 list the file in the zipfile, and print the content of FILE_ID.ZIP or README.TXT
 68 if it exists
 69 */
 70 
 71 
 72 /* change_file_date : change the date/time of a file
 73 filename : the filename of the file where date/time must be modified
 74 dosdate : the new date at the MSDos format (4 bytes)
 75 tmu_date : the SAME new date at the tm_unz format */
 76 static void change_file_date(const char *filename, uLong dosdate, tm_unz tmu_date)
 77 {
 78 #ifdef _WIN32
 79     HANDLE hFile;
 80     FILETIME ftm,ftLocal,ftCreate,ftLastAcc,ftLastWrite;
 81 
 82     hFile = CreateFileA(filename,GENERIC_READ | GENERIC_WRITE,
 83         0,NULL,OPEN_EXISTING,0,NULL);
 84     GetFileTime(hFile,&ftCreate,&ftLastAcc,&ftLastWrite);
 85     DosDateTimeToFileTime((WORD)(dosdate>>16),(WORD)dosdate,&ftLocal);
 86     LocalFileTimeToFileTime(&ftLocal,&ftm);
 87     SetFileTime(hFile,&ftm,&ftLastAcc,&ftm);
 88     CloseHandle(hFile);
 89 #else
 90 #ifdef _LINUX
 91     struct utimbuf ut;
 92     struct tm newdate;
 93     newdate.tm_sec = tmu_date.tm_sec;
 94     newdate.tm_min=tmu_date.tm_min;
 95     newdate.tm_hour=tmu_date.tm_hour;
 96     newdate.tm_mday=tmu_date.tm_mday;
 97     newdate.tm_mon=tmu_date.tm_mon;
 98     if (tmu_date.tm_year > 1900)
 99         newdate.tm_year=tmu_date.tm_year - 1900;
100     else
101         newdate.tm_year=tmu_date.tm_year ;
102     newdate.tm_isdst=-1;
103 
104     ut.actime=ut.modtime=mktime(&newdate);
105     utime(filename,&ut);
106 #endif
107 #endif
108 }
109 
110 
111 /* mymkdir and change_file_date are not 100 % portable
112 As I don‘t know well Unix, I wait feedback for the unix portion */
113 
114 static int mymkdir(const char* dirname)
115 {
116     int ret=0;
117 #ifdef _WIN32
118     ret = _mkdir(dirname);
119 #else
120 #ifdef _LINUX
121     ret = mkdir (dirname,0775);
122 #endif
123 #endif
124     return ret;
125 }
126 
127 int makedir (const char *newdir)
128 {
129     char *buffer ;
130     char *p;
131     int  len = (int)strlen(newdir);
132 
133     if (len <= 0)
134         return 0;
135 
136     buffer = (char*)malloc(len+1);
137     if (buffer==NULL)
138     {
139         printf("Error allocating memory\n");
140         return UNZ_INTERNALERROR;
141     }
142     strcpy(buffer,newdir);
143 
144     if (buffer[len-1] == ‘/‘) {
145         buffer[len-1] = ‘\0‘;
146     }
147     if (mymkdir(buffer) == 0)
148     {
149         free(buffer);
150         return 1;
151     }
152 
153     p = buffer+1;
154     while (1)
155     {
156         char hold;
157 
158         while(*p && *p != ‘\\‘ && *p != ‘/‘)
159             p++;
160         hold = *p;
161         *p = 0;
162         if ((mymkdir(buffer) == -1) && (errno == ENOENT))
163         {
164             printf("couldn‘t create directory %s\n",buffer);
165             free(buffer);
166             return 0;
167         }
168         if (hold == 0)
169             break;
170         *p++ = hold;
171     }
172     free(buffer);
173     return 1;
174 }
175 
176 static int do_extract_currentfile(unzFile uf, const char* password)
177 {
178     char filename_inzip[256];
179     char* filename_withoutpath;
180     char* p;
181     int err=UNZ_OK;
182     FILE *fout=NULL;
183     void* buf;
184     uInt size_buf;
185 
186     unz_file_info64 file_info;
187     uLong ratio=0;
188     err = unzGetCurrentFileInfo64(uf,&file_info,filename_inzip,sizeof(filename_inzip),NULL,0,NULL,0);
189 
190     if (err!=UNZ_OK)
191     {
192         printf("error %d with zipfile in unzGetCurrentFileInfo\n",err);
193         return err;
194     }
195 
196     size_buf = WRITEBUFFERSIZE;
197     buf = (void*)malloc(size_buf);
198     if (buf==NULL)
199     {
200         printf("Error allocating memory\n");
201         return UNZ_INTERNALERROR;
202     }
203 
204     p = filename_withoutpath = filename_inzip;
205     while ((*p) != ‘\0‘)
206     {
207         if (((*p)==‘/‘) || ((*p)==‘\\‘))
208             filename_withoutpath = p+1;
209         p++;
210     }
211 
212     if ((*filename_withoutpath)==‘\0‘)
213     {
214         mymkdir(filename_inzip);
215     }
216     else
217     {
218         const char* write_filename;
219 
220         write_filename = filename_inzip;
221 
222         err = unzOpenCurrentFilePassword(uf,password);
223         if (err==UNZ_OK)
224         {
225             fout=fopen64(write_filename,"wb");
226 
227             /* some zipfile don‘t contain directory alone before file */
228             if ((fout==NULL) &&
229                 (filename_withoutpath!=(char*)filename_inzip))
230             {
231                 char c=*(filename_withoutpath-1);
232                 *(filename_withoutpath-1)=‘\0‘;
233                 makedir(write_filename);
234                 *(filename_withoutpath-1)=c;
235                 fout=fopen64(write_filename,"wb");
236             }
237 
238             if (fout==NULL)
239             {
240                 printf("error opening %s\n",write_filename);
241             }
242         }
243         else
244         {
245             printf("error %d with zipfile in unzOpenCurrentFilePassword\n",err);
246         }
247 
248         if (fout!=NULL)
249         {
250             do
251             {
252                 err = unzReadCurrentFile(uf,buf,size_buf);
253                 if (err<0)
254                 {
255                     printf("error %d with zipfile in unzReadCurrentFile\n",err);
256                     break;
257                 }
258                 if (err>0)
259                     if (fwrite(buf,err,1,fout)!=1)
260                     {
261                         printf("error in writing extracted file\n");
262                         err=UNZ_ERRNO;
263                         break;
264                     }
265             }
266             while (err>0);
267             if (fout)
268                 fclose(fout);
269 
270             if (err==UNZ_OK)
271                 change_file_date(write_filename,file_info.dosDate,
272                 file_info.tmu_date);
273         }
274 
275         if (err==UNZ_OK)
276         {
277             err = unzCloseCurrentFile (uf);
278             if (err!=UNZ_OK)
279             {
280                 printf("error %d with zipfile in unzCloseCurrentFile\n",err);
281             }
282         }
283         else
284             unzCloseCurrentFile(uf); /* don‘t lose the error */
285     }
286 
287     free(buf);
288     return err;
289 }
290 
291 
292 static int do_extract(unzFile uf, const char* password)
293 {
294     uLong i;
295     unz_global_info64 gi;
296     int err;
297     FILE* fout=NULL;
298 
299     err = unzGetGlobalInfo64(uf,&gi);
300     if (err!=UNZ_OK)
301         printf("error %d with zipfile in unzGetGlobalInfo \n",err);
302 
303     for (i=0;i<gi.number_entry;i++)
304     {
305         if (do_extract_currentfile(uf, password) != UNZ_OK)
306             break;
307 
308         if ((i+1) < gi.number_entry)
309         {
310             err = unzGoToNextFile(uf);
311             if (err!=UNZ_OK)
312             {
313                 printf("error %d with zipfile in unzGoToNextFile\n",err);
314                 break;
315             }
316         }
317     }
318 
319     return 0;
320 }
321 
322 static int do_extract_onefile(unzFile uf, const char* filename, const char* password)
323 {
324     int err = UNZ_OK;
325     if (unzLocateFile(uf,filename,CASESENSITIVITY)!=UNZ_OK)
326     {
327         printf("file %s not found in the zipfile\n",filename);
328         return 2;
329     }
330 
331     if (do_extract_currentfile(uf, password) == UNZ_OK)
332         return 0;
333     else
334         return 1;
335 }
336 
337 
338 int DoUnzip(const char* szZipFile, const char* szTargetDir)
339 {
340     if (szZipFile == NULL)
341     {
342         return __LINE__;
343     }
344     
345     CStdString dirname;
346     if(szTargetDir) dirname = szTargetDir;
347     dirname.Trim();
348 
349     unzFile uf = unzOpen64(szZipFile);
350     if (uf)
351     {
352 #ifdef _WIN32
353         if (!dirname.IsEmpty() && _chdir(dirname.c_str()))
354 #else
355         if (!dirname.IsEmpty() && chdir(dirname.c_str()))
356 #endif
357         {
358             printf("Error changing into %s, aborting\n", dirname.c_str());
359             return __LINE__;
360         }
361 
362         do_extract(uf, NULL);
363 
364         unzClose(uf);
365         return 0;
366     }
367     
368     return __LINE__;
369 }
370 
371 int DoUnzipFile(const char* szZipFile, const char* srcFileToExtract, const char* szTargetDir)
372 {
373     if (szZipFile == NULL)
374     {
375         return __LINE__;
376     }
377 
378     CStdString dirname;
379     if(szTargetDir) dirname = szTargetDir;
380     dirname.Trim();
381 
382     unzFile uf = unzOpen64(szZipFile);
383     if (uf)
384     {
385 #ifdef _WIN32
386         if (!dirname.IsEmpty() && _chdir(dirname.c_str()))
387 #else
388         if (!dirname.IsEmpty() && chdir(dirname.c_str()))
389 #endif
390         {
391             printf("Error changing into %s, aborting\n", dirname.c_str());
392             return __LINE__;
393         }
394 
395         do_extract_onefile(uf, srcFileToExtract, NULL);
396 
397         unzClose(uf);
398         return 0;
399     }
400 
401     return __LINE__;
402 }
403 
404 #ifdef _TESTUNZIP
405 int main(int argc, char* argv[])
406 {
407     if(argc < 1)
408     {
409         printf("Usage: %s zipfile\n", argv[0]);
410         return 1;
411     }
412 
413     bool bExtractSingalFile = false;
414     for(int i = 1; i < argc; ++i)
415     {
416         if(strcmp(argv[i], "-s") == 0)
417         {
418             if(i + 1 < argc)
419             {
420                 i++;
421                 const char* filetoextract = argv[i];
422                 printf("extract singal file %s\n", filetoextract);
423                 i++;
424                 if(i < argc)
425                 {
426                     DoUnzipFile(argv[i++], filetoextract, NULL);
427                 }
428             }
429         }
430         else
431             DoUnzip(argv[i], NULL);
432     }
433 
434     return 0;
435 }
436 #endif