bool IsIPAddrInNetwork(ACE_INET_Addr const& net, ACE_INET_Addr const& addr, ACE_INET_Addr const& subnetMask) { uint32 mask = subnetMask.get_ip_address(); if ((net.get_ip_address() & mask) == (addr.get_ip_address() & mask)) return true; return false; }
int CACETrbNetAcceptorImpl::validate_connection( const TRB_Asynch_Accept::Result& result, const ACE_INET_Addr& remote, const ACE_INET_Addr& local) { SInetAddress remote1; SInetAddress local1; local1.ip = local.get_ip_address(); local1.port = local.get_port_number(); remote1.ip = remote.get_ip_address(); remote1.port = remote.get_port_number(); INetAcceptor* acceptor = getAcceptor(); if (!acceptor) { return -1; } //to check and block ip if (!acceptor->onCheckAddress(local1, remote1)) { return -1; } return 0; }
// static DeviceProxy * DeviceProxy::check_hello_and_create( ACE_Message_Block * mb , const ACE_INET_Addr& from_addr , Task * task ) { adportable::protocol::LifeCycleData data; adportable::protocol::LifeCycleFrame frame; if ( acewrapper::lifecycle_frame_serializer::unpack( mb, frame, data ) ) { try { using namespace adportable::protocol; LifeCycle_Hello& hello = boost::get< LifeCycle_Hello& >(data); ACE_INET_Addr addr; addr.string_to_addr( hello.ipaddr_.c_str() ); if ( addr.get_ip_address() == 0 ) { addr = from_addr; addr.set_port_number( hello.portnumber_ ); DeviceProxy * p = new DeviceProxy( addr, task ); p->initialize_dgram(); p->handle_lifecycle_mcast( frame, data ); #if defined _DEBUG // std::wstring key = adportable::string::convert( acewrapper::string( from_addr ) ); std::wstring text = adportable::string::convert( LifeCycleHelper::to_string( data ) ); task->dispatch_debug( text, p->name() ); #endif return p; // error should be handled by caller } } catch ( std::bad_cast& ) { } } return 0; }
int ACE_MEM_Addr::same_host (const ACE_INET_Addr &sap) { ACE_TRACE ("ACE_MEM_Addr::same_host"); return this->external_.get_ip_address () == sap.get_ip_address (); }
/** * Receiver::handle_input() * * Description: * Called when input is available */ int Receiver::handle_input() { if (connected_) { // TODO: Check if really needed! (Try not to read all data from socket) Miro::Guard guard(mutex_); /* needed for timeout handling */ CORBA::ULong header[HEADER_SIZE / sizeof(CORBA::ULong) + ACE_CDR::MAX_ALIGNMENT]; EventData eventData; iovec iov[1]; ACE_INET_Addr from; switch (receiveData(iov, from)) { case -1: PRINT_DBG(DBG_INFO, "handleInput: read"); return -1; case 0: PRINT_DBG(DBG_INFO, "handleInput: read 0"); return 0; default: /* fall through */ break; } /* Check if paket was sent locally and if so, drop it */ if (is_loopback(from)) return 0; //#if DEBUG_LEVEL == DBG_TOOMUCH struct in_addr ia; ia.s_addr = htonl(from.get_ip_address()); PRINT("Datagram from " << inet_ntoa(ia) << ":" << from.get_port_number()); //#endif /* Process packet */ memcpy(header, ((char *)iov[0].iov_base ), sizeof(header)); char *buf = ACE_reinterpret_cast(char *, header); TAO_InputCDR headerCdr(buf, sizeof(header), (int)buf[0]); eventData.systemTimestamp = ACE_OS::gettimeofday().msec(); headerCdr.read_boolean(eventData.byteOrder); headerCdr.read_ulong(eventData.requestId); headerCdr.read_ulong(eventData.requestSize); headerCdr.read_ulong(eventData.fragmentSize); headerCdr.read_ulong(eventData.fragmentOffset); headerCdr.read_ulong(eventData.fragmentId); headerCdr.read_ulong(eventData.fragmentCount); headerCdr.read_ulong(eventData.timestamp); cout << "test" << endl; handle_event(eventData, iov); } return 0; }
void TAO_UIPMC_Endpoint::object_addr (const ACE_INET_Addr &addr) { this->port_ = addr.get_port_number(); char tmp[INET6_ADDRSTRLEN]; addr.get_host_addr (tmp, sizeof tmp); this->host_ = CORBA::string_dup (tmp); this->object_addr_.set (addr); this->uint_ip_addr (addr.get_ip_address ()); }
int ACE_MEM_Addr::same_host (const ACE_INET_Addr &sap) { ACE_TRACE ("ACE_MEM_Addr::same_host"); ACE_UINT32 me = this->external_.get_ip_address (); ACE_UINT32 you = sap.get_ip_address (); return me == you; }
int HDS_UDP_EXPORT_API send(ACE_Message_Block * block , ACE_INET_Addr& ace_addr , HDS_UDP_SENDED_DEL_TYPE del_type) { SOCKADDR_IN remoteAddr; remoteAddr.sin_family=AF_INET; //这个值对以后会有影响 remoteAddr.sin_addr.s_addr=htonl(ace_addr.get_ip_address());// ace_remoteAddr.get_ip_address(); remoteAddr.sin_port=htons(ace_addr.get_port_number());//ace_remoteAddr.get_port_number(); int res = kernel_send(block->rd_ptr(),block->length(),0,(sockaddr*)&remoteAddr,sizeof(SOCKADDR_IN)); if(del_type == DELETE_AFTER_SEND) { block->release(); } return res; }
//************************************ // Method: connect // FullName: PeerConnector::connect // Access: public // Returns: void // Qualifier: 此方法将remote_addr_作为主键,mb_作为值压入map_中。 // Parameter: ACE_INET_Addr &remote_addr_ // Parameter: ACE_Message_Block *mb_ //************************************ int PeerConnector::make_connect(PeerID peerId, ACE_INET_Addr &remote_addr_,ACE_Message_Block *mb_ ) { ACE_Guard<ACE_Thread_Mutex> guard(mutex_); PeerInfoPtr pinfo = new PeerInfo(); pinfo->peerId_ = peerId; pinfo->address_ = remote_addr_.get_ip_address(); pinfo->mb_ = mb_; map_.insert(map<ACE_UINT32,PeerInfoPtr>::value_type(pinfo->address_,pinfo)); int iret =connect(remote_addr_); if(iret != 0) { iret = ACE_OS::last_error(); } return iret; }
/*virtual*/ int BufferedSocket::open(void* arg) { if (Base::open(arg) == -1) return -1; ACE_INET_Addr addr; if (peer().get_remote_addr(addr) == -1) return -1; // <anti DDoS> by boxa uint32 uintAddr = addr.get_ip_address(); if (!uintAddr) return -1; time_t currTime = time(NULL); if (!sIpListStorage.empty()) { // first del expired records for (TIpList::iterator itr = sIpListStorage.begin(); itr != sIpListStorage.end();) { if (itr->second < currTime) sIpListStorage.erase(itr++); else ++itr; } // then search current connected ip TIpList::const_iterator itr = sIpListStorage.find(uintAddr); if (itr != sIpListStorage.end()) return -1; } // add new ip addr into ip list sIpListStorage[uintAddr] = currTime; // </anti DDoS> char address[1024]; addr.get_host_addr(address, 1024); this->remote_address_ = address; this->OnAccept(); return 0; }
int ACE_SOCK_Dgram_Mcast::make_multicast_ifaddr (ip_mreq *ret_mreq, const ACE_INET_Addr &mcast_addr, const ACE_TCHAR *net_if) { ACE_TRACE ("ACE_SOCK_Dgram_Mcast::make_multicast_ifaddr"); ip_mreq lmreq; // Scratch copy. if (net_if != 0) { #if defined (ACE_WIN32) || defined(__INTERIX) // This port number is not necessary, just convenient ACE_INET_Addr interface_addr; if (interface_addr.set (mcast_addr.get_port_number (), net_if) == -1) return -1; lmreq.imr_interface.s_addr = ACE_HTONL (interface_addr.get_ip_address ()); #else ifreq if_address; #if defined (ACE_PSOS) // Look up the interface by number, not name. if_address.ifr_ifno = ACE_OS::atoi (net_if); #else ACE_OS::strcpy (if_address.ifr_name, ACE_TEXT_ALWAYS_CHAR (net_if)); #endif /* defined (ACE_PSOS) */ if (ACE_OS::ioctl (this->get_handle (), SIOCGIFADDR, &if_address) == -1) return -1; sockaddr_in *socket_address; socket_address = reinterpret_cast<sockaddr_in*> (&if_address.ifr_addr); lmreq.imr_interface.s_addr = socket_address->sin_addr.s_addr; #endif /* ACE_WIN32 || __INTERIX */ } else lmreq.imr_interface.s_addr = INADDR_ANY; lmreq.IMR_MULTIADDR.s_addr = ACE_HTONL (mcast_addr.get_ip_address ()); // Set return info, if requested. if (ret_mreq) *ret_mreq = lmreq; return 0; }
int TAO_AV_SCTP_SEQ_Base_Acceptor::acceptor_open (TAO_AV_SCTP_SEQ_Acceptor *acceptor, ACE_Reactor *reactor, const ACE_INET_Addr &local_addr, TAO_FlowSpec_Entry *entry) { ORBSVCS_DEBUG ((LM_DEBUG, "In base acceptor open")); this->acceptor_ = acceptor; this->reactor_ = reactor; this->entry_ = entry; ACE_Auto_Array_Ptr<ACE_UINT32> local_ip_addr (new ACE_UINT32[entry->num_local_sec_addrs ()]); ACE_INET_Addr ip_addr; char** addrs = entry->get_local_sec_addr (); for (int i = 0; i < entry->num_local_sec_addrs (); i++) { ACE_CString addr_str (addrs[i]); addr_str += ":"; ip_addr.set (addr_str.c_str ()); local_ip_addr[i] = ip_addr.get_ip_address (); } ACE_Multihomed_INET_Addr multi_addr; multi_addr.set (local_addr.get_port_number (), local_addr.get_ip_address (), 1, local_ip_addr.get(), entry->num_local_sec_addrs ()); char buf[BUFSIZ]; multi_addr.addr_to_string (buf, BUFSIZ); if (TAO_debug_level > 0) ORBSVCS_DEBUG ((LM_DEBUG, "TAO_AV_SCTP_SEQ_Base_Acceptor::open: %s", buf)); if (this->open (multi_addr,reactor) < 0) ORBSVCS_ERROR_RETURN ((LM_ERROR,"TAO_AV_SCTP_SEQ_Base_Acceptor::open failed\n"),-1); return 0; }
SimpleAddressServer::SimpleAddressServer (const ACE_INET_Addr& address) { #if defined (ACE_HAS_IPV6) if (address.get_type() == PF_INET6) { RtecUDPAdmin::UDP_Addr_v6 v6; sockaddr_in6 *in6 = reinterpret_cast<sockaddr_in6 *>(address.get_addr()); ACE_OS::memcpy (v6.ipaddr,&in6->sin6_addr,16); v6.port = address.get_port_number(); this->address_.v6_addr (v6); return; } #endif /* ACE_HAS_IPV6 */ RtecUDPAdmin::UDP_Addr v4; v4.ipaddr = address.get_ip_address (); v4.port = address.get_port_number (); this->address_.v4_addr (v4); }
int HDS_UDP_EXPORT_API R_Send( char *block, unsigned int length, ACE_INET_Addr & ace_addr, Connection_ID&con_id, HDS_UDP_SENDED_DEL_TYPE del_type, HDS_UDP_Sender_Handler handler, unsigned long defaultSSTHRESH, unsigned long maxWindowSize) { SOCKADDR_IN remoteAddr; remoteAddr.sin_family=AF_INET; //这个值对以后会有影响 remoteAddr.sin_addr.s_addr=htonl(ace_addr.get_ip_address());// ace_remoteAddr.get_ip_address(); remoteAddr.sin_port=htons(ace_addr.get_port_number());//ace_remoteAddr.get_port_number(); return connection::start_sender(NULL,block,length,(sockaddr*)&remoteAddr,sizeof(SOCKADDR_IN), &con_id,del_type,handler,defaultSSTHRESH,maxWindowSize); }
// constructor net_ace::net_ace (uint16_t port) :_port_self (port), _up_cond (NULL), _down_cond (NULL), _acceptor (NULL) { // necessary when using ACE within WinMain to avoid crash ACE::init (); // get hostname _hostname[0] = 0; _IPaddr[0] = 0; // NEW_THREAD will be created (ACE_OS called for 1st time?) ACE_OS::hostname (_hostname, 255); _udphandler = NULL; printf ("net_ace::net_ace(): Host IP: %s\n", getIPFromHost ()); ACE_INET_Addr addr (_port_self, getIPFromHost ()); // TODO: necessary here? actual port might be different and correct one // is set in svc () // reason is that when VASTVerse is created, it needs to find out / resolve // actual address for gateway whose IP is "127.0.0.1" _self_addr.setPublic ((uint32_t)addr.get_ip_address (), (uint16_t)addr.get_port_number ()); //_self_addr.setPublic ((uint32_t)addr.get_ip_address (), 0); /* // self-determine preliminary hostID first _self_addr.host_id = this->resolveHostID (&_self_addr.publicIP); */ // set the conversion rate between seconds and timestamp unit // for net_ace it's 1000 timestamp units = 1 second (each step is 1 ms) _sec2timestamp = 1000; }
bool ACE_INET_Addr::is_ip_equal (const ACE_INET_Addr &sap) const { if (this->get_type () != sap.get_type () || this->get_size () != sap.get_size ()) return false; #if defined (ACE_HAS_IPV6) if (this->get_type () == PF_INET6) { const unsigned int *addr = reinterpret_cast<const unsigned int*>(this->ip_addr_pointer()); const unsigned int *saddr = reinterpret_cast<const unsigned int*>(sap.ip_addr_pointer()); return (addr[0] == saddr[0] && addr[1] == saddr[1] && addr[2] == saddr[2] && addr[3] == saddr[3]); } else #endif /* ACE_HAS_IPV6 */ return this->get_ip_address () == sap.get_ip_address(); }
int run_main (int argc, ACE_TCHAR *argv[]) { ACE_UNUSED_ARG (argc); ACE_UNUSED_ARG (argv); ACE_START_TEST (ACE_TEXT ("INET_Addr_Test")); int status = 0; // Innocent until proven guilty const char *ipv4_addresses[] = { "127.0.0.1", "138.38.180.251", "64.219.54.121", "192.0.0.1", "10.0.0.1", 0 }; ACE_INET_Addr addr; status |= check_type_consistency (addr); char hostaddr[1024]; for (int i=0; ipv4_addresses[i] != 0; i++) { struct in_addr addrv4; ACE_UINT32 addr32; ACE_OS::inet_pton (AF_INET, ipv4_addresses[i], &addrv4); ACE_OS::memcpy (&addr32, &addrv4, sizeof (addr32)); addr.set (80, ipv4_addresses[i]); status |= check_type_consistency (addr); /* ** Now check to make sure get_ip_address matches and get_host_addr ** matches. */ if (addr.get_ip_address () != ACE_HTONL (addr32)) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Error: %s failed get_ip_address() check\n") ACE_TEXT ("0x%x != 0x%x\n"), ipv4_addresses[i], addr.get_ip_address (), addr32)); status = 1; } if (addr.get_host_addr () != 0 && ACE_OS::strcmp (addr.get_host_addr(), ipv4_addresses[i]) != 0) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("%s failed get_host_addr() check\n") ACE_TEXT ("%s != %s\n"), ipv4_addresses[i], addr.get_host_addr (), ipv4_addresses[i])); status = 1; } // Now we check the operation of get_host_addr(char*,int) const char* haddr = addr.get_host_addr (&hostaddr[0], sizeof(hostaddr)); if (haddr != 0 && ACE_OS::strcmp (&hostaddr[0], haddr) != 0) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("%s failed get_host_addr(char* buf,int) check\n") ACE_TEXT ("buf ['%s'] != return value ['%s']\n"), ipv4_addresses[i], &hostaddr[0], haddr)); status = 1; } if (ACE_OS::strcmp (&hostaddr[0], ipv4_addresses[i]) != 0) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("%s failed get_host_addr(char*,int) check\n") ACE_TEXT ("buf ['%s'] != expected value ['%s']\n"), ipv4_addresses[i], &hostaddr[0], ipv4_addresses[i])); status = 1; } // Clear out the address by setting it to 1 and check addr.set (0, ACE_UINT32 (1), 1); status |= check_type_consistency (addr); if (addr.get_ip_address () != 1) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Failed to set address to 1\n"))); status = 1; } // Now set the address using a 32 bit number and check that we get // the right string out of get_host_addr(). addr.set (80, addr32, 0); // addr32 is already in network byte order status |= check_type_consistency(addr); if (addr.get_host_addr () != 0 && ACE_OS::strcmp (addr.get_host_addr (), ipv4_addresses[i]) != 0) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("%s failed second get_host_addr() check\n") ACE_TEXT ("return value ['%s'] != expected value ['%s']\n"), ipv4_addresses[i], addr.get_host_addr (), ipv4_addresses[i])); status = 1; } // Test for ACE_INET_Addr::set_addr(). struct sockaddr_in sa4; sa4.sin_family = AF_INET; sa4.sin_addr = addrv4; sa4.sin_port = ACE_HTONS (8080); addr.set (0, ACE_UINT32 (1), 1); addr.set_addr (&sa4, sizeof(sa4)); status |= check_type_consistency (addr); if (addr.get_port_number () != 8080) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("ACE_INET_Addr::set_addr() ") ACE_TEXT ("failed to update port number.\n"))); status = 1; } if (addr.get_ip_address () != ACE_HTONL (addr32)) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("ACE_INET_Addr::set_addr() ") ACE_TEXT ("failed to update address.\n"))); status = 1; } } #if defined (ACE_HAS_IPV6) if (ACE::ipv6_enabled ()) { const char *ipv6_addresses[] = { "1080::8:800:200c:417a", // unicast address "ff01::101", // multicast address "::1", // loopback address "::", // unspecified addresses 0 }; for (int i=0; ipv6_addresses[i] != 0; i++) { ACE_INET_Addr addr (80, ipv6_addresses[i]); status |= check_type_consistency (addr); if (0 != ACE_OS::strcmp (addr.get_host_addr (), ipv6_addresses[i])) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("IPv6 get_host_addr failed: %s != %s\n"), addr.get_host_addr (), ipv6_addresses[i])); status = 1; } } } #endif struct Address loopback_addresses[] = { {"127.0.0.1", true}, {"127.1.2.3", true} , {"127.0.0.0", true}, {"127.255.255.255", true} , {"126.255.255.255", false}, {"128.0.0.0", false}, {0, true} }; for (int i=0; loopback_addresses[i].name != 0; i++) { struct in_addr addrv4; ACE_UINT32 addr32 = 0; ACE_OS::inet_pton (AF_INET, loopback_addresses[i].name, &addrv4); ACE_OS::memcpy (&addr32, &addrv4, sizeof (addr32)); addr.set (80, loopback_addresses[i].name); if (addr.is_loopback() != loopback_addresses[i].loopback) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("ACE_INET_Addr::is_loopback() ") ACE_TEXT ("failed to distinguish loopback address. %s\n") , loopback_addresses[i].name)); status = 1; } } ACE_END_TEST; return status; }
int ACE_SOCK_Dgram_Mcast::join (const ACE_INET_Addr &mcast_addr, int reuse_addr, const ACE_TCHAR *net_if) { ACE_TRACE ("ACE_SOCK_Dgram_Mcast::join"); ACE_INET_Addr subscribe_addr = mcast_addr; // If port# is 0, insert bound port# if it is set. (To satisfy lower-level // port# validation.) u_short def_port_number = this->send_addr_.get_port_number (); if (subscribe_addr.get_port_number () == 0 && def_port_number != 0) { subscribe_addr.set_port_number (def_port_number); } // Check for port# different than bound port#. u_short sub_port_number = mcast_addr.get_port_number (); if (sub_port_number != 0 && def_port_number != 0 && sub_port_number != def_port_number) { ACE_ERROR ((LM_ERROR, ACE_LIB_TEXT ("Subscribed port# (%u) different than bound ") ACE_LIB_TEXT ("port# (%u).\n"), (u_int) sub_port_number, (u_int) def_port_number)); errno = ENXIO; return -1; } // If bind_addr_opt_ is enabled, check for address different than // bound address. #if defined (__linux__) && defined (ACE_HAS_IPV6) if (ACE_BIT_ENABLED (this->opts_, OPT_BINDADDR_YES) && ((this->send_addr_.get_type () == AF_INET && this->send_addr_.get_ip_address () != INADDR_ANY && this->send_addr_.get_ip_address () != mcast_addr.get_ip_address ()) || (this->send_addr_.get_type () == AF_INET6 && ACE_OS::memcmp (&((sockaddr_in6 *) this->send_addr_.get_addr ())->sin6_addr, &in6addr_any, sizeof (in6_addr)) != 0 && ACE_OS::memcmp (&((sockaddr_in6 *) this->send_addr_.get_addr ())->sin6_addr, &((sockaddr_in6 *) mcast_addr.get_addr ())->sin6_addr, sizeof (in6_addr)) != 0))) #else if (ACE_BIT_ENABLED (this->opts_, OPT_BINDADDR_YES) && this->send_addr_.get_ip_address () != INADDR_ANY && this->send_addr_.get_ip_address () != mcast_addr.get_ip_address ()) #endif /* __linux__ && ACE_HAS_IPV6 */ { ACE_TCHAR sub_addr_string[MAXNAMELEN + 1]; ACE_TCHAR bound_addr_string[MAXNAMELEN + 1]; ACE_SDM_helpers::addr_to_string (mcast_addr, sub_addr_string, sizeof sub_addr_string, 1); ACE_SDM_helpers::addr_to_string (this->send_addr_, bound_addr_string, sizeof bound_addr_string, 1); ACE_ERROR ((LM_ERROR, ACE_LIB_TEXT ("Subscribed address (%s) different than ") ACE_LIB_TEXT ("bound address (%s).\n"), sub_addr_string, bound_addr_string)); errno = ENXIO; return -1; } // Attempt subscription. int result = this->subscribe_i (subscribe_addr, reuse_addr, net_if); #if defined (ACE_SOCK_DGRAM_MCAST_DUMPABLE) if (result == 0) { // Add this addr/iface info to the list of subscriptions. // (Assumes this is unique addr/iface combo - most systems don't allow // re-sub to same addr/iface.) ip_mreq *pmreq = new ip_mreq; // (should not fail) if (this->make_multicast_ifaddr (pmreq, subscribe_addr, net_if) != -1) { ACE_MT (ACE_GUARD_RETURN (ACE_SDM_LOCK, guard, this->subscription_list_lock_, -1)); this->subscription_list_.insert_tail (pmreq); return 0; } // this still isn't really right. If ACE_GUARD_RETURN fails, we leak. // Need to add one of Chris' fancy ace auto pointers (bound?). delete pmreq; } #endif /* ACE_SOCK_DGRAM_MCAST_DUMPABLE */ return result >= 0 ? 0 : result; }
// service method int net_ace:: svc (void) { // NEW_THREAD net_ace runs as ACE_TASK _reactor = new ACE_Reactor; _acceptor = new net_ace_acceptor (this); ACE_INET_Addr addr (_port_self, getIPFromHost ()); printf ("net_ace::svc () default port: %d\n", _port_self); // obtain a valid server TCP listen port while (true) { // NEW_THREAD (ACE_DEBUG called for 1st time?) ACE_DEBUG ((LM_DEBUG, "(%5t) attempting to start server at %s:%d\n", addr.get_host_addr (), addr.get_port_number ())); if (_acceptor->open (addr, _reactor) == 0) break; _port_self++; addr.set_port_number (_port_self); } ACE_DEBUG ((LM_DEBUG, "net_ace::svc () called. actual port binded: %d\n", _port_self)); // create new handler for listening to UDP packets // NEW_THREAD will be created (new handler that will listen to port?) ACE_NEW_RETURN (_udphandler, net_ace_handler, -1); _udp = _udphandler->openUDP (addr); _udphandler->open (_reactor, this); // NOTE: this is a private IP, publicIP is obtained from server // register my own address _self_addr.setPublic ((uint32_t)addr.get_ip_address (), (uint16_t)addr.get_port_number ()); // self-determine preliminary hostID first _self_addr.host_id = this->resolveHostID (&_self_addr.publicIP); // wait a bit to avoid signalling before the main thread tries to wait ACE_Time_Value sleep_interval (0, 200000); ACE_OS::sleep (sleep_interval); // continue execution of original thread in open() _up_cond->signal (); // enter into event handling state while (_active) { _reactor->handle_events(); } ACE_DEBUG ((LM_DEBUG, "(%5t) net_ace::svc () leaving event handling loop\n")); _reactor->remove_handler (_acceptor, ACE_Event_Handler::DONT_CALL); // NOTE: _acceptor will be deleted when reactor is deleted as one of its // event handlers if (_reactor != NULL) { _reactor->close (); delete _reactor; _reactor = NULL; // NOTE: acceptor is self deleted when its handle_close () is called by reactor, // so no need to delete again here _acceptor = NULL; } // wait a bit to avoid signalling before the main thread tries to wait ACE_OS::sleep (sleep_interval); // continue execution of original thread in close() // to ensure that svc () will exit if (_down_cond != NULL) _down_cond->signal (); return 0; }
/** * Receiver::isLoopback() * * Description: * Check if address (_from) is local * * Parameters: * _from: address to check */ bool Receiver::is_loopback(const ACE_INET_Addr &_from) { return (localIPs_.find(_from.get_ip_address()) != localIPs_.end()); }
int TAO_AV_SCTP_SEQ_Connector::connect (TAO_FlowSpec_Entry *entry, TAO_AV_Transport *&transport, TAO_AV_Core::Flow_Component flow_comp) { this->entry_ = entry; if (flow_comp == TAO_AV_Core::TAO_AV_CONTROL) this->flowname_ = TAO_AV_Core::get_control_flowname (entry->flowname ()); else this->flowname_ = entry->flowname (); ACE_Addr *remote_addr = entry->address (); ACE_INET_Addr *inet_addr = dynamic_cast<ACE_INET_Addr *> (remote_addr); TAO_AV_SCTP_SEQ_Flow_Handler *handler = 0; ACE_Multihomed_INET_Addr remote_multi_addr; remote_multi_addr.set (inet_addr->get_port_number (), inet_addr->get_ip_address (), 1, 0, 0); ACE_Multihomed_INET_Addr local_addr; //This can be a multihomed address ACE_INET_Addr *addr; if (entry->get_peer_addr () != 0) { addr = dynamic_cast<ACE_INET_Addr *> (entry->get_peer_addr ()); } else { ACE_NEW_RETURN (addr, ACE_INET_Addr ("0"), -1); } ACE_Auto_Array_Ptr<ACE_UINT32> local_ip_addr (new ACE_UINT32[entry->num_peer_sec_addrs ()]); ACE_INET_Addr ip_addr; char** addrs = entry->get_peer_sec_addr (); for (int i = 0; i < entry->num_peer_sec_addrs (); i++) { ACE_CString addr_str (addrs[i]); addr_str += ":"; ip_addr.set (addr_str.c_str ()); local_ip_addr[i] = ip_addr.get_ip_address (); } if (entry->num_peer_sec_addrs () != 0) local_addr.set (addr->get_port_number (), addr->get_ip_address (), 1, local_ip_addr.get(), entry->num_peer_sec_addrs ()); else local_addr.set (addr->get_port_number (), addr->get_ip_address (), 1, 0, entry->num_peer_sec_addrs ()); int result = this->connector_.connector_connect (handler, remote_multi_addr, local_addr); if (result < 0) ORBSVCS_ERROR_RETURN ((LM_ERROR,"TAO_AV_SCTP_SEQ_connector::connect failed\n"),-1); entry->handler (handler); transport = handler->transport (); if (TAO_debug_level > 0) { ORBSVCS_DEBUG ((LM_DEBUG, "Local Addrs\n")); char buf [BUFSIZ]; size_t size = BUFSIZ; ACE_INET_Addr *peer_addrs = 0; ACE_NEW_RETURN (peer_addrs,ACE_INET_Addr [size], -1); handler->peer ().get_local_addrs (peer_addrs, size); for (unsigned int i=0; i < size; i++) { peer_addrs [i].addr_to_string (buf, BUFSIZ); ORBSVCS_DEBUG ((LM_DEBUG, "%s %d\n", buf, size)); } ORBSVCS_DEBUG ((LM_DEBUG, "Remote Addrs\n")); size = BUFSIZ; handler->peer ().get_remote_addrs (peer_addrs, size); for (unsigned int i=0; i < size; i++) { peer_addrs [i].addr_to_string (buf, BUFSIZ); ORBSVCS_DEBUG ((LM_DEBUG, "%s %d\n", buf, size)); } //delete peer_addrs; } return 0; }
int run_main (int, ACE_TCHAR *[]) { ACE_START_TEST (ACE_TEXT ("INET_Addr_Test")); int status = 0; // Innocent until proven guilty // Try to set up known IP and port. u_short port (80); ACE_UINT32 const ia_any = INADDR_ANY; ACE_INET_Addr local_addr(port, ia_any); status |= check_type_consistency (local_addr); if (local_addr.get_port_number () != 80) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Got port %d, expecting 80\n"), (int)(local_addr.get_port_number ()))); status = 1; } if (local_addr.get_ip_address () != ia_any) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Mismatch on local IP addr\n"))); status = 1; } // Assignment constructor ACE_INET_Addr local_addr2 (local_addr); status |= check_type_consistency (local_addr2); if (local_addr2.get_port_number () != 80) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Copy got port %d, expecting 80\n"), (int)(local_addr2.get_port_number ()))); status = 1; } if (local_addr2.get_ip_address () != ia_any) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Mismatch on copy local IP addr\n"))); status = 1; } if (local_addr != local_addr2) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Copy local addr mismatch\n"))); status = 1; } // Try to parse out a simple address:port string. Intentionally reuse // the ACE_INET_Addr to ensure resetting an address works. const char *addr_ports[] = { "127.0.0.1:80", "www.dre.vanderbilt.edu:80", 0 }; ACE_INET_Addr addr_port; for (int i = 0; addr_ports[i] != 0; ++i) { if (addr_port.set (addr_ports[i]) == 0) { status |= check_type_consistency (addr_port); if (addr_port.get_port_number () != 80) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Got port %d from %s\n"), (int)(addr_port.get_port_number ()), addr_ports[i])); status = 1; } ACE_INET_Addr check (addr_ports[i]); if (addr_port != check) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Reset on iter %d failed\n"), i)); status = 1; } } else { // Sometimes this fails because the run-time host lacks the capability to // resolve a name. But it shouldn't fail on the first one, 127.0.0.1. if (i == 0) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("%C: %p\n"), addr_ports[i], ACE_TEXT ("lookup"))); status = 1; } else { ACE_ERROR ((LM_WARNING, ACE_TEXT ("%C: %p\n"), addr_ports[i], ACE_TEXT ("lookup"))); } } } const char *ipv4_addresses[] = { "127.0.0.1", "138.38.180.251", "64.219.54.121", "192.0.0.1", "10.0.0.1", 0 }; ACE_INET_Addr addr; status |= check_type_consistency (addr); char hostaddr[1024]; for (int i=0; ipv4_addresses[i] != 0; i++) { struct in_addr addrv4; ACE_OS::memset ((void *) &addrv4, 0, sizeof addrv4); ACE_UINT32 addr32; ACE_OS::inet_pton (AF_INET, ipv4_addresses[i], &addrv4); ACE_OS::memcpy (&addr32, &addrv4, sizeof (addr32)); status |= !(addr.set (80, ipv4_addresses[i]) == 0); status |= check_type_consistency (addr); /* ** Now check to make sure get_ip_address matches and get_host_addr ** matches. */ if (addr.get_ip_address () != ACE_HTONL (addr32)) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Error: %C failed get_ip_address() check\n") ACE_TEXT ("0x%x != 0x%x\n"), ipv4_addresses[i], addr.get_ip_address (), ACE_HTONL (addr32))); status = 1; } if (addr.get_host_addr () != 0 && ACE_OS::strcmp (addr.get_host_addr(), ipv4_addresses[i]) != 0) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("%C failed get_host_addr() check\n") ACE_TEXT ("%C != %C\n"), ipv4_addresses[i], addr.get_host_addr (), ipv4_addresses[i])); status = 1; } // Now we check the operation of get_host_addr(char*,int) const char* haddr = addr.get_host_addr (&hostaddr[0], sizeof(hostaddr)); if (haddr != 0 && ACE_OS::strcmp (&hostaddr[0], haddr) != 0) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("%C failed get_host_addr(char* buf,int) check\n") ACE_TEXT ("buf ['%C'] != return value ['%C']\n"), ipv4_addresses[i], &hostaddr[0], haddr)); status = 1; } if (ACE_OS::strcmp (&hostaddr[0], ipv4_addresses[i]) != 0) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("%C failed get_host_addr(char*,int) check\n") ACE_TEXT ("buf ['%C'] != expected value ['%C']\n"), ipv4_addresses[i], &hostaddr[0], ipv4_addresses[i])); status = 1; } // Clear out the address by setting it to 1 and check addr.set (0, ACE_UINT32 (1), 1); status |= check_type_consistency (addr); if (addr.get_ip_address () != 1) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Failed to set address to 1\n"))); status = 1; } // Now set the address using a 32 bit number and check that we get // the right string out of get_host_addr(). addr.set (80, addr32, 0); // addr32 is already in network byte order status |= check_type_consistency(addr); if (addr.get_host_addr () != 0 && ACE_OS::strcmp (addr.get_host_addr (), ipv4_addresses[i]) != 0) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("%C failed second get_host_addr() check\n") ACE_TEXT ("return value ['%C'] != expected value ['%C']\n"), ipv4_addresses[i], addr.get_host_addr (), ipv4_addresses[i])); status = 1; } // Test for ACE_INET_Addr::set_addr(). struct sockaddr_in sa4; sa4.sin_family = AF_INET; sa4.sin_addr = addrv4; sa4.sin_port = ACE_HTONS (8080); addr.set (0, ACE_UINT32 (1), 1); addr.set_addr (&sa4, sizeof(sa4)); status |= check_type_consistency (addr); if (addr.get_port_number () != 8080) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("ACE_INET_Addr::set_addr() ") ACE_TEXT ("failed to update port number.\n"))); status = 1; } if (addr.get_ip_address () != ACE_HTONL (addr32)) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("ACE_INET_Addr::set_addr() ") ACE_TEXT ("failed to update address.\n"))); status = 1; } } #if defined (ACE_HAS_IPV6) if (ACE::ipv6_enabled ()) { const char *ipv6_addresses[] = { "1080::8:800:200c:417a", // unicast address "ff01::101", // multicast address "::1", // loopback address "::", // unspecified addresses 0 }; for (int i=0; ipv6_addresses[i] != 0; i++) { ACE_INET_Addr addr (80, ipv6_addresses[i]); status |= check_type_consistency (addr); if (0 != ACE_OS::strcmp (addr.get_host_addr (), ipv6_addresses[i])) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("IPv6 get_host_addr failed: %C != %C\n"), addr.get_host_addr (), ipv6_addresses[i])); status = 1; } } const char *ipv6_names[] = { "naboo.dre.vanderbilt.edu", "v6.ipv6-test.com", 0 }; for (int i=0; ipv6_names[i] != 0; i++) { ACE_INET_Addr addr (80, ipv6_names[i]); status |= check_type_consistency (addr); if (0 != ACE_OS::strcmp (addr.get_host_name (), ipv6_names[i])) { // Alias? Check lookup on the reverse. ACE_INET_Addr alias_check; if (alias_check.set (80, addr.get_host_name ()) == 0) { if (addr != alias_check) ACE_ERROR ((LM_WARNING, ACE_TEXT ("IPv6 name mismatch: %s (%s) != %s\n"), addr.get_host_name (), addr.get_host_addr (), ipv6_names[i])); } else { ACE_ERROR ((LM_WARNING, ACE_TEXT ("IPv6 reverse lookup mismatch: %s (%s) != %s\n"), addr.get_host_name (), addr.get_host_addr (), ipv6_names[i])); } } } } ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("IPv6 tests done\n"))); #else ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("ACE_HAS_IPV6 not set; no IPv6 tests run\n"))); #endif struct Address loopback_addresses[] = { {"127.0.0.1", true}, {"127.1.2.3", true} , {"127.0.0.0", true}, {"127.255.255.255", true} , {"126.255.255.255", false}, {"128.0.0.0", false}, {0, true} }; for (int i=0; loopback_addresses[i].name != 0; i++) { struct in_addr addrv4; ACE_UINT32 addr32 = 0; ACE_OS::inet_pton (AF_INET, loopback_addresses[i].name, &addrv4); ACE_OS::memcpy (&addr32, &addrv4, sizeof (addr32)); addr.set (80, loopback_addresses[i].name); if (addr.is_loopback() != loopback_addresses[i].loopback) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("ACE_INET_Addr::is_loopback() ") ACE_TEXT ("failed to distinguish loopback address. %C\n") , loopback_addresses[i].name)); status = 1; } } if (addr.string_to_addr ("127.0.0.1:72000", AF_INET) != -1) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("ACE_INET_Addr::string_to_addr() ") ACE_TEXT ("failed to detect port number overflow\n"))); status = 1; } if (!test_tao_use ()) status = 1; if (!test_multiple ()) status = 1; if (!test_port_assignment ()) status = 1; ACE_INET_Addr a1 (80, "127.0.0.1"); ACE_INET_Addr a2 = a1; if (a1 != a2) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Address equality check failed after assignment\n"))); status = 1; } ACE_END_TEST; return status; }