15 Jun
2010
15 Jun
'10
5:36 p.m.
Module: sip-router
Branch: andrei/raw_sock
Commit: 869a731313e489254fb220ce52120b7682a2526c
URL:
http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=869a731…
Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org>
Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org>
Date: Tue Jun 15 16:27:55 2010 +0200
raw sockets: build ip header & fragmentation support
Support for sending on raw sockets with IP_HDRINCL or IPPROTO_RAW,
that require building the IP header and fragmentation.
---
raw_sock.c | 165 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++--
raw_sock.h | 6 ++-
2 files changed, 164 insertions(+), 7 deletions(-)
diff --git a/raw_sock.c b/raw_sock.c
index e8b90b1..136f595 100644
--- a/raw_sock.c
+++ b/raw_sock.c
@@ -24,11 +24,12 @@
* History:
* --------
* 2010-06-07 initial version (from older code) andrei
+ * 2010-06-15 IP_HDRINCL raw socket support, including on-send
+ * fragmentation (andrei)
*/
/*
* FIXME: IP_PKTINFO & IP_HDRINCL - linux specific
* FIXME: linux specific iphdr and udphdr
- * FIXME: send support for IP_HDRINCL
*/
#ifdef USE_RAW_SOCKS
@@ -37,7 +38,8 @@
#include "ip_addr.h"
#include "dprint.h"
#include "str.h"
-#include "ut.h"
+#include "rand/fastrand.h"
+#include "globals.h"
#include <errno.h>
#include <string.h>
@@ -99,7 +101,7 @@ int raw_socket(int proto, struct ip_addr* ip, str* iface, int
iphdr_incl)
}
t=IP_PMTUDISC_DONT;
if(setsockopt(sock, IPPROTO_IP, IP_MTU_DISCOVER, &t, sizeof(t)) ==-1){
- LOG(L_ERR, "raw_socket: setsockopt(IP_MTU_DISCOVER): %s\n",
+ ERR("raw_socket: setsockopt(IP_MTU_DISCOVER): %s\n",
strerror(errno));
goto error;
}
@@ -275,7 +277,7 @@ int raw_udp4_recv(int rsock, char** buf, int len, union
sockaddr_union* from,
n=-3;
goto error;
}else{
- LOG(L_ERR, "udp length too small: %d/%d\n",
+ ERR("udp length too small: %d/%d\n",
(int)udp_len, (int)(end-udph_start));
n=-3;
goto error;
@@ -290,7 +292,7 @@ int raw_udp4_recv(int rsock, char** buf, int len, union
sockaddr_union* from,
dst_ip.u.addr32[0]=iph.daddr;
/* fill dst_port */
dst_port=ntohs(udph.dest);
- ip_addr2su(to, &dst_ip, port);
+ ip_addr2su(to, &dst_ip, dst_port);
/* fill src_port */
src_port=ntohs(udph.source);
su_setport(from, src_port);
@@ -403,6 +405,34 @@ inline static int mk_udp_hdr(struct udphdr* u, struct sockaddr_in*
from,
+/** fill in an ip header.
+ * Note: the checksum is _not_ computed
+ * @param iph - ip header that will be filled.
+ * @param from - source ip v4 address (network byte order).
+ * @param to - destination ip v4 address (network byte order).
+ * @param payload len - payload length (not including the ip header).
+ * @param proto - protocol.
+ * @return 0 on success, < 0 on error.
+ */
+inline static int mk_ip_hdr(struct iphdr* iph, struct in_addr* from,
+ struct in_addr* to, int payload_len, unsigned char proto)
+{
+ iph->ihl = sizeof(struct iphdr)/4;
+ iph->version = 4;
+ iph->tos = tos;
+ iph->tot_len = htons(payload_len);
+ iph->id = 0;
+ iph->frag_off = 0; /* first 3 bits = flags = 0, last 13 bits = offset */
+ iph->ttl = 63; /* FIXME: use some configured value */
+ iph->protocol = proto;
+ iph->check = 0;
+ iph->saddr = from->s_addr;
+ iph->daddr = to->s_addr;
+ return 0;
+}
+
+
+
/** send an udp packet over a raw socket.
* @param rsock - raw socket
* @param buf - data
@@ -413,7 +443,8 @@ inline static int mk_udp_hdr(struct udphdr* u, struct sockaddr_in*
from,
* @return <0 on error (errno set too), number of bytes sent on success
* (including the udp header => on success len + udpheader size).
*/
-int raw_udp4_send(int rsock, char* buf, int len, union sockaddr_union* from,
+int raw_udp4_send(int rsock, char* buf, unsigned int len,
+ union sockaddr_union* from,
union sockaddr_union* to)
{
struct msghdr snd_msg;
@@ -453,4 +484,126 @@ int raw_udp4_send(int rsock, char* buf, int len, union
sockaddr_union* from,
+/** send an udp packet over an IP_HDRINCL raw socket.
+ * If needed, send several fragments.
+ * @param rsock - raw socket
+ * @param buf - data
+ * @param len - data len
+ * @param from - source address:port (_must_ be non-null, but the ip address
+ * can be 0, in which case it will be filled by the kernel).
+ * @param to - destination address:port
+ * @param mtu - maximum datagram size (including the ip header, excluding
+ * link layer headers). Minimum allowed size is 28
+ * (sizeof(ip_header + udp_header)). If mtu is lower, it will
+ * be ignored (the packet will be sent un-fragmented).
+ * 0 can be used to disable fragmentation.
+ * @return <0 on error (-2: datagram too big, -1: check errno),
+ * number of bytes sent on success
+ * (including the ip & udp headers =>
+ * on success len + udpheader + ipheader size).
+ */
+int raw_iphdr_udp4_send(int rsock, char* buf, unsigned int len,
+ union sockaddr_union* from,
+ union sockaddr_union* to, unsigned short mtu)
+{
+ struct msghdr snd_msg;
+ struct iovec iov[2];
+ struct ip_udp_hdr {
+ struct iphdr ip;
+ struct udphdr udp;
+ } hdr;
+ unsigned int totlen;
+ unsigned int ip_frag_size; /* fragment size */
+ unsigned int last_frag_extra; /* extra bytes possible in the last frag */
+ unsigned int ip_payload;
+ unsigned int last_frag_offs;
+ void* last_frag_start;
+ int frg_no;
+ int ret;
+
+ totlen = len + sizeof(hdr);
+ if (unlikely(totlen) > 65535)
+ return -2;
+ memset(&snd_msg, 0, sizeof(snd_msg));
+ snd_msg.msg_name=&to->sin;
+ snd_msg.msg_namelen=sockaddru_len(*to);
+ snd_msg.msg_iov=&iov[0];
+ /* prepare the udp & ip headers */
+ mk_udp_hdr(&hdr.udp, &from->sin, &to->sin, (unsigned char*)buf, len,
1);
+ mk_ip_hdr(&hdr.ip, &from->sin.sin_addr, &to->sin.sin_addr,
+ len + sizeof(hdr.udp), IPPROTO_UDP);
+ iov[0].iov_base=(char*)&hdr;
+ iov[0].iov_len=sizeof(hdr);
+ snd_msg.msg_iovlen=2;
+ snd_msg.msg_control=0;
+ snd_msg.msg_controllen=0;
+ snd_msg.msg_flags=0;
+ /* this part changes for different fragments */
+ /* packets are fragmented if mtu has a valid value (at least an
+ IP header + UDP header fit in it) and if the total length is greater
+ then the mtu */
+ if (likely(totlen <= mtu || mtu <= sizeof(hdr))) {
+ iov[1].iov_base=buf;
+ iov[1].iov_len=len;
+ ret=sendmsg(rsock, &snd_msg, 0);
+ } else {
+ ip_payload = len + sizeof(hdr.udp);
+ /* a fragment offset must be a multiple of 8 => its size must
+ also be a multiple of 8, except for the last fragment */
+ ip_frag_size = (mtu -sizeof(hdr.ip)) & (~7);
+ last_frag_extra = (mtu - sizeof(hdr.ip)) & 7; /* rest */
+ frg_no = ip_payload / ip_frag_size +
+ ((ip_payload % ip_frag_size) > last_frag_extra);
+ /*ip_last_frag_size = ip_payload % frag_size +
+ ((ip_payload % frag_size) <= last_frag_extra) *
+ ip_frag_size; */
+ last_frag_offs = (frg_no - 1) * ip_frag_size;
+ /* if we are here mtu => sizeof(ip_h+udp_h) && payload > mtu
+ => last_frag_offs >= sizeof(hdr.udp) */
+ last_frag_start = buf + last_frag_offs - sizeof(hdr.udp);
+ hdr.ip.id = fastrand_max(65534) + 1; /* random id, should be != 0
+ (if 0 the kernel will fill it) */
+ /* send the first fragment */
+ iov[1].iov_base=buf;
+ /* ip_frag_size >= sizeof(hdr.udp) because we are here only
+ if mtu >= sizeof(hdr.ip) + sizeof(hdr.udp) */
+ iov[1].iov_len=ip_frag_size - sizeof(hdr.udp);
+ hdr.ip.tot_len = htons(ip_frag_size);
+ hdr.ip.frag_off = htons(0x2000); /* set MF */
+ ret=sendmsg(rsock, &snd_msg, 0);
+ if (unlikely(ret < 0))
+ goto end;
+ /* all the other fragments, include only the ip header */
+ iov[0].iov_len = sizeof(hdr.ip);
+ iov[1].iov_base = (char*)iov[1].iov_base + iov[1].iov_len;
+ /* fragments between the first and the last */
+ while(unlikely(iov[1].iov_base < last_frag_start)) {
+ iov[1].iov_len = ip_frag_size;
+ hdr.ip.tot_len = htons(iov[1].iov_len);
+ /* set MF */
+ hdr.ip.frag_off = htons( (unsigned short)
+ (((char*)iov[1].iov_base - (char*)buf +
+ sizeof(hdr.udp)) / 8) | 0x2000);
+ ret=sendmsg(rsock, &snd_msg, 0);
+ if (unlikely(ret < 0))
+ goto end;
+ iov[1].iov_base = (char*)iov[1].iov_base + iov[1].iov_len;
+ }
+ /* last fragment */
+ iov[1].iov_len = buf + len - (char*)iov[1].iov_base;
+ hdr.ip.tot_len = htons(iov[1].iov_len);
+ /* don't set MF (last fragment) */
+ hdr.ip.frag_off = htons( (unsigned short)
+ (((char*)iov[1].iov_base - (char*)buf +
+ sizeof(hdr.udp)) / 8) );
+ ret=sendmsg(rsock, &snd_msg, 0);
+ if (unlikely(ret < 0))
+ goto end;
+ }
+end:
+ return ret;
+}
+
+
+
#endif /* USE_RAW_SOCKS */
diff --git a/raw_sock.h b/raw_sock.h
index b0e5653..6be0aba 100644
--- a/raw_sock.h
+++ b/raw_sock.h
@@ -46,7 +46,11 @@ int recvpkt4(int sock, char* buf, int len, union sockaddr_union* from,
union sockaddr_union* to);
int raw_udp4_recv(int rsock, char** buf, int len, union sockaddr_union* from,
union sockaddr_union* to, struct raw_filter* rf);
-int raw_udp4_send(int rsock, char* buf, int len, union sockaddr_union* from,
+int raw_udp4_send(int rsock, char* buf, unsigned int len,
+ union sockaddr_union* from,
union sockaddr_union* to);
+int raw_iphdr_udp4_send(int rsock, char* buf, unsigned int len,
+ union sockaddr_union* from,
+ union sockaddr_union* to, unsigned short mtu);
#endif /* _raw_sock_h */