?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
push 378fe7a60681a28e8b22f62dcfe122d585b92570
[wine/hacks.git] / dlls / setupapi / queue.c
blob6c9ca642c18f568e9180fb596c50a411ab77a60f
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];
726 INT flags;
727
728 TRACE( "hinf=%p/%p section=%s root=%s\n",
729 hinf, hlist, debugstr_w(section), debugstr_w(src_root) );
730
731 params.cbSize = sizeof(params);
732 params.QueueHandle = queue;
733 params.SourceRootPath = src_root;
734 params.SourcePath = NULL;
735 params.SourceDescription = NULL;
736 params.SourceTagfile = NULL;
737 params.TargetFilename = dest;
738 params.CopyStyle = style;
739 params.LayoutInf = hinf;
740 params.SecurityDescriptor = NULL;
741
742 if (!hlist) hlist = hinf;
743 if (!hinf) hinf = hlist;
744 if (!SetupFindFirstLineW( hlist, section, NULL, &context )) return FALSE;
745 if (!(params.TargetDirectory = get_destination_dir( hinf, section ))) return FALSE;
746 do
747 {
748 if (!SetupGetStringFieldW( &context, 1, dest, sizeof(dest)/sizeof(WCHAR), NULL ))
749 return FALSE;
750 if (!SetupGetStringFieldW( &context, 2, src, sizeof(src)/sizeof(WCHAR), NULL )) *src = 0;
751 if (!SetupGetIntField( &context, 4, &flags )) flags = 0; /* FIXME */
752
753 params.SourceFilename = *src ? src : NULL;
754 if (!SetupQueueCopyIndirectW( &params )) return FALSE;
755 } while (SetupFindNextLine( &context, &context ));
756 return TRUE;
757 }
758
759
760 /***********************************************************************
761 * SetupQueueDeleteSectionA (SETUPAPI.@)
762 */
763 BOOL WINAPI SetupQueueDeleteSectionA( HSPFILEQ queue, HINF hinf, HINF hlist, PCSTR section )
764 {
765 UNICODE_STRING sectionW;
766 BOOL ret = FALSE;
767
768 if (RtlCreateUnicodeStringFromAsciiz( &sectionW, section ))
769 {
770 ret = SetupQueueDeleteSectionW( queue, hinf, hlist, sectionW.Buffer );
771 RtlFreeUnicodeString( &sectionW );
772 }
773 else SetLastError( ERROR_NOT_ENOUGH_MEMORY );
774 return ret;
775 }
776
777
778 /***********************************************************************
779 * SetupQueueDeleteSectionW (SETUPAPI.@)
780 */
781 BOOL WINAPI SetupQueueDeleteSectionW( HSPFILEQ queue, HINF hinf, HINF hlist, PCWSTR section )
782 {
783 INFCONTEXT context;
784 WCHAR *dest_dir;
785 WCHAR buffer[MAX_PATH];
786 BOOL ret = FALSE;
787 INT flags;
788
789 TRACE( "hinf=%p/%p section=%s\n", hinf, hlist, debugstr_w(section) );
790
791 if (!hlist) hlist = hinf;
792 if (!SetupFindFirstLineW( hlist, section, NULL, &context )) return FALSE;
793 if (!(dest_dir = get_destination_dir( hinf, section ))) return FALSE;
794 do
795 {
796 if (!SetupGetStringFieldW( &context, 1, buffer, sizeof(buffer)/sizeof(WCHAR), NULL ))
797 goto done;
798 if (!SetupGetIntField( &context, 4, &flags )) flags = 0;
799 if (!SetupQueueDeleteW( queue, dest_dir, buffer )) goto done;
800 } while (SetupFindNextLine( &context, &context ));
801
802 ret = TRUE;
803 done:
804 HeapFree( GetProcessHeap(), 0, dest_dir );
805 return ret;
806 }
807
808
809 /***********************************************************************
810 * SetupQueueRenameSectionA (SETUPAPI.@)
811 */
812 BOOL WINAPI SetupQueueRenameSectionA( HSPFILEQ queue, HINF hinf, HINF hlist, PCSTR section )
813 {
814 UNICODE_STRING sectionW;
815 BOOL ret = FALSE;
816
817 if (RtlCreateUnicodeStringFromAsciiz( &sectionW, section ))
818 {
819 ret = SetupQueueRenameSectionW( queue, hinf, hlist, sectionW.Buffer );
820 RtlFreeUnicodeString( &sectionW );
821 }
822 else SetLastError( ERROR_NOT_ENOUGH_MEMORY );
823 return ret;
824 }
825
826
827 /***********************************************************************
828 * SetupQueueRenameSectionW (SETUPAPI.@)
829 */
830 BOOL WINAPI SetupQueueRenameSectionW( HSPFILEQ queue, HINF hinf, HINF hlist, PCWSTR section )
831 {
832 INFCONTEXT context;
833 WCHAR *dest_dir;
834 WCHAR src[MAX_PATH], dst[MAX_PATH];
835 BOOL ret = FALSE;
836
837 TRACE( "hinf=%p/%p section=%s\n", hinf, hlist, debugstr_w(section) );
838
839 if (!hlist) hlist = hinf;
840 if (!SetupFindFirstLineW( hlist, section, NULL, &context )) return FALSE;
841 if (!(dest_dir = get_destination_dir( hinf, section ))) return FALSE;
842 do
843 {
844 if (!SetupGetStringFieldW( &context, 1, dst, sizeof(dst)/sizeof(WCHAR), NULL ))
845 goto done;
846 if (!SetupGetStringFieldW( &context, 2, src, sizeof(src)/sizeof(WCHAR), NULL ))
847 goto done;
848 if (!SetupQueueRenameW( queue, dest_dir, src, NULL, dst )) goto done;
849 } while (SetupFindNextLine( &context, &context ));
850
851 ret = TRUE;
852 done:
853 HeapFree( GetProcessHeap(), 0, dest_dir );
854 return ret;
855 }
856
857
858 /***********************************************************************
859 * SetupCommitFileQueueA (SETUPAPI.@)
860 */
861 BOOL WINAPI SetupCommitFileQueueA( HWND owner, HSPFILEQ queue, PSP_FILE_CALLBACK_A handler,
862 PVOID context )
863 {
864 struct callback_WtoA_context ctx;
865
866 ctx.orig_context = context;
867 ctx.orig_handler = handler;
868 return SetupCommitFileQueueW( owner, queue, QUEUE_callback_WtoA, &ctx );
869 }
870
871
872 /***********************************************************************
873 * create_full_pathW
874 *
875 * Recursively create all directories in the path.
876 */
877 static BOOL create_full_pathW(const WCHAR *path)
878 {
879 BOOL ret = TRUE;
880 int len;
881 WCHAR *new_path;
882
883 new_path = HeapAlloc(GetProcessHeap(), 0, (strlenW(path) + 1) * sizeof(WCHAR));
884 strcpyW(new_path, path);
885
886 while((len = strlenW(new_path)) && new_path[len - 1] == '\\')
887 new_path[len - 1] = 0;
888
889 while(!CreateDirectoryW(new_path, NULL))
890 {
891 WCHAR *slash;
892 DWORD last_error = GetLastError();
893
894 if(last_error == ERROR_ALREADY_EXISTS)
895 break;
896
897 if(last_error != ERROR_PATH_NOT_FOUND)
898 {
899 ret = FALSE;
900 break;
901 }
902
903 if(!(slash = strrchrW(new_path, '\\')))
904 {
905 ret = FALSE;
906 break;
907 }
908
909 len = slash - new_path;
910 new_path[len] = 0;
911 if(!create_full_pathW(new_path))
912 {
913 ret = FALSE;
914 break;
915 }
916 new_path[len] = '\\';
917 }
918
919 HeapFree(GetProcessHeap(), 0, new_path);
920 return ret;
921 }
922
923 static BOOL do_file_copyW( LPCWSTR source, LPCWSTR target, DWORD style,
924 PSP_FILE_CALLBACK_W handler, PVOID context )
925 {
926 BOOL rc = FALSE;
927 BOOL docopy = TRUE;
928
929 TRACE("copy %s to %s style 0x%x\n",debugstr_w(source),debugstr_w(target),style);
930
931 /* before copy processing */
932 if (style & SP_COPY_REPLACEONLY)
933 {
934 if (GetFileAttributesW(target) == INVALID_FILE_ATTRIBUTES)
935 docopy = FALSE;
936 }
937 if (style & (SP_COPY_NEWER_OR_SAME | SP_COPY_NEWER_ONLY | SP_COPY_FORCE_NEWER))
938 {
939 DWORD VersionSizeSource=0;
940 DWORD VersionSizeTarget=0;
941 DWORD zero=0;
942
943 /*
944 * This is sort of an interesting workaround. You see, calling
945 * GetVersionInfoSize on a builtin dll loads that dll into memory
946 * and we do not properly unload builtin dlls.. so we effectively
947 * lock into memory all the targets we are replacing. This leads
948 * to problems when we try to register the replaced dlls.
949 *
950 * So I will test for the existence of the files first so that
951 * we just basically unconditionally replace the builtin versions.
952 */
953 if ((GetFileAttributesW(target) != INVALID_FILE_ATTRIBUTES) &&
954 (GetFileAttributesW(source) != INVALID_FILE_ATTRIBUTES))
955 {
956 VersionSizeSource = GetFileVersionInfoSizeW(source,&zero);
957 VersionSizeTarget = GetFileVersionInfoSizeW(target,&zero);
958 }
959
960 TRACE("SizeTarget %i ... SizeSource %i\n",VersionSizeTarget,
961 VersionSizeSource);
962
963 if (VersionSizeSource && VersionSizeTarget)
964 {
965 LPVOID VersionSource;
966 LPVOID VersionTarget;
967 VS_FIXEDFILEINFO *TargetInfo;
968 VS_FIXEDFILEINFO *SourceInfo;
969 UINT length;
970 WCHAR SubBlock[2]={'\\',0};
971 DWORD ret;
972
973 VersionSource = HeapAlloc(GetProcessHeap(),0,VersionSizeSource);
974 VersionTarget = HeapAlloc(GetProcessHeap(),0,VersionSizeTarget);
975
976 ret = GetFileVersionInfoW(source,0,VersionSizeSource,VersionSource);
977 if (ret)
978 ret = GetFileVersionInfoW(target, 0, VersionSizeTarget,
979 VersionTarget);
980
981 if (ret)
982 {
983 ret = VerQueryValueW(VersionSource, SubBlock,
984 (LPVOID*)&SourceInfo, &length);
985 if (ret)
986 ret = VerQueryValueW(VersionTarget, SubBlock,
987 (LPVOID*)&TargetInfo, &length);
988
989 if (ret)
990 {
991 FILEPATHS_W filepaths;
992
993 TRACE("Versions: Source %i.%i target %i.%i\n",
994 SourceInfo->dwFileVersionMS, SourceInfo->dwFileVersionLS,
995 TargetInfo->dwFileVersionMS, TargetInfo->dwFileVersionLS);
996
997 /* used in case of notification */
998 filepaths.Target = target;
999 filepaths.Source = source;
1000 filepaths.Win32Error = 0;
1001 filepaths.Flags = 0;
1002
1003 if (TargetInfo->dwFileVersionMS > SourceInfo->dwFileVersionMS)
1004 {
1005 if (handler)
1006 docopy = handler (context, SPFILENOTIFY_TARGETNEWER, (UINT_PTR)&filepaths, 0);
1007 else
1008 docopy = FALSE;
1009 }
1010 else if ((TargetInfo->dwFileVersionMS == SourceInfo->dwFileVersionMS)
1011 && (TargetInfo->dwFileVersionLS > SourceInfo->dwFileVersionLS))
1012 {
1013 if (handler)
1014 docopy = handler (context, SPFILENOTIFY_TARGETNEWER, (UINT_PTR)&filepaths, 0);
1015 else
1016 docopy = FALSE;
1017 }
1018 else if ((style & SP_COPY_NEWER_ONLY) &&
1019 (TargetInfo->dwFileVersionMS ==
1020 SourceInfo->dwFileVersionMS)
1021 &&(TargetInfo->dwFileVersionLS ==
1022 SourceInfo->dwFileVersionLS))
1023 {
1024 if (handler)
1025 docopy = handler (context, SPFILENOTIFY_TARGETNEWER, (UINT_PTR)&filepaths, 0);
1026 else
1027 docopy = FALSE;
1028 }
1029 }
1030 }
1031 HeapFree(GetProcessHeap(),0,VersionSource);
1032 HeapFree(GetProcessHeap(),0,VersionTarget);
1033 }
1034 }
1035 if (style & (SP_COPY_NOOVERWRITE | SP_COPY_FORCE_NOOVERWRITE))
1036 {
1037 if (GetFileAttributesW(target) != INVALID_FILE_ATTRIBUTES)
1038 {
1039 FIXME("Notify user target file exists\n");
1040 docopy = FALSE;
1041 }
1042 }
1043 if (style & (SP_COPY_NODECOMP | SP_COPY_LANGUAGEAWARE | SP_COPY_FORCE_IN_USE |
1044 SP_COPY_IN_USE_NEEDS_REBOOT | SP_COPY_NOSKIP | SP_COPY_WARNIFSKIP))
1045 {
1046 ERR("Unsupported style(s) 0x%x\n",style);
1047 }
1048
1049 if (docopy)
1050 {
1051 rc = CopyFileW(source,target,FALSE);
1052 TRACE("Did copy... rc was %i\n",rc);
1053 }
1054
1055 /* after copy processing */
1056 if (style & SP_COPY_DELETESOURCE)
1057 {
1058 if (rc)
1059 DeleteFileW(source);
1060 }
1061
1062 return rc;
1063 }
1064
1065 /***********************************************************************
1066 * SetupInstallFileExA (SETUPAPI.@)
1067 */
1068 BOOL WINAPI SetupInstallFileExA( HINF hinf, PINFCONTEXT inf_context, PCSTR source, PCSTR root,
1069 PCSTR dest, DWORD style, PSP_FILE_CALLBACK_A handler, PVOID context, PBOOL in_use )
1070 {
1071 BOOL ret = FALSE;
1072 struct callback_WtoA_context ctx;
1073 UNICODE_STRING sourceW, rootW, destW;
1074
1075 TRACE("%p %p %s %s %s %x %p %p %p\n", hinf, inf_context, debugstr_a(source), debugstr_a(root),
1076 debugstr_a(dest), style, handler, context, in_use);
1077
1078 sourceW.Buffer = rootW.Buffer = destW.Buffer = NULL;
1079 if (source && !RtlCreateUnicodeStringFromAsciiz( &sourceW, source ))
1080 {
1081 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1082 return FALSE;
1083 }
1084 if (root && !RtlCreateUnicodeStringFromAsciiz( &rootW, root ))
1085 {
1086 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1087 goto exit;
1088 }
1089 if (dest && !RtlCreateUnicodeStringFromAsciiz( &destW, dest ))
1090 {
1091 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1092 goto exit;
1093 }
1094
1095 ctx.orig_context = context;
1096 ctx.orig_handler = handler;
1097
1098 ret = SetupInstallFileExW( hinf, inf_context, sourceW.Buffer, rootW.Buffer, destW.Buffer, style, QUEUE_callback_WtoA, &ctx, in_use );
1099
1100 exit:
1101 RtlFreeUnicodeString( &sourceW );
1102 RtlFreeUnicodeString( &rootW );
1103 RtlFreeUnicodeString( &destW );
1104 return ret;
1105 }
1106
1107 /***********************************************************************
1108 * SetupInstallFileA (SETUPAPI.@)
1109 */
1110 BOOL WINAPI SetupInstallFileA( HINF hinf, PINFCONTEXT inf_context, PCSTR source, PCSTR root,
1111 PCSTR dest, DWORD style, PSP_FILE_CALLBACK_A handler, PVOID context )
1112 {
1113 return SetupInstallFileExA( hinf, inf_context, source, root, dest, style, handler, context, NULL );
1114 }
1115
1116 /***********************************************************************
1117 * SetupInstallFileExW (SETUPAPI.@)
1118 */
1119 BOOL WINAPI SetupInstallFileExW( HINF hinf, PINFCONTEXT inf_context, PCWSTR source, PCWSTR root,
1120 PCWSTR dest, DWORD style, PSP_FILE_CALLBACK_W handler, PVOID context, PBOOL in_use )
1121 {
1122 static const WCHAR CopyFiles[] = {'C','o','p','y','F','i','l','e','s',0};
1123
1124 BOOL ret, absolute = (root && *root && !(style & SP_COPY_SOURCE_ABSOLUTE));
1125 WCHAR *buffer, *p, *inf_source = NULL;
1126 unsigned int len;
1127
1128 TRACE("%p %p %s %s %s %x %p %p %p\n", hinf, inf_context, debugstr_w(source), debugstr_w(root),
1129 debugstr_w(dest), style, handler, context, in_use);
1130
1131 if (in_use) FIXME("no file in use support\n");
1132
1133 if (hinf)
1134 {
1135 INFCONTEXT ctx;
1136
1137 if (!inf_context)
1138 {
1139 inf_context = &ctx;
1140 if (!SetupFindFirstLineW( hinf, CopyFiles, NULL, inf_context )) return FALSE;
1141 }
1142 if (!SetupGetStringFieldW( inf_context, 1, NULL, 0, &len )) return FALSE;
1143 if (!(inf_source = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
1144 {
1145 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1146 return FALSE;
1147 }
1148 if (!SetupGetStringFieldW( inf_context, 1, inf_source, len, NULL )) return FALSE;
1149 source = inf_source;
1150 }
1151 else if (!source)
1152 {
1153 SetLastError( ERROR_INVALID_PARAMETER );
1154 return FALSE;
1155 }
1156
1157 len = strlenW( source ) + 1;
1158 if (absolute) len += strlenW( root ) + 1;
1159
1160 if (!(p = buffer = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
1161 {
1162 HeapFree( GetProcessHeap(), 0, inf_source );
1163 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1164 return FALSE;
1165 }
1166
1167 if (absolute)
1168 {
1169 strcpyW( buffer, root );
1170 p += strlenW( buffer );
1171 if (p[-1] != '\\') *p++ = '\\';
1172 }
1173 while (*source == '\\') source++;
1174 strcpyW( p, source );
1175
1176 ret = do_file_copyW( buffer, dest, style, handler, context );
1177
1178 HeapFree( GetProcessHeap(), 0, inf_source );
1179 HeapFree( GetProcessHeap(), 0, buffer );
1180 return ret;
1181 }
1182
1183 /***********************************************************************
1184 * SetupInstallFileW (SETUPAPI.@)
1185 */
1186 BOOL WINAPI SetupInstallFileW( HINF hinf, PINFCONTEXT inf_context, PCWSTR source, PCWSTR root,
1187 PCWSTR dest, DWORD style, PSP_FILE_CALLBACK_W handler, PVOID context )
1188 {
1189 return SetupInstallFileExW( hinf, inf_context, source, root, dest, style, handler, context, NULL );
1190 }
1191
1192 /***********************************************************************
1193 * SetupCommitFileQueueW (SETUPAPI.@)
1194 */
1195 BOOL WINAPI SetupCommitFileQueueW( HWND owner, HSPFILEQ handle, PSP_FILE_CALLBACK_W handler,
1196 PVOID context )
1197 {
1198 struct file_queue *queue = handle;
1199 struct file_op *op;
1200 BOOL result = FALSE;
1201 FILEPATHS_W paths;
1202 UINT op_result;
1203
1204 paths.Source = paths.Target = NULL;
1205
1206 if (!queue->copy_queue.count && !queue->delete_queue.count && !queue->rename_queue.count)
1207 return TRUE; /* nothing to do */
1208
1209 if (!handler( context, SPFILENOTIFY_STARTQUEUE, (UINT_PTR)owner, 0 )) return FALSE;
1210
1211 /* perform deletes */
1212
1213 if (queue->delete_queue.count)
1214 {
1215 if (!(handler( context, SPFILENOTIFY_STARTSUBQUEUE, FILEOP_DELETE,
1216 queue->delete_queue.count ))) goto done;
1217 for (op = queue->delete_queue.head; op; op = op->next)
1218 {
1219 build_filepathsW( op, &paths );
1220 op_result = handler( context, SPFILENOTIFY_STARTDELETE, (UINT_PTR)&paths, FILEOP_DELETE);
1221 if (op_result == FILEOP_ABORT) goto done;
1222 while (op_result == FILEOP_DOIT)
1223 {
1224 TRACE( "deleting file %s\n", debugstr_w(paths.Target) );
1225 if (DeleteFileW( paths.Target )) break; /* success */
1226 paths.Win32Error = GetLastError();
1227 op_result = handler( context, SPFILENOTIFY_DELETEERROR, (UINT_PTR)&paths, 0 );
1228 if (op_result == FILEOP_ABORT) goto done;
1229 }
1230 handler( context, SPFILENOTIFY_ENDDELETE, (UINT_PTR)&paths, 0 );
1231 }
1232 handler( context, SPFILENOTIFY_ENDSUBQUEUE, FILEOP_DELETE, 0 );
1233 }
1234
1235 /* perform renames */
1236
1237 if (queue->rename_queue.count)
1238 {
1239 if (!(handler( context, SPFILENOTIFY_STARTSUBQUEUE, FILEOP_RENAME,
1240 queue->rename_queue.count ))) goto done;
1241 for (op = queue->rename_queue.head; op; op = op->next)
1242 {
1243 build_filepathsW( op, &paths );
1244 op_result = handler( context, SPFILENOTIFY_STARTRENAME, (UINT_PTR)&paths, FILEOP_RENAME);
1245 if (op_result == FILEOP_ABORT) goto done;
1246 while (op_result == FILEOP_DOIT)
1247 {
1248 TRACE( "renaming file %s -> %s\n",
1249 debugstr_w(paths.Source), debugstr_w(paths.Target) );
1250 if (MoveFileW( paths.Source, paths.Target )) break; /* success */
1251 paths.Win32Error = GetLastError();
1252 op_result = handler( context, SPFILENOTIFY_RENAMEERROR, (UINT_PTR)&paths, 0 );
1253 if (op_result == FILEOP_ABORT) goto done;
1254 }
1255 handler( context, SPFILENOTIFY_ENDRENAME, (UINT_PTR)&paths, 0 );
1256 }
1257 handler( context, SPFILENOTIFY_ENDSUBQUEUE, FILEOP_RENAME, 0 );
1258 }
1259
1260 /* perform copies */
1261
1262 if (queue->copy_queue.count)
1263 {
1264 if (!(handler( context, SPFILENOTIFY_STARTSUBQUEUE, FILEOP_COPY,
1265 queue->copy_queue.count ))) goto done;
1266 for (op = queue->copy_queue.head; op; op = op->next)
1267 {
1268 WCHAR newpath[MAX_PATH];
1269
1270 build_filepathsW( op, &paths );
1271 op_result = handler( context, SPFILENOTIFY_STARTCOPY, (UINT_PTR)&paths, FILEOP_COPY );
1272 if (op_result == FILEOP_ABORT) goto done;
1273 if (op_result == FILEOP_NEWPATH) op_result = FILEOP_DOIT;
1274 while (op_result == FILEOP_DOIT || op_result == FILEOP_NEWPATH)
1275 {
1276 TRACE( "copying file %s -> %s\n",
1277 debugstr_w( op_result == FILEOP_NEWPATH ? newpath : paths.Source ),
1278 debugstr_w(paths.Target) );
1279 if (op->dst_path)
1280 {
1281 if (!create_full_pathW( op->dst_path ))
1282 {
1283 paths.Win32Error = GetLastError();
1284 op_result = handler( context, SPFILENOTIFY_COPYERROR,
1285 (UINT_PTR)&paths, (UINT_PTR)newpath );
1286 if (op_result == FILEOP_ABORT) goto done;
1287 }
1288 }
1289 if (do_file_copyW( op_result == FILEOP_NEWPATH ? newpath : paths.Source,
1290 paths.Target, op->style, handler, context )) break; /* success */
1291 /* try to extract it from the cabinet file */
1292 if (op->src_tag)
1293 {
1294 if (extract_cabinet_file( op->src_tag, op->src_root,
1295 paths.Source, paths.Target )) break;
1296 }
1297 paths.Win32Error = GetLastError();
1298 op_result = handler( context, SPFILENOTIFY_COPYERROR,
1299 (UINT_PTR)&paths, (UINT_PTR)newpath );
1300 if (op_result == FILEOP_ABORT) goto done;
1301 }
1302 handler( context, SPFILENOTIFY_ENDCOPY, (UINT_PTR)&paths, 0 );
1303 }
1304 handler( context, SPFILENOTIFY_ENDSUBQUEUE, FILEOP_COPY, 0 );
1305 }
1306
1307
1308 result = TRUE;
1309
1310 done:
1311 handler( context, SPFILENOTIFY_ENDQUEUE, result, 0 );
1312 HeapFree( GetProcessHeap(), 0, (void *)paths.Source );
1313 HeapFree( GetProcessHeap(), 0, (void *)paths.Target );
1314 return result;
1315 }
1316
1317
1318 /***********************************************************************
1319 * SetupScanFileQueueA (SETUPAPI.@)
1320 */
1321 BOOL WINAPI SetupScanFileQueueA( HSPFILEQ handle, DWORD flags, HWND window,
1322 PSP_FILE_CALLBACK_A handler, PVOID context, PDWORD result )
1323 {
1324 struct callback_WtoA_context ctx;
1325
1326 TRACE("%p %x %p %p %p %p\n", handle, flags, window, handler, context, result);
1327
1328 ctx.orig_context = context;
1329 ctx.orig_handler = handler;
1330
1331 return SetupScanFileQueueW( handle, flags, window, QUEUE_callback_WtoA, &ctx, result );
1332 }
1333
1334
1335 /***********************************************************************
1336 * SetupScanFileQueueW (SETUPAPI.@)
1337 */
1338 BOOL WINAPI SetupScanFileQueueW( HSPFILEQ handle, DWORD flags, HWND window,
1339 PSP_FILE_CALLBACK_W handler, PVOID context, PDWORD result )
1340 {
1341 struct file_queue *queue = handle;
1342 struct file_op *op;
1343 FILEPATHS_W paths;
1344 UINT notification = 0;
1345 BOOL ret = FALSE;
1346
1347 TRACE("%p %x %p %p %p %p\n", handle, flags, window, handler, context, result);
1348
1349 if (!queue->copy_queue.count) return TRUE;
1350
1351 if (flags & SPQ_SCAN_USE_CALLBACK) notification = SPFILENOTIFY_QUEUESCAN;
1352 else if (flags & SPQ_SCAN_USE_CALLBACKEX) notification = SPFILENOTIFY_QUEUESCAN_EX;
1353
1354 if (flags & ~(SPQ_SCAN_USE_CALLBACK | SPQ_SCAN_USE_CALLBACKEX))
1355 {
1356 FIXME("flags %x not fully implemented\n", flags);
1357 }
1358
1359 paths.Source = paths.Target = NULL;
1360
1361 for (op = queue->copy_queue.head; op; op = op->next)
1362 {
1363 build_filepathsW( op, &paths );
1364 switch (notification)
1365 {
1366 case SPFILENOTIFY_QUEUESCAN:
1367 /* FIXME: handle delay flag */
1368 if (handler( context, notification, (UINT_PTR)paths.Target, 0 )) goto done;
1369 break;
1370 case SPFILENOTIFY_QUEUESCAN_EX:
1371 if (handler( context, notification, (UINT_PTR)&paths, 0 )) goto done;
1372 break;
1373 default:
1374 ret = TRUE; goto done;
1375 }
1376 }
1377
1378 ret = TRUE;
1379
1380 done:
1381 if (result) *result = 0;
1382 HeapFree( GetProcessHeap(), 0, (void *)paths.Source );
1383 HeapFree( GetProcessHeap(), 0, (void *)paths.Target );
1384 return ret;
1385 }
1386
1387
1388 /***********************************************************************
1389 * SetupGetFileQueueCount (SETUPAPI.@)
1390 */
1391 BOOL WINAPI SetupGetFileQueueCount( HSPFILEQ handle, UINT op, PUINT result )
1392 {
1393 struct file_queue *queue = handle;
1394
1395 switch(op)
1396 {
1397 case FILEOP_COPY:
1398 *result = queue->copy_queue.count;
1399 return TRUE;
1400 case FILEOP_RENAME:
1401 *result = queue->rename_queue.count;
1402 return TRUE;
1403 case FILEOP_DELETE:
1404 *result = queue->delete_queue.count;
1405 return TRUE;
1406 }
1407 return FALSE;
1408 }
1409
1410
1411 /***********************************************************************
1412 * SetupGetFileQueueFlags (SETUPAPI.@)
1413 */
1414 BOOL WINAPI SetupGetFileQueueFlags( HSPFILEQ handle, PDWORD flags )
1415 {
1416 struct file_queue *queue = handle;
1417 *flags = queue->flags;
1418 return TRUE;
1419 }
1420
1421
1422 /***********************************************************************
1423 * SetupSetFileQueueFlags (SETUPAPI.@)
1424 */
1425 BOOL WINAPI SetupSetFileQueueFlags( HSPFILEQ handle, DWORD mask, DWORD flags )
1426 {
1427 struct file_queue *queue = handle;
1428 queue->flags = (queue->flags & ~mask) | flags;
1429 return TRUE;
1430 }
1431
1432
1433 /***********************************************************************
1434 * SetupSetFileQueueAlternatePlatformA (SETUPAPI.@)
1435 */
1436 BOOL WINAPI SetupSetFileQueueAlternatePlatformA(HSPFILEQ handle, PSP_ALTPLATFORM_INFO platform, PCSTR catalogfile)
1437 {
1438 FIXME("(%p, %p, %s) stub!\n", handle, platform, debugstr_a(catalogfile));
1439 return FALSE;
1440 }
1441
1442
1443 /***********************************************************************
1444 * SetupSetFileQueueAlternatePlatformW (SETUPAPI.@)
1445 */
1446 BOOL WINAPI SetupSetFileQueueAlternatePlatformW(HSPFILEQ handle, PSP_ALTPLATFORM_INFO platform, PCWSTR catalogfile)
1447 {
1448 FIXME("(%p, %p, %s) stub!\n", handle, platform, debugstr_w(catalogfile));
1449 return FALSE;
1450 }
1451
1452
1453 /***********************************************************************
1454 * SetupInitDefaultQueueCallback (SETUPAPI.@)
1455 */
1456 PVOID WINAPI SetupInitDefaultQueueCallback( HWND owner )
1457 {
1458 return SetupInitDefaultQueueCallbackEx( owner, 0, 0, 0, NULL );
1459 }
1460
1461
1462 /***********************************************************************
1463 * SetupInitDefaultQueueCallbackEx (SETUPAPI.@)
1464 */
1465 PVOID WINAPI SetupInitDefaultQueueCallbackEx( HWND owner, HWND progress, UINT msg,
1466 DWORD reserved1, PVOID reserved2 )
1467 {
1468 struct default_callback_context *context;
1469
1470 if ((context = HeapAlloc( GetProcessHeap(), 0, sizeof(*context) )))
1471 {
1472 context->owner = owner;
1473 context->progress = progress;
1474 context->message = msg;
1475 }
1476 return context;
1477 }
1478
1479
1480 /***********************************************************************
1481 * SetupTermDefaultQueueCallback (SETUPAPI.@)
1482 */
1483 void WINAPI SetupTermDefaultQueueCallback( PVOID context )
1484 {
1485 HeapFree( GetProcessHeap(), 0, context );
1486 }
1487
1488
1489 /***********************************************************************
1490 * SetupDefaultQueueCallbackA (SETUPAPI.@)
1491 */
1492 UINT WINAPI SetupDefaultQueueCallbackA( PVOID context, UINT notification,
1493 UINT_PTR param1, UINT_PTR param2 )
1494 {
1495 FILEPATHS_A *paths = (FILEPATHS_A *)param1;
1496 struct default_callback_context *ctx = context;
1497
1498 switch(notification)
1499 {
1500 case SPFILENOTIFY_STARTQUEUE:
1501 TRACE( "start queue\n" );
1502 return TRUE;
1503 case SPFILENOTIFY_ENDQUEUE:
1504 TRACE( "end queue\n" );
1505 return 0;
1506 case SPFILENOTIFY_STARTSUBQUEUE:
1507 TRACE( "start subqueue %ld count %ld\n", param1, param2 );
1508 return TRUE;
1509 case SPFILENOTIFY_ENDSUBQUEUE:
1510 TRACE( "end subqueue %ld\n", param1 );
1511 return 0;
1512 case SPFILENOTIFY_STARTDELETE:
1513 TRACE( "start delete %s\n", debugstr_a(paths->Target) );
1514 return FILEOP_DOIT;
1515 case SPFILENOTIFY_ENDDELETE:
1516 TRACE( "end delete %s\n", debugstr_a(paths->Target) );
1517 return 0;
1518 case SPFILENOTIFY_DELETEERROR:
1519 /*Windows Ignores attempts to delete files / folders which do not exist*/
1520 if ((paths->Win32Error != ERROR_FILE_NOT_FOUND) && (paths->Win32Error != ERROR_PATH_NOT_FOUND))
1521 SetupDeleteErrorA(ctx->owner, NULL, paths->Target, paths->Win32Error, 0);
1522 return FILEOP_SKIP;
1523 case SPFILENOTIFY_STARTRENAME:
1524 TRACE( "start rename %s -> %s\n", debugstr_a(paths->Source), debugstr_a(paths->Target) );
1525 return FILEOP_DOIT;
1526 case SPFILENOTIFY_ENDRENAME:
1527 TRACE( "end rename %s -> %s\n", debugstr_a(paths->Source), debugstr_a(paths->Target) );
1528 return 0;
1529 case SPFILENOTIFY_RENAMEERROR:
1530 SetupRenameErrorA(ctx->owner, NULL, paths->Source, paths->Target, paths->Win32Error, 0);
1531 return FILEOP_SKIP;
1532 case SPFILENOTIFY_STARTCOPY:
1533 TRACE( "start copy %s -> %s\n", debugstr_a(paths->Source), debugstr_a(paths->Target) );
1534 return FILEOP_DOIT;
1535 case SPFILENOTIFY_ENDCOPY:
1536 TRACE( "end copy %s -> %s\n", debugstr_a(paths->Source), debugstr_a(paths->Target) );
1537 return 0;
1538 case SPFILENOTIFY_COPYERROR:
1539 ERR( "copy error %d %s -> %s\n", paths->Win32Error,
1540 debugstr_a(paths->Source), debugstr_a(paths->Target) );
1541 return FILEOP_SKIP;
1542 case SPFILENOTIFY_NEEDMEDIA:
1543 TRACE( "need media\n" );
1544 return FILEOP_SKIP;
1545 default:
1546 FIXME( "notification %d params %lx,%lx\n", notification, param1, param2 );
1547 break;
1548 }
1549 return 0;
1550 }
1551
1552
1553 /***********************************************************************
1554 * SetupDefaultQueueCallbackW (SETUPAPI.@)
1555 */
1556 UINT WINAPI SetupDefaultQueueCallbackW( PVOID context, UINT notification,
1557 UINT_PTR param1, UINT_PTR param2 )
1558 {
1559 FILEPATHS_W *paths = (FILEPATHS_W *)param1;
1560 struct default_callback_context *ctx = context;
1561
1562 switch(notification)
1563 {
1564 case SPFILENOTIFY_STARTQUEUE:
1565 TRACE( "start queue\n" );
1566 return TRUE;
1567 case SPFILENOTIFY_ENDQUEUE:
1568 TRACE( "end queue\n" );
1569 return 0;
1570 case SPFILENOTIFY_STARTSUBQUEUE:
1571 TRACE( "start subqueue %ld count %ld\n", param1, param2 );
1572 return TRUE;
1573 case SPFILENOTIFY_ENDSUBQUEUE:
1574 TRACE( "end subqueue %ld\n", param1 );
1575 return 0;
1576 case SPFILENOTIFY_STARTDELETE:
1577 TRACE( "start delete %s\n", debugstr_w(paths->Target) );
1578 return FILEOP_DOIT;
1579 case SPFILENOTIFY_ENDDELETE:
1580 TRACE( "end delete %s\n", debugstr_w(paths->Target) );
1581 return 0;
1582 case SPFILENOTIFY_DELETEERROR:
1583 /*Windows Ignores attempts to delete files / folders which do not exist*/
1584 if ((paths->Win32Error != ERROR_FILE_NOT_FOUND) && (paths->Win32Error != ERROR_PATH_NOT_FOUND))
1585 SetupDeleteErrorW(ctx->owner, NULL, paths->Target, paths->Win32Error, 0);
1586 return FILEOP_SKIP;
1587 case SPFILENOTIFY_STARTRENAME:
1588 SetupRenameErrorW(ctx->owner, NULL, paths->Source, paths->Target, paths->Win32Error, 0);
1589 return FILEOP_DOIT;
1590 case SPFILENOTIFY_ENDRENAME:
1591 TRACE( "end rename %s -> %s\n", debugstr_w(paths->Source), debugstr_w(paths->Target) );
1592 return 0;
1593 case SPFILENOTIFY_RENAMEERROR:
1594 ERR( "rename error %d %s -> %s\n", paths->Win32Error,
1595 debugstr_w(paths->Source), debugstr_w(paths->Target) );
1596 return FILEOP_SKIP;
1597 case SPFILENOTIFY_STARTCOPY:
1598 TRACE( "start copy %s -> %s\n", debugstr_w(paths->Source), debugstr_w(paths->Target) );
1599 return FILEOP_DOIT;
1600 case SPFILENOTIFY_ENDCOPY:
1601 TRACE( "end copy %s -> %s\n", debugstr_w(paths->Source), debugstr_w(paths->Target) );
1602 return 0;
1603 case SPFILENOTIFY_COPYERROR:
1604 ERR( "copy error %d %s -> %s\n", paths->Win32Error,
1605 debugstr_w(paths->Source), debugstr_w(paths->Target) );
1606 return FILEOP_SKIP;
1607 case SPFILENOTIFY_NEEDMEDIA:
1608 TRACE( "need media\n" );
1609 return FILEOP_SKIP;
1610 default:
1611 FIXME( "notification %d params %lx,%lx\n", notification, param1, param2 );
1612 break;
1613 }
1614 return 0;
1615 }
1616
1617 /***********************************************************************
1618 * SetupDeleteErrorA (SETUPAPI.@)
1619 */
1620
1621 UINT WINAPI SetupDeleteErrorA( HWND parent, PCSTR dialogTitle, PCSTR file,
1622 UINT w32error, DWORD style)
1623 {
1624 FIXME( "stub: (Error Number %d when attempting to delete %s)\n",
1625 w32error, debugstr_a(file) );
1626 return DPROMPT_SKIPFILE;
1627 }
1628
1629 /***********************************************************************
1630 * SetupDeleteErrorW (SETUPAPI.@)
1631 */
1632
1633 UINT WINAPI SetupDeleteErrorW( HWND parent, PCWSTR dialogTitle, PCWSTR file,
1634 UINT w32error, DWORD style)
1635 {
1636 FIXME( "stub: (Error Number %d when attempting to delete %s)\n",
1637 w32error, debugstr_w(file) );
1638 return DPROMPT_SKIPFILE;
1639 }
1640
1641 /***********************************************************************
1642 * SetupRenameErrorA (SETUPAPI.@)
1643 */
1644
1645 UINT WINAPI SetupRenameErrorA( HWND parent, PCSTR dialogTitle, PCSTR source,
1646 PCSTR target, UINT w32error, DWORD style)
1647 {
1648 FIXME( "stub: (Error Number %d when attempting to rename %s to %s)\n",
1649 w32error, debugstr_a(source), debugstr_a(target));
1650 return DPROMPT_SKIPFILE;
1651 }
1652
1653 /***********************************************************************
1654 * SetupRenameErrorW (SETUPAPI.@)
1655 */
1656
1657 UINT WINAPI SetupRenameErrorW( HWND parent, PCWSTR dialogTitle, PCWSTR source,
1658 PCWSTR target, UINT w32error, DWORD style)
1659 {
1660 FIXME( "stub: (Error Number %d when attempting to rename %s to %s)\n",
1661 w32error, debugstr_w(source), debugstr_w(target));
1662 return DPROMPT_SKIPFILE;
1663 }
1664
1665
1666 /***********************************************************************
1667 * SetupCopyErrorA (SETUPAPI.@)
1668 */
1669
1670 UINT WINAPI SetupCopyErrorA( HWND parent, PCSTR dialogTitle, PCSTR diskname,
1671 PCSTR sourcepath, PCSTR sourcefile, PCSTR targetpath,
1672 UINT w32error, DWORD style, PSTR pathbuffer,
1673 DWORD buffersize, PDWORD requiredsize)
1674 {
1675 FIXME( "stub: (Error Number %d when attempting to copy file %s from %s to %s)\n",
1676 w32error, debugstr_a(sourcefile), debugstr_a(sourcepath) ,debugstr_a(targetpath));
1677 return DPROMPT_SKIPFILE;
1678 }
1679
1680 /***********************************************************************
1681 * SetupCopyErrorW (SETUPAPI.@)
1682 */
1683
1684 UINT WINAPI SetupCopyErrorW( HWND parent, PCWSTR dialogTitle, PCWSTR diskname,
1685 PCWSTR sourcepath, PCWSTR sourcefile, PCWSTR targetpath,
1686 UINT w32error, DWORD style, PWSTR pathbuffer,
1687 DWORD buffersize, PDWORD requiredsize)
1688 {
1689 FIXME( "stub: (Error Number %d when attempting to copy file %s from %s to %s)\n",
1690 w32error, debugstr_w(sourcefile), debugstr_w(sourcepath) ,debugstr_w(targetpath));
1691 return DPROMPT_SKIPFILE;
1692 }
1693
1694 /***********************************************************************
1695 * pSetupGetQueueFlags (SETUPAPI.@)
1696 */
1697 DWORD WINAPI pSetupGetQueueFlags( HSPFILEQ handle )
1698 {
1699 struct file_queue *queue = handle;
1700 return queue->flags;
1701 }
1702
1703 /***********************************************************************
1704 * pSetupSetQueueFlags (SETUPAPI.@)
1705 */
1706 BOOL WINAPI pSetupSetQueueFlags( HSPFILEQ handle, DWORD flags )
1707 {
1708 struct file_queue *queue = handle;
1709 queue->flags = flags;
1710 return TRUE;
1711 }
useful hacks and other patches not (yet) suitable for mainline