openssl

openssl

Synopsis




#define     GNUTLS_X509_CN_SIZE
#define     GNUTLS_X509_C_SIZE
#define     GNUTLS_X509_O_SIZE
#define     GNUTLS_X509_OU_SIZE
#define     GNUTLS_X509_L_SIZE
#define     GNUTLS_X509_S_SIZE
#define     GNUTLS_X509_EMAIL_SIZE
#define     OPENSSL_VERSION_NUMBER
#define     SSLEAY_VERSION_NUMBER
#define     OPENSSL_VERSION_TEXT
#define     SSL_ERROR_NONE
#define     SSL_ERROR_SSL
#define     SSL_ERROR_WANT_READ
#define     SSL_ERROR_WANT_WRITE
#define     SSL_ERROR_SYSCALL
#define     SSL_ERROR_ZERO_RETURN
#define     SSL_FILETYPE_PEM
#define     SSL_VERIFY_NONE
#define     SSL_ST_OK
#define     X509_V_ERR_CERT_NOT_YET_VALID
#define     X509_V_ERR_CERT_HAS_EXPIRED
#define     X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT
#define     SSL_OP_ALL
#define     SSL_OP_NO_TLSv1
#define     SSL_MODE_ENABLE_PARTIAL_WRITE
#define     SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER
#define     SSL_MODE_AUTO_RETRY
typedef     X509_NAME;
typedef     X509;
            SSL;
#define     current_cert
#define     X509_STORE_CTX_get_current_cert (ctx)
#define     rbio
struct      RSA;
#define     MD5_CTX
#define     RIPEMD160_CTX
#define     OpenSSL_add_ssl_algorithms      ()
#define     SSLeay_add_ssl_algorithms       ()
#define     SSLeay_add_all_algorithms       ()
#define     SSL_get_cipher_name             (ssl)
#define     SSL_get_cipher                  (ssl)
#define     SSL_get_cipher_bits             (ssl,bp)
#define     SSL_get_cipher_version          (ssl)
int         SSL_library_init                (void);
void        OpenSSL_add_all_algorithms      (void);
SSL_CTX*    SSL_CTX_new                     (SSL_METHOD *method);
void        SSL_CTX_free                    (SSL_CTX *ctx);
int         SSL_CTX_set_default_verify_paths
                                            (SSL_CTX *ctx);
int         SSL_CTX_use_certificate_file    (SSL_CTX *ctx,
                                             const char *certfile,
                                             int type);
int         SSL_CTX_use_PrivateKey_file     (SSL_CTX *ctx,
                                             const char *keyfile,
                                             int type);
void        SSL_CTX_set_verify              (SSL_CTX *ctx,
                                             int verify_mode,
                                             int (*verify_callback) (int, X509_STORE_CTX *));
unsigned long SSL_CTX_set_options           (SSL_CTX *ctx,
                                             long options );
long        SSL_CTX_set_mode                (SSL_CTX *ctx,
                                             long mode );
int         SSL_CTX_set_cipher_list         (SSL_CTX *ctx,
                                             const char *list);
long        SSL_CTX_sess_number             (SSL_CTX *ctx);
long        SSL_CTX_sess_connect            (SSL_CTX *ctx);
long        SSL_CTX_sess_connect_good       (SSL_CTX *ctx);
long        SSL_CTX_sess_connect_renegotiate
                                            (SSL_CTX *ctx);
long        SSL_CTX_sess_accept             (SSL_CTX *ctx);
long        SSL_CTX_sess_accept_good        (SSL_CTX *ctx);
long        SSL_CTX_sess_accept_renegotiate (SSL_CTX *ctx);
long        SSL_CTX_sess_hits               (SSL_CTX *ctx);
long        SSL_CTX_sess_misses             (SSL_CTX *ctx);
long        SSL_CTX_sess_timeouts           (SSL_CTX *ctx);
SSL*        SSL_new                         (SSL_CTX *ctx);
void        SSL_free                        (SSL *ssl);
void        SSL_load_error_strings          (void);
int         SSL_get_error                   (SSL *ssl,
                                             int ret);
int         SSL_set_fd                      (SSL *ssl,
                                             int fd);
int         SSL_set_rfd                     (SSL *ssl,
                                             int fd);
int         SSL_set_wfd                     (SSL *ssl,
                                             int fd);
void        SSL_set_bio                     (SSL *ssl,
                                             BIO *rbio,
                                             BIO *wbio);
void        SSL_set_connect_state           (SSL *ssl);
int         SSL_pending                     (SSL *ssl);
void        SSL_set_verify                  (SSL *ssl,
                                             int verify_mode,
                                             int (*verify_callback) (int, X509_STORE_CTX *));
