/* srputil.c
 *
 * Copyright (c) 2020-2024 Apple Inc. All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * SRP Advertising Proxy utility program, allows:
 *   start/stop advertising proxy
 *   get/track list of service types
 *   get/track list of services of a particular type
 *   get/track list of hosts
 *   get/track information about a particular host
 */

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <time.h>
#include <dns_sd.h>
#include <net/if.h>
#include <inttypes.h>

void *main_queue = NULL;

#include "srp.h"
#include "dns-msg.h"
#include "ioloop.h"
#include "advertising_proxy_services.h"
#include "route-tracker.h"
#include "state-machine.h"
#include "thread-service.h"
#include "service-tracker.h"
#include "probe-srp.h"
#include "cti-services.h"
#include "adv-ctl-server.h"


static void
flushed_callback(advertising_proxy_conn_ref cref, void *result, advertising_proxy_error_type err)
{
    INFO("flushed: cref %p  response %p   err %d.", cref, result, err);
    if (err != kDNSSDAdvertisingProxyStatus_NoError) {
        exit(1);
    }
    // We don't need to wait around after flushing.
    exit(0);
}

static void
block_callback(advertising_proxy_conn_ref cref, void *result, advertising_proxy_error_type err)
{
    INFO("blocked: cref %p  response %p   err %d.", cref, result, err);
    if (err != kDNSSDAdvertisingProxyStatus_NoError) {
        exit(1);
    }
    // We don't need to wait around after blocking.
    exit(0);
}

static void
unblock_callback(advertising_proxy_conn_ref cref, void *result, advertising_proxy_error_type err)
{
    INFO("unblocked: cref %p  response %p   err %d.", cref, result, err);
    if (err != kDNSSDAdvertisingProxyStatus_NoError) {
        exit(1);
    }
    // We don't need to wait around after unblocking.
    exit(0);
}

static void
regenerate_callback(advertising_proxy_conn_ref cref, void *result, advertising_proxy_error_type err)
{
    INFO("regenerated ula: cref %p  response %p   err %d.", cref, result, err);
    if (err != kDNSSDAdvertisingProxyStatus_NoError) {
        exit(1);
    }
    // We don't need to wait around after unblocking.
    exit(0);
}

static void
prefix_advertise_callback(advertising_proxy_conn_ref cref, void *result, advertising_proxy_error_type err)
{
    INFO("advertise prefix: cref %p  response %p   err %d.", cref, result, err);
    if (err != kDNSSDAdvertisingProxyStatus_NoError) {
        exit(1);
    }
    // We don't need to wait around after advertising prefix.
    exit(0);
}

static void
add_prefix_callback(advertising_proxy_conn_ref cref, void *result, advertising_proxy_error_type err)
{
    INFO("add prefix: cref %p  response %p   err %d.", cref, result, err);
    if (err != kDNSSDAdvertisingProxyStatus_NoError) {
        exit(1);
    }
    // We don't need to wait around after advertising prefix.
    exit(0);
}

static void
remove_prefix_callback(advertising_proxy_conn_ref cref, void *result, advertising_proxy_error_type err)
{
    INFO("remove prefix: cref %p  response %p   err %d.", cref, result, err);
    if (err != kDNSSDAdvertisingProxyStatus_NoError) {
        exit(1);
    }
    // We don't need to wait around after advertising prefix.
    exit(0);
}

static void
add_nat64_prefix_callback(advertising_proxy_conn_ref cref, void *result, advertising_proxy_error_type err)
{
    INFO("add nat64 prefix: cref %p  response %p   err %d.", cref, result, err);
    if (err != kDNSSDAdvertisingProxyStatus_NoError) {
        exit(1);
    }
    exit(0);
}

static void
remove_nat64_prefix_callback(advertising_proxy_conn_ref cref, void *result, advertising_proxy_error_type err)
{
    INFO("remove nat64 prefix: cref %p  response %p   err %d.", cref, result, err);
    if (err != kDNSSDAdvertisingProxyStatus_NoError) {
        exit(1);
    }
    exit(0);
}

static void
stop_callback(advertising_proxy_conn_ref cref, void *result, advertising_proxy_error_type err)
{
    INFO("stopped: cref %p  response %p   err %d.", cref, result, err);
    if (err != kDNSSDAdvertisingProxyStatus_NoError) {
        exit(1);
    }
    // We don't need to wait around after stopping.
    exit(0);
}

static const char *
print_address(advertising_proxy_host_address_t *address, char *addrbuf, size_t addrbuf_size)
{
    if (address->rrtype == 0) {
        return (char *)address->rdata;
    } else if (address->rrtype == dns_rrtype_a && address->rdlen == 4) {
        inet_ntop(AF_INET, address->rdata, addrbuf, (socklen_t)addrbuf_size);
        return addrbuf;
    } else if (address->rrtype == dns_rrtype_aaaa && address->rdlen == 16) {
        inet_ntop(AF_INET6, address->rdata, addrbuf, (socklen_t)addrbuf_size);
        return addrbuf;
    } else {
        sprintf(addrbuf, "Family-%d", address->rrtype);
        return addrbuf;
    }
}

