netevent.h

Go to the documentation of this file.

/*
 * util/netevent.h - event notification
 *
 * Copyright (c) 2007, NLnet Labs. All rights reserved.
 *
 * This software is open source.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 
 * Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 * 
 * Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 * 
 * Neither the name of the NLNET LABS nor the names of its contributors may
 * be used to endorse or promote products derived from this software without
 * specific prior written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
#ifndef NET_EVENT_H
#define NET_EVENT_H
 
#include "dnscrypt/dnscrypt.h"
 
struct sldns_buffer;
struct comm_point;
struct comm_reply;
struct ub_event_base;
 
/* internal event notification data storage structure. */
struct internal_event;
struct internal_base;
struct internal_timer; /* A sub struct of the comm_timer super struct */
 
typedef int comm_point_callback_type(struct comm_point*, void*, int, 
    struct comm_reply*);
 
#define NETEVENT_NOERROR 0
#define NETEVENT_CLOSED -1
#define NETEVENT_TIMEOUT -2 
#define NETEVENT_CAPSFAIL -3
#define NETEVENT_DONE -4
 
#define NETEVENT_SLOW_ACCEPT_TIME 2000
 
struct comm_base {
    struct internal_base* eb;
    void (*stop_accept)(void*);
    void (*start_accept)(void*);
    void* cb_arg;
};
 
struct comm_reply {
    struct comm_point* c;
    struct sockaddr_storage addr;
    socklen_t addrlen;
    int srctype;
    /* DnsCrypt context */
#ifdef USE_DNSCRYPT
    uint8_t client_nonce[crypto_box_HALF_NONCEBYTES];
    uint8_t nmkey[crypto_box_BEFORENMBYTES];
    const dnsccert *dnsc_cert;
    int is_dnscrypted;
#endif
    union {
#ifdef IPV6_PKTINFO
        struct in6_pktinfo v6info;
#endif
#ifdef IP_PKTINFO
        struct in_pktinfo v4info;
#elif defined(IP_RECVDSTADDR)
        struct in_addr v4addr;
#endif
    }
        pktinfo;
    size_t max_udp_size;
};
 
struct comm_point {
    struct internal_event* ev;
 
    int fd;
 
    struct timeval* timeout;
 
    struct sldns_buffer* buffer;
 
    /* -------- TCP Handler -------- */
    int tcp_is_reading;
    size_t tcp_byte_count;
    struct comm_point* tcp_parent;
    struct comm_reply repinfo;
 
    /* -------- TCP Accept -------- */
    int max_tcp_count;
    int cur_tcp_count;
    struct comm_point** tcp_handlers;
    struct comm_point* tcp_free;
 
    /* -------- SSL TCP DNS ------- */
    void* ssl;
    enum {
        comm_ssl_shake_none = 0,
        comm_ssl_shake_read,
        comm_ssl_shake_write,
        comm_ssl_shake_hs_read,
        comm_ssl_shake_hs_write
    } ssl_shake_state;
 
    /* -------- HTTP ------- */
    int http_in_headers;
    int http_in_chunk_headers;
    int http_is_chunked;
    struct sldns_buffer* http_temp;
    size_t http_stored;
 
    /* -------- dnstap ------- */
    struct dt_env* dtenv;
 
    enum comm_point_type {
        comm_udp, 
        comm_tcp_accept, 
        comm_tcp,
        comm_http,
        comm_local,
        comm_raw
    } 
        type;
 
    /* ---------- Behaviour ----------- */
    int do_not_close;
 
    int tcp_do_close;
 
    int tcp_do_toggle_rw;
 
    int tcp_timeout_msec;
 
    int tcp_check_nb_connect;
 
#ifdef USE_MSG_FASTOPEN
    int tcp_do_fastopen;
#endif
 
#ifdef USE_DNSCRYPT
    int dnscrypt;
    struct sldns_buffer* dnscrypt_buffer;
#endif
    int inuse;
 
    comm_point_callback_type* callback;
    void *cb_arg;
};
 
struct comm_timer {
    struct internal_timer* ev_timer;
 
    void (*callback)(void*);
 
    void* cb_arg;
};
 
struct comm_signal {
    struct comm_base* base;
 
    struct internal_signal* ev_signal;
 
    void (*callback)(int, void*);
 
    void* cb_arg;
};
 
struct comm_base* comm_base_create(int sigs);
 
