int net_closesocket (SOCKET sd)
{
#if (INCLUDE_SUPPORT_SOCKETS && INCLUDE_SSL)
PTCPPORT pport;
#endif
#if (INCLUDE_SUPPORT_SOCKETS)
if (!IS_INVALID_SOCKET(sd))
{
#if (INCLUDE_SSL)
if (net_is_secure_socket(sd))
{
pport = (PTCPPORT)api_sock_to_port(sd);
if (!pport)
return (-1);
/* ssl will close the socket */
return (vssl_clssock(sd,pport->ssl));
}
#endif
#if (defined(MT92101))
shutdown(sd, 0);
return(0);
#else
return (closesocket(sd));
#endif
}
#endif /* INCLUDE_SUPPORT_SOCKETS */
return (-1);
}
/*
* hb_deregister_from_master () -
* return: NO_ERROR or ER_FAILED
*
*/
int
hb_deregister_from_master (void)
{
int css_error;
int pid;
if (hb_Conn == NULL || IS_INVALID_SOCKET (hb_Conn->fd))
{
return ER_FAILED;
}
css_error = css_send_heartbeat_request (hb_Conn, SERVER_DEREGISTER_HA_PROCESS);
if (css_error != NO_ERRORS)
{
return ER_FAILED;
}
pid = htonl (getpid ());
css_error = css_send_heartbeat_data (hb_Conn, (char *) &pid, sizeof (pid));
if (css_error != NO_ERRORS)
{
return ER_FAILED;
}
return NO_ERROR;
}
int
ts_check_already_connected (nvplist *cli_response, int max_index,
int current_index, T_CLIENT_INFO *client_info)
{
int index = 0;
for (index = 0; index <= max_index; index++)
{
if (IS_INVALID_SOCKET (client_info[index].sock_fd)
|| (index == current_index))
{
continue;
}
if (!strcmp (client_info[current_index].user_id, client_info[index].user_id))
{
char message[1024];
sprintf (message,
"User %s was already connected from another client(%s)",
client_info[index].user_id, client_info[index].ip_address);
nv_update_val (cli_response, "status", "failure");
nv_update_val (cli_response, "note", message);
return index;
}
}
return -1;
}
/*
* css_accept() - accept of a request from a client
* return:
* sockfd(in):
*/
static SOCKET
css_accept (SOCKET sockfd)
{
struct sockaddr_in tcp_cli_addr;
SOCKET newsockfd;
int clilen, error;
while (true)
{
clilen = sizeof (tcp_cli_addr);
newsockfd = accept (sockfd, (struct sockaddr *) &tcp_cli_addr, &clilen);
if (IS_INVALID_SOCKET (newsockfd))
{
error = WSAGetLastError ();
if (error == WSAEINTR)
{
continue;
}
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ERR_CSS_WINTCP_ACCEPT_ERROR, 1, error);
return INVALID_SOCKET;
}
break;
}
return newsockfd;
}
void Socket::hangup(void)
{
if (!IS_INVALID_SOCKET(fd))
{
close(fd);
fd = INVALID_SOCKET;
}
}
/*
* css_shutdown_socket() -
* return:
* fd(in):
*/
void
css_shutdown_socket (SOCKET fd)
{
if (!IS_INVALID_SOCKET (fd))
{
closesocket (fd);
}
}
void RemoteDisco( void )
{
_DBG_NET(("RemoteDisco\r\n"));
if( !IS_INVALID_SOCKET( data_socket ) ) {
soclose( data_socket );
data_socket = INVALID_SOCKET;
}
}
/*
* css_close_server_connection_socket() - Close the socket that was opened by
* the server for incoming client
* requests
* return: void
*/
void
css_close_server_connection_socket (void)
{
if (!IS_INVALID_SOCKET (css_Server_connection_socket))
{
closesocket (css_Server_connection_socket);
css_Server_connection_socket = INVALID_SOCKET;
}
}
/*
* css_tcp_client_open() -
* return:
* hostname(in):
* port(in):
*/
SOCKET
css_tcp_client_open (const char *host_name, int port)
{
SOCKET fd;
fd = css_tcp_client_open_with_retry (host_name, port, true);
if (IS_INVALID_SOCKET (fd))
{
er_set_with_oserror (ER_ERROR_SEVERITY, ARG_FILE_LINE, ERR_CSS_TCP_CANNOT_CONNECT_TO_MASTER, 1, host_name);
}
return fd;
}
/*
* css_receive_heartbeat_data () -
* return:
*
* conn(in):
* data(in):
* size(in):
*/
int
css_receive_heartbeat_data (CSS_CONN_ENTRY * conn, char *data, int size)
{
int nbytes;
if (conn && !IS_INVALID_SOCKET (conn->fd))
{
nbytes = css_readn (conn->fd, data, size, -1);
if (nbytes == size)
{
return NO_ERRORS;
}
return ERROR_ON_READ;
}
return CONNECTION_CLOSED;
}
/*
* css_send_heartbeat_data () -
* return:
*
* conn(in):
* data(in):
* size(in):
*/
int
css_send_heartbeat_data (CSS_CONN_ENTRY * conn, const char *data, int size)
{
int nbytes;
if (conn && !IS_INVALID_SOCKET (conn->fd))
{
nbytes = send (conn->fd, (char *) data, size, 0);
if (nbytes == size)
{
return (NO_ERRORS);
}
return (ERROR_ON_WRITE);
}
return CONNECTION_CLOSED;
}
// Write a formatted string to a socket.
//
static int DCL_CDECL mod_email_sock_printf(SOCKET sock, const UTF8 *format, ...)
{
va_list vargs;
UTF8 mybuf[2*LBUF_SIZE];
if (IS_INVALID_SOCKET(sock))
{
return 0;
}
va_start(vargs, format);
mux_vsnprintf(mybuf, sizeof(mybuf), format, vargs);
va_end(vargs);
return SOCKET_WRITE(sock, (char *)&mybuf[0], strlen((char *)mybuf), 0);
}
// Write a formatted string to a socket.
//
static int DCL_CDECL mod_email_sock_printf(SOCKET sock, const char *format, ...)
{
va_list vargs;
char mybuf[2*LBUF_SIZE];
if (IS_INVALID_SOCKET(sock))
{
return 0;
}
va_start(vargs, format);
mux_vsnprintf(mybuf, sizeof(mybuf), format, vargs);
va_end(vargs);
return SOCKET_WRITE(sock, &mybuf[0], strlen(mybuf), 0);
// return sock.writeToSocket(&mybuf[0], strlen(mybuf));
}
int
Server::Start()
{
// Open up a server socket
mSocket = SocketManager::instance()->openSocket(AF_INET, SOCK_STREAM);
if (IS_INVALID_SOCKET(mSocket)) {
Trace::instance()->trace(TRACE_LEVEL_ERROR, __FILE__, __LINE__, "Could not open socket");
return 1;
}
// Set socket reusable and non-blocking
int res = SocketManager::instance()->setupSocket(mSocket, true, true);
if (res < 0) {
Trace::instance()->trace(TRACE_LEVEL_ERROR, __FILE__, __LINE__, "Could not setup socket");
goto error_cleanup;
}
// Bind to address and port
res = bind(mSocket, mAddress->getSockAddr(), mAddress->getAddrLength());
if (res != 0) {
Trace::instance()->trace(TRACE_LEVEL_ERROR, __FILE__, __LINE__, "Could not bind socket (res %d errno %d)",
res, errno);
goto error_cleanup;
}
// Listen
res = listen(mSocket, 10);
if (res != 0) {
Trace::instance()->trace(TRACE_LEVEL_ERROR, __FILE__, __LINE__, "Could not listen on socket");
goto error_cleanup;
}
Trace::instance()->trace(TRACE_LEVEL_TRACE, __FILE__, __LINE__, "Server socket %d is up!", mSocket);
return 0;
error_cleanup:
SocketManager::instance()->closeSocket(mSocket);
mSocket = INVALID_SOCKET;
return 1;
}
/*
* hb_process_to_master () -
* return: NO_ERROR or ER_FAILED
*
* argv(in):
*/
int
hb_process_master_request (void)
{
int error;
int r, status = 0;
struct pollfd po[1] = { {0, 0, 0} };
if (NULL == hb_Conn)
{
er_log_debug (ARG_FILE_LINE, "hb_Conn did not allocated yet. \n");
return (ER_FAILED);
}
while (false == hb_Proc_shutdown)
{
po[0].fd = hb_Conn->fd;
po[0].events = POLLIN;
r = poll (po, 1, (prm_get_integer_value (PRM_ID_TCP_CONNECTION_TIMEOUT) * 1000));
switch (r)
{
case 0:
break;
case -1:
if (!IS_INVALID_SOCKET (hb_Conn->fd)
#if defined(WINDOWS)
&& ioctlsocket (hb_Conn->fd, FIONREAD, (u_long *) & status) == SOCKET_ERROR
#else /* WINDOWS */
&& fcntl (hb_Conn->fd, F_GETFL, status) < 0
#endif /* WINDOWS */
)
hb_Proc_shutdown = true;
break;
default:
error = hb_process_master_request_info (hb_Conn);
if (NO_ERROR != error)
{
hb_Proc_shutdown = true;
}
break;
}
}
return (ER_FAILED);
}
/*
* css_send_heartbeat_request () -
* return:
*
* conn(in):
* command(in):
*/
int
css_send_heartbeat_request (CSS_CONN_ENTRY * conn, int command)
{
int nbytes;
int request;
request = htonl (command);
if (conn && !IS_INVALID_SOCKET (conn->fd))
{
nbytes = send (conn->fd, (char *) &request, sizeof (int), 0);
if (nbytes == sizeof (int))
{
return (NO_ERRORS);
}
return (ERROR_ON_WRITE);
}
return CONNECTION_CLOSED;
}
/*
* css_receive_heartbeat_request () -
* return:
*
* conn(in):
* command(in):
*/
int
css_receive_heartbeat_request (CSS_CONN_ENTRY * conn, int *command)
{
int nbytes;
int request;
int size = sizeof (request);
if (conn && !IS_INVALID_SOCKET (conn->fd))
{
nbytes = css_readn (conn->fd, (char *) &request, size, -1);
if (nbytes == size)
{
*command = ntohl (request);
return NO_ERRORS;
}
return ERROR_ON_READ;
}
return CONNECTION_CLOSED;
}
int
hm_con_handle_free (T_CON_HANDLE * con_handle)
{
if (con_handle == NULL)
{
return CCI_ER_CON_HANDLE;
}
con_handle_table[con_handle->id - 1] = NULL;
if (!IS_INVALID_SOCKET (con_handle->sock_fd))
{
CLOSE_SOCKET (con_handle->sock_fd);
con_handle->sock_fd = INVALID_SOCKET;
}
hm_req_handle_free_all (con_handle);
con_handle_content_free (con_handle);
FREE_MEM (con_handle);
return CCI_ER_NO_ERROR;
}
/*
* hb_register_to_master () -
* return: NO_ERROR or ER_FAILED
*
* conn(in):
* type(in):
*/
int
hb_register_to_master (CSS_CONN_ENTRY * conn, int type)
{
int error;
HBP_PROC_REGISTER *hbp_register = NULL;
if (NULL == conn)
{
er_log_debug (ARG_FILE_LINE, "invalid conn. (conn:NULL).\n");
return (ER_FAILED);
}
hbp_register = hb_make_set_hbp_register (type);
if (NULL == hbp_register)
{
er_log_debug (ARG_FILE_LINE, "hbp_register failed. \n");
return (ER_FAILED);
}
if (!IS_INVALID_SOCKET (conn->fd))
{
error = css_send_heartbeat_request (conn, SERVER_REGISTER_HA_PROCESS);
if (error != NO_ERRORS)
{
goto error_return;
}
error = css_send_heartbeat_data (conn, (const char *) hbp_register, sizeof (*hbp_register));
if (error != NO_ERRORS)
{
goto error_return;
}
}
free_and_init (hbp_register);
return (NO_ERROR);
error_return:
free_and_init (hbp_register);
return (ER_FAILED);
}
SOCKET
net_connect_client (SOCKET srv_sock_fd)
{
#if defined(WINDOWS) || defined(SOLARIS)
int clt_sock_addr_len;
#elif defined(UNIXWARE7)
size_t clt_sock_addr_len;
#else /* UNIXWARE7 */
socklen_t clt_sock_addr_len;
#endif /* UNIXWARE7 */
SOCKET clt_sock_fd;
struct sockaddr_in clt_sock_addr;
clt_sock_addr_len = sizeof (clt_sock_addr);
clt_sock_fd = accept (srv_sock_fd, (struct sockaddr *) &clt_sock_addr, &clt_sock_addr_len);
if (IS_INVALID_SOCKET (clt_sock_fd))
return INVALID_SOCKET;
net_error_flag = 0;
return clt_sock_fd;
}
void
hm_check_rc_time (T_CON_HANDLE * con_handle)
{
time_t cur_time, failure_time;
if (IS_INVALID_SOCKET (con_handle->sock_fd))
{
return;
}
if (con_handle->alter_host_id > 0 && con_handle->rc_time > 0)
{
cur_time = time (NULL);
failure_time = con_handle->last_failure_time;
if (failure_time > 0 && con_handle->rc_time < (cur_time - failure_time))
{
if (hm_is_host_reachable (con_handle, 0))
{
con_handle->force_failback = true;
con_handle->last_failure_time = 0;
}
}
}
}
/*
** Open a port
*/
static ErlDrvData trace_ip_start(ErlDrvPort port, char *buff)
{
TraceIpData *ret;
int portno;
int quesiz;
int flags;
SOCKET s;
struct sockaddr_in sin;
int reuse = 1;
#ifdef HARDDEBUG
fprintf(stderr,"trace_ip_drv/trace_ip_start (%s)\r\n", buff);
#endif
if (sscanf(buff,"trace_ip_drv %d %d %d",&portno, &quesiz, &flags) != 3)
return ERL_DRV_ERROR_GENERAL;
if (flags > 3 || flags < 0 || portno < 0 || quesiz < 0)
return ERL_DRV_ERROR_GENERAL;
if (lookup_data_by_port(portno) != NULL)
return ERL_DRV_ERROR_GENERAL;
if (IS_INVALID_SOCKET(s = socket(AF_INET, SOCK_STREAM, 0)))
return ERL_DRV_ERROR_GENERAL;
if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR,
(char *) &reuse, sizeof(reuse)) < 0) {
closesocket(s);
return ERL_DRV_ERROR_GENERAL;
}
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = INADDR_ANY;
sin.sin_port = htons((short) portno);
if (bind(s, (struct sockaddr *)&sin, sizeof(sin)) != 0) {
closesocket(s);
return ERL_DRV_ERROR_GENERAL;
}
if (portno == 0) {
#ifdef HAVE_SOCKLEN_T
socklen_t sinlen = sizeof(sin);
#else
int sinlen = (int) sizeof(sin);
#endif
if (getsockname(s, (struct sockaddr *)&sin, &sinlen) != 0) {
closesocket(s);
return ERL_DRV_ERROR_GENERAL;
} else {
portno = ntohs(sin.sin_port);
}
}
if (listen(s, 1)) { /* No significant backlog needed */
closesocket(s);
return ERL_DRV_ERROR_GENERAL;
}
if (set_nonblocking(s) != 0){
closesocket(s);
return ERL_DRV_ERROR_GENERAL;
}
/* OK, the socket is created, lets build the structure. */
/* Deliberately one more pointer than the quesize specified... */
ret = my_alloc(sizeof(TraceIpData) +
quesiz * sizeof(TraceIpMessage *));
ret->flags = flags | FLAG_LISTEN_PORT;
ret->listen_portno = portno;
ret->listenfd = s;
ret->fd = INVALID_SOCKET;
ret->port = port;
ret->next = first_data;
ret->quesiz = quesiz+1;
ret->questart = ret->questop = 0;
memset(ret->que, 0, ret->quesiz);
first_data = ret;
#ifdef __WIN32__
ret->listen_event_mask = 0;
ret->listen_event = 0;
ret->event_mask = 0;
ret->event = 0;
#endif
my_driver_select(ret, s, FLAG_READ, SELECT_ON);
set_port_control_flags(port, PORT_CONTROL_FLAG_BINARY);
return (ErlDrvData) ret;
}
char *RemoteLink( char *name, bool server )
{
unsigned short port;
#ifndef __RDOS__
struct servent *sp;
#endif
#ifdef SERVER
#ifndef __RDOS__
trp_socklen length;
#if !defined(__LINUX__) /* FIXME */
struct ifi_info *ifi, *ifihead;
struct sockaddr *sa;
#endif
char buff2[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( *name ) ) {
port = port * 10 + (*name - '0');
++name;
}
if( port == 0 )
port = DEFAULT_PORT;
wait_handle = RdosCreateWait( );
listen_handle = RdosCreateTcpListen( port, 1, SOCKET_BUFFER );
RdosAddWaitForTcpListen( wait_handle, listen_handle, &listen_handle );
#else
if( name == NULL || name[0] == '\0' )
name = "tcplink";
sp = getservbyname( name, "tcp" );
if( sp != NULL ) {
port = sp->s_port;
} else {
while( isdigit( *name ) ) {
port = port * 10 + (*name - '0');
++name;
}
if( port == 0 )
port = DEFAULT_PORT;
port = htons( port );
}
control_socket = socket(AF_INET, SOCK_STREAM, 0);
if( IS_INVALID_SOCKET( control_socket ) ) {
return( TRP_ERR_unable_to_open_stream_socket );
}
/* 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, (struct sockaddr TRAPFAR *)&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, (struct sockaddr TRAPFAR *)&socket_address, &length ) ) {
return( TRP_ERR_unable_to_get_socket_name );
}
sprintf( buff2, "%s%d", TRP_TCP_socket_number, ntohs( socket_address.sin_port ) );
ServMessage( buff2 );
_DBG_NET(("TCP: "));
_DBG_NET((buff2));
_DBG_NET(("\r\n"));
#if !defined(__LINUX__) /* FIXME */
/* Find and print TCP/IP interface addresses, ignore aliases */
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( buff2, "%s%s", TRP_TCP_ip_address,
inet_ntoa( ((struct sockaddr_in*)sa)->sin_addr ) );
ServMessage( buff2 );
}
}
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
char *sock;
#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 */
sock = name;
while( *sock != '\0' ) {
if( *sock == ':' ) {
*sock = '\0';
++sock;
break;
}
++sock;
}
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 );
}
/* Setup for socket connect using name 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( name );
if( socket_address.sin_addr.s_addr == (unsigned long)-1L ) {
struct hostent *hp;
hp = gethostbyname( name );
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 );
}
/*
* cas_network.c -
*/
#ident "$Id$"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <errno.h>
#include <assert.h>
#if defined(WINDOWS)
#include <winsock2.h>
#include <windows.h>
#include <io.h>
#else /* WINDOWS */
#include <sys/time.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/un.h>
#include <poll.h>
#endif /* WINDOWS */
#include "porting.h"
#include "cas_common.h"
#include "cas_network.h"
#include "cas.h"
#include "broker_env_def.h"
#include "cas_execute.h"
#include "error_code.h"
#include "broker_util.h"
#if defined(WINDOWS)
#include "broker_wsa_init.h"
#endif /* WINDOWS */
#define SELECT_MASK fd_set
static int write_buffer (SOCKET sock_fd, const char *buf, int size);
static int read_buffer (SOCKET sock_fd, char *buf, int size);
static void set_net_timeout_flag (void);
static void unset_net_timeout_flag (void);
#if defined(WINDOWS)
static int get_host_ip (unsigned char *ip_addr);
#endif /* WINDOWS */
static bool net_timeout_flag = false;
static char net_error_flag;
static int net_timeout = NET_DEFAULT_TIMEOUT;
SOCKET
#if defined(WINDOWS)
net_init_env (int *new_port)
#else /* WINDOWS */
net_init_env (char *port_name)
#endif /* WINDOWS */
{
int one = 1;
SOCKET sock_fd;
int sock_addr_len;
#if defined(WINDOWS)
struct sockaddr_in sock_addr;
int n;
#else /* WINDOWS */
struct sockaddr_un sock_addr;
#endif /* WINDOWS */
#if defined(WINDOWS)
/* WSA startup */
if (wsa_initialize ())
{
return INVALID_SOCKET;
}
#endif /* WINDOWS */
/* get a Unix stream socket */
#if defined(WINDOWS)
sock_fd = socket (AF_INET, SOCK_STREAM, 0);
#else /* WINDOWS */
sock_fd = socket (AF_UNIX, SOCK_STREAM, 0);
#endif /* WINDOWS */
if (IS_INVALID_SOCKET (sock_fd))
{
return INVALID_SOCKET;
}
if ((setsockopt (sock_fd, SOL_SOCKET, SO_REUSEADDR, (char *) &one, sizeof (one))) < 0)
{
CLOSE_SOCKET (sock_fd);
return INVALID_SOCKET;
}
#if defined(WINDOWS)
memset (&sock_addr, 0, sizeof (struct sockaddr_in));
sock_addr.sin_family = AF_INET;
sock_addr.sin_port = htons ((unsigned short) (*new_port));
sock_addr_len = sizeof (struct sockaddr_in);
n = INADDR_ANY;
memcpy (&sock_addr.sin_addr, &n, sizeof (int));
#else /* WINDOWS */
memset (&sock_addr, 0, sizeof (struct sockaddr_un));
sock_addr.sun_family = AF_UNIX;
snprintf (sock_addr.sun_path, sizeof (sock_addr.sun_path), "%s", port_name);
sock_addr_len = strlen (sock_addr.sun_path) + sizeof (sock_addr.sun_family) + 1;
#endif /* WINDOWS */
if (bind (sock_fd, (struct sockaddr *) &sock_addr, sock_addr_len) < 0)
{
CLOSE_SOCKET (sock_fd);
return INVALID_SOCKET;
}
#if defined(WINDOWS)
if (getsockname (sock_fd, (struct sockaddr *) &sock_addr, &sock_addr_len) < 0)
{
CLOSE_SOCKET (sock_fd);
return INVALID_SOCKET;
}
*new_port = ntohs (sock_addr.sin_port);
#endif /* WINDOWS */
if (listen (sock_fd, 3) < 0)
{
CLOSE_SOCKET (sock_fd);
return INVALID_SOCKET;
}
return (sock_fd);
}
static int
write_buffer (SOCKET sock_fd, const char *buf, int size)
{
int write_len = -1;
#ifdef ASYNC_MODE
struct pollfd po[1] = { {0, 0, 0} };
int timeout, n;
timeout = net_timeout < 0 ? -1 : net_timeout * 1000;
#endif /* ASYNC_MODE */
if (net_error_flag || IS_INVALID_SOCKET (sock_fd))
{
return -1;
}
#ifdef ASYNC_MODE
po[0].fd = sock_fd;
po[0].events = POLLOUT;
retry_poll:
n = poll (po, 1, timeout);
if (n < 0)
{
if (errno == EINTR)
{
goto retry_poll;
}
else
{
net_error_flag = 1;
return -1;
}
}
else if (n == 0)
{
/* TIMEOUT */
net_error_flag = 1;
return -1;
}
else
{
if (po[0].revents & POLLERR || po[0].revents & POLLHUP)
{
write_len = -1;
}
else if (po[0].revents & POLLOUT)
{
#endif /* ASYNC_MODE */
write_len = WRITE_TO_SOCKET (sock_fd, buf, size);
#if defined(ASYNC_MODE)
}
}
#endif /* ASYNC_MODE */
if (write_len <= 0)
{
net_error_flag = 1;
}
return write_len;
}
static int
read_buffer (SOCKET sock_fd, char *buf, int size)
{
int read_len = -1;
#if defined(ASYNC_MODE)
struct pollfd po[2] = { {0, 0, 0}, {0, 0, 0} };
int timeout, po_size, n;
#endif /* ASYNC_MODE */
unset_net_timeout_flag ();
if (net_error_flag)
{
return -1;
}
#if defined(ASYNC_MODE)
timeout = net_timeout < 0 ? -1 : net_timeout * 1000;
po[0].fd = sock_fd;
po[0].events = POLLIN;
po_size = 1;
if (cas_shard_flag == OFF)
{
if (!IS_INVALID_SOCKET (new_req_sock_fd))
{
po[1].fd = new_req_sock_fd;
po[1].events = POLLIN;
po_size = 2;
}
}
retry_poll:
n = poll (po, po_size, timeout);
if (n < 0)
{
if (errno == EINTR)
{
goto retry_poll;
}
else
{
net_error_flag = 1;
return -1;
}
}
else if (n == 0)
{
/* TIMEOUT */
set_net_timeout_flag ();
return -1;
}
else
{
if (cas_shard_flag == OFF && !IS_INVALID_SOCKET (new_req_sock_fd) && (po[1].revents & POLLIN))
{
/* CHANGE CLIENT */
return -1;
}
if (po[0].revents & POLLERR || po[0].revents & POLLHUP)
{
read_len = -1;
}
else if (po[0].revents & POLLIN)
{
#endif /* ASYNC_MODE */
/* RECEIVE NEW REQUEST */
read_len = READ_FROM_SOCKET (sock_fd, buf, size);
#if defined(ASYNC_MODE)
}
}
#endif /* ASYNC_MODE */
if (read_len <= 0)
{
net_error_flag = 1;
}
return read_len;
}
/* get a Unix stream socket */
#if defined(WINDOWS)
sock_fd = socket (AF_INET, SOCK_STREAM, 0);
#else /* WINDOWS */
sock_fd = socket (AF_UNIX, SOCK_STREAM, 0);
#endif /* WINDOWS */
if (IS_INVALID_SOCKET (sock_fd))
{
return INVALID_SOCKET;
}
if ((setsockopt (sock_fd, SOL_SOCKET, SO_REUSEADDR, (char *) &one, sizeof (one))) < 0)
{
CLOSE_SOCKET (sock_fd);
return INVALID_SOCKET;
}
#if defined(WINDOWS)
memset (&sock_addr, 0, sizeof (struct sockaddr_in));
sock_addr.sin_family = AF_INET;
sock_addr.sin_port = htons ((unsigned short) (*new_port));
sock_addr_len = sizeof (struct sockaddr_in);
n = INADDR_ANY;
memcpy (&sock_addr.sin_addr, &n, sizeof (int));
#else /* WINDOWS */
memset (&sock_addr, 0, sizeof (struct sockaddr_un));
sock_addr.sun_family = AF_UNIX;
snprintf (sock_addr.sun_path, sizeof (sock_addr.sun_path), "%s", port_name);
sock_addr_len = strlen (sock_addr.sun_path) + sizeof (sock_addr.sun_family) + 1;
#endif /* WINDOWS */
if (bind (sock_fd, (struct sockaddr *) &sock_addr, sock_addr_len) < 0)
{
CLOSE_SOCKET (sock_fd);
return INVALID_SOCKET;
}
#if defined(WINDOWS)
if (getsockname (sock_fd, (struct sockaddr *) &sock_addr, &sock_addr_len) < 0)
{
CLOSE_SOCKET (sock_fd);
return INVALID_SOCKET;
}
*new_port = ntohs (sock_addr.sin_port);
#endif /* WINDOWS */
if (listen (sock_fd, 3) < 0)
{
CLOSE_SOCKET (sock_fd);
return INVALID_SOCKET;
}
return (sock_fd);
}
#ifndef LIBCAS_FOR_JSP
#if defined(WINDOWS)
SOCKET
net_connect_proxy (int proxy_id)
#else /* WINDOWS */
SOCKET
net_connect_proxy (void)
#endif /* !WINDOWS */
{
int fd, len;
#if defined(WINDOWS)
char *broker_port;
int port = 0;
int one = 1;
unsigned char ip_addr[4];
struct sockaddr_in shard_sock_addr;
/* WSA startup */
if (wsa_initialize ())
{
return (INVALID_SOCKET);
}
if (get_host_ip (ip_addr) < 0)
{
return (INVALID_SOCKET);
}
fd = socket (AF_INET, SOCK_STREAM, 0);
if (IS_INVALID_SOCKET (fd))
{
return (INVALID_SOCKET);
}
if ((setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, (char *) &one, sizeof (one))) < 0)
{
return (INVALID_SOCKET);
}
if ((broker_port = getenv (PORT_NUMBER_ENV_STR)) == NULL)
{
return (INVALID_SOCKET);
}
port = atoi (broker_port) + 2;
port = proxy_id * 2 + port;
SHARD_ERR ("<CAS> connect to socket:[%d].\n", port);
memset (&shard_sock_addr, 0, sizeof (struct sockaddr_in));
shard_sock_addr.sin_family = AF_INET;
shard_sock_addr.sin_port = htons ((unsigned short) port);
len = sizeof (struct sockaddr_in);
memcpy (&shard_sock_addr.sin_addr, ip_addr, 4);
#else /* WINDOWS */
struct sockaddr_un shard_sock_addr;
char port_name[BROKER_PATH_MAX];
ut_get_proxy_port_name (port_name, shm_appl->broker_name, as_info->proxy_id, BROKER_PATH_MAX);
if (port_name == NULL)
{
return (INVALID_SOCKET);
}
/* FOR DEBUG */
SHARD_ERR ("<CAS> connect to unixdoamin:[%s].\n", port_name);
if ((fd = socket (AF_UNIX, SOCK_STREAM, 0)) < 0)
return (INVALID_SOCKET);
memset (&shard_sock_addr, 0, sizeof (shard_sock_addr));
shard_sock_addr.sun_family = AF_UNIX;
strncpy (shard_sock_addr.sun_path, port_name, sizeof (shard_sock_addr.sun_path) - 1);
#ifdef _SOCKADDR_LEN /* 4.3BSD Reno and later */
len = sizeof (shard_sock_addr.sun_len) + sizeof (shard_sock_addr.sun_family) + strlen (shard_sock_addr.sun_path) + 1;
shard_sock_addr.sun_len = len;
#else /* vanilla 4.3BSD */
len = strlen (shard_sock_addr.sun_path) + sizeof (shard_sock_addr.sun_family) + 1;
#endif
#endif /* !WINDOWS */
if (connect (fd, (struct sockaddr *) &shard_sock_addr, len) < 0)
{
CLOSE_SOCKET (fd);
return (INVALID_SOCKET);
}
net_error_flag = 0;
return (fd);
}
virtual bool isClosed() const
{
return IS_INVALID_SOCKET(fd);
}
// Read a line of input from the socket.
//
static int mod_email_sock_readline(SOCKET sock, UTF8 *buffer, int maxlen)
{
buffer[0] = '\0';
if (IS_INVALID_SOCKET(sock))
{
return 0;
}
fd_set read_fds;
FD_ZERO(&read_fds);
FD_SET(sock, &read_fds);
// Wait up to 1 second.
//
struct timeval tv;
tv.tv_sec = 1;
tv.tv_usec = 0;
// Check for data before giving up.
//
if (IS_SOCKET_ERROR(select(static_cast<int>(sock+1), &read_fds, NULL, NULL, &tv)))
{
return 0;
}
if (!FD_ISSET(sock, &read_fds))
{
return 0;
}
bool done = false;
bool possible_close = false;
int pos = 0;
while ( !done
&& pos < maxlen)
{
UTF8 getme[2];
int numread = SOCKET_READ(sock, (char *)&getme[0], 1, 0);
if ( IS_SOCKET_ERROR(numread)
|| 0 == numread)
{
if (possible_close)
{
done = true;
}
else
{
FD_ZERO(&read_fds);
FD_SET(sock, &read_fds);
// Wait up to 1 second.
//
tv.tv_sec = 1;
tv.tv_usec = 0;
// Check for data before giving up.
//
if (IS_SOCKET_ERROR(select(static_cast<int>(sock+1), &read_fds, NULL, NULL, &tv)))
{
done = true;
}
if (FD_ISSET(sock, &read_fds))
{
possible_close = true;
}
}
}
else
{
possible_close = false;
if (getme[0] != '\n')
{
buffer[pos++] = getme[0];
}
else
{
done = true;
}
}
}
buffer[pos] = '\0';
return pos;
}
/*
** We have something to read from a file descriptor
*/
static void trace_ip_ready_input(ErlDrvData handle, ErlDrvEvent fd)
{
TraceIpData *data = (TraceIpData *) handle;
int client;
if (!(data->flags & FLAG_LISTEN_PORT) && event2sock(fd) == data->listenfd) {
/*
** Someone tries to connect to already connected port,
** just accept and close.
*/
if (!IS_INVALID_SOCKET((client = my_accept(data->listenfd)))) {
closesocket(client);
}
return;
}
if (event2sock(fd) == data->listenfd) {
/*
** Maybe accept, we are a listen port...
*/
if (!IS_INVALID_SOCKET((client = my_accept(data->listenfd)))) {
data->fd = client;
set_nonblocking(client);
if (data->que[data->questart] != NULL) {
my_driver_select(data, data->fd, FLAG_WRITE | FLAG_READ, SELECT_ON);
} else {
my_driver_select(data, data->fd, FLAG_READ, SELECT_ON);
}
data->flags &= ~(FLAG_LISTEN_PORT);
}
return;
}
/*
* It is a probably EOF because the other end closed the socket,
* but better make sure.
*/
if ((SOCKET)(long)fd == data->fd) {
#ifdef __WIN32__
close_client(data);
#else
int res;
char sbuf[128];
if ((res = read(data->fd, sbuf, sizeof sbuf)) == 0) {
close_client(data);
}
/*
* Something else. Just ignore it.
*
* When /dev/poll is used on Solaris, this callback can
* be called even if there is nothing to read. An attempt
* to read will result in an EAGAIN error.
*/
#ifdef DEBUG
if (res < 0) {
fprintf(stderr, "Read on fd %d failed with errno=%d\r\n",
data->fd, errno);
}
#endif
#endif
return;
}
ASSERT(0);
}
