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 NetConnectionEnum(
  76     _In_ LMSTR servername,
  77     _In_ LMSTR qualifier,
  78     _In_ DWORD level,
  79     _Out_ LPBYTE *bufptr,
  80     _In_ DWORD prefmaxlen,
  81     _Out_ LPDWORD entriesread,
  82     _Out_ LPDWORD totalentries,
  83     _Inout_ LPDWORD resume_handle)
  84 {
  85     CONNECT_ENUM_STRUCT EnumStruct;
  86     CONNECT_INFO_0_CONTAINER Level0Container = {0, NULL};
  87     CONNECT_INFO_1_CONTAINER Level1Container = {0, NULL};
  88     NET_API_STATUS status = 0;
  89
  90     TRACE("NetConnectionEnum(%s %s %s %lu %p %lu %p %p %p)\n",
  91           debugstr_w(servername), debugstr_w(qualifier), level, bufptr,
  92           prefmaxlen, entriesread, totalentries, resume_handle);
  93
  94     if (level > 1)
  95         return ERROR_INVALID_LEVEL;
  96
  97     EnumStruct.Level = level;
  98     switch (level)
  99     {
 100         case 0:
 101             EnumStruct.ConnectInfo.Level0 = &Level0Container;
 102             break;
 103
 104         case 1:
 105             EnumStruct.ConnectInfo.Level1 = &Level1Container;
 106             break;
 107     }
 108
 109     RpcTryExcept
 110     {
 111         status = NetrConnectionEnum(servername,
 112                                     qualifier,
 113                                     &EnumStruct,
 114                                     prefmaxlen,
 115                                     totalentries,
 116                                     resume_handle);
 117
 118         switch (level)
 119         {
 120             case 0:
 121                 if (EnumStruct.ConnectInfo.Level0->Buffer != NULL)
 122                 {
 123                     *bufptr = (LPBYTE)EnumStruct.ConnectInfo.Level0->Buffer;
 124                     *entriesread = EnumStruct.ConnectInfo.Level0->EntriesRead;
 125                 }
 126                 break;
 127
 128             case 1:
 129                 if (EnumStruct.ConnectInfo.Level1->Buffer != NULL)
 130                 {
 131                     *bufptr = (LPBYTE)EnumStruct.ConnectInfo.Level1->Buffer;
 132                     *entriesread = EnumStruct.ConnectInfo.Level1->EntriesRead;
 133                 }
 134                 break;
 135         }
 136     }
 137     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 138     {
 139         status = I_RpcMapWin32Status(RpcExceptionCode());
 140     }
 141     RpcEndExcept;
 142
 143     return status;
 144 }
 145
 146
 147 NET_API_STATUS
 148 WINAPI
 149 NetFileClose(
 150     _In_ LMSTR servername,
 151     _In_ DWORD fileid)
 152 {
 153     NET_API_STATUS status;
 154
 155     TRACE("NetFileClose(%s %lu)\n",
 156           debugstr_w(servername), fileid);
 157
 158     RpcTryExcept
 159     {
 160         status = NetrFileClose(servername,
 161                                fileid);
 162     }
 163     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 164     {
 165         status = I_RpcMapWin32Status(RpcExceptionCode());
 166     }
 167     RpcEndExcept;
 168
 169     return status;
 170 }
 171
 172
 173 NET_API_STATUS
 174 WINAPI
 175 NetFileEnum(
 176     _In_ LMSTR servername,
 177     _In_ LMSTR basepath,
 178     _In_ LMSTR username,
 179     _In_ DWORD level,
 180     _Out_ LPBYTE *bufptr,
 181     _In_ DWORD prefmaxlen,
 182     _Out_ LPDWORD entriesread,
 183     _Out_ LPDWORD totalentries,
 184     _Inout_ PDWORD_PTR resume_handle)
 185 {
 186     FILE_ENUM_STRUCT EnumStruct;
 187     FILE_INFO_2_CONTAINER Level2Container = {0, NULL};
 188     FILE_INFO_3_CONTAINER Level3Container = {0, NULL};
 189     NET_API_STATUS status;
 190
 191     TRACE("NetFileEnum(%s %s %s %lu %p %lu %p %p %p)\n",
 192           debugstr_w(servername), debugstr_w(basepath), debugstr_w(username),
 193           level, bufptr, prefmaxlen, entriesread, totalentries, resume_handle);
 194
 195     if (level != 2 && level != 3)
 196         return ERROR_INVALID_LEVEL;
 197
 198     EnumStruct.Level = level;
 199     switch (level)
 200     {
 201         case 2:
 202             EnumStruct.FileInfo.Level2 = &Level2Container;
 203             break;
 204
 205         case 3:
 206             EnumStruct.FileInfo.Level3 = &Level3Container;
 207             break;
 208     }
 209
 210     RpcTryExcept
 211     {
 212         status = NetrFileEnum(servername,
 213                               basepath,
 214                               username,
 215                               &EnumStruct,
 216                               prefmaxlen,
 217                               totalentries,
 218                               (PDWORD)resume_handle);
 219
 220         switch (level)
 221         {
 222             case 2:
 223                 if (EnumStruct.FileInfo.Level2->Buffer != NULL)
 224                 {
 225                     *bufptr = (LPBYTE)EnumStruct.FileInfo.Level2->Buffer;
 226                     *entriesread = EnumStruct.FileInfo.Level2->EntriesRead;
 227                 }
 228                 break;
 229
 230             case 3:
 231                 if (EnumStruct.FileInfo.Level3->Buffer != NULL)
 232                 {
 233                     *bufptr = (LPBYTE)EnumStruct.FileInfo.Level3->Buffer;
 234                     *entriesread = EnumStruct.FileInfo.Level3->EntriesRead;
 235                 }
 236                 break;
 237         }
 238     }
 239     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 240     {
 241         status = I_RpcMapWin32Status(RpcExceptionCode());
 242     }
 243     RpcEndExcept;
 244
 245     return status;
 246 }
 247
 248
 249 NET_API_STATUS
 250 WINAPI
 251 NetFileGetInfo(
 252     _In_ LMSTR servername,
 253     _In_ DWORD fileid,
 254     _In_ DWORD level,
 255     _Out_ LPBYTE *bufptr)
 256 {
 257     NET_API_STATUS status;
 258
 259     TRACE("NetFileGetInfo(%s %lu %lu %p)\n",
 260           debugstr_w(servername), fileid, level, bufptr);
 261
 262     *bufptr = NULL;
 263
 264     RpcTryExcept
 265     {
 266         status = NetrFileGetInfo(servername,
 267                                  fileid,
 268                                  level,
 269                                  (LPFILE_INFO)bufptr);
 270     }
 271     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 272     {
 273         status = I_RpcMapWin32Status(RpcExceptionCode());
 274     }
 275     RpcEndExcept;
 276
 277     return status;
 278 }
 279
 280
 281 NET_API_STATUS
 282 WINAPI
 283 NetRemoteTOD(
 284     _In_ LPCWSTR UncServerName,
 285     _Out_ LPBYTE *BufferPtr)
 286 {
 287     NET_API_STATUS status;
 288
 289     TRACE("NetRemoteTOD(%s %p)\n",
 290           debugstr_w(UncServerName), BufferPtr);
 291
 292     *BufferPtr = NULL;
 293
 294     RpcTryExcept
 295     {
 296         status = NetrRemoteTOD((SRVSVC_HANDLE)UncServerName,
 297                                (LPTIME_OF_DAY_INFO *)BufferPtr);
 298     }
 299     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 300     {
 301         status = I_RpcMapWin32Status(RpcExceptionCode());
 302     }
 303     RpcEndExcept;
 304
 305     return status;
 306 }
 307
 308
 309 NET_API_STATUS
 310 WINAPI
 311 NetServerDiskEnum(
 312     _In_ LMSTR servername,
 313     _In_ DWORD level,
 314     _Out_ LPBYTE *bufptr,
 315     _In_ DWORD prefmaxlen,
 316     _Out_ LPDWORD entriesread,
 317     _Out_ LPDWORD totalentries,
 318     _Inout_ LPDWORD resume_handle)
 319 {
 320     DISK_ENUM_CONTAINER EnumContainer;
 321     NET_API_STATUS status;
 322
 323     TRACE("NetServerDiskEnum(%s %lu %p %lu %p %p %p)\n",
 324           debugstr_w(servername), level, bufptr, prefmaxlen,
 325           entriesread, totalentries, resume_handle);
 326
 327     EnumContainer.EntriesRead = 0;
 328     EnumContainer.Buffer = NULL;
 329
 330     RpcTryExcept
 331     {
 332         status = NetrServerDiskEnum(servername,
 333                                     level,
 334                                     &EnumContainer,
 335                                     prefmaxlen,
 336                                     totalentries,
 337                                     resume_handle);
 338
 339         if (EnumContainer.Buffer != NULL)
 340         {
 341             *bufptr = (LPBYTE)EnumContainer.Buffer;
 342         }
 343         else
 344         {
 345             *bufptr = NULL;
 346         }
 347
 348         if (EnumContainer.EntriesRead > 0)
 349         {
 350             *entriesread = EnumContainer.EntriesRead - 1;
 351         }
 352         else
 353         {
 354             *entriesread = 0;
 355         }
 356     }
 357     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 358     {
 359         status = I_RpcMapWin32Status(RpcExceptionCode());
 360     }
 361     RpcEndExcept;
 362
 363     return status;
 364 }
 365
 366
 367 #if 0
 368 NET_API_STATUS
 369 WINAPI
 370 NetServerGetInfo(
 371     LMSTR servername,
 372     DWORD level,
 373     LPBYTE *bufptr)
 374 {
 375     NET_API_STATUS status;
 376
 377     TRACE("NetServerGetInfo(%s %lu %p)\n",
 378           debugstr_w(servername), level, bufptr);
 379
 380     *bufptr = NULL;
 381
 382     RpcTryExcept
 383     {
 384         status = NetrServerGetInfo(servername,
 385                                    level,
 386                                    (LPSERVER_INFO)bufptr);
 387     }
 388     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 389     {
 390         status = I_RpcMapWin32Status(RpcExceptionCode());
 391     }
 392     RpcEndExcept;
 393
 394     return status;
 395 }
 396 #endif
 397
 398
 399 NET_API_STATUS
 400 WINAPI
 401 NetServerSetInfo(
 402     _In_ LPWSTR servername,
 403     _In_ DWORD level,
 404     _In_ LPBYTE buf,
 405     _Out_ LPDWORD parm_err)
 406 {
 407     NET_API_STATUS status;
 408
 409     TRACE("NetServerSetInfo(%s %lu %p %p)\n",
 410           debugstr_w(servername), level, buf, parm_err);
 411
 412     RpcTryExcept
 413     {
 414         status = NetrServerSetInfo(servername,
 415                                    level,
 416                                    (LPSERVER_INFO)&buf,
 417                                    parm_err);
 418     }
 419     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 420     {
 421         status = I_RpcMapWin32Status(RpcExceptionCode());
 422     }
 423     RpcEndExcept;
 424
 425     return status;
 426 }
 427
 428
 429 NET_API_STATUS
 430 WINAPI
 431 NetServerTransportAdd(
 432     _In_ LPWSTR servername,
 433     _In_ DWORD level,
 434     _In_ LPBYTE bufptr)
 435 {
 436     NET_API_STATUS status;
 437
 438     TRACE("NetServerTransportAdd(%s %lu %p)\n",
 439           debugstr_w(servername), level, bufptr);
 440
 441     RpcTryExcept
 442     {
 443         status = NetrServerTransportAdd(servername,
 444                                         level,
 445                                         (LPSERVER_TRANSPORT_INFO_0)bufptr);
 446     }
 447     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 448     {
 449         status = I_RpcMapWin32Status(RpcExceptionCode());
 450     }
 451     RpcEndExcept;
 452
 453     return status;
 454 }
 455
 456
 457 NET_API_STATUS
 458 WINAPI
 459 NetServerTransportAddEx(
 460     _In_ LPWSTR servername,
 461     _In_ DWORD level,
 462     _In_ LPBYTE bufptr)
 463 {
 464     NET_API_STATUS status;
 465
 466     TRACE("NetServerTransportAddEx(%s %lu %p)\n",
 467           debugstr_w(servername), level, bufptr);
 468
 469     RpcTryExcept
 470     {
 471         status = NetrServerTransportAddEx(servername,
 472                                           level,
 473                                           (LPTRANSPORT_INFO)bufptr);
 474     }
 475     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 476     {
 477         status = I_RpcMapWin32Status(RpcExceptionCode());
 478     }
 479     RpcEndExcept;
 480
 481     return status;
 482 }
 483
 484
 485 NET_API_STATUS
 486 WINAPI
 487 NetServerTransportDel(
 488     _In_ LPWSTR servername,
 489     _In_ DWORD level,
 490     _In_ LPBYTE bufptr)
 491 {
 492     NET_API_STATUS status;
 493
 494     TRACE("NetServerTransportDel(%s %lu %p)\n",
 495           debugstr_w(servername), level, bufptr);
 496
 497     RpcTryExcept
 498     {
 499         status = NetrServerTransportDel(servername,
 500                                         level,
 501                                         (LPSERVER_TRANSPORT_INFO_0)bufptr);
 502     }
 503     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 504     {
 505         status = I_RpcMapWin32Status(RpcExceptionCode());
 506     }
 507     RpcEndExcept;
 508
 509     return status;
 510 }
 511
 512
 513 NET_API_STATUS
 514 WINAPI
 515 NetServerTransportEnum(
 516     _In_ LPWSTR servername,
 517     _In_ DWORD level,
 518     _Out_ LPBYTE *bufptr,
 519     _In_ DWORD prefmaxlen,
 520     _Out_ LPDWORD entriesread,
 521     _Out_ LPDWORD totalentries,
 522     _Inout_ LPDWORD resume_handle)
 523 {
 524     SERVER_XPORT_ENUM_STRUCT EnumStruct;
 525     SERVER_XPORT_INFO_0_CONTAINER Level0Container = {0, NULL};
 526     SERVER_XPORT_INFO_1_CONTAINER Level1Container = {0, NULL};
 527     NET_API_STATUS status;
 528
 529     TRACE("NetServerTransportEnum(%s %lu %p %lu %p %p %p)\n",
 530           debugstr_w(servername), level, bufptr, prefmaxlen,
 531           entriesread, totalentries, resume_handle);
 532
 533     EnumStruct.Level = level;
 534     switch (level)
 535     {
 536         case 0:
 537             EnumStruct.XportInfo.Level0 = &Level0Container;
 538             break;
 539
 540         case 1:
 541             EnumStruct.XportInfo.Level1 = &Level1Container;
 542             break;
 543     }
 544
 545     RpcTryExcept
 546     {
 547         status = NetrServerTransportEnum(servername,
 548                                          &EnumStruct,
 549                                          prefmaxlen,
 550                                          totalentries,
 551                                          resume_handle);
 552
 553         switch (level)
 554         {
 555             case 0:
 556                 if (EnumStruct.XportInfo.Level0->Buffer != NULL)
 557                 {
 558                     *bufptr = (LPBYTE)EnumStruct.XportInfo.Level0->Buffer;
 559                     *entriesread = EnumStruct.XportInfo.Level0->EntriesRead;
 560                 }
 561                 break;
 562
 563             case 1:
 564                 if (EnumStruct.XportInfo.Level1->Buffer != NULL)
 565                 {
 566                     *bufptr = (LPBYTE)EnumStruct.XportInfo.Level1->Buffer;
 567                     *entriesread = EnumStruct.XportInfo.Level1->EntriesRead;
 568                 }
 569                 break;
 570         }
 571     }
 572     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 573     {
 574         status = I_RpcMapWin32Status(RpcExceptionCode());
 575     }
 576     RpcEndExcept;
 577
 578     return status;
 579 }
 580
 581
 582 NET_API_STATUS
 583 WINAPI
 584 NetSessionDel(
 585     _In_ LMSTR servername,
 586     _In_ LMSTR UncClientName,
 587     _In_ LMSTR username)
 588 {
 589     NET_API_STATUS status;
 590
 591     TRACE("NetSessionDel(%s %s %s)\n",
 592           debugstr_w(servername), debugstr_w(UncClientName), debugstr_w(username));
 593
 594     RpcTryExcept
 595     {
 596         status = NetrSessionDel(servername,
 597                                 UncClientName,
 598                                 username);
 599     }
 600     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 601     {
 602         status = I_RpcMapWin32Status(RpcExceptionCode());
 603     }
 604     RpcEndExcept;
 605
 606     return status;
 607 }
 608
 609
 610 NET_API_STATUS
 611 WINAPI
 612 NetSessionEnum(
 613     _In_ LMSTR servername,
 614     _In_ LMSTR UncClientName,
 615     _In_ LMSTR username,
 616     _In_ DWORD level,
 617     _Out_ LPBYTE *bufptr,
 618     _In_ DWORD prefmaxlen,
 619     _Out_ LPDWORD entriesread,
 620     _Out_ LPDWORD totalentries,
 621     _Inout_ LPDWORD resume_handle)
 622 {
 623     SESSION_ENUM_STRUCT EnumStruct;
 624     SESSION_INFO_0_CONTAINER Level0Container = {0, NULL};
 625     SESSION_INFO_1_CONTAINER Level1Container = {0, NULL};
 626     SESSION_INFO_2_CONTAINER Level2Container = {0, NULL};
 627     SESSION_INFO_10_CONTAINER Level10Container = {0, NULL};
 628     SESSION_INFO_502_CONTAINER Level502Container = {0, NULL};
 629     NET_API_STATUS status;
 630
 631     TRACE("NetSessionEnum(%s %s %s %lu %p %lu %p %p %p)\n",
 632           debugstr_w(servername), debugstr_w(UncClientName), debugstr_w(username),
 633           level, bufptr, prefmaxlen, entriesread, totalentries, resume_handle);
 634
 635     if (level > 2 && level != 10 && level != 502)
 636         return ERROR_INVALID_LEVEL;
 637
 638     if (UncClientName == NULL || username == NULL)
 639         return ERROR_INVALID_PARAMETER;
 640
 641     *bufptr = NULL;
 642     *entriesread = 0;
 643
 644     EnumStruct.Level = level;
 645     switch (level)
 646     {
 647         case 0:
 648             EnumStruct.SessionInfo.Level0 = &Level0Container;
 649             break;
 650
 651         case 1:
 652             EnumStruct.SessionInfo.Level1 = &Level1Container;
 653             break;
 654
 655         case 2:
 656             EnumStruct.SessionInfo.Level2 = &Level2Container;
 657             break;
 658
 659         case 10:
 660             EnumStruct.SessionInfo.Level10 = &Level10Container;
 661             break;
 662
 663         case 502:
 664             EnumStruct.SessionInfo.Level502 = &Level502Container;
 665             break;
 666     }
 667
 668     RpcTryExcept
 669     {
 670         status = NetrSessionEnum(servername,
 671                                  UncClientName,
 672                                  username,
 673                                  &EnumStruct,
 674                                  prefmaxlen,
 675                                  totalentries,
 676                                  resume_handle);
 677
 678         switch (level)
 679         {
 680             case 0:
 681                 if (EnumStruct.SessionInfo.Level0->Buffer != NULL)
 682                 {
 683                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level0->Buffer;
 684                     *entriesread = EnumStruct.SessionInfo.Level0->EntriesRead;
 685                 }
 686                 break;
 687
 688             case 1:
 689                 if (EnumStruct.SessionInfo.Level1->Buffer != NULL)
 690                 {
 691                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level1->Buffer;
 692                     *entriesread = EnumStruct.SessionInfo.Level1->EntriesRead;
 693                 }
 694                 break;
 695
 696             case 2:
 697                 if (EnumStruct.SessionInfo.Level2->Buffer != NULL)
 698                 {
 699                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level2->Buffer;
 700                     *entriesread = EnumStruct.SessionInfo.Level2->EntriesRead;
 701                 }
 702                 break;
 703
 704             case 10:
 705                 if (EnumStruct.SessionInfo.Level10->Buffer != NULL)
 706                 {
 707                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level10->Buffer;
 708                     *entriesread = EnumStruct.SessionInfo.Level10->EntriesRead;
 709                 }
 710                 break;
 711
 712             case 502:
 713                 if (EnumStruct.SessionInfo.Level502->Buffer != NULL)
 714                 {
 715                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level502->Buffer;
 716                     *entriesread = EnumStruct.SessionInfo.Level502->EntriesRead;
 717                 }
 718                 break;
 719         }
 720     }
 721     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 722     {
 723         status = I_RpcMapWin32Status(RpcExceptionCode());
 724     }
 725     RpcEndExcept;
 726
 727     return status;
 728 }
 729
 730
 731 NET_API_STATUS
 732 WINAPI
 733 NetSessionGetInfo(
 734     _In_ LMSTR servername,
 735     _In_ LMSTR UncClientName,
 736     _In_ LMSTR username,
 737     _In_ DWORD level,
 738     _Out_ LPBYTE *bufptr)
 739 {
 740     SESSION_ENUM_STRUCT EnumStruct;
 741     SESSION_INFO_0_CONTAINER Level0Container = {0, NULL};
 742     SESSION_INFO_1_CONTAINER Level1Container = {0, NULL};
 743     SESSION_INFO_2_CONTAINER Level2Container = {0, NULL};
 744     SESSION_INFO_10_CONTAINER Level10Container = {0, NULL};
 745     DWORD dwTotalEntries;
 746     NET_API_STATUS status;
 747
 748     TRACE("NetSessionGetInfo(%s %s %s %lu %p)\n",
 749           debugstr_w(servername), debugstr_w(UncClientName),
 750           debugstr_w(username), level, bufptr);
 751
 752     if (level > 2 && level != 10)
 753         return ERROR_INVALID_LEVEL;
 754
 755     if (UncClientName == NULL || username == NULL)
 756         return ERROR_INVALID_PARAMETER;
 757
 758     *bufptr = NULL;
 759
 760     EnumStruct.Level = level;
 761     switch (level)
 762     {
 763         case 0:
 764             EnumStruct.SessionInfo.Level0 = &Level0Container;
 765             break;
 766
 767         case 1:
 768             EnumStruct.SessionInfo.Level1 = &Level1Container;
 769             break;
 770
 771         case 2:
 772             EnumStruct.SessionInfo.Level2 = &Level2Container;
 773             break;
 774
 775         case 10:
 776             EnumStruct.SessionInfo.Level10 = &Level10Container;
 777             break;
 778     }
 779
 780     RpcTryExcept
 781     {
 782         status = NetrSessionEnum(servername,
 783                                  UncClientName,
 784                                  username,
 785                                  &EnumStruct,
 786                                  MAX_PREFERRED_LENGTH, //(DWORD)-1,
 787                                  &dwTotalEntries,
 788                                  NULL);
 789
 790         switch (level)
 791         {
 792             case 0:
 793                 if (EnumStruct.SessionInfo.Level0->Buffer != NULL)
 794                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level0->Buffer;
 795                 break;
 796
 797             case 1:
 798                 if (EnumStruct.SessionInfo.Level1->Buffer != NULL)
 799                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level1->Buffer;
 800                 break;
 801
 802             case 2:
 803                 if (EnumStruct.SessionInfo.Level2->Buffer != NULL)
 804                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level2->Buffer;
 805                 break;
 806
 807             case 10:
 808                 if (EnumStruct.SessionInfo.Level10->Buffer != NULL)
 809                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level10->Buffer;
 810                 break;
 811         }
 812     }
 813     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 814     {
 815         status = I_RpcMapWin32Status(RpcExceptionCode());
 816     }
 817     RpcEndExcept;
 818
 819     return status;
 820 }
 821
 822
 823 NET_API_STATUS
 824 WINAPI
 825 NetShareAdd(
 826     _In_ LMSTR servername,
 827     _In_ DWORD level,
 828     _In_ LPBYTE buf,
 829     _Out_ LPDWORD parm_err)
 830 {
 831     NET_API_STATUS status;
 832
 833     TRACE("NetShareAdd(%s %lu %p %p)\n",
 834           debugstr_w(servername), level, buf, parm_err);
 835
 836     if (level != 2 && level != 502 && level != 503)
 837         return ERROR_INVALID_LEVEL;
 838
 839     RpcTryExcept
 840     {
 841         status = NetrShareAdd(servername,
 842                               level,
 843                               (LPSHARE_INFO)&buf,
 844                               parm_err);
 845     }
 846     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 847     {
 848         status = I_RpcMapWin32Status(RpcExceptionCode());
 849     }
 850     RpcEndExcept;
 851
 852     return status;
 853 }
 854
 855
 856 NET_API_STATUS
 857 WINAPI
 858 NetShareCheck(
 859     _In_ LMSTR servername,
 860     _In_ LMSTR device,
 861     _Out_ LPDWORD type)
 862 {
 863     NET_API_STATUS status;
 864
 865     TRACE("NetShareCheck(%s %s %p)\n",
 866           debugstr_w(servername), debugstr_w(device), type);
 867
 868     RpcTryExcept
 869     {
 870         status = NetrShareCheck(servername,
 871                                 device,
 872                                 type);
 873     }
 874     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 875     {
 876         status = I_RpcMapWin32Status(RpcExceptionCode());
 877     }
 878     RpcEndExcept;
 879
 880     return status;
 881 }
 882
 883
 884 NET_API_STATUS
 885 WINAPI
 886 NetShareDel(
 887     _In_ LMSTR servername,
 888     _In_ LMSTR netname,
 889     _In_ DWORD reserved)
 890 {
 891     NET_API_STATUS status;
 892
 893     TRACE("NetShareDel(%s %s %lu)\n",
 894           debugstr_w(servername), debugstr_w(netname), reserved);
 895
 896     if (netname == NULL || (*netname == 0) || reserved != 0)
 897         return ERROR_INVALID_PARAMETER;
 898
 899     RpcTryExcept
 900     {
 901         status = NetrShareDel(servername,
 902                               netname,
 903                               reserved);
 904     }
 905     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 906     {
 907         status = I_RpcMapWin32Status(RpcExceptionCode());
 908     }
 909     RpcEndExcept;
 910
 911     return status;
 912 }
 913
 914
 915 NET_API_STATUS
 916 WINAPI
 917 NetShareDelSticky(
 918     _In_ LMSTR servername,
 919     _In_ LMSTR netname,
 920     _In_ DWORD reserved)
 921 {
 922     NET_API_STATUS status;
 923
 924     TRACE("NetShareDelSticky(%s %s %lu)\n",
 925           debugstr_w(servername), debugstr_w(netname), reserved);
 926
 927     if (netname == NULL || (*netname == 0) || reserved != 0)
 928         return ERROR_INVALID_PARAMETER;
 929
 930     RpcTryExcept
 931     {
 932         status = NetrShareDelSticky(servername,
 933                                     netname,
 934                                     reserved);
 935     }
 936     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 937     {
 938         status = I_RpcMapWin32Status(RpcExceptionCode());
 939     }
 940     RpcEndExcept;
 941
 942     return status;
 943 }
 944
 945
 946 NET_API_STATUS
 947 WINAPI
 948 NetShareEnum(
 949     _In_ LMSTR servername,
 950     _In_ DWORD level,
 951     _Out_ LPBYTE *bufptr,
 952     _In_ DWORD prefmaxlen,
 953     _Out_ LPDWORD entriesread,
 954     _Out_ LPDWORD totalentries,
 955     _Inout_ LPDWORD resume_handle)
 956 {
 957     SHARE_ENUM_STRUCT EnumStruct;
 958     SHARE_INFO_0_CONTAINER Level0Container = {0, NULL};
 959     SHARE_INFO_1_CONTAINER Level1Container = {0, NULL};
 960     SHARE_INFO_2_CONTAINER Level2Container = {0, NULL};
 961     SHARE_INFO_502_CONTAINER Level502Container = {0, NULL};
 962     NET_API_STATUS status;
 963
 964     TRACE("NetShareEnum(%s %lu %p %lu %p %p %p)\n",
 965           debugstr_w(servername), level, bufptr, prefmaxlen,
 966           entriesread, totalentries, resume_handle);
 967
 968     if (level > 2 && level != 502)
 969         return ERROR_INVALID_LEVEL;
 970
 971     *bufptr = NULL;
 972     *entriesread = 0;
 973     *totalentries = 0;
 974
 975     EnumStruct.Level = level;
 976     switch (level)
 977     {
 978         case 0:
 979             EnumStruct.ShareInfo.Level0 = &Level0Container;
 980             break;
 981
 982         case 1:
 983             EnumStruct.ShareInfo.Level1 = &Level1Container;
 984             break;
 985
 986         case 2:
 987             EnumStruct.ShareInfo.Level2 = &Level2Container;
 988             break;
 989
 990         case 502:
 991             EnumStruct.ShareInfo.Level502 = &Level502Container;
 992             break;
 993     }
 994
 995     RpcTryExcept
 996     {
 997         status = NetrShareEnum(servername,
 998                                &EnumStruct,
 999                                prefmaxlen,
1000                                totalentries,
1001                                resume_handle);
1002
1003         switch (level)
1004         {
1005             case 0:
1006                 if (EnumStruct.ShareInfo.Level0->Buffer != NULL)
1007                 {
1008                     *bufptr = (LPBYTE)EnumStruct.ShareInfo.Level0->Buffer;
1009                     *entriesread = EnumStruct.ShareInfo.Level0->EntriesRead;
1010                 }
1011                 break;
1012
1013             case 1:
1014                 if (EnumStruct.ShareInfo.Level1->Buffer != NULL)
1015                 {
1016                     *bufptr = (LPBYTE)EnumStruct.ShareInfo.Level1->Buffer;
1017                     *entriesread = EnumStruct.ShareInfo.Level1->EntriesRead;
1018                 }
1019                 break;
1020
1021             case 2:
1022                 if (EnumStruct.ShareInfo.Level2->Buffer != NULL)
1023                 {
1024                     *bufptr = (LPBYTE)EnumStruct.ShareInfo.Level2->Buffer;
1025                     *entriesread = EnumStruct.ShareInfo.Level2->EntriesRead;
1026                 }
1027                 break;
1028
1029             case 502:
1030                 if (EnumStruct.ShareInfo.Level502->Buffer != NULL)
1031                 {
1032                     *bufptr = (LPBYTE)EnumStruct.ShareInfo.Level502->Buffer;
1033                     *entriesread = EnumStruct.ShareInfo.Level502->EntriesRead;
1034                 }
1035                 break;
1036         }
1037     }
1038     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1039     {
1040         status = I_RpcMapWin32Status(RpcExceptionCode());
1041     }
1042     RpcEndExcept;
1043
1044     return status;
1045 }
1046
1047
1048 NET_API_STATUS
1049 WINAPI
1050 NetShareEnumSticky(
1051     _In_ LMSTR servername,
1052     _In_ DWORD level,
1053     _Out_ LPBYTE *bufptr,
1054     _In_ DWORD prefmaxlen,
1055     _Out_ LPDWORD entriesread,
1056     _Out_ LPDWORD totalentries,
1057     _Inout_ LPDWORD resume_handle)
1058 {
1059     SHARE_ENUM_STRUCT EnumStruct;
1060     SHARE_INFO_0_CONTAINER Level0Container = {0, NULL};
1061     SHARE_INFO_1_CONTAINER Level1Container = {0, NULL};
1062     SHARE_INFO_2_CONTAINER Level2Container = {0, NULL};
1063     SHARE_INFO_502_CONTAINER Level502Container = {0, NULL};
1064     NET_API_STATUS status;
1065
1066     TRACE("NetShareEnumSticky(%s %lu %p %lu %p %p %p)\n",
1067           debugstr_w(servername), level, bufptr, prefmaxlen,
1068           entriesread, totalentries, resume_handle);
1069
1070     if (level > 2 && level != 502)
1071         return ERROR_INVALID_LEVEL;
1072
1073     *bufptr = NULL;
1074     *entriesread = 0;
1075     *totalentries = 0;
1076
1077     EnumStruct.Level = level;
1078     switch (level)
1079     {
1080         case 0:
1081             EnumStruct.ShareInfo.Level0 = &Level0Container;
1082             break;
1083
1084         case 1:
1085             EnumStruct.ShareInfo.Level1 = &Level1Container;
1086             break;
1087
1088         case 2:
1089             EnumStruct.ShareInfo.Level2 = &Level2Container;
1090             break;
1091
1092         case 502:
1093             EnumStruct.ShareInfo.Level502 = &Level502Container;
1094             break;
1095     }
1096
1097     RpcTryExcept
1098     {
1099         status = NetrShareEnum(servername,
1100                                (LPSHARE_ENUM_STRUCT)&EnumStruct,
1101                                prefmaxlen,
1102                                totalentries,
1103                                resume_handle);
1104
1105         switch (level)
1106         {
1107             case 0:
1108                 if (EnumStruct.ShareInfo.Level0->Buffer != NULL)
1109                 {
1110                     *bufptr = (LPBYTE)EnumStruct.ShareInfo.Level0->Buffer;
1111                     *entriesread = EnumStruct.ShareInfo.Level0->EntriesRead;
1112                 }
1113                 break;
1114
1115             case 1:
1116                 if (EnumStruct.ShareInfo.Level1->Buffer != NULL)
1117                 {
1118                     *bufptr = (LPBYTE)EnumStruct.ShareInfo.Level1->Buffer;
1119                     *entriesread = EnumStruct.ShareInfo.Level1->EntriesRead;
1120                 }
1121                 break;
1122
1123             case 2:
1124                 if (EnumStruct.ShareInfo.Level2->Buffer != NULL)
1125                 {
1126                     *bufptr = (LPBYTE)EnumStruct.ShareInfo.Level2->Buffer;
1127                     *entriesread = EnumStruct.ShareInfo.Level2->EntriesRead;
1128                 }
1129                 break;
1130
1131             case 502:
1132                 if (EnumStruct.ShareInfo.Level502->Buffer != NULL)
1133                 {
1134                     *bufptr = (LPBYTE)EnumStruct.ShareInfo.Level502->Buffer;
1135                     *entriesread = EnumStruct.ShareInfo.Level502->EntriesRead;
1136                 }
1137                 break;
1138         }
1139     }
1140     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1141     {
1142         status = I_RpcMapWin32Status(RpcExceptionCode());
1143     }
1144     RpcEndExcept;
1145
1146     return status;
1147 }
1148
1149
1150 NET_API_STATUS
1151 WINAPI
1152 NetShareGetInfo(
1153     _In_ LMSTR servername,
1154     _In_ LMSTR netname,
1155     _In_ DWORD level,
1156     _Out_ LPBYTE *bufptr)
1157 {
1158     NET_API_STATUS status;
1159
1160     TRACE("NetShareGetInfo(%s %s %lu %p)\n",
1161           debugstr_w(servername), debugstr_w(netname), level, bufptr);
1162
1163     if (level > 2 && level != 502 && level != 1005)
1164         return ERROR_INVALID_LEVEL;
1165
1166     if (netname == NULL || *netname == 0)
1167         return ERROR_INVALID_PARAMETER;
1168
1169     *bufptr = NULL;
1170
1171     RpcTryExcept
1172     {
1173         status = NetrShareGetInfo(servername,
1174                                   netname,
1175                                   level,
1176                                   (LPSHARE_INFO)bufptr);
1177     }
1178     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1179     {
1180         status = I_RpcMapWin32Status(RpcExceptionCode());
1181     }
1182     RpcEndExcept;
1183
1184     return status;
1185 }
1186
1187
1188 NET_API_STATUS
1189 WINAPI
1190 NetShareSetInfo(
1191     _In_  LPWSTR servername,
1192     _In_  LPWSTR netname,
1193     _In_  DWORD level,
1194     _In_  LPBYTE buf,
1195     _Out_ LPDWORD parm_err)
1196 {
1197     NET_API_STATUS status;
1198
1199     TRACE("NetShareSetInfo(%s %s %lu %p %p)\n",
1200           debugstr_w(servername), debugstr_w(netname), level, buf, parm_err);
1201
1202     if (level != 2 && level != 502 && level != 503 && level != 1004 &&
1203         level != 1005 && level != 1006 && level != 1501)
1204         return ERROR_INVALID_LEVEL;
1205
1206     RpcTryExcept
1207     {
1208         status = NetrShareSetInfo(servername,
1209                                   netname,
1210                                   level,
1211                                   (LPSHARE_INFO)&buf,
1212                                   parm_err);
1213     }
1214     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1215     {
1216         status = I_RpcMapWin32Status(RpcExceptionCode());
1217     }
1218     RpcEndExcept;
1219
1220     return status;
1221 }
1222
1223 /* EOF */