struct comm_base* comm_base_create_event(struct ub_event_base* base);
 
void comm_base_delete_no_base(struct comm_base* b);
 
void comm_base_delete(struct comm_base* b);
 
void comm_base_timept(struct comm_base* b, time_t** tt, struct timeval** tv);
 
void comm_base_dispatch(struct comm_base* b);
 
void comm_base_exit(struct comm_base* b);
 
void comm_base_set_slow_accept_handlers(struct comm_base* b,
    void (*stop_accept)(void*), void (*start_accept)(void*), void* arg);
 
struct ub_event_base* comm_base_internal(struct comm_base* b);
 
struct comm_point* comm_point_create_udp(struct comm_base* base,
    int fd, struct sldns_buffer* buffer, 
    comm_point_callback_type* callback, void* callback_arg);
 
struct comm_point* comm_point_create_udp_ancil(struct comm_base* base,
    int fd, struct sldns_buffer* buffer, 
    comm_point_callback_type* callback, void* callback_arg);
 
struct comm_point* comm_point_create_tcp(struct comm_base* base,
    int fd, int num, size_t bufsize, 
    comm_point_callback_type* callback, void* callback_arg);
 
struct comm_point* comm_point_create_tcp_out(struct comm_base* base,
    size_t bufsize, comm_point_callback_type* callback, void* callback_arg);
 
struct comm_point* comm_point_create_http_out(struct comm_base* base,
    size_t bufsize, comm_point_callback_type* callback,
    void* callback_arg, struct sldns_buffer* temp);
 
struct comm_point* comm_point_create_local(struct comm_base* base,
    int fd, size_t bufsize, 
    comm_point_callback_type* callback, void* callback_arg);
 
struct comm_point* comm_point_create_raw(struct comm_base* base,
    int fd, int writing, 
    comm_point_callback_type* callback, void* callback_arg);
 
void comm_point_close(struct comm_point* c);
 
void comm_point_delete(struct comm_point* c);
 
void comm_point_send_reply(struct comm_reply* repinfo);
 
void comm_point_drop_reply(struct comm_reply* repinfo);
 
int comm_point_send_udp_msg(struct comm_point* c, struct sldns_buffer* packet,
    struct sockaddr* addr, socklen_t addrlen);
 
void comm_point_stop_listening(struct comm_point* c);
 
void comm_point_start_listening(struct comm_point* c, int newfd, int msec);
 
void comm_point_listen_for_rw(struct comm_point* c, int rd, int wr);
 
size_t comm_point_get_mem(struct comm_point* c);
 
struct comm_timer* comm_timer_create(struct comm_base* base, 
    void (*cb)(void*), void* cb_arg);
 
void comm_timer_disable(struct comm_timer* timer);
 
void comm_timer_set(struct comm_timer* timer, struct timeval* tv);
 
void comm_timer_delete(struct comm_timer* timer);
 
int comm_timer_is_set(struct comm_timer* timer);
 
size_t comm_timer_get_mem(struct comm_timer* timer);
 
struct comm_signal* comm_signal_create(struct comm_base* base,
    void (*callback)(int, void*), void* cb_arg);
 
int comm_signal_bind(struct comm_signal* comsig, int sig);
 
void comm_signal_delete(struct comm_signal* comsig);
 
int comm_point_perform_accept(struct comm_point* c, 
    struct sockaddr_storage* addr, socklen_t* addrlen);
 
/**** internal routines ****/
 
void comm_point_udp_callback(int fd, short event, void* arg);
 
void comm_point_udp_ancil_callback(int fd, short event, void* arg);
 
void comm_point_tcp_accept_callback(int fd, short event, void* arg);
 
void comm_point_tcp_handle_callback(int fd, short event, void* arg);
 
void comm_point_http_handle_callback(int fd, short event, void* arg);
 
void comm_timer_callback(int fd, short event, void* arg);
 
void comm_signal_callback(int fd, short event, void* arg);
 
void comm_point_local_handle_callback(int fd, short event, void* arg);
 
void comm_point_raw_handle_callback(int fd, short event, void* arg);
 
void comm_base_handle_slow_accept(int fd, short event, void* arg);
 
#ifdef USE_WINSOCK
void comm_point_tcp_win_bio_cb(struct comm_point* c, void* ssl);
#endif
 
int tcp_connect_errno_needs_log(struct sockaddr* addr, socklen_t addrlen);
 
#endif /* NET_EVENT_H */