badvpn/udpgw/udpgw.c

/*
 * Copyright (C) Ambroz Bizjak <ambrop7@gmail.com>
 * Contributions:
 * Transparent DNS: Copyright (C) Kerem Hadimli <kerem.hadimli@gmail.com>
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. 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.
 * 3. Neither the name of the author 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 AUTHOR 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.
 */

#include <stdio.h>
#include <string.h>
#include <stdarg.h>
#include <stdlib.h>
#include <limits.h>

#include <protocol/udpgw_proto.h>
#include <misc/debug.h>
#include <misc/version.h>
#include <misc/loggers_string.h>
#include <misc/loglevel.h>
#include <misc/offset.h>
#include <misc/byteorder.h>
#include <misc/bsize.h>
#include <misc/open_standard_streams.h>
#include <misc/balloc.h>
#include <misc/compare.h>
#include <misc/print_macros.h>
#include <structure/LinkedList1.h>
#include <structure/BAVL.h>
#include <base/BLog.h>
#include <system/BReactor.h>
#include <system/BNetwork.h>
#include <system/BConnection.h>
#include <system/BDatagram.h>
#include <system/BSignal.h>
#include <flow/PacketProtoDecoder.h>
#include <flow/PacketPassFairQueue.h>
#include <flow/PacketStreamSender.h>
#include <flow/PacketProtoFlow.h>
#include <flow/SinglePacketBuffer.h>

#ifndef BADVPN_USE_WINAPI
#include <base/BLog_syslog.h>
#include <arpa/nameser.h>
#include <resolv.h>
#endif

#include <udpgw/udpgw.h>

#include <generated/blog_channel_udpgw.h>

#define LOGGER_STDOUT 1
#define LOGGER_SYSLOG 2

#define DNS_UPDATE_TIME 2000

struct client {
    BConnection con;
    BAddr addr;
    BTimer disconnect_timer;
    PacketProtoDecoder recv_decoder;
    PacketPassInterface recv_if;
    PacketPassFairQueue send_queue;
    PacketStreamSender send_sender;
    BAVL connections_tree;
    LinkedList1 connections_list;
    int num_connections;
    LinkedList1 closing_connections_list;
    LinkedList1Node clients_list_node;
};

struct connection {
    struct client *client;
    uint16_t conid;
    BAddr addr;
    BAddr orig_addr;
    const uint8_t *first_data;
    int first_data_len;
    btime_t last_use_time;
    int closing;
    BPending first_job;
    BufferWriter *send_if;
    PacketProtoFlow send_ppflow;
    PacketPassFairQueueFlow send_qflow;
    union {
        struct {
            BDatagram udp_dgram;
            int local_port_index;
            BufferWriter udp_send_writer;
            PacketBuffer udp_send_buffer;
            SinglePacketBuffer udp_recv_buffer;
            PacketPassInterface udp_recv_if;
            BAVLNode connections_tree_node;
            LinkedList1Node connections_list_node;
        };
        struct {
            LinkedList1Node closing_connections_list_node;
        };
    };
};

// command-line options
struct {
    int help;
    int version;
    int logger;
    #ifndef BADVPN_USE_WINAPI
    char *logger_syslog_facility;
    char *logger_syslog_ident;
    #endif
    int loglevel;
    int loglevels[BLOG_NUM_CHANNELS];
    char *listen_addrs[MAX_LISTEN_ADDRS];
    int num_listen_addrs;
    int udp_mtu;
    int max_clients;
    int max_connections_for_client;
    int client_socket_sndbuf;
    int local_udp_num_ports;
    char *local_udp_addr;
    int local_udp_ip6_num_ports;
    char *local_udp_ip6_addr;
    int unique_local_ports;
} options;

// MTUs
int udpgw_mtu;
int pp_mtu;

// listen addresses
BAddr listen_addrs[MAX_LISTEN_ADDRS];
int num_listen_addrs;

// local UDP port range, if options.local_udp_num_ports>=0
BAddr local_udp_addr;

// local UDP/IPv6 port range, if options.local_udp_ip6_num_ports>=0
BAddr local_udp_ip6_addr;

// DNS forwarding
BAddr dns_addr;
btime_t last_dns_update_time;

// reactor
BReactor ss;

// listeners
BListener listeners[MAX_LISTEN_ADDRS];
int num_listeners;

// clients
LinkedList1 clients_list;
int num_clients;

static void print_help (const char *name);
static void print_version (void);
static int parse_arguments (int argc, char *argv[]);
static int process_arguments (void);
static void signal_handler (void *unused);
static void listener_handler (BListener *listener);
static void client_free (struct client *client);
static void client_logfunc (struct client *client);
static void client_log (struct client *client, int level, const char *fmt, ...);
static void client_disconnect_timer_handler (struct client *client);
static void client_connection_handler (struct client *client, int event);
static void client_decoder_handler_error (struct client *client);
static void client_recv_if_handler_send (struct client *client, uint8_t *data, int data_len);
static int get_local_num_ports (int addr_type);
static BAddr get_local_addr (int addr_type);
static uint8_t * build_port_usage_array_and_find_least_used_connection (BAddr remote_addr, struct connection **out_con);
static void connection_init (struct client *client, uint16_t conid, BAddr addr, BAddr orig_addr, const uint8_t *data, int data_len);
static void connection_free (struct connection *con);
static void connection_logfunc (struct connection *con);
static void connection_log (struct connection *con, int level, const char *fmt, ...);
static void connection_free_udp (struct connection *con);
static void connection_first_job_handler (struct connection *con);
static void connection_send_to_client (struct connection *con, uint8_t flags, const uint8_t *data, int data_len);
static int connection_send_to_udp (struct connection *con, const uint8_t *data, int data_len);
static void connection_close (struct connection *con);
static void connection_send_qflow_busy_handler (struct connection *con);
static void connection_dgram_handler_event (struct connection *con, int event);
static void connection_udp_recv_if_handler_send (struct connection *con, uint8_t *data, int data_len);
static struct connection * find_connection (struct client *client, uint16_t conid);
static int uint16_comparator (void *unused, uint16_t *v1, uint16_t *v2);
static void maybe_update_dns (void);

