replace macros with functions
authorNils Larsch <nils@openssl.org>
Wed, 29 Nov 2006 20:54:57 +0000 (20:54 +0000)
committerNils Larsch <nils@openssl.org>
Wed, 29 Nov 2006 20:54:57 +0000 (20:54 +0000)
Submitted by: Tracy Camp <tracyx.e.camp@intel.com>

apps/dgst.c
apps/enc.c
apps/s_client.c
apps/s_server.c
crypto/bio/bio.h
crypto/bio/bio_lib.c
crypto/evp/evp.h
crypto/evp/evp_lib.c
ssl/ssl.h
ssl/ssl_lib.c
ssl/ssl_sess.c

index 0c9c351..55ba869 100644 (file)
@@ -264,7 +264,7 @@ int MAIN(int argc, char **argv)
                {
                BIO_set_callback(in,BIO_debug_callback);
                /* needed for windows 3.1 */
-               BIO_set_callback_arg(in,bio_err);
+               BIO_set_callback_arg(in,(char *)bio_err);
                }
 
        if(!app_passwd(bio_err, passargin, NULL, &passin, NULL))
index 3e3e8eb..a41ea80 100644 (file)
@@ -365,8 +365,8 @@ bad:
                {
                BIO_set_callback(in,BIO_debug_callback);
                BIO_set_callback(out,BIO_debug_callback);
-               BIO_set_callback_arg(in,bio_err);
-               BIO_set_callback_arg(out,bio_err);
+               BIO_set_callback_arg(in,(char *)bio_err);
+               BIO_set_callback_arg(out,(char *)bio_err);
                }
 
        if (inf == NULL)
@@ -453,7 +453,7 @@ bad:
                if (debug)
                        {
                        BIO_set_callback(b64,BIO_debug_callback);
-                       BIO_set_callback_arg(b64,bio_err);
+                       BIO_set_callback_arg(b64,(char *)bio_err);
                        }
                if (olb64)
                        BIO_set_flags(b64,BIO_FLAGS_BASE64_NO_NL);
@@ -571,7 +571,7 @@ bad:
                if (debug)
                        {
                        BIO_set_callback(benc,BIO_debug_callback);
-                       BIO_set_callback_arg(benc,bio_err);
+                       BIO_set_callback_arg(benc,(char *)bio_err);
                        }
 
                if (printkey)
