d2/dc5/extract_8c_source.html

 /*
  * Unit tests for cabinet.dll extract functions
  *
  * Copyright (C) 2006 James Hawkins
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  */

 #include <stdio.h>
 #include <windows.h>
 #include "fci.h"
 #include "fdi.h"
 #include "wine/test.h"

 /* make the max size large so there is only one cab file */
 #define MEDIA_SIZE          999999999
 #define FOLDER_THRESHOLD    900000

 /* The following definitions were copied from dlls/cabinet/cabinet.h
  * because they are undocumented in windows.
  */

 /* SESSION Operation */
 #define EXTRACT_FILLFILELIST  0x00000001
 #define EXTRACT_EXTRACTFILES  0x00000002

 struct FILELIST{
     LPSTR FileName;
     struct FILELIST *next;
     BOOL DoExtract;
 };

 typedef struct {
     INT FileSize;
     ERF Error;
     struct FILELIST *FileList;
     INT FileCount;
     INT Operation;
     CHAR Destination[MAX_PATH];
     CHAR CurrentFile[MAX_PATH];
     CHAR Reserved[MAX_PATH];
     struct FILELIST *FilterList;
 } SESSION;

 /* function pointers */
 static HMODULE hCabinet;
 static HRESULT (WINAPI *pExtract)(SESSION*, LPCSTR);

 static CHAR CURR_DIR[MAX_PATH];

 static void init_function_pointers(void)
 {
     hCabinet = GetModuleHandleA("cabinet.dll");

     pExtract = (void *)GetProcAddress(hCabinet, "Extract");
 }

 /* creates a file with the specified name for tests */
 static void createTestFile(const CHAR *name)
 {
     HANDLE file;
     DWORD written;

     file = CreateFileA(name, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL);
     ok(file != INVALID_HANDLE_VALUE, "Failure to open file %s\n", name);
     WriteFile(file, name, strlen(name), &written, NULL);
     WriteFile(file, "\n", strlen("\n"), &written, NULL);
     CloseHandle(file);
 }

 static int getFileSize(const CHAR *name)
 {
     HANDLE file;
     int size;
     file = CreateFileA(name, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL);
     if (file == INVALID_HANDLE_VALUE)
         return -1;
     size = GetFileSize(file, NULL);
     CloseHandle(file);
     return size;
 }

 static void create_test_files(void)
 {
     int len;

     GetCurrentDirectoryA(MAX_PATH, CURR_DIR);
     len = lstrlenA(CURR_DIR);

     if(len && (CURR_DIR[len-1] == '\\'))
         CURR_DIR[len-1] = 0;

     createTestFile("a.txt");
     createTestFile("b.txt");
     CreateDirectoryA("testdir", NULL);
     createTestFile("testdir\\c.txt");
     createTestFile("testdir\\d.txt");
     CreateDirectoryA("dest", NULL);
 }

 static void delete_test_files(void)
 {
     DeleteFileA("a.txt");
     DeleteFileA("b.txt");
     DeleteFileA("testdir\\c.txt");
     DeleteFileA("testdir\\d.txt");
     RemoveDirectoryA("testdir");

     DeleteFileA("extract.cab");
 }

 /* the FCI callbacks */

 static void * CDECL mem_alloc(ULONG cb)
 {
     return HeapAlloc(GetProcessHeap(), 0, cb);
 }

 static void CDECL mem_free(void *memory)
 {
     HeapFree(GetProcessHeap(), 0, memory);
 }

 static BOOL CDECL get_next_cabinet(PCCAB pccab, ULONG  cbPrevCab, void *pv)
 {
     return TRUE;
 }

 static LONG CDECL progress(UINT typeStatus, ULONG cb1, ULONG cb2, void *pv)
 {
     return 0;
 }

 static int CDECL file_placed(PCCAB pccab, char *pszFile, LONG cbFile,
                              BOOL fContinuation, void *pv)
 {
     return 0;
 }

 static INT_PTR CDECL fci_open(char *pszFile, int oflag, int pmode, int *err, void *pv)
 {
     HANDLE handle;
     DWORD dwAccess = 0;
     DWORD dwShareMode = 0;
     DWORD dwCreateDisposition = OPEN_EXISTING;

     dwAccess = GENERIC_READ | GENERIC_WRITE;
     /* FILE_SHARE_DELETE is not supported by Windows Me/98/95 */
     dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;

     if (GetFileAttributesA(pszFile) != INVALID_FILE_ATTRIBUTES)
         dwCreateDisposition = OPEN_EXISTING;
     else
         dwCreateDisposition = CREATE_NEW;

     handle = CreateFileA(pszFile, dwAccess, dwShareMode, NULL,
                          dwCreateDisposition, 0, NULL);

     ok(handle != INVALID_HANDLE_VALUE, "Failed to CreateFile %s\n", pszFile);

     return (INT_PTR)handle;
 }

 static UINT CDECL fci_read(INT_PTR hf, void *memory, UINT cb, int *err, void *pv)
 {
     HANDLE handle = (HANDLE)hf;
     DWORD dwRead;
     BOOL res;

     res = ReadFile(handle, memory, cb, &dwRead, NULL);
     ok(res, "Failed to ReadFile\n");

     return dwRead;
 }

 static UINT CDECL fci_write(INT_PTR hf, void *memory, UINT cb, int *err, void *pv)
 {
     HANDLE handle = (HANDLE)hf;
     DWORD dwWritten;
     BOOL res;

     res = WriteFile(handle, memory, cb, &dwWritten, NULL);
     ok(res, "Failed to WriteFile\n");

     return dwWritten;
 }

 static int CDECL fci_close(INT_PTR hf, int *err, void *pv)
 {
     HANDLE handle = (HANDLE)hf;
     ok(CloseHandle(handle), "Failed to CloseHandle\n");

     return 0;
 }

 static LONG CDECL fci_seek(INT_PTR hf, LONG dist, int seektype, int *err, void *pv)
 {
     HANDLE handle = (HANDLE)hf;
     DWORD ret;

     ret = SetFilePointer(handle, dist, NULL, seektype);
     ok(ret != INVALID_SET_FILE_POINTER, "Failed to SetFilePointer\n");

     return ret;
 }

 static int CDECL fci_delete(char *pszFile, int *err, void *pv)
 {
     BOOL ret = DeleteFileA(pszFile);
     ok(ret, "Failed to DeleteFile %s\n", pszFile);

     return 0;
 }

 static BOOL CDECL get_temp_file(char *pszTempName, int cbTempName, void *pv)
 {
     LPSTR tempname;

     tempname = HeapAlloc(GetProcessHeap(), 0, MAX_PATH);
     GetTempFileNameA(".", "xx", 0, tempname);

     if (tempname && (strlen(tempname) < (unsigned)cbTempName))
     {
         lstrcpyA(pszTempName, tempname);
         HeapFree(GetProcessHeap(), 0, tempname);
         return TRUE;
     }

     HeapFree(GetProcessHeap(), 0, tempname);

     return FALSE;
 }

 static INT_PTR CDECL get_open_info(char *pszName, USHORT *pdate, USHORT *ptime,
                                    USHORT *pattribs, int *err, void *pv)
 {
     BY_HANDLE_FILE_INFORMATION finfo;
     FILETIME filetime;
     HANDLE handle;
     DWORD attrs;
     BOOL res;

     handle = CreateFileA(pszName, GENERIC_READ, FILE_SHARE_READ, NULL,
                          OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN, NULL);

     ok(handle != INVALID_HANDLE_VALUE, "Failed to CreateFile %s\n", pszName);

     res = GetFileInformationByHandle(handle, &finfo);
     ok(res, "Expected GetFileInformationByHandle to succeed\n");

     FileTimeToLocalFileTime(&finfo.ftLastWriteTime, &filetime);
     FileTimeToDosDateTime(&filetime, pdate, ptime);

     attrs = GetFileAttributesA(pszName);
     ok(attrs != INVALID_FILE_ATTRIBUTES, "Failed to GetFileAttributes\n");

     return (INT_PTR)handle;
 }

 static void add_file(HFCI hfci, char *file)
 {
     char path[MAX_PATH];
     BOOL res;

     lstrcpyA(path, CURR_DIR);
     lstrcatA(path, "\\");
     lstrcatA(path, file);

     res = FCIAddFile(hfci, path, file, FALSE, get_next_cabinet, progress,
                      get_open_info, tcompTYPE_MSZIP);
     ok(res, "Expected FCIAddFile to succeed\n");
 }

 static void set_cab_parameters(PCCAB pCabParams)
 {
     ZeroMemory(pCabParams, sizeof(CCAB));

     pCabParams->cb = MEDIA_SIZE;
     pCabParams->cbFolderThresh = FOLDER_THRESHOLD;
     pCabParams->setID = 0xbeef;
     lstrcpyA(pCabParams->szCabPath, CURR_DIR);
     lstrcatA(pCabParams->szCabPath, "\\");
     lstrcpyA(pCabParams->szCab, "extract.cab");
 }

 static void create_cab_file(void)
 {
     CCAB cabParams;
     HFCI hfci;
     ERF erf;
     static CHAR a_txt[]         = "a.txt",
                 b_txt[]         = "b.txt",
                 testdir_c_txt[] = "testdir\\c.txt",
                 testdir_d_txt[] = "testdir\\d.txt";
     BOOL res;

     set_cab_parameters(&cabParams);

     hfci = FCICreate(&erf, file_placed, mem_alloc, mem_free, fci_open,
                       fci_read, fci_write, fci_close, fci_seek, fci_delete,
                       get_temp_file, &cabParams, NULL);

     ok(hfci != NULL, "Failed to create an FCI context\n");

     add_file(hfci, a_txt);
     add_file(hfci, b_txt);
     add_file(hfci, testdir_c_txt);
     add_file(hfci, testdir_d_txt);

     res = FCIFlushCabinet(hfci, FALSE, get_next_cabinet, progress);
     ok(res, "Failed to flush the cabinet\n");

     res = FCIDestroy(hfci);
     ok(res, "Failed to destroy the cabinet\n");
 }

 static BOOL check_list(struct FILELIST **node, const char *filename, BOOL do_extract)
 {
     if (!*node)
         return FALSE;

     if (lstrcmpA((*node)->FileName, filename))
         return FALSE;

     if ((*node)->DoExtract != do_extract)
         return FALSE;

     *node = (*node)->next;
     return TRUE;
 }

 static void free_file_node(struct FILELIST *node)
 {
     HeapFree(GetProcessHeap(), 0, node->FileName);
     HeapFree(GetProcessHeap(), 0, node);
 }

 static void free_file_list(SESSION* session)
 {
     struct FILELIST *next, *curr = session->FileList;

     while (curr)
     {
         next = curr->next;
         free_file_node(curr);
         curr = next;
     }

     session->FileList = NULL;
 }

 static void test_Extract(void)
 {
     SESSION session;
     HRESULT res;
     struct FILELIST *node;

     /* native windows crashes if
     *   - invalid parameters are sent in
     *   - you call EXTRACT_EXTRACTFILES without calling
     *     EXTRACT_FILLFILELIST first or at the same time
     */

     /* try to extract all files */
     ZeroMemory(&session, sizeof(SESSION));
     lstrcpyA(session.Destination, "dest");
     session.Operation = EXTRACT_FILLFILELIST | EXTRACT_EXTRACTFILES;
     res = pExtract(&session, "extract.cab");
     node = session.FileList;
     ok(res == S_OK, "Expected S_OK, got %d\n", res);
     ok(session.FileSize == 40, "Expected 40, got %d\n", session.FileSize);
     ok(session.Error.erfOper == FDIERROR_NONE,
        "Expected FDIERROR_NONE, got %d\n", session.Error.erfOper);
     ok(session.Error.erfType == 0, "Expected 0, got %d\n", session.Error.erfType);
     ok(session.Error.fError == FALSE, "Expected FALSE, got %d\n", session.Error.fError);
     ok(session.FileCount == 4, "Expected 4, got %d\n", session.FileCount);
     ok(session.Operation == (EXTRACT_FILLFILELIST | EXTRACT_EXTRACTFILES),
        "Expected EXTRACT_FILLFILELIST | EXTRACT_EXTRACTFILES, got %d\n", session.Operation);
     ok(!lstrcmpA(session.Destination, "dest"), "Expected dest, got %s\n", session.Destination);
     ok(!lstrcmpA(session.CurrentFile, "dest\\testdir\\d.txt"),
        "Expected dest\\testdir\\d.txt, got %s\n", session.CurrentFile);
     ok(!*session.Reserved, "Expected empty string, got %s\n", session.Reserved);
     ok(!session.FilterList, "Expected empty filter list\n");
     ok(DeleteFileA("dest\\a.txt"), "Expected dest\\a.txt to exist\n");
     ok(DeleteFileA("dest\\b.txt"), "Expected dest\\b.txt to exist\n");
     ok(DeleteFileA("dest\\testdir\\c.txt"), "Expected dest\\testdir\\c.txt to exist\n");
     ok(DeleteFileA("dest\\testdir\\d.txt"), "Expected dest\\testdir\\d.txt to exist\n");
     ok(RemoveDirectoryA("dest\\testdir"), "Expected dest\\testdir to exist\n");
     ok(check_list(&node, "testdir\\d.txt", FALSE), "list entry wrong\n");
     ok(check_list(&node, "testdir\\c.txt", FALSE), "list entry wrong\n");
     ok(check_list(&node, "b.txt", FALSE), "list entry wrong\n");
     ok(check_list(&node, "a.txt", FALSE), "list entry wrong\n");
     free_file_list(&session);

     /* try fill file list operation */
     ZeroMemory(&session, sizeof(SESSION));
     lstrcpyA(session.Destination, "dest");
     session.Operation = EXTRACT_FILLFILELIST;
     res = pExtract(&session, "extract.cab");
     node = session.FileList;
     ok(res == S_OK, "Expected S_OK, got %d\n", res);
     ok(session.FileSize == 40, "Expected 40, got %d\n", session.FileSize);
     ok(session.Error.erfOper == FDIERROR_NONE,
        "Expected FDIERROR_NONE, got %d\n", session.Error.erfOper);
     ok(session.Error.erfType == 0, "Expected 0, got %d\n", session.Error.erfType);
     ok(session.Error.fError == FALSE, "Expected FALSE, got %d\n", session.Error.fError);
     ok(session.FileCount == 4, "Expected 4, got %d\n", session.FileCount);
     ok(session.Operation == EXTRACT_FILLFILELIST,
        "Expected EXTRACT_FILLFILELIST, got %d\n", session.Operation);
     ok(!lstrcmpA(session.Destination, "dest"), "Expected dest, got %s\n", session.Destination);
     ok(!lstrcmpA(session.CurrentFile, "dest\\testdir\\d.txt"),
        "Expected dest\\testdir\\d.txt, got %s\n", session.CurrentFile);
     ok(!*session.Reserved, "Expected empty string, got %s\n", session.Reserved);
     ok(!session.FilterList, "Expected empty filter list\n");
     ok(!DeleteFileA("dest\\a.txt"), "Expected dest\\a.txt to not exist\n");
     ok(!DeleteFileA("dest\\testdir\\c.txt"), "Expected dest\\testdir\\c.txt to not exist\n");
     ok(check_list(&node, "testdir\\d.txt", TRUE), "list entry wrong\n");
     ok(check_list(&node, "testdir\\c.txt", TRUE), "list entry wrong\n");
     ok(check_list(&node, "b.txt", TRUE), "list entry wrong\n");
     ok(check_list(&node, "a.txt", TRUE), "list entry wrong\n");

     /* try extract files operation once file list is filled */
     session.Operation = EXTRACT_EXTRACTFILES;
     res = pExtract(&session, "extract.cab");
     node = session.FileList;
     ok(res == S_OK, "Expected S_OK, got %d\n", res);
     ok(session.FileSize == 40, "Expected 40, got %d\n", session.FileSize);
     ok(session.Error.erfOper == FDIERROR_NONE,
        "Expected FDIERROR_NONE, got %d\n", session.Error.erfOper);
     ok(session.Error.erfType == 0, "Expected 0, got %d\n", session.Error.erfType);
     ok(session.Error.fError == FALSE, "Expected FALSE, got %d\n", session.Error.fError);
     ok(session.FileCount == 4, "Expected 4, got %d\n", session.FileCount);
     ok(session.Operation == EXTRACT_EXTRACTFILES,
        "Expected EXTRACT_EXTRACTFILES, got %d\n", session.Operation);
     ok(!lstrcmpA(session.Destination, "dest"), "Expected dest, got %s\n", session.Destination);
     ok(!lstrcmpA(session.CurrentFile, "dest\\testdir\\d.txt"),
        "Expected dest\\testdir\\d.txt, got %s\n", session.CurrentFile);
     ok(!*session.Reserved, "Expected empty string, got %s\n", session.Reserved);
     ok(!session.FilterList, "Expected empty filter list\n");
     ok(DeleteFileA("dest\\a.txt"), "Expected dest\\a.txt to exist\n");
     ok(DeleteFileA("dest\\b.txt"), "Expected dest\\b.txt to exist\n");
     ok(DeleteFileA("dest\\testdir\\c.txt"), "Expected dest\\testdir\\c.txt to exist\n");
     ok(DeleteFileA("dest\\testdir\\d.txt"), "Expected dest\\testdir\\d.txt to exist\n");
     ok(RemoveDirectoryA("dest\\testdir"), "Expected dest\\testdir to exist\n");
     ok(RemoveDirectoryA("dest"), "Expected dest to exist\n");
     ok(check_list(&node, "testdir\\d.txt", FALSE), "list entry wrong\n");
     ok(check_list(&node, "testdir\\c.txt", FALSE), "list entry wrong\n");
     ok(check_list(&node, "b.txt", FALSE), "list entry wrong\n");
     ok(check_list(&node, "a.txt", FALSE), "list entry wrong\n");

     /* Extract does not extract files if the dest dir does not exist */
     res = pExtract(&session, "extract.cab");
     node = session.FileList;
     ok(res == S_OK, "Expected S_OK, got %d\n", res);
     ok(session.FileSize == 40, "Expected 40, got %d\n", session.FileSize);
     ok(session.Error.erfOper == FDIERROR_NONE,
        "Expected FDIERROR_NONE, got %d\n", session.Error.erfOper);
     ok(session.Error.erfType == 0, "Expected 0, got %d\n", session.Error.erfType);
     ok(session.Error.fError == FALSE, "Expected FALSE, got %d\n", session.Error.fError);
     ok(session.FileCount == 4, "Expected 4, got %d\n", session.FileCount);
     ok(session.Operation == EXTRACT_EXTRACTFILES,
        "Expected EXTRACT_EXTRACTFILES, got %d\n", session.Operation);
     ok(!lstrcmpA(session.Destination, "dest"), "Expected dest, got %s\n", session.Destination);
     ok(!lstrcmpA(session.CurrentFile, "dest\\testdir\\d.txt"),
        "Expected dest\\testdir\\d.txt, got %s\n", session.CurrentFile);
     ok(!*session.Reserved, "Expected empty string, got %s\n", session.Reserved);
     ok(!session.FilterList, "Expected empty filter list\n");
     ok(!DeleteFileA("dest\\a.txt"), "Expected dest\\a.txt to not exist\n");
     ok(!DeleteFileA("dest\\b.txt"), "Expected dest\\b.txt to not exist\n");
     ok(!DeleteFileA("dest\\testdir\\c.txt"), "Expected dest\\testdir\\c.txt to not exist\n");
     ok(!DeleteFileA("dest\\testdir\\d.txt"), "Expected dest\\testdir\\d.txt to not exist\n");
     ok(check_list(&node, "testdir\\d.txt", FALSE), "list entry wrong\n");
     ok(check_list(&node, "testdir\\c.txt", FALSE), "list entry wrong\n");
     ok(check_list(&node, "b.txt", FALSE), "list entry wrong\n");
     ok(check_list(&node, "a.txt", FALSE), "list entry wrong\n");

     /* remove two of the files in the list */
     node = session.FileList->next;
     session.FileList->next = session.FileList->next->next;
     free_file_node(node);
     free_file_node(session.FileList->next->next);
     session.FileList->next->next = NULL;
     session.FilterList = NULL;
     CreateDirectoryA("dest", NULL);
     res = pExtract(&session, "extract.cab");
     node = session.FileList;
     ok(res == S_OK, "Expected S_OK, got %d\n", res);
     ok(session.FileSize == 40, "Expected 40, got %d\n", session.FileSize);
     ok(session.Error.erfOper == FDIERROR_NONE,
        "Expected FDIERROR_NONE, got %d\n", session.Error.erfOper);
     ok(session.Error.erfType == 0, "Expected 0, got %d\n", session.Error.erfType);
     ok(session.Error.fError == FALSE, "Expected FALSE, got %d\n", session.Error.fError);
     ok(session.FileCount == 4, "Expected 4, got %d\n", session.FileCount);
     ok(session.Operation == EXTRACT_EXTRACTFILES,
        "Expected EXTRACT_EXTRACTFILES, got %d\n", session.Operation);
     ok(!lstrcmpA(session.Destination, "dest"), "Expected dest, got %s\n", session.Destination);
     ok(!lstrcmpA(session.CurrentFile, "dest\\testdir\\d.txt"),
        "Expected dest\\testdir\\d.txt, got %s\n", session.CurrentFile);
     ok(!*session.Reserved, "Expected empty string, got %s\n", session.Reserved);
     ok(!session.FilterList, "Expected empty filter list\n");
     ok(DeleteFileA("dest\\a.txt"), "Expected dest\\a.txt to exist\n");
     ok(DeleteFileA("dest\\testdir\\c.txt"), "Expected dest\\testdir\\c.txt to exist\n");
     ok(!DeleteFileA("dest\\b.txt"), "Expected dest\\b.txt to not exist\n");
     ok(!DeleteFileA("dest\\testdir\\d.txt"), "Expected dest\\testdir\\d.txt to not exist\n");
     ok(check_list(&node, "testdir\\d.txt", FALSE), "list entry wrong\n");
     ok(!check_list(&node, "testdir\\c.txt", FALSE), "list entry wrong\n");
     ok(check_list(&node, "b.txt", FALSE), "list entry wrong\n");
     ok(!check_list(&node, "a.txt", FALSE), "list entry wrong\n");
     free_file_list(&session);

     session.Operation = EXTRACT_FILLFILELIST;
     session.FileList = NULL;
     res = pExtract(&session, "extract.cab");
     node = session.FileList;
     ok(res == S_OK, "Expected S_OK, got %d\n", res);
     ok(session.FileSize == 40, "Expected 40, got %d\n", session.FileSize);
     ok(session.Error.erfOper == FDIERROR_NONE,
        "Expected FDIERROR_NONE, got %d\n", session.Error.erfOper);
     ok(session.Error.erfType == 0, "Expected 0, got %d\n", session.Error.erfType);
     ok(session.Error.fError == FALSE, "Expected FALSE, got %d\n", session.Error.fError);
     ok(session.FileCount == 8, "Expected 8, got %d\n", session.FileCount);
     ok(session.Operation == EXTRACT_FILLFILELIST,
        "Expected EXTRACT_FILLFILELIST, got %d\n", session.Operation);
     ok(!lstrcmpA(session.Destination, "dest"), "Expected dest, got %s\n", session.Destination);
     ok(!lstrcmpA(session.CurrentFile, "dest\\testdir\\d.txt"),
        "Expected dest\\testdir\\d.txt, got %s\n", session.CurrentFile);
     ok(!*session.Reserved, "Expected empty string, got %s\n", session.Reserved);
     ok(!session.FilterList, "Expected empty filter list\n");
     ok(!DeleteFileA("dest\\a.txt"), "Expected dest\\a.txt to not exist\n");
     ok(!DeleteFileA("dest\\testdir\\c.txt"), "Expected dest\\testdir\\c.txt to not exist\n");
     ok(!DeleteFileA("dest\\b.txt"), "Expected dest\\b.txt to not exist\n");
     ok(!DeleteFileA("dest\\testdir\\d.txt"), "Expected dest\\testdir\\d.txt to not exist\n");
     ok(check_list(&node, "testdir\\d.txt", TRUE), "list entry wrong\n");
     ok(!check_list(&node, "testdir\\c.txt", FALSE), "list entry wrong\n");
     ok(!check_list(&node, "b.txt", FALSE), "list entry wrong\n");
     ok(!check_list(&node, "a.txt", FALSE), "list entry wrong\n");

     session.Operation = 0;
     res = pExtract(&session, "extract.cab");
     node = session.FileList;
     ok(res == S_OK, "Expected S_OK, got %d\n", res);
     ok(session.FileSize == 40, "Expected 40, got %d\n", session.FileSize);
     ok(session.Error.erfOper == FDIERROR_NONE,
        "Expected FDIERROR_NONE, got %d\n", session.Error.erfOper);
     ok(session.Error.erfType == 0, "Expected 0, got %d\n", session.Error.erfType);
     ok(session.Error.fError == FALSE, "Expected FALSE, got %d\n", session.Error.fError);
     ok(session.FileCount == 8, "Expected 8, got %d\n", session.FileCount);
     ok(session.Operation == 0, "Expected 0, got %d\n", session.Operation);
     ok(!lstrcmpA(session.Destination, "dest"), "Expected dest, got %s\n", session.Destination);
     ok(!lstrcmpA(session.CurrentFile, "dest\\testdir\\d.txt"),
        "Expected dest\\testdir\\d.txt, got %s\n", session.CurrentFile);
     ok(!*session.Reserved, "Expected empty string, got %s\n", session.Reserved);
     ok(!session.FilterList, "Expected empty filter list\n");
     ok(!DeleteFileA("dest\\a.txt"), "Expected dest\\a.txt to exist\n");
     ok(!DeleteFileA("dest\\testdir\\c.txt"), "Expected dest\\testdir\\c.txt to exist\n");
     ok(!DeleteFileA("dest\\b.txt"), "Expected dest\\b.txt to exist\n");
     ok(!DeleteFileA("dest\\testdir\\d.txt"), "Expected dest\\testdir\\d.txt to exist\n");
     ok(check_list(&node, "testdir\\d.txt", TRUE), "list entry wrong\n");
     ok(check_list(&node, "testdir\\c.txt", TRUE), "list entry wrong\n");
     ok(check_list(&node, "b.txt", TRUE), "list entry wrong\n");
     ok(check_list(&node, "a.txt", TRUE), "list entry wrong\n");

     session.Operation = 0;
     session.FilterList = session.FileList;
     res = pExtract(&session, "extract.cab");
     node = session.FileList;
     ok(res == S_OK, "Expected S_OK, got %d\n", res);
     ok(session.FileSize == 40, "Expected 40, got %d\n", session.FileSize);
     ok(session.Error.erfOper == FDIERROR_NONE,
        "Expected FDIERROR_NONE, got %d\n", session.Error.erfOper);
     ok(session.Error.erfType == 0, "Expected 0, got %d\n", session.Error.erfType);
     ok(session.Error.fError == FALSE, "Expected FALSE, got %d\n", session.Error.fError);
     ok(session.FileCount == 8, "Expected 8, got %d\n", session.FileCount);
     ok(session.Operation == 0, "Expected 0, got %d\n", session.Operation);
     ok(!lstrcmpA(session.Destination, "dest"), "Expected dest, got %s\n", session.Destination);
     ok(!lstrcmpA(session.CurrentFile, "dest\\testdir\\d.txt"),
        "Expected dest\\testdir\\d.txt, got %s\n", session.CurrentFile);
     ok(!*session.Reserved, "Expected empty string, got %s\n", session.Reserved);
     ok(DeleteFileA("dest\\a.txt"), "Expected dest\\a.txt to exist\n");
     ok(DeleteFileA("dest\\testdir\\c.txt"), "Expected dest\\testdir\\c.txt to exist\n");
     ok(DeleteFileA("dest\\b.txt"), "Expected dest\\b.txt to exist\n");
     ok(DeleteFileA("dest\\testdir\\d.txt"), "Expected dest\\testdir\\d.txt to exist\n");
     ok(check_list(&node, "testdir\\d.txt", FALSE), "list entry wrong\n");
     ok(check_list(&node, "testdir\\c.txt", FALSE), "list entry wrong\n");
     ok(check_list(&node, "b.txt", FALSE), "list entry wrong\n");
     ok(check_list(&node, "a.txt", FALSE), "list entry wrong\n");
     node = session.FilterList;
     ok(check_list(&node, "testdir\\d.txt", FALSE), "list entry wrong\n");
     ok(check_list(&node, "testdir\\c.txt", FALSE), "list entry wrong\n");
     ok(check_list(&node, "b.txt", FALSE), "list entry wrong\n");
     ok(check_list(&node, "a.txt", FALSE), "list entry wrong\n");
     free_file_list(&session);

     /* cabinet does not exist */
     ZeroMemory(&session, sizeof(SESSION));
     lstrcpyA(session.Destination, "dest");
     session.Operation = EXTRACT_FILLFILELIST | EXTRACT_EXTRACTFILES;
     res = pExtract(&session, "nonexistent.cab");
     node = session.FileList;
     ok(res == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
        "Expected HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), got %08x\n", res);
     ok(session.Error.erfOper == FDIERROR_CABINET_NOT_FOUND,
        "Expected FDIERROR_CABINET_NOT_FOUND, got %d\n", session.Error.erfOper);
     ok(session.FileSize == 0, "Expected 0, got %d\n", session.FileSize);
     ok(session.Error.erfType == 0, "Expected 0, got %d\n", session.Error.erfType);
     ok(session.Error.fError == TRUE, "Expected TRUE, got %d\n", session.Error.fError);
     ok(session.FileCount == 0, "Expected 0, got %d\n", session.FileCount);
     ok(session.Operation == (EXTRACT_FILLFILELIST | EXTRACT_EXTRACTFILES),
        "Expected EXTRACT_FILLFILELIST | EXTRACT_EXTRACTFILES, got %d\n", session.Operation);
     ok(!lstrcmpA(session.Destination, "dest"), "Expected dest, got %s\n", session.Destination);
     ok(!*session.CurrentFile, "Expected empty string, got %s\n", session.CurrentFile);
     ok(!*session.Reserved, "Expected empty string, got %s\n", session.Reserved);
     ok(!session.FilterList, "Expected empty filter list\n");
     ok(!DeleteFileA("dest\\a.txt"), "Expected dest\\a.txt to not exist\n");
     ok(!DeleteFileA("dest\\b.txt"), "Expected dest\\b.txt to not exist\n");
     ok(!DeleteFileA("dest\\testdir\\c.txt"), "Expected dest\\testdir\\c.txt to not exist\n");
     ok(!DeleteFileA("dest\\testdir\\d.txt"), "Expected dest\\testdir\\d.txt to not exist\n");
     ok(!check_list(&node, "testdir\\d.txt", FALSE), "list entry should not exist\n");
     ok(!check_list(&node, "testdir\\c.txt", FALSE), "list entry should not exist\n");
     ok(!check_list(&node, "b.txt", FALSE), "list entry should not exist\n");
     ok(!check_list(&node, "a.txt", FALSE), "list entry should not exist\n");
     free_file_list(&session);

     /* first file exists but is read-only */
     createTestFile("dest\\a.txt");
     SetFileAttributesA("dest\\a.txt", FILE_ATTRIBUTE_READONLY);
     ok(getFileSize("dest\\a.txt") == 11, "Expected dest\\a.txt to be 11 bytes\n");
     ZeroMemory(&session, sizeof(SESSION));
     lstrcpyA(session.Destination, "dest");
     session.Operation = EXTRACT_FILLFILELIST | EXTRACT_EXTRACTFILES;
     res = pExtract(&session, "extract.cab");
     node = session.FileList;
     ok(res == HRESULT_FROM_WIN32(ERROR_ACCESS_DENIED) || res == E_FAIL,
        "Expected HRESULT_FROM_WIN32(ERROR_ACCESS_DENIED) or E_FAIL, got %08x\n", res);
     ok(session.FileSize == 6, "Expected 6, got %d\n", session.FileSize);
     ok(session.Error.erfOper == FDIERROR_USER_ABORT,
        "Expected FDIERROR_USER_ABORT, got %d\n", session.Error.erfOper);
     ok(session.Error.fError == TRUE, "Expected TRUE, got %d\n", session.Error.fError);
     ok(session.FileCount == 1, "Expected 1, got %d\n", session.FileCount);
     ok(!lstrcmpA(session.CurrentFile, "dest\\a.txt"),
        "Expected dest\\a.txt, got %s\n", session.CurrentFile);
     ok(session.Error.erfType == 0, "Expected 0, got %d\n", session.Error.erfType);
     ok(session.Operation == (EXTRACT_FILLFILELIST | EXTRACT_EXTRACTFILES),
        "Expected EXTRACT_FILLFILELIST | EXTRACT_EXTRACTFILES, got %d\n", session.Operation);
     ok(!lstrcmpA(session.Destination, "dest"), "Expected dest, got %s\n", session.Destination);
     ok(!*session.Reserved, "Expected empty string, got %s\n", session.Reserved);
     ok(!session.FilterList, "Expected empty filter list\n");
     ok(getFileSize("dest\\a.txt") == 11, "Expected dest\\a.txt to be 11 bytes\n");
     ok(!DeleteFileA("dest\\a.txt"), "Expected dest\\a.txt to be read-only\n");
     ok(!DeleteFileA("dest\\b.txt"), "Expected dest\\b.txt to not exist\n");
     ok(!DeleteFileA("dest\\testdir\\c.txt"), "Expected dest\\testdir\\c.txt to not exist\n");
     ok(!DeleteFileA("dest\\testdir\\d.txt"), "Expected dest\\testdir\\d.txt to not exist\n");
     ok(!check_list(&node, "testdir\\d.txt", FALSE), "list entry should not exist\n");
     ok(!check_list(&node, "testdir\\c.txt", FALSE), "list entry should not exist\n");
     ok(!check_list(&node, "b.txt", FALSE), "list entry should not exist\n");
     ok(!check_list(&node, "a.txt", FALSE), "list entry should not exist\n");
     free_file_list(&session);

     SetFileAttributesA("dest\\a.txt", FILE_ATTRIBUTE_NORMAL);
     DeleteFileA("dest\\a.txt");

     /* first file exists and is writable, third file exists but is read-only */
     createTestFile("dest\\a.txt");
     createTestFile("dest\\testdir\\c.txt");
     SetFileAttributesA("dest\\testdir\\c.txt", FILE_ATTRIBUTE_READONLY);
     ZeroMemory(&session, sizeof(SESSION));
     lstrcpyA(session.Destination, "dest");
     session.Operation = EXTRACT_FILLFILELIST | EXTRACT_EXTRACTFILES;
     res = pExtract(&session, "extract.cab");
     node = session.FileList;
     ok(res == HRESULT_FROM_WIN32(ERROR_ACCESS_DENIED) || res == E_FAIL,
        "Expected HRESULT_FROM_WIN32(ERROR_ACCESS_DENIED) or E_FAIL, got %08x\n", res);
     ok(session.FileSize == 26, "Expected 26, got %d\n", session.FileSize);
     ok(session.Error.erfOper == FDIERROR_USER_ABORT,
        "Expected FDIERROR_USER_ABORT, got %d\n", session.Error.erfOper);
     ok(session.Error.fError == TRUE, "Expected TRUE, got %d\n", session.Error.fError);
     ok(session.FileCount == 3, "Expected 3, got %d\n", session.FileCount);
     ok(!lstrcmpA(session.CurrentFile, "dest\\testdir\\c.txt"),
        "Expected dest\\c.txt, got %s\n", session.CurrentFile);
     ok(session.Error.erfType == 0, "Expected 0, got %d\n", session.Error.erfType);
     ok(session.Operation == (EXTRACT_FILLFILELIST | EXTRACT_EXTRACTFILES),
        "Expected EXTRACT_FILLFILELIST | EXTRACT_EXTRACTFILES, got %d\n", session.Operation);
     ok(!lstrcmpA(session.Destination, "dest"), "Expected dest, got %s\n", session.Destination);
     ok(!*session.Reserved, "Expected empty string, got %s\n", session.Reserved);
     ok(!session.FilterList, "Expected empty filter list\n");
     ok(getFileSize("dest\\a.txt") == 6, "Expected dest\\a.txt to be 6 bytes\n");
     ok(DeleteFileA("dest\\a.txt"), "Expected dest\\a.txt to exist\n");
     ok(DeleteFileA("dest\\b.txt"), "Expected dest\\b.txt to exist\n");
     ok(!DeleteFileA("dest\\testdir\\c.txt"), "Expected dest\\testdir\\c.txt to be read-only\n");
     ok(!DeleteFileA("dest\\testdir\\d.txt"), "Expected dest\\testdir\\d.txt to not exist\n");
     ok(!check_list(&node, "testdir\\d.txt", FALSE), "list entry should not exist\n");
     ok(!check_list(&node, "testdir\\c.txt", FALSE), "list entry wrong\n");
     ok(!check_list(&node, "b.txt", FALSE), "list entry wrong\n");
     ok(!check_list(&node, "a.txt", TRUE), "list entry wrong\n");
     free_file_list(&session);

     SetFileAttributesA("dest\\testdir\\c.txt", FILE_ATTRIBUTE_NORMAL);
     DeleteFileA("dest\\testdir\\c.txt");

     ok(RemoveDirectoryA("dest\\testdir"), "Expected dest\\testdir to exist\n");
     ok(RemoveDirectoryA("dest"), "Expected dest to exist\n");
 }

 START_TEST(extract)
 {
     init_function_pointers();
     create_test_files();
     create_cab_file();

     test_Extract();

     delete_test_files();
 }
