dll/win32/netapi32/netlogon.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         NetAPI DLL
   4  * FILE:            dll/win32/netapi32/netlogon.c
   5  * PURPOSE:         Netlogon service interface code
   6  * PROGRAMMERS:     Eric Kohl (eric.kohl@reactos.org)
   7  */
   8
   9 /* INCLUDES ******************************************************************/
  10
  11 #include "netapi32.h"
  12 #include <winsock2.h>
  13 #include <rpc.h>
  14 #include <dsrole.h>
  15 #include <dsgetdc.h>
  16 #include "netlogon_c.h"
  17
  18 WINE_DEFAULT_DEBUG_CHANNEL(netapi32);
  19
  20 DWORD
  21 WINAPI
  22 DsGetDcNameWithAccountA(
  23     _In_opt_ LPCSTR ComputerName,
  24     _In_opt_ LPCSTR AccountName,
  25     _In_ ULONG AccountControlBits,
  26     _In_ LPCSTR DomainName,
  27     _In_ GUID *DomainGuid,
  28     _In_ LPCSTR SiteName,
  29     _In_ ULONG Flags,
  30     _Out_ PDOMAIN_CONTROLLER_INFOA *DomainControllerInfo);
  31
  32 DWORD
  33 WINAPI
  34 DsGetDcNameWithAccountW(
  35     _In_opt_ LPCWSTR ComputerName,
  36     _In_opt_ LPCWSTR AccountName,
  37     _In_ ULONG AccountControlBits,
  38     _In_ LPCWSTR DomainName,
  39     _In_ GUID *DomainGuid,
  40     _In_ LPCWSTR SiteName,
  41     _In_ ULONG Flags,
  42     _Out_ PDOMAIN_CONTROLLER_INFOW *DomainControllerInfo);
  43
  44 /* FUNCTIONS *****************************************************************/
  45
  46 handle_t
  47 __RPC_USER
  48 LOGONSRV_HANDLE_bind(
  49     LOGONSRV_HANDLE pszSystemName)
  50 {
  51     handle_t hBinding = NULL;
  52     LPWSTR pszStringBinding;
  53     RPC_STATUS status;
  54
  55     TRACE("LOGONSRV_HANDLE_bind() called\n");
  56
  57     status = RpcStringBindingComposeW(NULL,
  58                                       L"ncacn_np",
  59                                       pszSystemName,
  60                                       L"\\pipe\\netlogon",
  61                                       NULL,
  62                                       &pszStringBinding);
  63     if (status)
  64     {
  65         TRACE("RpcStringBindingCompose returned 0x%x\n", status);
  66         return NULL;
  67     }
  68
  69     /* Set the binding handle that will be used to bind to the server. */
  70     status = RpcBindingFromStringBindingW(pszStringBinding,
  71                                           &hBinding);
  72     if (status)
  73     {
  74         TRACE("RpcBindingFromStringBinding returned 0x%x\n", status);
  75     }
  76
  77     status = RpcStringFreeW(&pszStringBinding);
  78     if (status)
  79     {
  80 //        TRACE("RpcStringFree returned 0x%x\n", status);
  81     }
  82
  83     return hBinding;
  84 }
  85
  86
  87 void
  88 __RPC_USER
  89 LOGONSRV_HANDLE_unbind(
  90     LOGONSRV_HANDLE pszSystemName,
  91     handle_t hBinding)
  92 {
  93     RPC_STATUS status;
  94
  95     TRACE("LOGONSRV_HANDLE_unbind() called\n");
  96
  97     status = RpcBindingFree(&hBinding);
  98     if (status)
  99     {
 100         TRACE("RpcBindingFree returned 0x%x\n", status);
 101     }
 102 }
 103
 104
 105 /* PUBLIC FUNCTIONS **********************************************************/
 106
 107 DWORD
 108 WINAPI
 109 DsAddressToSiteNamesA(
 110     _In_opt_ LPCSTR ComputerName,
 111     _In_ DWORD EntryCount,
 112     _In_ PSOCKET_ADDRESS SocketAddresses,
 113     _Out_ LPSTR **SiteNames)
 114 {
 115     FIXME("DsAddressToSiteNamesA(%s, %lu, %p, %p)\n",
 116           debugstr_a(ComputerName), EntryCount, SocketAddresses, SiteNames);
 117     return ERROR_CALL_NOT_IMPLEMENTED;
 118 }
 119
 120
 121 DWORD
 122 WINAPI
 123 DsAddressToSiteNamesW(
 124     _In_opt_ LPCWSTR ComputerName,
 125     _In_ DWORD EntryCount,
 126     _In_ PSOCKET_ADDRESS SocketAddresses,
 127     _Out_ LPWSTR **SiteNames)
 128 {
 129     PNL_SITE_NAME_ARRAY SiteNameArray = NULL;
 130     PWSTR *SiteNamesBuffer = NULL, Ptr;
 131     ULONG BufferSize, i;
 132     NET_API_STATUS status;
 133
 134     TRACE("DsAddressToSiteNamesW(%s, %lu, %p, %p)\n",
 135           debugstr_w(ComputerName), EntryCount, SocketAddresses, SiteNames);
 136
 137     if (EntryCount == 0)
 138         return ERROR_INVALID_PARAMETER;
 139
 140     *SiteNames = NULL;
 141
 142     RpcTryExcept
 143     {
 144         status = DsrAddressToSiteNamesW((PWSTR)ComputerName,
 145                                         EntryCount,
 146                                         (PNL_SOCKET_ADDRESS)SocketAddresses,
 147                                         &SiteNameArray);
 148         if (status == NERR_Success)
 149         {
 150             if (SiteNameArray->EntryCount == 0)
 151             {
 152                 status = ERROR_INVALID_PARAMETER;
 153             }
 154             else
 155             {
 156                 BufferSize = SiteNameArray->EntryCount * sizeof(PWSTR);
 157                 for (i = 0; i < SiteNameArray->EntryCount; i++)
 158                     BufferSize += SiteNameArray->SiteNames[i].Length + sizeof(WCHAR);
 159
 160                 status = NetApiBufferAllocate(BufferSize, (PVOID*)&SiteNamesBuffer);
 161                 if (status == NERR_Success)
 162                 {
 163                     ZeroMemory(SiteNamesBuffer, BufferSize);
 164
 165                     Ptr = (PWSTR)((ULONG_PTR)SiteNamesBuffer + SiteNameArray->EntryCount * sizeof(PWSTR));
 166                     for (i = 0; i < SiteNameArray->EntryCount; i++)
 167                     {
 168                         SiteNamesBuffer[i] = Ptr;
 169                         CopyMemory(Ptr,
 170                                    SiteNameArray->SiteNames[i].Buffer,
 171                                    SiteNameArray->SiteNames[i].Length);
 172
 173                         Ptr = (PWSTR)((ULONG_PTR)Ptr + SiteNameArray->SiteNames[i].Length + sizeof(WCHAR));
 174                     }
 175
 176                     *SiteNames = SiteNamesBuffer;
 177                 }
 178             }
 179
 180             MIDL_user_free(SiteNameArray);
 181         }
 182     }
 183     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 184     {
 185         status = I_RpcMapWin32Status(RpcExceptionCode());
 186     }
 187     RpcEndExcept;
 188
 189     return status;
 190 }
 191
 192
 193 DWORD
 194 WINAPI
 195 DsAddressToSiteNamesExA(
 196     _In_opt_ LPCSTR ComputerName,
 197     _In_ DWORD EntryCount,
 198     _In_ PSOCKET_ADDRESS SocketAddresses,
 199     _Out_ LPSTR **SiteNames,
 200     _Out_ LPSTR **SubnetNames)
 201 {
 202     FIXME("DsAddressToSiteNamesExA(%s, %lu, %p, %p, %p)\n",
 203           debugstr_a(ComputerName), EntryCount, SocketAddresses,
 204           SiteNames, SubnetNames);
 205     return ERROR_CALL_NOT_IMPLEMENTED;
 206 }
 207
 208
 209 DWORD
 210 WINAPI
 211 DsAddressToSiteNamesExW(
 212     _In_opt_ LPCWSTR ComputerName,
 213     _In_ DWORD EntryCount,
 214     _In_ PSOCKET_ADDRESS SocketAddresses,
 215     _Out_ LPWSTR **SiteNames,
 216     _Out_ LPWSTR **SubnetNames)
 217 {
 218     PNL_SITE_NAME_EX_ARRAY SiteNameArray = NULL;
 219     PWSTR *SiteNamesBuffer = NULL, *SubnetNamesBuffer = NULL, Ptr;
 220     ULONG SiteNameBufferSize, SubnetNameBufferSize, i;
 221     NET_API_STATUS status;
 222
 223     TRACE("DsAddressToSiteNamesExW(%s, %lu, %p, %p, %p)\n",
 224           debugstr_w(ComputerName), EntryCount, SocketAddresses,
 225           SiteNames, SubnetNames);
 226
 227     if (EntryCount == 0)
 228         return ERROR_INVALID_PARAMETER;
 229
 230     *SiteNames = NULL;
 231     *SubnetNames = NULL;
 232
 233     RpcTryExcept
 234     {
 235         status = DsrAddressToSiteNamesExW((PWSTR)ComputerName,
 236                                           EntryCount,
 237                                           (PNL_SOCKET_ADDRESS)SocketAddresses,
 238                                           &SiteNameArray);
 239         if (status == NERR_Success)
 240         {
 241             if (SiteNameArray->EntryCount == 0)
 242             {
 243                 status = ERROR_INVALID_PARAMETER;
 244             }
 245             else
 246             {
 247                 SiteNameBufferSize = SiteNameArray->EntryCount * sizeof(PWSTR);
 248                 SubnetNameBufferSize = SiteNameArray->EntryCount * sizeof(PWSTR);
 249                 for (i = 0; i < SiteNameArray->EntryCount; i++)
 250                 {
 251                     SiteNameBufferSize += SiteNameArray->SiteNames[i].Length + sizeof(WCHAR);
 252                     SubnetNameBufferSize += SiteNameArray->SubnetNames[i].Length + sizeof(WCHAR);
 253                 }
 254
 255                 status = NetApiBufferAllocate(SiteNameBufferSize, (PVOID*)&SiteNamesBuffer);
 256                 if (status == NERR_Success)
 257                 {
 258                     ZeroMemory(SiteNamesBuffer, SiteNameBufferSize);
 259
 260                     Ptr = (PWSTR)((ULONG_PTR)SiteNamesBuffer + SiteNameArray->EntryCount * sizeof(PWSTR));
 261                     for (i = 0; i < SiteNameArray->EntryCount; i++)
 262                     {
 263                         SiteNamesBuffer[i] = Ptr;
 264                         CopyMemory(Ptr,
 265                                    SiteNameArray->SiteNames[i].Buffer,
 266                                    SiteNameArray->SiteNames[i].Length);
 267
 268                         Ptr = (PWSTR)((ULONG_PTR)Ptr + SiteNameArray->SiteNames[i].Length + sizeof(WCHAR));
 269                     }
 270
 271                     *SiteNames = SiteNamesBuffer;
 272                 }
 273
 274                 status = NetApiBufferAllocate(SubnetNameBufferSize, (PVOID*)&SubnetNamesBuffer);
 275                 if (status == NERR_Success)
 276                 {
 277                     ZeroMemory(SubnetNamesBuffer, SubnetNameBufferSize);
 278
 279                     Ptr = (PWSTR)((ULONG_PTR)SubnetNamesBuffer + SiteNameArray->EntryCount * sizeof(PWSTR));
 280                     for (i = 0; i < SiteNameArray->EntryCount; i++)
 281                     {
 282                         SubnetNamesBuffer[i] = Ptr;
 283                         CopyMemory(Ptr,
 284                                    SiteNameArray->SubnetNames[i].Buffer,
 285                                    SiteNameArray->SubnetNames[i].Length);
 286
 287                         Ptr = (PWSTR)((ULONG_PTR)Ptr + SiteNameArray->SubnetNames[i].Length + sizeof(WCHAR));
 288                     }
 289
 290                     *SubnetNames = SubnetNamesBuffer;
 291                 }
 292             }
 293
 294             MIDL_user_free(SiteNameArray);
 295         }
 296     }
 297     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 298     {
 299         status = I_RpcMapWin32Status(RpcExceptionCode());
 300     }
 301     RpcEndExcept;
 302
 303     return status;
 304 }
 305
 306
 307 DWORD
 308 WINAPI
 309 DsDeregisterDnsHostRecordsA(
 310     _In_opt_ LPSTR ServerName,
 311     _In_opt_ LPSTR DnsDomainName,
 312     _In_opt_ GUID *DomainGuid,
 313     _In_opt_ GUID *DsaGuid,
 314     _In_ LPSTR DnsHostName)
 315 {
 316     PWSTR pServerNameW = NULL, pDnsDomainNameW = NULL;
 317     PWSTR pDnsHostNameW = NULL;
 318     NET_API_STATUS status = NERR_Success;
 319
 320     TRACE("DsDeregisterDnsHostRecordsA(%s, %s, %p, %p, %s)\n",
 321           debugstr_a(ServerName), debugstr_a(DnsDomainName),
 322           DomainGuid, DsaGuid, debugstr_a(DnsHostName));
 323
 324     if (ServerName != NULL)
 325     {
 326         pServerNameW = NetpAllocWStrFromAnsiStr((PSTR)ServerName);
 327         if (pServerNameW == NULL)
 328         {
 329             status = ERROR_NOT_ENOUGH_MEMORY;
 330             goto done;
 331         }
 332     }
 333
 334     if (DnsDomainName != NULL)
 335     {
 336         pDnsDomainNameW = NetpAllocWStrFromAnsiStr((PSTR)DnsDomainName);
 337         if (pDnsDomainNameW == NULL)
 338         {
 339             status = ERROR_NOT_ENOUGH_MEMORY;
 340             goto done;
 341         }
 342     }
 343
 344     pDnsHostNameW = NetpAllocWStrFromAnsiStr((PSTR)DnsDomainName);
 345     if (pDnsHostNameW == NULL)
 346     {
 347         status = ERROR_NOT_ENOUGH_MEMORY;
 348         goto done;
 349     }
 350
 351     status = DsDeregisterDnsHostRecordsW(pServerNameW,
 352                                          pDnsDomainNameW,
 353                                          DomainGuid,
 354                                          DsaGuid,
 355                                          pDnsHostNameW);
 356
 357 done:
 358     if (pDnsHostNameW != NULL)
 359         NetApiBufferFree(pDnsHostNameW);
 360
 361     if (pDnsDomainNameW != NULL)
 362         NetApiBufferFree(pDnsDomainNameW);
 363
 364     if (pServerNameW != NULL)
 365         NetApiBufferFree(pServerNameW);
 366
 367     return status;
 368 }
 369
 370
 371 DWORD
 372 WINAPI
 373 DsDeregisterDnsHostRecordsW(
 374     _In_opt_ LPWSTR ServerName,
 375     _In_opt_ LPWSTR DnsDomainName,
 376     _In_opt_ GUID *DomainGuid,
 377     _In_opt_ GUID *DsaGuid,
 378     _In_ LPWSTR DnsHostName)
 379 {
 380     NET_API_STATUS status;
 381
 382     TRACE("DsDeregisterDnsHostRecordsW(%s, %s, %p, %p, %s)\n",
 383           debugstr_w(ServerName), debugstr_w(DnsDomainName),
 384           DomainGuid, DsaGuid, debugstr_w(DnsHostName));
 385
 386     RpcTryExcept
 387     {
 388         status = DsrDeregisterDnsHostRecords(ServerName,
 389                                              DnsDomainName,
 390                                              DomainGuid,
 391                                              DsaGuid,
 392                                              DnsHostName);
 393     }
 394     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 395     {
 396         status = I_RpcMapWin32Status(RpcExceptionCode());
 397     }
 398     RpcEndExcept;
 399
 400     return status;
 401 }
 402
 403
 404 DWORD
 405 WINAPI
 406 DsEnumerateDomainTrustsA(
 407     _In_opt_ LPSTR ServerName,
 408     _In_ ULONG Flags,
 409     _Out_ PDS_DOMAIN_TRUSTSA *Domains,
 410     _Out_ PULONG DomainCount)
 411 {
 412     FIXME("DsEnumerateDomainTrustsA(%s, %x, %p, %p)\n",
 413           debugstr_a(ServerName), Flags, Domains, DomainCount);
 414     return ERROR_CALL_NOT_IMPLEMENTED;
 415 }
 416
 417
 418 DWORD
 419 WINAPI
 420 DsEnumerateDomainTrustsW(
 421     _In_opt_ LPWSTR ServerName,
 422     _In_ ULONG Flags,
 423     _Out_ PDS_DOMAIN_TRUSTSW *Domains,
 424     _Out_ PULONG DomainCount)
 425 {
 426     FIXME("DsEnumerateDomainTrustsW(%s, %x, %p, %p)\n",
 427           debugstr_w(ServerName), Flags, Domains, DomainCount);
 428     return ERROR_CALL_NOT_IMPLEMENTED;
 429 }
 430
 431
 432 DWORD
 433 WINAPI
 434 DsGetDcNameA(
 435     _In_opt_ LPCSTR ComputerName,
 436     _In_ LPCSTR DomainName,
 437     _In_ GUID *DomainGuid,
 438     _In_ LPCSTR SiteName,
 439     _In_ ULONG Flags,
 440     _Out_ PDOMAIN_CONTROLLER_INFOA *DomainControllerInfo)
 441 {
 442     TRACE("DsGetDcNameA(%s, %s, %s, %s, %08lx, %p): stub\n",
 443           debugstr_a(ComputerName), debugstr_a(DomainName), debugstr_guid(DomainGuid),
 444           debugstr_a(SiteName), Flags, DomainControllerInfo);
 445     return DsGetDcNameWithAccountA(ComputerName,
 446                                    NULL,
 447                                    0,
 448                                    DomainName,
 449                                    DomainGuid,
 450                                    SiteName,
 451                                    Flags,
 452                                    DomainControllerInfo);
 453 }
 454
 455
 456 DWORD
 457 WINAPI
 458 DsGetDcNameW(
 459     _In_opt_ LPCWSTR ComputerName,
 460     _In_ LPCWSTR DomainName,
 461     _In_ GUID *DomainGuid,
 462     _In_ LPCWSTR SiteName,
 463     _In_ ULONG Flags,
 464     _Out_ PDOMAIN_CONTROLLER_INFOW *DomainControllerInfo)
 465 {
 466     TRACE("DsGetDcNameW(%s, %s, %s, %s, %08lx, %p)\n",
 467           debugstr_w(ComputerName), debugstr_w(DomainName), debugstr_guid(DomainGuid),
 468           debugstr_w(SiteName), Flags, DomainControllerInfo);
 469     return DsGetDcNameWithAccountW(ComputerName,
 470                                    NULL,
 471                                    0,
 472                                    DomainName,
 473                                    DomainGuid,
 474                                    SiteName,
 475                                    Flags,
 476                                    DomainControllerInfo);
 477 }
 478
 479
 480 DWORD
 481 WINAPI
 482 DsGetDcNameWithAccountA(
 483     _In_opt_ LPCSTR ComputerName,
 484     _In_opt_ LPCSTR AccountName,
 485     _In_ ULONG AccountControlBits,
 486     _In_ LPCSTR DomainName,
 487     _In_ GUID *DomainGuid,
 488     _In_ LPCSTR SiteName,
 489     _In_ ULONG Flags,
 490     _Out_ PDOMAIN_CONTROLLER_INFOA *DomainControllerInfo)
 491 {
 492     PWSTR pComputerNameW = NULL, pAccountNameW = NULL;
 493     PWSTR pDomainNameW = NULL, pSiteNameW = NULL;
 494     PDOMAIN_CONTROLLER_INFOW pDomainControllerInfoW = NULL;
 495     PDOMAIN_CONTROLLER_INFOA pDomainControllerInfoA = NULL;
 496     UNICODE_STRING UnicodeString;
 497     ANSI_STRING AnsiString;
 498     PSTR Ptr;
 499     ULONG BufferSize;
 500     NTSTATUS Status;
 501     NET_API_STATUS status = NERR_Success;
 502
 503     TRACE("DsGetDcNameWithAccountA(%s, %s, %08lx, %s, %s, %s, %08lx, %p): stub\n",
 504           debugstr_a(ComputerName), debugstr_a(AccountName), AccountControlBits,
 505           debugstr_a(DomainName), debugstr_guid(DomainGuid),
 506           debugstr_a(SiteName), Flags, DomainControllerInfo);
 507
 508     if (ComputerName != NULL)
 509     {
 510         pComputerNameW = NetpAllocWStrFromAnsiStr((PSTR)ComputerName);
 511         if (pComputerNameW == NULL)
 512         {
 513             status = ERROR_NOT_ENOUGH_MEMORY;
 514             goto done;
 515         }
 516     }
 517
 518     if (AccountName != NULL)
 519     {
 520         pAccountNameW = NetpAllocWStrFromAnsiStr((PSTR)AccountName);
 521         if (pAccountNameW == NULL)
 522         {
 523             status = ERROR_NOT_ENOUGH_MEMORY;
 524             goto done;
 525         }
 526     }
 527
 528     pDomainNameW = NetpAllocWStrFromAnsiStr((PSTR)DomainName);
 529     if (pDomainNameW == NULL)
 530     {
 531         status = ERROR_NOT_ENOUGH_MEMORY;
 532         goto done;
 533     }
 534
 535     pSiteNameW = NetpAllocWStrFromAnsiStr((PSTR)SiteName);
 536     if (pSiteNameW == NULL)
 537     {
 538         status = ERROR_NOT_ENOUGH_MEMORY;
 539         goto done;
 540     }
 541
 542     status = DsGetDcNameWithAccountW(pComputerNameW,
 543                                      pAccountNameW,
 544                                      AccountControlBits,
 545                                      pDomainNameW,
 546                                      DomainGuid,
 547                                      pSiteNameW,
 548                                      Flags,
 549                                      &pDomainControllerInfoW);
 550     if (status != NERR_Success)
 551         goto done;
 552
 553     BufferSize = sizeof(DOMAIN_CONTROLLER_INFOA);
 554
 555     RtlInitUnicodeString(&UnicodeString,
 556                          pDomainControllerInfoW->DomainControllerName);
 557     BufferSize += RtlUnicodeStringToAnsiSize(&UnicodeString);
 558
 559     RtlInitUnicodeString(&UnicodeString,
 560                          pDomainControllerInfoW->DomainControllerAddress);
 561     BufferSize += RtlUnicodeStringToAnsiSize(&UnicodeString);
 562
 563     RtlInitUnicodeString(&UnicodeString,
 564                          pDomainControllerInfoW->DomainName);
 565     BufferSize += RtlUnicodeStringToAnsiSize(&UnicodeString);
 566
 567     RtlInitUnicodeString(&UnicodeString,
 568                          pDomainControllerInfoW->DnsForestName);
 569     BufferSize += RtlUnicodeStringToAnsiSize(&UnicodeString);
 570
 571     if (pDomainControllerInfoW->DcSiteName != NULL)
 572     {
 573         RtlInitUnicodeString(&UnicodeString,
 574                              pDomainControllerInfoW->DcSiteName);
 575         BufferSize += RtlUnicodeStringToAnsiSize(&UnicodeString);
 576     }
 577
 578     if (pDomainControllerInfoW->ClientSiteName != NULL)
 579     {
 580         RtlInitUnicodeString(&UnicodeString,
 581                              pDomainControllerInfoW->ClientSiteName);
 582         BufferSize += RtlUnicodeStringToAnsiSize(&UnicodeString);
 583     }
 584
 585     /* Allocate the ANSI buffer */
 586     status = NetApiBufferAllocate(BufferSize, (PVOID*)&pDomainControllerInfoA);
 587     if (status != NERR_Success)
 588         goto done;
 589
 590     pDomainControllerInfoA->DomainControllerAddressType =
 591         pDomainControllerInfoW->DomainControllerAddressType;
 592
 593     pDomainControllerInfoA->Flags = pDomainControllerInfoW->Flags;
 594
 595     CopyMemory(&pDomainControllerInfoA->DomainGuid,
 596                &pDomainControllerInfoW->DomainGuid,
 597                sizeof(GUID));
 598
 599     Ptr = (PSTR)((ULONG_PTR)pDomainControllerInfoA + sizeof(DOMAIN_CONTROLLER_INFOA));
 600     BufferSize -= sizeof(DOMAIN_CONTROLLER_INFOA);
 601
 602     pDomainControllerInfoA->DomainControllerName = Ptr;
 603     RtlInitUnicodeString(&UnicodeString,
 604                          pDomainControllerInfoW->DomainControllerName);
 605     AnsiString.Length = 0;
 606     AnsiString.MaximumLength = BufferSize;
 607     AnsiString.Buffer = Ptr;
 608
 609     Status = RtlUnicodeStringToAnsiString(&AnsiString,
 610                                           &UnicodeString,
 611                                           FALSE);
 612     if (!NT_SUCCESS(Status))
 613     {
 614         status = RtlNtStatusToDosError(Status);
 615         goto done;
 616     }
 617
 618     Ptr = (PSTR)((ULONG_PTR)Ptr + AnsiString.Length + sizeof(CHAR));
 619     BufferSize -= AnsiString.Length + sizeof(CHAR);
 620
 621     pDomainControllerInfoA->DomainControllerAddress = Ptr;
 622     RtlInitUnicodeString(&UnicodeString,
 623                          pDomainControllerInfoW->DomainControllerAddress);
 624     AnsiString.Length = 0;
 625     AnsiString.MaximumLength = BufferSize;
 626     AnsiString.Buffer = Ptr;
 627
 628     Status = RtlUnicodeStringToAnsiString(&AnsiString,
 629                                           &UnicodeString,
 630                                           FALSE);
 631     if (!NT_SUCCESS(Status))
 632     {
 633         status = RtlNtStatusToDosError(Status);
 634         goto done;
 635     }
 636
 637     Ptr = (PSTR)((ULONG_PTR)Ptr + AnsiString.Length + sizeof(CHAR));
 638     BufferSize -= AnsiString.Length + sizeof(CHAR);
 639
 640     pDomainControllerInfoA->DomainName = Ptr;
 641     RtlInitUnicodeString(&UnicodeString,
 642                          pDomainControllerInfoW->DomainName);
 643     AnsiString.Length = 0;
 644     AnsiString.MaximumLength = BufferSize;
 645     AnsiString.Buffer = Ptr;
 646
 647     Status = RtlUnicodeStringToAnsiString(&AnsiString,
 648                                           &UnicodeString,
 649                                           FALSE);
 650     if (!NT_SUCCESS(Status))
 651     {
 652         status = RtlNtStatusToDosError(Status);
 653         goto done;
 654     }
 655
 656     Ptr = (PSTR)((ULONG_PTR)Ptr + AnsiString.Length + sizeof(CHAR));
 657     BufferSize -= AnsiString.Length + sizeof(CHAR);
 658
 659     pDomainControllerInfoA->DnsForestName = Ptr;
 660     RtlInitUnicodeString(&UnicodeString,
 661                          pDomainControllerInfoW->DnsForestName);
 662     AnsiString.Length = 0;
 663     AnsiString.MaximumLength = BufferSize;
 664     AnsiString.Buffer = Ptr;
 665
 666     Status = RtlUnicodeStringToAnsiString(&AnsiString,
 667                                           &UnicodeString,
 668                                           FALSE);
 669     if (!NT_SUCCESS(Status))
 670     {
 671         status = RtlNtStatusToDosError(Status);
 672         goto done;
 673     }
 674
 675     Ptr = (PSTR)((ULONG_PTR)Ptr + AnsiString.Length + sizeof(CHAR));
 676     BufferSize -= AnsiString.Length + sizeof(CHAR);
 677
 678     if (pDomainControllerInfoW->DcSiteName != NULL)
 679     {
 680         pDomainControllerInfoA->DcSiteName = Ptr;
 681         RtlInitUnicodeString(&UnicodeString,
 682                              pDomainControllerInfoW->DcSiteName);
 683         AnsiString.Length = 0;
 684         AnsiString.MaximumLength = BufferSize;
 685         AnsiString.Buffer = Ptr;
 686
 687         Status = RtlUnicodeStringToAnsiString(&AnsiString,
 688                                               &UnicodeString,
 689                                               FALSE);
 690         if (!NT_SUCCESS(Status))
 691         {
 692             status = RtlNtStatusToDosError(Status);
 693             goto done;
 694         }
 695
 696         Ptr = (PSTR)((ULONG_PTR)Ptr + AnsiString.Length + sizeof(CHAR));
 697         BufferSize -= AnsiString.Length + sizeof(CHAR);
 698     }
 699
 700     if (pDomainControllerInfoW->ClientSiteName != NULL)
 701     {
 702         pDomainControllerInfoA->ClientSiteName = Ptr;
 703         RtlInitUnicodeString(&UnicodeString,
 704                              pDomainControllerInfoW->ClientSiteName);
 705         AnsiString.Length = 0;
 706         AnsiString.MaximumLength = BufferSize;
 707         AnsiString.Buffer = Ptr;
 708
 709         Status = RtlUnicodeStringToAnsiString(&AnsiString,
 710                                               &UnicodeString,
 711                                               FALSE);
 712         if (!NT_SUCCESS(Status))
 713         {
 714             status = RtlNtStatusToDosError(Status);
 715             goto done;
 716         }
 717     }
 718
 719     *DomainControllerInfo = pDomainControllerInfoA;
 720     pDomainControllerInfoA = NULL;
 721
 722 done:
 723     if (pDomainControllerInfoA != NULL)
 724         NetApiBufferFree(pDomainControllerInfoA);
 725
 726     if (pDomainControllerInfoW != NULL)
 727         NetApiBufferFree(pDomainControllerInfoW);
 728
 729     if (pSiteNameW != NULL)
 730         NetApiBufferFree(pSiteNameW);
 731
 732     if (pDomainNameW != NULL)
 733         NetApiBufferFree(pDomainNameW);
 734
 735     if (pAccountNameW != NULL)
 736         NetApiBufferFree(pAccountNameW);
 737
 738     if (pComputerNameW != NULL)
 739         NetApiBufferFree(pComputerNameW);
 740
 741     return status;
 742 }
 743
 744
 745 DWORD
 746 WINAPI
 747 DsGetDcNameWithAccountW(
 748     _In_opt_ LPCWSTR ComputerName,
 749     _In_opt_ LPCWSTR AccountName,
 750     _In_ ULONG AccountControlBits,
 751     _In_ LPCWSTR DomainName,
 752     _In_ GUID *DomainGuid,
 753     _In_ LPCWSTR SiteName,
 754     _In_ ULONG Flags,
 755     _Out_ PDOMAIN_CONTROLLER_INFOW *DomainControllerInfo)
 756 {
 757     NET_API_STATUS status;
 758
 759     TRACE("DsGetDcNameWithAccountW(%s, %s, %08lx, %s, %s, %s, %08lx, %p): stub\n",
 760           debugstr_w(ComputerName), debugstr_w(AccountName), AccountControlBits,
 761           debugstr_w(DomainName), debugstr_guid(DomainGuid),
 762           debugstr_w(SiteName), Flags, DomainControllerInfo);
 763
 764     RpcTryExcept
 765     {
 766         status = DsrGetDcNameEx2((PWSTR)ComputerName,
 767                                  (PWSTR)AccountName,
 768                                  AccountControlBits,
 769                                  (PWSTR)DomainName,
 770                                  DomainGuid,
 771                                  (PWSTR)SiteName,
 772                                  Flags,
 773                                  DomainControllerInfo);
 774     }
 775     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 776     {
 777         status = I_RpcMapWin32Status(RpcExceptionCode());
 778     }
 779     RpcEndExcept;
 780
 781     return status;
 782 }
 783
 784
 785 DWORD
 786 WINAPI
 787 DsGetDcSiteCoverageA(
 788     _In_opt_ LPCSTR ServerName,
 789     _Out_ PULONG EntryCount,
 790     _Out_ LPSTR **SiteNames)
 791 {
 792     PWSTR pServerNameW = NULL;
 793     PWSTR *pSiteNamesW = NULL;
 794     PSTR *pSiteNamesA = NULL;
 795     UNICODE_STRING UnicodeString;
 796     ANSI_STRING AnsiString;
 797     PSTR Ptr;
 798     ULONG BufferSize, i;
 799     NTSTATUS Status;
 800     NET_API_STATUS status = NERR_Success;
 801
 802     TRACE("DsGetDcSiteCoverageA(%s, %p, %p)\n",
 803           debugstr_a(ServerName), EntryCount, SiteNames);
 804
 805     if (ServerName != NULL)
 806     {
 807         pServerNameW = NetpAllocWStrFromAnsiStr((PSTR)ServerName);
 808         if (pServerNameW == NULL)
 809         {
 810             status = ERROR_NOT_ENOUGH_MEMORY;
 811             goto done;
 812         }
 813     }
 814
 815     status = DsGetDcSiteCoverageW(pServerNameW,
 816                                   EntryCount,
 817                                   &pSiteNamesW);
 818     if (status != ERROR_SUCCESS)
 819         goto done;
 820
 821     BufferSize = *EntryCount * sizeof(PSTR);
 822     for (i = 0; i < *EntryCount; i++)
 823     {
 824         RtlInitUnicodeString(&UnicodeString, pSiteNamesW[i]);
 825         BufferSize += RtlUnicodeStringToAnsiSize(&UnicodeString);
 826     }
 827
 828     status = NetApiBufferAllocate(BufferSize, (PVOID*)&pSiteNamesA);
 829     if (status != NERR_Success)
 830         goto done;
 831
 832     ZeroMemory(pSiteNamesA, BufferSize);
 833
 834     Ptr = (PSTR)((ULONG_PTR)pSiteNamesA + *EntryCount * sizeof(PSTR));
 835     for (i = 0; i < *EntryCount; i++)
 836     {
 837         pSiteNamesA[i] = Ptr;
 838
 839         RtlInitUnicodeString(&UnicodeString, pSiteNamesW[i]);
 840
 841         AnsiString.Length = 0;
 842         AnsiString.MaximumLength = BufferSize;
 843         AnsiString.Buffer = Ptr;
 844
 845         Status = RtlUnicodeStringToAnsiString(&AnsiString,
 846                                               &UnicodeString,
 847                                               FALSE);
 848         if (!NT_SUCCESS(Status))
 849         {
 850             status = RtlNtStatusToDosError(Status);
 851             goto done;
 852         }
 853
 854         Ptr = (PSTR)((ULONG_PTR)Ptr + AnsiString.Length + sizeof(CHAR));
 855         BufferSize -= (AnsiString.Length + sizeof(CHAR));
 856     }
 857
 858     *SiteNames = pSiteNamesA;
 859     pSiteNamesA = NULL;
 860
 861 done:
 862     if (status != NERR_Success && pSiteNamesA != NULL)
 863         NetApiBufferFree(pSiteNamesA);
 864
 865     if (pSiteNamesW != NULL)
 866         NetApiBufferFree(pSiteNamesW);
 867
 868     if (pServerNameW != NULL)
 869         NetApiBufferFree(pServerNameW);
 870
 871     return status;
 872 }
 873
 874
 875 DWORD
 876 WINAPI
 877 DsGetDcSiteCoverageW(
 878     _In_opt_ LPCWSTR ServerName,
 879     _Out_ PULONG EntryCount,
 880     _Out_ LPWSTR **SiteNames)
 881 {
 882     PNL_SITE_NAME_ARRAY SiteNameArray = NULL;
 883     PWSTR *SiteNamesBuffer = NULL, Ptr;
 884     ULONG BufferSize, i;
 885     NET_API_STATUS status;
 886
 887     TRACE("DsGetDcSiteCoverageW(%s, %p, %p)\n",
 888           debugstr_w(ServerName), EntryCount, SiteNames);
 889
 890     *EntryCount = 0;
 891     *SiteNames = NULL;
 892
 893     RpcTryExcept
 894     {
 895         status = DsrGetDcSiteCoverageW((PWSTR)ServerName,
 896                                        &SiteNameArray);
 897         if (status == NERR_Success)
 898         {
 899             if (SiteNameArray->EntryCount == 0)
 900             {
 901                 status = ERROR_INVALID_PARAMETER;
 902             }
 903             else
 904             {
 905                 BufferSize = SiteNameArray->EntryCount * sizeof(PWSTR);
 906                 for (i = 0; i < SiteNameArray->EntryCount; i++)
 907                     BufferSize += SiteNameArray->SiteNames[i].Length + sizeof(WCHAR);
 908
 909                 status = NetApiBufferAllocate(BufferSize, (PVOID*)&SiteNamesBuffer);
 910                 if (status == NERR_Success)
 911                 {
 912                     ZeroMemory(SiteNamesBuffer, BufferSize);
 913
 914                     Ptr = (PWSTR)((ULONG_PTR)SiteNamesBuffer + SiteNameArray->EntryCount * sizeof(PWSTR));
 915                     for (i = 0; i < SiteNameArray->EntryCount; i++)
 916                     {
 917                         SiteNamesBuffer[i] = Ptr;
 918                         CopyMemory(Ptr,
 919                                    SiteNameArray->SiteNames[i].Buffer,
 920                                    SiteNameArray->SiteNames[i].Length);
 921
 922                         Ptr = (PWSTR)((ULONG_PTR)Ptr + SiteNameArray->SiteNames[i].Length + sizeof(WCHAR));
 923                     }
 924
 925                     *EntryCount = SiteNameArray->EntryCount;
 926                     *SiteNames = SiteNamesBuffer;
 927                 }
 928             }
 929
 930             MIDL_user_free(SiteNameArray);
 931         }
 932     }
 933     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 934     {
 935         status = I_RpcMapWin32Status(RpcExceptionCode());
 936     }
 937     RpcEndExcept;
 938
 939     return status;
 940 }
 941
 942
 943 DWORD
 944 WINAPI
 945 DsGetForestTrustInformationW(
 946     _In_opt_ LPCWSTR ServerName,
 947     _In_opt_ LPCWSTR TrustedDomainName,
 948     _In_ DWORD Flags,
 949     _Out_ PLSA_FOREST_TRUST_INFORMATION *ForestTrustInfo)
 950 {
 951     NET_API_STATUS status;
 952
 953     TRACE("DsGetForestTrustInformationW(%s, %s, 0x%08lx, %p)\n",
 954           debugstr_w(ServerName), debugstr_w(TrustedDomainName),
 955           Flags, ForestTrustInfo);
 956
 957     RpcTryExcept
 958     {
 959         status = DsrGetForestTrustInformation((PWSTR)ServerName,
 960                                               (PWSTR)TrustedDomainName,
 961                                               Flags,
 962                                               ForestTrustInfo);
 963     }
 964     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 965     {
 966         status = I_RpcMapWin32Status(RpcExceptionCode());
 967     }
 968     RpcEndExcept;
 969
 970     return status;
 971 }
 972
 973
 974 DWORD
 975 WINAPI
 976 DsGetSiteNameA(
 977     _In_opt_ LPCSTR ComputerName,
 978     _Out_ LPSTR *SiteName)
 979 {
 980     PWSTR pComputerNameW = NULL;
 981     PWSTR pSiteNameW = NULL;
 982     NET_API_STATUS status = ERROR_SUCCESS;
 983
 984     TRACE("DsGetSiteNameA(%s, %p)\n",
 985           debugstr_a(ComputerName), SiteName);
 986
 987     if (ComputerName != NULL)
 988     {
 989         pComputerNameW = NetpAllocWStrFromAnsiStr((PSTR)ComputerName);
 990         if (pComputerNameW == NULL)
 991         {
 992             status = ERROR_NOT_ENOUGH_MEMORY;
 993             goto done;
 994         }
 995     }
 996
 997     status = DsGetSiteNameW(pComputerNameW,
 998                             &pSiteNameW);
 999     if (status != ERROR_SUCCESS)
1000         goto done;
1001
1002     *SiteName = NetpAllocAnsiStrFromWStr(pSiteNameW);
1003     if (*SiteName == NULL)
1004     {
1005         status = ERROR_NOT_ENOUGH_MEMORY;
1006     }
1007
1008 done:
1009     if (pSiteNameW != NULL)
1010         NetApiBufferFree(pSiteNameW);
1011
1012     if (pComputerNameW != NULL)
1013         NetApiBufferFree(pComputerNameW);
1014
1015     return status;
1016 }
1017
1018
1019 DWORD
1020 WINAPI
1021 DsGetSiteNameW(
1022     _In_opt_ LPCWSTR ComputerName,
1023     _Out_ LPWSTR *SiteName)
1024 {
1025     NET_API_STATUS status;
1026
1027     TRACE("DsGetSiteNameW(%s, %p)\n",
1028           debugstr_w(ComputerName), SiteName);
1029
1030     RpcTryExcept
1031     {
1032         status = DsrGetSiteName((PWSTR)ComputerName,
1033                                 SiteName);
1034     }
1035     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1036     {
1037         status = I_RpcMapWin32Status(RpcExceptionCode());
1038     }
1039     RpcEndExcept;
1040
1041     return status;
1042 }
1043
1044
1045 DWORD
1046 WINAPI
1047 DsMergeForestTrustInformationW(
1048     _In_ LPCWSTR DomainName,
1049     _In_ PLSA_FOREST_TRUST_INFORMATION NewForestTrustInfo,
1050     _In_opt_ PLSA_FOREST_TRUST_INFORMATION OldForestTrustInfo,
1051     _Out_ PLSA_FOREST_TRUST_INFORMATION *ForestTrustInfo)
1052 {
1053     FIXME("DsMergeForestTrustInformationW(%s, %p, %p, %p)\n",
1054           debugstr_w(DomainName), NewForestTrustInfo,
1055           OldForestTrustInfo, ForestTrustInfo);
1056     return ERROR_CALL_NOT_IMPLEMENTED;
1057 }
1058
1059
1060 DWORD
1061 WINAPI
1062 DsValidateSubnetNameA(
1063     _In_ LPCSTR SubnetName)
1064 {
1065     FIXME("DsValidateSubnetNameA(%s)\n",
1066           debugstr_a(SubnetName));
1067     return ERROR_CALL_NOT_IMPLEMENTED;
1068 }
1069
1070
1071 DWORD
1072 WINAPI
1073 DsValidateSubnetNameW(
1074     _In_ LPCWSTR SubnetName)
1075 {
1076     FIXME("DsValidateSubnetNameW(%s)\n",
1077           debugstr_w(SubnetName));
1078     return ERROR_CALL_NOT_IMPLEMENTED;
1079 }
1080
1081
1082 NTSTATUS
1083 WINAPI
1084 NetEnumerateTrustedDomains(
1085     _In_ LPWSTR ServerName,
1086     _Out_ LPWSTR *DomainNames)
1087 {
1088     DOMAIN_NAME_BUFFER DomainNameBuffer = {0, NULL};
1089     NTSTATUS Status = 0;
1090
1091     TRACE("NetEnumerateTrustedDomains(%s, %p)\n",
1092           debugstr_w(ServerName), DomainNames);
1093
1094     RpcTryExcept
1095     {
1096         Status = NetrEnumerateTrustedDomains(ServerName,
1097                                              &DomainNameBuffer);
1098         if (NT_SUCCESS(Status))
1099         {
1100             *DomainNames = (LPWSTR)DomainNameBuffer.DomainNames;
1101         }
1102     }
1103     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1104     {
1105         Status = I_RpcMapWin32Status(RpcExceptionCode());
1106     } RpcEndExcept;
1107
1108     return Status;
1109 }
1110
1111
1112 NET_API_STATUS
1113 WINAPI
1114 NetGetAnyDCName(
1115     _In_opt_ LPCWSTR ServerName,
1116     _In_opt_ LPCWSTR DomainName,
1117     _Out_ LPBYTE *BufPtr)
1118 {
1119     NET_API_STATUS Status;
1120
1121     TRACE("NetGetAnyDCName(%s, %s, %p)\n",
1122           debugstr_w(ServerName), debugstr_w(DomainName), BufPtr);
1123
1124     *BufPtr = NULL;
1125
1126     RpcTryExcept
1127     {
1128         Status = NetrGetAnyDCName((PWSTR)ServerName,
1129                                   (PWSTR)DomainName,
1130                                   (PWSTR*)BufPtr);
1131     }
1132     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1133     {
1134         Status = I_RpcMapWin32Status(RpcExceptionCode());
1135     }
1136     RpcEndExcept;
1137
1138     return Status;
1139 }
1140
1141
1142 NET_API_STATUS
1143 WINAPI
1144 NetGetDCName(
1145     _In_opt_ LPCWSTR ServerName,
1146     _In_opt_ LPCWSTR DomainName,
1147     _Out_ LPBYTE *BufPtr)
1148 {
1149     PDOMAIN_CONTROLLER_INFOW pDomainControllerInfo = NULL;
1150     NET_API_STATUS Status;
1151
1152     FIXME("NetGetDCName(%s, %s, %p)\n",
1153           debugstr_w(ServerName), debugstr_w(DomainName), BufPtr);
1154
1155     if (ServerName == NULL || *ServerName == UNICODE_NULL)
1156     {
1157         Status = DsGetDcNameWithAccountW(NULL,
1158                                          NULL,
1159                                          0,
1160                                          DomainName,
1161                                          NULL,
1162                                          NULL,
1163                                          0, //???
1164                                          &pDomainControllerInfo);
1165         if (Status != NERR_Success)
1166             goto done;
1167
1168         Status = NetApiBufferAllocate((wcslen(pDomainControllerInfo->DomainControllerName) + 1) * sizeof(WCHAR),
1169                                       (PVOID*)BufPtr);
1170         if (Status != NERR_Success)
1171             goto done;
1172
1173         wcscpy((PWSTR)*BufPtr,
1174                pDomainControllerInfo->DomainControllerName);
1175     }
1176     else
1177     {
1178         FIXME("Not implemented yet!\n");
1179         Status = NERR_DCNotFound;
1180     }
1181
1182 done:
1183     if (pDomainControllerInfo != NULL)
1184         NetApiBufferFree(pDomainControllerInfo);
1185
1186     return Status;
1187 }
1188
1189
1190 NET_API_STATUS
1191 WINAPI
1192 NetLogonGetTimeServiceParentDomain(
1193     _In_ LPWSTR ServerName,
1194     _Out_ LPWSTR *DomainName,
1195     _Out_ LPBOOL PdcSameSite)
1196 {
1197     NET_API_STATUS Status;
1198
1199     TRACE("NetLogonGetTimeServiceParentDomain(%s, %p, %p)\n",
1200           debugstr_w(ServerName), DomainName, PdcSameSite);
1201
1202     RpcTryExcept
1203     {
1204         Status = NetrLogonGetTimeServiceParentDomain(ServerName,
1205                                                      DomainName,
1206                                                      PdcSameSite);
1207     }
1208     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1209     {
1210         Status = I_RpcMapWin32Status(RpcExceptionCode());
1211     }
1212     RpcEndExcept;
1213
1214     return Status;
1215 }
1216
1217
1218 NTSTATUS
1219 WINAPI
1220 NetLogonSetServiceBits(
1221     _In_ LPWSTR ServerName,
1222     _In_ DWORD ServiceBitsOfInterest,
1223     _In_ DWORD ServiceBits)
1224 {
1225     NTSTATUS Status;
1226
1227     TRACE("NetLogonSetServiceBits(%s 0x%lx 0x%lx)\n",
1228           debugstr_w(ServerName), ServiceBitsOfInterest, ServiceBits);
1229
1230     RpcTryExcept
1231     {
1232         Status = NetrLogonSetServiceBits(ServerName,
1233                                          ServiceBitsOfInterest,
1234                                          ServiceBits);
1235     }
1236     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1237     {
1238         Status = RpcExceptionCode();
1239     }
1240     RpcEndExcept;
1241
1242     return Status;
1243 }
1244
1245 /* EOF */