test_status.c (25947B)
1 /* Copyright (c) 2014-2021, The Tor Project, Inc. */ 2 /* See LICENSE for licensing information */ 3 4 #define STATUS_PRIVATE 5 #define HIBERNATE_PRIVATE 6 #define LOG_PRIVATE 7 #define REPHIST_PRIVATE 8 9 #include "orconfig.h" 10 11 #include <float.h> 12 #include <math.h> 13 14 #include "core/or/or.h" 15 #include "lib/log/log.h" 16 #include "tor_queue.h" 17 #include "core/or/status.h" 18 #include "core/or/circuitlist.h" 19 #include "app/config/config.h" 20 #include "feature/hibernate/hibernate.h" 21 #include "feature/stats/rephist.h" 22 #include "core/or/relay.h" 23 #include "feature/relay/router.h" 24 #include "feature/relay/routermode.h" 25 #include "core/mainloop/mainloop.h" 26 #include "feature/nodelist/nodelist.h" 27 #include "app/config/statefile.h" 28 #include "lib/tls/tortls.h" 29 #include "test/log_test_helpers.h" 30 31 #include "core/or/origin_circuit_st.h" 32 #include "app/config/or_state_st.h" 33 #include "feature/nodelist/routerinfo_st.h" 34 35 #include "test/test.h" 36 37 /* 38 * Test that count_circuits() is correctly counting the number of 39 * global circuits. 40 */ 41 42 static smartlist_t * mock_global_circuitlist = NULL; 43 44 static smartlist_t * status_count_circuits_circuit_get_global_list(void); 45 46 static void 47 test_status_count_circuits(void *arg) 48 { 49 /* Choose origin_circuit_t wlog. */ 50 origin_circuit_t *mock_circuit1, *mock_circuit2; 51 int expected_circuits = 2, actual_circuits; 52 53 (void)arg; 54 55 mock_circuit1 = tor_malloc_zero(sizeof(origin_circuit_t)); 56 mock_circuit2 = tor_malloc_zero(sizeof(origin_circuit_t)); 57 mock_global_circuitlist = smartlist_new(); 58 smartlist_add(mock_global_circuitlist, TO_CIRCUIT(mock_circuit1)); 59 smartlist_add(mock_global_circuitlist, TO_CIRCUIT(mock_circuit2)); 60 61 MOCK(circuit_get_global_list, 62 status_count_circuits_circuit_get_global_list); 63 64 actual_circuits = count_circuits(); 65 66 tt_assert(expected_circuits == actual_circuits); 67 68 done: 69 tor_free(mock_circuit1); 70 tor_free(mock_circuit2); 71 smartlist_free(mock_global_circuitlist); 72 mock_global_circuitlist = NULL; 73 UNMOCK(circuit_get_global_list); 74 } 75 76 static smartlist_t * 77 status_count_circuits_circuit_get_global_list(void) 78 { 79 return mock_global_circuitlist; 80 } 81 82 /* 83 * Test that secs_to_uptime() is converting the number of seconds that 84 * Tor is up for into the appropriate string form containing hours and minutes. 85 */ 86 87 static void 88 test_status_secs_to_uptime(void *arg) 89 { 90 const char *expected; 91 char *actual; 92 (void)arg; 93 94 expected = "0:00 hours"; 95 actual = secs_to_uptime(0); 96 tt_str_op(actual, OP_EQ, expected); 97 tor_free(actual); 98 99 expected = "0:00 hours"; 100 actual = secs_to_uptime(1); 101 tt_str_op(actual, OP_EQ, expected); 102 tor_free(actual); 103 104 expected = "0:01 hours"; 105 actual = secs_to_uptime(60); 106 tt_str_op(actual, OP_EQ, expected); 107 tor_free(actual); 108 109 expected = "0:59 hours"; 110 actual = secs_to_uptime(60 * 59); 111 tt_str_op(actual, OP_EQ, expected); 112 tor_free(actual); 113 114 expected = "1:00 hours"; 115 actual = secs_to_uptime(60 * 60); 116 tt_str_op(actual, OP_EQ, expected); 117 tor_free(actual); 118 119 expected = "23:59 hours"; 120 actual = secs_to_uptime(60 * 60 * 23 + 60 * 59); 121 tt_str_op(actual, OP_EQ, expected); 122 tor_free(actual); 123 124 expected = "1 day 0:00 hours"; 125 actual = secs_to_uptime(60 * 60 * 23 + 60 * 60); 126 tt_str_op(actual, OP_EQ, expected); 127 tor_free(actual); 128 129 expected = "1 day 0:00 hours"; 130 actual = secs_to_uptime(86400 + 1); 131 tt_str_op(actual, OP_EQ, expected); 132 tor_free(actual); 133 134 expected = "1 day 0:01 hours"; 135 actual = secs_to_uptime(86400 + 60); 136 tt_str_op(actual, OP_EQ, expected); 137 tor_free(actual); 138 139 expected = "10 days 0:00 hours"; 140 actual = secs_to_uptime(86400 * 10); 141 tt_str_op(actual, OP_EQ, expected); 142 tor_free(actual); 143 144 expected = "10 days 0:00 hours"; 145 actual = secs_to_uptime(864000 + 1); 146 tt_str_op(actual, OP_EQ, expected); 147 tor_free(actual); 148 149 expected = "10 days 0:01 hours"; 150 actual = secs_to_uptime(864000 + 60); 151 tt_str_op(actual, OP_EQ, expected); 152 tor_free(actual); 153 154 done: 155 if (actual != NULL) 156 tor_free(actual); 157 } 158 159 /* 160 * Test that bytes_to_usage() is correctly converting the number of bytes that 161 * Tor has read/written into the appropriate string form containing kilobytes, 162 * megabytes, or gigabytes. 163 */ 164 165 static void 166 test_status_bytes_to_usage(void *arg) 167 { 168 const char *expected; 169 char *actual; 170 (void)arg; 171 172 expected = "0 kB"; 173 actual = bytes_to_usage(0); 174 tt_str_op(actual, OP_EQ, expected); 175 tor_free(actual); 176 177 expected = "0 kB"; 178 actual = bytes_to_usage(1); 179 tt_str_op(actual, OP_EQ, expected); 180 tor_free(actual); 181 182 expected = "1 kB"; 183 actual = bytes_to_usage(1024); 184 tt_str_op(actual, OP_EQ, expected); 185 tor_free(actual); 186 187 expected = "1023 kB"; 188 actual = bytes_to_usage((1 << 20) - 1); 189 tt_str_op(actual, OP_EQ, expected); 190 tor_free(actual); 191 192 expected = "1.00 MB"; 193 actual = bytes_to_usage((1 << 20)); 194 tt_str_op(actual, OP_EQ, expected); 195 tor_free(actual); 196 197 expected = "1.00 MB"; 198 actual = bytes_to_usage((1 << 20) + 5242); 199 tt_str_op(actual, OP_EQ, expected); 200 tor_free(actual); 201 202 expected = "1.01 MB"; 203 actual = bytes_to_usage((1 << 20) + 5243); 204 tt_str_op(actual, OP_EQ, expected); 205 tor_free(actual); 206 207 expected = "1024.00 MB"; 208 actual = bytes_to_usage((1 << 30) - 1); 209 tt_str_op(actual, OP_EQ, expected); 210 tor_free(actual); 211 212 expected = "1.00 GB"; 213 actual = bytes_to_usage((1 << 30)); 214 tt_str_op(actual, OP_EQ, expected); 215 tor_free(actual); 216 217 expected = "1.00 GB"; 218 actual = bytes_to_usage((1 << 30) + 5368709); 219 tt_str_op(actual, OP_EQ, expected); 220 tor_free(actual); 221 222 expected = "1.01 GB"; 223 actual = bytes_to_usage((1 << 30) + 5368710); 224 tt_str_op(actual, OP_EQ, expected); 225 tor_free(actual); 226 227 expected = "10.00 GB"; 228 actual = bytes_to_usage((UINT64_C(1) << 30) * 10L); 229 tt_str_op(actual, OP_EQ, expected); 230 tor_free(actual); 231 232 done: 233 if (actual != NULL) 234 tor_free(actual); 235 } 236 237 /* 238 * Tests that log_heartbeat() fails when in the public server mode, 239 * not hibernating, and we couldn't get the current routerinfo. 240 */ 241 242 static double status_hb_fails_tls_get_write_overhead_ratio(void); 243 static int status_hb_fails_we_are_hibernating(void); 244 static int status_hb_fails_public_server_mode(const or_options_t *options); 245 static const routerinfo_t * status_hb_fails_router_get_my_routerinfo(void); 246 247 static void 248 test_status_hb_fails(void *arg) 249 { 250 int expected, actual; 251 (void)arg; 252 253 MOCK(tls_get_write_overhead_ratio, 254 status_hb_fails_tls_get_write_overhead_ratio); 255 MOCK(we_are_hibernating, 256 status_hb_fails_we_are_hibernating); 257 MOCK(public_server_mode, 258 status_hb_fails_public_server_mode); 259 MOCK(router_get_my_routerinfo, 260 status_hb_fails_router_get_my_routerinfo); 261 262 expected = -1; 263 actual = log_heartbeat(0); 264 265 tt_int_op(actual, OP_EQ, expected); 266 267 done: 268 UNMOCK(tls_get_write_overhead_ratio); 269 UNMOCK(we_are_hibernating); 270 UNMOCK(public_server_mode); 271 UNMOCK(router_get_my_routerinfo); 272 } 273 274 static double 275 status_hb_fails_tls_get_write_overhead_ratio(void) 276 { 277 return 2.0; 278 } 279 280 static int 281 status_hb_fails_we_are_hibernating(void) 282 { 283 return 0; 284 } 285 286 static int 287 status_hb_fails_public_server_mode(const or_options_t *options) 288 { 289 (void)options; 290 291 return 1; 292 } 293 294 static const routerinfo_t * 295 status_hb_fails_router_get_my_routerinfo(void) 296 { 297 return NULL; 298 } 299 300 /* 301 * Tests that log_heartbeat() logs appropriately if we are not in the cached 302 * consensus. 303 */ 304 305 static double status_hb_not_in_consensus_tls_get_write_overhead_ratio(void); 306 static int status_hb_not_in_consensus_we_are_hibernating(void); 307 static int status_hb_not_in_consensus_public_server_mode( 308 const or_options_t *options); 309 static const routerinfo_t *status_hb_not_in_consensus_get_my_routerinfo(void); 310 static const node_t * status_hb_not_in_consensus_node_get_by_id( 311 const char *identity_digest); 312 static int status_hb_not_in_consensus_server_mode(const or_options_t *options); 313 314 static routerinfo_t *mock_routerinfo; 315 316 static void 317 test_status_hb_not_in_consensus(void *arg) 318 { 319 int expected, actual; 320 (void)arg; 321 322 MOCK(tls_get_write_overhead_ratio, 323 status_hb_not_in_consensus_tls_get_write_overhead_ratio); 324 MOCK(we_are_hibernating, 325 status_hb_not_in_consensus_we_are_hibernating); 326 MOCK(public_server_mode, 327 status_hb_not_in_consensus_public_server_mode); 328 MOCK(router_get_my_routerinfo, 329 status_hb_not_in_consensus_get_my_routerinfo); 330 MOCK(node_get_by_id, 331 status_hb_not_in_consensus_node_get_by_id); 332 MOCK(server_mode, 333 status_hb_not_in_consensus_server_mode); 334 335 log_global_min_severity_ = LOG_DEBUG; 336 onion_handshakes_assigned[ONION_HANDSHAKE_TYPE_TAP] = 1; 337 onion_handshakes_requested[ONION_HANDSHAKE_TYPE_TAP] = 2; 338 onion_handshakes_assigned[ONION_HANDSHAKE_TYPE_NTOR] = 3; 339 onion_handshakes_requested[ONION_HANDSHAKE_TYPE_NTOR] = 4; 340 onion_handshakes_assigned[ONION_HANDSHAKE_TYPE_NTOR_V3] = 5; 341 onion_handshakes_requested[ONION_HANDSHAKE_TYPE_NTOR_V3] = 6; 342 343 expected = 0; 344 setup_capture_of_logs(LOG_INFO); 345 actual = log_heartbeat(0); 346 tt_int_op(actual, OP_EQ, expected); 347 348 expect_log_msg("Heartbeat: It seems like we are " 349 "not in the cached consensus.\n"); 350 expect_log_msg("Heartbeat: Tor's uptime is 0:00 hours, " 351 "with 0 circuits open. " 352 "I've sent 0 kB and received 0 kB. " 353 "I've received 0 connections on IPv4 and 0 on IPv6. " 354 "I've made 0 connections with IPv4 and 0 with IPv6.\n"); 355 expect_log_msg("Average packaged cell fullness: 100.000%. " 356 "TLS write overhead: 0%\n"); 357 expect_log_msg("Circuit handshake stats since last time: 1/2 TAP, " 358 "3/4 NTor, 5/6 NTor (v3).\n"); 359 expect_log_msg("Since startup we initiated 0 and received 0 v1 " 360 "connections; initiated 0 and received 0 v2 connections; " 361 "initiated 0 and received 0 v3 connections; " 362 "initiated 0 and received 0 v4 connections; " 363 "initiated 0 and received 0 v5 connections.\n"); 364 expect_log_msg("Heartbeat: DoS mitigation since startup: 0 circuits killed " 365 "with too many cells, [DoSCircuitCreationEnabled disabled], " 366 "[DoSConnectionEnabled disabled], " 367 "[DoSRefuseSingleHopClientRendezvous disabled], " 368 "[DoSStreamCreationEnabled disabled], " 369 "0 INTRODUCE2 rejected.\n"); 370 tt_int_op(mock_saved_log_n_entries(), OP_EQ, 6); 371 372 done: 373 teardown_capture_of_logs(); 374 UNMOCK(tls_get_write_overhead_ratio); 375 UNMOCK(we_are_hibernating); 376 UNMOCK(public_server_mode); 377 UNMOCK(router_get_my_routerinfo); 378 UNMOCK(node_get_by_id); 379 UNMOCK(server_mode); 380 tor_free(mock_routerinfo); 381 } 382 383 static double 384 status_hb_not_in_consensus_tls_get_write_overhead_ratio(void) 385 { 386 return 1.0; 387 } 388 389 static int 390 status_hb_not_in_consensus_we_are_hibernating(void) 391 { 392 return 0; 393 } 394 395 static int 396 status_hb_not_in_consensus_public_server_mode(const or_options_t *options) 397 { 398 (void)options; 399 400 return 1; 401 } 402 403 static const routerinfo_t * 404 status_hb_not_in_consensus_get_my_routerinfo(void) 405 { 406 mock_routerinfo = tor_malloc(sizeof(routerinfo_t)); 407 408 return mock_routerinfo; 409 } 410 411 static const node_t * 412 status_hb_not_in_consensus_node_get_by_id(const char *identity_digest) 413 { 414 (void)identity_digest; 415 416 return NULL; 417 } 418 419 static int 420 status_hb_not_in_consensus_server_mode(const or_options_t *options) 421 { 422 (void)options; 423 424 return 0; 425 } 426 427 /* 428 * Tests that log_heartbeat() correctly logs heartbeat information 429 * normally. 430 */ 431 432 static double status_hb_simple_tls_get_write_overhead_ratio(void); 433 static int status_hb_simple_we_are_hibernating(void); 434 static int status_hb_simple_public_server_mode(const or_options_t *options); 435 static long status_hb_simple_get_uptime(void); 436 static uint64_t status_hb_simple_get_bytes_read(void); 437 static uint64_t status_hb_simple_get_bytes_written(void); 438 static int status_hb_simple_server_mode(const or_options_t *options); 439 440 static void 441 test_status_hb_simple(void *arg) 442 { 443 int expected, actual; 444 (void)arg; 445 446 MOCK(tls_get_write_overhead_ratio, 447 status_hb_simple_tls_get_write_overhead_ratio); 448 MOCK(we_are_hibernating, 449 status_hb_simple_we_are_hibernating); 450 MOCK(public_server_mode, 451 status_hb_simple_public_server_mode); 452 MOCK(get_uptime, 453 status_hb_simple_get_uptime); 454 MOCK(get_bytes_read, 455 status_hb_simple_get_bytes_read); 456 MOCK(get_bytes_written, 457 status_hb_simple_get_bytes_written); 458 MOCK(server_mode, 459 status_hb_simple_server_mode); 460 461 log_global_min_severity_ = LOG_DEBUG; 462 463 setup_capture_of_logs(LOG_INFO); 464 expected = 0; 465 actual = log_heartbeat(0); 466 467 tt_int_op(actual, OP_EQ, expected); 468 469 expect_log_msg("Heartbeat: Tor's uptime is 0:00 hours, " 470 "with 0 circuits open. " 471 "I've sent 0 kB and received 0 kB. " 472 "I've received 0 connections on IPv4 and 0 on IPv6. " 473 "I've made 0 connections with IPv4 and 0 with IPv6. " 474 "We are currently hibernating.\n"); 475 476 done: 477 teardown_capture_of_logs(); 478 UNMOCK(tls_get_write_overhead_ratio); 479 UNMOCK(we_are_hibernating); 480 UNMOCK(public_server_mode); 481 UNMOCK(get_uptime); 482 UNMOCK(get_bytes_read); 483 UNMOCK(get_bytes_written); 484 UNMOCK(server_mode); 485 } 486 487 static double 488 status_hb_simple_tls_get_write_overhead_ratio(void) 489 { 490 return 1.0; 491 } 492 493 static int 494 status_hb_simple_we_are_hibernating(void) 495 { 496 return 1; 497 } 498 499 static int 500 status_hb_simple_public_server_mode(const or_options_t *options) 501 { 502 (void)options; 503 504 return 0; 505 } 506 507 static long 508 status_hb_simple_get_uptime(void) 509 { 510 return 0; 511 } 512 513 static uint64_t 514 status_hb_simple_get_bytes_read(void) 515 { 516 return 0; 517 } 518 519 static uint64_t 520 status_hb_simple_get_bytes_written(void) 521 { 522 return 0; 523 } 524 525 static int 526 status_hb_simple_server_mode(const or_options_t *options) 527 { 528 (void)options; 529 530 return 0; 531 } 532 533 /* 534 * Tests that log_heartbeat() correctly logs heartbeat information 535 * and accounting information when configured. 536 */ 537 538 static double status_hb_calls_log_accounting_tls_get_write_overhead_ratio( 539 void); 540 static int status_hb_calls_log_accounting_we_are_hibernating(void); 541 static int status_hb_calls_log_accounting_public_server_mode( 542 const or_options_t *options); 543 static long status_hb_calls_log_accounting_get_uptime(void); 544 static uint64_t status_hb_calls_log_accounting_get_bytes_read(void); 545 static uint64_t status_hb_calls_log_accounting_get_bytes_written(void); 546 static int status_hb_calls_log_accounting_server_mode( 547 const or_options_t *options); 548 static or_state_t * status_hb_calls_log_accounting_get_or_state(void); 549 static int status_hb_calls_log_accounting_accounting_is_enabled( 550 const or_options_t *options); 551 static time_t status_hb_calls_log_accounting_accounting_get_end_time(void); 552 553 static or_state_t * status_hb_calls_log_accounting_mock_state = NULL; 554 static or_options_t * status_hb_calls_log_accounting_mock_options = NULL; 555 556 static void 557 test_status_hb_calls_log_accounting(void *arg) 558 { 559 int expected, actual; 560 (void)arg; 561 562 MOCK(tls_get_write_overhead_ratio, 563 status_hb_calls_log_accounting_tls_get_write_overhead_ratio); 564 MOCK(we_are_hibernating, 565 status_hb_calls_log_accounting_we_are_hibernating); 566 MOCK(public_server_mode, 567 status_hb_calls_log_accounting_public_server_mode); 568 MOCK(get_uptime, 569 status_hb_calls_log_accounting_get_uptime); 570 MOCK(get_bytes_read, 571 status_hb_calls_log_accounting_get_bytes_read); 572 MOCK(get_bytes_written, 573 status_hb_calls_log_accounting_get_bytes_written); 574 MOCK(server_mode, 575 status_hb_calls_log_accounting_server_mode); 576 MOCK(get_or_state, 577 status_hb_calls_log_accounting_get_or_state); 578 MOCK(accounting_is_enabled, 579 status_hb_calls_log_accounting_accounting_is_enabled); 580 MOCK(accounting_get_end_time, 581 status_hb_calls_log_accounting_accounting_get_end_time); 582 583 log_global_min_severity_ = LOG_DEBUG; 584 585 setup_capture_of_logs(LOG_NOTICE); 586 expected = 0; 587 actual = log_heartbeat(0); 588 589 tt_int_op(actual, OP_EQ, expected); 590 591 expect_log_msg("Heartbeat: Tor's uptime is 0:00 hours, " 592 "with 0 circuits open. " 593 "I've sent 0 kB and received 0 kB. " 594 "I've received 0 connections on IPv4 and 0 on IPv6. " 595 "I've made 0 connections with IPv4 and 0 with IPv6.\n"); 596 597 expect_log_msg_containing("Heartbeat: Accounting enabled. Sent: 0 kB, " 598 "Received: 0 kB, Used: 0 kB / 0 kB, Rule: max. " 599 "The current accounting interval ends on "); 600 tt_int_op(mock_saved_log_n_entries(), OP_EQ, 2); 601 602 done: 603 teardown_capture_of_logs(); 604 UNMOCK(tls_get_write_overhead_ratio); 605 UNMOCK(we_are_hibernating); 606 UNMOCK(public_server_mode); 607 UNMOCK(get_uptime); 608 UNMOCK(get_bytes_read); 609 UNMOCK(get_bytes_written); 610 UNMOCK(server_mode); 611 UNMOCK(accounting_is_enabled); 612 UNMOCK(accounting_get_end_time); 613 tor_free_(status_hb_calls_log_accounting_mock_state); 614 tor_free_(status_hb_calls_log_accounting_mock_options); 615 } 616 617 static double 618 status_hb_calls_log_accounting_tls_get_write_overhead_ratio(void) 619 { 620 return 1.0; 621 } 622 623 static int 624 status_hb_calls_log_accounting_we_are_hibernating(void) 625 { 626 return 0; 627 } 628 629 static int 630 status_hb_calls_log_accounting_public_server_mode(const or_options_t *options) 631 { 632 (void)options; 633 634 return 0; 635 } 636 637 static long 638 status_hb_calls_log_accounting_get_uptime(void) 639 { 640 return 0; 641 } 642 643 static uint64_t 644 status_hb_calls_log_accounting_get_bytes_read(void) 645 { 646 return 0; 647 } 648 649 static uint64_t 650 status_hb_calls_log_accounting_get_bytes_written(void) 651 { 652 return 0; 653 } 654 655 static int 656 status_hb_calls_log_accounting_server_mode(const or_options_t *options) 657 { 658 (void)options; 659 660 return 1; 661 } 662 663 static int 664 status_hb_calls_log_accounting_accounting_is_enabled( 665 const or_options_t *options) 666 { 667 (void)options; 668 669 return 1; 670 } 671 672 static time_t 673 status_hb_calls_log_accounting_accounting_get_end_time(void) 674 { 675 return 60; 676 } 677 678 static or_state_t * 679 status_hb_calls_log_accounting_get_or_state(void) 680 { 681 status_hb_calls_log_accounting_mock_state = 682 tor_malloc_zero(sizeof(or_state_t)); 683 status_hb_calls_log_accounting_mock_state 684 ->AccountingBytesReadInInterval = 0; 685 status_hb_calls_log_accounting_mock_state 686 ->AccountingBytesWrittenInInterval = 0; 687 688 return status_hb_calls_log_accounting_mock_state; 689 } 690 691 /* 692 * Tests that log_heartbeat() correctly logs packaged cell 693 * fullness information. 694 */ 695 696 static double status_hb_packaged_cell_fullness_tls_get_write_overhead_ratio( 697 void); 698 static int status_hb_packaged_cell_fullness_we_are_hibernating(void); 699 static int status_hb_packaged_cell_fullness_public_server_mode( 700 const or_options_t *options); 701 static long status_hb_packaged_cell_fullness_get_uptime(void); 702 static uint64_t status_hb_packaged_cell_fullness_get_bytes_read(void); 703 static uint64_t status_hb_packaged_cell_fullness_get_bytes_written(void); 704 static int status_hb_packaged_cell_fullness_server_mode( 705 const or_options_t *options); 706 static int status_hb_packaged_cell_fullness_accounting_is_enabled( 707 const or_options_t *options); 708 709 static void 710 test_status_hb_packaged_cell_fullness(void *arg) 711 { 712 int expected, actual; 713 (void)arg; 714 715 MOCK(tls_get_write_overhead_ratio, 716 status_hb_packaged_cell_fullness_tls_get_write_overhead_ratio); 717 MOCK(we_are_hibernating, 718 status_hb_packaged_cell_fullness_we_are_hibernating); 719 MOCK(public_server_mode, 720 status_hb_packaged_cell_fullness_public_server_mode); 721 MOCK(get_uptime, 722 status_hb_packaged_cell_fullness_get_uptime); 723 MOCK(get_bytes_read, 724 status_hb_packaged_cell_fullness_get_bytes_read); 725 MOCK(get_bytes_written, 726 status_hb_packaged_cell_fullness_get_bytes_written); 727 MOCK(server_mode, 728 status_hb_packaged_cell_fullness_server_mode); 729 MOCK(accounting_is_enabled, 730 status_hb_packaged_cell_fullness_accounting_is_enabled); 731 log_global_min_severity_ = LOG_DEBUG; 732 733 stats_n_data_bytes_packaged = RELAY_PAYLOAD_SIZE; 734 stats_n_data_cells_packaged = 2; 735 expected = 0; 736 setup_capture_of_logs(LOG_INFO); 737 actual = log_heartbeat(0); 738 739 tt_int_op(actual, OP_EQ, expected); 740 expect_log_msg("Heartbeat: Tor's uptime is 0:00 hours, " 741 "with 0 circuits open. " 742 "I've sent 0 kB and received 0 kB. " 743 "I've received 0 connections on IPv4 and 0 on IPv6. " 744 "I've made 0 connections with IPv4 and 0 with IPv6.\n"); 745 expect_log_msg("Average packaged cell fullness: 50.000%. " 746 "TLS write overhead: 0%\n"); 747 748 done: 749 teardown_capture_of_logs(); 750 stats_n_data_bytes_packaged = 0; 751 stats_n_data_cells_packaged = 0; 752 UNMOCK(tls_get_write_overhead_ratio); 753 UNMOCK(we_are_hibernating); 754 UNMOCK(public_server_mode); 755 UNMOCK(get_uptime); 756 UNMOCK(get_bytes_read); 757 UNMOCK(get_bytes_written); 758 UNMOCK(server_mode); 759 UNMOCK(accounting_is_enabled); 760 } 761 762 static double 763 status_hb_packaged_cell_fullness_tls_get_write_overhead_ratio(void) 764 { 765 return 1.0; 766 } 767 768 static int 769 status_hb_packaged_cell_fullness_we_are_hibernating(void) 770 { 771 return 0; 772 } 773 774 static int 775 status_hb_packaged_cell_fullness_public_server_mode( 776 const or_options_t *options) 777 { 778 (void)options; 779 780 return 0; 781 } 782 783 static long 784 status_hb_packaged_cell_fullness_get_uptime(void) 785 { 786 return 0; 787 } 788 789 static uint64_t 790 status_hb_packaged_cell_fullness_get_bytes_read(void) 791 { 792 return 0; 793 } 794 795 static uint64_t 796 status_hb_packaged_cell_fullness_get_bytes_written(void) 797 { 798 return 0; 799 } 800 801 static int 802 status_hb_packaged_cell_fullness_server_mode(const or_options_t *options) 803 { 804 (void)options; 805 806 return 0; 807 } 808 809 static int 810 status_hb_packaged_cell_fullness_accounting_is_enabled( 811 const or_options_t *options) 812 { 813 (void)options; 814 815 return 0; 816 } 817 818 /* 819 * Tests that log_heartbeat() correctly logs the TLS write overhead information 820 * when the TLS write overhead ratio exceeds 1. 821 */ 822 823 static double status_hb_tls_write_overhead_tls_get_write_overhead_ratio(void); 824 static int status_hb_tls_write_overhead_we_are_hibernating(void); 825 static int status_hb_tls_write_overhead_public_server_mode( 826 const or_options_t *options); 827 static long status_hb_tls_write_overhead_get_uptime(void); 828 static uint64_t status_hb_tls_write_overhead_get_bytes_read(void); 829 static uint64_t status_hb_tls_write_overhead_get_bytes_written(void); 830 static int status_hb_tls_write_overhead_server_mode( 831 const or_options_t *options); 832 static int status_hb_tls_write_overhead_accounting_is_enabled( 833 const or_options_t *options); 834 835 static void 836 test_status_hb_tls_write_overhead(void *arg) 837 { 838 int expected, actual; 839 (void)arg; 840 841 MOCK(tls_get_write_overhead_ratio, 842 status_hb_tls_write_overhead_tls_get_write_overhead_ratio); 843 MOCK(we_are_hibernating, 844 status_hb_tls_write_overhead_we_are_hibernating); 845 MOCK(public_server_mode, 846 status_hb_tls_write_overhead_public_server_mode); 847 MOCK(get_uptime, 848 status_hb_tls_write_overhead_get_uptime); 849 MOCK(get_bytes_read, 850 status_hb_tls_write_overhead_get_bytes_read); 851 MOCK(get_bytes_written, 852 status_hb_tls_write_overhead_get_bytes_written); 853 MOCK(server_mode, 854 status_hb_tls_write_overhead_server_mode); 855 MOCK(accounting_is_enabled, 856 status_hb_tls_write_overhead_accounting_is_enabled); 857 stats_n_data_cells_packaged = 0; 858 log_global_min_severity_ = LOG_DEBUG; 859 860 expected = 0; 861 setup_capture_of_logs(LOG_NOTICE); 862 actual = log_heartbeat(0); 863 864 tt_int_op(actual, OP_EQ, expected); 865 expect_log_msg("Heartbeat: Tor's uptime is 0:00 hours, " 866 "with 0 circuits open. " 867 "I've sent 0 kB and received 0 kB. " 868 "I've received 0 connections on IPv4 and 0 on IPv6. " 869 "I've made 0 connections with IPv4 and 0 with IPv6.\n"); 870 expect_log_msg("Average packaged cell fullness: 100.000%. " 871 "TLS write overhead: 100%\n"); 872 873 done: 874 teardown_capture_of_logs(); 875 UNMOCK(tls_get_write_overhead_ratio); 876 UNMOCK(we_are_hibernating); 877 UNMOCK(public_server_mode); 878 UNMOCK(get_uptime); 879 UNMOCK(get_bytes_read); 880 UNMOCK(get_bytes_written); 881 UNMOCK(server_mode); 882 UNMOCK(accounting_is_enabled); 883 } 884 885 static double 886 status_hb_tls_write_overhead_tls_get_write_overhead_ratio(void) 887 { 888 return 2.0; 889 } 890 891 static int 892 status_hb_tls_write_overhead_we_are_hibernating(void) 893 { 894 return 0; 895 } 896 897 static int 898 status_hb_tls_write_overhead_public_server_mode(const or_options_t *options) 899 { 900 (void)options; 901 902 return 0; 903 } 904 905 static long 906 status_hb_tls_write_overhead_get_uptime(void) 907 { 908 return 0; 909 } 910 911 static uint64_t 912 status_hb_tls_write_overhead_get_bytes_read(void) 913 { 914 return 0; 915 } 916 917 static uint64_t 918 status_hb_tls_write_overhead_get_bytes_written(void) 919 { 920 return 0; 921 } 922 923 static int 924 status_hb_tls_write_overhead_server_mode(const or_options_t *options) 925 { 926 (void)options; 927 928 return 0; 929 } 930 931 static int 932 status_hb_tls_write_overhead_accounting_is_enabled(const or_options_t *options) 933 { 934 (void)options; 935 936 return 0; 937 } 938 939 struct testcase_t status_tests[] = { 940 { "count_circuits", test_status_count_circuits, TT_FORK, NULL, NULL }, 941 { "secs_to_uptime", test_status_secs_to_uptime, TT_FORK, NULL, NULL }, 942 { "bytes_to_usage", test_status_bytes_to_usage, TT_FORK, NULL, NULL }, 943 { "hb_fails", test_status_hb_fails, TT_FORK, NULL, NULL }, 944 { "hb_simple", test_status_hb_simple, TT_FORK, NULL, NULL }, 945 { "hb_not_in_consensus", test_status_hb_not_in_consensus, 946 TT_FORK, NULL, NULL }, 947 { "hb_calls_log_accounting", test_status_hb_calls_log_accounting, 948 TT_FORK, NULL, NULL }, 949 { "hb_packaged_cell_fullness", test_status_hb_packaged_cell_fullness, 950 TT_FORK, NULL, NULL }, 951 { "hb_tls_write_overhead", test_status_hb_tls_write_overhead, 952 TT_FORK, NULL, NULL }, 953 END_OF_TESTCASES 954 };