wined3d: Fix the d3dfmt_p8_init_palette() prototype.
[wine] / dlls / secur32 / wrapper.c
1 /* Copyright (C) 2004 Juan Lang
2  *
3  * Implements secur32 functions that forward to (wrap) an SSP's implementation.
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 <stdarg.h>
20 #include "windef.h"
21 #include "winbase.h"
22 #include "winnls.h"
23 #include "sspi.h"
24 #include "secur32_priv.h"
25
26 #include "wine/debug.h"
27
28 WINE_DEFAULT_DEBUG_CHANNEL(secur32);
29
30 /* Tries to allocate a new SecHandle, into which it stores package (in
31  * phSec->dwUpper) and a copy of realHandle (allocated with SECUR32_ALLOC,
32  * and stored in phSec->dwLower).  SecHandle is equivalent to both a
33  * CredHandle and a CtxtHandle.
34  */
35 static SECURITY_STATUS SECUR32_makeSecHandle(PSecHandle phSec,
36  SecurePackage *package, PSecHandle realHandle)
37 {
38     SECURITY_STATUS ret;
39
40     TRACE("%p %p %p\n", phSec, package, realHandle);
41
42     if (phSec && package && realHandle)
43     {
44         PSecHandle newSec = (PSecHandle)SECUR32_ALLOC(sizeof(SecHandle));
45
46         if (newSec)
47         {
48             memcpy(newSec, realHandle, sizeof(*realHandle));
49             phSec->dwUpper = (ULONG_PTR)package;
50             phSec->dwLower = (ULONG_PTR)newSec;
51             ret = SEC_E_OK;
52         }
53         else
54             ret = SEC_E_INSUFFICIENT_MEMORY;
55     }
56     else
57         ret = SEC_E_INVALID_HANDLE;
58     return ret;
59 }
60
61 /***********************************************************************
62  *              AcquireCredentialsHandleA (SECUR32.@)
63  */
64 SECURITY_STATUS WINAPI AcquireCredentialsHandleA(
65  SEC_CHAR *pszPrincipal, SEC_CHAR *pszPackage, ULONG fCredentialsUse,
66  PLUID pvLogonID, PVOID pAuthData, SEC_GET_KEY_FN pGetKeyFn,
67  PVOID pvGetKeyArgument, PCredHandle phCredential, PTimeStamp ptsExpiry)
68 {
69     SECURITY_STATUS ret;
70
71     TRACE("%s %s %d %p %p %p %p %p %p\n", debugstr_a(pszPrincipal),
72      debugstr_a(pszPackage), fCredentialsUse, pvLogonID, pAuthData, pGetKeyFn,
73      pvGetKeyArgument, phCredential, ptsExpiry);
74     if (pszPackage)
75     {
76         SecurePackage *package = SECUR32_findPackageA(pszPackage);
77
78         if (package && package->provider)
79         {
80             if (package->provider->fnTableA.AcquireCredentialsHandleA)
81             {
82                 CredHandle myCred;
83
84                 ret = package->provider->fnTableA.AcquireCredentialsHandleA(
85                  pszPrincipal, pszPackage, fCredentialsUse, pvLogonID,
86                  pAuthData, pGetKeyFn, pvGetKeyArgument, &myCred,
87                  ptsExpiry);
88                 if (ret == SEC_E_OK)
89                 {
90                     ret = SECUR32_makeSecHandle(phCredential, package, &myCred);
91                     if (ret != SEC_E_OK)
92                         package->provider->fnTableW.FreeCredentialsHandle(
93                          &myCred);
94                 }
95             }
96             else
97                 ret = SEC_E_UNSUPPORTED_FUNCTION;
98         }
99         else
100             ret = SEC_E_SECPKG_NOT_FOUND;
101     }
102     else
103         ret = SEC_E_SECPKG_NOT_FOUND;
104     return ret;
105 }
106
107 /***********************************************************************
108  *              AcquireCredentialsHandleW (SECUR32.@)
109  */
110 SECURITY_STATUS WINAPI AcquireCredentialsHandleW(
111  SEC_WCHAR *pszPrincipal, SEC_WCHAR *pszPackage, ULONG fCredentialsUse,
112  PLUID pvLogonID, PVOID pAuthData, SEC_GET_KEY_FN pGetKeyFn,
113  PVOID pvGetKeyArgument, PCredHandle phCredential, PTimeStamp ptsExpiry)
114 {
115     SECURITY_STATUS ret;
116
117     TRACE("%s %s %d %p %p %p %p %p %p\n", debugstr_w(pszPrincipal),
118      debugstr_w(pszPackage), fCredentialsUse, pvLogonID, pAuthData, pGetKeyFn,
119      pvGetKeyArgument, phCredential, ptsExpiry);
120     if (pszPackage)
121     {
122         SecurePackage *package = SECUR32_findPackageW(pszPackage);
123
124         if (package && package->provider)
125         {
126             if (package->provider->fnTableW.AcquireCredentialsHandleW)
127             {
128                 CredHandle myCred;
129
130                 ret = package->provider->fnTableW.AcquireCredentialsHandleW(
131                  pszPrincipal, pszPackage, fCredentialsUse, pvLogonID,
132                  pAuthData, pGetKeyFn, pvGetKeyArgument, &myCred,
133                  ptsExpiry);
134                 if (ret == SEC_E_OK)
135                 {
136                     ret = SECUR32_makeSecHandle(phCredential, package, &myCred);
137                     if (ret != SEC_E_OK)
138                         package->provider->fnTableW.FreeCredentialsHandle(
139                          &myCred);
140                 }
141             }
142             else
143                 ret = SEC_E_UNSUPPORTED_FUNCTION;
144         }
145         else
146             ret = SEC_E_SECPKG_NOT_FOUND;
147     }
148     else
149         ret = SEC_E_SECPKG_NOT_FOUND;
150     return ret;
151 }
152
153 /***********************************************************************
154  *              FreeCredentialsHandle (SECUR32.@)
155  */
156 SECURITY_STATUS WINAPI FreeCredentialsHandle(
157  PCredHandle phCredential)
158 {
159     SECURITY_STATUS ret;
160
161     TRACE("%p\n", phCredential);
162     if (phCredential)
163     {
164         SecurePackage *package = (SecurePackage *)phCredential->dwUpper;
165         PCredHandle cred = (PCredHandle)phCredential->dwLower;
166
167         if (package && package->provider &&
168          package->provider->fnTableW.FreeCredentialsHandle)
169             ret = package->provider->fnTableW.FreeCredentialsHandle(cred);
170         else
171             ret = SEC_E_INVALID_HANDLE;
172         SECUR32_FREE(cred);
173     }
174     else
175         ret = SEC_E_INVALID_HANDLE;
176     return ret;
177 }
178
179 /***********************************************************************
180  *              QueryCredentialsAttributesA (SECUR32.@)
181  */
182 SECURITY_STATUS WINAPI QueryCredentialsAttributesA(
183  PCredHandle phCredential, ULONG ulAttribute, void *pBuffer)
184 {
185     SECURITY_STATUS ret;
186
187     TRACE("%p %d %p\n", phCredential, ulAttribute, pBuffer);
188     if (phCredential)
189     {
190         SecurePackage *package = (SecurePackage *)phCredential->dwUpper;
191         PCredHandle cred = (PCredHandle)phCredential->dwLower;
192
193         if (package && package->provider)
194         {
195             if (package->provider->fnTableA.QueryCredentialsAttributesA)
196                 ret = package->provider->fnTableA.QueryCredentialsAttributesA(
197                  cred, ulAttribute, pBuffer);
198             else
199                 ret = SEC_E_UNSUPPORTED_FUNCTION;
200         }
201         else
202             ret = SEC_E_INVALID_HANDLE;
203     }
204     else
205         ret = SEC_E_INVALID_HANDLE;
206     return ret;
207 }
208
209 /***********************************************************************
210  *              QueryCredentialsAttributesW (SECUR32.@)
211  */
212 SECURITY_STATUS WINAPI QueryCredentialsAttributesW(
213  PCredHandle phCredential, ULONG ulAttribute, void *pBuffer)
214 {
215     SECURITY_STATUS ret;
216
217     TRACE("%p %d %p\n", phCredential, ulAttribute, pBuffer);
218     if (phCredential)
219     {
220         SecurePackage *package = (SecurePackage *)phCredential->dwUpper;
221         PCredHandle cred = (PCredHandle)phCredential->dwLower;
222
223         if (package && package->provider)
224         {
225             if (package->provider->fnTableW.QueryCredentialsAttributesW)
226                 ret = package->provider->fnTableW.QueryCredentialsAttributesW(
227                  cred, ulAttribute, pBuffer);
228             else
229                 ret = SEC_E_UNSUPPORTED_FUNCTION;
230         }
231         else
232             ret = SEC_E_INVALID_HANDLE;
233     }
234     else
235         ret = SEC_E_INVALID_HANDLE;
236     return ret;
237 }
238
239 /***********************************************************************
240  *              InitializeSecurityContextA (SECUR32.@)
241  */
242 SECURITY_STATUS WINAPI InitializeSecurityContextA(
243  PCredHandle phCredential, PCtxtHandle phContext,
244  SEC_CHAR *pszTargetName, ULONG fContextReq,
245  ULONG Reserved1, ULONG TargetDataRep, PSecBufferDesc pInput,
246  ULONG Reserved2, PCtxtHandle phNewContext, PSecBufferDesc pOutput,
247  ULONG *pfContextAttr, PTimeStamp ptsExpiry)
248 {
249     SECURITY_STATUS ret;
250     SecurePackage *package = NULL;
251     PCredHandle cred = NULL;
252     PCredHandle ctxt = NULL;
253
254     TRACE("%p %p %s %d %d %d %p %d %p %p %p %p\n", phCredential, phContext,
255      debugstr_a(pszTargetName), fContextReq, Reserved1, TargetDataRep, pInput,
256      Reserved1, phNewContext, pOutput, pfContextAttr, ptsExpiry);
257
258     if (phContext)
259     {
260         package = (SecurePackage *)phContext->dwUpper;
261         ctxt = (PCtxtHandle)phContext->dwLower;
262     }
263     if (phCredential)
264     {
265         package = (SecurePackage *)phCredential->dwUpper;
266         cred = (PCredHandle)phCredential->dwLower;
267     }
268
269     if (package && package->provider)
270     {
271         if (package->provider->fnTableA.InitializeSecurityContextA)
272         {
273             CtxtHandle myCtxt;
274
275             if (phContext)
276             {
277                 PCtxtHandle realCtxt = (PCtxtHandle)phContext->dwLower;
278                 myCtxt.dwUpper = realCtxt->dwUpper;
279                 myCtxt.dwLower = realCtxt->dwLower;
280             }
281
282             ret = package->provider->fnTableA.InitializeSecurityContextA(
283                  cred, ctxt, pszTargetName, fContextReq,
284                  Reserved1, TargetDataRep, pInput, Reserved2, phNewContext ? &myCtxt : NULL,
285                  pOutput, pfContextAttr, ptsExpiry);
286             if ((ret == SEC_E_OK || ret == SEC_I_CONTINUE_NEEDED) && phNewContext)
287             {
288                 SECURITY_STATUS ret2;
289                 ret2 = SECUR32_makeSecHandle(phNewContext, package, &myCtxt);
290                 if (ret2 != SEC_E_OK)
291                     package->provider->fnTableA.DeleteSecurityContext(&myCtxt);
292             }
293         }
294         else
295             ret = SEC_E_UNSUPPORTED_FUNCTION;
296     }
297     else
298         ret = SEC_E_INVALID_HANDLE;
299     return ret;
300 }
301
302 /***********************************************************************
303  *              InitializeSecurityContextW (SECUR32.@)
304  */
305 SECURITY_STATUS WINAPI InitializeSecurityContextW(
306  PCredHandle phCredential, PCtxtHandle phContext,
307  SEC_WCHAR *pszTargetName, ULONG fContextReq,
308  ULONG Reserved1, ULONG TargetDataRep, PSecBufferDesc pInput,
309  ULONG Reserved2, PCtxtHandle phNewContext, PSecBufferDesc pOutput,
310  ULONG *pfContextAttr, PTimeStamp ptsExpiry)
311 {
312     SECURITY_STATUS ret;
313     SecurePackage *package = NULL;
314     PCredHandle cred = NULL;
315     PCredHandle ctxt = NULL;
316
317     TRACE("%p %p %s %d %d %d %p %d %p %p %p %p\n", phCredential, phContext,
318      debugstr_w(pszTargetName), fContextReq, Reserved1, TargetDataRep, pInput,
319      Reserved1, phNewContext, pOutput, pfContextAttr, ptsExpiry);
320
321     if (phContext)
322     {
323         package = (SecurePackage *)phContext->dwUpper;
324         ctxt = (PCtxtHandle)phContext->dwLower;
325     }
326     if (phCredential)
327     {
328         package = (SecurePackage *)phCredential->dwUpper;
329         cred = (PCredHandle)phCredential->dwLower;
330     }
331
332     if (package && package->provider)
333     {
334         if (package->provider->fnTableW.InitializeSecurityContextW)
335         {
336             CtxtHandle myCtxt;
337
338             if (phContext)
339             {
340                 PCtxtHandle realCtxt = (PCtxtHandle)phContext->dwLower;
341                 myCtxt.dwUpper = realCtxt->dwUpper;
342                 myCtxt.dwLower = realCtxt->dwLower;
343             }
344
345             ret = package->provider->fnTableW.InitializeSecurityContextW(
346                  cred, ctxt, pszTargetName, fContextReq,
347                  Reserved1, TargetDataRep, pInput, Reserved2, phNewContext ? &myCtxt : NULL,
348                  pOutput, pfContextAttr, ptsExpiry);
349             if ((ret == SEC_E_OK || ret == SEC_I_CONTINUE_NEEDED) && phNewContext)
350             {
351                 SECURITY_STATUS ret2;
352                 ret2 = SECUR32_makeSecHandle(phNewContext, package, &myCtxt);
353                 if (ret2 != SEC_E_OK)
354                     package->provider->fnTableW.DeleteSecurityContext(&myCtxt);
355             }
356         }
357         else
358             ret = SEC_E_UNSUPPORTED_FUNCTION;
359     }
360     else
361         ret = SEC_E_INVALID_HANDLE;
362     return ret;
363 }
364
365 /***********************************************************************
366  *              AcceptSecurityContext (SECUR32.@)
367  */
368 SECURITY_STATUS WINAPI AcceptSecurityContext(
369  PCredHandle phCredential, PCtxtHandle phContext, PSecBufferDesc pInput,
370  ULONG fContextReq, ULONG TargetDataRep, PCtxtHandle phNewContext,
371  PSecBufferDesc pOutput, ULONG *pfContextAttr, PTimeStamp ptsExpiry)
372 {
373     SECURITY_STATUS ret;
374
375     TRACE("%p %p %p %d %d %p %p %p %p\n", phCredential, phContext, pInput,
376      fContextReq, TargetDataRep, phNewContext, pOutput, pfContextAttr,
377      ptsExpiry);
378     if (phCredential)
379     {
380         SecurePackage *package = (SecurePackage *)phCredential->dwUpper;
381         PCredHandle cred = (PCredHandle)phCredential->dwLower;
382
383         if (package && package->provider)
384         {
385             if (package->provider->fnTableW.AcceptSecurityContext)
386             {
387                 CtxtHandle myCtxt;
388
389                 if(phContext)
390                 {
391                     PCtxtHandle realCtxt = (PCtxtHandle)phContext->dwLower;
392                     TRACE("realCtx: %p\n", realCtxt);
393                     myCtxt.dwUpper = realCtxt->dwUpper;
394                     myCtxt.dwLower = realCtxt->dwLower;
395                 }
396                 
397                 ret = package->provider->fnTableW.AcceptSecurityContext(
398                  cred, phContext ? &myCtxt : NULL, pInput, fContextReq,
399                  TargetDataRep, &myCtxt, pOutput, pfContextAttr, ptsExpiry);
400                 if (ret == SEC_E_OK || ret == SEC_I_CONTINUE_NEEDED)
401                 {
402                     SECURITY_STATUS ret2;
403                     ret2 = SECUR32_makeSecHandle(phNewContext, package, &myCtxt);
404                     if (ret2 != SEC_E_OK)
405                         package->provider->fnTableW.DeleteSecurityContext(
406                          &myCtxt);
407                 }
408             }
409             else
410                 ret = SEC_E_UNSUPPORTED_FUNCTION;
411         }
412         else
413             ret = SEC_E_INVALID_HANDLE;
414     }
415     else
416         ret = SEC_E_INVALID_HANDLE;
417     return ret;
418 }
419
420 /***********************************************************************
421  *              CompleteAuthToken (SECUR32.@)
422  */
423 SECURITY_STATUS WINAPI CompleteAuthToken(PCtxtHandle phContext,
424  PSecBufferDesc pToken)
425 {
426     SECURITY_STATUS ret;
427
428     TRACE("%p %p\n", phContext, pToken);
429     if (phContext)
430     {
431         SecurePackage *package = (SecurePackage *)phContext->dwUpper;
432         PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower;
433
434         if (package && package->provider)
435         {
436             if (package->provider->fnTableW.CompleteAuthToken)
437                 ret = package->provider->fnTableW.CompleteAuthToken(ctxt,
438                  pToken);
439             else
440                 ret = SEC_E_UNSUPPORTED_FUNCTION;
441         }
442         else
443             ret = SEC_E_INVALID_HANDLE;
444     }
445     else
446         ret = SEC_E_INVALID_HANDLE;
447     return ret;
448 }
449
450 /***********************************************************************
451  *              DeleteSecurityContext (SECUR32.@)
452  */
453 SECURITY_STATUS WINAPI DeleteSecurityContext(PCtxtHandle phContext)
454 {
455     SECURITY_STATUS ret;
456
457     TRACE("%p\n", phContext);
458     if (phContext)
459     {
460         SecurePackage *package = (SecurePackage *)phContext->dwUpper;
461         PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower;
462
463         if (package && package->provider &&
464          package->provider->fnTableW.DeleteSecurityContext)
465             ret = package->provider->fnTableW.DeleteSecurityContext(ctxt);
466         else
467             ret = SEC_E_INVALID_HANDLE;
468         SECUR32_FREE(ctxt);
469     }
470     else
471         ret = SEC_E_INVALID_HANDLE;
472     return ret;
473 }
474
475 /***********************************************************************
476  *              ApplyControlToken (SECUR32.@)
477  */
478 SECURITY_STATUS WINAPI ApplyControlToken(PCtxtHandle phContext,
479  PSecBufferDesc pInput)
480 {
481     SECURITY_STATUS ret;
482
483     TRACE("%p %p\n", phContext, pInput);
484     if (phContext)
485     {
486         SecurePackage *package = (SecurePackage *)phContext->dwUpper;
487         PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower;
488
489         if (package && package->provider)
490         {
491             if (package->provider->fnTableW.ApplyControlToken)
492                 ret = package->provider->fnTableW.ApplyControlToken(
493                  ctxt, pInput);
494             else
495                 ret = SEC_E_UNSUPPORTED_FUNCTION;
496         }
497         else
498             ret = SEC_E_INVALID_HANDLE;
499     }
500     else
501         ret = SEC_E_INVALID_HANDLE;
502     return ret;
503 }
504
505 /***********************************************************************
506  *              QueryContextAttributesA (SECUR32.@)
507  */
508 SECURITY_STATUS WINAPI QueryContextAttributesA(PCtxtHandle phContext,
509  ULONG ulAttribute, void *pBuffer)
510 {
511     SECURITY_STATUS ret;
512
513     TRACE("%p %d %p\n", phContext, ulAttribute, pBuffer);
514     if (phContext)
515     {
516         SecurePackage *package = (SecurePackage *)phContext->dwUpper;
517         PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower;
518
519         if (package && package->provider)
520         {
521             if (package->provider->fnTableA.QueryContextAttributesA)
522                 ret = package->provider->fnTableA.QueryContextAttributesA(
523                  ctxt, ulAttribute, pBuffer);
524             else
525                 ret = SEC_E_UNSUPPORTED_FUNCTION;
526         }
527         else
528             ret = SEC_E_INVALID_HANDLE;
529     }
530     else
531         ret = SEC_E_INVALID_HANDLE;
532     return ret;
533 }
534
535 /***********************************************************************
536  *              QueryContextAttributesW (SECUR32.@)
537  */
538 SECURITY_STATUS WINAPI QueryContextAttributesW(PCtxtHandle phContext,
539  ULONG ulAttribute, void *pBuffer)
540 {
541     SECURITY_STATUS ret;
542
543     TRACE("%p %d %p\n", phContext, ulAttribute, pBuffer);
544     if (phContext)
545     {
546         SecurePackage *package = (SecurePackage *)phContext->dwUpper;
547         PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower;
548
549         if (package && package->provider)
550         {
551             if (package->provider->fnTableW.QueryContextAttributesW)
552                 ret = package->provider->fnTableW.QueryContextAttributesW(
553                  ctxt, ulAttribute, pBuffer);
554             else
555                 ret = SEC_E_UNSUPPORTED_FUNCTION;
556         }
557         else
558             ret = SEC_E_INVALID_HANDLE;
559     }
560     else
561         ret = SEC_E_INVALID_HANDLE;
562     return ret;
563 }
564
565 /***********************************************************************
566  *              ImpersonateSecurityContext (SECUR32.@)
567  */
568 SECURITY_STATUS WINAPI ImpersonateSecurityContext(PCtxtHandle phContext)
569 {
570     SECURITY_STATUS ret;
571
572     TRACE("%p\n", phContext);
573     if (phContext)
574     {
575         SecurePackage *package = (SecurePackage *)phContext->dwUpper;
576         PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower;
577
578         if (package && package->provider)
579         {
580             if (package->provider->fnTableW.ImpersonateSecurityContext)
581                 ret = package->provider->fnTableW.ImpersonateSecurityContext(
582                  ctxt);
583             else
584                 ret = SEC_E_UNSUPPORTED_FUNCTION;
585         }
586         else
587             ret = SEC_E_INVALID_HANDLE;
588     }
589     else
590         ret = SEC_E_INVALID_HANDLE;
591     return ret;
592 }
593
594 /***********************************************************************
595  *              RevertSecurityContext (SECUR32.@)
596  */
597 SECURITY_STATUS WINAPI RevertSecurityContext(PCtxtHandle phContext)
598 {
599     SECURITY_STATUS ret;
600
601     TRACE("%p\n", phContext);
602     if (phContext)
603     {
604         SecurePackage *package = (SecurePackage *)phContext->dwUpper;
605         PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower;
606
607         if (package && package->provider)
608         {
609             if (package->provider->fnTableW.RevertSecurityContext)
610                 ret = package->provider->fnTableW.RevertSecurityContext(
611                  ctxt);
612             else
613                 ret = SEC_E_UNSUPPORTED_FUNCTION;
614         }
615         else
616             ret = SEC_E_INVALID_HANDLE;
617     }
618     else
619         ret = SEC_E_INVALID_HANDLE;
620     return ret;
621 }
622
623 /***********************************************************************
624  *              MakeSignature (SECUR32.@)
625  */
626 SECURITY_STATUS WINAPI MakeSignature(PCtxtHandle phContext, ULONG fQOP,
627  PSecBufferDesc pMessage, ULONG MessageSeqNo)
628 {
629     SECURITY_STATUS ret;
630
631     TRACE("%p %d %p %d\n", phContext, fQOP, pMessage, MessageSeqNo);
632     if (phContext)
633     {
634         SecurePackage *package = (SecurePackage *)phContext->dwUpper;
635         PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower;
636
637         if (package && package->provider)
638         {
639             if (package->provider->fnTableW.MakeSignature)
640                 ret = package->provider->fnTableW.MakeSignature(
641                  ctxt, fQOP, pMessage, MessageSeqNo);
642             else
643                 ret = SEC_E_UNSUPPORTED_FUNCTION;
644         }
645         else
646             ret = SEC_E_INVALID_HANDLE;
647     }
648     else
649         ret = SEC_E_INVALID_HANDLE;
650     return ret;
651 }
652
653 /***********************************************************************
654  *              VerifySignature (SECUR32.@)
655  */
656 SECURITY_STATUS WINAPI VerifySignature(PCtxtHandle phContext,
657  PSecBufferDesc pMessage, ULONG MessageSeqNo, PULONG pfQOP)
658 {
659     SECURITY_STATUS ret;
660
661     TRACE("%p %p %d %p\n", phContext, pMessage, MessageSeqNo, pfQOP);
662     if (phContext)
663     {
664         SecurePackage *package = (SecurePackage *)phContext->dwUpper;
665         PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower;
666
667         if (package && package->provider)
668         {
669             if (package->provider->fnTableW.VerifySignature)
670                 ret = package->provider->fnTableW.VerifySignature(
671                  ctxt, pMessage, MessageSeqNo, pfQOP);
672             else
673                 ret = SEC_E_UNSUPPORTED_FUNCTION;
674         }
675         else
676             ret = SEC_E_INVALID_HANDLE;
677     }
678     else
679         ret = SEC_E_INVALID_HANDLE;
680     return ret;
681 }
682
683 /***********************************************************************
684  *              QuerySecurityPackageInfoA (SECUR32.@)
685  */
686 SECURITY_STATUS WINAPI QuerySecurityPackageInfoA(SEC_CHAR *pszPackageName,
687  PSecPkgInfoA *ppPackageInfo)
688 {
689     SECURITY_STATUS ret;
690    
691     TRACE("%s %p\n", debugstr_a(pszPackageName), ppPackageInfo);
692     if (pszPackageName)
693     {
694         SecurePackage *package = SECUR32_findPackageA(pszPackageName);
695
696         if (package)
697         {
698             size_t bytesNeeded = sizeof(SecPkgInfoA);
699             int nameLen = 0, commentLen = 0;
700
701             if (package->infoW.Name)
702             {
703                 nameLen = WideCharToMultiByte(CP_ACP, 0,
704                  package->infoW.Name, -1, NULL, 0, NULL, NULL);
705                 bytesNeeded += nameLen;
706             }
707             if (package->infoW.Comment)
708             {
709                 commentLen = WideCharToMultiByte(CP_ACP, 0,
710                  package->infoW.Comment, -1, NULL, 0, NULL, NULL);
711                 bytesNeeded += commentLen;
712             }
713             *ppPackageInfo = (PSecPkgInfoA)SECUR32_ALLOC(bytesNeeded);
714             if (*ppPackageInfo)
715             {
716                 PSTR nextString = (PSTR)((PBYTE)*ppPackageInfo +
717                  sizeof(SecPkgInfoA));
718
719                 memcpy(*ppPackageInfo, &package->infoW, sizeof(package->infoW));
720                 if (package->infoW.Name)
721                 {
722                     (*ppPackageInfo)->Name = nextString;
723                     nextString += WideCharToMultiByte(CP_ACP, 0,
724                      package->infoW.Name, -1, nextString, nameLen, NULL, NULL);
725                 }
726                 else
727                     (*ppPackageInfo)->Name = NULL;
728                 if (package->infoW.Comment)
729                 {
730                     (*ppPackageInfo)->Comment = nextString;
731                     nextString += WideCharToMultiByte(CP_ACP, 0,
732                      package->infoW.Comment, -1, nextString, commentLen, NULL,
733                      NULL);
734                 }
735                 else
736                     (*ppPackageInfo)->Comment = NULL;
737                 ret = SEC_E_OK;
738             }
739             else
740                 ret = SEC_E_INSUFFICIENT_MEMORY;
741         }
742         else
743             ret = SEC_E_SECPKG_NOT_FOUND;
744     }
745     else
746         ret = SEC_E_SECPKG_NOT_FOUND;
747     return ret;
748 }
749
750 /***********************************************************************
751  *              QuerySecurityPackageInfoW (SECUR32.@)
752  */
753 SECURITY_STATUS WINAPI QuerySecurityPackageInfoW(SEC_WCHAR *pszPackageName,
754  PSecPkgInfoW *ppPackageInfo)
755 {
756     SECURITY_STATUS ret;
757     SecurePackage *package = SECUR32_findPackageW(pszPackageName);
758
759     TRACE("%s %p\n", debugstr_w(pszPackageName), ppPackageInfo);
760     if (package)
761     {
762         size_t bytesNeeded = sizeof(SecPkgInfoW);
763         int nameLen = 0, commentLen = 0;
764
765         if (package->infoW.Name)
766         {
767             nameLen = lstrlenW(package->infoW.Name) + 1;
768             bytesNeeded += nameLen * sizeof(WCHAR);
769         }
770         if (package->infoW.Comment)
771         {
772             commentLen = lstrlenW(package->infoW.Comment) + 1;
773             bytesNeeded += commentLen * sizeof(WCHAR);
774         }
775         *ppPackageInfo = (PSecPkgInfoW)SECUR32_ALLOC(bytesNeeded);
776         if (*ppPackageInfo)
777         {
778             PWSTR nextString = (PWSTR)((PBYTE)*ppPackageInfo +
779              sizeof(SecPkgInfoW));
780
781             memcpy(*ppPackageInfo, &package->infoW, sizeof(package->infoW));
782             if (package->infoW.Name)
783             {
784                 (*ppPackageInfo)->Name = nextString;
785                 lstrcpynW(nextString, package->infoW.Name, nameLen);
786                 nextString += nameLen;
787             }
788             else
789                 (*ppPackageInfo)->Name = NULL;
790             if (package->infoW.Comment)
791             {
792                 (*ppPackageInfo)->Comment = nextString;
793                 lstrcpynW(nextString, package->infoW.Comment, commentLen);
794                 nextString += commentLen;
795             }
796             else
797                 (*ppPackageInfo)->Comment = NULL;
798             ret = SEC_E_OK;
799         }
800         else
801             ret = SEC_E_INSUFFICIENT_MEMORY;
802     }
803     else
804         ret = SEC_E_SECPKG_NOT_FOUND;
805     return ret;
806 }
807
808 /***********************************************************************
809  *              ExportSecurityContext (SECUR32.@)
810  */
811 SECURITY_STATUS WINAPI ExportSecurityContext(PCtxtHandle phContext,
812  ULONG fFlags, PSecBuffer pPackedContext, void **pToken)
813 {
814     SECURITY_STATUS ret;
815
816     TRACE("%p %d %p %p\n", phContext, fFlags, pPackedContext, pToken);
817     if (phContext)
818     {
819         SecurePackage *package = (SecurePackage *)phContext->dwUpper;
820         PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower;
821
822         if (package && package->provider)
823         {
824             if (package->provider->fnTableW.ExportSecurityContext)
825                 ret = package->provider->fnTableW.ExportSecurityContext(
826                  ctxt, fFlags, pPackedContext, pToken);
827             else
828                 ret = SEC_E_UNSUPPORTED_FUNCTION;
829         }
830         else
831             ret = SEC_E_INVALID_HANDLE;
832     }
833     else
834         ret = SEC_E_INVALID_HANDLE;
835     return ret;
836 }
837
838 /***********************************************************************
839  *              ImportSecurityContextA (SECUR32.@)
840  */
841 SECURITY_STATUS WINAPI ImportSecurityContextA(SEC_CHAR *pszPackage,
842  PSecBuffer pPackedContext, void *Token, PCtxtHandle phContext)
843 {
844     SECURITY_STATUS ret;
845     SecurePackage *package = SECUR32_findPackageA(pszPackage);
846  
847     TRACE("%s %p %p %p\n", debugstr_a(pszPackage), pPackedContext, Token,
848      phContext);
849     if (package && package->provider)
850     {
851         if (package->provider->fnTableA.ImportSecurityContextA)
852         {
853             CtxtHandle myCtxt;
854
855             ret = package->provider->fnTableA.ImportSecurityContextA(
856              pszPackage, pPackedContext, Token, &myCtxt);
857             if (ret == SEC_E_OK)
858             {
859                 ret = SECUR32_makeSecHandle(phContext, package, &myCtxt);
860                 if (ret != SEC_E_OK)
861                     package->provider->fnTableW.DeleteSecurityContext(&myCtxt);
862             }
863         }
864         else
865             ret = SEC_E_UNSUPPORTED_FUNCTION;
866     }
867     else
868         ret = SEC_E_SECPKG_NOT_FOUND;
869     return ret;
870
871 }
872
873 /***********************************************************************
874  *              ImportSecurityContextW (SECUR32.@)
875  */
876 SECURITY_STATUS WINAPI ImportSecurityContextW(SEC_WCHAR *pszPackage,
877  PSecBuffer pPackedContext, void *Token, PCtxtHandle phContext)
878 {
879     SECURITY_STATUS ret;
880     SecurePackage *package = SECUR32_findPackageW(pszPackage);
881
882     TRACE("%s %p %p %p\n", debugstr_w(pszPackage), pPackedContext, Token,
883      phContext);
884     if (package && package->provider)
885     {
886         if (package->provider->fnTableW.ImportSecurityContextW)
887         {
888             CtxtHandle myCtxt;
889
890             ret = package->provider->fnTableW.ImportSecurityContextW(
891              pszPackage, pPackedContext, Token, &myCtxt);
892             if (ret == SEC_E_OK)
893             {
894                 ret = SECUR32_makeSecHandle(phContext, package, &myCtxt);
895                 if (ret != SEC_E_OK)
896                     package->provider->fnTableW.DeleteSecurityContext(&myCtxt);
897             }
898         }
899         else
900             ret = SEC_E_UNSUPPORTED_FUNCTION;
901     }
902     else
903         ret = SEC_E_SECPKG_NOT_FOUND;
904     return ret;
905 }
906
907 /***********************************************************************
908  *              AddCredentialsA (SECUR32.@)
909  */
910 SECURITY_STATUS WINAPI AddCredentialsA(PCredHandle hCredentials,
911  SEC_CHAR *pszPrincipal, SEC_CHAR *pszPackage, ULONG fCredentialUse,
912  void *pAuthData, SEC_GET_KEY_FN pGetKeyFn, void *pvGetKeyArgument,
913  PTimeStamp ptsExpiry)
914 {
915     SECURITY_STATUS ret;
916
917     TRACE("%p %s %s %d %p %p %p %p\n", hCredentials, debugstr_a(pszPrincipal),
918      debugstr_a(pszPackage), fCredentialUse, pAuthData, pGetKeyFn,
919      pvGetKeyArgument, ptsExpiry);
920     if (hCredentials)
921     {
922         SecurePackage *package = (SecurePackage *)hCredentials->dwUpper;
923         PCredHandle cred = (PCtxtHandle)hCredentials->dwLower;
924
925         if (package && package->provider)
926         {
927             if (package->provider->fnTableA.AddCredentialsA)
928                 ret = package->provider->fnTableA.AddCredentialsA(
929                  cred, pszPrincipal, pszPackage, fCredentialUse, pAuthData,
930                  pGetKeyFn, pvGetKeyArgument, ptsExpiry);
931             else
932                 ret = SEC_E_UNSUPPORTED_FUNCTION;
933         }
934         else
935             ret = SEC_E_INVALID_HANDLE;
936     }
937     else
938         ret = SEC_E_INVALID_HANDLE;
939     return ret;
940 }
941
942 /***********************************************************************
943  *              AddCredentialsW (SECUR32.@)
944  */
945 SECURITY_STATUS WINAPI AddCredentialsW(PCredHandle hCredentials,
946  SEC_WCHAR *pszPrincipal, SEC_WCHAR *pszPackage, ULONG fCredentialUse,
947  void *pAuthData, SEC_GET_KEY_FN pGetKeyFn, void *pvGetKeyArgument,
948  PTimeStamp ptsExpiry)
949 {
950     SECURITY_STATUS ret;
951
952     TRACE("%p %s %s %d %p %p %p %p\n", hCredentials, debugstr_w(pszPrincipal),
953      debugstr_w(pszPackage), fCredentialUse, pAuthData, pGetKeyFn,
954      pvGetKeyArgument, ptsExpiry);
955     if (hCredentials)
956     {
957         SecurePackage *package = (SecurePackage *)hCredentials->dwUpper;
958         PCredHandle cred = (PCtxtHandle)hCredentials->dwLower;
959
960         if (package && package->provider)
961         {
962             if (package->provider->fnTableW.AddCredentialsW)
963                 ret = package->provider->fnTableW.AddCredentialsW(
964                  cred, pszPrincipal, pszPackage, fCredentialUse, pAuthData,
965                  pGetKeyFn, pvGetKeyArgument, ptsExpiry);
966             else
967                 ret = SEC_E_UNSUPPORTED_FUNCTION;
968         }
969         else
970             ret = SEC_E_INVALID_HANDLE;
971     }
972     else
973         ret = SEC_E_INVALID_HANDLE;
974     return ret;
975 }
976
977 /***********************************************************************
978  *              QuerySecurityContextToken (SECUR32.@)
979  */
980 SECURITY_STATUS WINAPI QuerySecurityContextToken(PCtxtHandle phContext,
981  HANDLE *phToken)
982 {
983     SECURITY_STATUS ret;
984
985     TRACE("%p %p\n", phContext, phToken);
986     if (phContext)
987     {
988         SecurePackage *package = (SecurePackage *)phContext->dwUpper;
989         PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower;
990
991         if (package && package->provider)
992         {
993             if (package->provider->fnTableW.QuerySecurityContextToken)
994                 ret = package->provider->fnTableW.QuerySecurityContextToken(
995                  ctxt, phToken);
996             else
997                 ret = SEC_E_UNSUPPORTED_FUNCTION;
998         }
999         else
1000             ret = SEC_E_INVALID_HANDLE;
1001     }
1002     else
1003         ret = SEC_E_INVALID_HANDLE;
1004     return ret;
1005 }
1006
1007 /***********************************************************************
1008  *              EncryptMessage (SECUR32.@)
1009  */
1010 SECURITY_STATUS WINAPI EncryptMessage(PCtxtHandle phContext, ULONG fQOP,
1011  PSecBufferDesc pMessage, ULONG MessageSeqNo)
1012 {
1013     SECURITY_STATUS ret;
1014
1015     TRACE("%p %d %p %d\n", phContext, fQOP, pMessage, MessageSeqNo);
1016     if (phContext)
1017     {
1018         SecurePackage *package = (SecurePackage *)phContext->dwUpper;
1019         PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower;
1020
1021         if (package && package->provider)
1022         {
1023             if (package->provider->fnTableW.EncryptMessage)
1024                 ret = package->provider->fnTableW.EncryptMessage(
1025                  ctxt, fQOP, pMessage, MessageSeqNo);
1026             else
1027                 ret = SEC_E_UNSUPPORTED_FUNCTION;
1028         }
1029         else
1030             ret = SEC_E_INVALID_HANDLE;
1031     }
1032     else
1033         ret = SEC_E_INVALID_HANDLE;
1034     return ret;
1035 }
1036
1037 /***********************************************************************
1038  *              DecryptMessage (SECUR32.@)
1039  */
1040 SECURITY_STATUS WINAPI DecryptMessage(PCtxtHandle phContext,
1041  PSecBufferDesc pMessage, ULONG MessageSeqNo, PULONG pfQOP)
1042 {
1043     SECURITY_STATUS ret;
1044
1045     TRACE("%p %p %d %p\n", phContext, pMessage, MessageSeqNo, pfQOP);
1046     if (phContext)
1047     {
1048         SecurePackage *package = (SecurePackage *)phContext->dwUpper;
1049         PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower;
1050
1051         if (package && package->provider)
1052         {
1053             if (package->provider->fnTableW.DecryptMessage)
1054                 ret = package->provider->fnTableW.DecryptMessage(
1055                  ctxt, pMessage, MessageSeqNo, pfQOP);
1056             else
1057                 ret = SEC_E_UNSUPPORTED_FUNCTION;
1058         }
1059         else
1060             ret = SEC_E_INVALID_HANDLE;
1061     }
1062     else
1063         ret = SEC_E_INVALID_HANDLE;
1064     return ret;
1065 }
1066
1067 /***********************************************************************
1068  *              SetContextAttributesA (SECUR32.@)
1069  */
1070 SECURITY_STATUS WINAPI SetContextAttributesA(PCtxtHandle phContext,
1071  ULONG ulAttribute, void *pBuffer, ULONG cbBuffer)
1072 {
1073     SECURITY_STATUS ret;
1074
1075     TRACE("%p %d %p %d\n", phContext, ulAttribute, pBuffer, cbBuffer);
1076     if (phContext)
1077     {
1078         SecurePackage *package = (SecurePackage *)phContext->dwUpper;
1079         PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower;
1080
1081         if (package && package->provider)
1082         {
1083             if (package->provider->fnTableA.SetContextAttributesA)
1084                 ret = package->provider->fnTableA.SetContextAttributesA(
1085                  ctxt, ulAttribute, pBuffer, cbBuffer);
1086             else
1087                 ret = SEC_E_UNSUPPORTED_FUNCTION;
1088         }
1089         else
1090             ret = SEC_E_INVALID_HANDLE;
1091     }
1092     else
1093         ret = SEC_E_INVALID_HANDLE;
1094     return ret;
1095 }
1096
1097 /***********************************************************************
1098  *              SetContextAttributesW (SECUR32.@)
1099  */
1100 SECURITY_STATUS WINAPI SetContextAttributesW(PCtxtHandle phContext,
1101  ULONG ulAttribute, void *pBuffer, ULONG cbBuffer)
1102 {
1103     SECURITY_STATUS ret;
1104
1105     TRACE("%p %d %p %d\n", phContext, ulAttribute, pBuffer, cbBuffer);
1106     if (phContext)
1107     {
1108         SecurePackage *package = (SecurePackage *)phContext->dwUpper;
1109         PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower;
1110
1111         if (package && package->provider)
1112         {
1113             if (package->provider->fnTableW.SetContextAttributesW)
1114                 ret = package->provider->fnTableW.SetContextAttributesW(
1115                  ctxt, ulAttribute, pBuffer, cbBuffer);
1116             else
1117                 ret = SEC_E_UNSUPPORTED_FUNCTION;
1118         }
1119         else
1120             ret = SEC_E_INVALID_HANDLE;
1121     }
1122     else
1123         ret = SEC_E_INVALID_HANDLE;
1124     return ret;
1125 }