盒子论坛 v2.1

unit libevent;

interface

uses
  Windows, Messages, SysUtils, Classes, Winsock, JwaWS2tcpip, JwaWinsock2,
  OverbyteIcsSSLEAY;

const
  event_openssl = 'libevent_openssl-2-0-5.dll';
  event_core = 'libevent_core-2-0-5.dll';
  event_extra = 'libevent_extra-2-0-5.dll';
  event = 'libevent-2-0-5.dll';
  EVBUFFER_FLAG_DRAINS_TO_FD = 1;
  EVBUFFER_CB_ENABLED = 1;
  BEV_EVENT_READING = $01;
  BEV_EVENT_WRITING = $02;
  BEV_EVENT_EOF = $10;
  BEV_EVENT_ERROR = $20;
  BEV_EVENT_TIMEOUT = $40;
  BEV_EVENT_CONNECTED = $80;
  DNS_ERR_NONE = 0;
  DNS_ERR_FORMAT = 1;
  DNS_ERR_SERVERFAILED = 2;
  DNS_ERR_NOTEXIST = 3;
  DNS_ERR_NOTIMPL = 4;
  DNS_ERR_REFUSED = 5;
  DNS_ERR_TRUNCATED = 65;
  DNS_ERR_UNKNOWN = 66;
  DNS_ERR_TIMEOUT = 67;
  DNS_ERR_SHUTDOWN = 68;
  DNS_ERR_CANCEL = 69;
  DNS_ERR_NODATA = 70;
  DNS_IPv4_A = 1;
  DNS_PTR = 2;
  DNS_IPv6_AAAA = 3;
  DNS_QUERY_NO_SEARCH = 1;
  DNS_OPTION_SEARCH = 1;
  DNS_OPTION_NAMESERVERS = 2;
  DNS_OPTION_MISC = 4;
  DNS_OPTION_HOSTSFILE = 8;
  DNS_OPTIONS_ALL = 15;
  DNS_NO_SEARCH = DNS_QUERY_NO_SEARCH;
  EVDNS_ANSWER_SECTION = 0;
  EVDNS_AUTHORITY_SECTION = 1;
  EVDNS_ADDITIONAL_SECTION = 2;
  EVDNS_TYPE_A = 1;
  EVDNS_TYPE_NS = 2;
  EVDNS_TYPE_CNAME = 5;
  EVDNS_TYPE_SOA = 6;
  EVDNS_TYPE_PTR = 12;
  EVDNS_TYPE_MX = 15;
  EVDNS_TYPE_TXT = 16;
  EVDNS_TYPE_AAAA = 28;
  EVDNS_QTYPE_AXFR = 252;
  EVDNS_QTYPE_ALL = 255;
  EVDNS_CLASS_INET = 1;
  EVDNS_FLAGS_AA = $400;
  EVDNS_FLAGS_RD = $080;
  _EVENT_VERSION = '2.0.16-stable';
  _EVENT_NUMERIC_VERSION = $02001000;
  LIBEVENT_VERSION = _EVENT_VERSION;
  LIBEVENT_VERSION_NUMBER = _EVENT_NUMERIC_VERSION;
  EVENT_MAX_PRIORITIES = 256;
  _EVENT_LOG_DEBUG = 0;
  _EVENT_LOG_MSG = 1;
  _EVENT_LOG_WARN = 2;
  _EVENT_LOG_ERR = 3;
  EVLOOP_ONCE = $01;
  EVLOOP_NONBLOCK = $02;
  EV_TIMEOUT = $01;
  EV_READ = $02;
  EV_WRITE = $04;
  EV_SIGNAL = $08;
  EV_PERSIST = $10;
  EV_ET = $20;
  HTTP_OK = 200;
  HTTP_NOCONTENT = 204;
  HTTP_MOVEPERM = 301;
  HTTP_MOVETEMP = 302;
  HTTP_NOTMODIFIED = 304;
  HTTP_BADREQUEST = 400;
  HTTP_NOTFOUND = 404;
  HTTP_BADMETHOD = 405;
  HTTP_ENTITYTOOLARGE = 413;
  HTTP_EXPECTATIONFAILED = 417;
  HTTP_INTERNAL = 500;
  HTTP_NOTIMPLEMENTED = 501;
  HTTP_SERVUNAVAIL = 503;
  EVTHREAD_WRITE = $04;
  EVTHREAD_READ = $08;
  EVTHREAD_TRY = $10;
  EVTHREAD_LOCK_API_VERSION = 1;
  EVTHREAD_LOCKTYPE_RECURSIVE = 1;
  EVTHREAD_LOCKTYPE_READWRITE = 2;
  EVTHREAD_CONDITION_API_VERSION = 1;
  LEV_OPT_LEAVE_SOCKETS_BLOCKING = (49 shl 0);
  LEV_OPT_CLOSE_ON_FREE = (49 shl 1);
  LEV_OPT_CLOSE_ON_EXEC = (49 shl 2);
  LEV_OPT_REUSEABLE = (49 shl 3);
  LEV_OPT_THREADSAFE = (49 shl 4);
  EVTHREAD_USE_WINDOWS_THREADS_IMPLEMENTED = 1;
  EVTHREAD_USE_PTHREADS_IMPLEMENTED = 1;
  EVHTTP_URI_NONCONFORMANT = $01;
  EVHTTP_REQ_OWN_CONNECTION = $0001;
  EVHTTP_PROXY_REQUEST = $0002;
  EVHTTP_USER_OWNED = $0004;
  EVHTTP_REQ_DEFER_FREE = $0008;
  EVHTTP_REQ_NEEDS_FREE = $0010;
  EVHTTP_CON_INCOMING = $0001;
  EVHTTP_CON_OUTGOING = $0002;
  EVHTTP_CON_CLOSEDETECT = $0004;
  EVRPC_STATUS_ERR_NONE = 0;
  EVRPC_STATUS_ERR_TIMEOUT = 1;
  EVRPC_STATUS_ERR_BADPAYLOAD = 2;
  EVRPC_STATUS_ERR_UNSTARTED = 3;
  EVRPC_STATUS_ERR_HOOKABORTED = 4;
  SSL_MAX_KEY_ARG_LENGTH = 8;
  SSL_MAX_BUF_FREELIST_LEN_DEFAULT = 32;
  SSL_MAX_MASTER_KEY_LENGTH = 48;
  SSL_MAX_SSL_SESSION_ID_LENGTH = 32;
  SSL_MAX_SID_CTX_LENGTH = 32;
  SSL_MAX_KRB5_PRINCIPAL_LENGTH = 256;
  SSL_PKEY_NUM = 8;
  HMAC_MAX_MD_CBLOCK = 128;