const X509* SSL_get_peer_certificate        (SSL *ssl);
int         SSL_connect                     (SSL *ssl);
int         SSL_accept                      (SSL *ssl);
int         SSL_shutdown                    (SSL *ssl);
int         SSL_read                        (SSL *ssl,
                                             void *buf,
                                             int len);
int         SSL_write                       (SSL *ssl,
                                             const void *buf,
                                             int len);
int         SSL_want                        (SSL *ssl);
#define     SSL_NOTHING
#define     SSL_WRITING
#define     SSL_READING
#define     SSL_X509_LOOKUP
#define     SSL_want_nothing                (s)
#define     SSL_want_read                   (s)
#define     SSL_want_write                  (s)
#define     SSL_want_x509_lookup            (s)
SSL_METHOD* SSLv23_client_method            (void);
SSL_METHOD* SSLv23_server_method            (void);
SSL_METHOD* SSLv3_client_method             (void);
SSL_METHOD* SSLv3_server_method             (void);
SSL_METHOD* TLSv1_client_method             (void);
SSL_METHOD* TLSv1_server_method             (void);
SSL_CIPHER* SSL_get_current_cipher          (SSL *ssl);
const char* SSL_CIPHER_get_name             (SSL_CIPHER *cipher);
int         SSL_CIPHER_get_bits             (SSL_CIPHER *cipher,
                                             int *bits);
const char* SSL_CIPHER_get_version          (SSL_CIPHER *cipher);
char*       SSL_CIPHER_description          (SSL_CIPHER *cipher,
                                             char *buf,
                                             int size);
X509_NAME*  X509_get_subject_name           (const X509 *cert);
X509_NAME*  X509_get_issuer_name            (const X509 *cert);
char*       X509_NAME_oneline               (gnutls_x509_dn *name,
                                             char *buf,
                                             int len);
void        X509_free                       (const X509 *cert);
void        BIO_get_fd                      (gnutls_session_t gnutls_state,
                                             int *fd);
BIO*        BIO_new_socket                  (int sock,
                                             int close_flag);
unsigned long ERR_get_error                 (void);
const char* ERR_error_string                (long e ,
                                             char *buf);
int         RAND_status                     (void);
void        RAND_seed                       (const void *buf,
                                             int num);
int         RAND_bytes                      (unsigned char *buf,
                                             int num);
const char* RAND_file_name                  (char *buf,
                                             size_t len);
int         RAND_load_file                  (const char *name,
                                             long maxbytes );
int         RAND_write_file                 (const char *name);
int         RAND_egd_bytes                  (const char *path,
                                             int bytes);
#define     RAND_egd                        (p)
#define     MD5_DIGEST_LENGTH
void        MD5_Init                        (MD5_CTX *ctx);
void        MD5_Update                      (MD5_CTX *ctx,
                                             const void *buf,
                                             int len);
void        MD5_Final                       (unsigned char *md,
                                             MD5_CTX *ctx);
unsigned char* MD5                          (unsigned char *buf,
                                             long len ,
                                             unsigned char *md);
void        RIPEMD160_Init                  (RIPEMD160_CTX *ctx);
void        RIPEMD160_Update                (RIPEMD160_CTX *ctx,
                                             const void *buf,
                                             int len);
void        RIPEMD160_Final                 (unsigned char *md,
                                             RIPEMD160_CTX *ctx);
unsigned char* RIPEMD160                    (unsigned char *buf,
                                             long len ,
                                             unsigned char *md);

Description

Details

GNUTLS_X509_CN_SIZE

#define     GNUTLS_X509_CN_SIZE

GNUTLS_X509_C_SIZE

#define     GNUTLS_X509_C_SIZE

GNUTLS_X509_O_SIZE

#define     GNUTLS_X509_O_SIZE

GNUTLS_X509_OU_SIZE

#define     GNUTLS_X509_OU_SIZE

GNUTLS_X509_L_SIZE

#define     GNUTLS_X509_L_SIZE

GNUTLS_X509_S_SIZE

#define     GNUTLS_X509_S_SIZE

GNUTLS_X509_EMAIL_SIZE

#define     GNUTLS_X509_EMAIL_SIZE

OPENSSL_VERSION_NUMBER

#define     OPENSSL_VERSION_NUMBER

SSLEAY_VERSION_NUMBER

#define     SSLEAY_VERSION_NUMBER

OPENSSL_VERSION_TEXT

#define     OPENSSL_VERSION_TEXT