static void
services_callback(advertising_proxy_conn_ref cref, void *result, advertising_proxy_error_type err)
{
    int i;
    int64_t lease, hours, minutes, seconds;
    advertising_proxy_host_t *host = result;
    const char *address = "<no address>";
    char *addrbuf = NULL;
    size_t addrbuflen;
    uint64_t ula;

    if (err != kDNSSDAdvertisingProxyStatus_NoError) {
        INFO("services: cref %p  response %p   err %d.", cref, result, err);
        exit(1);
    }
    if (result == NULL) {
        INFO("services: cref %p  response %p   err %d.", cref, result, err);
        exit(0);
    }

    if (host->num_instances == 0) {
        i = -1;
    } else {
        i = 0;
    }
    for (; i < host->num_instances; i++) {
        const char *instance_name, *service_type, *reg_type;
        char port[6]; // uint16_t as ascii

        if (i == -1 || host->instances[i].instance_name == NULL) {
            instance_name = "<no instances>";
            service_type = "";
            port[0] = 0;
            reg_type = "";
        } else {
            instance_name = host->instances[i].instance_name;
            service_type = host->instances[i].service_type;
            snprintf(port, sizeof(port), "%u", host->instances[i].port);
            reg_type = host->instances[i].reg_type;
        }

        if (host->num_addresses > 0) {
            addrbuflen = host->num_addresses * (INET6_ADDRSTRLEN + 1);
            addrbuf = malloc(addrbuflen);
            if (addrbuf == NULL) {
                address = "<no memory for address buffer>";
            } else {
                char *ap = addrbuf;
                for (int j = 0; j < host->num_addresses; j++) {
                    *ap++ = ' ';
                    address = print_address(&host->addresses[j], ap, addrbuflen - (ap - addrbuf));
                    size_t len = strlen(address);
                    if (address != ap) {
                        if (len + ap + 1 > addrbuf + addrbuflen) {
                            len = addrbuflen - (ap - addrbuf) - 1;
                        }
                        memcpy(ap, address, len + 1); // Includes NUL
                    }
                    ap += len;
                }
                address = addrbuf;
            }
        }
        lease = host->lease_time;
        hours = lease / 3600 / 1000;
        lease -= hours * 3600 * 1000;
        minutes = lease / 60 / 1000;
        lease -= minutes * 60 * 1000;
        seconds = lease / 1000;
        lease -= seconds * 1000;

        // Our implementation of the stable server ID uses the server ULA, so just copy out those 48 bits,
        // which are in network byte order.
        ula = 0;
        for (int j = 1; j < 6; j++) {
            ula = ula << 8 | (((uint8_t *)&host->server_id)[j]);
        }
        printf("\"%s\" \"%s\" %s %s %s %" PRIu64 ":%" PRIu64 ":%" PRIu64 ".%" PRIu64 " \"%s\" \"%s\" %s %" PRIx64 "\n",
               host->regname, instance_name, service_type, port,
               address == NULL ? "" : address, hours, minutes, seconds, lease, host->hostname,
               reg_type, host->removed ? "invalid" : "valid", ula);
        if (addrbuf != NULL) {
            free(addrbuf);
        }
    }
}

static void
ula_callback(advertising_proxy_conn_ref cref, void *result, advertising_proxy_error_type err)
{
    INFO("get_ula: cref %p  response %p   err %d.", cref, result, err);
    if (err != kDNSSDAdvertisingProxyStatus_NoError) {
        fprintf(stderr, "ULA get failed: %d\n", err);
        exit(1);
    }
    uint64_t ula = *((uint64_t *)result);
    printf("ULA: %" PRIx64 "\n", ula);
    exit(0);
}

static void
disable_srp_replication_callback(advertising_proxy_conn_ref cref, void *result, advertising_proxy_error_type err)
{
    INFO("disable_srp_replication: cref %p  response %p   err %d.", cref, result, err);
    if (err != kDNSSDAdvertisingProxyStatus_NoError) {
        exit(1);
    }
    // We don't need to wait around after SRP replication disabled.
    exit(0);
}

static void
drop_srpl_connection_callback(advertising_proxy_conn_ref cref, void *result, advertising_proxy_error_type err)
{
    INFO("drop_srpl_connection: cref %p  response %p   err %d.", cref, result, err);
    if (err != kDNSSDAdvertisingProxyStatus_NoError) {
        exit(1);
    }
    exit(0);
}

static void
undrop_srpl_connection_callback(advertising_proxy_conn_ref cref, void *result, advertising_proxy_error_type err)
{
    INFO("undrop_srpl_connection: cref %p  response %p   err %d.", cref, result, err);
    if (err != kDNSSDAdvertisingProxyStatus_NoError) {
        exit(1);
    }
    exit(0);
}

static void
drop_srpl_advertisement_callback(advertising_proxy_conn_ref cref, void *result, advertising_proxy_error_type err)
{
    INFO("drop_srpl_advertisement: cref %p  response %p   err %d.", cref, result, err);
    if (err != kDNSSDAdvertisingProxyStatus_NoError) {
        exit(1);
    }
    exit(0);
}

static void
undrop_srpl_advertisement_callback(advertising_proxy_conn_ref cref, void *result, advertising_proxy_error_type err)
{
    INFO("undrop_srpl_advertisement: cref %p  response %p   err %d.", cref, result, err);
    if (err != kDNSSDAdvertisingProxyStatus_NoError) {
        exit(1);
    }
    exit(0);
}

