j3d1/tinc
1
0
Fork 0
Code Issues 1 Pull requests Releases Wiki Activity

Add a variable offset to vpn_packet_t, drop sptps_packet_t.

Browse source 
The offset value indicates where the actual payload starts, so we can
process both legacy and SPTPS UDP packets without having to do casting
tricks and/or moving memory around.
This commit is contained in:
Guus Sliepen 2014-12-24 22:23:24 +01:00
parent 107d9c7da5
commit 6b92ac505d
14 changed files with 234 additions and 212 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

44
src/bsd/device.c
View file

@ -1,7 +1,7 @@
/* /*
device.c -- Interaction BSD tun/tap device device.c -- Interaction BSD tun/tap device
Copyright (C) 2001-2005 Ivo Timmermans, Copyright (C) 2001-2005 Ivo Timmermans,
2001-2013 Guus Sliepen <guus@tinc-vpn.org> 2001-2014 Guus Sliepen <guus@tinc-vpn.org>
2009 Grzegorz Dymarek <gregd72002@googlemail.com> 2009 Grzegorz Dymarek <gregd72002@googlemail.com>
This program is free software; you can redistribute it and/or modify This program is free software; you can redistribute it and/or modify
@ -222,10 +222,10 @@ static bool read_packet(vpn_packet_t *packet) {
#ifdef ENABLE_TUNEMU #ifdef ENABLE_TUNEMU
case DEVICE_TYPE_TUNEMU: case DEVICE_TYPE_TUNEMU:
if(device_type == DEVICE_TYPE_TUNEMU) if(device_type == DEVICE_TYPE_TUNEMU)
inlen = tunemu_read(device_fd, packet->data + 14, MTU - 14); inlen = tunemu_read(device_fd, DATA(packet) + 14, MTU - 14);
else else
#endif #endif
inlen = read(device_fd, packet->data + 14, MTU - 14); inlen = read(device_fd, DATA(packet) + 14, MTU - 14);
if(inlen <= 0) { if(inlen <= 0) {
logger(DEBUG_ALWAYS, LOG_ERR, "Error while reading from %s %s: %s", device_info, logger(DEBUG_ALWAYS, LOG_ERR, "Error while reading from %s %s: %s", device_info,
@ -233,29 +233,29 @@ static bool read_packet(vpn_packet_t *packet) {
return false; return false;
} }
switch(packet->data[14] >> 4) { switch(DATA(packet)[14] >> 4) {
case 4: case 4:
packet->data[12] = 0x08; DATA(packet)[12] = 0x08;
packet->data[13] = 0x00; DATA(packet)[13] = 0x00;
break; break;
case 6: case 6:
packet->data[12] = 0x86; DATA(packet)[12] = 0x86;
packet->data[13] = 0xDD; DATA(packet)[13] = 0xDD;
break; break;
default: default:
logger(DEBUG_TRAFFIC, LOG_ERR, logger(DEBUG_TRAFFIC, LOG_ERR,
"Unknown IP version %d while reading packet from %s %s", "Unknown IP version %d while reading packet from %s %s",
packet->data[14] >> 4, device_info, device); DATA(packet)[14] >> 4, device_info, device);
return false; return false;
} }
memset(packet->data, 0, 12); memset(DATA(packet), 0, 12);
packet->len = inlen + 14; packet->len = inlen + 14;
break; break;
case DEVICE_TYPE_TUNIFHEAD: { case DEVICE_TYPE_TUNIFHEAD: {
u_int32_t type; u_int32_t type;
struct iovec vector[2] = {{&type, sizeof type}, {packet->data + 14, MTU - 14}}; struct iovec vector[2] = {{&type, sizeof type}, {DATA(packet) + 14, MTU - 14}};
if((inlen = readv(device_fd, vector, 2)) <= 0) { if((inlen = readv(device_fd, vector, 2)) <= 0) {
logger(DEBUG_ALWAYS, LOG_ERR, "Error while reading from %s %s: %s", device_info, logger(DEBUG_ALWAYS, LOG_ERR, "Error while reading from %s %s: %s", device_info,
@ -265,13 +265,13 @@ static bool read_packet(vpn_packet_t *packet) {
switch (ntohl(type)) { switch (ntohl(type)) {
case AF_INET: case AF_INET:
packet->data[12] = 0x08; DATA(packet)[12] = 0x08;
packet->data[13] = 0x00; DATA(packet)[13] = 0x00;
break; break;
case AF_INET6: case AF_INET6:
packet->data[12] = 0x86; DATA(packet)[12] = 0x86;
packet->data[13] = 0xDD; DATA(packet)[13] = 0xDD;
break; break;
default: default:
@ -281,13 +281,13 @@ static bool read_packet(vpn_packet_t *packet) {
return false; return false;
} }
memset(packet->data, 0, 12); memset(DATA(packet), 0, 12);
packet->len = inlen + 10; packet->len = inlen + 10;
break; break;
} }
case DEVICE_TYPE_TAP: case DEVICE_TYPE_TAP:
if((inlen = read(device_fd, packet->data, MTU)) <= 0) { if((inlen = read(device_fd, DATA(packet), MTU)) <= 0) {
logger(DEBUG_ALWAYS, LOG_ERR, "Error while reading from %s %s: %s", device_info, logger(DEBUG_ALWAYS, LOG_ERR, "Error while reading from %s %s: %s", device_info,
device, strerror(errno)); device, strerror(errno));
return false; return false;
@ -312,7 +312,7 @@ static bool write_packet(vpn_packet_t *packet) {
switch(device_type) { switch(device_type) {
case DEVICE_TYPE_TUN: case DEVICE_TYPE_TUN:
if(write(device_fd, packet->data + 14, packet->len - 14) < 0) { if(write(device_fd, DATA(packet) + 14, packet->len - 14) < 0) {
logger(DEBUG_ALWAYS, LOG_ERR, "Error while writing to %s %s: %s", device_info, logger(DEBUG_ALWAYS, LOG_ERR, "Error while writing to %s %s: %s", device_info,
device, strerror(errno)); device, strerror(errno));
return false; return false;
@ -321,10 +321,10 @@ static bool write_packet(vpn_packet_t *packet) {
case DEVICE_TYPE_TUNIFHEAD: { case DEVICE_TYPE_TUNIFHEAD: {
u_int32_t type; u_int32_t type;
struct iovec vector[2] = {{&type, sizeof type}, {packet->data + 14, packet->len - 14}}; struct iovec vector[2] = {{&type, sizeof type}, {DATA(packet) + 14, packet->len - 14}};
int af; int af;
af = (packet->data[12] << 8) + packet->data[13]; af = (DATA(packet)[12] << 8) + DATA(packet)[13];
switch (af) { switch (af) {
case 0x0800: case 0x0800:
@ -349,7 +349,7 @@ static bool write_packet(vpn_packet_t *packet) {
} }
case DEVICE_TYPE_TAP: case DEVICE_TYPE_TAP:
if(write(device_fd, packet->data, packet->len) < 0) { if(write(device_fd, DATA(packet), packet->len) < 0) {
logger(DEBUG_ALWAYS, LOG_ERR, "Error while writing to %s %s: %s", device_info, logger(DEBUG_ALWAYS, LOG_ERR, "Error while writing to %s %s: %s", device_info,
device, strerror(errno)); device, strerror(errno));
return false; return false;
@ -358,7 +358,7 @@ static bool write_packet(vpn_packet_t *packet) {
#ifdef ENABLE_TUNEMU #ifdef ENABLE_TUNEMU
case DEVICE_TYPE_TUNEMU: case DEVICE_TYPE_TUNEMU:
if(tunemu_write(device_fd, packet->data + 14, packet->len - 14) < 0) { if(tunemu_write(device_fd, DATA(packet) + 14, packet->len - 14) < 0) {
logger(DEBUG_ALWAYS, LOG_ERR, "Error while writing to %s %s: %s", device_info, logger(DEBUG_ALWAYS, LOG_ERR, "Error while writing to %s %s: %s", device_info,
device, strerror(errno)); device, strerror(errno));
return false; return false;

6
src/cygwin/device.c
View file

@ -1,7 +1,7 @@
/* /*
device.c -- Interaction with Windows tap driver in a Cygwin environment device.c -- Interaction with Windows tap driver in a Cygwin environment
Copyright (C) 2002-2005 Ivo Timmermans, Copyright (C) 2002-2005 Ivo Timmermans,
2002-2013 Guus Sliepen <guus@tinc-vpn.org> 2002-2014 Guus Sliepen <guus@tinc-vpn.org>
This program is free software; you can redistribute it and/or modify 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 it under the terms of the GNU General Public License as published by
@ -227,7 +227,7 @@ static void close_device(void) {
static bool read_packet(vpn_packet_t *packet) { static bool read_packet(vpn_packet_t *packet) {
int inlen; int inlen;
if((inlen = read(sp[0], packet->data, MTU)) <= 0) { if((inlen = read(sp[0], DATA(packet), MTU)) <= 0) {
logger(DEBUG_ALWAYS, LOG_ERR, "Error while reading from %s %s: %s", device_info, logger(DEBUG_ALWAYS, LOG_ERR, "Error while reading from %s %s: %s", device_info,
device, strerror(errno)); device, strerror(errno));
return false; return false;
@ -247,7 +247,7 @@ static bool write_packet(vpn_packet_t *packet) {
logger(DEBUG_TRAFFIC, LOG_DEBUG, "Writing packet of %d bytes to %s", logger(DEBUG_TRAFFIC, LOG_DEBUG, "Writing packet of %d bytes to %s",
packet->len, device_info); packet->len, device_info);
if(!WriteFile (device_handle, packet->data, packet->len, &outlen, NULL)) { if(!WriteFile (device_handle, DATA(packet), packet->len, &outlen, NULL)) {
logger(DEBUG_ALWAYS, LOG_ERR, "Error while writing to %s %s: %s", device_info, device, winerror(GetLastError())); logger(DEBUG_ALWAYS, LOG_ERR, "Error while writing to %s %s: %s", device_info, device, winerror(GetLastError()));
return false; return false;
} }

14
src/linux/device.c
View file

@ -1,7 +1,7 @@
/* /*
device.c -- Interaction with Linux ethertap and tun/tap device device.c -- Interaction with Linux ethertap and tun/tap device
Copyright (C) 2001-2005 Ivo Timmermans, Copyright (C) 2001-2005 Ivo Timmermans,
2001-2013 Guus Sliepen <guus@tinc-vpn.org> 2001-2014 Guus Sliepen <guus@tinc-vpn.org>
This program is free software; you can redistribute it and/or modify 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 it under the terms of the GNU General Public License as published by
@ -131,7 +131,7 @@ static bool read_packet(vpn_packet_t *packet) {
switch(device_type) { switch(device_type) {
case DEVICE_TYPE_TUN: case DEVICE_TYPE_TUN:
inlen = read(device_fd, packet->data + 10, MTU - 10); inlen = read(device_fd, DATA(packet) + 10, MTU - 10);
if(inlen <= 0) { if(inlen <= 0) {
logger(DEBUG_ALWAYS, LOG_ERR, "Error while reading from %s %s: %s", logger(DEBUG_ALWAYS, LOG_ERR, "Error while reading from %s %s: %s",
@ -139,11 +139,11 @@ static bool read_packet(vpn_packet_t *packet) {
return false; return false;
} }
memset(packet->data, 0, 12); memset(DATA(packet), 0, 12);
packet->len = inlen + 10; packet->len = inlen + 10;
break; break;
case DEVICE_TYPE_TAP: case DEVICE_TYPE_TAP:
inlen = read(device_fd, packet->data, MTU); inlen = read(device_fd, DATA(packet), MTU);
if(inlen <= 0) { if(inlen <= 0) {
logger(DEBUG_ALWAYS, LOG_ERR, "Error while reading from %s %s: %s", logger(DEBUG_ALWAYS, LOG_ERR, "Error while reading from %s %s: %s",
@ -169,15 +169,15 @@ static bool write_packet(vpn_packet_t *packet) {
switch(device_type) { switch(device_type) {
case DEVICE_TYPE_TUN: case DEVICE_TYPE_TUN:
packet->data[10] = packet->data[11] = 0; DATA(packet)[10] = DATA(packet)[11] = 0;
if(write(device_fd, packet->data + 10, packet->len - 10) < 0) { if(write(device_fd, DATA(packet) + 10, packet->len - 10) < 0) {
logger(DEBUG_ALWAYS, LOG_ERR, "Can't write to %s %s: %s", device_info, device, logger(DEBUG_ALWAYS, LOG_ERR, "Can't write to %s %s: %s", device_info, device,
strerror(errno)); strerror(errno));
return false; return false;
} }
break; break;
case DEVICE_TYPE_TAP: case DEVICE_TYPE_TAP:
if(write(device_fd, packet->data, packet->len) < 0) { if(write(device_fd, DATA(packet), packet->len) < 0) {
logger(DEBUG_ALWAYS, LOG_ERR, "Can't write to %s %s: %s", device_info, device, logger(DEBUG_ALWAYS, LOG_ERR, "Can't write to %s %s: %s", device_info, device,
strerror(errno)); strerror(errno));
return false; return false;

4
src/mingw/device.c
View file

@ -1,7 +1,7 @@
/* /*
device.c -- Interaction with Windows tap driver in a MinGW environment device.c -- Interaction with Windows tap driver in a MinGW environment
Copyright (C) 2002-2005 Ivo Timmermans, Copyright (C) 2002-2005 Ivo Timmermans,
2002-2013 Guus Sliepen <guus@tinc-vpn.org> 2002-2014 Guus Sliepen <guus@tinc-vpn.org>
This program is free software; you can redistribute it and/or modify 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 it under the terms of the GNU General Public License as published by
@ -236,7 +236,7 @@ static bool write_packet(vpn_packet_t *packet) {
logger(DEBUG_TRAFFIC, LOG_DEBUG, "Writing packet of %d bytes to %s", logger(DEBUG_TRAFFIC, LOG_DEBUG, "Writing packet of %d bytes to %s",
packet->len, device_info); packet->len, device_info);
if(!WriteFile(device_handle, packet->data, packet->len, &outlen, &overlapped)) { if(!WriteFile(device_handle, DATA(packet), packet->len, &outlen, &overlapped)) {
logger(DEBUG_ALWAYS, LOG_ERR, "Error while writing to %s %s: %s", device_info, device, winerror(GetLastError())); logger(DEBUG_ALWAYS, LOG_ERR, "Error while writing to %s %s: %s", device_info, device, winerror(GetLastError()));
return false; return false;
} }

8
src/multicast_device.c
View file

@ -162,13 +162,13 @@ static void close_device(void) {
static bool read_packet(vpn_packet_t *packet) { static bool read_packet(vpn_packet_t *packet) {
int lenin; int lenin;
if((lenin = recv(device_fd, (void *)packet->data, MTU, 0)) <= 0) { if((lenin = recv(device_fd, DATA(packet), MTU, 0)) <= 0) {
logger(DEBUG_ALWAYS, LOG_ERR, "Error while reading from %s %s: %s", device_info, logger(DEBUG_ALWAYS, LOG_ERR, "Error while reading from %s %s: %s", device_info,
device, sockstrerror(sockerrno)); device, sockstrerror(sockerrno));
return false; return false;
} }
if(!memcmp(&ignore_src, packet->data + 6, sizeof ignore_src)) { if(!memcmp(&ignore_src, DATA(packet) + 6, sizeof ignore_src)) {
logger(DEBUG_SCARY_THINGS, LOG_DEBUG, "Ignoring loopback packet of %d bytes from %s", lenin, device_info); logger(DEBUG_SCARY_THINGS, LOG_DEBUG, "Ignoring loopback packet of %d bytes from %s", lenin, device_info);
return false; return false;
} }
@ -185,13 +185,13 @@ static bool write_packet(vpn_packet_t *packet) {
logger(DEBUG_TRAFFIC, LOG_DEBUG, "Writing packet of %d bytes to %s", logger(DEBUG_TRAFFIC, LOG_DEBUG, "Writing packet of %d bytes to %s",
packet->len, device_info); packet->len, device_info);
if(sendto(device_fd, (void *)packet->data, packet->len, 0, ai->ai_addr, ai->ai_addrlen) < 0) { if(sendto(device_fd, DATA(packet), packet->len, 0, ai->ai_addr, ai->ai_addrlen) < 0) {
logger(DEBUG_ALWAYS, LOG_ERR, "Can't write to %s %s: %s", device_info, device, logger(DEBUG_ALWAYS, LOG_ERR, "Can't write to %s %s: %s", device_info, device,
sockstrerror(sockerrno)); sockstrerror(sockerrno));
return false; return false;
} }
memcpy(&ignore_src, packet->data + 6, sizeof ignore_src); memcpy(&ignore_src, DATA(packet) + 6, sizeof ignore_src);
return true; return true;
} }

19
src/net.h
View file

@ -57,6 +57,7 @@ typedef struct node_id_t {
} node_id_t; } node_id_t;
typedef short length_t; typedef short length_t;
typedef uint32_t seqno_t;
#define AF_UNKNOWN 255 #define AF_UNKNOWN 255
@ -84,21 +85,19 @@ typedef union sockaddr_t {
#define SALEN(s) (s.sa_family==AF_INET?sizeof(struct sockaddr_in):sizeof(struct sockaddr_in6)) #define SALEN(s) (s.sa_family==AF_INET?sizeof(struct sockaddr_in):sizeof(struct sockaddr_in6))
#endif #endif
#define SEQNO(x) ((x)->data + (x)->offset - 4)
#define SRCID(x) ((node_id_t *)((x)->data + (x)->offset - 6))
#define DSTID(x) ((node_id_t *)((x)->data + (x)->offset - 12))
#define DATA(x) ((x)->data + (x)->offset)
#define DEFAULT_PACKET_OFFSET 12
typedef struct vpn_packet_t { typedef struct vpn_packet_t {
length_t len; /* the actual number of bytes in the `data' field */ length_t len; /* The actual number of valid bytes in the `data' field (including seqno or dstid/srcid) */
length_t offset; /* Offset in the buffer where the packet data starts (righter after seqno or dstid/srcid) */
int priority; /* priority or TOS */ int priority; /* priority or TOS */
uint32_t seqno; /* 32 bits sequence number (network byte order of course) */
uint8_t data[MAXSIZE]; uint8_t data[MAXSIZE];
} vpn_packet_t; } vpn_packet_t;
typedef struct sptps_packet_t {
length_t len; /* the actual number of bytes in the `data' field */
int priority; /* priority or TOS */
node_id_t dstid; /* node ID of the final recipient */
node_id_t srcid; /* node ID of the original sender */
char data[MAXSIZE];
} sptps_packet_t;
/* Packet types when using SPTPS */ /* Packet types when using SPTPS */
#define PKT_COMPRESSED 1 #define PKT_COMPRESSED 1

