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;
}
/**@ingroup tnet_socket_group
* @retval Zero if succeed and nonzero error code otherwise.
*/
int tnet_socket_handle_brokenpipe(tnet_socket_t* self)
{
int ret;
tnet_fd_t fd_old, fd_new;
if (!self || !TNET_SOCKET_TYPE_IS_DGRAM(self->type)) { // Must be UDP
TSK_DEBUG_ERROR("Invalid parameter");
return -1;
}
fd_old = self->fd;
fd_new = TNET_INVALID_FD;
// close old fd
ret = tnet_sockfd_close(&self->fd);
// try to create an fd binding to the same address
if ((ret = tnet_sockfd_init(self->ip, self->port, self->type, &fd_new)) != 0) {
TNET_PRINT_LAST_ERROR("Find to bind to %s:%d", self->ip, self->port);
// TODO: Create completly new socket?
return ret;
}
#if TNET_UNDER_IPHONE || TNET_UNDER_IPHONE_SIMULATOR
/* disable SIGPIPE signal */
{
int yes = 1;
if (setsockopt(fd_new, SOL_SOCKET, SO_NOSIGPIPE, (char*)&yes, sizeof(int))){
TNET_PRINT_LAST_ERROR("setsockopt(%d, SO_NOSIGPIPE) have failed", fd_new);
}
}
#endif /* TNET_UNDER_IPHONE || TNET_UNDER_IPHONE_SIMULATOR */
TSK_DEBUG_INFO("Broken pipe result for {%s:%d}: %d -> %d", self->ip, self->port, fd_old, fd_new);
self->fd = fd_new;
return 0;
}
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;
}
/*
* Sends dgarm to the specified destionation.
*/
tsk_size_t tnet_transport_sendto(const tnet_transport_handle_t *handle, tnet_fd_t from, const struct sockaddr *to, const void* buf, tsk_size_t size)
{
tnet_transport_t *transport = (tnet_transport_t*)handle;
WSABUF wsaBuffer;
DWORD numberOfBytesSent = 0;
int ret = -1;
if (!transport){
TSK_DEBUG_ERROR("Invalid server handle.");
return ret;
}
if (!TNET_SOCKET_TYPE_IS_DGRAM(transport->master->type)){
TSK_DEBUG_ERROR("In order to use WSASendTo you must use an udp transport.");
return ret;
}
wsaBuffer.buf = (CHAR*)buf;
wsaBuffer.len = (ULONG)size;
if ((ret = WSASendTo(from, &wsaBuffer, 1, &numberOfBytesSent, 0, to, tnet_get_sockaddr_size(to), 0, 0)) == SOCKET_ERROR){
if ((ret = WSAGetLastError()) == WSA_IO_PENDING){
TSK_DEBUG_INFO("WSA_IO_PENDING error for WSASendTo SSESSION");
ret = 0;
}
else{
TNET_PRINT_LAST_ERROR("WSASendTo have failed.");
return ret;
}
}
else ret = 0;
return numberOfBytesSent;
}
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;
}
if(transport->tls.enabled) {
const transport_socket_xt* socket = getSocket(transport->context, from);
if(socket && socket->tlshandle) {
if(!tnet_tls_socket_send(socket->tlshandle, buf, size)) {
numberOfBytesSent = size;
}
else {
numberOfBytesSent = 0;
}
goto bail;
}
}
else if((numberOfBytesSent = tnet_sockfd_send(from, buf, size, 0)) <= 0) {
TNET_PRINT_LAST_ERROR("send have failed.");
//tnet_sockfd_close(&from);
goto bail;
}
bail:
transport->bytes_out += numberOfBytesSent;
return numberOfBytesSent;
}
int tnet_tls_socket_accept(tnet_tls_socket_handle_t* self)
{
#if !HAVE_OPENSSL
TSK_DEBUG_ERROR("You MUST enable OpenSSL");
return -200;
#else
int ret = -1;
tnet_tls_socket_t* socket = self;
if(!self){
TSK_DEBUG_ERROR("Invalid parameter");
return -1;
}
if((ret = SSL_accept(socket->ssl)) != 1){
ret = SSL_get_error(socket->ssl, ret);
if(ret == SSL_ERROR_WANT_READ){
int retval;
fd_set rfds;
while (1)
{
FD_ZERO(&rfds);
FD_SET(socket->fd, &rfds);
retval = select(socket->fd + 1, &rfds, NULL, NULL, NULL);
if (retval == -1){
TNET_PRINT_LAST_ERROR("select() failed");
}
else if (retval)
{
if (FD_ISSET(socket->fd, &rfds)){
ret = SSL_accept(socket->ssl);
ret = SSL_get_error(socket->ssl, ret);
if (ret == SSL_ERROR_WANT_READ){
continue;
}
else{
if(ret == SSL_ERROR_NONE){
return 0;
}
break;
}
}
}
else
{
break;
}
}
}
TSK_DEBUG_ERROR("SSL_accept() failed with error code [%d, %s]", ret, ERR_error_string(ERR_get_error(), tsk_null));
return -3;
}
return 0;
#endif
}
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;
}
/*
* Sends stream/dgram data to the remote peer (shall be previously connected using @tnet_transport_connectto).
*/
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 ret = -1;
tsk_size_t sent = 0;
if (!transport) {
TSK_DEBUG_ERROR("Invalid transport handle.");
goto bail;
}
while (sent < size) {
int try_guard = 10;
if (transport->tls.enabled) {
transport_socket_xt* socket = getSocket(transport->context, from);
if (socket && socket->tlshandle) {
if (tnet_tls_socket_send(socket->tlshandle, buf, size) == 0) {
sent = size;
}
else {
TSK_DEBUG_ERROR("Tring to use a socket without TLS handle to send data");
}
goto bail; // TLS do not retry
}
}
else {
WSABUF wsaBuffer;
DWORD numberOfBytesSent = 0;
wsaBuffer.buf = ((CHAR*)buf) + sent;
wsaBuffer.len = (ULONG)(size - sent);
try_again:
if ((ret = WSASend(from, &wsaBuffer, 1, &numberOfBytesSent, 0, NULL, NULL)) == SOCKET_ERROR) {
ret = WSAGetLastError();
if (ret == WSA_IO_PENDING || ret == WSAEWOULDBLOCK) {
TSK_DEBUG_INFO("SendTCP() - WouldBlock. Retrying...");
if (try_guard--) {
tsk_thread_sleep(10);
goto try_again;
}
}
else {
TNET_PRINT_LAST_ERROR("WSASend have failed.");
goto bail;
}
}
else {
sent += numberOfBytesSent;
}
}
}
bail:
transport->bytes_out += sent;
return sent;
}
/*
* Sends stream/dgram data to the remote peer (shall be previously connected using @tnet_transport_connectto).
*/
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 ret = -1;
DWORD numberOfBytesSent = 0;
if (!transport){
TSK_DEBUG_ERROR("Invalid transport handle.");
goto bail;
}
if (transport->tls.enabled){
transport_socket_xt* socket = getSocket(transport->context, from);
if (socket && socket->tlshandle){
if (!tnet_tls_socket_send(socket->tlshandle, buf, size)){
numberOfBytesSent = (DWORD)size;
}
else{
TSK_DEBUG_ERROR("Tring to use a socket without TLS handle to send data");
numberOfBytesSent = 0;
}
goto bail;
}
}
else{
WSABUF wsaBuffer;
wsaBuffer.buf = (CHAR*)buf;
wsaBuffer.len = (ULONG)size;
if ((ret = WSASend(from, &wsaBuffer, 1, &numberOfBytesSent, 0, NULL, NULL)) == SOCKET_ERROR){
if ((ret = WSAGetLastError()) == WSA_IO_PENDING){
TSK_DEBUG_INFO("WSA_IO_PENDING error for WSASend SSESSION");
ret = 0;
}
else{
TNET_PRINT_LAST_ERROR("WSASend have failed.");
//tnet_sockfd_close(&from);
goto bail;
}
}
else{
ret = 0;
}
}
bail:
return numberOfBytesSent;
}
/*
* Add new socket to the watcher.
*/
int tnet_transport_add_socket(const tnet_transport_handle_t *handle, tnet_fd_t fd, tnet_socket_type_t type, tsk_bool_t take_ownership, tsk_bool_t isClient, tnet_tls_socket_handle_t* tlsHandle)
{
tnet_transport_t *transport = (tnet_transport_t*)handle;
transport_context_t* context;
int ret = -1;
if (!transport) {
TSK_DEBUG_ERROR("Invalid server handle.");
return ret;
}
if (!(context = (transport_context_t*)transport->context)) {
TSK_DEBUG_ERROR("Invalid context.");
return -2;
}
if (TNET_SOCKET_TYPE_IS_TLS(type) || TNET_SOCKET_TYPE_IS_WSS(type)) {
transport->tls.enabled = tsk_true;
}
addSocket(fd, type, transport, take_ownership, isClient, tlsHandle);
if (WSAEventSelect(fd, context->events[context->count - 1], FD_ALL_EVENTS) == SOCKET_ERROR) {
removeSocket((int)(context->count - 1), context);
TNET_PRINT_LAST_ERROR("WSAEventSelect have failed.");
return -1;
}
/* Signal if transport is running */
if (TSK_RUNNABLE(transport)->running || TSK_RUNNABLE(transport)->started) {
if (WSASetEvent(context->events[0])) {
TSK_DEBUG_INFO("New socket added to the network transport.");
return 0;
}
TSK_DEBUG_ERROR("Transport not started yet");
return -1;
}
TSK_DEBUG_INFO("Adding socket delayed");
return 0;
}
tsk_size_t tnet_transport_sendto(const tnet_transport_handle_t *handle, tnet_fd_t from, const struct sockaddr *to, const void* buf, tsk_size_t size)
{
tnet_transport_t *transport = (tnet_transport_t*)handle;
int numberOfBytesSent = 0;
if (!transport) {
TSK_DEBUG_ERROR("Invalid server handle.");
goto bail;
}
if (!TNET_SOCKET_TYPE_IS_DGRAM(transport->master->type)) {
TSK_DEBUG_ERROR("In order to use sendto you must use an udp transport.");
goto bail;
}
if ((numberOfBytesSent = sendto(from, buf, size, 0, to, sizeof(*to))) <= 0) {
TNET_PRINT_LAST_ERROR("sendto 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;
}
/* 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;
}
/*
* Add new socket to the watcher.
*/
int tnet_transport_add_socket(const tnet_transport_handle_t *handle, tnet_fd_t fd, tnet_socket_type_t type, tsk_bool_t take_ownership, tsk_bool_t isClient)
{
tnet_transport_t *transport = (tnet_transport_t*)handle;
transport_context_t* context;
int ret = -1;
if(!transport){
TSK_DEBUG_ERROR("Invalid server handle.");
return ret;
}
if(!(context = (transport_context_t*)transport->context)){
TSK_DEBUG_ERROR("Invalid context.");
return -2;
}
if(TNET_SOCKET_TYPE_IS_TLS(type)){
transport->tls.have_tls = 1;
}
addSocket(fd, type, transport, take_ownership, isClient);
if(WSAEventSelect(fd, context->events[context->count - 1], FD_ALL_EVENTS) == SOCKET_ERROR){
removeSocket((context->count - 1), context);
TNET_PRINT_LAST_ERROR("WSAEventSelect have failed.");
return -1;
}
/* Signal */
if(WSASetEvent(context->events[0])){
TSK_DEBUG_INFO("New socket added to the network transport.");
return 0;
}
// ...
return -1;
}
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;
}
void __CFSocketCallBack(CFSocketRef s, CFSocketCallBackType callbackType, CFDataRef address, const void *data, void *info) {
// Extract the context
tnet_transport_t *transport = (tnet_transport_t *) info;
transport_context_t *context = transport->context;
// Extract the native socket
int fd = CFSocketGetNative(s);
transport_socket_t *sock = (transport_socket_t *) getSocket(context, fd);
/* lock context */
tsk_safeobj_lock(context);
switch (callbackType) {
case kCFSocketReadCallBack:
{
int ret;
tsk_size_t len = 0;
void* buffer = 0;
tnet_transport_event_t* e;
if (tnet_ioctlt(sock->fd, FIONREAD, &len) < 0) {
TNET_PRINT_LAST_ERROR("IOCTLT FAILED.");
break;
}
if (!len) {
TSK_DEBUG_WARN("IOCTLT returned zero.");
TSK_RUNNABLE_ENQUEUE(transport, event_closed, transport->callback_data, sock->fd);
removeSocket(sock, context);
break;
}
if (!(buffer = tsk_calloc(len, sizeof(uint8_t)))) {
TSK_DEBUG_ERROR("TSK_CALLOC FAILED.");
break;
}
if ((ret = tnet_sockfd_recv(sock->fd, buffer, len, 0)) < 0) {
TSK_FREE(buffer);
removeSocket(sock, context);
TNET_PRINT_LAST_ERROR("recv have failed.");
break;
}
else if ((len != (tsk_size_t)ret) && len) { // useless test ?
len = (tsk_size_t)ret;
// buffer = tsk_realloc(buffer, len);
}
TSK_DEBUG_INFO("__CFSocketCallBack -> %u bytes read", len);
e = tnet_transport_event_create(event_data, transport->callback_data, sock->fd);
e->data = buffer;
e->size = len;
TSK_RUNNABLE_ENQUEUE_OBJECT(TSK_RUNNABLE(transport), e);
break;
}
case kCFSocketAcceptCallBack:
case kCFSocketConnectCallBack:
case kCFSocketDataCallBack:
case kCFSocketWriteCallBack:
default:
{
// Not Implemented
assert(42 == 0);
break;
}
}
/* unlock context */
tsk_safeobj_unlock(context);
}
/**
* 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;
}
/**@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;
}
/*=== 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;
}
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;
}
/*=== 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;
}
//=================================================================================================
// 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;
}
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;
}