reactos/services/umpnpmgr/umpnpmgr.c

   1 /*
   2  *  ReactOS kernel
   3  *  Copyright (C) 2005 ReactOS Team
   4  *
   5  *  This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this program; if not, write to the Free Software
  17  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18  */
  19 /*
  20  * COPYRIGHT:        See COPYING in the top level directory
  21  * PROJECT:          ReactOS kernel
  22  * FILE:             services/umpnpmgr/umpnpmgr.c
  23  * PURPOSE:          User-mode Plug and Play manager
  24  * PROGRAMMER:       Eric Kohl
  25  *                   Hervé Poussineau (hpoussin@reactos.org)
  26  */
  27
  28 /* INCLUDES *****************************************************************/
  29 #define WIN32_NO_STATUS
  30 #include <windows.h>
  31 #define NTOS_MODE_USER
  32 #include <ndk/ntndk.h>
  33 #include <umpnpmgr/sysguid.h>
  34 #include <wdmguid.h>
  35 #include <cfgmgr32.h>
  36
  37 #include <rpc.h>
  38 #include <rpcdce.h>
  39
  40 #include "pnp_c.h"
  41
  42 #define NDEBUG
  43 #include <debug.h>
  44
  45 /* GLOBALS ******************************************************************/
  46
  47 static VOID CALLBACK
  48 ServiceMain(DWORD argc, LPTSTR *argv);
  49
  50 static SERVICE_TABLE_ENTRY ServiceTable[2] =
  51 {
  52     {TEXT("PlugPlay"), ServiceMain},
  53     {NULL, NULL}
  54 };
  55
  56 static WCHAR szRootDeviceId[] = L"HTREE\\ROOT\\0";
  57
  58 static HKEY hEnumKey = NULL;
  59 static HKEY hClassKey = NULL;
  60
  61 static HANDLE hUserToken = NULL;
  62 static HANDLE hInstallEvent = NULL;
  63
  64
  65 /* FUNCTIONS *****************************************************************/
  66
  67 static DWORD WINAPI
  68 RpcServerThread(LPVOID lpParameter)
  69 {
  70     RPC_STATUS Status;
  71
  72     DPRINT("RpcServerThread() called\n");
  73
  74     Status = RpcServerUseProtseqEpW(L"ncacn_np",
  75                                     20,
  76                                     L"\\pipe\\umpnpmgr",
  77                                     NULL);  // Security descriptor
  78     if (Status != RPC_S_OK)
  79     {
  80         DPRINT1("RpcServerUseProtseqEpW() failed (Status %lx)\n", Status);
  81         return 0;
  82     }
  83
  84     Status = RpcServerRegisterIf(pnp_v1_0_s_ifspec,
  85                                  NULL,
  86                                  NULL);
  87     if (Status != RPC_S_OK)
  88     {
  89         DPRINT1("RpcServerRegisterIf() failed (Status %lx)\n", Status);
  90         return 0;
  91     }
  92
  93     Status = RpcServerListen(1,
  94                              20,
  95                              FALSE);
  96     if (Status != RPC_S_OK)
  97     {
  98         DPRINT1("RpcServerListen() failed (Status %lx)\n", Status);
  99         return 0;
 100     }
 101
 102     DPRINT("RpcServerThread() done\n");
 103
 104     return 0;
 105 }
 106
 107
 108 void __RPC_FAR * __RPC_USER midl_user_allocate(size_t len)
 109 {
 110     return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len);
 111 }
 112
 113
 114 void __RPC_USER midl_user_free(void __RPC_FAR * ptr)
 115 {
 116     HeapFree(GetProcessHeap(), 0, ptr);
 117 }
 118
 119
 120 static CONFIGRET WINAPI
 121 NtStatusToCrError(NTSTATUS Status)
 122 {
 123     switch (Status)
 124     {
 125         case STATUS_NO_SUCH_DEVICE:
 126             return CR_NO_SUCH_DEVINST;
 127
 128         default:
 129             /* FIXME: add more mappings */
 130             DPRINT1("Unable to map status 0x%08lx\n", Status);
 131             return CR_FAILURE;
 132     }
 133 }
 134
 135
 136 /* Function 2 */
 137 CONFIGRET
 138 PNP_GetVersion(handle_t BindingHandle,
 139                unsigned short *Version)
 140 {
 141     *Version = 0x0400;
 142     return CR_SUCCESS;
 143 }
 144
 145
 146 /* Function 3 */
 147 CONFIGRET
 148 PNP_GetGlobalState(handle_t BindingHandle,
 149                    unsigned long *State,
 150                    unsigned long Flags)
 151 {
 152     *State = CM_GLOBAL_STATE_CAN_DO_UI | CM_GLOBAL_STATE_SERVICES_AVAILABLE;
 153     return CR_SUCCESS;
 154 }
 155
 156
 157 /* Function 4 */
 158 CONFIGRET
 159 PNP_InitDetection(handle_t BindingHandle)
 160 {
 161     DPRINT("PNP_InitDetection() called\n");
 162     return CR_SUCCESS;
 163 }
 164
 165
 166 /* Function 5 */
 167 CONFIGRET
 168 PNP_ReportLogOn(handle_t BindingHandle,
 169                 unsigned long Admin,
 170                 unsigned long ProcessId)
 171 {
 172     HANDLE hProcess;
 173
 174     DPRINT1("PNP_ReportLogOn(%lu, %lu) called\n", Admin, ProcessId);
 175
 176     /* Get the users token */
 177     hProcess = OpenProcess(PROCESS_ALL_ACCESS,
 178                            TRUE,
 179                            ProcessId);
 180     if (hProcess != NULL)
 181     {
 182         if (hUserToken != NULL)
 183         {
 184             CloseHandle(hUserToken);
 185             hUserToken = NULL;
 186         }
 187
 188         OpenProcessToken(hProcess,
 189                          TOKEN_ALL_ACCESS,
 190                          &hUserToken);
 191         CloseHandle(hProcess);
 192     }
 193
 194     /* Trigger the installer thread */
 195     if (hInstallEvent != NULL)
 196         SetEvent(hInstallEvent);
 197
 198     return CR_SUCCESS;
 199 }
 200
 201
 202 /* Function 6 */
 203 CONFIGRET
 204 PNP_ValidateDeviceInstance(handle_t BindingHandle,
 205                            wchar_t *DeviceInstance,
 206                            unsigned long Flags)
 207 {
 208     CONFIGRET ret = CR_SUCCESS;
 209     HKEY hEnumKey = NULL;
 210     HKEY hDeviceKey = NULL;
 211
 212     DPRINT("PNP_ValidateDeviceInstance(%S %lx) called\n",
 213            DeviceInstance, Flags);
 214
 215     if (RegOpenKeyExW(HKEY_LOCAL_MACHINE,
 216                       L"System\\CurrentControlSet\\Enum",
 217                       0,
 218                       KEY_ALL_ACCESS,
 219                       &hEnumKey))
 220     {
 221         DPRINT("Could not open the Enum Key!\n");
 222         ret = CR_FAILURE;
 223         goto Done;
 224     }
 225
 226     if (RegOpenKeyExW(hEnumKey,
 227                       DeviceInstance,
 228                       0,
 229                       KEY_READ,
 230                       &hDeviceKey))
 231     {
 232         DPRINT("Could not open the Device Key!\n");
 233         ret = CR_NO_SUCH_DEVNODE;
 234         goto Done;
 235     }
 236
 237     /* FIXME: add more tests */
 238
 239 Done:
 240     if (hDeviceKey != NULL)
 241         RegCloseKey(hDeviceKey);
 242
 243     if (hEnumKey != NULL)
 244         RegCloseKey(hEnumKey);
 245
 246     DPRINT("PNP_ValidateDeviceInstance() done (returns %lx)\n", ret);
 247
 248     return ret;
 249 }
 250
 251
 252 /* Function 7 */
 253 CONFIGRET
 254 PNP_GetRootDeviceInstance(handle_t BindingHandle,
 255                           wchar_t *DeviceInstance,
 256                           unsigned long Length)
 257 {
 258     CONFIGRET ret = CR_SUCCESS;
 259
 260     DPRINT("PNP_GetRootDeviceInstance() called\n");
 261
 262     if (Length < lstrlenW(szRootDeviceId) + 1)
 263     {
 264         ret = CR_BUFFER_SMALL;
 265         goto Done;
 266     }
 267
 268     lstrcpyW(DeviceInstance,
 269              szRootDeviceId);
 270
 271 Done:
 272     DPRINT("PNP_GetRootDeviceInstance() done (returns %lx)\n", ret);
 273
 274     return ret;
 275 }
 276
 277
 278 /* Function 8 */
 279 CONFIGRET
 280 PNP_GetRelatedDeviceInstance(handle_t BindingHandle,
 281                              unsigned long Relationship,
 282                              wchar_t *DeviceId,
 283                              wchar_t *RelatedDeviceId,
 284                              unsigned long Length,
 285                              unsigned long Flags)
 286 {
 287     PLUGPLAY_CONTROL_RELATED_DEVICE_DATA PlugPlayData;
 288     CONFIGRET ret = CR_SUCCESS;
 289     NTSTATUS Status;
 290
 291     DPRINT("PNP_GetRelatedDeviceInstance() called\n");
 292     DPRINT("  Relationship %ld\n", Relationship);
 293     DPRINT("  DeviceId %S\n", DeviceId);
 294
 295     RtlInitUnicodeString(&PlugPlayData.TargetDeviceInstance,
 296                          DeviceId);
 297
 298     PlugPlayData.Relation = Relationship;
 299
 300     PlugPlayData.RelatedDeviceInstance.Length = 0;
 301     PlugPlayData.RelatedDeviceInstance.MaximumLength = Length;
 302     PlugPlayData.RelatedDeviceInstance.Buffer = RelatedDeviceId;
 303
 304     Status = NtPlugPlayControl(PlugPlayControlGetRelatedDevice,
 305                                (PVOID)&PlugPlayData,
 306                                sizeof(PLUGPLAY_CONTROL_RELATED_DEVICE_DATA));
 307     if (!NT_SUCCESS(Status))
 308     {
 309         ret = NtStatusToCrError(Status);
 310     }
 311
 312     DPRINT("PNP_GetRelatedDeviceInstance() done (returns %lx)\n", ret);
 313     if (ret == CR_SUCCESS)
 314     {
 315         DPRINT("RelatedDevice: %wZ\n", &PlugPlayData.RelatedDeviceInstance);
 316     }
 317
 318     return ret;
 319 }
 320
 321
 322 /* Function 9 */
 323 CONFIGRET
 324 PNP_EnumerateSubKeys(handle_t BindingHandle,
 325                      unsigned long Branch,
 326                      unsigned long Index,
 327                      wchar_t *Buffer,
 328                      unsigned long Length,
 329                      unsigned long *RequiredLength,
 330                      DWORD Flags)
 331 {
 332     CONFIGRET ret = CR_SUCCESS;
 333     HKEY hKey;
 334     DWORD dwError;
 335
 336     DPRINT("PNP_EnumerateSubKeys() called\n");
 337
 338     switch (Branch)
 339     {
 340         case PNP_BRANCH_ENUM:
 341             hKey = hEnumKey;
 342             break;
 343
 344         case PNP_BRANCH_CLASS:
 345             hKey = hClassKey;
 346             break;
 347
 348         default:
 349             return CR_FAILURE;
 350     }
 351
 352     *RequiredLength = Length;
 353     dwError = RegEnumKeyExW(hKey,
 354                             Index,
 355                             Buffer,
 356                             RequiredLength,
 357                             NULL,
 358                             NULL,
 359                             NULL,
 360                             NULL);
 361     if (dwError != ERROR_SUCCESS)
 362     {
 363         ret = (dwError == ERROR_NO_MORE_ITEMS) ? CR_NO_SUCH_VALUE : CR_FAILURE;
 364     }
 365     else
 366     {
 367         (*RequiredLength)++;
 368     }
 369
 370     DPRINT("PNP_EnumerateSubKeys() done (returns %lx)\n", ret);
 371
 372     return ret;
 373 }
 374
 375
 376 /* Function 11 */
 377 CONFIGRET
 378 PNP_GetDeviceListSize(handle_t BindingHandle,
 379                       wchar_t *Filter,
 380                       unsigned long *Length,
 381                       DWORD Flags)
 382 {
 383     DPRINT("PNP_GetDeviceListSize() called\n");
 384
 385     /* FIXME */
 386     *Length = 2;
 387
 388     return CR_SUCCESS;
 389 }
 390
 391
 392 /* Function 12 */
 393 CONFIGRET
 394 PNP_GetDepth(handle_t BindingHandle,
 395              wchar_t *DeviceInstance,
 396              unsigned long *Depth,
 397              DWORD Flags)
 398 {
 399     PLUGPLAY_CONTROL_DEPTH_DATA PlugPlayData;
 400     CONFIGRET ret = CR_SUCCESS;
 401     NTSTATUS Status;
 402
 403     DPRINT("PNP_GetDepth() called\n");
 404
 405     RtlInitUnicodeString(&PlugPlayData.DeviceInstance,
 406                          DeviceInstance);
 407
 408     Status = NtPlugPlayControl(PlugPlayControlGetDeviceDepth,
 409                                (PVOID)&PlugPlayData,
 410                                sizeof(PLUGPLAY_CONTROL_DEPTH_DATA));
 411     if (NT_SUCCESS(Status))
 412     {
 413         *Depth = PlugPlayData.Depth;
 414     }
 415     else
 416     {
 417         ret = NtStatusToCrError(Status);
 418     }
 419
 420     DPRINT("PNP_GetDepth() done (returns %lx)\n", ret);
 421
 422     return ret;
 423 }
 424
 425
 426 /* Function 13 */
 427 CONFIGRET
 428 PNP_GetDeviceRegProp(handle_t BindingHandle,
 429                      wchar_t *DeviceInstance,
 430                      unsigned long Property,
 431                      unsigned long *DataType,
 432                      char *Buffer,
 433                      unsigned long *TransferLen,
 434                      unsigned long *Length,
 435                      DWORD Flags)
 436 {
 437     PLUGPLAY_CONTROL_PROPERTY_DATA PlugPlayData;
 438     CONFIGRET ret = CR_SUCCESS;
 439     LPWSTR lpValueName = NULL;
 440     HKEY hKey = 0;
 441     NTSTATUS Status;
 442
 443     DPRINT("PNP_GetDeviceRegProp() called\n");
 444
 445     switch (Property)
 446     {
 447         case CM_DRP_DEVICEDESC:
 448             lpValueName = L"DeviceDesc";
 449             break;
 450
 451         case CM_DRP_HARDWAREID:
 452             lpValueName = L"HardwareID";
 453             break;
 454
 455         case CM_DRP_COMPATIBLEIDS:
 456             lpValueName = L"CompatibleIDs";
 457             break;
 458
 459         case CM_DRP_SERVICE:
 460             lpValueName = L"Service";
 461             break;
 462
 463         case CM_DRP_CLASS:
 464             lpValueName = L"Class";
 465             break;
 466
 467         case CM_DRP_CLASSGUID:
 468             lpValueName = L"ClassGUID";
 469             break;
 470
 471         case CM_DRP_DRIVER:
 472             lpValueName = L"Driver";
 473             break;
 474
 475         case CM_DRP_CONFIGFLAGS:
 476             lpValueName = L"ConfigFlags";
 477             break;
 478
 479         case CM_DRP_MFG:
 480             lpValueName = L"Mfg";
 481             break;
 482
 483         case CM_DRP_FRIENDLYNAME:
 484             lpValueName = L"FriendlyName";
 485             break;
 486
 487         case CM_DRP_LOCATION_INFORMATION:
 488             lpValueName = L"LocationInformation";
 489             break;
 490
 491         case CM_DRP_PHYSICAL_DEVICE_OBJECT_NAME:
 492             lpValueName = NULL;
 493             break;
 494
 495         case CM_DRP_CAPABILITIES:
 496             lpValueName = L"Capabilities";
 497             break;
 498
 499         case CM_DRP_UI_NUMBER:
 500             lpValueName = NULL;
 501             break;
 502
 503         case CM_DRP_UPPERFILTERS:
 504             lpValueName = L"UpperFilters";
 505             break;
 506
 507         case CM_DRP_LOWERFILTERS:
 508             lpValueName = L"LowerFilters";
 509             break;
 510
 511         case CM_DRP_BUSTYPEGUID:
 512             lpValueName = NULL;
 513             break;
 514
 515         case CM_DRP_LEGACYBUSTYPE:
 516             lpValueName = NULL;
 517             break;
 518
 519         case CM_DRP_BUSNUMBER:
 520             lpValueName = NULL;
 521             break;
 522
 523         case CM_DRP_ENUMERATOR_NAME:
 524             lpValueName = NULL;
 525             break;
 526
 527         default:
 528             return CR_INVALID_PROPERTY;
 529     }
 530
 531     DPRINT("Value name: %S\n", lpValueName);
 532
 533     if (lpValueName)
 534     {
 535         /* Retrieve information from the Registry */
 536         if (RegOpenKeyExW(hEnumKey,
 537                           DeviceInstance,
 538                           0,
 539                           KEY_ALL_ACCESS,
 540                           &hKey))
 541             return CR_INVALID_DEVNODE;
 542
 543         if (RegQueryValueExW(hKey,
 544                              lpValueName,
 545                              NULL,
 546                              DataType,
 547                              (LPBYTE)Buffer,
 548                              Length))
 549             ret = CR_REGISTRY_ERROR;
 550
 551         /* FIXME: Check buffer size */
 552
 553         RegCloseKey(hKey);
 554     }
 555     else
 556     {
 557         /* Retrieve information from the Device Node */
 558         RtlInitUnicodeString(&PlugPlayData.DeviceInstance,
 559                              DeviceInstance);
 560         PlugPlayData.Buffer = Buffer;
 561         PlugPlayData.BufferSize = *TransferLen;
 562
 563         switch (Property)
 564         {
 565 #if 0
 566             case CM_DRP_PHYSICAL_DEVICE_OBJECT_NAME:
 567                 PlugPlayData.Property = DevicePropertyPhysicalDeviceObjectName;
 568                 break;
 569
 570             case CM_DRP_UI_NUMBER:
 571                 PlugPlayData.Property = DevicePropertyUINumber;
 572                 break;
 573
 574             case CM_DRP_BUSTYPEGUID:
 575                 PlugPlayData.Property = DevicePropertyBusTypeGuid;
 576                 break;
 577
 578             case CM_DRP_LEGACYBUSTYPE:
 579                 PlugPlayData.Property = DevicePropertyLegacyBusType;
 580                 break;
 581
 582             case CM_DRP_BUSNUMBER:
 583                 PlugPlayData.Property = DevicePropertyBusNumber;
 584                 break;
 585
 586             case CM_DRP_ENUMERATOR_NAME:
 587                 PlugPlayData.Property = DevicePropertyEnumeratorName;
 588                 break;
 589 #endif
 590
 591             default:
 592                 return CR_INVALID_PROPERTY;
 593         }
 594
 595         Status = NtPlugPlayControl(PlugPlayControlProperty,
 596                                    (PVOID)&PlugPlayData,
 597                                    sizeof(PLUGPLAY_CONTROL_PROPERTY_DATA));
 598         if (NT_SUCCESS(Status))
 599         {
 600             *Length = PlugPlayData.BufferSize;
 601         }
 602         else
 603         {
 604             ret = NtStatusToCrError(Status);
 605         }
 606     }
 607
 608     DPRINT("PNP_GetDeviceRegProp() done (returns %lx)\n", ret);
 609
 610     return ret;
 611 }
 612
 613
 614 /* Function 14 */
 615 CONFIGRET
 616 PNP_SetDeviceRegProp(handle_t BindingHandle,
 617                      wchar_t *DeviceId,
 618                      unsigned long Property,
 619                      unsigned long DataType,
 620                      char *Buffer,
 621                      unsigned long Length,
 622                      unsigned long Flags)
 623 {
 624     CONFIGRET ret = CR_SUCCESS;
 625     LPWSTR lpValueName = NULL;
 626     HKEY hKey = 0;
 627
 628     DPRINT("PNP_SetDeviceRegProp() called\n");
 629
 630     DPRINT("DeviceId: %S\n", DeviceId);
 631     DPRINT("Property: %lu\n", Property);
 632     DPRINT("DataType: %lu\n", DataType);
 633     DPRINT("Length: %lu\n", Length);
 634
 635     switch (Property)
 636     {
 637         case CM_DRP_DEVICEDESC:
 638             lpValueName = L"DeviceDesc";
 639             break;
 640
 641         case CM_DRP_HARDWAREID:
 642             lpValueName = L"HardwareID";
 643             break;
 644
 645         case CM_DRP_COMPATIBLEIDS:
 646             lpValueName = L"CompatibleIDs";
 647             break;
 648
 649         case CM_DRP_SERVICE:
 650             lpValueName = L"Service";
 651             break;
 652
 653         case CM_DRP_CLASS:
 654             lpValueName = L"Class";
 655             break;
 656
 657         case CM_DRP_CLASSGUID:
 658             lpValueName = L"ClassGUID";
 659             break;
 660
 661         case CM_DRP_DRIVER:
 662             lpValueName = L"Driver";
 663             break;
 664
 665         case CM_DRP_CONFIGFLAGS:
 666             lpValueName = L"ConfigFlags";
 667             break;
 668
 669         case CM_DRP_MFG:
 670             lpValueName = L"Mfg";
 671             break;
 672
 673         case CM_DRP_FRIENDLYNAME:
 674             lpValueName = L"FriendlyName";
 675             break;
 676
 677         case CM_DRP_LOCATION_INFORMATION:
 678             lpValueName = L"LocationInformation";
 679             break;
 680
 681         case CM_DRP_UPPERFILTERS:
 682             lpValueName = L"UpperFilters";
 683             break;
 684
 685         case CM_DRP_LOWERFILTERS:
 686             lpValueName = L"LowerFilters";
 687             break;
 688
 689         default:
 690             return CR_INVALID_PROPERTY;
 691     }
 692
 693     DPRINT("Value name: %S\n", lpValueName);
 694
 695     if (RegOpenKeyExW(hEnumKey,
 696                       DeviceId,
 697                       0,
 698                       KEY_ALL_ACCESS,
 699                       &hKey))
 700         return CR_INVALID_DEVNODE;
 701
 702     if (Length == 0)
 703     {
 704         if (RegDeleteValueW(hKey,
 705                             lpValueName))
 706             ret = CR_REGISTRY_ERROR;
 707     }
 708     else
 709     {
 710         if (RegSetValueExW(hKey,
 711                            lpValueName,
 712                            0,
 713                            DataType,
 714                            (const BYTE*)Buffer,
 715                            Length))
 716             ret = CR_REGISTRY_ERROR;
 717     }
 718
 719     RegCloseKey(hKey);
 720
 721     DPRINT("PNP_SetDeviceRegProp() done (returns %lx)\n", ret);
 722
 723     return ret;
 724 }
 725
 726
 727 /* Function 15 */
 728 CONFIGRET
 729 PNP_GetClassInstance(handle_t BindingHandle,
 730                      wchar_t *DeviceId, /* in */
 731                      wchar_t *Buffer, /* out */
 732                      unsigned long Length)
 733 {
 734     CONFIGRET ret = CR_SUCCESS;
 735
 736     DPRINT("PNP_Get_Class_Instance() called\n");
 737
 738     DPRINT("PNP_Get_Class_Instance() done (returns %lx)\n", ret);
 739
 740     return ret;
 741 }
 742
 743
 744 /* Function 16 */
 745 CONFIGRET
 746 PNP_CreateKey(handle_t BindingHandle,
 747               wchar_t *SubKey,
 748               unsigned long samDesired,
 749               unsigned long Flags)
 750 {
 751     CONFIGRET ret = CR_SUCCESS;
 752
 753     DPRINT("PNP_CreateKey() called\n");
 754
 755     DPRINT("PNP_CreateKey() done (returns %lx)\n", ret);
 756
 757     return ret;
 758 }
 759
 760
 761 /* Function 17 */
 762 CONFIGRET
 763 PNP_DeleteRegistryKey(handle_t BindingHandle,
 764                       wchar_t *DeviceId,
 765                       wchar_t *ParentKey,
 766                       wchar_t *ChildKey,
 767                       unsigned long Flags)
 768 {
 769     CONFIGRET ret = CR_SUCCESS;
 770
 771     DPRINT("PNP_DeleteRegistryKey() called\n");
 772
 773     DPRINT("PNP_DeleteRegistryKey() done (returns %lx)\n", ret);
 774
 775     return ret;
 776 }
 777
 778
 779 /* Function 18 */
 780 #if 0
 781 CONFIGRET
 782 PNP_GetClassCount(handle_t BindingHandle,
 783                   unsigned long *ClassCount,
 784                   unsigned long Flags)
 785 {
 786     HANDLE hKey = NULL;
 787     DWORD dwError;
 788
 789     dwError = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
 790                             pszRegPathClass,
 791                             0,
 792                             KEY_QUERY_VALUE,
 793                             &hKey);
 794     if (dwError != ERROR_SUCCESS)
 795         return CR_INVALID_DATA;
 796
 797     dwError = RegQueryInfoKeyW(hKey,
 798                                NULL,
 799                                NULL,
 800                                NULL,
 801                                &ClassCount,
 802                                NULL,
 803                                NULL,
 804                                NULL,
 805                                NULL,
 806                                NULL,
 807                                NULL,
 808                                NULL);
 809     RegCloseKey(hKey);
 810     if (dwError != ERROR_SUCCESS)
 811         return CR_INVALID_DATA;
 812
 813     return CR_SUCCESS;
 814 }
 815 #endif
 816
 817
 818 /* Function 19 */
 819 CONFIGRET
 820 PNP_GetClassName(handle_t BindingHandle,
 821                  wchar_t *ClassGuid,
 822                  wchar_t *Buffer,
 823                  unsigned long *Length,
 824                  unsigned long Flags)
 825 {
 826     WCHAR szKeyName[MAX_PATH];
 827     CONFIGRET ret = CR_SUCCESS;
 828     HKEY hKey = NULL;
 829     ULONG ulSize;
 830
 831     DPRINT("PNP_GetClassName() called\n");
 832
 833     lstrcpyW(szKeyName, L"System\\CurrentControlSet\\Control\\Class");
 834     lstrcatW(szKeyName, L"\\");
 835     lstrcatW(szKeyName, ClassGuid);
 836
 837     if (RegOpenKeyExW(HKEY_LOCAL_MACHINE,
 838                       szKeyName,
 839                       0,
 840                       KEY_QUERY_VALUE,
 841                       &hKey))
 842         return CR_REGISTRY_ERROR;
 843
 844     ulSize = *Length * sizeof(WCHAR);
 845     if (RegQueryValueExW(hKey,
 846                          L"Class",
 847                          NULL,
 848                          NULL,
 849                          (LPBYTE)Buffer,
 850                          &ulSize))
 851     {
 852         *Length = 0;
 853         ret = CR_REGISTRY_ERROR;
 854     }
 855     else
 856     {
 857         *Length = ulSize / sizeof(WCHAR);
 858     }
 859
 860     RegCloseKey(hKey);
 861
 862     DPRINT("PNP_GetClassName() done (returns %lx)\n", ret);
 863
 864     return ret;
 865 }
 866
 867
 868 /* Function 20 */
 869 CONFIGRET
 870 PNP_DeleteClassKey(handle_t BindingHandle,
 871                    wchar_t *ClassGuid,
 872                    unsigned long Flags)
 873 {
 874     CONFIGRET ret = CR_SUCCESS;
 875
 876     DPRINT("PNP_GetClassName(%S, %lx) called\n", ClassGuid, Flags);
 877
 878     if (Flags & CM_DELETE_CLASS_SUBKEYS)
 879     {
 880         if (RegDeleteTreeW(hClassKey, ClassGuid) != ERROR_SUCCESS)
 881             ret = CR_REGISTRY_ERROR;
 882     }
 883     else
 884     {
 885         if (RegDeleteKeyW(hClassKey, ClassGuid) != ERROR_SUCCESS)
 886             ret = CR_REGISTRY_ERROR;
 887     }
 888
 889     DPRINT("PNP_DeleteClassKey() done (returns %lx)\n", ret);
 890
 891     return ret;
 892 }
 893
 894
 895 /* Function 29 */
 896 CONFIGRET
 897 PNP_DeviceInstanceAction(handle_t BindingHandle,
 898                          unsigned long MajorAction,
 899                          unsigned long MinorAction,
 900                          wchar_t *DeviceInstance1,
 901                          wchar_t *DeviceInstance2)
 902 {
 903     CONFIGRET ret = CR_SUCCESS;
 904
 905     DPRINT("PNP_DeviceInstanceAction() called\n");
 906
 907     switch (MajorAction)
 908     {
 909         case 2:
 910             DPRINT("Move device instance\n");
 911             /* FIXME */
 912             ret = CR_CALL_NOT_IMPLEMENTED;
 913             break;
 914
 915         case 3:
 916             DPRINT("Setup device instance\n");
 917             /* FIXME */
 918             ret = CR_CALL_NOT_IMPLEMENTED;
 919             break;
 920
 921         case 4:
 922             DPRINT("Enable device instance\n");
 923             /* FIXME */
 924             ret = CR_CALL_NOT_IMPLEMENTED;
 925             break;
 926
 927         case 5:
 928             DPRINT("Disable device instance\n");
 929             /* FIXME */
 930             ret = CR_CALL_NOT_IMPLEMENTED;
 931             break;
 932
 933         case 7:
 934             DPRINT("Reenumerate device instance\n");
 935             /* FIXME */
 936             ret = CR_CALL_NOT_IMPLEMENTED;
 937             break;
 938
 939         default:
 940             DPRINT1("Unknown function %lu\n", MajorAction);
 941             ret = CR_CALL_NOT_IMPLEMENTED;
 942     }
 943
 944     DPRINT("PNP_DeviceInstanceAction() done (returns %lx)\n", ret);
 945
 946     return ret;
 947 }
 948
 949
 950 /* Function 30 */
 951 CONFIGRET
 952 PNP_GetDeviceStatus(handle_t BindingHandle,
 953                     wchar_t *DeviceInstance,
 954                     unsigned long *pStatus,
 955                     unsigned long *pProblem,
 956                     DWORD Flags)
 957 {
 958     PLUGPLAY_CONTROL_STATUS_DATA PlugPlayData;
 959     CONFIGRET ret = CR_SUCCESS;
 960     NTSTATUS Status;
 961
 962     DPRINT("PNP_GetDeviceStatus() called\n");
 963
 964     RtlInitUnicodeString(&PlugPlayData.DeviceInstance,
 965                          DeviceInstance);
 966     PlugPlayData.Operation = 0; /* Get status */
 967
 968     Status = NtPlugPlayControl(PlugPlayControlDeviceStatus,
 969                                (PVOID)&PlugPlayData,
 970                                sizeof(PLUGPLAY_CONTROL_STATUS_DATA));
 971     if (NT_SUCCESS(Status))
 972     {
 973         *pStatus = PlugPlayData.DeviceStatus;
 974         *pProblem = PlugPlayData.DeviceProblem;
 975     }
 976     else
 977     {
 978         ret = NtStatusToCrError(Status);
 979     }
 980
 981     DPRINT("PNP_GetDeviceStatus() done (returns %lx)\n", ret);
 982
 983     return ret;
 984 }
 985
 986
 987 /* Function 31 */
 988 CONFIGRET
 989 PNP_SetDeviceProblem(handle_t BindingHandle,
 990                      wchar_t *DeviceInstance,
 991                      unsigned long Problem,
 992                      DWORD Flags)
 993 {
 994     CONFIGRET ret = CR_SUCCESS;
 995
 996     DPRINT1("PNP_SetDeviceProblem() called\n");
 997
 998     /* FIXME */
 999
1000     DPRINT1("PNP_SetDeviceProblem() done (returns %lx)\n", ret);
1001
1002     return ret;
1003 }
1004
1005
1006 /* Function 33 */
1007 CONFIGRET
1008 PNP_UninstallDevInst(handle_t BindingHandle,
1009                      wchar_t *DeviceInstance,
1010                      DWORD Flags)
1011 {
1012     CONFIGRET ret = CR_SUCCESS;
1013
1014     DPRINT1("PNP_UninstallDevInst() called\n");
1015
1016     /* FIXME */
1017
1018     DPRINT1("PNP_UninstallDevInst() done (returns %lx)\n", ret);
1019
1020     return ret;
1021 }
1022
1023
1024 /* Function 38 */
1025 CONFIGRET
1026 PNP_IsDockStationPresent(handle_t BindingHandle,
1027                          unsigned long *Present)
1028 {
1029     HKEY hKey;
1030     DWORD dwType;
1031     DWORD dwValue;
1032     DWORD dwSize;
1033     CONFIGRET ret = CR_SUCCESS;
1034
1035     DPRINT1("PNP_IsDockStationPresent() called\n");
1036
1037     *Present = FALSE;
1038
1039     if (RegOpenKeyExW(HKEY_CURRENT_CONFIG,
1040                       L"CurrentDockInfo",
1041                       0,
1042                       KEY_READ,
1043                       &hKey) != ERROR_SUCCESS)
1044         return CR_REGISTRY_ERROR;
1045
1046     dwSize = sizeof(DWORD);
1047     if (RegQueryValueExW(hKey,
1048                          L"DockingState",
1049                          NULL,
1050                          &dwType,
1051                          (LPBYTE)&dwValue,
1052                          &dwSize) != ERROR_SUCCESS)
1053         ret = CR_REGISTRY_ERROR;
1054
1055     RegCloseKey(hKey);
1056
1057     if (ret == CR_SUCCESS)
1058     {
1059         if (dwType != REG_DWORD || dwSize != sizeof(DWORD))
1060         {
1061             ret = CR_REGISTRY_ERROR;
1062         }
1063         else if (dwValue != 0)
1064         {
1065             *Present = TRUE;
1066         }
1067     }
1068
1069     DPRINT1("PNP_IsDockStationPresent() done (returns %lx)\n", ret);
1070
1071     return ret;
1072 }
1073
1074
1075 /* Function 39 */
1076 CONFIGRET
1077 PNP_RequestEjectPC(handle_t BindingHandle)
1078 {
1079     CONFIGRET ret = CR_SUCCESS;
1080
1081     DPRINT1("PNP_RequestEjectPC() called\n");
1082
1083     ret = CR_FAILURE; /* FIXME */
1084
1085     DPRINT1("PNP_RequestEjectPC() done (returns %lx)\n", ret);
1086
1087     return ret;
1088 }
1089
1090
1091 /* Function 58 */
1092 CONFIGRET
1093 PNP_RunDetection(handle_t BindingHandle,
1094                  unsigned long Flags)
1095 {
1096     DPRINT("PNP_RunDetection() called\n");
1097     return CR_CALL_NOT_IMPLEMENTED;
1098 }
1099
1100
1101 typedef BOOL (WINAPI *PDEV_INSTALL_W)(HWND, HINSTANCE, LPCWSTR, INT);
1102
1103 static BOOL
1104 InstallDevice(PCWSTR DeviceInstance, BOOL SetupIsActive)
1105 {
1106     PLUGPLAY_CONTROL_STATUS_DATA PlugPlayData;
1107     HMODULE hNewDev = NULL;
1108     PDEV_INSTALL_W DevInstallW;
1109     NTSTATUS Status;
1110     BOOL DeviceInstalled = FALSE;
1111
1112     RtlInitUnicodeString(&PlugPlayData.DeviceInstance,
1113                          DeviceInstance);
1114     PlugPlayData.Operation = 0; /* Get status */
1115
1116     /* Get device status */
1117     Status = NtPlugPlayControl(PlugPlayControlDeviceStatus,
1118                                (PVOID)&PlugPlayData,
1119                                sizeof(PLUGPLAY_CONTROL_STATUS_DATA));
1120     if (!NT_SUCCESS(Status))
1121         return FALSE;
1122
1123     if (PlugPlayData.DeviceStatus & DNF_STARTED || PlugPlayData.DeviceStatus & DNF_START_FAILED)
1124         /* Device is already started, or disabled due to some problem. Don't install it */
1125         return TRUE;
1126
1127     /* Install device */
1128     SetEnvironmentVariable(L"USERPROFILE", L"."); /* FIXME: why is it needed? */
1129
1130     hNewDev = LoadLibraryW(L"newdev.dll");
1131     if (!hNewDev)
1132         goto cleanup;
1133
1134     DevInstallW = (PDEV_INSTALL_W)GetProcAddress(hNewDev, (LPCSTR)"DevInstallW");
1135     if (!DevInstallW)
1136         goto cleanup;
1137
1138     if (!DevInstallW(NULL, NULL, DeviceInstance, SetupIsActive ? SW_HIDE : SW_SHOWNOACTIVATE))
1139         goto cleanup;
1140
1141     DeviceInstalled = TRUE;
1142
1143 cleanup:
1144     if (hNewDev != NULL)
1145         FreeLibrary(hNewDev);
1146
1147     return DeviceInstalled;
1148 }
1149
1150
1151 static BOOL
1152 SetupIsActive(VOID)
1153 {
1154     HKEY hKey = INVALID_HANDLE_VALUE;
1155     DWORD regType, active, size;
1156     LONG rc;
1157     BOOL ret = FALSE;
1158
1159     rc = RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"SYSTEM\\Setup", 0, KEY_QUERY_VALUE, &hKey);
1160     if (rc != ERROR_SUCCESS)
1161         goto cleanup;
1162
1163     size = sizeof(DWORD);
1164     rc = RegQueryValueExW(hKey, L"SystemSetupInProgress", NULL, &regType, (LPBYTE)&active, &size);
1165     if (rc != ERROR_SUCCESS)
1166         goto cleanup;
1167     if (regType != REG_DWORD || size != sizeof(DWORD))
1168         goto cleanup;
1169
1170     ret = (active != 0);
1171
1172 cleanup:
1173     if (hKey != INVALID_HANDLE_VALUE)
1174         RegCloseKey(hKey);
1175
1176     DPRINT("System setup in progress? %S\n", ret ? L"YES" : L"NO");
1177
1178     return ret;
1179 }
1180
1181
1182 static DWORD WINAPI
1183 PnpEventThread(LPVOID lpParameter)
1184 {
1185     PPLUGPLAY_EVENT_BLOCK PnpEvent;
1186     ULONG PnpEventSize;
1187     NTSTATUS Status;
1188     RPC_STATUS RpcStatus;
1189     BOOL setupActive;
1190
1191     PnpEventSize = 0x1000;
1192     PnpEvent = HeapAlloc(GetProcessHeap(), 0, PnpEventSize);
1193     if (PnpEvent == NULL)
1194         return ERROR_OUTOFMEMORY;
1195
1196     setupActive = SetupIsActive();
1197
1198     for (;;)
1199     {
1200         DPRINT("Calling NtGetPlugPlayEvent()\n");
1201
1202         /* Wait for the next pnp event */
1203         Status = NtGetPlugPlayEvent(0, 0, PnpEvent, PnpEventSize);
1204
1205         /* Resize the buffer for the PnP event if it's too small. */
1206         if (Status == STATUS_BUFFER_TOO_SMALL)
1207         {
1208             PnpEventSize += 0x400;
1209             PnpEvent = HeapReAlloc(GetProcessHeap(), 0, PnpEvent, PnpEventSize);
1210             if (PnpEvent == NULL)
1211                 return ERROR_OUTOFMEMORY;
1212             continue;
1213         }
1214
1215         if (!NT_SUCCESS(Status))
1216         {
1217             DPRINT("NtPlugPlayEvent() failed (Status %lx)\n", Status);
1218             break;
1219         }
1220
1221         DPRINT("Received PnP Event\n");
1222         if (UuidEqual(&PnpEvent->EventGuid, (UUID*)&GUID_DEVICE_ARRIVAL, &RpcStatus))
1223         {
1224             DPRINT("Device arrival event: %S\n", PnpEvent->TargetDevice.DeviceIds);
1225             InstallDevice(PnpEvent->TargetDevice.DeviceIds, setupActive);
1226         }
1227         else
1228         {
1229             DPRINT1("Unknown event\n");
1230         }
1231
1232         /* FIXME: Process the pnp event */
1233
1234         /* Dequeue the current pnp event and signal the next one */
1235         NtPlugPlayControl(PlugPlayControlUserResponse, NULL, 0);
1236     }
1237
1238     HeapFree(GetProcessHeap(), 0, PnpEvent);
1239
1240     return ERROR_SUCCESS;
1241 }
1242
1243
1244 static VOID CALLBACK
1245 ServiceMain(DWORD argc, LPTSTR *argv)
1246 {
1247     HANDLE hThread;
1248     DWORD dwThreadId;
1249
1250     DPRINT("ServiceMain() called\n");
1251
1252     hThread = CreateThread(NULL,
1253                            0,
1254                            PnpEventThread,
1255                            NULL,
1256                            0,
1257                            &dwThreadId);
1258     if (hThread != NULL)
1259         CloseHandle(hThread);
1260
1261     hThread = CreateThread(NULL,
1262                            0,
1263                            RpcServerThread,
1264                            NULL,
1265                            0,
1266                            &dwThreadId);
1267     if (hThread != NULL)
1268         CloseHandle(hThread);
1269
1270     DPRINT("ServiceMain() done\n");
1271 }
1272
1273
1274 int
1275 main(int argc, char *argv[])
1276 {
1277     DWORD dwError;
1278
1279     DPRINT("Umpnpmgr: main() started\n");
1280
1281     hInstallEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
1282     if (hInstallEvent == NULL)
1283     {
1284         dwError = GetLastError();
1285         DPRINT1("Could not create the Install Event! (Error %lu)\n", dwError);
1286         return dwError;
1287     }
1288
1289     dwError = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
1290                             L"System\\CurrentControlSet\\Enum",
1291                             0,
1292                             KEY_ALL_ACCESS,
1293                             &hEnumKey);
1294     if (dwError != ERROR_SUCCESS)
1295     {
1296         DPRINT1("Could not open the Enum Key! (Error %lu)\n", dwError);
1297         return dwError;
1298     }
1299
1300     dwError = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
1301                             L"System\\CurrentControlSet\\Control\\Class",
1302                             0,
1303                             KEY_ALL_ACCESS,
1304                             &hClassKey);
1305     if (dwError != ERROR_SUCCESS)
1306     {
1307         DPRINT1("Could not open the Class Key! (Error %lu)\n", dwError);
1308         return dwError;
1309     }
1310
1311     StartServiceCtrlDispatcher(ServiceTable);
1312
1313     DPRINT("Umpnpmgr: main() done\n");
1314
1315     ExitThread(0);
1316
1317     return 0;
1318 }
1319
1320 /* EOF */