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