lib/adns/regress/hrecord.c

   1 #include <assert.h>
   2 #include <string.h>
   3 #include <errno.h>
   4 #include <stdlib.h>
   5 #include <sys/types.h>
   6 #include <unistd.h>
   7 #include <fcntl.h>
   8 #include "harness.h"
   9 static FILE *Toutputfile;
  10 void Tshutdown(void) {
  11 }
  12 static void R_recordtime(void) {
  13   int r;
  14   struct timeval tv, tvrel;
  15   Tensureoutputfile();
  16   r= gettimeofday(&tv,0); if (r) Tfailed("gettimeofday syscallbegin");
  17   tvrel.tv_sec= tv.tv_sec - currenttime.tv_sec;
  18   tvrel.tv_usec= tv.tv_usec - currenttime.tv_usec;
  19   if (tv.tv_usec < 0) { tvrel.tv_usec += 1000000; tvrel.tv_sec--; }
  20   Tvbf("\n +%ld.%06ld",(long)tvrel.tv_sec,(long)tvrel.tv_usec);
  21   currenttime= tv;
  22 }
  23 void Tensureoutputfile(void) {
  24   const char *fdstr;
  25   int fd, r;
  26   if (Toutputfile) return;
  27   Toutputfile= stdout;
  28   fdstr= getenv("ADNS_TEST_OUT_FD");
  29   if (fdstr) {
  30     fd= atoi(fdstr);
  31     Toutputfile= fdopen(fd,"a"); if (!Toutputfile) Tfailed("fdopen ADNS_TEST_OUT_FD");
  32   }
  33   r= gettimeofday(&currenttime,0); if (r) Tfailed("gettimeofday syscallbegin");
  34   if (fprintf(Toutputfile," start %ld.%06ld\n",
  35               (long)currenttime.tv_sec,(long)currenttime.tv_usec) == EOF) Toutputerr();
  36 }
  37 void Q_vb(void) {
  38   if (!adns__vbuf_append(&vb,"",1)) Tnomem();
  39   Tensureoutputfile();
  40   if (fprintf(Toutputfile," %s\n",vb.buf) == EOF) Toutputerr();
  41   if (fflush(Toutputfile)) Toutputerr();
  42 }
  43 static void R_vb(void) {
  44   Q_vb();
  45 }
  46 int Hselect(    int max , fd_set *rfds , fd_set *wfds , fd_set *efds , struct timeval *to       ) {
  47  int r, e;
  48  Qselect(       max , rfds , wfds , efds , to   );
  49  r= select(     max , rfds , wfds , efds , to   );
  50  e= errno;
  51  vb.used= 0;
  52  Tvba("select=");
  53   if (r==-1) { Tvberrno(e); goto x_error; }
  54   Tvbf("%d",r);
  55         Tvba(" rfds="); Tvbfdset(max,rfds);
  56         Tvba(" wfds="); Tvbfdset(max,wfds);
  57         Tvba(" efds="); Tvbfdset(max,efds);
  58  x_error:
  59  R_recordtime();
  60  R_vb();
  61  errno= e;
  62  return r;
  63 }
  64 #ifdef HAVE_POLL
  65 int Hpoll(      struct pollfd *fds , int nfds , int timeout     ) {
  66  int r, e;
  67  Qpoll( fds , nfds , timeout    );
  68  r= poll(       fds , nfds , timeout    );
  69  e= errno;
  70  vb.used= 0;
  71  Tvba("poll=");
  72   if (r==-1) { Tvberrno(e); goto x_error; }
  73   Tvbf("%d",r);
  74         Tvba(" fds="); Tvbpollfds(fds,nfds);
  75  x_error:
  76  R_recordtime();
  77  R_vb();
  78  errno= e;
  79  return r;
  80 }
  81 #endif
  82 int Hsocket(    int domain , int type , int protocol    ) {
  83  int r, e;
  84         Tmust("socket","domain",domain==AF_INET);
  85   Tmust("socket","type",type==SOCK_STREAM || type==SOCK_DGRAM);
  86  Qsocket(        type   );
  87  r= socket(     domain , type , protocol        );
  88  e= errno;
  89  vb.used= 0;
  90  Tvba("socket=");
  91   if (r==-1) { Tvberrno(e); goto x_error; }
  92   Tvbf("%d",r);
  93  x_error:
  94  R_recordtime();
  95  R_vb();
  96  errno= e;
  97  return r;
  98 }
  99 int Hfcntl(     int fd , int cmd , ...  ) {
 100  int r, e;
 101         va_list al; long arg;
 102   Tmust("fcntl","cmd",cmd==F_SETFL || cmd==F_GETFL);
 103   if (cmd == F_SETFL) {
 104     va_start(al,cmd); arg= va_arg(al,long); va_end(al);
 105   } else {
 106     arg= 0;
 107   }
 108  Qfcntl(        fd , cmd , arg  );
 109  r= fcntl(      fd , cmd , arg  );
 110  e= errno;
 111  vb.used= 0;
 112  Tvba("fcntl=");
 113   if (r==-1) { Tvberrno(e); goto x_error; }
 114   if (cmd == F_GETFL) {
 115     Tvbf(r & O_NONBLOCK ? "O_NONBLOCK|..." : "~O_NONBLOCK&...");
 116   } else {
 117     if (cmd == F_SETFL) {
 118       Tmust("fcntl","return",!r);
 119     } else {
 120       Tmust("cmd","F_GETFL/F_SETFL",0);
 121     }
 122     Tvba("OK");
 123   }
 124  x_error:
 125  R_recordtime();
 126  R_vb();
 127  errno= e;
 128  return r;
 129 }
 130 int Hconnect(   int fd , const struct sockaddr *addr , int addrlen      ) {
 131  int r, e;
 132  Qconnect(      fd , addr , addrlen     );
 133  r= connect(    fd , addr , addrlen     );
 134  e= errno;
 135  vb.used= 0;
 136  Tvba("connect=");
 137   if (r) { Tvberrno(e); goto x_error; }
 138   Tvba("OK");
 139  x_error:
 140  R_recordtime();
 141  R_vb();
 142  errno= e;
 143  return r;
 144 }
 145 int Hclose(     int fd  ) {
 146  int r, e;
 147  Qclose(        fd      );
 148  r= close(      fd      );
 149  e= errno;
 150  vb.used= 0;
 151  Tvba("close=");
 152   if (r) { Tvberrno(e); goto x_error; }
 153   Tvba("OK");
 154  x_error:
 155  R_recordtime();
 156  R_vb();
 157  errno= e;
 158  return r;
 159 }
 160 int Hsendto(    int fd , const void *msg , int msglen , unsigned int flags , const struct sockaddr *addr , int addrlen  ) {
 161  int r, e;
 162         Tmust("sendto","flags",flags==0);
 163  Qsendto(       fd , msg , msglen , addr , addrlen      );
 164  r= sendto(     fd , msg , msglen , flags , addr , addrlen      );
 165  e= errno;
 166  vb.used= 0;
 167  Tvba("sendto=");
 168   if (r==-1) { Tvberrno(e); goto x_error; }
 169   Tvbf("%d",r);
 170  x_error:
 171  R_recordtime();
 172  R_vb();
 173  errno= e;
 174  return r;
 175 }
 176 int Hrecvfrom(  int fd , void *buf , int buflen , unsigned int flags , struct sockaddr *addr , int *addrlen     ) {
 177  int r, e;
 178         Tmust("recvfrom","flags",flags==0);
 179         Tmust("recvfrom","*addrlen",*addrlen>=sizeof(struct sockaddr_in));
 180  Qrecvfrom(     fd , buflen , *addrlen  );
 181  r= recvfrom(   fd , buf , buflen , flags , addr , addrlen      );
 182  e= errno;
 183  vb.used= 0;
 184  Tvba("recvfrom=");
 185   if (r==-1) { Tvberrno(e); goto x_error; }
 186   Tmust("recvfrom","return",r<=buflen);
 187   Tvba("OK");
 188         Tvba(" addr="); Tvbaddr(addr,*addrlen);
 189         Tvbbytes(buf,r);
 190  x_error:
 191  R_recordtime();
 192  R_vb();
 193  errno= e;
 194  return r;
 195 }
 196 int Hread(      int fd , void *buf , size_t buflen      ) {
 197  int r, e;
 198  Qread( fd , buflen     );
 199  r= read(       fd , buf , buflen       );
 200  e= errno;
 201  vb.used= 0;
 202  Tvba("read=");
 203   if (r==-1) { Tvberrno(e); goto x_error; }
 204   Tmust("read","return",r<=buflen);
 205   Tvba("OK");
 206         Tvbbytes(buf,r);
 207  x_error:
 208  R_recordtime();
 209  R_vb();
 210  errno= e;
 211  return r;
 212 }
 213 int Hwrite(     int fd , const void *buf , size_t len   ) {
 214  int r, e;
 215  Qwrite(        fd , buf , len  );
 216  r= write(      fd , buf , len  );
 217  e= errno;
 218  vb.used= 0;
 219  Tvba("write=");
 220   if (r==-1) { Tvberrno(e); goto x_error; }
 221   Tvbf("%d",r);
 222  x_error:
 223  R_recordtime();
 224  R_vb();
 225  errno= e;
 226  return r;
 227 }