mirror of
https://github.com/ChronosX88/netsukuku.git
synced 2024-11-22 18:22:18 +00:00
452 lines
11 KiB
C
452 lines
11 KiB
C
|
|
/* This file is part of Netsukuku
|
|
* (c) Copyright 2005 Andrea Lo Pumo aka AlpT <alpt@freaknet.org>
|
|
*
|
|
* This source code 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.
|
|
*
|
|
* This source code 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.
|
|
* Please refer to the GNU Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Public License along with
|
|
* this source code; if not, write to:
|
|
* Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
*
|
|
* --
|
|
* This code derives from iproute2/iprule.c, it was modified to fit in
|
|
* Netsukuku.
|
|
*
|
|
* Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
|
|
* Changes:
|
|
* Rani Assaf <rani@magic.metawire.com> 980929: resolve addresses
|
|
* Rani Assaf <rani@magic.metawire.com> 980930: do not allow key for ipip/sit
|
|
* Phil Karn <karn@ka9q.ampr.org> 990408: "pmtudisc" flag
|
|
*/
|
|
|
|
#include "includes.h"
|
|
|
|
#include "inet.h"
|
|
#include <linux/ip.h>
|
|
#include <linux/if_tunnel.h>
|
|
|
|
#include "libnetlink.h"
|
|
#include "libnetlink.h"
|
|
#include "ll_map.h"
|
|
#include "krnl_route.h"
|
|
#include "route.h"
|
|
#include "iptunnel.h"
|
|
#include "common.h"
|
|
|
|
static int do_add(int cmd, inet_prefix *remote, inet_prefix *local, char *dev,
|
|
char *tunl_prefix, int tunl_number);
|
|
int do_del(inet_prefix *remote, inet_prefix *local, char *dev,
|
|
char *tunl_prefix, int tunl_number);
|
|
|
|
int tunnel_add(inet_prefix *remote, inet_prefix *local, char *dev,
|
|
char *tunl_prefix, int tunl_number)
|
|
{
|
|
return do_add(SIOCADDTUNNEL, remote, local, dev, tunl_prefix,
|
|
tunl_number);
|
|
}
|
|
|
|
int tunnel_change(inet_prefix *remote, inet_prefix *local, char *dev,
|
|
char *tunl_prefix, int tunl_number)
|
|
{
|
|
return do_add(SIOCGETTUNNEL, remote, local, dev, tunl_prefix,
|
|
tunl_number);
|
|
}
|
|
|
|
int tunnel_del(inet_prefix *remote, inet_prefix *local, char *dev,
|
|
char *tunl_prefix, int tunl_number)
|
|
{
|
|
return do_del(remote, local, dev, tunl_prefix, tunl_number);
|
|
}
|
|
|
|
static int do_ioctl_get_ifindex(const char *dev)
|
|
{
|
|
struct ifreq ifr;
|
|
int fd;
|
|
int err;
|
|
|
|
strncpy(ifr.ifr_name, dev, IFNAMSIZ);
|
|
fd = socket(AF_INET, SOCK_DGRAM, 0);
|
|
err = ioctl(fd, SIOCGIFINDEX, &ifr);
|
|
if (err) {
|
|
error(ERROR_MSG "ioctl: %s", ERROR_POS, strerror(errno));
|
|
return 0;
|
|
}
|
|
close(fd);
|
|
return ifr.ifr_ifindex;
|
|
}
|
|
|
|
#if 0
|
|
static int do_ioctl_get_iftype(const char *dev)
|
|
{
|
|
struct ifreq ifr;
|
|
int fd;
|
|
int err;
|
|
|
|
strncpy(ifr.ifr_name, dev, IFNAMSIZ);
|
|
fd = socket(AF_INET, SOCK_DGRAM, 0);
|
|
err = ioctl(fd, SIOCGIFHWADDR, &ifr);
|
|
if (err) {
|
|
error(ERROR_MSG "ioctl: %s",ERROR_POS, strerror(errno));
|
|
return -1;
|
|
}
|
|
close(fd);
|
|
return ifr.ifr_addr.sa_family;
|
|
}
|
|
|
|
static char * do_ioctl_get_ifname(int idx)
|
|
{
|
|
static struct ifreq ifr;
|
|
int fd;
|
|
int err;
|
|
|
|
ifr.ifr_ifindex = idx;
|
|
fd = socket(AF_INET, SOCK_DGRAM, 0);
|
|
err = ioctl(fd, SIOCGIFNAME, &ifr);
|
|
if (err) {
|
|
error(ERROR_MSG "ioctl: %s",ERROR_POS, strerror(errno));
|
|
return NULL;
|
|
}
|
|
close(fd);
|
|
return ifr.ifr_name;
|
|
}
|
|
#endif
|
|
|
|
static int do_get_ioctl(const char *basedev, struct ip_tunnel_parm *p)
|
|
{
|
|
struct ifreq ifr;
|
|
int fd;
|
|
int err;
|
|
|
|
strncpy(ifr.ifr_name, basedev, IFNAMSIZ);
|
|
ifr.ifr_ifru.ifru_data = (void*)p;
|
|
fd = socket(AF_INET, SOCK_DGRAM, 0);
|
|
err = ioctl(fd, SIOCGETTUNNEL, &ifr);
|
|
/*
|
|
* if (err)
|
|
* error(ERROR_MSG "ioctl: %s",ERROR_POS, strerror(errno));
|
|
*/
|
|
close(fd);
|
|
return err;
|
|
}
|
|
|
|
static int do_add_ioctl(int cmd, const char *basedev, struct ip_tunnel_parm *p)
|
|
{
|
|
struct ifreq ifr;
|
|
int fd;
|
|
int err;
|
|
|
|
if (cmd == SIOCCHGTUNNEL && p->name[0])
|
|
strncpy(ifr.ifr_name, p->name, IFNAMSIZ);
|
|
else
|
|
strncpy(ifr.ifr_name, basedev, IFNAMSIZ);
|
|
ifr.ifr_ifru.ifru_data = (void*)p;
|
|
fd = socket(AF_INET, SOCK_DGRAM, 0);
|
|
err = ioctl(fd, cmd, &ifr);
|
|
error("Socket File Descriptor Is: %i cmd is: %i err is: %i ifr is: %s Errno is: %d", fd, cmd, err, &ifr, errno);
|
|
if (err)
|
|
error(ERROR_MSG "ioctl: %s",ERROR_POS, strerror(errno));
|
|
close(fd);
|
|
return err;
|
|
}
|
|
|
|
static int do_del_ioctl(const char *basedev, struct ip_tunnel_parm *p)
|
|
{
|
|
struct ifreq ifr;
|
|
int fd;
|
|
int err;
|
|
|
|
if (p->name[0])
|
|
strncpy(ifr.ifr_name, p->name, IFNAMSIZ);
|
|
else
|
|
strncpy(ifr.ifr_name, basedev, IFNAMSIZ);
|
|
ifr.ifr_ifru.ifru_data = (void*)p;
|
|
fd = socket(AF_INET, SOCK_DGRAM, 0);
|
|
err = ioctl(fd, SIOCDELTUNNEL, &ifr);
|
|
if (err)
|
|
error(ERROR_MSG "ioctl: %s",ERROR_POS, strerror(errno));
|
|
close(fd);
|
|
return err;
|
|
}
|
|
|
|
/*
|
|
* fill_tunnel_parm: fills the `p' struct.
|
|
* `remote' and `local' must be in host order
|
|
*/
|
|
static int fill_tunnel_parm(int cmd, inet_prefix *remote, inet_prefix *local,
|
|
char *dev, char *tunl_prefix, int tunl_number,
|
|
struct ip_tunnel_parm *p)
|
|
{
|
|
char medium[IFNAMSIZ];
|
|
|
|
memset(p, 0, sizeof(*p));
|
|
memset(&medium, 0, sizeof(medium));
|
|
|
|
p->iph.version = 4;
|
|
p->iph.ihl = 5;
|
|
#ifndef IP_DF
|
|
#define IP_DF 0x4000 /* Flag: "Don't Fragment" */
|
|
#endif
|
|
p->iph.frag_off = htons(IP_DF);
|
|
p->iph.protocol = IPPROTO_IPIP;
|
|
|
|
if(remote)
|
|
p->iph.daddr = htonl(remote->data[0]);
|
|
if(local)
|
|
p->iph.saddr = htonl(local->data[0]);
|
|
if(dev)
|
|
strncpy(medium, dev, IFNAMSIZ-1);
|
|
|
|
sprintf(p->name, TUNL_STRING, TUNL_N(tunl_prefix, tunl_number));
|
|
if (cmd == SIOCCHGTUNNEL) {
|
|
/* Change the old tunnel */
|
|
struct ip_tunnel_parm old_p;
|
|
memset(&old_p, 0, sizeof(old_p));
|
|
if (do_get_ioctl(p->name, &old_p))
|
|
return -1;
|
|
*p = old_p;
|
|
}
|
|
|
|
if (p->iph.protocol == IPPROTO_IPIP)
|
|
if ((p->i_flags & GRE_KEY) || (p->o_flags & GRE_KEY))
|
|
fatal("Keys are not allowed with ipip and sit.");
|
|
|
|
if (medium[0]) {
|
|
p->link = do_ioctl_get_ifindex(medium);
|
|
if (p->link == 0)
|
|
return -1;
|
|
}
|
|
|
|
if (IN_MULTICAST(ntohl(p->iph.daddr)) && !p->iph.saddr)
|
|
fatal("Broadcast tunnel requires a source address.");
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* do_get: returns 1 if the tunnel named `dev' exists.
|
|
*/
|
|
int do_get(char *dev)
|
|
{
|
|
struct ip_tunnel_parm old_p;
|
|
memset(&old_p, 0, sizeof(old_p));
|
|
|
|
if (do_get_ioctl(dev, &old_p))
|
|
return 0;
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int do_add(int cmd, inet_prefix *remote, inet_prefix *local, char *dev,
|
|
char *tunl_prefix, int tunl_number)
|
|
{
|
|
struct ip_tunnel_parm p;
|
|
|
|
if (fill_tunnel_parm(cmd, remote, local, dev, tunl_prefix,
|
|
tunl_number, &p) < 0)
|
|
return -1;
|
|
|
|
if (p.iph.ttl && p.iph.frag_off == 0)
|
|
fatal("ttl != 0 and noptmudisc are incompatible");
|
|
|
|
switch (p.iph.protocol) {
|
|
case IPPROTO_IPIP:
|
|
return do_add_ioctl(cmd, DEFAULT_TUNL_IF, &p);
|
|
default:
|
|
fatal("cannot determine tunnel mode (ipip, gre or sit)\n");
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
int do_del(inet_prefix *remote, inet_prefix *local, char *dev, char *tunl_prefix,
|
|
int tunl_number)
|
|
{
|
|
struct ip_tunnel_parm p;
|
|
|
|
if (fill_tunnel_parm(SIOCDELTUNNEL, remote, local, dev, tunl_prefix,
|
|
tunl_number, &p) < 0)
|
|
return -1;
|
|
|
|
switch (p.iph.protocol) {
|
|
case IPPROTO_IPIP:
|
|
return do_del_ioctl(DEFAULT_TUNL_IF, &p);
|
|
default:
|
|
return do_del_ioctl(p.name, &p);
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
/*
|
|
* tun_add_tunl: it adds in the `ifs' array a new struct which refers to
|
|
* the tunnel "tunlX", where X is a number equal to `tunl'.
|
|
*/
|
|
int tun_add_tunl(interface *ifs, char *tunl_prefix, u_char tunl_number)
|
|
{
|
|
char tunl_name[IFNAMSIZ];
|
|
|
|
sprintf(tunl_name, TUNL_STRING, TUNL_N(tunl_prefix, tunl_number));
|
|
strncpy(ifs->dev_name, tunl_name, IFNAMSIZ);
|
|
if(!(ifs->dev_idx=do_ioctl_get_ifindex(tunl_name)))
|
|
return -1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* tun_del_tunl: it removes from the `ifs' array, which must have at least
|
|
* MAX_TUNNEL_IFS members, the struct which refers the tunnel "tunlX", where X
|
|
* is a number equal to `tunl'.
|
|
* If no such struct is found, -1 is returned.
|
|
*/
|
|
int tun_del_tunl(interface *ifs, char *tunl_prefix, u_char tunl_number)
|
|
{
|
|
char tunl_name[IFNAMSIZ];
|
|
int i;
|
|
|
|
sprintf(tunl_name, TUNL_STRING, TUNL_N(tunl_prefix, tunl_number));
|
|
|
|
for(i=0; i<MAX_TUNNEL_IFS; i++)
|
|
if(!strncmp(ifs[i].dev_name, tunl_name, IFNAMSIZ)) {
|
|
memset(&ifs[i], 0, sizeof(interface));
|
|
return 0;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
|
|
|
|
void init_tunnels_ifs(void)
|
|
{
|
|
memset(tunnel_ifs, 0, sizeof(interface)*MAX_TUNNEL_IFS);
|
|
}
|
|
|
|
/*
|
|
* first_free_tunnel_if: returns the position of the first member of the
|
|
* `tunnel_ifs' array which isn't used yet.
|
|
* If the whole array is full, -1 is returned.
|
|
*/
|
|
int first_free_tunnel_if(void)
|
|
{
|
|
int i;
|
|
|
|
for(i=0; i<MAX_TUNNEL_IFS; i++)
|
|
if(!*tunnel_ifs[i].dev_name && !tunnel_ifs[i].dev_idx)
|
|
return i;
|
|
return -1;
|
|
}
|
|
|
|
/*
|
|
* set_tunnel_ip: it brings down and up and set the `tunl_ip' IP to the
|
|
* "tunl`tunl_number'" tunnel device
|
|
*/
|
|
int set_tunnel_ip(char *tunl_prefix, int tunl_number, inet_prefix *tunl_ip)
|
|
{
|
|
const char *ntop;
|
|
ntop=inet_to_str(*tunl_ip);
|
|
|
|
set_all_ifs(&tunnel_ifs[tunl_number], 1, set_dev_down);
|
|
set_all_ifs(&tunnel_ifs[tunl_number], 1, set_dev_up);
|
|
if(set_all_dev_ip(*tunl_ip, &tunnel_ifs[tunl_number], 1) < 0) {
|
|
error("Cannot set the %s ip to " TUNL_STRING,
|
|
ntop, TUNL_N(tunl_prefix, tunl_number));
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* add_tunnel_if: creates a new tunnel, adds it in the `tunnel_ifs' array, and
|
|
* if `tunl_ip' isn't null, sets to the tunnel the IP `tunl_ip'.
|
|
*/
|
|
int add_tunnel_if(inet_prefix *remote, inet_prefix *local, char *dev,
|
|
char *tunl_prefix, int tunl_number, inet_prefix *tunl_ip)
|
|
{
|
|
char tunl_name[IFNAMSIZ];
|
|
|
|
/*
|
|
* tunl0 zero is a special tunnel, it cannot be created nor destroyed.
|
|
* It's pure energy.
|
|
*/
|
|
if(!strcmp(tunl_prefix, DEFAULT_TUNL_PREFIX) && !tunl_number)
|
|
goto skip_krnl_add_tunl;
|
|
|
|
if(tunnel_add(remote, local, dev, tunl_prefix, tunl_number) < 0) {
|
|
error("Cannot add the \"" TUNL_STRING "\" tunnel",
|
|
TUNL_N(tunl_prefix, tunl_number));
|
|
return -1;
|
|
}
|
|
|
|
skip_krnl_add_tunl:
|
|
|
|
if(tun_add_tunl(&tunnel_ifs[tunl_number], tunl_prefix, tunl_number) < 0)
|
|
return -1;
|
|
|
|
if(tunl_ip) {
|
|
|
|
/*
|
|
* ifconfig tunnel `tunl_ip' up
|
|
*/
|
|
if(set_tunnel_ip(tunl_prefix, tunl_number, tunl_ip) < 0)
|
|
return -1;
|
|
|
|
|
|
/*
|
|
* ip route append tunl_ip_subnet dev tunnel proto kernel \
|
|
* scope link src `tunl_ip'
|
|
*/
|
|
sprintf(tunl_name, TUNL_STRING, TUNL_N(tunl_prefix, tunl_number));
|
|
rt_append_subnet_src(tunl_ip, tunl_name);
|
|
|
|
if(route_rp_filter_all_dev(my_family, &tunnel_ifs[tunl_number],
|
|
1, 0) < 0)
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* del_tunnel_if: the inverse of add_tunnel_if() (see above)
|
|
*/
|
|
int del_tunnel_if(inet_prefix *remote, inet_prefix *local, char *dev,
|
|
char *tunl_prefix, int tunl_number)
|
|
{
|
|
/* tunl0 is a highlander */
|
|
if(!strcmp(tunl_prefix, DEFAULT_TUNL_PREFIX) && !tunl_number)
|
|
goto skip_krnl_del_tunl;
|
|
|
|
if(tunnel_del(remote, local, dev, tunl_prefix, tunl_number) < 0) {
|
|
error("Cannot delete the \"" TUNL_STRING "\" tunnel",
|
|
TUNL_N(tunl_prefix, tunl_number));
|
|
return -1;
|
|
}
|
|
|
|
skip_krnl_del_tunl:
|
|
|
|
tun_del_tunl(tunnel_ifs, tunl_prefix, tunl_number);
|
|
return 0;
|
|
}
|
|
|
|
void del_all_tunnel_ifs(inet_prefix *remote, inet_prefix *local, char *dev,
|
|
char *tunl_prefix)
|
|
{
|
|
char tunl_name[IFNAMSIZ];
|
|
int i;
|
|
|
|
for(i=0; i<MAX_TUNNEL_IFS; i++) {
|
|
sprintf(tunl_name, TUNL_STRING, TUNL_N(tunl_prefix, i));
|
|
if(do_get(tunl_name))
|
|
del_tunnel_if(remote, local, 0, tunl_prefix, i);
|
|
else
|
|
break;
|
|
}
|
|
}
|