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