#include <queues/jobs/delete_child_sa_job.h>

#include <queues/jobs/rekey_child_sa_job.h>

#define KERNEL_ESP 50

#define KERNEL_AH 51

#define SPD_PRIORITY 1024

#define BUFFER_SIZE 1024

#define XFRM_RTA(nlh, x) ((struct rtattr*)(NLMSG_DATA(nlh) + NLMSG_ALIGN(sizeof(x))))

#define XFRM_RTA_NEXT(rta) ((struct rtattr*)(((char*)(rta)) + RTA_ALIGN((rta)->rta_len)))

#define XFRM_PAYLOAD(nlh, x) NLMSG_PAYLOAD(nlh, sizeof(x))

typedef struct kernel_algorithm_t kernel_algorithm_t;

/**

* Look up a kernel algorithm name and its key size

*/

{

while (kernel_algo->ikev2_id != END_OF_LIST)

{

return NULL;

}

typedef struct private_kernel_interface_t private_kernel_interface_t;

*/

struct private_kernel_interface_t {

/**

kernel_interface_t public;

/**

* Netlink communication socket.

*/

int socket;

/**

* Mutex locks access to replies list.

*/

/**

* Condvar allows signaling of threads waiting for a reply.

* Logger for XFRM stuff

*/

logger_t *logger;

/**

* Implementation of kernel_interface_t.get_spi.

{

unsigned char request[BUFFER_SIZE];

struct nlmsghdr *response;

memset(&request, 0, sizeof(request));

status_t status = SUCCESS;

this->logger->log(this->logger, CONTROL|LEVEL2, "getting spi");

hdr->nlmsg_flags = NLM_F_REQUEST;

hdr->nlmsg_type = XFRM_MSG_ALLOCSPI;

hdr->nlmsg_len = NLMSG_LENGTH(sizeof(struct xfrm_userspi_info));

userspi->info.saddr = src->get_xfrm_addr(src);

userspi->info.id.daddr = dest->get_xfrm_addr(dest);

userspi->info.id.proto = (protocol == PROTO_ESP) ? KERNEL_ESP : KERNEL_AH;

userspi->min = 0xc0000000;

userspi->max = 0xcFFFFFFF;

{

this->logger->log(this->logger, ERROR, "netlink communication failed");

return FAILED;

struct nlmsghdr *response;

char *alg_name;

size_t key_size;

memset(&request, 0, sizeof(request));

status_t status = SUCCESS;

this->logger->log(this->logger, CONTROL|LEVEL2, "adding SA");

hdr->nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;

hdr->nlmsg_type = replace ? XFRM_MSG_UPDSA : XFRM_MSG_NEWSA;

hdr->nlmsg_len = NLMSG_LENGTH(sizeof(struct xfrm_usersa_info));

sa->saddr = me->get_xfrm_addr(me);

sa->id.daddr = other->get_xfrm_addr(other);

rthdr = XFRM_RTA_NEXT(rthdr);

}

{

this->logger->log(this->logger, ERROR, "netlink communication failed");

return FAILED;

return status;

}

static status_t update_sa_hosts(

private_kernel_interface_t *this,

host_t *src, host_t *dst,

{

unsigned char request[BUFFER_SIZE];

struct nlmsghdr *update, *response;

memset(&request, 0, sizeof(request));

status_t status = SUCCESS;

this->logger->log(this->logger, CONTROL|LEVEL2, "getting SA");

hdr->nlmsg_flags = NLM_F_REQUEST;

hdr->nlmsg_type = XFRM_MSG_GETSA;

hdr->nlmsg_len = NLMSG_LENGTH(sizeof(struct xfrm_usersa_id));

sa_id->daddr = dst->get_xfrm_addr(dst);

sa_id->spi = spi;

sa_id->proto = (protocol == PROTO_ESP) ? KERNEL_ESP : KERNEL_AH;

sa_id->family = dst->get_family(dst);

{

this->logger->log(this->logger, ERROR, "netlink communication failed");

return FAILED;

}

}

{

this->logger->log(this->logger, ERROR, "netlink communication failed");

free(update);

free(response);

return status;

}

{

unsigned char request[BUFFER_SIZE];

struct nlmsghdr *response;

memset(&request, 0, sizeof(request));

status_t status = SUCCESS;

this->logger->log(this->logger, CONTROL|LEVEL2, "deleting SA");

hdr->nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;

hdr->nlmsg_type = XFRM_MSG_DELSA;

hdr->nlmsg_len = NLMSG_LENGTH(sizeof(struct xfrm_usersa_id));

sa_id->daddr = dst->get_xfrm_addr(dst);

sa_id->spi = spi;

sa_id->proto = (protocol == PROTO_ESP) ? KERNEL_ESP : KERNEL_AH;

sa_id->family = dst->get_family(dst);

{

this->logger->log(this->logger, ERROR, "netlink communication failed");

return FAILED;

host_t *me, host_t *other,

host_t *src, host_t *dst,

u_int8_t src_hostbits, u_int8_t dst_hostbits,

protocol_id_t protocol,

{

unsigned char request[BUFFER_SIZE];

struct nlmsghdr *response;

status_t status = SUCCESS;

policy->sel.saddr = src->get_xfrm_addr(src);

policy->sel.prefixlen_s = src_hostbits;

policy->sel.daddr = dst->get_xfrm_addr(dst);

policy->sel.prefixlen_d = dst_hostbits;

policy->sel.proto = upper_proto;

policy->sel.family = src->get_family(src);

struct rtattr *rthdr = XFRM_RTA(hdr, struct xfrm_userpolicy_info);

rthdr->rta_type = XFRMA_TMPL;

tmpl->saddr = me->get_xfrm_addr(me);

tmpl->id.daddr = other->get_xfrm_addr(other);

{

this->logger->log(this->logger, ERROR, "netlink communication failed");

return FAILED;

}

else if (response->nlmsg_type != NLMSG_ERROR)

{

status = FAILED;

}

else if (((struct nlmsgerr*)NLMSG_DATA(response))->error)

{

strerror(-((struct nlmsgerr*)NLMSG_DATA(response))->error));

status = FAILED;

}

return status;

}

{

unsigned char request[BUFFER_SIZE];

struct nlmsghdr *response;

status_t status = SUCCESS;

{

}

{

}

memset(&request, 0, sizeof(request));

hdr->nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;

hdr->nlmsg_type = XFRM_MSG_DELPOLICY;

hdr->nlmsg_len = NLMSG_LENGTH(sizeof(struct xfrm_userpolicy_id));

{

this->logger->log(this->logger, ERROR, "netlink communication failed");

return FAILED;

}

/**

* Implementation of kernel_interface_t.destroy.

*/

static void destroy(private_kernel_interface_t *this)

pthread_join(this->thread, NULL);

close(this->socket);

this->responses->destroy(this->responses);

free(this);

}

this->public.get_spi = (status_t(*)(kernel_interface_t*,host_t*,host_t*,protocol_id_t,u_int32_t,u_int32_t*))get_spi;

this->public.add_sa = (status_t(*)(kernel_interface_t *,host_t*,host_t*,u_int32_t,protocol_id_t,u_int32_t,u_int64_t,u_int64_t,algorithm_t*,algorithm_t*,prf_plus_t*,natt_conf_t*,bool))add_sa;

this->public.update_sa_hosts = (status_t(*)(kernel_interface_t*,host_t*,host_t*,host_t*,host_t*,int,int,u_int32_t,protocol_id_t))update_sa_hosts;

this->public.del_sa = (status_t(*)(kernel_interface_t*,host_t*,u_int32_t,protocol_id_t))del_sa;

this->public.destroy = (void(*)(kernel_interface_t*)) destroy;

/* private members */

this->pid = getpid();

this->responses = linked_list_create();

this->logger = logger_manager->get_logger(logger_manager, XFRM);

pthread_cond_init(&(this->condvar),NULL);

this->seq = 0;

charon->kill(charon, "Unable to bind netlink socket");

}

{

this->responses->destroy(this->responses);

close(this->socket);

charon->kill(charon, "Unable to create netlink thread");

}

}