904 lines
25 KiB
C
Executable File
904 lines
25 KiB
C
Executable File
/**
|
||
* @file stroke.c
|
||
*
|
||
* @brief Implementation of stroke_t.
|
||
*
|
||
*/
|
||
|
||
/*
|
||
* Copyright (C) 2006 Martin Willi
|
||
* Hochschule fuer Technik Rapperswil
|
||
*
|
||
* This program is free software; you can redistribute it and/or modify it
|
||
* under the terms of the GNU General Public License as published by the
|
||
* Free Software Foundation; either version 2 of the License, or (at your
|
||
* option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
|
||
*
|
||
* This program is distributed in the hope that it will be useful, but
|
||
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
||
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||
* for more details.
|
||
*/
|
||
|
||
#include <stdlib.h>
|
||
#include <sys/types.h>
|
||
#include <sys/stat.h>
|
||
#include <sys/socket.h>
|
||
#include <sys/un.h>
|
||
#include <sys/fcntl.h>
|
||
#include <unistd.h>
|
||
#include <dirent.h>
|
||
#include <errno.h>
|
||
#include <pthread.h>
|
||
|
||
#include "stroke_interface.h"
|
||
|
||
#include <stroke.h>
|
||
#include <types.h>
|
||
#include <daemon.h>
|
||
#include <crypto/x509.h>
|
||
#include <queues/jobs/initiate_ike_sa_job.h>
|
||
|
||
#define IKE_PORT 500
|
||
#define PATH_BUF 256
|
||
|
||
|
||
struct sockaddr_un socket_addr = { AF_UNIX, STROKE_SOCKET};
|
||
|
||
|
||
typedef struct private_stroke_t private_stroke_t;
|
||
|
||
/**
|
||
* Private data of an stroke_t object.
|
||
*/
|
||
struct private_stroke_t {
|
||
|
||
/**
|
||
* Public part of stroke_t object.
|
||
*/
|
||
stroke_t public;
|
||
|
||
/**
|
||
* Assigned logger_t object in charon.
|
||
*/
|
||
logger_t *logger;
|
||
|
||
/**
|
||
* Logger which logs to stroke
|
||
*/
|
||
logger_t *stroke_logger;
|
||
|
||
/**
|
||
* Unix socket to listen for strokes
|
||
*/
|
||
int socket;
|
||
|
||
/**
|
||
* Thread which reads from the ocket
|
||
*/
|
||
pthread_t assigned_thread;
|
||
|
||
/**
|
||
* Read from the socket and handle stroke messages
|
||
*/
|
||
void (*stroke_receive) (private_stroke_t *this);
|
||
};
|
||
|
||
/**
|
||
* Helper function which corrects the string pointers
|
||
* in a stroke_msg_t. Strings in a stroke_msg sent over "wire"
|
||
* contains RELATIVE addresses (relative to the beginning of the
|
||
* stroke_msg). They must be corrected if they reach our address
|
||
* space...
|
||
*/
|
||
static void pop_string(stroke_msg_t *msg, char **string)
|
||
{
|
||
if (*string == NULL)
|
||
return;
|
||
|
||
/* check for sanity of string pointer and string */
|
||
if (string < (char**)msg
|
||
|| string > (char**)msg + sizeof(stroke_msg_t)
|
||
|| (u_int)*string < (u_int)((char*)msg->buffer - (char*)msg)
|
||
|| (u_int)*string > msg->length)
|
||
{
|
||
*string = "(invalid pointer in stroke msg)";
|
||
}
|
||
else
|
||
{
|
||
*string = (char*)msg + (u_int)*string;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Load end entitity certificate
|
||
*/
|
||
static x509_t* load_end_certificate(const char *filename, identification_t **idp, logger_t *logger)
|
||
{
|
||
char path[PATH_BUF];
|
||
x509_t *cert;
|
||
|
||
if (*filename == '/')
|
||
{
|
||
/* absolute path name */
|
||
snprintf(path, sizeof(path), "%s", filename);
|
||
}
|
||
else
|
||
{
|
||
/* relative path name */
|
||
snprintf(path, sizeof(path), "%s/%s", CERTIFICATE_DIR, filename);
|
||
}
|
||
|
||
cert = x509_create_from_file(path, "end entity certificate");
|
||
|
||
if (cert)
|
||
{
|
||
identification_t *id = *idp;
|
||
identification_t *subject = cert->get_subject(cert);
|
||
|
||
err_t ugh = cert->is_valid(cert, NULL);
|
||
|
||
if (ugh != NULL)
|
||
{
|
||
logger->log(logger, ERROR, "warning: certificate %s", ugh);
|
||
}
|
||
if (!id->equals(id, subject) && !cert->equals_subjectAltName(cert, id))
|
||
{
|
||
id->destroy(id);
|
||
id = subject;
|
||
*idp = id->clone(id);
|
||
}
|
||
return charon->credentials->add_end_certificate(charon->credentials, cert);
|
||
}
|
||
return NULL;
|
||
}
|
||
|
||
/**
|
||
* Add a connection to the configuration list
|
||
*/
|
||
static void stroke_add_conn(private_stroke_t *this, stroke_msg_t *msg)
|
||
{
|
||
connection_t *connection;
|
||
policy_t *policy;
|
||
identification_t *my_id, *other_id;
|
||
identification_t *my_ca = NULL;
|
||
identification_t *other_ca = NULL;
|
||
bool my_ca_same = FALSE;
|
||
bool other_ca_same =FALSE;
|
||
host_t *my_host, *other_host, *my_subnet, *other_subnet;
|
||
proposal_t *proposal;
|
||
traffic_selector_t *my_ts, *other_ts;
|
||
|
||
pop_string(msg, &msg->add_conn.name);
|
||
pop_string(msg, &msg->add_conn.me.address);
|
||
pop_string(msg, &msg->add_conn.other.address);
|
||
pop_string(msg, &msg->add_conn.me.subnet);
|
||
pop_string(msg, &msg->add_conn.other.subnet);
|
||
pop_string(msg, &msg->add_conn.me.id);
|
||
pop_string(msg, &msg->add_conn.other.id);
|
||
pop_string(msg, &msg->add_conn.me.cert);
|
||
pop_string(msg, &msg->add_conn.other.cert);
|
||
pop_string(msg, &msg->add_conn.me.ca);
|
||
pop_string(msg, &msg->add_conn.other.ca);
|
||
pop_string(msg, &msg->add_conn.me.updown);
|
||
pop_string(msg, &msg->add_conn.other.updown);
|
||
pop_string(msg, &msg->add_conn.algorithms.ike);
|
||
pop_string(msg, &msg->add_conn.algorithms.esp);
|
||
|
||
this->logger->log(this->logger, CONTROL, "received stroke: add connection \"%s\"", msg->add_conn.name);
|
||
|
||
my_host = msg->add_conn.me.address?
|
||
host_create(AF_INET, msg->add_conn.me.address, IKE_PORT) : NULL;
|
||
if (my_host == NULL)
|
||
{
|
||
this->stroke_logger->log(this->stroke_logger, ERROR, "invalid host: %s", msg->add_conn.me.address);
|
||
return;
|
||
}
|
||
|
||
other_host = msg->add_conn.other.address ?
|
||
host_create(AF_INET, msg->add_conn.other.address, IKE_PORT) : NULL;
|
||
if (other_host == NULL)
|
||
{
|
||
this->stroke_logger->log(this->stroke_logger, ERROR, "invalid host: %s", msg->add_conn.other.address);
|
||
my_host->destroy(my_host);
|
||
return;
|
||
}
|
||
|
||
if (charon->interfaces->is_local_address(charon->interfaces, other_host))
|
||
{
|
||
stroke_end_t tmp_end;
|
||
host_t *tmp_host;
|
||
|
||
this->stroke_logger->log(this->stroke_logger, CONTROL|LEVEL1, "left is other host, swapping ends");
|
||
|
||
tmp_host = my_host;
|
||
my_host = other_host;
|
||
other_host = tmp_host;
|
||
|
||
tmp_end = msg->add_conn.me;
|
||
msg->add_conn.me = msg->add_conn.other;
|
||
msg->add_conn.other = tmp_end;
|
||
}
|
||
else if (!charon->interfaces->is_local_address(charon->interfaces, my_host))
|
||
{
|
||
this->stroke_logger->log(this->stroke_logger, ERROR, "left nor right host is our side, aborting");
|
||
goto destroy_hosts;
|
||
}
|
||
|
||
my_id = identification_create_from_string(msg->add_conn.me.id ?
|
||
msg->add_conn.me.id : msg->add_conn.me.address);
|
||
if (my_id == NULL)
|
||
{
|
||
this->stroke_logger->log(this->stroke_logger, ERROR, "invalid id: %s", msg->add_conn.me.id);
|
||
goto destroy_hosts;
|
||
}
|
||
|
||
other_id = identification_create_from_string(msg->add_conn.other.id ?
|
||
msg->add_conn.other.id : msg->add_conn.other.address);
|
||
if (other_id == NULL)
|
||
{
|
||
this->stroke_logger->log(this->stroke_logger, ERROR, "invalid id: %s", msg->add_conn.other.id);
|
||
my_id->destroy(my_id);
|
||
goto destroy_hosts;
|
||
}
|
||
|
||
my_subnet = host_create(AF_INET, msg->add_conn.me.subnet ?
|
||
msg->add_conn.me.subnet : msg->add_conn.me.address, IKE_PORT);
|
||
if (my_subnet == NULL)
|
||
{
|
||
this->stroke_logger->log(this->stroke_logger, ERROR, "invalid subnet: %s", msg->add_conn.me.subnet);
|
||
goto destroy_ids;
|
||
}
|
||
|
||
other_subnet = host_create(AF_INET, msg->add_conn.other.subnet ?
|
||
msg->add_conn.other.subnet : msg->add_conn.other.address, IKE_PORT);
|
||
if (other_subnet == NULL)
|
||
{
|
||
this->stroke_logger->log(this->stroke_logger, ERROR, "invalid subnet: %s", msg->add_conn.me.subnet);
|
||
my_subnet->destroy(my_subnet);
|
||
goto destroy_ids;
|
||
}
|
||
|
||
my_ts = traffic_selector_create_from_subnet(my_subnet,
|
||
msg->add_conn.me.subnet ? msg->add_conn.me.subnet_mask : 32,
|
||
msg->add_conn.me.protocol, msg->add_conn.me.port);
|
||
my_subnet->destroy(my_subnet);
|
||
|
||
other_ts = traffic_selector_create_from_subnet(other_subnet,
|
||
msg->add_conn.other.subnet ? msg->add_conn.other.subnet_mask : 32,
|
||
msg->add_conn.other.protocol, msg->add_conn.other.port);
|
||
other_subnet->destroy(other_subnet);
|
||
|
||
if (msg->add_conn.me.ca)
|
||
{
|
||
if (streq(msg->add_conn.me.ca, "%same"))
|
||
{
|
||
my_ca_same = TRUE;
|
||
}
|
||
else
|
||
{
|
||
my_ca = identification_create_from_string(msg->add_conn.me.ca);
|
||
}
|
||
}
|
||
if (msg->add_conn.other.ca)
|
||
{
|
||
if (streq(msg->add_conn.other.ca, "%same"))
|
||
{
|
||
other_ca_same = TRUE;
|
||
}
|
||
else
|
||
{
|
||
other_ca = identification_create_from_string(msg->add_conn.other.ca);
|
||
}
|
||
}
|
||
if (msg->add_conn.me.cert)
|
||
{
|
||
x509_t *cert = load_end_certificate(msg->add_conn.me.cert, &my_id, this->logger);
|
||
|
||
if (my_ca == NULL && !my_ca_same && cert)
|
||
{
|
||
identification_t *issuer = cert->get_issuer(cert);
|
||
|
||
my_ca = issuer->clone(issuer);
|
||
}
|
||
}
|
||
if (msg->add_conn.other.cert)
|
||
{
|
||
x509_t *cert = load_end_certificate(msg->add_conn.other.cert, &other_id, this->logger);
|
||
|
||
if (other_ca == NULL && !other_ca_same && cert)
|
||
{
|
||
identification_t *issuer = cert->get_issuer(cert);
|
||
|
||
other_ca = issuer->clone(issuer);
|
||
}
|
||
}
|
||
if (other_ca_same && my_ca)
|
||
{
|
||
other_ca = my_ca->clone(my_ca);
|
||
}
|
||
else if (my_ca_same && other_ca)
|
||
{
|
||
my_ca = other_ca->clone(other_ca);
|
||
}
|
||
if (my_ca == NULL)
|
||
{
|
||
my_ca = identification_create_from_string("%any");
|
||
}
|
||
if (other_ca == NULL)
|
||
{
|
||
other_ca = identification_create_from_string("%any");
|
||
}
|
||
this->logger->log(this->logger, CONTROL|LEVEL1, " my ca: '%s'", my_ca->get_string(my_ca));
|
||
this->logger->log(this->logger, CONTROL|LEVEL1, " other ca:'%s'", other_ca->get_string(other_ca));
|
||
this->logger->log(this->logger, CONTROL|LEVEL1, " updown:'%s'", msg->add_conn.me.updown);
|
||
|
||
connection = connection_create(msg->add_conn.name,
|
||
msg->add_conn.ikev2,
|
||
msg->add_conn.me.sendcert,
|
||
msg->add_conn.other.sendcert,
|
||
my_host, other_host,
|
||
RSA_DIGITAL_SIGNATURE
|
||
);
|
||
|
||
if (msg->add_conn.algorithms.ike)
|
||
{
|
||
char *proposal_string;
|
||
char *strict = msg->add_conn.algorithms.ike + strlen(msg->add_conn.algorithms.ike) - 1;
|
||
|
||
if (*strict == '!')
|
||
*strict = '\0';
|
||
else
|
||
strict = NULL;
|
||
|
||
while ((proposal_string = strsep(&msg->add_conn.algorithms.ike, ",")))
|
||
{
|
||
proposal = proposal_create_from_string(PROTO_IKE, proposal_string);
|
||
if (proposal == NULL)
|
||
{
|
||
this->logger->log(this->logger, ERROR, "invalid IKE proposal string: %s", msg->add_conn.algorithms.esp);
|
||
my_id->destroy(my_id);
|
||
other_id->destroy(other_id);
|
||
my_ts->destroy(my_ts);
|
||
other_ts->destroy(other_ts);
|
||
my_ca->destroy(my_ca);
|
||
other_ca->destroy(other_ca);
|
||
connection->destroy(connection);
|
||
return;
|
||
}
|
||
connection->add_proposal(connection, proposal);
|
||
}
|
||
if (!strict)
|
||
{
|
||
proposal = proposal_create_default(PROTO_IKE);
|
||
connection->add_proposal(connection, proposal);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
proposal = proposal_create_default(PROTO_IKE);
|
||
connection->add_proposal(connection, proposal);
|
||
}
|
||
|
||
policy = policy_create(msg->add_conn.name, my_id, other_id,
|
||
msg->add_conn.rekey.ipsec_lifetime,
|
||
msg->add_conn.rekey.ipsec_lifetime - msg->add_conn.rekey.margin,
|
||
msg->add_conn.rekey.margin * msg->add_conn.rekey.fuzz / 100);
|
||
policy->add_my_traffic_selector(policy, my_ts);
|
||
policy->add_other_traffic_selector(policy, other_ts);
|
||
policy->add_authorities(policy, my_ca, other_ca);
|
||
policy->add_updown(policy, msg->add_conn.me.updown);
|
||
|
||
if (msg->add_conn.algorithms.esp)
|
||
{
|
||
char *proposal_string;
|
||
char *strict = msg->add_conn.algorithms.esp + strlen(msg->add_conn.algorithms.esp) - 1;
|
||
|
||
if (*strict == '!')
|
||
*strict = '\0';
|
||
else
|
||
strict = NULL;
|
||
|
||
while ((proposal_string = strsep(&msg->add_conn.algorithms.esp, ",")))
|
||
{
|
||
proposal = proposal_create_from_string(PROTO_ESP, proposal_string);
|
||
if (proposal == NULL)
|
||
{
|
||
this->logger->log(this->logger, ERROR,
|
||
"invalid ESP proposal string: %s", msg->add_conn.algorithms.esp);
|
||
policy->destroy(policy);
|
||
connection->destroy(connection);
|
||
return;
|
||
}
|
||
policy->add_proposal(policy, proposal);
|
||
}
|
||
if (!strict)
|
||
{
|
||
proposal = proposal_create_default(PROTO_ESP);
|
||
policy->add_proposal(policy, proposal);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
proposal = proposal_create_default(PROTO_ESP);
|
||
policy->add_proposal(policy, proposal);
|
||
}
|
||
|
||
/* add to global connection list */
|
||
charon->connections->add_connection(charon->connections, connection);
|
||
this->logger->log(this->logger, CONTROL, "added connection \"%s\": %s[%s]...%s[%s]",
|
||
msg->add_conn.name,
|
||
my_host->get_string(my_host),
|
||
my_id->get_string(my_id),
|
||
other_host->get_string(other_host),
|
||
other_id->get_string(other_id));
|
||
/* add to global policy list */
|
||
charon->policies->add_policy(charon->policies, policy);
|
||
return;
|
||
|
||
/* mopping up after parsing errors */
|
||
|
||
destroy_ids:
|
||
my_id->destroy(my_id);
|
||
other_id->destroy(other_id);
|
||
|
||
destroy_hosts:
|
||
my_host->destroy(my_host);
|
||
other_host->destroy(other_host);
|
||
}
|
||
|
||
/**
|
||
* Delete a connection from the list
|
||
*/
|
||
static void stroke_del_conn(private_stroke_t *this, stroke_msg_t *msg)
|
||
{
|
||
status_t status;
|
||
|
||
pop_string(msg, &(msg->del_conn.name));
|
||
this->logger->log(this->logger, CONTROL, "received stroke: delete \"%s\"", msg->del_conn.name);
|
||
|
||
status = charon->connections->delete_connection(charon->connections,
|
||
msg->del_conn.name);
|
||
charon->policies->delete_policy(charon->policies, msg->del_conn.name);
|
||
if (status == SUCCESS)
|
||
{
|
||
this->stroke_logger->log(this->stroke_logger, CONTROL,
|
||
"Deleted connection '%s'", msg->del_conn.name);
|
||
}
|
||
else
|
||
{
|
||
this->stroke_logger->log(this->stroke_logger, ERROR,
|
||
"No connection named '%s'", msg->del_conn.name);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* initiate a connection by name
|
||
*/
|
||
static void stroke_initiate(private_stroke_t *this, stroke_msg_t *msg)
|
||
{
|
||
initiate_ike_sa_job_t *job;
|
||
connection_t *connection;
|
||
linked_list_t *ike_sas;
|
||
ike_sa_id_t *ike_sa_id;
|
||
|
||
pop_string(msg, &(msg->initiate.name));
|
||
this->logger->log(this->logger, CONTROL, "received stroke: initiate \"%s\"", msg->initiate.name);
|
||
connection = charon->connections->get_connection_by_name(charon->connections, msg->initiate.name);
|
||
if (connection == NULL)
|
||
{
|
||
this->stroke_logger->log(this->stroke_logger, ERROR, "no connection named \"%s\"", msg->initiate.name);
|
||
}
|
||
/* only initiate if it is an IKEv2 connection, ignore IKEv1 */
|
||
else if (connection->is_ikev2(connection))
|
||
{
|
||
/* check for already set up IKE_SAs befor initiating */
|
||
ike_sas = charon->ike_sa_manager->get_ike_sa_list_by_name(charon->ike_sa_manager, msg->initiate.name);
|
||
if (ike_sas->get_count(ike_sas) == 0)
|
||
{
|
||
this->stroke_logger->log(this->stroke_logger, CONTROL,
|
||
"initiating connection \"%s\" (see log)...", msg->initiate.name);
|
||
job = initiate_ike_sa_job_create(connection);
|
||
charon->job_queue->add(charon->job_queue, (job_t*)job);
|
||
}
|
||
else
|
||
{
|
||
this->stroke_logger->log(this->stroke_logger, CONTROL,
|
||
"connection \"%s\" already up", msg->initiate.name);
|
||
connection->destroy(connection);
|
||
}
|
||
while (ike_sas->remove_last(ike_sas, (void**)&ike_sa_id) == SUCCESS)
|
||
{
|
||
ike_sa_id->destroy(ike_sa_id);
|
||
}
|
||
ike_sas->destroy(ike_sas);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* terminate a connection by name
|
||
*/
|
||
static void stroke_terminate(private_stroke_t *this, stroke_msg_t *msg)
|
||
{
|
||
linked_list_t *ike_sas;
|
||
iterator_t *iterator;
|
||
int instances = 0;
|
||
connection_t *conn;
|
||
|
||
pop_string(msg, &(msg->terminate.name));
|
||
this->logger->log(this->logger, CONTROL, "received stroke: terminate \"%s\"", msg->terminate.name);
|
||
|
||
/* we have to do tricky tricks to give the most comprehensive output to the user.
|
||
* There are different cases:
|
||
* 1. Connection is available, but IKEv1:
|
||
* => just ignore it, let pluto print it
|
||
* 2. Connection is not available, but instances of a deleted connection template:
|
||
* => terminate them, and print their termination
|
||
* 3. Connection is not available, and and no instances are there:
|
||
* => show error about bad connection name
|
||
* 4. An IKEv2 connection is available, and may contain instances:
|
||
* => terminate and print, simple
|
||
*/
|
||
conn = charon->connections->get_connection_by_name(charon->connections, msg->terminate.name);
|
||
if (conn == NULL || conn->is_ikev2(conn))
|
||
{
|
||
ike_sas = charon->ike_sa_manager->get_ike_sa_list_by_name(charon->ike_sa_manager, msg->terminate.name);
|
||
|
||
iterator = ike_sas->create_iterator(ike_sas, TRUE);
|
||
while (iterator->has_next(iterator))
|
||
{
|
||
ike_sa_id_t *ike_sa_id;
|
||
iterator->current(iterator, (void**)&ike_sa_id);
|
||
charon->ike_sa_manager->delete(charon->ike_sa_manager, ike_sa_id);
|
||
ike_sa_id->destroy(ike_sa_id);
|
||
instances++;
|
||
}
|
||
iterator->destroy(iterator);
|
||
ike_sas->destroy(ike_sas);
|
||
if (conn == NULL && instances == 0)
|
||
{
|
||
this->stroke_logger->log(this->stroke_logger, CONTROL,
|
||
"no connection named \"%s\"",
|
||
msg->terminate.name);
|
||
}
|
||
else
|
||
{
|
||
this->stroke_logger->log(this->stroke_logger, CONTROL,
|
||
"terminated %d instances of \"%s\"",
|
||
instances, msg->terminate.name);
|
||
}
|
||
}
|
||
if (conn)
|
||
{
|
||
conn->destroy(conn);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* show status of (established) connections
|
||
*/
|
||
static void stroke_status(private_stroke_t *this, stroke_msg_t *msg)
|
||
{
|
||
if (msg->status.name)
|
||
{
|
||
pop_string(msg, &(msg->status.name));
|
||
}
|
||
charon->connections->log_connections(charon->connections, this->stroke_logger, msg->status.name);
|
||
charon->ike_sa_manager->log_status(charon->ike_sa_manager, this->stroke_logger, msg->status.name);
|
||
}
|
||
|
||
/**
|
||
* list various information
|
||
*/
|
||
static void stroke_list(private_stroke_t *this, stroke_msg_t *msg)
|
||
{
|
||
if (msg->list.flags & LIST_CERTS)
|
||
{
|
||
charon->credentials->log_certificates(charon->credentials, this->stroke_logger, msg->list.utc);
|
||
}
|
||
if (msg->list.flags & LIST_CACERTS)
|
||
{
|
||
charon->credentials->log_ca_certificates(charon->credentials, this->stroke_logger, msg->list.utc);
|
||
}
|
||
if (msg->list.flags & LIST_CRLS)
|
||
{
|
||
charon->credentials->log_crls(charon->credentials, this->stroke_logger, msg->list.utc);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* reread various information
|
||
*/
|
||
static void stroke_reread(private_stroke_t *this, stroke_msg_t *msg)
|
||
{
|
||
if (msg->reread.flags & REREAD_CACERTS)
|
||
{
|
||
charon->credentials->load_ca_certificates(charon->credentials);
|
||
}
|
||
if (msg->reread.flags & REREAD_CRLS)
|
||
{
|
||
charon->credentials->load_crls(charon->credentials);
|
||
}
|
||
}
|
||
|
||
logger_context_t get_context(char *context)
|
||
{
|
||
if (strcasecmp(context, "ALL") == 0) return ALL_LOGGERS;
|
||
else if (strcasecmp(context, "PARSR") == 0) return PARSER;
|
||
else if (strcasecmp(context, "GNRAT") == 0) return GENERATOR;
|
||
else if (strcasecmp(context, "IKESA") == 0) return IKE_SA;
|
||
else if (strcasecmp(context, "SAMGR") == 0) return IKE_SA_MANAGER;
|
||
else if (strcasecmp(context, "CHDSA") == 0) return CHILD_SA;
|
||
else if (strcasecmp(context, "MESSG") == 0) return MESSAGE;
|
||
else if (strcasecmp(context, "TPOOL") == 0) return THREAD_POOL;
|
||
else if (strcasecmp(context, "WORKR") == 0) return WORKER;
|
||
else if (strcasecmp(context, "SCHED") == 0) return SCHEDULER;
|
||
else if (strcasecmp(context, "SENDR") == 0) return SENDER;
|
||
else if (strcasecmp(context, "RECVR") == 0) return RECEIVER;
|
||
else if (strcasecmp(context, "SOCKT") == 0) return SOCKET;
|
||
else if (strcasecmp(context, "TESTR") == 0) return TESTER;
|
||
else if (strcasecmp(context, "DAEMN") == 0) return DAEMON;
|
||
else if (strcasecmp(context, "CONFG") == 0) return CONFIG;
|
||
else if (strcasecmp(context, "ENCPL") == 0) return ENCRYPTION_PAYLOAD;
|
||
else if (strcasecmp(context, "PAYLD") == 0) return PAYLOAD;
|
||
else if (strcasecmp(context, "XFRM") == 0) return XFRM;
|
||
else return -2;
|
||
}
|
||
|
||
/**
|
||
* set the type of logged messages in a context
|
||
*/
|
||
static void stroke_logtype(private_stroke_t *this, stroke_msg_t *msg)
|
||
{
|
||
pop_string(msg, &(msg->logtype.context));
|
||
pop_string(msg, &(msg->logtype.type));
|
||
|
||
this->logger->log(this->logger, CONTROL, "received stroke: logtype for %s", msg->logtype.context);
|
||
|
||
log_level_t level;
|
||
logger_context_t context = get_context(msg->logtype.context);
|
||
if (context == -2)
|
||
{
|
||
this->stroke_logger->log(this->stroke_logger, ERROR, "invalid context (%s)!", msg->logtype.context);
|
||
return;
|
||
}
|
||
|
||
if (strcasecmp(msg->logtype.type, "CONTROL") == 0)
|
||
level = CONTROL;
|
||
else if (strcasecmp(msg->logtype.type, "ERROR") == 0)
|
||
level = ERROR;
|
||
else if (strcasecmp(msg->logtype.type, "AUDIT") == 0)
|
||
level = AUDIT;
|
||
else if (strcasecmp(msg->logtype.type, "RAW") == 0)
|
||
level = RAW;
|
||
else if (strcasecmp(msg->logtype.type, "PRIVATE") == 0)
|
||
level = PRIVATE;
|
||
else
|
||
{
|
||
this->stroke_logger->log(this->stroke_logger, ERROR, "invalid type (%s)!", msg->logtype.type);
|
||
return;
|
||
}
|
||
|
||
if (msg->logtype.enable)
|
||
{
|
||
logger_manager->enable_log_level(logger_manager, context, level);
|
||
}
|
||
else
|
||
{
|
||
logger_manager->disable_log_level(logger_manager, context, level);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* set the verbosity of a logger
|
||
*/
|
||
static void stroke_loglevel(private_stroke_t *this, stroke_msg_t *msg)
|
||
{
|
||
log_level_t level;
|
||
logger_context_t context;
|
||
|
||
pop_string(msg, &(msg->loglevel.context));
|
||
this->logger->log(this->logger, CONTROL, "received stroke: loglevel for %s", msg->loglevel.context);
|
||
|
||
context = get_context(msg->loglevel.context);
|
||
if (context == -2)
|
||
{
|
||
this->stroke_logger->log(this->stroke_logger, ERROR, "invalid context (%s)!", msg->loglevel.context);
|
||
return;
|
||
}
|
||
|
||
if (msg->loglevel.level == 0)
|
||
level = LEVEL0;
|
||
else if (msg->loglevel.level == 1)
|
||
level = LEVEL1;
|
||
else if (msg->loglevel.level == 2)
|
||
level = LEVEL2;
|
||
else if (msg->loglevel.level == 3)
|
||
level = LEVEL3;
|
||
else
|
||
{
|
||
this->stroke_logger->log(this->stroke_logger, ERROR, "invalid level (%d)!", msg->loglevel.level);
|
||
return;
|
||
}
|
||
|
||
logger_manager->enable_log_level(logger_manager, context, level);
|
||
}
|
||
|
||
/**
|
||
* Implementation of private_stroke_t.stroke_receive.
|
||
*/
|
||
static void stroke_receive(private_stroke_t *this)
|
||
{
|
||
stroke_msg_t *msg;
|
||
u_int16_t msg_length;
|
||
struct sockaddr_un strokeaddr;
|
||
int strokeaddrlen = sizeof(strokeaddr);
|
||
ssize_t bytes_read;
|
||
int strokefd;
|
||
FILE *strokefile;
|
||
int oldstate;
|
||
|
||
/* disable cancellation by default */
|
||
pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
|
||
|
||
while (1)
|
||
{
|
||
/* wait for connections, but allow thread to terminate */
|
||
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &oldstate);
|
||
strokefd = accept(this->socket, (struct sockaddr *)&strokeaddr, &strokeaddrlen);
|
||
pthread_setcancelstate(oldstate, NULL);
|
||
|
||
if (strokefd < 0)
|
||
{
|
||
this->logger->log(this->logger, ERROR, "accepting stroke connection failed: %s", strerror(errno));
|
||
continue;
|
||
}
|
||
|
||
/* peek the length */
|
||
bytes_read = recv(strokefd, &msg_length, sizeof(msg_length), MSG_PEEK);
|
||
if (bytes_read != sizeof(msg_length))
|
||
{
|
||
this->logger->log(this->logger, ERROR, "reading lenght of stroke message failed");
|
||
close(strokefd);
|
||
continue;
|
||
}
|
||
|
||
/* read message */
|
||
msg = malloc(msg_length);
|
||
bytes_read = recv(strokefd, msg, msg_length, 0);
|
||
if (bytes_read != msg_length)
|
||
{
|
||
this->logger->log(this->logger, ERROR, "reading stroke message failed: %s");
|
||
close(strokefd);
|
||
continue;
|
||
}
|
||
|
||
strokefile = fdopen(dup(strokefd), "w");
|
||
if (strokefile == NULL)
|
||
{
|
||
this->logger->log(this->logger, ERROR, "opening stroke output channel failed:", strerror(errno));
|
||
close(strokefd);
|
||
free(msg);
|
||
continue;
|
||
}
|
||
|
||
/* setup a logger which writes status to the unix socket */
|
||
this->stroke_logger = logger_create("", CONTROL|ERROR, FALSE, strokefile);
|
||
|
||
this->logger->log_bytes(this->logger, RAW, "stroke message", (void*)msg, msg_length);
|
||
|
||
switch (msg->type)
|
||
{
|
||
case STR_INITIATE:
|
||
stroke_initiate(this, msg);
|
||
break;
|
||
case STR_TERMINATE:
|
||
stroke_terminate(this, msg);
|
||
break;
|
||
case STR_STATUS:
|
||
stroke_status(this, msg);
|
||
break;
|
||
case STR_STATUS_ALL:
|
||
this->stroke_logger->enable_level(this->stroke_logger, LEVEL1);
|
||
stroke_status(this, msg);
|
||
break;
|
||
case STR_ADD_CONN:
|
||
stroke_add_conn(this, msg);
|
||
break;
|
||
case STR_DEL_CONN:
|
||
stroke_del_conn(this, msg);
|
||
break;
|
||
case STR_LOGTYPE:
|
||
stroke_logtype(this, msg);
|
||
break;
|
||
case STR_LOGLEVEL:
|
||
stroke_loglevel(this, msg);
|
||
break;
|
||
case STR_LIST:
|
||
stroke_list(this, msg);
|
||
break;
|
||
case STR_REREAD:
|
||
stroke_reread(this, msg);
|
||
break;
|
||
default:
|
||
this->logger->log(this->logger, ERROR, "received invalid stroke");
|
||
}
|
||
this->stroke_logger->destroy(this->stroke_logger);
|
||
fclose(strokefile);
|
||
close(strokefd);
|
||
free(msg);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Implementation of stroke_t.destroy.
|
||
*/
|
||
static void destroy(private_stroke_t *this)
|
||
{
|
||
|
||
pthread_cancel(this->assigned_thread);
|
||
pthread_join(this->assigned_thread, NULL);
|
||
|
||
close(this->socket);
|
||
unlink(socket_addr.sun_path);
|
||
free(this);
|
||
}
|
||
|
||
|
||
/*
|
||
* Described in header-file
|
||
*/
|
||
stroke_t *stroke_create()
|
||
{
|
||
private_stroke_t *this = malloc_thing(private_stroke_t);
|
||
mode_t old;
|
||
|
||
/* public functions */
|
||
this->public.destroy = (void (*)(stroke_t*))destroy;
|
||
|
||
/* private functions */
|
||
this->stroke_receive = stroke_receive;
|
||
|
||
this->logger = logger_manager->get_logger(logger_manager, CONFIG);
|
||
|
||
/* set up unix socket */
|
||
this->socket = socket(AF_UNIX, SOCK_STREAM, 0);
|
||
if (this->socket == -1)
|
||
{
|
||
this->logger->log(this->logger, ERROR, "could not create whack socket");
|
||
free(this);
|
||
return NULL;
|
||
}
|
||
|
||
old = umask(~S_IRWXU);
|
||
if (bind(this->socket, (struct sockaddr *)&socket_addr, sizeof(socket_addr)) < 0)
|
||
{
|
||
this->logger->log(this->logger, ERROR, "could not bind stroke socket: %s", strerror(errno));
|
||
close(this->socket);
|
||
free(this);
|
||
return NULL;
|
||
}
|
||
umask(old);
|
||
|
||
if (listen(this->socket, 0) < 0)
|
||
{
|
||
this->logger->log(this->logger, ERROR, "could not listen on stroke socket: %s", strerror(errno));
|
||
close(this->socket);
|
||
unlink(socket_addr.sun_path);
|
||
free(this);
|
||
return NULL;
|
||
}
|
||
|
||
/* start a thread reading from the socket */
|
||
if (pthread_create(&(this->assigned_thread), NULL, (void*(*)(void*))this->stroke_receive, this) != 0)
|
||
{
|
||
this->logger->log(this->logger, ERROR, "Could not spawn stroke thread");
|
||
close(this->socket);
|
||
unlink(socket_addr.sun_path);
|
||
free(this);
|
||
return NULL;
|
||
}
|
||
|
||
return (&this->public);
|
||
}
|