![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to imv_hcd_agent.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / libimcv / plugins / imv_hcd|
Return to imv_hcd_agent.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / libimcv / plugins / imv_hcd |
1.1 misho 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: