authzone.h

Go to the documentation of this file.

/*
 * services/authzone.h - authoritative zone that is locally hosted.
 *
 * Copyright (c) 2017, 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 SERVICES_AUTHZONE_H
#define SERVICES_AUTHZONE_H
#include "util/rbtree.h"
#include "util/locks.h"
#include "services/mesh.h"
struct ub_packed_rrset_key;
struct regional;
struct config_file;
struct config_auth;
struct query_info;
struct dns_msg;
struct edns_data;
struct module_env;
struct worker;
struct comm_point;
struct comm_timer;
struct comm_reply;
struct auth_rrset;
struct auth_nextprobe;
struct auth_probe;
struct auth_transfer;
struct auth_master;
struct auth_chunk;

struct auth_zones {
    lock_rw_type lock;
    rbtree_type ztree;
    rbtree_type xtree;
    int have_downstream;
    size_t num_query_up;
    size_t num_query_down;
};

struct auth_zone {
    rbnode_type node;

    uint8_t* name;
    size_t namelen;
    int namelabs;
    uint16_t dclass;

    lock_rw_type lock;

    rbtree_type data;

    char* zonefile;
    int fallback_enabled;
    int zone_expired;
    int zone_is_slave;
    int for_downstream;
    int for_upstream;
    int zone_deleted;
    struct auth_zone* delete_next;
};

struct auth_data {
    rbnode_type node;
    uint8_t* name;
    size_t namelen;
    int namelabs;
    struct auth_rrset* rrsets;
};

struct auth_rrset {
    struct auth_rrset* next;
    uint16_t type;
    struct packed_rrset_data* data;
};

struct auth_xfer {
    rbnode_type node;

    lock_basic_type lock;

    uint8_t* name;
    size_t namelen;
    int namelabs;
    uint16_t dclass;

    struct auth_nextprobe* task_nextprobe;

    struct auth_probe* task_probe;

    struct auth_transfer* task_transfer;

    int notify_received;
    int notify_has_serial;
    uint32_t notify_serial;
    struct auth_master* allow_notify_list;
 
    /* protected by the lock on the structure, information about
     * the loaded authority zone. */
    int zone_expired;
    int have_zone;

    uint32_t serial;
    time_t retry;
    time_t refresh;
    time_t expiry;

    time_t lease_time;
};

struct auth_nextprobe {
    /* Worker pointer. NULL means unowned. */
    struct worker* worker;
    /* module env for this task */
    struct module_env* env;

    time_t backoff;
    time_t next_probe;
    struct comm_timer* timer;
};

struct auth_probe {
    /* Worker pointer. NULL means unowned. */
    struct worker* worker;
    /* module env for this task */
    struct module_env* env;

    struct auth_master* masters;

    struct auth_master* lookup_target;
    int lookup_aaaa;
    int only_lookup;

    struct auth_master* scan_specific;
    struct auth_master* scan_target;
    struct auth_addr* scan_addr;

    uint16_t id;
    struct comm_point* cp;
    struct comm_timer* timer;
    int timeout;
};

struct auth_transfer {
    /* Worker pointer. NULL means unowned. */
    struct worker* worker;
    /* module env for this task */
    struct module_env* env;

    struct auth_chunk* chunks_first;
    struct auth_chunk* chunks_last;

    struct auth_master* masters;

    struct auth_master* lookup_target;
    int lookup_aaaa;

    struct auth_master* scan_specific;
    struct auth_master* scan_target;
    struct auth_addr* scan_addr;
    struct auth_master* master;

    int ixfr_fail;
    int on_ixfr;
    int got_xfr_serial;
    size_t rr_scan_num;
    int on_ixfr_is_axfr;
    uint32_t incoming_xfr_serial;

    uint16_t id;
    struct comm_point* cp;
};

struct auth_addr {
    struct auth_addr* next;
    struct sockaddr_storage addr;
    socklen_t addrlen;
};

