programs/msiexec/msiexec.c

   1 /*
   2  * msiexec.exe implementation
   3  *
   4  * Copyright 2004 Vincent Béron
   5  * Copyright 2005 Mike McCormack
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #define WIN32_LEAN_AND_MEAN
  23
  24 #include <windows.h>
  25 #include <msi.h>
  26 #include <winsvc.h>
  27 #include <objbase.h>
  28 #include <stdio.h>
  29
  30 #include "wine/debug.h"
  31 #include "wine/unicode.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(msiexec);
  34
  35 typedef HRESULT (WINAPI *DLLREGISTERSERVER)(void);
  36 typedef HRESULT (WINAPI *DLLUNREGISTERSERVER)(void);
  37
  38 DWORD DoService(void);
  39
  40 struct string_list
  41 {
  42         struct string_list *next;
  43         WCHAR str[1];
  44 };
  45
  46 static const WCHAR ActionAdmin[] = {
  47    'A','C','T','I','O','N','=','A','D','M','I','N',0 };
  48 static const WCHAR RemoveAll[] = {
  49    'R','E','M','O','V','E','=','A','L','L',0 };
  50
  51 static const WCHAR InstallRunOnce[] = {
  52    'S','o','f','t','w','a','r','e','\\',
  53    'M','i','c','r','o','s','o','f','t','\\',
  54    'W','i','n','d','o','w','s','\\',
  55    'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
  56    'I','n','s','t','a','l','l','e','r','\\',
  57    'R','u','n','O','n','c','e','E','n','t','r','i','e','s',0};
  58
  59 static void ShowUsage(int ExitCode)
  60 {
  61     WCHAR msiexec_version[40];
  62     WCHAR filename[MAX_PATH];
  63     LPWSTR msi_res;
  64     LPWSTR msiexec_help;
  65     HMODULE hmsi = GetModuleHandleA("msi.dll");
  66     DWORD len;
  67     DWORD res;
  68
  69     /* MsiGetFileVersion need the full path */
  70     *filename = 0;
  71     res = GetModuleFileNameW(hmsi, filename, sizeof(filename) / sizeof(filename[0]));
  72     if (!res)
  73         WINE_ERR("GetModuleFileName failed: %d\n", GetLastError());
  74
  75     len = sizeof(msiexec_version) / sizeof(msiexec_version[0]);
  76     *msiexec_version = 0;
  77     res = MsiGetFileVersionW(filename, msiexec_version, &len, NULL, NULL);
  78     if (res)
  79         WINE_ERR("MsiGetFileVersion failed with %d\n", res);
  80
  81     /* Return the length of the resource.
  82        No typo: The LPWSTR parameter must be a LPWSTR * for this mode */
  83     len = LoadStringW(hmsi, 10, (LPWSTR) &msi_res, 0);
  84
  85     msi_res = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR));
  86     msiexec_help = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR) + sizeof(msiexec_version));
  87     if (msi_res && msiexec_help) {
  88         *msi_res = 0;
  89         LoadStringW(hmsi, 10, msi_res, len + 1);
  90
  91         sprintfW(msiexec_help, msi_res, msiexec_version);
  92         MsiMessageBoxW(0, msiexec_help, NULL, 0, GetUserDefaultLangID(), 0);
  93     }
  94     HeapFree(GetProcessHeap(), 0, msi_res);
  95     HeapFree(GetProcessHeap(), 0, msiexec_help);
  96     ExitProcess(ExitCode);
  97 }
  98
  99 static BOOL IsProductCode(LPWSTR str)
 100 {
 101         GUID ProductCode;
 102
 103         if(lstrlenW(str) != 38)
 104                 return FALSE;
 105         return ( (CLSIDFromString(str, &ProductCode) == NOERROR) );
 106
 107 }
 108
 109 static VOID StringListAppend(struct string_list **list, LPCWSTR str)
 110 {
 111         struct string_list *entry;
 112
 113         entry = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(struct string_list, str[lstrlenW(str) + 1]));
 114         if(!entry)
 115         {
 116                 WINE_ERR("Out of memory!\n");
 117                 ExitProcess(1);
 118         }
 119         lstrcpyW(entry->str, str);
 120         entry->next = NULL;
 121
 122         /*
 123          * Ignoring o(n^2) time complexity to add n strings for simplicity,
 124          *  add the string to the end of the list to preserve the order.
 125          */
 126         while( *list )
 127                 list = &(*list)->next;
 128         *list = entry;
 129 }
 130
 131 static LPWSTR build_properties(struct string_list *property_list)
 132 {
 133         struct string_list *list;
 134         LPWSTR ret, p, value;
 135         DWORD len;
 136         BOOL needs_quote;
 137
 138         if(!property_list)
 139                 return NULL;
 140
 141         /* count the space we need */
 142         len = 1;
 143         for(list = property_list; list; list = list->next)
 144                 len += lstrlenW(list->str) + 3;
 145
 146         ret = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );
 147
 148         /* add a space before each string, and quote the value */
 149         p = ret;
 150         for(list = property_list; list; list = list->next)
 151         {
 152                 value = strchrW(list->str,'=');
 153                 if(!value)
 154                         continue;
 155                 len = value - list->str;
 156                 *p++ = ' ';
 157                 memcpy(p, list->str, len * sizeof(WCHAR));
 158                 p += len;
 159                 *p++ = '=';
 160
 161                 /* check if the value contains spaces and maybe quote it */
 162                 value++;
 163                 needs_quote = strchrW(value,' ') ? 1 : 0;
 164                 if(needs_quote)
 165                         *p++ = '"';
 166                 len = lstrlenW(value);
 167                 memcpy(p, value, len * sizeof(WCHAR));
 168                 p += len;
 169                 if(needs_quote)
 170                         *p++ = '"';
 171         }
 172         *p = 0;
 173
 174         WINE_TRACE("properties -> %s\n", wine_dbgstr_w(ret) );
 175
 176         return ret;
 177 }
 178
 179 static LPWSTR build_transforms(struct string_list *transform_list)
 180 {
 181         struct string_list *list;
 182         LPWSTR ret, p;
 183         DWORD len;
 184
 185         /* count the space we need */
 186         len = 1;
 187         for(list = transform_list; list; list = list->next)
 188                 len += lstrlenW(list->str) + 1;
 189
 190         ret = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );
 191
 192         /* add all the transforms with a semicolon between each one */
 193         p = ret;
 194         for(list = transform_list; list; list = list->next)
 195         {
 196                 len = lstrlenW(list->str);
 197                 lstrcpynW(p, list->str, len );
 198                 p += len;
 199                 if(list->next)
 200                         *p++ = ';';
 201         }
 202         *p = 0;
 203
 204         return ret;
 205 }
 206
 207 static DWORD msi_atou(LPCWSTR str)
 208 {
 209         DWORD ret = 0;
 210         while(*str >= '0' && *str <= '9')
 211         {
 212                 ret *= 10;
 213                 ret += (*str - '0');
 214                 str++;
 215         }
 216         return ret;
 217 }
 218
 219 /* str1 is the same as str2, ignoring case */
 220 static BOOL msi_strequal(LPCWSTR str1, LPCSTR str2)
 221 {
 222         DWORD len, ret;
 223         LPWSTR strW;
 224
 225         len = MultiByteToWideChar( CP_ACP, 0, str2, -1, NULL, 0);
 226         if( !len )
 227                 return FALSE;
 228         if( lstrlenW(str1) != (len-1) )
 229                 return FALSE;
 230         strW = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR)*len);
 231         MultiByteToWideChar( CP_ACP, 0, str2, -1, strW, len);
 232         ret = CompareStringW(GetThreadLocale(), NORM_IGNORECASE, str1, len, strW, len);
 233         HeapFree(GetProcessHeap(), 0, strW);
 234         return (ret == CSTR_EQUAL);
 235 }
 236
 237 /* prefix is hyphen or dash, and str1 is the same as str2, ignoring case */
 238 static BOOL msi_option_equal(LPCWSTR str1, LPCSTR str2)
 239 {
 240     if (str1[0] != '/' && str1[0] != '-')
 241         return FALSE;
 242
 243     /* skip over the hyphen or slash */
 244     return msi_strequal(str1 + 1, str2);
 245 }
 246
 247 /* str2 is at the beginning of str1, ignoring case */
 248 static BOOL msi_strprefix(LPCWSTR str1, LPCSTR str2)
 249 {
 250         DWORD len, ret;
 251         LPWSTR strW;
 252
 253         len = MultiByteToWideChar( CP_ACP, 0, str2, -1, NULL, 0);
 254         if( !len )
 255                 return FALSE;
 256         if( lstrlenW(str1) < (len-1) )
 257                 return FALSE;
 258         strW = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR)*len);
 259         MultiByteToWideChar( CP_ACP, 0, str2, -1, strW, len);
 260         ret = CompareStringW(GetThreadLocale(), NORM_IGNORECASE, str1, len-1, strW, len-1);
 261         HeapFree(GetProcessHeap(), 0, strW);
 262         return (ret == CSTR_EQUAL);
 263 }
 264
 265 /* prefix is hyphen or dash, and str2 is at the beginning of str1, ignoring case */
 266 static BOOL msi_option_prefix(LPCWSTR str1, LPCSTR str2)
 267 {
 268     if (str1[0] != '/' && str1[0] != '-')
 269         return FALSE;
 270
 271     /* skip over the hyphen or slash */
 272     return msi_strprefix(str1 + 1, str2);
 273 }
 274
 275 static VOID *LoadProc(LPCWSTR DllName, LPCSTR ProcName, HMODULE* DllHandle)
 276 {
 277         VOID* (*proc)(void);
 278
 279         *DllHandle = LoadLibraryExW(DllName, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
 280         if(!*DllHandle)
 281         {
 282                 fprintf(stderr, "Unable to load dll %s\n", wine_dbgstr_w(DllName));
 283                 ExitProcess(1);
 284         }
 285         proc = (VOID *) GetProcAddress(*DllHandle, ProcName);
 286         if(!proc)
 287         {
 288                 fprintf(stderr, "Dll %s does not implement function %s\n",
 289                         wine_dbgstr_w(DllName), ProcName);
 290                 FreeLibrary(*DllHandle);
 291                 ExitProcess(1);
 292         }
 293
 294         return proc;
 295 }
 296
 297 static DWORD DoDllRegisterServer(LPCWSTR DllName)
 298 {
 299         HRESULT hr;
 300         DLLREGISTERSERVER pfDllRegisterServer = NULL;
 301         HMODULE DllHandle = NULL;
 302
 303         pfDllRegisterServer = LoadProc(DllName, "DllRegisterServer", &DllHandle);
 304
 305         hr = pfDllRegisterServer();
 306         if(FAILED(hr))
 307         {
 308                 fprintf(stderr, "Failed to register dll %s\n", wine_dbgstr_w(DllName));
 309                 return 1;
 310         }
 311         printf("Successfully registered dll %s\n", wine_dbgstr_w(DllName));
 312         if(DllHandle)
 313                 FreeLibrary(DllHandle);
 314         return 0;
 315 }
 316
 317 static DWORD DoDllUnregisterServer(LPCWSTR DllName)
 318 {
 319         HRESULT hr;
 320         DLLUNREGISTERSERVER pfDllUnregisterServer = NULL;
 321         HMODULE DllHandle = NULL;
 322
 323         pfDllUnregisterServer = LoadProc(DllName, "DllUnregisterServer", &DllHandle);
 324
 325         hr = pfDllUnregisterServer();
 326         if(FAILED(hr))
 327         {
 328                 fprintf(stderr, "Failed to unregister dll %s\n", wine_dbgstr_w(DllName));
 329                 return 1;
 330         }
 331         printf("Successfully unregistered dll %s\n", wine_dbgstr_w(DllName));
 332         if(DllHandle)
 333                 FreeLibrary(DllHandle);
 334         return 0;
 335 }
 336
 337 static DWORD DoRegServer(void)
 338 {
 339     static const WCHAR msiserverW[] = {'M','S','I','S','e','r','v','e','r',0};
 340     static const WCHAR msiexecW[] = {'\\','m','s','i','e','x','e','c',' ','/','V',0};
 341     SC_HANDLE scm, service;
 342     WCHAR path[MAX_PATH+12];
 343     DWORD len, ret = 0;
 344
 345     if (!(scm = OpenSCManagerW(NULL, SERVICES_ACTIVE_DATABASEW, SC_MANAGER_CREATE_SERVICE)))
 346     {
 347         fprintf(stderr, "Failed to open the service control manager.\n");
 348         return 1;
 349     }
 350     len = GetSystemDirectoryW(path, MAX_PATH);
 351     lstrcpyW(path + len, msiexecW);
 352     if ((service = CreateServiceW(scm, msiserverW, msiserverW, GENERIC_ALL,
 353                                   SERVICE_WIN32_SHARE_PROCESS, SERVICE_DEMAND_START,
 354                                   SERVICE_ERROR_NORMAL, path, NULL, NULL, NULL, NULL, NULL)))
 355     {
 356         CloseServiceHandle(service);
 357     }
 358     else if (GetLastError() != ERROR_SERVICE_EXISTS)
 359     {
 360         fprintf(stderr, "Failed to create MSI service\n");
 361         ret = 1;
 362     }
 363     CloseServiceHandle(scm);
 364     return ret;
 365 }
 366
 367 static DWORD DoUnregServer(void)
 368 {
 369     static const WCHAR msiserverW[] = {'M','S','I','S','e','r','v','e','r',0};
 370     SC_HANDLE scm, service;
 371     DWORD ret = 0;
 372
 373     if (!(scm = OpenSCManagerW(NULL, SERVICES_ACTIVE_DATABASEW, SC_MANAGER_CONNECT)))
 374     {
 375         fprintf(stderr, "Failed to open service control manager\n");
 376         return 1;
 377     }
 378     if ((service = OpenServiceW(scm, msiserverW, DELETE)))
 379     {
 380         if (!DeleteService(service))
 381         {
 382             fprintf(stderr, "Failed to delete MSI service\n");
 383             ret = 1;
 384         }
 385         CloseServiceHandle(service);
 386     }
 387     else if (GetLastError() != ERROR_SERVICE_DOES_NOT_EXIST)
 388     {
 389         fprintf(stderr, "Failed to open MSI service\n");
 390         ret = 1;
 391     }
 392     CloseServiceHandle(scm);
 393     return ret;
 394 }
 395
 396 static INT DoEmbedding( LPWSTR key )
 397 {
 398         printf("Remote custom actions are not supported yet\n");
 399         return 1;
 400 }
 401
 402 /*
 403  * state machine to break up the command line properly
 404  */
 405
 406 enum chomp_state
 407 {
 408     CS_WHITESPACE,
 409     CS_TOKEN,
 410     CS_QUOTE
 411 };
 412
 413 static int chomp( const WCHAR *in, WCHAR *out )
 414 {
 415     enum chomp_state state = CS_TOKEN;
 416     const WCHAR *p;
 417     int count = 1;
 418     BOOL ignore;
 419
 420     for (p = in; *p; p++)
 421     {
 422         ignore = TRUE;
 423         switch (state)
 424         {
 425         case CS_WHITESPACE:
 426             switch (*p)
 427             {
 428             case ' ':
 429                 break;
 430             case '"':
 431                 state = CS_QUOTE;
 432                 count++;
 433                 break;
 434             default:
 435                 count++;
 436                 ignore = FALSE;
 437                 state = CS_TOKEN;
 438             }
 439             break;
 440
 441         case CS_TOKEN:
 442             switch (*p)
 443             {
 444             case '"':
 445                 state = CS_QUOTE;
 446                 break;
 447             case ' ':
 448                 state = CS_WHITESPACE;
 449                 if (out) *out++ = 0;
 450                 break;
 451             default:
 452                 if (p > in && p[-1] == '"')
 453                 {
 454                     if (out) *out++ = 0;
 455                     count++;
 456                 }
 457                 ignore = FALSE;
 458             }
 459             break;
 460
 461         case CS_QUOTE:
 462             switch (*p)
 463             {
 464             case '"':
 465                 state = CS_TOKEN;
 466                 break;
 467             default:
 468                 ignore = FALSE;
 469             }
 470             break;
 471         }
 472         if (!ignore && out) *out++ = *p;
 473     }
 474     if (out) *out = 0;
 475     return count;
 476 }
 477
 478 static void process_args( WCHAR *cmdline, int *pargc, WCHAR ***pargv )
 479 {
 480     WCHAR **argv, *p;
 481     int i, count;
 482
 483     *pargc = 0;
 484     *pargv = NULL;
 485
 486     count = chomp( cmdline, NULL );
 487     if (!(p = HeapAlloc( GetProcessHeap(), 0, (lstrlenW(cmdline) + count + 1) * sizeof(WCHAR) )))
 488         return;
 489
 490     count = chomp( cmdline, p );
 491     if (!(argv = HeapAlloc( GetProcessHeap(), 0, (count + 1) * sizeof(WCHAR *) )))
 492     {
 493         HeapFree( GetProcessHeap(), 0, p );
 494         return;
 495     }
 496     for (i = 0; i < count; i++)
 497     {
 498         argv[i] = p;
 499         p += lstrlenW( p ) + 1;
 500     }
 501     argv[i] = NULL;
 502
 503     *pargc = count;
 504     *pargv = argv;
 505 }
 506
 507 static BOOL process_args_from_reg( const WCHAR *ident, int *pargc, WCHAR ***pargv )
 508 {
 509         LONG r;
 510         HKEY hkey;
 511         DWORD sz = 0, type = 0;
 512         WCHAR *buf;
 513         BOOL ret = FALSE;
 514
 515         r = RegOpenKeyW(HKEY_LOCAL_MACHINE, InstallRunOnce, &hkey);
 516         if(r != ERROR_SUCCESS)
 517                 return FALSE;
 518         r = RegQueryValueExW(hkey, ident, 0, &type, 0, &sz);
 519         if(r == ERROR_SUCCESS && type == REG_SZ)
 520         {
 521                 int len = lstrlenW( *pargv[0] );
 522                 if (!(buf = HeapAlloc( GetProcessHeap(), 0, sz + (len + 1) * sizeof(WCHAR) )))
 523                 {
 524                         RegCloseKey( hkey );
 525                         return FALSE;
 526                 }
 527                 memcpy( buf, *pargv[0], len * sizeof(WCHAR) );
 528                 buf[len++] = ' ';
 529                 r = RegQueryValueExW(hkey, ident, 0, &type, (LPBYTE)(buf + len), &sz);
 530                 if( r == ERROR_SUCCESS )
 531                 {
 532                         process_args(buf, pargc, pargv);
 533                         ret = TRUE;
 534                 }
 535                 HeapFree(GetProcessHeap(), 0, buf);
 536         }
 537         RegCloseKey(hkey);
 538         return ret;
 539 }
 540
 541 int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
 542 {
 543         int i;
 544         BOOL FunctionInstall = FALSE;
 545         BOOL FunctionInstallAdmin = FALSE;
 546         BOOL FunctionRepair = FALSE;
 547         BOOL FunctionAdvertise = FALSE;
 548         BOOL FunctionPatch = FALSE;
 549         BOOL FunctionDllRegisterServer = FALSE;
 550         BOOL FunctionDllUnregisterServer = FALSE;
 551         BOOL FunctionRegServer = FALSE;
 552         BOOL FunctionUnregServer = FALSE;
 553         BOOL FunctionServer = FALSE;
 554         BOOL FunctionUnknown = FALSE;
 555
 556         LPWSTR PackageName = NULL;
 557         LPWSTR Properties = NULL;
 558         struct string_list *property_list = NULL;
 559
 560         DWORD RepairMode = 0;
 561
 562         DWORD_PTR AdvertiseMode = 0;
 563         struct string_list *transform_list = NULL;
 564         LANGID Language = 0;
 565
 566         DWORD LogMode = 0;
 567         LPWSTR LogFileName = NULL;
 568         DWORD LogAttributes = 0;
 569
 570         LPWSTR PatchFileName = NULL;
 571         INSTALLTYPE InstallType = INSTALLTYPE_DEFAULT;
 572
 573         INSTALLUILEVEL InstallUILevel = INSTALLUILEVEL_FULL;
 574
 575         LPWSTR DllName = NULL;
 576         DWORD ReturnCode;
 577         int argc;
 578         LPWSTR *argvW = NULL;
 579
 580         /* parse the command line */
 581         process_args( GetCommandLineW(), &argc, &argvW );
 582
 583         /*
 584          * If the args begin with /@ IDENT then we need to load the real
 585          * command line out of the RunOnceEntries key in the registry.
 586          *  We do that before starting to process the real commandline,
 587          * then overwrite the commandline again.
 588          */
 589         if(argc>1 && msi_option_equal(argvW[1], "@"))
 590         {
 591                 if(!process_args_from_reg( argvW[2], &argc, &argvW ))
 592                         return 1;
 593         }
 594
 595         if (argc == 3 && msi_option_equal(argvW[1], "Embedding"))
 596                 return DoEmbedding( argvW[2] );
 597
 598         for(i = 1; i < argc; i++)
 599         {
 600                 WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i]));
 601
 602                 if (msi_option_equal(argvW[i], "regserver"))
 603                 {
 604                         FunctionRegServer = TRUE;
 605                 }
 606                 else if (msi_option_equal(argvW[i], "unregserver") || msi_option_equal(argvW[i], "unregister")
 607                         ||  msi_option_equal(argvW[i], "unreg"))
 608                 {
 609                         FunctionUnregServer = TRUE;
 610                 }
 611                 else if(msi_option_prefix(argvW[i], "i") || msi_option_prefix(argvW[i], "package"))
 612                 {
 613                         LPWSTR argvWi = argvW[i];
 614                         int argLen = (msi_option_prefix(argvW[i], "i") ? 2 : 8);
 615                         FunctionInstall = TRUE;
 616                         if(lstrlenW(argvW[i]) > argLen)
 617                                 argvWi += argLen;
 618                         else
 619                         {
 620                                 i++;
 621                                 if(i >= argc)
 622                                         ShowUsage(1);
 623                                 WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i]));
 624                                 argvWi = argvW[i];
 625                         }
 626                         PackageName = argvWi;
 627                 }
 628                 else if(msi_option_equal(argvW[i], "a"))
 629                 {
 630                         FunctionInstall = TRUE;
 631                         FunctionInstallAdmin = TRUE;
 632                         InstallType = INSTALLTYPE_NETWORK_IMAGE;
 633                         i++;
 634                         if(i >= argc)
 635                                 ShowUsage(1);
 636                         WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i]));
 637                         PackageName = argvW[i];
 638                         StringListAppend(&property_list, ActionAdmin);
 639                         WINE_FIXME("Administrative installs are not currently supported\n");
 640                 }
 641                 else if(msi_option_prefix(argvW[i], "f"))
 642                 {
 643                         int j;
 644                         int len = lstrlenW(argvW[i]);
 645                         FunctionRepair = TRUE;
 646                         for(j = 2; j < len; j++)
 647                         {
 648                                 switch(argvW[i][j])
 649                                 {
 650                                         case 'P':
 651                                         case 'p':
 652                                                 RepairMode |= REINSTALLMODE_FILEMISSING;
 653                                                 break;
 654                                         case 'O':
 655                                         case 'o':
 656                                                 RepairMode |= REINSTALLMODE_FILEOLDERVERSION;
 657                                                 break;
 658                                         case 'E':
 659                                         case 'e':
 660                                                 RepairMode |= REINSTALLMODE_FILEEQUALVERSION;
 661                                                 break;
 662                                         case 'D':
 663                                         case 'd':
 664                                                 RepairMode |= REINSTALLMODE_FILEEXACT;
 665                                                 break;
 666                                         case 'C':
 667                                         case 'c':
 668                                                 RepairMode |= REINSTALLMODE_FILEVERIFY;
 669                                                 break;
 670                                         case 'A':
 671                                         case 'a':
 672                                                 RepairMode |= REINSTALLMODE_FILEREPLACE;
 673                                                 break;
 674                                         case 'U':
 675                                         case 'u':
 676                                                 RepairMode |= REINSTALLMODE_USERDATA;
 677                                                 break;
 678                                         case 'M':
 679                                         case 'm':
 680                                                 RepairMode |= REINSTALLMODE_MACHINEDATA;
 681                                                 break;
 682                                         case 'S':
 683                                         case 's':
 684                                                 RepairMode |= REINSTALLMODE_SHORTCUT;
 685                                                 break;
 686                                         case 'V':
 687                                         case 'v':
 688                                                 RepairMode |= REINSTALLMODE_PACKAGE;
 689                                                 break;
 690                                         default:
 691                                                 fprintf(stderr, "Unknown option \"%c\" in Repair mode\n", argvW[i][j]);
 692                                                 break;
 693                                 }
 694                         }
 695                         if(len == 2)
 696                         {
 697                                 RepairMode = REINSTALLMODE_FILEMISSING |
 698                                         REINSTALLMODE_FILEEQUALVERSION |
 699                                         REINSTALLMODE_FILEVERIFY |
 700                                         REINSTALLMODE_MACHINEDATA |
 701                                         REINSTALLMODE_SHORTCUT;
 702                         }
 703                         i++;
 704                         if(i >= argc)
 705                                 ShowUsage(1);
 706                         WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i]));
 707                         PackageName = argvW[i];
 708                 }
 709                 else if(msi_option_prefix(argvW[i], "x") || msi_option_equal(argvW[i], "uninstall"))
 710                 {
 711                         FunctionInstall = TRUE;
 712                         if(msi_option_prefix(argvW[i], "x")) PackageName = argvW[i]+2;
 713                         if(!PackageName || !PackageName[0])
 714                         {
 715                                 i++;
 716                                 if (i >= argc)
 717                                         ShowUsage(1);
 718                                 PackageName = argvW[i];
 719                         }
 720                         WINE_TRACE("PackageName = %s\n", wine_dbgstr_w(PackageName));
 721                         StringListAppend(&property_list, RemoveAll);
 722                 }
 723                 else if(msi_option_prefix(argvW[i], "j"))
 724                 {
 725                         int j;
 726                         int len = lstrlenW(argvW[i]);
 727                         FunctionAdvertise = TRUE;
 728                         for(j = 2; j < len; j++)
 729                         {
 730                                 switch(argvW[i][j])
 731                                 {
 732                                         case 'U':
 733                                         case 'u':
 734                                                 AdvertiseMode = ADVERTISEFLAGS_USERASSIGN;
 735                                                 break;
 736                                         case 'M':
 737                                         case 'm':
 738                                                 AdvertiseMode = ADVERTISEFLAGS_MACHINEASSIGN;
 739                                                 break;
 740                                         default:
 741                                                 fprintf(stderr, "Unknown option \"%c\" in Advertise mode\n", argvW[i][j]);
 742                                                 break;
 743                                 }
 744                         }
 745                         i++;
 746                         if(i >= argc)
 747                                 ShowUsage(1);
 748                         WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i]));
 749                         PackageName = argvW[i];
 750                 }
 751                 else if(msi_strequal(argvW[i], "u"))
 752                 {
 753                         FunctionAdvertise = TRUE;
 754                         AdvertiseMode = ADVERTISEFLAGS_USERASSIGN;
 755                         i++;
 756                         if(i >= argc)
 757                                 ShowUsage(1);
 758                         WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i]));
 759                         PackageName = argvW[i];
 760                 }
 761                 else if(msi_strequal(argvW[i], "m"))
 762                 {
 763                         FunctionAdvertise = TRUE;
 764                         AdvertiseMode = ADVERTISEFLAGS_MACHINEASSIGN;
 765                         i++;
 766                         if(i >= argc)
 767                                 ShowUsage(1);
 768                         WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i]));
 769                         PackageName = argvW[i];
 770                 }
 771                 else if(msi_option_equal(argvW[i], "t"))
 772                 {
 773                         i++;
 774                         if(i >= argc)
 775                                 ShowUsage(1);
 776                         WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i]));
 777                         StringListAppend(&transform_list, argvW[i]);
 778                 }
 779                 else if(msi_option_equal(argvW[i], "g"))
 780                 {
 781                         i++;
 782                         if(i >= argc)
 783                                 ShowUsage(1);
 784                         WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i]));
 785                         Language = msi_atou(argvW[i]);
 786                 }
 787                 else if(msi_option_prefix(argvW[i], "l"))
 788                 {
 789                         int j;
 790                         int len = lstrlenW(argvW[i]);
 791                         for(j = 2; j < len; j++)
 792                         {
 793                                 switch(argvW[i][j])
 794                                 {
 795                                         case 'I':
 796                                         case 'i':
 797                                                 LogMode |= INSTALLLOGMODE_INFO;
 798                                                 break;
 799                                         case 'W':
 800                                         case 'w':
 801                                                 LogMode |= INSTALLLOGMODE_WARNING;
 802                                                 break;
 803                                         case 'E':
 804                                         case 'e':
 805                                                 LogMode |= INSTALLLOGMODE_ERROR;
 806                                                 break;
 807                                         case 'A':
 808                                         case 'a':
 809                                                 LogMode |= INSTALLLOGMODE_ACTIONSTART;
 810                                                 break;
 811                                         case 'R':
 812                                         case 'r':
 813                                                 LogMode |= INSTALLLOGMODE_ACTIONDATA;
 814                                                 break;
 815                                         case 'U':
 816                                         case 'u':
 817                                                 LogMode |= INSTALLLOGMODE_USER;
 818                                                 break;
 819                                         case 'C':
 820                                         case 'c':
 821                                                 LogMode |= INSTALLLOGMODE_COMMONDATA;
 822                                                 break;
 823                                         case 'M':
 824                                         case 'm':
 825                                                 LogMode |= INSTALLLOGMODE_FATALEXIT;
 826                                                 break;
 827                                         case 'O':
 828                                         case 'o':
 829                                                 LogMode |= INSTALLLOGMODE_OUTOFDISKSPACE;
 830                                                 break;
 831                                         case 'P':
 832                                         case 'p':
 833                                                 LogMode |= INSTALLLOGMODE_PROPERTYDUMP;
 834                                                 break;
 835                                         case 'V':
 836                                         case 'v':
 837                                                 LogMode |= INSTALLLOGMODE_VERBOSE;
 838                                                 break;
 839                                         case '*':
 840                                                 LogMode = INSTALLLOGMODE_FATALEXIT |
 841                                                         INSTALLLOGMODE_ERROR |
 842                                                         INSTALLLOGMODE_WARNING |
 843                                                         INSTALLLOGMODE_USER |
 844                                                         INSTALLLOGMODE_INFO |
 845                                                         INSTALLLOGMODE_RESOLVESOURCE |
 846                                                         INSTALLLOGMODE_OUTOFDISKSPACE |
 847                                                         INSTALLLOGMODE_ACTIONSTART |
 848                                                         INSTALLLOGMODE_ACTIONDATA |
 849                                                         INSTALLLOGMODE_COMMONDATA |
 850                                                         INSTALLLOGMODE_PROPERTYDUMP |
 851                                                         INSTALLLOGMODE_PROGRESS |
 852                                                         INSTALLLOGMODE_INITIALIZE |
 853                                                         INSTALLLOGMODE_TERMINATE |
 854                                                         INSTALLLOGMODE_SHOWDIALOG;
 855                                                 break;
 856                                         case '+':
 857                                                 LogAttributes |= INSTALLLOGATTRIBUTES_APPEND;
 858                                                 break;
 859                                         case '!':
 860                                                 LogAttributes |= INSTALLLOGATTRIBUTES_FLUSHEACHLINE;
 861                                                 break;
 862                                         default:
 863                                                 break;
 864                                 }
 865                         }
 866                         i++;
 867                         if(i >= argc)
 868                                 ShowUsage(1);
 869                         WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i]));
 870                         LogFileName = argvW[i];
 871                         if(MsiEnableLogW(LogMode, LogFileName, LogAttributes) != ERROR_SUCCESS)
 872                         {
 873                                 fprintf(stderr, "Logging in %s (0x%08x, %u) failed\n",
 874                                          wine_dbgstr_w(LogFileName), LogMode, LogAttributes);
 875                                 ExitProcess(1);
 876                         }
 877                 }
 878                 else if(msi_option_equal(argvW[i], "p") || msi_option_equal(argvW[i], "update"))
 879                 {
 880                         FunctionPatch = TRUE;
 881                         i++;
 882                         if(i >= argc)
 883                                 ShowUsage(1);
 884                         WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i]));
 885                         PatchFileName = argvW[i];
 886                 }
 887                 else if(msi_option_prefix(argvW[i], "q"))
 888                 {
 889                         if(lstrlenW(argvW[i]) == 2 || msi_strequal(argvW[i]+2, "n") ||
 890                            msi_strequal(argvW[i] + 2, "uiet"))
 891                         {
 892                                 InstallUILevel = INSTALLUILEVEL_NONE;
 893                         }
 894                         else if(msi_strequal(argvW[i]+2, "r"))
 895                         {
 896                                 InstallUILevel = INSTALLUILEVEL_REDUCED;
 897                         }
 898                         else if(msi_strequal(argvW[i]+2, "f"))
 899                         {
 900                                 InstallUILevel = INSTALLUILEVEL_FULL|INSTALLUILEVEL_ENDDIALOG;
 901                         }
 902                         else if(msi_strequal(argvW[i]+2, "n+"))
 903                         {
 904                                 InstallUILevel = INSTALLUILEVEL_NONE|INSTALLUILEVEL_ENDDIALOG;
 905                         }
 906                         else if(msi_strprefix(argvW[i]+2, "b"))
 907                         {
 908                 const WCHAR *ptr = argvW[i] + 3;
 909
 910                 InstallUILevel = INSTALLUILEVEL_BASIC;
 911
 912                 while (*ptr)
 913                 {
 914                     if (msi_strprefix(ptr, "+"))
 915                         InstallUILevel |= INSTALLUILEVEL_ENDDIALOG;
 916                     if (msi_strprefix(ptr, "-"))
 917                         InstallUILevel |= INSTALLUILEVEL_PROGRESSONLY;
 918                     if (msi_strprefix(ptr, "!"))
 919                     {
 920                         WINE_FIXME("Unhandled modifier: !\n");
 921                         InstallUILevel |= INSTALLUILEVEL_HIDECANCEL;
 922                     }
 923                     ptr++;
 924                 }
 925                         }
 926                         else
 927                         {
 928                                 fprintf(stderr, "Unknown option \"%s\" for UI level\n",
 929                                          wine_dbgstr_w(argvW[i]+2));
 930                         }
 931                 }
 932                 else if(msi_option_equal(argvW[i], "passive"))
 933                 {
 934                     static const WCHAR rebootpromptW[] =
 935                         {'R','E','B','O','O','T','P','R','O','M','P','T','=','"','S','"',0};
 936
 937                     InstallUILevel = INSTALLUILEVEL_BASIC|INSTALLUILEVEL_PROGRESSONLY|INSTALLUILEVEL_HIDECANCEL;
 938                     StringListAppend(&property_list, rebootpromptW);
 939                 }
 940                 else if(msi_option_equal(argvW[i], "y"))
 941                 {
 942                         FunctionDllRegisterServer = TRUE;
 943                         i++;
 944                         if(i >= argc)
 945                                 ShowUsage(1);
 946                         WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i]));
 947                         DllName = argvW[i];
 948                 }
 949                 else if(msi_option_equal(argvW[i], "z"))
 950                 {
 951                         FunctionDllUnregisterServer = TRUE;
 952                         i++;
 953                         if(i >= argc)
 954                                 ShowUsage(1);
 955                         WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i]));
 956                         DllName = argvW[i];
 957                 }
 958                 else if(msi_option_equal(argvW[i], "help") || msi_option_equal(argvW[i], "?"))
 959                 {
 960                         ShowUsage(0);
 961                 }
 962                 else if(msi_option_equal(argvW[i], "m"))
 963                 {
 964                         FunctionUnknown = TRUE;
 965                         WINE_FIXME("Unknown parameter /m\n");
 966                 }
 967                 else if(msi_option_equal(argvW[i], "D"))
 968                 {
 969                         FunctionUnknown = TRUE;
 970                         WINE_FIXME("Unknown parameter /D\n");
 971                 }
 972                 else if (msi_option_equal(argvW[i], "V"))
 973                 {
 974                     FunctionServer = TRUE;
 975                 }
 976                 else
 977                         StringListAppend(&property_list, argvW[i]);
 978         }
 979
 980         /* start the GUI */
 981         MsiSetInternalUI(InstallUILevel, NULL);
 982
 983         Properties = build_properties( property_list );
 984
 985         if(FunctionInstallAdmin && FunctionPatch)
 986                 FunctionInstall = FALSE;
 987
 988         ReturnCode = 1;
 989         if(FunctionInstall)
 990         {
 991                 if(IsProductCode(PackageName))
 992                         ReturnCode = MsiConfigureProductExW(PackageName, 0, INSTALLSTATE_DEFAULT, Properties);
 993                 else
 994                         ReturnCode = MsiInstallProductW(PackageName, Properties);
 995         }
 996         else if(FunctionRepair)
 997         {
 998                 if(IsProductCode(PackageName))
 999                         WINE_FIXME("Product code treatment not implemented yet\n");
1000                 else
1001                         ReturnCode = MsiReinstallProductW(PackageName, RepairMode);
1002         }
1003         else if(FunctionAdvertise)
1004         {
1005                 LPWSTR Transforms = build_transforms( property_list );
1006                 ReturnCode = MsiAdvertiseProductW(PackageName, (LPWSTR) AdvertiseMode, Transforms, Language);
1007         }
1008         else if(FunctionPatch)
1009         {
1010                 ReturnCode = MsiApplyPatchW(PatchFileName, PackageName, InstallType, Properties);
1011         }
1012         else if(FunctionDllRegisterServer)
1013         {
1014                 ReturnCode = DoDllRegisterServer(DllName);
1015         }
1016         else if(FunctionDllUnregisterServer)
1017         {
1018                 ReturnCode = DoDllUnregisterServer(DllName);
1019         }
1020         else if (FunctionRegServer)
1021         {
1022                 ReturnCode = DoRegServer();
1023         }
1024         else if (FunctionUnregServer)
1025         {
1026                 ReturnCode = DoUnregServer();
1027         }
1028         else if (FunctionServer)
1029         {
1030             ReturnCode = DoService();
1031         }
1032         else if (FunctionUnknown)
1033         {
1034                 WINE_FIXME( "Unknown function, ignoring\n" );
1035         }
1036         else
1037                 ShowUsage(1);
1038
1039         return ReturnCode;
1040 }