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