CCAB::cbFolderThresh
ULONG cbFolderThresh
Definition: fci.h:146

WriteFile
BOOL WINAPI WriteFile(IN HANDLE hFile, IN LPCVOID lpBuffer, IN DWORD nNumberOfBytesToWrite OPTIONAL, OUT LPDWORD lpNumberOfBytesWritten, IN LPOVERLAPPED lpOverlapped OPTIONAL)
Definition: rw.c:24

fci_open
static INT_PTR CDECL fci_open(char *pszFile, int oflag, int pmode, int *err, void *pv)
Definition: extract.c:152

mem_alloc
static void *CDECL mem_alloc(ULONG cb)
Definition: extract.c:126

handle
namespace GUID const ADDRINFOEXW ADDRINFOEXW struct timeval OVERLAPPED LPLOOKUPSERVICE_COMPLETION_ROUTINE HANDLE * handle
Definition: sock.c:82

TRUE
#define TRUE
Definition: types.h:120

CloseHandle
#define CloseHandle
Definition: compat.h:406

fci_write
static UINT CDECL fci_write(INT_PTR hf, void *memory, UINT cb, int *err, void *pv)
Definition: extract.c:188

INVALID_SET_FILE_POINTER
#define INVALID_SET_FILE_POINTER
Definition: winbase.h:115

