- reimplemented proper IKE SA deletion using a seperate state,
[strongswan.git] / src / charon / sa / states / ike_sa_init_responded.c
1 /**
2 * @file ike_sa_init_responded.c
3 *
4 * @brief State of a IKE_SA after responding to an IKE_SA_INIT request
5 *
6 */
7
8 /*
9 * Copyright (C) 2005 Jan Hutter, Martin Willi
10 * Hochschule fuer Technik Rapperswil
11 *
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>.
16 *
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
20 * for more details.
21 */
22
23 #include <string.h>
24
25 #include "ike_sa_init_responded.h"
26
27 #include <daemon.h>
28 #include <sa/authenticator.h>
29 #include <sa/child_sa.h>
30 #include <encoding/payloads/ts_payload.h>
31 #include <encoding/payloads/sa_payload.h>
32 #include <encoding/payloads/id_payload.h>
33 #include <encoding/payloads/auth_payload.h>
34 #include <encoding/payloads/notify_payload.h>
35 #include <crypto/signers/signer.h>
36 #include <crypto/crypters/crypter.h>
37 #include <sa/states/ike_sa_established.h>
38
39
40 typedef struct private_ike_sa_init_responded_t private_ike_sa_init_responded_t;
41
42 /**
43 * Private data of a ike_sa_init_responded_t object.
44 *
45 */
46 struct private_ike_sa_init_responded_t {
47 /**
48 * Public interface of ike_sa_init_responded_t.
49 */
50 ike_sa_init_responded_t public;
51
52 /**
53 * Assigned IKE_SA.
54 */
55 protected_ike_sa_t *ike_sa;
56
57 /**
58 * Received nonce.
59 */
60 chunk_t received_nonce;
61
62 /**
63 * Sent nonce.
64 */
65 chunk_t sent_nonce;
66
67 /**
68 * Binary representation of the IKE_SA_INIT response.
69 */
70 chunk_t ike_sa_init_response_data;
71
72 /**
73 * Binary representation of the IKE_SA_INIT request.
74 */
75 chunk_t ike_sa_init_request_data;
76
77 /**
78 * SA config to use.
79 */
80 policy_t *policy;
81
82 /**
83 * CHILD_SA, if set up
84 */
85 child_sa_t *child_sa;
86
87 /**
88 * Traffic selectors applicable at our site
89 */
90 linked_list_t *my_ts;
91
92 /**
93 * Traffic selectors applicable at remote site
94 */
95 linked_list_t *other_ts;
96
97 /**
98 * Assigned logger.
99 *
100 * Is logger of ike_sa!
101 */
102 logger_t *logger;
103
104 /**
105 * Process received IDi and IDr payload and build IDr payload for IKE_AUTH response.
106 *
107 * @param this calling object
108 * @param request_idi ID payload representing initiator
109 * @param request_idr ID payload representing responder (May be zero)
110 * @param response The created IDr payload is added to this message_t object
111 * @param response_idr The created IDr payload is also written to this location
112 */
113 status_t (*build_idr_payload) (private_ike_sa_init_responded_t *this,
114 id_payload_t *request_idi,
115 id_payload_t *request_idr,
116 message_t *response,
117 id_payload_t **response_idr);
118
119 /**
120 * Process received SA payload and build SA payload for IKE_AUTH response.
121 *
122 * @param this calling object
123 * @param request SA payload received in IKE_AUTH request
124 * @param response The created SA payload is added to this message_t object
125 */
126 status_t (*build_sa_payload) (private_ike_sa_init_responded_t *this, sa_payload_t *request, message_t *response);
127
128 /**
129 * Process received AUTH payload and build AUTH payload for IKE_AUTH response.
130 *
131 * @param this calling object
132 * @param request AUTH payload received in IKE_AUTH request
133 * @param other_id_payload other ID payload needed to verify AUTH data
134 * @param my_id_payload my ID payload needed to compute AUTH data
135 * @param response The created AUTH payload is added to this message_t object
136 */
137 status_t (*build_auth_payload) (private_ike_sa_init_responded_t *this, auth_payload_t *request,id_payload_t *other_id_payload,id_payload_t *my_id_payload, message_t* response);
138
139 /**
140 * Process received TS payload and build TS payload for IKE_AUTH response.
141 *
142 * @param this calling object
143 * @param is_initiator type of TS payload. TRUE for TSi, FALSE for TSr
144 * @param request TS payload received in IKE_AUTH request
145 * @param response the created TS payload is added to this message_t object
146 */
147 status_t (*build_ts_payload) (private_ike_sa_init_responded_t *this, bool ts_initiator, ts_payload_t *request, message_t *response);
148
149 /**
150 * Sends a IKE_AUTH reply containing a notify payload.
151 *
152 * @param this calling object
153 * @param notify_payload payload to process
154 * @return
155 * - DESTROY_ME if IKE_SA should be deleted
156 * - SUCCSS if processed successfull
157 */
158 status_t (*process_notify_payload) (private_ike_sa_init_responded_t *this, notify_payload_t* notify_payload);
159
160 /**
161 * Destroy function called internally of this class after state change to
162 * state IKE_SA_ESTABLISHED succeeded.
163 *
164 * This destroy function does not destroy objects which were passed to the new state.
165 *
166 * @param this calling object
167 */
168 void (*destroy_after_state_change) (private_ike_sa_init_responded_t *this);
169 };
170
171 /**
172 * Implements state_t.get_state
173 */
174 static status_t process_message(private_ike_sa_init_responded_t *this, message_t *request)
175 {
176 id_payload_t *idi_request = NULL, *idr_request = NULL,*idr_response;
177 ts_payload_t *tsi_request = NULL, *tsr_request = NULL;
178 auth_payload_t *auth_request = NULL;
179 sa_payload_t *sa_request = NULL;
180 iterator_t *payloads;
181 message_t *response;
182 crypter_t *crypter;
183 signer_t *signer;
184 status_t status;
185 host_t *my_host, *other_host;
186 connection_t *connection;
187
188 if (request->get_exchange_type(request) != IKE_AUTH)
189 {
190 this->logger->log(this->logger, ERROR | LEVEL1, "Message of type %s not supported in state ike_sa_init_responded",
191 mapping_find(exchange_type_m,request->get_exchange_type(request)));
192 return FAILED;
193 }
194
195 if (!request->get_request(request))
196 {
197 this->logger->log(this->logger, ERROR | LEVEL1, "IKE_AUTH responses not allowed state ike_sa_init_responded");
198 return FAILED;
199 }
200
201 /* get signer for verification and crypter for decryption */
202 signer = this->ike_sa->get_signer_initiator(this->ike_sa);
203 crypter = this->ike_sa->get_crypter_initiator(this->ike_sa);
204
205 status = request->parse_body(request, crypter, signer);
206 if (status != SUCCESS)
207 {
208 if (status == NOT_SUPPORTED)
209 {
210 this->logger->log(this->logger, ERROR | LEVEL1, "IKE_AUTH request contains unsupported payload with critical flag set. "
211 "Deleting IKE_SA");
212 this->ike_sa->send_notify(this->ike_sa, IKE_AUTH, UNSUPPORTED_CRITICAL_PAYLOAD, CHUNK_INITIALIZER);
213 return DESTROY_ME;
214 }
215 else
216 {
217 this->logger->log(this->logger, AUDIT, "IKE_AUTH request decryption failed. Ignoring message");
218 }
219 return status;
220 }
221
222 /* iterate over incoming payloads. Message is verified, we can be sure there are the required payloads */
223 payloads = request->get_payload_iterator(request);
224 while (payloads->has_next(payloads))
225 {
226 payload_t *payload;
227 payloads->current(payloads, (void**)&payload);
228
229 switch (payload->get_type(payload))
230 {
231 case ID_INITIATOR:
232 {
233 idi_request = (id_payload_t*)payload;
234 break;
235 }
236 case AUTHENTICATION:
237 {
238 auth_request = (auth_payload_t*)payload;
239 break;
240 }
241 case ID_RESPONDER:
242 {
243 idr_request = (id_payload_t*)payload;
244 break;
245 }
246 case SECURITY_ASSOCIATION:
247 {
248 sa_request = (sa_payload_t*)payload;
249 break;
250 }
251 case TRAFFIC_SELECTOR_INITIATOR:
252 {
253 tsi_request = (ts_payload_t*)payload;
254 break;
255 }
256 case TRAFFIC_SELECTOR_RESPONDER:
257 {
258 tsr_request = (ts_payload_t*)payload;
259 break;
260 }
261 case NOTIFY:
262 {
263 notify_payload_t *notify_payload = (notify_payload_t *) payload;
264 status = this->process_notify_payload(this, notify_payload);
265 if (status != SUCCESS)
266 {
267 payloads->destroy(payloads);
268 return status;
269 }
270 }
271 case CERTIFICATE:
272 {
273 /* TODO handle cert payloads */
274 }
275 case CERTIFICATE_REQUEST:
276 {
277 /* TODO handle certrequest payloads */
278 }
279 default:
280 {
281 this->logger->log(this->logger, ERROR|LEVEL1, "Ignoring payload %s (%d)",
282 mapping_find(payload_type_m, payload->get_type(payload)), payload->get_type(payload));
283 break;
284 }
285 }
286 }
287 /* iterator can be destroyed */
288 payloads->destroy(payloads);
289
290 /* check if we have all payloads */
291 if (!(idi_request && sa_request && auth_request && tsi_request && tsr_request))
292 {
293 this->logger->log(this->logger, AUDIT, "IKE_AUTH reply did not contain all required payloads. Deleting IKE_SA");
294 return DESTROY_ME;
295 }
296
297 /* build response */
298 this->ike_sa->build_message(this->ike_sa, IKE_AUTH, FALSE, &response);
299
300 /* add payloads to it */
301 status = this->build_idr_payload(this, idi_request, idr_request, response, &idr_response);
302 if (status != SUCCESS)
303 {
304 response->destroy(response);
305 return status;
306 }
307 status = this->build_auth_payload(this, auth_request,idi_request, idr_response,response);
308 if (status != SUCCESS)
309 {
310 response->destroy(response);
311 return status;
312 }
313 status = this->build_sa_payload(this, sa_request, response);
314 if (status != SUCCESS)
315 {
316 response->destroy(response);
317 return status;
318 }
319 status = this->build_ts_payload(this, TRUE, tsi_request, response);
320 if (status != SUCCESS)
321 {
322 response->destroy(response);
323 return status;
324 }
325 status = this->build_ts_payload(this, FALSE, tsr_request, response);
326 if (status != SUCCESS)
327 {
328 response->destroy(response);
329 return status;
330 }
331
332 status = this->ike_sa->send_response(this->ike_sa, response);
333 /* message can now be sent (must not be destroyed) */
334 if (status != SUCCESS)
335 {
336 this->logger->log(this->logger, AUDIT, "Unable to send IKE_AUTH reply. Deleting IKE_SA");
337 response->destroy(response);
338 return DESTROY_ME;
339 }
340
341 /* install child SA policies */
342 if (!this->child_sa)
343 {
344 this->logger->log(this->logger, CONTROL, "Proposal negotiation failed, no CHILD_SA built");
345 }
346 else if (this->my_ts->get_count(this->my_ts) == 0 || this->other_ts->get_count(this->other_ts) == 0)
347 {
348 this->logger->log(this->logger, CONTROL, "Traffic selector negotiation failed, no CHILD_SA built");
349 this->child_sa->destroy(this->child_sa);
350 this->child_sa = NULL;
351 }
352 else
353 {
354 status = this->child_sa->add_policies(this->child_sa, this->my_ts, this->other_ts);
355 if (status != SUCCESS)
356 {
357 this->logger->log(this->logger, AUDIT, "Could not install CHILD_SA policy! Deleting IKE_SA");
358 return DESTROY_ME;
359 }
360 this->ike_sa->add_child_sa(this->ike_sa, this->child_sa);
361 }
362
363 /* create new state */
364 this->ike_sa->set_new_state(this->ike_sa, (state_t*)ike_sa_established_create(this->ike_sa));
365 this->destroy_after_state_change(this);
366
367 connection = this->ike_sa->get_connection(this->ike_sa);
368 my_host = connection->get_my_host(connection);
369 other_host = connection->get_other_host(connection);
370 this->logger->log(this->logger, AUDIT, "IKE_SA established between %s - %s",
371 my_host->get_address(my_host), other_host->get_address(other_host));
372
373 return SUCCESS;
374 }
375
376 /**
377 * Implementation of private_ike_sa_init_responded_t.build_idr_payload.
378 */
379 static status_t build_idr_payload(private_ike_sa_init_responded_t *this, id_payload_t *request_idi, id_payload_t *request_idr, message_t *response,id_payload_t **response_idr)
380 {
381 identification_t *other_id, *my_id = NULL;
382 connection_t *connection;
383 id_payload_t *idr_response;
384
385 connection = this->ike_sa->get_connection(this->ike_sa);
386
387 /* update adresses, as connection may contain wildcards, or wrong IDs */
388 other_id = request_idi->get_identification(request_idi);
389 if (request_idr)
390 {
391 my_id = request_idr->get_identification(request_idr);
392 connection->update_my_id(connection, my_id);
393 }
394 else
395 {
396 my_id = connection->get_my_id(connection);
397 }
398 connection->update_other_id(connection, other_id);
399
400 /* build new sa config */
401 this->policy = charon->policies->get_policy(charon->policies, my_id, other_id);
402 if (this->policy == NULL)
403 {
404 this->logger->log(this->logger, AUDIT, "We don't have a policy for IDs %s - %s. Deleting IKE_SA",
405 my_id->get_string(my_id), other_id->get_string(other_id));
406 return DESTROY_ME;
407 }
408
409 /* get my id from policy, which must contain a fully qualified valid id */
410 my_id = this->policy->get_my_id(this->policy);
411
412 /* update others traffic selectors with actually used address */
413 this->policy->update_other_ts(this->policy, response->get_destination(response));
414
415 /* set policy in ike_sa for other states */
416 this->ike_sa->set_policy(this->ike_sa, this->policy);
417
418 /* build response */
419 idr_response = id_payload_create_from_identification(FALSE, my_id);
420 response->add_payload(response, (payload_t*)idr_response);
421 *response_idr = idr_response;
422
423 return SUCCESS;
424 }
425
426 /**
427 * Implementation of private_ike_sa_init_responded_t.build_sa_payload.
428 */
429 static status_t build_sa_payload(private_ike_sa_init_responded_t *this, sa_payload_t *request, message_t *response)
430 {
431 proposal_t *proposal, *proposal_tmp;
432 linked_list_t *proposal_list;
433 sa_payload_t *sa_response;
434 chunk_t seed;
435 prf_plus_t *prf_plus;
436 status_t status;
437 connection_t *connection;
438
439 /* get proposals from request */
440 proposal_list = request->get_proposals(request);
441 if (proposal_list->get_count(proposal_list) == 0)
442 {
443 /* if the other side did not offer any proposals, we do not create child sa's */
444 this->logger->log(this->logger, AUDIT, "IKE_AUH request did not contain any proposals. No CHILD_SA created");
445 sa_response = sa_payload_create();
446 response->add_payload(response, (payload_t*)sa_response);
447 proposal_list->destroy(proposal_list);
448 return SUCCESS;
449 }
450
451 /* now select a proposal */
452 this->logger->log(this->logger, CONTROL|LEVEL1, "Selecting proposals:");
453 proposal = this->policy->select_proposal(this->policy, proposal_list);
454 /* list is not needed anymore */
455 while (proposal_list->remove_last(proposal_list, (void**)&proposal_tmp) == SUCCESS)
456 {
457 proposal_tmp->destroy(proposal_tmp);
458 }
459 proposal_list->destroy(proposal_list);
460 /* do we have a proposal */
461 if (proposal == NULL)
462 {
463 this->logger->log(this->logger, AUDIT, "IKE_AUTH request did not contain any proposals we accept. Deleting IKE_SA");
464 this->ike_sa->send_notify(this->ike_sa, IKE_AUTH, NO_PROPOSAL_CHOSEN, CHUNK_INITIALIZER);
465 return DESTROY_ME;
466 }
467
468 /* set up child sa */
469 seed = chunk_alloc(this->received_nonce.len + this->sent_nonce.len);
470 memcpy(seed.ptr, this->received_nonce.ptr, this->received_nonce.len);
471 memcpy(seed.ptr + this->received_nonce.len, this->sent_nonce.ptr, this->sent_nonce.len);
472 prf_plus = prf_plus_create(this->ike_sa->get_child_prf(this->ike_sa), seed);
473 chunk_free(&seed);
474
475 connection = this->ike_sa->get_connection(this->ike_sa);
476 this->child_sa = child_sa_create(connection->get_my_host(connection),
477 connection->get_other_host(connection));
478
479 status = this->child_sa->add(this->child_sa, proposal, prf_plus);
480 prf_plus->destroy(prf_plus);
481 if (status != SUCCESS)
482 {
483 this->logger->log(this->logger, AUDIT, "Could not install CHILD_SA! Deleting IKE_SA");
484 return DESTROY_ME;
485 }
486
487 /* create payload with selected propsal */
488 sa_response = sa_payload_create_from_proposal(proposal);
489 response->add_payload(response, (payload_t*)sa_response);
490 proposal->destroy(proposal);
491 return SUCCESS;
492 }
493
494 /**
495 * Implementation of private_ike_sa_init_responded_t.build_auth_payload.
496 */
497 static status_t build_auth_payload(private_ike_sa_init_responded_t *this, auth_payload_t *auth_request,id_payload_t *other_id_payload,id_payload_t *my_id_payload, message_t* response)
498 {
499 authenticator_t *authenticator;
500 auth_payload_t *auth_reply;
501 status_t status;
502
503 authenticator = authenticator_create(this->ike_sa);
504 status = authenticator->verify_auth_data(authenticator,auth_request, this->ike_sa_init_request_data,this->sent_nonce,other_id_payload,TRUE);
505
506 if (status != SUCCESS)
507 {
508 this->logger->log(this->logger, AUDIT, "IKE_AUTH request verification failed. Deleting IKE_SA");
509 this->ike_sa->send_notify(this->ike_sa, IKE_AUTH, AUTHENTICATION_FAILED, CHUNK_INITIALIZER);
510 authenticator->destroy(authenticator);
511 return DESTROY_ME;
512 }
513
514 status = authenticator->compute_auth_data(authenticator,&auth_reply, this->ike_sa_init_response_data,this->received_nonce,my_id_payload,FALSE);
515 authenticator->destroy(authenticator);
516 if (status != SUCCESS)
517 {
518 this->logger->log(this->logger, AUDIT, "Unable to build authentication data for IKE_AUTH reply. Deleting IKE_SA");
519 return DESTROY_ME;
520 }
521
522 response->add_payload(response, (payload_t *)auth_reply);
523 return SUCCESS;
524 }
525
526 /**
527 * Implementation of private_ike_sa_init_responded_t.build_ts_payload.
528 */
529 static status_t build_ts_payload(private_ike_sa_init_responded_t *this, bool ts_initiator, ts_payload_t *request, message_t* response)
530 {
531 linked_list_t *ts_received, *ts_selected;
532 traffic_selector_t *ts;
533 status_t status = SUCCESS;
534 ts_payload_t *ts_response;
535
536 /* build a reply payload with selected traffic selectors */
537 ts_received = request->get_traffic_selectors(request);
538 /* select ts depending on payload type */
539 if (ts_initiator)
540 {
541 ts_selected = this->policy->select_other_traffic_selectors(this->policy, ts_received);
542 this->other_ts = ts_selected;
543 }
544 else
545 {
546 ts_selected = this->policy->select_my_traffic_selectors(this->policy, ts_received);
547 this->my_ts = ts_selected;
548 }
549
550 ts_response = ts_payload_create_from_traffic_selectors(ts_initiator, ts_selected);
551 response->add_payload(response, (payload_t*)ts_response);
552
553 /* cleanup */
554 while (ts_received->remove_last(ts_received, (void**)&ts) == SUCCESS)
555 {
556 ts->destroy(ts);
557 }
558 ts_received->destroy(ts_received);
559
560 return status;
561 }
562
563 static status_t process_notify_payload(private_ike_sa_init_responded_t *this, notify_payload_t *notify_payload)
564 {
565 notify_message_type_t notify_message_type = notify_payload->get_notify_message_type(notify_payload);
566
567 this->logger->log(this->logger, CONTROL|LEVEL1, "Process notify type %s",
568 mapping_find(notify_message_type_m, notify_message_type));
569
570 switch (notify_message_type)
571 {
572 case SET_WINDOW_SIZE:
573 /*
574 * TODO Increase window size.
575 */
576 case INITIAL_CONTACT:
577 /*
578 * TODO Delete existing IKE_SA's with other Identity.
579 */
580 default:
581 {
582 this->logger->log(this->logger, AUDIT, "IKE_AUTH request contained an unknown notify (%d), ignored.", notify_message_type);
583 }
584 }
585
586 return SUCCESS;
587 }
588
589 /**
590 * Implementation of state_t.get_state.
591 */
592 static ike_sa_state_t get_state(private_ike_sa_init_responded_t *this)
593 {
594 return IKE_SA_INIT_RESPONDED;
595 }
596
597 /**
598 * Implementation of state_t.destroy.
599 */
600 static void destroy(private_ike_sa_init_responded_t *this)
601 {
602 chunk_free(&(this->received_nonce));
603 chunk_free(&(this->sent_nonce));
604 chunk_free(&(this->ike_sa_init_response_data));
605 chunk_free(&(this->ike_sa_init_request_data));
606 if (this->my_ts)
607 {
608 traffic_selector_t *ts;
609 while (this->my_ts->remove_last(this->my_ts, (void**)&ts) == SUCCESS)
610 {
611 ts->destroy(ts);
612 }
613 this->my_ts->destroy(this->my_ts);
614 }
615 if (this->other_ts)
616 {
617 traffic_selector_t *ts;
618 while (this->other_ts->remove_last(this->other_ts, (void**)&ts) == SUCCESS)
619 {
620 ts->destroy(ts);
621 }
622 this->other_ts->destroy(this->other_ts);
623 }
624 if (this->child_sa)
625 {
626 this->child_sa->destroy(this->child_sa);
627 }
628
629 free(this);
630 }
631 /**
632 * Implementation of private_ike_sa_init_responded.destroy_after_state_change.
633 */
634 static void destroy_after_state_change(private_ike_sa_init_responded_t *this)
635 {
636 chunk_free(&(this->received_nonce));
637 chunk_free(&(this->sent_nonce));
638 chunk_free(&(this->ike_sa_init_response_data));
639 chunk_free(&(this->ike_sa_init_request_data));
640 if (this->my_ts)
641 {
642 traffic_selector_t *ts;
643 while (this->my_ts->remove_last(this->my_ts, (void**)&ts) == SUCCESS)
644 {
645 ts->destroy(ts);
646 }
647 this->my_ts->destroy(this->my_ts);
648 }
649 if (this->other_ts)
650 {
651 traffic_selector_t *ts;
652 while (this->other_ts->remove_last(this->other_ts, (void**)&ts) == SUCCESS)
653 {
654 ts->destroy(ts);
655 }
656 this->other_ts->destroy(this->other_ts);
657 }
658
659 free(this);
660 }
661
662 /*
663 * Described in header.
664 */
665 ike_sa_init_responded_t *ike_sa_init_responded_create(protected_ike_sa_t *ike_sa, chunk_t received_nonce, chunk_t sent_nonce,chunk_t ike_sa_init_request_data, chunk_t ike_sa_init_response_data)
666 {
667 private_ike_sa_init_responded_t *this = malloc_thing(private_ike_sa_init_responded_t);
668
669 /* interface functions */
670 this->public.state_interface.process_message = (status_t (*) (state_t *,message_t *)) process_message;
671 this->public.state_interface.get_state = (ike_sa_state_t (*) (state_t *)) get_state;
672 this->public.state_interface.destroy = (void (*) (state_t *)) destroy;
673
674 /* private functions */
675 this->build_idr_payload = build_idr_payload;
676 this->build_sa_payload = build_sa_payload;
677 this->build_auth_payload = build_auth_payload;
678 this->build_ts_payload = build_ts_payload;
679 this->process_notify_payload = process_notify_payload;
680 this->destroy_after_state_change = destroy_after_state_change;
681
682 /* private data */
683 this->ike_sa = ike_sa;
684 this->received_nonce = received_nonce;
685 this->sent_nonce = sent_nonce;
686 this->ike_sa_init_response_data = ike_sa_init_response_data;
687 this->ike_sa_init_request_data = ike_sa_init_request_data;
688 this->my_ts = NULL;
689 this->other_ts = NULL;
690 this->child_sa = NULL;
691 this->logger = logger_manager->get_logger(logger_manager, IKE_SA);
692
693 return &(this->public);
694 }