void debug_print_clients() {
int i;
for( i=0 ; i<CLIENT_MAX_NUM ; i++ ) {
Client *c = clients_get(i);
fprintf( stderr, "[%d] valid = %d\tsocket = %d\n", i, c->valid, c->socket );
}
}
int clients_new_from_fh(int fh, int proto, int byteorder, int update_nnode) {
struct roar_client * c;
int client;
if ( fh == -1 )
return -1;
if ( proto != ROAR_PROTO_ROARAUDIO || byteorder != ROAR_BYTEORDER_NETWORK )
return -1;
if ( (client = clients_new()) == -1 )
return -1;
if ( clients_set_fh(client, fh) == -1 ) {
clients_delete(client);
return -1;
}
if ( update_nnode ) {
if ( clients_get(client, &c) != -1 ) {
if ( roar_nnode_free(&(c->nnode)) != -1 ) {
roar_nnode_new_from_fh(&(c->nnode), fh, 1);
}
}
}
return 0;
}
void cmd_who(int connfd) {
char content[SIZE_SEND_BUFF] = "<ID>\t<nickname>\t<IP/port>\t<indicate me>\n";
char t_s[TMP_STRING_SIZE];
int i;
Client *c;
for( i=0 ; i<CLIENT_MAX_NUM ; i++ ) {
c = clients_get(i);
if(c->valid == FALSE) continue;
sprintf(t_s, "%d\t%s\t%s/%d", i+1, c->name, c->ip, c->port);
if(c->socket == connfd) {
strcat(t_s, "\t<-me\n");
} else {
strcat(t_s, "\n");
}
strcat(content, t_s);
}
snprintf(send_buff, sizeof(send_buff), content);
write(connfd, send_buff, strlen(send_buff));
}
void cmd_tell(int connfd, int target_id, char *buff) {
Client *c = clients_get(target_id);
char valid = c->valid;
if(!valid) {
sprintf(send_buff, "*** Error: user #%d does not exist yet. ***\n", target_id+1);
write(connfd, send_buff, strlen(send_buff));
} else {
broadcast_cmd_tell(connfd, target_id, buff);
}
}
int emul_esd_test_byteorder(int client, void * data) {
struct roar_client * c;
if ( clients_get(client, &c) == -1 )
return -1;
// "NDNE";
if ( !memcmp(data, "NDNE", 4) ) {
c->byteorder = ROAR_BYTEORDER_LE;
} else if ( !memcmp(data, "ENDE", 4) ) {
c->byteorder = ROAR_BYTEORDER_BE;
} else if ( !memcmp(data, "NEED", 4) ) {
c->byteorder = ROAR_BYTEORDER_PDP;
} else {
return -1;
}
return 0;
}
void cmd_name(int connfd, char *name) {
// if already exisits
int i;
Client *c;
for( i=0 ; i<CLIENT_MAX_NUM ; i++ ) {
c = clients_get(i);
if(strcmp(c->name, name) == 0) {
sprintf(send_buff, "*** User '%s' already exists. ***\n", name);
write(connfd, send_buff, strlen(send_buff));
return;
}
}
c = clients_get_from_socket(connfd);
strcpy(c->name, name);
broadcast_cmd_name(connfd);
}
void TestBT_Peer_share_20_pieces(CuTest * tc)
{
int num_pieces;
int ii;
client_t* a, *b;
hashmap_iterator_t iter;
void* mt;
char *addr;
num_pieces = 50;
clients_setup();
mt = mocktorrent_new(num_pieces, 5);
a = mock_client_setup(5);
b = mock_client_setup(5);
for (
hashmap_iterator(clients_get(), &iter);
hashmap_iterator_has_next(clients_get(), &iter);
)
{
void* bt, *cfg;
client_t* cli;
cli = hashmap_iterator_next_value(clients_get(), &iter);
bt = cli->bt;
/* default configuration for clients */
cfg = bt_dm_get_config(bt);
config_set_va(cfg, "npieces", "%d", num_pieces);
config_set(cfg, "piece_length", "5");
config_set(cfg, "infohash", "00000000000000000000");
/* add files/pieces */
bt_piecedb_increase_piece_space(bt_dm_get_piecedb(bt), num_pieces * 5);
for (ii = 0; ii < num_pieces; ii++)
{
char hash[21];
void* pd;
pd = bt_dm_get_piecedb(bt);
mocktorrent_get_piece_sha1(mt, hash, ii);
bt_piecedb_add_with_hash_and_size(pd, hash, 5);
}
}
/* B will initiate the connection */
asprintf(&addr, "%p", b);
client_add_peer(a, NULL, 0, addr, strlen(addr), 0);
__add_random_piece_subset_of_mocktorrent(
bt_dm_get_piecedb(a->bt),
mt, num_pieces);
__add_piece_intersection_of_mocktorrent(
bt_dm_get_piecedb(b->bt),
bt_dm_get_piecedb(a->bt),
mt, num_pieces);
bt_dm_check_pieces(a->bt);
bt_dm_check_pieces(b->bt);
for (ii = 0; ii < 2000; ii++)
{
#if 0 /* debugging */
printf("\nStep %d:\n", ii + 1);
#endif
bt_dm_periodic(a->bt, NULL);
bt_dm_periodic(b->bt, NULL);
network_poll(a->bt, (void*)&a, 0,
bt_dm_dispatch_from_buffer,
mock_on_connect);
network_poll(b->bt, (void*)&b, 0,
bt_dm_dispatch_from_buffer,
mock_on_connect);
}
bt_dm_periodic(a->bt, NULL);
bt_dm_periodic(b->bt, NULL);
// bt_piecedb_print_pieces_downloaded(bt_dm_get_piecedb(a->bt));
// bt_piecedb_print_pieces_downloaded(bt_dm_get_piecedb(b->bt));
CuAssertTrue(tc, 1 ==
bt_piecedb_all_pieces_are_complete(bt_dm_get_piecedb(a->bt)));
CuAssertTrue(tc, 1 ==
bt_piecedb_all_pieces_are_complete(bt_dm_get_piecedb(b->bt)));
}
void TestBT_Peer_shares_one_piece(
CuTest * tc
)
{
int ii;
client_t* a, *b;
hashmap_iterator_t iter;
void* mt;
char *addr;
clients_setup();
mt = mocktorrent_new(1, 5);
a = mock_client_setup(5);
b = mock_client_setup(5);
for (
hashmap_iterator(clients_get(), &iter);
hashmap_iterator_has_next(clients_get(), &iter);
)
{
char hash[21];
client_t* cli = hashmap_iterator_next_value(clients_get(), &iter);
void* bt = cli->bt;
void *cfg = bt_dm_get_config(bt);
/* default configuration for clients */
config_set(cfg, "npieces", "1");
config_set_va(cfg, "piece_length", "%d", 5);
config_set(cfg, "infohash", "00000000000000000000");
/* add files/pieces */
//bt_piecedb_add_file(bt_dm_get_piecedb(bt),"test.txt",8,5);
bt_piecedb_increase_piece_space(bt_dm_get_piecedb(bt), 5);
bt_piecedb_add_with_hash_and_size(bt_dm_get_piecedb(bt),
mocktorrent_get_piece_sha1(mt, hash,
0), 5);
}
/* write blocks to client A */
{
void* data;
bt_block_t blk;
data = mocktorrent_get_data(mt, 0);
blk.piece_idx = 0;
blk.offset = 0;
blk.len = 5;
bt_diskmem_write_block(
bt_piecedb_get_diskstorage(bt_dm_get_piecedb(a->bt)),
NULL, &blk, data);
}
bt_dm_check_pieces(a->bt);
bt_dm_check_pieces(b->bt);
/* let validation jobs run */
bt_dm_periodic(a->bt, NULL);
CuAssertTrue(tc, 1 ==
bt_piecedb_all_pieces_are_complete(bt_dm_get_piecedb(a->bt)));
/* connect clients */
asprintf(&addr, "%p", a);
client_add_peer(b, NULL, 0, addr, strlen(addr), 0);
for (ii = 0; ii < 10; ii++)
{
#if 0 /* debugging */
printf("\nStep %d:\n", ii + 1);
#endif
bt_dm_periodic(a->bt, NULL);
bt_dm_periodic(b->bt, NULL);
network_poll(a->bt, (void*)&a, 0,
bt_dm_dispatch_from_buffer,
mock_on_connect);
network_poll(b->bt, (void*)&b, 0,
bt_dm_dispatch_from_buffer,
mock_on_connect);
// __print_client_contents();
}
/* let validation jobs run */
bt_dm_periodic(a->bt, NULL);
bt_dm_periodic(b->bt, NULL);
CuAssertTrue(tc, 1 ==
bt_piecedb_all_pieces_are_complete(bt_dm_get_piecedb(b->bt)));
}
int emul_esd_on_all_info (int client, struct emul_esd_command * cmd, void * data, struct roar_vio_calls * vio) {
struct roar_stream_server * ss;
struct roar_audio_info * info;
struct roar_client * c;
char name[ESD_NAME_MAX];
char * sname;
int id, rate, left, right, format;
int i;
if ( emul_esd_on_server_info(client, cmd, data, vio) == -1 )
return -1;
for (i = 0; i < (ROAR_STREAMS_MAX+2); i++) {
memset(name, 0, sizeof(name));
id = rate = format = 0;
left = right = 0;
if ( i >= ROAR_STREAMS_MAX ) {
id = -1;
} else {
if ( streams_get(i, &ss) == -1 )
continue;
switch (streams_get_dir(i)) {
case ROAR_DIR_PLAY: format |= ESD_PLAY; break;
case ROAR_DIR_MONITOR: format |= ESD_MONITOR; break;
case ROAR_DIR_RECORD: format |= ESD_RECORD; break;
default: continue; break;
}
info = &(ROAR_STREAM(ss)->info);
id = i;
rate = info->rate;
switch (info->bits) {
case 8: format |= ESD_BITS8; break;
case 16: format |= ESD_BITS16; break;
}
switch (info->channels) {
case 1:
if ( ss->mixer.mixer[0] == ss->mixer.scale ) {
left = right = 256;
} else {
left = right = ss->mixer.mixer[0] * 256 / ss->mixer.scale;
}
format |= ESD_MONO;
break;
case 2:
if ( ss->mixer.mixer[0] == ss->mixer.scale ) {
left = 256;
} else {
left = ss->mixer.mixer[0] * 256 / ss->mixer.scale;
}
if ( ss->mixer.mixer[1] == ss->mixer.scale ) {
right = 256;
} else {
right = ss->mixer.mixer[1] * 256 / ss->mixer.scale;
}
format |= ESD_STEREO;
break;
default:
left = right = 0;
}
sname = streams_get_name(id);
if ( sname == NULL || sname[0] == 0 ) {
if ( clients_get(streams_get_client(id), &c) != -1 ) {
sname = c->name;
}
}
if ( sname == NULL || sname[0] == 0 )
sname = "(unknown)";
strncpy(name, sname, sizeof(name) > ROAR_BUFFER_NAME ? ROAR_BUFFER_NAME : sizeof(name));
name[sizeof(name)-1] = 0;
}
id = _ROAR2ESD(id);
if ( emul_esd_int_write(client, id, vio) == -1 )
return -1;
if ( roar_vio_write(vio, name, sizeof(name)) != sizeof(name) )
return -1;
if ( emul_esd_int_write(client, rate, vio) == -1 )
return -1;
if ( emul_esd_int_write(client, left, vio) == -1 )
return -1;
if ( emul_esd_int_write(client, right, vio) == -1 )
return -1;
if ( emul_esd_int_write(client, format, vio) == -1 )
return -1;
if ( i == ROAR_STREAMS_MAX+1) {
// write 'length'...
if ( emul_esd_int_write(client, id, vio) == -1 )
return -1;
}
}
return 0;
}
int emul_esd_on_stream (int client, struct emul_esd_command * cmd, void * data, struct roar_vio_calls * vio) {
struct roar_stream_server * ss;
struct roar_stream * s;
struct roar_client * c;
int stream;
int dir = -1;
int esdformat;
int rate = 0;
if ( client == -1 || cmd == NULL || data == NULL || vio == NULL )
return -1;
switch (cmd->cmd) {
case ESD_PROTO_STREAM_PLAY: dir = ROAR_DIR_PLAY; break;
case ESD_PROTO_STREAM_REC: dir = ROAR_DIR_RECORD; break;
case ESD_PROTO_STREAM_MON: dir = ROAR_DIR_MONITOR; break;
case ESD_PROTO_STREAM_FILT: dir = ROAR_DIR_FILTER; break;
default:
clients_delete(client);
return -1;
}
if ( clients_get(client, &c) == -1 ) {
return -1;
}
ROAR_DBG("emul_esd_on_stream(client=%i, ...): creating stream...", client);
if ((stream = streams_new()) == -1 ) {
clients_delete(client);
return -1;
}
ROAR_DBG("emul_esd_on_stream(client=%i, ...): getting stream...", client);
if ( streams_get(stream, &ss) == -1 ) {
streams_delete(stream);
clients_delete(client);
return -1;
}
s = ROAR_STREAM(ss);
ROAR_DBG("emul_esd_on_stream(client=%i, ...): set client of stream...", client);
if ( client_stream_add(client, stream) == -1 ) {
streams_delete(stream);
clients_delete(client);
return -1;
}
emul_esd_int_read_buf(client, &esdformat, data);
emul_esd_int_read_buf(client, &rate, data+_INTSIZE);
strncpy(c->name, data + 2*_INTSIZE, ROAR_BUFFER_NAME > ESD_NAME_MAX ? ESD_NAME_MAX : ROAR_BUFFER_NAME);
c->name[ROAR_BUFFER_NAME-1] = 0;
ROAR_DBG("emul_esd_on_stream(*): esdformat=0x%.8X, rate=%i", esdformat, rate);
s->info.rate = rate;
switch (esdformat & ESD_MASK_BITS) {
case ESD_BITS8: s->info.bits = 8; s->info.codec = ROAR_CODEC_PCM_U_LE; break;
case ESD_BITS16: s->info.bits = 16; s->info.codec = ROAR_CODEC_DEFAULT; break;
default:
streams_delete(stream);
clients_delete(client);
return -1;
}
switch (esdformat & ESD_MASK_CHAN) {
case ESD_MONO: s->info.channels = 1; break;
case ESD_STEREO: s->info.channels = 2; break;
default:
streams_delete(stream);
clients_delete(client);
return -1;
}
ss->codec_orgi = s->info.codec;
ROAR_DBG("emul_esd_on_stream(*): s->info = {.rate=%i, .bits=%i, .channels=%i, .codec=%i}", s->info.rate, s->info.bits, s->info.channels, s->info.codec);
if ( streams_set_dir(stream, dir, 1) == -1 ) {
clients_delete(client);
return -1;
}
if ( client_stream_exec(client, stream) == -1 ) {
clients_delete(client);
return -1;
}
return 0;
}
/** a have message has to be sent by client B, for client A and C to finish */
void TestBT_Peer_three_share_all_pieces_between_each_other(CuTest * tc)
{
int ii;
client_t* a, *b, *c;
hashmap_iterator_t iter;
void* mt;
char *addr;
clients_setup();
mt = mocktorrent_new(3,5);
a = mock_client_setup(5);
b = mock_client_setup(5);
c = mock_client_setup(5);
for (
hashmap_iterator(clients_get(), &iter);
hashmap_iterator_has_next(clients_get(), &iter);
)
{
char hash[21];
void* bt, *cfg;
client_t* cli;
cli = hashmap_iterator_next_value(clients_get(), &iter);
bt = cli->bt;
cfg = bt_dm_get_config(bt);
/* default configuration for clients */
config_set(cfg, "npieces", "3");
config_set(cfg, "piece_length", "5");
config_set(cfg, "infohash", "00000000000000000000");
/* add files/pieces */
bt_piecedb_increase_piece_space(bt_dm_get_piecedb(bt),20);
bt_piecedb_add_with_hash_and_size(bt_dm_get_piecedb(bt),
mocktorrent_get_piece_sha1(mt,hash,0), 5);
bt_piecedb_add_with_hash_and_size(bt_dm_get_piecedb(bt),
mocktorrent_get_piece_sha1(mt,hash,1), 5);
bt_piecedb_add_with_hash_and_size(bt_dm_get_piecedb(bt),
mocktorrent_get_piece_sha1(mt,hash,2), 5);
}
/* write blocks to client A & B */
{
void* data;
bt_block_t blk;
blk.piece_idx = 0;
blk.offset = 0;
blk.len = 5;
data = mocktorrent_get_data(mt,0);
bt_diskmem_write_block(
bt_piecedb_get_diskstorage(bt_dm_get_piecedb(a->bt)),
NULL, &blk, data);
blk.piece_idx = 1;
data = mocktorrent_get_data(mt,1);
bt_diskmem_write_block(
bt_piecedb_get_diskstorage(bt_dm_get_piecedb(b->bt)),
NULL, &blk, data);
blk.piece_idx = 2;
data = mocktorrent_get_data(mt,2);
bt_diskmem_write_block(
bt_piecedb_get_diskstorage(bt_dm_get_piecedb(c->bt)),
NULL, &blk, data);
}
bt_dm_check_pieces(a->bt);
bt_dm_check_pieces(b->bt);
bt_dm_check_pieces(c->bt);
/* A connects to B */
asprintf(&addr,"%p", b);
client_add_peer(a,NULL,0,addr,strlen(addr),0);
/* B connects to C */
asprintf(&addr,"%p", c);
client_add_peer(b,NULL,0,addr,strlen(addr),0);
for (ii=0; ii<10; ii++)
{
#if 0 /* debugging */
printf("\nStep %d:\n", ii+1);
#endif
bt_dm_periodic(a->bt, NULL);
bt_dm_periodic(b->bt, NULL);
bt_dm_periodic(c->bt, NULL);
network_poll(a->bt, (void*)&a, 0,
bt_dm_dispatch_from_buffer,
mock_on_connect);
network_poll(b->bt, (void*)&b, 0,
bt_dm_dispatch_from_buffer,
mock_on_connect);
network_poll(c->bt, (void*)&c, 0,
bt_dm_dispatch_from_buffer,
mock_on_connect);
// __print_client_contents();
}
// bt_piecedb_print_pieces_downloaded(bt_dm_get_piecedb(a->bt));
// bt_piecedb_print_pieces_downloaded(bt_dm_get_piecedb(b->bt));
// bt_piecedb_print_pieces_downloaded(bt_dm_get_piecedb(c->bt));
/* empty jobs */
bt_dm_periodic(a->bt, NULL);
bt_dm_periodic(b->bt, NULL);
bt_dm_periodic(c->bt, NULL);
CuAssertTrue(tc, 1 == bt_piecedb_all_pieces_are_complete(bt_dm_get_piecedb(a->bt)));
CuAssertTrue(tc, 1 == bt_piecedb_all_pieces_are_complete(bt_dm_get_piecedb(b->bt)));
CuAssertTrue(tc, 1 == bt_piecedb_all_pieces_are_complete(bt_dm_get_piecedb(c->bt)));
}
/**
* Does the bt_dm_check_pieces() confirm if a piece is complete? */
void TestBT_Peer_shares_all_pieces_between_each_other(
CuTest * tc
)
{
client_t* a, *b;
hashmap_iterator_t iter;
void* mt;
clients_setup();
mt = mocktorrent_new(2, 5);
a = mock_client_setup(5);
b = mock_client_setup(5);
for (
hashmap_iterator(clients_get(), &iter);
hashmap_iterator_has_next(clients_get(), &iter);
)
{
char hash[21];
void* bt, *cfg;
client_t* cli;
cli = hashmap_iterator_next_value(clients_get(), &iter);
bt = cli->bt;
cfg = bt_dm_get_config(bt);
/* default configuration for clients */
config_set(cfg, "npieces", "2");
config_set(cfg, "piece_length", "5");
config_set(cfg, "infohash", "00000000000000000000");
/* add files/pieces */
bt_piecedb_increase_piece_space(bt_dm_get_piecedb(bt), 5);
bt_piecedb_increase_piece_space(bt_dm_get_piecedb(bt), 12);
bt_piecedb_add_with_hash_and_size(bt_dm_get_piecedb(bt),
mocktorrent_get_piece_sha1(mt, hash,
0), 5);
bt_piecedb_add_with_hash_and_size(bt_dm_get_piecedb(bt),
mocktorrent_get_piece_sha1(mt, hash,
1), 5);
}
/* write blocks to client A & B */
{
void* data;
bt_block_t blk;
blk.piece_idx = 0;
blk.offset = 0;
blk.len = 5;
data = mocktorrent_get_data(mt, 0);
bt_diskmem_write_block(
bt_piecedb_get_diskstorage(bt_dm_get_piecedb(b->bt)),
NULL, &blk, data);
blk.piece_idx = 1;
data = mocktorrent_get_data(mt, 1);
bt_diskmem_write_block(
bt_piecedb_get_diskstorage(bt_dm_get_piecedb(a->bt)),
NULL, &blk, data);
}
bt_dm_check_pieces(a->bt);
bt_dm_check_pieces(b->bt);
bt_dm_periodic(a->bt, NULL);
bt_dm_periodic(b->bt, NULL);
CuAssertTrue(tc, bt_dm_piece_is_complete(a->bt, 1));
CuAssertTrue(tc, bt_dm_piece_is_complete(b->bt, 0));
}
