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 #include <stdbool.h>
  23
  24 #define COBJMACROS
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winreg.h"
  29 #include "winternl.h"
  30 #include "winerror.h"
  31 #include "wingdi.h"
  32 #include "winuser.h"
  33 #include "winnls.h"
  34 #include "winsvc.h"
  35 #include "shlobj.h"
  36 #include "shlwapi.h"
  37 #include "objidl.h"
  38 #include "objbase.h"
  39 #include "setupapi.h"
  40 #include "setupapi_private.h"
  41 #include "wine/debug.h"
  42
  43 WINE_DEFAULT_DEBUG_CHANNEL(setupapi);
  44
  45 /* info passed to callback functions dealing with files */
  46 struct files_callback_info
  47 {
  48     HSPFILEQ queue;
  49     PCWSTR   src_root;
  50     UINT     copy_flags;
  51     HINF     layout;
  52 };
  53
  54 /* info passed to callback functions dealing with the registry */
  55 struct registry_callback_info
  56 {
  57     HKEY default_root;
  58     BOOL delete;
  59 };
  60
  61 /* info passed to callback functions dealing with registering dlls */
  62 struct register_dll_info
  63 {
  64     PSP_FILE_CALLBACK_W callback;
  65     PVOID               callback_context;
  66     BOOL                unregister;
  67     int                 modules_size;
  68     int                 modules_count;
  69     HMODULE            *modules;
  70 };
  71
  72 typedef BOOL (*iterate_fields_func)( HINF hinf, PCWSTR field, void *arg );
  73
  74
  75 /***********************************************************************
  76  *            get_field_string
  77  *
  78  * Retrieve the contents of a field, dynamically growing the buffer if necessary.
  79  */
  80 static WCHAR *get_field_string( INFCONTEXT *context, DWORD index, WCHAR *buffer,
  81                                 WCHAR *static_buffer, DWORD *size )
  82 {
  83     DWORD required;
  84
  85     if (SetupGetStringFieldW( context, index, buffer, *size, &required )) return buffer;
  86     if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
  87     {
  88         /* now grow the buffer */
  89         if (buffer != static_buffer) HeapFree( GetProcessHeap(), 0, buffer );
  90         if (!(buffer = HeapAlloc( GetProcessHeap(), 0, required*sizeof(WCHAR) ))) return NULL;
  91         *size = required;
  92         if (SetupGetStringFieldW( context, index, buffer, *size, &required )) return buffer;
  93     }
  94     if (buffer != static_buffer) HeapFree( GetProcessHeap(), 0, buffer );
  95     return NULL;
  96 }
  97
  98
  99 /***********************************************************************
 100  *            dup_section_line_field
 101  *
 102  * Retrieve the contents of a field in a newly-allocated buffer.
 103  */
 104 static WCHAR *dup_section_line_field( HINF hinf, const WCHAR *section, const WCHAR *line, DWORD index )
 105 {
 106     INFCONTEXT context;
 107     DWORD size;
 108     WCHAR *buffer;
 109
 110     if (!SetupFindFirstLineW( hinf, section, line, &context )) return NULL;
 111     if (!SetupGetStringFieldW( &context, index, NULL, 0, &size )) return NULL;
 112     if (!(buffer = HeapAlloc( GetProcessHeap(), 0, size * sizeof(WCHAR) ))) return NULL;
 113     if (!SetupGetStringFieldW( &context, index, buffer, size, NULL )) buffer[0] = 0;
 114     return buffer;
 115 }
 116
 117 static void get_inf_src_path( HINF hinf, WCHAR *path )
 118 {
 119     const WCHAR *inf_path = PARSER_get_inf_filename( hinf );
 120     WCHAR pnf_path[MAX_PATH];
 121     FILE *pnf;
 122
 123     wcscpy( pnf_path, inf_path );
 124     PathRemoveExtensionW( pnf_path );
 125     PathAddExtensionW( pnf_path, L".pnf" );
 126     if ((pnf = _wfopen( pnf_path, L"r" )))
 127     {
 128         if (fgetws( path, MAX_PATH, pnf ) && !wcscmp( path, PNF_HEADER ))
 129         {
 130             fgetws( path, MAX_PATH, pnf );
 131             TRACE("using original source path %s\n", debugstr_w(path));
 132             fclose( pnf );
 133             return;
 134         }
 135         fclose( pnf );
 136     }
 137     wcscpy( path, inf_path );
 138 }
 139
 140 /***********************************************************************
 141  *            copy_files_callback
 142  *
 143  * Called once for each CopyFiles entry in a given section.
 144  */
 145 static BOOL copy_files_callback( HINF hinf, PCWSTR field, void *arg )
 146 {
 147     INFCONTEXT context;
 148     struct files_callback_info *info = arg;
 149     WCHAR src_root[MAX_PATH], *p;
 150
 151     if (!info->src_root)
 152     {
 153         const WCHAR *build_dir = _wgetenv( L"WINEBUILDDIR" );
 154         const WCHAR *data_dir = _wgetenv( L"WINEDATADIR" );
 155
 156         if ((build_dir || data_dir) && SetupFindFirstLineW( hinf, L"WineSourceDirs", field, &context ))
 157         {
 158             lstrcpyW( src_root, build_dir ? build_dir : data_dir );
 159             src_root[1] = '\\';  /* change \??\ to \\?\ */
 160             p = src_root + lstrlenW(src_root);
 161             *p++ = '\\';
 162             if (!build_dir || !SetupGetStringFieldW( &context, 2, p, MAX_PATH - (p - src_root), NULL ))
 163             {
 164                 if (!SetupGetStringFieldW( &context, 1, p, MAX_PATH - (p - src_root), NULL )) p[-1] = 0;
 165             }
 166         }
 167         else
 168         {
 169             get_inf_src_path( hinf, src_root );
 170             if ((p = wcsrchr( src_root, '\\' ))) *p = 0;
 171         }
 172     }
 173
 174     if (field[0] == '@')  /* special case: copy single file */
 175         SetupQueueDefaultCopyW( info->queue, info->layout ? info->layout : hinf,
 176                 info->src_root ? info->src_root : src_root, field+1, field+1, info->copy_flags );
 177     else
 178         SetupQueueCopySectionW( info->queue, info->src_root ? info->src_root : src_root,
 179                 info->layout ? info->layout : hinf, hinf, field, info->copy_flags );
 180     return TRUE;
 181 }
 182
 183
 184 /***********************************************************************
 185  *            delete_files_callback
 186  *
 187  * Called once for each DelFiles entry in a given section.
 188  */
 189 static BOOL delete_files_callback( HINF hinf, PCWSTR field, void *arg )
 190 {
 191     struct files_callback_info *info = arg;
 192     SetupQueueDeleteSectionW( info->queue, hinf, 0, field );
 193     return TRUE;
 194 }
 195
 196
 197 /***********************************************************************
 198  *            rename_files_callback
 199  *
 200  * Called once for each RenFiles entry in a given section.
 201  */
 202 static BOOL rename_files_callback( HINF hinf, PCWSTR field, void *arg )
 203 {
 204     struct files_callback_info *info = arg;
 205     SetupQueueRenameSectionW( info->queue, hinf, 0, field );
 206     return TRUE;
 207 }
 208
 209
 210 /***********************************************************************
 211  *            get_root_key
 212  *
 213  * Retrieve the registry root key from its name.
 214  */
 215 static HKEY get_root_key( const WCHAR *name, HKEY def_root )
 216 {
 217     if (!wcsicmp( name, L"HKCR" )) return HKEY_CLASSES_ROOT;
 218     if (!wcsicmp( name, L"HKCU" )) return HKEY_CURRENT_USER;
 219     if (!wcsicmp( name, L"HKLM" )) return HKEY_LOCAL_MACHINE;
 220     if (!wcsicmp( name, L"HKU" )) return HKEY_USERS;
 221     if (!wcsicmp( name, L"HKR" )) return def_root;
 222     return 0;
 223 }
 224
 225
 226 /***********************************************************************
 227  *            append_multi_sz_value
 228  *
 229  * Append a multisz string to a multisz registry value.
 230  */
 231 static bool append_multi_sz_value( HKEY hkey, const WCHAR *value, const WCHAR *strings,
 232                                    DWORD str_size )
 233 {
 234     DWORD size, type, total;
 235     WCHAR *buffer, *p;
 236     LONG ret;
 237
 238     if ((ret = RegQueryValueExW( hkey, value, NULL, &type, NULL, &size )))
 239     {
 240         if (ret != ERROR_FILE_NOT_FOUND)
 241         {
 242             ERR( "failed to query value %s, error %lu\n", debugstr_w(value), ret );
 243             SetLastError( ret );
 244             return false;
 245         }
 246
 247         if ((ret = RegSetValueExW( hkey, value, 0, REG_MULTI_SZ, (BYTE *)strings, str_size * sizeof(WCHAR) )))
 248         {
 249             ERR( "failed to set value %s, error %lu\n", debugstr_w(value), ret );
 250             SetLastError( ret );
 251             return false;
 252         }
 253
 254         return true;
 255     }
 256
 257     if (type != REG_MULTI_SZ)
 258     {
 259         WARN( "value %s exists but has wrong type %#lx\n", debugstr_w(value), type );
 260         SetLastError( ERROR_INVALID_DATA );
 261         return false;
 262     }
 263
 264     if (!(buffer = HeapAlloc( GetProcessHeap(), 0, (size + str_size) * sizeof(WCHAR) ))) return false;
 265     if (RegQueryValueExW( hkey, value, NULL, NULL, (BYTE *)buffer, &size ))
 266     {
 267         HeapFree( GetProcessHeap(), 0, buffer );
 268         return false;
 269     }
 270
 271     /* compare each string against all the existing ones */
 272     total = size;
 273     while (*strings)
 274     {
 275         int len = lstrlenW(strings) + 1;
 276
 277         for (p = buffer; *p; p += lstrlenW(p) + 1)
 278             if (!wcsicmp( p, strings )) break;
 279
 280         if (!*p)  /* not found, need to append it */
 281         {
 282             memcpy( p, strings, len * sizeof(WCHAR) );
 283             p[len] = 0;
 284             total += len * sizeof(WCHAR);
 285         }
 286         strings += len;
 287     }
 288     if (total != size)
 289     {
 290         TRACE( "setting value %s to %s\n", debugstr_w(value), debugstr_w(buffer) );
 291         RegSetValueExW( hkey, value, 0, REG_MULTI_SZ, (BYTE *)buffer, total );
 292     }
 293
 294     HeapFree( GetProcessHeap(), 0, buffer );
 295     return true;
 296 }
 297
 298
 299 /***********************************************************************
 300  *            delete_multi_sz_value
 301  *
 302  * Remove a string from a multisz registry value.
 303  */
 304 static void delete_multi_sz_value( HKEY hkey, const WCHAR *value, const WCHAR *string )
 305 {
 306     DWORD size, type;
 307     WCHAR *buffer, *src, *dst;
 308
 309     if (RegQueryValueExW( hkey, value, NULL, &type, NULL, &size )) return;
 310     if (type != REG_MULTI_SZ) return;
 311     /* allocate double the size, one for value before and one for after */
 312     if (!(buffer = HeapAlloc( GetProcessHeap(), 0, size * 2 * sizeof(WCHAR) ))) return;
 313     if (RegQueryValueExW( hkey, value, NULL, NULL, (BYTE *)buffer, &size )) goto done;
 314     src = buffer;
 315     dst = buffer + size;
 316     while (*src)
 317     {
 318         int len = lstrlenW(src) + 1;
 319         if (wcsicmp( src, string ))
 320         {
 321             memcpy( dst, src, len * sizeof(WCHAR) );
 322             dst += len;
 323         }
 324         src += len;
 325     }
 326     *dst++ = 0;
 327     if (dst != buffer + 2*size)  /* did we remove something? */
 328     {
 329         TRACE( "setting value %s to %s\n", debugstr_w(value), debugstr_w(buffer + size) );
 330         RegSetValueExW( hkey, value, 0, REG_MULTI_SZ,
 331                         (BYTE *)(buffer + size), dst - (buffer + size) );
 332     }
 333  done:
 334     HeapFree( GetProcessHeap(), 0, buffer );
 335 }
 336
 337
 338 /***********************************************************************
 339  *            do_reg_operation
 340  *
 341  * Perform an add/delete registry operation depending on the flags.
 342  */
 343 static BOOL do_reg_operation( HKEY hkey, const WCHAR *value, INFCONTEXT *context, INT flags )
 344 {
 345     DWORD type, size;
 346
 347     if (flags & (FLG_ADDREG_DELREG_BIT | FLG_ADDREG_DELVAL))  /* deletion */
 348     {
 349         if (*value && !(flags & FLG_DELREG_KEYONLY_COMMON))
 350         {
 351             if ((flags & FLG_DELREG_MULTI_SZ_DELSTRING) == FLG_DELREG_MULTI_SZ_DELSTRING)
 352             {
 353                 WCHAR *str;
 354
 355                 if (!SetupGetStringFieldW( context, 5, NULL, 0, &size ) || !size) return TRUE;
 356                 if (!(str = HeapAlloc( GetProcessHeap(), 0, size * sizeof(WCHAR) ))) return FALSE;
 357                 SetupGetStringFieldW( context, 5, str, size, NULL );
 358                 delete_multi_sz_value( hkey, value, str );
 359                 HeapFree( GetProcessHeap(), 0, str );
 360             }
 361             else RegDeleteValueW( hkey, value );
 362         }
 363         else
 364         {
 365             RegDeleteTreeW( hkey, NULL );
 366             NtDeleteKey( hkey );
 367         }
 368         return TRUE;
 369     }
 370
 371     if (flags & (FLG_ADDREG_KEYONLY|FLG_ADDREG_KEYONLY_COMMON)) return TRUE;
 372
 373     if (flags & (FLG_ADDREG_NOCLOBBER|FLG_ADDREG_OVERWRITEONLY))
 374     {
 375         BOOL exists = !RegQueryValueExW( hkey, value, NULL, NULL, NULL, NULL );
 376         if (exists && (flags & FLG_ADDREG_NOCLOBBER)) return TRUE;
 377         if (!exists && (flags & FLG_ADDREG_OVERWRITEONLY)) return TRUE;
 378     }
 379
 380     switch(flags & FLG_ADDREG_TYPE_MASK)
 381     {
 382     case FLG_ADDREG_TYPE_SZ:        type = REG_SZ; break;
 383     case FLG_ADDREG_TYPE_MULTI_SZ:  type = REG_MULTI_SZ; break;
 384     case FLG_ADDREG_TYPE_EXPAND_SZ: type = REG_EXPAND_SZ; break;
 385     case FLG_ADDREG_TYPE_BINARY:    type = REG_BINARY; break;
 386     case FLG_ADDREG_TYPE_DWORD:     type = REG_DWORD; break;
 387     case FLG_ADDREG_TYPE_NONE:      type = REG_NONE; break;
 388     default:                        type = flags >> 16; break;
 389     }
 390
 391     if (!(flags & FLG_ADDREG_BINVALUETYPE) ||
 392         (type == REG_DWORD && SetupGetFieldCount(context) == 5))
 393     {
 394         WCHAR *str = NULL;
 395
 396         if (type == REG_MULTI_SZ)
 397         {
 398             if (!SetupGetMultiSzFieldW( context, 5, NULL, 0, &size )) size = 0;
 399             if (size)
 400             {
 401                 if (!(str = HeapAlloc( GetProcessHeap(), 0, size * sizeof(WCHAR) ))) return FALSE;
 402                 SetupGetMultiSzFieldW( context, 5, str, size, NULL );
 403             }
 404             if (flags & FLG_ADDREG_APPEND)
 405             {
 406                 if (!str) return TRUE;
 407                 if (!append_multi_sz_value( hkey, value, str, size ))
 408                 {
 409                     HeapFree( GetProcessHeap(), 0, str );
 410                     return FALSE;
 411                 }
 412                 HeapFree( GetProcessHeap(), 0, str );
 413                 return TRUE;
 414             }
 415             /* else fall through to normal string handling */
 416         }
 417         else
 418         {
 419             if (!SetupGetStringFieldW( context, 5, NULL, 0, &size )) size = 0;
 420             if (size)
 421             {
 422                 if (!(str = HeapAlloc( GetProcessHeap(), 0, size * sizeof(WCHAR) ))) return FALSE;
 423                 SetupGetStringFieldW( context, 5, str, size, NULL );
 424                 if (type == REG_LINK) size--;  /* no terminating null for symlinks */
 425             }
 426         }
 427
 428         if (type == REG_DWORD)
 429         {
 430             DWORD dw = str ? wcstoul( str, NULL, 0 ) : 0;
 431             TRACE( "setting dword %s to %lx\n", debugstr_w(value), dw );
 432             RegSetValueExW( hkey, value, 0, type, (BYTE *)&dw, sizeof(dw) );
 433         }
 434         else
 435         {
 436             TRACE( "setting value %s to %s\n", debugstr_w(value), debugstr_w(str) );
 437             if (str) RegSetValueExW( hkey, value, 0, type, (BYTE *)str, size * sizeof(WCHAR) );
 438             else RegSetValueExW( hkey, value, 0, type, (const BYTE *)L"", sizeof(WCHAR) );
 439         }
 440         HeapFree( GetProcessHeap(), 0, str );
 441         return TRUE;
 442     }
 443     else  /* get the binary data */
 444     {
 445         BYTE *data = NULL;
 446
 447         if (!SetupGetBinaryField( context, 5, NULL, 0, &size )) size = 0;
 448         if (size)
 449         {
 450             if (!(data = HeapAlloc( GetProcessHeap(), 0, size ))) return FALSE;
 451             TRACE( "setting binary data %s len %ld\n", debugstr_w(value), size );
 452             SetupGetBinaryField( context, 5, data, size, NULL );
 453         }
 454         RegSetValueExW( hkey, value, 0, type, data, size );
 455         HeapFree( GetProcessHeap(), 0, data );
 456         return TRUE;
 457     }
 458 }
 459
 460
 461 /***********************************************************************
 462  *            registry_callback
 463  *
 464  * Called once for each AddReg and DelReg entry in a given section.
 465  */
 466 static BOOL registry_callback( HINF hinf, PCWSTR field, void *arg )
 467 {
 468     struct registry_callback_info *info = arg;
 469     INFCONTEXT context;
 470     HKEY root_key, hkey;
 471
 472     BOOL ok = SetupFindFirstLineW( hinf, field, NULL, &context );
 473
 474     for (; ok; ok = SetupFindNextLine( &context, &context ))
 475     {
 476         DWORD options = 0;
 477         WCHAR buffer[MAX_INF_STRING_LENGTH];
 478         INT flags;
 479
 480         /* get root */
 481         if (!SetupGetStringFieldW( &context, 1, buffer, ARRAY_SIZE( buffer ), NULL ))
 482             continue;
 483         if (!(root_key = get_root_key( buffer, info->default_root )))
 484             continue;
 485
 486         /* get key */
 487         if (!SetupGetStringFieldW( &context, 2, buffer, ARRAY_SIZE( buffer ), NULL ))
 488             *buffer = 0;
 489
 490         /* get flags */
 491         if (!SetupGetIntField( &context, 4, &flags )) flags = 0;
 492
 493         if (!info->delete)
 494         {
 495             if (flags & FLG_ADDREG_DELREG_BIT) continue;  /* ignore this entry */
 496         }
 497         else
 498         {
 499             if (!flags) flags = FLG_ADDREG_DELREG_BIT;
 500             else if (!(flags & FLG_ADDREG_DELREG_BIT)) continue;  /* ignore this entry */
 501         }
 502         /* Wine extension: magic support for symlinks */
 503         if (flags >> 16 == REG_LINK) options = REG_OPTION_OPEN_LINK | REG_OPTION_CREATE_LINK;
 504
 505         if (info->delete || (flags & FLG_ADDREG_OVERWRITEONLY))
 506         {
 507             if (RegOpenKeyExW( root_key, buffer, options, MAXIMUM_ALLOWED, &hkey ))
 508                 continue;  /* ignore if it doesn't exist */
 509         }
 510         else
 511         {
 512             DWORD res = RegCreateKeyExW( root_key, buffer, 0, NULL, options,
 513                                          MAXIMUM_ALLOWED, NULL, &hkey, NULL );
 514             if (res == ERROR_ALREADY_EXISTS && (options & REG_OPTION_CREATE_LINK))
 515                 res = RegCreateKeyExW( root_key, buffer, 0, NULL, REG_OPTION_OPEN_LINK,
 516                                        MAXIMUM_ALLOWED, NULL, &hkey, NULL );
 517             if (res)
 518             {
 519                 ERR( "could not create key %p %s\n", root_key, debugstr_w(buffer) );
 520                 continue;
 521             }
 522         }
 523         TRACE( "key %p %s\n", root_key, debugstr_w(buffer) );
 524
 525         /* get value name */
 526         if (!SetupGetStringFieldW( &context, 3, buffer, ARRAY_SIZE( buffer ), NULL ))
 527             *buffer = 0;
 528
 529         /* and now do it */
 530         if (!do_reg_operation( hkey, buffer, &context, flags ))
 531         {
 532             RegCloseKey( hkey );
 533             return FALSE;
 534         }
 535         RegCloseKey( hkey );
 536     }
 537     return TRUE;
 538 }
 539
 540
 541 /***********************************************************************
 542  *            do_register_dll
 543  *
 544  * Register or unregister a dll.
 545  */
 546 static BOOL do_register_dll( struct register_dll_info *info, const WCHAR *path,
 547                              INT flags, INT timeout, const WCHAR *args )
 548 {
 549     HMODULE module;
 550     HRESULT res;
 551     SP_REGISTER_CONTROL_STATUSW status;
 552     IMAGE_NT_HEADERS *nt;
 553
 554     status.cbSize = sizeof(status);
 555     status.FileName = path;
 556     status.FailureCode = SPREG_SUCCESS;
 557     status.Win32Error = ERROR_SUCCESS;
 558
 559     if (info->callback)
 560     {
 561         switch(info->callback( info->callback_context, SPFILENOTIFY_STARTREGISTRATION,
 562                                (UINT_PTR)&status, !info->unregister ))
 563         {
 564         case FILEOP_ABORT:
 565             SetLastError( ERROR_OPERATION_ABORTED );
 566             return FALSE;
 567         case FILEOP_SKIP:
 568             return TRUE;
 569         case FILEOP_DOIT:
 570             break;
 571         }
 572     }
 573
 574     if (!(module = LoadLibraryExW( path, 0, LOAD_WITH_ALTERED_SEARCH_PATH )))
 575     {
 576         WARN( "could not load %s\n", debugstr_w(path) );
 577         status.FailureCode = SPREG_LOADLIBRARY;
 578         status.Win32Error = GetLastError();
 579         goto done;
 580     }
 581
 582     if ((nt = RtlImageNtHeader( module )) && !(nt->FileHeader.Characteristics & IMAGE_FILE_DLL))
 583     {
 584         /* file is an executable, not a dll */
 585         STARTUPINFOW startup;
 586         PROCESS_INFORMATION process_info;
 587         WCHAR *cmd_line;
 588         BOOL res;
 589         DWORD len;
 590
 591         FreeLibrary( module );
 592         module = NULL;
 593         if (!args) args = L"/RegServer";
 594         len = lstrlenW(path) + lstrlenW(args) + 4;
 595         cmd_line = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
 596         swprintf( cmd_line, len, L"\"%s\" %s", path, args );
 597         memset( &startup, 0, sizeof(startup) );
 598         startup.cb = sizeof(startup);
 599         TRACE( "executing %s\n", debugstr_w(cmd_line) );
 600         res = CreateProcessW( path, cmd_line, NULL, NULL, FALSE, 0, NULL, NULL, &startup, &process_info );
 601         HeapFree( GetProcessHeap(), 0, cmd_line );
 602         if (!res)
 603         {
 604             status.FailureCode = SPREG_LOADLIBRARY;
 605             status.Win32Error = GetLastError();
 606             goto done;
 607         }
 608         CloseHandle( process_info.hThread );
 609
 610         if (WaitForSingleObject( process_info.hProcess, timeout*1000 ) == WAIT_TIMEOUT)
 611         {
 612             /* timed out, kill the process */
 613             TerminateProcess( process_info.hProcess, 1 );
 614             status.FailureCode = SPREG_TIMEOUT;
 615             status.Win32Error = ERROR_TIMEOUT;
 616         }
 617         CloseHandle( process_info.hProcess );
 618         goto done;
 619     }
 620
 621     if (flags & FLG_REGSVR_DLLREGISTER)
 622     {
 623         const char *entry_point = info->unregister ? "DllUnregisterServer" : "DllRegisterServer";
 624         HRESULT (WINAPI *func)(void) = (void *)GetProcAddress( module, entry_point );
 625
 626         if (!func)
 627         {
 628             status.FailureCode = SPREG_GETPROCADDR;
 629             status.Win32Error = GetLastError();
 630             goto done;
 631         }
 632
 633         TRACE( "calling %s in %s\n", entry_point, debugstr_w(path) );
 634         res = func();
 635
 636         if (FAILED(res))
 637         {
 638             WARN( "calling %s in %s returned error %lx\n", entry_point, debugstr_w(path), res );
 639             status.FailureCode = SPREG_REGSVR;
 640             status.Win32Error = res;
 641             goto done;
 642         }
 643     }
 644
 645     if (flags & FLG_REGSVR_DLLINSTALL)
 646     {
 647         HRESULT (WINAPI *func)(BOOL,LPCWSTR) = (void *)GetProcAddress( module, "DllInstall" );
 648
 649         if (!func)
 650         {
 651             status.FailureCode = SPREG_GETPROCADDR;
 652             status.Win32Error = GetLastError();
 653             goto done;
 654         }
 655
 656         TRACE( "calling DllInstall(%d,%s) in %s\n",
 657                !info->unregister, debugstr_w(args), debugstr_w(path) );
 658         res = func( !info->unregister, args );
 659
 660         if (FAILED(res))
 661         {
 662             WARN( "calling DllInstall in %s returned error %lx\n", debugstr_w(path), res );
 663             status.FailureCode = SPREG_REGSVR;
 664             status.Win32Error = res;
 665             goto done;
 666         }
 667     }
 668
 669 done:
 670     if (module)
 671     {
 672         if (info->modules_count >= info->modules_size)
 673         {
 674             int new_size = max( 32, info->modules_size * 2 );
 675             HMODULE *new = info->modules ?
 676                 HeapReAlloc( GetProcessHeap(), 0, info->modules, new_size * sizeof(*new) ) :
 677                 HeapAlloc( GetProcessHeap(), 0, new_size * sizeof(*new) );
 678             if (new)
 679             {
 680                 info->modules_size = new_size;
 681                 info->modules = new;
 682             }
 683         }
 684         if (info->modules_count < info->modules_size) info->modules[info->modules_count++] = module;
 685         else FreeLibrary( module );
 686     }
 687     if (info->callback) info->callback( info->callback_context, SPFILENOTIFY_ENDREGISTRATION,
 688                                         (UINT_PTR)&status, !info->unregister );
 689     return TRUE;
 690 }
 691
 692
 693 /***********************************************************************
 694  *            register_dlls_callback
 695  *
 696  * Called once for each RegisterDlls entry in a given section.
 697  */
 698 static BOOL register_dlls_callback( HINF hinf, PCWSTR field, void *arg )
 699 {
 700     struct register_dll_info *info = arg;
 701     INFCONTEXT context;
 702     BOOL ret = TRUE;
 703     BOOL ok = SetupFindFirstLineW( hinf, field, NULL, &context );
 704
 705     for (; ok; ok = SetupFindNextLine( &context, &context ))
 706     {
 707         WCHAR *path, *args, *p;
 708         WCHAR buffer[MAX_INF_STRING_LENGTH];
 709         INT flags, timeout;
 710
 711         /* get directory */
 712         if (!(path = PARSER_get_dest_dir( &context ))) continue;
 713
 714         /* get dll name */
 715         if (!SetupGetStringFieldW( &context, 3, buffer, ARRAY_SIZE( buffer ), NULL ))
 716             goto done;
 717         if (!(p = HeapReAlloc( GetProcessHeap(), 0, path,
 718                                (lstrlenW(path) + lstrlenW(buffer) + 2) * sizeof(WCHAR) ))) goto done;
 719         path = p;
 720         p += lstrlenW(p);
 721         if (p == path || p[-1] != '\\') *p++ = '\\';
 722         lstrcpyW( p, buffer );
 723
 724         /* get flags */
 725         if (!SetupGetIntField( &context, 4, &flags )) flags = 0;
 726
 727         /* get timeout */
 728         if (!SetupGetIntField( &context, 5, &timeout )) timeout = 60;
 729
 730         /* get command line */
 731         args = NULL;
 732         if (SetupGetStringFieldW( &context, 6, buffer, ARRAY_SIZE( buffer ), NULL ))
 733             args = buffer;
 734
 735         ret = do_register_dll( info, path, flags, timeout, args );
 736
 737     done:
 738         HeapFree( GetProcessHeap(), 0, path );
 739         if (!ret) break;
 740     }
 741     return ret;
 742 }
 743
 744 /***********************************************************************
 745  *            fake_dlls_callback
 746  *
 747  * Called once for each WineFakeDlls entry in a given section.
 748  */
 749 static BOOL fake_dlls_callback( HINF hinf, PCWSTR field, void *arg )
 750 {
 751     INFCONTEXT context;
 752     BOOL ok = SetupFindFirstLineW( hinf, field, NULL, &context );
 753
 754     for (; ok; ok = SetupFindNextLine( &context, &context ))
 755     {
 756         WCHAR *path, *p;
 757         WCHAR buffer[MAX_INF_STRING_LENGTH];
 758
 759         /* get directory */
 760         if (!(path = PARSER_get_dest_dir( &context ))) continue;
 761
 762         /* get dll name */
 763         if (!SetupGetStringFieldW( &context, 3, buffer, ARRAY_SIZE( buffer ), NULL ))
 764             goto done;
 765         if (!(p = HeapReAlloc( GetProcessHeap(), 0, path,
 766                                (lstrlenW(path) + lstrlenW(buffer) + 2) * sizeof(WCHAR) ))) goto done;
 767         path = p;
 768         p += lstrlenW(p);
 769         if (p == path || p[-1] != '\\') *p++ = '\\';
 770         lstrcpyW( p, buffer );
 771
 772         /* get source dll */
 773         if (SetupGetStringFieldW( &context, 4, buffer, ARRAY_SIZE( buffer ), NULL ))
 774             p = buffer;  /* otherwise use target base name as default source */
 775
 776         create_fake_dll( path, p );  /* ignore errors */
 777
 778     done:
 779         HeapFree( GetProcessHeap(), 0, path );
 780     }
 781     return TRUE;
 782 }
 783
 784 /***********************************************************************
 785  *            update_ini_callback
 786  *
 787  * Called once for each UpdateInis entry in a given section.
 788  */
 789 static BOOL update_ini_callback( HINF hinf, PCWSTR field, void *arg )
 790 {
 791     INFCONTEXT context;
 792
 793     BOOL ok = SetupFindFirstLineW( hinf, field, NULL, &context );
 794
 795     for (; ok; ok = SetupFindNextLine( &context, &context ))
 796     {
 797         WCHAR buffer[MAX_INF_STRING_LENGTH];
 798         WCHAR  filename[MAX_INF_STRING_LENGTH];
 799         WCHAR  section[MAX_INF_STRING_LENGTH];
 800         WCHAR  entry[MAX_INF_STRING_LENGTH];
 801         WCHAR  string[MAX_INF_STRING_LENGTH];
 802         LPWSTR divider;
 803
 804         if (!SetupGetStringFieldW( &context, 1, filename, ARRAY_SIZE( filename ), NULL ))
 805             continue;
 806
 807         if (!SetupGetStringFieldW( &context, 2, section, ARRAY_SIZE( section ), NULL ))
 808             continue;
 809
 810         if (!SetupGetStringFieldW( &context, 4, buffer, ARRAY_SIZE( buffer ), NULL ))
 811             continue;
 812
 813         divider = wcschr(buffer,'=');
 814         if (divider)
 815         {
 816             *divider = 0;
 817             lstrcpyW(entry,buffer);
 818             divider++;
 819             lstrcpyW(string,divider);
 820         }
 821         else
 822         {
 823             lstrcpyW(entry,buffer);
 824             string[0]=0;
 825         }
 826
 827         TRACE("Writing %s = %s in %s of file %s\n",debugstr_w(entry),
 828                debugstr_w(string),debugstr_w(section),debugstr_w(filename));
 829         WritePrivateProfileStringW(section,entry,string,filename);
 830
 831     }
 832     return TRUE;
 833 }
 834
 835 static BOOL update_ini_fields_callback( HINF hinf, PCWSTR field, void *arg )
 836 {
 837     FIXME( "should update ini fields %s\n", debugstr_w(field) );
 838     return TRUE;
 839 }
 840
 841 static BOOL ini2reg_callback( HINF hinf, PCWSTR field, void *arg )
 842 {
 843     FIXME( "should do ini2reg %s\n", debugstr_w(field) );
 844     return TRUE;
 845 }
 846
 847 static BOOL logconf_callback( HINF hinf, PCWSTR field, void *arg )
 848 {
 849     FIXME( "should do logconf %s\n", debugstr_w(field) );
 850     return TRUE;
 851 }
 852
 853 static BOOL bitreg_callback( HINF hinf, PCWSTR field, void *arg )
 854 {
 855     FIXME( "should do bitreg %s\n", debugstr_w(field) );
 856     return TRUE;
 857 }
 858
 859 static BOOL profile_items_callback( HINF hinf, PCWSTR field, void *arg )
 860 {
 861     WCHAR lnkpath[MAX_PATH];
 862     LPWSTR cmdline=NULL, lnkpath_end;
 863     DWORD name_size;
 864     INFCONTEXT name_context, context;
 865     int attrs=0;
 866
 867     TRACE( "(%s)\n", debugstr_w(field) );
 868
 869     if (SetupFindFirstLineW( hinf, field, L"Name", &name_context ))
 870     {
 871         SetupGetIntField( &name_context, 2, &attrs );
 872         if (attrs & ~FLG_PROFITEM_GROUP) FIXME( "unhandled attributes: %x\n", attrs );
 873     }
 874     else return TRUE;
 875
 876     /* calculate filename */
 877     SHGetFolderPathW( NULL, CSIDL_COMMON_PROGRAMS, NULL, SHGFP_TYPE_CURRENT, lnkpath );
 878     lnkpath_end = lnkpath + lstrlenW(lnkpath);
 879     if (lnkpath_end[-1] != '\\') *lnkpath_end++ = '\\';
 880
 881     if (!(attrs & FLG_PROFITEM_GROUP) && SetupFindFirstLineW( hinf, field, L"SubDir", &context ))
 882     {
 883         DWORD subdir_size;
 884
 885         if (!SetupGetStringFieldW( &context, 1, lnkpath_end, (lnkpath+MAX_PATH)-lnkpath_end, &subdir_size ))
 886             return TRUE;
 887
 888         lnkpath_end += subdir_size - 1;
 889         if (lnkpath_end[-1] != '\\') *lnkpath_end++ = '\\';
 890     }
 891
 892     if (!SetupGetStringFieldW( &name_context, 1, lnkpath_end, (lnkpath+MAX_PATH)-lnkpath_end, &name_size ))
 893         return TRUE;
 894
 895     lnkpath_end += name_size - 1;
 896
 897     if (attrs & FLG_PROFITEM_GROUP)
 898     {
 899         SHPathPrepareForWriteW( NULL, NULL, lnkpath, SHPPFW_DIRCREATE );
 900     }
 901     else
 902     {
 903         IShellLinkW* shelllink=NULL;
 904         IPersistFile* persistfile=NULL;
 905         HRESULT initresult=E_FAIL;
 906
 907         if (lnkpath+MAX_PATH < lnkpath_end + 5) return TRUE;
 908         lstrcpyW( lnkpath_end, L".lnk" );
 909
 910         TRACE( "link path: %s\n", debugstr_w(lnkpath) );
 911
 912         /* calculate command line */
 913         if (SetupFindFirstLineW( hinf, field, L"CmdLine", &context ))
 914         {
 915             unsigned int dir_len=0;
 916             DWORD subdir_size=0, filename_size=0;
 917             int dirid=0;
 918             LPCWSTR dir;
 919             LPWSTR cmdline_end;
 920
 921             SetupGetIntField( &context, 1, &dirid );
 922             dir = DIRID_get_string( dirid );
 923
 924             if (dir) dir_len = lstrlenW(dir);
 925
 926             SetupGetStringFieldW( &context, 2, NULL, 0, &subdir_size );
 927             SetupGetStringFieldW( &context, 3, NULL, 0, &filename_size );
 928
 929             if (dir_len && filename_size)
 930             {
 931                 cmdline = cmdline_end = HeapAlloc( GetProcessHeap(), 0, sizeof(WCHAR) * (dir_len+subdir_size+filename_size+1) );
 932
 933                 lstrcpyW( cmdline_end, dir );
 934                 cmdline_end += dir_len;
 935                 if (cmdline_end[-1] != '\\') *cmdline_end++ = '\\';
 936
 937                 if (subdir_size)
 938                 {
 939                     SetupGetStringFieldW( &context, 2, cmdline_end, subdir_size, NULL );
 940                     cmdline_end += subdir_size-1;
 941                     if (cmdline_end[-1] != '\\') *cmdline_end++ = '\\';
 942                 }
 943                 SetupGetStringFieldW( &context, 3, cmdline_end, filename_size, NULL );
 944                 TRACE( "cmdline: %s\n", debugstr_w(cmdline));
 945             }
 946         }
 947
 948         if (!cmdline) return TRUE;
 949
 950         initresult = CoInitialize(NULL);
 951
 952         if (FAILED(CoCreateInstance( &CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
 953                                      &IID_IShellLinkW, (LPVOID*)&shelllink )))
 954             goto done;
 955
 956         IShellLinkW_SetPath( shelllink, cmdline );
 957         SHPathPrepareForWriteW( NULL, NULL, lnkpath, SHPPFW_DIRCREATE|SHPPFW_IGNOREFILENAME );
 958         if (SUCCEEDED(IShellLinkW_QueryInterface( shelllink, &IID_IPersistFile, (LPVOID*)&persistfile)))
 959         {
 960             TRACE( "writing link: %s\n", debugstr_w(lnkpath) );
 961             IPersistFile_Save( persistfile, lnkpath, FALSE );
 962             IPersistFile_Release( persistfile );
 963         }
 964         IShellLinkW_Release( shelllink );
 965
 966     done:
 967         if (SUCCEEDED(initresult)) CoUninitialize();
 968         HeapFree( GetProcessHeap(), 0, cmdline );
 969     }
 970
 971     return TRUE;
 972 }
 973
 974 static BOOL copy_inf_callback( HINF hinf, PCWSTR field, void *arg )
 975 {
 976     FIXME( "should do copy inf %s\n", debugstr_w(field) );
 977     return TRUE;
 978 }
 979
 980
 981 /***********************************************************************
 982  *            iterate_section_fields
 983  *
 984  * Iterate over all fields of a certain key of a certain section
 985  */
 986 static BOOL iterate_section_fields( HINF hinf, PCWSTR section, PCWSTR key,
 987                                     iterate_fields_func callback, void *arg )
 988 {
 989     WCHAR static_buffer[200];
 990     WCHAR *buffer = static_buffer;
 991     DWORD size = ARRAY_SIZE( static_buffer );
 992     INFCONTEXT context;
 993     BOOL ret = FALSE;
 994
 995     BOOL ok = SetupFindFirstLineW( hinf, section, key, &context );
 996     while (ok)
 997     {
 998         UINT i, count = SetupGetFieldCount( &context );
 999         for (i = 1; i <= count; i++)
1000         {
1001             if (!(buffer = get_field_string( &context, i, buffer, static_buffer, &size )))
1002                 goto done;
1003             if (!callback( hinf, buffer, arg ))
1004             {
1005                 WARN("callback failed for %s %s err %ld\n",
1006                      debugstr_w(section), debugstr_w(buffer), GetLastError() );
1007                 goto done;
1008             }
1009         }
1010         ok = SetupFindNextMatchLineW( &context, key, &context );
1011     }
1012     ret = TRUE;
1013  done:
1014     if (buffer != static_buffer) HeapFree( GetProcessHeap(), 0, buffer );
1015     return ret;
1016 }
1017
1018
1019 /***********************************************************************
1020  *            SetupInstallFilesFromInfSectionA   (SETUPAPI.@)
1021  */
1022 BOOL WINAPI SetupInstallFilesFromInfSectionA( HINF hinf, HINF hlayout, HSPFILEQ queue,
1023                                               PCSTR section, PCSTR src_root, UINT flags )
1024 {
1025     UNICODE_STRING sectionW;
1026     BOOL ret = FALSE;
1027
1028     if (!RtlCreateUnicodeStringFromAsciiz( &sectionW, section ))
1029     {
1030         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1031         return FALSE;
1032     }
1033     if (!src_root)
1034         ret = SetupInstallFilesFromInfSectionW( hinf, hlayout, queue, sectionW.Buffer,
1035                                                 NULL, flags );
1036     else
1037     {
1038         UNICODE_STRING srcW;
1039         if (RtlCreateUnicodeStringFromAsciiz( &srcW, src_root ))
1040         {
1041             ret = SetupInstallFilesFromInfSectionW( hinf, hlayout, queue, sectionW.Buffer,
1042                                                     srcW.Buffer, flags );
1043             RtlFreeUnicodeString( &srcW );
1044         }
1045         else SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1046     }
1047     RtlFreeUnicodeString( &sectionW );
1048     return ret;
1049 }
1050
1051
1052 /***********************************************************************
1053  *            SetupInstallFilesFromInfSectionW   (SETUPAPI.@)
1054  */
1055 BOOL WINAPI SetupInstallFilesFromInfSectionW( HINF hinf, HINF hlayout, HSPFILEQ queue,
1056                                               PCWSTR section, PCWSTR src_root, UINT flags )
1057 {
1058     struct files_callback_info info;
1059
1060     info.queue      = queue;
1061     info.src_root   = src_root;
1062     info.copy_flags = flags;
1063     info.layout     = hlayout;
1064     return iterate_section_fields( hinf, section, L"CopyFiles", copy_files_callback, &info ) &&
1065            iterate_section_fields( hinf, section, L"DelFiles", delete_files_callback, &info ) &&
1066            iterate_section_fields( hinf, section, L"RenFiles", rename_files_callback, &info );
1067 }
1068
1069
1070 /***********************************************************************
1071  *            SetupInstallFromInfSectionA   (SETUPAPI.@)
1072  */
1073 BOOL WINAPI SetupInstallFromInfSectionA( HWND owner, HINF hinf, PCSTR section, UINT flags,
1074                                          HKEY key_root, PCSTR src_root, UINT copy_flags,
1075                                          PSP_FILE_CALLBACK_A callback, PVOID context,
1076                                          HDEVINFO devinfo, PSP_DEVINFO_DATA devinfo_data )
1077 {
1078     UNICODE_STRING sectionW, src_rootW;
1079     struct callback_WtoA_context ctx;
1080     BOOL ret = FALSE;
1081
1082     src_rootW.Buffer = NULL;
1083     if (src_root && !RtlCreateUnicodeStringFromAsciiz( &src_rootW, src_root ))
1084     {
1085         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1086         return FALSE;
1087     }
1088
1089     if (RtlCreateUnicodeStringFromAsciiz( &sectionW, section ))
1090     {
1091         ctx.orig_context = context;
1092         ctx.orig_handler = callback;
1093         ret = SetupInstallFromInfSectionW( owner, hinf, sectionW.Buffer, flags, key_root,
1094                                            src_rootW.Buffer, copy_flags, QUEUE_callback_WtoA,
1095                                            &ctx, devinfo, devinfo_data );
1096         RtlFreeUnicodeString( &sectionW );
1097     }
1098     else SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1099
1100     RtlFreeUnicodeString( &src_rootW );
1101     return ret;
1102 }
1103
1104
1105 /***********************************************************************
1106  *            SetupInstallFromInfSectionW   (SETUPAPI.@)
1107  */
1108 BOOL WINAPI SetupInstallFromInfSectionW( HWND owner, HINF hinf, PCWSTR section, UINT flags,
1109                                          HKEY key_root, PCWSTR src_root, UINT copy_flags,
1110                                          PSP_FILE_CALLBACK_W callback, PVOID context,
1111                                          HDEVINFO devinfo, PSP_DEVINFO_DATA devinfo_data )
1112 {
1113     BOOL ret;
1114     int i;
1115
1116     if (flags & SPINST_REGSVR)
1117     {
1118         if (iterate_section_fields( hinf, section, L"WineFakeDlls", fake_dlls_callback, NULL ))
1119             cleanup_fake_dlls();
1120         else
1121             return FALSE;
1122     }
1123     if (flags & SPINST_FILES)
1124     {
1125         HSPFILEQ queue;
1126
1127         if (!(queue = SetupOpenFileQueue())) return FALSE;
1128         ret = (SetupInstallFilesFromInfSectionW( hinf, NULL, queue, section, src_root, copy_flags ) &&
1129                SetupCommitFileQueueW( owner, queue, callback, context ));
1130         SetupCloseFileQueue( queue );
1131         if (!ret) return FALSE;
1132     }
1133     if (flags & SPINST_INIFILES)
1134     {
1135         if (!iterate_section_fields( hinf, section, L"UpdateInis", update_ini_callback, NULL ) ||
1136             !iterate_section_fields( hinf, section, L"UpdateIniFields",
1137                                      update_ini_fields_callback, NULL ))
1138             return FALSE;
1139     }
1140     if (flags & SPINST_INI2REG)
1141     {
1142         if (!iterate_section_fields( hinf, section, L"Ini2Reg", ini2reg_callback, NULL ))
1143             return FALSE;
1144     }
1145     if (flags & SPINST_LOGCONFIG)
1146     {
1147         if (!iterate_section_fields( hinf, section, L"LogConf", logconf_callback, NULL ))
1148             return FALSE;
1149     }
1150     if (flags & SPINST_REGSVR)
1151     {
1152         struct register_dll_info info = { .unregister = FALSE };
1153         HRESULT hr;
1154
1155         if (flags & SPINST_REGISTERCALLBACKAWARE)
1156         {
1157             info.callback         = callback;
1158             info.callback_context = context;
1159         }
1160
1161         hr = CoInitialize(NULL);
1162
1163         ret = iterate_section_fields( hinf, section, L"RegisterDlls", register_dlls_callback, &info );
1164         for (i = 0; i < info.modules_count; i++) FreeLibrary( info.modules[i] );
1165
1166         if (SUCCEEDED(hr))
1167             CoUninitialize();
1168
1169         HeapFree( GetProcessHeap(), 0, info.modules );
1170         if (!ret) return FALSE;
1171     }
1172     if (flags & SPINST_UNREGSVR)
1173     {
1174         struct register_dll_info info = { .unregister = TRUE };
1175         HRESULT hr;
1176
1177         if (flags & SPINST_REGISTERCALLBACKAWARE)
1178         {
1179             info.callback         = callback;
1180             info.callback_context = context;
1181         }
1182
1183         hr = CoInitialize(NULL);
1184
1185         ret = iterate_section_fields( hinf, section, L"UnregisterDlls", register_dlls_callback, &info );
1186         for (i = 0; i < info.modules_count; i++) FreeLibrary( info.modules[i] );
1187
1188         if (SUCCEEDED(hr))
1189             CoUninitialize();
1190
1191         HeapFree( GetProcessHeap(), 0, info.modules );
1192         if (!ret) return FALSE;
1193     }
1194     if (flags & SPINST_REGISTRY)
1195     {
1196         struct registry_callback_info info;
1197
1198         info.default_root = key_root;
1199         info.delete = TRUE;
1200         if (!iterate_section_fields( hinf, section, L"DelReg", registry_callback, &info ))
1201             return FALSE;
1202         info.delete = FALSE;
1203         if (!iterate_section_fields( hinf, section, L"AddReg", registry_callback, &info ))
1204             return FALSE;
1205     }
1206     if (flags & SPINST_BITREG)
1207     {
1208         if (!iterate_section_fields( hinf, section, L"BitReg", bitreg_callback, NULL ))
1209             return FALSE;
1210     }
1211     if (flags & SPINST_PROFILEITEMS)
1212     {
1213         if (!iterate_section_fields( hinf, section, L"ProfileItems", profile_items_callback, NULL ))
1214             return FALSE;
1215     }
1216     if (flags & SPINST_COPYINF)
1217     {
1218         if (!iterate_section_fields( hinf, section, L"CopyINF", copy_inf_callback, NULL ))
1219             return FALSE;
1220     }
1221
1222     SetLastError(ERROR_SUCCESS);
1223     return TRUE;
1224 }
1225
1226
1227 /***********************************************************************
1228  *              InstallHinfSectionW  (SETUPAPI.@)
1229  *
1230  * NOTE: 'cmdline' is <section> <mode> <path> from
1231  *   RUNDLL32.EXE SETUPAPI.DLL,InstallHinfSection <section> <mode> <path>
1232  */
1233 void WINAPI InstallHinfSectionW( HWND hwnd, HINSTANCE handle, LPCWSTR cmdline, INT show )
1234 {
1235 #ifdef __i386__
1236     static const WCHAR nt_platformW[] = L".ntx86";
1237 #elif defined(__x86_64__)
1238     static const WCHAR nt_platformW[] = L".ntamd64";
1239 #elif defined(__arm__)
1240     static const WCHAR nt_platformW[] = L".ntarm";
1241 #elif defined(__aarch64__)
1242     static const WCHAR nt_platformW[] = L".ntarm64";
1243 #else  /* FIXME: other platforms */
1244     static const WCHAR nt_platformW[] = L".nt";
1245 #endif
1246
1247     WCHAR *s, *path, section[MAX_PATH + ARRAY_SIZE( nt_platformW ) + ARRAY_SIZE( L".Services" )];
1248     void *callback_context;
1249     UINT mode;
1250     HINF hinf;
1251
1252     TRACE("hwnd %p, handle %p, cmdline %s\n", hwnd, handle, debugstr_w(cmdline));
1253
1254     lstrcpynW( section, cmdline, MAX_PATH );
1255
1256     if (!(s = wcschr( section, ' ' ))) return;
1257     *s++ = 0;
1258     while (*s == ' ') s++;
1259     mode = wcstol( s, NULL, 10 );
1260
1261     /* quoted paths are not allowed on native, the rest of the command line is taken as the path */
1262     if (!(s = wcschr( s, ' ' ))) return;
1263     while (*s == ' ') s++;
1264     path = s;
1265
1266     hinf = SetupOpenInfFileW( path, NULL, INF_STYLE_WIN4, NULL );
1267     if (hinf == INVALID_HANDLE_VALUE) return;
1268
1269     if (!(GetVersion() & 0x80000000))
1270     {
1271         INFCONTEXT context;
1272
1273         /* check for <section>.ntx86 (or corresponding name for the current platform)
1274          * and then <section>.nt */
1275         s = section + lstrlenW(section);
1276         lstrcpyW( s, nt_platformW );
1277         if (!(SetupFindFirstLineW( hinf, section, NULL, &context )))
1278         {
1279             lstrcpyW( s, L".nt" );
1280             if (!(SetupFindFirstLineW( hinf, section, NULL, &context ))) *s = 0;
1281         }
1282         if (*s) TRACE( "using section %s instead\n", debugstr_w(section) );
1283     }
1284
1285     callback_context = SetupInitDefaultQueueCallback( hwnd );
1286     SetupInstallFromInfSectionW( hwnd, hinf, section, SPINST_ALL, NULL, NULL, SP_COPY_NEWER,
1287                                  SetupDefaultQueueCallbackW, callback_context,
1288                                  NULL, NULL );
1289     SetupTermDefaultQueueCallback( callback_context );
1290     lstrcatW( section, L".Services" );
1291     SetupInstallServicesFromInfSectionW( hinf, section, 0 );
1292     SetupCloseInfFile( hinf );
1293
1294     /* FIXME: should check the mode and maybe reboot */
1295     /* there isn't much point in doing that since we */
1296     /* don't yet handle deferred file copies anyway. */
1297     if (mode & 7) TRACE( "should consider reboot, mode %u\n", mode );
1298 }
1299
1300
1301 /***********************************************************************
1302  *              InstallHinfSectionA  (SETUPAPI.@)
1303  */
1304 void WINAPI InstallHinfSectionA( HWND hwnd, HINSTANCE handle, LPCSTR cmdline, INT show )
1305 {
1306     UNICODE_STRING cmdlineW;
1307
1308     if (RtlCreateUnicodeStringFromAsciiz( &cmdlineW, cmdline ))
1309     {
1310         InstallHinfSectionW( hwnd, handle, cmdlineW.Buffer, show );
1311         RtlFreeUnicodeString( &cmdlineW );
1312     }
1313 }
1314
1315
1316 /***********************************************************************
1317  *            add_service
1318  *
1319  * Create a new service. Helper for SetupInstallServicesFromInfSectionW.
1320  */
1321 static BOOL add_service( SC_HANDLE scm, HINF hinf, const WCHAR *name, const WCHAR *section, DWORD flags )
1322 {
1323     struct registry_callback_info info;
1324     SC_HANDLE service;
1325     INFCONTEXT context;
1326     SERVICE_DESCRIPTIONW descr;
1327     WCHAR *display_name, *start_name, *load_order, *binary_path;
1328     INT service_type = 0, start_type = 0, error_control = 0;
1329     DWORD size;
1330     HKEY hkey;
1331
1332     /* first the mandatory fields */
1333
1334     if (!SetupFindFirstLineW( hinf, section, L"ServiceType", &context ) ||
1335         !SetupGetIntField( &context, 1, &service_type ))
1336     {
1337         SetLastError( ERROR_BAD_SERVICE_INSTALLSECT );
1338         return FALSE;
1339     }
1340     if (!SetupFindFirstLineW( hinf, section, L"StartType", &context ) ||
1341         !SetupGetIntField( &context, 1, &start_type ))
1342     {
1343         SetLastError( ERROR_BAD_SERVICE_INSTALLSECT );
1344         return FALSE;
1345     }
1346     if (!SetupFindFirstLineW( hinf, section, L"ErrorControl", &context ) ||
1347         !SetupGetIntField( &context, 1, &error_control ))
1348     {
1349         SetLastError( ERROR_BAD_SERVICE_INSTALLSECT );
1350         return FALSE;
1351     }
1352     if (!(binary_path = dup_section_line_field( hinf, section, L"ServiceBinary", 1 )))
1353     {
1354         SetLastError( ERROR_BAD_SERVICE_INSTALLSECT );
1355         return FALSE;
1356     }
1357
1358     /* now the optional fields */
1359
1360     display_name = dup_section_line_field( hinf, section, L"DisplayName", 1 );
1361     start_name = dup_section_line_field( hinf, section, L"StartName", 1 );
1362     load_order = dup_section_line_field( hinf, section, L"LoadOrderGroup", 1 );
1363     descr.lpDescription = dup_section_line_field( hinf, section, L"Description", 1 );
1364
1365     /* FIXME: Dependencies field */
1366     /* FIXME: Security field */
1367
1368     TRACE( "service %s display %s type %x start %x error %x binary %s order %s startname %s flags %lx\n",
1369            debugstr_w(name), debugstr_w(display_name), service_type, start_type, error_control,
1370            debugstr_w(binary_path), debugstr_w(load_order), debugstr_w(start_name), flags );
1371
1372     service = CreateServiceW( scm, name, display_name, SERVICE_ALL_ACCESS,
1373                               service_type, start_type, error_control, binary_path,
1374                               load_order, NULL, NULL, start_name, NULL );
1375     if (service)
1376     {
1377         if (descr.lpDescription) ChangeServiceConfig2W( service, SERVICE_CONFIG_DESCRIPTION, &descr );
1378     }
1379     else
1380     {
1381         if (GetLastError() != ERROR_SERVICE_EXISTS) goto done;
1382         service = OpenServiceW( scm, name, SERVICE_QUERY_CONFIG|SERVICE_CHANGE_CONFIG|SERVICE_START );
1383         if (!service) goto done;
1384
1385         if (flags & (SPSVCINST_NOCLOBBER_DISPLAYNAME | SPSVCINST_NOCLOBBER_STARTTYPE |
1386                      SPSVCINST_NOCLOBBER_ERRORCONTROL | SPSVCINST_NOCLOBBER_LOADORDERGROUP))
1387         {
1388             QUERY_SERVICE_CONFIGW *config = NULL;
1389
1390             if (!QueryServiceConfigW( service, NULL, 0, &size ) &&
1391                 GetLastError() == ERROR_INSUFFICIENT_BUFFER)
1392                 config = HeapAlloc( GetProcessHeap(), 0, size );
1393             if (config && QueryServiceConfigW( service, config, size, &size ))
1394             {
1395                 if (flags & SPSVCINST_NOCLOBBER_STARTTYPE) start_type = config->dwStartType;
1396                 if (flags & SPSVCINST_NOCLOBBER_ERRORCONTROL) error_control = config->dwErrorControl;
1397                 if (flags & SPSVCINST_NOCLOBBER_DISPLAYNAME)
1398                 {
1399                     HeapFree( GetProcessHeap(), 0, display_name );
1400                     display_name = strdupW( config->lpDisplayName );
1401                 }
1402                 if (flags & SPSVCINST_NOCLOBBER_LOADORDERGROUP)
1403                 {
1404                     HeapFree( GetProcessHeap(), 0, load_order );
1405                     load_order = strdupW( config->lpLoadOrderGroup );
1406                 }
1407             }
1408             HeapFree( GetProcessHeap(), 0, config );
1409         }
1410         TRACE( "changing %s display %s type %x start %x error %x binary %s loadorder %s startname %s\n",
1411                debugstr_w(name), debugstr_w(display_name), service_type, start_type, error_control,
1412                debugstr_w(binary_path), debugstr_w(load_order), debugstr_w(start_name) );
1413
1414         ChangeServiceConfigW( service, service_type, start_type, error_control, binary_path,
1415                               load_order, NULL, NULL, start_name, NULL, display_name );
1416
1417         if (!(flags & SPSVCINST_NOCLOBBER_DESCRIPTION))
1418             ChangeServiceConfig2W( service, SERVICE_CONFIG_DESCRIPTION, &descr );
1419     }
1420
1421     /* execute the AddReg, DelReg and BitReg entries */
1422
1423     info.default_root = 0;
1424     if (!RegOpenKeyW( HKEY_LOCAL_MACHINE, L"System\\CurrentControlSet\\Services", &hkey ))
1425     {
1426         RegOpenKeyW( hkey, name, &info.default_root );
1427         RegCloseKey( hkey );
1428     }
1429     if (info.default_root)
1430     {
1431         info.delete = TRUE;
1432         iterate_section_fields( hinf, section, L"DelReg", registry_callback, &info );
1433         info.delete = FALSE;
1434         iterate_section_fields( hinf, section, L"AddReg", registry_callback, &info );
1435         RegCloseKey( info.default_root );
1436     }
1437     iterate_section_fields( hinf, section, L"BitReg", bitreg_callback, NULL );
1438
1439     if (flags & SPSVCINST_STARTSERVICE) StartServiceW( service, 0, NULL );
1440     CloseServiceHandle( service );
1441
1442 done:
1443     if (!service) WARN( "failed err %lu\n", GetLastError() );
1444     HeapFree( GetProcessHeap(), 0, binary_path );
1445     HeapFree( GetProcessHeap(), 0, display_name );
1446     HeapFree( GetProcessHeap(), 0, start_name );
1447     HeapFree( GetProcessHeap(), 0, load_order );
1448     HeapFree( GetProcessHeap(), 0, descr.lpDescription );
1449     return service != 0;
1450 }
1451
1452
1453 /***********************************************************************
1454  *            del_service
1455  *
1456  * Delete service. Helper for SetupInstallServicesFromInfSectionW.
1457  */
1458 static BOOL del_service( SC_HANDLE scm, HINF hinf, const WCHAR *name, DWORD flags )
1459 {
1460     BOOL ret;
1461     SC_HANDLE service;
1462     SERVICE_STATUS status;
1463
1464     if (!(service = OpenServiceW( scm, name, SERVICE_STOP | DELETE )))
1465     {
1466         if (GetLastError() == ERROR_SERVICE_DOES_NOT_EXIST) return TRUE;
1467         WARN( "cannot open %s err %lu\n", debugstr_w(name), GetLastError() );
1468         return FALSE;
1469     }
1470     if (flags & SPSVCINST_STOPSERVICE) ControlService( service, SERVICE_CONTROL_STOP, &status );
1471     TRACE( "deleting %s\n", debugstr_w(name) );
1472     ret = DeleteService( service );
1473     CloseServiceHandle( service );
1474     return ret;
1475 }
1476
1477
1478 /***********************************************************************
1479  *              SetupInstallServicesFromInfSectionW  (SETUPAPI.@)
1480  */
1481 BOOL WINAPI SetupInstallServicesFromInfSectionW( HINF hinf, PCWSTR section, DWORD flags )
1482 {
1483     WCHAR service_name[MAX_INF_STRING_LENGTH];
1484     WCHAR service_section[MAX_INF_STRING_LENGTH];
1485     SC_HANDLE scm;
1486     INFCONTEXT context;
1487     INT section_flags;
1488     BOOL ret = TRUE;
1489
1490     if (!SetupFindFirstLineW( hinf, section, NULL, &context ))
1491     {
1492         SetLastError( ERROR_SECTION_NOT_FOUND );
1493         return FALSE;
1494     }
1495     if (!(scm = OpenSCManagerW( NULL, NULL, SC_MANAGER_ALL_ACCESS ))) return FALSE;
1496
1497     if (SetupFindFirstLineW( hinf, section, L"AddService", &context ))
1498     {
1499         do
1500         {
1501             if (!SetupGetStringFieldW( &context, 1, service_name, MAX_INF_STRING_LENGTH, NULL ))
1502                 continue;
1503             if (!SetupGetIntField( &context, 2, &section_flags )) section_flags = 0;
1504             if (!SetupGetStringFieldW( &context, 3, service_section, MAX_INF_STRING_LENGTH, NULL ))
1505                 continue;
1506             if (!(ret = add_service( scm, hinf, service_name, service_section, section_flags | flags )))
1507                 goto done;
1508         } while (SetupFindNextMatchLineW( &context, L"AddService", &context ));
1509     }
1510
1511     if (SetupFindFirstLineW( hinf, section, L"DelService", &context ))
1512     {
1513         do
1514         {
1515             if (!SetupGetStringFieldW( &context, 1, service_name, MAX_INF_STRING_LENGTH, NULL ))
1516                 continue;
1517             if (!SetupGetIntField( &context, 2, &section_flags )) section_flags = 0;
1518             if (!(ret = del_service( scm, hinf, service_name, section_flags | flags ))) goto done;
1519         } while (SetupFindNextMatchLineW( &context, L"AddService", &context ));
1520     }
1521     if (ret) SetLastError( ERROR_SUCCESS );
1522  done:
1523     CloseServiceHandle( scm );
1524     return ret;
1525 }
1526
1527
1528 /***********************************************************************
1529  *              SetupInstallServicesFromInfSectionA  (SETUPAPI.@)
1530  */
1531 BOOL WINAPI SetupInstallServicesFromInfSectionA( HINF Inf, PCSTR SectionName, DWORD Flags)
1532 {
1533     UNICODE_STRING SectionNameW;
1534     BOOL ret = FALSE;
1535
1536     if (RtlCreateUnicodeStringFromAsciiz( &SectionNameW, SectionName ))
1537     {
1538         ret = SetupInstallServicesFromInfSectionW( Inf, SectionNameW.Buffer, Flags );
1539         RtlFreeUnicodeString( &SectionNameW );
1540     }
1541     else
1542         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1543
1544     return ret;
1545 }
1546
1547
1548 /***********************************************************************
1549  *              SetupGetInfFileListA  (SETUPAPI.@)
1550  */
1551 BOOL WINAPI SetupGetInfFileListA(PCSTR dir, DWORD style, PSTR buffer,
1552                                  DWORD insize, PDWORD outsize)
1553 {
1554     UNICODE_STRING dirW;
1555     PWSTR bufferW = NULL;
1556     BOOL ret = FALSE;
1557     DWORD outsizeA, outsizeW;
1558
1559     if ( dir )
1560         RtlCreateUnicodeStringFromAsciiz( &dirW, dir );
1561     else
1562         dirW.Buffer = NULL;
1563
1564     if ( buffer )
1565         bufferW = HeapAlloc( GetProcessHeap(), 0, insize * sizeof( WCHAR ));
1566
1567     ret = SetupGetInfFileListW( dirW.Buffer, style, bufferW, insize, &outsizeW);
1568
1569     if ( ret )
1570     {
1571         outsizeA = WideCharToMultiByte( CP_ACP, 0, bufferW, outsizeW,
1572                                         buffer, insize, NULL, NULL);
1573         if ( outsize ) *outsize = outsizeA;
1574     }
1575
1576     HeapFree( GetProcessHeap(), 0, bufferW );
1577     RtlFreeUnicodeString( &dirW );
1578     return ret;
1579 }
1580
1581
1582 /***********************************************************************
1583  *              SetupGetInfFileListW  (SETUPAPI.@)
1584  */
1585 BOOL WINAPI SetupGetInfFileListW(PCWSTR dir, DWORD style, PWSTR buffer,
1586                                  DWORD insize, PDWORD outsize)
1587 {
1588     WCHAR *filter, *fullname = NULL, *ptr = buffer;
1589     DWORD dir_len, name_len = 20, size ;
1590     WIN32_FIND_DATAW finddata;
1591     HANDLE hdl;
1592     if (style & ~( INF_STYLE_OLDNT | INF_STYLE_WIN4 |
1593                    INF_STYLE_CACHE_ENABLE | INF_STYLE_CACHE_DISABLE ))
1594     {
1595         FIXME( "unknown inf_style(s) 0x%lx\n",
1596                style & ~( INF_STYLE_OLDNT | INF_STYLE_WIN4 |
1597                          INF_STYLE_CACHE_ENABLE | INF_STYLE_CACHE_DISABLE ));
1598         if( outsize ) *outsize = 1;
1599         return TRUE;
1600     }
1601     if ((style & ( INF_STYLE_OLDNT | INF_STYLE_WIN4 )) == INF_STYLE_NONE)
1602     {
1603         FIXME( "inf_style INF_STYLE_NONE not handled\n" );
1604         if( outsize ) *outsize = 1;
1605         return TRUE;
1606     }
1607     if (style & ( INF_STYLE_CACHE_ENABLE | INF_STYLE_CACHE_DISABLE ))
1608         FIXME("ignored inf_style(s) %s %s\n",
1609               ( style & INF_STYLE_CACHE_ENABLE  ) ? "INF_STYLE_CACHE_ENABLE"  : "",
1610               ( style & INF_STYLE_CACHE_DISABLE ) ? "INF_STYLE_CACHE_DISABLE" : "");
1611     if( dir )
1612     {
1613         DWORD att;
1614         DWORD msize;
1615         dir_len = lstrlenW( dir );
1616         if ( !dir_len ) return FALSE;
1617         msize = ( 7 + dir_len )  * sizeof( WCHAR ); /* \\*.inf\0 */
1618         filter = HeapAlloc( GetProcessHeap(), 0, msize );
1619         if( !filter )
1620         {
1621             SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1622             return FALSE;
1623         }
1624         lstrcpyW( filter, dir );
1625         if ( '\\' == filter[dir_len - 1] )
1626             filter[--dir_len] = 0;
1627
1628         att = GetFileAttributesW( filter );
1629         if (att != INVALID_FILE_ATTRIBUTES && !(att & FILE_ATTRIBUTE_DIRECTORY))
1630         {
1631             HeapFree( GetProcessHeap(), 0, filter );
1632             SetLastError( ERROR_DIRECTORY );
1633             return FALSE;
1634         }
1635     }
1636     else
1637     {
1638         DWORD msize;
1639         dir_len = GetWindowsDirectoryW( NULL, 0 );
1640         msize = ( 7 + 4 + dir_len ) * sizeof( WCHAR );
1641         filter = HeapAlloc( GetProcessHeap(), 0, msize );
1642         if( !filter )
1643         {
1644             SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1645             return FALSE;
1646         }
1647         GetWindowsDirectoryW( filter, msize );
1648         lstrcatW( filter, L"\\inf" );
1649     }
1650     lstrcatW( filter, L"\\*.inf" );
1651
1652     hdl = FindFirstFileW( filter , &finddata );
1653     if ( hdl == INVALID_HANDLE_VALUE )
1654     {
1655         if( outsize ) *outsize = 1;
1656         HeapFree( GetProcessHeap(), 0, filter );
1657         return TRUE;
1658     }
1659     size = 1;
1660     do
1661     {
1662         WCHAR signature[ MAX_PATH ];
1663         BOOL valid = FALSE;
1664         DWORD len = lstrlenW( finddata.cFileName );
1665         if (!fullname || ( name_len < len ))
1666         {
1667             name_len = ( name_len < len ) ? len : name_len;
1668             HeapFree( GetProcessHeap(), 0, fullname );
1669             fullname = HeapAlloc( GetProcessHeap(), 0,
1670                                   ( 2 + dir_len + name_len) * sizeof( WCHAR ));
1671             if( !fullname )
1672             {
1673                 FindClose( hdl );
1674                 HeapFree( GetProcessHeap(), 0, filter );
1675                 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1676                 return FALSE;
1677             }
1678             lstrcpyW( fullname, filter );
1679         }
1680         fullname[ dir_len + 1] = 0; /* keep '\\' */
1681         lstrcatW( fullname, finddata.cFileName );
1682         if (!GetPrivateProfileStringW( L"Version", L"Signature", NULL, signature, MAX_PATH, fullname ))
1683             signature[0] = 0;
1684         if( INF_STYLE_OLDNT & style )
1685             valid = wcsicmp( L"$Chicago$", signature ) && wcsicmp( L"$WINDOWS NT$", signature );
1686         if( INF_STYLE_WIN4 & style )
1687             valid = valid || !wcsicmp( L"$Chicago$", signature ) ||
1688                     !wcsicmp( L"$WINDOWS NT$", signature );
1689         if( valid )
1690         {
1691             size += 1 + lstrlenW( finddata.cFileName );
1692             if( ptr && insize >= size )
1693             {
1694                 lstrcpyW( ptr, finddata.cFileName );
1695                 ptr += 1 + lstrlenW( finddata.cFileName );
1696                 *ptr = 0;
1697             }
1698         }
1699     }
1700     while( FindNextFileW( hdl, &finddata ));
1701     FindClose( hdl );
1702
1703     HeapFree( GetProcessHeap(), 0, fullname );
1704     HeapFree( GetProcessHeap(), 0, filter );
1705     if( outsize ) *outsize = size;
1706     return TRUE;
1707 }