static wiced_result_t receive_data(wiced_tcp_socket_t *sock, uint32_t timeout, char **p_buf, uint32_t *len) {
wiced_packet_t *packet;
uint16_t data_offset;
uint16_t data_len;
uint16_t total_data_len;
uint8_t *data;
char *curr;
WICED_VERIFY(wiced_tcp_receive(sock, &packet, timeout));
data_offset = 0;
wiced_packet_get_data(packet, data_offset, &data, &data_len, &total_data_len);
*p_buf = (char *)malloc(sizeof(char) * ((size_t)total_data_len + 1));
curr = *p_buf;
memcpy(*p_buf, data, data_len);
data_offset = (uint16_t)(data_offset + data_len);
curr += data_len;
while (data_len < total_data_len) {
wiced_packet_get_data(packet, data_offset, &data, &data_len, &total_data_len);
memcpy(curr, data, data_len);
data_offset = (uint16_t)(data_offset + data_len);
curr += data_len;
}
*curr = '\0';
*len = total_data_len;
wiced_packet_delete(packet);
return WICED_SUCCESS;
}
int read_packet_and_dispose(tcp_packet_t& packet, void* buffer, int len, wiced_tcp_socket_t* tcp_socket, int _timeout)
{
int bytes_read = 0;
if (!packet.packet) {
packet.offset = 0;
wiced_result_t result = wiced_tcp_receive(tcp_socket, &packet.packet, _timeout);
if (result!=WICED_SUCCESS && result!=WICED_TIMEOUT) {
DEBUG("Socket %d receive fail %d", (int)(int)tcp_socket->socket, int(result));
return -result;
}
}
uint8_t* data;
uint16_t available;
uint16_t total;
bool dispose = true;
if (packet.packet && (wiced_packet_get_data(packet.packet, packet.offset, &data, &available, &total)==WICED_SUCCESS)) {
int read = std::min(uint16_t(len), available);
packet.offset += read;
memcpy(buffer, data, read);
dispose = (total==read);
bytes_read = read;
DEBUG("Socket %d receive bytes %d of %d", (int)(int)tcp_socket->socket, int(bytes_read), int(available));
}
if (dispose) {
packet.dispose_packet();
}
return bytes_read;
}
wiced_result_t wiced_tcp_stream_read_with_count( wiced_tcp_stream_t* tcp_stream, void* buffer, uint16_t buffer_length, uint32_t timeout, uint32_t* read_count )
{
WICED_LINK_CHECK_TCP_SOCKET( tcp_stream->socket );
if ( read_count != NULL )
{
*read_count = 0;
}
while ( buffer_length != 0 )
{
uint16_t amount_to_read;
uint16_t total_available;
uint8_t* packet_data = NULL;
uint16_t space_available = 0;
/* Check if we don't have a packet */
if (tcp_stream->rx_packet == NULL)
{
wiced_result_t result;
result = wiced_tcp_receive(tcp_stream->socket, &tcp_stream->rx_packet, timeout );
if ( result != WICED_TCPIP_SUCCESS)
{
if ( ( read_count != NULL ) && ( *read_count != 0 ) )
{
result = WICED_TCPIP_SUCCESS;
}
return result;
}
}
wiced_packet_get_data(tcp_stream->rx_packet, 0, &packet_data, &space_available, &total_available);
/* Read data */
amount_to_read = MIN(buffer_length, space_available);
buffer = MEMCAT((uint8_t*)buffer, packet_data, amount_to_read);
if ( read_count != NULL )
{
*read_count += amount_to_read;
}
/* Update buffer length */
buffer_length = (uint16_t)(buffer_length - amount_to_read);
/* Check if we need a new packet */
if ( amount_to_read == space_available )
{
wiced_packet_delete( tcp_stream->rx_packet );
tcp_stream->rx_packet = NULL;
}
else
{
/* Otherwise update the start of the data for the next read request */
wiced_packet_set_data_start(tcp_stream->rx_packet, packet_data + amount_to_read);
}
}
return WICED_TCPIP_SUCCESS;
}
wiced_result_t xively_flush_datastream( xively_datastream_t* stream )
{
wiced_packet_t* response_packet;
WICED_VERIFY( wiced_tcp_stream_flush( &stream->tcp_stream ) );
/* Receive and free response packet */
if ( wiced_tcp_receive( stream->tcp_stream.socket, &response_packet, 3000 ) == WICED_SUCCESS )
{
uint8_t* data;
uint16_t data_length;
uint16_t available_data_length;
char* is_ok_found;
/* Parse HTTP response. */
wiced_packet_get_data( response_packet, 0, &data, &data_length, &available_data_length );
/* Ensure that packet payload is NUL-terminated */
*( data + data_length - 1 ) = 0;
/* Find OK. Returns NULL of not found */
is_ok_found = strstr( (char*) data, (char*) "OK" );
wiced_packet_delete( response_packet );
/* OK found. */
if ( is_ok_found != NULL )
{
return WICED_SUCCESS;
}
/* If Not OK, assert flag to perform DNS query in the next data sending */
is_ip_address_resolved = WICED_FALSE;
}
return WICED_ERROR;
}
int
rwl_read_eth_port(void* hndle, char* read_buf, unsigned int data_size, unsigned int *numread)
{
wiced_result_t result = WICED_SUCCESS;
char* request;
uint16_t request_length;
uint16_t available_data_length;
wiced_packet_t* temp_packet = NULL;
*numread = 0;
if ( data_size == 0 )
{
return SUCCESS;
}
if (wiced_tcp_receive( &tcp_client_socket, &temp_packet, WICED_WAIT_FOREVER ) == WICED_SUCCESS)
{
result = result;
if (temp_packet)
{
/* Process the client request */
wiced_packet_get_data( temp_packet, 0, (uint8_t **)&request, &request_length, &available_data_length );
}
memcpy(read_buf,request,data_size);
// read_buf = request;
*numread = request_length;
wiced_packet_delete( temp_packet );
}
return SUCCESS;
}
static void tcp_server_thread_main(uint32_t arg)
{
tcp_server_handle_t* server = (tcp_server_handle_t*) arg;
while ( quit != WICED_TRUE )
{
wiced_packet_t* temp_packet = NULL;
/* Wait for a connection */
wiced_result_t result = wiced_tcp_accept( &server->socket );
#ifdef TCP_KEEPALIVE_ENABLED
result = wiced_tcp_enable_keepalive(&server->socket, TCP_SERVER_KEEP_ALIVE_INTERVAL, TCP_SERVER_KEEP_ALIVE_PROBES, TCP_SERVER_KEEP_ALIVE_TIME );
if( result != WICED_SUCCESS )
{
WPRINT_APP_INFO(("Keep alive initialization failed \n"));
}
#endif /* TCP_KEEPALIVE_ENABLED */
if ( result == WICED_SUCCESS )
{
/* Receive the query from the TCP client */
if (wiced_tcp_receive( &server->socket, &temp_packet, WICED_WAIT_FOREVER ) == WICED_SUCCESS)
{
/* Process the client request */
tcp_server_process( server, temp_packet );
/* Delete the packet, we're done with it */
wiced_packet_delete( temp_packet );
#ifdef TCP_KEEPALIVE_ENABLED
WPRINT_APP_INFO(("Waiting for data on a socket\n"));
/* Check keepalive: wait to see whether the keepalive protocol has commenced */
/* This is achieved by waiting forever for a packet to be received on the TCP connection*/
if (wiced_tcp_receive( &server->socket, &temp_packet, WICED_WAIT_FOREVER ) == WICED_SUCCESS)
{
tcp_server_process( server, temp_packet );
/* Release the packet, we don't need it any more */
wiced_packet_delete( temp_packet );
}
else
{
WPRINT_APP_INFO(("Connection has been dropped by networking stack\n\n"));
}
#endif /* TCP_KEEPALIVE_ENABLED */
}
else
{
/* Send failed or connection has been lost, close the existing connection and */
/* get ready to accept the next one */
wiced_tcp_disconnect( &server->socket );
}
}
}
WPRINT_APP_INFO(("Disconnect\n"));
wiced_tcp_disconnect( &server->socket );
WICED_END_OF_CURRENT_THREAD( );
}
wiced_result_t wiced_establish_websocket_handshake( wiced_websocket_t* websocket, wiced_websocket_handshake_fields_t* websocket_header_fields )
{
wiced_tcp_stream_t stream;
wiced_packet_t* tcp_reply_packet;
uint16_t tcp_data_available;
uint16_t total_received_bytes;
uint8_t* received_handshake;
/*Initialise the tcp stream*/
wiced_tcp_stream_init(&stream, &websocket->socket);
/*Initialise key array*/
memset(websocket_key_base64,0x0,CLIENT_WEBSOCKET_BASE64_KEY_LENGTH);
/*generate a unique websocket key to send to server as part of initial handshake*/
WICED_VERIFY( wiced_generate_client_websocket_key( websocket_key_base64 ) );
/*build the handshaking headers*/
/*< GET /uri HTTP/1.1 >*/
wiced_tcp_stream_write( &stream, "GET ",( uint16_t )strlen("GET ") );
wiced_tcp_stream_write(&stream, websocket_header_fields->request_uri, ( uint16_t )strlen(websocket_header_fields->request_uri) );
wiced_tcp_stream_write( &stream, " HTTP/1.1\r\n",( uint16_t )strlen(" HTTP/1.1\r\n") );
/*< Host: ip1.ip2.ip3.ip4 >*/
wiced_tcp_stream_write( &stream, "Host: ",( uint16_t )strlen("Host: ") );
wiced_tcp_stream_write(&stream, websocket_header_fields->host, ( uint16_t )strlen(websocket_header_fields->host) );
wiced_tcp_stream_write( &stream, "\r\n",( uint16_t )strlen("\r\n") );
/*< Upgrade: websocket>*/
wiced_tcp_stream_write(&stream, "Upgrade: websocket\r\n",( uint16_t )strlen("Upgrade: websocket\r\n") );
/*< Connection: Upgrade >*/
wiced_tcp_stream_write(&stream, "Connection: Upgrade\r\n",( uint16_t )strlen("Connection: Upgrade\r\n") );
/*< Sec-WebSocket-Key: random_base4_value >*/
wiced_tcp_stream_write(&stream, "Sec-WebSocket-Key: ",( uint16_t )strlen("Sec-WebSocket-Key: ") );
wiced_tcp_stream_write(&stream, websocket_key_base64, ( uint16_t )strlen((char*)websocket_key_base64) );
wiced_tcp_stream_write(&stream, "\r\n", ( uint16_t )strlen("\r\n") );
/*< Origin: ip1.ip2.ip3.ip4 >*/
wiced_tcp_stream_write(&stream, "Origin: ", ( uint16_t )strlen("Origin: ") );
wiced_tcp_stream_write(&stream, websocket_header_fields->origin, ( uint16_t )strlen( websocket_header_fields->origin ) );
wiced_tcp_stream_write(&stream, "\r\n",( uint16_t )strlen("\r\n") );
/*The sec_websocket_protocol is optional, so check if it has been added, include in header if required*/
if ( websocket_header_fields->sec_websocket_protocol != NULL)
{
/*< Sec-WebSocket-Protocol: server_understood_protocol >*/
wiced_tcp_stream_write(&stream, "Sec-WebSocket-Protocol: ",( uint16_t )strlen("Sec-WebSocket-Protocol: ") );
wiced_tcp_stream_write(&stream, websocket_header_fields->sec_websocket_protocol, ( uint16_t )strlen( websocket_header_fields->sec_websocket_protocol ) );
wiced_tcp_stream_write(&stream, "\r\n",( uint16_t )strlen("\r\n") );
}
/*< Sec-WebSocket-Version: 13 >*/
wiced_tcp_stream_write(&stream, "Sec-WebSocket-Version: 13\r\n\r\n",strlen("Sec-WebSocket-Version: 13\r\n\r\n") );
/*send the handshake to server*/
wiced_tcp_stream_flush( &stream );
wiced_tcp_stream_deinit( &stream );
WICED_VERIFY( wiced_tcp_receive( &websocket->socket, &tcp_reply_packet, WICED_WAIT_FOREVER ) );
wiced_packet_get_data( tcp_reply_packet, 0, (uint8_t**)&received_handshake, &total_received_bytes, &tcp_data_available );
WICED_VERIFY( wiced_verify_server_handshake( (char*)received_handshake ) );
return WICED_SUCCESS;
}
static void ota_server_thread_main(uint32_t arg)
{
ota_server_t* server = (ota_server_t*) arg;
uint32_t total_body_size = 0;
int i = 0;
server->reboot_required = WICED_FALSE;
while ( server->quit != WICED_TRUE )
{
wiced_packet_t* temp_packet = NULL;
/* Wait for a connection */
wiced_result_t result = wiced_tcp_accept( &server->socket );
if ( result == WICED_SUCCESS )
{
for(;;)
{
if ( wiced_tcp_receive( &server->socket, &temp_packet, WICED_WAIT_FOREVER ) == WICED_SUCCESS )
{
char* request_string;
uint16_t request_length;
uint16_t available_data_length;
if( server->state == READING_HEADER )
{
uint8_t temp = 0;
wiced_result_t result = WICED_ERROR;
if ( temp_packet == NULL )
{
goto disconnect;
}
init_request(server);
server->request.request_packets[server->request.current_packet_index] = temp_packet;
wiced_packet_get_data(temp_packet, 0, (uint8_t**)&request_string, &request_length, &available_data_length);
/* Check that this is a GET or POST request, abort everything else */
if ( ( strstr( request_string, "GET" ) == 0 ) && ( strstr( request_string, "POST") == 0 ) )
{
result = WICED_ERROR;
wiced_packet_delete(temp_packet);
goto disconnect;
}
/* Get header pointer and header size */
server->request.header_ptr = (uint8_t*)request_string;
server->request.header_size = ( (char*)strstr( (char*)request_string, crlfcrlf ) + strlen( crlfcrlf ) ) - (char*)request_string;
if( server->request.header_size == strlen( crlfcrlf ) )
{
goto disconnect;
}
/* Get content length */
server->request.content_length = 0;
if( strstr( request_string, "Content-Length") != NULL )
{
uint8_t* content_length_value = (uint8_t*)strstr( request_string, "Content-Length") + strlen("Content-Length:");
server->request.content_length = atoi((const char*)content_length_value);
}
temp = request_string[ server->request.header_size ];
request_string[ server->request.header_size ] ='\0';
request_string[ server->request.header_size ] = temp;
/* Get request type and the url */
result = get_http_request_type_and_url( (uint8_t*)request_string, request_length, &server->request);
if ( result == WICED_ERROR )
{
goto disconnect;
}
server->state = READING_BODY;
}
if( server->state == READING_BODY )
{
http_body_chunk_t* current_body_chunk = &server->request.body_chunks[server->request.current_packet_index];
if( server->request.current_packet_index != 0 )
{
server->request.request_packets[server->request.current_packet_index] = temp_packet;
}
wiced_packet_get_data(temp_packet, 0, (uint8_t**)&request_string, &request_length, &available_data_length);
if( server->request.current_packet_index == 0 )
{
current_body_chunk->data = server->request.header_ptr + server->request.header_size;
current_body_chunk->size = ( request_string + request_length ) - (char*)current_body_chunk->data;
}
else
{
current_body_chunk->data = (uint8_t*)request_string;
current_body_chunk->size = request_length;
}
/* calculate total combined size of all body chunks which belongs to this message */
total_body_size = 0;
for( i = 0; i < ( server->request.current_packet_index + 1 ) ; i++ )
{
total_body_size+= server->request.body_chunks[i].size;
}
server->request.current_packet_index++;
/* Check whether the combined size of the previous chunks and the current one is equal to the content length received in the first packet */
if( total_body_size == server->request.content_length )
{
ota_server_process_request( server, &server->socket );
/* Delete all packets belonging to the message */
for( i = 0; i < server->request.current_packet_index; i++ )
{
wiced_packet_delete(server->request.request_packets[i]);
}
server->state = READING_HEADER;
break;
}
}
}
else
{
goto disconnect;
}
}
}
disconnect:
wiced_tcp_disconnect( &server->socket );
}
wiced_tcp_delete_socket( &server->socket );
if( server->reboot_required == WICED_TRUE )
{
/* Give some for the response to be sent properly */
wiced_rtos_delay_milliseconds(2000);
/* Perform a reboot!!! */
wiced_framework_reboot();
}
WICED_END_OF_CURRENT_THREAD( );
}
static wiced_result_t received_data_callback( wiced_tcp_socket_t* socket, void* arg )
{
uint16_t request_length;
uint16_t available_data_length;
wiced_packet_t* temp_packet = NULL;
if(wiced_tcp_receive( socket, &temp_packet, 500 ) == WICED_SUCCESS) // get the data from the client
{
char *rbuffer;
dbEntry_t receive;
char commandId;
int err=1;
char returnMessage[15];
// get the pointer to the packet sent by the client and the data
wiced_packet_get_data( temp_packet, 0, (uint8_t**) &rbuffer, &request_length, &available_data_length );
sscanf(rbuffer,"%c%4x%2x%4x",&commandId,(unsigned int *)&receive.deviceId,(unsigned int *)&receive.regId,(unsigned int *)&receive.value);
wiced_packet_delete( temp_packet ); // free the packet
if(request_length >= 11 && request_length <= 13 ) //11 if no end 12 if CR 13 if CRLF
{
dbEntry_t *newDbEntry;
switch(commandId)
{
case 'R': // they sent a Read command
newDbEntry = dbFind(&receive); // look through the database to find a previous write of the deviceId/regId
if(newDbEntry)
{
err=0;
sprintf(returnMessage,"A%04X%02X%04X",(unsigned int)newDbEntry->deviceId,(unsigned int)newDbEntry->regId,(unsigned int)newDbEntry->value);
}
else
err = 1;
break;
case 'W': // they sent a Write command
sprintf(returnMessage,"A%04X%02X%04X",(unsigned int)receive.deviceId,(unsigned int)receive.regId,(unsigned int)receive.value);
dbEntry_t *newDB;
newDB = malloc(sizeof(dbEntry_t)); // make a new entry to put in the database
memcpy(newDB,&receive,sizeof(dbEntry_t)); // copy the received data into the new entry
dbSetValue(newDB); // save it.
err = 0;
break;
default: // if they don't send a legal command then it is an error
err = 1;
break;
}
}
// Print IP address of the client (peer) that sent the data and print to terminal
uint32_t peerAddressV4;
peerAddressV4 = (*socket).socket.nx_tcp_socket_connect_ip.nxd_ip_address.v4;
WPRINT_APP_INFO(("%u.%u.%u.%u\t",
(uint8_t)(peerAddressV4 >> 24),
(uint8_t)(peerAddressV4 >> 16),
(uint8_t)(peerAddressV4 >> 8),
(uint8_t)(peerAddressV4 >> 0)));
// Print the port that the peer connected from
uint16_t peerPort;
peerPort = (*socket).socket.nx_tcp_socket_connect_port;
WPRINT_APP_INFO(("%d\t",peerPort));
// Print the data that was sent by the client (peer)
if(err)
{
strcpy(returnMessage,"X");
WPRINT_APP_INFO(("X length=%d\n",available_data_length));
}
else
{
uint32_t count;
linked_list_get_count(&db,&count);
WPRINT_APP_INFO(("%c\t%4X\t%2X\t%4X\t%d\n",commandId,(unsigned int)receive.deviceId,(unsigned int)receive.regId,(unsigned int)receive.value,(int)count));
}
// send response packet
wiced_packet_t* tx_packet;
uint8_t *tx_data;
wiced_packet_create_tcp(socket, strlen(returnMessage), &tx_packet, (uint8_t**)&tx_data, &available_data_length);
memcpy(tx_data, returnMessage, strlen(returnMessage));
wiced_packet_set_data_end(tx_packet, (uint8_t*)&tx_data[strlen(returnMessage)]);
wiced_tcp_send_packet(socket, tx_packet);
wiced_packet_delete(tx_packet);
wiced_tcp_server_disconnect_socket(&tcp_server,socket);
}
