msiexec.c File Reference

#include <windows.h>
#include <commctrl.h>
#include <msi.h>
#include <winsvc.h>
#include <objbase.h>
#include <stdio.h>
#include "wine/debug.h"
#include "wine/heap.h"
#include "initguid.h"

Include dependency graph for msiexec.c:

Go to the source code of this file.

Classes
struct	string_list

Macros
#define	WIN32_LEAN_AND_MEAN

Typedefs
typedef HRESULT(WINAPI *	DLLREGISTERSERVER) (void)
typedef HRESULT(WINAPI *	DLLUNREGISTERSERVER) (void)

Enumerations
enum	chomp_state { CS_WHITESPACE, CS_TOKEN, CS_QUOTE }

Functions
	DEFINE_GUID (GUID_NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
	WINE_DEFAULT_DEBUG_CHANNEL (msiexec)
DWORD	DoService (void)
static void	ShowUsage (int ExitCode)
static BOOL	IsProductCode (LPWSTR str)
static VOID	StringListAppend (struct string_list **list, LPCWSTR str)
static LPWSTR	build_properties (struct string_list *property_list)
static LPWSTR	build_transforms (struct string_list *transform_list)
static DWORD	msi_atou (LPCWSTR str)
static BOOL	msi_strequal (LPCWSTR str1, LPCSTR str2)
static BOOL	msi_option_equal (LPCWSTR str1, LPCSTR str2)
static BOOL	msi_strprefix (LPCWSTR str1, LPCSTR str2)
static BOOL	msi_option_prefix (LPCWSTR str1, LPCSTR str2)
static VOID *	LoadProc (LPCWSTR DllName, LPCSTR ProcName, HMODULE *DllHandle)
static DWORD	DoDllRegisterServer (LPCWSTR DllName)
static DWORD	DoDllUnregisterServer (LPCWSTR DllName)
static DWORD	DoRegServer (void)
static DWORD	DoUnregServer (void)
UINT CDECL	__wine_msi_call_dll_function (DWORD client_pid, const GUID *guid)
static DWORD CALLBACK	custom_action_thread (void *arg)
static int	custom_action_server (const WCHAR *arg)
static int	chomp (const WCHAR *in, WCHAR *out)
static void	process_args (WCHAR *cmdline, int *pargc, WCHAR ***pargv)
static BOOL	process_args_from_reg (const WCHAR *ident, int *pargc, WCHAR ***pargv)
static WCHAR *	get_path_with_extension (const WCHAR *package_name)
int WINAPI	WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)

Variables
static DWORD	client_pid

Macro Definition Documentation

WIN32_LEAN_AND_MEAN

#define WIN32_LEAN_AND_MEAN

Definition at line 22 of file msiexec.c.

Typedef Documentation

DLLREGISTERSERVER

typedef HRESULT(WINAPI * DLLREGISTERSERVER) (void)

Definition at line 39 of file msiexec.c.

DLLUNREGISTERSERVER

typedef HRESULT(WINAPI * DLLUNREGISTERSERVER) (void)

Definition at line 40 of file msiexec.c.

Enumeration Type Documentation

chomp_state

enum chomp_state

Enumerator
CS_WHITESPACE
CS_TOKEN
CS_QUOTE

Definition at line 455 of file msiexec.c.

{
    CS_WHITESPACE,
    CS_TOKEN,
    CS_QUOTE
};

Function Documentation

__wine_msi_call_dll_function()

UINT CDECL __wine_msi_call_dll_function	(	DWORD	client_pid,
		const GUID *	guid
	)

Definition at line 507 of file custom.c.

{
    MsiCustomActionEntryPoint fn;
    MSIHANDLE remote_package = 0;
    RPC_WSTR binding_str;
    MSIHANDLE hPackage;
    RPC_STATUS status;
    WCHAR *dll = NULL, *action = NULL;
    LPSTR proc = NULL;
    HANDLE hModule;
    INT type;
    UINT r;

    TRACE("%s\n", debugstr_guid( guid ));

    if (!rpc_handle)
    {
        WCHAR endpoint[12];

        swprintf(endpoint, ARRAY_SIZE(endpoint), L"msi%x", client_pid);
        status = RpcStringBindingComposeW(NULL, (WCHAR *)L"ncalrpc", NULL, endpoint, NULL, &binding_str);
        if (status != RPC_S_OK)
        {
            ERR("RpcStringBindingCompose failed: %#lx\n", status);
            return status;
        }
        status = RpcBindingFromStringBindingW(binding_str, &rpc_handle);
        if (status != RPC_S_OK)
        {
            ERR("RpcBindingFromStringBinding failed: %#lx\n", status);
            return status;
        }
        RpcStringFreeW(&binding_str);
    }

    r = remote_GetActionInfo(guid, &action, &type, &dll, &proc, &remote_package);
    if (r != ERROR_SUCCESS)
        return r;

    hPackage = alloc_msi_remote_handle( remote_package );
    if (!hPackage)
    {
        ERR( "failed to create handle for %#lx\n", remote_package );
        midl_user_free( action );
        midl_user_free( dll );
        midl_user_free( proc );
        return ERROR_INSTALL_FAILURE;
    }

    hModule = LoadLibraryW( dll );
    if (!hModule)
    {
        ERR( "failed to load dll %s (%lu)\n", debugstr_w( dll ), GetLastError() );
        midl_user_free( action );
        midl_user_free( dll );
        midl_user_free( proc );
        MsiCloseHandle( hPackage );
        return ERROR_SUCCESS;
    }

    fn = (MsiCustomActionEntryPoint) GetProcAddress( hModule, proc );
    if (!fn) WARN( "GetProcAddress(%s) failed\n", debugstr_a(proc) );
    else
    {
        handle_msi_break(action);

        __TRY
        {
            r = custom_proc_wrapper( fn, hPackage );
        }
        __EXCEPT_PAGE_FAULT
        {
            ERR( "Custom action (%s:%s) caused a page fault: %#lx\n",
                 debugstr_w(dll), debugstr_a(proc), GetExceptionCode() );
            r = ERROR_SUCCESS;
        }
        __ENDTRY;
    }

    FreeLibrary(hModule);

    midl_user_free(action);
    midl_user_free(dll);
    midl_user_free(proc);

    MsiCloseAllHandles();
    return r;
}

