xref: /reactos/dll/win32/netapi32/srvsvc.c (revision bbccad0e) 
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     *bufptr = NULL;
667     *entriesread = 0;
668 
669     EnumStruct.Level = level;
670     switch (level)
671     {
672         case 0:
673             EnumStruct.SessionInfo.Level0 = &Level0Container;
674             break;
675 
676         case 1:
677             EnumStruct.SessionInfo.Level1 = &Level1Container;
678             break;
679 
680         case 2:
681             EnumStruct.SessionInfo.Level2 = &Level2Container;
682             break;
683 
684         case 10:
685             EnumStruct.SessionInfo.Level10 = &Level10Container;
686             break;
687 
688         case 502:
689             EnumStruct.SessionInfo.Level502 = &Level502Container;
690             break;
691     }
692 
693     RpcTryExcept
694     {
695         status = NetrSessionEnum(servername,
696                                  UncClientName,
697                                  username,
698                                  &EnumStruct,
699                                  prefmaxlen,
700                                  totalentries,
701                                  resume_handle);
702 
703         switch (level)
704         {
705             case 0:
706                 if (EnumStruct.SessionInfo.Level0->Buffer != NULL)
707                 {
708                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level0->Buffer;
709                     *entriesread = EnumStruct.SessionInfo.Level0->EntriesRead;
710                 }
711                 break;
712 
713             case 1:
714                 if (EnumStruct.SessionInfo.Level1->Buffer != NULL)
715                 {
716                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level1->Buffer;
717                     *entriesread = EnumStruct.SessionInfo.Level1->EntriesRead;
718                 }
719                 break;
720 
721             case 2:
722                 if (EnumStruct.SessionInfo.Level2->Buffer != NULL)
723                 {
724                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level2->Buffer;
725                     *entriesread = EnumStruct.SessionInfo.Level2->EntriesRead;
726                 }
727                 break;
728 
729             case 10:
730                 if (EnumStruct.SessionInfo.Level10->Buffer != NULL)
731                 {
732                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level10->Buffer;
733                     *entriesread = EnumStruct.SessionInfo.Level10->EntriesRead;
734                 }
735                 break;
736 
737             case 502:
738                 if (EnumStruct.SessionInfo.Level502->Buffer != NULL)
739                 {
740                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level502->Buffer;
741                     *entriesread = EnumStruct.SessionInfo.Level502->EntriesRead;
742                 }
743                 break;
744         }
745     }
746     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
747     {
748         status = I_RpcMapWin32Status(RpcExceptionCode());
749     }
750     RpcEndExcept;
751 
752     return status;
753 }
754 
755 
756 NET_API_STATUS
757 WINAPI
758 NetSessionGetInfo(
759     _In_opt_ LMSTR servername,
760     _In_ LMSTR UncClientName,
761     _In_ LMSTR username,
762     _In_ DWORD level,
763     _Out_ LPBYTE *bufptr)
764 {
765     SESSION_ENUM_STRUCT EnumStruct;
766     SESSION_INFO_0_CONTAINER Level0Container = {0, NULL};
767     SESSION_INFO_1_CONTAINER Level1Container = {0, NULL};
768     SESSION_INFO_2_CONTAINER Level2Container = {0, NULL};
769     SESSION_INFO_10_CONTAINER Level10Container = {0, NULL};
770     DWORD dwTotalEntries;
771     NET_API_STATUS status;
772 
773     TRACE("NetSessionGetInfo(%s %s %s %lu %p)\n",
774           debugstr_w(servername), debugstr_w(UncClientName),
775           debugstr_w(username), level, bufptr);
776 
777     if (level > 2 && level != 10)
778         return ERROR_INVALID_LEVEL;
779 
780     if (UncClientName == NULL || username == NULL)
781         return ERROR_INVALID_PARAMETER;
782 
783     *bufptr = NULL;
784 
785     EnumStruct.Level = level;
786     switch (level)
787     {
788         case 0:
789             EnumStruct.SessionInfo.Level0 = &Level0Container;
790             break;
791 
792         case 1:
793             EnumStruct.SessionInfo.Level1 = &Level1Container;
794             break;
795 
796         case 2:
797             EnumStruct.SessionInfo.Level2 = &Level2Container;
798             break;
799 
800         case 10:
801             EnumStruct.SessionInfo.Level10 = &Level10Container;
802             break;
803     }
804 
805     RpcTryExcept
806     {
807         status = NetrSessionEnum(servername,
808                                  UncClientName,
809                                  username,
810                                  &EnumStruct,
811                                  MAX_PREFERRED_LENGTH, //(DWORD)-1,
812                                  &dwTotalEntries,
813                                  NULL);
814 
815         switch (level)
816         {
817             case 0:
818                 if (EnumStruct.SessionInfo.Level0->Buffer != NULL)
819                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level0->Buffer;
820                 break;
821 
822             case 1:
823                 if (EnumStruct.SessionInfo.Level1->Buffer != NULL)
824                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level1->Buffer;
825                 break;
826 
827             case 2:
828                 if (EnumStruct.SessionInfo.Level2->Buffer != NULL)
829                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level2->Buffer;
830                 break;
831 
832             case 10:
833                 if (EnumStruct.SessionInfo.Level10->Buffer != NULL)
834                     *bufptr = (LPBYTE)EnumStruct.SessionInfo.Level10->Buffer;
835                 break;
836         }
837     }
838     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
839     {
840         status = I_RpcMapWin32Status(RpcExceptionCode());
841     }
842     RpcEndExcept;
843 
844     return status;
845 }
846 
847 
848 NET_API_STATUS
849 WINAPI
850 NetShareAdd(
851     _In_ LMSTR servername,
852     _In_ DWORD level,
853     _In_ LPBYTE buf,
854     _Out_ LPDWORD parm_err)
855 {
856     NET_API_STATUS status;
857 
858     TRACE("NetShareAdd(%s %lu %p %p)\n",
859           debugstr_w(servername), level, buf, parm_err);
860 
861     if (level != 2 && level != 502 && level != 503)
862         return ERROR_INVALID_LEVEL;
863 
864     RpcTryExcept
865     {
866         status = NetrShareAdd(servername,
867                               level,
868                               (LPSHARE_INFO)&buf,
869                               parm_err);
870     }
871     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
872     {
873         status = I_RpcMapWin32Status(RpcExceptionCode());
874     }
875     RpcEndExcept;
876 
877     return status;
878 }
879 
880 
881 NET_API_STATUS
882 WINAPI
883 NetShareCheck(
884     _In_ LMSTR servername,
885     _In_ LMSTR device,
886     _Out_ LPDWORD type)
887 {
888     NET_API_STATUS status;
889 
890     TRACE("NetShareCheck(%s %s %p)\n",
891           debugstr_w(servername), debugstr_w(device), type);
892 
893     RpcTryExcept
894     {
895         status = NetrShareCheck(servername,
896                                 device,
897                                 type);
898     }
899     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
900     {
901         status = I_RpcMapWin32Status(RpcExceptionCode());
902     }
903     RpcEndExcept;
904 
905     return status;
906 }
907 
908 
909 NET_API_STATUS
910 WINAPI
911 NetShareDel(
912     _In_ LMSTR servername,
913     _In_ LMSTR netname,
914     _In_ DWORD reserved)
915 {
916     NET_API_STATUS status;
917 
918     TRACE("NetShareDel(%s %s %lu)\n",
919           debugstr_w(servername), debugstr_w(netname), reserved);
920 
921     if (netname == NULL || (*netname == 0) || reserved != 0)
922         return ERROR_INVALID_PARAMETER;
923 
924     RpcTryExcept
925     {
926         status = NetrShareDel(servername,
927                               netname,
928                               reserved);
929     }
930     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
931     {
932         status = I_RpcMapWin32Status(RpcExceptionCode());
933     }
934     RpcEndExcept;
935 
936     return status;
937 }
938 
939 
940 NET_API_STATUS
941 WINAPI
942 NetShareDelSticky(
943     _In_ LMSTR servername,
944     _In_ LMSTR netname,
945     _In_ DWORD reserved)
946 {
947     NET_API_STATUS status;
948 
949     TRACE("NetShareDelSticky(%s %s %lu)\n",
950           debugstr_w(servername), debugstr_w(netname), reserved);
951 
952     if (netname == NULL || (*netname == 0) || reserved != 0)
953         return ERROR_INVALID_PARAMETER;
954 
955     RpcTryExcept
956     {
957         status = NetrShareDelSticky(servername,
958                                     netname,
959                                     reserved);
960     }
961     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
962     {
963         status = I_RpcMapWin32Status(RpcExceptionCode());
964     }
965     RpcEndExcept;
966 
967     return status;
968 }
969 
970 
971 NET_API_STATUS
972 WINAPI
973 NetShareEnum(
974     _In_ LMSTR servername,
975     _In_ DWORD level,
976     _Out_ LPBYTE *bufptr,
977     _In_ DWORD prefmaxlen,
978     _Out_ LPDWORD entriesread,
979     _Out_ LPDWORD totalentries,
980     _Inout_ LPDWORD resume_handle)
981 {
982     SHARE_ENUM_STRUCT EnumStruct;
983     SHARE_INFO_0_CONTAINER Level0Container = {0, NULL};
984     SHARE_INFO_1_CONTAINER Level1Container = {0, NULL};
985     SHARE_INFO_2_CONTAINER Level2Container = {0, NULL};
986     SHARE_INFO_502_CONTAINER Level502Container = {0, NULL};
987     NET_API_STATUS status;
988 
989     TRACE("NetShareEnum(%s %lu %p %lu %p %p %p)\n",
990           debugstr_w(servername), level, bufptr, prefmaxlen,
991           entriesread, totalentries, resume_handle);
992 
993     if (level > 2 && level != 502)
994         return ERROR_INVALID_LEVEL;
995 
996     *bufptr = NULL;
997     *entriesread = 0;
998     *totalentries = 0;
999 
1000     EnumStruct.Level = level;
1001     switch (level)
1002     {
1003         case 0:
1004             EnumStruct.ShareInfo.Level0 = &Level0Container;
1005             break;
1006 
1007         case 1:
1008             EnumStruct.ShareInfo.Level1 = &Level1Container;
1009             break;
1010 
1011         case 2:
1012             EnumStruct.ShareInfo.Level2 = &Level2Container;
1013             break;
1014 
1015         case 502:
1016             EnumStruct.ShareInfo.Level502 = &Level502Container;
1017             break;
1018     }
1019 
1020     RpcTryExcept
1021     {
1022         status = NetrShareEnum(servername,
1023                                &EnumStruct,
1024                                prefmaxlen,
1025                                totalentries,
1026                                resume_handle);
1027 
1028         switch (level)
1029         {
1030             case 0:
1031                 if (EnumStruct.ShareInfo.Level0->Buffer != NULL)
1032                 {
1033                     *bufptr = (LPBYTE)EnumStruct.ShareInfo.Level0->Buffer;
1034                     *entriesread = EnumStruct.ShareInfo.Level0->EntriesRead;
1035                 }
1036                 break;
1037 
1038             case 1:
1039                 if (EnumStruct.ShareInfo.Level1->Buffer != NULL)
1040                 {
1041                     *bufptr = (LPBYTE)EnumStruct.ShareInfo.Level1->Buffer;
1042                     *entriesread = EnumStruct.ShareInfo.Level1->EntriesRead;
1043                 }
1044                 break;
1045 
1046             case 2:
1047                 if (EnumStruct.ShareInfo.Level2->Buffer != NULL)
1048                 {
1049                     *bufptr = (LPBYTE)EnumStruct.ShareInfo.Level2->Buffer;
1050                     *entriesread = EnumStruct.ShareInfo.Level2->EntriesRead;
1051                 }
1052                 break;
1053 
1054             case 502:
1055                 if (EnumStruct.ShareInfo.Level502->Buffer != NULL)
1056                 {
1057                     *bufptr = (LPBYTE)EnumStruct.ShareInfo.Level502->Buffer;
1058                     *entriesread = EnumStruct.ShareInfo.Level502->EntriesRead;
1059                 }
1060                 break;
1061         }
1062     }
1063     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1064     {
1065         status = I_RpcMapWin32Status(RpcExceptionCode());
1066     }
1067     RpcEndExcept;
1068 
1069     return status;
1070 }
1071 
1072 
1073 NET_API_STATUS
1074 WINAPI
1075 NetShareEnumSticky(
1076     _In_ LMSTR servername,
1077     _In_ DWORD level,
1078     _Out_ LPBYTE *bufptr,
1079     _In_ DWORD prefmaxlen,
1080     _Out_ LPDWORD entriesread,
1081     _Out_ LPDWORD totalentries,
1082     _Inout_ LPDWORD resume_handle)
1083 {
1084     SHARE_ENUM_STRUCT EnumStruct;
1085     SHARE_INFO_0_CONTAINER Level0Container = {0, NULL};
1086     SHARE_INFO_1_CONTAINER Level1Container = {0, NULL};
1087     SHARE_INFO_2_CONTAINER Level2Container = {0, NULL};
1088     SHARE_INFO_502_CONTAINER Level502Container = {0, NULL};
1089     NET_API_STATUS status;
1090 
1091     TRACE("NetShareEnumSticky(%s %lu %p %lu %p %p %p)\n",
1092           debugstr_w(servername), level, bufptr, prefmaxlen,
1093           entriesread, totalentries, resume_handle);
1094 
1095     if (level > 2 && level != 502)
1096         return ERROR_INVALID_LEVEL;
1097 
1098     *bufptr = NULL;
1099     *entriesread = 0;
1100     *totalentries = 0;
1101 
1102     EnumStruct.Level = level;
1103     switch (level)
1104     {
1105         case 0:
1106             EnumStruct.ShareInfo.Level0 = &Level0Container;
1107             break;
1108 
1109         case 1:
1110             EnumStruct.ShareInfo.Level1 = &Level1Container;
1111             break;
1112 
1113         case 2:
1114             EnumStruct.ShareInfo.Level2 = &Level2Container;
1115             break;
1116 
1117         case 502:
1118             EnumStruct.ShareInfo.Level502 = &Level502Container;
1119             break;
1120     }
1121 
1122     RpcTryExcept
1123     {
1124         status = NetrShareEnum(servername,
1125                                (LPSHARE_ENUM_STRUCT)&EnumStruct,
1126                                prefmaxlen,
1127                                totalentries,
1128                                resume_handle);
1129 
1130         switch (level)
1131         {
1132             case 0:
1133                 if (EnumStruct.ShareInfo.Level0->Buffer != NULL)
1134                 {
1135                     *bufptr = (LPBYTE)EnumStruct.ShareInfo.Level0->Buffer;
1136                     *entriesread = EnumStruct.ShareInfo.Level0->EntriesRead;
1137                 }
1138                 break;
1139 
1140             case 1:
1141                 if (EnumStruct.ShareInfo.Level1->Buffer != NULL)
1142                 {
1143                     *bufptr = (LPBYTE)EnumStruct.ShareInfo.Level1->Buffer;
1144                     *entriesread = EnumStruct.ShareInfo.Level1->EntriesRead;
1145                 }
1146                 break;
1147 
1148             case 2:
1149                 if (EnumStruct.ShareInfo.Level2->Buffer != NULL)
1150                 {
1151                     *bufptr = (LPBYTE)EnumStruct.ShareInfo.Level2->Buffer;
1152                     *entriesread = EnumStruct.ShareInfo.Level2->EntriesRead;
1153                 }
1154                 break;
1155 
1156             case 502:
1157                 if (EnumStruct.ShareInfo.Level502->Buffer != NULL)
1158                 {
1159                     *bufptr = (LPBYTE)EnumStruct.ShareInfo.Level502->Buffer;
1160                     *entriesread = EnumStruct.ShareInfo.Level502->EntriesRead;
1161                 }
1162                 break;
1163         }
1164     }
1165     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1166     {
1167         status = I_RpcMapWin32Status(RpcExceptionCode());
1168     }
1169     RpcEndExcept;
1170 
1171     return status;
1172 }
1173 
1174 
1175 NET_API_STATUS
1176 WINAPI
1177 NetShareGetInfo(
1178     _In_ LMSTR servername,
1179     _In_ LMSTR netname,
1180     _In_ DWORD level,
1181     _Out_ LPBYTE *bufptr)
1182 {
1183     NET_API_STATUS status;
1184 
1185     TRACE("NetShareGetInfo(%s %s %lu %p)\n",
1186           debugstr_w(servername), debugstr_w(netname), level, bufptr);
1187 
1188     if (level > 2 && level != 502 && level != 1005)
1189         return ERROR_INVALID_LEVEL;
1190 
1191     if (netname == NULL || *netname == 0)
1192         return ERROR_INVALID_PARAMETER;
1193 
1194     *bufptr = NULL;
1195 
1196     RpcTryExcept
1197     {
1198         status = NetrShareGetInfo(servername,
1199                                   netname,
1200                                   level,
1201                                   (LPSHARE_INFO)bufptr);
1202     }
1203     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1204     {
1205         status = I_RpcMapWin32Status(RpcExceptionCode());
1206     }
1207     RpcEndExcept;
1208 
1209     return status;
1210 }
1211 
1212 
1213 NET_API_STATUS
1214 WINAPI
1215 NetShareSetInfo(
1216     _In_  LPWSTR servername,
1217     _In_  LPWSTR netname,
1218     _In_  DWORD level,
1219     _In_  LPBYTE buf,
1220     _Out_ LPDWORD parm_err)
1221 {
1222     NET_API_STATUS status;
1223 
1224     TRACE("NetShareSetInfo(%s %s %lu %p %p)\n",
1225           debugstr_w(servername), debugstr_w(netname), level, buf, parm_err);
1226 
1227     if (level != 2 && level != 502 && level != 503 && level != 1004 &&
1228         level != 1005 && level != 1006 && level != 1501)
1229         return ERROR_INVALID_LEVEL;
1230 
1231     RpcTryExcept
1232     {
1233         status = NetrShareSetInfo(servername,
1234                                   netname,
1235                                   level,
1236                                   (LPSHARE_INFO)&buf,
1237                                   parm_err);
1238     }
1239     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1240     {
1241         status = I_RpcMapWin32Status(RpcExceptionCode());
1242     }
1243     RpcEndExcept;
1244 
1245     return status;
1246 }
1247 
1248 /* EOF */
1249