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 */ }