wine/programs/msiexec/msiexec.c

1129 lines
28 KiB
C
Raw Normal View History

/*
* msiexec.exe implementation
*
* Copyright 2004 Vincent Béron
* Copyright 2005 Mike McCormack
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <commctrl.h>
#include <msi.h>
#include <winsvc.h>
#include <objbase.h>
#include <stdio.h>
#include "wine/debug.h"
#include "initguid.h"
DEFINE_GUID(GUID_NULL,0,0,0,0,0,0,0,0,0,0,0);
WINE_DEFAULT_DEBUG_CHANNEL(msiexec);
2005-08-11 10:59:51 +00:00
typedef HRESULT (WINAPI *DLLREGISTERSERVER)(void);
typedef HRESULT (WINAPI *DLLUNREGISTERSERVER)(void);
DWORD DoService(void);
struct string_list
{
struct string_list *next;
2005-02-10 17:12:59 +00:00
WCHAR str[1];
};
static void ShowUsage(int ExitCode)
{
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);
2023-11-07 05:17:35 +00:00
msi_res = malloc((len + 1) * sizeof(WCHAR));
msiexec_help = malloc((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);
}
2023-11-07 05:17:35 +00:00
free(msi_res);
free(msiexec_help);
ExitProcess(ExitCode);
}
static BOOL IsProductCode(LPWSTR str)
{
GUID ProductCode;
if(lstrlenW(str) != 38)
return FALSE;
return ( (CLSIDFromString(str, &ProductCode) == NOERROR) );
2004-07-30 04:23:37 +00:00
}
2005-02-10 17:12:59 +00:00
static VOID StringListAppend(struct string_list **list, LPCWSTR str)
{
struct string_list *entry;
2023-11-07 05:17:35 +00:00
entry = malloc(FIELD_OFFSET(struct string_list, str[wcslen(str) + 1]));
if(!entry)
{
WINE_ERR("Out of memory!\n");
ExitProcess(1);
}
2005-02-10 17:12:59 +00:00
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;
}
2005-02-10 17:12:59 +00:00
static LPWSTR build_properties(struct string_list *property_list)
{
struct string_list *list;
2005-02-10 17:12:59 +00:00
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)
2005-02-10 17:12:59 +00:00
len += lstrlenW(list->str) + 3;
2023-11-07 05:17:35 +00:00
ret = malloc(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++ = '"';
2005-02-10 17:12:59 +00:00
len = lstrlenW(value);
memcpy(p, value, len * sizeof(WCHAR));
p += len;
if(needs_quote)
*p++ = '"';
}
*p = 0;
2005-02-10 17:12:59 +00:00
WINE_TRACE("properties -> %s\n", wine_dbgstr_w(ret) );
return ret;
}
2005-02-10 17:12:59 +00:00
static LPWSTR build_transforms(struct string_list *transform_list)
{
struct string_list *list;
2005-02-10 17:12:59 +00:00
LPWSTR ret, p;
DWORD len;
/* count the space we need */
len = 1;
for(list = transform_list; list; list = list->next)
2005-02-10 17:12:59 +00:00
len += lstrlenW(list->str) + 1;
2023-11-07 05:17:35 +00:00
ret = malloc(len * sizeof(WCHAR));
/* add all the transforms with a semicolon between each one */
p = ret;
for(list = transform_list; list; list = list->next)
{
2005-02-10 17:12:59 +00:00
len = lstrlenW(list->str);
lstrcpynW(p, list->str, len );
p += len;
if(list->next)
*p++ = ';';
}
*p = 0;
return ret;
}
2005-02-10 17:12:59 +00:00
static DWORD msi_atou(LPCWSTR str)
{
2005-02-10 17:12:59 +00:00
DWORD ret = 0;
while(*str >= '0' && *str <= '9')
{
ret *= 10;
ret += (*str - '0');
str++;
}
return ret;
2005-02-10 17:12:59 +00:00
}
2005-02-10 17:12:59 +00:00
/* str1 is the same as str2, ignoring case */
static BOOL msi_strequal(LPCWSTR str1, LPCSTR str2)
{
DWORD len, ret;
LPWSTR strW;
len = MultiByteToWideChar( CP_ACP, 0, str2, -1, NULL, 0);
if( !len )
return FALSE;
2005-02-10 17:12:59 +00:00
if( lstrlenW(str1) != (len-1) )
return FALSE;
2023-11-07 05:17:35 +00:00
strW = malloc(sizeof(WCHAR) * len);
2005-02-10 17:12:59 +00:00
MultiByteToWideChar( CP_ACP, 0, str2, -1, strW, len);
ret = CompareStringW(GetThreadLocale(), NORM_IGNORECASE, str1, len, strW, len);
2023-11-07 05:17:35 +00:00
free(strW);
return (ret == CSTR_EQUAL);
2005-02-10 17:12:59 +00:00
}
/* prefix is hyphen or dash, and str1 is the same as str2, ignoring case */
static BOOL msi_option_equal(LPCWSTR str1, LPCSTR str2)
{
if (str1[0] != '/' && str1[0] != '-')
return FALSE;
/* skip over the hyphen or slash */
return msi_strequal(str1 + 1, str2);
}
2005-02-10 17:12:59 +00:00
/* str2 is at the beginning of str1, ignoring case */
static BOOL msi_strprefix(LPCWSTR str1, LPCSTR str2)
{
DWORD len, ret;
LPWSTR strW;
len = MultiByteToWideChar( CP_ACP, 0, str2, -1, NULL, 0);
if( !len )
return FALSE;
2005-02-10 17:12:59 +00:00
if( lstrlenW(str1) < (len-1) )
return FALSE;
2023-11-07 05:17:35 +00:00
strW = malloc(sizeof(WCHAR) * len);
2005-02-10 17:12:59 +00:00
MultiByteToWideChar( CP_ACP, 0, str2, -1, strW, len);
ret = CompareStringW(GetThreadLocale(), NORM_IGNORECASE, str1, len-1, strW, len-1);
2023-11-07 05:17:35 +00:00
free(strW);
return (ret == CSTR_EQUAL);
}
/* prefix is hyphen or dash, and str2 is at the beginning of str1, ignoring case */
static BOOL msi_option_prefix(LPCWSTR str1, LPCSTR str2)
{
if (str1[0] != '/' && str1[0] != '-')
return FALSE;
/* skip over the hyphen or slash */
return msi_strprefix(str1 + 1, str2);
}
2005-02-10 17:12:59 +00:00
static VOID *LoadProc(LPCWSTR DllName, LPCSTR ProcName, HMODULE* DllHandle)
{
VOID* (*proc)(void);
2005-02-10 17:12:59 +00:00
*DllHandle = LoadLibraryExW(DllName, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
if(!*DllHandle)
{
2005-02-10 17:12:59 +00:00
fprintf(stderr, "Unable to load dll %s\n", wine_dbgstr_w(DllName));
ExitProcess(1);
}
proc = (VOID *) GetProcAddress(*DllHandle, ProcName);
if(!proc)
{
2005-02-10 17:12:59 +00:00
fprintf(stderr, "Dll %s does not implement function %s\n",
wine_dbgstr_w(DllName), ProcName);
FreeLibrary(*DllHandle);
ExitProcess(1);
}
return proc;
}
static DWORD DoDllRegisterServer(LPCWSTR DllName)
{
HRESULT hr;
DLLREGISTERSERVER pfDllRegisterServer = NULL;
HMODULE DllHandle = NULL;
pfDllRegisterServer = LoadProc(DllName, "DllRegisterServer", &DllHandle);
hr = pfDllRegisterServer();
if(FAILED(hr))
{
2005-02-10 17:12:59 +00:00
fprintf(stderr, "Failed to register dll %s\n", wine_dbgstr_w(DllName));
return 1;
}
2005-02-10 17:12:59 +00:00
printf("Successfully registered dll %s\n", wine_dbgstr_w(DllName));
if(DllHandle)
FreeLibrary(DllHandle);
return 0;
}
static DWORD DoDllUnregisterServer(LPCWSTR DllName)
{
HRESULT hr;
DLLUNREGISTERSERVER pfDllUnregisterServer = NULL;
HMODULE DllHandle = NULL;
pfDllUnregisterServer = LoadProc(DllName, "DllUnregisterServer", &DllHandle);
hr = pfDllUnregisterServer();
if(FAILED(hr))
{
2005-02-10 17:12:59 +00:00
fprintf(stderr, "Failed to unregister dll %s\n", wine_dbgstr_w(DllName));
return 1;
}
2005-02-10 17:12:59 +00:00
printf("Successfully unregistered dll %s\n", wine_dbgstr_w(DllName));
if(DllHandle)
FreeLibrary(DllHandle);
return 0;
}
static DWORD DoRegServer(void)
{
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;
}
2013-02-12 13:32:45 +00:00
static DWORD DoUnregServer(void)
{
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)))
2013-02-12 13:32:45 +00:00
{
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;
}
extern UINT CDECL __wine_msi_call_dll_function(DWORD client_pid, const GUID *guid);
static DWORD client_pid;
static DWORD CALLBACK custom_action_thread(void *arg)
{
GUID guid = *(GUID *)arg;
2023-11-07 05:17:35 +00:00
free(arg);
return __wine_msi_call_dll_function(client_pid, &guid);
}
static int custom_action_server(const WCHAR *arg)
{
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, 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;
}
2023-11-07 05:17:35 +00:00
thread_guid = malloc(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();
}
/*
* state machine to break up the command line properly
*/
enum chomp_state
{
CS_WHITESPACE,
CS_TOKEN,
CS_QUOTE
};
static int chomp( const WCHAR *in, WCHAR *out )
{
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;
}
static void process_args( WCHAR *cmdline, int *pargc, WCHAR ***pargv )
{
WCHAR **argv, *p;
int i, count;
*pargc = 0;
*pargv = NULL;
count = chomp( cmdline, NULL );
2023-11-07 05:17:35 +00:00
if (!(p = malloc( (wcslen(cmdline) + count + 1) * sizeof(WCHAR) )))
return;
count = chomp( cmdline, p );
2023-11-07 05:17:35 +00:00
if (!(argv = malloc( (count + 1) * sizeof(WCHAR *) )))
{
2023-11-07 05:17:35 +00:00
free( p );
return;
}
for (i = 0; i < count; i++)
{
argv[i] = p;
p += lstrlenW( p ) + 1;
}
argv[i] = NULL;
*pargc = count;
*pargv = argv;
}
static BOOL process_args_from_reg( const WCHAR *ident, int *pargc, WCHAR ***pargv )
{
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] );
2023-11-07 05:17:35 +00:00
if (!(buf = malloc( (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;
}
2023-11-07 05:17:35 +00:00
free(buf);
}
RegCloseKey(hkey);
return ret;
}
static WCHAR *get_path_with_extension(const WCHAR *package_name)
{
static const WCHAR ext[] = L".msi";
unsigned int p;
WCHAR *path;
2023-11-07 05:17:35 +00:00
if (!(path = malloc(wcslen(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] == '.')
{
2023-11-07 05:17:35 +00:00
free(path);
return NULL;
}
lstrcatW(path, ext);
return path;
}
2008-11-12 16:16:24 +00:00
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
int i;
BOOL FunctionInstall = FALSE;
2004-07-29 02:39:20 +00:00
BOOL FunctionInstallAdmin = FALSE;
BOOL FunctionRepair = FALSE;
BOOL FunctionAdvertise = FALSE;
2004-07-29 02:39:20 +00:00
BOOL FunctionPatch = FALSE;
BOOL FunctionDllRegisterServer = FALSE;
BOOL FunctionDllUnregisterServer = FALSE;
BOOL FunctionRegServer = FALSE;
BOOL FunctionUnregServer = FALSE;
BOOL FunctionServer = FALSE;
BOOL FunctionUnknown = FALSE;
LPWSTR PackageName = NULL;
2005-02-10 17:12:59 +00:00
LPWSTR Properties = NULL;
struct string_list *property_list = NULL;
DWORD RepairMode = 0;
2006-05-30 01:47:27 +00:00
DWORD_PTR AdvertiseMode = 0;
struct string_list *transform_list = NULL;
LANGID Language = 0;
DWORD LogMode = 0;
2005-02-10 17:12:59 +00:00
LPWSTR LogFileName = NULL;
DWORD LogAttributes = 0;
2005-02-10 17:12:59 +00:00
LPWSTR PatchFileName = NULL;
2004-07-29 02:39:20 +00:00
INSTALLTYPE InstallType = INSTALLTYPE_DEFAULT;
2005-02-10 20:26:30 +00:00
INSTALLUILEVEL InstallUILevel = INSTALLUILEVEL_FULL;
2005-02-10 17:12:59 +00:00
LPWSTR DllName = NULL;
DWORD ReturnCode;
2008-11-12 16:16:24 +00:00
int argc;
2005-02-10 17:12:59 +00:00
LPWSTR *argvW = NULL;
WCHAR *path;
InitCommonControls();
2008-11-12 16:16:24 +00:00
/* 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++)
{
2005-02-10 17:12:59 +00:00
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;
}
2010-01-03 10:06:36 +00:00
else if(msi_option_prefix(argvW[i], "i") || msi_option_prefix(argvW[i], "package"))
{
2005-02-10 17:12:59 +00:00
LPWSTR argvWi = argvW[i];
2010-01-03 10:06:36 +00:00
int argLen = (msi_option_prefix(argvW[i], "i") ? 2 : 8);
FunctionInstall = TRUE;
2010-01-03 10:06:36 +00:00
if(lstrlenW(argvW[i]) > argLen)
argvWi += argLen;
else
{
2004-08-30 18:39:44 +00:00
i++;
if(i >= argc)
ShowUsage(1);
2005-02-10 17:12:59 +00:00
WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i]));
argvWi = argvW[i];
2004-08-30 18:39:44 +00:00
}
PackageName = argvWi;
}
else if(msi_option_equal(argvW[i], "a"))
{
FunctionInstall = TRUE;
2004-07-29 02:39:20 +00:00
FunctionInstallAdmin = TRUE;
InstallType = INSTALLTYPE_NETWORK_IMAGE;
i++;
if(i >= argc)
ShowUsage(1);
2005-02-10 17:12:59 +00:00
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;
2005-02-10 17:12:59 +00:00
int len = lstrlenW(argvW[i]);
FunctionRepair = TRUE;
for(j = 2; j < len; j++)
{
2005-02-10 17:12:59 +00:00
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:
2005-02-10 17:12:59 +00:00
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);
2005-02-10 17:12:59 +00:00
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;
2005-02-10 17:12:59 +00:00
int len = lstrlenW(argvW[i]);
FunctionAdvertise = TRUE;
for(j = 2; j < len; j++)
{
2005-02-10 17:12:59 +00:00
switch(argvW[i][j])
{
case 'U':
case 'u':
AdvertiseMode = ADVERTISEFLAGS_USERASSIGN;
break;
case 'M':
case 'm':
AdvertiseMode = ADVERTISEFLAGS_MACHINEASSIGN;
break;
default:
2005-02-10 17:12:59 +00:00
fprintf(stderr, "Unknown option \"%c\" in Advertise mode\n", argvW[i][j]);
break;
}
}
i++;
if(i >= argc)
ShowUsage(1);
2005-02-10 17:12:59 +00:00
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);
2005-02-10 17:12:59 +00:00
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);
2005-02-10 17:12:59 +00:00
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);
2005-02-10 17:12:59 +00:00
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);
2005-02-10 17:12:59 +00:00
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;
2005-02-10 17:12:59 +00:00
int len = lstrlenW(argvW[i]);
for(j = 2; j < len; j++)
{
2005-02-10 17:12:59 +00:00
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);
2005-02-10 17:12:59 +00:00
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%08lx, %lu) failed\n",
2005-02-10 17:12:59 +00:00
wine_dbgstr_w(LogFileName), LogMode, LogAttributes);
ExitProcess(1);
}
}
2014-11-27 11:15:46 +00:00
else if(msi_option_equal(argvW[i], "p") || msi_option_equal(argvW[i], "update"))
{
2004-07-29 02:39:20 +00:00
FunctionPatch = TRUE;
i++;
if(i >= argc)
ShowUsage(1);
2005-02-10 17:12:59 +00:00
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"))
2012-03-12 11:24:55 +00:00
{
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++;
}
2012-03-12 11:24:55 +00:00
}
else
{
2005-02-10 17:12:59 +00:00
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);
2005-02-10 17:12:59 +00:00
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);
2005-02-10 17:12:59 +00:00
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]);
}
2005-02-10 20:26:30 +00:00
/* start the GUI */
MsiSetInternalUI(InstallUILevel, NULL);
Properties = build_properties( property_list );
2004-07-29 02:39:20 +00:00
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);
2023-11-07 05:17:35 +00:00
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);
2023-11-07 05:17:35 +00:00
free(path);
}
}
}
else if(FunctionAdvertise)
{
LPWSTR Transforms = build_transforms( property_list );
2005-02-10 17:12:59 +00:00
ReturnCode = MsiAdvertiseProductW(PackageName, (LPWSTR) AdvertiseMode, Transforms, Language);
}
2004-07-29 02:39:20 +00:00
else if(FunctionPatch)
{
2005-02-10 17:12:59 +00:00
ReturnCode = MsiApplyPatchW(PatchFileName, PackageName, InstallType, Properties);
2004-07-29 02:39:20 +00:00
}
else if(FunctionDllRegisterServer)
{
ReturnCode = DoDllRegisterServer(DllName);
}
else if(FunctionDllUnregisterServer)
{
ReturnCode = DoDllUnregisterServer(DllName);
}
else if (FunctionRegServer)
{
ReturnCode = DoRegServer();
}
else if (FunctionUnregServer)
{
2013-02-12 13:32:45 +00:00
ReturnCode = DoUnregServer();
}
else if (FunctionServer)
{
ReturnCode = DoService();
}
else if (FunctionUnknown)
{
WINE_FIXME( "Unknown function, ignoring\n" );
}
else
ShowUsage(1);
return ReturnCode;
}