开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 压缩解压 > 查看源码
miniunz.c
资源名称：zlib.zip　[点击查看]
上传用户：zlt_tm
上传日期：2007-01-06
资源大小：214k
文件大小：11k
源码类别：

压缩解压

开发平台：

WINDOWS

miniunz.c：源码内容
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <time.h>
  5. #include <errno.h>
  6. #include <fcntl.h>
  8. #ifdef unix
  9. # include <unistd.h>
  10. # include <utime.h>
  11. #else
  12. # include <direct.h>
  13. # include <io.h>
  14. #endif
  16. #include "unzip.h"
  18. #define CASESENSITIVITY (0)
  19. #define WRITEBUFFERSIZE (8192)
  21. /*
  22.   mini unzip, demo of unzip package
  24.   usage :
  25.   Usage : miniunz [-exvlo] file.zip [file_to_extract]
  27.   list the file in the zipfile, and print the content of FILE_ID.ZIP or README.TXT
  28.     if it exists
  29. */
  32. /* change_file_date : change the date/time of a file
  33.     filename : the filename of the file where date/time must be modified
  34.     dosdate : the new date at the MSDos format (4 bytes)
  35.     tmu_date : the SAME new date at the tm_unz format */
  36. void change_file_date(filename,dosdate,tmu_date)
  37. const char *filename;
  38. uLong dosdate;
  39. tm_unz tmu_date;
  40. {
  41. #ifdef WIN32
  42.   HANDLE hFile;
  43.   FILETIME ftm,ftLocal,ftCreate,ftLastAcc,ftLastWrite;
  45.   hFile = CreateFile(filename,GENERIC_READ | GENERIC_WRITE,
  46.                       0,NULL,OPEN_EXISTING,0,NULL);
  47.   GetFileTime(hFile,&ftCreate,&ftLastAcc,&ftLastWrite);
  48.   DosDateTimeToFileTime((WORD)(dosdate>>16),(WORD)dosdate,&ftLocal);
  49.   LocalFileTimeToFileTime(&ftLocal,&ftm);
  50.   SetFileTime(hFile,&ftm,&ftLastAcc,&ftm);
  51.   CloseHandle(hFile);
  52. #else
  53. #ifdef unix
  54.   struct utimbuf ut;
  55.   struct tm newdate;
  56.   newdate.tm_sec = tmu_date.tm_sec;
  57.   newdate.tm_min=tmu_date.tm_min;
  58.   newdate.tm_hour=tmu_date.tm_hour;
  59.   newdate.tm_mday=tmu_date.tm_mday;
  60.   newdate.tm_mon=tmu_date.tm_mon;
  61.   if (tmu_date.tm_year > 1900)
  62.       newdate.tm_year=tmu_date.tm_year - 1900;
  63.   else
  64.       newdate.tm_year=tmu_date.tm_year ;
  65.   newdate.tm_isdst=-1;
  67.   ut.actime=ut.modtime=mktime(&newdate);
  68.   utime(filename,&ut);
  69. #endif
  70. #endif
  71. }
  74. /* mymkdir and change_file_date are not 100 % portable
  75.    As I don't know well Unix, I wait feedback for the unix portion */
  77. int mymkdir(dirname)
  78. const char* dirname;
  79. {
  80.     int ret=0;
  81. #ifdef WIN32
  82. ret = mkdir(dirname);
  83. #else
  84. #ifdef unix
  85. ret = mkdir (dirname,0775);
  86. #endif
  87. #endif
  88. return ret;
  89. }
  91. int makedir (newdir)
  92.     char *newdir;
  93. {
  94.   char *buffer ;
  95.   char *p;
  96.   int  len = strlen(newdir);  
  98.   if (len <= 0) 
  99.     return 0;
  101.   buffer = (char*)malloc(len+1);
  102.   strcpy(buffer,newdir);
  103.   
  104.   if (buffer[len-1] == '/') {
  105.     buffer[len-1] = '';
  106.   }
  107.   if (mymkdir(buffer) == 0)
  108.     {
  109.       free(buffer);
  110.       return 1;
  111.     }
  113.   p = buffer+1;
  114.   while (1)
  115.     {
  116.       char hold;
  118.       while(*p && *p != '\' && *p != '/')
  119.         p++;
  120.       hold = *p;
  121.       *p = 0;
  122.       if ((mymkdir(buffer) == -1) && (errno == ENOENT))
  123.         {
  124.           printf("couldn't create directory %sn",buffer);
  125.           free(buffer);
  126.           return 0;
  127.         }
  128.       if (hold == 0)
  129.         break;
  130.       *p++ = hold;
  131.     }
  132.   free(buffer);
  133.   return 1;
  134. }
  136. void do_banner()
  137. {
  138. printf("MiniUnz 0.15, demo of zLib + Unz package written by Gilles Vollantn");
  139. printf("more info at http://wwww.winimage/zLibDll/unzip.htmnn");
  140. }
  142. void do_help()
  143. {
  144. printf("Usage : miniunz [-exvlo] file.zip [file_to_extract]nn") ;
  145. }
  148. int do_list(uf)
  149. unzFile uf;
  150. {
  151. uLong i;
  152. unz_global_info gi;
  153. int err;
  155. err = unzGetGlobalInfo (uf,&gi);
  156. if (err!=UNZ_OK)
  157. printf("error %d with zipfile in unzGetGlobalInfo n",err);
  158.     printf(" Length  Method   Size  Ratio   Date    Time   CRC-32     Namen");
  159.     printf(" ------  ------   ----  -----   ----    ----   ------     ----n");
  160. for (i=0;i<gi.number_entry;i++)
  161. {
  162. char filename_inzip[256];
  163. unz_file_info file_info;
  164. uLong ratio=0;
  165. const char *string_method;
  166. err = unzGetCurrentFileInfo(uf,&file_info,filename_inzip,sizeof(filename_inzip),NULL,0,NULL,0);
  167. if (err!=UNZ_OK)
  168. {
  169. printf("error %d with zipfile in unzGetCurrentFileInfon",err);
  170. break;
  171. }
  172. if (file_info.uncompressed_size>0)
  173. ratio = (file_info.compressed_size*100)/file_info.uncompressed_size;
  175. if (file_info.compression_method==0)
  176. string_method="Stored";
  177. else
  178. if (file_info.compression_method==Z_DEFLATED)
  179. {
  180. uInt iLevel=(uInt)((file_info.flag & 0x6)/2);
  181. if (iLevel==0)
  182.   string_method="Defl:N";
  183. else if (iLevel==1)
  184.   string_method="Defl:X";
  185. else if ((iLevel==2) || (iLevel==3))
  186.   string_method="Defl:F"; /* 2:fast , 3 : extra fast*/
  187. }
  188. else
  189. string_method="Unkn. ";
  191. printf("%7lu  %6s %7lu %3lu%%  %2.2lu-%2.2lu-%2.2lu  %2.2lu:%2.2lu  %8.8lx   %sn",
  192.     file_info.uncompressed_size,string_method,file_info.compressed_size,
  193. ratio,
  194. (uLong)file_info.tmu_date.tm_mon + 1,
  195.                 (uLong)file_info.tmu_date.tm_mday,
  196. (uLong)file_info.tmu_date.tm_year % 100,
  197. (uLong)file_info.tmu_date.tm_hour,(uLong)file_info.tmu_date.tm_min,
  198. (uLong)file_info.crc,filename_inzip);
  199. if ((i+1)<gi.number_entry)
  200. {
  201. err = unzGoToNextFile(uf);
  202. if (err!=UNZ_OK)
  203. {
  204. printf("error %d with zipfile in unzGoToNextFilen",err);
  205. break;
  206. }
  207. }
  208. }
  210. return 0;
  211. }
  214. int do_extract_currentfile(uf,popt_extract_without_path,popt_overwrite)
  215. unzFile uf;
  216. const int* popt_extract_without_path;
  217.     int* popt_overwrite;
  218. {
  219. char filename_inzip[256];
  220. char* filename_withoutpath;
  221. char* p;
  222.     int err=UNZ_OK;
  223.     FILE *fout=NULL;
  224.     void* buf;
  225.     uInt size_buf;
  227. unz_file_info file_info;
  228. uLong ratio=0;
  229. err = unzGetCurrentFileInfo(uf,&file_info,filename_inzip,sizeof(filename_inzip),NULL,0,NULL,0);
  231. if (err!=UNZ_OK)
  232. {
  233. printf("error %d with zipfile in unzGetCurrentFileInfon",err);
  234. return err;
  235. }
  237.     size_buf = WRITEBUFFERSIZE;
  238.     buf = (void*)malloc(size_buf);
  239.     if (buf==NULL)
  240.     {
  241.         printf("Error allocating memoryn");
  242.         return UNZ_INTERNALERROR;
  243.     }
  245. p = filename_withoutpath = filename_inzip;
  246. while ((*p) != '')
  247. {
  248. if (((*p)=='/') || ((*p)=='\'))
  249. filename_withoutpath = p+1;
  250. p++;
  251. }
  253. if ((*filename_withoutpath)=='')
  254. {
  255. if ((*popt_extract_without_path)==0)
  256. {
  257. printf("creating directory: %sn",filename_inzip);
  258. mymkdir(filename_inzip);
  259. }
  260. }
  261. else
  262. {
  263. const char* write_filename;
  264. int skip=0;
  266. if ((*popt_extract_without_path)==0)
  267. write_filename = filename_inzip;
  268. else
  269. write_filename = filename_withoutpath;
  271. err = unzOpenCurrentFile(uf);
  272. if (err!=UNZ_OK)
  273. {
  274. printf("error %d with zipfile in unzOpenCurrentFilen",err);
  275. }
  277. if (((*popt_overwrite)==0) && (err==UNZ_OK))
  278. {
  279. char rep;
  280. FILE* ftestexist;
  281. ftestexist = fopen(write_filename,"rb");
  282. if (ftestexist!=NULL)
  283. {
  284. fclose(ftestexist);
  285. do
  286. {
  287. char answer[128];
  288. printf("The file %s exist. Overwrite ? [y]es, [n]o, [A]ll: ",write_filename);
  289. scanf("%1s",answer);
  290. rep = answer[0] ;
  291. if ((rep>='a') && (rep<='z'))
  292. rep -= 0x20;
  293. }
  294. while ((rep!='Y') && (rep!='N') && (rep!='A'));
  295. }
  297. if (rep == 'N')
  298. skip = 1;
  300. if (rep == 'A')
  301. *popt_overwrite=1;
  302. }
  304. if ((skip==0) && (err==UNZ_OK))
  305. {
  306. fout=fopen(write_filename,"wb");
  308.             /* some zipfile don't contain directory alone before file */
  309.             if ((fout==NULL) && ((*popt_extract_without_path)==0) && 
  310.                                 (filename_withoutpath!=(char*)filename_inzip))
  311.             {
  312.                 char c=*(filename_withoutpath-1);
  313.                 *(filename_withoutpath-1)='';
  314.                 makedir(write_filename);
  315.                 *(filename_withoutpath-1)=c;
  316.                 fout=fopen(write_filename,"wb");
  317.             }
  319. if (fout==NULL)
  320. {
  321. printf("error opening %sn",write_filename);
  322. }
  323. }
  325. if (fout!=NULL)
  326. {
  327. printf(" extracting: %sn",write_filename);
  329. do
  330. {
  331. err = unzReadCurrentFile(uf,buf,size_buf);
  332. if (err<0)
  333. {
  334. printf("error %d with zipfile in unzReadCurrentFilen",err);
  335. break;
  336. }
  337. if (err>0)
  338. if (fwrite(buf,err,1,fout)!=1)
  339. {
  340. printf("error in writing extracted filen");
  341.                         err=UNZ_ERRNO;
  342. break;
  343. }
  344. }
  345. while (err>0);
  346. fclose(fout);
  347. if (err==0) 
  348. change_file_date(write_filename,file_info.dosDate,
  349.              file_info.tmu_date);
  350. }
  352.         if (err==UNZ_OK)
  353.         {
  354.     err = unzCloseCurrentFile (uf);
  355.     if (err!=UNZ_OK)
  356.     {
  357.     printf("error %d with zipfile in unzCloseCurrentFilen",err);
  358.     }
  359.         }
  360.         else
  361.             unzCloseCurrentFile(uf); /* don't lose the error */       
  362. }
  364.     free(buf);    
  365.     return err;
  366. }
  369. int do_extract(uf,opt_extract_without_path,opt_overwrite)
  370. unzFile uf;
  371. int opt_extract_without_path;
  372.     int opt_overwrite;
  373. {
  374. uLong i;
  375. unz_global_info gi;
  376. int err;
  377. FILE* fout=NULL;
  379. err = unzGetGlobalInfo (uf,&gi);
  380. if (err!=UNZ_OK)
  381. printf("error %d with zipfile in unzGetGlobalInfo n",err);
  383. for (i=0;i<gi.number_entry;i++)
  384. {
  385.         if (do_extract_currentfile(uf,&opt_extract_without_path,
  386.                                       &opt_overwrite) != UNZ_OK)
  387.             break;
  389. if ((i+1)<gi.number_entry)
  390. {
  391. err = unzGoToNextFile(uf);
  392. if (err!=UNZ_OK)
  393. {
  394. printf("error %d with zipfile in unzGoToNextFilen",err);
  395. break;
  396. }
  397. }
  398. }
  400. return 0;
  401. }
  403. int do_extract_onefile(uf,filename,opt_extract_without_path,opt_overwrite)
  404. unzFile uf;
  405. const char* filename;
  406. int opt_extract_without_path;
  407.     int opt_overwrite;
  408. {
  409.     int err = UNZ_OK;
  410.     if (unzLocateFile(uf,filename,CASESENSITIVITY)!=UNZ_OK)
  411.     {
  412.         printf("file %s not found in the zipfilen",filename);
  413.         return 2;
  414.     }
  416.     if (do_extract_currentfile(uf,&opt_extract_without_path,
  417.                                       &opt_overwrite) == UNZ_OK)
  418.         return 0;
  419.     else
  420.         return 1;
  421. }
  424. int main(argc,argv)
  425. int argc;
  426. char *argv[];
  427. {
  428. const char *zipfilename=NULL;
  429.     const char *filename_to_extract=NULL;
  430. int i;
  431. int opt_do_list=0;
  432. int opt_do_extract=1;
  433. int opt_do_extract_withoutpath=0;
  434. int opt_overwrite=0;
  435. char filename_try[512];
  436. unzFile uf=NULL;
  438. do_banner();
  439. if (argc==1)
  440. {
  441. do_help();
  442. exit(0);
  443. }
  444. else
  445. {
  446. for (i=1;i<argc;i++)
  447. {
  448. if ((*argv[i])=='-')
  449. {
  450. const char *p=argv[i]+1;
  452. while ((*p)!='')
  453. {
  454. char c=*(p++);;
  455. if ((c=='l') || (c=='L'))
  456. opt_do_list = 1;
  457. if ((c=='v') || (c=='V'))
  458. opt_do_list = 1;
  459. if ((c=='x') || (c=='X'))
  460. opt_do_extract = 1;
  461. if ((c=='e') || (c=='E'))
  462. opt_do_extract = opt_do_extract_withoutpath = 1;
  463. if ((c=='o') || (c=='O'))
  464. opt_overwrite=1;
  465. }
  466. }
  467. else
  468.             {
  469. if (zipfilename == NULL)
  470. zipfilename = argv[i];
  471.                 else if (filename_to_extract==NULL)
  472.                         filename_to_extract = argv[i] ;
  473.             }
  474. }
  475. }
  477. if (zipfilename!=NULL)
  478. {
  479. strcpy(filename_try,zipfilename);
  480. uf = unzOpen(zipfilename);
  481. if (uf==NULL)
  482. {
  483. strcat(filename_try,".zip");
  484. uf = unzOpen(filename_try);
  485. }
  486. }
  488. if (uf==NULL)
  489. {
  490. printf("Cannot open %s or %s.zipn",zipfilename,zipfilename);
  491. exit (1);
  492. }
  493.     printf("%s openedn",filename_try);
  495. if (opt_do_list==1)
  496. return do_list(uf);
  497. else if (opt_do_extract==1)
  498.     {
  499.         if (filename_to_extract == NULL)
  500.     return do_extract(uf,opt_do_extract_withoutpath,opt_overwrite);
  501.         else
  502.             return do_extract_onefile(uf,filename_to_extract,
  503.                                       opt_do_extract_withoutpath,opt_overwrite);
  504.     }
  505. unzCloseCurrentFile(uf);
  507. return 0;  /* to avoid warning */
  508. }