src/charon-cmd/cmd/cmd_connection.c

   1 /*
   2  * Copyright (C) 2013 Martin Willi
   3  * Copyright (C) 2013 revosec AG
   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 "cmd_connection.h"
  17
  18 #include <signal.h>
  19 #include <unistd.h>
  20
  21 #include <utils/debug.h>
  22 #include <processing/jobs/callback_job.h>
  23 #include <daemon.h>
  24
  25 typedef struct private_cmd_connection_t private_cmd_connection_t;
  26
  27 /**
  28  * Private data of an cmd_connection_t object.
  29  */
  30 struct private_cmd_connection_t {
  31
  32         /**
  33          * Public cmd_connection_t interface.
  34          */
  35         cmd_connection_t public;
  36
  37         /**
  38          * Process ID to terminate on failure
  39          */
  40         pid_t pid;
  41
  42         /**
  43          * Hostname to connect to
  44          */
  45         char *host;
  46
  47         /**
  48          * Local identity
  49          */
  50         char *identity;
  51 };
  52
  53 /**
  54  * Shut down application
  55  */
  56 static void terminate(private_cmd_connection_t *this)
  57 {
  58         kill(this->pid, SIGUSR1);
  59 }
  60
  61 /**
  62  * Create peer config with associated ike config
  63  */
  64 static peer_cfg_t* create_peer_cfg(private_cmd_connection_t *this)
  65 {
  66         ike_cfg_t *ike_cfg;
  67         peer_cfg_t *peer_cfg;
  68
  69         ike_cfg = ike_cfg_create(IKEV2, TRUE, FALSE, "0.0.0.0", FALSE,
  70                                                          charon->socket->get_port(charon->socket, FALSE),
  71                                                          this->host, FALSE, IKEV2_UDP_PORT,
  72                                                          FRAGMENTATION_NO, 0);
  73         ike_cfg->add_proposal(ike_cfg, proposal_create_default(PROTO_IKE));
  74         peer_cfg = peer_cfg_create("cmd", ike_cfg,
  75                                         CERT_SEND_IF_ASKED, UNIQUE_REPLACE, 1, /* keyingtries */
  76                                         36000, 0, /* rekey 10h, reauth none */
  77                                         600, 600, /* jitter, over 10min */
  78                                         TRUE, FALSE, /* mobike, aggressive */
  79                                         30, 0, /* DPD delay, timeout */
  80                                         FALSE, NULL, NULL); /* mediation */
  81         peer_cfg->add_virtual_ip(peer_cfg, host_create_from_string("0.0.0.0", 0));
  82
  83         return peer_cfg;
  84 }
  85
  86 /**
  87  * Attach authentication configs to peer config
  88  */
  89 static void add_auth_cfgs(private_cmd_connection_t *this, peer_cfg_t *peer_cfg)
  90 {
  91         auth_cfg_t *auth;
  92
  93         auth = auth_cfg_create();
  94         auth->add(auth, AUTH_RULE_AUTH_CLASS, AUTH_CLASS_PUBKEY);
  95         auth->add(auth, AUTH_RULE_IDENTITY,
  96                           identification_create_from_string(this->identity));
  97         peer_cfg->add_auth_cfg(peer_cfg, auth, TRUE);
  98
  99         auth = auth_cfg_create();
 100
 101         auth->add(auth, AUTH_RULE_IDENTITY,
 102                           identification_create_from_string(this->host));
 103         peer_cfg->add_auth_cfg(peer_cfg, auth, FALSE);
 104 }
 105
 106 /**
 107  * Attach child config to peer config
 108  */
 109 static child_cfg_t* create_child_cfg(private_cmd_connection_t *this)
 110 {
 111         child_cfg_t *child_cfg;
 112         traffic_selector_t *ts;
 113         lifetime_cfg_t lifetime = {
 114                 .time = {
 115                         .life = 10800 /* 3h */,
 116                         .rekey = 10200 /* 2h50min */,
 117                         .jitter = 300 /* 5min */
 118                 }
 119         };
 120
 121         child_cfg = child_cfg_create("cmd", &lifetime,
 122                                                                  NULL, FALSE, MODE_TUNNEL, /* updown, hostaccess */
 123                                                                  ACTION_NONE, ACTION_NONE, ACTION_NONE, FALSE,
 124                                                                  0, 0, NULL, NULL, 0);
 125         child_cfg->add_proposal(child_cfg, proposal_create_default(PROTO_ESP));
 126         ts = traffic_selector_create_dynamic(0, 0, 65535);
 127         child_cfg->add_traffic_selector(child_cfg, TRUE, ts);
 128         ts = traffic_selector_create_from_string(0, TS_IPV4_ADDR_RANGE,
 129                                                                         "0.0.0.0", 0, "255.255.255.255", 65535);
 130         child_cfg->add_traffic_selector(child_cfg, FALSE, ts);
 131
 132         return child_cfg;
 133 }
 134
 135 /**
 136  * Initiate the configured connection
 137  */
 138 static job_requeue_t initiate(private_cmd_connection_t *this)
 139 {
 140         peer_cfg_t *peer_cfg;
 141         child_cfg_t *child_cfg;
 142
 143         if (!this->host)
 144         {
 145                 DBG1(DBG_CFG, "unable to initiate, missing --host option");
 146                 terminate(this);
 147                 return JOB_REQUEUE_NONE;
 148         }
 149         if (!this->identity)
 150         {
 151                 DBG1(DBG_CFG, "unable to initiate, missing --identity option");
 152                 terminate(this);
 153                 return JOB_REQUEUE_NONE;
 154         }
 155
 156         peer_cfg = create_peer_cfg(this);
 157
 158         add_auth_cfgs(this, peer_cfg);
 159
 160         child_cfg = create_child_cfg(this);
 161         peer_cfg->add_child_cfg(peer_cfg, child_cfg->get_ref(child_cfg));
 162
 163         if (charon->controller->initiate(charon->controller, peer_cfg, child_cfg,
 164                                                                          controller_cb_empty, NULL, 0) != SUCCESS)
 165         {
 166                 terminate(this);
 167         }
 168         return JOB_REQUEUE_NONE;
 169 }
 170
 171 METHOD(cmd_connection_t, handle, bool,
 172         private_cmd_connection_t *this, cmd_option_type_t opt, char *arg)
 173 {
 174         switch (opt)
 175         {
 176                 case CMD_OPT_HOST:
 177                         this->host = arg;
 178                         break;
 179                 case CMD_OPT_IDENTITY:
 180                         this->identity = arg;
 181                         break;
 182                 default:
 183                         return FALSE;
 184         }
 185         return TRUE;
 186 }
 187
 188 METHOD(cmd_connection_t, destroy, void,
 189         private_cmd_connection_t *this)
 190 {
 191         free(this);
 192 }
 193
 194 /**
 195  * See header
 196  */
 197 cmd_connection_t *cmd_connection_create()
 198 {
 199         private_cmd_connection_t *this;
 200
 201         INIT(this,
 202                 .public = {
 203                         .handle = _handle,
 204                         .destroy = _destroy,
 205                 },
 206                 .pid = getpid(),
 207         );
 208
 209         /* queue job, gets initiated as soon as we are up and running */
 210         lib->processor->queue_job(lib->processor,
 211                 (job_t*)callback_job_create_with_prio(
 212                         (callback_job_cb_t)initiate, this, NULL,
 213                         (callback_job_cancel_t)return_false, JOB_PRIO_CRITICAL));
 214
 215         return &this->public;
 216 }