Peer_Router_Context::Peer_Router_Context (u_short port) : reference_count_ (0) { // Initialize the Acceptor's "listen-mode" socket. ACE_INET_Addr endpoint (port); if (this->open (endpoint) == -1) ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("Acceptor::open"))); // Initialize the connection map. else if (this->peer_map_.open () == -1) ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("Map_Manager::open"))); else { ACE_INET_Addr addr; if (this->acceptor ().get_local_addr (addr) != -1) ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) initializing %C on port = %d, handle = %d, this = %u\n"), addr.get_port_number () == Options::instance ()->supplier_port () ? "Supplier_Handler" : "Consumer_Handler", addr.get_port_number (), this->acceptor().get_handle (), this)); else ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("get_local_addr"))); } }
/// This method is called by a TcpConnection object that has been /// created and opened by our acceptor_ as a result of passively /// accepting a connection on our local address. Ultimately, the connection /// object needs to be paired with a DataLink object that is (or will be) /// expecting this passive connection to be established. void TcpTransport::passive_connection(const ACE_INET_Addr& remote_address, const TcpConnection_rch& connection) { DBG_ENTRY_LVL("TcpTransport", "passive_connection", 6); const PriorityKey key(connection->transport_priority(), remote_address, remote_address == tcp_config_->local_address_, connection->is_connector()); VDBG_LVL((LM_DEBUG, ACE_TEXT("(%P|%t) TcpTransport::passive_connection() - ") ACE_TEXT("established with %C:%d.\n"), remote_address.get_host_name(), remote_address.get_port_number()), 2); GuardType connection_guard(connections_lock_); TcpDataLink_rch link; { GuardType guard(links_lock_); links_.find(key, link); } if (!link.is_nil()) { connection_guard.release(); if (connect_tcp_datalink(link, connection) == -1) { VDBG_LVL((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: connect_tcp_datalink failed\n")), 5); GuardType guard(links_lock_); links_.unbind(key); } else { con_checker_->add(connection); } return; } // If we reach this point, this link was not in links_, so the // accept_datalink() call hasn't happened yet. Store in connections_ for the // accept_datalink() method to find. VDBG_LVL((LM_DEBUG, "(%P|%t) # of bef connections: %d\n", connections_.size()), 5); const ConnectionMap::iterator where = connections_.find(key); if (where != connections_.end()) { ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: TcpTransport::passive_connection() - ") ACE_TEXT("connection with %C:%d at priority %d already exists, ") ACE_TEXT("overwriting previously established connection.\n"), remote_address.get_host_name(), remote_address.get_port_number(), connection->transport_priority())); } connections_[key] = connection; VDBG_LVL((LM_DEBUG, "(%P|%t) # of after connections: %d\n", connections_.size()), 5); con_checker_->add(connection); }
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; }
int CACETrbNetAcceptorImpl::validate_connection( const TRB_Asynch_Accept::Result& result, const ACE_INET_Addr& remote, const ACE_INET_Addr& local) { SInetAddress remote1; SInetAddress local1; local1.ip = local.get_ip_address(); local1.port = local.get_port_number(); remote1.ip = remote.get_ip_address(); remote1.port = remote.get_port_number(); INetAcceptor* acceptor = getAcceptor(); if (!acceptor) { return -1; } //to check and block ip if (!acceptor->onCheckAddress(local1, remote1)) { return -1; } return 0; }
int MyAcceptor::handleConnection() { int newConnSock = acceptConnection(); if (newConnSock <= 0) { PAS_ERROR2( "MyAcceptor:: accept ERROR %s. new sock fd = %d", ACE_OS::strerror(ACE_OS::last_error()), newConnSock); usleep(100000); return -1; } /// 단말기의 IP 주소를 구하기. ACE_SOCK_STREAM sock(newConnSock); ACE_INET_Addr peer; sock.get_remote_addr( peer ); PAS_INFO4( "Accept %s:%d sock=%d conn[%d] ", peer.get_host_addr(), peer.get_port_number(), newConnSock, numAccepts); numAccepts++; if (numAccepts > 10000 * 10000 * 10) numAccepts = 0; // L4 Health check ignore Config *conf = Config::instance(); if( !strcmp(peer.get_host_addr(), conf->network.L4Addr1.toStr()) || !strcmp(peer.get_host_addr(), conf->network.L4Addr2.toStr()) ) { #if 0 // set SO_LINGER - 2 sec. WIGCS 로부터 받은 팁. 2007.1.12 linger lingtime; lingtime.l_onoff = 1; lingtime.l_linger = 2; sock.set_option( SOL_SOCKET, SO_LINGER, (void*)&lingtime, sizeof(linger) ); #endif sock.close_writer(); sock.close(); PAS_INFO3( "Close L4 %s:%d sock=%d", peer.get_host_addr(), peer.get_port_number(), newConnSock); return 0; } ReactorInfo* rInfo = ReactorPool::instance()->workerReactor(); ClientHandler* pClientEH = new ClientHandler(rInfo); pClientEH->init(newConnSock); // reactor에 새로운 client 등록 // pClientEH 는 소켓이 종료될때 스스로 자신을 메모리에서 삭제한다. rInfo->pReactor->register_handler(pClientEH, READ_MASK); return 0; }
int TAO_SCIOP_Endpoint::set (const ACE_INET_Addr &addr, int use_dotted_decimal_addresses) { char tmp_host[MAXHOSTNAMELEN + 1]; if (use_dotted_decimal_addresses || addr.get_host_name (tmp_host, sizeof (tmp_host)) != 0) { const char *tmp = addr.get_host_addr (); if (tmp == 0) { if (TAO_debug_level > 0) TAOLIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\n\nTAO (%P|%t) ") ACE_TEXT ("SCIOP_Endpoint::set ") ACE_TEXT ("- %p\n\n"), ACE_TEXT ("cannot determine hostname"))); return -1; } else this->host_ = tmp; } else this->host_ = CORBA::string_dup (tmp_host); this->port_ = addr.get_port_number(); return 0; }
int Supplier_Router::info (ACE_TCHAR **strp, size_t length) const { ACE_TCHAR buf[BUFSIZ]; ACE_INET_Addr addr; const ACE_TCHAR *module_name = this->name (); if (this->context ()->acceptor ().get_local_addr (addr) == -1) return -1; ACE_OS::sprintf (buf, FMTSTR, module_name, addr.get_port_number (), ACE_TEXT ("tcp"), ACE_TEXT ("# supplier router"), this->is_reader () ? ACE_TEXT ("reader") : ACE_TEXT ("writer")); if (*strp == 0 && (*strp = ACE_OS::strdup (module_name)) == 0) return -1; else ACE_OS::strncpy (*strp, module_name, length); return ACE_Utils::truncate_cast<int> (ACE_OS::strlen (module_name)); }
bool TcpFace::open(const Contact& address) { YARP_DEBUG(Logger::get(), std::string("opening for address ") + address.toURI()); this->address = address; #ifdef YARP_HAS_ACE ACE_INET_Addr serverAddr((address.getPort()>0)?address.getPort():0); int result = peerAcceptor.open(serverAddr, 1); if (address.getPort()<=0) { ACE_INET_Addr localAddr; peerAcceptor.get_local_addr(localAddr); this->address = address; this->address.setSocket("tcp", NameConfig::getHostName(), localAddr.get_port_number()); } #else int result = peerAcceptor.open(address); if (address.getPort()<=0) { this->address = address; this->address.setSocket("tcp", NameConfig::getHostName(), peerAcceptor.get_port_number()); } #endif if (result==-1) { return false; } return true; }
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)); }
bool P2pEndpoint::readMessage(ACE_INET_Addr& peerAddr, ACE_Message_Block& mblock) { assert(mblock.size() >= P2pConfig::defaultMtu); const ssize_t recvSize = udp_->recv(mblock.wr_ptr(), mblock.space(), peerAddr); if (recvSize == 0) { return false; } if (recvSize < 0) { const int error = ACE_OS::last_error(); if (error == EWOULDBLOCK) { return false; } //if (error == ECONNRESET) { // return false; //} NSRPC_LOG_ERROR4( ACE_TEXT("P2pEndpoint::readMessage(from: %s:%d) FAILED!!!(%d,%m)"), peerAddr.get_host_addr(), peerAddr.get_port_number(), ACE_OS::last_error()); return false; } mblock.wr_ptr(recvSize); return true; }
int RealmSocket::open(void * arg) { ACE_INET_Addr addr; if (peer().get_remote_addr(addr) == -1) { sLog->outError(LOG_FILTER_AUTHSERVER, "Error %s while opening realm socket!", ACE_OS::strerror(errno)); return -1; } _remoteAddress = addr.get_host_addr(); _remotePort = addr.get_port_number(); // Register with ACE Reactor if (Base::open(arg) == -1) return -1; if (session_) session_->OnAccept(); // reactor takes care of the socket from now on remove_reference(); return 0; }
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::sprintf (buf, "%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; }
bool P2pEndpoint::open(srpc::UInt16 port) { const ACE_INET_Addr localAddr(port); const int reuse_addr = 1; if (udp_->open(localAddr, ACE_PROTOCOL_FAMILY_INET, 0, reuse_addr) == -1) { NSRPC_LOG_ERROR2(ACE_TEXT("Can't open a UDP socket(port:%d)(%m)"), port); return false; } setMaximumSocketBufferSize(get_handle()); udp_->enable(ACE_NONBLOCK); workaroundWinsockConnectionResetProblem(get_handle()); const ACE_Reactor_Mask masks = ACE_Event_Handler::READ_MASK; if (reactor()->register_handler(this, masks) == -1) { NSRPC_LOG_ERROR2( ACE_TEXT("ACE_Reactor::register_handler() FAILED!!!(%d,%m)"), ACE_OS::last_error()); return false; } ACE_INET_Addr realAddress; if (0 != udp_->get_local_addr(realAddress)) { assert(false && "what's the matter!"); return false; } if (! setAddresses(realAddress.get_port_number())) { return false; } return true; }
bool Session_T<ACE_SYNCH_USE>::attach_connection (connection_type* connection) { INET_TRACE ("ACE_HTTP_Session::attach_connection"); if (!connection->is_connected ()) return false; this->close (); ACE_INET_Addr remote; connection->peer ().get_remote_addr (remote); this->host_ = remote.get_host_name (); this->port_ = remote.get_port_number (); this->connection_ = connection; this->connection_->add_reference (); ACE_NEW_NORETURN (this->sock_stream_, sock_stream_type (this->connection_)); if (this->sock_stream_) { this->keep_alive_ = true; this->keep_alive_timeout_ = ACE_Time_Value::zero; this->cannot_reconnect_ = true; return true; } else { this->close (); return false; } }
int ACE_MEM_Acceptor::accept (ACE_MEM_Stream &new_stream, ACE_MEM_Addr *remote_sap, ACE_Time_Value *timeout, int restart, int reset_new_handle) { ACE_TRACE ("ACE_MEM_Acceptor::accept"); int *len_ptr = 0; sockaddr *addr = 0; int in_blocking_mode = 1; if (this->shared_accept_start (timeout, restart, in_blocking_mode) == -1) return -1; else { do new_stream.set_handle (ACE_OS::accept (this->get_handle (), addr, len_ptr)); while (new_stream.get_handle () == ACE_INVALID_HANDLE && restart != 0 && errno == EINTR && timeout == 0); if (remote_sap != 0) { ACE_INET_Addr temp (ACE_reinterpret_cast (sockaddr_in *, addr), *len_ptr); remote_sap->set_port_number(temp.get_port_number ()); } }
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; }
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; }
SimpleAddressServer::SimpleAddressServer (const ACE_INET_Addr& address) { #if defined (ACE_HAS_IPV6) if (address.get_type() == PF_INET6) { RtecUDPAdmin::UDP_Addr_v6 v6; sockaddr_in6 *in6 = reinterpret_cast<sockaddr_in6 *>(address.get_addr()); ACE_OS::memcpy (v6.ipaddr,&in6->sin6_addr,16); v6.port = address.get_port_number(); this->address_.v6_addr (v6); return; } #endif /* ACE_HAS_IPV6 */ RtecUDPAdmin::UDP_Addr v4; v4.ipaddr = address.get_ip_address (); v4.port = address.get_port_number (); this->address_.v4_addr (v4); }
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; }
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; }
/** * 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 KSG_Service_Acceptor::open(const ACE_INET_Addr &local_addr) { if(acceptor_.open(local_addr) == -1) { ACE_DEBUG((LM_ERROR,"在端口[%d]侦听失败!",local_addr.get_port_number())); return -1; } this->reactor()->register_handler(this,ACE_Event_Handler::ACCEPT_MASK); return 0; }
int accept_connections(){ if (peer_acceptor_.get_local_addr(server_addr_) == -1){ ACE_ERROR_RETURN((LM_ERROR, "%p\n", "Error in get_local_addr"), 1); } ACE_DEBUG((LM_DEBUG, "Starting server at port %d\n", server_addr_.get_port_number())); while (1){ ACE_Time_Value timeout(ACE_DEFAULT_TIMEOUT); if (peer_acceptor_.accept(new_stream_, &client_addr_, &timeout)){ ACE_ERROR((LM_ERROR, "%p\n", "accept")); continue; } else{ ACE_DEBUG((LM_DEBUG, "Connection established with remote %s:%d\n", client_addr_.get_host_name(), client_addr_.get_port_number())); handle_connection(); } } }
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 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 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; }
int TAO_IIOP_Endpoint::set (const ACE_INET_Addr &addr, int use_dotted_decimal_addresses) { char tmp_host[MAXHOSTNAMELEN + 1]; #if defined (ACE_HAS_IPV6) this->is_ipv6_decimal_ = false; // Reset #endif /* ACE_HAS_IPV6 */ if (use_dotted_decimal_addresses || addr.get_host_name (tmp_host, sizeof (tmp_host)) != 0) { if (use_dotted_decimal_addresses == 0 && TAO_debug_level > 5) { TAOLIB_DEBUG ((LM_DEBUG, ACE_TEXT ("TAO (%P|%t) - IIOP_Endpoint::set, ") ACE_TEXT ("%p\n"), ACE_TEXT ("cannot determine hostname"))); } const char *tmp = addr.get_host_addr (); if (tmp == 0) { if (TAO_debug_level > 0) { TAOLIB_ERROR ((LM_ERROR, ACE_TEXT ("TAO (%P|%t) - IIOP_Endpoint::set, ") ACE_TEXT ("%p\n"), ACE_TEXT ("cannot determine hostname and hostaddr"))); } return -1; } else { this->host_ = tmp; #if defined (ACE_HAS_IPV6) if (addr.get_type () == PF_INET6) this->is_ipv6_decimal_ = true; #endif /* ACE_HAS_IPV6 */ } } else this->host_ = CORBA::string_dup (tmp_host); this->port_ = addr.get_port_number(); return 0; }
CORBA::Long IIOP_Current_Impl::remote_port (void) { #if defined (TAO_HAS_IIOP) && (TAO_HAS_IIOP != 0) TAO_IIOP_Connection_Handler *iiopch = this->handler (); ACE_INET_Addr a; iiopch->peer ().get_remote_addr (a); return a.get_port_number (); #else throw ::CORBA::NO_IMPLEMENT (); #endif }