darwin.c

   1 #include <stdint.h>
   2 #include <sys/types.h>
   3 #include <unistd.h>
   4 #include <errno.h>
   5 #include <stdlib.h>
   6 #include <errno.h>
   7 #include <sys/event.h>
   8 #include <sys/time.h>
   9 #include "dat.h"
  10
  11 enum
  12 {
  13     Infinity = 1 << 30
  14 };
  15
  16 static int  kq;
  17 static char buf0[512]; /* buffer of zeros */
  18
  19
  20 /* Allocate disk space.
  21  * Expects fd's offset to be 0; may also reset fd's offset to 0.
  22  * Returns 0 on success, and a positive errno otherwise. */
  23 int
  24 rawfalloc(int fd, int len)
  25 {
  26     int i, w;
  27
  28     for (i = 0; i < len; i += w) {
  29         w = write(fd, buf0, sizeof buf0);
  30         if (w == -1) return errno;
  31     }
  32
  33     lseek(fd, 0, 0); /* do not care if this fails */
  34
  35     return 0;
  36 }
  37
  38
  39 int
  40 sockinit(void)
  41 {
  42     kq = kqueue();
  43     if (kq == -1) {
  44         twarn("kqueue");
  45         return -1;
  46     }
  47     return 0;
  48 }
  49
  50
  51 int
  52 sockwant(Socket *s, int rw)
  53 {
  54     int n = 0;
  55     struct kevent evs[2] = {}, *ev = evs;
  56     struct timespec ts = {};
  57
  58     if (s->added) {
  59         ev->ident = s->fd;
  60         ev->filter = s->added;
  61         ev->flags = EV_DELETE;
  62         ev++;
  63         n++;
  64     }
  65
  66     if (rw) {
  67         ev->ident = s->fd;
  68         switch (rw) {
  69         case 'r':
  70             ev->filter = EVFILT_READ;
  71             break;
  72         case 'w':
  73             ev->filter = EVFILT_WRITE;
  74             break;
  75         default:
  76             // check only for hangup
  77             ev->filter = EVFILT_READ;
  78             ev->fflags = NOTE_LOWAT;
  79             ev->data = Infinity;
  80         }
  81         ev->flags = EV_ADD;
  82         ev->udata = s;
  83         s->added = ev->filter;
  84         ev++;
  85         n++;
  86     }
  87
  88     return kevent(kq, evs, n, NULL, 0, &ts);
  89 }
  90
  91
  92 int
  93 socknext(Socket **s, int64 timeout)
  94 {
  95     int r;
  96     struct kevent ev;
  97     static struct timespec ts;
  98
  99     ts.tv_sec = timeout / 1000000000;
 100     ts.tv_nsec = timeout % 1000000000;
 101     r = kevent(kq, NULL, 0, &ev, 1, &ts);
 102     if (r == -1 && errno != EINTR) {
 103         twarn("kevent");
 104         return -1;
 105     }
 106
 107     if (r > 0) {
 108         *s = ev.udata;
 109         if (ev.flags & EV_EOF) {
 110             return 'h';
 111         }
 112         switch (ev.filter) {
 113         case EVFILT_READ:
 114             return 'r';
 115         case EVFILT_WRITE:
 116             return 'w';
 117         }
 118     }
 119     return 0;
 120 }