static void
start_dropping_push_connections_callback(advertising_proxy_conn_ref cref, void *result, advertising_proxy_error_type err)
{
    INFO("start_dropping_push_connections: cref %p  response %p   err %d.", cref, result, err);
    if (err != kDNSSDAdvertisingProxyStatus_NoError) {
        exit(1);
    }
    exit(0);
}

static void
start_breaking_time_validation_callback(advertising_proxy_conn_ref cref, void *result, advertising_proxy_error_type err)
{
    INFO("start_breaking_time_validation: cref %p  response %p   err %d.", cref, result, err);
    if (err != kDNSSDAdvertisingProxyStatus_NoError) {
        exit(1);
    }
    exit(0);
}

static void
block_anycast_service_callback(advertising_proxy_conn_ref cref, void *result, advertising_proxy_error_type err)
{
    INFO("block_anycast_service: cref %p  response %p   err %d.", cref, result, err);
    if (err != kDNSSDAdvertisingProxyStatus_NoError) {
        exit(1);
    }
    exit(0);
}

static void
unblock_anycast_service_callback(advertising_proxy_conn_ref cref, void *result, advertising_proxy_error_type err)
{
    INFO("unblock_anycast_service: cref %p  response %p   err %d.", cref, result, err);
    if (err != kDNSSDAdvertisingProxyStatus_NoError) {
        exit(1);
    }
    exit(0);
}

static void
start_thread_shutdown_callback(advertising_proxy_conn_ref cref, void *result, advertising_proxy_error_type err)
{
    INFO("cref %p  response %p   err %d.", cref, result, err);
    if (err != kDNSSDAdvertisingProxyStatus_NoError) {
        exit(1);
    }
    exit(0);
}

typedef struct variable variable_t;
struct variable {
    variable_t *next;
    const char *name, *value;
};

static void
set_variable_callback(advertising_proxy_conn_ref cref, void *context, void *result, advertising_proxy_error_type err)
{
    variable_t *variable = context;
    INFO("set_variable: cref %p  response %p   err %d, variable name %s, value %s.",
         cref, result, err, variable->name, variable->value);
    if (err != kDNSSDAdvertisingProxyStatus_NoError) {
        if (variable->next == NULL) {
            exit(1);
        }
    }
    if (variable->next == NULL) {
        exit(0);
    }
}

static comm_t *tcp_connection;
bool do_tcp_zero_test = false;
bool do_tcp_fin_length = false;
bool do_tcp_fin_payload = false;

service_tracker_t *tracker;

// Dummy functions required to use service tracker here
void
adv_ctl_thread_shutdown_status_check(srp_server_t *UNUSED server_state) {
}

static void
service_done_callback(void *context, cti_status_t status)
{
    const char *action = context;
    if (status != kCTIStatus_NoError) {
        fprintf(stderr, PUB_S_SRP " failed, status %d", action, status);
        exit(1);
    } else {
        fprintf(stderr, PUB_S_SRP " done", action);
        exit(0);
    }
}

static void
service_set_changed(bool unicast)
{
    thread_service_t *winner = NULL;
    for (thread_service_t *service = service_tracker_services_get(tracker); service != NULL; service = service->next) {
        if (service->ignore) {
            continue;
        }
        if (unicast && service->service_type == unicast_service) {
            if (winner == NULL || in6addr_compare(&service->u.unicast.address, &winner->u.unicast.address) < 0) {
                winner = service;
            }
        }
    }
    if (winner == NULL) {
        fprintf(stderr, "no services present!");
        exit(1);
    }
    winner->u.unicast.address.s6_addr[15] = 0;
    uint8_t service_data[1] = { THREAD_SRP_SERVER_OPTION };
    uint8_t server_data[18];
    memcpy(server_data, &winner->u.unicast.address, 15);
    server_data[15] = 0;
    server_data[16] = winner->u.unicast.port[0];
    server_data[17] = winner->u.unicast.port[1];
    int ret = cti_add_service(NULL, "add", service_done_callback, NULL,
                              THREAD_ENTERPRISE_NUMBER, service_data, 1, server_data, 18);
    if (ret != kCTIStatus_NoError) {
        fprintf(stderr, "add_service failed: %d", ret);
        exit(1);
    }
}

static void
unicast_service_set_changed(void *UNUSED context)
{
    service_set_changed(true);
}

static void
start_advertising_winning_unicast_service(void)
{
    tracker = service_tracker_create(NULL);
    if (tracker != NULL) {
        service_tracker_callback_add(tracker, unicast_service_set_changed, NULL, NULL);
        service_tracker_start(tracker);
    } else {
        fprintf(stderr, "unable to allocate tracker");
        exit(1);
    }
}

static void
start_removing_unicast_service(void)
{
    uint8_t service_data[1] = { THREAD_SRP_SERVER_OPTION };
    int ret = cti_remove_service(NULL, "remove", service_done_callback, NULL, THREAD_ENTERPRISE_NUMBER, service_data, 1);
    if (ret != kCTIStatus_NoError) {
        fprintf(stderr, "remove_service failed: %d", ret);
        exit(1);
    }
}

static void
tcp_datagram_callback(comm_t *NONNULL comm, message_t *NONNULL message, void *NULLABLE context)
{
    (void)comm;
    (void)context;
    fprintf(stderr, "tcp datagram received, length %d", message->length);
}

