tor

control_cmd.c (72189B)

---

/* Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
* Copyright (c) 2007-2021, The Tor Project, Inc. */
/* See LICENSE for licensing information */

/**
* \file control_cmd.c
* \brief Implement various commands for Tor's control-socket interface.
**/

#define CONTROL_MODULE_PRIVATE
#define CONTROL_CMD_PRIVATE
#define CONTROL_EVENTS_PRIVATE

#include "core/or/or.h"
#include "app/config/config.h"
#include "lib/confmgt/confmgt.h"
#include "app/main/main.h"
#include "core/mainloop/connection.h"
#include "core/or/circuitbuild.h"
#include "core/or/circuitlist.h"
#include "core/or/circuituse.h"
#include "core/or/connection_edge.h"
#include "core/or/circuitstats.h"
#include "core/or/extendinfo.h"
#include "feature/client/addressmap.h"
#include "feature/client/dnsserv.h"
#include "feature/client/entrynodes.h"
#include "feature/control/control.h"
#include "feature/control/control_auth.h"
#include "feature/control/control_cmd.h"
#include "feature/control/control_hs.h"
#include "feature/control/control_events.h"
#include "feature/control/control_getinfo.h"
#include "feature/control/control_proto.h"
#include "feature/hs/hs_config.h"
#include "feature/hs/hs_control.h"
#include "feature/hs/hs_service.h"
#include "feature/nodelist/nodelist.h"
#include "feature/nodelist/routerinfo.h"
#include "feature/nodelist/routerlist.h"
#include "feature/rend/rendcommon.h"
#include "lib/crypt_ops/crypto_rand.h"
#include "lib/crypt_ops/crypto_util.h"
#include "lib/encoding/confline.h"
#include "lib/encoding/kvline.h"

#include "core/or/cpath_build_state_st.h"
#include "core/or/entry_connection_st.h"
#include "core/or/origin_circuit_st.h"
#include "core/or/socks_request_st.h"
#include "feature/control/control_cmd_args_st.h"
#include "feature/control/control_connection_st.h"
#include "feature/nodelist/node_st.h"
#include "feature/nodelist/routerinfo_st.h"

#include "app/config/statefile.h"

static int control_setconf_helper(control_connection_t *conn,
                                 const control_cmd_args_t *args,
                                 int use_defaults);

/** Yield true iff <b>s</b> is the state of a control_connection_t that has
* finished authentication and is accepting commands. */
#define STATE_IS_OPEN(s) ((s) == CONTROL_CONN_STATE_OPEN)

/**
* Release all storage held in <b>args</b>
**/
void
control_cmd_args_free_(control_cmd_args_t *args)
{
 if (! args)
   return;

 if (args->args) {
   SMARTLIST_FOREACH(args->args, char *, c, tor_free(c));
   smartlist_free(args->args);
 }
 config_free_lines(args->kwargs);
 tor_free(args->cmddata);

 tor_free(args);
}

/** Erase all memory held in <b>args</b>. */
void
control_cmd_args_wipe(control_cmd_args_t *args)
{
 if (!args)
   return;

 if (args->args) {
   SMARTLIST_FOREACH(args->args, char *, c, memwipe(c, 0, strlen(c)));
 }
 for (config_line_t *line = args->kwargs; line; line = line->next) {
   memwipe(line->key, 0, strlen(line->key));
   memwipe(line->value, 0, strlen(line->value));
 }
 if (args->cmddata)
   memwipe(args->cmddata, 0, args->cmddata_len);
}

/**
* Return true iff any element of the NULL-terminated <b>array</b> matches
* <b>kwd</b>. Case-insensitive.
**/
static bool
string_array_contains_keyword(const char **array, const char *kwd)
{
 for (unsigned i = 0; array[i]; ++i) {
   if (! strcasecmp(array[i], kwd))
     return true;
 }
 return false;
}

/** Helper for argument parsing: check whether the keyword arguments just
* parsed in <b>result</b> were well-formed according to <b>syntax</b>.
*
* On success, return 0.  On failure, return -1 and set *<b>error_out</b>
* to a newly allocated error string.
**/
static int
kvline_check_keyword_args(const control_cmd_args_t *result,
                         const control_cmd_syntax_t *syntax,
                         char **error_out)
{
 if (result->kwargs == NULL) {
   tor_asprintf(error_out, "Cannot parse keyword argument(s)");
   return -1;
 }

 if (! syntax->allowed_keywords) {
   /* All keywords are permitted. */
   return 0;
 }

 /* Check for unpermitted arguments */
 const config_line_t *line;
 for (line = result->kwargs; line; line = line->next) {
   if (! string_array_contains_keyword(syntax->allowed_keywords,
                                       line->key)) {
     tor_asprintf(error_out, "Unrecognized keyword argument %s",
                  escaped(line->key));
     return -1;
   }
 }

 return 0;
}

/**
* Helper: parse the arguments to a command according to <b>syntax</b>.  On
* success, set *<b>error_out</b> to NULL and return a newly allocated
* control_cmd_args_t.  On failure, set *<b>error_out</b> to newly allocated
* error string, and return NULL.
**/
STATIC control_cmd_args_t *
control_cmd_parse_args(const char *command,
                      const control_cmd_syntax_t *syntax,
                      size_t body_len,
                      const char *body,
                      char **error_out)
{
 *error_out = NULL;
 control_cmd_args_t *result = tor_malloc_zero(sizeof(control_cmd_args_t));
 const char *cmdline;
 char *cmdline_alloc = NULL;
 tor_assert(syntax->max_args < INT_MAX || syntax->max_args == UINT_MAX);

 result->command = command;

 if (syntax->store_raw_body) {
   tor_assert(body[body_len] == 0);
   result->raw_body = body;
 }

 const char *eol = memchr(body, '\n', body_len);
 if (syntax->want_cmddata) {
   if (! eol || (eol+1) == body+body_len) {
     *error_out = tor_strdup("Empty body");
     goto err;
   }
   cmdline_alloc = tor_memdup_nulterm(body, eol-body);
   cmdline = cmdline_alloc;
   ++eol;
   result->cmddata_len = read_escaped_data(eol, (body+body_len)-eol,
                                          &result->cmddata);
 } else {
   if (eol && (eol+1) != body+body_len) {
     *error_out = tor_strdup("Unexpected body");
     goto err;
   }
   cmdline = body;
 }

 result->args = smartlist_new();
 smartlist_split_string(result->args, cmdline, " ",
                        SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK,
                        (int)(syntax->max_args+1));
 size_t n_args = smartlist_len(result->args);
 if (n_args < syntax->min_args) {
   tor_asprintf(error_out, "Need at least %u argument(s)",
                syntax->min_args);
   goto err;
 } else if (n_args > syntax->max_args && ! syntax->accept_keywords) {
   tor_asprintf(error_out, "Cannot accept more than %u argument(s)",
                syntax->max_args);
   goto err;
 }

 if (n_args > syntax->max_args) {
   /* We have extra arguments after the positional arguments, and we didn't
      treat them as an error, so they must count as keyword arguments: Either
      K=V pairs, or flags, or both. */
   tor_assert(n_args == syntax->max_args + 1);
   tor_assert(syntax->accept_keywords);
   char *remainder = smartlist_pop_last(result->args);
   result->kwargs = kvline_parse(remainder, syntax->kvline_flags);
   tor_free(remainder);
   if (kvline_check_keyword_args(result, syntax, error_out) < 0) {
     goto err;
   }
 }

 tor_assert_nonfatal(*error_out == NULL);
 goto done;
err:
 tor_assert_nonfatal(*error_out != NULL);
 control_cmd_args_free(result);
done:
 tor_free(cmdline_alloc);
 return result;
}

/**
* Return true iff <b>lines</b> contains <b>flags</b> as a no-value
* (keyword-only) entry.
**/
static bool
config_lines_contain_flag(const config_line_t *lines, const char *flag)
{
 const config_line_t *line = config_line_find_case(lines, flag);
 return line && !strcmp(line->value, "");
}

static const control_cmd_syntax_t setconf_syntax = {
 .max_args=0,
 .accept_keywords=true,
 .kvline_flags=KV_OMIT_VALS|KV_QUOTED,
};

/** Called when we receive a SETCONF message: parse the body and try
* to update our configuration.  Reply with a DONE or ERROR message.
* Modifies the contents of body.*/
static int
handle_control_setconf(control_connection_t *conn,
                      const control_cmd_args_t *args)
{
 return control_setconf_helper(conn, args, 0);
}

static const control_cmd_syntax_t resetconf_syntax = {
 .max_args=0,
 .accept_keywords=true,
 .kvline_flags=KV_OMIT_VALS|KV_QUOTED,
};

/** Called when we receive a RESETCONF message: parse the body and try
* to update our configuration.  Reply with a DONE or ERROR message.
* Modifies the contents of body. */
static int
handle_control_resetconf(control_connection_t *conn,
                        const control_cmd_args_t *args)
{
 return control_setconf_helper(conn, args, 1);
}

static const control_cmd_syntax_t getconf_syntax = {
 .max_args=UINT_MAX
};

