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