Generate DLLs with Mingw32.

[openssl.git] / ssl / s2_srvr.c

diff --git a/ssl/s2_srvr.c b/ssl/s2_srvr.c
index c6c8ea32f14472ed86639b66c5a367e1f05d53ec..e7eff6f6137e330a968eb5bb6053ee42388d9841 100644 (file)
--- a/ssl/s2_srvr.c
+++ b/ssl/s2_srvr.c
@@ -56,14 +56,15 @@
  * [including the GNU Public Licence.]
  */
 
+#ifndef NO_RSA
 #include <stdio.h>
-#include "bio.h"
-#include "rand.h"
-#include "objects.h"
+#include <openssl/bio.h>
+#include <openssl/rand.h>
+#include <openssl/objects.h>
 #include "ssl_locl.h"
-#include "evp.h"
+#include <openssl/evp.h>
 
-#ifndef NOPROTO
+static SSL_METHOD *ssl2_get_server_method(int ver);
 static int get_client_master_key(SSL *s);
 static int get_client_hello(SSL *s);
 static int server_hello(SSL *s); 
@@ -73,21 +74,9 @@ static int server_finish(SSL *s);
 static int request_certificate(SSL *s);
 static int ssl_rsa_private_decrypt(CERT *c, int len, unsigned char *from,
        unsigned char *to,int padding);
-#else
-static int get_client_master_key();
-static int get_client_hello();
-static int server_hello(); 
-static int get_client_finished();
-static int server_verify();
-static int server_finish();
-static int request_certificate();
-static int ssl_rsa_private_decrypt();
-#endif
-
 #define BREAK  break
 
-static SSL_METHOD *ssl2_get_server_method(ver)
-int ver;
+static SSL_METHOD *ssl2_get_server_method(int ver)
        {
        if (ver == SSL2_VERSION)
                return(SSLv2_server_method());
@@ -95,24 +84,23 @@ int ver;
                return(NULL);
        }
 
-SSL_METHOD *SSLv2_server_method()
+SSL_METHOD *SSLv2_server_method(void)
        {
        static int init=1;
        static SSL_METHOD SSLv2_server_data;
 
        if (init)
                {
-               init=0;
                memcpy((char *)&SSLv2_server_data,(char *)sslv2_base_method(),
                        sizeof(SSL_METHOD));
                SSLv2_server_data.ssl_accept=ssl2_accept;
                SSLv2_server_data.get_ssl_method=ssl2_get_server_method;
+               init=0;
                }
        return(&SSLv2_server_data);
        }
 
-int ssl2_accept(s)
-SSL *s;
+int ssl2_accept(SSL *s)
        {
        unsigned long l=time(NULL);
        BUF_MEM *buf=NULL;
@@ -121,7 +109,7 @@ SSL *s;
        void (*cb)()=NULL;
        int new_state,state;
 
-       RAND_seed((unsigned char *)&l,sizeof(l));
+       RAND_seed(&l,sizeof(l));
        ERR_clear_error();
        clear_sys_error();
 
@@ -153,6 +141,7 @@ SSL *s;
                case SSL_ST_BEFORE|SSL_ST_ACCEPT:
                case SSL_ST_OK|SSL_ST_ACCEPT:
 
+                       s->server=1;
                        if (cb != NULL) cb(s,SSL_CB_HANDSHAKE_START,1);
 
                        s->version=SSL2_VERSION;
@@ -166,7 +155,7 @@ SSL *s;
                                { ret= -1; goto end; }
                        s->init_buf=buf;
                        s->init_num=0;
-                       s->ctx->sess_accept++;
+                       s->ctx->stats.sess_accept++;
                        s->handshake_func=ssl2_accept;
                        s->state=SSL2_ST_GET_CLIENT_HELLO_A;
                        BREAK;
@@ -293,13 +282,14 @@ SSL *s;
 
                case SSL_ST_OK:
                        BUF_MEM_free(s->init_buf);
+                       ssl_free_wbio_buffer(s);
                        s->init_buf=NULL;
                        s->init_num=0;
                /*      ERR_clear_error();*/
 
                        ssl_update_cache(s,SSL_SESS_CACHE_SERVER);
 
-                       s->ctx->sess_accept_good++;
+                       s->ctx->stats.sess_accept_good++;
                        /* s->server=1; */
                        ret=1;
 
@@ -330,14 +320,13 @@ end:
        return(ret);
        }
 
-static int get_client_master_key(s)
-SSL *s;
+static int get_client_master_key(SSL *s)
        {
-       int export,i,n,keya,error=0,ek;
+       int export,i,n,keya,ek;
        unsigned char *p;
        SSL_CIPHER *cp;
-       EVP_CIPHER *c;
-       EVP_MD *md;
+       const EVP_CIPHER *c;
+       const EVP_MD *md;
 
        p=(unsigned char *)s->init_buf->data;
        if (s->state == SSL2_ST_GET_CLIENT_MASTER_KEY_A)
@@ -397,9 +386,9 @@ SSL *s;
                &(p[s->s2->tmp.clear]),&(p[s->s2->tmp.clear]),
                (s->s2->ssl2_rollback)?RSA_SSLV23_PADDING:RSA_PKCS1_PADDING);
 
