void csp_service_handler(csp_conn_t * conn, csp_packet_t * packet) {
switch (csp_conn_dport(conn)) {
case CSP_CMP:
/* Pass to CMP handler */
if (csp_cmp_handler(conn, packet) != CSP_ERR_NONE) {
csp_buffer_free(packet);
return;
}
break;
case CSP_PING:
/* A ping means, just echo the packet, so no changes */
csp_log_info("SERVICE: Ping received");
break;
case CSP_PS: {
/* Sanity check on request */
if ((packet->length != 1) || (packet->data[0] != 0x55)) {
/* Sanity check failed */
csp_buffer_free(packet);
/* Clear the packet, it has been freed */
packet = NULL;
break;
}
/* Start by allocating just the right amount of memory */
int task_list_size = csp_sys_tasklist_size();
char * pslist = csp_malloc(task_list_size);
/* Check for malloc fail */
if (pslist == NULL) {
/* Send out the data */
strcpy((char *)packet->data, "Not enough memory");
packet->length = strlen((char *)packet->data);
/* Break and let the default handling send packet */
break;
}
/* Retrieve the tasklist */
csp_sys_tasklist(pslist);
int pslen = strnlen(pslist, task_list_size);
/* Split the potentially very long string into packets */
int i = 0;
while(i < pslen) {
/* Allocate packet buffer, if need be */
if (packet == NULL)
packet = csp_buffer_get(CSP_RPS_MTU);
if (packet == NULL)
break;
/* Calculate length, either full MTU or the remainder */
packet->length = (pslen - i > CSP_RPS_MTU) ? CSP_RPS_MTU : (pslen - i);
/* Send out the data */
memcpy(packet->data, &pslist[i], packet->length);
i += packet->length;
if (!csp_send(conn, packet, 0))
csp_buffer_free(packet);
/* Clear the packet reference when sent */
packet = NULL;
}
csp_free(pslist);
break;
}
case CSP_MEMFREE: {
uint32_t total = csp_sys_memfree();
total = csp_hton32(total);
memcpy(packet->data, &total, sizeof(total));
packet->length = sizeof(total);
break;
}
case CSP_REBOOT: {
uint32_t magic_word;
memcpy(&magic_word, packet->data, sizeof(magic_word));
magic_word = csp_ntoh32(magic_word);
/* If the magic word is valid, reboot */
if (magic_word == CSP_REBOOT_MAGIC) {
csp_sys_reboot();
} else if (magic_word == CSP_REBOOT_SHUTDOWN_MAGIC) {
csp_sys_shutdown();
}
csp_buffer_free(packet);
return;
}
case CSP_BUF_FREE: {
uint32_t size = csp_buffer_remaining();
size = csp_hton32(size);
memcpy(packet->data, &size, sizeof(size));
packet->length = sizeof(size);
break;
}
case CSP_UPTIME: {
uint32_t time = csp_get_s();
time = csp_hton32(time);
memcpy(packet->data, &time, sizeof(time));
packet->length = sizeof(time);
break;
}
default:
csp_buffer_free(packet);
return;
}
if (packet != NULL) {
if (!csp_send(conn, packet, 0))
csp_buffer_free(packet);
}
}
void csp_service_handler(csp_conn_t * conn, csp_packet_t * packet) {
switch (csp_conn_dport(conn)) {
case CSP_CMP:
/* Pass to CMP handler */
if (csp_cmp_handler(conn, packet) != CSP_ERR_NONE) {
csp_buffer_free(packet);
return;
}
break;
case CSP_PING:
/* A ping means, just echo the packet, so no changes */
csp_log_info("SERVICE: Ping received\r\n");
break;
case CSP_PS: {
csp_sys_tasklist((char *)packet->data);
packet->length = strlen((char *)packet->data);
packet->data[packet->length] = '\0';
packet->length++;
break;
}
case CSP_MEMFREE: {
uint32_t total = csp_sys_memfree();
total = csp_hton32(total);
memcpy(packet->data, &total, sizeof(total));
packet->length = sizeof(total);
break;
}
case CSP_REBOOT: {
uint32_t magic_word;
memcpy(&magic_word, packet->data, sizeof(magic_word));
magic_word = csp_ntoh32(magic_word);
/* If the magic word is invalid, return */
if (magic_word != 0x80078007) {
csp_buffer_free(packet);
return;
}
/* Otherwise Reboot */
csp_sys_reboot();
csp_buffer_free(packet);
return;
}
case CSP_BUF_FREE: {
uint32_t size = csp_buffer_remaining();
size = csp_hton32(size);
memcpy(packet->data, &size, sizeof(size));
packet->length = sizeof(size);
break;
}
case CSP_UPTIME: {
uint32_t time = csp_get_s();
time = csp_hton32(time);
memcpy(packet->data, &time, sizeof(time));
packet->length = sizeof(time);
break;
}
/** @brief Returns route information
* If no data received, sends back number of routes that exist,
* otherwise returns up to nodes_requested, starting at index parameter
* First parameter is index of table to start at, and
* second parameter is number of indeces to return
*/
case CSP_GET_ROUTE: {
//if there is no data, return number of routes that exist
if(packet->length == 0)
{
uint8_t routes_left = csp_num_routes_left(0);
packet->length = sizeof(routes_left);
memcpy(&packet->data[0], &routes_left, sizeof(routes_left));
break;
}
//otherwise, return node information
csp_route_t * route;
uint8_t start_index,i, j, nodes_requested, routes_left;
memcpy(&start_index, &packet->data[0], sizeof(start_index));
memcpy(&nodes_requested, &packet->data[1], sizeof(nodes_requested));
csp_route_info return_info[nodes_requested];
memset(return_info, 0x00, sizeof(return_info));
//don't attempt to read beyond size of routes array
if(start_index >= CSP_ROUTE_COUNT){
csp_buffer_free(packet);
printf("CSP_GET_ROUTE: won't read past array\r\n");
return;
}
i = start_index;
j = 0;
//populated return_info while j index less than number
//of nodes requested and our i index is less than CSP_ROUTE_COUNT
while((j < nodes_requested) && (i < CSP_ROUTE_COUNT)){
route = csp_route_struct(i);
if(route != NULL){
return_info[j].node = i;
strncpy(&return_info[j].name_buffer[0],route->interface->name,
(sizeof(return_info[j].name_buffer)-1));
return_info[j].nexthop_mac_addr = route->nexthop_mac_addr;
if(i != CSP_DEFAULT_ROUTE){
return_info[j].nexthop_mac_addr = route->nexthop_mac_addr
== CSP_NODE_MAC ?(i) : route->nexthop_mac_addr;
}
else return_info[j].nexthop_mac_addr = route->nexthop_mac_addr;
j++;
}
i++;
}
routes_left = csp_num_routes_left(i);
//return data contains number of remaining nodes and node info
packet->length = sizeof(return_info)+sizeof(routes_left);
memcpy(&packet->data[0], &routes_left,sizeof(routes_left));
memcpy(&packet->data[1], return_info, sizeof(return_info));
break;
}
default:
csp_buffer_free(packet);
return;
}
if (!csp_send(conn, packet, 0))
csp_buffer_free(packet);
}
void csp_service_handler(csp_conn_t * conn, csp_packet_t * packet) {
switch (csp_conn_dport(conn)) {
case CSP_CMP:
/* Pass to CMP handler */
if (csp_cmp_handler(conn, packet) != CSP_ERR_NONE) {
csp_buffer_free(packet);
return;
}
break;
case CSP_PING:
/* A ping means, just echo the packet, so no changes */
csp_log_info("SERVICE: Ping received\r\n");
break;
case CSP_PS: {
csp_sys_tasklist((char *)packet->data);
packet->length = strlen((char *)packet->data);
packet->data[packet->length] = '\0';
packet->length++;
break;
}
case CSP_MEMFREE: {
uint32_t total = csp_sys_memfree();
total = csp_hton32(total);
memcpy(packet->data, &total, sizeof(total));
packet->length = sizeof(total);
break;
}
case CSP_REBOOT: {
uint32_t magic_word;
memcpy(&magic_word, packet->data, sizeof(magic_word));
magic_word = csp_ntoh32(magic_word);
/* If the magic word is invalid, return */
if (magic_word != 0x80078007) {
csp_buffer_free(packet);
return;
}
/* Otherwise Reboot */
csp_sys_reboot();
csp_buffer_free(packet);
return;
}
case CSP_BUF_FREE: {
uint32_t size = csp_buffer_remaining();
size = csp_hton32(size);
memcpy(packet->data, &size, sizeof(size));
packet->length = sizeof(size);
break;
}
case CSP_UPTIME: {
uint32_t time = csp_get_s();
time = csp_hton32(time);
memcpy(packet->data, &time, sizeof(time));
packet->length = sizeof(time);
break;
}
default:
csp_buffer_free(packet);
return;
}
if (!csp_send(conn, packet, 0))
csp_buffer_free(packet);
}