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 NetServerDiskEnum(
 238     _In_ LMSTR servername,
 239     _In_ DWORD level,
 240     _Out_ LPBYTE *bufptr,
 241     _In_ DWORD prefmaxlen,
 242     _Out_ LPDWORD entriesread,
 243     _Out_ LPDWORD totalentries,
 244     _Inout_ LPDWORD resume_handle)
 245 {
 246     DISK_ENUM_CONTAINER EnumContainer;
 247     NET_API_STATUS status;
 248
 249     TRACE("NetServerDiskEnum(%s %lu %p %lu %p %p %p)\n",
 250           debugstr_w(servername), level, bufptr, prefmaxlen,
 251           entriesread, totalentries, resume_handle);
 252
 253     EnumContainer.EntriesRead = 0;
 254     EnumContainer.Buffer = NULL;
 255
 256     RpcTryExcept
 257     {
 258         status = NetrServerDiskEnum(servername,
 259                                     level,
 260                                     &EnumContainer,
 261                                     prefmaxlen,
 262                                     totalentries,
 263                                     resume_handle);
 264
 265         if (EnumContainer.Buffer != NULL)
 266         {
 267             *bufptr = (LPBYTE)EnumContainer.Buffer;
 268         }
 269         else
 270         {
 271             *bufptr = NULL;
 272         }
 273
 274         if (EnumContainer.EntriesRead > 0)
 275         {
 276             *entriesread = EnumContainer.EntriesRead - 1;
 277         }
 278         else
 279         {
 280             *entriesread = 0;
 281         }
 282     }
 283     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 284     {
 285         status = I_RpcMapWin32Status(RpcExceptionCode());
 286     }
 287     RpcEndExcept;
 288
 289     return status;
 290 }
 291
 292
 293 #if 0
 294 NET_API_STATUS
 295 WINAPI
 296 NetServerGetInfo(
 297     LMSTR servername,
 298     DWORD level,
 299     LPBYTE *bufptr)
 300 {
 301     NET_API_STATUS status;
 302
 303     TRACE("NetServerGetInfo(%s %lu %p)\n",
 304           debugstr_w(servername), level, bufptr);
 305
 306     *bufptr = NULL;
 307
 308     RpcTryExcept
 309     {
 310         status = NetrServerGetInfo(servername,
 311                                    level,
 312                                    (LPSERVER_INFO)bufptr);
 313     }
 314     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 315     {
 316         status = I_RpcMapWin32Status(RpcExceptionCode());
 317     }
 318     RpcEndExcept;
 319
 320     return status;
 321 }
 322 #endif
 323
 324
 325 NET_API_STATUS
 326 WINAPI
 327 NetServerSetInfo(
 328     _In_ LPWSTR servername,
 329     _In_ DWORD level,
 330     _In_ LPBYTE buf,
 331     _Out_ LPDWORD parm_err)
 332 {
 333     NET_API_STATUS status;
 334
 335     TRACE("NetServerSetInfo(%s %lu %p %p)\n",
 336           debugstr_w(servername), level, buf, parm_err);
 337
 338     RpcTryExcept
 339     {
 340         status = NetrServerSetInfo(servername,
 341                                    level,
 342                                    (LPSERVER_INFO)&buf,
 343                                    parm_err);
 344     }
 345     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 346     {
 347         status = I_RpcMapWin32Status(RpcExceptionCode());
 348     }
 349     RpcEndExcept;
 350
 351     return status;
 352 }
 353
 354
 355 NET_API_STATUS
 356 WINAPI
 357 NetServerTransportAdd(
 358     _In_ LPWSTR servername,
 359     _In_ DWORD level,
 360     _In_ LPBYTE bufptr)
 361 {
 362     NET_API_STATUS status;
 363
 364     TRACE("NetServerTransportAdd(%s %lu %p)\n",
 365           debugstr_w(servername), level, bufptr);
 366
 367     RpcTryExcept
 368     {
 369         status = NetrServerTransportAdd(servername,
 370                                         level,
 371                                         (LPSERVER_TRANSPORT_INFO_0)bufptr);
 372     }
 373     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 374     {
 375         status = I_RpcMapWin32Status(RpcExceptionCode());
 376     }
 377     RpcEndExcept;
 378
 379     return status;
 380 }
 381
 382
 383 NET_API_STATUS
 384 WINAPI
 385 NetServerTransportAddEx(
 386     _In_ LPWSTR servername,
 387     _In_ DWORD level,
 388     _In_ LPBYTE bufptr)
 389 {
 390     NET_API_STATUS status;
 391
 392     TRACE("NetServerTransportAddEx(%s %lu %p)\n",
 393           debugstr_w(servername), level, bufptr);
 394
 395     RpcTryExcept
 396     {
 397         status = NetrServerTransportAddEx(servername,
 398                                           level,
 399                                           (LPTRANSPORT_INFO)bufptr);
 400     }
 401     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 402     {
 403         status = I_RpcMapWin32Status(RpcExceptionCode());
 404     }
 405     RpcEndExcept;
 406
 407     return status;
 408 }
 409
 410
 411 NET_API_STATUS
 412 WINAPI
 413 NetServerTransportDel(
 414     _In_ LPWSTR servername,
 415     _In_ DWORD level,
 416     _In_ LPBYTE bufptr)
 417 {
 418     NET_API_STATUS status;
 419
 420     TRACE("NetServerTransportDel(%s %lu %p)\n",
 421           debugstr_w(servername), level, bufptr);
 422
 423     RpcTryExcept
 424     {
 425         status = NetrServerTransportDel(servername,
 426                                         level,
 427                                         (LPSERVER_TRANSPORT_INFO_0)bufptr);
 428     }
 429     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 430     {
 431         status = I_RpcMapWin32Status(RpcExceptionCode());
 432     }
 433     RpcEndExcept;
 434
 435     return status;
 436 }
 437
 438
 439 NET_API_STATUS
 440 WINAPI
 441 NetServerTransportEnum(
 442     _In_ LPWSTR servername,
 443     _In_ DWORD level,
 444     _Out_ LPBYTE *bufptr,
 445     _In_ DWORD prefmaxlen,
 446     _Out_ LPDWORD entriesread,
 447     _Out_ LPDWORD totalentries,
 448     _Inout_ LPDWORD resume_handle)
 449 {
 450     SERVER_XPORT_ENUM_STRUCT EnumStruct;
 451     SERVER_XPORT_INFO_0_CONTAINER Level0Container = {0, NULL};
 452     SERVER_XPORT_INFO_1_CONTAINER Level1Container = {0, NULL};
 453     NET_API_STATUS status;
 454
 455     TRACE("NetServerTransportEnum(%s %lu %p %lu %p %p %p)\n",
 456           debugstr_w(servername), level, bufptr, prefmaxlen,
 457           entriesread, totalentries, resume_handle);
 458
 459     EnumStruct.Level = level;
 460     switch (level)
 461     {
 462         case 0:
 463             EnumStruct.XportInfo.Level0 = &Level0Container;
 464             break;
 465
 466         case 1:
 467             EnumStruct.XportInfo.Level1 = &Level1Container;
 468             break;
 469     }
 470
 471     RpcTryExcept
 472     {
 473         status = NetrServerTransportEnum(servername,
 474                                          &EnumStruct,
 475                                          prefmaxlen,
 476                                          totalentries,
 477                                          resume_handle);
 478
 479         switch (level)
 480         {
 481             case 0:
 482                 if (EnumStruct.XportInfo.Level0->Buffer != NULL)
 483                 {
 484                     *bufptr = (LPBYTE)EnumStruct.XportInfo.Level0->Buffer;
 485                     *entriesread = EnumStruct.XportInfo.Level0->EntriesRead;
 486                 }
 487                 break;
 488
 489             case 1:
 490                 if (EnumStruct.XportInfo.Level1->Buffer != NULL)
 491                 {
 492                     *bufptr = (LPBYTE)EnumStruct.XportInfo.Level1->Buffer;
 493                     *entriesread = EnumStruct.XportInfo.Level1->EntriesRead;
 494                 }
 495                 break;
 496         }
 497     }
 498     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 499     {
 500         status = I_RpcMapWin32Status(RpcExceptionCode());
 501     }
 502     RpcEndExcept;
 503
 504     return status;
 505 }
 506
 507
 508 NET_API_STATUS
 509 WINAPI
 510 NetSessionDel(
 511     _In_ LMSTR servername,
 512     _In_ LMSTR UncClientName,
 513     _In_ LMSTR username)
 514 {
 515     NET_API_STATUS status;
 516
 517     TRACE("NetSessionDel(%s %s %s)\n",
 518           debugstr_w(servername), debugstr_w(UncClientName), debugstr_w(username));
 519
 520     RpcTryExcept
 521     {
 522         status = NetrSessionDel(servername,
 523                                 UncClientName,
 524                                 username);
 525     }
 526     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 527     {
 528         status = I_RpcMapWin32Status(RpcExceptionCode());
 529     }
 530     RpcEndExcept;
 531
 532     return status;
 533 }
 534
 535
 536 NET_API_STATUS
 537 WINAPI
 538 NetSessionEnum(
 539     _In_ LMSTR servername,
 540     _In_ LMSTR UncClientName,
 541     _In_ LMSTR username,
 542     _In_ DWORD level,
 543     _Out_ LPBYTE *bufptr,
 544     _In_ DWORD prefmaxlen,
 545     _Out_ LPDWORD entriesread,
 546     _Out_ LPDWORD totalentries,
 547     _Inout_ LPDWORD resume_handle)
 548 {
 549     SESSION_ENUM_STRUCT EnumStruct;
 550     SESSION_INFO_0_CONTAINER Level0Container = {0, NULL};
 551     SESSION_INFO_1_CONTAINER Level1Container = {0, NULL};
 552     SESSION_INFO_2_CONTAINER Level2Container = {0, NULL};
 553     SESSION_INFO_10_CONTAINER Level10Container = {0, NULL};
 554     SESSION_INFO_502_CONTAINER Level502Container = {0, NULL};
 555     NET_API_STATUS status;
 556
 557     TRACE("NetSessionEnum(%s %s %s %lu %p %lu %p %p %p)\n",
 558           debugstr_w(servername), debugstr_w(UncClientName), debugstr_w(username),
 559           level, bufptr, prefmaxlen, entriesread, totalentries, resume_handle);
 560
 561     if (level > 2 && level != 10 && level != 502)
 562         return ERROR_INVALID_LEVEL;
 563
 564     if (UncClientName == NULL || username == NULL)
 565         return ERROR_INVALID_PARAMETER;
 566
 567     *bufptr = NULL;
 568     *entriesread = 0;
 569
 570     EnumStruct.Level = level;
 571     switch (level)
 572     {
 573         case 0:
 574             EnumStruct.SessionInfo.Level0 = &Level0Container;
 575             break;
 576
 577         case 1:
 578             EnumStruct.SessionInfo.Level1 = &Level1Container;
 579             break;
 580
 581         case 2:
 582             EnumStruct.SessionInfo.Level2 = &Level2Container;
 583             break;
 584
 585         case 10:
 586             EnumStruct.SessionInfo.Level10 = &Level10Container;
 587             break;
 588
 589         case 502:
 590             EnumStruct.SessionInfo.Level502 = &Level502Container;
 591             break;
 592     }
 593
 594     RpcTryExcept
 595     {
 596         status = NetrSessionEnum(servername,
 597                                  UncClientName,
 598                                  username,
 599                                  &EnumStruct,
 600                                  prefmaxlen,
 601                                  totalentries,
 602                                  resume_handle);
 603
 604         switch (level)
 605         {
 606             case 0:
 607                 if (EnumStruct.SessionInfo.Level0->Buffer != NULL)
 608                 {
 609                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level0->Buffer;
 610                     *entriesread = EnumStruct.SessionInfo.Level0->EntriesRead;
 611                 }
 612                 break;
 613
 614             case 1:
 615                 if (EnumStruct.SessionInfo.Level1->Buffer != NULL)
 616                 {
 617                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level1->Buffer;
 618                     *entriesread = EnumStruct.SessionInfo.Level1->EntriesRead;
 619                 }
 620                 break;
 621
 622             case 2:
 623                 if (EnumStruct.SessionInfo.Level2->Buffer != NULL)
 624                 {
 625                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level2->Buffer;
 626                     *entriesread = EnumStruct.SessionInfo.Level2->EntriesRead;
 627                 }
 628                 break;
 629
 630             case 10:
 631                 if (EnumStruct.SessionInfo.Level10->Buffer != NULL)
 632                 {
 633                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level10->Buffer;
 634                     *entriesread = EnumStruct.SessionInfo.Level10->EntriesRead;
 635                 }
 636                 break;
 637
 638             case 502:
 639                 if (EnumStruct.SessionInfo.Level502->Buffer != NULL)
 640                 {
 641                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level502->Buffer;
 642                     *entriesread = EnumStruct.SessionInfo.Level502->EntriesRead;
 643                 }
 644                 break;
 645         }
 646     }
 647     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 648     {
 649         status = I_RpcMapWin32Status(RpcExceptionCode());
 650     }
 651     RpcEndExcept;
 652
 653     return status;
 654 }
 655
 656
 657 NET_API_STATUS
 658 WINAPI
 659 NetSessionGetInfo(
 660     _In_ LMSTR servername,
 661     _In_ LMSTR UncClientName,
 662     _In_ LMSTR username,
 663     _In_ DWORD level,
 664     _Out_ LPBYTE *bufptr)
 665 {
 666     SESSION_ENUM_STRUCT EnumStruct;
 667     SESSION_INFO_0_CONTAINER Level0Container = {0, NULL};
 668     SESSION_INFO_1_CONTAINER Level1Container = {0, NULL};
 669     SESSION_INFO_2_CONTAINER Level2Container = {0, NULL};
 670     SESSION_INFO_10_CONTAINER Level10Container = {0, NULL};
 671     DWORD dwTotalEntries;
 672     NET_API_STATUS status;
 673
 674     TRACE("NetSessionGetInfo(%s %s %s %lu %p)\n",
 675           debugstr_w(servername), debugstr_w(UncClientName),
 676           debugstr_w(username), level, bufptr);
 677
 678     if (level > 2 && level != 10)
 679         return ERROR_INVALID_LEVEL;
 680
 681     if (UncClientName == NULL || username == NULL)
 682         return ERROR_INVALID_PARAMETER;
 683
 684     *bufptr = NULL;
 685
 686     EnumStruct.Level = level;
 687     switch (level)
 688     {
 689         case 0:
 690             EnumStruct.SessionInfo.Level0 = &Level0Container;
 691             break;
 692
 693         case 1:
 694             EnumStruct.SessionInfo.Level1 = &Level1Container;
 695             break;
 696
 697         case 2:
 698             EnumStruct.SessionInfo.Level2 = &Level2Container;
 699             break;
 700
 701         case 10:
 702             EnumStruct.SessionInfo.Level10 = &Level10Container;
 703             break;
 704     }
 705
 706     RpcTryExcept
 707     {
 708         status = NetrSessionEnum(servername,
 709                                  UncClientName,
 710                                  username,
 711                                  &EnumStruct,
 712                                  MAX_PREFERRED_LENGTH, //(DWORD)-1,
 713                                  &dwTotalEntries,
 714                                  NULL);
 715
 716         switch (level)
 717         {
 718             case 0:
 719                 if (EnumStruct.SessionInfo.Level0->Buffer != NULL)
 720                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level0->Buffer;
 721                 break;
 722
 723             case 1:
 724                 if (EnumStruct.SessionInfo.Level1->Buffer != NULL)
 725                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level1->Buffer;
 726                 break;
 727
 728             case 2:
 729                 if (EnumStruct.SessionInfo.Level2->Buffer != NULL)
 730                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level2->Buffer;
 731                 break;
 732
 733             case 10:
 734                 if (EnumStruct.SessionInfo.Level10->Buffer != NULL)
 735                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level10->Buffer;
 736                 break;
 737         }
 738     }
 739     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 740     {
 741         status = I_RpcMapWin32Status(RpcExceptionCode());
 742     }
 743     RpcEndExcept;
 744
 745     return status;
 746 }
 747
 748
 749 NET_API_STATUS
 750 WINAPI
 751 NetShareAdd(
 752     _In_ LMSTR servername,
 753     _In_ DWORD level,
 754     _In_ LPBYTE buf,
 755     _Out_ LPDWORD parm_err)
 756 {
 757     NET_API_STATUS status;
 758
 759     TRACE("NetShareAdd(%s %lu %p %p)\n",
 760           debugstr_w(servername), level, buf, parm_err);
 761
 762     if (level != 2 && level != 502 && level != 503)
 763         return ERROR_INVALID_LEVEL;
 764
 765     RpcTryExcept
 766     {
 767         status = NetrShareAdd(servername,
 768                               level,
 769                               (LPSHARE_INFO)&buf,
 770                               parm_err);
 771     }
 772     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 773     {
 774         status = I_RpcMapWin32Status(RpcExceptionCode());
 775     }
 776     RpcEndExcept;
 777
 778     return status;
 779 }
 780
 781
 782 NET_API_STATUS
 783 WINAPI
 784 NetShareCheck(
 785     _In_ LMSTR servername,
 786     _In_ LMSTR device,
 787     _Out_ LPDWORD type)
 788 {
 789     NET_API_STATUS status;
 790
 791     TRACE("NetShareCheck(%s %s %p)\n",
 792           debugstr_w(servername), debugstr_w(device), type);
 793
 794     RpcTryExcept
 795     {
 796         status = NetrShareCheck(servername,
 797                                 device,
 798                                 type);
 799     }
 800     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 801     {
 802         status = I_RpcMapWin32Status(RpcExceptionCode());
 803     }
 804     RpcEndExcept;
 805
 806     return status;
 807 }
 808
 809
 810 NET_API_STATUS
 811 WINAPI
 812 NetShareDel(
 813     _In_ LMSTR servername,
 814     _In_ LMSTR netname,
 815     _In_ DWORD reserved)
 816 {
 817     NET_API_STATUS status;
 818
 819     TRACE("NetShareDel(%s %s %lu)\n",
 820           debugstr_w(servername), debugstr_w(netname), reserved);
 821
 822     if (netname == NULL || (*netname == 0) || reserved != 0)
 823         return ERROR_INVALID_PARAMETER;
 824
 825     RpcTryExcept
 826     {
 827         status = NetrShareDel(servername,
 828                               netname,
 829                               reserved);
 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 NetShareDelSticky(
 844     _In_ LMSTR servername,
 845     _In_ LMSTR netname,
 846     _In_ DWORD reserved)
 847 {
 848     NET_API_STATUS status;
 849
 850     TRACE("NetShareDelSticky(%s %s %lu)\n",
 851           debugstr_w(servername), debugstr_w(netname), reserved);
 852
 853     if (netname == NULL || (*netname == 0) || reserved != 0)
 854         return ERROR_INVALID_PARAMETER;
 855
 856     RpcTryExcept
 857     {
 858         status = NetrShareDelSticky(servername,
 859                                     netname,
 860                                     reserved);
 861     }
 862     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 863     {
 864         status = I_RpcMapWin32Status(RpcExceptionCode());
 865     }
 866     RpcEndExcept;
 867
 868     return status;
 869 }
 870
 871
 872 NET_API_STATUS
 873 WINAPI
 874 NetShareEnum(
 875     _In_ LMSTR servername,
 876     _In_ DWORD level,
 877     _Out_ LPBYTE *bufptr,
 878     _In_ DWORD prefmaxlen,
 879     _Out_ LPDWORD entriesread,
 880     _Out_ LPDWORD totalentries,
 881     _Inout_ LPDWORD resume_handle)
 882 {
 883     SHARE_ENUM_STRUCT EnumStruct;
 884     SHARE_INFO_0_CONTAINER Level0Container = {0, NULL};
 885     SHARE_INFO_1_CONTAINER Level1Container = {0, NULL};
 886     SHARE_INFO_2_CONTAINER Level2Container = {0, NULL};
 887     SHARE_INFO_502_CONTAINER Level502Container = {0, NULL};
 888     NET_API_STATUS status;
 889
 890     TRACE("NetShareEnum(%s %lu %p %lu %p %p %p)\n",
 891           debugstr_w(servername), level, bufptr, prefmaxlen,
 892           entriesread, totalentries, resume_handle);
 893
 894     if (level > 2 && level != 502)
 895         return ERROR_INVALID_LEVEL;
 896
 897     *bufptr = NULL;
 898     *entriesread = 0;
 899     *totalentries = 0;
 900
 901     EnumStruct.Level = level;
 902     switch (level)
 903     {
 904         case 0:
 905             EnumStruct.ShareInfo.Level0 = &Level0Container;
 906             break;
 907
 908         case 1:
 909             EnumStruct.ShareInfo.Level1 = &Level1Container;
 910             break;
 911
 912         case 2:
 913             EnumStruct.ShareInfo.Level2 = &Level2Container;
 914             break;
 915
 916         case 502:
 917             EnumStruct.ShareInfo.Level502 = &Level502Container;
 918             break;
 919     }
 920
 921     RpcTryExcept
 922     {
 923         status = NetrShareEnum(servername,
 924                                &EnumStruct,
 925                                prefmaxlen,
 926                                totalentries,
 927                                resume_handle);
 928
 929         switch (level)
 930         {
 931             case 0:
 932                 if (EnumStruct.ShareInfo.Level0->Buffer != NULL)
 933                 {
 934                     *bufptr = (LPBYTE)EnumStruct.ShareInfo.Level0->Buffer;
 935                     *entriesread = EnumStruct.ShareInfo.Level0->EntriesRead;
 936                 }
 937                 break;
 938
 939             case 1:
 940                 if (EnumStruct.ShareInfo.Level1->Buffer != NULL)
 941                 {
 942                     *bufptr = (LPBYTE)EnumStruct.ShareInfo.Level1->Buffer;
 943                     *entriesread = EnumStruct.ShareInfo.Level1->EntriesRead;
 944                 }
 945                 break;
 946
 947             case 2:
 948                 if (EnumStruct.ShareInfo.Level2->Buffer != NULL)
 949                 {
 950                     *bufptr = (LPBYTE)EnumStruct.ShareInfo.Level2->Buffer;
 951                     *entriesread = EnumStruct.ShareInfo.Level2->EntriesRead;
 952                 }
 953                 break;
 954
 955             case 502:
 956                 if (EnumStruct.ShareInfo.Level502->Buffer != NULL)
 957                 {
 958                     *bufptr = (LPBYTE)EnumStruct.ShareInfo.Level502->Buffer;
 959                     *entriesread = EnumStruct.ShareInfo.Level502->EntriesRead;
 960                 }
 961                 break;
 962         }
 963     }
 964     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 965     {
 966         status = I_RpcMapWin32Status(RpcExceptionCode());
 967     }
 968     RpcEndExcept;
 969
 970     return status;
 971 }
 972
 973
 974 NET_API_STATUS
 975 WINAPI
 976 NetShareEnumSticky(
 977     _In_ LMSTR servername,
 978     _In_ DWORD level,
 979     _Out_ LPBYTE *bufptr,
 980     _In_ DWORD prefmaxlen,
 981     _Out_ LPDWORD entriesread,
 982     _Out_ LPDWORD totalentries,
 983     _Inout_ LPDWORD resume_handle)
 984 {
 985     SHARE_ENUM_STRUCT EnumStruct;
 986     SHARE_INFO_0_CONTAINER Level0Container = {0, NULL};
 987     SHARE_INFO_1_CONTAINER Level1Container = {0, NULL};
 988     SHARE_INFO_2_CONTAINER Level2Container = {0, NULL};
 989     SHARE_INFO_502_CONTAINER Level502Container = {0, NULL};
 990     NET_API_STATUS status;
 991
 992     TRACE("NetShareEnumSticky(%s %lu %p %lu %p %p %p)\n",
 993           debugstr_w(servername), level, bufptr, prefmaxlen,
 994           entriesread, totalentries, resume_handle);
 995
 996     if (level > 2 && level != 502)
 997         return ERROR_INVALID_LEVEL;
 998
 999     *bufptr = NULL;
1000     *entriesread = 0;
1001     *totalentries = 0;
1002
1003     EnumStruct.Level = level;
1004     switch (level)
1005     {
1006         case 0:
1007             EnumStruct.ShareInfo.Level0 = &Level0Container;
1008             break;
1009
1010         case 1:
1011             EnumStruct.ShareInfo.Level1 = &Level1Container;
1012             break;
1013
1014         case 2:
1015             EnumStruct.ShareInfo.Level2 = &Level2Container;
1016             break;
1017
1018         case 502:
1019             EnumStruct.ShareInfo.Level502 = &Level502Container;
1020             break;
1021     }
1022
1023     RpcTryExcept
1024     {
1025         status = NetrShareEnum(servername,
1026                                (LPSHARE_ENUM_STRUCT)&EnumStruct,
1027                                prefmaxlen,
1028                                totalentries,
1029                                resume_handle);
1030
1031         switch (level)
1032         {
1033             case 0:
1034                 if (EnumStruct.ShareInfo.Level0->Buffer != NULL)
1035                 {
1036                     *bufptr = (LPBYTE)EnumStruct.ShareInfo.Level0->Buffer;
1037                     *entriesread = EnumStruct.ShareInfo.Level0->EntriesRead;
1038                 }
1039                 break;
1040
1041             case 1:
1042                 if (EnumStruct.ShareInfo.Level1->Buffer != NULL)
1043                 {
1044                     *bufptr = (LPBYTE)EnumStruct.ShareInfo.Level1->Buffer;
1045                     *entriesread = EnumStruct.ShareInfo.Level1->EntriesRead;
1046                 }
1047                 break;
1048
1049             case 2:
1050                 if (EnumStruct.ShareInfo.Level2->Buffer != NULL)
1051                 {
1052                     *bufptr = (LPBYTE)EnumStruct.ShareInfo.Level2->Buffer;
1053                     *entriesread = EnumStruct.ShareInfo.Level2->EntriesRead;
1054                 }
1055                 break;
1056
1057             case 502:
1058                 if (EnumStruct.ShareInfo.Level502->Buffer != NULL)
1059                 {
1060                     *bufptr = (LPBYTE)EnumStruct.ShareInfo.Level502->Buffer;
1061                     *entriesread = EnumStruct.ShareInfo.Level502->EntriesRead;
1062                 }
1063                 break;
1064         }
1065     }
1066     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1067     {
1068         status = I_RpcMapWin32Status(RpcExceptionCode());
1069     }
1070     RpcEndExcept;
1071
1072     return status;
1073 }
1074
1075
1076 NET_API_STATUS
1077 WINAPI
1078 NetShareGetInfo(
1079     _In_ LMSTR servername,
1080     _In_ LMSTR netname,
1081     _In_ DWORD level,
1082     _Out_ LPBYTE *bufptr)
1083 {
1084     NET_API_STATUS status;
1085
1086     TRACE("NetShareGetInfo(%s %s %lu %p)\n",
1087           debugstr_w(servername), debugstr_w(netname), level, bufptr);
1088
1089     if (level > 2 && level != 502 && level != 1005)
1090         return ERROR_INVALID_LEVEL;
1091
1092     if (netname == NULL || *netname == 0)
1093         return ERROR_INVALID_PARAMETER;
1094
1095     *bufptr = NULL;
1096
1097     RpcTryExcept
1098     {
1099         status = NetrShareGetInfo(servername,
1100                                   netname,
1101                                   level,
1102                                   (LPSHARE_INFO)bufptr);
1103     }
1104     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1105     {
1106         status = I_RpcMapWin32Status(RpcExceptionCode());
1107     }
1108     RpcEndExcept;
1109
1110     return status;
1111 }
1112
1113
1114 NET_API_STATUS
1115 WINAPI
1116 NetShareSetInfo(
1117     _In_  LPWSTR servername,
1118     _In_  LPWSTR netname,
1119     _In_  DWORD level,
1120     _In_  LPBYTE buf,
1121     _Out_ LPDWORD parm_err)
1122 {
1123     NET_API_STATUS status;
1124
1125     TRACE("NetShareSetInfo(%s %s %lu %p %p)\n",
1126           debugstr_w(servername), debugstr_w(netname), level, buf, parm_err);
1127
1128     if (level != 2 && level != 502 && level != 503 && level != 1004 &&
1129         level != 1005 && level != 1006 && level != 1501)
1130         return ERROR_INVALID_LEVEL;
1131
1132     RpcTryExcept
1133     {
1134         status = NetrShareSetInfo(servername,
1135                                   netname,
1136                                   level,
1137                                   (LPSHARE_INFO)&buf,
1138                                   parm_err);
1139     }
1140     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1141     {
1142         status = I_RpcMapWin32Status(RpcExceptionCode());
1143     }
1144     RpcEndExcept;
1145
1146     return status;
1147 }
1148
1149 /* EOF */