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; }