/*
* xfrd-notify.c - notify sending routines
*
* Copyright (c) 2006, NLnet Labs. All rights reserved.
*
* See LICENSE for the license.
*
*/

#include "config.h"
#include <assert.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include "xfrd-notify.h"
#include "xfrd.h"
#include "xfrd-tcp.h"
#include "packet.h"

#define XFRD_NOTIFY_RETRY_TIMOUT 3 /* seconds between retries sending NOTIFY */

/* start sending notifies */
static void notify_enable(struct notify_zone* zone,
       struct xfrd_soa* new_soa);
/* setup the notify active state */
static void setup_notify_active(struct notify_zone* zone);

/* handle zone notify send */
static void xfrd_handle_notify_send(int fd, short event, void* arg);

static int xfrd_notify_send_udp(struct notify_zone* zone, int index);

static void
notify_send_disable(struct notify_zone* zone)
{
       zone->notify_send_enable = 0;
       event_del(&zone->notify_send_handler);
       if(zone->notify_send_handler.ev_fd != -1) {
               close(zone->notify_send_handler.ev_fd);
               zone->notify_send_handler.ev_fd = -1;
       }
}

static void
notify_send6_disable(struct notify_zone* zone)
{
       zone->notify_send6_enable = 0;
       event_del(&zone->notify_send6_handler);
       if(zone->notify_send6_handler.ev_fd != -1) {
               close(zone->notify_send6_handler.ev_fd);
               zone->notify_send6_handler.ev_fd = -1;
       }
}

void
notify_disable(struct notify_zone* zone)
{
       zone->notify_current = 0;
       /* if added, then remove */
       if(zone->notify_send_enable) {
               notify_send_disable(zone);
       }
       if(zone->notify_send6_enable) {
               notify_send6_disable(zone);
       }

       if(xfrd->notify_udp_num == XFRD_MAX_UDP_NOTIFY) {
               /* find next waiting and needy zone */
               while(xfrd->notify_waiting_first) {
                       /* snip off */
                       struct notify_zone* wz = xfrd->notify_waiting_first;
                       assert(wz->is_waiting);
                       wz->is_waiting = 0;
                       xfrd->notify_waiting_first = wz->waiting_next;
                       if(wz->waiting_next)
                               wz->waiting_next->waiting_prev = NULL;
                       if(xfrd->notify_waiting_last == wz)
                               xfrd->notify_waiting_last = NULL;
                       /* see if this zone needs notify sending */
                       if(wz->notify_current) {
                               DEBUG(DEBUG_XFRD,1, (LOG_INFO,
                                       "xfrd: zone %s: notify off waiting list.",
                                       zone->apex_str) );
                               setup_notify_active(wz);
                               return;
                       }
               }
       }
       xfrd->notify_udp_num--;
}

void
init_notify_send(rbtree_type* tree, region_type* region,
       struct zone_options* options)
{
       struct notify_zone* not = (struct notify_zone*)
               region_alloc(region, sizeof(struct notify_zone));
       memset(not, 0, sizeof(struct notify_zone));
       not->apex = options->node.key;
       not->apex_str = options->name;
       not->node.key = not->apex;
       not->options = options;

       /* if master zone and have a SOA */
       not->current_soa = (struct xfrd_soa*)region_alloc(region,
               sizeof(struct xfrd_soa));
       memset(not->current_soa, 0, sizeof(struct xfrd_soa));

       not->notify_send_handler.ev_fd = -1;
       not->notify_send6_handler.ev_fd = -1;
       not->is_waiting = 0;

       not->notify_send_enable = 0;
       not->notify_send6_enable = 0;
       tsig_create_record_custom(&not->notify_tsig, NULL, 0, 0, 4);
       not->notify_current = 0;
       rbtree_insert(tree, (rbnode_type*)not);
}

