Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | File List | Namespace Members | Class Members | File Members | Related Pages | Search for 

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 Member Functions

 ACE_ATM_Addr (u_char selector=DEFAULT_SELECTOR)
 Default constructor.

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

 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.

void init (u_char selector=DEFAULT_SELECTOR)
int set (const ACE_ATM_Addr &, u_char selector=DEFAULT_SELECTOR)
 Initializes from another ACE_ATM_Addr.

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.

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

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

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

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

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


Public Attributes

 ACE_ALLOC_HOOK_DECLARE
 Declare the dynamic allocation hooks.


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 59 of file ATM_Addr.h.

Constructor & Destructor Documentation

ACE_ATM_Addr::ACE_ATM_Addr (  u_char  selector = DEFAULT_SELECTOR  ) 
 

Default constructor.

Definition at line 48 of file ATM_Addr.cpp.

References ACE_OS::memset(). 

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

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

Copy constructor.

Definition at line 67 of file ATM_Addr.cpp.

References ACE_TRACE. 

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

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 88 of file ATM_Addr.cpp.

References ACE_TRACE, and ATM_Addr. 

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

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

Initializes an ACE_ATM_Addr from the 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 104 of file ATM_Addr.cpp.

References ACE_TCHAR, and ACE_TRACE. 

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

ACE_ATM_Addr::~ACE_ATM_Addr (  void   ) 
 

Default dtor.

Definition at line 119 of file ATM_Addr.cpp. 

00120 {
00121 }

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 of the is too small, else 0.(This version is non-reentrant since it returns a pointer to a static data area.)

Definition at line 441 of file ATM_Addr.cpp.

References ACE_TCHAR, ACE_TRACE, and MAXHOSTNAMELEN. 

00442 {
00443   ACE_TRACE ("ACE_ATM_Addr::addr_to_string");
00444 
00445   static ACE_TCHAR addr[MAXHOSTNAMELEN + 1];
00446   if (this->addr_to_string (addr,
00447                             MAXHOSTNAMELEN + 1) < 0)
00448     return 0;
00449 
00450   return addr;
00451 }

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 (which is assumed to be bytes long). This version is reentrant. Returns -1 if the of the is too small, else 0.

Definition at line 375 of file ATM_Addr.cpp.

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

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

void ACE_ATM_Addr::dump (  void   )  const
 

Dump the state of an object.

Reimplemented from ACE_Addr.

Definition at line 504 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(). 

00505 {
00506 #if defined (ACE_HAS_DUMP)
00507   ACE_TRACE ("ACE_ATM_Addr::dump");
00508 
00509   ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
00510 
00511   ACE_TCHAR s[ACE_MAX_FULLY_QUALIFIED_NAME_LEN + 16];
00512   ACE_OS::sprintf (s,
00513                    ACE_LIB_TEXT ("%s"),
00514                    this->addr_to_string ());
00515   ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("%s"), s));
00516   ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
00517 #endif /* ACE_HAS_DUMP */
00518 }

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

Return a pointer to the underlying network address.

Reimplemented from ACE_Addr.

Definition at line 126 of file ATM_Addr.cpp.

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(). 

00127 {
00128   ACE_TRACE ("ACE_ATM_Addr::get_addr");
00129   return (void *) &this->atm_addr_;
00130 }

ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE u_char ACE_ATM_Addr::get_selector (  void   )  const
 

Return the selector for network address.

Definition at line 8 of file ATM_Addr.inl.

References ACE_TRACE, and atm_addr_. 

00009 {
00010   ACE_TRACE ("ACE_ATM_Addr::get_selector");
00011 #if defined (ACE_HAS_FORE_ATM_XTI)
00012   return atm_addr_.sap.t_atm_sap_addr.address[ATMNSAP_ADDR_LEN - 1];
00013 #elif defined (ACE_HAS_FORE_ATM_WS2)
00014   return atm_addr_.satm_number.Addr[ ATM_ADDR_SIZE - 1 ];
00015 #elif defined (ACE_HAS_LINUX_ATM)
00016   return atm_addr_.sockaddratmsvc.sas_addr.prv[ATM_ESA_LEN - 1];
00017 #else
00018   return 0;
00019 #endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */
00020 }

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 133 of file ATM_Addr.cpp.

References atm_addr_, ACE_OS::memcpy(), and ACE_OS::memset().

Referenced by set(). 

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

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

Compare two addresses for inequality.

Definition at line 474 of file ATM_Addr.cpp.

References ACE_TRACE. 

00475 {
00476   ACE_TRACE ("ACE_ATM_Addr::operator !=");
00477   return ! ((*this) == sap);
00478 }

bool 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 483 of file ATM_Addr.cpp.

References ACE_TRACE, ATM_Addr, atm_addr_, and ACE_OS::memcmp(). 

00484 {
00485   ACE_TRACE ("ACE_ATM_Addr::operator ==");
00486 
00487 #if defined (ACE_HAS_LINUX_ATM)
00488   return (atm_equal ((const struct sockaddr *)& (this->atm_addr_.sockaddratmsvc),
00489  (const struct sockaddr *)& (sap.atm_addr_.sockaddratmsvc),
00490                     0,
00491                     0)
00492           &&
00493           sap_equal (& (this->atm_addr_.atmsap),
00494                     & (sap.atm_addr_.atmsap),
00495                     0));
00496 #else
00497   return ACE_OS::memcmp (&atm_addr_,
00498                          &sap.atm_addr_,
00499                          sizeof (ATM_Addr)) == 0;
00500 #endif /*  ACE_HAS_LINUX_ATM */
00501 }

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

