replace macros with functions

Submitted by: Tracy Camp <tracyx.e.camp@intel.com>

diff --git a/apps/dgst.c b/apps/dgst.c
index 0c9c351ebc38584d8c5064e20192e98cb714ff96..55ba869c696fc76802b69803c02c11f86281db1e 100644 (file)
--- a/apps/dgst.c
+++ b/apps/dgst.c
@@ -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(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))
                }
 
        if(!app_passwd(bio_err, passargin, NULL, &passin, NULL))

diff --git a/apps/enc.c b/apps/enc.c
index 3e3e8eb4b8a74c4ab62aed3c8d94a946b61ab029..a41ea800ac18ad3e12ecd4566ae137882e695a95 100644 (file)
--- a/apps/enc.c
+++ b/apps/enc.c
@@ -365,8 +365,8 @@ bad:
                {
                BIO_set_callback(in,BIO_debug_callback);
                BIO_set_callback(out,BIO_debug_callback);
                {
                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)
                }
 
        if (inf == NULL)


@@ -453,7 +453,7 @@ bad:
                if (debug)
                        {
                        BIO_set_callback(b64,BIO_debug_callback);
                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);
                        }
                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);
                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)
                        }
 
                if (printkey)

diff --git a/apps/s_client.c b/apps/s_client.c
index 35150704897b399a4c0323b17e473859437f105b..2872a8b64dffb0a3ad2f3bedfaaa6833bdd8c42e 100644 (file)
--- a/apps/s_client.c
+++ b/apps/s_client.c
@@ -872,7 +872,7 @@ re_start:
                {
                con->debug=1;
                BIO_set_callback(sbio,bio_dump_callback);
                {
                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)
                {
                }
        if (c_msg)
                {

diff --git a/apps/s_server.c b/apps/s_server.c
index ac43e5aac1de0b3d46cc48cc39fe0f6140fee4b5..28501eb43a2fea35c556083d8556b158f90cba1e 100644 (file)
--- a/apps/s_server.c
+++ b/apps/s_server.c
@@ -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);
                {
                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)
                {
                }
        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);
                {
                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)
                {
                }
        if (s_msg)
                {

diff --git a/crypto/bio/bio.h b/crypto/bio/bio.h
index d1c522a412b4db3b2386b02f79aafce4e9683d4c..2504cba8de68e0f2d8ba82e0b75adcc83f6ad385 100644 (file)
--- a/crypto/bio/bio.h
+++ b/crypto/bio/bio.h
@@ -196,28 +196,32 @@ extern "C" {
  */
 #define BIO_FLAGS_MEM_RDONLY   0x200
 
  */
 #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) \
 #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) \
 #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) \
 #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 */
 
 /* These are normally used internally in BIOs */

-#define BIO_clear_flags(b,f) ((b)->flags&= ~(f))

 #define BIO_clear_retry_flags(b) \
 #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) \
 #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 */
 
 /* 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,
 
 /* 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_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);
 
 
 typedef void bio_info_cb(struct bio_st *, int, const char *, int, long, long);
 

diff --git a/crypto/bio/bio_lib.c b/crypto/bio/bio_lib.c
index dcc989f9d6bfb930ec667f87855fcf7bc67006db..3f52ae953c2946b88e6d04c360aa52a4c2b631f7 100644 (file)
--- a/crypto/bio/bio_lib.c
+++ b/crypto/bio/bio_lib.c
@@ -141,6 +141,52 @@ int BIO_free(BIO *a)
 void BIO_vfree(BIO *a)
     { BIO_free(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;
 int BIO_read(BIO *b, void *out, int outl)
        {
        int i;

diff --git a/crypto/evp/evp.h b/crypto/evp/evp.h
index f89dedac9effbd3e5d4e263ea32de9dec5767be0..03259d0561189688161627e41876a84d44f6326e 100644 (file)
--- a/crypto/evp/evp.h
+++ b/crypto/evp/evp.h
@@ -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_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_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_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_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)
 
 #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 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))
 
 #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);  
 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);
 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);

diff --git a/crypto/evp/evp_lib.c b/crypto/evp/evp_lib.c
index 36213964dd83c9e3f5f9a2560ff83a50d629864b..745475bebcd4892499a7e0082d96de774c2786b0 100644 (file)
--- a/crypto/evp/evp_lib.c
+++ b/crypto/evp/evp_lib.c
@@ -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);
+       }

diff --git a/ssl/ssl.h b/ssl/ssl.h
index 23f1426cc6d8e1a450b5339613005018d017e48b..ed87d0430222ada7d5005e276e12dc060cdf880a 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_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
 
 #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);
 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);

diff --git a/ssl/ssl_lib.c b/ssl/ssl_lib.c
index 44f82eb3ee88037bfd917fe81f9e328f4d205cfc..1cc3ac9cb6c4e7d17381c31d943cfb23c4c53572 100644 (file)
--- a/ssl/ssl_lib.c
+++ b/ssl/ssl_lib.c
@@ -2550,14 +2550,14 @@ int SSL_CTX_load_verify_locations(SSL_CTX *ctx, const char *CAfile,
 #endif
 
 void SSL_set_info_callback(SSL *ssl,
 #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.  */
        {
        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;
        }
        {
        return ssl->info_callback;
        }


@@ -2764,6 +2764,36 @@ const char *SSL_get_psk_identity(const SSL *s)
                return NULL;
        return(s->session->psk_identity);
        }
                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))
 #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))

diff --git a/ssl/ssl_sess.c b/ssl/ssl_sess.c
index 7e0e786a42c52ed4a10ff7c248baf5fa61192ced..d83a2b03f44944f0dc41bc78fbbe7b527e342887 100644 (file)
--- a/ssl/ssl_sess.c
+++ b/ssl/ssl_sess.c
@@ -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;
+       }
+