Referenced by custom_action_thread().

build_properties()

static LPWSTR build_properties ( struct string_list *  property_list )

static

Definition at line 122 of file msiexec.c.

{
    struct string_list *list;
    LPWSTR ret, p, value;
    DWORD len;
    BOOL needs_quote;

    if(!property_list)
        return NULL;

    /* count the space we need */
    len = 1;
    for(list = property_list; list; list = list->next)
        len += lstrlenW(list->str) + 3;

    ret = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );

    /* add a space before each string, and quote the value */
    p = ret;
    for(list = property_list; list; list = list->next)
    {
        value = wcschr(list->str,'=');
        if(!value)
            continue;
        len = value - list->str;
        *p++ = ' ';
        memcpy(p, list->str, len * sizeof(WCHAR));
        p += len;
        *p++ = '=';

        /* check if the value contains spaces and maybe quote it */
        value++;
        needs_quote = wcschr(value,' ') ? 1 : 0;
        if(needs_quote)
            *p++ = '"';
        len = lstrlenW(value);
        memcpy(p, value, len * sizeof(WCHAR));
        p += len;
        if(needs_quote)
            *p++ = '"';
    }
    *p = 0;

    WINE_TRACE("properties -> %s\n", wine_dbgstr_w(ret) );

    return ret;
}

Referenced by WinMain().

build_transforms()

static LPWSTR build_transforms ( struct string_list *  transform_list )

static

Definition at line 170 of file msiexec.c.

{
    struct string_list *list;
    LPWSTR ret, p;
    DWORD len;

    /* count the space we need */
    len = 1;
    for(list = transform_list; list; list = list->next)
        len += lstrlenW(list->str) + 1;

    ret = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );

    /* add all the transforms with a semicolon between each one */
    p = ret;
    for(list = transform_list; list; list = list->next)
    {
        len = lstrlenW(list->str);
        lstrcpynW(p, list->str, len );
        p += len;
        if(list->next)
            *p++ = ';';
    }
    *p = 0;

    return ret;
}

Referenced by WinMain().

chomp()

static int chomp ( const WCHAR *  in, WCHAR *  out  )

static

Definition at line 462 of file msiexec.c.

{
    enum chomp_state state = CS_TOKEN;
    const WCHAR *p;
    int count = 1;
    BOOL ignore;

    for (p = in; *p; p++)
    {
        ignore = TRUE;
        switch (state)
        {
        case CS_WHITESPACE:
            switch (*p)
            {
            case ' ':
                break;
            case '"':
                state = CS_QUOTE;
                count++;
                break;
            default:
                count++;
                ignore = FALSE;
                state = CS_TOKEN;
            }
            break;

        case CS_TOKEN:
            switch (*p)
            {
            case '"':
                state = CS_QUOTE;
                break;
            case ' ':
                state = CS_WHITESPACE;
                if (out) *out++ = 0;
                break;
            default:
                if (p > in && p[-1] == '"')
                {
                    if (out) *out++ = 0;
                    count++;
                }
                ignore = FALSE;
            }
            break;

        case CS_QUOTE:
            switch (*p)
            {
            case '"':
                state = CS_TOKEN;
                break;
            default:
                ignore = FALSE;
            }
            break;
        }
        if (!ignore && out) *out++ = *p;
    }
    if (out) *out = 0;
    return count;
}

Referenced by process_args().

custom_action_server()

static int custom_action_server ( const WCHAR *  arg )

static

Definition at line 395 of file msiexec.c.