int main (int argc, char **argv)
{
    if (argc <= 0) {
        return 1;
    }
    
    // open standard streams
    open_standard_streams();
    
    // parse command-line arguments
    if (!parse_arguments(argc, argv)) {
        fprintf(stderr, "Failed to parse arguments\n");
        print_help(argv[0]);
        goto fail0;
    }
    
    // handle --help and --version
    if (options.help) {
        print_version();
        print_help(argv[0]);
        return 0;
    }
    if (options.version) {
        print_version();
        return 0;
    }
    
    // initialize logger
    switch (options.logger) {
        case LOGGER_STDOUT:
            BLog_InitStdout();
            break;
        #ifndef BADVPN_USE_WINAPI
        case LOGGER_SYSLOG:
            if (!BLog_InitSyslog(options.logger_syslog_ident, options.logger_syslog_facility)) {
                fprintf(stderr, "Failed to initialize syslog logger\n");
                goto fail0;
            }
            break;
        #endif
        default:
            ASSERT(0);
    }
    
    // configure logger channels
    for (int i = 0; i < BLOG_NUM_CHANNELS; i++) {
        if (options.loglevels[i] >= 0) {
            BLog_SetChannelLoglevel(i, options.loglevels[i]);
        }
        else if (options.loglevel >= 0) {
            BLog_SetChannelLoglevel(i, options.loglevel);
        }
    }
    
    BLog(BLOG_NOTICE, "initializing "GLOBAL_PRODUCT_NAME" "PROGRAM_NAME" "GLOBAL_VERSION);
    
    // initialize network
    if (!BNetwork_GlobalInit()) {
        BLog(BLOG_ERROR, "BNetwork_GlobalInit failed");
        goto fail1;
    }
    
    // process arguments
    if (!process_arguments()) {
        BLog(BLOG_ERROR, "Failed to process arguments");
        goto fail1;
    }
    
    // compute MTUs
    udpgw_mtu = udpgw_compute_mtu(options.udp_mtu);
    if (udpgw_mtu < 0 || udpgw_mtu > PACKETPROTO_MAXPAYLOAD) {
        udpgw_mtu = PACKETPROTO_MAXPAYLOAD;
    }
    pp_mtu = udpgw_mtu + sizeof(struct packetproto_header);
    
    // init time
    BTime_Init();
    
    // init DNS forwarding
    BAddr_InitNone(&dns_addr);
    last_dns_update_time = INT64_MIN;
    maybe_update_dns();
    
    // init reactor
    if (!BReactor_Init(&ss)) {
        BLog(BLOG_ERROR, "BReactor_Init failed");
        goto fail1;
    }
    
    // setup signal handler
    if (!BSignal_Init(&ss, signal_handler, NULL)) {
        BLog(BLOG_ERROR, "BSignal_Init failed");
        goto fail2;
    }
    
    // initialize listeners
    num_listeners = 0;
    while (num_listeners < num_listen_addrs) {
        if (!BListener_Init(&listeners[num_listeners], listen_addrs[num_listeners], &ss, &listeners[num_listeners], (BListener_handler)listener_handler)) {
            BLog(BLOG_ERROR, "Listener_Init failed");
            goto fail3;
        }
        num_listeners++;
    }
    
    // init clients list
    LinkedList1_Init(&clients_list);
    num_clients = 0;
    
    // enter event loop
    BLog(BLOG_NOTICE, "entering event loop");
    BReactor_Exec(&ss);
    
    // free clients
    while (!LinkedList1_IsEmpty(&clients_list)) {
        struct client *client = UPPER_OBJECT(LinkedList1_GetFirst(&clients_list), struct client, clients_list_node);
        client_free(client);
    }
fail3:
    // free listeners
    while (num_listeners > 0) {
        num_listeners--;
        BListener_Free(&listeners[num_listeners]);
    }
    // finish signal handling
    BSignal_Finish();
fail2:
    // free reactor
    BReactor_Free(&ss);
fail1:
    // free logger
    BLog(BLOG_NOTICE, "exiting");
    BLog_Free();
fail0:
    // finish debug objects
    DebugObjectGlobal_Finish();
    
    return 1;
}

void print_help (const char *name)
{
    printf(
        "Usage:\n"
        "    %s\n"
        "        [--help]\n"
        "        [--version]\n"
        "        [--logger <"LOGGERS_STRING">]\n"
        #ifndef BADVPN_USE_WINAPI
        "        (logger=syslog?\n"
        "            [--syslog-facility <string>]\n"
        "            [--syslog-ident <string>]\n"
        "        )\n"
        #endif
        "        [--loglevel <0-5/none/error/warning/notice/info/debug>]\n"
        "        [--channel-loglevel <channel-name> <0-5/none/error/warning/notice/info/debug>] ...\n"
        "        [--listen-addr <addr>] ...\n"
        "        [--udp-mtu <bytes>]\n"
        "        [--max-clients <number>]\n"
        "        [--max-connections-for-client <number>]\n"
        "        [--client-socket-sndbuf <bytes / 0>]\n"
        "        [--local-udp-addrs <addr> <num_ports>]\n"
        "        [--local-udp-ip6-addrs <addr> <num_ports>]\n"
        "        [--unique-local-ports]\n"
        "Address format is a.b.c.d:port (IPv4) or [addr]:port (IPv6).\n",
        name
    );
}

void print_version (void)
{
    printf(GLOBAL_PRODUCT_NAME" "PROGRAM_NAME" "GLOBAL_VERSION"\n"GLOBAL_COPYRIGHT_NOTICE"\n");
}