type
  time_t = Int64;
  Tev_ssize_t = Integer;
  Pevbuffer = ^Tevbuffer;
  Tevutil_socket_t = Integer;
  Tev_uint64_t = Int64;
  Tev_int64_t = Int64;
  Tev_uint16_t = Byte;
  Tev_socklen_t = Integer;
  Tev_uint32_t = Integer;
  Tev_off_t = Tev_int64_t;
  off_t = LongInt;

  Tevbuffer = record
    buffer: PChar;
    orig_buffer: PChar;
    misalign: Integer;
    totallen: Integer;
    off: Integer;
    cb: function(buffe: Pevbuffer; size1, size2: Integer;
      void: Pointer): Pointer;
    cbarg: Pointer;
  end;

  Tevent_watermark = record
    low: Integer;
    high: Integer;
  end;

  Ttimeval = record
    tv_sec: LongInt;
    tv_usec: LongInt;
  end;

  Pevent_base = ^Tevent_base;
  Tevent_method_feature = (EV_FEATURE_ET = $01, EV_FEATURE_O1 = $02,
    EV_FEATURE_FDS = $04);

  Teventop = record
    name: PChar;
    init: function(base: Pevent_base): Pointer;
    add: function(base: Pevent_base; fd: Tevutil_socket_t;
      old, events: ShortInt; fdinfo: Pointer): Integer;
    del: function(base: Pevent_base; fd: Tevutil_socket_t;
      old, events: ShortInt; fdinfo: Pointer): Integer;
    dispatch: function(base: Pevent_base; timeval: Ttimeval): Integer;
    dealloc: function(base: Pevent_base): Pointer;
    need_reinit: Integer;
    features: Tevent_method_feature;
    fdinfo_len: Integer;
  end;

  Tevent_change = record
    fd: Tevutil_socket_t;
    old_events: ShortInt;
    read_change: Byte;
    write_change: Byte;
  end;

  Tevent_changelist = record
    changes: Tevent_change;
    n_changes: Integer;
    changes_size: Integer;
  end;

  Pevent = ^Tevent;
  Tev_sighandler_t = function(int_: Integer): Pointer;

  Tevsig_info = record
    EV_SIGNAL: Pevent;
    ev_signal_pair: array [0 .. 1] of Tevutil_socket_t;
    ev_signal_added: Integer;
    ev_n_signals_added: Integer;
    sh_old: Tev_sighandler_t;
    sh_old_max: Integer;
  end;

  Tevent = record
    ev_next: Pevent_base;
    ev_active_next: Pevent;
    ev_signal_next: Pevent;
    min_heap_idx: Integer;
    ev_base: Pevent_base;
    ev_fd: Integer;
    ev_events: ShortInt;
    ev_ncalls: ShortInt;
    ev_pncalls: ShortInt;
    EV_TIMEOUT: Ttimeval;
    ev_pri: Integer;
    ev_callback: function(int_: Integer; short_: ShortInt;
      arg: Pointer): Pointer;
    ev_arg: Pointer;
    ev_res: Integer;
    ev_flags: Integer;
  end;

  Pevent_list = ^Tevent_list;

  Tevent_list = record
    slh_first: Pevent_list;
  end;

  Tcommon_timeout_list = record
    events: Tevent_list;
    duration: Ttimeval;
    timeout_event: Tevent;
    base: Pevent_base;
  end;

  Pdeferred_cb_queue = ^Tdeferred_cb_queue;
  Pdeferred_cb = ^Tdeferred_cb;
  Tdeferred_cb_fn = function(deferred_cb: Pdeferred_cb; void: Pointer): Pointer;

  Tdeferred_cb = record
    cb_next: Pdeferred_cb;
    queued: Cardinal;
    cb: Tdeferred_cb_fn;
    arg: Pointer;
  end;

  Tdeferred_cb_queue = record
    lock: Pointer;
    active_count: Integer;
    notify_fn: function(deferred_cb_queue: Pdeferred_cb_queue;
      void: Pointer): Pointer;
    notify_arg: Pointer;
    deferred_cb_list: Tdeferred_cb;
  end;

  Pevent_map_entry = ^Tevent_map_entry;

  Tevmap_io = record
    events: Tevent_list;
    nread: Integer;
    nwrite: Integer;
  end;

  Tent = packed record
    evmap_io: Tevmap_io;
  end;

  Tevent_map_entry = record
    map_node: Pevent_map_entry;
    fd: Tevutil_socket_t;
    ent: Tent;
  end;

  Tevent_io_map = ^Tevent_map_entry;
  Tevent_signal_map = ^Tevent_io_map;

  Tmin_heap = record
    p: Tevent;
    n: Cardinal;
    a: Cardinal;
  end;

  Tevent_iocp_port = record
    port: THandle;
    lock: TRTLCriticalSection;
    n_threads: ShortInt;
    shutdown: ShortInt;
    ms: LongInt;
    threads: THandle;
    n_live_threads: ShortInt;
    shutdownSemaphore: THandle;
  end;

  Tevent_base_config_flag = (EVENT_BASE_FLAG_NOLOCK = $01,
    EVENT_BASE_FLAG_IGNORE_ENV = $02, EVENT_BASE_FLAG_STARTUP_IOCP = $04,
    EVENT_BASE_FLAG_NO_CACHE_TIME = $08,
    EVENT_BASE_FLAG_EPOLL_USE_CHANGELIST = $10);

  Tevent_base = record
    evsel: Teventop;
    evbase: Pointer;
    changelist: Tevent_changelist;
    evsigsel: Teventop;
    sig: Tevsig_info;
    virtual_event_count: Integer;
    event_count: Integer;
    event_count_active: Integer;
    event_gotterm: Integer;
    event_break: Integer;
    running_loop: Integer;
    activequeues: Tevent_list;
    nactivequeues: Integer;
    common_timeout_queues: Tcommon_timeout_list;
    n_common_timeouts: Integer;
    n_common_timeouts_allocated: Integer;
    defer_queue: Tdeferred_cb_queue;
    io: Tevent_io_map;
    sigmap: Tevent_signal_map;
    eventqueue: Tevent_list;
    event_tv: Ttimeval;
    timeheap: Tmin_heap;
    tv_cache: Ttimeval;
    tv_clock_diff: Ttimeval;
    last_updated_clock_diff: time_t;
    th_owner_id: Cardinal;
    th_base_lock: Pointer;
    current_event: Tevent;
    current_event_cond: Pointer;
    current_event_waiters: Integer;
    iocp: Tevent_iocp_port;
    flags: Tevent_base_config_flag;
    is_notify_pending: Integer;
    th_notify_fd: array [0 .. 1] of Tevutil_socket_t;
    th_notify: Tevent;
    th_notify_fn: function(base: Tevent_base): Integer;
  end;

  Tbufferevent_flush_mode = (BEV_NORMAL = 0, BEV_FLUSH = 1, BEV_FINISHED = 2);
  Tbufferevent_ctrl_op = (BEV_CTRL_SET_FD, BEV_CTRL_GET_FD,
    BEV_CTRL_GET_UNDERLYING, BEV_CTRL_CANCEL_ALL);
  Pbufferevent = ^Tbufferevent;

  Tbufferevent_ctrl_data = packed record
    ptr: Pointer;
    fd: Tevutil_socket_t;
  end;

  Tbufferevent_ops = record
    cType: PChar;
    mem_offset: off_t;
    enable: function(bufferevent: Pbufferevent; short_: ShortInt): Integer;
    disable: function(bufferevent: Pbufferevent; short_: ShortInt): Integer;
    destruct: function(bufferevent: Pbufferevent): Pointer;
    adj_timeouts: function(bufferevent: Pbufferevent): Integer;
    flush: function(bufferevent: Pbufferevent; short_: ShortInt;
      mode: Tbufferevent_flush_mode): Integer;
    ctrl: function(bufferevent: Pbufferevent; ctrl_op: Tbufferevent_ctrl_op;
      ctrl_data: Tbufferevent_ctrl_data): Integer;
  end;

  Tbufferevent_data_cb = function(bev: Pbufferevent; ctx: Pointer): Pointer;
  Tbufferevent_event_cb = function(bev: Pbufferevent; what: ShortString;
    ctx: Pointer): Pointer;

  Tbufferevent = record
    ev_base: Tevent_base;
    be_ops: Tbufferevent_ops;
    EV_READ: Tevent;
    EV_WRITE: Tevent;
    input: Tevbuffer;
    output: Tevbuffer;
    wm_read: Tevent_watermark;
    wm_write: Tevent_watermark;
    readcb: Tbufferevent_data_cb;
    writecb: Tbufferevent_data_cb;
    errorcb: Tbufferevent_event_cb;
    cbarg: Pointer;
    timeout_read: Ttimeval;
    timeout_write: Ttimeval;
    enabled: ShortInt;
  end;

  Tevbuffer_iovec = record
    iov_base: Pointer;
    iov_len: Integer;
  end;

  Tevbuffer_cb_info = record
    orig_size: Integer;
    n_added: Integer;
    n_deleted: Integer;
  end;

  Tevthread_lock_callbacks = record
    lock_api_version: Integer;
    supported_locktypes: LongInt;
    alloc: function(locktype: LongInt): Pointer;
    free: function(lock: Pointer; locktype: LongInt): Pointer;
    lock: function(mode: LongInt; lock: Pointer): Integer;
    unlock: function(mode: LongInt; lock: Pointer): Integer;
  end;

  Tevthread_condition_callbacks = record
    condition_api_version: Integer;
    alloc_condition: function(condtype: LongInt): Pointer;
    free_condition: function(cond: Pointer): Pointer;
    signal_condition: function(cond: Pointer; broadcast: Integer): Integer;
    wait_condition: function(cond, lock: Pointer;
      var timeout: Ttimeval): Integer;
  end;

  Pevutil_addrinfo = ^Tevutil_addrinfo;

  Tevutil_addrinfo = record
    ai_flags: Integer;
    ai_family: Integer;
    ai_socktype: Integer;
    ai_protocol: Integer;
    ai_addrlen: Integer;
    ai_canonname: PChar;
    ai_addr: Tsockaddr;
    ai_next: Pevutil_addrinfo;
  end;

  Tevdns_server_question = record
    Type_: Integer;
    dns_question_class: Integer;
    class_: Integer;
    name: array [0 .. 1] OF PChar;
  end;

  Tevdns_server_request = record
    flags: Integer;
    nquestions: Integer;
    questions: Tevdns_server_question;
  end;

  Pevconnlistener = ^Tevconnlistener;

  Tevconnlistener_ops = record
    enable: function(evconnlistener: Pevconnlistener): Integer;
    disable: function(evconnlistener: Pevconnlistener): Integer;
    destroy: function(evconnlistener: Pevconnlistener): Pointer;
    shutdown: function(evconnlistener: Pevconnlistener): Pointer;
    getfd: function(evconnlistener: Pevconnlistener): Tevutil_socket_t;
    getbase: function(evconnlistener: Pevconnlistener): Tevent_base;
  end;

  Tevconnlistener_cb = function(evconnlistener_: Pevconnlistener;
    evutil_socket_t_: Tevutil_socket_t; sockaddr_: Tsockaddr; socklen: Integer;
    void: Pointer): Pointer;
  Tevconnlistener_errorcb = function(evconnlistener_: Pevconnlistener;
    void: Pointer): Pointer;

  Tevconnlistener = record
    ops: Tevconnlistener_ops;
    lock: Pointer;
    cb: Tevconnlistener_cb;
    errorcb: Tevconnlistener_errorcb;
    user_data: Pointer;
    flags: Cardinal;
    refcnt: SHORT;
    enabled: Cardinal;
  end;

  Tevhttp_cmd_type = (EVHTTP_REQ_GET = 1 shl 0, EVHTTP_REQ_POST = 1 shl 1,
    EVHTTP_REQ_HEAD = 1 shl 2, EVHTTP_REQ_PUT = 1 shl 3,
    EVHTTP_REQ_DELETE = 1 shl 4, EVHTTP_REQ_OPTIONS = 1 shl 5,
    EVHTTP_REQ_TRACE = 1 shl 6, EVHTTP_REQ_CONNECT = 1 shl 7,
    EVHTTP_REQ_PATCH = 1 shl 8);
  Tevhttp_request_kind = (EVHTTP_REQUEST, EVHTTP_RESPONSE);

  Pevhttp_request = ^Tevhttp_request;

  Tevhttp_request_next = packed record
    case LongInt of
      0:
        (tqe_next: Pevhttp_request);
      1:
        (tqe_prev: Pevhttp_request);
  end;

  Tevhttp_connection_state = (EVCON_DISCONNECTED, EVCON_CONNECTING, EVCON_IDLE,
    EVCON_READING_FIRSTLINE, EVCON_READING_HEADERS, EVCON_READING_BODY,
    EVCON_READING_TRAILER, EVCON_WRITING);

  Pevhttp_connection = ^Tevhttp_connection;

  Pevhttp_bound_socket = ^Tevhttp_bound_socket;

  Pevhttp = ^Tevhttp;

  Pevhttp_cb = ^Tevhttp_cb;

  Tevhttp_cb = record
    next: Pevhttp_cb;
    what: PChar;
    cb: function(req: Pevhttp_request; void: Pointer): Pointer;
    cbarg: Pointer;
  end;

  Tevhttp_bound_socket = record
    next: Pevhttp_bound_socket;
    listener: Tevconnlistener;
  end;

  Pevhttp_server_alias = ^Tevhttp_server_alias;

  Tevhttp_server_alias = record

    next: Pevhttp_server_alias;
    alias: PChar;
  end;

  Tevconq = Pevhttp_connection;

  Tevhttp = record
    next_vhost: Pevhttp;
    sockets: Tevhttp_bound_socket;
    callbacks: Tevhttp_cb;
    connections: Tevconq;
    virtualhosts: Pevhttp;
    aliases: Tevhttp_server_alias;
    vhost_pattern: PChar;
    timeout: Integer;
    default_max_headers_size: Integer;
    default_max_body_size: Tev_uint64_t;
    allowed_methods: Tev_uint16_t;
    gencb: function(req: Pevhttp_request; void: Pointer): Pointer;
    gencbarg: Pointer;
    base: Tevent_base;
  end;

  Pevdns_base = ^Tevdns_base;
  Pnameserver = ^Tnameserver;

  Tsockaddr_storage = record
    ss_family: PChar;
    __ss_pad1: array [0 .. _SS_PAD1SIZE - 1] of PChar;
    __ss_align: Int64;
    __ss_pad2: array [0 .. _SS_PAD2SIZE - 1] of PChar;
  end;

  Pevdns_request = ^Tevdns_request;

  Prequest = ^Trequest;

  Tevdns_callback_type = function(result_: Integer; cType: PChar;
    count, ttl: Integer; addresses, arg: Pointer): Pointer;

  Trequest = record
    request: Byte;
    request_type: Byte;
    request_len: Cardinal;
    reissue_count: Integer;
    tx_count: Integer;
    user_pointer: Pointer;
    user_callback: Tevdns_callback_type;
    ns: Pnameserver;
    next: Prequest;
    prev: Prequest;
    timeout_event: Tevent;
    trans_id: Word;
    request_appended: Cardinal;
    transmit_me: Cardinal;
    put_cname_in_ptr: PChar;
    base: Pevdns_base;
    HANDLE: Pevdns_request;
  end;

  Pserver_request = ^Tserver_request;

  Tevdns_request_callback_fn_type = function
    (server_request: Tevdns_server_request; void: Pointer): Pointer;

  Tevdns_server_port = record
    socket: Tevutil_socket_t;
    refcnt: Integer;
    choked: PChar;
    closing: PChar;
    user_callback: Tevdns_request_callback_fn_type;
    user_data: Pointer;
    event: Tevent;
    pending_replies: Pserver_request;
    event_base: Pevent_base;
    lock: Pointer;
  end;

  Pserver_reply_item = ^Tserver_reply_item;

  Tserver_reply_item = record
    next: Pserver_reply_item;
    name: PChar;
    cType: Word;
    class_: Word;
    ttl: Integer;
    is_name: PChar;
    datalen: Word;
    data: Pointer;
  end;

  Tserver_request = record
    next_pending: Pserver_request;
    prev_pending: Pserver_request;
    trans_id: Word;
    port: Tevdns_server_port;
    addr: Tsockaddr_storage;
    addrlen: Tev_socklen_t;
    n_answer: Integer;
    n_authority: Integer;
    n_additional: Integer;
    answer: Tserver_reply_item;
    authority: Tserver_reply_item;
    additional: Tserver_reply_item;
    response: PChar;
    response_len: Integer;
    base: Tevdns_server_request;
  end;

  Psearch_domain = ^Tsearch_domain;

  Tsearch_domain = record
    len: Integer;
    next: Psearch_domain;
  end;

  Tsearch_state = record
    refcount: Integer;
    ndots: Integer;
    num_domains: Integer;
    head: Tsearch_domain;
  end;

  Tevdns_request = record
    current_req: Trequest;
    base: Pevdns_base;
    pending_cb: Integer;
    search_index: Integer;
    search_state: Tsearch_state;
    search_origname: PChar;
    search_flags: Integer;
  end;

  Tnameserver = record
    socket: Tevutil_socket_t;
    address: Tsockaddr_storage;
    addrlen: Tev_socklen_t;
    failed_times: Integer;
    timedout: Integer;
    event: Tevent;
    next: Pnameserver;
    prev: Pnameserver;
    timeout_event: Tevent;
    probe_request: Tevdns_request;
    state: PChar;
    choked: PChar;
    write_waiting: PChar;
    base: Pevdns_base;
  end;

  Taddr = packed record
    sa: Tsockaddr;
    sin: TSockAddrIn;
    sin6: sockaddr_in6;
  end;

  Phosts_entry = ^Thosts_entry;

  Thosts_entry = record
    next: Phosts_entry;
    addr: Taddr;
    addrlen: Integer;
    hostname: array [0 .. 1] of PChar;
  end;

  Tevdns_base = record
    req_heads: Trequest;
    req_waiting_head: Trequest;
    server_head: Tnameserver;
    n_req_heads: Integer;
    event_base: Tevent_base;
    global_good_nameservers: Integer;
    global_requests_inflight: Integer;
    global_requests_waiting: Integer;
    global_max_requests_inflight: Integer;
    global_timeout: Ttimeval;
    global_max_reissues: Integer;
    global_max_retransmits: Integer;
    global_max_nameserver_timeout: Integer;
    global_randomize_case: Integer;
    global_nameserver_probe_initial_timeout: Ttimeval;
    global_outgoing_address: Tsockaddr_storage;
    global_outgoing_addrlen: Tev_socklen_t;
    global_getaddrinfo_allow_skew: Ttimeval;
    getaddrinfo_ipv4_timeouts: Integer;
    getaddrinfo_ipv6_timeouts: Integer;
    getaddrinfo_ipv4_answered: Integer;
    getaddrinfo_ipv6_answered: Integer;
    global_search_state: Tsearch_state;
    hostsdb: Thosts_entry;
    lock: Pointer;
  end;

  Tevhttp_connection = record
    next: Pevhttp_connection;
    fd: Tevutil_socket_t;
    bufev: Tbufferevent;
    retry_ev: Tevent;
    bind_address: PChar;
    bind_port: ShortInt;
    address: PChar;
    port: ShortInt;
    max_headers_size: Integer;
    max_body_size: Tev_uint64_t;
    flags: Integer;
    timeout: Integer;
    retry_cnt: Integer;
    retry_max: Integer;
    state: Tevhttp_connection_state;
    http_server: Tevhttp;
    requests: Pevhttp_request;
    cb: function(http_connection: Tevhttp_connection; void: Pointer): Pointer;
    cb_arg: Pointer;
    closecb: function(http_connection: Tevhttp_connection;
      void: Pointer): Pointer;
    closecb_arg: Pointer;
    read_more_deferred_cb: Tdeferred_cb;
    base: Tevent_base;
    dns_base: Tevdns_base;
  end;

  Pevkeyval = ^Tevkeyval;

  Tevkeyval = record
    next: Pevkeyval;
    key: PChar;
    value: PChar;
  end;

  Tevkeyvalq = Tevkeyval;

  Tevhttp_uri = record
    flags: Cardinal;
    scheme: PChar;
    userinfo: PChar;
    host: PChar;
    port: Integer;
    path: PChar;
    query: PChar;
    fragment: PChar;
  end;

  Tevhttp_request = record
    next: Tevhttp_request_next;
    evcon: Tevhttp_connection;
    flags: Integer;
    input_headers: Tevkeyvalq;
    output_headers: Tevkeyvalq;
    remote_host: PChar;
    remote_port: Integer;
    host_cache: PChar;
    kind: Tevhttp_request_kind;
    cType: Tevhttp_cmd_type;
    headers_size: Integer;
    body_size: Integer;
    uri: PChar;
    uri_elems: Tevhttp_uri;
    major: PChar;
    minor: PChar;
    response_code: Integer;
    response_code_line: PChar;
    input_buffer: Tevbuffer;
    ntoread: Tev_int64_t;
    chunked: Cardinal;
    output_buffer: Tevbuffer;
    cb: function(http_request: Tevhttp_request; void: Pointer): Pointer;
    cb_arg: Pointer;
    chunk_cb: function(http_request: Tevhttp_request; void: Pointer): Pointer;
  end;

  Tevbuffer_ptr_internal = packed record
    chain: Pointer;
    pos_in_chain: Integer;
  end;

  Tevbuffer_ptr = record
    pos: Tev_ssize_t;
    _internal: Tevbuffer_ptr_internal;
  end;

  Tevrpc_status = record
    error: Integer;
    http_req: Tevhttp_request;
  end;

  Pevrpc_meta = ^Tevrpc_meta;

  Tevrpc_meta = record
    next: Pevrpc_meta;
    key: PChar;
    data: Pointer;
    data_size: Integer;
  end;

  Tevrpc_meta_list = Tevrpc_meta;

  Tevrpc_hook_meta = record
    meta_data: Tevrpc_meta_list;
    evcon: Tevhttp_connection;
  end;

  Pevrpc = ^Tevrpc;
  Pevrpc_req_generic = ^Tevrpc_req_generic;
  Pevrpc_hook_ctx = ^Tevrpc_hook_ctx;
  Tevrpc_list = Pevrpc;
  Tevrpc_pause_list = Pevrpc_hook_ctx;
  TEVRPC_HOOK_RESULT = (EVRPC_TERMINATE = -1, EVRPC_CONTINUE = 0,
    EVRPC_PAUSE = 1);

  Tevrpc_hook_ctx = record
    next: Pevrpc_hook_ctx;
    ctx: Pointer;
    cb: function(void: Pointer; HOOK_RESULT: TEVRPC_HOOK_RESULT): Pointer;
  end;

  Pevrpc_hook = ^Tevrpc_hook;
  Tevrpc_hook_list = Pevrpc_hook;

  Tevrpc_hook = record
    next: Pevrpc_hook;
    process: function(void1: Pointer; request: Tevhttp_request;
      buffer: Tevbuffer; void2: Pointer): Integer;
    process_arg: Pointer;
  end;

  T_evrpc_hooks = record
    in_hooks: Tevrpc_hook_list;
    out_hooks: Tevrpc_hook_list;
    pause_requests: Tevrpc_pause_list;
  end;

  Tevrpc_base = record
    common: T_evrpc_hooks;
    http_server: Tevhttp;
    registered_rpcs: Tevrpc_list;
  end;

  Tevrpc = record
    next: Pevrpc;
    uri: PChar;
    request_new: function(): Pointer;
    request_new_arg: Pointer;
    request_free: function(): Pointer;
    request_unmarshal: function(void: Pointer; buffer: Tevbuffer): Integer;
    reply_new: function(): Pointer;
    reply_new_arg: Pointer;
    reply_free: function(): Pointer;
    reply_complete: function(): Integer;
    reply_marshal: function(buffer: Tevbuffer; void: Pointer): Pointer;
    cb: function(req_generic: Pevrpc_req_generic; void: Pointer): Pointer;
    cb_arg: Pointer;
    base: Tevrpc_base;
  end;

  Tevrpc_req_generic = record
    hook_meta: Tevrpc_hook_meta;
    request: Pointer;
    reply: Pointer;
    rpc: Tevrpc;
    http_req: Tevhttp_request;
    rpc_data: Tevbuffer;
  end;

  Pevbuffer_cb_entry = ^Tevbuffer_cb_entry;
  Tevbuffer_cb_func = function(buffer: Tevbuffer; var info: Tevbuffer_cb_info;
    arg: Pointer): Pointer;
  Tevbuffer_cb = function(buffer: Tevbuffer; old_len, new_len: Integer;
    arg: Pointer): Pointer;

  Tevbuffer_cb_entry_cb = packed record
    cb_func: Tevbuffer_cb_func;
    cb_obsolete: Tevbuffer_cb;
  end;

  Tevbuffer_cb_entry = record
    next: Pevbuffer_cb_entry;
    cb: Tevbuffer_cb_entry_cb;
    cbarg: Pointer;
    flags: Tev_uint32_t;
  end;

  Tev_token_bucket_cfg = record
    read_rate: Integer;
    read_maximum: Integer;
    write_rate: Integer;
    write_maximum: Integer;
    tick_timeout: Ttimeval;
    msec_per_tick: Cardinal;
  end;

  Tbufferevent_options = (BEV_OPT_CLOSE_ON_FREE = (1 shl 0),
    BEV_OPT_THREADSAFE = (1 shl 1),
    BEV_OPT_DEFER_CALLBACKS = (1 shl 2), BEV_OPT_UNLOCK_CALLBACKS = (1 shl 3));
  Tbufferevent_suspend_flags = Tev_uint16_t;
  Pbufferevent_rate_limit_group = ^Tbufferevent_rate_limit_group;
  Pbufferevent_private = ^Tbufferevent_private;

  Tev_token_bucket = record
    read_limit: Tev_ssize_t;
    write_limit: Tev_ssize_t;
    last_updated: Tev_uint32_t;
  end;

  Tbufferevent_rate_limit = record
    next_in_group: Pbufferevent_private;
    group: Pbufferevent_rate_limit_group;
    limit: Tev_token_bucket;
    cfg: Tev_token_bucket_cfg;
    refill_bucket_event: Tevent;
  end;

  Tbufferevent_private = record
    bev: Tbufferevent;
    read_watermarks_cb: Tevbuffer_cb_entry;
    own_lock: Cardinal;
    readcb_pending: Cardinal;
    writecb_pending: Cardinal;
    connecting: Cardinal;
    connection_refused: Cardinal;
    eventcb_pending: ShortInt;
    read_suspended: Tbufferevent_suspend_flags;
    write_suspended: Tbufferevent_suspend_flags;
    errno_pending: Integer;
    dns_error: Integer;
    deferred: Tdeferred_cb;
    options: Tbufferevent_options;
    refcnt: Integer;
    lock: Pointer;
    rate_limiting: Tbufferevent_rate_limit;
  end;

  Trlim_group_member_list = Tbufferevent_private;

  Tbufferevent_rate_limit_group = record
    members: Trlim_group_member_list;
    rate_limit: Tev_token_bucket;
    rate_limit_cfg: Tev_token_bucket_cfg;
    read_suspended: Cardinal;
    write_suspended: Cardinal;
    pending_unsuspend_read: Cardinal;
    pending_unsuspend_write: Cardinal;
    total_read: Tev_uint64_t;
    total_written: Tev_uint64_t;
    n_members: Int64;
    min_share: Tev_ssize_t;
    configured_min_share: Tev_ssize_t;
    master_refill_event: Tevent;
    lock: Pointer;
  end;

  Pevent_config_entry = ^Tevent_config_entry;
  Tevent_configq = Pevent_config_entry;

  Tevent_config_entry = record
    next: Pevent_config_entry;
    avoid_method: PChar;
  end;

  Tevent_config = record
    entries: Tevent_configq;
    n_cpus_hint: Integer;
    require_features: Tevent_method_feature;
    flags: Tevent_base_config_flag;
  end;

  Tgetaddrinfo_subrequest = record
    r: Tevdns_request;
    cType: Tev_uint32_t;
  end;

  Tevdns_getaddrinfo_cb = function(result: Integer; res: Tevutil_addrinfo;
    arg: Pointer): Pointer;

  Tevdns_getaddrinfo_request = record
    evdns_base: Tevdns_base;
    hints: Tevutil_addrinfo;
    user_cb: Tevdns_getaddrinfo_cb;
    user_data: Pointer;
    port: Tev_uint16_t;
    ipv4_request: Tgetaddrinfo_subrequest;
    ipv6_request: Tgetaddrinfo_subrequest;
    cname_result: PChar;
    pending_result: Tevutil_addrinfo;
    timeout: Tevent;
    pending_error: Integer;
    user_canceled: Cardinal;
    request_done: Cardinal;
  end;

  Pevrpc_request_wrapper = ^Tevrpc_request_wrapper;
  Tevrpc_requestq = Pevrpc_request_wrapper;

  Tevrpc_pool = record
    common: T_evrpc_hooks;
    base: Tevent_base;
    connections: Tevconq;
    timeout: Integer;
    requests: Tevrpc_requestq;
  end;

  Tevrpc_request_wrapper = record
    hook_meta: Tevrpc_hook_meta;
    next: Pevrpc_request_wrapper;
    pool: Tevrpc_pool;
    evcon: Tevhttp_connection;
    req: Tevhttp_request;
    EV_TIMEOUT: Tevent;
    name: PChar;
    cb: function(status: Tevrpc_status; request, reply, arg: Pointer): Pointer;
    cb_arg: Pointer;
    request: Pointer;
    reply: Pointer;
    request_marshal: function(buffer: Tevbuffer; void: Pointer): Pointer;
    reply_clear: function(): Pointer;
    reply_unmarshal: function(void: Pointer; buffer: Tevbuffer): Integer;
  end;

  Ttimezone = record
    tz_minuteswest: Integer;
    tz_dsttime: Integer;
  end;

  Tbufferevent_pair_new_pair = array [0 .. 1] of Tbufferevent;
  Tevbuffer_eol_style = (EVBUFFER_EOL_ANY, EVBUFFER_EOL_CRLF,
    EVBUFFER_EOL_CRLF_STRICT, EVBUFFER_EOL_LF);
  Tevbuffer_ptr_how = (EVBUFFER_PTR_SET, EVBUFFER_PTR_ADD);
  Tbufferevent_filter_result = (BEV_OK = 0, BEV_NEED_MORE = 1, BEV_ERROR = 2);
  Tbufferevent_ssl_state = (BUFFEREVENT_SSL_OPEN = 0,
    BUFFEREVENT_SSL_CONNECTING = 1,
    BUFFEREVENT_SSL_ACCEPTING = 2);
  TEVRPC_HOOK_TYPE = (EVRPC_INPUT, EVRPC_OUTPUT);
  Tevbuffer_ref_cleanup_cb = function(var data: Pointer; datalen: Integer;
    extra: Pointer): Pointer;
  Tbufferevent_filter_cb = function(src, dst: Tevbuffer;
    dst_limit: Tev_ssize_t; mode: Tbufferevent_flush_mode;
    ctx: Pointer): Tbufferevent_filter_result;
  Tbufferevent_filter_new_free_context = function(): Pointer;
  Tevdns_debug_log_fn_type = function(is_warning: Integer;
    var msg: PChar): Pointer;
  Tevdns_set_transaction_id_fn = function(): Integer;
  Tevdns_set_random_bytes_fn = function(char_: PChar; size: Integer): Pointer;
  Tevent_log_cb = function(severity: Integer; var msg: PChar): Pointer;
  Tevent_fatal_cb = function(err: Integer): Pointer;
  Tevent_callback_fn = function(evutil_socket_t_: Tevutil_socket_t;
    short_: ShortInt; void: Pointer): Pointer;
  Tevent_set_mem_functions_malloc_fn = function(sz: Integer): Pointer;
  Tevent_set_mem_functions_realloc_fn = function(void: Pointer;
    sz: Integer): Pointer;
  Tevent_set_mem_functions_free_fn = function(): Pointer;
  Tevhttp_set_cb = function(req: Tevhttp_request; void: Pointer): Pointer;
  Tevhttp_set_gencb = function(req: Tevhttp_request; void: Pointer): Pointer;
  Tevent_once = function(socket: Tevutil_socket_t; short_: ShortInt;
    void: Pointer): Pointer;
  Tevhttp_request_new_cb = function(EVHTTP_REQUEST: Tevhttp_request;
    void: Pointer): Pointer;
  Tevhttp_connection_set_closecb = function
    (evhttp_connection: Tevhttp_connection; void: Pointer): Pointer;
  Tevrpc_add_hook_cb = function(void: Pointer; req: Tevhttp_request;
    buffer: Tevbuffer; void2: Pointer): Integer;
  Tevthread_set_id_callback = function(): Cardinal;
  Tevrpc_request_set_cb = function(rpc_status: Tevrpc_status;
    request, reply, arg: Pointer): Pointer;
  Tevrpc_make_request_ctx_req_marshal = function(buffer: Tevbuffer;
    void: Pointer): Pointer;
  Tevrpc_make_request_ctx_req_rpl_clear = function(): Pointer;
  Tevrpc_make_request_ctx_req_rpl_unmarshal = function(void: Pointer;
    buffer: Tevbuffer): Pointer;
  Tevrpc_make_request_ctx_req_cb = function(rpc_status: Tevrpc_status;
    void1, void2, void3: Pointer): Pointer;
  Tevrpc_register_rpc = function(rpc_req_generic: Tevrpc_req_generic;
    void: Pointer): Pointer;
  Tevrpc_send_request_generic_cb = function(rpc_status: Tevrpc_status;
    void1, void2, void3: Pointer): Pointer;
  Tevrpc_send_request_generic_req_marshal = function(buffer: Tevbuffer;
    void: Pointer): Pointer;
  Tevrpc_send_request_generic_rpl_clear = function(): Pointer;
  Tevrpc_send_request_generic_rpl_unmarshal = function(void: Pointer;
    buffer: Tevbuffer): Pointer;
  Tevrpc_register_generic_callback = function
    (rpc_req_generic: Tevrpc_req_generic; void: Pointer): Pointer;
  Tevrpc_register_generic_req_new = function(void: Pointer): Pointer;
  Tevrpc_register_generic_req_free = function(void: Pointer): Pointer;
  Tevrpc_register_generic_req_unmarshal = function(void: Pointer;
    buffer: Tevbuffer): Pointer;
  Tevrpc_register_generic_rpl_new = function(void: Pointer): Pointer;
  Tevrpc_register_generic_rpl_free = function(void: Pointer): Pointer;
  Tevrpc_register_generic_rpl_complete = function(void: Pointer): Pointer;
  Tevrpc_register_generic_rpl_marshal = function(buffer: Tevbuffer;
    void: Pointer): Pointer;
  Tevutil_socketpair = array [0 .. 1] of Tevutil_socket_t;

