void
req_echo_str(FILE *fp, int fd, const struct sockaddr *destaddr, socklen_t addrlen)
{
char sbuf[MAXLINE], rbuf[MAXLINE];
int n;
struct sockaddr reply_addr;
socklen_t len;
os_connect(fd, destaddr, addrlen);
while (fgets(sbuf, MAXLINE, fp) != NULL) {
//printf("[send]: %s", sbuf);
os_write(fd, sbuf, strlen(sbuf));
len = addrlen;
n = os_read(fd, rbuf, MAXLINE);
#if 0
if (len != addrlen || memcmp(destaddr, &reply_addr, addrlen) != 0) {
printf("packet not for us\n");
continue;
}
#endif
rbuf[n] = 0;
fputs(rbuf, stdout);
}
}
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);
}
void send_run(const char* channel, const char* file1, const char* file2, unsigned dt)
{
int log1 = os_flash_open(file1, READ);
int log2 = os_flash_open(file2, READ);
int socket = os_connect(channel);
uint32_t now = os_now();
while (true) {
tc_sleep(now + dt);
now += dt;
int32_t min = 0x7FFFFFFF;
int32_t max = 0xFFFFFFFF;
aggregate_from(log1, &min, &max);
aggregate_from(log2, &min, &max);
send_via(socket, min, max);
}
}
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;
}
