trap_retval RemoteGet( void *data, trap_elen len )
{
unsigned_16 rec_len;
len = len;
_DBG_NET(("RemoteGet\r\n"));
if( IS_VALID_SOCKET( data_socket ) ) {
int size;
size = recvData( &rec_len, sizeof( rec_len ) );
#ifdef __RDOS__
while( size == 0 ) {
if( !IS_VALID_SOCKET( data_socket ) )
return( REQUEST_FAILED );
size = recvData( &rec_len, sizeof( rec_len ) );
}
#endif
if( size == sizeof( rec_len ) ) {
CONV_LE_16( rec_len );
#ifdef __RDOS__
if( rec_len && recvData( data, rec_len ) == rec_len ) {
#else
if( rec_len == 0 || recvData( data, rec_len ) == rec_len ) {
#endif
_DBG_NET(("Got a packet - size=%d\r\n", rec_len));
return( rec_len );
}
}
}
return( REQUEST_FAILED );
}
trap_retval RemotePut( void *data, trap_elen len )
{
unsigned_16 send_len;
int snd;
_DBG_NET(("RemotePut\r\n"));
if( IS_VALID_SOCKET( data_socket ) ) {
send_len = len;
CONV_LE_16( send_len );
snd = send( data_socket, (void *)&send_len, sizeof( send_len ), 0 );
if( IS_RET_OK( snd ) ) {
if( len != 0 )
snd = send( data_socket, data, len, 0 );
if( len == 0 || IS_RET_OK( snd ) ) {
#ifdef __RDOS__
RdosPushTcpConnection( data_socket );
#endif
_DBG_NET(("RemotePut...OK\r\n"));
return( len );
}
}
}
return( REQUEST_FAILED );
}
bool RemoteConnect( void )
{
#ifdef SERVER
#ifdef __RDOS__
void *obj;
obj = (void *)RdosWaitTimeout( wait_handle, 250 );
if( obj != NULL ) {
data_socket = RdosGetTcpListen( listen_handle );
if( IS_VALID_SOCKET( data_socket ) ) {
_DBG_NET(("Found a connection\r\n"));
return( true );
}
}
#else
struct timeval timeout;
fd_set ready;
struct sockaddr dummy;
trp_socklen dummy_len = sizeof( dummy );
int rc;
FD_ZERO( &ready );
FD_SET( control_socket, &ready );
timeout.tv_sec = 0;
timeout.tv_usec = 10000;
rc = select( control_socket + 1, &ready, 0, 0, &timeout );
if( IS_RET_OK( rc ) && rc > 0 ) {
data_socket = accept( control_socket, &dummy, &dummy_len );
if( IS_VALID_SOCKET( data_socket ) ) {
nodelay();
_DBG_NET(("Found a connection\r\n"));
return( true );
}
}
#endif
#else
#ifdef __RDOS__
// todo: Add code for connect!
#else
int rc;
data_socket = socket( AF_INET, SOCK_STREAM, 0 );
if( IS_VALID_SOCKET( data_socket ) ) {
rc = connect( data_socket, (LPSOCKADDR)&socket_address, sizeof( socket_address ) );
if( IS_RET_OK( rc ) ) {
nodelay();
return( true );
}
}
#endif
#endif
return( false );
}
void RemoteDisco( void )
{
_DBG_NET(("RemoteDisco\r\n"));
if( IS_VALID_SOCKET( data_socket ) ) {
soclose( data_socket );
data_socket = INVALID_SOCKET;
}
}
/** Close the socket
* @param sd socket to close
* @param l logger
* @return -1: some kind of error occured (!WIN32)
* SOCKET_ERROR: some kind of error occured (WIN32)
* 0: success
* @remark Does not change errno
*/
int jk_close_socket(jk_sock_t sd, jk_logger_t *l)
{
int rc;
int save_errno;
JK_TRACE_ENTER(l);
if (!IS_VALID_SOCKET(sd)) {
JK_TRACE_EXIT(l);
return -1;
}
save_errno = errno;
#if defined(WIN32) || (defined(NETWARE) && defined(__NOVELL_LIBC__))
rc = closesocket(sd) ? -1 : 0;
#else
do {
rc = close(sd);
} while (JK_IS_SOCKET_ERROR(rc) && (errno == EINTR || errno == EAGAIN));
#endif
JK_TRACE_EXIT(l);
errno = save_errno;
return rc;
}
const char *RemoteLink( const char *parms, bool server )
{
unsigned short port;
#ifndef __RDOS__
struct servent *sp;
#endif
#ifdef SERVER
#if !defined( __RDOS__ )
trp_socklen length;
char buff[128];
#endif
_DBG_NET(("SERVER: Calling into RemoteLink\r\n"));
#if defined(__NT__) || defined(__WINDOWS__)
{
WSADATA data;
if( WSAStartup( 0x101, &data ) != 0 ) {
return( TRP_ERR_unable_to_initialize_TCPIP );
}
}
#endif
port = 0;
#ifdef __RDOS__
while( isdigit( *parms ) ) {
port = port * 10 + (*parms - '0');
++parms;
}
if( port == 0 )
port = DEFAULT_PORT;
wait_handle = RdosCreateWait( );
listen_handle = RdosCreateTcpListen( port, 1, SOCKET_BUFFER );
RdosAddWaitForTcpListen( wait_handle, listen_handle, (int)(&listen_handle) );
#else
if( *parms == '\0' )
parms = "tcplink";
sp = getservbyname( parms, "tcp" );
if( sp != NULL ) {
port = sp->s_port;
} else {
while( isdigit( *parms ) ) {
port = port * 10 + (*parms - '0');
++parms;
}
if( port == 0 )
port = DEFAULT_PORT;
port = htons( port );
}
control_socket = socket(AF_INET, SOCK_STREAM, 0);
if( !IS_VALID_SOCKET( control_socket ) ) {
return( TRP_ERR_unable_to_open_stream_socket );
}
#ifdef GUISERVER
if( *ServParms == '\0' ) {
sprintf( ServParms, "%u", ntohs( port ) );
}
#endif
/* Name socket using wildcards */
socket_address.sin_family = AF_INET;
socket_address.sin_addr.s_addr = INADDR_ANY;
socket_address.sin_port = port;
if( bind( control_socket, (LPSOCKADDR)&socket_address, sizeof( socket_address ) ) ) {
return( TRP_ERR_unable_to_bind_stream_socket );
}
/* Find out assigned port number and print it out */
length = sizeof( socket_address );
if( getsockname( control_socket, (LPSOCKADDR)&socket_address, &length ) ) {
return( TRP_ERR_unable_to_get_socket_name );
}
sprintf( buff, "%s%d", TRP_TCP_socket_number, ntohs( socket_address.sin_port ) );
ServMessage( buff );
_DBG_NET(("TCP: "));
_DBG_NET((buff));
_DBG_NET(("\r\n"));
#ifdef LIST_INTERFACES
// TODO: need rework to POSIX if_nameindex in <net/if.h>
/* Find and print TCP/IP interface addresses, ignore aliases */
{
struct ifi_info *ifi, *ifihead;
struct sockaddr *sa;
ifihead = get_ifi_info( AF_INET, false );
for( ifi = ifihead; ifi != NULL; ifi = ifi->ifi_next ) {
/* Ignore loopback interfaces */
if( ifi->flags & IFI_LOOP )
continue;
if( (sa = ifi->ifi_addr) != NULL ) {
sprintf( buff, "%s%s", TRP_TCP_ip_address,
inet_ntoa( ((struct sockaddr_in *)sa)->sin_addr ) );
ServMessage( buff );
}
}
free_ifi_info( ifihead );
}
#endif
#endif
_DBG_NET(("Start accepting connections\r\n"));
/* Start accepting connections */
#ifndef __RDOS__
listen( control_socket, 5 );
#endif
#else
#ifdef __RDOS__
// Todo: handle connect
#else
const char *sock;
char buff[128];
char *p;
#if defined(__NT__) || defined(__WINDOWS__)
{
WSADATA data;
if( WSAStartup( 0x101, &data ) != 0 ) {
return( TRP_ERR_unable_to_initialize_TCPIP );
}
}
#endif
/* get port number out of name */
p = buff;
for( sock = parms; *sock != '\0'; ++sock ) {
if( *sock == ':' ) {
++sock;
break;
}
*p++ = *sock;
}
*p = '\0';
if( sock[0] == '\0' ) {
sp = getservbyname( "tcplink", "tcp" );
} else {
sp = getservbyname( sock, "tcp" );
}
if( sp != NULL ) {
port = sp->s_port;
} else {
port = 0;
while( isdigit( *sock ) ) {
port = port * 10 + (*sock - '0');
++sock;
}
if( *sock != '\0' ) {
return( TRP_ERR_unable_to_parse_port_number );
}
if( port == 0 )
port = DEFAULT_PORT;
port = htons( port );
}
parms = buff;
/* Setup for socket connect using parms specified by command line. */
socket_address.sin_family = AF_INET;
/* OS/2's TCP/IP gethostbyname doesn't handle numeric addresses */
socket_address.sin_addr.s_addr = inet_addr( parms );
if( socket_address.sin_addr.s_addr == (unsigned long)-1L ) {
struct hostent *hp;
hp = gethostbyname( parms );
if( hp != 0 ) {
memcpy( &socket_address.sin_addr, hp->h_addr, hp->h_length );
} else {
return( TRP_ERR_unknown_host );
}
}
socket_address.sin_port = port;
#endif
#endif
server = server;
return( NULL );
}
/** Drain and close the socket
* @param sd socket to close
* @param l logger
* @return -1: socket to close is invalid
* -1: some kind of error occured (!WIN32)
* SOCKET_ERROR: some kind of error occured (WIN32)
* 0: success
* @remark Does not change errno
*/
int jk_shutdown_socket(jk_sock_t sd, jk_logger_t *l)
{
char dummy[512];
char buf[DUMP_SINFO_BUF_SZ];
char *sb = NULL;
int rc = 0;
size_t rd = 0;
size_t rp = 0;
int save_errno;
int timeout = MS_TO_LINGER;
time_t start = time(NULL);
JK_TRACE_ENTER(l);
if (!IS_VALID_SOCKET(sd)) {
JK_TRACE_EXIT(l);
return -1;
}
save_errno = errno;
if (JK_IS_DEBUG_LEVEL(l)) {
sb = jk_dump_sinfo(sd, buf, sizeof(buf));
jk_log(l, JK_LOG_DEBUG, "About to shutdown socket %d [%s]",
sd, sb);
}
/* Shut down the socket for write, which will send a FIN
* to the peer.
*/
if (shutdown(sd, SHUT_WR)) {
rc = jk_close_socket(sd, l);
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Failed sending SHUT_WR for socket %d [%s]",
sd, sb);
errno = save_errno;
JK_TRACE_EXIT(l);
return rc;
}
do {
rp = 0;
if (jk_is_input_event(sd, timeout, l)) {
/* Do a restartable read on the socket
* draining out all the data currently in the socket buffer.
*/
int num = 0;
do {
num++;
#if defined(WIN32) || (defined(NETWARE) && defined(__NOVELL_LIBC__))
rc = recv(sd, &dummy[0], sizeof(dummy), 0);
if (JK_IS_SOCKET_ERROR(rc))
JK_GET_SOCKET_ERRNO();
#else
rc = read(sd, &dummy[0], sizeof(dummy));
#endif
if (rc > 0)
rp += rc;
} while (JK_IS_SOCKET_ERROR(rc) && (errno == EINTR || errno == EAGAIN) && num < MAX_READ_RETRY);
if (rc < 0) {
/* Read failed.
* Bail out from the loop.
*/
break;
}
}
else {
/* Error or timeout (reason is logged within jk_is_input_event)
* Exit the drain loop
*/
break;
}
rd += rp;
if (rp < sizeof(dummy)) {
if (timeout > MS_TO_LINGER_LAST) {
/* Try one last time with a short timeout
*/
timeout = MS_TO_LINGER_LAST;
continue;
}
/* We have read less then size of buffer
* It's a good chance there will be no more data
* to read.
*/
if ((rc = sononblock(sd))) {
rc = jk_close_socket(sd, l);
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"error setting socket %d [%s] to nonblocking",
sd, sb);
errno = save_errno;
JK_TRACE_EXIT(l);
return rc;
}
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"shutting down the read side of socket %d [%s]",
sd, sb);
shutdown(sd, SHUT_RD);
break;
}
timeout = MS_TO_LINGER;
} while ((rd < MAX_LINGER_BYTES) && (difftime(time(NULL), start) < MAX_SECS_TO_LINGER));
rc = jk_close_socket(sd, l);
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Shutdown socket %d [%s] and read %d lingering bytes in %d sec.",
sd, sb, rd, (int)difftime(time(NULL), start));
errno = save_errno;
JK_TRACE_EXIT(l);
return rc;
}
/** Connect to Tomcat
* @param addr address to connect to
* @param keepalive should we set SO_KEEPALIVE (if !=0)
* @param timeout connect timeout in seconds
* (<=0: no timeout=blocking)
* @param sock_buf size of send and recv buffer
* (<=0: use default)
* @param l logger
* @return JK_INVALID_SOCKET: some kind of error occured
* created socket: success
* @remark Cares about errno
*/
jk_sock_t jk_open_socket(jk_sockaddr_t *addr, jk_sockaddr_t *source,
int keepalive,
int timeout, int connect_timeout,
int sock_buf, jk_logger_t *l)
{
char buf[DUMP_SINFO_BUF_SZ];
jk_sock_t sd;
int set = 1;
int ret = 0;
int flags = 0;
#ifdef SO_LINGER
struct linger li;
#endif
JK_TRACE_ENTER(l);
errno = 0;
#if defined(SOCK_CLOEXEC) && defined(USE_SOCK_CLOEXEC)
flags |= SOCK_CLOEXEC;
#endif
sd = socket(addr->family, SOCK_STREAM | flags, 0);
if (!IS_VALID_SOCKET(sd)) {
JK_GET_SOCKET_ERRNO();
jk_log(l, JK_LOG_ERROR,
"socket() failed (errno=%d)", errno);
JK_TRACE_EXIT(l);
return JK_INVALID_SOCKET;
}
#if defined(FD_CLOEXEC) && !defined(USE_SOCK_CLOEXEC)
if ((flags = fcntl(sd, F_GETFD)) == -1) {
JK_GET_SOCKET_ERRNO();
jk_log(l, JK_LOG_ERROR,
"fcntl() failed (errno=%d)", errno);
jk_close_socket(sd, l);
JK_TRACE_EXIT(l);
return JK_INVALID_SOCKET;
}
flags |= FD_CLOEXEC;
if (fcntl(sd, F_SETFD, flags) == -1) {
JK_GET_SOCKET_ERRNO();
jk_log(l, JK_LOG_ERROR,
"fcntl() failed (errno=%d)", errno);
jk_close_socket(sd, l);
JK_TRACE_EXIT(l);
return JK_INVALID_SOCKET;
}
#endif
/* Disable Nagle algorithm */
if (setsockopt(sd, IPPROTO_TCP, TCP_NODELAY, (SET_TYPE)&set,
sizeof(set))) {
JK_GET_SOCKET_ERRNO();
jk_log(l, JK_LOG_ERROR,
"failed setting TCP_NODELAY (errno=%d)", errno);
jk_close_socket(sd, l);
JK_TRACE_EXIT(l);
return JK_INVALID_SOCKET;
}
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"socket TCP_NODELAY set to On");
if (keepalive) {
#if defined(WIN32) && !defined(NETWARE)
DWORD dw;
struct tcp_keepalive ka = { 0 }, ks = { 0 };
if (timeout)
ka.keepalivetime = timeout * 10000;
else
ka.keepalivetime = 60 * 10000; /* 10 minutes */
ka.keepaliveinterval = 1000;
ka.onoff = 1;
if (WSAIoctl(sd, SIO_KEEPALIVE_VALS, &ka, sizeof(ka),
&ks, sizeof(ks), &dw, NULL, NULL)) {
JK_GET_SOCKET_ERRNO();
jk_log(l, JK_LOG_ERROR,
"failed setting SIO_KEEPALIVE_VALS (errno=%d)", errno);
jk_close_socket(sd, l);
JK_TRACE_EXIT(l);
return JK_INVALID_SOCKET;
}
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"socket SO_KEEPALIVE set to %d seconds",
ka.keepalivetime / 1000);
#else
set = 1;
if (setsockopt(sd, SOL_SOCKET, SO_KEEPALIVE, (SET_TYPE)&set,
sizeof(set))) {
JK_GET_SOCKET_ERRNO();
jk_log(l, JK_LOG_ERROR,
"failed setting SO_KEEPALIVE (errno=%d)", errno);
jk_close_socket(sd, l);
JK_TRACE_EXIT(l);
return JK_INVALID_SOCKET;
}
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"socket SO_KEEPALIVE set to On");
#endif
}
if (sock_buf > 0) {
set = sock_buf;
/* Set socket send buffer size */
if (setsockopt(sd, SOL_SOCKET, SO_SNDBUF, (SET_TYPE)&set,
sizeof(set))) {
JK_GET_SOCKET_ERRNO();
jk_log(l, JK_LOG_ERROR,
"failed setting SO_SNDBUF (errno=%d)", errno);
jk_close_socket(sd, l);
JK_TRACE_EXIT(l);
return JK_INVALID_SOCKET;
}
set = sock_buf;
/* Set socket receive buffer size */
if (setsockopt(sd, SOL_SOCKET, SO_RCVBUF, (SET_TYPE)&set,
sizeof(set))) {
JK_GET_SOCKET_ERRNO();
jk_log(l, JK_LOG_ERROR,
"failed setting SO_RCVBUF (errno=%d)", errno);
jk_close_socket(sd, l);
JK_TRACE_EXIT(l);
return JK_INVALID_SOCKET;
}
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"socket SO_SNDBUF and SO_RCVBUF set to %d",
sock_buf);
}
if (timeout > 0) {
#if defined(WIN32) || (defined(NETWARE) && defined(__NOVELL_LIBC__))
int tmout = timeout * 1000;
setsockopt(sd, SOL_SOCKET, SO_RCVTIMEO,
(const char *) &tmout, sizeof(int));
setsockopt(sd, SOL_SOCKET, SO_SNDTIMEO,
(const char *) &tmout, sizeof(int));
JK_GET_SOCKET_ERRNO();
#elif defined(SO_RCVTIMEO) && defined(USE_SO_RCVTIMEO) && defined(SO_SNDTIMEO) && defined(USE_SO_SNDTIMEO)
struct timeval tv;
tv.tv_sec = timeout;
tv.tv_usec = 0;
setsockopt(sd, SOL_SOCKET, SO_RCVTIMEO,
(const void *) &tv, sizeof(tv));
setsockopt(sd, SOL_SOCKET, SO_SNDTIMEO,
(const void *) &tv, sizeof(tv));
#endif
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"timeout %d set for socket=%d",
timeout, sd);
}
#ifdef SO_NOSIGPIPE
/* The preferred method on Mac OS X (10.2 and later) to prevent SIGPIPEs when
* sending data to a dead peer. Possibly also existing and in use on other BSD
* systems?
*/
set = 1;
if (setsockopt(sd, SOL_SOCKET, SO_NOSIGPIPE, (const char *)&set,
sizeof(int))) {
JK_GET_SOCKET_ERRNO();
jk_log(l, JK_LOG_ERROR,
"failed setting SO_NOSIGPIPE (errno=%d)", errno);
jk_close_socket(sd, l);
JK_TRACE_EXIT(l);
return JK_INVALID_SOCKET;
}
#endif
#ifdef SO_LINGER
/* Make hard closesocket by disabling lingering */
li.l_linger = li.l_onoff = 0;
if (setsockopt(sd, SOL_SOCKET, SO_LINGER, (SET_TYPE)&li,
sizeof(li))) {
JK_GET_SOCKET_ERRNO();
jk_log(l, JK_LOG_ERROR,
"failed setting SO_LINGER (errno=%d)", errno);
jk_close_socket(sd, l);
JK_TRACE_EXIT(l);
return JK_INVALID_SOCKET;
}
#endif
/* Tries to connect to Tomcat (continues trying while error is EINTR) */
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"trying to connect socket %d to %s", sd,
jk_dump_hinfo(addr, buf, sizeof(buf)));
/* Need more infos for BSD 4.4 and Unix 98 defines, for now only
iSeries when Unix98 is required at compile time */
#if (_XOPEN_SOURCE >= 520) && defined(AS400)
((struct sockaddr *)addr)->sa.sin.sa_len = sizeof(struct sockaddr_in);
#endif
ret = nb_connect(sd, addr, source, connect_timeout, l);
#if defined(WIN32) || (defined(NETWARE) && defined(__NOVELL_LIBC__))
if (JK_IS_SOCKET_ERROR(ret)) {
JK_GET_SOCKET_ERRNO();
}
#endif /* WIN32 */
/* Check if we are connected */
if (ret) {
jk_log(l, JK_LOG_INFO,
"connect to %s failed (errno=%d)",
jk_dump_hinfo(addr, buf, sizeof(buf)), errno);
jk_close_socket(sd, l);
sd = JK_INVALID_SOCKET;
}
else {
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG, "socket %d [%s] connected",
sd, jk_dump_sinfo(sd, buf, sizeof(buf)));
}
JK_TRACE_EXIT(l);
return sd;
}