{
    GUID guid, *thread_guid;
    DWORD64 thread64;
    WCHAR buffer[24];
    HANDLE thread;
    HANDLE pipe;
    DWORD size;

    TRACE("%s\n", debugstr_w(arg));

    if (!(client_pid = wcstol(arg, NULL, 10)))
    {
        ERR("Invalid parameter %s\n", debugstr_w(arg));
        return 1;
    }

    swprintf(buffer, ARRAY_SIZE(buffer), L"\\\\.\\pipe\\msica_%x_%d", client_pid, (int)(sizeof(void *) * 8));
    pipe = CreateFileW(buffer, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
    if (pipe == INVALID_HANDLE_VALUE)
    {
        ERR("Failed to create custom action server pipe: %lu\n", GetLastError());
        return GetLastError();
    }

    /* We need this to unmarshal streams, and some apps expect it to be present. */
    CoInitializeEx(NULL, COINIT_MULTITHREADED);

    while (ReadFile(pipe, &guid, sizeof(guid), &size, NULL) && size == sizeof(guid))
    {
        if (IsEqualGUID(&guid, &GUID_NULL))
        {
            /* package closed; time to shut down */
            CoUninitialize();
            return 0;
        }

        thread_guid = heap_alloc(sizeof(GUID));
        memcpy(thread_guid, &guid, sizeof(GUID));
        thread = CreateThread(NULL, 0, custom_action_thread, thread_guid, 0, NULL);

        /* give the thread handle to the client to wait on, since we might have
         * to run a nested action and can't block during this one */
        thread64 = (DWORD_PTR)thread;
        if (!WriteFile(pipe, &thread64, sizeof(thread64), &size, NULL) || size != sizeof(thread64))
        {
            ERR("Failed to write to custom action server pipe: %lu\n", GetLastError());
            CoUninitialize();
            return GetLastError();
        }
    }
    ERR("Failed to read from custom action server pipe: %lu\n", GetLastError());
    CoUninitialize();
    return GetLastError();
}

Referenced by WinMain().

custom_action_thread()

static DWORD CALLBACK custom_action_thread ( void *  arg )

static

Definition at line 388 of file msiexec.c.

{
    GUID guid = *(GUID *)arg;
    heap_free(arg);
    return __wine_msi_call_dll_function(client_pid, &guid);
}

Referenced by custom_action_server().

DEFINE_GUID()

DEFINE_GUID	(	GUID_NULL	,
		0	,
		0	,
		0	,
		0	,
		0	,
		0	,
		0	,
		0	,
		0	,
		0	,
		0
	)

DoDllRegisterServer()

static DWORD DoDllRegisterServer ( LPCWSTR  DllName )

static

Definition at line 288 of file msiexec.c.

{
    HRESULT hr;
    DLLREGISTERSERVER pfDllRegisterServer = NULL;
    HMODULE DllHandle = NULL;

    pfDllRegisterServer = LoadProc(DllName, "DllRegisterServer", &DllHandle);

    hr = pfDllRegisterServer();
    if(FAILED(hr))
    {
        fprintf(stderr, "Failed to register dll %s\n", wine_dbgstr_w(DllName));
        return 1;
    }
    printf("Successfully registered dll %s\n", wine_dbgstr_w(DllName));
    if(DllHandle)
        FreeLibrary(DllHandle);
    return 0;
}

Referenced by WinMain().

DoDllUnregisterServer()

static DWORD DoDllUnregisterServer ( LPCWSTR  DllName )

static

Definition at line 308 of file msiexec.c.

{
    HRESULT hr;
    DLLUNREGISTERSERVER pfDllUnregisterServer = NULL;
    HMODULE DllHandle = NULL;

    pfDllUnregisterServer = LoadProc(DllName, "DllUnregisterServer", &DllHandle);

    hr = pfDllUnregisterServer();
    if(FAILED(hr))
    {
        fprintf(stderr, "Failed to unregister dll %s\n", wine_dbgstr_w(DllName));
        return 1;
    }
    printf("Successfully unregistered dll %s\n", wine_dbgstr_w(DllName));
    if(DllHandle)
        FreeLibrary(DllHandle);
    return 0;
}

Referenced by WinMain().

DoRegServer()

static DWORD DoRegServer ( void  )

static

Definition at line 328 of file msiexec.c.

{
    SC_HANDLE scm, service;
    WCHAR path[MAX_PATH+12];
    DWORD len, ret = 0;

    if (!(scm = OpenSCManagerW(NULL, SERVICES_ACTIVE_DATABASEW, SC_MANAGER_CREATE_SERVICE)))
    {
        fprintf(stderr, "Failed to open the service control manager.\n");
        return 1;
    }
    len = GetSystemDirectoryW(path, MAX_PATH);
    lstrcpyW(path + len, L"\\msiexec /V");
    if ((service = CreateServiceW(scm, L"MSIServer", L"MSIServer", GENERIC_ALL,
                                  SERVICE_WIN32_SHARE_PROCESS, SERVICE_DEMAND_START,
                                  SERVICE_ERROR_NORMAL, path, NULL, NULL, NULL, NULL, NULL)))
    {
        CloseServiceHandle(service);
    }
    else if (GetLastError() != ERROR_SERVICE_EXISTS)
    {
        fprintf(stderr, "Failed to create MSI service\n");
        ret = 1;
    }
    CloseServiceHandle(scm);
    return ret;
}

Referenced by WinMain().

DoService()

DWORD DoService

(

void

)

Definition at line 155 of file service.c.

{
    char service_name[] = "MSIServer";

    const SERVICE_TABLE_ENTRYA service[] =
    {
        {service_name, ServiceMain},
        {NULL, NULL},
    };

    WINE_TRACE("Starting MSIServer service\n");

    if (!StartServiceCtrlDispatcherA(service))
    {
        fprintf(stderr, "Failed to start MSIServer service\n");
        return 1;
    }

    return 0;
}

Referenced by WinMain().

DoUnregServer()

static DWORD DoUnregServer ( void  )

static

Definition at line 356 of file msiexec.c.

{
    SC_HANDLE scm, service;
    DWORD ret = 0;

    if (!(scm = OpenSCManagerW(NULL, SERVICES_ACTIVE_DATABASEW, SC_MANAGER_CONNECT)))
    {
        fprintf(stderr, "Failed to open service control manager\n");
        return 1;
    }
    if ((service = OpenServiceW(scm, L"MSIServer", DELETE)))
    {
        if (!DeleteService(service))
        {
            fprintf(stderr, "Failed to delete MSI service\n");
            ret = 1;
        }
        CloseServiceHandle(service);
    }
    else if (GetLastError() != ERROR_SERVICE_DOES_NOT_EXIST)
    {
        fprintf(stderr, "Failed to open MSI service\n");
        ret = 1;
    }
    CloseServiceHandle(scm);
    return ret;
}

Referenced by WinMain().

get_path_with_extension()

static WCHAR* get_path_with_extension ( const WCHAR *  package_name )

static

Definition at line 591 of file msiexec.c.

{
    static const WCHAR ext[] = L".msi";
    unsigned int p;
    WCHAR *path;

    if (!(path = heap_alloc(lstrlenW(package_name) * sizeof(WCHAR) + sizeof(ext))))
    {
        WINE_ERR("No memory.\n");
        return NULL;
    }

    lstrcpyW(path, package_name);
    p = lstrlenW(path);
    while (p && path[p] != '.' && path[p] != L'\\' && path[p] != '/')
        --p;
    if (path[p] == '.')
    {
        heap_free(path);
        return NULL;
    }
    lstrcatW(path, ext);
    return path;
}

Referenced by WinMain().

IsProductCode()

static BOOL IsProductCode ( LPWSTR  str )

static

Definition at line 90 of file msiexec.c.

{
    GUID ProductCode;

    if(lstrlenW(str) != 38)
        return FALSE;
    return ( (CLSIDFromString(str, &ProductCode) == NOERROR) );

}

Referenced by WinMain().

LoadProc()

static VOID* LoadProc ( LPCWSTR  DllName, LPCSTR  ProcName, HMODULE *  DllHandle  )

static

Definition at line 266 of file msiexec.c.

{
    VOID* (*proc)(void);

    *DllHandle = LoadLibraryExW(DllName, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
    if(!*DllHandle)
    {
        fprintf(stderr, "Unable to load dll %s\n", wine_dbgstr_w(DllName));
        ExitProcess(1);
    }
    proc = (VOID *) GetProcAddress(*DllHandle, ProcName);
    if(!proc)
    {
        fprintf(stderr, "Dll %s does not implement function %s\n",
            wine_dbgstr_w(DllName), ProcName);
        FreeLibrary(*DllHandle);
        ExitProcess(1);
    }

    return proc;
}

Referenced by DoDllRegisterServer(), DoDllUnregisterServer(), and load_data().

msi_atou()

static DWORD msi_atou ( LPCWSTR  str )

static

Definition at line 198 of file msiexec.c.

{
    DWORD ret = 0;
    while(*str >= '0' && *str <= '9')
    {
        ret *= 10;
        ret += (*str - '0');
        str++;
    }
    return ret;
}

Referenced by WinMain().

msi_option_equal()

static BOOL msi_option_equal ( LPCWSTR  str1, LPCSTR  str2  )

static

Definition at line 229 of file msiexec.c.

{
    if (str1[0] != '/' && str1[0] != '-')
        return FALSE;

    /* skip over the hyphen or slash */
    return msi_strequal(str1 + 1, str2);
}

Referenced by WinMain().

msi_option_prefix()

static BOOL msi_option_prefix ( LPCWSTR  str1, LPCSTR  str2  )

static

Definition at line 257 of file msiexec.c.

{
    if (str1[0] != '/' && str1[0] != '-')
        return FALSE;

    /* skip over the hyphen or slash */
    return msi_strprefix(str1 + 1, str2);
}

Referenced by WinMain().

msi_strequal()

static BOOL msi_strequal ( LPCWSTR  str1, LPCSTR  str2  )

static

Definition at line 211 of file msiexec.c.

{
    DWORD len, ret;
    LPWSTR strW;

    len = MultiByteToWideChar( CP_ACP, 0, str2, -1, NULL, 0);
    if( !len )
        return FALSE;
    if( lstrlenW(str1) != (len-1) )
        return FALSE;
    strW = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR)*len);
    MultiByteToWideChar( CP_ACP, 0, str2, -1, strW, len);
    ret = CompareStringW(GetThreadLocale(), NORM_IGNORECASE, str1, len, strW, len);
    HeapFree(GetProcessHeap(), 0, strW);
    return (ret == CSTR_EQUAL);
}

