static void
handle_command(int argc, char **argv)
{
char *command = argv[0];
argc -= 1;
argv += 1;
if (!strcmp(command, "ping"))
handle_ping(argc, argv);
else if (!strcmp(command, "add-ip"))
handle_add_ip(argc, argv);
else if (!strcmp(command, "add-node"))
handle_add_node(argc, argv);
else if (!strcmp(command, "remove-ip"))
handle_remove_ip(argc, argv);
else if (!strcmp(command, "remove-node"))
handle_remove_node(argc, argv);
else if (!strcmp(command, "show-ip"))
handle_show_ip(argc, argv);
else if (!strcmp(command, "show-node"))
handle_show_node(argc, argv);
else if (!strcmp(command, "status"))
handle_status(argc, argv);
else
usage();
}
static bool
dispatch_handler(int fd, struct ircmsg *msg)
{
switch (msg->type) {
case IRCMSG_UNKNOWN: return true;
case IRCMSG_PING: return handle_ping(fd, &msg->u.ping);
case IRCMSG_PART: return handle_part(fd, &msg->u.part);
case IRCMSG_JOIN: return handle_join(fd, &msg->u.join);
case IRCMSG_PRIVMSG: return handle_privmsg(fd, &msg->u.privmsg);
case IRCMSG_KICK: return handle_kick(fd, &msg->u.kick);
default: return false;
}
}
void
idleTracker()
{
int sockstat = socksnotready;
int i;
//float pingf;
//short *ping=malloc(sizeof(short));
int ping;
//char str[255];
sockstat = Net_checksocket(Net_gettrackersock());
while( ready_ping() )
{
handle_ping(servers);
for(i=0; i<nbservers; ++i)
{
printf("%d %d\n", servers[i].ping, servers[i].packets);
if( servers[i].packets > 0 )
{
printf("new ping is %d ( %d )\n", servers[i].ping, servers[i].packets);
//sprintf(str, "%d", servers[i].ping/servers[i].packets);
ping = (servers[i].ping/servers[i].packets)*1;
//*ping = (int)(pingf);
//(*ping)=(int)(pingf)*1;
printf("ping is %d\n", ping);
/*********************************************************v****/
setCell_wlist ( tracker.serverlist, (char *)&ping, sizeof(int), i, 3 );
rebuildindex_wlist(tracker.serverlist);
}
}
}
//free(ping);
if( sockstat != socksnotready )
{
if( sockstat & tcpsockready )
{
tracker_handle();
}
}
SystemPostRedisplay();
}
/*!
* Dispatch an asynchronous request by invoking the respective callback. If no
* matching command is found, return an error.
*
* \param[in] req Request
* \param[in,out] res Result
* \param[in,out] drv_state Driver state
* \param[in,out] trd_state Thread state
*/
extern void
dispatch(gd_req_t *req, gd_res_t *res, void *drv_state, void *trd_state) {
gdt_drv_t *drv = drv_state;
gdt_trd_t *trd = trd_state;
/* Dispatch the request */
switch (req->cmd) {
case GDE_CMD_SUM:
handle_sum(req, res, drv, trd);
break;
case GDE_CMD_PING:
handle_ping(req, res, drv, trd);
break;
case GDE_CMD_STATS:
handle_stats(req, res, drv, trd);
break;
default:
error_set(res, GDE_ERR_COMMAND);
}
}
static bool
handle_command (mock_server_t *server,
mongoc_stream_t *client,
mongoc_rpc_t *rpc)
{
int32_t len;
bool ret = false;
bson_iter_t iter;
const char *key;
bson_t doc;
BSON_ASSERT (rpc);
if (rpc->header.opcode != MONGOC_OPCODE_QUERY) {
return false;
}
memcpy (&len, rpc->query.query, 4);
len = BSON_UINT32_FROM_LE (len);
if (!bson_init_static (&doc, rpc->query.query, len)) {
return false;
}
if (!bson_iter_init (&iter, &doc) || !bson_iter_next (&iter)) {
return false;
}
key = bson_iter_key (&iter);
if (!strcasecmp (key, "ismaster")) {
ret = handle_ismaster (server, client, rpc, &doc);
} else if (!strcasecmp (key, "ping")) {
ret = handle_ping (server, client, rpc, &doc);
}
bson_destroy (&doc);
return ret;
}
void driver_command_data_received(driver_command_t *driver, uint8_t *data, size_t length)
{
command_packet_t *in = NULL;
command_packet_t *out = NULL;
buffer_add_bytes(driver->stream, data, length);
while((in = command_packet_read(driver->stream)))
{
/* TUNNEL_DATA commands are too noisy to print. */
if(in->command_id != TUNNEL_DATA)
{
printf("Got a command: ");
command_packet_print(in);
}
switch(in->command_id)
{
case COMMAND_PING:
out = handle_ping(driver, in);
break;
case COMMAND_SHELL:
out = handle_shell(driver, in);
break;
case COMMAND_EXEC:
out = handle_exec(driver, in);
break;
case COMMAND_DOWNLOAD:
out = handle_download(driver, in);
break;
case COMMAND_UPLOAD:
out = handle_upload(driver, in);
break;
case COMMAND_SHUTDOWN:
out = handle_shutdown(driver, in);
break;
case COMMAND_DELAY:
out = handle_delay(driver, in);
break;
case TUNNEL_CONNECT:
out = handle_tunnel_connect(driver, in);
break;
case TUNNEL_DATA:
out = handle_tunnel_data(driver, in);
break;
case TUNNEL_CLOSE:
out = handle_tunnel_close(driver, in);
break;
case COMMAND_ERROR:
out = handle_error(driver, in);
break;
default:
LOG_ERROR("Got a command packet that we don't know how to handle!\n");
out = command_packet_create_error_response(in->request_id, 0xFFFF, "Not implemented yet!");
}
/* Respond if and only if an outgoing packet was created. */
if(out)
{
uint8_t *data;
size_t length;
if(out->command_id != TUNNEL_DATA)
{
printf("Response: ");
command_packet_print(out);
}
data = command_packet_to_bytes(out, &length);
buffer_add_bytes(driver->outgoing_data, data, length);
safe_free(data);
command_packet_destroy(out);
}
command_packet_destroy(in);
}
}
int
main(int argc, char *argv[])
{
const char *filename;
bool skip_hs = false;
bool with_dump_headers = false;
int fd, c;
setvbuf(stdout, NULL, _IOLBF, 0);
while (-1 != (c = getopt(argc, argv, "DHh"))) {
switch (c) {
case 'h':
usage(EXIT_SUCCESS);
break;
case 'H':
skip_hs = true;
break;
case 'D':
with_dump_headers = true;
break;
default:
fprintf(stderr, "Unsupported option: -- %c\n", c);
usage(EXIT_FAILURE);
}
}
argc -= optind;
argv += optind;
if (argc > 1) {
fprintf(stderr,
"Error: "
"Specify exactly one filename or none to read from the standard input."
"\n");
usage(EXIT_FAILURE);
}
filename = argv[0];
if (filename) {
fd = open(filename, O_RDONLY, 0);
if (fd < 0) {
fprintf(stderr, "open(\"%s\", O_RDONLY, 0) failed: %s\n",
filename, strerror(errno));
exit(EXIT_FAILURE);
}
} else {
fd = STDIN_FILENO;
}
/* Discard the handshake */
if (skip_hs) {
if (0 != skip_handshake(fd)) {
fprintf(stderr, "Failed to skip handshake\n");
exit(EXIT_FAILURE);
}
printf("Skipped handshake\n");
}
for (;;) {
struct gnutella_header header;
static char *payload;
size_t ret;
uint32_t payload_size;
STATIC_ASSERT(23 == sizeof header);
if (!payload) {
payload = malloc(GNUTELLA_MAX_PAYLOAD);
if (!payload) {
fprintf(stderr, "malloc(%lu) failed: %s",
(unsigned long) GNUTELLA_MAX_PAYLOAD, strerror(errno));
return -1;
}
}
if (with_dump_headers) {
struct dump_header dh;
safe_read(fd, &dh, sizeof dh);
if (dh.flags & DH_F_TO) {
struct dump_header dh_from;
safe_read(fd, &dh_from, sizeof dh_from);
print_dump_from_header(&dh_from);
print_dump_to_header(&dh);
} else {
print_dump_from_header(&dh);
}
}
ret = fill_buffer_from_fd(fd, &header, sizeof header);
switch (ret) {
case 0:
fprintf(stderr, "Error: Unexpected end of file.\n");
exit(EXIT_FAILURE);
case (size_t) -1:
fprintf(stderr, "Error: Could not fill packet buffer: %s\n",
strerror(errno));
exit(EXIT_FAILURE);
case 1:
break;
default:
RUNTIME_ASSERT(0);
}
payload_size = peek_le32(header.size);
if (payload_size > GNUTELLA_MAX_PAYLOAD) {
fprintf(stderr, "Error: Message is too large.\n");
return -1;
}
if (payload_size > 0) {
ret = fill_buffer_from_fd(fd, payload, payload_size);
switch (ret) {
case 0:
case (size_t) -1:
exit(EXIT_FAILURE);
case 1:
break;
default:
RUNTIME_ASSERT(0);
}
}
printf("GUID: %08lx-%08lx-%08lx-%08lx\n",
(unsigned long) peek_be32(&header.guid.data[0]),
(unsigned long) peek_be32(&header.guid.data[4]),
(unsigned long) peek_be32(&header.guid.data[8]),
(unsigned long) peek_be32(&header.guid.data[12]));
if (header.type != GPT_DHT) {
printf("Type: %s\n", packet_type_to_string(header.type));
printf("TTL : %u\n", (unsigned char) header.ttl);
printf("Hops: %u\n", (unsigned char) header.hops);
printf("Size: %lu\n", (unsigned long) payload_size);
} else {
printf("Type: %s\n", kademlia_type_to_string(header.type));
printf("V : %u.%u\n",
(unsigned char) header.ttl, (unsigned char) header.hops);
printf("Size: %lu\n", (unsigned long) payload_size + 23 - 61);
}
printf("--\n");
switch ((enum gnutella_packet_type) header.type) {
case GPT_PING: handle_ping(payload, payload_size); break;
case GPT_PONG: handle_pong(payload, payload_size); break;
case GPT_QRP: handle_qrp(payload, payload_size); break;
case GPT_VMSG_PRIV: handle_vmsg_priv(&header, payload, payload_size); break;
case GPT_VMSG_STD: handle_vmsg_std(payload, payload_size); break;
case GPT_PUSH: handle_push(payload, payload_size); break;
case GPT_RUDP: handle_rudp(payload, payload_size); break;
case GPT_DHT: handle_dht(payload, payload_size); break;
case GPT_QUERY: handle_query(&header, payload, payload_size); break;
case GPT_QHIT: handle_qhit(payload, payload_size); break;
case GPT_HSEP: handle_hsep(payload, payload_size); break;
}
printf("==========\n");
}
return 0;
}
