/* Copyright (c) 2001 Matej Pfajfar.

 * Copyright (c) 2001-2004, Roger Dingledine.

 * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.

 * Copyright (c) 2007-2021, The Tor Project, Inc. */

/* See LICENSE for licensing information */

/**

 * \file statefile.c

 *

 * \brief Handles parsing and encoding the persistent 'state' file that carries

 *  miscellaneous persistent state between Tor invocations.

 *

 * This 'state' file is a typed key-value store that allows multiple

 * entries for the same key.  It follows the same metaformat as described

 * in confmgt.c, and uses the same code to read and write itself.

 *

 * The state file is most suitable for small values that don't change too

 * frequently.  For values that become very large, we typically use a separate

 * file -- for example, see how we handle microdescriptors, by storing them in

 * a separate file with a journal.

 *

 * The current state is accessed via get_or_state(), which returns a singleton

 * or_state_t object.  Functions that change it should call

 * or_state_mark_dirty() to ensure that it will get written to disk.

 *

 * The or_state_save() function additionally calls various functioens

 * throughout Tor that might want to flush more state to the the disk,

 * including some in rephist.c, entrynodes.c, circuitstats.c, hibernate.c.

 */

#define STATEFILE_PRIVATE

#include "core/or/or.h"

#include "core/or/circuitstats.h"

#include "app/config/config.h"

#include "feature/relay/transport_config.h"

#include "lib/confmgt/confmgt.h"

#include "core/mainloop/mainloop.h"

#include "core/mainloop/netstatus.h"

#include "core/mainloop/connection.h"

#include "feature/control/control_events.h"

#include "feature/client/entrynodes.h"

#include "feature/hibernate/hibernate.h"

#include "feature/stats/bwhist.h"

#include "feature/relay/router.h"

#include "feature/relay/routermode.h"

#include "lib/sandbox/sandbox.h"

#include "app/config/statefile.h"

#include "app/main/subsysmgr.h"

#include "lib/encoding/confline.h"

#include "lib/net/resolve.h"

#include "lib/version/torversion.h"

#include "app/config/or_state_st.h"

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#endif

/** A list of state-file "abbreviations," for compatibility. */

static config_abbrev_t state_abbrevs_[] = {

  { NULL, NULL, 0, 0},

};

/** A list of obsolete keys that we do not and should not preserve.

 *

 * We could just let these live in ExtraLines indefinitely, but they're

 * never going to be used again, and every version that used them

 * has been obsolete for a long time.

 * */

static const char *obsolete_state_keys[] = {

  /* These were renamed in 0.1.1.11-alpha */

  "AccountingBytesReadInterval",

  "HelperNode",

  "HelperNodeDownSince",

  "HelperNodeUnlistedSince",

  "EntryNode",

  "HelperNodeDownSince",

  "EntryNodeUnlistedSince",

  /* These were replaced by "Guard" in 0.3.0.1-alpha. */

  "EntryGuard",

  "EntryGuardDownSince",

  "EntryGuardUnlistedSince",

  "EntryGuardAddedBy",

  "EntryGuardPathBias",

  "EntryGuardPathUseBias",

  /* This was replaced by OPE-based revision numbers in 0.3.5.1-alpha,

   * and was never actually used in a released version. */

  "HidServRevCounter",

  NULL,

};

/** dummy instance of or_state_t, used for type-checking its

 * members with CONF_CHECK_VAR_TYPE. */

DUMMY_TYPECHECK_INSTANCE(or_state_t);

#define VAR(varname,conftype,member,initvalue)                          \

  CONFIG_VAR_ETYPE(or_state_t, varname, conftype, member, 0, initvalue)

