Return to imv_session_manager.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / libimcv / imv

Annotation of embedaddon/strongswan/src/libimcv/imv/imv_session_manager.c, revision 1.1

1.1     ! misho       1: /*
        !             2:  * Copyright (C) 2014-2015 Andreas Steffen
        !             3:  * HSR Hochschule fuer Technik Rapperswil
        !             4:  *
        !             5:  * This program is free software; you can redistribute it and/or modify it
        !             6:  * under the terms of the GNU General Public License as published by the
        !             7:  * Free Software Foundation; either version 2 of the License, or (at your
        !             8:  * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
        !             9:  *
        !            10:  * This program is distributed in the hope that it will be useful, but
        !            11:  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
        !            12:  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
        !            13:  * for more details.
        !            14:  */
        !            15: 
        !            16: #include "imv_session_manager.h"
        !            17: 
        !            18: #include <tncif_names.h>
        !            19: #include <tncif_identity.h>
        !            20: 
        !            21: #include <threading/mutex.h>
        !            22: 
        !            23: typedef struct private_imv_session_manager_t private_imv_session_manager_t;
        !            24: 
        !            25: /**
        !            26:  * Private data of a imv_session_manager_t object.
        !            27:  */
        !            28: struct private_imv_session_manager_t {
        !            29: 
        !            30:        /**
        !            31:         * Public imv_session_manager_t interface.
        !            32:         */
        !            33:        imv_session_manager_t public;
        !            34: 
        !            35:        /**
        !            36:         * Session list
        !            37:         */
        !            38:        linked_list_t *sessions;
        !            39: 
        !            40:        /**
        !            41:         * mutex used to lock session list
        !            42:         */
        !            43:        mutex_t *mutex;
        !            44: 
        !            45: };
        !            46: 
        !            47: METHOD(imv_session_manager_t, add_session, imv_session_t*,
        !            48:        private_imv_session_manager_t *this, TNC_ConnectionID conn_id,
        !            49:        linked_list_t *ar_identities)
        !            50: {
        !            51:        enumerator_t *enumerator;
        !            52:        tncif_identity_t *tnc_id;
        !            53:        imv_session_t *current, *session = NULL;
        !            54: 
        !            55:        this->mutex->lock(this->mutex);
        !            56: 
        !            57:        /* check if a session has already been assigned */
        !            58:        enumerator = this->sessions->create_enumerator(this->sessions);
        !            59:        while (enumerator->enumerate(enumerator, &current))
        !            60:        {
        !            61:                if (conn_id == current->get_connection_id(current))
        !            62:                {
        !            63:                        session = current;
        !            64:                        break;
        !            65:                }
        !            66:        }
        !            67:        enumerator->destroy(enumerator);
        !            68: 
        !            69:        /* session already exists */
        !            70:        if (session)
        !            71:        {
        !            72:                ar_identities->destroy_offset(ar_identities,
        !            73:                                                           offsetof(tncif_identity_t, destroy));
        !            74:                this->mutex->unlock(this->mutex);
        !            75:                return session->get_ref(session);
        !            76:        }
        !            77: 
        !            78:        /* Output list of Access Requestor identities */
        !            79:        enumerator = ar_identities->create_enumerator(ar_identities);
        !            80:        while (enumerator->enumerate(enumerator, &tnc_id))
        !            81:        {
        !            82:                pen_type_t id_type, subject_type, auth_type;
        !            83:                uint32_t tcg_id_type, tcg_subject_type, tcg_auth_type;
        !            84:                chunk_t id_value;
        !            85: 
        !            86:                id_type = tnc_id->get_identity_type(tnc_id);
        !            87:                id_value = tnc_id->get_identity_value(tnc_id);
        !            88:                subject_type = tnc_id->get_subject_type(tnc_id);
        !            89:                auth_type = tnc_id->get_auth_type(tnc_id);
        !            90: 
        !            91:                tcg_id_type = (subject_type.vendor_id == PEN_TCG) ?
        !            92:                                                        id_type.type : TNC_SUBJECT_UNKNOWN;
        !            93:                tcg_subject_type = (subject_type.vendor_id == PEN_TCG) ?
        !            94:                                                        subject_type.type : TNC_SUBJECT_UNKNOWN;
        !            95:                tcg_auth_type =    (auth_type.vendor_id == PEN_TCG) ?
        !            96:                                                        auth_type.type : TNC_AUTH_UNKNOWN;
        !            97: 
        !            98:                DBG2(DBG_IMV, "  %N AR identity '%.*s' of type %N authenticated by %N",
        !            99:                         TNC_Subject_names, tcg_subject_type,
        !           100:                         id_value.len, id_value.ptr,
        !           101:                         TNC_Identity_names, tcg_id_type,
        !           102:                         TNC_Authentication_names, tcg_auth_type);
        !           103:        }
        !           104:        enumerator->destroy(enumerator);
        !           105: 
        !           106:        /* create a new session entry */
        !           107:        session = imv_session_create(conn_id, ar_identities);
        !           108:        this->sessions->insert_last(this->sessions, session);
        !           109: 
        !           110:        this->mutex->unlock(this->mutex);
        !           111: 
        !           112:        return session;
        !           113: }
        !           114: 
        !           115: METHOD(imv_session_manager_t, remove_session, void,
        !           116:        private_imv_session_manager_t *this, imv_session_t *session)
        !           117: {
        !           118:        enumerator_t *enumerator;
        !           119:        imv_session_t *current;
        !           120: 
        !           121:        this->mutex->lock(this->mutex);
        !           122:        enumerator = this->sessions->create_enumerator(this->sessions);
        !           123:        while (enumerator->enumerate(enumerator, &current))
        !           124:        {
        !           125:                if (current == session)
        !           126:                {
        !           127:                        this->sessions->remove_at(this->sessions, enumerator);
        !           128:                        break;
        !           129:                }
        !           130:        }
        !           131:        enumerator->destroy(enumerator);
        !           132:        this->mutex->unlock(this->mutex);
        !           133: }
        !           134: 
        !           135: METHOD(imv_session_manager_t, destroy, void,
        !           136:        private_imv_session_manager_t *this)
        !           137: {
        !           138:        this->sessions->destroy_offset(this->sessions,
        !           139:                                                        offsetof(imv_session_t, destroy));
        !           140:        this->mutex->destroy(this->mutex);
        !           141:        free(this);
        !           142: }
        !           143: 
        !           144: /**
        !           145:  * See header
        !           146:  */
        !           147: imv_session_manager_t *imv_session_manager_create(void)
        !           148: {
        !           149:        private_imv_session_manager_t *this;
        !           150: 
        !           151:        INIT(this,
        !           152:                .public = {
        !           153:                        .add_session = _add_session,
        !           154:                        .remove_session = _remove_session,
        !           155:                        .destroy = _destroy,
        !           156:                },
        !           157:                .sessions = linked_list_create(),
        !           158:                .mutex = mutex_create(MUTEX_TYPE_DEFAULT),
        !           159:        );
        !           160: 
        !           161:        return &this->public;
        !           162: }
        !           163: