tests/eagain-common.h

   1 #define min(x,y) ((x)<(y)?(x):(y))
   2
   3 extern const char* side;
   4
   5 #define HANDSHAKE_EXPECT(c, s, clierr, serverr) \
   6   sret = cret = GNUTLS_E_AGAIN; \
   7   do \
   8     { \
   9       if (cret == GNUTLS_E_AGAIN) \
  10         { \
  11           side = "client"; \
  12           cret = gnutls_handshake (c); \
  13         } \
  14       if (sret == GNUTLS_E_AGAIN) \
  15         { \
  16           side = "server"; \
  17           sret = gnutls_handshake (s); \
  18         } \
  19     } \
  20   while ((cret == GNUTLS_E_AGAIN || (cret == 0 && sret == GNUTLS_E_AGAIN)) && (sret == GNUTLS_E_AGAIN || (sret == 0 && cret == GNUTLS_E_AGAIN))); \
  21   if (cret != clierr || sret != serverr) \
  22     { \
  23       fprintf(stderr, "client: %s\n", gnutls_strerror(cret)); \
  24       fprintf(stderr, "server: %s\n", gnutls_strerror(sret)); \
  25       fail("Handshake failed\n"); \
  26       exit(1); \
  27     }
  28
  29 #define HANDSHAKE(c, s) \
  30   HANDSHAKE_EXPECT(c,s,0,0)
  31
  32 #define TRANSFER(c, s, msg, msglen, buf, buflen) \
  33   do \
  34     { \
  35       side = "client"; \
  36       ret = gnutls_record_send (c, msg, msglen); \
  37     } \
  38   while(ret == GNUTLS_E_AGAIN); \
  39   \
  40   if (ret < 0) fail ("client send error: %s\n", gnutls_strerror (ret)); \
  41   \
  42   do \
  43     { \
  44       do \
  45         { \
  46           side = "server"; \
  47           ret = gnutls_record_recv (s, buf, buflen); \
  48         } \
  49       while(ret == GNUTLS_E_AGAIN); \
  50       if (ret == 0) \
  51         fail ("server: didn't receive any data\n"); \
  52       else if (ret < 0) \
  53         { \
  54           fail ("server: error: %s\n", gnutls_strerror (ret)); \
  55         } \
  56       else \
  57         { \
  58           transferred += ret; \
  59         } \
  60       do \
  61         { \
  62           side = "server"; \
  63           ns = gnutls_record_send (server, msg, msglen); \
  64         } \
  65       while (ns == GNUTLS_E_AGAIN); \
  66       if (ns < 0) fail ("server send error: %s\n", gnutls_strerror (ret)); \
  67       do \
  68         { \
  69           side = "client"; \
  70           ret = gnutls_record_recv (client, buf, buflen); \
  71         } \
  72       while(ret == GNUTLS_E_AGAIN); \
  73       if (ret == 0) \
  74         { \
  75           fail ("client: Peer has closed the TLS connection\n"); \
  76         } \
  77       else if (ret < 0) \
  78         { \
  79           if (debug) \
  80             fputs ("!", stdout); \
  81           fail ("client: Error: %s\n", gnutls_strerror (ret)); \
  82         } \
  83       else \
  84         { \
  85           if (msglen != ret || memcmp (buf, msg, msglen) != 0) \
  86             { \
  87               fail ("client: Transmitted data do not match\n"); \
  88             } \
  89           /* echo back */ \
  90           do \
  91             { \
  92               side = "client"; \
  93               ns = gnutls_record_send (client, buf, msglen); \
  94             } \
  95           while (ns == GNUTLS_E_AGAIN); \
  96           if (ns < 0) fail ("client send error: %s\n", gnutls_strerror (ret)); \
  97           transferred += ret; \
  98           if (debug) \
  99             fputs (".", stdout); \
 100         } \
 101     } \
 102   while (transferred < 70000)
 103
 104 static char to_server[64*1024];
 105 static size_t to_server_len = 0;
 106
 107 static char to_client[64*1024];
 108 static size_t to_client_len = 0;
 109
 110 #ifdef RANDOMIZE
 111 #define RETURN_RND_EAGAIN(session) \
 112   static unsigned char rnd = 0; \
 113   if (rnd++ % 2 == 0) \
 114     { \
 115       gnutls_transport_set_errno (session, EAGAIN); \
 116       return -1; \
 117     }
 118 #else
 119 #define RETURN_RND_EAGAIN(session)
 120 #endif
 121
 122 static ssize_t
 123 client_push (gnutls_transport_ptr_t tr, const void *data, size_t len)
 124 {
 125   size_t newlen;
 126   RETURN_RND_EAGAIN(tr);
 127
 128   len = min(len, sizeof(to_server)-to_server_len);
 129
 130   newlen = to_server_len + len;
 131   memcpy (to_server + to_server_len, data, len);
 132   to_server_len = newlen;
 133 #ifdef EAGAIN_DEBUG
 134   fprintf(stderr, "eagain: pushed %d bytes to server (avail: %d)\n", (int)len, (int)to_server_len);
 135 #endif
 136   return len;
 137 }
 138
 139 static ssize_t
 140 client_pull (gnutls_transport_ptr_t tr, void *data, size_t len)
 141 {
 142   RETURN_RND_EAGAIN(tr);
 143
 144   if (to_client_len == 0)
 145     {
 146 #ifdef EAGAIN_DEBUG
 147       fprintf(stderr, "eagain: Not enough data by server (asked for: %d, have: %d)\n", (int)len, (int)to_client_len);
 148 #endif
 149       gnutls_transport_set_errno ((gnutls_session_t)tr, EAGAIN);
 150       return -1;
 151     }
 152
 153   len = min(len, to_client_len);
 154
 155   memcpy (data, to_client, len);
 156
 157   memmove (to_client, to_client + len, to_client_len - len);
 158   to_client_len -= len;
 159 #ifdef EAGAIN_DEBUG
 160   fprintf(stderr, "eagain: pulled %d bytes by client (avail: %d)\n", (int)len, (int)to_client_len);
 161 #endif
 162   return len;
 163 }
 164
 165 static ssize_t
 166 server_pull (gnutls_transport_ptr_t tr, void *data, size_t len)
 167 {
 168   //success ("server_pull len %d has %d\n", len, to_server_len);
 169   RETURN_RND_EAGAIN(tr);
 170
 171   if (to_server_len == 0)
 172     {
 173 #ifdef EAGAIN_DEBUG
 174       fprintf(stderr, "eagain: Not enough data by client (asked for: %d, have: %d)\n", (int)len, (int)to_server_len);
 175 #endif
 176       gnutls_transport_set_errno ((gnutls_session_t)tr, EAGAIN);
 177       return -1;
 178     }
 179
 180   len = min(len, to_server_len);
 181 #ifdef EAGAIN_DEBUG
 182   fprintf(stderr, "eagain: pulled %d bytes by server (avail: %d)\n", (int)len, (int)to_server_len);
 183 #endif
 184   memcpy (data, to_server, len);
 185
 186   memmove (to_server, to_server + len, to_server_len - len);
 187   to_server_len -= len;
 188
 189   return len;
 190 }
 191
 192 static ssize_t
 193 server_push (gnutls_transport_ptr_t tr, const void *data, size_t len)
 194 {
 195   size_t newlen;
 196   RETURN_RND_EAGAIN(tr);
 197
 198 //  hexprint (data, len);
 199
 200   len = min(len, sizeof(to_client)-to_client_len);
 201
 202   newlen = to_client_len + len;
 203   memcpy (to_client + to_client_len, data, len);
 204   to_client_len = newlen;
 205 #ifdef EAGAIN_DEBUG
 206   fprintf(stderr, "eagain: pushed %d bytes to client (avail: %d)\n", (int)len, (int)to_client_len);
 207 #endif
 208
 209   return len;
 210 }
 211
 212 /* inline is used to avoid a gcc warning if used in mini-eagain */
 213 inline static int server_pull_timeout_func(gnutls_transport_ptr_t ptr, unsigned int ms)
 214 {
 215 int ret;
 216
 217   if (to_server_len > 0)
 218     ret = 1; /* available data */
 219   else
 220     ret = 0; /* timeout */
 221
 222 #ifdef EAGAIN_DEBUG
 223   fprintf(stderr, "eagain: server_pull_timeout: %d (avail: cli %d, serv %d)\n", ret, (int)to_client_len, (int)to_server_len);
 224 #endif
 225
 226   return ret;
 227 }
 228
 229 inline static int client_pull_timeout_func(gnutls_transport_ptr_t ptr, unsigned int ms)
 230 {
 231 int ret;
 232
 233   if (to_client_len > 0)
 234     ret = 1;
 235   else
 236     ret = 0;
 237
 238 #ifdef EAGAIN_DEBUG
 239   fprintf(stderr, "eagain: client_pull_timeout: %d (avail: cli %d, serv %d)\n", ret, (int)to_client_len, (int)to_server_len);
 240 #endif
 241
 242   return ret;
 243 }
 244
 245 inline static void reset_buffers(void)
 246 {
 247   to_server_len = 0;
 248   to_client_len = 0;
 249 }