开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 网络 > 查看源码
router.c
资源名称：tor-0.2.1.20.tar.gz　[点击查看]
上传用户：awang829
上传日期：2019-07-14
资源大小：2356k
文件大小：65k
源码类别：

网络

开发平台：

Unix_Linux

router.c：源码内容
  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-2009, The Tor Project, Inc. */
  5. /* See LICENSE for licensing information */
  7. #define ROUTER_PRIVATE
  9. #include "or.h"
  11. /**
  12.  * file router.c
  13.  * brief OR functionality, including key maintenance, generating
  14.  * and uploading server descriptors, retrying OR connections.
  15.  **/
  17. extern long stats_n_seconds_working;
  19. /************************************************************/
  21. /*****
  22.  * Key management: ORs only.
  23.  *****/
  25. /** Private keys for this OR.  There is also an SSL key managed by tortls.c.
  26.  */
  27. static tor_mutex_t *key_lock=NULL;
  28. static time_t onionkey_set_at=0; /**< When was onionkey last changed? */
  29. /** Current private onionskin decryption key: used to decode CREATE cells. */
  30. static crypto_pk_env_t *onionkey=NULL;
  31. /** Previous private onionskin decryption key: used to decode CREATE cells
  32.  * generated by clients that have an older version of our descriptor. */
  33. static crypto_pk_env_t *lastonionkey=NULL;
  34. /** Private "identity key": used to sign directory info and TLS
  35.  * certificates. Never changes. */
  36. static crypto_pk_env_t *identitykey=NULL;
  37. /** Digest of identitykey. */
  38. static char identitykey_digest[DIGEST_LEN];
  39. /** Signing key used for v3 directory material; only set for authorities. */
  40. static crypto_pk_env_t *authority_signing_key = NULL;
  41. /** Key certificate to authenticate v3 directory material; only set for
  42.  * authorities. */
  43. static authority_cert_t *authority_key_certificate = NULL;
  45. /** For emergency V3 authority key migration: An extra signing key that we use
  46.  * with our old (obsolete) identity key for a while. */
  47. static crypto_pk_env_t *legacy_signing_key = NULL;
  48. /** For emergency V3 authority key migration: An extra certificate to
  49.  * authenticate legacy_signing_key with our obsolete identity key.*/
  50. static authority_cert_t *legacy_key_certificate = NULL;
  52. /* (Note that v3 authorities also have a separate "authority identity key",
  53.  * but this key is never actually loaded by the Tor process.  Instead, it's
  54.  * used by tor-gencert to sign new signing keys and make new key
  55.  * certificates. */
  57. /** Replace the current onion key with <b>k</b>.  Does not affect
  58.  * lastonionkey; to update lastonionkey correctly, call rotate_onion_key().
  59.  */
  60. static void
  61. set_onion_key(crypto_pk_env_t *k)
  62. {
  63.   tor_mutex_acquire(key_lock);
  64.   if (onionkey)
  65.     crypto_free_pk_env(onionkey);
  66.   onionkey = k;
  67.   onionkey_set_at = time(NULL);
  68.   tor_mutex_release(key_lock);
  69.   mark_my_descriptor_dirty();
  70. }
  72. /** Return the current onion key.  Requires that the onion key has been
  73.  * loaded or generated. */
  74. crypto_pk_env_t *
  75. get_onion_key(void)
  76. {
  77.   tor_assert(onionkey);
  78.   return onionkey;
  79. }
  81. /** Store a full copy of the current onion key into *<b>key</b>, and a full
  82.  * copy of the most recent onion key into *<b>last</b>.
  83.  */
  84. void
  85. dup_onion_keys(crypto_pk_env_t **key, crypto_pk_env_t **last)
  86. {
  87.   tor_assert(key);
  88.   tor_assert(last);
  89.   tor_mutex_acquire(key_lock);
  90.   tor_assert(onionkey);
  91.   *key = crypto_pk_copy_full(onionkey);
  92.   if (lastonionkey)
  93.     *last = crypto_pk_copy_full(lastonionkey);
  94.   else
  95.     *last = NULL;
  96.   tor_mutex_release(key_lock);
  97. }
  99. /** Return the time when the onion key was last set.  This is either the time
  100.  * when the process launched, or the time of the most recent key rotation since
  101.  * the process launched.
  102.  */
  103. time_t
  104. get_onion_key_set_at(void)
  105. {
  106.   return onionkey_set_at;
  107. }
  109. /** Set the current identity key to k.
  110.  */
  111. void
  112. set_identity_key(crypto_pk_env_t *k)
  113. {
  114.   if (identitykey)
  115.     crypto_free_pk_env(identitykey);
  116.   identitykey = k;
  117.   crypto_pk_get_digest(identitykey, identitykey_digest);
  118. }
  120. /** Returns the current identity key; requires that the identity key has been
  121.  * set.
  122.  */
  123. crypto_pk_env_t *
  124. get_identity_key(void)
  125. {
  126.   tor_assert(identitykey);
  127.   return identitykey;
  128. }
  130. /** Return true iff the identity key has been set. */
  131. int
  132. identity_key_is_set(void)
  133. {
  134.   return identitykey != NULL;
  135. }
  137. /** Return the key certificate for this v3 (voting) authority, or NULL
  138.  * if we have no such certificate. */
  139. authority_cert_t *
  140. get_my_v3_authority_cert(void)
  141. {
  142.   return authority_key_certificate;
  143. }
  145. /** Return the v3 signing key for this v3 (voting) authority, or NULL
  146.  * if we have no such key. */
  147. crypto_pk_env_t *
  148. get_my_v3_authority_signing_key(void)
  149. {
  150.   return authority_signing_key;
  151. }
  153. /** If we're an authority, and we're using a legacy authority identity key for
  154.  * emergency migration purposes, return the certificate associated with that
  155.  * key. */
  156. authority_cert_t *
  157. get_my_v3_legacy_cert(void)
  158. {
  159.   return legacy_key_certificate;
  160. }
  162. /** If we're an authority, and we're using a legacy authority identity key for
  163.  * emergency migration purposes, return that key. */
  164. crypto_pk_env_t *
  165. get_my_v3_legacy_signing_key(void)
  166. {
  167.   return legacy_signing_key;
  168. }
  170. /** Replace the previous onion key with the current onion key, and generate
  171.  * a new previous onion key.  Immediately after calling this function,
  172.  * the OR should:
  173.  *   - schedule all previous cpuworkers to shut down _after_ processing
  174.  *     pending work.  (This will cause fresh cpuworkers to be generated.)
  175.  *   - generate and upload a fresh routerinfo.
  176.  */
  177. void
  178. rotate_onion_key(void)
  179. {
  180.   char *fname, *fname_prev;
  181.   crypto_pk_env_t *prkey;
  182.   or_state_t *state = get_or_state();
  183.   time_t now;
  184.   fname = get_datadir_fname2("keys", "secret_onion_key");
  185.   fname_prev = get_datadir_fname2("keys", "secret_onion_key.old");
  186.   if (!(prkey = crypto_new_pk_env())) {
  187.     log_err(LD_GENERAL,"Error constructing rotated onion key");
  188.     goto error;
  189.   }
  190.   if (crypto_pk_generate_key(prkey)) {
  191.     log_err(LD_BUG,"Error generating onion key");
  192.     goto error;
  193.   }
  194.   if (file_status(fname) == FN_FILE) {
  195.     if (replace_file(fname, fname_prev))
  196.       goto error;
  197.   }
  198.   if (crypto_pk_write_private_key_to_filename(prkey, fname)) {
  199.     log_err(LD_FS,"Couldn't write generated onion key to "%s".", fname);
  200.     goto error;
  201.   }
  202.   log_info(LD_GENERAL, "Rotating onion key");
  203.   tor_mutex_acquire(key_lock);
  204.   if (lastonionkey)
  205.     crypto_free_pk_env(lastonionkey);
  206.   lastonionkey = onionkey;
  207.   onionkey = prkey;
  208.   now = time(NULL);
  209.   state->LastRotatedOnionKey = onionkey_set_at = now;
  210.   tor_mutex_release(key_lock);
  211.   mark_my_descriptor_dirty();
  212.   or_state_mark_dirty(state, get_options()->AvoidDiskWrites ? now+3600 : 0);
  213.   goto done;
  214.  error:
  215.   log_warn(LD_GENERAL, "Couldn't rotate onion key.");
  216.   if (prkey)
  217.     crypto_free_pk_env(prkey);
  218.  done:
  219.   tor_free(fname);
  220.   tor_free(fname_prev);
  221. }
  223. /** Try to read an RSA key from <b>fname</b>.  If <b>fname</b> doesn't exist
  224.  * and <b>generate</b> is true, create a new RSA key and save it in
  225.  * <b>fname</b>.  Return the read/created key, or NULL on error.  Log all
  226.  * errors at level <b>severity</b>.
  227.  */
  228. crypto_pk_env_t *
  229. init_key_from_file(const char *fname, int generate, int severity)
  230. {
  231.   crypto_pk_env_t *prkey = NULL;
  233.   if (!(prkey = crypto_new_pk_env())) {
  234.     log(severity, LD_GENERAL,"Error constructing key");
  235.     goto error;
  236.   }
  238.   switch (file_status(fname)) {
  239.     case FN_DIR:
  240.     case FN_ERROR:
  241.       log(severity, LD_FS,"Can't read key from "%s"", fname);
  242.       goto error;
  243.     case FN_NOENT:
  244.       if (generate) {
  245.         if (!have_lockfile()) {
  246.           if (try_locking(get_options(), 0)<0) {
  247.             /* Make sure that --list-fingerprint only creates new keys
  248.              * if there is no possibility for a deadlock. */
  249.             log(severity, LD_FS, "Another Tor process has locked "%s". Not "
  250.                 "writing any new keys.", fname);
  251.             /*XXXX The 'other process' might make a key in a second or two;
  252.              * maybe we should wait for it. */
  253.             goto error;
  254.           }
  255.         }
  256.         log_info(LD_GENERAL, "No key found in "%s"; generating fresh key.",
  257.                  fname);
  258.         if (crypto_pk_generate_key(prkey)) {
  259.           log(severity, LD_GENERAL,"Error generating onion key");
  260.           goto error;
  261.         }
  262.         if (crypto_pk_check_key(prkey) <= 0) {
  263.           log(severity, LD_GENERAL,"Generated key seems invalid");
  264.           goto error;
  265.         }
  266.         log_info(LD_GENERAL, "Generated key seems valid");
  267.         if (crypto_pk_write_private_key_to_filename(prkey, fname)) {
  268.           log(severity, LD_FS,
  269.               "Couldn't write generated key to "%s".", fname);
  270.           goto error;
  271.         }
  272.       } else {
  273.         log_info(LD_GENERAL, "No key found in "%s"", fname);
  274.       }
  275.       return prkey;
  276.     case FN_FILE:
  277.       if (crypto_pk_read_private_key_from_filename(prkey, fname)) {
  278.         log(severity, LD_GENERAL,"Error loading private key.");
  279.         goto error;
  280.       }
  281.       return prkey;
  282.     default:
  283.       tor_assert(0);
  284.   }
  286.  error:
  287.   if (prkey)
  288.     crypto_free_pk_env(prkey);
  289.   return NULL;
  290. }
  292. /** Try to load the vote-signing private key and certificate for being a v3
  293.  * directory authority, and make sure they match.  If <b>legacy</b>, load a
  294.  * legacy key/cert set for emergency key migration; otherwise load the regular
  295.  * key/cert set.  On success, store them into *<b>key_out</b> and
  296.  * *<b>cert_out</b> respectively, and return 0.  On failure, return -1. */
  297. static int
  298. load_authority_keyset(int legacy, crypto_pk_env_t **key_out,
  299.                       authority_cert_t **cert_out)
  300. {
  301.   int r = -1;
  302.   char *fname = NULL, *cert = NULL;
  303.   const char *eos = NULL;
  304.   crypto_pk_env_t *signing_key = NULL;
  305.   authority_cert_t *parsed = NULL;
  307.   fname = get_datadir_fname2("keys",
  308.                  legacy ? "legacy_signing_key" : "authority_signing_key");
  309.   signing_key = init_key_from_file(fname, 0, LOG_INFO);
  310.   if (!signing_key) {
  311.     log_warn(LD_DIR, "No version 3 directory key found in %s", fname);
  312.     goto done;
  313.   }
  314.   tor_free(fname);
  315.   fname = get_datadir_fname2("keys",
  316.                legacy ? "legacy_certificate" : "authority_certificate");
  317.   cert = read_file_to_str(fname, 0, NULL);
  318.   if (!cert) {
  319.     log_warn(LD_DIR, "Signing key found, but no certificate found in %s",
  320.                fname);
  321.     goto done;
  322.   }
  323.   parsed = authority_cert_parse_from_string(cert, &eos);
  324.   if (!parsed) {
  325.     log_warn(LD_DIR, "Unable to parse certificate in %s", fname);
  326.     goto done;
  327.   }
  328.   if (crypto_pk_cmp_keys(signing_key, parsed->signing_key) != 0) {
  329.     log_warn(LD_DIR, "Stored signing key does not match signing key in "
  330.              "certificate");
  331.     goto done;
  332.   }
  334.   if (*key_out)
  335.     crypto_free_pk_env(*key_out);
  336.   if (*cert_out)
  337.     authority_cert_free(*cert_out);
  338.   *key_out = signing_key;
  339.   *cert_out = parsed;
  340.   r = 0;
  341.   signing_key = NULL;
  342.   parsed = NULL;
  344.  done:
  345.   tor_free(fname);
  346.   tor_free(cert);
  347.   if (signing_key)
  348.     crypto_free_pk_env(signing_key);
  349.   if (parsed)
  350.     authority_cert_free(parsed);
  351.   return r;
  352. }
  354. /** Load the v3 (voting) authority signing key and certificate, if they are
  355.  * present.  Return -1 if anything is missing, mismatched, or unloadable;
  356.  * return 0 on success. */
  357. static int
  358. init_v3_authority_keys(void)
  359. {
  360.   if (load_authority_keyset(0, &authority_signing_key,
  361.                             &authority_key_certificate)<0)
  362.     return -1;
  364.   if (get_options()->V3AuthUseLegacyKey &&
  365.       load_authority_keyset(1, &legacy_signing_key,
  366.                             &legacy_key_certificate)<0)
  367.     return -1;
  369.   return 0;
  370. }
  372. /** If we're a v3 authority, check whether we have a certificate that's
  373.  * likely to expire soon.  Warn if we do, but not too often. */
  374. void
  375. v3_authority_check_key_expiry(void)
  376. {
  377.   time_t now, expires;
  378.   static time_t last_warned = 0;
  379.   int badness, time_left, warn_interval;
  380.   if (!authdir_mode_v3(get_options()) || !authority_key_certificate)
  381.     return;
  383.   now = time(NULL);
  384.   expires = authority_key_certificate->expires;
  385.   time_left = (int)( expires - now );
  386.   if (time_left <= 0) {
  387.     badness = LOG_ERR;
  388.     warn_interval = 60*60;
  389.   } else if (time_left <= 24*60*60) {
  390.     badness = LOG_WARN;
  391.     warn_interval = 60*60;
  392.   } else if (time_left <= 24*60*60*7) {
  393.     badness = LOG_WARN;
  394.     warn_interval = 24*60*60;
  395.   } else if (time_left <= 24*60*60*30) {
  396.     badness = LOG_WARN;
  397.     warn_interval = 24*60*60*5;
  398.   } else {
  399.     return;
  400.   }
  402.   if (last_warned + warn_interval > now)
  403.     return;
  405.   if (time_left <= 0) {
  406.     log(badness, LD_DIR, "Your v3 authority certificate has expired."
  407.         " Generate a new one NOW.");
  408.   } else if (time_left <= 24*60*60) {
  409.     log(badness, LD_DIR, "Your v3 authority certificate expires in %d hours;"
  410.         " Generate a new one NOW.", time_left/(60*60));
  411.   } else {
  412.     log(badness, LD_DIR, "Your v3 authority certificate expires in %d days;"
  413.         " Generate a new one soon.", time_left/(24*60*60));
  414.   }
  415.   last_warned = now;
  416. }
  418. /** Initialize all OR private keys, and the TLS context, as necessary.
  419.  * On OPs, this only initializes the tls context. Return 0 on success,
  420.  * or -1 if Tor should die.
  421.  */
  422. int
  423. init_keys(void)
  424. {
  425.   char *keydir;
  426.   char fingerprint[FINGERPRINT_LEN+1];
  427.   /*nickname<space>fpn */
  428.   char fingerprint_line[MAX_NICKNAME_LEN+FINGERPRINT_LEN+3];
  429.   const char *mydesc;
  430.   crypto_pk_env_t *prkey;
  431.   char digest[20];
  432.   char v3_digest[20];
  433.   char *cp;
  434.   or_options_t *options = get_options();
  435.   authority_type_t type;
  436.   time_t now = time(NULL);
  437.   trusted_dir_server_t *ds;
  438.   int v3_digest_set = 0;
  439.   authority_cert_t *cert = NULL;
  441.   if (!key_lock)
  442.     key_lock = tor_mutex_new();
  444.   /* There are a couple of paths that put us here before */
  445.   if (crypto_global_init(get_options()->HardwareAccel)) {
  446.     log_err(LD_BUG, "Unable to initialize OpenSSL. Exiting.");
  447.     return -1;
  448.   }
  450.   /* OP's don't need persistent keys; just make up an identity and
  451.    * initialize the TLS context. */
  452.   if (!server_mode(options)) {
  453.     if (!(prkey = crypto_new_pk_env()))
  454.       return -1;
  455.     if (crypto_pk_generate_key(prkey)) {
  456.       crypto_free_pk_env(prkey);
  457.       return -1;
  458.     }
  459.     set_identity_key(prkey);
  460.     /* Create a TLS context; default the client nickname to "client". */
  461.     if (tor_tls_context_new(get_identity_key(), MAX_SSL_KEY_LIFETIME) < 0) {
  462.       log_err(LD_GENERAL,"Error creating TLS context for Tor client.");
  463.       return -1;
  464.     }
  465.     return 0;
  466.   }
  467.   /* Make sure DataDirectory exists, and is private. */
  468.   if (check_private_dir(options->DataDirectory, CPD_CREATE)) {
  469.     return -1;
  470.   }
  471.   /* Check the key directory. */
  472.   keydir = get_datadir_fname("keys");
  473.   if (check_private_dir(keydir, CPD_CREATE)) {
  474.     tor_free(keydir);
  475.     return -1;
  476.   }
  477.   tor_free(keydir);
  479.   /* 1a. Read v3 directory authority key/cert information. */
  480.   memset(v3_digest, 0, sizeof(v3_digest));
  481.   if (authdir_mode_v3(options)) {
  482.     if (init_v3_authority_keys()<0) {
  483.       log_err(LD_GENERAL, "We're configured as a V3 authority, but we "
  484.               "were unable to load our v3 authority keys and certificate! "
  485.               "Use tor-gencert to generate them. Dying.");
  486.       return -1;
  487.     }
  488.     cert = get_my_v3_authority_cert();
  489.     if (cert) {
  490.       crypto_pk_get_digest(get_my_v3_authority_cert()->identity_key,
  491.                            v3_digest);
  492.       v3_digest_set = 1;
  493.     }
  494.   }
  496.   /* 1. Read identity key. Make it if none is found. */
  497.   keydir = get_datadir_fname2("keys", "secret_id_key");
  498.   log_info(LD_GENERAL,"Reading/making identity key "%s"...",keydir);
  499.   prkey = init_key_from_file(keydir, 1, LOG_ERR);
  500.   tor_free(keydir);
  501.   if (!prkey) return -1;
  502.   set_identity_key(prkey);
  504.   /* 2. Read onion key.  Make it if none is found. */
  505.   keydir = get_datadir_fname2("keys", "secret_onion_key");
  506.   log_info(LD_GENERAL,"Reading/making onion key "%s"...",keydir);
  507.   prkey = init_key_from_file(keydir, 1, LOG_ERR);
  508.   tor_free(keydir);
  509.   if (!prkey) return -1;
  510.   set_onion_key(prkey);
  511.   if (options->command == CMD_RUN_TOR) {
  512.     /* only mess with the state file if we're actually running Tor */
  513.     or_state_t *state = get_or_state();
  514.     if (state->LastRotatedOnionKey > 100 && state->LastRotatedOnionKey < now) {
  515.       /* We allow for some parsing slop, but we don't want to risk accepting
  516.        * values in the distant future.  If we did, we might never rotate the
  517.        * onion key. */
  518.       onionkey_set_at = state->LastRotatedOnionKey;
  519.     } else {
  520.       /* We have no LastRotatedOnionKey set; either we just created the key
  521.        * or it's a holdover from 0.1.2.4-alpha-dev or earlier.  In either case,
  522.        * start the clock ticking now so that we will eventually rotate it even
  523.        * if we don't stay up for a full MIN_ONION_KEY_LIFETIME. */
  524.       state->LastRotatedOnionKey = onionkey_set_at = now;
  525.       or_state_mark_dirty(state, options->AvoidDiskWrites ?
  526.                                    time(NULL)+3600 : 0);
  527.     }
  528.   }
  530.   keydir = get_datadir_fname2("keys", "secret_onion_key.old");
  531.   if (!lastonionkey && file_status(keydir) == FN_FILE) {
  532.     prkey = init_key_from_file(keydir, 1, LOG_ERR);
  533.     if (prkey)
  534.       lastonionkey = prkey;
  535.   }
  536.   tor_free(keydir);
  538.   /* 3. Initialize link key and TLS context. */
  539.   if (tor_tls_context_new(get_identity_key(), MAX_SSL_KEY_LIFETIME) < 0) {
  540.     log_err(LD_GENERAL,"Error initializing TLS context");
  541.     return -1;
  542.   }
  543.   /* 4. Build our router descriptor. */
  544.   /* Must be called after keys are initialized. */
  545.   mydesc = router_get_my_descriptor();
  546.   if (authdir_mode(options)) {
  547.     const char *m = NULL;
  548.     routerinfo_t *ri;
  549.     /* We need to add our own fingerprint so it gets recognized. */
  550.     if (dirserv_add_own_fingerprint(options->Nickname, get_identity_key())) {
  551.       log_err(LD_GENERAL,"Error adding own fingerprint to approved set");
  552.       return -1;
  553.     }
  554.     if (mydesc) {
  555.       ri = router_parse_entry_from_string(mydesc, NULL, 1, 0, NULL);
  556.       if (!ri) {
  557.         log_err(LD_GENERAL,"Generated a routerinfo we couldn't parse.");
  558.         return -1;
  559.       }
  560.       if (!WRA_WAS_ADDED(dirserv_add_descriptor(ri, &m, "self"))) {
  561.         log_err(LD_GENERAL,"Unable to add own descriptor to directory: %s",
  562.                 m?m:"<unknown error>");
  563.         return -1;
  564.       }
  565.     }
  566.   }
  568.   /* 5. Dump fingerprint to 'fingerprint' */
  569.   keydir = get_datadir_fname("fingerprint");
  570.   log_info(LD_GENERAL,"Dumping fingerprint to "%s"...",keydir);
  571.   if (crypto_pk_get_fingerprint(get_identity_key(), fingerprint, 0)<0) {
  572.     log_err(LD_GENERAL,"Error computing fingerprint");
  573.     tor_free(keydir);
  574.     return -1;
  575.   }
  576.   tor_assert(strlen(options->Nickname) <= MAX_NICKNAME_LEN);
  577.   if (tor_snprintf(fingerprint_line, sizeof(fingerprint_line),
  578.                    "%s %sn",options->Nickname, fingerprint) < 0) {
  579.     log_err(LD_GENERAL,"Error writing fingerprint line");
  580.     tor_free(keydir);
  581.     return -1;
  582.   }
  583.   /* Check whether we need to write the fingerprint file. */
  584.   cp = NULL;
  585.   if (file_status(keydir) == FN_FILE)
  586.     cp = read_file_to_str(keydir, 0, NULL);
  587.   if (!cp || strcmp(cp, fingerprint_line)) {
  588.     if (write_str_to_file(keydir, fingerprint_line, 0)) {
  589.       log_err(LD_FS, "Error writing fingerprint line to file");
  590.       tor_free(keydir);
  591.       return -1;
  592.     }
  593.   }
  594.   tor_free(cp);
  595.   tor_free(keydir);
  597.   log(LOG_NOTICE, LD_GENERAL,
  598.       "Your Tor server's identity key fingerprint is '%s %s'",
  599.       options->Nickname, fingerprint);
  600.   if (!authdir_mode(options))
  601.     return 0;
  602.   /* 6. [authdirserver only] load approved-routers file */
  603.   if (dirserv_load_fingerprint_file() < 0) {
  604.     log_err(LD_GENERAL,"Error loading fingerprints");
  605.     return -1;
  606.   }
  607.   /* 6b. [authdirserver only] add own key to approved directories. */
  608.   crypto_pk_get_digest(get_identity_key(), digest);
  609.   type = ((options->V1AuthoritativeDir ? V1_AUTHORITY : NO_AUTHORITY) |
  610.           (options->V2AuthoritativeDir ? V2_AUTHORITY : NO_AUTHORITY) |
  611.           (options->V3AuthoritativeDir ? V3_AUTHORITY : NO_AUTHORITY) |
  612.           (options->BridgeAuthoritativeDir ? BRIDGE_AUTHORITY : NO_AUTHORITY) |
  613.           (options->HSAuthoritativeDir ? HIDSERV_AUTHORITY : NO_AUTHORITY));
  615.   ds = router_get_trusteddirserver_by_digest(digest);
  616.   if (!ds) {
  617.     ds = add_trusted_dir_server(options->Nickname, NULL,
  618.                                 (uint16_t)options->DirPort,
  619.                                 (uint16_t)options->ORPort,
  620.                                 digest,
  621.                                 v3_digest,
  622.                                 type);
  623.     if (!ds) {
  624.       log_err(LD_GENERAL,"We want to be a directory authority, but we "
  625.               "couldn't add ourselves to the authority list. Failing.");
  626.       return -1;
  627.     }
  628.   }
  629.   if (ds->type != type) {
  630.     log_warn(LD_DIR,  "Configured authority type does not match authority "
  631.              "type in DirServer list.  Adjusting. (%d v %d)",
  632.              type, ds->type);
  633.     ds->type = type;
  634.   }
  635.   if (v3_digest_set && (ds->type & V3_AUTHORITY) &&
  636.       memcmp(v3_digest, ds->v3_identity_digest, DIGEST_LEN)) {
  637.     log_warn(LD_DIR, "V3 identity key does not match identity declared in "
  638.              "DirServer line.  Adjusting.");
  639.     memcpy(ds->v3_identity_digest, v3_digest, DIGEST_LEN);
  640.   }
  642.   if (cert) { /* add my own cert to the list of known certs */
  643.     log_info(LD_DIR, "adding my own v3 cert");
  644.     if (trusted_dirs_load_certs_from_string(
  645.                       cert->cache_info.signed_descriptor_body, 0, 0)<0) {
  646.       log_warn(LD_DIR, "Unable to parse my own v3 cert! Failing.");
  647.       return -1;
  648.     }
  649.   }
  651.   return 0; /* success */
  652. }
  654. /* Keep track of whether we should upload our server descriptor,
  655.  * and what type of server we are.
  656.  */
  658. /** Whether we can reach our ORPort from the outside. */
  659. static int can_reach_or_port = 0;
  660. /** Whether we can reach our DirPort from the outside. */
  661. static int can_reach_dir_port = 0;
  663. /** Forget what we have learned about our reachability status. */
  664. void
  665. router_reset_reachability(void)
  666. {
  667.   can_reach_or_port = can_reach_dir_port = 0;
  668. }
  670. /** Return 1 if ORPort is known reachable; else return 0. */
  671. int
  672. check_whether_orport_reachable(void)
  673. {
  674.   or_options_t *options = get_options();
  675.   return options->AssumeReachable ||
  676.          can_reach_or_port;
  677. }
  679. /** Return 1 if we don't have a dirport configured, or if it's reachable. */
  680. int
  681. check_whether_dirport_reachable(void)
  682. {
  683.   or_options_t *options = get_options();
  684.   return !options->DirPort ||
  685.          options->AssumeReachable ||
  686.          we_are_hibernating() ||
  687.          can_reach_dir_port;
  688. }
  690. /** Look at a variety of factors, and return 0 if we don't want to
  691.  * advertise the fact that we have a DirPort open. Else return the
  692.  * DirPort we want to advertise.
  693.  *
  694.  * Log a helpful message if we change our mind about whether to publish
  695.  * a DirPort.
  696.  */
  697. static int
  698. decide_to_advertise_dirport(or_options_t *options, uint16_t dir_port)
  699. {
  700.   static int advertising=1; /* start out assuming we will advertise */
  701.   int new_choice=1;
  702.   const char *reason = NULL;
  704.   /* Section one: reasons to publish or not publish that aren't
  705.    * worth mentioning to the user, either because they're obvious
  706.    * or because they're normal behavior. */
  708.   if (!dir_port) /* short circuit the rest of the function */
  709.     return 0;
  710.   if (authdir_mode(options)) /* always publish */
  711.     return dir_port;
  712.   if (we_are_hibernating())
  713.     return 0;
  714.   if (!check_whether_dirport_reachable())
  715.     return 0;
  717.   /* Section two: reasons to publish or not publish that the user
  718.    * might find surprising. These are generally config options that
  719.    * make us choose not to publish. */
  721.   if (accounting_is_enabled(options)) {
  722.     /* if we might potentially hibernate */
  723.     new_choice = 0;
  724.     reason = "AccountingMax enabled";
  725. #define MIN_BW_TO_ADVERTISE_DIRPORT 51200
  726.   } else if (options->BandwidthRate < MIN_BW_TO_ADVERTISE_DIRPORT ||
  727.              (options->RelayBandwidthRate > 0 &&
  728.               options->RelayBandwidthRate < MIN_BW_TO_ADVERTISE_DIRPORT)) {
  729.     /* if we're advertising a small amount */
  730.     new_choice = 0;
  731.     reason = "BandwidthRate under 50KB";
  732.   }
  734.   if (advertising != new_choice) {
  735.     if (new_choice == 1) {
  736.       log(LOG_NOTICE, LD_DIR, "Advertising DirPort as %d", dir_port);
  737.     } else {
  738.       tor_assert(reason);
  739.       log(LOG_NOTICE, LD_DIR, "Not advertising DirPort (Reason: %s)", reason);
  740.     }
  741.     advertising = new_choice;
  742.   }
  744.   return advertising ? dir_port : 0;
  745. }
  747. /** Some time has passed, or we just got new directory information.
  748.  * See if we currently believe our ORPort or DirPort to be
  749.  * unreachable. If so, launch a new test for it.
  750.  *
  751.  * For ORPort, we simply try making a circuit that ends at ourselves.
  752.  * Success is noticed in onionskin_answer().
  753.  *
  754.  * For DirPort, we make a connection via Tor to our DirPort and ask
  755.  * for our own server descriptor.
  756.  * Success is noticed in connection_dir_client_reached_eof().
  757.  */
  758. void
  759. consider_testing_reachability(int test_or, int test_dir)
  760. {
  761.   routerinfo_t *me = router_get_my_routerinfo();
  762.   int orport_reachable = check_whether_orport_reachable();
  763.   tor_addr_t addr;
  764.   if (!me)
  765.     return;
  767.   if (test_or && (!orport_reachable || !circuit_enough_testing_circs())) {
  768.     log_info(LD_CIRC, "Testing %s of my ORPort: %s:%d.",
  769.              !orport_reachable ? "reachability" : "bandwidth",
  770.              me->address, me->or_port);
  771.     circuit_launch_by_router(CIRCUIT_PURPOSE_TESTING, me,
  772.                              CIRCLAUNCH_NEED_CAPACITY|CIRCLAUNCH_IS_INTERNAL);
  773.   }
  775.   tor_addr_from_ipv4h(&addr, me->addr);
  776.   if (test_dir && !check_whether_dirport_reachable() &&
  777.       !connection_get_by_type_addr_port_purpose(
  778.                 CONN_TYPE_DIR, &addr, me->dir_port,
  779.                 DIR_PURPOSE_FETCH_SERVERDESC)) {
  780.     /* ask myself, via tor, for my server descriptor. */
  781.     directory_initiate_command(me->address, &addr,
  782.                                me->or_port, me->dir_port,
  783.                                0, /* does not matter */
  784.                                0, me->cache_info.identity_digest,
  785.                                DIR_PURPOSE_FETCH_SERVERDESC,
  786.                                ROUTER_PURPOSE_GENERAL,
  787.                                1, "authority.z", NULL, 0, 0);
  788.   }
  789. }
  791. /** Annotate that we found our ORPort reachable. */
  792. void
  793. router_orport_found_reachable(void)
  794. {
  795.   if (!can_reach_or_port) {
  796.     routerinfo_t *me = router_get_my_routerinfo();
  797.     log_notice(LD_OR,"Self-testing indicates your ORPort is reachable from "
  798.                "the outside. Excellent.%s",
  799.                get_options()->_PublishServerDescriptor != NO_AUTHORITY ?
  800.                  " Publishing server descriptor." : "");
  801.     can_reach_or_port = 1;
  802.     mark_my_descriptor_dirty();
  803.     if (!me) { /* should never happen */
  804.       log_warn(LD_BUG, "ORPort found reachable, but I have no routerinfo "
  805.                "yet. Failing to inform controller of success.");
  806.       return;
  807.     }
  808.     control_event_server_status(LOG_NOTICE,
  809.                                 "REACHABILITY_SUCCEEDED ORADDRESS=%s:%d",
  810.                                 me->address, me->or_port);
  811.   }
  812. }
  814. /** Annotate that we found our DirPort reachable. */
  815. void
  816. router_dirport_found_reachable(void)
  817. {
  818.   if (!can_reach_dir_port) {
  819.     routerinfo_t *me = router_get_my_routerinfo();
  820.     log_notice(LD_DIRSERV,"Self-testing indicates your DirPort is reachable "
  821.                "from the outside. Excellent.");
  822.     can_reach_dir_port = 1;
  823.     if (!me || decide_to_advertise_dirport(get_options(), me->dir_port))
  824.       mark_my_descriptor_dirty();
  825.     if (!me) { /* should never happen */
  826.       log_warn(LD_BUG, "DirPort found reachable, but I have no routerinfo "
  827.                "yet. Failing to inform controller of success.");
  828.       return;
  829.     }
  830.     control_event_server_status(LOG_NOTICE,
  831.                                 "REACHABILITY_SUCCEEDED DIRADDRESS=%s:%d",
  832.                                 me->address, me->dir_port);
  833.   }
  834. }
  836. /** We have enough testing circuits open. Send a bunch of "drop"
  837.  * cells down each of them, to exercise our bandwidth. */
  838. void
  839. router_perform_bandwidth_test(int num_circs, time_t now)
  840. {
  841.   int num_cells = (int)(get_options()->BandwidthRate * 10 / CELL_NETWORK_SIZE);
  842.   int max_cells = num_cells < CIRCWINDOW_START ?
  843.                     num_cells : CIRCWINDOW_START;
  844.   int cells_per_circuit = max_cells / num_circs;
  845.   origin_circuit_t *circ = NULL;
  847.   log_notice(LD_OR,"Performing bandwidth self-test...done.");
  848.   while ((circ = circuit_get_next_by_pk_and_purpose(circ, NULL,
  849.                                               CIRCUIT_PURPOSE_TESTING))) {
  850.     /* dump cells_per_circuit drop cells onto this circ */
  851.     int i = cells_per_circuit;
  852.     if (circ->_base.state != CIRCUIT_STATE_OPEN)
  853.       continue;
  854.     circ->_base.timestamp_dirty = now;
  855.     while (i-- > 0) {
  856.       if (relay_send_command_from_edge(0, TO_CIRCUIT(circ),
  857.                                        RELAY_COMMAND_DROP,
  858.                                        NULL, 0, circ->cpath->prev)<0) {
  859.         return; /* stop if error */
  860.       }
  861.     }
  862.   }
  863. }
  865. /** Return true iff we believe ourselves to be an authoritative
  866.  * directory server.
  867.  */
  868. int
  869. authdir_mode(or_options_t *options)
  870. {
  871.   return options->AuthoritativeDir != 0;
  872. }
  873. /** Return true iff we believe ourselves to be a v1 authoritative
  874.  * directory server.
  875.  */
  876. int
  877. authdir_mode_v1(or_options_t *options)
  878. {
  879.   return authdir_mode(options) && options->V1AuthoritativeDir != 0;
  880. }
  881. /** Return true iff we believe ourselves to be a v2 authoritative
  882.  * directory server.
  883.  */
  884. int
  885. authdir_mode_v2(or_options_t *options)
  886. {
  887.   return authdir_mode(options) && options->V2AuthoritativeDir != 0;
  888. }
  889. /** Return true iff we believe ourselves to be a v3 authoritative
  890.  * directory server.
  891.  */
  892. int
  893. authdir_mode_v3(or_options_t *options)
  894. {
  895.   return authdir_mode(options) && options->V3AuthoritativeDir != 0;
  896. }
  897. /** Return true iff we are a v1, v2, or v3 directory authority. */
  898. int
  899. authdir_mode_any_main(or_options_t *options)
  900. {
  901.   return options->V1AuthoritativeDir ||
  902.          options->V2AuthoritativeDir ||
  903.          options->V3AuthoritativeDir;
  904. }
  905. /** Return true if we believe ourselves to be any kind of
  906.  * authoritative directory beyond just a hidserv authority. */
  907. int
  908. authdir_mode_any_nonhidserv(or_options_t *options)
  909. {
  910.   return options->BridgeAuthoritativeDir ||
  911.          authdir_mode_any_main(options);
  912. }
  913. /** Return true iff we are an authoritative directory server that is
  914.  * authoritative about receiving and serving descriptors of type
  915.  * <b>purpose</b> its dirport.  Use -1 for "any purpose". */
  916. int
  917. authdir_mode_handles_descs(or_options_t *options, int purpose)
  918. {
  919.   if (purpose < 0)
  920.     return authdir_mode_any_nonhidserv(options);
  921.   else if (purpose == ROUTER_PURPOSE_GENERAL)
  922.     return authdir_mode_any_main(options);
  923.   else if (purpose == ROUTER_PURPOSE_BRIDGE)
  924.     return (options->BridgeAuthoritativeDir);
  925.   else
  926.     return 0;
  927. }
  928. /** Return true iff we are an authoritative directory server that
  929.  * publishes its own network statuses.
  930.  */
  931. int
  932. authdir_mode_publishes_statuses(or_options_t *options)
  933. {
  934.   if (authdir_mode_bridge(options))
  935.     return 0;
  936.   return authdir_mode_any_nonhidserv(options);
  937. }
  938. /** Return true iff we are an authoritative directory server that
  939.  * tests reachability of the descriptors it learns about.
  940.  */
  941. int
  942. authdir_mode_tests_reachability(or_options_t *options)
  943. {
  944.   return authdir_mode_handles_descs(options, -1);
  945. }
  946. /** Return true iff we believe ourselves to be a bridge authoritative
  947.  * directory server.
  948.  */
  949. int
  950. authdir_mode_bridge(or_options_t *options)
  951. {
  952.   return authdir_mode(options) && options->BridgeAuthoritativeDir != 0;
  953. }
  954. /** Return true iff we once tried to stay connected to all ORs at once.
  955.  * FFFF this function, and the notion of staying connected to ORs, is
  956.  * nearly obsolete. One day there will be a proposal for getting rid of
  957.  * it.
  958.  */
  959. int
  960. clique_mode(or_options_t *options)
  961. {
  962.   return authdir_mode_tests_reachability(options);
  963. }
  965. /** Return true iff we are trying to be a server.
  966.  */
  967. int
  968. server_mode(or_options_t *options)
  969. {
  970.   if (options->ClientOnly) return 0;
  971.   return (options->ORPort != 0 || options->ORListenAddress);
  972. }
  974. /** Remember if we've advertised ourselves to the dirservers. */
  975. static int server_is_advertised=0;
  977. /** Return true iff we have published our descriptor lately.
  978.  */
  979. int
  980. advertised_server_mode(void)
  981. {
  982.   return server_is_advertised;
  983. }
  985. /**
  986.  * Called with a boolean: set whether we have recently published our
  987.  * descriptor.
  988.  */
  989. static void
  990. set_server_advertised(int s)
  991. {
  992.   server_is_advertised = s;
  993. }
  995. /** Return true iff we are trying to be a socks proxy. */
  996. int
  997. proxy_mode(or_options_t *options)
  998. {
  999.   return (options->SocksPort != 0 || options->SocksListenAddress ||
  1000.           options->TransPort != 0 || options->TransListenAddress ||
  1001.           options->NatdPort != 0 || options->NatdListenAddress ||
  1002.           options->DNSPort != 0 || options->DNSListenAddress);
  1003. }
  1005. /** Decide if we're a publishable server. We are a publishable server if:
  1006.  * - We don't have the ClientOnly option set
  1007.  * and
  1008.  * - We have the PublishServerDescriptor option set to non-empty
  1009.  * and
  1010.  * - We have ORPort set
  1011.  * and
  1012.  * - We believe we are reachable from the outside; or
  1013.  * - We are an authoritative directory server.
  1014.  */
  1015. static int
  1016. decide_if_publishable_server(void)
  1017. {
  1018.   or_options_t *options = get_options();
  1020.   if (options->ClientOnly)
  1021.     return 0;
  1022.   if (options->_PublishServerDescriptor == NO_AUTHORITY)
  1023.     return 0;
  1024.   if (!server_mode(options))
  1025.     return 0;
  1026.   if (authdir_mode(options))
  1027.     return 1;
  1029.   return check_whether_orport_reachable();
  1030. }
  1032. /** Initiate server descriptor upload as reasonable (if server is publishable,
  1033.  * etc).  <b>force</b> is as for router_upload_dir_desc_to_dirservers.
  1034.  *
  1035.  * We need to rebuild the descriptor if it's dirty even if we're not
  1036.  * uploading, because our reachability testing *uses* our descriptor to
  1037.  * determine what IP address and ports to test.
  1038.  */
  1039. void
  1040. consider_publishable_server(int force)
  1041. {
  1042.   int rebuilt;
  1044.   if (!server_mode(get_options()))
  1045.     return;
  1047.   rebuilt = router_rebuild_descriptor(0);
  1048.   if (decide_if_publishable_server()) {
  1049.     set_server_advertised(1);
  1050.     if (rebuilt == 0)
  1051.       router_upload_dir_desc_to_dirservers(force);
  1052.   } else {
  1053.     set_server_advertised(0);
  1054.   }
  1055. }
  1057. /*
  1058.  * Clique maintenance -- to be phased out.
  1059.  */
  1061. /** Return true iff we believe this OR tries to keep connections open
  1062.  * to all other ORs. */
  1063. int
  1064. router_is_clique_mode(routerinfo_t *router)
  1065. {
  1066.   if (router_digest_is_trusted_dir(router->cache_info.identity_digest))
  1067.     return 1;
  1068.   return 0;
  1069. }
  1071. /*
  1072.  * OR descriptor generation.
  1073.  */
  1075. /** My routerinfo. */
  1076. static routerinfo_t *desc_routerinfo = NULL;
  1077. /** My extrainfo */
  1078. static extrainfo_t *desc_extrainfo = NULL;
  1079. /** Since when has our descriptor been "clean"?  0 if we need to regenerate it
  1080.  * now. */
  1081. static time_t desc_clean_since = 0;
  1082. /** Boolean: do we need to regenerate the above? */
  1083. static int desc_needs_upload = 0;
  1085. /** OR only: If <b>force</b> is true, or we haven't uploaded this
  1086.  * descriptor successfully yet, try to upload our signed descriptor to
  1087.  * all the directory servers we know about.
  1088.  */
  1089. void
  1090. router_upload_dir_desc_to_dirservers(int force)
  1091. {
  1092.   routerinfo_t *ri;
  1093.   extrainfo_t *ei;
  1094.   char *msg;
  1095.   size_t desc_len, extra_len = 0, total_len;
  1096.   authority_type_t auth = get_options()->_PublishServerDescriptor;
  1098.   ri = router_get_my_routerinfo();
  1099.   if (!ri) {
  1100.     log_info(LD_GENERAL, "No descriptor; skipping upload");
  1101.     return;
  1102.   }
  1103.   ei = router_get_my_extrainfo();
  1104.   if (auth == NO_AUTHORITY)
  1105.     return;
  1106.   if (!force && !desc_needs_upload)
  1107.     return;
  1108.   desc_needs_upload = 0;
  1110.   desc_len = ri->cache_info.signed_descriptor_len;
  1111.   extra_len = ei ? ei->cache_info.signed_descriptor_len : 0;
  1112.   total_len = desc_len + extra_len + 1;
  1113.   msg = tor_malloc(total_len);
  1114.   memcpy(msg, ri->cache_info.signed_descriptor_body, desc_len);
  1115.   if (ei) {
  1116.     memcpy(msg+desc_len, ei->cache_info.signed_descriptor_body, extra_len);
  1117.   }
  1118.   msg[desc_len+extra_len] = 0;
  1120.   directory_post_to_dirservers(DIR_PURPOSE_UPLOAD_DIR,
  1121.                                (auth & BRIDGE_AUTHORITY) ?
  1122.                                  ROUTER_PURPOSE_BRIDGE :
  1123.                                  ROUTER_PURPOSE_GENERAL,
  1124.                                auth, msg, desc_len, extra_len);
  1125.   tor_free(msg);
  1126. }
  1128. /** OR only: Check whether my exit policy says to allow connection to
  1129.  * conn.  Return 0 if we accept; non-0 if we reject.
  1130.  */
  1131. int
  1132. router_compare_to_my_exit_policy(edge_connection_t *conn)
  1133. {
  1134.   if (!router_get_my_routerinfo()) /* make sure desc_routerinfo exists */
  1135.     return -1;
  1137.   /* make sure it's resolved to something. this way we can't get a
  1138.      'maybe' below. */
  1139.   if (tor_addr_is_null(&conn->_base.addr))
  1140.     return -1;
  1142.   /* XXXX IPv6 */
  1143.   if (tor_addr_family(&conn->_base.addr) != AF_INET)
  1144.     return -1;
  1146.   return compare_tor_addr_to_addr_policy(&conn->_base.addr, conn->_base.port,
  1147.                    desc_routerinfo->exit_policy) != ADDR_POLICY_ACCEPTED;
  1148. }
  1150. /** Return true iff I'm a server and <b>digest</b> is equal to
  1151.  * my identity digest. */
  1152. int
  1153. router_digest_is_me(const char *digest)
  1154. {
  1155.   return identitykey && !memcmp(identitykey_digest, digest, DIGEST_LEN);
  1156. }
  1158. /** Return true iff I'm a server and <b>digest</b> is equal to
  1159.  * my identity digest. */
  1160. int
  1161. router_extrainfo_digest_is_me(const char *digest)
  1162. {
  1163.   extrainfo_t *ei = router_get_my_extrainfo();
  1164.   if (!ei)
  1165.     return 0;
  1167.   return !memcmp(digest,
  1168.                  ei->cache_info.signed_descriptor_digest,
  1169.                  DIGEST_LEN);
  1170. }
  1172. /** A wrapper around router_digest_is_me(). */
  1173. int
  1174. router_is_me(routerinfo_t *router)
  1175. {
  1176.   return router_digest_is_me(router->cache_info.identity_digest);
  1177. }
  1179. /** Return true iff <b>fp</b> is a hex fingerprint of my identity digest. */
  1180. int
  1181. router_fingerprint_is_me(const char *fp)
  1182. {
  1183.   char digest[DIGEST_LEN];
  1184.   if (strlen(fp) == HEX_DIGEST_LEN &&
  1185.       base16_decode(digest, sizeof(digest), fp, HEX_DIGEST_LEN) == 0)
  1186.     return router_digest_is_me(digest);
  1188.   return 0;
  1189. }
  1191. /** Return a routerinfo for this OR, rebuilding a fresh one if
  1192.  * necessary.  Return NULL on error, or if called on an OP. */
  1193. routerinfo_t *
  1194. router_get_my_routerinfo(void)
  1195. {
  1196.   if (!server_mode(get_options()))
  1197.     return NULL;
  1198.   if (router_rebuild_descriptor(0))
  1199.     return NULL;
  1200.   return desc_routerinfo;
  1201. }
  1203. /** OR only: Return a signed server descriptor for this OR, rebuilding a fresh
  1204.  * one if necessary.  Return NULL on error.
  1205.  */
  1206. const char *
  1207. router_get_my_descriptor(void)
  1208. {
  1209.   const char *body;
  1210.   if (!router_get_my_routerinfo())
  1211.     return NULL;
  1212.   /* Make sure this is nul-terminated. */
  1213.   tor_assert(desc_routerinfo->cache_info.saved_location == SAVED_NOWHERE);
  1214.   body = signed_descriptor_get_body(&desc_routerinfo->cache_info);
  1215.   tor_assert(!body[desc_routerinfo->cache_info.signed_descriptor_len]);
  1216.   log_debug(LD_GENERAL,"my desc is '%s'", body);
  1217.   return body;
  1218. }
  1220. /** Return the extrainfo document for this OR, or NULL if we have none.
  1221.  * Rebuilt it (and the server descriptor) if necessary. */
  1222. extrainfo_t *
  1223. router_get_my_extrainfo(void)
  1224. {
  1225.   if (!server_mode(get_options()))
  1226.     return NULL;
  1227.   if (router_rebuild_descriptor(0))
  1228.     return NULL;
  1229.   return desc_extrainfo;
  1230. }
  1232. /** A list of nicknames that we've warned about including in our family
  1233.  * declaration verbatim rather than as digests. */
  1234. static smartlist_t *warned_nonexistent_family = NULL;
  1236. static int router_guess_address_from_dir_headers(uint32_t *guess);
  1238. /** Make a current best guess at our address, either because
  1239.  * it's configured in torrc, or because we've learned it from
  1240.  * dirserver headers. Place the answer in *<b>addr</b> and return
  1241.  * 0 on success, else return -1 if we have no guess. */
  1242. int
  1243. router_pick_published_address(or_options_t *options, uint32_t *addr)
  1244. {
  1245.   if (resolve_my_address(LOG_INFO, options, addr, NULL) < 0) {
  1246.     log_info(LD_CONFIG, "Could not determine our address locally. "
  1247.              "Checking if directory headers provide any hints.");
  1248.     if (router_guess_address_from_dir_headers(addr) < 0) {
  1249.       log_info(LD_CONFIG, "No hints from directory headers either. "
  1250.                "Will try again later.");
  1251.       return -1;
  1252.     }
  1253.   }
  1254.   return 0;
  1255. }
  1257. /** If <b>force</b> is true, or our descriptor is out-of-date, rebuild a fresh
  1258.  * routerinfo, signed server descriptor, and extra-info document for this OR.
  1259.  * Return 0 on success, -1 on temporary error.
  1260.  */
  1261. int
  1262. router_rebuild_descriptor(int force)
  1263. {
  1264.   routerinfo_t *ri;
  1265.   extrainfo_t *ei;
  1266.   uint32_t addr;
  1267.   char platform[256];
  1268.   int hibernating = we_are_hibernating();
  1269.   or_options_t *options = get_options();
  1271.   if (desc_clean_since && !force)
  1272.     return 0;
  1274.   if (router_pick_published_address(options, &addr) < 0) {
  1275.     /* Stop trying to rebuild our descriptor every second. We'll
  1276.      * learn that it's time to try again when server_has_changed_ip()
  1277.      * marks it dirty. */
  1278.     desc_clean_since = time(NULL);
  1279.     return -1;
  1280.   }
  1282.   ri = tor_malloc_zero(sizeof(routerinfo_t));
  1283.   ri->cache_info.routerlist_index = -1;
  1284.   ri->address = tor_dup_ip(addr);
  1285.   ri->nickname = tor_strdup(options->Nickname);
  1286.   ri->addr = addr;
  1287.   ri->or_port = options->ORPort;
  1288.   ri->dir_port = options->DirPort;
  1289.   ri->cache_info.published_on = time(NULL);
  1290.   ri->onion_pkey = crypto_pk_dup_key(get_onion_key()); /* must invoke from
  1291.                                                         * main thread */
  1292.   ri->identity_pkey = crypto_pk_dup_key(get_identity_key());
  1293.   if (crypto_pk_get_digest(ri->identity_pkey,
  1294.                            ri->cache_info.identity_digest)<0) {
  1295.     routerinfo_free(ri);
  1296.     return -1;
  1297.   }
  1298.   get_platform_str(platform, sizeof(platform));
  1299.   ri->platform = tor_strdup(platform);
  1301.   /* compute ri->bandwidthrate as the min of various options */
  1302.   ri->bandwidthrate = get_effective_bwrate(options);
  1304.   /* and compute ri->bandwidthburst similarly */
  1305.   ri->bandwidthburst = get_effective_bwburst(options);
  1307.   ri->bandwidthcapacity = hibernating ? 0 : rep_hist_bandwidth_assess();
  1309.   policies_parse_exit_policy(options->ExitPolicy, &ri->exit_policy,
  1310.                              options->ExitPolicyRejectPrivate,
  1311.                              ri->address);
  1313.   if (desc_routerinfo) { /* inherit values */
  1314.     ri->is_valid = desc_routerinfo->is_valid;
  1315.     ri->is_running = desc_routerinfo->is_running;
  1316.     ri->is_named = desc_routerinfo->is_named;
  1317.   }
  1318.   if (authdir_mode(options))
  1319.     ri->is_valid = ri->is_named = 1; /* believe in yourself */
  1320.   if (options->MyFamily) {
  1321.     smartlist_t *family;
  1322.     if (!warned_nonexistent_family)
  1323.       warned_nonexistent_family = smartlist_create();
  1324.     family = smartlist_create();
  1325.     ri->declared_family = smartlist_create();
  1326.     smartlist_split_string(family, options->MyFamily, ",",
  1327.       SPLIT_SKIP_SPACE|SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0);
  1328.     SMARTLIST_FOREACH(family, char *, name,
  1329.      {
  1330.        routerinfo_t *member;
  1331.        if (!strcasecmp(name, options->Nickname))
  1332.          member = ri;
  1333.        else
  1334.          member = router_get_by_nickname(name, 1);
  1335.        if (!member) {
  1336.          int is_legal = is_legal_nickname_or_hexdigest(name);
  1337.          if (!smartlist_string_isin(warned_nonexistent_family, name) &&
  1338.              !is_legal_hexdigest(name)) {
  1339.            if (is_legal)
  1340.              log_warn(LD_CONFIG,
  1341.                       "I have no descriptor for the router named "%s" in my "
  1342.                       "declared family; I'll use the nickname as is, but "
  1343.                       "this may confuse clients.", name);
  1344.            else
  1345.              log_warn(LD_CONFIG, "There is a router named "%s" in my "
  1346.                       "declared family, but that isn't a legal nickname. "
  1347.                       "Skipping it.", escaped(name));
  1348.            smartlist_add(warned_nonexistent_family, tor_strdup(name));
  1349.          }
  1350.          if (is_legal) {
  1351.            smartlist_add(ri->declared_family, name);
  1352.            name = NULL;
  1353.          }
  1354.        } else if (router_is_me(member)) {
  1355.          /* Don't list ourself in our own family; that's redundant */
  1356.        } else {
  1357.          char *fp = tor_malloc(HEX_DIGEST_LEN+2);
  1358.          fp[0] = '$';
  1359.          base16_encode(fp+1,HEX_DIGEST_LEN+1,
  1360.                        member->cache_info.identity_digest, DIGEST_LEN);
  1361.          smartlist_add(ri->declared_family, fp);
  1362.          if (smartlist_string_isin(warned_nonexistent_family, name))
  1363.            smartlist_string_remove(warned_nonexistent_family, name);
  1364.        }
  1365.        tor_free(name);
  1366.      });
  1368.     /* remove duplicates from the list */
  1369.     smartlist_sort_strings(ri->declared_family);
  1370.     smartlist_uniq_strings(ri->declared_family);
  1372.     smartlist_free(family);
  1373.   }
  1375.   /* Now generate the extrainfo. */
  1376.   ei = tor_malloc_zero(sizeof(extrainfo_t));
  1377.   ei->cache_info.is_extrainfo = 1;
  1378.   strlcpy(ei->nickname, get_options()->Nickname, sizeof(ei->nickname));
  1379.   ei->cache_info.published_on = ri->cache_info.published_on;
  1380.   memcpy(ei->cache_info.identity_digest, ri->cache_info.identity_digest,
  1381.          DIGEST_LEN);
  1382.   ei->cache_info.signed_descriptor_body = tor_malloc(8192);
  1383.   if (extrainfo_dump_to_string(ei->cache_info.signed_descriptor_body, 8192,
  1384.                                ei, get_identity_key()) < 0) {
  1385.     log_warn(LD_BUG, "Couldn't generate extra-info descriptor.");
  1386.     extrainfo_free(ei);
  1387.     return -1;
  1388.   }
  1389.   ei->cache_info.signed_descriptor_len =
  1390.     strlen(ei->cache_info.signed_descriptor_body);
  1391.   router_get_extrainfo_hash(ei->cache_info.signed_descriptor_body,
  1392.                             ei->cache_info.signed_descriptor_digest);
  1394.   /* Now finish the router descriptor. */
  1395.   memcpy(ri->cache_info.extra_info_digest,
  1396.          ei->cache_info.signed_descriptor_digest,
  1397.          DIGEST_LEN);
  1398.   ri->cache_info.signed_descriptor_body = tor_malloc(8192);
  1399.   if (router_dump_router_to_string(ri->cache_info.signed_descriptor_body, 8192,
  1400.                                    ri, get_identity_key())<0) {
  1401.     log_warn(LD_BUG, "Couldn't generate router descriptor.");
  1402.     return -1;
  1403.   }
  1404.   ri->cache_info.signed_descriptor_len =
  1405.     strlen(ri->cache_info.signed_descriptor_body);
  1407.   ri->purpose =
  1408.     options->BridgeRelay ? ROUTER_PURPOSE_BRIDGE : ROUTER_PURPOSE_GENERAL;
  1409.   ri->cache_info.send_unencrypted = 1;
  1410.   /* Let bridges serve their own descriptors unencrypted, so they can
  1411.    * pass reachability testing. (If they want to be harder to notice,
  1412.    * they can always leave the DirPort off). */
  1413.   if (!options->BridgeRelay)
  1414.     ei->cache_info.send_unencrypted = 1;
  1416.   router_get_router_hash(ri->cache_info.signed_descriptor_body,
  1417.                          ri->cache_info.signed_descriptor_digest);
  1419.   routerinfo_set_country(ri);
  1421.   tor_assert(! routerinfo_incompatible_with_extrainfo(ri, ei, NULL, NULL));
  1423.   if (desc_routerinfo)
  1424.     routerinfo_free(desc_routerinfo);
  1425.   desc_routerinfo = ri;
  1426.   if (desc_extrainfo)
  1427.     extrainfo_free(desc_extrainfo);
  1428.   desc_extrainfo = ei;
  1430.   desc_clean_since = time(NULL);
  1431.   desc_needs_upload = 1;
  1432.   control_event_my_descriptor_changed();
  1433.   return 0;
  1434. }
  1436. /** Mark descriptor out of date if it's older than <b>when</b> */
  1437. void
  1438. mark_my_descriptor_dirty_if_older_than(time_t when)
  1439. {
  1440.   if (desc_clean_since < when)
  1441.     mark_my_descriptor_dirty();
  1442. }
  1444. /** Call when the current descriptor is out of date. */
  1445. void
  1446. mark_my_descriptor_dirty(void)
  1447. {
  1448.   desc_clean_since = 0;
  1449. }
  1451. /** How frequently will we republish our descriptor because of large (factor
  1452.  * of 2) shifts in estimated bandwidth? */
  1453. #define MAX_BANDWIDTH_CHANGE_FREQ (20*60)
  1455. /** Check whether bandwidth has changed a lot since the last time we announced
  1456.  * bandwidth. If so, mark our descriptor dirty. */
  1457. void
  1458. check_descriptor_bandwidth_changed(time_t now)
  1459. {
  1460.   static time_t last_changed = 0;
  1461.   uint64_t prev, cur;
  1462.   if (!desc_routerinfo)
  1463.     return;
  1465.   prev = desc_routerinfo->bandwidthcapacity;
  1466.   cur = we_are_hibernating() ? 0 : rep_hist_bandwidth_assess();
  1467.   if ((prev != cur && (!prev || !cur)) ||
  1468.       cur > prev*2 ||
  1469.       cur < prev/2) {
  1470.     if (last_changed+MAX_BANDWIDTH_CHANGE_FREQ < now) {
  1471.       log_info(LD_GENERAL,
  1472.                "Measured bandwidth has changed; rebuilding descriptor.");
  1473.       mark_my_descriptor_dirty();
  1474.       last_changed = now;
  1475.     }
  1476.   }
  1477. }
  1479. /** Note at log level severity that our best guess of address has changed from
  1480.  * <b>prev</b> to <b>cur</b>. */
  1481. static void
  1482. log_addr_has_changed(int severity, uint32_t prev, uint32_t cur,
  1483.                      const char *source)
  1484. {
  1485.   char addrbuf_prev[INET_NTOA_BUF_LEN];
  1486.   char addrbuf_cur[INET_NTOA_BUF_LEN];
  1487.   struct in_addr in_prev;
  1488.   struct in_addr in_cur;
  1490.   in_prev.s_addr = htonl(prev);
  1491.   tor_inet_ntoa(&in_prev, addrbuf_prev, sizeof(addrbuf_prev));
  1493.   in_cur.s_addr = htonl(cur);
  1494.   tor_inet_ntoa(&in_cur, addrbuf_cur, sizeof(addrbuf_cur));
  1496.   if (prev)
  1497.     log_fn(severity, LD_GENERAL,
  1498.            "Our IP Address has changed from %s to %s; "
  1499.            "rebuilding descriptor (source: %s).",
  1500.            addrbuf_prev, addrbuf_cur, source);
  1501.   else
  1502.     log_notice(LD_GENERAL,
  1503.              "Guessed our IP address as %s (source: %s).",
  1504.              addrbuf_cur, source);
  1505. }
  1507. /** Check whether our own address as defined by the Address configuration
  1508.  * has changed. This is for routers that get their address from a service
  1509.  * like dyndns. If our address has changed, mark our descriptor dirty. */
  1510. void
  1511. check_descriptor_ipaddress_changed(time_t now)
  1512. {
  1513.   uint32_t prev, cur;
  1514.   or_options_t *options = get_options();
  1515.   (void) now;
  1517.   if (!desc_routerinfo)
  1518.     return;
  1520.   prev = desc_routerinfo->addr;
  1521.   if (resolve_my_address(LOG_INFO, options, &cur, NULL) < 0) {
  1522.     log_info(LD_CONFIG,"options->Address didn't resolve into an IP.");
  1523.     return;
  1524.   }
  1526.   if (prev != cur) {
  1527.     log_addr_has_changed(LOG_NOTICE, prev, cur, "resolve");
  1528.     ip_address_changed(0);
  1529.   }
  1530. }
  1532. /** The most recently guessed value of our IP address, based on directory
  1533.  * headers. */
  1534. static uint32_t last_guessed_ip = 0;
  1536. /** A directory server <b>d_conn</b> told us our IP address is
  1537.  * <b>suggestion</b>.
  1538.  * If this address is different from the one we think we are now, and
  1539.  * if our computer doesn't actually know its IP address, then switch. */
  1540. void
  1541. router_new_address_suggestion(const char *suggestion,
  1542.                               const dir_connection_t *d_conn)
  1543. {
  1544.   uint32_t addr, cur = 0;
  1545.   struct in_addr in;
  1546.   or_options_t *options = get_options();
  1548.   /* first, learn what the IP address actually is */
  1549.   if (!tor_inet_aton(suggestion, &in)) {
  1550.     log_debug(LD_DIR, "Malformed X-Your-Address-Is header %s. Ignoring.",
  1551.               escaped(suggestion));
  1552.     return;
  1553.   }
  1554.   addr = ntohl(in.s_addr);
  1556.   log_debug(LD_DIR, "Got X-Your-Address-Is: %s.", suggestion);
  1558.   if (!server_mode(options)) {
  1559.     last_guessed_ip = addr; /* store it in case we need it later */
  1560.     return;
  1561.   }
  1563.   if (resolve_my_address(LOG_INFO, options, &cur, NULL) >= 0) {
  1564.     /* We're all set -- we already know our address. Great. */
  1565.     last_guessed_ip = cur; /* store it in case we need it later */
  1566.     return;
  1567.   }
  1568.   if (is_internal_IP(addr, 0)) {
  1569.     /* Don't believe anybody who says our IP is, say, 127.0.0.1. */
  1570.     return;
  1571.   }
  1572.   if (tor_addr_eq_ipv4h(&d_conn->_base.addr, addr)) {
  1573.     /* Don't believe anybody who says our IP is their IP. */
  1574.     log_debug(LD_DIR, "A directory server told us our IP address is %s, "
  1575.               "but he's just reporting his own IP address. Ignoring.",
  1576.               suggestion);
  1577.     return;
  1578.   }
  1580.   /* Okay.  We can't resolve our own address, and X-Your-Address-Is is giving
  1581.    * us an answer different from what we had the last time we managed to
  1582.    * resolve it. */
  1583.   if (last_guessed_ip != addr) {
  1584.     control_event_server_status(LOG_NOTICE,
  1585.                                 "EXTERNAL_ADDRESS ADDRESS=%s METHOD=DIRSERV",
  1586.                                 suggestion);
  1587.     log_addr_has_changed(LOG_NOTICE, last_guessed_ip, addr,
  1588.                          d_conn->_base.address);
  1589.     ip_address_changed(0);
  1590.     last_guessed_ip = addr; /* router_rebuild_descriptor() will fetch it */
  1591.   }
  1592. }
  1594. /** We failed to resolve our address locally, but we'd like to build
  1595.  * a descriptor and publish / test reachability. If we have a guess
  1596.  * about our address based on directory headers, answer it and return
  1597.  * 0; else return -1. */
  1598. static int
  1599. router_guess_address_from_dir_headers(uint32_t *guess)
  1600. {
  1601.   if (last_guessed_ip) {
  1602.     *guess = last_guessed_ip;
  1603.     return 0;
  1604.   }
  1605.   return -1;
  1606. }
  1608. extern const char tor_svn_revision[]; /* from tor_main.c */
  1610. /** Set <b>platform</b> (max length <b>len</b>) to a NUL-terminated short
  1611.  * string describing the version of Tor and the operating system we're
  1612.  * currently running on.
  1613.  */
  1614. void
  1615. get_platform_str(char *platform, size_t len)
  1616. {
  1617.   tor_snprintf(platform, len, "Tor %s on %s", get_version(), get_uname());
  1618. }
  1620. /* XXX need to audit this thing and count fenceposts. maybe
  1621.  *     refactor so we don't have to keep asking if we're
  1622.  *     near the end of maxlen?
  1623.  */
  1624. #define DEBUG_ROUTER_DUMP_ROUTER_TO_STRING
  1626. /** OR only: Given a routerinfo for this router, and an identity key to sign
  1627.  * with, encode the routerinfo as a signed server descriptor and write the
  1628.  * result into <b>s</b>, using at most <b>maxlen</b> bytes.  Return -1 on
  1629.  * failure, and the number of bytes used on success.
  1630.  */
  1631. int
  1632. router_dump_router_to_string(char *s, size_t maxlen, routerinfo_t *router,
  1633.                              crypto_pk_env_t *ident_key)
  1634. {
  1635.   char *onion_pkey; /* Onion key, PEM-encoded. */
  1636.   char *identity_pkey; /* Identity key, PEM-encoded. */
  1637.   char digest[DIGEST_LEN];
  1638.   char published[ISO_TIME_LEN+1];
  1639.   char fingerprint[FINGERPRINT_LEN+1];
  1640.   char extra_info_digest[HEX_DIGEST_LEN+1];
  1641.   size_t onion_pkeylen, identity_pkeylen;
  1642.   size_t written;
  1643.   int result=0;
  1644.   addr_policy_t *tmpe;
  1645.   char *family_line;
  1646.   or_options_t *options = get_options();
  1648.   /* Make sure the identity key matches the one in the routerinfo. */
  1649.   if (crypto_pk_cmp_keys(ident_key, router->identity_pkey)) {
  1650.     log_warn(LD_BUG,"Tried to sign a router with a private key that didn't "
  1651.              "match router's public key!");
  1652.     return -1;
  1653.   }
  1655.   /* record our fingerprint, so we can include it in the descriptor */
  1656.   if (crypto_pk_get_fingerprint(router->identity_pkey, fingerprint, 1)<0) {
  1657.     log_err(LD_BUG,"Error computing fingerprint");
  1658.     return -1;
  1659.   }
  1661.   /* PEM-encode the onion key */
  1662.   if (crypto_pk_write_public_key_to_string(router->onion_pkey,
  1663.                                            &onion_pkey,&onion_pkeylen)<0) {
  1664.     log_warn(LD_BUG,"write onion_pkey to string failed!");
  1665.     return -1;
  1666.   }
  1668.   /* PEM-encode the identity key key */
  1669.   if (crypto_pk_write_public_key_to_string(router->identity_pkey,
  1670.                                         &identity_pkey,&identity_pkeylen)<0) {
  1671.     log_warn(LD_BUG,"write identity_pkey to string failed!");
  1672.     tor_free(onion_pkey);
  1673.     return -1;
  1674.   }
  1676.   /* Encode the publication time. */
  1677.   format_iso_time(published, router->cache_info.published_on);
  1679.   if (router->declared_family && smartlist_len(router->declared_family)) {
  1680.     size_t n;
  1681.     char *family = smartlist_join_strings(router->declared_family, " ", 0, &n);
  1682.     n += strlen("family ") + 2; /* 1 for n, 1 for . */
  1683.     family_line = tor_malloc(n);
  1684.     tor_snprintf(family_line, n, "family %sn", family);
  1685.     tor_free(family);
  1686.   } else {
  1687.     family_line = tor_strdup("");
  1688.   }
  1690.   base16_encode(extra_info_digest, sizeof(extra_info_digest),
  1691.                 router->cache_info.extra_info_digest, DIGEST_LEN);
  1693.   /* Generate the easy portion of the router descriptor. */
  1694.   result = tor_snprintf(s, maxlen,
  1695.                     "router %s %s %d 0 %dn"
  1696.                     "platform %sn"
  1697.                     "opt protocols Link 1 2 Circuit 1n"
  1698.                     "published %sn"
  1699.                     "opt fingerprint %sn"
  1700.                     "uptime %ldn"
  1701.                     "bandwidth %d %d %dn"
  1702.                     "opt extra-info-digest %sn%s"
  1703.                     "onion-keyn%s"
  1704.                     "signing-keyn%s"
  1705.                     "%s%s%s%s",
  1706.     router->nickname,
  1707.     router->address,
  1708.     router->or_port,
  1709.     decide_to_advertise_dirport(options, router->dir_port),
  1710.     router->platform,
  1711.     published,
  1712.     fingerprint,
  1713.     stats_n_seconds_working,
  1714.     (int) router->bandwidthrate,
  1715.     (int) router->bandwidthburst,
  1716.     (int) router->bandwidthcapacity,
  1717.     extra_info_digest,
  1718.     options->DownloadExtraInfo ? "opt caches-extra-infon" : "",
  1719.     onion_pkey, identity_pkey,
  1720.     family_line,
  1721.     we_are_hibernating() ? "opt hibernating 1n" : "",
  1722.     options->HidServDirectoryV2 ? "opt hidden-service-dirn" : "",
  1723.     options->AllowSingleHopExits ? "opt allow-single-hop-exitsn" : "");
  1725.   tor_free(family_line);
  1726.   tor_free(onion_pkey);
  1727.   tor_free(identity_pkey);
  1729.   if (result < 0) {
  1730.     log_warn(LD_BUG,"descriptor snprintf #1 ran out of room!");
  1731.     return -1;
  1732.   }
  1733.   /* From now on, we use 'written' to remember the current length of 's'. */
  1734.   written = result;
  1736.   if (options->ContactInfo && strlen(options->ContactInfo)) {
  1737.     const char *ci = options->ContactInfo;
  1738.     if (strchr(ci, 'n') || strchr(ci, 'r'))
  1739.       ci = escaped(ci);
  1740.     result = tor_snprintf(s+written,maxlen-written, "contact %sn", ci);
  1741.     if (result<0) {
  1742.       log_warn(LD_BUG,"descriptor snprintf #2 ran out of room!");
  1743.       return -1;
  1744.     }
  1745.     written += result;
  1746.   }
  1748.   /* Write the exit policy to the end of 's'. */
  1749.   if (dns_seems_to_be_broken() || has_dns_init_failed() ||
  1750.       !router->exit_policy || !smartlist_len(router->exit_policy)) {
  1751.     /* DNS is screwed up; don't claim to be an exit. */
  1752.     strlcat(s+written, "reject *:*n", maxlen-written);
  1753.     written += strlen("reject *:*n");
  1754.     tmpe = NULL;
  1755.   } else if (router->exit_policy) {
  1756.     int i;
  1757.     for (i = 0; i < smartlist_len(router->exit_policy); ++i) {
  1758.       tmpe = smartlist_get(router->exit_policy, i);
  1759.       result = policy_write_item(s+written, maxlen-written, tmpe, 1);
  1760.       if (result < 0) {
  1761.         log_warn(LD_BUG,"descriptor policy_write_item ran out of room!");
  1762.         return -1;
  1763.       }
  1764.       tor_assert(result == (int)strlen(s+written));
  1765.       written += result;
  1766.       if (written+2 > maxlen) {
  1767.         log_warn(LD_BUG,"descriptor policy_write_item ran out of room (2)!");
  1768.         return -1;
  1769.       }
  1770.       s[written++] = 'n';
  1771.     }
  1772.   }
  1774.   if (written+256 > maxlen) { /* Not enough room for signature. */
  1775.     log_warn(LD_BUG,"not enough room left in descriptor for signature!");
  1776.     return -1;
  1777.   }
  1779.   /* Sign the descriptor */
  1780.   strlcpy(s+written, "router-signaturen", maxlen-written);
  1781.   written += strlen(s+written);
  1782.   s[written] = '';
  1783.   if (router_get_router_hash(s, digest) < 0) {
  1784.     return -1;
  1785.   }
  1787.   note_crypto_pk_op(SIGN_RTR);
  1788.   if (router_append_dirobj_signature(s+written,maxlen-written,
  1789.                                      digest,ident_key)<0) {
  1790.     log_warn(LD_BUG, "Couldn't sign router descriptor");
  1791.     return -1;
  1792.   }
  1793.   written += strlen(s+written);
  1795.   if (written+2 > maxlen) {
  1796.     log_warn(LD_BUG,"Not enough room to finish descriptor.");
  1797.     return -1;
  1798.   }
  1799.   /* include a last 'n' */
  1800.   s[written] = 'n';
  1801.   s[written+1] = 0;
  1803. #ifdef DEBUG_ROUTER_DUMP_ROUTER_TO_STRING
  1804.   {
  1805.     char *s_dup;
  1806.     const char *cp;
  1807.     routerinfo_t *ri_tmp;
  1808.     cp = s_dup = tor_strdup(s);
  1809.     ri_tmp = router_parse_entry_from_string(cp, NULL, 1, 0, NULL);
  1810.     if (!ri_tmp) {
  1811.       log_err(LD_BUG,
  1812.               "We just generated a router descriptor we can't parse.");
  1813.       log_err(LD_BUG, "Descriptor was: <<%s>>", s);
  1814.       return -1;
  1815.     }
  1816.     tor_free(s_dup);
  1817.     routerinfo_free(ri_tmp);
  1818.   }
  1819. #endif
  1821.   return (int)written+1;
  1822. }
  1824. /** Write the contents of <b>extrainfo</b> to the <b>maxlen</b>-byte string
  1825.  * <b>s</b>, signing them with <b>ident_key</b>.  Return 0 on success,
  1826.  * negative on failure. */
  1827. int
  1828. extrainfo_dump_to_string(char *s, size_t maxlen, extrainfo_t *extrainfo,
  1829.                          crypto_pk_env_t *ident_key)
  1830. {
  1831.   or_options_t *options = get_options();
  1832.   char identity[HEX_DIGEST_LEN+1];
  1833.   char published[ISO_TIME_LEN+1];
  1834.   char digest[DIGEST_LEN];
  1835.   char *bandwidth_usage;
  1836.   int result;
  1837.   size_t len;
  1839.   base16_encode(identity, sizeof(identity),
  1840.                 extrainfo->cache_info.identity_digest, DIGEST_LEN);
  1841.   format_iso_time(published, extrainfo->cache_info.published_on);
  1842.   bandwidth_usage = rep_hist_get_bandwidth_lines(1);
  1844.   result = tor_snprintf(s, maxlen,
  1845.                         "extra-info %s %sn"
  1846.                         "published %sn%s",
  1847.                         extrainfo->nickname, identity,
  1848.                         published, bandwidth_usage);
  1849.   tor_free(bandwidth_usage);
  1850.   if (result<0)
  1851.     return -1;
  1853.   if (should_record_bridge_info(options)) {
  1854.     char *geoip_summary = extrainfo_get_client_geoip_summary(time(NULL));
  1855.     if (geoip_summary) {
  1856.       char geoip_start[ISO_TIME_LEN+1];
  1857.       format_iso_time(geoip_start, geoip_get_history_start());
  1858.       result = tor_snprintf(s+strlen(s), maxlen-strlen(s),
  1859.                             "geoip-start-time %sn"
  1860.                             "geoip-client-origins %sn",
  1861.                             geoip_start, geoip_summary);
  1862.       control_event_clients_seen(geoip_start, geoip_summary);
  1863.       tor_free(geoip_summary);
  1864.       if (result<0)
  1865.         return -1;
  1866.     }
  1867.   }
  1869.   len = strlen(s);
  1870.   strlcat(s+len, "router-signaturen", maxlen-len);
  1871.   len += strlen(s+len);
  1872.   if (router_get_extrainfo_hash(s, digest)<0)
  1873.     return -1;
  1874.   if (router_append_dirobj_signature(s+len, maxlen-len, digest, ident_key)<0)
  1875.     return -1;
  1877. #ifdef DEBUG_ROUTER_DUMP_ROUTER_TO_STRING
  1878.   {
  1879.     char *cp, *s_dup;
  1880.     extrainfo_t *ei_tmp;
  1881.     cp = s_dup = tor_strdup(s);
  1882.     ei_tmp = extrainfo_parse_entry_from_string(cp, NULL, 1, NULL);
  1883.     if (!ei_tmp) {
  1884.       log_err(LD_BUG,
  1885.               "We just generated an extrainfo descriptor we can't parse.");
  1886.       log_err(LD_BUG, "Descriptor was: <<%s>>", s);
  1887.       return -1;
  1888.     }
  1889.     tor_free(s_dup);
  1890.     extrainfo_free(ei_tmp);
  1891.   }
  1892. #endif
  1894.   return (int)strlen(s)+1;
  1895. }
  1897. /** Wrapper function for geoip_get_client_history(). It first discards
  1898.  * any items in the client history that are too old -- it dumps anything
  1899.  * more than 48 hours old, but it only considers whether to dump at most
  1900.  * once per 48 hours, so we aren't too precise to an observer (see also
  1901.  * r14780).
  1902.  */
  1903. char *
  1904. extrainfo_get_client_geoip_summary(time_t now)
  1905. {
  1906.   static time_t last_purged_at = 0;
  1907.   int geoip_purge_interval = 48*60*60;
  1908. #ifdef ENABLE_GEOIP_STATS
  1909.   if (get_options()->DirRecordUsageByCountry)
  1910.     geoip_purge_interval = get_options()->DirRecordUsageRetainIPs;
  1911. #endif
  1912.   if (now > last_purged_at+geoip_purge_interval) {
  1913.     geoip_remove_old_clients(now-geoip_purge_interval);
  1914.     last_purged_at = now;
  1915.   }
  1916.   return geoip_get_client_history(now, GEOIP_CLIENT_CONNECT);
  1917. }
  1919. /** Return true iff <b>s</b> is a legally valid server nickname. */
  1920. int
  1921. is_legal_nickname(const char *s)
  1922. {
  1923.   size_t len;
  1924.   tor_assert(s);
  1925.   len = strlen(s);
  1926.   return len > 0 && len <= MAX_NICKNAME_LEN &&
  1927.     strspn(s,LEGAL_NICKNAME_CHARACTERS) == len;
  1928. }
  1930. /** Return true iff <b>s</b> is a legally valid server nickname or
  1931.  * hex-encoded identity-key digest. */
  1932. int
  1933. is_legal_nickname_or_hexdigest(const char *s)
  1934. {
  1935.   if (*s!='$')
  1936.     return is_legal_nickname(s);
  1937.   else
  1938.     return is_legal_hexdigest(s);
  1939. }
  1941. /** Return true iff <b>s</b> is a legally valid hex-encoded identity-key
  1942.  * digest. */
  1943. int
  1944. is_legal_hexdigest(const char *s)
  1945. {
  1946.   size_t len;
  1947.   tor_assert(s);
  1948.   if (s[0] == '$') s++;
  1949.   len = strlen(s);
  1950.   if (len > HEX_DIGEST_LEN) {
  1951.     if (s[HEX_DIGEST_LEN] == '=' ||
  1952.         s[HEX_DIGEST_LEN] == '~') {
  1953.       if (!is_legal_nickname(s+HEX_DIGEST_LEN+1))
  1954.         return 0;
  1955.     } else {
  1956.       return 0;
  1957.     }
  1958.   }
  1959.   return (len >= HEX_DIGEST_LEN &&
  1960.           strspn(s,HEX_CHARACTERS)==HEX_DIGEST_LEN);
  1961. }
  1963. /** Set <b>buf</b> (which must have MAX_VERBOSE_NICKNAME_LEN+1 bytes) to the
  1964.  * verbose representation of the identity of <b>router</b>.  The format is:
  1965.  *  A dollar sign.
  1966.  *  The upper-case hexadecimal encoding of the SHA1 hash of router's identity.
  1967.  *  A "=" if the router is named; a "~" if it is not.
  1968.  *  The router's nickname.
  1969.  **/
  1970. void
  1971. router_get_verbose_nickname(char *buf, const routerinfo_t *router)
  1972. {
  1973.   buf[0] = '$';
  1974.   base16_encode(buf+1, HEX_DIGEST_LEN+1, router->cache_info.identity_digest,
  1975.                 DIGEST_LEN);
  1976.   buf[1+HEX_DIGEST_LEN] = router->is_named ? '=' : '~';
  1977.   strlcpy(buf+1+HEX_DIGEST_LEN+1, router->nickname, MAX_NICKNAME_LEN+1);
  1978. }
  1980. /** Set <b>buf</b> (which must have MAX_VERBOSE_NICKNAME_LEN+1 bytes) to the
  1981.  * verbose representation of the identity of <b>router</b>.  The format is:
  1982.  *  A dollar sign.
  1983.  *  The upper-case hexadecimal encoding of the SHA1 hash of router's identity.
  1984.  *  A "=" if the router is named; a "~" if it is not.
  1985.  *  The router's nickname.
  1986.  **/
  1987. void
  1988. routerstatus_get_verbose_nickname(char *buf, const routerstatus_t *router)
  1989. {
  1990.   buf[0] = '$';
  1991.   base16_encode(buf+1, HEX_DIGEST_LEN+1, router->identity_digest,
  1992.                 DIGEST_LEN);
  1993.   buf[1+HEX_DIGEST_LEN] = router->is_named ? '=' : '~';
  1994.   strlcpy(buf+1+HEX_DIGEST_LEN+1, router->nickname, MAX_NICKNAME_LEN+1);
  1995. }
  1997. /** Forget that we have issued any router-related warnings, so that we'll
  1998.  * warn again if we see the same errors. */
  1999. void
  2000. router_reset_warnings(void)
  2001. {
  2002.   if (warned_nonexistent_family) {
  2003.     SMARTLIST_FOREACH(warned_nonexistent_family, char *, cp, tor_free(cp));
  2004.     smartlist_clear(warned_nonexistent_family);
  2005.   }
  2006. }
  2008. /** Given a router purpose, convert it to a string.  Don't call this on
  2009.  * ROUTER_PURPOSE_UNKNOWN: The whole point of that value is that we don't
  2010.  * know its string representation. */
  2011. const char *
  2012. router_purpose_to_string(uint8_t p)
  2013. {
  2014.   switch (p)
  2015.     {
  2016.     case ROUTER_PURPOSE_GENERAL: return "general";
  2017.     case ROUTER_PURPOSE_BRIDGE: return "bridge";
  2018.     case ROUTER_PURPOSE_CONTROLLER: return "controller";
  2019.     default:
  2020.       tor_assert(0);
  2021.     }
  2022.   return NULL;
  2023. }
  2025. /** Given a string, convert it to a router purpose. */
  2026. uint8_t
  2027. router_purpose_from_string(const char *s)
  2028. {
  2029.   if (!strcmp(s, "general"))
  2030.     return ROUTER_PURPOSE_GENERAL;
  2031.   else if (!strcmp(s, "bridge"))
  2032.     return ROUTER_PURPOSE_BRIDGE;
  2033.   else if (!strcmp(s, "controller"))
  2034.     return ROUTER_PURPOSE_CONTROLLER;
  2035.   else
  2036.     return ROUTER_PURPOSE_UNKNOWN;
  2037. }
  2039. /** Release all static resources held in router.c */
  2040. void
  2041. router_free_all(void)
  2042. {
  2043.   if (onionkey)
  2044.     crypto_free_pk_env(onionkey);
  2045.   if (lastonionkey)
  2046.     crypto_free_pk_env(lastonionkey);
  2047.   if (identitykey)
  2048.     crypto_free_pk_env(identitykey);
  2049.   if (key_lock)
  2050.     tor_mutex_free(key_lock);
  2051.   if (desc_routerinfo)
  2052.     routerinfo_free(desc_routerinfo);
  2053.   if (desc_extrainfo)
  2054.     extrainfo_free(desc_extrainfo);
  2055.   if (authority_signing_key)
  2056.     crypto_free_pk_env(authority_signing_key);
  2057.   if (authority_key_certificate)
  2058.     authority_cert_free(authority_key_certificate);
  2059.   if (legacy_signing_key)
  2060.     crypto_free_pk_env(legacy_signing_key);
  2061.   if (legacy_key_certificate)
  2062.     authority_cert_free(legacy_key_certificate);
  2064.   if (warned_nonexistent_family) {
  2065.     SMARTLIST_FOREACH(warned_nonexistent_family, char *, cp, tor_free(cp));
  2066.     smartlist_free(warned_nonexistent_family);
  2067.   }
  2068. }