install.c File Reference

#include <stdarg.h>
#include <stdlib.h>
#include "windef.h"
#include "winbase.h"
#include "winuser.h"
#include "winreg.h"
#include "winternl.h"
#include "winnls.h"
#include "setupapi.h"
#include "advpub.h"
#include "ole2.h"
#include "wine/debug.h"
#include "advpack_private.h"

Include dependency graph for install.c:

Go to the source code of this file.

Classes
struct	_ADVInfo
struct	SETUPCOMMAND_PARAMS
struct	SETUPCOMMAND_PARAMSW

Macros
#define	SPAPI_ERROR   0xE0000000L
#define	SPAPI_PREFIX   0x800F0000L
#define	SPAPI_MASK   0xFFFFL
#define	HRESULT_FROM_SPAPI(x)   ((HRESULT)((x & SPAPI_MASK) | SPAPI_PREFIX))
#define	ADV_HRESULT(x)   ((x & SPAPI_ERROR) ? HRESULT_FROM_SPAPI(x) : HRESULT_FROM_WIN32(x))
#define	ADV_SUCCESS   0
#define	ADV_FAILURE   1

Typedefs
typedef struct _ADVInfo	ADVInfo
typedef HRESULT(*	iterate_fields_func) (HINF hinf, PCWSTR field, const void *arg)

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (advpack)
static HRESULT	del_dirs_callback (HINF hinf, PCWSTR field, const void *arg)
static HRESULT	per_user_install_callback (HINF hinf, PCWSTR field, const void *arg)
static HRESULT	register_ocxs_callback (HINF hinf, PCWSTR field, const void *arg)
static HRESULT	run_setup_commands_callback (HINF hinf, PCWSTR field, const void *arg)
LPWSTR	get_parameter (LPWSTR *params, WCHAR separator, BOOL quoted)
static BOOL	is_full_path (LPCWSTR path)
static WCHAR *	get_field_string (INFCONTEXT *context, DWORD index, WCHAR *buffer, const WCHAR *static_buffer, DWORD *size)
static HRESULT	iterate_section_fields (HINF hinf, PCWSTR section, PCWSTR key, iterate_fields_func callback, void *arg)
static HRESULT	check_admin_rights (const ADVInfo *info)
static HRESULT	spapi_install (const ADVInfo *info)
static HRESULT	adv_install (ADVInfo *info)
static HRESULT	get_working_dir (ADVInfo *info, LPCWSTR inf_filename, LPCWSTR working_dir)
static HRESULT	install_init (LPCWSTR inf_filename, LPCWSTR install_sec, LPCWSTR working_dir, DWORD flags, ADVInfo *info)
static void	install_release (const ADVInfo *info)
static HRESULT	DoInfInstallW (const SETUPCOMMAND_PARAMSW *setup)
HRESULT WINAPI	DoInfInstall (const SETUPCOMMAND_PARAMS *setup)
HRESULT WINAPI	ExecuteCabA (HWND hwnd, CABINFOA *pCab, LPVOID pReserved)
HRESULT WINAPI	ExecuteCabW (HWND hwnd, CABINFOW *pCab, LPVOID pReserved)
INT WINAPI	LaunchINFSectionA (HWND hWnd, HINSTANCE hInst, LPSTR cmdline, INT show)
INT WINAPI	LaunchINFSectionW (HWND hWnd, HINSTANCE hInst, LPWSTR cmdline, INT show)
HRESULT WINAPI	LaunchINFSectionExA (HWND hWnd, HINSTANCE hInst, LPSTR cmdline, INT show)
HRESULT WINAPI	LaunchINFSectionExW (HWND hWnd, HINSTANCE hInst, LPWSTR cmdline, INT show)
HRESULT	launch_exe (LPCWSTR cmd, LPCWSTR dir, HANDLE *phEXE)
HRESULT WINAPI	RunSetupCommandA (HWND hWnd, LPCSTR szCmdName, LPCSTR szInfSection, LPCSTR szDir, LPCSTR lpszTitle, HANDLE *phEXE, DWORD dwFlags, LPVOID pvReserved)
HRESULT WINAPI	RunSetupCommandW (HWND hWnd, LPCWSTR szCmdName, LPCWSTR szInfSection, LPCWSTR szDir, LPCWSTR lpszTitle, HANDLE *phEXE, DWORD dwFlags, LPVOID pvReserved)

Variables
static const WCHAR	CheckAdminRights []
static const WCHAR	DelDirs [] = {'D','e','l','D','i','r','s',0}
static const WCHAR	PerUserInstall [] = {'P','e','r','U','s','e','r','I','n','s','t','a','l','l',0}
static const WCHAR	RegisterOCXs [] = {'R','e','g','i','s','t','e','r','O','C','X','s',0}
static const WCHAR	RunPreSetupCommands []
static const WCHAR	RunPostSetupCommands []