142
src/net_packet.c
View file

@ -139,8 +139,9 @@ static void send_mtu_probe_handler(void *data) {
len = 64; len = 64;
vpn_packet_t packet; vpn_packet_t packet;
memset(packet.data, 0, 14); packet.offset = DEFAULT_PACKET_OFFSET;
randomize(packet.data + 14, len - 14); memset(DATA(&packet), 0, 14);
randomize(DATA(&packet) + 14, len - 14);
packet.len = len; packet.len = len;
packet.priority = 0; packet.priority = 0;
n->status.send_locally = i >= 4 && n->mtuprobes <= 10 && n->prevedge; n->status.send_locally = i >= 4 && n->mtuprobes <= 10 && n->prevedge;
@ -176,24 +177,24 @@ void send_mtu_probe(node_t *n) {
} }
static void mtu_probe_h(node_t *n, vpn_packet_t *packet, length_t len) { static void mtu_probe_h(node_t *n, vpn_packet_t *packet, length_t len) {
if(!packet->data[0]) { if(!DATA(packet)[0]) {
logger(DEBUG_TRAFFIC, LOG_INFO, "Got MTU probe request %d from %s (%s)", packet->len, n->name, n->hostname); logger(DEBUG_TRAFFIC, LOG_INFO, "Got MTU probe request %d from %s (%s)", packet->len, n->name, n->hostname);
/* It's a probe request, send back a reply */ /* It's a probe request, send back a reply */
/* Type 2 probe replies were introduced in protocol 17.3 */ /* Type 2 probe replies were introduced in protocol 17.3 */
if ((n->options >> 24) >= 3) { if ((n->options >> 24) >= 3) {
uint8_t* data = packet->data; uint8_t *data = DATA(packet);
*data++ = 2; *data++ = 2;
uint16_t len16 = htons(len); memcpy(data, &len16, 2); data += 2; uint16_t len16 = htons(len); memcpy(data, &len16, 2); data += 2;
struct timeval now; struct timeval now;
gettimeofday(&now, NULL); gettimeofday(&now, NULL);
uint32_t sec = htonl(now.tv_sec); memcpy(data, &sec, 4); data += 4; uint32_t sec = htonl(now.tv_sec); memcpy(data, &sec, 4); data += 4;
uint32_t usec = htonl(now.tv_usec); memcpy(data, &usec, 4); data += 4; uint32_t usec = htonl(now.tv_usec); memcpy(data, &usec, 4); data += 4;
packet->len = data - packet->data; packet->len -= 10;
} else { } else {
/* Legacy protocol: n won't understand type 2 probe replies. */ /* Legacy protocol: n won't understand type 2 probe replies. */
packet->data[0] = 1; DATA(packet)[0] = 1;
} }
/* Temporarily set udp_confirmed, so that the reply is sent /* Temporarily set udp_confirmed, so that the reply is sent
@ -205,14 +206,14 @@ static void mtu_probe_h(node_t *n, vpn_packet_t *packet, length_t len) {
n->status.udp_confirmed = udp_confirmed; n->status.udp_confirmed = udp_confirmed;
} else { } else {
length_t probelen = len; length_t probelen = len;
if (packet->data[0] == 2) { if (DATA(packet)[0] == 2) {
if (len < 3) if (len < 3)
logger(DEBUG_TRAFFIC, LOG_WARNING, "Received invalid (too short) MTU probe reply from %s (%s)", n->name, n->hostname); logger(DEBUG_TRAFFIC, LOG_WARNING, "Received invalid (too short) MTU probe reply from %s (%s)", n->name, n->hostname);
else { else {
uint16_t probelen16; memcpy(&probelen16, packet->data + 1, 2); probelen = ntohs(probelen16); uint16_t probelen16; memcpy(&probelen16, DATA(packet) + 1, 2); probelen = ntohs(probelen16);
} }
} }
logger(DEBUG_TRAFFIC, LOG_INFO, "Got type %d MTU probe reply %d from %s (%s)", packet->data[0], probelen, n->name, n->hostname); logger(DEBUG_TRAFFIC, LOG_INFO, "Got type %d MTU probe reply %d from %s (%s)", DATA(packet)[0], probelen, n->name, n->hostname);
/* It's a valid reply: now we know bidirectional communication /* It's a valid reply: now we know bidirectional communication
is possible using the address and socket that the reply is possible using the address and socket that the reply
@ -254,9 +255,9 @@ static void mtu_probe_h(node_t *n, vpn_packet_t *packet, length_t len) {
timersub(&now, &n->probe_time, &diff); timersub(&now, &n->probe_time, &diff);
struct timeval probe_timestamp = now; struct timeval probe_timestamp = now;
if (packet->data[0] == 2 && packet->len >= 11) { if (DATA(packet)[0] == 2 && packet->len >= 11) {
uint32_t sec; memcpy(&sec, packet->data + 3, 4); uint32_t sec; memcpy(&sec, DATA(packet) + 3, 4);
uint32_t usec; memcpy(&usec, packet->data + 7, 4); uint32_t usec; memcpy(&usec, DATA(packet) + 7, 4);
probe_timestamp.tv_sec = ntohl(sec); probe_timestamp.tv_sec = ntohl(sec);
probe_timestamp.tv_usec = ntohl(usec); probe_timestamp.tv_usec = ntohl(usec);
} }
@ -348,12 +349,12 @@ static void receive_packet(node_t *n, vpn_packet_t *packet) {
static bool try_mac(node_t *n, const vpn_packet_t *inpkt) { static bool try_mac(node_t *n, const vpn_packet_t *inpkt) {
if(n->status.sptps) if(n->status.sptps)
return sptps_verify_datagram(&n->sptps, ((sptps_packet_t *)inpkt)->data, inpkt->len); return sptps_verify_datagram(&n->sptps, DATA(inpkt), inpkt->len);
if(!digest_active(n->indigest) || inpkt->len < sizeof inpkt->seqno + digest_length(n->indigest)) if(!digest_active(n->indigest) || inpkt->len < sizeof(seqno_t) + digest_length(n->indigest))
return false; return false;
return digest_verify(n->indigest, (const char *)&inpkt->seqno, inpkt->len - digest_length(n->indigest), (const char *)&inpkt->seqno + inpkt->len - digest_length(n->indigest)); return digest_verify(n->indigest, SEQNO(inpkt), inpkt->len - digest_length(n->indigest), DATA(inpkt) + inpkt->len - digest_length(n->indigest));
} }
static bool receive_udppacket(node_t *n, vpn_packet_t *inpkt) { static bool receive_udppacket(node_t *n, vpn_packet_t *inpkt) {
@ -361,6 +362,8 @@ static bool receive_udppacket(node_t *n, vpn_packet_t *inpkt) {
vpn_packet_t *pkt[] = { &pkt1, &pkt2, &pkt1, &pkt2 }; vpn_packet_t *pkt[] = { &pkt1, &pkt2, &pkt1, &pkt2 };
int nextpkt = 0; int nextpkt = 0;
size_t outlen; size_t outlen;
pkt1.offset = DEFAULT_PACKET_OFFSET;
pkt2.offset = DEFAULT_PACKET_OFFSET;
if(n->status.sptps) { if(n->status.sptps) {
if(!n->sptps.state) { if(!n->sptps.state) {
@ -372,7 +375,8 @@ static bool receive_udppacket(node_t *n, vpn_packet_t *inpkt) {
} }
return false; return false;
} }
if(!sptps_receive_data(&n->sptps, ((sptps_packet_t *)inpkt)->data, inpkt->len)) { inpkt->offset += 2 * sizeof(node_id_t);
if(!sptps_receive_data(&n->sptps, DATA(inpkt), inpkt->len - 2 * sizeof(node_id_t))) {
logger(DEBUG_TRAFFIC, LOG_ERR, "Got bad packet from %s (%s)", n->name, n->hostname); logger(DEBUG_TRAFFIC, LOG_ERR, "Got bad packet from %s (%s)", n->name, n->hostname);
return false; return false;
} }
@ -386,17 +390,21 @@ static bool receive_udppacket(node_t *n, vpn_packet_t *inpkt) {
/* Check packet length */ /* Check packet length */
if(inpkt->len < sizeof inpkt->seqno + digest_length(n->indigest)) { if(inpkt->len < sizeof(seqno_t) + digest_length(n->indigest)) {
logger(DEBUG_TRAFFIC, LOG_DEBUG, "Got too short packet from %s (%s)", logger(DEBUG_TRAFFIC, LOG_DEBUG, "Got too short packet from %s (%s)",
n->name, n->hostname); n->name, n->hostname);
return false; return false;
} }
/* It's a legacy UDP packet, the data starts after the seqno */
inpkt->offset += sizeof(seqno_t);
/* Check the message authentication code */ /* Check the message authentication code */
if(digest_active(n->indigest)) { if(digest_active(n->indigest)) {
inpkt->len -= digest_length(n->indigest); inpkt->len -= digest_length(n->indigest);
if(!digest_verify(n->indigest, &inpkt->seqno, inpkt->len, (const char *)&inpkt->seqno + inpkt->len)) { if(!digest_verify(n->indigest, SEQNO(inpkt), inpkt->len, SEQNO(inpkt) + inpkt->len)) {
logger(DEBUG_TRAFFIC, LOG_DEBUG, "Got unauthenticated packet from %s (%s)", n->name, n->hostname); logger(DEBUG_TRAFFIC, LOG_DEBUG, "Got unauthenticated packet from %s (%s)", n->name, n->hostname);
return false; return false;
} }
@ -407,7 +415,7 @@ static bool receive_udppacket(node_t *n, vpn_packet_t *inpkt) {
vpn_packet_t *outpkt = pkt[nextpkt++]; vpn_packet_t *outpkt = pkt[nextpkt++];
outlen = MAXSIZE; outlen = MAXSIZE;
if(!cipher_decrypt(n->incipher, &inpkt->seqno, inpkt->len, &outpkt->seqno, &outlen, true)) { if(!cipher_decrypt(n->incipher, SEQNO(inpkt), inpkt->len, SEQNO(outpkt), &outlen, true)) {
logger(DEBUG_TRAFFIC, LOG_DEBUG, "Error decrypting packet from %s (%s)", n->name, n->hostname); logger(DEBUG_TRAFFIC, LOG_DEBUG, "Error decrypting packet from %s (%s)", n->name, n->hostname);
return false; return false;
} }
@ -418,8 +426,10 @@ static bool receive_udppacket(node_t *n, vpn_packet_t *inpkt) {
/* Check the sequence number */ /* Check the sequence number */
inpkt->len -= sizeof inpkt->seqno; seqno_t seqno;
uint32_t seqno = ntohl(inpkt->seqno); memcpy(&seqno, SEQNO(inpkt), sizeof seqno);
seqno = ntohl(seqno);
inpkt->len -= sizeof seqno;
if(replaywin) { if(replaywin) {
if(seqno != n->received_seqno + 1) { if(seqno != n->received_seqno + 1) {
@ -463,7 +473,7 @@ static bool receive_udppacket(node_t *n, vpn_packet_t *inpkt) {
if(n->incompression) { if(n->incompression) {
vpn_packet_t *outpkt = pkt[nextpkt++]; vpn_packet_t *outpkt = pkt[nextpkt++];
if((outpkt->len = uncompress_packet(outpkt->data, inpkt->data, inpkt->len, n->incompression)) < 0) { if((outpkt->len = uncompress_packet(DATA(outpkt), DATA(inpkt), inpkt->len, n->incompression)) < 0) {
logger(DEBUG_TRAFFIC, LOG_ERR, "Error while uncompressing packet from %s (%s)", logger(DEBUG_TRAFFIC, LOG_ERR, "Error while uncompressing packet from %s (%s)",
n->name, n->hostname); n->name, n->hostname);
return false; return false;
@ -476,7 +486,7 @@ static bool receive_udppacket(node_t *n, vpn_packet_t *inpkt) {
inpkt->priority = 0; inpkt->priority = 0;
if(!inpkt->data[12] && !inpkt->data[13]) if(!DATA(inpkt)[12] && !DATA(inpkt)[13])
mtu_probe_h(n, inpkt, origlen); mtu_probe_h(n, inpkt, origlen);
else else
receive_packet(n, inpkt); receive_packet(n, inpkt);
@ -485,8 +495,9 @@ static bool receive_udppacket(node_t *n, vpn_packet_t *inpkt) {
void receive_tcppacket(connection_t *c, const char *buffer, int len) { void receive_tcppacket(connection_t *c, const char *buffer, int len) {
vpn_packet_t outpkt; vpn_packet_t outpkt;
outpkt.offset = DEFAULT_PACKET_OFFSET;
if(len > sizeof outpkt.data) if(len > sizeof outpkt.data - outpkt.offset)
return; return;
outpkt.len = len; outpkt.len = len;
@ -494,7 +505,7 @@ void receive_tcppacket(connection_t *c, const char *buffer, int len) {
outpkt.priority = 0; outpkt.priority = 0;
else else
outpkt.priority = -1; outpkt.priority = -1;
memcpy(outpkt.data, buffer, len); memcpy(DATA(&outpkt), buffer, len);
receive_packet(c->node, &outpkt); receive_packet(c->node, &outpkt);
} }
@ -524,8 +535,8 @@ static void send_sptps_packet(node_t *n, vpn_packet_t *origpkt) {
uint8_t type = 0; uint8_t type = 0;
int offset = 0; int offset = 0;
if(!(origpkt->data[12] | origpkt->data[13])) { if(!(DATA(origpkt)[12] | DATA(origpkt)[13])) {
sptps_send_record(&n->sptps, PKT_PROBE, (char *)origpkt->data, origpkt->len); sptps_send_record(&n->sptps, PKT_PROBE, (char *)DATA(origpkt), origpkt->len);
return; return;
} }
@ -540,7 +551,8 @@ static void send_sptps_packet(node_t *n, vpn_packet_t *origpkt) {
vpn_packet_t outpkt; vpn_packet_t outpkt;
if(n->outcompression) { if(n->outcompression) {
int len = compress_packet(outpkt.data + offset, origpkt->data + offset, origpkt->len - offset, n->outcompression); outpkt.offset = 0;
int len = compress_packet(DATA(&outpkt) + offset, DATA(origpkt) + offset, origpkt->len - offset, n->outcompression);
if(len < 0) { if(len < 0) {
logger(DEBUG_TRAFFIC, LOG_ERR, "Error while compressing packet to %s (%s)", n->name, n->hostname); logger(DEBUG_TRAFFIC, LOG_ERR, "Error while compressing packet to %s (%s)", n->name, n->hostname);
} else if(len < origpkt->len - offset) { } else if(len < origpkt->len - offset) {
@ -550,7 +562,7 @@ static void send_sptps_packet(node_t *n, vpn_packet_t *origpkt) {
} }
} }
sptps_send_record(&n->sptps, type, (char *)origpkt->data + offset, origpkt->len - offset); sptps_send_record(&n->sptps, type, DATA(origpkt) + offset, origpkt->len - offset);
return; return;
} }
@ -643,6 +655,9 @@ static void send_udppacket(node_t *n, vpn_packet_t *origpkt) {
int origpriority = origpkt->priority; int origpriority = origpkt->priority;
#endif #endif
pkt1.offset = DEFAULT_PACKET_OFFSET;
pkt2.offset = DEFAULT_PACKET_OFFSET;
if(!n->status.reachable) { if(!n->status.reachable) {
logger(DEBUG_TRAFFIC, LOG_INFO, "Trying to send UDP packet to unreachable node %s (%s)", n->name, n->hostname); logger(DEBUG_TRAFFIC, LOG_INFO, "Trying to send UDP packet to unreachable node %s (%s)", n->name, n->hostname);
return; return;
@ -668,7 +683,7 @@ static void send_udppacket(node_t *n, vpn_packet_t *origpkt) {
return; return;
} }
if(n->options & OPTION_PMTU_DISCOVERY && inpkt->len > n->minmtu && (inpkt->data[12] | inpkt->data[13])) { if(n->options & OPTION_PMTU_DISCOVERY && inpkt->len > n->minmtu && (DATA(inpkt)[12] | DATA(inpkt)[13])) {
logger(DEBUG_TRAFFIC, LOG_INFO, logger(DEBUG_TRAFFIC, LOG_INFO,
"Packet for %s (%s) larger than minimum MTU, forwarding via %s", "Packet for %s (%s) larger than minimum MTU, forwarding via %s",
n->name, n->hostname, n != n->nexthop ? n->nexthop->name : "TCP"); n->name, n->hostname, n != n->nexthop ? n->nexthop->name : "TCP");
@ -686,7 +701,7 @@ static void send_udppacket(node_t *n, vpn_packet_t *origpkt) {
if(n->outcompression) { if(n->outcompression) {
outpkt = pkt[nextpkt++]; outpkt = pkt[nextpkt++];
if((outpkt->len = compress_packet(outpkt->data, inpkt->data, inpkt->len, n->outcompression)) < 0) { if((outpkt->len = compress_packet(DATA(outpkt), DATA(inpkt), inpkt->len, n->outcompression)) < 0) {
logger(DEBUG_TRAFFIC, LOG_ERR, "Error while compressing packet to %s (%s)", logger(DEBUG_TRAFFIC, LOG_ERR, "Error while compressing packet to %s (%s)",
n->name, n->hostname); n->name, n->hostname);
return; return;
@ -697,8 +712,9 @@ static void send_udppacket(node_t *n, vpn_packet_t *origpkt) {
/* Add sequence number */ /* Add sequence number */
inpkt->seqno = htonl(++(n->sent_seqno)); seqno_t seqno = htonl(++(n->sent_seqno));
inpkt->len += sizeof inpkt->seqno; memcpy(SEQNO(inpkt), &seqno, sizeof seqno);
inpkt->len += sizeof seqno;
/* Encrypt the packet */ /* Encrypt the packet */
@ -706,7 +722,7 @@ static void send_udppacket(node_t *n, vpn_packet_t *origpkt) {
outpkt = pkt[nextpkt++]; outpkt = pkt[nextpkt++];
outlen = MAXSIZE; outlen = MAXSIZE;
if(!cipher_encrypt(n->outcipher, &inpkt->seqno, inpkt->len, &outpkt->seqno, &outlen, true)) { if(!cipher_encrypt(n->outcipher, SEQNO(inpkt), inpkt->len, SEQNO(outpkt), &outlen, true)) {
logger(DEBUG_TRAFFIC, LOG_ERR, "Error while encrypting packet to %s (%s)", n->name, n->hostname); logger(DEBUG_TRAFFIC, LOG_ERR, "Error while encrypting packet to %s (%s)", n->name, n->hostname);
goto end; goto end;
} }
@ -718,7 +734,7 @@ static void send_udppacket(node_t *n, vpn_packet_t *origpkt) {
/* Add the message authentication code */ /* Add the message authentication code */
if(digest_active(n->outdigest)) { if(digest_active(n->outdigest)) {
if(!digest_create(n->outdigest, &inpkt->seqno, inpkt->len, &inpkt->seqno + inpkt->len)) { if(!digest_create(n->outdigest, SEQNO(inpkt), inpkt->len, SEQNO(inpkt) + inpkt->len)) {
logger(DEBUG_TRAFFIC, LOG_ERR, "Error while encrypting packet to %s (%s)", n->name, n->hostname); logger(DEBUG_TRAFFIC, LOG_ERR, "Error while encrypting packet to %s (%s)", n->name, n->hostname);
goto end; goto end;
} }
@ -746,7 +762,7 @@ static void send_udppacket(node_t *n, vpn_packet_t *origpkt) {
} }
#endif #endif
if(sendto(listen_socket[sock].udp.fd, &inpkt->seqno, inpkt->len, 0, &sa->sa, SALEN(sa->sa)) < 0 && !sockwouldblock(sockerrno)) { if(sendto(listen_socket[sock].udp.fd, SEQNO(inpkt), inpkt->len, 0, &sa->sa, SALEN(sa->sa)) < 0 && !sockwouldblock(sockerrno)) {
if(sockmsgsize(sockerrno)) { if(sockmsgsize(sockerrno)) {
if(n->maxmtu >= origlen) if(n->maxmtu >= origlen)
n->maxmtu = origlen - 1; n->maxmtu = origlen - 1;
@ -828,11 +844,11 @@ static bool send_sptps_data_priv(node_t *to, node_t *from, int type, const void
return true; return true;
} }
bool send_sptps_data(void *handle, uint8_t type, const char *data, size_t len) { bool send_sptps_data(void *handle, uint8_t type, const void *data, size_t len) {
return send_sptps_data_priv(handle, myself, type, data, len); return send_sptps_data_priv(handle, myself, type, data, len);
} }
bool receive_sptps_record(void *handle, uint8_t type, const char *data, uint16_t len) { bool receive_sptps_record(void *handle, uint8_t type, const void *data, uint16_t len) {
node_t *from = handle; node_t *from = handle;
if(type == SPTPS_HANDSHAKE) { if(type == SPTPS_HANDSHAKE) {
@ -850,10 +866,11 @@ bool receive_sptps_record(void *handle, uint8_t type, const char *data, uint16_t
} }
vpn_packet_t inpkt; vpn_packet_t inpkt;
inpkt.offset = DEFAULT_PACKET_OFFSET;
if(type == PKT_PROBE) { if(type == PKT_PROBE) {
inpkt.len = len; inpkt.len = len;
memcpy(inpkt.data, data, len); memcpy(DATA(&inpkt), data, len);
mtu_probe_h(from, &inpkt, len); mtu_probe_h(from, &inpkt, len);
return true; return true;
} }
@ -873,7 +890,7 @@ bool receive_sptps_record(void *handle, uint8_t type, const char *data, uint16_t
int offset = (type & PKT_MAC) ? 0 : 14; int offset = (type & PKT_MAC) ? 0 : 14;
if(type & PKT_COMPRESSED) { if(type & PKT_COMPRESSED) {
length_t ulen = uncompress_packet(inpkt.data + offset, (const uint8_t *)data, len, from->incompression); length_t ulen = uncompress_packet(DATA(&inpkt) + offset, (const uint8_t *)data, len, from->incompression);
if(ulen < 0) { if(ulen < 0) {
return false; return false;
} else { } else {
@ -882,25 +899,25 @@ bool receive_sptps_record(void *handle, uint8_t type, const char *data, uint16_t
if(inpkt.len > MAXSIZE) if(inpkt.len > MAXSIZE)
abort(); abort();
} else { } else {
memcpy(inpkt.data + offset, data, len); memcpy(DATA(&inpkt) + offset, data, len);
inpkt.len = len + offset; inpkt.len = len + offset;
} }
/* Generate the Ethernet packet type if necessary */ /* Generate the Ethernet packet type if necessary */
if(offset) { if(offset) {
switch(inpkt.data[14] >> 4) { switch(DATA(&inpkt)[14] >> 4) {
case 4: case 4:
inpkt.data[12] = 0x08; DATA(&inpkt)[12] = 0x08;
inpkt.data[13] = 0x00; DATA(&inpkt)[13] = 0x00;
break; break;
case 6: case 6:
inpkt.data[12] = 0x86; DATA(&inpkt)[12] = 0x86;
inpkt.data[13] = 0xDD; DATA(&inpkt)[13] = 0xDD;
break; break;
default: default:
logger(DEBUG_TRAFFIC, LOG_ERR, logger(DEBUG_TRAFFIC, LOG_ERR,
"Unknown IP version %d while reading packet from %s (%s)", "Unknown IP version %d while reading packet from %s (%s)",
inpkt.data[14] >> 4, from->name, from->hostname); DATA(&inpkt)[14] >> 4, from->name, from->hostname);
return false; return false;
} }
} }
@ -917,7 +934,7 @@ void send_packet(node_t *n, vpn_packet_t *packet) {
if(n == myself) { if(n == myself) {
if(overwrite_mac) if(overwrite_mac)
memcpy(packet->data, mymac.x, ETH_ALEN); memcpy(DATA(packet), mymac.x, ETH_ALEN);
n->out_packets++; n->out_packets++;
n->out_bytes += packet->len; n->out_bytes += packet->len;
devops.write(packet); devops.write(packet);
@ -1028,7 +1045,6 @@ static node_t *try_harder(const sockaddr_t *from, const vpn_packet_t *pkt) {
void handle_incoming_vpn_data(void *data, int flags) { void handle_incoming_vpn_data(void *data, int flags) {
listen_socket_t *ls = data; listen_socket_t *ls = data;
vpn_packet_t pkt; vpn_packet_t pkt;
sptps_packet_t *spkt = (sptps_packet_t *)&pkt;
char *hostname; char *hostname;
node_id_t nullid = {}; node_id_t nullid = {};
sockaddr_t addr = {}; sockaddr_t addr = {};
@ -1036,7 +1052,8 @@ void handle_incoming_vpn_data(void *data, int flags) {
node_t *from, *to; node_t *from, *to;
bool direct = false; bool direct = false;
int len = recvfrom(ls->udp.fd, &pkt.seqno, MAXSIZE, 0, &addr.sa, &addrlen); pkt.offset = 0;
int len = recvfrom(ls->udp.fd, DATA(&pkt), MAXSIZE, 0, &addr.sa, &addrlen);
if(len <= 0 || len > MAXSIZE) { if(len <= 0 || len > MAXSIZE) {
if(!sockwouldblock(sockerrno)) if(!sockwouldblock(sockerrno))
@ -1054,17 +1071,20 @@ void handle_incoming_vpn_data(void *data, int flags) {
if(!n) { if(!n) {
// It might be from a 1.1 node, which might have a source ID in the packet. // It might be from a 1.1 node, which might have a source ID in the packet.
from = lookup_node_id(&spkt->srcid); pkt.offset = 2 * sizeof(node_id_t);
if(from && !memcmp(&spkt->dstid, &nullid, sizeof nullid) && from->status.sptps) { from = lookup_node_id(SRCID(&pkt));
if(sptps_verify_datagram(&from->sptps, spkt->data, spkt->len - sizeof(spkt->srcid) - sizeof(spkt->dstid))) if(from && !memcmp(DSTID(&pkt), &nullid, sizeof nullid) && from->status.sptps) {
if(sptps_verify_datagram(&from->sptps, DATA(&pkt), pkt.len - 2 * sizeof(node_id_t)))
n = from; n = from;
else else
goto skip_harder; goto skip_harder;
} }
} }
if(!n) if(!n) {
pkt.offset = 0;
n = try_harder(&addr, &pkt); n = try_harder(&addr, &pkt);
}
skip_harder: skip_harder:
if(!n) { if(!n) {
@ -1077,22 +1097,23 @@ skip_harder:
} }
if(n->status.sptps) { if(n->status.sptps) {
if(!memcmp(&spkt->dstid, &nullid, sizeof nullid)) { pkt.offset = 2 * sizeof(node_id_t);
if(!memcmp(DSTID(&pkt), &nullid, sizeof nullid)) {
direct = true; direct = true;
from = n; from = n;
to = myself; to = myself;
} else { } else {
from = lookup_node_id(&spkt->srcid); from = lookup_node_id(SRCID(&pkt));
to = lookup_node_id(&spkt->dstid); to = lookup_node_id(DSTID(&pkt));
} }
if(!from || !to) { if(!from || !to) {
logger(DEBUG_PROTOCOL, LOG_WARNING, "Received UDP packet from %s (%s) with unknown source and/or destination ID", n->name, n->hostname); logger(DEBUG_PROTOCOL, LOG_WARNING, "Received UDP packet from %s (%s) with unknown source and/or destination ID", n->name, n->hostname);
return; return;
} }
spkt->len -= sizeof spkt->dstid + sizeof spkt->srcid;
if(to != myself) { if(to != myself) {
send_sptps_data_priv(to, n, 0, spkt->data, spkt->len); send_sptps_data_priv(to, n, 0, DATA(&pkt), pkt.len - 2 * sizeof(node_id_t));
return; return;
} }
} else { } else {
@ -1100,6 +1121,7 @@ skip_harder:
from = n; from = n;
} }
pkt.offset = 0;
if(!receive_udppacket(from, &pkt)) if(!receive_udppacket(from, &pkt))
return; return;
@ -1110,7 +1132,7 @@ skip_harder:
void handle_device_data(void *data, int flags) { void handle_device_data(void *data, int flags) {
vpn_packet_t packet; vpn_packet_t packet;
packet.offset = DEFAULT_PACKET_OFFSET;
packet.priority = 0; packet.priority = 0;
if(devops.read(&packet)) { if(devops.read(&packet)) {

8
src/protocol_auth.c
View file

@ -421,7 +421,7 @@ bool send_metakey(connection_t *c) {
if(!(c->outdigest = digest_open_sha1(-1))) if(!(c->outdigest = digest_open_sha1(-1)))
return false; return false;
size_t len = rsa_size(c->rsa); const size_t len = rsa_size(c->rsa);
char key[len]; char key[len];
char enckey[len]; char enckey[len];
char hexkey[2 * len + 1]; char hexkey[2 * len + 1];
@ -480,7 +480,7 @@ bool send_metakey(connection_t *c) {
bool metakey_h(connection_t *c, const char *request) { bool metakey_h(connection_t *c, const char *request) {
char hexkey[MAX_STRING_SIZE]; char hexkey[MAX_STRING_SIZE];
int cipher, digest, maclength, compression; int cipher, digest, maclength, compression;
size_t len = rsa_size(myself->connection->rsa); const size_t len = rsa_size(myself->connection->rsa);
char enckey[len]; char enckey[len];
char key[len]; char key[len];
@ -540,7 +540,7 @@ bool metakey_h(connection_t *c, const char *request) {
} }
bool send_challenge(connection_t *c) { bool send_challenge(connection_t *c) {
size_t len = rsa_size(c->rsa); const size_t len = rsa_size(c->rsa);
char buffer[len * 2 + 1]; char buffer[len * 2 + 1];
if(!c->hischallenge) if(!c->hischallenge)
@ -561,7 +561,7 @@ bool send_challenge(connection_t *c) {
bool challenge_h(connection_t *c, const char *request) { bool challenge_h(connection_t *c, const char *request) {
char buffer[MAX_STRING_SIZE]; char buffer[MAX_STRING_SIZE];
size_t len = rsa_size(myself->connection->rsa); const size_t len = rsa_size(myself->connection->rsa);
size_t digestlen = digest_length(c->indigest); size_t digestlen = digest_length(c->indigest);
char digest[digestlen]; char digest[digestlen];

2
src/protocol_misc.c
View file

@ -131,7 +131,7 @@ bool send_tcppacket(connection_t *c, const vpn_packet_t *packet) {
if(!send_request(c, "%d %hd", PACKET, packet->len)) if(!send_request(c, "%d %hd", PACKET, packet->len))
return false; return false;
return send_meta(c, (char *)packet->data, packet->len); return send_meta(c, (char *)DATA(packet), packet->len);
} }
bool tcppacket_h(connection_t *c, const char *request) { bool tcppacket_h(connection_t *c, const char *request) {

4
src/raw_socket_device.c
View file

@ -93,7 +93,7 @@ static void close_device(void) {
static bool read_packet(vpn_packet_t *packet) { static bool read_packet(vpn_packet_t *packet) {
int inlen; int inlen;
if((inlen = read(device_fd, packet->data, MTU)) <= 0) { if((inlen = read(device_fd, DATA(packet), MTU)) <= 0) {
logger(DEBUG_ALWAYS, LOG_ERR, "Error while reading from %s %s: %s", device_info, logger(DEBUG_ALWAYS, LOG_ERR, "Error while reading from %s %s: %s", device_info,
device, strerror(errno)); device, strerror(errno));
return false; return false;
@ -111,7 +111,7 @@ static bool write_packet(vpn_packet_t *packet) {
logger(DEBUG_TRAFFIC, LOG_DEBUG, "Writing packet of %d bytes to %s", logger(DEBUG_TRAFFIC, LOG_DEBUG, "Writing packet of %d bytes to %s",
packet->len, device_info); packet->len, device_info);
if(write(device_fd, packet->data, packet->len) < 0) { if(write(device_fd, DATA(packet), packet->len) < 0) {
logger(DEBUG_ALWAYS, LOG_ERR, "Can't write to %s %s: %s", device_info, device, logger(DEBUG_ALWAYS, LOG_ERR, "Can't write to %s %s: %s", device_info, device,
strerror(errno)); strerror(errno));
return false; return false;

163
src/route.c
View file

@ -115,16 +115,16 @@ static void clamp_mss(const node_t *source, const node_t *via, vpn_packet_t *pac
/* Find TCP header */ /* Find TCP header */
int start = ether_size; int start = ether_size;
uint16_t type = packet->data[12] << 8 | packet->data[13]; uint16_t type = DATA(packet)[12] << 8 | DATA(packet)[13];
if(type == ETH_P_8021Q) { if(type == ETH_P_8021Q) {
start += 4; start += 4;
type = packet->data[16] << 8 | packet->data[17]; type = DATA(packet)[16] << 8 | DATA(packet)[17];
} }
if(type == ETH_P_IP && packet->data[start + 9] == 6) if(type == ETH_P_IP && DATA(packet)[start + 9] == 6)
start += (packet->data[start] & 0xf) * 4; start += (DATA(packet)[start] & 0xf) * 4;
else if(type == ETH_P_IPV6 && packet->data[start + 6] == 6) else if(type == ETH_P_IPV6 && DATA(packet)[start + 6] == 6)
start += 40; start += 40;
else else
return; return;
@ -133,38 +133,38 @@ static void clamp_mss(const node_t *source, const node_t *via, vpn_packet_t *pac
return; return;
/* Use data offset field to calculate length of options field */ /* Use data offset field to calculate length of options field */
int len = ((packet->data[start + 12] >> 4) - 5) * 4; int len = ((DATA(packet)[start + 12] >> 4) - 5) * 4;
if(packet->len < start + 20 + len) if(packet->len < start + 20 + len)
return; return;
/* Search for MSS option header */ /* Search for MSS option header */
for(int i = 0; i < len;) { for(int i = 0; i < len;) {
if(packet->data[start + 20 + i] == 0) if(DATA(packet)[start + 20 + i] == 0)
break; break;
if(packet->data[start + 20 + i] == 1) { if(DATA(packet)[start + 20 + i] == 1) {
i++; i++;
continue; continue;
} }
if(i > len - 2 || i > len - packet->data[start + 21 + i]) if(i > len - 2 || i > len - DATA(packet)[start + 21 + i])
break; break;
if(packet->data[start + 20 + i] != 2) { if(DATA(packet)[start + 20 + i] != 2) {
if(packet->data[start + 21 + i] < 2) if(DATA(packet)[start + 21 + i] < 2)
break; break;
i += packet->data[start + 21 + i]; i += DATA(packet)[start + 21 + i];
continue; continue;
} }
if(packet->data[start + 21] != 4) if(DATA(packet)[start + 21] != 4)
break; break;
/* Found it */ /* Found it */
uint16_t oldmss = packet->data[start + 22 + i] << 8 | packet->data[start + 23 + i]; uint16_t oldmss = DATA(packet)[start + 22 + i] << 8 | DATA(packet)[start + 23 + i];
uint16_t newmss = mtu - start - 20; uint16_t newmss = mtu - start - 20;
uint16_t csum = packet->data[start + 16] << 8 | packet->data[start + 17]; uint16_t csum = DATA(packet)[start + 16] << 8 | DATA(packet)[start + 17];
if(oldmss <= newmss) if(oldmss <= newmss)
break; break;
@ -172,23 +172,23 @@ static void clamp_mss(const node_t *source, const node_t *via, vpn_packet_t *pac
logger(DEBUG_TRAFFIC, LOG_INFO, "Clamping MSS of packet from %s to %s to %d", source->name, via->name, newmss); logger(DEBUG_TRAFFIC, LOG_INFO, "Clamping MSS of packet from %s to %s to %d", source->name, via->name, newmss);
/* Update the MSS value and the checksum */ /* Update the MSS value and the checksum */
packet->data[start + 22 + i] = newmss >> 8; DATA(packet)[start + 22 + i] = newmss >> 8;
packet->data[start + 23 + i] = newmss & 0xff; DATA(packet)[start + 23 + i] = newmss & 0xff;
csum ^= 0xffff; csum ^= 0xffff;
csum -= oldmss; csum -= oldmss;
csum += newmss; csum += newmss;
csum ^= 0xffff; csum ^= 0xffff;
packet->data[start + 16] = csum >> 8; DATA(packet)[start + 16] = csum >> 8;
packet->data[start + 17] = csum & 0xff; DATA(packet)[start + 17] = csum & 0xff;
break; break;
} }
} }
static void swap_mac_addresses(vpn_packet_t *packet) { static void swap_mac_addresses(vpn_packet_t *packet) {
mac_t tmp; mac_t tmp;
memcpy(&tmp, &packet->data[0], sizeof tmp); memcpy(&tmp, &DATA(packet)[0], sizeof tmp);
memcpy(&packet->data[0], &packet->data[6], sizeof tmp); memcpy(&DATA(packet)[0], &DATA(packet)[6], sizeof tmp);
memcpy(&packet->data[6], &tmp, sizeof tmp); memcpy(&DATA(packet)[6], &tmp, sizeof tmp);
} }
static void age_subnets(void *data) { static void age_subnets(void *data) {
@ -267,7 +267,7 @@ static void route_ipv4_unreachable(node_t *source, vpn_packet_t *packet, length_
/* Copy headers from packet into properly aligned structs on the stack */ /* Copy headers from packet into properly aligned structs on the stack */
memcpy(&ip, packet->data + ether_size, ip_size); memcpy(&ip, DATA(packet) + ether_size, ip_size);
/* Remember original source and destination */ /* Remember original source and destination */
@ -284,7 +284,7 @@ static void route_ipv4_unreachable(node_t *source, vpn_packet_t *packet, length_
/* Copy first part of original contents to ICMP message */ /* Copy first part of original contents to ICMP message */
memmove(packet->data + ether_size + ip_size + icmp_size, packet->data + ether_size, oldlen); memmove(DATA(packet) + ether_size + ip_size + icmp_size, DATA(packet) + ether_size, oldlen);
/* Fill in IPv4 header */ /* Fill in IPv4 header */
@ -309,12 +309,12 @@ static void route_ipv4_unreachable(node_t *source, vpn_packet_t *packet, length_
icmp.icmp_cksum = 0; icmp.icmp_cksum = 0;
icmp.icmp_cksum = inet_checksum(&icmp, icmp_size, ~0); icmp.icmp_cksum = inet_checksum(&icmp, icmp_size, ~0);
icmp.icmp_cksum = inet_checksum(packet->data + ether_size + ip_size + icmp_size, oldlen, icmp.icmp_cksum); icmp.icmp_cksum = inet_checksum(DATA(packet) + ether_size + ip_size + icmp_size, oldlen, icmp.icmp_cksum);
/* Copy structs on stack back to packet */ /* Copy structs on stack back to packet */
memcpy(packet->data + ether_size, &ip, ip_size); memcpy(DATA(packet) + ether_size, &ip, ip_size);
memcpy(packet->data + ether_size + ip_size, &icmp, icmp_size); memcpy(DATA(packet) + ether_size + ip_size, &icmp, icmp_size);
packet->len = ether_size + ip_size + icmp_size + oldlen; packet->len = ether_size + ip_size + icmp_size + oldlen;
@ -330,8 +330,9 @@ static void fragment_ipv4_packet(node_t *dest, vpn_packet_t *packet, length_t et
uint8_t *offset; uint8_t *offset;
uint16_t ip_off, origf; uint16_t ip_off, origf;
memcpy(&ip, packet->data + ether_size, ip_size); memcpy(&ip, DATA(packet) + ether_size, ip_size);
fragment.priority = packet->priority; fragment.priority = packet->priority;
fragment.offset = DEFAULT_PACKET_OFFSET;
if(ip.ip_hl != ip_size / 4) if(ip.ip_hl != ip_size / 4)
return; return;
@ -345,7 +346,7 @@ static void fragment_ipv4_packet(node_t *dest, vpn_packet_t *packet, length_t et
logger(DEBUG_TRAFFIC, LOG_INFO, "Fragmenting packet of %d bytes to %s (%s)", packet->len, dest->name, dest->hostname); logger(DEBUG_TRAFFIC, LOG_INFO, "Fragmenting packet of %d bytes to %s (%s)", packet->len, dest->name, dest->hostname);
offset = packet->data + ether_size + ip_size; offset = DATA(packet) + ether_size + ip_size;
maxlen = (dest->mtu - ether_size - ip_size) & ~0x7; maxlen = (dest->mtu - ether_size - ip_size) & ~0x7;
ip_off = ntohs(ip.ip_off); ip_off = ntohs(ip.ip_off);
origf = ip_off & ~IP_OFFMASK; origf = ip_off & ~IP_OFFMASK;
@ -353,7 +354,7 @@ static void fragment_ipv4_packet(node_t *dest, vpn_packet_t *packet, length_t et
while(todo) { while(todo) {
len = todo > maxlen ? maxlen : todo; len = todo > maxlen ? maxlen : todo;
memcpy(fragment.data + ether_size + ip_size, offset, len); memcpy(DATA(&fragment) + ether_size + ip_size, offset, len);
todo -= len; todo -= len;
offset += len; offset += len;
@ -361,8 +362,8 @@ static void fragment_ipv4_packet(node_t *dest, vpn_packet_t *packet, length_t et
ip.ip_off = htons(ip_off | origf | (todo ? IP_MF : 0)); ip.ip_off = htons(ip_off | origf | (todo ? IP_MF : 0));
ip.ip_sum = 0; ip.ip_sum = 0;
ip.ip_sum = inet_checksum(&ip, ip_size, ~0); ip.ip_sum = inet_checksum(&ip, ip_size, ~0);
memcpy(fragment.data, packet->data, ether_size); memcpy(DATA(&fragment), DATA(packet), ether_size);
memcpy(fragment.data + ether_size, &ip, ip_size); memcpy(DATA(&fragment) + ether_size, &ip, ip_size);
fragment.len = ether_size + ip_size + len; fragment.len = ether_size + ip_size + len;
send_packet(dest, &fragment); send_packet(dest, &fragment);
@ -379,7 +380,7 @@ static void route_ipv4(node_t *source, vpn_packet_t *packet) {
node_t *via; node_t *via;
ipv4_t dest; ipv4_t dest;
memcpy(&dest, &packet->data[30], sizeof dest); memcpy(&dest, &DATA(packet)[30], sizeof dest);
subnet = lookup_subnet_ipv4(&dest); subnet = lookup_subnet_ipv4(&dest);
if(!subnet) { if(!subnet) {
@ -411,7 +412,7 @@ static void route_ipv4(node_t *source, vpn_packet_t *packet) {
return route_ipv4_unreachable(source, packet, ether_size, ICMP_DEST_UNREACH, ICMP_NET_ANO); return route_ipv4_unreachable(source, packet, ether_size, ICMP_DEST_UNREACH, ICMP_NET_ANO);
if(priorityinheritance) if(priorityinheritance)
packet->priority = packet->data[15]; packet->priority = DATA(packet)[15];
via = (subnet->owner->via == myself) ? subnet->owner->nexthop : subnet->owner->via; via = (subnet->owner->via == myself) ? subnet->owner->nexthop : subnet->owner->via;
@ -425,7 +426,7 @@ static void route_ipv4(node_t *source, vpn_packet_t *packet) {
if(via && packet->len > MAX(via->mtu, 590) && via != myself) { if(via && packet->len > MAX(via->mtu, 590) && via != myself) {
logger(DEBUG_TRAFFIC, LOG_INFO, "Packet for %s (%s) length %d larger than MTU %d", subnet->owner->name, subnet->owner->hostname, packet->len, via->mtu); logger(DEBUG_TRAFFIC, LOG_INFO, "Packet for %s (%s) length %d larger than MTU %d", subnet->owner->name, subnet->owner->hostname, packet->len, via->mtu);
if(packet->data[20] & 0x40) { if(DATA(packet)[20] & 0x40) {
packet->len = MAX(via->mtu, 590); packet->len = MAX(via->mtu, 590);
route_ipv4_unreachable(source, packet, ether_size, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED); route_ipv4_unreachable(source, packet, ether_size, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED);
} else { } else {
@ -463,7 +464,7 @@ static void route_ipv6_unreachable(node_t *source, vpn_packet_t *packet, length_
/* Copy headers from packet to structs on the stack */ /* Copy headers from packet to structs on the stack */
memcpy(&ip6, packet->data + ether_size, ip6_size); memcpy(&ip6, DATA(packet) + ether_size, ip6_size);
/* Remember original source and destination */ /* Remember original source and destination */
@ -480,7 +481,7 @@ static void route_ipv6_unreachable(node_t *source, vpn_packet_t *packet, length_
/* Copy first part of original contents to ICMP message */ /* Copy first part of original contents to ICMP message */
memmove(packet->data + ether_size + ip6_size + icmp6_size, packet->data + ether_size, pseudo.length); memmove(DATA(packet) + ether_size + ip6_size + icmp6_size, DATA(packet) + ether_size, pseudo.length);
/* Fill in IPv6 header */ /* Fill in IPv6 header */
@ -506,14 +507,14 @@ static void route_ipv6_unreachable(node_t *source, vpn_packet_t *packet, length_
checksum = inet_checksum(&pseudo, sizeof pseudo, ~0); checksum = inet_checksum(&pseudo, sizeof pseudo, ~0);
checksum = inet_checksum(&icmp6, icmp6_size, checksum); checksum = inet_checksum(&icmp6, icmp6_size, checksum);
checksum = inet_checksum(packet->data + ether_size + ip6_size + icmp6_size, ntohl(pseudo.length) - icmp6_size, checksum); checksum = inet_checksum(DATA(packet) + ether_size + ip6_size + icmp6_size, ntohl(pseudo.length) - icmp6_size, checksum);
icmp6.icmp6_cksum = checksum; icmp6.icmp6_cksum = checksum;
/* Copy structs on stack back to packet */ /* Copy structs on stack back to packet */
memcpy(packet->data + ether_size, &ip6, ip6_size); memcpy(DATA(packet) + ether_size, &ip6, ip6_size);
memcpy(packet->data + ether_size + ip6_size, &icmp6, icmp6_size); memcpy(DATA(packet) + ether_size + ip6_size, &icmp6, icmp6_size);
packet->len = ether_size + ip6_size + ntohl(pseudo.length); packet->len = ether_size + ip6_size + ntohl(pseudo.length);
@ -526,7 +527,7 @@ static void route_ipv6(node_t *source, vpn_packet_t *packet) {
if(!checklength(source, packet, ether_size + ip6_size)) if(!checklength(source, packet, ether_size + ip6_size))
return; return;
if(packet->data[20] == IPPROTO_ICMPV6 && checklength(source, packet, ether_size + ip6_size + icmp6_size) && packet->data[54] == ND_NEIGHBOR_SOLICIT) { if(DATA(packet)[20] == IPPROTO_ICMPV6 && checklength(source, packet, ether_size + ip6_size + icmp6_size) && DATA(packet)[54] == ND_NEIGHBOR_SOLICIT) {
route_neighborsol(source, packet); route_neighborsol(source, packet);
return; return;
} }
@ -535,7 +536,7 @@ static void route_ipv6(node_t *source, vpn_packet_t *packet) {
node_t *via; node_t *via;
ipv6_t dest; ipv6_t dest;
memcpy(&dest, &packet->data[38], sizeof dest); memcpy(&dest, &DATA(packet)[38], sizeof dest);
subnet = lookup_subnet_ipv6(&dest); subnet = lookup_subnet_ipv6(&dest);
if(!subnet) { if(!subnet) {
@ -621,15 +622,15 @@ static void route_neighborsol(node_t *source, vpn_packet_t *packet) {
/* Copy headers from packet to structs on the stack */ /* Copy headers from packet to structs on the stack */
memcpy(&ip6, packet->data + ether_size, ip6_size); memcpy(&ip6, DATA(packet) + ether_size, ip6_size);
memcpy(&ns, packet->data + ether_size + ip6_size, ns_size); memcpy(&ns, DATA(packet) + ether_size + ip6_size, ns_size);
if(has_opt) if(has_opt)
memcpy(&opt, packet->data + ether_size + ip6_size + ns_size, opt_size); memcpy(&opt, DATA(packet) + ether_size + ip6_size + ns_size, opt_size);
/* First, snatch the source address from the neighbor solicitation packet */ /* First, snatch the source address from the neighbor solicitation packet */
if(overwrite_mac) if(overwrite_mac)
memcpy(mymac.x, packet->data + ETH_ALEN, ETH_ALEN); memcpy(mymac.x, DATA(packet) + ETH_ALEN, ETH_ALEN);
/* Check if this is a valid neighbor solicitation request */ /* Check if this is a valid neighbor solicitation request */
@ -655,7 +656,7 @@ static void route_neighborsol(node_t *source, vpn_packet_t *packet) {
checksum = inet_checksum(&ns, ns_size, checksum); checksum = inet_checksum(&ns, ns_size, checksum);
if(has_opt) { if(has_opt) {
checksum = inet_checksum(&opt, opt_size, checksum); checksum = inet_checksum(&opt, opt_size, checksum);
checksum = inet_checksum(packet->data + ether_size + ip6_size + ns_size + opt_size, ETH_ALEN, checksum); checksum = inet_checksum(DATA(packet) + ether_size + ip6_size + ns_size + opt_size, ETH_ALEN, checksum);
} }
if(checksum) { if(checksum) {
@ -688,14 +689,14 @@ static void route_neighborsol(node_t *source, vpn_packet_t *packet) {
/* Create neighbor advertation reply */ /* Create neighbor advertation reply */
memcpy(packet->data, packet->data + ETH_ALEN, ETH_ALEN); /* copy destination address */ memcpy(DATA(packet), DATA(packet) + ETH_ALEN, ETH_ALEN); /* copy destination address */
packet->data[ETH_ALEN * 2 - 1] ^= 0xFF; /* mangle source address so it looks like it's not from us */ DATA(packet)[ETH_ALEN * 2 - 1] ^= 0xFF; /* mangle source address so it looks like it's not from us */
ip6.ip6_dst = ip6.ip6_src; /* swap destination and source protocoll address */ ip6.ip6_dst = ip6.ip6_src; /* swap destination and source protocoll address */
ip6.ip6_src = ns.nd_ns_target; ip6.ip6_src = ns.nd_ns_target;
if(has_opt) if(has_opt)
memcpy(packet->data + ether_size + ip6_size + ns_size + opt_size, packet->data + ETH_ALEN, ETH_ALEN); /* add fake source hard addr */ memcpy(DATA(packet) + ether_size + ip6_size + ns_size + opt_size, DATA(packet) + ETH_ALEN, ETH_ALEN); /* add fake source hard addr */
ns.nd_ns_cksum = 0; ns.nd_ns_cksum = 0;
ns.nd_ns_type = ND_NEIGHBOR_ADVERT; ns.nd_ns_type = ND_NEIGHBOR_ADVERT;
@ -718,17 +719,17 @@ static void route_neighborsol(node_t *source, vpn_packet_t *packet) {
checksum = inet_checksum(&ns, ns_size, checksum); checksum = inet_checksum(&ns, ns_size, checksum);
if(has_opt) { if(has_opt) {
checksum = inet_checksum(&opt, opt_size, checksum); checksum = inet_checksum(&opt, opt_size, checksum);
checksum = inet_checksum(packet->data + ether_size + ip6_size + ns_size + opt_size, ETH_ALEN, checksum); checksum = inet_checksum(DATA(packet) + ether_size + ip6_size + ns_size + opt_size, ETH_ALEN, checksum);
} }
ns.nd_ns_hdr.icmp6_cksum = checksum; ns.nd_ns_hdr.icmp6_cksum = checksum;
/* Copy structs on stack back to packet */ /* Copy structs on stack back to packet */
memcpy(packet->data + ether_size, &ip6, ip6_size); memcpy(DATA(packet) + ether_size, &ip6, ip6_size);
memcpy(packet->data + ether_size + ip6_size, &ns, ns_size); memcpy(DATA(packet) + ether_size + ip6_size, &ns, ns_size);
if(has_opt) if(has_opt)
memcpy(packet->data + ether_size + ip6_size + ns_size, &opt, opt_size); memcpy(DATA(packet) + ether_size + ip6_size + ns_size, &opt, opt_size);
send_packet(source, packet); send_packet(source, packet);
} }
@ -751,11 +752,11 @@ static void route_arp(node_t *source, vpn_packet_t *packet) {
/* First, snatch the source address from the ARP packet */ /* First, snatch the source address from the ARP packet */
if(overwrite_mac) if(overwrite_mac)
memcpy(mymac.x, packet->data + ETH_ALEN, ETH_ALEN); memcpy(mymac.x, DATA(packet) + ETH_ALEN, ETH_ALEN);
/* Copy headers from packet to structs on the stack */ /* Copy headers from packet to structs on the stack */
memcpy(&arp, packet->data + ether_size, arp_size); memcpy(&arp, DATA(packet) + ether_size, arp_size);
/* Check if this is a valid ARP request */ /* Check if this is a valid ARP request */
@ -781,20 +782,20 @@ static void route_arp(node_t *source, vpn_packet_t *packet) {
if(subnet->owner == myself) if(subnet->owner == myself)
return; /* silently ignore */ return; /* silently ignore */
memcpy(packet->data, packet->data + ETH_ALEN, ETH_ALEN); /* copy destination address */ memcpy(DATA(packet), DATA(packet) + ETH_ALEN, ETH_ALEN); /* copy destination address */
packet->data[ETH_ALEN * 2 - 1] ^= 0xFF; /* mangle source address so it looks like it's not from us */ DATA(packet)[ETH_ALEN * 2 - 1] ^= 0xFF; /* mangle source address so it looks like it's not from us */
memcpy(&addr, arp.arp_tpa, sizeof addr); /* save protocol addr */ memcpy(&addr, arp.arp_tpa, sizeof addr); /* save protocol addr */
memcpy(arp.arp_tpa, arp.arp_spa, sizeof addr); /* swap destination and source protocol address */ memcpy(arp.arp_tpa, arp.arp_spa, sizeof addr); /* swap destination and source protocol address */
memcpy(arp.arp_spa, &addr, sizeof addr); /* ... */ memcpy(arp.arp_spa, &addr, sizeof addr); /* ... */
memcpy(arp.arp_tha, arp.arp_sha, ETH_ALEN); /* set target hard/proto addr */ memcpy(arp.arp_tha, arp.arp_sha, ETH_ALEN); /* set target hard/proto addr */
memcpy(arp.arp_sha, packet->data + ETH_ALEN, ETH_ALEN); /* add fake source hard addr */ memcpy(arp.arp_sha, DATA(packet) + ETH_ALEN, ETH_ALEN); /* add fake source hard addr */
arp.arp_op = htons(ARPOP_REPLY); arp.arp_op = htons(ARPOP_REPLY);
/* Copy structs on stack back to packet */ /* Copy structs on stack back to packet */
memcpy(packet->data + ether_size, &arp, arp_size); memcpy(DATA(packet) + ether_size, &arp, arp_size);
send_packet(source, packet); send_packet(source, packet);
} }
@ -807,13 +808,13 @@ static void route_mac(node_t *source, vpn_packet_t *packet) {
if(source == myself) { if(source == myself) {
mac_t src; mac_t src;
memcpy(&src, &packet->data[6], sizeof src); memcpy(&src, &DATA(packet)[6], sizeof src);
learn_mac(&src); learn_mac(&src);
} }
/* Lookup destination address */ /* Lookup destination address */
memcpy(&dest, &packet->data[0], sizeof dest); memcpy(&dest, &DATA(packet)[0], sizeof dest);
subnet = lookup_subnet_mac(NULL, &dest); subnet = lookup_subnet_mac(NULL, &dest);
if(!subnet || !subnet->owner) { if(!subnet || !subnet->owner) {
@ -829,10 +830,10 @@ static void route_mac(node_t *source, vpn_packet_t *packet) {
if(forwarding_mode == FMODE_OFF && source != myself && subnet->owner != myself) if(forwarding_mode == FMODE_OFF && source != myself && subnet->owner != myself)
return; return;
uint16_t type = packet->data[12] << 8 | packet->data[13]; uint16_t type = DATA(packet)[12] << 8 | DATA(packet)[13];
if(priorityinheritance && type == ETH_P_IP && packet->len >= ether_size + ip_size) if(priorityinheritance && type == ETH_P_IP && packet->len >= ether_size + ip_size)
packet->priority = packet->data[15]; packet->priority = DATA(packet)[15];
// Handle packets larger than PMTU // Handle packets larger than PMTU
@ -846,12 +847,12 @@ static void route_mac(node_t *source, vpn_packet_t *packet) {
length_t ethlen = 14; length_t ethlen = 14;
if(type == ETH_P_8021Q) { if(type == ETH_P_8021Q) {
type = packet->data[16] << 8 | packet->data[17]; type = DATA(packet)[16] << 8 | DATA(packet)[17];
ethlen += 4; ethlen += 4;
} }
if(type == ETH_P_IP && packet->len > 576 + ethlen) { if(type == ETH_P_IP && packet->len > 576 + ethlen) {
if(packet->data[6 + ethlen] & 0x40) { if(DATA(packet)[6 + ethlen] & 0x40) {
packet->len = via->mtu; packet->len = via->mtu;
route_ipv4_unreachable(source, packet, ethlen, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED); route_ipv4_unreachable(source, packet, ethlen, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED);
} else { } else {
@ -883,16 +884,16 @@ static void send_pcap(vpn_packet_t *packet) {
len = c->outmaclength; len = c->outmaclength;
if(send_request(c, "%d %d %d", CONTROL, REQ_PCAP, len)) if(send_request(c, "%d %d %d", CONTROL, REQ_PCAP, len))
send_meta(c, (char *)packet->data, len); send_meta(c, (char *)DATA(packet), len);
} }
} }
static bool do_decrement_ttl(node_t *source, vpn_packet_t *packet) { static bool do_decrement_ttl(node_t *source, vpn_packet_t *packet) {
uint16_t type = packet->data[12] << 8 | packet->data[13]; uint16_t type = DATA(packet)[12] << 8 | DATA(packet)[13];
length_t ethlen = ether_size; length_t ethlen = ether_size;
if(type == ETH_P_8021Q) { if(type == ETH_P_8021Q) {
type = packet->data[16] << 8 | packet->data[17]; type = DATA(packet)[16] << 8 | DATA(packet)[17];
ethlen += 4; ethlen += 4;
} }
@ -901,22 +902,22 @@ static bool do_decrement_ttl(node_t *source, vpn_packet_t *packet) {
if(!checklength(source, packet, ethlen + ip_size)) if(!checklength(source, packet, ethlen + ip_size))
return false; return false;
if(packet->data[ethlen + 8] < 1) { if(DATA(packet)[ethlen + 8] < 1) {
if(packet->data[ethlen + 11] != IPPROTO_ICMP || packet->data[ethlen + 32] != ICMP_TIME_EXCEEDED) if(DATA(packet)[ethlen + 11] != IPPROTO_ICMP || DATA(packet)[ethlen + 32] != ICMP_TIME_EXCEEDED)
route_ipv4_unreachable(source, packet, ethlen, ICMP_TIME_EXCEEDED, ICMP_EXC_TTL); route_ipv4_unreachable(source, packet, ethlen, ICMP_TIME_EXCEEDED, ICMP_EXC_TTL);
return false; return false;
} }
uint16_t old = packet->data[ethlen + 8] << 8 | packet->data[ethlen + 9]; uint16_t old = DATA(packet)[ethlen + 8] << 8 | DATA(packet)[ethlen + 9];
packet->data[ethlen + 8]--; DATA(packet)[ethlen + 8]--;
uint16_t new = packet->data[ethlen + 8] << 8 | packet->data[ethlen + 9]; uint16_t new = DATA(packet)[ethlen + 8] << 8 | DATA(packet)[ethlen + 9];
uint32_t checksum = packet->data[ethlen + 10] << 8 | packet->data[ethlen + 11]; uint32_t checksum = DATA(packet)[ethlen + 10] << 8 | DATA(packet)[ethlen + 11];
checksum += old + (~new & 0xFFFF); checksum += old + (~new & 0xFFFF);
while(checksum >> 16) while(checksum >> 16)
checksum = (checksum & 0xFFFF) + (checksum >> 16); checksum = (checksum & 0xFFFF) + (checksum >> 16);
packet->data[ethlen + 10] = checksum >> 8; DATA(packet)[ethlen + 10] = checksum >> 8;
packet->data[ethlen + 11] = checksum & 0xff; DATA(packet)[ethlen + 11] = checksum & 0xff;
return true; return true;
@ -924,13 +925,13 @@ static bool do_decrement_ttl(node_t *source, vpn_packet_t *packet) {
if(!checklength(source, packet, ethlen + ip6_size)) if(!checklength(source, packet, ethlen + ip6_size))
return false; return false;
if(packet->data[ethlen + 7] < 1) { if(DATA(packet)[ethlen + 7] < 1) {
if(packet->data[ethlen + 6] != IPPROTO_ICMPV6 || packet->data[ethlen + 40] != ICMP6_TIME_EXCEEDED) if(DATA(packet)[ethlen + 6] != IPPROTO_ICMPV6 || DATA(packet)[ethlen + 40] != ICMP6_TIME_EXCEEDED)
route_ipv6_unreachable(source, packet, ethlen, ICMP6_TIME_EXCEEDED, ICMP6_TIME_EXCEED_TRANSIT); route_ipv6_unreachable(source, packet, ethlen, ICMP6_TIME_EXCEEDED, ICMP6_TIME_EXCEED_TRANSIT);
return false; return false;
} }
packet->data[ethlen + 7]--; DATA(packet)[ethlen + 7]--;
return true; return true;
@ -955,7 +956,7 @@ void route(node_t *source, vpn_packet_t *packet) {
if(!do_decrement_ttl(source, packet)) if(!do_decrement_ttl(source, packet))
return; return;
uint16_t type = packet->data[12] << 8 | packet->data[13]; uint16_t type = DATA(packet)[12] << 8 | DATA(packet)[13];
switch (routing_mode) { switch (routing_mode) {
case RMODE_ROUTER: case RMODE_ROUTER:

24
src/solaris/device.c
View file

@ -2,7 +2,7 @@
device.c -- Interaction with Solaris tun device device.c -- Interaction with Solaris tun device
Copyright (C) 2001-2005 Ivo Timmermans, Copyright (C) 2001-2005 Ivo Timmermans,
2002-2010 OpenVPN Technologies, Inc. <sales@openvpn.net> 2002-2010 OpenVPN Technologies, Inc. <sales@openvpn.net>
2001-2013 Guus Sliepen <guus@tinc-vpn.org> 2001-2014 Guus Sliepen <guus@tinc-vpn.org>
This program is free software; you can redistribute it and/or modify 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 it under the terms of the GNU General Public License as published by
@ -299,31 +299,31 @@ static bool read_packet(vpn_packet_t *packet) {
switch(device_type) { switch(device_type) {
case DEVICE_TYPE_TUN: case DEVICE_TYPE_TUN:
if((inlen = read(device_fd, packet->data + 14, MTU - 14)) <= 0) { if((inlen = read(device_fd, DATA(packet) + 14, MTU - 14)) <= 0) {
logger(DEBUG_ALWAYS, LOG_ERR, "Error while reading from %s %s: %s", device_info, device, strerror(errno)); logger(DEBUG_ALWAYS, LOG_ERR, "Error while reading from %s %s: %s", device_info, device, strerror(errno));
return false; return false;
} }
switch(packet->data[14] >> 4) { switch(DATA(packet)[14] >> 4) {
case 4: case 4:
packet->data[12] = 0x08; DATA(packet)[12] = 0x08;
packet->data[13] = 0x00; DATA(packet)[13] = 0x00;
break; break;
case 6: case 6:
packet->data[12] = 0x86; DATA(packet)[12] = 0x86;
packet->data[13] = 0xDD; DATA(packet)[13] = 0xDD;
break; break;
default: default:
logger(DEBUG_TRAFFIC, LOG_ERR, "Unknown IP version %d while reading packet from %s %s", packet->data[14] >> 4, device_info, device); logger(DEBUG_TRAFFIC, LOG_ERR, "Unknown IP version %d while reading packet from %s %s", DATA(packet)[14] >> 4, device_info, device);
return false; return false;
} }
memset(packet->data, 0, 12); memset(DATA(packet), 0, 12);
packet->len = inlen + 14; packet->len = inlen + 14;
break; break;
case DEVICE_TYPE_TAP: case DEVICE_TYPE_TAP:
if((inlen = read(device_fd, packet->data, MTU)) <= 0) { if((inlen = read(device_fd, DATA(packet), MTU)) <= 0) {
logger(DEBUG_ALWAYS, LOG_ERR, "Error while reading from %s %s: %s", device_info, device, strerror(errno)); logger(DEBUG_ALWAYS, LOG_ERR, "Error while reading from %s %s: %s", device_info, device, strerror(errno));
return false; return false;
} }
@ -345,14 +345,14 @@ static bool write_packet(vpn_packet_t *packet) {
switch(device_type) { switch(device_type) {
case DEVICE_TYPE_TUN: case DEVICE_TYPE_TUN:
if(write(device_fd, packet->data + 14, packet->len - 14) < 0) { if(write(device_fd, DATA(packet) + 14, packet->len - 14) < 0) {
logger(DEBUG_ALWAYS, LOG_ERR, "Can't write to %s %s: %s", device_info, device, strerror(errno)); logger(DEBUG_ALWAYS, LOG_ERR, "Can't write to %s %s: %s", device_info, device, strerror(errno));
return false; return false;
} }
break; break;
case DEVICE_TYPE_TAP: case DEVICE_TYPE_TAP:
if(write(device_fd, packet->data, packet->len) < 0) { if(write(device_fd, DATA(packet), packet->len) < 0) {
logger(DEBUG_ALWAYS, LOG_ERR, "Can't write to %s %s: %s", device_info, device, strerror(errno)); logger(DEBUG_ALWAYS, LOG_ERR, "Can't write to %s %s: %s", device_info, device, strerror(errno));
return false; return false;
} }

4
src/uml_device.c
View file

@ -244,7 +244,7 @@ static bool read_packet(vpn_packet_t *packet) {
} }
case 2: { case 2: {
if((inlen = read(data_fd, packet->data, MTU)) <= 0) { if((inlen = read(data_fd, DATA(packet), MTU)) <= 0) {
logger(DEBUG_ALWAYS, LOG_ERR, "Error while reading from %s %s: %s", device_info, logger(DEBUG_ALWAYS, LOG_ERR, "Error while reading from %s %s: %s", device_info,
device, strerror(errno)); device, strerror(errno));
event_exit(); event_exit();
@ -275,7 +275,7 @@ static bool write_packet(vpn_packet_t *packet) {
logger(DEBUG_TRAFFIC, LOG_DEBUG, "Writing packet of %d bytes to %s", logger(DEBUG_TRAFFIC, LOG_DEBUG, "Writing packet of %d bytes to %s",
packet->len, device_info); packet->len, device_info);
if(write(write_fd, packet->data, packet->len) < 0) { if(write(write_fd, DATA(packet), packet->len) < 0) {
if(errno != EINTR && errno != EAGAIN) { if(errno != EINTR && errno != EAGAIN) {
logger(DEBUG_ALWAYS, LOG_ERR, "Can't write to %s %s: %s", device_info, device, strerror(errno)); logger(DEBUG_ALWAYS, LOG_ERR, "Can't write to %s %s: %s", device_info, device, strerror(errno));
event_exit(); event_exit();

4
src/vde_device.c
View file

@ -97,7 +97,7 @@ static void close_device(void) {
} }
static bool read_packet(vpn_packet_t *packet) { static bool read_packet(vpn_packet_t *packet) {
int lenin = (ssize_t)plug.vde_recv(conn, packet->data, MTU, 0); int lenin = (ssize_t)plug.vde_recv(conn, DATA(packet), MTU, 0);
if(lenin <= 0) { if(lenin <= 0) {
logger(DEBUG_ALWAYS, LOG_ERR, "Error while reading from %s %s: %s", device_info, device, strerror(errno)); logger(DEBUG_ALWAYS, LOG_ERR, "Error while reading from %s %s: %s", device_info, device, strerror(errno));
event_exit(); event_exit();
@ -112,7 +112,7 @@ static bool read_packet(vpn_packet_t *packet) {
} }
static bool write_packet(vpn_packet_t *packet) { static bool write_packet(vpn_packet_t *packet) {
if((ssize_t)plug.vde_send(conn, packet->data, packet->len, 0) < 0) { if((ssize_t)plug.vde_send(conn, DATA(packet), packet->len, 0) < 0) {
if(errno != EINTR && errno != EAGAIN) { if(errno != EINTR && errno != EAGAIN) {
logger(DEBUG_ALWAYS, LOG_ERR, "Can't write to %s %s: %s", device_info, device, strerror(errno)); logger(DEBUG_ALWAYS, LOG_ERR, "Can't write to %s %s: %s", device_info, device, strerror(errno));
event_exit(); event_exit();