Referenced by msi_option_equal(), and WinMain().

msi_strprefix()

static BOOL msi_strprefix ( LPCWSTR  str1, LPCSTR  str2  )

static

Definition at line 239 of file msiexec.c.

{
    DWORD len, ret;
    LPWSTR strW;

    len = MultiByteToWideChar( CP_ACP, 0, str2, -1, NULL, 0);
    if( !len )
        return FALSE;
    if( lstrlenW(str1) < (len-1) )
        return FALSE;
    strW = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR)*len);
    MultiByteToWideChar( CP_ACP, 0, str2, -1, strW, len);
    ret = CompareStringW(GetThreadLocale(), NORM_IGNORECASE, str1, len-1, strW, len-1);
    HeapFree(GetProcessHeap(), 0, strW);
    return (ret == CSTR_EQUAL);
}

Referenced by msi_option_prefix(), and WinMain().

process_args()

static void process_args ( WCHAR *  cmdline, int *  pargc, WCHAR ***  pargv  )

static

Definition at line 527 of file msiexec.c.

{
    WCHAR **argv, *p;
    int i, count;

    *pargc = 0;
    *pargv = NULL;

    count = chomp( cmdline, NULL );
    if (!(p = HeapAlloc( GetProcessHeap(), 0, (lstrlenW(cmdline) + count + 1) * sizeof(WCHAR) )))
        return;

    count = chomp( cmdline, p );
    if (!(argv = HeapAlloc( GetProcessHeap(), 0, (count + 1) * sizeof(WCHAR *) )))
    {
        HeapFree( GetProcessHeap(), 0, p );
        return;
    }
    for (i = 0; i < count; i++)
    {
        argv[i] = p;
        p += lstrlenW( p ) + 1;
    }
    argv[i] = NULL;

    *pargc = count;
    *pargv = argv;
}