HRESULT_FROM_WIN32
#define HRESULT_FROM_WIN32(x)
Definition: winerror.h:92

FilterList
LIST_ENTRY FilterList
Definition: Filter.c:24

FCIFlushCabinet
BOOL __cdecl FCIFlushCabinet(HFCI hfci, BOOL fGetNextCab, PFNFCIGETNEXTCABINET pfnfcignc, PFNFCISTATUS pfnfcis)
Definition: fci.c:1675

FCICreate
HFCI __cdecl FCICreate(PERF perf, PFNFCIFILEPLACED pfnfiledest, PFNFCIALLOC pfnalloc, PFNFCIFREE pfnfree, PFNFCIOPEN pfnopen, PFNFCIREAD pfnread, PFNFCIWRITE pfnwrite, PFNFCICLOSE pfnclose, PFNFCISEEK pfnseek, PFNFCIDELETE pfndelete, PFNFCIGETTEMPFILE pfnfcigtf, PCCAB pccab, void *pv)
Definition: fci.c:998

FDIERROR_CABINET_NOT_FOUND
Definition: fdi.h:116

strlen
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269

CHAR
char CHAR
Definition: xmlstorage.h:175

FileList
vector< FileInfo > FileList
Definition: DriveVolume.h:63

file_placed
static int CDECL file_placed(PCCAB pccab, char *pszFile, LONG cbFile, BOOL fContinuation, void *pv)
Definition: extract.c:146