Macro Definition Documentation

ADV_FAILURE

#define ADV_FAILURE   1

Definition at line 46 of file install.c.

ADV_HRESULT

#define ADV_HRESULT

(

x

)

((x & SPAPI_ERROR) ? HRESULT_FROM_SPAPI(x) : HRESULT_FROM_WIN32(x))

Definition at line 43 of file install.c.

ADV_SUCCESS

#define ADV_SUCCESS   0

Definition at line 45 of file install.c.

HRESULT_FROM_SPAPI

#define HRESULT_FROM_SPAPI

(

x

)

((HRESULT)((x & SPAPI_MASK) | SPAPI_PREFIX))

Definition at line 41 of file install.c.

SPAPI_ERROR

#define SPAPI_ERROR   0xE0000000L

Definition at line 38 of file install.c.

SPAPI_MASK

#define SPAPI_MASK   0xFFFFL

Definition at line 40 of file install.c.

SPAPI_PREFIX

#define SPAPI_PREFIX   0x800F0000L

Definition at line 39 of file install.c.

Typedef Documentation

ADVInfo

typedef struct _ADVInfo ADVInfo

iterate_fields_func

typedef HRESULT(* iterate_fields_func) (HINF hinf, PCWSTR field, const void *arg)

Definition at line 60 of file install.c.

Function Documentation

adv_install()

static HRESULT adv_install ( ADVInfo *  info )

static

Definition at line 351 of file install.c.

{
    HRESULT hr;
 
    hr = check_admin_rights(info);
    if (hr != S_OK)
        return hr;
 
    hr = iterate_section_fields(info->hinf, info->install_sec, RunPreSetupCommands,
                                run_setup_commands_callback, info);
    if (hr != S_OK)
        return hr;
 
    OleInitialize(NULL);
    hr = iterate_section_fields(info->hinf, info->install_sec,
                                RegisterOCXs, register_ocxs_callback, NULL);
    OleUninitialize();
    if (hr != S_OK)
        return hr;
 
    hr = iterate_section_fields(info->hinf, info->install_sec,
                                PerUserInstall, per_user_install_callback, info);
    if (hr != S_OK)
        return hr;
 
    hr = iterate_section_fields(info->hinf, info->install_sec, RunPostSetupCommands,
                                run_setup_commands_callback, info);
    if (hr != S_OK)
        return hr;
 
    hr = iterate_section_fields(info->hinf, info->install_sec,
                                DelDirs, del_dirs_callback, info);
    if (hr != S_OK)
        return hr;
 
    return hr;
}

Referenced by DoInfInstallW(), ExecuteCabW(), LaunchINFSectionW(), and RunSetupCommandW().

check_admin_rights()

static HRESULT check_admin_rights ( const ADVInfo *  info )

static

Definition at line 296 of file install.c.

{
    INT check;
    INFCONTEXT context;
    HRESULT hr = S_OK;
 
    if (!SetupFindFirstLineW(info->hinf, info->install_sec,
                             CheckAdminRights, &context))
        return S_OK;
 
    if (!SetupGetIntField(&context, 1, &check))
        return S_OK;
 
    if (check == 1)
        hr = IsNTAdmin(0, NULL) ? S_OK : E_FAIL;
 
    return hr;
}

Referenced by adv_install().

del_dirs_callback()

static HRESULT del_dirs_callback ( HINF  hinf, PCWSTR  field, const void *  arg  )

static

Definition at line 77 of file install.c.

{
    INFCONTEXT context;
    HRESULT hr = S_OK;
    DWORD size;
 
    BOOL ok = SetupFindFirstLineW(hinf, field, NULL, &context);
    
    for (; ok; ok = SetupFindNextLine(&context, &context))
    {
        WCHAR directory[MAX_INF_STRING_LENGTH];
 
        if (!SetupGetLineTextW(&context, NULL, NULL, NULL, directory,
                               MAX_INF_STRING_LENGTH, &size))
            continue;
 
        if (DelNodeW(directory, ADN_DEL_IF_EMPTY) != S_OK)
            hr = E_FAIL;
    }
 
    return hr;
}

Referenced by adv_install().

DoInfInstall()

HRESULT WINAPI DoInfInstall

(

const SETUPCOMMAND_PARAMS *

setup

)

Definition at line 583 of file install.c.

{
    UNICODE_STRING title, inf, section, dir;
    SETUPCOMMAND_PARAMSW params;
    HRESULT hr;
 
    if (!setup)
        return E_INVALIDARG;
 
    RtlCreateUnicodeStringFromAsciiz(&title, setup->title);
    RtlCreateUnicodeStringFromAsciiz(&inf, setup->inf_name);
    RtlCreateUnicodeStringFromAsciiz(&section, setup->section_name);
    RtlCreateUnicodeStringFromAsciiz(&dir, setup->dir);
 
    params.title = title.Buffer;
    params.inf_name = inf.Buffer;
    params.section_name = section.Buffer;
    params.dir = dir.Buffer;
    params.hwnd = setup->hwnd;
 
    hr = DoInfInstallW(&params);
 
    RtlFreeUnicodeString(&title);
    RtlFreeUnicodeString(&inf);
    RtlFreeUnicodeString(&section);
    RtlFreeUnicodeString(&dir);
 
    return hr;
}