int parse_arguments (int argc, char *argv[])
{
    if (argc <= 0) {
        return 0;
    }
    
    options.help = 0;
    options.version = 0;
    options.logger = LOGGER_STDOUT;
    #ifndef BADVPN_USE_WINAPI
    options.logger_syslog_facility = "daemon";
    options.logger_syslog_ident = argv[0];
    #endif
    options.loglevel = -1;
    for (int i = 0; i < BLOG_NUM_CHANNELS; i++) {
        options.loglevels[i] = -1;
    }
    options.num_listen_addrs = 0;
    options.udp_mtu = DEFAULT_UDP_MTU;
    options.max_clients = DEFAULT_MAX_CLIENTS;
    options.max_connections_for_client = DEFAULT_MAX_CONNECTIONS_FOR_CLIENT;
    options.client_socket_sndbuf = CLIENT_DEFAULT_SOCKET_SEND_BUFFER;
    options.local_udp_num_ports = -1;
    options.local_udp_ip6_num_ports = -1;
    options.unique_local_ports = 0;
    
    int i;
    for (i = 1; i < argc; i++) {
        char *arg = argv[i];
        if (!strcmp(arg, "--help")) {
            options.help = 1;
        }
        else if (!strcmp(arg, "--version")) {
            options.version = 1;
        }
        else if (!strcmp(arg, "--logger")) {
            if (1 >= argc - i) {
                fprintf(stderr, "%s: requires an argument\n", arg);
                return 0;
            }
            char *arg2 = argv[i + 1];
            if (!strcmp(arg2, "stdout")) {
                options.logger = LOGGER_STDOUT;
            }
            #ifndef BADVPN_USE_WINAPI
            else if (!strcmp(arg2, "syslog")) {
                options.logger = LOGGER_SYSLOG;
            }
            #endif
            else {
                fprintf(stderr, "%s: wrong argument\n", arg);
                return 0;
            }
            i++;
        }
        #ifndef BADVPN_USE_WINAPI
        else if (!strcmp(arg, "--syslog-facility")) {
            if (1 >= argc - i) {
                fprintf(stderr, "%s: requires an argument\n", arg);
                return 0;
            }
            options.logger_syslog_facility = argv[i + 1];
            i++;
        }
        else if (!strcmp(arg, "--syslog-ident")) {
            if (1 >= argc - i) {
                fprintf(stderr, "%s: requires an argument\n", arg);
                return 0;
            }
            options.logger_syslog_ident = argv[i + 1];
            i++;
        }
        #endif
        else if (!strcmp(arg, "--loglevel")) {
            if (1 >= argc - i) {
                fprintf(stderr, "%s: requires an argument\n", arg);
                return 0;
            }
            if ((options.loglevel = parse_loglevel(argv[i + 1])) < 0) {
                fprintf(stderr, "%s: wrong argument\n", arg);
                return 0;
            }
            i++;
        }
        else if (!strcmp(arg, "--channel-loglevel")) {
            if (2 >= argc - i) {
                fprintf(stderr, "%s: requires two arguments\n", arg);
                return 0;
            }
            int channel = BLogGlobal_GetChannelByName(argv[i + 1]);
            if (channel < 0) {
                fprintf(stderr, "%s: wrong channel argument\n", arg);
                return 0;
            }
            int loglevel = parse_loglevel(argv[i + 2]);
            if (loglevel < 0) {
                fprintf(stderr, "%s: wrong loglevel argument\n", arg);
                return 0;
            }
            options.loglevels[channel] = loglevel;
            i += 2;
        }
        else if (!strcmp(arg, "--listen-addr")) {
            if (1 >= argc - i) {
                fprintf(stderr, "%s: requires an argument\n", arg);
                return 0;
            }
            if (options.num_listen_addrs == MAX_LISTEN_ADDRS) {
                fprintf(stderr, "%s: too many\n", arg);
                return 0;
            }
            options.listen_addrs[options.num_listen_addrs] = argv[i + 1];
            options.num_listen_addrs++;
            i++;
        }
        else if (!strcmp(arg, "--udp-mtu")) {
            if (1 >= argc - i) {
                fprintf(stderr, "%s: requires an argument\n", arg);
                return 0;
            }
            if ((options.udp_mtu = atoi(argv[i + 1])) < 0) {
                fprintf(stderr, "%s: wrong argument\n", arg);
                return 0;
            }
            i++;
        }
        else if (!strcmp(arg, "--max-clients")) {
            if (1 >= argc - i) {
                fprintf(stderr, "%s: requires an argument\n", arg);
                return 0;
            }
            if ((options.max_clients = atoi(argv[i + 1])) <= 0) {
                fprintf(stderr, "%s: wrong argument\n", arg);
                return 0;
            }
            i++;
        }
        else if (!strcmp(arg, "--max-connections-for-client")) {
            if (1 >= argc - i) {
                fprintf(stderr, "%s: requires an argument\n", arg);
                return 0;
            }
            if ((options.max_connections_for_client = atoi(argv[i + 1])) <= 0) {
                fprintf(stderr, "%s: wrong argument\n", arg);
                return 0;
            }
            i++;
        }
        else if (!strcmp(arg, "--client-socket-sndbuf")) {
            if (1 >= argc - i) {
                fprintf(stderr, "%s: requires an argument\n", arg);
                return 0;
            }
            if ((options.client_socket_sndbuf = atoi(argv[i + 1])) < 0) {
                fprintf(stderr, "%s: wrong argument\n", arg);
                return 0;
            }
            i++;
        }
        else if (!strcmp(arg, "--local-udp-addrs")) {
            if (2 >= argc - i) {
                fprintf(stderr, "%s: requires two arguments\n", arg);
                return 0;
            }
            options.local_udp_addr = argv[i + 1];
            if ((options.local_udp_num_ports = atoi(argv[i + 2])) < 0) {
                fprintf(stderr, "%s: wrong argument\n", arg);
                return 0;
            }
            i += 2;
        }
        else if (!strcmp(arg, "--local-udp-ip6-addrs")) {
            if (2 >= argc - i) {
                fprintf(stderr, "%s: requires two arguments\n", arg);
                return 0;
            }
            options.local_udp_ip6_addr = argv[i + 1];
            if ((options.local_udp_ip6_num_ports = atoi(argv[i + 2])) < 0) {
                fprintf(stderr, "%s: wrong argument\n", arg);
                return 0;
            }
            i += 2;
        }
        else if (!strcmp(arg, "--unique-local-ports")) {
            options.unique_local_ports = 1;
        }
        else {
            fprintf(stderr, "unknown option: %s\n", arg);
            return 0;
        }
    }
    
    if (options.help || options.version) {
        return 1;
    }
    
    return 1;
}

