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