getFileSize
static int getFileSize(const CHAR *name)
Definition: extract.c:83

fci_delete
static int CDECL fci_delete(char *pszFile, int *err, void *pv)
Definition: extract.c:219

FCIDestroy
BOOL __cdecl FCIDestroy(HFCI hfci)
Definition: fci.c:1709

fci_seek
static LONG CDECL fci_seek(INT_PTR hf, LONG dist, int seektype, int *err, void *pv)
Definition: extract.c:208

node::next
void * next
Definition: dlist.c:360

FileCount
PULONG FileCount
Definition: SfcGetFiles.c:18

INVALID_HANDLE_VALUE
#define INVALID_HANDLE_VALUE
Definition: compat.h:399

lstrcmpA
int WINAPI lstrcmpA(LPCSTR lpString1, LPCSTR lpString2)
Definition: lstring.c:18

ZeroMemory
#define ZeroMemory
Definition: winbase.h:1642

get_next_cabinet
static BOOL CDECL get_next_cabinet(PCCAB pccab, ULONG cbPrevCab, void *pv)
Definition: extract.c:136

fdi.h

handle
Definition: rpc_generic.c:61

check_list
static BOOL check_list(struct FILELIST **node, const char *filename, BOOL do_extract)
Definition: extract.c:329

FILE_SHARE_WRITE
#define FILE_SHARE_WRITE
Definition: nt_native.h:681

