tor

statefile.c (24914B)

---

/* 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);
}