DoInfInstallW()

static HRESULT DoInfInstallW ( const SETUPCOMMAND_PARAMSW *  setup )

static

Definition at line 546 of file install.c.

{
    ADVInfo info;
    HRESULT hr;
 
    TRACE("(%p)\n", setup);
 
    ZeroMemory(&info, sizeof(ADVInfo));
 
    hr = install_init(setup->inf_name, setup->section_name, setup->dir, 0, &info);
    if (hr != S_OK)
        goto done;
 
    hr = spapi_install(&info);
    if (hr != S_OK)
        goto done;
 
    hr = adv_install(&info);
 
done:
    install_release(&info);
 
    return S_OK;
}

Referenced by DoInfInstall().

ExecuteCabA()

HRESULT WINAPI ExecuteCabA	(	HWND	hwnd,
		CABINFOA *	pCab,
		LPVOID	pReserved
	)

Definition at line 618 of file install.c.

{
    UNICODE_STRING cab, inf, section;
    CABINFOW cabinfo;
    HRESULT hr;
 
    TRACE("(%p, %p, %p)\n", hwnd, pCab, pReserved);
 
    if (!pCab)
        return E_INVALIDARG;
 
    if (pCab->pszCab)
    {
        RtlCreateUnicodeStringFromAsciiz(&cab, pCab->pszCab);
        cabinfo.pszCab = cab.Buffer;
    }
    else
        cabinfo.pszCab = NULL;
 
    RtlCreateUnicodeStringFromAsciiz(&inf, pCab->pszInf);
    RtlCreateUnicodeStringFromAsciiz(&section, pCab->pszSection);
    
    MultiByteToWideChar(CP_ACP, 0, pCab->szSrcPath, -1, cabinfo.szSrcPath, ARRAY_SIZE(cabinfo.szSrcPath));
 
    cabinfo.pszInf = inf.Buffer;
    cabinfo.pszSection = section.Buffer;
    cabinfo.dwFlags = pCab->dwFlags;
 
    hr = ExecuteCabW(hwnd, &cabinfo, pReserved);
 
    if (pCab->pszCab)
        RtlFreeUnicodeString(&cab);
 
    RtlFreeUnicodeString(&inf);
    RtlFreeUnicodeString(&section);
 
    return hr;
}

ExecuteCabW()

HRESULT WINAPI ExecuteCabW	(	HWND	hwnd,
		CABINFOW *	pCab,
		LPVOID	pReserved
	)

Definition at line 671 of file install.c.

{
    ADVInfo info;
    HRESULT hr;
 
    TRACE("(%p, %p, %p)\n", hwnd, pCab, pReserved);
 
    ZeroMemory(&info, sizeof(ADVInfo));
 
    if (pCab->pszCab && *pCab->pszCab)
        FIXME("Cab archive not extracted!\n");
 
    hr = install_init(pCab->pszInf, pCab->pszSection, pCab->szSrcPath, pCab->dwFlags, &info);
    if (hr != S_OK)
        goto done;
 
    hr = spapi_install(&info);
    if (hr != S_OK)
        goto done;
 
    hr = adv_install(&info);
 
done:
    install_release(&info);
 
    return hr;
}

Referenced by ExecuteCabA(), LaunchINFSectionExW(), and RegInstallW().

get_field_string()

static WCHAR * get_field_string ( INFCONTEXT *  context, DWORD  index, WCHAR *  buffer, const WCHAR *  static_buffer, DWORD *  size  )

static

Definition at line 242 of file install.c.

{
    DWORD required;
 
    if (SetupGetStringFieldW(context, index, buffer, *size, &required)) return buffer;
 
    if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
    {
        /* now grow the buffer */
        if (buffer != static_buffer) HeapFree(GetProcessHeap(), 0, buffer);
        if (!(buffer = HeapAlloc(GetProcessHeap(), 0, required*sizeof(WCHAR)))) return NULL;
        *size = required;
        if (SetupGetStringFieldW(context, index, buffer, *size, &required)) return buffer;
    }
 
    if (buffer != static_buffer) HeapFree(GetProcessHeap(), 0, buffer);
    return NULL;
}

Referenced by iterate_section_fields().

get_parameter()

LPWSTR get_parameter	(	LPWSTR *	params,
		WCHAR	separator,
		BOOL	quoted
	)

Definition at line 200 of file install.c.