CCAB
Definition: fci.h:144

INT_PTR
int32_t INT_PTR
Definition: typedefs.h:62

LPSTR
char * LPSTR
Definition: xmlstorage.h:182

filename
const char * filename
Definition: ioapi.h:135

FileTimeToLocalFileTime
BOOL WINAPI FileTimeToLocalFileTime(IN CONST FILETIME *lpFileTime, OUT LPFILETIME lpLocalFileTime)
Definition: time.c:221

E_FAIL
#define E_FAIL
Definition: ddrawi.h:102

memory
static char memory[1024 *256]
Definition: process.c:116

INT
int32_t INT
Definition: typedefs.h:56

FILE_SHARE_READ
#define FILE_SHARE_READ
Definition: compat.h:125

extract
BOOL extract(char *filename, const bin_file *bin)
Definition: mspatcha.c:158

tcompTYPE_MSZIP
#define tcompTYPE_MSZIP
Definition: fci.h:65

hCabinet
static HMODULE hCabinet
Definition: extract.c:58

CURR_DIR
static CHAR CURR_DIR[MAX_PATH]
Definition: extract.c:61

SetFilePointer
DWORD WINAPI DECLSPEC_HOTPATCH SetFilePointer(HANDLE hFile, LONG lDistanceToMove, PLONG lpDistanceToMoveHigh, DWORD dwMoveMethod)
Definition: fileinfo.c:204

test.h

node
struct node node

free_file_node
static void free_file_node(struct FILELIST *node)
Definition: extract.c:344

LPCSTR
static LPCSTR
Definition: extract.c:59

ERROR_ACCESS_DENIED
#define ERROR_ACCESS_DENIED
Definition: compat.h:87

get_temp_file
static BOOL CDECL get_temp_file(char *pszTempName, int cbTempName, void *pv)
Definition: extract.c:227

BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94

LONG
long LONG
Definition: pedump.c:60

FALSE
Definition: jmorecfg.h:365

GetFileAttributesA
DWORD WINAPI GetFileAttributesA(LPCSTR lpFileName)
Definition: fileinfo.c:786

ERF
Definition: fci.h:44

GENERIC_WRITE
#define GENERIC_WRITE
Definition: nt_native.h:90

CCAB::szCab
char szCab[CB_MAX_CABINET_NAME]
Definition: fci.h:160

CCAB::cb
ULONG cb
Definition: fci.h:145

CreateDirectoryA
BOOL WINAPI CreateDirectoryA(IN LPCSTR lpPathName, IN LPSECURITY_ATTRIBUTES lpSecurityAttributes)
Definition: dir.c:37

NULL
smooth NULL
Definition: ftsmooth.c:416

DeleteFileA
BOOL WINAPI DeleteFileA(IN LPCSTR lpFileName)
Definition: delete.c:24

