wininet/ftp.c: Remove unneeded check.
[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_2,
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_2,
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 = (PWSTR)SECUR32_ALLOC((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 = (PWSTR)SECUR32_ALLOC(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 = (PSTR)SECUR32_ALLOC(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, const PWSTR 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     /* First load built-in providers */
547     SECUR32_initSchannelSP();
548     /* Do not load Negotiate yet. This breaks for some user on the wine-users
549      * mailing list as of 2006-09-12. Without Negotiate, applications should
550      * fall back to NTLM and that should work.*/
551 #if 0
552     SECUR32_initNegotiateSP();
553 #endif
554     SECUR32_initNTLMSP();
555     /* Now load providers from registry */
556     apiRet = RegOpenKeyExW(HKEY_LOCAL_MACHINE, securityProvidersKeyW, 0,
557      KEY_READ, &key);
558     if (apiRet == ERROR_SUCCESS)
559     {
560         WCHAR securityPkgNames[MAX_PATH]; /* arbitrary len */
561         DWORD size = sizeof(securityPkgNames) / sizeof(WCHAR), type;
562
563         apiRet = RegQueryValueExW(key, securityProvidersW, NULL, &type,
564          (PBYTE)securityPkgNames, &size);
565         if (apiRet == ERROR_SUCCESS && type == REG_SZ)
566         {
567             WCHAR *ptr;
568
569             for (ptr = securityPkgNames;
570              ptr < (PWSTR)((PBYTE)securityPkgNames + size); )
571             {
572                 WCHAR *comma;
573
574                 for (comma = ptr; *comma && *comma != ','; comma++)
575                     ;
576                 if (*comma == ',')
577                     *comma = '\0';
578                 for (; *ptr && isspace(*ptr) && ptr < securityPkgNames + size;
579                  ptr++)
580                     ;
581                 if (*ptr)
582                     _tryLoadProvider(ptr);
583                 ptr += lstrlenW(ptr) + 1;
584             }
585         }
586         RegCloseKey(key);
587     }
588 }
589
590 SecurePackage *SECUR32_findPackageW(PWSTR packageName)
591 {
592     SecurePackage *ret = NULL;
593     BOOL matched = FALSE;
594
595     if (packageTable && packageName)
596     {
597         LIST_FOR_EACH_ENTRY(ret, &packageTable->table, SecurePackage, entry)
598         {
599             matched = !lstrcmpiW(ret->infoW.Name, packageName);
600             if (matched)
601                 break;
602         }
603         
604         if (!matched)
605                 return NULL;
606
607         if (ret->provider && !ret->provider->loaded)
608         {
609             ret->provider->lib = LoadLibraryW(ret->provider->moduleName);
610             if (ret->provider->lib)
611             {
612                 INIT_SECURITY_INTERFACE_W pInitSecurityInterfaceW =
613                  (INIT_SECURITY_INTERFACE_W)GetProcAddress(ret->provider->lib,
614                  SECURITY_ENTRYPOINT_ANSIW);
615                 INIT_SECURITY_INTERFACE_A pInitSecurityInterfaceA =
616                  (INIT_SECURITY_INTERFACE_A)GetProcAddress(ret->provider->lib,
617                  SECURITY_ENTRYPOINT_ANSIA);
618                 PSecurityFunctionTableA fnTableA = NULL;
619                 PSecurityFunctionTableW fnTableW = NULL;
620
621                 if (pInitSecurityInterfaceA)
622                     fnTableA = pInitSecurityInterfaceA();
623                 if (pInitSecurityInterfaceW)
624                     fnTableW = pInitSecurityInterfaceW();
625                 _makeFnTableA(&ret->provider->fnTableA, fnTableA, fnTableW);
626                 _makeFnTableW(&ret->provider->fnTableW, fnTableA, fnTableW);
627                 ret->provider->loaded = TRUE;
628             }
629             else
630                 ret = NULL;
631         }
632     }
633     return ret;
634 }
635
636 SecurePackage *SECUR32_findPackageA(PSTR packageName)
637 {
638     SecurePackage *ret;
639
640     if (packageTable && packageName)
641     {
642         UNICODE_STRING package;
643
644         RtlCreateUnicodeStringFromAsciiz(&package, packageName);
645         ret = SECUR32_findPackageW(package.Buffer);
646         RtlFreeUnicodeString(&package);
647     }
648     else
649         ret = NULL;
650     return ret;
651 }
652
653 static void SECUR32_freeProviders(void)
654 {
655     SecurePackage *package;
656     SecureProvider *provider;
657
658     TRACE("\n");
659     EnterCriticalSection(&cs);
660
661     if (packageTable)
662     {
663         LIST_FOR_EACH_ENTRY(package, &packageTable->table, SecurePackage, entry)
664         {
665             SECUR32_FREE(package->infoW.Name);
666             SECUR32_FREE(package->infoW.Comment);
667         }
668
669         HeapFree(GetProcessHeap(), 0, packageTable);
670         packageTable = NULL;
671     }
672
673     if (providerTable)
674     {
675         LIST_FOR_EACH_ENTRY(provider, &providerTable->table, SecureProvider, entry)
676         {
677             SECUR32_FREE(provider->moduleName);
678             if (provider->lib)
679                 FreeLibrary(provider->lib);
680         }
681
682         HeapFree(GetProcessHeap(), 0, providerTable);
683         providerTable = NULL;
684     }
685
686     LeaveCriticalSection(&cs);
687     DeleteCriticalSection(&cs);
688 }
689
690 /***********************************************************************
691  *              FreeContextBuffer (SECUR32.@)
692  *
693  * Doh--if pv was allocated by a crypto package, this may not be correct.
694  * The sample ssp seems to use LocalAlloc/LocalFee, but there doesn't seem to
695  * be any guarantee, nor is there an alloc function in secur32.
696  */
697 SECURITY_STATUS WINAPI FreeContextBuffer(PVOID pv)
698 {
699     SECUR32_FREE(pv);
700
701     return SEC_E_OK;
702 }
703
704 /***********************************************************************
705  *              EnumerateSecurityPackagesW (SECUR32.@)
706  */
707 SECURITY_STATUS WINAPI EnumerateSecurityPackagesW(PULONG pcPackages,
708  PSecPkgInfoW *ppPackageInfo)
709 {
710     SECURITY_STATUS ret = SEC_E_OK;
711
712     TRACE("(%p, %p)\n", pcPackages, ppPackageInfo);
713
714     /* windows just crashes if pcPackages or ppPackageInfo is NULL, so will I */
715     *pcPackages = 0;
716     EnterCriticalSection(&cs);
717     if (packageTable)
718     {
719         SecurePackage *package;
720         size_t bytesNeeded;
721
722         bytesNeeded = packageTable->numPackages * sizeof(SecPkgInfoW);
723         LIST_FOR_EACH_ENTRY(package, &packageTable->table, SecurePackage, entry)
724         {
725             if (package->infoW.Name)
726                 bytesNeeded += (lstrlenW(package->infoW.Name) + 1) * sizeof(WCHAR);
727             if (package->infoW.Comment)
728                 bytesNeeded += (lstrlenW(package->infoW.Comment) + 1) * sizeof(WCHAR);
729         }
730         if (bytesNeeded)
731         {
732             *ppPackageInfo = (PSecPkgInfoW)SECUR32_ALLOC(bytesNeeded);
733             if (*ppPackageInfo)
734             {
735                 ULONG i = 0;
736                 PWSTR nextString;
737
738                 *pcPackages = packageTable->numPackages;
739                 nextString = (PWSTR)((PBYTE)*ppPackageInfo +
740                  packageTable->numPackages * sizeof(SecPkgInfoW));
741                 LIST_FOR_EACH_ENTRY(package, &packageTable->table, SecurePackage, entry)
742                 {
743                     PSecPkgInfoW pkgInfo = *ppPackageInfo + i++;
744
745                     memcpy(pkgInfo, &package->infoW, sizeof(SecPkgInfoW));
746                     if (package->infoW.Name)
747                     {
748                         TRACE("Name[%d] = %s\n", i - 1, debugstr_w(package->infoW.Name));
749                         pkgInfo->Name = nextString;
750                         lstrcpyW(nextString, package->infoW.Name);
751                         nextString += lstrlenW(nextString) + 1;
752                     }
753                     else
754                         pkgInfo->Name = NULL;
755                     if (package->infoW.Comment)
756                     {
757                         TRACE("Comment[%d] = %s\n", i - 1, debugstr_w(package->infoW.Comment));
758                         pkgInfo->Comment = nextString;
759                         lstrcpyW(nextString, package->infoW.Comment);
760                         nextString += lstrlenW(nextString) + 1;
761                     }
762                     else
763                         pkgInfo->Comment = NULL;
764                 }
765             }
766             else
767                 ret = SEC_E_INSUFFICIENT_MEMORY;
768         }
769     }
770     LeaveCriticalSection(&cs);
771     TRACE("<-- 0x%08x\n", ret);
772     return ret;
773 }
774
775 /* Converts info (which is assumed to be an array of cPackages SecPkgInfoW
776  * structures) into an array of SecPkgInfoA structures, which it returns.
777  */
778 static PSecPkgInfoA thunk_PSecPkgInfoWToA(ULONG cPackages,
779  const PSecPkgInfoW info)
780 {
781     PSecPkgInfoA ret;
782
783     if (info)
784     {
785         size_t bytesNeeded = cPackages * sizeof(SecPkgInfoA);
786         ULONG i;
787
788         for (i = 0; i < cPackages; i++)
789         {
790             if (info[i].Name)
791                 bytesNeeded += WideCharToMultiByte(CP_ACP, 0, info[i].Name,
792                  -1, NULL, 0, NULL, NULL);
793             if (info[i].Comment)
794                 bytesNeeded += WideCharToMultiByte(CP_ACP, 0, info[i].Comment,
795                  -1, NULL, 0, NULL, NULL);
796         }
797         ret = (PSecPkgInfoA)SECUR32_ALLOC(bytesNeeded);
798         if (ret)
799         {
800             PSTR nextString;
801
802             nextString = (PSTR)((PBYTE)ret + cPackages * sizeof(SecPkgInfoA));
803             for (i = 0; i < cPackages; i++)
804             {
805                 PSecPkgInfoA pkgInfo = ret + i;
806                 int bytes;
807
808                 memcpy(pkgInfo, &info[i], sizeof(SecPkgInfoA));
809                 if (info[i].Name)
810                 {
811                     pkgInfo->Name = nextString;
812                     /* just repeat back to WideCharToMultiByte how many bytes
813                      * it requires, since we asked it earlier
814                      */
815                     bytes = WideCharToMultiByte(CP_ACP, 0, info[i].Name, -1,
816                      NULL, 0, NULL, NULL);
817                     WideCharToMultiByte(CP_ACP, 0, info[i].Name, -1,
818                      pkgInfo->Name, bytes, NULL, NULL);
819                     nextString += lstrlenA(nextString) + 1;
820                 }
821                 else
822                     pkgInfo->Name = NULL;
823                 if (info[i].Comment)
824                 {
825                     pkgInfo->Comment = nextString;
826                     /* just repeat back to WideCharToMultiByte how many bytes
827                      * it requires, since we asked it earlier
828                      */
829                     bytes = WideCharToMultiByte(CP_ACP, 0, info[i].Comment, -1,
830                      NULL, 0, NULL, NULL);
831                     WideCharToMultiByte(CP_ACP, 0, info[i].Comment, -1,
832                      pkgInfo->Comment, bytes, NULL, NULL);
833                     nextString += lstrlenA(nextString) + 1;
834                 }
835                 else
836                     pkgInfo->Comment = NULL;
837             }
838         }
839     }
840     else
841         ret = NULL;
842     return ret;
843 }
844
845 /***********************************************************************
846  *              EnumerateSecurityPackagesA (SECUR32.@)
847  */
848 SECURITY_STATUS WINAPI EnumerateSecurityPackagesA(PULONG pcPackages,
849  PSecPkgInfoA *ppPackageInfo)
850 {
851     SECURITY_STATUS ret;
852     PSecPkgInfoW info;
853
854     ret = EnumerateSecurityPackagesW(pcPackages, &info);
855     if (ret == SEC_E_OK && *pcPackages && info)
856     {
857         *ppPackageInfo = thunk_PSecPkgInfoWToA(*pcPackages, info);
858         if (*pcPackages && !*ppPackageInfo)
859         {
860             *pcPackages = 0;
861             ret = SEC_E_INSUFFICIENT_MEMORY;
862         }
863         FreeContextBuffer(info);
864     }
865     return ret;
866 }
867
868 /***********************************************************************
869  *              GetComputerObjectNameA (SECUR32.@)
870  *
871  * Get the local computer's name using the format specified.
872  *
873  * PARAMS
874  *  NameFormat   [I] The format for the name.
875  *  lpNameBuffer [O] Pointer to buffer to receive the name.
876  *  nSize        [I/O] Size in characters of buffer.
877  *
878  * RETURNS
879  *  TRUE  If the name was written to lpNameBuffer.
880  *  FALSE If the name couldn't be written.
881  *
882  * NOTES
883  *  If lpNameBuffer is NULL, then the size of the buffer needed to hold the
884  *  name will be returned in *nSize.
885  *
886  *  nSize returns the number of characters written when lpNameBuffer is not
887  *  NULL or the size of the buffer needed to hold the name when the buffer
888  *  is too short or lpNameBuffer is NULL.
889  * 
890  *  It the buffer is too short, ERROR_INSUFFICIENT_BUFFER error will be set.
891  */
892 BOOLEAN WINAPI GetComputerObjectNameA(
893   EXTENDED_NAME_FORMAT NameFormat, LPSTR lpNameBuffer, PULONG nSize)
894 {
895     BOOLEAN rc;
896     LPWSTR bufferW = NULL;
897     ULONG sizeW = *nSize;
898     TRACE("(%d %p %p)\n", NameFormat, lpNameBuffer, nSize);
899     if (lpNameBuffer) {
900         bufferW = HeapAlloc(GetProcessHeap(), 0, sizeW * sizeof(WCHAR));
901         if (bufferW == NULL) {
902             SetLastError(ERROR_NOT_ENOUGH_MEMORY);
903             return FALSE;
904         }
905     }
906     rc = GetComputerObjectNameW(NameFormat, bufferW, &sizeW);
907     if (rc && bufferW) {
908         ULONG len = WideCharToMultiByte(CP_ACP, 0, bufferW, -1, NULL, 0, NULL, NULL);
909         WideCharToMultiByte(CP_ACP, 0, bufferW, -1, lpNameBuffer, *nSize, NULL, NULL);
910         *nSize = len;
911     }
912     else
913         *nSize = sizeW;
914     HeapFree(GetProcessHeap(), 0, bufferW);
915     return rc;
916 }
917
918 /***********************************************************************
919  *              GetComputerObjectNameW (SECUR32.@)
920  */
921 BOOLEAN WINAPI GetComputerObjectNameW(
922   EXTENDED_NAME_FORMAT NameFormat, LPWSTR lpNameBuffer, PULONG nSize)
923 {
924     LSA_HANDLE policyHandle;
925     LSA_OBJECT_ATTRIBUTES objectAttributes;
926     PPOLICY_DNS_DOMAIN_INFO domainInfo;
927     NTSTATUS ntStatus;
928     BOOLEAN status;
929     TRACE("(%d %p %p)\n", NameFormat, lpNameBuffer, nSize);
930
931     if (NameFormat == NameUnknown)
932     {
933         SetLastError(ERROR_INVALID_PARAMETER);
934         return FALSE;
935     }
936
937     ZeroMemory(&objectAttributes, sizeof(objectAttributes));
938     objectAttributes.Length = sizeof(objectAttributes);
939
940     ntStatus = LsaOpenPolicy(NULL, &objectAttributes,
941                              POLICY_VIEW_LOCAL_INFORMATION,
942                              &policyHandle);
943     if (ntStatus != STATUS_SUCCESS)
944     {
945         SetLastError(LsaNtStatusToWinError(ntStatus));
946         WARN("LsaOpenPolicy failed with NT status %u\n", GetLastError());
947         return FALSE;
948     }
949
950     ntStatus = LsaQueryInformationPolicy(policyHandle,
951                                          PolicyDnsDomainInformation,
952                                          (PVOID *)&domainInfo);
953     if (ntStatus != STATUS_SUCCESS)
954     {
955         SetLastError(LsaNtStatusToWinError(ntStatus));
956         WARN("LsaQueryInformationPolicy failed with NT status %u\n",
957              GetLastError());
958         LsaClose(policyHandle);
959         return FALSE;
960     }
961
962     if (domainInfo->Sid)
963     {
964         switch (NameFormat)
965         {
966         case NameSamCompatible:
967             {
968                 WCHAR name[MAX_COMPUTERNAME_LENGTH + 1];
969                 DWORD size = sizeof(name);
970                 if (GetComputerNameW(name, &size))
971                 {
972                     int len = domainInfo->Name.Length + size + 3;
973                     if (lpNameBuffer)
974                     {
975                         if (*nSize < len)
976                         {
977                             *nSize = len;
978                             SetLastError(ERROR_INSUFFICIENT_BUFFER);
979                             status = FALSE;
980                         }
981                         else
982                         {
983                             WCHAR bs[] = { '\\', 0 };
984                             WCHAR ds[] = { '$', 0 };
985                             lstrcpyW(lpNameBuffer, domainInfo->Name.Buffer);
986                             lstrcatW(lpNameBuffer, bs);
987                             lstrcatW(lpNameBuffer, name);
988                             lstrcatW(lpNameBuffer, ds);
989                             status = TRUE;
990                         }
991                     }
992                     else        /* just requesting length required */
993                     {
994                         *nSize = len;
995                         status = TRUE;
996                     }
997                 }
998                 else
999                 {
1000                     SetLastError(ERROR_INTERNAL_ERROR);
1001                     status = FALSE;
1002                 }
1003             }
1004             break;
1005         case NameFullyQualifiedDN:
1006         case NameDisplay:
1007         case NameUniqueId:
1008         case NameCanonical:
1009         case NameUserPrincipal:
1010         case NameCanonicalEx:
1011         case NameServicePrincipal:
1012         case NameDnsDomain:
1013             FIXME("NameFormat %d not implemented\n", NameFormat);
1014             SetLastError(ERROR_CANT_ACCESS_DOMAIN_INFO);
1015             status = FALSE;
1016             break;
1017         default:
1018             SetLastError(ERROR_INVALID_PARAMETER);
1019             status = FALSE;
1020         }
1021     }
1022     else
1023     {
1024         SetLastError(ERROR_CANT_ACCESS_DOMAIN_INFO);
1025         status = FALSE;
1026     }
1027
1028     LsaFreeMemory(domainInfo);
1029     LsaClose(policyHandle);
1030
1031     return status;
1032 }
1033
1034 /***********************************************************************
1035  *              GetUserNameExA (SECUR32.@)
1036  */
1037 BOOLEAN WINAPI GetUserNameExA(
1038   EXTENDED_NAME_FORMAT NameFormat, LPSTR lpNameBuffer, PULONG nSize)
1039 {
1040     FIXME("%d %p %p\n", NameFormat, lpNameBuffer, nSize);
1041     return FALSE;
1042 }
1043
1044 BOOLEAN WINAPI GetUserNameExW(
1045   EXTENDED_NAME_FORMAT NameFormat, LPWSTR lpNameBuffer, PULONG nSize)
1046 {
1047     FIXME("%d %p %p\n", NameFormat, lpNameBuffer, nSize);
1048     return FALSE;
1049 }
1050
1051 NTSTATUS WINAPI LsaCallAuthenticationPackage(
1052   HANDLE LsaHandle, ULONG AuthenticationPackage, PVOID ProtocolSubmitBuffer,
1053   ULONG SubmitBufferLength, PVOID* ProtocolReturnBuffer, PULONG ReturnBufferLength,
1054   PNTSTATUS ProtocolStatus)
1055 {
1056     FIXME("%p %d %p %d %p %p %p\n", LsaHandle, AuthenticationPackage,
1057           ProtocolSubmitBuffer, SubmitBufferLength, ProtocolReturnBuffer,
1058           ReturnBufferLength, ProtocolStatus);
1059     return 0;
1060 }
1061
1062 NTSTATUS WINAPI LsaConnectUntrusted(PHANDLE LsaHandle)
1063 {
1064     FIXME("%p\n", LsaHandle);
1065     return 0;
1066 }
1067
1068 NTSTATUS WINAPI LsaDeregisterLogonProcess(HANDLE LsaHandle)
1069 {
1070     FIXME("%p\n", LsaHandle);
1071     return 0;
1072 }
1073
1074 BOOLEAN WINAPI TranslateNameA(
1075   LPCSTR lpAccountName, EXTENDED_NAME_FORMAT AccountNameFormat,
1076   EXTENDED_NAME_FORMAT DesiredNameFormat, LPSTR lpTranslatedName,
1077   PULONG nSize)
1078 {
1079     FIXME("%p %d %d %p %p\n", lpAccountName, AccountNameFormat,
1080           DesiredNameFormat, lpTranslatedName, nSize);
1081     return FALSE;
1082 }
1083
1084 BOOLEAN WINAPI TranslateNameW(
1085   LPCWSTR lpAccountName, EXTENDED_NAME_FORMAT AccountNameFormat,
1086   EXTENDED_NAME_FORMAT DesiredNameFormat, LPWSTR lpTranslatedName,
1087   PULONG nSize)
1088 {
1089     FIXME("%p %d %d %p %p\n", lpAccountName, AccountNameFormat,
1090           DesiredNameFormat, lpTranslatedName, nSize);
1091     return FALSE;
1092 }
1093
1094 /***********************************************************************
1095  *              DllMain (SECUR32.0)
1096  */
1097 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
1098 {
1099     if (fdwReason == DLL_PROCESS_ATTACH)
1100     {
1101         DisableThreadLibraryCalls(hinstDLL);
1102         SECUR32_initializeProviders();
1103     }
1104     else if (fdwReason == DLL_PROCESS_DETACH)
1105     {
1106         SECUR32_freeProviders();
1107     }
1108
1109     return TRUE;
1110 }