static void
tcp_connect_callback(comm_t *NONNULL connection, void *NULLABLE context)
{
    fprintf(stderr, "tcp connection succeeded...\n");
    uint8_t length[2];
    struct iovec iov[2];
    char databuf[128];
    memset(databuf, 0, sizeof(databuf));
    memset(iov, 0, sizeof(iov));

    (void)context;

    if (do_tcp_zero_test) {
        memset(length, 0, sizeof(length));
        iov[0].iov_len = 2;
        iov[0].iov_base = length;
        ioloop_send_data(connection, NULL, iov, 1);
    } else if (do_tcp_fin_length) {
        memset(length, 0, sizeof(length));
        iov[0].iov_len = 1;
        iov[0].iov_base = &length;
        ioloop_send_final_data(connection, NULL, iov, 1);
    } else if (do_tcp_fin_payload) {
        length[0] = 0;
        length[1] = 255;
        iov[0].iov_len = 2;
        iov[0].iov_base = length;
        iov[1].iov_len = 128;
        iov[1].iov_base = databuf;
        ioloop_send_final_data(connection, NULL, iov, 2);
    }
}

static void
tcp_disconnect_callback(comm_t *NONNULL comm, void *NULLABLE context, int error)
{
    (void)comm;
    (void)context;
    (void)error;
    fprintf(stderr, "tcp remote close.\n");
    exit(0);
}

static int
start_tcp_test(void)
{
    addr_t address;
    memset(&address, 0, sizeof(address));
    address.sa.sa_family = AF_INET;
    address.sin.sin_addr.s_addr = htonl(0x7f000001);
    address.sin.sin_port = htons(53);
#ifndef NOT_HAVE_SA_LEN
    address.sin.sin_len = sizeof(address.sin);
#endif
    tcp_connection = ioloop_connection_create(&address, false, true, false, false, tcp_datagram_callback,
                                              tcp_connect_callback, tcp_disconnect_callback, NULL, NULL);
    if (tcp_connection == NULL) {
        return kDNSSDAdvertisingProxyStatus_NoMemory;
    }
    return kDNSSDAdvertisingProxyStatus_NoError;
}

const char *need_name, *need_service;
bool needed_flag;

advertising_proxy_conn_ref service_sub;

static void
service_callback(advertising_proxy_conn_ref UNUSED sub, void *UNUSED context, advertising_proxy_error_type error)
{
    fprintf(stderr, "service callback: %d\n", error);
    exit(0);
}

static void
start_needing_service(void)
{
    advertising_proxy_error_type ret = advertising_proxy_set_service_needed(&service_sub, dispatch_get_main_queue(),
                                                                            service_callback, NULL, NULL, need_service,
                                                                            needed_flag);
    if (ret != kDNSSDAdvertisingProxyStatus_NoError) {
        fprintf(stderr, "advertising_proxy_service_create failed: %d\n", ret);
        exit(1);
    }
}

advertising_proxy_conn_ref instance_sub;

static void
instance_callback(advertising_proxy_conn_ref UNUSED sub, void *UNUSED context, advertising_proxy_error_type error)
{
    fprintf(stderr, "instance callback: %d\n", error);
    exit(0);
}

static void
start_needing_instance(void)
{
    advertising_proxy_error_type ret = advertising_proxy_set_service_needed(&instance_sub, dispatch_get_main_queue(),
                                                                            instance_callback, NULL, need_name,
                                                                            need_service, needed_flag);
    if (ret != kDNSSDAdvertisingProxyStatus_NoError) {
        fprintf(stderr, "advertising_proxy_set_service_needed failed: %d\n", ret);
        exit(1);
    }
}

const char *browse_service, *resolve_name, *resolve_service;

advertising_proxy_subscription_t *browse_sub;

static void
browse_callback(advertising_proxy_subscription_t *UNUSED sub, advertising_proxy_error_type error, uint32_t interface_index,
                bool add, const char *instance_name, const char *service_type, void *UNUSED context)
{
    if (error != kDNSSDAdvertisingProxyStatus_NoError) {
        fprintf(stderr, "browse_callback: %d\n", error);
        exit(1);
    }

    fprintf(stderr, "browse: %d %s %s %s\n", interface_index, add ? "add" : "rmv", instance_name, service_type);
}

static void
start_browsing_service(void)
{
    advertising_proxy_error_type ret = advertising_proxy_browse_create(&browse_sub, dispatch_get_main_queue(),
                                                                        browse_service, browse_callback, NULL);
    if (ret != kDNSSDAdvertisingProxyStatus_NoError) {
        fprintf(stderr, "advertising_proxy_browse_create failed: %d\n", ret);
        exit(1);
    }
}

advertising_proxy_subscription_t *resolve_sub;

static void
resolve_callback(advertising_proxy_subscription_t *UNUSED sub, advertising_proxy_error_type error,
                 uint32_t interface_index, bool add, const char *fullname, const char *hostname, uint16_t port,
                 uint16_t txt_length, const uint8_t *UNUSED txt_record, void *UNUSED context)
{
    if (error != kDNSSDAdvertisingProxyStatus_NoError) {
        fprintf(stderr, "resolve_create callback: %d\n", error);
        exit(1);
    }

    fprintf(stderr, "resolved: %d %s %s %s %d %d\n", interface_index, add ? "add" : "rmv",
            fullname, hostname, port, txt_length);
}

