static int list_cabinet( char *cab_dir ) { ERF erf; int ret = 0; HFDI fdi = FDICreate( cab_alloc, cab_free, fdi_open, fdi_read, fdi_write, fdi_close, fdi_lseek, cpuUNKNOWN, &erf ); if (!FDICopy( fdi, opt_cab_file, cab_dir, 0, list_notify, NULL, NULL )) ret = GetLastError(); FDIDestroy( fdi ); return ret; }
/** * ExtractCabResource **/ UINT __fastcall ExtractCabResource( PSTR pszOutputPath, PSTR pszOutputPathAppend ) { ERF erf; EXTRACTDATA ed = { pszOutputPath, // PSTR pszOutputPath pszOutputPathAppend, // PSTR pszOutputPathAppend 0 // UINT uExtractedFiles }; HFDI hfdi = FDICreate( fdimalloc, fdifree, fdiopen, fdiread, fdiwrite, fdiclose, fdiseek, cpuUNKNOWN, &erf ); if (hfdi) { FDICopy(hfdi, "0", pszOutputPath, 0, fdiNotify, NULL, &ed); FDIDestroy(hfdi); } return(ed.uExtractedFiles); }
PVOID SfcabExtractMemory( PVOID CabPtr, ULONG CabSize, PULONG ExtractedBytes ) { HFDI hfdi; ERF erf; CHAR text[32]; CHAR name[1]; PVOID Buffer = NULL; CABDATA Data; if (ExtractedBytes == NULL) return NULL; __try { RtlSecureZeroMemory(&erf, sizeof(ERF)); hfdi = FDICreate((PFNALLOC)fdiAlloc, (PFNFREE)fdiFree, (PFNOPEN)fdiOpen, (PFNREAD)fdiRead, (PFNWRITE)fdiWrite, (PFNCLOSE)fdiClose, (PFNSEEK)fdiSeek, cpu80386, &erf); if (hfdi) { g_CabParam.Buffer = CabPtr; g_CabParam.Size = CabSize; g_CabParam.Offset = 0; RtlSecureZeroMemory(&text, sizeof(text)); #ifdef _WIN64 u64tostr_a((ULONG_PTR)&g_CabParam, text); #else ultostr_a((ULONG_PTR)&g_CabParam, text); #endif name[0] = 0; Data.Size = '_'; Data.Buffer = NULL; Data.Offset = 0; if (FDICopy(hfdi, name, text, 0, fdiNotify, 0, &Data)) { Buffer = Data.Buffer; *ExtractedBytes = Data.Size; } FDIDestroy(hfdi); } } __except (EXCEPTION_EXECUTE_HANDLER) { return NULL; } return Buffer; }
/*********************************************************************** * extract_cabinet_file * * Extract files from a cab file. */ static BOOL extract_cabinet_file(MSIPACKAGE* package, LPCWSTR source, LPCWSTR path) { HFDI hfdi; ERF erf; BOOL ret; char *cabinet; char *cab_path; CabData data; TRACE("Extracting %s to %s\n",debugstr_w(source), debugstr_w(path)); hfdi = FDICreate(cabinet_alloc, cabinet_free, cabinet_open, cabinet_read, cabinet_write, cabinet_close, cabinet_seek, 0, &erf); if (!hfdi) { ERR("FDICreate failed\n"); return FALSE; } if (!(cabinet = strdupWtoA( source ))) { FDIDestroy(hfdi); return FALSE; } if (!(cab_path = strdupWtoA( path ))) { FDIDestroy(hfdi); msi_free(cabinet); return FALSE; } data.package = package; data.cab_path = cab_path; ret = FDICopy(hfdi, cabinet, "", 0, cabinet_notify, NULL, &data); if (!ret) ERR("FDICopy failed\n"); FDIDestroy(hfdi); msi_free(cabinet); msi_free(cab_path); return ret; }
bool MsCab::extractFiles(LPWSTR pstrPath, LPWSTR pstrFile, FDICOPYFILECALLBACK copyCallback, void *data) { bool r = false; void *p; if((p = FDICreate(copyCallback, data)) != NULL) { r = FDICopy(p, pstrPath, pstrFile); FDIClose(p); } return r; }
static int extract_cabinet( char *cab_dir ) { ERF erf; int ret = 0; HFDI fdi = FDICreate( cab_alloc, cab_free, fdi_open, fdi_read, fdi_write, fdi_close, fdi_lseek, cpuUNKNOWN, &erf ); if (!FDICopy( fdi, opt_cab_file, cab_dir, 0, extract_notify, NULL, NULL )) { ret = GetLastError(); WINE_WARN("FDICopy() failed: code %u\n", ret); } FDIDestroy( fdi ); return ret; }
/*********************************************************************** * extract_cabinet_file * * Extract files from a cab file. */ static BOOL extract_cabinet_file(MSIPACKAGE* package, struct media_info *mi) { LPSTR cabinet, cab_path = NULL; LPWSTR ptr; HFDI hfdi; ERF erf; BOOL ret = FALSE; CabData data; TRACE("Extracting %s\n", debugstr_w(mi->source)); hfdi = FDICreate(cabinet_alloc, cabinet_free, cabinet_open, cabinet_read, cabinet_write, cabinet_close, cabinet_seek, 0, &erf); if (!hfdi) { ERR("FDICreate failed\n"); return FALSE; } ptr = strrchrW(mi->source, '\\') + 1; cabinet = strdupWtoA(ptr); if (!cabinet) goto done; cab_path = strdupWtoA(mi->source); if (!cab_path) goto done; cab_path[ptr - mi->source] = '\0'; data.package = package; data.mi = mi; ret = FDICopy(hfdi, cabinet, cab_path, 0, cabinet_notify, NULL, &data); if (!ret) ERR("FDICopy failed\n"); done: FDIDestroy(hfdi); msi_free(cabinet); msi_free(cab_path); if (ret) mi->is_extracted = TRUE; return ret; }
static void test_FDICopy(void) { CCAB cabParams; HFDI hfdi; HFCI hfci; ERF erf; BOOL ret; char name[] = "extract.cab"; char path[MAX_PATH + 1]; GetCurrentDirectoryA(MAX_PATH, path); 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); ret = FCIFlushCabinet(hfci, FALSE, get_next_cabinet, progress); ok(ret, "Failed to flush the cabinet\n"); FCIDestroy(hfci); hfdi = FDICreate(fdi_alloc, fdi_free, fdi_open, fdi_read, fdi_write, fdi_close, fdi_seek, cpuUNKNOWN, &erf); /* cabinet with no files or folders */ SetLastError(0xdeadbeef); ret = FDICopy(hfdi, name, path, 0, CopyProgress, NULL, 0); ok(ret == FALSE, "Expected FALSE, got %d\n", ret); todo_wine { ok(GetLastError() == ERROR_INVALID_HANDLE, "Expected ERROR_INVALID_HANDLE, got %d\n", GetLastError()); } FDIDestroy(hfdi); DeleteFileA(name); }
uint STDCALL gcabd_copy( HFDI hfdi, pubyte name, pubyte path, pdecabinfo pdecab ) { return FDICopy( hfdi, name, path, 0, decab_notify, NULL, ( pvoid )pdecab ); }
INT ExpandDiamondFile( IN NOTIFYPROC ExpandNotify, IN PSTR SourceFileName, IN PSTR TargetFileName, IN BOOL RenameTarget, OUT PLZINFO pLZI ) { BOOL b; INT rc; int h; DIAMOND_INFO DiamondInfo; if(!FdiContext) { return(LZERROR_BADVALUE); } DiamondLastIoError = TRUE; // // Get a handle to the source to use to // copy the date and time stamp. // h = SpdFdiOpen(SourceFileName,_O_RDONLY,0); if(h == -1) { return(LZERROR_BADINHANDLE); } pLZI->cblInSize = GetFileSize((HANDLE)h,NULL); if(pLZI->cblInSize == -1) { SpdFdiClose(h); return(LZERROR_BADINHANDLE); } DiamondInfo.SourceFileHandle = h; DiamondInfo.SourceFileName = SourceFileName; DiamondInfo.TargetFileName = TargetFileName; DiamondInfo.RenameTargetFile = RenameTarget; DiamondInfo.ExpandNotify = ExpandNotify; DiamondInfo.pLZI = pLZI; b = FDICopy( FdiContext, SourceFileName, // pass the whole path as the name "", // don't bother with the path part 0, // flags DiamondNotifyFunction, NULL, // no decryption &DiamondInfo ); if(b) { rc = TRUE; } else { switch(FdiError.erfOper) { case FDIERROR_CORRUPT_CABINET: case FDIERROR_UNKNOWN_CABINET_VERSION: case FDIERROR_BAD_COMPR_TYPE: rc = LZERROR_READ; // causes SID_FORMAT_ERROR message break; case FDIERROR_ALLOC_FAIL: rc = LZERROR_GLOBALLOC; break; case FDIERROR_TARGET_FILE: case FDIERROR_USER_ABORT: rc = DiamondLastIoError; break; default: // // The rest of the errors are not handled specially. // rc = LZERROR_BADVALUE; break; } // // Remove the partial target file. // DeleteFile(TargetFileName); } SpdFdiClose(h); return(rc); }
/*********************************************************************** * Extract (CABINET.3) * * Extracts the contents of the cabinet file to the specified * destination. * * PARAMS * dest [I/O] Controls the operation of Extract. See NOTES. * szCabName [I] Filename of the cabinet to extract. * * RETURNS * Success: S_OK. * Failure: E_FAIL. * * NOTES * The following members of the dest struct control the operation * of Extract: * FileSize [O] The size of all files extracted up to CurrentFile. * Error [O] The error in case the extract operation fails. * FileList [I] A linked list of filenames. Extract only extracts * files from the cabinet that are in this list. * FileCount [O] Contains the number of files in FileList on * completion. * Operation [I] See Operation. * Destination [I] The destination directory. * CurrentFile [O] The last file extracted. * FilterList [I] A linked list of files that should not be extracted. * * Operation * If Operation contains EXTRACT_FILLFILELIST, then FileList will be * filled with all the files in the cabinet. If Operation contains * EXTRACT_EXTRACTFILES, then only the files in the FileList will * be extracted from the cabinet. EXTRACT_FILLFILELIST can be called * by itself, but EXTRACT_EXTRACTFILES must have a valid FileList * in order to succeed. If Operation contains both EXTRACT_FILLFILELIST * and EXTRACT_EXTRACTFILES, then all the files in the cabinet * will be extracted. */ HRESULT WINAPI Extract(SESSION *dest, LPCSTR szCabName) { HRESULT res = S_OK; HFDI hfdi; char *str, *end, *path = NULL, *name = NULL; TRACE("(%p, %s)\n", dest, debugstr_a(szCabName)); hfdi = FDICreate(mem_alloc, mem_free, fdi_open, fdi_read, fdi_write, fdi_close, fdi_seek, cpuUNKNOWN, &dest->Error); if (!hfdi) return E_FAIL; if (GetFileAttributesA(dest->Destination) == INVALID_FILE_ATTRIBUTES) { res = S_OK; goto end; } /* split the cabinet name into path + name */ str = HeapAlloc(GetProcessHeap(), 0, lstrlenA(szCabName)+1); if (!str) { res = E_OUTOFMEMORY; goto end; } lstrcpyA(str, szCabName); if ((end = strrchr(str, '\\'))) { path = str; end++; name = HeapAlloc( GetProcessHeap(), 0, strlen(end) + 1 ); if (!name) { res = E_OUTOFMEMORY; goto end; } strcpy( name, end ); *end = 0; } else { name = str; path = NULL; } dest->FileSize = 0; if (!FDICopy(hfdi, name, path, 0, fdi_notify_extract, NULL, dest)) res = HRESULT_FROM_WIN32(GetLastError()); end: HeapFree(GetProcessHeap(), 0, path); HeapFree(GetProcessHeap(), 0, name); FDIDestroy(hfdi); return res; }