{
    LPWSTR token = *params;
 
    if (!*params)
        return NULL;
 
    if (quoted && *token == '"')
    {
        WCHAR *end = wcschr(token + 1, '"');
        if (end)
        {
            *end = 0;
            *params = end + 1;
            token = token + 1;
        }
    }
 
    *params = wcschr(*params, separator);
    if (*params)
        *(*params)++ = '\0';
 
    if (!*token)
        return NULL;
 
    return token;
}

Referenced by DelNodeRunDLL32W(), LaunchINFSectionExW(), LaunchINFSectionW(), RegisterOCX(), and set_ldids().

get_working_dir()

static HRESULT get_working_dir ( ADVInfo *  info, LPCWSTR  inf_filename, LPCWSTR  working_dir  )

static

Definition at line 390 of file install.c.

{
    WCHAR path[MAX_PATH];
    LPCWSTR ptr;
    DWORD len;
 
    static const WCHAR backslash[] = {'\\',0};
    static const WCHAR inf_dir[] = {'\\','I','N','F',0};
 
    if ((ptr = wcsrchr(inf_filename, '\\')))
    {
        len = ptr - inf_filename + 1;
        ptr = inf_filename;
    }
    else if (working_dir && *working_dir)
    {
        len = lstrlenW(working_dir) + 1;
        ptr = working_dir;
    }
    else
    {
        GetCurrentDirectoryW(MAX_PATH, path);
        lstrcatW(path, backslash);
        lstrcatW(path, inf_filename);
 
        /* check if the INF file is in the current directory */
        if (GetFileAttributesW(path) != INVALID_FILE_ATTRIBUTES)
        {
            GetCurrentDirectoryW(MAX_PATH, path);
        }
        else
        {
            /* default to the windows\inf directory if all else fails */
            GetWindowsDirectoryW(path, MAX_PATH);
            lstrcatW(path, inf_dir);
        }
 
        len = lstrlenW(path) + 1;
        ptr = path;
    }
 
    info->working_dir = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
    if (!info->working_dir)
        return E_OUTOFMEMORY;
 
    lstrcpynW(info->working_dir, ptr, len);
 
    return S_OK;
}

Referenced by install_init().

install_init()

static HRESULT install_init ( LPCWSTR  inf_filename, LPCWSTR  install_sec, LPCWSTR  working_dir, DWORD  flags, ADVInfo *  info  )

static

Definition at line 441 of file install.c.

{
    DWORD len;
    HRESULT hr;
    LPCWSTR ptr, path;
 
    static const WCHAR backslash[] = {'\\',0};
    static const WCHAR default_install[] = {
        'D','e','f','a','u','l','t','I','n','s','t','a','l','l',0
    };
 
    if (!(ptr = wcsrchr(inf_filename, '\\')))
        ptr = inf_filename;
 
    len = lstrlenW(ptr);
 
    info->inf_filename = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR));
    if (!info->inf_filename)
        return E_OUTOFMEMORY;
 
    lstrcpyW(info->inf_filename, ptr);
 
    /* FIXME: determine the proper platform to install (NTx86, etc) */
    if (!install_sec || !*install_sec)
    {
        len = sizeof(default_install) - 1;
        ptr = default_install;
    }
    else
    {
        len = lstrlenW(install_sec);
        ptr = install_sec;
    }
 
    info->install_sec = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR));
    if (!info->install_sec)
        return E_OUTOFMEMORY;
 
    lstrcpyW(info->install_sec, ptr);
 
    hr = get_working_dir(info, inf_filename, working_dir);
    if (FAILED(hr))
        return hr;
 
    len = lstrlenW(info->working_dir) + lstrlenW(info->inf_filename) + 2;
    info->inf_path = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
    if (!info->inf_path)
        return E_OUTOFMEMORY;
 
    lstrcpyW(info->inf_path, info->working_dir);
    lstrcatW(info->inf_path, backslash);
    lstrcatW(info->inf_path, info->inf_filename);
 
    /* RunSetupCommand opens unmodified filename parameter */
    if (flags & RSC_FLAG_INF)
        path = inf_filename;
    else
        path = info->inf_path;
 
    info->hinf = SetupOpenInfFileW(path, NULL, INF_STYLE_WIN4, NULL);
    if (info->hinf == INVALID_HANDLE_VALUE)
        return ADV_HRESULT(GetLastError());
 
    set_ldids(info->hinf, info->install_sec, info->working_dir);
 
    /* FIXME: check that the INF is advanced */
 
    info->flags = flags;
    info->need_reboot = FALSE;
 
    return S_OK;
}

Referenced by DoInfInstallW(), ExecuteCabW(), LaunchINFSectionW(), and RunSetupCommandW().

install_release()

static void install_release ( const ADVInfo *  info )

static

Definition at line 516 of file install.c.

{
    SetupCloseInfFile(info->hinf);
 
    HeapFree(GetProcessHeap(), 0, info->inf_path);
    HeapFree(GetProcessHeap(), 0, info->inf_filename);
    HeapFree(GetProcessHeap(), 0, info->install_sec);
    HeapFree(GetProcessHeap(), 0, info->working_dir);
}