int process_arguments (void)
{
    // resolve listen addresses
    num_listen_addrs = 0;
    while (num_listen_addrs < options.num_listen_addrs) {
        if (!BAddr_Parse(&listen_addrs[num_listen_addrs], options.listen_addrs[num_listen_addrs], NULL, 0)) {
            BLog(BLOG_ERROR, "listen addr: BAddr_Parse failed");
            return 0;
        }
        num_listen_addrs++;
    }
    
    // resolve local UDP address
    if (options.local_udp_num_ports >= 0) {
        if (!BAddr_Parse(&local_udp_addr, options.local_udp_addr, NULL, 0)) {
            BLog(BLOG_ERROR, "local udp addr: BAddr_Parse failed");
            return 0;
        }
        if (local_udp_addr.type != BADDR_TYPE_IPV4) {
            BLog(BLOG_ERROR, "local udp addr: must be an IPv4 address");
            return 0;
        }
    }
    
    // resolve local UDP/IPv6 address
    if (options.local_udp_ip6_num_ports >= 0) {
        if (!BAddr_Parse(&local_udp_ip6_addr, options.local_udp_ip6_addr, NULL, 0)) {
            BLog(BLOG_ERROR, "local udp ip6 addr: BAddr_Parse failed");
            return 0;
        }
        if (local_udp_ip6_addr.type != BADDR_TYPE_IPV6) {
            BLog(BLOG_ERROR, "local udp ip6 addr: must be an IPv6 address");
            return 0;
        }
    }
    
    return 1;
}

void signal_handler (void *unused)
{
    BLog(BLOG_NOTICE, "termination requested");
    
    // exit event loop
    BReactor_Quit(&ss, 1);
}

void listener_handler (BListener *listener)
{
    if (num_clients == options.max_clients) {
        BLog(BLOG_ERROR, "maximum number of clients reached");
        goto fail0;
    }
    
    // allocate structure
    struct client *client = (struct client *)malloc(sizeof(*client));
    if (!client) {
        BLog(BLOG_ERROR, "malloc failed");
        goto fail0;
    }
    
    // accept client
    if (!BConnection_Init(&client->con, BConnection_source_listener(listener, &client->addr), &ss, client, (BConnection_handler)client_connection_handler)) {
        BLog(BLOG_ERROR, "BConnection_Init failed");
        goto fail1;
    }
    
    // limit socket send buffer, else our scheduling is pointless
    if (options.client_socket_sndbuf > 0) {
        if (!BConnection_SetSendBuffer(&client->con, options.client_socket_sndbuf)) {
            BLog(BLOG_WARNING, "BConnection_SetSendBuffer failed");
        }
    }
    
    // init connection interfaces
    BConnection_SendAsync_Init(&client->con);
    BConnection_RecvAsync_Init(&client->con);
    
    // init disconnect timer
    BTimer_Init(&client->disconnect_timer, CLIENT_DISCONNECT_TIMEOUT, (BTimer_handler)client_disconnect_timer_handler, client);
    BReactor_SetTimer(&ss, &client->disconnect_timer);
    
    // init recv interface
    PacketPassInterface_Init(&client->recv_if, udpgw_mtu, (PacketPassInterface_handler_send)client_recv_if_handler_send, client, BReactor_PendingGroup(&ss));
    
    // init recv decoder
    if (!PacketProtoDecoder_Init(&client->recv_decoder, BConnection_RecvAsync_GetIf(&client->con), &client->recv_if, BReactor_PendingGroup(&ss), client,
        (PacketProtoDecoder_handler_error)client_decoder_handler_error
    )) {
        BLog(BLOG_ERROR, "PacketProtoDecoder_Init failed");
        goto fail2;
    }
    
    // init send sender
    PacketStreamSender_Init(&client->send_sender, BConnection_SendAsync_GetIf(&client->con), pp_mtu, BReactor_PendingGroup(&ss));
    
    // init send queue
    if (!PacketPassFairQueue_Init(&client->send_queue, PacketStreamSender_GetInput(&client->send_sender), BReactor_PendingGroup(&ss), 0, 1)) {
        BLog(BLOG_ERROR, "PacketPassFairQueue_Init failed");
        goto fail3;
    }
    
    // init connections tree
    BAVL_Init(&client->connections_tree, OFFSET_DIFF(struct connection, conid, connections_tree_node), (BAVL_comparator)uint16_comparator, NULL);
    
    // init connections list
    LinkedList1_Init(&client->connections_list);
    
    // set zero connections
    client->num_connections = 0;
    
    // init closing connections list
    LinkedList1_Init(&client->closing_connections_list);
    
    // insert to clients list
    LinkedList1_Append(&clients_list, &client->clients_list_node);
    num_clients++;
    
    client_log(client, BLOG_INFO, "connected");
    
    return;
    
fail3:
    PacketStreamSender_Free(&client->send_sender);
    PacketProtoDecoder_Free(&client->recv_decoder);
fail2:
    PacketPassInterface_Free(&client->recv_if);
    BReactor_RemoveTimer(&ss, &client->disconnect_timer);
    BConnection_RecvAsync_Free(&client->con);
    BConnection_SendAsync_Free(&client->con);
    BConnection_Free(&client->con);
fail1:
    free(client);
fail0:
    return;
}

void client_free (struct client *client)
{
    // allow freeing send queue flows
    PacketPassFairQueue_PrepareFree(&client->send_queue);
    
    // free connections
    while (!LinkedList1_IsEmpty(&client->connections_list)) {
        struct connection *con = UPPER_OBJECT(LinkedList1_GetFirst(&client->connections_list), struct connection, connections_list_node);
        connection_free(con);
    }
    
    // free closing connections
    while (!LinkedList1_IsEmpty(&client->closing_connections_list)) {
        struct connection *con = UPPER_OBJECT(LinkedList1_GetFirst(&client->closing_connections_list), struct connection, closing_connections_list_node);
        connection_free(con);
    }
    
    // remove from clients list
    LinkedList1_Remove(&clients_list, &client->clients_list_node);
    num_clients--;
    
    // free send queue
    PacketPassFairQueue_Free(&client->send_queue);
    
    // free send sender
    PacketStreamSender_Free(&client->send_sender);
    
    // free recv decoder
    PacketProtoDecoder_Free(&client->recv_decoder);
    
    // free recv interface
    PacketPassInterface_Free(&client->recv_if);
    
    // free disconnect timer
    BReactor_RemoveTimer(&ss, &client->disconnect_timer);
    
    // free connection interfaces
    BConnection_RecvAsync_Free(&client->con);
    BConnection_SendAsync_Free(&client->con);
    
    // free connection
    BConnection_Free(&client->con);
    
    // free structure
    free(client);
}

