static void test_exit( void )
{
MOCK_1_CALL( 0, deregister_mtd_blktrans, &blockrom_tr );
_mock_exit_cb();
TEST_ASSERT( _deregister_mtd_blktrans_called_count, 0, int );
MOCK_RESET( deregister_mtd_blktrans );
}
static void test_init( void )
{
const int init_ret = 12345;
MOCK_1_CALL( init_ret, register_mtd_blktrans, &blockrom_tr );
TEST_ASSERT( init_ret, _mock_init_cb(), int );
TEST_ASSERT( _register_mtd_blktrans_called_count, 0, int );
MOCK_RESET( register_mtd_blktrans );
}
/* Tests for connection_edge_process_resolved_cell().
The point of ..process_resolved_cell() is to handle an incoming cell
on an entry connection, and call connection_mark_unattached_ap() and/or
connection_ap_handshake_socks_resolved().
*/
static void
test_relaycell_resolved(void *arg)
{
entry_connection_t *entryconn;
edge_connection_t *edgeconn;
cell_t cell;
relay_header_t rh;
int r;
or_options_t *options = get_options_mutable();
#define SET_CELL(s) do { \
memset(&cell, 0, sizeof(cell)); \
memset(&rh, 0, sizeof(rh)); \
memcpy(cell.payload + RELAY_HEADER_SIZE, (s), sizeof((s))-1); \
rh.length = sizeof((s))-1; \
rh.command = RELAY_COMMAND_RESOLVED; \
} while (0)
#define MOCK_RESET() do { \
srm_ncalls = mum_ncalls = 0; \
} while (0)
#define ASSERT_MARK_CALLED(reason) do { \
tt_int_op(mum_ncalls, OP_EQ, 1); \
tt_ptr_op(mum_conn, OP_EQ, entryconn); \
tt_int_op(mum_endreason, OP_EQ, (reason)); \
} while (0)
#define ASSERT_RESOLVED_CALLED(atype, answer, ttl, expires) do { \
tt_int_op(srm_ncalls, OP_EQ, 1); \
tt_ptr_op(srm_conn, OP_EQ, entryconn); \
tt_int_op(srm_atype, OP_EQ, (atype)); \
if ((answer) != NULL) { \
tt_int_op(srm_alen, OP_EQ, sizeof(answer)-1); \
tt_int_op(srm_alen, OP_LT, 512); \
tt_int_op(srm_answer_is_set, OP_EQ, 1); \
tt_mem_op(srm_answer, OP_EQ, answer, sizeof(answer)-1); \
} else { \
tt_int_op(srm_answer_is_set, OP_EQ, 0); \
} \
tt_int_op(srm_ttl, OP_EQ, ttl); \
tt_i64_op(srm_expires, OP_EQ, expires); \
} while (0)
(void)arg;
MOCK(connection_mark_unattached_ap_, mark_unattached_mock);
MOCK(connection_ap_handshake_socks_resolved, socks_resolved_mock);
options->ClientDNSRejectInternalAddresses = 0;
SET_CELL(/* IPv4: 127.0.1.2, ttl 256 */
"\x04\x04\x7f\x00\x01\x02\x00\x00\x01\x00"
/* IPv4: 18.0.0.1, ttl 512 */
"\x04\x04\x12\x00\x00\x01\x00\x00\x02\x00"
/* IPv6: 2003::3, ttl 1024 */
"\x06\x10"
"\x20\x02\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x03"
"\x00\x00\x04\x00");
entryconn = entry_connection_new(CONN_TYPE_AP, AF_INET);
edgeconn = ENTRY_TO_EDGE_CONN(entryconn);
/* Try with connection in non-RESOLVE_WAIT state: cell gets ignored */
MOCK_RESET();
r = connection_edge_process_resolved_cell(edgeconn, &cell, &rh);
tt_int_op(r, OP_EQ, 0);
tt_int_op(srm_ncalls, OP_EQ, 0);
tt_int_op(mum_ncalls, OP_EQ, 0);
/* Now put it in the right state. */
ENTRY_TO_CONN(entryconn)->state = AP_CONN_STATE_RESOLVE_WAIT;
entryconn->socks_request->command = SOCKS_COMMAND_RESOLVE;
entryconn->entry_cfg.ipv4_traffic = 1;
entryconn->entry_cfg.ipv6_traffic = 1;
entryconn->entry_cfg.prefer_ipv6 = 0;
/* We prefer ipv4, so we should get the first ipv4 answer */
MOCK_RESET();
r = connection_edge_process_resolved_cell(edgeconn, &cell, &rh);
tt_int_op(r, OP_EQ, 0);
ASSERT_MARK_CALLED(END_STREAM_REASON_DONE|
END_STREAM_REASON_FLAG_ALREADY_SOCKS_REPLIED);
ASSERT_RESOLVED_CALLED(RESOLVED_TYPE_IPV4, "\x7f\x00\x01\x02", 256, -1);
/* But we may be discarding private answers. */
MOCK_RESET();
options->ClientDNSRejectInternalAddresses = 1;
r = connection_edge_process_resolved_cell(edgeconn, &cell, &rh);
tt_int_op(r, OP_EQ, 0);
ASSERT_MARK_CALLED(END_STREAM_REASON_DONE|
END_STREAM_REASON_FLAG_ALREADY_SOCKS_REPLIED);
ASSERT_RESOLVED_CALLED(RESOLVED_TYPE_IPV4, "\x12\x00\x00\x01", 512, -1);
/* now prefer ipv6, and get the first ipv6 answer */
entryconn->entry_cfg.prefer_ipv6 = 1;
MOCK_RESET();
r = connection_edge_process_resolved_cell(edgeconn, &cell, &rh);
tt_int_op(r, OP_EQ, 0);
ASSERT_MARK_CALLED(END_STREAM_REASON_DONE|
END_STREAM_REASON_FLAG_ALREADY_SOCKS_REPLIED);
ASSERT_RESOLVED_CALLED(RESOLVED_TYPE_IPV6,
"\x20\x02\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x03",
1024, -1);
/* With a cell that only has IPv4, we report IPv4 even if we prefer IPv6 */
MOCK_RESET();
SET_CELL("\x04\x04\x12\x00\x00\x01\x00\x00\x02\x00");
r = connection_edge_process_resolved_cell(edgeconn, &cell, &rh);
tt_int_op(r, OP_EQ, 0);
ASSERT_MARK_CALLED(END_STREAM_REASON_DONE|
END_STREAM_REASON_FLAG_ALREADY_SOCKS_REPLIED);
ASSERT_RESOLVED_CALLED(RESOLVED_TYPE_IPV4, "\x12\x00\x00\x01", 512, -1);
/* But if we don't allow IPv4, we report nothing if the cell contains only
* ipv4 */
MOCK_RESET();
entryconn->entry_cfg.ipv4_traffic = 0;
r = connection_edge_process_resolved_cell(edgeconn, &cell, &rh);
tt_int_op(r, OP_EQ, 0);
ASSERT_MARK_CALLED(END_STREAM_REASON_DONE|
END_STREAM_REASON_FLAG_ALREADY_SOCKS_REPLIED);
ASSERT_RESOLVED_CALLED(RESOLVED_TYPE_ERROR, NULL, -1, -1);
/* If we wanted hostnames, we report nothing, since we only had IPs. */
MOCK_RESET();
entryconn->entry_cfg.ipv4_traffic = 1;
entryconn->socks_request->command = SOCKS_COMMAND_RESOLVE_PTR;
r = connection_edge_process_resolved_cell(edgeconn, &cell, &rh);
tt_int_op(r, OP_EQ, 0);
ASSERT_MARK_CALLED(END_STREAM_REASON_DONE|
END_STREAM_REASON_FLAG_ALREADY_SOCKS_REPLIED);
ASSERT_RESOLVED_CALLED(RESOLVED_TYPE_ERROR, NULL, -1, -1);
/* A hostname cell is fine though. */
MOCK_RESET();
SET_CELL("\x00\x0fwww.example.com\x00\x01\x00\x00");
r = connection_edge_process_resolved_cell(edgeconn, &cell, &rh);
tt_int_op(r, OP_EQ, 0);
ASSERT_MARK_CALLED(END_STREAM_REASON_DONE|
END_STREAM_REASON_FLAG_ALREADY_SOCKS_REPLIED);
ASSERT_RESOLVED_CALLED(RESOLVED_TYPE_HOSTNAME, "www.example.com", 65536, -1);
/* error on malformed cell */
MOCK_RESET();
entryconn->socks_request->command = SOCKS_COMMAND_RESOLVE;
SET_CELL("\x04\x04\x01\x02\x03\x04"); /* no ttl */
r = connection_edge_process_resolved_cell(edgeconn, &cell, &rh);
tt_int_op(r, OP_EQ, 0);
ASSERT_MARK_CALLED(END_STREAM_REASON_TORPROTOCOL);
tt_int_op(srm_ncalls, OP_EQ, 0);
/* error on all addresses private */
MOCK_RESET();
SET_CELL(/* IPv4: 127.0.1.2, ttl 256 */
"\x04\x04\x7f\x00\x01\x02\x00\x00\x01\x00"
/* IPv4: 192.168.1.1, ttl 256 */
"\x04\x04\xc0\xa8\x01\x01\x00\x00\x01\x00");
r = connection_edge_process_resolved_cell(edgeconn, &cell, &rh);
tt_int_op(r, OP_EQ, 0);
ASSERT_MARK_CALLED(END_STREAM_REASON_TORPROTOCOL);
ASSERT_RESOLVED_CALLED(RESOLVED_TYPE_ERROR_TRANSIENT, NULL, 0, TIME_MAX);
/* Legit error code */
MOCK_RESET();
SET_CELL("\xf0\x15" "quiet and meaningless" "\x00\x00\x0f\xff");
r = connection_edge_process_resolved_cell(edgeconn, &cell, &rh);
tt_int_op(r, OP_EQ, 0);
ASSERT_MARK_CALLED(END_STREAM_REASON_DONE|
END_STREAM_REASON_FLAG_ALREADY_SOCKS_REPLIED);
ASSERT_RESOLVED_CALLED(RESOLVED_TYPE_ERROR_TRANSIENT, NULL, -1, -1);
done:
UNMOCK(connection_mark_unattached_ap_);
UNMOCK(connection_ap_handshake_socks_resolved);
}
static void test_add( void )
{
struct mtd_blktrans_ops test_ops;
struct mtd_info test_mtd;
struct mtd_block_map test_map;
const unsigned int nr_of_ebs = 4;
uint32_t block_map_mem[ nr_of_ebs ];
#ifdef CONFIG_MTD_BLOCK_ROM_DELAYED_INIT
struct task_struct task;
test_ops.name = "spargel";
test_mtd.index = 1954;
#endif
test_mtd.erasesize = 128 * 1024;
test_mtd.size = test_mtd.erasesize * nr_of_ebs;
test_mtd.block_isbad = mtd_block_isbad;
memset( &test_map, 0x00, sizeof(test_map));
memset( &block_map_mem, 0x00, sizeof(block_map_mem));
MOCK_2_CALL( &test_map, kzalloc, sizeof(test_map), GFP_KERNEL );
MOCK_2_CALL( &block_map_mem, kzalloc, sizeof(block_map_mem), GFP_KERNEL );
#ifdef CONFIG_MTD_BLOCK_ROM_DELAYED_INIT
MOCK_5_CALL( &task, kthread_run, blockrom_add_bottom, &test_map, DONT_CHECK_PARAM,
test_ops.name, test_mtd.index );
MOCK_CB_SET( kthread_run, my_kthread_run );
#endif
MOCK_2_CALL( 0, mtd_block_isbad, &test_mtd, test_mtd.erasesize * 0);
MOCK_2_CALL( 0, mtd_block_isbad, &test_mtd, test_mtd.erasesize * 1);
MOCK_2_CALL( 1, mtd_block_isbad, &test_mtd, test_mtd.erasesize * 2);
MOCK_2_CALL( 0, mtd_block_isbad, &test_mtd, test_mtd.erasesize * 3);
MOCK_1_CALL( 0, add_mtd_blktrans_dev, &test_map.dev );
blockrom_tr.add_mtd( &test_ops, &test_mtd );
TEST_ASSERT( test_map.dev.mtd, &test_mtd, struct mtd_info *);
TEST_ASSERT( test_map.block_map, (uint32_t *)&block_map_mem, uint32_t *);
TEST_ASSERT( test_map.dev.tr, &test_ops, struct mtd_blktrans_ops* );
TEST_ASSERT( nr_of_ebs, test_map.blocks_total, uint32_t);
TEST_ASSERT( 1, test_map.blocks_bad, uint32_t);
/* check HDD size (in 512 byte blocks); we have 1 bad eraseblock */
TEST_ASSERT( test_map.dev.size, (test_mtd.size - test_mtd.erasesize) / 512, uint32_t);
TEST_ASSERT( test_map.dev.readonly, 1, int);
TEST_ASSERT( test_map.block_map[ 0 ], 0, uint32_t );
TEST_ASSERT( test_map.block_map[ 1 ], 1, uint32_t );
TEST_ASSERT( test_map.block_map[ 2 ], 3, uint32_t );
TEST_ASSERT( test_map.block_map[ 3 ], 4, uint32_t );
TEST_ASSERT_CALLED( kzalloc, 2);
TEST_ASSERT_CALLED( mtd_block_isbad, nr_of_ebs);
TEST_ASSERT_CALLED( add_mtd_blktrans_dev, 1);
MOCK_RESET( kzalloc );
MOCK_RESET( mtd_block_isbad );
MOCK_RESET( add_mtd_blktrans_dev );
#ifdef CONFIG_MTD_BLOCK_ROM_DELAYED_INIT
MOCK_RESET( kthread_run );
MOCK_CB_CLEAR( kthread_run );
#endif
}