static void
start_resolving_service(void)
{
    advertising_proxy_error_type ret = advertising_proxy_resolve_create(&resolve_sub, dispatch_get_main_queue(),
                                                                        resolve_name, resolve_service, NULL,
                                                                        resolve_callback, NULL);
    if (ret != kDNSSDAdvertisingProxyStatus_NoError) {
        fprintf(stderr, "advertising_proxy_resolve_create failed: %d\n", ret);
        exit(1);
    }
}

advertising_proxy_subscription_t *registrar_sub;

static void
registrar_callback(advertising_proxy_subscription_t *UNUSED sub,
                   advertising_proxy_error_type error, void *UNUSED context)
{
    if (error != kDNSSDAdvertisingProxyStatus_NoError) {
        fprintf(stderr, "registrar_callback: %d\n", error);
        exit(1);
    }

    INFO("SRP registrar is enabled.");
}

static void
start_registrar(void)
{
    advertising_proxy_error_type ret = advertising_proxy_registrar_create(&registrar_sub, dispatch_get_main_queue(),
                                                                          registrar_callback, NULL);
    if (ret != kDNSSDAdvertisingProxyStatus_NoError) {
        fprintf(stderr, "advertising_proxy_registrar_create failed: %d", ret);
        exit(1);
    }
}


static void
usage(void)
{
    fprintf(stderr, "srputil start [if1 .. ifN -]            -- start the SRP MDNS Proxy through launchd\n");
    fprintf(stderr, "  tcp-zero                              -- connect to port 53, send a DNS message that's got a zero-length payload\n");
    fprintf(stderr, "  tcp-fin-length                        -- connect to port 53, send a DNS message that ends before length is complete\n");
    fprintf(stderr, "  tcp-fin-payload                       -- connect to port 53, send a DNS message that ends before payload is complete\n");
    fprintf(stderr, "  services                              -- get the list of services currently being advertised\n");
    fprintf(stderr, "  block                                 -- block the SRP listener\n");
    fprintf(stderr, "  unblock                               -- unblock the SRP listener\n");
    fprintf(stderr, "  regenerate-ula                        -- generate a new ULA and restart the network\n");
    fprintf(stderr, "  adv-prefix-high                       -- advertise high-priority prefix to thread network\n");
    fprintf(stderr, "  adv-prefix                            -- advertise prefix to thread network\n");
    fprintf(stderr, "  stop                                  -- stop advertising as SRP server\n");
    fprintf(stderr, "  get-ula                               -- fetch the current ULA prefix configured on the SRP server\n");
    fprintf(stderr, "  disable-srpl                          -- disable SRP replication\n");
    fprintf(stderr, "  add-prefix <ipv6 prefix>              -- add an OMR prefix\n");
    fprintf(stderr, "  remove-prefix <ipv6 prefix            -- remove an OMR prefix\n");
    fprintf(stderr, "  add-nat64-prefix <nat64 prefix>       -- add an nat64 prefix\n");
    fprintf(stderr, "  remove-nat64-prefix <nat64 prefix>    -- remove an nat64 prefix\n");
    fprintf(stderr, "  drop-srpl-connection                  -- drop existing srp replication connections\n");
    fprintf(stderr, "  undrop-srpl-connection                -- restart srp replication connections that were dropped \n");
    fprintf(stderr, "  drop-srpl-advertisement               -- stop advertising srpl service (but keep it around)\n");
    fprintf(stderr, "  undrop-srpl-advertisement             -- resume advertising srpl service\n");
    fprintf(stderr, "  start-dropping-push                   -- start repeatedly dropping any active push connections after 90 seconds\n");
    fprintf(stderr, "  start-breaking-time                   -- start breaking time validation on replicated SRP registrations\n");
    fprintf(stderr, "  set [variable] [value]                -- set the value of variable to value (e.g. set min-lease-time 100)\n");
    fprintf(stderr, "  block-anycast-service                 -- block advertising anycast service\n");
    fprintf(stderr, "  unblock-anycast-service               -- unblock advertising anycast service\n");
    fprintf(stderr, "  start-thread-shutdown                 -- start thread network shutdown\n");
    fprintf(stderr, "  advertise-winning-unicast-service     -- advertise a unicast service that wins over the current service\n");
    fprintf(stderr, "  browse <service>                      -- start an advertising_proxy_browse on the specified service\n");
    fprintf(stderr, "  resolve <name> <service>              -- start an advertising_proxy_resolve on the specified service instance\n");
    fprintf(stderr, "  need-service <service> <flag>         -- signal to srp-mdns-proxy that we need to discover a service\n");
    fprintf(stderr, "  need-instance <name> <service> <flag> -- signal to srp-mdns-proxy that we need to discover a service\n");
    fprintf(stderr, "  start-srp                             -- on thread device, enable srp registration\n");
#ifdef NOTYET
    fprintf(stderr, "  flush                                 -- flush all entries from the SRP proxy (for testing only)\n");
#endif
}

