2 * Copyright (c) 2011, JANET(UK)
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
16 * 3. Neither the name of JANET(UK) nor the names of its contributors
17 * may be used to endorse or promote products derived from this software
18 * without specific prior written permission.
20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34 * Attribute provider mechanism.
37 #include "gssapiP_eap.h"
46 /* lazy initialisation */
47 static GSSEAP_THREAD_ONCE gssEapAttrProvidersInitOnce = GSSEAP_ONCE_INITIALIZER;
48 static OM_uint32 gssEapAttrProvidersInitStatus = GSS_S_UNAVAILABLE;
51 gssEapAttrProvidersInitInternal(void)
53 OM_uint32 major, minor;
55 assert(gssEapAttrProvidersInitStatus == GSS_S_UNAVAILABLE);
57 major = gssEapRadiusAttrProviderInit(&minor);
61 major = gssEapSamlAttrProvidersInit(&minor);
65 /* Allow Shibboleth initialization failure to be non-fatal */
66 gssEapLocalAttrProviderInit(&minor);
70 assert(major == GSS_S_COMPLETE);
73 gssEapAttrProvidersInitStatus = major;
77 gssEapAttrProvidersInit(OM_uint32 *minor)
79 GSSEAP_ONCE(&gssEapAttrProvidersInitOnce, gssEapAttrProvidersInitInternal);
81 if (GSS_ERROR(gssEapAttrProvidersInitStatus))
82 *minor = GSSEAP_NO_ATTR_PROVIDERS;
84 return gssEapAttrProvidersInitStatus;
88 gssEapAttrProvidersFinalize(OM_uint32 *minor)
90 OM_uint32 major = GSS_S_COMPLETE;
92 if (gssEapAttrProvidersInitStatus == GSS_S_COMPLETE) {
93 major = gssEapLocalAttrProviderFinalize(minor);
94 if (major == GSS_S_COMPLETE)
95 major = gssEapSamlAttrProvidersFinalize(minor);
96 if (major == GSS_S_COMPLETE)
97 major = gssEapRadiusAttrProviderFinalize(minor);
99 gssEapAttrProvidersInitStatus = GSS_S_UNAVAILABLE;
105 static gss_eap_attr_create_provider gssEapAttrFactories[ATTR_TYPE_MAX + 1];
108 * Register a provider for a particular type and prefix
111 gss_eap_attr_ctx::registerProvider(unsigned int type,
112 gss_eap_attr_create_provider factory)
114 assert(type <= ATTR_TYPE_MAX);
116 assert(gssEapAttrFactories[type] == NULL);
118 gssEapAttrFactories[type] = factory;
122 * Unregister a provider
125 gss_eap_attr_ctx::unregisterProvider(unsigned int type)
127 assert(type <= ATTR_TYPE_MAX);
129 gssEapAttrFactories[type] = NULL;
133 * Create an attribute context, that manages instances of providers
135 gss_eap_attr_ctx::gss_eap_attr_ctx(void)
139 for (unsigned int i = ATTR_TYPE_MIN; i <= ATTR_TYPE_MAX; i++) {
140 gss_eap_attr_provider *provider;
142 if (gssEapAttrFactories[i] != NULL) {
143 provider = (gssEapAttrFactories[i])();
148 m_providers[i] = provider;
153 * Convert an attribute prefix to a type
156 gss_eap_attr_ctx::attributePrefixToType(const gss_buffer_t prefix) const
160 for (i = ATTR_TYPE_MIN; i < ATTR_TYPE_MAX; i++) {
163 if (!providerEnabled(i))
166 pprefix = m_providers[i]->prefix();
170 if (strlen(pprefix) == prefix->length &&
171 memcmp(pprefix, prefix->value, prefix->length) == 0)
175 return ATTR_TYPE_LOCAL;
179 * Convert a type to an attribute prefix
182 gss_eap_attr_ctx::attributeTypeToPrefix(unsigned int type) const
184 gss_buffer_desc prefix = GSS_C_EMPTY_BUFFER;
186 if (type < ATTR_TYPE_MIN || type >= ATTR_TYPE_MAX)
189 if (!providerEnabled(type))
192 prefix.value = (void *)m_providers[type]->prefix();
193 if (prefix.value != NULL)
194 prefix.length = strlen((char *)prefix.value);
200 gss_eap_attr_ctx::providerEnabled(unsigned int type) const
202 if (type == ATTR_TYPE_LOCAL &&
203 (m_flags & ATTR_FLAG_DISABLE_LOCAL))
206 if (m_providers[type] == NULL)
213 gss_eap_attr_ctx::releaseProvider(unsigned int type)
215 delete m_providers[type];
216 m_providers[type] = NULL;
220 * Initialize a context from an existing context.
223 gss_eap_attr_ctx::initFromExistingContext(const gss_eap_attr_ctx *manager)
227 m_flags = manager->m_flags;
229 for (unsigned int i = ATTR_TYPE_MIN; i <= ATTR_TYPE_MAX; i++) {
230 gss_eap_attr_provider *provider;
232 if (!providerEnabled(i)) {
237 provider = m_providers[i];
239 ret = provider->initFromExistingContext(this,
240 manager->m_providers[i]);
251 * Initialize a context from a GSS credential and context.
254 gss_eap_attr_ctx::initFromGssContext(const gss_cred_id_t cred,
255 const gss_ctx_id_t ctx)
259 if (cred != GSS_C_NO_CREDENTIAL &&
260 (cred->flags & GSS_EAP_DISABLE_LOCAL_ATTRS_FLAG)) {
261 m_flags |= ATTR_FLAG_DISABLE_LOCAL;
264 for (unsigned int i = ATTR_TYPE_MIN; i <= ATTR_TYPE_MAX; i++) {
265 gss_eap_attr_provider *provider;
267 if (!providerEnabled(i)) {
272 provider = m_providers[i];
274 ret = provider->initFromGssContext(this, cred, ctx);
285 gss_eap_attr_ctx::initWithJsonObject(JSONObject &obj)
288 bool foundSource[ATTR_TYPE_MAX + 1];
291 for (type = ATTR_TYPE_MIN; type <= ATTR_TYPE_MAX; type++)
292 foundSource[type] = false;
294 if (obj["version"].integer() != 1)
297 m_flags = obj["flags"].integer();
299 JSONObject sources = obj["sources"];
301 /* Initialize providers from serialized state */
302 for (type = ATTR_TYPE_MIN; type <= ATTR_TYPE_MAX; type++) {
303 gss_eap_attr_provider *provider;
306 if (!providerEnabled(type)) {
307 releaseProvider(type);
311 provider = m_providers[type];
312 key = provider->name();
316 JSONObject source = sources.get(key);
317 if (!source.isNull() &&
318 !provider->initWithJsonObject(this, source)) {
319 releaseProvider(type);
323 foundSource[type] = true;
326 /* Initialize remaining providers from initialized providers */
327 for (type = ATTR_TYPE_MIN; type <= ATTR_TYPE_MAX; type++) {
328 gss_eap_attr_provider *provider;
330 if (foundSource[type] || !providerEnabled(type))
333 provider = m_providers[type];
335 ret = provider->initFromGssContext(this,
339 releaseProvider(type);
348 gss_eap_attr_ctx::jsonRepresentation(void) const
350 JSONObject obj, sources;
353 obj.set("version", 1);
354 obj.set("flags", m_flags);
356 for (i = ATTR_TYPE_MIN; i <= ATTR_TYPE_MAX; i++) {
357 gss_eap_attr_provider *provider;
360 provider = m_providers[i];
361 if (provider == NULL)
362 continue; /* provider not initialised */
364 key = provider->name();
366 continue; /* provider does not have state */
368 JSONObject source = provider->jsonRepresentation();
369 sources.set(key, source);
372 obj.set("sources", sources);
378 * Initialize a context from an exported context or name token
381 gss_eap_attr_ctx::initFromBuffer(const gss_buffer_t buffer)
383 OM_uint32 major, minor;
388 major = bufferToString(&minor, buffer, &s);
389 if (GSS_ERROR(major))
392 JSONObject obj = JSONObject::load(s, 0, &error);
394 ret = initWithJsonObject(obj);
403 gss_eap_attr_ctx::~gss_eap_attr_ctx(void)
405 for (unsigned int i = ATTR_TYPE_MIN; i <= ATTR_TYPE_MAX; i++)
406 delete m_providers[i];
410 * Locate provider for a given type
412 gss_eap_attr_provider *
413 gss_eap_attr_ctx::getProvider(unsigned int type) const
415 assert(type >= ATTR_TYPE_MIN && type <= ATTR_TYPE_MAX);
416 return m_providers[type];
420 * Get primary provider. Only the primary provider is serialised when
421 * gss_export_sec_context() or gss_export_name_composite() is called.
423 gss_eap_attr_provider *
424 gss_eap_attr_ctx::getPrimaryProvider(void) const
426 return m_providers[ATTR_TYPE_MIN];
433 gss_eap_attr_ctx::setAttribute(int complete,
434 const gss_buffer_t attr,
435 const gss_buffer_t value)
437 gss_buffer_desc suffix = GSS_C_EMPTY_BUFFER;
439 gss_eap_attr_provider *provider;
442 decomposeAttributeName(attr, &type, &suffix);
444 provider = m_providers[type];
445 if (provider != NULL) {
446 ret = provider->setAttribute(complete,
447 (type == ATTR_TYPE_LOCAL) ? attr : &suffix,
455 * Delete an attrbiute
458 gss_eap_attr_ctx::deleteAttribute(const gss_buffer_t attr)
460 gss_buffer_desc suffix = GSS_C_EMPTY_BUFFER;
462 gss_eap_attr_provider *provider;
465 decomposeAttributeName(attr, &type, &suffix);
467 provider = m_providers[type];
468 if (provider != NULL) {
469 ret = provider->deleteAttribute(type == ATTR_TYPE_LOCAL ? attr : &suffix);
476 * Enumerate attribute types with callback
479 gss_eap_attr_ctx::getAttributeTypes(gss_eap_attr_enumeration_cb cb, void *data) const
484 for (i = ATTR_TYPE_MIN; i <= ATTR_TYPE_MAX; i++) {
485 gss_eap_attr_provider *provider = m_providers[i];
487 if (provider == NULL)
490 ret = provider->getAttributeTypes(cb, data);
498 struct eap_gss_get_attr_types_args {
500 gss_buffer_set_t attrs;
504 addAttribute(const gss_eap_attr_ctx *manager,
505 const gss_eap_attr_provider *provider GSSEAP_UNUSED,
506 const gss_buffer_t attribute,
509 eap_gss_get_attr_types_args *args = (eap_gss_get_attr_types_args *)data;
510 gss_buffer_desc qualified;
511 OM_uint32 major, minor;
513 if (args->type != ATTR_TYPE_LOCAL) {
514 manager->composeAttributeName(args->type, attribute, &qualified);
515 major = gss_add_buffer_set_member(&minor, &qualified, &args->attrs);
516 gss_release_buffer(&minor, &qualified);
518 major = gss_add_buffer_set_member(&minor, attribute, &args->attrs);
521 return GSS_ERROR(major) == false;
525 * Enumerate attribute types, output is buffer set
528 gss_eap_attr_ctx::getAttributeTypes(gss_buffer_set_t *attrs)
530 eap_gss_get_attr_types_args args;
531 OM_uint32 major, minor;
535 major = gss_create_empty_buffer_set(&minor, attrs);
536 if (GSS_ERROR(major))
537 throw new std::bad_alloc;
541 for (i = ATTR_TYPE_MIN; i <= ATTR_TYPE_MAX; i++) {
542 gss_eap_attr_provider *provider = m_providers[i];
546 if (provider == NULL)
549 ret = provider->getAttributeTypes(addAttribute, (void *)&args);
555 gss_release_buffer_set(&minor, attrs);
561 * Get attribute with given name
564 gss_eap_attr_ctx::getAttribute(const gss_buffer_t attr,
568 gss_buffer_t display_value,
571 gss_buffer_desc suffix = GSS_C_EMPTY_BUFFER;
573 gss_eap_attr_provider *provider;
576 decomposeAttributeName(attr, &type, &suffix);
578 provider = m_providers[type];
579 if (provider == NULL)
582 ret = provider->getAttribute(type == ATTR_TYPE_LOCAL ? attr : &suffix,
583 authenticated, complete,
584 value, display_value, more);
590 * Map attribute context to C++ object
593 gss_eap_attr_ctx::mapToAny(int authenticated,
594 gss_buffer_t type_id) const
597 gss_eap_attr_provider *provider;
598 gss_buffer_desc suffix;
600 decomposeAttributeName(type_id, &type, &suffix);
602 provider = m_providers[type];
603 if (provider == NULL)
604 return (gss_any_t)NULL;
606 return provider->mapToAny(authenticated, &suffix);
610 * Release mapped context
613 gss_eap_attr_ctx::releaseAnyNameMapping(gss_buffer_t type_id,
614 gss_any_t input) const
617 gss_eap_attr_provider *provider;
618 gss_buffer_desc suffix;
620 decomposeAttributeName(type_id, &type, &suffix);
622 provider = m_providers[type];
623 if (provider != NULL)
624 provider->releaseAnyNameMapping(&suffix, input);
628 * Export attribute context to buffer
631 gss_eap_attr_ctx::exportToBuffer(gss_buffer_t buffer) const
636 JSONObject obj = jsonRepresentation();
642 s = obj.dump(JSON_COMPACT);
644 if (GSS_ERROR(makeStringBuffer(&minor, s, buffer)))
645 throw new std::bad_alloc;
649 * Return soonest expiry time of providers
652 gss_eap_attr_ctx::getExpiryTime(void) const
655 time_t expiryTime = 0;
657 for (i = ATTR_TYPE_MIN; i <= ATTR_TYPE_MAX; i++) {
658 gss_eap_attr_provider *provider = m_providers[i];
659 time_t providerExpiryTime;
661 if (provider == NULL)
664 providerExpiryTime = provider->getExpiryTime();
665 if (providerExpiryTime == 0)
668 if (expiryTime == 0 || providerExpiryTime < expiryTime)
669 expiryTime = providerExpiryTime;
676 gss_eap_attr_ctx::mapException(OM_uint32 *minor, std::exception &e) const
681 /* Errors we handle ourselves */
682 if (typeid(e) == typeid(std::bad_alloc)) {
683 major = GSS_S_FAILURE;
686 } else if (typeid(e) == typeid(std::runtime_error)) {
687 major = GSS_S_BAD_NAME;
688 *minor = GSSEAP_BAD_ATTR_TOKEN;
690 } else if (this == NULL) {
691 major = GSS_S_FAILURE;
695 /* Errors we delegate to providers */
696 major = GSS_S_CONTINUE_NEEDED;
698 for (i = ATTR_TYPE_MIN; i <= ATTR_TYPE_MAX; i++) {
699 gss_eap_attr_provider *provider = m_providers[i];
701 if (provider == NULL)
704 major = provider->mapException(minor, e);
705 if (major != GSS_S_CONTINUE_NEEDED)
709 if (major == GSS_S_CONTINUE_NEEDED) {
710 *minor = GSSEAP_ATTR_CONTEXT_FAILURE;
711 major = GSS_S_FAILURE;
716 /* rethrow for now for debugging */
720 assert(GSS_ERROR(major));
726 * Decompose attribute name into prefix and suffix
729 gss_eap_attr_ctx::decomposeAttributeName(const gss_buffer_t attribute,
736 for (i = 0; i < attribute->length; i++) {
737 if (((char *)attribute->value)[i] == ' ') {
738 p = (char *)attribute->value + i + 1;
743 prefix->value = attribute->value;
746 if (p != NULL && *p != '\0') {
747 suffix->length = attribute->length - 1 - prefix->length;
751 suffix->value = NULL;
756 * Decompose attribute name into type and suffix
759 gss_eap_attr_ctx::decomposeAttributeName(const gss_buffer_t attribute,
761 gss_buffer_t suffix) const
763 gss_buffer_desc prefix = GSS_C_EMPTY_BUFFER;
765 decomposeAttributeName(attribute, &prefix, suffix);
766 *type = attributePrefixToType(&prefix);
770 * Compose attribute name from prefix, suffix; returns C++ string
773 gss_eap_attr_ctx::composeAttributeName(const gss_buffer_t prefix,
774 const gss_buffer_t suffix)
778 if (prefix == GSS_C_NO_BUFFER || prefix->length == 0)
781 str.append((const char *)prefix->value, prefix->length);
783 if (suffix != GSS_C_NO_BUFFER) {
785 str.append((const char *)suffix->value, suffix->length);
792 * Compose attribute name from type, suffix; returns C++ string
795 gss_eap_attr_ctx::composeAttributeName(unsigned int type,
796 const gss_buffer_t suffix)
798 gss_buffer_desc prefix = attributeTypeToPrefix(type);
800 return composeAttributeName(&prefix, suffix);
804 * Compose attribute name from prefix, suffix; returns GSS buffer
807 gss_eap_attr_ctx::composeAttributeName(const gss_buffer_t prefix,
808 const gss_buffer_t suffix,
809 gss_buffer_t attribute)
811 std::string str = composeAttributeName(prefix, suffix);
813 if (str.length() != 0) {
814 return duplicateBuffer(str, attribute);
816 attribute->length = 0;
817 attribute->value = NULL;
822 * Compose attribute name from type, suffix; returns GSS buffer
825 gss_eap_attr_ctx::composeAttributeName(unsigned int type,
826 const gss_buffer_t suffix,
827 gss_buffer_t attribute) const
829 gss_buffer_desc prefix = attributeTypeToPrefix(type);
831 return composeAttributeName(&prefix, suffix, attribute);
838 gssEapInquireName(OM_uint32 *minor,
842 gss_buffer_set_t *attrs)
846 if (name_is_MN != NULL)
847 *name_is_MN = (name->mechanismUsed != GSS_C_NULL_OID);
849 if (MN_mech != NULL) {
850 major = gssEapCanonicalizeOid(minor, name->mechanismUsed,
851 OID_FLAG_NULL_VALID, MN_mech);
852 if (GSS_ERROR(major))
856 if (name->attrCtx == NULL) {
857 *minor = GSSEAP_NO_ATTR_CONTEXT;
858 return GSS_S_UNAVAILABLE;
861 if (GSS_ERROR(gssEapAttrProvidersInit(minor))) {
862 return GSS_S_UNAVAILABLE;
866 if (!name->attrCtx->getAttributeTypes(attrs)) {
867 *minor = GSSEAP_NO_ATTR_CONTEXT;
868 return GSS_S_UNAVAILABLE;
870 } catch (std::exception &e) {
871 return name->attrCtx->mapException(minor, e);
874 return GSS_S_COMPLETE;
878 gssEapGetNameAttribute(OM_uint32 *minor,
884 gss_buffer_t display_value,
887 if (authenticated != NULL)
889 if (complete != NULL)
897 if (display_value != NULL) {
898 display_value->length = 0;
899 display_value->value = NULL;
902 if (name->attrCtx == NULL) {
903 *minor = GSSEAP_NO_ATTR_CONTEXT;
904 return GSS_S_UNAVAILABLE;
907 if (GSS_ERROR(gssEapAttrProvidersInit(minor))) {
908 return GSS_S_UNAVAILABLE;
912 if (!name->attrCtx->getAttribute(attr, authenticated, complete,
913 value, display_value, more)) {
914 *minor = GSSEAP_NO_SUCH_ATTR;
915 gssEapSaveStatusInfo(*minor, "Unknown naming attribute %.*s",
916 (int)attr->length, (char *)attr->value);
917 return GSS_S_UNAVAILABLE;
919 } catch (std::exception &e) {
920 return name->attrCtx->mapException(minor, e);
923 return GSS_S_COMPLETE;
927 gssEapDeleteNameAttribute(OM_uint32 *minor,
931 if (name->attrCtx == NULL) {
932 *minor = GSSEAP_NO_ATTR_CONTEXT;
933 return GSS_S_UNAVAILABLE;
936 if (GSS_ERROR(gssEapAttrProvidersInit(minor)))
937 return GSS_S_UNAVAILABLE;
940 if (!name->attrCtx->deleteAttribute(attr)) {
941 *minor = GSSEAP_NO_SUCH_ATTR;
942 gssEapSaveStatusInfo(*minor, "Unknown naming attribute %.*s",
943 (int)attr->length, (char *)attr->value);
944 return GSS_S_UNAVAILABLE;
946 } catch (std::exception &e) {
947 return name->attrCtx->mapException(minor, e);
950 return GSS_S_COMPLETE;
954 gssEapSetNameAttribute(OM_uint32 *minor,
960 if (name->attrCtx == NULL) {
961 *minor = GSSEAP_NO_ATTR_CONTEXT;
962 return GSS_S_UNAVAILABLE;
965 if (GSS_ERROR(gssEapAttrProvidersInit(minor)))
966 return GSS_S_UNAVAILABLE;
969 if (!name->attrCtx->setAttribute(complete, attr, value)) {
970 *minor = GSSEAP_NO_SUCH_ATTR;
971 gssEapSaveStatusInfo(*minor, "Unknown naming attribute %.*s",
972 (int)attr->length, (char *)attr->value);
973 return GSS_S_UNAVAILABLE;
975 } catch (std::exception &e) {
976 return name->attrCtx->mapException(minor, e);
979 return GSS_S_COMPLETE;
983 gssEapExportAttrContext(OM_uint32 *minor,
987 if (name->attrCtx == NULL) {
989 buffer->value = NULL;
991 return GSS_S_COMPLETE;
994 if (GSS_ERROR(gssEapAttrProvidersInit(minor)))
995 return GSS_S_UNAVAILABLE;
998 name->attrCtx->exportToBuffer(buffer);
999 } catch (std::exception &e) {
1000 return name->attrCtx->mapException(minor, e);
1003 return GSS_S_COMPLETE;
1007 gssEapImportAttrContext(OM_uint32 *minor,
1008 gss_buffer_t buffer,
1011 gss_eap_attr_ctx *ctx = NULL;
1013 assert(name->attrCtx == NULL);
1015 if (GSS_ERROR(gssEapAttrProvidersInit(minor)))
1016 return GSS_S_UNAVAILABLE;
1018 if (buffer->length != 0) {
1020 ctx = new gss_eap_attr_ctx();
1022 if (!ctx->initFromBuffer(buffer)) {
1024 *minor = GSSEAP_BAD_ATTR_TOKEN;
1025 return GSS_S_BAD_NAME;
1027 name->attrCtx = ctx;
1028 } catch (std::exception &e) {
1030 return name->attrCtx->mapException(minor, e);
1034 return GSS_S_COMPLETE;
1038 gssEapDuplicateAttrContext(OM_uint32 *minor,
1042 gss_eap_attr_ctx *ctx = NULL;
1044 assert(out->attrCtx == NULL);
1046 if (GSS_ERROR(gssEapAttrProvidersInit(minor)))
1047 return GSS_S_UNAVAILABLE;
1050 if (in->attrCtx != NULL) {
1051 ctx = new gss_eap_attr_ctx();
1052 if (!ctx->initFromExistingContext(in->attrCtx)) {
1054 *minor = GSSEAP_ATTR_CONTEXT_FAILURE;
1055 return GSS_S_FAILURE;
1059 } catch (std::exception &e) {
1061 return in->attrCtx->mapException(minor, e);
1064 return GSS_S_COMPLETE;
1068 gssEapMapNameToAny(OM_uint32 *minor,
1071 gss_buffer_t type_id,
1074 if (name->attrCtx == NULL) {
1075 *minor = GSSEAP_NO_ATTR_CONTEXT;
1076 return GSS_S_UNAVAILABLE;
1079 if (GSS_ERROR(gssEapAttrProvidersInit(minor)))
1080 return GSS_S_UNAVAILABLE;
1083 *output = name->attrCtx->mapToAny(authenticated, type_id);
1084 } catch (std::exception &e) {
1085 return name->attrCtx->mapException(minor, e);
1088 return GSS_S_COMPLETE;
1092 gssEapReleaseAnyNameMapping(OM_uint32 *minor,
1094 gss_buffer_t type_id,
1097 if (name->attrCtx == NULL) {
1098 *minor = GSSEAP_NO_ATTR_CONTEXT;
1099 return GSS_S_UNAVAILABLE;
1102 if (GSS_ERROR(gssEapAttrProvidersInit(minor)))
1103 return GSS_S_UNAVAILABLE;
1107 name->attrCtx->releaseAnyNameMapping(type_id, *input);
1109 } catch (std::exception &e) {
1110 return name->attrCtx->mapException(minor, e);
1113 return GSS_S_COMPLETE;
1117 gssEapReleaseAttrContext(OM_uint32 *minor,
1120 if (name->attrCtx != NULL)
1121 delete name->attrCtx;
1124 return GSS_S_COMPLETE;
1128 * Public accessor for initialisng a context from a GSS context. Also
1129 * sets expiry time on GSS context as a side-effect.
1132 gssEapCreateAttrContext(OM_uint32 *minor,
1133 gss_cred_id_t gssCred,
1134 gss_ctx_id_t gssCtx,
1135 struct gss_eap_attr_ctx **pAttrContext,
1136 time_t *pExpiryTime)
1138 gss_eap_attr_ctx *ctx = NULL;
1141 assert(gssCtx != GSS_C_NO_CONTEXT);
1143 major = gssEapAttrProvidersInit(minor);
1144 if (GSS_ERROR(major))
1147 *minor = GSSEAP_ATTR_CONTEXT_FAILURE;
1148 major = GSS_S_FAILURE;
1151 *pAttrContext = ctx = new gss_eap_attr_ctx();
1152 if (ctx->initFromGssContext(gssCred, gssCtx)) {
1154 major = GSS_S_COMPLETE;
1156 } catch (std::exception &e) {
1158 major = ctx->mapException(minor, e);
1161 if (major == GSS_S_COMPLETE) {
1162 *pExpiryTime = ctx->getExpiryTime();
1165 *pAttrContext = NULL;