function evbuffer_new(): Tevbuffer; cdecl;
external event_core name 'evbuffer_new';
function evbuffer_free(buf: Tevbuffer): Pointer; cdecl;
external event_core name 'evbuffer_free';
function evbuffer_enable_locking(buf: Tevbuffer; lock: Pointer): Integer;
  cdecl; external event_openssl name 'evbuffer_enable_locking';
function evbuffer_lock(buf: Tevbuffer): Pointer; cdecl;
external event_core name 'evbuffer_lock';
function evbuffer_unlock(buf: Tevbuffer): Pointer; cdecl;
external event_core name 'evbuffer_unlock';
function evbuffer_set_flags(buf: Tevbuffer; flags: Tev_uint64_t): Integer;
  cdecl; external event_core name 'evbuffer_set_flags';
function evbuffer_clear_flags(buf: Tevbuffer; flags: Tev_uint64_t): Integer;
  cdecl; external event_core name 'evbuffer_clear_flags';
function evbuffer_get_length(var buf: Tevbuffer): Integer; cdecl;
external event_core name 'evbuffer_get_length';
function evbuffer_get_contiguous_space(var buf: Tevbuffer): Integer; cdecl;
external event_core name 'evbuffer_get_contiguous_space';
function evbuffer_expand(buf: Tevbuffer; datlen: Integer): Integer; cdecl;
external event_core name 'evbuffer_expand';
function evbuffer_reserve_space(buf: Tevbuffer; size: Tev_ssize_t;
  vec: Tevbuffer_iovec; n_vec: Integer): Integer; cdecl;
