ioops.c

   1 #define _GNU_SOURCE
   2 #include <unistd.h>
   3 #include <sys/types.h>
   4 #include <sys/stat.h>
   5 #include <sys/ioctl.h>
   6 #include <sys/socket.h>
   7 #include <fcntl.h>
   8 #include <linux/if.h>
   9 #include <linux/if_tun.h>
  10
  11 #include "die.h"
  12 #include "dev.h"
  13 #include "ioops.h"
  14 #include "str.h"
  15 #include "xutils.h"
  16
  17 int open_or_die(const char *file, int flags)
  18 {
  19         int ret = open(file, flags);
  20         if (ret < 0)
  21                 panic("Cannot open file %s! %s.\n", file, strerror(errno));
  22
  23         return ret;
  24 }
  25
  26 int open_or_die_m(const char *file, int flags, mode_t mode)
  27 {
  28         int ret = open(file, flags, mode);
  29         if (ret < 0)
  30                 panic("Cannot open or create file %s! %s.", file, strerror(errno));
  31         return ret;
  32 }
  33
  34 void create_or_die(const char *file, mode_t mode)
  35 {
  36         int fd = open_or_die_m(file, O_WRONLY | O_CREAT, mode);
  37         close(fd);
  38 }
  39
  40 void pipe_or_die(int pipefd[2], int flags)
  41 {
  42         int ret = pipe2(pipefd, flags);
  43         if (ret < 0)
  44                 panic("Cannot create pipe2 event fd! %s.\n", strerror(errno));
  45 }
  46
  47 int tun_open_or_die(char *name, int type)
  48 {
  49         int fd, ret;
  50         short flags;
  51         struct ifreq ifr;
  52
  53         if (!name)
  54                 panic("No name provided for tundev!\n");
  55
  56         fd = open_or_die("/dev/net/tun", O_RDWR);
  57
  58         memset(&ifr, 0, sizeof(ifr));
  59         ifr.ifr_flags = type;
  60         strlcpy(ifr.ifr_name, name, IFNAMSIZ);
  61
  62         ret = ioctl(fd, TUNSETIFF, &ifr);
  63         if (ret < 0)
  64                 panic("ioctl screwed up! %s.\n", strerror(errno));
  65
  66         ret = fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_NONBLOCK);
  67         if (ret < 0)
  68                 panic("fctnl screwed up! %s.\n", strerror(errno));
  69
  70         flags = device_get_flags(name);
  71         flags |= IFF_UP | IFF_RUNNING;
  72         device_set_flags(name, flags);
  73
  74         return fd;
  75 }
  76
  77 ssize_t read_or_die(int fd, void *buf, size_t len)
  78 {
  79         ssize_t ret = read(fd, buf, len);
  80         if (ret < 0) {
  81                 if (errno == EPIPE)
  82                         die();
  83                 panic("Cannot read from descriptor! %s.\n", strerror(errno));
  84         }
  85
  86         return ret;
  87 }
  88
  89 ssize_t write_or_die(int fd, const void *buf, size_t len)
  90 {
  91         ssize_t ret = write(fd, buf, len);
  92         if (ret < 0) {
  93                 if (errno == EPIPE)
  94                         die();
  95                 panic("Cannot write to descriptor! %s.", strerror(errno));
  96         }
  97
  98         return ret;
  99 }