mountmgr.sys: Implemented the IOCTL_MOUNTMGR_QUERY_POINTS request.
[wine] / dlls / secur32 / secur32.c
1 /* Copyright (C) 2004 Juan Lang
2  *
3  * This file implements loading of SSP DLLs.
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation; either
8  * version 2.1 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public
16  * License along with this library; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
18  */
19 #include <assert.h>
20 #include <stdarg.h>
21
22 #include "ntstatus.h"
23 #define WIN32_NO_STATUS
24 #include "windef.h"
25 #include "winbase.h"
26 #include "winnls.h"
27 #include "winreg.h"
28 #include "winternl.h"
29 #include "shlwapi.h"
30 #include "sspi.h"
31 #include "secur32_priv.h"
32 #include "secext.h"
33 #include "ntsecapi.h"
34 #include "thunks.h"
35
36 #include "wine/list.h"
37 #include "wine/debug.h"
38
39 WINE_DEFAULT_DEBUG_CHANNEL(secur32);
40
41 /**
42  *  Type definitions
43  */
44
45 typedef struct _SecurePackageTable
46 {
47     DWORD numPackages;
48     DWORD numAllocated;
49     struct list table;
50 } SecurePackageTable;
51
52 typedef struct _SecureProviderTable
53 {
54     DWORD numProviders;
55     DWORD numAllocated;
56     struct list table;
57 } SecureProviderTable;
58
59 /**
60  *  Prototypes
61  */
62
63 /* Tries to load moduleName as a provider.  If successful, enumerates what
64  * packages it can and adds them to the package and provider tables.  Resizes
65  * tables as necessary.
66  */
67 static void _tryLoadProvider(PWSTR moduleName);
68
69 /* Initialization: read securityproviders value and attempt to open each dll
70  * there.  For each DLL, call _tryLoadProvider to see if it's really an SSP.
71  * Two undocumented functions, AddSecurityPackage(A/W) and
72  * DeleteSecurityPackage(A/W), seem suspiciously like they'd register or
73  * unregister a dll, but I'm not sure.
74  */
75 static void SECUR32_initializeProviders(void);
76
77 /* Frees all loaded packages and providers */
78 static void SECUR32_freeProviders(void);
79
80 /**
81  *  Globals
82  */
83
84 static CRITICAL_SECTION cs;
85 static SecurePackageTable *packageTable = NULL;
86 static SecureProviderTable *providerTable = NULL;
87
88 static SecurityFunctionTableA securityFunctionTableA = {
89     SECURITY_SUPPORT_PROVIDER_INTERFACE_VERSION,
90     EnumerateSecurityPackagesA,
91     QueryCredentialsAttributesA,
92     AcquireCredentialsHandleA,
93     FreeCredentialsHandle,
94     NULL, /* Reserved2 */
95     InitializeSecurityContextA,
96     AcceptSecurityContext,
97     CompleteAuthToken,
98     DeleteSecurityContext,
99     ApplyControlToken,
100     QueryContextAttributesA,
101     ImpersonateSecurityContext,
102     RevertSecurityContext,
103     MakeSignature,
104     VerifySignature,
105     FreeContextBuffer,
106     QuerySecurityPackageInfoA,
107     NULL, /* Reserved3 */
108     NULL, /* Reserved4 */
109     ExportSecurityContext,
110     ImportSecurityContextA,
111     AddCredentialsA,
112     NULL, /* Reserved8 */
113     QuerySecurityContextToken,
114     EncryptMessage,
115     DecryptMessage,
116     SetContextAttributesA
117 };
118
119 static SecurityFunctionTableW securityFunctionTableW = {
120     SECURITY_SUPPORT_PROVIDER_INTERFACE_VERSION,
121     EnumerateSecurityPackagesW,
122     QueryCredentialsAttributesW,
123     AcquireCredentialsHandleW,
124     FreeCredentialsHandle,
125     NULL, /* Reserved2 */
126     InitializeSecurityContextW,
127     AcceptSecurityContext,
128     CompleteAuthToken,
129     DeleteSecurityContext,
130     ApplyControlToken,
131     QueryContextAttributesW,
132     ImpersonateSecurityContext,
133     RevertSecurityContext,
134     MakeSignature,
135     VerifySignature,
136     FreeContextBuffer,
137     QuerySecurityPackageInfoW,
138     NULL, /* Reserved3 */
139     NULL, /* Reserved4 */
140     ExportSecurityContext,
141     ImportSecurityContextW,
142     AddCredentialsW,
143     NULL, /* Reserved8 */
144     QuerySecurityContextToken,
145     EncryptMessage,
146     DecryptMessage,
147     SetContextAttributesW
148 };
149
150 /***********************************************************************
151  *              InitSecurityInterfaceA (SECUR32.@)
152  */
153 PSecurityFunctionTableA WINAPI InitSecurityInterfaceA(void)
154 {
155     return &securityFunctionTableA;
156 }
157
158 /***********************************************************************
159  *              InitSecurityInterfaceW (SECUR32.@)
160  */
161 PSecurityFunctionTableW WINAPI InitSecurityInterfaceW(void)
162 {
163     return &securityFunctionTableW;
164 }
165
166 PWSTR SECUR32_strdupW(PCWSTR str)
167 {
168     PWSTR ret;
169
170     if (str)
171     {
172         ret = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(str) + 1) * sizeof(WCHAR));
173         if (ret)
174             lstrcpyW(ret, str);
175     }
176     else
177         ret = NULL;
178     return ret;
179 }
180
181 PWSTR SECUR32_AllocWideFromMultiByte(PCSTR str)
182 {
183     PWSTR ret;
184
185     if (str)
186     {
187         int charsNeeded = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
188
189         if (charsNeeded)
190         {
191             ret = HeapAlloc(GetProcessHeap(), 0, charsNeeded * sizeof(WCHAR));
192             if (ret)
193                 MultiByteToWideChar(CP_ACP, 0, str, -1, ret, charsNeeded);
194         }
195         else
196             ret = NULL;
197     }
198     else
199         ret = NULL;
200     return ret;
201 }
202
203 PSTR SECUR32_AllocMultiByteFromWide(PCWSTR str)
204 {
205     PSTR ret;
206
207     if (str)
208     {
209         int charsNeeded = WideCharToMultiByte(CP_ACP, 0, str, -1, NULL, 0,
210          NULL, NULL);
211
212         if (charsNeeded)
213         {
214             ret = HeapAlloc(GetProcessHeap(), 0, charsNeeded);
215             if (ret)
216                 WideCharToMultiByte(CP_ACP, 0, str, -1, ret, charsNeeded,
217                  NULL, NULL);
218         }
219         else
220             ret = NULL;
221     }
222     else
223         ret = NULL;
224     return ret;
225 }
226
227 static void _makeFnTableA(PSecurityFunctionTableA fnTableA,
228  const SecurityFunctionTableA *inFnTableA,
229  const SecurityFunctionTableW *inFnTableW)
230 {
231     if (fnTableA)
232     {
233         if (inFnTableA)
234         {
235             /* The size of the version 1 table is based on platform sdk's
236              * sspi.h, though the sample ssp also provided with platform sdk
237              * implies only functions through QuerySecurityPackageInfoA are
238              * implemented (yikes)
239              */
240             size_t tableSize = inFnTableA->dwVersion == 1 ?
241              (const BYTE *)&inFnTableA->SetContextAttributesA -
242              (const BYTE *)inFnTableA : sizeof(SecurityFunctionTableA);
243
244             memcpy(fnTableA, inFnTableA, tableSize);
245             /* override this, since we can do it internally anyway */
246             fnTableA->QuerySecurityPackageInfoA =
247              QuerySecurityPackageInfoA;
248         }
249         else if (inFnTableW)
250         {
251             /* functions with thunks */
252             if (inFnTableW->AcquireCredentialsHandleW)
253                 fnTableA->AcquireCredentialsHandleA =
254                  thunk_AcquireCredentialsHandleA;
255             if (inFnTableW->InitializeSecurityContextW)
256                 fnTableA->InitializeSecurityContextA =
257                  thunk_InitializeSecurityContextA;
258             if (inFnTableW->ImportSecurityContextW)
259                 fnTableA->ImportSecurityContextA =
260                  thunk_ImportSecurityContextA;
261             if (inFnTableW->AddCredentialsW)
262                 fnTableA->AddCredentialsA =
263                  thunk_AddCredentialsA;
264             if (inFnTableW->QueryCredentialsAttributesW)
265                 fnTableA->QueryCredentialsAttributesA =
266                  thunk_QueryCredentialsAttributesA;
267             if (inFnTableW->QueryContextAttributesW)
268                 fnTableA->QueryContextAttributesA =
269                  thunk_QueryContextAttributesA;
270             if (inFnTableW->SetContextAttributesW)
271                 fnTableA->SetContextAttributesA =
272                  thunk_SetContextAttributesA;
273             /* this can't be thunked, there's no extra param to know which
274              * package to forward to */
275             fnTableA->EnumerateSecurityPackagesA = NULL;
276             /* functions with no thunks needed */
277             fnTableA->AcceptSecurityContext = inFnTableW->AcceptSecurityContext;
278             fnTableA->CompleteAuthToken = inFnTableW->CompleteAuthToken;
279             fnTableA->DeleteSecurityContext = inFnTableW->DeleteSecurityContext;
280             fnTableA->ImpersonateSecurityContext =
281              inFnTableW->ImpersonateSecurityContext;
282             fnTableA->RevertSecurityContext = inFnTableW->RevertSecurityContext;
283             fnTableA->MakeSignature = inFnTableW->MakeSignature;
284             fnTableA->VerifySignature = inFnTableW->VerifySignature;
285             fnTableA->FreeContextBuffer = inFnTableW->FreeContextBuffer;
286             fnTableA->QuerySecurityPackageInfoA =
287              QuerySecurityPackageInfoA;
288             fnTableA->ExportSecurityContext =
289              inFnTableW->ExportSecurityContext;
290             fnTableA->QuerySecurityContextToken =
291              inFnTableW->QuerySecurityContextToken;
292             fnTableA->EncryptMessage = inFnTableW->EncryptMessage;
293             fnTableA->DecryptMessage = inFnTableW->DecryptMessage;
294         }
295     }
296 }
297
298 static void _makeFnTableW(PSecurityFunctionTableW fnTableW,
299  const SecurityFunctionTableA *inFnTableA,
300  const SecurityFunctionTableW *inFnTableW)
301 {
302     if (fnTableW)
303     {
304         if (inFnTableW)
305         {
306             /* The size of the version 1 table is based on platform sdk's
307              * sspi.h, though the sample ssp also provided with platform sdk
308              * implies only functions through QuerySecurityPackageInfoA are
309              * implemented (yikes)
310              */
311             size_t tableSize = inFnTableW->dwVersion == 1 ?
312              (const BYTE *)&inFnTableW->SetContextAttributesW -
313              (const BYTE *)inFnTableW : sizeof(SecurityFunctionTableW);
314
315             memcpy(fnTableW, inFnTableW, tableSize);
316             /* override this, since we can do it internally anyway */
317             fnTableW->QuerySecurityPackageInfoW =
318              QuerySecurityPackageInfoW;
319         }
320         else if (inFnTableA)
321         {
322             /* functions with thunks */
323             if (inFnTableA->AcquireCredentialsHandleA)
324                 fnTableW->AcquireCredentialsHandleW =
325                  thunk_AcquireCredentialsHandleW;
326             if (inFnTableA->InitializeSecurityContextA)
327                 fnTableW->InitializeSecurityContextW =
328                  thunk_InitializeSecurityContextW;
329             if (inFnTableA->ImportSecurityContextA)
330                 fnTableW->ImportSecurityContextW =
331                  thunk_ImportSecurityContextW;
332             if (inFnTableA->AddCredentialsA)
333                 fnTableW->AddCredentialsW =
334                  thunk_AddCredentialsW;
335             if (inFnTableA->QueryCredentialsAttributesA)
336                 fnTableW->QueryCredentialsAttributesW =
337                  thunk_QueryCredentialsAttributesW;
338             if (inFnTableA->QueryContextAttributesA)
339                 fnTableW->QueryContextAttributesW =
340                  thunk_QueryContextAttributesW;
341             if (inFnTableA->SetContextAttributesA)
342                 fnTableW->SetContextAttributesW =
343                  thunk_SetContextAttributesW;
344             /* this can't be thunked, there's no extra param to know which
345              * package to forward to */
346             fnTableW->EnumerateSecurityPackagesW = NULL;
347             /* functions with no thunks needed */
348             fnTableW->AcceptSecurityContext = inFnTableA->AcceptSecurityContext;
349             fnTableW->CompleteAuthToken = inFnTableA->CompleteAuthToken;
350             fnTableW->DeleteSecurityContext = inFnTableA->DeleteSecurityContext;
351             fnTableW->ImpersonateSecurityContext =
352              inFnTableA->ImpersonateSecurityContext;
353             fnTableW->RevertSecurityContext = inFnTableA->RevertSecurityContext;
354             fnTableW->MakeSignature = inFnTableA->MakeSignature;
355             fnTableW->VerifySignature = inFnTableA->VerifySignature;
356             fnTableW->FreeContextBuffer = inFnTableA->FreeContextBuffer;
357             fnTableW->QuerySecurityPackageInfoW =
358              QuerySecurityPackageInfoW;
359             fnTableW->ExportSecurityContext =
360              inFnTableA->ExportSecurityContext;
361             fnTableW->QuerySecurityContextToken =
362              inFnTableA->QuerySecurityContextToken;
363             fnTableW->EncryptMessage = inFnTableA->EncryptMessage;
364             fnTableW->DecryptMessage = inFnTableA->DecryptMessage;
365         }
366     }
367 }
368
369 static void _copyPackageInfo(PSecPkgInfoW info, const SecPkgInfoA *inInfoA,
370  const SecPkgInfoW *inInfoW)
371 {
372     if (info && (inInfoA || inInfoW))
373     {
374         /* odd, I know, but up until Name and Comment the structures are
375          * identical
376          */
377         memcpy(info, inInfoW ? inInfoW : (const SecPkgInfoW *)inInfoA, sizeof(*info));
378         if (inInfoW)
379         {
380             info->Name = SECUR32_strdupW(inInfoW->Name);
381             info->Comment = SECUR32_strdupW(inInfoW->Comment);
382         }
383         else
384         {
385             info->Name = SECUR32_AllocWideFromMultiByte(inInfoA->Name);
386             info->Comment = SECUR32_AllocWideFromMultiByte(inInfoA->Comment);
387         }
388     }
389 }
390
391 SecureProvider *SECUR32_addProvider(const SecurityFunctionTableA *fnTableA,
392  const SecurityFunctionTableW *fnTableW, PCWSTR moduleName)
393 {
394     SecureProvider *ret;
395
396     EnterCriticalSection(&cs);
397
398     if (!providerTable)
399     {
400         providerTable = HeapAlloc(GetProcessHeap(), 0, sizeof(SecureProviderTable));
401         if (!providerTable)
402         {
403             LeaveCriticalSection(&cs);
404             return NULL;
405         }
406
407         list_init(&providerTable->table);
408     }
409
410     ret = HeapAlloc(GetProcessHeap(), 0, sizeof(SecureProvider));
411     if (!ret)
412     {
413         LeaveCriticalSection(&cs);
414         return NULL;
415     }
416
417     list_add_tail(&providerTable->table, &ret->entry);
418     ret->lib = NULL;
419
420     if (fnTableA || fnTableW)
421     {
422         ret->moduleName = NULL;
423         _makeFnTableA(&ret->fnTableA, fnTableA, fnTableW);
424         _makeFnTableW(&ret->fnTableW, fnTableA, fnTableW);
425         ret->loaded = TRUE;
426     }
427     else
428     {
429         ret->moduleName = SECUR32_strdupW(moduleName);
430         ret->loaded = FALSE;
431     }
432     
433     LeaveCriticalSection(&cs);
434     return ret;
435 }
436
437 void SECUR32_addPackages(SecureProvider *provider, ULONG toAdd,
438  const SecPkgInfoA *infoA, const SecPkgInfoW *infoW)
439 {
440     ULONG i;
441
442     assert(provider);
443     assert(infoA || infoW);
444
445     EnterCriticalSection(&cs);
446
447     if (!packageTable)
448     {
449         packageTable = HeapAlloc(GetProcessHeap(), 0, sizeof(SecurePackageTable));
450         if (!packageTable)
451         {
452             LeaveCriticalSection(&cs);
453             return;
454         }
455
456         packageTable->numPackages = 0;
457         list_init(&packageTable->table);
458     }
459         
460     for (i = 0; i < toAdd; i++)
461     {
462         SecurePackage *package = HeapAlloc(GetProcessHeap(), 0, sizeof(SecurePackage));
463         if (!package)
464             continue;
465
466         list_add_tail(&packageTable->table, &package->entry);
467
468         package->provider = provider;
469         _copyPackageInfo(&package->infoW,
470             infoA ? &infoA[i] : NULL,
471             infoW ? &infoW[i] : NULL);
472     }
473     packageTable->numPackages += toAdd;
474
475     LeaveCriticalSection(&cs);
476 }
477
478 static void _tryLoadProvider(PWSTR moduleName)
479 {
480     HMODULE lib = LoadLibraryW(moduleName);
481
482     if (lib)
483     {
484         INIT_SECURITY_INTERFACE_W pInitSecurityInterfaceW =
485          (INIT_SECURITY_INTERFACE_W)GetProcAddress(lib,
486          SECURITY_ENTRYPOINT_ANSIW);
487         INIT_SECURITY_INTERFACE_A pInitSecurityInterfaceA =
488          (INIT_SECURITY_INTERFACE_A)GetProcAddress(lib,
489          SECURITY_ENTRYPOINT_ANSIA);
490
491         TRACE("loaded %s, InitSecurityInterfaceA is %p, InitSecurityInterfaceW is %p\n",
492          debugstr_w(moduleName), pInitSecurityInterfaceA,
493          pInitSecurityInterfaceW);
494         if (pInitSecurityInterfaceW || pInitSecurityInterfaceA)
495         {
496             PSecurityFunctionTableA fnTableA = NULL;
497             PSecurityFunctionTableW fnTableW = NULL;
498             ULONG toAdd = 0;
499             PSecPkgInfoA infoA = NULL;
500             PSecPkgInfoW infoW = NULL;
501             SECURITY_STATUS ret = SEC_E_OK;
502
503             if (pInitSecurityInterfaceA)
504                 fnTableA = pInitSecurityInterfaceA();
505             if (pInitSecurityInterfaceW)
506                 fnTableW = pInitSecurityInterfaceW();
507             if (fnTableW && fnTableW->EnumerateSecurityPackagesW)
508                 ret = fnTableW->EnumerateSecurityPackagesW(&toAdd, &infoW);
509             else if (fnTableA && fnTableA->EnumerateSecurityPackagesA)
510                 ret = fnTableA->EnumerateSecurityPackagesA(&toAdd, &infoA);
511             if (ret == SEC_E_OK && toAdd > 0 && (infoW || infoA))
512             {
513                 SecureProvider *provider = SECUR32_addProvider(NULL, NULL,
514                  moduleName);
515
516                 if (provider)
517                     SECUR32_addPackages(provider, toAdd, infoA, infoW);
518                 if (infoW)
519                     fnTableW->FreeContextBuffer(infoW);
520                 else
521                     fnTableA->FreeContextBuffer(infoA);
522             }
523         }
524         FreeLibrary(lib);
525     }
526     else
527         WARN("failed to load %s\n", debugstr_w(moduleName));
528 }
529
530 static const WCHAR securityProvidersKeyW[] = {
531  'S','Y','S','T','E','M','\\','C','u','r','r','e','n','t','C','o','n','t','r',
532  'o','l','S','e','t','\\','C','o','n','t','r','o','l','\\','S','e','c','u','r',
533  'i','t','y','P','r','o','v','i','d','e','r','s','\0'
534  };
535 static const WCHAR securityProvidersW[] = {
536  'S','e','c','u','r','i','t','y','P','r','o','v','i','d','e','r','s',0
537  };
538  
539 static void SECUR32_initializeProviders(void)
540 {
541     HKEY key;
542     long apiRet;
543
544     TRACE("\n");
545     InitializeCriticalSection(&cs);
546     cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": cs");
547     /* First load built-in providers */
548     SECUR32_initSchannelSP();
549     /* Do not load Negotiate yet. This breaks for some user on the wine-users
550      * mailing list as of 2006-09-12. Without Negotiate, applications should
551      * fall back to NTLM and that should work.*/
552 #if 0
553     SECUR32_initNegotiateSP();
554 #endif
555     SECUR32_initNTLMSP();
556     /* Now load providers from registry */
557     apiRet = RegOpenKeyExW(HKEY_LOCAL_MACHINE, securityProvidersKeyW, 0,
558      KEY_READ, &key);
559     if (apiRet == ERROR_SUCCESS)
560     {
561         WCHAR securityPkgNames[MAX_PATH]; /* arbitrary len */
562         DWORD size = sizeof(securityPkgNames) / sizeof(WCHAR), type;
563
564         apiRet = RegQueryValueExW(key, securityProvidersW, NULL, &type,
565          (PBYTE)securityPkgNames, &size);
566         if (apiRet == ERROR_SUCCESS && type == REG_SZ)
567         {
568             WCHAR *ptr;
569
570             size = size / sizeof(WCHAR);
571             for (ptr = securityPkgNames;
572               ptr < securityPkgNames + size; )
573             {
574                 WCHAR *comma;
575
576                 for (comma = ptr; *comma && *comma != ','; comma++)
577                     ;
578                 if (*comma == ',')
579                     *comma = '\0';
580                 for (; *ptr && isspace(*ptr) && ptr < securityPkgNames + size;
581                  ptr++)
582                     ;
583                 if (*ptr)
584                     _tryLoadProvider(ptr);
585                 ptr += lstrlenW(ptr) + 1;
586             }
587         }
588         RegCloseKey(key);
589     }
590 }
591
592 SecurePackage *SECUR32_findPackageW(PCWSTR packageName)
593 {
594     SecurePackage *ret = NULL;
595     BOOL matched = FALSE;
596
597     if (packageTable && packageName)
598     {
599         LIST_FOR_EACH_ENTRY(ret, &packageTable->table, SecurePackage, entry)
600         {
601             matched = !lstrcmpiW(ret->infoW.Name, packageName);
602             if (matched)
603                 break;
604         }
605         
606         if (!matched)
607                 return NULL;
608
609         if (ret->provider && !ret->provider->loaded)
610         {
611             ret->provider->lib = LoadLibraryW(ret->provider->moduleName);
612             if (ret->provider->lib)
613             {
614                 INIT_SECURITY_INTERFACE_W pInitSecurityInterfaceW =
615                  (INIT_SECURITY_INTERFACE_W)GetProcAddress(ret->provider->lib,
616                  SECURITY_ENTRYPOINT_ANSIW);
617                 INIT_SECURITY_INTERFACE_A pInitSecurityInterfaceA =
618                  (INIT_SECURITY_INTERFACE_A)GetProcAddress(ret->provider->lib,
619                  SECURITY_ENTRYPOINT_ANSIA);
620                 PSecurityFunctionTableA fnTableA = NULL;
621                 PSecurityFunctionTableW fnTableW = NULL;
622
623                 if (pInitSecurityInterfaceA)
624                     fnTableA = pInitSecurityInterfaceA();
625                 if (pInitSecurityInterfaceW)
626                     fnTableW = pInitSecurityInterfaceW();
627                 _makeFnTableA(&ret->provider->fnTableA, fnTableA, fnTableW);
628                 _makeFnTableW(&ret->provider->fnTableW, fnTableA, fnTableW);
629                 ret->provider->loaded = TRUE;
630             }
631             else
632                 ret = NULL;
633         }
634     }
635     return ret;
636 }
637
638 SecurePackage *SECUR32_findPackageA(PCSTR packageName)
639 {
640     SecurePackage *ret;
641
642     if (packageTable && packageName)
643     {
644         UNICODE_STRING package;
645
646         RtlCreateUnicodeStringFromAsciiz(&package, packageName);
647         ret = SECUR32_findPackageW(package.Buffer);
648         RtlFreeUnicodeString(&package);
649     }
650     else
651         ret = NULL;
652     return ret;
653 }
654
655 static void SECUR32_freeProviders(void)
656 {
657     SecurePackage *package;
658     SecureProvider *provider;
659
660     TRACE("\n");
661     EnterCriticalSection(&cs);
662
663     if (packageTable)
664     {
665         LIST_FOR_EACH_ENTRY(package, &packageTable->table, SecurePackage, entry)
666         {
667             HeapFree(GetProcessHeap(), 0, package->infoW.Name);
668             HeapFree(GetProcessHeap(), 0, package->infoW.Comment);
669         }
670
671         HeapFree(GetProcessHeap(), 0, packageTable);
672         packageTable = NULL;
673     }
674
675     if (providerTable)
676     {
677         LIST_FOR_EACH_ENTRY(provider, &providerTable->table, SecureProvider, entry)
678         {
679             HeapFree(GetProcessHeap(), 0, provider->moduleName);
680             if (provider->lib)
681                 FreeLibrary(provider->lib);
682         }
683
684         HeapFree(GetProcessHeap(), 0, providerTable);
685         providerTable = NULL;
686     }
687
688     LeaveCriticalSection(&cs);
689     cs.DebugInfo->Spare[0] = 0;
690     DeleteCriticalSection(&cs);
691 }
692
693 /***********************************************************************
694  *              FreeContextBuffer (SECUR32.@)
695  *
696  * Doh--if pv was allocated by a crypto package, this may not be correct.
697  * The sample ssp seems to use LocalAlloc/LocalFee, but there doesn't seem to
698  * be any guarantee, nor is there an alloc function in secur32.
699  */
700 SECURITY_STATUS WINAPI FreeContextBuffer(PVOID pv)
701 {
702     HeapFree(GetProcessHeap(), 0, pv);
703
704     return SEC_E_OK;
705 }
706
707 /***********************************************************************
708  *              EnumerateSecurityPackagesW (SECUR32.@)
709  */
710 SECURITY_STATUS WINAPI EnumerateSecurityPackagesW(PULONG pcPackages,
711  PSecPkgInfoW *ppPackageInfo)
712 {
713     SECURITY_STATUS ret = SEC_E_OK;
714
715     TRACE("(%p, %p)\n", pcPackages, ppPackageInfo);
716
717     /* windows just crashes if pcPackages or ppPackageInfo is NULL, so will I */
718     *pcPackages = 0;
719     EnterCriticalSection(&cs);
720     if (packageTable)
721     {
722         SecurePackage *package;
723         size_t bytesNeeded;
724
725         bytesNeeded = packageTable->numPackages * sizeof(SecPkgInfoW);
726         LIST_FOR_EACH_ENTRY(package, &packageTable->table, SecurePackage, entry)
727         {
728             if (package->infoW.Name)
729                 bytesNeeded += (lstrlenW(package->infoW.Name) + 1) * sizeof(WCHAR);
730             if (package->infoW.Comment)
731                 bytesNeeded += (lstrlenW(package->infoW.Comment) + 1) * sizeof(WCHAR);
732         }
733         if (bytesNeeded)
734         {
735             *ppPackageInfo = HeapAlloc(GetProcessHeap(), 0, bytesNeeded);
736             if (*ppPackageInfo)
737             {
738                 ULONG i = 0;
739                 PWSTR nextString;
740
741                 *pcPackages = packageTable->numPackages;
742                 nextString = (PWSTR)((PBYTE)*ppPackageInfo +
743                  packageTable->numPackages * sizeof(SecPkgInfoW));
744                 LIST_FOR_EACH_ENTRY(package, &packageTable->table, SecurePackage, entry)
745                 {
746                     PSecPkgInfoW pkgInfo = *ppPackageInfo + i++;
747
748                     memcpy(pkgInfo, &package->infoW, sizeof(SecPkgInfoW));
749                     if (package->infoW.Name)
750                     {
751                         TRACE("Name[%d] = %s\n", i - 1, debugstr_w(package->infoW.Name));
752                         pkgInfo->Name = nextString;
753                         lstrcpyW(nextString, package->infoW.Name);
754                         nextString += lstrlenW(nextString) + 1;
755                     }
756                     else
757                         pkgInfo->Name = NULL;
758                     if (package->infoW.Comment)
759                     {
760                         TRACE("Comment[%d] = %s\n", i - 1, debugstr_w(package->infoW.Comment));
761                         pkgInfo->Comment = nextString;
762                         lstrcpyW(nextString, package->infoW.Comment);
763                         nextString += lstrlenW(nextString) + 1;
764                     }
765                     else
766                         pkgInfo->Comment = NULL;
767                 }
768             }
769             else
770                 ret = SEC_E_INSUFFICIENT_MEMORY;
771         }
772     }
773     LeaveCriticalSection(&cs);
774     TRACE("<-- 0x%08x\n", ret);
775     return ret;
776 }
777
778 /* Converts info (which is assumed to be an array of cPackages SecPkgInfoW
779  * structures) into an array of SecPkgInfoA structures, which it returns.
780  */
781 static PSecPkgInfoA thunk_PSecPkgInfoWToA(ULONG cPackages,
782  const SecPkgInfoW *info)
783 {
784     PSecPkgInfoA ret;
785
786     if (info)
787     {
788         size_t bytesNeeded = cPackages * sizeof(SecPkgInfoA);
789         ULONG i;
790
791         for (i = 0; i < cPackages; i++)
792         {
793             if (info[i].Name)
794                 bytesNeeded += WideCharToMultiByte(CP_ACP, 0, info[i].Name,
795                  -1, NULL, 0, NULL, NULL);
796             if (info[i].Comment)
797                 bytesNeeded += WideCharToMultiByte(CP_ACP, 0, info[i].Comment,
798                  -1, NULL, 0, NULL, NULL);
799         }
800         ret = HeapAlloc(GetProcessHeap(), 0, bytesNeeded);
801         if (ret)
802         {
803             PSTR nextString;
804
805             nextString = (PSTR)((PBYTE)ret + cPackages * sizeof(SecPkgInfoA));
806             for (i = 0; i < cPackages; i++)
807             {
808                 PSecPkgInfoA pkgInfo = ret + i;
809                 int bytes;
810
811                 memcpy(pkgInfo, &info[i], sizeof(SecPkgInfoA));
812                 if (info[i].Name)
813                 {
814                     pkgInfo->Name = nextString;
815                     /* just repeat back to WideCharToMultiByte how many bytes
816                      * it requires, since we asked it earlier
817                      */
818                     bytes = WideCharToMultiByte(CP_ACP, 0, info[i].Name, -1,
819                      NULL, 0, NULL, NULL);
820                     WideCharToMultiByte(CP_ACP, 0, info[i].Name, -1,
821                      pkgInfo->Name, bytes, NULL, NULL);
822                     nextString += lstrlenA(nextString) + 1;
823                 }
824                 else
825                     pkgInfo->Name = NULL;
826                 if (info[i].Comment)
827                 {
828                     pkgInfo->Comment = nextString;
829                     /* just repeat back to WideCharToMultiByte how many bytes
830                      * it requires, since we asked it earlier
831                      */
832                     bytes = WideCharToMultiByte(CP_ACP, 0, info[i].Comment, -1,
833                      NULL, 0, NULL, NULL);
834                     WideCharToMultiByte(CP_ACP, 0, info[i].Comment, -1,
835                      pkgInfo->Comment, bytes, NULL, NULL);
836                     nextString += lstrlenA(nextString) + 1;
837                 }
838                 else
839                     pkgInfo->Comment = NULL;
840             }
841         }
842     }
843     else
844         ret = NULL;
845     return ret;
846 }
847
848 /***********************************************************************
849  *              EnumerateSecurityPackagesA (SECUR32.@)
850  */
851 SECURITY_STATUS WINAPI EnumerateSecurityPackagesA(PULONG pcPackages,
852  PSecPkgInfoA *ppPackageInfo)
853 {
854     SECURITY_STATUS ret;
855     PSecPkgInfoW info;
856
857     ret = EnumerateSecurityPackagesW(pcPackages, &info);
858     if (ret == SEC_E_OK && *pcPackages && info)
859     {
860         *ppPackageInfo = thunk_PSecPkgInfoWToA(*pcPackages, info);
861         if (*pcPackages && !*ppPackageInfo)
862         {
863             *pcPackages = 0;
864             ret = SEC_E_INSUFFICIENT_MEMORY;
865         }
866         FreeContextBuffer(info);
867     }
868     return ret;
869 }
870
871 /***********************************************************************
872  *              GetComputerObjectNameA (SECUR32.@)
873  *
874  * Get the local computer's name using the format specified.
875  *
876  * PARAMS
877  *  NameFormat   [I] The format for the name.
878  *  lpNameBuffer [O] Pointer to buffer to receive the name.
879  *  nSize        [I/O] Size in characters of buffer.
880  *
881  * RETURNS
882  *  TRUE  If the name was written to lpNameBuffer.
883  *  FALSE If the name couldn't be written.
884  *
885  * NOTES
886  *  If lpNameBuffer is NULL, then the size of the buffer needed to hold the
887  *  name will be returned in *nSize.
888  *
889  *  nSize returns the number of characters written when lpNameBuffer is not
890  *  NULL or the size of the buffer needed to hold the name when the buffer
891  *  is too short or lpNameBuffer is NULL.
892  * 
893  *  It the buffer is too short, ERROR_INSUFFICIENT_BUFFER error will be set.
894  */
895 BOOLEAN WINAPI GetComputerObjectNameA(
896   EXTENDED_NAME_FORMAT NameFormat, LPSTR lpNameBuffer, PULONG nSize)
897 {
898     BOOLEAN rc;
899     LPWSTR bufferW = NULL;
900     ULONG sizeW = *nSize;
901     TRACE("(%d %p %p)\n", NameFormat, lpNameBuffer, nSize);
902     if (lpNameBuffer) {
903         bufferW = HeapAlloc(GetProcessHeap(), 0, sizeW * sizeof(WCHAR));
904         if (bufferW == NULL) {
905             SetLastError(ERROR_NOT_ENOUGH_MEMORY);
906             return FALSE;
907         }
908     }
909     rc = GetComputerObjectNameW(NameFormat, bufferW, &sizeW);
910     if (rc && bufferW) {
911         ULONG len = WideCharToMultiByte(CP_ACP, 0, bufferW, -1, NULL, 0, NULL, NULL);
912         WideCharToMultiByte(CP_ACP, 0, bufferW, -1, lpNameBuffer, *nSize, NULL, NULL);
913         *nSize = len;
914     }
915     else
916         *nSize = sizeW;
917     HeapFree(GetProcessHeap(), 0, bufferW);
918     return rc;
919 }
920
921 /***********************************************************************
922  *              GetComputerObjectNameW (SECUR32.@)
923  */
924 BOOLEAN WINAPI GetComputerObjectNameW(
925   EXTENDED_NAME_FORMAT NameFormat, LPWSTR lpNameBuffer, PULONG nSize)
926 {
927     LSA_HANDLE policyHandle;
928     LSA_OBJECT_ATTRIBUTES objectAttributes;
929     PPOLICY_DNS_DOMAIN_INFO domainInfo;
930     NTSTATUS ntStatus;
931     BOOLEAN status;
932     TRACE("(%d %p %p)\n", NameFormat, lpNameBuffer, nSize);
933
934     if (NameFormat == NameUnknown)
935     {
936         SetLastError(ERROR_INVALID_PARAMETER);
937         return FALSE;
938     }
939
940     ZeroMemory(&objectAttributes, sizeof(objectAttributes));
941     objectAttributes.Length = sizeof(objectAttributes);
942
943     ntStatus = LsaOpenPolicy(NULL, &objectAttributes,
944                              POLICY_VIEW_LOCAL_INFORMATION,
945                              &policyHandle);
946     if (ntStatus != STATUS_SUCCESS)
947     {
948         SetLastError(LsaNtStatusToWinError(ntStatus));
949         WARN("LsaOpenPolicy failed with NT status %u\n", GetLastError());
950         return FALSE;
951     }
952
953     ntStatus = LsaQueryInformationPolicy(policyHandle,
954                                          PolicyDnsDomainInformation,
955                                          (PVOID *)&domainInfo);
956     if (ntStatus != STATUS_SUCCESS)
957     {
958         SetLastError(LsaNtStatusToWinError(ntStatus));
959         WARN("LsaQueryInformationPolicy failed with NT status %u\n",
960              GetLastError());
961         LsaClose(policyHandle);
962         return FALSE;
963     }
964
965     if (domainInfo->Sid)
966     {
967         switch (NameFormat)
968         {
969         case NameSamCompatible:
970             {
971                 WCHAR name[MAX_COMPUTERNAME_LENGTH + 1];
972                 DWORD size = sizeof(name);
973                 if (GetComputerNameW(name, &size))
974                 {
975                     int len = domainInfo->Name.Length + size + 3;
976                     if (lpNameBuffer)
977                     {
978                         if (*nSize < len)
979                         {
980                             *nSize = len;
981                             SetLastError(ERROR_INSUFFICIENT_BUFFER);
982                             status = FALSE;
983                         }
984                         else
985                         {
986                             WCHAR bs[] = { '\\', 0 };
987                             WCHAR ds[] = { '$', 0 };
988                             lstrcpyW(lpNameBuffer, domainInfo->Name.Buffer);
989                             lstrcatW(lpNameBuffer, bs);
990                             lstrcatW(lpNameBuffer, name);
991                             lstrcatW(lpNameBuffer, ds);
992                             status = TRUE;
993                         }
994                     }
995                     else        /* just requesting length required */
996                     {
997                         *nSize = len;
998                         status = TRUE;
999                     }
1000                 }
1001                 else
1002                 {
1003                     SetLastError(ERROR_INTERNAL_ERROR);
1004                     status = FALSE;
1005                 }
1006             }
1007             break;
1008         case NameFullyQualifiedDN:
1009         case NameDisplay:
1010         case NameUniqueId:
1011         case NameCanonical:
1012         case NameUserPrincipal:
1013         case NameCanonicalEx:
1014         case NameServicePrincipal:
1015         case NameDnsDomain:
1016             FIXME("NameFormat %d not implemented\n", NameFormat);
1017             SetLastError(ERROR_CANT_ACCESS_DOMAIN_INFO);
1018             status = FALSE;
1019             break;
1020         default:
1021             SetLastError(ERROR_INVALID_PARAMETER);
1022             status = FALSE;
1023         }
1024     }
1025     else
1026     {
1027         SetLastError(ERROR_CANT_ACCESS_DOMAIN_INFO);
1028         status = FALSE;
1029     }
1030
1031     LsaFreeMemory(domainInfo);
1032     LsaClose(policyHandle);
1033
1034     return status;
1035 }
1036
1037 /***********************************************************************
1038  *              GetUserNameExA (SECUR32.@)
1039  */
1040 BOOLEAN WINAPI GetUserNameExA(
1041   EXTENDED_NAME_FORMAT NameFormat, LPSTR lpNameBuffer, PULONG nSize)
1042 {
1043     FIXME("%d %p %p\n", NameFormat, lpNameBuffer, nSize);
1044     return FALSE;
1045 }
1046
1047 BOOLEAN WINAPI GetUserNameExW(
1048   EXTENDED_NAME_FORMAT NameFormat, LPWSTR lpNameBuffer, PULONG nSize)
1049 {
1050     FIXME("%d %p %p\n", NameFormat, lpNameBuffer, nSize);
1051     return FALSE;
1052 }
1053
1054 BOOLEAN WINAPI TranslateNameA(
1055   LPCSTR lpAccountName, EXTENDED_NAME_FORMAT AccountNameFormat,
1056   EXTENDED_NAME_FORMAT DesiredNameFormat, LPSTR lpTranslatedName,
1057   PULONG nSize)
1058 {
1059     FIXME("%p %d %d %p %p\n", lpAccountName, AccountNameFormat,
1060           DesiredNameFormat, lpTranslatedName, nSize);
1061     return FALSE;
1062 }
1063
1064 BOOLEAN WINAPI TranslateNameW(
1065   LPCWSTR lpAccountName, EXTENDED_NAME_FORMAT AccountNameFormat,
1066   EXTENDED_NAME_FORMAT DesiredNameFormat, LPWSTR lpTranslatedName,
1067   PULONG nSize)
1068 {
1069     FIXME("%p %d %d %p %p\n", lpAccountName, AccountNameFormat,
1070           DesiredNameFormat, lpTranslatedName, nSize);
1071     return FALSE;
1072 }
1073
1074 /***********************************************************************
1075  *              DllMain (SECUR32.0)
1076  */
1077 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
1078 {
1079     if (fdwReason == DLL_PROCESS_ATTACH)
1080     {
1081         DisableThreadLibraryCalls(hinstDLL);
1082         SECUR32_initializeProviders();
1083     }
1084     else if (fdwReason == DLL_PROCESS_DETACH)
1085     {
1086         SECUR32_freeProviders();
1087     }
1088
1089     return TRUE;
1090 }