/** Called when we receive a GETCONF message.  Parse the request, and
* reply with a CONFVALUE or an ERROR message */
static int
handle_control_getconf(control_connection_t *conn,
                      const control_cmd_args_t *args)
{
 const smartlist_t *questions = args->args;
 smartlist_t *answers = smartlist_new();
 smartlist_t *unrecognized = smartlist_new();
 const or_options_t *options = get_options();

 SMARTLIST_FOREACH_BEGIN(questions, const char *, q) {
   if (!option_is_recognized(q)) {
     control_reply_add_printf(unrecognized, 552,
                              "Unrecognized configuration key \"%s\"", q);
   } else {
     config_line_t *answer = option_get_assignment(options,q);
     if (!answer) {
       const char *name = option_get_canonical_name(q);
       control_reply_add_one_kv(answers, 250, KV_OMIT_VALS, name, "");
     }

     while (answer) {
       config_line_t *next;
       control_reply_add_one_kv(answers, 250, KV_RAW, answer->key,
                                answer->value);
       next = answer->next;
       tor_free(answer->key);
       tor_free(answer->value);
       tor_free(answer);
       answer = next;
     }
   }
 } SMARTLIST_FOREACH_END(q);

 if (smartlist_len(unrecognized)) {
   control_write_reply_lines(conn, unrecognized);
 } else if (smartlist_len(answers)) {
   control_write_reply_lines(conn, answers);
 } else {
   send_control_done(conn);
 }

 control_reply_free(answers);
 control_reply_free(unrecognized);
 return 0;
}

static const control_cmd_syntax_t loadconf_syntax = {
 .want_cmddata = true
};

/** Called when we get a +LOADCONF message. */
static int
handle_control_loadconf(control_connection_t *conn,
                       const control_cmd_args_t *args)
{
 setopt_err_t retval;
 char *errstring = NULL;

 retval = options_init_from_string(NULL, args->cmddata,
                                   CMD_RUN_TOR, NULL, &errstring);

 if (retval != SETOPT_OK)
   log_warn(LD_CONTROL,
            "Controller gave us config file that didn't validate: %s",
            errstring);

#define SEND_ERRMSG(code, msg)                          \
 control_printf_endreply(conn, code, msg "%s%s",       \
                         errstring ? ": " : "",        \
                         errstring ? errstring : "")
 switch (retval) {
 case SETOPT_ERR_PARSE:
   SEND_ERRMSG(552, "Invalid config file");
   break;
 case SETOPT_ERR_TRANSITION:
   SEND_ERRMSG(553, "Transition not allowed");
   break;
 case SETOPT_ERR_SETTING:
   SEND_ERRMSG(553, "Unable to set option");
   break;
 case SETOPT_ERR_MISC:
 default:
   SEND_ERRMSG(550, "Unable to load config");
   break;
 case SETOPT_OK:
   send_control_done(conn);
   break;
 }
#undef SEND_ERRMSG
 tor_free(errstring);
 return 0;
}

static const control_cmd_syntax_t setevents_syntax = {
 .max_args = UINT_MAX
};

/** Called when we get a SETEVENTS message: update conn->event_mask,
* and reply with DONE or ERROR. */
static int
handle_control_setevents(control_connection_t *conn,
                        const control_cmd_args_t *args)
{
 int event_code;
 event_mask_t event_mask = 0;
 const smartlist_t *events = args->args;

 SMARTLIST_FOREACH_BEGIN(events, const char *, ev)
   {
     if (!strcasecmp(ev, "EXTENDED") ||
         !strcasecmp(ev, "AUTHDIR_NEWDESCS")) {
       log_warn(LD_CONTROL, "The \"%s\" SETEVENTS argument is no longer "
                "supported.", ev);
       continue;
     } else {
       int i;
       event_code = -1;

       for (i = 0; control_event_table[i].event_name != NULL; ++i) {
         if (!strcasecmp(ev, control_event_table[i].event_name)) {
           event_code = control_event_table[i].event_code;
           break;
         }
       }

       if (event_code == -1) {
         control_printf_endreply(conn, 552, "Unrecognized event \"%s\"", ev);
         return 0;
       }
     }
     event_mask |= (((event_mask_t)1) << event_code);
   }
 SMARTLIST_FOREACH_END(ev);

 conn->event_mask = event_mask;

 control_update_global_event_mask();
 send_control_done(conn);
 return 0;
}

static const control_cmd_syntax_t saveconf_syntax = {
 .max_args = 0,
 .accept_keywords = true,
 .kvline_flags=KV_OMIT_VALS,
};

/** Called when we get a SAVECONF command. Try to flush the current options to
* disk, and report success or failure. */
static int
handle_control_saveconf(control_connection_t *conn,
                       const control_cmd_args_t *args)
{
 bool force = config_lines_contain_flag(args->kwargs, "FORCE");
 const or_options_t *options = get_options();
 if ((!force && options->IncludeUsed) || options_save_current() < 0) {
   control_write_endreply(conn, 551,
                          "Unable to write configuration to disk.");
 } else {
   send_control_done(conn);
 }
 return 0;
}

static const control_cmd_syntax_t signal_syntax = {
 .min_args = 1,
 .max_args = 1,
};

/** Called when we get a SIGNAL command. React to the provided signal, and
* report success or failure. (If the signal results in a shutdown, success
* may not be reported.) */
static int
handle_control_signal(control_connection_t *conn,
                     const control_cmd_args_t *args)
{
 int sig = -1;
 int i;

 tor_assert(smartlist_len(args->args) == 1);
 const char *s = smartlist_get(args->args, 0);

 for (i = 0; signal_table[i].signal_name != NULL; ++i) {
   if (!strcasecmp(s, signal_table[i].signal_name)) {
     sig = signal_table[i].sig;
     break;
   }
 }

 if (sig < 0)
   control_printf_endreply(conn, 552, "Unrecognized signal code \"%s\"", s);
 if (sig < 0)
   return 0;

 send_control_done(conn);
 /* Flush the "done" first if the signal might make us shut down. */
 if (sig == SIGTERM || sig == SIGINT)
   connection_flush(TO_CONN(conn));

 activate_signal(sig);

 return 0;
}

static const control_cmd_syntax_t takeownership_syntax = {
 .max_args = UINT_MAX, // This should probably become zero. XXXXX
};

/** Called when we get a TAKEOWNERSHIP command.  Mark this connection
* as an owning connection, so that we will exit if the connection
* closes. */
static int
handle_control_takeownership(control_connection_t *conn,
                            const control_cmd_args_t *args)
{
 (void)args;

 conn->is_owning_control_connection = 1;

 log_info(LD_CONTROL, "Control connection %d has taken ownership of this "
          "Tor instance.",
          (int)(conn->base_.s));

 send_control_done(conn);
 return 0;
}

static const control_cmd_syntax_t dropownership_syntax = {
 .max_args = UINT_MAX, // This should probably become zero. XXXXX
};

/** Called when we get a DROPOWNERSHIP command.  Mark this connection
* as a non-owning connection, so that we will not exit if the connection
* closes. */
static int
handle_control_dropownership(control_connection_t *conn,
                            const control_cmd_args_t *args)
{
 (void)args;

 conn->is_owning_control_connection = 0;

 log_info(LD_CONTROL, "Control connection %d has dropped ownership of this "
          "Tor instance.",
          (int)(conn->base_.s));

 send_control_done(conn);
 return 0;
}

/** Given a text circuit <b>id</b>, return the corresponding circuit. */
static origin_circuit_t *
get_circ(const char *id)
{
 uint32_t n_id;
 int ok;
 n_id = (uint32_t) tor_parse_ulong(id, 10, 0, UINT32_MAX, &ok, NULL);
 if (!ok)
   return NULL;
 return circuit_get_by_global_id(n_id);
}

/** Given a text stream <b>id</b>, return the corresponding AP connection. */
static entry_connection_t *
get_stream(const char *id)
{
 uint64_t n_id;
 int ok;
 connection_t *conn;
 n_id = tor_parse_uint64(id, 10, 0, UINT64_MAX, &ok, NULL);
 if (!ok)
   return NULL;
 conn = connection_get_by_global_id(n_id);
 if (!conn || conn->type != CONN_TYPE_AP || conn->marked_for_close)
   return NULL;
 return TO_ENTRY_CONN(conn);
}

/** Helper for setconf and resetconf. Acts like setconf, except
* it passes <b>use_defaults</b> on to options_trial_assign().  Modifies the
* contents of body.
*/
static int
control_setconf_helper(control_connection_t *conn,
                      const control_cmd_args_t *args,
                      int use_defaults)
{
 setopt_err_t opt_err;
 char *errstring = NULL;
 const unsigned flags =
   CAL_CLEAR_FIRST | (use_defaults ? CAL_USE_DEFAULTS : 0);

 // We need a copy here, since confmgt.c wants to canonicalize cases.
 config_line_t *lines = config_lines_dup(args->kwargs);

 opt_err = options_trial_assign(lines, flags, &errstring);
 {
#define SEND_ERRMSG(code, msg)                                  \
   control_printf_endreply(conn, code, msg ": %s", errstring);

   switch (opt_err) {
     case SETOPT_ERR_MISC:
       SEND_ERRMSG(552, "Unrecognized option");
       break;
     case SETOPT_ERR_PARSE:
       SEND_ERRMSG(513, "Unacceptable option value");
       break;
     case SETOPT_ERR_TRANSITION:
       SEND_ERRMSG(553, "Transition not allowed");
       break;
     case SETOPT_ERR_SETTING:
     default:
       SEND_ERRMSG(553, "Unable to set option");
       break;
     case SETOPT_OK:
       config_free_lines(lines);
       send_control_done(conn);
       return 0;
   }
#undef SEND_ERRMSG
   log_warn(LD_CONTROL,
            "Controller gave us config lines that didn't validate: %s",
            errstring);
   config_free_lines(lines);
   tor_free(errstring);
   return 0;
 }
}

/** Return true iff <b>addr</b> is unusable as a mapaddress target because of
* containing funny characters. */
static int
address_is_invalid_mapaddress_target(const char *addr)
{
 if (!strcmpstart(addr, "*."))
   return address_is_invalid_destination(addr+2, 1);
 else
   return address_is_invalid_destination(addr, 1);
}

