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 NetRemoteTOD(
  76     _In_ LPCWSTR UncServerName,
  77     _Out_ LPBYTE *BufferPtr)
  78 {
  79     NET_API_STATUS status;
  80
  81     TRACE("NetRemoteTOD(%s, %p)\n", debugstr_w(UncServerName),
  82           BufferPtr);
  83
  84     *BufferPtr = NULL;
  85
  86     RpcTryExcept
  87     {
  88         status = NetrRemoteTOD((SRVSVC_HANDLE)UncServerName,
  89                                (LPTIME_OF_DAY_INFO *)BufferPtr);
  90     }
  91     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
  92     {
  93         status = I_RpcMapWin32Status(RpcExceptionCode());
  94     }
  95     RpcEndExcept;
  96
  97     return status;
  98 }
  99
 100
 101 NET_API_STATUS
 102 WINAPI
 103 NetSessionDel(
 104     _In_ LMSTR servername,
 105     _In_ LMSTR UncClientName,
 106     _In_ LMSTR username)
 107 {
 108     NET_API_STATUS status;
 109
 110     TRACE("NetSessionDel(%s %s %s)\n",
 111           debugstr_w(servername), debugstr_w(UncClientName), debugstr_w(username));
 112
 113     RpcTryExcept
 114     {
 115         status = NetrSessionDel(servername,
 116                                 UncClientName,
 117                                 username);
 118     }
 119     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 120     {
 121         status = I_RpcMapWin32Status(RpcExceptionCode());
 122     }
 123     RpcEndExcept;
 124
 125     return status;
 126 }
 127
 128
 129 NET_API_STATUS
 130 WINAPI
 131 NetSessionEnum(
 132     _In_ LMSTR servername,
 133     _In_ LMSTR UncClientName,
 134     _In_ LMSTR username,
 135     _In_ DWORD level,
 136     _Out_ LPBYTE *bufptr,
 137     _In_ DWORD prefmaxlen,
 138     _Out_ LPDWORD entriesread,
 139     _Out_ LPDWORD totalentries,
 140     _Inout_ LPDWORD resume_handle)
 141 {
 142     SESSION_ENUM_STRUCT EnumStruct;
 143     SESSION_INFO_0_CONTAINER Level0Container = {0, NULL};
 144     SESSION_INFO_1_CONTAINER Level1Container = {0, NULL};
 145     SESSION_INFO_2_CONTAINER Level2Container = {0, NULL};
 146     SESSION_INFO_10_CONTAINER Level10Container = {0, NULL};
 147     SESSION_INFO_502_CONTAINER Level502Container = {0, NULL};
 148     NET_API_STATUS status;
 149
 150     FIXME("NetSessionEnum(%s %s %s %lu %p %lu %p %p %p)\n",
 151           debugstr_w(servername), debugstr_w(UncClientName), debugstr_w(username),
 152           level, bufptr, prefmaxlen, entriesread, totalentries, resume_handle);
 153
 154     if (level > 2 && level != 10 && level != 502)
 155         return ERROR_INVALID_LEVEL;
 156
 157     if (UncClientName == NULL || username == NULL)
 158         return ERROR_INVALID_PARAMETER;
 159
 160     *bufptr = NULL;
 161     *entriesread = 0;
 162
 163     EnumStruct.Level = level;
 164     switch (level)
 165     {
 166         case 0:
 167             EnumStruct.SessionInfo.Level0 = &Level0Container;
 168             break;
 169
 170         case 1:
 171             EnumStruct.SessionInfo.Level1 = &Level1Container;
 172             break;
 173
 174         case 2:
 175             EnumStruct.SessionInfo.Level2 = &Level2Container;
 176             break;
 177
 178         case 10:
 179             EnumStruct.SessionInfo.Level10 = &Level10Container;
 180             break;
 181
 182         case 502:
 183             EnumStruct.SessionInfo.Level502 = &Level502Container;
 184             break;
 185     }
 186
 187     RpcTryExcept
 188     {
 189         status = NetrSessionEnum(servername,
 190                                  UncClientName,
 191                                  username,
 192                                  &EnumStruct,
 193                                  prefmaxlen,
 194                                  totalentries,
 195                                  resume_handle);
 196
 197         switch (level)
 198         {
 199             case 0:
 200                 if (EnumStruct.SessionInfo.Level0->Buffer != NULL)
 201                 {
 202                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level0->Buffer;
 203                     *entriesread = EnumStruct.SessionInfo.Level0->EntriesRead;
 204                 }
 205                 break;
 206
 207             case 1:
 208                 if (EnumStruct.SessionInfo.Level1->Buffer != NULL)
 209                 {
 210                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level1->Buffer;
 211                     *entriesread = EnumStruct.SessionInfo.Level1->EntriesRead;
 212                 }
 213                 break;
 214
 215             case 2:
 216                 if (EnumStruct.SessionInfo.Level2->Buffer != NULL)
 217                 {
 218                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level2->Buffer;
 219                     *entriesread = EnumStruct.SessionInfo.Level2->EntriesRead;
 220                 }
 221                 break;
 222
 223             case 10:
 224                 if (EnumStruct.SessionInfo.Level10->Buffer != NULL)
 225                 {
 226                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level10->Buffer;
 227                     *entriesread = EnumStruct.SessionInfo.Level10->EntriesRead;
 228                 }
 229                 break;
 230
 231             case 502:
 232                 if (EnumStruct.SessionInfo.Level502->Buffer != NULL)
 233                 {
 234                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level502->Buffer;
 235                     *entriesread = EnumStruct.SessionInfo.Level502->EntriesRead;
 236                 }
 237                 break;
 238         }
 239     }
 240     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 241     {
 242         status = I_RpcMapWin32Status(RpcExceptionCode());
 243     }
 244     RpcEndExcept;
 245
 246     return status;
 247 }
 248
 249
 250 NET_API_STATUS
 251 WINAPI
 252 NetSessionGetInfo(
 253     _In_ LMSTR servername,
 254     _In_ LMSTR UncClientName,
 255     _In_ LMSTR username,
 256     _In_ DWORD level,
 257     _Out_ LPBYTE *bufptr)
 258 {
 259     SESSION_ENUM_STRUCT EnumStruct;
 260     SESSION_INFO_0_CONTAINER Level0Container = {0, NULL};
 261     SESSION_INFO_1_CONTAINER Level1Container = {0, NULL};
 262     SESSION_INFO_2_CONTAINER Level2Container = {0, NULL};
 263     SESSION_INFO_10_CONTAINER Level10Container = {0, NULL};
 264     DWORD dwTotalEntries;
 265     NET_API_STATUS status;
 266
 267     FIXME("NetSessionGetInfo(%s %s %s %lu %p)\n",
 268           debugstr_w(servername), debugstr_w(UncClientName),
 269           debugstr_w(username), level, bufptr);
 270
 271     if (level > 2 && level != 10)
 272         return ERROR_INVALID_LEVEL;
 273
 274     if (UncClientName == NULL || username == NULL)
 275         return ERROR_INVALID_PARAMETER;
 276
 277     *bufptr = NULL;
 278
 279     EnumStruct.Level = level;
 280     switch (level)
 281     {
 282         case 0:
 283             EnumStruct.SessionInfo.Level0 = &Level0Container;
 284             break;
 285
 286         case 1:
 287             EnumStruct.SessionInfo.Level1 = &Level1Container;
 288             break;
 289
 290         case 2:
 291             EnumStruct.SessionInfo.Level2 = &Level2Container;
 292             break;
 293
 294         case 10:
 295             EnumStruct.SessionInfo.Level10 = &Level10Container;
 296             break;
 297     }
 298
 299     RpcTryExcept
 300     {
 301         status = NetrSessionEnum(servername,
 302                                  UncClientName,
 303                                  username,
 304                                  &EnumStruct,
 305                                  MAX_PREFERRED_LENGTH, //(DWORD)-1,
 306                                  &dwTotalEntries,
 307                                  NULL);
 308
 309         switch (level)
 310         {
 311             case 0:
 312                 if (EnumStruct.SessionInfo.Level0->Buffer != NULL)
 313                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level0->Buffer;
 314                 break;
 315
 316             case 1:
 317                 if (EnumStruct.SessionInfo.Level1->Buffer != NULL)
 318                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level1->Buffer;
 319                 break;
 320
 321             case 2:
 322                 if (EnumStruct.SessionInfo.Level2->Buffer != NULL)
 323                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level2->Buffer;
 324                 break;
 325
 326             case 10:
 327                 if (EnumStruct.SessionInfo.Level10->Buffer != NULL)
 328                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level10->Buffer;
 329                 break;
 330         }
 331     }
 332     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 333     {
 334         status = I_RpcMapWin32Status(RpcExceptionCode());
 335     }
 336     RpcEndExcept;
 337
 338     return status;
 339 }
 340
 341
 342 NET_API_STATUS
 343 WINAPI
 344 NetShareAdd(
 345     _In_ LMSTR servername,
 346     _In_ DWORD level,
 347     _In_ LPBYTE buf,
 348     _Out_ LPDWORD parm_err)
 349 {
 350     NET_API_STATUS status;
 351
 352     TRACE("NetShareAdd(%s %lu %p %p)\n",
 353           debugstr_w(servername), level, buf, parm_err);
 354
 355     if (level != 2 && level != 502 && level != 503)
 356         return ERROR_INVALID_LEVEL;
 357
 358     RpcTryExcept
 359     {
 360         status = NetrShareAdd(servername,
 361                               level,
 362                               (LPSHARE_INFO)&buf,
 363                               parm_err);
 364     }
 365     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 366     {
 367         status = I_RpcMapWin32Status(RpcExceptionCode());
 368     }
 369     RpcEndExcept;
 370
 371     return status;
 372 }
 373
 374
 375 NET_API_STATUS
 376 WINAPI
 377 NetShareCheck(
 378     _In_ LMSTR servername,
 379     _In_ LMSTR device,
 380     _Out_ LPDWORD type)
 381 {
 382     NET_API_STATUS status;
 383
 384     TRACE("NetShareCheck(%s %s %p)\n",
 385           debugstr_w(servername), debugstr_w(device), type);
 386
 387     RpcTryExcept
 388     {
 389         status = NetrShareCheck(servername,
 390                                 device,
 391                                 type);
 392     }
 393     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 394     {
 395         status = I_RpcMapWin32Status(RpcExceptionCode());
 396     }
 397     RpcEndExcept;
 398
 399     return status;
 400 }
 401
 402
 403 NET_API_STATUS
 404 WINAPI
 405 NetShareDel(
 406     _In_ LMSTR servername,
 407     _In_ LMSTR netname,
 408     _In_ DWORD reserved)
 409 {
 410     NET_API_STATUS status;
 411
 412     TRACE("NetShareDel(%s %s %lu)\n",
 413           debugstr_w(servername), debugstr_w(netname), reserved);
 414
 415     if (netname == NULL || (*netname == 0) || reserved != 0)
 416         return ERROR_INVALID_PARAMETER;
 417
 418     RpcTryExcept
 419     {
 420         status = NetrShareDel(servername,
 421                               netname,
 422                               reserved);
 423     }
 424     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 425     {
 426         status = I_RpcMapWin32Status(RpcExceptionCode());
 427     }
 428     RpcEndExcept;
 429
 430     return status;
 431 }
 432
 433
 434 NET_API_STATUS
 435 WINAPI
 436 NetShareDelSticky(
 437     _In_ LMSTR servername,
 438     _In_ LMSTR netname,
 439     _In_ DWORD reserved)
 440 {
 441     NET_API_STATUS status;
 442
 443     TRACE("NetShareDelSticky(%s %s %lu)\n",
 444           debugstr_w(servername), debugstr_w(netname), reserved);
 445
 446     if (netname == NULL || (*netname == 0) || reserved != 0)
 447         return ERROR_INVALID_PARAMETER;
 448
 449     RpcTryExcept
 450     {
 451         status = NetrShareDelSticky(servername,
 452                                     netname,
 453                                     reserved);
 454     }
 455     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 456     {
 457         status = I_RpcMapWin32Status(RpcExceptionCode());
 458     }
 459     RpcEndExcept;
 460
 461     return status;
 462 }
 463
 464
 465 NET_API_STATUS
 466 WINAPI
 467 NetShareEnum(
 468     _In_ LMSTR servername,
 469     _In_ DWORD level,
 470     _Out_ LPBYTE *bufptr,
 471     _In_ DWORD prefmaxlen,
 472     _Out_ LPDWORD entriesread,
 473     _Out_ LPDWORD totalentries,
 474     _Inout_ LPDWORD resume_handle)
 475 {
 476     SHARE_ENUM_STRUCT EnumStruct;
 477     SHARE_INFO_0_CONTAINER Level0Container = {0, NULL};
 478     SHARE_INFO_1_CONTAINER Level1Container = {0, NULL};
 479     SHARE_INFO_2_CONTAINER Level2Container = {0, NULL};
 480     SHARE_INFO_502_CONTAINER Level502Container = {0, NULL};
 481     NET_API_STATUS status;
 482
 483     TRACE("NetShareEnum(%s %lu %p %lu %p %p %p)\n",
 484           debugstr_w(servername), level, bufptr, prefmaxlen,
 485           entriesread, totalentries, resume_handle);
 486
 487     if (level > 2 && level != 502)
 488         return ERROR_INVALID_LEVEL;
 489
 490     *bufptr = NULL;
 491     *entriesread = 0;
 492     *totalentries = 0;
 493
 494     EnumStruct.Level = level;
 495     switch (level)
 496     {
 497         case 0:
 498             EnumStruct.ShareInfo.Level0 = &Level0Container;
 499             break;
 500
 501         case 1:
 502             EnumStruct.ShareInfo.Level1 = &Level1Container;
 503             break;
 504
 505         case 2:
 506             EnumStruct.ShareInfo.Level2 = &Level2Container;
 507             break;
 508
 509         case 502:
 510             EnumStruct.ShareInfo.Level502 = &Level502Container;
 511             break;
 512     }
 513
 514     RpcTryExcept
 515     {
 516         status = NetrShareEnum(servername,
 517                                &EnumStruct,
 518                                prefmaxlen,
 519                                totalentries,
 520                                resume_handle);
 521
 522         switch (level)
 523         {
 524             case 0:
 525                 if (EnumStruct.ShareInfo.Level0->Buffer != NULL)
 526                 {
 527                     *bufptr = (LPBYTE)EnumStruct.ShareInfo.Level0->Buffer;
 528                     *entriesread = EnumStruct.ShareInfo.Level0->EntriesRead;
 529                 }
 530                 break;
 531
 532             case 1:
 533                 if (EnumStruct.ShareInfo.Level1->Buffer != NULL)
 534                 {
 535                     *bufptr = (LPBYTE)EnumStruct.ShareInfo.Level1->Buffer;
 536                     *entriesread = EnumStruct.ShareInfo.Level1->EntriesRead;
 537                 }
 538                 break;
 539
 540             case 2:
 541                 if (EnumStruct.ShareInfo.Level2->Buffer != NULL)
 542                 {
 543                     *bufptr = (LPBYTE)EnumStruct.ShareInfo.Level2->Buffer;
 544                     *entriesread = EnumStruct.ShareInfo.Level2->EntriesRead;
 545                 }
 546                 break;
 547
 548             case 502:
 549                 if (EnumStruct.ShareInfo.Level502->Buffer != NULL)
 550                 {
 551                     *bufptr = (LPBYTE)EnumStruct.ShareInfo.Level502->Buffer;
 552                     *entriesread = EnumStruct.ShareInfo.Level502->EntriesRead;
 553                 }
 554                 break;
 555         }
 556     }
 557     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 558     {
 559         status = I_RpcMapWin32Status(RpcExceptionCode());
 560     }
 561     RpcEndExcept;
 562
 563     return status;
 564 }
 565
 566
 567 NET_API_STATUS
 568 WINAPI
 569 NetShareEnumSticky(
 570     _In_ LMSTR servername,
 571     _In_ DWORD level,
 572     _Out_ LPBYTE *bufptr,
 573     _In_ DWORD prefmaxlen,
 574     _Out_ LPDWORD entriesread,
 575     _Out_ LPDWORD totalentries,
 576     _Inout_ LPDWORD resume_handle)
 577 {
 578     SHARE_ENUM_STRUCT EnumStruct;
 579     SHARE_INFO_0_CONTAINER Level0Container = {0, NULL};
 580     SHARE_INFO_1_CONTAINER Level1Container = {0, NULL};
 581     SHARE_INFO_2_CONTAINER Level2Container = {0, NULL};
 582     SHARE_INFO_502_CONTAINER Level502Container = {0, NULL};
 583     NET_API_STATUS status;
 584
 585     TRACE("NetShareEnumSticky(%s %lu %p %lu %p %p %p)\n",
 586           debugstr_w(servername), level, bufptr, prefmaxlen,
 587           entriesread, totalentries, resume_handle);
 588
 589     if (level > 2 && level != 502)
 590         return ERROR_INVALID_LEVEL;
 591
 592     *bufptr = NULL;
 593     *entriesread = 0;
 594     *totalentries = 0;
 595
 596     EnumStruct.Level = level;
 597     switch (level)
 598     {
 599         case 0:
 600             EnumStruct.ShareInfo.Level0 = &Level0Container;
 601             break;
 602
 603         case 1:
 604             EnumStruct.ShareInfo.Level1 = &Level1Container;
 605             break;
 606
 607         case 2:
 608             EnumStruct.ShareInfo.Level2 = &Level2Container;
 609             break;
 610
 611         case 502:
 612             EnumStruct.ShareInfo.Level502 = &Level502Container;
 613             break;
 614     }
 615
 616     RpcTryExcept
 617     {
 618         status = NetrShareEnum(servername,
 619                                (LPSHARE_ENUM_STRUCT)&EnumStruct,
 620                                prefmaxlen,
 621                                totalentries,
 622                                resume_handle);
 623
 624         switch (level)
 625         {
 626             case 0:
 627                 if (EnumStruct.ShareInfo.Level0->Buffer != NULL)
 628                 {
 629                     *bufptr = (LPBYTE)EnumStruct.ShareInfo.Level0->Buffer;
 630                     *entriesread = EnumStruct.ShareInfo.Level0->EntriesRead;
 631                 }
 632                 break;
 633
 634             case 1:
 635                 if (EnumStruct.ShareInfo.Level1->Buffer != NULL)
 636                 {
 637                     *bufptr = (LPBYTE)EnumStruct.ShareInfo.Level1->Buffer;
 638                     *entriesread = EnumStruct.ShareInfo.Level1->EntriesRead;
 639                 }
 640                 break;
 641
 642             case 2:
 643                 if (EnumStruct.ShareInfo.Level2->Buffer != NULL)
 644                 {
 645                     *bufptr = (LPBYTE)EnumStruct.ShareInfo.Level2->Buffer;
 646                     *entriesread = EnumStruct.ShareInfo.Level2->EntriesRead;
 647                 }
 648                 break;
 649
 650             case 502:
 651                 if (EnumStruct.ShareInfo.Level502->Buffer != NULL)
 652                 {
 653                     *bufptr = (LPBYTE)EnumStruct.ShareInfo.Level502->Buffer;
 654                     *entriesread = EnumStruct.ShareInfo.Level502->EntriesRead;
 655                 }
 656                 break;
 657         }
 658     }
 659     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 660     {
 661         status = I_RpcMapWin32Status(RpcExceptionCode());
 662     }
 663     RpcEndExcept;
 664
 665     return status;
 666 }
 667
 668
 669 NET_API_STATUS
 670 WINAPI
 671 NetShareGetInfo(
 672     _In_ LMSTR servername,
 673     _In_ LMSTR netname,
 674     _In_ DWORD level,
 675     _Out_ LPBYTE *bufptr)
 676 {
 677     NET_API_STATUS status;
 678
 679     TRACE("NetShareGetInfo(%s %s %lu %p)\n",
 680           debugstr_w(servername), debugstr_w(netname), level, bufptr);
 681
 682     if (level > 2 && level != 502 && level != 1005)
 683         return ERROR_INVALID_LEVEL;
 684
 685     if (netname == NULL || *netname == 0)
 686         return ERROR_INVALID_PARAMETER;
 687
 688     *bufptr = NULL;
 689
 690     RpcTryExcept
 691     {
 692         status = NetrShareGetInfo(servername,
 693                                   netname,
 694                                   level,
 695                                   (LPSHARE_INFO)bufptr);
 696     }
 697     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 698     {
 699         status = I_RpcMapWin32Status(RpcExceptionCode());
 700     }
 701     RpcEndExcept;
 702
 703     return status;
 704 }
 705
 706
 707 NET_API_STATUS
 708 WINAPI
 709 NetShareSetInfo(
 710     _In_  LPWSTR servername,
 711     _In_  LPWSTR netname,
 712     _In_  DWORD level,
 713     _In_  LPBYTE buf,
 714     _Out_ LPDWORD parm_err)
 715 {
 716     NET_API_STATUS status;
 717
 718     TRACE("NetShareSetInfo(%s %s %lu %p %p)\n",
 719           debugstr_w(servername), debugstr_w(netname), level, buf, parm_err);
 720
 721     if (level != 2 && level != 502 && level != 503 && level != 1004 &&
 722         level != 1005 && level != 1006 && level != 1501)
 723         return ERROR_INVALID_LEVEL;
 724
 725     RpcTryExcept
 726     {
 727         status = NetrShareSetInfo(servername,
 728                                   netname,
 729                                   level,
 730                                   (LPSHARE_INFO)&buf,
 731                                   parm_err);
 732     }
 733     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 734     {
 735         status = I_RpcMapWin32Status(RpcExceptionCode());
 736     }
 737     RpcEndExcept;
 738
 739     return status;
 740 }
 741
 742 /* EOF */