openssl/openssl_sml.c

   1 #include "openssl/bio.h"
   2 #include "openssl/ssl.h"
   3 #include "openssl/err.h"
   4
   5 #include <sys/types.h>
   6 #include <sys/socket.h>
   7 #include <unistd.h>
   8 #include <netinet/in.h>
   9
  10 void OpenSSL_SML_init() {
  11   SSL_library_init();
  12 }
  13
  14 void OpenSSL_SML_load_error_strings() {
  15   SSL_load_error_strings();
  16   ERR_load_X509_strings();
  17 }
  18
  19 void OpenSSL_SML_load_BIO_strings() {
  20   ERR_load_BIO_strings();
  21 }
  22
  23 int OpenSSL_SML_get_error() {
  24   return ERR_get_error();
  25 }
  26
  27 int OpenSSL_SML_should_retry(BIO *b) {
  28   return BIO_should_retry(b);
  29 }
  30
  31 const char *OpenSSL_SML_lib_error_string(int err) {
  32   return ERR_lib_error_string(err);
  33 }
  34
  35 const char *OpenSSL_SML_func_error_string(int err) {
  36   return ERR_func_error_string(err);
  37 }
  38
  39 const char *OpenSSL_SML_reason_error_string(int err) {
  40   return ERR_reason_error_string(err);
  41 }
  42
  43 int OpenSSL_SML_read(BIO *b, void *data, int len) {
  44   return BIO_read(b, data, len);
  45 }
  46
  47 int OpenSSL_SML_write(BIO *b, const void *data, int len) {
  48   return BIO_write(b, data, len);
  49 }
  50
  51 BIO *OpenSSL_SML_new_connect(char *addr) {
  52   return BIO_new_connect(addr);
  53 }
  54
  55 void OpenSSL_SML_free_all(BIO *b) {
  56   BIO_free_all(b);
  57 }
  58
  59 int OpenSSL_SML_do_connect(BIO *b) {
  60   return BIO_do_connect(b);
  61 }
  62
  63 int OpenSSL_SML_do_accept(BIO *b) {
  64   return BIO_do_accept(b);
  65 }
  66
  67 int OpenSSL_SML_do_handshake(BIO *b) {
  68   return BIO_do_handshake(b);
  69 }
  70
  71 SSL_CTX *OpenSSL_SML_CTX_new(SSL_METHOD *meth) {
  72   SSL_CTX *ctx = SSL_CTX_new(meth);
  73   SSL_CTX_set_verify(ctx,
  74                      SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
  75                      0);
  76   return ctx;
  77 }
  78
  79 void OpenSSL_SML_CTX_free(SSL_CTX *ctx) {
  80   return SSL_CTX_free(ctx);
  81 }
  82
  83 SSL_METHOD *OpenSSL_SML_SSLv23_method() {
  84   return SSLv23_method();
  85 }
  86
  87 int OpenSSL_SML_load_verify_locations(SSL_CTX *ctx, const char *trust, const char *certs) {
  88   return SSL_CTX_load_verify_locations(ctx, trust, certs);
  89 }
  90
  91 BIO *OpenSSL_SML_new_ssl_connect(SSL_CTX *ctx) {
  92   BIO *bio = BIO_new_ssl_connect(ctx);
  93   SSL *ssl;
  94
  95   BIO_get_ssl(bio, &ssl);
  96   SSL_set_mode(ssl, SSL_MODE_AUTO_RETRY);
  97
  98   return bio;
  99 }
 100
 101 BIO *OpenSSL_SML_new_ssl(SSL_CTX *ctx) {
 102   BIO *bio = BIO_new_ssl_connect(ctx);
 103   SSL *ssl;
 104
 105   BIO_get_ssl(bio, &ssl);
 106   SSL_set_mode(ssl, SSL_MODE_AUTO_RETRY);
 107
 108   return bio;
 109 }
 110
 111 BIO *OpenSSL_SML_new_accept(SSL_CTX *ctx, char *port) {
 112   BIO *sbio = BIO_new_ssl(ctx, 0);
 113   BIO *acpt = BIO_new_accept(port);
 114
 115   BIO_set_accept_bios(acpt, sbio);
 116
 117   return acpt;
 118 }
 119
 120 SSL *OpenSSL_SML_get_ssl(BIO *bio) {
 121   SSL *ssl;
 122
 123   if (BIO_get_ssl(bio, &ssl) <= 0)
 124     return NULL;
 125   else
 126     return ssl;
 127 }
 128
 129 int OpenSSL_SML_set_conn_hostname(BIO *bio, char *hostname) {
 130   BIO_set_conn_hostname(bio, hostname);
 131 }
 132
 133 int OpenSSL_SML_set_accept_port(BIO *bio, char *port) {
 134   BIO_set_accept_port(bio, port);
 135 }
 136
 137 int OpenSSL_SML_tcp_listen(int port, int qsize) {
 138   int sock;
 139   struct sockaddr_in sin;
 140   int val=1;
 141
 142   if((sock=socket(AF_INET,SOCK_STREAM,0))<0)
 143     return -1;
 144
 145   memset(&sin,0,sizeof(sin));
 146   sin.sin_addr.s_addr=INADDR_ANY;
 147   sin.sin_family=AF_INET;
 148   sin.sin_port=htons(port);
 149   setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,
 150              &val,sizeof(val));
 151
 152   if(bind(sock,(struct sockaddr *)&sin,
 153           sizeof(sin))<0)
 154     return -1;
 155   listen(sock, qsize);
 156
 157   return sock;
 158 }
 159
 160 int OpenSSL_SML_accept(int sock) {
 161   return accept(sock, 0, 0);
 162 }
 163
 164 BIO *OpenSSL_SML_new_socket(int sock) {
 165   return BIO_new_socket(sock, BIO_NOCLOSE);
 166 }
 167
 168 SSL *OpenSSL_SML_SSL_new(SSL_CTX *ctx) {
 169   SSL *ssl = SSL_new(ctx);
 170
 171   return ssl;
 172 }
 173
 174 int OpenSSL_SML_SSL_shutdown(SSL *ssl) {
 175   return SSL_shutdown(ssl);
 176 }
 177
 178 void OpenSSL_SML_shutdown(int sock) {
 179   shutdown(sock, 1);
 180 }
 181
 182 void OpenSSL_SML_SSL_set_bio(SSL *ssl, BIO *b1, BIO *b2) {
 183   SSL_set_mode(ssl, SSL_MODE_AUTO_RETRY);
 184   SSL_set_bio(ssl, b1, b2);
 185   BIO_set_ssl(b1, ssl, BIO_NOCLOSE);
 186 }
 187
 188 int OpenSSL_SML_use_PrivateKey_file(SSL_CTX *ctx, char *keyfile) {
 189   return SSL_CTX_use_PrivateKey_file(ctx,
 190                                      keyfile,
 191                                      SSL_FILETYPE_PEM);
 192 }
 193
 194 int OpenSSL_SML_SSL_accept(SSL *ssl) {
 195   return SSL_accept(ssl);
 196 }
 197
 198 int OpenSSL_SML_use_certificate_chain_file(SSL_CTX *ctx, char *keyfile) {
 199   return SSL_CTX_use_certificate_chain_file(ctx,
 200                                             keyfile);
 201 }
 202
 203 const char *OpenSSL_SML_get_peer_name(SSL *ssl) {
 204   X509 *x = SSL_get_peer_certificate(ssl);
 205
 206   if (x) {
 207     X509_NAME *name = X509_get_subject_name(x);
 208
 209     if (name) {
 210       X509_NAME_ENTRY *ne;
 211
 212       ne = X509_NAME_get_entry(name, 0);
 213
 214       if (ne) {
 215         ASN1_STRING *s = X509_NAME_ENTRY_get_data(ne);
 216         static char ret[1024];
 217
 218         if (M_ASN1_STRING_length(s) >= sizeof ret)
 219           return NULL;
 220         else {
 221           memcpy(ret, M_ASN1_STRING_data(s), M_ASN1_STRING_length(s));
 222           ret[M_ASN1_STRING_length(s)] = 0;
 223           return ret;
 224         }
 225       } else {
 226         printf("Null entry\n");
 227         return NULL;
 228       }
 229     } else {
 230       printf("Null name\n");
 231       return NULL;
 232     }
 233   } else {
 234     printf("Null certificate\n");
 235     return NULL;
 236   }
 237 }
 238
 239 BIO *OpenSSL_SML_pop(BIO *b) {
 240   return BIO_pop(b);
 241 }
 242
 243 BIO *OpenSSL_SML_next(BIO *b) {
 244   return BIO_next(b);
 245 }
 246
 247 int OpenSSL_SML_puts(BIO *b, const char *buf) {
 248   return BIO_puts(b, buf);
 249 }