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 static LPWSTR msi_strdup(LPCWSTR str)
 220 {
 221         DWORD len = lstrlenW(str)+1;
 222         LPWSTR ret = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR)*len);
 223         lstrcpyW(ret, str);
 224         return ret;
 225 }
 226
 227 /* str1 is the same as str2, ignoring case */
 228 static BOOL msi_strequal(LPCWSTR str1, LPCSTR str2)
 229 {
 230         DWORD len, ret;
 231         LPWSTR strW;
 232
 233         len = MultiByteToWideChar( CP_ACP, 0, str2, -1, NULL, 0);
 234         if( !len )
 235                 return FALSE;
 236         if( lstrlenW(str1) != (len-1) )
 237                 return FALSE;
 238         strW = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR)*len);
 239         MultiByteToWideChar( CP_ACP, 0, str2, -1, strW, len);
 240         ret = CompareStringW(GetThreadLocale(), NORM_IGNORECASE, str1, len, strW, len);
 241         HeapFree(GetProcessHeap(), 0, strW);
 242         return (ret == CSTR_EQUAL);
 243 }
 244
 245 /* prefix is hyphen or dash, and str1 is the same as str2, ignoring case */
 246 static BOOL msi_option_equal(LPCWSTR str1, LPCSTR str2)
 247 {
 248     if (str1[0] != '/' && str1[0] != '-')
 249         return FALSE;
 250
 251     /* skip over the hyphen or slash */
 252     return msi_strequal(str1 + 1, str2);
 253 }
 254
 255 /* str2 is at the beginning of str1, ignoring case */
 256 static BOOL msi_strprefix(LPCWSTR str1, LPCSTR str2)
 257 {
 258         DWORD len, ret;
 259         LPWSTR strW;
 260
 261         len = MultiByteToWideChar( CP_ACP, 0, str2, -1, NULL, 0);
 262         if( !len )
 263                 return FALSE;
 264         if( lstrlenW(str1) < (len-1) )
 265                 return FALSE;
 266         strW = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR)*len);
 267         MultiByteToWideChar( CP_ACP, 0, str2, -1, strW, len);
 268         ret = CompareStringW(GetThreadLocale(), NORM_IGNORECASE, str1, len-1, strW, len-1);
 269         HeapFree(GetProcessHeap(), 0, strW);
 270         return (ret == CSTR_EQUAL);
 271 }
 272
 273 /* prefix is hyphen or dash, and str2 is at the beginning of str1, ignoring case */
 274 static BOOL msi_option_prefix(LPCWSTR str1, LPCSTR str2)
 275 {
 276     if (str1[0] != '/' && str1[0] != '-')
 277         return FALSE;
 278
 279     /* skip over the hyphen or slash */
 280     return msi_strprefix(str1 + 1, str2);
 281 }
 282
 283 static VOID *LoadProc(LPCWSTR DllName, LPCSTR ProcName, HMODULE* DllHandle)
 284 {
 285         VOID* (*proc)(void);
 286
 287         *DllHandle = LoadLibraryExW(DllName, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
 288         if(!*DllHandle)
 289         {
 290                 fprintf(stderr, "Unable to load dll %s\n", wine_dbgstr_w(DllName));
 291                 ExitProcess(1);
 292         }
 293         proc = (VOID *) GetProcAddress(*DllHandle, ProcName);
 294         if(!proc)
 295         {
 296                 fprintf(stderr, "Dll %s does not implement function %s\n",
 297                         wine_dbgstr_w(DllName), ProcName);
 298                 FreeLibrary(*DllHandle);
 299                 ExitProcess(1);
 300         }
 301
 302         return proc;
 303 }
 304
 305 static DWORD DoDllRegisterServer(LPCWSTR DllName)
 306 {
 307         HRESULT hr;
 308         DLLREGISTERSERVER pfDllRegisterServer = NULL;
 309         HMODULE DllHandle = NULL;
 310
 311         pfDllRegisterServer = LoadProc(DllName, "DllRegisterServer", &DllHandle);
 312
 313         hr = pfDllRegisterServer();
 314         if(FAILED(hr))
 315         {
 316                 fprintf(stderr, "Failed to register dll %s\n", wine_dbgstr_w(DllName));
 317                 return 1;
 318         }
 319         printf("Successfully registered dll %s\n", wine_dbgstr_w(DllName));
 320         if(DllHandle)
 321                 FreeLibrary(DllHandle);
 322         return 0;
 323 }
 324
 325 static DWORD DoDllUnregisterServer(LPCWSTR DllName)
 326 {
 327         HRESULT hr;
 328         DLLUNREGISTERSERVER pfDllUnregisterServer = NULL;
 329         HMODULE DllHandle = NULL;
 330
 331         pfDllUnregisterServer = LoadProc(DllName, "DllUnregisterServer", &DllHandle);
 332
 333         hr = pfDllUnregisterServer();
 334         if(FAILED(hr))
 335         {
 336                 fprintf(stderr, "Failed to unregister dll %s\n", wine_dbgstr_w(DllName));
 337                 return 1;
 338         }
 339         printf("Successfully unregistered dll %s\n", wine_dbgstr_w(DllName));
 340         if(DllHandle)
 341                 FreeLibrary(DllHandle);
 342         return 0;
 343 }
 344
 345 static DWORD DoRegServer(void)
 346 {
 347     static const WCHAR msiserverW[] = {'M','S','I','S','e','r','v','e','r',0};
 348     static const WCHAR msiexecW[] = {'\\','m','s','i','e','x','e','c',' ','/','V',0};
 349     SC_HANDLE scm, service;
 350     WCHAR path[MAX_PATH+12];
 351     DWORD len, ret = 0;
 352
 353     if (!(scm = OpenSCManagerW(NULL, SERVICES_ACTIVE_DATABASEW, SC_MANAGER_CREATE_SERVICE)))
 354     {
 355         fprintf(stderr, "Failed to open the service control manager.\n");
 356         return 1;
 357     }
 358     len = GetSystemDirectoryW(path, MAX_PATH);
 359     lstrcpyW(path + len, msiexecW);
 360     if ((service = CreateServiceW(scm, msiserverW, msiserverW, GENERIC_ALL,
 361                                   SERVICE_WIN32_SHARE_PROCESS, SERVICE_DEMAND_START,
 362                                   SERVICE_ERROR_NORMAL, path, NULL, NULL, NULL, NULL, NULL)))
 363     {
 364         CloseServiceHandle(service);
 365     }
 366     else if (GetLastError() != ERROR_SERVICE_EXISTS)
 367     {
 368         fprintf(stderr, "Failed to create MSI service\n");
 369         ret = 1;
 370     }
 371     CloseServiceHandle(scm);
 372     return ret;
 373 }
 374
 375 static DWORD DoUnregServer(void)
 376 {
 377     static const WCHAR msiserverW[] = {'M','S','I','S','e','r','v','e','r',0};
 378     SC_HANDLE scm, service;
 379     DWORD ret = 0;
 380
 381     if (!(scm = OpenSCManagerW(NULL, SERVICES_ACTIVE_DATABASEW, SC_MANAGER_CONNECT)))
 382     {
 383         fprintf(stderr, "Failed to open service control manager\n");
 384         return 1;
 385     }
 386     if ((service = OpenServiceW(scm, msiserverW, DELETE)))
 387     {
 388         if (!DeleteService(service))
 389         {
 390             fprintf(stderr, "Failed to delete MSI service\n");
 391             ret = 1;
 392         }
 393         CloseServiceHandle(service);
 394     }
 395     else if (GetLastError() != ERROR_SERVICE_DOES_NOT_EXIST)
 396     {
 397         fprintf(stderr, "Failed to open MSI service\n");
 398         ret = 1;
 399     }
 400     CloseServiceHandle(scm);
 401     return ret;
 402 }
 403
 404 static INT DoEmbedding( LPWSTR key )
 405 {
 406         printf("Remote custom actions are not supported yet\n");
 407         return 1;
 408 }
 409
 410 /*
 411  * state machine to break up the command line properly
 412  */
 413
 414 enum chomp_state
 415 {
 416         cs_whitespace,
 417         cs_token,
 418         cs_quote
 419 };
 420
 421 static int chomp( WCHAR *str )
 422 {
 423         enum chomp_state state = cs_token;
 424         WCHAR *p, *out;
 425         int count = 1;
 426         BOOL ignore;
 427
 428         for( p = str, out = str; *p; p++ )
 429         {
 430                 ignore = TRUE;
 431                 switch( state )
 432                 {
 433                 case cs_whitespace:
 434                         switch( *p )
 435                         {
 436                         case ' ':
 437                                 break;
 438                         case '"':
 439                                 state = cs_quote;
 440                                 count++;
 441                                 break;
 442                         default:
 443                                 count++;
 444                                 ignore = FALSE;
 445                                 state = cs_token;
 446                         }
 447                         break;
 448
 449                 case cs_token:
 450                         switch( *p )
 451                         {
 452                         case '"':
 453                                 state = cs_quote;
 454                                 break;
 455                         case ' ':
 456                                 state = cs_whitespace;
 457                                 *out++ = 0;
 458                                 break;
 459                         default:
 460                                 ignore = FALSE;
 461                         }
 462                         break;
 463
 464                 case cs_quote:
 465                         switch( *p )
 466                         {
 467                         case '"':
 468                                 state = cs_token;
 469                                 break;
 470                         default:
 471                                 ignore = FALSE;
 472                         }
 473                         break;
 474                 }
 475                 if( !ignore )
 476                         *out++ = *p;
 477         }
 478
 479         *out = 0;
 480
 481         return count;
 482 }
 483
 484 static void process_args( WCHAR *cmdline, int *pargc, WCHAR ***pargv )
 485 {
 486         WCHAR **argv, *p = msi_strdup(cmdline);
 487         int i, n;
 488
 489         n = chomp( p );
 490         argv = HeapAlloc(GetProcessHeap(), 0, sizeof (WCHAR*)*(n+1));
 491         for( i=0; i<n; i++ )
 492         {
 493                 argv[i] = p;
 494                 p += lstrlenW(p) + 1;
 495         }
 496         argv[i] = NULL;
 497
 498         *pargc = n;
 499         *pargv = argv;
 500 }
 501
 502 static BOOL process_args_from_reg( const WCHAR *ident, int *pargc, WCHAR ***pargv )
 503 {
 504         LONG r;
 505         HKEY hkey;
 506         DWORD sz = 0, type = 0;
 507         WCHAR *buf;
 508         BOOL ret = FALSE;
 509
 510         r = RegOpenKeyW(HKEY_LOCAL_MACHINE, InstallRunOnce, &hkey);
 511         if(r != ERROR_SUCCESS)
 512                 return FALSE;
 513         r = RegQueryValueExW(hkey, ident, 0, &type, 0, &sz);
 514         if(r == ERROR_SUCCESS && type == REG_SZ)
 515         {
 516                 int len = lstrlenW( *pargv[0] );
 517                 if (!(buf = HeapAlloc( GetProcessHeap(), 0, sz + (len + 1) * sizeof(WCHAR) )))
 518                 {
 519                         RegCloseKey( hkey );
 520                         return FALSE;
 521                 }
 522                 memcpy( buf, *pargv[0], len * sizeof(WCHAR) );
 523                 buf[len++] = ' ';
 524                 r = RegQueryValueExW(hkey, ident, 0, &type, (LPBYTE)(buf + len), &sz);
 525                 if( r == ERROR_SUCCESS )
 526                 {
 527                         process_args(buf, pargc, pargv);
 528                         ret = TRUE;
 529                 }
 530                 HeapFree(GetProcessHeap(), 0, buf);
 531         }
 532         RegCloseKey(hkey);
 533         return ret;
 534 }
 535
 536 int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
 537 {
 538         int i;
 539         BOOL FunctionInstall = FALSE;
 540         BOOL FunctionInstallAdmin = FALSE;
 541         BOOL FunctionRepair = FALSE;
 542         BOOL FunctionAdvertise = FALSE;
 543         BOOL FunctionPatch = FALSE;
 544         BOOL FunctionDllRegisterServer = FALSE;
 545         BOOL FunctionDllUnregisterServer = FALSE;
 546         BOOL FunctionRegServer = FALSE;
 547         BOOL FunctionUnregServer = FALSE;
 548         BOOL FunctionServer = FALSE;
 549         BOOL FunctionUnknown = FALSE;
 550
 551         LPWSTR PackageName = NULL;
 552         LPWSTR Properties = NULL;
 553         struct string_list *property_list = NULL;
 554
 555         DWORD RepairMode = 0;
 556
 557         DWORD_PTR AdvertiseMode = 0;
 558         struct string_list *transform_list = NULL;
 559         LANGID Language = 0;
 560
 561         DWORD LogMode = 0;
 562         LPWSTR LogFileName = NULL;
 563         DWORD LogAttributes = 0;
 564
 565         LPWSTR PatchFileName = NULL;
 566         INSTALLTYPE InstallType = INSTALLTYPE_DEFAULT;
 567
 568         INSTALLUILEVEL InstallUILevel = INSTALLUILEVEL_FULL;
 569
 570         LPWSTR DllName = NULL;
 571         DWORD ReturnCode;
 572         int argc;
 573         LPWSTR *argvW = NULL;
 574
 575         /* parse the command line */
 576         process_args( GetCommandLineW(), &argc, &argvW );
 577
 578         /*
 579          * If the args begin with /@ IDENT then we need to load the real
 580          * command line out of the RunOnceEntries key in the registry.
 581          *  We do that before starting to process the real commandline,
 582          * then overwrite the commandline again.
 583          */
 584         if(argc>1 && msi_option_equal(argvW[1], "@"))
 585         {
 586                 if(!process_args_from_reg( argvW[2], &argc, &argvW ))
 587                         return 1;
 588         }
 589
 590         if (argc == 3 && msi_option_equal(argvW[1], "Embedding"))
 591                 return DoEmbedding( argvW[2] );
 592
 593         for(i = 1; i < argc; i++)
 594         {
 595                 WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i]));
 596
 597                 if (msi_option_equal(argvW[i], "regserver"))
 598                 {
 599                         FunctionRegServer = TRUE;
 600                 }
 601                 else if (msi_option_equal(argvW[i], "unregserver") || msi_option_equal(argvW[i], "unregister")
 602                         ||  msi_option_equal(argvW[i], "unreg"))
 603                 {
 604                         FunctionUnregServer = TRUE;
 605                 }
 606                 else if(msi_option_prefix(argvW[i], "i") || msi_option_prefix(argvW[i], "package"))
 607                 {
 608                         LPWSTR argvWi = argvW[i];
 609                         int argLen = (msi_option_prefix(argvW[i], "i") ? 2 : 8);
 610                         FunctionInstall = TRUE;
 611                         if(lstrlenW(argvW[i]) > argLen)
 612                                 argvWi += argLen;
 613                         else
 614                         {
 615                                 i++;
 616                                 if(i >= argc)
 617                                         ShowUsage(1);
 618                                 WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i]));
 619                                 argvWi = argvW[i];
 620                         }
 621                         PackageName = argvWi;
 622                 }
 623                 else if(msi_option_equal(argvW[i], "a"))
 624                 {
 625                         FunctionInstall = TRUE;
 626                         FunctionInstallAdmin = TRUE;
 627                         InstallType = INSTALLTYPE_NETWORK_IMAGE;
 628                         i++;
 629                         if(i >= argc)
 630                                 ShowUsage(1);
 631                         WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i]));
 632                         PackageName = argvW[i];
 633                         StringListAppend(&property_list, ActionAdmin);
 634                         WINE_FIXME("Administrative installs are not currently supported\n");
 635                 }
 636                 else if(msi_option_prefix(argvW[i], "f"))
 637                 {
 638                         int j;
 639                         int len = lstrlenW(argvW[i]);
 640                         FunctionRepair = TRUE;
 641                         for(j = 2; j < len; j++)
 642                         {
 643                                 switch(argvW[i][j])
 644                                 {
 645                                         case 'P':
 646                                         case 'p':
 647                                                 RepairMode |= REINSTALLMODE_FILEMISSING;
 648                                                 break;
 649                                         case 'O':
 650                                         case 'o':
 651                                                 RepairMode |= REINSTALLMODE_FILEOLDERVERSION;
 652                                                 break;
 653                                         case 'E':
 654                                         case 'e':
 655                                                 RepairMode |= REINSTALLMODE_FILEEQUALVERSION;
 656                                                 break;
 657                                         case 'D':
 658                                         case 'd':
 659                                                 RepairMode |= REINSTALLMODE_FILEEXACT;
 660                                                 break;
 661                                         case 'C':
 662                                         case 'c':
 663                                                 RepairMode |= REINSTALLMODE_FILEVERIFY;
 664                                                 break;
 665                                         case 'A':
 666                                         case 'a':
 667                                                 RepairMode |= REINSTALLMODE_FILEREPLACE;
 668                                                 break;
 669                                         case 'U':
 670                                         case 'u':
 671                                                 RepairMode |= REINSTALLMODE_USERDATA;
 672                                                 break;
 673                                         case 'M':
 674                                         case 'm':
 675                                                 RepairMode |= REINSTALLMODE_MACHINEDATA;
 676                                                 break;
 677                                         case 'S':
 678                                         case 's':
 679                                                 RepairMode |= REINSTALLMODE_SHORTCUT;
 680                                                 break;
 681                                         case 'V':
 682                                         case 'v':
 683                                                 RepairMode |= REINSTALLMODE_PACKAGE;
 684                                                 break;
 685                                         default:
 686                                                 fprintf(stderr, "Unknown option \"%c\" in Repair mode\n", argvW[i][j]);
 687                                                 break;
 688                                 }
 689                         }
 690                         if(len == 2)
 691                         {
 692                                 RepairMode = REINSTALLMODE_FILEMISSING |
 693                                         REINSTALLMODE_FILEEQUALVERSION |
 694                                         REINSTALLMODE_FILEVERIFY |
 695                                         REINSTALLMODE_MACHINEDATA |
 696                                         REINSTALLMODE_SHORTCUT;
 697                         }
 698                         i++;
 699                         if(i >= argc)
 700                                 ShowUsage(1);
 701                         WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i]));
 702                         PackageName = argvW[i];
 703                 }
 704                 else if(msi_option_prefix(argvW[i], "x") || msi_option_equal(argvW[i], "uninstall"))
 705                 {
 706                         FunctionInstall = TRUE;
 707                         if(msi_option_prefix(argvW[i], "x")) PackageName = argvW[i]+2;
 708                         if(!PackageName || !PackageName[0])
 709                         {
 710                                 i++;
 711                                 if (i >= argc)
 712                                         ShowUsage(1);
 713                                 PackageName = argvW[i];
 714                         }
 715                         WINE_TRACE("PackageName = %s\n", wine_dbgstr_w(PackageName));
 716                         StringListAppend(&property_list, RemoveAll);
 717                 }
 718                 else if(msi_option_prefix(argvW[i], "j"))
 719                 {
 720                         int j;
 721                         int len = lstrlenW(argvW[i]);
 722                         FunctionAdvertise = TRUE;
 723                         for(j = 2; j < len; j++)
 724                         {
 725                                 switch(argvW[i][j])
 726                                 {
 727                                         case 'U':
 728                                         case 'u':
 729                                                 AdvertiseMode = ADVERTISEFLAGS_USERASSIGN;
 730                                                 break;
 731                                         case 'M':
 732                                         case 'm':
 733                                                 AdvertiseMode = ADVERTISEFLAGS_MACHINEASSIGN;
 734                                                 break;
 735                                         default:
 736                                                 fprintf(stderr, "Unknown option \"%c\" in Advertise mode\n", argvW[i][j]);
 737                                                 break;
 738                                 }
 739                         }
 740                         i++;
 741                         if(i >= argc)
 742                                 ShowUsage(1);
 743                         WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i]));
 744                         PackageName = argvW[i];
 745                 }
 746                 else if(msi_strequal(argvW[i], "u"))
 747                 {
 748                         FunctionAdvertise = TRUE;
 749                         AdvertiseMode = ADVERTISEFLAGS_USERASSIGN;
 750                         i++;
 751                         if(i >= argc)
 752                                 ShowUsage(1);
 753                         WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i]));
 754                         PackageName = argvW[i];
 755                 }
 756                 else if(msi_strequal(argvW[i], "m"))
 757                 {
 758                         FunctionAdvertise = TRUE;
 759                         AdvertiseMode = ADVERTISEFLAGS_MACHINEASSIGN;
 760                         i++;
 761                         if(i >= argc)
 762                                 ShowUsage(1);
 763                         WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i]));
 764                         PackageName = argvW[i];
 765                 }
 766                 else if(msi_option_equal(argvW[i], "t"))
 767                 {
 768                         i++;
 769                         if(i >= argc)
 770                                 ShowUsage(1);
 771                         WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i]));
 772                         StringListAppend(&transform_list, argvW[i]);
 773                 }
 774                 else if(msi_option_equal(argvW[i], "g"))
 775                 {
 776                         i++;
 777                         if(i >= argc)
 778                                 ShowUsage(1);
 779                         WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i]));
 780                         Language = msi_atou(argvW[i]);
 781                 }
 782                 else if(msi_option_prefix(argvW[i], "l"))
 783                 {
 784                         int j;
 785                         int len = lstrlenW(argvW[i]);
 786                         for(j = 2; j < len; j++)
 787                         {
 788                                 switch(argvW[i][j])
 789                                 {
 790                                         case 'I':
 791                                         case 'i':
 792                                                 LogMode |= INSTALLLOGMODE_INFO;
 793                                                 break;
 794                                         case 'W':
 795                                         case 'w':
 796                                                 LogMode |= INSTALLLOGMODE_WARNING;
 797                                                 break;
 798                                         case 'E':
 799                                         case 'e':
 800                                                 LogMode |= INSTALLLOGMODE_ERROR;
 801                                                 break;
 802                                         case 'A':
 803                                         case 'a':
 804                                                 LogMode |= INSTALLLOGMODE_ACTIONSTART;
 805                                                 break;
 806                                         case 'R':
 807                                         case 'r':
 808                                                 LogMode |= INSTALLLOGMODE_ACTIONDATA;
 809                                                 break;
 810                                         case 'U':
 811                                         case 'u':
 812                                                 LogMode |= INSTALLLOGMODE_USER;
 813                                                 break;
 814                                         case 'C':
 815                                         case 'c':
 816                                                 LogMode |= INSTALLLOGMODE_COMMONDATA;
 817                                                 break;
 818                                         case 'M':
 819                                         case 'm':
 820                                                 LogMode |= INSTALLLOGMODE_FATALEXIT;
 821                                                 break;
 822                                         case 'O':
 823                                         case 'o':
 824                                                 LogMode |= INSTALLLOGMODE_OUTOFDISKSPACE;
 825                                                 break;
 826                                         case 'P':
 827                                         case 'p':
 828                                                 LogMode |= INSTALLLOGMODE_PROPERTYDUMP;
 829                                                 break;
 830                                         case 'V':
 831                                         case 'v':
 832                                                 LogMode |= INSTALLLOGMODE_VERBOSE;
 833                                                 break;
 834                                         case '*':
 835                                                 LogMode = INSTALLLOGMODE_FATALEXIT |
 836                                                         INSTALLLOGMODE_ERROR |
 837                                                         INSTALLLOGMODE_WARNING |
 838                                                         INSTALLLOGMODE_USER |
 839                                                         INSTALLLOGMODE_INFO |
 840                                                         INSTALLLOGMODE_RESOLVESOURCE |
 841                                                         INSTALLLOGMODE_OUTOFDISKSPACE |
 842                                                         INSTALLLOGMODE_ACTIONSTART |
 843                                                         INSTALLLOGMODE_ACTIONDATA |
 844                                                         INSTALLLOGMODE_COMMONDATA |
 845                                                         INSTALLLOGMODE_PROPERTYDUMP |
 846                                                         INSTALLLOGMODE_PROGRESS |
 847                                                         INSTALLLOGMODE_INITIALIZE |
 848                                                         INSTALLLOGMODE_TERMINATE |
 849                                                         INSTALLLOGMODE_SHOWDIALOG;
 850                                                 break;
 851                                         case '+':
 852                                                 LogAttributes |= INSTALLLOGATTRIBUTES_APPEND;
 853                                                 break;
 854                                         case '!':
 855                                                 LogAttributes |= INSTALLLOGATTRIBUTES_FLUSHEACHLINE;
 856                                                 break;
 857                                         default:
 858                                                 break;
 859                                 }
 860                         }
 861                         i++;
 862                         if(i >= argc)
 863                                 ShowUsage(1);
 864                         WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i]));
 865                         LogFileName = argvW[i];
 866                         if(MsiEnableLogW(LogMode, LogFileName, LogAttributes) != ERROR_SUCCESS)
 867                         {
 868                                 fprintf(stderr, "Logging in %s (0x%08x, %u) failed\n",
 869                                          wine_dbgstr_w(LogFileName), LogMode, LogAttributes);
 870                                 ExitProcess(1);
 871                         }
 872                 }
 873                 else if(msi_option_equal(argvW[i], "p") || msi_option_equal(argvW[i], "update"))
 874                 {
 875                         FunctionPatch = TRUE;
 876                         i++;
 877                         if(i >= argc)
 878                                 ShowUsage(1);
 879                         WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i]));
 880                         PatchFileName = argvW[i];
 881                 }
 882                 else if(msi_option_prefix(argvW[i], "q"))
 883                 {
 884                         if(lstrlenW(argvW[i]) == 2 || msi_strequal(argvW[i]+2, "n") ||
 885                            msi_strequal(argvW[i] + 2, "uiet"))
 886                         {
 887                                 InstallUILevel = INSTALLUILEVEL_NONE;
 888                         }
 889                         else if(msi_strequal(argvW[i]+2, "r"))
 890                         {
 891                                 InstallUILevel = INSTALLUILEVEL_REDUCED;
 892                         }
 893                         else if(msi_strequal(argvW[i]+2, "f"))
 894                         {
 895                                 InstallUILevel = INSTALLUILEVEL_FULL|INSTALLUILEVEL_ENDDIALOG;
 896                         }
 897                         else if(msi_strequal(argvW[i]+2, "n+"))
 898                         {
 899                                 InstallUILevel = INSTALLUILEVEL_NONE|INSTALLUILEVEL_ENDDIALOG;
 900                         }
 901                         else if(msi_strprefix(argvW[i]+2, "b"))
 902                         {
 903                 const WCHAR *ptr = argvW[i] + 3;
 904
 905                 InstallUILevel = INSTALLUILEVEL_BASIC;
 906
 907                 while (*ptr)
 908                 {
 909                     if (msi_strprefix(ptr, "+"))
 910                         InstallUILevel |= INSTALLUILEVEL_ENDDIALOG;
 911                     if (msi_strprefix(ptr, "-"))
 912                         InstallUILevel |= INSTALLUILEVEL_PROGRESSONLY;
 913                     if (msi_strprefix(ptr, "!"))
 914                     {
 915                         WINE_FIXME("Unhandled modifier: !\n");
 916                         InstallUILevel |= INSTALLUILEVEL_HIDECANCEL;
 917                     }
 918                     ptr++;
 919                 }
 920                         }
 921                         else
 922                         {
 923                                 fprintf(stderr, "Unknown option \"%s\" for UI level\n",
 924                                          wine_dbgstr_w(argvW[i]+2));
 925                         }
 926                 }
 927                 else if(msi_option_equal(argvW[i], "passive"))
 928                 {
 929                     static const WCHAR rebootpromptW[] =
 930                         {'R','E','B','O','O','T','P','R','O','M','P','T','=','"','S','"',0};
 931
 932                     InstallUILevel = INSTALLUILEVEL_BASIC|INSTALLUILEVEL_PROGRESSONLY|INSTALLUILEVEL_HIDECANCEL;
 933                     StringListAppend(&property_list, rebootpromptW);
 934                 }
 935                 else if(msi_option_equal(argvW[i], "y"))
 936                 {
 937                         FunctionDllRegisterServer = TRUE;
 938                         i++;
 939                         if(i >= argc)
 940                                 ShowUsage(1);
 941                         WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i]));
 942                         DllName = argvW[i];
 943                 }
 944                 else if(msi_option_equal(argvW[i], "z"))
 945                 {
 946                         FunctionDllUnregisterServer = TRUE;
 947                         i++;
 948                         if(i >= argc)
 949                                 ShowUsage(1);
 950                         WINE_TRACE("argvW[%d] = %s\n", i, wine_dbgstr_w(argvW[i]));
 951                         DllName = argvW[i];
 952                 }
 953                 else if(msi_option_equal(argvW[i], "help") || msi_option_equal(argvW[i], "?"))
 954                 {
 955                         ShowUsage(0);
 956                 }
 957                 else if(msi_option_equal(argvW[i], "m"))
 958                 {
 959                         FunctionUnknown = TRUE;
 960                         WINE_FIXME("Unknown parameter /m\n");
 961                 }
 962                 else if(msi_option_equal(argvW[i], "D"))
 963                 {
 964                         FunctionUnknown = TRUE;
 965                         WINE_FIXME("Unknown parameter /D\n");
 966                 }
 967                 else if (msi_option_equal(argvW[i], "V"))
 968                 {
 969                     FunctionServer = TRUE;
 970                 }
 971                 else
 972                         StringListAppend(&property_list, argvW[i]);
 973         }
 974
 975         /* start the GUI */
 976         MsiSetInternalUI(InstallUILevel, NULL);
 977
 978         Properties = build_properties( property_list );
 979
 980         if(FunctionInstallAdmin && FunctionPatch)
 981                 FunctionInstall = FALSE;
 982
 983         ReturnCode = 1;
 984         if(FunctionInstall)
 985         {
 986                 if(IsProductCode(PackageName))
 987                         ReturnCode = MsiConfigureProductExW(PackageName, 0, INSTALLSTATE_DEFAULT, Properties);
 988                 else
 989                         ReturnCode = MsiInstallProductW(PackageName, Properties);
 990         }
 991         else if(FunctionRepair)
 992         {
 993                 if(IsProductCode(PackageName))
 994                         WINE_FIXME("Product code treatment not implemented yet\n");
 995                 else
 996                         ReturnCode = MsiReinstallProductW(PackageName, RepairMode);
 997         }
 998         else if(FunctionAdvertise)
 999         {
1000                 LPWSTR Transforms = build_transforms( property_list );
1001                 ReturnCode = MsiAdvertiseProductW(PackageName, (LPWSTR) AdvertiseMode, Transforms, Language);
1002         }
1003         else if(FunctionPatch)
1004         {
1005                 ReturnCode = MsiApplyPatchW(PatchFileName, PackageName, InstallType, Properties);
1006         }
1007         else if(FunctionDllRegisterServer)
1008         {
1009                 ReturnCode = DoDllRegisterServer(DllName);
1010         }
1011         else if(FunctionDllUnregisterServer)
1012         {
1013                 ReturnCode = DoDllUnregisterServer(DllName);
1014         }
1015         else if (FunctionRegServer)
1016         {
1017                 ReturnCode = DoRegServer();
1018         }
1019         else if (FunctionUnregServer)
1020         {
1021                 ReturnCode = DoUnregServer();
1022         }
1023         else if (FunctionServer)
1024         {
1025             ReturnCode = DoService();
1026         }
1027         else if (FunctionUnknown)
1028         {
1029                 WINE_FIXME( "Unknown function, ignoring\n" );
1030         }
1031         else
1032                 ShowUsage(1);
1033
1034         return ReturnCode;
1035 }