Update winfile and write to most recent Wine Version.
[reactos.git] / reactos / dll / win32 / 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 }