command.c 23 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657
  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-2010, The Tor Project, Inc. */
  5. /* See LICENSE for licensing information */
  6. /**
  7. * \file command.c
  8. * \brief Functions for processing incoming cells.
  9. **/
  10. /* In-points to command.c:
  11. *
  12. * - command_process_cell(), called from
  13. * connection_or_process_cells_from_inbuf() in connection_or.c
  14. */
  15. #include "or.h"
  16. #include "circuitbuild.h"
  17. #include "circuitlist.h"
  18. #include "command.h"
  19. #include "connection.h"
  20. #include "connection_or.h"
  21. #include "config.h"
  22. #include "control.h"
  23. #include "cpuworker.h"
  24. #include "hibernate.h"
  25. #include "onion.h"
  26. #include "relay.h"
  27. #include "router.h"
  28. #include "routerlist.h"
  29. /** How many CELL_PADDING cells have we received, ever? */
  30. uint64_t stats_n_padding_cells_processed = 0;
  31. /** How many CELL_CREATE cells have we received, ever? */
  32. uint64_t stats_n_create_cells_processed = 0;
  33. /** How many CELL_CREATED cells have we received, ever? */
  34. uint64_t stats_n_created_cells_processed = 0;
  35. /** How many CELL_RELAY cells have we received, ever? */
  36. uint64_t stats_n_relay_cells_processed = 0;
  37. /** How many CELL_DESTROY cells have we received, ever? */
  38. uint64_t stats_n_destroy_cells_processed = 0;
  39. /** How many CELL_VERSIONS cells have we received, ever? */
  40. uint64_t stats_n_versions_cells_processed = 0;
  41. /** How many CELL_NETINFO cells have we received, ever? */
  42. uint64_t stats_n_netinfo_cells_processed = 0;
  43. /* These are the main functions for processing cells */
  44. static void command_process_create_cell(cell_t *cell, or_connection_t *conn);
  45. static void command_process_created_cell(cell_t *cell, or_connection_t *conn);
  46. static void command_process_relay_cell(cell_t *cell, or_connection_t *conn);
  47. static void command_process_destroy_cell(cell_t *cell, or_connection_t *conn);
  48. static void command_process_versions_cell(var_cell_t *cell,
  49. or_connection_t *conn);
  50. static void command_process_netinfo_cell(cell_t *cell, or_connection_t *conn);
  51. #ifdef KEEP_TIMING_STATS
  52. /** This is a wrapper function around the actual function that processes the
  53. * <b>cell</b> that just arrived on <b>conn</b>. Increment <b>*time</b>
  54. * by the number of microseconds used by the call to <b>*func(cell, conn)</b>.
  55. */
  56. static void
  57. command_time_process_cell(cell_t *cell, or_connection_t *conn, int *time,
  58. void (*func)(cell_t *, or_connection_t *))
  59. {
  60. struct timeval start, end;
  61. long time_passed;
  62. tor_gettimeofday(&start);
  63. (*func)(cell, conn);
  64. tor_gettimeofday(&end);
  65. time_passed = tv_udiff(&start, &end) ;
  66. if (time_passed > 10000) { /* more than 10ms */
  67. log_debug(LD_OR,"That call just took %ld ms.",time_passed/1000);
  68. }
  69. if (time_passed < 0) {
  70. log_info(LD_GENERAL,"That call took us back in time!");
  71. time_passed = 0;
  72. }
  73. *time += time_passed;
  74. }
  75. #endif
  76. /** Process a <b>cell</b> that was just received on <b>conn</b>. Keep internal
  77. * statistics about how many of each cell we've processed so far
  78. * this second, and the total number of microseconds it took to
  79. * process each type of cell.
  80. */
  81. void
  82. command_process_cell(cell_t *cell, or_connection_t *conn)
  83. {
  84. int handshaking = (conn->_base.state == OR_CONN_STATE_OR_HANDSHAKING);
  85. #ifdef KEEP_TIMING_STATS
  86. /* how many of each cell have we seen so far this second? needs better
  87. * name. */
  88. static int num_create=0, num_created=0, num_relay=0, num_destroy=0;
  89. /* how long has it taken to process each type of cell? */
  90. static int create_time=0, created_time=0, relay_time=0, destroy_time=0;
  91. static time_t current_second = 0; /* from previous calls to time */
  92. time_t now = time(NULL);
  93. if (now > current_second) { /* the second has rolled over */
  94. /* print stats */
  95. log_info(LD_OR,
  96. "At end of second: %d creates (%d ms), %d createds (%d ms), "
  97. "%d relays (%d ms), %d destroys (%d ms)",
  98. num_create, create_time/1000,
  99. num_created, created_time/1000,
  100. num_relay, relay_time/1000,
  101. num_destroy, destroy_time/1000);
  102. /* zero out stats */
  103. num_create = num_created = num_relay = num_destroy = 0;
  104. create_time = created_time = relay_time = destroy_time = 0;
  105. /* remember which second it is, for next time */
  106. current_second = now;
  107. }
  108. #endif
  109. #ifdef KEEP_TIMING_STATS
  110. #define PROCESS_CELL(tp, cl, cn) STMT_BEGIN { \
  111. ++num ## tp; \
  112. command_time_process_cell(cl, cn, & tp ## time , \
  113. command_process_ ## tp ## _cell); \
  114. } STMT_END
  115. #else
  116. #define PROCESS_CELL(tp, cl, cn) command_process_ ## tp ## _cell(cl, cn)
  117. #endif
  118. /* Reject all but VERSIONS and NETINFO when handshaking. */
  119. if (handshaking && cell->command != CELL_VERSIONS &&
  120. cell->command != CELL_NETINFO)
  121. return;
  122. switch (cell->command) {
  123. case CELL_PADDING:
  124. ++stats_n_padding_cells_processed;
  125. /* do nothing */
  126. break;
  127. case CELL_CREATE:
  128. case CELL_CREATE_FAST:
  129. ++stats_n_create_cells_processed;
  130. PROCESS_CELL(create, cell, conn);
  131. break;
  132. case CELL_CREATED:
  133. case CELL_CREATED_FAST:
  134. ++stats_n_created_cells_processed;
  135. PROCESS_CELL(created, cell, conn);
  136. break;
  137. case CELL_RELAY:
  138. case CELL_RELAY_EARLY:
  139. ++stats_n_relay_cells_processed;
  140. PROCESS_CELL(relay, cell, conn);
  141. break;
  142. case CELL_DESTROY:
  143. ++stats_n_destroy_cells_processed;
  144. PROCESS_CELL(destroy, cell, conn);
  145. break;
  146. case CELL_VERSIONS:
  147. tor_fragile_assert();
  148. break;
  149. case CELL_NETINFO:
  150. ++stats_n_netinfo_cells_processed;
  151. PROCESS_CELL(netinfo, cell, conn);
  152. break;
  153. default:
  154. log_fn(LOG_INFO, LD_PROTOCOL,
  155. "Cell of unknown type (%d) received. Dropping.", cell->command);
  156. break;
  157. }
  158. }
  159. /** Process a <b>cell</b> that was just received on <b>conn</b>. Keep internal
  160. * statistics about how many of each cell we've processed so far
  161. * this second, and the total number of microseconds it took to
  162. * process each type of cell.
  163. */
  164. void
  165. command_process_var_cell(var_cell_t *cell, or_connection_t *conn)
  166. {
  167. #ifdef KEEP_TIMING_STATS
  168. /* how many of each cell have we seen so far this second? needs better
  169. * name. */
  170. static int num_versions=0, num_cert=0;
  171. time_t now = time(NULL);
  172. if (now > current_second) { /* the second has rolled over */
  173. /* print stats */
  174. log_info(LD_OR,
  175. "At end of second: %d versions (%d ms), %d cert (%d ms)",
  176. num_versions, versions_time/1000,
  177. cert, cert_time/1000);
  178. num_versions = num_cert = 0;
  179. versions_time = cert_time = 0;
  180. /* remember which second it is, for next time */
  181. current_second = now;
  182. }
  183. #endif
  184. /* reject all when not handshaking. */
  185. if (conn->_base.state != OR_CONN_STATE_OR_HANDSHAKING)
  186. return;
  187. switch (cell->command) {
  188. case CELL_VERSIONS:
  189. ++stats_n_versions_cells_processed;
  190. PROCESS_CELL(versions, cell, conn);
  191. break;
  192. default:
  193. log_warn(LD_BUG,
  194. "Variable-length cell of unknown type (%d) received.",
  195. cell->command);
  196. tor_fragile_assert();
  197. break;
  198. }
  199. }
  200. /** Process a 'create' <b>cell</b> that just arrived from <b>conn</b>. Make a
  201. * new circuit with the p_circ_id specified in cell. Put the circuit in state
  202. * onionskin_pending, and pass the onionskin to the cpuworker. Circ will get
  203. * picked up again when the cpuworker finishes decrypting it.
  204. */
  205. static void
  206. command_process_create_cell(cell_t *cell, or_connection_t *conn)
  207. {
  208. or_circuit_t *circ;
  209. int id_is_high;
  210. if (we_are_hibernating()) {
  211. log_info(LD_OR,
  212. "Received create cell but we're shutting down. Sending back "
  213. "destroy.");
  214. connection_or_send_destroy(cell->circ_id, conn,
  215. END_CIRC_REASON_HIBERNATING);
  216. return;
  217. }
  218. if (!server_mode(get_options())) {
  219. log_fn(LOG_PROTOCOL_WARN, LD_PROTOCOL,
  220. "Received create cell (type %d) from %s:%d, but we're a client. "
  221. "Sending back a destroy.",
  222. (int)cell->command, conn->_base.address, conn->_base.port);
  223. connection_or_send_destroy(cell->circ_id, conn,
  224. END_CIRC_REASON_TORPROTOCOL);
  225. return;
  226. }
  227. /* If the high bit of the circuit ID is not as expected, close the
  228. * circ. */
  229. id_is_high = cell->circ_id & (1<<15);
  230. if ((id_is_high && conn->circ_id_type == CIRC_ID_TYPE_HIGHER) ||
  231. (!id_is_high && conn->circ_id_type == CIRC_ID_TYPE_LOWER)) {
  232. log_fn(LOG_PROTOCOL_WARN, LD_PROTOCOL,
  233. "Received create cell with unexpected circ_id %d. Closing.",
  234. cell->circ_id);
  235. connection_or_send_destroy(cell->circ_id, conn,
  236. END_CIRC_REASON_TORPROTOCOL);
  237. return;
  238. }
  239. if (circuit_id_in_use_on_orconn(cell->circ_id, conn)) {
  240. routerinfo_t *router = router_get_by_digest(conn->identity_digest);
  241. log_fn(LOG_PROTOCOL_WARN, LD_PROTOCOL,
  242. "Received CREATE cell (circID %d) for known circ. "
  243. "Dropping (age %d).",
  244. cell->circ_id, (int)(time(NULL) - conn->_base.timestamp_created));
  245. if (router)
  246. log_fn(LOG_PROTOCOL_WARN, LD_PROTOCOL,
  247. "Details: nickname \"%s\", platform %s.",
  248. router->nickname, escaped(router->platform));
  249. return;
  250. }
  251. circ = or_circuit_new(cell->circ_id, conn);
  252. circ->_base.purpose = CIRCUIT_PURPOSE_OR;
  253. circuit_set_state(TO_CIRCUIT(circ), CIRCUIT_STATE_ONIONSKIN_PENDING);
  254. if (cell->command == CELL_CREATE) {
  255. char *onionskin = tor_malloc(ONIONSKIN_CHALLENGE_LEN);
  256. memcpy(onionskin, cell->payload, ONIONSKIN_CHALLENGE_LEN);
  257. /* hand it off to the cpuworkers, and then return. */
  258. if (assign_onionskin_to_cpuworker(NULL, circ, onionskin) < 0) {
  259. #define WARN_HANDOFF_FAILURE_INTERVAL (6*60*60)
  260. static ratelim_t handoff_warning =
  261. RATELIM_INIT(WARN_HANDOFF_FAILURE_INTERVAL);
  262. char *m;
  263. if ((m = rate_limit_log(&handoff_warning, approx_time()))) {
  264. log_warn(LD_GENERAL,"Failed to hand off onionskin. Closing.%s",m);
  265. tor_free(m);
  266. }
  267. circuit_mark_for_close(TO_CIRCUIT(circ), END_CIRC_REASON_INTERNAL);
  268. return;
  269. }
  270. log_debug(LD_OR,"success: handed off onionskin.");
  271. } else {
  272. /* This is a CREATE_FAST cell; we can handle it immediately without using
  273. * a CPU worker. */
  274. char keys[CPATH_KEY_MATERIAL_LEN];
  275. char reply[DIGEST_LEN*2];
  276. tor_assert(cell->command == CELL_CREATE_FAST);
  277. if (fast_server_handshake(cell->payload, (uint8_t*)reply,
  278. (uint8_t*)keys, sizeof(keys))<0) {
  279. log_warn(LD_OR,"Failed to generate key material. Closing.");
  280. circuit_mark_for_close(TO_CIRCUIT(circ), END_CIRC_REASON_INTERNAL);
  281. return;
  282. }
  283. if (onionskin_answer(circ, CELL_CREATED_FAST, reply, keys)<0) {
  284. log_warn(LD_OR,"Failed to reply to CREATE_FAST cell. Closing.");
  285. circuit_mark_for_close(TO_CIRCUIT(circ), END_CIRC_REASON_INTERNAL);
  286. return;
  287. }
  288. }
  289. }
  290. /** Process a 'created' <b>cell</b> that just arrived from <b>conn</b>.
  291. * Find the circuit
  292. * that it's intended for. If we're not the origin of the circuit, package
  293. * the 'created' cell in an 'extended' relay cell and pass it back. If we
  294. * are the origin of the circuit, send it to circuit_finish_handshake() to
  295. * finish processing keys, and then call circuit_send_next_onion_skin() to
  296. * extend to the next hop in the circuit if necessary.
  297. */
  298. static void
  299. command_process_created_cell(cell_t *cell, or_connection_t *conn)
  300. {
  301. circuit_t *circ;
  302. circ = circuit_get_by_circid_orconn(cell->circ_id, conn);
  303. if (!circ) {
  304. log_info(LD_OR,
  305. "(circID %d) unknown circ (probably got a destroy earlier). "
  306. "Dropping.", cell->circ_id);
  307. return;
  308. }
  309. if (circ->n_circ_id != cell->circ_id) {
  310. log_fn(LOG_PROTOCOL_WARN,LD_PROTOCOL,
  311. "got created cell from Tor client? Closing.");
  312. circuit_mark_for_close(circ, END_CIRC_REASON_TORPROTOCOL);
  313. return;
  314. }
  315. if (CIRCUIT_IS_ORIGIN(circ)) { /* we're the OP. Handshake this. */
  316. origin_circuit_t *origin_circ = TO_ORIGIN_CIRCUIT(circ);
  317. int err_reason = 0;
  318. log_debug(LD_OR,"at OP. Finishing handshake.");
  319. if ((err_reason = circuit_finish_handshake(origin_circ, cell->command,
  320. cell->payload)) < 0) {
  321. log_warn(LD_OR,"circuit_finish_handshake failed.");
  322. circuit_mark_for_close(circ, -err_reason);
  323. return;
  324. }
  325. log_debug(LD_OR,"Moving to next skin.");
  326. if ((err_reason = circuit_send_next_onion_skin(origin_circ)) < 0) {
  327. log_info(LD_OR,"circuit_send_next_onion_skin failed.");
  328. /* XXX push this circuit_close lower */
  329. circuit_mark_for_close(circ, -err_reason);
  330. return;
  331. }
  332. } else { /* pack it into an extended relay cell, and send it. */
  333. log_debug(LD_OR,
  334. "Converting created cell to extended relay cell, sending.");
  335. relay_send_command_from_edge(0, circ, RELAY_COMMAND_EXTENDED,
  336. (char*)cell->payload, ONIONSKIN_REPLY_LEN,
  337. NULL);
  338. }
  339. }
  340. /** Process a 'relay' or 'relay_early' <b>cell</b> that just arrived from
  341. * <b>conn</b>. Make sure it came in with a recognized circ_id. Pass it on to
  342. * circuit_receive_relay_cell() for actual processing.
  343. */
  344. static void
  345. command_process_relay_cell(cell_t *cell, or_connection_t *conn)
  346. {
  347. circuit_t *circ;
  348. int reason, direction;
  349. circ = circuit_get_by_circid_orconn(cell->circ_id, conn);
  350. if (!circ) {
  351. log_debug(LD_OR,
  352. "unknown circuit %d on connection from %s:%d. Dropping.",
  353. cell->circ_id, conn->_base.address, conn->_base.port);
  354. return;
  355. }
  356. if (circ->state == CIRCUIT_STATE_ONIONSKIN_PENDING) {
  357. log_fn(LOG_PROTOCOL_WARN,LD_PROTOCOL,"circuit in create_wait. Closing.");
  358. circuit_mark_for_close(circ, END_CIRC_REASON_TORPROTOCOL);
  359. return;
  360. }
  361. if (CIRCUIT_IS_ORIGIN(circ)) {
  362. /* if we're a relay and treating connections with recent local
  363. * traffic better, then this is one of them. */
  364. conn->client_used = time(NULL);
  365. }
  366. if (!CIRCUIT_IS_ORIGIN(circ) &&
  367. cell->circ_id == TO_OR_CIRCUIT(circ)->p_circ_id)
  368. direction = CELL_DIRECTION_OUT;
  369. else
  370. direction = CELL_DIRECTION_IN;
  371. /* If we have a relay_early cell, make sure that it's outbound, and we've
  372. * gotten no more than MAX_RELAY_EARLY_CELLS_PER_CIRCUIT of them. */
  373. if (cell->command == CELL_RELAY_EARLY) {
  374. if (direction == CELL_DIRECTION_IN) {
  375. /* Allow an unlimited number of inbound relay_early cells,
  376. * for hidden service compatibility. There isn't any way to make
  377. * a long circuit through inbound relay_early cells anyway. See
  378. * bug 1038. -RD */
  379. } else {
  380. or_circuit_t *or_circ = TO_OR_CIRCUIT(circ);
  381. if (or_circ->remaining_relay_early_cells == 0) {
  382. log_fn(LOG_PROTOCOL_WARN, LD_OR,
  383. "Received too many RELAY_EARLY cells on circ %d from %s:%d."
  384. " Closing circuit.",
  385. cell->circ_id, safe_str(conn->_base.address),
  386. conn->_base.port);
  387. circuit_mark_for_close(circ, END_CIRC_REASON_TORPROTOCOL);
  388. return;
  389. }
  390. --or_circ->remaining_relay_early_cells;
  391. }
  392. }
  393. if ((reason = circuit_receive_relay_cell(cell, circ, direction)) < 0) {
  394. log_fn(LOG_PROTOCOL_WARN,LD_PROTOCOL,"circuit_receive_relay_cell "
  395. "(%s) failed. Closing.",
  396. direction==CELL_DIRECTION_OUT?"forward":"backward");
  397. circuit_mark_for_close(circ, -reason);
  398. }
  399. }
  400. /** Process a 'destroy' <b>cell</b> that just arrived from
  401. * <b>conn</b>. Find the circ that it refers to (if any).
  402. *
  403. * If the circ is in state
  404. * onionskin_pending, then call onion_pending_remove() to remove it
  405. * from the pending onion list (note that if it's already being
  406. * processed by the cpuworker, it won't be in the list anymore; but
  407. * when the cpuworker returns it, the circuit will be gone, and the
  408. * cpuworker response will be dropped).
  409. *
  410. * Then mark the circuit for close (which marks all edges for close,
  411. * and passes the destroy cell onward if necessary).
  412. */
  413. static void
  414. command_process_destroy_cell(cell_t *cell, or_connection_t *conn)
  415. {
  416. circuit_t *circ;
  417. int reason;
  418. circ = circuit_get_by_circid_orconn(cell->circ_id, conn);
  419. reason = (uint8_t)cell->payload[0];
  420. if (!circ) {
  421. log_info(LD_OR,"unknown circuit %d on connection from %s:%d. Dropping.",
  422. cell->circ_id, conn->_base.address, conn->_base.port);
  423. return;
  424. }
  425. log_debug(LD_OR,"Received for circID %d.",cell->circ_id);
  426. if (!CIRCUIT_IS_ORIGIN(circ) &&
  427. cell->circ_id == TO_OR_CIRCUIT(circ)->p_circ_id) {
  428. /* the destroy came from behind */
  429. circuit_set_p_circid_orconn(TO_OR_CIRCUIT(circ), 0, NULL);
  430. circuit_mark_for_close(circ, reason|END_CIRC_REASON_FLAG_REMOTE);
  431. } else { /* the destroy came from ahead */
  432. circuit_set_n_circid_orconn(circ, 0, NULL);
  433. if (CIRCUIT_IS_ORIGIN(circ)) {
  434. circuit_mark_for_close(circ, reason|END_CIRC_REASON_FLAG_REMOTE);
  435. } else {
  436. char payload[1];
  437. log_debug(LD_OR, "Delivering 'truncated' back.");
  438. payload[0] = (char)reason;
  439. relay_send_command_from_edge(0, circ, RELAY_COMMAND_TRUNCATED,
  440. payload, sizeof(payload), NULL);
  441. }
  442. }
  443. }
  444. /** Process a 'versions' cell. The current link protocol version must be 0
  445. * to indicate that no version has yet been negotiated. We compare the
  446. * versions in the cell to the list of versions we support, pick the
  447. * highest version we have in common, and continue the negotiation from
  448. * there.
  449. */
  450. static void
  451. command_process_versions_cell(var_cell_t *cell, or_connection_t *conn)
  452. {
  453. int highest_supported_version = 0;
  454. const uint8_t *cp, *end;
  455. if (conn->link_proto != 0 ||
  456. conn->_base.state != OR_CONN_STATE_OR_HANDSHAKING ||
  457. (conn->handshake_state && conn->handshake_state->received_versions)) {
  458. log_fn(LOG_PROTOCOL_WARN, LD_OR,
  459. "Received a VERSIONS cell on a connection with its version "
  460. "already set to %d; dropping", (int) conn->link_proto);
  461. return;
  462. }
  463. tor_assert(conn->handshake_state);
  464. end = cell->payload + cell->payload_len;
  465. for (cp = cell->payload; cp+1 < end; ++cp) {
  466. uint16_t v = ntohs(get_uint16(cp));
  467. if (is_or_protocol_version_known(v) && v > highest_supported_version)
  468. highest_supported_version = v;
  469. }
  470. if (!highest_supported_version) {
  471. log_fn(LOG_PROTOCOL_WARN, LD_OR,
  472. "Couldn't find a version in common between my version list and the "
  473. "list in the VERSIONS cell; closing connection.");
  474. connection_mark_for_close(TO_CONN(conn));
  475. return;
  476. } else if (highest_supported_version == 1) {
  477. /* Negotiating version 1 makes no sense, since version 1 has no VERSIONS
  478. * cells. */
  479. log_fn(LOG_PROTOCOL_WARN, LD_OR,
  480. "Used version negotiation protocol to negotiate a v1 connection. "
  481. "That's crazily non-compliant. Closing connection.");
  482. connection_mark_for_close(TO_CONN(conn));
  483. return;
  484. }
  485. conn->link_proto = highest_supported_version;
  486. conn->handshake_state->received_versions = 1;
  487. log_info(LD_OR, "Negotiated version %d with %s:%d; sending NETINFO.",
  488. highest_supported_version,
  489. safe_str_client(conn->_base.address),
  490. conn->_base.port);
  491. tor_assert(conn->link_proto >= 2);
  492. if (connection_or_send_netinfo(conn) < 0) {
  493. connection_mark_for_close(TO_CONN(conn));
  494. return;
  495. }
  496. }
  497. /** Process a 'netinfo' cell: read and act on its contents, and set the
  498. * connection state to "open". */
  499. static void
  500. command_process_netinfo_cell(cell_t *cell, or_connection_t *conn)
  501. {
  502. time_t timestamp;
  503. uint8_t my_addr_type;
  504. uint8_t my_addr_len;
  505. const uint8_t *my_addr_ptr;
  506. const uint8_t *cp, *end;
  507. uint8_t n_other_addrs;
  508. time_t now = time(NULL);
  509. long apparent_skew = 0;
  510. uint32_t my_apparent_addr = 0;
  511. if (conn->link_proto < 2) {
  512. log_fn(LOG_PROTOCOL_WARN, LD_OR,
  513. "Received a NETINFO cell on %s connection; dropping.",
  514. conn->link_proto == 0 ? "non-versioned" : "a v1");
  515. return;
  516. }
  517. if (conn->_base.state != OR_CONN_STATE_OR_HANDSHAKING) {
  518. log_fn(LOG_PROTOCOL_WARN, LD_OR,
  519. "Received a NETINFO cell on non-handshaking connection; dropping.");
  520. return;
  521. }
  522. tor_assert(conn->handshake_state &&
  523. conn->handshake_state->received_versions);
  524. /* Decode the cell. */
  525. timestamp = ntohl(get_uint32(cell->payload));
  526. if (labs(now - conn->handshake_state->sent_versions_at) < 180) {
  527. apparent_skew = now - timestamp;
  528. }
  529. my_addr_type = (uint8_t) cell->payload[4];
  530. my_addr_len = (uint8_t) cell->payload[5];
  531. my_addr_ptr = (uint8_t*) cell->payload + 6;
  532. end = cell->payload + CELL_PAYLOAD_SIZE;
  533. cp = cell->payload + 6 + my_addr_len;
  534. if (cp >= end) {
  535. log_fn(LOG_PROTOCOL_WARN, LD_OR,
  536. "Addresses too long in netinfo cell; closing connection.");
  537. connection_mark_for_close(TO_CONN(conn));
  538. return;
  539. } else if (my_addr_type == RESOLVED_TYPE_IPV4 && my_addr_len == 4) {
  540. my_apparent_addr = ntohl(get_uint32(my_addr_ptr));
  541. }
  542. n_other_addrs = (uint8_t) *cp++;
  543. while (n_other_addrs && cp < end-2) {
  544. /* Consider all the other addresses; if any matches, this connection is
  545. * "canonical." */
  546. tor_addr_t addr;
  547. const uint8_t *next = decode_address_from_payload(&addr, cp, (int)(end-cp));
  548. if (next == NULL) {
  549. log_fn(LOG_PROTOCOL_WARN, LD_OR,
  550. "Bad address in netinfo cell; closing connection.");
  551. connection_mark_for_close(TO_CONN(conn));
  552. return;
  553. }
  554. if (tor_addr_eq(&addr, &conn->real_addr)) {
  555. conn->is_canonical = 1;
  556. break;
  557. }
  558. cp = next;
  559. --n_other_addrs;
  560. }
  561. /* Act on apparent skew. */
  562. /** Warn when we get a netinfo skew with at least this value. */
  563. #define NETINFO_NOTICE_SKEW 3600
  564. if (labs(apparent_skew) > NETINFO_NOTICE_SKEW &&
  565. router_get_by_digest(conn->identity_digest)) {
  566. char dbuf[64];
  567. int severity;
  568. /*XXXX be smarter about when everybody says we are skewed. */
  569. if (router_digest_is_trusted_dir(conn->identity_digest))
  570. severity = LOG_WARN;
  571. else
  572. severity = LOG_INFO;
  573. format_time_interval(dbuf, sizeof(dbuf), apparent_skew);
  574. log_fn(severity, LD_GENERAL, "Received NETINFO cell with skewed time from "
  575. "server at %s:%d. It seems that our clock is %s by %s, or "
  576. "that theirs is %s. Tor requires an accurate clock to work: "
  577. "please check your time and date settings.",
  578. conn->_base.address, (int)conn->_base.port,
  579. apparent_skew>0 ? "ahead" : "behind", dbuf,
  580. apparent_skew>0 ? "behind" : "ahead");
  581. if (severity == LOG_WARN) /* only tell the controller if an authority */
  582. control_event_general_status(LOG_WARN,
  583. "CLOCK_SKEW SKEW=%ld SOURCE=OR:%s:%d",
  584. apparent_skew,
  585. conn->_base.address, conn->_base.port);
  586. }
  587. /* XXX maybe act on my_apparent_addr, if the source is sufficiently
  588. * trustworthy. */
  589. if (connection_or_set_state_open(conn)<0)
  590. connection_mark_for_close(TO_CONN(conn));
  591. else
  592. log_info(LD_OR, "Got good NETINFO cell from %s:%d; OR connection is now "
  593. "open, using protocol version %d",
  594. safe_str_client(conn->_base.address),
  595. conn->_base.port, (int)conn->link_proto);
  596. assert_connection_ok(TO_CONN(conn),time(NULL));
  597. }