lib/vconn-ssl.c

   1 /* Copyright (C) 2008 Board of Trustees, Leland Stanford Jr. University.
   2  *
   3  * Permission is hereby granted, free of charge, to any person obtaining a copy
   4  * of this software and associated documentation files (the "Software"), to
   5  * deal in the Software without restriction, including without limitation the
   6  * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
   7  * sell copies of the Software, and to permit persons to whom the Software is
   8  * furnished to do so, subject to the following conditions:
   9  *
  10  * The above copyright notice and this permission notice shall be included in
  11  * all copies or substantial portions of the Software.
  12  *
  13  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  14  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  15  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  16  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  17  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  18  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  19  * IN THE SOFTWARE.
  20  */
  21
  22 #include "vconn-ssl.h"
  23 #include "dhparams.h"
  24 #include <assert.h>
  25 #include <errno.h>
  26 #include <string.h>
  27 #include <netinet/tcp.h>
  28 #include <openssl/err.h>
  29 #include <openssl/ssl.h>
  30 #include <poll.h>
  31 #include <unistd.h>
  32 #include "buffer.h"
  33 #include "socket-util.h"
  34 #include "util.h"
  35 #include "openflow.h"
  36 #include "poll-loop.h"
  37 #include "ofp-print.h"
  38 #include "socket-util.h"
  39 #include "vconn.h"
  40
  41 #include "vlog.h"
  42 #define THIS_MODULE VLM_vconn_ssl
  43
  44 /* Active SSL. */
  45
  46 enum ssl_state {
  47     STATE_TCP_CONNECTING,
  48     STATE_SSL_CONNECTING
  49 };
  50
  51 enum session_type {
  52     CLIENT,
  53     SERVER
  54 };
  55
  56 struct ssl_vconn
  57 {
  58     struct vconn vconn;
  59     enum ssl_state state;
  60     int connect_error;
  61     enum session_type type;
  62     int fd;
  63     SSL *ssl;
  64     struct buffer *rxbuf;
  65     struct buffer *txbuf;
  66     struct poll_waiter *tx_waiter;
  67 };
  68
  69 /* SSL context created by ssl_init(). */
  70 static SSL_CTX *ctx;
  71
  72 /* Required configuration. */
  73 static bool has_private_key, has_certificate, has_ca_cert;
  74
  75 static int ssl_init(void);
  76 static int do_ssl_init(void);
  77 static bool ssl_wants_io(int ssl_error);
  78 static void ssl_close(struct vconn *);
  79 static int interpret_ssl_error(const char *function, int ret, int error);
  80 static void ssl_do_tx(int fd, short int revents, void *vconn_);
  81 static DH *tmp_dh_callback(SSL *ssl, int is_export UNUSED, int keylength);
  82
  83 static int
  84 new_ssl_vconn(const char *name, int fd, enum session_type type,
  85               enum ssl_state state, struct vconn **vconnp)
  86 {
  87     struct ssl_vconn *sslv;
  88     SSL *ssl = NULL;
  89     int on = 1;
  90     int retval;
  91
  92     /* Check for all the needful configuration. */
  93     if (!has_private_key) {
  94         VLOG_ERR("Private key must be configured to use SSL");
  95         goto error;
  96     }
  97     if (!has_certificate) {
  98         VLOG_ERR("Certificate must be configured to use SSL");
  99         goto error;
 100     }
 101     if (!has_ca_cert) {
 102         VLOG_ERR("CA certificate must be configured to use SSL");
 103         goto error;
 104     }
 105     if (!SSL_CTX_check_private_key(ctx)) {
 106         VLOG_ERR("Private key does not match certificate public key");
 107         goto error;
 108     }
 109
 110     /* Disable Nagle. */
 111     retval = setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &on, sizeof on);
 112     if (retval) {
 113         VLOG_ERR("%s: setsockopt(TCP_NODELAY): %s", name, strerror(errno));
 114         close(fd);
 115         return errno;
 116     }
 117
 118     /* Create and configure OpenSSL stream. */
 119     ssl = SSL_new(ctx);
 120     if (ssl == NULL) {
 121         VLOG_ERR("SSL_new: %s", ERR_error_string(ERR_get_error(), NULL));
 122         close(fd);
 123         return ENOPROTOOPT;
 124     }
 125     if (SSL_set_fd(ssl, fd) == 0) {
 126         VLOG_ERR("SSL_set_fd: %s", ERR_error_string(ERR_get_error(), NULL));
 127         goto error;
 128     }
 129
 130     /* Create and return the ssl_vconn. */
 131     sslv = xmalloc(sizeof *sslv);
 132     sslv->vconn.class = &ssl_vconn_class;
 133     sslv->vconn.connect_status = EAGAIN;
 134     sslv->state = state;
 135     sslv->type = type;
 136     sslv->fd = fd;
 137     sslv->ssl = ssl;
 138     sslv->rxbuf = NULL;
 139     sslv->txbuf = NULL;
 140     sslv->tx_waiter = NULL;
 141     *vconnp = &sslv->vconn;
 142     return 0;
 143
 144 error:
 145     if (ssl) {
 146         SSL_free(ssl);
 147     }
 148     close(fd);
 149     return ENOPROTOOPT;
 150 }
 151
 152 static struct ssl_vconn *
 153 ssl_vconn_cast(struct vconn *vconn)
 154 {
 155     assert(vconn->class == &ssl_vconn_class);
 156     return CONTAINER_OF(vconn, struct ssl_vconn, vconn);
 157 }
 158
 159 static int
 160 ssl_open(const char *name, char *suffix, struct vconn **vconnp)
 161 {
 162     char *save_ptr, *host_name, *port_string;
 163     struct sockaddr_in sin;
 164     int retval;
 165     int fd;
 166
 167     retval = ssl_init();
 168     if (retval) {
 169         return retval;
 170     }
 171
 172     /* Glibc 2.7 has a bug in strtok_r when compiling with optimization that
 173      * can cause segfaults here:
 174      * http://sources.redhat.com/bugzilla/show_bug.cgi?id=5614.
 175      * Using "::" instead of the obvious ":" works around it. */
 176     host_name = strtok_r(suffix, "::", &save_ptr);
 177     port_string = strtok_r(NULL, "::", &save_ptr);
 178     if (!host_name) {
 179         fatal(0, "%s: bad peer name format", name);
 180     }
 181
 182     memset(&sin, 0, sizeof sin);
 183     sin.sin_family = AF_INET;
 184     if (lookup_ip(host_name, &sin.sin_addr)) {
 185         return ENOENT;
 186     }
 187     sin.sin_port = htons(port_string && *port_string ? atoi(port_string)
 188                          : OFP_SSL_PORT);
 189
 190     /* Create socket. */
 191     fd = socket(AF_INET, SOCK_STREAM, 0);
 192     if (fd < 0) {
 193         VLOG_ERR("%s: socket: %s", name, strerror(errno));
 194         return errno;
 195     }
 196     retval = set_nonblocking(fd);
 197     if (retval) {
 198         close(fd);
 199         return retval;
 200     }
 201
 202     /* Connect socket. */
 203     retval = connect(fd, (struct sockaddr *) &sin, sizeof sin);
 204     if (retval < 0) {
 205         if (errno == EINPROGRESS) {
 206             return new_ssl_vconn(name, fd, CLIENT, STATE_TCP_CONNECTING,
 207                                  vconnp);
 208         } else {
 209             int error = errno;
 210             VLOG_ERR("%s: connect: %s", name, strerror(error));
 211             close(fd);
 212             return error;
 213         }
 214     } else {
 215         return new_ssl_vconn(name, fd, CLIENT, STATE_SSL_CONNECTING,
 216                              vconnp);
 217     }
 218 }
 219
 220 static int
 221 ssl_connect(struct vconn *vconn)
 222 {
 223     struct ssl_vconn *sslv = ssl_vconn_cast(vconn);
 224     int retval;
 225
 226     switch (sslv->state) {
 227     case STATE_TCP_CONNECTING:
 228         retval = check_connection_completion(sslv->fd);
 229         if (retval) {
 230             return retval;
 231         }
 232         sslv->state = STATE_SSL_CONNECTING;
 233         /* Fall through. */
 234
 235     case STATE_SSL_CONNECTING:
 236         retval = (sslv->type == CLIENT
 237                    ? SSL_connect(sslv->ssl) : SSL_accept(sslv->ssl));
 238         if (retval != 1) {
 239             int error = SSL_get_error(sslv->ssl, retval);
 240             if (retval < 0 && ssl_wants_io(error)) {
 241                 return EAGAIN;
 242             } else {
 243                 interpret_ssl_error((sslv->type == CLIENT ? "SSL_connect"
 244                                      : "SSL_accept"), retval, error);
 245                 shutdown(sslv->fd, SHUT_RDWR);
 246                 return EPROTO;
 247             }
 248         } else {
 249             return 0;
 250         }
 251     }
 252
 253     NOT_REACHED();
 254 }
 255
 256 static void
 257 ssl_close(struct vconn *vconn)
 258 {
 259     struct ssl_vconn *sslv = ssl_vconn_cast(vconn);
 260     poll_cancel(sslv->tx_waiter);
 261     SSL_free(sslv->ssl);
 262     close(sslv->fd);
 263     free(sslv);
 264 }
 265
 266 static int
 267 interpret_ssl_error(const char *function, int ret, int error)
 268 {
 269     switch (error) {
 270     case SSL_ERROR_NONE:
 271         VLOG_ERR("%s: unexpected SSL_ERROR_NONE", function);
 272         break;
 273
 274     case SSL_ERROR_ZERO_RETURN:
 275         VLOG_ERR("%s: unexpected SSL_ERROR_ZERO_RETURN", function);
 276         break;
 277
 278     case SSL_ERROR_WANT_READ:
 279     case SSL_ERROR_WANT_WRITE:
 280         return EAGAIN;
 281
 282     case SSL_ERROR_WANT_CONNECT:
 283         VLOG_ERR("%s: unexpected SSL_ERROR_WANT_CONNECT", function);
 284         break;
 285
 286     case SSL_ERROR_WANT_ACCEPT:
 287         VLOG_ERR("%s: unexpected SSL_ERROR_WANT_ACCEPT", function);
 288         break;
 289
 290     case SSL_ERROR_WANT_X509_LOOKUP:
 291         VLOG_ERR("%s: unexpected SSL_ERROR_WANT_X509_LOOKUP", function);
 292         break;
 293
 294     case SSL_ERROR_SYSCALL: {
 295         int queued_error = ERR_get_error();
 296         if (queued_error == 0) {
 297             if (ret < 0) {
 298                 int status = errno;
 299                 VLOG_WARN("%s: system error (%s)", function, strerror(status));
 300                 return status;
 301             } else {
 302                 VLOG_WARN("%s: unexpected SSL connection close", function);
 303                 return EPROTO;
 304             }
 305         } else {
 306             VLOG_DBG("%s: %s", function, ERR_error_string(queued_error, NULL));
 307             break;
 308         }
 309     }
 310
 311     case SSL_ERROR_SSL: {
 312         int queued_error = ERR_get_error();
 313         if (queued_error != 0) {
 314             VLOG_DBG("%s: %s", function, ERR_error_string(queued_error, NULL));
 315         } else {
 316             VLOG_ERR("%s: SSL_ERROR_SSL without queued error", function);
 317         }
 318         break;
 319     }
 320
 321     default:
 322         VLOG_ERR("%s: bad SSL error code %d", function, error);
 323         break;
 324     }
 325     return EIO;
 326 }
 327
 328 static int
 329 ssl_recv(struct vconn *vconn, struct buffer **bufferp)
 330 {
 331     struct ssl_vconn *sslv = ssl_vconn_cast(vconn);
 332     struct buffer *rx;
 333     size_t want_bytes;
 334     ssize_t ret;
 335
 336     if (sslv->rxbuf == NULL) {
 337         sslv->rxbuf = buffer_new(1564);
 338     }
 339     rx = sslv->rxbuf;
 340
 341 again:
 342     if (sizeof(struct ofp_header) > rx->size) {
 343         want_bytes = sizeof(struct ofp_header) - rx->size;
 344     } else {
 345         struct ofp_header *oh = rx->data;
 346         size_t length = ntohs(oh->length);
 347         if (length < sizeof(struct ofp_header)) {
 348             VLOG_ERR("received too-short ofp_header (%zu bytes)", length);
 349             return EPROTO;
 350         }
 351         want_bytes = length - rx->size;
 352     }
 353     buffer_reserve_tailroom(rx, want_bytes);
 354
 355     /* Behavior of zero-byte SSL_read is poorly defined. */
 356     assert(want_bytes > 0);
 357
 358     ret = SSL_read(sslv->ssl, buffer_tail(rx), want_bytes);
 359     if (ret > 0) {
 360         rx->size += ret;
 361         if (ret == want_bytes) {
 362             if (rx->size > sizeof(struct ofp_header)) {
 363                 *bufferp = rx;
 364                 sslv->rxbuf = NULL;
 365                 return 0;
 366             } else {
 367                 goto again;
 368             }
 369         }
 370         return EAGAIN;
 371     } else {
 372         int error = SSL_get_error(sslv->ssl, ret);
 373         if (error == SSL_ERROR_ZERO_RETURN) {
 374             /* Connection closed (EOF). */
 375             if (rx->size) {
 376                 VLOG_WARN("SSL_read: unexpected connection close");
 377                 return EPROTO;
 378             } else {
 379                 return EOF;
 380             }
 381         } else {
 382             return interpret_ssl_error("SSL_read", ret, error);
 383         }
 384     }
 385 }
 386
 387 static void
 388 ssl_clear_txbuf(struct ssl_vconn *sslv)
 389 {
 390     buffer_delete(sslv->txbuf);
 391     sslv->txbuf = NULL;
 392     sslv->tx_waiter = NULL;
 393 }
 394
 395 static void
 396 ssl_register_tx_waiter(struct vconn *vconn)
 397 {
 398     struct ssl_vconn *sslv = ssl_vconn_cast(vconn);
 399     short int events = SSL_want_read(sslv->ssl) ? POLLIN : POLLOUT;
 400     sslv->tx_waiter = poll_fd_callback(sslv->fd, events, ssl_do_tx, vconn);
 401 }
 402
 403 static void
 404 ssl_do_tx(int fd UNUSED, short int revents UNUSED, void *vconn_)
 405 {
 406     struct vconn *vconn = vconn_;
 407     struct ssl_vconn *sslv = ssl_vconn_cast(vconn);
 408     int ret = SSL_write(sslv->ssl, sslv->txbuf->data, sslv->txbuf->size);
 409     if (ret > 0) {
 410         buffer_pull(sslv->txbuf, ret);
 411         if (sslv->txbuf->size == 0) {
 412             ssl_clear_txbuf(sslv);
 413             return;
 414         }
 415     } else {
 416         int error = SSL_get_error(sslv->ssl, ret);
 417         if (error == SSL_ERROR_ZERO_RETURN) {
 418             /* Connection closed (EOF). */
 419             VLOG_WARN("SSL_write: connection close");
 420         } else if (interpret_ssl_error("SSL_write", ret, error) != EAGAIN) {
 421             ssl_clear_txbuf(sslv);
 422             return;
 423         }
 424     }
 425     ssl_register_tx_waiter(vconn);
 426 }
 427
 428 static int
 429 ssl_send(struct vconn *vconn, struct buffer *buffer)
 430 {
 431     struct ssl_vconn *sslv = ssl_vconn_cast(vconn);
 432     ssize_t ret;
 433
 434     if (sslv->txbuf) {
 435         return EAGAIN;
 436     }
 437
 438     ret = SSL_write(sslv->ssl, buffer->data, buffer->size);
 439     if (ret > 0) {
 440         if (ret == buffer->size) {
 441             buffer_delete(buffer);
 442         } else {
 443             sslv->txbuf = buffer;
 444             buffer_pull(buffer, ret);
 445             ssl_register_tx_waiter(vconn);
 446         }
 447         return 0;
 448     } else {
 449         int error = SSL_get_error(sslv->ssl, ret);
 450         if (error == SSL_ERROR_ZERO_RETURN) {
 451             /* Connection closed (EOF). */
 452             VLOG_WARN("SSL_write: connection close");
 453             return EPIPE;
 454         } else {
 455             return interpret_ssl_error("SSL_write", ret, error);
 456         }
 457     }
 458 }
 459
 460 static bool
 461 ssl_needs_wait(struct ssl_vconn *sslv)
 462 {
 463     if (SSL_want_read(sslv->ssl)) {
 464         poll_fd_wait(sslv->fd, POLLIN, NULL);
 465         return true;
 466     } else if (SSL_want_write(sslv->ssl)) {
 467         poll_fd_wait(sslv->fd, POLLOUT, NULL);
 468         return true;
 469     } else {
 470         return false;
 471     }
 472 }
 473
 474 static void
 475 ssl_wait(struct vconn *vconn, enum vconn_wait_type wait)
 476 {
 477     struct ssl_vconn *sslv = ssl_vconn_cast(vconn);
 478
 479     switch (wait) {
 480     case WAIT_CONNECT:
 481         if (vconn_connect(vconn) != EAGAIN) {
 482             poll_immediate_wake();
 483         } else if (sslv->state == STATE_TCP_CONNECTING) {
 484             poll_fd_wait(sslv->fd, POLLOUT, NULL);
 485         } else if (!ssl_needs_wait(sslv)) {
 486             NOT_REACHED();
 487         }
 488         break;
 489
 490     case WAIT_RECV:
 491         if (!ssl_needs_wait(sslv)) {
 492             if (SSL_pending(sslv->ssl)) {
 493                 poll_immediate_wake();
 494             } else {
 495                 poll_fd_wait(sslv->fd, POLLIN, NULL);
 496             }
 497         }
 498         break;
 499
 500     case WAIT_SEND:
 501         if (!sslv->txbuf && !ssl_needs_wait(sslv)) {
 502             poll_fd_wait(sslv->fd, POLLOUT, NULL);
 503         }
 504         break;
 505
 506     default:
 507         NOT_REACHED();
 508     }
 509 }
 510
 511 struct vconn_class ssl_vconn_class = {
 512     .name = "ssl",
 513     .open = ssl_open,
 514     .close = ssl_close,
 515     .connect = ssl_connect,
 516     .recv = ssl_recv,
 517     .send = ssl_send,
 518     .wait = ssl_wait,
 519 };
 520 \f
 521 /* Passive SSL. */
 522
 523 struct pssl_vconn
 524 {
 525     struct vconn vconn;
 526     int fd;
 527 };
 528
 529 static struct pssl_vconn *
 530 pssl_vconn_cast(struct vconn *vconn)
 531 {
 532     assert(vconn->class == &pssl_vconn_class);
 533     return CONTAINER_OF(vconn, struct pssl_vconn, vconn);
 534 }
 535
 536 static int
 537 pssl_open(const char *name, char *suffix, struct vconn **vconnp)
 538 {
 539     struct sockaddr_in sin;
 540     struct pssl_vconn *pssl;
 541     int retval;
 542     int fd;
 543     unsigned int yes = 1;
 544
 545     retval = ssl_init();
 546     if (retval) {
 547         return retval;
 548     }
 549
 550     /* Create socket. */
 551     fd = socket(AF_INET, SOCK_STREAM, 0);
 552     if (fd < 0) {
 553         int error = errno;
 554         VLOG_ERR("%s: socket: %s", name, strerror(error));
 555         return error;
 556     }
 557
 558     if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof yes) < 0) {
 559         int error = errno;
 560         VLOG_ERR("%s: setsockopt(SO_REUSEADDR): %s", name, strerror(errno));
 561         return error;
 562     }
 563
 564     memset(&sin, 0, sizeof sin);
 565     sin.sin_family = AF_INET;
 566     sin.sin_addr.s_addr = htonl(INADDR_ANY);
 567     sin.sin_port = htons(atoi(suffix) ? atoi(suffix) : OFP_SSL_PORT);
 568     retval = bind(fd, (struct sockaddr *) &sin, sizeof sin);
 569     if (retval < 0) {
 570         int error = errno;
 571         VLOG_ERR("%s: bind: %s", name, strerror(error));
 572         close(fd);
 573         return error;
 574     }
 575
 576     retval = listen(fd, 10);
 577     if (retval < 0) {
 578         int error = errno;
 579         VLOG_ERR("%s: listen: %s", name, strerror(error));
 580         close(fd);
 581         return error;
 582     }
 583
 584     retval = set_nonblocking(fd);
 585     if (retval) {
 586         close(fd);
 587         return retval;
 588     }
 589
 590     pssl = xmalloc(sizeof *pssl);
 591     pssl->vconn.class = &pssl_vconn_class;
 592     pssl->vconn.connect_status = 0;
 593     pssl->fd = fd;
 594     *vconnp = &pssl->vconn;
 595     return 0;
 596 }
 597
 598 static void
 599 pssl_close(struct vconn *vconn)
 600 {
 601     struct pssl_vconn *pssl = pssl_vconn_cast(vconn);
 602     close(pssl->fd);
 603     free(pssl);
 604 }
 605
 606 static int
 607 pssl_accept(struct vconn *vconn, struct vconn **new_vconnp)
 608 {
 609     struct pssl_vconn *pssl = pssl_vconn_cast(vconn);
 610     int new_fd;
 611     int error;
 612
 613     new_fd = accept(pssl->fd, NULL, NULL);
 614     if (new_fd < 0) {
 615         int error = errno;
 616         if (error != EAGAIN) {
 617             VLOG_DBG("accept: %s", strerror(error));
 618         }
 619         return error;
 620     }
 621
 622     error = set_nonblocking(new_fd);
 623     if (error) {
 624         close(new_fd);
 625         return error;
 626     }
 627
 628     return new_ssl_vconn("ssl" /* FIXME */, new_fd,
 629                          SERVER, STATE_SSL_CONNECTING, new_vconnp);
 630 }
 631
 632 static void
 633 pssl_wait(struct vconn *vconn, enum vconn_wait_type wait)
 634 {
 635     struct pssl_vconn *pssl = pssl_vconn_cast(vconn);
 636     assert(wait == WAIT_ACCEPT);
 637     poll_fd_wait(pssl->fd, POLLIN, NULL);
 638 }
 639
 640 struct vconn_class pssl_vconn_class = {
 641     .name = "pssl",
 642     .open = pssl_open,
 643     .close = pssl_close,
 644     .accept = pssl_accept,
 645     .wait = pssl_wait,
 646 };
 647 \f
 648 /*
 649  * Returns true if OpenSSL error is WANT_READ or WANT_WRITE, indicating that
 650  * OpenSSL is requesting that we call it back when the socket is ready for read
 651  * or writing, respectively.
 652  */
 653 static bool
 654 ssl_wants_io(int ssl_error)
 655 {
 656     return (ssl_error == SSL_ERROR_WANT_WRITE
 657             || ssl_error == SSL_ERROR_WANT_READ);
 658 }
 659
 660 static int
 661 ssl_init(void)
 662 {
 663     static int init_status = -1;
 664     if (init_status < 0) {
 665         init_status = do_ssl_init();
 666         assert(init_status >= 0);
 667     }
 668     return init_status;
 669 }
 670
 671 static int
 672 do_ssl_init(void)
 673 {
 674     SSL_METHOD *method;
 675
 676     SSL_library_init();
 677     SSL_load_error_strings();
 678
 679     method = TLSv1_method();
 680     if (method == NULL) {
 681         VLOG_ERR("TLSv1_method: %s", ERR_error_string(ERR_get_error(), NULL));
 682         return ENOPROTOOPT;
 683     }
 684
 685     ctx = SSL_CTX_new(method);
 686     if (ctx == NULL) {
 687         VLOG_ERR("SSL_CTX_new: %s", ERR_error_string(ERR_get_error(), NULL));
 688         return ENOPROTOOPT;
 689     }
 690     SSL_CTX_set_options(ctx, SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3);
 691     SSL_CTX_set_tmp_dh_callback(ctx, tmp_dh_callback);
 692     SSL_CTX_set_mode(ctx, SSL_MODE_ENABLE_PARTIAL_WRITE);
 693     SSL_CTX_set_mode(ctx, SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER);
 694     SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
 695                        NULL);
 696
 697     return 0;
 698 }
 699
 700 static DH *
 701 tmp_dh_callback(SSL *ssl, int is_export UNUSED, int keylength)
 702 {
 703     struct dh {
 704         int keylength;
 705         DH *dh;
 706         DH *(*constructor)(void);
 707     };
 708
 709     static struct dh dh_table[] = {
 710         {1024, NULL, get_dh1024},
 711         {2048, NULL, get_dh2048},
 712         {4096, NULL, get_dh4096},
 713     };
 714
 715     struct dh *dh;
 716
 717     for (dh = dh_table; dh < &dh_table[ARRAY_SIZE(dh_table)]; dh++) {
 718         if (dh->keylength == keylength) {
 719             if (!dh->dh) {
 720                 dh->dh = dh->constructor();
 721                 if (!dh->dh) {
 722                     fatal(ENOMEM, "out of memory constructing "
 723                           "Diffie-Hellman parameters");
 724                 }
 725             }
 726             return dh->dh;
 727         }
 728     }
 729     VLOG_ERR("no Diffie-Hellman parameters for key length %d", keylength);
 730     return NULL;
 731 }
 732
 733 void
 734 vconn_ssl_set_private_key_file(const char *file_name)
 735 {
 736     if (ssl_init()) {
 737         return;
 738     }
 739     if (SSL_CTX_use_PrivateKey_file(ctx, file_name, SSL_FILETYPE_PEM) != 1) {
 740         VLOG_ERR("SSL_use_PrivateKey_file: %s",
 741                  ERR_error_string(ERR_get_error(), NULL));
 742         return;
 743     }
 744     has_private_key = true;
 745 }
 746
 747 void
 748 vconn_ssl_set_certificate_file(const char *file_name)
 749 {
 750     if (ssl_init()) {
 751         return;
 752     }
 753     if (SSL_CTX_use_certificate_chain_file(ctx, file_name) != 1) {
 754         VLOG_ERR("SSL_use_certificate_file: %s",
 755                  ERR_error_string(ERR_get_error(), NULL));
 756         return;
 757     }
 758     has_certificate = true;
 759 }
 760
 761 void
 762 vconn_ssl_set_ca_cert_file(const char *file_name)
 763 {
 764     STACK_OF(X509_NAME) *ca_list;
 765
 766     if (ssl_init()) {
 767         return;
 768     }
 769
 770     /* Set up list of CAs that the server will accept from the client. */
 771     ca_list = SSL_load_client_CA_file(file_name);
 772     if (ca_list == NULL) {
 773         VLOG_ERR("SSL_load_client_CA_file: %s",
 774                  ERR_error_string(ERR_get_error(), NULL));
 775         return;
 776     }
 777     SSL_CTX_set_client_CA_list(ctx, ca_list);
 778
 779     /* Set up CAs for OpenSSL to trust in verifying the peer's certificate. */
 780     if (SSL_CTX_load_verify_locations(ctx, file_name, NULL) != 1) {
 781         VLOG_ERR("SSL_load_verify_locations: %s",
 782                  ERR_error_string(ERR_get_error(), NULL));
 783         return;
 784     }
 785
 786     has_ca_cert = true;
 787 }