//when you need to handle a join reply, use the params join_ip and join_port //otherwise, join_ip=0 and join_port=-1 void peer_list(unsigned int join_ip, short join_port, unsigned int room){ //create payload for join and update replies struct peer *s; int num_in_room = 0; for(s=peers; s != NULL; s=(peer *)s->hh.next){ if(s->room==room){ num_in_room = num_in_room+1; } } struct sockaddr_in list[num_in_room]; int a = 0; for(s=peers; s != NULL; s=(peer *)s->hh.next){ if(s->room==room){ unsigned int peer_ip = get_ip(s->ip_and_port); short peer_port = get_port(s->ip_and_port); struct sockaddr_in peer_info = get_sockaddr_in(peer_ip, peer_port); sockaddr_in* peer_info_ptr = &peer_info; memcpy((sockaddr_in*)&list[a], peer_info_ptr, sizeof(peer_info)); a=a+1; } } packet update_pkt; update_pkt.header.type = 'u'; update_pkt.header.error = '\0'; update_pkt.header.payload_length = num_in_room * sizeof(struct sockaddr_in); memcpy(update_pkt.payload, list, num_in_room * sizeof(struct sockaddr_in)); for(s=peers; s != NULL; s=(peer *)s->hh.next){ if(s->room==room){ unsigned int peer_ip = get_ip(s->ip_and_port); short peer_port = get_port(s->ip_and_port); if(join_port!=-1 and join_ip!=0 and peer_ip == join_ip and peer_port==join_port){ //send join packet join_pkt; join_pkt.header.type = 'j'; join_pkt.header.error = '\0'; join_pkt.header.room = room; join_pkt.header.payload_length = num_in_room * sizeof(struct sockaddr_in); memcpy(join_pkt.payload, list, num_in_room * sizeof(struct sockaddr_in)); struct sockaddr_in peer_addr = get_sockaddr_in(peer_ip, peer_port); int status = sendto(sock, &join_pkt, sizeof(join_pkt), 0, (struct sockaddr *)&peer_addr, sizeof(peer_addr)); if (status == -1) { pthread_mutex_lock(&stdout_lock); fprintf(stderr, "%s\n", "error - error sending packet to peer"); pthread_mutex_unlock(&stdout_lock); } }else{ struct sockaddr_in peer_addr = get_sockaddr_in(peer_ip, peer_port); int status = sendto(sock, &update_pkt, sizeof(update_pkt), 0, (struct sockaddr *)&peer_addr, sizeof(peer_addr)); if (status == -1) { pthread_mutex_lock(&stdout_lock); fprintf(stderr, "%s\n", "error - error sending packet to peer"); pthread_mutex_unlock(&stdout_lock); } } } } }
static void incoming_arp(struct clip_vcc *clip_vcc, struct atmarphdr *hdr, int len) { void *spa,*tpa; u32 src_ip,tgt_ip; u8 *here; if (len < hdr->data - (u8 *)hdr) { printk(KERN_WARNING "got truncated ARP packet (%d bytes)\n", len); return; } if (hdr->ar_hrd != htons(ARPHRD_ATM)) { printk(KERN_WARNING "unknown hw protocol 0x%04x", ntohs(hdr->ar_hrd)); return; } if (hdr->ar_pro != htons(ETH_P_IP)) { printk(KERN_WARNING "unknown upper protocol 0x%04x", ntohs(hdr->ar_pro)); return; } if (!(hdr->ar_shtl & TL_LEN)) hdr->ar_shtl = 0; /* paranoia */ if (!(hdr->ar_thtl & TL_LEN)) hdr->ar_thtl = 0; here = hdr->data; get_addr(&here, hdr->ar_shtl & TL_LEN); get_addr(&here, hdr->ar_sstl & TL_LEN); spa = get_addr(&here, hdr->ar_spln); get_addr(&here, hdr->ar_thtl & TL_LEN); get_addr(&here, hdr->ar_tstl & TL_LEN); tpa = get_addr(&here, hdr->ar_tpln); if (here - (u8 *)hdr > len) { printk(KERN_WARNING "message too short (got %d, need %d)",len, here - (u8 *)hdr); return; } src_ip = get_ip(spa); tgt_ip = get_ip(tpa); switch (ntohs(hdr->ar_op)) { case ARPOP_InREQUEST: DPRINTK("got InARP_REQ"); if (!clip_learn(clip_vcc, src_ip)) clip_inarp_reply_send(clip_vcc->vcc, src_ip); break; case ARPOP_InREPLY: DPRINTK("got InARP_REP"); clip_learn(clip_vcc, src_ip); break; default: DPRINTK("unrecognized ARP op 0x%x", ntohs(hdr->ar_op)); } }
void Client::disconnect(const char* reason) { if(!connected) return; if(reason) logger->info(format("[%1%] Disconnecting - %2%") % get_ip() % reason); else logger->info(format("[%1%] Disconnection. Reason unknown.") % get_ip()); really_disconnect(socket, logger); connected = false; }
int tcp_connect(char *host) { struct sockaddr_in *remote; int sock; int tmpres; char *ip; if((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0){ perror("Can't create TCP socket"); return 0; } ip = get_ip(host); fprintf(stderr, "IP is %s\n", ip); remote = (struct sockaddr_in *)malloc(sizeof(struct sockaddr_in *)); remote->sin_family = AF_INET; tmpres = inet_pton(AF_INET, ip, (void *)(&(remote->sin_addr.s_addr))); if( tmpres < 0) { perror("Can't set remote->sin_addr.s_addr"); return 0; }else if(tmpres == 0) { fprintf(stderr, "%s is not a valid IP address\n", ip); return 0; } remote->sin_port = htons(PORT); if(connect(sock, (struct sockaddr *)remote, sizeof(struct sockaddr)) < 0){ perror("Could not connect"); return 0; } return sock; }
int main() { // sock: the socket. int sock = create_tcp_socket(); // remote: a record of an input socket address. struct sockaddr_in* remote = (struct sockaddr_in *)malloc(sizeof(struct sockaddr_in *)); remote->sin_family = AF_INET; host = argv[1]; char* ip = get_ip(host); int tmp_res = inet_pton(AF_INET, ip, (void*) (&(remote->sin_addr.s_addr))); if (tmp_res < 0) { fprintf(stderr, "inet_pton failed\n"); exit(1); } remote->sin_port = htons(PORT); // Connect the socket to the remote host. if (connect(sock, (struct sockaddr*) remote, sizeof(struct sockaddr)) < 0) { fprintf(stderr, "connect failed\n"); exit(0); } printf("connected successfully to remote host\n"); return; }
int send_ipmac() //sleep 2s ,发送一次,接收函数需要无阻塞 { char sendmsg[100]; char mac_data[30]; char ipaddr[40]; memset(mac_data,0,sizeof(char)*30); memset(ipaddr,0,sizeof(char)*40); memset(sendmsg,0,sizeof(char)*100); if(!get_ip("eth0",ipaddr)) { DEBUG_printf("get IP error\n"); } get_macforkey(mac_data,"eth0"); strncpy(mac_tmp,mac_data,strlen(mac_data)); strcpy(sendmsg,ipaddr); strcat(sendmsg,","); strcat(sendmsg,mac_data); int ret=sendto(udp_sock, sendmsg, strlen(sendmsg), 0, (struct sockaddr*)&addrto, sizeof(addrto)); if(ret<0) { DEBUG_printf("send error...."); } else { DEBUG_printf("send ipmac:\n%s\n",sendmsg); } DELAY_2S; return 1; }
int send_request(struct request* req, int* http_response_code, char * buffer) { struct sockaddr_in *remote; int sock; int buffer_size = TAILLE; int tmpres; char ip[16]; memset( (char*) ip, 0, 16); get_ip(req->host, (char*) ip); if (ip==NULL) { perror("libvmod_3scale: could not resolve the ip"); } else { char* template; char * srequest; if (req->http_verb==HTTP_POST) { int body_len = strlen(req->body); char tmp[128]; sprintf(tmp,"%d",body_len+1); int body_len_len = strlen(tmp); if ((req->header==NULL) || (strlen(req->header)==0)) {
int send_uptime(void) { struct sockaddr_in sai; struct stat st; PackUp *mem; int len, servidx; char servhost[UHOSTLEN] = "none"; module_entry *me; if (uptimeip == -1) { uptimeip = get_ip(); if (uptimeip == -1) return -2; } uptimecount++; upPack.packets_sent = htonl(uptimecount); /* Tell the server how many uptime packets we've sent. */ upPack.now2 = htonl(time(NULL)); upPack.ontime = 0; if ((me = module_find("server", 1, 0))) { Function *server_funcs = me->funcs; if (server_online) { servidx = findanyidx(serv); strncpyz(servhost, dcc[servidx].host, sizeof servhost); upPack.ontime = htonl(server_online); } } if (!upPack.pid) upPack.pid = htonl(getpid()); if (!upPack.uptime) upPack.uptime = htonl(online_since); if (stat("/proc", &st) < 0) upPack.sysup = 0; else upPack.sysup = htonl(st.st_ctime); len = sizeof(upPack) + strlen(botnetnick) + strlen(servhost) + strlen(uptime_version); mem = (PackUp *) nmalloc(len); egg_bzero(mem, len); /* mem *should* be completely filled before it's * sent to the server. But belt-and-suspenders * is always good. */ my_memcpy(mem, &upPack, sizeof(upPack)); sprintf(mem->string, "%s %s %s", botnetnick, servhost, uptime_version); egg_bzero(&sai, sizeof(sai)); sai.sin_family = AF_INET; sai.sin_addr.s_addr = uptimeip; sai.sin_port = htons(uptime_port); len = sendto(uptimesock, (void *) mem, len, 0, (struct sockaddr *) &sai, sizeof(sai)); nfree(mem); return len; }
void write_new_config() { int log; char filename[1024]; char log_string[1024]; char filepath[1024]; char *dir; strcpy(log_string,""); strcat(log_string,"\n");memcpy(username,"0",strlen((char *)username)); strcat(log_string,"\n");memcpy(passwd,"0",strlen((char *)passwd)); get_ip(); strcat(log_string,(char *)ip_addr);strcat(log_string,"\n"); strcat(log_string,SERVER);strcat(log_string,"\n"); get_mac();tr_mac(); strcat(log_string,(char *)mac_addr);strcat(log_string,"\n"); dir=getenv("HOME"); sprintf(filepath,"%s/.mynet/",dir); mkdir(filepath,O_RDWR|O_CREAT|O_TRUNC); chmod(filepath,0777); sprintf(filename,"%sconfig",filepath); log=open(filename,O_RDWR|O_CREAT|O_TRUNC,0777); chmod(filename,0777); write(log,log_string,strlen(log_string)); close(log); }
bool SSLClient::connection(const string& host, const int& port) { if(host=="localhost") { return connectionUnresolv(host, port); } struct sockaddr_in *remote; int tmpres; char *ip; sockfd = create_tcp_socket(); ip = get_ip((char*)host.c_str()); fprintf(stderr, "IP is %s\n", ip); remote = (struct sockaddr_in *)malloc(sizeof(struct sockaddr_in *)); remote->sin_family = AF_INET; tmpres = inet_pton(AF_INET, ip, (void *)(&(remote->sin_addr.s_addr))); if( tmpres < 0) { perror("Can't set remote->sin_addr.s_addr"); return false; } else if(tmpres == 0) { fprintf(stderr, "%s is not a valid IP address\n", ip); return false; } remote->sin_port = htons(port); if(connect(sockfd, (struct sockaddr *)remote, sizeof(struct sockaddr)) < 0){ perror("Could not connect"); connected = false; } else { connected = true; } free(remote); free(ip); /* Build our SSL context*/ init(); /* Connect the SSL socket */ ssl=SSL_new(ctx); sbio=BIO_new_socket(sockfd,BIO_CLOSE); SSL_set_bio(ssl,sbio,sbio); io=BIO_new(BIO_f_buffer()); ssl_bio=BIO_new(BIO_f_ssl()); BIO_set_ssl(ssl_bio,ssl,BIO_NOCLOSE); BIO_push(io,ssl_bio); if(SSL_connect(ssl)<=0) { logger << "SSL connect error"; return false; } ERR_clear_error(); connected = true; return true; }
/* * initiates a tcp connection to the specified host (either in * ip format (xxx.xxx.xxx.xxx) or as a hostname (microsoft.com) * to the host's tcp port. * * return values: != -1 on success, -1 on failure. */ int tcp_connect(char *host, unsigned int port) { int sock; struct sockaddr_in saddress; struct in_addr *iaddr; iaddr = Malloc(sizeof(struct in_addr)); /* write the hostname information into the in_addr structure */ if(get_ip(iaddr, host) != 0) return -1; saddress.sin_addr.s_addr = iaddr->s_addr; saddress.sin_family = AF_INET; saddress.sin_port = htons(port); /* create the socket */ if((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1) return -1; /* make the connection */ if(connect(sock, (struct sockaddr *) &saddress, sizeof(saddress)) != 0) { close(sock); return -1; } /* everything succeeded, return the connected socket */ return sock; }
char* send_request(struct request* req, int* http_response_code) { struct sockaddr_in *remote; int sock; int buffer_size = 16*1024; char* buffer = (char*)malloc(sizeof(char)*buffer_size); int tmpres; char* ip = get_ip(req->host); if (ip==NULL) { perror("libvmod_3scale: could not resolve the ip"); } else { char* template; char* srequest; if (req->http_verb==HTTP_POST) { int body_len = strlen(req->body); char tmp[128]; sprintf(tmp,"%d",body_len); int body_len_len = strlen(tmp); if ((req->header==NULL) || (strlen(req->header)==0)) {
int is_for_rangeip(const char *range, int verbose) { char *bip, *ip; int pos, size, retValue = 0; if (range == NULL) return (0); size = (int) ((unsigned char) range[8]); ip = get_ip(0); //don't resolv dns if (ip == NULL) return (0); bip = TagParseRangeIP(ip); if (bip == NULL) return (0); pos = 0; while (size >= 8) { if (range[pos] <= bip[pos] && bip[pos] <= range[pos + 4]) { pos++; size -= 8; } else goto error_is_for_rangeip; } if (size > 0) { bip[pos] = (unsigned char) bip[pos] >> (8 - size); bip[pos] = (unsigned char) bip[pos] << (8 - size); if (range[pos] > bip[pos] || bip[pos] > range[pos + 4]) goto error_is_for_rangeip; }
void Client::on_packet_header( PacketHeader* p, system::error_code err, size_t bytesTransferred) { unused_parameter(bytesTransferred); // Only used for debug builds. assert(p); PacketAllocator::auto_free f(packetPool, reinterpret_cast<uint8_t*>(p)); if(err) return disconnect("Failure in recv(Header)."); assert(bytesTransferred == PacketHeader::SIZE); if(p->version == 0x65) { decrypt_header(p, cryptoKey.c_array()); } else if(p->version != 0x64) logger->info(format("[%1%] Unknown protocol version %2% recieved.") % get_ip() % p->version); recieve_payload(p->fullSize, p->version == 0x65); }
int htsp_connect(struct htsp_t* htsp) { int res; htsp->sock = create_tcp_socket(); if (htsp->ip == NULL) htsp->ip = get_ip(htsp->host); fprintf(stderr,"Connecting to %s (%s) port %d...\n",htsp->host,htsp->ip,htsp->port); htsp->remote = (struct sockaddr_in *)malloc(sizeof(struct sockaddr_in)); htsp->remote->sin_family = AF_INET; res = inet_pton(AF_INET, htsp->ip, (void *)(&(htsp->remote->sin_addr.s_addr))); if (res < 0) { perror("Can't set remote->sin_addr.s_addr"); exit(1); } else if (res == 0) { fprintf(stderr, "%s is not a valid IP address\n", htsp->ip); return 1; } htsp->remote->sin_port = htons(htsp->port); if (connect(htsp->sock, (struct sockaddr *)htsp->remote, sizeof(struct sockaddr)) < 0){ perror("Could not connect"); return 2; } return 0; }
void send_connect_auth(char *cmd) { char *total_packg=NULL; char *userid; char *mac_data; char *ip_data; char ip_temp[40]; char *cuniqid; char uid_tmp[60]; char type[10]; unsigned char authbody_size; memset(uid_tmp,0,sizeof(char)*60); memset(type,0,sizeof(char)*10); memset(ip_temp,0,sizeof(char)*40); cuniqid= (char*)calloc(10,sizeof(char)); mac_data=(char*)calloc(30,sizeof(char)); ip_data=(char*)calloc(25,sizeof(char)); userid=(char*)calloc(60,sizeof(char)); if(!get_ip(ETH,ip_temp)) { DEBUG_printf("get ip error!\n"); } sprintf(ip_data,"IP=%s,",ip_temp); strcpy( userid,"UID="); #ifdef BB_BLACK strcat( userid,read_conf_by_type(bb_black_conf_dir,"api-uid",uid_tmp)); #endif // BB_BLACK #ifdef OPENWRT strcat( userid,read_luci_conf("user_id")); #endif // OPENWRT strcat( userid,","); sprintf(type,"TYPE=%d",MINERTYPE); authbody_size=strlen(gen_cuniqid(deal_package_cmd.pkg_nonce))+strlen(get_mac(mac_data,ETH))+strlen(ip_data)+strlen(userid)+strlen(type); send_head(cmd,authbody_size); total_packg=(char*)calloc((authbody_size+4),sizeof(char)); strcpy(total_packg,deal_package_cmd.pkg_nonce); strcat(total_packg,mac_data); strcat(total_packg,ip_data); strcat(total_packg,userid); strcat(total_packg,type); if ((sendbytes = senddata(ssl,sockfd,total_packg,authbody_size)) == -1) { perror("send"); //exit(1); } DEBUG_printf("send pakge str :%s\n",total_packg); free(mac_data); free(ip_data); free(userid); free(cuniqid); if(total_packg) free(total_packg); }
int main(int argc, char **argv){ struct sockaddr_in *remote; int sock; int tmpres; char *ip: char *get; char buf[BUFSIZ+1]; char *host; char *page; /* program is called without option */ if(argc==1){ usage(); exit(2); } /* program is called with host and page */ if(argc > 2){ page = argv[2]; } /* program is called without page - using default page */ else{ page=PAGE; } /* create client socket */ if((sock=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP)) < 0){ perror("Error creating client socket\n"); exit(1); } ip=get_ip(host); fprintf(stderr,"IP address is %s\n", ip); remote=(struct sockaddr_in *)malloc(sizeof(struct sockaddr_in *)); /* setting the address family */ remote->sin_famiily=AF_INET; tmpres=inet_pton(AF_INET,ip,(void *)(&(remote->sin_addr.s_addr))); if(tmpres < 0){ perror("Can't set sin_addr.s_addr \n"); exit(1); } else if(tmpres==0){ fprintf("%s is not a valid IP address\n",ip); exit(1); } remote->sin_port=htons(PORT); /* connecting to the webserver */ if(connect(sock,(struct sockaddr *)remote,sizeof(struct sockaddr)) <0){ perror("Can't connect to the webserver\n"); exit(1); } get=build_get_query(host,page); }
void free_am(void) { get_ip(NULL); /* Free IP address string memory */ if (opts->ifname != NULL) { free(opts->ifname); opts->ifname = NULL; } }
void delete_dead_peers(){ struct peer *s; for(s=peers; s != NULL; s=(struct peer *)s->hh.next){ if(s->alive==0){ unsigned int peer_ip = get_ip(s->ip_and_port); short peer_port = get_port(s->ip_and_port); peer_leave(peer_ip, peer_port); } } }
FACT_t sprout (func_t * scope, syn_tree_t expression) { /** * sprout - Create a new thread and manage the threads structure. * returns the id of the thread created. */ syn_tree_t *arg; FACT_thread_t *curr; FACT_thread_t *temp; static pthread_mutex_t list_lock = PTHREAD_MUTEX_INITIALIZER; expression.syntax += get_ip (); arg = better_malloc (sizeof (syn_tree_t)); *arg = expression; // Wait until we have control of the list while (pthread_mutex_trylock (&list_lock) == EBUSY); // Do nothing for (curr = root_thread; curr->next != NULL; curr = curr->next) { if (curr->exited && curr->destroy) break; } if (curr->exited && curr->destroy) { // Use a pre-existing thread. curr->ip = 0; curr->exited = false; curr->destroy = false; curr->root = NULL; } else { // Allocate memory for a new thread. temp = FACT_malloc (sizeof (FACT_thread_t)); pthread_mutex_init (&temp->queue_lock, NULL); temp->ip = 0; temp->nid = curr->nid + 1; temp->exited = false; temp->destroy = false; temp->root = NULL; temp->next = NULL; temp->prev = curr; curr->next = temp; curr = curr->next; } pthread_create (&(curr->tid), NULL, thread_wrapper, (void *) arg); pthread_mutex_unlock (&list_lock); return FACT_get_ui (curr->nid); }
/*---------------------------------------------------------------------------*/ static int on_new_session(struct xio_session *session, struct xio_new_session_req *session_data, void *cb_prv_data) { struct xio_msg *req; int i = 0; printf("**** [%p] on_new_session :%s:%d\n", session, get_ip((struct sockaddr *)&session_data->src_addr), get_port((struct sockaddr *)&session_data->src_addr)); xio_accept(session, NULL, 0, NULL, 0); msg_pool_reset(pool); conn = xio_get_connection(session, ctx); printf("**** starting ...\n"); while (1) { /* create transaction */ req = msg_pool_get(pool); if (req == NULL) break; /* get pointers to internal buffers */ req->in.header.iov_base = NULL; req->in.header.iov_len = 0; req->in.data_iovlen = 1; req->in.data_iov[0].iov_base = NULL; req->in.data_iov[0].iov_len = ONE_MB; req->in.data_iov[0].mr = NULL; /* recycle the message and fill new request */ msg_set(req, 1, test_config.hdr_len, test_config.data_len); /* try to send it */ if (xio_send_request(conn, req) == -1) { printf("**** sent %d messages\n", i); if (xio_errno() != EAGAIN) printf("**** [%p] Error - xio_send_msg " \ "failed. %s\n", session, xio_strerror(xio_errno())); msg_pool_put(pool, req); return 0; } i++; if (i == 256) break; } return 0; }
int BIO_get_host_ip(const char *str, unsigned char *ip) { int i; int err = 1; int locked = 0; struct hostent *he; i=get_ip(str,ip); if (i < 0) { BIOerr(BIO_F_BIO_GET_HOST_IP,BIO_R_INVALID_IP_ADDRESS); goto err; } /* At this point, we have something that is most probably correct in some way, so let's init the socket. */ if (BIO_sock_init() != 1) return 0; /* don't generate another error code here */ /* If the string actually contained an IP address, we need not do anything more */ if (i > 0) return(1); /* do a gethostbyname */ CRYPTO_w_lock(CRYPTO_LOCK_GETHOSTBYNAME); locked = 1; he=BIO_gethostbyname(str); if (he == NULL) { BIOerr(BIO_F_BIO_GET_HOST_IP,BIO_R_BAD_HOSTNAME_LOOKUP); goto err; } /* cast to short because of win16 winsock definition */ if ((short)he->h_addrtype != AF_INET) { BIOerr(BIO_F_BIO_GET_HOST_IP,BIO_R_GETHOSTBYNAME_ADDR_IS_NOT_AF_INET); goto err; } for (i=0; i<4; i++) ip[i]=he->h_addr_list[0][i]; err = 0; err: if (locked) CRYPTO_w_unlock(CRYPTO_LOCK_GETHOSTBYNAME); if (err) { ERR_add_error_data(2,"host=",str); return 0; } else return 1; }
int parse_arguments(int ac, char **av) { int i; std::string value; std::string team; int port = 4242; std::string ip("0"); i = 1; while (i < ac) { value = av[i]; if (value.compare("-n") == 0) { if (av[i + 1] != NULL) team = av[++i]; else { std::cerr << "An argument afther -n option is missing" << std::endl; return (-1); } } else if (value.compare("-p") == 0) { if (av[i + 1] != NULL) port = get_port(av[++i]); else { std::cerr << "An argument afther -p option is missing" << std::endl; return (-1); } } else if (value.compare("-h") == 0) { if (av[i + 1] != NULL) ip = get_ip(av[++i]); else { std::cerr << "An argument afther -h option is missing" << std::endl; return (-1); } } else { std::cerr << "The option " << value << " does not exist" << std::endl; return (-1); } i++; } if (port != -1 && ip.compare("KO") != 0) connect_to_server(team, port, ip); return (0); }
/*---------------------------------------------------------------------------*/ static int on_new_session(struct xio_session *session, struct xio_new_session_req *req, void *cb_prv_data) { printf("**** [%p] on_new_session :%s:%d\n", session, get_ip((struct sockaddr *)&req->src_addr), get_port((struct sockaddr *)&req->src_addr)); xio_accept(session, NULL, 0, NULL, 0); return 0; }
int main() { int rc = 0; unsigned int ip_addr; if(get_ip(&ip_addr, "localhost") != 0) { fprintf(stderr, "Unable to convert IP address " " to format used in RPC calls"); } else { printf("IP address %d\n", ip_addr); } return 0; }
gnutls_ProxyInfo_ext get_proxy_info(gnutls_session_t session) { gnutls_ProxyInfo_ext cur_proxy_info; char p[16]; strcpy(p,get_ip()); cur_proxy_info.cipher_algo = gnutls_cipher_get(session);//rand()%20; cur_proxy_info.kx_algo = gnutls_kx_get(session); cur_proxy_info.mac_algo = gnutls_mac_get(session); cur_proxy_info.ip_addr=get_ip_int(p);//get_cur_ip_addr(); cur_proxy_info.mac_addr=rand()%20;//get_cur_max_addr(); return cur_proxy_info; }
int handle_connection(struct map_queue *q) { char *buf = (char*)&q->port; ssize_t size_r, size_w; while(q->size_r < sizeof(q->port)) { size_r = read(q->fd, buf + q->size_r, sizeof(q->port) - q->size_r); if (size_r == -1) { switch (errno) { case EAGAIN: return FD_NODATA; case ECONNRESET: case EPIPE: return FD_CNXCLOSED; } } CHECK_RES_RETURN(size_r, "read"); if (size_r == 0) return FD_CNXCLOSED; q->size_r += size_r; } if (verbose) fprintf(stderr, "request fd %d: %d\n", q->fd, ntohs(q->port)); if(q->ip == 0xFFFFFFFF) q->ip = htonl(get_ip(ntohs(q->port))); if (verbose) fprintf(stderr, "got ip %u associated with port %u\n", ntohl(q->ip), ntohs(q->port)); buf = (char*)&q->ip; while(q->size_w < sizeof(q->ip)) { size_w = write(q->fd, buf + q->size_w, sizeof(q->ip) - q->size_w); if (size_w == -1) { switch (errno) { case EAGAIN: return FD_STALLED; case ECONNRESET: case EPIPE: return FD_CNXCLOSED; } } CHECK_RES_RETURN(size_w, "write"); q->size_w += size_w; } q->size_r = 0; q->size_w = 0; q->ip = 0xFFFFFFFF; return 1; }
void border_printNodes(struct ip_list *list) { printf("Im Netz verfügbare Knoten:\n"); int i; for (i = 0; i < size_ip(list); i++) { printf("%d: ", i); print_ip(get_ip(list, i)); uint8_t *tmp = get_via(list, i); if (tmp != NULL) { printf(" via "); print_ip(tmp); } printf("\n"); } }
static PyObject *dsuimod_declare(PyObject *self, PyObject *args) { char *group, *name; if (!PyArg_ParseTuple(args, "ss", &group, &name)) { return NULL; } get_ip(group, name, DS_EVENT_TYPE, strdup("print_pickle")); Py_RETURN_NONE; }
void check_network_interface(inetface_t *iface) { bool ok; bool update_hwaddr = false; char hwaddr_pathname[PATH_MAX]; char old_hwaddr[20]; snprintf(hwaddr_pathname, PATH_MAX, "/etc/checkip/%s.hwaddr", iface->name); if (!file_exist(hwaddr_pathname)) { log_info("File %s does not exist", hwaddr_pathname); update_hwaddr = true; get_ip(iface, update_hwaddr); return; } ok = read_inetface_hwaddr(iface, old_hwaddr); if (!ok) { log_fatal("Could read old NIC hardware address"); return; } if (0 == strcasecmp(old_hwaddr, iface->mac) && is_ip_public(iface->ip)) { log_info("%s is up and got a public IP, nothing to do", iface->name); return; } if (0 != strcasecmp(old_hwaddr, iface->mac)) { log_info("Hardware address changed (%s to %s), this is a new card", old_hwaddr, iface->mac); update_hwaddr = true; } get_ip(iface, update_hwaddr); }