Main Page   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members   File Members   Related Pages  

ACE_ATM_Addr Class Reference

Defines the ATM domain address family address format. More...

#include <ATM_Addr.h>

Inheritance diagram for ACE_ATM_Addr:

Inheritance graph
[legend]
Collaboration diagram for ACE_ATM_Addr:

Collaboration graph
[legend]
List of all members.

Public Methods

 ACE_ATM_Addr (u_char selector=DEFAULT_SELECTOR)
 Default constructor. More...

 ACE_ATM_Addr (const ACE_ATM_Addr &, u_char selector=DEFAULT_SELECTOR)
 Copy constructor. More...

 ACE_ATM_Addr (const ATM_Addr *, u_char selector=DEFAULT_SELECTOR)
 ACE_ATM_Addr (const ACE_TCHAR sap[], u_char selector=DEFAULT_SELECTOR)
 ~ACE_ATM_Addr (void)
 Default dtor. More...

void init (u_char selector=DEFAULT_SELECTOR)
 Default initialization for non-address values (e.g., t_atm_sap_addr.SVE_tag_addr, t_atm_sap_addr.SVE_tag_selector). More...

int set (const ACE_ATM_Addr &, u_char selector=DEFAULT_SELECTOR)
 Initializes from another <ACE_ATM_Addr>. More...

int set (const ATM_Addr *, u_char selector=DEFAULT_SELECTOR)
int set (const ACE_TCHAR sap[], u_char selector=DEFAULT_SELECTOR)
virtual int string_to_addr (const ACE_TCHAR sap[])
virtual int addr_to_string (ACE_TCHAR addr[], size_t addrlen) const
const ACE_TCHAR * addr_to_string (void) const
virtual void * get_addr (void) const
 Return a pointer to the underlying network address. More...

virtual void set_addr (void *, int)
 Set a pointer to the address. More...

u_char get_selector (void) const
 Return the selector for network address. More...

void set_selector (u_char selector)
 Set the selector for the network address. More...

int operator== (const ACE_ATM_Addr &SAP) const
int operator!= (const ACE_ATM_Addr &SAP) const
 Compare two addresses for inequality. More...

void dump (void) const
 Dump the state of an object. More...


Public Attributes

 ACE_ALLOC_HOOK_DECLARE
 Declare the dynamic allocation hooks. More...


Static Public Attributes

const long LINE_RATE = 0L
const int OPT_FLAGS_CPID = 0
const int OPT_FLAGS_PMP = 0
const int DEFAULT_SELECTOR = 0x0

Private Attributes

ATM_Addr atm_addr_

Detailed Description

Defines the ATM domain address family address format.

Definition at line 52 of file ATM_Addr.h.

Constructor & Destructor Documentation

ACE_ATM_Addr::ACE_ATM_Addr (  u_char    selector = DEFAULT_SELECTOR ) 
 

Default constructor.

Definition at line 47 of file ATM_Addr.cpp.

References ACE_OS_String::memset. 

00049   : ACE_Addr (AF_ATM,
00050 #elif defined (ACE_HAS_LINUX_ATM)
00051   : ACE_Addr (PF_ATMSVC,
00052 #else
00053   : ACE_Addr (AF_UNSPEC,
00054 #endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */
00055               sizeof this->atm_addr_)
00056 {
00057   // ACE_TRACE ("ACE_ATM_Addr::ACE_ATM_Addr");
00058  (void) ACE_OS::memset ((void *) &this->atm_addr_,
00059                          0,
00060                          sizeof this->atm_addr_);
00061   this->init (selector);
00062 }

ACE_ATM_Addr::ACE_ATM_Addr (  const ACE_ATM_Addr &   ,
u_char    selector = DEFAULT_SELECTOR
) 
 

Copy constructor.

Definition at line 66 of file ATM_Addr.cpp.

References ACE_TRACE. 

00069   : ACE_Addr (AF_ATM,
00070 #elif defined (ACE_HAS_LINUX_ATM)
00071   : ACE_Addr (PF_ATMSVC,
00072 #else
00073   : ACE_Addr (AF_UNSPEC,
00074 #endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */
00075               sizeof this->atm_addr_)
00076 {
00077   ACE_TRACE ("ACE_ATM_Addr::ACE_ATM_Addr");
00078   this->set (sap, selector);
00079 #if defined (ACE_HAS_LINUX_ATM)
00080   this->atm_addr_.sockaddratmsvc.sas_family = PF_ATMSVC;
00081   this->atm_addr_.atmsap.blli[0].l3_proto = ATM_L3_NONE;
00082   this->atm_addr_.atmsap.blli[0].l2_proto = ATM_L2_NONE;
00083   this->atm_addr_.atmsap.bhli.hl_type = ATM_HL_NONE;
00084 #endif /* ACE_HAS_LINUX_ATM */
00085 }

ACE_ATM_Addr::ACE_ATM_Addr (  const ATM_Addr *   ,
u_char    selector = DEFAULT_SELECTOR
) 
 

Creates an <ACE_ATM_Addr> from an ATMSAPAddress structure. This is vendor specific (FORE systems). May need to change when other vendors are supported.

Definition at line 87 of file ATM_Addr.cpp.

References ACE_TRACE, and ATM_Addr. 

00090   : ACE_Addr (AF_ATM,
00091 #elif defined (ACE_HAS_LINUX_ATM)
00092   : ACE_Addr (PF_ATMSVC,
00093 #else
00094   : ACE_Addr (AF_UNSPEC,
00095 #endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */
00096               sizeof this->atm_addr_)
00097 {
00098   ACE_TRACE ("ACE_ATM_Addr::ACE_ATM_Addr");
00099   this->set (sap, selector);
00100 }

ACE_ATM_Addr::ACE_ATM_Addr (  const ACE_TCHAR    sap[],
u_char    selector = DEFAULT_SELECTOR
) 
 

Initializes an <ACE_ATM_Addr> from the <sap> which can be "atm-address" (e.g., "47.0005.80.ffe100.0000.f20f.2200.0020480694f9.00") or "hostname" (e.g., "frisbee.cs.wustl.edu").

Definition at line 103 of file ATM_Addr.cpp.

References ACE_TCHAR, and ACE_TRACE. 

00106   : ACE_Addr (AF_ATM,
00107 #elif defined (ACE_HAS_LINUX_ATM)
00108   : ACE_Addr (PF_ATMSVC,
00109 #else
00110   : ACE_Addr (AF_UNSPEC,
00111 #endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */
00112               sizeof this->atm_addr_)
00113 {
00114   ACE_TRACE ("ACE_ATM_Addr::ACE_ATM_Addr");
00115   this->set (sap, selector);
00116 }

ACE_INLINE ACE_ATM_Addr::~ACE_ATM_Addr (  void    ) 
 

Default dtor.

Definition at line 7 of file ATM_Addr.i. 

00008 {
00009 }

Member Function Documentation

const ACE_TCHAR * ACE_ATM_Addr::addr_to_string (  void    )  const
 

Return the character representation of the ATM address (e.g., "47.0005.80.ffe100.0000.f20f.2200.0020480694f9.00"). Returns -1 if the <size> of the <buffer> is too small, else 0.(This version is non-reentrant since it returns a pointer to a static data area.)

Definition at line 427 of file ATM_Addr.cpp.

References ACE_TCHAR, ACE_TRACE, and MAXHOSTNAMELEN. 

00428 {
00429   ACE_TRACE ("ACE_ATM_Addr::addr_to_string");
00430 
00431   static ACE_TCHAR addr[MAXHOSTNAMELEN + 1];
00432   if (this->addr_to_string (addr,
00433                             MAXHOSTNAMELEN + 1) < 0)
00434     return 0;
00435 
00436   return addr;
00437 }

int ACE_ATM_Addr::addr_to_string (  ACE_TCHAR    addr[],
size_t    addrlen
)  const [virtual]
 

Return the character representation of the ATM address (e.g., "47.0005.80.ffe100.0000.f20f.2200.0020480694f9.00") storing it in the <addr> (which is assumed to be <addrlen> bytes long). This version is reentrant. Returns -1 if the <addrlen> of the <addr> is too small, else 0.

Definition at line 361 of file ATM_Addr.cpp.

References ACE_DEBUG, ACE_LIB_TEXT, ACE_TCHAR, ACE_TRACE, atm_addr_, LM_DEBUG, MAXNAMELEN, ACE_OS_String::memcpy, ACE_OS::sprintf, ACE_OS_String::strcpy, and ACE_OS_String::strlen. 

00363 {
00364   ACE_TRACE ("ACE_ATM_Addr::addr_to_string");
00365 
00366 #if defined (ACE_HAS_FORE_ATM_XTI)
00367   ACE_TCHAR buffer[MAXNAMELEN + 1];
00368   struct atmnsap_addr nsap;
00369   ACE_OS::memcpy (nsap.atmnsap,
00370                   atm_addr_.sap.t_atm_sap_addr.address,
00371                   ATMNSAP_ADDR_LEN);
00372   ACE_OS::sprintf (buffer,
00373                    ACE_LIB_TEXT ("%s"),
00374                    atmnsap_ntoa (nsap));
00375 
00376   size_t total_len = ACE_OS::strlen (buffer) + sizeof ('\0');
00377 
00378   if (addrlen < total_len)
00379     return -1;
00380   else
00381     ACE_OS::strcpy (addr, buffer);
00382 
00383   return 0;
00384 #elif defined (ACE_HAS_FORE_ATM_WS2)
00385   ACE_TCHAR buffer[MAXNAMELEN + 1];
00386   int i;
00387 
00388   if (addrlen < ATM_ADDR_SIZE + 1) 
00389           return -1;
00390 
00391   for (i = 0; i < ATM_ADDR_SIZE; i++) {
00392     buffer[ i * 3 ] = '\0';
00393           ACE_OS::sprintf (buffer, ACE_LIB_TEXT ("%s%02x."), 
00394                      buffer, 
00395                      atm_addr_.satm_number.Addr[ i ]);
00396   }
00397 
00398   buffer[ ATM_ADDR_SIZE * 3 - 1 ] = '\0';
00399   ACE_OS::strcpy (addr, buffer);
00400 
00401   return 0;
00402 #elif defined (ACE_HAS_LINUX_ATM)
00403   ACE_TCHAR buffer[MAX_ATM_ADDR_LEN + 1];
00404   int total_len;
00405   if ((total_len = atm2text (buffer,
00406                             sizeof buffer,
00407  (struct sockaddr *)& (atm_addr_.sockaddratmsvc), 
00408                             A2T_PRETTY)) < 0) {
00409     ACE_DEBUG ((LM_DEBUG,"ACE_ATM_Addr (addr_to_string): atm2text failed\n"));
00410     return -1;
00411   }
00412   if (addrlen < (size_t)total_len)
00413     return -1;
00414   else
00415     ACE_OS::strcpy (addr,
00416                    buffer);
00417 
00418   return 0;
00419 #else
00420   ACE_UNUSED_ARG (addr);
00421   ACE_UNUSED_ARG (addrlen);
00422   return -1;
00423 #endif /* ACE_HAS_FORE_ATM_XTI && ACE_HAS_FORE_ATM_WS2 */
00424 }

void ACE_ATM_Addr::dump (  void    )  const
 

Dump the state of an object.

Reimplemented from ACE_Addr.

Definition at line 490 of file ATM_Addr.cpp.

References ACE_BEGIN_DUMP, ACE_DEBUG, ACE_END_DUMP, ACE_LIB_TEXT, ACE_MAX_FULLY_QUALIFIED_NAME_LEN, ACE_TCHAR, ACE_TRACE, LM_DEBUG, and ACE_OS::sprintf. 

00491 {
00492   ACE_TRACE ("ACE_ATM_Addr::dump");
00493 
00494   ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
00495 
00496   ACE_TCHAR s[ACE_MAX_FULLY_QUALIFIED_NAME_LEN + 16];
00497   ACE_OS::sprintf (s,
00498                    ACE_LIB_TEXT ("%s"),
00499                    this->addr_to_string ());
00500   ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("%s"), s));
00501   ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
00502 }

ACE_INLINE void * ACE_ATM_Addr::get_addr (  void    )  const [virtual]
 

Return a pointer to the underlying network address.

Reimplemented from ACE_Addr.

Definition at line 14 of file ATM_Addr.i.

References ACE_TRACE, and atm_addr_.

Referenced by ACE_ATM_Connector::connect, ACE_ATM_Acceptor::get_local_addr, ACE_ATM_Stream::get_peer_name, and ACE_ATM_Acceptor::open. 

00015 {
00016   ACE_TRACE ("ACE_ATM_Addr::get_addr");
00017   return (void *) &this->atm_addr_;
00018 }

ACE_INLINE u_char ACE_ATM_Addr::get_selector (  void    )  const
 

Return the selector for network address.

Definition at line 21 of file ATM_Addr.i.

References ACE_TRACE, and atm_addr_. 

00022 {
00023   ACE_TRACE ("ACE_ATM_Addr::get_selector");
00024 #if defined (ACE_HAS_FORE_ATM_XTI)
00025   return atm_addr_.sap.t_atm_sap_addr.address[ATMNSAP_ADDR_LEN - 1];
00026 #elif defined (ACE_HAS_FORE_ATM_WS2)
00027   return atm_addr_.satm_number.Addr[ ATM_ADDR_SIZE - 1 ];
00028 #elif defined (ACE_HAS_LINUX_ATM)
00029   return atm_addr_.sockaddratmsvc.sas_addr.prv[ATM_ESA_LEN - 1];
00030 #else
00031   return 0;
00032 #endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */
00033 }

void ACE_ATM_Addr::init (  u_char    selector = DEFAULT_SELECTOR ) 
 

Default initialization for non-address values (e.g., t_atm_sap_addr.SVE_tag_addr, t_atm_sap_addr.SVE_tag_selector).

Definition at line 119 of file ATM_Addr.cpp.

References atm_addr_, ACE_OS_String::memcpy, and ACE_OS_String::memset.

Referenced by set. 

00120 {
00121 #if defined (ACE_HAS_FORE_ATM_XTI)
00122   // Note: this approach may be FORE implementation-specific.  When we
00123   // bind with tag_addr ABSENT and tag_selector PRESENT, only the
00124   // selector (i.e. address[19]) is used by the TP.  The rest of the
00125   // local address is filled in by the TP and can be obtained via the
00126   // 'ret' parameter or with t_getname ()/t_getprotaddr ().
00127 
00128   atm_addr_.addressType = (u_int16_t) AF_ATM;
00129 
00130   atm_addr_.sap.t_atm_sap_addr.SVE_tag_addr = (int8_t) T_ATM_ABSENT;
00131   atm_addr_.sap.t_atm_sap_addr.SVE_tag_selector = (int8_t) T_ATM_PRESENT;
00132 
00133   atm_addr_.sap.t_atm_sap_addr.address_format = (u_int8_t) T_ATM_ENDSYS_ADDR;
00134   atm_addr_.sap.t_atm_sap_addr.address_length = ATMNSAP_ADDR_LEN;
00135   atm_addr_.sap.t_atm_sap_addr.address[ATMNSAP_ADDR_LEN - 1] = selector;
00136 
00137   atm_addr_.sap.t_atm_sap_layer2.SVE_tag = (int8_t) T_ATM_ABSENT;
00138   atm_addr_.sap.t_atm_sap_layer3.SVE_tag = (int8_t) T_ATM_ABSENT;
00139 
00140   atm_addr_.sap.t_atm_sap_appl.SVE_tag = (int8_t) T_ATM_PRESENT;
00141   atm_addr_.sap.t_atm_sap_appl.ID_type = (u_int8_t) T_ATM_USER_APP_ID;
00142 
00143   ACE_OS::memcpy (atm_addr_.sap.t_atm_sap_appl.ID.user_defined_ID,
00144                   BHLI_MAGIC,
00145                   sizeof atm_addr_.sap.t_atm_sap_appl.ID);
00146 #elif defined (ACE_HAS_FORE_ATM_WS2)
00147   ACE_OS::memset ((void *)&atm_addr_, 0, sizeof atm_addr_);
00148   atm_addr_.satm_number.Addr[ ATM_ADDR_SIZE - 1 ] = (char)selector;
00149   atm_addr_.satm_family = AF_ATM;
00150   atm_addr_.satm_number.AddressType = ATM_NSAP;
00151   atm_addr_.satm_number.NumofDigits = ATM_ADDR_SIZE;
00152   atm_addr_.satm_blli.Layer2Protocol = SAP_FIELD_ABSENT;
00153   atm_addr_.satm_blli.Layer3Protocol = SAP_FIELD_ABSENT;
00154   atm_addr_.satm_bhli.HighLayerInfoType = SAP_FIELD_ABSENT;
00155 
00156   // Need to know the correspondence.
00157   //atm_addr_.sap.t_atm_sap_appl.SVE_tag = (int8_t) T_ATM_PRESENT;
00158   //atm_addr_.sap.t_atm_sap_appl.ID_type = (u_int8_t) T_ATM_USER_APP_ID;
00159   //ACE_OS::memcpy (atm_addr_.sap.t_atm_sap_appl.ID.user_defined_ID,
00160   //                BHLI_MAGIC,
00161   //                sizeof atm_addr_.sap.t_atm_sap_appl.ID);
00162 #elif defined (ACE_HAS_LINUX_ATM)
00163   atm_addr_.sockaddratmsvc.sas_family = AF_ATMSVC;
00164   atm_addr_.sockaddratmsvc.sas_addr.prv[ATM_ESA_LEN - 1] = (char)selector;
00165   atm_addr_.atmsap.blli[0].l3_proto = ATM_L3_NONE;
00166   atm_addr_.atmsap.blli[0].l2_proto = ATM_L2_NONE;
00167   atm_addr_.atmsap.bhli.hl_type = ATM_HL_NONE;
00168 #else
00169   ACE_UNUSED_ARG (selector);
00170 #endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */
00171 }

int ACE_ATM_Addr::operator!= (  const ACE_ATM_Addr &    SAP )  const
 

Compare two addresses for inequality.

Definition at line 460 of file ATM_Addr.cpp.

References ACE_TRACE. 

00461 {
00462   ACE_TRACE ("ACE_ATM_Addr::operator !=");
00463   return ! ((*this) == sap);
00464 }

int ACE_ATM_Addr::operator== (  const ACE_ATM_Addr &    SAP )  const
 

Compare two addresses for equality. The addresses are considered equal if they contain the same ATM address. Q: Is there any other check for equality needed for ATM?

Definition at line 469 of file ATM_Addr.cpp.

References ACE_TRACE, ATM_Addr, atm_addr_, and ACE_OS_String::memcmp. 

00470 {
00471   ACE_TRACE ("ACE_ATM_Addr::operator ==");
00472 
00473 #if defined (ACE_HAS_LINUX_ATM)
00474   return (atm_equal ((const struct sockaddr *)& (this->atm_addr_.sockaddratmsvc),
00475  (const struct sockaddr *)& (sap.atm_addr_.sockaddratmsvc),
00476                     0,
00477                     0)
00478           &&
00479           sap_equal (& (this->atm_addr_.atmsap),
00480                     & (sap.atm_addr_.atmsap),
00481                     0));
00482 #else
00483   return ACE_OS::memcmp (&atm_addr_,
00484                          &sap.atm_addr_,
00485                          sizeof (ATM_Addr)) == 0;
00486 #endif /*  ACE_HAS_LINUX_ATM */
00487 }

int ACE_ATM_Addr::set (  const ACE_TCHAR    sap[],
u_char    selector = DEFAULT_SELECTOR
) 
 

Initializes an <ACE_ATM_Addr> from the <sap> which can be "atm-address" (e.g., "47.0005.80.ffe100.0000.f20f.2200.0020480694f9.00") or "hostname" (e.g., "frisbee.cs.wustl.edu").

Definition at line 220 of file ATM_Addr.cpp.

References ACE_TCHAR, ACE_TRACE, atm_addr_, init, set_selector, and string_to_addr. 

00222 {
00223   ACE_TRACE ("ACE_ATM_Addr::set");
00224   int ret;
00225 
00226   this->init (selector);
00227 
00228 #if defined (ACE_HAS_FORE_ATM_XTI)
00229   atm_addr_.sap.t_atm_sap_addr.SVE_tag_addr =
00230  (int8_t) T_ATM_PRESENT;
00231 #endif /* ACE_HAS_FORE_ATM_XTI */
00232 
00233   ret = this -> string_to_addr (address);
00234   this -> set_selector (selector);
00235   return ret;
00236 }

int ACE_ATM_Addr::set (  const ATM_Addr *   ,
u_char    selector = DEFAULT_SELECTOR
) 
 

Initializes an <ACE_ATM_Addr> from an ATMSAPAddress/sockaddr_atm structure. This is vendor specific (FORE systems). May need to change when other vendors are supported.

Definition at line 197 of file ATM_Addr.cpp.

References ACE_TRACE, ATM_Addr, ACE_Addr::base_set, init, and ACE_OS_String::memcpy. 

00199 {
00200   ACE_TRACE ("ACE_ATM_Addr::set");
00201 
00202   this->init (selector);
00203 
00204 #if defined (ACE_HAS_FORE_ATM_XTI) || defined (ACE_HAS_FORE_ATM_WS2)
00205   this->ACE_Addr::base_set (AF_ATM,
00206 #elif defined (ACE_HAS_LINUX_ATM)
00207   this->ACE_Addr::base_set (PF_ATMSVC,
00208 #else
00209   this->ACE_Addr::base_set (AF_UNSPEC,
00210 #endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 */
00211                             sizeof (*sap));
00212 
00213  (void) ACE_OS::memcpy ((void *) &this->atm_addr_,
00214  (void *) sap,
00215                          sizeof this->atm_addr_);
00216   return 0;
00217 }

int ACE_ATM_Addr::set (  const ACE_ATM_Addr &   ,
u_char    selector = DEFAULT_SELECTOR
) 
 

Initializes from another <ACE_ATM_Addr>.

Definition at line 174 of file ATM_Addr.cpp.

References ACE_ASSERT, ACE_TRACE, atm_addr_, ACE_Addr::base_set, ACE_Addr::get_size, ACE_Addr::get_type, init, and ACE_OS_String::memcpy. 

00176 {
00177   ACE_TRACE ("ACE_ATM_Addr::set");
00178 
00179   this->init (selector);
00180 
00181   this->ACE_Addr::base_set (sap.get_type (),
00182                             sap.get_size ());
00183 
00184 #if defined (ACE_HAS_FORE_ATM_XTI) || defined (ACE_HAS_FORE_ATM_WS2)
00185   ACE_ASSERT (sap.get_type () == AF_ATM);
00186 #elif defined (ACE_HAS_LINUX_ATM)
00187   ACE_ASSERT (sap.get_type () == PF_ATMSVC);
00188 #endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 */
00189 
00190  (void) ACE_OS::memcpy ((void *) &this->atm_addr_,
00191  (void *) &sap.atm_addr_,
00192                          sizeof this->atm_addr_);
00193   return 0;
00194 }

void ACE_ATM_Addr::set_addr (  void *   ,
int   
)  [virtual]
 

Set a pointer to the address.

Reimplemented from ACE_Addr.

Definition at line 441 of file ATM_Addr.cpp.

References ACE_TRACE, ACE_Addr::base_set, and ACE_OS_String::memcpy. 

00442 {
00443   ACE_TRACE ("ACE_ATM_Addr::set_addr");
00444 
00445 #if defined (ACE_HAS_FORE_ATM_XTI) || defined (ACE_HAS_FORE_ATM_WS2)
00446   this->ACE_Addr::base_set (AF_ATM,
00447 #elif defined (ACE_HAS_LINUX_ATM)
00448   this->ACE_Addr::base_set (PF_ATMSVC,
00449 #else
00450   this->ACE_Addr::base_set (AF_UNSPEC,
00451 #endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_WS2 */
00452                             len);
00453   ACE_OS::memcpy ((void *) &this->atm_addr_,
00454  (void *) addr, len);
00455 }

ACE_INLINE void ACE_ATM_Addr::set_selector (  u_char    selector ) 
 

Set the selector for the network address.

Definition at line 36 of file ATM_Addr.i.

References ACE_TRACE, and atm_addr_.

Referenced by ACE_ATM_Acceptor::open, and set. 

00037 {
00038   ACE_TRACE ("ACE_ATM_Addr::set_selector");
00039 #if defined (ACE_HAS_FORE_ATM_XTI)
00040   atm_addr_.sap.t_atm_sap_addr.address[ATMNSAP_ADDR_LEN - 1] = selector;
00041 #elif defined (ACE_HAS_FORE_ATM_WS2)
00042   atm_addr_.satm_number.Addr[ ATM_ADDR_SIZE - 1 ] = selector;
00043 #elif defined (ACE_HAS_LINUX_ATM)
00044   atm_addr_.sockaddratmsvc.sas_addr.prv[ATM_ESA_LEN - 1] = selector;
00045 #else
00046   ACE_UNUSED_ARG (selector);
00047 #endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */
00048 }

int ACE_ATM_Addr::string_to_addr (  const ACE_TCHAR    sap[] )  [virtual]
 

Initializes an <ACE_ATM_Addr> from the <sap> which can be "atm-address" (e.g., "47.0005.80.ffe100.0000.f20f.2200.0020480694f9.00") or "hostname" (e.g., "frisbee.cs.wustl.edu").

Definition at line 241 of file ATM_Addr.cpp.

References ACE_DEBUG, ACE_TCHAR, ACE_TRACE, atm_addr_, ACE_Addr::base_set, LM_DEBUG, ACE_OS_String::memcpy, ACE_OS::printf, and ACE_OS_String::strcmp.

Referenced by set. 

00242 {
00243   ACE_TRACE ("ACE_ATM_Addr::string_to_addr");
00244 
00245 #if defined (ACE_HAS_FORE_ATM_XTI) || defined (ACE_HAS_FORE_ATM_WS2)
00246   this->ACE_Addr::base_set (AF_ATM,
00247 #elif defined (ACE_HAS_LINUX_ATM)
00248   this->ACE_Addr::base_set (PF_ATMSVC,
00249 #else
00250   this->ACE_Addr::base_set (AF_UNSPEC,
00251 #endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */
00252                             sizeof this->atm_addr_);
00253 #if defined (ACE_HAS_FORE_ATM_XTI)
00254   struct hostent *entry;
00255   struct atmnsap_addr *nsap;
00256 
00257   // Yow, someone gave us a NULL ATM address!
00258   if (sap == 0)
00259     {
00260       errno = EINVAL;
00261       return -1;
00262     }
00263   else if ((entry = gethostbyname_atmnsap ((ACE_TCHAR *)sap)) != 0)
00264     {
00265       ACE_OS::memcpy (atm_addr_.sap.t_atm_sap_addr.address, 
00266                       entry->h_addr_list[0],
00267                       ATMNSAP_ADDR_LEN - 1);
00268     }
00269   else if ((nsap = atmnsap_addr (sap)) != 0)
00270     {
00271       ACE_OS::memcpy (atm_addr_.sap.t_atm_sap_addr.address,
00272                       nsap->atmnsap,
00273                       ATMNSAP_ADDR_LEN);
00274     }
00275   else {
00276       errno = EINVAL;
00277       return -1;
00278     }
00279 #elif defined (ACE_HAS_FORE_ATM_WS2)
00280    DWORD dwValue;
00281    HANDLE hLookup;
00282    WSAQUERYSETW qsRestrictions;
00283    CSADDR_INFO  csaBuffer;
00284    WCHAR  tmpWStr[100];
00285 
00286    MultiByteToWideChar (CP_ACP, MB_PRECOMPOSED, sap, -1, tmpWStr, 100);  
00287 
00288    csaBuffer.LocalAddr.iSockaddrLength = sizeof (struct sockaddr_atm);
00289    csaBuffer.LocalAddr.lpSockaddr = (struct sockaddr *)&atm_addr_;
00290    csaBuffer.RemoteAddr.iSockaddrLength = sizeof (struct sockaddr_atm);
00291    csaBuffer.RemoteAddr.lpSockaddr = (struct sockaddr *)&atm_addr_;
00292 
00293    qsRestrictions.dwSize                  = sizeof (WSAQUERYSETW);
00294    qsRestrictions.lpszServiceInstanceName = 0;
00295    qsRestrictions.lpServiceClassId        = &FORE_NAME_CLASS;
00296    qsRestrictions.lpVersion               = 0;
00297    qsRestrictions.lpszComment             = 0;
00298    qsRestrictions.dwNameSpace             = FORE_NAME_SPACE;
00299    qsRestrictions.lpNSProviderId          = 0;
00300    qsRestrictions.lpszContext             = L"";
00301    qsRestrictions.dwNumberOfProtocols     = 0;
00302    qsRestrictions.lpafpProtocols          = 0;
00303    qsRestrictions.lpszQueryString         = tmpWStr;
00304    qsRestrictions.dwNumberOfCsAddrs       = 1;
00305    qsRestrictions.lpcsaBuffer             = &csaBuffer;
00306    qsRestrictions.lpBlob                  = 0; //&blob;
00307 
00308    if (::WSALookupServiceBeginW (&qsRestrictions, LUP_RETURN_ALL, &hLookup) 
00309         == SOCKET_ERROR) {
00310      ACE_OS::printf ("Error: WSALookupServiceBeginW failed! %d\n",
00311                      ::WSAGetLastError ());
00312            return -1;
00313    }                
00314 
00315    dwValue = sizeof (WSAQUERYSETW);
00316 
00317    if (::WSALookupServiceNextW (hLookup, 0, &dwValue, &qsRestrictions) 
00318         == SOCKET_ERROR) {
00319      if (WSAGetLastError () != WSA_E_NO_MORE) {
00320        ACE_OS::printf ("Error: WSALookupServiceNextW failed! %d\n", 
00321                        ::WSAGetLastError ());
00322              return -1;
00323      }
00324    }
00325 
00326    if (WSALookupServiceEnd (hLookup) == SOCKET_ERROR) {
00327      ACE_OS::printf ("Error : WSALookupServiceEnd failed! %d \n", 
00328                      ::WSAGetLastError ());
00329       errno = EINVAL;
00330       return -1;
00331    }
00332 #elif defined (ACE_HAS_LINUX_ATM)
00333    if (sap == 0 || !ACE_OS::strcmp (sap,"")) {
00334      errno = EINVAL;
00335      return -1;
00336    }
00337 
00338    if (text2atm ((ACE_TCHAR *)sap, 
00339  (struct sockaddr *)& (atm_addr_.sockaddratmsvc), 
00340                  sizeof (atm_addr_.sockaddratmsvc), 
00341                  T2A_SVC | T2A_NAME) < 0) {
00342      ACE_DEBUG (LM_DEBUG,
00343                "Error : text2atm failed!\n");
00344      errno = EINVAL;
00345      return -1;
00346    }
00347 #else
00348   ACE_UNUSED_ARG (sap);
00349   
00350   return 0;
00351 #endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */
00352 
00353 #if defined (ACE_HAS_FORE_ATM_XTI) || defined (ACE_HAS_FORE_ATM_WS2) || defined (ACE_HAS_LINUX_ATM)
00354   return 0;
00355 #endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 */
00356 }

Member Data Documentation

ACE_ATM_Addr::ACE_ALLOC_HOOK_DECLARE
 

Declare the dynamic allocation hooks.

Reimplemented from ACE_Addr.

Definition at line 168 of file ATM_Addr.h.

ATM_Addr ACE_ATM_Addr::atm_addr_ [private]
 

Definition at line 177 of file ATM_Addr.h.

Referenced by addr_to_string, get_addr, get_selector, init, operator==, set, set_selector, and string_to_addr.

const int ACE_ATM_Addr::DEFAULT_SELECTOR = 0x0 [static]
 

Definition at line 42 of file ATM_Addr.cpp.

const long ACE_ATM_Addr::LINE_RATE = 0L [static]
 

Definition at line 39 of file ATM_Addr.cpp.

const int ACE_ATM_Addr::OPT_FLAGS_CPID = 0 [static]
 

Definition at line 40 of file ATM_Addr.cpp.

const int ACE_ATM_Addr::OPT_FLAGS_PMP = 0 [static]
 

Definition at line 41 of file ATM_Addr.cpp.

The documentation for this class was generated from the following files:
Generated on Mon Jun 16 12:45:54 2003 for ACE by doxygen1.2.14 written by Dimitri van Heesch, © 1997-2002