Annotation of embedaddon/strongswan/src/libtnccs/tnc/tnccs/tnccs_manager.h, revision 1.1.1.1

1.1       misho       1: /*
                      2:  * Copyright (C) 2010-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: /**
                     17:  * @defgroup tnccs_manager tnccs_manager
                     18:  * @{ @ingroup tnccs
                     19:  */
                     20: 
                     21: #ifndef TNCCS_MANAGER_H_
                     22: #define TNCCS_MANAGER_H_
                     23: 
                     24: typedef struct tnccs_manager_t tnccs_manager_t;
                     25: 
                     26: #include "tnccs.h"
                     27: #include "tnc/imv/imv_recommendations.h"
                     28: 
                     29: /**
                     30:  * The TNCCS manager manages all TNCCS implementations and creates instances.
                     31:  *
                     32:  * A plugin registers its implemented TNCCS protocol with the manager by
                     33:  * providing type and a constructor function. The manager then creates
                     34:  * TNCCS protocol instances via the provided constructor.
                     35:  */
                     36: struct tnccs_manager_t {
                     37: 
                     38:        /**
                     39:         * Register a TNCCS protocol implementation.
                     40:         *
                     41:         * @param type                  TNCCS protocol type
                     42:         * @param constructor   constructor, returns a TNCCS protocol implementation
                     43:         */
                     44:        void (*add_method)(tnccs_manager_t *this, tnccs_type_t type,
                     45:                                           tnccs_constructor_t constructor);
                     46: 
                     47:        /**
                     48:         * Unregister a TNCCS protocol implementation using it's constructor.
                     49:         *
                     50:         * @param constructor   constructor function to remove, as added in add_method
                     51:         */
                     52:        void (*remove_method)(tnccs_manager_t *this, tnccs_constructor_t constructor);
                     53: 
                     54:        /**
                     55:         * Create a new TNCCS protocol instance.
                     56:         *
                     57:         * @param type            type of the TNCCS protocol
                     58:         * @param is_server       TRUE if TNC Server, FALSE if TNC Client
                     59:         * @param server_id       Server identity
                     60:         * @param peer_id         Client identity
                     61:         * @param server_ip       Server IP address
                     62:         * @param peer_ip         Client IP address
                     63:         * @param transport       Underlying TNC IF-T transport protocol used
                     64:         * @param cb              Callback function if TNC Server, NULL if TNC Client
                     65:         * @return                        TNCCS protocol instance, NULL if no constructor found
                     66:         */
                     67:        tnccs_t* (*create_instance)(tnccs_manager_t *this, tnccs_type_t type,
                     68:                                                                bool is_server, identification_t *server_id,
                     69:                                                                identification_t *peer_id, host_t *server_ip,
                     70:                                                                host_t *peer_ip, tnc_ift_type_t transport,
                     71:                                                                tnccs_cb_t cb);
                     72: 
                     73:        /**
                     74:         * Create a TNCCS connection and assign a unique connection ID as well a
                     75:         * callback function for adding a message to a TNCCS batch and create
                     76:         * an empty set for collecting IMV recommendations
                     77:         *
                     78:         * @param type                                          TNCCS protocol type
                     79:         * @param tnccs                                         TNCCS connection instance
                     80:         * @param send_message                          TNCCS callback function
                     81:         * @param request_handshake_retry       pointer to boolean variable
                     82:         * @param max_msg_len                           maximum PA-TNC message size
                     83:         * @param recs                                          pointer to IMV recommendation set
                     84:         * @return                                                      assigned connection ID
                     85:         */
                     86:        TNC_ConnectionID (*create_connection)(tnccs_manager_t *this,
                     87:                                                                                  tnccs_type_t type, tnccs_t *tnccs,
                     88:                                                                                  tnccs_send_message_t send_message,
                     89:                                                                                  bool *request_handshake_retry,
                     90:                                                                                  uint32_t max_msg_len,
                     91:                                                                                  recommendations_t **recs);
                     92: 
                     93:        /**
                     94:         * Remove a TNCCS connection using its connection ID.
                     95:         *
                     96:         * @param id                            ID of the connection to be removed
                     97:         * @param is_server                     TNC Server if TRUE, TNC Client if FALSE
                     98:         */
                     99:        void (*remove_connection)(tnccs_manager_t *this, TNC_ConnectionID id,
                    100:                                                          bool is_server);
                    101: 
                    102:        /**
                    103:         * Request a handshake retry
                    104:         *
                    105:         * @param is_imc                        TRUE if IMC, FALSE if IMV
                    106:         * @param imcv_id                       ID of IMC or IMV requesting the retry
                    107:         * @param id                            ID of a specific connection or any connection
                    108:         * @param reason                        reason for the handshake retry
                    109:         * @return                                      return code
                    110:         */
                    111:        TNC_Result (*request_handshake_retry)(tnccs_manager_t *this, bool is_imc,
                    112:                                                                                  TNC_UInt32 imcv_id,
                    113:                                                                                  TNC_ConnectionID id,
                    114:                                                                                  TNC_RetryReason reason);
                    115: 
                    116:        /**
                    117:         * Add an IMC/IMV message to the batch of a given connection ID.
                    118:         *
                    119:         * @param imc_id                        ID of IMC or TNC_IMCID_ANY
                    120:         * @param imv_id                        ID of IMV or TNC_IMVID_ANY
                    121:         * @param id                            ID of target connection
                    122:         * @param msg_flags                     message flags
                    123:         * @param msg                           message to be added
                    124:         * @param msg_len                       message length
                    125:         * @param msg_vid                       message vendor ID
                    126:         * @param msg_subtype           message subtype
                    127:         * @return                                      return code
                    128:         */
                    129:        TNC_Result (*send_message)(tnccs_manager_t *this,
                    130:                                                           TNC_IMCID imc_id,
                    131:                                                           TNC_IMVID imv_id,
                    132:                                                           TNC_ConnectionID id,
                    133:                                                           TNC_UInt32 msg_flags,
                    134:                                                           TNC_BufferReference msg,
                    135:                                                           TNC_UInt32 msg_len,
                    136:                                                           TNC_VendorID msg_vid,
                    137:                                                           TNC_MessageSubtype msg_subtype);
                    138: 
                    139:        /**
                    140:         * Deliver an IMV Action Recommendation and IMV Evaluation Result to the TNCS
                    141:         *
                    142:         * @param imv_id                        ID of the IMV providing the recommendation
                    143:         * @param id                            ID of target connection
                    144:         * @param rec                           action recommendation
                    145:         * @param eval                          evaluation result
                    146:         * @return                                      return code
                    147:         */
                    148:        TNC_Result (*provide_recommendation)(tnccs_manager_t *this,
                    149:                                                                                 TNC_IMVID imv_id,
                    150:                                                                                 TNC_ConnectionID id,
                    151:                                                                                 TNC_IMV_Action_Recommendation rec,
                    152:                                                                                 TNC_IMV_Evaluation_Result eval);
                    153: 
                    154:        /**
                    155:         * Get the value of an attribute associated with a connection or with the
                    156:         * TNCS as a whole.
                    157:         *
                    158:         * @param is_imc                        TRUE if IMC, FALSE if IMV
                    159:         * @param imcv_id                       ID of the IMC/IMV requesting the attribute
                    160:         * @param id                            ID of target connection
                    161:         * @param attribute_id          ID of the requested attribute
                    162:         * @param buffer_len            length of the buffer in bytes
                    163:         * @param buffer                        pointer to the buffer
                    164:         * @param value_len                     actual length of the returned attribute
                    165:         * @return                                      return code
                    166:         */
                    167:        TNC_Result (*get_attribute)(tnccs_manager_t *this, bool is_imc,
                    168:                                                           TNC_UInt32 imcv_id,
                    169:                                                           TNC_ConnectionID id,
                    170:                                                           TNC_AttributeID attribute_id,
                    171:                                                           TNC_UInt32 buffer_len,
                    172:                                                           TNC_BufferReference buffer,
                    173:                                                           TNC_UInt32 *value_len);
                    174: 
                    175:        /**
                    176:         * Set the value of an attribute associated with a connection or with the
                    177:         * TNCS as a whole.
                    178:         *
                    179:         * @param is_imc                        TRUE if IMC, FALSE if IMV
                    180:         * @param imcv_id                       ID of the IMC/IMV setting the attribute
                    181:         * @param id                            ID of target connection
                    182:         * @param attribute_id          ID of the attribute to be set
                    183:         * @param buffer_len            length of the buffer in bytes
                    184:         * @param buffer                        pointer to the buffer
                    185:         * @return                                      return code
                    186:         */
                    187:        TNC_Result (*set_attribute)(tnccs_manager_t *this, bool is_imc,
                    188:                                                                TNC_UInt32 imcv_id,
                    189:                                                                TNC_ConnectionID id,
                    190:                                                                TNC_AttributeID attribute_id,
                    191:                                                                TNC_UInt32 buffer_len,
                    192:                                                                TNC_BufferReference buffer);
                    193: 
                    194:        /**
                    195:         * Destroy a tnccs_manager instance.
                    196:         */
                    197:        void (*destroy)(tnccs_manager_t *this);
                    198: };
                    199: 
                    200: /**
                    201:  * Helper function to (un-)register TNCCS methods from plugin features.
                    202:  *
                    203:  * This function is a plugin_feature_callback_t and can be used with the
                    204:  * PLUGIN_CALLBACK macro to register a TNCCS method constructor.
                    205:  *
                    206:  * @param plugin               plugin registering the TNCCS method constructor
                    207:  * @param feature              associated plugin feature
                    208:  * @param reg                  TRUE to register, FALSE to unregister.
                    209:  * @param data                 data passed to callback, a tnccs_constructor_t
                    210:  */
                    211: bool tnccs_method_register(plugin_t *plugin, plugin_feature_t *feature,
                    212:                                                   bool reg, void *data);
                    213: 
                    214: #endif /** TNCCS_MANAGER_H_ @}*/

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>