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 "xstring.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         struct ifreq ifr;
  62
  63         fd = open_or_die("/dev/net/tun", O_RDWR);
  64
  65         memset(&ifr, 0, sizeof(ifr));
  66         ifr.ifr_flags = type;
  67
  68         if (name)
  69                 strlcpy(ifr.ifr_name, name, IFNAMSIZ);
  70
  71         ret = ioctl(fd, TUNSETIFF, &ifr);
  72         if (ret < 0)
  73                 panic("ioctl screwed up!\n");
  74
  75         ret = fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_NONBLOCK);
  76         if (ret < 0)
  77                 panic("fctnl screwed up!\n");
  78
  79         return fd;
  80 }
  81
  82 ssize_t read_or_die(int fd, void *buf, size_t len)
  83 {
  84         ssize_t ret = read(fd, buf, len);
  85         if (ret < 0) {
  86                 if (errno == EPIPE)
  87                         die();
  88                 panic("Cannot read from descriptor!\n");
  89         }
  90
  91         return ret;
  92 }
  93
  94 ssize_t write_or_die(int fd, const void *buf, size_t len)
  95 {
  96         ssize_t ret = write(fd, buf, len);
  97         if (ret < 0) {
  98                 if (errno == EPIPE)
  99                         die();
 100                 panic("Cannot write to descriptor!");
 101         }
 102
 103         return ret;
 104 }
 105
 106 extern volatile sig_atomic_t sigint;
 107
 108 ssize_t read_exact(int fd, void *buf, size_t len, int mayexit)
 109 {
 110         register ssize_t num = 0, written;
 111
 112         while (len > 0 && !sigint) {
 113                 if ((written = read(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
 128         return num;
 129 }
 130
 131 ssize_t write_exact(int fd, void *buf, size_t len, int mayexit)
 132 {
 133         register ssize_t num = 0, written;
 134
 135         while (len > 0 && !sigint) {
 136                 if ((written = write(fd, buf, len)) < 0) {
 137                         if (errno == EAGAIN && num > 0)
 138                                 continue;
 139                         if (mayexit)
 140                                 return -1;
 141                         else
 142                                 continue;
 143                 }
 144                 if (!written)
 145                         return 0;
 146                 len -= written;
 147                 buf += written;
 148                 num += written;
 149         }
 150
 151         return num;
 152 }