Maemo: Listen for a special "Start" D-BUS call.
[strongswan.git] / src / libcharon / plugins / maemo / maemo_plugin.c
1 /*
2 * Copyright (C) 2010 Tobias Brunner
3 * Hochschule fuer Technik Rapperswil
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License as published by the
7 * Free Software Foundation; either version 2 of the License, or (at your
8 * option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
9 *
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
12 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13 * for more details.
14 */
15
16 #include <glib.h>
17 #include <libosso.h>
18
19 #include "maemo_plugin.h"
20
21 #include <daemon.h>
22 #include <credentials/sets/mem_cred.h>
23 #include <processing/jobs/callback_job.h>
24
25 #define OSSO_CHARON_NAME "charon"
26 #define OSSO_CHARON_SERVICE "org.strongswan."OSSO_CHARON_NAME
27 #define OSSO_CHARON_OBJECT "/org/strongswan/"OSSO_CHARON_NAME
28 #define OSSO_CHARON_IFACE "org.strongswan."OSSO_CHARON_NAME
29
30 typedef struct private_maemo_plugin_t private_maemo_plugin_t;
31
32 /**
33 * private data of maemo plugin
34 */
35 struct private_maemo_plugin_t {
36
37 /**
38 * implements plugin interface
39 */
40 maemo_plugin_t public;
41
42 /**
43 * credentials
44 */
45 mem_cred_t *creds;
46
47 /**
48 * Glib main loop for a thread, handles DBUS calls
49 */
50 GMainLoop *loop;
51
52 /**
53 * Context for OSSO
54 */
55 osso_context_t *context;
56
57 /**
58 * Name of the current connection
59 */
60 gchar *current;
61
62 };
63
64 static gboolean initiate_connection(private_maemo_plugin_t *this,
65 GArray *arguments)
66 {
67 gint i;
68 gchar *hostname = NULL, *cacert = NULL, *username = NULL, *password = NULL;
69 identification_t *gateway = NULL, *user = NULL;
70 ike_cfg_t *ike_cfg;
71 peer_cfg_t *peer_cfg;
72 child_cfg_t *child_cfg;
73 traffic_selector_t *ts;
74 auth_cfg_t *auth;
75 certificate_t *cert;
76 lifetime_cfg_t lifetime = {
77 .time = {
78 .life = 10800, /* 3h */
79 .rekey = 10200, /* 2h50min */
80 .jitter = 300 /* 5min */
81 }
82 };
83
84 if (this->current)
85 {
86 DBG1(DBG_CFG, "currently connected to '%s', disconnect first",
87 this->current);
88 return FALSE;
89 }
90
91 if (arguments->len != 5)
92 {
93 DBG1(DBG_CFG, "wrong number of arguments: %d", arguments->len);
94 return FALSE;
95 }
96
97 for (i = 0; i < arguments->len; i++)
98 {
99 osso_rpc_t *arg = &g_array_index(arguments, osso_rpc_t, i);
100 if (arg->type != DBUS_TYPE_STRING)
101 {
102 DBG1(DBG_CFG, "invalid argument [%d]: %d", i, arg->type);
103 this->current = (g_free(this->current), NULL);
104 return FALSE;
105 }
106 switch (i)
107 {
108 case 0: /* name */
109 this->current = g_strdup(arg->value.s);
110 break;
111 case 1: /* hostname */
112 hostname = arg->value.s;
113 break;
114 case 2: /* CA certificate path */
115 cacert = arg->value.s;
116 break;
117 case 3: /* username */
118 username = arg->value.s;
119 break;
120 case 4: /* password */
121 password = arg->value.s;
122 break;
123 }
124 }
125
126 DBG1(DBG_CFG, "received initiate for connection '%s'", this->current);
127
128 cert = lib->creds->create(lib->creds, CRED_CERTIFICATE, CERT_X509,
129 BUILD_FROM_FILE, cacert, BUILD_END);
130 if (cert)
131 {
132 this->creds->add_cert(this->creds, TRUE, cert);
133 }
134 else
135 {
136 DBG1(DBG_CFG, "failed to load CA certificate");
137 }
138 /* if this is a server cert we could use the cert subject as id */
139
140 gateway = identification_create_from_string(hostname);
141 DBG1(DBG_CFG, "using CA certificate, gateway identitiy '%Y'", gateway);
142
143 {
144 shared_key_t *shared_key;
145 chunk_t secret = chunk_create(password, strlen(password));
146 user = identification_create_from_string(username);
147 shared_key = shared_key_create(SHARED_EAP, chunk_clone(secret));
148 this->creds->add_shared(this->creds, shared_key, user->clone(user),
149 NULL);
150 }
151
152 ike_cfg = ike_cfg_create(TRUE, FALSE, "0.0.0.0", IKEV2_UDP_PORT,
153 hostname, IKEV2_UDP_PORT);
154 ike_cfg->add_proposal(ike_cfg, proposal_create_default(PROTO_IKE));
155
156 peer_cfg = peer_cfg_create(this->current, 2, ike_cfg, CERT_SEND_IF_ASKED,
157 UNIQUE_REPLACE, 1, /* keyingtries */
158 36000, 0, /* rekey 10h, reauth none */
159 600, 600, /* jitter, over 10min */
160 TRUE, 0, /* mobike, DPD */
161 host_create_from_string("0.0.0.0", 0) /* virt */,
162 NULL, FALSE, NULL, NULL); /* pool, mediation */
163
164 auth = auth_cfg_create();
165 auth->add(auth, AUTH_RULE_AUTH_CLASS, AUTH_CLASS_EAP);
166 auth->add(auth, AUTH_RULE_IDENTITY, user);
167 peer_cfg->add_auth_cfg(peer_cfg, auth, TRUE);
168 auth = auth_cfg_create();
169 auth->add(auth, AUTH_RULE_AUTH_CLASS, AUTH_CLASS_PUBKEY);
170 auth->add(auth, AUTH_RULE_IDENTITY, gateway);
171 peer_cfg->add_auth_cfg(peer_cfg, auth, FALSE);
172
173 child_cfg = child_cfg_create(this->current, &lifetime, NULL /* updown */,
174 TRUE, MODE_TUNNEL, ACTION_NONE, ACTION_NONE,
175 FALSE, 0, 0, NULL, NULL);
176 child_cfg->add_proposal(child_cfg, proposal_create_default(PROTO_ESP));
177 ts = traffic_selector_create_dynamic(0, 0, 65535);
178 child_cfg->add_traffic_selector(child_cfg, TRUE, ts);
179 ts = traffic_selector_create_from_string(0, TS_IPV4_ADDR_RANGE, "0.0.0.0",
180 0, "255.255.255.255", 65535);
181 child_cfg->add_traffic_selector(child_cfg, FALSE, ts);
182 peer_cfg->add_child_cfg(peer_cfg, child_cfg);
183
184 if (charon->controller->initiate(charon->controller, peer_cfg, child_cfg,
185 controller_cb_empty, NULL) != SUCCESS)
186 {
187 DBG1(DBG_CFG, "failed to initiate tunnel");
188 this->current = (g_free(this->current), NULL);
189 return FALSE;
190 }
191 return TRUE;
192 }
193
194 static void disconnect(private_maemo_plugin_t *this)
195 {
196 ike_sa_t *ike_sa;
197 u_int id;
198
199 if (!this->current)
200 {
201 return;
202 }
203
204 ike_sa = charon->ike_sa_manager->checkout_by_name(charon->ike_sa_manager,
205 this->current, FALSE);
206 if (ike_sa)
207 {
208 id = ike_sa->get_unique_id(ike_sa);
209 charon->ike_sa_manager->checkin(charon->ike_sa_manager, ike_sa);
210 charon->controller->terminate_ike(charon->controller, id,
211 NULL, NULL);
212 }
213 this->current = (g_free(this->current), NULL);
214 }
215
216 /**
217 * Callback for libosso dbus wrapper
218 */
219 static gint dbus_req_handler(const gchar *interface, const gchar *method,
220 GArray *arguments, private_maemo_plugin_t *this,
221 osso_rpc_t *retval)
222 {
223 if (streq(method, "Start"))
224 { /* void start (void), dummy function to start charon as root */
225 return OSSO_OK;
226 }
227 else if (streq(method, "Connect"))
228 { /* bool connect (name, host, cert, user, pass) */
229 retval->value.b = initiate_connection(this, arguments);
230 retval->type = DBUS_TYPE_BOOLEAN;
231 }
232 else if (streq(method, "Disconnect"))
233 { /* void disconnect (void) */
234 disconnect(this);
235 }
236 else
237 {
238 return OSSO_ERROR;
239 }
240 return OSSO_OK;
241 }
242
243 /**
244 * Main loop to handle D-BUS messages.
245 */
246 static job_requeue_t run(private_maemo_plugin_t *this)
247 {
248 this->loop = g_main_loop_new(NULL, FALSE);
249 g_main_loop_run(this->loop);
250 return JOB_REQUEUE_NONE;
251 }
252
253 METHOD(plugin_t, destroy, void,
254 private_maemo_plugin_t *this)
255 {
256 if (this->loop)
257 {
258 if (g_main_loop_is_running(this->loop))
259 {
260 g_main_loop_quit(this->loop);
261 }
262 g_main_loop_unref(this->loop);
263 }
264 if (this->context)
265 {
266 osso_deinitialize(this->context);
267 }
268 lib->credmgr->remove_set(lib->credmgr, &this->creds->set);
269 this->creds->destroy(this->creds);
270 free(this);
271 }
272
273 /*
274 * See header
275 */
276 plugin_t *maemo_plugin_create()
277 {
278 osso_return_t result;
279 private_maemo_plugin_t *this;
280
281 INIT(this,
282 .public.plugin = {
283 .destroy = _destroy,
284 },
285 .creds = mem_cred_create(),
286 );
287
288 lib->credmgr->add_set(lib->credmgr, &this->creds->set);
289
290 this->context = osso_initialize(OSSO_CHARON_SERVICE, "0.0.1", TRUE, NULL);
291 if (!this->context)
292 {
293 DBG1(DBG_CFG, "failed to initialize OSSO context");
294 destroy(this);
295 return NULL;
296 }
297
298 result = osso_rpc_set_cb_f(this->context,
299 OSSO_CHARON_SERVICE,
300 OSSO_CHARON_OBJECT,
301 OSSO_CHARON_IFACE,
302 (osso_rpc_cb_f*)dbus_req_handler,
303 this);
304 if (result != OSSO_OK)
305 {
306 DBG1(DBG_CFG, "failed to set D-BUS callback (%d)", result);
307 destroy(this);
308 return NULL;
309 }
310
311 this->loop = NULL;
312 if (!g_thread_supported())
313 {
314 g_thread_init(NULL);
315 }
316
317 lib->processor->queue_job(lib->processor,
318 (job_t*)callback_job_create((callback_job_cb_t)run, this, NULL, NULL));
319
320 return &this->public.plugin;
321 }
322