src/xio.c

   1 /*
   2  * netsniff-ng - the packet sniffing beast
   3  * By Daniel Borkmann <daniel@netsniff-ng.org>
   4  * Copyright 2009, 2010 Daniel Borkmann.
   5  * Subject to the GPL, version 2.
   6  */
   7
   8 #define _GNU_SOURCE
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11 #include <unistd.h>
  12 #include <string.h>
  13 #include <errno.h>
  14 #include <fcntl.h>
  15 #include <signal.h>
  16 #include <sys/types.h>
  17 #include <sys/stat.h>
  18 #include <sys/types.h>
  19 #include <sys/ioctl.h>
  20 #include <sys/socket.h>
  21 #include <linux/if.h>
  22 #include <linux/if_tun.h>
  23
  24 #include "die.h"
  25 #include "xio.h"
  26 #include "xutils.h"
  27
  28 int open_or_die(const char *file, int flags)
  29 {
  30         int ret = open(file, flags);
  31         if (ret < 0)
  32                 panic("Cannot open file!\n");
  33
  34         return ret;
  35 }
  36
  37 int open_or_die_m(const char *file, int flags, mode_t mode)
  38 {
  39         int ret = open(file, flags, mode);
  40         if (ret < 0)
  41                 panic("Cannot open or create file!");
  42         return ret;
  43 }
  44
  45 void create_or_die(const char *file, mode_t mode)
  46 {
  47         int fd = open_or_die_m(file, O_WRONLY | O_CREAT, mode);
  48         close(fd);
  49 }
  50
  51 void pipe_or_die(int pipefd[2], int flags)
  52 {
  53         int ret = pipe2(pipefd, flags);
  54         if (ret < 0)
  55                 panic("Cannot create pipe2 event fd!\n");
  56 }
  57
  58 int tun_open_or_die(char *name, int type)
  59 {
  60         int fd, ret;
  61         short flags;
  62         struct ifreq ifr;
  63
  64         if (!name)
  65                 panic("No name provided for tundev!\n");
  66
  67         fd = open_or_die("/dev/net/tun", O_RDWR);
  68
  69         memset(&ifr, 0, sizeof(ifr));
  70         ifr.ifr_flags = type;
  71         strlcpy(ifr.ifr_name, name, IFNAMSIZ);
  72
  73         ret = ioctl(fd, TUNSETIFF, &ifr);
  74         if (ret < 0)
  75                 panic("ioctl screwed up!\n");
  76
  77         ret = fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_NONBLOCK);
  78         if (ret < 0)
  79                 panic("fctnl screwed up!\n");
  80
  81         flags = device_get_flags(name);
  82         flags |= IFF_UP | IFF_RUNNING;
  83         device_set_flags(name, flags);
  84
  85         return fd;
  86 }
  87
  88 ssize_t read_or_die(int fd, void *buf, size_t len)
  89 {
  90         ssize_t ret = read(fd, buf, len);
  91         if (ret < 0) {
  92                 if (errno == EPIPE)
  93                         die();
  94                 panic("Cannot read from descriptor!\n");
  95         }
  96
  97         return ret;
  98 }
  99
 100 ssize_t write_or_die(int fd, const void *buf, size_t len)
 101 {
 102         ssize_t ret = write(fd, buf, len);
 103         if (ret < 0) {
 104                 if (errno == EPIPE)
 105                         die();
 106                 panic("Cannot write to descriptor!");
 107         }
 108
 109         return ret;
 110 }
 111
 112 extern volatile sig_atomic_t sigint;
 113
 114 ssize_t read_exact(int fd, void *buf, size_t len, int mayexit)
 115 {
 116         register ssize_t num = 0, written;
 117
 118         while (len > 0 && !sigint) {
 119                 if ((written = read(fd, buf, len)) < 0) {
 120                         if (errno == EAGAIN && num > 0)
 121                                 continue;
 122                         if (mayexit)
 123                                 return -1;
 124                         else
 125                                 continue;
 126                 }
 127                 if (!written)
 128                         return 0;
 129                 len -= written;
 130                 buf += written;
 131                 num += written;
 132         }
 133
 134         return num;
 135 }
 136
 137 ssize_t write_exact(int fd, void *buf, size_t len, int mayexit)
 138 {
 139         register ssize_t num = 0, written;
 140
 141         while (len > 0 && !sigint) {
 142                 if ((written = write(fd, buf, len)) < 0) {
 143                         if (errno == EAGAIN && num > 0)
 144                                 continue;
 145                         if (mayexit)
 146                                 return -1;
 147                         else
 148                                 continue;
 149                 }
 150                 if (!written)
 151                         return 0;
 152                 len -= written;
 153                 buf += written;
 154                 num += written;
 155         }
 156
 157         return num;
 158 }