SSL_ERROR_NONE

#define     SSL_ERROR_NONE

SSL_ERROR_SSL

#define     SSL_ERROR_SSL

SSL_ERROR_WANT_READ

#define     SSL_ERROR_WANT_READ

SSL_ERROR_WANT_WRITE

#define     SSL_ERROR_WANT_WRITE

SSL_ERROR_SYSCALL

#define     SSL_ERROR_SYSCALL

SSL_ERROR_ZERO_RETURN

#define     SSL_ERROR_ZERO_RETURN

SSL_FILETYPE_PEM

#define     SSL_FILETYPE_PEM

SSL_VERIFY_NONE

#define     SSL_VERIFY_NONE

SSL_ST_OK

#define     SSL_ST_OK

X509_V_ERR_CERT_NOT_YET_VALID

#define     X509_V_ERR_CERT_NOT_YET_VALID

X509_V_ERR_CERT_HAS_EXPIRED

#define     X509_V_ERR_CERT_HAS_EXPIRED

X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT

#define     X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT

SSL_OP_ALL

#define     SSL_OP_ALL

SSL_OP_NO_TLSv1

#define     SSL_OP_NO_TLSv1

SSL_MODE_ENABLE_PARTIAL_WRITE

#define     SSL_MODE_ENABLE_PARTIAL_WRITE

SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER

#define     SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER

SSL_MODE_AUTO_RETRY

#define     SSL_MODE_AUTO_RETRY

X509_NAME

X509

SSL

typedef struct {
    gnutls_session_t gnutls_state;

    gnutls_certificate_client_credentials gnutls_cred;

    SSL_CTX *ctx;
    SSL_CIPHER ciphersuite;

    int last_error;
    int shutdown;
    int state;
    unsigned long options;

    int (*verify_callback) (int, X509_STORE_CTX *);
    int verify_mode;

    gnutls_transport_ptr_t rfd;
    gnutls_transport_ptr_t wfd;
} SSL;

current_cert

#define     current_cert

X509_STORE_CTX_get_current_cert()

#define     X509_STORE_CTX_get_current_cert(ctx)

ctx :

rbio

#define     rbio

struct RSA

struct RSA;

MD5_CTX

#define     MD5_CTX

RIPEMD160_CTX

#define     RIPEMD160_CTX

OpenSSL_add_ssl_algorithms()

#define     OpenSSL_add_ssl_algorithms()

SSLeay_add_ssl_algorithms()

#define     SSLeay_add_ssl_algorithms()

SSLeay_add_all_algorithms()

#define     SSLeay_add_all_algorithms()

SSL_get_cipher_name()

#define     SSL_get_cipher_name(ssl)

ssl :

SSL_get_cipher()

#define     SSL_get_cipher(ssl)

ssl :

SSL_get_cipher_bits()

#define     SSL_get_cipher_bits(ssl,bp)

ssl :
bp :

SSL_get_cipher_version()

#define     SSL_get_cipher_version(ssl)

ssl :

SSL_library_init ()

int         SSL_library_init                (void);

Returns :

OpenSSL_add_all_algorithms ()

void        OpenSSL_add_all_algorithms      (void);

SSL_CTX_new ()

SSL_CTX*    SSL_CTX_new                     (SSL_METHOD *method);

method :
Returns :

SSL_CTX_free ()

void        SSL_CTX_free                    (SSL_CTX *ctx);

ctx :

SSL_CTX_set_default_verify_paths ()

int         SSL_CTX_set_default_verify_paths
                                            (SSL_CTX *ctx);

ctx :
Returns :

SSL_CTX_use_certificate_file ()

int         SSL_CTX_use_certificate_file    (SSL_CTX *ctx,
                                             const char *certfile,
                                             int type);

ctx :
certfile :
type :
Returns :

SSL_CTX_use_PrivateKey_file ()

int         SSL_CTX_use_PrivateKey_file     (SSL_CTX *ctx,
                                             const char *keyfile,
                                             int type);

ctx :
keyfile :
type :
Returns :

SSL_CTX_set_verify ()

void        SSL_CTX_set_verify              (SSL_CTX *ctx,
                                             int verify_mode,
                                             int (*verify_callback) (int, X509_STORE_CTX *));

ctx :
verify_mode :
verify_callback :

SSL_CTX_set_options ()

unsigned long SSL_CTX_set_options           (SSL_CTX *ctx,
                                             long options );

ctx :
Param2 :
Returns :

SSL_CTX_set_mode ()

long        SSL_CTX_set_mode                (SSL_CTX *ctx,
                                             long mode );

