/**
* Connects the given socket to the address.
* @param sd The socket handle to connect
* @param addr The address to connect to
* @param addrlen The length of the address details.
* @return 0 on success.
*/
sock_result_t socket_connect(sock_handle_t sd, const sockaddr_t *addr, long addrlen)
{
wiced_result_t result = WICED_INVALID_SOCKET;
socket_t* socket = from_handle(sd);
tcp_socket_t* tcp_socket = tcp(socket);
if (tcp_socket) {
std::lock_guard<socket_t> lk(*socket);
result = wiced_tcp_bind(tcp_socket, WICED_ANY_PORT);
if (result==WICED_SUCCESS) {
// WICED callbacks are broken
//wiced_tcp_register_callbacks(tcp(socket), socket_t::notify_connected, socket_t::notify_received, socket_t::notify_disconnected, (void*)socket);
SOCKADDR_TO_PORT_AND_IPADDR(addr, addr_data, port, ip_addr);
unsigned timeout = 5*1000;
result = wiced_tcp_connect(tcp_socket, &ip_addr, port, timeout);
if (result==WICED_SUCCESS) {
tcp_socket->connected();
} else {
// Work around WICED bug that doesn't set connection handler to NULL after deleting
// it, leading to deleting the same memory twice and a crash
// WICED/network/LwIP/WICED/tcpip.c:920
tcp_socket->conn_handler = NULL;
}
}
}
return as_sock_result(result);
}
static wiced_result_t wiced_websocket_tls_connect( wiced_websocket_t* websocket,wiced_ip_address_t* address )
{
wiced_result_t result = WICED_ERROR;
wiced_tls_init_simple_context( &websocket_tls_context, NULL );
WICED_VERIFY( wiced_tcp_create_socket( &websocket->socket, WICED_STA_INTERFACE ) );
wiced_tcp_register_callbacks( &websocket->socket, websocket->on_open, NULL, websocket->on_close );
wiced_tcp_enable_tls( &websocket->socket, &websocket_tls_context );
wiced_tcp_bind( &websocket->socket, 443 );
result = wiced_tcp_connect( &websocket->socket, address, 443, 10000 );
if ( result != WICED_SUCCESS )
{
websocket->error_type=WEBSOCKET_CLIENT_CONNECT_ERROR;
websocket->on_error( websocket );
wiced_tcp_delete_socket( &websocket->socket );
return ( result );
}
return ( result );
}
int platform_network_connect(Network* n, char* hostname, int port)
{
wiced_ip_address_t ip_address;
wiced_result_t rc = -1;
int attempt = 1;
do
{
platform_printf("trying to resolve hostname (attempt %d)\n", attempt);
if ((rc = wiced_hostname_lookup(hostname, &ip_address, 10000)) == WICED_SUCCESS)
{
platform_printf("hostname resolved\n");
break;
}
}
while (++attempt <= 5);
if (rc != WICED_SUCCESS)
{
platform_printf("failed to resolve ip address of %s, rc = %d\n", hostname, rc);
return rc;
}
if (n->tls_enabled)
wiced_tls_init_simple_context(&n->tls_context, hostname);
/* Create a TCP socket */
rc = wiced_tcp_create_socket(&n->socket, WICED_STA_INTERFACE);
if (rc != WICED_SUCCESS)
{
platform_printf("tcp socket creation failed, rc = %d\n", rc);
return rc;
}
if (n->tls_enabled)
wiced_tcp_enable_tls(&n->socket, &n->tls_context);
rc = wiced_tcp_connect(&n->socket, &ip_address, port, 5000);
if (rc != WICED_SUCCESS)
{
platform_printf("unable to establish connection to %s:%d, rc = %d\n", hostname, port, rc);
goto exit;
}
rc = wiced_tcp_stream_init(&n->stream, &n->socket);
if (rc != WICED_SUCCESS)
{
platform_printf("unable to init tcp stream, rc = %d\n", rc);
goto exit;
}
rc = WICED_SUCCESS;
exit:
if (rc != WICED_SUCCESS)
platform_network_disconnect(n);
return rc;
}
wiced_result_t xively_open_feed( xively_feed_t* feed )
{
wiced_result_t result;
if ( is_ip_address_resolved == WICED_FALSE )
{
WICED_VERIFY( wiced_hostname_lookup( HOST_NAME, &xively_server_ip_address, DNS_TIMEOUT ) );
is_ip_address_resolved = WICED_TRUE;
}
wiced_tls_init_simple_context( &feed->tls_context, NULL );
WICED_VERIFY( wiced_tcp_create_socket( &feed->socket, WICED_STA_INTERFACE ) );
result = wiced_tcp_bind( &feed->socket, WICED_ANY_PORT );
if ( result != WICED_SUCCESS )
{
wiced_tcp_delete_socket( &feed->socket );
return result;
}
result = wiced_tcp_enable_tls( &feed->socket, &feed->tls_context );
if ( result != WICED_SUCCESS )
{
wiced_tls_deinit_context( &feed->tls_context );
wiced_tcp_delete_socket( &feed->socket );
return result;
}
result = wiced_tcp_connect( &feed->socket, &xively_server_ip_address, HTTPS_PORT, SOCKET_CONNECT_TIMEOUT );
if ( result != WICED_SUCCESS )
{
wiced_tcp_delete_socket( &feed->socket );
return result;
}
return WICED_SUCCESS;
}
wiced_result_t open_websocket(websocket_handshake_t *hs, websocket_msg_handler_t binary_msg_handler, websocket_msg_handler_t text_msg_handler, void *ctx) {
wiced_result_t ret;
wiced_ip_address_t host_ip;
wiced_tls_context_t tls_ctx;
wiced_tcp_socket_t sock;
wiced_tcp_stream_t stream;
char *buf = NULL;
uint32_t i;
https_header_t *header;
WPRINT_LIB_INFO( ("Starting WebSocket handshake to https://%s%s\n", hs->hostname, hs->path) );
ret = wiced_hostname_lookup(hs->hostname, &host_ip, DNS_TIMEOUT);
if (ret != WICED_SUCCESS) {
WPRINT_LIB_INFO( ("DNS lookup failed for %s (err=%u)\n", hs->hostname, ret) );
return ret;
}
wiced_tls_init_context(&tls_ctx, NULL, NULL);
wiced_tcp_create_socket(&sock, WICED_STA_INTERFACE);
wiced_tcp_enable_tls(&sock, &tls_ctx);
{
char ip_str[48];
ip_to_str(&host_ip, ip_str);
WPRINT_LIB_INFO( ("Establishing TLS connection to %s port %d\n", ip_str, HTTPS_PORT) );
}
ret = wiced_tcp_connect(&sock, &host_ip, HTTPS_PORT, HTTPS_CONNECT_TIMEOUT);
if (ret != WICED_SUCCESS) {
WPRINT_LIB_INFO( ("Failed to create TCP connection (err=%u)\n", ret) );
wiced_tcp_delete_socket(&sock);
return ret;
}
do {
ret = wiced_tcp_stream_init(&stream, &sock);
if (ret != WICED_SUCCESS) {
WPRINT_LIB_INFO( ("Failed to initialize TCP stream (err=%u)\n", ret) );
break;
}
buf = (char *)malloc(STREAM_BUF_SIZE);
snprintf(buf, STREAM_BUF_SIZE, "GET %s HTTP/1.1\r\n", hs->path);
WRITE_STREAM(stream, buf, ret);
// Required headers.
snprintf(buf, STREAM_BUF_SIZE,
"Host: %s\r\n" \
"Connection: upgrade\r\n" \
"Upgrade: websocket\r\n" \
"Sec-WebSocket-Key: %s\r\n" \
"Sec-WebSocket-Version: 13\r\n",
hs->hostname, hs->key);
WRITE_STREAM(stream, buf, ret);
// Additional headers.
for (i = 0; i < hs->num_headers; i++) {
header = &(hs->headers[i]);
snprintf(buf, STREAM_BUF_SIZE, "%s: %s\r\n", header->name, header->value);
WRITE_STREAM(stream, buf, ret);
}
if (i < hs->num_headers) {
break;
}
strcpy(buf, "\r\n");
WRITE_STREAM(stream, buf, ret);
ret = wiced_tcp_stream_flush(&stream);
if (ret != WICED_SUCCESS) {
break;
}
ret = process_handshake_response(hs, &sock);
} while (WICED_FALSE);
if (buf) {
free(buf);
}
wiced_tcp_stream_deinit(&stream);
if (ret == WICED_SUCCESS) {
WPRINT_LIB_INFO( ("WebSocket handshake OK\n") );
process_frames(&sock, binary_msg_handler, text_msg_handler, ctx);
WPRINT_LIB_INFO( ("Closing WebSocket.\n") );
}
else {
WPRINT_LIB_INFO( ("WebSocket handshake failed (err=%u)\n", ret) );
}
wiced_tcp_disconnect(&sock);
wiced_tcp_delete_socket(&sock);
return ret;
}
