give pseudo prototypes instead of macro definitions for better clarity

 BIO_METHOD *BIO_s_accept(void);

 #define BIO_set_accept_port(b,name) BIO_ctrl(b,BIO_C_SET_ACCEPT,0,(char *)name)

 #define BIO_get_accept_port(b)	BIO_ptr_ctrl(b,BIO_C_GET_ACCEPT,0)

 long BIO_set_accept_port(BIO *b, char *name);

 char *BIO_get_accept_port(BIO *b);

 BIO *BIO_new_accept(char *host_port);

 #define BIO_set_nbio_accept(b,n) BIO_ctrl(b,BIO_C_SET_ACCEPT,1,(n)?"a":NULL)

 #define BIO_set_accept_bios(b,bio) BIO_ctrl(b,BIO_C_SET_ACCEPT,2,(char *)bio)

 long BIO_set_nbio_accept(BIO *b, int n);

 long BIO_set_accept_bios(BIO *b, char *bio);

 #define BIO_set_bind_mode(b,mode) BIO_ctrl(b,BIO_C_SET_BIND_MODE,mode,NULL)

 #define BIO_get_bind_mode(b,mode) BIO_ctrl(b,BIO_C_GET_BIND_MODE,0,NULL)

 long BIO_set_bind_mode(BIO *b, long mode);

 long BIO_get_bind_mode(BIO *b, long dummy);

 #define BIO_BIND_NORMAL		0

 #define BIO_BIND_REUSEADDR_IF_UNUSED	1

 #define BIO_BIND_REUSEADDR		2

 #define BIO_do_accept(b)	BIO_do_handshake(b)

 int BIO_do_accept(BIO *b);

=head1 DESCRIPTION

BIO_s_accept() returns the accept BIO method. This is a wrapper

round the platform's TCP/IP socket accept routines.

Using accept BIOs TCP/IP connections can be accepted and data

Using accept BIOs, TCP/IP connections can be accepted and data

transferred using only BIO routines. In this way any platform

specific operations are hidden by the BIO abstraction.

connections. This can be resolved by using BIO_pop() (see above)

and freeing up the accept BIO after the initial connection.

If the underlying accept socket is non blocking and BIO_do_accept() is

If the underlying accept socket is non-blocking and BIO_do_accept() is

called to await an incoming connection it is possible for

BIO_should_io_special() with the reason BIO_RR_ACCEPT. If this happens

then it is an indication that an accept attempt would block: the application

should take appropriate action to wait until the underlying socket has

accepted a connection and retry the call.

BIO_set_accept_port(), BIO_get_accept_port(), BIO_set_nbio_accept(),

BIO_set_accept_bios(), BIO_set_bind_mode(), BIO_get_bind_mode() and

BIO_do_accept() are macros.

=head1 RETURN VALUES

TBA

 BIO_METHOD * BIO_s_connect(void);

 #define BIO_set_conn_hostname(b,name) BIO_ctrl(b,BIO_C_SET_CONNECT,0,(char *)name)

 #define BIO_set_conn_port(b,port) BIO_ctrl(b,BIO_C_SET_CONNECT,1,(char *)port)

 #define BIO_set_conn_ip(b,ip)	  BIO_ctrl(b,BIO_C_SET_CONNECT,2,(char *)ip)

 #define BIO_set_conn_int_port(b,port) BIO_ctrl(b,BIO_C_SET_CONNECT,3,(char *)port)

 #define BIO_get_conn_hostname(b)  BIO_ptr_ctrl(b,BIO_C_GET_CONNECT,0)

 #define BIO_get_conn_port(b)      BIO_ptr_ctrl(b,BIO_C_GET_CONNECT,1)

 #define BIO_get_conn_ip(b,ip) BIO_ptr_ctrl(b,BIO_C_SET_CONNECT,2)

 #define BIO_get_conn_int_port(b,port) BIO_int_ctrl(b,BIO_C_SET_CONNECT,3,port)

 BIO *BIO_new_connect(char *name);

 #define BIO_set_nbio(b,n)	BIO_ctrl(b,BIO_C_SET_NBIO,(n),NULL)

 long BIO_set_conn_hostname(BIO *b, char *name);

 long BIO_set_conn_port(BIO *b, char *port);

 long BIO_set_conn_ip(BIO *b, char *ip);

 long BIO_set_conn_int_port(BIO *b, char *port);

 char *BIO_get_conn_hostname(BIO *b);

 char *BIO_get_conn_port(BIO *b);

 char *BIO_get_conn_ip(BIO *b, dummy);

 long BIO_get_conn_int_port(BIO *b, int port);

 #define BIO_do_connect(b)	BIO_do_handshake(b)

 long BIO_set_nbio(BIO *b, long n);

 int BIO_do_connect(BIO *b);

=head1 DESCRIPTION

BIO_s_connect() returns the connect BIO method. This is a wrapper

round the platform's TCP/IP socket connection routines.

Using connect BIOs TCP/IP connections can be made and data

Using connect BIOs, TCP/IP connections can be made and data

transferred using only BIO routines. In this way any platform

specific operations are hidden by the BIO abstraction.

it also returns the socket . If B<c> is not NULL it should be of

type (int *).

BIO_set_conn_hostname() uses the string B<name> to set the hostname

BIO_set_conn_hostname() uses the string B<name> to set the hostname.

The hostname can be an IP address. The hostname can also include the

port in the form hostname:port . It is also acceptable to use the

form "hostname/any/other/path" or "hostname:port/any/other/path".

should be made before the connection is established because 

non blocking I/O is set during the connect process.

BIO_new_connect() combines BIO_new() and BIO_set_conn_hostname() into

a single call: that is it creates a new connect BIO with B<name>.

BIO_do_connect() attempts to connect the supplied BIO. It returns 1

if the connection was established successfully. A zero or negative

value is returned if the connection could not be established, the

the application should then take appropriate action to wait until

the underlying socket has connected and retry the call.

BIO_set_conn_hostname(), BIO_set_conn_port(), BIO_set_conn_ip(),

BIO_set_conn_int_port(), BIO_get_conn_hostname(), BIO_get_conn_port(),

BIO_get_conn_ip(), BIO_get_conn_int_port(), BIO_set_nbio() and

BIO_do_connect() are macros.

=head1 RETURN VALUES

BIO_s_connect() returns the connect BIO method.

 BIO_METHOD *BIO_s_socket(void);

 #define BIO_set_fd(b,fd,c)	BIO_int_ctrl(b,BIO_C_SET_FD,c,fd)

 #define BIO_get_fd(b,c)	BIO_ctrl(b,BIO_C_GET_FD,0,(char *)c)

 long BIO_set_fd(BIO *b, int fd, long close_flag);

 long BIO_get_fd(BIO *b, int *c);

 BIO *BIO_new_socket(int sock, int close_flag);

when the BIO is freed.

BIO_set_fd() sets the socket of BIO B<b> to B<fd> and the close

flag to B<c>.

flag to B<close_flag>.

BIO_get_fd() places the socket in B<c> if it is not NULL, it also

returns the socket. If B<c> is not NULL it should be of type (int *).

Windows is one such platform. Any code mixing the two will not work on

all platforms.

BIO_set_fd() and BIO_get_fd() are macros.

=head1 RETURN VALUES

BIO_s_socket() returns the socket BIO method.