void process_server_info(struct sockaddr_in *sockaddr, struct buffer_t *buffer)
{
struct queried_server_t *cserver = queried_servers;
struct found_server_t new_server_info;
uint16_t servers;
struct sockaddr_in s;
time_t t;
int proto_ver;
while(cserver)
{
if(cserver->ip == sockaddr->sin_addr.s_addr &&
cserver->port == sockaddr->sin_port)
{
proto_ver = buffer_read_uint8(buffer);
if(proto_ver != EM_PROTO_VER)
{
if(proto_ver > EM_PROTO_VER)
num_servers_new_proto++;
break;
}
new_server_info.ip = sockaddr->sin_addr.s_addr;
new_server_info.port = sockaddr->sin_port;
new_server_info.ping = get_wall_time() - cserver->stamp;
new_server_info.host_name = buffer_read_string(buffer);
new_server_info.map_name = buffer_read_string(buffer);
new_server_info.num_players = buffer_read_uint8(buffer);
new_server_info.max_players = buffer_read_uint8(buffer);
new_server_info.authenticating = buffer_read_uint8(buffer);
add_new_found_server(&new_server_info);
add_new_server(&rumoured_servers, sockaddr, time(NULL));
servers = buffer_read_uint16(buffer);
while(servers--)
{
s.sin_addr.s_addr = buffer_read_uint32(buffer);
s.sin_port = buffer_read_uint16(buffer);
t = buffer_read_uint32(buffer);
if(!find_queried_server(s.sin_addr.s_addr, s.sin_port))
{
if(add_new_server(&unqueried_servers, &s, t))
num_servers_unqueried++;
}
}
break;
}
LL_NEXT(cserver);
}
}
bool unabto_buffer_test(void) {
char * raw_test_string = "asjdhc#21?(!?(92814skzjbcasa";
uint8_t data[7 + 2 + strlen(raw_test_string)];
unabto_buffer buf, raw_string_buf;
buffer_write_t w_buf;
buffer_read_t r_buf;
uint32_t t32;
uint16_t t16;
uint8_t t8;
uint8_t raw_string_data[strlen(raw_test_string) + 1];
buffer_init(&raw_string_buf, (uint8_t*)raw_test_string, strlen(raw_test_string));
buffer_init(&buf, data, sizeof(data));
buffer_write_init(&w_buf, &buf);
if (! (buffer_write_uint32(&w_buf, 0x12345678) &&
buffer_write_uint16(&w_buf, 0x1234) &&
buffer_write_uint8(&w_buf, 0x12) &&
buffer_write_raw(&w_buf, &raw_string_buf) ) ) {
NABTO_LOG_ERROR(("Buffer write test failed"));
return false;
}
buffer_read_init(&r_buf, &buf);
memset(raw_string_data, 0, sizeof(raw_string_data) + 1);
buffer_init(&raw_string_buf, raw_string_data, sizeof(raw_string_data));
bool t = false;
if (! ( buffer_read_uint32(&r_buf, &t32) && t32 == 0x12345678 &&
buffer_read_uint16(&r_buf, &t16) && t16 == 0x1234 &&
buffer_read_uint8(&r_buf, &t8) && t8 == 0x12 &&
(t = buffer_read_raw(&r_buf, &raw_string_buf)) && buffer_get_size(&raw_string_buf) == strlen(raw_test_string) &&
0 == strncmp((char*)buffer_get_data(&raw_string_buf), raw_test_string, strlen(raw_test_string)) )) {
NABTO_LOG_ERROR(("Failed read test failed"));
return false;
}
if (buffer_read_uint32(&r_buf, &t32) ||
buffer_read_uint16(&r_buf, &t16) ||
buffer_read_uint8(&r_buf, &t8) ||
buffer_read_raw(&w_buf, &raw_string_buf) ||
buffer_write_uint32(&w_buf, 0x12345678) ||
buffer_write_uint16(&w_buf, 0x1234) ||
buffer_write_uint8(&w_buf, 0x12) ||
buffer_write_raw(&w_buf, &raw_string_buf) ) {
NABTO_LOG_ERROR(("Some function should have returned false but returned true"));
return false;
}
return true;
}
/***************** The uNabto application logic *****************
* This is where the user implements his/her own functionality
* to the device. When a Nabto message is received, this function
* gets called with the message's request id and parameters.
* Afterwards a user defined message can be sent back to the
* requesting browser.
****************************************************************/
application_event_result application_event(application_request* request, buffer_read_t* read_buffer, buffer_write_t* write_buffer) {
switch(request->queryId) {
case 1: {
/** Get acceleration data */
extern int16_t gAccData[3];
uint16_t acc_x;
uint16_t acc_y;
uint16_t acc_z;
// Get accelerometer data and calculate yaw, pitch and roll with offset
Accelerometer_Get();
acc_x = gAccData[0] + 0xFF;
acc_y = gAccData[1] + 0xFF;
acc_z = gAccData[2] + 0xFF;
// Write back data
if (!buffer_write_uint16(write_buffer, acc_x)) return AER_REQ_RSP_TOO_LARGE;
if (!buffer_write_uint16(write_buffer, acc_y)) return AER_REQ_RSP_TOO_LARGE;
if (!buffer_write_uint16(write_buffer, acc_z)) return AER_REQ_RSP_TOO_LARGE;
return AER_REQ_RESPONSE_READY;
}
case 2: {
/** Get temperature data */
uint16_t temp;
temp = Temperature_Get();
// Write back data
if (!buffer_write_uint16(write_buffer, temp)) return AER_REQ_RSP_TOO_LARGE;
return AER_REQ_RESPONSE_READY;
}
case 3: {
/** Get light level */
uint16_t light;
light = LightSensor_Get();
// Write back data
if (!buffer_write_uint16(write_buffer, light)) return AER_REQ_RSP_TOO_LARGE;
return AER_REQ_RESPONSE_READY;
}
case 4: {
/** Get potentiometer data */
uint32_t pot;
pot = Potentiometer_Get();
// Write back data
if (!buffer_write_uint32(write_buffer, pot)) return AER_REQ_RSP_TOO_LARGE;
return AER_REQ_RESPONSE_READY;
}
case 5: {
/** Get button status */
uint8_t button1;
uint8_t button2;
uint8_t button3;
button1 = Switch1IsPressed();
button2 = Switch2IsPressed();
button3 = Switch3IsPressed();
// Write back data
if (!buffer_write_uint8(write_buffer, button1)) return AER_REQ_RSP_TOO_LARGE;
if (!buffer_write_uint8(write_buffer, button2)) return AER_REQ_RSP_TOO_LARGE;
if (!buffer_write_uint8(write_buffer, button3)) return AER_REQ_RSP_TOO_LARGE;
return AER_REQ_RESPONSE_READY;
}
case 6: {
/** Get sound level */
uint32_t sound;
sound = Microphone_Get();
// Write back data
if (!buffer_write_uint32(write_buffer, sound)) return AER_REQ_RSP_TOO_LARGE;
return AER_REQ_RESPONSE_READY;
}
case 7: {
/** Set LED */
uint16_t led;
// Read parameters in request
if (!buffer_read_uint16(read_buffer, &led)) return AER_REQ_TOO_SMALL;
if (led == 1) {
led_all_on();
} else {
led_all_off();
}
// Write back data
if (!buffer_write_uint16(write_buffer, led)) return AER_REQ_RSP_TOO_LARGE;
return AER_REQ_RESPONSE_READY;
}
}
return AER_REQ_INV_QUERY_ID;
}
