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