external event_core name 'evbuffer_reserve_space';
function evbuffer_commit_space(buf: Tevbuffer; vec: Tevbuffer_iovec;
  n_vec: Integer): Integer; cdecl;
external event_core name 'evbuffer_commit_space';
function evbuffer_add(buf: Tevbuffer; var data: Pointer;
  datlen: Integer): Integer; cdecl; external event_core name 'evbuffer_add';
function evbuffer_remove(buf: Tevbuffer; data: Pointer;
  datlen: Integer): Integer; cdecl; external event_core name 'evbuffer_remove';
function evbuffer_copyout(buf: Tevbuffer; data_out: Pointer;
  datlen: Integer): Tev_ssize_t; cdecl;
external event_core name 'evbuffer_copyout';
function evbuffer_remove_buffer(src, dst: Tevbuffer; datlen: Integer): Integer;
  cdecl; external event_core name 'evbuffer_remove_buffer';
function evbuffer_readln(buf: Tevbuffer; n_read_out: Integer;
  eol_style: Tevbuffer_eol_style): PChar; cdecl;
external event_core name 'evbuffer_readln';
function evbuffer_add_buffer(outbuf: Tevbuffer; inbuf: Tevbuffer): Integer;
  cdecl; external event_core name 'evbuffer_add_buffer';

function evbuffer_add_reference(outbuf: Tevbuffer; var data: Pointer;
  datlendata: Integer; cleanupfn: Tevbuffer_ref_cleanup_cb;
  cleanupfn_arg: Pointer): Integer; cdecl;
external event_core name 'evbuffer_add_reference';
function evbuffer_add_file(outbuf: Tevbuffer; fd: Integer;
  offset, length: Tev_off_t): Integer; cdecl;
external event_core name 'evbuffer_add_reference';
function evbuffer_add_printf(buf: Tevbuffer; var fmt: PChar): Integer; cdecl;
external event_core name 'evbuffer_add_printf';
function evbuffer_add_vprintf(buf: Tevbuffer; var fmt: PChar;
  ap: va_list): Integer; cdecl;
external event_core name 'evbuffer_add_vprintf';
function evbuffer_drain(buf: Tevbuffer; len: Integer): Integer; cdecl;
external event_core name 'evbuffer_new';
function evbuffer_write(buf: Tevbuffer; fd: Tevutil_socket_t): Integer; cdecl;
external event_core name 'evbuffer_drain';
function evbuffer_write_atmost(buf: Tevbuffer; fd: Tevutil_socket_t;
  howmuch: Tev_ssize_t): Integer; cdecl;
external event_core name 'evbuffer_write_atmost';
function evbuffer_read(buf: Tevbuffer; fd: Tevutil_socket_t;
  howmuch: Integer): Integer; cdecl; external event_core name 'evbuffer_read';
function evbuffer_search(buf: Tevbuffer; var what: PChar; len: Integer;
  var start: Tevbuffer_ptr): Tevbuffer_ptr; cdecl;
external event_core name 'evbuffer_search';
function evbuffer_search_range(buf: Tevbuffer; var what: PChar; len: Integer;
  var start: Tevbuffer_ptr; var _end: Tevbuffer_ptr): Tevbuffer_ptr; cdecl;
external event_core name 'evbuffer_search_range';
function evbuffer_ptr_setf(buf: Tevbuffer; ptr: Tevbuffer_ptr;
  position: Integer; how: Tevbuffer_ptr_how): Integer; cdecl;
external event_core name 'evbuffer_ptr_setf';
function evbuffer_search_eol(buf: Tevbuffer; start: Tevbuffer_ptr;
  eol_len_out: Integer; eol_style: Tevbuffer_eol_style): Tevbuffer_ptr; cdecl;
external event_core name 'evbuffer_search_eol';
function evbuffer_peek(buf: Tevbuffer; len: Tev_ssize_t;
  start_at: Tevbuffer_ptr; vec_out: Tevbuffer_iovec;
  n_vec: Integer): Integer; cdecl;
external event_core name 'evbuffer_peek';
function evbuffer_add_cb(buf: Tevbuffer; cb: Tevbuffer_cb_func;
  cbarg: Pointer): Tevbuffer_cb_entry; cdecl;
external event_core name 'evbuffer_add_cb';
function evbuffer_remove_cb_entry(buf: Tevbuffer;
  ent: Tevbuffer_cb_entry): Integer; cdecl;
external event_core name 'evbuffer_remove_cb_entry';
function evbuffer_remove_cb(buf: Tevbuffer; cb: Tevbuffer_cb_func;
  cbarg: Pointer): Integer; cdecl;
external event_core name 'evbuffer_remove_cb';
function evbuffer_cb_set_flags(buf: Tevbuffer; cb: Tevbuffer_cb_entry;
  flags: Tev_uint32_t): Integer; cdecl;
external event_core name 'evbuffer_cb_set_flags';
function evbuffer_cb_clear_flags(buf: Tevbuffer; cb: Tevbuffer_cb_entry;
  flags: Tev_uint32_t): Integer; cdecl;
external event_core name 'evbuffer_cb_clear_flags';
function evbuffer_cb_suspend(buf: Tevbuffer; cb: Tevbuffer_cb_entry): Pointer;
  cdecl; external event_core name 'evbuffer_cb_suspend';
function evbuffer_cb_unsuspend(buf: Tevbuffer; cb: Tevbuffer_cb_entry)
  : Pointer; cdecl; external event_core name 'evbuffer_cb_unsuspend';
function evbuffer_pullup(buf: Tevbuffer; size: Tev_ssize_t): PChar; cdecl;
external event_core name 'evbuffer_pullup';
function evbuffer_prepend(buf: Tevbuffer; var data: Pointer;
  size: Integer): Integer; cdecl; external event_core name 'evbuffer_prepend';
function evbuffer_prepend_buffer(dst, src: Tevbuffer): Integer; cdecl;
external event_core name 'evbuffer_prepend_buffer';
function evbuffer_freeze(buf: Tevbuffer; at_front: Integer): Integer; cdecl;
external event_core name 'evbuffer_freeze';
function evbuffer_unfreeze(buf: Tevbuffer; at_front: Integer): Integer; cdecl;
external event_core name 'evbuffer_unfreeze';
function evbuffer_defer_callbacks(buf: Tevbuffer; base: Tevent_base): Integer;
  cdecl; external event_core name 'evbuffer_defer_callbacks';
function evbuffer_readline(buffer: Tevbuffer): PChar; cdecl;
external event_core name 'evbuffer_readline';
function evbuffer_setcb(buffer: Tevbuffer; cb: Tevbuffer_cb;
  cbarg: Pointer): Pointer; cdecl; external event_core name 'evbuffer_setcb';
function evbuffer_find(buffer: Tevbuffer; var what: PChar;
  len: Integer): PChar; cdecl; external event_core name 'evbuffer_find';
function bufferevent_socket_new(base: Tevent_base; fd: Tevutil_socket_t;
  options: Integer): Tbufferevent; cdecl;
external event_core name 'bufferevent_socket_new';
function bufferevent_socket_connect(bufev: Tbufferevent; sockaddr: Tsockaddr;
  _int: Integer): Integer; cdecl;
external event_core name 'bufferevent_socket_connect';
function bufferevent_socket_connect_hostname(bufev: Tbufferevent;
  base: Tevdns_base; _int: Integer; var char1: PChar; int1: Integer): Integer;
  cdecl; external event_core name 'bufferevent_socket_connect_hostname';
function bufferevent_socket_get_dns_error(bev: Tbufferevent): Integer; cdecl;
external event_core name 'bufferevent_socket_get_dns_error';
function bufferevent_base_set(base: Tevdns_base; bev: Tbufferevent): Integer;
  cdecl; external event_core name 'bufferevent_base_set';
function bufferevent_get_base(bev: Tbufferevent): Tevent_base; cdecl;
external event_core name 'bufferevent_get_base';
function bufferevent_priority_set(bufev: Tbufferevent; pri: Integer): Integer;
  cdecl; external event_core name 'bufferevent_priority_set';
function bufferevent_free(bev: Tbufferevent): Pointer; cdecl;
external event_core name 'bufferevent_free';
function bufferevent_setcb(bufev: Tbufferevent; readcb, writecb,
  eventcb: Tbufferevent_data_cb; cbarg: Pointer): Pointer; cdecl;
external event_core name 'bufferevent_setcb';
function bufferevent_setfd(bufev: Tbufferevent; fd: Tevutil_socket_t): Integer;
  cdecl; external event_core name 'bufferevent_setfd';
function bufferevent_getfd(bufev: Tbufferevent): Tevutil_socket_t; cdecl;
external event_core name 'bufferevent_getfd';
function bufferevent_get_underlying(bufev: Tbufferevent): Tbufferevent; cdecl;
external event_core name 'bufferevent_get_underlying';
function bufferevent_write(bufev: Tbufferevent; var data: Pointer;
  size: Integer): Integer; cdecl;
external event_core name 'bufferevent_write';
function bufferevent_write_buffer(bufev: Tbufferevent;
  buf: Tevbuffer): Integer; cdecl;
external event_core name 'bufferevent_write_buffer';
function bufferevent_read(bufev: Tbufferevent; data: Pointer;
  size: Integer): Integer; cdecl; external event_core name 'bufferevent_read';
function bufferevent_read_buffer(bufev: Tbufferevent; buf: Tevbuffer): Integer;
  cdecl; external event_core name 'bufferevent_read_buffer';
function bufferevent_get_input(bufev: Tbufferevent): Tevbuffer; cdecl;
external event_core name 'bufferevent_get_input';
function bufferevent_get_output(bufev: Tbufferevent): Tevbuffer; cdecl;
external event_core name 'bufferevent_get_output';
function bufferevent_enable(bufev: Tbufferevent; event: ShortInt): Integer;
  cdecl; external event_core name 'bufferevent_enable';
function bufferevent_disable(bufev: Tbufferevent; event: ShortInt): Integer;
  cdecl; external event_core name 'bufferevent_disable';
function bufferevent_get_enabled(bufev: Tbufferevent): SmallInt; cdecl;
external event_core name 'bufferevent_get_enabled';
function bufferevent_set_timeouts(bufev: Tbufferevent;
  var timeout_read: Ttimeval; var timeout_write: Ttimeval): Integer; cdecl;
external event_core name 'bufferevent_set_timeouts';
function bufferevent_setwatermark(bufev: Tbufferevent; events: ShortInt;
  lowmark, highmark: Integer): Pointer; cdecl;
