regress/junk

   1
   2
   3
   4 m4_define(`hm_arg_timeval_out_abs', `')
   5 m4_define(`hm_arg_nullptr', `')
   6 m4_define(`hm_arg_fdset_io', `const fd_set *$1 $3')
   7 m4_define(`hm_arg_must', `')
   8 m4_define(`hm_arg_ign', `')
   9 m4_define(`hm_arg_fcntl_arg', `long arg')
  10 m4_define(`hm_arg_bytes_out', `$3 $4 $6')
  11 m4_define(`hm_arg_addr_out', `int $2 $3')
  12
  13
  14 m4_define(`hm_syscall', `void Q$1(hm_args_checkvoid(`$3'));')
  15
  16
  17
  18
  19
  20 int Hgettimeofday(struct timeval *tv, struct timezone *tz) {
  21   int r;
  22   struct timeval diff;
  23
  24   assert(tv); assert(!tz);
  25
  26   Qgettimeofday();
  27
  28   r= gettimeofday(tv,0); if (r) Tfailed("gettimeofday");
  29
  30   vb.used= 0;
  31   if (!begin_set) {
  32     Tvbf("gettimeofday= %ld.%06ld",tv->tv_sec,tv->tv_usec);
  33     begin= *tv;
  34     begin_set= 1;
  35   } else {
  36     diff.tv_sec= tv->tv_sec - begin.tv_sec;
  37     diff.tv_usec= tv->tv_usec - begin.tv_usec;
  38     if (diff.tv_usec < 0) {
  39       diff.tv_sec -= 1;
  40       diff.tv_usec += 1000000;
  41     }
  42     assert(diff.tv_sec >= 0);
  43     assert(diff.tv_usec >= 0);
  44     Tvbf("gettimeofday= +%ld.%06ld",diff.tv_sec,diff.tv_usec);
  45   }
  46   Rvb();
  47
  48   return 0;
  49 }
  50
  51 int Hselect(int n, fd_set *rfds, fd_set *wfds, fd_set *efds, struct timeval *to) {
  52   int r;
  53
  54   Qselect(n,rfds,wfds,efds,to);
  55
  56   r= select(n,rfds,wfds,efds,to);
  57
  58   if (r==-1) {
  59     Rerrno("select");
  60   } else {
  61     vb.used= 0;
  62     Tvbf("select= %d",r);
  63     Tvbfdset(n,rfds);
  64     Tvbfdset(n,wfds);
  65     Tvbfdset(n,efds);
  66     Rvb();
  67   }
  68
  69   if (to) memset(to,0x5a,sizeof(*to));
  70
  71   return r;
  72 }
  73
  74 int Hsocket(int domain, int type, int protocol) {
  75   int r;
  76
  77   assert(domain == AF_INET);
  78
  79   Qsocket(type);
  80   r= socket(domain,type,protocol); if (r==-1) Tfailed("socket");
  81
  82   Rf("socket= %d",r);
  83   return r;
  84 }
  85
  86 int Hfcntl(int fd, int cmd, ...) {
  87   long arg;
  88   int r;
  89   va_list al;
  90
  91   if (cmd == F_SETFL) {
  92     va_start(al,cmd);
  93     arg= va_arg(al,long);
  94     va_end(al);
  95     Qfcntl_setfl(fd,cmd,arg);
  96     r= fcntl(fd, cmd, arg);
  97   } else {
  98     Qfcntl_other(fd,cmd);
  99     r= fcntl(fd, cmd);
 100   }
 101
 102   if (r==-1) Tfailed("fcntl");
 103   Rf("fcntl= %d",r);
 104   return r;
 105 }
 106
 107 int Hconnect(int fd, struct sockaddr *addr, int addrlen) {
 108   int r;
 109
 110   Qconnect(fd,addr,addrlen);
 111
 112   r= connect(fd, addr, addrlen);
 113
 114   if (r) {
 115     Rerrno("connect");
 116   } else {
 117     Rf("connect= ok");
 118   }
 119   return r;
 120 }
 121
 122 int Hclose(int fd) {
 123   Qclose(fd);
 124   return 0;
 125 }
 126
 127 int Hsendto(int fd, const void *msg, int msglen, unsigned int flags,
 128             const struct sockaddr *addr, int addrlen) {
 129   int r;
 130
 131   assert(!flags);
 132   Qsendto(fd,msg,msglen,addr,addrlen);
 133
 134   r= sendto(fd,msg,msglen,flags,addr,addrlen);
 135   if (r==-1) {
 136     Rerrno("sendto");
 137   } else {
 138     Rf("sendto= %d",r);
 139   }
 140   return r;
 141 }
 142
 143 int Hrecvfrom(int fd, void *buf, int buflen, unsigned int flags,
 144               struct sockaddr *addr, int *addrlen) {
 145   int r;
 146
 147   assert(!flags);
 148   Qrecvfrom(fd,buflen,*addrlen);
 149
 150   r= recvfrom(fd,buf,buflen,flags,addr,addrlen);
 151   if (r==-1) {
 152     Rerrno("recvfrom");
 153   } else {
 154     vb.used= 0;
 155     Tvbf("recvfrom= %d",r);
 156     Tvbaddr(addr,*addrlen);
 157     Tvbbytes(buf,r);
 158     Rvb();
 159   }
 160
 161   return r;
 162 }
 163
 164 int Hread(int fd, void *buf, size_t len) {
 165   int r;
 166
 167   Qread(fd,len);
 168
 169   r= read(fd,buf,len);
 170   if (r==-1) {
 171     Rerrno("read");
 172   } else {
 173     vb.used= 0;
 174     Tvba("read=");
 175     Tvbbytes(buf,r);
 176     Rvb();
 177   }
 178
 179   return r;
 180 }
 181
 182 int Hwrite(int fd, const void *buf, size_t len) {
 183   int r;
 184
 185   Qwrite(fd,buf,len);
 186
 187   r= write(fd,buf,len);
 188   if (r==-1) {
 189     Rerrno("write");
 190   } else {
 191     Rf("write= %d",r);
 192   }
 193
 194   return r;
 195 }
 196
 197
 198
 199
 200
 201