-       export=(s->session->cipher->algorithms & SSL_EXP)?1:0;
+       export=SSL_C_IS_EXPORT(s->session->cipher);
        
-       if (!ssl_cipher_get_evp(s->session->cipher,&c,&md))
+       if (!ssl_cipher_get_evp(s->session,&c,&md,NULL))
                {
                ssl2_return_error(s,SSL2_PE_NO_CIPHER);
                SSLerr(SSL_F_GET_CLIENT_MASTER_KEY,SSL_R_PROBLEMS_MAPPING_CIPHER_FUNCTIONS);
@@ -456,13 +445,12 @@ SSL *s;
        return(1);
        }
 
-static int get_client_hello(s)
-SSL *s;
+static int get_client_hello(SSL *s)
        {
        int i,n;
        unsigned char *p;
-       STACK *cs; /* a stack of SSL_CIPHERS */
-       STACK *cl; /* the ones we want to use */
+       STACK_OF(SSL_CIPHER) *cs; /* a stack of SSL_CIPHERS */
+       STACK_OF(SSL_CIPHER) *cl; /* the ones we want to use */
        int z;
 
        /* This is a bit of a hack to check for the correct packet
@@ -570,11 +558,11 @@ SSL *s;
 
                cl=ssl_get_ciphers_by_id(s);
 
-               for (z=0; z<sk_num(cs); z++)
+               for (z=0; z<sk_SSL_CIPHER_num(cs); z++)
                        {
-                       if (sk_find(cl,sk_value(cs,z)) < 0)
+                       if (sk_SSL_CIPHER_find(cl,sk_SSL_CIPHER_value(cs,z)) < 0)
                                {
-                               sk_delete(cs,z);
+                               sk_SSL_CIPHER_delete(cs,z);
                                z--;
                                }
                        }
@@ -599,12 +587,11 @@ mem_err:
        return(0);
        }
 
-static int server_hello(s)
-SSL *s;
+static int server_hello(SSL *s)
        {
        unsigned char *p,*d;
        int n,hit;
-       STACK *sk;
+       STACK_OF(SSL_CIPHER) *sk;
 
        p=(unsigned char *)s->init_buf->data;
        if (s->state == SSL2_ST_SEND_SERVER_HELLO_A)
@@ -690,8 +677,7 @@ SSL *s;
        return(ssl2_do_write(s));
        }
 
-static int get_client_finished(s)
-SSL *s;
+static int get_client_finished(SSL *s)
        {
        unsigned char *p;
        int i;
@@ -733,8 +719,7 @@ SSL *s;
        return(1);
        }
 
-static int server_verify(s)
-SSL *s;
+static int server_verify(SSL *s)
        {
        unsigned char *p;
 
@@ -752,8 +737,7 @@ SSL *s;
        return(ssl2_do_write(s));
        }
 
-static int server_finish(s)
-SSL *s;
+static int server_finish(SSL *s)
        {
        unsigned char *p;
 
@@ -776,14 +760,13 @@ SSL *s;
        }
 
 /* send the request and check the response */
-static int request_certificate(s)
-SSL *s;
+static int request_certificate(SSL *s)
        {
        unsigned char *p,*p2,*buf2;
        unsigned char *ccd;
        int i,j,ctype,ret= -1;
        X509 *x509=NULL;
-       STACK *sk=NULL;
+       STACK_OF(X509) *sk=NULL;
 
        ccd=s->s2->tmp.ccl;
        if (s->state == SSL2_ST_SEND_REQUEST_CERTIFICATE_A)
@@ -872,7 +855,7 @@ SSL *s;
                goto msg_end;
                }
 
-       if (((sk=sk_new_null()) == NULL) || (!sk_push(sk,(char *)x509)))
+       if (((sk=sk_X509_new_null()) == NULL) || (!sk_X509_push(sk,x509)))
                {
                SSLerr(SSL_F_REQUEST_CERTIFICATE,ERR_R_MALLOC_FAILURE);
                goto msg_end;
@@ -905,6 +888,7 @@ SSL *s;
                pkey=X509_get_pubkey(x509);
                if (pkey == NULL) goto end;
                i=EVP_VerifyFinal(&ctx,p,s->s2->tmp.rlen,pkey);
+               EVP_PKEY_free(pkey);
                memset(&ctx,0,sizeof(ctx));
 
                if (i) 
@@ -928,17 +912,13 @@ msg_end:
                ssl2_return_error(s,SSL2_PE_BAD_CERTIFICATE);
                }
 end:
-       if (sk != NULL) sk_free(sk);
-       if (x509 != NULL) X509_free(x509);
+       sk_X509_free(sk);
+       X509_free(x509);
        return(ret);
        }
 
-static int ssl_rsa_private_decrypt(c, len, from, to,padding)
-CERT *c;
-int len;
-unsigned char *from;
-unsigned char *to;
-int padding;
+static int ssl_rsa_private_decrypt(CERT *c, int len, unsigned char *from,
+            unsigned char *to, int padding)
        {
        RSA *rsa;
        int i;
@@ -961,4 +941,4 @@ int padding;
                SSLerr(SSL_F_SSL_RSA_PRIVATE_DECRYPT,ERR_R_RSA_LIB);
        return(i);
        }
-
+#endif