void client_logfunc (struct client *client)
{
    char addr[BADDR_MAX_PRINT_LEN];
    BAddr_Print(&client->addr, addr);
    
    BLog_Append("client (%s): ", addr);
}

void client_log (struct client *client, int level, const char *fmt, ...)
{
    va_list vl;
    va_start(vl, fmt);
    BLog_LogViaFuncVarArg((BLog_logfunc)client_logfunc, client, BLOG_CURRENT_CHANNEL, level, fmt, vl);
    va_end(vl);
}

void client_disconnect_timer_handler (struct client *client)
{
    client_log(client, BLOG_INFO, "timed out, disconnecting");
    
    // free client
    client_free(client);
}

void client_connection_handler (struct client *client, int event)
{
    if (event == BCONNECTION_EVENT_RECVCLOSED) {
        client_log(client, BLOG_INFO, "client closed");
    } else {
        client_log(client, BLOG_INFO, "client error");
    }
    
    // free client
    client_free(client);
}

void client_decoder_handler_error (struct client *client)
{
    client_log(client, BLOG_ERROR, "decoder error");
    
    // free client
    client_free(client);
}

void client_recv_if_handler_send (struct client *client, uint8_t *data, int data_len)
{
    ASSERT(data_len >= 0)
    ASSERT(data_len <= udpgw_mtu)
    
    // accept packet
    PacketPassInterface_Done(&client->recv_if);
    
    // parse header
    if (data_len < sizeof(struct udpgw_header)) {
        client_log(client, BLOG_ERROR, "missing header");
        return;
    }
    struct udpgw_header header;
    memcpy(&header, data, sizeof(header));
    data += sizeof(header);
    data_len -= sizeof(header);
    uint8_t flags = ltoh8(header.flags);
    uint16_t conid = ltoh16(header.conid);
    
    // reset disconnect timer
    BReactor_SetTimer(&ss, &client->disconnect_timer);
    
    // if this is keepalive, ignore any payload
    if ((flags & UDPGW_CLIENT_FLAG_KEEPALIVE)) {
        client_log(client, BLOG_DEBUG, "received keepalive");
        return;
    }
    
    // parse address
    BAddr orig_addr;
    if ((flags & UDPGW_CLIENT_FLAG_IPV6)) {
        if (data_len < sizeof(struct udpgw_addr_ipv6)) {
            client_log(client, BLOG_ERROR, "missing ipv6 address");
            return;
        }
        struct udpgw_addr_ipv6 addr_ipv6;
        memcpy(&addr_ipv6, data, sizeof(addr_ipv6));
        data += sizeof(addr_ipv6);
        data_len -= sizeof(addr_ipv6);
        BAddr_InitIPv6(&orig_addr, addr_ipv6.addr_ip, addr_ipv6.addr_port);
    } else {
        if (data_len < sizeof(struct udpgw_addr_ipv4)) {
            client_log(client, BLOG_ERROR, "missing ipv4 address");
            return;
        }
        struct udpgw_addr_ipv4 addr_ipv4;
        memcpy(&addr_ipv4, data, sizeof(addr_ipv4));
        data += sizeof(addr_ipv4);
        data_len -= sizeof(addr_ipv4);
        BAddr_InitIPv4(&orig_addr, addr_ipv4.addr_ip, addr_ipv4.addr_port);
    }
    
    // check payload length
    if (data_len > options.udp_mtu) {
        client_log(client, BLOG_ERROR, "too much data");
        return;
    }
    
    // find connection
    struct connection *con = find_connection(client, conid);
    ASSERT(!con || !con->closing)
    
    // if connection exists, close it if needed
    if (con && ((flags & UDPGW_CLIENT_FLAG_REBIND) || !BAddr_Compare(&con->orig_addr, &orig_addr))) {
        connection_log(con, BLOG_DEBUG, "close old");
        connection_close(con);
        con = NULL;
    }
    
    // if connection doesn't exists, create it
    if (!con) {
        // check number of connections
        if (client->num_connections == options.max_connections_for_client) {
            // close least recently used connection
            con = UPPER_OBJECT(LinkedList1_GetFirst(&client->connections_list), struct connection, connections_list_node);
            connection_close(con);
        }
        
        // if this is DNS, replace actual address, but keep still remember the orig_addr
        BAddr addr = orig_addr;
        if ((flags & UDPGW_CLIENT_FLAG_DNS)) {
            maybe_update_dns();
            if (dns_addr.type == BADDR_TYPE_NONE) {
                client_log(client, BLOG_WARNING, "received DNS packet, but no DNS server available");
            } else {
                client_log(client, BLOG_DEBUG, "received DNS");
                addr = dns_addr;
            }
        }
        
        // create new connection
        connection_init(client, conid, addr, orig_addr, data, data_len);
    } else {
        // submit packet to existing connection
        connection_send_to_udp(con, data, data_len);
    }
}

int get_local_num_ports (int addr_type)
{
    switch (addr_type) {
        case BADDR_TYPE_IPV4: return options.local_udp_num_ports;
        case BADDR_TYPE_IPV6: return options.local_udp_ip6_num_ports;
        default: ASSERT(0); return 0;
    }
}

BAddr get_local_addr (int addr_type)
{
    ASSERT(get_local_num_ports(addr_type) >= 0)
    
    switch (addr_type) {
        case BADDR_TYPE_IPV4: return local_udp_addr;
        case BADDR_TYPE_IPV6: return local_udp_ip6_addr;
        default: ASSERT(0); return BAddr_MakeNone();
    }
}

