static bool test_tao_use (void) { char host[256]; if (::gethostname (host, 255) != 0) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Test TAO Use fail %p\n"), ACE_TEXT ("gethostname"))); return false; } ACE_INET_Addr addr; addr.set ((unsigned short)0, host); ACE_CString full (host); full += ":12345"; addr.set (full.c_str ()); u_short p = addr.get_port_number (); if (p != 12345) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Test TAO Use expected port 12345 got %d\n"), p)); return false; } ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Test TAO Use passed\n"))); return true; }
bool CControlListen::AddListen( const char* pListenIP, uint32 u4Port, uint8 u1IPType, int nPacketParseID) { bool blState = App_ConnectAcceptorManager::instance()->CheckIPInfo(pListenIP, u4Port); if(true == blState) { //当前监听已经存在,不可以重复建设 OUR_DEBUG((LM_INFO, "[CServerManager::AddListen](%s:%d) is exist.\n", pListenIP, u4Port)); return false; } ACE_INET_Addr listenAddr; //判断IPv4还是IPv6 int nErr = 0; if (u1IPType == TYPE_IPV4) { nErr = listenAddr.set(u4Port, pListenIP); } else { nErr = listenAddr.set(u4Port, pListenIP, 1, PF_INET6); } if (nErr != 0) { OUR_DEBUG((LM_INFO, "[CControlListen::AddListen](%s:%d)set_address error[%d].\n", pListenIP, u4Port, errno)); return false; } //得到接收器 ConnectAcceptor* pConnectAcceptor = App_ConnectAcceptorManager::instance()->GetNewConnectAcceptor(); if (NULL == pConnectAcceptor) { OUR_DEBUG((LM_INFO, "[CControlListen::AddListen](%s:%d)pConnectAcceptor is NULL.\n", pListenIP, u4Port)); return false; } pConnectAcceptor->SetPacketParseInfoID(nPacketParseID); int nRet = pConnectAcceptor->open2(listenAddr, App_ReactorManager::instance()->GetAce_Reactor(REACTOR_CLIENTDEFINE), ACE_NONBLOCK, (int)GetXmlConfigAttribute(xmlNetWorkMode)->BackLog); if (-1 == nRet) { OUR_DEBUG((LM_INFO, "[CControlListen::AddListen] Listen from [%s:%d] error(%d).\n", listenAddr.get_host_addr(), listenAddr.get_port_number(), errno)); return false; } OUR_DEBUG((LM_INFO, "[CControlListen::AddListen] Listen from [%s:%d] OK.\n", listenAddr.get_host_addr(), listenAddr.get_port_number())); return true; }
bool CProControlListen::AddListen( const char* pListenIP, uint32 u4Port, uint8 u1IPType ) { bool blState = App_ProConnectAcceptManager::instance()->CheckIPInfo(pListenIP, u4Port); if(true == blState) { //当前监听已经存在,不可以重复建设 OUR_DEBUG((LM_INFO, "[CProControlListen::AddListen](%s:%d) is exist.\n", pListenIP, u4Port)); return false; } //创建一个新的accept对象 ProConnectAcceptor* pProConnectAcceptor = App_ProConnectAcceptManager::instance()->GetNewConnectAcceptor(); if(NULL == pProConnectAcceptor) { OUR_DEBUG((LM_INFO, "[CProControlListen::AddListen](%s:%d) new ConnectAcceptor error.\n", pListenIP, u4Port)); return false; } ACE_INET_Addr listenAddr; //判断IPv4还是IPv6 int nErr = 0; if(u1IPType == TYPE_IPV4) { nErr = listenAddr.set(u4Port, pListenIP); } else { nErr = listenAddr.set(u4Port, pListenIP, 1, PF_INET6); } if(nErr != 0) { OUR_DEBUG((LM_INFO, "[CProControlListen::AddListen](%s:%d)set_address error[%d].\n", pListenIP, u4Port, errno)); return false; } //创建新的监听 //设置监听IP信息 pProConnectAcceptor->SetListenInfo(pListenIP, u4Port); ACE_Proactor* pProactor = App_ProactorManager::instance()->GetAce_Proactor(REACTOR_CLIENTDEFINE); if(NULL == pProactor) { OUR_DEBUG((LM_INFO, "[CProControlListen::AddListen]App_ProactorManager::instance()->GetAce_Proactor(REACTOR_CLIENTDEFINE) is NULL.\n")); return false; } int nRet = pProConnectAcceptor->open(listenAddr, 0, 1, App_MainConfig::instance()->GetBacklog(), 1, pProactor); if(-1 == nRet) { OUR_DEBUG((LM_INFO, "[CProControlListen::AddListen] Listen from [%s:%d] error(%d).\n",listenAddr.get_host_addr(), listenAddr.get_port_number(), errno)); return false; } OUR_DEBUG((LM_INFO, "[CProControlListen::AddListen](%s:%d)Add Listen success.\n", pListenIP, u4Port)); return true; }
template <class HANDLER> void ACE_Asynch_Acceptor<HANDLER>::parse_address (const ACE_Asynch_Accept::Result &result, ACE_INET_Addr &remote_address, ACE_INET_Addr &local_address) { ACE_TRACE ("ACE_Asynch_Acceptor<>::parse_address"); #if defined (ACE_HAS_AIO_CALLS) // Use an ACE_SOCK to get the addresses - it knows how to deal with // ACE_INET_Addr objects and get IPv4/v6 addresses. ACE_SOCK_Stream str (result.accept_handle ()); str.get_local_addr (local_address); str.get_remote_addr (remote_address); #elif defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0) ACE_Message_Block &message_block = result.message_block (); sockaddr *local_addr = 0; sockaddr *remote_addr = 0; int local_size = 0; int remote_size = 0; // This matches setup in accept(). size_t addr_size = sizeof (sockaddr_in) + 16; #if defined (ACE_HAS_IPV6) if (this->addr_family_ == PF_INET6) addr_size = sizeof (sockaddr_in6) + 16; #endif /* ACE_HAS_IPV6 */ ::GetAcceptExSockaddrs (message_block.rd_ptr (), static_cast<DWORD> (this->bytes_to_read_), static_cast<DWORD> (addr_size), static_cast<DWORD> (addr_size), &local_addr, &local_size, &remote_addr, &remote_size); local_address.set (reinterpret_cast<sockaddr_in *> (local_addr), local_size); remote_address.set (reinterpret_cast<sockaddr_in *> (remote_addr), remote_size); #else // just in case errno = ENOTSUP; #endif /* defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0) */ return; }
bool CClientReConnectManager::ConnectUDP(int nServerID, const char* pIP, int nPort, uint8 u1IPType, EM_UDP_TYPE emType, IClientUDPMessage* pClientUDPMessage) { ACE_Guard<ACE_Recursive_Thread_Mutex> guard(m_ThreadWritrLock); CReactorUDPClient* pReactorUDPClient = NULL; //初始化连接动作 if (false == ConnectUdpInit(nServerID, pReactorUDPClient)) { return false; } //初始化连接地址 ACE_INET_Addr AddrLocal; int nErr = 0; if (emType != UDP_BROADCAST) { if (u1IPType == TYPE_IPV4) { nErr = AddrLocal.set(nPort, pIP); } else { nErr = AddrLocal.set(nPort, pIP, 1, PF_INET6); } } else { //如果是UDP广播 AddrLocal.set(nPort, (uint32)INADDR_ANY); } if (nErr != 0) { OUR_DEBUG((LM_INFO, "[CClientReConnectManager::ConnectUDP](%d)UDP set_address error[%d].\n", nServerID, errno)); SAFE_DELETE(pReactorUDPClient); return false; } //开始连接 if (0 != pReactorUDPClient->OpenAddress(AddrLocal, emType, App_ReactorManager::instance()->GetAce_Reactor(REACTOR_UDPDEFINE), pClientUDPMessage)) { OUR_DEBUG((LM_INFO, "[CClientReConnectManager::ConnectUDP](%d)UDP OpenAddress error.\n", nServerID)); SAFE_DELETE(pReactorUDPClient); return false; } return true; }
bool CClientReConnectManager::ConnectUDP(int nServerID, const char* pIP, int nPort, uint8 u1IPType, IClientUDPMessage* pClientUDPMessage) { ACE_Guard<ACE_Recursive_Thread_Mutex> guard(m_ThreadWritrLock); mapReactorUDPConnectInfo::iterator f = m_mapReactorUDPConnectInfo.find(nServerID); if (f != m_mapReactorUDPConnectInfo.end()) { //如果这个链接已经存在,则不创建新的链接 OUR_DEBUG((LM_ERROR, "[CClientReConnectManager::ConnectUDP]nServerID =(%d) is exist.\n", nServerID)); return false; } CReactorUDPClient* pReactorUDPClient = new CReactorUDPClient(); if (NULL == pReactorUDPClient) { OUR_DEBUG((LM_ERROR, "[CClientReConnectManager::ConnectUDP]nServerID =(%d) pProactorUDPClient is NULL.\n", nServerID)); return false; } m_mapReactorUDPConnectInfo[nServerID] = pReactorUDPClient; ACE_INET_Addr AddrLocal; int nErr = 0; if (u1IPType == TYPE_IPV4) { nErr = AddrLocal.set(nPort, pIP); } else { nErr = AddrLocal.set(nPort, pIP, 1, PF_INET6); } if (nErr != 0) { OUR_DEBUG((LM_INFO, "[CClientReConnectManager::ConnectUDP](%d)UDP set_address error[%d].\n", nServerID, errno)); SAFE_DELETE(pReactorUDPClient); return false; } if (0 != pReactorUDPClient->OpenAddress(AddrLocal, App_ReactorManager::instance()->GetAce_Reactor(REACTOR_UDPDEFINE), pClientUDPMessage)) { OUR_DEBUG((LM_INFO, "[CClientReConnectManager::ConnectUDP](%d)UDP OpenAddress error.\n", nServerID)); SAFE_DELETE(pReactorUDPClient); return false; } return true; }
bool CProactorUDPClient::SendMessage(const char* pMessage, uint32 u4Len, const char* szIP, int nPort) { ACE_INET_Addr AddrRemote; int nErr = AddrRemote.set(nPort, szIP); if(nErr != 0) { OUR_DEBUG((LM_INFO, "[CProactorUDPClient::SendMessage]set_address error[%d].\n", errno)); SAFE_DELETE_ARRAY(pMessage); return false; } int nSize = (int)m_skRemote.send(pMessage, u4Len, AddrRemote); if((uint32)nSize == u4Len) { m_atvOutput = ACE_OS::gettimeofday(); m_u4SendSize += u4Len; m_u4SendPacketCount++; SAFE_DELETE_ARRAY(pMessage); return true; } else { OUR_DEBUG((LM_ERROR, "[CProactorUDPClient::SendMessage]send error(%d).\n", errno)); SAFE_DELETE_ARRAY(pMessage); return false; } }
int HandlersRegister::registerTCPHandlers () { ACE_INET_Addr addr (BaseTCPPort); if (-1 == acceptor_->open (addr, reactor_, 1)) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT (" (%P) %p\n"), ACE_TEXT ("Cannot open acceptor port")), -1); int i; addr.set (BaseTCPPort, ACE_TEXT ("127.0.0.1")); for (i = 0; i < HandlersNo; ++i) { if (-1 == connectors_[ i ]->connect ( TCPClients_[ i ], addr, ACE_Synch_Options::asynch)) if (errno != EWOULDBLOCK ) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT (" (%P) %p (%d)\n"), ACE_TEXT ("Cannot connect connector"), i), -1); } return 0; }
void ManageGateSession::connectGate() { const GateCfgVec_t & gate_cfg_vec = ManageConfig::instance()->getGateCfg(); ACE_SOCK_Connector connector; ACE_INET_Addr addr; for (GateCfgVec_t::const_iterator it = gate_cfg_vec.begin(); it != gate_cfg_vec.end(); ) { addr.set(it->port, it->ip.c_str()); GateSession * gate_session = new GateSession(); if (connector.connect(gate_session->peer(), addr) == -1) { DEF_LOG_ERROR("Failed to connector gate, ip is <%s>, port is <%d>, last error is <%d>\n", it->ip.c_str(), it->port, ACE_OS::last_error()); ACE_OS::sleep(1); continue; } else { gate_session->setPacketHandler(RouteGatePacket::instance()); gate_session->netConnected(); gate_session->peer().enable(ACE_NONBLOCK); int flag = 1; gate_session->peer().set_option(IPPROTO_TCP, TCP_NODELAY, (char *)&flag, sizeof(flag)); m_reactor->register_handler(gate_session, ACE_Event_Handler::READ_MASK); ++it; } } }
template <class HANDLER> void ACE_Asynch_Connector<HANDLER>::parse_address (const ACE_Asynch_Connect::Result &result, ACE_INET_Addr &remote_address, ACE_INET_Addr &local_address) { #if defined (ACE_HAS_IPV6) // Getting the addresses. sockaddr_in6 local_addr; sockaddr_in6 remote_addr; #else // Getting the addresses. sockaddr_in local_addr; sockaddr_in remote_addr; #endif /* ACE_HAS_IPV6 */ // Get the length. int local_size = sizeof (local_addr); int remote_size = sizeof (remote_addr); // Get the local address. if (ACE_OS::getsockname (result.connect_handle (), reinterpret_cast<sockaddr *> (&local_addr), &local_size) < 0) ACELIB_ERROR ((LM_ERROR, ACE_TEXT("%p\n"), ACE_TEXT("ACE_Asynch_Connector::<getsockname> failed"))); // Get the remote address. if (ACE_OS::getpeername (result.connect_handle (), reinterpret_cast<sockaddr *> (&remote_addr), &remote_size) < 0) ACELIB_ERROR ((LM_ERROR, ACE_TEXT("%p\n"), ACE_TEXT("ACE_Asynch_Connector::<getpeername> failed"))); // Set the addresses. local_address.set (reinterpret_cast<sockaddr_in *> (&local_addr), local_size); remote_address.set (reinterpret_cast<sockaddr_in *> (&remote_addr), remote_size); return; }
int YARPNameClient::check_in_udp(const YARPString &name, const ACE_INET_Addr ®_addr, ACE_INET_Addr &addr, NetInt32 *ports, NetInt32 n) { YNC("YNC %s:%d --> check in %s\n",__FILE__,__LINE__,name.c_str()); int ret = YARP_FAIL; mutex_.Wait(); YARPString ip = reg_addr.get_host_addr(); ret = _checkInUdp(name, ip, ports, n); addr.set (ports[0], ip.c_str()); mutex_.Post(); return ret; }
bool CACETrbNetAcceptorImpl::binding(const CDENET::SInetAddress& address) { ACE_INET_Addr aceAddr; aceAddr.set(address.port, address.ip); return TRB_Asynch_Acceptor<CACETrbNetConnectionImpl>::open( aceAddr, 0, 1, ACE_DEFAULT_ASYNCH_BACKLOG, 1, TRB_Proactor::instance(), 1 ) != -1; }
bool Server_Manager_Common_Addr(uint8 u4IpType, const char* pIP, uint32 u4Port, ACE_INET_Addr& listenAddr) { //判断IPv4还是IPv6 int nErr = 0; if (u4IpType == TYPE_IPV4) { if (ACE_OS::strcmp(pIP, "INADDR_ANY") == 0) { nErr = listenAddr.set(u4Port, (uint32)INADDR_ANY); } else { nErr = listenAddr.set(u4Port, pIP); } } else { if (ACE_OS::strcmp(pIP, "INADDR_ANY") == 0) { nErr = listenAddr.set(u4Port, (uint32)INADDR_ANY); } else { nErr = listenAddr.set(u4Port, pIP, 1, PF_INET6); } } if (nErr != 0) { OUR_DEBUG((LM_INFO, "[Server_Manager_Common_Addr](%d)set_address error[%s:%d].\n", pIP, u4Port, errno)); return false; } return true; }
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { // Register a signal handler. ACE_Sig_Action sa ((ACE_SignalHandler) handler, SIGINT); ACE_UNUSED_ARG (sa); Logging_Acceptor *peer_acceptor; ACE_NEW_RETURN (peer_acceptor, Logging_Acceptor, 1); ACE_INET_Addr addr (PORT); ACE_Get_Opt get_opt (argc, argv, ACE_TEXT ("p:")); for (int c; (c = get_opt ()) != -1; ) switch (c) { case 'p': addr.set (ACE_OS::atoi (get_opt.opt_arg ())); break; default: break; } if (peer_acceptor->open (addr) == -1) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("open")), -1); else if (REACTOR::instance ()->register_handler (peer_acceptor, ACE_Event_Handler::ACCEPT_MASK) == -1) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("registering service with ACE_Reactor\n")), -1); // Run forever, performing the logging service. ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) starting up server logging daemon\n"))); while (!finished) REACTOR::instance ()->handle_events (); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) shutting down server logging daemon\n"))); return 0; }
int TAO_AV_SCTP_SEQ_Acceptor::open_default (TAO_Base_StreamEndPoint *endpoint, TAO_AV_Core *av_core, TAO_FlowSpec_Entry *entry, TAO_AV_Flow_Protocol_Factory *factory, TAO_AV_Core::Flow_Component flow_comp) { this->flow_protocol_factory_ = factory; this->av_core_ = av_core; this->endpoint_ = endpoint; 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_INET_Addr *address; ACE_NEW_RETURN (address, ACE_INET_Addr ("0"), -1); int result = this->acceptor_.acceptor_open (this, av_core->reactor (), *address, entry); if (result < 0) ORBSVCS_ERROR_RETURN ((LM_ERROR, "TAO_AV_SCTP_SEQ_Acceptor::open failed"), -1); this->acceptor_.acceptor ().get_local_addr (*address); address->set (address->get_port_number (), address->get_host_name ()); char buf[BUFSIZ]; address->addr_to_string (buf,BUFSIZ); if (TAO_debug_level > 0) ORBSVCS_DEBUG ((LM_DEBUG, "TAO_AV_SCTP_SEQ_Acceptor::open_default: %s\n", buf)); entry->set_local_addr (address); return 0; }
static bool test_multiple (void) { bool success = true; // Check the behavior when there are multiple addresses assigned to a name. // The NTP pool should always return multiples, though always different. ACE_INET_Addr ntp; if (ntp.set (123, ACE_TEXT ("pool.ntp.org")) == -1) { // This is just a warning to prevent fails on lookups on hosts with no // DNS service. The real value of this test is to accurately get // multiples from the result. ACE_ERROR ((LM_WARNING, ACE_TEXT ("%p\n"), ACE_TEXT ("pool.ntp.org"))); return true; } size_t count = 0; ACE_TCHAR addr_string[256]; do { ++count; // If lookup succeeded, there's at least one ntp.addr_to_string (addr_string, sizeof (addr_string)); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("IPv4 %B: %s\n"), count, addr_string)); } while (ntp.next ()); success = count > 1; #if defined (ACE_HAS_IPV6) ACE_INET_Addr ntp6; if (ntp6.set (123, ACE_TEXT ("2.pool.ntp.org"), 1, AF_INET6) == -1) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("2.pool.ntp.org"))); return false; } count = 0; do { ++count; // If lookup succeeded, there's at least one ntp6.addr_to_string (addr_string, sizeof (addr_string)); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("IPv6 %B: %s\n"), count, addr_string)); } while (ntp6.next ()); if (count <= 1) success = false; #endif /* ACE_HAS_IPV6 */ return success; }
static void SmartHost(YARPString& result) { char buf[256] = "localhost"; result = buf; int r = ACE_OS::hostname(buf,sizeof(buf)); if (r!=-1) { result = buf; ACE_INET_Addr addr; int r = addr.set((short unsigned int)0,(const char *)buf); if (r!=-1) { YARPString outIp = addr.get_host_addr(); if (outIp!=YARPString("127.0.0.1")) { result = outIp; } } } }
ACE_BEGIN_VERSIONED_NAMESPACE_DECL int ACE_Remote_Name_Space::open (const ACE_TCHAR *servername, u_short port) { ACE_TRACE ("ACE_Remote_Name_Space::open"); ACE_INET_Addr servaddr; // Initialize Addr if (servaddr.set (port, servername) == -1) return -1; // Connect to Name Server process. if (this->ns_proxy_.open (servaddr) == -1) return -1; return 0; }
bool ClientRequestHandler::parse_address (const ACE_CString& str, ACE_INET_Addr& addr) { static const int eof_ = std::char_traits<char>::eof (); ACE::IOS::CString_OStream sos_host; u_short port_hi = 0, port_lo = 0; ACE::IOS::CString_IStream sis (str); sis.ignore (str.length (), '('); int ch = sis.get (); if (ACE_OS::ace_isdigit (ch)) { for (int i=0; i<4 ;++i) { if (ch == ',') { sos_host.put ('.'); ch = sis.get (); } while (ch != eof_ && ACE_OS::ace_isdigit (ch)) { sos_host.put (ch); ch = sis.get (); } } if (ch == ',') { sis >> port_hi; ch = sis.get (); if (ch == ',') { sis >> port_lo; u_short port = port_hi*256 + port_lo; addr.set (port, sos_host.str ().c_str ()); return true; } }
int YARPNameClient2::queryName(const char *name, ACE_INET_Addr& addr, int *type) { YNC("queryName %s\n", name); YARPString cmd("NAME_SERVER query "); cmd = cmd + name + "\n"; YARPString result = send(cmd,true); Params p(result.c_str()); if (p.size()>=9) { // registration name /bozo ip 5.255.112.225 port 10002 type tcp const char *ip = p.get(4); int port = atoi(p.get(6)); addr.set(port,ip); //addr.set_port_number(port); if (type!=NULL) { int tnum = 0; switch (p.get(8)[0]) { case 'u': tnum = YARP_UDP; break; case 's': tnum = YARP_SHMEM; break; case 'm': tnum = YARP_MCAST; break; case 't': tnum = YARP_TCP; break; default: tnum = -1; break; } *type = tnum; YNC("registration is for ip %s and port %d, type %d\n", ip, port, tnum); } return YARP_OK; } return YARP_FAIL; }
int TAO::SSLIOP::Acceptor::open_default (TAO_ORB_Core *orb_core, ACE_Reactor *reactor, int major, int minor, const char *options) { // Ensure that neither the endpoint configuration nor the ORB // configuration violate security measures. if (this->verify_secure_configuration (orb_core, major, minor) != 0) return -1; // Open the non-SSL enabled endpoints, then open the SSL enabled // endpoints. if (this->IIOP_SSL_Acceptor::open_default (orb_core, reactor, major, minor, options) == -1) return -1; // Now that each network interface's hostname has been cached, open // an endpoint on each network interface using the INADDR_ANY // address. ACE_INET_Addr addr; // this->ssl_component_.port is initialized to zero or it is set in // this->parse_options(). if (addr.set (this->ssl_component_.port, static_cast<ACE_UINT32> (INADDR_ANY), 1) != 0) return -1; return this->ssliop_open_i (orb_core, addr, reactor); }
Session_t SessionPoolImp::ISessionPool_connect(const string & connect_addr) { ACE_SOCK_Connector connector; ACE_INET_Addr addr; addr.set(connect_addr.c_str()); CellSession * cell_session = new CellSession(true); if (connector.connect(cell_session->peer(), addr) == -1) { DEF_LOG_ERROR("failed to connect the addr : <%s>, last error is <%d>\n", connect_addr.c_str(), ACE_OS::last_error()); return 0; } if (cell_session->setReadEvent() == -1) { DEF_LOG_ERROR("failed to call open of cell session, last error is <%d>\n", ACE_OS::last_error()); return 0; } if (m_socket_intput_buffer_size > 0) { cell_session->setBufSize(m_socket_intput_buffer_size, m_socket_output_buffer_size); } cell_session->setHandleInput(this); m_input_session_pool.handleSession(cell_session); m_output_session_pool.handleSession(cell_session); DEF_LOG_INFO("success to connect the addr <%s>\n", connect_addr.c_str()); if (NULL != m_handle_session_event) { m_handle_session_event->ISessionPoolEvent_newConnection(cell_session, cell_session->isClientSide()); } return cell_session; }
int YARPNameClient2::registerName(const char *name, const char *ip, const char *type, ACE_INET_Addr& addr) { YNC("registerName %s\n", name); YARPString cmd("NAME_SERVER register "); cmd = cmd + name + " tcp ... ... 10\n"; YARPString result = send(cmd,true); Params p(result.c_str()); if (p.size()>=9) { // registration name /bozo ip 5.255.112.225 port 10002 type tcp const char *ip = p.get(4); int port = atoi(p.get(6)); YNC("registration is for ip %s and port %d\n", ip, port); //addr.set(ip); addr.set(port,ip); YNC("confirm registration is for ip %s and port %d\n", addr.get_host_addr(), addr.get_port_number()); send(YARPString("NAME_SERVER set ") + name + " offers tcp udp mcast shmem\n"); send(YARPString("NAME_SERVER set ") + name + " accepts tcp udp mcast shmem\n"); return YARP_OK; } return YARP_FAIL; }
/* * Advance the address by 1, e.g., 239.255.0.1 => 239.255.0.2 * Note that the algorithm is somewhat simplistic, but sufficient for our * purpose. */ int advance_addr (ACE_INET_Addr &addr) { int a, b, c, d; ::sscanf (addr.get_host_addr (), "%d.%d.%d.%d", &a, &b, &c, &d); if (d < 255) ++d; else if (c < 255) { d = 1; ++c; } else if (b < 255) { d = 1; c = 0; ++b; } else if (a < 239) { d = 1; c = 0; b = 0; ++a; } else ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("advance_addr - Cannot advance multicast ") ACE_TEXT ("group address past %s\n"), addr.get_host_addr ()), -1); ACE_TCHAR buf[MAX_STRING_SIZE]; ACE_OS::sprintf (buf, ACE_TEXT ("%d.%d.%d.%d:%d"), a, b, c, d, addr.get_port_number ()); addr.set (buf); return 0; }
ACE_INET_Addr* NetworkUtils::get_ip_interface(const char* itf) { // Take advantage of the BSD getifaddrs function that simplifies // access to connected interfaces. struct ifaddrs *ifap = 0; struct ifaddrs *p_if = 0; if (::getifaddrs(&ifap) != 0) { return 0; } for (p_if = ifap; p_if != 0; p_if = p_if->ifa_next) { if (p_if->ifa_addr && p_if->ifa_addr->sa_family == AF_INET) { struct sockaddr_in *addr = reinterpret_cast<sockaddr_in *> (p_if->ifa_addr); // Sometimes the kernel returns 0.0.0.0 as the interface // address, skip those... if (addr->sin_addr.s_addr != INADDR_ANY) { //ACE_DEBUG((LM_DEBUG,ACE_TEXT("(%t|%T)JJJJJJJJJJJJJJJJ=%s\n", p_if->ifa_name); if (strcmp(p_if->ifa_name, itf) == 0) { //ACE_DEBUG((LM_DEBUG,ACE_TEXT("(%t|%T)JJJJJJJJJJJJJJJJ EHEHEHEHEH=%s\n", p_if->ifa_name); ACE_INET_Addr* addrItf = new ACE_INET_Addr(); addrItf->set((u_short) 0, addr->sin_addr.s_addr, 0); ::freeifaddrs(ifap); return addrItf; } } } } ::freeifaddrs(ifap); return 0; }
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 run_main (int argc, ACE_TCHAR *argv[]) { ACE_START_TEST (ACE_TEXT ("TP_Reactor_Test")); #if defined(ACE_HAS_THREADS) if (::parse_args (argc, argv) == -1) return -1; ::disable_signal (SIGPIPE, SIGPIPE); MyTask task1; Acceptor acceptor; Connector connector; if (task1.start (threads) == 0) { int rc = 0; ACE_INET_Addr addr (port); if (both != 0 || host == 0) // Acceptor rc += acceptor.start (addr); if (both != 0 || host != 0) { if (host == 0) host = ACE_LOCALHOST; if (addr.set (port, host, 1, addr.get_type ()) == -1) ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), host)); rc += connector.start (addr, senders); } if (rc > 0) ACE_OS::sleep (seconds); } task1.stop (); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\nNumber of Receivers objects = %d\n") ACE_TEXT ("\nNumber of Sender objects = %d\n"), acceptor.get_number_sessions (), connector.get_number_sessions ())); // As Reactor event loop now is inactive it is safe to destroy all // senders connector.stop (); acceptor.stop (); //Print statistic ACE_TCHAR bufs [256]; ACE_TCHAR bufr [256]; ACE_OS::sprintf ( bufs , ACE_TEXT ("%ld(%ld)"), connector.get_total_snd(), connector.get_total_w() ); ACE_OS::sprintf ( bufr , ACE_TEXT ("%ld(%ld)"), connector.get_total_rcv(), connector.get_total_r() ); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Connector/Senders total bytes: snd=%s rcv=%s\n"), bufs, bufr )); ACE_OS::sprintf ( bufs , ACE_TEXT ("%ld(%ld)"), acceptor.get_total_snd(), acceptor.get_total_w() ); ACE_OS::sprintf ( bufr , ACE_TEXT ("%ld(%ld)"), acceptor.get_total_rcv(), acceptor.get_total_r() ); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Acceptor/Receivers total bytes: snd=%s rcv=%s\n"), bufs, bufr )); #else /* ACE_HAS_THREADS */ ACE_UNUSED_ARG( argc ); ACE_UNUSED_ARG( argv ); #endif /* ACE_HAS_THREADS */ ACE_END_TEST; return 0; }
bool CProServerManager::Start() { //注册信号量 //if(0 != App_SigHandler::instance()->RegisterSignal(NULL)) //{ // return false; //} //启动TCP监听 int nServerPortCount = App_MainConfig::instance()->GetServerPortCount(); bool blState = false; for(int i = 0 ; i < nServerPortCount; i++) { ACE_INET_Addr listenAddr; _ServerInfo* pServerInfo = App_MainConfig::instance()->GetServerPort(i); if(NULL == pServerInfo) { OUR_DEBUG((LM_INFO, "[CProServerManager::Start]pServerInfo [%d] is NULL.\n", i)); return false; } int nErr = listenAddr.set(pServerInfo->m_nPort, pServerInfo->m_szServerIP); if(nErr != 0) { OUR_DEBUG((LM_INFO, "[CProServerManager::Start](%d)set_address error[%d].\n", i, errno)); return false; } //得到接收器 ProConnectAcceptor* pConnectAcceptor = m_ConnectAcceptorManager.GetConnectAcceptor(i); if(NULL == pConnectAcceptor) { OUR_DEBUG((LM_INFO, "[CProServerManager::Start]pConnectAcceptor[%d] is NULL.\n", i)); return false; } ACE_Proactor* pProactor = App_ProactorManager::instance()->GetAce_Proactor(REACTOR_CLIENTDEFINE); if(NULL == pProactor) { OUR_DEBUG((LM_INFO, "[CProServerManager::Start]App_ProactorManager::instance()->GetAce_Proactor(REACTOR_CLIENTDEFINE) is NULL.\n")); return false; } int nRet = pConnectAcceptor->open(listenAddr, 0, 1, MAX_ASYNCH_BACKLOG, 1, pProactor); if(-1 == nRet) { OUR_DEBUG((LM_INFO, "[CProServerManager::Start] pConnectAcceptor->open[%d] is error.\n", i)); OUR_DEBUG((LM_INFO, "[CProServerManager::Start] Listen from [%s:%d] error(%d).\n",listenAddr.get_host_addr(), listenAddr.get_port_number(), errno)); return false; } OUR_DEBUG((LM_INFO, "[CProServerManager::Start] Listen from [%s:%d] OK.\n", listenAddr.get_host_addr(), listenAddr.get_port_number())); } //启动UDP监听 int nUDPServerPortCount = App_MainConfig::instance()->GetUDPServerPortCount(); for(int i = 0 ; i < nUDPServerPortCount; i++) { ACE_INET_Addr listenAddr; _ServerInfo* pServerInfo = App_MainConfig::instance()->GetUDPServerPort(i); if(NULL == pServerInfo) { OUR_DEBUG((LM_INFO, "[CProServerManager::Start]UDP pServerInfo [%d] is NULL.\n", i)); return false; } CProactorUDPHandler* pProactorUDPHandler = App_ProUDPManager::instance()->Create(); if(NULL == pProactorUDPHandler) { OUR_DEBUG((LM_INFO, "[CProServerManager::Start] pProactorUDPHandler is NULL[%d] is error.\n", i)); return false; } else { int nErr = listenAddr.set(pServerInfo->m_nPort, pServerInfo->m_szServerIP); if(nErr != 0) { OUR_DEBUG((LM_INFO, "[CProServerManager::Start](%d)UDP set_address error[%d].\n", i, errno)); return false; } ACE_Proactor* pProactor = App_ProactorManager::instance()->GetAce_Proactor(REACTOR_CLIENTDEFINE); if(NULL == pProactor) { OUR_DEBUG((LM_INFO, "[CProServerManager::Start]UDP App_ProactorManager::instance()->GetAce_Proactor(REACTOR_CLIENTDEFINE) is NULL.\n")); return false; } if(0 != pProactorUDPHandler->OpenAddress(listenAddr, pProactor)) { OUR_DEBUG((LM_INFO, "[CProServerManager::Start] UDP Listen from [%s:%d] error(%d).\n",listenAddr.get_host_addr(), listenAddr.get_port_number(), errno)); return false; } OUR_DEBUG((LM_INFO, "[CProServerManager::Start] UDP Listen from [%s:%d] OK.\n", listenAddr.get_host_addr(), listenAddr.get_port_number())); } } //启动后台管理端口监听 if(App_MainConfig::instance()->GetConsoleSupport() == CONSOLE_ENABLE) { ACE_INET_Addr listenConsoleAddr; int nErr = listenConsoleAddr.set(App_MainConfig::instance()->GetConsolePort(), App_MainConfig::instance()->GetConsoleIP()); if(nErr != 0) { OUR_DEBUG((LM_INFO, "[CProServerManager::Start]listenConsoleAddr set_address error[%d].\n", errno)); return false; } ACE_Proactor* pProactor = App_ProactorManager::instance()->GetAce_Proactor(REACTOR_CLIENTDEFINE); if(NULL == pProactor) { OUR_DEBUG((LM_INFO, "[CProServerManager::Start]App_ProactorManager::instance()->GetAce_Proactor(REACTOR_CLIENTDEFINE) is NULL.\n")); return false; } int nRet = m_ProConsoleConnectAcceptor.open(listenConsoleAddr, 0, 1, MAX_ASYNCH_BACKLOG, 1, pProactor, true); if(-1 == nRet) { OUR_DEBUG((LM_INFO, "[CProServerManager::Start] m_ProConsoleConnectAcceptor.open is error.\n")); OUR_DEBUG((LM_INFO, "[CProServerManager::Start] Listen from [%s:%d] error(%d).\n",listenConsoleAddr.get_host_addr(), listenConsoleAddr.get_port_number(), errno)); return false; } } //启动日志服务线程 if(0 != AppLogManager::instance()->Start()) { AppLogManager::instance()->WriteLog(LOG_SYSTEM, "[CProServerManager::Init]AppLogManager is ERROR."); } else { AppLogManager::instance()->WriteLog(LOG_SYSTEM, "[CProServerManager::Init]AppLogManager is OK."); } /* //设置定时器策略(使用高精度定时器) (void) ACE_High_Res_Timer::global_scale_factor (); auto_ptr<ACE_Timer_Heap_Variable_Time_Source> tq(new ACE_Timer_Heap_Variable_Time_Source); tq->set_time_policy(&ACE_High_Res_Timer::gettimeofday_hr); App_TimerManager::instance()->timer_queue(tq); tq.release(); */ //启动定时器 if(0 != App_TimerManager::instance()->activate()) { OUR_DEBUG((LM_INFO, "[CProServerManager::Start]App_TimerManager::instance()->Start() is error.\n")); return false; } //先启动其他的Proactor,最后启动原始的Proactor,因为原始的会挂起线程,所以最后启动一下。 if(!App_ProactorManager::instance()->StartProactor()) { OUR_DEBUG((LM_INFO, "[CProServerManager::Start]App_ProactorManager::instance()->StartProactor is error.\n")); return false; } //启动中间服务器链接管理器 App_ClientProConnectManager::instance()->Init(App_ProactorManager::instance()->GetAce_Proactor(REACTOR_POSTDEFINE)); App_ClientProConnectManager::instance()->StartConnectTask(App_MainConfig::instance()->GetConnectServerCheck()); //初始化模块加载,因为这里可能包含了中间服务器连接加载 blState = App_ModuleLoader::instance()->LoadModule(App_MainConfig::instance()->GetModulePath(), App_MainConfig::instance()->GetModuleString()); if(false == blState) { OUR_DEBUG((LM_INFO, "[CProServerManager::Start]LoadModule is error.\n")); return false; } //开始消息处理线程 App_MessageService::instance()->Start(); //开始启动链接发送定时器 App_ProConnectManager::instance()->StartTimer(); //最后启动反应器 OUR_DEBUG((LM_INFO, "[CProServerManager::Start]App_ProactorManager::instance()->StartProactorDefault begin....\n")); if(!App_ProactorManager::instance()->StartProactorDefault()) { OUR_DEBUG((LM_INFO, "[CProServerManager::Start]App_ProactorManager::instance()->StartProactorDefault is error.\n")); return false; } return true; }
int TAO_IIOP_Connection_Handler::process_listen_point_list ( IIOP::ListenPointList &listen_list) { // Get the size of the list CORBA::ULong len = listen_list.length (); if (TAO_debug_level > 0 && len == 0) { TAOLIB_ERROR ((LM_ERROR, ACE_TEXT("TAO (%P|%t) - IIOP_Connection_Handler::") ACE_TEXT("process_listen_point_list, ") ACE_TEXT("Received list of size 0, check client config.\n"))); } // @@ We can only handle a single endpoint for now because the // transport is recached for each endpoint, loosing older // information. This means that when more than one listen_point is // sent, the cache will end up only being associated with the last // address. This poses a problem at invocation time because the // default endpoint selector steps through the profiles/endpoints // sequentially and will try and possibly succeed in connecting to // one of the earlier endpoints. My assumption is that when this // method is called, it is before the first attempt to connect to // any object in the target process, thus the first listen point in // the list will correspond with the first profile and thus that // should match the cache. // // Probably what needs to be done to make this model work well is to // allow the transport cache to have multiple keys reference the // same transport so that rather than recaching, we simply add a // key. len = 1; for (CORBA::ULong i = 0; i < len; ++i) { IIOP::ListenPoint listen_point = listen_list[i]; // since the supplied host/port could be unresolvable, the assigning // constructor of the INET addr should not be as it will emit an error // if the underlying set fails. An unresolvable address in this case // is OK, as it will only be used to find an already cached transport. ACE_INET_Addr addr; (void)addr.set(listen_point.port, listen_point.host.in ()); if (TAO_debug_level > 0) { TAOLIB_DEBUG ((LM_DEBUG, ACE_TEXT("TAO (%P|%t) - IIOP_Connection_Handler::") ACE_TEXT("process_listen_point_list, ") ACE_TEXT("Listening port [%d] on [%C]\n"), listen_point.port, listen_point.host.in ())); } // Construct an IIOP_Endpoint object using the host as provided // in the listen point list. We must use host in that form because // that's also how the ORB on the other side will advertise the host // in an IOR. TAO_IIOP_Endpoint endpoint (listen_point.host.in (), listen_point.port, addr); // Construct a property object TAO_Base_Transport_Property prop (&endpoint); // Mark the connection as bidirectional prop.set_bidir_flag (1); // The property for this handler has changed. Recache the // handler with this property if (this->transport ()->recache_transport (&prop) == -1) return -1; // Make the handler idle and ready for use this->transport ()->make_idle (); } return 0; }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { ACE_SOCK_Stream connection_stream; int c; printf("HZ = %d\n", HZ); if (argc < 2) goto usage; while ((c = getopt (argc, argv, "drstU:uvBDTb:f:l:n:p:A:O:L:xh:")) != -1) { switch (c) { case 'h': host = optarg; break; case 'x': new_line = 1; break; case 'L': title = optarg; break; case 'B': b_flag = 1; break; case 't': trans = 1; break; case 'r': trans = 0; break; case 'd': options |= SO_DEBUG; break; case 'D': #ifdef TCP_NODELAY nodelay = 1; #else fprintf (stderr, "ttcp: -D option ignored: TCP_NODELAY socket option not supported\n"); #endif break; case 'n': nbuf = atoi (optarg); break; case 'l': data_buf_len = atoi (optarg); break; case 's': sinkmode = !sinkmode; break; case 'p': port = atoi (optarg); break; case 'U': domain = PF_UNIX; domainname = optarg; break; case 'u': udp = 1; break; case 'v': verbose = 1; break; case 'A': bufalign = atoi (optarg); break; case 'O': bufoffset = atoi (optarg); break; case 'b': #if defined(SO_SNDBUF) || defined(SO_RCVBUF) sockbufsize = atoi (optarg); #else fprintf (stderr, "ttcp: -b option ignored: SO_SNDBUF/SO_RCVBUF socket options not supported\n"); #endif break; case 'f': fmt = *optarg; break; case 'T': touchdata = 1; break; default: goto usage; } } /* if transmitter, create remote address to transmit to. */ if (trans) { if (address.set (port, host) == -1) perror ("address.set"), exit (1); } /* else, receiver create address to listen on */ else { address.set (port); } total_msg_len = sizeof (long) + data_buf_len; // allocate the buffer message_buf = (Data_Control_Message *) malloc (total_msg_len); if (message_buf == 0) err ("malloc"); // if (bufalign != 0) // message_buf += (bufalign - ((int) message_buf % bufalign) + bufoffset) % bufalign; // let's go ahead and set the control message for every send right now message_buf->size_ = data_buf_len; session_control_buf.nbuf_ = nbuf; session_control_buf.size_ = data_buf_len; // // print out option values for trans and receiver // if (trans) { fprintf (stdout, "ttcp-t: data_buf_len=%d, nbuf=%d, align=%d/%d, port=%d", data_buf_len, nbuf, bufalign, bufoffset, port); if (sockbufsize) fprintf (stdout, ", sockbufsize=%d", sockbufsize); fprintf (stdout, " %s -> %s\n", domain == PF_INET ? (udp ? "udp" : "tcp") : "unix", host == 0 ? domainname : host); } else // receiver { fprintf (stdout, "ttcp-r: data_buf_len=%d, nbuf=%d, align=%d/%d, port=%d", data_buf_len, nbuf, bufalign, bufoffset, port); if (sockbufsize) fprintf (stdout, ", sockbufsize=%d", sockbufsize); fprintf (stdout, " %s\n", domain == PF_INET ? (udp ? "udp" : "tcp") : "unix"); } mes ("socket"); // // connect and accept // if (!udp) { signal (SIGPIPE, (SIG_TYP) sigpipe); /* the transmitter will set options and connect to receiver */ if (trans) { // turn off weird ack things if (nodelay) { struct protoent *p = getprotobyname ("tcp"); if (p && connection_stream.set_option (p->p_proto, TCP_NODELAY, (char *)& one, sizeof (one))) err ("setsockopt: nodelay"); mes ("nodelay"); } if (connector_factory.connect (connection_stream, address) == -1) perror ("connection failed"), exit (1); fprintf (stdout, "ttcp-t: data_buf_len=%d, nbuf=%d, align=%d/%d, port=%d", data_buf_len, nbuf, bufalign, bufoffset, port); if (sockbufsize) { if (connection_stream.set_option (SOL_SOCKET, SO_SNDBUF, (char *) &sockbufsize, sizeof sockbufsize) == -1) err ("acceptor_factory.set_option"); mes ("sndbuf"); } } /* receiver will listen for connections from the transmitter */ else { if (acceptor_factory.open (address, 1) == -1) perror ("acceptor open"), exit (1); if (sockbufsize) { if (connection_stream.set_option (SOL_SOCKET, SO_RCVBUF, (char *) &sockbufsize, sizeof sockbufsize) == -1) err ("acceptor_factory.set_option"); mes ("rcvbuf"); } ACE_INET_Addr remote_address; if (acceptor_factory.accept (connection_stream, (ACE_Addr *) &remote_address) == -1) perror ("acceptor accept"), exit (1); // set the window size fprintf (stderr, "ttcp-r: accept from %s\n", remote_address.get_host_name()); } } // // start timer // errno = 0; if (trans) { pattern (& (message_buf->data_), data_buf_len); prep_timer (); ACE_DEBUG ((LM_DEBUG, "Sending session control message" " nbuf %d, size %d\n", session_control_buf.nbuf_, session_control_buf.size_)); if (connection_stream.send_n ((char *) &session_control_buf, sizeof (Session_Control_Message)) != sizeof (Session_Control_Message)) ACE_ERROR_RETURN ((LM_ERROR, "%p send session control failed\n", "ttcp"), -1); long ack; int send_result; while (nbuf--) { send_result = connection_stream.send_n ((char *) message_buf, total_msg_len); if (send_result != total_msg_len) ACE_ERROR_RETURN ((LM_ERROR, "%p only sent %d of %d bytes on call %d\n", "ttcp", send_result, total_msg_len, numCalls + 1), -1); numCalls++; nbytes += data_buf_len; if (connection_stream.recv_n ((char *) &ack, sizeof ack) != sizeof ack) ACE_ERROR_RETURN ((LM_ERROR, "%p recv of ack failed\n", "ttcp"), -1); if (ack != data_buf_len) ACE_DEBUG ((LM_DEBUG, "received ack for only %d bytes\n", ack)); } printf("Client finished.\n"); } else { prep_timer (); if (connection_stream.recv_n ((char *) &session_control_buf, sizeof (Session_Control_Message)) != sizeof (Session_Control_Message)) ACE_ERROR_RETURN ((LM_ERROR, "%p recv session control failed\n", "ttcp"), -1); ACE_DEBUG ((LM_DEBUG, "received session control message" " nbuf %d, size %d\n", session_control_buf.nbuf_, session_control_buf.size_)); nbuf = session_control_buf.nbuf_; // ignore session_control_buf.size_ for now long cnt; while (nbuf--) { if (connection_stream.recv_n ((char *) message_buf, sizeof (long)) != sizeof (long)) ACE_ERROR_RETURN ((LM_ERROR, "%p recv data control failed\n", "ttcp"), -1); cnt = connection_stream.recv_n (& (message_buf->data_), message_buf->size_); if (cnt != message_buf->size_) ACE_ERROR_RETURN ((LM_ERROR, "recv data failed\n"), -1); numCalls++; nbytes += cnt; if (connection_stream.send_n ((char *) &cnt, sizeof cnt) != sizeof cnt) ACE_ERROR_RETURN ((LM_ERROR, "%p send ack failed\n", "ttcp"), -1); } printf("Server finished.\n"); } /* if (errno) err ("IO"); */ // // stop the timer // (void) read_timer (stats, sizeof (stats)); if (udp && trans) { (void) Nwrite (connection_stream, message_buf, 4); /* rcvr end */ (void) Nwrite (connection_stream, message_buf, 4); /* rcvr end */ (void) Nwrite (connection_stream, message_buf, 4); /* rcvr end */ (void) Nwrite (connection_stream, message_buf, 4); /* rcvr end */ } if (cput <= 0.0) cput = 0.001; if (realt <= 0.0) realt = 0.001; #if defined (LM_RESULTS) if (trans && (title != 0)) { double tmp; FILE *fd; char filename[BUFSIZ]; ACE_OS::sprintf (filename, "%s.results", title); fd = fopen(filename,"a+"); if (new_line) fprintf(fd,"\n -l %ldk \t", data_buf_len/1024); tmp = ((double) nbytes) / realt; fprintf(fd,"%.2f ", tmp * 8.0 / 1024.0 / 1024.0); fclose(fd); } #endif fprintf (stdout, "ttcp%s: %ld bytes in %.2f real seconds = %s/sec +++\n", trans ? "-t" : "-r", nbytes, realt, outfmt (((double) nbytes) / realt)); if (verbose) { fprintf (stdout, "ttcp%s: %ld bytes in %.2f CPU seconds = %s/cpu sec\n", trans ? "-t" : "-r", nbytes, cput, outfmt (((double) nbytes) / cput)); } fprintf (stdout, "ttcp%s: %d I/O calls, msec/call = %.2f, calls/sec = %.2f\n", trans ? "-t" : "-r", numCalls, 1024.0 * realt / ((double) numCalls), ((double) numCalls) / realt); fprintf (stdout, "ttcp%s: %s\n", trans ? "-t" : "-r", stats); if (verbose) { fprintf (stdout, "ttcp%s: buffer address %#x\n", trans ? "-t" : "-r", message_buf); } exit (0); usage: fprintf (stderr, Usage); return 1; }