tsk_size_t tnet_transport_send(const tnet_transport_handle_t *handle, tnet_fd_t from, const void* buf, tsk_size_t size)
{
tnet_transport_t *transport = (tnet_transport_t*)handle;
int numberOfBytesSent = 0;
if (!transport) {
TSK_DEBUG_ERROR("Invalid transport handle.");
goto bail;
}
const transport_socket_t* sock = getSocket(transport->context, from);
if (TNET_SOCKET_TYPE_IS_STREAM(sock->type)) {
if (!sock->cf_write_stream) {
TNET_PRINT_LAST_ERROR("No stream found.");
goto bail;
}
if (CFWriteStreamGetStatus(sock->cf_write_stream) == kCFStreamStatusNotOpen) {
CFWriteStreamOpen(sock->cf_write_stream);
}
if ((numberOfBytesSent = CFWriteStreamWrite(sock->cf_write_stream, buf, (CFIndex) size)) <= 0) {
TNET_PRINT_LAST_ERROR("Send have failed.");
goto bail;
}
} else {
if ((numberOfBytesSent = send(from, buf, size, 0)) <= 0) {
TNET_PRINT_LAST_ERROR("Send have failed.");
goto bail;
}
}
bail:
return numberOfBytesSent;
}
int tnet_transport_prepare(tnet_transport_t *transport)
{
int ret = -1;
transport_context_t *context;
if (!transport || !transport->context) {
TSK_DEBUG_ERROR("Invalid parameter.");
return -1;
}
else {
context = transport->context;
}
if (transport->prepared) {
TSK_DEBUG_ERROR("Transport already prepared.");
return -2;
}
/* Prepare master */
if (!transport->master) {
if ((transport->master = tnet_socket_create(transport->local_host, transport->req_local_port, transport->type))) {
tsk_strupdate(&transport->local_ip, transport->master->ip);
transport->bind_local_port = transport->master->port;
}
else {
TSK_DEBUG_ERROR("Failed to create master socket");
return -3;
}
}
/* Start listening */
if (TNET_SOCKET_TYPE_IS_STREAM(transport->master->type)) {
if ((ret = tnet_sockfd_listen(transport->master->fd, WSA_MAXIMUM_WAIT_EVENTS))) {
TNET_PRINT_LAST_ERROR("listen have failed.");
goto bail;
}
}
/* Add the master socket to the context. */
// don't take ownership: will be closed by the dctor() when refCount==0
// otherwise will be closed twice: dctor() and removeSocket()
if ((ret = addSocket(transport->master->fd, transport->master->type, transport, tsk_false, tsk_false, tsk_null))) {
TSK_DEBUG_ERROR("Failed to add master socket");
goto bail;
}
/* set events on master socket */
if ((ret = WSAEventSelect(transport->master->fd, context->events[context->count - 1], FD_ALL_EVENTS) == SOCKET_ERROR)) {
TNET_PRINT_LAST_ERROR("WSAEventSelect have failed.");
goto bail;
}
transport->prepared = tsk_true;
bail:
return ret;
}
/**@ingroup tnet_socket_group
* Returns the number of bytes sent (or negative value on error)
*/
int tnet_socket_send_stream(tnet_socket_t* self, const void* data, tsk_size_t size)
{
if (!self || self->fd == TNET_INVALID_FD || !data || !size || !TNET_SOCKET_TYPE_IS_STREAM(self->type)) {
TSK_DEBUG_ERROR("Invalid parameter");
return -1;
}
if (self->tlshandle && (TNET_SOCKET_TYPE_IS_TLS(self->type) || TNET_SOCKET_TYPE_IS_WSS(self->type))) {
return tnet_tls_socket_send(self->tlshandle, data, size) == 0 ? (int)size : -1; // returns zero on success
}
return (int)tnet_sockfd_send(self->fd, data, size, 0);
}
/*== Add new socket ==*/
int addSocket(tnet_fd_t fd, tnet_socket_type_t type, tnet_transport_t *transport, tsk_bool_t take_ownership, tsk_bool_t is_client, tnet_tls_socket_handle_t* tlsHandle)
{
transport_context_t *context = transport?transport->context:0;
if(context) {
transport_socket_xt *sock = tsk_calloc(1, sizeof(transport_socket_xt));
sock->fd = fd;
sock->type = type;
sock->owner = take_ownership;
if((TNET_SOCKET_TYPE_IS_TLS(sock->type) || TNET_SOCKET_TYPE_IS_WSS(sock->type)) && transport->tls.enabled) {
if(tlsHandle) {
sock->tlshandle = tsk_object_ref(tlsHandle);
}
else {
#if HAVE_OPENSSL
sock->tlshandle = tnet_tls_socket_create(sock->fd, is_client ? transport->tls.ctx_client : transport->tls.ctx_server);
#endif
}
}
tsk_safeobj_lock(context);
context->ufds[context->count].fd = fd;
context->ufds[context->count].events = (fd == context->pipeR) ? TNET_POLLIN : (TNET_POLLIN | TNET_POLLNVAL | TNET_POLLERR);
if(TNET_SOCKET_TYPE_IS_STREAM(sock->type) && fd != context->pipeR) {
context->ufds[context->count].events |= TNET_POLLOUT; // emulate WinSock2 FD_CONNECT event
}
context->ufds[context->count].revents = 0;
context->sockets[context->count] = sock;
context->count++;
tsk_safeobj_unlock(context);
TSK_DEBUG_INFO("Socket added[%s]: fd=%d, tail.count=%d", transport->description, fd, (int)context->count);
return 0;
}
else {
TSK_DEBUG_ERROR("Context is Null.");
return -1;
}
}
int tnet_transport_prepare(tnet_transport_t *transport)
{
int ret = -1;
transport_context_t *context;
if(!transport || !transport->context){
TSK_DEBUG_ERROR("Invalid parameter.");
return -1;
}
else{
context = transport->context;
}
if(transport->prepared){
TSK_DEBUG_ERROR("Transport already prepared.");
return -2;
}
/* Start listening */
if(TNET_SOCKET_TYPE_IS_STREAM(transport->master->type)){
if((ret = tnet_sockfd_listen(transport->master->fd, WSA_MAXIMUM_WAIT_EVENTS))){
TNET_PRINT_LAST_ERROR("listen have failed.");
goto bail;
}
}
/* Add the master socket to the context. */
if((ret = addSocket(transport->master->fd, transport->master->type, transport, tsk_true, tsk_false))){
TSK_DEBUG_ERROR("Failed to add master socket");
goto bail;
}
/* set events on master socket */
if((ret = WSAEventSelect(transport->master->fd, context->events[context->count - 1], TNET_SOCKET_TYPE_IS_DGRAM(transport->master->type) ? FD_READ : FD_ALL_EVENTS/*FD_ACCEPT | FD_READ | FD_CONNECT | FD_CLOSE*/) == SOCKET_ERROR)){
TNET_PRINT_LAST_ERROR("WSAEventSelect have failed.");
goto bail;
}
transport->prepared = tsk_true;
bail:
return ret;
}
int tnet_transport_prepare(tnet_transport_t *transport)
{
int ret = -1;
transport_context_t *context;
if (!transport || !transport->context) {
TSK_DEBUG_ERROR("Invalid parameter.");
return -1;
}
else{
context = transport->context;
}
if (transport->prepared) {
TSK_DEBUG_ERROR("Transport already prepared.");
return -2;
}
/* Start listening */
if (TNET_SOCKET_TYPE_IS_STREAM(transport->master->type)) {
if ((ret = tnet_sockfd_listen(transport->master->fd, TNET_MAX_FDS))) {
TNET_PRINT_LAST_ERROR("listen have failed.");
goto bail;
}
}
/* Add the master socket to the context. */
if ((ret = addSocket(transport->master->fd, transport->master->type, transport, tsk_true, tsk_false))) {
TSK_DEBUG_ERROR("Failed to add master socket");
goto bail;
}
transport->prepared = tsk_true;
bail:
return ret;
}
//=================================================================================================
// SOCKET object definition
//
static tsk_object_t* tnet_socket_ctor(tsk_object_t * self, va_list * app)
{
tnet_socket_t *sock = self;
if(sock){
int status;
tsk_bool_t nonblocking;
tsk_bool_t bindsocket;
tsk_istr_t port;
struct addrinfo *result = 0;
struct addrinfo *ptr = 0;
struct addrinfo hints;
tnet_host_t local_hostname;
const char *host = va_arg(*app, const char*);
#if defined(__GNUC__)
sock->port = (tnet_port_t)va_arg(*app, unsigned);
#else
sock->port = va_arg(*app, tnet_port_t);
#endif
tsk_itoa(sock->port, &port);
sock->type = va_arg(*app, tnet_socket_type_t);
nonblocking = va_arg(*app, tsk_bool_t);
bindsocket = va_arg(*app, tsk_bool_t);
memset(local_hostname, 0, sizeof(local_hostname));
/* Get the local host name */
if(host != TNET_SOCKET_HOST_ANY && !tsk_strempty(host)){
memcpy(local_hostname, host, tsk_strlen(host)>sizeof(local_hostname)-1 ? sizeof(local_hostname)-1 : tsk_strlen(host));
}
else{
if(TNET_SOCKET_TYPE_IS_IPV6(sock->type)){
memcpy(local_hostname, "::", 2);
}
else{
memcpy(local_hostname, "0.0.0.0", 7);
}
//if((status = tnet_gethostname(&local_hostname)))
//{
// TNET_PRINT_LAST_ERROR("gethostname have failed.");
// goto bail;
//}
}
/* hints address info structure */
memset(&hints, 0, sizeof(hints));
hints.ai_family = TNET_SOCKET_TYPE_IS_IPV46(sock->type) ? AF_UNSPEC : (TNET_SOCKET_TYPE_IS_IPV6(sock->type) ? AF_INET6 : AF_INET);
hints.ai_socktype = TNET_SOCKET_TYPE_IS_STREAM(sock->type) ? SOCK_STREAM : SOCK_DGRAM;
hints.ai_protocol = TNET_SOCKET_TYPE_IS_STREAM(sock->type) ? IPPROTO_TCP : IPPROTO_UDP;
hints.ai_flags = AI_PASSIVE
#if !TNET_UNDER_WINDOWS || _WIN32_WINNT>=0x600
| AI_ADDRCONFIG
#endif
;
/* Performs getaddrinfo */
if((status = tnet_getaddrinfo(local_hostname, port, &hints, &result))){
TNET_PRINT_LAST_ERROR("tnet_getaddrinfo(family=%d, hostname=%s and port=%s) failed: [%s]",
hints.ai_family, local_hostname, port, tnet_gai_strerror(status));
goto bail;
}
/* Find our address. */
for(ptr = result; ptr; ptr = ptr->ai_next){
sock->fd = tnet_soccket(ptr->ai_family, ptr->ai_socktype, ptr->ai_protocol);
if(ptr->ai_family != AF_INET6 && ptr->ai_family != AF_INET){
continue;
}
if(bindsocket){
/* Bind the socket */
if((status = bind(sock->fd, ptr->ai_addr, ptr->ai_addrlen))){
TNET_PRINT_LAST_ERROR("bind have failed.");
tnet_socket_close(sock);
continue;
}
/* Get local IP string. */
if(status = tnet_get_ip_n_port(sock->fd , &sock->ip, &sock->port)) /* % */
//if((status = tnet_getnameinfo(ptr->ai_addr, ptr->ai_addrlen, sock->ip, sizeof(sock->ip), 0, 0, NI_NUMERICHOST)))
{
TNET_PRINT_LAST_ERROR("Failed to get local IP and port.");
tnet_socket_close(sock);
continue;
}
// else{
//#if TNET_UNDER_WINDOWS
// int index;
// if((index = tsk_strindexOf(sock->ip, tsk_strlen(sock->ip), "%")) > 0){
// *(sock->ip + index) = '\0';
// }
//#endif
// }
}
/* sets the real socket type (if ipv46) */
if(ptr->ai_family == AF_INET6) {
TNET_SOCKET_TYPE_SET_IPV6Only(sock->type);
}
else{
TNET_SOCKET_TYPE_SET_IPV4Only(sock->type);
}
break;
}
/* Check socket validity. */
if(!TNET_SOCKET_IS_VALID(sock)) {
TNET_PRINT_LAST_ERROR("Invalid socket.");
goto bail;
}
/* To avoid "Address already in use" error */
{
#if defined(SOLARIS)
char yes = '1';
#else
int yes = 1;
#endif
if(setsockopt(sock->fd, SOL_SOCKET, SO_REUSEADDR, (char*)&yes, sizeof(int))){
TNET_PRINT_LAST_ERROR("setsockopt(SO_REUSEADDR) have failed.");
}
}
/* Sets the socket to nonblocking mode */
if(nonblocking){
if((status = tnet_sockfd_set_nonblocking(sock->fd))){
goto bail;
}
}
bail:
/* Free addrinfo */
tnet_freeaddrinfo(result);
/* Close socket if failed. */
if(status && TNET_SOCKET_IS_VALID(sock)){
tnet_socket_close(sock);
}
}
return self;
}
/**
* Connects a socket.
* @param handle The transport to use to connect() the socket. The new socket will be managed by this transport.
* @param host The remote @a host to connect() to.
* @param port The remote @a port to connect() to.
* @param type The type of the socket to use to connect() to the remote @a host.
* @retval The newly connected socket. For non-blocking sockets you should use @ref tnet_sockfd_waitUntilWritable to check
* the socket for writability.
* @sa tnet_sockfd_waitUntilWritable.
*/
tnet_fd_t tnet_transport_connectto(const tnet_transport_handle_t *handle, const char* host, tnet_port_t port, tnet_socket_type_t type)
{
tnet_transport_t *transport = (tnet_transport_t*)handle;
struct sockaddr_storage to;
int status = -1;
tnet_fd_t fd = TNET_INVALID_FD;
tnet_tls_socket_handle_t* tls_handle = tsk_null;
if(!transport || !transport->master){
TSK_DEBUG_ERROR("Invalid transport handle");
goto bail;
}
if((TNET_SOCKET_TYPE_IS_STREAM(transport->master->type) && !TNET_SOCKET_TYPE_IS_STREAM(type)) ||
(TNET_SOCKET_TYPE_IS_DGRAM(transport->master->type) && !TNET_SOCKET_TYPE_IS_DGRAM(type))){
TSK_DEBUG_ERROR("Master/destination types mismatch [%u/%u]", transport->master->type, type);
goto bail;
}
/* Init destination sockaddr fields */
if((status = tnet_sockaddr_init(host, port, type, &to))){
TSK_DEBUG_ERROR("Invalid HOST/PORT [%s/%u]", host, port);
goto bail;
}
else if(TNET_SOCKET_TYPE_IS_IPV46(type)){
/* Update the type (unambiguously) */
if(to.ss_family == AF_INET6){
TNET_SOCKET_TYPE_SET_IPV6Only(type);
}
else{
TNET_SOCKET_TYPE_SET_IPV4Only(type);
}
}
/*
* STREAM ==> create new socket and connect it to the remote host.
* DGRAM ==> connect the master to the remote host.
*/
if(TNET_SOCKET_TYPE_IS_STREAM(type)){
/* Create client socket descriptor. */
if((status = tnet_sockfd_init(transport->local_host, TNET_SOCKET_PORT_ANY, type, &fd))){
TSK_DEBUG_ERROR("Failed to create new sockfd.");
goto bail;
}
}
else{
fd = transport->master->fd;
}
if((status = tnet_sockfd_connectto(fd, (const struct sockaddr_storage *)&to))){
if(fd != transport->master->fd){
tnet_sockfd_close(&fd);
}
goto bail;
}
else{
static const tsk_bool_t __isClient = tsk_true;
static const tsk_bool_t __takeOwnership = tsk_true;
if(TNET_SOCKET_TYPE_IS_TLS(type) || TNET_SOCKET_TYPE_IS_WSS(type)){
#if HAVE_OPENSSL
tls_handle = tnet_tls_socket_create(fd, transport->tls.ctx_client);
if((status = tnet_tls_socket_connect(tls_handle))){
tnet_sockfd_close(&fd);
goto bail;
}
#endif
}
/* Add the socket */
// socket must be added after connect() otherwise many Linux systems when return POLLHUP as the fd is not active yet
if((status = tnet_transport_add_socket(handle, fd, type, __takeOwnership, __isClient, tls_handle))){
TNET_PRINT_LAST_ERROR("Failed to add new socket");
tnet_sockfd_close(&fd);
goto bail;
}
}
bail:
TSK_OBJECT_SAFE_FREE(tls_handle);
return fd;
}
tnet_fd_t tnet_transport_connectto_3(const tnet_transport_handle_t *handle, struct tnet_socket_s* socket, const char* host, tnet_port_t port, tnet_socket_type_t type)
{
tnet_transport_t *transport = (tnet_transport_t*)handle;
struct sockaddr_storage to;
int status = -1;
tnet_fd_t fd = socket ? socket->fd : TNET_INVALID_FD;
tnet_tls_socket_handle_t* tls_handle = tsk_null;
tsk_bool_t owe_socket = socket ? tsk_false : tsk_true;
tsk_bool_t use_proxy = TNET_SOCKET_TYPE_IS_STREAM(type);
const char* to_host = host;
tnet_port_t to_port = port;
tnet_socket_type_t to_type = type;
tnet_proxyinfo_t* proxy_info = tsk_null;
if (!transport || !transport->master) {
TSK_DEBUG_ERROR("Invalid transport handle");
goto bail;
}
if ((TNET_SOCKET_TYPE_IS_STREAM(transport->master->type) && !TNET_SOCKET_TYPE_IS_STREAM(type)) ||
(TNET_SOCKET_TYPE_IS_DGRAM(transport->master->type) && !TNET_SOCKET_TYPE_IS_DGRAM(type))) {
TSK_DEBUG_ERROR("Master/destination types mismatch [%u/%u]", transport->master->type, type);
goto bail;
}
if (use_proxy) {
// auto-detect the proxy
if (transport->proxy.auto_detect) {
char* url = tsk_null;
// The proxy detection implementations are designed for a browser and expect a "http://" or "https://" schemes (will work with socks).
tsk_sprintf(&url, "%s://%s:%d", TNET_SOCKET_TYPE_IS_TLS(to_type) ? "https" : "http", to_host, to_port);
proxy_info = tnet_proxydetect_get_info_fast(url, to_type);
TSK_FREE(url);
}
// fall-back to the hard proxy if auto-detection failed
if (!tnet_proxyinfo_is_valid(proxy_info) && tnet_proxyinfo_is_valid(transport->proxy.info)) {
proxy_info = tsk_object_ref(transport->proxy.info);
}
}
use_proxy &= tnet_proxyinfo_is_valid(proxy_info);
if (use_proxy) {
if (tnet_proxy_node_is_nettransport_supported(proxy_info->type, type)) {
to_host = proxy_info->hostname;
to_port = proxy_info->port;
// SOCKS still doesn't define RFC for SSL security (https://tools.ietf.org/html/draft-ietf-aft-socks-ssl-00) but Kerberos6 authentication is supported
if (proxy_info->type == tnet_proxy_type_http || proxy_info->type == tnet_proxy_type_socks4 || proxy_info->type == tnet_proxy_type_socks4a || proxy_info->type == tnet_proxy_type_socks5) {
// Send CONNET to the proxy using unsecure connection then begin SSL handshaking if needed
TNET_SOCKET_TYPE_UNSET(to_type, TLS); // Make the type unsecure (will keep other flags-e.g. IP version-)
TNET_SOCKET_TYPE_SET(to_type, TCP); // Use plain TCP
}
}
else {
// Not an error.
TSK_DEBUG_INFO("No proxy plugin to handle network transport type = %d", type);
use_proxy = tsk_false;
}
}
TSK_DEBUG_INFO("tnet_transport_connectto_3(host=%s, port=%d, type=%d, fd=%d, use_proxy=%d, to_host=%s, to_port=%d, to_type=%d, proxy_type=%d)" , host, port, type, fd, use_proxy, to_host, to_port, to_type, proxy_info ? proxy_info->type : 0);
/* Init destination sockaddr fields */
if ((status = tnet_sockaddr_init(to_host, to_port, to_type, &to))) {
TSK_DEBUG_ERROR("Invalid HOST/PORT [%s/%u]", host, port);
goto bail;
}
if (TNET_SOCKET_TYPE_IS_IPV46(type)) {
/* Update the type (unambiguously) */
if (to.ss_family == AF_INET6) {
TNET_SOCKET_TYPE_SET_IPV6Only(type);
}
else {
TNET_SOCKET_TYPE_SET_IPV4Only(type);
}
}
/*
* STREAM ==> create new socket and connect it to the remote host.
* DGRAM ==> connect the master to the remote host.
*/
if (fd == TNET_INVALID_FD) {
// Create client socket descriptor.
if ((status = tnet_sockfd_init(transport->local_host, TNET_SOCKET_PORT_ANY, to_type, &fd))) {
TSK_DEBUG_ERROR("Failed to create new sockfd.");
goto bail;
}
}
if ((status = tnet_sockfd_connectto(fd, (const struct sockaddr_storage *)&to))) {
if (fd != transport->master->fd) {
tnet_sockfd_close(&fd);
}
goto bail;
}
else {
static const tsk_bool_t __isClient = tsk_true;
if (TNET_SOCKET_TYPE_IS_TLS(to_type) || TNET_SOCKET_TYPE_IS_WSS(to_type)) {
#if HAVE_OPENSSL
tls_handle = tnet_tls_socket_create(fd, transport->tls.ctx_client);
if (socket) {
TSK_OBJECT_SAFE_FREE(socket->tlshandle);
socket->tlshandle = tsk_object_ref(tls_handle);
}
if ((status = tnet_tls_socket_connect(tls_handle))) {
tnet_sockfd_close(&fd);
goto bail;
}
#endif
}
/* Add the socket */
// socket must be added after connect() otherwise many Linux systems will return POLLHUP as the fd is not active yet
if ((status = tnet_transport_add_socket_2(handle, fd, to_type, owe_socket, __isClient, tls_handle, host, port, proxy_info))) {
TNET_PRINT_LAST_ERROR("Failed to add new socket");
tnet_sockfd_close(&fd);
goto bail;
}
}
bail:
TSK_OBJECT_SAFE_FREE(tls_handle);
TSK_OBJECT_SAFE_FREE(proxy_info);
return status == 0 ? fd : TNET_INVALID_FD;
}
/**@ingroup tnet_socket_group
* Creates a new socket.
* To check that the returned socket is valid use @ref TNET_SOCKET_IS_VALID function.
* @param host FQDN (e.g. www.doubango.org) or IPv4/IPv6 IP string.
* @param port The local/remote port used to receive/send data. Set the port value to @ref TNET_SOCKET_PORT_ANY to bind to a random port.
* @param type The type of the socket. See @ref tnet_socket_type_t.
* @param nonblocking Indicates whether to create non-blocking socket.
* @param bindsocket Indicates whether to bind the newly created socket or not.
* @retval @ref tnet_socket_t object.
* @sa @ref tnet_socket_create.
*/
tnet_socket_t* tnet_socket_create_2(const char* host, tnet_port_t port_, tnet_socket_type_t type, tsk_bool_t nonblocking, tsk_bool_t bindsocket)
{
tnet_socket_t *sock;
if ((sock = tsk_object_new(tnet_socket_def_t))) {
int status;
tsk_istr_t port;
struct addrinfo *result = tsk_null;
struct addrinfo *ptr = tsk_null;
struct addrinfo hints;
tnet_host_t local_hostname;
sock->port = port_;
tsk_itoa(sock->port, &port);
sock->type = type;
memset(local_hostname, 0, sizeof(local_hostname));
/* Get the local host name */
if (host != TNET_SOCKET_HOST_ANY && !tsk_strempty(host)){
memcpy(local_hostname, host, tsk_strlen(host) > sizeof(local_hostname) - 1 ? sizeof(local_hostname) - 1 : tsk_strlen(host));
}
else{
if (TNET_SOCKET_TYPE_IS_IPV6(sock->type)){
memcpy(local_hostname, "::", 2);
}
else {
memcpy(local_hostname, "0.0.0.0", 7);
}
}
/* hints address info structure */
memset(&hints, 0, sizeof(hints));
hints.ai_family = TNET_SOCKET_TYPE_IS_IPV46(sock->type) ? AF_UNSPEC : (TNET_SOCKET_TYPE_IS_IPV6(sock->type) ? AF_INET6 : AF_INET);
hints.ai_socktype = TNET_SOCKET_TYPE_IS_STREAM(sock->type) ? SOCK_STREAM : SOCK_DGRAM;
hints.ai_protocol = TNET_SOCKET_TYPE_IS_STREAM(sock->type) ? IPPROTO_TCP : IPPROTO_UDP;
hints.ai_flags = AI_PASSIVE
#if !TNET_UNDER_WINDOWS || _WIN32_WINNT>=0x600
| AI_ADDRCONFIG
#endif
;
/* Performs getaddrinfo */
if ((status = tnet_getaddrinfo(local_hostname, port, &hints, &result))) {
TNET_PRINT_LAST_ERROR("tnet_getaddrinfo(family=%d, hostname=%s and port=%s) failed: [%s]",
hints.ai_family, local_hostname, port, tnet_gai_strerror(status));
goto bail;
}
/* Find our address. */
for (ptr = result; ptr; ptr = ptr->ai_next){
sock->fd = (tnet_fd_t)tnet_soccket(ptr->ai_family, ptr->ai_socktype, ptr->ai_protocol);
if (ptr->ai_family != AF_INET6 && ptr->ai_family != AF_INET){
continue;
}
/* To avoid "Address already in use" error
* Check issue 368 (https://code.google.com/p/doubango/issues/detail?id=368) to understand why it's not used for UDP/DTLS.
*/
//
if (TNET_SOCKET_TYPE_IS_STREAM(sock->type)) {
if ((status = tnet_sockfd_reuseaddr(sock->fd, 1))) {
// do not break...continue
}
}
if (bindsocket){
/* Bind the socket */
if ((status = bind(sock->fd, ptr->ai_addr, (int)ptr->ai_addrlen))){
TNET_PRINT_LAST_ERROR("bind to [%s:%s]have failed", local_hostname, port);
tnet_socket_close(sock);
continue;
}
/* Get local IP string. */
if ((status = tnet_get_ip_n_port(sock->fd, tsk_true/*local*/, &sock->ip, &sock->port))) /* % */
//if((status = tnet_getnameinfo(ptr->ai_addr, ptr->ai_addrlen, sock->ip, sizeof(sock->ip), 0, 0, NI_NUMERICHOST)))
{
TNET_PRINT_LAST_ERROR("Failed to get local IP and port.");
tnet_socket_close(sock);
continue;
}
}
/* sets the real socket type (if ipv46) */
if (ptr->ai_family == AF_INET6) {
TNET_SOCKET_TYPE_SET_IPV6Only(sock->type);
}
else {
TNET_SOCKET_TYPE_SET_IPV4Only(sock->type);
}
break;
}
/* Check socket validity. */
if (!TNET_SOCKET_IS_VALID(sock)) {
TNET_PRINT_LAST_ERROR("Invalid socket.");
goto bail;
}
#if TNET_UNDER_IPHONE || TNET_UNDER_IPHONE_SIMULATOR
/* disable SIGPIPE signal */
{
int yes = 1;
if (setsockopt(sock->fd, SOL_SOCKET, SO_NOSIGPIPE, (char*)&yes, sizeof(int))){
TNET_PRINT_LAST_ERROR("setsockopt(SO_NOSIGPIPE) have failed.");
}
}
#endif /* TNET_UNDER_IPHONE */
/* Sets the socket to nonblocking mode */
if(nonblocking){
if((status = tnet_sockfd_set_nonblocking(sock->fd))){
goto bail;
}
}
bail:
/* Free addrinfo */
tnet_freeaddrinfo(result);
/* Close socket if failed. */
if (status){
if (TNET_SOCKET_IS_VALID(sock)){
tnet_socket_close(sock);
}
return tsk_null;
}
}
return sock;
}
int tnet_transport_wrap(tnet_transport_t *transport, int index) {
transport_context_t *context = transport->context;
transport_socket_t *sock = context->sockets[index];
// If the socket is already wrapped in a CFSocket then return.
if (sock->cf_socket || sock->cf_read_stream) {
return 1;
}
// Put a reference to the transport context
const CFSocketContext socket_context = { 0, transport, NULL, NULL, NULL };
if (TNET_SOCKET_TYPE_IS_DGRAM(sock->type)) {
// Create a CFSocket from the native socket and register for Read events
sock->cf_socket = CFSocketCreateWithNative(kCFAllocatorDefault,
sock->fd,
kCFSocketReadCallBack,
&__CFSocketCallBack,
&socket_context);
// Don't close the socket if the CFSocket is invalidated
CFOptionFlags flags = CFSocketGetSocketFlags(sock->cf_socket);
flags = flags & ~kCFSocketCloseOnInvalidate;
CFSocketSetSocketFlags(sock->cf_socket, flags);
// Create a new RunLoopSource and register it with the main thread RunLoop
sock->cf_run_loop_source = CFSocketCreateRunLoopSource(kCFAllocatorDefault, sock->cf_socket, 0);
CFRunLoopAddSource(context->cf_run_loop, sock->cf_run_loop_source, kCFRunLoopDefaultMode);
CFRelease(sock->cf_run_loop_source);
} else if (TNET_SOCKET_TYPE_IS_STREAM(sock->type)) {
// Create a pair of streams (read/write) from the socket
CFStreamCreatePairWithSocket(kCFAllocatorDefault, sock->fd, &sock->cf_read_stream, &sock->cf_write_stream);
// Don't close underlying socket
CFReadStreamSetProperty(sock->cf_read_stream, kCFStreamPropertyShouldCloseNativeSocket, kCFBooleanFalse);
CFWriteStreamSetProperty(sock->cf_write_stream, kCFStreamPropertyShouldCloseNativeSocket, kCFBooleanFalse);
if (TNET_SOCKET_TYPE_IS_SECURE(sock->type)) {
CFMutableDictionaryRef settings = CFDictionaryCreateMutable(kCFAllocatorDefault, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
CFDictionaryAddValue(settings, kCFStreamSSLAllowsExpiredCertificates, kCFBooleanTrue);
CFDictionaryAddValue(settings, kCFStreamSSLAllowsAnyRoot, kCFBooleanTrue);
CFDictionaryAddValue(settings, kCFStreamSSLValidatesCertificateChain, kCFBooleanFalse);
CFDictionaryAddValue(settings, kCFStreamSSLPeerName, kCFNull);
// Set the SSL settings
CFReadStreamSetProperty(sock->cf_read_stream, kCFStreamPropertySocketSecurityLevel, kCFStreamSocketSecurityLevelNegotiatedSSL);
CFReadStreamSetProperty(sock->cf_read_stream, kCFStreamPropertySSLSettings, settings);
CFWriteStreamSetProperty(sock->cf_write_stream, kCFStreamPropertySocketSecurityLevel, kCFStreamSocketSecurityLevelNegotiatedSSL);
CFWriteStreamSetProperty(sock->cf_write_stream, kCFStreamPropertySSLSettings, settings);
CFRelease(settings);
}
#if __IPHONE_4_0
// Mark the stream for VoIP usage
CFReadStreamSetProperty(sock->cf_read_stream, kCFStreamNetworkServiceType, kCFStreamNetworkServiceTypeVoIP);
CFWriteStreamSetProperty(sock->cf_write_stream, kCFStreamNetworkServiceType, kCFStreamNetworkServiceTypeVoIP);
#endif
// Setup a context for the streams
CFStreamClientContext streamContext = { 0, transport, NULL, NULL, NULL };
// Set the client callback for the stream
CFReadStreamSetClient(sock->cf_read_stream,
kCFStreamEventOpenCompleted | kCFStreamEventHasBytesAvailable | kCFStreamEventErrorOccurred | kCFStreamEventEndEncountered,
&__CFReadStreamClientCallBack,
&streamContext);
CFWriteStreamSetClient(sock->cf_write_stream,
kCFStreamEventOpenCompleted | kCFStreamEventErrorOccurred | kCFStreamEventEndEncountered,
&__CFWriteStreamClientCallBack,
&streamContext);
// Enroll streams in the run-loop
CFReadStreamScheduleWithRunLoop(sock->cf_read_stream, context->cf_run_loop, kCFRunLoopDefaultMode);
CFWriteStreamScheduleWithRunLoop(sock->cf_write_stream, context->cf_run_loop, kCFRunLoopDefaultMode);
// Release references
CFRelease(sock->cf_read_stream);
CFRelease(sock->cf_write_stream);
CFReadStreamOpen(sock->cf_read_stream);
CFWriteStreamOpen(sock->cf_write_stream);
}
return 0;
}
/*=== Main thread */
void *tnet_transport_mainthread(void *param)
{
tnet_transport_t *transport = param;
transport_context_t *context = transport->context;
int ret, status;
tsk_size_t i;
tsk_bool_t is_stream;
tnet_fd_t fd;
struct sockaddr_storage remote_addr = {0};
transport_socket_xt* active_socket;
/* check whether the transport is already prepared */
if(!transport->prepared) {
TSK_DEBUG_ERROR("Transport must be prepared before strating.");
goto bail;
}
is_stream = TNET_SOCKET_TYPE_IS_STREAM(transport->master->type);
TSK_DEBUG_INFO("Starting [%s] server with IP {%s} on port {%d} using master fd {%d} with type {%d} with max_fds {%lu}...",
transport->description,
transport->master->ip,
transport->master->port,
transport->master->fd,
transport->master->type,
sizeof(context->ufds)/sizeof(context->ufds[0]));
while(TSK_RUNNABLE(transport)->running || TSK_RUNNABLE(transport)->started) {
context->polling = tsk_true;
ret = tnet_poll(context->ufds, context->count, -1);
context->polling = tsk_false;
if(ret < 0) {
TNET_PRINT_LAST_ERROR("poll() have failed.");
goto bail;
}
if(!TSK_RUNNABLE(transport)->running && !TSK_RUNNABLE(transport)->started) {
TSK_DEBUG_INFO("Stopping [%s] server with IP {%s} on port {%d} with type {%d}...", transport->description, transport->master->ip, transport->master->port, transport->master->type);
goto bail;
}
/* lock context */
tsk_safeobj_lock(context);
/* == == */
for(i=0; i<context->count; i++) {
if(!context->ufds[i].revents) {
continue;
}
// TSK_DEBUG_INFO("REVENTS(i=%d) = %d", i, context->ufds[i].revents);
if(context->ufds[i].fd == context->pipeR) {
TSK_DEBUG_INFO("PipeR event = %d", context->ufds[i].revents);
if(context->ufds[i].revents & TNET_POLLIN) {
static char __buffer[1024];
if(read(context->pipeR, __buffer, sizeof(__buffer)) < 0) {
TNET_PRINT_LAST_ERROR("Failed to read from the Pipe");
}
}
else if(context->ufds[i].revents & TNET_POLLHUP) {
TNET_PRINT_LAST_ERROR("Pipe Error");
goto bail;
}
context->ufds[i].revents = 0;
continue;
}
/* Get active event and socket */
active_socket = context->sockets[i];
/*================== TNET_POLLHUP ==================*/
if(context->ufds[i].revents & (TNET_POLLHUP)) {
if(context->ufds[i].revents & TNET_POLLOUT) {
TSK_DEBUG_INFO("POLLOUT and POLLHUP are exclusive");
}
else {
fd = active_socket->fd;
TSK_DEBUG_INFO("NETWORK EVENT FOR SERVER [%s] -- TNET_POLLHUP(%d)", transport->description, fd);
tnet_transport_remove_socket(transport, &active_socket->fd);
TSK_RUNNABLE_ENQUEUE(transport, event_closed, transport->callback_data, fd);
continue;
}
}
/*================== TNET_POLLERR ==================*/
if(context->ufds[i].revents & (TNET_POLLERR)) {
fd = active_socket->fd;
TSK_DEBUG_INFO("NETWORK EVENT FOR SERVER [%s] -- TNET_POLLERR(%d)", transport->description, fd);
tnet_transport_remove_socket(transport, &active_socket->fd);
TSK_RUNNABLE_ENQUEUE(transport, event_error, transport->callback_data, fd);
continue;
}
/*================== TNET_POLLNVAL ==================*/
if(context->ufds[i].revents & (TNET_POLLNVAL)) {
fd = active_socket->fd;
TSK_DEBUG_INFO("NETWORK EVENT FOR SERVER [%s] -- TNET_POLLNVAL(%d)", transport->description, fd);
tnet_transport_remove_socket(transport, &active_socket->fd);
TSK_RUNNABLE_ENQUEUE(transport, event_error, transport->callback_data, fd);
continue;
}
/*================== POLLIN ==================*/
if(context->ufds[i].revents & TNET_POLLIN) {
tsk_size_t len = 0;
void* buffer = tsk_null;
tnet_transport_event_t* e;
// TSK_DEBUG_INFO("NETWORK EVENT FOR SERVER [%s] -- TNET_POLLIN(%d)", transport->description, active_socket->fd);
/* check whether the socket is paused or not */
if(active_socket->paused) {
TSK_DEBUG_INFO("Socket is paused");
goto TNET_POLLIN_DONE;
}
/* Retrieve the amount of pending data.
* IMPORTANT: If you are using Symbian please update your SDK to the latest build (August 2009) to have 'FIONREAD'.
* This apply whatever you are using the 3rd or 5th edition.
* Download link: http://wiki.forum.nokia.com/index.php/Open_C/C%2B%2B_Release_History
*/
ret = tnet_ioctlt(active_socket->fd, FIONREAD, &len);
if((ret < 0 || !len) && is_stream) {
/* It's probably an incoming connection --> try to accept() it */
int listening = 0, remove_socket = 0;
socklen_t socklen = sizeof(listening);
TSK_DEBUG_INFO("ioctlt(%d), len=%u returned zero or failed", active_socket->fd, (unsigned)len);
// check if socket is listening
if(getsockopt(active_socket->fd, SOL_SOCKET, SO_ACCEPTCONN, &listening, &socklen) != 0) {
#if defined(BSD) /* old FreeBSD versions (and OSX up to Lion) do not support SO_ACCEPTCONN */
listening = 1;
#else
TNET_PRINT_LAST_ERROR("getsockopt(SO_ACCEPTCONN, %d) failed\n", active_socket->fd);
/* not socket accepted -> no socket to remove */
goto TNET_POLLIN_DONE;
#endif
}
if (listening) {
if((fd = accept(active_socket->fd, tsk_null, tsk_null)) != TNET_INVALID_SOCKET) {
TSK_DEBUG_INFO("NETWORK EVENT FOR SERVER [%s] -- FD_ACCEPT(fd=%d)", transport->description, fd);
addSocket(fd, transport->master->type, transport, tsk_true, tsk_false, tsk_null);
TSK_RUNNABLE_ENQUEUE(transport, event_accepted, transport->callback_data, fd);
if(active_socket->tlshandle) {
transport_socket_xt* tls_socket;
if((tls_socket = getSocket(context, fd))) {
if(tnet_tls_socket_accept(tls_socket->tlshandle) != 0) {
TSK_RUNNABLE_ENQUEUE(transport, event_closed, transport->callback_data, fd);
tnet_transport_remove_socket(transport, &fd);
TNET_PRINT_LAST_ERROR("SSL_accept() failed");
continue;
}
}
}
}
else {
TNET_PRINT_LAST_ERROR("accept(%d) failed", active_socket->fd);
remove_socket = 1;
}
}
else {
TSK_DEBUG_INFO("Closing socket with fd = %d because ioctlt() returned zero or failed", active_socket->fd);
remove_socket = 1;
}
if(remove_socket) {
fd = active_socket->fd;
tnet_transport_remove_socket(transport, &active_socket->fd);
TSK_RUNNABLE_ENQUEUE(transport, event_closed, transport->callback_data, fd);
continue;
}
goto TNET_POLLIN_DONE;
}
if(len <= 0) {
#if defined(__ANDROID__) || defined(ANDROID)
// workaround for indoona OSX which sends bodiless UDP packets
// vand Android requires to call recv() even if len is equal to zero
if(len == 0 && ret == 0) {
static char __fake_buff[1];
ret = recv(active_socket->fd, __fake_buff, len, 0);
}
#endif
goto TNET_POLLIN_DONE;
}
if (!(buffer = tsk_calloc(len, sizeof(uint8_t)))) {
TSK_DEBUG_ERROR("TSK_CALLOC FAILED");
goto TNET_POLLIN_DONE;
}
// Retrieve the remote address
if (TNET_SOCKET_TYPE_IS_STREAM(transport->master->type)) {
ret = tnet_getpeername(active_socket->fd, &remote_addr);
}
// Receive the waiting data
if (active_socket->tlshandle) {
int isEncrypted;
tsk_size_t tlslen = len;
if ((ret = tnet_tls_socket_recv(active_socket->tlshandle, &buffer, &tlslen, &isEncrypted)) == 0) {
if (isEncrypted) {
TSK_FREE(buffer);
goto TNET_POLLIN_DONE;
}
if (ret == 0) {
len = ret = tlslen;
}
}
}
else {
if (is_stream) {
ret = tnet_sockfd_recv(active_socket->fd, buffer, len, 0);
}
else {
ret = tnet_sockfd_recvfrom(active_socket->fd, buffer, len, 0, (struct sockaddr*)&remote_addr);
}
}
if(ret < 0) {
TSK_FREE(buffer);
status = tnet_geterrno();
// do not remove the socket for i/o pending errors
if (status == TNET_ERROR_WOULDBLOCK || status == TNET_ERROR_INPROGRESS || status == TNET_ERROR_EAGAIN) {
TSK_DEBUG_WARN("recv returned error code:%d", status);
}
else {
TNET_PRINT_LAST_ERROR("recv/recvfrom have failed");
removeSocket(i, context);
}
goto TNET_POLLIN_DONE;
}
if((len != (tsk_size_t)ret) && len) {
len = (tsk_size_t)ret;
// buffer = tsk_realloc(buffer, len);
}
if(len > 0) {
transport->bytes_in += len;
e = tnet_transport_event_create(event_data, transport->callback_data, active_socket->fd);
e->data = buffer, buffer = tsk_null;
e->size = len;
e->remote_addr = remote_addr;
TSK_RUNNABLE_ENQUEUE_OBJECT_SAFE(TSK_RUNNABLE(transport), e);
}
TSK_FREE(buffer);
TNET_POLLIN_DONE:
/*context->ufds[i].revents &= ~TNET_POLLIN*/
;
}
/*================== TNET_POLLOUT ==================*/
if(context->ufds[i].revents & TNET_POLLOUT) {
TSK_DEBUG_INFO("NETWORK EVENT FOR SERVER [%s] -- TNET_POLLOUT", transport->description);
if(!active_socket->connected) {
active_socket->connected = tsk_true;
TSK_RUNNABLE_ENQUEUE(transport, event_connected, transport->callback_data, active_socket->fd);
}
//else{
context->ufds[i].events &= ~TNET_POLLOUT;
//}
}
/*================== TNET_POLLPRI ==================*/
if(context->ufds[i].revents & TNET_POLLPRI) {
TSK_DEBUG_INFO("NETWORK EVENT FOR SERVER [%s] -- TNET_POLLPRI", transport->description);
}
context->ufds[i].revents = 0;
}/* for */
done:
/* unlock context */
tsk_safeobj_unlock(context);
} /* while */
bail:
TSK_DEBUG_INFO("Stopped [%s] server with IP {%s} on port {%d}", transport->description, transport->master->ip, transport->master->port);
return 0;
}
int tnet_transport_prepare(tnet_transport_t *transport)
{
int ret = -1;
transport_context_t *context;
tnet_fd_t pipes[2];
TSK_DEBUG_INFO("tnet_transport_prepare()");
if(!transport || !transport->context) {
TSK_DEBUG_ERROR("Invalid parameter.");
return -1;
}
else {
context = transport->context;
}
if(transport->prepared) {
TSK_DEBUG_ERROR("Transport already prepared.");
return -2;
}
/* Prepare master */
if(!transport->master) {
if((transport->master = tnet_socket_create(transport->local_host, transport->req_local_port, transport->type))) {
tsk_strupdate(&transport->local_ip, transport->master->ip);
transport->bind_local_port = transport->master->port;
}
else {
TSK_DEBUG_ERROR("Failed to create master socket");
return -3;
}
}
/* Start listening */
if(TNET_SOCKET_TYPE_IS_STREAM(transport->master->type)) {
if((ret = tnet_sockfd_listen(transport->master->fd, TNET_MAX_FDS))) {
TNET_PRINT_LAST_ERROR("listen have failed.");
goto bail;
}
}
/* Create and add pipes to the fd_set */
if((ret = pipe(pipes))) {
TNET_PRINT_LAST_ERROR("Failed to create new pipes.");
goto bail;
}
/* set both R and W sides */
context->pipeR = pipes[0];
context->pipeW = pipes[1];
/* add R side */
TSK_DEBUG_INFO("pipeR fd=%d, pipeW=%d", context->pipeR, context->pipeW);
if((ret = addSocket(context->pipeR, transport->master->type, transport, tsk_true, tsk_false, tsk_null))) {
goto bail;
}
/* Add the master socket to the context. */
TSK_DEBUG_INFO("master fd=%d", transport->master->fd);
// don't take ownership: will be closed by the dctor() when refCount==0
// otherwise will be closed twice: dctor() and removeSocket()
if((ret = addSocket(transport->master->fd, transport->master->type, transport, tsk_false, tsk_false, tsk_null))) {
TSK_DEBUG_ERROR("Failed to add master socket");
goto bail;
}
transport->prepared = tsk_true;
bail:
return ret;
}
/*=== Main thread */
void* TSK_STDCALL tnet_transport_mainthread(void *param)
{
tnet_transport_t *transport = (tnet_transport_t*)param;
transport_context_t *context = (transport_context_t*)transport->context;
DWORD evt;
WSANETWORKEVENTS networkEvents;
DWORD flags = 0;
int ret;
struct sockaddr_storage remote_addr = { 0 };
WSAEVENT active_event;
transport_socket_xt* active_socket;
int index;
TSK_DEBUG_INFO("Starting [%s] server with IP {%s} on port {%d} with type {%d}...", transport->description, transport->master->ip, transport->master->port, transport->master->type);
while (TSK_RUNNABLE(transport)->running || TSK_RUNNABLE(transport)->started) {
/* Wait for multiple events */
if ((evt = WSAWaitForMultipleEvents((DWORD)context->count, context->events, FALSE, WSA_INFINITE, FALSE)) == WSA_WAIT_FAILED) {
TNET_PRINT_LAST_ERROR("WSAWaitForMultipleEvents have failed.");
goto bail;
}
if (!TSK_RUNNABLE(transport)->running && !TSK_RUNNABLE(transport)->started) {
goto bail;
}
/* lock context */
tsk_safeobj_lock(context);
/* Get active event and socket */
index = (evt - WSA_WAIT_EVENT_0);
active_event = context->events[index];
if (!(active_socket = context->sockets[index])) {
goto done;
}
/* Get the network events flags */
if (WSAEnumNetworkEvents(active_socket->fd, active_event, &networkEvents) == SOCKET_ERROR) {
TSK_RUNNABLE_ENQUEUE(transport, event_error, transport->callback_data, active_socket->fd);
TNET_PRINT_LAST_ERROR("WSAEnumNetworkEvents have failed.");
tsk_safeobj_unlock(context);
goto bail;
}
/*================== FD_ACCEPT ==================*/
if (networkEvents.lNetworkEvents & FD_ACCEPT) {
tnet_fd_t fd;
TSK_DEBUG_INFO("NETWORK EVENT FOR SERVER [%s] -- FD_ACCEPT", transport->description);
if (networkEvents.iErrorCode[FD_ACCEPT_BIT]) {
TSK_RUNNABLE_ENQUEUE(transport, event_error, transport->callback_data, active_socket->fd);
TNET_PRINT_LAST_ERROR("ACCEPT FAILED.");
goto done;
}
/* Accept the connection */
if ((fd = (tnet_fd_t)WSAAccept(active_socket->fd, NULL, NULL, AcceptCondFunc, (DWORD_PTR)context)) != INVALID_SOCKET) {
/* Add the new fd to the server context */
addSocket(fd, transport->master->type, transport, tsk_true, tsk_false, tsk_null);
if (active_socket->tlshandle) {
transport_socket_xt* tls_socket;
if ((tls_socket = getSocket(context, fd))) {
if (tnet_tls_socket_accept(tls_socket->tlshandle)) {
tnet_transport_remove_socket(transport, &fd);
TNET_PRINT_LAST_ERROR("SSL_accept() failed");
goto done;
}
}
}
if (WSAEventSelect(fd, context->events[context->count - 1], FD_READ | FD_WRITE | FD_CLOSE) == SOCKET_ERROR) {
tnet_transport_remove_socket(transport, &fd);
TNET_PRINT_LAST_ERROR("WSAEventSelect() have failed.");
goto done;
}
TSK_RUNNABLE_ENQUEUE(transport, event_accepted, transport->callback_data, fd);
}
else {
TNET_PRINT_LAST_ERROR("ACCEPT FAILED.");
goto done;
}
}
/*================== FD_CONNECT ==================*/
if (networkEvents.lNetworkEvents & FD_CONNECT) {
TSK_DEBUG_INFO("NETWORK EVENT FOR SERVER [%s] -- FD_CONNECT", transport->description);
if (networkEvents.iErrorCode[FD_CONNECT_BIT]) {
tnet_fd_t fd = active_socket->fd;
TSK_RUNNABLE_ENQUEUE(transport, event_error, transport->callback_data, fd);
tnet_transport_remove_socket(transport, &fd);
TNET_PRINT_LAST_ERROR("CONNECT FAILED.");
goto done;
}
else {
TSK_RUNNABLE_ENQUEUE(transport, event_connected, transport->callback_data, active_socket->fd);
active_socket->connected = 1;
}
}
/*================== FD_READ ==================*/
if (networkEvents.lNetworkEvents & FD_READ) {
DWORD readCount = 0;
WSABUF wsaBuffer;
/* TSK_DEBUG_INFO("NETWORK EVENT FOR SERVER [%s] -- FD_READ", transport->description); */
/* check whether the socket is paused or not */
if (active_socket->paused) {
TSK_DEBUG_INFO("Socket is paused");
goto FD_READ_DONE;
}
if (networkEvents.iErrorCode[FD_READ_BIT]) {
TSK_RUNNABLE_ENQUEUE(transport, event_error, transport->callback_data, active_socket->fd);
TNET_PRINT_LAST_ERROR("READ FAILED.");
goto done;
}
/* Retrieve the amount of pending data */
if (tnet_ioctlt(active_socket->fd, FIONREAD, &(wsaBuffer.len)) < 0) {
TNET_PRINT_LAST_ERROR("IOCTLT FAILED.");
goto done;
}
if (!wsaBuffer.len) {
goto done;
}
/* Alloc data */
if (!(wsaBuffer.buf = tsk_calloc(wsaBuffer.len, sizeof(uint8_t)))) {
goto done;
}
/* Retrieve the remote address */
if (TNET_SOCKET_TYPE_IS_STREAM(transport->master->type)) {
ret = tnet_getpeername(active_socket->fd, &remote_addr);
}
/* Receive the waiting data. */
if (active_socket->tlshandle) {
int isEncrypted;
tsk_size_t len = wsaBuffer.len;
if (!(ret = tnet_tls_socket_recv(active_socket->tlshandle, &wsaBuffer.buf, &len, &isEncrypted))) {
if (isEncrypted) {
TSK_FREE(wsaBuffer.buf);
goto done;
}
wsaBuffer.len = (ULONG)len;
}
}
else {
if (TNET_SOCKET_TYPE_IS_STREAM(transport->master->type)) {
ret = WSARecv(active_socket->fd, &wsaBuffer, 1, &readCount, &flags, 0, 0);
}
else {
int len = sizeof(remote_addr);
ret = WSARecvFrom(active_socket->fd, &wsaBuffer, 1, &readCount, &flags,
(struct sockaddr*)&remote_addr, &len, 0, 0);
}
if (readCount < wsaBuffer.len) {
wsaBuffer.len = readCount;
/* wsaBuffer.buf = tsk_realloc(wsaBuffer.buf, readCount); */
}
}
if (ret) {
ret = WSAGetLastError();
if (ret == WSAEWOULDBLOCK) {
// Doesn't (always) mean congestion but... another thread is also poll()ing the FD. For example, when TURN session has a reference to the fd.
TSK_DEBUG_WARN("WSAEWOULDBLOCK error for READ SSESSION");
}
else if (ret == WSAECONNRESET && TNET_SOCKET_TYPE_IS_DGRAM(transport->master->type)) {
/* For DGRAM ==> The sent packet gernerated "ICMP Destination/Port unreachable" result. */
TSK_FREE(wsaBuffer.buf);
goto done; // ignore and retry.
}
else {
TSK_FREE(wsaBuffer.buf);
removeSocket(index, context);
TNET_PRINT_LAST_ERROR("WSARecv have failed.");
goto done;
}
}
else {
tnet_transport_event_t* e = tnet_transport_event_create(event_data, transport->callback_data, active_socket->fd);
transport->bytes_in += wsaBuffer.len;
e->data = wsaBuffer.buf;
e->size = wsaBuffer.len;
e->remote_addr = remote_addr;
TSK_RUNNABLE_ENQUEUE_OBJECT_SAFE(TSK_RUNNABLE(transport), e);
}
FD_READ_DONE:
;
}
/*================== FD_WRITE ==================*/
if (networkEvents.lNetworkEvents & FD_WRITE) {
TSK_DEBUG_INFO("NETWORK EVENT FOR SERVER [%s] -- FD_WRITE", transport->description);
if (networkEvents.iErrorCode[FD_WRITE_BIT]) {
TSK_RUNNABLE_ENQUEUE(transport, event_error, transport->callback_data, active_socket->fd);
TNET_PRINT_LAST_ERROR("WRITE FAILED.");
goto done;
}
}
/*================== FD_CLOSE ==================*/
if (networkEvents.lNetworkEvents & FD_CLOSE) {
TSK_DEBUG_INFO("NETWORK EVENT FOR SERVER [%s] -- FD_CLOSE", transport->description);
TSK_RUNNABLE_ENQUEUE(transport, event_closed, transport->callback_data, active_socket->fd);
removeSocket(index, context);
}
/* http://msdn.microsoft.com/en-us/library/ms741690(VS.85).aspx
The proper way to reset the state of an event object used with the WSAEventSelect function
is to pass the handle of the event object to the WSAEnumNetworkEvents function in the hEventObject parameter.
This will reset the event object and adjust the status of active FD events on the socket in an atomic fashion.
*/
/* WSAResetEvent(active_event); <== DO NOT USE (see above) */
done:
/* unlock context */
tsk_safeobj_unlock(context);
} /* while(transport->running) */
bail:
TSK_DEBUG_INFO("Stopped [%s] server with IP {%s} on port {%d} with type {%d}...", transport->description, transport->master->ip, transport->master->port, transport->master->type);
return tsk_null;
}
int tnet_transport_prepare(tnet_transport_t *transport)
{
int ret = -1;
transport_context_t *context;
tnet_fd_t pipes[2];
if(!transport || !transport->context){
TSK_DEBUG_ERROR("Invalid parameter.");
return -1;
}
else{
context = transport->context;
}
if(transport->prepared){
TSK_DEBUG_ERROR("Transport already prepared.");
return -2;
}
/* Prepare master */
if(!transport->master){
if((transport->master = tnet_socket_create(transport->local_host, transport->req_local_port, transport->type))){
tsk_strupdate(&transport->local_ip, transport->master->ip);
transport->bind_local_port = transport->master->port;
}
else{
TSK_DEBUG_ERROR("Failed to create master socket");
return -3;
}
}
/* set events */
context->events = TNET_POLLIN | TNET_POLLNVAL | TNET_POLLERR;
if(TNET_SOCKET_TYPE_IS_STREAM(transport->master->type)){
context->events |= TNET_POLLOUT // emulate WinSock2 FD_CONNECT event
//#if !defined(ANDROID)
// | TNET_POLLHUP /* FIXME: always present */
//#endif
;
}
/* Start listening */
if(TNET_SOCKET_TYPE_IS_STREAM(transport->master->type)){
if((ret = tnet_sockfd_listen(transport->master->fd, TNET_MAX_FDS))){
TNET_PRINT_LAST_ERROR("listen have failed.");
goto bail;
}
}
/* Create and add pipes to the fd_set */
if((ret = pipe(pipes))){
TNET_PRINT_LAST_ERROR("Failed to create new pipes.");
goto bail;
}
/* set both R and W sides */
context->pipeR = pipes[0];
context->pipeW = pipes[1];
/* add R side */
TSK_DEBUG_INFO("pipeR fd=%d", context->pipeR);
if((ret = addSocket(context->pipeR, transport->master->type, transport, tsk_true, tsk_false))){
goto bail;
}
/* Add the master socket to the context. */
TSK_DEBUG_INFO("master fd=%d", transport->master->fd);
// don't take ownership: will be closed by the dctor()
// otherwise will be closed twice: dctor() and removeSocket()
if((ret = addSocket(transport->master->fd, transport->master->type, transport, tsk_false, tsk_false))){
TSK_DEBUG_ERROR("Failed to add master socket");
goto bail;
}
transport->prepared = tsk_true;
bail:
return ret;
}