static const control_cmd_syntax_t mapaddress_syntax = {
 // no positional arguments are expected
 .max_args=0,
 // an arbitrary number of K=V entries are supported.
 .accept_keywords=true,
};

/** Called when we get a MAPADDRESS command; try to bind all listed addresses,
* and report success or failure. */
static int
handle_control_mapaddress(control_connection_t *conn,
                         const control_cmd_args_t *args)
{
 smartlist_t *reply;
 char *r;
 size_t sz;

 reply = smartlist_new();
 const config_line_t *line;
 for (line = args->kwargs; line; line = line->next) {
   const char *from = line->key;
   const char *to = line->value;
   {
     if (address_is_invalid_mapaddress_target(to)) {
       smartlist_add_asprintf(reply,
                    "512-syntax error: invalid address '%s'", to);
       log_warn(LD_CONTROL,
                "Skipping invalid argument '%s' in MapAddress msg", to);
     } else if (!strcmp(from, ".") || !strcmp(from, "0.0.0.0") ||
                !strcmp(from, "::")) {
       const char type =
         !strcmp(from,".") ? RESOLVED_TYPE_HOSTNAME :
         (!strcmp(from, "0.0.0.0") ? RESOLVED_TYPE_IPV4 : RESOLVED_TYPE_IPV6);
       const char *address = addressmap_register_virtual_address(
                                                    type, tor_strdup(to));
       if (!address) {
         smartlist_add_asprintf(reply,
                  "451-resource exhausted: skipping '%s=%s'", from,to);
         log_warn(LD_CONTROL,
                  "Unable to allocate address for '%s' in MapAddress msg",
                  safe_str_client(to));
       } else {
         smartlist_add_asprintf(reply, "250-%s=%s", address, to);
       }
     } else {
       const char *msg;
       if (addressmap_register_auto(from, to, 1,
                                    ADDRMAPSRC_CONTROLLER, &msg) < 0) {
         smartlist_add_asprintf(reply,
                                "512-syntax error: invalid address mapping "
                                " '%s=%s': %s", from, to, msg);
         log_warn(LD_CONTROL,
                  "Skipping invalid argument '%s=%s' in MapAddress msg: %s",
                  from, to, msg);
       } else {
         smartlist_add_asprintf(reply, "250-%s=%s", from, to);
       }
     }
   }
 }

 if (smartlist_len(reply)) {
   ((char*)smartlist_get(reply,smartlist_len(reply)-1))[3] = ' ';
   r = smartlist_join_strings(reply, "\r\n", 1, &sz);
   connection_buf_add(r, sz, TO_CONN(conn));
   tor_free(r);
 } else {
   control_write_endreply(conn, 512, "syntax error: "
                          "not enough arguments to mapaddress.");
 }

 SMARTLIST_FOREACH(reply, char *, cp, tor_free(cp));
 smartlist_free(reply);
 return 0;
}

/** Given a string, convert it to a circuit purpose. */
static uint8_t
circuit_purpose_from_string(const char *string)
{
 if (!strcasecmpstart(string, "purpose="))
   string += strlen("purpose=");

 if (!strcasecmp(string, "general"))
   return CIRCUIT_PURPOSE_C_GENERAL;
 else if (!strcasecmp(string, "controller"))
   return CIRCUIT_PURPOSE_CONTROLLER;
 else
   return CIRCUIT_PURPOSE_UNKNOWN;
}

static const control_cmd_syntax_t extendcircuit_syntax = {
 .min_args=1,
 .max_args=1, // see note in function
 .accept_keywords=true,
 .kvline_flags=KV_OMIT_VALS
};

/** Called when we get an EXTENDCIRCUIT message.  Try to extend the listed
* circuit, and report success or failure. */
static int
handle_control_extendcircuit(control_connection_t *conn,
                            const control_cmd_args_t *args)
{
 smartlist_t *router_nicknames=smartlist_new(), *nodes=NULL;
 origin_circuit_t *circ = NULL;
 uint8_t intended_purpose = CIRCUIT_PURPOSE_C_GENERAL;
 const config_line_t *kwargs = args->kwargs;
 const char *circ_id = smartlist_get(args->args, 0);
 const char *path_str = NULL;
 char *path_str_alloc = NULL;

 /* The syntax for this command is unfortunate. The second argument is
    optional, and is a comma-separated list long-format fingerprints, which
    can (historically!) contain an equals sign.

    Here we check the second argument to see if it's a path, and if so we
    remove it from the kwargs list and put it in path_str.
 */
 if (kwargs) {
   const config_line_t *arg1 = kwargs;
   if (!strcmp(arg1->value, "")) {
     path_str = arg1->key;
     kwargs = kwargs->next;
   } else if (arg1->key[0] == '$') {
     tor_asprintf(&path_str_alloc, "%s=%s", arg1->key, arg1->value);
     path_str = path_str_alloc;
     kwargs = kwargs->next;
   }
 }

 const config_line_t *purpose_line = config_line_find_case(kwargs, "PURPOSE");
 bool zero_circ = !strcmp("0", circ_id);

 if (purpose_line) {
   intended_purpose = circuit_purpose_from_string(purpose_line->value);
   if (intended_purpose == CIRCUIT_PURPOSE_UNKNOWN) {
     control_printf_endreply(conn, 552, "Unknown purpose \"%s\"",
                             purpose_line->value);
     goto done;
   }
 }

 if (zero_circ) {
   if (!path_str) {
     // "EXTENDCIRCUIT 0" with no path.
     circ = circuit_launch(intended_purpose, CIRCLAUNCH_NEED_CAPACITY);
     if (!circ) {
       control_write_endreply(conn, 551, "Couldn't start circuit");
     } else {
       control_printf_endreply(conn, 250, "EXTENDED %lu",
                               (unsigned long)circ->global_identifier);
     }
     goto done;
   }
 }

 if (!zero_circ && !(circ = get_circ(circ_id))) {
   control_printf_endreply(conn, 552, "Unknown circuit \"%s\"", circ_id);
   goto done;
 }

 if (!path_str) {
   control_write_endreply(conn, 512, "syntax error: path required.");
   goto done;
 }

 smartlist_split_string(router_nicknames, path_str, ",", 0, 0);

 nodes = smartlist_new();
 bool first_node = zero_circ;
 SMARTLIST_FOREACH_BEGIN(router_nicknames, const char *, n) {
   const node_t *node = node_get_by_nickname(n, 0);
   if (!node) {
     control_printf_endreply(conn, 552, "No such router \"%s\"", n);
     goto done;
   }
   if (!node_has_preferred_descriptor(node, first_node)) {
     control_printf_endreply(conn, 552, "No descriptor for \"%s\"", n);
     goto done;
   }
   smartlist_add(nodes, (void*)node);
   first_node = false;
 } SMARTLIST_FOREACH_END(n);

 if (!smartlist_len(nodes)) {
   control_write_endreply(conn, 512, "No router names provided");
   goto done;
 }

 if (zero_circ) {
   /* start a new circuit */
   circ = origin_circuit_init(intended_purpose, 0);
   circ->first_hop_from_controller = 1;
 }

 circ->any_hop_from_controller = 1;

 /* now circ refers to something that is ready to be extended */
 first_node = zero_circ;
 SMARTLIST_FOREACH(nodes, const node_t *, node,
 {
   /* We treat every hop as an exit to try to negotiate congestion
    * control, because we have no idea which hop the controller wil
    * try to use for streams and when */
   extend_info_t *info = extend_info_from_node(node, first_node, true);
   if (!info) {
     tor_assert_nonfatal(first_node);
     log_warn(LD_CONTROL,
              "controller tried to connect to a node that lacks a suitable "
              "descriptor, or which doesn't have any "
              "addresses that are allowed by the firewall configuration; "
              "circuit marked for closing.");
     circuit_mark_for_close(TO_CIRCUIT(circ), -END_CIRC_REASON_CONNECTFAILED);
     control_write_endreply(conn, 551, "Couldn't start circuit");
     goto done;
   }
   circuit_append_new_exit(circ, info);
   if (circ->build_state->desired_path_len > 1) {
     circ->build_state->onehop_tunnel = 0;
   }
   extend_info_free(info);
   first_node = 0;
 });

 /* now that we've populated the cpath, start extending */
 if (zero_circ) {
   int err_reason = 0;
   if ((err_reason = circuit_handle_first_hop(circ)) < 0) {
     circuit_mark_for_close(TO_CIRCUIT(circ), -err_reason);
     control_write_endreply(conn, 551, "Couldn't start circuit");
     goto done;
   }
 } else {
   if (circ->base_.state == CIRCUIT_STATE_OPEN ||
       circ->base_.state == CIRCUIT_STATE_GUARD_WAIT) {
     int err_reason = 0;
     circuit_set_state(TO_CIRCUIT(circ), CIRCUIT_STATE_BUILDING);
     if ((err_reason = circuit_send_next_onion_skin(circ)) < 0) {
       log_info(LD_CONTROL,
                "send_next_onion_skin failed; circuit marked for closing.");
       circuit_mark_for_close(TO_CIRCUIT(circ), -err_reason);
       control_write_endreply(conn, 551, "Couldn't send onion skin");
       goto done;
     }
   }
 }

 control_printf_endreply(conn, 250, "EXTENDED %lu",
                         (unsigned long)circ->global_identifier);
 if (zero_circ) /* send a 'launched' event, for completeness */
   circuit_event_status(circ, CIRC_EVENT_LAUNCHED, 0);
done:
 SMARTLIST_FOREACH(router_nicknames, char *, n, tor_free(n));
 smartlist_free(router_nicknames);
 smartlist_free(nodes);
 tor_free(path_str_alloc);
 return 0;
}

