自学教程：C++ tor_asprintf函数代码示例

/** Write the persistent state to disk. Return 0 for success, <0 on failure. */intor_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. */  entry_guards_update_state(global_state);  rep_hist_update_state(global_state);  circuit_build_times_update_state(&circ_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(&state_format, 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 GMT/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;}

tor_bug_occurred_(const char *fname, unsigned int line,                  const char *func, const char *expr,                  int once, const char *fmt, ...){  char *buf = NULL;  const char *once_str = once ?    " (Future instances of this warning will be silenced.)": "";  if (! expr) {    if (capturing_bugs()) {      add_captured_bug("This line should not have been reached.");      return;    }    log_warn(LD_BUG, "%s:%u: %s: This line should not have been reached.%s",             fname, line, func, once_str);    tor_asprintf(&buf,                 "Line unexpectedly reached at %s at %s:%u",                 func, fname, line);  } else {    if (capturing_bugs()) {      add_captured_bug(expr);      return;    }    va_list ap;    char *extra = NULL;#ifdef __clang__#pragma clang diagnostic push#pragma clang diagnostic ignored "-Wformat-nonliteral"#endif    if (fmt) {      va_start(ap,fmt);      tor_vasprintf(&extra, fmt, ap);      va_end(ap);    }#ifdef __clang__#pragma clang diagnostic pop#endif    log_warn(LD_BUG, "%s:%u: %s: Non-fatal assertion %s failed.%s",             fname, line, func, expr, once_str);    tor_asprintf(&buf, "Non-fatal assertion %s failed in %s at %s:%u%s%s",                 expr, func, fname, line, fmt ? " : " : "",                 extra ? extra : "");    tor_free(extra);  }  log_backtrace(LOG_WARN, LD_BUG, buf);  tor_free(buf);#ifdef TOR_UNIT_TESTS  if (failed_assertion_cb) {    failed_assertion_cb();  }#endif}

/** Set up code to handle generating error messages on crashes. */intconfigure_backtrace_handler(const char *tor_version){  tor_free(bt_version);  if (tor_version)    tor_asprintf(&bt_version, "Tor %s", tor_version);  else    tor_asprintf(&bt_version, "Tor");  return install_bt_handler();}

static voidtest_storagedir_deletion(void *arg){  (void)arg;  char *dirname = tor_strdup(get_fname_rnd("store_dir"));  storage_dir_t *d = NULL;  char *fn1 = NULL, *fn2 = NULL;  char *bytes = NULL;  int r;  const char str1[] = "There are nine and sixty ways to disguise communiques";  const char str2[] = "And rather more than one of them is right";  // Make sure the directory is there. */  d = storage_dir_new(dirname, 10);  storage_dir_free(d);  d = NULL;  tor_asprintf(&fn1, "%s/1007", dirname);  r = write_str_to_file(fn1, str1, 0);  tt_int_op(r, OP_EQ, 0);  tor_asprintf(&fn2, "%s/1003.tmp", dirname);  r = write_str_to_file(fn2, str2, 0);  tt_int_op(r, OP_EQ, 0);  // The tempfile should be deleted the next time we list the directory.  d = storage_dir_new(dirname, 10);  tt_int_op(1, OP_EQ, smartlist_len(storage_dir_list(d)));  tt_u64_op(strlen(str1), OP_EQ, storage_dir_get_usage(d));  tt_int_op(FN_FILE, OP_EQ, file_status(fn1));  tt_int_op(FN_NOENT, OP_EQ, file_status(fn2));  bytes = (char*) storage_dir_read(d, "1007", 1, NULL);  tt_str_op(bytes, OP_EQ, str1);  // Should have no effect; file already gone.  storage_dir_remove_file(d, "1003.tmp");  tt_int_op(1, OP_EQ, smartlist_len(storage_dir_list(d)));  tt_u64_op(strlen(str1), OP_EQ, storage_dir_get_usage(d));  // Actually remove a file.  storage_dir_remove_file(d, "1007");  tt_int_op(FN_NOENT, OP_EQ, file_status(fn1));  tt_int_op(0, OP_EQ, smartlist_len(storage_dir_list(d)));  tt_u64_op(0, OP_EQ, storage_dir_get_usage(d)); done:  tor_free(dirname);  tor_free(fn1);  tor_free(fn2);  storage_dir_free(d);  tor_free(bytes);}

/** Build a formatted command line used for the NT service. Return a * pointer to the formatted string on success, or NULL on failure.  Set * *<b>using_default_torrc</b> to true if we're going to use the default * location to torrc, or 1 if an option was specified on the command line. */static char *nt_service_command_line(int *using_default_torrc){  TCHAR tor_exe[MAX_PATH+1];  char tor_exe_ascii[MAX_PATH*2+1];  char *command=NULL, *options=NULL;  smartlist_t *sl;  int i;  *using_default_torrc = 1;  /* Get the location of tor.exe */  if (0 == GetModuleFileName(NULL, tor_exe, MAX_PATH))    return NULL;  /* Get the service arguments */  sl = smartlist_new();  for (i = 1; i < backup_argc; ++i) {    if (!strcmp(backup_argv[i], "--options") ||        !strcmp(backup_argv[i], "-options")) {      while (++i < backup_argc) {        if (!strcmp(backup_argv[i], "-f"))          *using_default_torrc = 0;        smartlist_add(sl, backup_argv[i]);      }    }  }  if (smartlist_len(sl))    options = smartlist_join_strings(sl,"/" /"",0,NULL);  smartlist_free(sl);#ifdef UNICODE  wcstombs(tor_exe_ascii, tor_exe, sizeof(tor_exe_ascii));  tor_exe_ascii[sizeof(tor_exe_ascii)-1] = '/0';#else  strlcpy(tor_exe_ascii, tor_exe, sizeof(tor_exe_ascii));#endif  /* Allocate a string for the NT service command line and */  /* Format the service command */  if (options) {    tor_asprintf(&command, "/"%s/" --nt-service /"%s/"",                 tor_exe_ascii, options);  } else { /* ! options */    tor_asprintf(&command, "/"%s/" --nt-service", tor_exe_ascii);  }  tor_free(options);  return command;}

static voidtest_md_corrupt_desc(void *arg){  char *cp = NULL;  smartlist_t *sl = NULL;  (void) arg;  sl = microdescs_add_to_cache(get_microdesc_cache(),                               "@last-listed 2015-06-22 10:00:00/n"                               "onion-k/n",                               NULL, SAVED_IN_JOURNAL, 0, time(NULL), NULL);  tt_int_op(smartlist_len(sl), OP_EQ, 0);  smartlist_free(sl);  sl = microdescs_add_to_cache(get_microdesc_cache(),                               "@last-listed 2015-06-22 10:00:00/n"                               "wiggly/n",                               NULL, SAVED_IN_JOURNAL, 0, time(NULL), NULL);  tt_int_op(smartlist_len(sl), OP_EQ, 0);  smartlist_free(sl);  tor_asprintf(&cp, "%s/n%s", test_md1, "@foobar/nonion-wobble/n");  sl = microdescs_add_to_cache(get_microdesc_cache(),                               cp, cp+strlen(cp),                               SAVED_IN_JOURNAL, 0, time(NULL), NULL);  tt_int_op(smartlist_len(sl), OP_EQ, 0); done:  tor_free(cp);  smartlist_free(sl);}

tor_assertion_failed_(const char *fname, unsigned int line,                      const char *func, const char *expr,                      const char *fmt, ...){  char *buf = NULL;  char *extra = NULL;  va_list ap;#ifdef __clang__#pragma clang diagnostic push#pragma clang diagnostic ignored "-Wformat-nonliteral"#endif  if (fmt) {    va_start(ap,fmt);    tor_vasprintf(&extra, fmt, ap);    va_end(ap);  }#ifdef __clang__#pragma clang diagnostic pop#endif  log_err(LD_BUG, "%s:%u: %s: Assertion %s failed; aborting.",          fname, line, func, expr);  tor_asprintf(&buf, "Assertion %s failed in %s at %s:%u: %s",               expr, func, fname, line, extra ? extra : "");  tor_free(extra);  log_backtrace(LOG_ERR, LD_BUG, buf);  tor_free(buf);}

/** * Save a broken state file to a backup location. */static voidor_state_save_broken(char *fname){  int i;  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);    unlink(fname);  } 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 (rename(fname, fname2) < 0) {      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);}

/** Give a statement of our current performance thresholds for inclusion * in a vote document. */char *dirserv_get_flag_thresholds_line(void){  char *result=NULL;  const int measured_threshold =    get_options()->MinMeasuredBWsForAuthToIgnoreAdvertised;  const int enough_measured_bw =    dirserv_get_last_n_measured_bws() > measured_threshold;  tor_asprintf(&result,      "stable-uptime=%lu stable-mtbf=%lu "      "fast-speed=%lu "      "guard-wfu=%.03f%% guard-tk=%lu "      "guard-bw-inc-exits=%lu guard-bw-exc-exits=%lu "      "enough-mtbf=%d ignoring-advertised-bws=%d",      (unsigned long)stable_uptime,      (unsigned long)stable_mtbf,      (unsigned long)fast_bandwidth_kb*1000,      guard_wfu*100,      (unsigned long)guard_tk,      (unsigned long)guard_bandwidth_including_exits_kb*1000,      (unsigned long)guard_bandwidth_excluding_exits_kb*1000,      enough_mtbf_info ? 1 : 0,      enough_measured_bw ? 1 : 0);  return result;}

static voidtest_md_cache_broken(void *data){  or_options_t *options;  char *fn=NULL;  microdesc_cache_t *mc = NULL;  (void)data;  options = get_options_mutable();  tt_assert(options);  tor_free(options->CacheDirectory);  options->CacheDirectory = tor_strdup(get_fname("md_datadir_test2"));#ifdef _WIN32  tt_int_op(0, OP_EQ, mkdir(options->CacheDirectory));#else  tt_int_op(0, OP_EQ, mkdir(options->CacheDirectory, 0700));#endif  tor_asprintf(&fn, "%s"PATH_SEPARATOR"cached-microdescs",               options->CacheDirectory);  write_str_to_file(fn, truncated_md, 1);  mc = get_microdesc_cache();  tt_assert(mc); done:  if (options)    tor_free(options->CacheDirectory);  tor_free(fn);  microdesc_free_all();}

static char *fmt_coord(msg_aux_data_t d){  char *v;  struct coord *c = d.ptr;  tor_asprintf(&v, "[%d, %d]", c->x, c->y);  return v;}

/** Helper function: called when we get a GETINFO request for an * accounting-related key on the control connection <b>conn</b>.  If we can * answer the request for <b>question</b>, then set *<b>answer</b> to a newly * allocated string holding the result.  Otherwise, set *<b>answer</b> to * NULL. */intgetinfo_helper_accounting(control_connection_t *conn,                          const char *question, char **answer,                          const char **errmsg){  (void) conn;  (void) errmsg;  if (!strcmp(question, "accounting/enabled")) {    *answer = tor_strdup(accounting_is_enabled(get_options()) ? "1" : "0");  } else if (!strcmp(question, "accounting/hibernating")) {    if (hibernate_state == HIBERNATE_STATE_DORMANT)      *answer = tor_strdup("hard");    else if (hibernate_state == HIBERNATE_STATE_LOWBANDWIDTH)      *answer = tor_strdup("soft");    else      *answer = tor_strdup("awake");  } else if (!strcmp(question, "accounting/bytes")) {    tor_asprintf(answer, U64_FORMAT" "U64_FORMAT,                 U64_PRINTF_ARG(n_bytes_read_in_interval),                 U64_PRINTF_ARG(n_bytes_written_in_interval));  } else if (!strcmp(question, "accounting/bytes-left")) {    uint64_t limit = get_options()->AccountingMax;    uint64_t read_left = 0, write_left = 0;    if (n_bytes_read_in_interval < limit)      read_left = limit - n_bytes_read_in_interval;    if (n_bytes_written_in_interval < limit)      write_left = limit - n_bytes_written_in_interval;    tor_asprintf(answer, U64_FORMAT" "U64_FORMAT,                 U64_PRINTF_ARG(read_left), U64_PRINTF_ARG(write_left));  } else if (!strcmp(question, "accounting/interval-start")) {    *answer = tor_malloc(ISO_TIME_LEN+1);    format_iso_time(*answer, interval_start_time);  } else if (!strcmp(question, "accounting/interval-wake")) {    *answer = tor_malloc(ISO_TIME_LEN+1);    format_iso_time(*answer, interval_wakeup_time);  } else if (!strcmp(question, "accounting/interval-end")) {    *answer = tor_malloc(ISO_TIME_LEN+1);    format_iso_time(*answer, interval_end_time);  } else {    *answer = NULL;  }  return 0;}

/* Return a heap allocated string that contains the given <b>srv</b> string * representation formatted for a networkstatus document using the * <b>key</b> as the start of the line. This doesn't return NULL. */static char *srv_to_ns_string(const sr_srv_t *srv, const char *key){  char *srv_str;  char srv_hash_encoded[SR_SRV_VALUE_BASE64_LEN + 1];  tor_assert(srv);  tor_assert(key);  sr_srv_encode(srv_hash_encoded, sizeof(srv_hash_encoded), srv);  tor_asprintf(&srv_str, "%s %" PRIu64 " %s/n", key,               srv->num_reveals, srv_hash_encoded);  log_debug(LD_DIR, "SR: Consensus SRV line: %s", srv_str);  return srv_str;}

/* Using <b>commit</b>, return a newly allocated string containing the commit * information that should be used during SRV calculation. It's the caller * responsibility to free the memory. Return NULL if this is not a commit to be * used for SRV calculation. */static char *get_srv_element_from_commit(const sr_commit_t *commit){  char *element;  tor_assert(commit);  if (!commit_has_reveal_value(commit)) {    return NULL;  }  tor_asprintf(&element, "%s%s", sr_commit_get_rsa_fpr(commit),               commit->encoded_reveal);  return element;}

/* Given <b>commit</b> give the line that we should place in our votes. * It's the responsibility of the caller to free the string. */static char *get_vote_line_from_commit(const sr_commit_t *commit, sr_phase_t phase){  char *vote_line = NULL;  switch (phase) {  case SR_PHASE_COMMIT:    tor_asprintf(&vote_line, "%s %u %s %s %s/n",                 commit_ns_str,                 SR_PROTO_VERSION,                 crypto_digest_algorithm_get_name(commit->alg),                 sr_commit_get_rsa_fpr(commit),                 commit->encoded_commit);    break;  case SR_PHASE_REVEAL:  {    /* Send a reveal value for this commit if we have one. */    const char *reveal_str = commit->encoded_reveal;    if (tor_mem_is_zero(commit->encoded_reveal,                        sizeof(commit->encoded_reveal))) {      reveal_str = "";    }    tor_asprintf(&vote_line, "%s %u %s %s %s %s/n",                 commit_ns_str,                 SR_PROTO_VERSION,                 crypto_digest_algorithm_get_name(commit->alg),                 sr_commit_get_rsa_fpr(commit),                 commit->encoded_commit, reveal_str);    break;  }  default:    tor_assert(0);  }  log_debug(LD_DIR, "SR: Commit vote line: %s", vote_line);  return vote_line;}

/** Return a newly allocated string holding the address described in * <b>sa</b>.  AF_UNIX, AF_UNSPEC, AF_INET, and AF_INET6 are supported. */char *tor_sockaddr_to_str(const struct sockaddr *sa){  char address[TOR_ADDR_BUF_LEN];  char *result;  tor_addr_t addr;  uint16_t port;#ifdef HAVE_SYS_UN_H  if (sa->sa_family == AF_UNIX) {    struct sockaddr_un *s_un = (struct sockaddr_un *)sa;    tor_asprintf(&result, "unix:%s", s_un->sun_path);    return result;  }#endif  if (sa->sa_family == AF_UNSPEC)    return tor_strdup("unspec");  if (tor_addr_from_sockaddr(&addr, sa, &port) < 0)    return NULL;  if (! tor_addr_to_str(address, &addr, sizeof(address), 1))    return NULL;  tor_asprintf(&result, "%s:%d", address, (int)port);  return result;}

/* From a valid srv object and an allocated config line, set the line's * value to the state string representation of a shared random value. */static voiddisk_state_put_srv_line(const sr_srv_t *srv, config_line_t *line){  char encoded[SR_SRV_VALUE_BASE64_LEN + 1];  tor_assert(line);  /* No SRV value thus don't add the line. This is possible since we might   * not have a current or previous SRV value in our state. */  if (srv == NULL) {    return;  }  sr_srv_encode(encoded, sizeof(encoded), srv);  tor_asprintf(&line->value, "%" PRIu64 " %s", srv->num_reveals, encoded);}

/* From a valid commit object and an allocated config line, set the line's * value to the state string representation of a commit. */static voiddisk_state_put_commit_line(const sr_commit_t *commit, config_line_t *line){  char *reveal_str = NULL;  tor_assert(commit);  tor_assert(line);  if (!tor_mem_is_zero(commit->encoded_reveal,                       sizeof(commit->encoded_reveal))) {    /* Add extra whitespace so we can format the line correctly. */    tor_asprintf(&reveal_str, " %s", commit->encoded_reveal);  }  tor_asprintf(&line->value, "%u %s %s %s%s",               SR_PROTO_VERSION,               crypto_digest_algorithm_get_name(commit->alg),               sr_commit_get_rsa_fpr(commit),               commit->encoded_commit,               reveal_str != NULL ? reveal_str : "");  if (reveal_str != NULL) {    memwipe(reveal_str, 0, strlen(reveal_str));    tor_free(reveal_str);  }}

/** Take seconds <b>secs</b> and return a newly allocated human-readable * uptime string */static char *secs_to_uptime(long secs){  long int days = secs / 86400;  int hours = (int)((secs - (days * 86400)) / 3600);  int minutes = (int)((secs - (days * 86400) - (hours * 3600)) / 60);  char *uptime_string = NULL;  switch (days) {  case 0:    tor_asprintf(&uptime_string, "%d:%02d hours", hours, minutes);    break;  case 1:    tor_asprintf(&uptime_string, "%ld day %d:%02d hours",                 days, hours, minutes);    break;  default:    tor_asprintf(&uptime_string, "%ld days %d:%02d hours",                 days, hours, minutes);    break;  }  return uptime_string;}

/** Print a spec-conformant string to stdout describing the results of *  the TCP port forwarding operation from <b>external_port</b> to *  <b>internal_port</b>. */static voidtor_fw_helper_report_port_fw_results(uint16_t internal_port,                                     uint16_t external_port,                                     int succeded,                                     const char *message){    char *report_string = NULL;    tor_asprintf(&report_string, "%s %s %u %u %s %s/n",                 "tor-fw-helper",                 "tcp-forward",                 external_port, internal_port,                 succeded ? "SUCCESS" : "FAIL",                 message);    fprintf(stdout, "%s", report_string);    fflush(stdout);    tor_free(report_string);}

/** Unregister all TrackHostExits mappings from any address to * *.exitname.exit. */voidclear_trackexithost_mappings(const char *exitname){  char *suffix = NULL;  if (!addressmap || !exitname)    return;  tor_asprintf(&suffix, ".%s.exit", exitname);  tor_strlower(suffix);  STRMAP_FOREACH_MODIFY(addressmap, address, addressmap_entry_t *, ent) {    if (ent->source == ADDRMAPSRC_TRACKEXIT &&        !strcmpend(ent->new_address, suffix)) {      addressmap_ent_remove(address, ent);      MAP_DEL_CURRENT(address);    }  } STRMAP_FOREACH_END;  tor_free(suffix);}

/* Save the disk state to disk but before that update it from the current * state so we always have the latest. Return 0 on success else -1. */static intdisk_state_save_to_disk(void){  int ret;  char *state, *content = NULL, *fname = NULL;  char tbuf[ISO_TIME_LEN + 1];  time_t now = time(NULL);  /* If we didn't have the opportunity to setup an internal disk state,   * don't bother saving something to disk. */  if (sr_disk_state == NULL) {    ret = 0;    goto done;  }  /* Make sure that our disk state is up to date with our memory state   * before saving it to disk. */  disk_state_update();  state = config_dump(&state_format, NULL, sr_disk_state, 0, 0);  format_local_iso_time(tbuf, now);  tor_asprintf(&content,               "# Tor shared random state file last generated on %s "               "local time/n"               "# Other times below are in UTC/n"               "# Please *do not* edit this file./n/n%s",               tbuf, state);  tor_free(state);  fname = get_datadir_fname(default_fname);  if (write_str_to_file(fname, content, 0) < 0) {    log_warn(LD_FS, "SR: Unable to write SR state to file %s", fname);    ret = -1;    goto done;  }  ret = 0;  log_debug(LD_DIR, "SR: Saved state to file %s", fname); done:  tor_free(fname);  tor_free(content);  return ret;}

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

/** Append some EntryGuard lines to the Tor state at <b>state</b>.   <b>entry_guard_lines</b> is a smartlist containing 2-tuple   smartlists that carry the key and values of the statefile.   As an example:   entry_guard_lines =     (("EntryGuard", "name 67E72FF33D7D41BF11C569646A0A7B4B188340DF DirCache"),      ("EntryGuardDownSince", "2014-06-07 16:02:46 2014-06-07 16:02:46"))*/static voidstate_insert_entry_guard_helper(or_state_t *state,                                smartlist_t *entry_guard_lines){  config_line_t **next, *line;  next = &state->EntryGuards;  *next = NULL;  /* Loop over all the state lines in the smartlist */  SMARTLIST_FOREACH_BEGIN(entry_guard_lines, const smartlist_t *,state_lines) {    /* Get key and value for each line */    const char *state_key = smartlist_get(state_lines, 0);    const char *state_value = smartlist_get(state_lines, 1);    *next = line = tor_malloc_zero(sizeof(config_line_t));    line->key = tor_strdup(state_key);    tor_asprintf(&line->value, "%s", state_value);    next = &(line->next);  } SMARTLIST_FOREACH_END(state_lines);}

/** * Output a histogram of current circuit build times to * the or_state_t state structure. */voidcircuit_build_times_update_state(circuit_build_times_t *cbt,                                 or_state_t *state){  uint32_t *histogram;  build_time_t i = 0;  build_time_t nbins = 0;  config_line_t **next, *line;  histogram = circuit_build_times_create_histogram(cbt, &nbins);  // write to state  config_free_lines(state->BuildtimeHistogram);  next = &state->BuildtimeHistogram;  *next = NULL;  state->TotalBuildTimes = cbt->total_build_times;  state->CircuitBuildAbandonedCount = 0;  for (i = 0; i < CBT_NCIRCUITS_TO_OBSERVE; i++) {    if (cbt->circuit_build_times[i] == CBT_BUILD_ABANDONED)      state->CircuitBuildAbandonedCount++;  }  for (i = 0; i < nbins; i++) {    // compress the histogram by skipping the blanks    if (histogram[i] == 0) continue;    *next = line = tor_malloc_zero(sizeof(config_line_t));    line->key = tor_strdup("CircuitBuildTimeBin");    tor_asprintf(&line->value, "%d %d",            CBT_BIN_TO_MS(i), histogram[i]);    next = &(line->next);  }  if (!unit_tests) {    if (!get_options()->AvoidDiskWrites)      or_state_mark_dirty(get_or_state(), 0);  }  tor_free(histogram);}

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

/* Remove a directory and all of its subdirectories */static voidrm_rf(const char *dir){  struct stat st;  smartlist_t *elements;  elements = tor_listdir(dir);  if (elements) {    SMARTLIST_FOREACH_BEGIN(elements, const char *, cp) {         char *tmp = NULL;         tor_asprintf(&tmp, "%s"PATH_SEPARATOR"%s", dir, cp);         if (0 == stat(tmp,&st) && (st.st_mode & S_IFDIR)) {           rm_rf(tmp);         } else {           if (unlink(tmp)) {             fprintf(stderr, "Error removing %s: %s/n", tmp, strerror(errno));           }         }         tor_free(tmp);    } SMARTLIST_FOREACH_END(cp);    SMARTLIST_FOREACH(elements, char *, cp, tor_free(cp));    smartlist_free(elements);  }

static voidtest_routerkeys_write_fingerprint(void *arg){  crypto_pk_t *key = pk_generate(2);  or_options_t *options = get_options_mutable();  const char *ddir = get_fname("write_fingerprint");  char *cp = NULL, *cp2 = NULL;  char fp[FINGERPRINT_LEN+1];  (void)arg;  tt_assert(key);  options->ORPort_set = 1; /* So that we can get the server ID key */  tor_free(options->DataDirectory);  options->DataDirectory = tor_strdup(ddir);  options->Nickname = tor_strdup("haflinger");  set_server_identity_key(key);  set_client_identity_key(crypto_pk_dup_key(key));  tt_int_op(0, OP_EQ, check_private_dir(ddir, CPD_CREATE, NULL));  tt_int_op(crypto_pk_cmp_keys(get_server_identity_key(),key),OP_EQ,0);  /* Write fingerprint file */  tt_int_op(0, OP_EQ, router_write_fingerprint(0));  cp = read_file_to_str(get_fname("write_fingerprint/fingerprint"),                        0, NULL);  crypto_pk_get_fingerprint(key, fp, 0);  tor_asprintf(&cp2, "haflinger %s/n", fp);  tt_str_op(cp, OP_EQ, cp2);  tor_free(cp);  tor_free(cp2);  /* Write hashed-fingerprint file */  tt_int_op(0, OP_EQ, router_write_fingerprint(1));  cp = read_file_to_str(get_fname("write_fingerprint/hashed-fingerprint"),                        0, NULL);  crypto_pk_get_hashed_fingerprint(key, fp);  tor_asprintf(&cp2, "haflinger %s/n", fp);  tt_str_op(cp, OP_EQ, cp2);  tor_free(cp);  tor_free(cp2);  /* Replace outdated file */  write_str_to_file(get_fname("write_fingerprint/hashed-fingerprint"),                    "junk goes here", 0);  tt_int_op(0, OP_EQ, router_write_fingerprint(1));  cp = read_file_to_str(get_fname("write_fingerprint/hashed-fingerprint"),                        0, NULL);  crypto_pk_get_hashed_fingerprint(key, fp);  tor_asprintf(&cp2, "haflinger %s/n", fp);  tt_str_op(cp, OP_EQ, cp2);  tor_free(cp);  tor_free(cp2); done:  crypto_pk_free(key);  set_client_identity_key(NULL);  tor_free(cp);  tor_free(cp2);}

/** <b>c</b>-/>key is known to be a real key. Update <b>options</b> * with <b>c</b>-/>value and return 0, or return -1 if bad value. * * Called from config_assign_line() and option_reset(). */static intconfig_assign_value(const config_format_t *fmt, void *options,                    config_line_t *c, char **msg){  int i, ok;  const config_var_t *var;  void *lvalue;  int *csv_int;  smartlist_t *csv_str;  CONFIG_CHECK(fmt, options);  var = config_find_option(fmt, c->key);  tor_assert(var);  lvalue = STRUCT_VAR_P(options, var->var_offset);  switch (var->type) {  case CONFIG_TYPE_PORT:    if (!strcasecmp(c->value, "auto")) {      *(int *)lvalue = CFG_AUTO_PORT;      break;    }    /* fall through */  case CONFIG_TYPE_INT:  case CONFIG_TYPE_UINT:    i = (int)tor_parse_long(c->value, 10,                            var->type==CONFIG_TYPE_INT ? INT_MIN : 0,                            var->type==CONFIG_TYPE_PORT ? 65535 : INT_MAX,                            &ok, NULL);    if (!ok) {      tor_asprintf(msg,          "Int keyword '%s %s' is malformed or out of bounds.",          c->key, c->value);      return -1;    }    *(int *)lvalue = i;    break;  case CONFIG_TYPE_INTERVAL: {    i = config_parse_interval(c->value, &ok);    if (!ok) {      tor_asprintf(msg,          "Interval '%s %s' is malformed or out of bounds.",          c->key, c->value);      return -1;    }    *(int *)lvalue = i;    break;  }  case CONFIG_TYPE_MSEC_INTERVAL: {    i = config_parse_msec_interval(c->value, &ok);    if (!ok) {      tor_asprintf(msg,          "Msec interval '%s %s' is malformed or out of bounds.",          c->key, c->value);      return -1;    }    *(int *)lvalue = i;    break;  }  case CONFIG_TYPE_MEMUNIT: {    uint64_t u64 = config_parse_memunit(c->value, &ok);    if (!ok) {      tor_asprintf(msg,          "Value '%s %s' is malformed or out of bounds.",          c->key, c->value);      return -1;    }    *(uint64_t *)lvalue = u64;    break;  }  case CONFIG_TYPE_BOOL:    i = (int)tor_parse_long(c->value, 10, 0, 1, &ok, NULL);    if (!ok) {      tor_asprintf(msg,          "Boolean '%s %s' expects 0 or 1.",          c->key, c->value);      return -1;    }    *(int *)lvalue = i;    break;  case CONFIG_TYPE_AUTOBOOL:    if (!strcmp(c->value, "auto"))      *(int *)lvalue = -1;    else if (!strcmp(c->value, "0"))      *(int *)lvalue = 0;    else if (!strcmp(c->value, "1"))      *(int *)lvalue = 1;    else {//.........这里部分代码省略.........

/** * Generate a routerstatus for v3_networkstatus test. */vote_routerstatus_t *dir_common_gen_routerstatus_for_v3ns(int idx, time_t now){  vote_routerstatus_t *vrs=NULL;  routerstatus_t *rs = NULL;  tor_addr_t addr_ipv6;  char *method_list = NULL;  switch (idx) {    case 0:      /* Generate the first routerstatus. */      vrs = tor_malloc_zero(sizeof(vote_routerstatus_t));      rs = &vrs->status;      vrs->version = tor_strdup("0.1.2.14");      rs->published_on = now-1500;      strlcpy(rs->nickname, "router2", sizeof(rs->nickname));      memset(rs->identity_digest, TEST_DIR_ROUTER_ID_1, DIGEST_LEN);      memset(rs->descriptor_digest, TEST_DIR_ROUTER_DD_1, DIGEST_LEN);      rs->addr = 0x99008801;      rs->or_port = 443;      rs->dir_port = 8000;      /* all flags but running and v2dir cleared */      rs->is_flagged_running = 1;      rs->is_v2_dir = 1;      break;    case 1:      /* Generate the second routerstatus. */      vrs = tor_malloc_zero(sizeof(vote_routerstatus_t));      rs = &vrs->status;      vrs->version = tor_strdup("0.2.0.5");      rs->published_on = now-1000;      strlcpy(rs->nickname, "router1", sizeof(rs->nickname));      memset(rs->identity_digest, TEST_DIR_ROUTER_ID_2, DIGEST_LEN);      memset(rs->descriptor_digest, TEST_DIR_ROUTER_DD_2, DIGEST_LEN);      rs->addr = 0x99009901;      rs->or_port = 443;      rs->dir_port = 0;      tor_addr_parse(&addr_ipv6, "[1:2:3::4]");      tor_addr_copy(&rs->ipv6_addr, &addr_ipv6);      rs->ipv6_orport = 4711;      rs->is_exit = rs->is_stable = rs->is_fast = rs->is_flagged_running =        rs->is_valid = rs->is_possible_guard = rs->is_v2_dir = 1;      break;    case 2:      /* Generate the third routerstatus. */      vrs = tor_malloc_zero(sizeof(vote_routerstatus_t));      rs = &vrs->status;      vrs->version = tor_strdup("0.1.0.3");      rs->published_on = now-1000;      strlcpy(rs->nickname, "router3", sizeof(rs->nickname));      memset(rs->identity_digest, TEST_DIR_ROUTER_ID_3, DIGEST_LEN);      memset(rs->descriptor_digest, TEST_DIR_ROUTER_DD_3, DIGEST_LEN);      rs->addr = 0xAA009901;      rs->or_port = 400;      rs->dir_port = 9999;      rs->is_authority = rs->is_exit = rs->is_stable = rs->is_fast =        rs->is_flagged_running = rs->is_valid = rs->is_v2_dir =        rs->is_possible_guard = 1;      break;    case 3:      /* Generate a fourth routerstatus that is not running. */      vrs = tor_malloc_zero(sizeof(vote_routerstatus_t));      rs = &vrs->status;      vrs->version = tor_strdup("0.1.6.3");      rs->published_on = now-1000;      strlcpy(rs->nickname, "router4", sizeof(rs->nickname));      memset(rs->identity_digest, TEST_DIR_ROUTER_ID_4, DIGEST_LEN);      memset(rs->descriptor_digest, TEST_DIR_ROUTER_DD_4, DIGEST_LEN);      rs->addr = 0xC0000203;      rs->or_port = 500;      rs->dir_port = 1999;      rs->is_v2_dir = 1;      /* Running flag (and others) cleared */      break;    case 4:      /* No more for this test; return NULL */      vrs = NULL;      break;    default:      /* Shouldn't happen */      tt_assert(0);  }  if (vrs) {    vrs->microdesc = tor_malloc_zero(sizeof(vote_microdesc_hash_t));    method_list = make_consensus_method_list(MIN_SUPPORTED_CONSENSUS_METHOD,                                             MAX_SUPPORTED_CONSENSUS_METHOD,                                             ",");    tor_asprintf(&vrs->microdesc->microdesc_hash_line,                 "m %s "                 "sha256=xyzajkldsdsajdadlsdjaslsdksdjlsdjsdaskdaaa%d/n",                 method_list, idx);  } done:  tor_free(method_list);  return vrs;}