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
  74         return TRUE;
  75 }
  76
  77 METHOD(imv_manager_t, remove_, imv_t*,
  78         private_tnc_imv_manager_t *this, TNC_IMVID id)
  79 {
  80         enumerator_t *enumerator;
  81         imv_t *imv;
  82
  83         enumerator = this->imvs->create_enumerator(this->imvs);
  84         while (enumerator->enumerate(enumerator, &imv))
  85         {
  86                 if (id == imv->get_id(imv))
  87                 {
  88                         this->imvs->remove_at(this->imvs, enumerator);
  89                         return imv;
  90                 }
  91         }
  92         enumerator->destroy(enumerator);
  93         return NULL;
  94 }
  95
  96 METHOD(imv_manager_t, notify_connection_change, void,
  97         private_tnc_imv_manager_t *this, TNC_ConnectionID id,
  98                                                                          TNC_ConnectionState state)
  99 {
 100         enumerator_t *enumerator;
 101         imv_t *imv;
 102
 103         enumerator = this->imvs->create_enumerator(this->imvs);
 104         while (enumerator->enumerate(enumerator, &imv))
 105         {
 106                 if (imv->notify_connection_change)
 107                 {
 108                         imv->notify_connection_change(imv->get_id(imv), id, state);
 109                 }
 110         }
 111         enumerator->destroy(enumerator);
 112 }
 113
 114 METHOD(imv_manager_t, set_message_types, TNC_Result,
 115         private_tnc_imv_manager_t *this, TNC_IMVID id,
 116                                                                          TNC_MessageTypeList supported_types,
 117                                                                          TNC_UInt32 type_count)
 118 {
 119         enumerator_t *enumerator;
 120         imv_t *imv;
 121         TNC_Result result = TNC_RESULT_FATAL;
 122
 123         enumerator = this->imvs->create_enumerator(this->imvs);
 124         while (enumerator->enumerate(enumerator, &imv))
 125         {
 126                 if (id == imv->get_id(imv))
 127                 {
 128                         imv->set_message_types(imv, supported_types, type_count);
 129                         result = TNC_RESULT_SUCCESS;
 130                         break;
 131                 }
 132         }
 133         enumerator->destroy(enumerator);
 134         return result;
 135 }
 136
 137 METHOD(imv_manager_t, receive_message, void,
 138         private_tnc_imv_manager_t *this, TNC_ConnectionID connection_id,
 139                                                                          TNC_BufferReference message,
 140                                                                          TNC_UInt32 message_len,
 141                                                                          TNC_MessageType message_type)
 142 {
 143         enumerator_t *enumerator;
 144         imv_t *imv;
 145
 146         enumerator = this->imvs->create_enumerator(this->imvs);
 147         while (enumerator->enumerate(enumerator, &imv))
 148         {
 149                 if (imv->receive_message && imv->type_supported(imv, message_type))
 150                 {
 151                         imv->receive_message(imv->get_id(imv), connection_id,
 152                                                                  message, message_len, message_type);
 153                 }
 154         }
 155         enumerator->destroy(enumerator);
 156 }
 157
 158 METHOD(imv_manager_t, destroy, void,
 159         private_tnc_imv_manager_t *this)
 160 {
 161         imv_t *imv;
 162
 163         while (this->imvs->remove_last(this->imvs, (void**)&imv) == SUCCESS)
 164         {
 165                 if (imv->terminate &&
 166                         imv->terminate(imv->get_id(imv)) != TNC_RESULT_SUCCESS)
 167                 {
 168                         DBG1(DBG_TNC, "IMV '%s' not terminated successfully",
 169                                                    imv->get_name(imv));
 170                 }
 171                 imv->destroy(imv);
 172         }
 173         this->imvs->destroy(this->imvs);
 174         free(this);
 175 }
 176
 177 /**
 178  * Described in header.
 179  */
 180 imv_manager_t* tnc_imv_manager_create(void)
 181 {
 182         private_tnc_imv_manager_t *this;
 183
 184         INIT(this,
 185                 .public = {
 186                         .add = _add,
 187                         .remove = _remove_, /* avoid name conflict with stdio.h */
 188                         .notify_connection_change = _notify_connection_change,
 189                         .set_message_types = _set_message_types,
 190                         .receive_message = _receive_message,
 191                         .destroy = _destroy,
 192         },
 193                 .imvs = linked_list_create(),
 194                 .next_imv_id = 1,
 195         );
 196
 197         return &this->public;
 198 }