void
xfrd_del_notify(xfrd_state_type* xfrd, const dname_type* dname)
{
       /* find it */
       struct notify_zone* not = (struct notify_zone*)rbtree_delete(
               xfrd->notify_zones, dname);
       if(!not)
               return;

       /* waiting list */
       if(not->is_waiting) {
               if(not->waiting_prev)
                       not->waiting_prev->waiting_next = not->waiting_next;
               else    xfrd->notify_waiting_first = not->waiting_next;
               if(not->waiting_next)
                       not->waiting_next->waiting_prev = not->waiting_prev;
               else    xfrd->notify_waiting_last = not->waiting_prev;
               not->is_waiting = 0;
       }

       /* event */
       if(not->notify_send_enable || not->notify_send6_enable) {
               notify_disable(not);
       }

       /* del tsig */
       tsig_delete_record(&not->notify_tsig, NULL);

       /* free it */
       region_recycle(xfrd->region, not->current_soa, sizeof(xfrd_soa_type));
       /* the apex is recycled when the zone_options.node.key is removed */
       region_recycle(xfrd->region, not, sizeof(*not));
}

static int
reply_pkt_is_ack(struct notify_zone* zone, buffer_type* packet, int index)
{
       if((OPCODE(packet) != OPCODE_NOTIFY) ||
               (QR(packet) == 0)) {
               log_msg(LOG_ERR, "xfrd: zone %s: received bad notify reply opcode/flags from %s",
                       zone->apex_str, zone->pkts[index].dest->ip_address_spec);

               return 0;
       }
       /* we know it is OPCODE NOTIFY, QUERY_REPLY and for this zone */
       if(ID(packet) != zone->pkts[index].notify_query_id) {
               log_msg(LOG_ERR, "xfrd: zone %s: received notify-ack with bad ID from %s",
                       zone->apex_str, zone->pkts[index].dest->ip_address_spec);
               return 0;
       }
       /* could check tsig, but why. The reply does not cause processing. */
       if(RCODE(packet) != RCODE_OK) {
               log_msg(LOG_ERR, "xfrd: zone %s: received notify response error %s from %s",
                       zone->apex_str, rcode2str(RCODE(packet)),
                       zone->pkts[index].dest->ip_address_spec);
               if(RCODE(packet) == RCODE_IMPL)
                       return 1; /* rfc1996: notimpl notify reply: consider retries done */
               return 0;
       }
       DEBUG(DEBUG_XFRD,1, (LOG_INFO, "xfrd: zone %s: host %s acknowledges notify",
               zone->apex_str, zone->pkts[index].dest->ip_address_spec));
       return 1;
}

/* compare sockaddr and acl_option addr and port numbers */
static int
cmp_addr_equal(struct sockaddr* a, socklen_t a_len, struct acl_options* dest)
{
       if(dest) {
               unsigned int destport = ((dest->port == 0)?
                       (unsigned)atoi(TCP_PORT):dest->port);
#ifdef INET6
               struct sockaddr_storage* a1 = (struct sockaddr_storage*)a;
               if(a1->ss_family == AF_INET6 && dest->is_ipv6) {
                       struct sockaddr_in6* a2 = (struct sockaddr_in6*)a;
                       if(a_len < sizeof(struct sockaddr_in6))
                               return 0; /* too small */
                       if(ntohs(a2->sin6_port) != destport)
                               return 0; /* different port number */
                       if(memcmp(&a2->sin6_addr, &dest->addr.addr6,
                               sizeof(struct in6_addr)) != 0)
                               return 0; /* different address */
                       return 1;
               }
               if(a1->ss_family == AF_INET6 || dest->is_ipv6)
                       return 0; /* different address family */
               else {
#endif /* INET6 */
                       struct sockaddr_in* a3 = (struct sockaddr_in*)a;
                       if(a_len < sizeof(struct sockaddr_in))
                               return 0; /* too small */
                       if(ntohs(a3->sin_port) != destport)
                               return 0; /* different port number */
                       if(memcmp(&a3->sin_addr, &dest->addr.addr,
                               sizeof(struct in_addr)) != 0)
                               return 0; /* different address */
                       return 1;
#ifdef INET6
               }
#endif
       }
       return 0;
}

static void
notify_pkt_done(struct notify_zone* zone, int index)
{
       zone->pkts[index].dest = NULL;
       zone->pkts[index].notify_retry = 0;
       zone->pkts[index].send_time = 0;
       zone->pkts[index].notify_query_id = 0;
       zone->notify_pkt_count--;
}

static void
notify_pkt_retry(struct notify_zone* zone, int index)
{
       if(++zone->pkts[index].notify_retry >=
               zone->options->pattern->notify_retry) {
               log_msg(LOG_ERR, "xfrd: zone %s: max notify send count reached, %s unreachable",
                       zone->apex_str,
                       zone->pkts[index].dest->ip_address_spec);
               notify_pkt_done(zone, index);
               return;
       }
       if(!xfrd_notify_send_udp(zone, index)) {
               notify_pkt_retry(zone, index);
       }
}