static const control_cmd_syntax_t setcircuitpurpose_syntax = {
 .max_args=1,
 .accept_keywords=true,
};

/** Called when we get a SETCIRCUITPURPOSE message. If we can find the
* circuit and it's a valid purpose, change it. */
static int
handle_control_setcircuitpurpose(control_connection_t *conn,
                                const control_cmd_args_t *args)
{
 origin_circuit_t *circ = NULL;
 uint8_t new_purpose;
 const char *circ_id = smartlist_get(args->args,0);

 if (!(circ = get_circ(circ_id))) {
   control_printf_endreply(conn, 552, "Unknown circuit \"%s\"", circ_id);
   goto done;
 }

 {
   const config_line_t *purp = config_line_find_case(args->kwargs, "PURPOSE");
   if (!purp) {
     control_write_endreply(conn, 552, "No purpose given");
     goto done;
   }
   new_purpose = circuit_purpose_from_string(purp->value);
   if (new_purpose == CIRCUIT_PURPOSE_UNKNOWN) {
     control_printf_endreply(conn, 552, "Unknown purpose \"%s\"",
                             purp->value);
     goto done;
   }
 }

 circuit_change_purpose(TO_CIRCUIT(circ), new_purpose);
 send_control_done(conn);

done:
 return 0;
}

static const char *attachstream_keywords[] = {
 "HOP", NULL
};
static const control_cmd_syntax_t attachstream_syntax = {
 .min_args=2, .max_args=2,
 .accept_keywords=true,
 .allowed_keywords=attachstream_keywords
};

/** Called when we get an ATTACHSTREAM message.  Try to attach the requested
* stream, and report success or failure. */
static int
handle_control_attachstream(control_connection_t *conn,
                           const control_cmd_args_t *args)
{
 entry_connection_t *ap_conn = NULL;
 origin_circuit_t *circ = NULL;
 crypt_path_t *cpath=NULL;
 int hop=0, hop_line_ok=1;
 const char *stream_id = smartlist_get(args->args, 0);
 const char *circ_id = smartlist_get(args->args, 1);
 int zero_circ = !strcmp(circ_id, "0");
 const config_line_t *hoparg = config_line_find_case(args->kwargs, "HOP");

 if (!(ap_conn = get_stream(stream_id))) {
   control_printf_endreply(conn, 552, "Unknown stream \"%s\"", stream_id);
   return 0;
 } else if (!zero_circ && !(circ = get_circ(circ_id))) {
   control_printf_endreply(conn, 552, "Unknown circuit \"%s\"", circ_id);
   return 0;
 } else if (circ) {
   if (hoparg) {
     hop = (int) tor_parse_ulong(hoparg->value, 10, 0, INT_MAX,
                                 &hop_line_ok, NULL);
     if (!hop_line_ok) { /* broken hop line */
       control_printf_endreply(conn, 552, "Bad value hop=%s",
                               hoparg->value);
       return 0;
     }
   }
 }

 if (ENTRY_TO_CONN(ap_conn)->state != AP_CONN_STATE_CONTROLLER_WAIT &&
     ENTRY_TO_CONN(ap_conn)->state != AP_CONN_STATE_CONNECT_WAIT &&
     ENTRY_TO_CONN(ap_conn)->state != AP_CONN_STATE_RESOLVE_WAIT) {
   control_write_endreply(conn, 555,
                          "Connection is not managed by controller.");
   return 0;
 }

 /* Do we need to detach it first? */
 if (ENTRY_TO_CONN(ap_conn)->state != AP_CONN_STATE_CONTROLLER_WAIT) {
   edge_connection_t *edge_conn = ENTRY_TO_EDGE_CONN(ap_conn);
   circuit_t *tmpcirc = circuit_get_by_edge_conn(edge_conn);
   connection_edge_end(edge_conn, END_STREAM_REASON_TIMEOUT);
   /* Un-mark it as ending, since we're going to reuse it. */
   edge_conn->edge_has_sent_end = 0;
   edge_conn->end_reason = 0;
   if (tmpcirc)
     circuit_detach_stream(tmpcirc, edge_conn);
   connection_entry_set_controller_wait(ap_conn);
 }

 if (circ && (circ->base_.state != CIRCUIT_STATE_OPEN)) {
   control_write_endreply(conn, 551,
                          "Can't attach stream to non-open origin circuit");
   return 0;
 }
 /* Is this a single hop circuit? */
 if (circ && (circuit_get_cpath_len(circ)<2 || hop==1)) {
   control_write_endreply(conn, 551,
                          "Can't attach stream to this one-hop circuit.");
   return 0;
 }

 if (circ && hop>0) {
   /* find this hop in the circuit, and set cpath */
   cpath = circuit_get_cpath_hop(circ, hop);
   if (!cpath) {
     control_printf_endreply(conn, 551, "Circuit doesn't have %d hops.", hop);
     return 0;
   }
 }
 if (connection_ap_handshake_rewrite_and_attach(ap_conn, circ, cpath) < 0) {
   control_write_endreply(conn, 551, "Unable to attach stream");
   return 0;
 }
 send_control_done(conn);
 return 0;
}

static const char *postdescriptor_keywords[] = {
 "cache", "purpose", NULL,
};

static const control_cmd_syntax_t postdescriptor_syntax = {
 .max_args = 0,
 .accept_keywords = true,
 .allowed_keywords = postdescriptor_keywords,
 .want_cmddata = true,
};

/** Called when we get a POSTDESCRIPTOR message.  Try to learn the provided
* descriptor, and report success or failure. */
static int
handle_control_postdescriptor(control_connection_t *conn,
                             const control_cmd_args_t *args)
{
 const char *msg=NULL;
 uint8_t purpose = ROUTER_PURPOSE_GENERAL;
 int cache = 0; /* eventually, we may switch this to 1 */
 const config_line_t *line;

 line = config_line_find_case(args->kwargs, "purpose");
 if (line) {
   purpose = router_purpose_from_string(line->value);
   if (purpose == ROUTER_PURPOSE_UNKNOWN) {
     control_printf_endreply(conn, 552, "Unknown purpose \"%s\"",
                             line->value);
     goto done;
   }
 }
 line = config_line_find_case(args->kwargs, "cache");
 if (line) {
   if (!strcasecmp(line->value, "no"))
     cache = 0;
   else if (!strcasecmp(line->value, "yes"))
     cache = 1;
   else {
     control_printf_endreply(conn, 552, "Unknown cache request \"%s\"",
                             line->value);
     goto done;
   }
 }

 switch (router_load_single_router(args->cmddata, purpose, cache, &msg)) {
 case -1:
   if (!msg) msg = "Could not parse descriptor";
   control_write_endreply(conn, 554, msg);
   break;
 case 0:
   if (!msg) msg = "Descriptor not added";
   control_write_endreply(conn, 251, msg);
   break;
 case 1:
   send_control_done(conn);
   break;
 }

done:
 return 0;
}

static const control_cmd_syntax_t redirectstream_syntax = {
 .min_args = 2,
 .max_args = UINT_MAX, // XXX should be 3.
};

/** Called when we receive a REDIRECTSTREAM command.  Try to change the target
* address of the named AP stream, and report success or failure. */
static int
handle_control_redirectstream(control_connection_t *conn,
                             const control_cmd_args_t *cmd_args)
{
 entry_connection_t *ap_conn = NULL;
 char *new_addr = NULL;
 uint16_t new_port = 0;
 const smartlist_t *args = cmd_args->args;

 if (!(ap_conn = get_stream(smartlist_get(args, 0)))
          || !ap_conn->socks_request) {
   control_printf_endreply(conn, 552, "Unknown stream \"%s\"",
                           (char*)smartlist_get(args, 0));
 } else {
   int ok = 1;
   if (smartlist_len(args) > 2) { /* they included a port too */
     new_port = (uint16_t) tor_parse_ulong(smartlist_get(args, 2),
                                           10, 1, 65535, &ok, NULL);
   }
   if (!ok) {
     control_printf_endreply(conn, 512, "Cannot parse port \"%s\"",
                             (char*)smartlist_get(args, 2));
   } else {
     new_addr = tor_strdup(smartlist_get(args, 1));
   }
 }

 if (!new_addr)
   return 0;

 strlcpy(ap_conn->socks_request->address, new_addr,
         sizeof(ap_conn->socks_request->address));
 if (new_port)
   ap_conn->socks_request->port = new_port;
 tor_free(new_addr);
 send_control_done(conn);
 return 0;
}

static const control_cmd_syntax_t closestream_syntax = {
 .min_args = 2,
 .max_args = UINT_MAX, /* XXXX This is the original behavior, but
                        * maybe we should change the spec. */
};

/** Called when we get a CLOSESTREAM command; try to close the named stream
* and report success or failure. */
static int
handle_control_closestream(control_connection_t *conn,
                          const control_cmd_args_t *cmd_args)
{
 entry_connection_t *ap_conn=NULL;
 uint8_t reason=0;
 int ok;
 const smartlist_t *args = cmd_args->args;

 tor_assert(smartlist_len(args) >= 2);

 if (!(ap_conn = get_stream(smartlist_get(args, 0))))
   control_printf_endreply(conn, 552, "Unknown stream \"%s\"",
                           (char*)smartlist_get(args, 0));
 else {
   reason = (uint8_t) tor_parse_ulong(smartlist_get(args,1), 10, 0, 255,
                                      &ok, NULL);
   if (!ok) {
     control_printf_endreply(conn, 552, "Unrecognized reason \"%s\"",
                             (char*)smartlist_get(args, 1));
     ap_conn = NULL;
   }
 }
 if (!ap_conn)
   return 0;

 connection_mark_unattached_ap(ap_conn, reason);
 send_control_done(conn);
 return 0;
}

