statefile.c 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698
  1. /* Copyright (c) 2001 Matej Pfajfar.
  2. * Copyright (c) 2001-2004, Roger Dingledine.
  3. * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
  4. * Copyright (c) 2007-2017, The Tor Project, Inc. */
  5. /* See LICENSE for licensing information */
  6. /**
  7. * \file statefile.c
  8. *
  9. * \brief Handles parsing and encoding the persistent 'state' file that carries
  10. * miscellaneous persistent state between Tor invocations.
  11. *
  12. * This 'state' file is a typed key-value store that allows multiple
  13. * entries for the same key. It follows the same metaformat as described
  14. * in confparse.c, and uses the same code to read and write itself.
  15. *
  16. * The state file is most suitable for small values that don't change too
  17. * frequently. For values that become very large, we typically use a separate
  18. * file -- for example, see how we handle microdescriptors, by storing them in
  19. * a separate file with a journal.
  20. *
  21. * The current state is accessed via get_or_state(), which returns a singleton
  22. * or_state_t object. Functions that change it should call
  23. * or_state_mark_dirty() to ensure that it will get written to disk.
  24. *
  25. * The or_state_save() function additionally calls various functioens
  26. * throughout Tor that might want to flush more state to the the disk,
  27. * including some in rephist.c, entrynodes.c, circuitstats.c, hibernate.c.
  28. */
  29. #define STATEFILE_PRIVATE
  30. #include "or.h"
  31. #include "circuitstats.h"
  32. #include "config.h"
  33. #include "confparse.h"
  34. #include "connection.h"
  35. #include "control.h"
  36. #include "entrynodes.h"
  37. #include "hibernate.h"
  38. #include "rephist.h"
  39. #include "router.h"
  40. #include "sandbox.h"
  41. #include "statefile.h"
  42. /** A list of state-file "abbreviations," for compatibility. */
  43. static config_abbrev_t state_abbrevs_[] = {
  44. { "AccountingBytesReadInterval", "AccountingBytesReadInInterval", 0, 0 },
  45. { "HelperNode", "EntryGuard", 0, 0 },
  46. { "HelperNodeDownSince", "EntryGuardDownSince", 0, 0 },
  47. { "HelperNodeUnlistedSince", "EntryGuardUnlistedSince", 0, 0 },
  48. { "EntryNode", "EntryGuard", 0, 0 },
  49. { "EntryNodeDownSince", "EntryGuardDownSince", 0, 0 },
  50. { "EntryNodeUnlistedSince", "EntryGuardUnlistedSince", 0, 0 },
  51. { NULL, NULL, 0, 0},
  52. };
  53. /** dummy instance of or_state_t, used for type-checking its
  54. * members with CONF_CHECK_VAR_TYPE. */
  55. DUMMY_TYPECHECK_INSTANCE(or_state_t);
  56. /*XXXX these next two are duplicates or near-duplicates from config.c */
  57. #define VAR(name,conftype,member,initvalue) \
  58. { name, CONFIG_TYPE_ ## conftype, offsetof(or_state_t, member), \
  59. initvalue CONF_TEST_MEMBERS(or_state_t, conftype, member) }
  60. /** As VAR, but the option name and member name are the same. */
  61. #define V(member,conftype,initvalue) \
  62. VAR(#member, conftype, member, initvalue)
  63. /** Array of "state" variables saved to the ~/.tor/state file. */
  64. static config_var_t state_vars_[] = {
  65. /* Remember to document these in state-contents.txt ! */
  66. V(AccountingBytesReadInInterval, MEMUNIT, NULL),
  67. V(AccountingBytesWrittenInInterval, MEMUNIT, NULL),
  68. V(AccountingExpectedUsage, MEMUNIT, NULL),
  69. V(AccountingIntervalStart, ISOTIME, NULL),
  70. V(AccountingSecondsActive, INTERVAL, NULL),
  71. V(AccountingSecondsToReachSoftLimit,INTERVAL, NULL),
  72. V(AccountingSoftLimitHitAt, ISOTIME, NULL),
  73. V(AccountingBytesAtSoftLimit, MEMUNIT, NULL),
  74. VAR("EntryGuard", LINELIST_S, EntryGuards, NULL),
  75. VAR("EntryGuardDownSince", LINELIST_S, EntryGuards, NULL),
  76. VAR("EntryGuardUnlistedSince", LINELIST_S, EntryGuards, NULL),
  77. VAR("EntryGuardAddedBy", LINELIST_S, EntryGuards, NULL),
  78. VAR("EntryGuardPathBias", LINELIST_S, EntryGuards, NULL),
  79. VAR("EntryGuardPathUseBias", LINELIST_S, EntryGuards, NULL),
  80. V(EntryGuards, LINELIST_V, NULL),
  81. VAR("TransportProxy", LINELIST_S, TransportProxies, NULL),
  82. V(TransportProxies, LINELIST_V, NULL),
  83. V(HidServRevCounter, LINELIST, NULL),
  84. V(BWHistoryReadEnds, ISOTIME, NULL),
  85. V(BWHistoryReadInterval, UINT, "900"),
  86. V(BWHistoryReadValues, CSV, ""),
  87. V(BWHistoryReadMaxima, CSV, ""),
  88. V(BWHistoryWriteEnds, ISOTIME, NULL),
  89. V(BWHistoryWriteInterval, UINT, "900"),
  90. V(BWHistoryWriteValues, CSV, ""),
  91. V(BWHistoryWriteMaxima, CSV, ""),
  92. V(BWHistoryDirReadEnds, ISOTIME, NULL),
  93. V(BWHistoryDirReadInterval, UINT, "900"),
  94. V(BWHistoryDirReadValues, CSV, ""),
  95. V(BWHistoryDirReadMaxima, CSV, ""),
  96. V(BWHistoryDirWriteEnds, ISOTIME, NULL),
  97. V(BWHistoryDirWriteInterval, UINT, "900"),
  98. V(BWHistoryDirWriteValues, CSV, ""),
  99. V(BWHistoryDirWriteMaxima, CSV, ""),
  100. V(Guard, LINELIST, NULL),
  101. V(TorVersion, STRING, NULL),
  102. V(LastRotatedOnionKey, ISOTIME, NULL),
  103. V(LastWritten, ISOTIME, NULL),
  104. V(TotalBuildTimes, UINT, NULL),
  105. V(CircuitBuildAbandonedCount, UINT, "0"),
  106. VAR("CircuitBuildTimeBin", LINELIST_S, BuildtimeHistogram, NULL),
  107. VAR("BuildtimeHistogram", LINELIST_V, BuildtimeHistogram, NULL),
  108. END_OF_CONFIG_VARS
  109. };
  110. #undef VAR
  111. #undef V
  112. static int or_state_validate(or_state_t *state, char **msg);
  113. static int or_state_validate_cb(void *old_options, void *options,
  114. void *default_options,
  115. int from_setconf, char **msg);
  116. /** Magic value for or_state_t. */
  117. #define OR_STATE_MAGIC 0x57A73f57
  118. /** "Extra" variable in the state that receives lines we can't parse. This
  119. * lets us preserve options from versions of Tor newer than us. */
  120. static config_var_t state_extra_var = {
  121. "__extra", CONFIG_TYPE_LINELIST, offsetof(or_state_t, ExtraLines), NULL
  122. CONF_TEST_MEMBERS(or_state_t, LINELIST, ExtraLines)
  123. };
  124. /** Configuration format for or_state_t. */
  125. static const config_format_t state_format = {
  126. sizeof(or_state_t),
  127. OR_STATE_MAGIC,
  128. offsetof(or_state_t, magic_),
  129. state_abbrevs_,
  130. NULL,
  131. state_vars_,
  132. or_state_validate_cb,
  133. &state_extra_var,
  134. };
  135. /** Persistent serialized state. */
  136. static or_state_t *global_state = NULL;
  137. /** Return the persistent state struct for this Tor. */
  138. MOCK_IMPL(or_state_t *,
  139. get_or_state, (void))
  140. {
  141. tor_assert(global_state);
  142. return global_state;
  143. }
  144. /** Return true iff we have loaded the global state for this Tor */
  145. int
  146. or_state_loaded(void)
  147. {
  148. return global_state != NULL;
  149. }
  150. /** Return true if <b>line</b> is a valid state TransportProxy line.
  151. * Return false otherwise. */
  152. static int
  153. state_transport_line_is_valid(const char *line)
  154. {
  155. smartlist_t *items = NULL;
  156. char *addrport=NULL;
  157. tor_addr_t addr;
  158. uint16_t port = 0;
  159. int r;
  160. items = smartlist_new();
  161. smartlist_split_string(items, line, NULL,
  162. SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, -1);
  163. if (smartlist_len(items) != 2) {
  164. log_warn(LD_CONFIG, "state: Not enough arguments in TransportProxy line.");
  165. goto err;
  166. }
  167. addrport = smartlist_get(items, 1);
  168. if (tor_addr_port_lookup(addrport, &addr, &port) < 0) {
  169. log_warn(LD_CONFIG, "state: Could not parse addrport.");
  170. goto err;
  171. }
  172. if (!port) {
  173. log_warn(LD_CONFIG, "state: Transport line did not contain port.");
  174. goto err;
  175. }
  176. r = 1;
  177. goto done;
  178. err:
  179. r = 0;
  180. done:
  181. SMARTLIST_FOREACH(items, char*, s, tor_free(s));
  182. smartlist_free(items);
  183. return r;
  184. }
  185. /** Return 0 if all TransportProxy lines in <b>state</b> are well
  186. * formed. Otherwise, return -1. */
  187. static int
  188. validate_transports_in_state(or_state_t *state)
  189. {
  190. int broken = 0;
  191. config_line_t *line;
  192. for (line = state->TransportProxies ; line ; line = line->next) {
  193. tor_assert(!strcmp(line->key, "TransportProxy"));
  194. if (!state_transport_line_is_valid(line->value))
  195. broken = 1;
  196. }
  197. if (broken)
  198. log_warn(LD_CONFIG, "state: State file seems to be broken.");
  199. return 0;
  200. }
  201. static int
  202. or_state_validate_cb(void *old_state, void *state, void *default_state,
  203. int from_setconf, char **msg)
  204. {
  205. /* We don't use these; only options do. Still, we need to match that
  206. * signature. */
  207. (void) from_setconf;
  208. (void) default_state;
  209. (void) old_state;
  210. return or_state_validate(state, msg);
  211. }
  212. /** Return 0 if every setting in <b>state</b> is reasonable, and a
  213. * permissible transition from <b>old_state</b>. Else warn and return -1.
  214. * Should have no side effects, except for normalizing the contents of
  215. * <b>state</b>.
  216. */
  217. static int
  218. or_state_validate(or_state_t *state, char **msg)
  219. {
  220. if (entry_guards_parse_state(state, 0, msg)<0)
  221. return -1;
  222. if (validate_transports_in_state(state)<0)
  223. return -1;
  224. return 0;
  225. }
  226. /** Replace the current persistent state with <b>new_state</b> */
  227. static int
  228. or_state_set(or_state_t *new_state)
  229. {
  230. char *err = NULL;
  231. int ret = 0;
  232. tor_assert(new_state);
  233. config_free(&state_format, global_state);
  234. global_state = new_state;
  235. if (entry_guards_parse_state(global_state, 1, &err)<0) {
  236. log_warn(LD_GENERAL,"%s",err);
  237. tor_free(err);
  238. ret = -1;
  239. }
  240. if (rep_hist_load_state(global_state, &err)<0) {
  241. log_warn(LD_GENERAL,"Unparseable bandwidth history state: %s",err);
  242. tor_free(err);
  243. ret = -1;
  244. }
  245. if (circuit_build_times_parse_state(
  246. get_circuit_build_times_mutable(),global_state) < 0) {
  247. ret = -1;
  248. }
  249. return ret;
  250. }
  251. /**
  252. * Save a broken state file to a backup location.
  253. */
  254. static void
  255. or_state_save_broken(char *fname)
  256. {
  257. int i, res;
  258. file_status_t status;
  259. char *fname2 = NULL;
  260. for (i = 0; i < 100; ++i) {
  261. tor_asprintf(&fname2, "%s.%d", fname, i);
  262. status = file_status(fname2);
  263. if (status == FN_NOENT)
  264. break;
  265. tor_free(fname2);
  266. }
  267. if (i == 100) {
  268. log_warn(LD_BUG, "Unable to parse state in \"%s\"; too many saved bad "
  269. "state files to move aside. Discarding the old state file.",
  270. fname);
  271. res = unlink(fname);
  272. if (res != 0) {
  273. log_warn(LD_FS,
  274. "Also couldn't discard old state file \"%s\" because "
  275. "unlink() failed: %s",
  276. fname, strerror(errno));
  277. }
  278. } else {
  279. log_warn(LD_BUG, "Unable to parse state in \"%s\". Moving it aside "
  280. "to \"%s\". This could be a bug in Tor; please tell "
  281. "the developers.", fname, fname2);
  282. if (tor_rename(fname, fname2) < 0) {//XXXX sandbox prohibits
  283. log_warn(LD_BUG, "Weirdly, I couldn't even move the state aside. The "
  284. "OS gave an error of %s", strerror(errno));
  285. }
  286. }
  287. tor_free(fname2);
  288. }
  289. STATIC or_state_t *
  290. or_state_new(void)
  291. {
  292. or_state_t *new_state = tor_malloc_zero(sizeof(or_state_t));
  293. new_state->magic_ = OR_STATE_MAGIC;
  294. config_init(&state_format, new_state);
  295. return new_state;
  296. }
  297. /** Reload the persistent state from disk, generating a new state as needed.
  298. * Return 0 on success, less than 0 on failure.
  299. */
  300. int
  301. or_state_load(void)
  302. {
  303. or_state_t *new_state = NULL;
  304. char *contents = NULL, *fname;
  305. char *errmsg = NULL;
  306. int r = -1, badstate = 0;
  307. fname = get_datadir_fname("state");
  308. switch (file_status(fname)) {
  309. case FN_FILE:
  310. if (!(contents = read_file_to_str(fname, 0, NULL))) {
  311. log_warn(LD_FS, "Unable to read state file \"%s\"", fname);
  312. goto done;
  313. }
  314. break;
  315. /* treat empty state files as if the file doesn't exist, and generate
  316. * a new state file, overwriting the empty file in or_state_save() */
  317. case FN_NOENT:
  318. case FN_EMPTY:
  319. break;
  320. case FN_ERROR:
  321. case FN_DIR:
  322. default:
  323. log_warn(LD_GENERAL,"State file \"%s\" is not a file? Failing.", fname);
  324. goto done;
  325. }
  326. new_state = or_state_new();
  327. if (contents) {
  328. config_line_t *lines=NULL;
  329. int assign_retval;
  330. if (config_get_lines(contents, &lines, 0)<0)
  331. goto done;
  332. assign_retval = config_assign(&state_format, new_state,
  333. lines, 0, &errmsg);
  334. config_free_lines(lines);
  335. if (assign_retval<0)
  336. badstate = 1;
  337. if (errmsg) {
  338. log_warn(LD_GENERAL, "%s", errmsg);
  339. tor_free(errmsg);
  340. }
  341. }
  342. if (!badstate && or_state_validate(new_state, &errmsg) < 0)
  343. badstate = 1;
  344. if (errmsg) {
  345. log_warn(LD_GENERAL, "%s", errmsg);
  346. tor_free(errmsg);
  347. }
  348. if (badstate && !contents) {
  349. log_warn(LD_BUG, "Uh oh. We couldn't even validate our own default state."
  350. " This is a bug in Tor.");
  351. goto done;
  352. } else if (badstate && contents) {
  353. or_state_save_broken(fname);
  354. tor_free(contents);
  355. config_free(&state_format, new_state);
  356. new_state = or_state_new();
  357. } else if (contents) {
  358. log_info(LD_GENERAL, "Loaded state from \"%s\"", fname);
  359. /* Warn the user if their clock has been set backwards,
  360. * they could be tricked into using old consensuses */
  361. time_t apparent_skew = time(NULL) - new_state->LastWritten;
  362. if (apparent_skew < 0) {
  363. /* Initialize bootstrap event reporting because we might call
  364. * clock_skew_warning() before the bootstrap state is
  365. * initialized, causing an assertion failure. */
  366. control_event_bootstrap(BOOTSTRAP_STATUS_STARTING, 0);
  367. clock_skew_warning(NULL, (long)apparent_skew, 1, LD_GENERAL,
  368. "local state file", fname);
  369. }
  370. } else {
  371. log_info(LD_GENERAL, "Initialized state");
  372. }
  373. if (or_state_set(new_state) == -1) {
  374. or_state_save_broken(fname);
  375. }
  376. new_state = NULL;
  377. if (!contents) {
  378. global_state->next_write = 0;
  379. or_state_save(time(NULL));
  380. }
  381. r = 0;
  382. done:
  383. tor_free(fname);
  384. tor_free(contents);
  385. if (new_state)
  386. config_free(&state_format, new_state);
  387. return r;
  388. }
  389. /** Did the last time we tried to write the state file fail? If so, we
  390. * should consider disabling such features as preemptive circuit generation
  391. * to compute circuit-build-time. */
  392. static int last_state_file_write_failed = 0;
  393. /** Return whether the state file failed to write last time we tried. */
  394. int
  395. did_last_state_file_write_fail(void)
  396. {
  397. return last_state_file_write_failed;
  398. }
  399. /** If writing the state to disk fails, try again after this many seconds. */
  400. #define STATE_WRITE_RETRY_INTERVAL 3600
  401. /** If we're a relay, how often should we checkpoint our state file even
  402. * if nothing else dirties it? This will checkpoint ongoing stats like
  403. * bandwidth used, per-country user stats, etc. */
  404. #define STATE_RELAY_CHECKPOINT_INTERVAL (12*60*60)
  405. /** Write the persistent state to disk. Return 0 for success, <0 on failure. */
  406. int
  407. or_state_save(time_t now)
  408. {
  409. char *state, *contents;
  410. char tbuf[ISO_TIME_LEN+1];
  411. char *fname;
  412. tor_assert(global_state);
  413. if (global_state->next_write > now)
  414. return 0;
  415. /* Call everything else that might dirty the state even more, in order
  416. * to avoid redundant writes. */
  417. entry_guards_update_state(global_state);
  418. rep_hist_update_state(global_state);
  419. circuit_build_times_update_state(get_circuit_build_times(), global_state);
  420. if (accounting_is_enabled(get_options()))
  421. accounting_run_housekeeping(now);
  422. global_state->LastWritten = now;
  423. tor_free(global_state->TorVersion);
  424. tor_asprintf(&global_state->TorVersion, "Tor %s", get_version());
  425. state = config_dump(&state_format, NULL, global_state, 1, 0);
  426. format_local_iso_time(tbuf, now);
  427. tor_asprintf(&contents,
  428. "# Tor state file last generated on %s local time\n"
  429. "# Other times below are in UTC\n"
  430. "# You *do not* need to edit this file.\n\n%s",
  431. tbuf, state);
  432. tor_free(state);
  433. fname = get_datadir_fname("state");
  434. if (write_str_to_file(fname, contents, 0)<0) {
  435. log_warn(LD_FS, "Unable to write state to file \"%s\"; "
  436. "will try again later", fname);
  437. last_state_file_write_failed = 1;
  438. tor_free(fname);
  439. tor_free(contents);
  440. /* Try again after STATE_WRITE_RETRY_INTERVAL (or sooner, if the state
  441. * changes sooner). */
  442. global_state->next_write = now + STATE_WRITE_RETRY_INTERVAL;
  443. return -1;
  444. }
  445. last_state_file_write_failed = 0;
  446. log_info(LD_GENERAL, "Saved state to \"%s\"", fname);
  447. tor_free(fname);
  448. tor_free(contents);
  449. if (server_mode(get_options()))
  450. global_state->next_write = now + STATE_RELAY_CHECKPOINT_INTERVAL;
  451. else
  452. global_state->next_write = TIME_MAX;
  453. return 0;
  454. }
  455. /** Return the config line for transport <b>transport</b> in the current state.
  456. * Return NULL if there is no config line for <b>transport</b>. */
  457. STATIC config_line_t *
  458. get_transport_in_state_by_name(const char *transport)
  459. {
  460. or_state_t *or_state = get_or_state();
  461. config_line_t *line;
  462. config_line_t *ret = NULL;
  463. smartlist_t *items = NULL;
  464. for (line = or_state->TransportProxies ; line ; line = line->next) {
  465. tor_assert(!strcmp(line->key, "TransportProxy"));
  466. items = smartlist_new();
  467. smartlist_split_string(items, line->value, NULL,
  468. SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, -1);
  469. if (smartlist_len(items) != 2) /* broken state */
  470. goto done;
  471. if (!strcmp(smartlist_get(items, 0), transport)) {
  472. ret = line;
  473. goto done;
  474. }
  475. SMARTLIST_FOREACH(items, char*, s, tor_free(s));
  476. smartlist_free(items);
  477. items = NULL;
  478. }
  479. done:
  480. if (items) {
  481. SMARTLIST_FOREACH(items, char*, s, tor_free(s));
  482. smartlist_free(items);
  483. }
  484. return ret;
  485. }
  486. /** Return string containing the address:port part of the
  487. * TransportProxy <b>line</b> for transport <b>transport</b>.
  488. * If the line is corrupted, return NULL. */
  489. static const char *
  490. get_transport_bindaddr(const char *line, const char *transport)
  491. {
  492. char *line_tmp = NULL;
  493. if (strlen(line) < strlen(transport) + 2) {
  494. goto broken_state;
  495. } else {
  496. /* line should start with the name of the transport and a space.
  497. (for example, "obfs2 127.0.0.1:47245") */
  498. tor_asprintf(&line_tmp, "%s ", transport);
  499. if (strcmpstart(line, line_tmp))
  500. goto broken_state;
  501. tor_free(line_tmp);
  502. return (line+strlen(transport)+1);
  503. }
  504. broken_state:
  505. tor_free(line_tmp);
  506. return NULL;
  507. }
  508. /** Return a string containing the address:port that a proxy transport
  509. * should bind on. The string is stored on the heap and must be freed
  510. * by the caller of this function. */
  511. char *
  512. get_stored_bindaddr_for_server_transport(const char *transport)
  513. {
  514. char *default_addrport = NULL;
  515. const char *stored_bindaddr = NULL;
  516. config_line_t *line = NULL;
  517. {
  518. /* See if the user explicitly asked for a specific listening
  519. address for this transport. */
  520. char *conf_bindaddr = get_transport_bindaddr_from_config(transport);
  521. if (conf_bindaddr)
  522. return conf_bindaddr;
  523. }
  524. line = get_transport_in_state_by_name(transport);
  525. if (!line) /* Found no references in state for this transport. */
  526. goto no_bindaddr_found;
  527. stored_bindaddr = get_transport_bindaddr(line->value, transport);
  528. if (stored_bindaddr) /* found stored bindaddr in state file. */
  529. return tor_strdup(stored_bindaddr);
  530. no_bindaddr_found:
  531. /** If we didn't find references for this pluggable transport in the
  532. state file, we should instruct the pluggable transport proxy to
  533. listen on INADDR_ANY on a random ephemeral port. */
  534. tor_asprintf(&default_addrport, "%s:%s", fmt_addr32(INADDR_ANY), "0");
  535. return default_addrport;
  536. }
  537. /** Save <b>transport</b> listening on <b>addr</b>:<b>port</b> to
  538. state */
  539. void
  540. save_transport_to_state(const char *transport,
  541. const tor_addr_t *addr, uint16_t port)
  542. {
  543. or_state_t *state = get_or_state();
  544. char *transport_addrport=NULL;
  545. /** find where to write on the state */
  546. config_line_t **next, *line;
  547. /* see if this transport is already stored in state */
  548. config_line_t *transport_line =
  549. get_transport_in_state_by_name(transport);
  550. if (transport_line) { /* if transport already exists in state... */
  551. const char *prev_bindaddr = /* get its addrport... */
  552. get_transport_bindaddr(transport_line->value, transport);
  553. transport_addrport = tor_strdup(fmt_addrport(addr, port));
  554. /* if transport in state has the same address as this one, life is good */
  555. if (!strcmp(prev_bindaddr, transport_addrport)) {
  556. log_info(LD_CONFIG, "Transport seems to have spawned on its usual "
  557. "address:port.");
  558. goto done;
  559. } else { /* if addrport in state is different than the one we got */
  560. log_info(LD_CONFIG, "Transport seems to have spawned on different "
  561. "address:port. Let's update the state file with the new "
  562. "address:port");
  563. tor_free(transport_line->value); /* free the old line */
  564. /* replace old addrport line with new line */
  565. tor_asprintf(&transport_line->value, "%s %s", transport,
  566. fmt_addrport(addr, port));
  567. }
  568. } else { /* never seen this one before; save it in state for next time */
  569. log_info(LD_CONFIG, "It's the first time we see this transport. "
  570. "Let's save its address:port");
  571. next = &state->TransportProxies;
  572. /* find the last TransportProxy line in the state and point 'next'
  573. right after it */
  574. line = state->TransportProxies;
  575. while (line) {
  576. next = &(line->next);
  577. line = line->next;
  578. }
  579. /* allocate space for the new line and fill it in */
  580. *next = line = tor_malloc_zero(sizeof(config_line_t));
  581. line->key = tor_strdup("TransportProxy");
  582. tor_asprintf(&line->value, "%s %s", transport, fmt_addrport(addr, port));
  583. }
  584. if (!get_options()->AvoidDiskWrites)
  585. or_state_mark_dirty(state, 0);
  586. done:
  587. tor_free(transport_addrport);
  588. }
  589. STATIC void
  590. or_state_free(or_state_t *state)
  591. {
  592. if (!state)
  593. return;
  594. config_free(&state_format, state);
  595. }
  596. void
  597. or_state_free_all(void)
  598. {
  599. or_state_free(global_state);
  600. global_state = NULL;
  601. }