bool start_proxy = false;
bool flush_entries = false;
bool list_services = false;
bool block = false;
bool unblock = false;
bool regenerate_ula = false;
bool adv_prefix = false;
bool adv_prefix_high = false;
bool stop_proxy = false;
bool dump_stdin = false;
bool get_ula = false;
bool disable_srp_replication = false;
bool dso_test = false;
bool drop_srpl_connection;
bool undrop_srpl_connection;
bool drop_srpl_advertisement;
bool undrop_srpl_advertisement;
bool start_dropping_push_connections;
bool add_thread_prefix = false;
bool remove_thread_prefix = false;
bool add_nat64_prefix = false;
bool remove_nat64_prefix = false;
bool start_breaking_time_validation = false;
bool test_route_tracker = false;
bool block_anycast_service = false;
bool unblock_anycast_service = false;
bool start_thread_shutdown = false;
bool advertise_winning_unicast_service = false;
bool remove_unicast_service = false;
bool start_srp = false;
uint8_t prefix_buf[16];
#ifdef NOTYET
bool watch = false;
bool get = false;
#endif
variable_t *variables;
int num_permitted_interfaces;
char **permitted_interfaces;

static void
start_activities(void *context)
{
    advertising_proxy_error_type err = kDNSSDAdvertisingProxyStatus_NoError;;
    advertising_proxy_conn_ref cref = NULL;
    (void)context;

    if (err == kDNSSDAdvertisingProxyStatus_NoError && flush_entries) {
        err = advertising_proxy_flush_entries(&cref, main_queue, flushed_callback);
    }
    if (err == kDNSSDAdvertisingProxyStatus_NoError && (do_tcp_zero_test ||
                                                        do_tcp_fin_length || do_tcp_fin_payload)) {
        err = start_tcp_test();
    }
    if (err == kDNSSDAdvertisingProxyStatus_NoError && list_services) {
        err = advertising_proxy_get_service_list(&cref, main_queue, services_callback);
    }
    if (err == kDNSSDAdvertisingProxyStatus_NoError && block) {
        err = advertising_proxy_block_service(&cref, main_queue, block_callback);
    }
    if (err == kDNSSDAdvertisingProxyStatus_NoError && unblock) {
        err = advertising_proxy_unblock_service(&cref, main_queue, unblock_callback);
    }
    if (err == kDNSSDAdvertisingProxyStatus_NoError && regenerate_ula) {
        err = advertising_proxy_regenerate_ula(&cref, main_queue, regenerate_callback);
    }
    if (err == kDNSSDAdvertisingProxyStatus_NoError && adv_prefix) {
        err = advertising_proxy_advertise_prefix(&cref, adv_prefix_high, main_queue, prefix_advertise_callback);
    }
    if (err == kDNSSDAdvertisingProxyStatus_NoError && stop_proxy) {
        err = advertising_proxy_stop(&cref, main_queue, stop_callback);
    }
    if (err == kDNSSDAdvertisingProxyStatus_NoError && get_ula) {
        err = advertising_proxy_get_ula(&cref, main_queue, ula_callback);
    }
    if (err == kDNSSDAdvertisingProxyStatus_NoError && disable_srp_replication) {
        err = advertising_proxy_disable_srp_replication(&cref, main_queue, disable_srp_replication_callback);
    }
    if (err == kDNSSDAdvertisingProxyStatus_NoError && add_thread_prefix) {
        err = advertising_proxy_add_prefix(&cref, main_queue, add_prefix_callback, prefix_buf, sizeof(prefix_buf));
    }
    if (err == kDNSSDAdvertisingProxyStatus_NoError && remove_thread_prefix) {
        err = advertising_proxy_remove_prefix(&cref, main_queue, remove_prefix_callback, prefix_buf, sizeof(prefix_buf));
    }
    if (err == kDNSSDAdvertisingProxyStatus_NoError && add_nat64_prefix) {
        err = advertising_proxy_add_nat64_prefix(&cref, main_queue, add_nat64_prefix_callback, prefix_buf, sizeof(prefix_buf));
    }
    if (err == kDNSSDAdvertisingProxyStatus_NoError && remove_nat64_prefix) {
        err = advertising_proxy_remove_nat64_prefix(&cref, main_queue, remove_nat64_prefix_callback, prefix_buf, sizeof(prefix_buf));
    }
    if (err == kDNSSDAdvertisingProxyStatus_NoError && drop_srpl_connection) {
        err = advertising_proxy_drop_srpl_connection(&cref, main_queue, drop_srpl_connection_callback);
    }
    if (err == kDNSSDAdvertisingProxyStatus_NoError && undrop_srpl_connection) {
        err = advertising_proxy_undrop_srpl_connection(&cref, main_queue, undrop_srpl_connection_callback);
    }
    if (err == kDNSSDAdvertisingProxyStatus_NoError && drop_srpl_advertisement) {
        err = advertising_proxy_drop_srpl_advertisement(&cref, main_queue, drop_srpl_advertisement_callback);
    }
    if (err == kDNSSDAdvertisingProxyStatus_NoError && undrop_srpl_advertisement) {
        err = advertising_proxy_undrop_srpl_advertisement(&cref, main_queue, undrop_srpl_advertisement_callback);
    }
    if (err == kDNSSDAdvertisingProxyStatus_NoError && start_dropping_push_connections) {
        err = advertising_proxy_start_dropping_push_connections(&cref, main_queue, start_dropping_push_connections_callback);
    }
    if (err == kDNSSDAdvertisingProxyStatus_NoError && start_breaking_time_validation) {
        err = advertising_proxy_start_breaking_time_validation(&cref, main_queue, start_breaking_time_validation_callback);
    }
    if (err == kDNSSDAdvertisingProxyStatus_NoError && block_anycast_service) {
        err = advertising_proxy_block_anycast_service(&cref, main_queue, block_anycast_service_callback);
    }
    if (err == kDNSSDAdvertisingProxyStatus_NoError && unblock_anycast_service) {
        err = advertising_proxy_unblock_anycast_service(&cref, main_queue, unblock_anycast_service_callback);
    }
    if (err == kDNSSDAdvertisingProxyStatus_NoError && start_thread_shutdown) {
        err = advertising_proxy_start_thread_shutdown(&cref, main_queue, start_thread_shutdown_callback);
    }
    if (err == kDNSSDAdvertisingProxyStatus_NoError && test_route_tracker) {
        route_tracker_test_start(1000);
    }
    if (err == kDNSSDAdvertisingProxyStatus_NoError && advertise_winning_unicast_service) {
        start_advertising_winning_unicast_service();
    }
    if (err == kDNSSDAdvertisingProxyStatus_NoError && remove_unicast_service) {
        start_removing_unicast_service();
    }
    if (err == kDNSSDAdvertisingProxyStatus_NoError && advertise_winning_unicast_service) {
        start_advertising_winning_unicast_service();
    }
    if (err == kDNSSDAdvertisingProxyStatus_NoError && browse_service != NULL) {
        start_browsing_service();
    }
    if (err == kDNSSDAdvertisingProxyStatus_NoError && resolve_service != NULL) {
        start_resolving_service();
    }
    if (err == kDNSSDAdvertisingProxyStatus_NoError && need_service != NULL && need_name == NULL) {
        start_needing_service();
    }
    if (err == kDNSSDAdvertisingProxyStatus_NoError && need_service != NULL && need_name != NULL) {
        start_needing_instance();
    }
    if (err == kDNSSDAdvertisingProxyStatus_NoError && start_srp) {
        start_registrar();
    }
    if (err == kDNSSDAdvertisingProxyStatus_NoError && variables != NULL) {
        for (variable_t *variable = variables; variable != NULL; variable = variable->next) {
            err = advertising_proxy_set_variable(&cref, main_queue, set_variable_callback, variable, variable->name, variable->value);
            if (err != kDNSSDAdvertisingProxyStatus_NoError) {
                break;
            }
        }
    }
    if (err != kDNSSDAdvertisingProxyStatus_NoError) {
        exit(1);
    }
}