Referenced by DoInfInstallW(), ExecuteCabW(), LaunchINFSectionW(), and RunSetupCommandW().

is_full_path()

static BOOL is_full_path ( LPCWSTR  path )

static

Definition at line 228 of file install.c.

{
    const int MIN_PATH_LEN = 3;
 
    if (!path || lstrlenW(path) < MIN_PATH_LEN)
        return FALSE;
 
    if ((path[1] == ':' && path[2] == '\\') || (path[0] == '\\' && path[1] == '\\'))
        return TRUE;
 
    return FALSE;
}

Referenced by LaunchINFSectionExW().

iterate_section_fields()

static HRESULT iterate_section_fields ( HINF  hinf, PCWSTR  section, PCWSTR  key, iterate_fields_func  callback, void *  arg  )

static

Definition at line 263 of file install.c.

{
    WCHAR static_buffer[200];
    WCHAR *buffer = static_buffer;
    DWORD size = ARRAY_SIZE(static_buffer);
    INFCONTEXT context;
    HRESULT hr = E_FAIL;
 
    BOOL ok = SetupFindFirstLineW(hinf, section, key, &context);
    while (ok)
    {
        UINT i, count = SetupGetFieldCount(&context);
 
        for (i = 1; i <= count; i++)
        {
            if (!(buffer = get_field_string(&context, i, buffer, static_buffer, &size)))
                goto done;
 
            if ((hr = callback(hinf, buffer, arg)) != S_OK)
                goto done;
        }
 
        ok = SetupFindNextMatchLineW(&context, key, &context);
    }
 
    hr = S_OK;
 
 done:
    if (buffer != static_buffer) HeapFree(GetProcessHeap(), 0, buffer);
    return hr;
}

Referenced by adv_install(), SetupInstallFilesFromInfSectionW(), SetupInstallFromInfSectionW(), and SetupInstallServicesFromInfSectionExW().

launch_exe()

HRESULT launch_exe	(	LPCWSTR	cmd,
		LPCWSTR	dir,
		HANDLE *	phEXE
	)

Definition at line 894 of file install.c.

{
    STARTUPINFOW si;
    PROCESS_INFORMATION pi;
 
    if (phEXE) *phEXE = NULL;
 
    ZeroMemory(&pi, sizeof(pi));
    ZeroMemory(&si, sizeof(si));
    si.cb = sizeof(si);
 
    if (!CreateProcessW(NULL, (LPWSTR)cmd, NULL, NULL, FALSE,
                        CREATE_DEFAULT_ERROR_MODE | CREATE_NEW_PROCESS_GROUP,
                        NULL, dir, &si, &pi))
    {
        return HRESULT_FROM_WIN32(GetLastError());
    }
 
    CloseHandle(pi.hThread);
 
    if (phEXE)
    {
        *phEXE = pi.hProcess;
        return S_ASYNCHRONOUS;
    }
 
    /* wait for the child process to finish */
    WaitForSingleObject(pi.hProcess, INFINITE);
    CloseHandle(pi.hProcess);
 
    return S_OK;
}

Referenced by run_setup_commands_callback(), RunSetupCommandW(), and UserInstStubWrapperW().

LaunchINFSectionA()

INT WINAPI LaunchINFSectionA	(	HWND	hWnd,
		HINSTANCE	hInst,
		LPSTR	cmdline,
		INT	show
	)

Definition at line 704 of file install.c.

{
    UNICODE_STRING cmd;
    HRESULT hr;
 
    TRACE("(%p, %p, %s, %i)\n", hWnd, hInst, debugstr_a(cmdline), show);
 
    if (!cmdline)
        return ADV_FAILURE;
 
    RtlCreateUnicodeStringFromAsciiz(&cmd, cmdline);
 
    hr = LaunchINFSectionW(hWnd, hInst, cmd.Buffer, show);
 
    RtlFreeUnicodeString(&cmd);
 
    return hr;
}

LaunchINFSectionExA()

HRESULT WINAPI LaunchINFSectionExA	(	HWND	hWnd,
		HINSTANCE	hInst,
		LPSTR	cmdline,
		INT	show
	)

Definition at line 800 of file install.c.

{
    UNICODE_STRING cmd;
    HRESULT hr;
 
    TRACE("(%p, %p, %s, %i)\n", hWnd, hInst, debugstr_a(cmdline), show);
 
    if (!cmdline)
        return ADV_FAILURE;
 
    RtlCreateUnicodeStringFromAsciiz(&cmd, cmdline);
 
    hr = LaunchINFSectionExW(hWnd, hInst, cmd.Buffer, show);
 
    RtlFreeUnicodeString(&cmd);
 
    return hr;
}

LaunchINFSectionExW()

HRESULT WINAPI LaunchINFSectionExW	(	HWND	hWnd,
		HINSTANCE	hInst,
		LPWSTR	cmdline,
		INT	show
	)

Definition at line 846 of file install.c.

{
    LPWSTR cmdline_copy, cmdline_ptr;
    LPWSTR flags, ptr;
    CABINFOW cabinfo;
    HRESULT hr;
 
    TRACE("(%p, %p, %s, %d)\n", hWnd, hInst, debugstr_w(cmdline), show);
 
    if (!cmdline)
        return ADV_FAILURE;
 
    cmdline_copy = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(cmdline) + 1) * sizeof(WCHAR));
    cmdline_ptr = cmdline_copy;
    lstrcpyW(cmdline_copy, cmdline);
 
    cabinfo.pszInf = get_parameter(&cmdline_ptr, ',', TRUE);
    cabinfo.pszSection = get_parameter(&cmdline_ptr, ',', TRUE);
    cabinfo.pszCab = get_parameter(&cmdline_ptr, ',', TRUE);
    *cabinfo.szSrcPath = '\0';
 
    flags = get_parameter(&cmdline_ptr, ',', TRUE);
    if (flags)
        cabinfo.dwFlags = wcstol(flags, NULL, 10);
 
    if (!is_full_path(cabinfo.pszCab) && !is_full_path(cabinfo.pszInf))
    {
        HeapFree(GetProcessHeap(), 0, cmdline_copy);
        return E_INVALIDARG;
    }
 
    /* get the source path from the cab filename */
    if (cabinfo.pszCab && *cabinfo.pszCab)
    {
        if (!is_full_path(cabinfo.pszCab))
            lstrcpyW(cabinfo.szSrcPath, cabinfo.pszInf);
        else
            lstrcpyW(cabinfo.szSrcPath, cabinfo.pszCab);
 
        ptr = wcsrchr(cabinfo.szSrcPath, '\\');
        *(++ptr) = '\0';
    }
 
    hr = ExecuteCabW(hWnd, &cabinfo, NULL);
    HeapFree(GetProcessHeap(), 0, cmdline_copy);
    return SUCCEEDED(hr) ? ADV_SUCCESS : ADV_FAILURE;
}

Referenced by LaunchINFSectionExA().

LaunchINFSectionW()

INT WINAPI LaunchINFSectionW	(	HWND	hWnd,
		HINSTANCE	hInst,
		LPWSTR	cmdline,
		INT	show
	)

Definition at line 747 of file install.c.

{
    ADVInfo info;
    LPWSTR cmdline_copy, cmdline_ptr;
    LPWSTR inf_filename, install_sec;
    LPWSTR str_flags;
    DWORD flags = 0;
    HRESULT hr = S_OK;
 
    TRACE("(%p, %p, %s, %d)\n", hWnd, hInst, debugstr_w(cmdline), show);
 
    if (!cmdline)
        return ADV_FAILURE;
 
    cmdline_copy = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(cmdline) + 1) * sizeof(WCHAR));
    cmdline_ptr = cmdline_copy;
    lstrcpyW(cmdline_copy, cmdline);
 
    inf_filename = get_parameter(&cmdline_ptr, ',', TRUE);
    install_sec = get_parameter(&cmdline_ptr, ',', TRUE);
 
    str_flags = get_parameter(&cmdline_ptr, ',', TRUE);
    if (str_flags)
    {
        DWORD inf_flags = wcstol(str_flags, NULL, 10);
        if (inf_flags & LIS_QUIET) flags |= RSC_FLAG_QUIET;
        if (inf_flags & LIS_NOGRPCONV) flags |= RSC_FLAG_NGCONV;
    }
 
    ZeroMemory(&info, sizeof(ADVInfo));
 
    hr = install_init(inf_filename, install_sec, NULL, flags, &info);
    if (hr != S_OK)
        goto done;
 
    hr = spapi_install(&info);
    if (hr != S_OK)
        goto done;
 
    hr = adv_install(&info);
 
done:
    install_release(&info);
    HeapFree(GetProcessHeap(), 0, cmdline_copy);
 
    return SUCCEEDED(hr) ? ADV_SUCCESS : ADV_FAILURE;
}

Referenced by LaunchINFSectionA().

per_user_install_callback()

static HRESULT per_user_install_callback ( HINF  hinf, PCWSTR  field, const void *  arg  )

static

Definition at line 100 of file install.c.