Referenced by process_args_from_reg(), and WinMain().

process_args_from_reg()

static BOOL process_args_from_reg ( const WCHAR *  ident, int *  pargc, WCHAR ***  pargv  )

static

Definition at line 556 of file msiexec.c.

{
    LONG r;
    HKEY hkey;
    DWORD sz = 0, type = 0;
    WCHAR *buf;
    BOOL ret = FALSE;

    r = RegOpenKeyW(HKEY_LOCAL_MACHINE,
            L"Software\\Microsoft\\Windows\\CurrentVersion\\Installer\\RunOnceEntries", &hkey);
    if(r != ERROR_SUCCESS)
        return FALSE;
    r = RegQueryValueExW(hkey, ident, 0, &type, 0, &sz);
    if(r == ERROR_SUCCESS && type == REG_SZ)
    {
        int len = lstrlenW( *pargv[0] );
        if (!(buf = HeapAlloc( GetProcessHeap(), 0, sz + (len + 1) * sizeof(WCHAR) )))
        {
            RegCloseKey( hkey );
            return FALSE;
        }
        memcpy( buf, *pargv[0], len * sizeof(WCHAR) );
        buf[len++] = ' ';
        r = RegQueryValueExW(hkey, ident, 0, &type, (LPBYTE)(buf + len), &sz);
        if( r == ERROR_SUCCESS )
        {
            process_args(buf, pargc, pargv);
            ret = TRUE;
        }
        HeapFree(GetProcessHeap(), 0, buf);
    }
    RegCloseKey(hkey);
    return ret;
}

Referenced by WinMain().

ShowUsage()

static void ShowUsage ( int  ExitCode )

static

Definition at line 50 of file msiexec.c.

{
    WCHAR msiexec_version[40];
    WCHAR filename[MAX_PATH];
    LPWSTR msi_res;
    LPWSTR msiexec_help;
    HMODULE hmsi = GetModuleHandleA("msi.dll");
    DWORD len;
    DWORD res;

    /* MsiGetFileVersion need the full path */
    *filename = 0;
    res = GetModuleFileNameW(hmsi, filename, ARRAY_SIZE(filename));
    if (!res)
        WINE_ERR("GetModuleFileName failed: %ld\n", GetLastError());

    len = ARRAY_SIZE(msiexec_version);
    *msiexec_version = 0;
    res = MsiGetFileVersionW(filename, msiexec_version, &len, NULL, NULL);
    if (res)
        WINE_ERR("MsiGetFileVersion failed with %ld\n", res);

    /* Return the length of the resource.
       No typo: The LPWSTR parameter must be a LPWSTR * for this mode */
    len = LoadStringW(hmsi, 10, (LPWSTR) &msi_res, 0);

    msi_res = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR));
    msiexec_help = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR) + sizeof(msiexec_version));
    if (msi_res && msiexec_help) {
        *msi_res = 0;
        LoadStringW(hmsi, 10, msi_res, len + 1);

        swprintf(msiexec_help, len + 1 + ARRAY_SIZE(msiexec_version), msi_res, msiexec_version);
        MsiMessageBoxW(0, msiexec_help, NULL, 0, GetUserDefaultLangID(), 0);
    }
    HeapFree(GetProcessHeap(), 0, msi_res);
    HeapFree(GetProcessHeap(), 0, msiexec_help);
    ExitProcess(ExitCode);
}

Referenced by CCABManager::ParseCmdline(), ParseCmdline(), and WinMain().

StringListAppend()

static VOID StringListAppend ( struct string_list **  list, LPCWSTR  str  )

static

Definition at line 100 of file msiexec.c.

{
    struct string_list *entry;

    entry = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(struct string_list, str[lstrlenW(str) + 1]));
    if(!entry)
    {
        WINE_ERR("Out of memory!\n");
        ExitProcess(1);
    }
    lstrcpyW(entry->str, str);
    entry->next = NULL;

    /*
     * Ignoring o(n^2) time complexity to add n strings for simplicity,
     *  add the string to the end of the list to preserve the order.
     */
    while( *list )
        list = &(*list)->next;
    *list = entry;
}

Referenced by WinMain().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

msiexec

)

WinMain()

int WINAPI WinMain	(	HINSTANCE	hInstance,
		HINSTANCE	hPrevInstance,
		LPSTR	lpCmdLine,
		int	nCmdShow
	)

Definition at line 616 of file msiexec.c.

