- new configuration support added to ike_sa and states
[strongswan.git] / Source / charon / config / configuration_manager.c
1 /**
2 * @file configuration.c
3 *
4 * @brief Configuration class used to store IKE_SA-configurations.
5 *
6 * Object of this type represents the configuration for all IKE_SA's and their child_sa's.
7 *
8 */
9
10 /*
11 * Copyright (C) 2005 Jan Hutter, Martin Willi
12 * Hochschule fuer Technik Rapperswil
13 *
14 * This program is free software; you can redistribute it and/or modify it
15 * under the terms of the GNU General Public License as published by the
16 * Free Software Foundation; either version 2 of the License, or (at your
17 * option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
18 *
19 * This program is distributed in the hope that it will be useful, but
20 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
21 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
22 * for more details.
23 */
24
25 #include <stdlib.h>
26
27 #include "configuration_manager.h"
28
29 #include <types.h>
30 #include <daemon.h>
31 #include <utils/allocator.h>
32
33 typedef struct configuration_entry_t configuration_entry_t;
34
35 /* A configuration entry combines a configuration name with a init and sa
36 * configuration represented as init_config_t and sa_config_t objects.
37 */
38 struct configuration_entry_t {
39
40 /**
41 * Configuration name.
42 *
43 */
44 char *name;
45
46 /**
47 * Configuration for IKE_SA_INIT exchange.
48 */
49 init_config_t *init_config;
50
51 /**
52 * Configuration for all phases after IKE_SA_INIT exchange.
53 */
54 sa_config_t *sa_config;
55
56 /**
57 * Destroys a configuration_entry_t
58 *
59 *
60 * @param this calling object
61 */
62 void (*destroy) (configuration_entry_t *this);
63 };
64
65 static void configuration_entry_destroy (configuration_entry_t *this)
66 {
67 allocator_free(this->name);
68 allocator_free(this);
69 }
70
71 /**
72 * Creates a configuration_entry_t object
73 *
74 * @param name name of the configuration entry (gets copied)
75 * @param init_config object of type init_config_t
76 * @param sa_config object of type sa_config_t
77 */
78 configuration_entry_t * configuration_entry_create(char * name, init_config_t * init_config, sa_config_t * sa_config)
79 {
80 configuration_entry_t *entry = allocator_alloc_thing(configuration_entry_t);
81
82 /* functions */
83 entry->destroy = configuration_entry_destroy;
84
85 /* private data */
86 entry->init_config = init_config;
87 entry->sa_config = sa_config;
88 entry->name = allocator_alloc(strlen(name) + 1);
89 strcpy(entry->name,name);
90 return entry;
91 }
92
93
94 typedef struct private_configuration_manager_t private_configuration_manager_t;
95
96 /**
97 * Private data of an configuration_t object
98 */
99 struct private_configuration_manager_t {
100
101 /**
102 * Public part of configuration manager.
103 */
104 configuration_manager_t public;
105
106 /**
107 * Holding all configurations.
108 */
109 linked_list_t *configurations;
110
111 /**
112 * Holding all init_configs.
113 */
114 linked_list_t *init_configs;
115
116 /**
117 * Holding all init_configs.
118 */
119 linked_list_t *sa_configs;
120
121
122 /**
123 * Assigned logger object.
124 */
125 logger_t *logger;
126
127 /**
128 * Load default configuration
129 *
130 *
131 * @param this calling object
132 * @param name name for the configuration
133 * @param init_config init_config_t object
134 * @param sa_config sa_config_t object
135 */
136 void (*add_new_configuration) (private_configuration_manager_t *this, char *name, init_config_t *init_config, sa_config_t *sa_config);
137
138 /**
139 * Load default configuration
140 *
141 *
142 * @param this calling object
143 */
144 void (*load_default_config) (private_configuration_manager_t *this);
145 };
146
147 /**
148 * Implementation of private_configuration_manager_t.load_default_config.
149 */
150 static void load_default_config (private_configuration_manager_t *this)
151 {
152 init_config_t *init_config1, *init_config2, *init_config3;
153 ike_proposal_t proposals[2];
154 sa_config_t *sa_config;
155
156 init_config1 = init_config_create("152.96.193.130","152.96.193.131",IKEV2_UDP_PORT,IKEV2_UDP_PORT);
157 init_config2 = init_config_create("152.96.193.131","152.96.193.130",IKEV2_UDP_PORT,IKEV2_UDP_PORT);
158 init_config3 = init_config_create("0.0.0.0","127.0.0.1",IKEV2_UDP_PORT,IKEV2_UDP_PORT);
159
160
161 proposals[0].encryption_algorithm = ENCR_AES_CBC;
162 proposals[0].encryption_algorithm_key_length = 20;
163 proposals[0].integrity_algorithm = AUTH_HMAC_SHA1_96;
164 proposals[0].integrity_algorithm_key_length = 20;
165 proposals[0].pseudo_random_function = PRF_HMAC_SHA1;
166 proposals[0].pseudo_random_function_key_length = 20;
167 proposals[0].diffie_hellman_group = MODP_768_BIT;
168
169 proposals[1] = proposals[0];
170 proposals[1].integrity_algorithm = AUTH_HMAC_MD5_96;
171 proposals[1].integrity_algorithm_key_length = 16;
172 proposals[1].pseudo_random_function = PRF_HMAC_MD5;
173 proposals[1].pseudo_random_function_key_length = 16;
174
175 init_config1->add_proposal(init_config1,1,proposals[0]);
176 init_config1->add_proposal(init_config1,1,proposals[1]);
177 init_config2->add_proposal(init_config2,1,proposals[0]);
178 init_config2->add_proposal(init_config2,1,proposals[1]);
179 init_config3->add_proposal(init_config3,1,proposals[0]);
180 init_config3->add_proposal(init_config3,1,proposals[1]);
181
182 this->add_new_configuration(this,"pinflb31",init_config1,sa_config);
183 this->add_new_configuration(this,"pinflb30",init_config2,sa_config);
184 this->add_new_configuration(this,"localhost",init_config3,sa_config);
185
186 }
187
188 /**
189 * Implementation of configuration_manager_t.get_init_config_for_host.
190 */
191 static status_t get_init_config_for_host (private_configuration_manager_t *this, host_t *my_host, host_t *other_host,init_config_t **init_config)
192 {
193 iterator_t *iterator;
194 status_t status = NOT_FOUND;
195
196 iterator = this->configurations->create_iterator(this->configurations,TRUE);
197
198 while (iterator->has_next(iterator))
199 {
200 configuration_entry_t *entry;
201 host_t *config_my_host;
202 host_t *config_other_host;
203
204 iterator->current(iterator,(void **) &entry);
205
206 config_my_host = entry->init_config->get_my_host(entry->init_config);
207 config_other_host = entry->init_config->get_other_host(entry->init_config);
208
209 /* first check if ip is equal */
210 if(config_other_host->ip_is_equal(config_other_host,other_host))
211 {
212 /* could be right one, check my_host for default route*/
213 if (config_my_host->is_default_route(config_my_host))
214 {
215 *init_config = entry->init_config;
216 status = SUCCESS;
217 break;
218 }
219 /* check now if host informations are the same */
220 else if (config_my_host->ip_is_equal(config_my_host,my_host))
221 {
222 *init_config = entry->init_config;
223 status = SUCCESS;
224 break;
225 }
226
227 }
228 /* Then check for wildcard hosts!
229 * TODO
230 * actually its only checked if other host with default route can be found! */
231 else if (config_other_host->is_default_route(config_other_host))
232 {
233 /* could be right one, check my_host for default route*/
234 if (config_my_host->is_default_route(config_my_host))
235 {
236 *init_config = entry->init_config;
237 status = SUCCESS;
238 break;
239 }
240 /* check now if host informations are the same */
241 else if (config_my_host->ip_is_equal(config_my_host,my_host))
242 {
243 *init_config = entry->init_config;
244 status = SUCCESS;
245 break;
246 }
247 }
248 }
249
250 iterator->destroy(iterator);
251
252 return status;
253 }
254
255 /**
256 * Implementation of configuration_manager_t.get_init_config_for_name.
257 */
258 static status_t get_init_config_for_name (private_configuration_manager_t *this, char *name, init_config_t **init_config)
259 {
260 iterator_t *iterator;
261 status_t status = NOT_FOUND;
262
263 iterator = this->configurations->create_iterator(this->configurations,TRUE);
264
265 while (iterator->has_next(iterator))
266 {
267 configuration_entry_t *entry;
268 iterator->current(iterator,(void **) &entry);
269
270 if (strcmp(entry->name,name) == 0)
271 {
272
273 /* found configuration */
274 *init_config = entry->init_config;
275 status = SUCCESS;
276 break;
277 }
278 }
279
280 iterator->destroy(iterator);
281
282 return status;
283 }
284
285 /**
286 * Implementation of configuration_manager_t.get_sa_config_for_name.
287 */
288 static status_t get_sa_config_for_name (private_configuration_manager_t *this, char *name, sa_config_t **sa_config)
289 {
290 iterator_t *iterator;
291 status_t status = NOT_FOUND;
292
293 iterator = this->configurations->create_iterator(this->configurations,TRUE);
294
295 while (iterator->has_next(iterator))
296 {
297 configuration_entry_t *entry;
298 iterator->current(iterator,(void **) &entry);
299
300 if (strcmp(entry->name,name) == 0)
301 {
302 /* found configuration */
303 *sa_config = entry->sa_config;
304 status = SUCCESS;
305 break;
306 }
307 }
308
309 iterator->destroy(iterator);
310
311 return status;
312 }
313
314 /**
315 * Implementation of configuration_manager_t.get_sa_config_for_init_config_and_id.
316 */
317 static status_t get_sa_config_for_init_config_and_id (private_configuration_manager_t *this, init_config_t *init_config, identification_t *other_id, identification_t *my_id,sa_config_t **sa_config)
318 {
319 iterator_t *iterator;
320 status_t status = NOT_FOUND;
321
322 iterator = this->configurations->create_iterator(this->configurations,TRUE);
323
324 while (iterator->has_next(iterator))
325 {
326 configuration_entry_t *entry;
327 iterator->current(iterator,(void **) &entry);
328
329 if (entry->init_config == init_config)
330 {
331 identification_t *config_my_id = entry->sa_config->get_my_id(entry->sa_config);
332 identification_t *config_other_id = entry->sa_config->get_other_id(entry->sa_config);
333
334 /* host informations seem to be the same */
335 if (config_other_id->equals(config_other_id,other_id))
336 {
337 /* other ids seems to match */
338
339 if (my_id == NULL)
340 {
341 /* first matching one is selected */
342
343 /* TODO priorize found entries */
344 *sa_config = entry->sa_config;
345 status = SUCCESS;
346 break;
347 }
348
349 if (config_my_id->equals(config_my_id,my_id))
350 {
351 *sa_config = entry->sa_config;
352 status = SUCCESS;
353 break;
354 }
355
356 }
357 }
358 }
359
360 iterator->destroy(iterator);
361
362 return status;
363 }
364
365 /**
366 * Implementation of private_configuration_manager_t.add_new_configuration.
367 */
368 static void add_new_configuration (private_configuration_manager_t *this, char *name, init_config_t *init_config, sa_config_t *sa_config)
369 {
370 iterator_t *iterator;
371 bool found;
372
373 iterator = this->init_configs->create_iterator(this->init_configs,TRUE);
374 found = FALSE;
375 while (iterator->has_next(iterator))
376 {
377 init_config_t *found_init_config;
378 iterator->current(iterator,(void **) &found_init_config);
379 if (init_config == found_init_config)
380 {
381 found = TRUE;
382 break;
383 }
384 }
385 iterator->destroy(iterator);
386 if (!found)
387 {
388 this->init_configs->insert_first(this->init_configs,init_config);
389 }
390
391 iterator = this->sa_configs->create_iterator(this->sa_configs,TRUE);
392 found = FALSE;
393 while (iterator->has_next(iterator))
394 {
395 sa_config_t *found_sa_config;
396 iterator->current(iterator,(void **) &found_sa_config);
397 if (sa_config == found_sa_config)
398 {
399 found = TRUE;
400 break;
401 }
402 }
403 iterator->destroy(iterator);
404 if (!found)
405 {
406 this->sa_configs->insert_first(this->sa_configs,sa_config);
407 }
408
409 this->configurations->insert_first(this->configurations,configuration_entry_create(name,init_config,sa_config));
410 }
411
412 /**
413 * Implementation of configuration_manager_t.destroy.
414 */
415 static void destroy(private_configuration_manager_t *this)
416 {
417 this->logger->log(this->logger,CONTROL | MORE, "Going to destroy configuration manager ");
418
419 while (this->configurations->get_count(this->configurations) > 0)
420 {
421 configuration_entry_t *entry;
422 this->configurations->remove_first(this->configurations,(void **) &entry);
423 entry->destroy(entry);
424 }
425 /* todo delete all config objects */
426
427 this->configurations->destroy(this->configurations);
428
429 while (this->sa_configs->get_count(this->sa_configs) > 0)
430 {
431 sa_config_t *sa_config;
432 this->sa_configs->remove_first(this->sa_configs,(void **) &sa_config);
433 // sa_config->destroy(sa_config);
434 }
435
436 this->sa_configs->destroy(this->sa_configs);
437
438 while (this->init_configs->get_count(this->init_configs) > 0)
439 {
440 init_config_t *init_config;
441 this->init_configs->remove_first(this->init_configs,(void **) &init_config);
442 init_config->destroy(init_config);
443 }
444 this->init_configs->destroy(this->init_configs);
445
446 this->logger->log(this->logger,CONTROL | MOST, "Destroy assigned logger");
447 charon->logger_manager->destroy_logger(charon->logger_manager,this->logger);
448 allocator_free(this);
449 }
450
451 /*
452 * Described in header-file
453 */
454 configuration_manager_t *configuration_manager_create()
455 {
456 private_configuration_manager_t *this = allocator_alloc_thing(private_configuration_manager_t);
457
458 /* public functions */
459 this->public.destroy = (void(*)(configuration_manager_t*))destroy;
460 this->public.get_init_config_for_name = (status_t (*) (configuration_manager_t *, char *, init_config_t **)) get_init_config_for_name;
461 this->public.get_init_config_for_host = (status_t (*) (configuration_manager_t *, host_t *, host_t *,init_config_t **)) get_init_config_for_host;
462 this->public.get_sa_config_for_name =(status_t (*) (configuration_manager_t *, char *, sa_config_t **)) get_sa_config_for_name;
463 this->public.get_sa_config_for_init_config_and_id =(status_t (*) (configuration_manager_t *, init_config_t *, identification_t *, identification_t *,sa_config_t **)) get_sa_config_for_init_config_and_id;
464
465 /* private functions */
466 this->load_default_config = load_default_config;
467 this->add_new_configuration = add_new_configuration;
468
469 /* private variables */
470 this->logger = charon->logger_manager->create_logger(charon->logger_manager,CONFIGURATION_MANAGER,NULL);
471 this->configurations = linked_list_create();
472 this->sa_configs = linked_list_create();
473 this->init_configs = linked_list_create();
474
475 this->load_default_config(this);
476
477 return (&this->public);
478 }