static void
dump_packet(void)
{
    ssize_t len;
    dns_message_t *message = NULL;
    dns_wire_t wire;

    len = read(0, &wire, sizeof(wire));
    if (len < 0) {
        ERROR("stdin: %s", strerror(errno));
        return;
    }
    if (len < DNS_HEADER_SIZE) {
        ERROR("stdin: too short: %zd bytes", len);
        return;
    }
    if (!dns_wire_parse(&message, &wire, (unsigned)len, true)) {
        fprintf(stderr, "DNS message parse failed\n");
        return;
    }
}

int
main(int argc, char **argv)
{
    int i;
    bool something = false;
    bool log_stderr = false;

    for (i = 1; i < argc; i++) {
        if (!strcmp(argv[i], "start")) {
			start_proxy = true;
            something = true;
            int j;
            for (j = i + 1; j < argc; j++) {
                if (!strcmp(argv[j], "-")) {
                    break;
                }
            }
            num_permitted_interfaces = j - i - 1;
            permitted_interfaces = argv + i + 1;
            i = j;
        } else if (!strcmp(argv[i], "tcp-zero")) {
            do_tcp_zero_test = true;
            something = true;
        } else if (!strcmp(argv[i], "tcp-fin-length")) {
            do_tcp_fin_length = true;
            something = true;
        } else if (!strcmp(argv[i], "tcp-fin-payload")) {
            do_tcp_fin_payload = true;
            something = true;
		} else if (!strcmp(argv[i], "flush")) {
            flush_entries = true;
            something = true;
		} else if (!strcmp(argv[i], "services")) {
            list_services = true;
            something = true;
		} else if (!strcmp(argv[i], "block")) {
            block = true;
            something = true;
		} else if (!strcmp(argv[i], "unblock")) {
            unblock = true;
            something = true;
		} else if (!strcmp(argv[i], "regenerate-ula")) {
            regenerate_ula = true;
            something = true;
        } else if (!strcmp(argv[i], "adv-prefix")) {
            adv_prefix = true;
            something = true;
        } else if (!strcmp(argv[i], "adv-prefix-high")) {
            adv_prefix = true;
            adv_prefix_high = true;
            something = true;
        } else if (!strcmp(argv[i], "stop")) {
            stop_proxy = true;
            something = true;
        } else if (!strcmp(argv[i], "dump")) {
            dump_packet();
            exit(0);
        } else if (!strcmp(argv[i], "get-ula")) {
            get_ula = true;
            something = true;
        } else if (!strcmp(argv[i], "disable-srpl")) {
            disable_srp_replication = true;
            something = true;
        } else if (!strcmp(argv[i], "add-prefix")) {
            if (i + 1 >= argc) {
                usage();
            }
            if (inet_pton(AF_INET6, argv[i + 1], prefix_buf) < 1) {
                fprintf(stderr, "Invalid ipv6 prefix %s.\n", argv[i + 1]);
                usage();
            } else {
                add_thread_prefix = true;
                something = true;
                i++;
            }
        } else if (!strcmp(argv[i], "remove-prefix")) {
            if (i + 1 >= argc) {
                usage();
            }
            if (inet_pton(AF_INET6, argv[i + 1], prefix_buf) < 1) {
                fprintf(stderr, "Invalid ipv6 prefix %s.\n", argv[i + 1]);
                usage();
            } else {
                remove_thread_prefix = true;
                something = true;
                i++;
            }
        } else if (!strcmp(argv[i], "add-nat64-prefix")) {
            if (i + 1 >= argc) {
                usage();
            }
            if (inet_pton(AF_INET6, argv[i + 1], prefix_buf) < 1) {
                fprintf(stderr, "Invalid ipv6 prefix %s.\n", argv[i + 1]);
                usage();
            } else {
                add_nat64_prefix = true;
                something = true;
                i++;
            }
        } else if (!strcmp(argv[i], "remove-nat64-prefix")) {
            if (i + 1 >= argc) {
                usage();
            }
            if (inet_pton(AF_INET6, argv[i + 1], prefix_buf) < 1) {
                fprintf(stderr, "Invalid ipv6 prefix %s.\n", argv[i + 1]);
                usage();
            } else {
                remove_nat64_prefix = true;
                something = true;
                i++;
            }
        } else if (!strcmp(argv[i], "browse")) {
            if (i + 1 >= argc) {
                usage();
            }
            browse_service = argv[i + 1];
            i++;
            something = true;
        } else if (!strcmp(argv[i], "resolve")) {
            if (i + 2 >= argc) {
                usage();
            }
            resolve_name = argv[i + 1];
            resolve_service = argv[i + 2];
            i += 2;
            something = true;
        } else if (!strcmp(argv[i], "need-service")) {
            if (i + 2 >= argc) {
                usage();
            }
            need_service = argv[i + 1];
            if (!strcmp(argv[i + 2], "true")) {
                needed_flag = true;
            } else {
                needed_flag = false;
            }
            i += 2;
            something = true;
        } else if (!strcmp(argv[i], "need-instance")) {
            if (i + 3 >= argc) {
                usage();
            }
            need_name = argv[i + 1];
            need_service = argv[i + 2];
            if (!strcmp(argv[i + 3], "true")) {
                needed_flag = true;
            } else {
                needed_flag = false;
            }
            i += 3;
            something = true;
        } else if (!strcmp(argv[i], "start-srp")) {
            start_srp = true;
            something = true;
        } else if (!strcmp(argv[i], "drop-srpl-connection")) {
            drop_srpl_connection = true;
            something = true;
        } else if (!strcmp(argv[i], "undrop-srpl-connection")) {
            undrop_srpl_connection = true;
            something = true;
        } else if (!strcmp(argv[i], "drop-srpl-advertisement")) {
            drop_srpl_advertisement = true;
            something = true;
        } else if (!strcmp(argv[i], "undrop-srpl-advertisement")) {
            undrop_srpl_advertisement = true;
            something = true;
        } else if (!strcmp(argv[i], "start-dropping-push")) {
            start_dropping_push_connections = true;
            something = true;
        } else if (!strcmp(argv[i], "start-breaking-time")) {
            start_breaking_time_validation = true;
            something = true;
        } else if (!strcmp(argv[i], "block-anycast-service")) {
            block_anycast_service = true;
            something = true;
        } else if (!strcmp(argv[i], "unblock-anycast-service")) {
            unblock_anycast_service = true;
            something = true;
        } else if (!strcmp(argv[i], "test-route-tracker")) {
            test_route_tracker = true;
            something = true;
        } else if (!strcmp(argv[i], "start-thread-shutdown")) {
            start_thread_shutdown = true;
            something = true;
        } else if (!strcmp(argv[i], "advertise-winning-unicast-service")) {
            advertise_winning_unicast_service = true;
            something = true;
        } else if (!strcmp(argv[i], "remove-unicast-service")) {
            remove_unicast_service = true;
            something = true;
        } else if (!strcmp(argv[i], "set")) {
            if (i + 2 >= argc) {
                usage();
            }
            variable_t *variable = calloc(1, sizeof(*variable));
            if (variable == NULL) {
                fprintf(stderr, "no memory for variable %s", argv[i + 1]);
                exit(1);
            }
            variable->name = argv[i + 1];
            variable->value = argv[i + 2];
            variable->next = variables;
            variables = variable;
            i += 2;
            something = true;
#ifdef NOTYET
		} else if (!strcmp(argv[i], "watch")) {
            fprintf(stderr, "Watching not implemented yet.\n");
            exit(1);
		} else if (!strcmp(argv[i], "get")) {
            fprintf(stderr, "Getting not implemented yet.\n");
            exit(1);
#endif
        } else if (!strcmp(argv[i], "--debug")) {
            OPENLOG("srputil", true);
            log_stderr = true;
        } else {
            usage();
            exit(1);
        }
    }

    if (!something) {
        usage();
        exit(1);
    }

    if (log_stderr == false) {
        OPENLOG("srputil", log_stderr);
    }

    ioloop_init();
    // Start the queue, //then// do the work
    ioloop_run_async(start_activities, NULL);
    ioloop();
}

// Local Variables:
// mode: C
// tab-width: 4
// c-file-style: "bsd"
// c-basic-offset: 4
// fill-column: 108
// indent-tabs-mode: nil
// End: