src/libcharon/plugins/tnc_imv/tnc_imv_manager.c

   1 /*
   2  * Copyright (C) 2006 Mike McCauley
   3  * Copyright (C) 2010 Andreas Steffen, 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 "tnc_imv_manager.h"
  17
  18 #include <tnc/imv/imv_manager.h>
  19 #include <tnc/tncifimv.h>
  20
  21 #include <debug.h>
  22 #include <library.h>
  23 #include <utils/linked_list.h>
  24
  25 typedef struct private_tnc_imv_manager_t private_tnc_imv_manager_t;
  26
  27 /**
  28  * Private data of an imv_manager_t object.
  29  */
  30 struct private_tnc_imv_manager_t {
  31
  32         /**
  33          * Public members of imv_manager_t.
  34          */
  35         imv_manager_t public;
  36
  37         /**
  38          * Linked list of IMVs
  39          */
  40         linked_list_t *imvs;
  41
  42         /**
  43          * Next IMV ID to be assigned
  44          */
  45         TNC_IMVID next_imv_id;
  46 };
  47
  48 METHOD(imv_manager_t, add, bool,
  49         private_tnc_imv_manager_t *this, imv_t *imv)
  50 {
  51         TNC_Version version;
  52
  53         /* Initialize the IMV module */
  54         imv->set_id(imv, this->next_imv_id);
  55         if (imv->initialize(imv->get_id(imv), TNC_IFIMV_VERSION_1,
  56                 TNC_IFIMV_VERSION_1, &version) != TNC_RESULT_SUCCESS)
  57         {
  58                 DBG1(DBG_TNC, "could not initialize IMV '%s'",
  59                                            imv->get_name(imv));
  60                 return FALSE;
  61         }
  62         this->imvs->insert_last(this->imvs, imv);
  63         this->next_imv_id++;
  64
  65     if (imv->provide_bind_function(imv->get_id(imv), TNC_TNCS_BindFunction)
  66                         != TNC_RESULT_SUCCESS)
  67         {
  68                 DBG1(DBG_TNC, "could not provide bind function for IMV '%s'",
  69                                            imv->get_name(imv));
  70                 this->imvs->remove_last(this->imvs, (void**)&imv);
  71                 return FALSE;
  72         }
  73         return TRUE;
  74 }
  75
  76 METHOD(imv_manager_t, remove_, imv_t*,
  77         private_tnc_imv_manager_t *this, TNC_IMVID id)
  78 {
  79         enumerator_t *enumerator;
  80         imv_t *imv;
  81
  82         enumerator = this->imvs->create_enumerator(this->imvs);
  83         while (enumerator->enumerate(enumerator, &imv))
  84         {
  85                 if (id == imv->get_id(imv))
  86                 {
  87                         this->imvs->remove_at(this->imvs, enumerator);
  88                         return imv;
  89                 }
  90         }
  91         enumerator->destroy(enumerator);
  92 }
  93
  94 METHOD(imv_manager_t, notify_connection_change, void,
  95         private_tnc_imv_manager_t *this, TNC_ConnectionID id,
  96                                                                          TNC_ConnectionState state)
  97 {
  98         enumerator_t *enumerator;
  99         imv_t *imv;
 100
 101         enumerator = this->imvs->create_enumerator(this->imvs);
 102         while (enumerator->enumerate(enumerator, &imv))
 103         {
 104                 if (imv->notify_connection_change)
 105                 {
 106                         imv->notify_connection_change(imv->get_id(imv), id, state);
 107                 }
 108         }
 109         enumerator->destroy(enumerator);
 110 }
 111
 112 METHOD(imv_manager_t, set_message_types, TNC_Result,
 113         private_tnc_imv_manager_t *this, TNC_IMVID id,
 114                                                                          TNC_MessageTypeList supported_types,
 115                                                                          TNC_UInt32 type_count)
 116 {
 117         enumerator_t *enumerator;
 118         imv_t *imv;
 119         TNC_Result result = TNC_RESULT_FATAL;
 120
 121         enumerator = this->imvs->create_enumerator(this->imvs);
 122         while (enumerator->enumerate(enumerator, &imv))
 123         {
 124                 if (id == imv->get_id(imv))
 125                 {
 126                         imv->set_message_types(imv, supported_types, type_count);
 127                         result = TNC_RESULT_SUCCESS;
 128                         break;
 129                 }
 130         }
 131         enumerator->destroy(enumerator);
 132         return result;
 133 }
 134
 135 METHOD(imv_manager_t, receive_message, void,
 136         private_tnc_imv_manager_t *this, TNC_ConnectionID connection_id,
 137                                                                          TNC_BufferReference message,
 138                                                                          TNC_UInt32 message_len,
 139                                                                          TNC_MessageType message_type)
 140 {
 141         enumerator_t *enumerator;
 142         imv_t *imv;
 143
 144         enumerator = this->imvs->create_enumerator(this->imvs);
 145         while (enumerator->enumerate(enumerator, &imv))
 146         {
 147                 if (imv->receive_message && imv->type_supported(imv, message_type))
 148                 {
 149                         imv->receive_message(imv->get_id(imv), connection_id,
 150                                                                  message, message_len, message_type);
 151                 }
 152         }
 153         enumerator->destroy(enumerator);
 154 }
 155
 156 METHOD(imv_manager_t, destroy, void,
 157         private_tnc_imv_manager_t *this)
 158 {
 159         imv_t *imv;
 160
 161         while (this->imvs->remove_last(this->imvs, (void**)&imv) == SUCCESS)
 162         {
 163                 if (imv->terminate &&
 164                         imv->terminate(imv->get_id(imv)) != TNC_RESULT_SUCCESS)
 165                 {
 166                         DBG1(DBG_TNC, "IMV '%s' not terminated successfully",
 167                                                    imv->get_name(imv));
 168                 }
 169                 imv->destroy(imv);
 170         }
 171         this->imvs->destroy(this->imvs);
 172         free(this);
 173 }
 174
 175 /**
 176  * Described in header.
 177  */
 178 imv_manager_t* tnc_imv_manager_create(void)
 179 {
 180         private_tnc_imv_manager_t *this;
 181
 182         INIT(this,
 183                 .public = {
 184                         .add = _add,
 185                         .remove = _remove_, /* avoid name conflict with stdio.h */
 186                         .notify_connection_change = _notify_connection_change,
 187                         .set_message_types = _set_message_types,
 188                         .receive_message = _receive_message,
 189                         .destroy = _destroy,
 190         },
 191                 .imvs = linked_list_create(),
 192                 .next_imv_id = 1,
 193         );
 194
 195
 196         return &this->public;
 197 }
 198
 199