?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
push 38a8c0aff9170390b5a3ded41e7cf5b02f3a73d8
[wine/hacks.git] / dlls / setupapi / queue.c
blob6a2b8d62009edbffdcc63273d31ba6a228619119
1 /*
2 * Setupapi file queue routines
3 *
4 * Copyright 2002 Alexandre Julliard for CodeWeavers
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 <stdarg.h>
22
23 #include "windef.h"
24 #include "winbase.h"
25 #include "winreg.h"
26 #include "winternl.h"
27 #include "winerror.h"
28 #include "wingdi.h"
29 #include "winuser.h"
30 #include "winnls.h"
31 #include "setupapi.h"
32 #include "wine/unicode.h"
33 #include "setupapi_private.h"
34 #include "winver.h"
35 #include "wine/debug.h"
36
37 WINE_DEFAULT_DEBUG_CHANNEL(setupapi);
38
39 /* context structure for the default queue callback */
40 struct default_callback_context
41 {
42 HWND owner;
43 HWND progress;
44 UINT message;
45 };
46
47 struct file_op
48 {
49 struct file_op *next;
50 UINT style;
51 WCHAR *src_root;
52 WCHAR *src_path;
53 WCHAR *src_file;
54 WCHAR *src_descr;
55 WCHAR *src_tag;
56 WCHAR *dst_path;
57 WCHAR *dst_file;
58 };
59
60 struct file_op_queue
61 {
62 struct file_op *head;
63 struct file_op *tail;
64 unsigned int count;
65 };
66
67 struct file_queue
68 {
69 struct file_op_queue copy_queue;
70 struct file_op_queue delete_queue;
71 struct file_op_queue rename_queue;
72 DWORD flags;
73 };
74
75
76 /* append a file operation to a queue */
77 static inline void queue_file_op( struct file_op_queue *queue, struct file_op *op )
78 {
79 op->next = NULL;
80 if (queue->tail) queue->tail->next = op;
81 else queue->head = op;
82 queue->tail = op;
83 queue->count++;
84 }
85
86 /* free all the file operations on a given queue */
87 static void free_file_op_queue( struct file_op_queue *queue )
88 {
89 struct file_op *t, *op = queue->head;
90
91 while( op )
92 {
93 HeapFree( GetProcessHeap(), 0, op->src_root );
94 HeapFree( GetProcessHeap(), 0, op->src_path );
95 HeapFree( GetProcessHeap(), 0, op->src_file );
96 HeapFree( GetProcessHeap(), 0, op->src_descr );
97 HeapFree( GetProcessHeap(), 0, op->src_tag );
98 HeapFree( GetProcessHeap(), 0, op->dst_path );
99 if (op->dst_file != op->src_file) HeapFree( GetProcessHeap(), 0, op->dst_file );
100 t = op;
101 op = op->next;
102 HeapFree( GetProcessHeap(), 0, t );
103 }
104 }
105
106 /* concat 3 strings to make a path, handling separators correctly */
107 static void concat_W( WCHAR *buffer, const WCHAR *src1, const WCHAR *src2, const WCHAR *src3 )
108 {
109 *buffer = 0;
110 if (src1 && *src1)
111 {
112 strcpyW( buffer, src1 );
113 buffer += strlenW(buffer );
114 if (buffer[-1] != '\\') *buffer++ = '\\';
115 if (src2) while (*src2 == '\\') src2++;
116 }
117
118 if (src2)
119 {
120 strcpyW( buffer, src2 );
121 buffer += strlenW(buffer );
122 if (buffer[-1] != '\\') *buffer++ = '\\';
123 if (src3) while (*src3 == '\\') src3++;
124 }
125 if (src3)
126 {
127 strcpyW( buffer, src3 );
128 buffer += strlenW(buffer );
129 }
130 }
131
132
133 /***********************************************************************
134 * build_filepathsW
135 *
136 * Build a FILEPATHS_W structure for a given file operation.
137 */
138 static BOOL build_filepathsW( const struct file_op *op, FILEPATHS_W *paths )
139 {
140 unsigned int src_len = 1, dst_len = 1;
141 WCHAR *source = (PWSTR)paths->Source, *target = (PWSTR)paths->Target;
142
143 if (op->src_root) src_len += strlenW(op->src_root) + 1;
144 if (op->src_path) src_len += strlenW(op->src_path) + 1;
145 if (op->src_file) src_len += strlenW(op->src_file) + 1;
146 if (op->dst_path) dst_len += strlenW(op->dst_path) + 1;
147 if (op->dst_file) dst_len += strlenW(op->dst_file) + 1;
148 src_len *= sizeof(WCHAR);
149 dst_len *= sizeof(WCHAR);
150
151 if (!source || HeapSize( GetProcessHeap(), 0, source ) < src_len )
152 {
153 HeapFree( GetProcessHeap(), 0, source );
154 paths->Source = source = HeapAlloc( GetProcessHeap(), 0, src_len );
155 }
156 if (!target || HeapSize( GetProcessHeap(), 0, target ) < dst_len )
157 {
158 HeapFree( GetProcessHeap(), 0, target );
159 paths->Target = target = HeapAlloc( GetProcessHeap(), 0, dst_len );
160 }
161 if (!source || !target) return FALSE;
162 concat_W( source, op->src_root, op->src_path, op->src_file );
163 concat_W( target, NULL, op->dst_path, op->dst_file );
164 paths->Win32Error = 0;
165 paths->Flags = 0;
166 return TRUE;
167 }
168
169
170 /***********************************************************************
171 * QUEUE_callback_WtoA
172 *
173 * Map a file callback parameters from W to A and call the A callback.
174 */
175 UINT CALLBACK QUEUE_callback_WtoA( void *context, UINT notification,
176 UINT_PTR param1, UINT_PTR param2 )
177 {
178 struct callback_WtoA_context *callback_ctx = context;
179 char buffer[MAX_PATH];
180 UINT ret;
181 UINT_PTR old_param2 = param2;
182
183 switch(notification)
184 {
185 case SPFILENOTIFY_COPYERROR:
186 param2 = (UINT_PTR)buffer;
187 /* fall through */
188 case SPFILENOTIFY_STARTDELETE:
189 case SPFILENOTIFY_ENDDELETE:
190 case SPFILENOTIFY_DELETEERROR:
191 case SPFILENOTIFY_STARTRENAME:
192 case SPFILENOTIFY_ENDRENAME:
193 case SPFILENOTIFY_RENAMEERROR:
194 case SPFILENOTIFY_STARTCOPY:
195 case SPFILENOTIFY_ENDCOPY:
196 case SPFILENOTIFY_QUEUESCAN_EX:
197 {
198 FILEPATHS_W *pathsW = (FILEPATHS_W *)param1;
199 FILEPATHS_A pathsA;
200
201 pathsA.Source = strdupWtoA( pathsW->Source );
202 pathsA.Target = strdupWtoA( pathsW->Target );
203 pathsA.Win32Error = pathsW->Win32Error;
204 pathsA.Flags = pathsW->Flags;
205 ret = callback_ctx->orig_handler( callback_ctx->orig_context, notification,
206 (UINT_PTR)&pathsA, param2 );
207 HeapFree( GetProcessHeap(), 0, (void *)pathsA.Source );
208 HeapFree( GetProcessHeap(), 0, (void *)pathsA.Target );
209 }
210 if (notification == SPFILENOTIFY_COPYERROR)
211 MultiByteToWideChar( CP_ACP, 0, buffer, -1, (WCHAR *)old_param2, MAX_PATH );
212 break;
213
214 case SPFILENOTIFY_STARTREGISTRATION:
215 case SPFILENOTIFY_ENDREGISTRATION:
216 {
217 SP_REGISTER_CONTROL_STATUSW *statusW = (SP_REGISTER_CONTROL_STATUSW *)param1;
218 SP_REGISTER_CONTROL_STATUSA statusA;
219
220 statusA.cbSize = sizeof(statusA);
221 statusA.FileName = strdupWtoA( statusW->FileName );
222 statusA.Win32Error = statusW->Win32Error;
223 statusA.FailureCode = statusW->FailureCode;
224 ret = callback_ctx->orig_handler( callback_ctx->orig_context, notification,
225 (UINT_PTR)&statusA, param2 );
226 HeapFree( GetProcessHeap(), 0, (LPSTR)statusA.FileName );
227 }
228 break;
229
230 case SPFILENOTIFY_QUEUESCAN:
231 {
232 LPWSTR targetW = (LPWSTR)param1;
233 LPSTR target = strdupWtoA( targetW );
234
235 ret = callback_ctx->orig_handler( callback_ctx->orig_context, notification,
236 (UINT_PTR)target, param2 );
237 HeapFree( GetProcessHeap(), 0, target );
238 }
239 break;
240
241 case SPFILENOTIFY_NEEDMEDIA:
242 FIXME("mapping for %d not implemented\n",notification);
243 case SPFILENOTIFY_STARTQUEUE:
244 case SPFILENOTIFY_ENDQUEUE:
245 case SPFILENOTIFY_STARTSUBQUEUE:
246 case SPFILENOTIFY_ENDSUBQUEUE:
247 default:
248 ret = callback_ctx->orig_handler( callback_ctx->orig_context, notification, param1, param2 );
249 break;
250 }
251 return ret;
252 }
253
254
255 /***********************************************************************
256 * get_src_file_info
257 *
258 * Retrieve the source file information for a given file.
259 */
260 static void get_src_file_info( HINF hinf, struct file_op *op )
261 {
262 static const WCHAR SourceDisksNames[] =
263 {'S','o','u','r','c','e','D','i','s','k','s','N','a','m','e','s',0};
264 static const WCHAR SourceDisksFiles[] =
265 {'S','o','u','r','c','e','D','i','s','k','s','F','i','l','e','s',0};
266
267 INFCONTEXT file_ctx, disk_ctx;
268 INT id, diskid;
269 DWORD len, len2;
270
271 /* find the SourceDisksFiles entry */
272 if (!SetupFindFirstLineW( hinf, SourceDisksFiles, op->src_file, &file_ctx ))
273 {
274 if ((op->style & (SP_COPY_SOURCE_ABSOLUTE|SP_COPY_SOURCEPATH_ABSOLUTE))) return;
275 /* no specific info, use .inf file source directory */
276 if (!op->src_root) op->src_root = PARSER_get_src_root( hinf );
277 return;
278 }
279 if (!SetupGetIntField( &file_ctx, 1, &diskid )) return;
280
281 /* now find the diskid in the SourceDisksNames section */
282 if (!SetupFindFirstLineW( hinf, SourceDisksNames, NULL, &disk_ctx )) return;
283 for (;;)
284 {
285 if (SetupGetIntField( &disk_ctx, 0, &id ) && (id == diskid)) break;
286 if (!SetupFindNextLine( &disk_ctx, &disk_ctx )) return;
287 }
288
289 /* and fill in the missing info */
290
291 if (!op->src_descr)
292 {
293 if (SetupGetStringFieldW( &disk_ctx, 1, NULL, 0, &len ) &&
294 (op->src_descr = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) )))
295 SetupGetStringFieldW( &disk_ctx, 1, op->src_descr, len, NULL );
296 }
297 if (!op->src_tag)
298 {
299 if (SetupGetStringFieldW( &disk_ctx, 2, NULL, 0, &len ) &&
300 (op->src_tag = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) )))
301 SetupGetStringFieldW( &disk_ctx, 2, op->src_tag, len, NULL );
302 }
303 if (!op->src_path && !(op->style & SP_COPY_SOURCE_ABSOLUTE))
304 {
305 len = len2 = 0;
306 if (!(op->style & SP_COPY_SOURCEPATH_ABSOLUTE))
307 {
308 /* retrieve relative path for this disk */
309 if (!SetupGetStringFieldW( &disk_ctx, 4, NULL, 0, &len )) len = 0;
310 }
311 /* retrieve relative path for this file */
312 if (!SetupGetStringFieldW( &file_ctx, 2, NULL, 0, &len2 )) len2 = 0;
313
314 if ((len || len2) &&
315 (op->src_path = HeapAlloc( GetProcessHeap(), 0, (len+len2)*sizeof(WCHAR) )))
316 {
317 WCHAR *ptr = op->src_path;
318 if (len)
319 {
320 SetupGetStringFieldW( &disk_ctx, 4, op->src_path, len, NULL );
321 ptr = op->src_path + strlenW(op->src_path);
322 if (len2 && ptr > op->src_path && ptr[-1] != '\\') *ptr++ = '\\';
323 }
324 if (!SetupGetStringFieldW( &file_ctx, 2, ptr, len2, NULL )) *ptr = 0;
325 }
326 }
327 if (!op->src_root) op->src_root = PARSER_get_src_root(hinf);
328 }
329
330
331 /***********************************************************************
332 * get_destination_dir
333 *
334 * Retrieve the destination dir for a given section.
335 */
336 static WCHAR *get_destination_dir( HINF hinf, const WCHAR *section )
337 {
338 static const WCHAR Dest[] = {'D','e','s','t','i','n','a','t','i','o','n','D','i','r','s',0};
339 static const WCHAR Def[] = {'D','e','f','a','u','l','t','D','e','s','t','D','i','r',0};
340 INFCONTEXT context;
341
342 if (!SetupFindFirstLineW( hinf, Dest, section, &context ) &&
343 !SetupFindFirstLineW( hinf, Dest, Def, &context )) return NULL;
344 return PARSER_get_dest_dir( &context );
345 }
346
347
348 static void (WINAPI *pExtractFiles)( LPSTR, LPSTR, DWORD, DWORD, DWORD, DWORD );
349
350 /***********************************************************************
351 * extract_cabinet_file
352 *
353 * Extract a file from a .cab file.
354 */
355 static BOOL extract_cabinet_file( const WCHAR *cabinet, const WCHAR *root,
356 const WCHAR *src, const WCHAR *dst )
357 {
358 static const WCHAR extW[] = {'.','c','a','b',0};
359 static HMODULE advpack;
360
361 char *cab_path, *cab_file;
362 int len = strlenW( cabinet );
363
364 /* make sure the cabinet file has a .cab extension */
365 if (len <= 4 || strcmpiW( cabinet + len - 4, extW )) return FALSE;
366 if (!pExtractFiles)
367 {
368 if (!advpack && !(advpack = LoadLibraryA( "advpack.dll" )))
369 {
370 ERR( "could not load advpack.dll\n" );
371 return FALSE;
372 }
373 if (!(pExtractFiles = (void *)GetProcAddress( advpack, "ExtractFiles" )))
374 {
375 ERR( "could not find ExtractFiles in advpack.dll\n" );
376 return FALSE;
377 }
378 }
379
380 if (!(cab_path = strdupWtoA( root ))) return FALSE;
381 len = WideCharToMultiByte( CP_ACP, 0, cabinet, -1, NULL, 0, NULL, NULL );
382 if (!(cab_file = HeapAlloc( GetProcessHeap(), 0, strlen(cab_path) + len + 1 )))
383 {
384 HeapFree( GetProcessHeap(), 0, cab_path );
385 return FALSE;
386 }
387 strcpy( cab_file, cab_path );
388 if (cab_file[0] && cab_file[strlen(cab_file)-1] != '\\') strcat( cab_file, "\\" );
389 WideCharToMultiByte( CP_ACP, 0, cabinet, -1, cab_file + strlen(cab_file), len, NULL, NULL );
390 FIXME( "awful hack: extracting cabinet %s\n", debugstr_a(cab_file) );
391 pExtractFiles( cab_file, cab_path, 0, 0, 0, 0 );
392 HeapFree( GetProcessHeap(), 0, cab_file );
393 HeapFree( GetProcessHeap(), 0, cab_path );
394 return CopyFileW( src, dst, FALSE /*FIXME*/ );
395 }
396
397
398 /***********************************************************************
399 * SetupOpenFileQueue (SETUPAPI.@)
400 */
401 HSPFILEQ WINAPI SetupOpenFileQueue(void)
402 {
403 struct file_queue *queue;
404
405 if (!(queue = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*queue))))
406 return INVALID_HANDLE_VALUE;
407 return queue;
408 }
409
410
411 /***********************************************************************
412 * SetupCloseFileQueue (SETUPAPI.@)
413 */
414 BOOL WINAPI SetupCloseFileQueue( HSPFILEQ handle )
415 {
416 struct file_queue *queue = handle;
417
418 free_file_op_queue( &queue->copy_queue );
419 free_file_op_queue( &queue->rename_queue );
420 free_file_op_queue( &queue->delete_queue );
421 HeapFree( GetProcessHeap(), 0, queue );
422 return TRUE;
423 }
424
425
426 /***********************************************************************
427 * SetupQueueCopyIndirectA (SETUPAPI.@)
428 */
429 BOOL WINAPI SetupQueueCopyIndirectA( PSP_FILE_COPY_PARAMS_A params )
430 {
431 struct file_queue *queue = params->QueueHandle;
432 struct file_op *op;
433
434 if (!(op = HeapAlloc( GetProcessHeap(), 0, sizeof(*op) ))) return FALSE;
435 op->style = params->CopyStyle;
436 op->src_root = strdupAtoW( params->SourceRootPath );
437 op->src_path = strdupAtoW( params->SourcePath );
438 op->src_file = strdupAtoW( params->SourceFilename );
439 op->src_descr = strdupAtoW( params->SourceDescription );
440 op->src_tag = strdupAtoW( params->SourceTagfile );
441 op->dst_path = strdupAtoW( params->TargetDirectory );
442 op->dst_file = strdupAtoW( params->TargetFilename );
443
444 /* some defaults */
445 if (!op->src_file) op->src_file = op->dst_file;
446 if (params->LayoutInf)
447 {
448 get_src_file_info( params->LayoutInf, op );
449 if (!op->dst_path) op->dst_path = get_destination_dir( params->LayoutInf, op->dst_file );
450 }
451
452 TRACE( "root=%s path=%s file=%s -> dir=%s file=%s descr=%s tag=%s\n",
453 debugstr_w(op->src_root), debugstr_w(op->src_path), debugstr_w(op->src_file),
454 debugstr_w(op->dst_path), debugstr_w(op->dst_file),
455 debugstr_w(op->src_descr), debugstr_w(op->src_tag) );
456
457 queue_file_op( &queue->copy_queue, op );
458 return TRUE;
459 }
460
461
462 /***********************************************************************
463 * SetupQueueCopyIndirectW (SETUPAPI.@)
464 */
465 BOOL WINAPI SetupQueueCopyIndirectW( PSP_FILE_COPY_PARAMS_W params )
466 {
467 struct file_queue *queue = params->QueueHandle;
468 struct file_op *op;
469
470 if (!(op = HeapAlloc( GetProcessHeap(), 0, sizeof(*op) ))) return FALSE;
471 op->style = params->CopyStyle;
472 op->src_root = strdupW( params->SourceRootPath );
473 op->src_path = strdupW( params->SourcePath );
474 op->src_file = strdupW( params->SourceFilename );
475 op->src_descr = strdupW( params->SourceDescription );
476 op->src_tag = strdupW( params->SourceTagfile );
477 op->dst_path = strdupW( params->TargetDirectory );
478 op->dst_file = strdupW( params->TargetFilename );
479
480 /* some defaults */
481 if (!op->src_file) op->src_file = op->dst_file;
482 if (params->LayoutInf)
483 {
484 get_src_file_info( params->LayoutInf, op );
485 if (!op->dst_path) op->dst_path = get_destination_dir( params->LayoutInf, op->dst_file );
486 }
487
488 TRACE( "root=%s path=%s file=%s -> dir=%s file=%s descr=%s tag=%s\n",
489 debugstr_w(op->src_root), debugstr_w(op->src_path), debugstr_w(op->src_file),
490 debugstr_w(op->dst_path), debugstr_w(op->dst_file),
491 debugstr_w(op->src_descr), debugstr_w(op->src_tag) );
492
493 queue_file_op( &queue->copy_queue, op );
494 return TRUE;
495 }
496
497
498 /***********************************************************************
499 * SetupQueueCopyA (SETUPAPI.@)
500 */
501 BOOL WINAPI SetupQueueCopyA( HSPFILEQ queue, PCSTR src_root, PCSTR src_path, PCSTR src_file,
502 PCSTR src_descr, PCSTR src_tag, PCSTR dst_dir, PCSTR dst_file,
503 DWORD style )
504 {
505 SP_FILE_COPY_PARAMS_A params;
506
507 params.cbSize = sizeof(params);
508 params.QueueHandle = queue;
509 params.SourceRootPath = src_root;
510 params.SourcePath = src_path;
511 params.SourceFilename = src_file;
512 params.SourceDescription = src_descr;
513 params.SourceTagfile = src_tag;
514 params.TargetDirectory = dst_dir;
515 params.TargetFilename = dst_file;
516 params.CopyStyle = style;
517 params.LayoutInf = 0;
518 params.SecurityDescriptor = NULL;
519 return SetupQueueCopyIndirectA( &params );
520 }
521
522
523 /***********************************************************************
524 * SetupQueueCopyW (SETUPAPI.@)
525 */
526 BOOL WINAPI SetupQueueCopyW( HSPFILEQ queue, PCWSTR src_root, PCWSTR src_path, PCWSTR src_file,
527 PCWSTR src_descr, PCWSTR src_tag, PCWSTR dst_dir, PCWSTR dst_file,
528 DWORD style )
529 {
530 SP_FILE_COPY_PARAMS_W params;
531
532 params.cbSize = sizeof(params);
533 params.QueueHandle = queue;
534 params.SourceRootPath = src_root;
535 params.SourcePath = src_path;
536 params.SourceFilename = src_file;
537 params.SourceDescription = src_descr;
538 params.SourceTagfile = src_tag;
539 params.TargetDirectory = dst_dir;
540 params.TargetFilename = dst_file;
541 params.CopyStyle = style;
542 params.LayoutInf = 0;
543 params.SecurityDescriptor = NULL;
544 return SetupQueueCopyIndirectW( &params );
545 }
546
547
548 /***********************************************************************
549 * SetupQueueDefaultCopyA (SETUPAPI.@)
550 */
551 BOOL WINAPI SetupQueueDefaultCopyA( HSPFILEQ queue, HINF hinf, PCSTR src_root, PCSTR src_file,
552 PCSTR dst_file, DWORD style )
553 {
554 SP_FILE_COPY_PARAMS_A params;
555
556 params.cbSize = sizeof(params);
557 params.QueueHandle = queue;
558 params.SourceRootPath = src_root;
559 params.SourcePath = NULL;
560 params.SourceFilename = src_file;
561 params.SourceDescription = NULL;
562 params.SourceTagfile = NULL;
563 params.TargetDirectory = NULL;
564 params.TargetFilename = dst_file;
565 params.CopyStyle = style;
566 params.LayoutInf = hinf;
567 params.SecurityDescriptor = NULL;
568 return SetupQueueCopyIndirectA( &params );
569 }
570
571
572 /***********************************************************************
573 * SetupQueueDefaultCopyW (SETUPAPI.@)
574 */
575 BOOL WINAPI SetupQueueDefaultCopyW( HSPFILEQ queue, HINF hinf, PCWSTR src_root, PCWSTR src_file,
576 PCWSTR dst_file, DWORD style )
577 {
578 SP_FILE_COPY_PARAMS_W params;
579
580 params.cbSize = sizeof(params);
581 params.QueueHandle = queue;
582 params.SourceRootPath = src_root;
583 params.SourcePath = NULL;
584 params.SourceFilename = src_file;
585 params.SourceDescription = NULL;
586 params.SourceTagfile = NULL;
587 params.TargetDirectory = NULL;
588 params.TargetFilename = dst_file;
589 params.CopyStyle = style;
590 params.LayoutInf = hinf;
591 params.SecurityDescriptor = NULL;
592 return SetupQueueCopyIndirectW( &params );
593 }
594
595
596 /***********************************************************************
597 * SetupQueueDeleteA (SETUPAPI.@)
598 */
599 BOOL WINAPI SetupQueueDeleteA( HSPFILEQ handle, PCSTR part1, PCSTR part2 )
600 {
601 struct file_queue *queue = handle;
602 struct file_op *op;
603
604 if (!(op = HeapAlloc( GetProcessHeap(), 0, sizeof(*op) ))) return FALSE;
605 op->style = 0;
606 op->src_root = NULL;
607 op->src_path = NULL;
608 op->src_file = NULL;
609 op->src_descr = NULL;
610 op->src_tag = NULL;
611 op->dst_path = strdupAtoW( part1 );
612 op->dst_file = strdupAtoW( part2 );
613 queue_file_op( &queue->delete_queue, op );
614 return TRUE;
615 }
616
617
618 /***********************************************************************
619 * SetupQueueDeleteW (SETUPAPI.@)
620 */
621 BOOL WINAPI SetupQueueDeleteW( HSPFILEQ handle, PCWSTR part1, PCWSTR part2 )
622 {
623 struct file_queue *queue = handle;
624 struct file_op *op;
625
626 if (!(op = HeapAlloc( GetProcessHeap(), 0, sizeof(*op) ))) return FALSE;
627 op->style = 0;
628 op->src_root = NULL;
629 op->src_path = NULL;
630 op->src_file = NULL;
631 op->src_descr = NULL;
632 op->src_tag = NULL;
633 op->dst_path = strdupW( part1 );
634 op->dst_file = strdupW( part2 );
635 queue_file_op( &queue->delete_queue, op );
636 return TRUE;
637 }
638
639
640 /***********************************************************************
641 * SetupQueueRenameA (SETUPAPI.@)
642 */
643 BOOL WINAPI SetupQueueRenameA( HSPFILEQ handle, PCSTR SourcePath, PCSTR SourceFilename,
644 PCSTR TargetPath, PCSTR TargetFilename )
645 {
646 struct file_queue *queue = handle;
647 struct file_op *op;
648
649 if (!(op = HeapAlloc( GetProcessHeap(), 0, sizeof(*op) ))) return FALSE;
650 op->style = 0;
651 op->src_root = NULL;
652 op->src_path = strdupAtoW( SourcePath );
653 op->src_file = strdupAtoW( SourceFilename );
654 op->src_descr = NULL;
655 op->src_tag = NULL;
656 op->dst_path = strdupAtoW( TargetPath );
657 op->dst_file = strdupAtoW( TargetFilename );
658 queue_file_op( &queue->rename_queue, op );
659 return TRUE;
660 }
661
662
663 /***********************************************************************
664 * SetupQueueRenameW (SETUPAPI.@)
665 */
666 BOOL WINAPI SetupQueueRenameW( HSPFILEQ handle, PCWSTR SourcePath, PCWSTR SourceFilename,
667 PCWSTR TargetPath, PCWSTR TargetFilename )
668 {
669 struct file_queue *queue = handle;
670 struct file_op *op;
671
672 if (!(op = HeapAlloc( GetProcessHeap(), 0, sizeof(*op) ))) return FALSE;
673 op->style = 0;
674 op->src_root = NULL;
675 op->src_path = strdupW( SourcePath );
676 op->src_file = strdupW( SourceFilename );
677 op->src_descr = NULL;
678 op->src_tag = NULL;
679 op->dst_path = strdupW( TargetPath );
680 op->dst_file = strdupW( TargetFilename );
681 queue_file_op( &queue->rename_queue, op );
682 return TRUE;
683 }
684
685
686 /***********************************************************************
687 * SetupQueueCopySectionA (SETUPAPI.@)
688 */
689 BOOL WINAPI SetupQueueCopySectionA( HSPFILEQ queue, PCSTR src_root, HINF hinf, HINF hlist,
690 PCSTR section, DWORD style )
691 {
692 UNICODE_STRING sectionW;
693 BOOL ret = FALSE;
694
695 if (!RtlCreateUnicodeStringFromAsciiz( &sectionW, section ))
696 {
697 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
698 return FALSE;
699 }
700 if (!src_root)
701 ret = SetupQueueCopySectionW( queue, NULL, hinf, hlist, sectionW.Buffer, style );
702 else
703 {
704 UNICODE_STRING srcW;
705 if (RtlCreateUnicodeStringFromAsciiz( &srcW, src_root ))
706 {
707 ret = SetupQueueCopySectionW( queue, srcW.Buffer, hinf, hlist, sectionW.Buffer, style );
708 RtlFreeUnicodeString( &srcW );
709 }
710 else SetLastError( ERROR_NOT_ENOUGH_MEMORY );
711 }
712 RtlFreeUnicodeString( &sectionW );
713 return ret;
714 }
715
716
717 /***********************************************************************
718 * SetupQueueCopySectionW (SETUPAPI.@)
719 */
720 BOOL WINAPI SetupQueueCopySectionW( HSPFILEQ queue, PCWSTR src_root, HINF hinf, HINF hlist,
721 PCWSTR section, DWORD style )
722 {
723 SP_FILE_COPY_PARAMS_W params;
724 INFCONTEXT context;
725 WCHAR dest[MAX_PATH], src[MAX_PATH], *dest_dir;
726 INT flags;
727 BOOL ret = FALSE;
728
729 TRACE( "hinf=%p/%p section=%s root=%s\n",
730 hinf, hlist, debugstr_w(section), debugstr_w(src_root) );
731
732 params.cbSize = sizeof(params);
733 params.QueueHandle = queue;
734 params.SourceRootPath = src_root;
735 params.SourcePath = NULL;
736 params.SourceDescription = NULL;
737 params.SourceTagfile = NULL;
738 params.TargetFilename = dest;
739 params.CopyStyle = style;
740 params.LayoutInf = hinf;
741 params.SecurityDescriptor = NULL;
742
743 if (!hlist) hlist = hinf;
744 if (!hinf) hinf = hlist;
745 if (!SetupFindFirstLineW( hlist, section, NULL, &context )) return FALSE;
746 if (!(params.TargetDirectory = dest_dir = get_destination_dir( hinf, section ))) return FALSE;
747 do
748 {
749 if (!SetupGetStringFieldW( &context, 1, dest, sizeof(dest)/sizeof(WCHAR), NULL ))
750 goto end;
751 if (!SetupGetStringFieldW( &context, 2, src, sizeof(src)/sizeof(WCHAR), NULL )) *src = 0;
752 if (!SetupGetIntField( &context, 4, &flags )) flags = 0; /* FIXME */
753
754 params.SourceFilename = *src ? src : NULL;
755 if (!SetupQueueCopyIndirectW( &params )) goto end;
756 } while (SetupFindNextLine( &context, &context ));
757 ret = TRUE;
758 end:
759 HeapFree(GetProcessHeap(), 0, dest_dir);
760 return ret;
761 }
762
763
764 /***********************************************************************
765 * SetupQueueDeleteSectionA (SETUPAPI.@)
766 */
767 BOOL WINAPI SetupQueueDeleteSectionA( HSPFILEQ queue, HINF hinf, HINF hlist, PCSTR section )
768 {
769 UNICODE_STRING sectionW;
770 BOOL ret = FALSE;
771
772 if (RtlCreateUnicodeStringFromAsciiz( &sectionW, section ))
773 {
774 ret = SetupQueueDeleteSectionW( queue, hinf, hlist, sectionW.Buffer );
775 RtlFreeUnicodeString( &sectionW );
776 }
777 else SetLastError( ERROR_NOT_ENOUGH_MEMORY );
778 return ret;
779 }
780
781
782 /***********************************************************************
783 * SetupQueueDeleteSectionW (SETUPAPI.@)
784 */
785 BOOL WINAPI SetupQueueDeleteSectionW( HSPFILEQ queue, HINF hinf, HINF hlist, PCWSTR section )
786 {
787 INFCONTEXT context;
788 WCHAR *dest_dir;
789 WCHAR buffer[MAX_PATH];
790 BOOL ret = FALSE;
791 INT flags;
792
793 TRACE( "hinf=%p/%p section=%s\n", hinf, hlist, debugstr_w(section) );
794
795 if (!hlist) hlist = hinf;
796 if (!SetupFindFirstLineW( hlist, section, NULL, &context )) return FALSE;
797 if (!(dest_dir = get_destination_dir( hinf, section ))) return FALSE;
798 do
799 {
800 if (!SetupGetStringFieldW( &context, 1, buffer, sizeof(buffer)/sizeof(WCHAR), NULL ))
801 goto done;
802 if (!SetupGetIntField( &context, 4, &flags )) flags = 0;
803 if (!SetupQueueDeleteW( queue, dest_dir, buffer )) goto done;
804 } while (SetupFindNextLine( &context, &context ));
805
806 ret = TRUE;
807 done:
808 HeapFree( GetProcessHeap(), 0, dest_dir );
809 return ret;
810 }
811
812
813 /***********************************************************************
814 * SetupQueueRenameSectionA (SETUPAPI.@)
815 */
816 BOOL WINAPI SetupQueueRenameSectionA( HSPFILEQ queue, HINF hinf, HINF hlist, PCSTR section )
817 {
818 UNICODE_STRING sectionW;
819 BOOL ret = FALSE;
820
821 if (RtlCreateUnicodeStringFromAsciiz( &sectionW, section ))
822 {
823 ret = SetupQueueRenameSectionW( queue, hinf, hlist, sectionW.Buffer );
824 RtlFreeUnicodeString( &sectionW );
825 }
826 else SetLastError( ERROR_NOT_ENOUGH_MEMORY );
827 return ret;
828 }
829
830
831 /***********************************************************************
832 * SetupQueueRenameSectionW (SETUPAPI.@)
833 */
834 BOOL WINAPI SetupQueueRenameSectionW( HSPFILEQ queue, HINF hinf, HINF hlist, PCWSTR section )
835 {
836 INFCONTEXT context;
837 WCHAR *dest_dir;
838 WCHAR src[MAX_PATH], dst[MAX_PATH];
839 BOOL ret = FALSE;
840
841 TRACE( "hinf=%p/%p section=%s\n", hinf, hlist, debugstr_w(section) );
842
843 if (!hlist) hlist = hinf;
844 if (!SetupFindFirstLineW( hlist, section, NULL, &context )) return FALSE;
845 if (!(dest_dir = get_destination_dir( hinf, section ))) return FALSE;
846 do
847 {
848 if (!SetupGetStringFieldW( &context, 1, dst, sizeof(dst)/sizeof(WCHAR), NULL ))
849 goto done;
850 if (!SetupGetStringFieldW( &context, 2, src, sizeof(src)/sizeof(WCHAR), NULL ))
851 goto done;
852 if (!SetupQueueRenameW( queue, dest_dir, src, NULL, dst )) goto done;
853 } while (SetupFindNextLine( &context, &context ));
854
855 ret = TRUE;
856 done:
857 HeapFree( GetProcessHeap(), 0, dest_dir );
858 return ret;
859 }
860
861
862 /***********************************************************************
863 * SetupCommitFileQueueA (SETUPAPI.@)
864 */
865 BOOL WINAPI SetupCommitFileQueueA( HWND owner, HSPFILEQ queue, PSP_FILE_CALLBACK_A handler,
866 PVOID context )
867 {
868 struct callback_WtoA_context ctx;
869
870 ctx.orig_context = context;
871 ctx.orig_handler = handler;
872 return SetupCommitFileQueueW( owner, queue, QUEUE_callback_WtoA, &ctx );
873 }
874
875
876 /***********************************************************************
877 * create_full_pathW
878 *
879 * Recursively create all directories in the path.
880 */
881 static BOOL create_full_pathW(const WCHAR *path)
882 {
883 BOOL ret = TRUE;
884 int len;
885 WCHAR *new_path;
886
887 new_path = HeapAlloc(GetProcessHeap(), 0, (strlenW(path) + 1) * sizeof(WCHAR));
888 strcpyW(new_path, path);
889
890 while((len = strlenW(new_path)) && new_path[len - 1] == '\\')
891 new_path[len - 1] = 0;
892
893 while(!CreateDirectoryW(new_path, NULL))
894 {
895 WCHAR *slash;
896 DWORD last_error = GetLastError();
897
898 if(last_error == ERROR_ALREADY_EXISTS)
899 break;
900
901 if(last_error != ERROR_PATH_NOT_FOUND)
902 {
903 ret = FALSE;
904 break;
905 }
906
907 if(!(slash = strrchrW(new_path, '\\')))
908 {
909 ret = FALSE;
910 break;
911 }
912
913 len = slash - new_path;
914 new_path[len] = 0;
915 if(!create_full_pathW(new_path))
916 {
917 ret = FALSE;
918 break;
919 }
920 new_path[len] = '\\';
921 }
922
923 HeapFree(GetProcessHeap(), 0, new_path);
924 return ret;
925 }
926
927 static BOOL do_file_copyW( LPCWSTR source, LPCWSTR target, DWORD style,
928 PSP_FILE_CALLBACK_W handler, PVOID context )
929 {
930 BOOL rc = FALSE;
931 BOOL docopy = TRUE;
932
933 TRACE("copy %s to %s style 0x%x\n",debugstr_w(source),debugstr_w(target),style);
934
935 /* before copy processing */
936 if (style & SP_COPY_REPLACEONLY)
937 {
938 if (GetFileAttributesW(target) == INVALID_FILE_ATTRIBUTES)
939 docopy = FALSE;
940 }
941 if (style & (SP_COPY_NEWER_OR_SAME | SP_COPY_NEWER_ONLY | SP_COPY_FORCE_NEWER))
942 {
943 DWORD VersionSizeSource=0;
944 DWORD VersionSizeTarget=0;
945 DWORD zero=0;
946
947 /*
948 * This is sort of an interesting workaround. You see, calling
949 * GetVersionInfoSize on a builtin dll loads that dll into memory
950 * and we do not properly unload builtin dlls.. so we effectively
951 * lock into memory all the targets we are replacing. This leads
952 * to problems when we try to register the replaced dlls.
953 *
954 * So I will test for the existence of the files first so that
955 * we just basically unconditionally replace the builtin versions.
956 */
957 if ((GetFileAttributesW(target) != INVALID_FILE_ATTRIBUTES) &&
958 (GetFileAttributesW(source) != INVALID_FILE_ATTRIBUTES))
959 {
960 VersionSizeSource = GetFileVersionInfoSizeW(source,&zero);
961 VersionSizeTarget = GetFileVersionInfoSizeW(target,&zero);
962 }
963
964 TRACE("SizeTarget %i ... SizeSource %i\n",VersionSizeTarget,
965 VersionSizeSource);
966
967 if (VersionSizeSource && VersionSizeTarget)
968 {
969 LPVOID VersionSource;
970 LPVOID VersionTarget;
971 VS_FIXEDFILEINFO *TargetInfo;
972 VS_FIXEDFILEINFO *SourceInfo;
973 UINT length;
974 WCHAR SubBlock[2]={'\\',0};
975 DWORD ret;
976
977 VersionSource = HeapAlloc(GetProcessHeap(),0,VersionSizeSource);
978 VersionTarget = HeapAlloc(GetProcessHeap(),0,VersionSizeTarget);
979
980 ret = GetFileVersionInfoW(source,0,VersionSizeSource,VersionSource);
981 if (ret)
982 ret = GetFileVersionInfoW(target, 0, VersionSizeTarget,
983 VersionTarget);
984
985 if (ret)
986 {
987 ret = VerQueryValueW(VersionSource, SubBlock,
988 (LPVOID*)&SourceInfo, &length);
989 if (ret)
990 ret = VerQueryValueW(VersionTarget, SubBlock,
991 (LPVOID*)&TargetInfo, &length);
992
993 if (ret)
994 {
995 FILEPATHS_W filepaths;
996
997 TRACE("Versions: Source %i.%i target %i.%i\n",
998 SourceInfo->dwFileVersionMS, SourceInfo->dwFileVersionLS,
999 TargetInfo->dwFileVersionMS, TargetInfo->dwFileVersionLS);
1000
1001 /* used in case of notification */
1002 filepaths.Target = target;
1003 filepaths.Source = source;
1004 filepaths.Win32Error = 0;
1005 filepaths.Flags = 0;
1006
1007 if (TargetInfo->dwFileVersionMS > SourceInfo->dwFileVersionMS)
1008 {
1009 if (handler)
1010 docopy = handler (context, SPFILENOTIFY_TARGETNEWER, (UINT_PTR)&filepaths, 0);
1011 else
1012 docopy = FALSE;
1013 }
1014 else if ((TargetInfo->dwFileVersionMS == SourceInfo->dwFileVersionMS)
1015 && (TargetInfo->dwFileVersionLS > SourceInfo->dwFileVersionLS))
1016 {
1017 if (handler)
1018 docopy = handler (context, SPFILENOTIFY_TARGETNEWER, (UINT_PTR)&filepaths, 0);
1019 else
1020 docopy = FALSE;
1021 }
1022 else if ((style & SP_COPY_NEWER_ONLY) &&
1023 (TargetInfo->dwFileVersionMS ==
1024 SourceInfo->dwFileVersionMS)
1025 &&(TargetInfo->dwFileVersionLS ==
1026 SourceInfo->dwFileVersionLS))
1027 {
1028 if (handler)
1029 docopy = handler (context, SPFILENOTIFY_TARGETNEWER, (UINT_PTR)&filepaths, 0);
1030 else
1031 docopy = FALSE;
1032 }
1033 }
1034 }
1035 HeapFree(GetProcessHeap(),0,VersionSource);
1036 HeapFree(GetProcessHeap(),0,VersionTarget);
1037 }
1038 }
1039 if (style & (SP_COPY_NOOVERWRITE | SP_COPY_FORCE_NOOVERWRITE))
1040 {
1041 if (GetFileAttributesW(target) != INVALID_FILE_ATTRIBUTES)
1042 {
1043 FIXME("Notify user target file exists\n");
1044 docopy = FALSE;
1045 }
1046 }
1047 if (style & (SP_COPY_NODECOMP | SP_COPY_LANGUAGEAWARE | SP_COPY_FORCE_IN_USE |
1048 SP_COPY_IN_USE_NEEDS_REBOOT | SP_COPY_NOSKIP | SP_COPY_WARNIFSKIP))
1049 {
1050 ERR("Unsupported style(s) 0x%x\n",style);
1051 }
1052
1053 if (docopy)
1054 {
1055 rc = CopyFileW(source,target,FALSE);
1056 TRACE("Did copy... rc was %i\n",rc);
1057 }
1058
1059 /* after copy processing */
1060 if (style & SP_COPY_DELETESOURCE)
1061 {
1062 if (rc)
1063 DeleteFileW(source);
1064 }
1065
1066 return rc;
1067 }
1068
1069 /***********************************************************************
1070 * SetupInstallFileExA (SETUPAPI.@)
1071 */
1072 BOOL WINAPI SetupInstallFileExA( HINF hinf, PINFCONTEXT inf_context, PCSTR source, PCSTR root,
1073 PCSTR dest, DWORD style, PSP_FILE_CALLBACK_A handler, PVOID context, PBOOL in_use )
1074 {
1075 BOOL ret = FALSE;
1076 struct callback_WtoA_context ctx;
1077 UNICODE_STRING sourceW, rootW, destW;
1078
1079 TRACE("%p %p %s %s %s %x %p %p %p\n", hinf, inf_context, debugstr_a(source), debugstr_a(root),
1080 debugstr_a(dest), style, handler, context, in_use);
1081
1082 sourceW.Buffer = rootW.Buffer = destW.Buffer = NULL;
1083 if (source && !RtlCreateUnicodeStringFromAsciiz( &sourceW, source ))
1084 {
1085 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1086 return FALSE;
1087 }
1088 if (root && !RtlCreateUnicodeStringFromAsciiz( &rootW, root ))
1089 {
1090 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1091 goto exit;
1092 }
1093 if (dest && !RtlCreateUnicodeStringFromAsciiz( &destW, dest ))
1094 {
1095 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1096 goto exit;
1097 }
1098
1099 ctx.orig_context = context;
1100 ctx.orig_handler = handler;
1101
1102 ret = SetupInstallFileExW( hinf, inf_context, sourceW.Buffer, rootW.Buffer, destW.Buffer, style, QUEUE_callback_WtoA, &ctx, in_use );
1103
1104 exit:
1105 RtlFreeUnicodeString( &sourceW );
1106 RtlFreeUnicodeString( &rootW );
1107 RtlFreeUnicodeString( &destW );
1108 return ret;
1109 }
1110
1111 /***********************************************************************
1112 * SetupInstallFileA (SETUPAPI.@)
1113 */
1114 BOOL WINAPI SetupInstallFileA( HINF hinf, PINFCONTEXT inf_context, PCSTR source, PCSTR root,
1115 PCSTR dest, DWORD style, PSP_FILE_CALLBACK_A handler, PVOID context )
1116 {
1117 return SetupInstallFileExA( hinf, inf_context, source, root, dest, style, handler, context, NULL );
1118 }
1119
1120 /***********************************************************************
1121 * SetupInstallFileExW (SETUPAPI.@)
1122 */
1123 BOOL WINAPI SetupInstallFileExW( HINF hinf, PINFCONTEXT inf_context, PCWSTR source, PCWSTR root,
1124 PCWSTR dest, DWORD style, PSP_FILE_CALLBACK_W handler, PVOID context, PBOOL in_use )
1125 {
1126 static const WCHAR CopyFiles[] = {'C','o','p','y','F','i','l','e','s',0};
1127
1128 BOOL ret, absolute = (root && *root && !(style & SP_COPY_SOURCE_ABSOLUTE));
1129 WCHAR *buffer, *p, *inf_source = NULL;
1130 unsigned int len;
1131
1132 TRACE("%p %p %s %s %s %x %p %p %p\n", hinf, inf_context, debugstr_w(source), debugstr_w(root),
1133 debugstr_w(dest), style, handler, context, in_use);
1134
1135 if (in_use) FIXME("no file in use support\n");
1136
1137 if (hinf)
1138 {
1139 INFCONTEXT ctx;
1140
1141 if (!inf_context)
1142 {
1143 inf_context = &ctx;
1144 if (!SetupFindFirstLineW( hinf, CopyFiles, NULL, inf_context )) return FALSE;
1145 }
1146 if (!SetupGetStringFieldW( inf_context, 1, NULL, 0, &len )) return FALSE;
1147 if (!(inf_source = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
1148 {
1149 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1150 return FALSE;
1151 }
1152 if (!SetupGetStringFieldW( inf_context, 1, inf_source, len, NULL )) return FALSE;
1153 source = inf_source;
1154 }
1155 else if (!source)
1156 {
1157 SetLastError( ERROR_INVALID_PARAMETER );
1158 return FALSE;
1159 }
1160
1161 len = strlenW( source ) + 1;
1162 if (absolute) len += strlenW( root ) + 1;
1163
1164 if (!(p = buffer = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
1165 {
1166 HeapFree( GetProcessHeap(), 0, inf_source );
1167 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1168 return FALSE;
1169 }
1170
1171 if (absolute)
1172 {
1173 strcpyW( buffer, root );
1174 p += strlenW( buffer );
1175 if (p[-1] != '\\') *p++ = '\\';
1176 }
1177 while (*source == '\\') source++;
1178 strcpyW( p, source );
1179
1180 ret = do_file_copyW( buffer, dest, style, handler, context );
1181
1182 HeapFree( GetProcessHeap(), 0, inf_source );
1183 HeapFree( GetProcessHeap(), 0, buffer );
1184 return ret;
1185 }
1186
1187 /***********************************************************************
1188 * SetupInstallFileW (SETUPAPI.@)
1189 */
1190 BOOL WINAPI SetupInstallFileW( HINF hinf, PINFCONTEXT inf_context, PCWSTR source, PCWSTR root,
1191 PCWSTR dest, DWORD style, PSP_FILE_CALLBACK_W handler, PVOID context )
1192 {
1193 return SetupInstallFileExW( hinf, inf_context, source, root, dest, style, handler, context, NULL );
1194 }
1195
1196 /***********************************************************************
1197 * SetupCommitFileQueueW (SETUPAPI.@)
1198 */
1199 BOOL WINAPI SetupCommitFileQueueW( HWND owner, HSPFILEQ handle, PSP_FILE_CALLBACK_W handler,
1200 PVOID context )
1201 {
1202 struct file_queue *queue = handle;
1203 struct file_op *op;
1204 BOOL result = FALSE;
1205 FILEPATHS_W paths;
1206 UINT op_result;
1207
1208 paths.Source = paths.Target = NULL;
1209
1210 if (!queue->copy_queue.count && !queue->delete_queue.count && !queue->rename_queue.count)
1211 return TRUE; /* nothing to do */
1212
1213 if (!handler( context, SPFILENOTIFY_STARTQUEUE, (UINT_PTR)owner, 0 )) return FALSE;
1214
1215 /* perform deletes */
1216
1217 if (queue->delete_queue.count)
1218 {
1219 if (!(handler( context, SPFILENOTIFY_STARTSUBQUEUE, FILEOP_DELETE,
1220 queue->delete_queue.count ))) goto done;
1221 for (op = queue->delete_queue.head; op; op = op->next)
1222 {
1223 build_filepathsW( op, &paths );
1224 op_result = handler( context, SPFILENOTIFY_STARTDELETE, (UINT_PTR)&paths, FILEOP_DELETE);
1225 if (op_result == FILEOP_ABORT) goto done;
1226 while (op_result == FILEOP_DOIT)
1227 {
1228 TRACE( "deleting file %s\n", debugstr_w(paths.Target) );
1229 if (DeleteFileW( paths.Target )) break; /* success */
1230 paths.Win32Error = GetLastError();
1231 op_result = handler( context, SPFILENOTIFY_DELETEERROR, (UINT_PTR)&paths, 0 );
1232 if (op_result == FILEOP_ABORT) goto done;
1233 }
1234 handler( context, SPFILENOTIFY_ENDDELETE, (UINT_PTR)&paths, 0 );
1235 }
1236 handler( context, SPFILENOTIFY_ENDSUBQUEUE, FILEOP_DELETE, 0 );
1237 }
1238
1239 /* perform renames */
1240
1241 if (queue->rename_queue.count)
1242 {
1243 if (!(handler( context, SPFILENOTIFY_STARTSUBQUEUE, FILEOP_RENAME,
1244 queue->rename_queue.count ))) goto done;
1245 for (op = queue->rename_queue.head; op; op = op->next)
1246 {
1247 build_filepathsW( op, &paths );
1248 op_result = handler( context, SPFILENOTIFY_STARTRENAME, (UINT_PTR)&paths, FILEOP_RENAME);
1249 if (op_result == FILEOP_ABORT) goto done;
1250 while (op_result == FILEOP_DOIT)
1251 {
1252 TRACE( "renaming file %s -> %s\n",
1253 debugstr_w(paths.Source), debugstr_w(paths.Target) );
1254 if (MoveFileW( paths.Source, paths.Target )) break; /* success */
1255 paths.Win32Error = GetLastError();
1256 op_result = handler( context, SPFILENOTIFY_RENAMEERROR, (UINT_PTR)&paths, 0 );
1257 if (op_result == FILEOP_ABORT) goto done;
1258 }
1259 handler( context, SPFILENOTIFY_ENDRENAME, (UINT_PTR)&paths, 0 );
1260 }
1261 handler( context, SPFILENOTIFY_ENDSUBQUEUE, FILEOP_RENAME, 0 );
1262 }
1263
1264 /* perform copies */
1265
1266 if (queue->copy_queue.count)
1267 {
1268 if (!(handler( context, SPFILENOTIFY_STARTSUBQUEUE, FILEOP_COPY,
1269 queue->copy_queue.count ))) goto done;
1270 for (op = queue->copy_queue.head; op; op = op->next)
1271 {
1272 WCHAR newpath[MAX_PATH];
1273
1274 build_filepathsW( op, &paths );
1275 op_result = handler( context, SPFILENOTIFY_STARTCOPY, (UINT_PTR)&paths, FILEOP_COPY );
1276 if (op_result == FILEOP_ABORT) goto done;
1277 if (op_result == FILEOP_NEWPATH) op_result = FILEOP_DOIT;
1278 while (op_result == FILEOP_DOIT || op_result == FILEOP_NEWPATH)
1279 {
1280 TRACE( "copying file %s -> %s\n",
1281 debugstr_w( op_result == FILEOP_NEWPATH ? newpath : paths.Source ),
1282 debugstr_w(paths.Target) );
1283 if (op->dst_path)
1284 {
1285 if (!create_full_pathW( op->dst_path ))
1286 {
1287 paths.Win32Error = GetLastError();
1288 op_result = handler( context, SPFILENOTIFY_COPYERROR,
1289 (UINT_PTR)&paths, (UINT_PTR)newpath );
1290 if (op_result == FILEOP_ABORT) goto done;
1291 }
1292 }
1293 if (do_file_copyW( op_result == FILEOP_NEWPATH ? newpath : paths.Source,
1294 paths.Target, op->style, handler, context )) break; /* success */
1295 /* try to extract it from the cabinet file */
1296 if (op->src_tag)
1297 {
1298 if (extract_cabinet_file( op->src_tag, op->src_root,
1299 paths.Source, paths.Target )) break;
1300 }
1301 paths.Win32Error = GetLastError();
1302 op_result = handler( context, SPFILENOTIFY_COPYERROR,
1303 (UINT_PTR)&paths, (UINT_PTR)newpath );
1304 if (op_result == FILEOP_ABORT) goto done;
1305 }
1306 handler( context, SPFILENOTIFY_ENDCOPY, (UINT_PTR)&paths, 0 );
1307 }
1308 handler( context, SPFILENOTIFY_ENDSUBQUEUE, FILEOP_COPY, 0 );
1309 }
1310
1311
1312 result = TRUE;
1313
1314 done:
1315 handler( context, SPFILENOTIFY_ENDQUEUE, result, 0 );
1316 HeapFree( GetProcessHeap(), 0, (void *)paths.Source );
1317 HeapFree( GetProcessHeap(), 0, (void *)paths.Target );
1318 return result;
1319 }
1320
1321
1322 /***********************************************************************
1323 * SetupScanFileQueueA (SETUPAPI.@)
1324 */
1325 BOOL WINAPI SetupScanFileQueueA( HSPFILEQ handle, DWORD flags, HWND window,
1326 PSP_FILE_CALLBACK_A handler, PVOID context, PDWORD result )
1327 {
1328 struct callback_WtoA_context ctx;
1329
1330 TRACE("%p %x %p %p %p %p\n", handle, flags, window, handler, context, result);
1331
1332 ctx.orig_context = context;
1333 ctx.orig_handler = handler;
1334
1335 return SetupScanFileQueueW( handle, flags, window, QUEUE_callback_WtoA, &ctx, result );
1336 }
1337
1338
1339 /***********************************************************************
1340 * SetupScanFileQueueW (SETUPAPI.@)
1341 */
1342 BOOL WINAPI SetupScanFileQueueW( HSPFILEQ handle, DWORD flags, HWND window,
1343 PSP_FILE_CALLBACK_W handler, PVOID context, PDWORD result )
1344 {
1345 struct file_queue *queue = handle;
1346 struct file_op *op;
1347 FILEPATHS_W paths;
1348 UINT notification = 0;
1349 BOOL ret = FALSE;
1350
1351 TRACE("%p %x %p %p %p %p\n", handle, flags, window, handler, context, result);
1352
1353 if (!queue->copy_queue.count) return TRUE;
1354
1355 if (flags & SPQ_SCAN_USE_CALLBACK) notification = SPFILENOTIFY_QUEUESCAN;
1356 else if (flags & SPQ_SCAN_USE_CALLBACKEX) notification = SPFILENOTIFY_QUEUESCAN_EX;
1357
1358 if (flags & ~(SPQ_SCAN_USE_CALLBACK | SPQ_SCAN_USE_CALLBACKEX))
1359 {
1360 FIXME("flags %x not fully implemented\n", flags);
1361 }
1362
1363 paths.Source = paths.Target = NULL;
1364
1365 for (op = queue->copy_queue.head; op; op = op->next)
1366 {
1367 build_filepathsW( op, &paths );
1368 switch (notification)
1369 {
1370 case SPFILENOTIFY_QUEUESCAN:
1371 /* FIXME: handle delay flag */
1372 if (handler( context, notification, (UINT_PTR)paths.Target, 0 )) goto done;
1373 break;
1374 case SPFILENOTIFY_QUEUESCAN_EX:
1375 if (handler( context, notification, (UINT_PTR)&paths, 0 )) goto done;
1376 break;
1377 default:
1378 ret = TRUE; goto done;
1379 }
1380 }
1381
1382 ret = TRUE;
1383
1384 done:
1385 if (result) *result = 0;
1386 HeapFree( GetProcessHeap(), 0, (void *)paths.Source );
1387 HeapFree( GetProcessHeap(), 0, (void *)paths.Target );
1388 return ret;
1389 }
1390
1391
1392 /***********************************************************************
1393 * SetupGetFileQueueCount (SETUPAPI.@)
1394 */
1395 BOOL WINAPI SetupGetFileQueueCount( HSPFILEQ handle, UINT op, PUINT result )
1396 {
1397 struct file_queue *queue = handle;
1398
1399 switch(op)
1400 {
1401 case FILEOP_COPY:
1402 *result = queue->copy_queue.count;
1403 return TRUE;
1404 case FILEOP_RENAME:
1405 *result = queue->rename_queue.count;
1406 return TRUE;
1407 case FILEOP_DELETE:
1408 *result = queue->delete_queue.count;
1409 return TRUE;
1410 }
1411 return FALSE;
1412 }
1413
1414
1415 /***********************************************************************
1416 * SetupGetFileQueueFlags (SETUPAPI.@)
1417 */
1418 BOOL WINAPI SetupGetFileQueueFlags( HSPFILEQ handle, PDWORD flags )
1419 {
1420 struct file_queue *queue = handle;
1421 *flags = queue->flags;
1422 return TRUE;
1423 }
1424
1425
1426 /***********************************************************************
1427 * SetupSetFileQueueFlags (SETUPAPI.@)
1428 */
1429 BOOL WINAPI SetupSetFileQueueFlags( HSPFILEQ handle, DWORD mask, DWORD flags )
1430 {
1431 struct file_queue *queue = handle;
1432 queue->flags = (queue->flags & ~mask) | flags;
1433 return TRUE;
1434 }
1435
1436
1437 /***********************************************************************
1438 * SetupSetFileQueueAlternatePlatformA (SETUPAPI.@)
1439 */
1440 BOOL WINAPI SetupSetFileQueueAlternatePlatformA(HSPFILEQ handle, PSP_ALTPLATFORM_INFO platform, PCSTR catalogfile)
1441 {
1442 FIXME("(%p, %p, %s) stub!\n", handle, platform, debugstr_a(catalogfile));
1443 return FALSE;
1444 }
1445
1446
1447 /***********************************************************************
1448 * SetupSetFileQueueAlternatePlatformW (SETUPAPI.@)
1449 */
1450 BOOL WINAPI SetupSetFileQueueAlternatePlatformW(HSPFILEQ handle, PSP_ALTPLATFORM_INFO platform, PCWSTR catalogfile)
1451 {
1452 FIXME("(%p, %p, %s) stub!\n", handle, platform, debugstr_w(catalogfile));
1453 return FALSE;
1454 }
1455
1456
1457 /***********************************************************************
1458 * SetupInitDefaultQueueCallback (SETUPAPI.@)
1459 */
1460 PVOID WINAPI SetupInitDefaultQueueCallback( HWND owner )
1461 {
1462 return SetupInitDefaultQueueCallbackEx( owner, 0, 0, 0, NULL );
1463 }
1464
1465
1466 /***********************************************************************
1467 * SetupInitDefaultQueueCallbackEx (SETUPAPI.@)
1468 */
1469 PVOID WINAPI SetupInitDefaultQueueCallbackEx( HWND owner, HWND progress, UINT msg,
1470 DWORD reserved1, PVOID reserved2 )
1471 {
1472 struct default_callback_context *context;
1473
1474 if ((context = HeapAlloc( GetProcessHeap(), 0, sizeof(*context) )))
1475 {
1476 context->owner = owner;
1477 context->progress = progress;
1478 context->message = msg;
1479 }
1480 return context;
1481 }
1482
1483
1484 /***********************************************************************
1485 * SetupTermDefaultQueueCallback (SETUPAPI.@)
1486 */
1487 void WINAPI SetupTermDefaultQueueCallback( PVOID context )
1488 {
1489 HeapFree( GetProcessHeap(), 0, context );
1490 }
1491
1492
1493 /***********************************************************************
1494 * SetupDefaultQueueCallbackA (SETUPAPI.@)
1495 */
1496 UINT WINAPI SetupDefaultQueueCallbackA( PVOID context, UINT notification,
1497 UINT_PTR param1, UINT_PTR param2 )
1498 {
1499 FILEPATHS_A *paths = (FILEPATHS_A *)param1;
1500 struct default_callback_context *ctx = context;
1501
1502 switch(notification)
1503 {
1504 case SPFILENOTIFY_STARTQUEUE:
1505 TRACE( "start queue\n" );
1506 return TRUE;
1507 case SPFILENOTIFY_ENDQUEUE:
1508 TRACE( "end queue\n" );
1509 return 0;
1510 case SPFILENOTIFY_STARTSUBQUEUE:
1511 TRACE( "start subqueue %ld count %ld\n", param1, param2 );
1512 return TRUE;
1513 case SPFILENOTIFY_ENDSUBQUEUE:
1514 TRACE( "end subqueue %ld\n", param1 );
1515 return 0;
1516 case SPFILENOTIFY_STARTDELETE:
1517 TRACE( "start delete %s\n", debugstr_a(paths->Target) );
1518 return FILEOP_DOIT;
1519 case SPFILENOTIFY_ENDDELETE:
1520 TRACE( "end delete %s\n", debugstr_a(paths->Target) );
1521 return 0;
1522 case SPFILENOTIFY_DELETEERROR:
1523 /*Windows Ignores attempts to delete files / folders which do not exist*/
1524 if ((paths->Win32Error != ERROR_FILE_NOT_FOUND) && (paths->Win32Error != ERROR_PATH_NOT_FOUND))
1525 SetupDeleteErrorA(ctx->owner, NULL, paths->Target, paths->Win32Error, 0);
1526 return FILEOP_SKIP;
1527 case SPFILENOTIFY_STARTRENAME:
1528 TRACE( "start rename %s -> %s\n", debugstr_a(paths->Source), debugstr_a(paths->Target) );
1529 return FILEOP_DOIT;
1530 case SPFILENOTIFY_ENDRENAME:
1531 TRACE( "end rename %s -> %s\n", debugstr_a(paths->Source), debugstr_a(paths->Target) );
1532 return 0;
1533 case SPFILENOTIFY_RENAMEERROR:
1534 SetupRenameErrorA(ctx->owner, NULL, paths->Source, paths->Target, paths->Win32Error, 0);
1535 return FILEOP_SKIP;
1536 case SPFILENOTIFY_STARTCOPY:
1537 TRACE( "start copy %s -> %s\n", debugstr_a(paths->Source), debugstr_a(paths->Target) );
1538 return FILEOP_DOIT;
1539 case SPFILENOTIFY_ENDCOPY:
1540 TRACE( "end copy %s -> %s\n", debugstr_a(paths->Source), debugstr_a(paths->Target) );
1541 return 0;
1542 case SPFILENOTIFY_COPYERROR:
1543 ERR( "copy error %d %s -> %s\n", paths->Win32Error,
1544 debugstr_a(paths->Source), debugstr_a(paths->Target) );
1545 return FILEOP_SKIP;
1546 case SPFILENOTIFY_NEEDMEDIA:
1547 TRACE( "need media\n" );
1548 return FILEOP_SKIP;
1549 default:
1550 FIXME( "notification %d params %lx,%lx\n", notification, param1, param2 );
1551 break;
1552 }
1553 return 0;
1554 }
1555
1556
1557 /***********************************************************************
1558 * SetupDefaultQueueCallbackW (SETUPAPI.@)
1559 */
1560 UINT WINAPI SetupDefaultQueueCallbackW( PVOID context, UINT notification,
1561 UINT_PTR param1, UINT_PTR param2 )
1562 {
1563 FILEPATHS_W *paths = (FILEPATHS_W *)param1;
1564 struct default_callback_context *ctx = context;
1565
1566 switch(notification)
1567 {
1568 case SPFILENOTIFY_STARTQUEUE:
1569 TRACE( "start queue\n" );
1570 return TRUE;
1571 case SPFILENOTIFY_ENDQUEUE:
1572 TRACE( "end queue\n" );
1573 return 0;
1574 case SPFILENOTIFY_STARTSUBQUEUE:
1575 TRACE( "start subqueue %ld count %ld\n", param1, param2 );
1576 return TRUE;
1577 case SPFILENOTIFY_ENDSUBQUEUE:
1578 TRACE( "end subqueue %ld\n", param1 );
1579 return 0;
1580 case SPFILENOTIFY_STARTDELETE:
1581 TRACE( "start delete %s\n", debugstr_w(paths->Target) );
1582 return FILEOP_DOIT;
1583 case SPFILENOTIFY_ENDDELETE:
1584 TRACE( "end delete %s\n", debugstr_w(paths->Target) );
1585 return 0;
1586 case SPFILENOTIFY_DELETEERROR:
1587 /*Windows Ignores attempts to delete files / folders which do not exist*/
1588 if ((paths->Win32Error != ERROR_FILE_NOT_FOUND) && (paths->Win32Error != ERROR_PATH_NOT_FOUND))
1589 SetupDeleteErrorW(ctx->owner, NULL, paths->Target, paths->Win32Error, 0);
1590 return FILEOP_SKIP;
1591 case SPFILENOTIFY_STARTRENAME:
1592 SetupRenameErrorW(ctx->owner, NULL, paths->Source, paths->Target, paths->Win32Error, 0);
1593 return FILEOP_DOIT;
1594 case SPFILENOTIFY_ENDRENAME:
1595 TRACE( "end rename %s -> %s\n", debugstr_w(paths->Source), debugstr_w(paths->Target) );
1596 return 0;
1597 case SPFILENOTIFY_RENAMEERROR:
1598 ERR( "rename error %d %s -> %s\n", paths->Win32Error,
1599 debugstr_w(paths->Source), debugstr_w(paths->Target) );
1600 return FILEOP_SKIP;
1601 case SPFILENOTIFY_STARTCOPY:
1602 TRACE( "start copy %s -> %s\n", debugstr_w(paths->Source), debugstr_w(paths->Target) );
1603 return FILEOP_DOIT;
1604 case SPFILENOTIFY_ENDCOPY:
1605 TRACE( "end copy %s -> %s\n", debugstr_w(paths->Source), debugstr_w(paths->Target) );
1606 return 0;
1607 case SPFILENOTIFY_COPYERROR:
1608 ERR( "copy error %d %s -> %s\n", paths->Win32Error,
1609 debugstr_w(paths->Source), debugstr_w(paths->Target) );
1610 return FILEOP_SKIP;
1611 case SPFILENOTIFY_NEEDMEDIA:
1612 TRACE( "need media\n" );
1613 return FILEOP_SKIP;
1614 default:
1615 FIXME( "notification %d params %lx,%lx\n", notification, param1, param2 );
1616 break;
1617 }
1618 return 0;
1619 }
1620
1621 /***********************************************************************
1622 * SetupDeleteErrorA (SETUPAPI.@)
1623 */
1624
1625 UINT WINAPI SetupDeleteErrorA( HWND parent, PCSTR dialogTitle, PCSTR file,
1626 UINT w32error, DWORD style)
1627 {
1628 FIXME( "stub: (Error Number %d when attempting to delete %s)\n",
1629 w32error, debugstr_a(file) );
1630 return DPROMPT_SKIPFILE;
1631 }
1632
1633 /***********************************************************************
1634 * SetupDeleteErrorW (SETUPAPI.@)
1635 */
1636
1637 UINT WINAPI SetupDeleteErrorW( HWND parent, PCWSTR dialogTitle, PCWSTR file,
1638 UINT w32error, DWORD style)
1639 {
1640 FIXME( "stub: (Error Number %d when attempting to delete %s)\n",
1641 w32error, debugstr_w(file) );
1642 return DPROMPT_SKIPFILE;
1643 }
1644
1645 /***********************************************************************
1646 * SetupRenameErrorA (SETUPAPI.@)
1647 */
1648
1649 UINT WINAPI SetupRenameErrorA( HWND parent, PCSTR dialogTitle, PCSTR source,
1650 PCSTR target, UINT w32error, DWORD style)
1651 {
1652 FIXME( "stub: (Error Number %d when attempting to rename %s to %s)\n",
1653 w32error, debugstr_a(source), debugstr_a(target));
1654 return DPROMPT_SKIPFILE;
1655 }
1656
1657 /***********************************************************************
1658 * SetupRenameErrorW (SETUPAPI.@)
1659 */
1660
1661 UINT WINAPI SetupRenameErrorW( HWND parent, PCWSTR dialogTitle, PCWSTR source,
1662 PCWSTR target, UINT w32error, DWORD style)
1663 {
1664 FIXME( "stub: (Error Number %d when attempting to rename %s to %s)\n",
1665 w32error, debugstr_w(source), debugstr_w(target));
1666 return DPROMPT_SKIPFILE;
1667 }
1668
1669
1670 /***********************************************************************
1671 * SetupCopyErrorA (SETUPAPI.@)
1672 */
1673
1674 UINT WINAPI SetupCopyErrorA( HWND parent, PCSTR dialogTitle, PCSTR diskname,
1675 PCSTR sourcepath, PCSTR sourcefile, PCSTR targetpath,
1676 UINT w32error, DWORD style, PSTR pathbuffer,
1677 DWORD buffersize, PDWORD requiredsize)
1678 {
1679 FIXME( "stub: (Error Number %d when attempting to copy file %s from %s to %s)\n",
1680 w32error, debugstr_a(sourcefile), debugstr_a(sourcepath) ,debugstr_a(targetpath));
1681 return DPROMPT_SKIPFILE;
1682 }
1683
1684 /***********************************************************************
1685 * SetupCopyErrorW (SETUPAPI.@)
1686 */
1687
1688 UINT WINAPI SetupCopyErrorW( HWND parent, PCWSTR dialogTitle, PCWSTR diskname,
1689 PCWSTR sourcepath, PCWSTR sourcefile, PCWSTR targetpath,
1690 UINT w32error, DWORD style, PWSTR pathbuffer,
1691 DWORD buffersize, PDWORD requiredsize)
1692 {
1693 FIXME( "stub: (Error Number %d when attempting to copy file %s from %s to %s)\n",
1694 w32error, debugstr_w(sourcefile), debugstr_w(sourcepath) ,debugstr_w(targetpath));
1695 return DPROMPT_SKIPFILE;
1696 }
1697
1698 /***********************************************************************
1699 * pSetupGetQueueFlags (SETUPAPI.@)
1700 */
1701 DWORD WINAPI pSetupGetQueueFlags( HSPFILEQ handle )
1702 {
1703 struct file_queue *queue = handle;
1704 return queue->flags;
1705 }
1706
1707 /***********************************************************************
1708 * pSetupSetQueueFlags (SETUPAPI.@)
1709 */
1710 BOOL WINAPI pSetupSetQueueFlags( HSPFILEQ handle, DWORD flags )
1711 {
1712 struct file_queue *queue = handle;
1713 queue->flags = flags;
1714 return TRUE;
1715 }
useful hacks and other patches not (yet) suitable for mainline