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
  16 int open_or_die(const char *file, int flags)
  17 {
  18         int ret = open(file, flags);
  19         if (ret < 0)
  20                 panic("Cannot open file %s! %s.\n", file, strerror(errno));
  21
  22         return ret;
  23 }
  24
  25 int open_or_die_m(const char *file, int flags, mode_t mode)
  26 {
  27         int ret = open(file, flags, mode);
  28         if (ret < 0)
  29                 panic("Cannot open or create file %s! %s.", file, strerror(errno));
  30         return ret;
  31 }
  32
  33 void create_or_die(const char *file, mode_t mode)
  34 {
  35         int fd = open_or_die_m(file, O_WRONLY | O_CREAT, mode);
  36         close(fd);
  37 }
  38
  39 void pipe_or_die(int pipefd[2], int flags)
  40 {
  41         int ret = pipe2(pipefd, flags);
  42         if (ret < 0)
  43                 panic("Cannot create pipe2 event fd! %s.\n", strerror(errno));
  44 }
  45
  46 int tun_open_or_die(char *name, int type)
  47 {
  48         int fd, ret;
  49         short flags;
  50         struct ifreq ifr;
  51
  52         if (!name)
  53                 panic("No name provided for tundev!\n");
  54
  55         fd = open_or_die("/dev/net/tun", O_RDWR);
  56
  57         memset(&ifr, 0, sizeof(ifr));
  58         ifr.ifr_flags = type;
  59         strlcpy(ifr.ifr_name, name, IFNAMSIZ);
  60
  61         ret = ioctl(fd, TUNSETIFF, &ifr);
  62         if (ret < 0)
  63                 panic("ioctl screwed up! %s.\n", strerror(errno));
  64
  65         ret = fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_NONBLOCK);
  66         if (ret < 0)
  67                 panic("fctnl screwed up! %s.\n", strerror(errno));
  68
  69         flags = device_get_flags(name);
  70         flags |= IFF_UP | IFF_RUNNING;
  71         device_set_flags(name, flags);
  72
  73         return fd;
  74 }
  75
  76 ssize_t read_or_die(int fd, void *buf, size_t len)
  77 {
  78         ssize_t ret = read(fd, buf, len);
  79         if (ret < 0) {
  80                 if (errno == EPIPE)
  81                         die();
  82                 panic("Cannot read from descriptor! %s.\n", strerror(errno));
  83         }
  84
  85         return ret;
  86 }
  87
  88 ssize_t write_or_die(int fd, const void *buf, size_t len)
  89 {
  90         ssize_t ret = write(fd, buf, len);
  91         if (ret < 0) {
  92                 if (errno == EPIPE)
  93                         die();
  94                 panic("Cannot write to descriptor! %s.", strerror(errno));
  95         }
  96
  97         return ret;
  98 }
  99
 100 int read_blob_or_die(const char *file, void *blob, size_t count)
 101 {
 102         int fd, ret;
 103
 104         fd = open_or_die(file, O_RDONLY);
 105         ret = read_or_die(fd, blob, count);
 106         close(fd);
 107
 108         return ret;
 109 }
 110
 111 int write_blob_or_die(const char *file, const void *blob, size_t count)
 112 {
 113         int fd, ret;
 114
 115         fd = open_or_die_m(file, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
 116         ret = write_or_die(fd, blob, count);
 117         fdatasync(fd);
 118         close(fd);
 119
 120         return ret;
 121 }