src/libimcv/plugins/imv_hcd/imv_hcd_agent.c

   1 /*
   2  * Copyright (C) 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 #define _GNU_SOURCE
  17 #include <stdio.h>
  18
  19 #include "imv_hcd_agent.h"
  20 #include "imv_hcd_state.h"
  21
  22 #include <imcv.h>
  23 #include <imv/imv_agent.h>
  24 #include <imv/imv_msg.h>
  25 #include <generic/generic_attr_bool.h>
  26 #include <generic/generic_attr_chunk.h>
  27 #include <generic/generic_attr_string.h>
  28 #include <ietf/ietf_attr.h>
  29 #include <ietf/ietf_attr_attr_request.h>
  30 #include <ietf/ietf_attr_fwd_enabled.h>
  31 #include <pwg/pwg_attr.h>
  32 #include <pwg/pwg_attr_vendor_smi_code.h>
  33 #include "tcg/seg/tcg_seg_attr_max_size.h"
  34 #include "tcg/seg/tcg_seg_attr_seg_env.h"
  35
  36 #include <tncif_names.h>
  37 #include <tncif_pa_subtypes.h>
  38
  39 #include <pen/pen.h>
  40 #include <utils/debug.h>
  41
  42 #define HCD_MAX_ATTR_SIZE       10000000
  43
  44 typedef struct private_imv_hcd_agent_t private_imv_hcd_agent_t;
  45
  46 /* Subscribed PA-TNC message subtypes */
  47 static pen_type_t msg_types[] = {
  48         { PEN_IETF, PA_SUBTYPE_IETF_OPERATING_SYSTEM },
  49         { PEN_PWG, PA_SUBTYPE_PWG_HCD_SYSTEM },
  50         { PEN_PWG, PA_SUBTYPE_PWG_HCD_CONSOLE },
  51         { PEN_PWG, PA_SUBTYPE_PWG_HCD_MARKER },
  52         { PEN_PWG, PA_SUBTYPE_PWG_HCD_FINISHER },
  53         { PEN_PWG, PA_SUBTYPE_PWG_HCD_INTERFACE },
  54         { PEN_PWG, PA_SUBTYPE_PWG_HCD_SCANNER }
  55 };
  56
  57 static imv_hcd_attr_t attr_type_to_flag(pwg_attr_t attr_type)
  58 {
  59         switch (attr_type)
  60         {
  61                 case PWG_HCD_DEFAULT_PWD_ENABLED:
  62                         return IMV_HCD_ATTR_DEFAULT_PWD_ENABLED;
  63                 case PWG_HCD_FIREWALL_SETTING:
  64                         return IMV_HCD_ATTR_FIREWALL_SETTING;
  65                 case PWG_HCD_FORWARDING_ENABLED:
  66                         return IMV_HCD_ATTR_FORWARDING_ENABLED;
  67                 case PWG_HCD_MACHINE_TYPE_MODEL:
  68                         return IMV_HCD_ATTR_MACHINE_TYPE_MODEL;
  69                 case PWG_HCD_PSTN_FAX_ENABLED:
  70                         return IMV_HCD_ATTR_PSTN_FAX_ENABLED;
  71                 case PWG_HCD_TIME_SOURCE:
  72                         return IMV_HCD_ATTR_TIME_SOURCE;
  73                 case PWG_HCD_USER_APP_ENABLED:
  74                         return IMV_HCD_ATTR_USER_APP_ENABLED;
  75                 case PWG_HCD_USER_APP_PERSIST_ENABLED:
  76                         return IMV_HCD_ATTR_USER_APP_PERSIST_ENABLED;
  77                 case PWG_HCD_VENDOR_NAME:
  78                         return IMV_HCD_ATTR_VENDOR_NAME;
  79                 case PWG_HCD_VENDOR_SMI_CODE:
  80                         return IMV_HCD_ATTR_VENDOR_SMI_CODE;
  81                 case PWG_HCD_CERTIFICATION_STATE:
  82                         return IMV_HCD_ATTR_CERTIFICATION_STATE;
  83                 case PWG_HCD_CONFIGURATION_STATE:
  84                         return IMV_HCD_ATTR_CONFIGURATION_STATE;
  85                 case PWG_HCD_ATTRS_NATURAL_LANG:
  86                         return IMV_HCD_ATTR_NATURAL_LANG;
  87                 case PWG_HCD_FIRMWARE_NAME:
  88                         return IMV_HCD_ATTR_FIRMWARE_NAME;
  89                 case PWG_HCD_RESIDENT_APP_NAME:
  90                         return IMV_HCD_ATTR_RESIDENT_APP_NAME;
  91                 case PWG_HCD_USER_APP_NAME:
  92                         return IMV_HCD_ATTR_USER_APP_NAME;
  93                 default:
  94                         return IMV_HCD_ATTR_NONE;
  95         }
  96 }
  97
  98 /**
  99  * Private data of an imv_hcd_agent_t object.
 100  */
 101 struct private_imv_hcd_agent_t {
 102
 103         /**
 104          * Public members of imv_hcd_agent_t
 105          */
 106         imv_agent_if_t public;
 107
 108         /**
 109          * IMV agent responsible for generic functions
 110          */
 111         imv_agent_t *agent;
 112
 113 };
 114
 115 METHOD(imv_agent_if_t, bind_functions, TNC_Result,
 116         private_imv_hcd_agent_t *this, TNC_TNCS_BindFunctionPointer bind_function)
 117 {
 118         return this->agent->bind_functions(this->agent, bind_function);
 119 }
 120
 121 METHOD(imv_agent_if_t, notify_connection_change, TNC_Result,
 122         private_imv_hcd_agent_t *this, TNC_ConnectionID id,
 123         TNC_ConnectionState new_state)
 124 {
 125         TNC_IMV_Action_Recommendation rec;
 126         imv_state_t *state;
 127         imv_session_t *session;
 128
 129         switch (new_state)
 130         {
 131                 case TNC_CONNECTION_STATE_CREATE:
 132                         state = imv_hcd_state_create(id);
 133                         return this->agent->create_state(this->agent, state);
 134                 case TNC_CONNECTION_STATE_DELETE:
 135                         return this->agent->delete_state(this->agent, id);
 136                 case TNC_CONNECTION_STATE_ACCESS_ALLOWED:
 137                 case TNC_CONNECTION_STATE_ACCESS_ISOLATED:
 138                 case TNC_CONNECTION_STATE_ACCESS_NONE:
 139                         if (this->agent->get_state(this->agent, id, &state) && imcv_db)
 140                         {
 141                                 session = state->get_session(state);
 142
 143                                 if (session->get_policy_started(session))
 144                                 {
 145                                         switch (new_state)
 146                                         {
 147                                                 case TNC_CONNECTION_STATE_ACCESS_ALLOWED:
 148                                                         rec = TNC_IMV_ACTION_RECOMMENDATION_ALLOW;
 149                                                         break;
 150                                                 case TNC_CONNECTION_STATE_ACCESS_ISOLATED:
 151                                                         rec = TNC_IMV_ACTION_RECOMMENDATION_ISOLATE;
 152                                                         break;
 153                                                 case TNC_CONNECTION_STATE_ACCESS_NONE:
 154                                                 default:
 155                                                         rec = TNC_IMV_ACTION_RECOMMENDATION_NO_ACCESS;
 156                                         }
 157                                         imcv_db->add_recommendation(imcv_db, session, rec);
 158                                         if (!imcv_db->policy_script(imcv_db, session, FALSE))
 159                                         {
 160                                                 DBG1(DBG_IMV, "error in policy script stop");
 161                                         }
 162                                 }
 163                         }
 164                         /* fall through to default state */
 165                 default:
 166                         return this->agent->change_state(this->agent, id, new_state, NULL);
 167         }
 168 }
 169
 170 /**
 171  * Process a received message
 172  */
 173 static TNC_Result receive_msg(private_imv_hcd_agent_t *this, imv_state_t *state,
 174                                                           imv_msg_t *in_msg)
 175 {
 176         imv_msg_t *out_msg;
 177         imv_hcd_state_t *hcd_state;
 178         pa_tnc_attr_t *attr;
 179         enum_name_t *pa_subtype_names;
 180         pen_type_t type, msg_type;
 181         TNC_Result result;
 182         bool fatal_error = FALSE, assessment = FALSE;
 183         enumerator_t *enumerator;
 184
 185         hcd_state = (imv_hcd_state_t*)state;
 186
 187         /* generate an outgoing PA-TNC message - we might need it */
 188         out_msg = imv_msg_create_as_reply(in_msg);
 189
 190         /* parse received PA-TNC message and handle local and remote errors */
 191         result = in_msg->receive(in_msg,out_msg, &fatal_error);
 192         if (result != TNC_RESULT_SUCCESS)
 193         {
 194                 out_msg->destroy(out_msg);
 195                 return result;
 196         }
 197         msg_type = in_msg->get_msg_type(in_msg);
 198         pa_subtype_names = get_pa_subtype_names(msg_type.vendor_id);
 199         DBG2(DBG_IMV, "received attributes for PA subtype %N/%N",
 200                  pen_names, msg_type.vendor_id, pa_subtype_names, msg_type.type);
 201
 202         /* set current subtype */
 203         if (msg_type.vendor_id == PEN_IETF)
 204         {
 205                 hcd_state->set_subtype(hcd_state, PA_SUBTYPE_PWG_HCD_SYSTEM);
 206         }
 207         else
 208         {
 209                 hcd_state->set_subtype(hcd_state, msg_type.type);
 210         }
 211
 212         /* analyze PA-TNC attributes */
 213         enumerator = in_msg->create_attribute_enumerator(in_msg);
 214         while (enumerator->enumerate(enumerator, &attr))
 215         {
 216                 type = attr->get_type(attr);
 217
 218                 if (type.vendor_id == PEN_IETF)
 219                 {
 220                         switch (type.type)
 221                         {
 222                                 case IETF_ATTR_FORWARDING_ENABLED:
 223                                 {
 224                                         ietf_attr_fwd_enabled_t *attr_cast;
 225                                         os_fwd_status_t fwd_status;
 226
 227                                         attr_cast = (ietf_attr_fwd_enabled_t*)attr;
 228                                         fwd_status = attr_cast->get_status(attr_cast);
 229                                         DBG2(DBG_IMV, "  %N: %N", ietf_attr_names, type.type,
 230                                                                    os_fwd_status_names, fwd_status);
 231                                         state->set_action_flags(state,
 232                                                                                         IMV_HCD_ATTR_FORWARDING_ENABLED);
 233                                         break;
 234                                 }
 235                                 case IETF_ATTR_FACTORY_DEFAULT_PWD_ENABLED:
 236                                 {
 237                                         generic_attr_bool_t *attr_cast;
 238                                         bool status;
 239
 240                                         attr_cast = (generic_attr_bool_t*)attr;
 241                                         status = attr_cast->get_status(attr_cast);
 242                                         DBG2(DBG_IMV, "  %N: %s", ietf_attr_names, type.type,
 243                                                                    status ? "yes" : "no");
 244                                         state->set_action_flags(state,
 245                                                                                         IMV_HCD_ATTR_DEFAULT_PWD_ENABLED);
 246                                         break;
 247                                 }
 248                                 default:
 249                                         break;
 250                         }
 251                 }
 252                 else if (type.vendor_id == PEN_PWG)
 253                 {
 254                         state->set_action_flags(state, attr_type_to_flag(type.type));
 255
 256                         switch (type.type)
 257                         {
 258                                 case PWG_HCD_ATTRS_NATURAL_LANG:
 259                                 case PWG_HCD_MACHINE_TYPE_MODEL:
 260                                 case PWG_HCD_VENDOR_NAME:
 261                                 case PWG_HCD_TIME_SOURCE:
 262                                 case PWG_HCD_FIRMWARE_NAME:
 263                                 case PWG_HCD_FIRMWARE_STRING_VERSION:
 264                                 case PWG_HCD_RESIDENT_APP_NAME:
 265                                 case PWG_HCD_RESIDENT_APP_STRING_VERSION:
 266                                 case PWG_HCD_USER_APP_NAME:
 267                                 case PWG_HCD_USER_APP_STRING_VERSION:
 268                                 {
 269                                         chunk_t value;
 270
 271                                         value = attr->get_value(attr);
 272                                         DBG2(DBG_IMV, "  %N: %.*s", pwg_attr_names, type.type,
 273                                                                   value.len, value.ptr);
 274                                         break;
 275                                 }
 276                                 case PWG_HCD_FIRMWARE_PATCHES:
 277                                 case PWG_HCD_RESIDENT_APP_PATCHES:
 278                                 case PWG_HCD_USER_APP_PATCHES:
 279                                 {
 280                                         chunk_t value;
 281                                         size_t len;
 282
 283                                         value = attr->get_value(attr);
 284                                         len = value.len;
 285
 286                                         /* remove any trailing LF from patches string */
 287                                         if (len && (value.ptr[len - 1] == '\n'))
 288                                         {
 289                                                 len--;
 290                                         }
 291                                         DBG2(DBG_IMV, "  %N:%s%.*s", pwg_attr_names, type.type,
 292                                                                   len ? "\n" : " ", len, value.ptr);
 293                                         break;
 294                                 }
 295                                 case PWG_HCD_FIRMWARE_VERSION:
 296                                 case PWG_HCD_RESIDENT_APP_VERSION:
 297                                 case PWG_HCD_USER_APP_VERSION:
 298                                 {
 299                                         chunk_t value;
 300
 301                                         value = attr->get_value(attr);
 302                                         DBG2(DBG_IMV, "  %N: %#B", pwg_attr_names, type.type, &value);
 303                                         break;
 304                                 }
 305                                 case PWG_HCD_CERTIFICATION_STATE:
 306                                 case PWG_HCD_CONFIGURATION_STATE:
 307                                 {
 308                                         chunk_t value;
 309
 310                                         value = attr->get_value(attr);
 311                                         DBG2(DBG_IMV, "  %N: %B", pwg_attr_names, type.type, &value);
 312                                         break;
 313                                 }
 314                                 case PWG_HCD_DEFAULT_PWD_ENABLED:
 315                                 case PWG_HCD_PSTN_FAX_ENABLED:
 316                                 case PWG_HCD_USER_APP_ENABLED:
 317                                 case PWG_HCD_USER_APP_PERSIST_ENABLED:
 318                                 {
 319                                         generic_attr_bool_t *attr_cast;
 320                                         bool status;
 321
 322                                         attr_cast = (generic_attr_bool_t*)attr;
 323                                         status = attr_cast->get_status(attr_cast);
 324                                         DBG2(DBG_IMV, "  %N: %s", pwg_attr_names, type.type,
 325                                                                   status ? "yes" : "no");
 326
 327                                         if (type.type == PWG_HCD_USER_APP_ENABLED && !status)
 328                                         {
 329                                                 /* do not request user applications */
 330                                                 hcd_state->set_user_app_disabled(hcd_state);
 331                                         }
 332                                         break;
 333                                 }
 334                                 case PWG_HCD_FORWARDING_ENABLED:
 335                                 {
 336                                         ietf_attr_fwd_enabled_t *attr_cast;
 337                                         os_fwd_status_t fwd_status;
 338
 339                                         attr_cast = (ietf_attr_fwd_enabled_t*)attr;
 340                                         fwd_status = attr_cast->get_status(attr_cast);
 341                                         DBG2(DBG_IMV, "  %N: %N", pwg_attr_names, type.type,
 342                                                                   os_fwd_status_names, fwd_status);
 343                                         break;
 344                                 }
 345
 346                                 case PWG_HCD_VENDOR_SMI_CODE:
 347                                 {
 348                                         pwg_attr_vendor_smi_code_t *attr_cast;
 349                                         uint32_t smi_code;
 350
 351                                         attr_cast = (pwg_attr_vendor_smi_code_t*)attr;
 352                                         smi_code = attr_cast->get_vendor_smi_code(attr_cast);
 353                                         DBG2(DBG_IMV, "  %N: 0x%06x (%u)", pwg_attr_names, type.type,
 354                                                                   smi_code, smi_code);
 355                                         break;
 356                                 }
 357                                 default:
 358                                         break;
 359                         }
 360                 }
 361         }
 362         enumerator->destroy(enumerator);
 363
 364         if (fatal_error)
 365         {
 366                 state->set_recommendation(state,
 367                                                                 TNC_IMV_ACTION_RECOMMENDATION_NO_RECOMMENDATION,
 368                                                                 TNC_IMV_EVALUATION_RESULT_ERROR);
 369                 assessment = TRUE;
 370         }
 371
 372         if (assessment)
 373         {
 374                 hcd_state->set_handshake_state(hcd_state, IMV_HCD_STATE_END);
 375                 result = out_msg->send_assessment(out_msg);
 376                 if (result == TNC_RESULT_SUCCESS)
 377                 {
 378                         result = this->agent->provide_recommendation(this->agent, state);
 379                 }
 380         }
 381         else
 382         {
 383                 /* send PA-TNC message with the EXCL flag set */
 384                 result = out_msg->send(out_msg, TRUE);
 385         }
 386         out_msg->destroy(out_msg);
 387
 388         return result;
 389 }
 390
 391 METHOD(imv_agent_if_t, receive_message, TNC_Result,
 392         private_imv_hcd_agent_t *this, TNC_ConnectionID id,
 393         TNC_MessageType msg_type, chunk_t msg)
 394 {
 395         imv_state_t *state;
 396         imv_msg_t *in_msg;
 397         TNC_Result result;
 398
 399         if (!this->agent->get_state(this->agent, id, &state))
 400         {
 401                 return TNC_RESULT_FATAL;
 402         }
 403         in_msg = imv_msg_create_from_data(this->agent, state, id, msg_type, msg);
 404         result = receive_msg(this, state, in_msg);
 405         in_msg->destroy(in_msg);
 406
 407         return result;
 408 }
 409
 410 METHOD(imv_agent_if_t, receive_message_long, TNC_Result,
 411         private_imv_hcd_agent_t *this, TNC_ConnectionID id,
 412         TNC_UInt32 src_imc_id, TNC_UInt32 dst_imv_id,
 413         TNC_VendorID msg_vid, TNC_MessageSubtype msg_subtype, chunk_t msg)
 414 {
 415         imv_state_t *state;
 416         imv_msg_t *in_msg;
 417         TNC_Result result;
 418
 419         if (!this->agent->get_state(this->agent, id, &state))
 420         {
 421                 return TNC_RESULT_FATAL;
 422         }
 423         in_msg = imv_msg_create_from_long_data(this->agent, state, id,
 424                                         src_imc_id, dst_imv_id, msg_vid, msg_subtype, msg);
 425         result = receive_msg(this, state, in_msg);
 426         in_msg->destroy(in_msg);
 427
 428         return result;
 429
 430 }
 431
 432 /**
 433  * Build an IETF Attribute Request attribute for missing attributes
 434  */
 435 static pa_tnc_attr_t* build_attr_request(uint32_t received)
 436 {
 437         pa_tnc_attr_t *attr;
 438         ietf_attr_attr_request_t *attr_cast;
 439
 440         attr = ietf_attr_attr_request_create(PEN_RESERVED, 0);
 441         attr_cast = (ietf_attr_attr_request_t*)attr;
 442
 443         if (!(received & IMV_HCD_ATTR_NATURAL_LANG))
 444         {
 445                 attr_cast->add(attr_cast, PEN_PWG, PWG_HCD_ATTRS_NATURAL_LANG);
 446         }
 447         if (!(received & IMV_HCD_ATTR_DEFAULT_PWD_ENABLED))
 448         {
 449                 attr_cast->add(attr_cast, PEN_PWG, PWG_HCD_DEFAULT_PWD_ENABLED);
 450         }
 451         if (!(received & IMV_HCD_ATTR_FIREWALL_SETTING))
 452         {
 453                 attr_cast->add(attr_cast, PEN_PWG, PWG_HCD_FIREWALL_SETTING);
 454         }
 455         if (!(received & IMV_HCD_ATTR_FIRMWARE_NAME))
 456         {
 457                 attr_cast->add(attr_cast, PEN_PWG, PWG_HCD_FIRMWARE_NAME);
 458         }
 459         if (!(received & IMV_HCD_ATTR_FORWARDING_ENABLED))
 460         {
 461                 attr_cast->add(attr_cast, PEN_PWG, PWG_HCD_FORWARDING_ENABLED);
 462         }
 463         if (!(received & IMV_HCD_ATTR_MACHINE_TYPE_MODEL))
 464         {
 465                 attr_cast->add(attr_cast, PEN_PWG, PWG_HCD_MACHINE_TYPE_MODEL);
 466         }
 467         if (!(received & IMV_HCD_ATTR_PSTN_FAX_ENABLED))
 468         {
 469                 attr_cast->add(attr_cast, PEN_PWG, PWG_HCD_PSTN_FAX_ENABLED);
 470         }
 471         if (!(received & IMV_HCD_ATTR_RESIDENT_APP_NAME))
 472         {
 473                 attr_cast->add(attr_cast, PEN_PWG, PWG_HCD_RESIDENT_APP_NAME);
 474         }
 475         if (!(received & IMV_HCD_ATTR_TIME_SOURCE))
 476         {
 477                 attr_cast->add(attr_cast, PEN_PWG, PWG_HCD_TIME_SOURCE);
 478         }
 479         if (!(received & IMV_HCD_ATTR_USER_APP_ENABLED))
 480         {
 481                 attr_cast->add(attr_cast, PEN_PWG, PWG_HCD_USER_APP_ENABLED);
 482         }
 483         if (!(received & IMV_HCD_ATTR_USER_APP_PERSIST_ENABLED))
 484         {
 485                 attr_cast->add(attr_cast, PEN_PWG, PWG_HCD_USER_APP_PERSIST_ENABLED);
 486         }
 487         if (!(received & IMV_HCD_ATTR_USER_APP_NAME))
 488         {
 489                 attr_cast->add(attr_cast, PEN_PWG, PWG_HCD_USER_APP_NAME);
 490         }
 491         if (!(received & IMV_HCD_ATTR_VENDOR_NAME))
 492         {
 493                 attr_cast->add(attr_cast, PEN_PWG, PWG_HCD_VENDOR_NAME);
 494         }
 495         if (!(received & IMV_HCD_ATTR_VENDOR_SMI_CODE))
 496         {
 497                 attr_cast->add(attr_cast, PEN_PWG, PWG_HCD_VENDOR_SMI_CODE);
 498         }
 499         if (!(received & IMV_HCD_ATTR_CERTIFICATION_STATE))
 500         {
 501                 attr_cast->add(attr_cast, PEN_PWG, PWG_HCD_CERTIFICATION_STATE);
 502         }
 503         if (!(received & IMV_HCD_ATTR_CONFIGURATION_STATE))
 504         {
 505                 attr_cast->add(attr_cast, PEN_PWG, PWG_HCD_CONFIGURATION_STATE);
 506         }
 507         return attr;
 508 }
 509
 510 METHOD(imv_agent_if_t, batch_ending, TNC_Result,
 511         private_imv_hcd_agent_t *this, TNC_ConnectionID id)
 512 {
 513         imv_msg_t *out_msg;
 514         imv_state_t *state;
 515         imv_hcd_state_t *hcd_state;
 516         imv_hcd_handshake_state_t handshake_state;
 517         pa_tnc_attr_t *attr;
 518         TNC_IMVID imv_id;
 519         TNC_Result result = TNC_RESULT_SUCCESS;
 520
 521         if (!this->agent->get_state(this->agent, id, &state))
 522         {
 523                 return TNC_RESULT_FATAL;
 524         }
 525         hcd_state = (imv_hcd_state_t*)state;
 526         handshake_state = hcd_state->get_handshake_state(hcd_state);
 527         imv_id = this->agent->get_id(this->agent);
 528
 529         if (handshake_state == IMV_HCD_STATE_END)
 530         {
 531                 return TNC_RESULT_SUCCESS;
 532         }
 533
 534         if (handshake_state == IMV_HCD_STATE_INIT)
 535         {
 536                 size_t max_attr_size = HCD_MAX_ATTR_SIZE;
 537                 size_t max_seg_size;
 538                 seg_contract_t *contract;
 539                 seg_contract_manager_t *contracts;
 540                 char buf[BUF_LEN];
 541                 uint32_t received;
 542                 int i;
 543
 544                 /* Determine maximum PA-TNC attribute segment size */
 545                 max_seg_size = state->get_max_msg_len(state)
 546                                                                 - PA_TNC_HEADER_SIZE
 547                                                                 - PA_TNC_ATTR_HEADER_SIZE
 548                                                                 - TCG_SEG_ATTR_SEG_ENV_HEADER
 549                                                                 - PA_TNC_ATTR_HEADER_SIZE
 550                                                                 - TCG_SEG_ATTR_MAX_SIZE_SIZE;
 551                 contracts = state->get_contracts(state);
 552
 553                 for (i = 1; i < countof(msg_types); i++)
 554                 {
 555                         out_msg = imv_msg_create(this->agent, state, id, imv_id,
 556                                                                          TNC_IMCID_ANY, msg_types[i]);
 557
 558                         /* Announce support of PA-TNC segmentation to IMC */
 559                         contract = seg_contract_create(msg_types[i], max_attr_size,
 560                                                                                    max_seg_size, TRUE, imv_id, FALSE);
 561                         contract->get_info_string(contract, buf, BUF_LEN, TRUE);
 562                         DBG2(DBG_IMV, "%s", buf);
 563                         contracts->add_contract(contracts, contract);
 564                         attr = tcg_seg_attr_max_size_create(max_attr_size, max_seg_size,
 565                                                                                                 TRUE);
 566                         out_msg->add_attribute(out_msg, attr);
 567
 568                         hcd_state->set_subtype(hcd_state, msg_types[i].type);
 569                         received = state->get_action_flags(state);
 570
 571                         if ((received & IMV_HCD_ATTR_MUST) != IMV_HCD_ATTR_MUST)
 572                         {
 573                                 /* create attribute request for missing mandatory attributes */
 574                                 out_msg->add_attribute(out_msg, build_attr_request(received));
 575                         }
 576                         result = out_msg->send(out_msg, FALSE);
 577                         out_msg->destroy(out_msg);
 578
 579                         if (result != TNC_RESULT_SUCCESS)
 580                         {
 581                                 break;
 582                         }
 583                 }
 584                 hcd_state->set_handshake_state(hcd_state, IMV_HCD_STATE_ATTR_REQ);
 585         }
 586
 587         return result;
 588 }
 589
 590 METHOD(imv_agent_if_t, solicit_recommendation, TNC_Result,
 591         private_imv_hcd_agent_t *this, TNC_ConnectionID id)
 592 {
 593         imv_state_t *state;
 594         imv_hcd_state_t* hcd_state;
 595         imv_hcd_handshake_state_t handshake_state;
 596         enum_name_t *pa_subtype_names;
 597         bool missing = FALSE;
 598         uint32_t received;
 599         int i;
 600
 601         if (!this->agent->get_state(this->agent, id, &state))
 602         {
 603                 return TNC_RESULT_FATAL;
 604         }
 605         hcd_state = (imv_hcd_state_t*)state;
 606         handshake_state = hcd_state->get_handshake_state(hcd_state);
 607
 608         if (handshake_state == IMV_HCD_STATE_ATTR_REQ)
 609         {
 610                 pa_subtype_names = get_pa_subtype_names(PEN_PWG);
 611
 612                 for (i = 1; i < countof(msg_types); i++)
 613                 {
 614                         hcd_state->set_subtype(hcd_state, msg_types[i].type);
 615                         received = state->get_action_flags(state);
 616                         if ((received & IMV_HCD_ATTR_MUST) != IMV_HCD_ATTR_MUST)
 617                         {
 618                                 DBG1(DBG_IMV, "missing attributes for PA subtype %N/%N",
 619                                          pen_names, PEN_PWG, pa_subtype_names, msg_types[i].type);
 620                                 missing = TRUE;
 621                         }
 622                 }
 623
 624                 if (missing)
 625                 {
 626                         state->set_recommendation(state,
 627                                                         TNC_IMV_ACTION_RECOMMENDATION_NO_ACCESS ,
 628                                                         TNC_IMV_EVALUATION_RESULT_NONCOMPLIANT_MAJOR);
 629                 }
 630                 else
 631                 {
 632                         state->set_recommendation(state,
 633                                                         TNC_IMV_ACTION_RECOMMENDATION_ALLOW ,
 634                                                         TNC_IMV_EVALUATION_RESULT_COMPLIANT);
 635                 }
 636         }
 637         hcd_state->set_handshake_state(hcd_state, IMV_HCD_STATE_END);
 638
 639         return this->agent->provide_recommendation(this->agent, state);
 640 }
 641
 642 METHOD(imv_agent_if_t, destroy, void,
 643         private_imv_hcd_agent_t *this)
 644 {
 645         DESTROY_IF(this->agent);
 646         free(this);
 647 }
 648
 649 /**
 650  * Described in header.
 651  */
 652 imv_agent_if_t *imv_hcd_agent_create(const char *name, TNC_IMVID id,
 653                                                                         TNC_Version *actual_version)
 654 {
 655         private_imv_hcd_agent_t *this;
 656         imv_agent_t *agent;
 657
 658         agent = imv_agent_create(name, msg_types, countof(msg_types), id,
 659                                                          actual_version);
 660         if (!agent)
 661         {
 662                 return NULL;
 663         }
 664
 665         INIT(this,
 666                 .public = {
 667                         .bind_functions = _bind_functions,
 668                         .notify_connection_change = _notify_connection_change,
 669                         .receive_message = _receive_message,
 670                         .receive_message_long = _receive_message_long,
 671                         .batch_ending = _batch_ending,
 672                         .solicit_recommendation = _solicit_recommendation,
 673                         .destroy = _destroy,
 674                 },
 675                 .agent = agent,
 676         );
 677
 678         return &this->public;
 679 }
 680