shared_random_state.c 40 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358
  1. /* Copyright (c) 2016, The Tor Project, Inc. */
  2. /* See LICENSE for licensing information */
  3. /**
  4. * \file shared_random_state.c
  5. *
  6. * \brief Functions and data structures for the state of the random protocol
  7. * as defined in proposal #250.
  8. **/
  9. #define SHARED_RANDOM_STATE_PRIVATE
  10. #include "or.h"
  11. #include "shared_random.h"
  12. #include "config.h"
  13. #include "confparse.h"
  14. #include "dirvote.h"
  15. #include "networkstatus.h"
  16. #include "router.h"
  17. #include "shared_random_state.h"
  18. /* Default filename of the shared random state on disk. */
  19. static const char default_fname[] = "sr-state";
  20. /* String representation of a protocol phase. */
  21. static const char *phase_str[] = { "unknown", "commit", "reveal" };
  22. /* Our shared random protocol state. There is only one possible state per
  23. * protocol run so this is the global state which is reset at every run once
  24. * the shared random value has been computed. */
  25. static sr_state_t *sr_state = NULL;
  26. /* Representation of our persistent state on disk. The sr_state above
  27. * contains the data parsed from this state. When we save to disk, we
  28. * translate the sr_state to this sr_disk_state. */
  29. static sr_disk_state_t *sr_disk_state = NULL;
  30. /* Disk state file keys. */
  31. static const char dstate_commit_key[] = "Commit";
  32. static const char dstate_prev_srv_key[] = "SharedRandPreviousValue";
  33. static const char dstate_cur_srv_key[] = "SharedRandCurrentValue";
  34. /* These next two are duplicates or near-duplicates from config.c */
  35. #define VAR(name, conftype, member, initvalue) \
  36. { name, CONFIG_TYPE_ ## conftype, STRUCT_OFFSET(sr_disk_state_t, member), \
  37. initvalue }
  38. /* As VAR, but the option name and member name are the same. */
  39. #define V(member, conftype, initvalue) \
  40. VAR(#member, conftype, member, initvalue)
  41. /* Our persistent state magic number. */
  42. #define SR_DISK_STATE_MAGIC 0x98AB1254
  43. /* Each protocol phase has 12 rounds */
  44. #define SHARED_RANDOM_N_ROUNDS 12
  45. /* Number of phase we have in a protocol. */
  46. #define SHARED_RANDOM_N_PHASES 2
  47. static int
  48. disk_state_validate_cb(void *old_state, void *state, void *default_state,
  49. int from_setconf, char **msg);
  50. /* Array of variables that are saved to disk as a persistent state. */
  51. static config_var_t state_vars[] = {
  52. V(Version, UINT, "0"),
  53. V(TorVersion, STRING, NULL),
  54. V(ValidAfter, ISOTIME, NULL),
  55. V(ValidUntil, ISOTIME, NULL),
  56. V(Commit, LINELIST, NULL),
  57. V(SharedRandValues, LINELIST_V, NULL),
  58. VAR("SharedRandPreviousValue",LINELIST_S, SharedRandValues, NULL),
  59. VAR("SharedRandCurrentValue", LINELIST_S, SharedRandValues, NULL),
  60. { NULL, CONFIG_TYPE_OBSOLETE, 0, NULL }
  61. };
  62. /* "Extra" variable in the state that receives lines we can't parse. This
  63. * lets us preserve options from versions of Tor newer than us. */
  64. static config_var_t state_extra_var = {
  65. "__extra", CONFIG_TYPE_LINELIST,
  66. STRUCT_OFFSET(sr_disk_state_t, ExtraLines), NULL
  67. };
  68. /* Configuration format of sr_disk_state_t. */
  69. static const config_format_t state_format = {
  70. sizeof(sr_disk_state_t),
  71. SR_DISK_STATE_MAGIC,
  72. STRUCT_OFFSET(sr_disk_state_t, magic_),
  73. NULL,
  74. state_vars,
  75. disk_state_validate_cb,
  76. &state_extra_var,
  77. };
  78. /* Return a string representation of a protocol phase. */
  79. STATIC const char *
  80. get_phase_str(sr_phase_t phase)
  81. {
  82. const char *the_string = NULL;
  83. switch (phase) {
  84. case SR_PHASE_COMMIT:
  85. case SR_PHASE_REVEAL:
  86. the_string = phase_str[phase];
  87. break;
  88. default:
  89. /* Unknown phase shouldn't be possible. */
  90. tor_assert(0);
  91. }
  92. return the_string;
  93. }
  94. /* Return the voting interval of the tor vote subsystem. */
  95. static int
  96. get_voting_interval(void)
  97. {
  98. int interval;
  99. networkstatus_t *consensus = networkstatus_get_live_consensus(time(NULL));
  100. if (consensus) {
  101. interval = (int)(consensus->fresh_until - consensus->valid_after);
  102. } else {
  103. /* Same for both a testing and real network. We voluntarily ignore the
  104. * InitialVotingInterval since it complexifies things and it doesn't
  105. * affect the SR protocol. */
  106. interval = get_options()->V3AuthVotingInterval;
  107. }
  108. tor_assert(interval > 0);
  109. return interval;
  110. }
  111. /* Given the time <b>now</b>, return the start time of the current round of
  112. * the SR protocol. For example, if it's 23:47:08, the current round thus
  113. * started at 23:47:00 for a voting interval of 10 seconds. */
  114. static time_t
  115. get_start_time_of_current_round(time_t now)
  116. {
  117. const or_options_t *options = get_options();
  118. int voting_interval = get_voting_interval();
  119. voting_schedule_t *new_voting_schedule =
  120. get_voting_schedule(options, now, LOG_INFO);
  121. tor_assert(new_voting_schedule);
  122. /* First, get the start time of the next round */
  123. time_t next_start = new_voting_schedule->interval_starts;
  124. /* Now roll back next_start by a voting interval to find the start time of
  125. the current round. */
  126. time_t curr_start = dirvote_get_start_of_next_interval(
  127. next_start - voting_interval - 1,
  128. voting_interval,
  129. options->TestingV3AuthVotingStartOffset);
  130. tor_free(new_voting_schedule);
  131. return curr_start;
  132. }
  133. /* Return the time we should expire the state file created at <b>now</b>.
  134. * We expire the state file in the beginning of the next protocol run. */
  135. STATIC time_t
  136. get_state_valid_until_time(time_t now)
  137. {
  138. int total_rounds = SHARED_RANDOM_N_ROUNDS * SHARED_RANDOM_N_PHASES;
  139. int current_round, voting_interval, rounds_left;
  140. time_t valid_until, beginning_of_current_round;
  141. voting_interval = get_voting_interval();
  142. /* Find the time the current round started. */
  143. beginning_of_current_round = get_start_time_of_current_round(now);
  144. /* Find how many rounds are left till the end of the protocol run */
  145. current_round = (now / voting_interval) % total_rounds;
  146. rounds_left = total_rounds - current_round;
  147. /* To find the valid-until time now, take the start time of the current
  148. * round and add to it the time it takes for the leftover rounds to
  149. * complete. */
  150. valid_until = beginning_of_current_round + (rounds_left * voting_interval);
  151. { /* Logging */
  152. char tbuf[ISO_TIME_LEN + 1];
  153. format_iso_time(tbuf, valid_until);
  154. log_debug(LD_DIR, "SR: Valid until time for state set to %s.", tbuf);
  155. }
  156. return valid_until;
  157. }
  158. /* Given the consensus 'valid-after' time, return the protocol phase we should
  159. * be in. */
  160. STATIC sr_phase_t
  161. get_sr_protocol_phase(time_t valid_after)
  162. {
  163. /* Shared random protocol has two phases, commit and reveal. */
  164. int total_periods = SHARED_RANDOM_N_ROUNDS * SHARED_RANDOM_N_PHASES;
  165. int current_slot;
  166. /* Split time into slots of size 'voting_interval'. See which slot we are
  167. * currently into, and find which phase it corresponds to. */
  168. current_slot = (valid_after / get_voting_interval()) % total_periods;
  169. if (current_slot < SHARED_RANDOM_N_ROUNDS) {
  170. return SR_PHASE_COMMIT;
  171. } else {
  172. return SR_PHASE_REVEAL;
  173. }
  174. }
  175. /* Add the given <b>commit</b> to <b>state</b>. It MUST be a valid commit
  176. * and there shouldn't be a commit from the same authority in the state
  177. * already else verification hasn't been done prior. This takes ownership of
  178. * the commit once in our state. */
  179. static void
  180. commit_add_to_state(sr_commit_t *commit, sr_state_t *state)
  181. {
  182. sr_commit_t *saved_commit;
  183. tor_assert(commit);
  184. tor_assert(state);
  185. saved_commit = digestmap_set(state->commits, commit->rsa_identity,
  186. commit);
  187. if (saved_commit != NULL) {
  188. /* This means we already have that commit in our state so adding twice
  189. * the same commit is either a code flow error, a corrupted disk state
  190. * or some new unknown issue. */
  191. log_warn(LD_DIR, "SR: Commit from %s exists in our state while "
  192. "adding it: '%s'", sr_commit_get_rsa_fpr(commit),
  193. commit->encoded_commit);
  194. sr_commit_free(saved_commit);
  195. }
  196. }
  197. /* Helper: deallocate a commit object. (Used with digestmap_free(), which
  198. * requires a function pointer whose argument is void *). */
  199. static void
  200. commit_free_(void *p)
  201. {
  202. sr_commit_free(p);
  203. }
  204. /* Free a state that was allocated with state_new(). */
  205. static void
  206. state_free(sr_state_t *state)
  207. {
  208. if (state == NULL) {
  209. return;
  210. }
  211. tor_free(state->fname);
  212. digestmap_free(state->commits, commit_free_);
  213. tor_free(state->current_srv);
  214. tor_free(state->previous_srv);
  215. tor_free(state);
  216. }
  217. /* Allocate an sr_state_t object and returns it. If no <b>fname</b>, the
  218. * default file name is used. This function does NOT initialize the state
  219. * timestamp, phase or shared random value. NULL is never returned. */
  220. static sr_state_t *
  221. state_new(const char *fname, time_t now)
  222. {
  223. sr_state_t *new_state = tor_malloc_zero(sizeof(*new_state));
  224. /* If file name is not provided, use default. */
  225. if (fname == NULL) {
  226. fname = default_fname;
  227. }
  228. new_state->fname = tor_strdup(fname);
  229. new_state->version = SR_PROTO_VERSION;
  230. new_state->commits = digestmap_new();
  231. new_state->phase = get_sr_protocol_phase(now);
  232. new_state->valid_until = get_state_valid_until_time(now);
  233. return new_state;
  234. }
  235. /* Set our global state pointer with the one given. */
  236. static void
  237. state_set(sr_state_t *state)
  238. {
  239. tor_assert(state);
  240. if (sr_state != NULL) {
  241. state_free(sr_state);
  242. }
  243. sr_state = state;
  244. }
  245. /* Free an allocated disk state. */
  246. static void
  247. disk_state_free(sr_disk_state_t *state)
  248. {
  249. if (state == NULL) {
  250. return;
  251. }
  252. config_free(&state_format, state);
  253. }
  254. /* Allocate a new disk state, initialize it and return it. */
  255. static sr_disk_state_t *
  256. disk_state_new(time_t now)
  257. {
  258. sr_disk_state_t *new_state = tor_malloc_zero(sizeof(*new_state));
  259. new_state->magic_ = SR_DISK_STATE_MAGIC;
  260. new_state->Version = SR_PROTO_VERSION;
  261. new_state->TorVersion = tor_strdup(get_version());
  262. new_state->ValidUntil = get_state_valid_until_time(now);
  263. new_state->ValidAfter = now;
  264. /* Init config format. */
  265. config_init(&state_format, new_state);
  266. return new_state;
  267. }
  268. /* Set our global disk state with the given state. */
  269. static void
  270. disk_state_set(sr_disk_state_t *state)
  271. {
  272. tor_assert(state);
  273. if (sr_disk_state != NULL) {
  274. disk_state_free(sr_disk_state);
  275. }
  276. sr_disk_state = state;
  277. }
  278. /* Return -1 if the disk state is invalid (something in there that we can't or
  279. * shouldn't use). Return 0 if everything checks out. */
  280. static int
  281. disk_state_validate(const sr_disk_state_t *state)
  282. {
  283. time_t now;
  284. tor_assert(state);
  285. /* Do we support the protocol version in the state or is it 0 meaning
  286. * Version wasn't found in the state file or bad anyway ? */
  287. if (state->Version == 0 || state->Version > SR_PROTO_VERSION) {
  288. goto invalid;
  289. }
  290. /* If the valid until time is before now, we shouldn't use that state. */
  291. now = time(NULL);
  292. if (state->ValidUntil < now) {
  293. log_info(LD_DIR, "SR: Disk state has expired. Ignoring it.");
  294. goto invalid;
  295. }
  296. /* Make sure we don't have a valid after time that is earlier than a valid
  297. * until time which would make things not work well. */
  298. if (state->ValidAfter >= state->ValidUntil) {
  299. log_info(LD_DIR, "SR: Disk state valid after/until times are invalid.");
  300. goto invalid;
  301. }
  302. return 0;
  303. invalid:
  304. return -1;
  305. }
  306. /* Validate the disk state (NOP for now). */
  307. static int
  308. disk_state_validate_cb(void *old_state, void *state, void *default_state,
  309. int from_setconf, char **msg)
  310. {
  311. /* We don't use these; only options do. */
  312. (void) from_setconf;
  313. (void) default_state;
  314. (void) old_state;
  315. /* This is called by config_dump which is just before we are about to
  316. * write it to disk. At that point, our global memory state has been
  317. * copied to the disk state so it's fair to assume it's trustable. */
  318. (void) state;
  319. (void) msg;
  320. return 0;
  321. }
  322. /* Parse the Commit line(s) in the disk state and translate them to the
  323. * the memory state. Return 0 on success else -1 on error. */
  324. static int
  325. disk_state_parse_commits(sr_state_t *state,
  326. const sr_disk_state_t *disk_state)
  327. {
  328. config_line_t *line;
  329. smartlist_t *args = NULL;
  330. tor_assert(state);
  331. tor_assert(disk_state);
  332. for (line = disk_state->Commit; line; line = line->next) {
  333. sr_commit_t *commit = NULL;
  334. /* Extra safety. */
  335. if (strcasecmp(line->key, dstate_commit_key) ||
  336. line->value == NULL) {
  337. /* Ignore any lines that are not commits. */
  338. tor_fragile_assert();
  339. continue;
  340. }
  341. args = smartlist_new();
  342. smartlist_split_string(args, line->value, " ",
  343. SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0);
  344. if (smartlist_len(args) < 3) {
  345. log_warn(LD_BUG, "SR: Too few arguments in Commit Line: %s",
  346. escaped(line->value));
  347. goto error;
  348. }
  349. commit = sr_parse_commit(args);
  350. if (commit == NULL) {
  351. /* Ignore badly formed commit. It could also be a authority
  352. * fingerprint that we don't know about so it shouldn't be used. */
  353. continue;
  354. }
  355. /* We consider parseable commit from our disk state to be valid because
  356. * they need to be in the first place to get in there. */
  357. commit->valid = 1;
  358. /* Add commit to our state pointer. */
  359. commit_add_to_state(commit, state);
  360. SMARTLIST_FOREACH(args, char *, cp, tor_free(cp));
  361. smartlist_free(args);
  362. }
  363. return 0;
  364. error:
  365. SMARTLIST_FOREACH(args, char *, cp, tor_free(cp));
  366. smartlist_free(args);
  367. return -1;
  368. }
  369. /* Parse a share random value line from the disk state and save it to dst
  370. * which is an allocated srv object. Return 0 on success else -1. */
  371. static int
  372. disk_state_parse_srv(const char *value, sr_srv_t *dst)
  373. {
  374. int ret = -1;
  375. smartlist_t *args;
  376. sr_srv_t *srv;
  377. tor_assert(value);
  378. tor_assert(dst);
  379. args = smartlist_new();
  380. smartlist_split_string(args, value, " ",
  381. SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0);
  382. if (smartlist_len(args) < 2) {
  383. log_warn(LD_BUG, "SR: Too few arguments in shared random value. "
  384. "Line: %s", escaped(value));
  385. goto error;
  386. }
  387. srv = sr_parse_srv(args);
  388. if (srv == NULL) {
  389. goto error;
  390. }
  391. dst->num_reveals = srv->num_reveals;
  392. memcpy(dst->value, srv->value, sizeof(dst->value));
  393. tor_free(srv);
  394. ret = 0;
  395. error:
  396. SMARTLIST_FOREACH(args, char *, s, tor_free(s));
  397. smartlist_free(args);
  398. return ret;
  399. }
  400. /* Parse both SharedRandCurrentValue and SharedRandPreviousValue line from
  401. * the state. Return 0 on success else -1. */
  402. static int
  403. disk_state_parse_sr_values(sr_state_t *state,
  404. const sr_disk_state_t *disk_state)
  405. {
  406. /* Only one value per type (current or previous) is allowed so we keep
  407. * track of it with these flag. */
  408. unsigned int seen_previous = 0, seen_current = 0;
  409. config_line_t *line;
  410. sr_srv_t *srv = NULL;
  411. tor_assert(state);
  412. tor_assert(disk_state);
  413. for (line = disk_state->SharedRandValues; line; line = line->next) {
  414. if (line->value == NULL) {
  415. continue;
  416. }
  417. srv = tor_malloc_zero(sizeof(*srv));
  418. if (disk_state_parse_srv(line->value, srv) < 0) {
  419. log_warn(LD_BUG, "SR: Broken current SRV line in state %s",
  420. escaped(line->value));
  421. goto bad;
  422. }
  423. if (!strcasecmp(line->key, dstate_prev_srv_key)) {
  424. if (seen_previous) {
  425. log_warn(LD_DIR, "SR: Second previous SRV value seen. Bad state");
  426. goto bad;
  427. }
  428. state->previous_srv = srv;
  429. seen_previous = 1;
  430. } else if (!strcasecmp(line->key, dstate_cur_srv_key)) {
  431. if (seen_current) {
  432. log_warn(LD_DIR, "SR: Second current SRV value seen. Bad state");
  433. goto bad;
  434. }
  435. state->current_srv = srv;
  436. seen_current = 1;
  437. } else {
  438. /* Unknown key. Ignoring. */
  439. tor_free(srv);
  440. }
  441. }
  442. return 0;
  443. bad:
  444. tor_free(srv);
  445. return -1;
  446. }
  447. /* Parse the given disk state and set a newly allocated state. On success,
  448. * return that state else NULL. */
  449. static sr_state_t *
  450. disk_state_parse(const sr_disk_state_t *new_disk_state)
  451. {
  452. sr_state_t *new_state = state_new(default_fname, time(NULL));
  453. tor_assert(new_disk_state);
  454. new_state->version = new_disk_state->Version;
  455. new_state->valid_until = new_disk_state->ValidUntil;
  456. new_state->valid_after = new_disk_state->ValidAfter;
  457. /* Set our current phase according to the valid-after time in our disk
  458. * state. The disk state we are parsing contains everything for the phase
  459. * starting at valid_after so make sure our phase reflects that. */
  460. new_state->phase = get_sr_protocol_phase(new_state->valid_after);
  461. /* Parse the shared random values. */
  462. if (disk_state_parse_sr_values(new_state, new_disk_state) < 0) {
  463. goto error;
  464. }
  465. /* Parse the commits. */
  466. if (disk_state_parse_commits(new_state, new_disk_state) < 0) {
  467. goto error;
  468. }
  469. /* Great! This new state contains everything we had on disk. */
  470. return new_state;
  471. error:
  472. state_free(new_state);
  473. return NULL;
  474. }
  475. /* From a valid commit object and an allocated config line, set the line's
  476. * value to the state string representation of a commit. */
  477. static void
  478. disk_state_put_commit_line(const sr_commit_t *commit, config_line_t *line)
  479. {
  480. char *reveal_str = NULL;
  481. tor_assert(commit);
  482. tor_assert(line);
  483. if (!tor_mem_is_zero(commit->encoded_reveal,
  484. sizeof(commit->encoded_reveal))) {
  485. /* Add extra whitespace so we can format the line correctly. */
  486. tor_asprintf(&reveal_str, " %s", commit->encoded_reveal);
  487. }
  488. tor_asprintf(&line->value, "%u %s %s %s%s",
  489. SR_PROTO_VERSION,
  490. crypto_digest_algorithm_get_name(commit->alg),
  491. sr_commit_get_rsa_fpr(commit),
  492. commit->encoded_commit,
  493. reveal_str != NULL ? reveal_str : "");
  494. if (reveal_str != NULL) {
  495. memwipe(reveal_str, 0, strlen(reveal_str));
  496. tor_free(reveal_str);
  497. }
  498. }
  499. /* From a valid srv object and an allocated config line, set the line's
  500. * value to the state string representation of a shared random value. */
  501. static void
  502. disk_state_put_srv_line(const sr_srv_t *srv, config_line_t *line)
  503. {
  504. char encoded[SR_SRV_VALUE_BASE64_LEN + 1];
  505. tor_assert(line);
  506. /* No SRV value thus don't add the line. This is possible since we might
  507. * not have a current or previous SRV value in our state. */
  508. if (srv == NULL) {
  509. return;
  510. }
  511. sr_srv_encode(encoded, sizeof(encoded), srv);
  512. tor_asprintf(&line->value, "%" PRIu64 " %s", srv->num_reveals, encoded);
  513. }
  514. /* Reset disk state that is free allocated memory and zeroed the object. */
  515. static void
  516. disk_state_reset(void)
  517. {
  518. /* Free allocated memory */
  519. config_free_lines(sr_disk_state->Commit);
  520. config_free_lines(sr_disk_state->SharedRandValues);
  521. config_free_lines(sr_disk_state->ExtraLines);
  522. tor_free(sr_disk_state->TorVersion);
  523. /* Clean up the struct */
  524. memset(sr_disk_state, 0, sizeof(*sr_disk_state));
  525. /* Reset it with useful data */
  526. sr_disk_state->magic_ = SR_DISK_STATE_MAGIC;
  527. sr_disk_state->TorVersion = tor_strdup(get_version());
  528. }
  529. /* Update our disk state based on our global SR state. */
  530. static void
  531. disk_state_update(void)
  532. {
  533. config_line_t **next, *line;
  534. tor_assert(sr_disk_state);
  535. tor_assert(sr_state);
  536. /* Reset current disk state. */
  537. disk_state_reset();
  538. /* First, update elements that we don't need to do a construction. */
  539. sr_disk_state->Version = sr_state->version;
  540. sr_disk_state->ValidUntil = sr_state->valid_until;
  541. sr_disk_state->ValidAfter = sr_state->valid_after;
  542. /* Shared random values. */
  543. next = &sr_disk_state->SharedRandValues;
  544. if (sr_state->previous_srv != NULL) {
  545. *next = line = tor_malloc_zero(sizeof(config_line_t));
  546. line->key = tor_strdup(dstate_prev_srv_key);
  547. disk_state_put_srv_line(sr_state->previous_srv, line);
  548. /* Go to the next shared random value. */
  549. next = &(line->next);
  550. }
  551. if (sr_state->current_srv != NULL) {
  552. *next = line = tor_malloc_zero(sizeof(*line));
  553. line->key = tor_strdup(dstate_cur_srv_key);
  554. disk_state_put_srv_line(sr_state->current_srv, line);
  555. }
  556. /* Parse the commits and construct config line(s). */
  557. next = &sr_disk_state->Commit;
  558. DIGESTMAP_FOREACH(sr_state->commits, key, sr_commit_t *, commit) {
  559. *next = line = tor_malloc_zero(sizeof(*line));
  560. line->key = tor_strdup(dstate_commit_key);
  561. disk_state_put_commit_line(commit, line);
  562. next = &(line->next);
  563. } DIGESTMAP_FOREACH_END;
  564. }
  565. /* Load state from disk and put it into our disk state. If the state passes
  566. * validation, our global state will be updated with it. Return 0 on
  567. * success. On error, -EINVAL is returned if the state on disk did contained
  568. * something malformed or is unreadable. -ENOENT is returned indicating that
  569. * the state file is either empty of non existing. */
  570. static int
  571. disk_state_load_from_disk(void)
  572. {
  573. int ret;
  574. char *fname;
  575. fname = get_datadir_fname(default_fname);
  576. ret = disk_state_load_from_disk_impl(fname);
  577. tor_free(fname);
  578. return ret;
  579. }
  580. /* Helper for disk_state_load_from_disk(). */
  581. STATIC int
  582. disk_state_load_from_disk_impl(const char *fname)
  583. {
  584. int ret;
  585. char *content = NULL;
  586. sr_state_t *parsed_state = NULL;
  587. sr_disk_state_t *disk_state = NULL;
  588. /* Read content of file so we can parse it. */
  589. if ((content = read_file_to_str(fname, 0, NULL)) == NULL) {
  590. log_warn(LD_FS, "SR: Unable to read SR state file %s",
  591. escaped(fname));
  592. ret = -errno;
  593. goto error;
  594. }
  595. {
  596. config_line_t *lines = NULL;
  597. char *errmsg = NULL;
  598. /* Every error in this code path will return EINVAL. */
  599. ret = -EINVAL;
  600. if (config_get_lines(content, &lines, 0) < 0) {
  601. config_free_lines(lines);
  602. goto error;
  603. }
  604. disk_state = disk_state_new(time(NULL));
  605. config_assign(&state_format, disk_state, lines, 0, 0, &errmsg);
  606. config_free_lines(lines);
  607. if (errmsg) {
  608. log_warn(LD_DIR, "SR: Reading state error: %s", errmsg);
  609. tor_free(errmsg);
  610. goto error;
  611. }
  612. }
  613. /* So far so good, we've loaded our state file into our disk state. Let's
  614. * validate it and then parse it. */
  615. if (disk_state_validate(disk_state) < 0) {
  616. ret = -EINVAL;
  617. goto error;
  618. }
  619. parsed_state = disk_state_parse(disk_state);
  620. if (parsed_state == NULL) {
  621. ret = -EINVAL;
  622. goto error;
  623. }
  624. state_set(parsed_state);
  625. disk_state_set(disk_state);
  626. tor_free(content);
  627. log_info(LD_DIR, "SR: State loaded successfully from file %s", fname);
  628. return 0;
  629. error:
  630. disk_state_free(disk_state);
  631. tor_free(content);
  632. return ret;
  633. }
  634. /* Save the disk state to disk but before that update it from the current
  635. * state so we always have the latest. Return 0 on success else -1. */
  636. static int
  637. disk_state_save_to_disk(void)
  638. {
  639. int ret;
  640. char *state, *content = NULL, *fname = NULL;
  641. char tbuf[ISO_TIME_LEN + 1];
  642. time_t now = time(NULL);
  643. /* If we didn't have the opportunity to setup an internal disk state,
  644. * don't bother saving something to disk. */
  645. if (sr_disk_state == NULL) {
  646. ret = 0;
  647. goto done;
  648. }
  649. /* Make sure that our disk state is up to date with our memory state
  650. * before saving it to disk. */
  651. disk_state_update();
  652. state = config_dump(&state_format, NULL, sr_disk_state, 0, 0);
  653. format_local_iso_time(tbuf, now);
  654. tor_asprintf(&content,
  655. "# Tor shared random state file last generated on %s "
  656. "local time\n"
  657. "# Other times below are in UTC\n"
  658. "# Please *do not* edit this file.\n\n%s",
  659. tbuf, state);
  660. tor_free(state);
  661. fname = get_datadir_fname(default_fname);
  662. if (write_str_to_file(fname, content, 0) < 0) {
  663. log_warn(LD_FS, "SR: Unable to write SR state to file %s", fname);
  664. ret = -1;
  665. goto done;
  666. }
  667. ret = 0;
  668. log_debug(LD_DIR, "SR: Saved state to file %s", fname);
  669. done:
  670. tor_free(fname);
  671. tor_free(content);
  672. return ret;
  673. }
  674. /* Reset our state to prepare for a new protocol run. Once this returns, all
  675. * commits in the state will be removed and freed. */
  676. STATIC void
  677. reset_state_for_new_protocol_run(time_t valid_after)
  678. {
  679. tor_assert(sr_state);
  680. /* Keep counters in track */
  681. sr_state->n_reveal_rounds = 0;
  682. sr_state->n_commit_rounds = 0;
  683. sr_state->n_protocol_runs++;
  684. /* Reset valid-until */
  685. sr_state->valid_until = get_state_valid_until_time(valid_after);
  686. sr_state->valid_after = valid_after;
  687. /* We are in a new protocol run so cleanup commits. */
  688. sr_state_delete_commits();
  689. }
  690. /* This is the first round of the new protocol run starting at
  691. * <b>valid_after</b>. Do the necessary housekeeping. */
  692. STATIC void
  693. new_protocol_run(time_t valid_after)
  694. {
  695. sr_commit_t *our_commitment = NULL;
  696. /* Only compute the srv at the end of the reveal phase. */
  697. if (sr_state->phase == SR_PHASE_REVEAL) {
  698. /* We are about to compute a new shared random value that will be set in
  699. * our state as the current value so rotate values. */
  700. state_rotate_srv();
  701. /* Compute the shared randomness value of the day. */
  702. sr_compute_srv();
  703. }
  704. /* Prepare for the new protocol run by reseting the state */
  705. reset_state_for_new_protocol_run(valid_after);
  706. /* Do some logging */
  707. log_info(LD_DIR, "SR: Protocol run #%" PRIu64 " starting!",
  708. sr_state->n_protocol_runs);
  709. /* Generate fresh commitments for this protocol run */
  710. our_commitment = sr_generate_our_commit(valid_after,
  711. get_my_v3_authority_cert());
  712. if (our_commitment) {
  713. /* Add our commitment to our state. In case we are unable to create one
  714. * (highly unlikely), we won't vote for this protocol run since our
  715. * commitment won't be in our state. */
  716. sr_state_add_commit(our_commitment);
  717. }
  718. }
  719. /* Return 1 iff the <b>next_phase</b> is a phase transition from the current
  720. * phase that is it's different. */
  721. STATIC int
  722. is_phase_transition(sr_phase_t next_phase)
  723. {
  724. return sr_state->phase != next_phase;
  725. }
  726. /* Helper function: return a commit using the RSA fingerprint of the
  727. * authority or NULL if no such commit is known. */
  728. static sr_commit_t *
  729. state_query_get_commit(const char *rsa_fpr)
  730. {
  731. tor_assert(rsa_fpr);
  732. return digestmap_get(sr_state->commits, rsa_fpr);
  733. }
  734. /* Helper function: This handles the GET state action using an
  735. * <b>obj_type</b> and <b>data</b> needed for the action. */
  736. static void *
  737. state_query_get_(sr_state_object_t obj_type, const void *data)
  738. {
  739. void *obj = NULL;
  740. switch (obj_type) {
  741. case SR_STATE_OBJ_COMMIT:
  742. {
  743. obj = state_query_get_commit(data);
  744. break;
  745. }
  746. case SR_STATE_OBJ_COMMITS:
  747. obj = sr_state->commits;
  748. break;
  749. case SR_STATE_OBJ_CURSRV:
  750. obj = sr_state->current_srv;
  751. break;
  752. case SR_STATE_OBJ_PREVSRV:
  753. obj = sr_state->previous_srv;
  754. break;
  755. case SR_STATE_OBJ_PHASE:
  756. obj = &sr_state->phase;
  757. break;
  758. case SR_STATE_OBJ_VALID_AFTER:
  759. default:
  760. tor_assert(0);
  761. }
  762. return obj;
  763. }
  764. /* Helper function: This handles the PUT state action using an
  765. * <b>obj_type</b> and <b>data</b> needed for the action. */
  766. static void
  767. state_query_put_(sr_state_object_t obj_type, void *data)
  768. {
  769. switch (obj_type) {
  770. case SR_STATE_OBJ_COMMIT:
  771. {
  772. sr_commit_t *commit = data;
  773. tor_assert(commit);
  774. commit_add_to_state(commit, sr_state);
  775. break;
  776. }
  777. case SR_STATE_OBJ_CURSRV:
  778. sr_state->current_srv = (sr_srv_t *) data;
  779. break;
  780. case SR_STATE_OBJ_PREVSRV:
  781. sr_state->previous_srv = (sr_srv_t *) data;
  782. break;
  783. case SR_STATE_OBJ_VALID_AFTER:
  784. sr_state->valid_after = *((time_t *) data);
  785. break;
  786. /* It's not allowed to change the phase nor the full commitments map from
  787. * the state. The phase is decided during a strict process post voting and
  788. * the commits should be put individually. */
  789. case SR_STATE_OBJ_PHASE:
  790. case SR_STATE_OBJ_COMMITS:
  791. default:
  792. tor_assert(0);
  793. }
  794. }
  795. /* Helper function: This handles the DEL_ALL state action using an
  796. * <b>obj_type</b> and <b>data</b> needed for the action. */
  797. static void
  798. state_query_del_all_(sr_state_object_t obj_type)
  799. {
  800. switch (obj_type) {
  801. case SR_STATE_OBJ_COMMIT:
  802. {
  803. /* We are in a new protocol run so cleanup commitments. */
  804. DIGESTMAP_FOREACH_MODIFY(sr_state->commits, key, sr_commit_t *, c) {
  805. sr_commit_free(c);
  806. MAP_DEL_CURRENT(key);
  807. } DIGESTMAP_FOREACH_END;
  808. break;
  809. }
  810. /* The following object are _NOT_ suppose to be removed. */
  811. case SR_STATE_OBJ_CURSRV:
  812. case SR_STATE_OBJ_PREVSRV:
  813. case SR_STATE_OBJ_PHASE:
  814. case SR_STATE_OBJ_COMMITS:
  815. case SR_STATE_OBJ_VALID_AFTER:
  816. default:
  817. tor_assert(0);
  818. }
  819. }
  820. /* Helper function: This handles the DEL state action using an
  821. * <b>obj_type</b> and <b>data</b> needed for the action. */
  822. static void
  823. state_query_del_(sr_state_object_t obj_type, void *data)
  824. {
  825. (void) data;
  826. switch (obj_type) {
  827. case SR_STATE_OBJ_PREVSRV:
  828. tor_free(sr_state->previous_srv);
  829. break;
  830. case SR_STATE_OBJ_CURSRV:
  831. tor_free(sr_state->current_srv);
  832. break;
  833. case SR_STATE_OBJ_COMMIT:
  834. case SR_STATE_OBJ_COMMITS:
  835. case SR_STATE_OBJ_PHASE:
  836. case SR_STATE_OBJ_VALID_AFTER:
  837. default:
  838. tor_assert(0);
  839. }
  840. }
  841. /* Query state using an <b>action</b> for an object type <b>obj_type</b>.
  842. * The <b>data</b> pointer needs to point to an object that the action needs
  843. * to use and if anything is required to be returned, it is stored in
  844. * <b>out</b>.
  845. *
  846. * This mechanism exists so we have one single point where we synchronized
  847. * our memory state with our disk state for every actions that changes it.
  848. * We then trigger a write on disk immediately.
  849. *
  850. * This should be the only entry point to our memory state. It's used by all
  851. * our state accessors and should be in the future. */
  852. static void
  853. state_query(sr_state_action_t action, sr_state_object_t obj_type,
  854. void *data, void **out)
  855. {
  856. switch (action) {
  857. case SR_STATE_ACTION_GET:
  858. *out = state_query_get_(obj_type, data);
  859. break;
  860. case SR_STATE_ACTION_PUT:
  861. state_query_put_(obj_type, data);
  862. break;
  863. case SR_STATE_ACTION_DEL:
  864. state_query_del_(obj_type, data);
  865. break;
  866. case SR_STATE_ACTION_DEL_ALL:
  867. state_query_del_all_(obj_type);
  868. break;
  869. case SR_STATE_ACTION_SAVE:
  870. /* Only trigger a disk state save. */
  871. break;
  872. default:
  873. tor_assert(0);
  874. }
  875. /* If the action actually changes the state, immediately save it to disk.
  876. * The following will sync the state -> disk state and then save it. */
  877. if (action != SR_STATE_ACTION_GET) {
  878. disk_state_save_to_disk();
  879. }
  880. }
  881. /* Delete the current SRV value from the state freeing it and the value is set
  882. * to NULL meaning empty. */
  883. static void
  884. state_del_current_srv(void)
  885. {
  886. state_query(SR_STATE_ACTION_DEL, SR_STATE_OBJ_CURSRV, NULL, NULL);
  887. }
  888. /* Delete the previous SRV value from the state freeing it and the value is
  889. * set to NULL meaning empty. */
  890. static void
  891. state_del_previous_srv(void)
  892. {
  893. state_query(SR_STATE_ACTION_DEL, SR_STATE_OBJ_PREVSRV, NULL, NULL);
  894. }
  895. /* Rotate SRV value by freeing the previous value, assigning the current
  896. * value to the previous one and nullifying the current one. */
  897. STATIC void
  898. state_rotate_srv(void)
  899. {
  900. /* First delete previous SRV from the state. Object will be freed. */
  901. state_del_previous_srv();
  902. /* Set previous SRV with the current one. */
  903. sr_state_set_previous_srv(sr_state_get_current_srv());
  904. /* Nullify the current srv. */
  905. sr_state_set_current_srv(NULL);
  906. }
  907. /* Set valid after time in the our state. */
  908. void
  909. sr_state_set_valid_after(time_t valid_after)
  910. {
  911. state_query(SR_STATE_ACTION_PUT, SR_STATE_OBJ_VALID_AFTER,
  912. (void *) &valid_after, NULL);
  913. }
  914. /* Return the phase we are currently in according to our state. */
  915. sr_phase_t
  916. sr_state_get_phase(void)
  917. {
  918. void *ptr;
  919. state_query(SR_STATE_ACTION_GET, SR_STATE_OBJ_PHASE, NULL, &ptr);
  920. return *(sr_phase_t *) ptr;
  921. }
  922. /* Return the previous SRV value from our state. Value CAN be NULL. */
  923. const sr_srv_t *
  924. sr_state_get_previous_srv(void)
  925. {
  926. const sr_srv_t *srv;
  927. state_query(SR_STATE_ACTION_GET, SR_STATE_OBJ_PREVSRV, NULL,
  928. (void *) &srv);
  929. return srv;
  930. }
  931. /* Set the current SRV value from our state. Value CAN be NULL. The srv
  932. * object ownership is transfered to the state object. */
  933. void
  934. sr_state_set_previous_srv(const sr_srv_t *srv)
  935. {
  936. state_query(SR_STATE_ACTION_PUT, SR_STATE_OBJ_PREVSRV, (void *) srv,
  937. NULL);
  938. }
  939. /* Return the current SRV value from our state. Value CAN be NULL. */
  940. const sr_srv_t *
  941. sr_state_get_current_srv(void)
  942. {
  943. const sr_srv_t *srv;
  944. state_query(SR_STATE_ACTION_GET, SR_STATE_OBJ_CURSRV, NULL,
  945. (void *) &srv);
  946. return srv;
  947. }
  948. /* Set the current SRV value from our state. Value CAN be NULL. The srv
  949. * object ownership is transfered to the state object. */
  950. void
  951. sr_state_set_current_srv(const sr_srv_t *srv)
  952. {
  953. state_query(SR_STATE_ACTION_PUT, SR_STATE_OBJ_CURSRV, (void *) srv,
  954. NULL);
  955. }
  956. /* Clean all the SRVs in our state. */
  957. void
  958. sr_state_clean_srvs(void)
  959. {
  960. /* Remove SRVs from state. They will be set to NULL as "empty". */
  961. state_del_previous_srv();
  962. state_del_current_srv();
  963. }
  964. /* Return a pointer to the commits map from our state. CANNOT be NULL. */
  965. digestmap_t *
  966. sr_state_get_commits(void)
  967. {
  968. digestmap_t *commits;
  969. state_query(SR_STATE_ACTION_GET, SR_STATE_OBJ_COMMITS,
  970. NULL, (void *) &commits);
  971. tor_assert(commits);
  972. return commits;
  973. }
  974. /* Update the current SR state as needed for the upcoming voting round at
  975. * <b>valid_after</b>. */
  976. void
  977. sr_state_update(time_t valid_after)
  978. {
  979. sr_phase_t next_phase;
  980. tor_assert(sr_state);
  981. /* Don't call this function twice in the same voting period. */
  982. if (valid_after <= sr_state->valid_after) {
  983. log_info(LD_DIR, "SR: Asked to update state twice. Ignoring.");
  984. return;
  985. }
  986. /* Get phase of upcoming round. */
  987. next_phase = get_sr_protocol_phase(valid_after);
  988. /* If we are transitioning to a new protocol phase, prepare the stage. */
  989. if (is_phase_transition(next_phase)) {
  990. if (next_phase == SR_PHASE_COMMIT) {
  991. /* Going into commit phase means we are starting a new protocol run. */
  992. new_protocol_run(valid_after);
  993. }
  994. /* Set the new phase for this round */
  995. sr_state->phase = next_phase;
  996. } else if (sr_state->phase == SR_PHASE_COMMIT &&
  997. digestmap_size(sr_state->commits) == 0) {
  998. /* We are _NOT_ in a transition phase so if we are in the commit phase
  999. * and have no commit, generate one. Chances are that we are booting up
  1000. * so let's have a commit in our state for the next voting period. */
  1001. sr_commit_t *our_commit =
  1002. sr_generate_our_commit(valid_after, get_my_v3_authority_cert());
  1003. if (our_commit) {
  1004. /* Add our commitment to our state. In case we are unable to create one
  1005. * (highly unlikely), we won't vote for this protocol run since our
  1006. * commitment won't be in our state. */
  1007. sr_state_add_commit(our_commit);
  1008. }
  1009. }
  1010. sr_state_set_valid_after(valid_after);
  1011. /* Count the current round */
  1012. if (sr_state->phase == SR_PHASE_COMMIT) {
  1013. /* invariant check: we've not entered reveal phase yet */
  1014. tor_assert(sr_state->n_reveal_rounds == 0);
  1015. sr_state->n_commit_rounds++;
  1016. } else {
  1017. sr_state->n_reveal_rounds++;
  1018. }
  1019. { /* Debugging. */
  1020. char tbuf[ISO_TIME_LEN + 1];
  1021. format_iso_time(tbuf, valid_after);
  1022. log_info(LD_DIR, "SR: State prepared for upcoming voting period (%s). "
  1023. "Upcoming phase is %s (counters: %d commit & %d reveal rounds).",
  1024. tbuf, get_phase_str(sr_state->phase),
  1025. sr_state->n_commit_rounds, sr_state->n_reveal_rounds);
  1026. }
  1027. }
  1028. /* Return commit object from the given authority digest <b>rsa_identity</b>.
  1029. * Return NULL if not found. */
  1030. sr_commit_t *
  1031. sr_state_get_commit(const char *rsa_identity)
  1032. {
  1033. sr_commit_t *commit;
  1034. tor_assert(rsa_identity);
  1035. state_query(SR_STATE_ACTION_GET, SR_STATE_OBJ_COMMIT,
  1036. (void *) rsa_identity, (void *) &commit);
  1037. return commit;
  1038. }
  1039. /* Add <b>commit</b> to the permanent state. The commit object ownership is
  1040. * transfered to the state so the caller MUST not free it. */
  1041. void
  1042. sr_state_add_commit(sr_commit_t *commit)
  1043. {
  1044. tor_assert(commit);
  1045. /* Put the commit to the global state. */
  1046. state_query(SR_STATE_ACTION_PUT, SR_STATE_OBJ_COMMIT,
  1047. (void *) commit, NULL);
  1048. log_debug(LD_DIR, "SR: Commit from %s has been added to our state.",
  1049. sr_commit_get_rsa_fpr(commit));
  1050. }
  1051. /* Remove all commits from our state. */
  1052. void
  1053. sr_state_delete_commits(void)
  1054. {
  1055. state_query(SR_STATE_ACTION_DEL_ALL, SR_STATE_OBJ_COMMIT, NULL, NULL);
  1056. }
  1057. /* Copy the reveal information from <b>commit</b> into <b>saved_commit</b>.
  1058. * This <b>saved_commit</b> MUST come from our current SR state. Once modified,
  1059. * the disk state is updated. */
  1060. void
  1061. sr_state_copy_reveal_info(sr_commit_t *saved_commit, const sr_commit_t *commit)
  1062. {
  1063. tor_assert(saved_commit);
  1064. tor_assert(commit);
  1065. saved_commit->reveal_ts = commit->reveal_ts;
  1066. memcpy(saved_commit->random_number, commit->random_number,
  1067. sizeof(saved_commit->random_number));
  1068. strlcpy(saved_commit->encoded_reveal, commit->encoded_reveal,
  1069. sizeof(saved_commit->encoded_reveal));
  1070. state_query(SR_STATE_ACTION_SAVE, 0, NULL, NULL);
  1071. log_debug(LD_DIR, "SR: Reveal value learned %s (for commit %s) from %s",
  1072. saved_commit->encoded_reveal, saved_commit->encoded_commit,
  1073. sr_commit_get_rsa_fpr(saved_commit));
  1074. }
  1075. /* Set the fresh SRV flag from our state. This doesn't need to trigger a
  1076. * disk state synchronization so we directly change the state. */
  1077. void
  1078. sr_state_set_fresh_srv(void)
  1079. {
  1080. sr_state->is_srv_fresh = 1;
  1081. }
  1082. /* Unset the fresh SRV flag from our state. This doesn't need to trigger a
  1083. * disk state synchronization so we directly change the state. */
  1084. void
  1085. sr_state_unset_fresh_srv(void)
  1086. {
  1087. sr_state->is_srv_fresh = 0;
  1088. }
  1089. /* Return the value of the fresh SRV flag. */
  1090. unsigned int
  1091. sr_state_srv_is_fresh(void)
  1092. {
  1093. return sr_state->is_srv_fresh;
  1094. }
  1095. /* Cleanup and free our disk and memory state. */
  1096. void
  1097. sr_state_free(void)
  1098. {
  1099. state_free(sr_state);
  1100. disk_state_free(sr_disk_state);
  1101. /* Nullify our global state. */
  1102. sr_state = NULL;
  1103. sr_disk_state = NULL;
  1104. }
  1105. /* Save our current state in memory to disk. */
  1106. void
  1107. sr_state_save(void)
  1108. {
  1109. /* Query a SAVE action on our current state so it's synced and saved. */
  1110. state_query(SR_STATE_ACTION_SAVE, 0, NULL, NULL);
  1111. }
  1112. /* Return 1 iff the state has been initialized that is it exists in memory.
  1113. * Return 0 otherwise. */
  1114. int
  1115. sr_state_is_initialized(void)
  1116. {
  1117. return sr_state == NULL ? 0 : 1;
  1118. }
  1119. /* Initialize the disk and memory state.
  1120. *
  1121. * If save_to_disk is set to 1, the state is immediately saved to disk after
  1122. * creation else it's not thus only kept in memory.
  1123. * If read_from_disk is set to 1, we try to load the state from the disk and
  1124. * if not found, a new state is created.
  1125. *
  1126. * Return 0 on success else a negative value on error. */
  1127. int
  1128. sr_state_init(int save_to_disk, int read_from_disk)
  1129. {
  1130. int ret = -ENOENT;
  1131. time_t now = time(NULL);
  1132. /* We shouldn't have those assigned. */
  1133. tor_assert(sr_disk_state == NULL);
  1134. tor_assert(sr_state == NULL);
  1135. /* First, try to load the state from disk. */
  1136. if (read_from_disk) {
  1137. ret = disk_state_load_from_disk();
  1138. }
  1139. if (ret < 0) {
  1140. switch (-ret) {
  1141. case EINVAL:
  1142. /* We have a state on disk but it contains something we couldn't parse
  1143. * or an invalid entry in the state file. Let's remove it since it's
  1144. * obviously unusable and replace it by an new fresh state below. */
  1145. case ENOENT:
  1146. {
  1147. /* No state on disk so allocate our states for the first time. */
  1148. sr_state_t *new_state = state_new(default_fname, now);
  1149. sr_disk_state_t *new_disk_state = disk_state_new(now);
  1150. state_set(new_state);
  1151. /* It's important to set our disk state pointer since the save call
  1152. * below uses it to synchronized it with our memory state. */
  1153. disk_state_set(new_disk_state);
  1154. /* No entry, let's save our new state to disk. */
  1155. if (save_to_disk && disk_state_save_to_disk() < 0) {
  1156. goto error;
  1157. }
  1158. break;
  1159. }
  1160. default:
  1161. /* Big problem. Not possible. */
  1162. tor_assert(0);
  1163. }
  1164. }
  1165. /* We have a state in memory, let's make sure it's updated for the current
  1166. * and next voting round. */
  1167. {
  1168. time_t valid_after = get_next_valid_after_time(now);
  1169. sr_state_update(valid_after);
  1170. }
  1171. return 0;
  1172. error:
  1173. return -1;
  1174. }
  1175. #ifdef TOR_UNIT_TESTS
  1176. /* Set the current phase of the protocol. Used only by unit tests. */
  1177. void
  1178. set_sr_phase(sr_phase_t phase)
  1179. {
  1180. tor_assert(sr_state);
  1181. sr_state->phase = phase;
  1182. }
  1183. /* Get the SR state. Used only by unit tests */
  1184. sr_state_t *
  1185. get_sr_state(void)
  1186. {
  1187. return sr_state;
  1188. }
  1189. #endif /* TOR_UNIT_TESTS */