msvcrt: Corrected the .spec definition for the printf functions family.
[wine] / dlls / setupapi / setupcab.c
1 /* 
2  * Setupapi cabinet routines
3  *
4  * Copyright 2003 Gregory M. Turner
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  * Many useful traces are commented in code, uncomment them if you have
22  * trouble and run with WINEDEBUG=+setupapi
23  * 
24  */
25
26 #include <stdarg.h>
27 #include <string.h>
28 #include <stdlib.h>
29
30 #include "windef.h"
31 #include "winbase.h"
32 #include "wingdi.h"
33 #include "winuser.h"
34 #include "winnls.h"
35 #include "winreg.h"
36 #include "setupapi.h"
37 #include "setupapi_private.h"
38 #include "fdi.h"
39 #include "wine/unicode.h"
40
41 #include "msvcrt/fcntl.h"
42 #include "msvcrt/share.h"
43
44 #include "wine/debug.h"
45
46 OSVERSIONINFOW OsVersionInfo;
47
48 static HINSTANCE CABINET_hInstance = 0;
49
50 static HFDI (__cdecl *sc_FDICreate)(PFNALLOC, PFNFREE, PFNOPEN,
51                 PFNREAD, PFNWRITE, PFNCLOSE, PFNSEEK, int, PERF);
52
53 static BOOL (__cdecl *sc_FDICopy)(HFDI, char *, char *, int,
54                 PFNFDINOTIFY, PFNFDIDECRYPT, void *);
55
56 static BOOL (__cdecl *sc_FDIDestroy)(HFDI);
57
58 #define SC_HSC_A_MAGIC 0xACABFEED
59 typedef struct {
60   UINT magic;
61   HFDI hfdi;
62   PSP_FILE_CALLBACK_A msghandler;
63   PVOID context;
64   CHAR most_recent_cabinet_name[MAX_PATH];
65 } SC_HSC_A, *PSC_HSC_A;
66
67 #define SC_HSC_W_MAGIC 0x0CABFEED
68 typedef struct {
69   UINT magic;
70   HFDI hfdi;
71   PSP_FILE_CALLBACK_W msghandler;
72   PVOID context;
73   WCHAR most_recent_cabinet_name[MAX_PATH];
74 } SC_HSC_W, *PSC_HSC_W;
75
76 WINE_DEFAULT_DEBUG_CHANNEL(setupapi);
77
78 static BOOL LoadCABINETDll(void)
79 {
80   if (!CABINET_hInstance) {
81     CABINET_hInstance = LoadLibraryA("cabinet.dll");
82     if (CABINET_hInstance)  {
83       sc_FDICreate = (void *)GetProcAddress(CABINET_hInstance, "FDICreate");
84       sc_FDICopy = (void *)GetProcAddress(CABINET_hInstance, "FDICopy");
85       sc_FDIDestroy = (void *)GetProcAddress(CABINET_hInstance, "FDIDestroy");
86       return TRUE;
87     } else {
88       ERR("load cabinet dll failed.\n");
89       return FALSE;
90     }
91   } else
92     return TRUE;
93 }
94
95 static void UnloadCABINETDll(void)
96 {
97   if (CABINET_hInstance) {
98     FreeLibrary(CABINET_hInstance);
99     CABINET_hInstance = 0;
100   }
101 }
102
103 /* FDICreate callbacks */
104
105 static void *sc_cb_alloc(ULONG cb)
106 {
107   return HeapAlloc(GetProcessHeap(), 0, cb);
108 }
109
110 static void sc_cb_free(void *pv)
111 {
112   HeapFree(GetProcessHeap(), 0, pv);
113 }
114
115 static INT_PTR sc_cb_open(char *pszFile, int oflag, int pmode)
116 {
117   DWORD creation = 0, sharing = 0;
118   int ioflag = 0;
119   INT_PTR ret = 0;
120   SECURITY_ATTRIBUTES sa;
121
122   /* TRACE("(pszFile == %s, oflag == %d, pmode == %d)\n", debugstr_a(pszFile), oflag, pmode); */
123
124   switch(oflag & (_O_RDONLY | _O_WRONLY | _O_RDWR)) {
125   case _O_RDONLY:
126     ioflag |= GENERIC_READ;
127     break;
128   case _O_WRONLY:
129     ioflag |= GENERIC_WRITE;
130     break;
131   case _O_RDWR:
132     ioflag |= GENERIC_READ & GENERIC_WRITE;
133     break;
134   case _O_WRONLY | _O_RDWR: /* hmmm.. */
135     ERR("_O_WRONLY & _O_RDWR in oflag?\n");
136     return -1;
137   }
138
139   if (oflag & _O_CREAT) {
140     if (oflag & _O_EXCL)
141       creation = CREATE_NEW;
142     else if (oflag & _O_TRUNC)
143       creation = CREATE_ALWAYS;
144     else
145       creation = OPEN_ALWAYS;
146   } else  /* no _O_CREAT */ {
147     if (oflag & _O_TRUNC)
148       creation = TRUNCATE_EXISTING;
149     else
150       creation = OPEN_EXISTING;
151   }
152
153   switch( pmode & 0x70 ) {
154     case _SH_DENYRW:
155       sharing = 0L;
156       break;
157     case _SH_DENYWR:
158       sharing = FILE_SHARE_READ;
159       break;
160     case _SH_DENYRD:
161       sharing = FILE_SHARE_WRITE;
162       break;
163     case _SH_COMPAT:
164     case _SH_DENYNO:
165       sharing = FILE_SHARE_READ | FILE_SHARE_WRITE;
166       break;
167     default:
168       ERR("<-- -1 (Unhandled pmode 0x%x)\n", pmode);
169       return -1;
170   }
171
172   if (oflag & ~(_O_BINARY | _O_TRUNC | _O_EXCL | _O_CREAT | _O_RDWR | _O_WRONLY | _O_NOINHERIT))
173     WARN("unsupported oflag 0x%04x\n",oflag);
174
175   sa.nLength              = sizeof( SECURITY_ATTRIBUTES );
176   sa.lpSecurityDescriptor = NULL;
177   sa.bInheritHandle       = (ioflag & _O_NOINHERIT) ? FALSE : TRUE;
178
179   ret = (INT_PTR) CreateFileA(pszFile, ioflag, sharing, &sa, creation, FILE_ATTRIBUTE_NORMAL, NULL);
180
181   /* TRACE("<-- %d\n", ret); */
182
183   return ret;
184 }
185
186 static UINT sc_cb_read(INT_PTR hf, void *pv, UINT cb)
187 {
188   DWORD num_read;
189   BOOL rslt;
190
191   /* TRACE("(hf == %d, pv == ^%p, cb == %u)\n", hf, pv, cb); */
192
193   rslt = ReadFile((HANDLE) hf, pv, cb, &num_read, NULL);
194
195
196   /* eof and failure both give "-1" return */
197   if ((! rslt) || ((cb > 0) && (num_read == 0))) {
198     /* TRACE("<-- -1\n"); */
199     return -1;
200   }
201
202   /* TRACE("<-- %lu\n", num_read); */
203   return num_read;
204 }
205
206 static UINT sc_cb_write(INT_PTR hf, void *pv, UINT cb)
207 {
208   DWORD num_written;
209   /* BOOL rv; */
210
211   /* TRACE("(hf == %d, pv == ^%p, cb == %u)\n", hf, pv, cb); */
212
213   if ( /* (rv = */ WriteFile((HANDLE) hf, pv, cb, &num_written, NULL) /* ) */
214        && (num_written == cb)) {
215     /* TRACE("<-- %lu\n", num_written); */
216     return num_written;
217   } else {
218     /* TRACE("rv == %d, num_written == %lu, cb == %u\n", rv, num_written,cb); */
219     /* TRACE("<-- -1\n"); */
220     return -1;
221   }
222 }
223
224 static int sc_cb_close(INT_PTR hf)
225 {
226   /* TRACE("(hf == %d)\n", hf); */
227
228   if (CloseHandle((HANDLE) hf))
229     return 0;
230   else
231     return -1;
232 }
233
234 static long sc_cb_lseek(INT_PTR hf, long dist, int seektype)
235 {
236   DWORD ret;
237
238   /* TRACE("(hf == %d, dist == %ld, seektype == %d)\n", hf, dist, seektype); */
239
240   if (seektype < 0 || seektype > 2)
241     return -1;
242
243   if (((ret = SetFilePointer((HANDLE) hf, dist, NULL, seektype)) != INVALID_SET_FILE_POINTER) || !GetLastError()) {
244     /* TRACE("<-- %lu\n", ret); */
245     return ret;
246   } else {
247     /* TRACE("<-- -1\n"); */
248     return -1;
249   }
250 }
251
252 #define SIZEOF_MYSTERIO (MAX_PATH*3)
253
254 /* FDICopy callbacks */
255
256 static INT_PTR sc_FNNOTIFY_A(FDINOTIFICATIONTYPE fdint, PFDINOTIFICATION pfdin)
257 {
258   FILE_IN_CABINET_INFO_A fici;
259   PSC_HSC_A phsc;
260   CABINET_INFO_A ci;
261   FILEPATHS_A fp;
262   UINT err;
263
264   CHAR mysterio[SIZEOF_MYSTERIO]; /* how big? undocumented! probably 256... */
265
266   memset(&(mysterio[0]), 0, SIZEOF_MYSTERIO);
267
268   TRACE("(fdint == %d, pfdin == ^%p)\n", fdint, pfdin);
269
270   if (pfdin && pfdin->pv && (*((void **) pfdin->pv) == (void *)SC_HSC_A_MAGIC))
271     phsc = (PSC_HSC_A) pfdin->pv;
272   else {
273     ERR("pv %p is not an SC_HSC_A.\n", (pfdin) ? pfdin->pv : NULL);
274     return -1;
275   }
276
277   switch (fdint) {
278   case fdintCABINET_INFO:
279     TRACE("Cabinet info notification\n");
280     /* TRACE("  Cabinet name: %s\n", debugstr_a(pfdin->psz1));
281     TRACE("  Cabinet disk: %s\n", debugstr_a(pfdin->psz2));
282     TRACE("  Cabinet path: %s\n", debugstr_a(pfdin->psz3));
283     TRACE("  Cabinet Set#: %d\n", pfdin->setID);
284     TRACE("  Cabinet Cab#: %d\n", pfdin->iCabinet); */
285     WARN("SPFILENOTIFY_CABINETINFO undocumented: guess implementation.\n");
286     ci.CabinetFile = &(phsc->most_recent_cabinet_name[0]);
287     ci.CabinetPath = pfdin->psz3;
288     ci.DiskName = pfdin->psz2;
289     ci.SetId = pfdin->setID;
290     ci.CabinetNumber = pfdin->iCabinet;
291     phsc->msghandler(phsc->context, SPFILENOTIFY_CABINETINFO, (UINT) &ci, 0);
292     return 0;
293   case fdintPARTIAL_FILE:
294     TRACE("Partial file notification\n");
295     /* TRACE("  Partial file name: %s\n", debugstr_a(pfdin->psz1)); */
296     return 0;
297   case fdintCOPY_FILE:
298     TRACE("Copy file notification\n");
299     TRACE("  File name: %s\n", debugstr_a(pfdin->psz1));
300     /* TRACE("  File size: %ld\n", pfdin->cb);
301     TRACE("  File date: %u\n", pfdin->date);
302     TRACE("  File time: %u\n", pfdin->time);
303     TRACE("  File attr: %u\n", pfdin->attribs); */
304     fici.NameInCabinet = pfdin->psz1;
305     fici.FileSize = pfdin->cb;
306     fici.Win32Error = 0;
307     fici.DosDate = pfdin->date;
308     fici.DosTime = pfdin->time;
309     fici.DosAttribs = pfdin->attribs;
310     memset(&(fici.FullTargetName[0]), 0, MAX_PATH);
311     err = phsc->msghandler(phsc->context, SPFILENOTIFY_FILEINCABINET,
312                            (UINT) &fici, (UINT) pfdin->psz1);
313     if (err == FILEOP_DOIT) {
314       TRACE("  Callback specified filename: %s\n", debugstr_a(&(fici.FullTargetName[0])));
315       if (!fici.FullTargetName[0]) {
316         WARN("  Empty return string causing abort.\n");
317         SetLastError(ERROR_PATH_NOT_FOUND);
318         return -1;
319       }
320       return sc_cb_open(&(fici.FullTargetName[0]), _O_BINARY | _O_CREAT | _O_WRONLY,  _S_IREAD | _S_IWRITE);
321     } else {
322       TRACE("  Callback skipped file.\n");
323       return 0;
324     }
325   case fdintCLOSE_FILE_INFO:
326     TRACE("Close file notification\n");
327     /* TRACE("  File name: %s\n", debugstr_a(pfdin->psz1));
328     TRACE("  Exec file? %s\n", (pfdin->cb) ? "Yes" : "No");
329     TRACE("  File hndl: %d\n", pfdin->hf); */
330     fp.Source = &(phsc->most_recent_cabinet_name[0]);
331     fp.Target = pfdin->psz1;
332     fp.Win32Error = 0;
333     fp.Flags = 0;
334     /* the following should be a fixme -- but it occurs too many times */
335     WARN("Should set file date/time/attribs (and execute files?)\n");
336     err = phsc->msghandler(phsc->context, SPFILENOTIFY_FILEEXTRACTED, (UINT) &fp, 0);
337     if (sc_cb_close(pfdin->hf))
338       WARN("_close failed.\n");
339     if (err) {
340       SetLastError(err);
341       return FALSE;
342     } else
343       return TRUE;
344   case fdintNEXT_CABINET:
345     TRACE("Next cabinet notification\n");
346     /* TRACE("  Cabinet name: %s\n", debugstr_a(pfdin->psz1));
347     TRACE("  Cabinet disk: %s\n", debugstr_a(pfdin->psz2));
348     TRACE("  Cabinet path: %s\n", debugstr_a(pfdin->psz3));
349     TRACE("  Cabinet Set#: %d\n", pfdin->setID);
350     TRACE("  Cabinet Cab#: %d\n", pfdin->iCabinet); */
351     ci.CabinetFile = pfdin->psz1;
352     ci.CabinetPath = pfdin->psz3;
353     ci.DiskName = pfdin->psz2;
354     ci.SetId = pfdin->setID;
355     ci.CabinetNumber = pfdin->iCabinet;
356     /* remember the new cabinet name */
357     strcpy(&(phsc->most_recent_cabinet_name[0]), pfdin->psz1);
358     err = phsc->msghandler(phsc->context, SPFILENOTIFY_NEEDNEWCABINET, (UINT) &ci, (UINT) &(mysterio[0]));
359     if (err) {
360       SetLastError(err);
361       return -1;
362     } else {
363       if (mysterio[0]) {
364         /* some easy paranoia.  no such carefulness exists on the wide API IIRC */
365         lstrcpynA(pfdin->psz3, &(mysterio[0]), SIZEOF_MYSTERIO);
366       }
367       return 0;
368     }
369   default:
370     FIXME("Unknown notification type %d.\n", fdint);
371     return 0;
372   }
373 }
374
375 static INT_PTR sc_FNNOTIFY_W(FDINOTIFICATIONTYPE fdint, PFDINOTIFICATION pfdin)
376 {
377   FILE_IN_CABINET_INFO_W fici;
378   PSC_HSC_W phsc;
379   CABINET_INFO_W ci;
380   FILEPATHS_W fp;
381   UINT err;
382   int len;
383
384   WCHAR mysterio[SIZEOF_MYSTERIO]; /* how big? undocumented! */
385   WCHAR buf[MAX_PATH], buf2[MAX_PATH];
386   CHAR charbuf[MAX_PATH];
387
388   memset(&(mysterio[0]), 0, SIZEOF_MYSTERIO * sizeof(WCHAR));
389   memset(&(buf[0]), 0, MAX_PATH * sizeof(WCHAR));
390   memset(&(buf2[0]), 0, MAX_PATH * sizeof(WCHAR));
391   memset(&(charbuf[0]), 0, MAX_PATH);
392
393   TRACE("(fdint == %d, pfdin == ^%p)\n", fdint, pfdin);
394
395   if (pfdin && pfdin->pv && (*((void **) pfdin->pv) == (void *)SC_HSC_W_MAGIC))
396     phsc = (PSC_HSC_W) pfdin->pv;
397   else {
398     ERR("pv %p is not an SC_HSC_W.\n", (pfdin) ? pfdin->pv : NULL);
399     return -1;
400   }
401
402   switch (fdint) {
403   case fdintCABINET_INFO:
404     TRACE("Cabinet info notification\n");
405     /* TRACE("  Cabinet name: %s\n", debugstr_a(pfdin->psz1));
406     TRACE("  Cabinet disk: %s\n", debugstr_a(pfdin->psz2));
407     TRACE("  Cabinet path: %s\n", debugstr_a(pfdin->psz3));
408     TRACE("  Cabinet Set#: %d\n", pfdin->setID);
409     TRACE("  Cabinet Cab#: %d\n", pfdin->iCabinet); */
410     WARN("SPFILENOTIFY_CABINETINFO undocumented: guess implementation.\n");
411     ci.CabinetFile = &(phsc->most_recent_cabinet_name[0]);
412     len = 1 + MultiByteToWideChar(CP_ACP, 0, pfdin->psz3, -1, &(buf[0]), MAX_PATH);
413     if ((len > MAX_PATH) || (len <= 1))
414       buf[0] = '\0';
415     ci.CabinetPath = &(buf[0]);
416     len = 1 + MultiByteToWideChar(CP_ACP, 0, pfdin->psz2, -1, &(buf2[0]), MAX_PATH);
417     if ((len > MAX_PATH) || (len <= 1))
418       buf2[0] = '\0';
419     ci.DiskName = &(buf2[0]);
420     ci.SetId = pfdin->setID;
421     ci.CabinetNumber = pfdin->iCabinet;
422     phsc->msghandler(phsc->context, SPFILENOTIFY_CABINETINFO, (UINT) &ci, 0);
423     return 0;
424   case fdintPARTIAL_FILE:
425     TRACE("Partial file notification\n");
426     /* TRACE("  Partial file name: %s\n", debugstr_a(pfdin->psz1)); */
427     return 0;
428   case fdintCOPY_FILE:
429     TRACE("Copy file notification\n");
430     TRACE("  File name: %s\n", debugstr_a(pfdin->psz1));
431     /* TRACE("  File size: %ld\n", pfdin->cb);
432     TRACE("  File date: %u\n", pfdin->date);
433     TRACE("  File time: %u\n", pfdin->time);
434     TRACE("  File attr: %u\n", pfdin->attribs); */
435     len = 1 + MultiByteToWideChar(CP_ACP, 0, pfdin->psz1, -1, &(buf2[0]), MAX_PATH);
436     if ((len > MAX_PATH) || (len <= 1))
437       buf2[0] = '\0';
438     fici.NameInCabinet = &(buf2[0]);
439     fici.FileSize = pfdin->cb;
440     fici.Win32Error = 0;
441     fici.DosDate = pfdin->date;
442     fici.DosTime = pfdin->time;
443     fici.DosAttribs = pfdin->attribs;
444     memset(&(fici.FullTargetName[0]), 0, MAX_PATH * sizeof(WCHAR));
445     err = phsc->msghandler(phsc->context, SPFILENOTIFY_FILEINCABINET,
446                            (UINT) &fici, (UINT) pfdin->psz1);
447     if (err == FILEOP_DOIT) {
448       TRACE("  Callback specified filename: %s\n", debugstr_w(&(fici.FullTargetName[0])));
449       if (fici.FullTargetName[0]) {
450         len = strlenW(&(fici.FullTargetName[0])) + 1;
451         if ((len > MAX_PATH ) || (len <= 1))
452           return 0;
453         if (!WideCharToMultiByte(CP_ACP, 0, &(fici.FullTargetName[0]), len, &(charbuf[0]), MAX_PATH, 0, 0))
454           return 0;
455       } else {
456         WARN("Empty buffer string caused abort.\n");
457         SetLastError(ERROR_PATH_NOT_FOUND);
458         return -1;
459       }
460       return sc_cb_open(&(charbuf[0]), _O_BINARY | _O_CREAT | _O_WRONLY,  _S_IREAD | _S_IWRITE);
461     } else {
462       TRACE("  Callback skipped file.\n");
463       return 0;
464     }
465   case fdintCLOSE_FILE_INFO:
466     TRACE("Close file notification\n");
467     /* TRACE("  File name: %s\n", debugstr_a(pfdin->psz1));
468     TRACE("  Exec file? %s\n", (pfdin->cb) ? "Yes" : "No");
469     TRACE("  File hndl: %d\n", pfdin->hf); */
470     fp.Source = &(phsc->most_recent_cabinet_name[0]);
471     len = 1 + MultiByteToWideChar(CP_ACP, 0, pfdin->psz1, -1, &(buf[0]), MAX_PATH);
472     if ((len > MAX_PATH) || (len <= 1))
473       buf[0] = '\0';
474     fp.Target = &(buf[0]);
475     fp.Win32Error = 0;
476     fp.Flags = 0;
477     /* a valid fixme -- but occurs too many times */
478     /* FIXME("Should set file date/time/attribs (and execute files?)\n"); */
479     err = phsc->msghandler(phsc->context, SPFILENOTIFY_FILEEXTRACTED, (UINT) &fp, 0);
480     if (sc_cb_close(pfdin->hf))
481       WARN("_close failed.\n");
482     if (err) {
483       SetLastError(err);
484       return FALSE;
485     } else
486       return TRUE;
487   case fdintNEXT_CABINET:
488     TRACE("Next cabinet notification\n");
489     /* TRACE("  Cabinet name: %s\n", debugstr_a(pfdin->psz1));
490     TRACE("  Cabinet disk: %s\n", debugstr_a(pfdin->psz2));
491     TRACE("  Cabinet path: %s\n", debugstr_a(pfdin->psz3));
492     TRACE("  Cabinet Set#: %d\n", pfdin->setID);
493     TRACE("  Cabinet Cab#: %d\n", pfdin->iCabinet); */
494     /* remember the new cabinet name */
495     len = 1 + MultiByteToWideChar(CP_ACP, 0, pfdin->psz1, -1, &(phsc->most_recent_cabinet_name[0]), MAX_PATH);
496     if ((len > MAX_PATH) || (len <= 1))
497       phsc->most_recent_cabinet_name[0] = '\0';
498     ci.CabinetFile = &(phsc->most_recent_cabinet_name[0]);
499     len = 1 + MultiByteToWideChar(CP_ACP, 0, pfdin->psz3, -1, &(buf[0]), MAX_PATH);
500     if ((len > MAX_PATH) || (len <= 1))
501       buf[0] = '\0';
502     ci.CabinetPath = &(buf[0]);
503     len = 1 + MultiByteToWideChar(CP_ACP, 0, pfdin->psz2, -1, &(buf2[0]), MAX_PATH);
504     if ((len > MAX_PATH) || (len <= 1))
505       buf2[0] = '\0';
506     ci.DiskName = &(buf2[0]);
507     ci.SetId = pfdin->setID;
508     ci.CabinetNumber = pfdin->iCabinet;
509     err = phsc->msghandler(phsc->context, SPFILENOTIFY_NEEDNEWCABINET, (UINT) &ci, (UINT) &(mysterio[0]));
510     if (err) {
511       SetLastError(err);
512       return -1;
513     } else {
514       if (mysterio[0]) {
515         len = strlenW(&(mysterio[0])) + 1;
516         if ((len > 255) || (len <= 1))
517           return 0;
518         if (!WideCharToMultiByte(CP_ACP, 0, &(mysterio[0]), len, pfdin->psz3, 255, 0, 0))
519           return 0;
520       }
521       return 0;
522     }
523   default:
524     FIXME("Unknown notification type %d.\n", fdint);
525     return 0;
526   }
527 }
528
529 /***********************************************************************
530  *              SetupIterateCabinetA (SETUPAPI.@)
531  */
532 BOOL WINAPI SetupIterateCabinetA(PCSTR CabinetFile, DWORD Reserved,
533                                  PSP_FILE_CALLBACK_A MsgHandler, PVOID Context)
534 {
535
536   SC_HSC_A my_hsc;
537   ERF erf;
538   CHAR pszCabinet[MAX_PATH], pszCabPath[MAX_PATH], *p;
539   DWORD fpnsize;
540   BOOL ret;
541
542
543   TRACE("(CabinetFile == %s, Reserved == %u, MsgHandler == ^%p, Context == ^%p)\n",
544         debugstr_a(CabinetFile), Reserved, MsgHandler, Context);
545
546   if (! LoadCABINETDll()) 
547     return FALSE;
548
549   memset(&my_hsc, 0, sizeof(SC_HSC_A));
550   pszCabinet[0] = '\0';
551   pszCabPath[0] = '\0';
552
553   fpnsize = strlen(CabinetFile);
554   if (fpnsize >= MAX_PATH) {
555     SetLastError(ERROR_BAD_PATHNAME);
556     return FALSE;
557   }
558
559   fpnsize = GetFullPathNameA(CabinetFile, MAX_PATH, &(pszCabPath[0]), &p);
560   if (fpnsize > MAX_PATH) {
561     SetLastError(ERROR_BAD_PATHNAME);
562     return FALSE;
563   }
564
565   if (p) {
566     strcpy(pszCabinet, p);
567     *p = '\0';
568   } else {
569     strcpy(pszCabinet, CabinetFile);
570     pszCabPath[0] = '\0';
571   }
572
573   TRACE("path: %s, cabfile: %s\n", debugstr_a(pszCabPath), debugstr_a(pszCabinet));
574
575   /* remember the cabinet name */
576   strcpy(&(my_hsc.most_recent_cabinet_name[0]), pszCabinet);
577
578   my_hsc.magic = SC_HSC_A_MAGIC;
579   my_hsc.msghandler = MsgHandler;
580   my_hsc.context = Context;
581   my_hsc.hfdi = sc_FDICreate( sc_cb_alloc, sc_cb_free, sc_cb_open, sc_cb_read,
582                            sc_cb_write, sc_cb_close, sc_cb_lseek, cpuUNKNOWN, &erf );
583
584   if (!my_hsc.hfdi) return FALSE;
585
586   ret = ( sc_FDICopy(my_hsc.hfdi, pszCabinet, pszCabPath,
587                      0, sc_FNNOTIFY_A, NULL, &my_hsc)     ) ? TRUE : FALSE;
588
589   sc_FDIDestroy(my_hsc.hfdi);
590   return ret;
591 }
592
593
594 /***********************************************************************
595  *              SetupIterateCabinetW (SETUPAPI.@)
596  */
597 BOOL WINAPI SetupIterateCabinetW(PCWSTR CabinetFile, DWORD Reserved,
598                                  PSP_FILE_CALLBACK_W MsgHandler, PVOID Context)
599 {
600   CHAR pszCabinet[MAX_PATH], pszCabPath[MAX_PATH];
601   UINT len;
602   SC_HSC_W my_hsc;
603   ERF erf;
604   WCHAR pszCabPathW[MAX_PATH], *p;
605   DWORD fpnsize;
606   BOOL ret;
607
608   TRACE("(CabinetFile == %s, Reserved == %u, MsgHandler == ^%p, Context == ^%p)\n",
609         debugstr_w(CabinetFile), Reserved, MsgHandler, Context);
610
611   if (!LoadCABINETDll())
612     return FALSE;
613
614   if (!CabinetFile) return FALSE;
615
616   memset(&my_hsc, 0, sizeof(SC_HSC_W));
617
618   fpnsize = GetFullPathNameW(CabinetFile, MAX_PATH, pszCabPathW, &p);
619   if (fpnsize > MAX_PATH) {
620     SetLastError(ERROR_BAD_PATHNAME);
621     return FALSE;
622   }
623
624   if (p) {
625     strcpyW(my_hsc.most_recent_cabinet_name, p);
626     *p = 0;
627     len = WideCharToMultiByte(CP_ACP, 0, pszCabPathW, -1, pszCabPath,
628                                 MAX_PATH, 0, 0);
629     if (!len) return FALSE;
630   } else {
631     strcpyW(my_hsc.most_recent_cabinet_name, CabinetFile);
632     pszCabPath[0] = '\0';
633   }
634
635   len = WideCharToMultiByte(CP_ACP, 0, my_hsc.most_recent_cabinet_name, -1,
636                                 pszCabinet, MAX_PATH, 0, 0);
637   if (!len) return FALSE;
638
639   TRACE("path: %s, cabfile: %s\n",
640         debugstr_a(pszCabPath), debugstr_a(pszCabinet));
641
642   my_hsc.magic = SC_HSC_W_MAGIC;
643   my_hsc.msghandler = MsgHandler;
644   my_hsc.context = Context;
645   my_hsc.hfdi = sc_FDICreate( sc_cb_alloc, sc_cb_free, sc_cb_open, sc_cb_read,
646                               sc_cb_write, sc_cb_close, sc_cb_lseek, cpuUNKNOWN, &erf );
647
648   if (!my_hsc.hfdi) return FALSE;
649
650   ret = ( sc_FDICopy(my_hsc.hfdi, pszCabinet, pszCabPath,
651                      0, sc_FNNOTIFY_W, NULL, &my_hsc)     ) ? TRUE : FALSE;
652
653   sc_FDIDestroy(my_hsc.hfdi);
654   return ret;
655 }
656
657
658 /***********************************************************************
659  * DllMain
660  *
661  * PARAMS
662  *     hinstDLL    [I] handle to the DLL's instance
663  *     fdwReason   [I]
664  *     lpvReserved [I] reserved, must be NULL
665  *
666  * RETURNS
667  *     Success: TRUE
668  *     Failure: FALSE
669  */
670
671 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
672 {
673     switch (fdwReason) {
674     case DLL_PROCESS_ATTACH:
675         DisableThreadLibraryCalls(hinstDLL);
676         OsVersionInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFOW);
677         if (!GetVersionExW(&OsVersionInfo))
678             return FALSE;
679         break;
680     case DLL_PROCESS_DETACH:
681         UnloadCABINETDll();
682         break;
683     }
684
685     return TRUE;
686 }