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