external event_core name 'bufferevent_setwatermark';
function bufferevent_lock(bufev: Tbufferevent): Pointer; cdecl;
external event_core name 'bufferevent_lock';
function bufferevent_unlock(bufev: Tbufferevent): Pointer; cdecl;
external event_core name 'bufferevent_unlock';
function bufferevent_flush(bufev: Tbufferevent; iotype: ShortInt;
  mode: Tbufferevent_flush_mode): Integer; cdecl;
external event_core name 'bufferevent_flush';
function bufferevent_filter_new(underlying: Tbufferevent;
  input_filter, output_filter: Tbufferevent_filter_cb; options: Integer;
  free_context: Tbufferevent_filter_new_free_context;
  ctx: Pointer): Tbufferevent; cdecl;
external event_core name 'bufferevent_filter_new';
function bufferevent_pair_new(base: Tevent_base; options: Integer;
  pair: Tbufferevent_pair_new_pair): Integer; cdecl;
external event_core name 'bufferevent_pair_new';
function bufferevent_pair_get_partner(bufev: Tbufferevent): Tbufferevent;
  cdecl; external event_core name 'bufferevent_pair_get_partner';
function ev_token_bucket_cfg_new(read_rate, read_burst, write_rate,
  write_burst: Integer; var tick_len: Ttimeval): Tev_token_bucket_cfg; cdecl;
external event_core name 'ev_token_bucket_cfg_new';
function ev_token_bucket_cfg_free(cfg: Tev_token_bucket_cfg): Pointer; cdecl;
external event_core name 'ev_token_bucket_cfg_free';
function bufferevent_set_rate_limit(bufev: Tbufferevent;
  cfg: Tev_token_bucket_cfg): Integer; cdecl;
external event_core name 'bufferevent_set_rate_limit';
function bufferevent_rate_limit_group_new(base: Tevent_base;
  var cfg: Tev_token_bucket_cfg): Tbufferevent_rate_limit_group; cdecl;
external event_core name 'bufferevent_rate_limit_group_new';
function bufferevent_rate_limit_group_set_cfg
  (group: Tbufferevent_rate_limit_group; var cfg: Tev_token_bucket_cfg)
  : Integer; cdecl; external event_core name
  'bufferevent_rate_limit_group_set_cfg';
function bufferevent_rate_limit_group_set_min_share
  (group: Tbufferevent_rate_limit_group; size: Integer): Integer; cdecl;
external event_core name 'bufferevent_rate_limit_group_set_min_share';
function bufferevent_rate_limit_group_free(grp: Tbufferevent_rate_limit_group)
  : Pointer; cdecl; external event_core name
  'bufferevent_rate_limit_group_free';
function bufferevent_add_to_rate_limit_group(bev: Tbufferevent;
  group: Tbufferevent_rate_limit_group): Integer; cdecl;
external event_core name 'bufferevent_add_to_rate_limit_group';
function bufferevent_remove_from_rate_limit_group(bev: Tbufferevent): Integer;
  cdecl; external event_core name 'bufferevent_remove_from_rate_limit_group';
function bufferevent_get_read_limit(bev: Tbufferevent): Tev_ssize_t; cdecl;
external event_core name 'bufferevent_get_read_limit';
function bufferevent_get_write_limit(bev: Tbufferevent): Tev_ssize_t; cdecl;
external event_core name 'bufferevent_get_write_limit';
function bufferevent_get_max_to_read(bev: Tbufferevent): Tev_ssize_t; cdecl;
external event_core name 'bufferevent_get_max_to_read';
function bufferevent_get_max_to_write(bev: Tbufferevent): Tev_ssize_t; cdecl;
external event_core name 'bufferevent_get_max_to_write';
function bufferevent_rate_limit_group_get_read_limit
  (grp: Tbufferevent_rate_limit_group): Tev_ssize_t; cdecl;
external event_core name
  'bufferevent_rate_limit_group_get_read_limit';
function bufferevent_rate_limit_group_get_write_limit
  (grp: Tbufferevent_rate_limit_group): Tev_ssize_t; cdecl;
external event_core name
  'bufferevent_rate_limit_group_get_write_limit';
function bufferevent_decrement_read_limit(bev: Tbufferevent;
  decr: Tev_ssize_t): Integer; cdecl;
external event_core name 'bufferevent_decrement_read_limit';
function bufferevent_decrement_write_limit(bev: Tbufferevent;
  decr: Tev_ssize_t): Integer; cdecl;
external event_core name 'bufferevent_decrement_write_limit';
function bufferevent_rate_limit_group_decrement_read
  (group: Tbufferevent_rate_limit_group; size: Tev_ssize_t): Integer; cdecl;
external event_core name 'bufferevent_rate_limit_group_decrement_read';
function bufferevent_rate_limit_group_decrement_write
  (group: Tbufferevent_rate_limit_group; size: Tev_ssize_t): Integer; cdecl;
external event_core name 'bufferevent_rate_limit_group_decrement_write';
function bufferevent_rate_limit_group_get_totals
  (grp: Tbufferevent_rate_limit_group;
  total_read_out, total_written_out: Tev_uint64_t): Pointer; cdecl;
external event_core name 'bufferevent_rate_limit_group_get_totals';
function bufferevent_rate_limit_group_reset_totals
  (grp: Tbufferevent_rate_limit_group): Pointer; cdecl;
external event_core name 'bufferevent_rate_limit_group_reset_totals';
function bufferevent_openssl_filter_new(base: Tevent_base;
  underlying: Tbufferevent; SSL: PSSL; state: Tbufferevent_ssl_state;
  options: Integer): Tbufferevent; cdecl;
external event_openssl name 'bufferevent_openssl_filter_new';
function bufferevent_openssl_socket_new(base: Tevent_base;
  fd: Tevutil_socket_t; SSL: PSSL; state: Tbufferevent_ssl_state;
  options: Integer): Tbufferevent; cdecl;
external event_openssl name 'bufferevent_openssl_socket_new';
function bufferevent_openssl_get_ssl(bufev: Tbufferevent): PSSL; cdecl;
external event_openssl name 'bufferevent_openssl_get_ssl';
function bufferevent_ssl_renegotiate(bufev: Tbufferevent): Integer; cdecl;
external event_openssl name 'bufferevent_ssl_renegotiate';
function bufferevent_get_openssl_error(bufev: Tbufferevent): LongInt; cdecl;
external event_openssl name 'bufferevent_get_openssl_error';
function evdns_base_new(event_base: Tevent_base;
  initialize_nameservers: Integer): Tevdns_base; cdecl;
external event_extra name 'evdns_base_new';
function evdns_base_free(base: Tevdns_base; fail_requests: Integer): Pointer;
  cdecl; external event_extra name 'evdns_base_free';
function evdns_err_to_string(err: Integer): PChar; cdecl;
external event_extra name 'evdns_err_to_string';
function evdns_base_nameserver_add(base: Tevdns_base;
  address: LongInt): Integer; cdecl;
external event_extra name 'evdns_base_nameserver_add';
function evdns_base_count_nameservers(base: Tevdns_base): Integer; cdecl;
external event_extra name 'evdns_base_count_nameservers';
function evdns_base_clear_nameservers_and_suspend(base: Tevdns_base): Integer;
  cdecl; external event_extra name 'evdns_base_clear_nameservers_and_suspend';
function evdns_base_resume(base: Tevdns_base): Integer; cdecl;
external event_extra name 'evdns_base_resume';
function evdns_base_nameserver_ip_add(base: Tevdns_base;
  var ip_as_string: PChar): Integer; cdecl;
external event_extra name 'evdns_base_nameserver_ip_add';
function evdns_base_nameserver_sockaddr_add(base: Tevdns_base;
  var sa: Tsockaddr; len: Tev_socklen_t; flags: Cardinal): Integer;
  cdecl; external event_extra name 'evdns_base_nameserver_sockaddr_add';
function evdns_base_resolve_ipv4(base: Tevdns_base; var name: PChar;
  flags: Integer; callback: Tevdns_callback_type;
  ptr: Pointer): Tevdns_request; cdecl;
external event_extra name 'evdns_base_resolve_ipv4';
function evdns_base_resolve_ipv6(base: Tevdns_base; var name: PChar;
  flags: Integer; callback: Tevdns_callback_type;
  ptr: Pointer): Tevdns_request; cdecl;
external event_extra name 'evdns_base_resolve_ipv6';
function evdns_base_resolve_reverse(base: Tevdns_base; var in_: in_addr;
  flags: Integer; callback: Tevdns_callback_type;
  ptr: Pointer): Tevdns_request; cdecl;
external event_extra name 'evdns_base_resolve_reverse';
function evdns_base_resolve_reverse_ipv6(base: Tevdns_base; var in_: in6_addr;
  flags: Integer; callback: Tevdns_callback_type;
  ptr: Pointer): Tevdns_request; cdecl;
external event_extra name 'evdns_base_resolve_reverse_ipv6';
function evdns_cancel_request(base: Tevdns_base; req: Tevdns_request): Pointer;
  cdecl; external event_extra name 'evdns_cancel_request';
function evdns_base_set_option(base: Tevdns_base; var option: PChar;
  var val: PChar): Integer; cdecl;
external event_extra name 'evdns_base_set_option';
function evdns_base_resolv_conf_parse(base: Tevdns_base; flags: Integer;
  var char_: PChar; var filename: PChar): Integer; cdecl;
external event_extra name 'evdns_base_resolv_conf_parse';
function evdns_base_load_hosts(base: Tevdns_base;
  var hosts_fname: PChar): Integer; cdecl;
external event_extra name 'evdns_base_load_hosts';
function evdns_base_config_windows_nameservers(base: Tevdns_base): Integer;
  cdecl; external event_extra name 'evdns_base_config_windows_nameservers';
function evdns_base_search_clear(base: Tevdns_base): Pointer; cdecl;
external event_extra name 'evdns_base_search_clear';
function evdns_base_search_add(base: Tevdns_base; var domain: PChar): Pointer;
  cdecl; external event_extra name 'evdns_base_search_add';
function evdns_base_search_ndots_set(base: Tevdns_base;
  var ndots: Integer): Pointer; cdecl;
external event_extra name 'evdns_base_search_ndots_set';
function evdns_set_log_fn(fn: Tevdns_debug_log_fn_type): Pointer; cdecl;
external event_extra name 'evdns_set_log_fn';
function evdns_set_transaction_id_fn(fn: Tevdns_set_transaction_id_fn)
  : Pointer; cdecl; external event_extra name 'evdns_set_transaction_id_fn';
function evdns_set_random_bytes_fn(fn: Tevdns_set_random_bytes_fn): Pointer;
  cdecl; external event_extra name 'evdns_set_random_bytes_fn';
function evdns_add_server_port_with_base(base: Tevent_base;
  socket: Tevutil_socket_t; flags: Integer;
  callback: Tevdns_request_callback_fn_type;
  user_data: Pointer): Tevdns_server_port; cdecl;
external event_extra name 'evdns_add_server_port_with_base';
function evdns_close_server_port(port: Tevdns_server_port): Pointer; cdecl;
external event_extra name 'evdns_close_server_port';
function evdns_server_request_set_flags(req: Tevdns_server_request;
  flags: Integer): Pointer; cdecl;
external event_extra name 'evdns_server_request_set_flags';
function evdns_server_request_add_reply(req: Tevdns_server_request;
  section: Integer; var name: PChar; cType, dns_class, ttl, datalen,
  is_name: Integer; var data: PChar): Integer; cdecl;
external event_extra name 'evdns_server_request_add_reply';
function evdns_server_request_add_a_reply(req: Tevdns_server_request;
  var name: PChar; n: Integer; var addrs: Pointer; ttl: Integer): Integer;
  cdecl; external event_extra name 'evdns_server_request_add_a_reply';
function evdns_server_request_add_aaaa_reply(req: Tevdns_server_request;
  var name: PChar; n: Integer; var addrs: Pointer; ttl: Integer): Integer;
  cdecl; external event_extra name 'evdns_server_request_add_aaaa_reply';
function evdns_server_request_add_ptr_reply(req: Tevdns_server_request;
  in_: in_addr; var inaddr_name: PChar; var hostname: PChar;
  ttl: Integer): Integer; cdecl; external event_extra name
  'evdns_server_request_add_ptr_reply';
function evdns_server_request_add_cname_reply(req: Tevdns_server_request;
  var name: PChar; var cname: PChar; ttl: Integer): Integer; cdecl;
external event_extra name 'evdns_server_request_add_cname_reply';
function evdns_server_request_respond(req: Tevdns_server_request;
  err: Integer): Integer; cdecl;
external event_extra name 'evdns_server_request_respond';
function evdns_server_request_drop(req: Tevdns_server_request): Integer; cdecl;
external event_extra name 'evdns_server_request_drop';
function evdns_server_request_get_requesting_addr(req: Tevdns_server_request;
  sa: Tsockaddr; addr_len: Integer): Integer; cdecl;
external event_extra name 'evdns_server_request_get_requesting_addr';
function evdns_getaddrinfo(dns_base: Tevdns_base; var nodename: PChar;
  var servname: PChar; var hints_in: Tevutil_addrinfo;
  cb: Tevdns_getaddrinfo_cb; arg: Pointer): Tevdns_getaddrinfo_request; cdecl;
external event_extra name 'evdns_getaddrinfo';
function evdns_getaddrinfo_cancel(req: Tevdns_getaddrinfo_request): Pointer;
  cdecl; external event_extra name 'evdns_getaddrinfo_cancel';