static void
xfrd_handle_notify_reply(struct notify_zone* zone, buffer_type* packet,
       struct sockaddr* src, socklen_t srclen)
{
       int i;
       for(i=0; i<NOTIFY_CONCURRENT_MAX; i++) {
               /* is this entry in use */
               if(!zone->pkts[i].dest)
                       continue;
               /* based on destination */
               if(!cmp_addr_equal(src, srclen, zone->pkts[i].dest))
                       continue;
               if(reply_pkt_is_ack(zone, packet, i)) {
                       /* is done */
                       notify_pkt_done(zone, i);
                       return;
               } else {
                       /* retry */
                       notify_pkt_retry(zone, i);
                       return;
               }
       }
}

static int
xfrd_notify_send_udp(struct notify_zone* zone, int index)
{
       buffer_type* packet = xfrd_get_temp_buffer();
       if(!zone->pkts[index].dest) return 0;
       /* send NOTIFY to secondary. */
       xfrd_setup_packet(packet, TYPE_SOA, CLASS_IN, zone->apex,
               qid_generate());
       zone->pkts[index].notify_query_id = ID(packet);
       OPCODE_SET(packet, OPCODE_NOTIFY);
       AA_SET(packet);
       if(zone->current_soa->serial != 0) {
               /* add current SOA to answer section */
               ANCOUNT_SET(packet, 1);
               xfrd_write_soa_buffer(packet, zone->apex, zone->current_soa);
       }
       if(zone->pkts[index].dest->key_options) {
               xfrd_tsig_sign_request(packet, &zone->notify_tsig, zone->pkts[index].dest);
       }
       buffer_flip(packet);

       if((zone->pkts[index].dest->is_ipv6
               && zone->notify_send6_handler.ev_fd == -1) ||
               (!zone->pkts[index].dest->is_ipv6
               && zone->notify_send_handler.ev_fd == -1)) {
               /* open fd */
               int fd = xfrd_send_udp(zone->pkts[index].dest, packet,
                       zone->options->pattern->outgoing_interface);
               if(fd == -1) {
                       log_msg(LOG_ERR, "xfrd: zone %s: could not send notify #%d to %s",
                               zone->apex_str, zone->pkts[index].notify_retry,
                               zone->pkts[index].dest->ip_address_spec);
                       return 0;
               }
               if(zone->pkts[index].dest->is_ipv6)
                       zone->notify_send6_handler.ev_fd = fd;
               else    zone->notify_send_handler.ev_fd = fd;
       } else {
               /* send on existing fd */
#ifdef INET6
               struct sockaddr_storage to;
#else
               struct sockaddr_in to;
#endif /* INET6 */
               int fd;
               socklen_t to_len = xfrd_acl_sockaddr_to(
                       zone->pkts[index].dest, &to);
               if(zone->pkts[index].dest->is_ipv6)
                       fd = zone->notify_send6_handler.ev_fd;
               else    fd = zone->notify_send_handler.ev_fd;
               if(sendto(fd,
                       buffer_current(packet), buffer_remaining(packet), 0,
                       (struct sockaddr*)&to, to_len) == -1) {
                       log_msg(LOG_ERR, "xfrd notify: sendto %s failed %s",
                               zone->pkts[index].dest->ip_address_spec,
                               strerror(errno));
                       return 0;
               }
       }
       zone->pkts[index].send_time = time(NULL);
       DEBUG(DEBUG_XFRD,1, (LOG_INFO, "xfrd: zone %s: sent notify #%d to %s",
               zone->apex_str, zone->pkts[index].notify_retry,
               zone->pkts[index].dest->ip_address_spec));
       return 1;
}

static void
notify_timeout_check(struct notify_zone* zone)
{
       time_t now = time(NULL);
       int i;
       for(i=0; i<NOTIFY_CONCURRENT_MAX; i++) {
               if(!zone->pkts[i].dest)
                       continue;
               if(now >= zone->pkts[i].send_time + XFRD_NOTIFY_RETRY_TIMOUT) {
                       notify_pkt_retry(zone, i);
               }
       }
}

