Annotation of embedaddon/strongswan/src/libimcv/suites/test_imcv_swima.c, revision 1.1
1.1 ! misho 1: /*
! 2: * Copyright (C) 2017-2018 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: #include "test_suite.h"
! 17:
! 18: #include "swima/swima_record.h"
! 19: #include "swima/swima_data_model.h"
! 20: #include "swima/swima_inventory.h"
! 21: #include "swima/swima_event.h"
! 22: #include "swima/swima_events.h"
! 23: #include "swima/swima_collector.h"
! 24: #include "ietf/swima/ietf_swima_attr_req.h"
! 25: #include "ietf/swima/ietf_swima_attr_sw_inv.h"
! 26: #include "ietf/swima/ietf_swima_attr_sw_ev.h"
! 27:
! 28: static pen_type_t ita_data_model = { PEN_ITA, 0x19 };
! 29:
! 30: static char* sw_id_str[] = {
! 31: "strongswan.org_strongSwan_5.3.3",
! 32: "strongswan.org_62251aa6-1a01-479b-aea6-f3dcf0ab1f1a"
! 33: };
! 34: static char sw_locator_str[] = "/usr/share/strongswan";
! 35:
! 36: static char* sw_record_str[] = {
! 37: "<SoftwareIdentity tagId=\"abc\"></SoftwareIdentity>",
! 38: "<SoftwareIdentity tagId=\"def\"></SoftwareIdentity>"
! 39: };
! 40:
! 41: START_TEST(test_imcv_swima_record)
! 42: {
! 43: chunk_t sw_id, sw_locator, locator;
! 44: swima_record_t *sw_record, *sw_record_cp;
! 45: uint32_t record_id = 1;
! 46: uint8_t source_id = 2;
! 47: chunk_t record = chunk_from_str(sw_record_str[0]);
! 48:
! 49: sw_id = chunk_from_str(sw_id_str[0]);
! 50: sw_locator = chunk_from_str(sw_locator_str);
! 51:
! 52: /* Software Identity with Software Locator */
! 53: sw_record = swima_record_create(record_id, sw_id, sw_locator),
! 54: ck_assert(sw_record);
! 55: sw_record_cp = sw_record->get_ref(sw_record);
! 56:
! 57: ck_assert(record_id == sw_record->get_record_id(sw_record));
! 58: ck_assert_chunk_eq(sw_id, sw_record->get_sw_id(sw_record, NULL));
! 59: ck_assert_chunk_eq(sw_id, sw_record->get_sw_id(sw_record, &locator));
! 60: ck_assert_chunk_eq(locator, sw_locator);
! 61:
! 62: sw_record->set_data_model(sw_record, ita_data_model);
! 63: ck_assert(pen_type_equals(sw_record->get_data_model(sw_record),
! 64: ita_data_model));
! 65:
! 66: sw_record->set_source_id(sw_record, source_id);
! 67: ck_assert(source_id == sw_record->get_source_id(sw_record));
! 68:
! 69: sw_record->set_record(sw_record, record);
! 70: ck_assert_chunk_eq(record, sw_record->get_record(sw_record));
! 71:
! 72: sw_record->destroy(sw_record);
! 73: sw_record_cp->destroy(sw_record);
! 74:
! 75: /* Software Identity without Software Locator */
! 76: sw_record = swima_record_create(record_id, sw_id, chunk_empty),
! 77: ck_assert(sw_record);
! 78: ck_assert_chunk_eq(sw_id, sw_record->get_sw_id(sw_record, &locator));
! 79: ck_assert(locator.ptr == NULL && locator.len == 0);
! 80:
! 81: ck_assert(pen_type_equals(swima_data_model_iso_2015_swid_xml,
! 82: sw_record->get_data_model(sw_record)));
! 83:
! 84: sw_record->destroy(sw_record);
! 85: }
! 86: END_TEST
! 87:
! 88: typedef struct req_data_t req_data_t;
! 89:
! 90: struct req_data_t {
! 91: uint8_t flags;
! 92: uint32_t request_id;
! 93: uint32_t earliest_eid;
! 94: uint32_t sw_id_count;
! 95: chunk_t value;
! 96: };
! 97:
! 98: static req_data_t req_data[] = {
! 99: { IETF_SWIMA_ATTR_REQ_FLAG_NONE, 1, 0, 0, chunk_from_chars(
! 100: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
! 101: 0x00, 0x00)
! 102: },
! 103: { IETF_SWIMA_ATTR_REQ_FLAG_R, 2, 15, 1, chunk_from_chars(
! 104: 0x20, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
! 105: 0x00, 0x0F, 0x00, 0x1f, 0x73, 0x74, 0x72, 0x6f, 0x6e, 0x67,
! 106: 0x73, 0x77, 0x61, 0x6e, 0x2e, 0x6f, 0x72, 0x67, 0x5f, 0x73,
! 107: 0x74, 0x72, 0x6f, 0x6e, 0x67, 0x53, 0x77, 0x61, 0x6e, 0x5f,
! 108: 0x35, 0x2e, 0x33, 0x2e, 0x33)
! 109: },
! 110: { IETF_SWIMA_ATTR_REQ_FLAG_S, 3, 256, 2, chunk_from_chars(
! 111: 0x40, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
! 112: 0x01, 0x00, 0x00, 0x1f, 0x73, 0x74, 0x72, 0x6f, 0x6e, 0x67,
! 113: 0x73, 0x77, 0x61, 0x6e, 0x2e, 0x6f, 0x72, 0x67, 0x5f, 0x73,
! 114: 0x74, 0x72, 0x6f, 0x6e, 0x67, 0x53, 0x77, 0x61, 0x6e, 0x5f,
! 115: 0x35, 0x2e, 0x33, 0x2e, 0x33, 0x00, 0x33, 0x73, 0x74, 0x72,
! 116: 0x6f, 0x6e, 0x67, 0x73, 0x77, 0x61, 0x6e, 0x2e, 0x6f, 0x72,
! 117: 0x67, 0x5f, 0x36, 0x32, 0x32, 0x35, 0x31, 0x61, 0x61, 0x36,
! 118: 0x2d, 0x31, 0x61, 0x30, 0x31, 0x2d, 0x34, 0x37, 0x39, 0x62,
! 119: 0x2d, 0x61, 0x65, 0x61, 0x36, 0x2d, 0x66, 0x33, 0x64, 0x63,
! 120: 0x66, 0x30, 0x61, 0x62, 0x31, 0x66, 0x31, 0x61)
! 121: },
! 122: };
! 123:
! 124: START_TEST(test_imcv_swima_sw_req)
! 125: {
! 126: pen_type_t type;
! 127: pen_type_t pen_type = { PEN_IETF, IETF_ATTR_SWIMA_REQUEST };
! 128: pa_tnc_attr_t *attr, *attr1, *attr2;
! 129: ietf_swima_attr_req_t *c_attr;
! 130: swima_record_t *target;
! 131: swima_inventory_t *targets;
! 132: chunk_t sw_id, value;
! 133: enumerator_t *enumerator;
! 134: uint32_t offset;
! 135: int n;
! 136:
! 137: attr = ietf_swima_attr_req_create(req_data[_i].flags,
! 138: req_data[_i].request_id);
! 139: ck_assert(attr);
! 140:
! 141: type = attr->get_type(attr);
! 142: ck_assert(pen_type_equals(type, pen_type));
! 143:
! 144: ck_assert(attr->get_noskip_flag(attr) == FALSE);
! 145: attr->set_noskip_flag(attr, TRUE);
! 146: ck_assert(attr->get_noskip_flag(attr) == TRUE);
! 147:
! 148: targets = swima_inventory_create();
! 149: targets->set_eid(targets, req_data[_i].earliest_eid, 0);
! 150:
! 151: for (n = 0; n < req_data[_i].sw_id_count; n++)
! 152: {
! 153: sw_id = chunk_from_str(sw_id_str[n]);
! 154: target = swima_record_create(0, sw_id, chunk_empty);
! 155: targets->add(targets, target);
! 156: }
! 157: c_attr = (ietf_swima_attr_req_t*)attr;
! 158: c_attr->set_targets(c_attr, targets);
! 159: c_attr->set_targets(c_attr, targets);
! 160: targets->destroy(targets);
! 161:
! 162: attr->build(attr);
! 163: attr->build(attr);
! 164: value = attr->get_value(attr);
! 165: ck_assert_chunk_eq(value, req_data[_i].value);
! 166:
! 167: attr1 = attr->get_ref(attr);
! 168: attr->destroy(attr);
! 169:
! 170: attr2 = ietf_swima_attr_req_create_from_data(value.len, value);
! 171: ck_assert(attr2);
! 172:
! 173: attr1->destroy(attr1);
! 174: ck_assert(attr2->process(attr2, &offset) == SUCCESS);
! 175:
! 176: type = attr2->get_type(attr2);
! 177: ck_assert(pen_type_equals(type, pen_type));
! 178:
! 179: c_attr = (ietf_swima_attr_req_t*)attr2;
! 180: ck_assert(c_attr->get_flags(c_attr) == req_data[_i].flags);
! 181: ck_assert(c_attr->get_request_id(c_attr) == req_data[_i].request_id);
! 182:
! 183: targets = c_attr->get_targets(c_attr);
! 184: ck_assert(targets->get_eid(targets, NULL) == req_data[_i].earliest_eid);
! 185:
! 186: enumerator = targets->create_enumerator(targets);
! 187: ck_assert(enumerator);
! 188: n = 0;
! 189: while (enumerator->enumerate(enumerator, &target))
! 190: {
! 191: sw_id = target->get_sw_id(target, NULL);
! 192: ck_assert(chunk_equals(sw_id, chunk_from_str(sw_id_str[n++])));
! 193: }
! 194: enumerator->destroy(enumerator);
! 195:
! 196: attr2->destroy(attr2);
! 197: }
! 198: END_TEST
! 199:
! 200: START_TEST(test_imcv_swima_sw_req_trunc)
! 201: {
! 202: pa_tnc_attr_t *attr;
! 203: chunk_t data;
! 204: uint32_t offset = 100;
! 205:
! 206: /* Data smaller than minimum size */
! 207: attr = ietf_swima_attr_req_create_from_data(0, chunk_empty);
! 208: ck_assert(attr);
! 209: ck_assert(attr->process(attr, &offset) == FAILED && offset == 0);
! 210: attr->destroy(attr);
! 211:
! 212: /* Truncate first SW ID */
! 213: data = req_data[2].value;
! 214: data.len = 14;
! 215: attr = ietf_swima_attr_req_create_from_data(data.len, data);
! 216: ck_assert(attr);
! 217: ck_assert(attr->process(attr, &offset) == FAILED && offset == 12);
! 218: attr->destroy(attr);
! 219:
! 220: /* Truncate second SW ID */
! 221: data = req_data[2].value;
! 222: data.len = 47;
! 223: attr = ietf_swima_attr_req_create_from_data(data.len, data);
! 224: ck_assert(attr);
! 225: ck_assert(attr->process(attr, &offset) == FAILED && offset == 45);
! 226: attr->destroy(attr);
! 227:
! 228: /* Segmentation */
! 229: data = req_data[2].value;
! 230: data.len = 50;
! 231: attr = ietf_swima_attr_req_create_from_data(req_data[2].value.len, data);
! 232: ck_assert(attr);
! 233: ck_assert(attr->process(attr, &offset) == NEED_MORE);
! 234: data = chunk_skip(req_data[2].value, 50);
! 235: attr->add_segment(attr, data);
! 236: ck_assert(attr->process(attr, &offset) == SUCCESS);
! 237: attr->destroy(attr);
! 238: }
! 239: END_TEST
! 240:
! 241: static pen_type_t sw_inv_types[] = {
! 242: { PEN_IETF, IETF_ATTR_SW_INVENTORY },
! 243: { PEN_IETF, IETF_ATTR_SW_ID_INVENTORY }
! 244: };
! 245:
! 246: typedef struct sw_inv_data_t sw_inv_data_t;
! 247:
! 248: struct sw_inv_data_t {
! 249: uint8_t flags;
! 250: uint32_t request_id;
! 251: uint32_t eid_epoch;
! 252: uint32_t last_eid;
! 253: chunk_t value;
! 254: };
! 255:
! 256: static sw_inv_data_t sw_inv_data[] = {
! 257: { IETF_SWIMA_ATTR_SW_INV_FLAG_NONE, 0xaabbccd0, 0x87654321, 0x00000007,
! 258: chunk_from_chars(
! 259: 0x00, 0x00, 0x00, 0x00, 0xAA, 0xBB, 0xCC, 0xD0, 0x87, 0x65,
! 260: 0x43, 0x21, 0x00, 0x00, 0x00, 0x07)
! 261: },
! 262: { IETF_SWIMA_ATTR_SW_INV_FLAG_NONE, 0xaabbccd1, 0x87654321, 0x00000007,
! 263: chunk_from_chars(
! 264: 0x00, 0x00, 0x00, 0x00, 0xAA, 0xBB, 0xCC, 0xD1, 0x87, 0x65,
! 265: 0x43, 0x21, 0x00, 0x00, 0x00, 0x07)
! 266: },
! 267: { IETF_SWIMA_ATTR_SW_INV_FLAG_NONE, 0xaabbccd2, 0x12345678, 0x00000030,
! 268: chunk_from_chars(
! 269: 0x00, 0x00, 0x00, 0x01, 0xAA, 0xBB, 0xCC, 0xD2, 0x12, 0x34,
! 270: 0x56, 0x78, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00,
! 271: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x73, 0x74,
! 272: 0x72, 0x6F, 0x6E, 0x67, 0x73, 0x77, 0x61, 0x6E, 0x2E, 0x6F,
! 273: 0x72, 0x67, 0x5F, 0x73, 0x74, 0x72, 0x6F, 0x6E, 0x67, 0x53,
! 274: 0x77, 0x61, 0x6E, 0x5F, 0x35, 0x2E, 0x33, 0x2E, 0x33, 0x00,
! 275: 0x00, 0x00, 0x00, 0x00, 0x31, 0x3C, 0x53, 0x6F, 0x66, 0x74,
! 276: 0x77, 0x61, 0x72, 0x65, 0x49, 0x64, 0x65, 0x6E, 0x74, 0x69,
! 277: 0x74, 0x79, 0x20, 0x74, 0x61, 0x67, 0x49, 0x64, 0x3D, 0x22,
! 278: 0x61, 0x62, 0x63, 0x22, 0x3E, 0x3C, 0x2F, 0x53, 0x6F, 0x66,
! 279: 0x74, 0x77, 0x61, 0x72, 0x65, 0x49, 0x64, 0x65, 0x6E, 0x74,
! 280: 0x69, 0x74, 0x79, 0x3E)
! 281: },
! 282: { IETF_SWIMA_ATTR_SW_INV_FLAG_NONE, 0xaabbccd3, 0x12345678, 0x00000030,
! 283: chunk_from_chars(
! 284: 0x00, 0x00, 0x00, 0x01, 0xAA, 0xBB, 0xCC, 0xD3, 0x12, 0x34,
! 285: 0x56, 0x78, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00,
! 286: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x73, 0x74,
! 287: 0x72, 0x6F, 0x6E, 0x67, 0x73, 0x77, 0x61, 0x6E, 0x2E, 0x6F,
! 288: 0x72, 0x67, 0x5F, 0x73, 0x74, 0x72, 0x6F, 0x6E, 0x67, 0x53,
! 289: 0x77, 0x61, 0x6E, 0x5F, 0x35, 0x2E, 0x33, 0x2E, 0x33, 0x00,
! 290: 0x00)
! 291: },
! 292: { IETF_SWIMA_ATTR_SW_INV_FLAG_S_F, 0xaabbccd4, 0x12345678, 0x00000034,
! 293: chunk_from_chars(
! 294: 0x80, 0x00, 0x00, 0x02, 0xAA, 0xBB, 0xCC, 0xD4, 0x12, 0x34,
! 295: 0x56, 0x78, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00, 0x00,
! 296: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x73, 0x74,
! 297: 0x72, 0x6F, 0x6E, 0x67, 0x73, 0x77, 0x61, 0x6E, 0x2E, 0x6F,
! 298: 0x72, 0x67, 0x5F, 0x73, 0x74, 0x72, 0x6F, 0x6E, 0x67, 0x53,
! 299: 0x77, 0x61, 0x6E, 0x5F, 0x35, 0x2E, 0x33, 0x2E, 0x33, 0x00,
! 300: 0x00, 0x00, 0x00, 0x00, 0x31, 0x3C, 0x53, 0x6F, 0x66, 0x74,
! 301: 0x77, 0x61, 0x72, 0x65, 0x49, 0x64, 0x65, 0x6E, 0x74, 0x69,
! 302: 0x74, 0x79, 0x20, 0x74, 0x61, 0x67, 0x49, 0x64, 0x3D, 0x22,
! 303: 0x61, 0x62, 0x63, 0x22, 0x3E, 0x3C, 0x2F, 0x53, 0x6F, 0x66,
! 304: 0x74, 0x77, 0x61, 0x72, 0x65, 0x49, 0x64, 0x65, 0x6E, 0x74,
! 305: 0x69, 0x74, 0x79, 0x3E, 0x00, 0x00, 0x00, 0x01, 0x00, 0x90,
! 306: 0x2A, 0x19, 0x11, 0x00, 0x00, 0x33, 0x73, 0x74, 0x72, 0x6F,
! 307: 0x6E, 0x67, 0x73, 0x77, 0x61, 0x6E, 0x2E, 0x6F, 0x72, 0x67,
! 308: 0x5F, 0x36, 0x32, 0x32, 0x35, 0x31, 0x61, 0x61, 0x36, 0x2D,
! 309: 0x31, 0x61, 0x30, 0x31, 0x2D, 0x34, 0x37, 0x39, 0x62, 0x2D,
! 310: 0x61, 0x65, 0x61, 0x36, 0x2D, 0x66, 0x33, 0x64, 0x63, 0x66,
! 311: 0x30, 0x61, 0x62, 0x31, 0x66, 0x31, 0x61, 0x00, 0x00, 0x00,
! 312: 0x00, 0x00, 0x31, 0x3C, 0x53, 0x6F, 0x66, 0x74, 0x77, 0x61,
! 313: 0x72, 0x65, 0x49, 0x64, 0x65, 0x6E, 0x74, 0x69, 0x74, 0x79,
! 314: 0x20, 0x74, 0x61, 0x67, 0x49, 0x64, 0x3D, 0x22, 0x64, 0x65,
! 315: 0x66, 0x22, 0x3E, 0x3C, 0x2F, 0x53, 0x6F, 0x66, 0x74, 0x77,
! 316: 0x61, 0x72, 0x65, 0x49, 0x64, 0x65, 0x6E, 0x74, 0x69, 0x74,
! 317: 0x79, 0x3E)
! 318: },
! 319: { IETF_SWIMA_ATTR_SW_INV_FLAG_S_F, 0xaabbccd5, 0x12345678, 0x00000034,
! 320: chunk_from_chars(
! 321: 0x80, 0x00, 0x00, 0x02, 0xAA, 0xBB, 0xCC, 0xD5, 0x12, 0x34,
! 322: 0x56, 0x78, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00, 0x00,
! 323: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x73, 0x74,
! 324: 0x72, 0x6F, 0x6E, 0x67, 0x73, 0x77, 0x61, 0x6E, 0x2E, 0x6F,
! 325: 0x72, 0x67, 0x5F, 0x73, 0x74, 0x72, 0x6F, 0x6E, 0x67, 0x53,
! 326: 0x77, 0x61, 0x6E, 0x5F, 0x35, 0x2E, 0x33, 0x2E, 0x33, 0x00,
! 327: 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x90, 0x2A, 0x19, 0x11,
! 328: 0x00, 0x00, 0x33, 0x73, 0x74, 0x72, 0x6F, 0x6E, 0x67, 0x73,
! 329: 0x77, 0x61, 0x6E, 0x2E, 0x6F, 0x72, 0x67, 0x5F, 0x36, 0x32,
! 330: 0x32, 0x35, 0x31, 0x61, 0x61, 0x36, 0x2D, 0x31, 0x61, 0x30,
! 331: 0x31, 0x2D, 0x34, 0x37, 0x39, 0x62, 0x2D, 0x61, 0x65, 0x61,
! 332: 0x36, 0x2D, 0x66, 0x33, 0x64, 0x63, 0x66, 0x30, 0x61, 0x62,
! 333: 0x31, 0x66, 0x31, 0x61, 0x00, 0x00)
! 334: }
! 335: };
! 336:
! 337: START_TEST(test_imcv_swima_inv)
! 338: {
! 339: pen_type_t type, data_model;
! 340: chunk_t sw_id, record, value;
! 341: ietf_swima_attr_sw_inv_t *c_attr;
! 342: pa_tnc_attr_t *attr, *attr1, *attr2;
! 343: swima_record_t *sw_record;
! 344: swima_inventory_t *sw_inv;
! 345: enumerator_t *enumerator;
! 346: uint32_t offset, epoch;
! 347: uint8_t source_id;
! 348: bool sw_id_only = _i % 2;
! 349: int n;
! 350:
! 351: attr = ietf_swima_attr_sw_inv_create(sw_inv_data[_i].flags,
! 352: sw_inv_data[_i].request_id,
! 353: sw_id_only);
! 354:
! 355: sw_inv = swima_inventory_create();
! 356: sw_inv->set_eid(sw_inv, sw_inv_data[_i].last_eid, sw_inv_data[_i].eid_epoch);
! 357: for (n = 0; n < _i/2; n++)
! 358: {
! 359: sw_id = chunk_from_str(sw_id_str[n]);
! 360: sw_record = swima_record_create(n, sw_id, chunk_empty);
! 361:
! 362: if (n == 1)
! 363: {
! 364: sw_record->set_data_model(sw_record, ita_data_model);
! 365: sw_record->set_source_id(sw_record, 0x11);
! 366: }
! 367: if (!sw_id_only)
! 368: {
! 369: record = chunk_from_str(sw_record_str[n]);
! 370: sw_record->set_record(sw_record, record);
! 371: }
! 372: sw_inv->add(sw_inv, sw_record);
! 373: }
! 374: c_attr = (ietf_swima_attr_sw_inv_t*)attr;
! 375: c_attr->set_inventory(c_attr, sw_inv);
! 376: c_attr->set_inventory(c_attr, sw_inv);
! 377:
! 378: attr->build(attr);
! 379: attr->build(attr);
! 380: sw_inv->destroy(sw_inv);
! 381:
! 382: type = attr->get_type(attr);
! 383: ck_assert(pen_type_equals(type, sw_inv_types[sw_id_only]));
! 384:
! 385: ck_assert(attr->get_noskip_flag(attr) == FALSE);
! 386: attr->set_noskip_flag(attr, TRUE);
! 387: ck_assert(attr->get_noskip_flag(attr) == TRUE);
! 388:
! 389: value = attr->get_value(attr);
! 390: ck_assert_chunk_eq(value, sw_inv_data[_i].value);
! 391:
! 392: attr1 = attr->get_ref(attr);
! 393: attr->destroy(attr);
! 394:
! 395: attr2 = ietf_swima_attr_sw_inv_create_from_data(value.len, value,
! 396: sw_id_only);
! 397: ck_assert(attr2);
! 398: attr1->destroy(attr1);
! 399: ck_assert(attr2->process(attr2, &offset) == SUCCESS);
! 400:
! 401: type = attr2->get_type(attr2);
! 402: ck_assert(pen_type_equals(type, sw_inv_types[sw_id_only]));
! 403:
! 404: c_attr = (ietf_swima_attr_sw_inv_t*)attr2;
! 405: ck_assert(c_attr->get_flags(c_attr) == sw_inv_data[_i].flags);
! 406: ck_assert(c_attr->get_record_count(c_attr) == 0);
! 407: ck_assert(c_attr->get_request_id(c_attr) == sw_inv_data[_i].request_id);
! 408:
! 409: sw_inv = c_attr->get_inventory(c_attr);
! 410: ck_assert(sw_inv->get_eid(sw_inv, NULL) == sw_inv_data[_i].last_eid);
! 411: ck_assert(sw_inv->get_eid(sw_inv, &epoch) == sw_inv_data[_i].last_eid);
! 412: ck_assert(epoch == sw_inv_data[_i].eid_epoch);
! 413: ck_assert(sw_inv);
! 414: ck_assert(sw_inv->get_count(sw_inv) == _i/2);
! 415:
! 416: enumerator = sw_inv->create_enumerator(sw_inv);
! 417: ck_assert(enumerator);
! 418:
! 419: n = 0;
! 420: while (enumerator->enumerate(enumerator, &sw_record))
! 421: {
! 422: ck_assert(sw_record->get_record_id(sw_record) == n);
! 423: data_model = sw_record->get_data_model(sw_record);
! 424: ck_assert(pen_type_equals(data_model, (n == 1) ? ita_data_model :
! 425: swima_data_model_iso_2015_swid_xml));
! 426: source_id = sw_record->get_source_id(sw_record);
! 427: ck_assert(source_id == (n == 1 ? 0x11 : 0x00));
! 428: n++;
! 429: }
! 430: enumerator->destroy(enumerator);
! 431: ck_assert(n == _i/2);
! 432:
! 433: attr2->destroy(attr2);
! 434: }
! 435: END_TEST
! 436:
! 437: /**
! 438: * Offsets in sw_inv_data[4].value
! 439: *
! 440: * 0 constant header
! 441: * 12 segment 1 - 12 octets
! 442: * 16 record_id
! 443: * 18 segment 2 - 6 octets
! 444: * 20 data_model_pen
! 445: * 22 segment 3 - 4 octets
! 446: * 23 segment 4 - 1 octet
! 447: * 23 data_model_type
! 448: * 24 segment 5 - 1 octet
! 449: * 24 source_id
! 450: * 25 segment 6 - 1 octet
! 451: * 25 reserved
! 452: * 26 sw_id
! 453: * 27 segment 7 - 2 octets
! 454: * 59 sw_locator
! 455: * 60 segment 8 - 33 octets
! 456: * 61 record
! 457: * 63 segment 9 - 3 octets
! 458: * 114 sw record 2
! 459: * 115 segment 10 - 52 octets
! 460: * 231 segment 11 - 117 octets
! 461: */
! 462:
! 463: START_TEST(test_imcv_swima_sw_inv_trunc)
! 464: {
! 465: pa_tnc_attr_t *attr;
! 466: ietf_swima_attr_sw_inv_t *c_attr;
! 467: chunk_t data;
! 468: swima_inventory_t *sw_inv;
! 469: size_t len = sw_inv_data[4].value.len;
! 470: uint32_t offset = 100;
! 471:
! 472: /* Data smaller than minimum size */
! 473: attr = ietf_swima_attr_sw_inv_create_from_data(0, chunk_empty, FALSE);
! 474: ck_assert(attr);
! 475: ck_assert(attr->process(attr, &offset) == FAILED && offset == 0);
! 476: attr->destroy(attr);
! 477:
! 478: /* Length larger than data */
! 479: data = sw_inv_data[4].value;
! 480: attr = ietf_swima_attr_sw_inv_create_from_data(len + 2, data, FALSE);
! 481: ck_assert(attr);
! 482: ck_assert(attr->process(attr, &offset) == FAILED && offset == len);
! 483: attr->destroy(attr);
! 484:
! 485: /* Segment 1 truncates minimum size */
! 486: data = sw_inv_data[4].value;
! 487: data.len = 12;
! 488: attr = ietf_swima_attr_sw_inv_create_from_data(len, data, FALSE);
! 489: ck_assert(attr);
! 490: ck_assert(attr->process(attr, &offset) == NEED_MORE);
! 491:
! 492: /* Segment 2 truncates record_id */
! 493: data = chunk_skip(sw_inv_data[4].value, 12);
! 494: data.len = 6;
! 495: attr->add_segment(attr, data);
! 496: ck_assert(attr->process(attr, &offset) == NEED_MORE);
! 497:
! 498: /* Segment 3 truncates data_model_pen */
! 499: data = chunk_skip(sw_inv_data[4].value, 18);
! 500: data.len = 4;
! 501: attr->add_segment(attr, data);
! 502: ck_assert(attr->process(attr, &offset) == NEED_MORE);
! 503:
! 504: /* Segment 4 truncates data_model_type */
! 505: data = chunk_skip(sw_inv_data[4].value, 22);
! 506: data.len = 1;
! 507: attr->add_segment(attr, data);
! 508: ck_assert(attr->process(attr, &offset) == NEED_MORE);
! 509:
! 510: /* Segment 5 truncates source_id */
! 511: data = chunk_skip(sw_inv_data[4].value, 23);
! 512: data.len = 1;
! 513: attr->add_segment(attr, data);
! 514: ck_assert(attr->process(attr, &offset) == NEED_MORE);
! 515:
! 516: /* Segment 6 truncates reserved */
! 517: data = chunk_skip(sw_inv_data[4].value, 24);
! 518: data.len = 1;
! 519: attr->add_segment(attr, data);
! 520: ck_assert(attr->process(attr, &offset) == NEED_MORE);
! 521:
! 522: /* Segment 7 truncates sw_id */
! 523: data = chunk_skip(sw_inv_data[4].value, 25);
! 524: data.len = 2;
! 525: attr->add_segment(attr, data);
! 526: ck_assert(attr->process(attr, &offset) == NEED_MORE);
! 527:
! 528: /* Segment 8 truncates sw_locator */
! 529: data = chunk_skip(sw_inv_data[4].value, 27);
! 530: data.len = 33;
! 531: attr->add_segment(attr, data);
! 532: ck_assert(attr->process(attr, &offset) == NEED_MORE);
! 533:
! 534: /* Segment 9 truncates record */
! 535: data = chunk_skip(sw_inv_data[4].value, 60);
! 536: data.len = 3;
! 537: attr->add_segment(attr, data);
! 538: ck_assert(attr->process(attr, &offset) == NEED_MORE);
! 539:
! 540: /* Segment 10 truncates second sw_record */
! 541: data = chunk_skip(sw_inv_data[4].value, 63);
! 542: data.len = 52;
! 543: attr->add_segment(attr, data);
! 544: ck_assert(attr->process(attr, &offset) == SUCCESS);
! 545:
! 546: /* Process first inventory entry */
! 547: c_attr = (ietf_swima_attr_sw_inv_t*)attr;
! 548: sw_inv = c_attr->get_inventory(c_attr);
! 549: ck_assert(sw_inv->get_count(sw_inv) == 1);
! 550: c_attr->clear_inventory(c_attr);
! 551:
! 552: /* Segment 11 truncates second sw_record */
! 553: data = chunk_skip(sw_inv_data[4].value, 115);
! 554: data.len = 117;
! 555: attr->add_segment(attr, data);
! 556: ck_assert(attr->process(attr, &offset) == SUCCESS);
! 557:
! 558: /* Process second inventory entry */
! 559: sw_inv = c_attr->get_inventory(c_attr);
! 560: ck_assert(sw_inv->get_count(sw_inv) == 1);
! 561: c_attr->clear_inventory(c_attr);
! 562:
! 563: attr->destroy(attr);
! 564: }
! 565: END_TEST
! 566:
! 567: static char* sw_ev_timestamp_str[] = {
! 568: "2017-05-30T18:09:25Z",
! 569: "2017-06-14T15:38:00Z"
! 570: };
! 571:
! 572: START_TEST(test_imcv_swima_event)
! 573: {
! 574: chunk_t sw_id, sw_timestamp, timestamp;
! 575: swima_event_t *sw_event, *sw_event_cp;
! 576: swima_record_t *sw_record;
! 577: uint32_t record_id = 1, eid = 7;
! 578: uint8_t action = SWIMA_EVENT_ACTION_CREATION;
! 579:
! 580: sw_id = chunk_from_str(sw_id_str[0]);
! 581: sw_timestamp = chunk_from_str(sw_ev_timestamp_str[0]);
! 582:
! 583: /* Software Identity without Software Locator */
! 584: sw_record = swima_record_create(record_id, sw_id, chunk_empty),
! 585: ck_assert(sw_record);
! 586:
! 587: sw_event = swima_event_create(eid, sw_timestamp, action, sw_record);
! 588: ck_assert(sw_event);
! 589: sw_event_cp = sw_event->get_ref(sw_event);
! 590:
! 591: ck_assert(sw_event->get_eid(sw_event, NULL) == eid);
! 592: ck_assert(sw_event->get_eid(sw_event, ×tamp) == eid);
! 593: ck_assert_chunk_eq(sw_timestamp, timestamp);
! 594: ck_assert(sw_event->get_action(sw_event) == action);
! 595: sw_event->destroy(sw_event);
! 596:
! 597: sw_record = sw_event_cp->get_sw_record(sw_event_cp);
! 598: ck_assert(sw_record);
! 599: ck_assert(sw_record->get_record_id(sw_record) == record_id);
! 600: ck_assert_chunk_eq(sw_record->get_sw_id(sw_record, NULL), sw_id);
! 601: sw_event_cp->destroy(sw_event_cp);
! 602: }
! 603: END_TEST
! 604:
! 605: static pen_type_t sw_ev_types[] = {
! 606: { PEN_IETF, IETF_ATTR_SW_EVENTS },
! 607: { PEN_IETF, IETF_ATTR_SW_ID_EVENTS }
! 608: };
! 609:
! 610: typedef struct sw_ev_data_t sw_ev_data_t;
! 611:
! 612: struct sw_ev_data_t {
! 613: uint8_t flags;
! 614: uint32_t request_id;
! 615: uint32_t eid_epoch;
! 616: uint32_t last_eid;
! 617: uint32_t last_consulted_eid;
! 618: chunk_t value;
! 619: };
! 620:
! 621: static sw_ev_data_t sw_ev_data[] = {
! 622: { IETF_SWIMA_ATTR_SW_EV_FLAG_NONE, 0xaabbccd0, 0x87654321, 0x00000007,
! 623: 0x00000007, chunk_from_chars(
! 624: 0x00, 0x00, 0x00, 0x00, 0xAA, 0xBB, 0xCC, 0xD0, 0x87, 0x65,
! 625: 0x43, 0x21, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07)
! 626: },
! 627: { IETF_SWIMA_ATTR_SW_EV_FLAG_NONE, 0xaabbccd1, 0x87654321, 0x00000007,
! 628: 0x00000007, chunk_from_chars(
! 629: 0x00, 0x00, 0x00, 0x00, 0xAA, 0xBB, 0xCC, 0xD1, 0x87, 0x65,
! 630: 0x43, 0x21, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07)
! 631: },
! 632: { IETF_SWIMA_ATTR_SW_EV_FLAG_NONE, 0xaabbccd2, 0x12345678, 0x00000030,
! 633: 0x00000030, chunk_from_chars(
! 634: 0x00, 0x00, 0x00, 0x01, 0xAA, 0xBB, 0xCC, 0xD2, 0x12, 0x34,
! 635: 0x56, 0x78, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x30,
! 636: 0x00, 0x00, 0x00, 0x30, '2', '0', '1', '7', '-', '0',
! 637: '5', '-', '3', '0', 'T', '1', '8', ':', '0', '9',
! 638: ':', '2', '5', 'Z', 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
! 639: 0x00, 0x00, 0x00, 0x01, 0x00, 0x1F, 0x73, 0x74, 0x72, 0x6F,
! 640: 0x6E, 0x67, 0x73, 0x77, 0x61, 0x6E, 0x2E, 0x6F, 0x72, 0x67,
! 641: 0x5F, 0x73, 0x74, 0x72, 0x6F, 0x6E, 0x67, 0x53, 0x77, 0x61,
! 642: 0x6E, 0x5F, 0x35, 0x2E, 0x33, 0x2E, 0x33, 0x00, 0x00, 0x00,
! 643: 0x00, 0x00, 0x31, 0x3C, 0x53, 0x6F, 0x66, 0x74, 0x77, 0x61,
! 644: 0x72, 0x65, 0x49, 0x64, 0x65, 0x6E, 0x74, 0x69, 0x74, 0x79,
! 645: 0x20, 0x74, 0x61, 0x67, 0x49, 0x64, 0x3D, 0x22, 0x61, 0x62,
! 646: 0x63, 0x22, 0x3E, 0x3C, 0x2F, 0x53, 0x6F, 0x66, 0x74, 0x77,
! 647: 0x61, 0x72, 0x65, 0x49, 0x64, 0x65, 0x6E, 0x74, 0x69, 0x74,
! 648: 0x79, 0x3E)
! 649: },
! 650: { IETF_SWIMA_ATTR_SW_EV_FLAG_NONE, 0xaabbccd3, 0x12345678, 0x00000030,
! 651: 0x00000030, chunk_from_chars(
! 652: 0x00, 0x00, 0x00, 0x01, 0xAA, 0xBB, 0xCC, 0xD3, 0x12, 0x34,
! 653: 0x56, 0x78, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x30,
! 654: 0x00, 0x00, 0x00, 0x30, '2', '0', '1', '7', '-', '0',
! 655: '5', '-', '3', '0', 'T', '1', '8', ':', '0', '9',
! 656: ':', '2', '5', 'Z', 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
! 657: 0x00, 0x00, 0x00, 0x01, 0x00, 0x1F, 0x73, 0x74, 0x72, 0x6F,
! 658: 0x6E, 0x67, 0x73, 0x77, 0x61, 0x6E, 0x2E, 0x6F, 0x72, 0x67,
! 659: 0x5F, 0x73, 0x74, 0x72, 0x6F, 0x6E, 0x67, 0x53, 0x77, 0x61,
! 660: 0x6E, 0x5F, 0x35, 0x2E, 0x33, 0x2E, 0x33, 0x00, 0x00)
! 661: },
! 662: { IETF_SWIMA_ATTR_SW_EV_FLAG_S_F, 0xaabbccd4, 0x12345678, 0x00000050,
! 663: 0x00000034, chunk_from_chars(
! 664: 0x80, 0x00, 0x00, 0x02, 0xAA, 0xBB, 0xCC, 0xD4, 0x12, 0x34,
! 665: 0x56, 0x78, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x34,
! 666: 0x00, 0x00, 0x00, 0x30, '2', '0', '1', '7', '-', '0',
! 667: '5', '-', '3', '0', 'T', '1', '8', ':', '0', '9',
! 668: ':', '2', '5', 'Z', 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
! 669: 0x00, 0x00, 0x00, 0x01, 0x00, 0x1F, 0x73, 0x74, 0x72, 0x6F,
! 670: 0x6E, 0x67, 0x73, 0x77, 0x61, 0x6E, 0x2E, 0x6F, 0x72, 0x67,
! 671: 0x5F, 0x73, 0x74, 0x72, 0x6F, 0x6E, 0x67, 0x53, 0x77, 0x61,
! 672: 0x6E, 0x5F, 0x35, 0x2E, 0x33, 0x2E, 0x33, 0x00, 0x00, 0x00,
! 673: 0x00, 0x00, 0x31, 0x3C, 0x53, 0x6F, 0x66, 0x74, 0x77, 0x61,
! 674: 0x72, 0x65, 0x49, 0x64, 0x65, 0x6E, 0x74, 0x69, 0x74, 0x79,
! 675: 0x20, 0x74, 0x61, 0x67, 0x49, 0x64, 0x3D, 0x22, 0x61, 0x62,
! 676: 0x63, 0x22, 0x3E, 0x3C, 0x2F, 0x53, 0x6F, 0x66, 0x74, 0x77,
! 677: 0x61, 0x72, 0x65, 0x49, 0x64, 0x65, 0x6E, 0x74, 0x69, 0x74,
! 678: 0x79, 0x3E, 0x00, 0x00, 0x00, 0x34, '2', '0', '1', '7',
! 679: '-', '0', '6', '-', '1', '4', 'T', '1', '5', ':',
! 680: '3', '8', ':', '0', '0', 'Z', 0x00, 0x00, 0x00, 0x01,
! 681: 0x00, 0x90, 0x2A, 0x19, 0x11, 0x02, 0x00, 0x33, 0x73, 0x74,
! 682: 0x72, 0x6F, 0x6E, 0x67, 0x73, 0x77, 0x61, 0x6E, 0x2E, 0x6F,
! 683: 0x72, 0x67, 0x5F, 0x36, 0x32, 0x32, 0x35, 0x31, 0x61, 0x61,
! 684: 0x36, 0x2D, 0x31, 0x61, 0x30, 0x31, 0x2D, 0x34, 0x37, 0x39,
! 685: 0x62, 0x2D, 0x61, 0x65, 0x61, 0x36, 0x2D, 0x66, 0x33, 0x64,
! 686: 0x63, 0x66, 0x30, 0x61, 0x62, 0x31, 0x66, 0x31, 0x61, 0x00,
! 687: 0x00, 0x00, 0x00, 0x00, 0x31, 0x3C, 0x53, 0x6F, 0x66, 0x74,
! 688: 0x77, 0x61, 0x72, 0x65, 0x49, 0x64, 0x65, 0x6E, 0x74, 0x69,
! 689: 0x74, 0x79, 0x20, 0x74, 0x61, 0x67, 0x49, 0x64, 0x3D, 0x22,
! 690: 0x64, 0x65, 0x66, 0x22, 0x3E, 0x3C, 0x2F, 0x53, 0x6F, 0x66,
! 691: 0x74, 0x77, 0x61, 0x72, 0x65, 0x49, 0x64, 0x65, 0x6E, 0x74,
! 692: 0x69, 0x74, 0x79, 0x3E)
! 693: },
! 694: { IETF_SWIMA_ATTR_SW_EV_FLAG_S_F, 0xaabbccd5, 0x12345678, 0x00000050,
! 695: 0x00000034, chunk_from_chars(
! 696: 0x80, 0x00, 0x00, 0x02, 0xAA, 0xBB, 0xCC, 0xD5, 0x12, 0x34,
! 697: 0x56, 0x78, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x34,
! 698: 0x00, 0x00, 0x00, 0x30, '2', '0', '1', '7', '-', '0',
! 699: '5', '-', '3', '0', 'T', '1', '8', ':', '0', '9',
! 700: ':', '2', '5', 'Z', 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
! 701: 0x00, 0x00, 0x00, 0x01, 0x00, 0x1F, 0x73, 0x74, 0x72, 0x6F,
! 702: 0x6E, 0x67, 0x73, 0x77, 0x61, 0x6E, 0x2E, 0x6F, 0x72, 0x67,
! 703: 0x5F, 0x73, 0x74, 0x72, 0x6F, 0x6E, 0x67, 0x53, 0x77, 0x61,
! 704: 0x6E, 0x5F, 0x35, 0x2E, 0x33, 0x2E, 0x33, 0x00, 0x00, 0x00,
! 705: 0x00, 0x00, 0x34, '2', '0', '1', '7', '-', '0', '6',
! 706: '-', '1', '4', 'T', '1', '5', ':', '3', '8', ':',
! 707: '0', '0', 'Z', 0x00, 0x00, 0x00, 0x01, 0x00, 0x90, 0x2A,
! 708: 0x19, 0x11, 0x02, 0x00, 0x33, 0x73, 0x74, 0x72, 0x6F, 0x6E,
! 709: 0x67, 0x73, 0x77, 0x61, 0x6E, 0x2E, 0x6F, 0x72, 0x67, 0x5F,
! 710: 0x36, 0x32, 0x32, 0x35, 0x31, 0x61, 0x61, 0x36, 0x2D, 0x31,
! 711: 0x61, 0x30, 0x31, 0x2D, 0x34, 0x37, 0x39, 0x62, 0x2D, 0x61,
! 712: 0x65, 0x61, 0x36, 0x2D, 0x66, 0x33, 0x64, 0x63, 0x66, 0x30,
! 713: 0x61, 0x62, 0x31, 0x66, 0x31, 0x61, 0x00, 0x00)
! 714: }
! 715: };
! 716:
! 717: START_TEST(test_imcv_swima_ev)
! 718: {
! 719: pen_type_t type, data_model;
! 720: chunk_t sw_id, record, timestamp, value;
! 721: ietf_swima_attr_sw_ev_t *c_attr;
! 722: pa_tnc_attr_t *attr, *attr1, *attr2;
! 723: swima_record_t *sw_record;
! 724: swima_event_t *sw_event;
! 725: swima_events_t *sw_ev;
! 726: enumerator_t *enumerator;
! 727: uint32_t offset, epoch, eid, last_eid;
! 728: uint8_t source_id, action;
! 729: bool sw_id_only = _i % 2;
! 730: int n;
! 731:
! 732: attr = ietf_swima_attr_sw_ev_create(sw_ev_data[_i].flags,
! 733: sw_ev_data[_i].request_id,
! 734: sw_id_only);
! 735: sw_ev = swima_events_create();
! 736: sw_ev->set_eid(sw_ev, sw_ev_data[_i].last_consulted_eid,
! 737: sw_ev_data[_i].eid_epoch);
! 738: if (sw_ev_data[_i].last_consulted_eid < sw_ev_data[_i].last_eid)
! 739: {
! 740: sw_ev->set_last_eid(sw_ev, sw_ev_data[_i].last_eid);
! 741: }
! 742:
! 743: for (n = 0; n < _i/2; n++)
! 744: {
! 745: sw_id = chunk_from_str(sw_id_str[n]);
! 746: sw_record = swima_record_create(n, sw_id, chunk_empty);
! 747:
! 748: if (n == 1)
! 749: {
! 750: sw_record->set_data_model(sw_record, ita_data_model);
! 751: sw_record->set_source_id(sw_record, 0x11);
! 752: }
! 753: if (!sw_id_only)
! 754: {
! 755: record = chunk_from_str(sw_record_str[n]);
! 756: sw_record->set_record(sw_record, record);
! 757: }
! 758: eid = 0x30 + 4 * n;
! 759: timestamp = chunk_from_str(sw_ev_timestamp_str[n]);
! 760: action = n + 1;
! 761: sw_event = swima_event_create(eid, timestamp, action, sw_record);
! 762: sw_ev->add(sw_ev, sw_event);
! 763: }
! 764: c_attr = (ietf_swima_attr_sw_ev_t*)attr;
! 765: c_attr->set_events(c_attr, sw_ev);
! 766: c_attr->set_events(c_attr, sw_ev);
! 767:
! 768: attr->build(attr);
! 769: attr->build(attr);
! 770: sw_ev->destroy(sw_ev);
! 771:
! 772: type = attr->get_type(attr);
! 773: ck_assert(pen_type_equals(type, sw_ev_types[sw_id_only]));
! 774:
! 775: ck_assert(attr->get_noskip_flag(attr) == FALSE);
! 776: attr->set_noskip_flag(attr, TRUE);
! 777: ck_assert(attr->get_noskip_flag(attr) == TRUE);
! 778:
! 779: value = attr->get_value(attr);
! 780: ck_assert_chunk_eq(value, sw_ev_data[_i].value);
! 781:
! 782: attr1 = attr->get_ref(attr);
! 783: attr->destroy(attr);
! 784:
! 785: attr2 = ietf_swima_attr_sw_ev_create_from_data(value.len, value,
! 786: sw_id_only);
! 787: ck_assert(attr2);
! 788: attr1->destroy(attr1);
! 789: ck_assert(attr2->process(attr2, &offset) == SUCCESS);
! 790:
! 791: type = attr2->get_type(attr2);
! 792: ck_assert(pen_type_equals(type, sw_ev_types[sw_id_only]));
! 793:
! 794: c_attr = (ietf_swima_attr_sw_ev_t*)attr2;
! 795: ck_assert(c_attr->get_flags(c_attr) == sw_ev_data[_i].flags);
! 796: ck_assert(c_attr->get_event_count(c_attr) == 0);
! 797: ck_assert(c_attr->get_request_id(c_attr) == sw_ev_data[_i].request_id);
! 798:
! 799: sw_ev = c_attr->get_events(c_attr);
! 800: ck_assert(sw_ev);
! 801: eid = sw_ev->get_eid(sw_ev, NULL, NULL);
! 802: ck_assert(eid == sw_ev_data[_i].last_consulted_eid);
! 803: eid = sw_ev->get_eid(sw_ev, &epoch, &last_eid);
! 804: ck_assert(eid == sw_ev_data[_i].last_consulted_eid);
! 805: ck_assert(epoch == sw_ev_data[_i].eid_epoch);
! 806: ck_assert(last_eid == sw_ev_data[_i].last_eid);
! 807: ck_assert(sw_ev->get_count(sw_ev) == _i/2);
! 808:
! 809: enumerator = sw_ev->create_enumerator(sw_ev);
! 810: ck_assert(enumerator);
! 811:
! 812: n = 0;
! 813: while (enumerator->enumerate(enumerator, &sw_event))
! 814: {
! 815: ck_assert(sw_event->get_eid(sw_event, ×tamp) == 0x30 + 4 * n);
! 816: ck_assert_chunk_eq(timestamp, chunk_from_str(sw_ev_timestamp_str[n]));
! 817: sw_record = sw_event->get_sw_record(sw_event);
! 818: ck_assert(sw_record);
! 819: ck_assert(sw_record->get_record_id(sw_record) == n);
! 820: data_model = sw_record->get_data_model(sw_record);
! 821: ck_assert(pen_type_equals(data_model, (n == 1) ? ita_data_model :
! 822: swima_data_model_iso_2015_swid_xml));
! 823: source_id = sw_record->get_source_id(sw_record);
! 824: ck_assert(source_id == (n == 1 ? 0x11 : 0x00));
! 825: n++;
! 826: }
! 827: enumerator->destroy(enumerator);
! 828: ck_assert(n == _i/2);
! 829:
! 830: attr2->destroy(attr2);
! 831: }
! 832: END_TEST
! 833:
! 834:
! 835: /**
! 836: * Offsets in sw_ev_data[4].value
! 837: *
! 838: * 0 constant header
! 839: * 16 segment 1 - 16 octets
! 840: * 20 eid
! 841: * 22 segment 2 - 6 octets
! 842: * 24 timestamp
! 843: * 26 segment 3 - 4 octets
! 844: * 44 record_id
! 845: * 46 segment 4 - 20 octets
! 846: * 48 data_model_pen
! 847: * 50 segment 5 - 4 octets
! 848: * 51 segment 6 - 1 octet
! 849: * 51 data_model_type
! 850: * 52 segment 7 - 1 octet
! 851: * 52 source_id
! 852: * 53 segment 8 - 1 octet
! 853: * 53 action
! 854: * 54 sw_id
! 855: * 55 segment 9 - 2 octets
! 856: * 87 sw_locator
! 857: * 88 segment 10 - 33 octets
! 858: * 89 record
! 859: * 91 segment 11 - 3 octets
! 860: * 142 sw record 2
! 861: * 143 segment 12 - 52 octets
! 862: * 284 segment 13 - 141 octets
! 863: */
! 864:
! 865: START_TEST(test_imcv_swima_sw_ev_trunc)
! 866: {
! 867: pa_tnc_attr_t *attr;
! 868: ietf_swima_attr_sw_ev_t *c_attr;
! 869: chunk_t data;
! 870: swima_events_t *sw_ev;
! 871: size_t len = sw_ev_data[4].value.len;
! 872: uint32_t offset = 100;
! 873:
! 874: /* Data smaller than minimum size */
! 875: attr = ietf_swima_attr_sw_ev_create_from_data(0, chunk_empty, FALSE);
! 876: ck_assert(attr);
! 877: ck_assert(attr->process(attr, &offset) == FAILED && offset == 0);
! 878: attr->destroy(attr);
! 879:
! 880: /* Length larger than data */
! 881: data = sw_ev_data[4].value;
! 882: attr = ietf_swima_attr_sw_ev_create_from_data(len + 2, data, FALSE);
! 883: ck_assert(attr);
! 884: ck_assert(attr->process(attr, &offset) == FAILED && offset == len);
! 885: attr->destroy(attr);
! 886:
! 887: /* Segment 1 truncates minimum size */
! 888: data = sw_ev_data[4].value;
! 889: data.len = 16;
! 890: attr = ietf_swima_attr_sw_ev_create_from_data(len, data, FALSE);
! 891: ck_assert(attr);
! 892: ck_assert(attr->process(attr, &offset) == NEED_MORE);
! 893:
! 894: /* Segment 2 truncates eid */
! 895: data = chunk_skip(sw_ev_data[4].value, 16);
! 896: data.len = 6;
! 897: attr->add_segment(attr, data);
! 898: ck_assert(attr->process(attr, &offset) == NEED_MORE);
! 899:
! 900: /* Segment 3 truncates timestamp */
! 901: data = chunk_skip(sw_ev_data[4].value, 22);
! 902: data.len = 4;
! 903: attr->add_segment(attr, data);
! 904: ck_assert(attr->process(attr, &offset) == NEED_MORE);
! 905:
! 906: /* Segment 4 truncates record_id */
! 907: data = chunk_skip(sw_ev_data[4].value, 26);
! 908: data.len = 20;
! 909: attr->add_segment(attr, data);
! 910: ck_assert(attr->process(attr, &offset) == NEED_MORE);
! 911:
! 912: /* Segment 5 truncates data_model_pen */
! 913: data = chunk_skip(sw_ev_data[4].value, 46);
! 914: data.len = 4;
! 915: attr->add_segment(attr, data);
! 916: ck_assert(attr->process(attr, &offset) == NEED_MORE);
! 917:
! 918: /* Segment 6 truncates data_model_type */
! 919: data = chunk_skip(sw_ev_data[4].value, 50);
! 920: data.len = 1;
! 921: attr->add_segment(attr, data);
! 922: ck_assert(attr->process(attr, &offset) == NEED_MORE);
! 923:
! 924: /* Segment 7 truncates source_id */
! 925: data = chunk_skip(sw_ev_data[4].value, 51);
! 926: data.len = 1;
! 927: attr->add_segment(attr, data);
! 928: ck_assert(attr->process(attr, &offset) == NEED_MORE);
! 929:
! 930: /* Segment 8 truncates action */
! 931: data = chunk_skip(sw_ev_data[4].value, 52);
! 932: data.len = 1;
! 933: attr->add_segment(attr, data);
! 934: ck_assert(attr->process(attr, &offset) == NEED_MORE);
! 935:
! 936: /* Segment 9 truncates sw_id */
! 937: data = chunk_skip(sw_ev_data[4].value, 53);
! 938: data.len = 2;
! 939: attr->add_segment(attr, data);
! 940: ck_assert(attr->process(attr, &offset) == NEED_MORE);
! 941:
! 942: /* Segment 10 truncates sw_locator */
! 943: data = chunk_skip(sw_ev_data[4].value, 55);
! 944: data.len = 33;
! 945: attr->add_segment(attr, data);
! 946: ck_assert(attr->process(attr, &offset) == NEED_MORE);
! 947:
! 948: /* Segment 11 truncates record */
! 949: data = chunk_skip(sw_ev_data[4].value, 88);
! 950: data.len = 3;
! 951: attr->add_segment(attr, data);
! 952: ck_assert(attr->process(attr, &offset) == NEED_MORE);
! 953:
! 954: /* Segment 12 truncates second sw_entry */
! 955: data = chunk_skip(sw_ev_data[4].value, 91);
! 956: data.len = 52;
! 957: attr->add_segment(attr, data);
! 958: ck_assert(attr->process(attr, &offset) == SUCCESS);
! 959:
! 960: /* Process first event entry */
! 961: c_attr = (ietf_swima_attr_sw_ev_t*)attr;
! 962: sw_ev = c_attr->get_events(c_attr);
! 963: ck_assert(sw_ev->get_count(sw_ev) == 1);
! 964: c_attr->clear_events(c_attr);
! 965:
! 966: /* Segment 13 truncates second sw_record */
! 967: data = chunk_skip(sw_ev_data[4].value, 143);
! 968: data.len = 141;
! 969: attr->add_segment(attr, data);
! 970: ck_assert(attr->process(attr, &offset) == SUCCESS);
! 971:
! 972: /* Process second event entry */
! 973: sw_ev = c_attr->get_events(c_attr);
! 974: ck_assert(sw_ev->get_count(sw_ev) == 1);
! 975: c_attr->clear_events(c_attr);
! 976: attr->destroy(attr);
! 977:
! 978: /* Invalid Action values */
! 979: data = chunk_clone(sw_ev_data[2].value);
! 980: data.ptr[53] = 0;
! 981: attr = ietf_swima_attr_sw_ev_create_from_data(data.len, data, FALSE);
! 982: ck_assert(attr);
! 983: ck_assert(attr->process(attr, &offset) == FAILED);
! 984: attr->destroy(attr);
! 985:
! 986: data.ptr[53] = SWIMA_EVENT_ACTION_LAST + 1;
! 987: attr = ietf_swima_attr_sw_ev_create_from_data(data.len, data, FALSE);
! 988: ck_assert(attr);
! 989: ck_assert(attr->process(attr, &offset) == FAILED && offset == 20);
! 990: attr->destroy(attr);
! 991: chunk_free(&data);
! 992: }
! 993: END_TEST
! 994:
! 995: START_TEST(test_imcv_swima_sw_collector)
! 996: {
! 997: swima_collector_t *collector;
! 998: swima_inventory_t *targets, *inventory;
! 999: swima_events_t *events;
! 1000: swima_record_t *sw_record;
! 1001: swima_event_t *sw_event;
! 1002: chunk_t sw_id, sw_locator, swid_tag;
! 1003: enumerator_t *enumerator;
! 1004: uint8_t source_id;
! 1005: int item = 0, items;
! 1006:
! 1007: targets = swima_inventory_create();
! 1008: collector = swima_collector_create();
! 1009:
! 1010: /* software identifier events only */
! 1011: events = collector->collect_events(collector, TRUE, targets);
! 1012: if (events)
! 1013: {
! 1014: items = events->get_count(events);
! 1015: DBG1(DBG_IMC, "%d software identifiers collected", items);
! 1016:
! 1017: enumerator = events->create_enumerator(events);
! 1018: while (enumerator->enumerate(enumerator, &sw_event))
! 1019: {
! 1020: item++;
! 1021: if ( item == 1 || item == items)
! 1022: {
! 1023: sw_record = sw_event->get_sw_record(sw_event);
! 1024: sw_id = sw_record->get_sw_id(sw_record, NULL);
! 1025: source_id =sw_record->get_source_id(sw_record);
! 1026: DBG1(DBG_IMC, "source %u: %.*s", source_id, sw_id.len, sw_id.ptr);
! 1027: }
! 1028: }
! 1029: enumerator->destroy(enumerator);
! 1030: }
! 1031:
! 1032: /* software identifier inventory only */
! 1033: inventory = collector->collect_inventory(collector, TRUE, targets);
! 1034: if (inventory)
! 1035: {
! 1036: items = inventory->get_count(inventory);
! 1037: DBG1(DBG_IMC, "%d software identifiers collected", items);
! 1038:
! 1039: enumerator = inventory->create_enumerator(inventory);
! 1040: while (enumerator->enumerate(enumerator, &sw_record))
! 1041: {
! 1042: item++;
! 1043: if ( item == 1 || item == items)
! 1044: {
! 1045: sw_id = sw_record->get_sw_id(sw_record, &sw_locator);
! 1046: source_id =sw_record->get_source_id(sw_record);
! 1047: DBG1(DBG_IMC, "source %u: %.*s", source_id, sw_id.len, sw_id.ptr);
! 1048: if (sw_locator.len > 0)
! 1049: {
! 1050: DBG1(DBG_IMC, " locator: %.*s",
! 1051: sw_locator.len, sw_locator.ptr);
! 1052: }
! 1053: targets->add(targets, sw_record->get_ref(sw_record));
! 1054: }
! 1055: }
! 1056: enumerator->destroy(enumerator);
! 1057: }
! 1058:
! 1059: /* targeted software inventory */
! 1060: inventory = collector->collect_inventory(collector, FALSE, targets);
! 1061: if (inventory)
! 1062: {
! 1063: items = inventory->get_count(inventory);
! 1064: DBG1(DBG_IMC, "%d SWID tags collected", items);
! 1065:
! 1066: enumerator = inventory->create_enumerator(inventory);
! 1067: while (enumerator->enumerate(enumerator, &sw_record))
! 1068: {
! 1069: sw_id = sw_record->get_sw_id(sw_record, NULL);
! 1070: source_id =sw_record->get_source_id(sw_record);
! 1071: swid_tag = sw_record->get_record(sw_record);
! 1072: DBG1(DBG_IMC, "source %u: %.*s", source_id, sw_id.len, sw_id.ptr);
! 1073: DBG2(DBG_IMC, "%B", &swid_tag);
! 1074: }
! 1075: enumerator->destroy(enumerator);
! 1076: }
! 1077:
! 1078: collector->destroy(collector);
! 1079: targets->destroy(targets);
! 1080: }
! 1081: END_TEST
! 1082:
! 1083: Suite *imcv_swima_suite_create()
! 1084: {
! 1085: Suite *s;
! 1086: TCase *tc;
! 1087:
! 1088: s = suite_create("imcv_swima");
! 1089:
! 1090: tc = tcase_create("sw_record");
! 1091: tcase_add_test(tc, test_imcv_swima_record);
! 1092: suite_add_tcase(s, tc);
! 1093:
! 1094: tc = tcase_create("sw_req");
! 1095: tcase_add_loop_test(tc, test_imcv_swima_sw_req, 0, countof(req_data));
! 1096: suite_add_tcase(s, tc);
! 1097:
! 1098: tc = tcase_create("sw_req_trunc");
! 1099: tcase_add_test(tc, test_imcv_swima_sw_req_trunc);
! 1100: suite_add_tcase(s, tc);
! 1101:
! 1102: tc = tcase_create("sw_inv");
! 1103: tcase_add_loop_test(tc, test_imcv_swima_inv, 0, 6);
! 1104: suite_add_tcase(s, tc);
! 1105:
! 1106: tc = tcase_create("sw_inv_trunc");
! 1107: tcase_add_test(tc, test_imcv_swima_sw_inv_trunc);
! 1108: suite_add_tcase(s, tc);
! 1109:
! 1110: tc = tcase_create("sw_event");
! 1111: tcase_add_test(tc, test_imcv_swima_event);
! 1112: suite_add_tcase(s, tc);
! 1113:
! 1114: tc = tcase_create("sw_ev");
! 1115: tcase_add_loop_test(tc, test_imcv_swima_ev, 0, 6);
! 1116: suite_add_tcase(s, tc);
! 1117:
! 1118: tc = tcase_create("sw_ev_trunc");
! 1119: tcase_add_test(tc, test_imcv_swima_sw_ev_trunc);
! 1120: suite_add_tcase(s, tc);
! 1121:
! 1122: tc = tcase_create("sw_collector");
! 1123: tcase_add_test(tc, test_imcv_swima_sw_collector);
! 1124: suite_add_tcase(s, tc);
! 1125:
! 1126: return s;
! 1127: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to test_imcv_swima.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 / suites