reactos/base/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 along
  16  *  with this program; if not, write to the Free Software Foundation, Inc.,
  17  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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  *                   Colin Finck (colin@reactos.org)
  27  */
  28
  29 /* INCLUDES *****************************************************************/
  30 //#define HAVE_SLIST_ENTRY_IMPLEMENTED
  31 #define WIN32_NO_STATUS
  32 #include <windows.h>
  33 #include <stdio.h>
  34 #include <cmtypes.h>
  35 #include <cmfuncs.h>
  36 #include <rtlfuncs.h>
  37 #include <setypes.h>
  38 #include <umpnpmgr/sysguid.h>
  39 #include <wdmguid.h>
  40 #include <cfgmgr32.h>
  41 #include <regstr.h>
  42 #include <userenv.h>
  43
  44 #include <rpc.h>
  45 #include <rpcdce.h>
  46
  47 #include "pnp_s.h"
  48
  49 #define NDEBUG
  50 #include <debug.h>
  51
  52 /* GLOBALS ******************************************************************/
  53
  54 static VOID CALLBACK
  55 ServiceMain(DWORD argc, LPTSTR *argv);
  56
  57 static SERVICE_TABLE_ENTRY ServiceTable[2] =
  58 {
  59     {TEXT("PlugPlay"), ServiceMain},
  60     {NULL, NULL}
  61 };
  62
  63 static WCHAR szRootDeviceId[] = L"HTREE\\ROOT\\0";
  64
  65 static HKEY hEnumKey = NULL;
  66 static HKEY hClassKey = NULL;
  67
  68 static HANDLE hUserToken = NULL;
  69 static HANDLE hInstallEvent = NULL;
  70 static HANDLE hNoPendingInstalls = NULL;
  71
  72 #ifdef HAVE_SLIST_ENTRY_IMPLEMENTED
  73 static SLIST_HEADER DeviceInstallListHead;
  74 #else
  75 static LIST_ENTRY DeviceInstallListHead;
  76 #endif
  77 static HANDLE hDeviceInstallListNotEmpty;
  78
  79 typedef struct
  80 {
  81 #ifdef HAVE_SLIST_ENTRY_IMPLEMENTED
  82     SLIST_ENTRY ListEntry;
  83 #else
  84     LIST_ENTRY ListEntry;
  85 #endif
  86     WCHAR DeviceIds[1];
  87 } DeviceInstallParams;
  88
  89 /* FUNCTIONS *****************************************************************/
  90
  91 static DWORD WINAPI
  92 RpcServerThread(LPVOID lpParameter)
  93 {
  94     RPC_STATUS Status;
  95
  96     UNREFERENCED_PARAMETER(lpParameter);
  97
  98     DPRINT("RpcServerThread() called\n");
  99
 100     Status = RpcServerUseProtseqEpW(L"ncacn_np",
 101                                     20,
 102                                     L"\\pipe\\umpnpmgr",
 103                                     NULL);  // Security descriptor
 104     if (Status != RPC_S_OK)
 105     {
 106         DPRINT1("RpcServerUseProtseqEpW() failed (Status %lx)\n", Status);
 107         return 0;
 108     }
 109
 110     Status = RpcServerRegisterIf(pnp_v1_0_s_ifspec,
 111                                  NULL,
 112                                  NULL);
 113     if (Status != RPC_S_OK)
 114     {
 115         DPRINT1("RpcServerRegisterIf() failed (Status %lx)\n", Status);
 116         return 0;
 117     }
 118
 119     Status = RpcServerListen(1,
 120                              20,
 121                              FALSE);
 122     if (Status != RPC_S_OK)
 123     {
 124         DPRINT1("RpcServerListen() failed (Status %lx)\n", Status);
 125         return 0;
 126     }
 127
 128     /* ROS HACK (this should never happen...) */
 129     DPRINT1("*** Other devices won't be installed correctly. If something\n");
 130     DPRINT1("*** doesn't work, try to reboot to get a new chance.\n");
 131
 132     DPRINT("RpcServerThread() done\n");
 133
 134     return 0;
 135 }
 136
 137
 138 void __RPC_FAR * __RPC_USER midl_user_allocate(SIZE_T len)
 139 {
 140     return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len);
 141 }
 142
 143
 144 void __RPC_USER midl_user_free(void __RPC_FAR * ptr)
 145 {
 146     HeapFree(GetProcessHeap(), 0, ptr);
 147 }
 148
 149
 150 static CONFIGRET WINAPI
 151 NtStatusToCrError(NTSTATUS Status)
 152 {
 153     switch (Status)
 154     {
 155         case STATUS_NO_SUCH_DEVICE:
 156             return CR_NO_SUCH_DEVINST;
 157
 158         default:
 159             /* FIXME: add more mappings */
 160             DPRINT1("Unable to map status 0x%08lx\n", Status);
 161             return CR_FAILURE;
 162     }
 163 }
 164
 165
 166 /* Function 0 */
 167 DWORD PNP_Disconnect(
 168     handle_t hBinding)
 169 {
 170     UNREFERENCED_PARAMETER(hBinding);
 171     UNIMPLEMENTED;
 172     return CR_CALL_NOT_IMPLEMENTED;
 173 }
 174
 175
 176 /* Function 1 */
 177 DWORD PNP_Connect(
 178     handle_t hBinding)
 179 {
 180     UNREFERENCED_PARAMETER(hBinding);
 181     UNIMPLEMENTED;
 182     return CR_CALL_NOT_IMPLEMENTED;
 183 }
 184
 185
 186 /* Function 2 */
 187 DWORD PNP_GetVersion(
 188     handle_t hBinding,
 189     WORD *pVersion)
 190 {
 191     UNREFERENCED_PARAMETER(hBinding);
 192
 193     *pVersion = 0x0400;
 194     return CR_SUCCESS;
 195 }
 196
 197
 198 /* Function 3 */
 199 DWORD PNP_GetGlobalState(
 200     handle_t hBinding,
 201     DWORD *pulState,
 202     DWORD ulFlags)
 203 {
 204     UNREFERENCED_PARAMETER(hBinding);
 205     UNREFERENCED_PARAMETER(ulFlags);
 206
 207     *pulState = CM_GLOBAL_STATE_CAN_DO_UI | CM_GLOBAL_STATE_SERVICES_AVAILABLE;
 208     return CR_SUCCESS;
 209 }
 210
 211
 212 /* Function 4 */
 213 DWORD PNP_InitDetection(
 214     handle_t hBinding)
 215 {
 216     UNREFERENCED_PARAMETER(hBinding);
 217
 218     DPRINT("PNP_InitDetection() called\n");
 219     return CR_SUCCESS;
 220 }
 221
 222
 223 /* Function 5 */
 224 DWORD PNP_ReportLogOn(
 225     handle_t hBinding,
 226     BOOL Admin,
 227     DWORD ProcessId)
 228 {
 229     DWORD ReturnValue = CR_FAILURE;
 230     HANDLE hProcess;
 231
 232     UNREFERENCED_PARAMETER(hBinding);
 233     UNREFERENCED_PARAMETER(Admin);
 234
 235     DPRINT("PNP_ReportLogOn(%u, %u) called\n", Admin, ProcessId);
 236
 237     /* Get the users token */
 238     hProcess = OpenProcess(PROCESS_ALL_ACCESS, TRUE, ProcessId);
 239
 240     if(!hProcess)
 241     {
 242         DPRINT1("OpenProcess failed with error %u\n", GetLastError());
 243         goto cleanup;
 244     }
 245
 246     if (hUserToken)
 247     {
 248         CloseHandle(hUserToken);
 249         hUserToken = NULL;
 250     }
 251
 252     if(!OpenProcessToken(hProcess, TOKEN_ASSIGN_PRIMARY | TOKEN_DUPLICATE | TOKEN_QUERY, &hUserToken))
 253     {
 254         DPRINT1("OpenProcessToken failed with error %u\n", GetLastError());
 255         goto cleanup;
 256     }
 257
 258     /* Trigger the installer thread */
 259     if (hInstallEvent)
 260         SetEvent(hInstallEvent);
 261
 262     ReturnValue = CR_SUCCESS;
 263
 264 cleanup:
 265     if(hProcess)
 266         CloseHandle(hProcess);
 267
 268     return ReturnValue;
 269 }
 270
 271
 272 /* Function 6 */
 273 DWORD PNP_ValidateDeviceInstance(
 274     handle_t hBinding,
 275     LPWSTR pDeviceID,
 276     DWORD ulFlags)
 277 {
 278     CONFIGRET ret = CR_SUCCESS;
 279     HKEY hDeviceKey = NULL;
 280
 281     UNREFERENCED_PARAMETER(hBinding);
 282     UNREFERENCED_PARAMETER(ulFlags);
 283
 284     DPRINT("PNP_ValidateDeviceInstance(%S %lx) called\n",
 285            pDeviceID, ulFlags);
 286
 287     if (RegOpenKeyExW(hEnumKey,
 288                       pDeviceID,
 289                       0,
 290                       KEY_READ,
 291                       &hDeviceKey))
 292     {
 293         DPRINT("Could not open the Device Key!\n");
 294         ret = CR_NO_SUCH_DEVNODE;
 295         goto Done;
 296     }
 297
 298     /* FIXME: add more tests */
 299
 300 Done:
 301     if (hDeviceKey != NULL)
 302         RegCloseKey(hDeviceKey);
 303
 304     DPRINT("PNP_ValidateDeviceInstance() done (returns %lx)\n", ret);
 305
 306     return ret;
 307 }
 308
 309
 310 /* Function 7 */
 311 DWORD PNP_GetRootDeviceInstance(
 312     handle_t hBinding,
 313     LPWSTR pDeviceID,
 314     PNP_RPC_STRING_LEN ulLength)
 315 {
 316     CONFIGRET ret = CR_SUCCESS;
 317
 318     UNREFERENCED_PARAMETER(hBinding);
 319
 320     DPRINT("PNP_GetRootDeviceInstance() called\n");
 321
 322     if (!pDeviceID)
 323     {
 324         ret = CR_INVALID_POINTER;
 325         goto Done;
 326     }
 327     if (ulLength < lstrlenW(szRootDeviceId) + 1)
 328     {
 329         ret = CR_BUFFER_SMALL;
 330         goto Done;
 331     }
 332
 333     lstrcpyW(pDeviceID,
 334              szRootDeviceId);
 335
 336 Done:
 337     DPRINT("PNP_GetRootDeviceInstance() done (returns %lx)\n", ret);
 338
 339     return ret;
 340 }
 341
 342
 343 /* Function 8 */
 344 DWORD PNP_GetRelatedDeviceInstance(
 345     handle_t hBinding,
 346     DWORD ulRelationship,
 347     LPWSTR pDeviceID,
 348     LPWSTR pRelatedDeviceId,
 349     PNP_RPC_STRING_LEN *pulLength,
 350     DWORD ulFlags)
 351 {
 352     PLUGPLAY_CONTROL_RELATED_DEVICE_DATA PlugPlayData;
 353     CONFIGRET ret = CR_SUCCESS;
 354     NTSTATUS Status;
 355
 356     UNREFERENCED_PARAMETER(hBinding);
 357     UNREFERENCED_PARAMETER(ulFlags);
 358
 359     DPRINT("PNP_GetRelatedDeviceInstance() called\n");
 360     DPRINT("  Relationship %ld\n", ulRelationship);
 361     DPRINT("  DeviceId %S\n", pDeviceID);
 362
 363     RtlInitUnicodeString(&PlugPlayData.TargetDeviceInstance,
 364                          pDeviceID);
 365
 366     PlugPlayData.Relation = ulRelationship;
 367
 368     PlugPlayData.RelatedDeviceInstanceLength = *pulLength;
 369     PlugPlayData.RelatedDeviceInstance = pRelatedDeviceId;
 370
 371     Status = NtPlugPlayControl(PlugPlayControlGetRelatedDevice,
 372                                (PVOID)&PlugPlayData,
 373                                sizeof(PLUGPLAY_CONTROL_RELATED_DEVICE_DATA));
 374     if (!NT_SUCCESS(Status))
 375     {
 376         ret = NtStatusToCrError(Status);
 377     }
 378
 379     DPRINT("PNP_GetRelatedDeviceInstance() done (returns %lx)\n", ret);
 380     if (ret == CR_SUCCESS)
 381     {
 382         DPRINT("RelatedDevice: %wZ\n", &PlugPlayData.RelatedDeviceInstance);
 383     }
 384
 385     return ret;
 386 }
 387
 388
 389 /* Function 9 */
 390 DWORD PNP_EnumerateSubKeys(
 391     handle_t hBinding,
 392     DWORD ulBranch,
 393     DWORD ulIndex,
 394     LPWSTR Buffer,
 395     PNP_RPC_STRING_LEN ulLength,
 396     PNP_RPC_STRING_LEN *pulRequiredLen,
 397     DWORD ulFlags)
 398 {
 399     CONFIGRET ret = CR_SUCCESS;
 400     HKEY hKey;
 401     DWORD dwError;
 402
 403     UNREFERENCED_PARAMETER(hBinding);
 404     UNREFERENCED_PARAMETER(ulFlags);
 405
 406     DPRINT("PNP_EnumerateSubKeys() called\n");
 407
 408     switch (ulBranch)
 409     {
 410         case PNP_ENUMERATOR_SUBKEYS:
 411             hKey = hEnumKey;
 412             break;
 413
 414         case PNP_CLASS_SUBKEYS:
 415             hKey = hClassKey;
 416             break;
 417
 418         default:
 419             return CR_FAILURE;
 420     }
 421
 422     *pulRequiredLen = ulLength;
 423     dwError = RegEnumKeyExW(hKey,
 424                             ulIndex,
 425                             Buffer,
 426                             pulRequiredLen,
 427                             NULL,
 428                             NULL,
 429                             NULL,
 430                             NULL);
 431     if (dwError != ERROR_SUCCESS)
 432     {
 433         ret = (dwError == ERROR_NO_MORE_ITEMS) ? CR_NO_SUCH_VALUE : CR_FAILURE;
 434     }
 435     else
 436     {
 437         (*pulRequiredLen)++;
 438     }
 439
 440     DPRINT("PNP_EnumerateSubKeys() done (returns %lx)\n", ret);
 441
 442     return ret;
 443 }
 444
 445
 446 /* Function 10 */
 447 DWORD PNP_GetDeviceList(
 448     handle_t hBinding,
 449     LPWSTR pszFilter,
 450     LPWSTR Buffer,
 451     PNP_RPC_STRING_LEN *pulLength,
 452     DWORD ulFlags)
 453 {
 454     UNIMPLEMENTED;
 455     return CR_CALL_NOT_IMPLEMENTED;
 456 }
 457
 458
 459 /* Function 11 */
 460 DWORD PNP_GetDeviceListSize(
 461     handle_t hBinding,
 462     LPWSTR pszFilter,
 463     PNP_RPC_BUFFER_SIZE *pulLen,
 464     DWORD ulFlags)
 465 {
 466     UNIMPLEMENTED;
 467     return CR_CALL_NOT_IMPLEMENTED;
 468 }
 469
 470
 471 /* Function 12 */
 472 DWORD PNP_GetDepth(
 473     handle_t hBinding,
 474     LPWSTR pszDeviceID,
 475     DWORD *pulDepth,
 476     DWORD ulFlags)
 477 {
 478     PLUGPLAY_CONTROL_DEPTH_DATA PlugPlayData;
 479     CONFIGRET ret = CR_SUCCESS;
 480     NTSTATUS Status;
 481
 482     UNREFERENCED_PARAMETER(hBinding);
 483     UNREFERENCED_PARAMETER(ulFlags);
 484
 485     DPRINT("PNP_GetDepth() called\n");
 486
 487     RtlInitUnicodeString(&PlugPlayData.DeviceInstance,
 488                          pszDeviceID);
 489
 490     Status = NtPlugPlayControl(PlugPlayControlGetDeviceDepth,
 491                                (PVOID)&PlugPlayData,
 492                                sizeof(PLUGPLAY_CONTROL_DEPTH_DATA));
 493     if (NT_SUCCESS(Status))
 494     {
 495         *pulDepth = PlugPlayData.Depth;
 496     }
 497     else
 498     {
 499         ret = NtStatusToCrError(Status);
 500     }
 501
 502     DPRINT("PNP_GetDepth() done (returns %lx)\n", ret);
 503
 504     return ret;
 505 }
 506
 507
 508 /* Function 13 */
 509 DWORD PNP_GetDeviceRegProp(
 510     handle_t hBinding,
 511     LPWSTR pDeviceID,
 512     DWORD ulProperty,
 513     DWORD *pulRegDataType,
 514     BYTE *Buffer,
 515     PNP_PROP_SIZE *pulTransferLen,
 516     PNP_PROP_SIZE *pulLength,
 517     DWORD ulFlags)
 518 {
 519     PLUGPLAY_CONTROL_PROPERTY_DATA PlugPlayData;
 520     CONFIGRET ret = CR_SUCCESS;
 521     LPWSTR lpValueName = NULL;
 522     HKEY hKey = 0;
 523     NTSTATUS Status;
 524
 525     UNREFERENCED_PARAMETER(hBinding);
 526     UNREFERENCED_PARAMETER(ulFlags);
 527
 528     DPRINT("PNP_GetDeviceRegProp() called\n");
 529
 530     switch (ulProperty)
 531     {
 532         case CM_DRP_DEVICEDESC:
 533             lpValueName = L"DeviceDesc";
 534             break;
 535
 536         case CM_DRP_HARDWAREID:
 537             lpValueName = L"HardwareID";
 538             break;
 539
 540         case CM_DRP_COMPATIBLEIDS:
 541             lpValueName = L"CompatibleIDs";
 542             break;
 543
 544         case CM_DRP_SERVICE:
 545             lpValueName = L"Service";
 546             break;
 547
 548         case CM_DRP_CLASS:
 549             lpValueName = L"Class";
 550             break;
 551
 552         case CM_DRP_CLASSGUID:
 553             lpValueName = L"ClassGUID";
 554             break;
 555
 556         case CM_DRP_DRIVER:
 557             lpValueName = L"Driver";
 558             break;
 559
 560         case CM_DRP_CONFIGFLAGS:
 561             lpValueName = L"ConfigFlags";
 562             break;
 563
 564         case CM_DRP_MFG:
 565             lpValueName = L"Mfg";
 566             break;
 567
 568         case CM_DRP_FRIENDLYNAME:
 569             lpValueName = L"FriendlyName";
 570             break;
 571
 572         case CM_DRP_LOCATION_INFORMATION:
 573             lpValueName = L"LocationInformation";
 574             break;
 575
 576         case CM_DRP_PHYSICAL_DEVICE_OBJECT_NAME:
 577             lpValueName = NULL;
 578             break;
 579
 580         case CM_DRP_CAPABILITIES:
 581             lpValueName = L"Capabilities";
 582             break;
 583
 584         case CM_DRP_UI_NUMBER:
 585             lpValueName = NULL;
 586             break;
 587
 588         case CM_DRP_UPPERFILTERS:
 589             lpValueName = L"UpperFilters";
 590             break;
 591
 592         case CM_DRP_LOWERFILTERS:
 593             lpValueName = L"LowerFilters";
 594             break;
 595
 596         case CM_DRP_BUSTYPEGUID:
 597             lpValueName = NULL;
 598             break;
 599
 600         case CM_DRP_LEGACYBUSTYPE:
 601             lpValueName = NULL;
 602             break;
 603
 604         case CM_DRP_BUSNUMBER:
 605             lpValueName = NULL;
 606             break;
 607
 608         case CM_DRP_ENUMERATOR_NAME:
 609             lpValueName = NULL;
 610             break;
 611
 612         default:
 613             return CR_INVALID_PROPERTY;
 614     }
 615
 616     DPRINT("Value name: %S\n", lpValueName);
 617
 618     if (lpValueName)
 619     {
 620         /* Retrieve information from the Registry */
 621         if (RegOpenKeyExW(hEnumKey,
 622                           pDeviceID,
 623                           0,
 624                           KEY_ALL_ACCESS,
 625                           &hKey))
 626             return CR_INVALID_DEVNODE;
 627
 628         if (RegQueryValueExW(hKey,
 629                              lpValueName,
 630                              NULL,
 631                              pulRegDataType,
 632                              Buffer,
 633                              pulLength))
 634             ret = CR_REGISTRY_ERROR;
 635
 636         /* FIXME: Check buffer size */
 637
 638         RegCloseKey(hKey);
 639     }
 640     else
 641     {
 642         /* Retrieve information from the Device Node */
 643         RtlInitUnicodeString(&PlugPlayData.DeviceInstance,
 644                              pDeviceID);
 645         PlugPlayData.Buffer = Buffer;
 646         PlugPlayData.BufferSize = *pulTransferLen;
 647
 648         switch (ulProperty)
 649         {
 650 #if 0
 651             case CM_DRP_PHYSICAL_DEVICE_OBJECT_NAME:
 652                 PlugPlayData.Property = DevicePropertyPhysicalDeviceObjectName;
 653                 break;
 654
 655             case CM_DRP_UI_NUMBER:
 656                 PlugPlayData.Property = DevicePropertyUINumber;
 657                 break;
 658
 659             case CM_DRP_BUSTYPEGUID:
 660                 PlugPlayData.Property = DevicePropertyBusTypeGuid;
 661                 break;
 662
 663             case CM_DRP_LEGACYBUSTYPE:
 664                 PlugPlayData.Property = DevicePropertyLegacyBusType;
 665                 break;
 666
 667             case CM_DRP_BUSNUMBER:
 668                 PlugPlayData.Property = DevicePropertyBusNumber;
 669                 break;
 670 #endif
 671
 672             case CM_DRP_ENUMERATOR_NAME:
 673                 PlugPlayData.Property = 15; //DevicePropertyEnumeratorName;
 674                 break;
 675
 676             default:
 677                 return CR_INVALID_PROPERTY;
 678         }
 679
 680         Status = NtPlugPlayControl(PlugPlayControlProperty,
 681                                    (PVOID)&PlugPlayData,
 682                                    sizeof(PLUGPLAY_CONTROL_PROPERTY_DATA));
 683         if (NT_SUCCESS(Status))
 684         {
 685             *pulLength = PlugPlayData.BufferSize;
 686         }
 687         else
 688         {
 689             ret = NtStatusToCrError(Status);
 690         }
 691     }
 692
 693     DPRINT("PNP_GetDeviceRegProp() done (returns %lx)\n", ret);
 694
 695     return ret;
 696 }
 697
 698
 699 /* Function 14 */
 700 DWORD PNP_SetDeviceRegProp(
 701     handle_t hBinding,
 702     LPWSTR pDeviceId,
 703     DWORD ulProperty,
 704     DWORD ulDataType,
 705     BYTE *Buffer,
 706     PNP_PROP_SIZE ulLength,
 707     DWORD ulFlags)
 708 {
 709     CONFIGRET ret = CR_SUCCESS;
 710     LPWSTR lpValueName = NULL;
 711     HKEY hKey = 0;
 712
 713     UNREFERENCED_PARAMETER(hBinding);
 714     UNREFERENCED_PARAMETER(ulFlags);
 715
 716     DPRINT("PNP_SetDeviceRegProp() called\n");
 717
 718     DPRINT("DeviceId: %S\n", pDeviceId);
 719     DPRINT("Property: %lu\n", ulProperty);
 720     DPRINT("DataType: %lu\n", ulDataType);
 721     DPRINT("Length: %lu\n", ulLength);
 722
 723     switch (ulProperty)
 724     {
 725         case CM_DRP_DEVICEDESC:
 726             lpValueName = L"DeviceDesc";
 727             break;
 728
 729         case CM_DRP_HARDWAREID:
 730             lpValueName = L"HardwareID";
 731             break;
 732
 733         case CM_DRP_COMPATIBLEIDS:
 734             lpValueName = L"CompatibleIDs";
 735             break;
 736
 737         case CM_DRP_SERVICE:
 738             lpValueName = L"Service";
 739             break;
 740
 741         case CM_DRP_CLASS:
 742             lpValueName = L"Class";
 743             break;
 744
 745         case CM_DRP_CLASSGUID:
 746             lpValueName = L"ClassGUID";
 747             break;
 748
 749         case CM_DRP_DRIVER:
 750             lpValueName = L"Driver";
 751             break;
 752
 753         case CM_DRP_CONFIGFLAGS:
 754             lpValueName = L"ConfigFlags";
 755             break;
 756
 757         case CM_DRP_MFG:
 758             lpValueName = L"Mfg";
 759             break;
 760
 761         case CM_DRP_FRIENDLYNAME:
 762             lpValueName = L"FriendlyName";
 763             break;
 764
 765         case CM_DRP_LOCATION_INFORMATION:
 766             lpValueName = L"LocationInformation";
 767             break;
 768
 769         case CM_DRP_UPPERFILTERS:
 770             lpValueName = L"UpperFilters";
 771             break;
 772
 773         case CM_DRP_LOWERFILTERS:
 774             lpValueName = L"LowerFilters";
 775             break;
 776
 777         default:
 778             return CR_INVALID_PROPERTY;
 779     }
 780
 781     DPRINT("Value name: %S\n", lpValueName);
 782
 783     if (RegOpenKeyExW(hEnumKey,
 784                       pDeviceId,
 785                       0,
 786                       KEY_ALL_ACCESS, /* FIXME: so much? */
 787                       &hKey))
 788         return CR_INVALID_DEVNODE;
 789
 790     if (ulLength == 0)
 791     {
 792         if (RegDeleteValueW(hKey,
 793                             lpValueName))
 794             ret = CR_REGISTRY_ERROR;
 795     }
 796     else
 797     {
 798         if (RegSetValueExW(hKey,
 799                            lpValueName,
 800                            0,
 801                            ulDataType,
 802                            Buffer,
 803                            ulLength))
 804             ret = CR_REGISTRY_ERROR;
 805     }
 806
 807     RegCloseKey(hKey);
 808
 809     DPRINT("PNP_SetDeviceRegProp() done (returns %lx)\n", ret);
 810
 811     return ret;
 812 }
 813
 814
 815 /* Function 15 */
 816 DWORD PNP_GetClassInstance(
 817     handle_t hBinding,
 818     LPWSTR pDeviceId,
 819     LPWSTR pszClassInstance,
 820     PNP_RPC_STRING_LEN ulLength)
 821 {
 822     UNIMPLEMENTED;
 823     return CR_CALL_NOT_IMPLEMENTED;
 824 }
 825
 826
 827 /* Function 16 */
 828 DWORD PNP_CreateKey(
 829     handle_t hBinding,
 830     LPWSTR pszSubKey,
 831     DWORD samDesired,
 832     DWORD ulFlags)
 833 {
 834     UNIMPLEMENTED;
 835     return CR_CALL_NOT_IMPLEMENTED;
 836 }
 837
 838
 839 /* Function 17 */
 840 DWORD PNP_DeleteRegistryKey(
 841     handle_t hBinding,
 842     LPWSTR pszDeviceID,
 843     LPWSTR pszParentKey,
 844     LPWSTR pszChildKey,
 845     DWORD ulFlags)
 846 {
 847     UNIMPLEMENTED;
 848     return CR_CALL_NOT_IMPLEMENTED;
 849 }
 850
 851
 852 /* Function 18 */
 853 DWORD PNP_GetClassCount(
 854     handle_t hBinding,
 855     DWORD *pulClassCount,
 856     DWORD ulFlags)
 857 {
 858     HKEY hKey;
 859     DWORD dwError;
 860
 861     UNREFERENCED_PARAMETER(hBinding);
 862     UNREFERENCED_PARAMETER(ulFlags);
 863
 864     dwError = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
 865                             REGSTR_PATH_CLASS,
 866                             0,
 867                             KEY_QUERY_VALUE,
 868                             &hKey);
 869     if (dwError != ERROR_SUCCESS)
 870         return CR_INVALID_DATA;
 871
 872     dwError = RegQueryInfoKeyW(hKey,
 873                                NULL,
 874                                NULL,
 875                                NULL,
 876                                pulClassCount,
 877                                NULL,
 878                                NULL,
 879                                NULL,
 880                                NULL,
 881                                NULL,
 882                                NULL,
 883                                NULL);
 884     RegCloseKey(hKey);
 885     if (dwError != ERROR_SUCCESS)
 886         return CR_INVALID_DATA;
 887
 888     return CR_SUCCESS;
 889 }
 890
 891
 892 /* Function 19 */
 893 DWORD PNP_GetClassName(
 894     handle_t hBinding,
 895     LPWSTR pszClassGuid,
 896     LPWSTR Buffer,
 897     PNP_RPC_STRING_LEN *pulLength,
 898     DWORD ulFlags)
 899 {
 900     WCHAR szKeyName[MAX_PATH];
 901     CONFIGRET ret = CR_SUCCESS;
 902     HKEY hKey;
 903     DWORD dwSize;
 904
 905     UNREFERENCED_PARAMETER(hBinding);
 906     UNREFERENCED_PARAMETER(ulFlags);
 907
 908     DPRINT("PNP_GetClassName() called\n");
 909
 910     lstrcpyW(szKeyName, L"System\\CurrentControlSet\\Control\\Class\\");
 911     if(lstrlenW(pszClassGuid) + 1 < sizeof(szKeyName)/sizeof(WCHAR)-(lstrlenW(szKeyName) * sizeof(WCHAR)))
 912         lstrcatW(szKeyName, pszClassGuid);
 913     else return CR_INVALID_DATA;
 914
 915     if (RegOpenKeyExW(HKEY_LOCAL_MACHINE,
 916                       szKeyName,
 917                       0,
 918                       KEY_QUERY_VALUE,
 919                       &hKey))
 920         return CR_REGISTRY_ERROR;
 921
 922     dwSize = *pulLength * sizeof(WCHAR);
 923     if (RegQueryValueExW(hKey,
 924                          L"Class",
 925                          NULL,
 926                          NULL,
 927                          (LPBYTE)Buffer,
 928                          &dwSize))
 929     {
 930         *pulLength = 0;
 931         ret = CR_REGISTRY_ERROR;
 932     }
 933     else
 934     {
 935         *pulLength = dwSize / sizeof(WCHAR);
 936     }
 937
 938     RegCloseKey(hKey);
 939
 940     DPRINT("PNP_GetClassName() done (returns %lx)\n", ret);
 941
 942     return ret;
 943 }
 944
 945
 946 /* Function 20 */
 947 DWORD PNP_DeleteClassKey(
 948     handle_t hBinding,
 949     LPWSTR pszClassGuid,
 950     DWORD ulFlags)
 951 {
 952     CONFIGRET ret = CR_SUCCESS;
 953
 954     UNREFERENCED_PARAMETER(hBinding);
 955
 956     DPRINT("PNP_GetClassName(%S, %lx) called\n", pszClassGuid, ulFlags);
 957
 958     if (ulFlags & CM_DELETE_CLASS_SUBKEYS)
 959     {
 960         if (RegDeleteTreeW(hClassKey, pszClassGuid) != ERROR_SUCCESS)
 961             ret = CR_REGISTRY_ERROR;
 962     }
 963     else
 964     {
 965         if (RegDeleteKeyW(hClassKey, pszClassGuid) != ERROR_SUCCESS)
 966             ret = CR_REGISTRY_ERROR;
 967     }
 968
 969     DPRINT("PNP_DeleteClassKey() done (returns %lx)\n", ret);
 970
 971     return ret;
 972 }
 973
 974
 975 /* Function 21 */
 976 DWORD PNP_GetInterfaceDeviceAlias(
 977     handle_t hBinding,
 978     LPWSTR pszInterfaceDevice,
 979     GUID *AliasInterfaceGuid,
 980     LPWSTR pszAliasInterfaceDevice,
 981     PNP_RPC_STRING_LEN *pulLength,
 982     PNP_RPC_STRING_LEN *pulTransferLen,
 983     DWORD ulFlags)
 984 {
 985     UNIMPLEMENTED;
 986     return CR_CALL_NOT_IMPLEMENTED;
 987 }
 988
 989
 990 /* Function 22 */
 991 DWORD PNP_GetInterfaceDeviceList(
 992     handle_t hBinding,
 993     GUID *InterfaceGuid,
 994     LPWSTR pszDeviceID,
 995     BYTE *Buffer,
 996     PNP_RPC_BUFFER_SIZE *pulLength,
 997     DWORD ulFlags)
 998 {
 999     UNIMPLEMENTED;
1000     return CR_CALL_NOT_IMPLEMENTED;
1001 }
1002
1003
1004 /* Function 23 */
1005 DWORD PNP_GetInterfaceDeviceListSize(
1006     handle_t hBinding,
1007     PNP_RPC_BUFFER_SIZE *pulLen,
1008     GUID *InterfaceGuid,
1009     LPWSTR pszDeviceID,
1010     DWORD ulFlags)
1011 {
1012     UNIMPLEMENTED;
1013     return CR_CALL_NOT_IMPLEMENTED;
1014 }
1015
1016
1017 /* Function 24 */
1018 DWORD PNP_RegisterDeviceClassAssociation(
1019     handle_t hBinding,
1020     LPWSTR pszDeviceID,
1021     GUID *InterfaceGuid,
1022     LPWSTR pszReference,
1023     LPWSTR pszSymLink,
1024     PNP_RPC_STRING_LEN *pulLength,
1025     PNP_RPC_STRING_LEN *pulTransferLen,
1026     DWORD ulFlags)
1027 {
1028     UNIMPLEMENTED;
1029     return CR_CALL_NOT_IMPLEMENTED;
1030 }
1031
1032
1033 /* Function 25 */
1034 DWORD PNP_UnregisterDeviceClassAssociation(
1035     handle_t hBinding,
1036     LPWSTR pszInterfaceDevice,
1037     DWORD ulFlags)
1038 {
1039     UNIMPLEMENTED;
1040     return CR_CALL_NOT_IMPLEMENTED;
1041 }
1042
1043
1044 /* Function 26 */
1045 DWORD PNP_GetClassRegProp(
1046     handle_t hBinding,
1047     LPWSTR pszClassGuid,
1048     DWORD ulProperty,
1049     DWORD *pulRegDataType,
1050     BYTE *Buffer,
1051     PNP_RPC_STRING_LEN *pulTransferLen,
1052     PNP_RPC_STRING_LEN *pulLength,
1053     DWORD ulFlags)
1054 {
1055     UNIMPLEMENTED;
1056     return CR_CALL_NOT_IMPLEMENTED;
1057 }
1058
1059
1060 /* Function 27 */
1061 DWORD PNP_SetClassRegProp(
1062     handle_t hBinding,
1063     LPWSTR *pszClassGuid,
1064     DWORD ulProperty,
1065     DWORD ulDataType,
1066     BYTE *Buffer,
1067     PNP_PROP_SIZE ulLength,
1068     DWORD ulFlags)
1069 {
1070     UNIMPLEMENTED;
1071     return CR_CALL_NOT_IMPLEMENTED;
1072 }
1073
1074
1075 /* Function 28 */
1076 DWORD PNP_CreateDevInst(
1077     handle_t hBinding,
1078     LPWSTR pszDeviceID,
1079     LPWSTR pszParentDeviceID,
1080     PNP_RPC_STRING_LEN ulLength,
1081     DWORD ulFlags)
1082 {
1083     UNIMPLEMENTED;
1084     return CR_CALL_NOT_IMPLEMENTED;
1085 }
1086
1087
1088 static CONFIGRET
1089 MoveDeviceInstance(LPWSTR pszDeviceInstanceDestination,
1090                    LPWSTR pszDeviceInstanceSource)
1091 {
1092     DPRINT("MoveDeviceInstance: not implemented\n");
1093     /* FIXME */
1094     return CR_CALL_NOT_IMPLEMENTED;
1095 }
1096
1097
1098 static CONFIGRET
1099 SetupDeviceInstance(LPWSTR pszDeviceInstance,
1100                     DWORD ulFlags)
1101 {
1102     DPRINT("SetupDeviceInstance: not implemented\n");
1103     /* FIXME */
1104     return CR_CALL_NOT_IMPLEMENTED;
1105 }
1106
1107
1108 static CONFIGRET
1109 EnableDeviceInstance(LPWSTR pszDeviceInstance)
1110 {
1111     PLUGPLAY_CONTROL_RESET_DEVICE_DATA ResetDeviceData;
1112     CONFIGRET ret = CR_SUCCESS;
1113     NTSTATUS Status;
1114
1115     DPRINT("Enable device instance\n");
1116
1117     RtlInitUnicodeString(&ResetDeviceData.DeviceInstance, pszDeviceInstance);
1118     Status = NtPlugPlayControl(PlugPlayControlResetDevice, &ResetDeviceData, sizeof(PLUGPLAY_CONTROL_RESET_DEVICE_DATA));
1119     if (!NT_SUCCESS(Status))
1120         ret = NtStatusToCrError(Status);
1121
1122     return ret;
1123 }
1124
1125
1126 static CONFIGRET
1127 DisableDeviceInstance(LPWSTR pszDeviceInstance)
1128 {
1129     DPRINT("DisableDeviceInstance: not implemented\n");
1130     /* FIXME */
1131     return CR_CALL_NOT_IMPLEMENTED;
1132 }
1133
1134
1135 static CONFIGRET
1136 ReenumerateDeviceInstance(LPWSTR pszDeviceInstance)
1137 {
1138     DPRINT("ReenumerateDeviceInstance: not implemented\n");
1139     /* FIXME */
1140     return CR_CALL_NOT_IMPLEMENTED;
1141 }
1142
1143
1144 /* Function 29 */
1145 DWORD PNP_DeviceInstanceAction(
1146     handle_t hBinding,
1147     DWORD ulAction,
1148     DWORD ulFlags,
1149     LPWSTR pszDeviceInstance1,
1150     LPWSTR pszDeviceInstance2)
1151 {
1152     CONFIGRET ret = CR_SUCCESS;
1153
1154     UNREFERENCED_PARAMETER(hBinding);
1155
1156     DPRINT("PNP_DeviceInstanceAction() called\n");
1157
1158     switch (ulAction)
1159     {
1160         case PNP_DEVINST_MOVE:
1161             ret = MoveDeviceInstance(pszDeviceInstance1,
1162                                      pszDeviceInstance2);
1163             break;
1164
1165         case PNP_DEVINST_SETUP:
1166             ret = SetupDeviceInstance(pszDeviceInstance1,
1167                                       ulFlags);
1168             break;
1169
1170         case PNP_DEVINST_ENABLE:
1171             ret = EnableDeviceInstance(pszDeviceInstance1);
1172             break;
1173
1174         case PNP_DEVINST_DISABLE:
1175             ret = DisableDeviceInstance(pszDeviceInstance1);
1176             break;
1177
1178         case PNP_DEVINST_REENUMERATE:
1179             ret = ReenumerateDeviceInstance(pszDeviceInstance1);
1180             break;
1181
1182         default:
1183             DPRINT1("Unknown device action %lu: not implemented\n", ulAction);
1184             ret = CR_CALL_NOT_IMPLEMENTED;
1185     }
1186
1187     DPRINT("PNP_DeviceInstanceAction() done (returns %lx)\n", ret);
1188
1189     return ret;
1190 }
1191
1192
1193 /* Function 30 */
1194 DWORD PNP_GetDeviceStatus(
1195     handle_t hBinding,
1196     LPWSTR pDeviceID,
1197     DWORD *pulStatus,
1198     DWORD *pulProblem,
1199     DWORD ulFlags)
1200 {
1201     PLUGPLAY_CONTROL_STATUS_DATA PlugPlayData;
1202     CONFIGRET ret = CR_SUCCESS;
1203     NTSTATUS Status;
1204
1205     UNREFERENCED_PARAMETER(hBinding);
1206     UNREFERENCED_PARAMETER(ulFlags);
1207
1208     DPRINT("PNP_GetDeviceStatus() called\n");
1209
1210     RtlInitUnicodeString(&PlugPlayData.DeviceInstance,
1211                          pDeviceID);
1212     PlugPlayData.Operation = 0; /* Get status */
1213
1214     Status = NtPlugPlayControl(PlugPlayControlDeviceStatus,
1215                                (PVOID)&PlugPlayData,
1216                                sizeof(PLUGPLAY_CONTROL_STATUS_DATA));
1217     if (NT_SUCCESS(Status))
1218     {
1219         *pulStatus = PlugPlayData.DeviceStatus;
1220         *pulProblem = PlugPlayData.DeviceProblem;
1221     }
1222     else
1223     {
1224         ret = NtStatusToCrError(Status);
1225     }
1226
1227     DPRINT("PNP_GetDeviceStatus() done (returns %lx)\n", ret);
1228
1229     return ret;
1230 }
1231
1232
1233 /* Function 31 */
1234 DWORD PNP_SetDeviceProblem(
1235     handle_t hBinding,
1236     LPWSTR pDeviceID,
1237     DWORD ulProblem,
1238     DWORD ulFlags)
1239 {
1240     UNIMPLEMENTED;
1241     return CR_CALL_NOT_IMPLEMENTED;
1242 }
1243
1244
1245 /* Function 32 */
1246 DWORD PNP_DisableDevInst(
1247     handle_t hBinding,
1248     LPWSTR pDeviceID,
1249     PPNP_VETO_TYPE pVetoType,
1250     LPWSTR pszVetoName,
1251     DWORD ulNameLength,
1252     DWORD ulFlags)
1253 {
1254     UNIMPLEMENTED;
1255     return CR_CALL_NOT_IMPLEMENTED;
1256 }
1257
1258 /* Function 33 */
1259 DWORD PNP_UninstallDevInst(
1260     handle_t hBinding,
1261     LPWSTR pDeviceID,
1262     DWORD ulFlags)
1263 {
1264     UNIMPLEMENTED;
1265     return CR_CALL_NOT_IMPLEMENTED;
1266 }
1267
1268
1269 static BOOL
1270 CheckForDeviceId(LPWSTR lpDeviceIdList,
1271                  LPWSTR lpDeviceId)
1272 {
1273     LPWSTR lpPtr;
1274     DWORD dwLength;
1275
1276     lpPtr = lpDeviceIdList;
1277     while (*lpPtr != 0)
1278     {
1279         dwLength = wcslen(lpPtr);
1280         if (0 == _wcsicmp(lpPtr, lpDeviceId))
1281             return TRUE;
1282
1283         lpPtr += (dwLength + 1);
1284     }
1285
1286     return FALSE;
1287 }
1288
1289
1290 static VOID
1291 AppendDeviceId(LPWSTR lpDeviceIdList,
1292                LPDWORD lpDeviceIdListSize,
1293                LPWSTR lpDeviceId)
1294 {
1295     DWORD dwLen;
1296     DWORD dwPos;
1297
1298     dwLen = wcslen(lpDeviceId);
1299     dwPos = (*lpDeviceIdListSize / sizeof(WCHAR)) - 1;
1300
1301     wcscpy(&lpDeviceIdList[dwPos], lpDeviceId);
1302
1303     dwPos += (dwLen + 1);
1304
1305     lpDeviceIdList[dwPos] = 0;
1306
1307     *lpDeviceIdListSize = dwPos * sizeof(WCHAR);
1308 }
1309
1310
1311 /* Function 34 */
1312 DWORD PNP_AddID(
1313     handle_t hBinding,
1314     LPWSTR pszDeviceID,
1315     LPWSTR pszID,
1316     DWORD ulFlags)
1317 {
1318     CONFIGRET ret = CR_SUCCESS;
1319     HKEY hDeviceKey;
1320     LPWSTR pszSubKey;
1321     DWORD dwDeviceIdListSize;
1322     DWORD dwNewDeviceIdSize;
1323     WCHAR * pszDeviceIdList = NULL;
1324
1325     UNREFERENCED_PARAMETER(hBinding);
1326
1327     DPRINT("PNP_AddID() called\n");
1328     DPRINT("  DeviceInstance: %S\n", pszDeviceID);
1329     DPRINT("  DeviceId: %S\n", pszID);
1330     DPRINT("  Flags: %lx\n", ulFlags);
1331
1332     if (RegOpenKeyExW(hEnumKey,
1333                       pszDeviceID,
1334                       0,
1335                       KEY_QUERY_VALUE | KEY_SET_VALUE,
1336                       &hDeviceKey) != ERROR_SUCCESS)
1337     {
1338         DPRINT("Failed to open the device key!\n");
1339         return CR_INVALID_DEVNODE;
1340     }
1341
1342     pszSubKey = (ulFlags & CM_ADD_ID_COMPATIBLE) ? L"CompatibleIDs" : L"HardwareID";
1343
1344     if (RegQueryValueExW(hDeviceKey,
1345                          pszSubKey,
1346                          NULL,
1347                          NULL,
1348                          NULL,
1349                          &dwDeviceIdListSize) != ERROR_SUCCESS)
1350     {
1351         DPRINT("Failed to query the desired ID string!\n");
1352         ret = CR_REGISTRY_ERROR;
1353         goto Done;
1354     }
1355
1356     dwNewDeviceIdSize = lstrlenW(pszDeviceID);
1357     if (!dwNewDeviceIdSize)
1358     {
1359         ret = CR_INVALID_POINTER;
1360         goto Done;
1361     }
1362
1363     dwDeviceIdListSize += (dwNewDeviceIdSize + 2) * sizeof(WCHAR);
1364
1365     pszDeviceIdList = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwDeviceIdListSize);
1366     if (!pszDeviceIdList)
1367     {
1368         DPRINT("Failed to allocate memory for the desired ID string!\n");
1369         ret = CR_OUT_OF_MEMORY;
1370         goto Done;
1371     }
1372
1373     if (RegQueryValueExW(hDeviceKey,
1374                          pszSubKey,
1375                          NULL,
1376                          NULL,
1377                          (LPBYTE)pszDeviceIdList,
1378                          &dwDeviceIdListSize) != ERROR_SUCCESS)
1379     {
1380         DPRINT("Failed to query the desired ID string!\n");
1381         ret = CR_REGISTRY_ERROR;
1382         goto Done;
1383     }
1384
1385     /* Check whether the device ID is already in use */
1386     if (CheckForDeviceId(pszDeviceIdList, pszDeviceID))
1387     {
1388         DPRINT("Device ID was found in the ID string!\n");
1389         ret = CR_SUCCESS;
1390         goto Done;
1391     }
1392
1393     /* Append the Device ID */
1394     AppendDeviceId(pszDeviceIdList, &dwDeviceIdListSize, pszID);
1395
1396     if (RegSetValueExW(hDeviceKey,
1397                        pszSubKey,
1398                        0,
1399                        REG_MULTI_SZ,
1400                        (LPBYTE)pszDeviceIdList,
1401                        dwDeviceIdListSize) != ERROR_SUCCESS)
1402     {
1403         DPRINT("Failed to set the desired ID string!\n");
1404         ret = CR_REGISTRY_ERROR;
1405     }
1406
1407 Done:
1408     RegCloseKey(hDeviceKey);
1409     if (pszDeviceIdList)
1410         HeapFree(GetProcessHeap(), 0, pszDeviceIdList);
1411
1412     DPRINT("PNP_AddID() done (returns %lx)\n", ret);
1413
1414     return ret;
1415 }
1416
1417
1418 /* Function 35 */
1419 DWORD PNP_RegisterDriver(
1420     handle_t hBinding,
1421     LPWSTR pszDeviceID,
1422     DWORD ulFlags)
1423 {
1424     UNIMPLEMENTED;
1425     return CR_CALL_NOT_IMPLEMENTED;
1426 }
1427
1428
1429 /* Function 36 */
1430 DWORD PNP_QueryRemove(
1431     handle_t hBinding,
1432     LPWSTR pszDeviceID,
1433     PPNP_VETO_TYPE pVetoType,
1434     LPWSTR pszVetoName,
1435     DWORD ulNameLength,
1436     DWORD ulFlags)
1437 {
1438     UNIMPLEMENTED;
1439     return CR_CALL_NOT_IMPLEMENTED;
1440 }
1441
1442
1443 /* Function 37 */
1444 DWORD PNP_RequestDeviceEject(
1445     handle_t hBinding,
1446     LPWSTR pszDeviceID,
1447     PPNP_VETO_TYPE pVetoType,
1448     LPWSTR pszVetoName,
1449     DWORD ulNameLength,
1450     DWORD ulFlags)
1451 {
1452     UNIMPLEMENTED;
1453     return CR_CALL_NOT_IMPLEMENTED;
1454 }
1455
1456 /* Function 38 */
1457 CONFIGRET
1458 PNP_IsDockStationPresent(handle_t hBinding,
1459                          BOOL *Present)
1460 {
1461     HKEY hKey;
1462     DWORD dwType;
1463     DWORD dwValue;
1464     DWORD dwSize;
1465     CONFIGRET ret = CR_SUCCESS;
1466
1467     UNREFERENCED_PARAMETER(hBinding);
1468
1469     DPRINT1("PNP_IsDockStationPresent() called\n");
1470
1471     *Present = FALSE;
1472
1473     if (RegOpenKeyExW(HKEY_CURRENT_CONFIG,
1474                       L"CurrentDockInfo",
1475                       0,
1476                       KEY_READ,
1477                       &hKey) != ERROR_SUCCESS)
1478         return CR_REGISTRY_ERROR;
1479
1480     dwSize = sizeof(DWORD);
1481     if (RegQueryValueExW(hKey,
1482                          L"DockingState",
1483                          NULL,
1484                          &dwType,
1485                          (LPBYTE)&dwValue,
1486                          &dwSize) != ERROR_SUCCESS)
1487         ret = CR_REGISTRY_ERROR;
1488
1489     RegCloseKey(hKey);
1490
1491     if (ret == CR_SUCCESS)
1492     {
1493         if (dwType != REG_DWORD || dwSize != sizeof(DWORD))
1494         {
1495             ret = CR_REGISTRY_ERROR;
1496         }
1497         else if (dwValue != 0)
1498         {
1499             *Present = TRUE;
1500         }
1501     }
1502
1503     DPRINT1("PNP_IsDockStationPresent() done (returns %lx)\n", ret);
1504
1505     return ret;
1506 }
1507
1508
1509 /* Function 39 */
1510 DWORD PNP_RequestEjectPC(
1511     handle_t hBinding)
1512 {
1513     UNIMPLEMENTED;
1514     return CR_CALL_NOT_IMPLEMENTED;
1515 }
1516
1517
1518 /* Function 40 */
1519 DWORD PNP_HwProfFlags(
1520     handle_t hBinding,
1521     DWORD ulAction,
1522     LPWSTR pDeviceID,
1523     DWORD ulConfig,
1524     DWORD *pulValue,
1525     PPNP_VETO_TYPE pVetoType,
1526     LPWSTR pszVetoName,
1527     DWORD ulNameLength,
1528     DWORD ulFlags)
1529 {
1530     CONFIGRET ret = CR_SUCCESS;
1531     WCHAR szKeyName[MAX_PATH];
1532     HKEY hKey;
1533     HKEY hDeviceKey;
1534     DWORD dwSize;
1535
1536     UNREFERENCED_PARAMETER(hBinding);
1537
1538     DPRINT("PNP_HwProfFlags() called\n");
1539
1540     if (ulConfig == 0)
1541     {
1542         wcscpy(szKeyName,
1543                L"System\\CurrentControlSet\\HardwareProfiles\\Current\\System\\CurrentControlSet\\Enum");
1544     }
1545     else
1546     {
1547         swprintf(szKeyName,
1548                  L"System\\CurrentControlSet\\HardwareProfiles\\%04u\\System\\CurrentControlSet\\Enum",
1549                  ulConfig);
1550     }
1551
1552     if (RegOpenKeyExW(HKEY_LOCAL_MACHINE,
1553                       szKeyName,
1554                       0,
1555                       KEY_QUERY_VALUE,
1556                       &hKey) != ERROR_SUCCESS)
1557         return CR_REGISTRY_ERROR;
1558
1559     if (ulAction == PNP_GET_HWPROFFLAGS)
1560     {
1561          if (RegOpenKeyExW(hKey,
1562                            pDeviceID,
1563                            0,
1564                            KEY_QUERY_VALUE,
1565                            &hDeviceKey) != ERROR_SUCCESS)
1566          {
1567             *pulValue = 0;
1568          }
1569          else
1570          {
1571              dwSize = sizeof(DWORD);
1572              if (!RegQueryValueExW(hDeviceKey,
1573                                    L"CSConfigFlags",
1574                                    NULL,
1575                                    NULL,
1576                                    (LPBYTE)pulValue,
1577                                    &dwSize) != ERROR_SUCCESS)
1578              {
1579                  *pulValue = 0;
1580              }
1581
1582              RegCloseKey(hDeviceKey);
1583          }
1584     }
1585     else if (ulAction == PNP_SET_HWPROFFLAGS)
1586     {
1587         /* FIXME: not implemented yet */
1588         ret = CR_CALL_NOT_IMPLEMENTED;
1589     }
1590
1591     RegCloseKey(hKey);
1592
1593     return ret;
1594 }
1595
1596
1597 /* Function 41 */
1598 DWORD PNP_GetHwProfInfo(
1599     handle_t hBinding,
1600     DWORD ulIndex,
1601     HWPROFILEINFO *pHWProfileInfo,
1602     DWORD ulProfileInfoSize,
1603     DWORD ulFlags)
1604 {
1605     UNIMPLEMENTED;
1606     return CR_CALL_NOT_IMPLEMENTED;
1607 }
1608
1609
1610 /* Function 42 */
1611 DWORD PNP_AddEmptyLogConf(
1612     handle_t hBinding,
1613     LPWSTR pDeviceID,
1614     DWORD ulPriority,
1615     DWORD *pulLogConfTag,
1616     DWORD ulFlags)
1617 {
1618     UNIMPLEMENTED;
1619     return CR_CALL_NOT_IMPLEMENTED;
1620 }
1621
1622
1623 /* Function 43 */
1624 DWORD PNP_FreeLogConf(
1625     handle_t hBinding,
1626     LPWSTR pDeviceID,
1627     DWORD ulLogConfType,
1628     DWORD ulLogConfTag,
1629     DWORD ulFlags)
1630 {
1631     UNIMPLEMENTED;
1632     return CR_CALL_NOT_IMPLEMENTED;
1633 }
1634
1635
1636 /* Function 44 */
1637 DWORD PNP_GetFirstLogConf(
1638     handle_t hBinding,
1639     LPWSTR pDeviceID,
1640     DWORD ulLogConfType,
1641     DWORD *pulLogConfTag,
1642     DWORD ulFlags)
1643 {
1644     UNIMPLEMENTED;
1645     return CR_CALL_NOT_IMPLEMENTED;
1646 }
1647
1648
1649 /* Function 45 */
1650 DWORD PNP_GetNextLogConf(
1651     handle_t hBinding,
1652     LPWSTR pDeviceID,
1653     DWORD ulLogConfType,
1654     DWORD ulCurrentTag,
1655     DWORD *pulNextTag,
1656     DWORD ulFlags)
1657 {
1658     UNIMPLEMENTED;
1659     return CR_CALL_NOT_IMPLEMENTED;
1660 }
1661
1662
1663 /* Function 46 */
1664 DWORD PNP_GetLogConfPriority(
1665     handle_t hBinding,
1666     LPWSTR pDeviceID,
1667     DWORD ulType,
1668     DWORD ulTag,
1669     DWORD *pPriority,
1670     DWORD ulFlags)
1671 {
1672     UNIMPLEMENTED;
1673     return CR_CALL_NOT_IMPLEMENTED;
1674 }
1675
1676
1677 /* Function 47 */
1678 DWORD PNP_AddResDes(
1679     handle_t hBinding,
1680     LPWSTR pDeviceID,
1681     DWORD ulLogConfTag,
1682     DWORD ulLogConfType,
1683     RESOURCEID ResourceID,
1684     DWORD *pulResourceTag,
1685     BYTE *ResourceData,
1686     PNP_RPC_BUFFER_SIZE ResourceLen,
1687     DWORD ulFlags)
1688 {
1689     UNIMPLEMENTED;
1690     return CR_CALL_NOT_IMPLEMENTED;
1691 }
1692
1693
1694 /* Function 48 */
1695 DWORD PNP_FreeResDes(
1696     handle_t hBinding,
1697     LPWSTR pDeviceID,
1698     DWORD ulLogConfTag,
1699     DWORD ulLogConfType,
1700     RESOURCEID ResourceID,
1701     DWORD ulResourceTag,
1702     DWORD *pulPreviousResType,
1703     DWORD *pulPreviousResTag,
1704     DWORD ulFlags)
1705 {
1706     UNIMPLEMENTED;
1707     return CR_CALL_NOT_IMPLEMENTED;
1708 }
1709
1710
1711 /* Function 49 */
1712 DWORD PNP_GetNextResDes(
1713     handle_t hBinding,
1714     LPWSTR pDeviceID,
1715     DWORD ulLogConfTag,
1716     DWORD ulLogConfType,
1717     RESOURCEID ResourceID,
1718     DWORD ulResourceTag,
1719     DWORD *pulNextResType,
1720     DWORD *pulNextResTag,
1721     DWORD ulFlags)
1722 {
1723     UNIMPLEMENTED;
1724     return CR_CALL_NOT_IMPLEMENTED;
1725 }
1726
1727
1728 /* Function 50 */
1729 DWORD PNP_GetResDesData(
1730     handle_t hBinding,
1731     LPWSTR pDeviceID,
1732     DWORD ulLogConfTag,
1733     DWORD ulLogConfType,
1734     RESOURCEID ResourceID,
1735     DWORD ulResourceTag,
1736     BYTE *Buffer,
1737     PNP_RPC_BUFFER_SIZE BufferLen,
1738     DWORD ulFlags)
1739 {
1740     UNIMPLEMENTED;
1741     return CR_CALL_NOT_IMPLEMENTED;
1742 }
1743
1744
1745 /* Function 51 */
1746 DWORD PNP_GetResDesDataSize(
1747     handle_t hBinding,
1748     LPWSTR pDeviceID,
1749     DWORD ulLogConfTag,
1750     DWORD ulLogConfType,
1751     RESOURCEID ResourceID,
1752     DWORD ulResourceTag,
1753     DWORD *pulSize,
1754     DWORD ulFlags)
1755 {
1756     UNIMPLEMENTED;
1757     return CR_CALL_NOT_IMPLEMENTED;
1758 }
1759
1760
1761 /* Function 52 */
1762 DWORD PNP_ModifyResDes(
1763     handle_t hBinding,
1764     LPWSTR pDeviceID,
1765     DWORD ulLogConfTag,
1766     DWORD ulLogConfType,
1767     RESOURCEID CurrentResourceID,
1768     RESOURCEID NewResourceID,
1769     DWORD ulResourceTag,
1770     BYTE *ResourceData,
1771     PNP_RPC_BUFFER_SIZE ResourceLen,
1772     DWORD ulFlags)
1773 {
1774     UNIMPLEMENTED;
1775     return CR_CALL_NOT_IMPLEMENTED;
1776 }
1777
1778
1779 /* Function 53 */
1780 DWORD PNP_DetectResourceConflict(
1781     handle_t hBinding,
1782     LPWSTR pDeviceID,
1783     RESOURCEID ResourceID,
1784     BYTE *ResourceData,
1785     PNP_RPC_BUFFER_SIZE ResourceLen,
1786     BOOL *pbConflictDetected,
1787     DWORD ulFlags)
1788 {
1789     UNIMPLEMENTED;
1790     return CR_CALL_NOT_IMPLEMENTED;
1791 }
1792
1793
1794 /* Function 54 */
1795 DWORD PNP_QueryResConfList(
1796     handle_t hBinding,
1797     LPWSTR pDeviceID,
1798     RESOURCEID ResourceID,
1799     BYTE *ResourceData,
1800     PNP_RPC_BUFFER_SIZE ResourceLen,
1801     BYTE *Buffer,
1802     PNP_RPC_BUFFER_SIZE BufferLen,
1803     DWORD ulFlags)
1804 {
1805     UNIMPLEMENTED;
1806     return CR_CALL_NOT_IMPLEMENTED;
1807 }
1808
1809
1810 /* Function 55 */
1811 DWORD PNP_SetHwProf(
1812     handle_t hBinding)
1813 {
1814     UNIMPLEMENTED;
1815     return CR_CALL_NOT_IMPLEMENTED;
1816 }
1817
1818
1819 /* Function 56 */
1820 DWORD PNP_QueryArbitratorFreeData(
1821     handle_t hBinding)
1822 {
1823     UNIMPLEMENTED;
1824     return CR_CALL_NOT_IMPLEMENTED;
1825 }
1826
1827
1828 /* Function 57 */
1829 DWORD PNP_QueryArbitratorFreeSize(
1830     handle_t hBinding)
1831 {
1832     UNIMPLEMENTED;
1833     return CR_CALL_NOT_IMPLEMENTED;
1834 }
1835
1836
1837 /* Function 58 */
1838 CONFIGRET
1839 PNP_RunDetection(
1840     handle_t hBinding,
1841     DWORD ulFlags)
1842 {
1843     UNIMPLEMENTED;
1844     return CR_CALL_NOT_IMPLEMENTED;
1845 }
1846
1847
1848 /* Function 59 */
1849 DWORD PNP_RegisterNotification(
1850     handle_t hBinding)
1851 {
1852     UNIMPLEMENTED;
1853     return CR_CALL_NOT_IMPLEMENTED;
1854 }
1855
1856
1857 /* Function 60 */
1858 DWORD PNP_UnregisterNotification(
1859     handle_t hBinding)
1860 {
1861     UNIMPLEMENTED;
1862     return CR_CALL_NOT_IMPLEMENTED;
1863 }
1864
1865
1866 /* Function 61 */
1867 DWORD PNP_GetCustomDevProp(
1868     handle_t hBinding,
1869     LPWSTR pDeviceID,
1870     LPWSTR CustomPropName,
1871     DWORD *pulRegDataType,
1872     BYTE *Buffer,
1873     PNP_RPC_STRING_LEN *pulTransferLen,
1874     PNP_RPC_STRING_LEN *pulLength,
1875     DWORD ulFlags)
1876 {
1877     UNIMPLEMENTED;
1878     return CR_CALL_NOT_IMPLEMENTED;
1879 }
1880
1881
1882 /* Function 62 */
1883 DWORD PNP_GetVersionInternal(
1884     handle_t hBinding,
1885     WORD *pwVersion)
1886 {
1887     UNIMPLEMENTED;
1888     return CR_CALL_NOT_IMPLEMENTED;
1889 }
1890
1891
1892 /* Function 63 */
1893 DWORD PNP_GetBlockedDriverInfo(
1894     handle_t hBinding,
1895     BYTE *Buffer,
1896     PNP_RPC_BUFFER_SIZE *pulTransferLen,
1897     PNP_RPC_BUFFER_SIZE *pulLength,
1898     DWORD ulFlags)
1899 {
1900     UNIMPLEMENTED;
1901     return CR_CALL_NOT_IMPLEMENTED;
1902 }
1903
1904
1905 /* Function 64 */
1906 DWORD PNP_GetServerSideDeviceInstallFlags(
1907     handle_t hBinding,
1908     DWORD *pulSSDIFlags,
1909     DWORD ulFlags)
1910 {
1911     UNIMPLEMENTED;
1912     return CR_CALL_NOT_IMPLEMENTED;
1913 }
1914
1915
1916 /* Function 65 */
1917 DWORD PNP_GetObjectPropKeys(
1918     handle_t hBinding,
1919     LPWSTR ObjectName,
1920     DWORD ObjectType,
1921     LPWSTR PropertyCultureName,
1922     PNP_PROP_COUNT *PropertyCount,
1923     PNP_PROP_COUNT *TransferLen,
1924     DEVPROPKEY *PropertyKeys,
1925     DWORD Flags)
1926 {
1927     UNIMPLEMENTED;
1928     return CR_CALL_NOT_IMPLEMENTED;
1929 }
1930
1931
1932 /* Function 66 */
1933 DWORD PNP_GetObjectProp(
1934     handle_t hBinding,
1935     LPWSTR ObjectName,
1936     DWORD ObjectType,
1937     LPWSTR PropertyCultureName,
1938     const DEVPROPKEY *PropertyKey,
1939     DEVPROPTYPE *PropertyType,
1940     PNP_PROP_SIZE *PropertySize,
1941     PNP_PROP_SIZE *TransferLen,
1942     BYTE *PropertyBuffer,
1943     DWORD Flags)
1944 {
1945     UNIMPLEMENTED;
1946     return CR_CALL_NOT_IMPLEMENTED;
1947 }
1948
1949
1950 /* Function 67 */
1951 DWORD PNP_SetObjectProp(
1952     handle_t hBinding,
1953     LPWSTR ObjectName,
1954     DWORD ObjectType,
1955     LPWSTR PropertyCultureName,
1956     const DEVPROPKEY *PropertyKey,
1957     DEVPROPTYPE PropertyType,
1958     PNP_PROP_SIZE PropertySize,
1959     BYTE *PropertyBuffer,
1960     DWORD Flags)
1961 {
1962     UNIMPLEMENTED;
1963     return CR_CALL_NOT_IMPLEMENTED;
1964 }
1965
1966
1967 /* Function 68 */
1968 DWORD PNP_InstallDevInst(
1969     handle_t hBinding)
1970 {
1971     UNIMPLEMENTED;
1972     return CR_CALL_NOT_IMPLEMENTED;
1973 }
1974
1975
1976 /* Function 69 */
1977 DWORD PNP_ApplyPowerSettings(
1978     handle_t hBinding)
1979 {
1980     UNIMPLEMENTED;
1981     return CR_CALL_NOT_IMPLEMENTED;
1982 }
1983
1984
1985 /* Function 70 */
1986 DWORD PNP_DriverStoreAddDriverPackage(
1987     handle_t hBinding)
1988 {
1989     UNIMPLEMENTED;
1990     return CR_CALL_NOT_IMPLEMENTED;
1991 }
1992
1993
1994 /* Function 71 */
1995 DWORD PNP_DriverStoreDeleteDriverPackage(
1996     handle_t hBinding)
1997 {
1998     UNIMPLEMENTED;
1999     return CR_CALL_NOT_IMPLEMENTED;
2000 }
2001
2002
2003 /* Function 72 */
2004 DWORD PNP_RegisterServiceNotification(
2005     handle_t hBinding)
2006 {
2007     UNIMPLEMENTED;
2008     return CR_CALL_NOT_IMPLEMENTED;
2009 }
2010
2011
2012 /* Function 73 */
2013 DWORD PNP_SetActiveService(
2014     handle_t hBinding)
2015 {
2016     UNIMPLEMENTED;
2017     return CR_CALL_NOT_IMPLEMENTED;
2018 }
2019
2020
2021 /* Function 74 */
2022 DWORD PNP_DeleteServiceDevices(
2023     handle_t hBinding)
2024 {
2025     UNIMPLEMENTED;
2026     return CR_CALL_NOT_IMPLEMENTED;
2027 }
2028
2029
2030 static BOOL
2031 InstallDevice(PCWSTR DeviceInstance, BOOL ShowWizard)
2032 {
2033     PLUGPLAY_CONTROL_STATUS_DATA PlugPlayData;
2034     NTSTATUS Status;
2035     BOOL DeviceInstalled = FALSE;
2036     DWORD BytesWritten;
2037     DWORD Value;
2038     HANDLE hPipe = INVALID_HANDLE_VALUE;
2039     LPVOID Environment = NULL;
2040     PROCESS_INFORMATION ProcessInfo;
2041     STARTUPINFOW StartupInfo;
2042     UUID RandomUuid;
2043
2044     /* The following lengths are constant (see below), they cannot overflow */
2045     WCHAR CommandLine[116];
2046     WCHAR InstallEventName[73];
2047     WCHAR PipeName[74];
2048     WCHAR UuidString[39];
2049
2050     DPRINT("InstallDevice(%S, %d)\n", DeviceInstance, ShowWizard);
2051
2052     ZeroMemory(&ProcessInfo, sizeof(ProcessInfo));
2053
2054     RtlInitUnicodeString(&PlugPlayData.DeviceInstance,
2055                          DeviceInstance);
2056     PlugPlayData.Operation = 0; /* Get status */
2057
2058     /* Get device status */
2059     Status = NtPlugPlayControl(PlugPlayControlDeviceStatus,
2060                                (PVOID)&PlugPlayData,
2061                                sizeof(PLUGPLAY_CONTROL_STATUS_DATA));
2062     if (!NT_SUCCESS(Status))
2063     {
2064         DPRINT1("NtPlugPlayControl('%S') failed with status 0x%08lx\n", DeviceInstance, Status);
2065         return FALSE;
2066     }
2067
2068     if ((PlugPlayData.DeviceStatus & (DNF_STARTED | DNF_START_FAILED)) != 0)
2069     {
2070         /* Device is already started, or disabled due to some problem. Don't install it */
2071         DPRINT("No need to install '%S'\n", DeviceInstance);
2072         return TRUE;
2073     }
2074
2075     /* Create a random UUID for the named pipe */
2076     UuidCreate(&RandomUuid);
2077     swprintf(UuidString, L"{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
2078         RandomUuid.Data1, RandomUuid.Data2, RandomUuid.Data3,
2079         RandomUuid.Data4[0], RandomUuid.Data4[1], RandomUuid.Data4[2],
2080         RandomUuid.Data4[3], RandomUuid.Data4[4], RandomUuid.Data4[5],
2081         RandomUuid.Data4[6], RandomUuid.Data4[7]);
2082
2083     /* Create the named pipe */
2084     wcscpy(PipeName, L"\\\\.\\pipe\\PNP_Device_Install_Pipe_0.");
2085     wcscat(PipeName, UuidString);
2086     hPipe = CreateNamedPipeW(PipeName, PIPE_ACCESS_OUTBOUND, PIPE_TYPE_BYTE, 1, 512, 512, 0, NULL);
2087
2088     if(hPipe == INVALID_HANDLE_VALUE)
2089     {
2090         DPRINT1("CreateNamedPipeW failed with error %u\n", GetLastError());
2091         goto cleanup;
2092     }
2093
2094     /* Launch rundll32 to call ClientSideInstallW */
2095     wcscpy(CommandLine, L"rundll32.exe newdev.dll,ClientSideInstall ");
2096     wcscat(CommandLine, PipeName);
2097
2098     ZeroMemory(&StartupInfo, sizeof(StartupInfo));
2099     StartupInfo.cb = sizeof(StartupInfo);
2100
2101     if(hUserToken)
2102     {
2103         /* newdev has to run under the environment of the current user */
2104         if(!CreateEnvironmentBlock(&Environment, hUserToken, FALSE))
2105         {
2106             DPRINT1("CreateEnvironmentBlock failed with error %d\n", GetLastError());
2107             goto cleanup;
2108         }
2109
2110         if(!CreateProcessAsUserW(hUserToken, NULL, CommandLine, NULL, NULL, FALSE, CREATE_UNICODE_ENVIRONMENT, Environment, NULL, &StartupInfo, &ProcessInfo))
2111         {
2112             DPRINT1("CreateProcessAsUserW failed with error %u\n", GetLastError());
2113             goto cleanup;
2114         }
2115     }
2116     else
2117     {
2118         /* FIXME: This is probably not correct, I guess newdev should never be run with SYSTEM privileges.
2119
2120            Still, we currently do that in 2nd stage setup and probably Console mode as well, so allow it here.
2121            (ShowWizard is only set to FALSE for these two modes) */
2122         ASSERT(!ShowWizard);
2123
2124         if(!CreateProcessW(NULL, CommandLine, NULL, NULL, FALSE, 0, NULL, NULL, &StartupInfo, &ProcessInfo))
2125         {
2126             DPRINT1("CreateProcessW failed with error %u\n", GetLastError());
2127             goto cleanup;
2128         }
2129     }
2130
2131     /* Wait for the function to connect to our pipe */
2132     if(!ConnectNamedPipe(hPipe, NULL))
2133     {
2134         DPRINT1("ConnectNamedPipe failed with error %u\n", GetLastError());
2135         goto cleanup;
2136     }
2137
2138     /* Pass the data. The following output is partly compatible to Windows XP SP2 (researched using a modified newdev.dll to log this stuff) */
2139     wcscpy(InstallEventName, L"Global\\PNP_Device_Install_Event_0.");
2140     wcscat(InstallEventName, UuidString);
2141
2142     Value = sizeof(InstallEventName);
2143     WriteFile(hPipe, &Value, sizeof(Value), &BytesWritten, NULL);
2144     WriteFile(hPipe, InstallEventName, Value, &BytesWritten, NULL);
2145
2146     /* I couldn't figure out what the following value means under WinXP. It's usually 0 in my tests, but was also 5 once.
2147        Therefore the following line is entirely ReactOS-specific. We use the value here to pass the ShowWizard variable. */
2148     WriteFile(hPipe, &ShowWizard, sizeof(ShowWizard), &BytesWritten, NULL);
2149
2150     Value = (wcslen(DeviceInstance) + 1) * sizeof(WCHAR);
2151     WriteFile(hPipe, &Value, sizeof(Value), &BytesWritten, NULL);
2152     WriteFile(hPipe, DeviceInstance, Value, &BytesWritten, NULL);
2153
2154     /* Wait for newdev.dll to finish processing */
2155     WaitForSingleObject(ProcessInfo.hProcess, INFINITE);
2156
2157     /* The following check for success is probably not compatible to Windows, but should do its job */
2158     if(!GetExitCodeProcess(ProcessInfo.hProcess, &Value))
2159     {
2160         DPRINT1("GetExitCodeProcess failed with error %u\n", GetLastError());
2161         goto cleanup;
2162     }
2163
2164     DeviceInstalled = Value;
2165
2166 cleanup:
2167     if(hPipe != INVALID_HANDLE_VALUE)
2168         CloseHandle(hPipe);
2169
2170     if(Environment)
2171         DestroyEnvironmentBlock(Environment);
2172
2173     if(ProcessInfo.hProcess)
2174         CloseHandle(ProcessInfo.hProcess);
2175
2176     if(ProcessInfo.hThread)
2177         CloseHandle(ProcessInfo.hThread);
2178
2179     return DeviceInstalled;
2180 }
2181
2182
2183 static LONG
2184 ReadRegSzKey(
2185     IN HKEY hKey,
2186     IN LPCWSTR pszKey,
2187     OUT LPWSTR* pValue)
2188 {
2189     LONG rc;
2190     DWORD dwType;
2191     DWORD cbData = 0;
2192     LPWSTR Value;
2193
2194     if (!pValue)
2195         return ERROR_INVALID_PARAMETER;
2196
2197     *pValue = NULL;
2198     rc = RegQueryValueExW(hKey, pszKey, NULL, &dwType, NULL, &cbData);
2199     if (rc != ERROR_SUCCESS)
2200         return rc;
2201     if (dwType != REG_SZ)
2202         return ERROR_FILE_NOT_FOUND;
2203     Value = HeapAlloc(GetProcessHeap(), 0, cbData + sizeof(WCHAR));
2204     if (!Value)
2205         return ERROR_NOT_ENOUGH_MEMORY;
2206     rc = RegQueryValueExW(hKey, pszKey, NULL, NULL, (LPBYTE)Value, &cbData);
2207     if (rc != ERROR_SUCCESS)
2208     {
2209         HeapFree(GetProcessHeap(), 0, Value);
2210         return rc;
2211     }
2212     /* NULL-terminate the string */
2213     Value[cbData / sizeof(WCHAR)] = '\0';
2214
2215     *pValue = Value;
2216     return ERROR_SUCCESS;
2217 }
2218
2219
2220 static BOOL
2221 SetupIsActive(VOID)
2222 {
2223     HKEY hKey = NULL;
2224     DWORD regType, active, size;
2225     LONG rc;
2226     BOOL ret = FALSE;
2227
2228     rc = RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"SYSTEM\\Setup", 0, KEY_QUERY_VALUE, &hKey);
2229     if (rc != ERROR_SUCCESS)
2230         goto cleanup;
2231
2232     size = sizeof(DWORD);
2233     rc = RegQueryValueExW(hKey, L"SystemSetupInProgress", NULL, &regType, (LPBYTE)&active, &size);
2234     if (rc != ERROR_SUCCESS)
2235         goto cleanup;
2236     if (regType != REG_DWORD || size != sizeof(DWORD))
2237         goto cleanup;
2238
2239     ret = (active != 0);
2240
2241 cleanup:
2242     if (hKey != NULL)
2243         RegCloseKey(hKey);
2244
2245     DPRINT("System setup in progress? %S\n", ret ? L"YES" : L"NO");
2246
2247     return ret;
2248 }
2249
2250
2251 static BOOL
2252 IsConsoleBoot(VOID)
2253 {
2254     HKEY ControlKey = NULL;
2255     LPWSTR SystemStartOptions = NULL;
2256     LPWSTR CurrentOption, NextOption; /* Pointers into SystemStartOptions */
2257     BOOL ConsoleBoot = FALSE;
2258     LONG rc;
2259
2260     rc = RegOpenKeyExW(
2261         HKEY_LOCAL_MACHINE,
2262         L"SYSTEM\\CurrentControlSet\\Control",
2263         0,
2264         KEY_QUERY_VALUE,
2265         &ControlKey);
2266
2267     rc = ReadRegSzKey(ControlKey, L"SystemStartOptions", &SystemStartOptions);
2268     if (rc != ERROR_SUCCESS)
2269         goto cleanup;
2270
2271     /* Check for CMDCONS in SystemStartOptions */
2272     CurrentOption = SystemStartOptions;
2273     while (CurrentOption)
2274     {
2275         NextOption = wcschr(CurrentOption, L' ');
2276         if (NextOption)
2277             *NextOption = L'\0';
2278         if (_wcsicmp(CurrentOption, L"CONSOLE") == 0)
2279         {
2280             DPRINT("Found %S. Switching to console boot\n", CurrentOption);
2281             ConsoleBoot = TRUE;
2282             goto cleanup;
2283         }
2284         CurrentOption = NextOption ? NextOption + 1 : NULL;
2285     }
2286
2287 cleanup:
2288     if (ControlKey != NULL)
2289         RegCloseKey(ControlKey);
2290     HeapFree(GetProcessHeap(), 0, SystemStartOptions);
2291     return ConsoleBoot;
2292 }
2293
2294
2295 /* Loop to install all queued devices installations */
2296 static DWORD WINAPI
2297 DeviceInstallThread(LPVOID lpParameter)
2298 {
2299 #ifdef HAVE_SLIST_ENTRY_IMPLEMENTED
2300     PSLIST_ENTRY ListEntry;
2301 #else
2302     PLIST_ENTRY ListEntry;
2303 #endif
2304     DeviceInstallParams* Params;
2305     BOOL showWizard;
2306
2307     UNREFERENCED_PARAMETER(lpParameter);
2308
2309     WaitForSingleObject(hInstallEvent, INFINITE);
2310
2311     showWizard = !SetupIsActive() && !IsConsoleBoot();
2312
2313     while (TRUE)
2314     {
2315 #ifdef HAVE_SLIST_ENTRY_IMPLEMENTED
2316         ListEntry = InterlockedPopEntrySList(&DeviceInstallListHead);
2317 #else
2318         if ((BOOL)IsListEmpty(&DeviceInstallListHead))
2319             ListEntry = NULL;
2320         else
2321             ListEntry = RemoveHeadList(&DeviceInstallListHead);
2322 #endif
2323         if (ListEntry == NULL)
2324         {
2325             SetEvent(hNoPendingInstalls);
2326             WaitForSingleObject(hDeviceInstallListNotEmpty, INFINITE);
2327         }
2328         else
2329         {
2330             ResetEvent(hNoPendingInstalls);
2331             Params = CONTAINING_RECORD(ListEntry, DeviceInstallParams, ListEntry);
2332             InstallDevice(Params->DeviceIds, showWizard);
2333         }
2334     }
2335
2336     return 0;
2337 }
2338
2339
2340 static DWORD WINAPI
2341 PnpEventThread(LPVOID lpParameter)
2342 {
2343     PPLUGPLAY_EVENT_BLOCK PnpEvent;
2344     ULONG PnpEventSize;
2345     NTSTATUS Status;
2346     RPC_STATUS RpcStatus;
2347
2348     UNREFERENCED_PARAMETER(lpParameter);
2349
2350     PnpEventSize = 0x1000;
2351     PnpEvent = HeapAlloc(GetProcessHeap(), 0, PnpEventSize);
2352     if (PnpEvent == NULL)
2353         return ERROR_OUTOFMEMORY;
2354
2355     for (;;)
2356     {
2357         DPRINT("Calling NtGetPlugPlayEvent()\n");
2358
2359         /* Wait for the next pnp event */
2360         Status = NtGetPlugPlayEvent(0, 0, PnpEvent, PnpEventSize);
2361
2362         /* Resize the buffer for the PnP event if it's too small. */
2363         if (Status == STATUS_BUFFER_TOO_SMALL)
2364         {
2365             PnpEventSize += 0x400;
2366             HeapFree(GetProcessHeap(), 0, PnpEvent);
2367             PnpEvent = HeapAlloc(GetProcessHeap(), 0, PnpEventSize);
2368             if (PnpEvent == NULL)
2369                 return ERROR_OUTOFMEMORY;
2370             continue;
2371         }
2372
2373         if (!NT_SUCCESS(Status))
2374         {
2375             DPRINT("NtGetPlugPlayEvent() failed (Status %lx)\n", Status);
2376             break;
2377         }
2378
2379         /* Process the pnp event */
2380         DPRINT("Received PnP Event\n");
2381         if (UuidEqual(&PnpEvent->EventGuid, (UUID*)&GUID_DEVICE_ENUMERATED, &RpcStatus))
2382         {
2383             DeviceInstallParams* Params;
2384             DWORD len;
2385             DWORD DeviceIdLength;
2386
2387             DPRINT("Device enumerated: %S\n", PnpEvent->TargetDevice.DeviceIds);
2388
2389             DeviceIdLength = lstrlenW(PnpEvent->TargetDevice.DeviceIds);
2390             if (DeviceIdLength)
2391             {
2392                 /* Queue device install (will be dequeued by DeviceInstallThread */
2393                 len = FIELD_OFFSET(DeviceInstallParams, DeviceIds) + (DeviceIdLength + 1) * sizeof(WCHAR);
2394                 Params = HeapAlloc(GetProcessHeap(), 0, len);
2395                 if (Params)
2396                 {
2397                     wcscpy(Params->DeviceIds, PnpEvent->TargetDevice.DeviceIds);
2398 #ifdef HAVE_SLIST_ENTRY_IMPLEMENTED
2399                     InterlockedPushEntrySList(&DeviceInstallListHead, &Params->ListEntry);
2400 #else
2401                     InsertTailList(&DeviceInstallListHead, &Params->ListEntry);
2402 #endif
2403                     SetEvent(hDeviceInstallListNotEmpty);
2404                 }
2405             }
2406         }
2407         else if (UuidEqual(&PnpEvent->EventGuid, (UUID*)&GUID_DEVICE_ARRIVAL, &RpcStatus))
2408         {
2409             DPRINT("Device arrival: %S\n", PnpEvent->TargetDevice.DeviceIds);
2410             /* FIXME: ? */
2411         }
2412         else
2413         {
2414             DPRINT1("Unknown event, GUID {%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}\n",
2415                 PnpEvent->EventGuid.Data1, PnpEvent->EventGuid.Data2, PnpEvent->EventGuid.Data3,
2416                 PnpEvent->EventGuid.Data4[0], PnpEvent->EventGuid.Data4[1], PnpEvent->EventGuid.Data4[2],
2417                 PnpEvent->EventGuid.Data4[3], PnpEvent->EventGuid.Data4[4], PnpEvent->EventGuid.Data4[5],
2418                 PnpEvent->EventGuid.Data4[6], PnpEvent->EventGuid.Data4[7]);
2419         }
2420
2421         /* Dequeue the current pnp event and signal the next one */
2422         NtPlugPlayControl(PlugPlayControlUserResponse, NULL, 0);
2423     }
2424
2425     HeapFree(GetProcessHeap(), 0, PnpEvent);
2426
2427     return ERROR_SUCCESS;
2428 }
2429
2430
2431 static VOID CALLBACK
2432 ServiceMain(DWORD argc, LPTSTR *argv)
2433 {
2434     HANDLE hThread;
2435     DWORD dwThreadId;
2436
2437     UNREFERENCED_PARAMETER(argc);
2438     UNREFERENCED_PARAMETER(argv);
2439
2440     DPRINT("ServiceMain() called\n");
2441
2442     hThread = CreateThread(NULL,
2443                            0,
2444                            PnpEventThread,
2445                            NULL,
2446                            0,
2447                            &dwThreadId);
2448     if (hThread != NULL)
2449         CloseHandle(hThread);
2450
2451     hThread = CreateThread(NULL,
2452                            0,
2453                            RpcServerThread,
2454                            NULL,
2455                            0,
2456                            &dwThreadId);
2457     if (hThread != NULL)
2458         CloseHandle(hThread);
2459
2460     hThread = CreateThread(NULL,
2461                            0,
2462                            DeviceInstallThread,
2463                            NULL,
2464                            0,
2465                            &dwThreadId);
2466     if (hThread != NULL)
2467         CloseHandle(hThread);
2468
2469     DPRINT("ServiceMain() done\n");
2470 }
2471
2472
2473 int
2474 wmain(int argc, WCHAR *argv[])
2475 {
2476     BOOLEAN OldValue;
2477     DWORD dwError;
2478
2479     UNREFERENCED_PARAMETER(argc);
2480     UNREFERENCED_PARAMETER(argv);
2481
2482     DPRINT("Umpnpmgr: main() started\n");
2483
2484     /* We need this privilege for using CreateProcessAsUserW */
2485     RtlAdjustPrivilege(SE_ASSIGNPRIMARYTOKEN_PRIVILEGE, TRUE, FALSE, &OldValue);
2486
2487     hInstallEvent = CreateEvent(NULL, TRUE, SetupIsActive()/*FALSE*/, NULL);
2488     if (hInstallEvent == NULL)
2489     {
2490         dwError = GetLastError();
2491         DPRINT1("Could not create the Install Event! (Error %lu)\n", dwError);
2492         return dwError;
2493     }
2494
2495     hDeviceInstallListNotEmpty = CreateEvent(NULL, FALSE, FALSE, NULL);
2496     if (hDeviceInstallListNotEmpty == NULL)
2497     {
2498         dwError = GetLastError();
2499         DPRINT1("Could not create the Event! (Error %lu)\n", dwError);
2500         return dwError;
2501     }
2502
2503     hNoPendingInstalls = CreateEventW(NULL,
2504                                       TRUE,
2505                                       FALSE,
2506                                       L"Global\\PnP_No_Pending_Install_Events");
2507     if (hNoPendingInstalls == NULL)
2508     {
2509         dwError = GetLastError();
2510         DPRINT1("Could not create the Event! (Error %lu)\n", dwError);
2511         return dwError;
2512     }
2513
2514 #ifdef HAVE_SLIST_ENTRY_IMPLEMENTED
2515     InitializeSListHead(&DeviceInstallListHead);
2516 #else
2517     InitializeListHead(&DeviceInstallListHead);
2518 #endif
2519
2520     dwError = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
2521                             L"System\\CurrentControlSet\\Enum",
2522                             0,
2523                             KEY_ALL_ACCESS,
2524                             &hEnumKey);
2525     if (dwError != ERROR_SUCCESS)
2526     {
2527         DPRINT1("Could not open the Enum Key! (Error %lu)\n", dwError);
2528         return dwError;
2529     }
2530
2531     dwError = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
2532                             L"System\\CurrentControlSet\\Control\\Class",
2533                             0,
2534                             KEY_ALL_ACCESS,
2535                             &hClassKey);
2536     if (dwError != ERROR_SUCCESS)
2537     {
2538         DPRINT1("Could not open the Class Key! (Error %lu)\n", dwError);
2539         return dwError;
2540     }
2541
2542     StartServiceCtrlDispatcher(ServiceTable);
2543
2544     DPRINT("Umpnpmgr: main() done\n");
2545
2546     ExitThread(0);
2547
2548     return 0;
2549 }
2550
2551 /* EOF */