ctx :
Param2 :
Returns :

SSL_CTX_set_cipher_list ()

int         SSL_CTX_set_cipher_list         (SSL_CTX *ctx,
                                             const char *list);

ctx :
list :
Returns :

SSL_CTX_sess_number ()

long        SSL_CTX_sess_number             (SSL_CTX *ctx);

ctx :
Returns :

SSL_CTX_sess_connect ()

long        SSL_CTX_sess_connect            (SSL_CTX *ctx);

ctx :
Returns :

SSL_CTX_sess_connect_good ()

long        SSL_CTX_sess_connect_good       (SSL_CTX *ctx);

ctx :
Returns :

SSL_CTX_sess_connect_renegotiate ()

long        SSL_CTX_sess_connect_renegotiate
                                            (SSL_CTX *ctx);

ctx :
Returns :

SSL_CTX_sess_accept ()

long        SSL_CTX_sess_accept             (SSL_CTX *ctx);

ctx :
Returns :

SSL_CTX_sess_accept_good ()

long        SSL_CTX_sess_accept_good        (SSL_CTX *ctx);

ctx :
Returns :

SSL_CTX_sess_accept_renegotiate ()

long        SSL_CTX_sess_accept_renegotiate (SSL_CTX *ctx);

ctx :
Returns :

SSL_CTX_sess_hits ()

long        SSL_CTX_sess_hits               (SSL_CTX *ctx);

ctx :
Returns :

SSL_CTX_sess_misses ()

long        SSL_CTX_sess_misses             (SSL_CTX *ctx);

ctx :
Returns :

SSL_CTX_sess_timeouts ()

long        SSL_CTX_sess_timeouts           (SSL_CTX *ctx);

ctx :
Returns :

SSL_new ()

SSL*        SSL_new                         (SSL_CTX *ctx);

ctx :
Returns :

SSL_free ()

void        SSL_free                        (SSL *ssl);

ssl :

SSL_load_error_strings ()

void        SSL_load_error_strings          (void);

SSL_get_error ()

int         SSL_get_error                   (SSL *ssl,
                                             int ret);

ssl :
ret :
Returns :

SSL_set_fd ()

int         SSL_set_fd                      (SSL *ssl,
                                             int fd);

ssl :
fd :
Returns :

SSL_set_rfd ()

int         SSL_set_rfd                     (SSL *ssl,
                                             int fd);

ssl :
fd :
Returns :

SSL_set_wfd ()

int         SSL_set_wfd                     (SSL *ssl,
                                             int fd);

ssl :
fd :
Returns :

SSL_set_bio ()

void        SSL_set_bio                     (SSL *ssl,
                                             BIO *rbio,
                                             BIO *wbio);

ssl :
rbio :
wbio :

SSL_set_connect_state ()

void        SSL_set_connect_state           (SSL *ssl);

ssl :

SSL_pending ()

int         SSL_pending                     (SSL *ssl);

ssl :
Returns :

SSL_set_verify ()

void        SSL_set_verify                  (SSL *ssl,
                                             int verify_mode,
                                             int (*verify_callback) (int, X509_STORE_CTX *));

ssl :
verify_mode :
verify_callback :

SSL_get_peer_certificate ()

const X509* SSL_get_peer_certificate        (SSL *ssl);

ssl :
Returns :

SSL_connect ()

int         SSL_connect                     (SSL *ssl);

ssl :
Returns :

SSL_accept ()

int         SSL_accept                      (SSL *ssl);

ssl :
Returns :

SSL_shutdown ()

int         SSL_shutdown                    (SSL *ssl);

ssl :
Returns :

SSL_read ()

int         SSL_read                        (SSL *ssl,
                                             void *buf,
                                             int len);

ssl :
buf :
len :
Returns :

SSL_write ()

int         SSL_write                       (SSL *ssl,
                                             const void *buf,
                                             int len);

ssl :
buf :
len :
Returns :

SSL_want ()

int         SSL_want                        (SSL *ssl);

ssl :
Returns :

SSL_NOTHING

#define     SSL_NOTHING

SSL_WRITING

#define     SSL_WRITING

SSL_READING

#define     SSL_READING

SSL_X509_LOOKUP

#define     SSL_X509_LOOKUP

SSL_want_nothing()

#define     SSL_want_nothing(s)

s :

SSL_want_read()

#define     SSL_want_read(s)

s :

SSL_want_write()

#define     SSL_want_write(s)

s :

SSL_want_x509_lookup()

#define     SSL_want_x509_lookup(s)

s :

SSLv23_client_method ()

