/* site.c - manage communication with a remote network site */
+/* The 'site' code doesn't know anything about the structure of the
+ packets it's transmitting. In fact, under the new netlink
+ configuration scheme it doesn't need to know anything at all about
+ IP addresses, except how to contact its peer. This means it could
+ potentially be used to tunnel other protocols too (IPv6, IPX, plain
+ old Ethernet frames) if appropriate netlink code can be written
+ (and that ought not to be too hard, eg. using the TUN/TAP device to
+ pretend to be an Ethernet interface). */
+
#include "secnet.h"
#include <stdio.h>
+#include <string.h>
/* MBM asserts the next one is needed for compilation under BSD. */
#include <sys/socket.h>
{ NULL, 0 }
};
-static struct flagstr netlink_option_table[]={
- { "soft", NETLINK_OPTION_SOFTROUTE },
- { "allow-route", NETLINK_OPTION_ALLOW_ROUTE },
- { NULL, 0}
-};
-
struct site {
closure_t cl;
struct site_if ops;
struct log_if *log;
struct random_if *random;
struct rsaprivkey_if *privkey;
- struct subnet_list remotenets;
struct rsapubkey_if *pubkey;
struct transform_if *transform;
struct dh_if *dh;
uint32_t state;
uint64_t now; /* Most recently seen time */
- void *netlink_cid;
-
uint32_t remote_session_id;
struct transform_inst_if *current_transform;
bool_t current_valid;
{
va_list ap;
uint8_t buf[240];
+ uint32_t class;
va_start(ap,msg);
if (event&st->log_events) {
+ switch(event) {
+ case LOG_UNEXPECTED: class=M_INFO; break;
+ case LOG_SETUP_INIT: class=M_INFO; break;
+ case LOG_SETUP_TIMEOUT: class=M_NOTICE; break;
+ case LOG_ACTIVATE_KEY: class=M_INFO; break;
+ case LOG_TIMEOUT_KEY: class=M_INFO; break;
+ case LOG_SEC: class=M_SECURITY; break;
+ case LOG_STATE: class=M_DEBUG; break;
+ case LOG_DROP: class=M_DEBUG; break;
+ case LOG_DUMP: class=M_DEBUG; break;
+ case LOG_ERROR: class=M_ERR; break;
+ default: class=M_ERR; break;
+ }
+
vsnprintf(buf,240,msg,ap);
- st->log->log(st->log->st,0,"%s: %s",st->tunname,buf);
+ st->log->log(st->log->st,class,"%s: %s",st->tunname,buf);
}
va_end(ap);
}
msg0,&transform_err)) {
/* There's a problem */
slog(st,LOG_SEC,"transform: %s",transform_err);
- return False;
+ return initiate_key_setup(st);
}
CHECK_AVAIL(msg0,4);
type=buf_unprepend_uint32(msg0);
switch(type) {
case LABEL_MSG9:
/* Deliver to netlink layer */
- st->netlink->deliver(st->netlink->st,st->netlink_cid,msg0);
+ st->netlink->deliver(st->netlink->st,msg0);
return True;
break;
default:
uint32_t msgtype=ntohl(*(uint32_t *)(buf->start+8));
if (st->log_events & LOG_DUMP)
- log(st->log,0,"%s: %s: %08x<-%08x: %08x:",
+ log(st->log,M_DEBUG,"%s: %s: %08x<-%08x: %08x:",
st->tunname,incoming?"incoming":"outgoing",
dest,source,msgtype);
}
else
quality=LINK_QUALITY_DOWN;
- st->netlink->set_quality(st->netlink->st,st->netlink_cid,quality);
+ st->netlink->set_quality(st->netlink->st,quality);
}
static void enter_state_run(struct site *st)
/* This function is called by the netlink device to deliver packets
intended for the remote network. The packet is in "raw" wire
format, but is guaranteed to be word-aligned. */
-static void site_outgoing(void *sst, void *cid, struct buffer_if *buf)
+static void site_outgoing(void *sst, struct buffer_if *buf)
{
struct site *st=sst;
string_t transform_err;
struct site *st;
item_t *item;
dict_t *dict;
- uint32_t netlink_options;
st=safe_malloc(sizeof(*st),"site_apply");
site() closures for all sites including our own): refuse to
talk to ourselves */
if (strcmp(st->localname,st->remotename)==0) {
- Message(M_INFO,"site %s: local-name==name -> ignoring this site\n",
+ Message(M_DEBUG,"site %s: local-name==name -> ignoring this site\n",
st->localname);
free(st);
return NULL;
}
- st->netlink=find_cl_if(dict,"netlink",CL_NETLINK,True,"site",loc);
+ st->netlink=find_cl_if(dict,"link",CL_NETLINK,True,"site",loc);
st->comm=find_cl_if(dict,"comm",CL_COMM,True,"site",loc);
st->resolver=find_cl_if(dict,"resolver",CL_RESOLVER,True,"site",loc);
st->log=find_cl_if(dict,"log",CL_LOG,True,"site",loc);
if (st->address)
st->remoteport=dict_read_number(dict,"port",True,"site",loc,0);
else st->remoteport=0;
- dict_read_subnet_list(dict, "networks", True, "site", loc,
- &st->remotenets);
st->pubkey=find_cl_if(dict,"key",CL_RSAPUBKEY,True,"site",loc);
st->transform=
st->log_events=string_list_to_word(dict_lookup(dict,"log-events"),
log_event_table,"site");
- netlink_options=string_list_to_word(dict_lookup(dict,"netlink-options"),
- netlink_option_table,"site");
-
st->tunname=safe_malloc(strlen(st->localname)+strlen(st->remotename)+5,
"site_apply");
sprintf(st->tunname,"%s<->%s",st->localname,st->remotename);
st->sharedsecret=safe_malloc(st->transform->keylen,"site:sharedsecret");
/* We need to register the remote networks with the netlink device */
- st->netlink_cid=st->netlink->regnets(st->netlink->st, &st->remotenets,
- site_outgoing, st,
- st->transform->max_start_pad+(4*4),
- st->transform->max_end_pad,
- netlink_options, st->tunname);
- if (!st->netlink_cid) {
- Message(M_WARNING,"%s: netlink device did not let us register "
- "our remote networks. This site will not start.\n",
- st->tunname);
- return NULL; /* XXX should free site first */
- }
+ st->netlink->reg(st->netlink->st, site_outgoing, st,
+ st->transform->max_start_pad+(4*4),
+ st->transform->max_end_pad);
st->comm->request_notify(st->comm->st, st, site_incoming);
~ian / secnet.git / blobdiff