function evdns_init(): Integer; cdecl; external event_extra name 'evdns_init';
function evdns_get_global_base(): Tevdns_base; cdecl;
external event_extra name 'evdns_get_global_base';
function evdns_shutdown(fail_requests: Integer): Pointer; cdecl;
external event_extra name 'evdns_shutdown';
function evdns_nameserver_add(address: Cardinal): Integer; cdecl;
external event_extra name 'evdns_nameserver_add';
function evdns_count_nameservers(): Integer; cdecl;
external event_extra name 'evdns_count_nameservers';
function evdns_clear_nameservers_and_suspend(): Integer; cdecl;
external event_extra name 'evdns_clear_nameservers_and_suspend';
function evdns_resume(): Integer; cdecl;
external event_extra name 'evdns_resume';
function evdns_nameserver_ip_add(var ip_as_string: PChar): Integer; cdecl;
external event_extra name 'evdns_nameserver_ip_add';
function evdns_resolve_ipv4(var name: PChar; flags: Integer;
  callback: Tevdns_callback_type; ptr: Pointer): Integer; cdecl;
external event_extra name 'evdns_resolve_ipv4';
function evdns_resolve_ipv6(var name: PChar; flags: Integer;
  callback: Tevdns_callback_type; ptr: Pointer): Integer; cdecl;
external event_extra name 'evdns_resolve_ipv6';
function evdns_resolve_reverse(var in_: in_addr; flags: Integer;
  callback: Tevdns_callback_type; ptr: Pointer): Integer; cdecl;
external event_extra name 'evdns_resolve_reverse';
function evdns_resolve_reverse_ipv6(var in_: in6_addr; flags: Integer;
  callback: Tevdns_callback_type; ptr: Pointer): Integer; cdecl;
external event_extra name 'evdns_resolve_reverse_ipv6';
function evdns_set_option(var option: PChar; var val: PChar;
  flags: Integer): Integer; cdecl;
external event_extra name 'evdns_set_option';
function evdns_resolv_conf_parse(flags: Integer; var char_: PChar;
  var filename: PChar): Integer; cdecl;
external event_extra name 'evdns_resolv_conf_parse';
function evdns_search_clear(): Pointer; cdecl;
external event_extra name 'evdns_search_clear';
function evdns_search_add(var domain: PChar): Pointer; cdecl;
external event_extra name 'evdns_search_add';
function evdns_search_ndots_set(var ndots: Integer): Pointer; cdecl;
external event_extra name 'evdns_search_ndots_set';
function evdns_add_server_port(socket: Tevutil_socket_t; flags: Integer;
  callback: Tevdns_request_callback_fn_type;
  user_data: Pointer): Tevdns_server_port; cdecl;
external event_extra name 'evdns_add_server_port';
function evdns_config_windows_nameservers(): Integer; cdecl;
external event_extra name 'evdns_config_windows_nameservers';
function event_enable_debug_mode(): Pointer; cdecl;
external event name 'event_enable_debug_mode';
function event_debug_unassign(event: Tevent): Pointer; cdecl;
external event name 'event_debug_unassign';
function event_base_new(): Tevent_base; cdecl;
external event name 'event_base_new';
function event_reinit(base: Tevent_base): Integer; cdecl;
external event name 'event_reinit';
function event_base_dispatch(base: Tevent_base): Integer; cdecl;
external event name 'event_base_dispatch';
function event_base_get_method(var base: Tevent_base): PChar; cdecl;
external event name 'event_base_get_method';
function event_get_supported_methods(): PChar; cdecl;
external event name 'event_get_supported_methods';
function event_config_new(): Tevent_config; cdecl;
external event name 'event_config_new';
function event_config_free(cfg: Tevent_config): Pointer; cdecl;
external event name 'event_config_free';
function event_config_avoid_method(cfg: Tevent_config;
  var method: PChar): Integer; cdecl;
external event name 'event_config_avoid_method';
function event_base_get_features(var base: Tevent_base): Integer; cdecl;
external event name 'event_base_get_features';
function event_config_require_features(cfg: Tevent_config;
  feature: Integer): Integer; cdecl;
external event name 'event_config_require_features';
function event_config_set_flag(cfg: Tevent_config; flag: Integer): Integer;
  cdecl; external event name 'event_config_set_flag';
function event_config_set_num_cpus_hint(cfg: Tevent_config;
  cpus: Integer): Integer; cdecl;
external event name 'event_config_set_num_cpus_hint';
function event_base_new_with_config(var cfg: Tevent_config): Tevent_base;
  cdecl; external event name 'event_base_new_with_config';
function event_base_free(base: Tevent_base): Pointer; cdecl;
external event name 'event_base_free';
function event_set_log_callback(cb: Tevent_log_cb): Pointer; cdecl;
external event name 'event_set_log_callback';
function event_set_fatal_callback(cb: Tevent_fatal_cb): Pointer; cdecl;
external event name 'event_set_fatal_callback';
function event_base_set(base: Tevent_base; event: Tevent): Integer; cdecl;
external event name 'event_base_set';
function event_base_loop(base: Tevent_base; int_: Integer): Integer; cdecl;
external event name 'event_base_loop';
function event_base_loopexit(base: Tevent_base;
  var timeval: Ttimeval): Integer; cdecl;
external event name 'event_base_loopexit';
function event_base_loopbreak(base: Tevent_base): Integer; cdecl;
external event name 'event_base_loopbreak';
function event_base_got_exit(base: Tevent_base): Integer; cdecl;
external event name 'event_base_got_exit';
function event_base_got_break(base: Tevent_base): Integer; cdecl;
external event name 'event_base_got_break';
function event_new(base: Tevent_base; socket: Tevutil_socket_t;
  SHORT: ShortInt; callback: Tevent_callback_fn; void: Pointer): Tevent;
  cdecl; external event name 'event_new';
function event_assign(event: Tevent; base: Tevent_base;
  socket: Tevutil_socket_t; SHORT: ShortInt;
  callback: Tevent_callback_fn; void: Pointer): Integer; cdecl;
external event name 'event_assign';
function event_free(event: Tevent): Pointer; cdecl;
external event name 'event_free';
function event_base_once(base: Tevent_base; socket: Tevutil_socket_t;
  SHORT: ShortInt; callback: Tevent_callback_fn; void: Pointer;
  var timeval: Ttimeval): Integer; cdecl;
external event name 'event_base_once';
function event_add(ev: Tevent; var timeout: Ttimeval): Integer; cdecl;
external event name 'event_add';
function event_del(event: Tevent): Integer; cdecl;
external event name 'event_del';
function event_active(ev: Tevent; res: Integer; ncalls: ShortInt): Pointer;
  cdecl; external event name 'event_active';
function event_pending(var ev: Tevent; events: ShortInt;
  tv: Ttimeval): Integer; cdecl; external event name 'event_pending';
function event_initialized(var ev: Tevent): Integer; cdecl;
external event name 'event_initialized';
function event_get_fd(var ev: Tevent): Tevutil_socket_t; cdecl;
external event name 'event_get_fd';
function event_get_base(var ev: Tevent): Tevent_base; cdecl;
external event name 'event_get_base';
function event_get_events(var ev: Tevent): ShortInt; cdecl;
external event name 'event_get_events';
function event_get_callback(var ev: Tevent): Tevent_callback_fn; cdecl;
external event name 'event_get_callback';
function event_get_callback_arg(var ev: Tevent): Pointer; cdecl;
external event name 'event_get_callback_arg';
function event_get_assignment(var ev: Tevent; base_out: Tevent_base;
  fd_out: Tevutil_socket_t; events_out: ShortInt;
  callback_out: Tevent_callback_fn; arg_out: Pointer): Pointer; cdecl;
external event name 'event_get_assignment';
function event_get_struct_event_size(): Integer; cdecl;
external event name 'event_get_struct_event_size';
function event_get_version(): PChar; cdecl;
external event name 'event_get_version';
function event_get_version_number(): Tev_uint32_t; cdecl;
external event name 'event_get_version_number';
function event_base_priority_init(base: Tevent_base; int_: Integer): Integer;
  cdecl; external event name 'event_base_priority_init';
function event_priority_set(ev: Tevent; int_: Integer): Integer; cdecl;
external event name 'event_priority_set';
function event_base_init_common_timeout(base: Tevent_base;
  var duration: Ttimeval): Ttimeval; cdecl;
external event name 'event_base_init_common_timeout';
function event_set_mem_functions(malloc_fn: Tevent_set_mem_functions_malloc_fn;
  realloc_fn: Tevent_set_mem_functions_realloc_fn;
  free_fn: Tevent_set_mem_functions_free_fn): Pointer; cdecl;
external event name 'event_set_mem_functions';
function event_base_dump_events(base: Tevent_base; var cFile: file): Pointer;
  cdecl; external event name 'event_base_dump_events';
function event_base_gettimeofday_cached(base: Tevent_base;
  tv: Ttimeval): Integer; cdecl;
external event name 'event_base_gettimeofday_cached';
function event_init(): Tevent_base; cdecl; external event name 'event_init';
function event_dispatch(): Integer; cdecl; external event name 'event_dispatch';
function event_loop(): Integer; cdecl; external event name 'event_loop';
function event_loopexit(var timeval: Ttimeval): Integer; cdecl;
external event name 'event_loopexit';
function event_loopbreak(): Integer; cdecl;
external event name 'event_loopbreak';
function event_once(socket: Tevutil_socket_t; short_: ShortInt;
  once: Tevent_once; void: Pointer; var timeval: Ttimeval): Integer; cdecl;
external event name 'event_once';
function event_get_method(): PChar; cdecl;
external event name 'event_get_method';
function event_priority_init(): Integer; cdecl;
external event name 'event_priority_init';
function event_set(ev: Tevent; socket: Tevutil_socket_t; short_: ShortInt;
  once: Tevent_once; void: Pointer): Pointer; cdecl;
external event name 'event_set';
function evhttp_new(base: Tevent_base): Tevhttp; cdecl;
external event_extra name 'evhttp_new';
function evhttp_bind_socket(http: Tevhttp; var address: PChar;
  port: Tev_uint16_t): Integer; cdecl;
external event_extra name 'evhttp_bind_socket';
function evhttp_bind_socket_with_handle(http: Tevhttp; var address: PChar;
  port: Tev_uint16_t): Tevhttp_bound_socket; cdecl;
external event_extra name 'evhttp_bind_socket_with_handle';
function evhttp_accept_socket(http: Tevhttp; fd: Tevutil_socket_t): Integer;
  cdecl; external event_extra name 'evhttp_accept_socket';
function evhttp_accept_socket_with_handle(http: Tevhttp; fd: Tevutil_socket_t)
  : Tevhttp_bound_socket; cdecl; external event_extra name
  'evhttp_accept_socket_with_handle';
function evhttp_bind_listener(http: Tevhttp; listener: Tevconnlistener)
  : Tevhttp_bound_socket; cdecl;
external event_extra name 'evhttp_bind_listener';
function evhttp_bound_socket_get_listener(bound: Tevhttp_bound_socket)
  : Tevconnlistener; cdecl; external event_extra name
  'evhttp_bound_socket_get_listener';
function evhttp_del_accept_socket(http: Tevhttp;
  bound_socket: Tevhttp_bound_socket): Pointer; cdecl;
external event_extra name 'evhttp_del_accept_socket';
function evhttp_bound_socket_get_fd(bound_socket: Tevhttp_bound_socket)
  : Tevutil_socket_t; cdecl;
external event_extra name 'evhttp_bound_socket_get_fd';
function evhttp_free(http: Tevhttp): Pointer; cdecl;
external event_extra name 'evhttp_free';
function evhttp_set_max_headers_size(http: Tevhttp;
  max_headers_size: Tev_ssize_t): Pointer; cdecl;
external event_extra name 'evhttp_set_max_headers_size';
function evhttp_set_max_body_size(http: Tevhttp;
  max_body_size: Tev_ssize_t): Pointer; cdecl;
external event_extra name 'evhttp_set_max_body_size';
function evhttp_set_allowed_methods(http: Tevhttp;
  methods: Tev_uint16_t): Pointer; cdecl;
external event_extra name 'evhttp_set_allowed_methods';
function evhttp_set_cb(http: Tevhttp; var path: PChar; cb: Tevhttp_set_cb;
  cb_arg: Pointer): Integer; cdecl; external event_extra name 'evhttp_set_cb';
function evhttp_del_cb(http: Tevhttp; var char_: PChar): Integer; cdecl;
external event_extra name 'evhttp_del_cb';
function evhttp_set_gencb(http: Tevhttp; cb: Tevhttp_set_gencb;
  arg: Pointer): Pointer; cdecl; external event_extra name 'evhttp_set_gencb';
function evhttp_add_virtual_host(http: Tevhttp; var pattern: PChar;
  vhost: Tevhttp): Integer; cdecl;
external event_extra name 'evhttp_add_virtual_host';
function evhttp_remove_virtual_host(http, vhost: Tevhttp): Integer; cdecl;
external event_extra name 'evhttp_remove_virtual_host';
function evhttp_add_server_alias(http: Tevhttp; var alias: PChar): Integer;
  cdecl; external event_extra name 'evhttp_add_server_alias';
function evhttp_remove_server_alias(http: Tevhttp; var alias: PChar): Integer;
  cdecl; external event_extra name 'evhttp_remove_server_alias';
function evhttp_set_timeout(http: Tevhttp; timeout_in_secs: Integer): Pointer;
  cdecl; external event_extra name 'evhttp_set_timeout';
function evhttp_send_error(req: Tevhttp_request; error: Integer;
  var reason: PChar): Pointer; cdecl;
