Merge branch 'master' into 1.1

[meshlink] / src / bsd / device.c

diff --git a/src/bsd/device.c b/src/bsd/device.c
index d647734ed16d92a1baf9bdf56cccfede7625fbfc..c50005b2661f3d2b3bed45c9070c388d69d29e1d 100644 (file)
--- a/src/bsd/device.c
+++ b/src/bsd/device.c
@@ -1,7 +1,7 @@
 /*
     device.c -- Interaction BSD tun/tap device
     Copyright (C) 2001-2005 Ivo Timmermans,
-                  2001-2011 Guus Sliepen <guus@tinc-vpn.org>
+                  2001-2012 Guus Sliepen <guus@tinc-vpn.org>
                   2009      Grzegorz Dymarek <gregd72002@googlemail.com>
 
     This program is free software; you can redistribute it and/or modify
@@ -22,6 +22,7 @@
 #include "system.h"
 
 #include "conf.h"
+#include "device.h"
 #include "logger.h"
 #include "net.h"
 #include "route.h"
@@ -32,7 +33,12 @@
 #include "bsd/tunemu.h"
 #endif
 
-#define DEFAULT_DEVICE "/dev/tun0"
+#define DEFAULT_TUN_DEVICE "/dev/tun0"
+#if defined(HAVE_FREEBSD) || defined(HAVE_NETBSD)
+#define DEFAULT_TAP_DEVICE "/dev/tap0"
+#else
+#define DEFAULT_TAP_DEVICE "/dev/tun0"
+#endif
 
 typedef enum device_type {
        DEVICE_TYPE_TUN,
@@ -57,11 +63,15 @@ static device_type_t device_type = DEVICE_TYPE_TUNIFHEAD;
 static device_type_t device_type = DEVICE_TYPE_TUN;
 #endif
 
-bool setup_device(void) {
+static bool setup_device(void) {
        char *type;
 
-       if(!get_config_string(lookup_config(config_tree, "Device"), &device))
-               device = xstrdup(DEFAULT_DEVICE);
+       if(!get_config_string(lookup_config(config_tree, "Device"), &device)) {
+               if(routing_mode == RMODE_ROUTER)
+                       device = xstrdup(DEFAULT_TUN_DEVICE);
+               else
+                       device = xstrdup(DEFAULT_TAP_DEVICE);
+       }
 
        if(!get_config_string(lookup_config(config_tree, "Interface"), &iface))
                iface = xstrdup(strrchr(device, '/') ? strrchr(device, '/') + 1 : device);
@@ -80,7 +90,7 @@ bool setup_device(void) {
                else if(!strcasecmp(type, "tap"))
                        device_type = DEVICE_TYPE_TAP;
                else {
-                       logger(LOG_ERR, "Unknown device type %s!", type);
+                       logger(DEBUG_ALWAYS, LOG_ERR, "Unknown device type %s!", type);
                        return false;
                }
        } else {
@@ -101,10 +111,14 @@ bool setup_device(void) {
        }
 
        if(device_fd < 0) {
-               logger(LOG_ERR, "Could not open %s: %s", device, strerror(errno));
+               logger(DEBUG_ALWAYS, LOG_ERR, "Could not open %s: %s", device, strerror(errno));
                return false;
        }
 
+#ifdef FD_CLOEXEC
+       fcntl(device_fd, F_SETFD, FD_CLOEXEC);
+#endif
+
        switch(device_type) {
                default:
                        device_type = DEVICE_TYPE_TUN;
@@ -113,7 +127,7 @@ bool setup_device(void) {
                {       
                        const int zero = 0;
                        if(ioctl(device_fd, TUNSIFHEAD, &zero, sizeof zero) == -1) {
-                               logger(LOG_ERR, "System call `%s' failed: %s", "ioctl", strerror(errno));
+                               logger(DEBUG_ALWAYS, LOG_ERR, "System call `%s' failed: %s", "ioctl", strerror(errno));
                                return false;
                        }
                }
@@ -132,7 +146,7 @@ bool setup_device(void) {
                {
                        const int one = 1;
                        if(ioctl(device_fd, TUNSIFHEAD, &one, sizeof one) == -1) {
-                               logger(LOG_ERR, "System call `%s' failed: %s", "ioctl", strerror(errno));
+                               logger(DEBUG_ALWAYS, LOG_ERR, "System call `%s' failed: %s", "ioctl", strerror(errno));
                                return false;
                        }
                }
@@ -169,12 +183,12 @@ bool setup_device(void) {
 #endif
        }
 
-       logger(LOG_INFO, "%s is a %s", device, device_info);
+       logger(DEBUG_ALWAYS, LOG_INFO, "%s is a %s", device, device_info);
 
        return true;
 }
 
-void close_device(void) {
+static void close_device(void) {
        switch(device_type) {
 #ifdef HAVE_TUNEMU
                case DEVICE_TYPE_TUNEMU:
@@ -189,7 +203,7 @@ void close_device(void) {
        free(iface);
 }
 
-bool read_packet(vpn_packet_t *packet) {
+static bool read_packet(vpn_packet_t *packet) {
        int inlen;
 
        switch(device_type) {
@@ -203,7 +217,7 @@ bool read_packet(vpn_packet_t *packet) {
                                inlen = read(device_fd, packet->data + 14, MTU - 14);
 
                        if(inlen <= 0) {
-                               logger(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));
                                return false;
                        }
@@ -218,7 +232,7 @@ bool read_packet(vpn_packet_t *packet) {
                                        packet->data[13] = 0xDD;
                                        break;
                                default:
-                                       ifdebug(TRAFFIC) logger(LOG_ERR,
+                                       logger(DEBUG_TRAFFIC, LOG_ERR,
                                                           "Unknown IP version %d while reading packet from %s %s",
                                                           packet->data[14] >> 4, device_info, device);
                                        return false;
@@ -232,7 +246,7 @@ bool read_packet(vpn_packet_t *packet) {
                        struct iovec vector[2] = {{&type, sizeof type}, {packet->data + 14, MTU - 14}};
 
                        if((inlen = readv(device_fd, vector, 2)) <= 0) {
-                               logger(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));
                                return false;
                        }
@@ -249,7 +263,7 @@ bool read_packet(vpn_packet_t *packet) {
                                        break;
 
                                default:
-                                       ifdebug(TRAFFIC) logger(LOG_ERR,
+                                       logger(DEBUG_TRAFFIC, LOG_ERR,
                                                           "Unknown address family %x while reading packet from %s %s",
                                                           ntohl(type), device_info, device);
                                        return false;
@@ -261,7 +275,7 @@ bool read_packet(vpn_packet_t *packet) {
 
                case DEVICE_TYPE_TAP:
                        if((inlen = read(device_fd, packet->data, MTU)) <= 0) {
-                               logger(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));
                                return false;
                        }
@@ -275,20 +289,20 @@ bool read_packet(vpn_packet_t *packet) {
                
        device_total_in += packet->len;
 
-       ifdebug(TRAFFIC) logger(LOG_DEBUG, "Read packet of %d bytes from %s",
+       logger(DEBUG_TRAFFIC, LOG_DEBUG, "Read packet of %d bytes from %s",
                           packet->len, device_info);
 
        return true;
 }
 
-bool write_packet(vpn_packet_t *packet) {
-       ifdebug(TRAFFIC) logger(LOG_DEBUG, "Writing packet of %d bytes to %s",
+static bool write_packet(vpn_packet_t *packet) {
+       logger(DEBUG_TRAFFIC, LOG_DEBUG, "Writing packet of %d bytes to %s",
                           packet->len, device_info);
 
        switch(device_type) {
                case DEVICE_TYPE_TUN:
                        if(write(device_fd, packet->data + 14, packet->len - 14) < 0) {
-                               logger(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));
                                return false;
                        }
@@ -309,14 +323,14 @@ bool write_packet(vpn_packet_t *packet) {
                                        type = htonl(AF_INET6);
                                        break;
                                default:
-                                       ifdebug(TRAFFIC) logger(LOG_ERR,
+                                       logger(DEBUG_TRAFFIC, LOG_ERR,
                                                           "Unknown address family %x while writing packet to %s %s",
                                                           af, device_info, device);
                                        return false;
                        }
 
                        if(writev(device_fd, vector, 2) < 0) {
-                               logger(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));
                                return false;
                        }
@@ -325,7 +339,7 @@ bool write_packet(vpn_packet_t *packet) {
                        
                case DEVICE_TYPE_TAP:
                        if(write(device_fd, packet->data, packet->len) < 0) {
-                               logger(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));
                                return false;
                        }
@@ -334,7 +348,7 @@ bool write_packet(vpn_packet_t *packet) {
 #ifdef HAVE_TUNEMU
                case DEVICE_TYPE_TUNEMU:
                        if(tunemu_write(device_fd, packet->data + 14, packet->len - 14) < 0) {
-                               logger(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));
                                return false;
                        }
@@ -350,8 +364,16 @@ bool write_packet(vpn_packet_t *packet) {
        return true;
 }
 
-void dump_device_stats(void) {
-       logger(LOG_DEBUG, "Statistics for %s %s:", device_info, device);
-       logger(LOG_DEBUG, " total bytes in:  %10"PRIu64, device_total_in);
-       logger(LOG_DEBUG, " total bytes out: %10"PRIu64, device_total_out);
+static void dump_device_stats(void) {
+       logger(DEBUG_ALWAYS, LOG_DEBUG, "Statistics for %s %s:", device_info, device);
+       logger(DEBUG_ALWAYS, LOG_DEBUG, " total bytes in:  %10"PRIu64, device_total_in);
+       logger(DEBUG_ALWAYS, LOG_DEBUG, " total bytes out: %10"PRIu64, device_total_out);
 }
+
+const devops_t os_devops = {
+       .setup = setup_device,
+       .close = close_device,
+       .read = read_packet,
+       .write = write_packet,
+       .dump_stats = dump_device_stats,
+};