Merge branch 'master' into 1.1

[meshlink] / src / bsd / device.c

diff --git a/src/bsd/device.c b/src/bsd/device.c
index d6dd055428491f815e75fb5fa403b3ea8f59cf56..c50005b2661f3d2b3bed45c9070c388d69d29e1d 100644 (file)
--- a/src/bsd/device.c
+++ b/src/bsd/device.c
@@ -90,7 +90,7 @@ static 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 {
@@ -111,7 +111,7 @@ static 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;
        }
 
@@ -127,7 +127,7 @@ static 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;
                        }
                }
@@ -146,7 +146,7 @@ static 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;
                        }
                }
@@ -183,7 +183,7 @@ static 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;
 }
@@ -204,20 +204,20 @@ static void close_device(void) {
 }
 
 static bool read_packet(vpn_packet_t *packet) {
-       int lenin;
+       int inlen;
 
        switch(device_type) {
                case DEVICE_TYPE_TUN:
 #ifdef HAVE_TUNEMU
                case DEVICE_TYPE_TUNEMU:
                        if(device_type == DEVICE_TYPE_TUNEMU)
-                               lenin = tunemu_read(device_fd, packet->data + 14, MTU - 14);
+                               inlen = tunemu_read(device_fd, packet->data + 14, MTU - 14);
                        else
 #endif
-                               lenin = read(device_fd, packet->data + 14, MTU - 14);
+                               inlen = read(device_fd, packet->data + 14, MTU - 14);
 
-                       if(lenin <= 0) {
-                               logger(LOG_ERR, "Error while reading from %s %s: %s", device_info,
+                       if(inlen <= 0) {
+                               logger(DEBUG_ALWAYS, LOG_ERR, "Error while reading from %s %s: %s", device_info,
                                           device, strerror(errno));
                                return false;
                        }
@@ -232,21 +232,21 @@ static 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;
                        }
 
-                       packet->len = lenin + 14;
+                       packet->len = inlen + 14;
                        break;
 
                case DEVICE_TYPE_TUNIFHEAD: {
                        u_int32_t type;
-                       struct iovec vector[2] = {{&type, sizeof(type)}, {packet->data + 14, MTU - 14}};
+                       struct iovec vector[2] = {{&type, sizeof type}, {packet->data + 14, MTU - 14}};
 
-                       if((lenin = readv(device_fd, vector, 2)) <= 0) {
-                               logger(LOG_ERR, "Error while reading from %s %s: %s", device_info,
+                       if((inlen = readv(device_fd, vector, 2)) <= 0) {
+                               logger(DEBUG_ALWAYS, LOG_ERR, "Error while reading from %s %s: %s", device_info,
                                           device, strerror(errno));
                                return false;
                        }
@@ -263,24 +263,24 @@ static 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;
                        }
 
-                       packet->len = lenin + 10;
+                       packet->len = inlen + 10;
                        break;
                }
 
                case DEVICE_TYPE_TAP:
-                       if((lenin = read(device_fd, packet->data, MTU)) <= 0) {
-                               logger(LOG_ERR, "Error while reading from %s %s: %s", device_info,
+                       if((inlen = read(device_fd, packet->data, MTU)) <= 0) {
+                               logger(DEBUG_ALWAYS, LOG_ERR, "Error while reading from %s %s: %s", device_info,
                                           device, strerror(errno));
                                return false;
                        }
 
-                       packet->len = lenin;
+                       packet->len = inlen;
                        break;
 
                default:
@@ -289,20 +289,20 @@ static 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;
 }
 
 static bool write_packet(vpn_packet_t *packet) {
-       ifdebug(TRAFFIC) logger(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);
 
        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;
                        }
@@ -310,7 +310,7 @@ static bool write_packet(vpn_packet_t *packet) {
 
                case DEVICE_TYPE_TUNIFHEAD: {
                        u_int32_t type;
-                       struct iovec vector[2] = {{&type, sizeof(type)}, {packet->data + 14, packet->len - 14}};
+                       struct iovec vector[2] = {{&type, sizeof type}, {packet->data + 14, packet->len - 14}};
                        int af;
                        
                        af = (packet->data[12] << 8) + packet->data[13];
@@ -323,14 +323,14 @@ static 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;
                        }
@@ -339,7 +339,7 @@ static 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;
                        }
@@ -348,7 +348,7 @@ static 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;
                        }
@@ -365,9 +365,9 @@ static bool write_packet(vpn_packet_t *packet) {
 }
 
 static 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);
+       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 = {