dlls/cabinet/cabinet_main.c

   1 /*
   2  * cabinet.dll main
   3  *
   4  * Copyright 2002 Patrik Stridvall
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22
  23 #include <assert.h>
  24 #include <stdarg.h>
  25 #include <string.h>
  26
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "winerror.h"
  30 #define NO_SHLWAPI_REG
  31 #include "shlwapi.h"
  32 #undef NO_SHLWAPI_REG
  33
  34 #include "cabinet.h"
  35
  36 #include "wine/debug.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(cabinet);
  39
  40
  41 /***********************************************************************
  42  * DllGetVersion (CABINET.2)
  43  *
  44  * Retrieves version information of the 'CABINET.DLL'
  45  *
  46  * PARAMS
  47  *     pdvi [O] pointer to version information structure.
  48  *
  49  * RETURNS
  50  *     Success: S_OK
  51  *     Failure: E_INVALIDARG
  52  *
  53  * NOTES
  54  *     Supposedly returns version from IE6SP1RP1
  55  */
  56 HRESULT WINAPI DllGetVersion (DLLVERSIONINFO *pdvi)
  57 {
  58   WARN("hmmm... not right version number \"5.1.1106.1\"?\n");
  59
  60   if (pdvi->cbSize != sizeof(DLLVERSIONINFO)) return E_INVALIDARG;
  61
  62   pdvi->dwMajorVersion = 5;
  63   pdvi->dwMinorVersion = 1;
  64   pdvi->dwBuildNumber = 1106;
  65   pdvi->dwPlatformID = 1;
  66
  67   return S_OK;
  68 }
  69
  70 /* FDI callback functions */
  71
  72 static void * CDECL mem_alloc(ULONG cb)
  73 {
  74     return HeapAlloc(GetProcessHeap(), 0, cb);
  75 }
  76
  77 static void CDECL mem_free(void *memory)
  78 {
  79     HeapFree(GetProcessHeap(), 0, memory);
  80 }
  81
  82 static INT_PTR CDECL fdi_open(char *pszFile, int oflag, int pmode)
  83 {
  84     HANDLE handle;
  85     DWORD dwAccess = 0;
  86     DWORD dwShareMode = 0;
  87     DWORD dwCreateDisposition;
  88
  89     switch (oflag & _O_ACCMODE)
  90     {
  91         case _O_RDONLY:
  92             dwAccess = GENERIC_READ;
  93             dwShareMode = FILE_SHARE_READ | FILE_SHARE_DELETE;
  94             break;
  95         case _O_WRONLY:
  96             dwAccess = GENERIC_WRITE;
  97             dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE;
  98             break;
  99         case _O_RDWR:
 100             dwAccess = GENERIC_READ | GENERIC_WRITE;
 101             dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE;
 102             break;
 103     }
 104
 105     if (oflag & _O_CREAT)
 106     {
 107         dwCreateDisposition = OPEN_ALWAYS;
 108         if (oflag & _O_EXCL) dwCreateDisposition = CREATE_NEW;
 109         else if (oflag & _O_TRUNC) dwCreateDisposition = CREATE_ALWAYS;
 110     }
 111     else
 112     {
 113         dwCreateDisposition = OPEN_EXISTING;
 114         if (oflag & _O_TRUNC) dwCreateDisposition = TRUNCATE_EXISTING;
 115     }
 116
 117     handle = CreateFileA(pszFile, dwAccess, dwShareMode, NULL,
 118                          dwCreateDisposition, 0, NULL);
 119
 120     return (INT_PTR) handle;
 121 }
 122
 123 static UINT CDECL fdi_read(INT_PTR hf, void *pv, UINT cb)
 124 {
 125     HANDLE handle = (HANDLE) hf;
 126     DWORD dwRead;
 127
 128     if (ReadFile(handle, pv, cb, &dwRead, NULL))
 129         return dwRead;
 130
 131     return 0;
 132 }
 133
 134 static UINT CDECL fdi_write(INT_PTR hf, void *pv, UINT cb)
 135 {
 136     HANDLE handle = (HANDLE) hf;
 137     DWORD dwWritten;
 138
 139     if (WriteFile(handle, pv, cb, &dwWritten, NULL))
 140         return dwWritten;
 141
 142     return 0;
 143 }
 144
 145 static int CDECL fdi_close(INT_PTR hf)
 146 {
 147     HANDLE handle = (HANDLE) hf;
 148     return CloseHandle(handle) ? 0 : -1;
 149 }
 150
 151 static LONG CDECL fdi_seek(INT_PTR hf, LONG dist, int seektype)
 152 {
 153     HANDLE handle = (HANDLE) hf;
 154     return SetFilePointer(handle, dist, NULL, seektype);
 155 }
 156
 157 static void fill_file_node(struct FILELIST *pNode, LPCSTR szFilename)
 158 {
 159     pNode->next = NULL;
 160     pNode->DoExtract = FALSE;
 161
 162     pNode->FileName = HeapAlloc(GetProcessHeap(), 0, strlen(szFilename) + 1);
 163     lstrcpyA(pNode->FileName, szFilename);
 164 }
 165
 166 static BOOL file_in_list(struct FILELIST *pNode, LPCSTR szFilename,
 167                          struct FILELIST **pOut)
 168 {
 169     while (pNode)
 170     {
 171         if (!lstrcmpiA(pNode->FileName, szFilename))
 172         {
 173             if (pOut)
 174                 *pOut = pNode;
 175
 176             return TRUE;
 177         }
 178
 179         pNode = pNode->next;
 180     }
 181
 182     return FALSE;
 183 }
 184
 185 static INT_PTR CDECL fdi_notify_extract(FDINOTIFICATIONTYPE fdint, PFDINOTIFICATION pfdin)
 186 {
 187     switch (fdint)
 188     {
 189         case fdintCOPY_FILE:
 190         {
 191             struct FILELIST *fileList, *node = NULL;
 192             SESSION *pDestination = pfdin->pv;
 193             LPSTR szFullPath, szDirectory;
 194             HANDLE hFile = 0;
 195             DWORD dwSize;
 196
 197             dwSize = lstrlenA(pDestination->Destination) +
 198                     lstrlenA("\\") + lstrlenA(pfdin->psz1) + 1;
 199             szFullPath = HeapAlloc(GetProcessHeap(), 0, dwSize);
 200
 201             lstrcpyA(szFullPath, pDestination->Destination);
 202             lstrcatA(szFullPath, "\\");
 203             lstrcatA(szFullPath, pfdin->psz1);
 204
 205             /* pull out the destination directory string from the full path */
 206             dwSize = strrchr(szFullPath, '\\') - szFullPath + 1;
 207             szDirectory = HeapAlloc(GetProcessHeap(), 0, dwSize);
 208             lstrcpynA(szDirectory, szFullPath, dwSize);
 209
 210             pDestination->FileSize += pfdin->cb;
 211
 212             if (pDestination->Operation & EXTRACT_FILLFILELIST)
 213             {
 214                 fileList = HeapAlloc(GetProcessHeap(), 0,
 215                                      sizeof(struct FILELIST));
 216
 217                 fill_file_node(fileList, pfdin->psz1);
 218                 fileList->DoExtract = TRUE;
 219                 fileList->next = pDestination->FileList;
 220                 pDestination->FileList = fileList;
 221                 lstrcpyA(pDestination->CurrentFile, szFullPath);
 222                 pDestination->FileCount++;
 223             }
 224
 225             if ((pDestination->Operation & EXTRACT_EXTRACTFILES) ||
 226                 file_in_list(pDestination->FilterList, pfdin->psz1, NULL))
 227             {
 228                 /* find the file node */
 229                 file_in_list(pDestination->FileList, pfdin->psz1, &node);
 230
 231                 if (node && !node->DoExtract)
 232                 {
 233                     HeapFree(GetProcessHeap(), 0, szFullPath);
 234                     HeapFree(GetProcessHeap(), 0, szDirectory);
 235                     return 0;
 236                 }
 237
 238                 /* create the destination directory if it doesn't exist */
 239                 if (GetFileAttributesA(szDirectory) == INVALID_FILE_ATTRIBUTES)
 240                 {
 241                     char *ptr;
 242
 243                     for(ptr = szDirectory + strlen(pDestination->Destination)+1; *ptr; ptr++) {
 244                         if(*ptr == '\\') {
 245                             *ptr = 0;
 246                             CreateDirectoryA(szDirectory, NULL);
 247                             *ptr = '\\';
 248                         }
 249                     }
 250                     CreateDirectoryA(szDirectory, NULL);
 251                 }
 252
 253                 hFile = CreateFileA(szFullPath, GENERIC_READ | GENERIC_WRITE, 0, NULL,
 254                                     CREATE_NEW, FILE_ATTRIBUTE_NORMAL, NULL);
 255
 256                 if (hFile == INVALID_HANDLE_VALUE)
 257                     hFile = 0;
 258                 else if (node)
 259                     node->DoExtract = FALSE;
 260             }
 261
 262             HeapFree(GetProcessHeap(), 0, szFullPath);
 263             HeapFree(GetProcessHeap(), 0, szDirectory);
 264
 265             return (INT_PTR) hFile;
 266         }
 267
 268         case fdintCLOSE_FILE_INFO:
 269         {
 270             FILETIME ft;
 271             FILETIME ftLocal;
 272             HANDLE handle = (HANDLE) pfdin->hf;
 273
 274             if (!DosDateTimeToFileTime(pfdin->date, pfdin->time, &ft))
 275                 return FALSE;
 276
 277             if (!LocalFileTimeToFileTime(&ft, &ftLocal))
 278                 return FALSE;
 279
 280             if (!SetFileTime(handle, &ftLocal, 0, &ftLocal))
 281                 return FALSE;
 282
 283             CloseHandle(handle);
 284             return TRUE;
 285         }
 286
 287         default:
 288             return 0;
 289     }
 290 }
 291
 292 /***********************************************************************
 293  * Extract (CABINET.3)
 294  *
 295  * Extracts the contents of the cabinet file to the specified
 296  * destination.
 297  *
 298  * PARAMS
 299  *   dest      [I/O] Controls the operation of Extract.  See NOTES.
 300  *   szCabName [I] Filename of the cabinet to extract.
 301  *
 302  * RETURNS
 303  *     Success: S_OK.
 304  *     Failure: E_FAIL.
 305  *
 306  * NOTES
 307  *   The following members of the dest struct control the operation
 308  *   of Extract:
 309  *       FileSize    [O] The size of all files extracted up to CurrentFile.
 310  *       Error       [O] The error in case the extract operation fails.
 311  *       FileList    [I] A linked list of filenames.  Extract only extracts
 312  *                       files from the cabinet that are in this list.
 313  *       FileCount   [O] Contains the number of files in FileList on
 314  *                       completion.
 315  *       Operation   [I] See Operation.
 316  *       Destination [I] The destination directory.
 317  *       CurrentFile [O] The last file extracted.
 318  *       FilterList  [I] A linked list of files that should not be extracted.
 319  *
 320  *   Operation
 321  *     If Operation contains EXTRACT_FILLFILELIST, then FileList will be
 322  *     filled with all the files in the cabinet.  If Operation contains
 323  *     EXTRACT_EXTRACTFILES, then only the files in the FileList will
 324  *     be extracted from the cabinet.  EXTRACT_FILLFILELIST can be called
 325  *     by itself, but EXTRACT_EXTRACTFILES must have a valid FileList
 326  *     in order to succeed.  If Operation contains both EXTRACT_FILLFILELIST
 327  *     and EXTRACT_EXTRACTFILES, then all the files in the cabinet
 328  *     will be extracted.
 329  */
 330 HRESULT WINAPI Extract(SESSION *dest, LPCSTR szCabName)
 331 {
 332     HRESULT res = S_OK;
 333     HFDI hfdi;
 334     char *str, *end, *path = NULL, *name = NULL;
 335
 336     TRACE("(%p, %s)\n", dest, szCabName);
 337
 338     hfdi = FDICreate(mem_alloc,
 339                      mem_free,
 340                      fdi_open,
 341                      fdi_read,
 342                      fdi_write,
 343                      fdi_close,
 344                      fdi_seek,
 345                      cpuUNKNOWN,
 346                      &dest->Error);
 347
 348     if (!hfdi)
 349         return E_FAIL;
 350
 351     if (GetFileAttributesA(dest->Destination) == INVALID_FILE_ATTRIBUTES)
 352     {
 353         res = S_OK;
 354         goto end;
 355     }
 356
 357     /* split the cabinet name into path + name */
 358     str = HeapAlloc(GetProcessHeap(), 0, lstrlenA(szCabName)+1);
 359     if (!str)
 360     {
 361         res = E_OUTOFMEMORY;
 362         goto end;
 363     }
 364     lstrcpyA(str, szCabName);
 365
 366     if ((end = strrchr(str, '\\')))
 367     {
 368         end++;
 369         name = HeapAlloc( GetProcessHeap(), 0, strlen(end) + 1 );
 370         if (!name)
 371         {
 372             res = E_OUTOFMEMORY;
 373             goto end;
 374         }
 375         strcpy( name, end );
 376         *end = 0;
 377         path = str;
 378     }
 379     else
 380     {
 381         name = str;
 382         path = NULL;
 383     }
 384
 385     dest->FileSize = 0;
 386
 387     if (!FDICopy(hfdi, name, path, 0,
 388          fdi_notify_extract, NULL, dest))
 389         res = HRESULT_FROM_WIN32(GetLastError());
 390
 391 end:
 392     HeapFree(GetProcessHeap(), 0, path);
 393     HeapFree(GetProcessHeap(), 0, name);
 394     FDIDestroy(hfdi);
 395     return res;
 396 }