2 * @file generator_test.c
4 * @brief Tests for the generator_t class.
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>
41 #include <encoding/payloads/id_payload.h>
42 #include <encoding/payloads/auth_payload.h>
43 #include <encoding/payloads/ts_payload.h>
48 void test_generator_with_header_payload(tester_t
*tester
)
50 generator_t
*generator
;
51 ike_header_t
*header_data
;
52 chunk_t generated_data
;
55 logger
= charon
->logger_manager
->create_logger(charon
->logger_manager
,TESTER
,"header payload");
57 header_data
= ike_header_create();
58 header_data
->set_initiator_spi(header_data
,1);
59 header_data
->set_responder_spi(header_data
,2);
60 ((payload_t
*) header_data
)->set_next_type((payload_t
*) header_data
, 3);
61 header_data
->set_exchange_type(header_data
, 6);
62 header_data
->set_initiator_flag(header_data
, TRUE
);
63 header_data
->set_response_flag(header_data
, TRUE
);
64 header_data
->set_message_id(header_data
,7);
66 generator
= generator_create();
67 tester
->assert_true(tester
,(generator
!= NULL
), "generator create check");
69 generator
->generate_payload(generator
,(payload_t
*) header_data
);
71 generator
->write_to_chunk(generator
,&generated_data
);
73 u_int8_t expected_generation
[] = {
83 logger
->log_bytes(logger
,RAW
,"expected header",expected_generation
,sizeof(expected_generation
));
84 tester
->assert_true(tester
,(generated_data
.len
== sizeof(expected_generation
)), "compare generated data length");
85 logger
->log_chunk(logger
,RAW
,"generated header",&generated_data
);
86 tester
->assert_true(tester
,(memcmp(expected_generation
,generated_data
.ptr
,sizeof(expected_generation
)) == 0), "compare generated data 1");
87 allocator_free_chunk(&generated_data
);
89 generator
->destroy(generator
);
91 header_data
->set_initiator_spi(header_data
,0x22000054231234LL
);
92 header_data
->set_responder_spi(header_data
,0x122398);
93 ((payload_t
*) header_data
)->set_next_type((payload_t
*) header_data
,0xF3);
94 header_data
->set_exchange_type(header_data
, 0x12);
95 header_data
->set_initiator_flag(header_data
, TRUE
);
96 header_data
->set_response_flag(header_data
, TRUE
);
97 header_data
->set_message_id(header_data
,0x33AFF3);
99 generator
= generator_create();
100 tester
->assert_true(tester
,(generator
!= NULL
), "generator create check");
102 generator
->generate_payload(generator
,(payload_t
*)header_data
);
104 generator
->write_to_chunk(generator
,&generated_data
);
106 u_int8_t expected_generation2
[] = {
117 logger
->log_bytes(logger
,RAW
,"expected header",expected_generation2
,sizeof(expected_generation2
));
119 logger
->log_chunk(logger
,RAW
,"generated header",&generated_data
);
121 tester
->assert_true(tester
,(memcmp(expected_generation2
,generated_data
.ptr
,sizeof(expected_generation2
)) == 0), "compare generated data 2");
122 allocator_free_chunk(&generated_data
);
124 header_data
->destroy(header_data
);
126 charon
->logger_manager
->destroy_logger(charon
->logger_manager
,logger
);
127 generator
->destroy(generator
);
131 * Described in header
133 void test_generator_with_transform_attribute(tester_t
*tester
)
135 generator_t
*generator
;
136 transform_attribute_t
*attribute
;
137 chunk_t generated_data
;
140 logger
= charon
->logger_manager
->create_logger(charon
->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 attribute
->destroy(attribute
);
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 attribute
->destroy(attribute
);
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 attribute
->set_value_chunk(attribute
,data
);
197 attribute
->set_attribute_type(attribute
,456);
200 generator
->generate_payload(generator
,(payload_t
*)attribute
);
201 generator
->write_to_chunk(generator
,&generated_data
);
202 logger
->log_chunk(logger
,RAW
,"generated attribute",&generated_data
);
204 u_int8_t expected_generation3
[] = {
214 tester
->assert_true(tester
,(memcmp(expected_generation3
,generated_data
.ptr
,sizeof(expected_generation3
)) == 0), "compare generated data");
216 allocator_free_chunk(&generated_data
);
217 attribute
->destroy(attribute
);
218 generator
->destroy(generator
);
221 charon
->logger_manager
->destroy_logger(charon
->logger_manager
,logger
);
227 * Described in header
229 void test_generator_with_transform_substructure(tester_t
*tester
)
231 generator_t
*generator
;
232 transform_attribute_t
*attribute1
, *attribute2
;
233 transform_substructure_t
*transform
;
235 chunk_t generated_data
;
238 logger
= charon
->logger_manager
->create_logger(charon
->logger_manager
,TESTER
,"transform substr.");
240 /* create generator */
241 generator
= generator_create();
242 tester
->assert_true(tester
,(generator
!= NULL
), "generator create check");
244 /* create attribute 1 */
245 attribute1
= transform_attribute_create();
246 char *stringval
= "abcd";
247 data
.ptr
= (void *) stringval
;
249 attribute1
->set_value_chunk(attribute1
,data
);
250 attribute1
->set_attribute_type(attribute1
,0);
251 logger
->log(logger
,CONTROL
,"attribute1 created");
253 /* create attribute 2 */
254 attribute2
= transform_attribute_create();
256 data
.ptr
= (void *) stringval
;
258 attribute2
->set_value_chunk(attribute2
,data
);
259 attribute2
->set_attribute_type(attribute2
,0);
260 logger
->log(logger
,CONTROL
,"attribute2 created");
262 /* create transform */
263 transform
= transform_substructure_create();
264 tester
->assert_true(tester
,(transform
!= NULL
), "transform create check");
265 transform
->add_transform_attribute(transform
,attribute1
);
266 transform
->add_transform_attribute(transform
,attribute2
);
267 transform
->set_transform_type(transform
,5); /* hex 5 */
268 transform
->set_transform_id(transform
,65000); /* hex FDE8 */
271 logger
->log(logger
,CONTROL
,"transform created");
273 generator
->generate_payload(generator
,(payload_t
*)transform
);
274 generator
->write_to_chunk(generator
,&generated_data
);
275 logger
->log_chunk(logger
,RAW
,"generated transform",&generated_data
);
277 u_int8_t expected_generation3
[] = {
285 tester
->assert_true(tester
,(memcmp(expected_generation3
,generated_data
.ptr
,sizeof(expected_generation3
)) == 0), "compare generated data");
287 allocator_free_chunk(&generated_data
);
288 transform
->destroy(transform
);
289 generator
->destroy(generator
);
292 charon
->logger_manager
->destroy_logger(charon
->logger_manager
,logger
);
297 * Described in header
299 void test_generator_with_proposal_substructure(tester_t
*tester
)
301 generator_t
*generator
;
302 transform_attribute_t
*attribute1
, *attribute2
, *attribute3
;
303 transform_substructure_t
*transform1
, *transform2
;
304 proposal_substructure_t
*proposal
;
306 chunk_t generated_data
;
309 logger
= charon
->logger_manager
->create_logger(charon
->logger_manager
,TESTER
,"transform substr.");
311 /* create generator */
312 generator
= generator_create();
313 tester
->assert_true(tester
,(generator
!= NULL
), "generator create check");
315 /* create attribute 1 */
316 attribute1
= transform_attribute_create();
317 char *stringval
= "abcd";
318 data
.ptr
= (void *) stringval
;
320 attribute1
->set_value_chunk(attribute1
,data
);
321 attribute1
->set_attribute_type(attribute1
,0);
323 logger
->log(logger
,CONTROL
,"attribute1 created");
325 /* create attribute 2 */
326 attribute2
= transform_attribute_create();
328 data
.ptr
= (void *) stringval
;
330 attribute2
->set_value_chunk(attribute2
,data
);
331 attribute2
->set_attribute_type(attribute2
,0);
332 logger
->log(logger
,CONTROL
,"attribute2 created");
334 /* create attribute 3 */
335 attribute3
= transform_attribute_create();
337 data
.ptr
= (void *) stringval
;
339 attribute3
->set_value_chunk(attribute3
,data
);
340 attribute3
->set_attribute_type(attribute3
,0);
341 logger
->log(logger
,CONTROL
,"attribute3 created");
343 /* create transform 1*/
344 transform1
= transform_substructure_create();
345 tester
->assert_true(tester
,(transform1
!= NULL
), "transform create check");
346 transform1
->add_transform_attribute(transform1
,attribute1
);
347 transform1
->add_transform_attribute(transform1
,attribute2
);
348 transform1
->set_transform_type(transform1
,5); /* hex 5 */
349 transform1
->set_transform_id(transform1
,65000); /* hex FDE8 */
351 /* create transform 2*/
352 transform2
= transform_substructure_create();
353 tester
->assert_true(tester
,(transform2
!= NULL
), "transform create check");
354 transform2
->add_transform_attribute(transform2
,attribute3
);
355 transform2
->set_transform_type(transform2
,3); /* hex 3 */
356 transform2
->set_transform_id(transform2
,4); /* hex 4 */
358 logger
->log(logger
,CONTROL
,"transforms created");
360 proposal
= proposal_substructure_create();
361 tester
->assert_true(tester
,(proposal
!= NULL
), "proposal create check");
363 stringval
= "ABCDEFGH";
364 data
.ptr
= (void *) stringval
;
367 proposal
->add_transform_substructure(proposal
,transform1
);
368 proposal
->add_transform_substructure(proposal
,transform2
);
369 proposal
->set_spi(proposal
,data
);
370 proposal
->set_proposal_number(proposal
,7);
371 proposal
->set_protocol_id(proposal
,4);
373 generator
->generate_payload(generator
,(payload_t
*)proposal
);
374 generator
->write_to_chunk(generator
,&generated_data
);
375 logger
->log_chunk(logger
,RAW
,"generated transform",&generated_data
);
377 u_int8_t expected_generation
[] = {
378 /* proposal header */
384 /* first transform */
387 /* first transform attributes */
392 /* second transform */
395 /* second transform attributes */
399 logger
->log_bytes(logger
,RAW
,"expected transform",expected_generation
,sizeof(expected_generation
));
401 tester
->assert_true(tester
,(memcmp(expected_generation
,generated_data
.ptr
,sizeof(expected_generation
)) == 0), "compare generated data");
403 allocator_free_chunk(&generated_data
);
404 proposal
->destroy(proposal
);
405 generator
->destroy(generator
);
408 charon
->logger_manager
->destroy_logger(charon
->logger_manager
,logger
);
412 * Described in header
414 void test_generator_with_sa_payload(tester_t
*tester
)
416 generator_t
*generator
;
417 transform_attribute_t
*attribute1
, *attribute2
, *attribute3
;
418 transform_substructure_t
*transform1
, *transform2
;
419 proposal_substructure_t
*proposal1
, *proposal2
;
420 ike_proposal_t
*ike_proposals
;
421 size_t ike_proposal_count
;
422 sa_payload_t
*sa_payload
;
423 ike_header_t
*ike_header
;
426 chunk_t generated_data
;
429 logger
= charon
->logger_manager
->create_logger(charon
->logger_manager
,TESTER
,"Message with SA Payload");
431 /* create generator */
432 generator
= generator_create();
433 tester
->assert_true(tester
,(generator
!= NULL
), "generator create check");
435 /* --------------------------- */
436 /* test first with self created proposals */
438 /* create attribute 1 */
439 attribute1
= transform_attribute_create();
440 char *stringval
= "abcd";
441 data
.ptr
= (void *) stringval
;
443 attribute1
->set_value_chunk(attribute1
,data
);
444 attribute1
->set_attribute_type(attribute1
,0);
445 logger
->log(logger
,CONTROL
,"attribute1 created");
447 /* create attribute 2 */
448 attribute2
= transform_attribute_create();
450 data
.ptr
= (void *) stringval
;
452 attribute2
->set_value_chunk(attribute2
,data
);
453 attribute2
->set_attribute_type(attribute2
,0);
454 logger
->log(logger
,CONTROL
,"attribute2 created");
456 /* create attribute 3 */
457 attribute3
= transform_attribute_create();
459 data
.ptr
= (void *) stringval
;
461 attribute3
->set_value_chunk(attribute3
,data
);
462 attribute3
->set_attribute_type(attribute3
,0);
463 logger
->log(logger
,CONTROL
,"attribute3 created");
465 /* create transform 1*/
466 transform1
= transform_substructure_create();
467 tester
->assert_true(tester
,(transform1
!= NULL
), "transform create check");
468 transform1
->add_transform_attribute(transform1
,attribute1
);
469 transform1
->add_transform_attribute(transform1
,attribute2
);
470 transform1
->set_transform_type(transform1
,5); /* hex 5 */
471 transform1
->set_transform_id(transform1
,65000); /* hex FDE8 */
473 /* create transform 2*/
474 transform2
= transform_substructure_create();
475 tester
->assert_true(tester
,(transform2
!= NULL
), "transform create check");
476 transform2
->add_transform_attribute(transform2
,attribute3
);
477 transform2
->set_transform_type(transform2
,3); /* hex 3 */
478 transform2
->set_transform_id(transform2
,4); /* hex 4 */
480 logger
->log(logger
,CONTROL
,"transforms created");
482 /* create proposal 1 */
483 proposal1
= proposal_substructure_create();
484 tester
->assert_true(tester
,(proposal1
!= NULL
), "proposal create check");
486 stringval
= "ABCDEFGH";
487 data
.ptr
= (void *) stringval
;
490 proposal1
->add_transform_substructure(proposal1
,transform1
);
491 proposal1
->add_transform_substructure(proposal1
,transform2
);
492 proposal1
->set_spi(proposal1
,data
);
493 proposal1
->set_proposal_number(proposal1
,7);
494 proposal1
->set_protocol_id(proposal1
,4);
496 /* create proposal 2 */
497 proposal2
= proposal_substructure_create();
498 tester
->assert_true(tester
,(proposal2
!= NULL
), "proposal create check");
499 proposal2
->set_proposal_number(proposal2
,7);
500 proposal2
->set_protocol_id(proposal2
,5);
502 /* create sa_payload */
503 sa_payload
= sa_payload_create();
505 sa_payload
->add_proposal_substructure(sa_payload
,proposal1
);
506 sa_payload
->add_proposal_substructure(sa_payload
,proposal2
);
508 ike_header
= ike_header_create();
509 ike_header
->set_initiator_spi(ike_header
,0x22000054231234LL
);
510 ike_header
->set_responder_spi(ike_header
,0x122398);
511 ((payload_t
*) ike_header
)->set_next_type((payload_t
*) ike_header
,SECURITY_ASSOCIATION
);
512 ike_header
->set_exchange_type(ike_header
, 0x12);
513 ike_header
->set_initiator_flag(ike_header
, TRUE
);
514 ike_header
->set_response_flag(ike_header
, TRUE
);
515 ike_header
->set_message_id(ike_header
,0x33AFF3);
517 generator
->generate_payload(generator
,(payload_t
*)ike_header
);
518 generator
->generate_payload(generator
,(payload_t
*)sa_payload
);
519 generator
->write_to_chunk(generator
,&generated_data
);
520 logger
->log_chunk(logger
,RAW
,"generated transform",&generated_data
);
522 u_int8_t expected_generation
[] = {
523 /* sa payload header */
532 /* sa payload header */
534 /* proposal header */
540 /* first transform */
543 /* first transform attributes */
548 /* second transform */
551 /* second transform attributes */
554 /* proposal header 2*/
560 logger
->log_bytes(logger
,RAW
,"expected transform",expected_generation
,sizeof(expected_generation
));
562 tester
->assert_true(tester
,(memcmp(expected_generation
,generated_data
.ptr
,sizeof(expected_generation
)) == 0), "compare generated data");
564 allocator_free_chunk(&generated_data
);
565 ike_header
->destroy(ike_header
);
566 sa_payload
->destroy(sa_payload
);
567 generator
->destroy(generator
);
570 /* test with automatic created proposals */
572 generator
= generator_create();
573 tester
->assert_true(tester
,(generator
!= NULL
), "generator create check");
576 ike_proposal_count
= 2;
577 ike_proposals
= allocator_alloc(ike_proposal_count
* (sizeof(ike_proposal_t
)));
579 ike_proposals
[0].encryption_algorithm
= 1;
580 ike_proposals
[0].encryption_algorithm_key_length
= 20;
581 ike_proposals
[0].pseudo_random_function
= 2;
582 ike_proposals
[0].pseudo_random_function_key_length
= 22;
583 ike_proposals
[0].integrity_algorithm
= 3;
584 ike_proposals
[0].integrity_algorithm_key_length
= 24;
585 ike_proposals
[0].diffie_hellman_group
= 4;
587 ike_proposals
[1].encryption_algorithm
= 5;
588 ike_proposals
[1].encryption_algorithm_key_length
= 26;
589 ike_proposals
[1].pseudo_random_function
= 6;
590 ike_proposals
[1].pseudo_random_function_key_length
= 28;
591 ike_proposals
[1].integrity_algorithm
= 7;
592 ike_proposals
[1].integrity_algorithm_key_length
= 30;
593 ike_proposals
[1].diffie_hellman_group
= 8;
595 sa_payload
= sa_payload_create_from_ike_proposals(ike_proposals
,ike_proposal_count
);
596 tester
->assert_true(tester
,(sa_payload
!= NULL
), "sa_payload create check");
598 generator
->generate_payload(generator
,(payload_t
*)sa_payload
);
599 generator
->write_to_chunk(generator
,&generated_data
);
600 logger
->log_chunk(logger
,RAW
,"generated",&generated_data
);
602 u_int8_t expected_generation2
[] = {
603 0x00,0x00,0x00,0x6C, /* payload header*/
604 0x02,0x00,0x00,0x34, /* a proposal */
606 0x03,0x00,0x00,0x0C, /* transform 1 */
608 0x80,0x0E,0x00,0x14, /* keylength attribute with 20 bytes length */
609 0x03,0x00,0x00,0x0C, /* transform 2 */
611 0x80,0x0E,0x00,0x16, /* keylength attribute with 20 bytes length */
612 0x03,0x00,0x00,0x0C, /* transform 3 */
614 0x80,0x0E,0x00,0x18, /* keylength attribute with 20 bytes length */
615 0x00,0x00,0x00,0x08, /* transform 4 */
617 0x00,0x00,0x00,0x34, /* a proposal */
619 0x03,0x00,0x00,0x0C, /* transform 1 */
621 0x80,0x0E,0x00,0x1A, /* keylength attribute with 16 bytes length */
622 0x03,0x00,0x00,0x0C, /* transform 2 */
624 0x80,0x0E,0x00,0x1C, /* keylength attribute with 16 bytes length */
625 0x03,0x00,0x00,0x0C, /* transform 3 */
627 0x80,0x0E,0x00,0x1E, /* keylength attribute with 16 bytes length */
628 0x00,0x00,0x00,0x08, /* transform 4 */
633 logger
->log_bytes(logger
,RAW
,"expected",expected_generation2
,sizeof(expected_generation2
));
635 tester
->assert_true(tester
,(memcmp(expected_generation2
,generated_data
.ptr
,sizeof(expected_generation2
)) == 0), "compare generated data");
637 sa_payload
->destroy(sa_payload
);
638 allocator_free(ike_proposals
);
639 allocator_free_chunk(&generated_data
);
640 generator
->destroy(generator
);
642 charon
->logger_manager
->destroy_logger(charon
->logger_manager
,logger
);
647 * Described in header
649 void test_generator_with_ke_payload(tester_t
*tester
)
651 generator_t
*generator
;
652 ke_payload_t
*ke_payload
;
654 chunk_t generated_data
;
655 chunk_t key_exchange_data
;
657 logger
= charon
->logger_manager
->create_logger(charon
->logger_manager
,TESTER
,"Message with KE Payload");
659 /* create generator */
660 generator
= generator_create();
661 tester
->assert_true(tester
,(generator
!= NULL
), "generator create check");
663 ke_payload
= ke_payload_create();
666 key_exchange_data
.ptr
= "test-text";
667 key_exchange_data
.len
= strlen(key_exchange_data
.ptr
);
669 ke_payload
->set_key_exchange_data(ke_payload
,key_exchange_data
);
671 ke_payload
->set_dh_group_number(ke_payload
,7777);
673 generator
->generate_payload(generator
,(payload_t
*)ke_payload
);
674 generator
->write_to_chunk(generator
,&generated_data
);
675 logger
->log_chunk(logger
,RAW
,"generated payload",&generated_data
);
677 u_int8_t expected_generation
[] = {
681 /* key exchange data */
688 logger
->log_bytes(logger
,RAW
,"expected payload",expected_generation
,sizeof(expected_generation
));
690 tester
->assert_true(tester
,(memcmp(expected_generation
,generated_data
.ptr
,sizeof(expected_generation
)) == 0), "compare generated data");
692 allocator_free_chunk(&generated_data
);
694 ke_payload
->destroy(ke_payload
);
695 generator
->destroy(generator
);
697 charon
->logger_manager
->destroy_logger(charon
->logger_manager
,logger
);
702 * Described in header
704 void test_generator_with_notify_payload(tester_t
*tester
)
706 generator_t
*generator
;
707 notify_payload_t
*notify_payload
;
709 chunk_t generated_data
;
710 chunk_t spi
,notification_data
;
712 logger
= charon
->logger_manager
->create_logger(charon
->logger_manager
,TESTER
,"Message with Notify Payload");
714 /* create generator */
715 generator
= generator_create();
716 tester
->assert_true(tester
,(generator
!= NULL
), "generator create check");
718 notify_payload
= notify_payload_create();
722 spi
.len
= strlen(spi
.ptr
);
724 notification_data
.ptr
= "67890";
725 notification_data
.len
= strlen(notification_data
.ptr
);
727 notify_payload
->set_protocol_id(notify_payload
,255);
728 notify_payload
->set_notify_message_type(notify_payload
,63333); /* Hex F765 */
729 notify_payload
->set_spi(notify_payload
,spi
);
730 notify_payload
->set_notification_data(notify_payload
,notification_data
);
732 generator
->generate_payload(generator
,(payload_t
*)notify_payload
);
733 generator
->write_to_chunk(generator
,&generated_data
);
734 logger
->log_chunk(logger
,RAW
,"generated payload",&generated_data
);
736 u_int8_t expected_generation
[] = {
743 /* notification data */
748 logger
->log_bytes(logger
,RAW
,"expected payload",expected_generation
,sizeof(expected_generation
));
750 tester
->assert_true(tester
,(memcmp(expected_generation
,generated_data
.ptr
,sizeof(expected_generation
)) == 0), "compare generated data");
752 allocator_free_chunk(&generated_data
);
754 notify_payload
->destroy(notify_payload
);
755 generator
->destroy(generator
);
757 charon
->logger_manager
->destroy_logger(charon
->logger_manager
,logger
);
762 * Described in header
764 void test_generator_with_nonce_payload(tester_t
*tester
)
766 generator_t
*generator
;
767 nonce_payload_t
*nonce_payload
;
769 chunk_t generated_data
;
772 logger
= charon
->logger_manager
->create_logger(charon
->logger_manager
,TESTER
,"Message with Nonce Payload");
774 /* create generator */
775 generator
= generator_create();
776 tester
->assert_true(tester
,(generator
!= NULL
), "generator create check");
778 nonce_payload
= nonce_payload_create();
781 nonce
.ptr
= "1234567890123456";
782 nonce
.len
= strlen("1234567890123456");
784 nonce_payload
->set_nonce(nonce_payload
,nonce
);
786 generator
->generate_payload(generator
,(payload_t
*)nonce_payload
);
787 generator
->write_to_chunk(generator
,&generated_data
);
788 logger
->log_chunk(logger
,RAW
,"generated payload",&generated_data
);
791 u_int8_t expected_generation
[] = {
801 logger
->log_bytes(logger
,RAW
,"expected payload",expected_generation
,sizeof(expected_generation
));
803 tester
->assert_true(tester
,(memcmp(expected_generation
,generated_data
.ptr
,sizeof(expected_generation
)) == 0), "compare generated data");
805 allocator_free_chunk(&generated_data
);
808 nonce_payload
->destroy(nonce_payload
);
809 generator
->destroy(generator
);
811 charon
->logger_manager
->destroy_logger(charon
->logger_manager
,logger
);
816 * Described in header.
818 void test_generator_with_id_payload(tester_t
*tester
)
820 generator_t
*generator
;
821 id_payload_t
*id_payload
;
823 chunk_t generated_data
;
826 logger
= charon
->logger_manager
->create_logger(charon
->logger_manager
,TESTER
,"Message with ID Payload");
828 /* create generator */
829 generator
= generator_create();
830 tester
->assert_true(tester
,(generator
!= NULL
), "generator create check");
832 id_payload
= id_payload_create(FALSE
);
835 id
.ptr
= "123456789012";
836 id
.len
= strlen(id
.ptr
);
838 id_payload
->set_id_type(id_payload
,ID_IPV4_ADDR
);
839 id_payload
->set_data(id_payload
,id
);
841 generator
->generate_payload(generator
,(payload_t
*)id_payload
);
842 generator
->write_to_chunk(generator
,&generated_data
);
843 logger
->log_chunk(logger
,RAW
,"generated payload",&generated_data
);
846 u_int8_t expected_generation
[] = {
856 logger
->log_bytes(logger
,RAW
,"expected payload",expected_generation
,sizeof(expected_generation
));
858 tester
->assert_true(tester
,(memcmp(expected_generation
,generated_data
.ptr
,sizeof(expected_generation
)) == 0), "compare generated data");
860 allocator_free_chunk(&generated_data
);
862 id_payload
->destroy(id_payload
);
863 generator
->destroy(generator
);
865 charon
->logger_manager
->destroy_logger(charon
->logger_manager
,logger
);
869 * Described in header.
871 void test_generator_with_auth_payload(tester_t
*tester
)
873 generator_t
*generator
;
874 auth_payload_t
*auth_payload
;
876 chunk_t generated_data
;
879 logger
= charon
->logger_manager
->create_logger(charon
->logger_manager
,TESTER
,"Message with AUTH Payload");
881 /* create generator */
882 generator
= generator_create();
883 tester
->assert_true(tester
,(generator
!= NULL
), "generator create check");
885 auth_payload
= auth_payload_create(FALSE
);
888 auth
.ptr
= "123456789012";
889 auth
.len
= strlen(auth
.ptr
);
891 auth_payload
->set_auth_method(auth_payload
,SHARED_KEY_MESSAGE_INTEGRITY_CODE
);
892 auth_payload
->set_data(auth_payload
,auth
);
894 generator
->generate_payload(generator
,(payload_t
*)auth_payload
);
895 generator
->write_to_chunk(generator
,&generated_data
);
896 logger
->log_chunk(logger
,RAW
,"generated payload",&generated_data
);
899 u_int8_t expected_generation
[] = {
909 logger
->log_bytes(logger
,RAW
,"expected payload",expected_generation
,sizeof(expected_generation
));
911 tester
->assert_true(tester
,(memcmp(expected_generation
,generated_data
.ptr
,sizeof(expected_generation
)) == 0), "compare generated data");
913 allocator_free_chunk(&generated_data
);
915 auth_payload
->destroy(auth_payload
);
916 generator
->destroy(generator
);
918 charon
->logger_manager
->destroy_logger(charon
->logger_manager
,logger
);
922 * Described in header.
924 void test_generator_with_ts_payload(tester_t
*tester
)
926 generator_t
*generator
;
927 ts_payload_t
*ts_payload
;
928 traffic_selector_substructure_t
*ts1
, *ts2
;
929 host_t
*start_host1
, *start_host2
, *end_host1
, *end_host2
;
931 chunk_t generated_data
;
933 logger
= charon
->logger_manager
->create_logger(charon
->logger_manager
,TESTER
,"Message with TS Payload");
935 /* create generator */
936 generator
= generator_create();
937 tester
->assert_true(tester
,(generator
!= NULL
), "generator create check");
939 ts_payload
= ts_payload_create(TRUE
);
941 /* first traffic selector */
942 ts1
= traffic_selector_substructure_create();
944 start_host1
= host_create(AF_INET
,"192.168.1.0",500);
945 ts1
->set_start_host(ts1
,start_host1
);
946 start_host1
->destroy(start_host1
);
948 end_host1
= host_create(AF_INET
,"192.168.1.255",500);
949 ts1
->set_end_host(ts1
,end_host1
);
950 end_host1
->destroy(end_host1
);
952 ts_payload
->add_traffic_selector_substructure(ts_payload
,ts1
);
954 /* second traffic selector */
956 ts2
= traffic_selector_substructure_create();
958 start_host2
= host_create(AF_INET
,"0.0.0.0",0);
959 ts2
->set_start_host(ts2
,start_host2
);
960 ts2
->set_protocol_id(ts2
,3);
961 start_host2
->destroy(start_host2
);
963 end_host2
= host_create(AF_INET
,"255.255.255.255",65535);
964 ts2
->set_end_host(ts2
,end_host2
);
965 end_host2
->destroy(end_host2
);
967 ts_payload
->add_traffic_selector_substructure(ts_payload
,ts2
);
970 generator
->generate_payload(generator
,(payload_t
*)ts_payload
);
971 generator
->write_to_chunk(generator
,&generated_data
);
972 logger
->log_chunk(logger
,RAW
,"generated payload",&generated_data
);
975 u_int8_t expected_generation
[] = {
980 /* traffic selector 1 */
986 /* traffic selector 2 */
993 logger
->log_bytes(logger
,RAW
,"expected payload",expected_generation
,sizeof(expected_generation
));
995 tester
->assert_true(tester
,(memcmp(expected_generation
,generated_data
.ptr
,sizeof(expected_generation
)) == 0), "compare generated data");
997 allocator_free_chunk(&generated_data
);
999 ts_payload
->destroy(ts_payload
);
1000 generator
->destroy(generator
);
1002 charon
->logger_manager
->destroy_logger(charon
->logger_manager
,logger
);