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 #include <stdio.h>
   9 #include <stdlib.h>
  10 #include <unistd.h>
  11 #include <string.h>
  12 #include <errno.h>
  13 #include <fcntl.h>
  14 #include <signal.h>
  15 #include <sys/types.h>
  16 #include <sys/stat.h>
  17 #include <sys/types.h>
  18 #include <sys/ioctl.h>
  19 #include <sys/socket.h>
  20 #include <linux/if.h>
  21 #include <linux/if_tun.h>
  22
  23 #include "die.h"
  24 #include "xio.h"
  25 #include "strlcpy.h"
  26
  27 int open_or_die(const char *file, int flags)
  28 {
  29         int ret = open(file, flags);
  30         if (ret < 0)
  31                 panic("Cannot open file!\n");
  32         return ret;
  33 }
  34
  35 int open_or_die_m(const char *file, int flags, mode_t mode)
  36 {
  37         int ret = open(file, flags, mode);
  38         if (ret < 0)
  39                 panic("Cannot open or create file!");
  40         return ret;
  41 }
  42
  43 int tun_open_or_die(char *name, int type)
  44 {
  45         int fd, ret;
  46         struct ifreq ifr;
  47         fd = open("/dev/net/tun", O_RDWR);
  48         if (fd < 0)
  49                 panic("Cannot open /dev/net/tun!\n");
  50         memset(&ifr, 0, sizeof(ifr));
  51         ifr.ifr_flags = type;
  52         if (name)
  53                 strlcpy(ifr.ifr_name, name, IFNAMSIZ);
  54         ret = ioctl(fd, TUNSETIFF, &ifr);
  55         if (ret < 0)
  56                 panic("ioctl screwed up!\n");
  57         ret = fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_NONBLOCK);
  58         if (ret < 0)
  59                 panic("fctnl screwed up!\n");
  60         return fd;
  61 }
  62
  63 ssize_t read_or_die(int fd, void *buf, size_t len)
  64 {
  65         ssize_t ret = read(fd, buf, len);
  66         if (ret < 0) {
  67                 if (errno == EPIPE)
  68                         die();
  69                 panic("Cannot read from descriptor!\n");
  70         }
  71         return ret;
  72 }
  73
  74 ssize_t write_or_die(int fd, const void *buf, size_t len)
  75 {
  76         ssize_t ret = write(fd, buf, len);
  77         if (ret < 0) {
  78                 if (errno == EPIPE)
  79                         die();
  80                 panic("Cannot write to descriptor!");
  81         }
  82
  83         return ret;
  84 }
  85
  86 extern sig_atomic_t sigint;
  87
  88 ssize_t read_exact(int fd, void *buf, size_t len, int mayexit)
  89 {
  90         register ssize_t num = 0, written;
  91         while (len > 0 && !sigint) {
  92                 if ((written = read(fd, buf, len)) < 0) {
  93                         if (errno == EAGAIN && num > 0)
  94                                 continue;
  95                         if (mayexit)
  96                                 return -1;
  97                         else
  98                                 continue;
  99                 }
 100                 if (!written)
 101                         return 0;
 102                 len -= written;
 103                 buf += written;
 104                 num += written;
 105         }
 106         return num;
 107 }
 108
 109 ssize_t write_exact(int fd, void *buf, size_t len, int mayexit)
 110 {
 111         register ssize_t num = 0, written;
 112         while (len > 0 && !sigint) {
 113                 if ((written = write(fd, buf, len)) < 0) {
 114                         if (errno == EAGAIN && num > 0)
 115                                 continue;
 116                         if (mayexit)
 117                                 return -1;
 118                         else
 119                                 continue;
 120                 }
 121                 if (!written)
 122                         return 0;
 123                 len -= written;
 124                 buf += written;
 125                 num += written;
 126         }
 127         return num;
 128 }
 129
 130 void check_for_root_maybe_die(void)
 131 {
 132         if (geteuid() != 0 || geteuid() != getuid())
 133                 panic("Uhhuh, not root?!\n");
 134 }