- Go away STDCALL, time has come for WINAPI and NTAPI
[reactos.git] / reactos / dll / win32 / advapi32 / sec / lsa.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS system libraries
4 * FILE: lib/advapi32/sec/lsa.c
5 * PURPOSE: Local security authority functions
6 * PROGRAMMER: Emanuele Aliberti
7 * UPDATE HISTORY:
8 * 19990322 EA created
9 * 19990515 EA stubs
10 * 20030202 KJK compressed stubs
11 *
12 */
13
14 #include <advapi32.h>
15 #include "wine/debug.h"
16
17 WINE_DEFAULT_DEBUG_CHANNEL(advapi);
18
19
20 handle_t __RPC_USER
21 PLSAPR_SERVER_NAME_bind(PLSAPR_SERVER_NAME pszSystemName)
22 {
23 handle_t hBinding = NULL;
24 LPWSTR pszStringBinding;
25 RPC_STATUS status;
26
27 TRACE("PLSAPR_SERVER_NAME_bind() called\n");
28
29 status = RpcStringBindingComposeW(NULL,
30 L"ncacn_np",
31 pszSystemName,
32 L"\\pipe\\lsarpc",
33 NULL,
34 &pszStringBinding);
35 if (status)
36 {
37 TRACE("RpcStringBindingCompose returned 0x%x\n", status);
38 return NULL;
39 }
40
41 /* Set the binding handle that will be used to bind to the server. */
42 status = RpcBindingFromStringBindingW(pszStringBinding,
43 &hBinding);
44 if (status)
45 {
46 TRACE("RpcBindingFromStringBinding returned 0x%x\n", status);
47 }
48
49 status = RpcStringFreeW(&pszStringBinding);
50 if (status)
51 {
52 TRACE("RpcStringFree returned 0x%x\n", status);
53 }
54
55 return hBinding;
56 }
57
58
59 void __RPC_USER
60 PLSAPR_SERVER_NAME_unbind(PLSAPR_SERVER_NAME pszSystemName,
61 handle_t hBinding)
62 {
63 RPC_STATUS status;
64
65 TRACE("PLSAPR_SERVER_NAME_unbind() called\n");
66
67 status = RpcBindingFree(&hBinding);
68 if (status)
69 {
70 TRACE("RpcBindingFree returned 0x%x\n", status);
71 }
72 }
73
74
75 /*
76 * @implemented
77 */
78 NTSTATUS WINAPI
79 LsaClose(LSA_HANDLE ObjectHandle)
80 {
81 TRACE("LsaClose(0x%p) called\n", ObjectHandle);
82
83 /* This is our fake handle, don't go too much long way */
84 if (ObjectHandle == (LSA_HANDLE)0xcafe)
85 return STATUS_SUCCESS;
86
87 return LsarClose((PLSAPR_HANDLE)&ObjectHandle);
88 }
89
90
91 /*
92 * @implemented
93 */
94 NTSTATUS WINAPI
95 LsaDelete(LSA_HANDLE ObjectHandle)
96 {
97 TRACE("LsaDelete(0x%p) called\n", ObjectHandle);
98
99 return LsarDelete((LSAPR_HANDLE)ObjectHandle);
100 }
101
102
103 /*
104 * @unimplemented
105 */
106 NTSTATUS
107 WINAPI
108 LsaAddAccountRights(
109 LSA_HANDLE PolicyHandle,
110 PSID AccountSid,
111 PLSA_UNICODE_STRING UserRights,
112 ULONG CountOfRights)
113 {
114 FIXME("(%p,%p,%p,0x%08x) stub\n", PolicyHandle, AccountSid, UserRights, CountOfRights);
115 return STATUS_NOT_IMPLEMENTED;
116 }
117
118 /*
119 * @unimplemented
120 */
121 NTSTATUS
122 WINAPI
123 LsaCreateTrustedDomainEx(
124 LSA_HANDLE PolicyHandle,
125 PTRUSTED_DOMAIN_INFORMATION_EX TrustedDomainInformation,
126 PTRUSTED_DOMAIN_AUTH_INFORMATION AuthenticationInformation,
127 ACCESS_MASK DesiredAccess,
128 PLSA_HANDLE TrustedDomainHandle)
129 {
130 FIXME("(%p,%p,%p,0x%08x,%p) stub\n", PolicyHandle, TrustedDomainInformation, AuthenticationInformation,
131 DesiredAccess, TrustedDomainHandle);
132 return STATUS_NOT_IMPLEMENTED;
133 }
134
135 /*
136 * @unimplemented
137 */
138 NTSTATUS
139 WINAPI
140 LsaDeleteTrustedDomain(
141 LSA_HANDLE PolicyHandle,
142 PSID TrustedDomainSid)
143 {
144 FIXME("(%p,%p) stub\n", PolicyHandle, TrustedDomainSid);
145 return STATUS_NOT_IMPLEMENTED;
146 }
147
148 /*
149 * @unimplemented
150 */
151 NTSTATUS
152 WINAPI
153 LsaEnumerateAccountRights(
154 LSA_HANDLE PolicyHandle,
155 PSID AccountSid,
156 PLSA_UNICODE_STRING *UserRights,
157 PULONG CountOfRights)
158 {
159 FIXME("(%p,%p,%p,%p) stub\n", PolicyHandle, AccountSid, UserRights, CountOfRights);
160 return STATUS_NOT_IMPLEMENTED;
161 }
162
163 /*
164 * @unimplemented
165 */
166 NTSTATUS
167 WINAPI
168 LsaEnumerateAccountsWithUserRight(
169 LSA_HANDLE PolicyHandle,
170 OPTIONAL PLSA_UNICODE_STRING UserRights,
171 PVOID *EnumerationBuffer,
172 PULONG CountReturned)
173 {
174 FIXME("(%p,%p,%p,%p) stub\n", PolicyHandle, UserRights, EnumerationBuffer, CountReturned);
175 return STATUS_NOT_IMPLEMENTED;
176 }
177
178 /*
179 * @unimplemented
180 */
181 NTSTATUS
182 WINAPI
183 LsaEnumerateTrustedDomains(
184 LSA_HANDLE PolicyHandle,
185 PLSA_ENUMERATION_HANDLE EnumerationContext,
186 PVOID *Buffer,
187 ULONG PreferedMaximumLength,
188 PULONG CountReturned)
189 {
190 FIXME("(%p,%p,%p,0x%08x,%p) stub\n", PolicyHandle, EnumerationContext,
191 Buffer, PreferedMaximumLength, CountReturned);
192 return STATUS_NOT_IMPLEMENTED;
193 }
194
195 /*
196 * @unimplemented
197 */
198 NTSTATUS
199 WINAPI
200 LsaEnumerateTrustedDomainsEx(
201 LSA_HANDLE PolicyHandle,
202 PLSA_ENUMERATION_HANDLE EnumerationContext,
203 PVOID *Buffer,
204 ULONG PreferedMaximumLength,
205 PULONG CountReturned)
206 {
207 FIXME("(%p,%p,%p,0x%08x,%p) stub\n", PolicyHandle, EnumerationContext, Buffer,
208 PreferedMaximumLength, CountReturned);
209 return STATUS_NOT_IMPLEMENTED;
210 }
211
212 /*
213 * @implemented
214 */
215 NTSTATUS WINAPI
216 LsaFreeMemory(PVOID Buffer)
217 {
218 TRACE("(%p)\n", Buffer);
219 return RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
220 }
221
222 /*
223 * @implemented
224 */
225 NTSTATUS
226 WINAPI
227 LsaLookupNames(
228 LSA_HANDLE PolicyHandle,
229 ULONG Count,
230 PLSA_UNICODE_STRING Names,
231 PLSA_REFERENCED_DOMAIN_LIST *ReferencedDomains,
232 PLSA_TRANSLATED_SID *Sids)
233 {
234 PLSA_TRANSLATED_SID2 Sids2;
235 LSA_TRANSLATED_SID *TranslatedSids;
236 ULONG i;
237 NTSTATUS Status;
238
239 TRACE("(%p,0x%08x,%p,%p,%p)\n", PolicyHandle, Count, Names,
240 ReferencedDomains, Sids);
241
242 /* Call LsaLookupNames2, which supersedes this function */
243 Status = LsaLookupNames2(PolicyHandle, Count, 0, Names, ReferencedDomains, &Sids2);
244 if (!NT_SUCCESS(Status))
245 return Status;
246
247 /* Translate the returned structure */
248 TranslatedSids = RtlAllocateHeap(RtlGetProcessHeap(), 0, Count * sizeof(LSA_TRANSLATED_SID));
249 if (!TranslatedSids)
250 {
251 LsaFreeMemory(Sids2);
252 return SCESTATUS_NOT_ENOUGH_RESOURCE;
253 }
254 RtlZeroMemory(Sids, Count * sizeof(PLSA_TRANSLATED_SID));
255 for (i = 0; i < Count; i++)
256 {
257 TranslatedSids[i].Use = Sids2[i].Use;
258 if (Sids2[i].Use != SidTypeInvalid && Sids2[i].Use != SidTypeUnknown)
259 {
260 TranslatedSids[i].DomainIndex = Sids2[i].DomainIndex;
261 if (Sids2[i].Use != SidTypeDomain)
262 TranslatedSids[i].RelativeId = *GetSidSubAuthority(Sids2[i].Sid, 0);
263 }
264 }
265 LsaFreeMemory(Sids2);
266
267 *Sids = TranslatedSids;
268
269 return Status;
270 }
271
272 /*
273 * @unimplemented
274 */
275 NTSTATUS
276 WINAPI
277 LsaLookupNames2(
278 LSA_HANDLE PolicyHandle,
279 ULONG Flags,
280 ULONG Count,
281 PLSA_UNICODE_STRING Names,
282 PLSA_REFERENCED_DOMAIN_LIST *ReferencedDomains,
283 PLSA_TRANSLATED_SID2 *Sids)
284 {
285 FIXME("(%p,0x%08x,0x%08x,%p,%p,%p) stub\n", PolicyHandle, Flags,
286 Count, Names, ReferencedDomains, Sids);
287 return STATUS_NONE_MAPPED;
288 }
289
290 /*
291 * @unimplemented
292 */
293 NTSTATUS
294 WINAPI
295 LsaLookupSids(
296 LSA_HANDLE PolicyHandle,
297 ULONG Count,
298 PSID *Sids,
299 PLSA_REFERENCED_DOMAIN_LIST *ReferencedDomains,
300 PLSA_TRANSLATED_NAME *Names)
301 {
302 static const UNICODE_STRING UserName = RTL_CONSTANT_STRING(L"Administrator");
303 PLSA_REFERENCED_DOMAIN_LIST LocalDomains;
304 PLSA_TRANSLATED_NAME LocalNames;
305
306 TRACE("(%p,%u,%p,%p,%p) stub\n", PolicyHandle, Count, Sids,
307 ReferencedDomains, Names);
308
309 WARN("LsaLookupSids(): stub. Always returning 'Administrator'\n");
310 if (Count != 1)
311 return STATUS_NONE_MAPPED;
312 LocalDomains = RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(LSA_TRANSLATED_SID));
313 if (!LocalDomains)
314 return SCESTATUS_NOT_ENOUGH_RESOURCE;
315 LocalNames = RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(LSA_TRANSLATED_NAME) + UserName.MaximumLength);
316 if (!LocalNames)
317 {
318 LsaFreeMemory(LocalDomains);
319 return SCESTATUS_NOT_ENOUGH_RESOURCE;
320 }
321 LocalDomains[0].Entries = 0;
322 LocalDomains[0].Domains = NULL;
323 LocalNames[0].Use = SidTypeWellKnownGroup;
324 LocalNames[0].Name.Buffer = (LPWSTR)((ULONG_PTR)(LocalNames) + sizeof(LSA_TRANSLATED_NAME));
325 LocalNames[0].Name.Length = UserName.Length;
326 LocalNames[0].Name.MaximumLength = UserName.MaximumLength;
327 RtlCopyMemory(LocalNames[0].Name.Buffer, UserName.Buffer, UserName.MaximumLength);
328
329 *ReferencedDomains = LocalDomains;
330 *Names = LocalNames;
331 return STATUS_SUCCESS;
332 }
333
334 /******************************************************************************
335 * LsaNtStatusToWinError
336 *
337 * PARAMS
338 * Status [I]
339 *
340 * @implemented
341 */
342 ULONG WINAPI
343 LsaNtStatusToWinError(NTSTATUS Status)
344 {
345 TRACE("(%lx)\n", Status);
346 return RtlNtStatusToDosError(Status);
347 }
348
349 /******************************************************************************
350 * LsaOpenPolicy
351 *
352 * PARAMS
353 * x1 []
354 * x2 []
355 * x3 []
356 * x4 []
357 *
358 * @unimplemented
359 */
360 NTSTATUS
361 WINAPI
362 LsaOpenPolicy(
363 IN PLSA_UNICODE_STRING SystemName,
364 IN PLSA_OBJECT_ATTRIBUTES ObjectAttributes,
365 IN ACCESS_MASK DesiredAccess,
366 IN OUT PLSA_HANDLE PolicyHandle)
367 {
368 TRACE("(%s,%p,0x%08x,%p) stub\n",
369 SystemName?debugstr_w(SystemName->Buffer):"(null)",
370 ObjectAttributes, DesiredAccess, PolicyHandle);
371
372 if(PolicyHandle) *PolicyHandle = (LSA_HANDLE)0xcafe;
373 return STATUS_SUCCESS;
374 }
375
376 /*
377 * @unimplemented
378 */
379 NTSTATUS
380 WINAPI
381 LsaOpenTrustedDomainByName(
382 LSA_HANDLE PolicyHandle,
383 PLSA_UNICODE_STRING TrustedDomainName,
384 ACCESS_MASK DesiredAccess,
385 PLSA_HANDLE TrustedDomainHandle)
386 {
387 FIXME("(%p,%p,0x%08x,%p) stub\n", PolicyHandle, TrustedDomainName, DesiredAccess, TrustedDomainHandle);
388 return STATUS_NOT_IMPLEMENTED;
389 }
390
391 /*
392 * @unimplemented
393 */
394 NTSTATUS
395 WINAPI
396 LsaQueryDomainInformationPolicy(
397 LSA_HANDLE PolicyHandle,
398 POLICY_DOMAIN_INFORMATION_CLASS InformationClass,
399 PVOID *Buffer)
400 {
401 FIXME("(%p,0x%08x,%p)\n", PolicyHandle, InformationClass, Buffer);
402 return STATUS_NOT_IMPLEMENTED;
403 }
404
405 /*
406 * @unimplemented
407 */
408 NTSTATUS
409 WINAPI
410 LsaQueryForestTrustInformation(
411 LSA_HANDLE PolicyHandle,
412 PLSA_UNICODE_STRING TrustedDomainName,
413 PLSA_FOREST_TRUST_INFORMATION * ForestTrustInfo)
414 {
415 FIXME("(%p,%p,%p) stub\n", PolicyHandle, TrustedDomainName, ForestTrustInfo);
416 return STATUS_NOT_IMPLEMENTED;
417 }
418
419 /*
420 * @unimplemented
421 */
422 NTSTATUS WINAPI
423 LsaQueryInformationPolicy(LSA_HANDLE PolicyHandle,
424 POLICY_INFORMATION_CLASS InformationClass,
425 PVOID *Buffer)
426 {
427 TRACE("(%p,0x%08x,%p)\n", PolicyHandle, InformationClass, Buffer);
428
429 if(!Buffer) return STATUS_INVALID_PARAMETER;
430 switch (InformationClass)
431 {
432 case PolicyAuditEventsInformation: /* 2 */
433 {
434 PPOLICY_AUDIT_EVENTS_INFO p = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY,
435 sizeof(POLICY_AUDIT_EVENTS_INFO));
436 p->AuditingMode = FALSE; /* no auditing */
437 *Buffer = p;
438 }
439 break;
440 case PolicyPrimaryDomainInformation: /* 3 */
441 case PolicyAccountDomainInformation: /* 5 */
442 {
443 struct di
444 {
445 POLICY_PRIMARY_DOMAIN_INFO ppdi;
446 SID sid;
447 };
448 SID_IDENTIFIER_AUTHORITY localSidAuthority = {SECURITY_NT_AUTHORITY};
449
450 struct di * xdi = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*xdi));
451 HKEY key;
452 BOOL useDefault = TRUE;
453 LONG ret;
454
455 if ((ret = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
456 "System\\CurrentControlSet\\Services\\VxD\\VNETSUP", 0,
457 KEY_READ, &key)) == ERROR_SUCCESS)
458 {
459 DWORD size = 0;
460 WCHAR wg[] = { 'W','o','r','k','g','r','o','u','p',0 };
461
462 ret = RegQueryValueExW(key, wg, NULL, NULL, NULL, &size);
463 if (ret == ERROR_MORE_DATA || ret == ERROR_SUCCESS)
464 {
465 xdi->ppdi.Name.Buffer = RtlAllocateHeap(RtlGetProcessHeap(),
466 HEAP_ZERO_MEMORY, size);
467 if ((ret = RegQueryValueExW(key, wg, NULL, NULL,
468 (LPBYTE)xdi->ppdi.Name.Buffer, &size)) == ERROR_SUCCESS)
469 {
470 xdi->ppdi.Name.Length = (USHORT)size;
471 useDefault = FALSE;
472 }
473 else
474 {
475 RtlFreeHeap(RtlGetProcessHeap(), 0, xdi->ppdi.Name.Buffer);
476 xdi->ppdi.Name.Buffer = NULL;
477 }
478 }
479 RegCloseKey(key);
480 }
481 if (useDefault)
482 RtlCreateUnicodeStringFromAsciiz(&(xdi->ppdi.Name), "DOMAIN");
483 TRACE("setting domain to \n");
484
485 xdi->ppdi.Sid = &(xdi->sid);
486 xdi->sid.Revision = SID_REVISION;
487 xdi->sid.SubAuthorityCount = 1;
488 xdi->sid.IdentifierAuthority = localSidAuthority;
489 xdi->sid.SubAuthority[0] = SECURITY_LOCAL_SYSTEM_RID;
490 *Buffer = xdi;
491 }
492 break;
493 case PolicyAuditLogInformation:
494 case PolicyPdAccountInformation:
495 case PolicyLsaServerRoleInformation:
496 case PolicyReplicaSourceInformation:
497 case PolicyDefaultQuotaInformation:
498 case PolicyModificationInformation:
499 case PolicyAuditFullSetInformation:
500 case PolicyAuditFullQueryInformation:
501 case PolicyDnsDomainInformation:
502 case PolicyEfsInformation:
503 {
504 FIXME("category not implemented\n");
505 return STATUS_UNSUCCESSFUL;
506 }
507 }
508 return STATUS_SUCCESS;
509 }
510
511 /*
512 * @unimplemented
513 */
514 NTSTATUS
515 WINAPI
516 LsaQueryTrustedDomainInfoByName(
517 LSA_HANDLE PolicyHandle,
518 PLSA_UNICODE_STRING TrustedDomainName,
519 TRUSTED_INFORMATION_CLASS InformationClass,
520 PVOID *Buffer)
521 {
522 FIXME("(%p,%p,%d,%p) stub\n", PolicyHandle, TrustedDomainName, InformationClass, Buffer);
523 return STATUS_NOT_IMPLEMENTED;
524 }
525
526 /*
527 * @unimplemented
528 */
529 NTSTATUS
530 WINAPI
531 LsaQueryTrustedDomainInfo(
532 LSA_HANDLE PolicyHandle,
533 PSID TrustedDomainSid,
534 TRUSTED_INFORMATION_CLASS InformationClass,
535 PVOID *Buffer)
536 {
537 FIXME("(%p,%p,%d,%p) stub\n", PolicyHandle, TrustedDomainSid, InformationClass, Buffer);
538 return STATUS_NOT_IMPLEMENTED;
539 }
540
541 /*
542 * @unimplemented
543 */
544 NTSTATUS
545 WINAPI
546 LsaRemoveAccountRights(
547 LSA_HANDLE PolicyHandle,
548 PSID AccountSid,
549 BOOLEAN AllRights,
550 PLSA_UNICODE_STRING UserRights,
551 ULONG CountOfRights)
552 {
553 FIXME("(%p,%p,%d,%p,0x%08x) stub\n", PolicyHandle, AccountSid, AllRights, UserRights, CountOfRights);
554 return STATUS_NOT_IMPLEMENTED;
555 }
556
557 /*
558 * @unimplemented
559 */
560 NTSTATUS
561 WINAPI
562 LsaRetrievePrivateData(
563 LSA_HANDLE PolicyHandle,
564 PLSA_UNICODE_STRING KeyName,
565 PLSA_UNICODE_STRING *PrivateData)
566 {
567 FIXME("(%p,%p,%p) stub\n", PolicyHandle, KeyName, PrivateData);
568 return STATUS_NOT_IMPLEMENTED;
569 }
570
571 /*
572 * @unimplemented
573 */
574 NTSTATUS
575 WINAPI
576 LsaSetDomainInformationPolicy(
577 LSA_HANDLE PolicyHandle,
578 POLICY_DOMAIN_INFORMATION_CLASS InformationClass,
579 PVOID Buffer)
580 {
581 FIXME("(%p,0x%08x,%p) stub\n", PolicyHandle, InformationClass, Buffer);
582 return STATUS_NOT_IMPLEMENTED;
583 }
584
585 /*
586 * @unimplemented
587 */
588 NTSTATUS
589 WINAPI
590 LsaSetInformationPolicy(
591 LSA_HANDLE PolicyHandle,
592 POLICY_INFORMATION_CLASS InformationClass,
593 PVOID Buffer)
594 {
595 FIXME("(%p,0x%08x,%p) stub\n", PolicyHandle, InformationClass, Buffer);
596 return STATUS_NOT_IMPLEMENTED;
597 }
598
599 /*
600 * @unimplemented
601 */
602 NTSTATUS
603 WINAPI
604 LsaSetForestTrustInformation(
605 LSA_HANDLE PolicyHandle,
606 PLSA_UNICODE_STRING TrustedDomainName,
607 PLSA_FOREST_TRUST_INFORMATION ForestTrustInfo,
608 BOOL CheckOnly,
609 PLSA_FOREST_TRUST_COLLISION_INFORMATION *CollisionInfo)
610 {
611 FIXME("(%p,%p,%p,%d,%p) stub\n", PolicyHandle, TrustedDomainName, ForestTrustInfo, CheckOnly, CollisionInfo);
612 return STATUS_NOT_IMPLEMENTED;
613 }
614
615 /*
616 * @unimplemented
617 */
618 NTSTATUS
619 WINAPI
620 LsaSetTrustedDomainInfoByName(
621 LSA_HANDLE PolicyHandle,
622 PLSA_UNICODE_STRING TrustedDomainName,
623 TRUSTED_INFORMATION_CLASS InformationClass,
624 PVOID Buffer)
625 {
626 FIXME("(%p,%p,%d,%p) stub\n", PolicyHandle, TrustedDomainName, InformationClass, Buffer);
627 return STATUS_NOT_IMPLEMENTED;
628 }
629
630 /*
631 * @unimplemented
632 */
633 NTSTATUS
634 WINAPI
635 LsaSetTrustedDomainInformation(
636 LSA_HANDLE PolicyHandle,
637 PSID TrustedDomainSid,
638 TRUSTED_INFORMATION_CLASS InformationClass,
639 PVOID Buffer)
640 {
641 FIXME("(%p,%p,%d,%p) stub\n", PolicyHandle, TrustedDomainSid, InformationClass, Buffer);
642 return STATUS_NOT_IMPLEMENTED;
643 }
644
645 /*
646 * @unimplemented
647 */
648 NTSTATUS
649 WINAPI
650 LsaStorePrivateData(
651 LSA_HANDLE PolicyHandle,
652 PLSA_UNICODE_STRING KeyName,
653 PLSA_UNICODE_STRING PrivateData)
654 {
655 FIXME("(%p,%p,%p) stub\n", PolicyHandle, KeyName, PrivateData);
656 return STATUS_NOT_IMPLEMENTED;
657 }
658
659 /*
660 * @unimplemented
661 */
662 NTSTATUS
663 WINAPI
664 LsaGetUserName(
665 PUNICODE_STRING *UserName,
666 PUNICODE_STRING *DomainName)
667 {
668 FIXME("(%p,%p) stub\n", UserName, DomainName);
669 return STATUS_NOT_IMPLEMENTED;
670 }
671
672 /*
673 * @unimplemented
674 */
675 NTSTATUS
676 WINAPI
677 LsaQueryInfoTrustedDomain (DWORD Unknonw0,
678 DWORD Unknonw1,
679 DWORD Unknonw2)
680 {
681 FIXME("(%d,%d,%d) stub\n", Unknonw0, Unknonw1, Unknonw2);
682 return STATUS_NOT_IMPLEMENTED;
683 }
684
685
686 /* EOF */