xref: /reactos/dll/win32/netapi32/srvsvc.c (revision 019f21ee) 
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 NET_API_STATUS
368 WINAPI
369 NetServerGetInfo(
370     LMSTR servername,
371     DWORD level,
372     LPBYTE *bufptr)
373 {
374     NET_API_STATUS status;
375 
376     TRACE("NetServerGetInfo(%s %lu %p)\n",
377           debugstr_w(servername), level, bufptr);
378 
379     *bufptr = NULL;
380 
381     RpcTryExcept
382     {
383         status = NetrServerGetInfo(servername,
384                                    level,
385                                    (LPSERVER_INFO *)bufptr);
386     }
387     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
388     {
389         status = I_RpcMapWin32Status(RpcExceptionCode());
390     }
391     RpcEndExcept;
392 
393     return status;
394 }
395 
396 
397 NET_API_STATUS
398 WINAPI
399 NetServerSetInfo(
400     _In_ LPWSTR servername,
401     _In_ DWORD level,
402     _In_ LPBYTE buf,
403     _Out_ LPDWORD parm_err)
404 {
405     NET_API_STATUS status;
406 
407     TRACE("NetServerSetInfo(%s %lu %p %p)\n",
408           debugstr_w(servername), level, buf, parm_err);
409 
410     RpcTryExcept
411     {
412         status = NetrServerSetInfo(servername,
413                                    level,
414                                    (LPSERVER_INFO)&buf,
415                                    parm_err);
416     }
417     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
418     {
419         status = I_RpcMapWin32Status(RpcExceptionCode());
420     }
421     RpcEndExcept;
422 
423     return status;
424 }
425 
426 
427 NET_API_STATUS
428 WINAPI
429 I_NetServerSetServiceBits(
430     _In_ LPWSTR servername,
431     _In_ LPWSTR transport,
432     _In_ DWORD servicebits,
433     _In_ DWORD updateimmediately)
434 {
435     NET_API_STATUS status;
436 
437     TRACE("I_NetServerSetServiceBits(%s %s 0x%lx %lu)\n",
438           debugstr_w(servername), debugstr_w(transport), servicebits, updateimmediately);
439 
440     RpcTryExcept
441     {
442         status = NetrServerSetServiceBits(servername,
443                                           transport,
444                                           servicebits,
445                                           updateimmediately);
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 NetServerTransportAdd(
460     _In_ LPWSTR servername,
461     _In_ DWORD level,
462     _In_ LPBYTE bufptr)
463 {
464     NET_API_STATUS status;
465 
466     TRACE("NetServerTransportAdd(%s %lu %p)\n",
467           debugstr_w(servername), level, bufptr);
468 
469     RpcTryExcept
470     {
471         status = NetrServerTransportAdd(servername,
472                                         level,
473                                         (LPSERVER_TRANSPORT_INFO_0)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 NetServerTransportAddEx(
488     _In_ LPWSTR servername,
489     _In_ DWORD level,
490     _In_ LPBYTE bufptr)
491 {
492     NET_API_STATUS status;
493 
494     TRACE("NetServerTransportAddEx(%s %lu %p)\n",
495           debugstr_w(servername), level, bufptr);
496 
497     RpcTryExcept
498     {
499         status = NetrServerTransportAddEx(servername,
500                                           level,
501                                           (LPTRANSPORT_INFO)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 NetServerTransportDel(
516     _In_ LPWSTR servername,
517     _In_ DWORD level,
518     _In_ LPBYTE bufptr)
519 {
520     NET_API_STATUS status;
521 
522     TRACE("NetServerTransportDel(%s %lu %p)\n",
523           debugstr_w(servername), level, bufptr);
524 
525     RpcTryExcept
526     {
527         status = NetrServerTransportDel(servername,
528                                         level,
529                                         (LPSERVER_TRANSPORT_INFO_0)bufptr);
530     }
531     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
532     {
533         status = I_RpcMapWin32Status(RpcExceptionCode());
534     }
535     RpcEndExcept;
536 
537     return status;
538 }
539 
540 
541 NET_API_STATUS
542 WINAPI
543 NetServerTransportEnum(
544     _In_ LPWSTR servername,
545     _In_ DWORD level,
546     _Out_ LPBYTE *bufptr,
547     _In_ DWORD prefmaxlen,
548     _Out_ LPDWORD entriesread,
549     _Out_ LPDWORD totalentries,
550     _Inout_ LPDWORD resume_handle)
551 {
552     SERVER_XPORT_ENUM_STRUCT EnumStruct;
553     SERVER_XPORT_INFO_0_CONTAINER Level0Container = {0, NULL};
554     SERVER_XPORT_INFO_1_CONTAINER Level1Container = {0, NULL};
555     NET_API_STATUS status;
556 
557     TRACE("NetServerTransportEnum(%s %lu %p %lu %p %p %p)\n",
558           debugstr_w(servername), level, bufptr, prefmaxlen,
559           entriesread, totalentries, resume_handle);
560 
561     EnumStruct.Level = level;
562     switch (level)
563     {
564         case 0:
565             EnumStruct.XportInfo.Level0 = &Level0Container;
566             break;
567 
568         case 1:
569             EnumStruct.XportInfo.Level1 = &Level1Container;
570             break;
571     }
572 
573     RpcTryExcept
574     {
575         status = NetrServerTransportEnum(servername,
576                                          &EnumStruct,
577                                          prefmaxlen,
578                                          totalentries,
579                                          resume_handle);
580 
581         switch (level)
582         {
583             case 0:
584                 if (EnumStruct.XportInfo.Level0->Buffer != NULL)
585                 {
586                     *bufptr = (LPBYTE)EnumStruct.XportInfo.Level0->Buffer;
587                     *entriesread = EnumStruct.XportInfo.Level0->EntriesRead;
588                 }
589                 break;
590 
591             case 1:
592                 if (EnumStruct.XportInfo.Level1->Buffer != NULL)
593                 {
594                     *bufptr = (LPBYTE)EnumStruct.XportInfo.Level1->Buffer;
595                     *entriesread = EnumStruct.XportInfo.Level1->EntriesRead;
596                 }
597                 break;
598         }
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 NetSessionDel(
613     _In_opt_ LMSTR servername,
614     _In_opt_ LMSTR UncClientName,
615     _In_opt_ LMSTR username)
616 {
617     NET_API_STATUS status;
618 
619     TRACE("NetSessionDel(%s %s %s)\n",
620           debugstr_w(servername), debugstr_w(UncClientName), debugstr_w(username));
621 
622     RpcTryExcept
623     {
624         status = NetrSessionDel(servername,
625                                 UncClientName,
626                                 username);
627     }
628     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
629     {
630         status = I_RpcMapWin32Status(RpcExceptionCode());
631     }
632     RpcEndExcept;
633 
634     return status;
635 }
636 
637 
638 NET_API_STATUS
639 WINAPI
640 NetSessionEnum(
641     _In_opt_ LMSTR servername,
642     _In_opt_ LMSTR UncClientName,
643     _In_opt_ LMSTR username,
644     _In_ DWORD level,
645     _Out_ LPBYTE *bufptr,
646     _In_ DWORD prefmaxlen,
647     _Out_ LPDWORD entriesread,
648     _Out_ LPDWORD totalentries,
649     _Inout_ LPDWORD resume_handle)
650 {
651     SESSION_ENUM_STRUCT EnumStruct;
652     SESSION_INFO_0_CONTAINER Level0Container = {0, NULL};
653     SESSION_INFO_1_CONTAINER Level1Container = {0, NULL};
654     SESSION_INFO_2_CONTAINER Level2Container = {0, NULL};
655     SESSION_INFO_10_CONTAINER Level10Container = {0, NULL};
656     SESSION_INFO_502_CONTAINER Level502Container = {0, NULL};
657     NET_API_STATUS status;
658 
659     TRACE("NetSessionEnum(%s %s %s %lu %p %lu %p %p %p)\n",
660           debugstr_w(servername), debugstr_w(UncClientName), debugstr_w(username),
661           level, bufptr, prefmaxlen, entriesread, totalentries, resume_handle);
662 
663     if (level > 2 && level != 10 && level != 502)
664         return ERROR_INVALID_LEVEL;
665 
666     if (UncClientName == NULL || username == NULL)
667         return ERROR_INVALID_PARAMETER;
668 
669     *bufptr = NULL;
670     *entriesread = 0;
671 
672     EnumStruct.Level = level;
673     switch (level)
674     {
675         case 0:
676             EnumStruct.SessionInfo.Level0 = &Level0Container;
677             break;
678 
679         case 1:
680             EnumStruct.SessionInfo.Level1 = &Level1Container;
681             break;
682 
683         case 2:
684             EnumStruct.SessionInfo.Level2 = &Level2Container;
685             break;
686 
687         case 10:
688             EnumStruct.SessionInfo.Level10 = &Level10Container;
689             break;
690 
691         case 502:
692             EnumStruct.SessionInfo.Level502 = &Level502Container;
693             break;
694     }
695 
696     RpcTryExcept
697     {
698         status = NetrSessionEnum(servername,
699                                  UncClientName,
700                                  username,
701                                  &EnumStruct,
702                                  prefmaxlen,
703                                  totalentries,
704                                  resume_handle);
705 
706         switch (level)
707         {
708             case 0:
709                 if (EnumStruct.SessionInfo.Level0->Buffer != NULL)
710                 {
711                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level0->Buffer;
712                     *entriesread = EnumStruct.SessionInfo.Level0->EntriesRead;
713                 }
714                 break;
715 
716             case 1:
717                 if (EnumStruct.SessionInfo.Level1->Buffer != NULL)
718                 {
719                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level1->Buffer;
720                     *entriesread = EnumStruct.SessionInfo.Level1->EntriesRead;
721                 }
722                 break;
723 
724             case 2:
725                 if (EnumStruct.SessionInfo.Level2->Buffer != NULL)
726                 {
727                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level2->Buffer;
728                     *entriesread = EnumStruct.SessionInfo.Level2->EntriesRead;
729                 }
730                 break;
731 
732             case 10:
733                 if (EnumStruct.SessionInfo.Level10->Buffer != NULL)
734                 {
735                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level10->Buffer;
736                     *entriesread = EnumStruct.SessionInfo.Level10->EntriesRead;
737                 }
738                 break;
739 
740             case 502:
741                 if (EnumStruct.SessionInfo.Level502->Buffer != NULL)
742                 {
743                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level502->Buffer;
744                     *entriesread = EnumStruct.SessionInfo.Level502->EntriesRead;
745                 }
746                 break;
747         }
748     }
749     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
750     {
751         status = I_RpcMapWin32Status(RpcExceptionCode());
752     }
753     RpcEndExcept;
754 
755     return status;
756 }
757 
758 
759 NET_API_STATUS
760 WINAPI
761 NetSessionGetInfo(
762     _In_opt_ LMSTR servername,
763     _In_ LMSTR UncClientName,
764     _In_ LMSTR username,
765     _In_ DWORD level,
766     _Out_ LPBYTE *bufptr)
767 {
768     SESSION_ENUM_STRUCT EnumStruct;
769     SESSION_INFO_0_CONTAINER Level0Container = {0, NULL};
770     SESSION_INFO_1_CONTAINER Level1Container = {0, NULL};
771     SESSION_INFO_2_CONTAINER Level2Container = {0, NULL};
772     SESSION_INFO_10_CONTAINER Level10Container = {0, NULL};
773     DWORD dwTotalEntries;
774     NET_API_STATUS status;
775 
776     TRACE("NetSessionGetInfo(%s %s %s %lu %p)\n",
777           debugstr_w(servername), debugstr_w(UncClientName),
778           debugstr_w(username), level, bufptr);
779 
780     if (level > 2 && level != 10)
781         return ERROR_INVALID_LEVEL;
782 
783     if (UncClientName == NULL || username == NULL)
784         return ERROR_INVALID_PARAMETER;
785 
786     *bufptr = NULL;
787 
788     EnumStruct.Level = level;
789     switch (level)
790     {
791         case 0:
792             EnumStruct.SessionInfo.Level0 = &Level0Container;
793             break;
794 
795         case 1:
796             EnumStruct.SessionInfo.Level1 = &Level1Container;
797             break;
798 
799         case 2:
800             EnumStruct.SessionInfo.Level2 = &Level2Container;
801             break;
802 
803         case 10:
804             EnumStruct.SessionInfo.Level10 = &Level10Container;
805             break;
806     }
807 
808     RpcTryExcept
809     {
810         status = NetrSessionEnum(servername,
811                                  UncClientName,
812                                  username,
813                                  &EnumStruct,
814                                  MAX_PREFERRED_LENGTH, //(DWORD)-1,
815                                  &dwTotalEntries,
816                                  NULL);
817 
818         switch (level)
819         {
820             case 0:
821                 if (EnumStruct.SessionInfo.Level0->Buffer != NULL)
822                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level0->Buffer;
823                 break;
824 
825             case 1:
826                 if (EnumStruct.SessionInfo.Level1->Buffer != NULL)
827                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level1->Buffer;
828                 break;
829 
830             case 2:
831                 if (EnumStruct.SessionInfo.Level2->Buffer != NULL)
832                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level2->Buffer;
833                 break;
834 
835             case 10:
836                 if (EnumStruct.SessionInfo.Level10->Buffer != NULL)
837                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level10->Buffer;
838                 break;
839         }
840     }
841     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
842     {
843         status = I_RpcMapWin32Status(RpcExceptionCode());
844     }
845     RpcEndExcept;
846 
847     return status;
848 }
849 
850 
851 NET_API_STATUS
852 WINAPI
853 NetShareAdd(
854     _In_ LMSTR servername,
855     _In_ DWORD level,
856     _In_ LPBYTE buf,
857     _Out_ LPDWORD parm_err)
858 {
859     NET_API_STATUS status;
860 
861     TRACE("NetShareAdd(%s %lu %p %p)\n",
862           debugstr_w(servername), level, buf, parm_err);
863 
864     if (level != 2 && level != 502 && level != 503)
865         return ERROR_INVALID_LEVEL;
866 
867     RpcTryExcept
868     {
869         status = NetrShareAdd(servername,
870                               level,
871                               (LPSHARE_INFO)&buf,
872                               parm_err);
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 NetShareCheck(
887     _In_ LMSTR servername,
888     _In_ LMSTR device,
889     _Out_ LPDWORD type)
890 {
891     NET_API_STATUS status;
892 
893     TRACE("NetShareCheck(%s %s %p)\n",
894           debugstr_w(servername), debugstr_w(device), type);
895 
896     RpcTryExcept
897     {
898         status = NetrShareCheck(servername,
899                                 device,
900                                 type);
901     }
902     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
903     {
904         status = I_RpcMapWin32Status(RpcExceptionCode());
905     }
906     RpcEndExcept;
907 
908     return status;
909 }
910 
911 
912 NET_API_STATUS
913 WINAPI
914 NetShareDel(
915     _In_ LMSTR servername,
916     _In_ LMSTR netname,
917     _In_ DWORD reserved)
918 {
919     NET_API_STATUS status;
920 
921     TRACE("NetShareDel(%s %s %lu)\n",
922           debugstr_w(servername), debugstr_w(netname), reserved);
923 
924     if (netname == NULL || (*netname == 0) || reserved != 0)
925         return ERROR_INVALID_PARAMETER;
926 
927     RpcTryExcept
928     {
929         status = NetrShareDel(servername,
930                               netname,
931                               reserved);
932     }
933     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
934     {
935         status = I_RpcMapWin32Status(RpcExceptionCode());
936     }
937     RpcEndExcept;
938 
939     return status;
940 }
941 
942 
943 NET_API_STATUS
944 WINAPI
945 NetShareDelSticky(
946     _In_ LMSTR servername,
947     _In_ LMSTR netname,
948     _In_ DWORD reserved)
949 {
950     NET_API_STATUS status;
951 
952     TRACE("NetShareDelSticky(%s %s %lu)\n",
953           debugstr_w(servername), debugstr_w(netname), reserved);
954 
955     if (netname == NULL || (*netname == 0) || reserved != 0)
956         return ERROR_INVALID_PARAMETER;
957 
958     RpcTryExcept
959     {
960         status = NetrShareDelSticky(servername,
961                                     netname,
962                                     reserved);
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 NetShareEnum(
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("NetShareEnum(%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                                &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 NetShareEnumSticky(
1079     _In_ LMSTR servername,
1080     _In_ DWORD level,
1081     _Out_ LPBYTE *bufptr,
1082     _In_ DWORD prefmaxlen,
1083     _Out_ LPDWORD entriesread,
1084     _Out_ LPDWORD totalentries,
1085     _Inout_ LPDWORD resume_handle)
1086 {
1087     SHARE_ENUM_STRUCT EnumStruct;
1088     SHARE_INFO_0_CONTAINER Level0Container = {0, NULL};
1089     SHARE_INFO_1_CONTAINER Level1Container = {0, NULL};
1090     SHARE_INFO_2_CONTAINER Level2Container = {0, NULL};
1091     SHARE_INFO_502_CONTAINER Level502Container = {0, NULL};
1092     NET_API_STATUS status;
1093 
1094     TRACE("NetShareEnumSticky(%s %lu %p %lu %p %p %p)\n",
1095           debugstr_w(servername), level, bufptr, prefmaxlen,
1096           entriesread, totalentries, resume_handle);
1097 
1098     if (level > 2 && level != 502)
1099         return ERROR_INVALID_LEVEL;
1100 
1101     *bufptr = NULL;
1102     *entriesread = 0;
1103     *totalentries = 0;
1104 
1105     EnumStruct.Level = level;
1106     switch (level)
1107     {
1108         case 0:
1109             EnumStruct.ShareInfo.Level0 = &Level0Container;
1110             break;
1111 
1112         case 1:
1113             EnumStruct.ShareInfo.Level1 = &Level1Container;
1114             break;
1115 
1116         case 2:
1117             EnumStruct.ShareInfo.Level2 = &Level2Container;
1118             break;
1119 
1120         case 502:
1121             EnumStruct.ShareInfo.Level502 = &Level502Container;
1122             break;
1123     }
1124 
1125     RpcTryExcept
1126     {
1127         status = NetrShareEnum(servername,
1128                                (LPSHARE_ENUM_STRUCT)&EnumStruct,
1129                                prefmaxlen,
1130                                totalentries,
1131                                resume_handle);
1132 
1133         switch (level)
1134         {
1135             case 0:
1136                 if (EnumStruct.ShareInfo.Level0->Buffer != NULL)
1137                 {
1138                     *bufptr = (LPBYTE)EnumStruct.ShareInfo.Level0->Buffer;
1139                     *entriesread = EnumStruct.ShareInfo.Level0->EntriesRead;
1140                 }
1141                 break;
1142 
1143             case 1:
1144                 if (EnumStruct.ShareInfo.Level1->Buffer != NULL)
1145                 {
1146                     *bufptr = (LPBYTE)EnumStruct.ShareInfo.Level1->Buffer;
1147                     *entriesread = EnumStruct.ShareInfo.Level1->EntriesRead;
1148                 }
1149                 break;
1150 
1151             case 2:
1152                 if (EnumStruct.ShareInfo.Level2->Buffer != NULL)
1153                 {
1154                     *bufptr = (LPBYTE)EnumStruct.ShareInfo.Level2->Buffer;
1155                     *entriesread = EnumStruct.ShareInfo.Level2->EntriesRead;
1156                 }
1157                 break;
1158 
1159             case 502:
1160                 if (EnumStruct.ShareInfo.Level502->Buffer != NULL)
1161                 {
1162                     *bufptr = (LPBYTE)EnumStruct.ShareInfo.Level502->Buffer;
1163                     *entriesread = EnumStruct.ShareInfo.Level502->EntriesRead;
1164                 }
1165                 break;
1166         }
1167     }
1168     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1169     {
1170         status = I_RpcMapWin32Status(RpcExceptionCode());
1171     }
1172     RpcEndExcept;
1173 
1174     return status;
1175 }
1176 
1177 
1178 NET_API_STATUS
1179 WINAPI
1180 NetShareGetInfo(
1181     _In_ LMSTR servername,
1182     _In_ LMSTR netname,
1183     _In_ DWORD level,
1184     _Out_ LPBYTE *bufptr)
1185 {
1186     NET_API_STATUS status;
1187 
1188     TRACE("NetShareGetInfo(%s %s %lu %p)\n",
1189           debugstr_w(servername), debugstr_w(netname), level, bufptr);
1190 
1191     if (level > 2 && level != 502 && level != 1005)
1192         return ERROR_INVALID_LEVEL;
1193 
1194     if (netname == NULL || *netname == 0)
1195         return ERROR_INVALID_PARAMETER;
1196 
1197     *bufptr = NULL;
1198 
1199     RpcTryExcept
1200     {
1201         status = NetrShareGetInfo(servername,
1202                                   netname,
1203                                   level,
1204                                   (LPSHARE_INFO)bufptr);
1205     }
1206     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1207     {
1208         status = I_RpcMapWin32Status(RpcExceptionCode());
1209     }
1210     RpcEndExcept;
1211 
1212     return status;
1213 }
1214 
1215 
1216 NET_API_STATUS
1217 WINAPI
1218 NetShareSetInfo(
1219     _In_  LPWSTR servername,
1220     _In_  LPWSTR netname,
1221     _In_  DWORD level,
1222     _In_  LPBYTE buf,
1223     _Out_ LPDWORD parm_err)
1224 {
1225     NET_API_STATUS status;
1226 
1227     TRACE("NetShareSetInfo(%s %s %lu %p %p)\n",
1228           debugstr_w(servername), debugstr_w(netname), level, buf, parm_err);
1229 
1230     if (level != 2 && level != 502 && level != 503 && level != 1004 &&
1231         level != 1005 && level != 1006 && level != 1501)
1232         return ERROR_INVALID_LEVEL;
1233 
1234     RpcTryExcept
1235     {
1236         status = NetrShareSetInfo(servername,
1237                                   netname,
1238                                   level,
1239                                   (LPSHARE_INFO)&buf,
1240                                   parm_err);
1241     }
1242     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1243     {
1244         status = I_RpcMapWin32Status(RpcExceptionCode());
1245     }
1246     RpcEndExcept;
1247 
1248     return status;
1249 }
1250 
1251 /* EOF */
1252