host_entry::host_entry(struct addrinfo* __ainfo) { ufc_check_ptr (__ainfo); for (struct addrinfo* __ai = __ainfo; __ai; __ai = __ai->ai_next) { if (__ai->ai_canonname) { _name.assign(__ai->ai_canonname); } if (__ai->ai_addrlen && __ai->ai_addr) { switch (__ai->ai_addr->sa_family) { case AF_INET: _addresses.push_back(ip_address(&reinterpret_cast<struct sockaddr_in*>(__ai->ai_addr)->sin_addr, sizeof(in_addr))); break; #if defined(ufc_have_ipv6) case AF_INET6: _addresses.push_back(ip_address(&reinterpret_cast<struct sockaddr_in6*>(__ai->ai_addr)->sin6_addr, sizeof(in6_addr), reinterpret_cast<struct sockaddr_in6*>(__ai->ai_addr)->sin6_scope_id)); break; #endif } } } }
void neigh_table_mgr::notify_cb(event *ev) { neigh_mgr_logdbg(""); // Got event from netlink neigh_nl_event* nl_ev = dynamic_cast <neigh_nl_event*> (ev); BULLSEYE_EXCLUDE_BLOCK_START if (nl_ev == NULL) { neigh_mgr_logdbg("Non neigh_nl_event type"); return; } BULLSEYE_EXCLUDE_BLOCK_END const netlink_neigh_info* nl_info = nl_ev->get_neigh_info(); struct in_addr in; if (1 != inet_pton(AF_INET, (const char *)(nl_info->dst_addr_str.c_str()), &in)) { neigh_mgr_logdbg("Ignoring netlink neigh event neigh for IP = %s, not a valid IP", nl_info->dst_addr_str.c_str()); return; } in_addr_t neigh_ip = in.s_addr; // Search for this neigh ip in cache_table m_lock.lock(); net_dev_lst_t* p_ndv_val_lst = g_p_net_device_table_mgr->get_net_device_val_lst_from_index(nl_info->ifindex); //find all neigh entries with an appropriate peer_ip and net_device if (p_ndv_val_lst) { net_dev_lst_t::iterator itr; for (itr = p_ndv_val_lst->begin(); itr != p_ndv_val_lst->end(); ++itr) { net_device_val* p_ndev = dynamic_cast <net_device_val *>(*itr); if (p_ndev) { std::tr1::unordered_map< neigh_key, cache_entry_subject<neigh_key,neigh_val*> *>::iterator cache_itr; cache_itr = m_cache_tbl.find(neigh_key(ip_address(neigh_ip), p_ndev)); if (cache_itr == m_cache_tbl.end()) { neigh_mgr_logdbg("Ignoring netlink neigh event for IP = %s if:%s, index=%d, p_ndev=%p", nl_info->dst_addr_str.c_str(), p_ndev->to_str().c_str(), nl_info->ifindex, p_ndev); } else { neigh_entry *p_ne = dynamic_cast <neigh_entry *>(cache_itr->second); if (p_ne) { // Call the relevant neigh_entry to handle the event p_ne->handle_neigh_event(nl_ev); } } } else { neigh_mgr_logdbg("could not find ndv_val for ifindex=%d", nl_info->ifindex); } } } else { neigh_mgr_logdbg("could not find ndv_val list for ifindex=%d", nl_info->ifindex); } m_lock.unlock(); return; }
void update() { struct string ip = ip_address(); str_trim_right(&ip.ptr); url_upload(&ip); free(ip.ptr); }
bool tcp_server_socket::on_readable() { while( true ) { union { struct sockaddr sa; struct sockaddr_storage ss; } addr; socklen_t addrlen = sizeof(addr); #ifdef _GNU_SOURCE int s = ::accept4(m_fd, &(addr.sa), &addrlen, SOCK_NONBLOCK|SOCK_CLOEXEC); #else int s = ::accept(m_fd, &(addr.sa), &addrlen); if( s != -1 ) { int fl = fcntl(s, F_GETFL, 0); if( fl == -1 ) fl = 0; if( fcntl(s, F_SETFL, fl | O_NONBLOCK) == -1 ) { ::close(s); throw_unix_error(errno, "fcntl(F_SETFL)"); } fl = fcntl(s, F_GETFD, 0); if( fl == -1 ) fl = 0; if( fcntl(s, F_SETFD, fl | FD_CLOEXEC) == -1 ) { ::close(s); throw_unix_error(errno, "fcntl(F_SETFD)"); } } #endif if( s == -1 ) { if( errno == EINTR || errno == ECONNABORTED ) continue; if( errno == EMFILE || errno == ENFILE ) { logger::error() << "accept: Too many open files."; continue; } if( errno == EAGAIN || errno == EWOULDBLOCK ) break; throw_unix_error(errno, "accept"); } try { std::unique_ptr<tcp_socket> t = m_wrapper(s, ip_address(&(addr.sa))); if( t.get() == nullptr ) { ::close(s); } else { m_reactor->add_resource( std::move(t), reactor::EVENT_IN|reactor::EVENT_OUT ); } } catch( ... ) { ::close(s); throw; } } return true; }
ip_address make_ip_address_local() { //http://tangentsoft.net/wskfaq/examples/ipaddr.html unsigned long addr = INADDR_NONE; char host_name[80]; if (::gethostname(host_name, sizeof(host_name)) != SOCKET_ERROR) { hostent* he = ::gethostbyname(host_name); if (he != nullptr) { addr = *((unsigned long*)he->h_addr_list[0]); } } return ip_address(addr); }
void ribi::gtst::DebugDialog::OnUploadDone() { boost::shared_ptr<Parameters> parameters(new Parameters(m_server)); assert(parameters); try { parameters->ReadFromFile(m_fileupload->spoolFileName()); } catch (std::runtime_error& e) { m_label_state_upload->setText(e.what()); return; } m_label_state_upload->setText("OK: parameter file loaded"); m_server->Reset(); m_server->SetParameters(parameters); //Create the Participant dialogs ///Remove all ParticipantDialogs from Wt::WContainerWidget and std::vector this->clear(); m_dialogs.resize(0); const int n_participants = m_server->GetGroups()->CollectParticipants().size(); //Display the dialogs in a random order std::vector<int> indices(n_participants); std::iota(indices.begin(),indices.end(),0); std::random_shuffle(indices.begin(),indices.end()); for (int dialog_index=0; dialog_index!=n_participants; ++dialog_index) { const int i = indices[dialog_index]; std::string ip_address_str = "000.000.000." + std::to_string(i); boost::scoped_ptr<SafeIpAddress> ip_address( new SafeIpAddress(ip_address_str)); ParticipantDialog* const dialog = new ParticipantDialog(m_server,ip_address.get()); m_dialogs.push_back(dialog); Wt::WGroupBox * const box = new Wt::WGroupBox; box->addWidget(dialog); addWidget(new Wt::WBreak); addWidget(new Wt::WBreak); addWidget(box); } }
void neigh_table_mgr::notify_cb(event *ev) { neigh_mgr_logdbg(""); // Got event from netlink neigh_nl_event* nl_ev = dynamic_cast <neigh_nl_event*> (ev); BULLSEYE_EXCLUDE_BLOCK_START if (nl_ev == NULL) { neigh_mgr_logdbg("Non neigh_nl_event type"); return; } BULLSEYE_EXCLUDE_BLOCK_END const netlink_neigh_info* nl_info = nl_ev->get_neigh_info(); struct in_addr in; if (1 != inet_pton(AF_INET, (const char *)(nl_info->dst_addr_str.c_str()), &in)) { neigh_mgr_logdbg("Ignoring netlink neigh event neigh for IP = %s, not a valid IP", nl_info->dst_addr_str.c_str()); return; } in_addr_t neigh_ip = in.s_addr; // Search for this neigh ip in cache_table m_lock.lock(); net_device_val* p_ndev = g_p_net_device_table_mgr->get_net_device_val(nl_info->ifindex); //find all neigh entries with an appropriate peer_ip and net_device if (p_ndev) { neigh_entry *p_ne = dynamic_cast <neigh_entry *>(get_entry(neigh_key(ip_address(neigh_ip), p_ndev))); if (p_ne) { // Call the relevant neigh_entry to handle the event p_ne->handle_neigh_event(nl_ev); } else { neigh_mgr_logdbg("Ignoring netlink neigh event for IP = %s if:%s, index=%d, p_ndev=%p", nl_info->dst_addr_str.c_str(), p_ndev->to_str().c_str(), nl_info->ifindex, p_ndev); } } else { neigh_mgr_logdbg("could not find ndv_val for ifindex=%d", nl_info->ifindex); } m_lock.unlock(); return; }
int ip(char * Buffer,struct Global *g ) { int rc ; char arg0[80],arg1[80],arg2[80],arg3[80],arg4[80] ; bzero(arg1,sizeof(arg1)); bzero(arg2,sizeof(arg2)); bzero(arg3,sizeof(arg3)); sscanf(Buffer,"%s %s %s\n",arg1,arg2,arg3 ) ; if (!strcmp(arg2,"address") ) rc = ip_address(Buffer,g) ; else if (!strcmp(arg2,"route") ) rc = ip_route( Buffer, g) ; else { fprintf(stderr,"Erreur de syntaxe arg 2 ou arg3 \n" ) ; printf("Erreur de syntaxe arg 2 ou arg3\n") ; rc = 0 ; } return (rc) ; }
bool NetworkClient::Open(const str& local_address) { ScopeLock lock(&lock_); SendDisconnect(); Stop(); bool ok = !is_socket_connecting_; if (!ok) { log_.Warning("Already connecting (from some other thread?)..."); deb_assert(false); } SocketAddress _local_address; uint16 end_port = 0; if (ok) { ok = _local_address.ResolveRange(local_address, end_port); if (!ok) { log_.Warning("Unable to resolve public local address, network down?"); ok = true; uint8 ipv4[] = {0,0,0,0}; IPAddress ip_address(ipv4, sizeof(ipv4)); _local_address.Set(ip_address, 1025); end_port = 65534; } } if (ok) { //ScopeLock lock(&lock_); for (; _local_address.GetPort() <= end_port; _local_address.SetPort(_local_address.GetPort()+1)) { SetMuxSocket(new MuxSocket("Client ", _local_address, false)); if (mux_socket_->IsOpen()) { break; } delete (mux_socket_); mux_socket_ = 0; } ok = (mux_socket_ != 0); } return (ok); }
void igmp_mgr::process_igmp_packet(struct iphdr* p_ip_h, in_addr_t local_if) { igmp_mgr_logfunc(""); igmp_handler* p_igmp_hdlr = NULL; uint16_t ip_h_hdr_len = (int)(p_ip_h->ihl)*4; struct igmphdr* p_igmp_h = (struct igmphdr*)(((uint8_t*)p_ip_h) + ip_h_hdr_len); net_device_val* p_ndvl = g_p_net_device_table_mgr->get_net_device_val(local_if); BULLSEYE_EXCLUDE_BLOCK_START if (!p_ndvl){ igmp_mgr_logerr("Failed getting relevant net device"); return; } BULLSEYE_EXCLUDE_BLOCK_END igmp_key key(ip_address(p_igmp_h->group), p_ndvl); p_igmp_hdlr = get_igmp_handler(key, p_igmp_h->code); BULLSEYE_EXCLUDE_BLOCK_START if (!p_igmp_hdlr){ igmp_mgr_logerr("Failed getting relevant igmp_handler"); return; } BULLSEYE_EXCLUDE_BLOCK_END switch (p_igmp_h->type) { case IGMP_HOST_MEMBERSHIP_QUERY: p_igmp_hdlr->handle_query(p_igmp_h->code); break; case IGMP_HOST_MEMBERSHIP_REPORT: case IGMPV2_HOST_MEMBERSHIP_REPORT: p_igmp_hdlr->handle_report(); break; default: break; } }
host_entry::host_entry(struct hostent* __entry) { ufc_check_ptr (__entry); _name = __entry->h_name; char** alias = __entry->h_aliases; if (alias) { while (*alias) { _aliases.push_back(string(*alias)); ++alias; } } char** address = __entry->h_addr_list; if (address) { while (*address) { _addresses.push_back(ip_address(*address, __entry->h_length)); ++address; } } }
ip_address make_ip_address_any() { return ip_address(htonl(INADDR_ANY)); }
//--------------------------------------------------------------------------- void ribi::gtst::Test::TestParticipant() { //Create a GroupAssigner const int expected_group = 1 + (std::rand() % 256); boost::shared_ptr<GroupAssigner> group_assigner( new GroupAssignerPredetermined(expected_group)); { //Test the GroupAssigner /* for (int i=0; i!=10; ++i) { const int dummy_id = std::rand(); assert(group_assigner->Assign(dummy_id) == expected_group && "Assume GroupAssignerPredetermined always produces the same integer"); } */ } boost::shared_ptr<Participant> p( new Participant( //chat_tag, group_assigner,m_server)); { //assert(!p->CanGetGroup()); assert(!p->CanGetId()); assert(p->GetActions().empty()); assert(p->GetVotes().empty()); assert(!p->CanGetIpAddress()); } //Assign an ID { const int id = 1 + (std::rand() % 256); p->AssignId(id); assert(p->CanGetId()); assert(p->GetId() == id); } //Assign an IP address { boost::shared_ptr<SafeIpAddress> ip_address( new SafeIpAddress("123.123.123.123")); p->SetIpAddress(ip_address); assert(p->CanGetIpAddress()); assert(p->GetIpAddress()->Get() == ip_address.get()->Get()); } //Assign a group { //p->AssignGroup(); //assert(p->CanGetGroup()); //assert(p->GetGroup() == expected_group); } //Chat #1 { boost::shared_ptr<ChatMessage> chat_message( new ChatMessage( p, std::string("chat") + std::to_string(std::rand()))); assert(p->GetChatLog().empty()); //std::clog << "p has not yet chatted, not even close\n"; //assert(!p->HasChatted()); p->StartChat(); assert(!p->GetChatLog().empty()); assert(p->GetChatLog().back().empty()); //assert(!p->CanGetLastChat()); //std::clog << "p has not yet chatted\n"; //assert(!p->HasChatted()); p->AppendChat(chat_message); //assert(p->CanGetLastChat()); //std::clog << "p has chatted\n"; assert(!p->GetChatLog().empty()); assert(!p->GetChatLog().back().empty()); //assert(p->HasChatted()); //std::clog << "p should not have an empty chat log\n"; //assert(!p->GetLastChat().empty()); //std::clog << "p should not have a chat log with one message\n"; assert(p->GetChatLog().back().size() == 1); //std::clog << "p should not have a chat log with the one message chatted\n"; assert(p->GetChatLog().back()[0] == chat_message); } //Voting #1 { //const int vote = std::rand(); //assert(!p->CanGetLastVote()); //std::clog << "p has not yet voted, not even close\n"; //assert(p->HasVoted()); //p->StartVoting(); //assert(!p->CanGetLastVote()); //assert(!p->HasVoted()); assert(p->GetVotes().empty()); p->Vote(boost::shared_ptr<VotingOption>( new VotingOption(0.5,0.1,"Test"))); assert(!p->GetVotes().empty()); //assert(p->CanGetLastVote()); //assert(p->HasVoted()); //assert(p->GetLastVote() == vote); } //Choose action #1 /* { const int action = std::rand(); //assert(!p->CanGetLastAction()); //assert(p->HasChosenAction()); //p->StartChooseAction(); //assert(!p->CanGetLastAction()); //assert(!p->HasChosenAction()); assert(p->GetActions().empty()); p->ChooseAction(action); assert(!p->GetActions().empty()); //assert(p->CanGetLastAction()); //assert(p->HasChosenAction()); //assert(p->GetLastChosenAction() == action); } */ //Voting #2 { //const int vote = std::rand(); //assert(p->CanGetLastVote()); //assert(p->HasVoted()); //p->StartVoting(); //assert(p->CanGetLastVote()); //assert(!p->HasVoted()); p->Vote(boost::shared_ptr<VotingOption>( new VotingOption(0.5,0.1,"Test2"))); assert(p->GetVotes().size() == 2); //assert(p->CanGetLastVote()); //assert(p->HasVoted()); //assert(p->GetLastVote() == vote); } //Choose action #2 /* { const int action = std::rand(); //assert(p->CanGetLastAction()); //assert(p->HasChosenAction()); //p->StartChooseAction(); //assert(p->CanGetLastAction()); //assert(!p->HasChosenAction()); p->ChooseAction(action); assert(p->GetActions().size() == 2); //assert(p->CanGetLastAction()); //assert(p->HasChosenAction()); //assert(p->GetLastChosenAction() == action); } */ //Chat #2 { boost::shared_ptr<ChatMessage> chat_message( new ChatMessage( p, std::string("chat") + std::to_string(std::rand()))); //assert(p->CanGetLastChat()); //assert(p->HasChatted()); assert(p->GetChatLog().size() == 1); p->StartChat(); assert(p->GetChatLog().size() == 2); assert(p->GetChatLog().back().empty()); //assert(!p->CanGetLastChat()); //assert(!p->HasChatted()); p->AppendChat(chat_message); assert(!p->GetChatLog().back().empty()); //assert(p->CanGetLastChat()); //assert(p->HasChatted()); //assert(!p->GetLastChat().empty()); //assert(p->GetLastChat().size() == 1); assert(p->GetChatLog().back()[0] == chat_message); } ///Check the default Participant creation { boost::shared_ptr<Parameters> parameters( new Parameters(m_server)); boost::shared_ptr<Participant> p1 = parameters->CreateDefaultParticipant(); boost::shared_ptr<Participant> p2 = parameters->CreateDefaultParticipant(); assert(p1->GetChatShape() != p2->GetChatShape()); } }
static ip_address string_to_address(const std::string& addr) { int32 _addr = ::htonl(::inet_addr(addr.c_str())); return ip_address(_addr); }
route_table_mgr::route_table_mgr() : cache_table_mgr<ip_address,route_val*>("route_table_mgr") { rt_mgr_logdbg(""); m_pid = getpid(); m_buff_size = MSG_BUFF_SIZE; m_seq_num = 0; // Create Socket BULLSEYE_EXCLUDE_BLOCK_START if ((m_fd = orig_os_api.socket(PF_NETLINK, SOCK_DGRAM, NETLINK_ROUTE)) < 0) { rt_mgr_logerr("NL socket Creation: "); return; } BULLSEYE_EXCLUDE_BLOCK_END //save the routing table rt_mgr_update_tbl(); // create route_entry for each net_dev- needed for receiving port up/down events for net_dev_entry route_val *p_rtv; for (int i = 0; i < m_rt_tab.entries_num; i++) { p_rtv = &m_rt_tab.rtv[i]; in_addr_t src_addr = p_rtv->get_src_addr(); std::tr1::unordered_map<in_addr_t, route_entry*>::iterator iter = m_rte_list_for_each_net_dev.find(src_addr); // if src_addr of interface exists in the map, no need to create another route_entry if (iter == m_rte_list_for_each_net_dev.end()) { m_rte_list_for_each_net_dev.insert(pair<in_addr_t, route_entry*> (src_addr, create_new_entry(ip_address(src_addr), NULL))); } } print_route_tbl(); // register to netlink event g_p_netlink_handler->register_event(nlgrpROUTE, this); rt_mgr_logdbg("Registered to g_p_netlink_handler"); rt_mgr_logdbg("Done"); }
net_device_entry::net_device_entry(in_addr_t local_ip, net_device_val* ndv) : cache_entry_subject<ip_address,net_device_val*>(ip_address(local_ip)) { nde_logdbg(""); m_val = ndv; m_is_valid = false; m_cma_id_bind_trial_count = 0; m_timer_handle = NULL; timer_count = -1; m_bond = net_device_val::NO_BOND; BULLSEYE_EXCLUDE_BLOCK_START if (!m_val) { nde_logdbg("ERROR: received m_val = NULL"); return; } BULLSEYE_EXCLUDE_BLOCK_END m_is_valid = true; m_bond = ndv->get_is_bond(); if(m_bond != net_device_val::NO_BOND) { m_timer_handle = g_p_event_handler_manager->register_timer_event(SLAVE_CHECK_TIMER_PERIOD_MSEC, this, PERIODIC_TIMER, 0); } if(ndv->get_is_bond() == net_device_val::LAG_8023ad) { ndv->register_to_ibverbs_events(this); } nde_logdbg("Done"); }
///Parse a line in a Parameter file. void ribi::gtst::Parameters::Parse(const std::string& s) { if (s.empty()) return; if (s.size() > 0 && s.substr(0,1) == "#") return; if (s.size() > 1 && s.substr(0,2) == "//") return; ///Parameters starting with finished_ are parsed by ParametersFinished if (s.size() > 9 && s.substr(0,9) == "finished_") { const std::string t = s.substr(9,s.size()-9); this->GetFinished()->Parse(t); return; } ///Parameters starting with finished_ are parsed by ParametersGroupReAssign if (s.size() > 13 && s.substr(0,13) == "group_assign_") { const std::string t = s.substr(13,s.size()-13); this->GetGroupAssign()->Parse(t); return; } ///Parameters starting with finished_ are parsed by ParametersGroupReAssign if (s.size() > 15 && s.substr(0,15) == "group_reassign_") { const std::string t = s.substr(15,s.size()-15); this->GetGroupReAssign()->Parse(t); return; } ///Parameters starting with finished_ are parsed by ParametersGroupReAssign if (s.size() > 14 && s.substr(0,14) == "assign_payoff_") { const std::string t = s.substr(14,s.size()-14); this->GetAssignPayoff()->Parse(t); return; } ///Parameters starting with finished_ are parsed by ParametersViewResultsGroup if (s.size() > 20 && s.substr(0,20) == "view_results_voting_") { const std::string t = s.substr(20,s.size()-20); this->GetViewResultsVoting()->Parse(t); return; } ///Parameters starting with finished_ are parsed by ParametersViewResultsGroup if (s.size() > 19 && s.substr(0,19) == "view_results_group_") { const std::string t = s.substr(19,s.size()-19); this->GetViewResultsGroup()->Parse(t); return; } ///Parameters starting with finished_ are parsed by ParametersViewResultsGroup if (s.size() > 14 && s.substr(0,14) == "assign_payoff_") { const std::string t = s.substr(14,s.size()-14); this->GetAssignPayoff()->Parse(t); return; } if (s.size() > 14 && s.substr(0,14) == "choose_action_") { const std::string t = s.substr(14,s.size()-14); this->GetChooseAction()->Parse(t); return; } if (s.size() > 5 && s.substr(0,5) == "chat_") { const std::string t = s.substr(5,s.size()-5); this->GetChat()->Parse(t); return; } if (s.size() > 7 && s.substr(0,7) == "voting_") { const std::string t = s.substr(7,s.size()-7); this->GetVoting()->Parse(t); return; } //Participants if (s.size() > 12 && s.substr(0,12) == "participant=") { const std::string t = s.substr(12,s.size() - 12); const std::vector<std::string> v = SeperateString(t,','); if (v.size() != 2) { throw std::runtime_error((std::string("Incorrectly formed participant line: ") + s).c_str());; } assert(v.size() == 2 && "Participant must have two elements"); boost::shared_ptr<GroupAssigner> group_assigner = GroupAssigner::CreateAssigner(v[0]); const std::string ip_address_str = v[1]; boost::shared_ptr<Participant> participant( new Participant(group_assigner,m_server) ); if (ip_address_str!="*") { try { boost::shared_ptr<SafeIpAddress> ip_address(new SafeIpAddress(ip_address_str)); participant->SetIpAddress(ip_address); } catch (std::logic_error&) { throw std::runtime_error((std::string("Incorrectly formed IP address: ") + ip_address_str).c_str()); } } m_participants.push_back(participant); return; } throw std::runtime_error((std::string("Unparsable parameter file line: ") + s).c_str()); }