{
    int i;
    BOOL FunctionInstall = FALSE;
    BOOL FunctionInstallAdmin = FALSE;
    BOOL FunctionRepair = FALSE;
    BOOL FunctionAdvertise = FALSE;
    BOOL FunctionPatch = FALSE;
    BOOL FunctionDllRegisterServer = FALSE;
    BOOL FunctionDllUnregisterServer = FALSE;
    BOOL FunctionRegServer = FALSE;
    BOOL FunctionUnregServer = FALSE;
    BOOL FunctionServer = FALSE;
    BOOL FunctionUnknown = FALSE;

    LPWSTR PackageName = NULL;
    LPWSTR Properties = NULL;
    struct string_list *property_list = NULL;

    DWORD RepairMode = 0;

    DWORD_PTR AdvertiseMode = 0;
    struct string_list *transform_list = NULL;
    LANGID Language = 0;

    DWORD LogMode = 0;
    LPWSTR LogFileName = NULL;
    DWORD LogAttributes = 0;

    LPWSTR PatchFileName = NULL;
    INSTALLTYPE InstallType = INSTALLTYPE_DEFAULT;

    INSTALLUILEVEL InstallUILevel = INSTALLUILEVEL_FULL;

    LPWSTR DllName = NULL;
    DWORD ReturnCode;
    int argc;
    LPWSTR *argvW = NULL;
    WCHAR *path;

        InitCommonControls();

    /* parse the command line */
    process_args( GetCommandLineW(), &argc, &argvW );

    /*
     * If the args begin with /@ IDENT then we need to load the real
     * command line out of the RunOnceEntries key in the registry.
     *  We do that before starting to process the real commandline,
     * then overwrite the commandline again.
     */
    if(argc>1 && msi_option_equal(argvW[1], "@"))
    {
        if(!process_args_from_reg( argvW[2], &argc, &argvW ))
            return 1;
    }

    if (argc == 3 && msi_option_equal(argvW[1], "Embedding"))
        return custom_action_server(argvW[2]);

    for(i = 1; i < argc; i++)
    {
        WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i]));

        if (msi_option_equal(argvW[i], "regserver"))
        {
            FunctionRegServer = TRUE;
        }
        else if (msi_option_equal(argvW[i], "unregserver") || msi_option_equal(argvW[i], "unregister")
            ||  msi_option_equal(argvW[i], "unreg"))
        {
            FunctionUnregServer = TRUE;
        }
        else if(msi_option_prefix(argvW[i], "i") || msi_option_prefix(argvW[i], "package"))
        {
            LPWSTR argvWi = argvW[i];
            int argLen = (msi_option_prefix(argvW[i], "i") ? 2 : 8);
            FunctionInstall = TRUE;
            if(lstrlenW(argvW[i]) > argLen)
                argvWi += argLen;
            else
            {
                i++;
                if(i >= argc)
                    ShowUsage(1);
                WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i]));
                argvWi = argvW[i];
            }
            PackageName = argvWi;
        }
        else if(msi_option_equal(argvW[i], "a"))
        {
            FunctionInstall = TRUE;
            FunctionInstallAdmin = TRUE;
            InstallType = INSTALLTYPE_NETWORK_IMAGE;
            i++;
            if(i >= argc)
                ShowUsage(1);
            WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i]));
            PackageName = argvW[i];
            StringListAppend(&property_list, L"ACTION=ADMIN");
            WINE_FIXME("Administrative installs are not currently supported\n");
        }
        else if(msi_option_prefix(argvW[i], "f"))
        {
            int j;
            int len = lstrlenW(argvW[i]);
            FunctionRepair = TRUE;
            for(j = 2; j < len; j++)
            {
                switch(argvW[i][j])
                {
                    case 'P':
                    case 'p':
                        RepairMode |= REINSTALLMODE_FILEMISSING;
                        break;
                    case 'O':
                    case 'o':
                        RepairMode |= REINSTALLMODE_FILEOLDERVERSION;
                        break;
                    case 'E':
                    case 'e':
                        RepairMode |= REINSTALLMODE_FILEEQUALVERSION;
                        break;
                    case 'D':
                    case 'd':
                        RepairMode |= REINSTALLMODE_FILEEXACT;
                        break;
                    case 'C':
                    case 'c':
                        RepairMode |= REINSTALLMODE_FILEVERIFY;
                        break;
                    case 'A':
                    case 'a':
                        RepairMode |= REINSTALLMODE_FILEREPLACE;
                        break;
                    case 'U':
                    case 'u':
                        RepairMode |= REINSTALLMODE_USERDATA;
                        break;
                    case 'M':
                    case 'm':
                        RepairMode |= REINSTALLMODE_MACHINEDATA;
                        break;
                    case 'S':
                    case 's':
                        RepairMode |= REINSTALLMODE_SHORTCUT;
                        break;
                    case 'V':
                    case 'v':
                        RepairMode |= REINSTALLMODE_PACKAGE;
                        break;
                    default:
                        fprintf(stderr, "Unknown option \"%c\" in Repair mode\n", argvW[i][j]);
                        break;
                }
            }
            if(len == 2)
            {
                RepairMode = REINSTALLMODE_FILEMISSING |
                    REINSTALLMODE_FILEEQUALVERSION |
                    REINSTALLMODE_FILEVERIFY |
                    REINSTALLMODE_MACHINEDATA |
                    REINSTALLMODE_SHORTCUT;
            }
            i++;
            if(i >= argc)
                ShowUsage(1);
            WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i]));
            PackageName = argvW[i];
        }
        else if(msi_option_prefix(argvW[i], "x") || msi_option_equal(argvW[i], "uninstall"))
        {
            FunctionInstall = TRUE;
            if(msi_option_prefix(argvW[i], "x")) PackageName = argvW[i]+2;
            if(!PackageName || !PackageName[0])
            {
                i++;
                if (i >= argc)
                    ShowUsage(1);
                PackageName = argvW[i];
            }
            WINE_TRACE("PackageName = %s\n", wine_dbgstr_w(PackageName));
            StringListAppend(&property_list, L"REMOVE=ALL");
        }
        else if(msi_option_prefix(argvW[i], "j"))
        {
            int j;
            int len = lstrlenW(argvW[i]);
            FunctionAdvertise = TRUE;
            for(j = 2; j < len; j++)
            {
                switch(argvW[i][j])
                {
                    case 'U':
                    case 'u':
                        AdvertiseMode = ADVERTISEFLAGS_USERASSIGN;
                        break;
                    case 'M':
                    case 'm':
                        AdvertiseMode = ADVERTISEFLAGS_MACHINEASSIGN;
                        break;
                    default:
                        fprintf(stderr, "Unknown option \"%c\" in Advertise mode\n", argvW[i][j]);
                        break;
                }
            }
            i++;
            if(i >= argc)
                ShowUsage(1);
            WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i]));
            PackageName = argvW[i];
        }
        else if(msi_strequal(argvW[i], "u"))
        {
            FunctionAdvertise = TRUE;
            AdvertiseMode = ADVERTISEFLAGS_USERASSIGN;
            i++;
            if(i >= argc)
                ShowUsage(1);
            WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i]));
            PackageName = argvW[i];
        }
        else if(msi_strequal(argvW[i], "m"))
        {
            FunctionAdvertise = TRUE;
            AdvertiseMode = ADVERTISEFLAGS_MACHINEASSIGN;
            i++;
            if(i >= argc)
                ShowUsage(1);
            WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i]));
            PackageName = argvW[i];
        }
        else if(msi_option_equal(argvW[i], "t"))
        {
            i++;
            if(i >= argc)
                ShowUsage(1);
            WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i]));
            StringListAppend(&transform_list, argvW[i]);
        }
        else if(msi_option_equal(argvW[i], "g"))
        {
            i++;
            if(i >= argc)
                ShowUsage(1);
            WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i]));
            Language = msi_atou(argvW[i]);
        }
        else if(msi_option_prefix(argvW[i], "l"))
        {
            int j;
            int len = lstrlenW(argvW[i]);
            for(j = 2; j < len; j++)
            {
                switch(argvW[i][j])
                {
                    case 'I':
                    case 'i':
                        LogMode |= INSTALLLOGMODE_INFO;
                        break;
                    case 'W':
                    case 'w':
                        LogMode |= INSTALLLOGMODE_WARNING;
                        break;
                    case 'E':
                    case 'e':
                        LogMode |= INSTALLLOGMODE_ERROR;
                        break;
                    case 'A':
                    case 'a':
                        LogMode |= INSTALLLOGMODE_ACTIONSTART;
                        break;
                    case 'R':
                    case 'r':
                        LogMode |= INSTALLLOGMODE_ACTIONDATA;
                        break;
                    case 'U':
                    case 'u':
                        LogMode |= INSTALLLOGMODE_USER;
                        break;
                    case 'C':
                    case 'c':
                        LogMode |= INSTALLLOGMODE_COMMONDATA;
                        break;
                    case 'M':
                    case 'm':
                        LogMode |= INSTALLLOGMODE_FATALEXIT;
                        break;
                    case 'O':
                    case 'o':
                        LogMode |= INSTALLLOGMODE_OUTOFDISKSPACE;
                        break;
                    case 'P':
                    case 'p':
                        LogMode |= INSTALLLOGMODE_PROPERTYDUMP;
                        break;
                    case 'V':
                    case 'v':
                        LogMode |= INSTALLLOGMODE_VERBOSE;
                        break;
                    case '*':
                        LogMode = INSTALLLOGMODE_FATALEXIT |
                            INSTALLLOGMODE_ERROR |
                            INSTALLLOGMODE_WARNING |
                            INSTALLLOGMODE_USER |
                            INSTALLLOGMODE_INFO |
                            INSTALLLOGMODE_RESOLVESOURCE |
                            INSTALLLOGMODE_OUTOFDISKSPACE |
                            INSTALLLOGMODE_ACTIONSTART |
                            INSTALLLOGMODE_ACTIONDATA |
                            INSTALLLOGMODE_COMMONDATA |
                            INSTALLLOGMODE_PROPERTYDUMP |
                            INSTALLLOGMODE_PROGRESS |
                            INSTALLLOGMODE_INITIALIZE |
                            INSTALLLOGMODE_TERMINATE |
                            INSTALLLOGMODE_SHOWDIALOG;
                        break;
                    case '+':
                        LogAttributes |= INSTALLLOGATTRIBUTES_APPEND;
                        break;
                    case '!':
                        LogAttributes |= INSTALLLOGATTRIBUTES_FLUSHEACHLINE;
                        break;
                    default:
                        break;
                }
            }
            i++;
            if(i >= argc)
                ShowUsage(1);
            WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i]));
            LogFileName = argvW[i];
            if(MsiEnableLogW(LogMode, LogFileName, LogAttributes) != ERROR_SUCCESS)
            {
                fprintf(stderr, "Logging in %s (0x%08x, %u) failed\n",
                     wine_dbgstr_w(LogFileName), LogMode, LogAttributes);
                ExitProcess(1);
            }
        }
        else if(msi_option_equal(argvW[i], "p") || msi_option_equal(argvW[i], "update"))
        {
            FunctionPatch = TRUE;
            i++;
            if(i >= argc)
                ShowUsage(1);
            WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i]));
            PatchFileName = argvW[i];
        }
        else if(msi_option_prefix(argvW[i], "q"))
        {
            if(lstrlenW(argvW[i]) == 2 || msi_strequal(argvW[i]+2, "n") ||
               msi_strequal(argvW[i] + 2, "uiet"))
            {
                InstallUILevel = INSTALLUILEVEL_NONE;
            }
            else if(msi_strequal(argvW[i]+2, "r"))
            {
                InstallUILevel = INSTALLUILEVEL_REDUCED;
            }
            else if(msi_strequal(argvW[i]+2, "f"))
            {
                InstallUILevel = INSTALLUILEVEL_FULL|INSTALLUILEVEL_ENDDIALOG;
            }
            else if(msi_strequal(argvW[i]+2, "n+"))
            {
                InstallUILevel = INSTALLUILEVEL_NONE|INSTALLUILEVEL_ENDDIALOG;
            }
            else if(msi_strprefix(argvW[i]+2, "b"))
            {
                const WCHAR *ptr = argvW[i] + 3;

                InstallUILevel = INSTALLUILEVEL_BASIC;

                while (*ptr)
                {
                    if (msi_strprefix(ptr, "+"))
                        InstallUILevel |= INSTALLUILEVEL_ENDDIALOG;
                    if (msi_strprefix(ptr, "-"))
                        InstallUILevel |= INSTALLUILEVEL_PROGRESSONLY;
                    if (msi_strprefix(ptr, "!"))
                    {
                        WINE_FIXME("Unhandled modifier: !\n");
                        InstallUILevel |= INSTALLUILEVEL_HIDECANCEL;
                    }
                    ptr++;
                }
            }
            else
            {
                fprintf(stderr, "Unknown option \"%s\" for UI level\n",
                     wine_dbgstr_w(argvW[i]+2));
            }
        }
                else if(msi_option_equal(argvW[i], "passive"))
                {
                    InstallUILevel = INSTALLUILEVEL_BASIC|INSTALLUILEVEL_PROGRESSONLY|INSTALLUILEVEL_HIDECANCEL;
                    StringListAppend(&property_list, L"REBOOTPROMPT=\"S\"");
                }
        else if(msi_option_equal(argvW[i], "y"))
        {
            FunctionDllRegisterServer = TRUE;
            i++;
            if(i >= argc)
                ShowUsage(1);
            WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i]));
            DllName = argvW[i];
        }
        else if(msi_option_equal(argvW[i], "z"))
        {
            FunctionDllUnregisterServer = TRUE;
            i++;
            if(i >= argc)
                ShowUsage(1);
            WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i]));
            DllName = argvW[i];
        }
        else if(msi_option_equal(argvW[i], "help") || msi_option_equal(argvW[i], "?"))
        {
            ShowUsage(0);
        }
        else if(msi_option_equal(argvW[i], "m"))
        {
            FunctionUnknown = TRUE;
            WINE_FIXME("Unknown parameter /m\n");
        }
        else if(msi_option_equal(argvW[i], "D"))
        {
            FunctionUnknown = TRUE;
            WINE_FIXME("Unknown parameter /D\n");
        }
        else if (msi_option_equal(argvW[i], "V"))
        {
            FunctionServer = TRUE;
        }
        else
            StringListAppend(&property_list, argvW[i]);
    }

    /* start the GUI */
    MsiSetInternalUI(InstallUILevel, NULL);

    Properties = build_properties( property_list );

    if(FunctionInstallAdmin && FunctionPatch)
        FunctionInstall = FALSE;

    ReturnCode = 1;
    if(FunctionInstall)
    {
        if(IsProductCode(PackageName))
            ReturnCode = MsiConfigureProductExW(PackageName, 0, INSTALLSTATE_DEFAULT, Properties);
        else
        {
            if ((ReturnCode = MsiInstallProductW(PackageName, Properties)) == ERROR_FILE_NOT_FOUND
                    && (path = get_path_with_extension(PackageName)))
            {
                ReturnCode = MsiInstallProductW(path, Properties);
                heap_free(path);
            }
        }
    }
    else if(FunctionRepair)
    {
        if(IsProductCode(PackageName))
            WINE_FIXME("Product code treatment not implemented yet\n");
        else
        {
            if ((ReturnCode = MsiReinstallProductW(PackageName, RepairMode)) == ERROR_FILE_NOT_FOUND
                    && (path = get_path_with_extension(PackageName)))
            {
                ReturnCode = MsiReinstallProductW(path, RepairMode);
                heap_free(path);
            }
        }
    }
    else if(FunctionAdvertise)
    {
        LPWSTR Transforms = build_transforms( property_list );
        ReturnCode = MsiAdvertiseProductW(PackageName, (LPWSTR) AdvertiseMode, Transforms, Language);
    }
    else if(FunctionPatch)
    {
        ReturnCode = MsiApplyPatchW(PatchFileName, PackageName, InstallType, Properties);
    }
    else if(FunctionDllRegisterServer)
    {
        ReturnCode = DoDllRegisterServer(DllName);
    }
    else if(FunctionDllUnregisterServer)
    {
        ReturnCode = DoDllUnregisterServer(DllName);
    }
    else if (FunctionRegServer)
    {
        ReturnCode = DoRegServer();
    }
    else if (FunctionUnregServer)
    {
        ReturnCode = DoUnregServer();
    }
    else if (FunctionServer)
    {
        ReturnCode = DoService();
    }
    else if (FunctionUnknown)
    {
        WINE_FIXME( "Unknown function, ignoring\n" );
    }
    else
        ShowUsage(1);

    return ReturnCode;
}

Variable Documentation

client_pid

DWORD client_pid

static

Definition at line 386 of file msiexec.c.

Referenced by __wine_msi_call_dll_function(), custom_action_server(), custom_action_thread(), test_ddeml_client(), test_end_to_end_client(), and test_initialisation().