uint8_t * build_port_usage_array_and_find_least_used_connection (BAddr remote_addr, struct connection **out_con)
{
    ASSERT(remote_addr.type == BADDR_TYPE_IPV4 || remote_addr.type == BADDR_TYPE_IPV6)
    ASSERT(get_local_num_ports(remote_addr.type) >= 0)
    
    int local_num_ports = get_local_num_ports(remote_addr.type);
    
    // allocate port usage array
    uint8_t *port_usage = (uint8_t *)BAllocSize(bsize_fromint(local_num_ports));
    if (!port_usage) {
        return NULL;
    }
    
    // zero array
    memset(port_usage, 0, local_num_ports);
    
    struct connection *least_con = NULL;
    
    // flag inappropriate ports (those with the same remote address)
    for (LinkedList1Node *ln = LinkedList1_GetFirst(&clients_list); ln; ln = LinkedList1Node_Next(ln)) {
        struct client *client = UPPER_OBJECT(ln, struct client, clients_list_node);
        
        for (LinkedList1Node *ln2 = LinkedList1_GetFirst(&client->connections_list); ln2; ln2 = LinkedList1Node_Next(ln2)) {
            struct connection *con = UPPER_OBJECT(ln2, struct connection, connections_list_node);
            ASSERT(con->client == client)
            ASSERT(!con->closing)
            
            if (con->addr.type != remote_addr.type || con->local_port_index < 0) {
                continue;
            }
            ASSERT(con->local_port_index < local_num_ports)
            
            if (options.unique_local_ports) {
                BIPAddr ip1;
                BIPAddr ip2;
                BAddr_GetIPAddr(&con->addr, &ip1);
                BAddr_GetIPAddr(&remote_addr, &ip2);
                if (!BIPAddr_Compare(&ip1, &ip2)) {
                    continue;
                }
            } else {
                if (!BAddr_Compare(&con->addr, &remote_addr)) {
                    continue;
                }
            }
            
            port_usage[con->local_port_index] = 1;
            
            if (!PacketPassFairQueueFlow_IsBusy(&con->send_qflow)) {
                if (!least_con || con->last_use_time < least_con->last_use_time) {
                    least_con = con;
                }
            }
        }
    }
    
    *out_con = least_con;
    return port_usage;
}

void connection_init (struct client *client, uint16_t conid, BAddr addr, BAddr orig_addr, const uint8_t *data, int data_len)
{
    ASSERT(client->num_connections < options.max_connections_for_client)
    ASSERT(!find_connection(client, conid))
    BAddr_Assert(&addr);
    ASSERT(addr.type == BADDR_TYPE_IPV4 || addr.type == BADDR_TYPE_IPV6)
    ASSERT(orig_addr.type == BADDR_TYPE_IPV4 || orig_addr.type == BADDR_TYPE_IPV6)
    ASSERT(data_len >= 0)
    ASSERT(data_len <= options.udp_mtu)
    
    // allocate structure
    struct connection *con = (struct connection *)malloc(sizeof(*con));
    if (!con) {
        client_log(client, BLOG_ERROR, "malloc failed");
        goto fail0;
    }
    
    // init arguments
    con->client = client;
    con->conid = conid;
    con->addr = addr;
    con->orig_addr = orig_addr;
    con->first_data = data;
    con->first_data_len = data_len;
    
    // set last use time
    con->last_use_time = btime_gettime();
    
    // set not closing
    con->closing = 0;
    
    // init first job
    BPending_Init(&con->first_job, BReactor_PendingGroup(&ss), (BPending_handler)connection_first_job_handler, con);
    BPending_Set(&con->first_job);
    
    // init send queue flow
    PacketPassFairQueueFlow_Init(&con->send_qflow, &client->send_queue);
    
    // init send PacketProtoFlow
    if (!PacketProtoFlow_Init(&con->send_ppflow, udpgw_mtu, CONNECTION_CLIENT_BUFFER_SIZE, PacketPassFairQueueFlow_GetInput(&con->send_qflow), BReactor_PendingGroup(&ss))) {
        client_log(client, BLOG_ERROR, "PacketProtoFlow_Init failed");
        goto fail1;
    }
    con->send_if = PacketProtoFlow_GetInput(&con->send_ppflow);
    
    // init UDP dgram
    if (!BDatagram_Init(&con->udp_dgram, addr.type, &ss, con, (BDatagram_handler)connection_dgram_handler_event)) {
        client_log(client, BLOG_ERROR, "BDatagram_Init failed");
        goto fail2;
    }
    
    con->local_port_index = -1;
    
    int local_num_ports = get_local_num_ports(addr.type);
    
    if (local_num_ports >= 0) {
        // build port usage array, find least used connection
        struct connection *least_con;
        uint8_t *port_usage = build_port_usage_array_and_find_least_used_connection(addr, &least_con);
        if (!port_usage) {
            client_log(client, BLOG_ERROR, "build_port_usage_array failed");
            goto failed;
        }
        
        // set SO_REUSEADDR
        if (!BDatagram_SetReuseAddr(&con->udp_dgram, 1)) {
            client_log(client, BLOG_ERROR, "set SO_REUSEADDR failed");
            goto failed;
        }
        
        // get starting local address
        BAddr local_addr = get_local_addr(addr.type);
        
        // try different ports
        for (int i = 0; i < local_num_ports; i++) {
            // skip inappropriate ports
            if (port_usage[i]) {
                continue;
            }
            
            BAddr bind_addr = local_addr;
            BAddr_SetPort(&bind_addr, hton16(ntoh16(BAddr_GetPort(&bind_addr)) + (uint16_t)i));
            if (BDatagram_Bind(&con->udp_dgram, bind_addr)) {
                // remember which port we're using
                con->local_port_index = i;
                goto cont;
            }
        }
        
        // try closing an unused connection with the same remote addr
        if (!least_con) {
            goto failed;
        }
        
        ASSERT(least_con->addr.type == addr.type)
        ASSERT(least_con->local_port_index >= 0)
        ASSERT(least_con->local_port_index < local_num_ports)
        ASSERT(!PacketPassFairQueueFlow_IsBusy(&least_con->send_qflow))
        
        int i = least_con->local_port_index;
        
        BLog(BLOG_INFO, "closing connection for its remote address");
        
        // close the offending connection
        connection_close(least_con);
        
        // try binding to its port
        BAddr bind_addr = local_addr;
        BAddr_SetPort(&bind_addr, hton16(ntoh16(BAddr_GetPort(&bind_addr)) + (uint16_t)i));
        if (BDatagram_Bind(&con->udp_dgram, bind_addr)) {
            // remember which port we're using
            con->local_port_index = i;
            goto cont;
        }
        
    failed:
        client_log(client, BLOG_WARNING, "failed to bind to any local address; proceeding regardless");
    cont:;
        BFree(port_usage);
    }
    
    // set UDP dgram send address
    BIPAddr ipaddr;
    BIPAddr_InitInvalid(&ipaddr);
    BDatagram_SetSendAddrs(&con->udp_dgram, addr, ipaddr);
    
    // init UDP dgram interfaces
    BDatagram_SendAsync_Init(&con->udp_dgram, options.udp_mtu);
    BDatagram_RecvAsync_Init(&con->udp_dgram, options.udp_mtu);
    
    // init UDP writer
    BufferWriter_Init(&con->udp_send_writer, options.udp_mtu, BReactor_PendingGroup(&ss));
    
    // init UDP buffer
    if (!PacketBuffer_Init(&con->udp_send_buffer, BufferWriter_GetOutput(&con->udp_send_writer), BDatagram_SendAsync_GetIf(&con->udp_dgram), CONNECTION_UDP_BUFFER_SIZE, BReactor_PendingGroup(&ss))) {
        client_log(client, BLOG_ERROR, "PacketBuffer_Init failed");
        goto fail4;
    }
    
    // init UDP recv interface
    PacketPassInterface_Init(&con->udp_recv_if, options.udp_mtu, (PacketPassInterface_handler_send)connection_udp_recv_if_handler_send, con, BReactor_PendingGroup(&ss));
    
    // init UDP recv buffer
    if (!SinglePacketBuffer_Init(&con->udp_recv_buffer, BDatagram_RecvAsync_GetIf(&con->udp_dgram), &con->udp_recv_if, BReactor_PendingGroup(&ss))) {
        client_log(client, BLOG_ERROR, "SinglePacketBuffer_Init failed");
        goto fail5;
    }
    
    // insert to client's connections tree
    ASSERT_EXECUTE(BAVL_Insert(&client->connections_tree, &con->connections_tree_node, NULL))
    
    // insert to client's connections list
    LinkedList1_Append(&client->connections_list, &con->connections_list_node);
    
    // increment number of connections
    client->num_connections++;
    
    connection_log(con, BLOG_DEBUG, "initialized");
    
    return;
    
fail5:
    PacketPassInterface_Free(&con->udp_recv_if);
    PacketBuffer_Free(&con->udp_send_buffer);
fail4:
    BufferWriter_Free(&con->udp_send_writer);
    BDatagram_RecvAsync_Free(&con->udp_dgram);
    BDatagram_SendAsync_Free(&con->udp_dgram);
    BDatagram_Free(&con->udp_dgram);
fail2:
    PacketProtoFlow_Free(&con->send_ppflow);
fail1:
    PacketPassFairQueueFlow_Free(&con->send_qflow);
    BPending_Free(&con->first_job);
    free(con);
fail0:
    return;
}

