_ Git - BearSSL/blob - tools/sslio.c

   1 /*
   2  * Copyright (c) 2016 Thomas Pornin <pornin@bolet.org>
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining
   5  * a copy of this software and associated documentation files (the
   6  * "Software"), to deal in the Software without restriction, including
   7  * without limitation the rights to use, copy, modify, merge, publish,
   8  * distribute, sublicense, and/or sell copies of the Software, and to
   9  * permit persons to whom the Software is furnished to do so, subject to
  10  * the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be
  13  * included in all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  16  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  17  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  18  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  19  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  20  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  21  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  22  * SOFTWARE.
  23  */
  24
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <stdint.h>
  29 #include <errno.h>
  30
  31 #ifdef _WIN32
  32 #include <winsock2.h>
  33 #include <ws2tcpip.h>
  34 #else
  35 #include <sys/types.h>
  36 #include <sys/socket.h>
  37 #include <netdb.h>
  38 #include <netinet/in.h>
  39 #include <arpa/inet.h>
  40 #include <unistd.h>
  41 #include <fcntl.h>
  42 #include <poll.h>
  43
  44 #define SOCKET           int
  45 #define INVALID_SOCKET   (-1)
  46 #endif
  47
  48 #include "brssl.h"
  49
  50 static void
  51 dump_blob(const char *name, const void *data, size_t len)
  52 {
  53         const unsigned char *buf;
  54         size_t u;
  55
  56         buf = data;
  57         fprintf(stderr, "%s (len = %lu)", name, (unsigned long)len);
  58         for (u = 0; u < len; u ++) {
  59                 if ((u & 15) == 0) {
  60                         fprintf(stderr, "\n%08lX  ", (unsigned long)u);
  61                 } else if ((u & 7) == 0) {
  62                         fprintf(stderr, " ");
  63                 }
  64                 fprintf(stderr, " %02x", buf[u]);
  65         }
  66         fprintf(stderr, "\n");
  67 }
  68
  69 /*
  70  * Inspect the provided data in case it is a "command" to trigger a
  71  * special behaviour. If the command is recognised, then it is executed
  72  * and this function returns 1. Otherwise, this function returns 0.
  73  */
  74 static int
  75 run_command(br_ssl_engine_context *cc, unsigned char *buf, size_t len)
  76 {
  77         /*
  78          * A single static slot for saving session parameters.
  79          */
  80         static br_ssl_session_parameters slot;
  81         static int slot_used = 0;
  82
  83         size_t u;
  84
  85         if (len < 2 || len > 3) {
  86                 return 0;
  87         }
  88         if (len == 3 && (buf[1] != '\r' || buf[2] != '\n')) {
  89                 return 0;
  90         }
  91         if (len == 2 && buf[1] != '\n') {
  92                 return 0;
  93         }
  94         switch (buf[0]) {
  95         case 'Q':
  96                 fprintf(stderr, "closing...\n");
  97                 br_ssl_engine_close(cc);
  98                 return 1;
  99         case 'R':
 100                 if (br_ssl_engine_renegotiate(cc)) {
 101                         fprintf(stderr, "renegotiating...\n");
 102                 } else {
 103                         fprintf(stderr, "not renegotiating.\n");
 104                 }
 105                 return 1;
 106         case 'F':
 107                 /*
 108                  * Session forget is nominally client-only. But the
 109                  * session parameters are in the engine structure, which
 110                  * is the first field of the client context, so the cast
 111                  * still works properly. On the server, this forgetting
 112                  * has no effect.
 113                  */
 114                 fprintf(stderr, "forgetting session...\n");
 115                 br_ssl_client_forget_session((br_ssl_client_context *)cc);
 116                 return 1;
 117         case 'S':
 118                 fprintf(stderr, "saving session parameters...\n");
 119                 br_ssl_engine_get_session_parameters(cc, &slot);
 120                 fprintf(stderr, "  id = ");
 121                 for (u = 0; u < slot.session_id_len; u ++) {
 122                         fprintf(stderr, "%02X", slot.session_id[u]);
 123                 }
 124                 fprintf(stderr, "\n");
 125                 slot_used = 1;
 126                 return 1;
 127         case 'P':
 128                 if (slot_used) {
 129                         fprintf(stderr, "restoring session parameters...\n");
 130                         fprintf(stderr, "  id = ");
 131                         for (u = 0; u < slot.session_id_len; u ++) {
 132                                 fprintf(stderr, "%02X", slot.session_id[u]);
 133                         }
 134                         fprintf(stderr, "\n");
 135                         br_ssl_engine_set_session_parameters(cc, &slot);
 136                         return 1;
 137                 }
 138                 return 0;
 139         default:
 140                 return 0;
 141         }
 142 }
 143
 144 #ifdef _WIN32
 145
 146 typedef struct {
 147         unsigned char buf[1024];
 148         size_t ptr, len;
 149 } in_buffer;
 150
 151 static int
 152 in_return_bytes(in_buffer *bb, unsigned char *buf, size_t len)
 153 {
 154         if (bb->ptr < bb->len) {
 155                 size_t clen;
 156
 157                 if (buf == NULL) {
 158                         return 1;
 159                 }
 160                 clen = bb->len - bb->ptr;
 161                 if (clen > len) {
 162                         clen = len;
 163                 }
 164                 memcpy(buf, bb->buf + bb->ptr, clen);
 165                 bb->ptr += clen;
 166                 if (bb->ptr == bb->len) {
 167                         bb->ptr = bb->len = 0;
 168                 }
 169                 return (int)clen;
 170         }
 171         return 0;
 172 }
 173
 174 /*
 175  * A buffered version of in_read(), using a buffer to return only
 176  * full lines when feasible.
 177  */
 178 static int
 179 in_read_buffered(HANDLE h_in, in_buffer *bb, unsigned char *buf, size_t len)
 180 {
 181         int n;
 182
 183         if (len == 0) {
 184                 return 0;
 185         }
 186         n = in_return_bytes(bb, buf, len);
 187         if (n != 0) {
 188                 return n;
 189         }
 190         for (;;) {
 191                 INPUT_RECORD inrec;
 192                 DWORD v;
 193
 194                 if (!PeekConsoleInput(h_in, &inrec, 1, &v)) {
 195                         fprintf(stderr, "ERROR: PeekConsoleInput()"
 196                                 " failed with 0x%08lX\n",
 197                                 (unsigned long)GetLastError());
 198                         return -1;
 199                 }
 200                 if (v == 0) {
 201                         return 0;
 202                 }
 203                 if (!ReadConsoleInput(h_in, &inrec, 1, &v)) {
 204                         fprintf(stderr, "ERROR: ReadConsoleInput()"
 205                                 " failed with 0x%08lX\n",
 206                                 (unsigned long)GetLastError());
 207                         return -1;
 208                 }
 209                 if (v == 0) {
 210                         return 0;
 211                 }
 212                 if (inrec.EventType == KEY_EVENT
 213                         && inrec.Event.KeyEvent.bKeyDown)
 214                 {
 215                         int c;
 216
 217                         c = inrec.Event.KeyEvent.uChar.AsciiChar;
 218                         if (c == '\n' || c == '\r' || c == '\t'
 219                                 || (c >= 32 && c != 127))
 220                         {
 221                                 if (c == '\r') {
 222                                         c = '\n';
 223                                 }
 224                                 bb->buf[bb->ptr ++] = (unsigned char)c;
 225                                 printf("%c", c);
 226                                 fflush(stdout);
 227                                 bb->len = bb->ptr;
 228                                 if (bb->len == sizeof bb->buf || c == '\n') {
 229                                         bb->ptr = 0;
 230                                         return in_return_bytes(bb, buf, len);
 231                                 }
 232                         }
 233                 }
 234         }
 235 }
 236
 237 static int
 238 in_avail_buffered(HANDLE h_in, in_buffer *bb)
 239 {
 240         return in_read_buffered(h_in, bb, NULL, 1);
 241 }
 242
 243 #endif
 244
 245 /* see brssl.h */
 246 int
 247 run_ssl_engine(br_ssl_engine_context *cc, unsigned long fd, unsigned flags)
 248 {
 249         int hsdetails;
 250         int retcode;
 251         int verbose;
 252         int trace;
 253 #ifdef _WIN32
 254         WSAEVENT fd_event;
 255         int can_send, can_recv;
 256         HANDLE h_in, h_out;
 257         in_buffer bb;
 258 #endif
 259
 260         hsdetails = 0;
 261         retcode = 0;
 262         verbose = (flags & RUN_ENGINE_VERBOSE) != 0;
 263         trace = (flags & RUN_ENGINE_TRACE) != 0;
 264
 265         /*
 266          * Print algorithm details.
 267          */
 268         if (verbose) {
 269                 fprintf(stderr, "Algorithms:\n");
 270                 if (cc->iaes_cbcenc != 0) {
 271                         fprintf(stderr, "   AES/CBC (enc): %s\n",
 272                                 get_algo_name(cc->iaes_cbcenc, 0));
 273                 }
 274                 if (cc->iaes_cbcdec != 0) {
 275                         fprintf(stderr, "   AES/CBC (dec): %s\n",
 276                                 get_algo_name(cc->iaes_cbcdec, 0));
 277                 }
 278                 if (cc->iaes_ctr != 0) {
 279                         fprintf(stderr, "   AES/CTR:       %s\n",
 280                                 get_algo_name(cc->iaes_cbcdec, 0));
 281                 }
 282                 if (cc->ides_cbcenc != 0) {
 283                         fprintf(stderr, "   DES/CBC (enc): %s\n",
 284                                 get_algo_name(cc->ides_cbcenc, 0));
 285                 }
 286                 if (cc->ides_cbcdec != 0) {
 287                         fprintf(stderr, "   DES/CBC (dec): %s\n",
 288                                 get_algo_name(cc->ides_cbcdec, 0));
 289                 }
 290                 if (cc->ighash != 0) {
 291                         fprintf(stderr, "   GHASH (GCM):   %s\n",
 292                                 get_algo_name(cc->ighash, 0));
 293                 }
 294                 if (cc->ichacha != 0) {
 295                         fprintf(stderr, "   ChaCha20:      %s\n",
 296                                 get_algo_name(cc->ichacha, 0));
 297                 }
 298                 if (cc->ipoly != 0) {
 299                         fprintf(stderr, "   Poly1305:      %s\n",
 300                                 get_algo_name(cc->ipoly, 0));
 301                 }
 302                 if (cc->iec != 0) {
 303                         fprintf(stderr, "   EC:            %s\n",
 304                                 get_algo_name(cc->iec, 0));
 305                 }
 306                 if (cc->iecdsa != 0) {
 307                         fprintf(stderr, "   ECDSA:         %s\n",
 308                                 get_algo_name(cc->iecdsa, 0));
 309                 }
 310                 if (cc->irsavrfy != 0) {
 311                         fprintf(stderr, "   RSA (vrfy):    %s\n",
 312                                 get_algo_name(cc->irsavrfy, 0));
 313                 }
 314         }
 315
 316 #ifdef _WIN32
 317         fd_event = WSA_INVALID_EVENT;
 318         can_send = 0;
 319         can_recv = 0;
 320         bb.ptr = bb.len = 0;
 321 #endif
 322
 323         /*
 324          * On Unix systems, we need to follow three descriptors:
 325          * standard input (0), standard output (1), and the socket
 326          * itself (for both read and write). This is done with a poll()
 327          * call.
 328          *
 329          * On Windows systems, we use WSAEventSelect() to associate
 330          * an event handle with the network activity, and we use
 331          * WaitForMultipleObjectsEx() on that handle and the standard
 332          * input handle, when appropriate. Standard output is assumed
 333          * to be always writeable, and standard input to be the console;
 334          * this does not work well (or at all) with redirections (to
 335          * pipes or files) but it should be enough for a debug tool
 336          * (TODO: make something that handles redirections as well).
 337          */
 338
 339 #ifdef _WIN32
 340         fd_event = WSACreateEvent();
 341         if (fd_event == WSA_INVALID_EVENT) {
 342                 fprintf(stderr, "ERROR: WSACreateEvent() failed with %d\n",
 343                         WSAGetLastError());
 344                 retcode = -2;
 345                 goto engine_exit;
 346         }
 347         WSAEventSelect(fd, fd_event, FD_READ | FD_WRITE | FD_CLOSE);
 348         h_in = GetStdHandle(STD_INPUT_HANDLE);
 349         h_out = GetStdHandle(STD_OUTPUT_HANDLE);
 350         SetConsoleMode(h_in, ENABLE_ECHO_INPUT
 351                 | ENABLE_LINE_INPUT
 352                 | ENABLE_PROCESSED_INPUT
 353                 | ENABLE_PROCESSED_OUTPUT
 354                 | ENABLE_WRAP_AT_EOL_OUTPUT);
 355 #else
 356         /*
 357          * Make sure that stdin and stdout are non-blocking.
 358          */
 359         fcntl(0, F_SETFL, O_NONBLOCK);
 360         fcntl(1, F_SETFL, O_NONBLOCK);
 361 #endif
 362
 363         /*
 364          * Perform the loop.
 365          */
 366         for (;;) {
 367                 unsigned st;
 368                 int sendrec, recvrec, sendapp, recvapp;
 369 #ifdef _WIN32
 370                 HANDLE pfd[2];
 371                 DWORD wt;
 372 #else
 373                 struct pollfd pfd[3];
 374                 int n;
 375 #endif
 376                 size_t u, k_fd, k_in, k_out;
 377                 int sendrec_ok, recvrec_ok, sendapp_ok, recvapp_ok;
 378
 379                 /*
 380                  * Get current engine state.
 381                  */
 382                 st = br_ssl_engine_current_state(cc);
 383                 if (st == BR_SSL_CLOSED) {
 384                         int err;
 385
 386                         err = br_ssl_engine_last_error(cc);
 387                         if (err == BR_ERR_OK) {
 388                                 if (verbose) {
 389                                         fprintf(stderr,
 390                                                 "SSL closed normally\n");
 391                                 }
 392                                 retcode = 0;
 393                                 goto engine_exit;
 394                         } else {
 395                                 fprintf(stderr, "ERROR: SSL error %d", err);
 396                                 retcode = err;
 397                                 if (err >= BR_ERR_SEND_FATAL_ALERT) {
 398                                         err -= BR_ERR_SEND_FATAL_ALERT;
 399                                         fprintf(stderr,
 400                                                 " (sent alert %d)\n", err);
 401                                 } else if (err >= BR_ERR_RECV_FATAL_ALERT) {
 402                                         err -= BR_ERR_RECV_FATAL_ALERT;
 403                                         fprintf(stderr,
 404                                                 " (received alert %d)\n", err);
 405                                 } else {
 406                                         const char *ename;
 407
 408                                         ename = find_error_name(err, NULL);
 409                                         if (ename == NULL) {
 410                                                 ename = "unknown";
 411                                         }
 412                                         fprintf(stderr, " (%s)\n", ename);
 413                                 }
 414                                 goto engine_exit;
 415                         }
 416                 }
 417
 418                 /*
 419                  * Compute descriptors that must be polled, depending
 420                  * on engine state.
 421                  */
 422                 sendrec = ((st & BR_SSL_SENDREC) != 0);
 423                 recvrec = ((st & BR_SSL_RECVREC) != 0);
 424                 sendapp = ((st & BR_SSL_SENDAPP) != 0);
 425                 recvapp = ((st & BR_SSL_RECVAPP) != 0);
 426                 if (verbose && sendapp && !hsdetails) {
 427                         char csn[80];
 428                         const char *pname;
 429
 430                         fprintf(stderr, "Handshake completed\n");
 431                         fprintf(stderr, "   version:               ");
 432                         switch (cc->session.version) {
 433                         case BR_SSL30:
 434                                 fprintf(stderr, "SSL 3.0");
 435                                 break;
 436                         case BR_TLS10:
 437                                 fprintf(stderr, "TLS 1.0");
 438                                 break;
 439                         case BR_TLS11:
 440                                 fprintf(stderr, "TLS 1.1");
 441                                 break;
 442                         case BR_TLS12:
 443                                 fprintf(stderr, "TLS 1.2");
 444                                 break;
 445                         default:
 446                                 fprintf(stderr, "unknown (0x%04X)",
 447                                         (unsigned)cc->session.version);
 448                                 break;
 449                         }
 450                         fprintf(stderr, "\n");
 451                         get_suite_name_ext(
 452                                 cc->session.cipher_suite, csn, sizeof csn);
 453                         fprintf(stderr, "   cipher suite:          %s\n", csn);
 454                         if (uses_ecdhe(cc->session.cipher_suite)) {
 455                                 get_curve_name_ext(
 456                                         br_ssl_engine_get_ecdhe_curve(cc),
 457                                         csn, sizeof csn);
 458                                 fprintf(stderr,
 459                                         "   ECDHE curve:           %s\n", csn);
 460                         }
 461                         fprintf(stderr, "   secure renegotiation:  %s\n",
 462                                 cc->reneg == 1 ? "no" : "yes");
 463                         pname = br_ssl_engine_get_selected_protocol(cc);
 464                         if (pname != NULL) {
 465                                 fprintf(stderr,
 466                                         "   protocol name (ALPN):  %s\n",
 467                                         pname);
 468                         }
 469                         hsdetails = 1;
 470                 }
 471
 472                 k_fd = (size_t)-1;
 473                 k_in = (size_t)-1;
 474                 k_out = (size_t)-1;
 475
 476                 u = 0;
 477 #ifdef _WIN32
 478                 /*
 479                  * If we recorded that we can send or receive data, and we
 480                  * want to do exactly that, then we don't wait; we just do
 481                  * it.
 482                  */
 483                 recvapp_ok = 0;
 484                 sendrec_ok = 0;
 485                 recvrec_ok = 0;
 486                 sendapp_ok = 0;
 487
 488                 if (sendrec && can_send) {
 489                         sendrec_ok = 1;
 490                 } else if (recvrec && can_recv) {
 491                         recvrec_ok = 1;
 492                 } else if (recvapp) {
 493                         recvapp_ok = 1;
 494                 } else if (sendapp && in_avail_buffered(h_in, &bb)) {
 495                         sendapp_ok = 1;
 496                 } else {
 497                         /*
 498                          * If we cannot do I/O right away, then we must
 499                          * wait for some event, and try again.
 500                          */
 501                         pfd[u] = (HANDLE)fd_event;
 502                         k_fd = u;
 503                         u ++;
 504                         if (sendapp) {
 505                                 pfd[u] = h_in;
 506                                 k_in = u;
 507                                 u ++;
 508                         }
 509                         wt = WaitForMultipleObjectsEx(u, pfd,
 510                                 FALSE, INFINITE, FALSE);
 511                         if (wt == WAIT_FAILED) {
 512                                 fprintf(stderr, "ERROR:"
 513                                         " WaitForMultipleObjectsEx()"
 514                                         " failed with 0x%08lX",
 515                                         (unsigned long)GetLastError());
 516                                 retcode = -2;
 517                                 goto engine_exit;
 518                         }
 519                         if (wt == k_fd) {
 520                                 WSANETWORKEVENTS e;
 521
 522                                 if (WSAEnumNetworkEvents(fd, fd_event, &e)) {
 523                                         fprintf(stderr, "ERROR:"
 524                                                 " WSAEnumNetworkEvents()"
 525                                                 " failed with %d\n",
 526                                                 WSAGetLastError());
 527                                         retcode = -2;
 528                                         goto engine_exit;
 529                                 }
 530                                 if (e.lNetworkEvents & (FD_WRITE | FD_CLOSE)) {
 531                                         can_send = 1;
 532                                 }
 533                                 if (e.lNetworkEvents & (FD_READ | FD_CLOSE)) {
 534                                         can_recv = 1;
 535                                 }
 536                         }
 537                         continue;
 538                 }
 539 #else
 540                 if (sendrec || recvrec) {
 541                         pfd[u].fd = fd;
 542                         pfd[u].revents = 0;
 543                         pfd[u].events = 0;
 544                         if (sendrec) {
 545                                 pfd[u].events |= POLLOUT;
 546                         }
 547                         if (recvrec) {
 548                                 pfd[u].events |= POLLIN;
 549                         }
 550                         k_fd = u;
 551                         u ++;
 552                 }
 553                 if (sendapp) {
 554                         pfd[u].fd = 0;
 555                         pfd[u].revents = 0;
 556                         pfd[u].events = POLLIN;
 557                         k_in = u;
 558                         u ++;
 559                 }
 560                 if (recvapp) {
 561                         pfd[u].fd = 1;
 562                         pfd[u].revents = 0;
 563                         pfd[u].events = POLLOUT;
 564                         k_out = u;
 565                         u ++;
 566                 }
 567                 n = poll(pfd, u, -1);
 568                 if (n < 0) {
 569                         if (errno == EINTR) {
 570                                 continue;
 571                         }
 572                         perror("ERROR: poll()");
 573                         retcode = -2;
 574                         goto engine_exit;
 575                 }
 576                 if (n == 0) {
 577                         continue;
 578                 }
 579
 580                 /*
 581                  * We transform closures/errors into read+write accesses
 582                  * so as to force the read() or write() call that will
 583                  * detect the situation.
 584                  */
 585                 while (u -- > 0) {
 586                         if (pfd[u].revents & (POLLERR | POLLHUP)) {
 587                                 pfd[u].revents |= POLLIN | POLLOUT;
 588                         }
 589                 }
 590
 591                 recvapp_ok = recvapp && (pfd[k_out].revents & POLLOUT) != 0;
 592                 sendrec_ok = sendrec && (pfd[k_fd].revents & POLLOUT) != 0;
 593                 recvrec_ok = recvrec && (pfd[k_fd].revents & POLLIN) != 0;
 594                 sendapp_ok = sendapp && (pfd[k_in].revents & POLLIN) != 0;
 595 #endif
 596
 597                 /*
 598                  * We give preference to outgoing data, on stdout and on
 599                  * the socket.
 600                  */
 601                 if (recvapp_ok) {
 602                         unsigned char *buf;
 603                         size_t len;
 604 #ifdef _WIN32
 605                         DWORD wlen;
 606 #else
 607                         ssize_t wlen;
 608 #endif
 609
 610                         buf = br_ssl_engine_recvapp_buf(cc, &len);
 611 #ifdef _WIN32
 612                         if (!WriteFile(h_out, buf, len, &wlen, NULL)) {
 613                                 if (verbose) {
 614                                         fprintf(stderr, "stdout closed...\n");
 615                                 }
 616                                 retcode = -2;
 617                                 goto engine_exit;
 618                         }
 619 #else
 620                         wlen = write(1, buf, len);
 621                         if (wlen <= 0) {
 622                                 if (verbose) {
 623                                         fprintf(stderr, "stdout closed...\n");
 624                                 }
 625                                 retcode = -2;
 626                                 goto engine_exit;
 627                         }
 628 #endif
 629                         br_ssl_engine_recvapp_ack(cc, wlen);
 630                         continue;
 631                 }
 632                 if (sendrec_ok) {
 633                         unsigned char *buf;
 634                         size_t len;
 635                         int wlen;
 636
 637                         buf = br_ssl_engine_sendrec_buf(cc, &len);
 638                         wlen = send(fd, buf, len, 0);
 639                         if (wlen <= 0) {
 640 #ifdef _WIN32
 641                                 int err;
 642
 643                                 err = WSAGetLastError();
 644                                 if (err == EWOULDBLOCK
 645                                         || err == WSAEWOULDBLOCK)
 646                                 {
 647                                         can_send = 0;
 648                                         continue;
 649                                 }
 650 #else
 651                                 if (errno == EINTR || errno == EWOULDBLOCK) {
 652                                         continue;
 653                                 }
 654 #endif
 655                                 if (verbose) {
 656                                         fprintf(stderr, "socket closed...\n");
 657                                 }
 658                                 retcode = -1;
 659                                 goto engine_exit;
 660                         }
 661                         if (trace) {
 662                                 dump_blob("Outgoing bytes", buf, wlen);
 663                         }
 664                         br_ssl_engine_sendrec_ack(cc, wlen);
 665                         continue;
 666                 }
 667                 if (recvrec_ok) {
 668                         unsigned char *buf;
 669                         size_t len;
 670                         int rlen;
 671
 672                         buf = br_ssl_engine_recvrec_buf(cc, &len);
 673                         rlen = recv(fd, buf, len, 0);
 674                         if (rlen == 0) {
 675                                 if (verbose) {
 676                                         fprintf(stderr, "socket closed...\n");
 677                                 }
 678                                 retcode = -1;
 679                                 goto engine_exit;
 680                         }
 681                         if (rlen < 0) {
 682 #ifdef _WIN32
 683                                 int err;
 684
 685                                 err = WSAGetLastError();
 686                                 if (err == EWOULDBLOCK
 687                                         || err == WSAEWOULDBLOCK)
 688                                 {
 689                                         can_recv = 0;
 690                                         continue;
 691                                 }
 692 #else
 693                                 if (errno == EINTR || errno == EWOULDBLOCK) {
 694                                         continue;
 695                                 }
 696 #endif
 697                                 if (verbose) {
 698                                         fprintf(stderr, "socket broke...\n");
 699                                 }
 700                                 retcode = -1;
 701                                 goto engine_exit;
 702                         }
 703                         if (trace) {
 704                                 dump_blob("Incoming bytes", buf, rlen);
 705                         }
 706                         br_ssl_engine_recvrec_ack(cc, rlen);
 707                         continue;
 708                 }
 709                 if (sendapp_ok) {
 710                         unsigned char *buf;
 711                         size_t len;
 712 #ifdef _WIN32
 713                         int rlen;
 714 #else
 715                         ssize_t rlen;
 716 #endif
 717
 718                         buf = br_ssl_engine_sendapp_buf(cc, &len);
 719 #ifdef _WIN32
 720                         rlen = in_read_buffered(h_in, &bb, buf, len);
 721 #else
 722                         rlen = read(0, buf, len);
 723 #endif
 724                         if (rlen <= 0) {
 725                                 if (verbose) {
 726                                         fprintf(stderr, "stdin closed...\n");
 727                                 }
 728                                 br_ssl_engine_close(cc);
 729                         } else if (!run_command(cc, buf, rlen)) {
 730                                 br_ssl_engine_sendapp_ack(cc, rlen);
 731                         }
 732                         br_ssl_engine_flush(cc, 0);
 733                         continue;
 734                 }
 735
 736                 /* We should never reach that point. */
 737                 fprintf(stderr, "ERROR: poll() misbehaves\n");
 738                 retcode = -2;
 739                 goto engine_exit;
 740         }
 741
 742         /*
 743          * Release allocated structures.
 744          */
 745 engine_exit:
 746 #ifdef _WIN32
 747         if (fd_event != WSA_INVALID_EVENT) {
 748                 WSACloseEvent(fd_event);
 749         }
 750 #endif
 751         return retcode;
 752 }