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
SRVSVC_HANDLE_bind(SRVSVC_HANDLE pszSystemName)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
SRVSVC_HANDLE_unbind(SRVSVC_HANDLE pszSystemName,handle_t hBinding)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
NetConnectionEnum(_In_ LMSTR servername,_In_ LMSTR qualifier,_In_ DWORD level,_Out_ LPBYTE * bufptr,_In_ DWORD prefmaxlen,_Out_ LPDWORD entriesread,_Out_ LPDWORD totalentries,_Inout_ LPDWORD resume_handle)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
NetFileClose(_In_ LMSTR servername,_In_ DWORD fileid)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
NetFileEnum(_In_ LMSTR servername,_In_ LMSTR basepath,_In_ LMSTR username,_In_ DWORD level,_Out_ LPBYTE * bufptr,_In_ DWORD prefmaxlen,_Out_ LPDWORD entriesread,_Out_ LPDWORD totalentries,_Inout_ PDWORD_PTR resume_handle)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
NetFileGetInfo(_In_ LMSTR servername,_In_ DWORD fileid,_In_ DWORD level,_Out_ LPBYTE * bufptr)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
NetRemoteTOD(_In_ LPCWSTR UncServerName,_Out_ LPBYTE * BufferPtr)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
NetServerDiskEnum(_In_ LMSTR servername,_In_ DWORD level,_Out_ LPBYTE * bufptr,_In_ DWORD prefmaxlen,_Out_ LPDWORD entriesread,_Out_ LPDWORD totalentries,_Inout_ LPDWORD resume_handle)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
NetServerGetInfo(LMSTR servername,DWORD level,LPBYTE * bufptr)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
NetServerSetInfo(_In_ LPWSTR servername,_In_ DWORD level,_In_ LPBYTE buf,_Out_ LPDWORD parm_err)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
I_NetServerSetServiceBits(_In_ LPWSTR servername,_In_ LPWSTR transport,_In_ DWORD servicebits,_In_ DWORD updateimmediately)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
NetServerTransportAdd(_In_ LPWSTR servername,_In_ DWORD level,_In_ LPBYTE bufptr)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
NetServerTransportAddEx(_In_ LPWSTR servername,_In_ DWORD level,_In_ LPBYTE bufptr)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
NetServerTransportDel(_In_ LPWSTR servername,_In_ DWORD level,_In_ LPBYTE bufptr)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
NetServerTransportEnum(_In_ LPWSTR servername,_In_ DWORD level,_Out_ LPBYTE * bufptr,_In_ DWORD prefmaxlen,_Out_ LPDWORD entriesread,_Out_ LPDWORD totalentries,_Inout_ LPDWORD resume_handle)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
NetSessionDel(_In_opt_ LMSTR servername,_In_opt_ LMSTR UncClientName,_In_opt_ LMSTR username)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
NetSessionEnum(_In_opt_ LMSTR servername,_In_opt_ LMSTR UncClientName,_In_opt_ LMSTR username,_In_ DWORD level,_Out_ LPBYTE * bufptr,_In_ DWORD prefmaxlen,_Out_ LPDWORD entriesread,_Out_ LPDWORD totalentries,_Inout_ LPDWORD resume_handle)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
NetSessionGetInfo(_In_opt_ LMSTR servername,_In_ LMSTR UncClientName,_In_ LMSTR username,_In_ DWORD level,_Out_ LPBYTE * bufptr)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
NetShareAdd(_In_ LMSTR servername,_In_ DWORD level,_In_ LPBYTE buf,_Out_ LPDWORD parm_err)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
NetShareCheck(_In_ LMSTR servername,_In_ LMSTR device,_Out_ LPDWORD type)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
NetShareDel(_In_ LMSTR servername,_In_ LMSTR netname,_In_ DWORD reserved)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
NetShareDelSticky(_In_ LMSTR servername,_In_ LMSTR netname,_In_ DWORD reserved)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
NetShareEnum(_In_ LMSTR servername,_In_ DWORD level,_Out_ LPBYTE * bufptr,_In_ DWORD prefmaxlen,_Out_ LPDWORD entriesread,_Out_ LPDWORD totalentries,_Inout_ LPDWORD resume_handle)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
NetShareEnumSticky(_In_ LMSTR servername,_In_ DWORD level,_Out_ LPBYTE * bufptr,_In_ DWORD prefmaxlen,_Out_ LPDWORD entriesread,_Out_ LPDWORD totalentries,_Inout_ LPDWORD resume_handle)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
NetShareGetInfo(_In_ LMSTR servername,_In_ LMSTR netname,_In_ DWORD level,_Out_ LPBYTE * bufptr)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
NetShareSetInfo(_In_ LPWSTR servername,_In_ LPWSTR netname,_In_ DWORD level,_In_ LPBYTE buf,_Out_ LPDWORD parm_err)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