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 "xstring.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         return ret;
  83 }
  84
  85 extern volatile sig_atomic_t sigint;
  86
  87 ssize_t read_exact(int fd, void *buf, size_t len, int mayexit)
  88 {
  89         register ssize_t num = 0, written;
  90         while (len > 0 && !sigint) {
  91                 if ((written = read(fd, buf, len)) < 0) {
  92                         if (errno == EAGAIN && num > 0)
  93                                 continue;
  94                         if (mayexit)
  95                                 return -1;
  96                         else
  97                                 continue;
  98                 }
  99                 if (!written)
 100                         return 0;
 101                 len -= written;
 102                 buf += written;
 103                 num += written;
 104         }
 105         return num;
 106 }
 107
 108 ssize_t write_exact(int fd, void *buf, size_t len, int mayexit)
 109 {
 110         register ssize_t num = 0, written;
 111         while (len > 0 && !sigint) {
 112                 if ((written = write(fd, buf, len)) < 0) {
 113                         if (errno == EAGAIN && num > 0)
 114                                 continue;
 115                         if (mayexit)
 116                                 return -1;
 117                         else
 118                                 continue;
 119                 }
 120                 if (!written)
 121                         return 0;
 122                 len -= written;
 123                 buf += written;
 124                 num += written;
 125         }
 126         return num;
 127 }