iops.h

Go to the documentation of this file.

/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
/*
 *     Copyright 2014 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

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);

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 void (*lcb_io_start_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_ioE_socket_fn socket; 
    lcb_ioE_connect_fn connect; 
    lcb_ioE_recv_fn recv; 
    lcb_ioE_send_fn send; 
    lcb_ioE_recvv_fn recvv; 
    lcb_ioE_sendv_fn sendv; 
    lcb_ioE_close_fn close; 
    lcb_io_timer_create_fn create_timer; 
    lcb_io_timer_destroy_fn destroy_timer; 
    lcb_io_timer_cancel_fn delete_timer; 
    lcb_io_timer_schedule_fn update_timer; 
    lcb_ioE_event_create_fn create_event; 
    lcb_ioE_event_destroy_fn destroy_event; 
    lcb_ioE_event_watch_fn update_event; 
    lcb_ioE_event_cancel_fn delete_event;

    lcb_io_stop_fn stop_event_loop; 
    lcb_io_start_fn run_event_loop; 
};

struct lcb_iops_completion_st {
    LCB_IOPS_BASE_FIELDS

    lcb_ioC_socket_fn create_socket;
    lcb_ioC_connect_fn start_connect;
    lcb_ioC_wballoc_fn create_writebuf;
    lcb_ioC_wbfree_fn release_writebuf;
    lcb_ioC_write_fn start_write;
    lcb_ioC_read_fn start_read;
    lcb_ioC_close_fn close_socket;

    lcb_io_timer_create_fn create_timer;
    lcb_io_timer_destroy_fn destroy_timer;
    lcb_io_timer_cancel_fn delete_timer;
    lcb_io_timer_schedule_fn update_timer;

    lcb_ioC_nameinfo_fn get_nameinfo;

    void (*pad1)(void);
    void (*pad2)(void);

    void (*send_error)(struct lcb_io_opt_st*, lcb_sockdata_t*,void(*)(lcb_sockdata_t*));

    lcb_io_stop_fn stop_event_loop;
    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_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_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_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;
};

#define LCB_IOPROCS_VERSION 3

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;
    } v;
};

typedef lcb_error_t (*lcb_io_create_fn)
        (int version, lcb_io_opt_t *io, void *cookie);


#ifdef __cplusplus
}
#endif

#endif