src/WINNT/install/loopback/loopbackutils.cpp

   1 /*
   2    Copyright 2004 by the Massachusetts Institute of Technology
   3
   4    All rights reserved.
   5
   6    Permission to use, copy, modify, and distribute this software and its
   7    documentation for any purpose and without fee is hereby granted,
   8    provided that the above copyright notice appear in all copies and that
   9    both that copyright notice and this permission notice appear in
  10    supporting documentation, and that the name of the Massachusetts
  11    Institute of Technology (M.I.T.) not be used in advertising or publicity
  12    pertaining to distribution of the software without specific, written
  13    prior permission.
  14
  15    M.I.T. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  16    ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  17    M.I.T. BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  18    ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  19    WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  20    ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  21    SOFTWARE.
  22 */
  23
  24 #define _WIN32_DCOM
  25 #include <windows.h>
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28
  29 struct Args {
  30         bool bQuiet;
  31         LPWSTR lpIPAddr;
  32         LPWSTR lpSubnetMask;
  33     LPWSTR lpConnectionName;
  34         Args () : bQuiet (0), lpIPAddr (0), lpSubnetMask (0), lpConnectionName (0) { }
  35         ~Args () {
  36                 if (lpIPAddr) free (lpIPAddr);
  37                 if (lpSubnetMask) free (lpSubnetMask);
  38         if (lpConnectionName) free (lpConnectionName);
  39         }
  40 };
  41
  42 #include <shellapi.h>
  43 #define INITGUID
  44 #include <guiddef.h>
  45 #include <devguid.h>
  46 #include <objbase.h>
  47 #include <setupapi.h>
  48 #include <tchar.h>
  49 #include <Msi.h>
  50 #include <Msiquery.h>
  51 #include "loopbackutils.h"
  52
  53 extern "C" DWORD UnInstallLoopBack(void)
  54 {
  55     BOOL ok;
  56     DWORD ret = 0;
  57     GUID netGuid;
  58     HDEVINFO hDeviceInfo = INVALID_HANDLE_VALUE;
  59     SP_DEVINFO_DATA DeviceInfoData;
  60     DWORD index = 0;
  61     BOOL found = FALSE;
  62     DWORD size = 0;
  63
  64     // initialize the structure size
  65     DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
  66
  67     // copy the net class GUID
  68     memcpy(&netGuid, &GUID_DEVCLASS_NET, sizeof(GUID_DEVCLASS_NET));
  69
  70     // return a device info set contains all installed devices of the Net class
  71     hDeviceInfo = SetupDiGetClassDevs(&netGuid, NULL, NULL, DIGCF_PRESENT);
  72
  73     if (hDeviceInfo == INVALID_HANDLE_VALUE)
  74         return GetLastError();
  75
  76     // enumerate the driver info list
  77     while (TRUE)
  78     {
  79         TCHAR * deviceHwid;
  80
  81         ok = SetupDiEnumDeviceInfo(hDeviceInfo, index, &DeviceInfoData);
  82
  83         if(!ok)
  84         {
  85           if(GetLastError() == ERROR_NO_MORE_ITEMS)
  86               break;
  87           else
  88           {
  89               index++;
  90               continue;
  91           }
  92         }
  93
  94         // try to get the DeviceDesc registry property
  95         ok = SetupDiGetDeviceRegistryProperty(hDeviceInfo,
  96                                               &DeviceInfoData,
  97                                               SPDRP_HARDWAREID,
  98                                               NULL,
  99                                               NULL,
 100                                               0,
 101                                               &size);
 102         if (!ok)
 103         {
 104             ret = GetLastError();
 105             if (ret != ERROR_INSUFFICIENT_BUFFER) {
 106                 index++;
 107                 continue;
 108             }
 109
 110             deviceHwid = (TCHAR *)malloc(size);
 111             ok = SetupDiGetDeviceRegistryProperty(hDeviceInfo,
 112                                                   &DeviceInfoData,
 113                                                   SPDRP_HARDWAREID,
 114                                                   NULL,
 115                                                   (PBYTE)deviceHwid,
 116                                                   size,
 117                                                   NULL);
 118             if (!ok) {
 119                 free(deviceHwid);
 120                 deviceHwid = NULL;
 121                 index++;
 122                 continue;
 123             }
 124         } else {
 125             // something is wrong.  This shouldn't have worked with a NULL buffer
 126             ReportMessage(0, "GetDeviceRegistryProperty succeeded with a NULL buffer", NULL,  NULL, 0);
 127             index++;
 128             continue;
 129         }
 130
 131         for (TCHAR *t = deviceHwid; t && *t && t < &deviceHwid[size / sizeof(TCHAR)]; t += _tcslen(t) + 1)
 132         {
 133             if(!_tcsicmp(DRIVERHWID, t)) {
 134                 found = TRUE;
 135                 break;
 136             }
 137         }
 138
 139         if (deviceHwid) {
 140             free(deviceHwid);
 141             deviceHwid = NULL;
 142         }
 143
 144         if (found)
 145             break;
 146
 147         index++;
 148     }
 149
 150     if (found == FALSE)
 151     {
 152         ret = GetLastError();
 153         ReportMessage(0,"Driver does not seem to be installed", DRIVER_DESC, NULL, ret);
 154         goto cleanup;
 155     }
 156
 157     ok = SetupDiSetSelectedDevice(hDeviceInfo, &DeviceInfoData);
 158     if (!ok)
 159     {
 160         ret = GetLastError();
 161         goto cleanup;
 162     }
 163
 164     ok = SetupDiCallClassInstaller(DIF_REMOVE, hDeviceInfo, &DeviceInfoData);
 165     if (!ok)
 166     {
 167         ret = GetLastError();
 168         goto cleanup;
 169     }
 170
 171     ret = 0;
 172
 173 cleanup:
 174     // clean up the device info set
 175     if (hDeviceInfo != INVALID_HANDLE_VALUE)
 176         SetupDiDestroyDeviceInfoList(hDeviceInfo);
 177
 178     return ret;
 179 }
 180
 181 BOOL IsLoopbackInstalled(void)
 182 {
 183     HDEVINFO DeviceInfoSet;
 184     SP_DEVINFO_DATA DeviceInfoData;
 185     DWORD i,err;
 186     BOOL found;
 187
 188     //
 189     // Create a Device Information Set with all present devices.
 190     //
 191     DeviceInfoSet = SetupDiGetClassDevs(NULL, 0, 0, DIGCF_ALLCLASSES | DIGCF_PRESENT ); // All devices present on system
 192     if (DeviceInfoSet == INVALID_HANDLE_VALUE)
 193     {
 194         return FALSE; // nothing installed?
 195     }
 196
 197     //
 198     //  Enumerate through all Devices.
 199     //
 200     found = FALSE;
 201     DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
 202     for (i=0; ;i++)
 203     {
 204         BOOL ok;
 205         DWORD DataT;
 206         TCHAR *p, *buffer = NULL;
 207         DWORD buffersize = 0;
 208
 209         ok = SetupDiEnumDeviceInfo(DeviceInfoSet, i, &DeviceInfoData);
 210
 211         if(!ok) {
 212           if(GetLastError() == ERROR_NO_MORE_ITEMS)
 213             break;
 214           else
 215             continue;
 216         }
 217
 218         //
 219         // We won't know the size of the HardwareID buffer until we call
 220         // this function. So call it with a null to begin with, and then
 221         // use the required buffer size to Alloc the nessicary space.
 222         // Keep calling we have success or an unknown failure.
 223         //
 224         while (!SetupDiGetDeviceRegistryProperty(DeviceInfoSet,
 225                                                  &DeviceInfoData,
 226                                                  SPDRP_HARDWAREID,
 227                                                  &DataT,
 228                                                  (PBYTE)buffer,
 229                                                  buffersize,
 230                                                  &buffersize))
 231         {
 232             if (GetLastError() == ERROR_INVALID_DATA)
 233             {
 234                 // May be a Legacy Device with no hwid. Continue.
 235                 break;
 236             }
 237             else if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
 238             {
 239                 // We need to change the buffer size.
 240                 if (buffer)
 241                     LocalFree(buffer);
 242                 buffer = (TCHAR *)LocalAlloc(LPTR,buffersize);
 243             }
 244             else
 245             {
 246                 if (buffer)
 247                     LocalFree(buffer);
 248                 goto cleanup_DeviceInfo;
 249             }
 250         }
 251
 252         if (GetLastError() == ERROR_INVALID_DATA) {
 253             if (buffer)
 254                 LocalFree(buffer);
 255             continue;
 256         }
 257
 258         // Compare each entry in the buffer multi-sz list with our hwid.
 259         for (p=buffer; *p && (p < &buffer[buffersize]); p += _tcslen(p)+1)
 260         {
 261             if (!_tcsicmp(DRIVERHWID,p))
 262             {
 263                 found = TRUE;
 264                 break;
 265             }
 266         }
 267
 268         if (buffer)
 269             LocalFree(buffer);
 270         if (found)
 271             break;
 272     }
 273
 274     //  Cleanup.
 275 cleanup_DeviceInfo:
 276     err = GetLastError();
 277     SetupDiDestroyDeviceInfoList(DeviceInfoSet);
 278     SetLastError(err);
 279
 280     return found;
 281 }
 282
 283
 284 extern "C" DWORD InstallLoopBack(LPCTSTR pConnectionName, LPCTSTR ip, LPCTSTR mask)
 285 {
 286     BOOL ok;
 287     DWORD ret = 0;
 288     GUID netGuid;
 289     HDEVINFO hDeviceInfo = INVALID_HANDLE_VALUE;
 290     SP_DEVINFO_DATA DeviceInfoData;
 291     SP_DRVINFO_DATA DriverInfoData;
 292     SP_DEVINSTALL_PARAMS  DeviceInstallParams;
 293     TCHAR className[MAX_PATH];
 294     TCHAR temp[MAX_PATH];
 295     DWORD index = 0;
 296     BOOL found = FALSE;
 297     BOOL registered = FALSE;
 298     BOOL destroyList = FALSE;
 299     PSP_DRVINFO_DETAIL_DATA pDriverInfoDetail;
 300     DWORD detailBuf[2048];    // for our purposes, 8k buffer is more
 301                               // than enough to obtain the hardware ID
 302                               // of the loopback driver.
 303
 304     HKEY hkey = NULL;
 305     DWORD cbSize;
 306     DWORD dwValueType;
 307     TCHAR pCfgGuidString[40];
 308
 309     // initialize the structure size
 310     DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
 311     DriverInfoData.cbSize = sizeof(SP_DRVINFO_DATA);
 312
 313     // copy the net class GUID
 314     memcpy(&netGuid, &GUID_DEVCLASS_NET, sizeof(GUID_DEVCLASS_NET));
 315
 316     // create an empty device info set associated with the net class GUID
 317     hDeviceInfo = SetupDiCreateDeviceInfoList(&netGuid, NULL);
 318     if (hDeviceInfo == INVALID_HANDLE_VALUE)
 319         return GetLastError();
 320
 321     // get the class name from GUID
 322     ok = SetupDiClassNameFromGuid(&netGuid, className, MAX_PATH, NULL);
 323     if (!ok)
 324     {
 325         ret = GetLastError();
 326         goto cleanup;
 327     }
 328
 329     // create a device info element and add the new device instance
 330     // key to registry
 331     ok = SetupDiCreateDeviceInfo(hDeviceInfo, className, &netGuid, NULL, NULL,
 332                                  DICD_GENERATE_ID, &DeviceInfoData);
 333     if (!ok)
 334     {
 335         ret = GetLastError();
 336         goto cleanup;
 337     }
 338
 339     // select the newly created device info to be the currently
 340     // selected member
 341     ok = SetupDiSetSelectedDevice(hDeviceInfo, &DeviceInfoData);
 342     if (!ok)
 343     {
 344         ret = GetLastError();
 345         goto cleanup;
 346     }
 347
 348     // build a list of class drivers
 349     ok = SetupDiBuildDriverInfoList(hDeviceInfo, &DeviceInfoData,
 350                                     SPDIT_CLASSDRIVER);
 351     if (!ok)
 352     {
 353         ret = GetLastError();
 354         goto cleanup;
 355     }
 356
 357     destroyList = TRUE;
 358
 359     // enumerate the driver info list
 360     while (TRUE)
 361     {
 362         BOOL ret;
 363
 364         ret = SetupDiEnumDriverInfo(hDeviceInfo, &DeviceInfoData,
 365                                   SPDIT_CLASSDRIVER, index, &DriverInfoData);
 366
 367         // if the function failed and GetLastError() returned
 368         // ERROR_NO_MORE_ITEMS, then we have reached the end of the
 369         // list.  Othewise there was something wrong with this
 370         // particular driver.
 371         if(!ret) {
 372           if(GetLastError() == ERROR_NO_MORE_ITEMS)
 373             break;
 374           else {
 375             index++;
 376             continue;
 377           }
 378         }
 379
 380         pDriverInfoDetail = (PSP_DRVINFO_DETAIL_DATA) detailBuf;
 381         pDriverInfoDetail->cbSize = sizeof(SP_DRVINFO_DETAIL_DATA);
 382
 383         // if we successfully find the hardware ID and it turns out to
 384         // be the one for the loopback driver, then we are done.
 385         if (SetupDiGetDriverInfoDetail(hDeviceInfo,
 386                                       &DeviceInfoData,
 387                                       &DriverInfoData,
 388                                       pDriverInfoDetail,
 389                                       sizeof(detailBuf),
 390                                       NULL)) {
 391             TCHAR * t;
 392
 393             // pDriverInfoDetail->HardwareID is a MULTISZ string.  Go through the
 394             // whole list and see if there is a match somewhere.
 395             t = pDriverInfoDetail->HardwareID;
 396             while (t && *t && t < (TCHAR *) &detailBuf[sizeof(detailBuf)/sizeof(detailBuf[0])]) {
 397               if (!_tcsicmp(t, DRIVERHWID))
 398                 break;
 399
 400               t += _tcslen(t) + 1;
 401             }
 402
 403             if (t && *t && t < (TCHAR *) &detailBuf[sizeof(detailBuf)/sizeof(detailBuf[0])]) {
 404               found = TRUE;
 405               break;
 406             }
 407         }
 408
 409         index++;
 410     }
 411
 412     if (!found)
 413     {
 414         ret = GetLastError();
 415         ReportMessage(0,"Could not find the driver to install", DRIVER_DESC, NULL, 0);
 416         goto cleanup;
 417     }
 418
 419     // set the loopback driver to be the currently selected
 420     ok = SetupDiSetSelectedDriver(hDeviceInfo, &DeviceInfoData,
 421                                   &DriverInfoData);
 422     if (!ok)
 423     {
 424         ret = GetLastError();
 425         goto cleanup;
 426     }
 427
 428     // register the phantom device to repare for install
 429     ok = SetupDiCallClassInstaller(DIF_REGISTERDEVICE, hDeviceInfo,
 430                                    &DeviceInfoData);
 431     if (!ok)
 432     {
 433         ret = GetLastError();
 434         goto cleanup;
 435     }
 436
 437     // registered, but remove if errors occur in the following code
 438     registered = TRUE;
 439
 440     // ask the installer if we can install the device
 441     ok = SetupDiCallClassInstaller(DIF_ALLOW_INSTALL, hDeviceInfo,
 442                                    &DeviceInfoData);
 443     if (!ok)
 444     {
 445         ret = GetLastError();
 446         if (ret != ERROR_DI_DO_DEFAULT)
 447         {
 448             goto cleanup;
 449         }
 450         else
 451             ret = 0;
 452     }
 453
 454     // install the files first
 455     ok = SetupDiCallClassInstaller(DIF_INSTALLDEVICEFILES, hDeviceInfo,
 456                                    &DeviceInfoData);
 457     if (!ok)
 458     {
 459         ret = GetLastError();
 460         goto cleanup;
 461     }
 462
 463     // get the device install parameters and disable filecopy
 464     DeviceInstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS);
 465     ok = SetupDiGetDeviceInstallParams(hDeviceInfo, &DeviceInfoData,
 466                                        &DeviceInstallParams);
 467     if (ok)
 468     {
 469         DeviceInstallParams.Flags |= DI_NOFILECOPY;
 470         ok = SetupDiSetDeviceInstallParams(hDeviceInfo, &DeviceInfoData,
 471                                            &DeviceInstallParams);
 472         if (!ok)
 473         {
 474             ret = GetLastError();
 475             goto cleanup;
 476         }
 477     }
 478
 479     //
 480     // Register any device-specific co-installers for this device,
 481     //
 482
 483     ok = SetupDiCallClassInstaller(DIF_REGISTER_COINSTALLERS,
 484                                    hDeviceInfo,
 485                                    &DeviceInfoData);
 486     if (!ok)
 487     {
 488         ret = GetLastError();
 489         goto cleanup;
 490     }
 491
 492     //
 493     // install any  installer-specified interfaces.
 494     // and then do the real install
 495     //
 496     ok = SetupDiCallClassInstaller(DIF_INSTALLINTERFACES,
 497                                    hDeviceInfo,
 498                                    &DeviceInfoData);
 499     if (!ok)
 500     {
 501         ret = GetLastError();
 502         goto cleanup;
 503     }
 504     PAUSE;
 505     ok = SetupDiCallClassInstaller(DIF_INSTALLDEVICE,
 506                                    hDeviceInfo,
 507                                    &DeviceInfoData);
 508     if (!ok)
 509     {
 510         ret = GetLastError();
 511         PAUSE;
 512         goto cleanup;
 513     }
 514
 515     /* Skip to the end if we aren't setting the name */
 516     if (!pConnectionName) goto cleanup;
 517
 518     // Figure out NetCfgInstanceId
 519     hkey = SetupDiOpenDevRegKey(hDeviceInfo,
 520                                 &DeviceInfoData,
 521                                 DICS_FLAG_GLOBAL,
 522                                 0,
 523                                 DIREG_DRV,
 524                                 KEY_READ);
 525     if (hkey == INVALID_HANDLE_VALUE)
 526     {
 527         ret = GetLastError();
 528         goto cleanup;
 529     }
 530
 531     cbSize = sizeof(pCfgGuidString);
 532     ret = RegQueryValueEx(hkey, _T("NetCfgInstanceId"), NULL,
 533                           &dwValueType, (LPBYTE)pCfgGuidString, &cbSize);
 534     RegCloseKey(hkey);
 535
 536     ret = RenameConnection(pCfgGuidString, pConnectionName);
 537     if (ret)
 538     {
 539         ReportMessage(0,"Could not set the connection name", NULL, pConnectionName, 0);
 540         goto cleanup;
 541     }
 542
 543     if (!ip) goto cleanup;
 544     ret = SetIpAddress(pCfgGuidString, ip, mask);
 545     if (ret)
 546     {
 547         ReportMessage(0,"Could not set the ip address and network mask",NULL,NULL,ret);
 548         goto cleanup;
 549     }
 550     ret = LoopbackBindings(pCfgGuidString);
 551     if (ret)
 552     {
 553         ReportMessage(0,"Could not properly set the bindings",NULL,NULL,0);
 554         goto cleanup;
 555     }
 556     ret = !UpdateHostsFile( pConnectionName, ip, "hosts", FALSE );
 557     if (ret)
 558     {
 559         ReportMessage(0,"Could not update hosts file",NULL,NULL,0);
 560         goto cleanup;
 561     }
 562     ret = !UpdateHostsFile( pConnectionName, ip, "lmhosts", TRUE );
 563     if (ret)
 564     {
 565         ReportMessage(0,"Could not update lmhosts file",NULL,NULL,0);
 566         goto cleanup;
 567     }
 568
 569
 570 cleanup:
 571     // an error has occured, but the device is registered, we must remove it
 572     if (ret != 0 && registered)
 573         SetupDiCallClassInstaller(DIF_REMOVE, hDeviceInfo, &DeviceInfoData);
 574
 575     found = SetupDiDeleteDeviceInfo(hDeviceInfo, &DeviceInfoData);
 576
 577     // destroy the driver info list
 578     if (destroyList)
 579         SetupDiDestroyDriverInfoList(hDeviceInfo, &DeviceInfoData,
 580                                      SPDIT_CLASSDRIVER);
 581     // clean up the device info set
 582     if (hDeviceInfo != INVALID_HANDLE_VALUE)
 583         SetupDiDestroyDeviceInfoList(hDeviceInfo);
 584
 585     return ret;
 586 };
 587
 588 /* The following functions provide the RunDll32 interface
 589  *    RunDll32 loopback_install.dll doLoopBackEntry [Interface Name] [IP address] [Subnet Mask]
 590  */
 591
 592 static void wcsMallocAndCpy (LPWSTR * dst, const LPWSTR src) {
 593         *dst = (LPWSTR) malloc ((wcslen (src) + 1) * sizeof (WCHAR));
 594         wcscpy (*dst, src);
 595 }
 596
 597 static void display_usage()
 598 {
 599     MessageBoxW( NULL,
 600                  L"Installation utility for the MS Loopback Adapter\r\n\r\n"
 601                  L"Usage:\r\n"
 602                  L"RunDll32 loopback_install.dll doLoopBackEntry [q|quiet] [Connection Name] [IP address] [Submask]\r\n",
 603                  L"loopback_install", MB_ICONINFORMATION | MB_OK );
 604 }
 605
 606 static int process_args (LPWSTR lpCmdLine, int skip, Args & args) {
 607         int i, iNumArgs;
 608         LPWSTR * argvW;
 609
 610         argvW = CommandLineToArgvW (lpCmdLine, &iNumArgs);
 611         // Skip over the command name
 612         for (i = skip; i < iNumArgs; i++)
 613         {
 614                 if (wcsstr (argvW[i], L"help")
 615                         || !_wcsicmp (argvW[i], L"?")
 616                         || (wcslen(argvW[i]) == 2 && argvW[i][1] == L'?'))
 617                 {
 618                         display_usage();
 619                         GlobalFree (argvW);
 620                         return 0;
 621                 }
 622
 623                 if (!_wcsicmp (argvW[i], L"q") || !_wcsicmp (argvW[i], L"quiet")) {
 624                         args.bQuiet = true;
 625                         continue;
 626                 }
 627
 628                 if (!args.lpConnectionName) {
 629                         wcsMallocAndCpy (&args.lpConnectionName, argvW[i]);
 630                         continue;
 631                 }
 632
 633                 if (!args.lpIPAddr) {
 634                         wcsMallocAndCpy (&args.lpIPAddr, argvW[i]);
 635                         continue;
 636                 }
 637
 638                 if (!args.lpSubnetMask) {
 639                         wcsMallocAndCpy (&args.lpSubnetMask, argvW[i]);
 640                         continue;
 641                 }
 642
 643                 display_usage();
 644                 GlobalFree (argvW);
 645                 return 0;
 646         }
 647
 648         if (!args.lpConnectionName)
 649                 wcsMallocAndCpy (&args.lpConnectionName, DEFAULT_NAME);
 650         if (!args.lpIPAddr)
 651                 wcsMallocAndCpy (&args.lpIPAddr, DEFAULT_IP);
 652         if (!args.lpSubnetMask)
 653                 wcsMallocAndCpy (&args.lpSubnetMask, DEFAULT_MASK);
 654
 655         GlobalFree (argvW);
 656
 657         return 1;
 658 }
 659
 660 void CALLBACK doLoopBackEntryW (HWND hwnd, HINSTANCE hinst, LPWSTR lpCmdLine, int nCmdShow)
 661 {
 662         Args args;
 663
 664         if (!process_args(lpCmdLine, 0, args))
 665         return;
 666
 667         InstallLoopBack(args.lpConnectionName, args.lpIPAddr, args.lpSubnetMask);
 668 }
 669
 670 void CALLBACK uninstallLoopBackEntryW (HWND hwnd, HINSTANCE hinst, LPWSTR lpCmdLine, int nCmdSHow)
 671 {
 672     Args args;
 673
 674     // initialize COM
 675         // This and CoInitializeSecurity fail when running under the MSI
 676         // engine, but there seems to be no ill effect (the security is now
 677         // set on the specific object via CoSetProxyBlanket in loopback_configure)
 678     if(CoInitializeEx(NULL, COINIT_DISABLE_OLE1DDE | COINIT_APARTMENTTHREADED ))
 679     {
 680                 //Don't fail (MSI install will have already initialized COM)
 681         //EasyErrorBox(0, L"Failed to initialize COM.");
 682         //return 1;
 683     }
 684
 685         // Initialize COM security (otherwise we'll get permission denied when we try to use WMI or NetCfg)
 686     CoInitializeSecurity( NULL, -1, NULL, NULL, RPC_C_AUTHN_LEVEL_DEFAULT, RPC_C_IMP_LEVEL_IMPERSONATE, NULL, EOAC_NONE, NULL);
 687
 688     UnInstallLoopBack();
 689
 690         CoUninitialize();
 691 }
 692
 693 /* And an MSI installer interface */
 694
 695 UINT __stdcall installLoopbackMSI (MSIHANDLE hInstall)
 696 {
 697         LPWSTR szValueBuf;
 698         DWORD cbValueBuf = 256;
 699         Args args;
 700         UINT rc;
 701
 702         SetMsiReporter("InstallLoopback", "Installing loopback adapter", hInstall);
 703
 704     /* check if there is already one installed.  If there is, we shouldn't try to
 705      * install another.
 706      */
 707         if(IsLoopbackInstalled())
 708         return ERROR_SUCCESS;
 709
 710         szValueBuf = (LPWSTR) malloc (cbValueBuf * sizeof (WCHAR));
 711         while (rc = MsiGetPropertyW(hInstall, L"CustomActionData", szValueBuf, &cbValueBuf)) {
 712                 free (szValueBuf);
 713                 if (rc == ERROR_MORE_DATA) {
 714                         cbValueBuf++;
 715                         szValueBuf = (LPWSTR) malloc (cbValueBuf * sizeof (WCHAR));
 716                 }
 717         else
 718             return ERROR_INSTALL_FAILURE;
 719         }
 720
 721         if (!process_args(szValueBuf, 1, args))
 722         return ERROR_INSTALL_FAILURE;
 723
 724         rc = InstallLoopBack (args.lpConnectionName, args.lpIPAddr, args.lpSubnetMask);
 725
 726         if (rc != 2 && rc != 0)
 727         return ERROR_INSTALL_FAILURE;
 728
 729         if (rc == 2) {
 730                 MsiDoActionW (hInstall, L"ScheduleReboot");
 731         }
 732
 733         return ERROR_SUCCESS;
 734 }
 735
 736 UINT __stdcall uninstallLoopbackMSI (MSIHANDLE hInstall)
 737 {
 738         LPWSTR szValueBuf;
 739         DWORD cbValueBuf = 256;
 740         Args args;
 741         UINT rc;
 742
 743         SetMsiReporter("RemoveLoopback", "Removing loopback adapter",  hInstall);
 744
 745         szValueBuf = (LPWSTR) malloc (cbValueBuf * sizeof (WCHAR));
 746         while (rc = MsiGetPropertyW(hInstall, L"CustomActionData", szValueBuf, &cbValueBuf)) {
 747                 free (szValueBuf);
 748                 if (rc == ERROR_MORE_DATA) {
 749                         cbValueBuf++;
 750                         szValueBuf = (LPWSTR) malloc (cbValueBuf * sizeof (WCHAR));
 751                 }
 752         else
 753             return ERROR_INSTALL_FAILURE;
 754         }
 755
 756         if (!process_args(szValueBuf, 1, args))
 757         return ERROR_INSTALL_FAILURE;
 758
 759         rc = UnInstallLoopBack ();
 760
 761         if (rc == 1)
 762         return ERROR_INSTALL_FAILURE;
 763
 764         if (rc == 2) {
 765                 MsiDoActionW (hInstall, L"ScheduleReboot");
 766         }
 767
 768         return ERROR_SUCCESS;
 769 }
 770
 771 DWORD hMsiHandle = 0;
 772 DWORD dwReporterType = REPORT_PRINTF;
 773
 774 extern "C" void ReportMessage(int level, LPCSTR msg, LPCSTR str, LPCWSTR wstr, DWORD dw) {
 775     if(dwReporterType == REPORT_PRINTF)
 776                 printf("%s:[%s][%S][%d]\n", (msg?msg:""), (str?str:""), (wstr?wstr:L""), dw);
 777         else if(dwReporterType == REPORT_MSI && hMsiHandle && level == 0) {
 778                 MSIHANDLE hRec = MsiCreateRecord(5);
 779
 780                 MsiRecordClearData(hRec);
 781                 MsiRecordSetStringA(hRec,1,(msg)?msg:"");
 782                 MsiRecordSetStringA(hRec,2,(str)?str:"");
 783                 MsiRecordSetStringW(hRec,3,(wstr)?wstr:L"");
 784                 MsiRecordSetInteger(hRec,4,dw);
 785
 786                 MsiProcessMessage(hMsiHandle,INSTALLMESSAGE_ACTIONDATA,hRec);
 787
 788                 MsiCloseHandle(hRec);
 789         }
 790 }
 791
 792 extern "C" void SetMsiReporter(LPCSTR strAction, LPCSTR strDesc,DWORD h) {
 793         dwReporterType = REPORT_MSI;
 794         hMsiHandle = h;
 795
 796 #ifdef DONT_NEED
 797     /* this is performed in the Wix installer */
 798         MSIHANDLE hRec = MsiCreateRecord(4);
 799
 800     MsiRecordClearData(hRec);
 801         MsiRecordSetStringA(hRec,1,strAction);
 802         MsiRecordSetStringA(hRec,2,strDesc);
 803         MsiRecordSetStringA(hRec,3,"[1]:([2])([3])([4])");
 804
 805         MsiProcessMessage(h,INSTALLMESSAGE_ACTIONSTART, hRec);
 806
 807     MsiCloseHandle(hRec);
 808 #endif
 809 }