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