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 <netinet/tcp.h>
  27 #include <openssl/err.h>
  28 #include <openssl/ssl.h>
  29 #include <poll.h>
  30 #include <unistd.h>
  31 #include "buffer.h"
  32 #include "socket-util.h"
  33 #include "util.h"
  34 #include "openflow.h"
  35 #include "ofp-print.h"
  36 #include "vconn.h"
  37
  38 #include "vlog.h"
  39 #define THIS_MODULE VLM_vconn_ssl
  40
  41 /* Active SSL. */
  42
  43 enum ssl_state {
  44     STATE_SSL_CONNECTING,
  45     STATE_CONNECTED
  46 };
  47
  48 enum session_type {
  49     CLIENT,
  50     SERVER
  51 };
  52
  53 struct ssl_vconn
  54 {
  55     struct vconn vconn;
  56     enum ssl_state state;
  57     int connect_error;
  58     enum session_type type;
  59     int fd;
  60     SSL *ssl;
  61     struct buffer *rxbuf;
  62     struct buffer *txbuf;
  63 };
  64
  65 /* SSL context created by ssl_init(). */
  66 static SSL_CTX *ctx;
  67
  68 /* Required configuration. */
  69 static bool has_private_key, has_certificate, has_ca_cert;
  70
  71 static int ssl_init(void);
  72 static int do_ssl_init(void);
  73 static void connect_completed(struct ssl_vconn *, int error);
  74 static bool ssl_wants_io(int ssl_error);
  75 static void ssl_close(struct vconn *);
  76 static bool state_machine(struct ssl_vconn *sslv);
  77 static DH *tmp_dh_callback(SSL *ssl, int is_export UNUSED, int keylength);
  78
  79 static int
  80 new_ssl_vconn(const char *name, int fd, enum session_type type,
  81               struct vconn **vconnp)
  82 {
  83     struct ssl_vconn *sslv;
  84     SSL *ssl = NULL;
  85     int on = 1;
  86     int retval;
  87
  88     /* Check for all the needful configuration. */
  89     if (!has_private_key) {
  90         VLOG_ERR("Private key must be configured to use SSL");
  91         goto error;
  92     }
  93     if (!has_certificate) {
  94         VLOG_ERR("Certificate must be configured to use SSL");
  95         goto error;
  96     }
  97     if (!has_ca_cert) {
  98         VLOG_ERR("CA certificate must be configured to use SSL");
  99         goto error;
 100     }
 101     if (!SSL_CTX_check_private_key(ctx)) {
 102         VLOG_ERR("Private key does not match certificate public key");
 103         goto error;
 104     }
 105
 106     /* Make 'fd' non-blocking and disable Nagle. */
 107     retval = set_nonblocking(fd);
 108     if (retval) {
 109         VLOG_ERR("%s: set_nonblocking: %s", name, strerror(retval));
 110         close(fd);
 111         return retval;
 112     }
 113     retval = setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &on, sizeof on);
 114     if (retval) {
 115         VLOG_ERR("%s: setsockopt(TCP_NODELAY): %s", name, strerror(errno));
 116         close(fd);
 117         return errno;
 118     }
 119
 120     /* Create and configure OpenSSL stream. */
 121     ssl = SSL_new(ctx);
 122     if (ssl == NULL) {
 123         VLOG_DBG("SSL_new: %s", ERR_error_string(ERR_get_error(), NULL));
 124         close(fd);
 125         return ENOPROTOOPT;
 126     }
 127     if (SSL_set_fd(ssl, fd) == 0) {
 128         VLOG_DBG("SSL_set_fd: %s", ERR_error_string(ERR_get_error(), NULL));
 129         goto error;
 130     }
 131
 132     /* Create and return the ssl_vconn. */
 133     sslv = xmalloc(sizeof *sslv);
 134     sslv->vconn.class = &ssl_vconn_class;
 135     sslv->state = STATE_SSL_CONNECTING;
 136     sslv->type = type;
 137     sslv->fd = fd;
 138     sslv->ssl = ssl;
 139     sslv->rxbuf = NULL;
 140     sslv->txbuf = 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
 197     /* Connect socket (blocking). */
 198     retval = connect(fd, (struct sockaddr *) &sin, sizeof sin);
 199     if (retval < 0) {
 200         int error = errno;
 201         VLOG_ERR("%s: connect: %s", name, strerror(error));
 202         close(fd);
 203         return error;
 204     }
 205
 206     /* Make an ssl_vconn for the socket. */
 207     return new_ssl_vconn(name, fd, CLIENT, vconnp);
 208 }
 209
 210 static void
 211 ssl_close(struct vconn *vconn)
 212 {
 213     struct ssl_vconn *sslv = ssl_vconn_cast(vconn);
 214     SSL_free(sslv->ssl);
 215     close(sslv->fd);
 216     free(sslv);
 217 }
 218
 219 static bool
 220 ssl_want_io_to_events(SSL *ssl, short int *events)
 221 {
 222     if (SSL_want_read(ssl)) {
 223         *events |= POLLIN;
 224         return true;
 225     } else if (SSL_want_write(ssl)) {
 226         *events |= POLLOUT;
 227         return true;
 228     } else {
 229         return false;
 230     }
 231 }
 232
 233 static bool
 234 ssl_prepoll(struct vconn *vconn, int want, struct pollfd *pfd)
 235 {
 236     struct ssl_vconn *sslv = ssl_vconn_cast(vconn);
 237     pfd->fd = sslv->fd;
 238     if (!state_machine(sslv)) {
 239         switch (sslv->state) {
 240         case STATE_SSL_CONNECTING:
 241             if (!ssl_want_io_to_events(sslv->ssl, &pfd->events)) {
 242                 /* state_machine() should have transitioned us away to another
 243                  * state. */
 244                 NOT_REACHED();
 245             }
 246             break;
 247         default:
 248             NOT_REACHED();
 249         }
 250     } else if (sslv->connect_error) {
 251         pfd->events = 0;
 252         return true;
 253     } else if (!ssl_want_io_to_events(sslv->ssl, &pfd->events)) {
 254         if (want & WANT_RECV) {
 255             pfd->events |= POLLIN;
 256         }
 257         if (want & WANT_SEND || sslv->txbuf) {
 258             pfd->events |= POLLOUT;
 259         }
 260     }
 261     return false;
 262 }
 263
 264 static void
 265 ssl_postpoll(struct vconn *vconn, short int *revents)
 266 {
 267     struct ssl_vconn *sslv = ssl_vconn_cast(vconn);
 268     if (!state_machine(sslv)) {
 269         *revents = 0;
 270     } else if (sslv->connect_error) {
 271         *revents |= POLLERR;
 272     } else if (*revents & POLLOUT && sslv->txbuf) {
 273         ssize_t n = SSL_write(sslv->ssl, sslv->txbuf->data, sslv->txbuf->size);
 274         if (n > 0) {
 275             buffer_pull(sslv->txbuf, n);
 276             if (sslv->txbuf->size == 0) {
 277                 buffer_delete(sslv->txbuf);
 278                 sslv->txbuf = NULL;
 279             }
 280         }
 281         if (sslv->txbuf) {
 282             *revents &= ~POLLOUT;
 283         }
 284     }
 285 }
 286
 287 static int
 288 interpret_ssl_error(const char *function, int ret, int error)
 289 {
 290     switch (error) {
 291     case SSL_ERROR_NONE:
 292         VLOG_ERR("%s: unexpected SSL_ERROR_NONE", function);
 293         break;
 294
 295     case SSL_ERROR_ZERO_RETURN:
 296         VLOG_ERR("%s: unexpected SSL_ERROR_ZERO_RETURN", function);
 297         break;
 298
 299     case SSL_ERROR_WANT_READ:
 300     case SSL_ERROR_WANT_WRITE:
 301         return EAGAIN;
 302
 303     case SSL_ERROR_WANT_CONNECT:
 304         VLOG_ERR("%s: unexpected SSL_ERROR_WANT_CONNECT", function);
 305         break;
 306
 307     case SSL_ERROR_WANT_ACCEPT:
 308         VLOG_ERR("%s: unexpected SSL_ERROR_WANT_ACCEPT", function);
 309         break;
 310
 311     case SSL_ERROR_WANT_X509_LOOKUP:
 312         VLOG_ERR("%s: unexpected SSL_ERROR_WANT_X509_LOOKUP", function);
 313         break;
 314
 315     case SSL_ERROR_SYSCALL: {
 316         int queued_error = ERR_get_error();
 317         if (queued_error == 0) {
 318             if (ret < 0) {
 319                 int status = errno;
 320                 VLOG_WARN("%s: system error (%s)", function, strerror(status));
 321                 return status;
 322             } else {
 323                 VLOG_WARN("%s: unexpected SSL connection close", function);
 324                 return EPROTO;
 325             }
 326         } else {
 327             VLOG_DBG("%s: %s", function, ERR_error_string(queued_error, NULL));
 328             break;
 329         }
 330     }
 331
 332     case SSL_ERROR_SSL: {
 333         int queued_error = ERR_get_error();
 334         if (queued_error != 0) {
 335             VLOG_DBG("%s: %s", function, ERR_error_string(queued_error, NULL));
 336         } else {
 337             VLOG_ERR("%s: SSL_ERROR_SSL without queued error", function);
 338         }
 339         break;
 340     }
 341
 342     default:
 343         VLOG_ERR("%s: bad SSL error code %d", function, error);
 344         break;
 345     }
 346     return EIO;
 347 }
 348
 349 static int
 350 ssl_recv(struct vconn *vconn, struct buffer **bufferp)
 351 {
 352     struct ssl_vconn *sslv = ssl_vconn_cast(vconn);
 353     struct buffer *rx;
 354     size_t want_bytes;
 355     ssize_t ret;
 356
 357     if (!state_machine(sslv)) {
 358         return EAGAIN;
 359     } else if (sslv->connect_error) {
 360         return sslv->connect_error;
 361     }
 362
 363     if (sslv->rxbuf == NULL) {
 364         sslv->rxbuf = buffer_new(1564);
 365     }
 366     rx = sslv->rxbuf;
 367
 368 again:
 369     if (sizeof(struct ofp_header) > rx->size) {
 370         want_bytes = sizeof(struct ofp_header) - rx->size;
 371     } else {
 372         struct ofp_header *oh = rx->data;
 373         size_t length = ntohs(oh->length);
 374         if (length < sizeof(struct ofp_header)) {
 375             VLOG_ERR("received too-short ofp_header (%zu bytes)", length);
 376             return EPROTO;
 377         }
 378         want_bytes = length - rx->size;
 379     }
 380     buffer_reserve_tailroom(rx, want_bytes);
 381
 382     /* Behavior of zero-byte SSL_read is poorly defined. */
 383     assert(want_bytes > 0);
 384
 385     ret = SSL_read(sslv->ssl, buffer_tail(rx), want_bytes);
 386     if (ret > 0) {
 387         rx->size += ret;
 388         if (ret == want_bytes) {
 389             if (rx->size > sizeof(struct ofp_header)) {
 390                 *bufferp = rx;
 391                 sslv->rxbuf = NULL;
 392                 return 0;
 393             } else {
 394                 goto again;
 395             }
 396         }
 397         return EAGAIN;
 398     } else {
 399         int error = SSL_get_error(sslv->ssl, ret);
 400         if (error == SSL_ERROR_ZERO_RETURN) {
 401             /* Connection closed (EOF). */
 402             if (rx->size) {
 403                 VLOG_WARN("SSL_read: unexpected connection close");
 404                 return EPROTO;
 405             } else {
 406                 return EOF;
 407             }
 408         } else {
 409             return interpret_ssl_error("SSL_read", ret, error);
 410         }
 411     }
 412 }
 413
 414 static int
 415 ssl_send(struct vconn *vconn, struct buffer *buffer)
 416 {
 417     struct ssl_vconn *sslv = ssl_vconn_cast(vconn);
 418     ssize_t ret;
 419
 420     if (!state_machine(sslv)) {
 421         return EAGAIN;
 422     } else if (sslv->connect_error) {
 423         return sslv->connect_error;
 424     }
 425
 426     if (sslv->txbuf) {
 427         return EAGAIN;
 428     }
 429
 430     ret = SSL_write(sslv->ssl, buffer->data, buffer->size);
 431     if (ret > 0) {
 432         if (ret == buffer->size) {
 433             buffer_delete(buffer);
 434         } else {
 435             sslv->txbuf = buffer;
 436             buffer_pull(buffer, ret);
 437         }
 438         return 0;
 439     } else {
 440         int error = SSL_get_error(sslv->ssl, ret);
 441         if (error == SSL_ERROR_ZERO_RETURN) {
 442             /* Connection closed (EOF). */
 443             VLOG_WARN("SSL_write: connection close");
 444             return EPIPE;
 445         } else {
 446             return interpret_ssl_error("SSL_write", ret, error);
 447         }
 448     }
 449 }
 450
 451 struct vconn_class ssl_vconn_class = {
 452     .name = "ssl",
 453     .open = ssl_open,
 454     .close = ssl_close,
 455     .prepoll = ssl_prepoll,
 456     .postpoll = ssl_postpoll,
 457     .recv = ssl_recv,
 458     .send = ssl_send,
 459 };
 460 \f
 461 /* Passive SSL. */
 462
 463 struct pssl_vconn
 464 {
 465     struct vconn vconn;
 466     int fd;
 467 };
 468
 469 static struct pssl_vconn *
 470 pssl_vconn_cast(struct vconn *vconn)
 471 {
 472     assert(vconn->class == &pssl_vconn_class);
 473     return CONTAINER_OF(vconn, struct pssl_vconn, vconn);
 474 }
 475
 476 static int
 477 pssl_open(const char *name, char *suffix, struct vconn **vconnp)
 478 {
 479     struct sockaddr_in sin;
 480     struct pssl_vconn *pssl;
 481     int retval;
 482     int fd;
 483     unsigned int yes = 1;
 484
 485     retval = ssl_init();
 486     if (retval) {
 487         return retval;
 488     }
 489
 490     /* Create socket. */
 491     fd = socket(AF_INET, SOCK_STREAM, 0);
 492     if (fd < 0) {
 493         int error = errno;
 494         VLOG_ERR("%s: socket: %s", name, strerror(error));
 495         return error;
 496     }
 497
 498     if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof yes) < 0) {
 499         int error = errno;
 500         VLOG_ERR("%s: setsockopt(SO_REUSEADDR): %s", name, strerror(errno));
 501         return error;
 502     }
 503
 504     memset(&sin, 0, sizeof sin);
 505     sin.sin_family = AF_INET;
 506     sin.sin_addr.s_addr = htonl(INADDR_ANY);
 507     sin.sin_port = htons(atoi(suffix) ? atoi(suffix) : OFP_SSL_PORT);
 508     retval = bind(fd, (struct sockaddr *) &sin, sizeof sin);
 509     if (retval < 0) {
 510         int error = errno;
 511         VLOG_ERR("%s: bind: %s", name, strerror(error));
 512         close(fd);
 513         return error;
 514     }
 515
 516     retval = listen(fd, 10);
 517     if (retval < 0) {
 518         int error = errno;
 519         VLOG_ERR("%s: listen: %s", name, strerror(error));
 520         close(fd);
 521         return error;
 522     }
 523
 524     retval = set_nonblocking(fd);
 525     if (retval) {
 526         VLOG_ERR("%s: set_nonblocking: %s", name, strerror(retval));
 527         close(fd);
 528         return retval;
 529     }
 530
 531     pssl = xmalloc(sizeof *pssl);
 532     pssl->vconn.class = &pssl_vconn_class;
 533     pssl->fd = fd;
 534     *vconnp = &pssl->vconn;
 535     return 0;
 536 }
 537
 538 static void
 539 pssl_close(struct vconn *vconn)
 540 {
 541     struct pssl_vconn *pssl = pssl_vconn_cast(vconn);
 542     close(pssl->fd);
 543     free(pssl);
 544 }
 545
 546 static bool
 547 pssl_prepoll(struct vconn *vconn, int want, struct pollfd *pfd)
 548 {
 549     struct pssl_vconn *pssl = pssl_vconn_cast(vconn);
 550     pfd->fd = pssl->fd;
 551     if (want & WANT_ACCEPT) {
 552         pfd->events |= POLLIN;
 553     }
 554     return false;
 555 }
 556
 557 static int
 558 pssl_accept(struct vconn *vconn, struct vconn **new_vconnp)
 559 {
 560     struct pssl_vconn *pssl = pssl_vconn_cast(vconn);
 561     int new_fd;
 562
 563     new_fd = accept(pssl->fd, NULL, NULL);
 564     if (new_fd < 0) {
 565         int error = errno;
 566         if (error != EAGAIN) {
 567             VLOG_DBG("pssl: accept: %s", strerror(error));
 568         }
 569         return error;
 570     }
 571
 572     return new_ssl_vconn("ssl" /* FIXME */, new_fd, SERVER, new_vconnp);
 573 }
 574
 575 struct vconn_class pssl_vconn_class = {
 576     .name = "pssl",
 577     .open = pssl_open,
 578     .close = pssl_close,
 579     .prepoll = pssl_prepoll,
 580     .accept = pssl_accept,
 581 };
 582 \f
 583 /*
 584  * Returns true if OpenSSL error is WANT_READ or WANT_WRITE, indicating that
 585  * OpenSSL is requesting that we call it back when the socket is ready for read
 586  * or writing (respectively.
 587  */
 588 static bool
 589 ssl_wants_io(int ssl_error)
 590 {
 591     return (ssl_error == SSL_ERROR_WANT_WRITE
 592             || ssl_error == SSL_ERROR_WANT_READ);
 593 }
 594
 595 static int
 596 ssl_init(void)
 597 {
 598     static int init_status = -1;
 599     if (init_status < 0) {
 600         init_status = do_ssl_init();
 601         assert(init_status >= 0);
 602     }
 603     return init_status;
 604 }
 605
 606 static int
 607 do_ssl_init(void)
 608 {
 609     SSL_METHOD *method;
 610
 611     SSL_library_init();
 612     SSL_load_error_strings();
 613
 614     method = TLSv1_method();
 615     if (method == NULL) {
 616         VLOG_ERR("TLSv1_method: %s", ERR_error_string(ERR_get_error(), NULL));
 617         return ENOPROTOOPT;
 618     }
 619
 620     ctx = SSL_CTX_new(method);
 621     if (ctx == NULL) {
 622         VLOG_ERR("SSL_CTX_new: %s", ERR_error_string(ERR_get_error(), NULL));
 623         return ENOPROTOOPT;
 624     }
 625     SSL_CTX_set_options(ctx, SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3);
 626     SSL_CTX_set_tmp_dh_callback(ctx, tmp_dh_callback);
 627     SSL_CTX_set_mode(ctx, SSL_MODE_ENABLE_PARTIAL_WRITE);
 628     SSL_CTX_set_mode(ctx, SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER);
 629     SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
 630                        NULL);
 631
 632     return 0;
 633 }
 634
 635 static bool
 636 state_machine(struct ssl_vconn *sslv)
 637 {
 638     if (sslv->state == STATE_SSL_CONNECTING) {
 639         int ret = (sslv->type == CLIENT
 640                    ? SSL_connect(sslv->ssl) : SSL_accept(sslv->ssl));
 641         if (ret != 1) {
 642             int error = SSL_get_error(sslv->ssl, ret);
 643             if (ret < 0 && ssl_wants_io(error)) {
 644                 /* Stay in this state to repeat the SSL_connect later. */
 645                 return false;
 646             } else {
 647                 interpret_ssl_error((sslv->type == CLIENT ? "SSL_connect"
 648                                      : "SSL_accept"), ret, error);
 649                 shutdown(sslv->fd, SHUT_RDWR);
 650                 connect_completed(sslv, EPROTO);
 651             }
 652         } else {
 653             connect_completed(sslv, 0);
 654         }
 655     }
 656     return sslv->state == STATE_CONNECTED;
 657 }
 658
 659 static void
 660 connect_completed(struct ssl_vconn *sslv, int error)
 661 {
 662     sslv->state = STATE_CONNECTED;
 663     sslv->connect_error = error;
 664 }
 665
 666 static DH *
 667 tmp_dh_callback(SSL *ssl, int is_export UNUSED, int keylength)
 668 {
 669     struct dh {
 670         int keylength;
 671         DH *dh;
 672         DH *(*constructor)(void);
 673     };
 674
 675     static struct dh dh_table[] = {
 676         {512, NULL, get_dh512},
 677         {1024, NULL, get_dh1024},
 678         {2048, NULL, get_dh2048},
 679         {4096, NULL, get_dh4096},
 680     };
 681
 682     struct dh *dh;
 683
 684     for (dh = dh_table; dh < &dh[ARRAY_SIZE(dh_table)]; dh++) {
 685         if (dh->keylength == keylength) {
 686             if (!dh->dh) {
 687                 dh->dh = dh->constructor();
 688                 if (!dh->dh) {
 689                     fatal(ENOMEM, "out of memory constructing "
 690                           "Diffie-Hellman parameters");
 691                 }
 692             }
 693             return dh->dh;
 694         }
 695     }
 696     VLOG_ERR("no Diffie-Hellman parameters for key length %d", keylength);
 697     return NULL;
 698 }
 699
 700 void
 701 vconn_ssl_set_private_key_file(const char *file_name)
 702 {
 703     if (ssl_init()) {
 704         return;
 705     }
 706     if (SSL_CTX_use_PrivateKey_file(ctx, file_name, SSL_FILETYPE_PEM) != 1) {
 707         VLOG_ERR("SSL_use_PrivateKey_file: %s",
 708                  ERR_error_string(ERR_get_error(), NULL));
 709         return;
 710     }
 711     has_private_key = true;
 712 }
 713
 714 void
 715 vconn_ssl_set_certificate_file(const char *file_name)
 716 {
 717     if (ssl_init()) {
 718         return;
 719     }
 720     if (SSL_CTX_use_certificate_chain_file(ctx, file_name) != 1) {
 721         VLOG_ERR("SSL_use_certificate_file: %s",
 722                  ERR_error_string(ERR_get_error(), NULL));
 723         return;
 724     }
 725     has_certificate = true;
 726 }
 727
 728 void
 729 vconn_ssl_set_ca_cert_file(const char *file_name)
 730 {
 731     STACK_OF(X509_NAME) *ca_list;
 732
 733     if (ssl_init()) {
 734         return;
 735     }
 736
 737     /* Set up list of CAs that the server will accept from the client. */
 738     ca_list = SSL_load_client_CA_file(file_name);
 739     if (ca_list == NULL) {
 740         VLOG_ERR("SSL_load_client_CA_file: %s",
 741                  ERR_error_string(ERR_get_error(), NULL));
 742         return;
 743     }
 744     SSL_CTX_set_client_CA_list(ctx, ca_list);
 745
 746     /* Set up CAs for OpenSSL to trust in verifying the peer's certificate. */
 747     if (SSL_CTX_load_verify_locations(ctx, file_name, NULL) != 1) {
 748         VLOG_ERR("SSL_load_verify_locations: %s",
 749                  ERR_error_string(ERR_get_error(), NULL));
 750         return;
 751     }
 752
 753     has_ca_cert = true;
 754 }