CZipCreatorImpl Struct Reference

Collaboration diagram for CZipCreatorImpl:

Public Member Functions
unsigned	JustDoIt ()

Public Attributes
CSimpleArray< CStringW >	m_items
CStringW	m_ExistingZip
CStringW	m_TargetDir

Detailed Description

Definition at line 128 of file CZipCreator.cpp.

Member Function Documentation

JustDoIt()

unsigned CZipCreatorImpl::JustDoIt

(

)

Definition at line 209 of file CZipCreator.cpp.

{
    // TODO: Show progress.
 
    CStringW strZipName;
    INT appendMode;
    if (m_ExistingZip.IsEmpty())
    {
        strZipName = DoGetZipName(m_items[0]);
        appendMode = APPEND_STATUS_CREATE;
    }
    else
    {
        strZipName = m_ExistingZip;
        appendMode = APPEND_STATUS_ADDINZIP;
    }
 
    if (m_items.GetSize() <= 0)
    {
        DPRINT1("GetSize() <= 0\n");
        return CZCERR_ZEROITEMS;
    }
 
    CSimpleArray<CStringW> files;
    for (INT iItem = 0; iItem < m_items.GetSize(); ++iItem)
    {
        DoAddFilesFromItem(files, m_items[iItem]);
    }
 
    if (files.GetSize() <= 0)
    {
        DPRINT1("files.GetSize() <= 0\n");
 
        CStringW strTitle(MAKEINTRESOURCEW(IDS_ERRORTITLE));
        CStringW strText;
        strText.Format(IDS_NOFILES, static_cast<PCWSTR>(m_items[0]));
        MessageBoxW(NULL, strText, strTitle, MB_ICONERROR);
 
        return CZCERR_NOFILES;
    }
 
    zlib_filefunc64_def ffunc;
    ZeroMemory(&ffunc, sizeof(ffunc));
    fill_win32_filefunc64W(&ffunc);
 
    zipFile zf = zipOpen2_64(strZipName, appendMode, NULL, &ffunc);
    if (zf == 0)
    {
        DPRINT1("zf == 0\n");
 
        int err = CZCERR_CREATE;
 
        CStringW strTitle(MAKEINTRESOURCEW(IDS_ERRORTITLE));
        CStringW strText;
        strText.Format(IDS_CANTCREATEZIP, static_cast<PCWSTR>(strZipName), err);
        MessageBoxW(NULL, strText, strTitle, MB_ICONERROR);
 
        return err;
    }
 
    // TODO: password
    const char *password = NULL;
 
    // Use dwAllocationGranularity for file mapping
    SYSTEM_INFO si;
    GetSystemInfo(&si);
    const ULONGLONG dwChunkSize = si.dwAllocationGranularity * 256;
 
    // The loop for creating a ZIP file
    CStringW strTarget, strBaseName = DoGetBaseName(m_items[0]);
    UINT nCodePage = GetZipCodePage(FALSE);
    INT err = ZIP_OK;
    for (INT iFile = 0; iFile < files.GetSize() && err == ZIP_OK; ++iFile)
    {
        const CStringW& strFile = files[iFile];
        zip_fileinfo zi;
 
        // Open the file for storing it into a ZIP file
        HANDLE hFile = CreateFileW(strFile, GENERIC_READ, FILE_SHARE_READ, NULL,
                                   OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, NULL);
        if (hFile == INVALID_HANDLE_VALUE)
        {
            DPRINT1("Cannot open file '%S'\n", (PCWSTR)strFile);
            err = CZCERR_READ;
            break;
        }
 
        // Load the file time info
        DoGetFileTimeInfo(hFile, &zi);
 
        // Get the file size
        LARGE_INTEGER fileSize;
        if (!GetFileSizeEx(hFile, &fileSize))
        {
            DPRINT1("Cannot get file size '%S'\n", (PCWSTR)strFile);
            CloseHandle(hFile);
            err = CZCERR_READ;
            break;
        }
 
        unsigned long crc = 0;
        if (password)
        {
            // TODO: crc = ...;
        }
 
        // Get filename info
        CStringA strNameInZip = DoGetNameInZip(strBaseName, strFile, nCodePage);
        CStringA strNameInZipUTF8 = DoGetNameInZip(strBaseName, strFile, CP_UTF8);
        if (!m_TargetDir.IsEmpty())
        {
            CStringA strTargetDir = CStringA(CW2AEX<MAX_PATH>(m_TargetDir, nCodePage));
            strNameInZip = strTargetDir + strNameInZip;
 
            CStringA strTargetDirUTF8 = CStringA(CW2AEX<MAX_PATH>(m_TargetDir, CP_UTF8));
            strNameInZipUTF8 = strTargetDirUTF8 + strNameInZipUTF8;
        }
 
        // Prepare additional field (UTF-8 name)
        CSimpleArray<BYTE> extraField;
        if (nCodePage != CP_UTF8 && strNameInZip != strNameInZipUTF8)
        {
            // Header
            WORD headerID = EF_UNIPATH, dataSize = 1 + 4 + strNameInZipUTF8.GetLength();
            extraField.Add(headerID & 0xFF);
            extraField.Add((headerID >> 8) & 0xFF);
            extraField.Add(dataSize & 0xFF);
            extraField.Add((dataSize >> 8) & 0xFF);
            extraField.Add(1); // Version
 
            // CRC32
            DWORD nameCRC = CalculateNameCRC32(strNameInZip);
            extraField.Add(nameCRC & 0xFF);
            extraField.Add((nameCRC >> 8) & 0xFF);
            extraField.Add((nameCRC >> 16) & 0xFF);
            extraField.Add((nameCRC >> 24) & 0xFF);
 
            // UTF-8 name
            for (INT ich = 0; ich < strNameInZipUTF8.GetLength(); ++ich)
                extraField.Add(strNameInZipUTF8[ich]);
        }
 
        // Add a new file entry into a ZIP file
        err = zipOpenNewFileInZip4_64(zf, strNameInZip, &zi,
                                      (extraField.GetSize() ? extraField.GetData() : NULL),
                                      extraField.GetSize(), NULL, 0, NULL, Z_DEFLATED,
                                      Z_DEFAULT_COMPRESSION, 0, -MAX_WBITS, DEF_MEM_LEVEL,
                                      Z_DEFAULT_STRATEGY, password, crc,
                                      MINIZIP_COMPATIBLE_VERSION,
                                      (nCodePage == CP_UTF8 ? MINIZIP_UTF8_FLAG : 0), 1);
        if (err)
        {
            DPRINT1("zipOpenNewFileInZip3_64\n");
            break;
        }
 
        if (fileSize.QuadPart > 0) // Not an empty file?
        {
            // Use a file mapping for quick file access and large file support
            HANDLE hMapping = CreateFileMappingW(hFile, NULL, PAGE_READONLY, 0, 0, NULL);
            if (!hMapping)
            {
                DPRINT1("Cannot create file mapping\n");
                err = CZCERR_READ;
                CloseHandle(hFile);
                break;
            }
 
            // The loop for reading and storing file contents
            DWORD dwMapSize;
            for (ULONGLONG offset = 0; offset < (ULONGLONG)fileSize.QuadPart && err == ZIP_OK;
                 offset += dwMapSize)
            {
                ULONGLONG dwDelta = fileSize.QuadPart - offset;
                dwMapSize = (DWORD)min(dwChunkSize, dwDelta);
                DWORD offsetLow = (DWORD)offset, offsetHigh = (DWORD)(offset >> 32);
                PVOID pData = MapViewOfFile(hMapping, FILE_MAP_READ, offsetHigh, offsetLow,
                                            dwMapSize);
                if (!pData)
                {
                    DPRINT1("Cannot map the view\n");
                    err = CZCERR_READ;
                    break;
                }
 
                err = zipWriteInFileInZip(zf, pData, dwMapSize);
                UnmapViewOfFile(pData);
            }
 
            CloseHandle(hMapping);
        }
 
        CloseHandle(hFile);
 
        zipCloseFileInZip(zf);
    }
 
    zipClose(zf, NULL);
 
    if (err)
    {
        if (err && m_ExistingZip.IsEmpty())
            DeleteFileW(strZipName);
 
        CStringW strTitle(MAKEINTRESOURCEW(IDS_ERRORTITLE));
 
        CStringW strText;
        if (err < 0)
            strText.Format(IDS_CANTCREATEZIP, static_cast<PCWSTR>(strZipName), err);
        else
            strText.Format(IDS_CANTREADFILE, static_cast<PCWSTR>(strTarget));
 
        MessageBoxW(NULL, strText, strTitle, MB_ICONERROR);
    }
    else
    {
        WCHAR szFullPath[MAX_PATH];
        GetFullPathNameW(strZipName, _countof(szFullPath), szFullPath, NULL);
 
        if (m_ExistingZip.IsEmpty())
            SHChangeNotify(SHCNE_CREATE, SHCNF_PATHW, szFullPath, NULL);
        else
            SHChangeNotify(SHCNE_UPDATEITEM, SHCNF_PATHW, szFullPath, NULL);
    }
 
    return err;
}

Member Data Documentation

m_ExistingZip

CStringW CZipCreatorImpl::m_ExistingZip

Definition at line 131 of file CZipCreator.cpp.

Referenced by JustDoIt().

m_items

CSimpleArray<CStringW> CZipCreatorImpl::m_items

Definition at line 130 of file CZipCreator.cpp.

Referenced by JustDoIt().

m_TargetDir

CStringW CZipCreatorImpl::m_TargetDir

Definition at line 132 of file CZipCreator.cpp.

Referenced by JustDoIt().

---

The documentation for this struct was generated from the following file:

• dll/shellext/zipfldr/CZipCreator.cpp