mos_api.h

Go to the documentation of this file.

#ifndef __MOS_API_H_
#define __MOS_API_H_

#ifdef DARWIN
#include <netinet/tcp.h>
#include <netinet/if_ether.h>
#else
#include <linux/tcp.h>
#include <linux/if_ether.h>
#endif
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netinet/ip.h>
#include <stddef.h> /* for offsetof */
#include "mtcp_epoll.h"
#include <stdbool.h>

#ifndef __MTCP_MANAGER
#define __MTCP_MANAGER
typedef struct mtcp_manager * mtcp_manager_t;
#endif
#ifndef __SOCKET_MAP
#define __SOCKET_MAP
typedef struct socket_map * socket_map_t;
#endif

enum mtcp_hook_point
{
    /* NOTE: The value of hooking points should not overlap with any of
     * mos_event_types */

    MOS_NULL    = (1 << 29),
    MOS_HK_RCV     = (1 << 30),
    MOS_HK_SND  = (1 << 31),
};

enum mos_event_type
{
    MOS_NULL_EVENT          = (0),
    /* mos-defined tcp build-in events */
    MOS_ON_PKT_IN       = (0x1<<0),
    /* THIS EVENT IS NOW DEPRECATED (USED ONLY FOR DEBUGGING) */
    MOS_ON_PKT_OUT      = (0x1<<1),
    MOS_ON_CONN_START   = (0x1<<2),
    /* THIS EVENT IS NOW DEPRECATED */
    MOS_ON_CONN_SETUP   = (0x1<<3),
    MOS_ON_CONN_NEW_DATA    = (0x1<<4),
    MOS_ON_ERROR        = (0x1<<5),
    MOS_ON_TIMEOUT      = (0x1<<6),
    MOS_ON_TCP_STATE_CHANGE = (0x1<<7),
    MOS_ON_ORPHAN       = (0x1<<8),
    MOS_ON_REXMIT           = (0x1<<9),
    MOS_ON_CONN_END     = (0x1<<10),

    MOS_ON_DEBUG_MESSAGE  = (0x1<<11),
};

#if 0
/* This may go away in future revisions */
typedef union event_data {
    uint32_t u32;
    uint64_t u64;
    void *ptr;
} event_data_t;
#endif

/* Macros for updating packet context */
#define MOS_ETH_HDR     (1 << 0)
#define MOS_IP_HDR      (1 << 1)
#define MOS_TCP_HDR     (1 << 2)
#define MOS_TCP_PAYLOAD     (1 << 3)
#define MOS_UPDATE_IP_CHKSUM    (1 << 4)
#define MOS_UPDATE_TCP_CHKSUM   (1 << 5)
#define MOS_DROP        (1 << 6)
#define MOS_OVERWRITE       (1 << 7)
#define MOS_CHOMP       (1 << 8)
#define MOS_INSERT      (1 << 9)

struct pkt_info {
    uint32_t      cur_ts;    
    /* ETH */
    uint16_t      eth_len;
    
    /* IP */
    uint16_t      ip_len;
    
    /* TCP */
    uint64_t      offset;    
    uint16_t      payloadlen;
    uint32_t      seq;
    uint32_t      ack_seq;
    uint16_t      window;
    
    /* ~~ 28 byte boundary ~~ */
    
    /*
     * CAUTION!!!
     * It is extremely critical that the last 5 fields (ethh .. frame)
     * are always placed at the end of the definition. MOS relies on
     * this specific arrangement when it is creating a new instantiation
     * of pctx during mtcp_getlastpkt() invocation.
     */
    struct ethhdr *ethh;
    struct iphdr  *iph;
    struct tcphdr *tcph;
    uint8_t       *payload;
};

struct pkt_ctx {
    struct pkt_info  p;

    int8_t        direction; 
    uint8_t       forward;   
    int8_t        in_ifidx;  
    int8_t        out_ifidx; 
    int8_t        batch_index; 
    /* ~~ 64 byte boundary ~~ */
};
#define PKT_INFO_LEN        offsetof(struct pkt_info, ethh)

/* 
 * Sequence number change structure. 
 * Used for MOS_SEQ_REMAP.
 */
typedef struct {
    int64_t seq_off;    /* the amount of sequence number drift */
    int side;       /* which side does this sequence number change apply to? */
    uint32_t base_seq;  /* seq # of the flow where the actual sequence # translation starts */
} seq_remap_info;

typedef struct filter_arg {
    void *arg;
    size_t len;
} filter_arg_t;

#ifndef SOL_SOCKET
/* Level number for (get/set)sockopt() to apply to socket itself. */
#define SOL_SOCKET      0xffff  /* options for socket level */
#endif
#define SOL_MONSOCKET       0xfffe  /* MOS monitor socket level */

enum mos_socket_opts {
    MOS_FRAGINFO_CLIBUF = 0x01,
    MOS_FRAGINFO_SVRBUF = 0x02,
    MOS_INFO_CLIBUF     = 0x03,
    MOS_INFO_SVRBUF     = 0x04,
    MOS_TCP_STATE_CLI   = 0x05,
    MOS_TCP_STATE_SVR   = 0x06,
    MOS_TIMESTAMP       = 0x07,
    MOS_MONLEVEL        = 0x08,
    MOS_CLIBUF          = 0x09,
    MOS_SVRBUF          = 0x0a,
    MOS_SEQ_REMAP       = 0x0b,
    MOS_STOP_MON        = 0x0c,
    MOS_FRAG_CLIBUF     = 0x0d,
    MOS_FRAG_SVRBUF     = 0x0e,
    MOS_CLIOVERLAP      = 0x0f,
    MOS_SVROVERLAP      = 0x10,
#ifdef OLD_API
    MOS_NO_CLIBUF       = 0x0f,
    MOS_NO_SVRBUF       = 0x10,
#endif
};

