int create_server(int port, char* ip)
{
int s_fd = -1;
struct sockaddr_in server;
memset(&server, 0, sizeof(struct sockaddr_in));
s_fd = os_socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK, 0);
if (s_fd < 0)
{
//perror("ERROR: SOCKET SERVER");
return -1;
}
server.sin_family = AF_INET;
server.sin_port = htons(5557);
server.sin_addr.s_addr = htonl(INADDR_ANY);
if (os_bind(s_fd, (struct sockaddr*) &server, sizeof(server)) < 0)
{
//perror("ERROR: BIND SERVER");
os_close(s_fd);
return -1;
}
return s_fd;
}
ut_setup()
{
int len;
struct in_addr addr;
int reuse;
UT_ASSERT(!os_net_init());
/* create sockets */
server_sock = os_socket(AF_INET, SOCK_STREAM, 0);
UT_ASSERT(server_sock >= 0);
reuse = 1;
UT_ASSERT(os_setsockopt(server_sock, SOL_SOCKET, SO_REUSEADDR,
&reuse, sizeof(reuse)) >= 0);
client_sock = os_socket(AF_INET, SOCK_STREAM, 0);
UT_ASSERT(client_sock >= 0);
/* fill in server information */
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
server_addr.sin_port = htons(DATA_PORT);
/* bind sockets */
UT_ASSERT(os_bind(server_sock, (struct sockaddr *)&server_addr,
sizeof(server_addr)) >= 0);
UT_ASSERT(os_listen(server_sock, BACKLOG) >= 0);
/* connect to server */
os_inet_aton("127.0.0.1", &addr);
memset(&client_addr, 0, sizeof(client_addr));
client_addr.sin_family = AF_INET;
client_addr.sin_addr.s_addr = addr.s_addr;
client_addr.sin_port = htons(DATA_PORT);
if (os_connect(client_sock, (struct sockaddr *)&client_addr, sizeof(client_addr)) < 0)
UT_FAIL();
len = sizeof(struct sockaddr_in);
accept_sock = os_accept(server_sock, (struct sockaddr *)&server_addr, &len);
UT_ASSERT(accept_sock >= 0);
}
TI_BOOL loggerConn_init (THandle loggerConn,
ELoggerConnMedia mediaType, /*currently unused */
TLoggerConnParams* mediaParams
)
{
PLOG_CONN_DATA LogConn = (PLOG_CONN_DATA) loggerConn;
TI_BOOL rc;
rc = os_socket(&LogConn->listen_sock);
if(!rc) {
return(FALSE);
}
LogConn->data_sock = NULL;
rc = os_bind(LogConn->listen_sock, mediaParams->port_num);
if(!rc) {
return(FALSE);
}
return TRUE;
}
/** \brief Return a descritor on a socket that allow us to wait GUI/CLI Request
*
* \param[in] port: The IP port to wait on
* \return Return a descritor on a socket if > 0 or a negative error code
*/
static int
listen_socket_port(int port)
{
int sd;
struct sockaddr_in sin;
int autorisation;
int retval;
/* get an internet domain socket */
if ((sd = os_socket (AF_INET, SOCK_STREAM, 0)) < 0)
return sd;
/* Change socket options to be able to restart the daemon right
* after it has been stopped -- otherwise, bind() would block for
* 60 secs because of TCP */
autorisation = 1;
os_setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, &autorisation, sizeof(int));
/* complete the socket structure */
memset(&sin, 0, sizeof (sin));
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = INADDR_ANY;
sin.sin_port = htons (port);
/* bind the socket to the port number */
retval = os_bind(sd, (struct sockaddr *) &sin, sizeof (sin));
if (retval < 0)
return retval;
/* show that we are willing to listen */
retval = os_listen (sd, 5);
if (retval < 0)
return retval;
return sd;
}
/**
* init_plugin initialise internal data
*
* if we are server, try to bind and launch a thread to accept
* launch the thread of receive data
*
* @param net_plugin Info on the new instance that we will fill
*
* @return EXA_SUCCESS or error
*/
int algopr_init_plugin(exa_nodeid_t node_id, int max_buffer_size)
{
struct sockaddr_in serv_addr;
int retval = -NBD_ERR_MALLOC_FAILED;
int i;
EXA_ASSERT(EXA_NODEID_VALID(node_id));
this_node_id = node_id;
init_peers();
eth.max_buffer_size = max_buffer_size + max_buffer_size;
wq_init(ð.wq_send);
nbd_init_root(MAX_BIG_RECV_ELT, eth.max_buffer_size, ð.root_list_big_recv);
nbd_init_root(MAX_SEND_ELT, sizeof(payload_t), ð.root_list_send);
for (i = 0; i < EXA_MAX_NODES_NUMBER; i++)
nbd_init_list(ð.root_list_send, ð.send_list[i]);
algopr_run = true;
if (!exathread_create_named(ð.receive_thread,
NBD_THREAD_STACK_SIZE +
MIN_THREAD_STACK_SIZE_OF_THIS_PLUGIN,
algopr_receive_thread, NULL, "AlgoPrRcv"))
return -NBD_ERR_THREAD_CREATION;
if (!exathread_create_named(ð.send_thread,
NBD_THREAD_STACK_SIZE +
MIN_THREAD_STACK_SIZE_OF_THIS_PLUGIN,
algopr_send_thread, NULL, "AlgoPrSnd"))
return -NBD_ERR_THREAD_CREATION;
eth.accept_sock = os_socket(PF_INET, SOCK_STREAM, 0);
if (eth.accept_sock < 0)
return -EXA_ERR_CREATE_SOCKET;
/* bind a socket to SERVERD_DATA_PORT port and make it listen for incoming
* connections */
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = INADDR_ANY;
serv_addr.sin_port = htons(algopr_network_port);
retval = internal_setsock_opt(eth.accept_sock, SOCK_LISTEN_FLAGS);
if (retval != EXA_SUCCESS)
return retval;
if (os_bind(eth.accept_sock, (struct sockaddr *) &serv_addr,
sizeof(serv_addr)) < 0)
return -EXA_ERR_CREATE_SOCKET;
if (os_listen(eth.accept_sock, EXA_MAX_NODES_NUMBER) < 0)
return -EXA_ERR_CREATE_SOCKET;
if (!exathread_create_named(ð.accept_thread,
NBD_THREAD_STACK_SIZE +
MIN_THREAD_STACK_SIZE_OF_THIS_PLUGIN,
accept_thread, NULL, "servEthAccPlugin"))
return -NBD_ERR_THREAD_CREATION;
return EXA_SUCCESS;
}
static int __connect_to_peer(exa_nodeid_t node_id)
{
peer_t *peer;
struct sockaddr_in this_node_addr;
struct sockaddr_in serv_addr;
struct in_addr inaddr;
int sock = -1;
int err = EXA_SUCCESS;
int r;
peer = &peers[node_id];
exalog_debug("connecting to peer %"PRInodeid" '%s'", node_id, peer->ip_addr);
EXA_ASSERT(peer->ip_addr[0] != '\0');
EXA_ASSERT(peer->sock == -1);
r = os_inet_aton(peer->ip_addr, &inaddr);
if (r == 0)
{
exalog_error("Invalid IP '%s' for node %"PRInodeid, peer->ip_addr, node_id);
err = -EXA_ERR_CREATE_SOCKET;
goto done;
}
r = os_socket(PF_INET, SOCK_STREAM, 0);
if (r < 0)
{
exalog_error("Failed creating socket: %s (%d)", os_strerror(-r), r);
err = -EXA_ERR_CREATE_SOCKET;
goto done;
}
sock = r;
/* Bind the socket. Otherwise the system would be free to use whichever
interface it pleases, which may not match the IP address this node is
known as on other nodes participating in the PR. */
this_node_addr.sin_family = AF_INET;
os_inet_aton(peers[this_node_id].ip_addr, &this_node_addr.sin_addr);
this_node_addr.sin_port = htons(0); /* let the system choose */
r = os_bind(sock, (struct sockaddr *)&this_node_addr, sizeof(this_node_addr));
if (r < 0)
{
exalog_error("Failed binding socket %d to %s: %s (%d)", sock,
peers[this_node_id].ip_addr, os_strerror(-r), r);
err = -EXA_ERR_CREATE_SOCKET;
goto done;
}
os_sock_set_timeouts(sock, 4000);
memset(&serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = inaddr.s_addr;
serv_addr.sin_port = htons(algopr_network_port);
r = os_connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr));
if (r < 0)
{
exalog_error("Cannot connect to node %d (IP '%s'): %s (%d)",
node_id, peer->ip_addr, os_strerror(-r), r);
err = -NBD_ERR_SERVER_REFUSED_CONNECTION;
goto done;
}
os_sock_set_timeouts(sock, 0);
internal_setsock_opt(sock, SOCK_FLAGS);
peer->sock = sock;
done:
if (err != EXA_SUCCESS && sock != -1)
__close_socket(sock);
return err;
}
