jscript: Added Dll[Un]RegisterServer implementation.
[wine] / 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 *mem_alloc(ULONG cb)
73 {
74     return HeapAlloc(GetProcessHeap(), 0, cb);
75 }
76
77 static void mem_free(void *memory)
78 {
79     HeapFree(GetProcessHeap(), 0, memory);
80 }
81
82 static INT_PTR 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 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 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 fdi_close(INT_PTR hf)
146 {
147     HANDLE handle = (HANDLE) hf;
148     return CloseHandle(handle) ? 0 : -1;
149 }
150
151 static long 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 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                     CreateDirectoryA(szDirectory, NULL);
241
242                 hFile = CreateFileA(szFullPath, GENERIC_READ | GENERIC_WRITE, 0, NULL,
243                                     CREATE_NEW, FILE_ATTRIBUTE_NORMAL, NULL);
244
245                 if (hFile == INVALID_HANDLE_VALUE)
246                     hFile = 0;
247                 else if (node)
248                     node->DoExtract = FALSE;
249             }
250
251             HeapFree(GetProcessHeap(), 0, szFullPath);
252             HeapFree(GetProcessHeap(), 0, szDirectory);
253
254             return (INT_PTR) hFile;
255         }
256
257         case fdintCLOSE_FILE_INFO:
258         {
259             FILETIME ft;
260             FILETIME ftLocal;
261             HANDLE handle = (HANDLE) pfdin->hf;
262
263             if (!DosDateTimeToFileTime(pfdin->date, pfdin->time, &ft))
264                 return FALSE;
265
266             if (!LocalFileTimeToFileTime(&ft, &ftLocal))
267                 return FALSE;
268
269             if (!SetFileTime(handle, &ftLocal, 0, &ftLocal))
270                 return FALSE;
271
272             CloseHandle(handle);
273             return TRUE;
274         }
275
276         default:
277             return 0;
278     }
279 }
280
281 /***********************************************************************
282  * Extract (CABINET.3)
283  *
284  * Extracts the contents of the cabinet file to the specified
285  * destination.
286  *
287  * PARAMS
288  *   dest      [I/O] Controls the operation of Extract.  See NOTES.
289  *   szCabName [I] Filename of the cabinet to extract.
290  *
291  * RETURNS
292  *     Success: S_OK.
293  *     Failure: E_FAIL.
294  *
295  * NOTES
296  *   The following members of the dest struct control the operation
297  *   of Extract:
298  *       FileSize    [O] The size of all files extracted up to CurrentFile.
299  *       Error       [O] The error in case the extract operation fails.
300  *       FileList    [I] A linked list of filenames.  Extract only extracts
301  *                       files from the cabinet that are in this list.
302  *       FileCount   [O] Contains the number of files in FileList on
303  *                       completion.
304  *       Operation   [I] See Operation.
305  *       Destination [I] The destination directory.
306  *       CurrentFile [O] The last file extracted.
307  *       FilterList  [I] A linked list of files that should not be extracted.
308  *
309  *   Operation
310  *     If Operation contains EXTRACT_FILLFILELIST, then FileList will be
311  *     filled with all the files in the cabinet.  If Operation contains
312  *     EXTRACT_EXTRACTFILES, then only the files in the FileList will
313  *     be extracted from the cabinet.  EXTRACT_FILLFILELIST can be called
314  *     by itself, but EXTRACT_EXTRACTFILES must have a valid FileList
315  *     in order to succeed.  If Operation contains both EXTRACT_FILLFILELIST
316  *     and EXTRACT_EXTRACTFILES, then all the files in the cabinet
317  *     will be extracted.
318  */
319 HRESULT WINAPI Extract(SESSION *dest, LPCSTR szCabName)
320 {
321     HRESULT res = S_OK;
322     HFDI hfdi;
323     char *str, *path, *name;
324
325     TRACE("(%p, %s)\n", dest, szCabName);
326
327     hfdi = FDICreate(mem_alloc,
328                      mem_free,
329                      fdi_open,
330                      fdi_read,
331                      fdi_write,
332                      fdi_close,
333                      fdi_seek,
334                      cpuUNKNOWN,
335                      &dest->Error);
336
337     if (!hfdi)
338         return E_FAIL;
339
340     if (GetFileAttributesA(dest->Destination) == INVALID_FILE_ATTRIBUTES)
341         return S_OK;
342
343     /* split the cabinet name into path + name */
344     str = HeapAlloc(GetProcessHeap(), 0, lstrlenA(szCabName)+1);
345     if (!str)
346     {
347         res = E_OUTOFMEMORY;
348         goto end;
349     }
350     lstrcpyA(str, szCabName);
351
352     path = str;
353     name = strrchr(path, '\\');
354     if (name)
355         *name++ = 0;
356     else
357     {
358         name = path;
359         path = NULL;
360     }
361
362     dest->FileSize = 0;
363
364     if (!FDICopy(hfdi, name, path, 0,
365          fdi_notify_extract, NULL, dest))
366         res = HRESULT_FROM_WIN32(GetLastError());
367
368     HeapFree(GetProcessHeap(), 0, str);
369 end:
370
371     FDIDestroy(hfdi);
372
373     return res;
374 }