external event_extra name 'evhttp_send_error';
function evhttp_send_reply(req: Tevhttp_request; code: Integer;
  var reason: PChar; databuf: Tevbuffer): Pointer; cdecl;
external event_extra name 'evhttp_send_reply';
function evhttp_send_reply_start(req: Tevhttp_request; code: Integer;
  var reason: PChar): Pointer; cdecl;
external event_extra name 'evhttp_send_reply_start';
function evhttp_send_reply_chunk(req: Tevhttp_request;
  databuf: Tevbuffer): Pointer; cdecl;
external event_extra name 'evhttp_send_reply_chunk';
function evhttp_send_reply_end(req: Tevhttp_request): Pointer; cdecl;
external event_extra name 'evhttp_send_reply_end';
function evhttp_request_new(cb: Tevhttp_request_new_cb;
  arg: Pointer): Tevhttp_request; cdecl;
external event_extra name 'evhttp_request_new';
function evhttp_request_set_chunked_cb(req: Tevhttp_request;
  cb: Tevhttp_request_new_cb): Pointer; cdecl;
external event_extra name 'evhttp_request_set_chunked_cb';
function evhttp_request_free(req: Tevhttp_request): Pointer; cdecl;
external event_extra name 'evhttp_request_free';
function evhttp_connection_base_new(base: Tevent_base; dnsbase: Tevdns_base;
  var address: PChar; port: ShortInt): Tevhttp_connection; cdecl;
external event_extra name 'evhttp_connection_base_new';
function evhttp_request_own(req: Tevhttp_request): Pointer; cdecl;
external event_extra name 'evhttp_request_own';
function evhttp_request_is_owned(req: Tevhttp_request): Integer; cdecl;
external event_extra name 'evhttp_request_is_owned';
function evhttp_request_get_connection(req: Tevhttp_request)
  : Tevhttp_connection; cdecl;
external event_extra name 'evhttp_request_get_connection';
function evhttp_connection_get_base(req: Tevhttp_connection): Tevent_base;
  cdecl; external event_extra name 'evhttp_connection_get_base';
function evhttp_connection_set_max_headers_size(evcon: Tevhttp_connection;
  new_max_headers_size: Tev_ssize_t): Pointer; cdecl;
external event_extra name 'evhttp_connection_set_max_headers_size';
function evhttp_connection_set_max_body_size(evcon: Tevhttp_connection;
  new_max_body_size: Tev_ssize_t): Pointer; cdecl;
external event_extra name 'evhttp_connection_set_max_body_size';
function evhttp_connection_free(evcon: Tevhttp_connection): Pointer; cdecl;
external event_extra name 'evhttp_connection_free';
function evhttp_connection_set_local_address(evcon: Tevhttp_connection;
  var address: PChar): Pointer; cdecl;
external event_extra name 'evhttp_connection_set_local_address';
function evhttp_connection_set_local_port(evcon: Tevhttp_connection;
  port: Tev_uint16_t): Pointer; cdecl;
external event_extra name 'evhttp_connection_set_local_port';
function evhttp_connection_set_timeout(evcon: Tevhttp_connection;
  timeout_in_secs: Integer): Pointer; cdecl;
external event_extra name 'evhttp_connection_set_timeout';
function evhttp_connection_set_retries(evcon: Tevhttp_connection;
  retry_max: Integer): Pointer; cdecl;
external event_extra name 'evhttp_connection_set_retries';
function evhttp_connection_set_closecb(evcon: Tevhttp_connection;
  cb: Tevhttp_connection_set_closecb; void: Pointer): Pointer; cdecl;
external event_extra name 'evhttp_connection_set_closecb';
function evhttp_connection_get_peer(evcon: Tevhttp_connection; address: PChar;
  port: Tev_uint16_t): Pointer; cdecl;
external event_extra name 'evhttp_connection_get_peer';
function evhttp_make_request(evcon: Tevhttp_connection; req: Tevhttp_request;
  cType: Tevhttp_cmd_type; var uri: PChar): Integer; cdecl;
external event_extra name 'evhttp_make_request';
function evhttp_cancel_request(req: Tevhttp_request): Pointer; cdecl;
external event_extra name 'evhttp_cancel_request';
function evhttp_request_get_uri(var req: Tevhttp_request): PChar; cdecl;
external event_extra name 'evhttp_request_get_uri';
function evhttp_request_get_evhttp_uri(var req: Tevhttp_request): Tevhttp_uri;
  cdecl; external event_extra name 'evhttp_request_get_evhttp_uri';
function evhttp_request_get_command(var req: Tevhttp_request)
  : Tevhttp_cmd_type; cdecl;
external event_extra name 'evhttp_request_get_command';
function evhttp_request_get_response_code(var req: Tevhttp_request): Integer;
  cdecl; external event_extra name 'evhttp_request_get_response_code';
function evhttp_request_get_input_headers(req: Tevhttp_request): Tevkeyvalq;
  cdecl; external event_extra name 'evhttp_request_get_input_headers';
function evhttp_request_get_output_headers(req: Tevhttp_request): Tevkeyvalq;
  cdecl; external event_extra name 'evhttp_request_get_output_headers';
function evhttp_request_get_input_buffer(req: Tevhttp_request): Tevbuffer;
  cdecl; external event_extra name 'evhttp_request_get_input_buffer';
function evhttp_request_get_output_buffer(req: Tevhttp_request): Tevbuffer;
  cdecl; external event_extra name 'evhttp_request_get_output_buffer';
function evhttp_request_get_host(req: Tevhttp_request): PChar; cdecl;
external event_extra name 'evhttp_request_get_host';
function evhttp_find_header(var headers: Tevkeyvalq; var key: PChar): PChar;
  cdecl; external event_extra name 'evhttp_find_header';
function evhttp_remove_header(headers: Tevkeyvalq; var key: PChar): Integer;
  cdecl; external event_extra name 'evhttp_remove_header';
function evhttp_add_header(headers: Tevkeyvalq; var key: PChar;
  var value: PChar): Integer; cdecl;
external event_extra name 'evhttp_add_header';
function evhttp_clear_headers(headers: Tevkeyvalq): Pointer; cdecl;
external event_extra name 'evhttp_clear_headers';
function evhttp_encode_uri(var str: PChar): PChar; cdecl;
external event_extra name 'evhttp_encode_uri';
function evhttp_uriencode(var str: PChar; size: Tev_ssize_t;
  space_to_plus: Integer): PChar; cdecl;
external event_extra name 'evhttp_uriencode';
function evhttp_decode_uri(var uri: PChar): PChar; cdecl;
external event_extra name 'evhttp_decode_uri';
function evhttp_uridecode(var uri: PChar;
  decode_plus, size_out: Integer): PChar; cdecl;
external event_extra name 'evhttp_uridecode';
function evhttp_parse_query(var uri: PChar; headers: Tevkeyvalq): Integer;
  cdecl; external event_extra name 'evhttp_parse_query';
function evhttp_parse_query_str(var uri: PChar; headers: Tevkeyvalq): Integer;
  cdecl; external event_extra name 'evhttp_parse_query_str';
function evhttp_htmlescape(var html: PChar): PChar; cdecl;
external event_extra name 'evhttp_htmlescape';
function evhttp_uri_new(): Tevhttp_uri; cdecl;
external event_extra name 'evhttp_uri_new';
function evhttp_uri_set_flags(uri: Tevhttp_uri; flags: Cardinal): Pointer;
  cdecl; external event_extra name 'evhttp_uri_set_flags';
function evhttp_uri_get_scheme(var uri: Tevhttp_uri): PChar; cdecl;
external event_extra name 'evhttp_uri_get_scheme';
function evhttp_uri_get_userinfo(var uri: Tevhttp_uri): PChar; cdecl;
external event_extra name 'evhttp_uri_get_userinfo';
function evhttp_uri_get_host(var uri: Tevhttp_uri): PChar; cdecl;
external event_extra name 'evhttp_uri_get_host';
function evhttp_uri_get_port(var uri: Tevhttp_uri): Integer; cdecl;
external event_extra name 'evhttp_uri_get_port';
function evhttp_uri_get_path(var uri: Tevhttp_uri): PChar; cdecl;
external event_extra name 'evhttp_uri_get_path';
function evhttp_uri_get_query(var uri: Tevhttp_uri): PChar; cdecl;
external event_extra name 'evhttp_uri_get_query';
function evhttp_uri_get_fragment(var uri: Tevhttp_uri): PChar; cdecl;
external event_extra name 'evhttp_uri_get_fragment';
function evhttp_uri_set_scheme(uri: Tevhttp_uri; var scheme: PChar): Integer;
  cdecl; external event_extra name 'evhttp_uri_set_scheme';
function evhttp_uri_set_userinfo(uri: Tevhttp_uri;
  var userinfo: PChar): Integer; cdecl;
external event_extra name 'evhttp_uri_set_userinfo';
function evhttp_uri_set_host(uri: Tevhttp_uri; var host: PChar): Integer;
  cdecl; external event_extra name 'evhttp_uri_set_host';
function evhttp_uri_set_port(uri: Tevhttp_uri; port: Integer): Integer; cdecl;
external event_extra name 'evhttp_uri_set_port';
function evhttp_uri_set_path(uri: Tevhttp_uri; var path: PChar): Integer;
  cdecl; external event_extra name 'evhttp_uri_set_path';
function evhttp_uri_set_query(uri: Tevhttp_uri; var query: PChar): Integer;
  cdecl; external event_extra name 'evhttp_uri_set_query';
function evhttp_uri_set_fragment(uri: Tevhttp_uri;
  var fragment: PChar): Integer; cdecl;
external event_extra name 'evhttp_uri_set_fragment';
function evhttp_uri_parse_with_flags(var source_uri: PChar;
  flags: Cardinal): Tevhttp_uri; cdecl;
external event_extra name 'evhttp_uri_parse_with_flags';
function evhttp_uri_parse(var source_uri: PChar): Tevhttp_uri; cdecl;
external event_extra name 'evhttp_uri_parse';
function evhttp_uri_free(uri: Tevhttp_uri): Pointer; cdecl;
external event_extra name 'evhttp_uri_free';
function evhttp_uri_join(uri: Tevhttp_uri; buf: PChar; limit: Integer): PChar;
  cdecl; external event_extra name 'evhttp_uri_join';
function evhttp_start(var address: PChar; port: ShortInt): Tevhttp; cdecl;
external event_extra name 'evhttp_start';
function evhttp_connection_new(var address: PChar;
  port: ShortInt): Tevhttp_connection; cdecl;
external event_extra name 'evhttp_connection_new';
function evhttp_connection_set_base(evcon: Tevhttp_connection;
  base: Tevent_base): Pointer; cdecl;
external event_extra name 'evhttp_connection_set_base';
function evconnlistener_new(base: Tevent_base; cb: Tevconnlistener_cb;
  ptr: Pointer; flags: Cardinal; backlog: Integer; fd: Tevutil_socket_t)
  : Tevconnlistener; cdecl; external event name 'evconnlistener_new';
function evconnlistener_new_bind(base: Tevent_base; cb: Tevconnlistener_cb;
  ptr: Pointer; flags: Cardinal; backlog: Integer; var sa: Tsockaddr;
  socklen: Integer): Tevconnlistener; cdecl;
external event name 'evconnlistener_new_bind';
function evconnlistener_free(lev: Tevconnlistener): Pointer; cdecl;
external event name 'evconnlistener_free';
function evconnlistener_enable(lev: Tevconnlistener): Integer; cdecl;
external event name 'evconnlistener_enable';
function evconnlistener_disable(lev: Tevconnlistener): Integer; cdecl;
external event name 'evconnlistener_disable';
function evconnlistener_get_base(lev: Tevconnlistener): Tevent_base; cdecl;
external event name 'evconnlistener_get_base';
function evconnlistener_get_fd(lev: Tevconnlistener): Tevutil_socket_t; cdecl;
external event name 'evconnlistener_get_fd';
function evconnlistener_set_cb(lev: Tevconnlistener; cb: Tevconnlistener_cb;
  arg: Pointer): Pointer; cdecl; external event name 'evconnlistener_set_cb';
function evconnlistener_set_error_cb(lev: Tevconnlistener;
  errorcb: Tevconnlistener_errorcb): Pointer; cdecl;
external event name 'evconnlistener_set_error_cb';
function evrpc_make_request_ctx(pool: Tevrpc_pool; request, reply: Pointer;
  var rpcname: PChar; req_marshal: Tevrpc_make_request_ctx_req_marshal;
  rpl_clear: Tevrpc_make_request_ctx_req_rpl_clear;
  rpl_unmarshal: Tevrpc_make_request_ctx_req_rpl_unmarshal;
  cb: Tevrpc_make_request_ctx_req_cb; cbarg: Pointer): Tevrpc_request_wrapper;
  cdecl; external event_extra name 'evrpc_make_request_ctx';
function evrpc_request_done(req: Tevrpc_req_generic): Pointer; cdecl;
external event_extra name 'evrpc_request_done';
function evrpc_get_request(req: Tevrpc_req_generic): Pointer; cdecl;
external event_extra name 'evrpc_get_request';
function evrpc_get_reply(req: Tevrpc_req_generic): Pointer; cdecl;
external event_extra name 'evrpc_get_reply';
function evrpc_init(server: Tevhttp): Tevrpc_base; cdecl;
external event_extra name 'evrpc_init';
function evrpc_free(base: Tevrpc_base): Pointer; cdecl;
external event_extra name 'evrpc_free';
function evrpc_register_rpc(base: Tevrpc_base; rpc: Tevrpc;
  register_rpc: Tevrpc_register_rpc; void: Pointer): Integer; cdecl;