SetFileAttributesA
BOOL WINAPI SetFileAttributesA(LPCSTR lpFileName, DWORD dwFileAttributes)
Definition: fileinfo.c:926

Reserved
_Reserved_ PVOID Reserved
Definition: winddi.h:3974

test_Extract
static void test_Extract(void)
Definition: extract.c:364

ERROR_FILE_NOT_FOUND
#define ERROR_FILE_NOT_FOUND
Definition: disk.h:79

OPEN_EXISTING
#define OPEN_EXISTING
Definition: compat.h:434

FILELIST::DoExtract
BOOL DoExtract
Definition: files.c:526

set_cab_parameters
static void set_cab_parameters(PCCAB pCabParams)
Definition: extract.c:286

FDIERROR_NONE
Definition: fdi.h:115

lstrcatA
LPSTR WINAPI lstrcatA(LPSTR lpString1, LPCSTR lpString2)
Definition: lstring.c:123

create_cab_file
static void create_cab_file(void)
Definition: extract.c:298

size
GLsizeiptr size
Definition: glext.h:5919

GetProcessHeap
#define GetProcessHeap()
Definition: compat.h:403

session
Definition: winhttp_private.h:78

FDIERROR_USER_ABORT
Definition: fdi.h:126

HeapAlloc
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)

GetFileInformationByHandle
BOOL WINAPI GetFileInformationByHandle(HANDLE hFile, LPBY_HANDLE_FILE_INFORMATION lpFileInformation)
Definition: fileinfo.c:608

filetime
Definition: fatfs.h:121

HRESULT
LONG HRESULT
Definition: typedefs.h:77

erf
double __cdecl erf(double)

MAX_PATH
#define MAX_PATH
Definition: compat.h:26

WINAPI
#define WINAPI
Definition: msvc.h:6

file
const char file[]
Definition: icontest.c:11

SESSION
Definition: files.c:529

FILE_ATTRIBUTE_READONLY
#define FILE_ATTRIBUTE_READONLY
Definition: nt_native.h:702

HANDLE
PVOID HANDLE
Definition: typedefs.h:71

DWORD
unsigned long DWORD
Definition: ntddk_ex.h:95

