git.oblomov.eu Git - wine/blob - dlls/setupapi/install.c

   1 /*
   2  * Setupapi install routines
   3  *
   4  * Copyright 2002 Alexandre Julliard for CodeWeavers
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <stdarg.h>
  22
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "winreg.h"
  26 #include "winternl.h"
  27 #include "winerror.h"
  28 #include "wingdi.h"
  29 #include "winuser.h"
  30 #include "winnls.h"
  31 #include "winsvc.h"
  32 #include "setupapi.h"
  33 #include "setupapi_private.h"
  34 #include "wine/unicode.h"
  35 #include "wine/debug.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(setupapi);
  38
  39 /* info passed to callback functions dealing with files */
  40 struct files_callback_info
  41 {
  42     HSPFILEQ queue;
  43     PCWSTR   src_root;
  44     UINT     copy_flags;
  45     HINF     layout;
  46 };
  47
  48 /* info passed to callback functions dealing with the registry */
  49 struct registry_callback_info
  50 {
  51     HKEY default_root;
  52     BOOL delete;
  53 };
  54
  55 /* info passed to callback functions dealing with registering dlls */
  56 struct register_dll_info
  57 {
  58     PSP_FILE_CALLBACK_W callback;
  59     PVOID               callback_context;
  60     BOOL                unregister;
  61 };
  62
  63 typedef BOOL (*iterate_fields_func)( HINF hinf, PCWSTR field, void *arg );
  64
  65 /* Unicode constants */
  66 static const WCHAR CopyFiles[]  = {'C','o','p','y','F','i','l','e','s',0};
  67 static const WCHAR DelFiles[]   = {'D','e','l','F','i','l','e','s',0};
  68 static const WCHAR RenFiles[]   = {'R','e','n','F','i','l','e','s',0};
  69 static const WCHAR Ini2Reg[]    = {'I','n','i','2','R','e','g',0};
  70 static const WCHAR LogConf[]    = {'L','o','g','C','o','n','f',0};
  71 static const WCHAR AddReg[]     = {'A','d','d','R','e','g',0};
  72 static const WCHAR DelReg[]     = {'D','e','l','R','e','g',0};
  73 static const WCHAR BitReg[]     = {'B','i','t','R','e','g',0};
  74 static const WCHAR UpdateInis[] = {'U','p','d','a','t','e','I','n','i','s',0};
  75 static const WCHAR CopyINF[]    = {'C','o','p','y','I','N','F',0};
  76 static const WCHAR AddService[] = {'A','d','d','S','e','r','v','i','c','e',0};
  77 static const WCHAR DelService[] = {'D','e','l','S','e','r','v','i','c','e',0};
  78 static const WCHAR UpdateIniFields[] = {'U','p','d','a','t','e','I','n','i','F','i','e','l','d','s',0};
  79 static const WCHAR RegisterDlls[]    = {'R','e','g','i','s','t','e','r','D','l','l','s',0};
  80 static const WCHAR UnregisterDlls[]  = {'U','n','r','e','g','i','s','t','e','r','D','l','l','s',0};
  81 static const WCHAR ProfileItems[]    = {'P','r','o','f','i','l','e','I','t','e','m','s',0};
  82 static const WCHAR WineFakeDlls[]    = {'W','i','n','e','F','a','k','e','D','l','l','s',0};
  83 static const WCHAR DisplayName[]     = {'D','i','s','p','l','a','y','N','a','m','e',0};
  84 static const WCHAR Description[]     = {'D','e','s','c','r','i','p','t','i','o','n',0};
  85 static const WCHAR ServiceBinary[]   = {'S','e','r','v','i','c','e','B','i','n','a','r','y',0};
  86 static const WCHAR StartName[]       = {'S','t','a','r','t','N','a','m','e',0};
  87 static const WCHAR LoadOrderGroup[]  = {'L','o','a','d','O','r','d','e','r','G','r','o','u','p',0};
  88 static const WCHAR ServiceType[]     = {'S','e','r','v','i','c','e','T','y','p','e',0};
  89 static const WCHAR StartType[]       = {'S','t','a','r','t','T','y','p','e',0};
  90 static const WCHAR ErrorControl[]    = {'E','r','r','o','r','C','o','n','t','r','o','l',0};
  91
  92 static const WCHAR ServicesKey[] = {'S','y','s','t','e','m','\\',
  93                         'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
  94                         'S','e','r','v','i','c','e','s',0};
  95
  96 /***********************************************************************
  97  *            get_field_string
  98  *
  99  * Retrieve the contents of a field, dynamically growing the buffer if necessary.
 100  */
 101 static WCHAR *get_field_string( INFCONTEXT *context, DWORD index, WCHAR *buffer,
 102                                 WCHAR *static_buffer, DWORD *size )
 103 {
 104     DWORD required;
 105
 106     if (SetupGetStringFieldW( context, index, buffer, *size, &required )) return buffer;
 107     if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
 108     {
 109         /* now grow the buffer */
 110         if (buffer != static_buffer) HeapFree( GetProcessHeap(), 0, buffer );
 111         if (!(buffer = HeapAlloc( GetProcessHeap(), 0, required*sizeof(WCHAR) ))) return NULL;
 112         *size = required;
 113         if (SetupGetStringFieldW( context, index, buffer, *size, &required )) return buffer;
 114     }
 115     if (buffer != static_buffer) HeapFree( GetProcessHeap(), 0, buffer );
 116     return NULL;
 117 }
 118
 119
 120 /***********************************************************************
 121  *            dup_section_line_field
 122  *
 123  * Retrieve the contents of a field in a newly-allocated buffer.
 124  */
 125 static WCHAR *dup_section_line_field( HINF hinf, const WCHAR *section, const WCHAR *line, DWORD index )
 126 {
 127     INFCONTEXT context;
 128     DWORD size;
 129     WCHAR *buffer;
 130
 131     if (!SetupFindFirstLineW( hinf, section, line, &context )) return NULL;
 132     if (!SetupGetStringFieldW( &context, index, NULL, 0, &size )) return NULL;
 133     if (!(buffer = HeapAlloc( GetProcessHeap(), 0, size * sizeof(WCHAR) ))) return NULL;
 134     if (!SetupGetStringFieldW( &context, index, buffer, size, NULL )) buffer[0] = 0;
 135     return buffer;
 136 }
 137
 138 /***********************************************************************
 139  *            copy_files_callback
 140  *
 141  * Called once for each CopyFiles entry in a given section.
 142  */
 143 static BOOL copy_files_callback( HINF hinf, PCWSTR field, void *arg )
 144 {
 145     struct files_callback_info *info = arg;
 146
 147     if (field[0] == '@')  /* special case: copy single file */
 148         SetupQueueDefaultCopyW( info->queue, info->layout ? info->layout : hinf, info->src_root, NULL, field+1, info->copy_flags );
 149     else
 150         SetupQueueCopySectionW( info->queue, info->src_root, info->layout ? info->layout : hinf, hinf, field, info->copy_flags );
 151     return TRUE;
 152 }
 153
 154
 155 /***********************************************************************
 156  *            delete_files_callback
 157  *
 158  * Called once for each DelFiles entry in a given section.
 159  */
 160 static BOOL delete_files_callback( HINF hinf, PCWSTR field, void *arg )
 161 {
 162     struct files_callback_info *info = arg;
 163     SetupQueueDeleteSectionW( info->queue, hinf, 0, field );
 164     return TRUE;
 165 }
 166
 167
 168 /***********************************************************************
 169  *            rename_files_callback
 170  *
 171  * Called once for each RenFiles entry in a given section.
 172  */
 173 static BOOL rename_files_callback( HINF hinf, PCWSTR field, void *arg )
 174 {
 175     struct files_callback_info *info = arg;
 176     SetupQueueRenameSectionW( info->queue, hinf, 0, field );
 177     return TRUE;
 178 }
 179
 180
 181 /***********************************************************************
 182  *            get_root_key
 183  *
 184  * Retrieve the registry root key from its name.
 185  */
 186 static HKEY get_root_key( const WCHAR *name, HKEY def_root )
 187 {
 188     static const WCHAR HKCR[] = {'H','K','C','R',0};
 189     static const WCHAR HKCU[] = {'H','K','C','U',0};
 190     static const WCHAR HKLM[] = {'H','K','L','M',0};
 191     static const WCHAR HKU[]  = {'H','K','U',0};
 192     static const WCHAR HKR[]  = {'H','K','R',0};
 193
 194     if (!strcmpiW( name, HKCR )) return HKEY_CLASSES_ROOT;
 195     if (!strcmpiW( name, HKCU )) return HKEY_CURRENT_USER;
 196     if (!strcmpiW( name, HKLM )) return HKEY_LOCAL_MACHINE;
 197     if (!strcmpiW( name, HKU )) return HKEY_USERS;
 198     if (!strcmpiW( name, HKR )) return def_root;
 199     return 0;
 200 }
 201
 202
 203 /***********************************************************************
 204  *            append_multi_sz_value
 205  *
 206  * Append a multisz string to a multisz registry value.
 207  */
 208 static void append_multi_sz_value( HKEY hkey, const WCHAR *value, const WCHAR *strings,
 209                                    DWORD str_size )
 210 {
 211     DWORD size, type, total;
 212     WCHAR *buffer, *p;
 213
 214     if (RegQueryValueExW( hkey, value, NULL, &type, NULL, &size )) return;
 215     if (type != REG_MULTI_SZ) return;
 216
 217     if (!(buffer = HeapAlloc( GetProcessHeap(), 0, (size + str_size) * sizeof(WCHAR) ))) return;
 218     if (RegQueryValueExW( hkey, value, NULL, NULL, (BYTE *)buffer, &size )) goto done;
 219
 220     /* compare each string against all the existing ones */
 221     total = size;
 222     while (*strings)
 223     {
 224         int len = strlenW(strings) + 1;
 225
 226         for (p = buffer; *p; p += strlenW(p) + 1)
 227             if (!strcmpiW( p, strings )) break;
 228
 229         if (!*p)  /* not found, need to append it */
 230         {
 231             memcpy( p, strings, len * sizeof(WCHAR) );
 232             p[len] = 0;
 233             total += len;
 234         }
 235         strings += len;
 236     }
 237     if (total != size)
 238     {
 239         TRACE( "setting value %s to %s\n", debugstr_w(value), debugstr_w(buffer) );
 240         RegSetValueExW( hkey, value, 0, REG_MULTI_SZ, (BYTE *)buffer, total );
 241     }
 242  done:
 243     HeapFree( GetProcessHeap(), 0, buffer );
 244 }
 245
 246
 247 /***********************************************************************
 248  *            delete_multi_sz_value
 249  *
 250  * Remove a string from a multisz registry value.
 251  */
 252 static void delete_multi_sz_value( HKEY hkey, const WCHAR *value, const WCHAR *string )
 253 {
 254     DWORD size, type;
 255     WCHAR *buffer, *src, *dst;
 256
 257     if (RegQueryValueExW( hkey, value, NULL, &type, NULL, &size )) return;
 258     if (type != REG_MULTI_SZ) return;
 259     /* allocate double the size, one for value before and one for after */
 260     if (!(buffer = HeapAlloc( GetProcessHeap(), 0, size * 2 * sizeof(WCHAR) ))) return;
 261     if (RegQueryValueExW( hkey, value, NULL, NULL, (BYTE *)buffer, &size )) goto done;
 262     src = buffer;
 263     dst = buffer + size;
 264     while (*src)
 265     {
 266         int len = strlenW(src) + 1;
 267         if (strcmpiW( src, string ))
 268         {
 269             memcpy( dst, src, len * sizeof(WCHAR) );
 270             dst += len;
 271         }
 272         src += len;
 273     }
 274     *dst++ = 0;
 275     if (dst != buffer + 2*size)  /* did we remove something? */
 276     {
 277         TRACE( "setting value %s to %s\n", debugstr_w(value), debugstr_w(buffer + size) );
 278         RegSetValueExW( hkey, value, 0, REG_MULTI_SZ,
 279                         (BYTE *)(buffer + size), dst - (buffer + size) );
 280     }
 281  done:
 282     HeapFree( GetProcessHeap(), 0, buffer );
 283 }
 284
 285
 286 /***********************************************************************
 287  *            do_reg_operation
 288  *
 289  * Perform an add/delete registry operation depending on the flags.
 290  */
 291 static BOOL do_reg_operation( HKEY hkey, const WCHAR *value, INFCONTEXT *context, INT flags )
 292 {
 293     DWORD type, size;
 294
 295     if (flags & (FLG_ADDREG_DELREG_BIT | FLG_ADDREG_DELVAL))  /* deletion */
 296     {
 297         if (*value && !(flags & FLG_DELREG_KEYONLY_COMMON))
 298         {
 299             if ((flags & FLG_DELREG_MULTI_SZ_DELSTRING) == FLG_DELREG_MULTI_SZ_DELSTRING)
 300             {
 301                 WCHAR *str;
 302
 303                 if (!SetupGetStringFieldW( context, 5, NULL, 0, &size ) || !size) return TRUE;
 304                 if (!(str = HeapAlloc( GetProcessHeap(), 0, size * sizeof(WCHAR) ))) return FALSE;
 305                 SetupGetStringFieldW( context, 5, str, size, NULL );
 306                 delete_multi_sz_value( hkey, value, str );
 307                 HeapFree( GetProcessHeap(), 0, str );
 308             }
 309             else RegDeleteValueW( hkey, value );
 310         }
 311         else NtDeleteKey( hkey );
 312         return TRUE;
 313     }
 314
 315     if (flags & (FLG_ADDREG_KEYONLY|FLG_ADDREG_KEYONLY_COMMON)) return TRUE;
 316
 317     if (flags & (FLG_ADDREG_NOCLOBBER|FLG_ADDREG_OVERWRITEONLY))
 318     {
 319         BOOL exists = !RegQueryValueExW( hkey, value, NULL, NULL, NULL, NULL );
 320         if (exists && (flags & FLG_ADDREG_NOCLOBBER)) return TRUE;
 321         if (!exists && (flags & FLG_ADDREG_OVERWRITEONLY)) return TRUE;
 322     }
 323
 324     switch(flags & FLG_ADDREG_TYPE_MASK)
 325     {
 326     case FLG_ADDREG_TYPE_SZ:        type = REG_SZ; break;
 327     case FLG_ADDREG_TYPE_MULTI_SZ:  type = REG_MULTI_SZ; break;
 328     case FLG_ADDREG_TYPE_EXPAND_SZ: type = REG_EXPAND_SZ; break;
 329     case FLG_ADDREG_TYPE_BINARY:    type = REG_BINARY; break;
 330     case FLG_ADDREG_TYPE_DWORD:     type = REG_DWORD; break;
 331     case FLG_ADDREG_TYPE_NONE:      type = REG_NONE; break;
 332     default:                        type = flags >> 16; break;
 333     }
 334
 335     if (!(flags & FLG_ADDREG_BINVALUETYPE) ||
 336         (type == REG_DWORD && SetupGetFieldCount(context) == 5))
 337     {
 338         static const WCHAR empty;
 339         WCHAR *str = NULL;
 340
 341         if (type == REG_MULTI_SZ)
 342         {
 343             if (!SetupGetMultiSzFieldW( context, 5, NULL, 0, &size )) size = 0;
 344             if (size)
 345             {
 346                 if (!(str = HeapAlloc( GetProcessHeap(), 0, size * sizeof(WCHAR) ))) return FALSE;
 347                 SetupGetMultiSzFieldW( context, 5, str, size, NULL );
 348             }
 349             if (flags & FLG_ADDREG_APPEND)
 350             {
 351                 if (!str) return TRUE;
 352                 append_multi_sz_value( hkey, value, str, size );
 353                 HeapFree( GetProcessHeap(), 0, str );
 354                 return TRUE;
 355             }
 356             /* else fall through to normal string handling */
 357         }
 358         else
 359         {
 360             if (!SetupGetStringFieldW( context, 5, NULL, 0, &size )) size = 0;
 361             if (size)
 362             {
 363                 if (!(str = HeapAlloc( GetProcessHeap(), 0, size * sizeof(WCHAR) ))) return FALSE;
 364                 SetupGetStringFieldW( context, 5, str, size, NULL );
 365             }
 366         }
 367
 368         if (type == REG_DWORD)
 369         {
 370             DWORD dw = str ? strtoulW( str, NULL, 0 ) : 0;
 371             TRACE( "setting dword %s to %x\n", debugstr_w(value), dw );
 372             RegSetValueExW( hkey, value, 0, type, (BYTE *)&dw, sizeof(dw) );
 373         }
 374         else
 375         {
 376             TRACE( "setting value %s to %s\n", debugstr_w(value), debugstr_w(str) );
 377             if (str) RegSetValueExW( hkey, value, 0, type, (BYTE *)str, size * sizeof(WCHAR) );
 378             else RegSetValueExW( hkey, value, 0, type, (const BYTE *)&empty, sizeof(WCHAR) );
 379         }
 380         HeapFree( GetProcessHeap(), 0, str );
 381         return TRUE;
 382     }
 383     else  /* get the binary data */
 384     {
 385         BYTE *data = NULL;
 386
 387         if (!SetupGetBinaryField( context, 5, NULL, 0, &size )) size = 0;
 388         if (size)
 389         {
 390             if (!(data = HeapAlloc( GetProcessHeap(), 0, size ))) return FALSE;
 391             TRACE( "setting binary data %s len %d\n", debugstr_w(value), size );
 392             SetupGetBinaryField( context, 5, data, size, NULL );
 393         }
 394         RegSetValueExW( hkey, value, 0, type, data, size );
 395         HeapFree( GetProcessHeap(), 0, data );
 396         return TRUE;
 397     }
 398 }
 399
 400
 401 /***********************************************************************
 402  *            registry_callback
 403  *
 404  * Called once for each AddReg and DelReg entry in a given section.
 405  */
 406 static BOOL registry_callback( HINF hinf, PCWSTR field, void *arg )
 407 {
 408     struct registry_callback_info *info = arg;
 409     INFCONTEXT context;
 410     HKEY root_key, hkey;
 411
 412     BOOL ok = SetupFindFirstLineW( hinf, field, NULL, &context );
 413
 414     for (; ok; ok = SetupFindNextLine( &context, &context ))
 415     {
 416         WCHAR buffer[MAX_INF_STRING_LENGTH];
 417         INT flags;
 418
 419         /* get root */
 420         if (!SetupGetStringFieldW( &context, 1, buffer, sizeof(buffer)/sizeof(WCHAR), NULL ))
 421             continue;
 422         if (!(root_key = get_root_key( buffer, info->default_root )))
 423             continue;
 424
 425         /* get key */
 426         if (!SetupGetStringFieldW( &context, 2, buffer, sizeof(buffer)/sizeof(WCHAR), NULL ))
 427             *buffer = 0;
 428
 429         /* get flags */
 430         if (!SetupGetIntField( &context, 4, &flags )) flags = 0;
 431
 432         if (!info->delete)
 433         {
 434             if (flags & FLG_ADDREG_DELREG_BIT) continue;  /* ignore this entry */
 435         }
 436         else
 437         {
 438             if (!flags) flags = FLG_ADDREG_DELREG_BIT;
 439             else if (!(flags & FLG_ADDREG_DELREG_BIT)) continue;  /* ignore this entry */
 440         }
 441
 442         if (info->delete || (flags & FLG_ADDREG_OVERWRITEONLY))
 443         {
 444             if (RegOpenKeyW( root_key, buffer, &hkey )) continue;  /* ignore if it doesn't exist */
 445         }
 446         else if (RegCreateKeyW( root_key, buffer, &hkey ))
 447         {
 448             ERR( "could not create key %p %s\n", root_key, debugstr_w(buffer) );
 449             continue;
 450         }
 451         TRACE( "key %p %s\n", root_key, debugstr_w(buffer) );
 452
 453         /* get value name */
 454         if (!SetupGetStringFieldW( &context, 3, buffer, sizeof(buffer)/sizeof(WCHAR), NULL ))
 455             *buffer = 0;
 456
 457         /* and now do it */
 458         if (!do_reg_operation( hkey, buffer, &context, flags ))
 459         {
 460             RegCloseKey( hkey );
 461             return FALSE;
 462         }
 463         RegCloseKey( hkey );
 464     }
 465     return TRUE;
 466 }
 467
 468
 469 /***********************************************************************
 470  *            do_register_dll
 471  *
 472  * Register or unregister a dll.
 473  */
 474 static BOOL do_register_dll( const struct register_dll_info *info, const WCHAR *path,
 475                              INT flags, INT timeout, const WCHAR *args )
 476 {
 477     HMODULE module;
 478     HRESULT res;
 479     SP_REGISTER_CONTROL_STATUSW status;
 480     IMAGE_NT_HEADERS *nt;
 481
 482     status.cbSize = sizeof(status);
 483     status.FileName = path;
 484     status.FailureCode = SPREG_SUCCESS;
 485     status.Win32Error = ERROR_SUCCESS;
 486
 487     if (info->callback)
 488     {
 489         switch(info->callback( info->callback_context, SPFILENOTIFY_STARTREGISTRATION,
 490                                (UINT_PTR)&status, !info->unregister ))
 491         {
 492         case FILEOP_ABORT:
 493             SetLastError( ERROR_OPERATION_ABORTED );
 494             return FALSE;
 495         case FILEOP_SKIP:
 496             return TRUE;
 497         case FILEOP_DOIT:
 498             break;
 499         }
 500     }
 501
 502     if (!(module = LoadLibraryExW( path, 0, LOAD_WITH_ALTERED_SEARCH_PATH )))
 503     {
 504         WARN( "could not load %s\n", debugstr_w(path) );
 505         status.FailureCode = SPREG_LOADLIBRARY;
 506         status.Win32Error = GetLastError();
 507         goto done;
 508     }
 509
 510     if ((nt = RtlImageNtHeader( module )) && !(nt->FileHeader.Characteristics & IMAGE_FILE_DLL))
 511     {
 512         /* file is an executable, not a dll */
 513         STARTUPINFOW startup;
 514         PROCESS_INFORMATION info;
 515         WCHAR *cmd_line;
 516         BOOL res;
 517         static const WCHAR format[] = {'"','%','s','"',' ','%','s',0};
 518         static const WCHAR default_args[] = {'/','R','e','g','S','e','r','v','e','r',0};
 519
 520         FreeLibrary( module );
 521         module = NULL;
 522         if (!args) args = default_args;
 523         cmd_line = HeapAlloc( GetProcessHeap(), 0, (strlenW(path) + strlenW(args) + 4) * sizeof(WCHAR) );
 524         sprintfW( cmd_line, format, path, args );
 525         memset( &startup, 0, sizeof(startup) );
 526         startup.cb = sizeof(startup);
 527         TRACE( "executing %s\n", debugstr_w(cmd_line) );
 528         res = CreateProcessW( NULL, cmd_line, NULL, NULL, FALSE, 0, NULL, NULL, &startup, &info );
 529         HeapFree( GetProcessHeap(), 0, cmd_line );
 530         if (!res)
 531         {
 532             status.FailureCode = SPREG_LOADLIBRARY;
 533             status.Win32Error = GetLastError();
 534             goto done;
 535         }
 536         CloseHandle( info.hThread );
 537
 538         if (WaitForSingleObject( info.hProcess, timeout*1000 ) == WAIT_TIMEOUT)
 539         {
 540             /* timed out, kill the process */
 541             TerminateProcess( info.hProcess, 1 );
 542             status.FailureCode = SPREG_TIMEOUT;
 543             status.Win32Error = ERROR_TIMEOUT;
 544         }
 545         CloseHandle( info.hProcess );
 546         goto done;
 547     }
 548
 549     if (flags & FLG_REGSVR_DLLREGISTER)
 550     {
 551         const char *entry_point = info->unregister ? "DllUnregisterServer" : "DllRegisterServer";
 552         HRESULT (WINAPI *func)(void) = (void *)GetProcAddress( module, entry_point );
 553
 554         if (!func)
 555         {
 556             status.FailureCode = SPREG_GETPROCADDR;
 557             status.Win32Error = GetLastError();
 558             goto done;
 559         }
 560
 561         TRACE( "calling %s in %s\n", entry_point, debugstr_w(path) );
 562         res = func();
 563
 564         if (FAILED(res))
 565         {
 566             WARN( "calling %s in %s returned error %x\n", entry_point, debugstr_w(path), res );
 567             status.FailureCode = SPREG_REGSVR;
 568             status.Win32Error = res;
 569             goto done;
 570         }
 571     }
 572
 573     if (flags & FLG_REGSVR_DLLINSTALL)
 574     {
 575         HRESULT (WINAPI *func)(BOOL,LPCWSTR) = (void *)GetProcAddress( module, "DllInstall" );
 576
 577         if (!func)
 578         {
 579             status.FailureCode = SPREG_GETPROCADDR;
 580             status.Win32Error = GetLastError();
 581             goto done;
 582         }
 583
 584         TRACE( "calling DllInstall(%d,%s) in %s\n",
 585                !info->unregister, debugstr_w(args), debugstr_w(path) );
 586         res = func( !info->unregister, args );
 587
 588         if (FAILED(res))
 589         {
 590             WARN( "calling DllInstall in %s returned error %x\n", debugstr_w(path), res );
 591             status.FailureCode = SPREG_REGSVR;
 592             status.Win32Error = res;
 593             goto done;
 594         }
 595     }
 596
 597 done:
 598     if (module) FreeLibrary( module );
 599     if (info->callback) info->callback( info->callback_context, SPFILENOTIFY_ENDREGISTRATION,
 600                                         (UINT_PTR)&status, !info->unregister );
 601     return TRUE;
 602 }
 603
 604
 605 /***********************************************************************
 606  *            register_dlls_callback
 607  *
 608  * Called once for each RegisterDlls entry in a given section.
 609  */
 610 static BOOL register_dlls_callback( HINF hinf, PCWSTR field, void *arg )
 611 {
 612     struct register_dll_info *info = arg;
 613     INFCONTEXT context;
 614     BOOL ret = TRUE;
 615     BOOL ok = SetupFindFirstLineW( hinf, field, NULL, &context );
 616
 617     for (; ok; ok = SetupFindNextLine( &context, &context ))
 618     {
 619         WCHAR *path, *args, *p;
 620         WCHAR buffer[MAX_INF_STRING_LENGTH];
 621         INT flags, timeout;
 622
 623         /* get directory */
 624         if (!(path = PARSER_get_dest_dir( &context ))) continue;
 625
 626         /* get dll name */
 627         if (!SetupGetStringFieldW( &context, 3, buffer, sizeof(buffer)/sizeof(WCHAR), NULL ))
 628             goto done;
 629         if (!(p = HeapReAlloc( GetProcessHeap(), 0, path,
 630                                (strlenW(path) + strlenW(buffer) + 2) * sizeof(WCHAR) ))) goto done;
 631         path = p;
 632         p += strlenW(p);
 633         if (p == path || p[-1] != '\\') *p++ = '\\';
 634         strcpyW( p, buffer );
 635
 636         /* get flags */
 637         if (!SetupGetIntField( &context, 4, &flags )) flags = 0;
 638
 639         /* get timeout */
 640         if (!SetupGetIntField( &context, 5, &timeout )) timeout = 60;
 641
 642         /* get command line */
 643         args = NULL;
 644         if (SetupGetStringFieldW( &context, 6, buffer, sizeof(buffer)/sizeof(WCHAR), NULL ))
 645             args = buffer;
 646
 647         ret = do_register_dll( info, path, flags, timeout, args );
 648
 649     done:
 650         HeapFree( GetProcessHeap(), 0, path );
 651         if (!ret) break;
 652     }
 653     return ret;
 654 }
 655
 656 /***********************************************************************
 657  *            fake_dlls_callback
 658  *
 659  * Called once for each WineFakeDlls entry in a given section.
 660  */
 661 static BOOL fake_dlls_callback( HINF hinf, PCWSTR field, void *arg )
 662 {
 663     INFCONTEXT context;
 664     BOOL ret = TRUE;
 665     BOOL ok = SetupFindFirstLineW( hinf, field, NULL, &context );
 666
 667     for (; ok; ok = SetupFindNextLine( &context, &context ))
 668     {
 669         WCHAR *path, *p;
 670         WCHAR buffer[MAX_INF_STRING_LENGTH];
 671
 672         /* get directory */
 673         if (!(path = PARSER_get_dest_dir( &context ))) continue;
 674
 675         /* get dll name */
 676         if (!SetupGetStringFieldW( &context, 3, buffer, sizeof(buffer)/sizeof(WCHAR), NULL ))
 677             goto done;
 678         if (!(p = HeapReAlloc( GetProcessHeap(), 0, path,
 679                                (strlenW(path) + strlenW(buffer) + 2) * sizeof(WCHAR) ))) goto done;
 680         path = p;
 681         p += strlenW(p);
 682         if (p == path || p[-1] != '\\') *p++ = '\\';
 683         strcpyW( p, buffer );
 684
 685         /* get source dll */
 686         if (SetupGetStringFieldW( &context, 4, buffer, sizeof(buffer)/sizeof(WCHAR), NULL ))
 687             p = buffer;  /* otherwise use target base name as default source */
 688
 689         create_fake_dll( path, p );  /* ignore errors */
 690
 691     done:
 692         HeapFree( GetProcessHeap(), 0, path );
 693         if (!ret) break;
 694     }
 695     return ret;
 696 }
 697
 698 /***********************************************************************
 699  *            update_ini_callback
 700  *
 701  * Called once for each UpdateInis entry in a given section.
 702  */
 703 static BOOL update_ini_callback( HINF hinf, PCWSTR field, void *arg )
 704 {
 705     INFCONTEXT context;
 706
 707     BOOL ok = SetupFindFirstLineW( hinf, field, NULL, &context );
 708
 709     for (; ok; ok = SetupFindNextLine( &context, &context ))
 710     {
 711         WCHAR buffer[MAX_INF_STRING_LENGTH];
 712         WCHAR  filename[MAX_INF_STRING_LENGTH];
 713         WCHAR  section[MAX_INF_STRING_LENGTH];
 714         WCHAR  entry[MAX_INF_STRING_LENGTH];
 715         WCHAR  string[MAX_INF_STRING_LENGTH];
 716         LPWSTR divider;
 717
 718         if (!SetupGetStringFieldW( &context, 1, filename,
 719                                    sizeof(filename)/sizeof(WCHAR), NULL ))
 720             continue;
 721
 722         if (!SetupGetStringFieldW( &context, 2, section,
 723                                    sizeof(section)/sizeof(WCHAR), NULL ))
 724             continue;
 725
 726         if (!SetupGetStringFieldW( &context, 4, buffer,
 727                                    sizeof(buffer)/sizeof(WCHAR), NULL ))
 728             continue;
 729
 730         divider = strchrW(buffer,'=');
 731         if (divider)
 732         {
 733             *divider = 0;
 734             strcpyW(entry,buffer);
 735             divider++;
 736             strcpyW(string,divider);
 737         }
 738         else
 739         {
 740             strcpyW(entry,buffer);
 741             string[0]=0;
 742         }
 743
 744         TRACE("Writing %s = %s in %s of file %s\n",debugstr_w(entry),
 745                debugstr_w(string),debugstr_w(section),debugstr_w(filename));
 746         WritePrivateProfileStringW(section,entry,string,filename);
 747
 748     }
 749     return TRUE;
 750 }
 751
 752 static BOOL update_ini_fields_callback( HINF hinf, PCWSTR field, void *arg )
 753 {
 754     FIXME( "should update ini fields %s\n", debugstr_w(field) );
 755     return TRUE;
 756 }
 757
 758 static BOOL ini2reg_callback( HINF hinf, PCWSTR field, void *arg )
 759 {
 760     FIXME( "should do ini2reg %s\n", debugstr_w(field) );
 761     return TRUE;
 762 }
 763
 764 static BOOL logconf_callback( HINF hinf, PCWSTR field, void *arg )
 765 {
 766     FIXME( "should do logconf %s\n", debugstr_w(field) );
 767     return TRUE;
 768 }
 769
 770 static BOOL bitreg_callback( HINF hinf, PCWSTR field, void *arg )
 771 {
 772     FIXME( "should do bitreg %s\n", debugstr_w(field) );
 773     return TRUE;
 774 }
 775
 776 static BOOL profile_items_callback( HINF hinf, PCWSTR field, void *arg )
 777 {
 778     FIXME( "should do profile items %s\n", debugstr_w(field) );
 779     return TRUE;
 780 }
 781
 782 static BOOL copy_inf_callback( HINF hinf, PCWSTR field, void *arg )
 783 {
 784     FIXME( "should do copy inf %s\n", debugstr_w(field) );
 785     return TRUE;
 786 }
 787
 788
 789 /***********************************************************************
 790  *            iterate_section_fields
 791  *
 792  * Iterate over all fields of a certain key of a certain section
 793  */
 794 static BOOL iterate_section_fields( HINF hinf, PCWSTR section, PCWSTR key,
 795                                     iterate_fields_func callback, void *arg )
 796 {
 797     WCHAR static_buffer[200];
 798     WCHAR *buffer = static_buffer;
 799     DWORD size = sizeof(static_buffer)/sizeof(WCHAR);
 800     INFCONTEXT context;
 801     BOOL ret = FALSE;
 802
 803     BOOL ok = SetupFindFirstLineW( hinf, section, key, &context );
 804     while (ok)
 805     {
 806         UINT i, count = SetupGetFieldCount( &context );
 807         for (i = 1; i <= count; i++)
 808         {
 809             if (!(buffer = get_field_string( &context, i, buffer, static_buffer, &size )))
 810                 goto done;
 811             if (!callback( hinf, buffer, arg ))
 812             {
 813                 WARN("callback failed for %s %s err %d\n",
 814                      debugstr_w(section), debugstr_w(buffer), GetLastError() );
 815                 goto done;
 816             }
 817         }
 818         ok = SetupFindNextMatchLineW( &context, key, &context );
 819     }
 820     ret = TRUE;
 821  done:
 822     if (buffer != static_buffer) HeapFree( GetProcessHeap(), 0, buffer );
 823     return ret;
 824 }
 825
 826
 827 /***********************************************************************
 828  *            SetupInstallFilesFromInfSectionA   (SETUPAPI.@)
 829  */
 830 BOOL WINAPI SetupInstallFilesFromInfSectionA( HINF hinf, HINF hlayout, HSPFILEQ queue,
 831                                               PCSTR section, PCSTR src_root, UINT flags )
 832 {
 833     UNICODE_STRING sectionW;
 834     BOOL ret = FALSE;
 835
 836     if (!RtlCreateUnicodeStringFromAsciiz( &sectionW, section ))
 837     {
 838         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
 839         return FALSE;
 840     }
 841     if (!src_root)
 842         ret = SetupInstallFilesFromInfSectionW( hinf, hlayout, queue, sectionW.Buffer,
 843                                                 NULL, flags );
 844     else
 845     {
 846         UNICODE_STRING srcW;
 847         if (RtlCreateUnicodeStringFromAsciiz( &srcW, src_root ))
 848         {
 849             ret = SetupInstallFilesFromInfSectionW( hinf, hlayout, queue, sectionW.Buffer,
 850                                                     srcW.Buffer, flags );
 851             RtlFreeUnicodeString( &srcW );
 852         }
 853         else SetLastError( ERROR_NOT_ENOUGH_MEMORY );
 854     }
 855     RtlFreeUnicodeString( &sectionW );
 856     return ret;
 857 }
 858
 859
 860 /***********************************************************************
 861  *            SetupInstallFilesFromInfSectionW   (SETUPAPI.@)
 862  */
 863 BOOL WINAPI SetupInstallFilesFromInfSectionW( HINF hinf, HINF hlayout, HSPFILEQ queue,
 864                                               PCWSTR section, PCWSTR src_root, UINT flags )
 865 {
 866     struct files_callback_info info;
 867
 868     info.queue      = queue;
 869     info.src_root   = src_root;
 870     info.copy_flags = flags;
 871     info.layout     = hlayout;
 872     return iterate_section_fields( hinf, section, CopyFiles, copy_files_callback, &info );
 873 }
 874
 875
 876 /***********************************************************************
 877  *            SetupInstallFromInfSectionA   (SETUPAPI.@)
 878  */
 879 BOOL WINAPI SetupInstallFromInfSectionA( HWND owner, HINF hinf, PCSTR section, UINT flags,
 880                                          HKEY key_root, PCSTR src_root, UINT copy_flags,
 881                                          PSP_FILE_CALLBACK_A callback, PVOID context,
 882                                          HDEVINFO devinfo, PSP_DEVINFO_DATA devinfo_data )
 883 {
 884     UNICODE_STRING sectionW, src_rootW;
 885     struct callback_WtoA_context ctx;
 886     BOOL ret = FALSE;
 887
 888     src_rootW.Buffer = NULL;
 889     if (src_root && !RtlCreateUnicodeStringFromAsciiz( &src_rootW, src_root ))
 890     {
 891         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
 892         return FALSE;
 893     }
 894
 895     if (RtlCreateUnicodeStringFromAsciiz( &sectionW, section ))
 896     {
 897         ctx.orig_context = context;
 898         ctx.orig_handler = callback;
 899         ret = SetupInstallFromInfSectionW( owner, hinf, sectionW.Buffer, flags, key_root,
 900                                            src_rootW.Buffer, copy_flags, QUEUE_callback_WtoA,
 901                                            &ctx, devinfo, devinfo_data );
 902         RtlFreeUnicodeString( &sectionW );
 903     }
 904     else SetLastError( ERROR_NOT_ENOUGH_MEMORY );
 905
 906     RtlFreeUnicodeString( &src_rootW );
 907     return ret;
 908 }
 909
 910
 911 /***********************************************************************
 912  *            SetupInstallFromInfSectionW   (SETUPAPI.@)
 913  */
 914 BOOL WINAPI SetupInstallFromInfSectionW( HWND owner, HINF hinf, PCWSTR section, UINT flags,
 915                                          HKEY key_root, PCWSTR src_root, UINT copy_flags,
 916                                          PSP_FILE_CALLBACK_W callback, PVOID context,
 917                                          HDEVINFO devinfo, PSP_DEVINFO_DATA devinfo_data )
 918 {
 919     if (flags & SPINST_FILES)
 920     {
 921         struct files_callback_info info;
 922         HSPFILEQ queue;
 923         BOOL ret;
 924
 925         if (!(queue = SetupOpenFileQueue())) return FALSE;
 926         info.queue      = queue;
 927         info.src_root   = src_root;
 928         info.copy_flags = copy_flags;
 929         info.layout     = hinf;
 930         ret = (iterate_section_fields( hinf, section, CopyFiles, copy_files_callback, &info ) &&
 931                iterate_section_fields( hinf, section, DelFiles, delete_files_callback, &info ) &&
 932                iterate_section_fields( hinf, section, RenFiles, rename_files_callback, &info ) &&
 933                SetupCommitFileQueueW( owner, queue, callback, context ));
 934         SetupCloseFileQueue( queue );
 935         if (!ret) return FALSE;
 936     }
 937     if (flags & SPINST_INIFILES)
 938     {
 939         if (!iterate_section_fields( hinf, section, UpdateInis, update_ini_callback, NULL ) ||
 940             !iterate_section_fields( hinf, section, UpdateIniFields,
 941                                      update_ini_fields_callback, NULL ))
 942             return FALSE;
 943     }
 944     if (flags & SPINST_INI2REG)
 945     {
 946         if (!iterate_section_fields( hinf, section, Ini2Reg, ini2reg_callback, NULL ))
 947             return FALSE;
 948     }
 949     if (flags & SPINST_LOGCONFIG)
 950     {
 951         if (!iterate_section_fields( hinf, section, LogConf, logconf_callback, NULL ))
 952             return FALSE;
 953     }
 954     if (flags & SPINST_REGSVR)
 955     {
 956         struct register_dll_info info;
 957
 958         info.unregister = FALSE;
 959         if (flags & SPINST_REGISTERCALLBACKAWARE)
 960         {
 961             info.callback         = callback;
 962             info.callback_context = context;
 963         }
 964         else info.callback = NULL;
 965
 966         if (!iterate_section_fields( hinf, section, RegisterDlls, register_dlls_callback, &info ))
 967             return FALSE;
 968
 969         if (!iterate_section_fields( hinf, section, WineFakeDlls, fake_dlls_callback, NULL ))
 970             return FALSE;
 971     }
 972     if (flags & SPINST_UNREGSVR)
 973     {
 974         struct register_dll_info info;
 975
 976         info.unregister = TRUE;
 977         if (flags & SPINST_REGISTERCALLBACKAWARE)
 978         {
 979             info.callback         = callback;
 980             info.callback_context = context;
 981         }
 982         else info.callback = NULL;
 983
 984         if (!iterate_section_fields( hinf, section, UnregisterDlls, register_dlls_callback, &info ))
 985             return FALSE;
 986     }
 987     if (flags & SPINST_REGISTRY)
 988     {
 989         struct registry_callback_info info;
 990
 991         info.default_root = key_root;
 992         info.delete = TRUE;
 993         if (!iterate_section_fields( hinf, section, DelReg, registry_callback, &info ))
 994             return FALSE;
 995         info.delete = FALSE;
 996         if (!iterate_section_fields( hinf, section, AddReg, registry_callback, &info ))
 997             return FALSE;
 998     }
 999     if (flags & SPINST_BITREG)
1000     {
1001         if (!iterate_section_fields( hinf, section, BitReg, bitreg_callback, NULL ))
1002             return FALSE;
1003     }
1004     if (flags & SPINST_PROFILEITEMS)
1005     {
1006         if (!iterate_section_fields( hinf, section, ProfileItems, profile_items_callback, NULL ))
1007             return FALSE;
1008     }
1009     if (flags & SPINST_COPYINF)
1010     {
1011         if (!iterate_section_fields( hinf, section, CopyINF, copy_inf_callback, NULL ))
1012             return FALSE;
1013     }
1014
1015     return TRUE;
1016 }
1017
1018
1019 /***********************************************************************
1020  *              InstallHinfSectionW  (SETUPAPI.@)
1021  *
1022  * NOTE: 'cmdline' is <section> <mode> <path> from
1023  *   RUNDLL32.EXE SETUPAPI.DLL,InstallHinfSection <section> <mode> <path>
1024  */
1025 void WINAPI InstallHinfSectionW( HWND hwnd, HINSTANCE handle, LPCWSTR cmdline, INT show )
1026 {
1027 #ifdef __i386__
1028     static const WCHAR nt_platformW[] = {'.','n','t','x','8','6',0};
1029 #elif defined(__x86_64)
1030     static const WCHAR nt_platformW[] = {'.','n','t','a','m','d','6','4',0};
1031 #else  /* FIXME: other platforms */
1032     static const WCHAR nt_platformW[] = {'.','n','t',0};
1033 #endif
1034     static const WCHAR nt_genericW[] = {'.','n','t',0};
1035     static const WCHAR servicesW[] = {'.','S','e','r','v','i','c','e','s',0};
1036
1037     WCHAR *s, *path, section[MAX_PATH + (sizeof(nt_platformW) + sizeof(servicesW)) / sizeof(WCHAR)];
1038     void *callback_context;
1039     UINT mode;
1040     HINF hinf;
1041
1042     TRACE("hwnd %p, handle %p, cmdline %s\n", hwnd, handle, debugstr_w(cmdline));
1043
1044     lstrcpynW( section, cmdline, MAX_PATH );
1045
1046     if (!(s = strchrW( section, ' ' ))) return;
1047     *s++ = 0;
1048     while (*s == ' ') s++;
1049     mode = atoiW( s );
1050
1051     /* quoted paths are not allowed on native, the rest of the command line is taken as the path */
1052     if (!(s = strchrW( s, ' ' ))) return;
1053     while (*s == ' ') s++;
1054     path = s;
1055
1056     hinf = SetupOpenInfFileW( path, NULL, INF_STYLE_WIN4, NULL );
1057     if (hinf == INVALID_HANDLE_VALUE) return;
1058
1059     if (!(GetVersion() & 0x80000000))
1060     {
1061         INFCONTEXT context;
1062
1063         /* check for <section>.ntx86 (or corresponding name for the current platform)
1064          * and then <section>.nt */
1065         s = section + strlenW(section);
1066         memcpy( s, nt_platformW, sizeof(nt_platformW) );
1067         if (!(SetupFindFirstLineW( hinf, section, NULL, &context )))
1068         {
1069             memcpy( s, nt_genericW, sizeof(nt_genericW) );
1070             if (!(SetupFindFirstLineW( hinf, section, NULL, &context ))) *s = 0;
1071         }
1072         if (*s) TRACE( "using section %s instead\n", debugstr_w(section) );
1073     }
1074
1075     callback_context = SetupInitDefaultQueueCallback( hwnd );
1076     SetupInstallFromInfSectionW( hwnd, hinf, section, SPINST_ALL, NULL, NULL, SP_COPY_NEWER,
1077                                  SetupDefaultQueueCallbackW, callback_context,
1078                                  NULL, NULL );
1079     SetupTermDefaultQueueCallback( callback_context );
1080     strcatW( section, servicesW );
1081     SetupInstallServicesFromInfSectionW( hinf, section, 0 );
1082     SetupCloseInfFile( hinf );
1083
1084     /* FIXME: should check the mode and maybe reboot */
1085     /* there isn't much point in doing that since we */
1086     /* don't yet handle deferred file copies anyway. */
1087 }
1088
1089
1090 /***********************************************************************
1091  *              InstallHinfSectionA  (SETUPAPI.@)
1092  */
1093 void WINAPI InstallHinfSectionA( HWND hwnd, HINSTANCE handle, LPCSTR cmdline, INT show )
1094 {
1095     UNICODE_STRING cmdlineW;
1096
1097     if (RtlCreateUnicodeStringFromAsciiz( &cmdlineW, cmdline ))
1098     {
1099         InstallHinfSectionW( hwnd, handle, cmdlineW.Buffer, show );
1100         RtlFreeUnicodeString( &cmdlineW );
1101     }
1102 }
1103
1104
1105 /***********************************************************************
1106  *            add_service
1107  *
1108  * Create a new service. Helper for SetupInstallServicesFromInfSectionW.
1109  */
1110 static BOOL add_service( SC_HANDLE scm, HINF hinf, const WCHAR *name, const WCHAR *section, DWORD flags )
1111 {
1112     struct registry_callback_info info;
1113     SC_HANDLE service;
1114     INFCONTEXT context;
1115     SERVICE_DESCRIPTIONW descr;
1116     WCHAR *display_name, *start_name, *load_order, *binary_path;
1117     INT service_type = 0, start_type = 0, error_control = 0;
1118     DWORD size;
1119     HKEY hkey;
1120
1121     /* first the mandatory fields */
1122
1123     if (!SetupFindFirstLineW( hinf, section, ServiceType, &context ) ||
1124         !SetupGetIntField( &context, 1, &service_type ))
1125     {
1126         SetLastError( ERROR_BAD_SERVICE_INSTALLSECT );
1127         return FALSE;
1128     }
1129     if (!SetupFindFirstLineW( hinf, section, StartType, &context ) ||
1130         !SetupGetIntField( &context, 1, &start_type ))
1131     {
1132         SetLastError( ERROR_BAD_SERVICE_INSTALLSECT );
1133         return FALSE;
1134     }
1135     if (!SetupFindFirstLineW( hinf, section, ErrorControl, &context ) ||
1136         !SetupGetIntField( &context, 1, &error_control ))
1137     {
1138         SetLastError( ERROR_BAD_SERVICE_INSTALLSECT );
1139         return FALSE;
1140     }
1141     if (!(binary_path = dup_section_line_field( hinf, section, ServiceBinary, 1 )))
1142     {
1143         SetLastError( ERROR_BAD_SERVICE_INSTALLSECT );
1144         return FALSE;
1145     }
1146
1147     /* now the optional fields */
1148
1149     display_name = dup_section_line_field( hinf, section, DisplayName, 1 );
1150     start_name = dup_section_line_field( hinf, section, StartName, 1 );
1151     load_order = dup_section_line_field( hinf, section, LoadOrderGroup, 1 );
1152     descr.lpDescription = dup_section_line_field( hinf, section, Description, 1 );
1153
1154     /* FIXME: Dependencies field */
1155     /* FIXME: Security field */
1156
1157     TRACE( "service %s display %s type %x start %x error %x binary %s order %s startname %s flags %x\n",
1158            debugstr_w(name), debugstr_w(display_name), service_type, start_type, error_control,
1159            debugstr_w(binary_path), debugstr_w(load_order), debugstr_w(start_name), flags );
1160
1161     service = CreateServiceW( scm, name, display_name, SERVICE_ALL_ACCESS,
1162                               service_type, start_type, error_control, binary_path,
1163                               load_order, NULL, NULL, start_name, NULL );
1164     if (service)
1165     {
1166         if (descr.lpDescription) ChangeServiceConfig2W( service, SERVICE_CONFIG_DESCRIPTION, &descr );
1167     }
1168     else
1169     {
1170         if (GetLastError() != ERROR_SERVICE_EXISTS) goto done;
1171         service = OpenServiceW( scm, name, SERVICE_QUERY_CONFIG|SERVICE_CHANGE_CONFIG|SERVICE_START );
1172         if (!service) goto done;
1173
1174         if (flags & (SPSVCINST_NOCLOBBER_DISPLAYNAME | SPSVCINST_NOCLOBBER_STARTTYPE |
1175                      SPSVCINST_NOCLOBBER_ERRORCONTROL | SPSVCINST_NOCLOBBER_LOADORDERGROUP))
1176         {
1177             QUERY_SERVICE_CONFIGW *config = NULL;
1178
1179             if (!QueryServiceConfigW( service, NULL, 0, &size ) &&
1180                 GetLastError() == ERROR_INSUFFICIENT_BUFFER)
1181                 config = HeapAlloc( GetProcessHeap(), 0, size );
1182             if (config && QueryServiceConfigW( service, config, size, &size ))
1183             {
1184                 if (flags & SPSVCINST_NOCLOBBER_STARTTYPE) start_type = config->dwStartType;
1185                 if (flags & SPSVCINST_NOCLOBBER_ERRORCONTROL) error_control = config->dwErrorControl;
1186                 if (flags & SPSVCINST_NOCLOBBER_DISPLAYNAME)
1187                 {
1188                     HeapFree( GetProcessHeap(), 0, display_name );
1189                     display_name = strdupW( config->lpDisplayName );
1190                 }
1191                 if (flags & SPSVCINST_NOCLOBBER_LOADORDERGROUP)
1192                 {
1193                     HeapFree( GetProcessHeap(), 0, load_order );
1194                     load_order = strdupW( config->lpLoadOrderGroup );
1195                 }
1196             }
1197             HeapFree( GetProcessHeap(), 0, config );
1198         }
1199         TRACE( "changing %s display %s type %x start %x error %x binary %s loadorder %s startname %s\n",
1200                debugstr_w(name), debugstr_w(display_name), service_type, start_type, error_control,
1201                debugstr_w(binary_path), debugstr_w(load_order), debugstr_w(start_name) );
1202
1203         ChangeServiceConfigW( service, service_type, start_type, error_control, binary_path,
1204                               load_order, NULL, NULL, start_name, NULL, display_name );
1205
1206         if (!(flags & SPSVCINST_NOCLOBBER_DESCRIPTION))
1207             ChangeServiceConfig2W( service, SERVICE_CONFIG_DESCRIPTION, &descr );
1208     }
1209
1210     /* execute the AddReg, DelReg and BitReg entries */
1211
1212     info.default_root = 0;
1213     if (!RegOpenKeyW( HKEY_LOCAL_MACHINE, ServicesKey, &hkey ))
1214     {
1215         RegOpenKeyW( hkey, name, &info.default_root );
1216         RegCloseKey( hkey );
1217     }
1218     if (info.default_root)
1219     {
1220         info.delete = TRUE;
1221         iterate_section_fields( hinf, section, DelReg, registry_callback, &info );
1222         info.delete = FALSE;
1223         iterate_section_fields( hinf, section, AddReg, registry_callback, &info );
1224         RegCloseKey( info.default_root );
1225     }
1226     iterate_section_fields( hinf, section, BitReg, bitreg_callback, NULL );
1227
1228     if (flags & SPSVCINST_STARTSERVICE) StartServiceW( service, 0, NULL );
1229     CloseServiceHandle( service );
1230
1231 done:
1232     if (!service) WARN( "failed err %u\n", GetLastError() );
1233     HeapFree( GetProcessHeap(), 0, binary_path );
1234     HeapFree( GetProcessHeap(), 0, display_name );
1235     HeapFree( GetProcessHeap(), 0, start_name );
1236     HeapFree( GetProcessHeap(), 0, load_order );
1237     HeapFree( GetProcessHeap(), 0, descr.lpDescription );
1238     return service != 0;
1239 }
1240
1241
1242 /***********************************************************************
1243  *            del_service
1244  *
1245  * Delete service. Helper for SetupInstallServicesFromInfSectionW.
1246  */
1247 static BOOL del_service( SC_HANDLE scm, HINF hinf, const WCHAR *name, DWORD flags )
1248 {
1249     BOOL ret;
1250     SC_HANDLE service;
1251     SERVICE_STATUS status;
1252
1253     if (!(service = OpenServiceW( scm, name, SERVICE_STOP | DELETE )))
1254     {
1255         if (GetLastError() == ERROR_SERVICE_DOES_NOT_EXIST) return TRUE;
1256         WARN( "cannot open %s err %u\n", debugstr_w(name), GetLastError() );
1257         return FALSE;
1258     }
1259     if (flags & SPSVCINST_STOPSERVICE) ControlService( service, SERVICE_CONTROL_STOP, &status );
1260     TRACE( "deleting %s\n", debugstr_w(name) );
1261     ret = DeleteService( service );
1262     CloseServiceHandle( service );
1263     return ret;
1264 }
1265
1266
1267 /***********************************************************************
1268  *              SetupInstallServicesFromInfSectionW  (SETUPAPI.@)
1269  */
1270 BOOL WINAPI SetupInstallServicesFromInfSectionW( HINF hinf, PCWSTR section, DWORD flags )
1271 {
1272     WCHAR service_name[MAX_INF_STRING_LENGTH];
1273     WCHAR service_section[MAX_INF_STRING_LENGTH];
1274     SC_HANDLE scm;
1275     INFCONTEXT context;
1276     INT section_flags;
1277     BOOL ok, ret = FALSE;
1278
1279     if (!(scm = OpenSCManagerW( NULL, NULL, SC_MANAGER_ALL_ACCESS ))) return FALSE;
1280
1281     if (!(ok = SetupFindFirstLineW( hinf, section, AddService, &context )))
1282         SetLastError( ERROR_SECTION_NOT_FOUND );
1283     while (ok)
1284     {
1285         if (!SetupGetStringFieldW( &context, 1, service_name, MAX_INF_STRING_LENGTH, NULL ))
1286             continue;
1287         if (!SetupGetIntField( &context, 2, &section_flags )) section_flags = 0;
1288         if (!SetupGetStringFieldW( &context, 3, service_section, MAX_INF_STRING_LENGTH, NULL ))
1289             continue;
1290         if (!(ret = add_service( scm, hinf, service_name, service_section, section_flags | flags )))
1291             goto done;
1292         ok = SetupFindNextMatchLineW( &context, AddService, &context );
1293     }
1294
1295     if (!(ok = SetupFindFirstLineW( hinf, section, DelService, &context )))
1296         SetLastError( ERROR_SECTION_NOT_FOUND );
1297     while (ok)
1298     {
1299         if (!SetupGetStringFieldW( &context, 1, service_name, MAX_INF_STRING_LENGTH, NULL ))
1300             continue;
1301         if (!SetupGetIntField( &context, 2, &section_flags )) section_flags = 0;
1302         if (!(ret = del_service( scm, hinf, service_name, section_flags | flags ))) goto done;
1303         ok = SetupFindNextMatchLineW( &context, AddService, &context );
1304     }
1305     if (ret) SetLastError( ERROR_SUCCESS );
1306  done:
1307     CloseServiceHandle( scm );
1308     return ret;
1309 }
1310
1311
1312 /***********************************************************************
1313  *              SetupInstallServicesFromInfSectionA  (SETUPAPI.@)
1314  */
1315 BOOL WINAPI SetupInstallServicesFromInfSectionA( HINF Inf, PCSTR SectionName, DWORD Flags)
1316 {
1317     UNICODE_STRING SectionNameW;
1318     BOOL ret = FALSE;
1319
1320     if (RtlCreateUnicodeStringFromAsciiz( &SectionNameW, SectionName ))
1321     {
1322         ret = SetupInstallServicesFromInfSectionW( Inf, SectionNameW.Buffer, Flags );
1323         RtlFreeUnicodeString( &SectionNameW );
1324     }
1325     else
1326         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1327
1328     return ret;
1329 }