external event_extra name 'evrpc_register_rpc';
function evrpc_unregister_rpc(base: Tevrpc_base; var name: PChar): Integer;
  cdecl; external event_extra name 'evrpc_unregister_rpc';
function evrpc_make_request(ctx: Tevrpc_request_wrapper): Integer; cdecl;
external event_extra name 'evrpc_make_request';
function evrpc_pool_new(base: Tevent_base): Tevrpc_pool; cdecl;
external event_extra name 'evrpc_pool_new';
function evrpc_pool_free(pool: Tevrpc_pool): Pointer; cdecl;
external event_extra name 'evrpc_pool_free';
function evrpc_pool_add_connection(pool: Tevrpc_pool;
  evcon: Tevhttp_connection): Pointer; cdecl;
external event_extra name 'evrpc_pool_add_connection';
function evrpc_pool_remove_connection(pool: Tevrpc_pool;
  evcon: Tevhttp_connection): Pointer; cdecl;
external event_extra name 'evrpc_pool_remove_connection';
function evrpc_pool_set_timeout(pool: Tevrpc_pool;
  timeout_in_secs: Integer): Pointer; cdecl;
external event_extra name 'evrpc_pool_set_timeout';
function evrpc_add_hook(vbase: Integer; hook_type: TEVRPC_HOOK_TYPE;
  cb: Tevrpc_add_hook_cb; cb_arg: Pointer): Pointer; cdecl;
external event_extra name 'evrpc_add_hook';
function evrpc_remove_hook(vbase: Integer; hook_type: TEVRPC_HOOK_TYPE;
  HANDLE: Pointer): Integer; cdecl;
external event_extra name 'evrpc_remove_hook';
function evrpc_resume_request(vbase, ctx: Pointer;
  res: TEVRPC_HOOK_RESULT): Integer; cdecl;
external event_extra name 'evrpc_resume_request';
function evrpc_hook_add_meta(ctx: Pointer; var key: PChar; var data: Pointer;
  data_size: Integer): Pointer; cdecl;
external event_extra name 'evrpc_hook_add_meta';
function evrpc_hook_find_meta(ctx: Pointer; var key: PChar; data: Pointer;
  data_size: Integer): Integer; cdecl;
external event_extra name 'evrpc_hook_find_meta';
function evrpc_hook_get_connection(ctx: Pointer): Tevhttp_connection; cdecl;
external event_extra name 'evrpc_hook_get_connection';
function evrpc_send_request_generic(pool: Tevrpc_pool; request, reply: Pointer;
  cb: Tevrpc_send_request_generic_cb; cb_arg: Pointer; var rpcname: PChar;
  req_marshal: Tevrpc_send_request_generic_req_marshal;
  rpl_clear: Tevrpc_send_request_generic_rpl_clear;
  rpl_unmarshal: Tevrpc_send_request_generic_rpl_unmarshal): Integer; cdecl;
external event_extra name 'evrpc_send_request_generic';
function evrpc_register_generic(base: Tevrpc_base; var name: PChar;
  callback: Tevrpc_register_generic_callback; cbarg: Pointer;
  req_new: Tevrpc_register_generic_req_new; req_new_arg: Pointer;
  req_free: Tevrpc_register_generic_req_free;
  req_unmarshal: Tevrpc_register_generic_req_unmarshal;
  rpl_new: Tevrpc_register_generic_rpl_new; rpl_new_arg: Pointer;
  rpl_free: Tevrpc_register_generic_rpl_free;
  rpl_complete: Tevrpc_register_generic_rpl_complete;
  rpl_marshal: Tevrpc_register_generic_rpl_marshal): Integer; cdecl;
external event_extra name 'evrpc_register_generic';
function evrpc_request_get_pool(): Tevrpc_pool; cdecl;
external event_extra name 'evrpc_request_get_pool';
function evrpc_request_set_pool(ctx: Tevrpc_request_wrapper;
  pool: Tevrpc_pool): Pointer; cdecl;
external event_extra name 'evrpc_request_set_pool';
function evrpc_request_set_cb(ctx: Tevrpc_request_wrapper;
  cb: Tevrpc_request_set_cb; cb_arg: Pointer): Pointer; cdecl;
external event_extra name 'evrpc_request_set_cb';
function evtag_init(): Pointer; cdecl; external event_extra name 'evtag_init';
function evtag_unmarshal_header(evbuf: Tevbuffer; ptag: Tev_uint32_t): Integer;
  cdecl; external event_extra name 'evtag_unmarshal_header';
function evtag_marshal(evbuf: Tevbuffer; tag: Tev_uint32_t; var data: Pointer;
  len: Tev_uint32_t): Pointer; cdecl; external event_extra name 'evtag_marshal';
function evtag_marshal_buffer(evbuf: Tevbuffer; tag: Tev_uint32_t;
  data: Tevbuffer): Pointer; cdecl;
external event_extra name 'evtag_marshal_buffer';
function evtag_encode_int(evbuf: Tevbuffer; number: Tev_uint32_t): Pointer;
  cdecl; external event_extra name 'evtag_encode_int';
function evtag_encode_int64(evbuf: Tevbuffer; number: Tev_uint64_t): Pointer;
  cdecl; external event_extra name 'evtag_encode_int64';
function evtag_marshal_int(evbuf: Tevbuffer; tag: Tev_uint32_t;
  integer_: Tev_uint32_t): Pointer; cdecl;
external event_extra name 'evtag_marshal_int';
function evtag_marshal_int64(evbuf: Tevbuffer; tag: Tev_uint32_t;
  integer_: Tev_uint64_t): Pointer; cdecl;
external event_extra name 'evtag_marshal_int64';
function evtag_marshal_string(evbuf: Tevbuffer; tag: Tev_uint32_t;
  var cString: PChar): Pointer; cdecl;
external event_extra name 'evtag_marshal_string';
function evtag_marshal_timeval(evbuf: Tevbuffer; tag: Tev_uint32_t;
  tv: Ttimeval): Pointer; cdecl;
external event_extra name 'evtag_marshal_timeval';
function evtag_unmarshal(src: Tevbuffer; ptag: Tev_uint32_t;
  dst: Tevbuffer): Integer; cdecl; external event_extra name 'evtag_unmarshal';
function evtag_peek(evbuf: Tevbuffer; ptag: Tev_uint32_t): Integer; cdecl;
external event_extra name 'evtag_peek';
function evtag_peek_length(evbuf: Tevbuffer; plength: Tev_uint32_t): Integer;
  cdecl; external event_extra name 'evtag_peek_length';
function evtag_payload_length(evbuf: Tevbuffer;
  plength: Tev_uint32_t): Integer; cdecl;
external event_extra name 'evtag_payload_length';
function evtag_consume(evbuf: Tevbuffer): Integer; cdecl;
external event_extra name 'evtag_consume';
function evtag_unmarshal_int(evbuf: Tevbuffer;
  need_tag, pinteger: Tev_uint32_t): Integer; cdecl;
external event_extra name 'evtag_unmarshal_int';
function evtag_unmarshal_int64(evbuf: Tevbuffer; need_tag: Tev_uint32_t;
  pinteger: Tev_uint64_t): Integer; cdecl;
external event_extra name 'evtag_unmarshal_int64';
function evtag_unmarshal_fixed(src: Tevbuffer; need_tag: Tev_uint32_t;
  data: Pointer; len: Integer): Integer; cdecl;
external event_extra name 'evtag_unmarshal_fixed';
function evtag_unmarshal_string(evbuf: Tevbuffer; need_tag: Tev_uint32_t;
  pstring: PChar): Integer; cdecl;
external event_extra name 'evtag_unmarshal_string';
function evtag_unmarshal_timeval(evbuf: Tevbuffer; need_tag: Tev_uint32_t;
  ptv: Ttimeval): Integer; cdecl;
external event_extra name 'evtag_unmarshal_timeval';
function evthread_set_lock_callbacks(var callbacks: Tevthread_lock_callbacks)
  : Integer; cdecl; external event name 'evthread_set_lock_callbacks';
function evthread_set_condition_callbacks
  (var callbacks: Tevthread_condition_callbacks): Integer; cdecl;
external event name 'evthread_set_condition_callbacks';
function evthread_set_id_callback(id_f: Tevthread_set_id_callback): Pointer;
  cdecl; external event name 'evthread_set_id_callback';
function evthread_use_windows_threads(): Integer; cdecl;
external event name 'evthread_use_windows_threads';
function evthread_use_pthreads(): Integer; cdecl;
external event name 'evthread_use_pthreads';
function evthread_enable_lock_debuging(): Pointer; cdecl;
external event name 'evthread_enable_lock_debuging';
function evthread_make_base_notifiable(base: Tevent_base): Integer; cdecl;
external event name 'evthread_make_base_notifiable';
function evutil_socketpair(d, cType, protocol: Integer;
  sv: Tevutil_socketpair): Integer; cdecl;
external event name 'evutil_socketpair';
function evutil_make_socket_nonblocking(sock: Tevutil_socket_t): Integer;
  cdecl; external event name 'evutil_make_socket_nonblocking';
function evutil_make_listen_socket_reuseable(sock: Tevutil_socket_t): Integer;
  cdecl; external event name 'evutil_make_listen_socket_reuseable';
function evutil_make_socket_closeonexec(sock: Tevutil_socket_t): Integer;
  cdecl; external event name 'evutil_make_socket_closeonexec';
function evutil_closesocket(sock: Tevutil_socket_t): Integer; cdecl;
external event name 'evutil_closesocket';
function evutil_socket_geterror(sock: Tevutil_socket_t): Integer; cdecl;
external event name 'evutil_socket_geterror';
function evutil_socket_error_to_string(errcode: Integer): PChar; cdecl;
external event name 'evutil_socket_error_to_string';
function evutil_strtoll(var s: PChar; endptr: PChar;
  base: Integer): Tev_int64_t; cdecl;
external event name 'evutil_strtoll';
function evutil_gettimeofday(tv: Ttimeval; tz: Ttimezone): Integer; cdecl;
external event name 'evutil_gettimeofday';
function evutil_snprintf(buf: PChar; buflen: Integer;
  var format: PChar): Integer; cdecl; external event name 'evutil_snprintf';
function evutil_vsnprintf(buf: PChar; buflen: Integer; var format: PChar;
  ap: va_list): Integer; cdecl; external event name 'evutil_vsnprintf';
function evutil_inet_ntop(af: Integer; var src: Pointer; dst: PChar;
  len: Integer): PChar; cdecl; external event name 'evutil_inet_ntop';
function evutil_inet_pton(af: Integer; var src: PChar; dst: Pointer): Integer;
  cdecl; external event name 'evutil_inet_pton';
function evutil_parse_sockaddr_port(var str: PChar; out_: Tsockaddr;
  outlen: Integer): Integer; cdecl;
external event name 'evutil_parse_sockaddr_port';
function evutil_sockaddr_cmp(var sa1: Tsockaddr; var sa2: Tsockaddr;
  include_port: Integer): Integer; cdecl;
external event name 'evutil_sockaddr_cmp';
function evutil_ascii_strcasecmp(var str1: PChar; var str2: PChar): Integer;
  cdecl; external event name 'evutil_ascii_strcasecmp';
function evutil_ascii_strncasecmp(var str1: PChar; var str2: PChar;
  n: Integer): Integer; cdecl; external event name 'evutil_ascii_strncasecmp';
function evutil_getaddrinfo(var nodename: PChar; var servname: PChar;
  var hints_in: Tevutil_addrinfo; res: Tevutil_addrinfo): Integer; cdecl;
external event name 'evutil_getaddrinfo';
function evutil_freeaddrinfo(ai: Tevutil_addrinfo): Pointer; cdecl;
external event name 'evutil_freeaddrinfo';
function evutil_gai_strerror(err: Integer): PChar; cdecl;
external event name 'evutil_gai_strerror';
function evutil_secure_rng_get_bytes(buf: Pointer; n: Integer): Pointer; cdecl;
external event name 'evutil_secure_rng_get_bytes';
function evutil_secure_rng_init(): Integer; cdecl;
external event name 'evutil_secure_rng_init';
function evutil_secure_rng_add_bytes(var dat: PChar; datlen: Integer): Pointer;
  cdecl; external event name 'evutil_secure_rng_add_bytes';

implementation

end.
----------------------------------------------

作者：

xuchuantao (暗黑天使)	★☆☆☆☆	-
	普通会员

2012/2/13 20:54:09

1楼：

libevent API声明;
----------------------------------------------

作者：

bahamut8348 (leonna)	★☆☆☆☆	-
	普通会员

2012/2/15 12:18:15

2楼：

这么多pchar?

如果人家用09以后的版本就挂了。。

还有，一些函数翻译的有问题吧。比如：
int evdns_resolve_ipv6(const char *name, int flags, evdns_callback_type callback, void *ptr);

第一个参数怎么会搞成var的？
----------------------------------------------
--

作者：

xuchuantao (暗黑天使)	★☆☆☆☆	-
	普通会员

2012/2/15 19:34:12

3楼：

const char *name是说定义一个名字为name的char常量，不是var那要翻译为什么。
----------------------------------------------

作者：

xsnows (望穿秋水)	▲▲▲▲▲	-
	普通会员

2012/2/15 20:55:28

4楼：

const char *name const pchar 或者 const pbyte
好似都行你试试吧
----------------------------------------------
-

信息

登陆以后才能回复