static const control_cmd_syntax_t closecircuit_syntax = {
 .min_args=1, .max_args=1,
 .accept_keywords=true,
 .kvline_flags=KV_OMIT_VALS,
 // XXXX we might want to exclude unrecognized flags, but for now we
 // XXXX just ignore them for backward compatibility.
};

/** Called when we get a CLOSECIRCUIT command; try to close the named circuit
* and report success or failure. */
static int
handle_control_closecircuit(control_connection_t *conn,
                           const control_cmd_args_t *args)
{
 const char *circ_id = smartlist_get(args->args, 0);
 origin_circuit_t *circ = NULL;

 if (!(circ=get_circ(circ_id))) {
   control_printf_endreply(conn, 552, "Unknown circuit \"%s\"", circ_id);
   return 0;
 }

 bool safe =  config_lines_contain_flag(args->kwargs, "IfUnused");

 if (!safe || !circ->p_streams) {
   circuit_mark_for_close(TO_CIRCUIT(circ), END_CIRC_REASON_REQUESTED);
 }

 send_control_done(conn);
 return 0;
}

static const control_cmd_syntax_t resolve_syntax = {
 .max_args=0,
 .accept_keywords=true,
 .kvline_flags=KV_OMIT_VALS,
};

/** Called when we get a RESOLVE command: start trying to resolve
* the listed addresses. */
static int
handle_control_resolve(control_connection_t *conn,
                      const control_cmd_args_t *args)
{
 smartlist_t *failed;
 int is_reverse = 0;

 if (!(conn->event_mask & (((event_mask_t)1)<<EVENT_ADDRMAP))) {
   log_warn(LD_CONTROL, "Controller asked us to resolve an address, but "
            "isn't listening for ADDRMAP events.  It probably won't see "
            "the answer.");
 }

 {
   const config_line_t *modearg = config_line_find_case(args->kwargs, "mode");
   if (modearg && !strcasecmp(modearg->value, "reverse"))
     is_reverse = 1;
 }
 failed = smartlist_new();
 for (const config_line_t *line = args->kwargs; line; line = line->next) {
   if (!strlen(line->value)) {
     const char *addr = line->key;
     if (dnsserv_launch_request(addr, is_reverse, conn)<0)
       smartlist_add(failed, (char*)addr);
   } else {
     // XXXX arguably we should reject unrecognized keyword arguments,
     // XXXX but the old implementation didn't do that.
   }
 }

 send_control_done(conn);
 SMARTLIST_FOREACH(failed, const char *, arg, {
     control_event_address_mapped(arg, arg, time(NULL),
                                  "internal", 0, 0);
 });

 smartlist_free(failed);
 return 0;
}

static const control_cmd_syntax_t protocolinfo_syntax = {
 .max_args = UINT_MAX
};

/** Return a comma-separated list of authentication methods for
   handle_control_protocolinfo().  Caller must free this string. */
static char *
get_authmethods(const or_options_t *options)
{
 int cookies = options->CookieAuthentication;
 char *methods;
 int passwd = (options->HashedControlPassword != NULL ||
               options->HashedControlSessionPassword != NULL);
 smartlist_t *mlist = smartlist_new();

 if (cookies) {
   smartlist_add(mlist, (char*)"COOKIE");
   smartlist_add(mlist, (char*)"SAFECOOKIE");
 }
 if (passwd)
   smartlist_add(mlist, (char*)"HASHEDPASSWORD");
 if (!cookies && !passwd)
   smartlist_add(mlist, (char*)"NULL");
 methods = smartlist_join_strings(mlist, ",", 0, NULL);
 smartlist_free(mlist);

 return methods;
}

/** Return escaped cookie filename.  Caller must free this string.
   Return NULL if cookie authentication is disabled. */
static char *
get_esc_cfile(const or_options_t *options)
{
 char *cfile = NULL, *abs_cfile = NULL, *esc_cfile = NULL;

 if (!options->CookieAuthentication)
   return NULL;

 cfile = get_controller_cookie_file_name();
 abs_cfile = make_path_absolute(cfile);
 esc_cfile = esc_for_log(abs_cfile);
 tor_free(cfile);
 tor_free(abs_cfile);
 return esc_cfile;
}

/** Compose the auth methods line of a PROTOCOLINFO reply. */
static void
add_authmethods(smartlist_t *reply)
{
 const or_options_t *options = get_options();
 char *methods = get_authmethods(options);
 char *esc_cfile = get_esc_cfile(options);

 control_reply_add_str(reply, 250, "AUTH");
 control_reply_append_kv(reply, "METHODS", methods);
 if (esc_cfile)
   control_reply_append_kv(reply, "COOKIEFILE", esc_cfile);

 tor_free(methods);
 tor_free(esc_cfile);
}

/** Called when we get a PROTOCOLINFO command: send back a reply. */
static int
handle_control_protocolinfo(control_connection_t *conn,
                           const control_cmd_args_t *cmd_args)
{
 const char *bad_arg = NULL;
 const smartlist_t *args = cmd_args->args;
 smartlist_t *reply = NULL;

 conn->have_sent_protocolinfo = 1;

 SMARTLIST_FOREACH(args, const char *, arg, {
     int ok;
     tor_parse_long(arg, 10, 0, LONG_MAX, &ok, NULL);
     if (!ok) {
       bad_arg = arg;
       break;
     }
   });
 if (bad_arg) {
   control_printf_endreply(conn, 513, "No such version %s",
                           escaped(bad_arg));
   /* Don't tolerate bad arguments when not authenticated. */
   if (!STATE_IS_OPEN(TO_CONN(conn)->state))
     connection_mark_for_close(TO_CONN(conn));
   return 0;
 }
 reply = smartlist_new();
 control_reply_add_str(reply, 250, "PROTOCOLINFO 1");
 add_authmethods(reply);
 control_reply_add_str(reply, 250, "VERSION");
 control_reply_append_kv(reply, "Tor", escaped(VERSION));
 control_reply_add_done(reply);

 control_write_reply_lines(conn, reply);
 control_reply_free(reply);
 return 0;
}

static const control_cmd_syntax_t usefeature_syntax = {
 .max_args = UINT_MAX
};

/** Called when we get a USEFEATURE command: parse the feature list, and
* set up the control_connection's options properly. */
static int
handle_control_usefeature(control_connection_t *conn,
                         const control_cmd_args_t *cmd_args)
{
 const smartlist_t *args = cmd_args->args;
 int bad = 0;
 SMARTLIST_FOREACH_BEGIN(args, const char *, arg) {
     if (!strcasecmp(arg, "VERBOSE_NAMES"))
       ;
     else if (!strcasecmp(arg, "EXTENDED_EVENTS"))
       ;
     else {
       control_printf_endreply(conn, 552, "Unrecognized feature \"%s\"",
                               arg);
       bad = 1;
       break;
     }
 } SMARTLIST_FOREACH_END(arg);

 if (!bad) {
   send_control_done(conn);
 }

 return 0;
}

static const control_cmd_syntax_t dropguards_syntax = {
 .max_args = 0,
};

/** Implementation for the DROPGUARDS command. */
static int
handle_control_dropguards(control_connection_t *conn,
                         const control_cmd_args_t *args)
{
 (void) args; /* We don't take arguments. */

 static int have_warned = 0;
 if (! have_warned) {
   log_warn(LD_CONTROL, "DROPGUARDS is dangerous; make sure you understand "
            "the risks before using it. It may be removed in a future "
            "version of Tor.");
   have_warned = 1;
 }

 remove_all_entry_guards();
 send_control_done(conn);

 return 0;
}

static const control_cmd_syntax_t droptimeouts_syntax = {
 .max_args = 0,
};

/** Implementation for the DROPTIMEOUTS command. */
static int
handle_control_droptimeouts(control_connection_t *conn,
                         const control_cmd_args_t *args)
{
 (void) args; /* We don't take arguments. */

 static int have_warned = 0;
 if (! have_warned) {
   log_warn(LD_CONTROL, "DROPTIMEOUTS is dangerous; make sure you understand "
            "the risks before using it. It may be removed in a future "
            "version of Tor.");
   have_warned = 1;
 }

 circuit_build_times_reset(get_circuit_build_times_mutable());
 send_control_done(conn);
 or_state_mark_dirty(get_or_state(), 0);
 cbt_control_event_buildtimeout_set(get_circuit_build_times(),
                                    BUILDTIMEOUT_SET_EVENT_RESET);

 return 0;
}

static const char *hsfetch_keywords[] = {
 "SERVER", NULL,
};
static const control_cmd_syntax_t hsfetch_syntax = {
 .min_args = 1, .max_args = 1,
 .accept_keywords = true,
 .allowed_keywords = hsfetch_keywords,
};

/** Implementation for the HSFETCH command. */
static int
handle_control_hsfetch(control_connection_t *conn,
                      const control_cmd_args_t *args)

