APR_DECLARE(apr_status_t) apr_socket_addr_get(apr_sockaddr_t **sa,
apr_interface_e which,
apr_socket_t *sock)
{
if (which == APR_LOCAL) {
if (sock->local_interface_unknown || sock->local_port_unknown) {
apr_status_t rv = get_local_addr(sock);
if (rv != APR_SUCCESS) {
return rv;
}
}
*sa = sock->local_addr;
}
else if (which == APR_REMOTE) {
if (sock->remote_addr_unknown) {
apr_status_t rv = get_remote_addr(sock);
if (rv != APR_SUCCESS) {
return rv;
}
}
*sa = sock->remote_addr;
}
else {
*sa = NULL;
return APR_EINVAL;
}
return APR_SUCCESS;
}
void _XMP_mpi_contiguous_get(const int org_target_rank, const _XMP_coarray_t *dst_desc, const _XMP_coarray_t *src_desc,
const size_t dst_offset, const size_t src_offset,
const size_t dst_elmts, const size_t src_elmts, const size_t elmt_size, const bool is_dst_on_acc, const bool is_src_on_acc)
{
const int target_rank = _XMP_mpi_trans_rank(src_desc, org_target_rank);
size_t transfer_size = elmt_size * dst_elmts;
char *dst = get_local_addr(dst_desc, is_dst_on_acc);
if(dst_elmts == src_elmts){
_mpi_contiguous(_XMP_N_COARRAY_GET,
target_rank,
src_desc, dst,
src_offset, dst_offset,
transfer_size, is_src_on_acc);
}else if(src_elmts == 1){
_XMP_array_section_t dst_info;
dst_info.start = dst_offset / elmt_size;
dst_info.length = dst_elmts;
dst_info.stride = 1;
dst_info.elmts = dst_info.start + dst_info.length;
dst_info.distance = elmt_size;
_mpi_scalar_mget(target_rank,
dst, src_desc,
dst_offset, src_offset,
1 /*dst_dims*/,
&dst_info,
is_src_on_acc);
}else{
_XMP_fatal("Coarray Error ! transfer size is wrong.\n");
}
}
void goto_index(int delay)
{
char *local_addr = NULL;
char dest[256] = {0};
local_addr = get_local_addr();
sprintf(dest, REDIRECT_INDEX, local_addr, delay);
printf("%s", dest);
}
/** \brief convert the object into a string
*/
std::string udp_itor_t::to_string() const throw()
{
if( is_null() ) return "null";
return get_local_addr().to_string() + " to " + get_remote_addr().to_string();
}
int main(int argc, char **argv)
{
pthread_mutex_init(&heart,NULL); // protects the beat counter
pthread_mutex_init(&con,NULL); // protects the default server connection value from badly-timed updates
pthread_mutex_init(&queue,NULL); // protects the cache from poorly-timed access
cache = new_cache(-1); // creates query cache with default size (when arg is < 0, MAX_SIZE used. See cache.h
clients = new_cache(100); // creates a cache of connected clients
pending_queries = new_cache(100); // creates a cache of pending updates. When client requests a value that
// must be retrieved from the database, the client's callback information is stored here until the DB query
// is completed.
/* Read command-line arguments */
if(argc>1)
{
int x;
for(x=1;x<argc;x++)
{
// database addr
if(strcmp("-d",*(argv + x))==0)
{
if(strlen( *(argv + x + 1) )>0)
{
strcpy(database_addr,*(argv + x + 1));
}
else
{
usage();
}
}
else if(strcmp("-P",*(argv + x))==0)
{
pthread_t pull_thread;
pthread_create(&pull_thread,NULL,(void *)pull_updater,(void *)cache);
}
else if(strcmp("-C",*(argv + x))==0)
{
pthread_t updater;
pthread_create(&updater,NULL,(void *)caco,NULL);
}
else if(strcmp("-n",*(argv + x))==0)
{
strcpy(neighbor_addr,*(argv + x + 1));
}
else if(strcmp("-S",*(argv + x))==0)
{
server_id = atoi(*(argv + x + 1));
}
}
}
else
{
usage();
}
start_listener();
start_sender();
// wait for all threads to come online
sleep(2);
while(server_id==0);
/* Begin the heartbeat between this host and its neighbor */
char h_msg[CONTENT_MAX];
sprintf(h_msg,"%s,%d,NULL",hea,server_id);
while(sender_queue==NULL);
message_host(neighbor_addr,h_msg);
/* End Heartbeat. Should be cycling now */
for(;;)
{
// neighbor recovered!
if(beat_count == 0 && solo == 1)
{
// if we took over the Caco process for another server, shut it down now
if(!CACO_SERVER)
{
printf("\n\n** ATTENTION! ***************************\n");
printf("****** CANCELING CACO UPDATER ************\n");
printf("******************************************\n\n");
pthread_cancel(caco_thread);
}
solo = 0;
printf("\n\n** ATTENTION! ****************************\n");
printf("** NEIGHBOR BACK ONLINE *******************\n");
printf("*******************************************\n\n");
struct cache_entry *client;
int x;
/* Inform all adopted clients that the other server is back online */
for(x=0;x<clients->length;x++)
{
client = get_index(x,clients);
// only message clients of the other front-end server
if(client->server_id==server_id)
continue;
char r_msg[CONTENT_MAX];
sprintf(r_msg,"%s,%s,NULL",rea,neighbor_addr);
message_host(client->value,r_msg);
}
}
pthread_mutex_lock(&heart);
beat_count++; // we'll wait until HEARTBEAT_DELAY has elapsed before we declare the other
// server dead.
// assume we've lost the neighbor
if(beat_count==HEARTBEAT_DELAY)
{
// If we need to take over the Caco process for the other server, start it now.
if(!CACO_SERVER)
{
printf("\n\n** NOTICE *************************\n");
printf("** taking over caco updater *******\n");
printf("***********************************\n\n");
pthread_create(&caco_thread,NULL,caco,NULL);
}
// sets the state-var solo, indicating that we are running alone
solo = 1;
printf("\n\n** NOTICE *************************.\n");
printf("** LOST CONTACT WITH NEIGHBOR SERVER **\n");
printf("** ASSUMING RESPONSIBILITY ************\n");
printf("***************************************\n\n");
struct cache_entry *client;
int x;
/* Adopt the clients from the other server. Notify them of the changes */
for(x=0;x<clients->length;x++)
{
client = get_index(x,clients);
// only message clients of the other front-end server
if(client->server_id==server_id)
continue;
char r_msg[CONTENT_MAX];
char addr[CONTENT_MAX];
get_local_addr(addr);
sprintf(r_msg,"%s,%s,NULL",rea,addr);
message_host(client->value,r_msg);
}
}
pthread_mutex_unlock(&heart);
sleep(1);
}
return 0;
}
static int tcp_connect(struct http_client_ctx *ctx)
{
socklen_t addrlen = sizeof(struct sockaddr_in);
int ret;
if (ctx->tcp.ctx && net_context_is_used(ctx->tcp.ctx) &&
net_context_get_state(ctx->tcp.ctx) == NET_CONTEXT_CONNECTED) {
/* If we are already connected, then just return */
return -EALREADY;
}
if (ctx->tcp.remote.family == AF_INET6) {
addrlen = sizeof(struct sockaddr_in6);
/* If we are reconnecting, then make sure the source port
* is re-calculated so that the peer will not get confused
* which connection the connection is related to.
* This was seen in Linux which dropped packets when the same
* source port was for a new connection after the old connection
* was terminated.
*/
net_sin6(&ctx->tcp.local)->sin6_port = 0;
} else {
net_sin(&ctx->tcp.local)->sin_port = 0;
}
ret = get_local_addr(ctx);
if (ret < 0) {
NET_DBG("Cannot get local address (%d)", ret);
return ret;
}
ret = net_context_get(ctx->tcp.remote.family, SOCK_STREAM,
IPPROTO_TCP, &ctx->tcp.ctx);
if (ret) {
NET_DBG("Get context error (%d)", ret);
return ret;
}
net_context_setup_pools(ctx->tcp.ctx, ctx->tx_slab, ctx->data_pool);
ret = net_context_bind(ctx->tcp.ctx, &ctx->tcp.local,
addrlen);
if (ret) {
NET_DBG("Bind error (%d)", ret);
goto out;
}
ret = net_context_connect(ctx->tcp.ctx,
&ctx->tcp.remote, addrlen,
NULL, ctx->tcp.timeout, NULL);
if (ret) {
NET_DBG("Connect error (%d)", ret);
goto out;
}
return net_context_recv(ctx->tcp.ctx, ctx->tcp.recv_cb, K_NO_WAIT, ctx);
out:
net_context_put(ctx->tcp.ctx);
ctx->tcp.ctx = NULL;
return ret;
}
/*
* Funzione prova a connetersi ai superpeer indicati nella lista passata come parametro.
* Ritorna 0 in caso di successo e -1 se si è verificato un errore o se non è riuscita
* a connettersi a nessun superpeer della lista.
*/
int join_overlay(const struct sockaddr_in *sp_addr_list, int list_len) {
int i, ok = 1;
int sock_tmp;
int addr_check = 0;
int j, nread;
struct sockaddr_in *addr_list;
struct packet recv_pck;
if (list_len > max_tcp_sock / 2) {
near_str = (char *)realloc(near_str, list_len * 2 * ADDR_STR_LEN);
memset(near_str + max_tcp_sock * ADDR_STR_LEN, 0, (list_len * 2 - max_tcp_sock) * ADDR_STR_LEN);
max_tcp_sock = list_len * 2;
}
for (i = 0; i < list_len; i ++) {
if (get_near_by_addr(&sp_addr_list[i]) != NULL) {
continue;
}
if (ok) {
if ((sock_tmp = tcp_socket()) < 0) {
perror("join_overlay error - can't initialize tcp socket");
return -1;
}
//printf("SOCKET: %d\n", sock_tmp);
// printf("LISTLEN: %d\n", list_len);
}
printf("join_overlay - addr: %s:%d\n", inet_ntoa(sp_addr_list[i].sin_addr), ntohs(sp_addr_list[i].sin_port));
if (tcp_connect(sock_tmp, &sp_addr_list[i]) < 0) {
perror("join_overlay error - can't connect to superpeer");
ok = 0;
continue; //provo il prossimo indirizzo
} else {
printf("Connected with superpeer %s:%d\n", inet_ntoa(sp_addr_list[i].sin_addr), ntohs(sp_addr_list[i].sin_port));
if (addr_check == 0) {
get_local_addr(sock_tmp, &myaddr);
addr_check = 1;
}
ok = 1;
if ((nread = recv_packet_tcp(sock_tmp, &recv_pck)) < 0) {
perror("join_overlay error - recv_packet_tcp failed\n");
return -1;
} else if (nread == 0) {
printf("join_overlay - connection closed by superpeer\n");
if (close(sock_tmp) < 0) {
perror("join_overlay error - close failed");
return -1;
}
continue;
}
if (!strncmp(recv_pck.cmd, CMD_ACK, CMD_STR_LEN)) {
if (write(sock_tmp, (char *)&conf.udp_port, sizeof(conf.udp_port)) < 0) {
perror("join_overlay error - write failed\n");
return -1;
}
fd_add(sock_tmp);
if (insert_near(sock_tmp, &sp_addr_list[i]) < 0) {
fprintf(stderr, "join_overlay error - insert_near failed\n");
return -1;
}
addr2str(near_str + nsock * 6, sp_addr_list[i].sin_addr.s_addr, sp_addr_list[i].sin_port);
addr_list = str_to_addr(near_str, max_tcp_sock);
for(j = 0; j < max_tcp_sock; j ++){
printf("join_overlay - near %s:%d\n", inet_ntoa(addr_list[j].sin_addr), ntohs(addr_list[j].sin_port));
}
nsock ++;
} else if (!strncmp(recv_pck.cmd, CMD_ERR, CMD_STR_LEN)) {
printf("RICEVUTO ERR\n");
printf("join_overlay - connection closed by superpeer\n");
if (close(sock_tmp) < 0) {
perror("join_overlay error - close failed");
return -1;
}
continue;
} else {
fprintf(stderr, "join_overlay error - packet not expected\n");
if (close(sock_tmp) < 0) {
perror("join_overlay error - close failed");
return -1;
}
continue;
}
}
}
if (!ok) {
close(sock_tmp);
}
if (nsock != list_len) {
printf("join_overlay error - can't connect to all superpeer in the list\n");
return 1;
}
return 0;
}
static int
doit (krb5_keytab keytab, int port)
{
krb5_error_code ret;
int *sockets;
int maxfd;
krb5_realm *realms;
krb5_addresses addrs;
krb5_address *my_addrp;
unsigned n, i;
fd_set real_fdset;
struct sockaddr_storage __ss;
struct sockaddr *sa = (struct sockaddr *)&__ss;
#ifdef INETD_SUPPORT
int fdz;
int from_inetd;
socklen_t fromlen;
krb5_address my_addr;
struct sockaddr_storage __local;
struct sockaddr *localsa = (struct sockaddr *)&__local;
#endif
ret = krb5_get_default_realms(context, &realms);
if (ret)
krb5_err (context, 1, ret, "krb5_get_default_realms");
#ifdef INETD_SUPPORT
fromlen = sizeof __ss;
from_inetd = (getsockname(0, sa, &fromlen) == 0);
if (!from_inetd) {
#endif
if (explicit_addresses.len) {
addrs = explicit_addresses;
} else {
ret = krb5_get_all_server_addrs (context, &addrs);
if (ret)
krb5_err (context, 1, ret, "krb5_get_all_server_addrs");
}
n = addrs.len;
sockets = malloc (n * sizeof(*sockets));
if (sockets == NULL)
krb5_errx (context, 1, "out of memory");
maxfd = -1;
FD_ZERO(&real_fdset);
for (i = 0; i < n; ++i) {
krb5_socklen_t sa_size = sizeof(__ss);
krb5_addr2sockaddr (context, &addrs.val[i], sa, &sa_size, port);
sockets[i] = socket (sa->sa_family, SOCK_DGRAM, 0);
if (sockets[i] < 0)
krb5_err (context, 1, errno, "socket");
if (bind (sockets[i], sa, sa_size) < 0) {
char str[128];
size_t len;
int save_errno = errno;
ret = krb5_print_address (&addrs.val[i], str, sizeof(str), &len);
if (ret)
strlcpy(str, "unknown address", sizeof(str));
krb5_warn (context, save_errno, "bind(%s)", str);
continue;
}
maxfd = max (maxfd, sockets[i]);
if (maxfd >= FD_SETSIZE)
krb5_errx (context, 1, "fd too large");
FD_SET(sockets[i], &real_fdset);
}
#ifdef INETD_SUPPORT
} else {
n = 1;
maxfd = 0;
fdz = 0;
sockets = &fdz;
FD_ZERO(&real_fdset);
FD_SET(0, &real_fdset);
}
#endif
if (maxfd == -1)
krb5_errx (context, 1, "No sockets!");
while(exit_flag == 0) {
krb5_ssize_t retx;
fd_set fdset = real_fdset;
retx = select (maxfd + 1, &fdset, NULL, NULL, NULL);
if (retx < 0) {
if (errno == EINTR)
continue;
else
krb5_err (context, 1, errno, "select");
}
for (i = 0; i < n; ++i)
if (FD_ISSET(sockets[i], &fdset)) {
u_char buf[BUFSIZ];
socklen_t addrlen = sizeof(__ss);
retx = recvfrom(sockets[i], buf, sizeof(buf), 0,
sa, &addrlen);
if (retx < 0) {
if(errno == EINTR)
break;
else
krb5_err (context, 1, errno, "recvfrom");
}
#ifdef INETD_SUPPORT
if (from_inetd) {
socklen_t loclen = sizeof(__local);
int ret2;
ret2 = get_local_addr(sa, addrlen, localsa, &loclen);
if (ret2 < 0)
krb5_errx (context, errno, "get_local_addr");
ret2 = krb5_sockaddr2address(context, localsa,
&my_addr);
if (ret2)
krb5_errx (context, ret2,
"krb5_sockaddr2address");
my_addrp = &my_addr;
} else
#endif
my_addrp = &addrs.val[i];
process (realms, keytab, sockets[i],
my_addrp,
sa, addrlen,
buf, retx);
#ifdef INETD_SUPPORT
if (from_inetd) {
krb5_free_address(context, &my_addr);
}
#endif
}
#ifdef INETD_SUPPORT
if (from_inetd)
break;
#endif
}
for (i = 0; i < n; ++i)
close(sockets[i]);
free(sockets);
#ifdef INETD_SUPPORT
if (!from_inetd)
#endif
krb5_free_addresses (context, &addrs);
krb5_free_host_realm (context, realms);
krb5_free_context (context);
return 0;
}
int ip_dest_check(const ip_fragment_t *frag)
{
return (frag->head->daddr == get_local_addr())
|| (frag->head->daddr == 0x7f000001) ? 1 : 0;
}
char *_XMP_mpi_coarray_get_local_addr(const _XMP_coarray_t *desc, const bool is_acc)
{
return get_local_addr(desc, is_acc);
}
int argt_func(int argc, char **argv)
{
int opt, ret = 1;
struct option longopts[] = {
{ "help", 0, NULL, 'h' }, //1
{ "version", 0, NULL, 'v' }, //2
{ "save", 0, NULL, 's' }, //3
{ "read", 0, NULL, 'r' }, //4
{ "show", 0, NULL, 'c' }, //5
{ "selist", 0, NULL, 'l' }, //6
{ "loglevel", 1, NULL, 'L' }, //7
{ "id", 1, NULL, 'N' }, //8
{ "addr", 1, NULL, 'A' }, //9
{ "rip", 1, NULL, 'I' }, //10
{ "rport", 1, NULL, 'P' }, //11
{ 0, 0, 0, 0 },
};
cfg.rf433.net_id = RF433_CFG_NET_ID;
cfg.rf433.local_addr = RF433_CFG_LOCAL_ADDR;
cfg.rf433.m_mask = 0;
cfg.socket.server_ip.s_addr = inet_addr(RF433_CFG_SRV_IP);
cfg.socket.server_port = RF433_CFG_UDP_PORT;
cfg.socket.m_mask = 0;
se433_set.se433_addr = 0;
se433_set.op = 0;
if (argc <= 1) {
printf(USAGE);
ret = 0;
goto err;
}
while ((opt = getopt_long(argc, argv, "hvsrclL:N:A:I:P:", longopts, NULL)) != -1) {
switch (opt) {
case 's': // save
opt_id = MSG_REQ_SAVE_CFG;
break;
case 'r': // read
opt_id = MSG_REQ_READ_CFG;
break;
case 'c': // show
opt_id = MSG_REQ_GET_CFG;
break;
case 'l': // se433 list
opt_id = MSG_REQ_GET_SE433L;
break;
case 'L': // loglevel
if ((get_log_level(optarg, &log_level)) == -1) {
fprintf(stderr, "\n invalid value (%s)\n\n", optarg);
ret = -1;
goto err;
}
opt_id = MSG_REQ_SET_LOG;
break;
case 'N': // netid
if ((get_netid(optarg, &cfg.rf433.net_id)) == -1) {
fprintf(stderr, "\n invalid value (%s)\n\n", optarg);
ret = -1;
goto err;
}
cfg.rf433.m_mask |= RF433_MASK_NET_ID;
opt_id = MSG_REQ_SET_CFG;
break;
case 'A': // addr
if ((get_local_addr(optarg, &cfg.rf433.local_addr)) == -1) {
fprintf(stderr, "\n invalid value (%s)\n\n", optarg);
ret = -1;
goto err;
}
cfg.rf433.m_mask |= RF433_MASK_RCV_ADDR;
opt_id = MSG_REQ_SET_CFG;
break;
#if 0
case 'E': // seadd
if ((get_se433_addr(optarg, &se433_set.se433_addr)) == -1) {
fprintf(stderr, "\n invalid value (%s)\n\n", optarg);
ret = -1;
goto err;
}
se433_set.op = SE433_OP_ADD;
break;
case 'D': // sedel
if ((get_se433_addr(optarg, &se433_set.se433_addr)) == -1) {
fprintf(stderr, "\n invalid value (%s)\n\n", optarg);
ret = -1;
goto err;
}
se433_set.op = SE433_OP_DEL;
break;
#endif
case 'I': // rip
if ((get_ip(optarg, &cfg.socket.server_ip)) == -1) {
fprintf(stderr, "\n invalid value (%s)\n\n", optarg);
ret = -1;
goto err;
}
cfg.socket.m_mask |= SOCK_MASK_SER_IP;
opt_id = MSG_REQ_SET_CFG;
break;
case 'P': // rport
if ((get_port(optarg, &cfg.socket.server_port)) == -1) {
fprintf(stderr, "\n invalid value (%s)\n\n", optarg);
ret = -1;
goto err;
}
cfg.socket.m_mask |= SOCK_MASK_UDP_PORT;
opt_id = MSG_REQ_SET_CFG;
break;
case 'h':
case 'v':
printf(USAGE);
ret = 0;
goto err;
break;
default:
fprintf(stderr, "%s: invalid opt (%c)\n\n", argv[0], opt);
printf(USAGE);
ret = 0;
goto err;
break;
}
}
err:
return ret;
}
/* get_addr: get IP address of server */
in_addr_t get_addr()
{
return (in_addr_t)get_local_addr();
}