struct tcp_buf_info {
    uint32_t tcpbi_init_seq;
    uint32_t tcpbi_last_byte_read;
    uint32_t tcpbi_next_byte_expected;
    uint32_t tcpbi_last_byte_received;
};

struct tcp_ring_fragment {
    uint64_t offset;
    uint32_t len;
};

enum tcpstate
{
    TCP_CLOSED      = 0,
    TCP_LISTEN      = 1,
    TCP_SYN_SENT        = 2,
    TCP_SYN_RCVD        = 3,
    TCP_ESTABLISHED     = 4,
    TCP_FIN_WAIT_1      = 5,
    TCP_FIN_WAIT_2      = 6,
    TCP_CLOSE_WAIT      = 7,
    TCP_CLOSING     = 8,
    TCP_LAST_ACK        = 9,
    TCP_TIME_WAIT       = 10
};

enum {
    MOS_OVERLAP_POLICY_FIRST=0,
    MOS_OVERLAP_POLICY_LAST,
    MOS_OVERLAP_CNT
};

typedef uint64_t event_t;

enum {MOS_SIDE_CLI=0, MOS_SIDE_SVR, MOS_SIDE_BOTH};

/* mos callback/filter function type definition */
typedef void (*callback_t)(mctx_t mctx, int sock, int side,
             event_t event, filter_arg_t *arg);
typedef bool (*filter_t)(mctx_t mctx, int sock, int side,
               event_t event, filter_arg_t *arg);

/*----------------------------------------------------------------------------*/
/* Definition of monitor_filter type */
union monitor_filter {
    char *raw_pkt_filter;
    struct {
        char *stream_syn_filter;
        char *stream_orphan_filter;
    };  
};
typedef union monitor_filter *monitor_filter_t;

/* Assign an address range (specified by ft) to monitor via sock
 *
 * (1) If sock is MOS_SOCK_MONITOR_RAW type, ft.raw_pkt_filter is applied to
 *     every packet coming in.
 * (2) If sock is MOS_SOCK_MONITOR_STREAM type,
 *     ft.stream_syn_filter is applied to the first SYN pkt of the flow.
 *     (The succeeding packets of that flow will bypass the filter operation.)
 *     ft.stream_orphan_filter is applied to the pkts that don't belong to any
 *     of the existing TCP streams which are being monitored.
 *     (e.g., non-SYN pkt with no identified flow)
 * [*] ft.stream_syn_filter and ft.stream_orphan_filter should be consisted
 *     only of the following keywords:
 *     - 'tcp, 'host', 'src', 'dst', 'net', 'mask', 'port', 'portrange'
 *     - 'and', 'or', '&', '|'
 *
 * @param [in] mctx: mtcp context
 * @param [in] sock: socket id (should be MOS_SOCK_MONITOR_RAW
 *                   or MOS_SOCK_MONITOR_STREAM type)
 * @param [in] cf: Describe a set of connections to accept
 *                 in a BPF (Berkerley Packet Filter) format
 *                 NULL if you want to monitor any packet
 * @return zero on success, -1 on error
 */
int
mtcp_bind_monitor_filter(mctx_t mctx, int sock, monitor_filter_t ft);
/*----------------------------------------------------------------------------*/

int
mtcp_register_callback(mctx_t mctx, int sock, event_t event,
                               int hook_point, callback_t cb);

event_t
mtcp_alloc_event(event_t event);

event_t
mtcp_define_event(event_t event, filter_t filter, struct filter_arg *arg);

int
mtcp_raise_event(mctx_t mctx, event_t event);

/*
 * Callback only functions
 */

void
mtcp_set_uctx(mctx_t mctx, int sock, void *uctx);

void *
mtcp_get_uctx(mctx_t mctx, int sock);

ssize_t
mtcp_peek(mctx_t mctx, int sock, int side,
         char *buf, size_t len);

ssize_t mtcp_ppeek(mctx_t mctx, int sock, int side, 
              char *buf, size_t count, uint64_t off);

/* Use this macro to copy packets when mtcp_getlastpkt is called */
#define MTCP_CB_GETCURPKT_CREATE_COPY

int
mtcp_getlastpkt(mctx_t mctx, int sock, int side, struct pkt_info *p);

int
mtcp_settimer(mctx_t mctx, int id, struct timeval *timeout, callback_t cb);

uint32_t
mtcp_cb_get_ts(mctx_t mctx);

void
mtcp_app_join(mctx_t mctx);

int
mtcp_getpeername(mctx_t mctx, int sock, struct sockaddr *saddr, socklen_t *addrlen, int side);

int
mtcp_setlastpkt(mctx_t mctx, int sock, int side, off_t offset,
        byte *data, uint16_t datalen, int option);

//int
//mtcp_cb_dropcurpkt(mctx_t mctx);

/* Reset the connection (send RST to both sides)
 * (This API will be updated after discussion.)
 */
int
mtcp_reset_conn(mctx_t mctx, int sock);

int
mtcp_set_debug_string(mtcp_manager_t mtcp, const char *fmt, ...);

int
mtcp_get_debug_string(mctx_t mctx, char *buf, int len);

/**************************************************************************/
/* experimental mOS APIs from here 
   (NOTE: do not include those when releasing the mOS release package) */

int
mtcp_sendpkt(mctx_t mctx, int sock, const struct pkt_info *pkt);

/**************************************************************************/

#endif /* __MOS_API_H_ */