Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. /*
  2.    minizip.c
  3.    Version 1.01e, February 12th, 2005
  4.  
  5.    Copyright (C) 1998-2005 Gilles Vollant
  6. */
  7.  
  8. #include <stdio.h>
  9. #include <stdlib.h>
  10. #include <string.h>
  11. #include <time.h>
  12. #include <errno.h>
  13. #include <fcntl.h>
  14.  
  15. #ifdef unix
  16. # include <unistd.h>
  17. # include <utime.h>
  18. # include <sys/types.h>
  19. # include <sys/stat.h>
  20. #else
  21. # include <direct.h>
  22. # include <io.h>
  23. #endif
  24.  
  25. #include "zip.h"
  26.  
  27. #ifdef WIN32
  28. #define USEWIN32IOAPI
  29. #include "iowin32.h"
  30. #endif
  31.  
  32.  
  33.  
  34. #define WRITEBUFFERSIZE (16384)
  35. #define MAXFILENAME (256)
  36.  
  37. #ifdef WIN32
  38. uLong filetime(f, tmzip, dt)
  39.     char *f;                /* name of file to get info on */
  40.     tm_zip *tmzip;             /* return value: access, modific. and creation times */
  41.     uLong *dt;             /* dostime */
  42. {
  43.   int ret = 0;
  44.   {
  45.       FILETIME ftLocal;
  46.       HANDLE hFind;
  47.       WIN32_FIND_DATA  ff32;
  48.  
  49.       hFind = FindFirstFile(f,&ff32);
  50.       if (hFind != INVALID_HANDLE_VALUE)
  51.       {
  52.         FileTimeToLocalFileTime(&(ff32.ftLastWriteTime),&ftLocal);
  53.         FileTimeToDosDateTime(&ftLocal,((LPWORD)dt)+1,((LPWORD)dt)+0);
  54.         FindClose(hFind);
  55.         ret = 1;
  56.       }
  57.   }
  58.   return ret;
  59. }
  60. #else
  61. #ifdef unix
  62. uLong filetime(f, tmzip, dt)
  63.     char *f;               /* name of file to get info on */
  64.     tm_zip *tmzip;         /* return value: access, modific. and creation times */
  65.     uLong *dt;             /* dostime */
  66. {
  67.   int ret=0;
  68.   struct stat s;        /* results of stat() */
  69.   struct tm* filedate;
  70.   time_t tm_t=0;
  71.  
  72.   if (strcmp(f,"-")!=0)
  73.   {
  74.     char name[MAXFILENAME+1];
  75.     int len = strlen(f);
  76.     if (len > MAXFILENAME)
  77.       len = MAXFILENAME;
  78.  
  79.     strncpy(name, f,MAXFILENAME-1);
  80.     /* strncpy doesnt append the trailing NULL, of the string is too long. */
  81.     name[ MAXFILENAME ] = '\0';
  82.  
  83.     if (name[len - 1] == '/')
  84.       name[len - 1] = '\0';
  85.     /* not all systems allow stat'ing a file with / appended */
  86.     if (stat(name,&s)==0)
  87.     {
  88.       tm_t = s.st_mtime;
  89.       ret = 1;
  90.     }
  91.   }
  92.   filedate = localtime(&tm_t);
  93.  
  94.   tmzip->tm_sec  = filedate->tm_sec;
  95.   tmzip->tm_min  = filedate->tm_min;
  96.   tmzip->tm_hour = filedate->tm_hour;
  97.   tmzip->tm_mday = filedate->tm_mday;
  98.   tmzip->tm_mon  = filedate->tm_mon ;
  99.   tmzip->tm_year = filedate->tm_year;
  100.  
  101.   return ret;
  102. }
  103. #else
  104. uLong filetime(f, tmzip, dt)
  105.     char *f;                /* name of file to get info on */
  106.     tm_zip *tmzip;             /* return value: access, modific. and creation times */
  107.     uLong *dt;             /* dostime */
  108. {
  109.     return 0;
  110. }
  111. #endif
  112. #endif
  113.  
  114.  
  115.  
  116.  
  117. int check_exist_file(filename)
  118.     const char* filename;
  119. {
  120.     FILE* ftestexist;
  121.     int ret = 1;
  122.     ftestexist = fopen(filename,"rb");
  123.     if (ftestexist==NULL)
  124.         ret = 0;
  125.     else
  126.         fclose(ftestexist);
  127.     return ret;
  128. }
  129.  
  130. void do_banner()
  131. {
  132.     printf("MiniZip 1.01b, demo of zLib + Zip package written by Gilles Vollant\n");
  133.     printf("more info at http://www.winimage.com/zLibDll/unzip.html\n\n");
  134. }
  135.  
  136. void do_help()
  137. {
  138.     printf("Usage : minizip [-o] [-a] [-0 to -9] [-p password] file.zip [files_to_add]\n\n" \
  139.            "  -o  Overwrite existing file.zip\n" \
  140.            "  -a  Append to existing file.zip\n" \
  141.            "  -0  Store only\n" \
  142.            "  -1  Compress faster\n" \
  143.            "  -9  Compress better\n\n");
  144. }
  145.  
  146. /* calculate the CRC32 of a file,
  147.    because to encrypt a file, we need known the CRC32 of the file before */
  148. int getFileCrc(const char* filenameinzip,void*buf,unsigned long size_buf,unsigned long* result_crc)
  149. {
  150.    unsigned long calculate_crc=0;
  151.    int err=ZIP_OK;
  152.    FILE * fin = fopen(filenameinzip,"rb");
  153.    unsigned long size_read = 0;
  154.    unsigned long total_read = 0;
  155.    if (fin==NULL)
  156.    {
  157.        err = ZIP_ERRNO;
  158.    }
  159.  
  160.     if (err == ZIP_OK)
  161.         do
  162.         {
  163.             err = ZIP_OK;
  164.             size_read = (int)fread(buf,1,size_buf,fin);
  165.             if (size_read < size_buf)
  166.                 if (feof(fin)==0)
  167.             {
  168.                 printf("error in reading %s\n",filenameinzip);
  169.                 err = ZIP_ERRNO;
  170.             }
  171.  
  172.             if (size_read>0)
  173.                 calculate_crc = crc32(calculate_crc,buf,size_read);
  174.             total_read += size_read;
  175.  
  176.         } while ((err == ZIP_OK) && (size_read>0));
  177.  
  178.     if (fin)
  179.         fclose(fin);
  180.  
  181.     *result_crc=calculate_crc;
  182.     printf("file %s crc %x\n",filenameinzip,calculate_crc);
  183.     return err;
  184. }
  185.  
  186. int main(argc,argv)
  187.     int argc;
  188.     char *argv[];
  189. {
  190.     int i;
  191.     int opt_overwrite=0;
  192.     int opt_compress_level=Z_DEFAULT_COMPRESSION;
  193.     int zipfilenamearg = 0;
  194.     char filename_try[MAXFILENAME+16];
  195.     int zipok;
  196.     int err=0;
  197.     int size_buf=0;
  198.     void* buf=NULL;
  199.     const char* password=NULL;
  200.  
  201.  
  202.     do_banner();
  203.     if (argc==1)
  204.     {
  205.         do_help();
  206.         return 0;
  207.     }
  208.     else
  209.     {
  210.         for (i=1;i<argc;i++)
  211.         {
  212.             if ((*argv[i])=='-')
  213.             {
  214.                 const char *p=argv[i]+1;
  215.  
  216.                 while ((*p)!='\0')
  217.                 {
  218.                     char c=*(p++);;
  219.                     if ((c=='o') || (c=='O'))
  220.                         opt_overwrite = 1;
  221.                     if ((c=='a') || (c=='A'))
  222.                         opt_overwrite = 2;
  223.                     if ((c>='0') && (c<='9'))
  224.                         opt_compress_level = c-'0';
  225.  
  226.                     if (((c=='p') || (c=='P')) && (i+1<argc))
  227.                     {
  228.                         password=argv[i+1];
  229.                         i++;
  230.                     }
  231.                 }
  232.             }
  233.             else
  234.                 if (zipfilenamearg == 0)
  235.                     zipfilenamearg = i ;
  236.         }
  237.     }
  238.  
  239.     size_buf = WRITEBUFFERSIZE;
  240.     buf = (void*)malloc(size_buf);
  241.     if (buf==NULL)
  242.     {
  243.         printf("Error allocating memory\n");
  244.         return ZIP_INTERNALERROR;
  245.     }
  246.  
  247.     if (zipfilenamearg==0)
  248.         zipok=0;
  249.     else
  250.     {
  251.         int i,len;
  252.         int dot_found=0;
  253.  
  254.         zipok = 1 ;
  255.         strncpy(filename_try, argv[zipfilenamearg],MAXFILENAME-1);
  256.         /* strncpy doesnt append the trailing NULL, of the string is too long. */
  257.         filename_try[ MAXFILENAME ] = '\0';
  258.  
  259.         len=(int)strlen(filename_try);
  260.         for (i=0;i<len;i++)
  261.             if (filename_try[i]=='.')
  262.                 dot_found=1;
  263.  
  264.         if (dot_found==0)
  265.             strcat(filename_try,".zip");
  266.  
  267.         if (opt_overwrite==2)
  268.         {
  269.             /* if the file don't exist, we not append file */
  270.             if (check_exist_file(filename_try)==0)
  271.                 opt_overwrite=1;
  272.         }
  273.         else
  274.         if (opt_overwrite==0)
  275.             if (check_exist_file(filename_try)!=0)
  276.             {
  277.                 char rep=0;
  278.                 do
  279.                 {
  280.                     char answer[128];
  281.                     int ret;
  282.                     printf("The file %s exists. Overwrite ? [y]es, [n]o, [a]ppend : ",filename_try);
  283.                     ret = scanf("%1s",answer);
  284.                     if (ret != 1)
  285.                     {
  286.                        exit(EXIT_FAILURE);
  287.                     }
  288.                     rep = answer[0] ;
  289.                     if ((rep>='a') && (rep<='z'))
  290.                         rep -= 0x20;
  291.                 }
  292.                 while ((rep!='Y') && (rep!='N') && (rep!='A'));
  293.                 if (rep=='N')
  294.                     zipok = 0;
  295.                 if (rep=='A')
  296.                     opt_overwrite = 2;
  297.             }
  298.     }
  299.  
  300.     if (zipok==1)
  301.     {
  302.         zipFile zf;
  303.         int errclose;
  304. #        ifdef USEWIN32IOAPI
  305.         zlib_filefunc_def ffunc;
  306.         fill_win32_filefunc(&ffunc);
  307.         zf = zipOpen2(filename_try,(opt_overwrite==2) ? 2 : 0,NULL,&ffunc);
  308. #        else
  309.         zf = zipOpen(filename_try,(opt_overwrite==2) ? 2 : 0);
  310. #        endif
  311.  
  312.         if (zf == NULL)
  313.         {
  314.             printf("error opening %s\n",filename_try);
  315.             err= ZIP_ERRNO;
  316.         }
  317.         else
  318.             printf("creating %s\n",filename_try);
  319.  
  320.         for (i=zipfilenamearg+1;(i<argc) && (err==ZIP_OK);i++)
  321.         {
  322.             if (!((((*(argv[i]))=='-') || ((*(argv[i]))=='/')) &&
  323.                   ((argv[i][1]=='o') || (argv[i][1]=='O') ||
  324.                    (argv[i][1]=='a') || (argv[i][1]=='A') ||
  325.                    (argv[i][1]=='p') || (argv[i][1]=='P') ||
  326.                    ((argv[i][1]>='0') || (argv[i][1]<='9'))) &&
  327.                   (strlen(argv[i]) == 2)))
  328.             {
  329.                 FILE * fin;
  330.                 int size_read;
  331.                 const char* filenameinzip = argv[i];
  332.                 zip_fileinfo zi;
  333.                 unsigned long crcFile=0;
  334.  
  335.                 zi.tmz_date.tm_sec = zi.tmz_date.tm_min = zi.tmz_date.tm_hour =
  336.                 zi.tmz_date.tm_mday = zi.tmz_date.tm_mon = zi.tmz_date.tm_year = 0;
  337.                 zi.dosDate = 0;
  338.                 zi.internal_fa = 0;
  339.                 zi.external_fa = 0;
  340.                 filetime(filenameinzip,&zi.tmz_date,&zi.dosDate);
  341.  
  342. /*
  343.                 err = zipOpenNewFileInZip(zf,filenameinzip,&zi,
  344.                                  NULL,0,NULL,0,NULL / * comment * /,
  345.                                  (opt_compress_level != 0) ? Z_DEFLATED : 0,
  346.                                  opt_compress_level);
  347. */
  348.                 if ((password != NULL) && (err==ZIP_OK))
  349.                     err = getFileCrc(filenameinzip,buf,size_buf,&crcFile);
  350.  
  351.                 err = zipOpenNewFileInZip3(zf,filenameinzip,&zi,
  352.                                  NULL,0,NULL,0,NULL /* comment*/,
  353.                                  (opt_compress_level != 0) ? Z_DEFLATED : 0,
  354.                                  opt_compress_level,0,
  355.                                  /* -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, */
  356.                                  -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
  357.                                  password,crcFile);
  358.  
  359.                 if (err != ZIP_OK)
  360.                     printf("error in opening %s in zipfile\n",filenameinzip);
  361.                 else
  362.                 {
  363.                     fin = fopen(filenameinzip,"rb");
  364.                     if (fin==NULL)
  365.                     {
  366.                         err=ZIP_ERRNO;
  367.                         printf("error in opening %s for reading\n",filenameinzip);
  368.                     }
  369.                 }
  370.  
  371.                 if (err == ZIP_OK)
  372.                     do
  373.                     {
  374.                         err = ZIP_OK;
  375.                         size_read = (int)fread(buf,1,size_buf,fin);
  376.                         if (size_read < size_buf)
  377.                             if (feof(fin)==0)
  378.                         {
  379.                             printf("error in reading %s\n",filenameinzip);
  380.                             err = ZIP_ERRNO;
  381.                         }
  382.  
  383.                         if (size_read>0)
  384.                         {
  385.                             err = zipWriteInFileInZip (zf,buf,size_read);
  386.                             if (err<0)
  387.                             {
  388.                                 printf("error in writing %s in the zipfile\n",
  389.                                                  filenameinzip);
  390.                             }
  391.  
  392.                         }
  393.                     } while ((err == ZIP_OK) && (size_read>0));
  394.  
  395.                 if (fin)
  396.                     fclose(fin);
  397.  
  398.                 if (err<0)
  399.                     err=ZIP_ERRNO;
  400.                 else
  401.                 {
  402.                     err = zipCloseFileInZip(zf);
  403.                     if (err!=ZIP_OK)
  404.                         printf("error in closing %s in the zipfile\n",
  405.                                     filenameinzip);
  406.                 }
  407.             }
  408.         }
  409.         errclose = zipClose(zf,NULL);
  410.         if (errclose != ZIP_OK)
  411.             printf("error in closing %s\n",filename_try);
  412.     }
  413.     else
  414.     {
  415.        do_help();
  416.     }
  417.  
  418.     free(buf);
  419.     return 0;
  420. }
  421.