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

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

压缩解压

开发平台：

Visual C++

makezip.c：源码内容
  1. /*
  2.  Copyright (C) 1996 Mike White
  3.  Permission is granted to any individual or institution to use, copy, or
  4.  redistribute this software so long as all of the original files are included,
  5.  that it is not sold for profit, and that this copyright notice is retained.
  7. */
  9. #ifdef __BORLANDC__
  10. #include <dir.h>
  11. #endif
  12. #include <direct.h>
  13. #include <string.h>
  14. #include <io.h>
  15. #include <stdio.h>
  16. #include <ctype.h>
  17. #include <dos.h>
  18. #include <fcntl.h>
  19. #include <io.h>
  20. #include "wiz.h"
  21. #include "helpids.h"
  23. #ifndef WIN32
  24. #include <lzexpand.h>
  25. #endif
  27. /* Define size of read/write buffer for copying files */
  28. #define READ_WRITE_BUF 4096
  30. extern char **pszIndex;
  31. extern char *sz;
  32. extern LPSTR szFileList;
  33. extern HANDLE hFileList;
  34. extern int ZipRetCode;
  35. BOOL fMakeDosSFX;
  36. BOOL fMakeSFX;
  37. char szTempFileName[PATH_MAX];
  38. char szTargetName[PATH_MAX];
  40. static char szTargetFileName[PATH_MAX] = "";
  41. char __based(__segname("STRINGS_TEXT")) szTargetZipDir[PATH_MAX];
  42. char __based(__segname("STRINGS_TEXT")) szTargetZipFile[PATH_MAX] = "";
  43. char __based(__segname("STRINGS_TEXT")) szCantMakeZip[] =
  44.    "Internal error: Cannot make zip file. Common dialog error code is 0x%lX.";
  46. void MakeArchive(HWND hWnd)
  47. {
  48. char tempFileName[PATH_MAX], tempPath[PATH_MAX];
  50. /* temporary zip options flags */
  51. BOOL fVerbose,fForce,fSystem,fVolume,fNoDirEntries,fJunkDir,fCRLF_LF,
  52.      fLF_CRLF,fEncrypt,fRecurse,fMove,fLatestTime,fUpdate,fFreshen,
  53.      fQuiet,fComment,fmakesfx,fOffsets, fExtra;
  54. #ifdef WIN32
  55. BOOL fPrivilege, fdossfx;
  56. #endif
  57. char fLevel;
  58. int fRepair;
  60. #ifndef WIN32
  61.    FARPROC lpfnGetFilesProc;
  62. #endif
  63. /* Save zip options flags */
  64. fRepair       = ZpOpt.fRepair;
  65. #ifdef WIN32
  66. fPrivilege    = ZpOpt.fPrivilege;
  67. #endif
  68. fExtra        = ZpOpt.fExtra;
  69. fVerbose      = ZpOpt.fVerbose;
  70. fForce        = ZpOpt.fForce;
  71. fSystem       = ZpOpt.fSystem;
  72. fVolume       = ZpOpt.fVolume;
  73. fNoDirEntries = ZpOpt.fNoDirEntries;
  74. fJunkDir      = ZpOpt.fJunkDir;
  75. fCRLF_LF      = ZpOpt.fCRLF_LF;
  76. fLF_CRLF      = ZpOpt.fLF_CRLF;
  77. fEncrypt      = ZpOpt.fEncrypt;
  78. fRecurse      = ZpOpt.fRecurse;
  79. fMove         = ZpOpt.fMove;
  80. fLatestTime   = ZpOpt.fLatestTime;
  81. fUpdate       = ZpOpt.fUpdate;
  82. fFreshen      = ZpOpt.fFreshen;
  83. fQuiet        = ZpOpt.fQuiet;
  84. fComment      = ZpOpt.fComment;
  85. fLevel        = ZpOpt.fLevel;
  86. fmakesfx      = fMakeSFX;
  87. fOffsets      = ZpOpt.fOffsets;
  89. #ifdef WIN32
  90. fdossfx       = fMakeDosSFX;
  91. #endif
  93. #ifndef WIN32
  94. _fmemset(&lpumb->ofn, '', sizeof(OPENFILENAME)); /* initialize struct */
  95. #else
  96. memset(&lpumb->ofn, '', sizeof(OPENFILENAME)); /* initialize struct */
  97. #endif
  98. WinAssert(hWnd);
  100. lpumb->szUnzipToDirNameTmp[0] = '';
  102. lpumb->ofn.lStructSize = sizeof(OPENFILENAME);
  103. lpumb->ofn.hwndOwner = hWnd;
  104. lpumb->ofn.hInstance = hInst;
  105. lpumb->ofn.lpstrFilter = "Zip Files (*.zip)*.zipSelf-extracting Files (*.exe)*.exeAll Files (*.*)*.*";
  106. lpumb->ofn.nFilterIndex = 1;
  107. lpumb->ofn.lpstrFile = lpumb->szUnzipToDirNameTmp; /* result goes here! */
  108. lpumb->ofn.nMaxFile = PATH_MAX;
  109. lpumb->ofn.lpstrFileTitle = NULL; /* NULL causes nMaxFileTitle to be ignored */
  110. lpumb->ofn.nMaxFileTitle = PATH_MAX; /* ignored ! */
  111. lpumb->ofn.lpstrTitle = (LPSTR)"Archive Name";
  112. lpumb->ofn.lpstrInitialDir =
  113.    (LPSTR)(!szTargetZipDir[0] ? NULL : szTargetZipDir);
  114. lpumb->ofn.Flags = OFN_SHOWHELP | OFN_HIDEREADONLY;
  115. uf.fTrailingSlash = FALSE; /* set trailing slash to FALSE */
  116. lpumb->szZipFileName[0] = '';
  118. dwCommDlgHelpId = HELPID_ZIP_GET_ARCHIVE_NAME;
  120. if (GetOpenFileName(&lpumb->ofn)) /* successfully got archive name ? */
  121.    {
  122.    if (lstrcmpi(lpumb->szUnzipToDirNameTmp, lpumb->szZipFileName)!=0)
  123.       {
  124.       lstrcpy(tempPath, lpumb->szUnzipToDirNameTmp);
  125.       if (!uf.fTrailingSlash) /* Do we have a trailing slash? */
  126.          { /* No - strip file name off and save it */
  127.          StripDirectory(tempPath);
  128.          lstrcpy(tempFileName, tempPath);
  129.          /* Strip file name off, we've just saved it */
  130.          GetDirectory(lpumb->szUnzipToDirNameTmp);
  131.          }
  132.       uf.fTrailingSlash = FALSE;
  133.       /* Okay, make the directory, if necessary */
  134.       lstrcpy(szTargetZipDir, lpumb->szUnzipToDirNameTmp);
  135.       if (MakeDirectory(lpumb->szUnzipToDirNameTmp, FALSE))
  136.          {
  137.          if (lpumb->szUnzipToDirNameTmp[0] != '')
  138.             lstrcat(lpumb->szUnzipToDirNameTmp, "\");
  139.          lstrcat(lpumb->szUnzipToDirNameTmp, tempFileName);
  140.          /* lpumb->szUnzipToDirNameTmp now contains the fully qualified
  141.             zip file name.
  142.          */
  143.          if (strrchr(lpumb->szUnzipToDirNameTmp, '.') == NULL)
  144.             {
  145.             if (!fMakeSFX)
  146.                lstrcat(lpumb->szUnzipToDirNameTmp, ".zip");
  147.             else
  148.                lstrcat(lpumb->szUnzipToDirNameTmp, ".exe");
  149.             }
  150.          lstrcpy(szTargetFileName, lpumb->szUnzipToDirNameTmp);
  151.          lstrcpy(lpumb->szZipFileName, lpumb->szUnzipToDirNameTmp);
  152.          ZpZCL.lpszZipFN = szTargetFileName;
  154.          }
  156.       if (fSaveZipToDir)
  157.          {
  158.          getcwd(szTargetZipDir, PATH_MAX);
  159.          WriteZipOptionsProfile();
  160.          }
  162.    /* NOTE: Here is where we must actually call to get the files
  163.       to go into the archive. All we've done so far is get the
  164.       archive name.
  165.    */
  166.       {
  167.       dwCommDlgHelpId = HELPID_ZIP_SELECT_FILES;
  168. #ifndef WIN32
  169.       _fmemset(&lpumb->ofn, '', sizeof(OPENFILENAME)); /* initialize struct */
  170. #else
  171.       memset(&lpumb->ofn, '', sizeof(OPENFILENAME)); /* initialize struct */
  172. #endif
  173.       WinAssert(hWnd);
  174.       szTargetZipFile[0] = '';
  175.       lpumb->ofn.lStructSize = sizeof(OPENFILENAME);
  176.       lpumb->ofn.hwndOwner = hWnd;
  177.       lpumb->ofn.hInstance = hInst;
  178.       lpumb->ofn.lpstrFilter = "All Files (*.*)*.*";
  179.       lpumb->ofn.nFilterIndex = 1;
  181.       lpumb->ofn.lpstrFile = szTargetZipFile;
  182.       lpumb->ofn.nMaxFile = PATH_MAX;
  183.       lpumb->ofn.lpstrFileTitle = NULL;
  184.       lpumb->ofn.nMaxFileTitle = PATH_MAX; /* ignored ! */
  186.       wsprintf(lpumb->szBuffer, "Archive %s", lpumb->szZipFileName);
  188.       lpumb->ofn.lpstrTitle = (LPSTR) lpumb->szBuffer;
  189.       lpumb->ofn.lpstrInitialDir =
  190.          (LPSTR)(!szTargetZipDir[0] ? NULL : szTargetZipDir);
  191.       lpumb->ofn.Flags = OFN_SHOWHELP | OFN_ENABLEHOOK | OFN_CREATEPROMPT |
  192.          OFN_HIDEREADONLY|OFN_ENABLETEMPLATE;
  193. #ifndef WIN32
  194.       lpfnGetFilesProc = MakeProcInstance((FARPROC)GetFilesProc, hInst);
  195. #   ifndef MSC
  196.       (UINT CALLBACK *)lpumb->ofn.lpfnHook = (UINT CALLBACK *)lpfnGetFilesProc;
  197. #   else
  198.       lpumb->ofn.lpfnHook = lpfnGetFilesProc;
  199. #   endif
  200. #else
  201.       lpumb->ofn.lpfnHook = (LPOFNHOOKPROC)GetFilesProc;
  202. #endif
  203.       lpumb->ofn.lpTemplateName = "GETFILES";   /* see getfiles.dlg   */
  204.       if (GetOpenFileName(&lpumb->ofn) && (hFileList &&
  205.              (ZpZCL.lpszZipFN[0] != '')) ||
  206.              (ZpOpt.fRepair && (ZpZCL.lpszZipFN[0] != '')))
  207.          {
  208.          char *ptr;
  210.          UpdateWindow(hWndMain);
  212.          if (fMakeSFX)
  213.             {
  214.             ptr = strrchr(lpumb->szZipFileName, '.') + 1;
  215.             *ptr = '';
  216.             lstrcat(lpumb->szZipFileName, "exe");
  217.             lstrcpy(ZpZCL.lpszZipFN, lpumb->szZipFileName);
  218.             }
  220.          ZpZCL.FNV = (char **)szFileList;
  221.          if (!ZpOpt.fRepair)
  222.             BufferOut( "Creating/Updating Archive: %sn",
  223.                lpumb->szZipFileName);
  224.          else
  225.             if (ZpZCL.argc != 0)
  226.                BufferOut( "Repairing/Updating Archive: %sn",
  227.                   lpumb->szZipFileName);
  228.             else
  229.                BufferOut( "Repairing Archive: %sn",
  230.                   lpumb->szZipFileName);
  231.          hSaveCursor = SetCursor(hHourGlass);
  232.          ShowCursor(TRUE);
  233.          if (fMakeSFX)
  234.             {
  235.             OFSTRUCT ofStrSrc;
  236.             OFSTRUCT ofStrDest;
  237.             HFILE hfSrcFile, hfDstFile;
  238. #ifndef WIN32
  239.             struct find_t ffblk;
  240. #else
  241.             WIN32_FIND_DATA ffblk;
  242.             HANDLE hfile;
  243. #endif
  245.             ZpOpt.fOffsets = TRUE; /* Force adjusting of offsets */
  246.             /* Get the path we are executing from */
  247.             GetModuleFileName(hInst, szTargetName,
  248.                   sizeof(szTargetName));
  249.             ptr = strrchr(szTargetName, '\') + 1;
  250.             *ptr = ''; /* We've now got the path we are executing from */
  251. #ifdef WIN32
  252.             if (fMakeDosSFX)
  253.                lstrcat(szTargetName, "sfx16.dat");
  254.             else
  255.                lstrcat(szTargetName, "sfx32.dat");
  256. #else
  257.             lstrcat(szTargetName, "sfx16.dat");
  258. #endif
  259. #ifndef WIN32
  260.             if (_dos_findfirst(ZpZCL.lpszZipFN,
  261.                 _A_NORMAL|_A_RDONLY|_A_ARCH,&ffblk) != 0)
  262. #else
  263.             if ((hfile = FindFirstFile(ZpZCL.lpszZipFN, &ffblk)) == INVALID_HANDLE_VALUE)
  264. #endif
  265.                {
  266.                hfSrcFile = LZOpenFile(szTargetName,
  267.                   &ofStrSrc, OF_READ);
  268.                if (hfSrcFile < 0)
  269.                   {
  270. #ifdef WIN32
  271.                   if (fMakeDosSFX)
  272.                      MessageBox (hWnd, "Can't find SFX16.DAT, continuing without making SFX exe.",
  273.                         "Can't find SFX16.DAT", MB_ICONINFORMATION | MB_OK);
  274.                   else
  275.                      MessageBox (hWnd, "Can't find SFX32.DAT, continuing without making SFX exe.",
  276.                         "Can't find SFX32.DAT", MB_ICONINFORMATION | MB_OK);
  277. #else
  278.                   MessageBox (hWnd, "Can't find SFX16.D1, continuing without making SFX exe.",
  279.                      "Can't find SFX16.DAT", MB_ICONINFORMATION | MB_OK);
  280. #endif
  281.                   }
  282.                else
  283.                   {
  284.                   hfDstFile = LZOpenFile(ZpZCL.lpszZipFN,
  285.                      &ofStrDest, OF_CREATE);
  287.                   LZCopy(hfSrcFile, hfDstFile);
  289.                   LZClose(hfSrcFile);
  290.                   LZClose(hfDstFile);
  291.                   }
  292.                }
  293.             else
  294.                {
  295.                int in, out;
  296. #ifdef WIN32
  297.                FindClose(hfile);
  298. #endif
  299.                /* Copy the prefix file over to the temp file */
  300.                hfSrcFile = LZOpenFile(szTargetName,
  301.                   &ofStrSrc, OF_READ);
  302.                if (hfSrcFile < 0)
  303.                   {
  304. #ifdef WIN32
  305.                   if (fMakeDosSFX)
  306.                      MessageBox (hWnd, "Can't find SFX16.DAT, continuing without making SFX exe.",
  307.                         "Can't find SFX16.DAT", MB_ICONINFORMATION | MB_OK);
  308.                   else
  309.                      MessageBox (hWnd, "Can't find SFX32.DAT, continuing without making SFX exe.",
  310.                         "Can't find SFX32.DAT", MB_ICONINFORMATION | MB_OK);
  311. #else
  312.                   MessageBox (hWnd, "Can't find SFX16.DAT, continuing without making SFX exe.",
  313.                      "Can't find SFX16.DAT", MB_ICONINFORMATION | MB_OK);
  314. #endif
  315.                   }
  316.                else
  317.                   {
  318.                   char buf[READ_WRITE_BUF];
  319.                   /* Get a temp file name and directory (Goes in directory
  320.                    * designated by tmp, temp or the current directory)
  321.                    */
  322. #ifdef WIN32
  323.                   GetTempPath(sizeof(szTargetName), szTargetName);
  324.                   GetTempFileName(szTargetName, "WIZ", 0, szTempFileName);
  325. #else
  326.                   GetTempFileName(0, "WIZ", 0, szTempFileName);
  327. #endif
  328.                   hfDstFile = LZOpenFile(szTempFileName,
  329.                      &ofStrDest, OF_CREATE);
  331.                   LZCopy(hfSrcFile, hfDstFile);
  333.                   LZClose(hfSrcFile);
  334.                   LZClose(hfDstFile);
  335.                   /* We've got the prefix moved over, now append the
  336.                    * archive file itself.
  337.                    */
  338.                   out = open(szTempFileName, O_RDWR | O_APPEND | O_BINARY );
  339.                   in = open(ZpZCL.lpszZipFN, O_RDONLY | O_BINARY);
  341.                   lseek(out, SEEK_CUR, SEEK_END);
  342.                   while (read(in, buf, READ_WRITE_BUF) > 0)
  343.                      {
  344.                      write(out, buf, READ_WRITE_BUF);
  345.                      }
  347.                   close(in);
  348.                   close(out);
  350.                   /* Copy the temp file back over the original file */
  351.                   hfSrcFile = LZOpenFile(szTempFileName,
  352.                      &ofStrSrc, OF_READ);
  353.                   if (hfSrcFile < 0)
  354.                      {
  355.                      MessageBox (hWnd, "Can't find temp file, continuing without making SFX exe.",
  356.                         "Can't find temp file", MB_ICONINFORMATION | MB_OK);
  357.                      }
  358.                   else
  359.                      {
  360.                      hfDstFile = LZOpenFile(ZpZCL.lpszZipFN,
  361.                         &ofStrDest, OF_CREATE);
  363.                      LZCopy(hfSrcFile, hfDstFile);
  364.                      LZClose(hfSrcFile);
  365.                      LZClose(hfDstFile);
  366.                      remove(szTempFileName);
  367.                      lstrcpy(szTempFileName, ZpZCL.lpszZipFN);
  368.                      if (lstrcmpi(&szTempFileName[lstrlen(ZpZCL.lpszZipFN) - 4],
  369.                         ".exe") != 0)
  370.                         {
  371.                         lstrcpy(&ZpZCL.lpszZipFN[lstrlen(ZpZCL.lpszZipFN) - 4],
  372.                            ".exe");
  373.                         rename(szTempFileName, ZpZCL.lpszZipFN);
  374.                         }
  375.                      }
  376.                   }
  377.                }
  378.             }
  379.          ZipSetOptions(ZpOpt);
  380.          ZipRetCode = ZipArchive(ZpZCL);
  381.          ShowCursor(FALSE);
  382.          SetCursor(hSaveCursor);
  383.          }
  384.       }
  386.       if ((toupper(lpumb->ofn.lpstrFile[0]) != 'A') &&
  387.           (toupper(lpumb->ofn.lpstrFile[0]) != 'B'))
  388.           {
  389.           lstrcpy(szTargetZipFile, lpumb->ofn.lpstrFile);
  390.           if ((lpchLast = lstrrchr(szTargetZipFile, '\'))!=0)
  391.              {
  392.              *lpchLast = '';
  393.              }
  394.            else if ((lpchLast = lstrrchr(szTargetZipFile, ':'))!=0)
  395.              {
  396.              *(lpchLast+1) = '';
  397.              lstrcat(szTargetZipFile, "\");
  398.              }
  399.            }
  400.         }
  401.       }
  402. else /* either real error or canceled */
  403.    {
  404.    DWORD dwExtdError = CommDlgExtendedError(); /* debugging */
  406.    if (dwExtdError != 0L) /* if not canceled then real error */
  407.       {
  408.       wsprintf (lpumb->szBuffer, szCantMakeZip, dwExtdError);
  409.       MessageBox (hWnd, lpumb->szBuffer, szAppName, MB_ICONINFORMATION | MB_OK);
  410.       }
  411.    else
  412.       {
  413.       RECT mRect;
  415.       WinAssert(hWndMain);
  416.       GetWindowRect(hWndMain, &mRect);
  417.       InvalidateRect(hWndMain, &mRect, TRUE);
  418.       SendMessage(hWndMain, WM_SIZE, SIZE_RESTORED,
  419.          MAKELONG(mRect.right-mRect.left, mRect.top-mRect.bottom));
  420.       UpdateWindow(hWndMain);
  421.       }
  422.    }
  423. /* Restore zip options flags */
  424. #ifdef WIN32
  425. ZpOpt.fPrivilege    = fPrivilege;
  426. #endif
  427. ZpOpt.fExtra        = fExtra;
  428. ZpOpt.fRepair       = fRepair;
  429. ZpOpt.fVerbose      = fVerbose;
  430. ZpOpt.fForce        = fForce;
  431. ZpOpt.fSystem       = fSystem;
  432. ZpOpt.fVolume       = fVolume;
  433. ZpOpt.fNoDirEntries = fNoDirEntries;
  434. ZpOpt.fJunkDir      = fJunkDir;
  435. ZpOpt.fCRLF_LF      = fCRLF_LF;
  436. ZpOpt.fLF_CRLF      = fLF_CRLF;
  437. ZpOpt.fEncrypt      = fEncrypt;
  438. ZpOpt.fRecurse      = fRecurse;
  439. ZpOpt.fMove         = fMove;
  440. ZpOpt.fLatestTime   = fLatestTime;
  441. ZpOpt.fUpdate       = fUpdate;
  442. ZpOpt.fFreshen      = fFreshen;
  443. ZpOpt.fComment      = fComment;
  444. ZpOpt.fQuiet        = fQuiet;
  445. ZpOpt.fLevel        = fLevel;
  446. fMakeSFX              = fmakesfx;
  447. ZpOpt.fOffsets      = fOffsets;
  449. #ifdef WIN32
  450. fMakeDosSFX           = fdossfx;
  451. #endif
  453. if (hFileList)
  454.    {
  455.    GlobalUnlock(hFileList);
  456.    GlobalFree(hFileList);
  457.    }
  458. }