This moves hydra->kernel_interface to charon->kernel.
* for more details.
*/
-#include <hydra.h>
+#include <daemon.h>
#include <utils/debug.h>
#include <tkm/constants.h>
#include <tkm/types.h>
void charon_esa_acquire(result_type *res, const sp_id_type sp_id)
{
DBG1(DBG_KNL, "ees: acquire received for reqid %u", sp_id);
- hydra->kernel_interface->acquire(hydra->kernel_interface, sp_id, NULL,
- NULL);
+ charon->kernel->acquire(charon->kernel, sp_id, NULL, NULL);
*res = TKM_OK;
}
DBG1(DBG_KNL, "ees: expire received for reqid %u, spi %x, dst %H", sp_id,
ntohl(spi_rem), dst);
- hydra->kernel_interface->expire(hydra->kernel_interface, protocol,
- spi_rem, dst, hard != 0);
+ charon->kernel->expire(charon->kernel, protocol, spi_rem, dst, hard != 0);
}
#include <tests/test_suite.h>
#include <daemon.h>
-#include <hydra.h>
#include <config/proposal.h>
#include <encoding/payloads/ike_header.h>
#include <tkm/client.h>
#define CONFTEST_H_
#include <library.h>
-#include <hydra.h>
#include <daemon.h>
#include <credentials/sets/mem_cred.h>
#include "android_attr.h"
#include "../charonservice.h"
-#include <hydra.h>
#include <utils/debug.h>
#include <library.h>
#include "android_dns_proxy.h"
-#include <hydra.h>
+#include <daemon.h>
#include <threading/rwlock.h>
#include <collections/hashtable.h>
#include <processing/jobs/callback_job.h>
DBG1(DBG_NET, "could not open proxy socket: %s", strerror(errno));
return -1;
}
- if (!hydra->kernel_interface->bypass_socket(hydra->kernel_interface,
- skt, family))
+ if (!charon->kernel->bypass_socket(charon->kernel, skt, family))
{
DBG1(DBG_NET, "installing bypass policy for proxy socket failed");
close(skt);
#include <utils/debug.h>
#include <library.h>
-#include <hydra.h>
+#include <daemon.h>
#include <ipsec.h>
typedef struct private_kernel_android_ipsec_t private_kernel_android_ipsec_t;
*/
static void expire(u_int8_t protocol, u_int32_t spi, host_t *dst, bool hard)
{
- hydra->kernel_interface->expire(hydra->kernel_interface, protocol,
- spi, dst, hard);
+ charon->kernel->expire(charon->kernel, protocol, spi, dst, hard);
}
METHOD(kernel_ipsec_t, get_spi, status_t,
#include "../android_jni.h"
#include "../charonservice.h"
-#include <hydra.h>
+#include <daemon.h>
#include <processing/jobs/callback_job.h>
#include <threading/mutex.h>
{
/* this will fail if no connection is up */
charonservice->bypass_socket(charonservice, -1, 0);
- hydra->kernel_interface->roam(hydra->kernel_interface, TRUE);
+ charon->kernel->roam(charon->kernel, TRUE);
return JOB_REQUEUE_NONE;
}
encoding/payloads/vendor_id_payload.c encoding/payloads/vendor_id_payload.h \
encoding/payloads/hash_payload.c encoding/payloads/hash_payload.h \
encoding/payloads/fragment_payload.c encoding/payloads/fragment_payload.h \
-kernel/kernel_handler.c kernel/kernel_handler.h \
+kernel/kernel_interface.c kernel/kernel_interface.h \
+kernel/kernel_ipsec.c kernel/kernel_ipsec.h \
+kernel/kernel_net.c kernel/kernel_net.h \
+kernel/kernel_listener.h kernel/kernel_handler.c kernel/kernel_handler.h \
network/receiver.c network/receiver.h network/sender.c network/sender.h \
network/socket.c network/socket.h \
network/socket_manager.c network/socket_manager.h \
encoding/payloads/vendor_id_payload.c encoding/payloads/vendor_id_payload.h \
encoding/payloads/hash_payload.c encoding/payloads/hash_payload.h \
encoding/payloads/fragment_payload.c encoding/payloads/fragment_payload.h \
-kernel/kernel_handler.c kernel/kernel_handler.h \
+kernel/kernel_interface.c kernel/kernel_interface.h \
+kernel/kernel_ipsec.c kernel/kernel_ipsec.h \
+kernel/kernel_net.c kernel/kernel_net.h \
+kernel/kernel_listener.h kernel/kernel_handler.c kernel/kernel_handler.h \
network/receiver.c network/receiver.h network/sender.c network/sender.h \
network/socket.c network/socket.h \
network/socket_manager.c network/socket_manager.h \
#include "mem_pool.h"
#include <library.h>
-#include <hydra.h>
#include <utils/debug.h>
#include <collections/hashtable.h>
#include <collections/array.h>
DESTROY_IF(this->public.xauth);
DESTROY_IF(this->public.backends);
DESTROY_IF(this->public.socket);
+ DESTROY_IF(this->public.kernel);
/* rehook library logging, shutdown logging */
dbg = dbg_old;
.ref = 1,
);
charon = &this->public;
+ this->public.kernel = kernel_interface_create();
this->public.attributes = attribute_manager_create();
this->public.controller = controller_create();
this->public.eap = eap_manager_create();
* @defgroup payloads payloads
* @ingroup encoding
*
- * @defgroup ckernel kernel
+ * @defgroup kernel kernel
* @ingroup libcharon
*
* @defgroup network network
typedef struct daemon_t daemon_t;
#include <attributes/attribute_manager.h>
+#include <kernel/kernel_interface.h>
#include <network/sender.h>
#include <network/receiver.h>
#include <network/socket_manager.h>
*/
socket_manager_t *socket;
+ /**
+ * Kernel interface to communicate with kernel
+ */
+ kernel_interface_t *kernel;
+
/**
* A ike_sa_manager_t instance.
*/
#include "kernel_handler.h"
-#include <hydra.h>
#include <daemon.h>
#include <processing/jobs/acquire_job.h>
#include <processing/jobs/delete_child_sa_job.h>
METHOD(kernel_handler_t, destroy, void,
private_kernel_handler_t *this)
{
- hydra->kernel_interface->remove_listener(hydra->kernel_interface,
- &this->public.listener);
+ charon->kernel->remove_listener(charon->kernel, &this->public.listener);
free(this);
}
},
);
- hydra->kernel_interface->add_listener(hydra->kernel_interface,
- &this->public.listener);
+ charon->kernel->add_listener(charon->kernel, &this->public.listener);
return &this->public;
}
/**
* @defgroup kernel_handler kernel_handler
- * @{ @ingroup ckernel
+ * @{ @ingroup kernel
*/
#ifndef KERNEL_HANDLER_H_
#include "kernel_interface.h"
-#include <hydra.h>
#include <utils/debug.h>
#include <threading/mutex.h>
#include <collections/linked_list.h>
/**
* @defgroup kernel_interface kernel_interface
- * @{ @ingroup hkernel
+ * @{ @ingroup kernel
*/
#ifndef KERNEL_INTERFACE_H_
#include "kernel_ipsec.h"
-#include <hydra.h>
+#include <daemon.h>
/**
* See header
{
if (reg)
{
- return hydra->kernel_interface->add_ipsec_interface(
- hydra->kernel_interface,
+ return charon->kernel->add_ipsec_interface(charon->kernel,
(kernel_ipsec_constructor_t)data);
}
else
{
- return hydra->kernel_interface->remove_ipsec_interface(
- hydra->kernel_interface,
+ return charon->kernel->remove_ipsec_interface(charon->kernel,
(kernel_ipsec_constructor_t)data);
}
}
/**
* @defgroup kernel_ipsec kernel_ipsec
- * @{ @ingroup hkernel
+ * @{ @ingroup kernel
*/
#ifndef KERNEL_IPSEC_H_
/**
* @defgroup kernel_listener kernel_listener
- * @{ @ingroup hkernel
+ * @{ @ingroup kernel
*/
#ifndef KERNEL_LISTENER_H_
#include "kernel_net.h"
-#include <hydra.h>
+#include <daemon.h>
/**
* See header
{
if (reg)
{
- return hydra->kernel_interface->add_net_interface(
- hydra->kernel_interface,
+ return charon->kernel->add_net_interface(charon->kernel,
(kernel_net_constructor_t)data);
}
else
{
- return hydra->kernel_interface->remove_net_interface(
- hydra->kernel_interface,
+ return charon->kernel->remove_net_interface(charon->kernel,
(kernel_net_constructor_t)data);
}
}
/**
* @defgroup kernel_net kernel_net
- * @{ @ingroup hkernel
+ * @{ @ingroup kernel
*/
#ifndef KERNEL_NET_H_
#include "receiver.h"
-#include <hydra.h>
#include <daemon.h>
#include <network/socket.h>
#include <processing/jobs/job.h>
dst = packet->get_destination(packet);
src = packet->get_source(packet);
- if (!hydra->kernel_interface->all_interfaces_usable(hydra->kernel_interface)
- && !hydra->kernel_interface->get_interface(hydra->kernel_interface,
- dst, NULL))
+ if (!charon->kernel->all_interfaces_usable(charon->kernel)
+ && !charon->kernel->get_interface(charon->kernel, dst, NULL))
{
DBG3(DBG_NET, "received packet from %#H to %#H on ignored interface",
src, dst);
#include <threading/condvar.h>
#include <threading/thread.h>
-#include <hydra.h>
#include <daemon.h>
#include <processing/jobs/callback_job.h>
else
{
/* act as relay agent */
- src = hydra->kernel_interface->get_source_addr(hydra->kernel_interface,
- this->dst, NULL);
+ src = charon->kernel->get_source_addr(charon->kernel, this->dst, NULL);
if (src)
{
memcpy(&dhcp->gateway_address, src->get_address(src).ptr,
#include <ifaddrs.h>
#include <net/if.h>
-#include <hydra.h>
#include <daemon.h>
#include <threading/thread.h>
#include <processing/jobs/callback_job.h>
lib->watcher->remove(lib->watcher, this->kernel.pkt);
close(this->kernel.pkt);
}
- hydra->kernel_interface->remove_listener(hydra->kernel_interface,
- &this->kernel.listener);
+ charon->kernel->remove_listener(charon->kernel, &this->kernel.listener);
free(this);
}
setup_interface(&this->kernel);
- hydra->kernel_interface->add_listener(hydra->kernel_interface,
- &this->kernel.listener);
+ charon->kernel->add_listener(charon->kernel,
+ &this->kernel.listener);
lib->watcher->add(lib->watcher, this->kernel.pkt, WATCHER_READ,
(watcher_cb_t)receive_casts, this);
#include "kernel_iph_net.h"
-#include <hydra.h>
+#include <daemon.h>
#include <threading/mutex.h>
#include <collections/linked_list.h>
#include <processing/jobs/callback_job.h>
this->roam_address = FALSE;
this->mutex->unlock(this->mutex);
- hydra->kernel_interface->roam(hydra->kernel_interface, address);
+ charon->kernel->roam(charon->kernel, address);
return JOB_REQUEUE_NONE;
}
#include "kernel_iph_plugin.h"
#include "kernel_iph_net.h"
-#include <hydra.h>
-
typedef struct private_kernel_iph_plugin_t private_kernel_iph_plugin_t;
/**
#include <library.h>
#include <ipsec.h>
-#include <hydra.h>
+#include <daemon.h>
#include <networking/tun_device.h>
#include <threading/mutex.h>
#include <utils/debug.h>
*/
static void expire(u_int8_t protocol, u_int32_t spi, host_t *dst, bool hard)
{
- hydra->kernel_interface->expire(hydra->kernel_interface, protocol,
- spi, dst, hard);
+ charon->kernel->expire(charon->kernel, protocol, spi, dst, hard);
}
METHOD(kernel_ipsec_t, get_features, kernel_feature_t,
if (!route->exclude)
{
DBG2(DBG_KNL, "installing new exclude route for %H src %H", dst, src);
- gtw = hydra->kernel_interface->get_nexthop(hydra->kernel_interface,
- dst, -1, NULL);
+ gtw = charon->kernel->get_nexthop(charon->kernel, dst, -1, NULL);
if (gtw)
{
char *if_name = NULL;
- if (hydra->kernel_interface->get_interface(
- hydra->kernel_interface, src, &if_name) &&
- hydra->kernel_interface->add_route(hydra->kernel_interface,
- dst->get_address(dst),
+ if (charon->kernel->get_interface(charon->kernel, src, &if_name) &&
+ charon->kernel->add_route(charon->kernel, dst->get_address(dst),
dst->get_family(dst) == AF_INET ? 32 : 128,
gtw, src, if_name) == SUCCESS)
{
dst = route->exclude->dst;
DBG2(DBG_KNL, "uninstalling exclude route for %H src %H",
dst, route->exclude->src);
- if (hydra->kernel_interface->get_interface(
- hydra->kernel_interface,
- route->exclude->src, &if_name) &&
- hydra->kernel_interface->del_route(hydra->kernel_interface,
- dst->get_address(dst),
- dst->get_family(dst) == AF_INET ? 32 : 128,
- route->exclude->gtw, route->exclude->src,
- if_name) != SUCCESS)
+ if (charon->kernel->get_interface(charon->kernel, route->exclude->src,
+ &if_name) &&
+ charon->kernel->del_route(charon->kernel, dst->get_address(dst),
+ dst->get_family(dst) == AF_INET ? 32 : 128,
+ route->exclude->gtw, route->exclude->src,
+ if_name) != SUCCESS)
{
DBG1(DBG_KNL, "uninstalling exclude route for %H failed", dst);
}
return TRUE;
}
- if (hydra->kernel_interface->get_address_by_ts(hydra->kernel_interface,
- src_ts, &src_ip, &is_virtual) != SUCCESS)
+ if (charon->kernel->get_address_by_ts(charon->kernel, src_ts, &src_ip,
+ &is_virtual) != SUCCESS)
{
traffic_selector_t *multicast, *broadcast = NULL;
bool ignore = FALSE;
);
#ifndef __linux__
/* on Linux we cant't install a gateway */
- route->gateway = hydra->kernel_interface->get_nexthop(
- hydra->kernel_interface, dst, -1, src);
+ route->gateway = charon->kernel->get_nexthop(charon->kernel, dst, -1, src);
#endif
if (policy->route)
return TRUE;
}
/* uninstall previously installed route */
- if (hydra->kernel_interface->del_route(hydra->kernel_interface,
- old->dst_net, old->prefixlen, old->gateway,
- old->src_ip, old->if_name) != SUCCESS)
+ if (charon->kernel->del_route(charon->kernel, old->dst_net,
+ old->prefixlen, old->gateway,
+ old->src_ip, old->if_name) != SUCCESS)
{
DBG1(DBG_KNL, "error uninstalling route installed with policy "
"%R === %R %N", src_ts, dst_ts, policy_dir_names,
DBG2(DBG_KNL, "installing route: %R src %H dev %s",
dst_ts, route->src_ip, route->if_name);
- switch (hydra->kernel_interface->add_route(hydra->kernel_interface,
- route->dst_net, route->prefixlen, route->gateway,
- route->src_ip, route->if_name))
+ switch (charon->kernel->add_route(charon->kernel, route->dst_net,
+ route->prefixlen, route->gateway,
+ route->src_ip, route->if_name))
{
case ALREADY_DONE:
/* route exists, do not uninstall */
{
route_entry_t *route = policy->route;
- if (hydra->kernel_interface->del_route(hydra->kernel_interface,
- route->dst_net, route->prefixlen, route->gateway, route->src_ip,
- route->if_name) != SUCCESS)
+ if (charon->kernel->del_route(charon->kernel, route->dst_net,
+ route->prefixlen, route->gateway,
+ route->src_ip, route->if_name) != SUCCESS)
{
DBG1(DBG_KNL, "error uninstalling route installed with "
"policy %R === %R %N", src_ts, dst_ts,
{
route_entry_t *route = pol->route;
- hydra->kernel_interface->del_route(hydra->kernel_interface,
- route->dst_net, route->prefixlen, route->gateway,
- route->src_ip, route->if_name);
+ charon->kernel->del_route(charon->kernel, route->dst_net,
+ route->prefixlen, route->gateway,
+ route->src_ip, route->if_name);
remove_exclude_route(this, route);
}
policy_entry_destroy(pol);
#include "kernel_libipsec_router.h"
#include <daemon.h>
-#include <hydra.h>
#include <ipsec.h>
#include <collections/hashtable.h>
#include <networking/tun_device.h>
(ipsec_outbound_cb_t)send_esp);
ipsec->processor->unregister_inbound(ipsec->processor,
(ipsec_inbound_cb_t)deliver_plain);
- hydra->kernel_interface->remove_listener(hydra->kernel_interface,
- &this->public.listener);
+ charon->kernel->remove_listener(charon->kernel, &this->public.listener);
this->lock->destroy(this->lock);
this->tuns->destroy(this->tuns);
close(this->notify[0]);
(hashtable_equals_t)tun_entry_equals, 4);
this->lock = rwlock_create(RWLOCK_TYPE_DEFAULT);
- hydra->kernel_interface->add_listener(hydra->kernel_interface,
- &this->public.listener);
+ charon->kernel->add_listener(charon->kernel, &this->public.listener);
ipsec->processor->register_outbound(ipsec->processor, send_esp, NULL);
ipsec->processor->register_inbound(ipsec->processor,
(ipsec_inbound_cb_t)deliver_plain, this);
AM_CPPFLAGS = \
-I${linux_headers} \
-I$(top_srcdir)/src/libstrongswan \
- -I$(top_srcdir)/src/libhydra \
+ -I$(top_srcdir)/src/libcharon \
-DROUTING_TABLE=${routing_table} \
-DROUTING_TABLE_PRIO=${routing_table_prio}
#include "kernel_netlink_ipsec.h"
#include "kernel_netlink_shared.h"
-#include <hydra.h>
+#include <daemon.h>
#include <utils/debug.h>
#include <threading/mutex.h>
#include <collections/array.h>
return list[i].name;
}
}
- if (hydra->kernel_interface->lookup_algorithm(hydra->kernel_interface,
- ikev2, type, NULL, &name))
+ if (charon->kernel->lookup_algorithm(charon->kernel, ikev2, type, NULL,
+ &name))
{
return name;
}
src_ts = selector2ts(&acquire->sel, TRUE);
dst_ts = selector2ts(&acquire->sel, FALSE);
- hydra->kernel_interface->acquire(hydra->kernel_interface, reqid, src_ts,
- dst_ts);
+ charon->kernel->acquire(charon->kernel, reqid, src_ts, dst_ts);
}
/**
dst = xfrm2host(expire->state.family, &expire->state.id.daddr, 0);
if (dst)
{
- hydra->kernel_interface->expire(hydra->kernel_interface, protocol,
- spi, dst, expire->hard != 0);
+ charon->kernel->expire(charon->kernel, protocol, spi, dst,
+ expire->hard != 0);
dst->destroy(dst);
}
}
if (src_ts && dst_ts && local && remote)
{
- hydra->kernel_interface->migrate(hydra->kernel_interface, reqid,
- src_ts, dst_ts, dir, local, remote);
+ charon->kernel->migrate(charon->kernel, reqid, src_ts, dst_ts, dir,
+ local, remote);
}
else
{
mapping->new_sport);
if (new)
{
- hydra->kernel_interface->mapping(hydra->kernel_interface,
- IPPROTO_ESP, spi, dst, new);
+ charon->kernel->mapping(charon->kernel, IPPROTO_ESP, spi, dst,
+ new);
new->destroy(new);
}
dst->destroy(dst);
.prefixlen = policy->sel.prefixlen_s,
);
- if (hydra->kernel_interface->get_address_by_ts(hydra->kernel_interface,
- fwd->dst_ts, &route->src_ip, NULL) == SUCCESS)
+ if (charon->kernel->get_address_by_ts(charon->kernel, fwd->dst_ts,
+ &route->src_ip, NULL) == SUCCESS)
{
/* get the nexthop to src (src as we are in POLICY_FWD) */
if (!ipsec->src->is_anyaddr(ipsec->src))
{
- route->gateway = hydra->kernel_interface->get_nexthop(
- hydra->kernel_interface, ipsec->src,
- -1, ipsec->dst);
+ route->gateway = charon->kernel->get_nexthop(charon->kernel,
+ ipsec->src, -1, ipsec->dst);
}
else
{ /* for shunt policies */
iface = xfrm2host(policy->sel.family, &policy->sel.saddr, 0);
- route->gateway = hydra->kernel_interface->get_nexthop(
- hydra->kernel_interface, iface,
- policy->sel.prefixlen_s, route->src_ip);
+ route->gateway = charon->kernel->get_nexthop(charon->kernel,
+ iface, policy->sel.prefixlen_s,
+ route->src_ip);
iface->destroy(iface);
}
route->dst_net = chunk_alloc(policy->sel.family == AF_INET ? 4 : 16);
iface = route->src_ip;
}
/* install route via outgoing interface */
- if (!hydra->kernel_interface->get_interface(hydra->kernel_interface,
- iface, &route->if_name))
+ if (!charon->kernel->get_interface(charon->kernel, iface,
+ &route->if_name))
{
this->mutex->unlock(this->mutex);
route_entry_destroy(route);
return SUCCESS;
}
/* uninstall previously installed route */
- if (hydra->kernel_interface->del_route(hydra->kernel_interface,
- old->dst_net, old->prefixlen, old->gateway,
- old->src_ip, old->if_name) != SUCCESS)
+ if (charon->kernel->del_route(charon->kernel, old->dst_net,
+ old->prefixlen, old->gateway,
+ old->src_ip, old->if_name) != SUCCESS)
{
DBG1(DBG_KNL, "error uninstalling route installed with "
"policy %R === %R %N", fwd->src_ts,
DBG2(DBG_KNL, "installing route: %R via %H src %H dev %s",
fwd->src_ts, route->gateway, route->src_ip, route->if_name);
- switch (hydra->kernel_interface->add_route(
- hydra->kernel_interface, route->dst_net,
- route->prefixlen, route->gateway,
- route->src_ip, route->if_name))
+ switch (charon->kernel->add_route(charon->kernel, route->dst_net,
+ route->prefixlen, route->gateway,
+ route->src_ip, route->if_name))
{
default:
DBG1(DBG_KNL, "unable to install source route for %H",
if (current->route)
{
route_entry_t *route = current->route;
- if (hydra->kernel_interface->del_route(hydra->kernel_interface,
- route->dst_net, route->prefixlen, route->gateway,
- route->src_ip, route->if_name) != SUCCESS)
+ if (charon->kernel->del_route(charon->kernel, route->dst_net,
+ route->prefixlen, route->gateway,
+ route->src_ip, route->if_name) != SUCCESS)
{
DBG1(DBG_KNL, "error uninstalling route installed with "
"policy %R === %R %N", src_ts, dst_ts,
#include "kernel_netlink_net.h"
#include "kernel_netlink_shared.h"
-#include <hydra.h>
+#include <daemon.h>
#include <utils/debug.h>
#include <threading/mutex.h>
#include <threading/rwlock.h>
address = this->roam_address;
this->roam_address = FALSE;
this->roam_lock->unlock(this->roam_lock);
- hydra->kernel_interface->roam(hydra->kernel_interface, address);
+ charon->kernel->roam(charon->kernel, address);
return JOB_REQUEUE_NONE;
}
INIT(entry,
.ifindex = msg->ifi_index,
.addrs = linked_list_create(),
- .usable = hydra->kernel_interface->is_interface_usable(
- hydra->kernel_interface, name),
+ .usable = charon->kernel->is_interface_usable(
+ charon->kernel, name),
);
this->ifaces->insert_last(this->ifaces, entry);
}
#include "kernel_netlink_ipsec.h"
#include "kernel_netlink_net.h"
-#include <hydra.h>
-
typedef struct private_kernel_netlink_plugin_t private_kernel_netlink_plugin_t;
/**
#include <test_runner.h>
-#include <hydra.h>
-
/* declare test suite constructors */
#define TEST_SUITE(x) test_suite_t* x();
#include "tests.h"
AM_CPPFLAGS = \
-I${linux_headers} \
-I$(top_srcdir)/src/libstrongswan \
- -I$(top_srcdir)/src/libhydra
+ -I$(top_srcdir)/src/libcharon
AM_CFLAGS = \
$(PLUGIN_CFLAGS)
#include "kernel_pfkey_ipsec.h"
-#include <hydra.h>
+#include <daemon.h>
#include <utils/debug.h>
#include <networking/host.h>
#include <collections/linked_list.h>
}
list++;
}
- hydra->kernel_interface->lookup_algorithm(hydra->kernel_interface, ikev2,
- type, &alg, NULL);
+ charon->kernel->lookup_algorithm(charon->kernel, ikev2, type, &alg, NULL);
return alg;
}
src_ts = sadb_address2ts(response.src);
dst_ts = sadb_address2ts(response.dst);
- hydra->kernel_interface->acquire(hydra->kernel_interface, reqid, src_ts,
- dst_ts);
+ charon->kernel->acquire(charon->kernel, reqid, src_ts, dst_ts);
}
/**
dst = host_create_from_sockaddr((sockaddr_t*)(response.dst + 1));
if (dst)
{
- hydra->kernel_interface->expire(hydra->kernel_interface, protocol,
- spi, dst, hard);
+ charon->kernel->expire(charon->kernel, protocol, spi, dst, hard);
dst->destroy(dst);
}
}
if (src_ts && dst_ts && local && remote)
{
- hydra->kernel_interface->migrate(hydra->kernel_interface, reqid,
- src_ts, dst_ts, dir, local, remote);
+ charon->kernel->migrate(charon->kernel, reqid, src_ts, dst_ts, dir,
+ local, remote);
}
else
{
new = host_create_from_sockaddr(sa);
if (new)
{
- hydra->kernel_interface->mapping(hydra->kernel_interface,
- IPPROTO_ESP, spi, dst, new);
+ charon->kernel->mapping(charon->kernel, IPPROTO_ESP, spi, dst, new);
new->destroy(new);
}
dst->destroy(dst);
if (!route->exclude)
{
DBG2(DBG_KNL, "installing new exclude route for %H src %H", dst, src);
- gtw = hydra->kernel_interface->get_nexthop(hydra->kernel_interface,
- dst, -1, NULL);
+ gtw = charon->kernel->get_nexthop(charon->kernel, dst, -1, NULL);
if (gtw)
{
char *if_name = NULL;
- if (hydra->kernel_interface->get_interface(
- hydra->kernel_interface, src, &if_name) &&
- hydra->kernel_interface->add_route(hydra->kernel_interface,
+ if (charon->kernel->get_interface(charon->kernel, src, &if_name) &&
+ charon->kernel->add_route(charon->kernel,
dst->get_address(dst),
dst->get_family(dst) == AF_INET ? 32 : 128,
gtw, src, if_name) == SUCCESS)
dst = route->exclude->dst;
DBG2(DBG_KNL, "uninstalling exclude route for %H src %H",
dst, route->exclude->src);
- if (hydra->kernel_interface->get_interface(
- hydra->kernel_interface,
+ if (charon->kernel->get_interface(
+ charon->kernel,
route->exclude->src, &if_name) &&
- hydra->kernel_interface->del_route(hydra->kernel_interface,
+ charon->kernel->del_route(charon->kernel,
dst->get_address(dst),
dst->get_family(dst) == AF_INET ? 32 : 128,
route->exclude->gtw, route->exclude->src,
host_t *host, *src, *dst;
bool is_virtual;
- if (hydra->kernel_interface->get_address_by_ts(hydra->kernel_interface,
- in->dst_ts, &host, &is_virtual) != SUCCESS)
+ if (charon->kernel->get_address_by_ts(charon->kernel, in->dst_ts, &host,
+ &is_virtual) != SUCCESS)
{
return FALSE;
}
if (!dst->is_anyaddr(dst))
{
- route->gateway = hydra->kernel_interface->get_nexthop(
- hydra->kernel_interface, dst, -1, src);
+ route->gateway = charon->kernel->get_nexthop(charon->kernel, dst, -1,
+ src);
/* if the IP is virtual, we install the route over the interface it has
* been installed on. Otherwise we use the interface we use for IKE, as
}
else
{ /* for shunt policies */
- route->gateway = hydra->kernel_interface->get_nexthop(
- hydra->kernel_interface, policy->src.net,
- policy->src.mask, route->src_ip);
+ route->gateway = charon->kernel->get_nexthop(charon->kernel,
+ policy->src.net, policy->src.mask,
+ route->src_ip);
/* we don't have a source address, use the address we found */
src = route->src_ip;
}
/* get interface for route, using source address */
- if (!hydra->kernel_interface->get_interface(hydra->kernel_interface,
- src, &route->if_name))
+ if (!charon->kernel->get_interface(charon->kernel, src, &route->if_name))
{
route_entry_destroy(route);
return FALSE;
return TRUE;
}
/* uninstall previously installed route */
- if (hydra->kernel_interface->del_route(hydra->kernel_interface,
- old->dst_net, old->prefixlen, old->gateway,
- old->src_ip, old->if_name) != SUCCESS)
+ if (charon->kernel->del_route(charon->kernel, old->dst_net,
+ old->prefixlen, old->gateway,
+ old->src_ip, old->if_name) != SUCCESS)
{
DBG1(DBG_KNL, "error uninstalling route installed with policy "
"%R === %R %N", in->src_ts, in->dst_ts,
}
/* if remote traffic selector covers the IKE peer, add an exclude route */
- if (hydra->kernel_interface->get_features(
- hydra->kernel_interface) & KERNEL_REQUIRE_EXCLUDE_ROUTE)
+ if (charon->kernel->get_features(charon->kernel) & KERNEL_REQUIRE_EXCLUDE_ROUTE)
{
if (in->src_ts->is_host(in->src_ts, dst))
{
DBG2(DBG_KNL, "installing route: %R via %H src %H dev %s",
in->src_ts, route->gateway, route->src_ip, route->if_name);
- switch (hydra->kernel_interface->add_route(hydra->kernel_interface,
- route->dst_net, route->prefixlen, route->gateway,
- route->src_ip, route->if_name))
+ switch (charon->kernel->add_route(charon->kernel, route->dst_net,
+ route->prefixlen, route->gateway,
+ route->src_ip, route->if_name))
{
case ALREADY_DONE:
/* route exists, do not uninstall */
if (policy->route)
{
route_entry_t *route = policy->route;
- if (hydra->kernel_interface->del_route(hydra->kernel_interface,
- route->dst_net, route->prefixlen, route->gateway,
- route->src_ip, route->if_name) != SUCCESS)
+ if (charon->kernel->del_route(charon->kernel, route->dst_net,
+ route->prefixlen, route->gateway,
+ route->src_ip, route->if_name) != SUCCESS)
{
DBG1(DBG_KNL, "error uninstalling route installed with "
"policy %R === %R %N", src_ts, dst_ts,
#include "kernel_pfkey_ipsec.h"
-#include <hydra.h>
-
typedef struct private_kernel_pfkey_plugin_t private_kernel_pfkey_plugin_t;
/**
AM_CPPFLAGS = \
-I${linux_headers} \
-I$(top_srcdir)/src/libstrongswan \
- -I$(top_srcdir)/src/libhydra
+ -I$(top_srcdir)/src/libcharon
AM_CFLAGS = \
$(PLUGIN_CFLAGS)
#include "kernel_pfroute_net.h"
-#include <hydra.h>
+#include <daemon.h>
#include <utils/debug.h>
#include <networking/host.h>
#include <networking/tun_device.h>
address = this->roam_address;
this->roam_address = FALSE;
this->roam_lock->unlock(this->roam_lock);
- hydra->kernel_interface->roam(hydra->kernel_interface, address);
+ charon->kernel->roam(charon->kernel, address);
return JOB_REQUEUE_NONE;
}
if (if_indextoname(iface->ifindex, iface->ifname))
{
DBG1(DBG_KNL, "interface %s appeared", iface->ifname);
- iface->usable = hydra->kernel_interface->is_interface_usable(
- hydra->kernel_interface, iface->ifname);
+ iface->usable = charon->kernel->is_interface_usable(charon->kernel,
+ iface->ifname);
repopulate_iface(this, iface);
this->ifaces->insert_last(this->ifaces, iface);
if (iface->usable)
/* lets do this while holding the lock, thus preventing another thread
* from deleting the TUN device concurrently, hopefully listeners are quick
* and cause no deadlocks */
- hydra->kernel_interface->tun(hydra->kernel_interface, tun, TRUE);
+ charon->kernel->tun(charon->kernel, tun, TRUE);
this->lock->unlock(this->lock);
return SUCCESS;
if (addr && addr->ip_equals(addr, vip))
{
this->tuns->remove_at(this->tuns, enumerator);
- hydra->kernel_interface->tun(hydra->kernel_interface, tun,
- FALSE);
+ charon->kernel->tun(charon->kernel, tun, FALSE);
tun->destroy(tun);
found = TRUE;
break;
.ifindex = if_nametoindex(ifa->ifa_name),
.flags = ifa->ifa_flags,
.addrs = linked_list_create(),
- .usable = hydra->kernel_interface->is_interface_usable(
- hydra->kernel_interface, ifa->ifa_name),
+ .usable = charon->kernel->is_interface_usable(
+ charon->kernel, ifa->ifa_name),
);
memcpy(iface->ifname, ifa->ifa_name, IFNAMSIZ);
this->ifaces->insert_last(this->ifaces, iface);
#include "kernel_pfroute_net.h"
-#include <hydra.h>
-
typedef struct private_kernel_pfroute_plugin_t private_kernel_pfroute_plugin_t;
/**
#include "kernel_wfp_ipsec.h"
#include <daemon.h>
-#include <hydra.h>
#include <threading/mutex.h>
#include <collections/array.h>
#include <collections/hashtable.h>
{
if (--route->refs == 0)
{
- if (hydra->kernel_interface->get_interface(hydra->kernel_interface,
- src, &name))
+ if (charon->kernel->get_interface(charon->kernel, src, &name))
{
- res = hydra->kernel_interface->del_route(hydra->kernel_interface,
+ res = charon->kernel->del_route(charon->kernel,
dst->get_address(dst), mask, gtw, src, name) == SUCCESS;
free(name);
}
}
else
{
- if (hydra->kernel_interface->get_interface(hydra->kernel_interface,
- src, &name))
+ if (charon->kernel->get_interface(charon->kernel, src, &name))
{
- if (hydra->kernel_interface->add_route(hydra->kernel_interface,
+ if (charon->kernel->add_route(charon->kernel,
dst->get_address(dst), mask, gtw, src, name) == SUCCESS)
{
INIT(route,
{
return FALSE;
}
- if (hydra->kernel_interface->get_address_by_ts(hydra->kernel_interface,
- src_ts, &src, NULL) != SUCCESS)
+ if (charon->kernel->get_address_by_ts(charon->kernel, src_ts, &src,
+ NULL) != SUCCESS)
{
dst->destroy(dst);
return FALSE;
}
- gtw = hydra->kernel_interface->get_nexthop(hydra->kernel_interface,
- remote, -1, local);
+ gtw = charon->kernel->get_nexthop(charon->kernel, remote, -1, local);
if (add)
{
done = install_route(this, dst, mask, src, gtw);
{
src = src ? src->clone(src) : NULL;
dst = dst ? dst->clone(dst) : NULL;
- hydra->kernel_interface->acquire(hydra->kernel_interface, reqid,
- src, dst);
+ charon->kernel->acquire(charon->kernel, reqid, src, dst);
}
}
if (entry)
{
- hydra->kernel_interface->expire(hydra->kernel_interface, protocol,
- data->spi, data->dst, data->hard);
+ charon->kernel->expire(charon->kernel, protocol, data->spi, data->dst,
+ data->hard);
}
return JOB_REQUEUE_NONE;
#include <netdb.h>
#include <daemon.h>
-#include <hydra.h>
#include <attributes/mem_pool.h>
#include <collections/hashtable.h>
#include <threading/mutex.h>
id->destroy(id);
return NULL;
}
- if (hydra->kernel_interface->add_ip(hydra->kernel_interface,
- found, this->prefix, iface) != SUCCESS)
+ if (charon->kernel->add_ip(charon->kernel, found, this->prefix,
+ iface) != SUCCESS)
{
DBG1(DBG_CFG, "installing load-tester IP %H on %s failed", found, iface);
found->destroy(found);
{
if (pool->release_address(pool, entry->host, entry->id))
{
- hydra->kernel_interface->del_ip(hydra->kernel_interface,
- entry->host, this->prefix, FALSE);
+ charon->kernel->del_ip(charon->kernel, entry->host,
+ this->prefix, FALSE);
break;
}
}
{
if (online)
{
- hydra->kernel_interface->del_ip(hydra->kernel_interface,
- addr, this->prefix, FALSE);
+ charon->kernel->del_ip(charon->kernel, addr, this->prefix,
+ FALSE);
entry = this->leases->remove(this->leases, addr);
if (entry)
{
#include <unistd.h>
-#include <hydra.h>
#include <daemon.h>
#include <processing/jobs/callback_job.h>
#include <threading/condvar.h>
#include <sys/stat.h>
#include <unistd.h>
-#include <hydra.h>
#include <utils/debug.h>
#include <threading/mutex.h>
#include <netinet/udp.h>
#include <net/if.h>
-#include <hydra.h>
#include <daemon.h>
#include <threading/thread.h>
}
#endif
- if (!hydra->kernel_interface->bypass_socket(hydra->kernel_interface,
- skt, family))
+ if (!charon->kernel->bypass_socket(charon->kernel, skt, family))
{
DBG1(DBG_NET, "installing IKE bypass policy failed");
}
/* enable UDP decapsulation for NAT-T sockets */
if (port == &this->natt &&
- !hydra->kernel_interface->enable_udp_decap(hydra->kernel_interface,
- skt, family, this->natt))
+ !charon->kernel->enable_udp_decap(charon->kernel, skt, family,
+ this->natt))
{
DBG1(DBG_NET, "enabling UDP decapsulation for %s on port %d failed",
family == AF_INET ? "IPv4" : "IPv6", this->natt);
#include <netinet/udp.h>
#include <net/if.h>
-#include <hydra.h>
#include <daemon.h>
#include <threading/thread.h>
#include <threading/rwlock.h>
return 0;
}
- if (!hydra->kernel_interface->bypass_socket(hydra->kernel_interface,
- fd, family))
+ if (!charon->kernel->bypass_socket(charon->kernel, fd, family))
{
DBG1(DBG_NET, "installing IKE bypass policy failed");
}
/* enable UDP decapsulation on each socket */
- if (!hydra->kernel_interface->enable_udp_decap(hydra->kernel_interface,
- fd, family, *port))
+ if (!charon->kernel->enable_udp_decap(charon->kernel, fd, family, *port))
{
DBG1(DBG_NET, "enabling UDP decapsulation for %s on port %d failed",
family == AF_INET ? "IPv4" : "IPv6", *port);
#include "socket_win_socket.h"
#include <library.h>
-#include <hydra.h>
#include <threading/thread.h>
#include <daemon.h>
closesocket(s);
return INVALID_SOCKET;
}
- if (!hydra->kernel_interface->bypass_socket(hydra->kernel_interface,
- s, AF_INET))
+ if (!charon->kernel->bypass_socket(charon->kernel, s, AF_INET))
{
DBG1(DBG_NET, "installing IPv4 IKE bypass policy failed");
}
- if (!hydra->kernel_interface->bypass_socket(hydra->kernel_interface,
- s, AF_INET6))
+ if (!charon->kernel->bypass_socket(charon->kernel, s, AF_INET6))
{
DBG1(DBG_NET, "installing IPv6 IKE bypass policy failed");
}
#include "stroke_config.h"
-#include <hydra.h>
#include <daemon.h>
#include <threading/mutex.h>
#include <utils/lexparser.h>
host = host_create_from_dns(token, 0, 0);
if (host)
{
- if (hydra->kernel_interface->get_interface(
- hydra->kernel_interface, host, NULL))
+ if (charon->kernel->get_interface(charon->kernel, host, NULL))
{
found = TRUE;
}
#include "stroke_control.h"
-#include <hydra.h>
#include <daemon.h>
#include <processing/jobs/delete_ike_sa_job.h>
#include <malloc.h>
#endif /* HAVE_MALLINFO */
-#include <hydra.h>
#include <daemon.h>
#include <collections/linked_list.h>
#include <plugins/plugin.h>
}
enumerator->destroy(enumerator);
- enumerator = hydra->kernel_interface->create_address_enumerator(
- hydra->kernel_interface, ADDR_TYPE_REGULAR);
+ enumerator = charon->kernel->create_address_enumerator(charon->kernel,
+ ADDR_TYPE_REGULAR);
fprintf(out, "Listening IP addresses:\n");
while (enumerator->enumerate(enumerator, (void**)&host))
{
#include "tnc_ifmap_renew_session_job.h"
#include <daemon.h>
-#include <hydra.h>
#include <utils/debug.h>
#define IFMAP_RENEW_SESSION_INTERVAL 150
host_t *host;
bool success = TRUE;
- enumerator = hydra->kernel_interface->create_address_enumerator(
- hydra->kernel_interface, ADDR_TYPE_REGULAR);
+ enumerator = charon->kernel->create_address_enumerator(charon->kernel,
+ ADDR_TYPE_REGULAR);
while (enumerator->enumerate(enumerator, &host))
{
if (!this->ifmap->publish_device_ip(this->ifmap, host))
#include "updown_listener.h"
#include <utils/process.h>
-#include <hydra.h>
#include <daemon.h>
#include <config/child_cfg.h>
config->get_name(config));
if (up)
{
- if (hydra->kernel_interface->get_interface(hydra->kernel_interface,
- me, &iface))
+ if (charon->kernel->get_interface(charon->kernel, me, &iface))
{
cache_iface(this, child_sa->get_reqid(child_sa), iface);
}
#include <test_runner.h>
#include <daemon.h>
-#include <hydra.h>
/* declare test suite constructors */
#define TEST_SUITE(x) test_suite_t* x();
#include "adopt_children_job.h"
#include <daemon.h>
-#include <hydra.h>
#include <collections/array.h>
#include <processing/jobs/delete_ike_sa_job.h>
#include <string.h>
#include <time.h>
-#include <hydra.h>
#include <daemon.h>
#include <collections/array.h>
{
if (this->my_spi)
{
- status = hydra->kernel_interface->query_sa(hydra->kernel_interface,
- this->other_addr, this->my_addr, this->my_spi,
- proto_ike2ip(this->protocol), this->mark_in,
- &bytes, &packets, &time);
+ status = charon->kernel->query_sa(charon->kernel, this->other_addr,
+ this->my_addr, this->my_spi,
+ proto_ike2ip(this->protocol), this->mark_in,
+ &bytes, &packets, &time);
if (status == SUCCESS)
{
if (bytes > this->my_usebytes)
{
if (this->other_spi)
{
- status = hydra->kernel_interface->query_sa(hydra->kernel_interface,
- this->my_addr, this->other_addr, this->other_spi,
- proto_ike2ip(this->protocol), this->mark_out,
- &bytes, &packets, &time);
+ status = charon->kernel->query_sa(charon->kernel, this->my_addr,
+ this->other_addr, this->other_spi,
+ proto_ike2ip(this->protocol), this->mark_out,
+ &bytes, &packets, &time);
if (status == SUCCESS)
{
if (bytes > this->other_usebytes)
if (inbound)
{
- if (hydra->kernel_interface->query_policy(hydra->kernel_interface,
- other_ts, my_ts, POLICY_IN, this->mark_in, &in) == SUCCESS)
+ if (charon->kernel->query_policy(charon->kernel, other_ts,
+ my_ts, POLICY_IN, this->mark_in, &in) == SUCCESS)
{
last_use = max(last_use, in);
}
if (this->mode != MODE_TRANSPORT)
{
- if (hydra->kernel_interface->query_policy(hydra->kernel_interface,
- other_ts, my_ts, POLICY_FWD, this->mark_in, &fwd) == SUCCESS)
+ if (charon->kernel->query_policy(charon->kernel, other_ts,
+ my_ts, POLICY_FWD, this->mark_in, &fwd) == SUCCESS)
{
last_use = max(last_use, fwd);
}
}
else
{
- if (hydra->kernel_interface->query_policy(hydra->kernel_interface,
- my_ts, other_ts, POLICY_OUT, this->mark_out, &out) == SUCCESS)
+ if (charon->kernel->query_policy(charon->kernel, my_ts,
+ other_ts, POLICY_OUT, this->mark_out, &out) == SUCCESS)
{
last_use = max(last_use, out);
}
METHOD(child_sa_t, alloc_spi, u_int32_t,
private_child_sa_t *this, protocol_id_t protocol)
{
- if (hydra->kernel_interface->get_spi(hydra->kernel_interface,
- this->other_addr, this->my_addr,
- proto_ike2ip(protocol),
- &this->my_spi) == SUCCESS)
+ if (charon->kernel->get_spi(charon->kernel, this->other_addr, this->my_addr,
+ proto_ike2ip(protocol), &this->my_spi) == SUCCESS)
{
/* if we allocate a SPI, but then are unable to establish the SA, we
* need to know the protocol family to delete the partial SA */
METHOD(child_sa_t, alloc_cpi, u_int16_t,
private_child_sa_t *this)
{
- if (hydra->kernel_interface->get_cpi(hydra->kernel_interface,
- this->other_addr, this->my_addr,
- &this->my_cpi) == SUCCESS)
+ if (charon->kernel->get_cpi(charon->kernel, this->other_addr, this->my_addr,
+ &this->my_cpi) == SUCCESS)
{
return this->my_cpi;
}
if (!this->reqid_allocated && !this->static_reqid)
{
- status = hydra->kernel_interface->alloc_reqid(hydra->kernel_interface,
- my_ts, other_ts, this->mark_in, this->mark_out,
- &this->reqid);
+ status = charon->kernel->alloc_reqid(charon->kernel, my_ts, other_ts,
+ this->mark_in, this->mark_out, &this->reqid);
if (status != SUCCESS)
{
return status;
dst_ts = other_ts;
}
- status = hydra->kernel_interface->add_sa(hydra->kernel_interface,
+ status = charon->kernel->add_sa(charon->kernel,
src, dst, spi, proto_ike2ip(this->protocol), this->reqid,
inbound ? this->mark_in : this->mark_out, tfc,
lifetime, enc_alg, encr, int_alg, integ, this->mode,
{
kernel_feature_t f;
- f = hydra->kernel_interface->get_features(hydra->kernel_interface);
+ f = charon->kernel->get_features(charon->kernel);
return !(f & KERNEL_NO_POLICY_UPDATES);
}
ipsec_sa_cfg_t *other_sa, policy_type_t type, policy_priority_t priority)
{
status_t status = SUCCESS;
- status |= hydra->kernel_interface->add_policy(hydra->kernel_interface,
+ status |= charon->kernel->add_policy(charon->kernel,
my_addr, other_addr, my_ts, other_ts,
POLICY_OUT, type, other_sa,
this->mark_out, priority);
- status |= hydra->kernel_interface->add_policy(hydra->kernel_interface,
+ status |= charon->kernel->add_policy(charon->kernel,
other_addr, my_addr, other_ts, my_ts,
POLICY_IN, type, my_sa,
this->mark_in, priority);
if (this->mode != MODE_TRANSPORT)
{
- status |= hydra->kernel_interface->add_policy(hydra->kernel_interface,
+ status |= charon->kernel->add_policy(charon->kernel,
other_addr, my_addr, other_ts, my_ts,
POLICY_FWD, type, my_sa,
this->mark_in, priority);
ipsec_sa_cfg_t *other_sa, policy_type_t type, policy_priority_t priority)
{
- hydra->kernel_interface->del_policy(hydra->kernel_interface,
+ charon->kernel->del_policy(charon->kernel,
my_addr, other_addr, my_ts, other_ts, POLICY_OUT, type,
other_sa, this->mark_out, priority);
- hydra->kernel_interface->del_policy(hydra->kernel_interface,
+ charon->kernel->del_policy(charon->kernel,
other_addr, my_addr, other_ts, my_ts, POLICY_IN,
type, my_sa, this->mark_in, priority);
if (this->mode != MODE_TRANSPORT)
{
- hydra->kernel_interface->del_policy(hydra->kernel_interface,
+ charon->kernel->del_policy(charon->kernel,
other_addr, my_addr, other_ts, my_ts, POLICY_FWD,
type, my_sa, this->mark_in, priority);
}
if (!this->reqid_allocated && !this->static_reqid)
{
/* trap policy, get or confirm reqid */
- status = hydra->kernel_interface->alloc_reqid(
- hydra->kernel_interface, my_ts_list, other_ts_list,
+ status = charon->kernel->alloc_reqid(
+ charon->kernel, my_ts_list, other_ts_list,
this->mark_in, this->mark_out, &this->reqid);
if (status != SUCCESS)
{
{
char *iface;
- if (hydra->kernel_interface->get_interface(hydra->kernel_interface,
- me, &iface))
+ if (charon->kernel->get_interface(charon->kernel, me, &iface))
{
- hydra->kernel_interface->del_ip(hydra->kernel_interface, vip, -1, TRUE);
- hydra->kernel_interface->add_ip(hydra->kernel_interface, vip, -1, iface);
+ charon->kernel->del_ip(charon->kernel, vip, -1, TRUE);
+ charon->kernel->add_ip(charon->kernel, vip, -1, iface);
free(iface);
}
}
/* update our (initiator) SA */
if (this->my_spi)
{
- if (hydra->kernel_interface->update_sa(hydra->kernel_interface,
+ if (charon->kernel->update_sa(charon->kernel,
this->my_spi, proto_ike2ip(this->protocol),
this->ipcomp != IPCOMP_NONE ? this->my_cpi : 0,
this->other_addr, this->my_addr, other, me,
/* update his (responder) SA */
if (this->other_spi)
{
- if (hydra->kernel_interface->update_sa(hydra->kernel_interface,
+ if (charon->kernel->update_sa(charon->kernel,
this->other_spi, proto_ike2ip(this->protocol),
this->ipcomp != IPCOMP_NONE ? this->other_cpi : 0,
this->my_addr, this->other_addr, me, other,
/* delete SAs in the kernel, if they are set up */
if (this->my_spi)
{
- hydra->kernel_interface->del_sa(hydra->kernel_interface,
+ charon->kernel->del_sa(charon->kernel,
this->other_addr, this->my_addr, this->my_spi,
proto_ike2ip(this->protocol), this->my_cpi,
this->mark_in);
}
if (this->other_spi)
{
- hydra->kernel_interface->del_sa(hydra->kernel_interface,
+ charon->kernel->del_sa(charon->kernel,
this->my_addr, this->other_addr, this->other_spi,
proto_ike2ip(this->protocol), this->other_cpi,
this->mark_out);
if (this->reqid_allocated)
{
- if (hydra->kernel_interface->release_reqid(hydra->kernel_interface,
+ if (charon->kernel->release_reqid(charon->kernel,
this->reqid, this->mark_in, this->mark_out) != SUCCESS)
{
DBG1(DBG_CHD, "releasing reqid %u failed", this->reqid);
#include "ike_sa.h"
#include <library.h>
-#include <hydra.h>
#include <daemon.h>
#include <collections/array.h>
#include <utils/lexparser.h>
{
char *iface;
- if (hydra->kernel_interface->get_interface(hydra->kernel_interface,
- this->my_host, &iface))
+ if (charon->kernel->get_interface(charon->kernel, this->my_host,
+ &iface))
{
DBG1(DBG_IKE, "installing new virtual IP %H", ip);
- if (hydra->kernel_interface->add_ip(hydra->kernel_interface,
- ip, -1, iface) == SUCCESS)
+ if (charon->kernel->add_ip(charon->kernel, ip, -1,
+ iface) == SUCCESS)
{
array_insert_create(&this->my_vips, ARRAY_TAIL, ip->clone(ip));
}
{
if (local)
{
- hydra->kernel_interface->del_ip(hydra->kernel_interface,
- vip, -1, TRUE);
+ charon->kernel->del_ip(charon->kernel, vip, -1, TRUE);
}
vip->destroy(vip);
}
!this->other_host->is_anyaddr(this->other_host))
{
host->destroy(host);
- host = hydra->kernel_interface->get_source_addr(
- hydra->kernel_interface, this->other_host, NULL);
+ host = charon->kernel->get_source_addr(charon->kernel,
+ this->other_host, NULL);
if (host)
{
host->set_port(host, this->ike_cfg->get_my_port(this->ike_cfg));
{
bool valid = FALSE;
host_t *src;
- src = hydra->kernel_interface->get_source_addr(hydra->kernel_interface,
- this->other_host, this->my_host);
+ src = charon->kernel->get_source_addr(charon->kernel, this->other_host,
+ this->my_host);
if (src)
{
if (src->ip_equals(src, this->my_host))
continue;
}
DBG1(DBG_IKE, "looking for a route to %H ...", addr);
- src = hydra->kernel_interface->get_source_addr(
- hydra->kernel_interface, addr, NULL);
+ src = charon->kernel->get_source_addr(charon->kernel, addr, NULL);
if (src)
{
break;
}
while (array_remove(this->my_vips, ARRAY_TAIL, &vip))
{
- hydra->kernel_interface->del_ip(hydra->kernel_interface, vip, -1, TRUE);
+ charon->kernel->del_ip(charon->kernel, vip, -1, TRUE);
vip->destroy(vip);
}
if (array_count(this->other_vips))
#include <string.h>
-#include <hydra.h>
#include <daemon.h>
#include <sa/ikev1/keymat_v1.h>
#include <config/peer_cfg.h>
{
if (!ike_cfg->force_encap(ike_cfg))
{
- return hydra->kernel_interface->get_features(hydra->kernel_interface) &
+ return charon->kernel->get_features(charon->kernel) &
KERNEL_REQUIRE_UDP_ENCAPSULATION;
}
return TRUE;
#include "xauth.h"
#include <daemon.h>
-#include <hydra.h>
#include <encoding/payloads/cp_payload.h>
#include <processing/jobs/adopt_children_job.h>
#include <sa/ikev1/tasks/mode_config.h>
#include "child_create.h"
#include <daemon.h>
-#include <hydra.h>
#include <sa/ikev2/keymat_v2.h>
#include <crypto/diffie_hellman.h>
#include <credentials/certificates/x509.h>
break;
}
- features = hydra->kernel_interface->get_features(hydra->kernel_interface);
+ features = charon->kernel->get_features(charon->kernel);
if (!(features & KERNEL_ESP_V3_TFC))
{
message->add_notify(message, FALSE, ESP_TFC_PADDING_NOT_SUPPORTED,
#include <string.h>
-#include <hydra.h>
#include <daemon.h>
#include <config/peer_cfg.h>
#include <encoding/payloads/id_payload.h>
host = this->ike_sa->get_my_host(this->ike_sa);
port = host->get_port(host);
- enumerator = hydra->kernel_interface->create_address_enumerator(
- hydra->kernel_interface, ADDR_TYPE_REGULAR);
+ enumerator = charon->kernel->create_address_enumerator(charon->kernel,
+ ADDR_TYPE_REGULAR);
while (enumerator->enumerate(enumerator, (void**)&addr))
{
host = addr->clone(addr);
#include <string.h>
-#include <hydra.h>
#include <daemon.h>
#include <sa/ikev2/tasks/ike_natd.h>
#include <encoding/payloads/notify_payload.h>
int added = 0;
me = this->ike_sa->get_my_host(this->ike_sa);
- enumerator = hydra->kernel_interface->create_address_enumerator(
- hydra->kernel_interface, ADDR_TYPE_REGULAR);
+ enumerator = charon->kernel->create_address_enumerator(charon->kernel,
+ ADDR_TYPE_REGULAR);
while (enumerator->enumerate(enumerator, (void**)&host))
{
if (me->ip_equals(me, host))
if (!this->check)
{
- me = hydra->kernel_interface->get_source_addr(hydra->kernel_interface,
- other_old, me_old);
+ me = charon->kernel->get_source_addr(charon->kernel, other_old, me_old);
if (me)
{
if (me->ip_equals(me, me_old))
{
continue;
}
- me = hydra->kernel_interface->get_source_addr(
- hydra->kernel_interface, other, NULL);
+ me = charon->kernel->get_source_addr(charon->kernel, other, NULL);
if (me)
{
/* reuse port for an active address, 4500 otherwise */
/* we check if the existing address is still valid */
old = message->get_source(message);
- new = hydra->kernel_interface->get_source_addr(hydra->kernel_interface,
+ new = charon->kernel->get_source_addr(charon->kernel,
message->get_destination(message), old);
if (new)
{
#include <string.h>
-#include <hydra.h>
#include <daemon.h>
#include <config/peer_cfg.h>
#include <crypto/hashers/hasher.h>
{
if (!ike_cfg->force_encap(ike_cfg))
{
- return hydra->kernel_interface->get_features(hydra->kernel_interface) &
+ return charon->kernel->get_features(charon->kernel) &
KERNEL_REQUIRE_UDP_ENCAPSULATION;
}
return TRUE;
}
else
{
- host = hydra->kernel_interface->get_source_addr(hydra->kernel_interface,
+ host = charon->kernel->get_source_addr(charon->kernel,
this->ike_sa->get_other_host(this->ike_sa), NULL);
if (host)
{ /* 2. */
}
else
{ /* 3. */
- enumerator = hydra->kernel_interface->create_address_enumerator(
- hydra->kernel_interface, ADDR_TYPE_REGULAR);
+ enumerator = charon->kernel->create_address_enumerator(
+ charon->kernel, ADDR_TYPE_REGULAR);
while (enumerator->enumerate(enumerator, (void**)&host))
{
/* apply port 500 to host, but work on a copy */
#include "shunt_manager.h"
-#include <hydra.h>
#include <daemon.h>
#include <threading/rwlock.h>
#include <threading/rwlock_condvar.h>
continue;
}
/* install out policy */
- status |= hydra->kernel_interface->add_policy(
- hydra->kernel_interface, host_any, host_any,
+ status |= charon->kernel->add_policy(charon->kernel,
+ host_any, host_any,
my_ts, other_ts, POLICY_OUT, policy_type,
&sa, child->get_mark(child, FALSE),
policy_prio);
/* install in policy */
- status |= hydra->kernel_interface->add_policy(
- hydra->kernel_interface, host_any, host_any,
+ status |= charon->kernel->add_policy(charon->kernel,
+ host_any, host_any,
other_ts, my_ts, POLICY_IN, policy_type,
&sa, child->get_mark(child, TRUE),
policy_prio);
/* install forward policy */
- status |= hydra->kernel_interface->add_policy(
- hydra->kernel_interface, host_any, host_any,
+ status |= charon->kernel->add_policy(charon->kernel,
+ host_any, host_any,
other_ts, my_ts, POLICY_FWD, policy_type,
&sa, child->get_mark(child, TRUE),
policy_prio);
continue;
}
/* uninstall out policy */
- status |= hydra->kernel_interface->del_policy(
- hydra->kernel_interface, host_any, host_any,
+ status |= charon->kernel->del_policy(charon->kernel,
+ host_any, host_any,
my_ts, other_ts, POLICY_OUT, policy_type,
&sa, child->get_mark(child, FALSE),
policy_prio);
/* uninstall in policy */
- status |= hydra->kernel_interface->del_policy(
- hydra->kernel_interface, host_any, host_any,
+ status |= charon->kernel->del_policy(charon->kernel,
+ host_any, host_any,
other_ts, my_ts, POLICY_IN, policy_type,
&sa, child->get_mark(child, TRUE),
policy_prio);
/* uninstall forward policy */
- status |= hydra->kernel_interface->del_policy(
- hydra->kernel_interface, host_any, host_any,
+ status |= charon->kernel->del_policy(charon->kernel,
+ host_any, host_any,
other_ts, my_ts, POLICY_FWD, policy_type,
&sa, child->get_mark(child, TRUE),
policy_prio);
#include "trap_manager.h"
-#include <hydra.h>
#include <daemon.h>
#include <threading/mutex.h>
#include <threading/rwlock.h>
if (!me || me->is_anyaddr(me))
{
DESTROY_IF(me);
- me = hydra->kernel_interface->get_source_addr(
- hydra->kernel_interface, other, NULL);
+ me = charon->kernel->get_source_addr(charon->kernel, other, NULL);
if (!me)
{
DBG1(DBG_CFG, "installing trap failed, local address unknown");
# copy-n-paste from Makefile.am
libhydra_la_SOURCES := \
-hydra.c hydra.h \
-kernel/kernel_interface.c kernel/kernel_interface.h \
-kernel/kernel_ipsec.c kernel/kernel_ipsec.h \
-kernel/kernel_net.c kernel/kernel_net.h \
-kernel/kernel_listener.h
+hydra.c hydra.h
LOCAL_SRC_FILES := $(filter %.c,$(libhydra_la_SOURCES))
ipseclib_LTLIBRARIES = libhydra.la
libhydra_la_SOURCES = \
-hydra.c hydra.h \
-kernel/kernel_interface.c kernel/kernel_interface.h \
-kernel/kernel_ipsec.c kernel/kernel_ipsec.h \
-kernel/kernel_net.c kernel/kernel_net.h \
-kernel/kernel_listener.h
+hydra.c hydra.h
libhydra_la_LIBADD = \
$(top_builddir)/src/libstrongswan/libstrongswan.la
return;
}
- this->public.kernel_interface->destroy(this->public.kernel_interface);
free(this);
hydra = NULL;
}
);
hydra = &this->public;
- this->public.kernel_interface = kernel_interface_create();
-
if (lib->integrity &&
!lib->integrity->check(lib->integrity, "libhydra", libhydra_init))
{
typedef struct hydra_t hydra_t;
-#include <kernel/kernel_interface.h>
-
#include <library.h>
/**
*/
struct hydra_t {
- /**
- * kernel interface to communicate with kernel
- */
- kernel_interface_t *kernel_interface;
};
/**
-I${linux_headers} \
-I$(top_srcdir)/src/libstrongswan \
-I$(top_srcdir)/src/libhydra \
+ -I$(top_srcdir)/src/libcharon \
-I$(top_srcdir)/src/starter \
-I$(top_srcdir)/src/stroke \
-DIPSEC_DIR=\"${ipsecdir}\" \
starter_LDADD = \
$(top_builddir)/src/libstrongswan/libstrongswan.la \
$(top_builddir)/src/libhydra/libhydra.la \
+ $(top_builddir)/src/libcharon/libcharon.la \
libstarter.la \
$(SOCKLIB) $(PTHREADLIB)
#include <stdlib.h>
#include <library.h>
-#include <hydra.h>
#include <utils/debug.h>
#include "files.h"
projects / thirdparty / strongswan.git / commitdiff
