outside_network.h

Go to the documentation of this file.

/*
 * services/outside_network.h - listen to answers from the network
 *
 * 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 OUTSIDE_NETWORK_H
#define OUTSIDE_NETWORK_H
 
#include "util/rbtree.h"
#include "util/netevent.h"
#include "dnstap/dnstap_config.h"
struct pending;
struct pending_timeout;
struct ub_randstate;
struct pending_tcp;
struct waiting_tcp;
struct waiting_udp;
struct infra_cache;
struct port_comm;
struct port_if;
struct sldns_buffer;
struct serviced_query;
struct dt_env;
struct edns_option;
struct module_env;
struct module_qstate;
struct query_info;
 
struct outside_network {
    struct comm_base* base;
    time_t* now_secs;
    struct timeval* now_tv;
 
    struct sldns_buffer* udp_buff;
    size_t svcd_overhead;
    int use_caps_for_id;
    int want_to_quit;
 
    size_t unwanted_replies;
    size_t unwanted_total;
    size_t unwanted_threshold;
    void (*unwanted_action)(void*);
    void* unwanted_param;
 
    struct port_comm* unused_fds;
    int do_udp;
    int delayclose;
    struct timeval delay_tv;
 
    struct port_if* ip4_ifs;
    int num_ip4;
 
    struct port_if* ip6_ifs;
    int num_ip6;
 
    struct pending* udp_wait_first;
    struct pending* udp_wait_last;
 
    rbtree_type* pending;
    rbtree_type* serviced;
    struct infra_cache* infra;
    struct ub_randstate* rnd;
    void* sslctx;
#ifdef USE_DNSTAP
    struct dt_env* dtenv;
#endif
    int tcp_mss;
 
    struct pending_tcp **tcp_conns;
    size_t num_tcp;
    size_t num_tcp_outgoing;
    struct pending_tcp* tcp_free;
    struct waiting_tcp* tcp_wait_first;
    struct waiting_tcp* tcp_wait_last;
};
 
struct port_if {
    struct sockaddr_storage addr;
    socklen_t addrlen;
 
    int pfxlen;
 
    int* avail_ports;
    int avail_total;
 
    struct port_comm** out;
    int maxout;
    int inuse;
};
 
struct port_comm {
    struct port_comm* next;
    int number;
    struct port_if* pif;
    int index;
    int num_outstanding;
    struct comm_point* cp;
};
 
struct pending {
    rbnode_type node;
    unsigned int id;
    struct sockaddr_storage addr;
    socklen_t addrlen;
    struct port_comm* pc;
    struct comm_timer* timer;
    comm_point_callback_type* cb;
    void* cb_arg;
    struct outside_network* outnet;
    struct serviced_query* sq;
 
    /*---- filled if udp pending is waiting -----*/
    struct pending* next_waiting;
    int timeout;
    uint8_t* pkt;
    size_t pkt_len;
};
 
struct pending_tcp {
    struct pending_tcp* next_free;
    uint16_t id;
    struct comm_point* c;
    struct waiting_tcp* query;
};
 
struct waiting_tcp {
    struct waiting_tcp* next_waiting;
    struct comm_timer* timer;
    struct outside_network* outnet;
    struct sockaddr_storage addr;
    socklen_t addrlen;
    uint8_t* pkt;
    size_t pkt_len;
    comm_point_callback_type* cb;
    void* cb_arg;
    int ssl_upstream;
    char* tls_auth_name;
};
 
struct service_callback {
    struct service_callback* next;
    comm_point_callback_type* cb;
    void* cb_arg;
};
 
#define EDNS_FRAG_SIZE_IP4 1472
#define EDNS_FRAG_SIZE_IP6 1232
 
