[NETAPI32] Implement I_NetServerSetServiceBits()
[reactos.git] / 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 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_ LMSTR servername,
614 _In_ LMSTR UncClientName,
615 _In_ 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_ LMSTR servername,
642 _In_ LMSTR UncClientName,
643 _In_ 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_ 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 */