Destination
_In_ PUNICODE_STRING _Inout_ PUNICODE_STRING Destination
Definition: rtlfuncs.h:2922

Error
BOOL Error
Definition: chkdsk.c:66

GetFileSize
DWORD WINAPI GetFileSize(HANDLE hFile, LPDWORD lpFileSizeHigh)
Definition: fileinfo.c:481

INVALID_FILE_ATTRIBUTES
#define INVALID_FILE_ATTRIBUTES
Definition: vfdcmd.c:23

lstrcpyA
LPSTR WINAPI lstrcpyA(LPSTR lpString1, LPCSTR lpString2)
Definition: lstring.c:100

FILELIST::next
struct FILELIST * next
Definition: files.c:525

EXTRACT_EXTRACTFILES
#define EXTRACT_EXTRACTFILES
Definition: extract.c:37

ret
int ret
Definition: wcstombs-tests.c:31

FILE_ATTRIBUTE_NORMAL
#define FILE_ATTRIBUTE_NORMAL
Definition: compat.h:126

fci.h

_BY_HANDLE_FILE_INFORMATION::ftLastWriteTime
FILETIME ftLastWriteTime
Definition: winbase.h:614

createTestFile
static void createTestFile(const CHAR *name)
Definition: extract.c:71

len
GLenum GLsizei len
Definition: glext.h:6722

FileSize
_Must_inspect_result_ _Out_ PLARGE_INTEGER FileSize
Definition: fsrtlfuncs.h:108

GetModuleHandleA
HMODULE WINAPI DECLSPEC_HOTPATCH GetModuleHandleA(LPCSTR lpModuleName)
Definition: loader.c:821

GENERIC_READ
#define GENERIC_READ
Definition: compat.h:124

err
#define err(...)
Definition: reactos_support_code.h:30

FILELIST
Definition: files.c:523

FOLDER_THRESHOLD
#define FOLDER_THRESHOLD
Definition: extract.c:29

_BY_HANDLE_FILE_INFORMATION
Definition: winbase.h:610

create_test_files
static void create_test_files(void)
Definition: extract.c:95

init_function_pointers
static void init_function_pointers(void)
Definition: extract.c:63

FileTimeToDosDateTime
BOOL WINAPI FileTimeToDosDateTime(IN CONST FILETIME *lpFileTime, OUT LPWORD lpFatDate, OUT LPWORD lpFatTime)
Definition: time.c:37

FILELIST::FileName
LPSTR FileName
Definition: files.c:524

S_OK
#define S_OK
Definition: intsafe.h:59

CREATE_ALWAYS
#define CREATE_ALWAYS
Definition: disk.h:72

next
static unsigned __int64 next
Definition: rand_nt.c:6

lstrlenA
int WINAPI lstrlenA(LPCSTR lpString)
Definition: lstring.c:145

HRESULT
static HRESULT(WINAPI *pExtract)(SESSION *

CDECL
#define CDECL
Definition: compat.h:21

USHORT
unsigned short USHORT
Definition: pedump.c:61

FILE_FLAG_SEQUENTIAL_SCAN
#define FILE_FLAG_SEQUENTIAL_SCAN
Definition: disk.h:43

progress
static LONG CDECL progress(UINT typeStatus, ULONG cb1, ULONG cb2, void *pv)
Definition: extract.c:141

_FILETIME
Definition: mapidefs.h:59

ok
#define ok(value,...)
Definition: atltest.h:57

GetCurrentDirectoryA
DWORD WINAPI GetCurrentDirectoryA(IN DWORD nBufferLength, OUT LPSTR lpBuffer)
Definition: path.c:2145

path
Definition: wbemprox_private.h:187

RemoveDirectoryA
BOOL WINAPI RemoveDirectoryA(IN LPCSTR lpPathName)
Definition: dir.c:714

CCAB::setID
USHORT setID
Definition: fci.h:157

get_open_info
static INT_PTR CDECL get_open_info(char *pszName, USHORT *pdate, USHORT *ptime, USHORT *pattribs, int *err, void *pv)
Definition: extract.c:246

UINT
unsigned int UINT
Definition: ndis.h:50

fci_read
static UINT CDECL fci_read(INT_PTR hf, void *memory, UINT cb, int *err, void *pv)
Definition: extract.c:176

FCIAddFile
BOOL __cdecl FCIAddFile(HFCI hfci, char *pszSourceFile, char *pszFileName, BOOL fExecute, PFNFCIGETNEXTCABINET pfnfcignc, PFNFCISTATUS pfnfcis, PFNFCIGETOPENINFO pfnfcigoi, TCOMP typeCompress)
Definition: fci.c:1397

fci_close
static int CDECL fci_close(INT_PTR hf, int *err, void *pv)
Definition: extract.c:200

START_TEST
START_TEST(extract)
Definition: extract.c:716

cb
static HMODULE MODULEINFO DWORD cb
Definition: module.c:32

name
Definition: name.c:38

add_file
static void add_file(HFCI hfci, char *file)
Definition: extract.c:272

res
GLuint res
Definition: glext.h:9613

CCAB::szCabPath
char szCabPath[CB_MAX_CAB_PATH]
Definition: fci.h:161

ULONG
unsigned int ULONG
Definition: retypes.h:1

Operation
_In_ FLT_SET_CONTEXT_OPERATION Operation
Definition: fltkernel.h:1468

GetProcAddress
#define GetProcAddress(x, y)
Definition: compat.h:418

CREATE_NEW
#define CREATE_NEW
Definition: disk.h:69

CreateFileA
#define CreateFileA(a, b, c, d, e, f, g)
Definition: compat.h:407

void
Definition: nsiface.idl:2306

ReadFile
BOOL WINAPI ReadFile(IN HANDLE hFile, IN LPVOID lpBuffer, IN DWORD nNumberOfBytesToRead, OUT LPDWORD lpNumberOfBytesRead OPTIONAL, IN LPOVERLAPPED lpOverlapped OPTIONAL)
Definition: rw.c:123

mem_free
static void CDECL mem_free(void *memory)
Definition: extract.c:131

GetTempFileNameA
UINT WINAPI GetTempFileNameA(IN LPCSTR lpPathName, IN LPCSTR lpPrefixString, IN UINT uUnique, OUT LPSTR lpTempFileName)
Definition: filename.c:26

HeapFree
#define HeapFree(x, y, z)
Definition: compat.h:402

EXTRACT_FILLFILELIST
#define EXTRACT_FILLFILELIST
Definition: extract.c:36

free_file_list
static void free_file_list(SESSION *session)
Definition: extract.c:350

MEDIA_SIZE
#define MEDIA_SIZE
Definition: extract.c:28

delete_test_files
static void delete_test_files(void)
Definition: extract.c:113

node
Definition: dlist.c:348

file
Definition: fci.c:126