index 3515070..2872a8b 100644 (file)
@@ -872,7 +872,7 @@ re_start:
                {
                con->debug=1;
                BIO_set_callback(sbio,bio_dump_callback);
-               BIO_set_callback_arg(sbio,bio_c_out);
+               BIO_set_callback_arg(sbio,(char *)bio_c_out);
                }
        if (c_msg)
                {
index ac43e5a..28501eb 100644 (file)
@@ -1602,7 +1602,7 @@ static int sv_body(char *hostname, int s, unsigned char *context)
                {
                con->debug=1;
                BIO_set_callback(SSL_get_rbio(con),bio_dump_callback);
-               BIO_set_callback_arg(SSL_get_rbio(con),bio_s_out);
+               BIO_set_callback_arg(SSL_get_rbio(con),(char *)bio_s_out);
                }
        if (s_msg)
                {
@@ -2020,7 +2020,7 @@ static int www_body(char *hostname, int s, unsigned char *context)
                {
                con->debug=1;
                BIO_set_callback(SSL_get_rbio(con),bio_dump_callback);
-               BIO_set_callback_arg(SSL_get_rbio(con),bio_s_out);
+               BIO_set_callback_arg(SSL_get_rbio(con),(char *)bio_s_out);
                }
        if (s_msg)
                {
index d1c522a..2504cba 100644 (file)
@@ -196,28 +196,32 @@ extern "C" {
  */
 #define BIO_FLAGS_MEM_RDONLY   0x200
 
-#define BIO_set_flags(b,f) ((b)->flags|=(f))
-#define BIO_get_flags(b) ((b)->flags)
+typedef struct bio_st BIO;
+
+void BIO_set_flags(BIO *b, int flags);
+int  BIO_test_flags(const BIO *b, int flags);
+void BIO_clear_flags(BIO *b, int flags);
+
+#define BIO_get_flags(b) BIO_test_flags(b, ~(0x0))
 #define BIO_set_retry_special(b) \
-               ((b)->flags|=(BIO_FLAGS_IO_SPECIAL|BIO_FLAGS_SHOULD_RETRY))
+               BIO_set_flags(b, (BIO_FLAGS_IO_SPECIAL|BIO_FLAGS_SHOULD_RETRY))
 #define BIO_set_retry_read(b) \
-               ((b)->flags|=(BIO_FLAGS_READ|BIO_FLAGS_SHOULD_RETRY))
+               BIO_set_flags(b, (BIO_FLAGS_READ|BIO_FLAGS_SHOULD_RETRY))
 #define BIO_set_retry_write(b) \
-               ((b)->flags|=(BIO_FLAGS_WRITE|BIO_FLAGS_SHOULD_RETRY))
+               BIO_set_flags(b, (BIO_FLAGS_WRITE|BIO_FLAGS_SHOULD_RETRY))
 
 /* These are normally used internally in BIOs */
-#define BIO_clear_flags(b,f) ((b)->flags&= ~(f))
 #define BIO_clear_retry_flags(b) \
-               ((b)->flags&= ~(BIO_FLAGS_RWS|BIO_FLAGS_SHOULD_RETRY))
+               BIO_clear_flags(b, (BIO_FLAGS_RWS|BIO_FLAGS_SHOULD_RETRY))
 #define BIO_get_retry_flags(b) \
-               ((b)->flags&(BIO_FLAGS_RWS|BIO_FLAGS_SHOULD_RETRY))
+               BIO_test_flags(b, (BIO_FLAGS_RWS|BIO_FLAGS_SHOULD_RETRY))
 
 /* These should be used by the application to tell why we should retry */
-#define BIO_should_read(a)             ((a)->flags & BIO_FLAGS_READ)
-#define BIO_should_write(a)            ((a)->flags & BIO_FLAGS_WRITE)
-#define BIO_should_io_special(a)       ((a)->flags & BIO_FLAGS_IO_SPECIAL)
-#define BIO_retry_type(a)              ((a)->flags & BIO_FLAGS_RWS)
-#define BIO_should_retry(a)            ((a)->flags & BIO_FLAGS_SHOULD_RETRY)
+#define BIO_should_read(a)             BIO_test_flags(a, BIO_FLAGS_READ)
+#define BIO_should_write(a)            BIO_test_flags(a, BIO_FLAGS_WRITE)
+#define BIO_should_io_special(a)       BIO_test_flags(a, BIO_FLAGS_IO_SPECIAL)
+#define BIO_retry_type(a)              BIO_test_flags(a, BIO_FLAGS_RWS)
+#define BIO_should_retry(a)            BIO_test_flags(a, BIO_FLAGS_SHOULD_RETRY)
 
 /* The next three are used in conjunction with the
  * BIO_should_io_special() condition.  After this returns true,
@@ -246,14 +250,14 @@ extern "C" {
 #define BIO_cb_pre(a)  (!((a)&BIO_CB_RETURN))
 #define BIO_cb_post(a) ((a)&BIO_CB_RETURN)
 
-#define BIO_set_callback(b,cb)         ((b)->callback=(cb))
-#define BIO_set_callback_arg(b,arg)    ((b)->cb_arg=(char *)(arg))
-#define BIO_get_callback_arg(b)                ((b)->cb_arg)
-#define BIO_get_callback(b)            ((b)->callback)
-#define BIO_method_name(b)             ((b)->method->name)
-#define BIO_method_type(b)             ((b)->method->type)
+long (*BIO_get_callback(const BIO *b)) (struct bio_st *,int,const char *,int, long,long);
+void BIO_set_callback(BIO *b, 
+       long (*callback)(struct bio_st *,int,const char *,int, long,long));
+char *BIO_get_callback_arg(const BIO *b);
+void BIO_set_callback_arg(BIO *b, char *arg);
 
-typedef struct bio_st BIO;
+const char * BIO_method_name(const BIO *b);
+int BIO_method_type(const BIO *b);
 
 typedef void bio_info_cb(struct bio_st *, int, const char *, int, long, long);
 
index dcc989f..3f52ae9 100644 (file)
@@ -141,6 +141,52 @@ int BIO_free(BIO *a)
 void BIO_vfree(BIO *a)
     { BIO_free(a); }
 
+void BIO_clear_flags(BIO *b, int flags)
+       {
+       b->flags &= ~flags;
+       }
+
+int    BIO_test_flags(const BIO *b, int flags)
+       {
+       return (b->flags & flags);
+       }
+
+void   BIO_set_flags(BIO *b, int flags)
+       {
+       b->flags |= flags;
+       }
+
+long (*BIO_get_callback(const BIO *b))(struct bio_st *,int,const char *,int, long,long)
+       {
+       return b->callback;
+       }
+
+void BIO_set_callback(BIO *b, long (*cb)(struct bio_st *,int,const char *,int, long,long))
+       {
+       b->callback = cb;
+       }
+
+void BIO_set_callback_arg(BIO *b, char *arg)
+       {
+       b->cb_arg = arg;
+       }
+
+char * BIO_get_callback_arg(const BIO *b)
+       {
+       return b->cb_arg;
+       }
+
+const char * BIO_method_name(const BIO *b)
+       {
+       return b->method->name;
+       }
+
+int BIO_method_type(const BIO *b)
+       {
+       return b->method->type;
+       }
+
+
 int BIO_read(BIO *b, void *out, int outl)
        {
        int i;
index f89deda..03259d0 100644 (file)
@@ -411,36 +411,36 @@ typedef int (EVP_PBE_KEYGEN)(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
 #define EVP_get_cipherbynid(a) EVP_get_cipherbyname(OBJ_nid2sn(a))
 #define EVP_get_cipherbyobj(a) EVP_get_cipherbynid(OBJ_obj2nid(a))
 
-#define EVP_MD_type(e)                 ((e)->type)
+int EVP_MD_type(const EVP_MD *md);
 #define EVP_MD_nid(e)                  EVP_MD_type(e)
 #define EVP_MD_name(e)                 OBJ_nid2sn(EVP_MD_nid(e))
-#define EVP_MD_pkey_type(e)            ((e)->pkey_type)
-#define EVP_MD_size(e)                 ((e)->md_size)
-#define EVP_MD_block_size(e)           ((e)->block_size)
+int EVP_MD_pkey_type(const EVP_MD *md);        
+int EVP_MD_size(const EVP_MD *md);
+int EVP_MD_block_size(const EVP_MD *md);
 
-#define EVP_MD_CTX_md(e)               ((e)->digest)
-#define EVP_MD_CTX_size(e)             EVP_MD_size((e)->digest)
-#define EVP_MD_CTX_block_size(e)       EVP_MD_block_size((e)->digest)
-#define EVP_MD_CTX_type(e)             EVP_MD_type((e)->digest)
+const EVP_MD *EVP_MD_CTX_md(const EVP_MD_CTX *ctx);
+#define EVP_MD_CTX_size(e)             EVP_MD_size(EVP_MD_CTX_md(e))
+#define EVP_MD_CTX_block_size(e)       EVP_MD_block_size(EVP_MD_CTX_md(e))
+#define EVP_MD_CTX_type(e)             EVP_MD_type(EVP_MD_CTX_md(e))
 
-#define EVP_CIPHER_nid(e)              ((e)->nid)
+int EVP_CIPHER_nid(const EVP_CIPHER *cipher);
 #define EVP_CIPHER_name(e)             OBJ_nid2sn(EVP_CIPHER_nid(e))
-#define EVP_CIPHER_block_size(e)       ((e)->block_size)
-#define EVP_CIPHER_key_length(e)       ((e)->key_len)
-#define EVP_CIPHER_iv_length(e)                ((e)->iv_len)
-#define EVP_CIPHER_flags(e)            ((e)->flags)
-#define EVP_CIPHER_mode(e)             (((e)->flags) & EVP_CIPH_MODE)
-
-#define EVP_CIPHER_CTX_cipher(e)       ((e)->cipher)
-#define EVP_CIPHER_CTX_nid(e)          ((e)->cipher->nid)
-#define EVP_CIPHER_CTX_block_size(e)   ((e)->cipher->block_size)
-#define EVP_CIPHER_CTX_key_length(e)   ((e)->key_len)
-#define EVP_CIPHER_CTX_iv_length(e)    ((e)->cipher->iv_len)
-#define EVP_CIPHER_CTX_get_app_data(e) ((e)->app_data)
-#define EVP_CIPHER_CTX_set_app_data(e,d) ((e)->app_data=(char *)(d))
+int EVP_CIPHER_block_size(const EVP_CIPHER *cipher);
+int EVP_CIPHER_key_length(const EVP_CIPHER *cipher);
+int EVP_CIPHER_iv_length(const EVP_CIPHER *cipher);
+unsigned long EVP_CIPHER_flags(const EVP_CIPHER *cipher);
+#define EVP_CIPHER_mode(e)             (EVP_CIPHER_flags(e) & EVP_CIPH_MODE)
+
+const EVP_CIPHER * EVP_CIPHER_CTX_cipher(const EVP_CIPHER_CTX *ctx);
+int EVP_CIPHER_CTX_nid(const EVP_CIPHER_CTX *ctx);
+int EVP_CIPHER_CTX_block_size(const EVP_CIPHER_CTX *ctx);
+int EVP_CIPHER_CTX_key_length(const EVP_CIPHER_CTX *ctx);
+int EVP_CIPHER_CTX_iv_length(const EVP_CIPHER_CTX *ctx);
+void * EVP_CIPHER_CTX_get_app_data(const EVP_CIPHER_CTX *ctx);
+void EVP_CIPHER_CTX_set_app_data(EVP_CIPHER_CTX *ctx, void *data);
 #define EVP_CIPHER_CTX_type(c)         EVP_CIPHER_type(EVP_CIPHER_CTX_cipher(c))
-#define EVP_CIPHER_CTX_flags(e)                ((e)->cipher->flags)
-#define EVP_CIPHER_CTX_mode(e)         ((e)->cipher->flags & EVP_CIPH_MODE)
+unsigned long EVP_CIPHER_CTX_flags(const EVP_CIPHER_CTX *ctx);
+#define EVP_CIPHER_CTX_mode(e)         (EVP_CIPHER_CTX_flags(e) & EVP_CIPH_MODE)
 
 #define EVP_ENCODE_LENGTH(l)   (((l+2)/3*4)+(l/48+1)*2+80)
 #define EVP_DECODE_LENGTH(l)   ((l+3)/4*3+80)
@@ -466,7 +466,10 @@ void BIO_set_md(BIO *,const EVP_MD *md);
 #define BIO_get_cipher_status(b)       BIO_ctrl(b,BIO_C_GET_CIPHER_STATUS,0,NULL)
 #define BIO_get_cipher_ctx(b,c_pp)     BIO_ctrl(b,BIO_C_GET_CIPHER_CTX,0,(char *)c_pp)
 
-#define        EVP_Cipher(c,o,i,l)     (c)->cipher->do_cipher((c),(o),(i),(l))
+int EVP_Cipher(EVP_CIPHER_CTX *c,
+               unsigned char *out,
+               const unsigned char *in,
+               unsigned int inl);
 
 #define EVP_add_cipher_alias(n,alias) \
        OBJ_NAME_add((alias),OBJ_NAME_TYPE_CIPHER_METH|OBJ_NAME_ALIAS,(n))
@@ -482,9 +485,9 @@ int EVP_MD_CTX_cleanup(EVP_MD_CTX *ctx);
 EVP_MD_CTX *EVP_MD_CTX_create(void);
 void   EVP_MD_CTX_destroy(EVP_MD_CTX *ctx);
 int     EVP_MD_CTX_copy_ex(EVP_MD_CTX *out,const EVP_MD_CTX *in);  
-#define EVP_MD_CTX_set_flags(ctx,flgs) ((ctx)->flags|=(flgs))
-#define EVP_MD_CTX_clear_flags(ctx,flgs) ((ctx)->flags&=~(flgs))
-#define EVP_MD_CTX_test_flags(ctx,flgs) ((ctx)->flags&(flgs))
+void   EVP_MD_CTX_set_flags(EVP_MD_CTX *ctx, int flags);
+void   EVP_MD_CTX_clear_flags(EVP_MD_CTX *ctx, int flags);
+int    EVP_MD_CTX_test_flags(const EVP_MD_CTX *ctx,int flags);
 int    EVP_DigestInit_ex(EVP_MD_CTX *ctx, const EVP_MD *type, ENGINE *impl);
 int    EVP_DigestUpdate(EVP_MD_CTX *ctx,const void *d,
                         size_t cnt);
index 3621396..745475b 100644 (file)
@@ -168,3 +168,112 @@ int EVP_CIPHER_type(const EVP_CIPHER *ctx)
        }
 }
 
+int EVP_CIPHER_block_size(const EVP_CIPHER *e)
+       {
+       return e->block_size;
+       }
+
+int EVP_CIPHER_CTX_block_size(const EVP_CIPHER_CTX *ctx)
+       {
+       return ctx->cipher->block_size;
+       }
+
+int EVP_Cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, unsigned int inl)
+       {
+       return ctx->cipher->do_cipher(ctx,out,in,inl);
+       }
+
+const EVP_CIPHER *EVP_CIPHER_CTX_cipher(const EVP_CIPHER_CTX *ctx)
+       {
+       return ctx->cipher;
+       }
+
+unsigned long EVP_CIPHER_flags(const EVP_CIPHER *cipher)
+       {
+       return cipher->flags;
+       }
+
+unsigned long EVP_CIPHER_CTX_flags(const EVP_CIPHER_CTX *ctx)
+       {
+       return ctx->cipher->flags;
+       }
+
+void *EVP_CIPHER_CTX_get_app_data(const EVP_CIPHER_CTX *ctx)
+       {
+       return ctx->app_data;
+       }
+
+void EVP_CIPHER_CTX_set_app_data(EVP_CIPHER_CTX *ctx, void *data)
+       {
+       ctx->app_data = data;
+       }
+
+int EVP_CIPHER_iv_length(const EVP_CIPHER *cipher)
+       {
+       return cipher->iv_len;
+       }
+
+int EVP_CIPHER_CTX_iv_length(const EVP_CIPHER_CTX *ctx)
+       {
+       return ctx->cipher->iv_len;
+       }
+
+int EVP_CIPHER_key_length(const EVP_CIPHER *cipher)
+       {
+       return cipher->key_len;
+       }
+
+int EVP_CIPHER_CTX_key_length(const EVP_CIPHER_CTX *ctx)
+       {
+       return ctx->cipher->key_len;
+       }
+
+int EVP_CIPHER_nid(const EVP_CIPHER *cipher)
+       {
+       return cipher->nid;
+       }
+
+int EVP_CIPHER_CTX_nid(const EVP_CIPHER_CTX *ctx)
+       {
+       return ctx->cipher->nid;
+       }
+
+int EVP_MD_block_size(const EVP_MD *md) 
+       {
+       return md->block_size;
+       }
+
+int EVP_MD_type(const EVP_MD *md)
+       {
+       return md->type;
+       }
+
+int EVP_MD_pkey_type(const EVP_MD *md)
+       {
+       return md->pkey_type;
+       }
+
+int EVP_MD_size(const EVP_MD *md)
+       {
+       return md->md_size;
+       }
+
+const EVP_MD *EVP_MD_CTX_md(const EVP_MD_CTX *ctx)
+       {
+       return ctx->digest;
+       }
+
+void EVP_MD_CTX_set_flags(EVP_MD_CTX *ctx, int flags)
+       {
+       ctx->flags |= flags;
+       }
+
+void EVP_MD_CTX_clear_flags(EVP_MD_CTX *ctx, int flags)
+       {
+       ctx->flags &= ~flags;
+       }
+
+int EVP_MD_CTX_test_flags(const EVP_MD_CTX *ctx, int flags)
+       {
+       return (ctx->flags & flags);
+       }
index 23f1426..ed87d04 100644 (file)
--- a/ssl/ssl.h
+++ b/ssl/ssl.h
@@ -865,28 +865,38 @@ struct ssl_ctx_st
 #define SSL_CTX_sess_cache_full(ctx) \
        SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_CACHE_FULL,0,NULL)
 
-#define SSL_CTX_sess_set_new_cb(ctx,cb)        ((ctx)->new_session_cb=(cb))
-#define SSL_CTX_sess_get_new_cb(ctx)   ((ctx)->new_session_cb)
-#define SSL_CTX_sess_set_remove_cb(ctx,cb)     ((ctx)->remove_session_cb=(cb))
-#define SSL_CTX_sess_get_remove_cb(ctx)        ((ctx)->remove_session_cb)
-#define SSL_CTX_sess_set_get_cb(ctx,cb)        ((ctx)->get_session_cb=(cb))
-#define SSL_CTX_sess_get_get_cb(ctx)   ((ctx)->get_session_cb)
-#define SSL_CTX_set_info_callback(ctx,cb)      ((ctx)->info_callback=(cb))
-#define SSL_CTX_get_info_callback(ctx)         ((ctx)->info_callback)
-#define SSL_CTX_set_client_cert_cb(ctx,cb)     ((ctx)->client_cert_cb=(cb))
-#define SSL_CTX_get_client_cert_cb(ctx)                ((ctx)->client_cert_cb)
-#define SSL_CTX_set_cookie_generate_cb(ctx,cb) ((ctx)->app_gen_cookie_cb=(cb))
-#define SSL_CTX_set_cookie_verify_cb(ctx,cb) ((ctx)->app_verify_cookie_cb=(cb))
+void SSL_CTX_sess_set_new_cb(SSL_CTX *ctx, int (*new_session_cb)(struct ssl_st *ssl,SSL_SESSION *sess));
+int (*SSL_CTX_sess_get_new_cb(SSL_CTX *ctx))(struct ssl_st *ssl, SSL_SESSION *sess);
+void SSL_CTX_sess_set_remove_cb(SSL_CTX *ctx, void (*remove_session_cb)(struct ssl_ctx_st *ctx,SSL_SESSION *sess));
+void (*SSL_CTX_sess_get_remove_cb(SSL_CTX *ctx))(struct ssl_ctx_st *ctx, SSL_SESSION *sess);
+void SSL_CTX_sess_set_get_cb(SSL_CTX *ctx, SSL_SESSION *(*get_session_cb)(struct ssl_st *ssl, unsigned char *data,int len,int *copy));
+SSL_SESSION *(*SSL_CTX_sess_get_get_cb(SSL_CTX *ctx))(struct ssl_st *ssl, unsigned char *Data, int len, int *copy);
+void SSL_CTX_set_info_callback(SSL_CTX *ctx, void (*cb)(const SSL *ssl,int type,int val));
+void (*SSL_CTX_get_info_callback(SSL_CTX *ctx))(const SSL *ssl,int type,int val);
+void SSL_CTX_set_client_cert_cb(SSL_CTX *ctx, int (*client_cert_cb)(SSL *ssl, X509 **x509, EVP_PKEY **pkey));
+int (*SSL_CTX_get_client_cert_cb(SSL_CTX *ctx))(SSL *ssl, X509 **x509, EVP_PKEY **pkey);
+void SSL_CTX_set_cookie_generate_cb(SSL_CTX *ctx, int (*app_gen_cookie_cb)(SSL *ssl, unsigned char *cookie, unsigned int *cookie_len));
+void SSL_CTX_set_cookie_verify_cb(SSL_CTX *ctx, int (*app_verify_cookie_cb)(SSL *ssl, unsigned char *cookie, unsigned int cookie_len));
 
 #ifndef OPENSSL_NO_PSK
 /* the maximum length of the buffer given to callbacks containing the
  * resulting identity/psk */
 #define PSK_MAX_IDENTITY_LEN 128
 #define PSK_MAX_PSK_LEN 64
-#define SSL_CTX_set_psk_client_callback(ctx,cb) ((ctx)->psk_client_callback=(cb))
-#define SSL_set_psk_client_callback(ssl, cb) ((ssl)->psk_client_callback=(cb))
-#define SSL_CTX_set_psk_server_callback(ctx,cb) ((ctx)->psk_server_callback=(cb))
-#define SSL_set_psk_server_callback(ssl, cb) ((ssl)->psk_server_callback=(cb))
+void SSL_CTX_set_psk_client_callback(SSL_CTX *ctx, 
+       unsigned int (*psk_client_callback)(SSL *ssl, const char *hint, 
+               char *identity, unsigned int max_identity_len, unsigned char *psk,
+               unsigned int max_psk_len));
+void SSL_set_psk_client_callback(SSL *ssl, 
+       unsigned int (*psk_client_callback)(SSL *ssl, const char *hint, 
+               char *identity, unsigned int max_identity_len, unsigned char *psk,
+               unsigned int max_psk_len));
+void SSL_CTX_set_psk_server_callback(SSL_CTX *ctx, 
+       unsigned int (*psk_server_callback)(SSL *ssl, const char *identity,
+               unsigned char *psk, unsigned int max_psk_len));
+void SSL_set_psk_server_callback(SSL *ssl,
+       unsigned int (*psk_server_callback)(SSL *ssl, const char *identity,
+               unsigned char *psk, unsigned int max_psk_len));
 int SSL_CTX_use_psk_identity_hint(SSL_CTX *ctx, const char *identity_hint);
 int SSL_use_psk_identity_hint(SSL *s, const char *identity_hint);
 const char *SSL_get_psk_identity_hint(const SSL *s);
index 44f82eb..1cc3ac9 100644 (file)
@@ -2550,14 +2550,14 @@ int SSL_CTX_load_verify_locations(SSL_CTX *ctx, const char *CAfile,
 #endif
 
 void SSL_set_info_callback(SSL *ssl,
-                          void (*cb)(const SSL *ssl,int type,int val))
+       void (*cb)(const SSL *ssl,int type,int val))
        {
        ssl->info_callback=cb;
        }
 
 /* One compiler (Diab DCC) doesn't like argument names in returned
    function pointer.  */
-void (*SSL_get_info_callback(const SSL *ssl))(const SSL * /*ssl*/,int /*type*/,int /*val*/)
+void (*SSL_get_info_callback(const SSL *ssl))(const SSL * /*ssl*/,int /*type*/,int /*val*/) 
        {
        return ssl->info_callback;
        }
@@ -2764,6 +2764,36 @@ const char *SSL_get_psk_identity(const SSL *s)
                return NULL;
        return(s->session->psk_identity);
        }
+
+void SSL_set_psk_client_callback(SSL *s, 
+       unsigned int (*cb)(SSL *ssl, const char *hint,
+                char *identity, unsigned int max_identity_len, unsigned char *psk,
+                unsigned int max_psk_len))
+       {
+       s->psk_client_callback = cb;    
+       }
+
+void SSL_CTX_set_psk_client_callback(SSL_CTX *ctx,
+       unsigned int (*cb)(SSL *ssl, const char *hint,
+                char *identity, unsigned int max_identity_len, unsigned char *psk,
+                unsigned int max_psk_len))
+       {
+       ctx->psk_client_callback = cb;  
+       }
+
+void SSL_set_psk_server_callback(SSL *s, 
+       unsigned int (*cb)(SSL *ssl, const char *identity,
+                unsigned char *psk, unsigned int max_psk_len))
+       {
+       s->psk_server_callback = cb;    
+       }
+
+void SSL_CTX_set_psk_server_callback(SSL_CTX *ctx,
+       unsigned int (*cb)(SSL *ssl, const char *identity,
+                unsigned char *psk, unsigned int max_psk_len))
+       {
+       ctx->psk_server_callback = cb;  
+       }
 #endif
 
 void SSL_CTX_set_msg_callback(SSL_CTX *ctx, void (*cb)(int write_p, int version, int content_type, const void *buf, size_t len, SSL *ssl, void *arg))
index 7e0e786..d83a2b0 100644 (file)
@@ -908,3 +908,72 @@ static void SSL_SESSION_list_add(SSL_CTX *ctx, SSL_SESSION *s)
                }
        }
 
+void SSL_CTX_sess_set_new_cb(SSL_CTX *ctx,
+       int (*cb)(struct ssl_st *ssl,SSL_SESSION *sess))
+       {
+       ctx->new_session_cb=cb;
+       }
+
+int (*SSL_CTX_sess_get_new_cb(SSL_CTX *ctx))(struct ssl_st */*ssl*/,SSL_SESSION */*sess*/)
+       {
+       return ctx->new_session_cb;
+       }
+
+void SSL_CTX_sess_set_remove_cb(SSL_CTX *ctx,
+       void (*cb)(struct ssl_ctx_st *ctx,SSL_SESSION *sess))
+       {
+       ctx->remove_session_cb=cb;
+       }
+
+void (*SSL_CTX_sess_get_remove_cb(SSL_CTX *ctx))(struct ssl_ctx_st */*ctx*/,SSL_SESSION */*sess*/)
+       {
+       return ctx->remove_session_cb;
+       }
+
+void SSL_CTX_sess_set_get_cb(SSL_CTX *ctx,
+       SSL_SESSION *(*cb)(struct ssl_st *ssl,
+                unsigned char *data,int len,int *copy))
+       {
+       ctx->get_session_cb=cb;
+       }
+
+SSL_SESSION * (*SSL_CTX_sess_get_get_cb(SSL_CTX *ctx))(struct ssl_st */*ssl*/,
+                unsigned char */*data*/,int /*len*/,int */*copy*/)
+       {
+       return ctx->get_session_cb;
+       }
+
+void SSL_CTX_set_info_callback(SSL_CTX *ctx, 
+       void (*cb)(const SSL *ssl,int type,int val))
+       {
+       ctx->info_callback=cb;
+       }
+
+void (*SSL_CTX_get_info_callback(SSL_CTX *ctx))(const SSL */*ssl*/,int /*type*/,int /*val*/)
+       {
+       return ctx->info_callback;
+       }
+
+void SSL_CTX_set_client_cert_cb(SSL_CTX *ctx,
+       int (*cb)(SSL *ssl, X509 **x509, EVP_PKEY **pkey))
+       {
+       ctx->client_cert_cb=cb;
+       }
+
+int (*SSL_CTX_get_client_cert_cb(SSL_CTX *ctx))(SSL * /*ssl */, X509 **/* x509 */, EVP_PKEY **/*pkey*/)
+       {
+       return ctx->client_cert_cb;
+       }
+
+void SSL_CTX_set_cookie_generate_cb(SSL_CTX *ctx,
+       int (*cb)(SSL *ssl, unsigned char *cookie, unsigned int *cookie_len))
+       {
+       ctx->app_gen_cookie_cb=cb;
+       }
+
+void SSL_CTX_set_cookie_verify_cb(SSL_CTX *ctx,
+       int (*cb)(SSL *ssl, unsigned char *cookie, unsigned int cookie_len))
+       {
+       ctx->app_verify_cookie_cb=cb;
+       }
+