src/write_or_die.c

   1 /*
   2  * transsip - the telephony network
   3  * By Daniel Borkmann <daniel@transsip.org>
   4  * Copyright 2011 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 "write_or_die.h"
  24 #include "die.h"
  25 #include "strlcpy.h"
  26
  27 extern sig_atomic_t quit;
  28
  29 void fsync_or_die(int fd, const char *msg)
  30 {
  31         if (fsync(fd) < 0)
  32                 puke_and_die(EXIT_FAILURE, "%s: fsync error", msg);
  33 }
  34
  35 int open_or_die(const char *file, int flags)
  36 {
  37         int ret = open(file, flags);
  38         if (ret < 0)
  39                 puke_and_die(EXIT_FAILURE, "Open error");
  40         return ret;
  41 }
  42
  43 int open_or_die_m(const char *file, int flags, mode_t mode)
  44 {
  45         int ret = open(file, flags, mode);
  46         if (ret < 0)
  47                 puke_and_die(EXIT_FAILURE, "Open error");
  48         return ret;
  49 }
  50
  51 int tun_open_or_die(char *name)
  52 {
  53         int fd, ret;
  54         struct ifreq ifr;
  55
  56         fd = open("/dev/net/tun", O_RDWR);
  57         if (fd < 0)
  58                 panic("Cannot open /dev/net/tun!\n");
  59
  60         memset(&ifr, 0, sizeof(ifr));
  61         ifr.ifr_flags = IFF_TUN | IFF_NO_PI;
  62
  63         if (name)
  64                 strlcpy(ifr.ifr_name, name, IFNAMSIZ);
  65
  66         ret = ioctl(fd, TUNSETIFF, &ifr);
  67         if (ret < 0)
  68                 panic("ioctl screwed up!\n");
  69
  70         ret = fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_NONBLOCK);
  71         if (ret < 0)
  72                 panic("fctnl screwed up!\n");
  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                         exit(EXIT_SUCCESS);
  83                 puke_and_die(EXIT_FAILURE, "Read error");
  84         }
  85
  86         return ret;
  87 }
  88
  89 ssize_t read_exact(int fd, void *buf, size_t len, int mayexit)
  90 {
  91         register ssize_t num = 0, written;
  92
  93         while (len > 0 && !quit) {
  94                 if ((written = read(fd, buf, len)) < 0) {
  95                         if (errno == EAGAIN && num > 0)
  96                                 continue;
  97                         if (mayexit)
  98                                 return -1;
  99                         else
 100                                 continue;
 101                 }
 102
 103                 if (!written)
 104                         return 0;
 105
 106                 len -= written;
 107                 buf += written;
 108                 num += written;
 109         }
 110
 111         return num;
 112 }
 113
 114 ssize_t write_exact(int fd, void *buf, size_t len, int mayexit)
 115 {
 116         register ssize_t num = 0, written;
 117
 118         while (len > 0 && !quit) {
 119                 if ((written = write(fd, buf, len)) < 0) {
 120                         if (errno == EAGAIN && num > 0)
 121                                 continue;
 122                         if (mayexit)
 123                                 return -1;
 124                         else
 125                                 continue;
 126                 }
 127
 128                 if (!written)
 129                         return 0;
 130
 131                 len -= written;
 132                 buf += written;
 133                 num += written;
 134         }
 135
 136         return num;
 137 }
 138
 139 ssize_t write_or_die(int fd, const void *buf, size_t len)
 140 {
 141         ssize_t ret = write(fd, buf, len);
 142         if (ret < 0) {
 143                 if (errno == EPIPE)
 144                         exit(EXIT_SUCCESS);
 145                 puke_and_die(EXIT_FAILURE, "Write error");
 146         }
 147
 148         return ret;
 149 }
 150
 151 ssize_t write_or_whine_pipe(int fd, const void *buf, size_t len,
 152                             const char *msg)
 153 {
 154         ssize_t ret = write(fd, buf, len);
 155         if (ret < 0) {
 156                 if (errno == EPIPE)
 157                         exit(0);
 158                 whine("%s: write error (%s)!\n", msg, strerror(errno));
 159                 return 0;
 160         }
 161
 162         return ret;
 163 }
 164
 165 ssize_t write_or_whine(int fd, const void *buf, size_t len,
 166                        const char *msg)
 167 {
 168         ssize_t ret = write(fd, buf, len);
 169         if (ret < 0) {
 170                 whine("%s: write error (%s)!\n", msg, strerror(errno));
 171                 return 0;
 172         }
 173
 174         return ret;
 175 }