Initializes an ACE_ATM_Addr from the 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 234 of file ATM_Addr.cpp.

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

00236 {
00237   ACE_TRACE ("ACE_ATM_Addr::set");
00238   int ret;
00239 
00240   this->init (selector);
00241 
00242 #if defined (ACE_HAS_FORE_ATM_XTI)
00243   atm_addr_.sap.t_atm_sap_addr.SVE_tag_addr =
00244  (int8_t) T_ATM_PRESENT;
00245 #endif /* ACE_HAS_FORE_ATM_XTI */
00246 
00247   ret = this -> string_to_addr (address);
00248   this -> set_selector (selector);
00249   return ret;
00250 }

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 211 of file ATM_Addr.cpp.

References ACE_TRACE, ATM_Addr, ACE_Addr::base_set(), init(), and ACE_OS::memcpy(). 

00213 {
00214   ACE_TRACE ("ACE_ATM_Addr::set");
00215 
00216   this->init (selector);
00217 
00218 #if defined (ACE_HAS_FORE_ATM_XTI) || defined (ACE_HAS_FORE_ATM_WS2)
00219   this->ACE_Addr::base_set (AF_ATM,
00220 #elif defined (ACE_HAS_LINUX_ATM)
00221   this->ACE_Addr::base_set (PF_ATMSVC,
00222 #else
00223   this->ACE_Addr::base_set (AF_UNSPEC,
00224 #endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 */
00225                             sizeof (*sap));
00226 
00227  (void) ACE_OS::memcpy ((void *) &this->atm_addr_,
00228  (void *) sap,
00229                          sizeof this->atm_addr_);
00230   return 0;
00231 }

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

Initializes from another ACE_ATM_Addr.

Definition at line 188 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::memcpy(). 

00190 {
00191   ACE_TRACE ("ACE_ATM_Addr::set");
00192 
00193   this->init (selector);
00194 
00195   this->ACE_Addr::base_set (sap.get_type (),
00196                             sap.get_size ());
00197 
00198 #if defined (ACE_HAS_FORE_ATM_XTI) || defined (ACE_HAS_FORE_ATM_WS2)
00199   ACE_ASSERT (sap.get_type () == AF_ATM);
00200 #elif defined (ACE_HAS_LINUX_ATM)
00201   ACE_ASSERT (sap.get_type () == PF_ATMSVC);
00202 #endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 */
00203 
00204  (void) ACE_OS::memcpy ((void *) &this->atm_addr_,
00205  (void *) &sap.atm_addr_,
00206                          sizeof this->atm_addr_);
00207   return 0;
00208 }

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

Set a pointer to the address.

Reimplemented from ACE_Addr.

Definition at line 455 of file ATM_Addr.cpp.

References ACE_TRACE, ACE_Addr::base_set(), and ACE_OS::memcpy(). 

00456 {
00457   ACE_TRACE ("ACE_ATM_Addr::set_addr");
00458 
00459 #if defined (ACE_HAS_FORE_ATM_XTI) || defined (ACE_HAS_FORE_ATM_WS2)
00460   this->ACE_Addr::base_set (AF_ATM,
00461 #elif defined (ACE_HAS_LINUX_ATM)
00462   this->ACE_Addr::base_set (PF_ATMSVC,
00463 #else
00464   this->ACE_Addr::base_set (AF_UNSPEC,
00465 #endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_WS2 */
00466                             len);
00467   ACE_OS::memcpy ((void *) &this->atm_addr_,
00468  (void *) addr, len);
00469 }

ACE_INLINE void ACE_ATM_Addr::set_selector (  u_char  selector  ) 
 

Set the selector for the network address.

Definition at line 23 of file ATM_Addr.inl.

References ACE_TRACE, and atm_addr_.

Referenced by ACE_ATM_Acceptor::open(), and set(). 

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

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

Initializes an ACE_ATM_Addr from the 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 255 of file ATM_Addr.cpp.

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

Referenced by set(). 

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

Member Data Documentation

ACE_ATM_Addr::ACE_ALLOC_HOOK_DECLARE
 

Declare the dynamic allocation hooks.

Reimplemented from ACE_Addr.

Definition at line 175 of file ATM_Addr.h.

ATM_Addr ACE_ATM_Addr::atm_addr_ [private]
 

Definition at line 184 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 43 of file ATM_Addr.cpp.

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

Definition at line 40 of file ATM_Addr.cpp.

const int ACE_ATM_Addr::OPT_FLAGS_CPID = 0 [static]
 

Definition at line 41 of file ATM_Addr.cpp.

const int ACE_ATM_Addr::OPT_FLAGS_PMP = 0 [static]
 

Definition at line 42 of file ATM_Addr.cpp.

The documentation for this class was generated from the following files:
Generated on Thu Nov 9 11:20:09 2006 for ACE by doxygen 1.3.6