iops.h

Go to the documentation of this file.

/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
/*
 *     Copyright 2017-2020 Couchbase, Inc.
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 */
 
#ifndef LIBCOUCHBASE_COUCHBASE_H
#error "include libcouchbase/couchbase.h first"
#endif
 
#ifndef LCB_IOPS_H
#define LCB_IOPS_H
 
#ifdef __cplusplus
extern "C" {
#endif
 
#ifdef _WIN32
typedef SOCKET lcb_socket_t;
#else
typedef int lcb_socket_t;
#endif
 
struct sockaddr;
 
#ifndef _WIN32
#define LCB_IOV_LAYOUT_UIO
typedef struct lcb_iovec_st {
    void *iov_base;
    size_t iov_len;
} lcb_IOV;
#else
#define LCB_IOV_LAYOUT_WSABUF
typedef struct lcb_iovec_st {
    ULONG iov_len;
    void *iov_base;
} lcb_IOV;
#endif
 
#if defined(LIBCOUCHBASE_INTERNAL) && !defined(LCB_IOPS_V12_NO_DEPRECATE)
#define LCB__IOPS_CONCAT2(X, Y) X##Y
#define LCB__IOPS_CONCAT(X, Y) LCB__IOPS_CONCAT2(X, Y)
#define LCB_IOPS_DEPRECATED(X) void (*LCB__IOPS_CONCAT(lcb__iops__dummy, __LINE__))(void)
#else
#define LCB_IOPS_DEPRECATED(X) X
#endif
 
struct lcb_nameinfo_st {
    struct {
        struct sockaddr *name;
        int *len;
    } local;
 
    struct {
        struct sockaddr *name;
        int *len;
    } remote;
};
 
typedef struct lcb_io_opt_st *lcb_io_opt_t;
 
typedef void (*lcb_ioE_callback)(lcb_socket_t sock, short events, void *uarg);
 
typedef void *(*lcb_io_timer_create_fn)(lcb_io_opt_t iops);
 
typedef void (*lcb_io_timer_destroy_fn)(lcb_io_opt_t iops, void *timer);
 
typedef void (*lcb_io_timer_cancel_fn)(lcb_io_opt_t iops, void *timer);
 
typedef int (*lcb_io_timer_schedule_fn)(lcb_io_opt_t iops, void *timer, lcb_U32 usecs, void *uarg,
                                        lcb_ioE_callback callback);
 
typedef void *(*lcb_ioE_event_create_fn)(lcb_io_opt_t iops);
 
typedef void (*lcb_ioE_event_destroy_fn)(lcb_io_opt_t iops, void *event);
 
typedef void (*lcb_ioE_event_cancel_fn)(lcb_io_opt_t iops, lcb_socket_t sock, void *event);
 
#define LCB_READ_EVENT 0x02
#define LCB_WRITE_EVENT 0x04
#define LCB_ERROR_EVENT 0x08
#define LCB_RW_EVENT (LCB_READ_EVENT | LCB_WRITE_EVENT)
 
typedef int (*lcb_ioE_event_watch_fn)(lcb_io_opt_t iops, lcb_socket_t socket, void *event, short evflags, void *uarg,
                                      lcb_ioE_callback callback);
 
typedef lcb_SSIZE (*lcb_ioE_recv_fn)(lcb_io_opt_t iops, lcb_socket_t sock, void *target_buf, lcb_SIZE buflen,
                                     int _unused_flags);
 
typedef lcb_SSIZE (*lcb_ioE_send_fn)(lcb_io_opt_t iops, lcb_socket_t sock, const void *srcbuf, lcb_SIZE buflen,
                                     int _ignored);
 
typedef lcb_SSIZE (*lcb_ioE_recvv_fn)(lcb_io_opt_t iops, lcb_socket_t sock, lcb_IOV *iov, lcb_SIZE niov);
 
typedef lcb_SSIZE (*lcb_ioE_sendv_fn)(lcb_io_opt_t iops, lcb_socket_t sock, lcb_IOV *iov, lcb_SIZE niov);
 
typedef lcb_socket_t (*lcb_ioE_socket_fn)(lcb_io_opt_t iops, int domain, int type, int protocol);
 
typedef int (*lcb_ioE_connect_fn)(lcb_io_opt_t iops, lcb_socket_t sock, const struct sockaddr *dst,
                                  unsigned int addrlen);
 
typedef int (*lcb_ioE_bind_fn)(lcb_io_opt_t iops, lcb_socket_t sock, const struct sockaddr *srcaddr,
                               unsigned int addrlen);
 
typedef int (*lcb_ioE_listen_fn)(lcb_io_opt_t iops, lcb_socket_t bound_sock, unsigned int queuelen);
 
typedef lcb_socket_t (*lcb_ioE_accept_fn)(lcb_io_opt_t iops, lcb_socket_t lsnsock);
 
typedef void (*lcb_ioE_close_fn)(lcb_io_opt_t iops, lcb_socket_t sock);
 
#define LCB_IO_SOCKCHECK_PEND_IS_ERROR 1
 
#define LCB_IO_SOCKCHECK_STATUS_CLOSED 1
#define LCB_IO_SOCKCHECK_STATUS_OK 0
#define LCB_IO_SOCKCHECK_STATUS_UNKNOWN -1
 
typedef int (*lcb_ioE_chkclosed_fn)(lcb_io_opt_t iops, lcb_socket_t sock, int flags);
 
#define LCB_IO_CNTL_GET 0
#define LCB_IO_CNTL_SET 1
 
#define LCB_IO_CNTL_TCP_NODELAY 1
 
#define LCB_IO_CNTL_TCP_KEEPALIVE 2
 
typedef int (*lcb_ioE_cntl_fn)(lcb_io_opt_t iops, lcb_socket_t sock, int mode, int option, void *arg);
struct ringbuffer_st;
struct lcb_connection_st;
struct lcbio_SOCKET;
 
struct lcb_buf_info {
    char *root;
    lcb_SIZE size;
    struct ringbuffer_st *ringbuffer;
    struct lcb_iovec_st iov[2];
};
 
typedef struct lcb_sockdata_st {
    lcb_socket_t socket;             
    lcb_io_opt_t parent;             
    struct lcbio_SOCKET *lcbconn;    
    int closed;                      
    int is_reading;                  
    struct lcb_buf_info read_buffer; 
} lcb_sockdata_t;
 
typedef struct lcb_io_writebuf_st {
    struct lcb_io_opt_st *parent;
    struct lcb_buf_info buffer;
} lcb_io_writebuf_t;
 
typedef lcb_sockdata_t *(*lcb_ioC_socket_fn)(lcb_io_opt_t iops, int domain, int type, int protocol);
 
typedef void (*lcb_io_connect_cb)(lcb_sockdata_t *socket, int status);
 
typedef int (*lcb_ioC_connect_fn)(lcb_io_opt_t iops, lcb_sockdata_t *sd, const struct sockaddr *dst, unsigned int naddr,
                                  lcb_io_connect_cb callback);
 
typedef void(lcb_ioC_serve_callback)(lcb_sockdata_t *sd_server, lcb_sockdata_t *sd_client, int status);
 
typedef int (*lcb_ioC_serve_fn)(lcb_io_opt_t iops, lcb_sockdata_t *server_socket, const struct sockaddr *listen_addr,
                                lcb_ioC_serve_callback callback);
 
typedef int (*lcb_ioC_nameinfo_fn)(lcb_io_opt_t iops, lcb_sockdata_t *sock, struct lcb_nameinfo_st *ni);
 
typedef void (*lcb_ioC_read_callback)(lcb_sockdata_t *sd, lcb_SSIZE nread);
#define lcb_io_read_cb lcb_ioC_read_callback
typedef int (*lcb_ioC_read_fn)(lcb_io_opt_t, lcb_sockdata_t *, lcb_ioC_read_callback);
typedef lcb_io_writebuf_t *(*lcb_ioC_wballoc_fn)(lcb_io_opt_t, lcb_sockdata_t *);
typedef void (*lcb_ioC_wbfree_fn)(lcb_io_opt_t, lcb_sockdata_t *, lcb_io_writebuf_t *);
typedef void (*lcb_ioC_write_callback)(lcb_sockdata_t *, lcb_io_writebuf_t *, int);
#define lcb_io_write_cb lcb_ioC_write_callback
 
typedef int (*lcb_ioC_write_fn)(lcb_io_opt_t, lcb_sockdata_t *, lcb_io_writebuf_t *, lcb_ioC_write_callback);
 
typedef void (*lcb_ioC_write2_callback)(lcb_sockdata_t *sd, int status, void *arg);
 
typedef int (*lcb_ioC_write2_fn)(lcb_io_opt_t iops, lcb_sockdata_t *sd, lcb_IOV *iov, lcb_SIZE niov, void *uarg,
                                 lcb_ioC_write2_callback callback);
 
typedef void (*lcb_ioC_read2_callback)(lcb_sockdata_t *sd, lcb_SSIZE nread, void *arg);
typedef int (*lcb_ioC_read2_fn)(lcb_io_opt_t iops, lcb_sockdata_t *sd, lcb_IOV *iov, lcb_SIZE niov, void *uarg,
                                lcb_ioC_read2_callback callback);
 
typedef unsigned int (*lcb_ioC_close_fn)(lcb_io_opt_t iops, lcb_sockdata_t *sd);
 
typedef int (*lcb_ioC_chkclosed_fn)(lcb_io_opt_t iops, lcb_sockdata_t *sd, int flags);
 
typedef int (*lcb_ioC_cntl_fn)(lcb_io_opt_t iops, lcb_sockdata_t *sd, int mode, int option, void *arg);
 
typedef void (*lcb_io_start_fn)(lcb_io_opt_t iops);
 
typedef void (*lcb_io_tick_fn)(lcb_io_opt_t iops);
 
typedef void (*lcb_io_stop_fn)(lcb_io_opt_t iops);
 
LCB_DEPRECATED(typedef void (*lcb_io_error_cb)(lcb_sockdata_t *socket));
 
#define LCB_IOPS_BASE_FIELDS                                                                                           \
    void *cookie;                                                                                                      \
    int error;                                                                                                         \
    int need_cleanup;
 
struct lcb_iops_evented_st {
    LCB_IOPS_BASE_FIELDS
    LCB_IOPS_DEPRECATED(lcb_ioE_socket_fn socket);
    LCB_IOPS_DEPRECATED(lcb_ioE_connect_fn connect);
    LCB_IOPS_DEPRECATED(lcb_ioE_recv_fn recv);
    LCB_IOPS_DEPRECATED(lcb_ioE_send_fn send);
    LCB_IOPS_DEPRECATED(lcb_ioE_recvv_fn recvv);
    LCB_IOPS_DEPRECATED(lcb_ioE_sendv_fn sendv);
    LCB_IOPS_DEPRECATED(lcb_ioE_close_fn close);
    LCB_IOPS_DEPRECATED(lcb_io_timer_create_fn create_timer);
    LCB_IOPS_DEPRECATED(lcb_io_timer_destroy_fn destroy_timer);
    LCB_IOPS_DEPRECATED(lcb_io_timer_cancel_fn delete_timer);
    LCB_IOPS_DEPRECATED(lcb_io_timer_schedule_fn update_timer);
    LCB_IOPS_DEPRECATED(lcb_ioE_event_create_fn create_event);
    LCB_IOPS_DEPRECATED(lcb_ioE_event_destroy_fn destroy_event);
    LCB_IOPS_DEPRECATED(lcb_ioE_event_watch_fn update_event);
    LCB_IOPS_DEPRECATED(lcb_ioE_event_cancel_fn delete_event);
    LCB_IOPS_DEPRECATED(lcb_io_stop_fn stop_event_loop);
    LCB_IOPS_DEPRECATED(lcb_io_start_fn run_event_loop);
};
 
struct lcb_iops_completion_st {
    LCB_IOPS_BASE_FIELDS
    LCB_IOPS_DEPRECATED(lcb_ioC_socket_fn create_socket);
    LCB_IOPS_DEPRECATED(lcb_ioC_connect_fn start_connect);
    LCB_IOPS_DEPRECATED(lcb_ioC_wballoc_fn create_writebuf);
    LCB_IOPS_DEPRECATED(lcb_ioC_wbfree_fn release_writebuf);
    LCB_IOPS_DEPRECATED(lcb_ioC_write_fn start_write);
    LCB_IOPS_DEPRECATED(lcb_ioC_read_fn start_read);
    LCB_IOPS_DEPRECATED(lcb_ioC_close_fn close_socket);
    LCB_IOPS_DEPRECATED(lcb_io_timer_create_fn create_timer);
    LCB_IOPS_DEPRECATED(lcb_io_timer_destroy_fn destroy_timer);
    LCB_IOPS_DEPRECATED(lcb_io_timer_cancel_fn delete_timer);
    LCB_IOPS_DEPRECATED(lcb_io_timer_schedule_fn update_timer);
    LCB_IOPS_DEPRECATED(lcb_ioC_nameinfo_fn get_nameinfo);
    void (*pad1)(void);
    void (*pad2)(void);
    LCB_IOPS_DEPRECATED(void (*send_error)(struct lcb_io_opt_st *, lcb_sockdata_t *, void (*)(lcb_sockdata_t *)));
    LCB_IOPS_DEPRECATED(lcb_io_stop_fn stop_event_loop);
    LCB_IOPS_DEPRECATED(lcb_io_start_fn run_event_loop);
};
 
typedef struct lcb_timerprocs_st {
    lcb_io_timer_create_fn create;
    lcb_io_timer_destroy_fn destroy;
    lcb_io_timer_cancel_fn cancel;
    lcb_io_timer_schedule_fn schedule;
} lcb_timer_procs;
 
typedef struct lcb_loopprocs_st {
    lcb_io_start_fn start;
    lcb_io_stop_fn stop;
    lcb_io_tick_fn tick;
} lcb_loop_procs;
 
typedef struct lcb_bsdprocs_st {
    lcb_ioE_socket_fn socket0;
    lcb_ioE_connect_fn connect0;
    lcb_ioE_recv_fn recv;
    lcb_ioE_recvv_fn recvv;
    lcb_ioE_send_fn send;
    lcb_ioE_sendv_fn sendv;
    lcb_ioE_close_fn close;
    lcb_ioE_bind_fn bind;
    lcb_ioE_listen_fn listen;
    lcb_ioE_accept_fn accept;
    lcb_ioE_chkclosed_fn is_closed;
    lcb_ioE_cntl_fn cntl;
} lcb_bsd_procs;
 
typedef struct lcb_evprocs_st {
    lcb_ioE_event_create_fn create;
    lcb_ioE_event_destroy_fn destroy;
    lcb_ioE_event_cancel_fn cancel;
    lcb_ioE_event_watch_fn watch;
} lcb_ev_procs;
 
typedef struct {
    lcb_ioC_socket_fn socket;
    lcb_ioC_close_fn close;
    lcb_ioC_read_fn read;
    lcb_ioC_connect_fn connect;
    lcb_ioC_wballoc_fn wballoc;
    lcb_ioC_wbfree_fn wbfree;
    lcb_ioC_write_fn write;
    lcb_ioC_write2_fn write2;
    lcb_ioC_read2_fn read2;
    lcb_ioC_serve_fn serve;
    lcb_ioC_nameinfo_fn nameinfo;
    lcb_ioC_chkclosed_fn is_closed;
    lcb_ioC_cntl_fn cntl;
} lcb_completion_procs;
 
typedef enum {
    LCB_IOMODEL_EVENT,     
    LCB_IOMODEL_COMPLETION 
} lcb_iomodel_t;
 
typedef void (*lcb_io_procs_fn)(int version, lcb_loop_procs *loop_procs, lcb_timer_procs *timer_procs,
                                lcb_bsd_procs *bsd_procs, lcb_ev_procs *ev_procs,
                                lcb_completion_procs *completion_procs, lcb_iomodel_t *iomodel);
 
struct lcbio_TABLE;
struct lcb_iops2_st {
    LCB_IOPS_BASE_FIELDS
    lcb_io_procs_fn get_procs;
    struct lcbio_TABLE *iot;
};
 
/* This is here to provide backwards compatibility with older (broken) clients
 * which attempt to 'subclass' the select plugin, or similar. In this case we
 * provide 17 callback fields (unused here) which the plugin implementation
 * may set, so that the older code can continue to function without upgrading
 * the client to a newer version. This should not be used except by internal
 * plugins; specifically the ABI layout of this field is subject to change
 * (for example, additional fields may be added or existing fields may be
 * renamed/removed) without notice.
 */
typedef void (*lcb__iops3fndummy)(void);
struct lcb_iops3_st {
    LCB_IOPS_BASE_FIELDS
    lcb__iops3fndummy pads[17];
    lcb_io_procs_fn get_procs;
    struct lcbio_TABLE *iot;
};
 
#define LCB_IOPROCS_VERSION 4
 
#define LCB_IOPS_BASEFLD(iops, fld) ((iops)->v.base).fld
#define LCB_IOPS_ERRNO(iops) LCB_IOPS_BASEFLD(iops, error)
 
struct lcb_io_opt_st {
    int version;
    void *dlhandle;
    void (*destructor)(struct lcb_io_opt_st *iops);
    union {
        struct {
            LCB_IOPS_BASE_FIELDS
        } base;
 
        struct lcb_iops_evented_st v0;
        struct lcb_iops_completion_st v1;
        struct lcb_iops2_st v2;
        struct lcb_iops3_st v3;
    } v;
};
 
typedef lcb_STATUS (*lcb_io_create_fn)(int version, lcb_io_opt_t *io, void *cookie);
 
LIBCOUCHBASE_API
void lcb_iops_wire_bsd_impl2(lcb_bsd_procs *procs, int version);
 
/******************************************************************************
 ******************************************************************************
 ** IO CREATION                                                              **
 ******************************************************************************
 ******************************************************************************/
 
typedef enum {
    LCB_IO_OPS_INVALID = 0x00, 
    LCB_IO_OPS_DEFAULT = 0x01, 
    LCB_IO_OPS_LIBEVENT = 0x02,
    LCB_IO_OPS_WINSOCK = 0x03, 
    LCB_IO_OPS_LIBEV = 0x04,
    LCB_IO_OPS_SELECT = 0x05,
    LCB_IO_OPS_WINIOCP = 0x06,
    LCB_IO_OPS_LIBUV = 0x07
} lcb_io_ops_type_t;
 
typedef struct {
    lcb_io_ops_type_t type; 
    void *cookie;           
} lcb_IOCREATEOPTS_BUILTIN;
 
#ifndef __LCB_DOXYGEN__
/* These are mostly internal structures which may be in use by older applications.*/
typedef struct {
    const char *sofile;
    const char *symbol;
    void *cookie;
} lcb_IOCREATEOPTS_DSO;
typedef struct {
    lcb_io_create_fn create;
    void *cookie;
} lcb_IOCREATEOPS_FUNCTIONPOINTER;
#endif
 
struct lcb_create_io_ops_st {
    int version;
    union {
        lcb_IOCREATEOPTS_BUILTIN v0;
        lcb_IOCREATEOPTS_DSO v1;
        lcb_IOCREATEOPS_FUNCTIONPOINTER v2;
    } v;
};
 
LIBCOUCHBASE_API
lcb_STATUS lcb_create_io_ops(lcb_io_opt_t *op, const struct lcb_create_io_ops_st *options);
 
LIBCOUCHBASE_API
lcb_STATUS lcb_destroy_io_ops(lcb_io_opt_t op);
 
#ifdef __cplusplus
}
#endif
 
#endif