static void
notify_start_pkts(struct notify_zone* zone)
{
       int i;
       if(!zone->notify_current) return; /* no more acl to send to */
       for(i=0; i<NOTIFY_CONCURRENT_MAX; i++) {
               /* while loop, in case the retries all fail, and we can
                * start another on this slot, or run out of notify acls */
               while(zone->pkts[i].dest==NULL && zone->notify_current) {
                       zone->pkts[i].dest = zone->notify_current;
                       zone->notify_current = zone->notify_current->next;
                       zone->pkts[i].notify_retry = 0;
                       zone->pkts[i].notify_query_id = 0;
                       zone->pkts[i].send_time = 0;
                       zone->notify_pkt_count++;
                       if(!xfrd_notify_send_udp(zone, i)) {
                               notify_pkt_retry(zone, i);
                       }
               }
       }
}

static void
notify_setup_event(struct notify_zone* zone)
{
       if(zone->notify_send_handler.ev_fd != -1) {
               int fd = zone->notify_send_handler.ev_fd;
               if(zone->notify_send_enable) {
                       event_del(&zone->notify_send_handler);
               }
               zone->notify_timeout.tv_sec = XFRD_NOTIFY_RETRY_TIMOUT;
               memset(&zone->notify_send_handler, 0,
                       sizeof(zone->notify_send_handler));
               event_set(&zone->notify_send_handler, fd, EV_READ | EV_TIMEOUT,
                       xfrd_handle_notify_send, zone);
               if(event_base_set(xfrd->event_base, &zone->notify_send_handler) != 0)
                       log_msg(LOG_ERR, "notify_send: event_base_set failed");
               if(event_add(&zone->notify_send_handler, &zone->notify_timeout) != 0)
                       log_msg(LOG_ERR, "notify_send: event_add failed");
               zone->notify_send_enable = 1;
       }
       if(zone->notify_send6_handler.ev_fd != -1) {
               int fd = zone->notify_send6_handler.ev_fd;
               if(zone->notify_send6_enable) {
                       event_del(&zone->notify_send6_handler);
               }
               zone->notify_timeout.tv_sec = XFRD_NOTIFY_RETRY_TIMOUT;
               memset(&zone->notify_send6_handler, 0,
                       sizeof(zone->notify_send6_handler));
               event_set(&zone->notify_send6_handler, fd, EV_READ | EV_TIMEOUT,
                       xfrd_handle_notify_send, zone);
               if(event_base_set(xfrd->event_base, &zone->notify_send6_handler) != 0)
                       log_msg(LOG_ERR, "notify_send: event_base_set failed");
               if(event_add(&zone->notify_send6_handler, &zone->notify_timeout) != 0)
                       log_msg(LOG_ERR, "notify_send: event_add failed");
               zone->notify_send6_enable = 1;
       }
}

static void
xfrd_handle_notify_send(int fd, short event, void* arg)
{
       struct notify_zone* zone = (struct notify_zone*)arg;
       buffer_type* packet = xfrd_get_temp_buffer();
       if(zone->is_waiting) {
               DEBUG(DEBUG_XFRD,1, (LOG_INFO,
                       "xfrd: notify waiting, skipped, %s", zone->apex_str));
               return;
       }
       if((event & EV_READ)) {
               struct sockaddr_storage src;
               socklen_t srclen = (socklen_t)sizeof(src);
               DEBUG(DEBUG_XFRD,1, (LOG_INFO,
                       "xfrd: zone %s: read notify ACK", zone->apex_str));
               assert(fd != -1);
               if(xfrd_udp_read_packet(packet, fd, (struct sockaddr*)&src,
                       &srclen)) {
                       /* find entry, send retry or make entry NULL */
                       xfrd_handle_notify_reply(zone, packet,
                               (struct sockaddr*)&src, srclen);
               }
       }
       if((event & EV_TIMEOUT)) {
               DEBUG(DEBUG_XFRD,1, (LOG_INFO, "xfrd: zone %s: notify timeout",
                       zone->apex_str));
               /* timeout, try again */
       }

       /* see which pkts have timeouted, retry or NULL them */
       notify_timeout_check(zone);

       /* start new packets if we have empty space */
       notify_start_pkts(zone);

       /* see if we are done */
       if(!zone->notify_current && !zone->notify_pkt_count) {
               /* we are done */
               DEBUG(DEBUG_XFRD,1, (LOG_INFO,
                       "xfrd: zone %s: no more notify-send acls. stop notify.",
                       zone->apex_str));
               notify_disable(zone);
               return;
       }

       notify_setup_event(zone);
}

