bool
ACE_INET_Addr::operator == (const ACE_INET_Addr &sap) const
{
ACE_TRACE ("ACE_INET_Addr::operator ==");
if (this->get_type () != sap.get_type ()
|| this->get_size () != sap.get_size ())
return false;
return (ACE_OS::memcmp (&this->inet_addr_,
&sap.inet_addr_,
this->get_size ()) == 0);
}
int
Peer_Factory::info (ACE_TCHAR **strp, size_t length) const
{
ACE_TCHAR buf[BUFSIZ];
ACE_TCHAR consumer_addr_str[BUFSIZ];
ACE_TCHAR supplier_addr_str[BUFSIZ];
ACE_INET_Addr addr;
if (this->consumer_acceptor_.acceptor ().get_local_addr (addr) == -1)
return -1;
else if (addr.addr_to_string (consumer_addr_str,
sizeof addr) == -1)
return -1;
else if (this->supplier_acceptor_.acceptor ().get_local_addr (addr) == -1)
return -1;
else if (addr.addr_to_string (supplier_addr_str,
sizeof addr) == -1)
return -1;
ACE_OS::strcpy (buf, ACE_TEXT ("peerd\t C:"));
ACE_OS::strcat (buf, consumer_addr_str);
ACE_OS::strcat (buf, ACE_TEXT ("|S:"));
ACE_OS::strcat (buf, supplier_addr_str);
ACE_OS::strcat
(buf, ACE_TEXT ("/tcp # Gateway traffic generator and data sink\n"));
if (*strp == 0 && (*strp = ACE_OS::strdup (buf)) == 0)
return -1;
else
ACE_OS::strncpy (*strp, buf, length);
return ACE_OS::strlen (buf);
}
int
Peer_Connector::open_connector (Peer_Handler *&peer_handler,
u_short port)
{
// This object only gets allocated once and is just recycled
// forever.
ACE_NEW_RETURN (peer_handler,
Peer_Handler,
-1);
ACE_INET_Addr addr (port,
Options::instance ()->connector_host ());
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("connecting to %s:%d\n"),
addr.get_host_name (),
addr.get_port_number ()));
if (this->connect (peer_handler, addr) == -1)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("connect")),
-1);
else
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("connected to %C:%d\n"),
addr.get_host_name (),
addr.get_port_number ()));
return 0;
}
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;
}
int
ACE_Service_Manager::info (ACE_TCHAR **strp, size_t length) const
{
ACE_TRACE ("ACE_Service_Manager::info");
ACE_INET_Addr sa;
ACE_TCHAR buf[BUFSIZ];
if (this->acceptor_.get_local_addr (sa) == -1)
{
return -1;
}
ACE_OS::sprintf (buf,
ACE_TEXT ("%d/%s %s"),
sa.get_port_number (),
ACE_TEXT ("tcp"),
ACE_TEXT ("# lists all services in the daemon\n"));
if (*strp == 0 && (*strp = ACE_OS::strdup (buf)) == 0)
{
return -1;
}
else
{
ACE_OS::strsncpy (*strp, buf, length);
}
return static_cast<int> (ACE_OS::strlen (buf));
}
int send_dgram (ACE_SOCK_Dgram &socket, ACE_INET_Addr addr, int done = 0)
{
// Send each message twice, once to the right port, and once to the "wrong"
// port. This helps generate noise and lets us see if port filtering is
// working properly.
const char *address = addr.get_host_addr ();
int port = addr.get_port_number ();
for (int i = 0; i < 2; ++i)
{
char buf[MAX_STRING_SIZE];
if (done)
buf[0] = 0;
else
ACE_OS::snprintf (buf, MAX_STRING_SIZE, "%s/%d", address, port);
if (socket.send (buf, ACE_OS::strlen (buf),addr) == -1)
ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("Send to %C, %p\n"),
address,
ACE_TEXT ("send_dgram - error calling send on ")
ACE_TEXT ("ACE_SOCK_Dgram.")), -1);
addr.set_port_number (++port);
}
return 0;
}
CLocalIPPort CAceTCPServer::GetLocalIPPort(ACE_SOCK_Stream* ppeer){
CLocalIPPort local;
ACE_INET_Addr raddr;
ppeer->get_local_addr(raddr);
local.IP = raddr.get_host_addr();
local.port = raddr.get_port_number();
return local;
}
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;
}
int open (void)
{
ACE_INET_Addr ClientaddrRemote;
this->peer().get_remote_addr(ClientaddrRemote);
ACE_OS::printf("[CConnectHandler::open] Connection from [%s:%d]\n", ClientaddrRemote.get_host_addr(), ClientaddrRemote.get_port_number());
//注册读就绪回调函数
return this->reactor ()->register_handler(this, ACE_Event_Handler::READ_MASK);
}
bool
RtpsUdpTransport::configure_i(TransportInst* config)
{
config_i_ = RtpsUdpInst_rch(dynamic_cast<RtpsUdpInst*>(config), false);
if (config_i_.is_nil()) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: ")
ACE_TEXT("RtpsUdpTransport::configure_i: ")
ACE_TEXT("invalid configuration!\n")),
false);
}
// Override with DCPSDefaultAddress.
if (this->config_i_->local_address() == ACE_INET_Addr () &&
!TheServiceParticipant->default_address ().empty ()) {
this->config_i_->local_address(0, TheServiceParticipant->default_address ().c_str ());
}
// Open the socket here so that any addresses/ports left
// unspecified in the RtpsUdpInst are known by the time we get to
// connection_info_i(). Opening the sockets here also allows us to
// detect and report errors during DataReader/Writer setup instead
// of during association.
if (!open_appropriate_socket_type(unicast_socket_, config_i_->local_address())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: ")
ACE_TEXT("RtpsUdpTransport::configure_i: open_appropriate_socket_type:")
ACE_TEXT("%m\n")),
false);
}
if (config_i_->local_address().get_port_number() == 0) {
ACE_INET_Addr address;
if (unicast_socket_.get_local_addr(address) != 0) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: RtpsUdpDataLink::configure_i - %p\n"),
ACE_TEXT("cannot get local addr")), false);
}
config_i_->local_address_set_port(address.get_port_number());
}
create_reactor_task();
if (config_i_->opendds_discovery_default_listener_) {
RtpsUdpDataLink_rch link =
make_datalink(config_i_->opendds_discovery_guid_.guidPrefix);
link->default_listener(config_i_->opendds_discovery_default_listener_);
default_listener_ =
dynamic_cast<TransportClient*>(config_i_->opendds_discovery_default_listener_);
}
return true;
}
bool
RtpsUdpTransport::configure_i(TransportInst* config)
{
config_i_ = RtpsUdpInst_rch(dynamic_cast<RtpsUdpInst*>(config), false);
if (config_i_.is_nil()) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: ")
ACE_TEXT("RtpsUdpTransport::configure_i: ")
ACE_TEXT("invalid configuration!\n")),
false);
}
// Open the socket here so that any addresses/ports left
// unspecified in the RtpsUdpInst are known by the time we get to
// connection_info_i(). Opening the sockets here also allows us to
// detect and report errors during DataReader/Writer setup instead
// of during association.
if (unicast_socket_.open(config_i_->local_address_) != 0) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: ")
ACE_TEXT("RtpsUdpTransport::configure_i: socket open:")
ACE_TEXT("%m\n")),
false);
}
if (config_i_->local_address_.is_any()) {
OpenDDS::DCPS::get_fully_qualified_hostname(&config_i_->local_address_);
}
if (config_i_->local_address_.get_port_number() == 0) {
ACE_INET_Addr address;
if (unicast_socket_.get_local_addr(address) != 0) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: RtpsUdpDataLink::configure_i - %p\n"),
ACE_TEXT("cannot get local addr")), false);
}
config_i_->local_address_.set_port_number(address.get_port_number());
}
create_reactor_task();
if (config_i_->opendds_discovery_default_listener_) {
RtpsUdpDataLink_rch link =
make_datalink(config_i_->opendds_discovery_guid_.guidPrefix);
link->default_listener(config_i_->opendds_discovery_default_listener_);
default_listener_ =
dynamic_cast<TransportClient*>(config_i_->opendds_discovery_default_listener_);
}
return true;
}
/**
* Receiver::handle_input()
*
* Description:
* Called when input is available
*/
int Receiver::handle_input() {
if (connected_) {
// TODO: Check if really needed! (Try not to read all data from socket)
Miro::Guard guard(mutex_); /* needed for timeout handling */
CORBA::ULong header[HEADER_SIZE / sizeof(CORBA::ULong) + ACE_CDR::MAX_ALIGNMENT];
EventData eventData;
iovec iov[1];
ACE_INET_Addr from;
switch (receiveData(iov, from)) {
case -1:
PRINT_DBG(DBG_INFO, "handleInput: read");
return -1;
case 0:
PRINT_DBG(DBG_INFO, "handleInput: read 0");
return 0;
default:
/* fall through */
break;
}
/* Check if paket was sent locally and if so, drop it */
if (is_loopback(from))
return 0;
//#if DEBUG_LEVEL == DBG_TOOMUCH
struct in_addr ia;
ia.s_addr = htonl(from.get_ip_address());
PRINT("Datagram from " << inet_ntoa(ia) << ":" << from.get_port_number());
//#endif
/* Process packet */
memcpy(header, ((char *)iov[0].iov_base ), sizeof(header));
char *buf = ACE_reinterpret_cast(char *, header);
TAO_InputCDR headerCdr(buf, sizeof(header), (int)buf[0]);
eventData.systemTimestamp = ACE_OS::gettimeofday().msec();
headerCdr.read_boolean(eventData.byteOrder);
headerCdr.read_ulong(eventData.requestId);
headerCdr.read_ulong(eventData.requestSize);
headerCdr.read_ulong(eventData.fragmentSize);
headerCdr.read_ulong(eventData.fragmentOffset);
headerCdr.read_ulong(eventData.fragmentId);
headerCdr.read_ulong(eventData.fragmentCount);
headerCdr.read_ulong(eventData.timestamp);
cout << "test" << endl;
handle_event(eventData, iov);
}
return 0;
}
void
TAO_UIPMC_Endpoint::object_addr (const ACE_INET_Addr &addr)
{
this->port_ = addr.get_port_number();
char tmp[INET6_ADDRSTRLEN];
addr.get_host_addr (tmp, sizeof tmp);
this->host_ = CORBA::string_dup (tmp);
this->object_addr_.set (addr);
this->uint_ip_addr (addr.get_ip_address ());
}
int chromatic_handler::open ( void* accept )
{
ACE_Trace _( ACE_TEXT( "chromatic_handler::open" ) , __LINE__ );
output_boiler_plate();
map_commands();
silent( false );
acceptor ( (chromatic_imap_acceptor_ptr) accept);
m_ptrImap = new chromatic_imap_mgr( acceptor()->Data()->default_host() ,
acceptor()->Data()->dn() ,
this );
string strConcurrency;
//check for timeout every 30 seconds
ACE_Time_Value reschedule( m_maximumTimeToWait.sec() / 60 );
m_dwTimerToken = reactor()->schedule_timer( this , (void*) timer_id , m_maximumTimeToWait , reschedule );
if ( concurrency () == concurrency_t::thread_per_connection_ )
{
return activate ( THR_DETACHED );
}
reactor ( acceptor()->reactor () );
ACE_INET_Addr addr;
if ( peer ().get_remote_addr (addr) == -1 )
{
return ( -1 );
}
if ( reactor ()->register_handler ( this,
REGISTER_MASK ) == -1 )
{
ACE_ERROR_RETURN ((LM_ERROR,
"(%P|%t) can't register with reactor\n"),
-1);
}
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) connected with %s\n",
addr.get_host_name ()));
return ( 0L );
}
int run_main (int argc, ACE_TCHAR *argv[])
{
ACE_START_TEST (ACE_TEXT ("FlReactor_Test"));
Fl_Window window (300, 370);
Test_Window tw (10, 75, window.w () - 20, window.h ()-90);
window.resizable (&tw);
Fl_Hor_Slider slider (60, 5, window.w () - 70, 30, "Sides:");
slider.align (FL_ALIGN_LEFT);
slider.callback (sides_cb, &tw);
slider.value (tw.sides ());
slider.step (1);
slider.bounds (3, 10);
ACE_FlReactor reactor;
ACE_Reactor r (&reactor);
Fl_Box *box = new Fl_Box (FL_UP_BOX, 10, 40,
window.w () - 20, 30,
"Setting up");
box->labelfont (FL_BOLD);
Acceptor acceptor (&tw, box);
ACE_INET_Addr address;
if (acceptor.open (address, &r) == -1)
ACE_ERROR_RETURN ((LM_ERROR,
"%p\n",
"open acceptor"),
-1);
acceptor.acceptor ().get_local_addr (address);
const int bufsiz = 128;
char buf[bufsiz];
address.addr_to_string (buf, bufsiz, 0);
char msg[2 * bufsiz];
ACE_OS::sprintf (msg, "Listening on <%s>\n", buf);
box->label (msg);
box->redraw ();
window.end ();
window.show (argc, argv);
tw.show ();
return Fl::run ();
ACE_END_TEST;
}
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;
}
int ProactorServerAcceptor::validate_connection(const ACE_Asynch_Accept::Result& Result, const ACE_INET_Addr& Remote, const ACE_INET_Addr& Local)
{
struct in_addr* remote_addr = reinterpret_cast<struct in_addr*>(Remote.get_addr());
struct in_addr* local_addr = reinterpret_cast <struct in_addr*>(Local.get_addr());
ACE_UNUSED_ARG(Result);
ACE_UNUSED_ARG(Remote);
ACE_UNUSED_ARG(Local);
return 0;
}
bool
RtpsUdpTransport::map_ipv4_to_ipv6() const
{
bool map = false;
ACE_INET_Addr tmp;
link_->unicast_socket().get_local_addr(tmp);
if (tmp.get_type() != AF_INET) {
map = true;
}
return map;
}
// Registers the new ClientService instance with the reactor
//
// We try to print a log message stating which host connected, then call ACE_Reactor::register_handler()
// to register for input events with the reactor. We return the return value of register_handler(),
// which is 0 for success and �for failure. This value is passed back to the ClientAcceptor::handle_input() method,
// and handle_input() also will return �for error and 0 for success.
// If ClientAcceptor::handle_input() returns �we will have to close the handle.
//
int ClientService::open()
{
ACE_TCHAR peerName[MAXHOSTNAMELEN];
ACE_INET_Addr peerAddress;
if (this->m_socket.get_remote_addr(peerAddress) == 0 && peerAddress.addr_to_string(peerName, MAXHOSTNAMELEN) == 0)
{
ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) Connection from %s\n"), peerName));
}
return this->reactor()->register_handler(this, ACE_Event_Handler::READ_MASK);
}
string chromatic_handler::client_addr()
{
ACE_INET_Addr addr;
char addrstr[MAXHOSTNAMELEN + 1];
peer().get_remote_addr( addr );
addr.addr_to_string( addrstr , sizeof( addrstr ) );
string strTemp( addrstr );
return ( strTemp );
}
int
TAO_AV_TCP_Flow_Handler::open (void * /*arg*/)
{
#if defined (TCP_NODELAY)
int nodelay = 1;
if (this->peer ().set_option (IPPROTO_TCP,
TCP_NODELAY,
(void *) &nodelay,
sizeof (nodelay)) == -1)
ORBSVCS_ERROR_RETURN ((LM_ERROR,
"NODELAY failed\n"),
-1);
#endif /* TCP_NODELAY */
int buf_size = BUFSIZ;
int s = sizeof (buf_size);
if (this->peer ().get_option (SOL_SOCKET, /*IPPROTO_TCP,*/
SO_RCVBUF,
(void *) &buf_size, &s) == -1)
buf_size = BUFSIZ;
((TAO_AV_TCP_Object*)(this->protocol_object_))->frame_.size (buf_size);
// Called by the <Strategy_Acceptor> when the handler is completely
// connected.
ACE_INET_Addr addr;
if (this->peer ().get_remote_addr (addr) == -1)
return -1;
ACE_TCHAR server[MAXHOSTNAMELEN + 16];
(void) addr.addr_to_string (server, sizeof (server));
if (TAO_debug_level > 0)
if (TAO_debug_level > 0) ORBSVCS_DEBUG ((LM_DEBUG,
"(%P|%t) connection to server <%s> on %d\n",
server, this->peer ().get_handle ()));
this->peer ().enable (ACE_NONBLOCK);
// Register the handler with the reactor.
if (this->reactor ()
&& this->reactor ()->register_handler
(this,
ACE_Event_Handler::READ_MASK) == -1)
ORBSVCS_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("unable to register client handler")),
-1);
return 0;
}
int
ACE_MEM_Addr::same_host (const ACE_INET_Addr &sap)
{
ACE_TRACE ("ACE_MEM_Addr::same_host");
// ACE_INET_Addr::operator== takes port number into account, so get
// the addresses without a port number and compare.
ACE_INET_Addr me (this->external_);
ACE_INET_Addr you (sap);
me.set_port_number (0);
you.set_port_number (0);
return me == you;
}
int Make_Common_Dispose_Client_WorkTread_Message(uint16 u2CommandID, uint32 u4ServerID, ACE_Message_Block* pmblk, ACE_INET_Addr& AddrRemote)
{
//组织数据
CMessage* pMessage = App_MessageServiceGroup::instance()->CreateMessage(u4ServerID, CONNECT_IO_TCP);
if (NULL == pMessage)
{
//放入消息框架失败
OUR_DEBUG((LM_ERROR, "[CConnectClient::SendMessageGroup] ConnectID = %d CreateMessage fail.\n", u4ServerID));
App_MessageBlockManager::instance()->Close(pmblk);
return -1;
}
else
{
ACE_Message_Block* pMBBHead = App_MessageBlockManager::instance()->Create(sizeof(uint32));
if (NULL == pMBBHead)
{
OUR_DEBUG((LM_ERROR, "[CConnectClient::SendMessageGroup] ConnectID = %d pMBBHead fail.\n", u4ServerID));
App_MessageBlockManager::instance()->Close(pmblk);
return -1;
}
//添加消息包头
uint32 u4PacketLen = (uint32)pmblk->length();
memcpy_safe((char*)&u4PacketLen, sizeof(uint32), pMBBHead->wr_ptr(), sizeof(uint32));
pMBBHead->wr_ptr(sizeof(uint32));
sprintf_safe(pMessage->GetMessageBase()->m_szListenIP, MAX_BUFF_20, "%s", AddrRemote.get_host_addr());
sprintf_safe(pMessage->GetMessageBase()->m_szIP, MAX_BUFF_20, "127.0.0.1");
pMessage->GetMessageBase()->m_u2Cmd = u2CommandID;
pMessage->GetMessageBase()->m_u4ConnectID = u4ServerID;
pMessage->GetMessageBase()->m_u4ListenPort = (uint32)AddrRemote.get_port_number();
pMessage->GetMessageBase()->m_tvRecvTime = ACE_OS::gettimeofday();
pMessage->GetMessageBase()->m_u1ResouceType = RESOUCE_FROM_SERVER;
pMessage->GetMessageBase()->m_u4HeadSrcSize = sizeof(uint32);
pMessage->GetMessageBase()->m_u4BodySrcSize = u4PacketLen;
pMessage->SetPacketHead(pMBBHead);
pMessage->SetPacketBody(pmblk);
//将要处理的消息放入消息处理线程
if (false == App_MessageServiceGroup::instance()->PutMessage(pMessage))
{
OUR_DEBUG((LM_ERROR, "[CConnectClient::SendMessageGroup] App_MessageServiceGroup::instance()->PutMessage Error.\n"));
App_MessageServiceGroup::instance()->DeleteMessage(u4ServerID, pMessage);
return -1;
}
}
return 0;
}
int RASocket::open(void *)
{
ACE_INET_Addr remoteAddress;
if (peer().get_remote_addr(remoteAddress) == -1)
{
TC_LOG_ERROR(LOG_FILTER_WORLDSERVER, "RASocket::open: peer().get_remote_addr error is %s", ACE_OS::strerror(errno));
return -1;
}
TC_LOG_INFO(LOG_FILTER_REMOTECOMMAND, "Incoming connection from %s", remoteAddress.get_host_addr());
return activate();
}
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;
}
int RASocket::open(void *)
{
ACE_INET_Addr remoteAddress;
if (peer().get_remote_addr(remoteAddress) == -1)
{
TC_LOG_ERROR("server.worldserver", "RASocket::open: peer().get_remote_addr error is %s", ACE_OS::strerror(errno));
return -1;
}
TC_LOG_INFO("commands.ra", "Incoming connection from %s", remoteAddress.get_host_addr());
return activate();
}
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;
}
int HDS_UDP_EXPORT_API send(ACE_Message_Block * block , ACE_INET_Addr& ace_addr ,
HDS_UDP_SENDED_DEL_TYPE del_type)
{
SOCKADDR_IN remoteAddr;
remoteAddr.sin_family=AF_INET; //这个值对以后会有影响
remoteAddr.sin_addr.s_addr=htonl(ace_addr.get_ip_address());// ace_remoteAddr.get_ip_address();
remoteAddr.sin_port=htons(ace_addr.get_port_number());//ace_remoteAddr.get_port_number();
int res = kernel_send(block->rd_ptr(),block->length(),0,(sockaddr*)&remoteAddr,sizeof(SOCKADDR_IN));
if(del_type == DELETE_AFTER_SEND)
{
block->release();
}
return res;
}
int RASocket::open(void *)
{
ACE_INET_Addr remoteAddress;
if (peer().get_remote_addr(remoteAddress) == -1)
{
sLog->outError("RASocket::open: peer().get_remote_addr error is %s", ACE_OS::strerror(errno));
return -1;
}
sLog->outRemote("Incoming connection from %s", remoteAddress.get_host_addr());
return activate();
}
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;
}
