// Function responsible of setting the keep-alive interval.
inline void TCPSocket::keep_alive_interval( const u_long value )
{
lock_ref().enter();
_keep_alive_timeout = value;
_set_keep_alive_option();
lock_ref().leave();
};
// Function responsible of setting the keep-alive option of the socket.
inline void TCPSocket::keep_alive( const bool value )
{
lock_ref().enter();
_keep_alive = value;
_set_keep_alive_option();
lock_ref().leave();
};
// Function responsible of returning the interval period for the keep-alive option.
inline u_long TCPSocket::keep_alive_interval() const
{
u_long return_value = 0;
lock_ref().enter();
return_value = _keep_alive_interval;
lock_ref().leave();
return return_value;
};
// Function responsible of returning whether the keep-alive option is enabled for this socket.
inline bool TCPSocket::keep_alive() const
{
bool return_value = false;
lock_ref().enter();
return_value = _keep_alive;
lock_ref().leave();
return return_value;
};
// Function responsible of returning the size of the listen queue.
inline int TCPSocket::queue_size() const
{
int return_value = 0;
lock_ref().enter();
return_value = _queue_size;
lock_ref().leave();
return return_value;
};
// Function responsible of accepting a connection on the socket.
inline Socket* TCPSocket::accept()
{
Socket* return_value = NULL;
lock_ref().enter();
if ( socket_ref() != NULL && listen() )
{
sockaddr_storage target;
SOCKET new_socket;
int target_size = sizeof(target);
memset(&target,'\0',target_size);
new_socket = WSAAccept(socket_ref(),reinterpret_cast<sockaddr*>(&target),&target_size,NULL,NULL);
if ( new_socket != INVALID_SOCKET )
{
TCPSocket* accepted_socket = new (std::nothrow) TCPSocket( ( protocol() == SOCKET_TCP_V4 ? false : true ) , new_socket,target);
if ( accepted_socket != NULL )
{
accepted_socket->queue_size(queue_size());
accepted_socket->blocking(blocking());
accepted_socket->send_timeout(send_timeout());
accepted_socket->receive_timeout(receive_timeout());
accepted_socket->keep_alive(keep_alive());
accepted_socket->keep_alive_timeout(keep_alive_timeout());
accepted_socket->keep_alive_interval(keep_alive_interval());
accepted_socket->overlapped(overlapped());
accepted_socket->send_overlapped_function(send_overlapped_function());
accepted_socket->receive_overlapped_function(receive_overlapped_function());
_accepted_sockets.push_back(accepted_socket);
return_value = accepted_socket;
}
else
closesocket(new_socket);
}
}
lock_ref().leave();
return return_value;
};
void
lock_write_ref (struct rwlock_t *lockp)
{
LOCK_PRINTK("lock_write_ref: %d\n", lockp);
/* Stop switching to other user processes. */
SWITCH_OFF();
if (lockp->passed) {
lockp->lock++;
lock_ref (&lockp->lock);
lockp->lock--;
} else
lock_ref (&lockp->lock);
}
// Function responsible of connecting the socket.
inline bool TCPSocket::connect()
{
bool return_value = false;
lock_ref().enter();
if ( socket_ref() != NULL && address_ref() != "" )
{
create_socket_info();
if ( WSAConnect(socket_ref(),reinterpret_cast<sockaddr*>(&socket_info_ref()),sizeof(socket_info_ref()),NULL,NULL,NULL,NULL) == 0 )
return_value = true;
}
lock_ref().leave();
return return_value;
};
// Function responsible of listening on a socket.
inline bool TCPSocket::listen()
{
bool return_value = false;
lock_ref().enter();
if ( socket_ref() != NULL && bound() )
{
if ( ::listen(socket_ref(),_queue_size) == 0 )
{
listening(true);
return_value = true;
}
}
lock_ref().leave();
return return_value;
};
void
lock_read_ref (struct rwlock_t *lockp)
{
LOCK_PRINTK("lock_read_ref: %d\n", lockp);
/* Stop switching to other user processes. */
SWITCH_OFF();
while (1) {
/* Increment pass-by count. */
if (!lockp->lock) {
lockp->passed++;
break;
}
/* A writer occupied the lock, wait for its release. */
lock_ref (&lockp->lock);
lock_unref (&lockp->lock);
}
SWITCH_ON();
}
// Function responsible of setting the size of the listen queue.
inline void TCPSocket::queue_size( const int size )
{
lock_ref().enter();
_queue_size = std::abs(size);
lock_ref().leave();
};
