*
* This file is part of Trivial IP Encryption (TrIPE).
*
- * TrIPE is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
+ * TrIPE is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 3 of the License, or (at your
+ * option) any later version.
*
- * TrIPE is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
+ * TrIPE is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * for more details.
*
* You should have received a copy of the GNU General Public License
- * along with TrIPE; if not, write to the Free Software Foundation,
- * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ * along with TrIPE. If not, see <https://www.gnu.org/licenses/>.
*/
/*----- Header files ------------------------------------------------------*/
-#if defined(linux)
-# define _BSD_SOURCE
-#endif
-
#include "config.h"
#include <assert.h>
static void f2tv(struct timeval *tv, double t)
{ tv->tv_sec = t; tv->tv_usec = (t - tv->tv_sec)*MILLION; }
+union addr {
+ struct sockaddr sa;
+ struct sockaddr_in sin;
+ struct sockaddr_in6 sin6;
+};
+
+/* Check whether an address family is even slightly supported. */
+static int addrfamok(int af)
+{
+ switch (af) {
+ case AF_INET: case AF_INET6: return (1);
+ default: return (0);
+ }
+}
+
+/* Return the size of a socket address. */
+static size_t addrsz(const union addr *a)
+{
+ switch (a->sa.sa_family) {
+ case AF_INET: return (sizeof(a->sin));
+ case AF_INET6: return (sizeof(a->sin6));
+ default: abort();
+ }
+}
+
+/* Compare two addresses. Maybe compare the port numbers too. */
+#define AEF_PORT 1u
+static int addreq(const union addr *a, const union addr *b, unsigned f)
+{
+ switch (a->sa.sa_family) {
+ case AF_INET:
+ return (a->sin.sin_addr.s_addr == b->sin.sin_addr.s_addr &&
+ (!(f&AEF_PORT) || a->sin.sin_port == b->sin.sin_port));
+ case AF_INET6:
+ return (!memcmp(a->sin6.sin6_addr.s6_addr,
+ b->sin6.sin6_addr.s6_addr, 16) &&
+ (!(f&AEF_PORT) || a->sin6.sin6_port == b->sin6.sin6_port));
+ default:
+ abort();
+ }
+}
+
/*----- Main algorithm skeleton -------------------------------------------*/
struct param {
double timeout; /* Retransmission timeout */
int seqoff; /* Offset to write sequence number */
const struct probe_ops *pops; /* Probe algorithm description */
- struct sockaddr_in sin; /* Destination address */
+ union addr a; /* Destination address */
};
struct probestate {
/* Build and connect a UDP socket. We'll need this to know the local port
* number to use if nothing else. Set other stuff up.
*/
- if ((sk = socket(PF_INET, SOCK_DGRAM, 0)) < 0) goto fail_0;
- if (connect(sk, (struct sockaddr *)&pp->sin, sizeof(pp->sin))) goto fail_1;
+ if ((sk = socket(pp->a.sa.sa_family, SOCK_DGRAM, IPPROTO_UDP)) < 0)
+ goto fail_0;
+ if (connect(sk, &pp->a.sa, addrsz(&pp->a))) goto fail_1;
st = xmalloc(pp->pops->statesz);
if ((mtu = pp->pops->setup(st, sk, pp)) < 0) goto fail_2;
ps.pp = pp; ps.q = rand() & 0xffff;
- lo = 576; hi = mtu;
+ switch (pp->a.sa.sa_family) {
+ case AF_INET: lo = 576; break;
+ case AF_INET6: lo = 1280; break;
+ default: abort();
+ }
+ hi = mtu;
+ if (hi < lo) { errno = EMSGSIZE; return (-1); }
/* And now we do a thing which is sort of like a binary search, except that
* we also take explicit clues as establishing a new upper bound, and we
};
struct raw_state {
- struct sockaddr_in me, sin;
+ union addr me, a;
int sk, rawicmp, rawudp;
unsigned q;
};
static int raw_setup(void *stv, int sk, const struct param *pp)
{
struct raw_state *st = stv;
- size_t sz;
+ socklen_t sz;
int i, mtu = -1;
struct ifaddrs *ifa, *ifaa, *ifap;
struct ifreq ifr;
- /* If we couldn't acquire raw sockets, we fail here. */
- if (rawerr) { errno = rawerr; goto fail_0; }
- st->rawicmp = rawicmp; st->rawudp = rawudp; st->sk = sk;
+ /* Check that the address is OK, and that we have the necessary raw
+ * sockets.
+ */
+ switch (pp->a.sa.sa_family) {
+ case AF_INET:
+ if (rawerr) { errno = rawerr; goto fail_0; }
+ st->rawicmp = rawicmp; st->rawudp = rawudp; st->sk = sk;
+ break;
+ default:
+ errno = EPFNOSUPPORT; goto fail_0;
+ }
/* Initialize the sequence number. */
st->q = rand() & 0xffff;
/* Snaffle the local and remote address and port number. */
- st->sin = pp->sin;
+ st->a = pp->a;
sz = sizeof(st->me);
- if (getsockname(sk, (struct sockaddr *)&st->me, &sz))
+ if (getsockname(sk, &st->me.sa, &sz))
goto fail_0;
/* There isn't a portable way to force the DF flag onto a packet through
for (i = 0; i < 2; i++) {
for (ifap = 0, ifa = ifaa; ifa; ifa = ifa->ifa_next) {
if (!(ifa->ifa_flags & IFF_UP) || !ifa->ifa_addr ||
- ifa->ifa_addr->sa_family != AF_INET ||
+ ifa->ifa_addr->sa_family != st->me.sa.sa_family ||
(i == 0 &&
- ((struct sockaddr_in *)ifa->ifa_addr)->sin_addr.s_addr !=
- st->me.sin_addr.s_addr) ||
+ !addreq((union addr *)ifa->ifa_addr, &st->me, 0)) ||
(i == 1 && ifap && strcmp(ifap->ifa_name, ifa->ifa_name) == 0) ||
strlen(ifa->ifa_name) >= sizeof(ifr.ifr_name))
continue;
ip->ip_ttl = 64;
ip->ip_p = IPPROTO_UDP;
ip->ip_sum = 0;
- ip->ip_src = st->me.sin_addr;
- ip->ip_dst = st->sin.sin_addr;
+ ip->ip_src = st->me.sin.sin_addr;
+ ip->ip_dst = st->a.sin.sin_addr;
/* Build a UDP packet in the output buffer. */
udp = (struct udphdr *)(ip + 1);
- udp->uh_sport = st->me.sin_port;
- udp->uh_dport = st->sin.sin_port;
+ udp->uh_sport = st->me.sin.sin_port;
+ udp->uh_dport = st->a.sin.sin_port;
udp->uh_ulen = htons(mtu - sizeof(*ip));
udp->uh_sum = 0;
/* Send the whole thing off. If we're too big for the interface then we
* might need to trim immediately.
*/
- if (sendto(st->rawudp, b, mtu, 0,
- (struct sockaddr *)&st->sin, sizeof(st->sin)) < 0) {
+ if (sendto(st->rawudp, b, mtu, 0, &st->a.sa, addrsz(&st->a)) < 0) {
if (errno == EMSGSIZE) return (RC_LOWER);
else goto fail_0;
}
struct ip *ip;
struct icmp *icmp;
struct udphdr *udp;
+ const unsigned char *payload;
ssize_t n;
/* An ICMP packet: see what's inside. */
if (n < sizeof(*ip) ||
ip->ip_p != IPPROTO_UDP || ip->ip_hl != sizeof(*ip)/4 ||
ip->ip_id != htons(st->q) ||
- ip->ip_src.s_addr != st->me.sin_addr.s_addr ||
- ip->ip_dst.s_addr != st->sin.sin_addr.s_addr)
+ ip->ip_src.s_addr != st->me.sin.sin_addr.s_addr ||
+ ip->ip_dst.s_addr != st->a.sin.sin_addr.s_addr)
goto skip_icmp;
n -= sizeof(*ip);
udp = (struct udphdr *)(ip + 1);
- if (n < sizeof(udp) || udp->uh_sport != st->me.sin_port ||
- udp->uh_dport != st->sin.sin_port)
+ if (n < sizeof(udp) || udp->uh_sport != st->me.sin.sin_port ||
+ udp->uh_dport != st->a.sin.sin_port)
goto skip_icmp;
n -= sizeof(*udp);
+ payload = (const unsigned char *)(udp + 1);
+ if (!mypacketp(ps, payload, n)) goto skip_icmp;
+
if (icmp->icmp_code == ICMP_UNREACH_PORT) return (RC_HIGHER);
else if (icmp->icmp_code != ICMP_UNREACH_NEEDFRAG) goto skip_icmp;
else if (icmp->icmp_nextmtu) return (htons(icmp->icmp_nextmtu));
{
struct linux_state *st = stv;
int i, mtu;
- size_t sz;
+ socklen_t sz;
+
+ /* Check that the address is OK. */
+ switch (pp->a.sa.sa_family) {
+ case AF_INET: break;
+ default: errno = EPFNOSUPPORT; return (-1);
+ }
/* Snaffle the UDP socket. */
st->sk = sk;
/* Turn on kernel path-MTU discovery and force DF on. */
- i = IP_PMTUDISC_DO;
+ i = IP_PMTUDISC_PROBE;
if (setsockopt(st->sk, IPPROTO_IP, IP_MTU_DISCOVER, &i, sizeof(i)))
return (-1);
{
struct linux_state *st = stv;
int mtu;
- size_t sz;
+ socklen_t sz;
ssize_t n;
unsigned char b[65536];
static void usage(FILE *fp)
{
- pquis(fp, "Usage: $ [-H HEADER] [-m METHOD]\n\
+ pquis(fp, "Usage: $ [-46v] [-H HEADER] [-m METHOD]\n\
[-r SECS] [-g FACTOR] [-t SECS] HOST [PORT]\n");
}
Options in full:\n\
\n\
-h, --help Show this help text.\n\
--v, --version Show version number.\n\
+-V, --version Show version number.\n\
-u, --usage Show brief usage message.\n\
\n\
+-4, --ipv4 Restrict to IPv4 only.\n\
+-6, --ipv6 Restrict to IPv6 only.\n\
-g, --growth=FACTOR Growth factor for retransmit interval.\n\
-m, --method=METHOD Use METHOD to probe for MTU.\n\
-r, --retransmit=SECS Retransmit if no reply after SEC.\n\
-t, --timeout=SECS Give up expecting a reply after SECS.\n\
+-v, --verbose Write a running commentary to stderr.\n\
-H, --header=HEX Packet header, in hexadecimal.\n\
\n\
Probe methods:\n\
hex_ctx hc;
dstr d = DSTR_INIT;
size_t sz;
- int i;
- unsigned long u;
- char *q;
- struct hostent *h;
- struct servent *s;
+ int i, err;
+ struct addrinfo aihint = { 0 }, *ailist, *ai;
+ const char *host, *svc = "7";
unsigned f = 0;
#define f_bogus 1u
ego(argv[0]);
fillbuffer(buf, sizeof(buf));
- pp.sin.sin_port = htons(7);
+
+ aihint.ai_family = AF_UNSPEC;
+ aihint.ai_protocol = IPPROTO_UDP;
+ aihint.ai_socktype = SOCK_DGRAM;
+ aihint.ai_flags = AI_ADDRCONFIG;
for (;;) {
static const struct option opts[] = {
{ "help", 0, 0, 'h' },
{ "version", 0, 0, 'V' },
{ "usage", 0, 0, 'u' },
+ { "ipv4", 0, 0, '4' },
+ { "ipv6", 0, 0, '6' },
{ "header", OPTF_ARGREQ, 0, 'H' },
{ "growth", OPTF_ARGREQ, 0, 'g' },
{ "method", OPTF_ARGREQ, 0, 'm' },
{ 0, 0, 0, 0 }
};
- i = mdwopt(argc, argv, "hVu" "H:g:m:r:t:v", opts, 0, 0, 0);
+ i = mdwopt(argc, argv, "hVu" "46H:g:m:r:t:v", opts, 0, 0, 0);
if (i < 0) break;
switch (i) {
case 'h': help(stdout); exit(0);
pp.seqoff = sz;
break;
+ case '4': aihint.ai_family = AF_INET; break;
+ case '6': aihint.ai_family = AF_INET6; break;
case 'g': pp.regr = s2f(optarg, "retransmit growth factor"); break;
case 'r': pp.retx = s2f(optarg, "retransmit interval"); break;
case 't': pp.timeout = s2f(optarg, "timeout"); break;
exit(EXIT_FAILURE);
}
- if ((h = gethostbyname(*argv)) == 0)
- die(EXIT_FAILURE, "unknown host `%s': %s", *argv, hstrerror(h_errno));
- if (h->h_addrtype != AF_INET)
- die(EXIT_FAILURE, "unsupported address family for host `%s'", *argv);
- memcpy(&pp.sin.sin_addr, h->h_addr, sizeof(struct in_addr));
- argv++; argc--;
-
- if (*argv) {
- errno = 0;
- u = strtoul(*argv, &q, 0);
- if (!errno && !*q)
- pp.sin.sin_port = htons(u);
- else if ((s = getservbyname(*argv, "udp")) == 0)
- die(EXIT_FAILURE, "unknown UDP service `%s'", *argv);
- else
- pp.sin.sin_port = s->s_port;
+ host = argv[0];
+ if (argv[1]) svc = argv[1];
+ if ((err = getaddrinfo(host, svc, &aihint, &ailist)) != 0) {
+ die(EXIT_FAILURE, "unknown host `%s' or service `%s': %s",
+ host, svc, gai_strerror(err));
}
+ for (ai = ailist; ai && !addrfamok(ai->ai_family); ai = ai->ai_next);
+ if (!ai) die(EXIT_FAILURE, "no supported address families for `%s'", host);
+ assert(ai->ai_addrlen <= sizeof(pp.a));
+ memcpy(&pp.a, ai->ai_addr, ai->ai_addrlen);
- pp.sin.sin_family = AF_INET;
i = pathmtu(&pp);
if (i < 0)
die(EXIT_FAILURE, "failed to discover MTU: %s", strerror(errno));
~mdw / tripe / blobdiff