{
 smartlist_t *hsdirs = NULL;
 ed25519_public_key_t v3_pk;
 uint32_t version;
 const char *hsaddress = NULL;

 /* Extract the first argument (either HSAddress or DescID). */
 const char *arg1 = smartlist_get(args->args, 0);
 if (hs_address_is_valid(arg1)) {
   hsaddress = arg1;
   version = HS_VERSION_THREE;
   hs_parse_address(hsaddress, &v3_pk, NULL, NULL);
 } else {
   control_printf_endreply(conn, 513, "Invalid argument \"%s\"", arg1);
   goto done;
 }

 for (const config_line_t *line = args->kwargs; line; line = line->next) {
   if (!strcasecmp(line->key, "SERVER")) {
     const char *server = line->value;

     const node_t *node = node_get_by_hex_id(server, 0);
     if (!node) {
       control_printf_endreply(conn, 552, "Server \"%s\" not found", server);
       goto done;
     }
     if (!hsdirs) {
       /* Stores routerstatus_t cmddata for each specified server. */
       hsdirs = smartlist_new();
     }
     /* Valid server, add it to our local list. */
     smartlist_add(hsdirs, node->rs);
   } else {
     tor_assert_nonfatal_unreached();
   }
 }

 /* We are about to trigger HSDir fetch so send the OK now because after
  * that 650 event(s) are possible so better to have the 250 OK before them
  * to avoid out of order replies. */
 send_control_done(conn);

 /* Trigger the fetch using the built rend query and possibly a list of HS
  * directory to use. This function ignores the client cache thus this will
  * always send a fetch command. */
 if (version == HS_VERSION_THREE) {
   hs_control_hsfetch_command(&v3_pk, hsdirs);
 }

done:
 /* Contains data pointer that we don't own thus no cleanup. */
 smartlist_free(hsdirs);
 return 0;
}

static const char *hspost_keywords[] = {
 "SERVER", "HSADDRESS", NULL
};
static const control_cmd_syntax_t hspost_syntax = {
 .min_args = 0, .max_args = 0,
 .accept_keywords = true,
 .want_cmddata = true,
 .allowed_keywords = hspost_keywords
};

/** Implementation for the HSPOST command. */
static int
handle_control_hspost(control_connection_t *conn,
                     const control_cmd_args_t *args)
{
 smartlist_t *hs_dirs = NULL;
 const char *encoded_desc = args->cmddata;
 const char *onion_address = NULL;
 const config_line_t *line;

 for (line = args->kwargs; line; line = line->next) {
   if (!strcasecmpstart(line->key, "SERVER")) {
     const char *server = line->value;
     const node_t *node = node_get_by_hex_id(server, 0);

     if (!node || !node->rs) {
       control_printf_endreply(conn, 552, "Server \"%s\" not found",
                               server);
       goto done;
     }
     /* Valid server, add it to our local list. */
     if (!hs_dirs)
       hs_dirs = smartlist_new();
     smartlist_add(hs_dirs, node->rs);
   } else if (!strcasecmpstart(line->key, "HSADDRESS")) {
     const char *address = line->value;
     if (!hs_address_is_valid(address)) {
       control_write_endreply(conn, 512, "Malformed onion address");
       goto done;
     }
     onion_address = address;
   } else {
     tor_assert_nonfatal_unreached();
   }
 }

 /* Handle the v3 case. */
 if (onion_address) {
   if (hs_control_hspost_command(encoded_desc, onion_address, hs_dirs) < 0) {
     control_write_endreply(conn, 554, "Invalid descriptor");
   } else {
     send_control_done(conn);
   }
   goto done;
 }

done:
 smartlist_free(hs_dirs); /* Contents belong to the rend service code. */
 return 0;
}

/* Helper function for ADD_ONION that adds an ephemeral service depending on
* the given hs_version.
*
* The secret key in pk depends on the hs_version. The ownership of the key
* used in pk is given to the HS subsystem so the caller must stop accessing
* it after.
*
* The port_cfgs is a list of service port. Ownership transferred to service.
* The max_streams refers to the MaxStreams= key.
* The max_streams_close_circuit refers to the MaxStreamsCloseCircuit key.
* The ownership of that list is transferred to the service.
*
* On success (RSAE_OKAY), the address_out points to a newly allocated string
* containing the onion address without the .onion part. On error, address_out
* is untouched. */
STATIC hs_service_add_ephemeral_status_t
add_onion_helper_add_service(int hs_version,
                            add_onion_secret_key_t *pk,
                            smartlist_t *port_cfgs, int max_streams,
                            int max_streams_close_circuit,
                            int pow_defenses_enabled,
                            uint32_t pow_queue_rate,
                            uint32_t pow_queue_burst,
                            smartlist_t *auth_clients_v3, char **address_out)
{
 hs_service_add_ephemeral_status_t ret;

 tor_assert(pk);
 tor_assert(port_cfgs);
 tor_assert(address_out);

 switch (hs_version) {
 case HS_VERSION_THREE:
   ret = hs_service_add_ephemeral(pk->v3, port_cfgs, max_streams,
                                  max_streams_close_circuit,
                                  pow_defenses_enabled,
                                  pow_queue_rate,
                                  pow_queue_burst,
                                  auth_clients_v3, address_out);
   break;
 default:
   tor_assert_unreached();
 }

 return ret;
}

/** The list of onion services that have been added via ADD_ONION that do not
* belong to any particular control connection.
*/
static smartlist_t *detached_onion_services = NULL;

/**
* Return a list of detached onion services, or NULL if none exist.
**/
smartlist_t *
get_detached_onion_services(void)
{
 return detached_onion_services;
}

static const char *add_onion_keywords[] = {
  "Port",
  "Flags",
  "MaxStreams",
  "PoWDefensesEnabled",
  "PoWQueueRate",
  "PoWQueueBurst",
  "ClientAuth",
  "ClientAuthV3",
  NULL
};
static const control_cmd_syntax_t add_onion_syntax = {
 .min_args = 1, .max_args = 1,
 .accept_keywords = true,
 .allowed_keywords = add_onion_keywords
};

