tls_result_t tls_host_create_buffer( ssl_context* ssl, uint8_t** buffer, uint16_t buffer_size )
{
wiced_assert("", ssl->outgoing_packet == NULL);
/* Round requested buffer size up to next 64 byte chunk (required if encryption is active) */
buffer_size = (uint16_t) ROUND_UP(buffer_size, 64);
/* Check if requested buffer fits within a single MTU */
if (buffer_size < 1300) /* TODO: Fix this */
{
uint16_t actual_packet_size;
if ( wiced_packet_create_tcp( ssl->send_context, buffer_size, (wiced_packet_t**) &ssl->outgoing_packet, buffer, &actual_packet_size ) != WICED_SUCCESS )
{
*buffer = NULL;
return 1;
}
}
else
{
/* Malloc space */
*buffer = tls_host_malloc("tls", buffer_size);
ssl->out_buffer_size = buffer_size;
}
return 0;
}
/*
* Flush any data not yet written
*/
tls_result_t ssl_flush_output( ssl_context *ssl, uint8_t* buffer, uint32_t length )
{
if ( ssl->transport_protocol == TLS_TCP_TRANSPORT )
{
if (ssl->outgoing_packet != NULL)
{
wiced_packet_set_data_end((wiced_packet_t*)ssl->outgoing_packet, buffer + length);
tls_host_send_tcp_packet(ssl->send_context, ssl->outgoing_packet);
ssl->outgoing_packet = NULL;
ssl->out_buffer_size = 0;
}
else
{
uint16_t actual_packet_size;
tls_packet_t* temp_packet;
uint8_t* packet_buffer;
uint8_t* data = buffer;
while (length != 0)
{
uint16_t amount_to_copy;
if ( wiced_packet_create_tcp( ssl->send_context, (uint16_t)length, (wiced_packet_t**) &temp_packet, &packet_buffer, &actual_packet_size ) != WICED_SUCCESS )
{
tls_host_free(buffer);
return 1;
}
if ( ssl->state == SSL_HANDSHAKE_OVER )
{
/* this doesn't need the extra space for the encryption header that a normal TLS socket would use - remove it */
packet_buffer -= sizeof(tls_record_header_t);
wiced_packet_set_data_start((wiced_packet_t*) temp_packet, packet_buffer);
}
amount_to_copy = (uint16_t) MIN(length, actual_packet_size);
packet_buffer = MEMCAT(packet_buffer, data, amount_to_copy);
data += amount_to_copy;
length -= amount_to_copy;
wiced_packet_set_data_end((wiced_packet_t*)temp_packet, packet_buffer );
tls_host_send_tcp_packet(ssl->send_context, temp_packet);
}
tls_host_free(buffer);
}
}
#ifndef DISABLE_EAP_TLS
else if ( ssl->transport_protocol == TLS_EAP_TRANSPORT )
{
supplicant_host_send_eap_tls_fragments( (supplicant_workspace_t*) ssl->send_context, buffer, length );
ssl->out_buffer_size = 0;
tls_host_free( buffer );
buffer = NULL;
}
#endif /* DISABLE_EAP_TLS */
return TLS_SUCCESS;
}
wiced_result_t wiced_tcp_stream_write( wiced_tcp_stream_t* tcp_stream, const void* data, uint32_t data_length )
{
wiced_assert("Bad args", tcp_stream != NULL);
WICED_LINK_CHECK_TCP_SOCKET( tcp_stream->socket );
while ( data_length != 0 )
{
uint16_t amount_to_write;
/* Check if we don't have a packet */
if ( tcp_stream->tx_packet == NULL )
{
wiced_result_t result;
result = wiced_packet_create_tcp( tcp_stream->socket, (uint16_t) MIN( data_length, 0xffff ), &tcp_stream->tx_packet, &tcp_stream->tx_packet_data , &tcp_stream->tx_packet_space_available );
if ( result != WICED_TCPIP_SUCCESS )
{
return result;
}
}
/* Write data */
amount_to_write = (uint16_t) MIN( data_length, tcp_stream->tx_packet_space_available );
tcp_stream->tx_packet_data = MEMCAT( tcp_stream->tx_packet_data, data, amount_to_write );
/* Update variables */
data_length = (uint16_t)(data_length - amount_to_write);
tcp_stream->tx_packet_space_available = (uint16_t) ( tcp_stream->tx_packet_space_available - amount_to_write );
data = (void*)((uint32_t)data + amount_to_write);
/* Check if the packet is full */
if ( tcp_stream->tx_packet_space_available == 0 )
{
wiced_result_t result;
/* Send the packet */
wiced_packet_set_data_end( tcp_stream->tx_packet, (uint8_t*)tcp_stream->tx_packet_data );
result = wiced_tcp_send_packet( tcp_stream->socket, tcp_stream->tx_packet );
tcp_stream->tx_packet_data = NULL;
tcp_stream->tx_packet_space_available = 0;
if ( result != WICED_TCPIP_SUCCESS )
{
wiced_packet_delete( tcp_stream->tx_packet );
tcp_stream->tx_packet = NULL;
return result;
}
tcp_stream->tx_packet = NULL;
}
}
return WICED_TCPIP_SUCCESS;
}
int
rwl_write_eth_port(void* hndle, char* write_buf, unsigned long size, unsigned long *numwritten)
{
uint16_t available_data_length;
wiced_packet_t* tx_packet;
char* tx_data;
unsigned long temp_size = 0;
unsigned long temp=0;
if ( size == 0 )
{
return SUCCESS;
}
while (size > 0)
{
if (wiced_packet_create_tcp(&tcp_client_socket, 128, &tx_packet, (uint8_t **)&tx_data, &available_data_length) != WICED_SUCCESS)
{
WPRINT_APP_INFO(("TCP packet creation failed\n"));
return WICED_ERROR;
}
if (size > available_data_length)
{
temp_size = available_data_length;
}
else
{
temp_size =size;
}
/* Write the message into tx_data"*/
memcpy(tx_data, (write_buf + temp), temp_size);
wiced_packet_set_data_end( tx_packet, (uint8_t*)tx_data + temp_size );
/* Send the TCP packet*/
if ( wiced_tcp_send_packet( &tcp_client_socket, tx_packet ) != WICED_SUCCESS )
{
WPRINT_APP_INFO(("TCP packet send failed \n"));
/*Delete packet, since the send failed*/
wiced_packet_delete(tx_packet);
return WICED_ERROR;
}
wiced_packet_delete(tx_packet);
size = size - temp_size;
temp = temp+temp_size;
}
return available_data_length;
}
static wiced_result_t tls_packetize_buffered_data( wiced_tls_context_t* context, wiced_packet_t** packet )
{
uint8_t* data;
uint16_t length;
uint16_t available_length;
uint16_t record_length;
wiced_result_t result;
uint32_t amount_to_copy;
(void)available_length;
record_length = (uint16_t)( htobe16(context->current_record->length) + sizeof(tls_record_header_t) );
/* Get a buffer and fill with decrypted content */
result = wiced_packet_create_tcp( context->send_context, (uint16_t) MIN(1024, record_length - context->defragmentation_buffer_bytes_processed), (wiced_packet_t**) packet, &data, &length );
if ( result != WICED_SUCCESS )
{
*packet = NULL;
return result;
}
if ( context->state == SSL_HANDSHAKE_OVER )
{
/* this doesn't need the extra space for the encryption header that a normal TLS socket would use - remove it */
data -= sizeof(tls_record_header_t);
wiced_packet_set_data_start((wiced_packet_t*) *packet, data);
}
amount_to_copy = (uint32_t) MIN( length, record_length - context->defragmentation_buffer_bytes_processed );
memcpy( data, &context->defragmentation_buffer[context->defragmentation_buffer_bytes_processed], amount_to_copy );
wiced_packet_set_data_end( *packet, data + amount_to_copy );
context->defragmentation_buffer_bytes_processed = (uint16_t) ( context->defragmentation_buffer_bytes_processed + amount_to_copy );
/* Check if we've returned all the data to the user */
if ( context->defragmentation_buffer_bytes_processed >= record_length )
{
tls_host_free_defragmentation_buffer(context->defragmentation_buffer);
context->defragmentation_buffer = 0;
context->current_record = NULL;
}
return WICED_SUCCESS;
}
static wiced_result_t tcp_server_process( tcp_server_handle_t* server, wiced_packet_t* rx_packet )
{
char* request;
uint16_t request_length;
uint16_t available_data_length;
wiced_packet_t* tx_packet;
char* tx_data;
wiced_packet_get_data( rx_packet, 0, (uint8_t**) &request, &request_length, &available_data_length );
/* Null terminate the received string */
request[request_length] = '\x0';
WPRINT_APP_INFO(("Received data: %s \n", request));
/* Send echo back */
if (wiced_packet_create_tcp(&server->socket, TCP_PACKET_MAX_DATA_LENGTH, &tx_packet, (uint8_t**)&tx_data, &available_data_length) != WICED_SUCCESS)
{
WPRINT_APP_INFO(("TCP packet creation failed\n"));
return WICED_ERROR;
}
/* Write the message into tx_data" */
tx_data[request_length] = '\x0';
memcpy(tx_data, request, request_length);
/* Set the end of the data portion */
wiced_packet_set_data_end(tx_packet, (uint8_t*)tx_data + request_length);
/* Send the TCP packet */
if (wiced_tcp_send_packet(&server->socket, tx_packet) != WICED_SUCCESS)
{
WPRINT_APP_INFO(("TCP packet send failed\n"));
/* Delete packet, since the send failed */
wiced_packet_delete(tx_packet);
server->quit=WICED_TRUE;
return WICED_ERROR;
}
WPRINT_APP_INFO(("Echo data: %s\n", tx_data));
return WICED_SUCCESS;
}
wiced_result_t wiced_tcp_send_buffer( wiced_tcp_socket_t* socket, const void* buffer, uint16_t buffer_length )
{
wiced_packet_t* packet = NULL;
uint8_t* data_ptr = (uint8_t*)buffer;
uint8_t* packet_data_ptr;
uint16_t available_space;
wiced_assert("Bad args", socket != NULL);
WICED_LINK_CHECK_TCP_SOCKET( socket );
/* Create a packet, copy the data and send it off */
while ( buffer_length != 0 )
{
uint16_t data_to_write;
wiced_result_t result = wiced_packet_create_tcp( socket, buffer_length, &packet, &packet_data_ptr, &available_space );
if ( result != WICED_TCPIP_SUCCESS )
{
return result;
}
/* Write data */
data_to_write = MIN(buffer_length, available_space);
packet_data_ptr = MEMCAT(packet_data_ptr, data_ptr, data_to_write);
wiced_packet_set_data_end( packet, packet_data_ptr );
/* Update variables */
data_ptr += data_to_write;
buffer_length = (uint16_t) ( buffer_length - data_to_write );
available_space = (uint16_t) ( available_space - data_to_write );
result = wiced_tcp_send_packet( socket, packet );
if ( result != WICED_TCPIP_SUCCESS )
{
wiced_packet_delete( packet );
return result;
}
}
return WICED_TCPIP_SUCCESS;
}
tls_result_t tls_host_create_buffer( ssl_context* ssl, uint8_t** buffer, uint16_t buffer_size )
{
wiced_assert("", ssl->outgoing_packet == NULL);
/* Round requested buffer size up to next 64 byte chunk (required if encryption is active) */
buffer_size = (uint16_t) ROUND_UP(buffer_size, 64);
/* Check if requested buffer fits within a single MTU */
if ( ( buffer_size < 1300) && ( ssl->transport_protocol == TLS_TCP_TRANSPORT ) ) /* TODO: Fix this */
{
uint16_t actual_packet_size;
if ( wiced_packet_create_tcp( ssl->send_context, buffer_size, (wiced_packet_t**) &ssl->outgoing_packet, buffer, &actual_packet_size ) != WICED_SUCCESS )
{
*buffer = NULL;
return 1;
}
if ( ssl->state == SSL_HANDSHAKE_OVER )
{
/* this doesn't need the extra space for the encryption header that a normal TLS socket would use - remove it */
*buffer -= sizeof(tls_record_header_t);
wiced_packet_set_data_start((wiced_packet_t*) ssl->outgoing_packet, *buffer);
}
}
else
{
/* Requested size bigger than a MTU or TLS_EAP_TRANSPORT */
/* Malloc space */
*buffer = tls_host_malloc("tls", buffer_size);
if ( *buffer == NULL )
{
return TLS_ERROR_OUT_OF_MEMORY;
}
memset( *buffer, 0, buffer_size );
ssl->out_buffer_size = buffer_size;
}
return 0;
}
/*
* Flush any data not yet written
*/
tls_result_t ssl_flush_output( ssl_context *ssl, uint8_t* buffer, uint32_t length )
{
if (ssl->outgoing_packet != NULL)
{
wiced_packet_set_data_end((wiced_packet_t*)ssl->outgoing_packet, buffer + length);
tls_host_send_packet(ssl->send_context, ssl->outgoing_packet);
ssl->outgoing_packet = NULL;
ssl->out_buffer_size = 0;
}
else
{
uint16_t actual_packet_size;
tls_packet_t* temp_packet;
uint8_t* packet_buffer;
uint8_t* data = buffer;
while (length != 0)
{
uint16_t amount_to_copy;
if ( wiced_packet_create_tcp( ssl->send_context, (uint16_t)length, (wiced_packet_t**) &temp_packet, &packet_buffer, &actual_packet_size ) != WICED_SUCCESS )
{
free(buffer);
return 1;
}
amount_to_copy = (uint16_t) MIN(length, actual_packet_size);
packet_buffer = MEMCAT(packet_buffer, data, amount_to_copy);
data += amount_to_copy;
length -= amount_to_copy;
wiced_packet_set_data_end((wiced_packet_t*)temp_packet, packet_buffer );
tls_host_send_packet(ssl->send_context, temp_packet);
}
free(buffer);
}
return( 0 );
}
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);
}
