4 * @brief Tests to test the Generator class generator_t
9 * Copyright (C) 2005 Jan Hutter, Martin Willi
10 * Hochschule fuer Technik Rapperswil
12 * This program is free software; you can redistribute it and/or modify it
13 * under the terms of the GNU General Public License as published by the
14 * Free Software Foundation; either version 2 of the License, or (at your
15 * option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
17 * This program is distributed in the hope that it will be useful, but
18 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
19 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
25 #include "generator_test.h"
28 #include <encoding/generator.h>
29 #include <utils/allocator.h>
30 #include <utils/logger_manager.h>
31 #include <utils/logger.h>
32 #include <encoding/payloads/encodings.h>
33 #include <encoding/payloads/ike_header.h>
34 #include <encoding/payloads/transform_attribute.h>
35 #include <encoding/payloads/transform_substructure.h>
36 #include <encoding/payloads/proposal_substructure.h>
37 #include <encoding/payloads/sa_payload.h>
38 #include <encoding/payloads/ke_payload.h>
39 #include <encoding/payloads/notify_payload.h>
40 #include <encoding/payloads/nonce_payload.h>
45 void test_generator_with_header_payload(tester_t
*tester
)
47 generator_t
*generator
;
48 ike_header_t
*header_data
;
49 chunk_t generated_data
;
53 logger
= global_logger_manager
->create_logger(global_logger_manager
,TESTER
,"header payload");
55 header_data
= ike_header_create();
56 header_data
->set_initiator_spi(header_data
,1);
57 header_data
->set_responder_spi(header_data
,2);
58 ((payload_t
*) header_data
)->set_next_type((payload_t
*) header_data
, 3);
59 header_data
->set_exchange_type(header_data
, 6);
60 header_data
->set_initiator_flag(header_data
, TRUE
);
61 header_data
->set_response_flag(header_data
, TRUE
);
62 header_data
->set_message_id(header_data
,7);
64 generator
= generator_create();
65 tester
->assert_true(tester
,(generator
!= NULL
), "generator create check");
67 generator
->generate_payload(generator
,(payload_t
*) header_data
);
69 generator
->write_to_chunk(generator
,&generated_data
);
71 u_int8_t expected_generation
[] = {
81 logger
->log_bytes(logger
,RAW
,"expected header",expected_generation
,sizeof(expected_generation
));
82 tester
->assert_true(tester
,(generated_data
.len
== sizeof(expected_generation
)), "compare generated data length");
83 logger
->log_chunk(logger
,RAW
,"generated header",&generated_data
);
84 tester
->assert_true(tester
,(memcmp(expected_generation
,generated_data
.ptr
,sizeof(expected_generation
)) == 0), "compare generated data 1");
85 allocator_free_chunk(&generated_data
);
87 generator
->destroy(generator
);
89 header_data
->set_initiator_spi(header_data
,0x22000054231234LL
);
90 header_data
->set_responder_spi(header_data
,0x122398);
91 ((payload_t
*) header_data
)->set_next_type((payload_t
*) header_data
,0xF3);
92 header_data
->set_exchange_type(header_data
, 0x12);
93 header_data
->set_initiator_flag(header_data
, TRUE
);
94 header_data
->set_response_flag(header_data
, TRUE
);
95 header_data
->set_message_id(header_data
,0x33AFF3);
97 generator
= generator_create();
98 tester
->assert_true(tester
,(generator
!= NULL
), "generator create check");
100 generator
->generate_payload(generator
,(payload_t
*)header_data
);
101 tester
->assert_true(tester
,(status
== SUCCESS
),"generate_payload call check");
103 generator
->write_to_chunk(generator
,&generated_data
);
105 u_int8_t expected_generation2
[] = {
116 logger
->log_bytes(logger
,RAW
,"expected header",expected_generation2
,sizeof(expected_generation2
));
118 logger
->log_chunk(logger
,RAW
,"generated header",&generated_data
);
120 tester
->assert_true(tester
,(memcmp(expected_generation2
,generated_data
.ptr
,sizeof(expected_generation2
)) == 0), "compare generated data 2");
121 allocator_free_chunk(&generated_data
);
123 header_data
->destroy(header_data
);
125 global_logger_manager
->destroy_logger(global_logger_manager
,logger
);
126 generator
->destroy(generator
);
130 * Described in header
132 void test_generator_with_transform_attribute(tester_t
*tester
)
134 generator_t
*generator
;
135 transform_attribute_t
*attribute
;
137 chunk_t generated_data
;
140 logger
= global_logger_manager
->create_logger(global_logger_manager
,TESTER
,"transform_attribute payload");
143 /* test empty attribute */
144 generator
= generator_create();
145 tester
->assert_true(tester
,(generator
!= NULL
), "generator create check");
146 attribute
= transform_attribute_create();
147 generator
->generate_payload(generator
,(payload_t
*)attribute
);
148 generator
->write_to_chunk(generator
,&generated_data
);
149 logger
->log_chunk(logger
,RAW
,"generated attribute",&generated_data
);
151 u_int8_t expected_generation
[] = {
154 tester
->assert_true(tester
,(memcmp(expected_generation
,generated_data
.ptr
,sizeof(expected_generation
)) == 0), "compare generated data");
155 allocator_free_chunk(&generated_data
);
156 tester
->assert_true(tester
,(attribute
->destroy(attribute
) == SUCCESS
), "attribute destroy call check");
157 generator
->destroy(generator
);
159 /* test attribute with 2 byte data */
160 generator
= generator_create();
161 tester
->assert_true(tester
,(generator
!= NULL
), "generator create check");
163 attribute
= transform_attribute_create();
164 u_int16_t dataval
= 5768;
166 data
.ptr
= (void *) &dataval
;
169 attribute
->set_value_chunk(attribute
,data
);
171 generator
->generate_payload(generator
,(payload_t
*)attribute
);
172 generator
->write_to_chunk(generator
,&generated_data
);
173 logger
->log_chunk(logger
,RAW
,"generated attribute",&generated_data
);
175 u_int8_t expected_generation2
[] = {
178 tester
->assert_true(tester
,(memcmp(expected_generation2
,generated_data
.ptr
,sizeof(expected_generation2
)) == 0), "compare generated data");
180 allocator_free_chunk(&generated_data
);
181 tester
->assert_true(tester
,(attribute
->destroy(attribute
) == SUCCESS
), "attribute destroy call check");
182 generator
->destroy(generator
);
186 /* test attribute with 25 byte data */
187 generator
= generator_create();
188 tester
->assert_true(tester
,(generator
!= NULL
), "generator create check");
190 attribute
= transform_attribute_create();
191 char *stringval
= "ddddddddddeeeeeeeeeefffff";
192 data
.ptr
= (void *) stringval
;
195 status
= attribute
->set_value_chunk(attribute
,data
);
196 tester
->assert_true(tester
,(status
== SUCCESS
),"set_value call check");
198 status
= attribute
->set_attribute_type(attribute
,456);
199 tester
->assert_true(tester
,(status
== SUCCESS
),"set_attribute_type call check");
202 generator
->generate_payload(generator
,(payload_t
*)attribute
);
203 generator
->write_to_chunk(generator
,&generated_data
);
204 logger
->log_chunk(logger
,RAW
,"generated attribute",&generated_data
);
206 u_int8_t expected_generation3
[] = {
216 tester
->assert_true(tester
,(memcmp(expected_generation3
,generated_data
.ptr
,sizeof(expected_generation3
)) == 0), "compare generated data");
218 allocator_free_chunk(&generated_data
);
219 tester
->assert_true(tester
,(attribute
->destroy(attribute
) == SUCCESS
), "attribute destroy call check");
220 generator
->destroy(generator
);
223 global_logger_manager
->destroy_logger(global_logger_manager
,logger
);
229 * Described in header
231 void test_generator_with_transform_substructure(tester_t
*tester
)
233 generator_t
*generator
;
234 transform_attribute_t
*attribute1
, *attribute2
;
235 transform_substructure_t
*transform
;
238 chunk_t generated_data
;
241 logger
= global_logger_manager
->create_logger(global_logger_manager
,TESTER
,"transform substr.");
243 /* create generator */
244 generator
= generator_create();
245 tester
->assert_true(tester
,(generator
!= NULL
), "generator create check");
247 /* create attribute 1 */
248 attribute1
= transform_attribute_create();
249 char *stringval
= "abcd";
250 data
.ptr
= (void *) stringval
;
252 status
= attribute1
->set_value_chunk(attribute1
,data
);
253 tester
->assert_true(tester
,(status
== SUCCESS
),"set_value call check");
254 status
= attribute1
->set_attribute_type(attribute1
,0);
255 tester
->assert_true(tester
,(status
== SUCCESS
),"set_attribute_type call check");
256 logger
->log(logger
,CONTROL
,"attribute1 created");
258 /* create attribute 2 */
259 attribute2
= transform_attribute_create();
261 data
.ptr
= (void *) stringval
;
263 status
= attribute2
->set_value_chunk(attribute2
,data
);
264 tester
->assert_true(tester
,(status
== SUCCESS
),"set_value call check");
265 status
= attribute2
->set_attribute_type(attribute2
,0);
266 tester
->assert_true(tester
,(status
== SUCCESS
),"set_attribute_type call check");
267 logger
->log(logger
,CONTROL
,"attribute2 created");
269 /* create transform */
270 transform
= transform_substructure_create();
271 tester
->assert_true(tester
,(transform
!= NULL
), "transform create check");
272 status
= transform
->add_transform_attribute(transform
,attribute1
);
273 tester
->assert_true(tester
,(status
== SUCCESS
),"add_transform_attribute call check");
274 status
= transform
->add_transform_attribute(transform
,attribute2
);
275 tester
->assert_true(tester
,(status
== SUCCESS
),"add_transform_attribute call check");
276 status
= transform
->set_transform_type(transform
,5); /* hex 5 */
277 tester
->assert_true(tester
,(status
== SUCCESS
),"set_transform_type call check");
278 status
= transform
->set_transform_id(transform
,65000); /* hex FDE8 */
279 tester
->assert_true(tester
,(status
== SUCCESS
),"set_transform_id call check");
282 logger
->log(logger
,CONTROL
,"transform created");
284 generator
->generate_payload(generator
,(payload_t
*)transform
);
285 generator
->write_to_chunk(generator
,&generated_data
);
286 logger
->log_chunk(logger
,RAW
,"generated transform",&generated_data
);
288 u_int8_t expected_generation3
[] = {
296 tester
->assert_true(tester
,(memcmp(expected_generation3
,generated_data
.ptr
,sizeof(expected_generation3
)) == 0), "compare generated data");
298 allocator_free_chunk(&generated_data
);
299 tester
->assert_true(tester
,(transform
->destroy(transform
) == SUCCESS
), "transform destroy call check");
300 generator
->destroy(generator
);
303 global_logger_manager
->destroy_logger(global_logger_manager
,logger
);
308 * Described in header
310 void test_generator_with_proposal_substructure(tester_t
*tester
)
312 generator_t
*generator
;
313 transform_attribute_t
*attribute1
, *attribute2
, *attribute3
;
314 transform_substructure_t
*transform1
, *transform2
;
315 proposal_substructure_t
*proposal
;
318 chunk_t generated_data
;
321 logger
= global_logger_manager
->create_logger(global_logger_manager
,TESTER
,"transform substr.");
323 /* create generator */
324 generator
= generator_create();
325 tester
->assert_true(tester
,(generator
!= NULL
), "generator create check");
327 /* create attribute 1 */
328 attribute1
= transform_attribute_create();
329 char *stringval
= "abcd";
330 data
.ptr
= (void *) stringval
;
332 status
= attribute1
->set_value_chunk(attribute1
,data
);
333 tester
->assert_true(tester
,(status
== SUCCESS
),"set_value call check");
334 status
= attribute1
->set_attribute_type(attribute1
,0);
335 tester
->assert_true(tester
,(status
== SUCCESS
),"set_attribute_type call check");
336 logger
->log(logger
,CONTROL
,"attribute1 created");
338 /* create attribute 2 */
339 attribute2
= transform_attribute_create();
341 data
.ptr
= (void *) stringval
;
343 status
= attribute2
->set_value_chunk(attribute2
,data
);
344 tester
->assert_true(tester
,(status
== SUCCESS
),"set_value call check");
345 status
= attribute2
->set_attribute_type(attribute2
,0);
346 tester
->assert_true(tester
,(status
== SUCCESS
),"set_attribute_type call check");
347 logger
->log(logger
,CONTROL
,"attribute2 created");
349 /* create attribute 3 */
350 attribute3
= transform_attribute_create();
352 data
.ptr
= (void *) stringval
;
354 status
= attribute3
->set_value_chunk(attribute3
,data
);
355 tester
->assert_true(tester
,(status
== SUCCESS
),"set_value call check");
356 status
= attribute3
->set_attribute_type(attribute3
,0);
357 tester
->assert_true(tester
,(status
== SUCCESS
),"set_attribute_type call check");
358 logger
->log(logger
,CONTROL
,"attribute3 created");
360 /* create transform 1*/
361 transform1
= transform_substructure_create();
362 tester
->assert_true(tester
,(transform1
!= NULL
), "transform create check");
363 status
= transform1
->add_transform_attribute(transform1
,attribute1
);
364 tester
->assert_true(tester
,(status
== SUCCESS
),"add_transform_attribute call check");
365 status
= transform1
->add_transform_attribute(transform1
,attribute2
);
366 tester
->assert_true(tester
,(status
== SUCCESS
),"add_transform_attribute call check");
367 status
= transform1
->set_transform_type(transform1
,5); /* hex 5 */
368 tester
->assert_true(tester
,(status
== SUCCESS
),"set_transform_type call check");
369 status
= transform1
->set_transform_id(transform1
,65000); /* hex FDE8 */
370 tester
->assert_true(tester
,(status
== SUCCESS
),"set_transform_id call check");
372 /* create transform 2*/
373 transform2
= transform_substructure_create();
374 tester
->assert_true(tester
,(transform2
!= NULL
), "transform create check");
375 status
= transform2
->add_transform_attribute(transform2
,attribute3
);
376 tester
->assert_true(tester
,(status
== SUCCESS
),"add_transform_attribute call check");
377 status
= transform2
->set_transform_type(transform2
,3); /* hex 3 */
378 tester
->assert_true(tester
,(status
== SUCCESS
),"set_transform_type call check");
379 status
= transform2
->set_transform_id(transform2
,4); /* hex 4 */
380 tester
->assert_true(tester
,(status
== SUCCESS
),"set_transform_id call check");
382 logger
->log(logger
,CONTROL
,"transforms created");
384 proposal
= proposal_substructure_create();
385 tester
->assert_true(tester
,(proposal
!= NULL
), "proposal create check");
387 stringval
= "ABCDEFGH";
388 data
.ptr
= (void *) stringval
;
391 status
= proposal
->add_transform_substructure(proposal
,transform1
);
392 tester
->assert_true(tester
,(status
== SUCCESS
),"add_transform_substructure call check");
393 status
= proposal
->add_transform_substructure(proposal
,transform2
);
394 tester
->assert_true(tester
,(status
== SUCCESS
),"add_transform_substructure call check");
395 status
= proposal
->set_spi(proposal
,data
);
396 tester
->assert_true(tester
,(status
== SUCCESS
),"set_spi call check");
397 status
= proposal
->set_proposal_number(proposal
,7);
398 tester
->assert_true(tester
,(status
== SUCCESS
),"set_proposal_number call check");
399 status
= proposal
->set_protocol_id(proposal
,4);
400 tester
->assert_true(tester
,(status
== SUCCESS
),"set_protocol_id call check");
403 generator
->generate_payload(generator
,(payload_t
*)proposal
);
404 generator
->write_to_chunk(generator
,&generated_data
);
405 logger
->log_chunk(logger
,RAW
,"generated transform",&generated_data
);
407 u_int8_t expected_generation
[] = {
408 /* proposal header */
414 /* first transform */
417 /* first transform attributes */
422 /* second transform */
425 /* second transform attributes */
429 logger
->log_bytes(logger
,RAW
,"expected transform",expected_generation
,sizeof(expected_generation
));
431 tester
->assert_true(tester
,(memcmp(expected_generation
,generated_data
.ptr
,sizeof(expected_generation
)) == 0), "compare generated data");
433 allocator_free_chunk(&generated_data
);
434 tester
->assert_true(tester
,(proposal
->destroy(proposal
) == SUCCESS
), "proposal destroy call check");
435 generator
->destroy(generator
);
438 global_logger_manager
->destroy_logger(global_logger_manager
,logger
);
442 * Described in header
444 void test_generator_with_sa_payload(tester_t
*tester
)
446 generator_t
*generator
;
447 transform_attribute_t
*attribute1
, *attribute2
, *attribute3
;
448 transform_substructure_t
*transform1
, *transform2
;
449 proposal_substructure_t
*proposal1
, *proposal2
;
450 sa_payload_t
*sa_payload
;
451 ike_header_t
*ike_header
;
455 chunk_t generated_data
;
458 logger
= global_logger_manager
->create_logger(global_logger_manager
,TESTER
,"Message with SA Payload");
460 /* create generator */
461 generator
= generator_create();
462 tester
->assert_true(tester
,(generator
!= NULL
), "generator create check");
464 /* create attribute 1 */
465 attribute1
= transform_attribute_create();
466 char *stringval
= "abcd";
467 data
.ptr
= (void *) stringval
;
469 status
= attribute1
->set_value_chunk(attribute1
,data
);
470 tester
->assert_true(tester
,(status
== SUCCESS
),"set_value call check");
471 status
= attribute1
->set_attribute_type(attribute1
,0);
472 tester
->assert_true(tester
,(status
== SUCCESS
),"set_attribute_type call check");
473 logger
->log(logger
,CONTROL
,"attribute1 created");
475 /* create attribute 2 */
476 attribute2
= transform_attribute_create();
478 data
.ptr
= (void *) stringval
;
480 status
= attribute2
->set_value_chunk(attribute2
,data
);
481 tester
->assert_true(tester
,(status
== SUCCESS
),"set_value call check");
482 status
= attribute2
->set_attribute_type(attribute2
,0);
483 tester
->assert_true(tester
,(status
== SUCCESS
),"set_attribute_type call check");
484 logger
->log(logger
,CONTROL
,"attribute2 created");
486 /* create attribute 3 */
487 attribute3
= transform_attribute_create();
489 data
.ptr
= (void *) stringval
;
491 status
= attribute3
->set_value_chunk(attribute3
,data
);
492 tester
->assert_true(tester
,(status
== SUCCESS
),"set_value call check");
493 status
= attribute3
->set_attribute_type(attribute3
,0);
494 tester
->assert_true(tester
,(status
== SUCCESS
),"set_attribute_type call check");
495 logger
->log(logger
,CONTROL
,"attribute3 created");
497 /* create transform 1*/
498 transform1
= transform_substructure_create();
499 tester
->assert_true(tester
,(transform1
!= NULL
), "transform create check");
500 status
= transform1
->add_transform_attribute(transform1
,attribute1
);
501 tester
->assert_true(tester
,(status
== SUCCESS
),"add_transform_attribute call check");
502 status
= transform1
->add_transform_attribute(transform1
,attribute2
);
503 tester
->assert_true(tester
,(status
== SUCCESS
),"add_transform_attribute call check");
504 status
= transform1
->set_transform_type(transform1
,5); /* hex 5 */
505 tester
->assert_true(tester
,(status
== SUCCESS
),"set_transform_type call check");
506 status
= transform1
->set_transform_id(transform1
,65000); /* hex FDE8 */
507 tester
->assert_true(tester
,(status
== SUCCESS
),"set_transform_id call check");
509 /* create transform 2*/
510 transform2
= transform_substructure_create();
511 tester
->assert_true(tester
,(transform2
!= NULL
), "transform create check");
512 status
= transform2
->add_transform_attribute(transform2
,attribute3
);
513 tester
->assert_true(tester
,(status
== SUCCESS
),"add_transform_attribute call check");
514 status
= transform2
->set_transform_type(transform2
,3); /* hex 3 */
515 tester
->assert_true(tester
,(status
== SUCCESS
),"set_transform_type call check");
516 status
= transform2
->set_transform_id(transform2
,4); /* hex 4 */
517 tester
->assert_true(tester
,(status
== SUCCESS
),"set_transform_id call check");
519 logger
->log(logger
,CONTROL
,"transforms created");
521 /* create proposal 1 */
522 proposal1
= proposal_substructure_create();
523 tester
->assert_true(tester
,(proposal1
!= NULL
), "proposal create check");
525 stringval
= "ABCDEFGH";
526 data
.ptr
= (void *) stringval
;
529 status
= proposal1
->add_transform_substructure(proposal1
,transform1
);
530 tester
->assert_true(tester
,(status
== SUCCESS
),"add_transform_substructure call check");
531 status
= proposal1
->add_transform_substructure(proposal1
,transform2
);
532 tester
->assert_true(tester
,(status
== SUCCESS
),"add_transform_substructure call check");
533 status
= proposal1
->set_spi(proposal1
,data
);
534 tester
->assert_true(tester
,(status
== SUCCESS
),"set_spi call check");
535 status
= proposal1
->set_proposal_number(proposal1
,7);
536 tester
->assert_true(tester
,(status
== SUCCESS
),"set_proposal_number call check");
537 status
= proposal1
->set_protocol_id(proposal1
,4);
538 tester
->assert_true(tester
,(status
== SUCCESS
),"set_protocol_id call check");
540 /* create proposal 2 */
541 proposal2
= proposal_substructure_create();
542 tester
->assert_true(tester
,(proposal2
!= NULL
), "proposal create check");
543 status
= proposal2
->set_proposal_number(proposal2
,7);
544 tester
->assert_true(tester
,(status
== SUCCESS
),"set_proposal_number call check");
545 status
= proposal2
->set_protocol_id(proposal2
,5);
546 tester
->assert_true(tester
,(status
== SUCCESS
),"set_protocol_id call check");
548 /* create sa_payload */
549 sa_payload
= sa_payload_create();
551 sa_payload
->add_proposal_substructure(sa_payload
,proposal1
);
552 sa_payload
->add_proposal_substructure(sa_payload
,proposal2
);
554 ike_header
= ike_header_create();
555 ike_header
->set_initiator_spi(ike_header
,0x22000054231234LL
);
556 ike_header
->set_responder_spi(ike_header
,0x122398);
557 ((payload_t
*) ike_header
)->set_next_type((payload_t
*) ike_header
,SECURITY_ASSOCIATION
);
558 ike_header
->set_exchange_type(ike_header
, 0x12);
559 ike_header
->set_initiator_flag(ike_header
, TRUE
);
560 ike_header
->set_response_flag(ike_header
, TRUE
);
561 ike_header
->set_message_id(ike_header
,0x33AFF3);
563 generator
->generate_payload(generator
,(payload_t
*)ike_header
);
564 generator
->generate_payload(generator
,(payload_t
*)sa_payload
);
565 generator
->write_to_chunk(generator
,&generated_data
);
566 logger
->log_chunk(logger
,RAW
,"generated transform",&generated_data
);
568 u_int8_t expected_generation
[] = {
569 /* sa payload header */
578 /* sa payload header */
580 /* proposal header */
586 /* first transform */
589 /* first transform attributes */
594 /* second transform */
597 /* second transform attributes */
600 /* proposal header 2*/
606 logger
->log_bytes(logger
,RAW
,"expected transform",expected_generation
,sizeof(expected_generation
));
608 tester
->assert_true(tester
,(memcmp(expected_generation
,generated_data
.ptr
,sizeof(expected_generation
)) == 0), "compare generated data");
610 allocator_free_chunk(&generated_data
);
611 tester
->assert_true(tester
,(ike_header
->destroy(ike_header
) == SUCCESS
), "ike_header destroy call check");
612 tester
->assert_true(tester
,(sa_payload
->destroy(sa_payload
) == SUCCESS
), "sa_payload destroy call check");
613 generator
->destroy(generator
);
615 global_logger_manager
->destroy_logger(global_logger_manager
,logger
);
620 * Described in header
622 void test_generator_with_ke_payload(tester_t
*tester
)
624 generator_t
*generator
;
625 ke_payload_t
*ke_payload
;
627 chunk_t generated_data
;
628 chunk_t key_exchange_data
;
630 logger
= global_logger_manager
->create_logger(global_logger_manager
,TESTER
,"Message with KE Payload");
632 /* create generator */
633 generator
= generator_create();
634 tester
->assert_true(tester
,(generator
!= NULL
), "generator create check");
636 ke_payload
= ke_payload_create();
639 key_exchange_data
.ptr
= "test-text";
640 key_exchange_data
.len
= strlen(key_exchange_data
.ptr
);
642 ke_payload
->set_key_exchange_data(ke_payload
,key_exchange_data
);
644 ke_payload
->set_dh_group_number(ke_payload
,7777);
646 generator
->generate_payload(generator
,(payload_t
*)ke_payload
);
647 generator
->write_to_chunk(generator
,&generated_data
);
648 logger
->log_chunk(logger
,RAW
,"generated payload",&generated_data
);
650 u_int8_t expected_generation
[] = {
654 /* key exchange data */
661 logger
->log_bytes(logger
,RAW
,"expected payload",expected_generation
,sizeof(expected_generation
));
663 tester
->assert_true(tester
,(memcmp(expected_generation
,generated_data
.ptr
,sizeof(expected_generation
)) == 0), "compare generated data");
665 allocator_free_chunk(&generated_data
);
667 tester
->assert_true(tester
,(ke_payload
->destroy(ke_payload
) == SUCCESS
), "sa_payload destroy call check");
668 generator
->destroy(generator
);
670 global_logger_manager
->destroy_logger(global_logger_manager
,logger
);
675 * Described in header
677 void test_generator_with_notify_payload(tester_t
*tester
)
679 generator_t
*generator
;
680 notify_payload_t
*notify_payload
;
682 chunk_t generated_data
;
683 chunk_t spi
,notification_data
;
685 logger
= global_logger_manager
->create_logger(global_logger_manager
,TESTER
,"Message with Notify Payload");
687 /* create generator */
688 generator
= generator_create();
689 tester
->assert_true(tester
,(generator
!= NULL
), "generator create check");
691 notify_payload
= notify_payload_create();
695 spi
.len
= strlen(spi
.ptr
);
697 notification_data
.ptr
= "67890";
698 notification_data
.len
= strlen(notification_data
.ptr
);
700 notify_payload
->set_protocol_id(notify_payload
,255);
701 notify_payload
->set_notify_message_type(notify_payload
,63333); /* Hex F765 */
702 notify_payload
->set_spi(notify_payload
,spi
);
703 notify_payload
->set_notification_data(notify_payload
,notification_data
);
705 generator
->generate_payload(generator
,(payload_t
*)notify_payload
);
706 generator
->write_to_chunk(generator
,&generated_data
);
707 logger
->log_chunk(logger
,RAW
,"generated payload",&generated_data
);
709 u_int8_t expected_generation
[] = {
716 /* notification data */
721 logger
->log_bytes(logger
,RAW
,"expected payload",expected_generation
,sizeof(expected_generation
));
723 tester
->assert_true(tester
,(memcmp(expected_generation
,generated_data
.ptr
,sizeof(expected_generation
)) == 0), "compare generated data");
725 allocator_free_chunk(&generated_data
);
727 tester
->assert_true(tester
,(notify_payload
->destroy(notify_payload
) == SUCCESS
), "notify_payload destroy call check");
728 generator
->destroy(generator
);
730 global_logger_manager
->destroy_logger(global_logger_manager
,logger
);
735 * Described in header
737 void test_generator_with_nonce_payload(tester_t
*tester
)
739 generator_t
*generator
;
740 nonce_payload_t
*nonce_payload
;
742 chunk_t generated_data
;
745 logger
= global_logger_manager
->create_logger(global_logger_manager
,TESTER
,"Message with Nonce Payload");
747 /* create generator */
748 generator
= generator_create();
749 tester
->assert_true(tester
,(generator
!= NULL
), "generator create check");
751 nonce_payload
= nonce_payload_create();
754 nonce
.ptr
= "1234567890123456";
755 nonce
.len
= strlen("1234567890123456");
757 nonce_payload
->set_nonce(nonce_payload
,nonce
);
759 generator
->generate_payload(generator
,(payload_t
*)nonce_payload
);
760 generator
->write_to_chunk(generator
,&generated_data
);
761 logger
->log_chunk(logger
,RAW
,"generated payload",&generated_data
);
764 u_int8_t expected_generation
[] = {
774 logger
->log_bytes(logger
,RAW
,"expected payload",expected_generation
,sizeof(expected_generation
));
776 tester
->assert_true(tester
,(memcmp(expected_generation
,generated_data
.ptr
,sizeof(expected_generation
)) == 0), "compare generated data");
778 allocator_free_chunk(&generated_data
);
781 tester
->assert_true(tester
,(nonce_payload
->destroy(nonce_payload
) == SUCCESS
), "notify_payload destroy call check");
782 generator
->destroy(generator
);
784 global_logger_manager
->destroy_logger(global_logger_manager
,logger
);