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 */ }
int ACE_ATM_Acceptor::accept (ACE_ATM_Stream &new_sap, ACE_Addr *remote_addr, ACE_Time_Value *timeout, bool restart, bool reset_new_handle, ACE_ATM_Params params, ACE_ATM_QoS qos) { ACE_TRACE ("ACE_ATM_Acceptor::accept"); #if defined (ACE_HAS_FORE_ATM_XTI) ATM_QoS optbuf = qos.get_qos (); return (acceptor_.accept (new_sap.get_stream (), remote_addr, timeout, restart, reset_new_handle, params.get_rw_flag (), params.get_user_data (), &optbuf)); #elif defined (ACE_HAS_FORE_ATM_WS2) ACE_HANDLE n_handle; ACE_HANDLE s_handle = ((ACE_SOCK_Acceptor *) this) -> get_handle (); struct sockaddr_atm *cli_addr = (struct sockaddr_atm *)remote_addr -> get_addr (); int caddr_len = sizeof (struct sockaddr_atm); do { n_handle = ACE_OS::accept (s_handle, reinterpret_cast<struct sockaddr *> (cli_addr), &caddr_len); } while (n_handle == ACE_INVALID_HANDLE && errno == EINTR); ((ACE_ATM_Addr *)remote_addr) -> set (cli_addr, ((ACE_ATM_Addr *)remote_addr) -> get_selector ()); ((ACE_IPC_SAP *)&new_sap) -> set_handle (n_handle); return 0; #elif defined (ACE_HAS_LINUX_ATM) ACE_UNUSED_ARG (params); ACE_HANDLE s_handle = ((ACE_SOCK_Acceptor *) this) -> get_handle (); struct atm_qos accept_qos = qos.get_qos (); if (ACE_OS::setsockopt (s_handle, SOL_ATM, SO_ATMQOS, reinterpret_cast<char*> (&accept_qos), sizeof (accept_qos)) < 0) { ACE_OS::printf ("Acceptor (accept): error setting Qos"); } return (acceptor_.accept (new_sap.get_stream (), remote_addr, timeout, restart, reset_new_handle)); #else ACE_UNUSED_ARG (new_sap); ACE_UNUSED_ARG (remote_addr); ACE_UNUSED_ARG (timeout); ACE_UNUSED_ARG (restart); ACE_UNUSED_ARG (reset_new_handle); ACE_UNUSED_ARG (params); ACE_UNUSED_ARG (qos); return 0; #endif /* ACE_HAS_FORE_ATM_XTI */ }
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { if (argc < 2) ACE_ERROR_RETURN ((LM_ERROR, "Usage: %s [-s selector] hostname [QoS in KB/sec]\n", argv[0]), 1); unsigned char selector = ACE_ATM_Addr::DEFAULT_SELECTOR; int selector_specified = 0; extern int optind; 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 hostname [-s selector] [QoS in KB/s]\n", argv[0]), 1); } // switch } // while getopt const char *host = argv[optind]; int rate = (argc == 3) ? ACE_OS::atoi (argv[2]) : (argc == 5) ? ACE_OS::atoi (argv[4]) : 0; // The timeout really gets ignored since FORE's drivers don't work when // ioctl or fcntl calls are made on the transport id/file descriptor int timeout = ACE_DEFAULT_TIMEOUT; char buf[BUFSIZ]; ACE_TLI_Stream cli_stream; ACE_ATM_Addr remote_addr (host); if (selector_specified) remote_addr.set_selector(selector); char hostname[MAXNAMELEN]; ACE_OS::hostname(hostname, MAXNAMELEN); ACE_ATM_Addr local_addr (hostname); // In order to construct connections options the file handle is // needed. Therefore, we need to open the TLI_Stream before we // construct the options. if (cli_stream.open (ACE_XTI_ATM_DEVICE, O_RDWR, 0) == -1) ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "open failed"), 1); ACE_DEBUG ((LM_DEBUG, "starting non-blocking connect\n")); // Initiate timed, non-blocking connection with server. ACE_TLI_Connector con; // Construct QoS options - currently FORE only supports bandwidth ACE_ATM_QoS qos; qos.set_rate(cli_stream.get_handle (), rate, ACE_ATM_QoS::OPT_FLAGS_CPID); struct netbuf optbuf = qos.get_qos(); // long optlen = 0; // char *options = remote_addr.construct_options (cli_stream.get_handle (), // rate, // ACE_ATM_Addr::OPT_FLAGS_CPID, // &optlen); // struct netbuf optbuf; // optbuf.len = optlen; // optbuf.buf = options; // Not sure why but reuse_addr set to true/1 causes problems for // FORE/XTI/ATM - this is now handled in ACE_TLI_Connector::connect() if (con.connect (cli_stream, remote_addr, (ACE_Time_Value *) &ACE_Time_Value::zero, local_addr, 1, O_RDWR, 0, ACE_XTI_ATM_DEVICE, 0, 1, 0, &optbuf) == -1) { if (errno != EWOULDBLOCK) ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "connection failed"), 1); ACE_DEBUG ((LM_DEBUG, "starting timed connect\n")); // Check if non-blocking connection is in progress, and wait up // to timeout seconds for it to complete. ACE_Time_Value tv (timeout); if (con.complete (cli_stream, &remote_addr, &tv) == -1) ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "connection failed"), 1); else ACE_DEBUG ((LM_DEBUG, "connected to %s\n", remote_addr.addr_to_string ())); } // Send data to server (correctly handles "incomplete writes"). for (int r_bytes; (r_bytes = ACE_OS::read (ACE_STDIN, buf, sizeof buf)) > 0; ) if (cli_stream.send_n (buf, r_bytes, 0) == -1) ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "send_n"), 1); // Explicitly close the connection. if (cli_stream.close () == -1) ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "close"), -1); return 0; }