void connection_free (struct connection *con)
{
    struct client *client = con->client;
    PacketPassFairQueueFlow_AssertFree(&con->send_qflow);
    
    if (con->closing) {
        // remove from client's closing connections list
        LinkedList1_Remove(&client->closing_connections_list, &con->closing_connections_list_node);
    } else {
        // decrement number of connections
        client->num_connections--;
        
        // remove from client's connections list
        LinkedList1_Remove(&client->connections_list, &con->connections_list_node);
        
        // remove from client's connections tree
        BAVL_Remove(&client->connections_tree, &con->connections_tree_node);
        
        // free UDP
        connection_free_udp(con);
    }
    
    // free send PacketProtoFlow
    PacketProtoFlow_Free(&con->send_ppflow);
    
    // free send queue flow
    PacketPassFairQueueFlow_Free(&con->send_qflow);
    
    // free first job
    BPending_Free(&con->first_job);
    
    // free structure
    free(con);
}

void connection_logfunc (struct connection *con)
{
    client_logfunc(con->client);
    
    if (con->closing) {
        BLog_Append("old connection %"PRIu16": ", con->conid);
    } else {
        BLog_Append("connection %"PRIu16": ", con->conid);
    }
}

void connection_log (struct connection *con, int level, const char *fmt, ...)
{
    va_list vl;
    va_start(vl, fmt);
    BLog_LogViaFuncVarArg((BLog_logfunc)connection_logfunc, con, BLOG_CURRENT_CHANNEL, level, fmt, vl);
    va_end(vl);
}

void connection_free_udp (struct connection *con)
{
    // free UDP receive buffer
    SinglePacketBuffer_Free(&con->udp_recv_buffer);
    
    // free UDP receive interface
    PacketPassInterface_Free(&con->udp_recv_if);
    
    // free UDP buffer
    PacketBuffer_Free(&con->udp_send_buffer);
    
    // free UDP writer
    BufferWriter_Free(&con->udp_send_writer);
    
    // free UDP dgram interfaces
    BDatagram_RecvAsync_Free(&con->udp_dgram);
    BDatagram_SendAsync_Free(&con->udp_dgram);
    
    // free UDP dgram
    BDatagram_Free(&con->udp_dgram);
}

void connection_first_job_handler (struct connection *con)
{
    ASSERT(!con->closing)
    
    connection_send_to_udp(con, con->first_data, con->first_data_len);
}

