reactos/dll/win32/netapi32/srvsvc.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         NetAPI DLL
   4  * FILE:            reactos/dll/win32/netapi32/srvsvc.c
   5  * PURPOSE:         Server service interface code
   6  * PROGRAMMERS:     Eric Kohl <eric.kohl@reactos.org>
   7  */
   8
   9 /* INCLUDES ******************************************************************/
  10
  11 #include "netapi32.h"
  12 #include "srvsvc_c.h"
  13
  14 WINE_DEFAULT_DEBUG_CHANNEL(netapi32);
  15
  16 /* FUNCTIONS *****************************************************************/
  17
  18 handle_t __RPC_USER
  19 SRVSVC_HANDLE_bind(SRVSVC_HANDLE pszSystemName)
  20 {
  21     handle_t hBinding = NULL;
  22     LPWSTR pszStringBinding;
  23     RPC_STATUS status;
  24
  25     TRACE("SRVSVC_HANDLE_bind() called\n");
  26
  27     status = RpcStringBindingComposeW(NULL,
  28                                       L"ncacn_np",
  29                                       (RPC_WSTR)pszSystemName,
  30                                       L"\\pipe\\srvsvc",
  31                                       NULL,
  32                                       &pszStringBinding);
  33     if (status)
  34     {
  35         TRACE("RpcStringBindingCompose returned 0x%x\n", status);
  36         return NULL;
  37     }
  38
  39     /* Set the binding handle that will be used to bind to the server. */
  40     status = RpcBindingFromStringBindingW(pszStringBinding,
  41                                           &hBinding);
  42     if (status)
  43     {
  44         TRACE("RpcBindingFromStringBinding returned 0x%x\n", status);
  45     }
  46
  47     status = RpcStringFreeW(&pszStringBinding);
  48     if (status)
  49     {
  50 //        TRACE("RpcStringFree returned 0x%x\n", status);
  51     }
  52
  53     return hBinding;
  54 }
  55
  56
  57 void __RPC_USER
  58 SRVSVC_HANDLE_unbind(SRVSVC_HANDLE pszSystemName,
  59                      handle_t hBinding)
  60 {
  61     RPC_STATUS status;
  62
  63     TRACE("SRVSVC_HANDLE_unbind() called\n");
  64
  65     status = RpcBindingFree(&hBinding);
  66     if (status)
  67     {
  68         TRACE("RpcBindingFree returned 0x%x\n", status);
  69     }
  70 }
  71
  72
  73 NET_API_STATUS
  74 WINAPI
  75 NetFileClose(
  76     _In_ LMSTR servername,
  77     _In_ DWORD fileid)
  78 {
  79     NET_API_STATUS status;
  80
  81     TRACE("NetFileClose(%s %lu)\n",
  82           debugstr_w(servername), fileid);
  83
  84     RpcTryExcept
  85     {
  86         status = NetrFileClose(servername,
  87                                fileid);
  88     }
  89     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
  90     {
  91         status = I_RpcMapWin32Status(RpcExceptionCode());
  92     }
  93     RpcEndExcept;
  94
  95     return status;
  96 }
  97
  98
  99 NET_API_STATUS
 100 WINAPI
 101 NetFileEnum(
 102     _In_ LMSTR servername,
 103     _In_ LMSTR basepath,
 104     _In_ LMSTR username,
 105     _In_ DWORD level,
 106     _Out_ LPBYTE *bufptr,
 107     _In_ DWORD prefmaxlen,
 108     _Out_ LPDWORD entriesread,
 109     _Out_ LPDWORD totalentries,
 110     _Inout_ PDWORD_PTR resume_handle)
 111 {
 112     FILE_ENUM_STRUCT EnumStruct;
 113     FILE_INFO_2_CONTAINER Level2Container = {0, NULL};
 114     FILE_INFO_3_CONTAINER Level3Container = {0, NULL};
 115     NET_API_STATUS status;
 116
 117     TRACE("NetFileEnum(%s %s %s %lu %p %lu %p %p %p)\n",
 118           debugstr_w(servername), debugstr_w(basepath), debugstr_w(username),
 119           level, bufptr, prefmaxlen, entriesread, totalentries, resume_handle);
 120
 121     if (level != 2 && level != 3)
 122         return ERROR_INVALID_LEVEL;
 123
 124     EnumStruct.Level = level;
 125     switch (level)
 126     {
 127         case 2:
 128             EnumStruct.FileInfo.Level2 = &Level2Container;
 129             break;
 130
 131         case 3:
 132             EnumStruct.FileInfo.Level3 = &Level3Container;
 133             break;
 134     }
 135
 136     RpcTryExcept
 137     {
 138         status = NetrFileEnum(servername,
 139                               basepath,
 140                               username,
 141                               &EnumStruct,
 142                               prefmaxlen,
 143                               totalentries,
 144                               (PDWORD)resume_handle);
 145
 146         switch (level)
 147         {
 148             case 2:
 149                 if (EnumStruct.FileInfo.Level2->Buffer != NULL)
 150                 {
 151                     *bufptr = (LPBYTE)EnumStruct.FileInfo.Level2->Buffer;
 152                     *entriesread = EnumStruct.FileInfo.Level2->EntriesRead;
 153                 }
 154                 break;
 155
 156             case 3:
 157                 if (EnumStruct.FileInfo.Level3->Buffer != NULL)
 158                 {
 159                     *bufptr = (LPBYTE)EnumStruct.FileInfo.Level3->Buffer;
 160                     *entriesread = EnumStruct.FileInfo.Level3->EntriesRead;
 161                 }
 162                 break;
 163         }
 164     }
 165     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 166     {
 167         status = I_RpcMapWin32Status(RpcExceptionCode());
 168     }
 169     RpcEndExcept;
 170
 171     return status;
 172 }
 173
 174
 175 NET_API_STATUS
 176 WINAPI
 177 NetFileGetInfo(
 178     _In_ LMSTR servername,
 179     _In_ DWORD fileid,
 180     _In_ DWORD level,
 181     _Out_ LPBYTE *bufptr)
 182 {
 183     NET_API_STATUS status;
 184
 185     TRACE("NetFileGetInfo(%s %lu %lu %p)\n",
 186           debugstr_w(servername), fileid, level, bufptr);
 187
 188     *bufptr = NULL;
 189
 190     RpcTryExcept
 191     {
 192         status = NetrFileGetInfo(servername,
 193                                  fileid,
 194                                  level,
 195                                  (LPFILE_INFO)bufptr);
 196     }
 197     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 198     {
 199         status = I_RpcMapWin32Status(RpcExceptionCode());
 200     }
 201     RpcEndExcept;
 202
 203     return status;
 204 }
 205
 206
 207 NET_API_STATUS
 208 WINAPI
 209 NetRemoteTOD(
 210     _In_ LPCWSTR UncServerName,
 211     _Out_ LPBYTE *BufferPtr)
 212 {
 213     NET_API_STATUS status;
 214
 215     TRACE("NetRemoteTOD(%s %p)\n",
 216           debugstr_w(UncServerName), BufferPtr);
 217
 218     *BufferPtr = NULL;
 219
 220     RpcTryExcept
 221     {
 222         status = NetrRemoteTOD((SRVSVC_HANDLE)UncServerName,
 223                                (LPTIME_OF_DAY_INFO *)BufferPtr);
 224     }
 225     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 226     {
 227         status = I_RpcMapWin32Status(RpcExceptionCode());
 228     }
 229     RpcEndExcept;
 230
 231     return status;
 232 }
 233
 234
 235 NET_API_STATUS
 236 WINAPI
 237 NetSessionDel(
 238     _In_ LMSTR servername,
 239     _In_ LMSTR UncClientName,
 240     _In_ LMSTR username)
 241 {
 242     NET_API_STATUS status;
 243
 244     TRACE("NetSessionDel(%s %s %s)\n",
 245           debugstr_w(servername), debugstr_w(UncClientName), debugstr_w(username));
 246
 247     RpcTryExcept
 248     {
 249         status = NetrSessionDel(servername,
 250                                 UncClientName,
 251                                 username);
 252     }
 253     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 254     {
 255         status = I_RpcMapWin32Status(RpcExceptionCode());
 256     }
 257     RpcEndExcept;
 258
 259     return status;
 260 }
 261
 262
 263 NET_API_STATUS
 264 WINAPI
 265 NetSessionEnum(
 266     _In_ LMSTR servername,
 267     _In_ LMSTR UncClientName,
 268     _In_ LMSTR username,
 269     _In_ DWORD level,
 270     _Out_ LPBYTE *bufptr,
 271     _In_ DWORD prefmaxlen,
 272     _Out_ LPDWORD entriesread,
 273     _Out_ LPDWORD totalentries,
 274     _Inout_ LPDWORD resume_handle)
 275 {
 276     SESSION_ENUM_STRUCT EnumStruct;
 277     SESSION_INFO_0_CONTAINER Level0Container = {0, NULL};
 278     SESSION_INFO_1_CONTAINER Level1Container = {0, NULL};
 279     SESSION_INFO_2_CONTAINER Level2Container = {0, NULL};
 280     SESSION_INFO_10_CONTAINER Level10Container = {0, NULL};
 281     SESSION_INFO_502_CONTAINER Level502Container = {0, NULL};
 282     NET_API_STATUS status;
 283
 284     TRACE("NetSessionEnum(%s %s %s %lu %p %lu %p %p %p)\n",
 285           debugstr_w(servername), debugstr_w(UncClientName), debugstr_w(username),
 286           level, bufptr, prefmaxlen, entriesread, totalentries, resume_handle);
 287
 288     if (level > 2 && level != 10 && level != 502)
 289         return ERROR_INVALID_LEVEL;
 290
 291     if (UncClientName == NULL || username == NULL)
 292         return ERROR_INVALID_PARAMETER;
 293
 294     *bufptr = NULL;
 295     *entriesread = 0;
 296
 297     EnumStruct.Level = level;
 298     switch (level)
 299     {
 300         case 0:
 301             EnumStruct.SessionInfo.Level0 = &Level0Container;
 302             break;
 303
 304         case 1:
 305             EnumStruct.SessionInfo.Level1 = &Level1Container;
 306             break;
 307
 308         case 2:
 309             EnumStruct.SessionInfo.Level2 = &Level2Container;
 310             break;
 311
 312         case 10:
 313             EnumStruct.SessionInfo.Level10 = &Level10Container;
 314             break;
 315
 316         case 502:
 317             EnumStruct.SessionInfo.Level502 = &Level502Container;
 318             break;
 319     }
 320
 321     RpcTryExcept
 322     {
 323         status = NetrSessionEnum(servername,
 324                                  UncClientName,
 325                                  username,
 326                                  &EnumStruct,
 327                                  prefmaxlen,
 328                                  totalentries,
 329                                  resume_handle);
 330
 331         switch (level)
 332         {
 333             case 0:
 334                 if (EnumStruct.SessionInfo.Level0->Buffer != NULL)
 335                 {
 336                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level0->Buffer;
 337                     *entriesread = EnumStruct.SessionInfo.Level0->EntriesRead;
 338                 }
 339                 break;
 340
 341             case 1:
 342                 if (EnumStruct.SessionInfo.Level1->Buffer != NULL)
 343                 {
 344                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level1->Buffer;
 345                     *entriesread = EnumStruct.SessionInfo.Level1->EntriesRead;
 346                 }
 347                 break;
 348
 349             case 2:
 350                 if (EnumStruct.SessionInfo.Level2->Buffer != NULL)
 351                 {
 352                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level2->Buffer;
 353                     *entriesread = EnumStruct.SessionInfo.Level2->EntriesRead;
 354                 }
 355                 break;
 356
 357             case 10:
 358                 if (EnumStruct.SessionInfo.Level10->Buffer != NULL)
 359                 {
 360                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level10->Buffer;
 361                     *entriesread = EnumStruct.SessionInfo.Level10->EntriesRead;
 362                 }
 363                 break;
 364
 365             case 502:
 366                 if (EnumStruct.SessionInfo.Level502->Buffer != NULL)
 367                 {
 368                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level502->Buffer;
 369                     *entriesread = EnumStruct.SessionInfo.Level502->EntriesRead;
 370                 }
 371                 break;
 372         }
 373     }
 374     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 375     {
 376         status = I_RpcMapWin32Status(RpcExceptionCode());
 377     }
 378     RpcEndExcept;
 379
 380     return status;
 381 }
 382
 383
 384 NET_API_STATUS
 385 WINAPI
 386 NetSessionGetInfo(
 387     _In_ LMSTR servername,
 388     _In_ LMSTR UncClientName,
 389     _In_ LMSTR username,
 390     _In_ DWORD level,
 391     _Out_ LPBYTE *bufptr)
 392 {
 393     SESSION_ENUM_STRUCT EnumStruct;
 394     SESSION_INFO_0_CONTAINER Level0Container = {0, NULL};
 395     SESSION_INFO_1_CONTAINER Level1Container = {0, NULL};
 396     SESSION_INFO_2_CONTAINER Level2Container = {0, NULL};
 397     SESSION_INFO_10_CONTAINER Level10Container = {0, NULL};
 398     DWORD dwTotalEntries;
 399     NET_API_STATUS status;
 400
 401     TRACE("NetSessionGetInfo(%s %s %s %lu %p)\n",
 402           debugstr_w(servername), debugstr_w(UncClientName),
 403           debugstr_w(username), level, bufptr);
 404
 405     if (level > 2 && level != 10)
 406         return ERROR_INVALID_LEVEL;
 407
 408     if (UncClientName == NULL || username == NULL)
 409         return ERROR_INVALID_PARAMETER;
 410
 411     *bufptr = NULL;
 412
 413     EnumStruct.Level = level;
 414     switch (level)
 415     {
 416         case 0:
 417             EnumStruct.SessionInfo.Level0 = &Level0Container;
 418             break;
 419
 420         case 1:
 421             EnumStruct.SessionInfo.Level1 = &Level1Container;
 422             break;
 423
 424         case 2:
 425             EnumStruct.SessionInfo.Level2 = &Level2Container;
 426             break;
 427
 428         case 10:
 429             EnumStruct.SessionInfo.Level10 = &Level10Container;
 430             break;
 431     }
 432
 433     RpcTryExcept
 434     {
 435         status = NetrSessionEnum(servername,
 436                                  UncClientName,
 437                                  username,
 438                                  &EnumStruct,
 439                                  MAX_PREFERRED_LENGTH, //(DWORD)-1,
 440                                  &dwTotalEntries,
 441                                  NULL);
 442
 443         switch (level)
 444         {
 445             case 0:
 446                 if (EnumStruct.SessionInfo.Level0->Buffer != NULL)
 447                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level0->Buffer;
 448                 break;
 449
 450             case 1:
 451                 if (EnumStruct.SessionInfo.Level1->Buffer != NULL)
 452                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level1->Buffer;
 453                 break;
 454
 455             case 2:
 456                 if (EnumStruct.SessionInfo.Level2->Buffer != NULL)
 457                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level2->Buffer;
 458                 break;
 459
 460             case 10:
 461                 if (EnumStruct.SessionInfo.Level10->Buffer != NULL)
 462                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level10->Buffer;
 463                 break;
 464         }
 465     }
 466     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 467     {
 468         status = I_RpcMapWin32Status(RpcExceptionCode());
 469     }
 470     RpcEndExcept;
 471
 472     return status;
 473 }
 474
 475
 476 NET_API_STATUS
 477 WINAPI
 478 NetShareAdd(
 479     _In_ LMSTR servername,
 480     _In_ DWORD level,
 481     _In_ LPBYTE buf,
 482     _Out_ LPDWORD parm_err)
 483 {
 484     NET_API_STATUS status;
 485
 486     TRACE("NetShareAdd(%s %lu %p %p)\n",
 487           debugstr_w(servername), level, buf, parm_err);
 488
 489     if (level != 2 && level != 502 && level != 503)
 490         return ERROR_INVALID_LEVEL;
 491
 492     RpcTryExcept
 493     {
 494         status = NetrShareAdd(servername,
 495                               level,
 496                               (LPSHARE_INFO)&buf,
 497                               parm_err);
 498     }
 499     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 500     {
 501         status = I_RpcMapWin32Status(RpcExceptionCode());
 502     }
 503     RpcEndExcept;
 504
 505     return status;
 506 }
 507
 508
 509 NET_API_STATUS
 510 WINAPI
 511 NetShareCheck(
 512     _In_ LMSTR servername,
 513     _In_ LMSTR device,
 514     _Out_ LPDWORD type)
 515 {
 516     NET_API_STATUS status;
 517
 518     TRACE("NetShareCheck(%s %s %p)\n",
 519           debugstr_w(servername), debugstr_w(device), type);
 520
 521     RpcTryExcept
 522     {
 523         status = NetrShareCheck(servername,
 524                                 device,
 525                                 type);
 526     }
 527     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 528     {
 529         status = I_RpcMapWin32Status(RpcExceptionCode());
 530     }
 531     RpcEndExcept;
 532
 533     return status;
 534 }
 535
 536
 537 NET_API_STATUS
 538 WINAPI
 539 NetShareDel(
 540     _In_ LMSTR servername,
 541     _In_ LMSTR netname,
 542     _In_ DWORD reserved)
 543 {
 544     NET_API_STATUS status;
 545
 546     TRACE("NetShareDel(%s %s %lu)\n",
 547           debugstr_w(servername), debugstr_w(netname), reserved);
 548
 549     if (netname == NULL || (*netname == 0) || reserved != 0)
 550         return ERROR_INVALID_PARAMETER;
 551
 552     RpcTryExcept
 553     {
 554         status = NetrShareDel(servername,
 555                               netname,
 556                               reserved);
 557     }
 558     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 559     {
 560         status = I_RpcMapWin32Status(RpcExceptionCode());
 561     }
 562     RpcEndExcept;
 563
 564     return status;
 565 }
 566
 567
 568 NET_API_STATUS
 569 WINAPI
 570 NetShareDelSticky(
 571     _In_ LMSTR servername,
 572     _In_ LMSTR netname,
 573     _In_ DWORD reserved)
 574 {
 575     NET_API_STATUS status;
 576
 577     TRACE("NetShareDelSticky(%s %s %lu)\n",
 578           debugstr_w(servername), debugstr_w(netname), reserved);
 579
 580     if (netname == NULL || (*netname == 0) || reserved != 0)
 581         return ERROR_INVALID_PARAMETER;
 582
 583     RpcTryExcept
 584     {
 585         status = NetrShareDelSticky(servername,
 586                                     netname,
 587                                     reserved);
 588     }
 589     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 590     {
 591         status = I_RpcMapWin32Status(RpcExceptionCode());
 592     }
 593     RpcEndExcept;
 594
 595     return status;
 596 }
 597
 598
 599 NET_API_STATUS
 600 WINAPI
 601 NetShareEnum(
 602     _In_ LMSTR servername,
 603     _In_ DWORD level,
 604     _Out_ LPBYTE *bufptr,
 605     _In_ DWORD prefmaxlen,
 606     _Out_ LPDWORD entriesread,
 607     _Out_ LPDWORD totalentries,
 608     _Inout_ LPDWORD resume_handle)
 609 {
 610     SHARE_ENUM_STRUCT EnumStruct;
 611     SHARE_INFO_0_CONTAINER Level0Container = {0, NULL};
 612     SHARE_INFO_1_CONTAINER Level1Container = {0, NULL};
 613     SHARE_INFO_2_CONTAINER Level2Container = {0, NULL};
 614     SHARE_INFO_502_CONTAINER Level502Container = {0, NULL};
 615     NET_API_STATUS status;
 616
 617     TRACE("NetShareEnum(%s %lu %p %lu %p %p %p)\n",
 618           debugstr_w(servername), level, bufptr, prefmaxlen,
 619           entriesread, totalentries, resume_handle);
 620
 621     if (level > 2 && level != 502)
 622         return ERROR_INVALID_LEVEL;
 623
 624     *bufptr = NULL;
 625     *entriesread = 0;
 626     *totalentries = 0;
 627
 628     EnumStruct.Level = level;
 629     switch (level)
 630     {
 631         case 0:
 632             EnumStruct.ShareInfo.Level0 = &Level0Container;
 633             break;
 634
 635         case 1:
 636             EnumStruct.ShareInfo.Level1 = &Level1Container;
 637             break;
 638
 639         case 2:
 640             EnumStruct.ShareInfo.Level2 = &Level2Container;
 641             break;
 642
 643         case 502:
 644             EnumStruct.ShareInfo.Level502 = &Level502Container;
 645             break;
 646     }
 647
 648     RpcTryExcept
 649     {
 650         status = NetrShareEnum(servername,
 651                                &EnumStruct,
 652                                prefmaxlen,
 653                                totalentries,
 654                                resume_handle);
 655
 656         switch (level)
 657         {
 658             case 0:
 659                 if (EnumStruct.ShareInfo.Level0->Buffer != NULL)
 660                 {
 661                     *bufptr = (LPBYTE)EnumStruct.ShareInfo.Level0->Buffer;
 662                     *entriesread = EnumStruct.ShareInfo.Level0->EntriesRead;
 663                 }
 664                 break;
 665
 666             case 1:
 667                 if (EnumStruct.ShareInfo.Level1->Buffer != NULL)
 668                 {
 669                     *bufptr = (LPBYTE)EnumStruct.ShareInfo.Level1->Buffer;
 670                     *entriesread = EnumStruct.ShareInfo.Level1->EntriesRead;
 671                 }
 672                 break;
 673
 674             case 2:
 675                 if (EnumStruct.ShareInfo.Level2->Buffer != NULL)
 676                 {
 677                     *bufptr = (LPBYTE)EnumStruct.ShareInfo.Level2->Buffer;
 678                     *entriesread = EnumStruct.ShareInfo.Level2->EntriesRead;
 679                 }
 680                 break;
 681
 682             case 502:
 683                 if (EnumStruct.ShareInfo.Level502->Buffer != NULL)
 684                 {
 685                     *bufptr = (LPBYTE)EnumStruct.ShareInfo.Level502->Buffer;
 686                     *entriesread = EnumStruct.ShareInfo.Level502->EntriesRead;
 687                 }
 688                 break;
 689         }
 690     }
 691     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 692     {
 693         status = I_RpcMapWin32Status(RpcExceptionCode());
 694     }
 695     RpcEndExcept;
 696
 697     return status;
 698 }
 699
 700
 701 NET_API_STATUS
 702 WINAPI
 703 NetShareEnumSticky(
 704     _In_ LMSTR servername,
 705     _In_ DWORD level,
 706     _Out_ LPBYTE *bufptr,
 707     _In_ DWORD prefmaxlen,
 708     _Out_ LPDWORD entriesread,
 709     _Out_ LPDWORD totalentries,
 710     _Inout_ LPDWORD resume_handle)
 711 {
 712     SHARE_ENUM_STRUCT EnumStruct;
 713     SHARE_INFO_0_CONTAINER Level0Container = {0, NULL};
 714     SHARE_INFO_1_CONTAINER Level1Container = {0, NULL};
 715     SHARE_INFO_2_CONTAINER Level2Container = {0, NULL};
 716     SHARE_INFO_502_CONTAINER Level502Container = {0, NULL};
 717     NET_API_STATUS status;
 718
 719     TRACE("NetShareEnumSticky(%s %lu %p %lu %p %p %p)\n",
 720           debugstr_w(servername), level, bufptr, prefmaxlen,
 721           entriesread, totalentries, resume_handle);
 722
 723     if (level > 2 && level != 502)
 724         return ERROR_INVALID_LEVEL;
 725
 726     *bufptr = NULL;
 727     *entriesread = 0;
 728     *totalentries = 0;
 729
 730     EnumStruct.Level = level;
 731     switch (level)
 732     {
 733         case 0:
 734             EnumStruct.ShareInfo.Level0 = &Level0Container;
 735             break;
 736
 737         case 1:
 738             EnumStruct.ShareInfo.Level1 = &Level1Container;
 739             break;
 740
 741         case 2:
 742             EnumStruct.ShareInfo.Level2 = &Level2Container;
 743             break;
 744
 745         case 502:
 746             EnumStruct.ShareInfo.Level502 = &Level502Container;
 747             break;
 748     }
 749
 750     RpcTryExcept
 751     {
 752         status = NetrShareEnum(servername,
 753                                (LPSHARE_ENUM_STRUCT)&EnumStruct,
 754                                prefmaxlen,
 755                                totalentries,
 756                                resume_handle);
 757
 758         switch (level)
 759         {
 760             case 0:
 761                 if (EnumStruct.ShareInfo.Level0->Buffer != NULL)
 762                 {
 763                     *bufptr = (LPBYTE)EnumStruct.ShareInfo.Level0->Buffer;
 764                     *entriesread = EnumStruct.ShareInfo.Level0->EntriesRead;
 765                 }
 766                 break;
 767
 768             case 1:
 769                 if (EnumStruct.ShareInfo.Level1->Buffer != NULL)
 770                 {
 771                     *bufptr = (LPBYTE)EnumStruct.ShareInfo.Level1->Buffer;
 772                     *entriesread = EnumStruct.ShareInfo.Level1->EntriesRead;
 773                 }
 774                 break;
 775
 776             case 2:
 777                 if (EnumStruct.ShareInfo.Level2->Buffer != NULL)
 778                 {
 779                     *bufptr = (LPBYTE)EnumStruct.ShareInfo.Level2->Buffer;
 780                     *entriesread = EnumStruct.ShareInfo.Level2->EntriesRead;
 781                 }
 782                 break;
 783
 784             case 502:
 785                 if (EnumStruct.ShareInfo.Level502->Buffer != NULL)
 786                 {
 787                     *bufptr = (LPBYTE)EnumStruct.ShareInfo.Level502->Buffer;
 788                     *entriesread = EnumStruct.ShareInfo.Level502->EntriesRead;
 789                 }
 790                 break;
 791         }
 792     }
 793     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 794     {
 795         status = I_RpcMapWin32Status(RpcExceptionCode());
 796     }
 797     RpcEndExcept;
 798
 799     return status;
 800 }
 801
 802
 803 NET_API_STATUS
 804 WINAPI
 805 NetShareGetInfo(
 806     _In_ LMSTR servername,
 807     _In_ LMSTR netname,
 808     _In_ DWORD level,
 809     _Out_ LPBYTE *bufptr)
 810 {
 811     NET_API_STATUS status;
 812
 813     TRACE("NetShareGetInfo(%s %s %lu %p)\n",
 814           debugstr_w(servername), debugstr_w(netname), level, bufptr);
 815
 816     if (level > 2 && level != 502 && level != 1005)
 817         return ERROR_INVALID_LEVEL;
 818
 819     if (netname == NULL || *netname == 0)
 820         return ERROR_INVALID_PARAMETER;
 821
 822     *bufptr = NULL;
 823
 824     RpcTryExcept
 825     {
 826         status = NetrShareGetInfo(servername,
 827                                   netname,
 828                                   level,
 829                                   (LPSHARE_INFO)bufptr);
 830     }
 831     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 832     {
 833         status = I_RpcMapWin32Status(RpcExceptionCode());
 834     }
 835     RpcEndExcept;
 836
 837     return status;
 838 }
 839
 840
 841 NET_API_STATUS
 842 WINAPI
 843 NetShareSetInfo(
 844     _In_  LPWSTR servername,
 845     _In_  LPWSTR netname,
 846     _In_  DWORD level,
 847     _In_  LPBYTE buf,
 848     _Out_ LPDWORD parm_err)
 849 {
 850     NET_API_STATUS status;
 851
 852     TRACE("NetShareSetInfo(%s %s %lu %p %p)\n",
 853           debugstr_w(servername), debugstr_w(netname), level, buf, parm_err);
 854
 855     if (level != 2 && level != 502 && level != 503 && level != 1004 &&
 856         level != 1005 && level != 1006 && level != 1501)
 857         return ERROR_INVALID_LEVEL;
 858
 859     RpcTryExcept
 860     {
 861         status = NetrShareSetInfo(servername,
 862                                   netname,
 863                                   level,
 864                                   (LPSHARE_INFO)&buf,
 865                                   parm_err);
 866     }
 867     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 868     {
 869         status = I_RpcMapWin32Status(RpcExceptionCode());
 870     }
 871     RpcEndExcept;
 872
 873     return status;
 874 }
 875
 876 /* EOF */