?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Initialize Xlib threading support to see what it breaks...
[wine.git] / dlls / setupapi / queue.c
blobb40f3047a04cdf48196be9901dd3ad1e557d3687
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 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 inline static 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
88 inline static WCHAR *strdupAtoW( const char *str )
89 {
90 WCHAR *ret = NULL;
91 if (str)
92 {
93 DWORD len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
94 if ((ret = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
95 MultiByteToWideChar( CP_ACP, 0, str, -1, ret, len );
96 }
97 return ret;
98 }
99
100 inline static char *strdupWtoA( const WCHAR *str )
101 {
102 char *ret = NULL;
103 if (str)
104 {
105 DWORD len = WideCharToMultiByte( CP_ACP, 0, str, -1, NULL, 0, NULL, NULL );
106 if ((ret = HeapAlloc( GetProcessHeap(), 0, len )))
107 WideCharToMultiByte( CP_ACP, 0, str, -1, ret, len, NULL, NULL );
108 }
109 return ret;
110 }
111
112 /* append a file operation to a queue */
113 inline static void queue_file_op( struct file_op_queue *queue, struct file_op *op )
114 {
115 op->next = NULL;
116 if (queue->tail) queue->tail->next = op;
117 else queue->head = op;
118 queue->tail = op;
119 queue->count++;
120 }
121
122 /* free all the file operations on a given queue */
123 static void free_file_op_queue( struct file_op_queue *queue )
124 {
125 struct file_op *t, *op = queue->head;
126
127 while( op )
128 {
129 HeapFree( GetProcessHeap(), 0, op->src_root );
130 HeapFree( GetProcessHeap(), 0, op->src_path );
131 HeapFree( GetProcessHeap(), 0, op->src_file );
132 HeapFree( GetProcessHeap(), 0, op->src_descr );
133 HeapFree( GetProcessHeap(), 0, op->src_tag );
134 HeapFree( GetProcessHeap(), 0, op->dst_path );
135 if (op->dst_file != op->src_file) HeapFree( GetProcessHeap(), 0, op->dst_file );
136 t = op;
137 op = op->next;
138 HeapFree( GetProcessHeap(), 0, t );
139 }
140 }
141
142 /* concat 3 strings to make a path, handling separators correctly */
143 static void concat_W( WCHAR *buffer, const WCHAR *src1, const WCHAR *src2, const WCHAR *src3 )
144 {
145 *buffer = 0;
146 if (src1 && *src1)
147 {
148 strcpyW( buffer, src1 );
149 buffer += strlenW(buffer );
150 if (buffer[-1] != '\\') *buffer++ = '\\';
151 if (src2) while (*src2 == '\\') src2++;
152 }
153
154 if (src2)
155 {
156 strcpyW( buffer, src2 );
157 buffer += strlenW(buffer );
158 if (buffer[-1] != '\\') *buffer++ = '\\';
159 if (src3) while (*src3 == '\\') src3++;
160 }
161 if (src3)
162 {
163 strcpyW( buffer, src3 );
164 buffer += strlenW(buffer );
165 }
166 }
167
168
169 /***********************************************************************
170 * build_filepathsW
171 *
172 * Build a FILEPATHS_W structure for a given file operation.
173 */
174 static BOOL build_filepathsW( const struct file_op *op, FILEPATHS_W *paths )
175 {
176 int src_len = 1, dst_len = 1;
177 WCHAR *source = (PWSTR)paths->Source, *target = (PWSTR)paths->Target;
178
179 if (op->src_root) src_len += strlenW(op->src_root) + 1;
180 if (op->src_path) src_len += strlenW(op->src_path) + 1;
181 if (op->src_file) src_len += strlenW(op->src_file) + 1;
182 if (op->dst_path) dst_len += strlenW(op->dst_path) + 1;
183 if (op->dst_file) dst_len += strlenW(op->dst_file) + 1;
184 src_len *= sizeof(WCHAR);
185 dst_len *= sizeof(WCHAR);
186
187 if (!source || HeapSize( GetProcessHeap(), 0, source ) < src_len )
188 {
189 HeapFree( GetProcessHeap(), 0, source );
190 paths->Source = source = HeapAlloc( GetProcessHeap(), 0, src_len );
191 }
192 if (!target || HeapSize( GetProcessHeap(), 0, target ) < dst_len )
193 {
194 HeapFree( GetProcessHeap(), 0, target );
195 paths->Target = target = HeapAlloc( GetProcessHeap(), 0, dst_len );
196 }
197 if (!source || !target) return FALSE;
198 concat_W( source, op->src_root, op->src_path, op->src_file );
199 concat_W( target, NULL, op->dst_path, op->dst_file );
200 paths->Win32Error = 0;
201 paths->Flags = 0;
202 return TRUE;
203 }
204
205
206 /***********************************************************************
207 * QUEUE_callback_WtoA
208 *
209 * Map a file callback parameters from W to A and call the A callback.
210 */
211 UINT CALLBACK QUEUE_callback_WtoA( void *context, UINT notification,
212 UINT_PTR param1, UINT_PTR param2 )
213 {
214 struct callback_WtoA_context *callback_ctx = context;
215 char buffer[MAX_PATH];
216 UINT ret;
217 UINT_PTR old_param2 = param2;
218
219 switch(notification)
220 {
221 case SPFILENOTIFY_COPYERROR:
222 param2 = (UINT_PTR)&buffer;
223 /* fall through */
224 case SPFILENOTIFY_STARTDELETE:
225 case SPFILENOTIFY_ENDDELETE:
226 case SPFILENOTIFY_DELETEERROR:
227 case SPFILENOTIFY_STARTRENAME:
228 case SPFILENOTIFY_ENDRENAME:
229 case SPFILENOTIFY_RENAMEERROR:
230 case SPFILENOTIFY_STARTCOPY:
231 case SPFILENOTIFY_ENDCOPY:
232 {
233 FILEPATHS_W *pathsW = (FILEPATHS_W *)param1;
234 FILEPATHS_A pathsA;
235
236 pathsA.Source = strdupWtoA( pathsW->Source );
237 pathsA.Target = strdupWtoA( pathsW->Target );
238 pathsA.Win32Error = pathsW->Win32Error;
239 pathsA.Flags = pathsW->Flags;
240 ret = callback_ctx->orig_handler( callback_ctx->orig_context, notification,
241 (UINT_PTR)&pathsA, param2 );
242 HeapFree( GetProcessHeap(), 0, (void *)pathsA.Source );
243 HeapFree( GetProcessHeap(), 0, (void *)pathsA.Target );
244 }
245 if (notification == SPFILENOTIFY_COPYERROR)
246 MultiByteToWideChar( CP_ACP, 0, buffer, -1, (WCHAR *)old_param2, MAX_PATH );
247 break;
248
249 case SPFILENOTIFY_NEEDMEDIA:
250 case SPFILENOTIFY_QUEUESCAN:
251 FIXME("mapping for %d not implemented\n",notification);
252 case SPFILENOTIFY_STARTQUEUE:
253 case SPFILENOTIFY_ENDQUEUE:
254 case SPFILENOTIFY_STARTSUBQUEUE:
255 case SPFILENOTIFY_ENDSUBQUEUE:
256 default:
257 ret = callback_ctx->orig_handler( callback_ctx->orig_context, notification, param1, param2 );
258 break;
259 }
260 return ret;
261 }
262
263
264 /***********************************************************************
265 * get_src_file_info
266 *
267 * Retrieve the source file information for a given file.
268 */
269 static void get_src_file_info( HINF hinf, struct file_op *op )
270 {
271 static const WCHAR SourceDisksNames[] =
272 {'S','o','u','r','c','e','D','i','s','k','s','N','a','m','e','s',0};
273 static const WCHAR SourceDisksFiles[] =
274 {'S','o','u','r','c','e','D','i','s','k','s','F','i','l','e','s',0};
275
276 INFCONTEXT file_ctx, disk_ctx;
277 INT id, diskid;
278 DWORD len, len2;
279
280 /* find the SourceDisksFiles entry */
281 if (!SetupFindFirstLineW( hinf, SourceDisksFiles, op->src_file, &file_ctx ))
282 {
283 const WCHAR *dir;
284
285 if ((op->style & (SP_COPY_SOURCE_ABSOLUTE|SP_COPY_SOURCEPATH_ABSOLUTE))) return;
286 /* no specific info, use .inf file source directory */
287 if (!op->src_root && (dir = DIRID_get_string( hinf, DIRID_SRCPATH )))
288 op->src_root = strdupW( dir );
289 return;
290 }
291 if (!SetupGetIntField( &file_ctx, 1, &diskid )) return;
292
293 /* now find the diskid in the SourceDisksNames section */
294 if (!SetupFindFirstLineW( hinf, SourceDisksNames, NULL, &disk_ctx )) return;
295 for (;;)
296 {
297 if (SetupGetIntField( &disk_ctx, 0, &id ) && (id == diskid)) break;
298 if (!SetupFindNextLine( &disk_ctx, &disk_ctx )) return;
299 }
300
301 /* and fill in the missing info */
302
303 if (!op->src_descr)
304 {
305 if (SetupGetStringFieldW( &disk_ctx, 1, NULL, 0, &len ) &&
306 (op->src_descr = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) )))
307 SetupGetStringFieldW( &disk_ctx, 1, op->src_descr, len, NULL );
308 }
309 if (!op->src_tag)
310 {
311 if (SetupGetStringFieldW( &disk_ctx, 2, NULL, 0, &len ) &&
312 (op->src_tag = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) )))
313 SetupGetStringFieldW( &disk_ctx, 2, op->src_tag, len, NULL );
314 }
315 if (!op->src_path && !(op->style & SP_COPY_SOURCE_ABSOLUTE))
316 {
317 if (!(op->style & SP_COPY_SOURCEPATH_ABSOLUTE))
318 {
319 /* retrieve relative path for this disk */
320 if (!SetupGetStringFieldW( &disk_ctx, 4, NULL, 0, &len )) len = 0;
321 }
322 /* retrieve relative path for this file */
323 if (!SetupGetStringFieldW( &file_ctx, 2, NULL, 0, &len2 )) len2 = 0;
324
325 if ((len || len2) &&
326 (op->src_path = HeapAlloc( GetProcessHeap(), 0, (len+len2)*sizeof(WCHAR) )))
327 {
328 WCHAR *ptr = op->src_path;
329 if (len)
330 {
331 SetupGetStringFieldW( &disk_ctx, 4, op->src_path, len, NULL );
332 ptr = op->src_path + strlenW(op->src_path);
333 if (len2 && ptr > op->src_path && ptr[-1] != '\\') *ptr++ = '\\';
334 }
335 if (!SetupGetStringFieldW( &disk_ctx, 4, ptr, len2, NULL )) *ptr = 0;
336 }
337 }
338 if (!op->src_root) op->src_root = strdupW( PARSER_get_src_root(hinf) );
339 }
340
341
342 /***********************************************************************
343 * get_destination_dir
344 *
345 * Retrieve the destination dir for a given section.
346 */
347 static WCHAR *get_destination_dir( HINF hinf, const WCHAR *section )
348 {
349 static const WCHAR Dest[] = {'D','e','s','t','i','n','a','t','i','o','n','D','i','r','s',0};
350 static const WCHAR Def[] = {'D','e','f','a','u','l','t','D','e','s','t','D','i','r',0};
351
352 const WCHAR *dir;
353 WCHAR *ptr, *ret;
354 INFCONTEXT context;
355 INT dirid;
356 DWORD len1, len2;
357
358 if (!SetupFindFirstLineW( hinf, Dest, section, &context ) &&
359 !SetupFindFirstLineW( hinf, Dest, Def, &context )) return NULL;
360 if (!SetupGetIntField( &context, 1, &dirid )) return NULL;
361 if (!(dir = DIRID_get_string( hinf, dirid ))) return NULL;
362 len1 = strlenW(dir) + 1;
363 if (!SetupGetStringFieldW( &context, 2, NULL, 0, &len2 )) len2 = 0;
364 if (!(ret = HeapAlloc( GetProcessHeap(), 0, (len1+len2) * sizeof(WCHAR) ))) return NULL;
365 strcpyW( ret, dir );
366 ptr = ret + strlenW(ret);
367 if (len2 && ptr > ret && ptr[-1] != '\\') *ptr++ = '\\';
368 if (!SetupGetStringFieldW( &context, 2, ptr, len2, NULL )) *ptr = 0;
369 return ret;
370 }
371
372
373 static void (WINAPI *pExtractFiles)( LPSTR, LPSTR, DWORD, DWORD, DWORD, DWORD );
374
375 /***********************************************************************
376 * extract_cabinet_file
377 *
378 * Extract a file from a .cab file.
379 */
380 static BOOL extract_cabinet_file( const WCHAR *cabinet, const WCHAR *root,
381 const WCHAR *src, const WCHAR *dst )
382 {
383 static const WCHAR extW[] = {'.','c','a','b',0};
384 static HMODULE advpack;
385
386 char *cab_path, *cab_file;
387 int len = strlenW( cabinet );
388
389 /* make sure the cabinet file has a .cab extension */
390 if (len <= 4 || strcmpiW( cabinet + len - 4, extW )) return FALSE;
391 if (!pExtractFiles)
392 {
393 if (!advpack && !(advpack = LoadLibraryA( "advpack.dll" )))
394 {
395 ERR( "could not load advpack.dll\n" );
396 return FALSE;
397 }
398 if (!(pExtractFiles = (void *)GetProcAddress( advpack, "ExtractFiles" )))
399 {
400 ERR( "could not find ExtractFiles in advpack.dll\n" );
401 return FALSE;
402 }
403 }
404
405 if (!(cab_path = strdupWtoA( root ))) return FALSE;
406 len = WideCharToMultiByte( CP_ACP, 0, cabinet, -1, NULL, 0, NULL, NULL );
407 if (!(cab_file = HeapAlloc( GetProcessHeap(), 0, strlen(cab_path) + len + 1 )))
408 {
409 HeapFree( GetProcessHeap(), 0, cab_path );
410 return FALSE;
411 }
412 strcpy( cab_file, cab_path );
413 if (cab_file[0] && cab_file[strlen(cab_file)-1] != '\\') strcat( cab_file, "\\" );
414 WideCharToMultiByte( CP_ACP, 0, cabinet, -1, cab_file + strlen(cab_file), len, NULL, NULL );
415 FIXME( "awful hack: extracting cabinet %s\n", debugstr_a(cab_file) );
416 pExtractFiles( cab_file, cab_path, 0, 0, 0, 0 );
417 HeapFree( GetProcessHeap(), 0, cab_file );
418 HeapFree( GetProcessHeap(), 0, cab_path );
419 return CopyFileW( src, dst, FALSE /*FIXME*/ );
420 }
421
422
423 /***********************************************************************
424 * SetupOpenFileQueue (SETUPAPI.@)
425 */
426 HSPFILEQ WINAPI SetupOpenFileQueue(void)
427 {
428 struct file_queue *queue;
429
430 if (!(queue = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*queue))))
431 return (HSPFILEQ)INVALID_HANDLE_VALUE;
432 return queue;
433 }
434
435
436 /***********************************************************************
437 * SetupCloseFileQueue (SETUPAPI.@)
438 */
439 BOOL WINAPI SetupCloseFileQueue( HSPFILEQ handle )
440 {
441 struct file_queue *queue = handle;
442
443 free_file_op_queue( &queue->copy_queue );
444 free_file_op_queue( &queue->rename_queue );
445 free_file_op_queue( &queue->delete_queue );
446 HeapFree( GetProcessHeap(), 0, queue );
447 return TRUE;
448 }
449
450
451 /***********************************************************************
452 * SetupQueueCopyIndirectA (SETUPAPI.@)
453 */
454 BOOL WINAPI SetupQueueCopyIndirectA( PSP_FILE_COPY_PARAMS_A params )
455 {
456 struct file_queue *queue = params->QueueHandle;
457 struct file_op *op;
458
459 if (!(op = HeapAlloc( GetProcessHeap(), 0, sizeof(*op) ))) return FALSE;
460 op->style = params->CopyStyle;
461 op->src_root = strdupAtoW( params->SourceRootPath );
462 op->src_path = strdupAtoW( params->SourcePath );
463 op->src_file = strdupAtoW( params->SourceFilename );
464 op->src_descr = strdupAtoW( params->SourceDescription );
465 op->src_tag = strdupAtoW( params->SourceTagfile );
466 op->dst_path = strdupAtoW( params->TargetDirectory );
467 op->dst_file = strdupAtoW( params->TargetFilename );
468
469 /* some defaults */
470 if (!op->src_file) op->src_file = op->dst_file;
471 if (params->LayoutInf)
472 {
473 get_src_file_info( params->LayoutInf, op );
474 if (!op->dst_path) op->dst_path = get_destination_dir( params->LayoutInf, op->dst_file );
475 }
476
477 TRACE( "root=%s path=%s file=%s -> dir=%s file=%s descr=%s tag=%s\n",
478 debugstr_w(op->src_root), debugstr_w(op->src_path), debugstr_w(op->src_file),
479 debugstr_w(op->dst_path), debugstr_w(op->dst_file),
480 debugstr_w(op->src_descr), debugstr_w(op->src_tag) );
481
482 queue_file_op( &queue->copy_queue, op );
483 return TRUE;
484 }
485
486
487 /***********************************************************************
488 * SetupQueueCopyIndirectW (SETUPAPI.@)
489 */
490 BOOL WINAPI SetupQueueCopyIndirectW( PSP_FILE_COPY_PARAMS_W params )
491 {
492 struct file_queue *queue = params->QueueHandle;
493 struct file_op *op;
494
495 if (!(op = HeapAlloc( GetProcessHeap(), 0, sizeof(*op) ))) return FALSE;
496 op->style = params->CopyStyle;
497 op->src_root = strdupW( params->SourceRootPath );
498 op->src_path = strdupW( params->SourcePath );
499 op->src_file = strdupW( params->SourceFilename );
500 op->src_descr = strdupW( params->SourceDescription );
501 op->src_tag = strdupW( params->SourceTagfile );
502 op->dst_path = strdupW( params->TargetDirectory );
503 op->dst_file = strdupW( params->TargetFilename );
504
505 /* some defaults */
506 if (!op->src_file) op->src_file = op->dst_file;
507 if (params->LayoutInf)
508 {
509 get_src_file_info( params->LayoutInf, op );
510 if (!op->dst_path) op->dst_path = get_destination_dir( params->LayoutInf, op->dst_file );
511 }
512
513 TRACE( "root=%s path=%s file=%s -> dir=%s file=%s descr=%s tag=%s\n",
514 debugstr_w(op->src_root), debugstr_w(op->src_path), debugstr_w(op->src_file),
515 debugstr_w(op->dst_path), debugstr_w(op->dst_file),
516 debugstr_w(op->src_descr), debugstr_w(op->src_tag) );
517
518 queue_file_op( &queue->copy_queue, op );
519 return TRUE;
520 }
521
522
523 /***********************************************************************
524 * SetupQueueCopyA (SETUPAPI.@)
525 */
526 BOOL WINAPI SetupQueueCopyA( HSPFILEQ queue, PCSTR src_root, PCSTR src_path, PCSTR src_file,
527 PCSTR src_descr, PCSTR src_tag, PCSTR dst_dir, PCSTR dst_file,
528 DWORD style )
529 {
530 SP_FILE_COPY_PARAMS_A 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 SetupQueueCopyIndirectA( &params );
545 }
546
547
548 /***********************************************************************
549 * SetupQueueCopyW (SETUPAPI.@)
550 */
551 BOOL WINAPI SetupQueueCopyW( HSPFILEQ queue, PCWSTR src_root, PCWSTR src_path, PCWSTR src_file,
552 PCWSTR src_descr, PCWSTR src_tag, PCWSTR dst_dir, PCWSTR dst_file,
553 DWORD style )
554 {
555 SP_FILE_COPY_PARAMS_W params;
556
557 params.cbSize = sizeof(params);
558 params.QueueHandle = queue;
559 params.SourceRootPath = src_root;
560 params.SourcePath = src_path;
561 params.SourceFilename = src_file;
562 params.SourceDescription = src_descr;
563 params.SourceTagfile = src_tag;
564 params.TargetDirectory = dst_dir;
565 params.TargetFilename = dst_file;
566 params.CopyStyle = style;
567 params.LayoutInf = 0;
568 params.SecurityDescriptor = NULL;
569 return SetupQueueCopyIndirectW( &params );
570 }
571
572
573 /***********************************************************************
574 * SetupQueueDefaultCopyA (SETUPAPI.@)
575 */
576 BOOL WINAPI SetupQueueDefaultCopyA( HSPFILEQ queue, HINF hinf, PCSTR src_root, PCSTR src_file,
577 PCSTR dst_file, DWORD style )
578 {
579 SP_FILE_COPY_PARAMS_A params;
580
581 params.cbSize = sizeof(params);
582 params.QueueHandle = queue;
583 params.SourceRootPath = src_root;
584 params.SourcePath = NULL;
585 params.SourceFilename = src_file;
586 params.SourceDescription = NULL;
587 params.SourceTagfile = NULL;
588 params.TargetDirectory = NULL;
589 params.TargetFilename = dst_file;
590 params.CopyStyle = style;
591 params.LayoutInf = hinf;
592 params.SecurityDescriptor = NULL;
593 return SetupQueueCopyIndirectA( &params );
594 }
595
596
597 /***********************************************************************
598 * SetupQueueDefaultCopyW (SETUPAPI.@)
599 */
600 BOOL WINAPI SetupQueueDefaultCopyW( HSPFILEQ queue, HINF hinf, PCWSTR src_root, PCWSTR src_file,
601 PCWSTR dst_file, DWORD style )
602 {
603 SP_FILE_COPY_PARAMS_W params;
604
605 params.cbSize = sizeof(params);
606 params.QueueHandle = queue;
607 params.SourceRootPath = src_root;
608 params.SourcePath = NULL;
609 params.SourceFilename = src_file;
610 params.SourceDescription = NULL;
611 params.SourceTagfile = NULL;
612 params.TargetDirectory = NULL;
613 params.TargetFilename = dst_file;
614 params.CopyStyle = style;
615 params.LayoutInf = hinf;
616 params.SecurityDescriptor = NULL;
617 return SetupQueueCopyIndirectW( &params );
618 }
619
620
621 /***********************************************************************
622 * SetupQueueDeleteA (SETUPAPI.@)
623 */
624 BOOL WINAPI SetupQueueDeleteA( HSPFILEQ handle, PCSTR part1, PCSTR part2 )
625 {
626 struct file_queue *queue = handle;
627 struct file_op *op;
628
629 if (!(op = HeapAlloc( GetProcessHeap(), 0, sizeof(*op) ))) return FALSE;
630 op->style = 0;
631 op->src_root = NULL;
632 op->src_path = NULL;
633 op->src_file = NULL;
634 op->src_descr = NULL;
635 op->src_tag = NULL;
636 op->dst_path = strdupAtoW( part1 );
637 op->dst_file = strdupAtoW( part2 );
638 queue_file_op( &queue->delete_queue, op );
639 return TRUE;
640 }
641
642
643 /***********************************************************************
644 * SetupQueueDeleteW (SETUPAPI.@)
645 */
646 BOOL WINAPI SetupQueueDeleteW( HSPFILEQ handle, PCWSTR part1, PCWSTR part2 )
647 {
648 struct file_queue *queue = handle;
649 struct file_op *op;
650
651 if (!(op = HeapAlloc( GetProcessHeap(), 0, sizeof(*op) ))) return FALSE;
652 op->style = 0;
653 op->src_root = NULL;
654 op->src_path = NULL;
655 op->src_file = NULL;
656 op->src_descr = NULL;
657 op->src_tag = NULL;
658 op->dst_path = strdupW( part1 );
659 op->dst_file = strdupW( part2 );
660 queue_file_op( &queue->delete_queue, op );
661 return TRUE;
662 }
663
664
665 /***********************************************************************
666 * SetupQueueRenameA (SETUPAPI.@)
667 */
668 BOOL WINAPI SetupQueueRenameA( HSPFILEQ handle, PCSTR SourcePath, PCSTR SourceFilename,
669 PCSTR TargetPath, PCSTR TargetFilename )
670 {
671 struct file_queue *queue = handle;
672 struct file_op *op;
673
674 if (!(op = HeapAlloc( GetProcessHeap(), 0, sizeof(*op) ))) return FALSE;
675 op->style = 0;
676 op->src_root = NULL;
677 op->src_path = strdupAtoW( SourcePath );
678 op->src_file = strdupAtoW( SourceFilename );
679 op->src_descr = NULL;
680 op->src_tag = NULL;
681 op->dst_path = strdupAtoW( TargetPath );
682 op->dst_file = strdupAtoW( TargetFilename );
683 queue_file_op( &queue->rename_queue, op );
684 return TRUE;
685 }
686
687
688 /***********************************************************************
689 * SetupQueueRenameW (SETUPAPI.@)
690 */
691 BOOL WINAPI SetupQueueRenameW( HSPFILEQ handle, PCWSTR SourcePath, PCWSTR SourceFilename,
692 PCWSTR TargetPath, PCWSTR TargetFilename )
693 {
694 struct file_queue *queue = handle;
695 struct file_op *op;
696
697 if (!(op = HeapAlloc( GetProcessHeap(), 0, sizeof(*op) ))) return FALSE;
698 op->style = 0;
699 op->src_root = NULL;
700 op->src_path = strdupW( SourcePath );
701 op->src_file = strdupW( SourceFilename );
702 op->src_descr = NULL;
703 op->src_tag = NULL;
704 op->dst_path = strdupW( TargetPath );
705 op->dst_file = strdupW( TargetFilename );
706 queue_file_op( &queue->rename_queue, op );
707 return TRUE;
708 }
709
710
711 /***********************************************************************
712 * SetupQueueCopySectionA (SETUPAPI.@)
713 */
714 BOOL WINAPI SetupQueueCopySectionA( HSPFILEQ queue, PCSTR src_root, HINF hinf, HINF hlist,
715 PCSTR section, DWORD style )
716 {
717 UNICODE_STRING sectionW;
718 BOOL ret = FALSE;
719
720 if (!RtlCreateUnicodeStringFromAsciiz( &sectionW, section ))
721 {
722 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
723 return FALSE;
724 }
725 if (!src_root)
726 ret = SetupQueueCopySectionW( queue, NULL, hinf, hlist, sectionW.Buffer, style );
727 else
728 {
729 UNICODE_STRING srcW;
730 if (RtlCreateUnicodeStringFromAsciiz( &srcW, src_root ))
731 {
732 ret = SetupQueueCopySectionW( queue, srcW.Buffer, hinf, hlist, sectionW.Buffer, style );
733 RtlFreeUnicodeString( &srcW );
734 }
735 else SetLastError( ERROR_NOT_ENOUGH_MEMORY );
736 }
737 RtlFreeUnicodeString( &sectionW );
738 return ret;
739 }
740
741
742 /***********************************************************************
743 * SetupQueueCopySectionW (SETUPAPI.@)
744 */
745 BOOL WINAPI SetupQueueCopySectionW( HSPFILEQ queue, PCWSTR src_root, HINF hinf, HINF hlist,
746 PCWSTR section, DWORD style )
747 {
748 SP_FILE_COPY_PARAMS_W params;
749 INFCONTEXT context;
750 WCHAR dest[MAX_PATH], src[MAX_PATH];
751 INT flags;
752
753 TRACE( "hinf=%p/%p section=%s root=%s\n",
754 hinf, hlist, debugstr_w(section), debugstr_w(src_root) );
755
756 params.cbSize = sizeof(params);
757 params.QueueHandle = queue;
758 params.SourceRootPath = src_root;
759 params.SourcePath = NULL;
760 params.SourceDescription = NULL;
761 params.SourceTagfile = NULL;
762 params.TargetFilename = dest;
763 params.CopyStyle = style;
764 params.LayoutInf = hinf;
765 params.SecurityDescriptor = NULL;
766
767 if (!hlist) hlist = hinf;
768 if (!SetupFindFirstLineW( hlist, section, NULL, &context )) return FALSE;
769 if (!(params.TargetDirectory = get_destination_dir( hinf, section ))) return FALSE;
770 do
771 {
772 if (!SetupGetStringFieldW( &context, 1, dest, sizeof(dest)/sizeof(WCHAR), NULL ))
773 return FALSE;
774 if (!SetupGetStringFieldW( &context, 2, src, sizeof(src)/sizeof(WCHAR), NULL )) *src = 0;
775 if (!SetupGetIntField( &context, 4, &flags )) flags = 0; /* FIXME */
776
777 params.SourceFilename = *src ? src : NULL;
778 if (!SetupQueueCopyIndirectW( &params )) return FALSE;
779 } while (SetupFindNextLine( &context, &context ));
780 return TRUE;
781 }
782
783
784 /***********************************************************************
785 * SetupQueueDeleteSectionA (SETUPAPI.@)
786 */
787 BOOL WINAPI SetupQueueDeleteSectionA( HSPFILEQ queue, HINF hinf, HINF hlist, PCSTR section )
788 {
789 UNICODE_STRING sectionW;
790 BOOL ret = FALSE;
791
792 if (RtlCreateUnicodeStringFromAsciiz( &sectionW, section ))
793 {
794 ret = SetupQueueDeleteSectionW( queue, hinf, hlist, sectionW.Buffer );
795 RtlFreeUnicodeString( &sectionW );
796 }
797 else SetLastError( ERROR_NOT_ENOUGH_MEMORY );
798 return ret;
799 }
800
801
802 /***********************************************************************
803 * SetupQueueDeleteSectionW (SETUPAPI.@)
804 */
805 BOOL WINAPI SetupQueueDeleteSectionW( HSPFILEQ queue, HINF hinf, HINF hlist, PCWSTR section )
806 {
807 INFCONTEXT context;
808 WCHAR *dest_dir;
809 WCHAR buffer[MAX_PATH];
810 BOOL ret = FALSE;
811 INT flags;
812
813 TRACE( "hinf=%p/%p section=%s\n", hinf, hlist, debugstr_w(section) );
814
815 if (!hlist) hlist = hinf;
816 if (!SetupFindFirstLineW( hlist, section, NULL, &context )) return FALSE;
817 if (!(dest_dir = get_destination_dir( hinf, section ))) return FALSE;
818 do
819 {
820 if (!SetupGetStringFieldW( &context, 1, buffer, sizeof(buffer)/sizeof(WCHAR), NULL ))
821 goto done;
822 if (!SetupGetIntField( &context, 4, &flags )) flags = 0;
823 if (!SetupQueueDeleteW( queue, dest_dir, buffer )) goto done;
824 } while (SetupFindNextLine( &context, &context ));
825
826 ret = TRUE;
827 done:
828 HeapFree( GetProcessHeap(), 0, dest_dir );
829 return ret;
830 }
831
832
833 /***********************************************************************
834 * SetupQueueRenameSectionA (SETUPAPI.@)
835 */
836 BOOL WINAPI SetupQueueRenameSectionA( HSPFILEQ queue, HINF hinf, HINF hlist, PCSTR section )
837 {
838 UNICODE_STRING sectionW;
839 BOOL ret = FALSE;
840
841 if (RtlCreateUnicodeStringFromAsciiz( &sectionW, section ))
842 {
843 ret = SetupQueueRenameSectionW( queue, hinf, hlist, sectionW.Buffer );
844 RtlFreeUnicodeString( &sectionW );
845 }
846 else SetLastError( ERROR_NOT_ENOUGH_MEMORY );
847 return ret;
848 }
849
850
851 /***********************************************************************
852 * SetupQueueRenameSectionW (SETUPAPI.@)
853 */
854 BOOL WINAPI SetupQueueRenameSectionW( HSPFILEQ queue, HINF hinf, HINF hlist, PCWSTR section )
855 {
856 INFCONTEXT context;
857 WCHAR *dest_dir;
858 WCHAR src[MAX_PATH], dst[MAX_PATH];
859 BOOL ret = FALSE;
860
861 TRACE( "hinf=%p/%p section=%s\n", hinf, hlist, debugstr_w(section) );
862
863 if (!hlist) hlist = hinf;
864 if (!SetupFindFirstLineW( hlist, section, NULL, &context )) return FALSE;
865 if (!(dest_dir = get_destination_dir( hinf, section ))) return FALSE;
866 do
867 {
868 if (!SetupGetStringFieldW( &context, 1, dst, sizeof(dst)/sizeof(WCHAR), NULL ))
869 goto done;
870 if (!SetupGetStringFieldW( &context, 2, src, sizeof(src)/sizeof(WCHAR), NULL ))
871 goto done;
872 if (!SetupQueueRenameW( queue, dest_dir, src, NULL, dst )) goto done;
873 } while (SetupFindNextLine( &context, &context ));
874
875 ret = TRUE;
876 done:
877 HeapFree( GetProcessHeap(), 0, dest_dir );
878 return ret;
879 }
880
881
882 /***********************************************************************
883 * SetupCommitFileQueueA (SETUPAPI.@)
884 */
885 BOOL WINAPI SetupCommitFileQueueA( HWND owner, HSPFILEQ queue, PSP_FILE_CALLBACK_A handler,
886 PVOID context )
887 {
888 struct callback_WtoA_context ctx;
889
890 ctx.orig_context = context;
891 ctx.orig_handler = handler;
892 return SetupCommitFileQueueW( owner, queue, QUEUE_callback_WtoA, &ctx );
893 }
894
895
896 /***********************************************************************
897 * create_full_pathW
898 *
899 * Recursively create all directories in the path.
900 */
901 static BOOL create_full_pathW(const WCHAR *path)
902 {
903 BOOL ret = TRUE;
904 int len;
905 WCHAR *new_path;
906
907 new_path = HeapAlloc(GetProcessHeap(), 0, (strlenW(path) + 1) * sizeof(WCHAR));
908 strcpyW(new_path, path);
909
910 while((len = strlenW(new_path)) && new_path[len - 1] == '\\')
911 new_path[len - 1] = 0;
912
913 while(!CreateDirectoryW(new_path, NULL))
914 {
915 WCHAR *slash;
916 DWORD last_error = GetLastError();
917
918 if(last_error == ERROR_ALREADY_EXISTS)
919 break;
920
921 if(last_error != ERROR_PATH_NOT_FOUND)
922 {
923 ret = FALSE;
924 break;
925 }
926
927 if(!(slash = strrchrW(new_path, '\\')))
928 {
929 ret = FALSE;
930 break;
931 }
932
933 len = slash - new_path;
934 new_path[len] = 0;
935 if(!create_full_pathW(new_path))
936 {
937 ret = FALSE;
938 break;
939 }
940 new_path[len] = '\\';
941 }
942
943 HeapFree(GetProcessHeap(), 0, new_path);
944 return ret;
945 }
946
947 BOOL static do_file_copyW( LPCWSTR source, LPCWSTR target, DWORD style)
948 {
949 BOOL rc = FALSE;
950 BOOL docopy = TRUE;
951
952 TRACE("copy %s to %s style 0x%lx\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 %li ... SizeSource %li\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 INT 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 TRACE("Versions: Source %li.%li target %li.%li\n",
1015 SourceInfo->dwFileVersionMS, SourceInfo->dwFileVersionLS,
1016 TargetInfo->dwFileVersionMS, TargetInfo->dwFileVersionLS);
1017
1018 if (TargetInfo->dwFileVersionMS > SourceInfo->dwFileVersionMS)
1019 {
1020 FIXME("Notify that target version is greater..\n");
1021 docopy = FALSE;
1022 }
1023 else if ((TargetInfo->dwFileVersionMS == SourceInfo->dwFileVersionMS)
1024 && (TargetInfo->dwFileVersionLS > SourceInfo->dwFileVersionLS))
1025 {
1026 FIXME("Notify that target version is greater..\n");
1027 docopy = FALSE;
1028 }
1029 else if ((style & SP_COPY_NEWER_ONLY) &&
1030 (TargetInfo->dwFileVersionMS ==
1031 SourceInfo->dwFileVersionMS)
1032 &&(TargetInfo->dwFileVersionLS ==
1033 SourceInfo->dwFileVersionLS))
1034 {
1035 FIXME("Notify that target version is greater..\n");
1036 docopy = FALSE;
1037 }
1038 }
1039 }
1040 HeapFree(GetProcessHeap(),0,VersionSource);
1041 HeapFree(GetProcessHeap(),0,VersionTarget);
1042 }
1043 }
1044 if (style & (SP_COPY_NOOVERWRITE | SP_COPY_FORCE_NOOVERWRITE))
1045 {
1046 if (GetFileAttributesW(target) != INVALID_FILE_ATTRIBUTES)
1047 {
1048 FIXME("Notify user target file exists\n");
1049 docopy = FALSE;
1050 }
1051 }
1052 if (style & (SP_COPY_NODECOMP | SP_COPY_LANGUAGEAWARE | SP_COPY_FORCE_IN_USE |
1053 SP_COPY_IN_USE_NEEDS_REBOOT | SP_COPY_NOSKIP | SP_COPY_WARNIFSKIP))
1054 {
1055 ERR("Unsupported style(s) 0x%lx\n",style);
1056 }
1057
1058 if (docopy)
1059 {
1060 rc = CopyFileW(source,target,FALSE);
1061 TRACE("Did copy... rc was %i\n",rc);
1062 }
1063
1064 /* after copy processing */
1065 if (style & SP_COPY_DELETESOURCE)
1066 {
1067 if (rc)
1068 DeleteFileW(source);
1069 }
1070
1071 return rc;
1072 }
1073
1074 /***********************************************************************
1075 * SetupCommitFileQueueW (SETUPAPI.@)
1076 */
1077 BOOL WINAPI SetupCommitFileQueueW( HWND owner, HSPFILEQ handle, PSP_FILE_CALLBACK_W handler,
1078 PVOID context )
1079 {
1080 struct file_queue *queue = handle;
1081 struct file_op *op;
1082 BOOL result = FALSE;
1083 FILEPATHS_W paths;
1084 UINT op_result;
1085
1086 paths.Source = paths.Target = NULL;
1087
1088 if (!queue->copy_queue.count && !queue->delete_queue.count && !queue->rename_queue.count)
1089 return TRUE; /* nothing to do */
1090
1091 if (!handler( context, SPFILENOTIFY_STARTQUEUE, (UINT)owner, 0 )) return FALSE;
1092
1093 /* perform deletes */
1094
1095 if (queue->delete_queue.count)
1096 {
1097 if (!(handler( context, SPFILENOTIFY_STARTSUBQUEUE, FILEOP_DELETE,
1098 queue->delete_queue.count ))) goto done;
1099 for (op = queue->delete_queue.head; op; op = op->next)
1100 {
1101 build_filepathsW( op, &paths );
1102 op_result = handler( context, SPFILENOTIFY_STARTDELETE, (UINT_PTR)&paths, FILEOP_DELETE);
1103 if (op_result == FILEOP_ABORT) goto done;
1104 while (op_result == FILEOP_DOIT)
1105 {
1106 TRACE( "deleting file %s\n", debugstr_w(paths.Target) );
1107 if (DeleteFileW( paths.Target )) break; /* success */
1108 paths.Win32Error = GetLastError();
1109 op_result = handler( context, SPFILENOTIFY_DELETEERROR, (UINT_PTR)&paths, 0 );
1110 if (op_result == FILEOP_ABORT) goto done;
1111 }
1112 handler( context, SPFILENOTIFY_ENDDELETE, (UINT_PTR)&paths, 0 );
1113 }
1114 handler( context, SPFILENOTIFY_ENDSUBQUEUE, FILEOP_DELETE, 0 );
1115 }
1116
1117 /* perform renames */
1118
1119 if (queue->rename_queue.count)
1120 {
1121 if (!(handler( context, SPFILENOTIFY_STARTSUBQUEUE, FILEOP_RENAME,
1122 queue->rename_queue.count ))) goto done;
1123 for (op = queue->rename_queue.head; op; op = op->next)
1124 {
1125 build_filepathsW( op, &paths );
1126 op_result = handler( context, SPFILENOTIFY_STARTRENAME, (UINT_PTR)&paths, FILEOP_RENAME);
1127 if (op_result == FILEOP_ABORT) goto done;
1128 while (op_result == FILEOP_DOIT)
1129 {
1130 TRACE( "renaming file %s -> %s\n",
1131 debugstr_w(paths.Source), debugstr_w(paths.Target) );
1132 if (MoveFileW( paths.Source, paths.Target )) break; /* success */
1133 paths.Win32Error = GetLastError();
1134 op_result = handler( context, SPFILENOTIFY_RENAMEERROR, (UINT_PTR)&paths, 0 );
1135 if (op_result == FILEOP_ABORT) goto done;
1136 }
1137 handler( context, SPFILENOTIFY_ENDRENAME, (UINT_PTR)&paths, 0 );
1138 }
1139 handler( context, SPFILENOTIFY_ENDSUBQUEUE, FILEOP_RENAME, 0 );
1140 }
1141
1142 /* perform copies */
1143
1144 if (queue->copy_queue.count)
1145 {
1146 if (!(handler( context, SPFILENOTIFY_STARTSUBQUEUE, FILEOP_COPY,
1147 queue->copy_queue.count ))) goto done;
1148 for (op = queue->copy_queue.head; op; op = op->next)
1149 {
1150 WCHAR newpath[MAX_PATH];
1151
1152 build_filepathsW( op, &paths );
1153 op_result = handler( context, SPFILENOTIFY_STARTCOPY, (UINT_PTR)&paths, FILEOP_COPY );
1154 if (op_result == FILEOP_ABORT) goto done;
1155 if (op_result == FILEOP_NEWPATH) op_result = FILEOP_DOIT;
1156 while (op_result == FILEOP_DOIT || op_result == FILEOP_NEWPATH)
1157 {
1158 TRACE( "copying file %s -> %s\n",
1159 debugstr_w( op_result == FILEOP_NEWPATH ? newpath : paths.Source ),
1160 debugstr_w(paths.Target) );
1161 if (op->dst_path)
1162 {
1163 if (!create_full_pathW( op->dst_path ))
1164 {
1165 paths.Win32Error = GetLastError();
1166 op_result = handler( context, SPFILENOTIFY_COPYERROR,
1167 (UINT_PTR)&paths, (UINT_PTR)newpath );
1168 if (op_result == FILEOP_ABORT) goto done;
1169 }
1170 }
1171 if (do_file_copyW( op_result == FILEOP_NEWPATH ? newpath : paths.Source,
1172 paths.Target, op->style )) break; /* success */
1173 /* try to extract it from the cabinet file */
1174 if (op->src_tag)
1175 {
1176 if (extract_cabinet_file( op->src_tag, op->src_root,
1177 paths.Source, paths.Target )) break;
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 handler( context, SPFILENOTIFY_ENDCOPY, (UINT_PTR)&paths, 0 );
1185 }
1186 handler( context, SPFILENOTIFY_ENDSUBQUEUE, FILEOP_COPY, 0 );
1187 }
1188
1189
1190 result = TRUE;
1191
1192 done:
1193 handler( context, SPFILENOTIFY_ENDQUEUE, result, 0 );
1194 HeapFree( GetProcessHeap(), 0, (void *)paths.Source );
1195 HeapFree( GetProcessHeap(), 0, (void *)paths.Target );
1196 return result;
1197 }
1198
1199
1200 /***********************************************************************
1201 * SetupScanFileQueueA (SETUPAPI.@)
1202 */
1203 BOOL WINAPI SetupScanFileQueueA( HSPFILEQ queue, DWORD flags, HWND window,
1204 PSP_FILE_CALLBACK_A callback, PVOID context, PDWORD result )
1205 {
1206 FIXME("stub\n");
1207 return FALSE;
1208 }
1209
1210
1211 /***********************************************************************
1212 * SetupScanFileQueueW (SETUPAPI.@)
1213 */
1214 BOOL WINAPI SetupScanFileQueueW( HSPFILEQ queue, DWORD flags, HWND window,
1215 PSP_FILE_CALLBACK_W callback, PVOID context, PDWORD result )
1216 {
1217 FIXME("stub\n");
1218 return FALSE;
1219 }
1220
1221
1222 /***********************************************************************
1223 * SetupGetFileQueueCount (SETUPAPI.@)
1224 */
1225 BOOL WINAPI SetupGetFileQueueCount( HSPFILEQ handle, UINT op, PUINT result )
1226 {
1227 struct file_queue *queue = handle;
1228
1229 switch(op)
1230 {
1231 case FILEOP_COPY:
1232 *result = queue->copy_queue.count;
1233 return TRUE;
1234 case FILEOP_RENAME:
1235 *result = queue->rename_queue.count;
1236 return TRUE;
1237 case FILEOP_DELETE:
1238 *result = queue->delete_queue.count;
1239 return TRUE;
1240 }
1241 return FALSE;
1242 }
1243
1244
1245 /***********************************************************************
1246 * SetupGetFileQueueFlags (SETUPAPI.@)
1247 */
1248 BOOL WINAPI SetupGetFileQueueFlags( HSPFILEQ handle, PDWORD flags )
1249 {
1250 struct file_queue *queue = handle;
1251 *flags = queue->flags;
1252 return TRUE;
1253 }
1254
1255
1256 /***********************************************************************
1257 * SetupSetFileQueueFlags (SETUPAPI.@)
1258 */
1259 BOOL WINAPI SetupSetFileQueueFlags( HSPFILEQ handle, DWORD mask, DWORD flags )
1260 {
1261 struct file_queue *queue = handle;
1262 queue->flags = (queue->flags & ~mask) | flags;
1263 return TRUE;
1264 }
1265
1266
1267 /***********************************************************************
1268 * SetupInitDefaultQueueCallback (SETUPAPI.@)
1269 */
1270 PVOID WINAPI SetupInitDefaultQueueCallback( HWND owner )
1271 {
1272 return SetupInitDefaultQueueCallbackEx( owner, 0, 0, 0, NULL );
1273 }
1274
1275
1276 /***********************************************************************
1277 * SetupInitDefaultQueueCallbackEx (SETUPAPI.@)
1278 */
1279 PVOID WINAPI SetupInitDefaultQueueCallbackEx( HWND owner, HWND progress, UINT msg,
1280 DWORD reserved1, PVOID reserved2 )
1281 {
1282 struct default_callback_context *context;
1283
1284 if ((context = HeapAlloc( GetProcessHeap(), 0, sizeof(*context) )))
1285 {
1286 context->owner = owner;
1287 context->progress = progress;
1288 context->message = msg;
1289 }
1290 return context;
1291 }
1292
1293
1294 /***********************************************************************
1295 * SetupTermDefaultQueueCallback (SETUPAPI.@)
1296 */
1297 void WINAPI SetupTermDefaultQueueCallback( PVOID context )
1298 {
1299 HeapFree( GetProcessHeap(), 0, context );
1300 }
1301
1302
1303 /***********************************************************************
1304 * SetupDefaultQueueCallbackA (SETUPAPI.@)
1305 */
1306 UINT WINAPI SetupDefaultQueueCallbackA( PVOID context, UINT notification,
1307 UINT_PTR param1, UINT_PTR param2 )
1308 {
1309 FILEPATHS_A *paths = (FILEPATHS_A *)param1;
1310
1311 switch(notification)
1312 {
1313 case SPFILENOTIFY_STARTQUEUE:
1314 TRACE( "start queue\n" );
1315 return TRUE;
1316 case SPFILENOTIFY_ENDQUEUE:
1317 TRACE( "end queue\n" );
1318 return 0;
1319 case SPFILENOTIFY_STARTSUBQUEUE:
1320 TRACE( "start subqueue %d count %d\n", param1, param2 );
1321 return TRUE;
1322 case SPFILENOTIFY_ENDSUBQUEUE:
1323 TRACE( "end subqueue %d\n", param1 );
1324 return 0;
1325 case SPFILENOTIFY_STARTDELETE:
1326 TRACE( "start delete %s\n", debugstr_a(paths->Target) );
1327 return FILEOP_DOIT;
1328 case SPFILENOTIFY_ENDDELETE:
1329 TRACE( "end delete %s\n", debugstr_a(paths->Target) );
1330 return 0;
1331 case SPFILENOTIFY_DELETEERROR:
1332 ERR( "delete error %d %s\n", paths->Win32Error, debugstr_a(paths->Target) );
1333 return FILEOP_SKIP;
1334 case SPFILENOTIFY_STARTRENAME:
1335 TRACE( "start rename %s -> %s\n", debugstr_a(paths->Source), debugstr_a(paths->Target) );
1336 return FILEOP_DOIT;
1337 case SPFILENOTIFY_ENDRENAME:
1338 TRACE( "end rename %s -> %s\n", debugstr_a(paths->Source), debugstr_a(paths->Target) );
1339 return 0;
1340 case SPFILENOTIFY_RENAMEERROR:
1341 ERR( "rename error %d %s -> %s\n", paths->Win32Error,
1342 debugstr_a(paths->Source), debugstr_a(paths->Target) );
1343 return FILEOP_SKIP;
1344 case SPFILENOTIFY_STARTCOPY:
1345 TRACE( "start copy %s -> %s\n", debugstr_a(paths->Source), debugstr_a(paths->Target) );
1346 return FILEOP_DOIT;
1347 case SPFILENOTIFY_ENDCOPY:
1348 TRACE( "end copy %s -> %s\n", debugstr_a(paths->Source), debugstr_a(paths->Target) );
1349 return 0;
1350 case SPFILENOTIFY_COPYERROR:
1351 ERR( "copy error %d %s -> %s\n", paths->Win32Error,
1352 debugstr_a(paths->Source), debugstr_a(paths->Target) );
1353 return FILEOP_SKIP;
1354 case SPFILENOTIFY_NEEDMEDIA:
1355 TRACE( "need media\n" );
1356 return FILEOP_SKIP;
1357 default:
1358 FIXME( "notification %d params %x,%x\n", notification, param1, param2 );
1359 break;
1360 }
1361 return 0;
1362 }
1363
1364
1365 /***********************************************************************
1366 * SetupDefaultQueueCallbackW (SETUPAPI.@)
1367 */
1368 UINT WINAPI SetupDefaultQueueCallbackW( PVOID context, UINT notification,
1369 UINT_PTR param1, UINT_PTR param2 )
1370 {
1371 FIXME( "notification %d params %x,%x\n", notification, param1, param2 );
1372 return FILEOP_SKIP;
1373 }
Windows API implementation