SSL_METHOD* SSLv23_client_method            (void);

Returns :

SSLv23_server_method ()

SSL_METHOD* SSLv23_server_method            (void);

Returns :

SSLv3_client_method ()

SSL_METHOD* SSLv3_client_method             (void);

Returns :

SSLv3_server_method ()

SSL_METHOD* SSLv3_server_method             (void);

Returns :

TLSv1_client_method ()

SSL_METHOD* TLSv1_client_method             (void);

Returns :

TLSv1_server_method ()

SSL_METHOD* TLSv1_server_method             (void);

Returns :

SSL_get_current_cipher ()

SSL_CIPHER* SSL_get_current_cipher          (SSL *ssl);

ssl :
Returns :

SSL_CIPHER_get_name ()

const char* SSL_CIPHER_get_name             (SSL_CIPHER *cipher);

cipher :
Returns :

SSL_CIPHER_get_bits ()

int         SSL_CIPHER_get_bits             (SSL_CIPHER *cipher,
                                             int *bits);

cipher :
bits :
Returns :

SSL_CIPHER_get_version ()

const char* SSL_CIPHER_get_version          (SSL_CIPHER *cipher);

cipher :
Returns :

SSL_CIPHER_description ()

char*       SSL_CIPHER_description          (SSL_CIPHER *cipher,
                                             char *buf,
                                             int size);

cipher :
buf :
size :
Returns :

X509_get_subject_name ()

X509_NAME*  X509_get_subject_name           (const X509 *cert);

cert :
Returns :

X509_get_issuer_name ()

X509_NAME*  X509_get_issuer_name            (const X509 *cert);

cert :
Returns :

X509_NAME_oneline ()

char*       X509_NAME_oneline               (gnutls_x509_dn *name,
                                             char *buf,
                                             int len);

name :
buf :
len :
Returns :

X509_free ()

void        X509_free                       (const X509 *cert);

cert :

BIO_get_fd ()

void        BIO_get_fd                      (gnutls_session_t gnutls_state,
                                             int *fd);

gnutls_state :
fd :

BIO_new_socket ()

BIO*        BIO_new_socket                  (int sock,
                                             int close_flag);

sock :
close_flag :
Returns :

ERR_get_error ()

unsigned long ERR_get_error                 (void);

Returns :

ERR_error_string ()

const char* ERR_error_string                (long e ,
                                             char *buf);

Param1 :
buf :
Returns :

RAND_status ()

int         RAND_status                     (void);

Returns :

RAND_seed ()

void        RAND_seed                       (const void *buf,
                                             int num);

buf :
num :

RAND_bytes ()

int         RAND_bytes                      (unsigned char *buf,
                                             int num);

buf :
num :
Returns :

RAND_file_name ()

const char* RAND_file_name                  (char *buf,
                                             size_t len);

buf :
len :
Returns :

RAND_load_file ()

int         RAND_load_file                  (const char *name,
                                             long maxbytes );

name :
Param2 :
Returns :

RAND_write_file ()

int         RAND_write_file                 (const char *name);

name :
Returns :

RAND_egd_bytes ()

int         RAND_egd_bytes                  (const char *path,
                                             int bytes);

path :
bytes :
Returns :

RAND_egd()

#define     RAND_egd(p)

p :

MD5_DIGEST_LENGTH

#define     MD5_DIGEST_LENGTH

MD5_Init ()

void        MD5_Init                        (MD5_CTX *ctx);

ctx :

MD5_Update ()

void        MD5_Update                      (MD5_CTX *ctx,
                                             const void *buf,
                                             int len);

ctx :
buf :
len :

MD5_Final ()

void        MD5_Final                       (unsigned char *md,
                                             MD5_CTX *ctx);

md :
ctx :

MD5 ()

unsigned char* MD5                          (unsigned char *buf,
                                             long len ,
                                             unsigned char *md);

buf :
Param2 :
md :
Returns :

RIPEMD160_Init ()

void        RIPEMD160_Init                  (RIPEMD160_CTX *ctx);

ctx :

RIPEMD160_Update ()

void        RIPEMD160_Update                (RIPEMD160_CTX *ctx,
                                             const void *buf,
                                             int len);

ctx :
buf :
len :

RIPEMD160_Final ()

void        RIPEMD160_Final                 (unsigned char *md,
                                             RIPEMD160_CTX *ctx);

md :
ctx :

RIPEMD160 ()

unsigned char* RIPEMD160                    (unsigned char *buf,
                                             long len ,
                                             unsigned char *md);

buf :
Param2 :
md :
Returns :