/** Called when we get a ADD_ONION command; parse the body, and set up
* the new ephemeral Onion Service. */
static int
handle_control_add_onion(control_connection_t *conn,
                        const control_cmd_args_t *args)
{
 /* Parse all of the arguments that do not involve handling cryptographic
  * material first, since there's no reason to touch that at all if any of
  * the other arguments are malformed.
  */
 rend_auth_type_t auth_type = REND_NO_AUTH;
 smartlist_t *port_cfgs = smartlist_new();
 smartlist_t *auth_clients_v3 = NULL;
 smartlist_t *auth_clients_v3_str = NULL;
 int discard_pk = 0;
 int detach = 0;
 int max_streams = 0;
 int max_streams_close_circuit = 0;
 int non_anonymous = 0;
 int pow_defenses_enabled = HS_CONFIG_V3_POW_DEFENSES_DEFAULT;
 uint32_t pow_queue_rate = HS_CONFIG_V3_POW_QUEUE_RATE;
 uint32_t pow_queue_burst = HS_CONFIG_V3_POW_QUEUE_BURST;
 const config_line_t *arg;

 for (arg = args->kwargs; arg; arg = arg->next) {
   if (!strcasecmp(arg->key, "Port")) {
     /* "Port=VIRTPORT[,TARGET]". */
     hs_port_config_t *cfg = hs_parse_port_config(arg->value, ",", NULL);
     if (!cfg) {
       control_write_endreply(conn, 512, "Invalid VIRTPORT/TARGET");
       goto out;
     }
     smartlist_add(port_cfgs, cfg);
   } else if (!strcasecmp(arg->key, "MaxStreams")) {
     /* "MaxStreams=[0..65535]". */
     int ok = 0;
     max_streams = (int)tor_parse_long(arg->value, 10, 0, 65535, &ok, NULL);
     if (!ok) {
       control_write_endreply(conn, 512, "Invalid MaxStreams");
       goto out;
     }
   } else if (!strcasecmp(arg->key, "PoWDefensesEnabled")) {
     int ok = 0;
     pow_defenses_enabled = (int)tor_parse_long(arg->value, 10,
                                                0, 1, &ok, NULL);
     if (!ok) {
       control_write_endreply(conn, 512, "Invalid PoWDefensesEnabled");
       goto out;
     }
   } else if (!strcasecmp(arg->key, "PoWQueueRate")) {
     int ok = 0;
     pow_queue_rate = (uint32_t)tor_parse_ulong(arg->value, 10,
                                                0, UINT32_MAX, &ok, NULL);
     if (!ok) {
       control_write_endreply(conn, 512, "Invalid PoWQueueRate");
       goto out;
     }
   } else if (!strcasecmp(arg->key, "PoWQueueBurst")) {
     int ok = 0;
     pow_queue_burst = (uint32_t)tor_parse_ulong(arg->value, 10,
                                                 0, UINT32_MAX, &ok, NULL);
     if (!ok) {
       control_write_endreply(conn, 512, "Invalid PoWQueueBurst");
       goto out;
     }
   } else if (!strcasecmp(arg->key, "Flags")) {
     /* "Flags=Flag[,Flag]", where Flag can be:
      *   * 'DiscardPK' - If tor generates the keypair, do not include it in
      *                   the response.
      *   * 'Detach' - Do not tie this onion service to any particular control
      *                connection.
      *   * 'MaxStreamsCloseCircuit' - Close the circuit if MaxStreams is
      *                                exceeded.
      *   * 'BasicAuth' - Client authorization using the 'basic' method.
      *   * 'NonAnonymous' - Add a non-anonymous Single Onion Service. If this
      *                      flag is present, tor must be in non-anonymous
      *                      hidden service mode. If this flag is absent,
      *                      tor must be in anonymous hidden service mode.
      */
     static const char *discard_flag = "DiscardPK";
     static const char *detach_flag = "Detach";
     static const char *max_s_close_flag = "MaxStreamsCloseCircuit";
     static const char *v3auth_flag = "V3Auth";
     static const char *non_anonymous_flag = "NonAnonymous";

     smartlist_t *flags = smartlist_new();
     int bad = 0;

     smartlist_split_string(flags, arg->value, ",", SPLIT_IGNORE_BLANK, 0);
     if (smartlist_len(flags) < 1) {
       control_write_endreply(conn, 512, "Invalid 'Flags' argument");
       bad = 1;
     }
     SMARTLIST_FOREACH_BEGIN(flags, const char *, flag)
     {
       if (!strcasecmp(flag, discard_flag)) {
         discard_pk = 1;
       } else if (!strcasecmp(flag, detach_flag)) {
         detach = 1;
       } else if (!strcasecmp(flag, max_s_close_flag)) {
         max_streams_close_circuit = 1;
       } else if (!strcasecmp(flag, v3auth_flag)) {
         auth_type = REND_V3_AUTH;
       } else if (!strcasecmp(flag, non_anonymous_flag)) {
         non_anonymous = 1;
       } else {
         control_printf_endreply(conn, 512, "Invalid 'Flags' argument: %s",
                                 escaped(flag));
         bad = 1;
         break;
       }
     } SMARTLIST_FOREACH_END(flag);
     SMARTLIST_FOREACH(flags, char *, cp, tor_free(cp));
     smartlist_free(flags);
     if (bad)
       goto out;
   } else if (!strcasecmp(arg->key, "ClientAuthV3")) {
     hs_service_authorized_client_t *client_v3 =
                            parse_authorized_client_key(arg->value, LOG_INFO);
     if (!client_v3) {
       control_write_endreply(conn, 512, "Cannot decode v3 client auth key");
       goto out;
     }

     if (auth_clients_v3 == NULL) {
       auth_clients_v3 = smartlist_new();
       auth_clients_v3_str = smartlist_new();
     }

     smartlist_add(auth_clients_v3, client_v3);
     smartlist_add(auth_clients_v3_str, tor_strdup(arg->value));
   } else {
     tor_assert_nonfatal_unreached();
     goto out;
   }
 }
 if (smartlist_len(port_cfgs) == 0) {
   control_write_endreply(conn, 512, "Missing 'Port' argument");
   goto out;
 } else if (auth_type == REND_NO_AUTH && auth_clients_v3 != NULL) {
   control_write_endreply(conn, 512, "No auth type specified");
   goto out;
 } else if (auth_type != REND_NO_AUTH && auth_clients_v3 == NULL) {
   control_write_endreply(conn, 512, "No auth clients specified");
   goto out;
 } else if (non_anonymous != hs_service_non_anonymous_mode_enabled(
                                                           get_options())) {
   /* If we failed, and the non-anonymous flag is set, Tor must be in
    * anonymous hidden service mode.
    * The error message changes based on the current Tor config:
    * 512 Tor is in anonymous hidden service mode
    * 512 Tor is in non-anonymous hidden service mode
    * (I've deliberately written them out in full here to aid searchability.)
    */
   control_printf_endreply(conn, 512,
                           "Tor is in %sanonymous hidden service " "mode",
                           non_anonymous ? "" : "non-");
   goto out;
 }

 /* Parse the "keytype:keyblob" argument. */
 int hs_version = 0;
 add_onion_secret_key_t pk = { NULL };
 const char *key_new_alg = NULL;
 char *key_new_blob = NULL;

 const char *onionkey = smartlist_get(args->args, 0);
 if (add_onion_helper_keyarg(onionkey, discard_pk,
                             &key_new_alg, &key_new_blob, &pk, &hs_version,
                             conn) < 0) {
   goto out;
 }

 /* Create the HS, using private key pk and port config port_cfg.
  * hs_service_add_ephemeral() will take ownership of pk and port_cfg,
  * regardless of success/failure. */
 char *service_id = NULL;
 int ret = add_onion_helper_add_service(hs_version, &pk, port_cfgs,
                                        max_streams,
                                        max_streams_close_circuit,
                                        pow_defenses_enabled,
                                        pow_queue_rate,
                                        pow_queue_burst,
                                        auth_clients_v3, &service_id);
 port_cfgs = NULL; /* port_cfgs is now owned by the hs_service code. */
 auth_clients_v3 = NULL; /* so is auth_clients_v3 */
 switch (ret) {
 case RSAE_OKAY:
 {
   if (detach) {
     if (!detached_onion_services)
       detached_onion_services = smartlist_new();
     smartlist_add(detached_onion_services, service_id);
   } else {
     if (!conn->ephemeral_onion_services)
       conn->ephemeral_onion_services = smartlist_new();
     smartlist_add(conn->ephemeral_onion_services, service_id);
   }

   tor_assert(service_id);
   control_printf_midreply(conn, 250, "ServiceID=%s", service_id);
   if (key_new_alg) {
     tor_assert(key_new_blob);
     control_printf_midreply(conn, 250, "PrivateKey=%s:%s",
                             key_new_alg, key_new_blob);
   }
   if (auth_clients_v3_str) {
     SMARTLIST_FOREACH(auth_clients_v3_str, char *, client_str, {
       control_printf_midreply(conn, 250, "ClientAuthV3=%s", client_str);
     });
   }

   send_control_done(conn);
   break;
 }
 case RSAE_BADPRIVKEY:
   control_write_endreply(conn, 551, "Failed to generate onion address");
   break;
 case RSAE_ADDREXISTS:
   control_write_endreply(conn, 550, "Onion address collision");
   break;
 case RSAE_BADVIRTPORT:
   control_write_endreply(conn, 512, "Invalid VIRTPORT/TARGET");
   break;
 case RSAE_BADAUTH:
   control_write_endreply(conn, 512, "Invalid client authorization");
   break;
 case RSAE_INTERNAL: FALLTHROUGH;
 default:
   control_write_endreply(conn, 551, "Failed to add Onion Service");
 }
 if (key_new_blob) {
   memwipe(key_new_blob, 0, strlen(key_new_blob));
   tor_free(key_new_blob);
 }

out:
 if (port_cfgs) {
   SMARTLIST_FOREACH(port_cfgs, hs_port_config_t*, p,
                     hs_port_config_free(p));
   smartlist_free(port_cfgs);
 }
 if (auth_clients_v3) {
   SMARTLIST_FOREACH(auth_clients_v3, hs_service_authorized_client_t *, ac,
                     service_authorized_client_free(ac));
   smartlist_free(auth_clients_v3);
 }
 if (auth_clients_v3_str) {
   SMARTLIST_FOREACH(auth_clients_v3_str, char *, client_str,
                     tor_free(client_str));
   smartlist_free(auth_clients_v3_str);
 }

 return 0;
}

/** Helper function to handle parsing the KeyType:KeyBlob argument to the
* ADD_ONION command. Return a new crypto_pk_t and if a new key was generated
* and the private key not discarded, the algorithm and serialized private key,
* or NULL and an optional control protocol error message on failure.  The
* caller is responsible for freeing the returned key_new_blob.
*
* Note: The error messages returned are deliberately vague to avoid echoing
* key material.
*
* Note: conn is only used for writing control replies. For testing
* purposes, it can be NULL if control_write_reply() is appropriately
* mocked.
*/
STATIC int
add_onion_helper_keyarg(const char *arg, int discard_pk,
                       const char **key_new_alg_out, char **key_new_blob_out,
                       add_onion_secret_key_t *decoded_key, int *hs_version,
                       control_connection_t *conn)
{
 smartlist_t *key_args = smartlist_new();
 const char *key_new_alg = NULL;
 char *key_new_blob = NULL;
 int ret = -1;

 smartlist_split_string(key_args, arg, ":", SPLIT_IGNORE_BLANK, 0);
 if (smartlist_len(key_args) != 2) {
   control_write_endreply(conn, 512, "Invalid key type/blob");
   goto err;
 }

 /* The format is "KeyType:KeyBlob". */
 static const char *key_type_new = "NEW";
 static const char *key_type_best = "BEST";
 static const char *key_type_ed25519_v3 = "ED25519-V3";

 const char *key_type = smartlist_get(key_args, 0);
 const char *key_blob = smartlist_get(key_args, 1);

 if (!strcasecmp(key_type_ed25519_v3, key_type)) {
   /* parsing of private ed25519 key */
   /* "ED25519-V3:<Base64 Blob>" - Loading a pre-existing ed25519 key. */
   ed25519_secret_key_t *sk = tor_malloc_zero(sizeof(*sk));
   if (base64_decode((char *) sk->seckey, sizeof(sk->seckey), key_blob,
                     strlen(key_blob)) != sizeof(sk->seckey)) {
     tor_free(sk);
     control_write_endreply(conn, 512, "Failed to decode ED25519-V3 key");
     goto err;
   }
   decoded_key->v3 = sk;
   *hs_version = HS_VERSION_THREE;
 } else if (!strcasecmp(key_type_new, key_type)) {
   /* "NEW:<Algorithm>" - Generating a new key, blob as algorithm. */
   if (!strcasecmp(key_type_ed25519_v3, key_blob) ||
       !strcasecmp(key_type_best, key_blob)) {
     /* "ED25519-V3", ed25519 key, also currently "BEST" by default. */
     ed25519_secret_key_t *sk = tor_malloc_zero(sizeof(*sk));
     if (ed25519_secret_key_generate(sk, 1) < 0) {
       tor_free(sk);
       control_printf_endreply(conn, 551, "Failed to generate %s key",
                               key_type_ed25519_v3);
       goto err;
     }
     if (!discard_pk) {
       ssize_t len = base64_encode_size(sizeof(sk->seckey), 0) + 1;
       key_new_blob = tor_malloc_zero(len);
       if (base64_encode(key_new_blob, len, (const char *) sk->seckey,
                         sizeof(sk->seckey), 0) != (len - 1)) {
         tor_free(sk);
         tor_free(key_new_blob);
         control_printf_endreply(conn, 551, "Failed to encode %s key",
                                 key_type_ed25519_v3);
         goto err;
       }
       key_new_alg = key_type_ed25519_v3;
     }
     decoded_key->v3 = sk;
     *hs_version = HS_VERSION_THREE;
   } else {
     control_write_endreply(conn, 513, "Invalid key type");
     goto err;
   }
 } else {
   control_write_endreply(conn, 513, "Invalid key type");
   goto err;
 }

 /* Succeeded in loading or generating a private key. */
 ret = 0;

err:
 SMARTLIST_FOREACH(key_args, char *, cp, {
   memwipe(cp, 0, strlen(cp));
   tor_free(cp);
 });
 smartlist_free(key_args);

 *key_new_alg_out = key_new_alg;
 *key_new_blob_out = key_new_blob;

 return ret;
}

