BIOsaccept(3) OpenSSL BIOsaccept(3)

NAME
       BIOsaccept, BIOsetacceptport, BIOgetacceptport,
       BIOsetnbioaccept, BIOsetacceptbios, BIOsetbindmode,
       BIOgetbindmode, BIOdoaccept - accept BIO

SYNOPSIS
        #include 

        BIOMETHOD *BIOsaccept(void);

        long BIOsetacceptport(BIO *b, char *name);
        char *BIOgetacceptport(BIO *b);

        BIO *BIOnewaccept(char *hostport);

        long BIOsetnbioaccept(BIO *b, int n);
        long BIOsetacceptbios(BIO *b, char *bio);

        long BIOsetbindmode(BIO *b, long mode);
        long BIOgetbindmode(BIO *b, long dummy);

        #define BIOBINDNORMAL                0
        #define BIOBINDREUSEADDRIFUNUSED   1
        #define BIOBINDREUSEADDR             2

        int BIOdoaccept(BIO *b);

DESCRIPTION
       BIOsaccept() 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
       transferred using only BIO routines. In this way any platform specific
       operations are hidden by the BIO abstraction.

       Read and write operations on an accept BIO will perform I/O on the
       underlying connection. If no connection is established and the port
       (see below) is set up properly then the BIO waits for an incoming
       connection.

       Accept BIOs support BIOputs() but not BIOgets().

       If the close flag is set on an accept BIO then any active connection on
       that chain is shutdown and the socket closed when the BIO is freed.

       Calling BIOreset() on a accept BIO will close any active connection
       and reset the BIO into a state where it awaits another incoming
       connection.

       BIOgetfd() and BIOsetfd() can be called to retrieve or set the
       accept socket. See BIOsfd(3)

       BIOsetacceptport() uses the string nnaammee to set the accept port. The
       port is represented as a string of the form "host:port", where "host"
       is the interface to use and "port" is the port.  Either or both values
       can be "*" which is interpreted as meaning any interface or port
       respectively. "port" has the same syntax as the port specified in
       BIOsetconnport() for connect BIOs, that is it can be a numerical
       port string or a string to lookup using getservbyname() and a string
       table.

       BIOnewaccept() combines BIOnew() and BIOsetacceptport() into a
       single call: that is it creates a new accept BIO with port hhoossttppoorrtt.

       BIOsetnbioaccept() sets the accept socket to blocking mode (the
       default) if nn is 0 or non blocking mode if nn is 1.

       BIOsetacceptbios() can be used to set a chain of BIOs which will be
       duplicated and prepended to the chain when an incoming connection is
       received. This is useful if, for example, a buffering or SSL BIO is
       required for each connection. The chain of BIOs must not be freed after
       this call, they will be automatically freed when the accept BIO is
       freed.

       BIOsetbindmode() and BIOgetbindmode() set and retrieve the
       current bind mode. If BIOBINDNORMAL (the default) is set then another
       socket cannot be bound to the same port. If BIOBINDREUSEADDR is set
       then other sockets can bind to the same port. If
       BIOBINDREUSEADDRIFUNUSED is set then and attempt is first made to
       use BIOBINNORMAL, if this fails and the port is not in use then a
       second attempt is made using BIOBINDREUSEADDR.

       BIOdoaccept() serves two functions. When it is first called, after
       the accept BIO has been setup, it will attempt to create the accept
       socket and bind an address to it. Second and subsequent calls to
       BIOdoaccept() will await an incoming connection, or request a retry
       in non blocking mode.

NNOOTTEESS
       When an accept BIO is at the end of a chain it will await an incoming
       connection before processing I/O calls. When an accept BIO is not at
       then end of a chain it passes I/O calls to the next BIO in the chain.

       When a connection is established a new socket BIO is created for the
       connection and appended to the chain. That is the chain is now
       accept->socket. This effectively means that attempting I/O on an
       initial accept socket will await an incoming connection then perform
       I/O on it.

       If any additional BIOs have been set using BIOsetacceptbios() then
       they are placed between the socket and the accept BIO, that is the
       chain will be accept->otherbios->socket.

       If a server wishes to process multiple connections (as is normally the
       case) then the accept BIO must be made available for further incoming
       connections. This can be done by waiting for a connection and then
       calling:

        connection = BIOpop(accept);

       After this call ccoonnnneeccttiioonn will contain a BIO for the recently
       established connection and aacccceepptt will now be a single BIO again which
       can be used to await further incoming connections.  If no further
       connections will be accepted the aacccceepptt can be freed using BIOfree().

       If only a single connection will be processed it is possible to perform
       I/O using the accept BIO itself. This is often undesirable however
       because the accept BIO will still accept additional incoming
       connections. This can be resolved by using BIOpop() (see above) and
       freeing up the accept BIO after the initial connection.

       If the underlying accept socket is non-blocking and BIOdoaccept() is
       called to await an incoming connection it is possible for
       BIOshouldiospecial() with the reason BIORRACCEPT. 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.

       BIOsetacceptport(), BIOgetacceptport(), BIOsetnbioaccept(),
       BIOsetacceptbios(), BIOsetbindmode(), BIOgetbindmode() and
       BIOdoaccept() are macros.

RETURN VALUES
       TBA

EEXXAAMMPPLLEE
       This example accepts two connections on port 4444, sends messages down
       each and finally closes both down.

        BIO *abio, *cbio, *cbio2;
        ERRloadcryptostrings();
        abio = BIOnewaccept("4444");

        /* First call to BIOaccept() sets up accept BIO */
        if(BIOdoaccept(abio) <= 0) {
               fprintf(stderr, "Error setting up accept\n");
               ERRprinterrorsfp(stderr);
               exit(0);
        }

        /* Wait for incoming connection */
        if(BIOdoaccept(abio) <= 0) {
               fprintf(stderr, "Error accepting connection\n");
               ERRprinterrorsfp(stderr);
               exit(0);
        }
        fprintf(stderr, "Connection 1 established\n");
        /* Retrieve BIO for connection */
        cbio = BIOpop(abio);
        BIOputs(cbio, "Connection 1: Sending out Data on initial connection\n");
        fprintf(stderr, "Sent out data on connection 1\n");
        /* Wait for another connection */
        if(BIOdoaccept(abio) <= 0) {
               fprintf(stderr, "Error accepting connection\n");
               ERRprinterrorsfp(stderr);
               exit(0);
        }
        fprintf(stderr, "Connection 2 established\n");
        /* Close accept BIO to refuse further connections */
        cbio2 = BIOpop(abio);
        BIOfree(abio);
        BIOputs(cbio2, "Connection 2: Sending out Data on second\n");
        fprintf(stderr, "Sent out data on connection 2\n");

        BIOputs(cbio, "Connection 1: Second connection established\n");
        /* Close the two established connections */
        BIOfree(cbio);
        BIOfree(cbio2);

SEE ALSO
       TBA



0.9.7l                            2002-12-12                   BIOsaccept(3)