int bind_to(const char * ip,int port, struct sockaddr_in* addr)
{
int res;
int fd = create_socket_udp();
if (fd < 0)
{
return -1;
}
res = set_reuse(fd);
if (res < 0)
{
close_socket(fd);
return -1;
}
make_address(addr, ip, port);
res = bind(fd, (const struct sockaddr*)addr, (socklen_t)sizeof(struct sockaddr_in));
if ( res < 0)
{
close_socket(fd);
return -1;
}
return fd;
}
// ============================================================
void CFido::operator= (LPCSTR name)
// ============================================================
{
int ret;
isdigit=zone=net=node=point=0;
if (*name=='#') // it's a direct phone number
{
isdigit=1;
strcpy(asciibuf,name);
return;
}
// if number contains '~' than FileSystem has long filenames
if (strchr(name,'~'))
{
::MessageBox(NULL,"Detected problem with filename length!","Error",MB_OK);
return;
}
if (strchr(name,'_'))
{
ret=sscanf(name,"%d_%d_%d_%d",&zone,&net,&node,&point);
ASSERT((ret==3) || (ret==4));
}
else
{
ret=parse_address(name,&zone,&net,&node,&point);
ASSERT(ret==3 || ret==4);
}
// store this adress internally
make_address(asciibuf,zone,net,node,point);
}
/* Option: --proto: tcp, also --port nnn (default 9000) */
static int add_tcp(struct configuration* cfg)
{
int s;
struct sockaddr_in host_address;
socklen_t clilen;
struct sockaddr_in cli_addr;
clilen = sizeof(cli_addr);
int connected_fd;
make_address(cfg->cfg_host, cfg->cfg_port, &host_address);
s = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP );
TEST(s >= 0);
TRY( bind(s, (struct sockaddr*)&host_address, sizeof(host_address)) );
TRY( listen( s, -1 ) );
printf( "TCP listening on port %d\n ", cfg->cfg_port );
connected_fd = accept(s, (struct sockaddr *) &cli_addr, &clilen);
TEST(connected_fd >= 0);
close(s);
printf("TCP connection accepted\n");
return connected_fd;
}
int G_sock_connect(const char *name)
{
int sockfd;
sockaddr_t addr;
init_sockets();
if (!G_sock_exists(name))
return -1;
/* must always zero socket structure */
memset(&addr, 0, sizeof(addr));
if (make_address(&addr, name, 1) < 0)
return -1;
sockfd = socket(PROTO, SOCK_STREAM, 0);
if (sockfd == INVALID_SOCKET)
return -1;
if (connect(sockfd, (struct sockaddr *)&addr, sizeof(addr)) != 0)
return -1;
else
return sockfd;
}
/* Receive a packet, and print out the timestamps from it */
static int do_recv(int sock, unsigned int pkt_num)
{
struct msghdr msg;
struct iovec iov;
struct sockaddr_in host_address;
char buffer[2048];
char control[1024];
int got;
/* recvmsg header structure */
make_address(0, &host_address);
iov.iov_base = buffer;
iov.iov_len = 2048;
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
msg.msg_name = &host_address;
msg.msg_namelen = sizeof(struct sockaddr_in);
msg.msg_control = control;
msg.msg_controllen = 1024;
/* block for message */
got = recvmsg(sock, &msg, 0);
if( !got && errno == EAGAIN )
return 0;
printf("Packet %d - %d bytes\t", pkt_num, got);
handle_time(&msg);
return got;
};
int nonblock_connect_to(const char * ip,int port, struct sockaddr_in* addr)
{
int res;
int fd = create_socket();
if (fd < 0)
{
return -1;
}
int flags = fcntl(fd,F_GETFL,0);
fcntl(fd, F_SETFL, flags | O_NONBLOCK);
make_address(addr, ip, port);
res = connect(fd, (const struct sockaddr*)addr, (socklen_t)sizeof(struct sockaddr));
if ( res < 0)
{
if(errno == EINPROGRESS)
{
return fd;
}
close_socket(fd);
return -1;
}
return fd;
}
/* Receive a packet, and print out the timestamps from it */
int do_echo(int sock, unsigned int pkt_num, int cfg_templated)
{
struct msghdr msg;
struct iovec iov;
struct sockaddr_in host_address;
char buffer[2048];
char control[1024];
int got;
int check = 0;
const int check_max = 999999;
/* recvmsg header structure */
make_address(0, 0, &host_address);
iov.iov_base = buffer;
iov.iov_len = 2048;
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
msg.msg_name = &host_address;
msg.msg_namelen = sizeof(struct sockaddr_in);
msg.msg_control = control;
msg.msg_controllen = 1024;
/* block for message */
got = recvmsg(sock, &msg, 0);
TEST(got >= 0);
printf("Packet %d - %d bytes\n", pkt_num, got);
/* echo back */
msg.msg_controllen = 0;
iov.iov_len = got;
#ifdef ONLOADEXT_AVAILABLE
if ( cfg_templated )
TRY(templated_send(sock, &iov) );
else
#endif
TRY(sendmsg(sock, &msg, 0));
/* retrieve TX timestamp
* Note: Waiting for it this way isn't the most efficient option.
* For higher throughput, check associate times to packets afterwards.
*/
msg.msg_control = control;
iov.iov_len = 2048;
do {
msg.msg_controllen = 1024;
got = recvmsg(sock, &msg, MSG_ERRQUEUE);
} while (got < 0 && errno == EAGAIN && check++ < check_max);
if ( got < 0 && errno == EAGAIN ) {
printf("Gave up acquiring timestamp.\n");
return -EAGAIN;
}
TEST(got >= 0);
handle_time(&msg);
return 0;
};
int listen_to(const char * ip,int port, struct sockaddr_in* addr, int is_block)
{
int res;
int fd = create_socket();
if (fd < 0)
{
fprintf(stderr,"create socket failed!\n");
return -1;
}
int result = 0;
if (is_block)
{
result = set_block(fd);
}
else
{
result = set_nonblock(fd);
}
if (result==-1)
{
fprintf(stderr,"set block failed!\n");
return -1;
}
res = set_reuse(fd);
if (res < 0)
{
fprintf(stderr,"set reuse failed!\n");
close_socket(fd);
return -1;
}
make_address(addr, ip, port);
res = bind(fd, (const struct sockaddr*)addr, (socklen_t)sizeof(struct sockaddr_in));
if ( res < 0)
{
fprintf(stderr,"bind failed!\n");
close_socket(fd);
return -1;
}
res = listen(fd, SOMAXCONN);
if ( res < 0)
{
fprintf(stderr,"listen failed!\n");
close_socket(fd);
return -1;
}
return fd;
}
/** Test whether bm_equal() works correctly. */
void bm_test2()
{
struct bitmap* bm1;
struct bitmap* bm2;
bm1 = DRD_(bm_new)();
bm2 = DRD_(bm_new)();
DRD_(bm_access_load_1)(bm1, 7);
DRD_(bm_access_load_1)(bm2, make_address(1, 0) + 7);
assert(! DRD_(bm_equal)(bm1, bm2));
assert(! DRD_(bm_equal)(bm2, bm1));
DRD_(bm_access_load_1)(bm2, 7);
assert(! DRD_(bm_equal)(bm1, bm2));
assert(! DRD_(bm_equal)(bm2, bm1));
DRD_(bm_access_store_1)(bm1, make_address(1, 0) + 7);
assert(! DRD_(bm_equal)(bm1, bm2));
assert(! DRD_(bm_equal)(bm2, bm1));
DRD_(bm_delete)(bm2);
DRD_(bm_delete)(bm1);
}
/** Make a copy of an address_t object */
address_t copy_address(address_t self)
{ address_t it,out=0;
if(!self) return 0;
TRY(out=make_address());
for(it=address_begin(self);it;it=address_next(self))
address_push(out,address_id(it));
return out;
Error:
free_address(out);
return 0;
}
static void a_create_test(void) {
printsln((String)__func__);
Array a;
Address addr;
a = a_create(3, sizeof(Address));
addr = make_address("Fred", "Oyster", "Hannover");
a_set(a, 0, &addr);
addr = make_address("Frida", "Qwirin", "Hannover");
a_set(a, 1, &addr);
addr = make_address("James", "Bond", "London");
a_set(a, 2, &addr);
Address *pa = a_get(a, 0);
// printsln(pa->firstname);
check_expect_s(pa->firstname, "Fred");
pa = a_get(a, 1);
// printsln(pa->firstname);
check_expect_s(pa->city, "Hannover");
pa = a_get(a, 2);
// printsln(pa->firstname);
check_expect_s(pa->lastname, "Bond");
a_free(a);
#if 0
Array ap = a_create(2, sizeof(Address*));
pa = &a;
a_set(ap, 0, &pa);
pa = &b;
a_set(ap, 1, &pa);
Address **ppa = a_get(ap, 0);
printsln((*ppa)->firstname);
ppa = a_get(ap, 1);
printsln((*ppa)->firstname);
#endif
}
static void a_of_buffer_test(void) {
printsln((String)__func__);
Address addr[] = {
make_address("Fred", "Oyster", "Hannover"),
make_address("Frida", "Qwirin", "Hannover"),
make_address("James", "Bond", "London"),
};
Array a = a_of_buffer(&addr, 3, sizeof(Address));
Address *pa = a_get(a, 0);
// printsln(pa->firstname);
check_expect_s(pa->firstname, "Fred");
pa = a_get(a, 1);
// printsln(pa->firstname);
check_expect_s(pa->city, "Hannover");
pa = a_get(a, 2);
// printsln(pa->firstname);
check_expect_s(pa->lastname, "Bond");
a_free(a);
}
/* Option: --proto udp (default), also --port nnn (default 9000) */
static int add_udp(struct configuration* cfg)
{
int s;
struct sockaddr_in host_address;
make_address(cfg->cfg_host, cfg->cfg_port, &host_address);
s = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
TEST(s >= 0);
TRY(bind(s, (struct sockaddr*)&host_address, sizeof(host_address)) );
printf("UDP socket created, listening on port %d\n", cfg->cfg_port);
return s;
}
address_t address_from_int(uint64_t v, size_t ndigits, uint64_t base)
{ size_t i;
address_t out=0;
TRY(out=make_address());
if(v==0)
return out;
TRY(reserve(out,ndigits));
out->sz=ndigits;
for(i=0;i<ndigits;++i)
{ out->ids[ndigits-i-1]=v?(v-1)%base:0; // 0 is root. digits 1-4 address nodes on the path.
v/=base;
}
return out;
Error:
free_address(out);
return 0;
}
static int add_socket(struct configuration* cfg)
{
int s;
struct sockaddr_in host_address;
int domain = SOCK_DGRAM;
if ( cfg->cfg_protocol == IPPROTO_TCP )
domain = SOCK_STREAM;
make_address(cfg->cfg_port, &host_address);
s = socket(PF_INET, domain, cfg->cfg_protocol);
TEST(s >= 0);
TRY(bind(s, (struct sockaddr*)&host_address, sizeof(host_address)) );
printf("Socket created, listening on port %d\n", cfg->cfg_port);
return s;
}
char *
parse_address(struct olsrv2 *olsr, struct address_list **list, char *msg_ptr, char *num_addr)
{
struct address_block_info info;
struct address_list *new_list = NULL, *tail = NULL;
int i;
union olsr_ip_addr mid;
msg_ptr = get_address_block_header(olsr, &info, msg_ptr);
debug_code(print_address_block_info(olsr, &info));
*num_addr = info.num_addr;// use after
tail = NULL;
for (i = 0; i < info.num_addr; i++)
{
new_list = (struct address_list *)olsr_malloc(sizeof(struct address_list), __FUNCTION__);
memset(new_list, 0, sizeof(struct address_list));
memset(&mid, 0, sizeof(union olsr_ip_addr));
new_list->next = NULL;
new_list->index = i;
msg_ptr = get_bytes(msg_ptr, info.mid_length, &mid);
make_address(&new_list->ip_addr, &mid, &info);
debug_code(print_new_list(olsr, new_list));
// QUEUE address
if (*list == NULL){
*list = new_list;
//tail = new_list;
}else{
new_list->next = *list;
*list = new_list;
//tail->next = new_list;
//tail = new_list;
}
}
debug_code(print_address_list(olsr, *list));
return msg_ptr;
}
int G_sock_bind(const char *name)
{
int sockfd;
sockaddr_t addr;
socklen_t size;
if (name == NULL)
return -1;
init_sockets();
/* Bind requires that the file does not exist. Force the caller
* to make sure the socket is not in use. The only way to test,
* is a call to connect().
*/
if (G_sock_exists(name)) {
errno = EADDRINUSE;
return -1;
}
/* must always zero socket structure */
memset(&addr, 0, sizeof(addr));
size = sizeof(addr);
if (make_address(&addr, name, 0) < 0)
return -1;
sockfd = socket(PROTO, SOCK_STREAM, 0);
if (sockfd == INVALID_SOCKET)
return -1;
if (bind(sockfd, (const struct sockaddr *)&addr, size) != 0)
return -1;
#ifdef USE_TCP
if (save_port(sockfd, name) < 0)
return -1;
#endif
return sockfd;
}
// ============================================================
LPCSTR CFido::Get(char *retbuf)
// ============================================================
{
char tmp[500];
if (isdigit==1)
{
if (retbuf)
strcpy(retbuf,asciibuf);
return asciibuf;
}
ASSERT(zone<=9999 && net<=9999 && node<=9999 && point<=9999);
make_address(tmp,zone,net,node,point);
if (retbuf)
strcpy(retbuf,tmp);
strcpy(asciibuf,tmp);
return asciibuf;
}
int connect_socket(char *name, uint16_t port){
struct sockaddr_in addr;
int socketfd;
socketfd = make_socket();
addr=make_address(name,port);
if(connect(socketfd,(struct sockaddr*) &addr,sizeof(struct sockaddr_in)) < 0){
if(errno!=EINTR) ERR("connect");
else {
fd_set wfds ;
int status;
socklen_t size = sizeof(int);
FD_ZERO(&wfds);
FD_SET(socketfd, &wfds);
if(TEMP_FAILURE_RETRY(select(socketfd+1,NULL,&wfds,NULL,NULL))<0) ERR("select");
if(getsockopt(socketfd,SOL_SOCKET,SO_ERROR,&status,&size)<0) ERR("getsockopt");
if(0!=status) ERR("connect");
}
}
printf("Połączono!\n");
return socketfd;
}
int connect_to(const char * ip,int port, struct sockaddr_in* addr)
{
int res;
int fd = create_socket();
if (fd < 0)
{
return -1;
}
make_address(addr, ip, port);
res = connect(fd, (const struct sockaddr*)addr, (socklen_t)sizeof(struct sockaddr));
if ( res < 0)
{
close_socket(fd);
return -1;
}
return fd;
}
static void a_copy_test(void) {
printsln((String)__func__);
Array array, copy;
Address a;
array = a_create(3, sizeof(Address));
a = make_address("Fred", "Oyster", "Hannover");
a_set(array, 0, &a);
a = make_address("Frida", "Qwirin", "Hannover");
a_set(array, 1, &a);
a = make_address("James", "Bond", "London");
a_set(array, 2, &a);
copy = a_copy(array);
a_check_expect(copy, array);
a_free(array);
a_free(copy);
array = ia_of_string("-1, -2, -3");
copy = a_copy(array);
ia_check_expect(copy, array);
a_free(array);
a_free(copy);
array = ia_of_string("10");
copy = a_copy(array);
ia_check_expect(copy, array);
a_free(array);
a_free(copy);
array = ia_of_string("100, -200");
copy = a_copy(array);
ia_check_expect(copy, array);
a_free(array);
a_free(copy);
array = ia_of_string("");
copy = a_copy(array);
ia_check_expect(copy, array);
a_free(array);
a_free(copy);
array = da_of_string("-1, -2, -3");
copy = a_copy(array);
da_check_within(array, copy);
a_free(array);
a_free(copy);
array = da_of_string("10");
copy = a_copy(array);
da_check_within(array, copy);
a_free(array);
a_free(copy);
array = da_of_string(" 100, -200 ");
copy = a_copy(array);
da_check_within(array, copy);
a_free(array);
a_free(copy);
array = da_of_string("");
copy = a_copy(array);
da_check_within(array, copy);
a_free(array);
a_free(copy);
}
int main(int argc, char *argv[]) {
struct configuration config;
parse_options(argc, argv, &config);
int sock;
/* Create the UDP socket */
if ((sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
Die("Failed to create socket");
}
set_socket_reuse(sock);
int on = 1;
setsockopt(sock, SOL_IP, IP_PKTINFO, &on, sizeof(on));
do_ts_sockopt(sock);
struct sockaddr_in server_addr;
make_address(config.server_ip, config.server_port, &server_addr);
struct sockaddr_in client_addr;
make_address(config.host_ip, config.host_port, &client_addr);
if(bind(sock, (struct sockaddr*)&client_addr, sizeof(client_addr)) < 0){
Die("bind");
}
struct sockaddr_in recv_addr;
make_address(0, 0, &recv_addr);
char buffer[config.msg_size];
unsigned int clientlen;
clientlen = sizeof(client_addr);
struct msghdr msg;
struct iovec iov;
char control[1024];
int got;
iov.iov_base = buffer;
iov.iov_len = config.msg_size;
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
msg.msg_namelen = sizeof(struct sockaddr_in);
msg.msg_control = control;
msg.msg_controllen = 1024;
msg.msg_name = &recv_addr;
char pay_load[config.msg_size];
const int timestamp_per_sample = 1;
size_t result_len = sizeof(struct timespec)*timestamp_per_sample*config.max_packets;
struct timespec (*result)[timestamp_per_sample] = (struct timespec ((*)[timestamp_per_sample]))malloc(result_len);
memset(result[0], 0, result_len);
int i;
runoncpu(3);
for(i = 0; i < config.max_packets; i++){
do {
got = recvmsg(sock, &msg, MSG_ERRQUEUE);
} while (got < 0 && errno == EAGAIN);
if(got >= 0){
keep_time(&msg, result[i]+1);
}else{
DEBUG("Unable to get TX_TIMESTAMPING\n");
}
}
FILE* outfile;
outfile = fopen("result_send_nic.txt", "w");
for(i = 0; i < config.max_packets; i++){
int j;
for (j = 0; j < timestamp_per_sample; j++){
if (j < timestamp_per_sample-1){
fprintf(outfile, "%ld,%9ld,", result[i][j].tv_sec, result[i][j].tv_nsec);
}else{
fprintf(outfile, "%ld,%9ld\n", result[i][j].tv_sec, result[i][j].tv_nsec);
}
}
}
close(outfile);
close(sock);
exit(0);
}
address bind_socket_to_device(io_service& ios, Socket& sock
, boost::asio::ip::tcp const& protocol
, char const* device_name, int port, error_code& ec)
{
tcp::endpoint bind_ep(address_v4::any(), std::uint16_t(port));
address ip = make_address(device_name, ec);
if (!ec)
{
#if TORRENT_USE_IPV6
// this is to cover the case where "0.0.0.0" is considered any IPv4 or
// IPv6 address. If we're asking to be bound to an IPv6 address and
// providing 0.0.0.0 as the device, turn it into "::"
if (ip == address_v4::any() && protocol == boost::asio::ip::tcp::v6())
ip = address_v6::any();
#endif
bind_ep.address(ip);
// it appears to be an IP. Just bind to that address
sock.bind(bind_ep, ec);
return bind_ep.address();
}
ec.clear();
#if TORRENT_HAS_BINDTODEVICE
// try to use SO_BINDTODEVICE here, if that exists. If it fails,
// fall back to the mechanism we have below
sock.set_option(aux::bind_to_device(device_name), ec);
if (ec)
#endif
{
ec.clear();
// TODO: 2 this could be done more efficiently by just looking up
// the interface with the given name, maybe even with if_nametoindex()
std::vector<ip_interface> ifs = enum_net_interfaces(ios, ec);
if (ec) return bind_ep.address();
bool found = false;
for (auto const& iface : ifs)
{
// we're looking for a specific interface, and its address
// (which must be of the same family as the address we're
// connecting to)
if (std::strcmp(iface.name, device_name) != 0) continue;
if (iface.interface_address.is_v4() != (protocol == boost::asio::ip::tcp::v4()))
continue;
bind_ep.address(iface.interface_address);
found = true;
break;
}
if (!found)
{
ec = error_code(boost::system::errc::no_such_device, generic_category());
return bind_ep.address();
}
}
sock.bind(bind_ep, ec);
return bind_ep.address();
}
/** Torture test of the functions that set or clear a range of bits. */
void bm_test3(const int outer_loop_step, const int inner_loop_step)
{
unsigned i, j;
struct bitmap* bm1;
struct bitmap* bm2;
const Addr lb = make_address(2, 0) - 2 * BITS_PER_UWORD;
const Addr ub = make_address(2, 0) + 2 * BITS_PER_UWORD;
assert(outer_loop_step >= 1);
assert((outer_loop_step % ADDR_GRANULARITY) == 0);
assert(inner_loop_step >= 1);
assert((inner_loop_step % ADDR_GRANULARITY) == 0);
bm1 = DRD_(bm_new)();
bm2 = DRD_(bm_new)();
for (i = lb; i < ub; i += outer_loop_step)
{
for (j = i + ADDR_GRANULARITY; j < ub; j += inner_loop_step)
{
DRD_(bm_access_range_load)(bm1, i, j);
DRD_(bm_clear_load)(bm1, i, j);
assert(bm_equal_print_diffs(bm1, bm2));
DRD_(bm_access_load_1)(bm1, i);
DRD_(bm_clear_load)(bm1, i, i + MAX(1, ADDR_GRANULARITY));
assert(bm_equal_print_diffs(bm1, bm2));
DRD_(bm_access_load_2)(bm1, i);
DRD_(bm_clear_load)(bm1, i, i + MAX(2, ADDR_GRANULARITY));
assert(bm_equal_print_diffs(bm1, bm2));
DRD_(bm_access_load_4)(bm1, i);
DRD_(bm_clear_load)(bm1, i, i + MAX(4, ADDR_GRANULARITY));
assert(bm_equal_print_diffs(bm1, bm2));
DRD_(bm_access_load_8)(bm1, i);
DRD_(bm_clear_load)(bm1, i, i + MAX(8, ADDR_GRANULARITY));
assert(bm_equal_print_diffs(bm1, bm2));
DRD_(bm_access_range_store)(bm1, i, j);
DRD_(bm_clear_store)(bm1, i, j);
assert(bm_equal_print_diffs(bm1, bm2));
DRD_(bm_access_store_1)(bm1, i);
DRD_(bm_clear_store)(bm1, i, i + MAX(1, ADDR_GRANULARITY));
assert(bm_equal_print_diffs(bm1, bm2));
DRD_(bm_access_store_2)(bm1, i);
DRD_(bm_clear_store)(bm1, i, i + MAX(2, ADDR_GRANULARITY));
assert(bm_equal_print_diffs(bm1, bm2));
DRD_(bm_access_store_4)(bm1, i);
DRD_(bm_clear_store)(bm1, i, i + MAX(4, ADDR_GRANULARITY));
assert(bm_equal_print_diffs(bm1, bm2));
DRD_(bm_access_store_8)(bm1, i);
DRD_(bm_clear_store)(bm1, i, i + MAX(8, ADDR_GRANULARITY));
assert(bm_equal_print_diffs(bm1, bm2));
DRD_(bm_access_range_load)(bm1, i, j);
DRD_(bm_access_range_store)(bm1, i, j);
DRD_(bm_clear)(bm1, i, j);
assert(bm_equal_print_diffs(bm1, bm2));
DRD_(bm_access_load_1)(bm1, i);
DRD_(bm_access_store_1)(bm1, i);
DRD_(bm_clear)(bm1, i, i + MAX(1, ADDR_GRANULARITY));
assert(bm_equal_print_diffs(bm1, bm2));
DRD_(bm_access_load_2)(bm1, i);
DRD_(bm_access_store_2)(bm1, i);
DRD_(bm_clear)(bm1, i, i + MAX(2, ADDR_GRANULARITY));
assert(bm_equal_print_diffs(bm1, bm2));
DRD_(bm_access_load_4)(bm1, i);
DRD_(bm_access_store_4)(bm1, i);
DRD_(bm_clear)(bm1, i, i + MAX(4, ADDR_GRANULARITY));
assert(bm_equal_print_diffs(bm1, bm2));
DRD_(bm_access_load_8)(bm1, i);
DRD_(bm_access_store_8)(bm1, i);
DRD_(bm_clear)(bm1, i, i + MAX(8, ADDR_GRANULARITY));
assert(bm_equal_print_diffs(bm1, bm2));
}
}
DRD_(bm_access_range_load)(bm1, 0, make_address(2, 0) + 2 * BITS_PER_UWORD);
DRD_(bm_access_range_store)(bm1, 0, make_address(2, 0) + 2 * BITS_PER_UWORD);
DRD_(bm_access_range_load)(bm2, 0, make_address(2, 0) + 2 * BITS_PER_UWORD);
DRD_(bm_access_range_store)(bm2, 0, make_address(2, 0) + 2 * BITS_PER_UWORD);
for (i = make_address(1, 0) - 2 * BITS_PER_UWORD;
i < make_address(1, 0) + 2 * BITS_PER_UWORD;
i += outer_loop_step)
{
for (j = i + 1; j < ub; j += inner_loop_step)
{
DRD_(bm_clear_load)(bm1, i, j);
DRD_(bm_access_range_load)(bm1, i, j);
assert(bm_equal_print_diffs(bm1, bm2));
DRD_(bm_clear_load)(bm1, i, i+1);
DRD_(bm_access_load_1)(bm1, i);
assert(bm_equal_print_diffs(bm1, bm2));
DRD_(bm_clear_load)(bm1, i, i+2);
DRD_(bm_access_load_2)(bm1, i);
assert(bm_equal_print_diffs(bm1, bm2));
DRD_(bm_clear_load)(bm1, i, i+4);
DRD_(bm_access_load_4)(bm1, i);
assert(bm_equal_print_diffs(bm1, bm2));
DRD_(bm_clear_load)(bm1, i, i+8);
DRD_(bm_access_load_8)(bm1, i);
assert(bm_equal_print_diffs(bm1, bm2));
DRD_(bm_clear_store)(bm1, i, j);
DRD_(bm_access_range_store)(bm1, i, j);
assert(bm_equal_print_diffs(bm1, bm2));
DRD_(bm_clear_store)(bm1, i, i+1);
DRD_(bm_access_store_1)(bm1, i);
assert(bm_equal_print_diffs(bm1, bm2));
DRD_(bm_clear_store)(bm1, i, i+2);
DRD_(bm_access_store_2)(bm1, i);
assert(bm_equal_print_diffs(bm1, bm2));
DRD_(bm_clear_store)(bm1, i, i+4);
DRD_(bm_access_store_4)(bm1, i);
assert(bm_equal_print_diffs(bm1, bm2));
DRD_(bm_clear_store)(bm1, i, i+8);
DRD_(bm_access_store_8)(bm1, i);
assert(bm_equal_print_diffs(bm1, bm2));
DRD_(bm_clear)(bm1, i, j);
DRD_(bm_access_range_load)(bm1, i, j);
DRD_(bm_access_range_store)(bm1, i, j);
assert(bm_equal_print_diffs(bm1, bm2));
}
}
DRD_(bm_delete)(bm2);
DRD_(bm_delete)(bm1);
}
unsigned DasmMIPS( char *buffer, UINT32 pc, const UINT8 *opram )
{
UINT32 op;
const UINT8 *oldopram;
oldopram = opram;
op = ( opram[ 3 ] << 24 ) | ( opram[ 2 ] << 16 ) | ( opram[ 1 ] << 8 ) | ( opram[ 0 ] << 0 );
opram += 4;
sprintf( buffer, "dw $%08x", op );
switch( INS_OP( op ) )
{
case OP_SPECIAL:
switch( INS_FUNCT( op ) )
{
case FUNCT_SLL:
if( op == 0 )
{
/* the standard nop is "sll zero,zero,$0000" */
sprintf( buffer, "nop" );
}
else
{
sprintf( buffer, "sll %s,%s,$%02x", s_cpugenreg[ INS_RD( op ) ], s_cpugenreg[ INS_RT( op ) ], INS_SHAMT( op ) );
}
break;
case FUNCT_SRL:
sprintf( buffer, "srl %s,%s,$%02x", s_cpugenreg[ INS_RD( op ) ], s_cpugenreg[ INS_RT( op ) ], INS_SHAMT( op ) );
break;
case FUNCT_SRA:
sprintf( buffer, "sra %s,%s,$%02x", s_cpugenreg[ INS_RD( op ) ], s_cpugenreg[ INS_RT( op ) ], INS_SHAMT( op ) );
break;
case FUNCT_SLLV:
sprintf( buffer, "sllv %s,%s,%s", s_cpugenreg[ INS_RD( op ) ], s_cpugenreg[ INS_RT( op ) ], s_cpugenreg[ INS_RS( op ) ] );
break;
case FUNCT_SRLV:
sprintf( buffer, "srlv %s,%s,%s", s_cpugenreg[ INS_RD( op ) ], s_cpugenreg[ INS_RT( op ) ], s_cpugenreg[ INS_RS( op ) ] );
break;
case FUNCT_SRAV:
sprintf( buffer, "srav %s,%s,%s", s_cpugenreg[ INS_RD( op ) ], s_cpugenreg[ INS_RT( op ) ], s_cpugenreg[ INS_RS( op ) ] );
break;
case FUNCT_JR:
if( INS_RD( op ) == 0 )
{
sprintf( buffer, "jr %s", s_cpugenreg[ INS_RS( op ) ] );
}
break;
case FUNCT_JALR:
sprintf( buffer, "jalr %s,%s", s_cpugenreg[ INS_RD( op ) ], s_cpugenreg[ INS_RS( op ) ] );
break;
case FUNCT_SYSCALL:
sprintf( buffer, "syscall $%05x", INS_CODE( op ) );
break;
case FUNCT_BREAK:
sprintf( buffer, "break $%05x", INS_CODE( op ) );
break;
case FUNCT_MFHI:
sprintf( buffer, "mfhi %s", s_cpugenreg[ INS_RD( op ) ] );
break;
case FUNCT_MTHI:
if( INS_RD( op ) == 0 )
{
sprintf( buffer, "mthi %s", s_cpugenreg[ INS_RS( op ) ] );
}
break;
case FUNCT_MFLO:
sprintf( buffer, "mflo %s", s_cpugenreg[ INS_RD( op ) ] );
break;
case FUNCT_MTLO:
if( INS_RD( op ) == 0 )
{
sprintf( buffer, "mtlo %s", s_cpugenreg[ INS_RS( op ) ] );
}
break;
case FUNCT_MULT:
if( INS_RD( op ) == 0 )
{
sprintf( buffer, "mult %s,%s", s_cpugenreg[ INS_RS( op ) ], s_cpugenreg[ INS_RT( op ) ] );
}
break;
case FUNCT_MULTU:
if( INS_RD( op ) == 0 )
{
sprintf( buffer, "multu %s,%s", s_cpugenreg[ INS_RS( op ) ], s_cpugenreg[ INS_RT( op ) ] );
}
break;
case FUNCT_DIV:
if( INS_RD( op ) == 0 )
{
sprintf( buffer, "div %s,%s", s_cpugenreg[ INS_RS( op ) ], s_cpugenreg[ INS_RT( op ) ] );
}
break;
case FUNCT_DIVU:
if( INS_RD( op ) == 0 )
{
sprintf( buffer, "divu %s,%s", s_cpugenreg[ INS_RS( op ) ], s_cpugenreg[ INS_RT( op ) ] );
}
break;
case FUNCT_ADD:
sprintf( buffer, "add %s,%s,%s", s_cpugenreg[ INS_RD( op ) ], s_cpugenreg[ INS_RS( op ) ], s_cpugenreg[ INS_RT( op ) ] );
break;
case FUNCT_ADDU:
sprintf( buffer, "addu %s,%s,%s", s_cpugenreg[ INS_RD( op ) ], s_cpugenreg[ INS_RS( op ) ], s_cpugenreg[ INS_RT( op ) ] );
break;
case FUNCT_SUB:
sprintf( buffer, "sub %s,%s,%s", s_cpugenreg[ INS_RD( op ) ], s_cpugenreg[ INS_RS( op ) ], s_cpugenreg[ INS_RT( op ) ] );
break;
case FUNCT_SUBU:
sprintf( buffer, "subu %s,%s,%s", s_cpugenreg[ INS_RD( op ) ], s_cpugenreg[ INS_RS( op ) ], s_cpugenreg[ INS_RT( op ) ] );
break;
case FUNCT_AND:
sprintf( buffer, "and %s,%s,%s", s_cpugenreg[ INS_RD( op ) ], s_cpugenreg[ INS_RS( op ) ], s_cpugenreg[ INS_RT( op ) ] );
break;
case FUNCT_OR:
sprintf( buffer, "or %s,%s,%s", s_cpugenreg[ INS_RD( op ) ], s_cpugenreg[ INS_RS( op ) ], s_cpugenreg[ INS_RT( op ) ] );
break;
case FUNCT_XOR:
sprintf( buffer, "xor %s,%s,%s", s_cpugenreg[ INS_RD( op ) ], s_cpugenreg[ INS_RS( op ) ], s_cpugenreg[ INS_RT( op ) ] );
break;
case FUNCT_NOR:
sprintf( buffer, "nor %s,%s,%s", s_cpugenreg[ INS_RD( op ) ], s_cpugenreg[ INS_RS( op ) ], s_cpugenreg[ INS_RT( op ) ] );
break;
case FUNCT_SLT:
sprintf( buffer, "slt %s,%s,%s", s_cpugenreg[ INS_RD( op ) ], s_cpugenreg[ INS_RS( op ) ], s_cpugenreg[ INS_RT( op ) ] );
break;
case FUNCT_SLTU:
sprintf( buffer, "sltu %s,%s,%s", s_cpugenreg[ INS_RD( op ) ], s_cpugenreg[ INS_RS( op ) ], s_cpugenreg[ INS_RT( op ) ] );
break;
}
break;
case OP_REGIMM:
switch( INS_RT( op ) )
{
case RT_BLTZ:
sprintf( buffer, "bltz %s,$%08x", s_cpugenreg[ INS_RS( op ) ], pc + 4 + ( MIPS_WORD_EXTEND( INS_IMMEDIATE( op ) ) << 2 ) );
break;
case RT_BGEZ:
sprintf( buffer, "bgez %s,$%08x", s_cpugenreg[ INS_RS( op ) ], pc + 4 + ( MIPS_WORD_EXTEND( INS_IMMEDIATE( op ) ) << 2 ) );
break;
case RT_BLTZAL:
sprintf( buffer, "bltzal %s,$%08x", s_cpugenreg[ INS_RS( op ) ], pc + 4 + ( MIPS_WORD_EXTEND( INS_IMMEDIATE( op ) ) << 2 ) );
break;
case RT_BGEZAL:
sprintf( buffer, "bgezal %s,$%08x", s_cpugenreg[ INS_RS( op ) ], pc + 4 + ( MIPS_WORD_EXTEND( INS_IMMEDIATE( op ) ) << 2 ) );
break;
}
break;
case OP_J:
sprintf( buffer, "j $%08x", ( ( pc + 4 ) & 0xF0000000 ) + ( INS_TARGET( op ) << 2 ) );
break;
case OP_JAL:
sprintf( buffer, "jal $%08x", ( ( pc + 4 ) & 0xF0000000 ) + ( INS_TARGET( op ) << 2 ) );
break;
case OP_BEQ:
sprintf( buffer, "beq %s,%s,$%08x", s_cpugenreg[ INS_RS( op ) ], s_cpugenreg[ INS_RT( op ) ], pc + 4 + ( MIPS_WORD_EXTEND( INS_IMMEDIATE( op ) ) << 2 ) );
break;
case OP_BNE:
sprintf( buffer, "bne %s,%s,$%08x", s_cpugenreg[ INS_RS( op ) ], s_cpugenreg[ INS_RT( op ) ], pc + 4 + ( MIPS_WORD_EXTEND( INS_IMMEDIATE( op ) ) << 2 ) );
break;
case OP_BLEZ:
if( INS_RT( op ) == 0 )
{
sprintf( buffer, "blez %s,$%08x", s_cpugenreg[ INS_RS( op ) ], pc + 4 + ( MIPS_WORD_EXTEND( INS_IMMEDIATE( op ) ) << 2 ) );
}
break;
case OP_BGTZ:
if( INS_RT( op ) == 0 )
{
sprintf( buffer, "bgtz %s,$%08x", s_cpugenreg[ INS_RS( op ) ], pc + 4 + ( MIPS_WORD_EXTEND( INS_IMMEDIATE( op ) ) << 2 ) );
}
break;
case OP_ADDI:
sprintf( buffer, "addi %s,%s,%s", s_cpugenreg[ INS_RT( op ) ], s_cpugenreg[ INS_RS( op ) ], make_signed_hex_str_16( INS_IMMEDIATE( op ) ) );
break;
case OP_ADDIU:
sprintf( buffer, "addiu %s,%s,%s", s_cpugenreg[ INS_RT( op ) ], s_cpugenreg[ INS_RS( op ) ], make_signed_hex_str_16( INS_IMMEDIATE( op ) ) );
break;
case OP_SLTI:
sprintf( buffer, "slti %s,%s,%s", s_cpugenreg[ INS_RT( op ) ], s_cpugenreg[ INS_RS( op ) ], make_signed_hex_str_16( INS_IMMEDIATE( op ) ) );
break;
case OP_SLTIU:
sprintf( buffer, "sltiu %s,%s,%s", s_cpugenreg[ INS_RT( op ) ], s_cpugenreg[ INS_RS( op ) ], make_signed_hex_str_16( INS_IMMEDIATE( op ) ) );
break;
case OP_ANDI:
sprintf( buffer, "andi %s,%s,$%04x", s_cpugenreg[ INS_RT( op ) ], s_cpugenreg[ INS_RS( op ) ], INS_IMMEDIATE( op ) );
break;
case OP_ORI:
sprintf( buffer, "ori %s,%s,$%04x", s_cpugenreg[ INS_RT( op ) ], s_cpugenreg[ INS_RS( op ) ], INS_IMMEDIATE( op ) );
break;
case OP_XORI:
sprintf( buffer, "xori %s,%s,$%04x", s_cpugenreg[ INS_RT( op ) ], s_cpugenreg[ INS_RS( op ) ], INS_IMMEDIATE( op ) );
break;
case OP_LUI:
sprintf( buffer, "lui %s,$%04x", s_cpugenreg[ INS_RT( op ) ], INS_IMMEDIATE( op ) );
break;
case OP_COP0:
switch( INS_RS( op ) )
{
case RS_MFC:
sprintf( buffer, "mfc0 %s,%s", s_cpugenreg[ INS_RT( op ) ], s_cp0genreg[ INS_RD( op ) ] );
break;
case RS_MTC:
sprintf( buffer, "mtc0 %s,%s", s_cpugenreg[ INS_RT( op ) ], s_cp0genreg[ INS_RD( op ) ] );
break;
case RS_BC:
switch( INS_RT( op ) )
{
case RT_BCF:
sprintf( buffer, "bc0f $%08x", pc + 4 + ( MIPS_WORD_EXTEND( INS_IMMEDIATE( op ) ) << 2 ) );
break;
case RT_BCT:
sprintf( buffer, "bc0t $%08x", pc + 4 + ( MIPS_WORD_EXTEND( INS_IMMEDIATE( op ) ) << 2 ) );
break;
}
break;
default:
switch( INS_CO( op ) )
{
case 1:
sprintf( buffer, "cop0 $%07x", INS_COFUN( op ) );
switch( INS_CF( op ) )
{
case 1:
sprintf( buffer, "tlbr" );
break;
case 4:
sprintf( buffer, "tlbwi" );
break;
case 6:
sprintf( buffer, "tlbwr" );
break;
case 8:
sprintf( buffer, "tlbp" );
break;
case 16:
sprintf( buffer, "rfe" );
break;
}
break;
}
break;
}
break;
case OP_COP1:
switch( INS_RS( op ) )
{
case RS_MFC:
sprintf( buffer, "mfc1 %s,%s", s_cpugenreg[ INS_RT( op ) ], s_cp1genreg[ INS_RD( op ) ] );
break;
case RS_CFC:
sprintf( buffer, "cfc1 %s,%s", s_cpugenreg[ INS_RT( op ) ], s_cp1ctlreg[ INS_RD( op ) ] );
break;
case RS_MTC:
sprintf( buffer, "mtc1 %s,%s", s_cpugenreg[ INS_RT( op ) ], s_cp1genreg[ INS_RD( op ) ] );
break;
case RS_CTC:
sprintf( buffer, "ctc1 %s,%s", s_cpugenreg[ INS_RT( op ) ], s_cp1ctlreg[ INS_RD( op ) ] );
break;
case RS_BC:
switch( INS_RT( op ) )
{
case RT_BCF:
sprintf( buffer, "bc1f $%08x", pc + 4 + ( MIPS_WORD_EXTEND( INS_IMMEDIATE( op ) ) << 2 ) );
break;
case RT_BCT:
sprintf( buffer, "bc1t $%08x", pc + 4 + ( MIPS_WORD_EXTEND( INS_IMMEDIATE( op ) ) << 2 ) );
break;
}
break;
default:
switch( INS_CO( op ) )
{
case 1:
sprintf( buffer, "cop1 $%07x", INS_COFUN( op ) );
break;
}
break;
}
break;
case OP_COP2:
switch( INS_RS( op ) )
{
case RS_MFC:
sprintf( buffer, "mfc2 %s,%s", s_cpugenreg[ INS_RT( op ) ], s_cp2genreg[ INS_RD( op ) ] );
break;
case RS_CFC:
sprintf( buffer, "cfc2 %s,%s", s_cpugenreg[ INS_RT( op ) ], s_cp2ctlreg[ INS_RD( op ) ] );
break;
case RS_MTC:
sprintf( buffer, "mtc2 %s,%s", s_cpugenreg[ INS_RT( op ) ], s_cp2genreg[ INS_RD( op ) ] );
break;
case RS_CTC:
sprintf( buffer, "ctc2 %s,%s", s_cpugenreg[ INS_RT( op ) ], s_cp2ctlreg[ INS_RD( op ) ] );
break;
case RS_BC:
switch( INS_RT( op ) )
{
case RT_BCF:
sprintf( buffer, "bc2f $%08x", pc + 4 + ( MIPS_WORD_EXTEND( INS_IMMEDIATE( op ) ) << 2 ) );
break;
case RT_BCT:
sprintf( buffer, "bc2t $%08x", pc + 4 + ( MIPS_WORD_EXTEND( INS_IMMEDIATE( op ) ) << 2 ) );
break;
}
break;
default:
switch( INS_CO( op ) )
{
case 1:
sprintf( buffer, "cop2 $%07x", INS_COFUN( op ) );
switch( GTE_FUNCT( op ) )
{
case 0x01:
if( INS_COFUN( op ) == 0x0180001 )
{
sprintf( buffer, "rtps" );
}
break;
case 0x06:
if( INS_COFUN( op ) == 0x0400006 ||
INS_COFUN( op ) == 0x1400006 ||
INS_COFUN( op ) == 0x0155cc6 )
{
sprintf( buffer, "nclip" );
}
break;
case 0x0c:
if( GTE_OP( op ) == 0x17 )
{
sprintf( buffer, "op%s", s_gtesf[ GTE_SF( op ) ] );
}
break;
case 0x10:
if( INS_COFUN( op ) == 0x0780010 )
{
sprintf( buffer, "dpcs" );
}
break;
case 0x11:
if( INS_COFUN( op ) == 0x0980011 )
{
sprintf( buffer, "intpl" );
}
break;
case 0x12:
if( GTE_OP( op ) == 0x04 )
{
sprintf( buffer, "mvmva%s %s + %s * %s (lm=%s)",
s_gtesf[ GTE_SF( op ) ], s_gtecv[ GTE_CV( op ) ], s_gtemx[ GTE_MX( op ) ],
s_gtev[ GTE_V( op ) ], s_gtelm[ GTE_LM( op ) ] );
}
break;
case 0x13:
if( INS_COFUN( op ) == 0x0e80413 )
{
sprintf( buffer, "ncds" );
}
break;
case 0x14:
if( INS_COFUN( op ) == 0x1280414 )
{
sprintf( buffer, "cdp" );
}
break;
case 0x16:
if( INS_COFUN( op ) == 0x0f80416 )
{
sprintf( buffer, "ncdt" );
}
break;
case 0x1b:
if( INS_COFUN( op ) == 0x108041b )
{
sprintf( buffer, "nccs" );
}
break;
case 0x1c:
if( INS_COFUN( op ) == 0x138041c )
{
sprintf( buffer, "cc" );
}
break;
case 0x1e:
if( INS_COFUN( op ) == 0x0c8041e )
{
sprintf( buffer, "ncs" );
}
break;
case 0x20:
if( INS_COFUN( op ) == 0x0d80420 )
{
sprintf( buffer, "nct" );
}
break;
case 0x28:
if( GTE_OP( op ) == 0x0a && GTE_LM( op ) == 1 )
{
sprintf( buffer, "sqr%s", s_gtesf[ GTE_SF( op ) ] );
}
break;
case 0x29:
if( INS_COFUN( op ) == 0x0680029 )
{
sprintf( buffer, "dcpl" );
}
break;
case 0x2a:
if( INS_COFUN( op ) == 0x0f8002a )
{
sprintf( buffer, "dpct" );
}
break;
case 0x2d:
if( INS_COFUN( op ) == 0x158002d )
{
sprintf( buffer, "avsz3" );
}
break;
case 0x2e:
if( INS_COFUN( op ) == 0x168002e )
{
sprintf( buffer, "avsz4" );
}
break;
case 0x30:
if( INS_COFUN( op ) == 0x0280030 )
{
sprintf( buffer, "rtpt" );
}
break;
case 0x3d:
if( GTE_OP( op ) == 0x09 ||
GTE_OP( op ) == 0x19 )
{
sprintf( buffer, "gpf%s", s_gtesf[ GTE_SF( op ) ] );
}
break;
case 0x3e:
if( GTE_OP( op ) == 0x1a )
{
sprintf( buffer, "gpl%s", s_gtesf[ GTE_SF( op ) ] );
}
break;
case 0x3f:
if( INS_COFUN( op ) == 0x108043f ||
INS_COFUN( op ) == 0x118043f )
{
sprintf( buffer, "ncct" );
}
break;
}
}
break;
}
break;
case OP_LB:
sprintf( buffer, "lb %s,%s", s_cpugenreg[ INS_RT( op ) ], make_address( pc, op ) );
break;
case OP_LH:
sprintf( buffer, "lh %s,%s", s_cpugenreg[ INS_RT( op ) ], make_address( pc, op ) );
break;
case OP_LWL:
sprintf( buffer, "lwl %s,%s", s_cpugenreg[ INS_RT( op ) ], make_address( pc, op ) );
break;
case OP_LW:
sprintf( buffer, "lw %s,%s", s_cpugenreg[ INS_RT( op ) ], make_address( pc, op ) );
break;
case OP_LBU:
sprintf( buffer, "lbu %s,%s", s_cpugenreg[ INS_RT( op ) ], make_address( pc, op ) );
break;
case OP_LHU:
sprintf( buffer, "lhu %s,%s", s_cpugenreg[ INS_RT( op ) ], make_address( pc, op ) );
break;
case OP_LWR:
sprintf( buffer, "lwr %s,%s", s_cpugenreg[ INS_RT( op ) ], make_address( pc, op ) );
break;
case OP_SB:
sprintf( buffer, "sb %s,%s", s_cpugenreg[ INS_RT( op ) ], make_address( pc, op ) );
break;
case OP_SH:
sprintf( buffer, "sh %s,%s", s_cpugenreg[ INS_RT( op ) ], make_address( pc, op ) );
break;
case OP_SWL:
sprintf( buffer, "swl %s,%s", s_cpugenreg[ INS_RT( op ) ], make_address( pc, op ) );
break;
case OP_SW:
sprintf( buffer, "sw %s,%s", s_cpugenreg[ INS_RT( op ) ], make_address( pc, op ) );
break;
case OP_SWR:
sprintf( buffer, "swr %s,%s", s_cpugenreg[ INS_RT( op ) ], make_address( pc, op ) );
break;
case OP_LWC1:
sprintf( buffer, "lwc1 %s,%s", s_cp1genreg[ INS_RT( op ) ], make_address( pc, op ) );
break;
case OP_LWC2:
sprintf( buffer, "lwc2 %s,%s", s_cp2genreg[ INS_RT( op ) ], make_address( pc, op ) );
break;
case OP_SWC1:
sprintf( buffer, "swc1 %s,%s", s_cp1genreg[ INS_RT( op ) ], make_address( pc, op ) );
break;
case OP_SWC2:
sprintf( buffer, "swc2 %s,%s", s_cp2genreg[ INS_RT( op ) ], make_address( pc, op ) );
break;
}
return ( opram - oldopram ) | DASMFLAG_SUPPORTED;
}
/**
* Main interpreter loop. Runs the steps of the test.
*
* @param cls NULL
* @param tc unused
*/
static void
interpreter (void *cls,
const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct Command *cmd;
interpreter_task = NULL;
while (1)
{
cmd = &test_commands[off];
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"#%u: %d %s\n",
off,
(int) cmd->code,
(NULL != cmd->label) ? cmd->label : "");
switch (cmd->code)
{
case CMD_END_PASS:
ret = 0;
GNUNET_SCHEDULER_shutdown ();
return;
case CMD_ADD_ADDRESS:
{
struct GNUNET_HELLO_Address *addr;
struct GNUNET_ATS_Session *session;
addr = make_address (cmd->details.add_address.pid,
cmd->details.add_address.addr_num,
cmd->details.add_address.addr_flags);
session = make_session (cmd->details.add_address.session);
if (cmd->details.add_address.expect_fail)
GNUNET_log_skip (1, GNUNET_NO);
cmd->details.add_address.ar
= GNUNET_ATS_address_add (sched_ats,
addr,
session,
&cmd->details.add_address.properties);
GNUNET_free (addr);
if (cmd->details.add_address.expect_fail)
{
GNUNET_log_skip (0, GNUNET_YES);
}
else if (NULL == cmd->details.add_address.ar)
{
GNUNET_break (0);
GNUNET_SCHEDULER_shutdown ();
return;
}
off++;
break;
}
case CMD_DEL_ADDRESS:
{
struct Command *add;
add = find_command (CMD_ADD_ADDRESS,
cmd->details.del_address.add_label);
GNUNET_assert (NULL != add->details.add_address.ar);
GNUNET_ATS_address_destroy (add->details.add_address.ar);
add->details.add_address.ar = NULL;
off++;
break;
}
case CMD_AWAIT_ADDRESS_SUGGESTION:
{
struct GNUNET_PeerIdentity pid;
struct GNUNET_HELLO_Address *addr;
struct Command *add;
struct AddressSuggestData *asd;
int done;
make_peer (cmd->details.await_address_suggestion.pid,
&pid);
asd = find_address_suggestion (&pid);
if (NULL == asd)
return;
if (GNUNET_NO == asd->active)
return; /* last suggestion was to disconnect, wait longer */
done = GNUNET_YES;
if (NULL != cmd->details.await_address_suggestion.add_label)
{
done = GNUNET_NO;
add = find_command (CMD_ADD_ADDRESS,
cmd->details.await_address_suggestion.add_label);
addr = make_address (add->details.add_address.pid,
add->details.add_address.addr_num,
add->details.add_address.addr_flags);
if ( (asd->session ==
make_session (add->details.add_address.session)) &&
(0 ==
GNUNET_HELLO_address_cmp (addr,
asd->address)) )
done = GNUNET_YES;
GNUNET_free (addr);
}
if (GNUNET_NO == done)
return;
off++;
break;
}
case CMD_AWAIT_DISCONNECT_SUGGESTION:
{
struct GNUNET_PeerIdentity pid;
struct AddressSuggestData *asd;
make_peer (cmd->details.await_disconnect_suggestion.pid,
&pid);
asd = find_address_suggestion (&pid);
if (NULL == asd)
return; /* odd, no suggestion at all yet!? */
if (GNUNET_YES == asd->active)
return; /* last suggestion was to activate, wait longer */
/* last suggestion was to deactivate, condition satisfied! */
off++;
break;
}
case CMD_REQUEST_CONNECTION_START:
{
struct GNUNET_PeerIdentity pid;
make_peer (cmd->details.request_connection_start.pid,
&pid);
cmd->details.request_connection_start.csh
= GNUNET_ATS_connectivity_suggest (con_ats,
&pid,
1);
off++;
break;
}
case CMD_REQUEST_CONNECTION_STOP:
{
struct Command *start;
start = find_command (CMD_REQUEST_CONNECTION_START,
cmd->details.request_connection_stop.connect_label);
GNUNET_ATS_connectivity_suggest_cancel (start->details.request_connection_start.csh);
start->details.request_connection_start.csh = NULL;
off++;
break;
}
case CMD_AWAIT_ADDRESS_INFORMATION:
{
struct AddressInformationData *aid;
struct Command *add;
struct Command *update;
struct GNUNET_HELLO_Address *addr;
const struct GNUNET_ATS_Properties *cmp;
add = find_command (CMD_ADD_ADDRESS,
cmd->details.await_address_information.add_label);
update = find_command (CMD_UPDATE_ADDRESS,
cmd->details.await_address_information.update_label);
addr = make_address (add->details.add_address.pid,
add->details.add_address.addr_num,
add->details.add_address.addr_flags);
aid = find_address_information (addr);
GNUNET_free (addr);
if (NULL == update)
cmp = &add->details.add_address.properties;
else
cmp = &update->details.update_address.properties;
if ( (NULL != aid) &&
(cmp->delay.rel_value_us == aid->properties.delay.rel_value_us) &&
(cmp->utilization_out == aid->properties.utilization_out) &&
(cmp->utilization_in == aid->properties.utilization_in) &&
(cmp->distance == aid->properties.distance) &&
(cmp->scope == aid->properties.scope) )
{
off++;
break;
}
return;
}
case CMD_UPDATE_ADDRESS:
{
struct Command *add;
add = find_command (CMD_ADD_ADDRESS,
cmd->details.update_address.add_label);
GNUNET_assert (NULL != add->details.add_address.ar);
GNUNET_ATS_address_update (add->details.add_address.ar,
&cmd->details.update_address.properties);
off++;
break;
}
case CMD_ADD_SESSION:
{
struct Command *add;
struct GNUNET_ATS_Session *session;
add = find_command (CMD_ADD_ADDRESS,
cmd->details.add_session.add_label);
session = make_session (cmd->details.add_session.session);
GNUNET_assert (NULL != add->details.add_address.ar);
GNUNET_ATS_address_add_session (add->details.add_address.ar,
session);
off++;
break;
}
case CMD_DEL_SESSION:
{
struct Command *add_address;
struct Command *add_session;
struct GNUNET_ATS_Session *session;
add_session = find_command (CMD_ADD_SESSION,
cmd->details.del_session.add_session_label);
add_address = find_command (CMD_ADD_ADDRESS,
add_session->details.add_session.add_label);
GNUNET_assert (NULL != add_address->details.add_address.ar);
session = make_session (add_session->details.add_session.session);
GNUNET_ATS_address_del_session (add_address->details.add_address.ar,
session);
off++;
break;
}
case CMD_CHANGE_PREFERENCE:
{
struct GNUNET_PeerIdentity pid;
make_peer (cmd->details.change_preference.pid,
&pid);
GNUNET_ATS_performance_change_preference (perf_ats,
&pid,
GNUNET_ATS_PREFERENCE_END);
off++;
break;
}
case CMD_PROVIDE_FEEDBACK:
{
struct GNUNET_PeerIdentity pid;
make_peer (cmd->details.provide_feedback.pid,
&pid);
GNUNET_ATS_performance_give_feedback (perf_ats,
&pid,
cmd->details.provide_feedback.scope,
GNUNET_ATS_PREFERENCE_END);
off++;
break;
}
case CMD_LIST_ADDRESSES:
{
struct GNUNET_PeerIdentity pid;
make_peer (cmd->details.list_addresses.pid,
&pid);
cmd->details.list_addresses.alh
= GNUNET_ATS_performance_list_addresses (perf_ats,
&pid,
cmd->details.list_addresses.all,
&info_cb,
cmd);
return;
}
case CMD_RESERVE_BANDWIDTH:
{
struct GNUNET_PeerIdentity pid;
make_peer (cmd->details.reserve_bandwidth.pid,
&pid);
cmd->details.reserve_bandwidth.rc
= GNUNET_ATS_reserve_bandwidth (perf_ats,
&pid,
cmd->details.reserve_bandwidth.amount,
&reservation_cb,
cmd);
return;
}
case CMD_SLEEP:
off++;
interpreter_task = GNUNET_SCHEDULER_add_delayed (cmd->details.sleep.delay,
&interpreter,
NULL);
return;
} /* end switch */
} /* end while(1) */
}