void connection_send_to_client (struct connection *con, uint8_t flags, const uint8_t *data, int data_len)
{
    ASSERT(data_len >= 0)
    ASSERT(data_len <= options.udp_mtu)
    
    size_t addr_len = (con->orig_addr.type == BADDR_TYPE_IPV6) ? sizeof(struct udpgw_addr_ipv6) :
                      (con->orig_addr.type == BADDR_TYPE_IPV4) ? sizeof(struct udpgw_addr_ipv4) : 0;
    if (data_len > udpgw_mtu - (int)(sizeof(struct udpgw_header) + addr_len)) {
        connection_log(con, BLOG_WARNING, "packet is too large, cannot send to client");
        return;
    }
    
    // get buffer location
    uint8_t *out;
    if (!BufferWriter_StartPacket(con->send_if, &out)) {
        connection_log(con, BLOG_ERROR, "out of client buffer");
        return;
    }
    int out_pos = 0;
    
    if (con->orig_addr.type == BADDR_TYPE_IPV6) {
        flags |= UDPGW_CLIENT_FLAG_IPV6;
    }
    
    // write header
    struct udpgw_header header;
    header.flags = htol8(flags);
    header.conid = htol16(con->conid);
    memcpy(out + out_pos, &header, sizeof(header));
    out_pos += sizeof(header);
    
    // write address
    switch (con->orig_addr.type) {
        case BADDR_TYPE_IPV4: {
            struct udpgw_addr_ipv4 addr_ipv4;
            addr_ipv4.addr_ip = con->orig_addr.ipv4.ip;
            addr_ipv4.addr_port = con->orig_addr.ipv4.port;
            memcpy(out + out_pos, &addr_ipv4, sizeof(addr_ipv4));
            out_pos += sizeof(addr_ipv4);
        } break;
        case BADDR_TYPE_IPV6: {
            struct udpgw_addr_ipv6 addr_ipv6;
            memcpy(addr_ipv6.addr_ip, con->orig_addr.ipv6.ip, sizeof(addr_ipv6.addr_ip));
            addr_ipv6.addr_port = con->orig_addr.ipv6.port;
            memcpy(out + out_pos, &addr_ipv6, sizeof(addr_ipv6));
            out_pos += sizeof(addr_ipv6);
        } break;
    }
    
    // write message
    memcpy(out + out_pos, data, data_len);
    out_pos += data_len;
    
    // submit written message
    ASSERT(out_pos <= udpgw_mtu)
    BufferWriter_EndPacket(con->send_if, out_pos);
}

int connection_send_to_udp (struct connection *con, const uint8_t *data, int data_len)
{
    struct client *client = con->client;
    ASSERT(!con->closing)
    ASSERT(data_len >= 0)
    ASSERT(data_len <= options.udp_mtu)
    
    connection_log(con, BLOG_DEBUG, "from client %d bytes", data_len);
    
    // set last use time
    con->last_use_time = btime_gettime();
    
    // move connection to front
    LinkedList1_Remove(&client->connections_list, &con->connections_list_node);
    LinkedList1_Append(&client->connections_list, &con->connections_list_node);
    
    // get buffer location
    uint8_t *out;
    if (!BufferWriter_StartPacket(&con->udp_send_writer, &out)) {
        connection_log(con, BLOG_ERROR, "out of UDP buffer");
        return 0;
    }
    
    // write message
    memcpy(out, data, data_len);
    
    // submit written message
    BufferWriter_EndPacket(&con->udp_send_writer, data_len);
    
    return 1;
}

void connection_close (struct connection *con)
{
    struct client *client = con->client;
    ASSERT(!con->closing)
    
    // if possible, free connection immediately
    if (!PacketPassFairQueueFlow_IsBusy(&con->send_qflow)) {
        connection_free(con);
        return;
    }
    
    connection_log(con, BLOG_DEBUG, "closing later");
    
    // decrement number of connections
    client->num_connections--;
    
    // remove from client's connections list
    LinkedList1_Remove(&client->connections_list, &con->connections_list_node);
    
    // remove from client's connections tree
    BAVL_Remove(&client->connections_tree, &con->connections_tree_node);
    
    // free UDP
    connection_free_udp(con);
    
    // insert to client's closing connections list
    LinkedList1_Append(&client->closing_connections_list, &con->closing_connections_list_node);
    
    // set busy handler
    PacketPassFairQueueFlow_SetBusyHandler(&con->send_qflow, (PacketPassFairQueue_handler_busy)connection_send_qflow_busy_handler, con);
    
    // unset first job
    BPending_Unset(&con->first_job);
    
    // set closing
    con->closing = 1;
}

void connection_send_qflow_busy_handler (struct connection *con)
{
    ASSERT(con->closing)
    PacketPassFairQueueFlow_AssertFree(&con->send_qflow);
    
    connection_log(con, BLOG_DEBUG, "closing finally");
    
    // free connection
    connection_free(con);
}

void connection_dgram_handler_event (struct connection *con, int event)
{
    ASSERT(!con->closing)
    
    connection_log(con, BLOG_INFO, "UDP error");
    
    // close connection
    connection_close(con);
}

void connection_udp_recv_if_handler_send (struct connection *con, uint8_t *data, int data_len)
{
    struct client *client = con->client;
    ASSERT(!con->closing)
    ASSERT(data_len >= 0)
    ASSERT(data_len <= options.udp_mtu)
    
    connection_log(con, BLOG_DEBUG, "from UDP %d bytes", data_len);
    
    // set last use time
    con->last_use_time = btime_gettime();
    
    // move connection to front
    LinkedList1_Remove(&client->connections_list, &con->connections_list_node);
    LinkedList1_Append(&client->connections_list, &con->connections_list_node);
    
    // accept packet
    PacketPassInterface_Done(&con->udp_recv_if);
    
    // send packet to client
    connection_send_to_client(con, 0, data, data_len);
}

struct connection * find_connection (struct client *client, uint16_t conid)
{
    BAVLNode *tree_node = BAVL_LookupExact(&client->connections_tree, &conid);
    if (!tree_node) {
        return NULL;
    }
    struct connection *con = UPPER_OBJECT(tree_node, struct connection, connections_tree_node);
    ASSERT(con->conid == conid)
    ASSERT(!con->closing)
    
    return con;
}

int uint16_comparator (void *unused, uint16_t *v1, uint16_t *v2)
{
    return B_COMPARE(*v1, *v2);
}

void maybe_update_dns (void)
{
#ifndef BADVPN_USE_WINAPI
    btime_t now = btime_gettime();
    if (now < btime_add(last_dns_update_time, DNS_UPDATE_TIME)) {
        return;
    }
    last_dns_update_time = now;
    BLog(BLOG_DEBUG, "update dns");
    
    if (res_init() != 0) {
        BLog(BLOG_ERROR, "res_init failed");
        goto fail;
    }
    
    if (_res.nscount == 0) {
        BLog(BLOG_ERROR, "no name servers available");
        goto fail;
    }
    
    BAddr addr;
    BAddr_InitIPv4(&addr, _res.nsaddr_list[0].sin_addr.s_addr, hton16(53));
    
    if (!BAddr_Compare(&addr, &dns_addr)) {
        char str[BADDR_MAX_PRINT_LEN];
        BAddr_Print(&addr, str);
        BLog(BLOG_INFO, "using DNS server %s", str);
    }
    
    dns_addr = addr;
    return;
    
fail:
    BAddr_InitNone(&dns_addr);
#endif
}