Man Linux: Main Page and Category List


       ber_sockbuf_alloc,          ber_sockbuf_free,         ber_sockbuf_ctrl,
       ber_sockbuf_add_io, ber_sockbuf_remove_io, Sockbuf_IO -  OpenLDAP  LBER
       I/O infrastructure


       OpenLDAP LBER (liblber, -llber)


       #include <lber.h>

       Sockbuf *ber_sockbuf_alloc( void );

       void ber_sockbuf_free(Sockbuf *sb);

       int ber_sockbuf_ctrl(Sockbuf *sb, int opt, void *arg);

       int  ber_sockbuf_add_io(Sockbuf  *sb, Sockbuf_IO *sbio, int layer, void

       int ber_sockbuf_remove_io(Sockbuf *sb, Sockbuf_IO *sbio, int layer);

       typedef struct sockbuf_io_desc {
       int sbiod_level;
       Sockbuf *sbiod_sb;
       Sockbuf_IO *sbiod_io;
       void *sbiod_pvt;
       struct sockbuf_io_desc *sbiod_next;
       } Sockbuf_IO_Desc;

       typedef struct sockbuf_io {
       int (*sbi_setup)(Sockbuf_IO_Desc *sbiod, void *arg);
       int (*sbi_remove)(Sockbuf_IO_Desc *sbiod);
       int (*sbi_ctrl)(Sockbuf_IO_Desc *sbiod, int opt, void *arg);
       ber_slen_t (*sbi_read)(Sockbuf_IO_Desc *sbiod, void *buf, ber_len_t len);
       ber_slen_t (*sbi_write)(Sockbuf_IO_Desc *sbiod, void *buf, ber_len_t len);
       int (*sbi_close)(Sockbuf_IO_Desc *sbiod);
       } Sockbuf_IO;


       These routines  are  used  to  manage  the  low  level  I/O  operations
       performed by the Lightweight BER library. They are called implicitly by
       the other libraries and usually do not need to be called directly  from
       applications.   The  I/O  framework  is  modularized  and new transport
       layers  can  be  supported  by  appropriately  defining  a   Sockbuf_IO
       structure   and  installing  it  onto  an  existing  Sockbuf.   Sockbuf
       structures  are  allocated  and  freed   by   ber_sockbuf_alloc()   and
       ber_sockbuf_free(),  respectively.  The  ber_sockbuf_ctrl() function is
       used to get and set options related to a Sockbuf or to a  specific  I/O
       layer     of     the    Sockbuf.     The    ber_sockbuf_add_io()    and
       ber_sockbuf_remove_io() functions are used to add and  remove  specific
       I/O layers on a Sockbuf.

       Options for ber_sockbuf_ctrl() include:

              Takes a Sockbuf_IO * argument and returns 1 if the given handler
              is installed on the Sockbuf, otherwise returns 0.

              Retrieves the file descriptor associated  to  the  Sockbuf;  arg
              must be a ber_socket_t *.  The return value will be 1 if a valid
              descriptor was present, -1 otherwise.

              Sets the file  descriptor  of  the  Sockbuf  to  the  descriptor
              pointed  to  by  arg;  arg must be a ber_socket_t *.  The return
              value will always be 1.

              Toggles the non-blocking state of the file descriptor associated
              to  the  Sockbuf.  arg should be NULL to disable and non-NULL to
              enable the non-blocking state.  The return value will be  1  for
              success, -1 otherwise.

              Flush  (read  and  discard)  all available input on the Sockbuf.
              The return value will be 1.

              Returns non-zero if input is waiting to be read.

              Returns non-zero if the Sockbuf is ready to be written.

              Returns the maximum allowed size of  an  incoming  message;  arg
              must be a ber_len_t *.  The return value will be 1.

              Sets  the  maximum allowed size of an incoming message; arg must
              be a ber_len_t *.  The return value will be 1.

       Options not in this list will be passed down to each Sockbuf_IO handler
       in  turn  until  one of them processes it. If the option is not handled
       ber_sockbuf_ctrl() will return 0.

       Multiple Sockbuf_IO handlers can  be  stacked  in  multiple  layers  to
       provide various functionality.  Currently defined layers include

              the lowest layer, talking directly to a network

              an intermediate layer

              a higher layer

       Currently defined Sockbuf_IO handlers in liblber include

              The default stream-oriented provider

              A stream-oriented provider for local IPC sockets

              A  datagram-oriented  provider.  This handler is only present if
              the liblber library was built with LDAP_CONNECTIONLESS  defined.

              A buffering layer, usually used with a datagram provider to hide
              the datagram semantics from upper layers.

              A generic handler that outputs hex dumps of  all  traffic.  This
              handler  may  be  inserted multiple times at arbitrary layers to
              show the flow of data between other handlers.

       Additional handlers may be present in libldap if support for  them  was

              An application layer handler for SASL encoding/decoding.

              A  transport  layer  handler for SSL/TLS encoding/decoding. Note
              that this handler is private to the library and is  not  exposed
              in the API.

       The  provided  handlers are all instantiated implicitly by libldap, and
       applications generally will not need to directly manipulate them.


       lber-decode(3), lber-encode(3), lber-types(3), ldap_get_option(3)


       OpenLDAP Software is developed and maintained by The  OpenLDAP  Project
       <>.    OpenLDAP   Software   is   derived  from
       University of Michigan LDAP 3.3 Release.