#define V(member,conftype,initvalue)            \

  VAR(#member, conftype, member, initvalue)

/** Array of "state" variables saved to the ~/.tor/state file. */

// clang-format off

static const config_var_t state_vars_[] = {

  /* Remember to document these in state-contents.txt ! */

  V(AccountingBytesReadInInterval,    MEMUNIT,  NULL),

  V(AccountingBytesWrittenInInterval, MEMUNIT,  NULL),

  V(AccountingExpectedUsage,          MEMUNIT,  NULL),

  V(AccountingIntervalStart,          ISOTIME,  NULL),

  V(AccountingSecondsActive,          INTERVAL, NULL),

  V(AccountingSecondsToReachSoftLimit,INTERVAL, NULL),

  V(AccountingSoftLimitHitAt,         ISOTIME,  NULL),

  V(AccountingBytesAtSoftLimit,       MEMUNIT,  NULL),

  VAR("TransportProxy",               LINELIST_S, TransportProxies, NULL),

  V(TransportProxies,                 LINELIST_V, NULL),

  V(BWHistoryReadEnds,                ISOTIME,  NULL),

  V(BWHistoryReadInterval,            POSINT,     "900"),

  V(BWHistoryReadValues,              CSV,      ""),

  V(BWHistoryReadMaxima,              CSV,      ""),

  V(BWHistoryWriteEnds,               ISOTIME,  NULL),

  V(BWHistoryWriteInterval,           POSINT,     "900"),

  V(BWHistoryWriteValues,             CSV,      ""),

  V(BWHistoryWriteMaxima,             CSV,      ""),

  V(BWHistoryIPv6ReadEnds,                ISOTIME,  NULL),

  V(BWHistoryIPv6ReadInterval,            POSINT,     "900"),

  V(BWHistoryIPv6ReadValues,              CSV,      ""),

  V(BWHistoryIPv6ReadMaxima,              CSV,      ""),

  V(BWHistoryIPv6WriteEnds,               ISOTIME,  NULL),

  V(BWHistoryIPv6WriteInterval,           POSINT,     "900"),

  V(BWHistoryIPv6WriteValues,             CSV,      ""),

  V(BWHistoryIPv6WriteMaxima,             CSV,      ""),

  V(BWHistoryDirReadEnds,             ISOTIME,  NULL),

  V(BWHistoryDirReadInterval,         POSINT,     "900"),

  V(BWHistoryDirReadValues,           CSV,      ""),

  V(BWHistoryDirReadMaxima,           CSV,      ""),

  V(BWHistoryDirWriteEnds,            ISOTIME,  NULL),

  V(BWHistoryDirWriteInterval,        POSINT,     "900"),

  V(BWHistoryDirWriteValues,          CSV,      ""),

  V(BWHistoryDirWriteMaxima,          CSV,      ""),

  V(Guard,                            LINELIST, NULL),

  V(TorVersion,                       STRING,   NULL),

  V(LastRotatedOnionKey,              ISOTIME,  NULL),

  V(LastWritten,                      ISOTIME,  NULL),

  V(TotalBuildTimes,                  POSINT,     NULL),

  V(CircuitBuildAbandonedCount,       POSINT,     "0"),

  VAR("CircuitBuildTimeBin",          LINELIST_S, BuildtimeHistogram, NULL),

  VAR("BuildtimeHistogram",           LINELIST_V, BuildtimeHistogram, NULL),

  END_OF_CONFIG_VARS

};

// clang-format on

#undef VAR

#undef V

static int or_state_validate(or_state_t *state, char **msg);

static int or_state_validate_cb(const void *old_options,

                                void *options, char **msg);

/** Magic value for or_state_t. */

#define OR_STATE_MAGIC 0x57A73f57

/** "Extra" variable in the state that receives lines we can't parse. This

 * lets us preserve options from versions of Tor newer than us. */

static struct_member_t state_extra_var = {

  .name = "__extra",

  .type = CONFIG_TYPE_LINELIST,

  .offset = offsetof(or_state_t, ExtraLines),

};

/** Configuration format for or_state_t. */

static const config_format_t state_format = {

  .size = sizeof(or_state_t),

  .magic = {

   "or_state_t",

   OR_STATE_MAGIC,

   offsetof(or_state_t, magic_),

  },

  .abbrevs = state_abbrevs_,

  .vars = state_vars_,

  .legacy_validate_fn = or_state_validate_cb,

  .extra = &state_extra_var,

  .has_config_suite = true,

  .config_suite_offset = offsetof(or_state_t, substates_),

};

/* A global configuration manager for state-file objects */

static config_mgr_t *state_mgr = NULL;

/** Return the configuration manager for state-file objects. */

STATIC const config_mgr_t *

get_state_mgr(void)

{

  if (PREDICT_UNLIKELY(state_mgr == NULL)) {

    state_mgr = config_mgr_new(&state_format);

    int rv = subsystems_register_state_formats(state_mgr);

    tor_assert(rv == 0);

    config_mgr_freeze(state_mgr);

  }

  return state_mgr;

}

#define CHECK_STATE_MAGIC(s) STMT_BEGIN                        \

    config_check_toplevel_magic(get_state_mgr(), (s));         \

  STMT_END

/** Persistent serialized state. */

static or_state_t *global_state = NULL;

/** Return the persistent state struct for this Tor. */

MOCK_IMPL(or_state_t *,

get_or_state, (void))

{

  tor_assert(global_state);

  return global_state;

}

/** Return true iff we have loaded the global state for this Tor */

int

or_state_loaded(void)

{

  return global_state != NULL;

}

/** Return true if <b>line</b> is a valid state TransportProxy line.

 *  Return false otherwise. */

static int

state_transport_line_is_valid(const char *line)

{

  smartlist_t *items = NULL;

  char *addrport=NULL;

  tor_addr_t addr;

  uint16_t port = 0;

  int r;

  items = smartlist_new();

  smartlist_split_string(items, line, NULL,

                         SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, -1);

  if (smartlist_len(items) != 2) {

    log_warn(LD_CONFIG, "state: Not enough arguments in TransportProxy line.");

    goto err;

  }

  addrport = smartlist_get(items, 1);

  if (tor_addr_port_lookup(addrport, &addr, &port) < 0) {

    log_warn(LD_CONFIG, "state: Could not parse addrport.");

    goto err;

  }

  if (!port) {

    log_warn(LD_CONFIG, "state: Transport line did not contain port.");

    goto err;

  }

  r = 1;

  goto done;

 err:

  r = 0;

 done:

  SMARTLIST_FOREACH(items, char*, s, tor_free(s));

  smartlist_free(items);

  return r;

}

/** Return 0 if all TransportProxy lines in <b>state</b> are well

 *  formed. Otherwise, return -1. */

static int

validate_transports_in_state(or_state_t *state)

{

  int broken = 0;

  config_line_t *line;

  for (line = state->TransportProxies ; line ; line = line->next) {

    tor_assert(!strcmp(line->key, "TransportProxy"));

    if (!state_transport_line_is_valid(line->value))

      broken = 1;

  }

  if (broken)

    log_warn(LD_CONFIG, "state: State file seems to be broken.");

  return 0;

}

/** Return 0 if every setting in <b>state</b> is reasonable, and a

 * permissible transition from <b>old_state</b>.  Else warn and return -1.

 * Should have no side effects, except for normalizing the contents of

 * <b>state</b>.

 */

static int

or_state_validate(or_state_t *state, char **msg)

{

  return config_validate(get_state_mgr(), NULL, state, msg);

}

/**

 * Legacy validation/normalization callback for or_state_t.  See

 * legacy_validate_fn_t for more information.

 */

static int

or_state_validate_cb(const void *old_state, void *state_, char **msg)

{

  /* There is not a meaningful concept of a state-to-state transition,

   * since we do not reload the state after we start. */

  (void) old_state;

  CHECK_STATE_MAGIC(state_);

  or_state_t *state = state_;

  if (entry_guards_parse_state(state, 0, msg)<0)

    return -1;

  if (validate_transports_in_state(state)<0)

    return -1;

  return 0;

}

/** Replace the current persistent state with <b>new_state</b> */

static int

or_state_set(or_state_t *new_state)

{

  char *err = NULL;

  int ret = 0;

  tor_assert(new_state);

  config_free(get_state_mgr(), global_state);

  global_state = new_state;

  if (subsystems_set_state(get_state_mgr(), global_state) < 0) {

    ret = -1;

  }

  if (entry_guards_parse_state(global_state, 1, &err)<0) {

    log_warn(LD_GENERAL,"%s",err);

    tor_free(err);

    ret = -1;

  }

  if (bwhist_load_state(global_state, &err)<0) {

    log_warn(LD_GENERAL,"Unparseable bandwidth history state: %s",err);

    tor_free(err);

    ret = -1;

  }

  if (circuit_build_times_parse_state(

      get_circuit_build_times_mutable(),global_state) < 0) {

    ret = -1;

  }

  return ret;

}

/**

 * Save a broken state file to a backup location.

 */

static void

or_state_save_broken(char *fname)

{

  int i, res;

  file_status_t status;

  char *fname2 = NULL;

  for (i = 0; i < 100; ++i) {

    tor_asprintf(&fname2, "%s.%d", fname, i);

    status = file_status(fname2);

    if (status == FN_NOENT)

      break;

    tor_free(fname2);

  }

  if (i == 100) {

    log_warn(LD_BUG, "Unable to parse state in \"%s\"; too many saved bad "

             "state files to move aside. Discarding the old state file.",

             fname);

    res = unlink(fname);

    if (res != 0) {

      log_warn(LD_FS,

               "Also couldn't discard old state file \"%s\" because "

               "unlink() failed: %s",

               fname, strerror(errno));

    }

  } else {

    log_warn(LD_BUG, "Unable to parse state in \"%s\". Moving it aside "

             "to \"%s\".  This could be a bug in Tor; please tell "

             "the developers.", fname, fname2);

    if (tor_rename(fname, fname2) < 0) {//XXXX sandbox prohibits

      log_warn(LD_BUG, "Weirdly, I couldn't even move the state aside. The "

               "OS gave an error of %s", strerror(errno));

    }

  }

  tor_free(fname2);

}

STATIC or_state_t *

or_state_new(void)

{

  or_state_t *new_state = config_new(get_state_mgr());

  config_init(get_state_mgr(), new_state);

  return new_state;

}

/** Reload the persistent state from disk, generating a new state as needed.

 * Return 0 on success, less than 0 on failure.

 */

int

or_state_load(void)

{

  or_state_t *new_state = NULL;

  char *contents = NULL, *fname;

  char *errmsg = NULL;

  int r = -1, badstate = 0;

  fname = get_datadir_fname("state");

  switch (file_status(fname)) {

    case FN_FILE:

      if (!(contents = read_file_to_str(fname, 0, NULL))) {

        log_warn(LD_FS, "Unable to read state file \"%s\"", fname);

        goto done;

      }

      break;

    /* treat empty state files as if the file doesn't exist, and generate

     * a new state file, overwriting the empty file in or_state_save() */

    case FN_NOENT:

    case FN_EMPTY:

      break;

    case FN_ERROR:

    case FN_DIR:

    default:

      log_warn(LD_GENERAL,"State file \"%s\" is not a file? Failing.", fname);

      goto done;

  }

  new_state = or_state_new();

  if (contents) {

    config_line_t *lines=NULL;

    int assign_retval;

    if (config_get_lines(contents, &lines, 0)<0)

      goto done;

    assign_retval = config_assign(get_state_mgr(), new_state,

                                  lines, 0, &errmsg);

    config_free_lines(lines);

    if (assign_retval<0)

      badstate = 1;

    if (errmsg) {

      log_warn(LD_GENERAL, "%s", errmsg);

      tor_free(errmsg);

    }

  }

  if (!badstate && or_state_validate(new_state, &errmsg) < 0)

    badstate = 1;

  if (errmsg) {

    log_warn(LD_GENERAL, "%s", errmsg);

    tor_free(errmsg);

  }

  if (badstate && !contents) {

    log_warn(LD_BUG, "Uh oh.  We couldn't even validate our own default state."

             " This is a bug in Tor.");

    goto done;

  } else if (badstate && contents) {

    or_state_save_broken(fname);

    tor_free(contents);

    config_free(get_state_mgr(), new_state);

    new_state = or_state_new();

  } else if (contents) {

    log_info(LD_GENERAL, "Loaded state from \"%s\"", fname);

    /* Warn the user if their clock has been set backwards,

     * they could be tricked into using old consensuses */

    time_t apparent_skew = time(NULL) - new_state->LastWritten;

    if (apparent_skew < 0) {

      /* Initialize bootstrap event reporting because we might call

       * clock_skew_warning() before the bootstrap state is

       * initialized, causing an assertion failure. */

      control_event_bootstrap(BOOTSTRAP_STATUS_STARTING, 0);

      clock_skew_warning(NULL, (long)apparent_skew, 1, LD_GENERAL,

                         "local state file", fname);

    }

  } else {

    log_info(LD_GENERAL, "Initialized state");

  }

  or_state_remove_obsolete_lines(&new_state->ExtraLines);

  if (or_state_set(new_state) == -1) {

    or_state_save_broken(fname);

  }

  new_state = NULL;

  if (!contents) {

    global_state->next_write = 0;

    or_state_save(time(NULL));

  }

  r = 0;

 done:

  tor_free(fname);

  tor_free(contents);

  if (new_state)

    config_free(get_state_mgr(), new_state);

  return r;

}

/** Remove from `extra_lines` every element whose key appears in

 * `obsolete_state_keys`. */

STATIC void

or_state_remove_obsolete_lines(config_line_t **extra_lines)

{

  /* make a strmap for the obsolete state names, so we can have O(1)

     lookup. */

  strmap_t *bad_keys = strmap_new();

  for (unsigned i = 0; obsolete_state_keys[i] != NULL; ++i) {

    strmap_set_lc(bad_keys, obsolete_state_keys[i], (void*)"rmv");

  }

  config_line_t **line = extra_lines;

  while (*line) {

    if (strmap_get_lc(bad_keys, (*line)->key) != NULL) {

      /* This key is obsolete; remove it. */

      config_line_t *victim = *line;

      *line = (*line)->next;

      victim->next = NULL; // prevent double-free.

      config_free_lines(victim);

    } else {

      /* This is just an unrecognized key; keep it. */

      line = &(*line)->next;

    }

  }

  strmap_free(bad_keys, NULL);

}

/** Did the last time we tried to write the state file fail? If so, we

 * should consider disabling such features as preemptive circuit generation

 * to compute circuit-build-time. */

static int last_state_file_write_failed = 0;

/** Return whether the state file failed to write last time we tried. */

int

did_last_state_file_write_fail(void)

{

  return last_state_file_write_failed;

}

/** If writing the state to disk fails, try again after this many seconds. */

#define STATE_WRITE_RETRY_INTERVAL 3600

/** If we're a relay, how often should we checkpoint our state file even

 * if nothing else dirties it? This will checkpoint ongoing stats like

 * bandwidth used, per-country user stats, etc. */

#define STATE_RELAY_CHECKPOINT_INTERVAL (12*60*60)

/** Write the persistent state to disk. Return 0 for success, <0 on failure. */

int

or_state_save(time_t now)

{

  char *state, *contents;

  char tbuf[ISO_TIME_LEN+1];

  char *fname;

  tor_assert(global_state);

  if (global_state->next_write > now)

    return 0;

  /* Call everything else that might dirty the state even more, in order

   * to avoid redundant writes. */

  (void) subsystems_flush_state(get_state_mgr(), global_state);

  entry_guards_update_state(global_state);

  bwhist_update_state(global_state);

  circuit_build_times_update_state(get_circuit_build_times(), global_state);

  if (accounting_is_enabled(get_options()))

    accounting_run_housekeeping(now);

  global_state->LastWritten = now;

  tor_free(global_state->TorVersion);

  tor_asprintf(&global_state->TorVersion, "Tor %s", get_version());

  state = config_dump(get_state_mgr(), NULL, global_state, 1, 0);

  format_local_iso_time(tbuf, now);

  tor_asprintf(&contents,

               "# Tor state file last generated on %s local time\n"

               "# Other times below are in UTC\n"

               "# You *do not* need to edit this file.\n\n%s",

               tbuf, state);

  tor_free(state);

  fname = get_datadir_fname("state");

  if (write_str_to_file(fname, contents, 0)<0) {

    log_warn(LD_FS, "Unable to write state to file \"%s\"; "

             "will try again later", fname);

    last_state_file_write_failed = 1;

    tor_free(fname);

    tor_free(contents);

    /* Try again after STATE_WRITE_RETRY_INTERVAL (or sooner, if the state

     * changes sooner). */

    global_state->next_write = now + STATE_WRITE_RETRY_INTERVAL;

    return -1;

  }

  last_state_file_write_failed = 0;

  log_info(LD_GENERAL, "Saved state to \"%s\"", fname);

  tor_free(fname);

  tor_free(contents);

  if (server_mode(get_options()))

    global_state->next_write = now + STATE_RELAY_CHECKPOINT_INTERVAL;

  else

    global_state->next_write = TIME_MAX;

  return 0;

}

/** Return the config line for transport <b>transport</b> in the current state.

 *  Return NULL if there is no config line for <b>transport</b>. */

STATIC config_line_t *

get_transport_in_state_by_name(const char *transport)

{

  or_state_t *or_state = get_or_state();

  config_line_t *line;

  config_line_t *ret = NULL;

  smartlist_t *items = NULL;

  for (line = or_state->TransportProxies ; line ; line = line->next) {

    tor_assert(!strcmp(line->key, "TransportProxy"));

    items = smartlist_new();

    smartlist_split_string(items, line->value, NULL,

                           SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, -1);

    if (smartlist_len(items) != 2) /* broken state */

      goto done;

    if (!strcmp(smartlist_get(items, 0), transport)) {

      ret = line;

      goto done;

    }

    SMARTLIST_FOREACH(items, char*, s, tor_free(s));

    smartlist_free(items);

    items = NULL;

  }

 done:

  if (items) {

    SMARTLIST_FOREACH(items, char*, s, tor_free(s));

    smartlist_free(items);

  }

  return ret;

}

/** Return string containing the address:port part of the

 *  TransportProxy <b>line</b> for transport <b>transport</b>.

 *  If the line is corrupted, return NULL. */

static const char *

get_transport_bindaddr(const char *line, const char *transport)

{

  char *line_tmp = NULL;

  if (strlen(line) < strlen(transport) + 2) {

    goto broken_state;

  } else {

    /* line should start with the name of the transport and a space.

       (for example, "obfs2 127.0.0.1:47245") */

    tor_asprintf(&line_tmp, "%s ", transport);

    if (strcmpstart(line, line_tmp))

      goto broken_state;

    tor_free(line_tmp);

    return (line+strlen(transport)+1);

  }

 broken_state:

  tor_free(line_tmp);

  return NULL;

}

/** Return a string containing the address:port that a proxy transport

 *  should bind on. The string is stored on the heap and must be freed

 *  by the caller of this function. */

char *

get_stored_bindaddr_for_server_transport(const char *transport)

{

  char *default_addrport = NULL;

  const char *stored_bindaddr = NULL;

  config_line_t *line = NULL;

  {

    /* See if the user explicitly asked for a specific listening

       address for this transport. */

    char *conf_bindaddr = pt_get_bindaddr_from_config(transport);

    if (conf_bindaddr)

      return conf_bindaddr;

  }

  line = get_transport_in_state_by_name(transport);

  if (!line) /* Found no references in state for this transport. */

    goto no_bindaddr_found;

  stored_bindaddr = get_transport_bindaddr(line->value, transport);

  if (stored_bindaddr) /* found stored bindaddr in state file. */

    return tor_strdup(stored_bindaddr);

 no_bindaddr_found:

  /** If we didn't find references for this pluggable transport in the

      state file, we should instruct the pluggable transport proxy to

      listen on INADDR_ANY on a random ephemeral port. */

  tor_asprintf(&default_addrport, "%s:%s", fmt_addr32(INADDR_ANY), "0");

  return default_addrport;

}

/** Save <b>transport</b> listening on <b>addr</b>:<b>port</b> to

    state */

void

save_transport_to_state(const char *transport,

                        const tor_addr_t *addr, uint16_t port)

{

  or_state_t *state = get_or_state();

  char *transport_addrport=NULL;

  /** find where to write on the state */

  config_line_t **next, *line;

  /* see if this transport is already stored in state */

  config_line_t *transport_line =

    get_transport_in_state_by_name(transport);

  if (transport_line) { /* if transport already exists in state... */

    const char *prev_bindaddr = /* get its addrport... */

      get_transport_bindaddr(transport_line->value, transport);

    transport_addrport = tor_strdup(fmt_addrport(addr, port));

    /* if transport in state has the same address as this one, life is good */

    if (!strcmp(prev_bindaddr, transport_addrport)) {

      log_info(LD_CONFIG, "Transport seems to have spawned on its usual "

               "address:port.");

      goto done;

    } else { /* if addrport in state is different than the one we got */

      log_info(LD_CONFIG, "Transport seems to have spawned on different "

               "address:port. Let's update the state file with the new "

               "address:port");

      tor_free(transport_line->value); /* free the old line */

      /* replace old addrport line with new line */

      tor_asprintf(&transport_line->value, "%s %s", transport,

                   fmt_addrport(addr, port));

    }

  } else { /* never seen this one before; save it in state for next time */

    log_info(LD_CONFIG, "It's the first time we see this transport. "

             "Let's save its address:port");

    next = &state->TransportProxies;

    /* find the last TransportProxy line in the state and point 'next'

       right after it  */

    line = state->TransportProxies;

    while (line) {

      next = &(line->next);

      line = line->next;

    }

    /* allocate space for the new line and fill it in */

    *next = line = tor_malloc_zero(sizeof(config_line_t));

    line->key = tor_strdup("TransportProxy");

    tor_asprintf(&line->value, "%s %s", transport, fmt_addrport(addr, port));

  }

  if (!get_options()->AvoidDiskWrites)

    or_state_mark_dirty(state, 0);

 done:

  tor_free(transport_addrport);

}

/** Change the next_write time of <b>state</b> to <b>when</b>, unless the

 * state is already scheduled to be written to disk earlier than <b>when</b>.

 */

void

or_state_mark_dirty(or_state_t *state, time_t when)

{

  if (state->next_write > when) {

    state->next_write = when;

    reschedule_or_state_save();

  }

}

STATIC void

or_state_free_(or_state_t *state)

{

  if (!state)

    return;

  config_free(get_state_mgr(), state);

}

void

or_state_free_all(void)

{

  or_state_free(global_state);

  global_state = NULL;

  config_mgr_free(state_mgr);

}