xref: /reactos/dll/win32/netapi32/wksta_new.c (revision 019f21ee) 
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 NetpBind(
143     LPCWSTR pszServerName,
144     handle_t *pBindingHandle)
145 {
146     handle_t hBinding = NULL;
147     LPWSTR pszStringBinding;
148     RPC_STATUS status;
149 
150     FIXME("NetpBind(%S)\n", pszServerName);
151 
152     *pBindingHandle = NULL;
153 
154     status = RpcStringBindingComposeW(NULL,
155                                       L"ncacn_np",
156                                       (LPWSTR)pszServerName,
157                                       L"\\pipe\\wkssvc",
158                                       NULL,
159                                       &pszStringBinding);
160     if (status)
161     {
162         FIXME("RpcStringBindingCompose returned 0x%x\n", status);
163         return NetpNtStatusToApiStatus(status);
164     }
165 
166     /* Set the binding handle that will be used to bind to the server. */
167     status = RpcBindingFromStringBindingW(pszStringBinding,
168                                           &hBinding);
169     if (status)
170     {
171         FIXME("RpcBindingFromStringBinding returned 0x%x\n", status);
172     }
173 
174     status = RpcStringFreeW(&pszStringBinding);
175     if (status)
176     {
177         FIXME("RpcStringFree returned 0x%x\n", status);
178     }
179 
180     *pBindingHandle = hBinding;
181 
182     return NetpNtStatusToApiStatus(status);
183 }
184 
185 
186 NET_API_STATUS
187 NetpUnbind(
188     handle_t BindingHandle)
189 {
190     RPC_STATUS status;
191 
192     FIXME("NetpUnbind(%p)\n", BindingHandle);
193 
194     status = RpcBindingFree(&hBinding);
195     if (status)
196     {
197         TRACE("RpcBindingFree returned 0x%x\n", status);
198         return NetpNtStatusToApiStatus(status);
199     }
200 
201     return NERR_Success;
202 }
203 
204 
205 NET_API_STATUS
206 WINAPI
207 NetAddAlternateComputerName(
208     _In_opt_ LPCWSTR Server,
209     _In_ LPCWSTR AlternateName,
210     _In_opt_ LPCWSTR DomainAccount,
211     _In_opt_ LPCWSTR DomainAccountPassword,
212     _In_ ULONG Reserved)
213 {
214     PJOINPR_ENCRYPTED_USER_PASSWORD EncryptedPassword = NULL;
215     handle_t BindingHandle = NULL;
216     NET_API_STATUS status;
217 
218     TRACE("NetAddAlternateComputerName(%s %s %s %s 0x%lx)\n",
219           debugstr_w(Server), debugstr_w(AlternateName), debugstr_w(DomainAccount),
220           debugstr_w(DomainAccountPassword), Reserved);
221 
222     /* FIXME */
223 
224     status = NetpBind(Server,
225                       &BindingHandle);
226     if (status != NERR_Success)
227     {
228         ERR("NetpBind() failed (status 0x%lx)\n", status);
229         return status;
230     }
231 
232     RpcTryExcept
233     {
234         status = NetrAddAlternateComputerName(BindingHandle,
235                                               (PWSTR)Server,
236                                               (PWSTR)AlternateName,
237                                               (PWSTR)DomainAccount,
238                                               EncryptedPassword,
239                                               Reserved);
240     }
241     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
242     {
243         status = I_RpcMapWin32Status(RpcExceptionCode());
244     }
245     RpcEndExcept;
246 
247     NetpUnbind(BindingHandle);
248 
249     return status;
250 }
251 
252 
253 NET_API_STATUS
254 WINAPI
255 NetEnumerateComputerNames(
256     _In_opt_ LPCWSTR Server,
257     _In_ NET_COMPUTER_NAME_TYPE NameType,
258     _In_ ULONG Reserved,
259     _Out_ PDWORD EntryCount,
260     _Out_ LPWSTR **ComputerNames)
261 {
262     PNET_COMPUTER_NAME_ARRAY ComputerNameArray = NULL;
263     ULONG BufferSize, i;
264     PWSTR *NameBuffer = NULL, Ptr;
265     NET_API_STATUS status;
266 
267     TRACE("NetEnumerateComputerNames(%s %lu %lu %p %p)\n",
268           debugstr_w(Server), NameType, Reserved, EntryCount, ComputerNames);
269 
270     RpcTryExcept
271     {
272         status = NetrEnumerateComputerNames((PWSTR)Server,
273                                             NameType,
274                                             Reserved,
275                                             &ComputerNameArray);
276         if (status == NERR_Success)
277         {
278             *EntryCount = ComputerNameArray->EntryCount;
279 
280             BufferSize = 0;
281             for (i = 0; i < ComputerNameArray->EntryCount; i++)
282             {
283                 BufferSize += ComputerNameArray->ComputerNames[i].Length + sizeof(WCHAR) + sizeof(PWSTR);
284             }
285 
286             status = NetApiBufferAllocate(BufferSize, (PVOID*)&NameBuffer);
287             if (status == NERR_Success)
288             {
289                 ZeroMemory(NameBuffer, BufferSize);
290 
291                 Ptr = (PWSTR)((ULONG_PTR)NameBuffer + ComputerNameArray->EntryCount * sizeof(PWSTR));
292                 for (i = 0; i < ComputerNameArray->EntryCount; i++)
293                 {
294                     NameBuffer[i] = Ptr;
295                     CopyMemory(Ptr,
296                                ComputerNameArray->ComputerNames[i].Buffer,
297                                ComputerNameArray->ComputerNames[i].Length);
298                     Ptr = (PWSTR)((ULONG_PTR)Ptr + ComputerNameArray->ComputerNames[i].Length + sizeof(WCHAR));
299                 }
300 
301                 *ComputerNames = NameBuffer;
302             }
303         }
304     }
305     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
306     {
307         status = I_RpcMapWin32Status(RpcExceptionCode());
308     }
309     RpcEndExcept;
310 
311     return status;
312 }
313 
314 
315 NET_API_STATUS
316 WINAPI
317 NetGetJoinInformation(
318     _In_ LPCWSTR lpServer,
319     _Out_ LPWSTR *lpNameBuffer,
320     _Out_ PNETSETUP_JOIN_STATUS BufferType)
321 {
322     NET_API_STATUS status;
323 
324     TRACE("NetGetJoinInformation(%s %p %p)\n",
325           debugstr_w(lpServer), lpNameBuffer, BufferType);
326 
327     if (lpNameBuffer == NULL || BufferType == NULL)
328         return ERROR_INVALID_PARAMETER;
329 
330     RpcTryExcept
331     {
332         status = NetrGetJoinInformation((LPWSTR)lpServer,
333                                         lpNameBuffer,
334                                         BufferType);
335     }
336     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
337     {
338         status = I_RpcMapWin32Status(RpcExceptionCode());
339     }
340     RpcEndExcept;
341 
342     return status;
343 }
344 
345 
346 NET_API_STATUS
347 WINAPI
348 NetGetJoinableOUs(
349     _In_opt_ LPCWSTR lpServer,
350     _In_ LPCWSTR lpDomain,
351     _In_opt_ LPCWSTR lpAccount,
352     _In_opt_ LPCWSTR lpPassword,
353     _Out_ DWORD *OUCount,
354     _Out_ LPWSTR **OUs)
355 {
356     PJOINPR_ENCRYPTED_USER_PASSWORD EncryptedPassword = NULL;
357     handle_t BindingHandle = NULL;
358     NET_API_STATUS status;
359 
360     TRACE("NetGetJoinableOUs(%s %s %s %s %p %p)\n",
361           debugstr_w(lpServer), debugstr_w(lpDomain), debugstr_w(lpAccount),
362           debugstr_w(lpPassword), OUCount, OUs);
363 
364     /* FIXME */
365 
366     status = NetpBind(lpServer,
367                       &BindingHandle);
368     if (status != NERR_Success)
369     {
370         ERR("NetpBind() failed (status 0x%lx)\n", status);
371         return status;
372     }
373 
374     RpcTryExcept
375     {
376         status = NetrGetJoinableOUs2(BindingHandle,
377                                      (PWSTR)lpServer,
378                                      (PWSTR)lpDomain,
379                                      (PWSTR)lpAccount,
380                                      EncryptedPassword,
381                                      OUCount,
382                                      OUs);
383     }
384     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
385     {
386         status = I_RpcMapWin32Status(RpcExceptionCode());
387     }
388     RpcEndExcept;
389 
390     NetpUnbind(BindingHandle);
391 
392     return status;
393 }
394 
395 
396 NET_API_STATUS
397 WINAPI
398 NetJoinDomain(
399     _In_opt_ LPCWSTR lpServer,
400     _In_ LPCWSTR lpDomain,
401     _In_opt_ LPCWSTR lpAccountOU,
402     _In_opt_ LPCWSTR lpAccount,
403     _In_opt_ LPCWSTR lpPassword,
404     _In_ DWORD fJoinOptions)
405 {
406     PJOINPR_ENCRYPTED_USER_PASSWORD EncryptedPassword = NULL;
407     handle_t BindingHandle = NULL;
408     NET_API_STATUS status;
409 
410     FIXME("NetJoinDomain(%s %s %s %s 0x%lx)\n",
411           debugstr_w(lpServer), debugstr_w(lpDomain), debugstr_w(lpAccountOU),
412           debugstr_w(lpAccount), debugstr_w(lpPassword), fJoinOptions);
413 
414     /* FIXME */
415 
416     status = NetpBind(lpServer,
417                       &BindingHandle);
418     if (status != NERR_Success)
419     {
420         ERR("NetpBind() failed (status 0x%lx)\n", status);
421         return status;
422     }
423 
424     RpcTryExcept
425     {
426         status = NetrJoinDomain2(BindingHandle,
427                                  (PWSTR)lpServer,
428                                  (PWSTR)lpDomain,
429                                  (PWSTR)lpAccountOU,
430                                  (PWSTR)lpAccount,
431                                  EncryptedPassword,
432                                  fJoinOptions);
433     }
434     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
435     {
436         RPC_STATUS rpcStatus = RpcExceptionCode();
437         FIXME("Exception 0x%lx\n", rpcStatus);
438         status = I_RpcMapWin32Status(rpcStatus);
439     }
440     RpcEndExcept;
441 
442     NetpUnbind(BindingHandle);
443 
444     return status;
445 }
446 
447 
448 NET_API_STATUS
449 WINAPI
450 NetRemoveAlternateComputerName(
451     _In_opt_ LPCWSTR Server,
452     _In_ LPCWSTR AlternateName,
453     _In_opt_ LPCWSTR DomainAccount,
454     _In_opt_ LPCWSTR DomainAccountPassword,
455     _In_ ULONG Reserved)
456 {
457     PJOINPR_ENCRYPTED_USER_PASSWORD EncryptedPassword = NULL;
458     handle_t BindingHandle = NULL;
459     NET_API_STATUS status;
460 
461     TRACE("NetRemoveAlternateComputerName(%s %s %s %s 0x%lx)\n",
462           debugstr_w(Server), debugstr_w(AlternateName), debugstr_w(DomainAccount),
463           debugstr_w(DomainAccountPassword), Reserved);
464 
465     /* FIXME */
466 
467     status = NetpBind(Server,
468                       &BindingHandle);
469     if (status != NERR_Success)
470     {
471         ERR("NetpBind() failed (status 0x%lx)\n", status);
472         return status;
473     }
474 
475     RpcTryExcept
476     {
477         status = NetrRemoveAlternateComputerName(BindingHandle,
478                                                  (PWSTR)Server,
479                                                  (PWSTR)AlternateName,
480                                                  (PWSTR)DomainAccount,
481                                                  EncryptedPassword,
482                                                  Reserved);
483     }
484     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
485     {
486         status = I_RpcMapWin32Status(RpcExceptionCode());
487     }
488     RpcEndExcept;
489 
490     NetpUnbind(BindingHandle);
491 
492     return status;
493 }
494 
495 
496 NET_API_STATUS
497 WINAPI
498 NetRenameMachineInDomain(
499     _In_opt_ LPCWSTR lpServer,
500     _In_opt_ LPCWSTR lpNewMachineName,
501     _In_opt_ LPCWSTR lpAccount,
502     _In_opt_ LPCWSTR lpPassword,
503     _In_ DWORD fRenameOptions)
504 {
505     PJOINPR_ENCRYPTED_USER_PASSWORD EncryptedPassword = NULL;
506     handle_t BindingHandle = NULL;
507     NET_API_STATUS status;
508 
509     TRACE("NetRenameMachineInDomain(%s %s %s %s 0x%lx)\n",
510           debugstr_w(lpServer), debugstr_w(lpNewMachineName), debugstr_w(lpAccount),
511           debugstr_w(lpPassword), fRenameOptions);
512 
513     /* FIXME */
514 
515     status = NetpBind(lpServer,
516                       &BindingHandle);
517     if (status != NERR_Success)
518     {
519         ERR("NetpBind() failed (status 0x%lx)\n", status);
520         return status;
521     }
522 
523     RpcTryExcept
524     {
525         status = NetrRenameMachineInDomain2(BindingHandle,
526                                             (PWSTR)lpServer,
527                                             (PWSTR)lpNewMachineName,
528                                             (PWSTR)lpAccount,
529                                             EncryptedPassword,
530                                             fRenameOptions);
531     }
532     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
533     {
534         status = I_RpcMapWin32Status(RpcExceptionCode());
535     }
536     RpcEndExcept;
537 
538     NetpUnbind(BindingHandle);
539 
540     return status;
541 }
542 
543 
544 NET_API_STATUS
545 WINAPI
546 NetSetPrimaryComputerName(
547     _In_opt_ LPCWSTR Server,
548     _In_ LPCWSTR PrimaryName,
549     _In_opt_ LPCWSTR DomainAccount,
550     _In_opt_ LPCWSTR DomainAccountPassword,
551     _In_ ULONG Reserved)
552 {
553     PJOINPR_ENCRYPTED_USER_PASSWORD EncryptedPassword = NULL;
554     handle_t BindingHandle = NULL;
555     NET_API_STATUS status;
556 
557     TRACE("NetSetPrimaryComputerName(%s %s %s %s %lu)\n",
558           debugstr_w(Server), debugstr_w(PrimaryName), debugstr_w(DomainAccount),
559           debugstr_w(DomainAccountPassword), Reserved);
560 
561     /* FIXME */
562 
563     status = NetpBind(Server,
564                       &BindingHandle);
565     if (status != NERR_Success)
566     {
567         ERR("NetpBind() failed (status 0x%lx)\n", status);
568         return status;
569     }
570 
571     RpcTryExcept
572     {
573         status = NetrSetPrimaryComputerName(BindingHandle,
574                                             (PWSTR)Server,
575                                             (PWSTR)PrimaryName,
576                                             (PWSTR)DomainAccount,
577                                             EncryptedPassword,
578                                             Reserved);
579     }
580     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
581     {
582         status = I_RpcMapWin32Status(RpcExceptionCode());
583     }
584     RpcEndExcept;
585 
586     NetpUnbind(BindingHandle);
587 
588     return status;
589 }
590 
591 
592 NET_API_STATUS
593 WINAPI
594 NetUnjoinDomain(
595     _In_opt_ LPCWSTR lpServer,
596     _In_opt_ LPCWSTR lpAccount,
597     _In_opt_ LPCWSTR lpPassword,
598     _In_ DWORD fUnjoinOptions)
599 {
600     PJOINPR_ENCRYPTED_USER_PASSWORD EncryptedPassword = NULL;
601     handle_t BindingHandle = NULL;
602     NET_API_STATUS status;
603 
604     TRACE("NetUnjoinDomain(%s %s %s %s 0x%lx)\n",
605           debugstr_w(lpServer), debugstr_w(lpAccount),
606           debugstr_w(lpPassword), fUnjoinOptions);
607 
608     /* FIXME */
609 
610     status = NetpBind(lpServer,
611                       &BindingHandle);
612     if (status != NERR_Success)
613     {
614         ERR("NetpBind() failed (status 0x%lx)\n", status);
615         return status;
616     }
617 
618     RpcTryExcept
619     {
620         status = NetrUnjoinDomain2(BindingHandle,
621                                    (PWSTR)lpServer,
622                                    (PWSTR)lpAccount,
623                                    EncryptedPassword,
624                                    fUnjoinOptions);
625     }
626     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
627     {
628         status = I_RpcMapWin32Status(RpcExceptionCode());
629     }
630     RpcEndExcept;
631 
632     NetpUnbind(BindingHandle);
633 
634     return status;
635 }
636 
637 
638 NET_API_STATUS
639 WINAPI
640 NetUseAdd(
641     _In_ LMSTR UncServerName,
642     _In_ DWORD Level,
643     _In_ LPBYTE Buf,
644     _Out_ LPDWORD ParmError)
645 {
646     NET_API_STATUS status;
647 
648     TRACE("NetUseAdd(%s %d %p %p)\n", debugstr_w(UncServerName),
649           Level, Buf, ParmError);
650 
651     RpcTryExcept
652     {
653         status = NetrUseAdd(UncServerName,
654                             Level,
655                             (LPUSE_INFO)Buf,
656                             ParmError);
657     }
658     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
659     {
660         status = I_RpcMapWin32Status(RpcExceptionCode());
661     }
662     RpcEndExcept;
663 
664     return status;
665 }
666 
667 
668 NET_API_STATUS
669 WINAPI
670 NetUseDel(
671     _In_ LMSTR UncServerName,
672     _In_ LMSTR UseName,
673     _In_ DWORD ForceCond)
674 {
675     NET_API_STATUS status;
676 
677     TRACE("NetUseDel(%s %s %d)\n", debugstr_w(UncServerName),
678           debugstr_w(UseName), ForceCond);
679 
680     RpcTryExcept
681     {
682         status = NetrUseDel(UncServerName,
683                             UseName,
684                             ForceCond);
685     }
686     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
687     {
688         status = I_RpcMapWin32Status(RpcExceptionCode());
689     }
690     RpcEndExcept;
691 
692     return status;
693 }
694 
695 
696 NET_API_STATUS
697 WINAPI
698 NetUseEnum(
699     _In_ LMSTR UncServerName,
700     _In_ DWORD Level,
701     _Out_ LPBYTE *BufPtr,
702     _In_ DWORD PreferedMaximumSize,
703     _Out_ LPDWORD EntriesRead,
704     _Out_ LPDWORD TotalEntries,
705     _Inout_ LPDWORD ResumeHandle)
706 {
707     USE_ENUM_STRUCT UseEnumInfo;
708     USE_INFO_0_CONTAINER Container0;
709     USE_INFO_1_CONTAINER Container1;
710     USE_INFO_2_CONTAINER Container2;
711     NET_API_STATUS status;
712 
713     TRACE("NetUseEnum(%s, %d, %p, %d, %p, %p, %p)\n", debugstr_w(UncServerName),
714           Level, BufPtr, PreferedMaximumSize, EntriesRead, TotalEntries, ResumeHandle);
715 
716     UseEnumInfo.Level = Level;
717     switch (Level)
718     {
719         case 0:
720             UseEnumInfo.UseInfo.Level0 = &Container0;
721             Container0.EntriesRead = 0;
722             Container0.Buffer = NULL;
723             break;
724 
725         case 1:
726             UseEnumInfo.UseInfo.Level1 = &Container1;
727             Container1.EntriesRead = 0;
728             Container1.Buffer = NULL;
729             break;
730 
731         case 2:
732             UseEnumInfo.UseInfo.Level2 = &Container2;
733             Container2.EntriesRead = 0;
734             Container2.Buffer = NULL;
735             break;
736 
737         default:
738             return ERROR_INVALID_PARAMETER;
739     }
740 
741     RpcTryExcept
742     {
743         status = NetrUseEnum(UncServerName,
744                              &UseEnumInfo,
745                              PreferedMaximumSize,
746                              TotalEntries,
747                              ResumeHandle);
748         if (status == NERR_Success || status == ERROR_MORE_DATA)
749         {
750             switch (Level)
751             {
752                 case 0:
753                     *BufPtr = (LPBYTE)UseEnumInfo.UseInfo.Level0->Buffer;
754                     *EntriesRead = UseEnumInfo.UseInfo.Level0->EntriesRead;
755                     break;
756 
757                 case 1:
758                     *BufPtr = (LPBYTE)UseEnumInfo.UseInfo.Level1->Buffer;
759                     *EntriesRead = UseEnumInfo.UseInfo.Level1->EntriesRead;
760                     break;
761 
762                 case 2:
763                     *BufPtr = (LPBYTE)UseEnumInfo.UseInfo.Level2->Buffer;
764                     *EntriesRead = UseEnumInfo.UseInfo.Level2->EntriesRead;
765                     break;
766             }
767         }
768     }
769     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
770     {
771         status = I_RpcMapWin32Status(RpcExceptionCode());
772     }
773     RpcEndExcept;
774 
775     return status;
776 }
777 
778 
779 NET_API_STATUS
780 WINAPI
781 NetUseGetInfo(
782     _In_ LMSTR UncServerName,
783     _In_ LMSTR UseName,
784     _In_ DWORD Level,
785     _Out_ LPBYTE *BufPtr)
786 {
787     NET_API_STATUS status;
788 
789     TRACE("NetUseGetInfo(%s, %s, %d, %p)\n", debugstr_w(UncServerName),
790           debugstr_w(UseName), Level, BufPtr);
791 
792     *BufPtr = NULL;
793 
794     RpcTryExcept
795     {
796         status = NetrUseGetInfo(UncServerName,
797                                 UseName,
798                                 Level,
799                                 (LPUSE_INFO)BufPtr);
800     }
801     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
802     {
803         status = I_RpcMapWin32Status(RpcExceptionCode());
804     }
805     RpcEndExcept;
806 
807     return status;
808 }
809 
810 
811 NET_API_STATUS
812 WINAPI
813 NetValidateName(
814     _In_opt_ LPCWSTR lpServer,
815     _In_ LPCWSTR lpName,
816     _In_opt_ LPCWSTR lpAccount,
817     _In_opt_ LPCWSTR lpPassword,
818     _In_ NETSETUP_NAME_TYPE NameType)
819 {
820     PJOINPR_ENCRYPTED_USER_PASSWORD EncryptedPassword = NULL;
821     handle_t BindingHandle = NULL;
822     NET_API_STATUS status;
823 
824     TRACE("NetValidateName(%s %s %s %s %u)\n",
825           debugstr_w(lpServer), debugstr_w(lpName), debugstr_w(lpAccount),
826           debugstr_w(lpPassword), NameType);
827 
828     /* FIXME */
829 
830     status = NetpBind(lpServer,
831                       &BindingHandle);
832     if (status != NERR_Success)
833     {
834         ERR("NetpBind() failed (status 0x%lx)\n", status);
835         return status;
836     }
837 
838     RpcTryExcept
839     {
840         status = NetrValidateName2(BindingHandle,
841                                    (PWSTR)lpServer,
842                                    (PWSTR)lpName,
843                                    (PWSTR)lpAccount,
844                                    EncryptedPassword,
845                                    NameType);
846     }
847     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
848     {
849         status = I_RpcMapWin32Status(RpcExceptionCode());
850     }
851     RpcEndExcept;
852 
853     NetpUnbind(BindingHandle);
854 
855     return status;
856 }
857 
858 
859 #if 0
860 NET_API_STATUS
861 WINAPI
862 NetWkstaGetInfo(
863     _In_ LPWSTR servername,
864     _In_ DWORD level,
865     _Out_ LPBYTE *bufptr)
866 {
867     NET_API_STATUS status;
868 
869     TRACE("NetWkstaGetInfo(%s, %d, %p)\n",
870           debugstr_w(servername), level, bufptr);
871 
872     if (bufptr == NULL)
873         return ERROR_INVALID_PARAMETER;
874 
875     *bufptr = NULL;
876 
877     RpcTryExcept
878     {
879         status = NetrWkstaGetInfo(servername,
880                                   level,
881                                   (LPWKSTA_INFO)bufptr);
882     }
883     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
884     {
885         status = I_RpcMapWin32Status(RpcExceptionCode());
886     }
887     RpcEndExcept;
888 
889     return status;
890 }
891 #endif
892 
893 
894 NET_API_STATUS
895 WINAPI
896 NetWkstaSetInfo(
897     _In_ LPWSTR servername,
898     _In_ DWORD level,
899     _In_ LPBYTE buffer,
900     _Out_ LPDWORD parm_err)
901 {
902     NET_API_STATUS status;
903 
904     TRACE("NetWkstaSetInfo(%s, %d, %p, %p)\n",
905           debugstr_w(servername), level, buffer, parm_err);
906 
907     RpcTryExcept
908     {
909         status = NetrWkstaSetInfo(servername,
910                                   level,
911                                   (LPWKSTA_INFO)buffer,
912                                   parm_err);
913     }
914     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
915     {
916         status = I_RpcMapWin32Status(RpcExceptionCode());
917     }
918     RpcEndExcept;
919 
920     return status;
921 }
922 
923 
924 NET_API_STATUS
925 WINAPI
926 NetWkstaTransportAdd(
927     _In_opt_ LPWSTR servername,
928     _In_ DWORD level,
929     _In_ LPBYTE buf,
930     _Out_ LPDWORD parm_err)
931 {
932     NET_API_STATUS status;
933 
934     TRACE("NetWkstaTransportAdd(%s, %d, %p, %p)\n", debugstr_w(servername),
935           level, buf, parm_err);
936 
937     RpcTryExcept
938     {
939         status = NetrWkstaTransportAdd(servername,
940                                        level,
941                                        (LPWKSTA_TRANSPORT_INFO_0)buf,
942                                        parm_err);
943     }
944     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
945     {
946         status = I_RpcMapWin32Status(RpcExceptionCode());
947     }
948     RpcEndExcept;
949 
950     return status;
951 }
952 
953 
954 NET_API_STATUS
955 WINAPI
956 NetWkstaTransportDel(
957     _In_opt_ LPWSTR servername,
958     _In_ LPWSTR transportname,
959     _In_ DWORD ucond)
960 {
961     NET_API_STATUS status;
962 
963     TRACE("NetWkstaTransportDel(%s, %s, %d)\n", debugstr_w(servername),
964           debugstr_w(transportname), ucond);
965 
966     RpcTryExcept
967     {
968         status = NetrWkstaTransportDel(servername,
969                                        transportname,
970                                        ucond);
971     }
972     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
973     {
974         status = I_RpcMapWin32Status(RpcExceptionCode());
975     }
976     RpcEndExcept;
977 
978     return status;
979 }
980 
981 
982 #if 0
983 NET_API_STATUS
984 WINAPI
985 NetWkstaTransportEnum(
986     _In_opt_ LPWSTR servername,
987     _In_ DWORD level,
988     _Out_ LPBYTE *bufptr,
989     _In_ DWORD prefmaxlen,
990     _Out_ LPDWORD entriesread,
991     _Out_ LPDWORD totalentries,
992     _Inout_ LPDWORD resumehandle)
993 {
994     WKSTA_TRANSPORT_ENUM_STRUCT TransportEnumInfo;
995     WKSTA_TRANSPORT_INFO_0_CONTAINER Container0;
996     NET_API_STATUS status;
997 
998     TRACE("NetWkstaTransportEnum(%s, %d, %p, %d, %p, %p, %p)\n", debugstr_w(servername),
999           level, bufptr, prefmaxlen, entriesread, totalentries, resumehandle);
1000 
1001     TransportEnumInfo.Level = level;
1002     switch (level)
1003     {
1004         case 0:
1005             TransportEnumInfo.WkstaTransportInfo.Level0 = &Container0;
1006             Container0.EntriesRead = 0;
1007             Container0.Buffer = NULL;
1008             break;
1009 
1010         default:
1011             return ERROR_INVALID_PARAMETER;
1012     }
1013 
1014     RpcTryExcept
1015     {
1016         status = NetrWkstaTransportEnum(servername,
1017                                         &TransportEnumInfo,
1018                                         prefmaxlen,
1019                                         totalentries,
1020                                         resumehandle);
1021         if (status == NERR_Success || status == ERROR_MORE_DATA)
1022         {
1023             switch (level)
1024             {
1025                 case 0:
1026                     *bufptr = (LPBYTE)TransportEnumInfo.WkstaTransportInfo.Level0->Buffer;
1027                     *entriesread = TransportEnumInfo.WkstaTransportInfo.Level0->EntriesRead;
1028                     break;
1029             }
1030         }
1031     }
1032     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1033     {
1034         status = I_RpcMapWin32Status(RpcExceptionCode());
1035     }
1036     RpcEndExcept;
1037 
1038     return status;
1039 }
1040 
1041 
1042 NET_API_STATUS
1043 WINAPI
1044 NetWkstaUserEnum(
1045     _In_ LPWSTR servername,
1046     _In_ DWORD level,
1047     _Out_ LPBYTE *bufptr,
1048     _In_ DWORD prefmaxlen,
1049     _Out_ LPDWORD entriesread,
1050     _Out_ LPDWORD totalentries,
1051     _Inout_ LPDWORD resumehandle)
1052 {
1053     WKSTA_USER_ENUM_STRUCT UserEnumInfo;
1054     WKSTA_USER_INFO_0_CONTAINER Container0;
1055     WKSTA_USER_INFO_1_CONTAINER Container1;
1056     NET_API_STATUS status;
1057 
1058     TRACE("NetWkstaUserEnum(%s, %d, %p, %d, %p, %p, %p)\n", debugstr_w(servername),
1059           level, bufptr, prefmaxlen, entriesread, totalentries, resumehandle);
1060 
1061     UserEnumInfo.Level = level;
1062     switch (level)
1063     {
1064         case 0:
1065             UserEnumInfo.WkstaUserInfo.Level0 = &Container0;
1066             Container0.EntriesRead = 0;
1067             Container0.Buffer = NULL;
1068             break;
1069 
1070         case 1:
1071             UserEnumInfo.WkstaUserInfo.Level1 = &Container1;
1072             Container1.EntriesRead = 0;
1073             Container1.Buffer = NULL;
1074             break;
1075 
1076         default:
1077             return ERROR_INVALID_PARAMETER;
1078     }
1079 
1080     RpcTryExcept
1081     {
1082         status = NetrWkstaUserEnum(servername,
1083                                    &UserEnumInfo,
1084                                    prefmaxlen,
1085                                    totalentries,
1086                                    resumehandle);
1087         if (status == NERR_Success || status == ERROR_MORE_DATA)
1088         {
1089             switch (level)
1090             {
1091                 case 0:
1092                     *bufptr = (LPBYTE)UserEnumInfo.WkstaUserInfo.Level0->Buffer;
1093                     *entriesread = UserEnumInfo.WkstaUserInfo.Level0->EntriesRead;
1094                     break;
1095 
1096                 case 1:
1097                     *bufptr = (LPBYTE)UserEnumInfo.WkstaUserInfo.Level1->Buffer;
1098                     *entriesread = UserEnumInfo.WkstaUserInfo.Level1->EntriesRead;
1099                     break;
1100             }
1101         }
1102     }
1103     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1104     {
1105         status = I_RpcMapWin32Status(RpcExceptionCode());
1106     }
1107     RpcEndExcept;
1108 
1109     return status;
1110 }
1111 
1112 
1113 NET_API_STATUS
1114 WINAPI
1115 NetWkstaUserGetInfo(
1116     LPWSTR reserved,
1117     _In_ DWORD level,
1118     _Out_ PBYTE *bufptr)
1119 {
1120     NET_API_STATUS status;
1121 
1122     TRACE("NetWkstaUserGetInfo(%s, %d, %p)\n",
1123           debugstr_w(reserved), level, bufptr);
1124 
1125     if (reserved != NULL)
1126         return ERROR_INVALID_PARAMETER;
1127 
1128     *bufptr = NULL;
1129 
1130     RpcTryExcept
1131     {
1132         status = NetrWkstaUserGetInfo(NULL,
1133                                       level,
1134                                       (LPWKSTA_USER_INFO)bufptr);
1135     }
1136     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1137     {
1138         status = I_RpcMapWin32Status(RpcExceptionCode());
1139     }
1140     RpcEndExcept;
1141 
1142     return status;
1143 }
1144 #endif
1145 
1146 
1147 NET_API_STATUS
1148 WINAPI
1149 NetWkstaUserSetInfo(
1150     LPWSTR reserved,
1151     _In_ DWORD level,
1152     _In_ LPBYTE buf,
1153     _Out_ LPDWORD parm_err)
1154 {
1155     NET_API_STATUS status;
1156 
1157     TRACE("NetWkstaSetInfo(%s, %d, %p, %p)\n",
1158           debugstr_w(reserved), level, buf, parm_err);
1159 
1160     if (reserved != NULL)
1161         return ERROR_INVALID_PARAMETER;
1162 
1163     RpcTryExcept
1164     {
1165        status = NetrWkstaUserSetInfo(NULL,
1166                                      level,
1167                                      (LPWKSTA_USER_INFO)&buf,
1168                                      parm_err);
1169     }
1170     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1171     {
1172         status = I_RpcMapWin32Status(RpcExceptionCode());
1173     }
1174     RpcEndExcept;
1175 
1176     return status;
1177 }
1178 
1179 /* EOF */
1180