int
ACE_ATM_Acceptor::get_local_addr (ACE_ATM_Addr &local_addr)
{
ACE_TRACE ("ACE_ATM_Acceptor::get_local_addr");
#if defined (ACE_HAS_FORE_ATM_WS2)
unsigned long ret = 0;
DWORD deviceID = 0;
ATM_ADDRESS addr;
struct sockaddr_atm *laddr;
if (::WSAIoctl ((int) ((ACE_SOCK_Acceptor *)this) -> get_handle (),
SIO_GET_ATM_ADDRESS,
(LPVOID) &deviceID,
sizeof (DWORD),
(LPVOID)&addr,
sizeof (ATM_ADDRESS),
&ret,
0,
0) == SOCKET_ERROR) {
ACE_OS::printf ("ATM_Acceptor (get_local_addr): WSIoctl: %d\n",
::WSAGetLastError ());
return -1;
}
laddr = (struct sockaddr_atm *)local_addr.get_addr ();
ACE_OS::memcpy ((void *)& (laddr -> satm_number),
(void *)&addr,
ATM_ADDR_SIZE - 1);
return 0;
#elif defined (ACE_HAS_FORE_ATM_XTI)
ACE_UNUSED_ARG (local_addr);
return 0;
#elif defined (ACE_HAS_LINUX_ATM)
ATM_Addr *myaddr = (ATM_Addr *)local_addr.get_addr ();
int addrlen = sizeof (myaddr->sockaddratmsvc);
if (ACE_OS::getsockname (acceptor_.get_handle (),
(struct sockaddr *) & (myaddr->sockaddratmsvc),
&addrlen) < 0) {
ACELIB_DEBUG ((LM_DEBUG,
ACE_TEXT ("ATM_Acceptor (get_local_addr): ioctl: %d\n"),
errno));
return -1;
}
return 0;
#else
ACE_UNUSED_ARG (local_addr);
return 0;
#endif /* ACE_HAS_FORE_ATM_WS2 && ACE_HAS_FORE_ATM_XTI */
}
int
ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
ACE_Time_Value timeout (ACE_DEFAULT_TIMEOUT);
unsigned char selector = ACE_ATM_Addr::DEFAULT_SELECTOR;
int selector_specified = 0;
int opt;
while ((opt = ACE_OS::getopt (argc, argv, "s:?h")) != EOF)
{
switch(opt)
{
case 's':
selector = ACE_OS::atoi (optarg);
selector_specified = 1;
break;
case '?':
case 'h':
ACE_ERROR_RETURN ((LM_ERROR,
"Usage: %s [-s selector]\n", argv[0]),
1);
} // switch
} // while getopt
// Create a server address.
ACE_ATM_Addr addr;
if (selector_specified)
addr.set_selector(selector);
// Create a server, reuse the addr.
ACE_TLI_Acceptor peer_acceptor;
// Not sure why but reuse_addr set to true/1 causes problems for
// FORE/XTI/ATM - this is now handled in ACE_TLI_Acceptor::open()
if (peer_acceptor.open (addr,
1,
O_RDWR,
0,
5,
ACE_XTI_ATM_DEVICE) == -1)
ACE_ERROR_RETURN ((LM_ERROR,
"%p\n",
"open"),
-1);
ACE_TLI_Stream new_stream;
ACE_DEBUG ((LM_DEBUG,
"starting server at address %s\n",
addr.addr_to_string ()));
// Performs the iterative server activities
for (;;)
{
char buf[BUFSIZ];
// Create a new ACE_TLI_Stream endpoint (note automatic restart
// if errno == EINTR).
if (peer_acceptor.accept (new_stream,
&addr,
&timeout) == -1)
{
ACE_ERROR ((LM_ERROR,
"%p\n",
"accept"));
continue;
}
ACE_DEBUG ((LM_DEBUG,
"client %s connected\n",
addr.addr_to_string ()));
// Read data from client (terminate on error).
for (int r_bytes;
(r_bytes = new_stream.recv (buf, sizeof buf, 0)) > 0; )
if (ACE_OS::write (ACE_STDOUT,
buf,
r_bytes) != r_bytes)
ACE_ERROR ((LM_ERROR,
"%p\n",
"ACE::send_n"));
// Close new endpoint (listening endpoint stays open).
if (new_stream.close () == -1)
ACE_ERROR ((LM_ERROR,
"%p\n",
"close"));
}
/* NOTREACHED */
return 0;
}
char*
ACE_ATM_Stream::get_peer_name (void) const
{
ACE_TRACE ("ACE_ATM_Stream::get_peer_name");
#if defined (ACE_HAS_FORE_ATM_XTI)
// // Use t_getprotaddr for XTI/ATM
// struct t_bind *localaddr
// = (struct t_bind *) ACE_OS::t_alloc (get_handle (),
// T_BIND,
// T_ADDR);
// struct t_bind *peeraddr
// = (struct t_bind *) ACE_OS::t_alloc (get_handle (),
// T_BIND,
// T_ADDR);
// ::t_getprotaddr (get_handle (),
// localaddr,
// peeraddr);
// char* connected_name = (char*) ACE_OS::malloc (peeraddr->addr.len + 1);
// ACE_OS::strcpy (connected_name,
// peeraddr->addr.buf);
// ACE_OS::t_free ((char *) localaddr,
// T_BIND);
// ACE_OS::t_free ((char *) peeraddr,
// T_BIND);
// return (connected_name);
#error "This doesn't seem to work. May need to jimmy-rig something with the"
#error "/etc/xti_hosts file - Ugh!"
ACE_ATM_Addr sa;
struct netbuf name;
name.maxlen = sa.get_size ();
name.buf = (char *) sa.get_addr ();
ACE_OS::t_getname (this->get_handle (), &name, REMOTENAME);
// ACE_OS::ioctl (this->get_handle (),
// TI_GETPEERNAME,
// &name);
return (name.buf);
#elif defined (ACE_HAS_FORE_ATM_WS2)
// Use getpeername for WinSock2.
struct sockaddr_atm name;
ACE_OS::memset (&name, 0, sizeof (name));
int nameSize = sizeof (name);
if (ACE_OS::getpeername (this->get_handle (),
(struct sockaddr *) &name,
&nameSize) != 0) {
return 0;
}
char buffer[256];
for (unsigned int index = 0; index < ATM_ADDR_SIZE - 1; index++) {
buffer[ index * 3 ] = '\0';
ACE_OS::sprintf (buffer, "%s%02x.", buffer, name.satm_number.Addr[ index ]);
}
buffer[ (ATM_ADDR_SIZE - 1) * 3 ] = '\0';
ACE_OS::sprintf (buffer, "%s%02x.", buffer, 0);
buffer[ ATM_ADDR_SIZE * 3 - 1 ] = '\0';
for (index = 0; index < ACE_OS::strlen (buffer); ++index)
buffer[index] = ACE_OS::ace_tolower (buffer[index]);
ifstream atm_hosts ("C:/WINNT/atmhosts");
assert (atm_hosts.is_open ());
// Find the host address in the ATM hosts file and return the
// host name
char line[256];
char *host_ptr, *host_name = 0;
ACE_NEW_RETURN (host_name, char[256], 0);
while (!atm_hosts.eof ()) {
atm_hosts.getline (line, 256);
// Convert the line to lower case to ease comparison
for (index = 0; index < ACE_OS::strlen (line); ++index)
line[index] = ACE_OS::ace_tolower (line[index]);
if (ACE_OS::strstr (line, buffer) != 0)
{
char *strtok_p;
// Grab the second token which is the host name
ACE_OS::strtok_r (line, " \t", &strtok_p);
host_ptr = ACE_OS::strtok (0, " \t", &strtok_p);
ACE_OS::strcpy (host_name, host_ptr);
break;
}
}
return host_name;
#elif defined (ACE_HAS_LINUX_ATM)
ATM_Addr name;
int nameSize = sizeof (name.sockaddratmsvc);
if (ACE_OS::getpeername (this->get_handle (),
(struct sockaddr *) & (name.sockaddratmsvc),
&nameSize) < 0) {
ACE_OS::perror ("ACE_ATM_Stream (get_peer_name) : ");
return 0;
}
static ACE_TCHAR buffer[MAX_ATM_ADDR_LEN + 1];
int total_len;
if ((total_len = atm2text (buffer,sizeof buffer,
(struct sockaddr *) & (name.sockaddratmsvc),
A2T_PRETTY|A2T_NAME)) < 0) {
ACE_DEBUG ((LM_DEBUG,ACE_TEXT ("ACE_ATM_Stream (get_peer_name) :%d"),errno));
return 0;
}
return (char*) buffer;
#else
return 0;
#endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */
}
int
ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
ACE_Time_Value timeout (ACE_DEFAULT_TIMEOUT);
//unsigned char selector = ACE_ATM_Addr::DEFAULT_SELECTOR;
//int selector_specified = 0;
if (argc > 2)
ACE_ERROR_RETURN ((LM_ERROR,
"Usage: %s [selector]\n",
argv[0]),
1);
// Create a server address.
ACE_ATM_Addr addr;
//if (selector_specified)
unsigned char selector = ( argc == 2 ) ? ACE_OS::atoi( argv[ 1 ]) : ACE_ATM_Addr::DEFAULT_SELECTOR;
addr.set_selector( selector );
ACE_OS::printf( "ATM_Server: selector changed to %d\n", addr.get_selector());
// Create a server, reuse the addr.
ACE_ATM_Acceptor peer_acceptor;
ACE_ATM_Params params;
// Not sure why but reuse_addr set to true/1 causes problems for
// FORE/XTI/ATM - this is now handled in ACE_ATM_Acceptor::open()
ACE_HANDLE ret = peer_acceptor.open (addr, 5, params);
if ( ret == ACE_INVALID_HANDLE )
ACE_ERROR_RETURN ((LM_ERROR,
"%p\n",
"open"),
-1);
ACE_ATM_Stream new_stream;
ACE_ATM_Addr local_addr;
local_addr.set_selector( selector );
peer_acceptor.get_local_addr( local_addr );
ACE_DEBUG ((LM_DEBUG,
"starting server at address %s\n",
local_addr.addr_to_string ()));
// Performs the iterative server activities
char buf[BUFSIZ];
ACE_High_Res_Timer timer;
int total;
ACE_Time_Value tv;
double real_time;
double actual_rate;
for (;;)
{
// Create a new ACE_ATM_Stream endpoint (note automatic restart
// if errno == EINTR).
ACE_OS::printf( "ATM_Server: expecting clients\n" );
if (peer_acceptor.accept (new_stream,
&addr,
&timeout) == -1)
{
ACE_ERROR ((LM_ERROR,
"%p\n",
"accept"));
continue;
}
ACE_OS::printf( "ATM_Server: got a connection\n" );
ACE_UINT16 vpi, vci;
vpi = vci = 0;
// This has problem on PMP connections on NT
//new_stream.get_vpi_vci(vpi, vci);
ACE_DEBUG ((LM_DEBUG,
"connected to VPI %d VCI %d\n",
vpi, vci));
ACE_OS::printf( "ATM_Server: connection accepted\n" );
ACE_DEBUG ((LM_DEBUG,
"client %s connected\n",
addr.addr_to_string ()));
ACE_DEBUG ((LM_DEBUG,
"client %s connected to host\n",
new_stream.get_peer_name ()));
// Read data from client (terminate on error).
int recvd = 0;
for ( ;; )
{
total = 0;
timer.start_incr();
for (int r_bytes;
(r_bytes = new_stream.recv (buf, sizeof buf, 0)) > 0; )
{
// ACE_OS::printf( "ATM_Server: received %dB\n", r_bytes );
// if (ACE_OS::write (ACE_STDOUT,
// buf,
// r_bytes) != r_bytes)
// ACE_ERROR ((LM_ERROR,
// "%p\n",
// "ACE::send_n"));
total += r_bytes;
if ( total > 10000000 )
break;
}
timer.stop_incr();
timer.elapsed_time_incr( tv );
real_time = tv.sec() * ACE_ONE_SECOND_IN_USECS + tv.usec();
recvd += total;
actual_rate = ( double )recvd * ( double )8 / real_time;
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%t) bytes = %d, usec = %f, rate = %0.00f Mbps\n"),
recvd,
real_time,
actual_rate < 0 ? 0 : actual_rate ));
}
// Close new endpoint (listening endpoint stays open).
if (new_stream.close () == -1)
ACE_ERROR ((LM_ERROR,
"%p\n",
"close"));
}
/* NOTREACHED */
return 0;
}
int
ACE_ATM_Connector::connect (ACE_ATM_Stream &new_stream,
const ACE_ATM_Addr &remote_sap,
ACE_ATM_Params params,
ACE_ATM_QoS options,
ACE_Time_Value *timeout,
const ACE_ATM_Addr &local_sap,
int reuse_addr,
int flags,
int perms)
{
ACE_TRACE ("ACE_ATM_Connector::connect");
#if defined (ACE_HAS_FORE_ATM_XTI)
return connector_.connect(new_stream.get_stream(),
remote_sap,
timeout,
local_sap,
reuse_addr,
flags,
perms,
params.get_device(),
params.get_info(),
params.get_rw_flag(),
params.get_user_data(),
&options.get_qos());
#elif defined (ACE_HAS_FORE_ATM_WS2)
ACE_DEBUG(LM_DEBUG,
ACE_TEXT ("ATM_Connector(connect): set QoS parameters\n" ));
ACE_HANDLE s = new_stream.get_handle();
struct sockaddr_atm *saddr = ( struct sockaddr_atm *)remote_sap.get_addr();
ACE_QoS cqos = options.get_qos();
ACE_QoS_Params qos_params = ACE_QoS_Params(0,
0,
&cqos,
0,
0);
ACE_DEBUG(LM_DEBUG,
ACE_TEXT ("ATM_Connector(connect): connecting...\n"));
int result = ACE_OS::connect( s,
( struct sockaddr *)saddr,
sizeof( struct sockaddr_atm ),
qos_params );
if( result != 0 )
ACE_OS::printf( "ATM_Connector(connect): connection failed, %d\n",
::WSAGetLastError());
return result;
#elif defined (ACE_HAS_LINUX_ATM)
ACE_UNUSED_ARG (params);
ACE_UNUSED_ARG (timeout);
ACE_UNUSED_ARG (reuse_addr);
ACE_UNUSED_ARG (perms);
ACE_UNUSED_ARG (flags);
ACE_HANDLE handle = new_stream.get_handle();
ATM_QoS qos =options.get_qos();
ATM_Addr *local_addr=(ATM_Addr*)local_sap.get_addr(),
*remote_addr=(ATM_Addr*)remote_sap.get_addr();
if(ACE_OS::setsockopt(handle,
SOL_ATM,
SO_ATMSAP,
reinterpret_cast<char*> (&(local_addr->atmsap)),
sizeof(local_addr->atmsap)) < 0) {
ACE_OS::printf( "ATM_Connector(connect): unable to set atmsap %d\nContinuing...",
errno);
}
if(ACE_OS::setsockopt(handle,
SOL_ATM,
SO_ATMQOS,
reinterpret_cast<char*> (&qos),
sizeof(qos)) < 0) {
ACE_DEBUG((LM_DEBUG,ACE_TEXT ("ATM_Connector(connect): unable to set qos %d\n"),
errno));
return -1;
}
int result = ACE_OS::connect(handle,
(struct sockaddr *)&(remote_addr->sockaddratmsvc),
sizeof( remote_addr->sockaddratmsvc));
if( result != 0 )
ACE_DEBUG(LM_DEBUG,
ACE_TEXT ("ATM_Connector(connect): connection failed, %d\n"),
errno);
return result;
#else
ACE_UNUSED_ARG (new_stream);
ACE_UNUSED_ARG (remote_sap);
ACE_UNUSED_ARG (params);
ACE_UNUSED_ARG (options);
ACE_UNUSED_ARG (timeout);
ACE_UNUSED_ARG (local_sap);
ACE_UNUSED_ARG (reuse_addr);
ACE_UNUSED_ARG (flags);
ACE_UNUSED_ARG (perms);
return 0;
#endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */
}
