int main () {
GC_init();
int sock = CHECK(socket, AF_INET, SOCK_STREAM, 0);
sockaddr_in listen_addr = any_addr();
printf("bind...\n");
CHECK(bind, sock, (sockaddr*)&listen_addr, sizeof(listen_addr));
printf("listen...\n");
CHECK(listen, sock, SOMAXCONN);
sockaddr_in client_addr;
socklen_t client_addr_len;
int new_sock;
printf("accept...\n");
do {
new_sock = CHECK(accept, sock, (sockaddr*)&client_addr, &client_addr_len);
char* message = recv_string(new_sock);
puts(message);
const char* response = process_message((const char*)message);
puts("Response generated.");
CHECK(send, new_sock, response, strlen(response) + 1, 0);
puts("Response sent.\n");
// char endbuf [MAX_BUFFER];
// CHECK(recv, new_sock, endbuf, MAX_BUFFER, 0);
// puts("Close request recieved.");
CHECK(close, new_sock);
} while (0);
CHECK(close, sock);
return 0;
}
TAO_Transport *
TAO_UIPMC_Connector::make_connection (TAO::Profile_Transport_Resolver *,
TAO_Transport_Descriptor_Interface &desc,
ACE_Time_Value *)
{
TAO_UIPMC_Endpoint *uipmc_endpoint =
dynamic_cast<TAO_UIPMC_Endpoint *> (desc.endpoint ());
if (uipmc_endpoint == 0)
return 0;
const ACE_INET_Addr &remote_address =
uipmc_endpoint->object_addr ();
#if defined (ACE_HAS_IPV6) && !defined (ACE_HAS_IPV6_V6ONLY)
// Check if we need to invalidate accepted connections
// from IPv4 mapped IPv6 addresses
if (this->orb_core ()->orb_params ()->connect_ipv6_only () &&
remote_address.is_ipv4_mapped_ipv6 ())
{
if (TAO_debug_level > 0)
{
ACE_TCHAR remote_as_string[MAXHOSTNAMELEN + 16];
(void) remote_address.addr_to_string (remote_as_string,
sizeof remote_as_string);
ORBSVCS_ERROR ((LM_ERROR,
ACE_TEXT ("TAO (%P|%t) - UIPMC_Connector::open, ")
ACE_TEXT ("invalid connection to IPv4 mapped IPv6 ")
ACE_TEXT ("interface <%s>!\n"),
remote_as_string));
}
return 0;
}
#endif /* ACE_HAS_IPV6 && ACE_HAS_IPV6_V6ONLY */
TAO_UIPMC_Connection_Handler *svc_handler = 0;
ACE_NEW_RETURN (svc_handler,
TAO_UIPMC_Connection_Handler (this->orb_core ()),
0);
// Make sure that we always do a remove_reference
ACE_Event_Handler_var svc_handler_auto_ptr (svc_handler);
u_short port = 0;
const ACE_UINT32 ia_any = INADDR_ANY;
ACE_INET_Addr any_addr(port, ia_any);
#if defined (ACE_HAS_IPV6)
if (remote_address.get_type () == AF_INET6)
any_addr.set (port,
ACE_IPV6_ANY);
#endif /* ACE_HAS_IPV6 */
ACE_INET_Addr local_addr(any_addr);
svc_handler->addr (remote_address);
int retval= 0;
while (uipmc_endpoint != 0)
{
if (uipmc_endpoint->is_preferred_network ())
{
local_addr.set(port, uipmc_endpoint->preferred_network ());
}
else
{
local_addr.set(any_addr);
}
svc_handler->local_addr (local_addr);
retval = svc_handler->open (0);
if (retval == 0)
{
#if defined (ACE_HAS_IPV6)
const char* prefer_if = uipmc_endpoint->preferred_if();
if (prefer_if && ACE_OS::strlen(prefer_if))
{
if (svc_handler->peer ().set_nic(prefer_if, AF_INET6))
{
if (TAO_debug_level > 0)
ORBSVCS_ERROR ((LM_ERROR,
"TAO (%P|%t) - UIPMC_Connector::make_connection, "
"connection to <%C:%u> - failed to set requested local network interface <%s>\n",
uipmc_endpoint->host (),
uipmc_endpoint->port (),
prefer_if));
retval = -1;
}
}
#endif /* ACE_HAS_IPV6 */
break;
}
else
{
if (TAO_debug_level > 3)
ORBSVCS_ERROR ((LM_ERROR,
"TAO (%P|%t) - UIPMC_Connector::make_connection, "
"connection to <%C:%u> from interface <%s> failed (%p)\n",
uipmc_endpoint->host (),
uipmc_endpoint->port (),
uipmc_endpoint->is_preferred_network () ? uipmc_endpoint->preferred_network () : "ANY",
ACE_TEXT ("errno")));
}
uipmc_endpoint = dynamic_cast<TAO_UIPMC_Endpoint *> (uipmc_endpoint->next());
}
// Failure to open a connection.
if (retval != 0)
{
svc_handler->close ();
if (TAO_debug_level > 0)
{
ORBSVCS_ERROR ((LM_ERROR,
"TAO (%P|%t) - UIPMC_Connector::make_connection, "
"failed to open the connection to <%C:%u>\n",
remote_address.get_host_addr (),
remote_address.get_port_number ()));
}
return 0;
}
// After the handler is opened we can try to obtain the real local address.
svc_handler->peer ().get_local_addr (local_addr);
svc_handler->local_addr (local_addr);
if (TAO_debug_level > 2)
{
char local_hostaddr[INET6_ADDRSTRLEN];
local_addr.get_host_addr (local_hostaddr, sizeof local_hostaddr);
char remote_hostaddr[INET6_ADDRSTRLEN];
remote_address.get_host_addr (remote_hostaddr, sizeof remote_hostaddr);
ORBSVCS_DEBUG ((LM_DEBUG,
ACE_TEXT ("TAO (%P|%t) - UIPMC_Connector::make_connection, ")
ACE_TEXT ("new connection from <%C:%u> to <%C:%u> on ")
ACE_TEXT ("HANDLE %d\n"),
local_hostaddr,
local_addr.get_port_number (),
remote_hostaddr,
remote_address.get_port_number (),
svc_handler->get_handle ()));
}
TAO_Transport *transport = svc_handler->transport ();
// In case of errors transport is zero
if (transport == 0)
{
svc_handler->close ();
// Give users a clue to the problem.
if (TAO_debug_level)
ORBSVCS_ERROR ((LM_ERROR,
ACE_TEXT ("TAO (%P|%t) - UIPMC_Connector:")
ACE_TEXT (":make_connection, connection to ")
ACE_TEXT ("<%C:%u> failed (%p)\n"),
uipmc_endpoint->host (),
uipmc_endpoint->port (),
ACE_TEXT ("errno")));
return 0;
}
// Add the handler to Cache
retval =
this->orb_core ()->lane_resources ().transport_cache ().cache_transport (&desc,
transport);
// Failure in adding to cache.
if (retval == -1)
{
svc_handler->close ();
if (TAO_debug_level)
{
ORBSVCS_ERROR ((LM_ERROR,
ACE_TEXT ("TAO (%P|%t) - UIPMC_Connector::")
ACE_TEXT ("make_connection, could not add the ")
ACE_TEXT ("new connection to cache\n")));
}
return 0;
}
svc_handler_auto_ptr.release ();
return transport;
}