{
    PERUSERSECTIONW per_user;
    INFCONTEXT context;
    DWORD size;
 
    static const WCHAR disp_name[] = {'D','i','s','p','l','a','y','N','a','m','e',0};
    static const WCHAR version[] = {'V','e','r','s','i','o','n',0};
    static const WCHAR is_installed[] = {'I','s','I','n','s','t','a','l','l','e','d',0};
    static const WCHAR comp_id[] = {'C','o','m','p','o','n','e','n','t','I','D',0};
    static const WCHAR guid[] = {'G','U','I','D',0};
    static const WCHAR locale[] = {'L','o','c','a','l','e',0};
    static const WCHAR stub_path[] = {'S','t','u','b','P','a','t','h',0};
 
    per_user.bRollback = FALSE;
    per_user.dwIsInstalled = 0;
 
    SetupGetLineTextW(NULL, hinf, field, disp_name, per_user.szDispName, ARRAY_SIZE(per_user.szDispName), &size);
 
    SetupGetLineTextW(NULL, hinf, field, version, per_user.szVersion, ARRAY_SIZE(per_user.szVersion), &size);
 
    if (SetupFindFirstLineW(hinf, field, is_installed, &context))
    {
        SetupGetIntField(&context, 1, (PINT)&per_user.dwIsInstalled);
    }
 
    SetupGetLineTextW(NULL, hinf, field, comp_id, per_user.szCompID, ARRAY_SIZE(per_user.szCompID), &size);
 
    SetupGetLineTextW(NULL, hinf, field, guid, per_user.szGUID, ARRAY_SIZE(per_user.szGUID), &size);
 
    SetupGetLineTextW(NULL, hinf, field, locale, per_user.szLocale, ARRAY_SIZE(per_user.szLocale), &size);
 
    SetupGetLineTextW(NULL, hinf, field, stub_path, per_user.szStub, ARRAY_SIZE(per_user.szStub), &size);
 
    return SetPerUserSecValuesW(&per_user);
}

Referenced by adv_install().

register_ocxs_callback()

static HRESULT register_ocxs_callback ( HINF  hinf, PCWSTR  field, const void *  arg  )

static

Definition at line 137 of file install.c.