static void
setup_notify_active(struct notify_zone* zone)
{
       zone->notify_pkt_count = 0;
       memset(zone->pkts, 0, sizeof(zone->pkts));
       zone->notify_current = zone->options->pattern->notify;
       zone->notify_timeout.tv_sec = 0;
       zone->notify_timeout.tv_usec = 0;

       if(zone->notify_send_enable)
               notify_send_disable(zone);
       memset(&zone->notify_send_handler, 0,
               sizeof(zone->notify_send_handler));
       event_set(&zone->notify_send_handler, -1, EV_TIMEOUT,
               xfrd_handle_notify_send, zone);
       if(event_base_set(xfrd->event_base, &zone->notify_send_handler) != 0)
               log_msg(LOG_ERR, "notifysend: event_base_set failed");
       if(evtimer_add(&zone->notify_send_handler, &zone->notify_timeout) != 0)
               log_msg(LOG_ERR, "notifysend: evtimer_add failed");
       zone->notify_send_enable = 1;
}

static void
notify_enable(struct notify_zone* zone, struct xfrd_soa* new_soa)
{
       if(!zone->options->pattern->notify) {
               return; /* no notify acl, nothing to do */
       }

       if(new_soa == NULL)
               memset(zone->current_soa, 0, sizeof(xfrd_soa_type));
       else
               memcpy(zone->current_soa, new_soa, sizeof(xfrd_soa_type));
       if(zone->is_waiting)
               return;

       if(xfrd->notify_udp_num < XFRD_MAX_UDP_NOTIFY) {
               setup_notify_active(zone);
               xfrd->notify_udp_num++;
               return;
       }
       /* put it in waiting list */
       zone->notify_current = zone->options->pattern->notify;
       zone->is_waiting = 1;
       zone->waiting_next = NULL;
       zone->waiting_prev = xfrd->notify_waiting_last;
       if(xfrd->notify_waiting_last) {
               xfrd->notify_waiting_last->waiting_next = zone;
       } else {
               xfrd->notify_waiting_first = zone;
       }
       xfrd->notify_waiting_last = zone;
       DEBUG(DEBUG_XFRD,1, (LOG_INFO, "xfrd: zone %s: notify on waiting list.",
               zone->apex_str));
}

void
xfrd_notify_start(struct notify_zone* zone, struct xfrd_state* xfrd)
{
       xfrd_zone_type* xz;
       if(zone->is_waiting || zone->notify_send_enable ||
               zone->notify_send6_enable)
               return;
       xz = (xfrd_zone_type*)rbtree_search(xfrd->zones, zone->apex);
       if(xz && xz->soa_nsd_acquired)
               notify_enable(zone, &xz->soa_nsd);
       else    notify_enable(zone, NULL);
}

void
xfrd_send_notify(rbtree_type* tree, const dname_type* apex, struct xfrd_soa* new_soa)
{
       /* lookup the zone */
       struct notify_zone* zone = (struct notify_zone*)
               rbtree_search(tree, apex);
       assert(zone);
       if(zone->notify_send_enable || zone->notify_send6_enable)
               notify_disable(zone);

       notify_enable(zone, new_soa);
}

void
notify_handle_master_zone_soainfo(rbtree_type* tree,
       const dname_type* apex, struct xfrd_soa* new_soa)
{
       /* lookup the zone */
       struct notify_zone* zone = (struct notify_zone*)
               rbtree_search(tree, apex);
       if(!zone) return; /* got SOAINFO but zone was deleted meanwhile */

       /* check if SOA changed */
       if( (new_soa == NULL && zone->current_soa->serial == 0) ||
               (new_soa && new_soa->serial == zone->current_soa->serial))
               return;
       if(zone->notify_send_enable || zone->notify_send6_enable)
               notify_disable(zone);
       notify_enable(zone, new_soa);
}

void
close_notify_fds(rbtree_type* tree)
{
       struct notify_zone* zone;
       RBTREE_FOR(zone, struct notify_zone*, tree)
       {
               if(zone->notify_send_enable || zone->notify_send6_enable)
                       notify_send_disable(zone);
       }
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.