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