{
    HMODULE hm;
    INFCONTEXT context;
    HRESULT hr = S_OK;
 
    BOOL ok = SetupFindFirstLineW(hinf, field, NULL, &context);
    
    for (; ok; ok = SetupFindNextLine(&context, &context))
    {
        WCHAR buffer[MAX_INF_STRING_LENGTH];
 
        /* get OCX filename */
        if (!SetupGetStringFieldW(&context, 1, buffer, ARRAY_SIZE(buffer), NULL))
            continue;
 
        hm = LoadLibraryExW(buffer, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
        if (hm)
        {
            if (do_ocx_reg(hm, TRUE, NULL, NULL) != S_OK)
                hr = E_FAIL;
 
            FreeLibrary(hm);
        }
        else
            hr = E_FAIL;
 
        if (FAILED(hr))
        {
            /* FIXME: display a message box */
            break;
        }
    }
 
    return hr;
}

Referenced by adv_install().

run_setup_commands_callback()

static HRESULT run_setup_commands_callback ( HINF  hinf, PCWSTR  field, const void *  arg  )

static

Definition at line 174 of file install.c.

{
    const ADVInfo *info = (const ADVInfo *)arg;
    INFCONTEXT context;
    HRESULT hr = S_OK;
    DWORD size;
 
    BOOL ok = SetupFindFirstLineW(hinf, field, NULL, &context);
 
    for (; ok; ok = SetupFindNextLine(&context, &context))
    {
        WCHAR buffer[MAX_INF_STRING_LENGTH];
 
        if (!SetupGetLineTextW(&context, NULL, NULL, NULL, buffer,
                               MAX_INF_STRING_LENGTH, &size))
            continue;
 
        if (launch_exe(buffer, info->working_dir, NULL) != S_OK)
            hr = E_FAIL;
    }
 
    return hr;
}

Referenced by adv_install().

RunSetupCommandA()

HRESULT WINAPI RunSetupCommandA	(	HWND	hWnd,
		LPCSTR	szCmdName,
		LPCSTR	szInfSection,
		LPCSTR	szDir,
		LPCSTR	lpszTitle,
		HANDLE *	phEXE,
		DWORD	dwFlags,
		LPVOID	pvReserved
	)

Definition at line 932 of file install.c.

{
    UNICODE_STRING cmdname, infsec;
    UNICODE_STRING dir, title;
    HRESULT hr;
 
    TRACE("(%p, %s, %s, %s, %s, %p, %d, %p)\n",
          hWnd, debugstr_a(szCmdName), debugstr_a(szInfSection),
          debugstr_a(szDir), debugstr_a(lpszTitle),
          phEXE, dwFlags, pvReserved);
 
    if (!szCmdName || !szDir)
        return E_INVALIDARG;
 
    RtlCreateUnicodeStringFromAsciiz(&cmdname, szCmdName);
    RtlCreateUnicodeStringFromAsciiz(&infsec, szInfSection);
    RtlCreateUnicodeStringFromAsciiz(&dir, szDir);
    RtlCreateUnicodeStringFromAsciiz(&title, lpszTitle);
 
    hr = RunSetupCommandW(hWnd, cmdname.Buffer, infsec.Buffer, dir.Buffer,
                          title.Buffer, phEXE, dwFlags, pvReserved);
 
    RtlFreeUnicodeString(&cmdname);
    RtlFreeUnicodeString(&infsec);
    RtlFreeUnicodeString(&dir);
    RtlFreeUnicodeString(&title);
 
    return hr;
}

RunSetupCommandW()

HRESULT WINAPI RunSetupCommandW	(	HWND	hWnd,
		LPCWSTR	szCmdName,
		LPCWSTR	szInfSection,
		LPCWSTR	szDir,
		LPCWSTR	lpszTitle,
		HANDLE *	phEXE,
		DWORD	dwFlags,
		LPVOID	pvReserved
	)

Definition at line 990 of file install.c.

{
    ADVInfo info;
    HRESULT hr;
 
    TRACE("(%p, %s, %s, %s, %s, %p, %d, %p)\n",
          hWnd, debugstr_w(szCmdName), debugstr_w(szInfSection),
          debugstr_w(szDir), debugstr_w(lpszTitle),
          phEXE, dwFlags, pvReserved);
 
    if (dwFlags & RSC_FLAG_UPDHLPDLLS)
        FIXME("Unhandled flag: RSC_FLAG_UPDHLPDLLS\n");
 
    if (!szCmdName || !szDir)
        return E_INVALIDARG;
 
    if (!(dwFlags & RSC_FLAG_INF))
        return launch_exe(szCmdName, szDir, phEXE);
 
    ZeroMemory(&info, sizeof(ADVInfo));
 
    hr = install_init(szCmdName, szInfSection, szDir, dwFlags, &info);
    if (hr != S_OK)
        goto done;
 
    hr = spapi_install(&info);
    if (hr != S_OK)
        goto done;
 
    hr = adv_install(&info);
 
done:
    install_release(&info);
 
    return hr;
}

Referenced by install_inf_file(), process_hook_section(), and RunSetupCommandA().

spapi_install()

static HRESULT spapi_install ( const ADVInfo *  info )

static

Definition at line 316 of file install.c.

{
    BOOL ret;
    HRESULT res;
    PVOID context;
 
    context = SetupInitDefaultQueueCallbackEx(NULL, INVALID_HANDLE_VALUE, 0, 0, NULL);
    if (!context)
        return ADV_HRESULT(GetLastError());
 
    ret = SetupInstallFromInfSectionW(NULL, info->hinf, info->install_sec,
                                      SPINST_FILES, NULL, info->working_dir,
                                      SP_COPY_NEWER, SetupDefaultQueueCallbackW,
                                      context, NULL, NULL);
    if (!ret)
    {
        res = ADV_HRESULT(GetLastError());
        SetupTermDefaultQueueCallback(context);
 
        return res;
    }
 
    SetupTermDefaultQueueCallback(context);
 
    ret = SetupInstallFromInfSectionW(NULL, info->hinf, info->install_sec,
                                      SPINST_INIFILES | SPINST_REGISTRY | SPINST_REGSVR,
                                      HKEY_LOCAL_MACHINE, NULL, 0,
                                      NULL, NULL, NULL, NULL);
    if (!ret)
        return ADV_HRESULT(GetLastError());
 
    return S_OK;
}

Referenced by DoInfInstallW(), ExecuteCabW(), LaunchINFSectionW(), and RunSetupCommandW().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

advpack

)

Variable Documentation

CheckAdminRights

const WCHAR CheckAdminRights[]

static

Initial value:

= {
    'C','h','e','c','k','A','d','m','i','n','R','i','g','h','t','s',0
}

Definition at line 63 of file install.c.

Referenced by check_admin_rights().

DelDirs

const WCHAR DelDirs[] = {'D','e','l','D','i','r','s',0}

static

Definition at line 66 of file install.c.

Referenced by adv_install().

PerUserInstall

const WCHAR PerUserInstall[] = {'P','e','r','U','s','e','r','I','n','s','t','a','l','l',0}

static

Definition at line 67 of file install.c.

Referenced by adv_install().

RegisterOCXs

const WCHAR RegisterOCXs[] = {'R','e','g','i','s','t','e','r','O','C','X','s',0}

static

Definition at line 68 of file install.c.

Referenced by adv_install().

RunPostSetupCommands

const WCHAR RunPostSetupCommands[]

static

Initial value:

= {
    'R','u','n','P','o','s','t','S','e','t','u','p','C','o','m','m','a','n','d','s',0
}

Definition at line 72 of file install.c.

Referenced by adv_install().

RunPreSetupCommands

const WCHAR RunPreSetupCommands[]

static

Initial value:

= {
    'R','u','n','P','r','e','S','e','t','u','p','C','o','m','m','a','n','d','s',0
}

Definition at line 69 of file install.c.

Referenced by adv_install().