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

   1 /*
   2  * Advpack install functions
   3  *
   4  * Copyright 2006 James Hawkins
   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 <stdlib.h>
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "winuser.h"
  27 #include "winreg.h"
  28 #include "winver.h"
  29 #include "winternl.h"
  30 #include "winnls.h"
  31 #include "setupapi.h"
  32 #include "advpub.h"
  33 #include "wine/debug.h"
  34 #include "wine/unicode.h"
  35 #include "advpack_private.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(advpack);
  38
  39 #define SPAPI_ERROR     0xE0000000L
  40 #define SPAPI_PREFIX    0x800F0000L
  41 #define SPAPI_MASK      0xFFFFL
  42 #define HRESULT_FROM_SPAPI(x)   ((x & SPAPI_MASK) | SPAPI_PREFIX)
  43
  44 #define ADV_HRESULT(x)  ((x & SPAPI_ERROR) ? HRESULT_FROM_SPAPI(x) : HRESULT_FROM_WIN32(x))
  45
  46 /* contains information about a specific install instance */
  47 typedef struct _ADVInfo
  48 {
  49     HINF hinf;
  50     LPWSTR inf_filename;
  51     LPWSTR install_sec;
  52     LPWSTR working_dir;
  53     DWORD flags;
  54     BOOL need_reboot;
  55 } ADVInfo;
  56
  57 typedef HRESULT (*iterate_fields_func)(HINF hinf, PCWSTR field, void *arg);
  58
  59 /* Advanced INF commands */
  60 static const WCHAR CheckAdminRights[] = {
  61     'C','h','e','c','k','A','d','m','i','n','R','i','g','h','t','s',0
  62 };
  63 static const WCHAR DelDirs[] = {'D','e','l','D','i','r','s',0};
  64 static const WCHAR PerUserInstall[] = {'P','e','r','U','s','e','r','I','n','s','t','a','l','l',0};
  65 static const WCHAR RegisterOCXs[] = {'R','e','g','i','s','t','e','r','O','C','X','s',0};
  66 static const WCHAR RunPreSetupCommands[] = {
  67     'R','u','n','P','r','e','S','e','t','u','p','C','o','m','m','a','n','d','s',0
  68 };
  69 static const WCHAR RunPostSetupCommands[] = {
  70     'R','u','n','P','o','s','t','S','e','t','u','p','C','o','m','m','a','n','d','s',0
  71 };
  72
  73 /* Advanced INF callbacks */
  74 static HRESULT del_dirs_callback(HINF hinf, PCWSTR field, void *arg)
  75 {
  76     INFCONTEXT context;
  77     HRESULT hr = S_OK;
  78     DWORD size;
  79
  80     BOOL ok = SetupFindFirstLineW(hinf, field, NULL, &context);
  81
  82     for (; ok; ok = SetupFindNextLine(&context, &context))
  83     {
  84         WCHAR directory[MAX_INF_STRING_LENGTH];
  85
  86         if (!SetupGetLineTextW(&context, NULL, NULL, NULL, directory,
  87                                MAX_INF_STRING_LENGTH, &size))
  88             continue;
  89
  90         if (DelNodeW(directory, ADN_DEL_IF_EMPTY))
  91             hr = E_FAIL;
  92     }
  93
  94     return hr;
  95 }
  96
  97 static HRESULT per_user_install_callback(HINF hinf, PCWSTR field, void *arg)
  98 {
  99     PERUSERSECTIONW per_user;
 100     INFCONTEXT context;
 101     DWORD size;
 102
 103     static const WCHAR disp_name[] = {'D','i','s','p','l','a','y','N','a','m','e',0};
 104     static const WCHAR version[] = {'V','e','r','s','i','o','n',0};
 105     static const WCHAR is_installed[] = {'I','s','I','n','s','t','a','l','l','e','d',0};
 106     static const WCHAR comp_id[] = {'C','o','m','p','o','n','e','n','t','I','D',0};
 107     static const WCHAR guid[] = {'G','U','I','D',0};
 108     static const WCHAR locale[] = {'L','o','c','a','l','e',0};
 109     static const WCHAR stub_path[] = {'S','t','u','b','P','a','t','h',0};
 110
 111     per_user.bRollback = FALSE;
 112     per_user.dwIsInstalled = 0;
 113
 114     SetupGetLineTextW(NULL, hinf, field, disp_name, per_user.szDispName,
 115                      sizeof(per_user.szDispName) / sizeof(WCHAR), &size);
 116
 117     SetupGetLineTextW(NULL, hinf, field, version, per_user.szVersion,
 118                      sizeof(per_user.szVersion) / sizeof(WCHAR), &size);
 119
 120     if (SetupFindFirstLineW(hinf, field, is_installed, &context))
 121     {
 122         SetupGetIntField(&context, 1, (PINT)&per_user.dwIsInstalled);
 123     }
 124
 125     SetupGetLineTextW(NULL, hinf, field, comp_id, per_user.szCompID,
 126                      sizeof(per_user.szCompID) / sizeof(WCHAR), &size);
 127
 128     SetupGetLineTextW(NULL, hinf, field, guid, per_user.szGUID,
 129                      sizeof(per_user.szGUID) / sizeof(WCHAR), &size);
 130
 131     SetupGetLineTextW(NULL, hinf, field, locale, per_user.szLocale,
 132                      sizeof(per_user.szLocale) / sizeof(WCHAR), &size);
 133
 134     SetupGetLineTextW(NULL, hinf, field, stub_path, per_user.szStub,
 135                      sizeof(per_user.szStub) / sizeof(WCHAR), &size);
 136
 137     return SetPerUserSecValuesW(&per_user);
 138 }
 139
 140 static HRESULT register_ocxs_callback(HINF hinf, PCWSTR field, void *arg)
 141 {
 142     HMODULE hm;
 143     INFCONTEXT context;
 144     HRESULT hr = S_OK;
 145
 146     BOOL ok = SetupFindFirstLineW(hinf, field, NULL, &context);
 147
 148     for (; ok; ok = SetupFindNextLine(&context, &context))
 149     {
 150         WCHAR buffer[MAX_INF_STRING_LENGTH];
 151
 152         /* get OCX filename */
 153         if (!SetupGetStringFieldW(&context, 1, buffer,
 154                                   sizeof(buffer) / sizeof(WCHAR), NULL))
 155             continue;
 156
 157         hm = LoadLibraryExW(buffer, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
 158         if (!hm)
 159             continue;
 160
 161         if (do_ocx_reg(hm, TRUE))
 162             hr = E_FAIL;
 163
 164         FreeLibrary(hm);
 165     }
 166
 167     return hr;
 168 }
 169
 170 static HRESULT run_setup_commands_callback(HINF hinf, PCWSTR field, void *arg)
 171 {
 172     ADVInfo *info = (ADVInfo *)arg;
 173     INFCONTEXT context;
 174     HRESULT hr = S_OK;
 175     DWORD size;
 176
 177     BOOL ok = SetupFindFirstLineW(hinf, field, NULL, &context);
 178
 179     for (; ok; ok = SetupFindNextLine(&context, &context))
 180     {
 181         WCHAR buffer[MAX_INF_STRING_LENGTH];
 182
 183         if (!SetupGetLineTextW(&context, NULL, NULL, NULL, buffer,
 184                                MAX_INF_STRING_LENGTH, &size))
 185             continue;
 186
 187         if (launch_exe(buffer, info->working_dir, NULL))
 188             hr = E_FAIL;
 189     }
 190
 191     return hr;
 192 }
 193
 194 /* sequentially returns pointers to parameters in a parameter list
 195  * returns NULL if the parameter is empty, e.g. one,,three  */
 196 LPWSTR get_parameter(LPWSTR *params, WCHAR separator)
 197 {
 198     LPWSTR token = *params;
 199
 200     if (!*params)
 201         return NULL;
 202
 203     *params = strchrW(*params, separator);
 204     if (*params)
 205         *(*params)++ = '\0';
 206
 207     if (!*token)
 208         return NULL;
 209
 210     return token;
 211 }
 212
 213 static BOOL is_full_path(LPWSTR path)
 214 {
 215     const int MIN_PATH_LEN = 3;
 216
 217     if (!path || lstrlenW(path) < MIN_PATH_LEN)
 218         return FALSE;
 219
 220     if (path[1] == ':' || (path[0] == '\\' && path[1] == '\\'))
 221         return TRUE;
 222
 223     return FALSE;
 224 }
 225
 226 /* retrieves the contents of a field, dynamically growing the buffer if necessary */
 227 static WCHAR *get_field_string(INFCONTEXT *context, DWORD index, WCHAR *buffer,
 228                                WCHAR *static_buffer, DWORD *size)
 229 {
 230     DWORD required;
 231
 232     if (SetupGetStringFieldW(context, index, buffer, *size, &required)) return buffer;
 233
 234     if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
 235     {
 236         /* now grow the buffer */
 237         if (buffer != static_buffer) HeapFree(GetProcessHeap(), 0, buffer);
 238         if (!(buffer = HeapAlloc(GetProcessHeap(), 0, required*sizeof(WCHAR)))) return NULL;
 239         *size = required;
 240         if (SetupGetStringFieldW(context, index, buffer, *size, &required)) return buffer;
 241     }
 242
 243     if (buffer != static_buffer) HeapFree(GetProcessHeap(), 0, buffer);
 244     return NULL;
 245 }
 246
 247 /* iterates over all fields of a certain key of a certain section */
 248 static HRESULT iterate_section_fields(HINF hinf, PCWSTR section, PCWSTR key,
 249                                       iterate_fields_func callback, void *arg)
 250 {
 251     WCHAR static_buffer[200];
 252     WCHAR *buffer = static_buffer;
 253     DWORD size = sizeof(static_buffer) / sizeof(WCHAR);
 254     INFCONTEXT context;
 255     HRESULT hr = E_FAIL;
 256
 257     BOOL ok = SetupFindFirstLineW(hinf, section, key, &context);
 258     while (ok)
 259     {
 260         UINT i, count = SetupGetFieldCount(&context);
 261
 262         for (i = 1; i <= count; i++)
 263         {
 264             if (!(buffer = get_field_string(&context, i, buffer, static_buffer, &size)))
 265                 goto done;
 266
 267             if ((hr = callback(hinf, buffer, arg)) != S_OK)
 268                 goto done;
 269         }
 270
 271         ok = SetupFindNextMatchLineW(&context, key, &context);
 272     }
 273
 274     hr = S_OK;
 275
 276  done:
 277     if (buffer && buffer != static_buffer) HeapFree(GetProcessHeap(), 0, buffer);
 278     return hr;
 279 }
 280
 281 static HRESULT check_admin_rights(ADVInfo *info)
 282 {
 283     INT check;
 284     INFCONTEXT context;
 285     HRESULT hr = S_OK;
 286
 287     if (!SetupFindFirstLineW(info->hinf, info->install_sec,
 288                              CheckAdminRights, &context))
 289         return S_OK;
 290
 291     if (!SetupGetIntField(&context, 1, &check))
 292         return S_OK;
 293
 294     if (check == 1)
 295         hr = IsNTAdmin(0, NULL) ? S_OK : E_FAIL;
 296
 297     return hr;
 298 }
 299
 300 /* performs a setupapi-level install of the INF file */
 301 static HRESULT spapi_install(ADVInfo *info)
 302 {
 303     BOOL ret;
 304     HRESULT res;
 305     PVOID context;
 306
 307     context = SetupInitDefaultQueueCallbackEx(NULL, INVALID_HANDLE_VALUE, 0, 0, NULL);
 308     if (!context)
 309         return ADV_HRESULT(GetLastError());
 310
 311     ret = SetupInstallFromInfSectionW(NULL, info->hinf, info->install_sec,
 312                                       SPINST_FILES, NULL, info->working_dir,
 313                                       SP_COPY_NEWER, SetupDefaultQueueCallbackW,
 314                                       context, NULL, NULL);
 315     if (!ret)
 316     {
 317         res = ADV_HRESULT(GetLastError());
 318         SetupTermDefaultQueueCallback(context);
 319
 320         return res;
 321     }
 322
 323     SetupTermDefaultQueueCallback(context);
 324
 325     ret = SetupInstallFromInfSectionW(NULL, info->hinf, info->install_sec,
 326                                       SPINST_INIFILES | SPINST_REGISTRY,
 327                                       HKEY_LOCAL_MACHINE, NULL, 0,
 328                                       NULL, NULL, NULL, NULL);
 329     if (!ret)
 330         return ADV_HRESULT(GetLastError());
 331
 332     return S_OK;
 333 }
 334
 335 /* processes the Advanced INF commands */
 336 static HRESULT adv_install(ADVInfo *info)
 337 {
 338     HRESULT hr;
 339
 340     hr = check_admin_rights(info);
 341     if (hr != S_OK)
 342         return hr;
 343
 344     hr = iterate_section_fields(info->hinf, info->install_sec, RunPreSetupCommands,
 345                                 run_setup_commands_callback, info);
 346     if (hr != S_OK)
 347         return hr;
 348
 349     hr = iterate_section_fields(info->hinf, info->install_sec,
 350                                 RegisterOCXs, register_ocxs_callback, NULL);
 351     if (hr != S_OK)
 352         return hr;
 353
 354     hr = iterate_section_fields(info->hinf, info->install_sec,
 355                                 PerUserInstall, per_user_install_callback, info);
 356     if (hr != S_OK)
 357         return hr;
 358
 359     hr = iterate_section_fields(info->hinf, info->install_sec, RunPostSetupCommands,
 360                                 run_setup_commands_callback, info);
 361     if (hr != S_OK)
 362         return hr;
 363
 364     hr = iterate_section_fields(info->hinf, info->install_sec,
 365                                 DelDirs, del_dirs_callback, info);
 366     if (hr != S_OK)
 367         return hr;
 368
 369     return hr;
 370 }
 371
 372 /* loads the INF file and performs checks on it */
 373 HRESULT install_init(LPCWSTR inf_filename, LPCWSTR install_sec,
 374                      LPCWSTR working_dir, DWORD flags, ADVInfo *info)
 375 {
 376     DWORD len;
 377     LPCWSTR ptr;
 378
 379     static const WCHAR default_install[] = {
 380         'D','e','f','a','u','l','t','I','n','s','t','a','l','l',0
 381     };
 382
 383     len = lstrlenW(inf_filename);
 384
 385     info->inf_filename = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR));
 386     if (!info->inf_filename)
 387         return E_OUTOFMEMORY;
 388
 389     lstrcpyW(info->inf_filename, inf_filename);
 390
 391     /* FIXME: determine the proper platform to install (NTx86, etc) */
 392     if (!install_sec || !*install_sec)
 393     {
 394         len = sizeof(default_install) - 1;
 395         ptr = default_install;
 396     }
 397     else
 398     {
 399         len = lstrlenW(install_sec);
 400         ptr = install_sec;
 401     }
 402
 403     info->install_sec = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR));
 404     if (!info->install_sec)
 405         return E_OUTOFMEMORY;
 406
 407     lstrcpyW(info->install_sec, ptr);
 408
 409     /* FIXME: need to get the real working directory */
 410     if (!working_dir || !*working_dir)
 411     {
 412         ptr = strrchrW(info->inf_filename, '\\');
 413         len = ptr - info->inf_filename + 1;
 414         ptr = info->inf_filename;
 415     }
 416     else
 417     {
 418         len = lstrlenW(working_dir) + 1;
 419         ptr = working_dir;
 420     }
 421
 422     info->working_dir = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 423     if (!info->working_dir)
 424         return E_OUTOFMEMORY;
 425
 426     lstrcpynW(info->working_dir, ptr, len);
 427
 428     info->hinf = SetupOpenInfFileW(info->inf_filename, NULL, INF_STYLE_WIN4, NULL);
 429     if (info->hinf == INVALID_HANDLE_VALUE)
 430         return ADV_HRESULT(GetLastError());
 431
 432     set_ldids(info->hinf, info->install_sec, info->working_dir);
 433
 434     /* FIXME: check that the INF is advanced */
 435
 436     info->flags = flags;
 437     info->need_reboot = FALSE;
 438
 439     return S_OK;
 440 }
 441
 442 /* release the install instance information */
 443 void install_release(ADVInfo *info)
 444 {
 445     if (info->hinf && info->hinf != INVALID_HANDLE_VALUE)
 446         SetupCloseInfFile(info->hinf);
 447
 448     HeapFree(GetProcessHeap(), 0, info->inf_filename);
 449     HeapFree(GetProcessHeap(), 0, info->install_sec);
 450     HeapFree(GetProcessHeap(), 0, info->working_dir);
 451 }
 452
 453 /* this structure very closely resembles parameters of RunSetupCommand() */
 454 typedef struct
 455 {
 456     HWND hwnd;
 457     LPCSTR title;
 458     LPCSTR inf_name;
 459     LPCSTR dir;
 460     LPCSTR section_name;
 461 } SETUPCOMMAND_PARAMS;
 462
 463 /***********************************************************************
 464  *      DoInfInstall  (ADVPACK.@)
 465  *
 466  * Install an INF section.
 467  *
 468  * PARAMS
 469  *  setup [I] Structure containing install information.
 470  *
 471  * RETURNS
 472  *   S_OK                                Everything OK
 473  *   HRESULT_FROM_WIN32(GetLastError())  Some other error
 474  */
 475 HRESULT WINAPI DoInfInstall(const SETUPCOMMAND_PARAMS *setup)
 476 {
 477     BOOL ret;
 478     HINF hinf;
 479     void *callback_context;
 480
 481     TRACE("(%p)\n", setup);
 482
 483     hinf = SetupOpenInfFileA(setup->inf_name, NULL, INF_STYLE_WIN4, NULL);
 484     if (hinf == INVALID_HANDLE_VALUE) return HRESULT_FROM_WIN32(GetLastError());
 485
 486     callback_context = SetupInitDefaultQueueCallback(setup->hwnd);
 487
 488     ret = SetupInstallFromInfSectionA(NULL, hinf, setup->section_name, SPINST_ALL,
 489                                       NULL, NULL, 0, SetupDefaultQueueCallbackA,
 490                                       callback_context, NULL, NULL);
 491     SetupTermDefaultQueueCallback(callback_context);
 492     SetupCloseInfFile(hinf);
 493
 494     return ret ? S_OK : HRESULT_FROM_WIN32(GetLastError());
 495 }
 496
 497 /***********************************************************************
 498  *             ExecuteCabA    (ADVPACK.@)
 499  *
 500  * See ExecuteCabW.
 501  */
 502 HRESULT WINAPI ExecuteCabA(HWND hwnd, CABINFOA* pCab, LPVOID pReserved)
 503 {
 504     UNICODE_STRING cab, inf, section;
 505     CABINFOW cabinfo;
 506     HRESULT hr;
 507
 508     TRACE("(%p, %p, %p)\n", hwnd, pCab, pReserved);
 509
 510     if (!pCab)
 511         return E_INVALIDARG;
 512
 513     if (pCab->pszCab)
 514     {
 515         RtlCreateUnicodeStringFromAsciiz(&cab, pCab->pszCab);
 516         cabinfo.pszCab = cab.Buffer;
 517     }
 518     else
 519         cabinfo.pszCab = NULL;
 520
 521     RtlCreateUnicodeStringFromAsciiz(&inf, pCab->pszInf);
 522     RtlCreateUnicodeStringFromAsciiz(&section, pCab->pszSection);
 523
 524     MultiByteToWideChar(CP_ACP, 0, pCab->szSrcPath, -1, cabinfo.szSrcPath,
 525                         sizeof(cabinfo.szSrcPath) / sizeof(WCHAR));
 526
 527     cabinfo.pszInf = inf.Buffer;
 528     cabinfo.pszSection = section.Buffer;
 529     cabinfo.dwFlags = pCab->dwFlags;
 530
 531     hr = ExecuteCabW(hwnd, &cabinfo, pReserved);
 532
 533     if (pCab->pszCab)
 534         RtlFreeUnicodeString(&cab);
 535
 536     RtlFreeUnicodeString(&inf);
 537     RtlFreeUnicodeString(&section);
 538
 539     return hr;
 540 }
 541
 542 /***********************************************************************
 543  *             ExecuteCabW    (ADVPACK.@)
 544  *
 545  * Installs the INF file extracted from a specified cabinet file.
 546  *
 547  * PARAMS
 548  *   hwnd      [I] Handle to the window used for the display.
 549  *   pCab      [I] Information about the cabinet file.
 550  *   pReserved [I] Reserved.  Must be NULL.
 551  *
 552  * RETURNS
 553  *   Success: S_OK.
 554  *   Failure: E_FAIL.
 555  */
 556 HRESULT WINAPI ExecuteCabW(HWND hwnd, CABINFOW* pCab, LPVOID pReserved)
 557 {
 558     ADVInfo info;
 559     HRESULT hr;
 560
 561     TRACE("(%p, %p, %p)\n", hwnd, pCab, pReserved);
 562
 563     ZeroMemory(&info, sizeof(ADVInfo));
 564
 565     if (pCab->pszCab && *pCab->pszCab)
 566         FIXME("Cab archive not extracted!\n");
 567
 568     hr = install_init(pCab->pszInf, pCab->pszSection, pCab->szSrcPath, pCab->dwFlags, &info);
 569     if (hr != S_OK)
 570         goto done;
 571
 572     hr = spapi_install(&info);
 573     if (hr != S_OK)
 574         goto done;
 575
 576     hr = adv_install(&info);
 577
 578 done:
 579     install_release(&info);
 580
 581     return hr;
 582 }
 583
 584 /***********************************************************************
 585  *      LaunchINFSectionA   (ADVPACK.@)
 586  *
 587  * See LaunchINFSectionW.
 588  */
 589 INT WINAPI LaunchINFSectionA(HWND hWnd, HINSTANCE hInst, LPSTR cmdline, INT show)
 590 {
 591     UNICODE_STRING cmd;
 592     HRESULT hr;
 593
 594     TRACE("(%p, %p, %s, %i)\n", hWnd, hInst, debugstr_a(cmdline), show);
 595
 596     RtlCreateUnicodeStringFromAsciiz(&cmd, cmdline);
 597
 598     hr = LaunchINFSectionW(hWnd, hInst, cmd.Buffer, show);
 599
 600     RtlFreeUnicodeString(&cmd);
 601
 602     return hr;
 603 }
 604
 605 /***********************************************************************
 606  *      LaunchINFSectionW   (ADVPACK.@)
 607  *
 608  * Installs an INF section without BACKUP/ROLLBACK capabilities.
 609  *
 610  * PARAMS
 611  *   hWnd    [I] Handle to parent window, NULL for desktop.
 612  *   hInst   [I] Instance of the process.
 613  *   cmdline [I] Contains parameters in the order INF,section,flags,reboot.
 614  *   show    [I] How the window should be shown.
 615  *
 616  * RETURNS
 617  *  Success: S_OK.
 618  *  Failure: S_FALSE
 619  *
 620  * NOTES
 621  *  INF - Filename of the INF to launch.
 622  *  section - INF section to install.
 623  *  flags - see advpub.h.
 624  *  reboot - smart reboot behavior
 625  *    'A' Always reboot.
 626  *    'I' Reboot if needed (default).
 627  *    'N' No reboot.
 628  */
 629 INT WINAPI LaunchINFSectionW(HWND hWnd, HINSTANCE hInst, LPWSTR cmdline, INT show)
 630 {
 631     ADVInfo info;
 632     LPWSTR cmdline_copy, cmdline_ptr;
 633     LPWSTR inf_filename, install_sec;
 634     LPWSTR str_flags;
 635     DWORD flags = 0;
 636     HRESULT hr = S_OK;
 637
 638     TRACE("(%p, %p, %s, %d)\n", hWnd, hInst, debugstr_w(cmdline), show);
 639
 640     if (!cmdline)
 641         return E_INVALIDARG;
 642
 643     cmdline_copy = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(cmdline) + 1) * sizeof(WCHAR));
 644     cmdline_ptr = cmdline_copy;
 645     lstrcpyW(cmdline_copy, cmdline);
 646
 647     inf_filename = get_parameter(&cmdline_ptr, ',');
 648     install_sec = get_parameter(&cmdline_ptr, ',');
 649
 650     str_flags = get_parameter(&cmdline_ptr, ',');
 651     if (str_flags)
 652         flags = atolW(str_flags);
 653
 654     ZeroMemory(&info, sizeof(ADVInfo));
 655
 656     hr = install_init(inf_filename, install_sec, NULL, flags, &info);
 657     if (hr != S_OK)
 658         goto done;
 659
 660     hr = spapi_install(&info);
 661     if (hr != S_OK)
 662         goto done;
 663
 664     hr = adv_install(&info);
 665
 666 done:
 667     install_release(&info);
 668     HeapFree(GetProcessHeap(), 0, cmdline_copy);
 669
 670     return hr;
 671 }
 672
 673 /***********************************************************************
 674  *      LaunchINFSectionExA (ADVPACK.@)
 675  *
 676  * See LaunchINFSectionExW.
 677  */
 678 HRESULT WINAPI LaunchINFSectionExA(HWND hWnd, HINSTANCE hInst, LPSTR cmdline, INT show)
 679 {
 680     UNICODE_STRING cmd;
 681     HRESULT hr;
 682
 683     TRACE("(%p, %p, %s, %i)\n", hWnd, hInst, debugstr_a(cmdline), show);
 684
 685     RtlCreateUnicodeStringFromAsciiz(&cmd, cmdline);
 686
 687     hr = LaunchINFSectionExW(hWnd, hInst, cmd.Buffer, show);
 688
 689     RtlFreeUnicodeString(&cmd);
 690
 691     return hr;
 692 }
 693
 694 /***********************************************************************
 695  *      LaunchINFSectionExW (ADVPACK.@)
 696  *
 697  * Installs an INF section with BACKUP/ROLLBACK capabilities.
 698  *
 699  * PARAMS
 700  *   hWnd    [I] Handle to parent window, NULL for desktop.
 701  *   hInst   [I] Instance of the process.
 702  *   cmdline [I] Contains parameters in the order INF,section,CAB,flags,reboot.
 703  *   show    [I] How the window should be shown.
 704  *
 705  * RETURNS
 706  *  Success: S_OK.
 707  *  Failure: E_FAIL.
 708  *
 709  * NOTES
 710  *  INF - Filename of the INF to launch.
 711  *  section - INF section to install.
 712  *  flags - see advpub.h.
 713  *  reboot - smart reboot behavior
 714  *    'A' Always reboot.
 715  *    'I' Reboot if needed (default).
 716  *    'N' No reboot.
 717  *
 718  * BUGS
 719  *  Doesn't handle the reboot flag.
 720  */
 721 HRESULT WINAPI LaunchINFSectionExW(HWND hWnd, HINSTANCE hInst, LPWSTR cmdline, INT show)
 722 {
 723     LPWSTR cmdline_copy, cmdline_ptr;
 724     LPWSTR flags, ptr;
 725     CABINFOW cabinfo;
 726     HRESULT hr = S_OK;
 727
 728     TRACE("(%p, %p, %s, %d)\n", hWnd, hInst, debugstr_w(cmdline), show);
 729
 730     if (!cmdline)
 731         return E_INVALIDARG;
 732
 733     cmdline_copy = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(cmdline) + 1) * sizeof(WCHAR));
 734     cmdline_ptr = cmdline_copy;
 735     lstrcpyW(cmdline_copy, cmdline);
 736
 737     cabinfo.pszInf = get_parameter(&cmdline_ptr, ',');
 738     cabinfo.pszSection = get_parameter(&cmdline_ptr, ',');
 739     cabinfo.pszCab = get_parameter(&cmdline_ptr, ',');
 740     *cabinfo.szSrcPath = '\0';
 741
 742     flags = get_parameter(&cmdline_ptr, ',');
 743     if (flags)
 744         cabinfo.dwFlags = atolW(flags);
 745
 746     /* get the source path from the cab filename */
 747     if (cabinfo.pszCab && *cabinfo.pszCab)
 748     {
 749         if (!is_full_path(cabinfo.pszCab))
 750             goto done;
 751
 752         lstrcpyW(cabinfo.szSrcPath, cabinfo.pszCab);
 753         ptr = strrchrW(cabinfo.szSrcPath, '\\');
 754         *(++ptr) = '\0';
 755     }
 756
 757     hr = ExecuteCabW(hWnd, &cabinfo, NULL);
 758
 759 done:
 760     HeapFree(GetProcessHeap(), 0, cmdline_copy);
 761
 762     return hr;
 763 }
 764
 765 HRESULT launch_exe(LPCWSTR cmd, LPCWSTR dir, HANDLE *phEXE)
 766 {
 767     STARTUPINFOW si;
 768     PROCESS_INFORMATION pi;
 769
 770     if (phEXE) *phEXE = NULL;
 771
 772     ZeroMemory(&pi, sizeof(pi));
 773     ZeroMemory(&si, sizeof(si));
 774     si.cb = sizeof(si);
 775
 776     if (!CreateProcessW(NULL, (LPWSTR)cmd, NULL, NULL, FALSE,
 777                         CREATE_DEFAULT_ERROR_MODE | CREATE_NEW_PROCESS_GROUP,
 778                         NULL, dir, &si, &pi))
 779     {
 780         return HRESULT_FROM_WIN32(GetLastError());
 781     }
 782
 783     CloseHandle(pi.hThread);
 784
 785     if (phEXE)
 786     {
 787         *phEXE = pi.hProcess;
 788         return S_ASYNCHRONOUS;
 789     }
 790
 791     /* wait for the child process to finish */
 792     WaitForSingleObject(pi.hProcess, INFINITE);
 793     CloseHandle(pi.hProcess);
 794
 795     return S_OK;
 796 }
 797
 798 /***********************************************************************
 799  *      RunSetupCommandA  (ADVPACK.@)
 800  *
 801  * See RunSetupCommandW.
 802  */
 803 HRESULT WINAPI RunSetupCommandA(HWND hWnd, LPCSTR szCmdName,
 804                                 LPCSTR szInfSection, LPCSTR szDir,
 805                                 LPCSTR lpszTitle, HANDLE *phEXE,
 806                                 DWORD dwFlags, LPVOID pvReserved)
 807 {
 808     UNICODE_STRING cmdname, infsec;
 809     UNICODE_STRING dir, title;
 810     HRESULT hr;
 811
 812     TRACE("(%p, %s, %s, %s, %s, %p, %ld, %p)\n",
 813           hWnd, debugstr_a(szCmdName), debugstr_a(szInfSection),
 814           debugstr_a(szDir), debugstr_a(lpszTitle),
 815           phEXE, dwFlags, pvReserved);
 816
 817     if (!szCmdName || !szDir)
 818         return E_INVALIDARG;
 819
 820     RtlCreateUnicodeStringFromAsciiz(&cmdname, szCmdName);
 821     RtlCreateUnicodeStringFromAsciiz(&infsec, szInfSection);
 822     RtlCreateUnicodeStringFromAsciiz(&dir, szDir);
 823     RtlCreateUnicodeStringFromAsciiz(&title, lpszTitle);
 824
 825     hr = RunSetupCommandW(hWnd, cmdname.Buffer, infsec.Buffer, dir.Buffer,
 826                           title.Buffer, phEXE, dwFlags, pvReserved);
 827
 828     RtlFreeUnicodeString(&cmdname);
 829     RtlFreeUnicodeString(&infsec);
 830     RtlFreeUnicodeString(&dir);
 831     RtlFreeUnicodeString(&title);
 832
 833     return hr;
 834 }
 835
 836 /***********************************************************************
 837  *      RunSetupCommandW  (ADVPACK.@)
 838  *
 839  * Executes an install section in an INF file or a program.
 840  *
 841  * PARAMS
 842  *   hWnd          [I] Handle to parent window, NULL for quiet mode
 843  *   szCmdName     [I] Inf or EXE filename to execute
 844  *   szInfSection  [I] Inf section to install, NULL for DefaultInstall
 845  *   szDir         [I] Path to extracted files
 846  *   szTitle       [I] Title of all dialogs
 847  *   phEXE         [O] Handle of EXE to wait for
 848  *   dwFlags       [I] Flags; see include/advpub.h
 849  *   pvReserved    [I] Reserved
 850  *
 851  * RETURNS
 852  *   S_OK                                 Everything OK
 853  *   S_ASYNCHRONOUS                       OK, required to wait on phEXE
 854  *   ERROR_SUCCESS_REBOOT_REQUIRED        Reboot required
 855  *   E_INVALIDARG                         Invalid argument given
 856  *   HRESULT_FROM_WIN32(ERROR_OLD_WIN_VERSION)
 857  *                                        Not supported on this Windows version
 858  *   E_UNEXPECTED                         Unexpected error
 859  *   HRESULT_FROM_WIN32(GetLastError())   Some other error
 860  */
 861 HRESULT WINAPI RunSetupCommandW(HWND hWnd, LPCWSTR szCmdName,
 862                                 LPCWSTR szInfSection, LPCWSTR szDir,
 863                                 LPCWSTR lpszTitle, HANDLE *phEXE,
 864                                 DWORD dwFlags, LPVOID pvReserved)
 865 {
 866     ADVInfo info;
 867     HRESULT hr;
 868
 869     TRACE("(%p, %s, %s, %s, %s, %p, %ld, %p)\n",
 870           hWnd, debugstr_w(szCmdName), debugstr_w(szInfSection),
 871           debugstr_w(szDir), debugstr_w(lpszTitle),
 872           phEXE, dwFlags, pvReserved);
 873
 874     if (dwFlags & RSC_FLAG_UPDHLPDLLS)
 875         FIXME("Unhandled flag: RSC_FLAG_UPDHLPDLLS\n");
 876
 877     if (!szCmdName || !szDir)
 878         return E_INVALIDARG;
 879
 880     if (!(dwFlags & RSC_FLAG_INF))
 881         return launch_exe(szCmdName, szDir, phEXE);
 882
 883     ZeroMemory(&info, sizeof(ADVInfo));
 884
 885     hr = install_init(szCmdName, szInfSection, szDir, dwFlags, &info);
 886     if (hr != S_OK)
 887         goto done;
 888
 889     hr = spapi_install(&info);
 890     if (hr != S_OK)
 891         goto done;
 892
 893     hr = adv_install(&info);
 894
 895 done:
 896     install_release(&info);
 897
 898     return hr;
 899 }