int
ACE_RMCast_IO_UDP::send_ack (ACE_RMCast::Ack &ack,
const ACE_INET_Addr &to)
{
//ACE_DEBUG ((LM_DEBUG,
// "IO_UDP::send_ack - pushing (%d:%d) out to <%s:%d>\n",
// ack.next_expected,
// ack.highest_received,
// to.get_host_addr (),
// to.get_port_number ()));
// @@ TODO: We could keep the header pre-initialized, and only
// update the portions that do change...
char header[16];
header[0] = ACE_RMCast::RMCAST_MT_ACK;
ACE_UINT32 tmp = ACE_HTONL (ack.next_expected);
ACE_OS::memcpy (header + 1,
&tmp, sizeof(ACE_UINT32));
tmp = ACE_HTONL (ack.highest_received);
ACE_OS::memcpy (header + 1 + sizeof(ACE_UINT32),
&tmp, sizeof(ACE_UINT32));
// ACE_SOCK_MCast_Dgram disallows sending, but it actually works.
ACE_SOCK_Dgram &dgram = this->dgram_;
if (dgram.send (header, 1 + 2*sizeof(ACE_UINT32), to) == -1)
return -1;
return 0;
}
int
ACE_Name_Reply::encode (void *&buf)
{
ACE_TRACE ("ACE_Name_Reply::encode");
int len = this->length (); // Get length *before* marshaling.
this->transfer_.length_ = ACE_HTONL (this->transfer_.length_);
this->transfer_.type_ = ACE_HTONL (this->transfer_.type_);
this->transfer_.errno_ = ACE_HTONL (this->transfer_.errno_);
buf = (void *) &this->transfer_;
return len;
}
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
ACE_Name_Request::encode (void *&buf)
{
ACE_TRACE ("ACE_Name_Request::encode");
// Compute the length *before* doing the marshaling.
ACE_UINT32 len = this->length ();
size_t nv_data_len =
(this->transfer_.name_len_ + this->transfer_.value_len_)
/ sizeof (ACE_WCHAR_T);
for (size_t i = 0; i < nv_data_len; i++)
this->transfer_.data_[i] =
ACE_HTONS (this->transfer_.data_[i]);
buf = (void *) &this->transfer_;
this->transfer_.block_forever_ = ACE_HTONL (this->transfer_.block_forever_);
this->transfer_.usec_timeout_ = ACE_HTONL (this->transfer_.usec_timeout_);
#if defined (ACE_LITTLE_ENDIAN)
ACE_UINT64 secs = this->transfer_.sec_timeout_;
ACE_CDR::swap_8 ((const char *)&secs, (char *)&this->transfer_.sec_timeout_);
#endif
this->transfer_.length_ = ACE_HTONL (this->transfer_.length_);
this->transfer_.msg_type_ = ACE_HTONL (this->transfer_.msg_type_);
this->transfer_.name_len_ = ACE_HTONL (this->transfer_.name_len_);
this->transfer_.value_len_ = ACE_HTONL (this->transfer_.value_len_);
this->transfer_.type_len_ = ACE_HTONL (this->transfer_.type_len_);
return len;
}
// Encode the transfer buffer into network byte order
// so that it can be sent to the server.
int
ACE_Time_Request::encode (void *&buf)
{
ACE_TRACE ("ACE_Time_Request::encode");
// Compute the length *before* doing the marshaling.
buf = (void *) &this->transfer_;
this->transfer_.block_forever_ = ACE_HTONL (this->transfer_.block_forever_);
this->transfer_.usec_timeout_ = ACE_HTONL (this->transfer_.usec_timeout_);
this->transfer_.msg_type_ = ACE_HTONL (this->transfer_.msg_type_);
#if defined (ACE_LITTLE_ENDIAN)
ACE_UINT64 secs = this->transfer_.sec_timeout_;
ACE_CDR::swap_8 ((const char *)&secs, (char *)&this->transfer_.sec_timeout_);
secs = this->transfer_.time_;
ACE_CDR::swap_8 ((const char *)&secs, (char *)&this->transfer_.time_);
#endif
return this->size (); // Always fixed
}
ACE_INET_Addr::ACE_INET_Addr (const wchar_t port_name[],
ACE_UINT32 inet_address,
const wchar_t protocol[])
: ACE_Addr (determine_type (), sizeof (inet_addr_))
{
ACE_TRACE ("ACE_INET_Addr::ACE_INET_Addr");
if (this->set (port_name,
ACE_HTONL (inet_address),
protocol) == -1)
ACELIB_ERROR ((LM_ERROR,
ACE_TEXT ("ACE_INET_Addr::ACE_INET_Addr")));
}
int CRtpPacket::SetTimeStamp(unsigned int ulTimeStamp)
{
if (NULL == m_pFixedHead)
{
//BP_RUN_LOG_ERR(UNDEF_ERRCODE, "CRtpPacket::SetTimeStamp","Rtp packet set timestamp fail packet is null.");
return NRU_FAIL;
}
m_pFixedHead->timestamp = ACE_HTONL(ulTimeStamp);
return NRU_SUCCESS;
}
int
Log_Wrapper::log_message (Log_Priority type, char *message)
{
sequence_number_++;
this->log_msg_.type = type;
// Casting time() to long will start causing bad results sometime in 2038
// but the receiver isn't looking at the time, so who cares?
this->log_msg_.time = (long) ACE_OS::time (0);
this->log_msg_.msg_length = ACE_OS::strlen(message)+1;
this->log_msg_.sequence_number = ACE_HTONL(sequence_number_);
iovec iovp[2];
iovp[0].iov_base = reinterpret_cast<char*> (&log_msg_);
iovp[0].iov_len = sizeof (log_msg_);
iovp[1].iov_base = message;
iovp[1].iov_len = log_msg_.msg_length;
logger_.send (iovp, 2);
// success.
return 0;
}
int HDReechoHandler1::DoResponse(HD8583STRUCT& req,HD8583STRUCT& resp,ACE_HANDLE peer)
{
unsigned int termid = req->TerminalSN;
unsigned short canid = req->Address;
// 回响测试不需要判断 CCU 下的设备是否存在
resp.SetFieldValue(FIELD_TERMINALSN,req->TerminalSN);
resp.SetFieldValue(FIELD_ADDRESS,req->Address);
resp.SetFieldValue(FIELD_RESPONSECODE,(BYTE)RC_SUCCESS);
ACE_SOCK_Stream stream(peer);
ACE_INET_Addr peer_addr;
if(stream.get_remote_addr(peer_addr) == -1)
{
return -1;
}
char ipbuf[10] = "";
ACE_UINT32 ip = peer_addr.get_ip_address();
// 全部使用网络字节序
ip = ACE_HTONL(ip);
ACE_OS::memcpy(ipbuf,(const void*)&ip,sizeof ip);
resp.SetFieldValue(FIELD_ADDITIONALDATA1,ipbuf,ACE_OS::strlen(ipbuf));
// 需要应答
return 1;
}
const char *
ACE_INET_Addr::get_host_addr (char *dst, int size) const
{
#if defined (ACE_HAS_IPV6)
if (this->get_type () == AF_INET6)
{
if (IN6_IS_ADDR_V4MAPPED (&this->inet_addr_.in6_.sin6_addr))
{
ACE_UINT32 addr;
addr = this->get_ip_address();
addr = ACE_HTONL (addr);
return ACE_OS::inet_ntop (AF_INET, &addr, dst, size);
}
# if defined (ACE_WIN32)
if (0 == ::getnameinfo (reinterpret_cast<const sockaddr*> (&this->inet_addr_.in6_),
this->get_size (),
dst,
size,
0, 0, // Don't want service name
NI_NUMERICHOST))
return dst;
ACE_OS::set_errno_to_wsa_last_error ();
return 0;
# else
const char *ch = ACE_OS::inet_ntop (AF_INET6,
&this->inet_addr_.in6_.sin6_addr,
dst,
size);
#if defined (__linux__)
if ((IN6_IS_ADDR_LINKLOCAL (&this->inet_addr_.in6_.sin6_addr) ||
IN6_IS_ADDR_MC_LINKLOCAL (&this->inet_addr_.in6_.sin6_addr)) &&
this->inet_addr_.in6_.sin6_scope_id != 0)
{
char scope_buf[32];
ACE_OS::sprintf (scope_buf, "%%%u", this->inet_addr_.in6_.sin6_scope_id);
if ((ACE_OS::strlen (ch)+ACE_OS::strlen (scope_buf)) < (size_t)size)
{
ACE_OS::strcat (dst, scope_buf);
}
}
#endif
return ch;
# endif /* ACE_WIN32 */
}
#endif /* ACE_HAS_IPV6 */
#if defined (VXWORKS)
ACE_UNUSED_ARG (dst);
ACE_UNUSED_ARG (size);
// It would be nice to be able to encapsulate this into
// ACE_OS::inet_ntoa(), but that would lead to either inefficiencies
// on vxworks or lack of thread safety.
//
// So, we use the way that vxworks suggests.
ACE_INET_Addr *ncthis = const_cast<ACE_INET_Addr *> (this);
inet_ntoa_b(this->inet_addr_.in4_.sin_addr, ncthis->buf_);
ACE_OS::strsncpy (dst, &buf_[0], size);
return &buf_[0];
#else /* VXWORKS */
char *ch = ACE_OS::inet_ntoa (this->inet_addr_.in4_.sin_addr);
ACE_OS::strsncpy (dst, ch, size);
return ch;
#endif
}
int ACE_INET_Addr::set_address (const char *ip_addr,
int len,
int encode /* = 1 */,
int map /* = 0 */)
{
ACE_TRACE ("ACE_INET_Addr::set_address");
// This is really intended for IPv4. If the object is IPv4, or the type
// hasn't been set but it's a 4-byte address, go ahead. If this is an
// IPv6 object and <encode> is requested, refuse.
if (encode && len != 4)
{
errno = EAFNOSUPPORT;
return -1;
}
if (len == 4)
{
ACE_UINT32 ip4 = *reinterpret_cast<const ACE_UINT32 *> (ip_addr);
if (encode)
ip4 = ACE_HTONL (ip4);
if (this->get_type () == AF_INET && map == 0) {
this->base_set (AF_INET, sizeof (this->inet_addr_.in4_));
this->inet_addr_.in4_.sin_family = AF_INET;
this->set_size (sizeof (this->inet_addr_.in4_));
ACE_OS::memcpy (&this->inet_addr_.in4_.sin_addr,
&ip4,
len);
}
#if defined (ACE_HAS_IPV6)
else if (map == 0)
{
// this->set_type (AF_INET);
this->base_set (AF_INET, sizeof (this->inet_addr_.in4_));
this->inet_addr_.in4_.sin_family = AF_INET;
this->set_size (sizeof (this->inet_addr_.in4_));
ACE_OS::memcpy (&this->inet_addr_.in4_.sin_addr,
&ip4, len);
}
// If given an IPv4 address to copy to an IPv6 object, map it to
// an IPv4-mapped IPv6 address.
else
{
this->base_set (AF_INET6, sizeof (this->inet_addr_.in6_));
this->inet_addr_.in6_.sin6_family = AF_INET6;
this->set_size (sizeof (this->inet_addr_.in6_));
if (ip4 == INADDR_ANY)
{
in6_addr ip6 = in6addr_any;
ACE_OS::memcpy (&this->inet_addr_.in6_.sin6_addr,
&ip6,
sizeof (ip6));
return 0;
}
if (ip4 == INADDR_LOOPBACK)
{
in6_addr ip6 = in6addr_loopback;
ACE_OS::memcpy (&this->inet_addr_.in6_.sin6_addr,
&ip6,
sizeof (ip6));
return 0;
}
// Build up a 128 bit address. An IPv4-mapped IPv6 address
// is defined as 0:0:0:0:0:ffff:IPv4_address. This is defined
// in RFC 1884 */
ACE_OS::memset (&this->inet_addr_.in6_.sin6_addr, 0, 16);
this->inet_addr_.in6_.sin6_addr.s6_addr[10] =
this->inet_addr_.in6_.sin6_addr.s6_addr[11] = 0xff;
ACE_OS::memcpy
(&this->inet_addr_.in6_.sin6_addr.s6_addr[12], &ip4, 4);
}
#endif /* ACE_HAS_IPV6 */
return 0;
} /* end if (len == 4) */
#if defined (ACE_HAS_IPV6)
else if (len == 16)
{
if (this->get_type () != PF_INET6)
{
errno = EAFNOSUPPORT;
return -1;
}
// We protect ourselves up above so IPv6 must be possible here.
this->base_set (AF_INET6, sizeof (this->inet_addr_.in6_));
this->inet_addr_.in6_.sin6_family = AF_INET6;
ACE_OS::memcpy (&this->inet_addr_.in6_.sin6_addr, ip_addr, len);
return 0;
} /* end len == 16 */
else
{
/* unknown or unsupported address length */
errno = EAFNOSUPPORT;
return -1;
}
#endif /* ACE_HAS_IPV6 */
// Here with an unrecognized length.
errno = EAFNOSUPPORT;
return -1;
}
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;
}
void
TAO_ECG_CDR_Message_Sender::send_fragment (const ACE_INET_Addr &addr,
CORBA::ULong request_id,
CORBA::ULong request_size,
CORBA::ULong fragment_size,
CORBA::ULong fragment_offset,
CORBA::ULong fragment_id,
CORBA::ULong fragment_count,
iovec iov[],
int iovcnt)
{
CORBA::ULong header[TAO_ECG_CDR_Message_Sender::ECG_HEADER_SIZE
/ sizeof(CORBA::ULong)
+ ACE_CDR::MAX_ALIGNMENT];
char* buf = reinterpret_cast<char*> (header);
TAO_OutputCDR cdr (buf, sizeof(header));
cdr.write_boolean (TAO_ENCAP_BYTE_ORDER);
// Insert some known values in the padding bytes, so we can smoke
// test the message on the receiving end.
cdr.write_octet ('A'); cdr.write_octet ('B'); cdr.write_octet ('C');
cdr.write_ulong (request_id);
cdr.write_ulong (request_size);
cdr.write_ulong (fragment_size);
cdr.write_ulong (fragment_offset);
cdr.write_ulong (fragment_id);
cdr.write_ulong (fragment_count);
CORBA::Octet padding[4];
// MRH
if (checksum_)
{
// Compute CRC
iov[0].iov_base = cdr.begin ()->rd_ptr ();
iov[0].iov_len = cdr.begin ()->length ();
unsigned int crc = 0;
unsigned char *crc_parts = (unsigned char *)(&crc);
if (iovcnt > 1)
{
crc = ACE::crc32 (iov, iovcnt);
crc = ACE_HTONL (crc);
}
for (int cnt=0; cnt<4; ++cnt)
{
padding[cnt] = crc_parts[cnt];
}
}
else
{
for (int cnt=0; cnt<4; ++cnt)
{
padding[cnt] = 0;
}
}
//End MRH
cdr.write_octet_array (padding, 4);
iov[0].iov_base = cdr.begin ()->rd_ptr ();
iov[0].iov_len = cdr.begin ()->length ();
ssize_t n = this->dgram ().send (iov,
iovcnt,
addr);
size_t expected_n = 0;
for (int i = 0; i < iovcnt; ++i)
expected_n += iov[i].iov_len;
if (n > 0 && size_t(n) != expected_n)
{
ORBSVCS_ERROR ((LM_ERROR, ("Sent only %d out of %d bytes "
"for mcast fragment.\n"),
n,
expected_n));
}
if (n == -1)
{
if (errno == EWOULDBLOCK)
{
ORBSVCS_ERROR ((LM_ERROR, "Send of mcast fragment failed (%m).\n"));
// @@ TODO Use a Event Channel specific exception
throw CORBA::COMM_FAILURE ();
}
else
{
ORBSVCS_DEBUG ((LM_WARNING, "Send of mcast fragment blocked (%m).\n"));
}
}
else if (n == 0)
{
ORBSVCS_DEBUG ((LM_WARNING, "EOF on send of mcast fragment (%m).\n"));
}
}
// conduct the UnMarshalled Octet performance test using separate
// send_n calls with Nagle's algorithm disabled
ACE_SCTP::HIST runUnmarshalledOctetTest(ACE_CDR::Octet *buf, size_t seqLen, ACE_SOCK_Stream & stream){
ACE_CDR::ULong const testIterations = Options_Manager::test_iterations;
size_t bt;
ACE_CDR::ULong cnt = 0;
// variables for the timing measurements
ACE_hrtime_t startTime, endTime;
ACE_CDR::Double messageLatency_usec = 0.0;
ACE_CDR::ULong msgLen = seqLen*ACE_CDR::OCTET_SIZE;
// explicity configure Nagling. Default is
// Options_Manager::test_enable_nagle=0 so default configurations is
// NO NAGLING
ACE_CDR::Long nagle;
if (Options_Manager::test_enable_nagle)
nagle=0;
else
nagle=1;
if (Options_Manager::test_transport_protocol == IPPROTO_SCTP){
// default - sctp case
if (-1 == stream.set_option(IPPROTO_SCTP, SCTP_NODELAY, &nagle, sizeof nagle))
ACE_ERROR_RETURN ((LM_ERROR,
"%p\n",
"set_option"),
0);
} else {
// tcp case
if (-1 == stream.set_option(IPPROTO_TCP, TCP_NODELAY, &nagle, sizeof nagle))
ACE_ERROR_RETURN ((LM_ERROR,
"%p\n",
"set_option"),
0);
}
// prime the client and server before starting the test
for(cnt=0;cnt<primerIterations;++cnt){
// send message size
// TODO : The message length should be CDR encoded
ACE_CDR::ULong msgLenExpressed = ACE_HTONL(msgLen);
if (-1 == stream.send_n (&msgLenExpressed, ACE_CDR::LONG_SIZE, 0, &bt))
ACE_ERROR_RETURN ((LM_ERROR,
"%p\n",
"send_n"),
0);
// send a message
if (-1 == stream.send_n (buf, msgLen, 0, &bt))
ACE_ERROR_RETURN ((LM_ERROR,
"%p\n",
"send_n"),
0);
// block for a Short reply
ACE_CDR::Short reply;
if ((stream.recv_n(&reply, ACE_CDR::SHORT_SIZE, 0, &bt)) == -1)
ACE_ERROR_RETURN((LM_ERROR,
"%p\n",
"recv_n"),
0);
}
// AFTER PRIMING THE PUMP CREATE THE HISTOGRAM
ACE_SCTP::HIST aceStream_hist = 0;
aceStream_hist = createHistogram(msgLen);
if (0 == aceStream_hist)
ACE_ERROR_RETURN((LM_ERROR,
"%p\n",
"histogram create failed"),
0);
iovec iov[2];
// PERFORMANCE TEST LOOP
for (cnt = 0; cnt < testIterations; ++cnt){
// get the start time
startTime = ACE_OS::gethrtime();
if (!startTime)
ACE_ERROR_RETURN((LM_ERROR,
"%p\n",
"ACE_OS::gethrtime()"),
0);
ACE_CDR::ULong msgLenExpressed = ACE_HTONL(msgLen);
iov[0].iov_base = reinterpret_cast<char *> (&msgLenExpressed);
iov[0].iov_len = ACE_CDR::LONG_SIZE;
iov[1].iov_base = reinterpret_cast<char *> (buf);
iov[1].iov_len = msgLen;
if (-1 == stream.sendv_n (iov, 2))
ACE_ERROR_RETURN ((LM_ERROR,
"%p\n",
"send_n"),
0);
// block for a Short reply
ACE_CDR::Short reply;
if ((stream.recv_n(&reply, ACE_CDR::SHORT_SIZE, 0, &bt)) == -1)
ACE_ERROR_RETURN((LM_ERROR,
"%p\n",
"recv_n"),
0);
// get the end time
endTime = ACE_OS::gethrtime();
if (!endTime)
ACE_ERROR_RETURN((LM_ERROR,
"%p\n",
"ACE_OS::gethrtime()"),
0);
// compute the message latency in micro-seconds
messageLatency_usec =
(static_cast<double> (ACE_UINT64_DBLCAST_ADAPTER(endTime)) -
static_cast<double> (ACE_UINT64_DBLCAST_ADAPTER(startTime)))
/ microsec_clock_scale_factor;
// record the message latency in the histogram
ACE_SCTP::record(messageLatency_usec, aceStream_hist);
}
// THE HEADER MESSAGE SENT TO THE SERVER CONTAINED THE NUMBER OF
// PRIMER AND TEST MESSAGES TO BE SENT AFTER WHICH THE SERVER WILL
// CLOSE THE STREAM SO ONCE WE REACH THIS POINT THE STREAM IS NO
// LONGER VALID AND WE CLOSE IT.
stream.close();
// allocated by runTest
delete[] buf;
return aceStream_hist;
}
int
ACE_RMCast_IO_UDP::send_data (ACE_RMCast::Data &data,
const ACE_INET_Addr &to)
{
//ACE_DEBUG ((LM_DEBUG,
// "IO_UDP::send_data - pushing out to <%s:%d>\n",
// to.get_host_addr (),
// to.get_port_number ()));
// The first message block contains the header
// @@ TODO: We could keep the header pre-initialized, and only
// update the portions that do change...
ACE_UINT32 tmp;
char header[1 + 3 * sizeof(ACE_UINT32)];
header[0] = ACE_RMCast::RMCAST_MT_DATA;
tmp = ACE_HTONL (data.sequence_number);
ACE_OS::memcpy (header + 1,
&tmp, sizeof(ACE_UINT32));
tmp = ACE_HTONL (data.total_size);
ACE_OS::memcpy (header + 1 + sizeof(ACE_UINT32),
&tmp, sizeof(ACE_UINT32));
tmp = ACE_HTONL (data.fragment_offset);
ACE_OS::memcpy (header + 1 + 2 * sizeof(ACE_UINT32),
&tmp, sizeof(ACE_UINT32));
iovec iov[ACE_IOV_MAX];
int iovcnt = 1;
iov[0].iov_base = header;
iov[0].iov_len = sizeof(header);
ACE_Message_Block *mb = data.payload;
for (const ACE_Message_Block *i = mb; i != 0; i = i->cont ())
{
iov[iovcnt].iov_base = i->rd_ptr ();
iov[iovcnt].iov_len = ACE_static_cast (u_long, i->length ());
iovcnt++;
if (iovcnt >= IOV_MAX)
return -1;
}
// @@ This pacing stuff here reduced the number of packet lost in
// loopback tests, but it should be taken out for real applications
// (or at least made configurable!)
ACE_Time_Value tv (0, 10000);
ACE_OS::sleep (tv);
// ACE_SOCK_MCast_Dgram disallows sending, but it actually works.
ACE_SOCK_Dgram &dgram = this->dgram_;
if (dgram.send (iov, iovcnt, to) == -1)
return -1;
#if 0
ACE_HEX_DUMP ((LM_DEBUG,
(char*)iov[0].iov_base,
iov[0].iov_len,
"Sending"));
#endif
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;
}
