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
}
