开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 系统编程 > 查看源码
install2.c
资源名称：shell.rar　[点击查看]
上传用户：xhy777
上传日期：2007-02-14
资源大小：24088k
文件大小：76k
源码类别：

系统编程

开发平台：

Visual C++

install2.c：源码内容
  1. #include "precomp.h"
  2. #pragma hdrstop
  4. #include <tchar.h>
  5. #include <initguid.h>
  6. #include <devguid.h>
  9. // temporary extern defition from newdev.c
  11. typedef
  12. BOOL
  13. (*PINSTALLNEWDEVICE)(
  14.    HWND hwndParent,
  15.    LPGUID ClassGuid,
  16.    PDWORD Reboot
  17.    );
  20. ULONG PreConfigured;
  21. ULONG KeepEnabled;
  23. BOOL
  24. CALLBACK
  25. AddPropSheetPageProc(
  26.     IN HPROPSHEETPAGE hpage,
  27.     IN LPARAM lParam
  28.    )
  29. {
  30.     *((HPROPSHEETPAGE *)lParam) = hpage;
  31.     return TRUE;
  32. }
  36. #define LEGACY_DETECT 1
  37. #define REPORT_DEVICE 2
  41. /***************************************************************************/
  42. /***************************************************************************/
  43. /**                                                                       **/
  44. /**                      Service Controller stuff                         **/
  45. /**                                                                       **/
  46. /***************************************************************************/
  47. /***************************************************************************/
  52. VOID
  53. DeskSCSetServiceDemandStart(
  54.     LPTSTR ServiceName
  55.     )
  56. {
  57.     SC_HANDLE SCMHandle;
  58.     SC_HANDLE ServiceHandle;
  59.     ULONG     Attempts;
  60.     SC_LOCK   SCLock = NULL;
  62.     ULONG                  ServiceConfigSize = 0;
  63.     LPQUERY_SERVICE_CONFIG ServiceConfig;
  65.     TraceMsg(TF_GENERAL, "DeskSCSetServiceDemandStart for service %ws calledn",
  66.              ServiceName);
  68.     //
  69.     // Pretty stright-forward :
  70.     //
  71.     // Open the service controller
  72.     // Open the service
  73.     // Change the service.
  74.     //
  76.     if (SCMHandle = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS))
  77.     {
  78.         if (ServiceHandle = OpenService(SCMHandle, ServiceName, SERVICE_ALL_ACCESS))
  79.         {
  80.             TraceMsg(TF_GENERAL, "DeskSCSetServiceDemandStart SC Managr handles opendedn");
  82.             QueryServiceConfig(ServiceHandle,
  83.                                NULL,
  84.                                0,
  85.                                &ServiceConfigSize);
  87.             ASSERT(GetLastError() == ERROR_INSUFFICIENT_BUFFER);
  89.             TraceMsg(TF_GENERAL, "DeskSCSetServiceDemandStart buffer size = %dn", ServiceConfigSize);
  91.             if (ServiceConfig = (LPQUERY_SERVICE_CONFIG)
  92.                                  LocalAlloc(LPTR, ServiceConfigSize))
  93.             {
  94.                 if (QueryServiceConfig(ServiceHandle,
  95.                                        ServiceConfig,
  96.                                        ServiceConfigSize,
  97.                                        &ServiceConfigSize))
  98.                 {
  99.                     TraceMsg(TF_GENERAL, "DeskSCSetServiceDemandStart Queried Config infon");
  101.                     //
  102.                     // The service exists.  Check that it's not disabled.
  103.                     //
  105.                     if (ServiceConfig->dwStartType == SERVICE_DISABLED) {
  106.                         ASSERT(FALSE);
  107.                     }
  109.                     //
  110.                     // Attempt to acquite the database lock.
  111.                     //
  113.                     for (Attempts = 20;
  114.                          ((SCLock = LockServiceDatabase(SCMHandle)) == NULL) &&
  115.                              Attempts;
  116.                          Attempts--)
  117.                     {
  118.                         TraceMsg(TF_GENERAL, "Install - Lock SC database lockedn");
  119.                         Sleep(500);
  120.                     }
  122.                     //
  123.                     // Change the service to demand start
  124.                     //
  126.                     if (ChangeServiceConfig(ServiceHandle,
  127.                                             SERVICE_NO_CHANGE,
  128.                                             SERVICE_DEMAND_START,
  129.                                             SERVICE_NO_CHANGE,
  130.                                             NULL,
  131.                                             NULL,
  132.                                             NULL,
  133.                                             NULL,
  134.                                             NULL,
  135.                                             NULL,
  136.                                             NULL))
  137.                     {
  138.                         TraceMsg(TF_GENERAL, "DeskSCSetServiceDemandStart SC manager succeededn");
  139.                     }
  140.                     else
  141.                     {
  142.                         TraceMsg(TF_GENERAL, "DeskSCSetServiceDemandStart SC manager failed : %dn",
  143.                                         GetLastError());
  144.                     }
  146.                     if (SCLock)
  147.                     {
  148.                         TraceMsg(TF_GENERAL, "DeskSCSetServiceDemandStart Unlock databasen");
  149.                         UnlockServiceDatabase(SCLock);
  150.                     }
  151.                 }
  153.                 LocalFree(ServiceConfig);
  154.             }
  157.             CloseServiceHandle(ServiceHandle);
  158.         }
  160.         CloseServiceHandle(SCMHandle);
  161.     }
  163.     TraceMsg(TF_GENERAL, "DeskSCSetServiceDemandStart Leaven");
  164. }
  168. DWORD
  169. DeskSCStartService(
  170.     LPTSTR ServiceName
  171.     )
  172. {
  173.     SC_HANDLE SCMHandle;
  174.     SC_HANDLE ServiceHandle;
  175.     DWORD     dwRet = ERROR_SERVICE_NEVER_STARTED;
  177.     TraceMsg(TF_GENERAL, "DeskSCStartService for service %ws calledn",
  178.              ServiceName);
  180.     //
  181.     // Pretty stright-forward :
  182.     //
  183.     // Open the service controller
  184.     // Open the service
  185.     // Change the service.
  186.     //
  188.     if (SCMHandle = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS))
  189.     {
  190.         if (ServiceHandle = OpenService(SCMHandle, ServiceName, SERVICE_ALL_ACCESS))
  191.         {
  192.             if (StartService(ServiceHandle, 0, NULL))
  193.             {
  194.                 dwRet = NO_ERROR;
  195.             }
  196.             else
  197.             {
  198.                 TraceMsg(TF_GENERAL, " StartService failed %dn", GetLastError());
  199.             }
  201.             CloseServiceHandle(ServiceHandle);
  202.         }
  204.         CloseServiceHandle(SCMHandle);
  205.     }
  207.     TraceMsg(TF_GENERAL, "DeskSCStartService Leave with status %wsn",
  208.              dwRet ? L"ERROR_SERVICE_NEVER_STARTED" : L"NO_ERROR");
  210.     return dwRet;
  211. }
  216. BOOL
  217. DeskSCStopService(
  218.     LPTSTR ServiceName
  219.     )
  220. {
  221.     SC_HANDLE      SCMHandle;
  222.     SC_HANDLE      ServiceHandle;
  223.     BOOL           bRet = FALSE;
  224.     SERVICE_STATUS ServiceStatus;
  226.     TraceMsg(TF_GENERAL, "DeskSCStopService for service %ws calledn",
  227.              ServiceName);
  229.     //
  230.     // Pretty stright-forward :
  231.     //
  232.     // Open the service controller
  233.     // Open the service
  234.     // Change the service.
  235.     //
  237.     if (SCMHandle = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS))
  238.     {
  239.         if (ServiceHandle = OpenService(SCMHandle, ServiceName, SERVICE_ALL_ACCESS))
  240.         {
  241.             if (ControlService(ServiceHandle,
  242.                                SERVICE_CONTROL_STOP,
  243.                                &ServiceStatus))
  244.             {
  245.                 bRet= TRUE;
  246.             }
  247.             else
  248.             {
  249.                 TraceMsg(TF_GENERAL, " StopService failed %dn", GetLastError());
  250.             }
  252.             CloseServiceHandle(ServiceHandle);
  253.         }
  255.         CloseServiceHandle(SCMHandle);
  256.     }
  258.     TraceMsg(TF_GENERAL, "DeskSCStopService Leave with status %wsn",
  259.              bRet ? L"TRUE" : L"FALSE");
  261.     return bRet;
  262. }
  267. BOOL
  268. DeskSCDeleteService(
  269.     LPTSTR ServiceName
  270.     )
  271. {
  272.     SC_HANDLE      SCMHandle;
  273.     SC_HANDLE      ServiceHandle;
  274.     BOOL           bRet = FALSE;
  276.     TraceMsg(TF_GENERAL, "DeskSCDeleteService for service %ws calledn",
  277.              ServiceName);
  279.     //
  280.     // Pretty stright-forward :
  281.     //
  282.     // Open the service controller
  283.     // Open the service
  284.     // Change the service.
  285.     //
  287.     if (SCMHandle = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS))
  288.     {
  289.         if (ServiceHandle = OpenService(SCMHandle, ServiceName, SERVICE_ALL_ACCESS))
  290.         {
  291.             if (DeleteService(ServiceHandle))
  292.             {
  293.                 bRet= TRUE;
  294.             }
  295.             else
  296.             {
  297.                 TraceMsg(TF_GENERAL, "DeleteService failed %dn", GetLastError());
  298.             }
  300.             CloseServiceHandle(ServiceHandle);
  301.         }
  303.         CloseServiceHandle(SCMHandle);
  304.     }
  306.     TraceMsg(TF_GENERAL, "DeskSCDeleteService Leave with status %wsn",
  307.              bRet ? L"TRUE" : L"FALSE");
  309.     return bRet;
  310. }
  315. /***************************************************************************/
  316. /***************************************************************************/
  317. /**                                                                       **/
  318. /**                      Service Installation                             **/
  319. /**                                                                       **/
  320. /***************************************************************************/
  321. /***************************************************************************/
  324. BOOL
  325. DeskIsPnPDriver(
  326.     IN HDEVINFO         hDevInfo,
  327.     IN PSP_DEVINFO_DATA pDeviceInfoData OPTIONAL
  328.     )
  329. {
  330.     SP_DRVINFO_DATA        DriverInfoData;
  331.     SP_DRVINFO_DETAIL_DATA DriverInfoDetailData;
  332.     DWORD                  cbOutputSize = 0;
  333.     HANDLE                 InfFileHandle;
  334.     DWORD                  PnPDriver = 0;
  335.     TCHAR                  szSoftwareSection[LINE_LEN];
  336.     INFCONTEXT             tmpContext;
  338.     TraceMsg(TF_GENERAL, "DeskIsPnPDrivern");
  340.     //
  341.     // Retrieve information about the driver node selected for this device.
  342.     //
  344.     DriverInfoData.cbSize = sizeof(SP_DRVINFO_DATA);
  346.     if (!SetupDiGetSelectedDriver(hDevInfo,
  347.                                   pDeviceInfoData,
  348.                                   &DriverInfoData))
  349.     {
  350.         TraceMsg(TF_GENERAL, "SetupDiGetSelectedDriver Error %dn", GetLastError());
  351.         return GetLastError();
  352.     }
  354.     DriverInfoDetailData.cbSize = sizeof(SP_DRVINFO_DETAIL_DATA);
  356.     if (!(SetupDiGetDriverInfoDetail(hDevInfo,
  357.                                      pDeviceInfoData,
  358.                                      &DriverInfoData,
  359.                                      &DriverInfoDetailData,
  360.                                      DriverInfoDetailData.cbSize,
  361.                                      &cbOutputSize)) &&
  362.         (GetLastError() != ERROR_INSUFFICIENT_BUFFER))
  363.     {
  364.         TraceMsg(TF_GENERAL, "SetupDiGetDriverInfoDetail Error %dn", GetLastError());
  365.         return GetLastError();
  366.     }
  369.     //
  370.     // open the inf so we can run the sections in the inf, more or less
  371.     // manually.
  372.     //
  374.     InfFileHandle = SetupOpenInfFile(DriverInfoDetailData.InfFileName,
  375.                                      NULL,
  376.                                      INF_STYLE_WIN4,
  377.                                      NULL);
  379.     if (InfFileHandle == INVALID_HANDLE_VALUE)
  380.     {
  381.         TraceMsg(TF_GENERAL, "SetupOpenInfFile Error %dn", INVALID_HANDLE_VALUE);
  382.         return ERROR_INVALID_PARAMETER;
  383.     }
  386.     //
  387.     // Get any interesting configuration data for the inf file.
  388.     //
  390.     wsprintf(szSoftwareSection,
  391.              TEXT("%ws.GeneralConfigData"),
  392.              DriverInfoDetailData.SectionName);
  395.     if (SetupFindFirstLine(InfFileHandle,
  396.                            szSoftwareSection,
  397.                            TEXT("PnPEnabled"),
  398.                            &tmpContext))
  399.     {
  400.         SetupGetIntField(&tmpContext,
  401.                          1,
  402.                          &PnPDriver);
  403.     }
  405.     TraceMsg(TF_GENERAL, "DeskIsPnPDriver returns %dn", (PnPDriver != 0));
  407.     return (PnPDriver != 0);
  408. }
  413. DWORD
  414. DeskInstallServiceExtensions(
  415.     IN HWND                    hwnd,
  416.     IN HDEVINFO                hDevInfo,
  417.     IN PSP_DEVINFO_DATA        pDeviceInfoData,
  418.     IN PSP_DRVINFO_DATA        DriverInfoData,
  419.     IN PSP_DRVINFO_DETAIL_DATA DriverInfoDetailData,
  420.     IN LPTSTR                  pServiceName,
  421.     IN DWORD                   dwDetect
  422.     )
  423. {
  424.     DWORD retError = NO_ERROR;
  426.     HINF       InfFileHandle;
  427.     PVOID      Context;
  428.     INFCONTEXT tmpContext;
  430.     TCHAR szSoftwareSection[LINE_LEN];
  432.     ULONG maxmem;
  433.     ULONG numDev;
  434.     ULONG PnPDriver;
  435.     SP_DEVINSTALL_PARAMS   DeviceInstallParams;
  437.     TCHAR keyName[LINE_LEN];
  438.     DWORD disposition;
  439.     HKEY  hkey;
  440.     BOOL  bSetSoftwareKey;
  442.     TraceMsg(TF_GENERAL, "DeskInstallServiceExtensions calledn");
  444.     //
  445.     // open the inf so we can run the sections in the inf, more or less
  446.     // manually.
  447.     //
  449.     InfFileHandle = SetupOpenInfFile(DriverInfoDetailData->InfFileName,
  450.                                      NULL,
  451.                                      INF_STYLE_WIN4,
  452.                                      NULL);
  454.     if (InfFileHandle == INVALID_HANDLE_VALUE)
  455.     {
  456.         TraceMsg(TF_GENERAL, "SetupOpenInfFile Error %dn", INVALID_HANDLE_VALUE);
  457.         return ERROR_INVALID_PARAMETER;
  458.     }
  461.     //
  462.     // Get any interesting configuration data for the inf file.
  463.     //
  465.     maxmem = 8;
  466.     numDev = 1;
  467.     PreConfigured = 0;
  468.     KeepEnabled = 0;
  469.     PnPDriver = 0;
  471.     wsprintf(szSoftwareSection,
  472.              TEXT("%ws.GeneralConfigData"),
  473.              DriverInfoDetailData->SectionName);
  475.     if (SetupFindFirstLine(InfFileHandle,
  476.                            szSoftwareSection,
  477.                            TEXT("MaximumNumberOfDevices"),
  478.                            &tmpContext))
  479.     {
  480.         SetupGetIntField(&tmpContext,
  481.                          1,
  482.                          &numDev);
  483.     }
  485.     if (SetupFindFirstLine(InfFileHandle,
  486.                            szSoftwareSection,
  487.                            TEXT("MaximumDeviceMemoryConfiguration"),
  488.                            &tmpContext))
  489.     {
  490.         SetupGetIntField(&tmpContext,
  491.                          1,
  492.                          &maxmem);
  493.     }
  495.     if (SetupFindFirstLine(InfFileHandle,
  496.                            szSoftwareSection,
  497.                            TEXT("PreConfiguredSettings"),
  498.                            &tmpContext))
  499.     {
  500.         SetupGetIntField(&tmpContext,
  501.                          1,
  502.                          &PreConfigured);
  503.     }
  505.     if (SetupFindFirstLine(InfFileHandle,
  506.                            szSoftwareSection,
  507.                            TEXT("KeepExistingDriverEnabled"),
  508.                            &tmpContext))
  509.     {
  510.         SetupGetIntField(&tmpContext,
  511.                          1,
  512.                          &KeepEnabled);
  513.     }
  515.     if (SetupFindFirstLine(InfFileHandle,
  516.                            szSoftwareSection,
  517.                            TEXT("PnPEnabled"),
  518.                            &tmpContext))
  519.     {
  520.         SetupGetIntField(&tmpContext,
  521.                          1,
  522.                          &PnPDriver);
  523.     }
  526.     //
  527.     // Write the PnP and Detect configuration information to the registry.
  528.     //
  530.     wsprintf(keyName,
  531.              TEXT("System\CurrentControlSet\Services\%ws"),
  532.              pServiceName, numDev);
  534.     if (RegCreateKeyEx(HKEY_LOCAL_MACHINE,
  535.                        keyName,
  536.                        0,
  537.                        NULL,
  538.                        REG_OPTION_NON_VOLATILE,
  539.                        KEY_READ | KEY_WRITE,
  540.                        NULL,
  541.                        &hkey,
  542.                        &disposition) == ERROR_SUCCESS)
  543.     {
  544.         ULONG Value = 1;
  546.         if (PnPDriver)
  547.         {
  548.             RegSetValueEx(hkey,
  549.                           TEXT("PnPEnabled"),
  550.                           0,
  551.                           REG_DWORD,
  552.                           (LPBYTE) (&Value),
  553.                           SIZEOF(ULONG) );
  554.         }
  556.         if (dwDetect == LEGACY_DETECT)
  557.         {
  558.             RegSetValueEx(hkey,
  559.                           TEXT("LegacyDetect"),
  560.                           0,
  561.                           REG_DWORD,
  562.                           (LPBYTE) (&Value),
  563.                           SIZEOF(ULONG) );
  564.         }
  565.         else if (dwDetect == REPORT_DEVICE)
  566.         {
  567.             RegSetValueEx(hkey,
  568.                           TEXT("ReportDevice"),
  569.                           0,
  570.                           REG_DWORD,
  571.                           (LPBYTE) (&Value),
  572.                           SIZEOF(ULONG) );
  573.         }
  575.         RegCloseKey(hkey);
  576.     }
  578.     //
  579.     // Increase the number of system PTEs if we have cards that will need
  580.     // more than 10 MEG of PTEs
  581.     //
  583.     if ((maxmem = maxmem * numDev) > 10)
  584.     {
  585.         //
  586.         // we need 1K PTEs to support 1 MEG
  587.         // Then add 50% for other devices this type of machine may have.
  588.         //
  589.         // NOTE - in the future, we may want to be smarter and try
  590.         // to merge with whatever someone else put in there.
  591.         //
  593.         maxmem *= 0x400 * 3/2;
  595.         if (RegCreateKeyEx(HKEY_LOCAL_MACHINE,
  596.                            TEXT("System\CurrentControlSet\Control\Session Manager\Memory Management"),
  597.                            0,
  598.                            NULL,
  599.                            REG_OPTION_NON_VOLATILE,
  600.                            KEY_READ | KEY_WRITE,
  601.                            NULL,
  602.                            &hkey,
  603.                            &disposition) == ERROR_SUCCESS)
  604.         {
  605.             //
  606.             // Check if we walready set maxmem in the registry.
  607.             //
  609.             DWORD data;
  610.             DWORD cb = sizeof(data);
  612.             if ( (RegQueryValueEx(hkey,
  613.                                   TEXT("SystemPages"),
  614.                                   NULL,
  615.                                   NULL,
  616.                                   (LPBYTE)(&data),
  617.                                   &cb) != ERROR_SUCCESS) ||
  618.                  (data < maxmem) )
  619.             {
  620.                 //
  621.                 // Set the new value
  622.                 //
  624.                 RegSetValueEx(hkey,
  625.                               TEXT("SystemPages"),
  626.                               0,
  627.                               REG_DWORD,
  628.                               (LPBYTE) &maxmem,
  629.                               sizeof(DWORD));
  631.                 //
  632.                 // Tell the system we must reboot before running this driver.
  633.                 //
  635.                 ZeroMemory(&DeviceInstallParams, sizeof(DeviceInstallParams));
  636.                 DeviceInstallParams.cbSize = sizeof(DeviceInstallParams);
  638.                 SetupDiGetDeviceInstallParams(hDevInfo,
  639.                                               pDeviceInfoData,
  640.                                               &DeviceInstallParams);
  642.                 DeviceInstallParams.Flags |= DI_NEEDREBOOT;
  644.                 SetupDiSetDeviceInstallParams(hDevInfo,
  645.                                               pDeviceInfoData,
  646.                                               &DeviceInstallParams);
  647.             }
  649.             RegCloseKey(hkey);
  650.         }
  652.     }
  654.     //
  655.     // We may have to do this for multiple adapters at this point.
  656.     // So loop throught the number of devices, which has 1 as the default
  657.     // value
  658.     //
  660.     //
  661.     // Initialize the default callback so that the MsgHandler works
  662.     // properly
  663.     //
  665.     Context = SetupInitDefaultQueueCallback(hwnd);
  667.     bSetSoftwareKey = TRUE;
  669.     do {
  671.         if (PnPDriver && bSetSoftwareKey)
  672.         {
  673.             HKEY hkeyTmp;
  675.             hkey = INVALID_HANDLE_VALUE;
  677.             //
  678.             // For PnP, install the display driver under the software key
  679.             //
  681.             hkeyTmp = SetupDiOpenDevRegKey(hDevInfo,
  682.                                            pDeviceInfoData,
  683.                                            DICS_FLAG_GLOBAL,
  684.                                            0,
  685.                                            DIREG_DRV,
  686.                                            KEY_READ | KEY_WRITE);
  688.             if (hkeyTmp != INVALID_HANDLE_VALUE)
  689.             {
  690.                 RegCreateKeyEx(hkeyTmp,
  691.                                TEXT("Settings"),
  692.                                0,
  693.                                NULL,
  694.                                REG_OPTION_NON_VOLATILE,
  695.                                KEY_READ | KEY_WRITE,
  696.                                NULL,
  697.                                &hkey,
  698.                                &disposition);
  700.                 RegCloseKey(hkeyTmp);
  701.             }
  702.         }
  703.         else
  704.         {
  705.             numDev -= 1;
  707.             //
  708.             // For all drivers, install the information under DeviceX
  709.             // We do this for legacy purposes since many drivers rely on
  710.             // information written to this key.
  711.             //
  713.             wsprintf(keyName,
  714.                      TEXT("System\CurrentControlSet\Services\%ws\Device%d"),
  715.                      pServiceName, numDev);
  717.             RegCreateKeyEx(HKEY_LOCAL_MACHINE,
  718.                            keyName,
  719.                            0,
  720.                            NULL,
  721.                            REG_OPTION_NON_VOLATILE,
  722.                            KEY_READ | KEY_WRITE,
  723.                            NULL,
  724.                            &hkey,
  725.                            &disposition);
  726.         }
  728.         if (hkey != INVALID_HANDLE_VALUE)
  729.         {
  730.             wsprintf(szSoftwareSection,
  731.                      TEXT("%ws.SoftwareSettings"),
  732.                      DriverInfoDetailData->SectionName);
  734.             if (!SetupInstallFromInfSection(hwnd,
  735.                                             InfFileHandle,
  736.                                             szSoftwareSection,
  737.                                             SPINST_REGISTRY,
  738.                                             hkey,
  739.                                             NULL,
  740.                                             0,
  741.                                             &SetupDefaultQueueCallback,
  742.                                             Context,
  743.                                             NULL,
  744.                                             NULL))
  745.             {
  746.                 TraceMsg(TF_GENERAL, "SetupInstallFromInfSection Error %dn", INVALID_HANDLE_VALUE);
  747.                 return ERROR_INVALID_PARAMETER;
  748.             }
  750.             //
  751.             // Write the description of the device if we are not detecting
  752.             //
  753.             // Only do this for legacy installation at this point.
  754.             //
  756.             if ((PnPDriver && bSetSoftwareKey) == FALSE)
  757.             {
  758.                 RegSetValueEx(hkey,
  759.                               TEXT("Device Description"),
  760.                               0,
  761.                               REG_SZ,
  762.                               (LPBYTE) DriverInfoDetailData->DrvDescription,
  763.                               (lstrlen(DriverInfoDetailData->DrvDescription) + 1) *
  764.                                    sizeof(TCHAR) );
  765.             }
  766. #if 0
  767.             //
  768.             // Invoke the resource picker for adapters that need it.
  769.             //
  771.             {
  772.                 LOG_CONF LogConfig;
  773.                 RES_DES ResDes;
  774.                 HMODULE hModule;
  775.                 FARPROC PropSheetExtProc;
  777.                 if (CM_Get_First_Log_Conf(&LogConfig,
  778.                                           pDeviceInfoData->DevInst,
  779.                                           BASIC_LOG_CONF) == CR_SUCCESS)
  780.                 {
  781.                     //
  782.                     // This device instance has a basic log config, so we want to
  783.                     // give the user a resource selection dialog.
  784.                     // (before we do that, go ahead and free the log config
  785.                     // handle--we don't need it.)
  786.                     //
  788.                     CM_Free_Log_Conf_Handle(LogConfig);
  790.                     if ((hModule = GetModuleHandle(TEXT("setupapi.dll"))) &&
  791.                         (PropSheetExtProc = GetProcAddress(hModule,
  792.                                                            "ExtensionPropSheetPageProc")))
  793.                     {
  794.                         SP_PROPSHEETPAGE_REQUEST PropSheetRequest;
  795.                         HPROPSHEETPAGE    hPage = {0};
  796.                         PROPSHEETPAGE     PropPage;
  797.                         PROPSHEETHEADER   PropHeader;
  799.                         PropSheetRequest.cbSize = sizeof(SP_PROPSHEETPAGE_REQUEST);
  800.                         PropSheetRequest.PageRequested = SPPSR_SELECT_DEVICE_RESOURCES;
  801.                         PropSheetRequest.DeviceInfoSet = hDevInfo;
  802.                         PropSheetRequest.pDeviceInfoData = pDeviceInfoData;
  804.                         //
  805.                         // Try to get the property sheet extension from setupapi.
  806.                         //
  808.                         if (PropSheetExtProc(&PropSheetRequest,
  809.                                              AddPropSheetPageProc,
  810.                                              &hPage))
  811.                         {
  813.                             PropHeader.dwSize      = sizeof(PROPSHEETHEADER);
  814.                             PropHeader.dwFlags     = PSH_NOAPPLYNOW;
  815.                             PropHeader.hwndParent  = hwnd;
  816.                             PropHeader.hInstance   = ghmod;
  817.                             PropHeader.pszIcon     = NULL;
  818.                             PropHeader.pszCaption  = TEXT(" ");
  819.                             PropHeader.nPages      = 1;
  820.                             PropHeader.phpage      = &hPage;
  821.                             PropHeader.nStartPage  = 0;
  822.                             PropHeader.pfnCallback = NULL;
  824.                             if (PropertySheet(&PropHeader) == -1)
  825.                             {
  826.                                 if(hPage)
  827.                                 {
  828.                                     DestroyPropertySheetPage(hPage);
  829.                                 }
  830.                             }
  831.                             else
  832.                             {
  833.                                 //
  834.                                 // BUGBUG can this return zero ?
  835.                                 //
  837.                                 //
  838.                                 // If we were successful, then we want to retrieve the user's selection.
  839.                                 //
  841.                                 CM_Get_First_Log_Conf(&LogConfig,
  842.                                                       pDeviceInfoData->DevInst,
  843.                                                       FORCED_LOG_CONF);
  845.                                 ResDes = LogConfig;
  847.                                 // while(
  849.                                 if (CM_Get_Next_Res_Des(&ResDes,
  850.                                                         ResDes,
  851.                                                         ResType_Mem,
  852.                                                         NULL,
  853.                                                         0) == CR_SUCCESS)
  854.                                 {
  855.                                     MEM_RESOURCE memRes;
  857.                                     if (CM_Get_Res_Des_Data(ResDes,
  858.                                                             &memRes,
  859.                                                             sizeof(memRes),
  860.                                                             0) == CR_SUCCESS)
  861.                                     {
  862.                                         RegSetValueEx(hkey,
  863.                                                       TEXT("MemBase"),
  864.                                                       0,
  865.                                                       REG_DWORD,
  866.                                                       (LPBYTE) &(memRes.MEM_Header.MD_Alloc_Base),
  867.                                                       sizeof(DWORD));
  868.                                     }
  870.                                     CM_Free_Res_Des_Handle(ResDes); // resdesnext
  871.                                 }
  872.                             }
  873.                         }
  874.                     }
  875.                 }
  876.             }
  877. #endif
  879.             RegCloseKey(hkey);
  880.         }
  882.         bSetSoftwareKey = FALSE;
  884.     } while (numDev != 0);
  886.     //
  887.     // optinally run the OpenGl section in the inf.
  888.     // Ignore any errors at this point since this is an optional
  889.     // entry.
  890.     //
  892.     if (RegCreateKeyEx(HKEY_LOCAL_MACHINE,
  893.                        TEXT("SOFTWARE\Microsoft\Windows NT\CurrentVersion\OpenGLDrivers"),
  894.                        0,
  895.                        NULL,
  896.                        REG_OPTION_NON_VOLATILE,
  897.                        KEY_READ | KEY_WRITE,
  898.                        NULL,
  899.                        &hkey,
  900.                        &disposition) == ERROR_SUCCESS)
  901.     {
  902.         wsprintf(szSoftwareSection,
  903.                  TEXT("%ws.OpenGLSoftwareSettings"),
  904.                  DriverInfoDetailData->SectionName);
  906.         SetupInstallFromInfSection(hwnd,
  907.                                    InfFileHandle,
  908.                                    szSoftwareSection,
  909.                                    SPINST_REGISTRY,
  910.                                    hkey,
  911.                                    NULL,
  912.                                    0,
  913.                                    &SetupDefaultQueueCallback,
  914.                                    Context,
  915.                                    NULL,
  916.                                    NULL);
  918.         RegCloseKey(hkey);
  919.     }
  921.     //
  922.     // Get the next line for detection if we are detecting.
  923.     //
  925.     SetupCloseInfFile(InfFileHandle);
  927.     TraceMsg(TF_GENERAL, "DeskInstallServiceExtensions return %dn", retError);
  929.     return retError;
  930. }
  936. DWORD
  937. DeskInstallService(
  938.     IN HDEVINFO         hDevInfo,
  939.     IN PSP_DEVINFO_DATA pDeviceInfoData OPTIONAL,
  940.     IN LPTSTR           pServiceName,
  941.     IN DWORD            dwDetect
  942.     )
  943. {
  944.     SP_DEVINSTALL_PARAMS   DeviceInstallParams;
  945.     SP_DRVINFO_DATA        DriverInfoData;
  946.     SP_DRVINFO_DETAIL_DATA DriverInfoDetailData;
  947.     DWORD                  cbOutputSize;
  948.     HINF                   hInf;
  949.     TCHAR                  ActualInfSection[LINE_LEN];
  950.     INFCONTEXT             infContext;
  951.     DWORD                  status = NO_ERROR;
  953.     TraceMsg(TF_GENERAL, "DeskInstallService calledn");
  956.     //
  957.     // Get the params so we can get the window handle.
  958.     //
  960.     DeviceInstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS);
  962.     SetupDiGetDeviceInstallParams(hDevInfo,
  963.                                   pDeviceInfoData,
  964.                                   &DeviceInstallParams);
  966.     //
  967.     // Retrieve information about the driver node selected for this device.
  968.     //
  970.     DriverInfoData.cbSize = sizeof(SP_DRVINFO_DATA);
  972.     if (!SetupDiGetSelectedDriver(hDevInfo,
  973.                                   pDeviceInfoData,
  974.                                   &DriverInfoData))
  975.     {
  976.         TraceMsg(TF_GENERAL, "SetupDiGetSelectedDriver Error %dn", GetLastError());
  977.         return GetLastError();
  978.     }
  980.     DriverInfoDetailData.cbSize = sizeof(SP_DRVINFO_DETAIL_DATA);
  982.     if (!(SetupDiGetDriverInfoDetail(hDevInfo,
  983.                                      pDeviceInfoData,
  984.                                      &DriverInfoData,
  985.                                      &DriverInfoDetailData,
  986.                                      DriverInfoDetailData.cbSize,
  987.                                      &cbOutputSize)) &&
  988.         (GetLastError() != ERROR_INSUFFICIENT_BUFFER))
  989.     {
  990.         TraceMsg(TF_GENERAL, "SetupDiGetDriverInfoDetail Error %dn", GetLastError());
  991.         return GetLastError();
  992.     }
  994.     //
  995.     // Open the INF that installs this driver node, so we can 'pre-run' the
  996.     // AddService/DelService entries in its install service install section.
  997.     //
  999.     hInf = SetupOpenInfFile(DriverInfoDetailData.InfFileName,
  1000.                             NULL,
  1001.                             INF_STYLE_WIN4,
  1002.                             NULL);
  1004.     if(hInf == INVALID_HANDLE_VALUE)
  1005.     {
  1006.         //
  1007.         // For some reason we couldn't open the INF--this should never happen.
  1008.         //
  1010.         TraceMsg(TF_GENERAL, "SetupOpenInfFile Errorn");
  1011.         return ERROR_INVALID_HANDLE;
  1012.     }
  1014.     //
  1015.     // Now find the actual (potentially OS/platform-specific) install section name.
  1016.     //
  1018.     if (!SetupDiGetActualSectionToInstall(hInf,
  1019.                                           DriverInfoDetailData.SectionName,
  1020.                                           ActualInfSection,
  1021.                                           sizeof(ActualInfSection) / sizeof(TCHAR),
  1022.                                           NULL,
  1023.                                           NULL))
  1024.     {
  1025.         status = GetLastError();
  1026.         TraceMsg(TF_GENERAL, "SetupDiGetActualSectionToInstall Error %dn", status);
  1027.     }
  1028.     else
  1029.     {
  1030.         //
  1031.         // Append a ".Services" to get the service install section name.
  1032.         //
  1034.         lstrcat(ActualInfSection, TEXT(".Services"));
  1036.         //
  1037.         // Now run the service modification entries in this section...
  1038.         //
  1040.         if (!SetupInstallServicesFromInfSection(hInf,
  1041.                                                 ActualInfSection,
  1042.                                                 0))
  1043.         {
  1044.             status = GetLastError();
  1045.             TraceMsg(TF_GENERAL, "SetupInstallServicesFromInfSection Error %dn", status);
  1046.         }
  1047.     }
  1049.     //
  1050.     // Get the service Name if needed (detection)
  1051.     //
  1053.     if (SetupFindFirstLine(hInf,
  1054.                            ActualInfSection,
  1055.                            TEXT("AddService"),
  1056.                            &infContext))
  1057.     {
  1058.         SetupGetStringField(&infContext,
  1059.                             1,
  1060.                             pServiceName,
  1061.                             LINE_LEN,
  1062.                             NULL);
  1063.     }
  1066.     SetupCloseInfFile(hInf);
  1068.     if (status != NO_ERROR)
  1069.     {
  1070.         return status;
  1071.     }
  1073.     //
  1074.     // Now that the basic install has been performed (wihtout starting the
  1075.     // device), write the extra data to the registry.
  1076.     //
  1078.     status = DeskInstallServiceExtensions(DeviceInstallParams.hwndParent,
  1079.                                           hDevInfo,
  1080.                                           pDeviceInfoData,
  1081.                                           &DriverInfoData,
  1082.                                           &DriverInfoDetailData,
  1083.                                           pServiceName,
  1084.                                           dwDetect);
  1086.     if (status != NO_ERROR)
  1087.     {
  1088.         TraceMsg(TF_GENERAL, "DeskInstallServiceExtensions Error %dn", status);
  1089.         return status;
  1090.     }
  1092.     if (dwDetect == 0)
  1093.     {
  1094.         //
  1095.         // We have a DEVNODE and therefore a pDeviceInfoData.
  1096.         // Do the full device install, which will also start the device
  1097.         // dynamically.
  1098.         //
  1100.         if (!SetupDiInstallDevice(hDevInfo, pDeviceInfoData))
  1101.         {
  1102.             TraceMsg(TF_GENERAL, "SetupDiInstallDevice Error %dn", GetLastError());
  1104.             //
  1105.             // Remove the device !??
  1106.             //
  1108.             return GetLastError();
  1109.         }
  1110.         else
  1111.         {
  1112.             //
  1113.             // For a PnP Device which will never do detection, we want to mark
  1114.             // the device as DemandStart.
  1115.             //
  1117.             DeskSCSetServiceDemandStart(pServiceName);
  1118.         }
  1119.     }
  1121.     //
  1122.     // If some of the flags (like paged pool) needed to be changed,
  1123.     // let's ask for a reboot right now.
  1124.     //
  1125.     // Otherwise, we can actually try to start the device at this point.
  1126.     //
  1128.     TraceMsg(TF_GENERAL, "DeskInstallService return 0n");
  1130.     return NO_ERROR;
  1131. }
  1136. DWORD
  1137. DeskRemoveService(
  1138.     IN HDEVINFO         hDevInfo,
  1139.     IN PSP_DEVINFO_DATA pDeviceInfoData OPTIONAL,
  1140.     IN LPTSTR           pServiceName
  1141.     )
  1142. {
  1143.     CONFIGRET  crStatus = CR_FAILURE;
  1144.     ULONG      DevIdBufferLen;
  1145.     LPTSTR     DevIdBuffer;
  1146.     LPTSTR     pTmp;
  1148.     TraceMsg(TF_GENERAL, "DeskRemoveService calledn");
  1150.     //
  1151.     // Remove the service
  1152.     //
  1154.     //
  1155.     // Check if any devices are controlled by this service.
  1156.     //
  1158.     CM_Get_Device_ID_List_Size(&DevIdBufferLen,
  1159.                                pServiceName,
  1160.                                CM_GETIDLIST_FILTER_SERVICE);
  1162.     if ( (DevIdBufferLen) &&
  1163.          (DevIdBuffer = LocalAlloc(LPTR, DevIdBufferLen * sizeof(TCHAR))))
  1164.     {
  1166.         crStatus = CM_Get_Device_ID_List(pServiceName,
  1167.                                          DevIdBuffer,
  1168.                                          DevIdBufferLen,
  1169.                                          CM_GETIDLIST_FILTER_SERVICE);
  1170.     }
  1172.     if (crStatus == CR_SUCCESS)
  1173.     {
  1174.         pTmp = DevIdBuffer;
  1176.         //
  1177.         // Walk the MULTI_SZ with the devices in it.
  1178.         //
  1180.         while (*pTmp)
  1181.         {
  1182.             DEVINST DevInst;
  1184.             // ASSERT(wcsstr(TEXT("_DETECT"), pTmp));
  1186.             crStatus =
  1187.                 CM_Locate_DevNode(&DevInst,
  1188.                                   pTmp,
  1189.                                   CM_LOCATE_DEVNODE_NORMAL | CM_LOCATE_DEVNODE_PHANTOM);
  1191.             if (crStatus != CR_SUCCESS)
  1192.             {
  1193.                 TraceMsg(TF_GENERAL, " CM_Locate_DevNode %ws failed %dn",
  1194.                          pTmp, crStatus);
  1195.                 continue;
  1196.             }
  1198.             //
  1199.             // LATER : Make sure we only delete legacy devnodes.
  1200.             //
  1202.             crStatus = CM_Uninstall_DevNode(DevInst, 0);
  1204.             if (crStatus != CR_SUCCESS)
  1205.             {
  1206.                 TraceMsg(TF_GENERAL, " CM_Locate_DevNode %ws failed %dn",
  1207.                          pTmp, crStatus);
  1208.                 continue;
  1209.             }
  1211.             TraceMsg(TF_GENERAL, "Deleted device %wsn", pTmp);
  1213.             //
  1214.             // Next string in the MULTI_SZ
  1215.             //
  1217.             while (*pTmp++);
  1218.         }
  1220.         DeskSCDeleteService(pServiceName);
  1221.     }
  1223.     TraceMsg(TF_GENERAL, "DeskRemoveService return 0n");
  1225.     return NO_ERROR;
  1226. }
  1229. /***************************************************************************/
  1230. /***************************************************************************/
  1231. /**                                                                       **/
  1232. /**                              Detection                                **/
  1233. /**                                                                       **/
  1234. /***************************************************************************/
  1235. /***************************************************************************/
  1239. DWORD
  1240. DeskDetectDevice(
  1241.     IN  HDEVINFO                hDevInfo,
  1242.     IN  PDETECT_PROGRESS_NOTIFY ProgressFunction,
  1243.     IN  PVOID                   ProgressFunctionParam,
  1244.     OUT PSP_DRVINFO_DATA        pDrvInfoData
  1245.     )
  1246. {
  1248.     SP_DEVINSTALL_PARAMS DeviceInstallParams;
  1249.     HINF                 InfFileHandle;
  1250.     PVOID                Context;
  1251.     INFCONTEXT           infoContext;
  1252.     ULONG                LineCount = 0;
  1253.     ULONG                LoopCount = 0;
  1254.     TCHAR                Provider[LINE_LEN];
  1255.     UCHAR                Buffer[1024];
  1256.     DWORD                detectionStatus = ERROR_DEV_NOT_EXIST;
  1258.     TraceMsg(TF_GENERAL, "DeskDetectDevice calledn");
  1260.     //
  1261.     // Set the parameters for the device installation to only use dispdet.inf
  1262.     // Also use this to get the hwnd.
  1263.     //
  1265.     ZeroMemory(&DeviceInstallParams, sizeof(DeviceInstallParams));
  1266.     DeviceInstallParams.cbSize = sizeof(DeviceInstallParams);
  1268.     SetupDiGetDeviceInstallParams(hDevInfo,
  1269.                                   NULL,
  1270.                                   &DeviceInstallParams);
  1272.     DeviceInstallParams.Flags |= DI_ENUMSINGLEINF;
  1274.     lstrcpy(DeviceInstallParams.DriverPath, TEXT("dispdet.inf"));
  1276.     SetupDiSetDeviceInstallParams(hDevInfo,
  1277.                                   NULL,
  1278.                                   &DeviceInstallParams);
  1280.     if (!SetupDiBuildDriverInfoList(hDevInfo, NULL, SPDIT_CLASSDRIVER))
  1281.     {
  1282.         return ERROR_INVALID_PARAMETER;
  1283.     }
  1285.     TraceMsg(TF_GENERAL, "DetectDriverList DriverInfoList createdn");
  1288.     //
  1289.     // Open the main inf for us to do detection.
  1290.     // Detection is only done on legacy drivers that we provide
  1291.     //
  1293.     InfFileHandle = SetupOpenInfFile(TEXT("dispdet.inf"),
  1294.                                      NULL,
  1295.                                      INF_STYLE_WIN4,
  1296.                                      NULL);
  1298.     if (InfFileHandle == INVALID_HANDLE_VALUE)
  1299.     {
  1300.         return ERROR_INVALID_PARAMETER;
  1301.     }
  1303.     //
  1304.     // Append layout.inx so we can do file copy.
  1305.     //
  1307.     SetupOpenAppendInfFile(NULL,
  1308.                            InfFileHandle,
  1309.                            NULL);
  1311.     Context = SetupInitDefaultQueueCallback(DeviceInstallParams.hwndParent);
  1313.     if (!SetupInstallFromInfSection(DeviceInstallParams.hwndParent,
  1314.                                     InfFileHandle,
  1315.                                     TEXT("detect.install.drivers"),
  1316.                                     SPINST_FILES,
  1317.                                     NULL,
  1318.                                     NULL,
  1319.                                     0,
  1320.                                     &SetupDefaultQueueCallback,
  1321.                                     Context,
  1322.                                     NULL,
  1323.                                     NULL))
  1324.     {
  1325.         TraceMsg(TF_GENERAL, " Install detect files failed %dn", GetLastError());
  1326.         return GetLastError();
  1327.     }
  1329.     //
  1330.     // Get the provider name
  1331.     //
  1333.     if (SetupGetInfInformation(InfFileHandle,
  1334.                                INFINFO_INF_SPEC_IS_HINF,
  1335.                                (PSP_INF_INFORMATION) Buffer,
  1336.                                sizeof(Buffer),
  1337.                                NULL))
  1338.     {
  1339.         TraceMsg(TF_GENERAL, " Getting Provider Namen");
  1341.         SetupQueryInfVersionInformation((PSP_INF_INFORMATION) Buffer,
  1342.                                         0,
  1343.                                         TEXT("Provider"),
  1344.                                         Provider,
  1345.                                         LINE_LEN,
  1346.                                         NULL);
  1347.     }
  1349.     //
  1350.     // Get the list of drivers we want to try to detect.
  1351.     //
  1353.     LineCount = SetupGetLineCount(InfFileHandle,
  1354.                                   TEXT("DetectDriverList"));
  1356.     TraceMsg(TF_GENERAL, "DetectDriverList size = %dn", LineCount);
  1358.     //
  1359.     // Get the list of drivers we want to try to detect.
  1360.     //
  1362.     if (!SetupFindFirstLine(InfFileHandle,
  1363.                             TEXT("DetectDriverList"),
  1364.                             NULL,
  1365.                             &infoContext))
  1366.     {
  1367.         return ERROR_INVALID_PARAMETER;
  1368.     }
  1370.     do
  1371.     {
  1372.         TCHAR DeviceDescription[LINE_LEN];
  1373.         ULONG DeviceDescriptionSize;
  1374.         TCHAR Manufacturer[LINE_LEN];
  1375.         ULONG ManufacturerSize;
  1376.         TCHAR ServiceName[LINE_LEN];
  1377.         TCHAR DetectBroken[LINE_LEN];
  1378.         ULONG DetectBrokenSize;
  1381.         ASSERT(LoopCount < LineCount);
  1383.         //
  1384.         // For each driver in the list, install it and see if it loads
  1385.         //
  1387.         if ( (!SetupGetStringField(&infoContext,
  1388.                                    0,
  1389.                                    Manufacturer,
  1390.                                    LINE_LEN,
  1391.                                    &ManufacturerSize))
  1392.            ||
  1393.              (!SetupGetStringField(&infoContext,
  1394.                                    1,
  1395.                                    DeviceDescription,
  1396.                                    LINE_LEN,
  1397.                                    &DeviceDescriptionSize))
  1398.            )
  1399.         {
  1400.             TraceMsg(TF_GENERAL, " Get Item failed on line %d, error %dn",
  1401.                      LineCount, GetLastError());
  1402.         }
  1403.         else
  1404.         {
  1405.             //
  1406.             // Find the appropriate entry in the list of devices.
  1407.             //
  1409.             TraceMsg(TF_GENERAL, "DeskDetectDevice on device %ws, %wsn",
  1410.                      Manufacturer, DeviceDescription);
  1412.             ZeroMemory(pDrvInfoData, sizeof(SP_DRVINFO_DATA));
  1413.             pDrvInfoData->cbSize     = sizeof(SP_DRVINFO_DATA);
  1414.             pDrvInfoData->DriverType = SPDIT_CLASSDRIVER;
  1415.             pDrvInfoData->Reserved   = 0; // Means search the list for this driver
  1416.             _tcscpy(pDrvInfoData->Description,  DeviceDescription);
  1417.             _tcscpy(pDrvInfoData->MfgName,      Manufacturer);
  1418.             _tcscpy(pDrvInfoData->ProviderName, Provider);
  1420.             if (!SetupDiSetSelectedDriver(hDevInfo,
  1421.                                           NULL,
  1422.                                           pDrvInfoData))
  1423.             {
  1424.                 TraceMsg(TF_GENERAL, "DeskDetectDevice Select device failed on %ws, error %dn",
  1425.                          DeviceDescription, GetLastError());
  1426.             }
  1427.             else
  1428.             {
  1429.                 TraceMsg(TF_GENERAL, "DeskDetectDevice Match on device %wsn", DeviceDescription);
  1431.                 //
  1432.                 // Install the service in the registry.
  1433.                 //
  1435.                 if (DeskInstallService(hDevInfo,
  1436.                                        NULL,
  1437.                                        ServiceName,
  1438.                                        LEGACY_DETECT) == NO_ERROR)
  1439.                 {
  1440.                     TraceMsg(TF_GENERAL, "DeskDetectDevice Service %ws installedn",
  1441.                              ServiceName);
  1443.                     //
  1444.                     //  We have no DEVNODE.  Start the driver by hand.
  1445.                     //
  1447.                     if (DeskSCStartService(ServiceName) == NO_ERROR)
  1448.                     {
  1449.                         TraceMsg(TF_GENERAL, "DeskDetectDevice Service startedn");
  1451.                         //
  1452.                         // We detected a device !!!
  1453.                         //
  1455.                         detectionStatus = NO_ERROR;
  1457.                         //
  1458.                         // Stop the service
  1459.                         // BUGBUG Don't care if it stops or not for now.
  1460.                         //
  1462.                         DeskSCStopService(ServiceName);
  1463.                     }
  1465.                     TraceMsg(TF_GENERAL, "DeskDetectDevice remove Servicen");
  1467.                     DeskRemoveService(hDevInfo,
  1468.                                       NULL,
  1469.                                       ServiceName);
  1471.                     //
  1472.                     // For broken drivers that trash the screen during
  1473.                     // detection, reset the device to the default state.
  1474.                     //
  1476.                     if (SetupGetStringField(&infoContext,
  1477.                                             2,
  1478.                                             DetectBroken,
  1479.                                             LINE_LEN,
  1480.                                             &DetectBrokenSize))
  1481.                     {
  1482.                         TraceMsg(TF_GENERAL, " detect : %wsn", DetectBroken);
  1484.                         if (_tcscmp(DetectBroken, TEXT("detect_broken")) == 0)
  1485.                         {
  1486.                             TraceMsg(TF_GENERAL, "DeskDetectDevice detect_broken - RESET_SCREENn");
  1487.                             ChangeDisplaySettings(NULL, CDS_RESET);
  1488.                         }
  1489.                     }
  1490.                 }
  1491.             }
  1493.             //
  1494.             // If we found a device, then stop detection.
  1495.             //
  1496.             // NOTE - machines with more than 1 video card should have PnP
  1497.             // drivers for those !
  1498.             //
  1500.             if (detectionStatus == NO_ERROR)
  1501.             {
  1502.                 TraceMsg(TF_GENERAL, "DeskDetectDevice found device - stop detectionn");
  1503.                 break;
  1504.             }
  1505.         }
  1507.         //
  1508.         // Track how far along we are in detection
  1509.         //
  1511.         TraceMsg(TF_GENERAL, "DeskDetectDevice Display LoopCountn");
  1513.         LoopCount++;
  1515.         if (ProgressFunction)
  1516.         {
  1517.             if (ProgressFunction(ProgressFunctionParam,
  1518.                                  LoopCount * 100 / LineCount))
  1519.             {
  1520.                 //
  1521.                 // User cancelled - leave now.
  1522.                 //
  1524.                 break;
  1525.             }
  1526.         }
  1528.     } while (SetupFindNextLine(&infoContext, &infoContext));
  1530.     TraceMsg(TF_GENERAL, "DeskDetectDevice Completen");
  1532.     //
  1533.     // Clean out all of the extra files we copied
  1534.     //
  1536.     if (!SetupInstallFromInfSection(DeviceInstallParams.hwndParent,
  1537.                                     InfFileHandle,
  1538.                                     TEXT("detect.remove.drivers"),
  1539.                                     SPINST_FILES,
  1540.                                     NULL,
  1541.                                     NULL,
  1542.                                     0,
  1543.                                     &SetupDefaultQueueCallback,
  1544.                                     Context,
  1545.                                     NULL,
  1546.                                     NULL))
  1547.     {
  1548.         TraceMsg(TF_GENERAL, " Remove detect files failed %dn", GetLastError());
  1549.     }
  1552.     return (detectionStatus);
  1553. }
  1558. /***************************************************************************/
  1559. /***************************************************************************/
  1560. /**                                                                       **/
  1561. /**                           Class Installers                            **/
  1562. /**                                                                       **/
  1563. /***************************************************************************/
  1564. /***************************************************************************/
  1567. LPTSTR UpdateDatabase[] = {
  1568.     TEXT("Root\LEGACY_UPGRADE_THIS_DRIVER\0000"),
  1569.     NULL,
  1570. };
  1573. BOOL
  1574. DeskCheckInstallDatabase(
  1575.     IN HDEVINFO         hDevInfo,
  1576.     IN PSP_DEVINFO_DATA pDeviceInfoData
  1577.     )
  1578. {
  1579.     BOOL            bRet = TRUE;
  1580.     HDEVINFO        HDevInfo;
  1581.     SP_DEVINFO_DATA DeviceInfoData;
  1582.     DWORD           index = 0;
  1583.     TCHAR           RegistryProperty[256];
  1584.     ULONG           BufferSize;
  1586. #if 0
  1587.     HKEY            hKey;
  1588.     //
  1589.     // BUGBUG this does not work.
  1590.     // It appears to always succeed
  1591.     //
  1593.     //
  1594.     // First. let's check if we have a driver key.
  1595.     // If we do, then we can control the upgrade easily.
  1596.     //
  1598.     hKey = SetupDiOpenDevRegKey(hDevInfo,
  1599.                                 pDeviceInfoData,
  1600.                                 DICS_FLAG_GLOBAL,
  1601.                                 0,
  1602.                                 DIREG_DRV,
  1603.                                 KEY_READ | KEY_WRITE);
  1605.     if (hKey != INVALID_HANDLE_VALUE)
  1606.     {
  1607.         //
  1608.         // If this succeeds, then we can safely upgrade the driver since
  1609.         // it is an existing, properly installed driver.
  1610.         //
  1612.         TraceMsg(TF_GENERAL, "Database - driver key existsn");
  1614.         RegCloseKey(hKey);
  1616.         return TRUE;
  1617.     }
  1618. #endif
  1620.     //
  1621.     // Let's find all the video drivers that are installed in the system
  1622.     //
  1624.     HDevInfo = SetupDiGetClassDevs((LPGUID) &GUID_DEVCLASS_DISPLAY,
  1625.                                    NULL,
  1626.                                    NULL,
  1627.                                    0);
  1629.     if (HDevInfo == INVALID_HANDLE_VALUE)
  1630.     {
  1631.         TraceMsg(TF_GENERAL, "Database - no existing drivern");
  1632.         return TRUE;
  1633.     }
  1635.     while (bRet)
  1636.     {
  1637.         ZeroMemory(&DeviceInfoData, sizeof(SP_DEVINFO_DATA));
  1638.         DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
  1640.         if (!SetupDiEnumDeviceInfo(HDevInfo,
  1641.                                    index++,
  1642.                                    &DeviceInfoData))
  1643.         {
  1644.             TraceMsg(TF_GENERAL, "Database retrieving device Error %dn", GetLastError());
  1645.             break;
  1646.         }
  1648.         //
  1649.         // For each driver we found, compare it to the driver we are being
  1650.         // asked to install.
  1651.         //
  1653.         //
  1654.         // If we have a root legacy device, then don't install any new
  1655.         // devnode (until we get better at this).
  1656.         //
  1659.         if (CR_SUCCESS == CM_Get_Device_ID(DeviceInfoData.DevInst,
  1660.                                            RegistryProperty,
  1661.                                            sizeof(RegistryProperty),
  1662.                                            0))
  1663.         {
  1664.             LPTSTR *pUpgrade = UpdateDatabase;
  1666.             TraceMsg(TF_GENERAL, "t CM_Get_Device_ID = %wsn", RegistryProperty);
  1668.             if (_tcsncicmp(TEXT("ROOT\LEGACY_"),
  1669.                            RegistryProperty,
  1670.                            sizeof(TEXT("ROOT\LEGACY_"))) == 0)
  1671.             {
  1672.                 TraceMsg(TF_GENERAL, "t Legacy DEVNODE = %wsn", RegistryProperty);
  1674.                 //
  1675.                 // We have a legacy DEVNODE.
  1676.                 // By default, we don't want to upgrade any of these devices.
  1677.                 //
  1678.                 // Check if it's part of our database that we should upgrade.
  1679.                 //
  1681.                 bRet = FALSE;
  1683.                 while (*pUpgrade)
  1684.                 {
  1685.                     if (_tcsicmp(*pUpgrade, RegistryProperty) == 0)
  1686.                     {
  1687.                         TraceMsg(TF_GENERAL, "t Upgrade DEVNODE = %wsn", RegistryProperty);
  1689.                         bRet = TRUE;
  1690.                         break;
  1691.                     }
  1693.                     pUpgrade++;
  1694.                 }
  1695.             }
  1697.         }
  1699.         //
  1700.         // Print out other data for informational purposes.
  1701.         //
  1703.         BufferSize = sizeof(RegistryProperty);
  1705.         if (CR_SUCCESS ==
  1706.                 CM_Get_DevNode_Registry_Property(DeviceInfoData.DevInst,
  1707.                                                  CM_DRP_DEVICEDESC,
  1708.                                                  NULL,
  1709.                                                  RegistryProperty,
  1710.                                                  &BufferSize,
  1711.                                                  0))
  1712.         {
  1713.             TraceMsg(TF_GENERAL, "t CM_DRP_DEVICEDESC = %wsn", RegistryProperty);
  1714.         }
  1716.         BufferSize = sizeof(RegistryProperty);
  1718.         if (CR_SUCCESS ==
  1719.                 CM_Get_DevNode_Registry_Property(DeviceInfoData.DevInst,
  1720.                                                  CM_DRP_SERVICE,
  1721.                                                  NULL,
  1722.                                                  RegistryProperty,
  1723.                                                  &BufferSize,
  1724.                                                  0))
  1725.         {
  1726.             TraceMsg(TF_GENERAL, "t CM_DRP_SERVICE = %wsn", RegistryProperty);
  1727.         }
  1728.     }
  1730.     return bRet;
  1731. }
  1733. BOOL
  1734. bDoLegacyDetection(VOID)
  1735. {
  1736.     BOOL   bRet;
  1737.     HKEY   hkey;
  1738.     DWORD  bSetupInProgress = 0;
  1739.     DWORD  bUpgradeInProgress = 0;
  1740.     TCHAR  data[256];
  1741.     DWORD  cb;
  1742.     LPTSTR regstring;
  1744.     // ULONG  cCount;
  1745.     // cCount = GetPrivateProfileString(TEXT("data"),
  1746.     //                                  TEXT("winntupgrade"),
  1747.     //                                  TEXT("missing"),
  1748.     //                                  data,
  1749.     //                                  256,
  1750.     //                                  TEXT(".\$winnt$.inf"));
  1753.     hkey = NULL;
  1755.     if (RegOpenKeyEx(HKEY_LOCAL_MACHINE,
  1756.                      TEXT("System\Setup"),
  1757.                      0,
  1758.                      KEY_READ | KEY_WRITE,
  1759.                      &hkey) == ERROR_SUCCESS)
  1760.     {
  1761.         cb = 256;
  1763.         if (RegQueryValueEx(hkey,
  1764.                             TEXT("SystemSetupInProgress"),
  1765.                             NULL,
  1766.                             NULL,
  1767.                             (LPBYTE)(data),
  1768.                             &cb) == ERROR_SUCCESS)
  1769.         {
  1770.             bSetupInProgress = * ((LPDWORD)(data));
  1771.         }
  1773.         cb = 256;
  1775.         if (RegQueryValueEx(hkey,
  1776.                             TEXT("UpgradeInProgress"),
  1777.                             NULL,
  1778.                             NULL,
  1779.                             (LPBYTE)(data),
  1780.                             &cb) == ERROR_SUCCESS)
  1781.         {
  1782.             bUpgradeInProgress = * ((LPDWORD)(data));
  1783.         }
  1785.         if (hkey) {
  1786.             RegCloseKey(hkey);
  1787.         }
  1788.     }
  1790.     if (bSetupInProgress)
  1791.     {
  1792.         if (bUpgradeInProgress)
  1793.         {
  1794.             regstring = TEXT("System\Video_Upgrade");
  1795.             TraceMsg(TF_GENERAL, "/t/tUpgraden");
  1796.             bRet = FALSE;
  1797.         }
  1798.         else
  1799.         {
  1800.             //
  1801.             // We only do installation or detection if not BASEVIDEO
  1802.             //
  1804.             cb = 256;
  1805.             hkey = NULL;
  1807.             if ( (RegOpenKeyEx(HKEY_LOCAL_MACHINE,
  1808.                                TEXT("System\CurrentControlSet\Control\Setup"),
  1809.                                0,
  1810.                                KEY_READ | KEY_WRITE,
  1811.                                &hkey) == ERROR_SUCCESS)     &&
  1812.                  (RegQueryValueEx(hkey,
  1813.                                   TEXT("video"),
  1814.                                   NULL,
  1815.                                   NULL,
  1816.                                   (LPBYTE)(data),
  1817.                                   &cb) == ERROR_SUCCESS)    &&
  1818.                  (_tcscmp(data, TEXT("forcevga")) == 0)
  1819.                )
  1820.             {
  1821.                 regstring = TEXT("System\Basevideo_Winnt");
  1822.                 TraceMsg(TF_GENERAL, "/t/tbasevideo installn");
  1823.                 bRet = FALSE;
  1824.             }
  1825.             else
  1826.             {
  1827.                 regstring = TEXT("System\Video_Clean");
  1828.                 TraceMsg(TF_GENERAL, "/t/tCleanInstalln");
  1829.                 bRet = TRUE;
  1830.             }
  1832.             if (hkey) {
  1833.                 RegCloseKey(hkey);
  1834.             }
  1835.         }
  1836.     }
  1837.     else
  1838.     {
  1839.         regstring = TEXT("System\Video_Missing_Winnt");
  1840.         TraceMsg(TF_GENERAL, "/t/tMissing $Winnt$.inf filen");
  1841.         bRet = TRUE;
  1842.     }
  1845. #if ANDREVA_DBG
  1846.     {
  1847.         DWORD  disposition;
  1849.         hkey = NULL;
  1850.         RegCreateKeyEx(HKEY_LOCAL_MACHINE,
  1851.                        regstring,
  1852.                        0,
  1853.                        NULL,
  1854.                        REG_OPTION_NON_VOLATILE,
  1855.                        KEY_READ | KEY_WRITE,
  1856.                        NULL,
  1857.                        &hkey,
  1858.                        &disposition);
  1860.         if (hkey) {
  1861.             RegCloseKey(hkey);
  1862.         }
  1863.     }
  1864. #endif
  1866.     return bRet;
  1867. }
  1873. DWORD
  1874. DisplayClassInstaller(
  1875.     IN DI_FUNCTION      InstallFunction,
  1876.     IN HDEVINFO         hDevInfo,
  1877.     IN PSP_DEVINFO_DATA pDeviceInfoData OPTIONAL
  1878.     )
  1880. /*++
  1882. Routine Description:
  1884.   This routine acts as the class installer for Display devices.
  1886. Arguments:
  1888.     InstallFunction - Specifies the device installer function code indicating
  1889.         the action being performed.
  1891.     DeviceInfoSet - Supplies a handle to the device information set being
  1892.         acted upon by this install action.
  1894.     pDeviceInfoData - Optionally, supplies the address of a device information
  1895.         element being acted upon by this install action.
  1897. Return Value:
  1899.     If this function successfully completed the requested action, the return
  1900.         value is NO_ERROR.
  1902.     If the default behavior is to be performed for the requested action, the
  1903.         return value is ERROR_DI_DO_DEFAULT.
  1905.     If an error occurred while attempting to perform the requested action, a
  1906.         Win32 error code is returned.
  1908. --*/
  1910. {
  1912.     DWORD err;
  1913.     SP_DRVINFO_DATA DrvInfoData;
  1914.     // SP_SELECTDEVICE_PARAMS  SelectDevParams;
  1915.     // SP_DETECTDEVICE_PARAMS  DetectDevParams;
  1916.     TCHAR ServiceName[LINE_LEN];
  1919.     switch(InstallFunction) {
  1921.     case DIF_SELECTDEVICE :
  1923.         TraceMsg(TF_GENERAL, "DisplayClassInstaller DIF_SELECTDEVICE n");
  1925.         //
  1926.         // Check for old display driver infs that we no longer support.
  1927.         //
  1929.         if (SetupDiBuildDriverInfoList(hDevInfo, NULL, SPDIT_CLASSDRIVER))
  1930.         {
  1931.             if (!SetupDiEnumDriverInfo(hDevInfo,
  1932.                                        NULL,
  1933.                                        SPDIT_CLASSDRIVER,
  1934.                                        0,
  1935.                                        &DrvInfoData))
  1936.             {
  1938.                 if (GetLastError() == ERROR_NO_MORE_ITEMS)
  1939.                 {
  1940.                     //
  1941.                     // This is what happens when an old inf is loaded.
  1942.                     // Tell the user it is an old inf.
  1943.                     //
  1945.                     FmtMessageBox(ghwndPropSheet,   // BUGBUG
  1946.                                   MB_ICONEXCLAMATION,
  1947.                                   FALSE,
  1948.                                   ID_DSP_TXT_INSTALL_DRIVER,
  1949.                                   ID_DSP_TXT_BAD_INF);
  1951.                     return ERROR_NO_MORE_ITEMS;
  1952.                 }
  1953.             }
  1954.         }
  1956.         break;
  1959. #if 0
  1960.         //
  1961.         // Set the test parameters for the display class installer.
  1962.         //
  1964.         ZeroMemory(&SelectDevParams, sizeof(SelectDevParams));
  1966.         SelectDevParams.ClassInstallHeader.cbSize
  1967.                                      = sizeof(SelectDevParams.ClassInstallHeader);
  1968.         SelectDevParams.ClassInstallHeader.InstallFunction
  1969.                                      = DIF_SELECTDEVICE;
  1971.         //
  1972.         // Get current SelectDevice parameters, and then set the fields
  1973.         // we want to be different from default
  1974.         //
  1976.         SetupDiGetClassInstallParams(hDevInfo,
  1977.                                      NULL,
  1978.                                      &SelectDevParams.ClassInstallHeader,
  1979.                                      sizeof(SelectDevParams),
  1980.                                      NULL);
  1982.         SelectDevParams.ClassInstallHeader.cbSize
  1983.                                  = sizeof(SelectDevParams.ClassInstallHeader);
  1984.         SelectDevParams.ClassInstallHeader.InstallFunction
  1985.                                  = DIF_SELECTDEVICE;
  1987.         //
  1988.         // Set the strings to use on the select driver page .
  1989.         //
  1991.         LoadString(ghmod,
  1992.                    IDS_DISPLAYINST,
  1993.                    SelectDevParams.Title,
  1994.                    sizeof(SelectDevParams.Title));
  1996.         LoadString(ghmod,
  1997.                    IDS_WINNTDEV_INSTRUCT,
  1998.                    SelectDevParams.Instructions,
  1999.                    sizeof(SelectDevParams.Instructions));
  2001.         LoadString(ghmod,
  2002.                    IDS_SELECTDEV_LABEL,
  2003.                    SelectDevParams.ListLabel,
  2004.                    sizeof(SelectDevParams.ListLabel));
  2006.         SetupDiSetClassInstallParams(hDevInfo,
  2007.                                      NULL,
  2008.                                      &SelectDevParams.ClassInstallHeader,
  2009.                                      sizeof(SelectDevParams));
  2011.         //
  2012.         // Let the wizard finish it's thing
  2013.         //
  2015.         break;
  2017. #endif
  2021.     case DIF_FIRSTTIMESETUP :
  2023.         TraceMsg(TF_GENERAL, "DisplayClassInstaller DIF_FIRSTTIMESETUP n");
  2025.         ASSERT(pDeviceInfoData == NULL);
  2027.         //
  2028.         // Don't do video driver detection during upgrade.
  2029.         //
  2031.         if (bDoLegacyDetection() == FALSE)
  2032.         {
  2033.             return NO_ERROR;
  2034.         }
  2037.         err = DeskDetectDevice(hDevInfo,
  2038.                                NULL,
  2039.                                NULL,
  2040.                                &DrvInfoData);
  2042.         if (err == NO_ERROR)
  2043.         {
  2044.             SP_DEVINFO_DATA      DeviceInfoData;
  2045.             SP_DEVINSTALL_PARAMS DeviceInstallParams;
  2046.             SP_DRVINFO_DATA      NewDrvInfoData = DrvInfoData;
  2048.             //
  2049.             // Create the DeviceInfoData for this new device.
  2050.             //
  2052.             TraceMsg(TF_GENERAL, " FIRSTTIME Creating DeviceInfon");
  2054.             ZeroMemory(&DeviceInfoData, sizeof(DeviceInfoData));
  2055.             DeviceInfoData.cbSize = sizeof(DeviceInfoData);
  2057.             if (!SetupDiCreateDeviceInfo(hDevInfo,
  2058.                                          TEXT("Display"),
  2059.                                          (LPGUID) &GUID_DEVCLASS_DISPLAY,
  2060.                                          NULL,
  2061.                                          NULL,
  2062.                                          DICD_GENERATE_ID,
  2063.                                          &DeviceInfoData))
  2064.             {
  2065.                 err = GetLastError();
  2066.                 TraceMsg(TF_GENERAL, " FIRSTTIME CreateDeviceInfo failed : error = %dn",err);
  2067.                 return err;
  2068.             }
  2070.             //
  2071.             // Set the inf name to display.inf
  2072.             //
  2073.             // Also copy the files silently since we are in setup.
  2074.             //
  2076.             ZeroMemory(&DeviceInstallParams, sizeof(DeviceInstallParams));
  2077.             DeviceInstallParams.cbSize = sizeof(DeviceInstallParams);
  2079.             if (!SetupDiGetDeviceInstallParams(hDevInfo,
  2080.                                                &DeviceInfoData,
  2081.                                                &DeviceInstallParams))
  2082.             {
  2083.                 err = GetLastError();
  2084.                 TraceMsg(TF_GENERAL, " FIRSTTIME GetDeviceInstall : error = %dn",err);
  2085.                 return err;
  2086.             }
  2088.             DeviceInstallParams.Flags |= DI_ENUMSINGLEINF | DI_QUIETINSTALL;
  2090.             lstrcpy(DeviceInstallParams.DriverPath, TEXT("display.inf"));
  2092.             if (!SetupDiSetDeviceInstallParams(hDevInfo,
  2093.                                                &DeviceInfoData,
  2094.                                                &DeviceInstallParams))
  2095.             {
  2096.                 err = GetLastError();
  2097.                 TraceMsg(TF_GENERAL, " FIRSTTIME SetDeviceInstall : error = %dn",err);
  2098.                 return err;
  2099.             }
  2101.             //
  2102.             // Build the driver list
  2103.             //
  2105.             if (!SetupDiBuildDriverInfoList(hDevInfo,
  2106.                                             &DeviceInfoData,
  2107.                                             SPDIT_CLASSDRIVER))
  2108.             {
  2109.                 err = GetLastError();
  2110.                 DbgPrint("Desk.cpl: FIRSTTIME SetupDiBuildDriverInfoList Error %dn", err);
  2111.                 return err;
  2112.             }
  2114.             //
  2115.             // Find the same driver in display.inf
  2116.             //
  2118.             NewDrvInfoData.Reserved = 0;
  2120.             if (!SetupDiSetSelectedDriver(hDevInfo,
  2121.                                           &DeviceInfoData,
  2122.                                           &NewDrvInfoData))
  2123.             {
  2124.                 err = GetLastError();
  2125.                 TraceMsg(TF_GENERAL, " FIRSTTIME display.inf dispdet.inf inconsistent = %dn", err);
  2126.                 ASSERT(FALSE);
  2127.                 return err;
  2128.             }
  2131.             //
  2132.             // How do we finish the install ... ?
  2133.             //
  2134.             // If this is a PnP device, just install the service and
  2135.             // run it.  The video port will call IoReportDetectedDevice
  2136.             // which will later complete the installation of the deivce
  2137.             //
  2138.             // For non-PnP drivers, we can do nothing at this point, and a
  2139.             // DEVNODE will be created.
  2140.             //
  2142.             if (DeskIsPnPDriver(hDevInfo, NULL))
  2143.             {
  2144.                 if (!SetupDiCallClassInstaller(DIF_INSTALLDEVICEFILES,
  2145.                                                hDevInfo,
  2146.                                                &DeviceInfoData))
  2147.                 {
  2148.                     err = GetLastError();
  2149.                     TraceMsg(TF_GENERAL, " FIRSTTIME install of driver files failed = %dn", err);
  2150.                 }
  2151.                 else
  2152.                 {
  2153.                     err = DeskInstallService(hDevInfo,
  2154.                                              &DeviceInfoData,
  2155.                                              ServiceName,
  2156.                                              REPORT_DEVICE);
  2158.                     if (err == NO_ERROR)
  2159.                     {
  2160.                         err = DeskSCStartService(ServiceName);
  2161.                     }
  2162.                 }
  2164.                 //
  2165.                 // Remove the device info since we don't want to install
  2166.                 // it later on.
  2167.                 //
  2169.                 SetupDiDeleteDeviceInfo(hDevInfo,
  2170.                                         &DeviceInfoData);
  2171.             }
  2172.             else
  2173.             {
  2174.                 //
  2175.                 // We will get called later to register and install this
  2176.                 // device if it is a TRUE legacy DEVNODE...
  2177.                 //
  2178.             }
  2179.         }
  2181.         return err;
  2184. #if LATER
  2186.     case DIF_DETECT :
  2188.         TraceMsg(TF_GENERAL, "DisplayClassInstaller DIF_DETECT n");
  2190.         ASSERT(pDeviceInfoData == NULL);
  2192.         //
  2193.         // Get the progress bar parameter for detection
  2194.         //
  2196.         ZeroMemory(&DetectDevParams, sizeof(DetectDevParams));
  2198.         DetectDevParams.ClassInstallHeader.cbSize
  2199.                                      = sizeof(DetectDevParams.ClassInstallHeader);
  2200.         DetectDevParams.ClassInstallHeader.InstallFunction
  2201.                                      = DIF_DETECT;
  2203.         SetupDiGetClassInstallParams(hDevInfo,
  2204.                                      NULL,
  2205.                                      &DetectDevParams.ClassInstallHeader,
  2206.                                      sizeof(DetectDevParams),
  2207.                                      NULL);
  2209.         err = DeskDetectDevice(hDevInfo,
  2210.                                DetectDevParams.DetectProgressNotify,
  2211.                                DetectDevParams.ProgressNotifyParam,
  2212.                                &DrvInfoData);
  2215.         return err;
  2216. #endif
  2219.     case DIF_REGISTERDEVICE :
  2222.         TraceMsg(TF_GENERAL, "DisplayClassInstaller DIF_REGISTERDEVICE n");
  2224.         if (!SetupDiRegisterDeviceInfo(hDevInfo,
  2225.                                        pDeviceInfoData,
  2226.                                        0,
  2227.                                        NULL,
  2228.                                        NULL,
  2229.                                        NULL))
  2230.         {
  2231.             err = GetLastError();
  2232.             TraceMsg(TF_GENERAL, "DIF_REGISTERDEVICE failed : error = %dn",err);
  2233.             return err;
  2234.         }
  2236.         return NO_ERROR;
  2239.     case DIF_ALLOW_INSTALL :
  2241.         TraceMsg(TF_GENERAL, "DisplayClassInstaller DIF_ALLOW_INSTALL n");
  2243.         //
  2244.         // Only allow installation if this is a DEVNODE we don't have a legacy
  2245.         // driver for already.
  2246.         //
  2248.         if (DeskCheckInstallDatabase(hDevInfo,
  2249.                                      pDeviceInfoData) == FALSE)
  2250.         {
  2251.             return ERROR_DI_DONT_INSTALL;
  2252.         }
  2254.         return ERROR_DI_DO_DEFAULT;
  2257.     case DIF_INSTALLDEVICE :
  2259.         TraceMsg(TF_GENERAL, "DisplayClassInstaller DIF_INSTALLDEVICE n");
  2261.         {
  2262.             DISPLAY_DEVICE displayDevice;
  2263.             displayDevice.cb = sizeof(DISPLAY_DEVICE);
  2265.             err = DeskInstallService(hDevInfo,
  2266.                                      pDeviceInfoData,
  2267.                                      ServiceName,
  2268.                                      0);  // not a detect install
  2270.             //
  2271.             // Calling EnumDisplayDevices will rescan the devices, and if a
  2272.             // new device is detected, we will disable and reenable the main
  2273.             // device.
  2274.             // This reset of the display device will clear up any mess caused
  2275.             // by installing a new driver
  2276.             //
  2278.             EnumDisplayDevices(NULL, 0, &displayDevice, 0);
  2279.         }
  2281.         return err;
  2284.     case DIF_REMOVE :
  2286.     default :
  2288.         TraceMsg(TF_GENERAL, "DisplayClassInstaller default function = %dn", (DWORD) InstallFunction);
  2290.         break;
  2291.     }
  2293.     //
  2294.     // If we did not exit from the routine by handling the call, tell the
  2295.     // setup code to handle everything the default way.
  2296.     //
  2298.     return ERROR_DI_DO_DEFAULT;
  2299. }
  2302. DWORD
  2303. MonitorClassInstaller(
  2304.     IN DI_FUNCTION      InstallFunction,
  2305.     IN HDEVINFO         hDevInfo,
  2306.     IN PSP_DEVINFO_DATA pDeviceInfoData OPTIONAL
  2307.     )
  2309. /*++
  2311. Routine Description:
  2313.   This routine acts as the class installer for Display devices.
  2315. Arguments:
  2317.     InstallFunction - Specifies the device installer function code indicating
  2318.         the action being performed.
  2320.     DeviceInfoSet - Supplies a handle to the device information set being
  2321.         acted upon by this install action.
  2323.     pDeviceInfoData - Optionally, supplies the address of a device information
  2324.         element being acted upon by this install action.
  2326. Return Value:
  2328.     If this function successfully completed the requested action, the return
  2329.         value is NO_ERROR.
  2331.     If the default behavior is to be performed for the requested action, the
  2332.         return value is ERROR_DI_DO_DEFAULT.
  2334.     If an error occurred while attempting to perform the requested action, a
  2335.         Win32 error code is returned.
  2337. --*/
  2339. {
  2342.     TraceMsg(TF_GENERAL, " MonitorClassInstaller function = %dn", (DWORD) InstallFunction);
  2344.     //
  2345.     // If we did not exit from the routine by handling the call, tell the
  2346.     // setup code to handle everything the default way.
  2347.     //
  2349.     return ERROR_DI_DO_DEFAULT;
  2350. }
  2355. /***************************************************************************/
  2356. /***************************************************************************/
  2357. /**                                                                       **/
  2358. /**                           Internal setup call                         **/
  2359. /**                                                                       **/
  2360. /***************************************************************************/
  2361. /***************************************************************************/
  2366. DWORD
  2367. InstallNewDriver(
  2368.     HWND    hwnd,
  2369.     LPCTSTR pszModel,
  2370.     PBOOL   pbKeepEnabled
  2371.     )
  2372. {
  2373.     DWORD err;
  2374.     BOOL bStatus;
  2375.     LPTSTR keyName;
  2376.     DWORD reboot;
  2378.     HMODULE hModule;
  2379.     PINSTALLNEWDEVICE InstallNewDevice;
  2381.     hModule = LoadLibrary(TEXT("newdev.dll"));
  2383.     if (hModule)
  2384.     {
  2385.         InstallNewDevice = (PINSTALLNEWDEVICE)GetProcAddress(hModule, "InstallNewDevice");
  2387.         if (InstallNewDevice)
  2388.         {
  2389.             bStatus = (*InstallNewDevice)(hwnd, (LPGUID) &GUID_DEVCLASS_DISPLAY, &reboot);
  2391.         }
  2392.     }
  2394.     if (bStatus)
  2395.     {
  2396.         DWORD disposition;
  2397.         HKEY hkey;
  2399.         *pbKeepEnabled = KeepEnabled;
  2401.         //
  2402.         // Tell the user the driver was installed.
  2403.         //
  2405.         FmtMessageBox(hwnd,
  2406.                       MB_ICONINFORMATION | MB_OK,
  2407.                       FALSE,
  2408.                       ID_DSP_TXT_INSTALL_DRIVER,
  2409.                       ID_DSP_TXT_DRIVER_INSTALLED);
  2411.         if (PreConfigured == 0)
  2412.         {
  2413.             //
  2414.             // Create a registry key that indicates a new display was
  2415.             // installed.
  2416.             //
  2418.             keyName = SZ_NEW_DISPLAY;
  2420.             if (RegCreateKeyEx(HKEY_LOCAL_MACHINE,
  2421.                                keyName,
  2422.                                0,
  2423.                                NULL,
  2424.                                REG_OPTION_NON_VOLATILE,
  2425.                                KEY_READ | KEY_WRITE,
  2426.                                NULL,
  2427.                                &hkey,
  2428.                                &disposition) == ERROR_SUCCESS)
  2429.             {
  2430.                 RegCloseKey(hkey);
  2431.             }
  2432.         }
  2435.         //
  2436.         // Save into the registry the fact that it will take a reboot
  2437.         // for these changes to take effect
  2438.         //
  2440.         if (RegCreateKeyEx(HKEY_LOCAL_MACHINE,
  2441.                            SZ_REBOOT_NECESSARY,
  2442.                            0,
  2443.                            NULL,
  2444.                            REG_OPTION_VOLATILE,
  2445.                            KEY_READ | KEY_WRITE,
  2446.                            NULL,
  2447.                            &hkey,
  2448.                            &disposition) == ERROR_SUCCESS)
  2449.         {
  2450.             RegCloseKey(hkey);
  2451.         }
  2453.         //
  2454.         // If everything succeeded properly, then we need to reboot the
  2455.         // machine
  2456.         //
  2457.         // Ask the user to reboot the machine.
  2458.         //
  2460.         PropSheet_RestartWindows(ghwndPropSheet);
  2461.         PropSheet_CancelToClose(ghwndPropSheet);
  2463.     }
  2464.     else
  2465.     {
  2466.         err = GetLastError();
  2468.         if (err != ERROR_CANCELLED)
  2469.         {
  2470.             //
  2471.             // Tell the user the driver was not installed properly.
  2472.             //
  2474.             FmtMessageBox(hwnd,
  2475.                           MB_ICONSTOP | MB_OK,
  2476.                           FALSE,
  2477.                           ID_DSP_TXT_INSTALL_DRIVER,
  2478.                           ID_DSP_TXT_DRIVER_INSTALLED_FAILED);
  2479.         }
  2480.     }
  2482.     return err;
  2483. }