struct serviced_query {
    rbnode_type node;
    uint8_t* qbuf;
    size_t qbuflen;
    int dnssec;
    int want_dnssec;
    int nocaps;
    int tcp_upstream, ssl_upstream;
    char* tls_auth_name;
    struct sockaddr_storage addr;
    socklen_t addrlen;
    uint8_t* zone;
    size_t zonelen;
    int qtype;
    enum serviced_query_status {
        serviced_initial,
        serviced_query_UDP_EDNS,
        serviced_query_UDP,
        serviced_query_TCP_EDNS,
        serviced_query_TCP,
        serviced_query_PROBE_EDNS,
        serviced_query_UDP_EDNS_fallback,
        serviced_query_TCP_EDNS_fallback,
        serviced_query_UDP_EDNS_FRAG
    }   
        status;
    int to_be_deleted;
    int retry;
    struct timeval last_sent_time;
    int last_rtt;
    int edns_lame_known;
    struct edns_option* opt_list;
    struct outside_network* outnet;
    struct service_callback* cblist;
    void* pending;
};
 
struct outside_network* outside_network_create(struct comm_base* base,
    size_t bufsize, size_t num_ports, char** ifs, int num_ifs,
    int do_ip4, int do_ip6, size_t num_tcp, struct infra_cache* infra, 
    struct ub_randstate* rnd, int use_caps_for_id, int* availports, 
    int numavailports, size_t unwanted_threshold, int tcp_mss,
    void (*unwanted_action)(void*), void* unwanted_param, int do_udp,
    void* sslctx, int delayclose, struct dt_env *dtenv);
 
void outside_network_delete(struct outside_network* outnet);
 
void outside_network_quit_prepare(struct outside_network* outnet);
 
struct pending* pending_udp_query(struct serviced_query* sq,
    struct sldns_buffer* packet, int timeout, comm_point_callback_type* callback,
    void* callback_arg);
 
struct waiting_tcp* pending_tcp_query(struct serviced_query* sq,
    struct sldns_buffer* packet, int timeout, comm_point_callback_type* callback,
    void* callback_arg);
 
void pending_delete(struct outside_network* outnet, struct pending* p);
 
struct serviced_query* outnet_serviced_query(struct outside_network* outnet,
    struct query_info* qinfo, uint16_t flags, int dnssec, int want_dnssec,
    int nocaps, int tcp_upstream, int ssl_upstream, char* tls_auth_name,
    struct sockaddr_storage* addr, socklen_t addrlen, uint8_t* zone,
    size_t zonelen, struct module_qstate* qstate,
    comm_point_callback_type* callback, void* callback_arg,
    struct sldns_buffer* buff, struct module_env* env);
 
void outnet_serviced_query_stop(struct serviced_query* sq, void* cb_arg);
 
size_t outnet_get_mem(struct outside_network* outnet);
 
size_t serviced_get_mem(struct serviced_query* sq);
 
int outnet_get_tcp_fd(struct sockaddr_storage* addr, socklen_t addrlen, int tcp_mss);
 
struct comm_point* outnet_comm_point_for_udp(struct outside_network* outnet,
    comm_point_callback_type* cb, void* cb_arg,
    struct sockaddr_storage* to_addr, socklen_t to_addrlen);
 
struct comm_point* outnet_comm_point_for_tcp(struct outside_network* outnet,
    comm_point_callback_type* cb, void* cb_arg,
    struct sockaddr_storage* to_addr, socklen_t to_addrlen,
    struct sldns_buffer* query, int timeout);
 
struct comm_point* outnet_comm_point_for_http(struct outside_network* outnet,
    comm_point_callback_type* cb, void* cb_arg,
    struct sockaddr_storage* to_addr, socklen_t to_addrlen, int timeout,
    int ssl, char* host, char* path);
 
int outnet_tcp_connect(int s, struct sockaddr_storage* addr, socklen_t addrlen);
 
int outnet_udp_cb(struct comm_point* c, void* arg, int error,
    struct comm_reply *reply_info);
 
int outnet_tcp_cb(struct comm_point* c, void* arg, int error,
    struct comm_reply *reply_info);
 
void pending_udp_timer_cb(void *arg);
 
void pending_udp_timer_delay_cb(void *arg);
 
void outnet_tcptimer(void* arg);
 
int serviced_udp_callback(struct comm_point* c, void* arg, int error,
        struct comm_reply* rep);
 
int serviced_tcp_callback(struct comm_point* c, void* arg, int error,
        struct comm_reply* rep);
 
int pending_cmp(const void* key1, const void* key2);
 
int serviced_cmp(const void* key1, const void* key2);
 
#endif /* OUTSIDE_NETWORK_H */