struct auth_master {
    struct auth_master* next;
    char* host;
    char* file;
    int http;
    int ixfr;
    int allow_notify;
    int ssl;
    int port;
    struct auth_addr* list;
};

struct auth_chunk {
    struct auth_chunk* next;
    uint8_t* data;
    size_t len;
};

struct auth_zones* auth_zones_create(void);

int auth_zones_apply_cfg(struct auth_zones* az, struct config_file* cfg,
    int setup);

void auth_xfer_pickup_initial(struct auth_zones* az, struct module_env* env);

void auth_zones_cleanup(struct auth_zones* az);

void auth_zones_delete(struct auth_zones* az);

int auth_zone_write_file(struct auth_zone* z, const char* fname);

int auth_zones_lookup(struct auth_zones* az, struct query_info* qinfo,
    struct regional* region, struct dns_msg** msg, int* fallback,
    uint8_t* dp_nm, size_t dp_nmlen);

int auth_zones_answer(struct auth_zones* az, struct module_env* env,
    struct query_info* qinfo, struct edns_data* edns, struct sldns_buffer* buf,
    struct regional* temp);

struct auth_zone* auth_zones_find_zone(struct auth_zones* az,
    uint8_t* name, size_t name_len, uint16_t dclass);

struct auth_zone* auth_zone_find(struct auth_zones* az, uint8_t* nm,
    size_t nmlen, uint16_t dclass);

struct auth_xfer* auth_xfer_find(struct auth_zones* az, uint8_t* nm,
    size_t nmlen, uint16_t dclass);

struct auth_zone* auth_zone_create(struct auth_zones* az, uint8_t* nm,
    size_t nmlen, uint16_t dclass);

int auth_zone_set_zonefile(struct auth_zone* z, char* zonefile);

int auth_zone_set_fallback(struct auth_zone* z, char* fallbackstr);

int auth_zones_can_fallback(struct auth_zones* az, uint8_t* nm, size_t nmlen,
    uint16_t dclass);

int auth_zones_notify(struct auth_zones* az, struct module_env* env,
    uint8_t* nm, size_t nmlen, uint16_t dclass,
    struct sockaddr_storage* addr, socklen_t addrlen, int has_serial,
    uint32_t serial, int* refused);

int auth_zone_parse_notify_serial(struct sldns_buffer* pkt, uint32_t *serial);

int auth_zone_read_zonefile(struct auth_zone* z);

int auth_zone_get_serial(struct auth_zone* z, uint32_t* serial);

int auth_zone_cmp(const void* z1, const void* z2);

int auth_data_cmp(const void* z1, const void* z2);

int auth_xfer_cmp(const void* z1, const void* z2);

struct auth_xfer* auth_xfer_create(struct auth_zones* az, struct auth_zone* z);

int xfer_set_masters(struct auth_master** list, struct config_auth* c,
    int with_http);

void auth_xfer_timer(void* arg);

int auth_xfer_probe_udp_callback(struct comm_point* c, void* arg, int err,
        struct comm_reply* repinfo);
int auth_xfer_transfer_tcp_callback(struct comm_point* c, void* arg, int err,
        struct comm_reply* repinfo);
int auth_xfer_transfer_http_callback(struct comm_point* c, void* arg, int err,
        struct comm_reply* repinfo);
void auth_xfer_probe_timer_callback(void* arg);
void auth_xfer_probe_lookup_callback(void* arg, int rcode,
    struct sldns_buffer* buf, enum sec_status sec, char* why_bogus);
void auth_xfer_transfer_lookup_callback(void* arg, int rcode,
    struct sldns_buffer* buf, enum sec_status sec, char* why_bogus);
 
/*
 * Compares two 32-bit serial numbers as defined in RFC1982.  Returns
 * <0 if a < b, 0 if a == b, and >0 if a > b.  The result is undefined
 * if a != b but neither is greater or smaller (see RFC1982 section
 * 3.2.).
 */
int compare_serial(uint32_t a, uint32_t b);
 
#endif /* SERVICES_AUTHZONE_H */