1 /* 2 * Setupapi install routines 3 * 4 * Copyright 2002 Alexandre Julliard for CodeWeavers 5 * 2005-2006 Herv� Poussineau (hpoussin@reactos.org) 6 * 7 * This library is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU Lesser General Public 9 * License as published by the Free Software Foundation; either 10 * version 2.1 of the License, or (at your option) any later version. 11 * 12 * This library is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 * Lesser General Public License for more details. 16 * 17 * You should have received a copy of the GNU Lesser General Public 18 * License along with this library; if not, write to the Free Software 19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA 20 */ 21 22 #include "setupapi_private.h" 23 24 #include <winsvc.h> 25 #include <ndk/cmfuncs.h> 26 27 /* Unicode constants */ 28 static const WCHAR BackSlash[] = {'\\',0}; 29 static const WCHAR GroupOrderListKey[] = {'S','Y','S','T','E','M','\\','C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\','C','o','n','t','r','o','l','\\','G','r','o','u','p','O','r','d','e','r','L','i','s','t',0}; 30 static const WCHAR InfDirectory[] = {'i','n','f','\\',0}; 31 static const WCHAR OemFileMask[] = {'o','e','m','*','.','i','n','f',0}; 32 static const WCHAR OemFileSpecification[] = {'o','e','m','%','l','u','.','i','n','f',0}; 33 static const WCHAR DotLnk[] = {'.','l','n','k',0}; 34 static const WCHAR DotServices[] = {'.','S','e','r','v','i','c','e','s',0}; 35 36 static const WCHAR DependenciesKey[] = {'D','e','p','e','n','d','e','n','c','i','e','s',0}; 37 static const WCHAR DescriptionKey[] = {'D','e','s','c','r','i','p','t','i','o','n',0}; 38 static const WCHAR DisplayNameKey[] = {'D','i','s','p','l','a','y','N','a','m','e',0}; 39 static const WCHAR ErrorControlKey[] = {'E','r','r','o','r','C','o','n','t','r','o','l',0}; 40 static const WCHAR LoadOrderGroupKey[] = {'L','o','a','d','O','r','d','e','r','G','r','o','u','p',0}; 41 static const WCHAR SecurityKey[] = {'S','e','c','u','r','i','t','y',0}; 42 static const WCHAR ServiceBinaryKey[] = {'S','e','r','v','i','c','e','B','i','n','a','r','y',0}; 43 static const WCHAR ServiceTypeKey[] = {'S','e','r','v','i','c','e','T','y','p','e',0}; 44 static const WCHAR StartTypeKey[] = {'S','t','a','r','t','T','y','p','e',0}; 45 static const WCHAR StartNameKey[] = {'S','t','a','r','t','N','a','m','e',0}; 46 47 static const WCHAR Name[] = {'N','a','m','e',0}; 48 static const WCHAR CmdLine[] = {'C','m','d','L','i','n','e',0}; 49 static const WCHAR SubDir[] = {'S','u','b','D','i','r',0}; 50 static const WCHAR WorkingDir[] = {'W','o','r','k','i','n','g','D','i','r',0}; 51 static const WCHAR IconPath[] = {'I','c','o','n','P','a','t','h',0}; 52 static const WCHAR IconIndex[] = {'I','c','o','n','I','n','d','e','x',0}; 53 static const WCHAR HotKey[] = {'H','o','t','K','e','y',0}; 54 static const WCHAR InfoTip[] = {'I','n','f','o','T','i','p',0}; 55 static const WCHAR DisplayResource[] = {'D','i','s','p','l','a','y','R','e','s','o','u','r','c','e',0}; 56 57 /* info passed to callback functions dealing with files */ 58 struct files_callback_info 59 { 60 HSPFILEQ queue; 61 PCWSTR src_root; 62 UINT copy_flags; 63 HINF layout; 64 }; 65 66 /* info passed to callback functions dealing with the registry */ 67 struct registry_callback_info 68 { 69 HKEY default_root; 70 BOOL delete; 71 }; 72 73 /* info passed to callback functions dealing with registering dlls */ 74 struct register_dll_info 75 { 76 PSP_FILE_CALLBACK_W callback; 77 PVOID callback_context; 78 BOOL unregister; 79 }; 80 81 /* info passed to callback functions dealing with Needs directives */ 82 struct needs_callback_info 83 { 84 UINT type; 85 86 HWND owner; 87 UINT flags; 88 HKEY key_root; 89 LPCWSTR src_root; 90 UINT copy_flags; 91 PVOID callback; 92 PVOID context; 93 HDEVINFO devinfo; 94 PSP_DEVINFO_DATA devinfo_data; 95 PVOID reserved1; 96 PVOID reserved2; 97 }; 98 99 typedef BOOL (*iterate_fields_func)( HINF hinf, PCWSTR field, void *arg ); 100 static BOOL GetLineText( HINF hinf, PCWSTR section_name, PCWSTR key_name, PWSTR *value); 101 typedef HRESULT (WINAPI *COINITIALIZE)(IN LPVOID pvReserved); 102 typedef HRESULT (WINAPI *COCREATEINSTANCE)(IN REFCLSID rclsid, IN LPUNKNOWN pUnkOuter, IN DWORD dwClsContext, IN REFIID riid, OUT LPVOID *ppv); 103 typedef HRESULT (WINAPI *COUNINITIALIZE)(VOID); 104 105 /* Unicode constants */ 106 static const WCHAR AddService[] = {'A','d','d','S','e','r','v','i','c','e',0}; 107 static const WCHAR CopyFiles[] = {'C','o','p','y','F','i','l','e','s',0}; 108 static const WCHAR DelFiles[] = {'D','e','l','F','i','l','e','s',0}; 109 static const WCHAR RenFiles[] = {'R','e','n','F','i','l','e','s',0}; 110 static const WCHAR Ini2Reg[] = {'I','n','i','2','R','e','g',0}; 111 static const WCHAR LogConf[] = {'L','o','g','C','o','n','f',0}; 112 static const WCHAR AddReg[] = {'A','d','d','R','e','g',0}; 113 static const WCHAR DelReg[] = {'D','e','l','R','e','g',0}; 114 static const WCHAR BitReg[] = {'B','i','t','R','e','g',0}; 115 static const WCHAR UpdateInis[] = {'U','p','d','a','t','e','I','n','i','s',0}; 116 static const WCHAR CopyINF[] = {'C','o','p','y','I','N','F',0}; 117 static const WCHAR UpdateIniFields[] = {'U','p','d','a','t','e','I','n','i','F','i','e','l','d','s',0}; 118 static const WCHAR RegisterDlls[] = {'R','e','g','i','s','t','e','r','D','l','l','s',0}; 119 static const WCHAR UnregisterDlls[] = {'U','n','r','e','g','i','s','t','e','r','D','l','l','s',0}; 120 static const WCHAR ProfileItems[] = {'P','r','o','f','i','l','e','I','t','e','m','s',0}; 121 static const WCHAR Include[] = {'I','n','c','l','u','d','e',0}; 122 static const WCHAR Needs[] = {'N','e','e','d','s',0}; 123 static const WCHAR DotSecurity[] = {'.','S','e','c','u','r','i','t','y',0}; 124 #ifdef __WINESRC__ 125 static const WCHAR WineFakeDlls[] = {'W','i','n','e','F','a','k','e','D','l','l','s',0}; 126 #endif 127 128 129 /*********************************************************************** 130 * get_field_string 131 * 132 * Retrieve the contents of a field, dynamically growing the buffer if necessary. 133 */ 134 static WCHAR *get_field_string( INFCONTEXT *context, DWORD index, WCHAR *buffer, 135 WCHAR *static_buffer, DWORD *size ) 136 { 137 DWORD required; 138 139 if (SetupGetStringFieldW( context, index, buffer, *size, &required )) return buffer; 140 if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) 141 { 142 /* now grow the buffer */ 143 if (buffer != static_buffer) HeapFree( GetProcessHeap(), 0, buffer ); 144 if (!(buffer = HeapAlloc( GetProcessHeap(), 0, required*sizeof(WCHAR) ))) return NULL; 145 *size = required; 146 if (SetupGetStringFieldW( context, index, buffer, *size, &required )) return buffer; 147 } 148 if (buffer != static_buffer) HeapFree( GetProcessHeap(), 0, buffer ); 149 return NULL; 150 } 151 152 153 /*********************************************************************** 154 * copy_files_callback 155 * 156 * Called once for each CopyFiles entry in a given section. 157 */ 158 static BOOL copy_files_callback( HINF hinf, PCWSTR field, void *arg ) 159 { 160 struct files_callback_info *info = arg; 161 162 if (field[0] == '@') /* special case: copy single file */ 163 SetupQueueDefaultCopyW( info->queue, info->layout ? info->layout : hinf, info->src_root, NULL, field+1, info->copy_flags ); 164 else 165 SetupQueueCopySectionW( info->queue, info->src_root, info->layout ? info->layout : hinf, hinf, field, info->copy_flags ); 166 return TRUE; 167 } 168 169 170 /*********************************************************************** 171 * delete_files_callback 172 * 173 * Called once for each DelFiles entry in a given section. 174 */ 175 static BOOL delete_files_callback( HINF hinf, PCWSTR field, void *arg ) 176 { 177 struct files_callback_info *info = arg; 178 SetupQueueDeleteSectionW( info->queue, hinf, 0, field ); 179 return TRUE; 180 } 181 182 183 /*********************************************************************** 184 * rename_files_callback 185 * 186 * Called once for each RenFiles entry in a given section. 187 */ 188 static BOOL rename_files_callback( HINF hinf, PCWSTR field, void *arg ) 189 { 190 struct files_callback_info *info = arg; 191 SetupQueueRenameSectionW( info->queue, hinf, 0, field ); 192 return TRUE; 193 } 194 195 196 /*********************************************************************** 197 * get_root_key 198 * 199 * Retrieve the registry root key from its name. 200 */ 201 static HKEY get_root_key( const WCHAR *name, HKEY def_root ) 202 { 203 static const WCHAR HKCR[] = {'H','K','C','R',0}; 204 static const WCHAR HKCU[] = {'H','K','C','U',0}; 205 static const WCHAR HKLM[] = {'H','K','L','M',0}; 206 static const WCHAR HKU[] = {'H','K','U',0}; 207 static const WCHAR HKR[] = {'H','K','R',0}; 208 209 if (!strcmpiW( name, HKCR )) return HKEY_CLASSES_ROOT; 210 if (!strcmpiW( name, HKCU )) return HKEY_CURRENT_USER; 211 if (!strcmpiW( name, HKLM )) return HKEY_LOCAL_MACHINE; 212 if (!strcmpiW( name, HKU )) return HKEY_USERS; 213 if (!strcmpiW( name, HKR )) return def_root; 214 return 0; 215 } 216 217 218 /*********************************************************************** 219 * append_multi_sz_value 220 * 221 * Append a multisz string to a multisz registry value. 222 */ 223 static void append_multi_sz_value( HKEY hkey, const WCHAR *value, const WCHAR *strings, 224 DWORD str_size ) 225 { 226 DWORD size, type, total; 227 WCHAR *buffer, *p; 228 229 if (RegQueryValueExW( hkey, value, NULL, &type, NULL, &size )) return; 230 if (type != REG_MULTI_SZ) return; 231 232 size = size + str_size * sizeof(WCHAR) ; 233 if (!(buffer = HeapAlloc( GetProcessHeap(), 0, size))) return; 234 if (RegQueryValueExW( hkey, value, NULL, NULL, (BYTE *)buffer, &size )) goto done; 235 236 /* compare each string against all the existing ones */ 237 total = size; 238 while (*strings) 239 { 240 int len = strlenW(strings) + 1; 241 242 for (p = buffer; *p; p += strlenW(p) + 1) 243 if (!strcmpiW( p, strings )) break; 244 245 if (!*p) /* not found, need to append it */ 246 { 247 memcpy( p, strings, len * sizeof(WCHAR) ); 248 p[len] = 0; 249 total += len * sizeof(WCHAR); 250 } 251 strings += len; 252 } 253 if (total != size) 254 { 255 TRACE( "setting value %s to %s\n", debugstr_w(value), debugstr_w(buffer) ); 256 RegSetValueExW( hkey, value, 0, REG_MULTI_SZ, (BYTE *)buffer, total + sizeof(WCHAR) ); 257 } 258 done: 259 HeapFree( GetProcessHeap(), 0, buffer ); 260 } 261 262 263 /*********************************************************************** 264 * delete_multi_sz_value 265 * 266 * Remove a string from a multisz registry value. 267 */ 268 static void delete_multi_sz_value( HKEY hkey, const WCHAR *value, const WCHAR *string ) 269 { 270 DWORD size, type; 271 WCHAR *buffer, *src, *dst; 272 273 if (RegQueryValueExW( hkey, value, NULL, &type, NULL, &size )) return; 274 if (type != REG_MULTI_SZ) return; 275 /* allocate double the size, one for value before and one for after */ 276 if (!(buffer = HeapAlloc( GetProcessHeap(), 0, size * 2))) return; 277 if (RegQueryValueExW( hkey, value, NULL, NULL, (BYTE *)buffer, &size )) goto done; 278 src = buffer; 279 dst = buffer + size; 280 while (*src) 281 { 282 int len = strlenW(src) + 1; 283 if (strcmpiW( src, string )) 284 { 285 memcpy( dst, src, len * sizeof(WCHAR) ); 286 dst += len; 287 } 288 src += len; 289 } 290 *dst++ = 0; 291 if (dst != buffer + 2*size) /* did we remove something? */ 292 { 293 TRACE( "setting value %s to %s\n", debugstr_w(value), debugstr_w(buffer + size) ); 294 RegSetValueExW( hkey, value, 0, REG_MULTI_SZ, 295 (BYTE *)(buffer + size), dst - (buffer + size) ); 296 } 297 done: 298 HeapFree( GetProcessHeap(), 0, buffer ); 299 } 300 301 302 /*********************************************************************** 303 * do_reg_operation 304 * 305 * Perform an add/delete registry operation depending on the flags. 306 */ 307 static BOOL do_reg_operation( HKEY hkey, const WCHAR *value, INFCONTEXT *context, INT flags ) 308 { 309 DWORD type, size; 310 311 if (flags & (FLG_ADDREG_DELREG_BIT | FLG_ADDREG_DELVAL)) /* deletion */ 312 { 313 if (*value && !(flags & FLG_DELREG_KEYONLY_COMMON)) 314 { 315 if ((flags & FLG_DELREG_MULTI_SZ_DELSTRING) == FLG_DELREG_MULTI_SZ_DELSTRING) 316 { 317 WCHAR *str; 318 319 if (!SetupGetStringFieldW( context, 5, NULL, 0, &size ) || !size) return TRUE; 320 if (!(str = HeapAlloc( GetProcessHeap(), 0, size * sizeof(WCHAR) ))) return FALSE; 321 SetupGetStringFieldW( context, 5, str, size, NULL ); 322 delete_multi_sz_value( hkey, value, str ); 323 HeapFree( GetProcessHeap(), 0, str ); 324 } 325 else RegDeleteValueW( hkey, value ); 326 } 327 else NtDeleteKey( hkey ); 328 return TRUE; 329 } 330 331 if (flags & (FLG_ADDREG_KEYONLY|FLG_ADDREG_KEYONLY_COMMON)) return TRUE; 332 333 if (flags & (FLG_ADDREG_NOCLOBBER|FLG_ADDREG_OVERWRITEONLY)) 334 { 335 BOOL exists = !RegQueryValueExW( hkey, value, NULL, NULL, NULL, NULL ); 336 if (exists && (flags & FLG_ADDREG_NOCLOBBER)) return TRUE; 337 if (!exists && (flags & FLG_ADDREG_OVERWRITEONLY)) return TRUE; 338 } 339 340 switch(flags & FLG_ADDREG_TYPE_MASK) 341 { 342 case FLG_ADDREG_TYPE_SZ: type = REG_SZ; break; 343 case FLG_ADDREG_TYPE_MULTI_SZ: type = REG_MULTI_SZ; break; 344 case FLG_ADDREG_TYPE_EXPAND_SZ: type = REG_EXPAND_SZ; break; 345 case FLG_ADDREG_TYPE_BINARY: type = REG_BINARY; break; 346 case FLG_ADDREG_TYPE_DWORD: type = REG_DWORD; break; 347 case FLG_ADDREG_TYPE_NONE: type = REG_NONE; break; 348 default: type = flags >> 16; break; 349 } 350 351 if (!(flags & FLG_ADDREG_BINVALUETYPE) || 352 (type == REG_DWORD && SetupGetFieldCount(context) == 5)) 353 { 354 static const WCHAR empty; 355 WCHAR *str = NULL; 356 357 if (type == REG_MULTI_SZ) 358 { 359 if (!SetupGetMultiSzFieldW( context, 5, NULL, 0, &size )) size = 0; 360 if (size) 361 { 362 if (!(str = HeapAlloc( GetProcessHeap(), 0, size * sizeof(WCHAR) ))) return FALSE; 363 SetupGetMultiSzFieldW( context, 5, str, size, NULL ); 364 } 365 if (flags & FLG_ADDREG_APPEND) 366 { 367 if (!str) return TRUE; 368 append_multi_sz_value( hkey, value, str, size ); 369 HeapFree( GetProcessHeap(), 0, str ); 370 return TRUE; 371 } 372 /* else fall through to normal string handling */ 373 } 374 else 375 { 376 if (!SetupGetStringFieldW( context, 5, NULL, 0, &size )) size = 0; 377 if (size) 378 { 379 if (!(str = HeapAlloc( GetProcessHeap(), 0, size * sizeof(WCHAR) ))) return FALSE; 380 SetupGetStringFieldW( context, 5, str, size, NULL ); 381 } 382 } 383 384 if (type == REG_DWORD) 385 { 386 DWORD dw = str ? strtoulW( str, NULL, 0 ) : 0; 387 TRACE( "setting dword %s to %x\n", debugstr_w(value), dw ); 388 RegSetValueExW( hkey, value, 0, type, (BYTE *)&dw, sizeof(dw) ); 389 } 390 else 391 { 392 TRACE( "setting value %s to %s\n", debugstr_w(value), debugstr_w(str) ); 393 if (str) RegSetValueExW( hkey, value, 0, type, (BYTE *)str, size * sizeof(WCHAR) ); 394 else RegSetValueExW( hkey, value, 0, type, (const BYTE *)&empty, sizeof(WCHAR) ); 395 } 396 HeapFree( GetProcessHeap(), 0, str ); 397 return TRUE; 398 } 399 else /* get the binary data */ 400 { 401 BYTE *data = NULL; 402 403 if (!SetupGetBinaryField( context, 5, NULL, 0, &size )) size = 0; 404 if (size) 405 { 406 if (!(data = HeapAlloc( GetProcessHeap(), 0, size ))) return FALSE; 407 TRACE( "setting binary data %s len %d\n", debugstr_w(value), size ); 408 SetupGetBinaryField( context, 5, data, size, NULL ); 409 } 410 RegSetValueExW( hkey, value, 0, type, data, size ); 411 HeapFree( GetProcessHeap(), 0, data ); 412 return TRUE; 413 } 414 } 415 416 417 /*********************************************************************** 418 * registry_callback 419 * 420 * Called once for each AddReg and DelReg entry in a given section. 421 */ 422 static BOOL registry_callback( HINF hinf, PCWSTR field, void *arg ) 423 { 424 struct registry_callback_info *info = arg; 425 LPWSTR security_key, security_descriptor; 426 INFCONTEXT context, security_context; 427 PSECURITY_DESCRIPTOR sd = NULL; 428 SECURITY_ATTRIBUTES security_attributes = { 0, }; 429 HKEY root_key, hkey; 430 DWORD required; 431 432 BOOL ok = SetupFindFirstLineW( hinf, field, NULL, &context ); 433 if (!ok) 434 return TRUE; 435 436 /* Check for .Security section */ 437 security_key = MyMalloc( (strlenW( field ) + strlenW( DotSecurity )) * sizeof(WCHAR) + sizeof(UNICODE_NULL) ); 438 if (!security_key) 439 { 440 SetLastError(ERROR_NOT_ENOUGH_MEMORY); 441 return FALSE; 442 } 443 strcpyW( security_key, field ); 444 strcatW( security_key, DotSecurity ); 445 ok = SetupFindFirstLineW( hinf, security_key, NULL, &security_context ); 446 MyFree(security_key); 447 if (ok) 448 { 449 if (!SetupGetLineTextW( &security_context, NULL, NULL, NULL, NULL, 0, &required )) 450 return FALSE; 451 security_descriptor = MyMalloc( required * sizeof(WCHAR) ); 452 if (!security_descriptor) 453 { 454 SetLastError(ERROR_NOT_ENOUGH_MEMORY); 455 return FALSE; 456 } 457 if (!SetupGetLineTextW( &security_context, NULL, NULL, NULL, security_descriptor, required, NULL )) 458 return FALSE; 459 ok = ConvertStringSecurityDescriptorToSecurityDescriptorW( security_descriptor, SDDL_REVISION_1, &sd, NULL ); 460 MyFree( security_descriptor ); 461 if (!ok) 462 return FALSE; 463 security_attributes.nLength = sizeof(SECURITY_ATTRIBUTES); 464 security_attributes.lpSecurityDescriptor = sd; 465 } 466 467 for (ok = TRUE; ok; ok = SetupFindNextLine( &context, &context )) 468 { 469 WCHAR buffer[MAX_INF_STRING_LENGTH]; 470 INT flags; 471 472 /* get root */ 473 if (!SetupGetStringFieldW( &context, 1, buffer, sizeof(buffer)/sizeof(WCHAR), NULL )) 474 continue; 475 if (!(root_key = get_root_key( buffer, info->default_root ))) 476 continue; 477 478 /* get key */ 479 if (!SetupGetStringFieldW( &context, 2, buffer, sizeof(buffer)/sizeof(WCHAR), NULL )) 480 *buffer = 0; 481 482 /* get flags */ 483 if (!SetupGetIntField( &context, 4, &flags )) flags = 0; 484 485 if (!info->delete) 486 { 487 if (flags & FLG_ADDREG_DELREG_BIT) continue; /* ignore this entry */ 488 } 489 else 490 { 491 if (!flags) flags = FLG_ADDREG_DELREG_BIT; 492 else if (!(flags & FLG_ADDREG_DELREG_BIT)) continue; /* ignore this entry */ 493 } 494 495 if (info->delete || (flags & FLG_ADDREG_OVERWRITEONLY)) 496 { 497 if (RegOpenKeyW( root_key, buffer, &hkey )) continue; /* ignore if it doesn't exist */ 498 } 499 else if (RegCreateKeyExW( root_key, buffer, 0, NULL, 0, MAXIMUM_ALLOWED, 500 sd ? &security_attributes : NULL, &hkey, NULL )) 501 { 502 ERR( "could not create key %p %s\n", root_key, debugstr_w(buffer) ); 503 continue; 504 } 505 TRACE( "key %p %s\n", root_key, debugstr_w(buffer) ); 506 507 /* get value name */ 508 if (!SetupGetStringFieldW( &context, 3, buffer, sizeof(buffer)/sizeof(WCHAR), NULL )) 509 *buffer = 0; 510 511 /* and now do it */ 512 if (!do_reg_operation( hkey, buffer, &context, flags )) 513 { 514 if (hkey != root_key) RegCloseKey( hkey ); 515 if (sd) LocalFree( sd ); 516 return FALSE; 517 } 518 if (hkey != root_key) RegCloseKey( hkey ); 519 } 520 if (sd) LocalFree( sd ); 521 return TRUE; 522 } 523 524 525 /*********************************************************************** 526 * do_register_dll 527 * 528 * Register or unregister a dll. 529 */ 530 static BOOL do_register_dll( const struct register_dll_info *info, const WCHAR *path, 531 INT flags, INT timeout, const WCHAR *args ) 532 { 533 HMODULE module; 534 HRESULT res; 535 SP_REGISTER_CONTROL_STATUSW status; 536 #ifdef __WINESRC__ 537 IMAGE_NT_HEADERS *nt; 538 #endif 539 540 status.cbSize = sizeof(status); 541 status.FileName = path; 542 status.FailureCode = SPREG_SUCCESS; 543 status.Win32Error = ERROR_SUCCESS; 544 545 if (info->callback) 546 { 547 switch(info->callback( info->callback_context, SPFILENOTIFY_STARTREGISTRATION, 548 (UINT_PTR)&status, !info->unregister )) 549 { 550 case FILEOP_ABORT: 551 SetLastError( ERROR_OPERATION_ABORTED ); 552 return FALSE; 553 case FILEOP_SKIP: 554 return TRUE; 555 case FILEOP_DOIT: 556 break; 557 } 558 } 559 560 if (!(module = LoadLibraryExW( path, 0, LOAD_WITH_ALTERED_SEARCH_PATH ))) 561 { 562 WARN( "could not load %s\n", debugstr_w(path) ); 563 status.FailureCode = SPREG_LOADLIBRARY; 564 status.Win32Error = GetLastError(); 565 goto done; 566 } 567 568 #ifdef __WINESRC__ 569 if ((nt = RtlImageNtHeader( module )) && !(nt->FileHeader.Characteristics & IMAGE_FILE_DLL)) 570 { 571 /* file is an executable, not a dll */ 572 STARTUPINFOW startup; 573 PROCESS_INFORMATION info; 574 WCHAR *cmd_line; 575 BOOL res; 576 static const WCHAR format[] = {'"','%','s','"',' ','%','s',0}; 577 static const WCHAR default_args[] = {'/','R','e','g','S','e','r','v','e','r',0}; 578 579 FreeLibrary( module ); 580 module = NULL; 581 if (!args) args = default_args; 582 cmd_line = HeapAlloc( GetProcessHeap(), 0, (strlenW(path) + strlenW(args) + 4) * sizeof(WCHAR) ); 583 sprintfW( cmd_line, format, path, args ); 584 memset( &startup, 0, sizeof(startup) ); 585 startup.cb = sizeof(startup); 586 TRACE( "executing %s\n", debugstr_w(cmd_line) ); 587 res = CreateProcessW( NULL, cmd_line, NULL, NULL, FALSE, 0, NULL, NULL, &startup, &info ); 588 HeapFree( GetProcessHeap(), 0, cmd_line ); 589 if (!res) 590 { 591 status.FailureCode = SPREG_LOADLIBRARY; 592 status.Win32Error = GetLastError(); 593 goto done; 594 } 595 CloseHandle( info.hThread ); 596 597 if (WaitForSingleObject( info.hProcess, timeout*1000 ) == WAIT_TIMEOUT) 598 { 599 /* timed out, kill the process */ 600 TerminateProcess( info.hProcess, 1 ); 601 status.FailureCode = SPREG_TIMEOUT; 602 status.Win32Error = ERROR_TIMEOUT; 603 } 604 CloseHandle( info.hProcess ); 605 goto done; 606 } 607 #endif // __WINESRC__ 608 609 if (flags & FLG_REGSVR_DLLREGISTER) 610 { 611 const char *entry_point = info->unregister ? "DllUnregisterServer" : "DllRegisterServer"; 612 HRESULT (WINAPI *func)(void) = (void *)GetProcAddress( module, entry_point ); 613 614 if (!func) 615 { 616 status.FailureCode = SPREG_GETPROCADDR; 617 status.Win32Error = GetLastError(); 618 goto done; 619 } 620 621 TRACE( "calling %s in %s\n", entry_point, debugstr_w(path) ); 622 res = func(); 623 624 if (FAILED(res)) 625 { 626 WARN( "calling %s in %s returned error %x\n", entry_point, debugstr_w(path), res ); 627 status.FailureCode = SPREG_REGSVR; 628 status.Win32Error = res; 629 goto done; 630 } 631 } 632 633 if (flags & FLG_REGSVR_DLLINSTALL) 634 { 635 HRESULT (WINAPI *func)(BOOL,LPCWSTR) = (void *)GetProcAddress( module, "DllInstall" ); 636 637 if (!func) 638 { 639 status.FailureCode = SPREG_GETPROCADDR; 640 status.Win32Error = GetLastError(); 641 goto done; 642 } 643 644 TRACE( "calling DllInstall(%d,%s) in %s\n", 645 !info->unregister, debugstr_w(args), debugstr_w(path) ); 646 res = func( !info->unregister, args ); 647 648 if (FAILED(res)) 649 { 650 WARN( "calling DllInstall in %s returned error %x\n", debugstr_w(path), res ); 651 status.FailureCode = SPREG_REGSVR; 652 status.Win32Error = res; 653 goto done; 654 } 655 } 656 657 done: 658 if (module) FreeLibrary( module ); 659 if (info->callback) info->callback( info->callback_context, SPFILENOTIFY_ENDREGISTRATION, 660 (UINT_PTR)&status, !info->unregister ); 661 return TRUE; 662 } 663 664 665 /*********************************************************************** 666 * register_dlls_callback 667 * 668 * Called once for each RegisterDlls entry in a given section. 669 */ 670 static BOOL register_dlls_callback( HINF hinf, PCWSTR field, void *arg ) 671 { 672 struct register_dll_info *info = arg; 673 INFCONTEXT context; 674 BOOL ret = TRUE; 675 BOOL ok = SetupFindFirstLineW( hinf, field, NULL, &context ); 676 677 for (; ok; ok = SetupFindNextLine( &context, &context )) 678 { 679 WCHAR *path, *args, *p; 680 WCHAR buffer[MAX_INF_STRING_LENGTH]; 681 INT flags, timeout; 682 683 /* get directory */ 684 if (!(path = PARSER_get_dest_dir( &context ))) continue; 685 686 /* get dll name */ 687 if (!SetupGetStringFieldW( &context, 3, buffer, sizeof(buffer)/sizeof(WCHAR), NULL )) 688 goto done; 689 if (!(p = HeapReAlloc( GetProcessHeap(), 0, path, 690 (strlenW(path) + strlenW(buffer) + 2) * sizeof(WCHAR) ))) goto done; 691 path = p; 692 p += strlenW(p); 693 if (p == path || p[-1] != '\\') *p++ = '\\'; 694 strcpyW( p, buffer ); 695 696 /* get flags */ 697 if (!SetupGetIntField( &context, 4, &flags )) flags = 0; 698 699 /* get timeout */ 700 if (!SetupGetIntField( &context, 5, &timeout )) timeout = 60; 701 702 /* get command line */ 703 args = NULL; 704 if (SetupGetStringFieldW( &context, 6, buffer, sizeof(buffer)/sizeof(WCHAR), NULL )) 705 args = buffer; 706 707 ret = do_register_dll( info, path, flags, timeout, args ); 708 709 done: 710 HeapFree( GetProcessHeap(), 0, path ); 711 if (!ret) break; 712 } 713 return ret; 714 } 715 716 #ifdef __WINESRC__ 717 /*********************************************************************** 718 * fake_dlls_callback 719 * 720 * Called once for each WineFakeDlls entry in a given section. 721 */ 722 static BOOL fake_dlls_callback( HINF hinf, PCWSTR field, void *arg ) 723 { 724 INFCONTEXT context; 725 BOOL ret = TRUE; 726 BOOL ok = SetupFindFirstLineW( hinf, field, NULL, &context ); 727 728 for (; ok; ok = SetupFindNextLine( &context, &context )) 729 { 730 WCHAR *path, *p; 731 WCHAR buffer[MAX_INF_STRING_LENGTH]; 732 733 /* get directory */ 734 if (!(path = PARSER_get_dest_dir( &context ))) continue; 735 736 /* get dll name */ 737 if (!SetupGetStringFieldW( &context, 3, buffer, sizeof(buffer)/sizeof(WCHAR), NULL )) 738 goto done; 739 if (!(p = HeapReAlloc( GetProcessHeap(), 0, path, 740 (strlenW(path) + strlenW(buffer) + 2) * sizeof(WCHAR) ))) goto done; 741 path = p; 742 p += strlenW(p); 743 if (p == path || p[-1] != '\\') *p++ = '\\'; 744 strcpyW( p, buffer ); 745 746 /* get source dll */ 747 if (SetupGetStringFieldW( &context, 4, buffer, sizeof(buffer)/sizeof(WCHAR), NULL )) 748 p = buffer; /* otherwise use target base name as default source */ 749 750 create_fake_dll( path, p ); /* ignore errors */ 751 752 done: 753 HeapFree( GetProcessHeap(), 0, path ); 754 if (!ret) break; 755 } 756 return ret; 757 } 758 #endif // __WINESRC__ 759 760 /*********************************************************************** 761 * update_ini_callback 762 * 763 * Called once for each UpdateInis entry in a given section. 764 */ 765 static BOOL update_ini_callback( HINF hinf, PCWSTR field, void *arg ) 766 { 767 INFCONTEXT context; 768 769 BOOL ok = SetupFindFirstLineW( hinf, field, NULL, &context ); 770 771 for (; ok; ok = SetupFindNextLine( &context, &context )) 772 { 773 WCHAR buffer[MAX_INF_STRING_LENGTH]; 774 WCHAR filename[MAX_INF_STRING_LENGTH]; 775 WCHAR section[MAX_INF_STRING_LENGTH]; 776 WCHAR entry[MAX_INF_STRING_LENGTH]; 777 WCHAR string[MAX_INF_STRING_LENGTH]; 778 LPWSTR divider; 779 780 if (!SetupGetStringFieldW( &context, 1, filename, 781 sizeof(filename)/sizeof(WCHAR), NULL )) 782 continue; 783 784 if (!SetupGetStringFieldW( &context, 2, section, 785 sizeof(section)/sizeof(WCHAR), NULL )) 786 continue; 787 788 if (!SetupGetStringFieldW( &context, 4, buffer, 789 sizeof(buffer)/sizeof(WCHAR), NULL )) 790 continue; 791 792 divider = strchrW(buffer,'='); 793 if (divider) 794 { 795 *divider = 0; 796 strcpyW(entry,buffer); 797 divider++; 798 strcpyW(string,divider); 799 } 800 else 801 { 802 strcpyW(entry,buffer); 803 string[0]=0; 804 } 805 806 TRACE("Writing %s = %s in %s of file %s\n",debugstr_w(entry), 807 debugstr_w(string),debugstr_w(section),debugstr_w(filename)); 808 WritePrivateProfileStringW(section,entry,string,filename); 809 810 } 811 return TRUE; 812 } 813 814 static BOOL update_ini_fields_callback( HINF hinf, PCWSTR field, void *arg ) 815 { 816 FIXME( "should update ini fields %s\n", debugstr_w(field) ); 817 return TRUE; 818 } 819 820 static BOOL ini2reg_callback( HINF hinf, PCWSTR field, void *arg ) 821 { 822 FIXME( "should do ini2reg %s\n", debugstr_w(field) ); 823 return TRUE; 824 } 825 826 static BOOL logconf_callback( HINF hinf, PCWSTR field, void *arg ) 827 { 828 FIXME( "should do logconf %s\n", debugstr_w(field) ); 829 return TRUE; 830 } 831 832 static BOOL bitreg_callback( HINF hinf, PCWSTR field, void *arg ) 833 { 834 FIXME( "should do bitreg %s\n", debugstr_w(field) ); 835 return TRUE; 836 } 837 838 static BOOL Concatenate(int DirId, LPCWSTR SubDirPart, LPCWSTR NamePart, LPWSTR *pFullName) 839 { 840 DWORD dwRequired = 0; 841 LPCWSTR Dir; 842 LPWSTR FullName; 843 844 *pFullName = NULL; 845 846 Dir = DIRID_get_string(DirId); 847 if (Dir) 848 dwRequired += wcslen(Dir) + 1; 849 if (SubDirPart) 850 dwRequired += wcslen(SubDirPart) + 1; 851 if (NamePart) 852 dwRequired += wcslen(NamePart); 853 dwRequired = dwRequired * sizeof(WCHAR) + sizeof(UNICODE_NULL); 854 855 FullName = MyMalloc(dwRequired); 856 if (!FullName) 857 { 858 SetLastError(ERROR_NOT_ENOUGH_MEMORY); 859 return FALSE; 860 } 861 FullName[0] = UNICODE_NULL; 862 863 if (Dir) 864 { 865 wcscat(FullName, Dir); 866 if (FullName[wcslen(FullName) - 1] != '\\') 867 wcscat(FullName, BackSlash); 868 } 869 if (SubDirPart) 870 { 871 wcscat(FullName, SubDirPart); 872 if (FullName[wcslen(FullName) - 1] != '\\') 873 wcscat(FullName, BackSlash); 874 } 875 if (NamePart) 876 wcscat(FullName, NamePart); 877 878 *pFullName = FullName; 879 return TRUE; 880 } 881 882 /*********************************************************************** 883 * profile_items_callback 884 * 885 * Called once for each ProfileItems entry in a given section. 886 */ 887 static BOOL 888 profile_items_callback( 889 IN HINF hInf, 890 IN PCWSTR SectionName, 891 IN PVOID Arg) 892 { 893 INFCONTEXT Context; 894 LPWSTR LinkSubDir = NULL, LinkName = NULL; 895 INT LinkAttributes = 0; 896 INT LinkFolder = 0; 897 INT FileDirId = 0; 898 INT CSIDL = CSIDL_COMMON_PROGRAMS; 899 LPWSTR FileSubDir = NULL; 900 INT DirId = 0; 901 LPWSTR SubDirPart = NULL, NamePart = NULL; 902 LPWSTR FullLinkName = NULL, FullFileName = NULL, FullWorkingDir = NULL, FullIconName = NULL; 903 INT IconIdx = 0; 904 LPWSTR lpHotKey = NULL, lpInfoTip = NULL; 905 LPWSTR DisplayName = NULL; 906 INT DisplayResId = 0; 907 BOOL ret = FALSE; 908 DWORD Index, Required; 909 910 IShellLinkW *psl; 911 IPersistFile *ppf; 912 HMODULE hOle32 = NULL; 913 COINITIALIZE pCoInitialize; 914 COCREATEINSTANCE pCoCreateInstance; 915 COUNINITIALIZE pCoUninitialize; 916 HRESULT hr; 917 918 TRACE("hInf %p, SectionName %s, Arg %p\n", 919 hInf, debugstr_w(SectionName), Arg); 920 921 /* Read 'Name' entry */ 922 if (!SetupFindFirstLineW(hInf, SectionName, Name, &Context)) 923 goto cleanup; 924 if (!GetStringField(&Context, 1, &LinkName)) 925 goto cleanup; 926 if (SetupGetFieldCount(&Context) >= 2) 927 { 928 if (!SetupGetIntField(&Context, 2, &LinkAttributes)) 929 goto cleanup; 930 } 931 if (SetupGetFieldCount(&Context) >= 3) 932 { 933 if (!SetupGetIntField(&Context, 3, &LinkFolder)) 934 goto cleanup; 935 } 936 937 /* Read 'CmdLine' entry */ 938 if (!SetupFindFirstLineW(hInf, SectionName, CmdLine, &Context)) 939 goto cleanup; 940 Index = 1; 941 if (!SetupGetIntField(&Context, Index++, &FileDirId)) 942 goto cleanup; 943 if (SetupGetFieldCount(&Context) >= 3) 944 { 945 if (!GetStringField(&Context, Index++, &FileSubDir)) 946 goto cleanup; 947 } 948 if (!GetStringField(&Context, Index++, &NamePart)) 949 goto cleanup; 950 if (!Concatenate(FileDirId, FileSubDir, NamePart, &FullFileName)) 951 goto cleanup; 952 MyFree(NamePart); 953 NamePart = NULL; 954 955 /* Read 'SubDir' entry */ 956 if ((LinkAttributes & FLG_PROFITEM_GROUP) == 0 && SetupFindFirstLineW(hInf, SectionName, SubDir, &Context)) 957 { 958 if (!GetStringField(&Context, 1, &LinkSubDir)) 959 goto cleanup; 960 } 961 962 /* Read 'WorkingDir' entry */ 963 if (SetupFindFirstLineW(hInf, SectionName, WorkingDir, &Context)) 964 { 965 if (!SetupGetIntField(&Context, 1, &DirId)) 966 goto cleanup; 967 if (SetupGetFieldCount(&Context) >= 2) 968 { 969 if (!GetStringField(&Context, 2, &SubDirPart)) 970 goto cleanup; 971 } 972 if (!Concatenate(DirId, SubDirPart, NULL, &FullWorkingDir)) 973 goto cleanup; 974 MyFree(SubDirPart); 975 SubDirPart = NULL; 976 } 977 else 978 { 979 if (!Concatenate(FileDirId, FileSubDir, NULL, &FullWorkingDir)) 980 goto cleanup; 981 } 982 983 /* Read 'IconPath' entry */ 984 if (SetupFindFirstLineW(hInf, SectionName, IconPath, &Context)) 985 { 986 Index = 1; 987 if (!SetupGetIntField(&Context, Index++, &DirId)) 988 goto cleanup; 989 if (SetupGetFieldCount(&Context) >= 3) 990 { 991 if (!GetStringField(&Context, Index++, &SubDirPart)) 992 goto cleanup; 993 } 994 if (!GetStringField(&Context, Index, &NamePart)) 995 goto cleanup; 996 if (!Concatenate(DirId, SubDirPart, NamePart, &FullIconName)) 997 goto cleanup; 998 MyFree(SubDirPart); 999 MyFree(NamePart); 1000 SubDirPart = NamePart = NULL; 1001 } 1002 else 1003 { 1004 FullIconName = pSetupDuplicateString(FullFileName); 1005 if (!FullIconName) 1006 goto cleanup; 1007 } 1008 1009 /* Read 'IconIndex' entry */ 1010 if (SetupFindFirstLineW(hInf, SectionName, IconIndex, &Context)) 1011 { 1012 if (!SetupGetIntField(&Context, 1, &IconIdx)) 1013 goto cleanup; 1014 } 1015 1016 /* Read 'HotKey' and 'InfoTip' entries */ 1017 GetLineText(hInf, SectionName, HotKey, &lpHotKey); 1018 GetLineText(hInf, SectionName, InfoTip, &lpInfoTip); 1019 1020 /* Read 'DisplayResource' entry */ 1021 if (SetupFindFirstLineW(hInf, SectionName, DisplayResource, &Context)) 1022 { 1023 if (!GetStringField(&Context, 1, &DisplayName)) 1024 goto cleanup; 1025 if (!SetupGetIntField(&Context, 2, &DisplayResId)) 1026 goto cleanup; 1027 } 1028 1029 /* Some debug */ 1030 TRACE("Link is %s\\%s, attributes 0x%x\n", debugstr_w(LinkSubDir), debugstr_w(LinkName), LinkAttributes); 1031 TRACE("File is %s\n", debugstr_w(FullFileName)); 1032 TRACE("Working dir %s\n", debugstr_w(FullWorkingDir)); 1033 TRACE("Icon is %s, %d\n", debugstr_w(FullIconName), IconIdx); 1034 TRACE("Hotkey %s\n", debugstr_w(lpHotKey)); 1035 TRACE("InfoTip %s\n", debugstr_w(lpInfoTip)); 1036 TRACE("Display %s, %d\n", DisplayName, DisplayResId); 1037 1038 /* Load ole32.dll */ 1039 hOle32 = LoadLibraryA("ole32.dll"); 1040 if (!hOle32) 1041 goto cleanup; 1042 pCoInitialize = (COINITIALIZE)GetProcAddress(hOle32, "CoInitialize"); 1043 if (!pCoInitialize) 1044 goto cleanup; 1045 pCoCreateInstance = (COCREATEINSTANCE)GetProcAddress(hOle32, "CoCreateInstance"); 1046 if (!pCoCreateInstance) 1047 goto cleanup; 1048 pCoUninitialize = (COUNINITIALIZE)GetProcAddress(hOle32, "CoUninitialize"); 1049 if (!pCoUninitialize) 1050 goto cleanup; 1051 1052 /* Create shortcut */ 1053 hr = pCoInitialize(NULL); 1054 if (!SUCCEEDED(hr)) 1055 { 1056 if (HRESULT_FACILITY(hr) == FACILITY_WIN32) 1057 SetLastError(HRESULT_CODE(hr)); 1058 else 1059 SetLastError(E_FAIL); 1060 goto cleanup; 1061 } 1062 hr = pCoCreateInstance(&CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, &IID_IShellLinkW, (LPVOID*)&psl); 1063 if (SUCCEEDED(hr)) 1064 { 1065 /* Fill link properties */ 1066 hr = IShellLinkW_SetPath(psl, FullFileName); 1067 if (SUCCEEDED(hr)) 1068 hr = IShellLinkW_SetArguments(psl, L""); 1069 if (SUCCEEDED(hr)) 1070 hr = IShellLinkW_SetWorkingDirectory(psl, FullWorkingDir); 1071 if (SUCCEEDED(hr)) 1072 hr = IShellLinkW_SetIconLocation(psl, FullIconName, IconIdx); 1073 if (SUCCEEDED(hr) && lpHotKey) 1074 FIXME("Need to store hotkey %s in shell link\n", debugstr_w(lpHotKey)); 1075 if (SUCCEEDED(hr) && lpInfoTip) 1076 hr = IShellLinkW_SetDescription(psl, lpInfoTip); 1077 if (SUCCEEDED(hr) && DisplayName) 1078 FIXME("Need to store display name %s, %d in shell link\n", debugstr_w(DisplayName), DisplayResId); 1079 if (SUCCEEDED(hr)) 1080 { 1081 hr = IShellLinkW_QueryInterface(psl, &IID_IPersistFile, (LPVOID*)&ppf); 1082 if (SUCCEEDED(hr)) 1083 { 1084 Required = (MAX_PATH + 1 + 1085 ((LinkSubDir != NULL) ? wcslen(LinkSubDir) : 0) + 1086 ((LinkName != NULL) ? wcslen(LinkName) : 0)) * sizeof(WCHAR); 1087 FullLinkName = MyMalloc(Required); 1088 if (!FullLinkName) 1089 hr = E_OUTOFMEMORY; 1090 else 1091 { 1092 if (LinkAttributes & (FLG_PROFITEM_DELETE | FLG_PROFITEM_GROUP)) 1093 FIXME("Need to handle FLG_PROFITEM_DELETE and FLG_PROFITEM_GROUP\n"); 1094 if (LinkAttributes & FLG_PROFITEM_CSIDL) 1095 CSIDL = LinkFolder; 1096 else if (LinkAttributes & FLG_PROFITEM_CURRENTUSER) 1097 CSIDL = CSIDL_PROGRAMS; 1098 1099 if (SHGetSpecialFolderPathW( 1100 NULL, 1101 FullLinkName, 1102 CSIDL, 1103 TRUE)) 1104 { 1105 if (FullLinkName[wcslen(FullLinkName) - 1] != '\\') 1106 wcscat(FullLinkName, BackSlash); 1107 if (LinkSubDir) 1108 { 1109 wcscat(FullLinkName, LinkSubDir); 1110 if (FullLinkName[wcslen(FullLinkName) - 1] != '\\') 1111 wcscat(FullLinkName, BackSlash); 1112 } 1113 if (LinkName) 1114 { 1115 wcscat(FullLinkName, LinkName); 1116 wcscat(FullLinkName, DotLnk); 1117 } 1118 hr = IPersistFile_Save(ppf, FullLinkName, TRUE); 1119 } 1120 else 1121 hr = HRESULT_FROM_WIN32(GetLastError()); 1122 } 1123 IPersistFile_Release(ppf); 1124 } 1125 } 1126 IShellLinkW_Release(psl); 1127 } 1128 pCoUninitialize(); 1129 if (SUCCEEDED(hr)) 1130 ret = TRUE; 1131 else 1132 { 1133 if (HRESULT_FACILITY(hr) == FACILITY_WIN32) 1134 SetLastError(HRESULT_CODE(hr)); 1135 else 1136 SetLastError(E_FAIL); 1137 } 1138 1139 cleanup: 1140 MyFree(LinkSubDir); 1141 MyFree(LinkName); 1142 MyFree(FileSubDir); 1143 MyFree(SubDirPart); 1144 MyFree(NamePart); 1145 MyFree(FullFileName); 1146 MyFree(FullWorkingDir); 1147 MyFree(FullIconName); 1148 MyFree(FullLinkName); 1149 MyFree(lpHotKey); 1150 MyFree(lpInfoTip); 1151 MyFree(DisplayName); 1152 if (hOle32) 1153 FreeLibrary(hOle32); 1154 1155 TRACE("Returning %d\n", ret); 1156 return ret; 1157 } 1158 1159 static BOOL copy_inf_callback( HINF hinf, PCWSTR field, void *arg ) 1160 { 1161 FIXME( "should do copy inf %s\n", debugstr_w(field) ); 1162 return TRUE; 1163 } 1164 1165 1166 /*********************************************************************** 1167 * iterate_section_fields 1168 * 1169 * Iterate over all fields of a certain key of a certain section 1170 */ 1171 static BOOL iterate_section_fields( HINF hinf, PCWSTR section, PCWSTR key, 1172 iterate_fields_func callback, void *arg ) 1173 { 1174 WCHAR static_buffer[200]; 1175 WCHAR *buffer = static_buffer; 1176 DWORD size = sizeof(static_buffer)/sizeof(WCHAR); 1177 INFCONTEXT context; 1178 BOOL ret = FALSE; 1179 1180 BOOL ok = SetupFindFirstLineW( hinf, section, key, &context ); 1181 while (ok) 1182 { 1183 UINT i, count = SetupGetFieldCount( &context ); 1184 for (i = 1; i <= count; i++) 1185 { 1186 if (!(buffer = get_field_string( &context, i, buffer, static_buffer, &size ))) 1187 goto done; 1188 if (!callback( hinf, buffer, arg )) 1189 { 1190 WARN("callback failed for %s %s err %d\n", 1191 debugstr_w(section), debugstr_w(buffer), GetLastError() ); 1192 goto done; 1193 } 1194 } 1195 ok = SetupFindNextMatchLineW( &context, key, &context ); 1196 } 1197 ret = TRUE; 1198 done: 1199 if (buffer != static_buffer) HeapFree( GetProcessHeap(), 0, buffer ); 1200 return ret; 1201 } 1202 1203 1204 /*********************************************************************** 1205 * SetupInstallFilesFromInfSectionA (SETUPAPI.@) 1206 */ 1207 BOOL WINAPI SetupInstallFilesFromInfSectionA( HINF hinf, HINF hlayout, HSPFILEQ queue, 1208 PCSTR section, PCSTR src_root, UINT flags ) 1209 { 1210 UNICODE_STRING sectionW; 1211 BOOL ret = FALSE; 1212 1213 if (!RtlCreateUnicodeStringFromAsciiz( §ionW, section )) 1214 { 1215 SetLastError( ERROR_NOT_ENOUGH_MEMORY ); 1216 return FALSE; 1217 } 1218 if (!src_root) 1219 ret = SetupInstallFilesFromInfSectionW( hinf, hlayout, queue, sectionW.Buffer, 1220 NULL, flags ); 1221 else 1222 { 1223 UNICODE_STRING srcW; 1224 if (RtlCreateUnicodeStringFromAsciiz( &srcW, src_root )) 1225 { 1226 ret = SetupInstallFilesFromInfSectionW( hinf, hlayout, queue, sectionW.Buffer, 1227 srcW.Buffer, flags ); 1228 RtlFreeUnicodeString( &srcW ); 1229 } 1230 else SetLastError( ERROR_NOT_ENOUGH_MEMORY ); 1231 } 1232 RtlFreeUnicodeString( §ionW ); 1233 return ret; 1234 } 1235 1236 1237 /*********************************************************************** 1238 * SetupInstallFilesFromInfSectionW (SETUPAPI.@) 1239 */ 1240 BOOL WINAPI SetupInstallFilesFromInfSectionW( HINF hinf, HINF hlayout, HSPFILEQ queue, 1241 PCWSTR section, PCWSTR src_root, UINT flags ) 1242 { 1243 struct files_callback_info info; 1244 1245 info.queue = queue; 1246 info.src_root = src_root; 1247 info.copy_flags = flags; 1248 info.layout = hlayout; 1249 return iterate_section_fields( hinf, section, CopyFiles, copy_files_callback, &info ); 1250 } 1251 1252 1253 /*********************************************************************** 1254 * SetupInstallFromInfSectionA (SETUPAPI.@) 1255 */ 1256 BOOL WINAPI SetupInstallFromInfSectionA( HWND owner, HINF hinf, PCSTR section, UINT flags, 1257 HKEY key_root, PCSTR src_root, UINT copy_flags, 1258 PSP_FILE_CALLBACK_A callback, PVOID context, 1259 HDEVINFO devinfo, PSP_DEVINFO_DATA devinfo_data ) 1260 { 1261 UNICODE_STRING sectionW, src_rootW; 1262 struct callback_WtoA_context ctx; 1263 BOOL ret = FALSE; 1264 1265 src_rootW.Buffer = NULL; 1266 if (src_root && !RtlCreateUnicodeStringFromAsciiz( &src_rootW, src_root )) 1267 { 1268 SetLastError( ERROR_NOT_ENOUGH_MEMORY ); 1269 return FALSE; 1270 } 1271 1272 if (RtlCreateUnicodeStringFromAsciiz( §ionW, section )) 1273 { 1274 ctx.orig_context = context; 1275 ctx.orig_handler = callback; 1276 ret = SetupInstallFromInfSectionW( owner, hinf, sectionW.Buffer, flags, key_root, 1277 src_rootW.Buffer, copy_flags, QUEUE_callback_WtoA, 1278 &ctx, devinfo, devinfo_data ); 1279 RtlFreeUnicodeString( §ionW ); 1280 } 1281 else SetLastError( ERROR_NOT_ENOUGH_MEMORY ); 1282 1283 RtlFreeUnicodeString( &src_rootW ); 1284 return ret; 1285 } 1286 1287 1288 /*********************************************************************** 1289 * include_callback 1290 * 1291 * Called once for each Include entry in a given section. 1292 */ 1293 static BOOL include_callback( HINF hinf, PCWSTR field, void *arg ) 1294 { 1295 return SetupOpenAppendInfFileW( field, hinf, NULL ); 1296 } 1297 1298 1299 /*********************************************************************** 1300 * needs_callback 1301 * 1302 * Called once for each Needs entry in a given section. 1303 */ 1304 static BOOL needs_callback( HINF hinf, PCWSTR field, void *arg ) 1305 { 1306 struct needs_callback_info *info = arg; 1307 1308 switch (info->type) 1309 { 1310 case 0: 1311 return SetupInstallFromInfSectionW(info->owner, *(HINF*)hinf, field, info->flags, 1312 info->key_root, info->src_root, info->copy_flags, info->callback, 1313 info->context, info->devinfo, info->devinfo_data); 1314 case 1: 1315 return SetupInstallServicesFromInfSectionExW(*(HINF*)hinf, field, info->flags, 1316 info->devinfo, info->devinfo_data, info->reserved1, info->reserved2); 1317 default: 1318 ERR("Unknown info type %u\n", info->type); 1319 return FALSE; 1320 } 1321 } 1322 1323 1324 /*********************************************************************** 1325 * SetupInstallFromInfSectionW (SETUPAPI.@) 1326 */ 1327 BOOL WINAPI SetupInstallFromInfSectionW( HWND owner, HINF hinf, PCWSTR section, UINT flags, 1328 HKEY key_root, PCWSTR src_root, UINT copy_flags, 1329 PSP_FILE_CALLBACK_W callback, PVOID context, 1330 HDEVINFO devinfo, PSP_DEVINFO_DATA devinfo_data ) 1331 { 1332 struct needs_callback_info needs_info; 1333 1334 /* Parse 'Include' and 'Needs' directives */ 1335 iterate_section_fields( hinf, section, Include, include_callback, NULL); 1336 needs_info.type = 0; 1337 needs_info.owner = owner; 1338 needs_info.flags = flags; 1339 needs_info.key_root = key_root; 1340 needs_info.src_root = src_root; 1341 needs_info.copy_flags = copy_flags; 1342 needs_info.callback = callback; 1343 needs_info.context = context; 1344 needs_info.devinfo = devinfo; 1345 needs_info.devinfo_data = devinfo_data; 1346 iterate_section_fields( hinf, section, Needs, needs_callback, &needs_info); 1347 1348 if (flags & SPINST_FILES) 1349 { 1350 SP_DEVINSTALL_PARAMS_W install_params; 1351 struct files_callback_info info; 1352 HSPFILEQ queue = NULL; 1353 BOOL use_custom_queue; 1354 BOOL ret; 1355 1356 install_params.cbSize = sizeof(SP_DEVINSTALL_PARAMS); 1357 use_custom_queue = SetupDiGetDeviceInstallParamsW(devinfo, devinfo_data, &install_params) && (install_params.Flags & DI_NOVCP); 1358 if (!use_custom_queue && ((queue = SetupOpenFileQueue()) == (HSPFILEQ)INVALID_HANDLE_VALUE )) 1359 return FALSE; 1360 info.queue = use_custom_queue ? install_params.FileQueue : queue; 1361 info.src_root = src_root; 1362 info.copy_flags = copy_flags; 1363 info.layout = hinf; 1364 ret = (iterate_section_fields( hinf, section, CopyFiles, copy_files_callback, &info ) && 1365 iterate_section_fields( hinf, section, DelFiles, delete_files_callback, &info ) && 1366 iterate_section_fields( hinf, section, RenFiles, rename_files_callback, &info )); 1367 if (!use_custom_queue) 1368 { 1369 if (ret) 1370 ret = SetupCommitFileQueueW( owner, queue, callback, context ); 1371 SetupCloseFileQueue( queue ); 1372 } 1373 if (!ret) return FALSE; 1374 } 1375 if (flags & SPINST_INIFILES) 1376 { 1377 if (!iterate_section_fields( hinf, section, UpdateInis, update_ini_callback, NULL ) || 1378 !iterate_section_fields( hinf, section, UpdateIniFields, 1379 update_ini_fields_callback, NULL )) 1380 return FALSE; 1381 } 1382 if (flags & SPINST_INI2REG) 1383 { 1384 if (!iterate_section_fields( hinf, section, Ini2Reg, ini2reg_callback, NULL )) 1385 return FALSE; 1386 } 1387 if (flags & SPINST_LOGCONFIG) 1388 { 1389 if (!iterate_section_fields( hinf, section, LogConf, logconf_callback, NULL )) 1390 return FALSE; 1391 } 1392 if (flags & SPINST_REGSVR) 1393 { 1394 struct register_dll_info info; 1395 1396 info.unregister = FALSE; 1397 if (flags & SPINST_REGISTERCALLBACKAWARE) 1398 { 1399 info.callback = callback; 1400 info.callback_context = context; 1401 } 1402 else info.callback = NULL; 1403 1404 if (!iterate_section_fields( hinf, section, RegisterDlls, register_dlls_callback, &info )) 1405 return FALSE; 1406 1407 #ifdef __WINESRC__ 1408 if (!iterate_section_fields( hinf, section, WineFakeDlls, fake_dlls_callback, NULL )) 1409 return FALSE; 1410 #endif // __WINESRC__ 1411 } 1412 if (flags & SPINST_UNREGSVR) 1413 { 1414 struct register_dll_info info; 1415 1416 info.unregister = TRUE; 1417 if (flags & SPINST_REGISTERCALLBACKAWARE) 1418 { 1419 info.callback = callback; 1420 info.callback_context = context; 1421 } 1422 else info.callback = NULL; 1423 1424 if (!iterate_section_fields( hinf, section, UnregisterDlls, register_dlls_callback, &info )) 1425 return FALSE; 1426 } 1427 if (flags & SPINST_REGISTRY) 1428 { 1429 struct registry_callback_info info; 1430 1431 info.default_root = key_root; 1432 info.delete = TRUE; 1433 if (!iterate_section_fields( hinf, section, DelReg, registry_callback, &info )) 1434 return FALSE; 1435 info.delete = FALSE; 1436 if (!iterate_section_fields( hinf, section, AddReg, registry_callback, &info )) 1437 return FALSE; 1438 } 1439 if (flags & SPINST_BITREG) 1440 { 1441 if (!iterate_section_fields( hinf, section, BitReg, bitreg_callback, NULL )) 1442 return FALSE; 1443 } 1444 if (flags & SPINST_PROFILEITEMS) 1445 { 1446 if (!iterate_section_fields( hinf, section, ProfileItems, profile_items_callback, NULL )) 1447 return FALSE; 1448 } 1449 if (flags & SPINST_COPYINF) 1450 { 1451 if (!iterate_section_fields( hinf, section, CopyINF, copy_inf_callback, NULL )) 1452 return FALSE; 1453 } 1454 1455 return TRUE; 1456 } 1457 1458 1459 /*********************************************************************** 1460 * InstallHinfSectionW (SETUPAPI.@) 1461 * 1462 * NOTE: 'cmdline' is <section> <mode> <path> from 1463 * RUNDLL32.EXE SETUPAPI.DLL,InstallHinfSection <section> <mode> <path> 1464 */ 1465 void WINAPI InstallHinfSectionW( HWND hwnd, HINSTANCE handle, LPCWSTR cmdline, INT show ) 1466 { 1467 BOOL ret = FALSE; 1468 WCHAR *s, *path, section[MAX_PATH]; 1469 void *callback_context = NULL; 1470 DWORD SectionNameLength; 1471 UINT mode; 1472 HINF hinf = INVALID_HANDLE_VALUE; 1473 BOOL bRebootRequired = FALSE; 1474 1475 TRACE("hwnd %p, handle %p, cmdline %s\n", hwnd, handle, debugstr_w(cmdline)); 1476 1477 lstrcpynW( section, cmdline, MAX_PATH ); 1478 1479 if (!(s = strchrW( section, ' ' ))) goto cleanup; 1480 *s++ = 0; 1481 while (*s == ' ') s++; 1482 mode = atoiW( s ); 1483 1484 /* quoted paths are not allowed on native, the rest of the command line is taken as the path */ 1485 if (!(s = strchrW( s, ' ' ))) goto cleanup; 1486 while (*s == ' ') s++; 1487 path = s; 1488 1489 if (mode & 0x80) 1490 { 1491 FIXME("default path of the installation not changed\n"); 1492 mode &= ~0x80; 1493 } 1494 1495 hinf = SetupOpenInfFileW( path, NULL, INF_STYLE_WIN4, NULL ); 1496 if (hinf == INVALID_HANDLE_VALUE) 1497 { 1498 WARN("SetupOpenInfFileW(%s) failed (Error %u)\n", path, GetLastError()); 1499 goto cleanup; 1500 } 1501 1502 ret = SetupDiGetActualSectionToInstallW( 1503 hinf, section, section, sizeof(section)/sizeof(section[0]), &SectionNameLength, NULL ); 1504 if (!ret) 1505 { 1506 WARN("SetupDiGetActualSectionToInstallW() failed (Error %u)\n", GetLastError()); 1507 goto cleanup; 1508 } 1509 if (SectionNameLength > MAX_PATH - strlenW(DotServices)) 1510 { 1511 WARN("Section name '%s' too long\n", section); 1512 goto cleanup; 1513 } 1514 1515 /* Copy files and add registry entries */ 1516 callback_context = SetupInitDefaultQueueCallback( hwnd ); 1517 ret = SetupInstallFromInfSectionW( hwnd, hinf, section, SPINST_ALL, NULL, NULL, 1518 SP_COPY_NEWER | SP_COPY_IN_USE_NEEDS_REBOOT, 1519 SetupDefaultQueueCallbackW, callback_context, 1520 NULL, NULL ); 1521 if (!ret) 1522 { 1523 WARN("SetupInstallFromInfSectionW() failed (Error %u)\n", GetLastError()); 1524 goto cleanup; 1525 } 1526 /* FIXME: need to check if some files were in use and need reboot 1527 * bReboot = ...; 1528 */ 1529 1530 /* Install services */ 1531 wcscat(section, DotServices); 1532 ret = SetupInstallServicesFromInfSectionW( hinf, section, 0 ); 1533 if (!ret && GetLastError() == ERROR_SECTION_NOT_FOUND) 1534 ret = TRUE; 1535 if (!ret) 1536 { 1537 WARN("SetupInstallServicesFromInfSectionW() failed (Error %u)\n", GetLastError()); 1538 goto cleanup; 1539 } 1540 else if (GetLastError() == ERROR_SUCCESS_REBOOT_REQUIRED) 1541 { 1542 bRebootRequired = TRUE; 1543 } 1544 1545 /* Check if we need to reboot */ 1546 switch (mode) 1547 { 1548 case 0: 1549 /* Never reboot */ 1550 break; 1551 case 1: 1552 /* Always reboot */ 1553 ExitWindowsEx(EWX_REBOOT, SHTDN_REASON_MAJOR_APPLICATION | 1554 SHTDN_REASON_MINOR_INSTALLATION | SHTDN_REASON_FLAG_PLANNED); 1555 break; 1556 case 2: 1557 /* Query user before rebooting */ 1558 SetupPromptReboot(NULL, hwnd, FALSE); 1559 break; 1560 case 3: 1561 /* Reboot if necessary */ 1562 if (bRebootRequired) 1563 { 1564 ExitWindowsEx(EWX_REBOOT, SHTDN_REASON_MAJOR_APPLICATION | 1565 SHTDN_REASON_MINOR_INSTALLATION | SHTDN_REASON_FLAG_PLANNED); 1566 } 1567 break; 1568 case 4: 1569 /* If necessary, query user before rebooting */ 1570 if (bRebootRequired) 1571 { 1572 SetupPromptReboot(NULL, hwnd, FALSE); 1573 } 1574 break; 1575 default: 1576 break; 1577 } 1578 1579 cleanup: 1580 if ( callback_context ) 1581 SetupTermDefaultQueueCallback( callback_context ); 1582 if ( hinf != INVALID_HANDLE_VALUE ) 1583 SetupCloseInfFile( hinf ); 1584 1585 #ifdef CORE_11689_IS_FIXED 1586 // TODO: Localize the error string. 1587 if (!ret && !(GlobalSetupFlags & PSPGF_NONINTERACTIVE)) 1588 { 1589 MessageBoxW(hwnd, section, L"setupapi.dll: An error happened...", MB_ICONERROR | MB_OK); 1590 } 1591 #endif 1592 } 1593 1594 1595 /*********************************************************************** 1596 * InstallHinfSectionA (SETUPAPI.@) 1597 */ 1598 void WINAPI InstallHinfSectionA( HWND hwnd, HINSTANCE handle, LPCSTR cmdline, INT show ) 1599 { 1600 UNICODE_STRING cmdlineW; 1601 1602 if (RtlCreateUnicodeStringFromAsciiz( &cmdlineW, cmdline )) 1603 { 1604 InstallHinfSectionW( hwnd, handle, cmdlineW.Buffer, show ); 1605 RtlFreeUnicodeString( &cmdlineW ); 1606 } 1607 } 1608 1609 /*********************************************************************** 1610 * SetupInstallServicesFromInfSectionW (SETUPAPI.@) 1611 */ 1612 BOOL WINAPI SetupInstallServicesFromInfSectionW( HINF Inf, PCWSTR SectionName, DWORD Flags) 1613 { 1614 return SetupInstallServicesFromInfSectionExW( Inf, SectionName, Flags, 1615 NULL, NULL, NULL, NULL ); 1616 } 1617 1618 /*********************************************************************** 1619 * SetupInstallServicesFromInfSectionA (SETUPAPI.@) 1620 */ 1621 BOOL WINAPI SetupInstallServicesFromInfSectionA( HINF Inf, PCSTR SectionName, DWORD Flags) 1622 { 1623 return SetupInstallServicesFromInfSectionExA( Inf, SectionName, Flags, 1624 NULL, NULL, NULL, NULL ); 1625 } 1626 1627 /*********************************************************************** 1628 * SetupInstallServicesFromInfSectionExA (SETUPAPI.@) 1629 */ 1630 BOOL WINAPI SetupInstallServicesFromInfSectionExA( HINF hinf, PCSTR sectionname, DWORD flags, HDEVINFO devinfo, PSP_DEVINFO_DATA devinfo_data, PVOID reserved1, PVOID reserved2 ) 1631 { 1632 UNICODE_STRING sectionnameW; 1633 BOOL ret = FALSE; 1634 1635 if (RtlCreateUnicodeStringFromAsciiz( §ionnameW, sectionname )) 1636 { 1637 ret = SetupInstallServicesFromInfSectionExW( hinf, sectionnameW.Buffer, flags, devinfo, devinfo_data, reserved1, reserved2 ); 1638 RtlFreeUnicodeString( §ionnameW ); 1639 } 1640 else 1641 SetLastError( ERROR_NOT_ENOUGH_MEMORY ); 1642 1643 return ret; 1644 } 1645 1646 1647 static BOOL GetLineText( HINF hinf, PCWSTR section_name, PCWSTR key_name, PWSTR *value) 1648 { 1649 DWORD required; 1650 PWSTR buf = NULL; 1651 1652 *value = NULL; 1653 1654 if (! SetupGetLineTextW( NULL, hinf, section_name, key_name, NULL, 0, &required ) 1655 && GetLastError() != ERROR_INSUFFICIENT_BUFFER ) 1656 return FALSE; 1657 1658 buf = HeapAlloc( GetProcessHeap(), 0, required * sizeof(WCHAR) ); 1659 if ( ! buf ) 1660 { 1661 SetLastError(ERROR_NOT_ENOUGH_MEMORY); 1662 return FALSE; 1663 } 1664 1665 if (! SetupGetLineTextW( NULL, hinf, section_name, key_name, buf, required, &required ) ) 1666 { 1667 HeapFree( GetProcessHeap(), 0, buf ); 1668 return FALSE; 1669 } 1670 1671 *value = buf; 1672 return TRUE; 1673 } 1674 1675 1676 static BOOL GetIntField( HINF hinf, PCWSTR section_name, PCWSTR key_name, INT *value) 1677 { 1678 LPWSTR buffer, end; 1679 INT res; 1680 1681 if (! GetLineText( hinf, section_name, key_name, &buffer ) ) 1682 return FALSE; 1683 1684 res = wcstol( buffer, &end, 0 ); 1685 if (end != buffer && !*end) 1686 { 1687 HeapFree(GetProcessHeap(), 0, buffer); 1688 *value = res; 1689 return TRUE; 1690 } 1691 else 1692 { 1693 HeapFree(GetProcessHeap(), 0, buffer); 1694 SetLastError( ERROR_INVALID_DATA ); 1695 return FALSE; 1696 } 1697 } 1698 1699 1700 BOOL GetStringField( PINFCONTEXT context, DWORD index, PWSTR *value) 1701 { 1702 DWORD RequiredSize; 1703 BOOL ret; 1704 1705 ret = SetupGetStringFieldW( 1706 context, 1707 index, 1708 NULL, 0, 1709 &RequiredSize); 1710 if (!ret) 1711 return FALSE; 1712 else if (RequiredSize == 0) 1713 { 1714 *value = NULL; 1715 return TRUE; 1716 } 1717 1718 /* We got the needed size for the buffer */ 1719 *value = MyMalloc(RequiredSize * sizeof(WCHAR)); 1720 if (!*value) 1721 { 1722 SetLastError(ERROR_NOT_ENOUGH_MEMORY); 1723 return FALSE; 1724 } 1725 ret = SetupGetStringFieldW( 1726 context, 1727 index, 1728 *value, RequiredSize, NULL); 1729 if (!ret) 1730 MyFree(*value); 1731 1732 return ret; 1733 } 1734 1735 static VOID FixupServiceBinaryPath( 1736 IN DWORD ServiceType, 1737 IN OUT LPWSTR *ServiceBinary) 1738 { 1739 LPWSTR Buffer; 1740 WCHAR ReactOSDir[MAX_PATH]; 1741 DWORD RosDirLength, ServiceLength, Win32Length; 1742 1743 GetWindowsDirectoryW(ReactOSDir, MAX_PATH); 1744 RosDirLength = strlenW(ReactOSDir); 1745 ServiceLength = strlenW(*ServiceBinary); 1746 1747 /* Check and fix two things: 1748 1. Get rid of C:\ReactOS and use relative 1749 path instead. 1750 2. Add %SystemRoot% for Win32 services */ 1751 1752 if (ServiceLength < RosDirLength) 1753 return; 1754 1755 if (!wcsnicmp(*ServiceBinary, ReactOSDir, RosDirLength)) 1756 { 1757 /* Yes, the first part is the C:\ReactOS\, just skip it */ 1758 MoveMemory(*ServiceBinary, *ServiceBinary + RosDirLength + 1, 1759 (ServiceLength - RosDirLength) * sizeof(WCHAR)); 1760 1761 /* Handle Win32-services differently */ 1762 if (ServiceType & SERVICE_WIN32) 1763 { 1764 Win32Length = (ServiceLength - RosDirLength) * sizeof(WCHAR) 1765 - sizeof(L'\\') + sizeof(L"%SystemRoot%\\"); 1766 Buffer = MyMalloc(Win32Length); 1767 1768 wcscpy(Buffer, L"%SystemRoot%\\"); 1769 wcscat(Buffer, *ServiceBinary); 1770 MyFree(*ServiceBinary); 1771 1772 *ServiceBinary = Buffer; 1773 } 1774 } 1775 } 1776 1777 static BOOL InstallOneService( 1778 struct DeviceInfoSet *list, 1779 IN HINF hInf, 1780 IN LPCWSTR ServiceSection, 1781 IN LPCWSTR ServiceName, 1782 IN UINT ServiceFlags) 1783 { 1784 SC_HANDLE hSCManager = NULL; 1785 SC_HANDLE hService = NULL; 1786 LPDWORD GroupOrder = NULL; 1787 LPQUERY_SERVICE_CONFIGW ServiceConfig = NULL; 1788 HKEY hServicesKey, hServiceKey; 1789 LONG rc; 1790 BOOL ret = FALSE; 1791 1792 HKEY hGroupOrderListKey = NULL; 1793 LPWSTR ServiceBinary = NULL; 1794 LPWSTR LoadOrderGroup = NULL; 1795 LPWSTR DisplayName = NULL; 1796 LPWSTR Description = NULL; 1797 LPWSTR Dependencies = NULL; 1798 LPWSTR StartName = NULL; 1799 LPWSTR SecurityDescriptor = NULL; 1800 PSECURITY_DESCRIPTOR sd = NULL; 1801 INT ServiceType, StartType, ErrorControl; 1802 DWORD dwRegType; 1803 DWORD tagId = (DWORD)-1; 1804 BOOL useTag; 1805 1806 if (!GetIntField(hInf, ServiceSection, ServiceTypeKey, &ServiceType)) 1807 { 1808 SetLastError( ERROR_BAD_SERVICE_INSTALLSECT ); 1809 goto cleanup; 1810 } 1811 if (!GetIntField(hInf, ServiceSection, StartTypeKey, &StartType)) 1812 { 1813 SetLastError( ERROR_BAD_SERVICE_INSTALLSECT ); 1814 goto cleanup; 1815 } 1816 if (!GetIntField(hInf, ServiceSection, ErrorControlKey, &ErrorControl)) 1817 { 1818 SetLastError( ERROR_BAD_SERVICE_INSTALLSECT ); 1819 goto cleanup; 1820 } 1821 useTag = (ServiceType == SERVICE_BOOT_START || ServiceType == SERVICE_SYSTEM_START); 1822 1823 hSCManager = OpenSCManagerW(NULL, SERVICES_ACTIVE_DATABASE, SC_MANAGER_CREATE_SERVICE); 1824 if (hSCManager == NULL) 1825 goto cleanup; 1826 1827 if (!GetLineText(hInf, ServiceSection, ServiceBinaryKey, &ServiceBinary)) 1828 { 1829 SetLastError( ERROR_BAD_SERVICE_INSTALLSECT ); 1830 goto cleanup; 1831 } 1832 1833 /* Adjust binary path according to the service type */ 1834 FixupServiceBinaryPath(ServiceType, &ServiceBinary); 1835 1836 /* Don't check return value, as these fields are optional and 1837 * GetLineText initialize output parameter even on failure */ 1838 GetLineText(hInf, ServiceSection, LoadOrderGroupKey, &LoadOrderGroup); 1839 GetLineText(hInf, ServiceSection, DisplayNameKey, &DisplayName); 1840 GetLineText(hInf, ServiceSection, DescriptionKey, &Description); 1841 GetLineText(hInf, ServiceSection, DependenciesKey, &Dependencies); 1842 GetLineText(hInf, ServiceSection, StartNameKey, &StartName); 1843 1844 /* If there is no group, we must not request a tag */ 1845 if (!LoadOrderGroup || !*LoadOrderGroup) 1846 useTag = FALSE; 1847 1848 hService = OpenServiceW( 1849 hSCManager, 1850 ServiceName, 1851 DELETE | SERVICE_QUERY_CONFIG | SERVICE_CHANGE_CONFIG | WRITE_DAC); 1852 if (hService == NULL && GetLastError() != ERROR_SERVICE_DOES_NOT_EXIST) 1853 goto cleanup; 1854 1855 if (hService && (ServiceFlags & SPSVCINST_DELETEEVENTLOGENTRY)) 1856 { 1857 ret = DeleteService(hService); 1858 if (!ret && GetLastError() != ERROR_SERVICE_MARKED_FOR_DELETE) 1859 goto cleanup; 1860 } 1861 1862 if (hService == NULL) 1863 { 1864 /* Create new service */ 1865 hService = CreateServiceW( 1866 hSCManager, 1867 ServiceName, 1868 DisplayName, 1869 WRITE_DAC, 1870 ServiceType, 1871 StartType, 1872 ErrorControl, 1873 ServiceBinary, 1874 LoadOrderGroup, 1875 useTag ? &tagId : NULL, 1876 Dependencies, 1877 StartName, 1878 NULL); 1879 if (hService == NULL) 1880 goto cleanup; 1881 } 1882 else 1883 { 1884 DWORD bufferSize; 1885 /* Read current configuration */ 1886 if (!QueryServiceConfigW(hService, NULL, 0, &bufferSize)) 1887 { 1888 if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) 1889 goto cleanup; 1890 ServiceConfig = MyMalloc(bufferSize); 1891 if (!ServiceConfig) 1892 { 1893 SetLastError(ERROR_NOT_ENOUGH_MEMORY); 1894 goto cleanup; 1895 } 1896 if (!QueryServiceConfigW(hService, ServiceConfig, bufferSize, &bufferSize)) 1897 goto cleanup; 1898 } 1899 tagId = ServiceConfig->dwTagId; 1900 1901 /* Update configuration */ 1902 ret = ChangeServiceConfigW( 1903 hService, 1904 ServiceType, 1905 (ServiceFlags & SPSVCINST_NOCLOBBER_STARTTYPE) ? SERVICE_NO_CHANGE : StartType, 1906 (ServiceFlags & SPSVCINST_NOCLOBBER_ERRORCONTROL) ? SERVICE_NO_CHANGE : ErrorControl, 1907 ServiceBinary, 1908 (ServiceFlags & SPSVCINST_NOCLOBBER_LOADORDERGROUP && ServiceConfig->lpLoadOrderGroup) ? NULL : LoadOrderGroup, 1909 useTag ? &tagId : NULL, 1910 (ServiceFlags & SPSVCINST_NOCLOBBER_DEPENDENCIES && ServiceConfig->lpDependencies) ? NULL : Dependencies, 1911 StartName, 1912 NULL, 1913 (ServiceFlags & SPSVCINST_NOCLOBBER_DISPLAYNAME && ServiceConfig->lpDisplayName) ? NULL : DisplayName); 1914 if (!ret) 1915 goto cleanup; 1916 } 1917 1918 /* Set security */ 1919 if (GetLineText(hInf, ServiceSection, SecurityKey, &SecurityDescriptor)) 1920 { 1921 ret = ConvertStringSecurityDescriptorToSecurityDescriptorW(SecurityDescriptor, SDDL_REVISION_1, &sd, NULL); 1922 if (!ret) 1923 goto cleanup; 1924 ret = SetServiceObjectSecurity(hService, DACL_SECURITY_INFORMATION, sd); 1925 if (!ret) 1926 goto cleanup; 1927 } 1928 1929 /* FIXME: use Description and SPSVCINST_NOCLOBBER_DESCRIPTION */ 1930 1931 if (useTag) 1932 { 1933 /* Add the tag to SYSTEM\CurrentControlSet\Control\GroupOrderList key */ 1934 LPCWSTR lpLoadOrderGroup; 1935 DWORD bufferSize; 1936 1937 lpLoadOrderGroup = LoadOrderGroup; 1938 if ((ServiceFlags & SPSVCINST_NOCLOBBER_LOADORDERGROUP) && ServiceConfig && ServiceConfig->lpLoadOrderGroup) 1939 lpLoadOrderGroup = ServiceConfig->lpLoadOrderGroup; 1940 1941 rc = RegOpenKeyW( 1942 list ? list->HKLM : HKEY_LOCAL_MACHINE, 1943 GroupOrderListKey, 1944 &hGroupOrderListKey); 1945 if (rc != ERROR_SUCCESS) 1946 { 1947 SetLastError(rc); 1948 goto cleanup; 1949 } 1950 rc = RegQueryValueExW(hGroupOrderListKey, lpLoadOrderGroup, NULL, &dwRegType, NULL, &bufferSize); 1951 if (rc == ERROR_FILE_NOT_FOUND) 1952 bufferSize = sizeof(DWORD); 1953 else if (rc != ERROR_SUCCESS) 1954 { 1955 SetLastError(rc); 1956 goto cleanup; 1957 } 1958 else if (dwRegType != REG_BINARY || bufferSize == 0 || bufferSize % sizeof(DWORD) != 0) 1959 { 1960 SetLastError(ERROR_GEN_FAILURE); 1961 goto cleanup; 1962 } 1963 /* Allocate buffer to store existing data + the new tag */ 1964 GroupOrder = MyMalloc(bufferSize + sizeof(DWORD)); 1965 if (!GroupOrder) 1966 { 1967 SetLastError(ERROR_NOT_ENOUGH_MEMORY); 1968 goto cleanup; 1969 } 1970 if (rc == ERROR_SUCCESS) 1971 { 1972 /* Read existing data */ 1973 rc = RegQueryValueExW( 1974 hGroupOrderListKey, 1975 lpLoadOrderGroup, 1976 NULL, 1977 NULL, 1978 (BYTE*)GroupOrder, 1979 &bufferSize); 1980 if (rc != ERROR_SUCCESS) 1981 { 1982 SetLastError(rc); 1983 goto cleanup; 1984 } 1985 if (ServiceFlags & SPSVCINST_TAGTOFRONT) 1986 memmove(&GroupOrder[2], &GroupOrder[1], bufferSize - sizeof(DWORD)); 1987 } 1988 else 1989 { 1990 GroupOrder[0] = 0; 1991 } 1992 GroupOrder[0]++; 1993 if (ServiceFlags & SPSVCINST_TAGTOFRONT) 1994 GroupOrder[1] = tagId; 1995 else 1996 GroupOrder[bufferSize / sizeof(DWORD)] = tagId; 1997 1998 rc = RegSetValueExW( 1999 hGroupOrderListKey, 2000 lpLoadOrderGroup, 2001 0, 2002 REG_BINARY, 2003 (BYTE*)GroupOrder, 2004 bufferSize + sizeof(DWORD)); 2005 if (rc != ERROR_SUCCESS) 2006 { 2007 SetLastError(rc); 2008 goto cleanup; 2009 } 2010 } 2011 2012 /* Handle AddReg and DelReg */ 2013 rc = RegOpenKeyExW( 2014 list ? list->HKLM : HKEY_LOCAL_MACHINE, 2015 REGSTR_PATH_SERVICES, 2016 0, 2017 READ_CONTROL, 2018 &hServicesKey); 2019 if (rc != ERROR_SUCCESS) 2020 { 2021 SetLastError(rc); 2022 goto cleanup; 2023 } 2024 rc = RegOpenKeyExW( 2025 hServicesKey, 2026 ServiceName, 2027 0, 2028 KEY_READ | KEY_WRITE, 2029 &hServiceKey); 2030 RegCloseKey(hServicesKey); 2031 if (rc != ERROR_SUCCESS) 2032 { 2033 SetLastError(rc); 2034 goto cleanup; 2035 } 2036 2037 ret = SetupInstallFromInfSectionW( 2038 NULL, 2039 hInf, 2040 ServiceSection, 2041 SPINST_REGISTRY, 2042 hServiceKey, 2043 NULL, 2044 0, 2045 NULL, 2046 NULL, 2047 NULL, 2048 NULL); 2049 RegCloseKey(hServiceKey); 2050 2051 cleanup: 2052 if (hSCManager != NULL) 2053 CloseServiceHandle(hSCManager); 2054 if (hService != NULL) 2055 CloseServiceHandle(hService); 2056 if (hGroupOrderListKey != NULL) 2057 RegCloseKey(hGroupOrderListKey); 2058 if (sd != NULL) 2059 LocalFree(sd); 2060 MyFree(ServiceConfig); 2061 MyFree(ServiceBinary); 2062 MyFree(LoadOrderGroup); 2063 MyFree(DisplayName); 2064 MyFree(Description); 2065 MyFree(Dependencies); 2066 MyFree(SecurityDescriptor); 2067 MyFree(GroupOrder); 2068 MyFree(StartName); 2069 2070 TRACE("Returning %d\n", ret); 2071 return ret; 2072 } 2073 2074 2075 /*********************************************************************** 2076 * SetupInstallServicesFromInfSectionExW (SETUPAPI.@) 2077 */ 2078 BOOL WINAPI SetupInstallServicesFromInfSectionExW( HINF hinf, PCWSTR sectionname, DWORD flags, HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData, PVOID reserved1, PVOID reserved2 ) 2079 { 2080 struct DeviceInfoSet *list = NULL; 2081 BOOL ret = FALSE; 2082 2083 TRACE("%p, %s, 0x%lx, %p, %p, %p, %p\n", hinf, debugstr_w(sectionname), 2084 flags, DeviceInfoSet, DeviceInfoData, reserved1, reserved2); 2085 2086 if (!sectionname) 2087 SetLastError(ERROR_INVALID_PARAMETER); 2088 else if (flags & ~(SPSVCINST_TAGTOFRONT | SPSVCINST_DELETEEVENTLOGENTRY | SPSVCINST_NOCLOBBER_DISPLAYNAME | SPSVCINST_NOCLOBBER_STARTTYPE | SPSVCINST_NOCLOBBER_ERRORCONTROL | SPSVCINST_NOCLOBBER_LOADORDERGROUP | SPSVCINST_NOCLOBBER_DEPENDENCIES | SPSVCINST_STOPSERVICE)) 2089 { 2090 TRACE("Unknown flags: 0x%08lx\n", flags & ~(SPSVCINST_TAGTOFRONT | SPSVCINST_DELETEEVENTLOGENTRY | SPSVCINST_NOCLOBBER_DISPLAYNAME | SPSVCINST_NOCLOBBER_STARTTYPE | SPSVCINST_NOCLOBBER_ERRORCONTROL | SPSVCINST_NOCLOBBER_LOADORDERGROUP | SPSVCINST_NOCLOBBER_DEPENDENCIES | SPSVCINST_STOPSERVICE)); 2091 SetLastError(ERROR_INVALID_FLAGS); 2092 } 2093 else if (DeviceInfoSet == (HDEVINFO)INVALID_HANDLE_VALUE) 2094 SetLastError(ERROR_INVALID_HANDLE); 2095 else if (DeviceInfoSet && (list = (struct DeviceInfoSet *)DeviceInfoSet)->magic != SETUP_DEVICE_INFO_SET_MAGIC) 2096 SetLastError(ERROR_INVALID_HANDLE); 2097 else if (DeviceInfoData && DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA)) 2098 SetLastError(ERROR_INVALID_USER_BUFFER); 2099 else if (reserved1 != NULL || reserved2 != NULL) 2100 SetLastError(ERROR_INVALID_PARAMETER); 2101 else 2102 { 2103 struct needs_callback_info needs_info; 2104 LPWSTR ServiceName = NULL; 2105 LPWSTR ServiceSection = NULL; 2106 INT ServiceFlags; 2107 INFCONTEXT ContextService; 2108 BOOL bNeedReboot = FALSE; 2109 2110 /* Parse 'Include' and 'Needs' directives */ 2111 iterate_section_fields( hinf, sectionname, Include, include_callback, NULL); 2112 needs_info.type = 1; 2113 needs_info.flags = flags; 2114 needs_info.devinfo = DeviceInfoSet; 2115 needs_info.devinfo_data = DeviceInfoData; 2116 needs_info.reserved1 = reserved1; 2117 needs_info.reserved2 = reserved2; 2118 iterate_section_fields( hinf, sectionname, Needs, needs_callback, &needs_info); 2119 2120 if (flags & SPSVCINST_STOPSERVICE) 2121 { 2122 FIXME("Stopping the device not implemented\n"); 2123 /* This may lead to require a reboot */ 2124 /* bNeedReboot = TRUE; */ 2125 #if 0 2126 SERVICE_STATUS ServiceStatus; 2127 ret = ControlService(hService, SERVICE_CONTROL_STOP, &ServiceStatus); 2128 if (!ret && GetLastError() != ERROR_SERVICE_NOT_ACTIVE) 2129 goto done; 2130 if (ServiceStatus.dwCurrentState != SERVICE_STOP_PENDING && ServiceStatus.dwCurrentState != SERVICE_STOPPED) 2131 { 2132 SetLastError(ERROR_INSTALL_SERVICE_FAILURE); 2133 goto done; 2134 } 2135 #endif 2136 flags &= ~SPSVCINST_STOPSERVICE; 2137 } 2138 2139 if (!(ret = SetupFindFirstLineW( hinf, sectionname, NULL, &ContextService ))) 2140 { 2141 SetLastError( ERROR_SECTION_NOT_FOUND ); 2142 goto done; 2143 } 2144 2145 ret = SetupFindFirstLineW(hinf, sectionname, AddService, &ContextService); 2146 while (ret) 2147 { 2148 if (!GetStringField(&ContextService, 1, &ServiceName)) 2149 goto done; 2150 2151 ret = SetupGetIntField( 2152 &ContextService, 2153 2, /* Field index */ 2154 &ServiceFlags); 2155 if (!ret) 2156 { 2157 /* The field may be empty. Ignore the error */ 2158 ServiceFlags = 0; 2159 } 2160 2161 if (!GetStringField(&ContextService, 3, &ServiceSection)) 2162 goto done; 2163 2164 ret = InstallOneService(list, hinf, ServiceSection, ServiceName, (ServiceFlags & ~SPSVCINST_ASSOCSERVICE) | flags); 2165 if (!ret) 2166 goto done; 2167 2168 if (ServiceFlags & SPSVCINST_ASSOCSERVICE) 2169 { 2170 ret = SetupDiSetDeviceRegistryPropertyW(DeviceInfoSet, DeviceInfoData, SPDRP_SERVICE, (LPBYTE)ServiceName, (strlenW(ServiceName) + 1) * sizeof(WCHAR)); 2171 if (!ret) 2172 goto done; 2173 } 2174 2175 HeapFree(GetProcessHeap(), 0, ServiceName); 2176 HeapFree(GetProcessHeap(), 0, ServiceSection); 2177 ServiceName = ServiceSection = NULL; 2178 ret = SetupFindNextMatchLineW(&ContextService, AddService, &ContextService); 2179 } 2180 2181 if (bNeedReboot) 2182 SetLastError(ERROR_SUCCESS_REBOOT_REQUIRED); 2183 else 2184 SetLastError(ERROR_SUCCESS); 2185 ret = TRUE; 2186 } 2187 done: 2188 TRACE("Returning %d\n", ret); 2189 return ret; 2190 } 2191 2192 2193 /*********************************************************************** 2194 * SetupCopyOEMInfA (SETUPAPI.@) 2195 */ 2196 BOOL WINAPI SetupCopyOEMInfA( 2197 IN PCSTR SourceInfFileName, 2198 IN PCSTR OEMSourceMediaLocation, 2199 IN DWORD OEMSourceMediaType, 2200 IN DWORD CopyStyle, 2201 OUT PSTR DestinationInfFileName OPTIONAL, 2202 IN DWORD DestinationInfFileNameSize, 2203 OUT PDWORD RequiredSize OPTIONAL, 2204 OUT PSTR* DestinationInfFileNameComponent OPTIONAL) 2205 { 2206 PWSTR SourceInfFileNameW = NULL; 2207 PWSTR OEMSourceMediaLocationW = NULL; 2208 PWSTR DestinationInfFileNameW = NULL; 2209 PWSTR DestinationInfFileNameComponentW = NULL; 2210 BOOL ret = FALSE; 2211 DWORD size; 2212 2213 TRACE("%s %s 0x%lx 0x%lx %p 0%lu %p %p\n", 2214 SourceInfFileName, OEMSourceMediaLocation, OEMSourceMediaType, 2215 CopyStyle, DestinationInfFileName, DestinationInfFileNameSize, 2216 RequiredSize, DestinationInfFileNameComponent); 2217 2218 if (!DestinationInfFileName && DestinationInfFileNameSize > 0) 2219 SetLastError(ERROR_INVALID_PARAMETER); 2220 else if (!(SourceInfFileNameW = pSetupMultiByteToUnicode(SourceInfFileName, CP_ACP))) 2221 SetLastError(ERROR_INVALID_PARAMETER); 2222 else if (OEMSourceMediaType != SPOST_NONE && !(OEMSourceMediaLocationW = pSetupMultiByteToUnicode(OEMSourceMediaLocation, CP_ACP))) 2223 SetLastError(ERROR_INVALID_PARAMETER); 2224 else 2225 { 2226 if (DestinationInfFileNameSize != 0) 2227 { 2228 DestinationInfFileNameW = MyMalloc(DestinationInfFileNameSize * sizeof(WCHAR)); 2229 if (!DestinationInfFileNameW) 2230 { 2231 SetLastError(ERROR_NOT_ENOUGH_MEMORY); 2232 goto cleanup; 2233 } 2234 } 2235 2236 ret = SetupCopyOEMInfW( 2237 SourceInfFileNameW, 2238 OEMSourceMediaLocationW, 2239 OEMSourceMediaType, 2240 CopyStyle, 2241 DestinationInfFileNameW, 2242 DestinationInfFileNameSize, 2243 &size, 2244 DestinationInfFileNameComponent ? &DestinationInfFileNameComponentW : NULL); 2245 if (!ret) 2246 { 2247 if (RequiredSize) *RequiredSize = size; 2248 goto cleanup; 2249 } 2250 2251 if (DestinationInfFileNameSize != 0) 2252 { 2253 if (WideCharToMultiByte(CP_ACP, 0, DestinationInfFileNameW, -1, 2254 DestinationInfFileName, DestinationInfFileNameSize, NULL, NULL) == 0) 2255 { 2256 DestinationInfFileName[0] = '\0'; 2257 goto cleanup; 2258 } 2259 } 2260 if (DestinationInfFileNameComponent) 2261 { 2262 if (DestinationInfFileNameComponentW) 2263 *DestinationInfFileNameComponent = &DestinationInfFileName[DestinationInfFileNameComponentW - DestinationInfFileNameW]; 2264 else 2265 *DestinationInfFileNameComponent = NULL; 2266 } 2267 ret = TRUE; 2268 } 2269 2270 cleanup: 2271 MyFree(SourceInfFileNameW); 2272 MyFree(OEMSourceMediaLocationW); 2273 MyFree(DestinationInfFileNameW); 2274 TRACE("Returning %d\n", ret); 2275 if (ret) SetLastError(ERROR_SUCCESS); 2276 return ret; 2277 } 2278 2279 static int compare_files( HANDLE file1, HANDLE file2 ) 2280 { 2281 char buffer1[2048]; 2282 char buffer2[2048]; 2283 DWORD size1; 2284 DWORD size2; 2285 2286 while( ReadFile(file1, buffer1, sizeof(buffer1), &size1, NULL) && 2287 ReadFile(file2, buffer2, sizeof(buffer2), &size2, NULL) ) 2288 { 2289 int ret; 2290 if (size1 != size2) 2291 return size1 > size2 ? 1 : -1; 2292 if (!size1) 2293 return 0; 2294 ret = memcmp( buffer1, buffer2, size1 ); 2295 if (ret) 2296 return ret; 2297 } 2298 2299 return 0; 2300 } 2301 2302 /*********************************************************************** 2303 * SetupCopyOEMInfW (SETUPAPI.@) 2304 */ 2305 BOOL WINAPI SetupCopyOEMInfW( 2306 IN PCWSTR SourceInfFileName, 2307 IN PCWSTR OEMSourceMediaLocation, 2308 IN DWORD OEMSourceMediaType, 2309 IN DWORD CopyStyle, 2310 OUT PWSTR DestinationInfFileName OPTIONAL, 2311 IN DWORD DestinationInfFileNameSize, 2312 OUT PDWORD RequiredSize OPTIONAL, 2313 OUT PWSTR* DestinationInfFileNameComponent OPTIONAL) 2314 { 2315 BOOL ret = FALSE; 2316 2317 TRACE("%s %s 0x%lx 0x%lx %p 0%lu %p %p\n", 2318 debugstr_w(SourceInfFileName), debugstr_w(OEMSourceMediaLocation), OEMSourceMediaType, 2319 CopyStyle, DestinationInfFileName, DestinationInfFileNameSize, 2320 RequiredSize, DestinationInfFileNameComponent); 2321 2322 if (!SourceInfFileName) 2323 SetLastError(ERROR_INVALID_PARAMETER); 2324 else if (OEMSourceMediaType != SPOST_NONE && OEMSourceMediaType != SPOST_PATH && OEMSourceMediaType != SPOST_URL) 2325 SetLastError(ERROR_INVALID_PARAMETER); 2326 else if (CopyStyle & ~(SP_COPY_DELETESOURCE | SP_COPY_REPLACEONLY | SP_COPY_NOOVERWRITE | SP_COPY_OEMINF_CATALOG_ONLY)) 2327 { 2328 TRACE("Unknown flags: 0x%08lx\n", CopyStyle & ~(SP_COPY_DELETESOURCE | SP_COPY_REPLACEONLY | SP_COPY_NOOVERWRITE | SP_COPY_OEMINF_CATALOG_ONLY)); 2329 SetLastError(ERROR_INVALID_FLAGS); 2330 } 2331 else if (!DestinationInfFileName && DestinationInfFileNameSize > 0) 2332 SetLastError(ERROR_INVALID_PARAMETER); 2333 else if (CopyStyle & SP_COPY_OEMINF_CATALOG_ONLY) 2334 { 2335 FIXME("CopyStyle 0x%x not supported\n", SP_COPY_OEMINF_CATALOG_ONLY); 2336 SetLastError(ERROR_CALL_NOT_IMPLEMENTED); 2337 } 2338 else 2339 { 2340 HANDLE hSearch = INVALID_HANDLE_VALUE; 2341 WIN32_FIND_DATAW FindFileData; 2342 BOOL AlreadyExists; 2343 DWORD NextFreeNumber = 0; 2344 SIZE_T len; 2345 LPWSTR pFullFileName = NULL; 2346 LPWSTR pFileName; /* Pointer into pFullFileName buffer */ 2347 HANDLE hSourceFile = INVALID_HANDLE_VALUE; 2348 2349 if (OEMSourceMediaType == SPOST_PATH || OEMSourceMediaType == SPOST_URL) 2350 FIXME("OEMSourceMediaType 0x%lx ignored\n", OEMSourceMediaType); 2351 2352 /* Check if source file exists, and open it */ 2353 if (strchrW(SourceInfFileName, '\\' ) || strchrW(SourceInfFileName, '/' )) 2354 { 2355 WCHAR *path; 2356 2357 if (!(len = GetFullPathNameW(SourceInfFileName, 0, NULL, NULL))) 2358 return FALSE; 2359 if (!(path = MyMalloc(len * sizeof(WCHAR)))) 2360 { 2361 SetLastError(ERROR_NOT_ENOUGH_MEMORY); 2362 return FALSE; 2363 } 2364 GetFullPathNameW(SourceInfFileName, len, path, NULL); 2365 hSourceFile = CreateFileW( 2366 path, FILE_READ_DATA | FILE_READ_ATTRIBUTES, 2367 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, 2368 NULL, OPEN_EXISTING, 0, NULL); 2369 MyFree(path); 2370 } 2371 else /* try Windows directory */ 2372 { 2373 WCHAR *path, *p; 2374 static const WCHAR Inf[] = {'\\','i','n','f','\\',0}; 2375 static const WCHAR System32[] = {'\\','s','y','s','t','e','m','3','2','\\',0}; 2376 2377 len = GetWindowsDirectoryW(NULL, 0) + strlenW(SourceInfFileName) + 12; 2378 if (!(path = MyMalloc(len * sizeof(WCHAR)))) 2379 { 2380 SetLastError(ERROR_NOT_ENOUGH_MEMORY); 2381 return FALSE; 2382 } 2383 GetWindowsDirectoryW(path, len); 2384 p = path + strlenW(path); 2385 strcpyW(p, Inf); 2386 strcatW(p, SourceInfFileName); 2387 hSourceFile = CreateFileW( 2388 path, FILE_READ_DATA | FILE_READ_ATTRIBUTES, 2389 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, 2390 NULL, OPEN_EXISTING, 0, NULL); 2391 if (hSourceFile == INVALID_HANDLE_VALUE) 2392 { 2393 strcpyW(p, System32); 2394 strcatW(p, SourceInfFileName); 2395 hSourceFile = CreateFileW( 2396 path, FILE_READ_DATA | FILE_READ_ATTRIBUTES, 2397 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, 2398 NULL, OPEN_EXISTING, 0, NULL); 2399 } 2400 MyFree(path); 2401 } 2402 if (hSourceFile == INVALID_HANDLE_VALUE) 2403 { 2404 SetLastError(ERROR_FILE_NOT_FOUND); 2405 goto cleanup; 2406 } 2407 2408 /* Prepare .inf file specification */ 2409 len = MAX_PATH + 1 + strlenW(InfDirectory) + 13; 2410 pFullFileName = MyMalloc(len * sizeof(WCHAR)); 2411 if (!pFullFileName) 2412 { 2413 SetLastError(ERROR_NOT_ENOUGH_MEMORY); 2414 goto cleanup; 2415 } 2416 len = GetSystemWindowsDirectoryW(pFullFileName, MAX_PATH); 2417 if (len == 0 || len > MAX_PATH) 2418 goto cleanup; 2419 if (pFullFileName[strlenW(pFullFileName) - 1] != '\\') 2420 strcatW(pFullFileName, BackSlash); 2421 strcatW(pFullFileName, InfDirectory); 2422 pFileName = &pFullFileName[strlenW(pFullFileName)]; 2423 2424 /* Search if the specified .inf file already exists in %WINDIR%\Inf */ 2425 AlreadyExists = FALSE; 2426 strcpyW(pFileName, OemFileMask); 2427 hSearch = FindFirstFileW(pFullFileName, &FindFileData); 2428 if (hSearch != INVALID_HANDLE_VALUE) 2429 { 2430 LARGE_INTEGER SourceFileSize; 2431 2432 if (GetFileSizeEx(hSourceFile, &SourceFileSize)) 2433 { 2434 do 2435 { 2436 LARGE_INTEGER DestFileSize; 2437 HANDLE hDestFile; 2438 2439 strcpyW(pFileName, FindFileData.cFileName); 2440 hDestFile = CreateFileW( 2441 pFullFileName, FILE_READ_DATA | FILE_READ_ATTRIBUTES, 2442 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, 2443 NULL, OPEN_EXISTING, 0, NULL); 2444 if (hDestFile != INVALID_HANDLE_VALUE) 2445 { 2446 if (GetFileSizeEx(hDestFile, &DestFileSize) 2447 && DestFileSize.QuadPart == SourceFileSize.QuadPart 2448 && !compare_files(hSourceFile, hDestFile)) 2449 { 2450 TRACE("%s already exists as %s\n", 2451 debugstr_w(SourceInfFileName), debugstr_w(pFileName)); 2452 AlreadyExists = TRUE; 2453 } 2454 } 2455 } while (!AlreadyExists && FindNextFileW(hSearch, &FindFileData)); 2456 } 2457 FindClose(hSearch); 2458 hSearch = INVALID_HANDLE_VALUE; 2459 } 2460 2461 if (!AlreadyExists && CopyStyle & SP_COPY_REPLACEONLY) 2462 { 2463 /* FIXME: set DestinationInfFileName, RequiredSize, DestinationInfFileNameComponent */ 2464 SetLastError(ERROR_FILE_NOT_FOUND); 2465 goto cleanup; 2466 } 2467 else if (AlreadyExists && (CopyStyle & SP_COPY_NOOVERWRITE)) 2468 { 2469 DWORD Size = strlenW(pFileName) + 1; 2470 2471 if (RequiredSize) 2472 *RequiredSize = Size; 2473 if (DestinationInfFileNameSize == 0) 2474 SetLastError(ERROR_FILE_EXISTS); 2475 else if (DestinationInfFileNameSize < Size) 2476 SetLastError(ERROR_INSUFFICIENT_BUFFER); 2477 else 2478 { 2479 SetLastError(ERROR_FILE_EXISTS); 2480 strcpyW(DestinationInfFileName, pFileName); 2481 } 2482 goto cleanup; 2483 } 2484 2485 /* Search the number to give to OEM??.INF */ 2486 strcpyW(pFileName, OemFileMask); 2487 hSearch = FindFirstFileW(pFullFileName, &FindFileData); 2488 if (hSearch == INVALID_HANDLE_VALUE) 2489 { 2490 if (GetLastError() != ERROR_FILE_NOT_FOUND) 2491 goto cleanup; 2492 } 2493 else 2494 { 2495 do 2496 { 2497 DWORD CurrentNumber; 2498 if (swscanf(FindFileData.cFileName, OemFileSpecification, &CurrentNumber) == 1 2499 && CurrentNumber <= 99999) 2500 { 2501 if (CurrentNumber >= NextFreeNumber) 2502 NextFreeNumber = CurrentNumber + 1; 2503 } 2504 } while (FindNextFileW(hSearch, &FindFileData)); 2505 } 2506 2507 if (NextFreeNumber > 99999) 2508 { 2509 ERR("Too much custom .inf files\n"); 2510 SetLastError(ERROR_GEN_FAILURE); 2511 goto cleanup; 2512 } 2513 2514 /* Create the full path: %WINDIR%\Inf\OEM{XXXXX}.inf */ 2515 sprintfW(pFileName, OemFileSpecification, NextFreeNumber); 2516 TRACE("Next available file is %s\n", debugstr_w(pFileName)); 2517 2518 if (!CopyFileW(SourceInfFileName, pFullFileName, TRUE)) 2519 { 2520 TRACE("CopyFileW() failed with error 0x%lx\n", GetLastError()); 2521 goto cleanup; 2522 } 2523 2524 len = strlenW(pFullFileName) + 1; 2525 if (RequiredSize) 2526 *RequiredSize = len; 2527 if (DestinationInfFileName) 2528 { 2529 if (DestinationInfFileNameSize >= len) 2530 { 2531 strcpyW(DestinationInfFileName, pFullFileName); 2532 if (DestinationInfFileNameComponent) 2533 *DestinationInfFileNameComponent = &DestinationInfFileName[pFileName - pFullFileName]; 2534 } 2535 else 2536 { 2537 SetLastError(ERROR_INSUFFICIENT_BUFFER); 2538 goto cleanup; 2539 } 2540 } 2541 2542 if (CopyStyle & SP_COPY_DELETESOURCE) 2543 { 2544 if (!DeleteFileW(SourceInfFileName)) 2545 { 2546 TRACE("DeleteFileW() failed with error 0x%lx\n", GetLastError()); 2547 goto cleanup; 2548 } 2549 } 2550 2551 ret = TRUE; 2552 2553 cleanup: 2554 if (hSourceFile != INVALID_HANDLE_VALUE) 2555 CloseHandle(hSourceFile); 2556 if (hSearch != INVALID_HANDLE_VALUE) 2557 FindClose(hSearch); 2558 MyFree(pFullFileName); 2559 } 2560 2561 TRACE("Returning %d\n", ret); 2562 if (ret) SetLastError(ERROR_SUCCESS); 2563 return ret; 2564 } 2565