static const control_cmd_syntax_t del_onion_syntax = {
 .min_args = 1, .max_args = 1,
};

/** Called when we get a DEL_ONION command; parse the body, and remove
* the existing ephemeral Onion Service. */
static int
handle_control_del_onion(control_connection_t *conn,
                        const control_cmd_args_t *cmd_args)
{
 int hs_version = 0;
 smartlist_t *args = cmd_args->args;
 tor_assert(smartlist_len(args) == 1);

 const char *service_id = smartlist_get(args, 0);
 if (hs_address_is_valid(service_id)) {
   hs_version = HS_VERSION_THREE;
 } else {
   control_write_endreply(conn, 512, "Malformed Onion Service id");
   goto out;
 }

 /* Determine if the onion service belongs to this particular control
  * connection, or if it is in the global list of detached services.  If it
  * is in neither, either the service ID is invalid in some way, or it
  * explicitly belongs to a different control connection, and an error
  * should be returned.
  */
 smartlist_t *services[2] = {
   conn->ephemeral_onion_services,
   detached_onion_services
 };
 smartlist_t *onion_services = NULL;
 int idx = -1;
 for (size_t i = 0; i < ARRAY_LENGTH(services); i++) {
   idx = smartlist_string_pos(services[i], service_id);
   if (idx != -1) {
     onion_services = services[i];
     break;
   }
 }
 if (onion_services == NULL) {
   control_write_endreply(conn, 552, "Unknown Onion Service id");
 } else {
   int ret = -1;
   switch (hs_version) {
   case HS_VERSION_THREE:
     ret = hs_service_del_ephemeral(service_id);
     break;
   default:
     /* The ret value will be -1 thus hitting the warning below. This should
      * never happen because of the check at the start of the function. */
     break;
   }
   if (ret < 0) {
     /* This should *NEVER* fail, since the service is on either the
      * per-control connection list, or the global one.
      */
     log_warn(LD_BUG, "Failed to remove Onion Service %s.",
              escaped(service_id));
     tor_fragile_assert();
   }

   /* Remove/scrub the service_id from the appropriate list. */
   char *cp = smartlist_get(onion_services, idx);
   smartlist_del(onion_services, idx);
   memwipe(cp, 0, strlen(cp));
   tor_free(cp);

   send_control_done(conn);
 }

out:
 return 0;
}

static const control_cmd_syntax_t obsolete_syntax = {
 .max_args = UINT_MAX
};

/**
* Called when we get an obsolete command: tell the controller that it is
* obsolete.
*/
static int
handle_control_obsolete(control_connection_t *conn,
                       const control_cmd_args_t *args)
{
 (void)args;
 char *command = tor_strdup(conn->current_cmd);
 tor_strupper(command);
 control_printf_endreply(conn, 511, "%s is obsolete.", command);
 tor_free(command);
 return 0;
}

/**
* Function pointer to a handler function for a controller command.
**/
typedef int (*handler_fn_t) (control_connection_t *conn,
                            const control_cmd_args_t *args);

/**
* Definition for a controller command.
*/
typedef struct control_cmd_def_t {
 /**
  * The name of the command. If the command is multiline, the name must
  * begin with "+".  This is not case-sensitive. */
 const char *name;
 /**
  * A function to execute the command.
  */
 handler_fn_t handler;
 /**
  * Zero or more CMD_FL_* flags, or'd together.
  */
 unsigned flags;
 /**
  * For parsed command: a syntax description.
  */
 const control_cmd_syntax_t *syntax;
} control_cmd_def_t;

/**
* Indicates that the command's arguments are sensitive, and should be
* memwiped after use.
*/
#define CMD_FL_WIPE (1u<<0)

#ifndef COCCI
/** Macro: declare a command with a one-line argument, a given set of flags,
* and a syntax definition.
**/
#define ONE_LINE(name, flags)                                   \
 {                                                             \
   (#name),                                                    \
     handle_control_ ##name,                                   \
     flags,                                                    \
     &name##_syntax,                                           \
  }

/**
* Macro: declare a command with a multi-line argument and a given set of
* flags.
**/
#define MULTLINE(name, flags)                                   \
 { ("+"#name),                                                 \
     handle_control_ ##name,                                   \
     flags,                                                    \
     &name##_syntax                                            \
 }

/**
* Macro: declare an obsolete command. (Obsolete commands give a different
* error than non-existent ones.)
**/
#define OBSOLETE(name)                          \
 { #name,                                      \
     handle_control_obsolete,                  \
     0,                                        \
     &obsolete_syntax,                         \
 }
#endif /* !defined(COCCI) */

/**
* An array defining all the recognized controller commands.
**/
static const control_cmd_def_t CONTROL_COMMANDS[] =
{
 ONE_LINE(setconf, 0),
 ONE_LINE(resetconf, 0),
 ONE_LINE(getconf, 0),
 MULTLINE(loadconf, 0),
 ONE_LINE(setevents, 0),
 ONE_LINE(authenticate, CMD_FL_WIPE),
 ONE_LINE(saveconf, 0),
 ONE_LINE(signal, 0),
 ONE_LINE(takeownership, 0),
 ONE_LINE(dropownership, 0),
 ONE_LINE(mapaddress, 0),
 ONE_LINE(getinfo, 0),
 ONE_LINE(extendcircuit, 0),
 ONE_LINE(setcircuitpurpose, 0),
 OBSOLETE(setrouterpurpose),
 ONE_LINE(attachstream, 0),
 MULTLINE(postdescriptor, 0),
 ONE_LINE(redirectstream, 0),
 ONE_LINE(closestream, 0),
 ONE_LINE(closecircuit, 0),
 ONE_LINE(usefeature, 0),
 ONE_LINE(resolve, 0),
 ONE_LINE(protocolinfo, 0),
 ONE_LINE(authchallenge, CMD_FL_WIPE),
 ONE_LINE(dropguards, 0),
 ONE_LINE(droptimeouts, 0),
 ONE_LINE(hsfetch, 0),
 MULTLINE(hspost, 0),
 ONE_LINE(add_onion, CMD_FL_WIPE),
 ONE_LINE(del_onion, CMD_FL_WIPE),
 ONE_LINE(onion_client_auth_add, CMD_FL_WIPE),
 ONE_LINE(onion_client_auth_remove, 0),
 ONE_LINE(onion_client_auth_view, 0),
};

/**
* The number of entries in CONTROL_COMMANDS.
**/
static const size_t N_CONTROL_COMMANDS = ARRAY_LENGTH(CONTROL_COMMANDS);

/**
* Run a single control command, as defined by a control_cmd_def_t,
* with a given set of arguments.
*/
static int
handle_single_control_command(const control_cmd_def_t *def,
                             control_connection_t *conn,
                             uint32_t cmd_data_len,
                             char *args)
{
 int rv = 0;

 control_cmd_args_t *parsed_args;
 char *err=NULL;
 tor_assert(def->syntax);
 parsed_args = control_cmd_parse_args(conn->current_cmd,
                                      def->syntax,
                                      cmd_data_len, args,
                                      &err);
 if (!parsed_args) {
   control_printf_endreply(conn, 512, "Bad arguments to %s: %s",
                           conn->current_cmd, err?err:"");
   tor_free(err);
 } else {
   if (BUG(err))
     tor_free(err);
   if (def->handler(conn, parsed_args))
     rv = 0;

   if (def->flags & CMD_FL_WIPE)
     control_cmd_args_wipe(parsed_args);

   control_cmd_args_free(parsed_args);
 }

 if (def->flags & CMD_FL_WIPE)
   memwipe(args, 0, cmd_data_len);

 return rv;
}

/**
* Run a given controller command, as selected by the current_cmd field of
* <b>conn</b>.
*/
int
handle_control_command(control_connection_t *conn,
                      uint32_t cmd_data_len,
                      char *args)
{
 tor_assert(conn);
 tor_assert(args);
 tor_assert(args[cmd_data_len] == '\0');

 for (unsigned i = 0; i < N_CONTROL_COMMANDS; ++i) {
   const control_cmd_def_t *def = &CONTROL_COMMANDS[i];
   if (!strcasecmp(conn->current_cmd, def->name)) {
     return handle_single_control_command(def, conn, cmd_data_len, args);
   }
 }

 control_printf_endreply(conn, 510, "Unrecognized command \"%s\"",
                         conn->current_cmd);

 return 0;
}

void
control_cmd_free_all(void)
{
 if (detached_onion_services) { /* Free the detached onion services */
   SMARTLIST_FOREACH(detached_onion_services, char *, cp, tor_free(cp));
   smartlist_free(detached_onion_services);
 }
}