1 files changed, 48 insertions, 48 deletions

diff --git a/src/lib/libressl/ressl.c b/src/lib/libtls/tls.c
index 06c7d54cc2..a7f612e40b 100644
--- a/src/lib/libressl/ressl.c
+++ b/src/lib/libtls/tls.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ressl.c,v 1.18 2014/10/15 21:02:39 tedu Exp $ */
+/* $OpenBSD: tls.c,v 1.1 2014/10/31 13:46:17 jsing Exp $ */
 /*
  * Copyright (c) 2014 Joel Sing <jsing@openbsd.org>
  *
@@ -26,38 +26,38 @@
 #include <openssl/pem.h>
 #include <openssl/x509.h>
 
-#include <ressl.h>
-#include "ressl_internal.h"
+#include <tls.h>
+#include "tls_internal.h"
 
-static struct ressl_config *ressl_config_default;
+static struct tls_config *tls_config_default;
 
 int
-ressl_init(void)
+tls_init(void)
 {
-        static int ressl_initialised = 0;
+        static int tls_initialised = 0;
 
-        if (ressl_initialised)
+        if (tls_initialised)
                 return (0);
 
         SSL_load_error_strings();
         SSL_library_init();
 
-        if ((ressl_config_default = ressl_config_new()) == NULL)
+        if ((tls_config_default = tls_config_new()) == NULL)
                 return (-1);
 
-        ressl_initialised = 1;
+        tls_initialised = 1;
 
         return (0);
 }
 
 const char *
-ressl_error(struct ressl *ctx)
+tls_error(struct tls *ctx)
 {
         return ctx->errmsg;
 }
 
 int
-ressl_set_error(struct ressl *ctx, char *fmt, ...)
+tls_set_error(struct tls *ctx, char *fmt, ...)
 {
         va_list ap;
         int rv;
@@ -73,37 +73,37 @@ ressl_set_error(struct ressl *ctx, char *fmt, ...)
         return (rv);
 }
 
-struct ressl *
-ressl_new(void)
+struct tls *
+tls_new(void)
 {
-        struct ressl *ctx;
+        struct tls *ctx;
 
         if ((ctx = calloc(1, sizeof(*ctx))) == NULL)
                 return (NULL);
 
-        ctx->config = ressl_config_default;
+        ctx->config = tls_config_default;
 
-        ressl_reset(ctx);
+        tls_reset(ctx);
 
         return (ctx);
 }
 
 int
-ressl_configure(struct ressl *ctx, struct ressl_config *config)
+tls_configure(struct tls *ctx, struct tls_config *config)
 {
         if (config == NULL)
-                config = ressl_config_default;
+                config = tls_config_default;
 
         ctx->config = config;
 
-        if ((ctx->flags & RESSL_SERVER) != 0)
-                return (ressl_configure_server(ctx));
+        if ((ctx->flags & TLS_SERVER) != 0)
+                return (tls_configure_server(ctx));
 
         return (0);
 }
 
 int
-ressl_configure_keypair(struct ressl *ctx)
+tls_configure_keypair(struct tls *ctx)
 {
         EVP_PKEY *pkey = NULL;
         X509 *cert = NULL;
@@ -112,7 +112,7 @@ ressl_configure_keypair(struct ressl *ctx)
         if (ctx->config->cert_mem != NULL) {
                 if (SSL_CTX_use_certificate_chain(ctx->ssl_ctx,
                     ctx->config->cert_mem, ctx->config->cert_len) != 1) {
-                        ressl_set_error(ctx, "failed to load certificate");
+                        tls_set_error(ctx, "failed to load certificate");
                         goto err;
                 }
                 cert = NULL;
@@ -120,16 +120,16 @@ ressl_configure_keypair(struct ressl *ctx)
         if (ctx->config->key_mem != NULL) {
                 if ((bio = BIO_new_mem_buf(ctx->config->key_mem,
                     ctx->config->key_len)) == NULL) {
-                        ressl_set_error(ctx, "failed to create buffer");
+                        tls_set_error(ctx, "failed to create buffer");
                         goto err;
                 }
                 if ((pkey = PEM_read_bio_PrivateKey(bio, NULL, NULL,
                     NULL)) == NULL) {
-                        ressl_set_error(ctx, "failed to read private key");
+                        tls_set_error(ctx, "failed to read private key");
                         goto err;
                 }
                 if (SSL_CTX_use_PrivateKey(ctx->ssl_ctx, pkey) != 1) {
-                        ressl_set_error(ctx, "failed to load private key");
+                        tls_set_error(ctx, "failed to load private key");
                         goto err;
                 }
                 BIO_free(bio);
@@ -141,20 +141,20 @@ ressl_configure_keypair(struct ressl *ctx)
         if (ctx->config->cert_file != NULL) {
                 if (SSL_CTX_use_certificate_chain_file(ctx->ssl_ctx,
                     ctx->config->cert_file) != 1) {
-                        ressl_set_error(ctx, "failed to load certificate file");
+                        tls_set_error(ctx, "failed to load certificate file");
                         goto err;
                 }
         }
         if (ctx->config->key_file != NULL) {
                 if (SSL_CTX_use_PrivateKey_file(ctx->ssl_ctx,
                     ctx->config->key_file, SSL_FILETYPE_PEM) != 1) {
-                        ressl_set_error(ctx, "failed to load private key file");
+                        tls_set_error(ctx, "failed to load private key file");
                         goto err;
                 }
         }
 
         if (SSL_CTX_check_private_key(ctx->ssl_ctx) != 1) {
-                ressl_set_error(ctx, "private/public key mismatch");
+                tls_set_error(ctx, "private/public key mismatch");
                 goto err;
         }
 
@@ -169,7 +169,7 @@ err:
 }
 
 int
-ressl_configure_ssl(struct ressl *ctx)
+tls_configure_ssl(struct tls *ctx)
 {
         SSL_CTX_set_options(ctx->ssl_ctx, SSL_OP_NO_SSLv2);
         SSL_CTX_set_options(ctx->ssl_ctx, SSL_OP_NO_SSLv3);
@@ -178,17 +178,17 @@ ressl_configure_ssl(struct ressl *ctx)
         SSL_CTX_clear_options(ctx->ssl_ctx, SSL_OP_NO_TLSv1_1);
         SSL_CTX_clear_options(ctx->ssl_ctx, SSL_OP_NO_TLSv1_2);
 
-        if ((ctx->config->protocols & RESSL_PROTOCOL_TLSv1_0) == 0)
+        if ((ctx->config->protocols & TLS_PROTOCOL_TLSv1_0) == 0)
                 SSL_CTX_set_options(ctx->ssl_ctx, SSL_OP_NO_TLSv1);
-        if ((ctx->config->protocols & RESSL_PROTOCOL_TLSv1_1) == 0)
+        if ((ctx->config->protocols & TLS_PROTOCOL_TLSv1_1) == 0)
                 SSL_CTX_set_options(ctx->ssl_ctx, SSL_OP_NO_TLSv1_1);
-        if ((ctx->config->protocols & RESSL_PROTOCOL_TLSv1_2) == 0)
+        if ((ctx->config->protocols & TLS_PROTOCOL_TLSv1_2) == 0)
                 SSL_CTX_set_options(ctx->ssl_ctx, SSL_OP_NO_TLSv1_2);
 
         if (ctx->config->ciphers != NULL) {
                 if (SSL_CTX_set_cipher_list(ctx->ssl_ctx,
                     ctx->config->ciphers) != 1) {
-                        ressl_set_error(ctx, "failed to set ciphers");
+                        tls_set_error(ctx, "failed to set ciphers");
                         goto err;
                 }
         }
@@ -200,16 +200,16 @@ err:
 }
 
 void
-ressl_free(struct ressl *ctx)
+tls_free(struct tls *ctx)
 {
         if (ctx == NULL)
                 return;
-        ressl_reset(ctx);
+        tls_reset(ctx);
         free(ctx);
 }
 
 void
-ressl_reset(struct ressl *ctx)
+tls_reset(struct tls *ctx)
 {
         SSL_CTX_free(ctx->ssl_ctx);
         SSL_free(ctx->ssl_conn);
@@ -225,7 +225,7 @@ ressl_reset(struct ressl *ctx)
 }
 
 int
-ressl_read(struct ressl *ctx, void *buf, size_t buflen, size_t *outlen)
+tls_read(struct tls *ctx, void *buf, size_t buflen, size_t *outlen)
 {
         int ret, ssl_err;
 
@@ -238,17 +238,17 @@ ressl_read(struct ressl *ctx, void *buf, size_t buflen, size_t *outlen)
         ssl_err = SSL_get_error(ctx->ssl_conn, ret);
         switch (ssl_err) {
         case SSL_ERROR_WANT_READ:
-                return (RESSL_READ_AGAIN);
+                return (TLS_READ_AGAIN);
         case SSL_ERROR_WANT_WRITE:
-                return (RESSL_WRITE_AGAIN);
+                return (TLS_WRITE_AGAIN);
         default:
-                ressl_set_error(ctx, "read failed (%i)", ssl_err);
+                tls_set_error(ctx, "read failed (%i)", ssl_err);
                 return (-1);
         }
 }
 
 int
-ressl_write(struct ressl *ctx, const void *buf, size_t buflen, size_t *outlen)
+tls_write(struct tls *ctx, const void *buf, size_t buflen, size_t *outlen)
 {
         int ret, ssl_err;
 
@@ -261,33 +261,33 @@ ressl_write(struct ressl *ctx, const void *buf, size_t buflen, size_t *outlen)
         ssl_err = SSL_get_error(ctx->ssl_conn, ret);
         switch (ssl_err) {
         case SSL_ERROR_WANT_READ:
-                return (RESSL_READ_AGAIN);
+                return (TLS_READ_AGAIN);
         case SSL_ERROR_WANT_WRITE:
-                return (RESSL_WRITE_AGAIN);
+                return (TLS_WRITE_AGAIN);
         default:
-                ressl_set_error(ctx, "write failed (%i)", ssl_err);
+                tls_set_error(ctx, "write failed (%i)", ssl_err);
                 return (-1);
         }
 }
 
 int
-ressl_close(struct ressl *ctx)
+tls_close(struct tls *ctx)
 {
         /* XXX - handle case where multiple calls are required. */
         if (ctx->ssl_conn != NULL) {
                 if (SSL_shutdown(ctx->ssl_conn) == -1) {
-                        ressl_set_error(ctx, "SSL shutdown failed");
+                        tls_set_error(ctx, "SSL shutdown failed");
                         goto err;
                 }
         }
 
         if (ctx->socket != -1) {
                 if (shutdown(ctx->socket, SHUT_RDWR) != 0) {
-                        ressl_set_error(ctx, "shutdown");
+                        tls_set_error(ctx, "shutdown");
                         goto err;
                 }
                 if (close(ctx->socket) != 0) {
-                        ressl_set_error(ctx, "close");
+                        tls_set_error(ctx, "close");
                         goto err;
                 }
                 ctx->socket = -1;