xref: /reactos/dll/win32/netapi32/wksta_new.c (revision cc439606) 
1 /*
2  * COPYRIGHT:       See COPYING in the top level directory
3  * PROJECT:         NetAPI DLL
4  * FILE:            reactos/dll/win32/netapi32/wksta_new.c
5  * PURPOSE:         Workstation service interface code
6  *
7  * PROGRAMMERS:     Eric Kohl
8  */
9 
10 /* INCLUDES ******************************************************************/
11 
12 #include "netapi32.h"
13 #include "wkssvc_c.h"
14 
15 WINE_DEFAULT_DEBUG_CHANNEL(netapi32);
16 
17 /* FUNCTIONS *****************************************************************/
18 
19 void __RPC_FAR * __RPC_USER midl_user_allocate(SIZE_T len)
20 {
21     return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len);
22 }
23 
24 
25 void __RPC_USER midl_user_free(void __RPC_FAR * ptr)
26 {
27     HeapFree(GetProcessHeap(), 0, ptr);
28 }
29 
30 
31 handle_t __RPC_USER
32 WKSSVC_IDENTIFY_HANDLE_bind(WKSSVC_IDENTIFY_HANDLE pszSystemName)
33 {
34     handle_t hBinding = NULL;
35     LPWSTR pszStringBinding;
36     RPC_STATUS status;
37 
38     TRACE("WKSSVC_IDENTIFY_HANDLE_bind() called\n");
39 
40     status = RpcStringBindingComposeW(NULL,
41                                       L"ncacn_np",
42                                       pszSystemName,
43                                       L"\\pipe\\wkssvc",
44                                       NULL,
45                                       &pszStringBinding);
46     if (status)
47     {
48         TRACE("RpcStringBindingCompose returned 0x%x\n", status);
49         return NULL;
50     }
51 
52     /* Set the binding handle that will be used to bind to the server. */
53     status = RpcBindingFromStringBindingW(pszStringBinding,
54                                           &hBinding);
55     if (status)
56     {
57         TRACE("RpcBindingFromStringBinding returned 0x%x\n", status);
58     }
59 
60     status = RpcStringFreeW(&pszStringBinding);
61     if (status)
62     {
63 //        TRACE("RpcStringFree returned 0x%x\n", status);
64     }
65 
66     return hBinding;
67 }
68 
69 
70 void __RPC_USER
71 WKSSVC_IDENTIFY_HANDLE_unbind(WKSSVC_IDENTIFY_HANDLE pszSystemName,
72                               handle_t hBinding)
73 {
74     RPC_STATUS status;
75 
76     TRACE("WKSSVC_IDENTIFY_HANDLE_unbind() called\n");
77 
78     status = RpcBindingFree(&hBinding);
79     if (status)
80     {
81         TRACE("RpcBindingFree returned 0x%x\n", status);
82     }
83 }
84 
85 
86 handle_t __RPC_USER
87 WKSSVC_IMPERSONATE_HANDLE_bind(WKSSVC_IMPERSONATE_HANDLE pszSystemName)
88 {
89     handle_t hBinding = NULL;
90     LPWSTR pszStringBinding;
91     RPC_STATUS status;
92 
93     TRACE("WKSSVC_IMPERSONATE_HANDLE_bind() called\n");
94 
95     status = RpcStringBindingComposeW(NULL,
96                                       L"ncacn_np",
97                                       pszSystemName,
98                                       L"\\pipe\\wkssvc",
99                                       NULL,
100                                       &pszStringBinding);
101     if (status)
102     {
103         TRACE("RpcStringBindingCompose returned 0x%x\n", status);
104         return NULL;
105     }
106 
107     /* Set the binding handle that will be used to bind to the server. */
108     status = RpcBindingFromStringBindingW(pszStringBinding,
109                                           &hBinding);
110     if (status)
111     {
112         TRACE("RpcBindingFromStringBinding returned 0x%x\n", status);
113     }
114 
115     status = RpcStringFreeW(&pszStringBinding);
116     if (status)
117     {
118 //        TRACE("RpcStringFree returned 0x%x\n", status);
119     }
120 
121     return hBinding;
122 }
123 
124 
125 void __RPC_USER
126 WKSSVC_IMPERSONATE_HANDLE_unbind(WKSSVC_IMPERSONATE_HANDLE pszSystemName,
127                                  handle_t hBinding)
128 {
129     RPC_STATUS status;
130 
131     TRACE("WKSSVC_IMPERSONATE_HANDLE_unbind() called\n");
132 
133     status = RpcBindingFree(&hBinding);
134     if (status)
135     {
136         TRACE("RpcBindingFree returned 0x%x\n", status);
137     }
138 }
139 
140 
141 NET_API_STATUS
142 WINAPI
143 NetAddAlternateComputerName(
144     _In_opt_ LPCWSTR Server,
145     _In_ LPCWSTR AlternateName,
146     _In_opt_ LPCWSTR DomainAccount,
147     _In_opt_ LPCWSTR DomainAccountPassword,
148     _In_ ULONG Reserved)
149 {
150     PJOINPR_ENCRYPTED_USER_PASSWORD EncryptedPassword;
151     handle_t BindingHandle;
152     NET_API_STATUS status;
153 
154     TRACE("NetAddAlternateComputerName(%s %s %s %s 0x%lx)\n",
155           debugstr_w(Server), debugstr_w(AlternateName), debugstr_w(DomainAccount),
156           debugstr_w(DomainAccountPassword), Reserved);
157 
158     /* FIXME */
159     BindingHandle = NULL;
160     EncryptedPassword = NULL;
161 
162     RpcTryExcept
163     {
164         status = NetrAddAlternateComputerName(BindingHandle,
165                                               (PWSTR)Server,
166                                               (PWSTR)AlternateName,
167                                               (PWSTR)DomainAccount,
168                                               EncryptedPassword,
169                                               Reserved);
170     }
171     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
172     {
173         status = I_RpcMapWin32Status(RpcExceptionCode());
174     }
175     RpcEndExcept;
176 
177     return status;
178 }
179 
180 
181 NET_API_STATUS
182 WINAPI
183 NetEnumerateComputerNames(
184     _In_opt_ LPCWSTR Server,
185     _In_ NET_COMPUTER_NAME_TYPE NameType,
186     _In_ ULONG Reserved,
187     _Out_ PDWORD EntryCount,
188     _Out_ LPWSTR **ComputerNames)
189 {
190     PNET_COMPUTER_NAME_ARRAY ComputerNameArray = NULL;
191     ULONG BufferSize, i;
192     PWSTR *NameBuffer = NULL, Ptr;
193     NET_API_STATUS status;
194 
195     TRACE("NetEnumerateComputerNames(%s %lu %lu %p %p)\n",
196           debugstr_w(Server), NameType, Reserved, EntryCount, ComputerNames);
197 
198     RpcTryExcept
199     {
200         status = NetrEnumerateComputerNames((PWSTR)Server,
201                                             NameType,
202                                             Reserved,
203                                             &ComputerNameArray);
204         if (status == NERR_Success)
205         {
206             *EntryCount = ComputerNameArray->EntryCount;
207 
208             BufferSize = 0;
209             for (i = 0; i < ComputerNameArray->EntryCount; i++)
210             {
211                 BufferSize += ComputerNameArray->ComputerNames[i].Length + sizeof(WCHAR) + sizeof(PWSTR);
212             }
213 
214             status = NetApiBufferAllocate(BufferSize, (PVOID*)&NameBuffer);
215             if (status == NERR_Success)
216             {
217                 ZeroMemory(NameBuffer, BufferSize);
218 
219                 Ptr = (PWSTR)((ULONG_PTR)NameBuffer + ComputerNameArray->EntryCount * sizeof(PWSTR));
220                 for (i = 0; i < ComputerNameArray->EntryCount; i++)
221                 {
222                     NameBuffer[i] = Ptr;
223                     CopyMemory(Ptr,
224                                ComputerNameArray->ComputerNames[i].Buffer,
225                                ComputerNameArray->ComputerNames[i].Length);
226                     Ptr = (PWSTR)((ULONG_PTR)Ptr + ComputerNameArray->ComputerNames[i].Length + sizeof(WCHAR));
227                 }
228 
229                 *ComputerNames = NameBuffer;
230             }
231         }
232     }
233     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
234     {
235         status = I_RpcMapWin32Status(RpcExceptionCode());
236     }
237     RpcEndExcept;
238 
239     return status;
240 }
241 
242 
243 #if 0
244 NET_API_STATUS
245 WINAPI
246 NetGetJoinInformation(
247     _In_ LPCWSTR lpServer,
248     _Out_ LPWSTR *lpNameBuffer,
249     _Out_ PNETSETUP_JOIN_STATUS BufferType)
250 {
251     NET_API_STATUS status;
252 
253     TRACE("NetGetJoinInformation(%s %p %p)\n",
254           debugstr_w(lpServer), lpNameBuffer, BufferType);
255 
256     if (lpNameBuffer == NULL || BufferType == NULL)
257         return ERROR_INVALID_PARAMETER;
258 
259     RpcTryExcept
260     {
261         status = NetrGetJoinInformation((LPWSTR)lpServer,
262                                         lpNameBuffer,
263                                         BufferType);
264     }
265     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
266     {
267         status = I_RpcMapWin32Status(RpcExceptionCode());
268     }
269     RpcEndExcept;
270 
271     return status;
272 }
273 #endif
274 
275 
276 NET_API_STATUS
277 WINAPI
278 NetGetJoinableOUs(
279     _In_ LPCWSTR lpServer,
280     _In_ LPCWSTR lpDomain,
281     _In_ LPCWSTR lpAccount,
282     _In_ LPCWSTR lpPassword,
283     _Out_ DWORD *OUCount,
284     _Out_ LPWSTR **OUs)
285 {
286     PJOINPR_ENCRYPTED_USER_PASSWORD EncryptedPassword;
287     handle_t BindingHandle;
288     NET_API_STATUS status;
289 
290     TRACE("NetGetJoinableOUs(%s %s %s %s %p %p)\n",
291           debugstr_w(lpServer), debugstr_w(lpDomain), debugstr_w(lpAccount),
292           debugstr_w(lpPassword), OUCount, OUs);
293 
294     /* FIXME */
295     BindingHandle = NULL;
296     EncryptedPassword = NULL;
297 
298     RpcTryExcept
299     {
300         status = NetrGetJoinableOUs2(BindingHandle,
301                                      (PWSTR)lpServer,
302                                      (PWSTR)lpDomain,
303                                      (PWSTR)lpAccount,
304                                      EncryptedPassword,
305                                      OUCount,
306                                      OUs);
307     }
308     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
309     {
310         status = I_RpcMapWin32Status(RpcExceptionCode());
311     }
312     RpcEndExcept;
313 
314     return status;
315 }
316 
317 
318 NET_API_STATUS
319 WINAPI
320 NetJoinDomain(
321     _In_ LPCWSTR lpServer,
322     _In_ LPCWSTR lpDomain,
323     _In_ LPCWSTR lpAccountOU,
324     _In_ LPCWSTR lpAccount,
325     _In_ LPCWSTR lpPassword,
326     _In_ DWORD fJoinOptions)
327 {
328     PJOINPR_ENCRYPTED_USER_PASSWORD EncryptedPassword;
329     handle_t BindingHandle;
330     NET_API_STATUS status;
331 
332     TRACE("NetJoinDomain(%s %s %s %s 0x%lx)\n",
333           debugstr_w(lpServer), debugstr_w(lpDomain), debugstr_w(lpAccountOU),
334           debugstr_w(lpAccount), debugstr_w(lpPassword), fJoinOptions);
335 
336     /* FIXME */
337     BindingHandle = NULL;
338     EncryptedPassword = NULL;
339 
340     RpcTryExcept
341     {
342         status = NetrJoinDomain2(BindingHandle,
343                                  (PWSTR)lpServer,
344                                  (PWSTR)lpDomain,
345                                  (PWSTR)lpAccountOU,
346                                  (PWSTR)lpAccount,
347                                  EncryptedPassword,
348                                  fJoinOptions);
349     }
350     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
351     {
352         status = I_RpcMapWin32Status(RpcExceptionCode());
353     }
354     RpcEndExcept;
355 
356     return status;
357 }
358 
359 
360 NET_API_STATUS
361 WINAPI
362 NetRemoveAlternateComputerName(
363     _In_opt_ LPCWSTR Server,
364     _In_ LPCWSTR AlternateName,
365     _In_opt_ LPCWSTR DomainAccount,
366     _In_opt_ LPCWSTR DomainAccountPassword,
367     _In_ ULONG Reserved)
368 {
369     PJOINPR_ENCRYPTED_USER_PASSWORD EncryptedPassword;
370     handle_t BindingHandle;
371     NET_API_STATUS status;
372 
373     TRACE("NetRemoveAlternateComputerName(%s %s %s %s 0x%lx)\n",
374           debugstr_w(Server), debugstr_w(AlternateName), debugstr_w(DomainAccount),
375           debugstr_w(DomainAccountPassword), Reserved);
376 
377     /* FIXME */
378     BindingHandle = NULL;
379     EncryptedPassword = NULL;
380 
381     RpcTryExcept
382     {
383         status = NetrRemoveAlternateComputerName(BindingHandle,
384                                                  (PWSTR)Server,
385                                                  (PWSTR)AlternateName,
386                                                  (PWSTR)DomainAccount,
387                                                  EncryptedPassword,
388                                                  Reserved);
389     }
390     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
391     {
392         status = I_RpcMapWin32Status(RpcExceptionCode());
393     }
394     RpcEndExcept;
395 
396     return status;
397 }
398 
399 
400 NET_API_STATUS
401 WINAPI
402 NetRenameMachineInDomain(
403     _In_ LPCWSTR lpServer,
404     _In_ LPCWSTR lpNewMachineName,
405     _In_ LPCWSTR lpAccount,
406     _In_ LPCWSTR lpPassword,
407     _In_ DWORD fRenameOptions)
408 {
409     PJOINPR_ENCRYPTED_USER_PASSWORD EncryptedPassword;
410     handle_t BindingHandle;
411     NET_API_STATUS status;
412 
413     TRACE("NetRenameMachineInDomain(%s %s %s %s 0x%lx)\n",
414           debugstr_w(lpServer), debugstr_w(lpNewMachineName), debugstr_w(lpAccount),
415           debugstr_w(lpPassword), fRenameOptions);
416 
417     /* FIXME */
418     BindingHandle = NULL;
419     EncryptedPassword = NULL;
420 
421     RpcTryExcept
422     {
423         status = NetrRenameMachineInDomain2(BindingHandle,
424                                             (PWSTR)lpServer,
425                                             (PWSTR)lpNewMachineName,
426                                             (PWSTR)lpAccount,
427                                             EncryptedPassword,
428                                             fRenameOptions);
429     }
430     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
431     {
432         status = I_RpcMapWin32Status(RpcExceptionCode());
433     }
434     RpcEndExcept;
435 
436     return status;
437 }
438 
439 
440 NET_API_STATUS
441 WINAPI
442 NetSetPrimaryComputerName(
443     _In_opt_ LPCWSTR Server,
444     _In_ LPCWSTR PrimaryName,
445     _In_opt_ LPCWSTR DomainAccount,
446     _In_opt_ LPCWSTR DomainAccountPassword,
447     _In_ ULONG Reserved)
448 {
449     PJOINPR_ENCRYPTED_USER_PASSWORD EncryptedPassword;
450     handle_t BindingHandle;
451     NET_API_STATUS status;
452 
453     TRACE("NetSetPrimaryComputerName(%s %s %s %s %lu)\n",
454           debugstr_w(Server), debugstr_w(PrimaryName), debugstr_w(DomainAccount),
455           debugstr_w(DomainAccountPassword), Reserved);
456 
457     /* FIXME */
458     BindingHandle = NULL;
459     EncryptedPassword = NULL;
460 
461     RpcTryExcept
462     {
463         status = NetrSetPrimaryComputerName(BindingHandle,
464                                             (PWSTR)Server,
465                                             (PWSTR)PrimaryName,
466                                             (PWSTR)DomainAccount,
467                                             EncryptedPassword,
468                                             Reserved);
469     }
470     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
471     {
472         status = I_RpcMapWin32Status(RpcExceptionCode());
473     }
474     RpcEndExcept;
475 
476     return status;
477 }
478 
479 
480 NET_API_STATUS
481 WINAPI
482 NetUnjoinDomain(
483     _In_ LPCWSTR lpServer,
484     _In_ LPCWSTR lpAccount,
485     _In_ LPCWSTR lpPassword,
486     _In_ DWORD fUnjoinOptions)
487 {
488     PJOINPR_ENCRYPTED_USER_PASSWORD EncryptedPassword;
489     handle_t BindingHandle;
490     NET_API_STATUS status;
491 
492     TRACE("NetUnjoinDomain(%s %s %s %s 0x%lx)\n",
493           debugstr_w(lpServer), debugstr_w(lpAccount),
494           debugstr_w(lpPassword), fUnjoinOptions);
495 
496     /* FIXME */
497     BindingHandle = NULL;
498     EncryptedPassword = NULL;
499 
500     RpcTryExcept
501     {
502         status = NetrUnjoinDomain2(BindingHandle,
503                                    (PWSTR)lpServer,
504                                    (PWSTR)lpAccount,
505                                    EncryptedPassword,
506                                    fUnjoinOptions);
507     }
508     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
509     {
510         status = I_RpcMapWin32Status(RpcExceptionCode());
511     }
512     RpcEndExcept;
513 
514     return status;
515 }
516 
517 
518 NET_API_STATUS
519 WINAPI
520 NetUseAdd(
521     _In_ LMSTR UncServerName,
522     _In_ DWORD Level,
523     _In_ LPBYTE Buf,
524     _Out_ LPDWORD ParmError)
525 {
526     NET_API_STATUS status;
527 
528     TRACE("NetUseAdd(%s %d %p %p)\n", debugstr_w(UncServerName),
529           Level, Buf, ParmError);
530 
531     RpcTryExcept
532     {
533         status = NetrUseAdd(UncServerName,
534                             Level,
535                             (LPUSE_INFO)Buf,
536                             ParmError);
537     }
538     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
539     {
540         status = I_RpcMapWin32Status(RpcExceptionCode());
541     }
542     RpcEndExcept;
543 
544     return status;
545 }
546 
547 
548 NET_API_STATUS
549 WINAPI
550 NetUseDel(
551     _In_ LMSTR UncServerName,
552     _In_ LMSTR UseName,
553     _In_ DWORD ForceCond)
554 {
555     NET_API_STATUS status;
556 
557     TRACE("NetUseDel(%s %s %d)\n", debugstr_w(UncServerName),
558           debugstr_w(UseName), ForceCond);
559 
560     RpcTryExcept
561     {
562         status = NetrUseDel(UncServerName,
563                             UseName,
564                             ForceCond);
565     }
566     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
567     {
568         status = I_RpcMapWin32Status(RpcExceptionCode());
569     }
570     RpcEndExcept;
571 
572     return status;
573 }
574 
575 
576 NET_API_STATUS
577 WINAPI
578 NetUseEnum(
579     _In_ LMSTR UncServerName,
580     _In_ DWORD Level,
581     _Out_ LPBYTE *BufPtr,
582     _In_ DWORD PreferedMaximumSize,
583     _Out_ LPDWORD EntriesRead,
584     _Out_ LPDWORD TotalEntries,
585     _Inout_ LPDWORD ResumeHandle)
586 {
587     USE_ENUM_STRUCT UseEnumInfo;
588     USE_INFO_0_CONTAINER Container0;
589     USE_INFO_1_CONTAINER Container1;
590     USE_INFO_2_CONTAINER Container2;
591     NET_API_STATUS status;
592 
593     TRACE("NetUseEnum(%s, %d, %p, %d, %p, %p, %p)\n", debugstr_w(UncServerName),
594           Level, BufPtr, PreferedMaximumSize, EntriesRead, TotalEntries, ResumeHandle);
595 
596     UseEnumInfo.Level = Level;
597     switch (Level)
598     {
599         case 0:
600             UseEnumInfo.UseInfo.Level0 = &Container0;
601             Container0.EntriesRead = 0;
602             Container0.Buffer = NULL;
603             break;
604 
605         case 1:
606             UseEnumInfo.UseInfo.Level1 = &Container1;
607             Container1.EntriesRead = 0;
608             Container1.Buffer = NULL;
609             break;
610 
611         case 2:
612             UseEnumInfo.UseInfo.Level2 = &Container2;
613             Container2.EntriesRead = 0;
614             Container2.Buffer = NULL;
615             break;
616 
617         default:
618             return ERROR_INVALID_PARAMETER;
619     }
620 
621     RpcTryExcept
622     {
623         status = NetrUseEnum(UncServerName,
624                              &UseEnumInfo,
625                              PreferedMaximumSize,
626                              TotalEntries,
627                              ResumeHandle);
628         if (status == NERR_Success || status == ERROR_MORE_DATA)
629         {
630             switch (Level)
631             {
632                 case 0:
633                     *BufPtr = (LPBYTE)UseEnumInfo.UseInfo.Level0->Buffer;
634                     *EntriesRead = UseEnumInfo.UseInfo.Level0->EntriesRead;
635                     break;
636 
637                 case 1:
638                     *BufPtr = (LPBYTE)UseEnumInfo.UseInfo.Level1->Buffer;
639                     *EntriesRead = UseEnumInfo.UseInfo.Level1->EntriesRead;
640                     break;
641 
642                 case 2:
643                     *BufPtr = (LPBYTE)UseEnumInfo.UseInfo.Level2->Buffer;
644                     *EntriesRead = UseEnumInfo.UseInfo.Level2->EntriesRead;
645                     break;
646             }
647         }
648     }
649     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
650     {
651         status = I_RpcMapWin32Status(RpcExceptionCode());
652     }
653     RpcEndExcept;
654 
655     return status;
656 }
657 
658 
659 NET_API_STATUS
660 WINAPI
661 NetUseGetInfo(
662     _In_ LMSTR UncServerName,
663     _In_ LMSTR UseName,
664     _In_ DWORD Level,
665     _Out_ LPBYTE *BufPtr)
666 {
667     NET_API_STATUS status;
668 
669     TRACE("NetUseGetInfo(%s, %s, %d, %p)\n", debugstr_w(UncServerName),
670           debugstr_w(UseName), Level, BufPtr);
671 
672     *BufPtr = NULL;
673 
674     RpcTryExcept
675     {
676         status = NetrUseGetInfo(UncServerName,
677                                 UseName,
678                                 Level,
679                                 (LPUSE_INFO)BufPtr);
680     }
681     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
682     {
683         status = I_RpcMapWin32Status(RpcExceptionCode());
684     }
685     RpcEndExcept;
686 
687     return status;
688 }
689 
690 
691 NET_API_STATUS
692 WINAPI
693 NetValidateName(
694     _In_ LPCWSTR lpServer,
695     _In_ LPCWSTR lpName,
696     _In_ LPCWSTR lpAccount,
697     _In_ LPCWSTR lpPassword,
698     _In_ NETSETUP_NAME_TYPE NameType)
699 {
700     PJOINPR_ENCRYPTED_USER_PASSWORD EncryptedPassword;
701     handle_t BindingHandle;
702     NET_API_STATUS status;
703 
704     TRACE("NetValidateName(%s %s %s %s %u)\n",
705           debugstr_w(lpServer), debugstr_w(lpName), debugstr_w(lpAccount),
706           debugstr_w(lpPassword), NameType);
707 
708     /* FIXME */
709     BindingHandle = NULL;
710     EncryptedPassword = NULL;
711 
712     RpcTryExcept
713     {
714         status = NetrValidateName2(BindingHandle,
715                                    (PWSTR)lpServer,
716                                    (PWSTR)lpName,
717                                    (PWSTR)lpAccount,
718                                    EncryptedPassword,
719                                    NameType);
720     }
721     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
722     {
723         status = I_RpcMapWin32Status(RpcExceptionCode());
724     }
725     RpcEndExcept;
726 
727     return status;
728 }
729 
730 
731 #if 0
732 NET_API_STATUS
733 WINAPI
734 NetWkstaGetInfo(
735     _In_ LPWSTR servername,
736     _In_ DWORD level,
737     _Out_ LPBYTE *bufptr)
738 {
739     NET_API_STATUS status;
740 
741     TRACE("NetWkstaGetInfo(%s, %d, %p)\n",
742           debugstr_w(servername), level, bufptr);
743 
744     if (bufptr == NULL)
745         return ERROR_INVALID_PARAMETER;
746 
747     *bufptr = NULL;
748 
749     RpcTryExcept
750     {
751         status = NetrWkstaGetInfo(servername,
752                                   level,
753                                   (LPWKSTA_INFO)bufptr);
754     }
755     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
756     {
757         status = I_RpcMapWin32Status(RpcExceptionCode());
758     }
759     RpcEndExcept;
760 
761     return status;
762 }
763 #endif
764 
765 
766 NET_API_STATUS
767 WINAPI
768 NetWkstaSetInfo(
769     _In_ LPWSTR servername,
770     _In_ DWORD level,
771     _In_ LPBYTE buffer,
772     _Out_ LPDWORD parm_err)
773 {
774     NET_API_STATUS status;
775 
776     TRACE("NetWkstaSetInfo(%s, %d, %p, %p)\n",
777           debugstr_w(servername), level, buffer, parm_err);
778 
779     RpcTryExcept
780     {
781         status = NetrWkstaSetInfo(servername,
782                                   level,
783                                   (LPWKSTA_INFO)buffer,
784                                   parm_err);
785     }
786     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
787     {
788         status = I_RpcMapWin32Status(RpcExceptionCode());
789     }
790     RpcEndExcept;
791 
792     return status;
793 }
794 
795 
796 NET_API_STATUS
797 WINAPI
798 NetWkstaTransportAdd(
799     _In_opt_ LPWSTR servername,
800     _In_ DWORD level,
801     _In_ LPBYTE buf,
802     _Out_ LPDWORD parm_err)
803 {
804     NET_API_STATUS status;
805 
806     TRACE("NetWkstaTransportAdd(%s, %d, %p, %p)\n", debugstr_w(servername),
807           level, buf, parm_err);
808 
809     RpcTryExcept
810     {
811         status = NetrWkstaTransportAdd(servername,
812                                        level,
813                                        (LPWKSTA_TRANSPORT_INFO_0)buf,
814                                        parm_err);
815     }
816     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
817     {
818         status = I_RpcMapWin32Status(RpcExceptionCode());
819     }
820     RpcEndExcept;
821 
822     return status;
823 }
824 
825 
826 NET_API_STATUS
827 WINAPI
828 NetWkstaTransportDel(
829     _In_opt_ LPWSTR servername,
830     _In_ LPWSTR transportname,
831     _In_ DWORD ucond)
832 {
833     NET_API_STATUS status;
834 
835     TRACE("NetWkstaTransportDel(%s, %s, %d)\n", debugstr_w(servername),
836           debugstr_w(transportname), ucond);
837 
838     RpcTryExcept
839     {
840         status = NetrWkstaTransportDel(servername,
841                                        transportname,
842                                        ucond);
843     }
844     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
845     {
846         status = I_RpcMapWin32Status(RpcExceptionCode());
847     }
848     RpcEndExcept;
849 
850     return status;
851 }
852 
853 
854 #if 0
855 NET_API_STATUS
856 WINAPI
857 NetWkstaTransportEnum(
858     _In_opt_ LPWSTR servername,
859     _In_ DWORD level,
860     _Out_ LPBYTE *bufptr,
861     _In_ DWORD prefmaxlen,
862     _Out_ LPDWORD entriesread,
863     _Out_ LPDWORD totalentries,
864     _Inout_ LPDWORD resumehandle)
865 {
866     WKSTA_TRANSPORT_ENUM_STRUCT TransportEnumInfo;
867     WKSTA_TRANSPORT_INFO_0_CONTAINER Container0;
868     NET_API_STATUS status;
869 
870     TRACE("NetWkstaTransportEnum(%s, %d, %p, %d, %p, %p, %p)\n", debugstr_w(servername),
871           level, bufptr, prefmaxlen, entriesread, totalentries, resumehandle);
872 
873     TransportEnumInfo.Level = level;
874     switch (level)
875     {
876         case 0:
877             TransportEnumInfo.WkstaTransportInfo.Level0 = &Container0;
878             Container0.EntriesRead = 0;
879             Container0.Buffer = NULL;
880             break;
881 
882         default:
883             return ERROR_INVALID_PARAMETER;
884     }
885 
886     RpcTryExcept
887     {
888         status = NetrWkstaTransportEnum(servername,
889                                         &TransportEnumInfo,
890                                         prefmaxlen,
891                                         totalentries,
892                                         resumehandle);
893         if (status == NERR_Success || status == ERROR_MORE_DATA)
894         {
895             switch (level)
896             {
897                 case 0:
898                     *bufptr = (LPBYTE)TransportEnumInfo.WkstaTransportInfo.Level0->Buffer;
899                     *entriesread = TransportEnumInfo.WkstaTransportInfo.Level0->EntriesRead;
900                     break;
901             }
902         }
903     }
904     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
905     {
906         status = I_RpcMapWin32Status(RpcExceptionCode());
907     }
908     RpcEndExcept;
909 
910     return status;
911 }
912 
913 
914 NET_API_STATUS
915 WINAPI
916 NetWkstaUserEnum(
917     _In_ LPWSTR servername,
918     _In_ DWORD level,
919     _Out_ LPBYTE *bufptr,
920     _In_ DWORD prefmaxlen,
921     _Out_ LPDWORD entriesread,
922     _Out_ LPDWORD totalentries,
923     _Inout_ LPDWORD resumehandle)
924 {
925     WKSTA_USER_ENUM_STRUCT UserEnumInfo;
926     WKSTA_USER_INFO_0_CONTAINER Container0;
927     WKSTA_USER_INFO_1_CONTAINER Container1;
928     NET_API_STATUS status;
929 
930     TRACE("NetWkstaUserEnum(%s, %d, %p, %d, %p, %p, %p)\n", debugstr_w(servername),
931           level, bufptr, prefmaxlen, entriesread, totalentries, resumehandle);
932 
933     UserEnumInfo.Level = level;
934     switch (level)
935     {
936         case 0:
937             UserEnumInfo.WkstaUserInfo.Level0 = &Container0;
938             Container0.EntriesRead = 0;
939             Container0.Buffer = NULL;
940             break;
941 
942         case 1:
943             UserEnumInfo.WkstaUserInfo.Level1 = &Container1;
944             Container1.EntriesRead = 0;
945             Container1.Buffer = NULL;
946             break;
947 
948         default:
949             return ERROR_INVALID_PARAMETER;
950     }
951 
952     RpcTryExcept
953     {
954         status = NetrWkstaUserEnum(servername,
955                                    &UserEnumInfo,
956                                    prefmaxlen,
957                                    totalentries,
958                                    resumehandle);
959         if (status == NERR_Success || status == ERROR_MORE_DATA)
960         {
961             switch (level)
962             {
963                 case 0:
964                     *bufptr = (LPBYTE)UserEnumInfo.WkstaUserInfo.Level0->Buffer;
965                     *entriesread = UserEnumInfo.WkstaUserInfo.Level0->EntriesRead;
966                     break;
967 
968                 case 1:
969                     *bufptr = (LPBYTE)UserEnumInfo.WkstaUserInfo.Level1->Buffer;
970                     *entriesread = UserEnumInfo.WkstaUserInfo.Level1->EntriesRead;
971                     break;
972             }
973         }
974     }
975     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
976     {
977         status = I_RpcMapWin32Status(RpcExceptionCode());
978     }
979     RpcEndExcept;
980 
981     return status;
982 }
983 
984 
985 NET_API_STATUS
986 WINAPI
987 NetWkstaUserGetInfo(
988     LPWSTR reserved,
989     _In_ DWORD level,
990     _Out_ PBYTE *bufptr)
991 {
992     NET_API_STATUS status;
993 
994     TRACE("NetWkstaUserGetInfo(%s, %d, %p)\n",
995           debugstr_w(reserved), level, bufptr);
996 
997     if (reserved != NULL)
998         return ERROR_INVALID_PARAMETER;
999 
1000     *bufptr = NULL;
1001 
1002     RpcTryExcept
1003     {
1004         status = NetrWkstaUserGetInfo(NULL,
1005                                       level,
1006                                       (LPWKSTA_USER_INFO)bufptr);
1007     }
1008     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1009     {
1010         status = I_RpcMapWin32Status(RpcExceptionCode());
1011     }
1012     RpcEndExcept;
1013 
1014     return status;
1015 }
1016 #endif
1017 
1018 
1019 NET_API_STATUS
1020 WINAPI
1021 NetWkstaUserSetInfo(
1022     LPWSTR reserved,
1023     _In_ DWORD level,
1024     _In_ LPBYTE buf,
1025     _Out_ LPDWORD parm_err)
1026 {
1027     NET_API_STATUS status;
1028 
1029     TRACE("NetWkstaSetInfo(%s, %d, %p, %p)\n",
1030           debugstr_w(reserved), level, buf, parm_err);
1031 
1032     if (reserved != NULL)
1033         return ERROR_INVALID_PARAMETER;
1034 
1035     RpcTryExcept
1036     {
1037        status = NetrWkstaUserSetInfo(NULL,
1038                                      level,
1039                                      (LPWKSTA_USER_INFO)&buf,
1040                                      parm_err);
1041     }
1042     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1043     {
1044         status = I_RpcMapWin32Status(RpcExceptionCode());
1045     }
1046     RpcEndExcept;
1047 
1048     return status;
1049 }
1050 
1051 /* EOF */
1052