ACE/ace/ATM_Addr.cpp

   1 // Defines the Internet domain address family address format.
   2
   3 #include "ace/ATM_Addr.h"
   4 #if defined (ACE_HAS_ATM)
   5
   6 #include "ace/Log_Category.h"
   7
   8 #if defined (ACE_HAS_FORE_ATM_WS2)
   9 #include /**/ "forews2.h"
  10 #endif /* ACE_HAS_FORE_ATM_WS2 */
  11
  12 #if !defined (__ACE_INLINE__)
  13 #include "ace/ATM_Addr.inl"
  14 #endif /* __ACE_INLINE__ */
  15
  16 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  17
  18 ACE_ALLOC_HOOK_DEFINE(ACE_ATM_Addr)
  19
  20 #if defined (ACE_HAS_FORE_ATM_XTI) || defined (ACE_HAS_FORE_ATM_WS2)
  21 #define BHLI_MAGIC "FORE_ATM"
  22 // This is line rate in cells/s for an OC-3 MM interface.
  23 const long ACE_ATM_Addr::LINE_RATE = 353207;
  24 const int ACE_ATM_Addr::OPT_FLAGS_CPID = 0x1;
  25 const int ACE_ATM_Addr::OPT_FLAGS_PMP = 0x2;
  26 const int ACE_ATM_Addr::DEFAULT_SELECTOR = 0x99;
  27 #elif defined (ACE_HAS_LINUX_ATM)
  28 //pbrandao:for Linux:
  29 //pbrandao:for now stick with current definitions
  30 //pbrandao:see if later need to change
  31 const long ACE_ATM_Addr::LINE_RATE = 353207;
  32 const int ACE_ATM_Addr::OPT_FLAGS_CPID = 0;
  33 const int ACE_ATM_Addr::OPT_FLAGS_PMP = 0;
  34 const int ACE_ATM_Addr::DEFAULT_SELECTOR = 0x99;
  35 #else
  36 const long ACE_ATM_Addr::LINE_RATE = 0L;
  37 const int ACE_ATM_Addr::OPT_FLAGS_CPID = 0;
  38 const int ACE_ATM_Addr::OPT_FLAGS_PMP = 0;
  39 const int ACE_ATM_Addr::DEFAULT_SELECTOR = 0x0;
  40 #endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */
  41
  42 // Default constructor
  43
  44 ACE_ATM_Addr::ACE_ATM_Addr (u_char selector)
  45 #if defined (ACE_HAS_FORE_ATM_XTI) || defined (ACE_HAS_FORE_ATM_WS2)
  46   : ACE_Addr (AF_ATM,
  47 #elif defined (ACE_HAS_LINUX_ATM)
  48   : ACE_Addr (PF_ATMSVC,
  49 #else
  50   : ACE_Addr (AF_UNSPEC,
  51 #endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */
  52               sizeof this->atm_addr_)
  53 {
  54   // ACE_TRACE ("ACE_ATM_Addr::ACE_ATM_Addr");
  55  (void) ACE_OS::memset ((void *) &this->atm_addr_,
  56                          0,
  57                          sizeof this->atm_addr_);
  58   this->init (selector);
  59 }
  60
  61 // Copy constructor.
  62
  63 ACE_ATM_Addr::ACE_ATM_Addr (const ACE_ATM_Addr &sap,
  64                             u_char selector)
  65 #if defined (ACE_HAS_FORE_ATM_XTI) || defined (ACE_HAS_FORE_ATM_WS2)
  66   : ACE_Addr (AF_ATM,
  67 #elif defined (ACE_HAS_LINUX_ATM)
  68   : ACE_Addr (PF_ATMSVC,
  69 #else
  70   : ACE_Addr (AF_UNSPEC,
  71 #endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */
  72               sizeof this->atm_addr_)
  73 {
  74   ACE_TRACE ("ACE_ATM_Addr::ACE_ATM_Addr");
  75   this->set (sap, selector);
  76 #if defined (ACE_HAS_LINUX_ATM)
  77   this->atm_addr_.sockaddratmsvc.sas_family = PF_ATMSVC;
  78   this->atm_addr_.atmsap.blli[0].l3_proto = ATM_L3_NONE;
  79   this->atm_addr_.atmsap.blli[0].l2_proto = ATM_L2_NONE;
  80   this->atm_addr_.atmsap.bhli.hl_type = ATM_HL_NONE;
  81 #endif /* ACE_HAS_LINUX_ATM */
  82 }
  83
  84 ACE_ATM_Addr::ACE_ATM_Addr (const ATM_Addr *sap,
  85                             u_char selector)
  86 #if defined (ACE_HAS_FORE_ATM_XTI) || defined (ACE_HAS_FORE_ATM_WS2)
  87   : ACE_Addr (AF_ATM,
  88 #elif defined (ACE_HAS_LINUX_ATM)
  89   : ACE_Addr (PF_ATMSVC,
  90 #else
  91   : ACE_Addr (AF_UNSPEC,
  92 #endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */
  93               sizeof this->atm_addr_)
  94 {
  95   ACE_TRACE ("ACE_ATM_Addr::ACE_ATM_Addr");
  96   this->set (sap, selector);
  97 }
  98
  99
 100 ACE_ATM_Addr::ACE_ATM_Addr (const ACE_TCHAR sap[],
 101                             u_char selector)
 102 #if defined (ACE_HAS_FORE_ATM_XTI) || defined (ACE_HAS_FORE_ATM_WS2)
 103   : ACE_Addr (AF_ATM,
 104 #elif defined (ACE_HAS_LINUX_ATM)
 105   : ACE_Addr (PF_ATMSVC,
 106 #else
 107   : ACE_Addr (AF_UNSPEC,
 108 #endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */
 109               sizeof this->atm_addr_)
 110 {
 111   ACE_TRACE ("ACE_ATM_Addr::ACE_ATM_Addr");
 112   this->set (sap, selector);
 113 }
 114
 115 ACE_ATM_Addr::~ACE_ATM_Addr (void)
 116 {
 117 }
 118
 119 // Return the address.
 120
 121 void *
 122 ACE_ATM_Addr::get_addr (void) const
 123 {
 124   ACE_TRACE ("ACE_ATM_Addr::get_addr");
 125   return (void *) &this->atm_addr_;
 126 }
 127
 128 void
 129 ACE_ATM_Addr::init (u_char selector)
 130 {
 131 #if defined (ACE_HAS_FORE_ATM_XTI)
 132   // Note: this approach may be FORE implementation-specific.  When we
 133   // bind with tag_addr ABSENT and tag_selector PRESENT, only the
 134   // selector (i.e. address[19]) is used by the TP.  The rest of the
 135   // local address is filled in by the TP and can be obtained via the
 136   // 'ret' parameter or with t_getname ()/t_getprotaddr ().
 137
 138   atm_addr_.addressType = (u_int16_t) AF_ATM;
 139
 140   atm_addr_.sap.t_atm_sap_addr.SVE_tag_addr = (int8_t) T_ATM_ABSENT;
 141   atm_addr_.sap.t_atm_sap_addr.SVE_tag_selector = (int8_t) T_ATM_PRESENT;
 142
 143   atm_addr_.sap.t_atm_sap_addr.address_format = (u_int8_t) T_ATM_ENDSYS_ADDR;
 144   atm_addr_.sap.t_atm_sap_addr.address_length = ATMNSAP_ADDR_LEN;
 145   atm_addr_.sap.t_atm_sap_addr.address[ATMNSAP_ADDR_LEN - 1] = selector;
 146
 147   atm_addr_.sap.t_atm_sap_layer2.SVE_tag = (int8_t) T_ATM_ABSENT;
 148   atm_addr_.sap.t_atm_sap_layer3.SVE_tag = (int8_t) T_ATM_ABSENT;
 149
 150   atm_addr_.sap.t_atm_sap_appl.SVE_tag = (int8_t) T_ATM_PRESENT;
 151   atm_addr_.sap.t_atm_sap_appl.ID_type = (u_int8_t) T_ATM_USER_APP_ID;
 152
 153   ACE_OS::memcpy (atm_addr_.sap.t_atm_sap_appl.ID.user_defined_ID,
 154                   BHLI_MAGIC,
 155                   sizeof atm_addr_.sap.t_atm_sap_appl.ID);
 156 #elif defined (ACE_HAS_FORE_ATM_WS2)
 157   ACE_OS::memset ((void *)&atm_addr_, 0, sizeof atm_addr_);
 158   atm_addr_.satm_number.Addr[ ATM_ADDR_SIZE - 1 ] = (char)selector;
 159   atm_addr_.satm_family = AF_ATM;
 160   atm_addr_.satm_number.AddressType = ATM_NSAP;
 161   atm_addr_.satm_number.NumofDigits = ATM_ADDR_SIZE;
 162   atm_addr_.satm_blli.Layer2Protocol = SAP_FIELD_ABSENT;
 163   atm_addr_.satm_blli.Layer3Protocol = SAP_FIELD_ABSENT;
 164   atm_addr_.satm_bhli.HighLayerInfoType = SAP_FIELD_ABSENT;
 165
 166   // Need to know the correspondence.
 167   //atm_addr_.sap.t_atm_sap_appl.SVE_tag = (int8_t) T_ATM_PRESENT;
 168   //atm_addr_.sap.t_atm_sap_appl.ID_type = (u_int8_t) T_ATM_USER_APP_ID;
 169   //ACE_OS::memcpy (atm_addr_.sap.t_atm_sap_appl.ID.user_defined_ID,
 170   //                BHLI_MAGIC,
 171   //                sizeof atm_addr_.sap.t_atm_sap_appl.ID);
 172 #elif defined (ACE_HAS_LINUX_ATM)
 173   atm_addr_.sockaddratmsvc.sas_family = AF_ATMSVC;
 174   atm_addr_.sockaddratmsvc.sas_addr.prv[ATM_ESA_LEN - 1] = (char)selector;
 175   atm_addr_.atmsap.blli[0].l3_proto = ATM_L3_NONE;
 176   atm_addr_.atmsap.blli[0].l2_proto = ATM_L2_NONE;
 177   atm_addr_.atmsap.bhli.hl_type = ATM_HL_NONE;
 178 #else
 179   ACE_UNUSED_ARG (selector);
 180 #endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */
 181 }
 182
 183 int
 184 ACE_ATM_Addr::set (const ACE_ATM_Addr &sap,
 185                    u_char selector)
 186 {
 187   ACE_TRACE ("ACE_ATM_Addr::set");
 188
 189   this->init (selector);
 190
 191   this->ACE_Addr::base_set (sap.get_type (),
 192                             sap.get_size ());
 193
 194 #if defined (ACE_HAS_FORE_ATM_XTI) || defined (ACE_HAS_FORE_ATM_WS2)
 195   ACE_ASSERT (sap.get_type () == AF_ATM);
 196 #elif defined (ACE_HAS_LINUX_ATM)
 197   ACE_ASSERT (sap.get_type () == PF_ATMSVC);
 198 #endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 */
 199
 200  (void) ACE_OS::memcpy ((void *) &this->atm_addr_,
 201  (void *) &sap.atm_addr_,
 202                          sizeof this->atm_addr_);
 203   return 0;
 204 }
 205
 206 int
 207 ACE_ATM_Addr::set (const ATM_Addr *sap,
 208                    u_char selector)
 209 {
 210   ACE_TRACE ("ACE_ATM_Addr::set");
 211
 212   this->init (selector);
 213
 214 #if defined (ACE_HAS_FORE_ATM_XTI) || defined (ACE_HAS_FORE_ATM_WS2)
 215   this->ACE_Addr::base_set (AF_ATM,
 216 #elif defined (ACE_HAS_LINUX_ATM)
 217   this->ACE_Addr::base_set (PF_ATMSVC,
 218 #else
 219   this->ACE_Addr::base_set (AF_UNSPEC,
 220 #endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 */
 221                             sizeof (*sap));
 222
 223  (void) ACE_OS::memcpy ((void *) &this->atm_addr_,
 224  (void *) sap,
 225                          sizeof this->atm_addr_);
 226   return 0;
 227 }
 228
 229 int
 230 ACE_ATM_Addr::set (const ACE_TCHAR address[],
 231                    u_char selector)
 232 {
 233   ACE_TRACE ("ACE_ATM_Addr::set");
 234   int ret;
 235
 236   this->init (selector);
 237
 238 #if defined (ACE_HAS_FORE_ATM_XTI)
 239   atm_addr_.sap.t_atm_sap_addr.SVE_tag_addr =
 240  (int8_t) T_ATM_PRESENT;
 241 #endif /* ACE_HAS_FORE_ATM_XTI */
 242
 243   ret = this -> string_to_addr (address);
 244   this -> set_selector (selector);
 245   return ret;
 246 }
 247
 248 // Transform the string into the current addressing format.
 249
 250 int
 251 ACE_ATM_Addr::string_to_addr (const ACE_TCHAR sap[])
 252 {
 253   ACE_TRACE ("ACE_ATM_Addr::string_to_addr");
 254
 255 #if defined (ACE_HAS_FORE_ATM_XTI) || defined (ACE_HAS_FORE_ATM_WS2)
 256   this->ACE_Addr::base_set (AF_ATM,
 257 #elif defined (ACE_HAS_LINUX_ATM)
 258   this->ACE_Addr::base_set (PF_ATMSVC,
 259 #else
 260   this->ACE_Addr::base_set (AF_UNSPEC,
 261 #endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */
 262                             sizeof this->atm_addr_);
 263 #if defined (ACE_HAS_FORE_ATM_XTI)
 264   struct hostent *entry;
 265   struct atmnsap_addr *nsap;
 266
 267   // Yow, someone gave us a NULL ATM address!
 268   if (sap == 0)
 269     {
 270       errno = EINVAL;
 271       return -1;
 272     }
 273   else if ((entry = gethostbyname_atmnsap ((ACE_TCHAR *)sap)) != 0)
 274     {
 275       ACE_OS::memcpy (atm_addr_.sap.t_atm_sap_addr.address,
 276                       entry->h_addr_list[0],
 277                       ATMNSAP_ADDR_LEN - 1);
 278     }
 279   else if ((nsap = atmnsap_addr (sap)) != 0)
 280     {
 281       ACE_OS::memcpy (atm_addr_.sap.t_atm_sap_addr.address,
 282                       nsap->atmnsap,
 283                       ATMNSAP_ADDR_LEN);
 284     }
 285   else {
 286       errno = EINVAL;
 287       return -1;
 288     }
 289 #elif defined (ACE_HAS_FORE_ATM_WS2)
 290    DWORD dwValue;
 291    HANDLE hLookup;
 292    WSAQUERYSETW qsRestrictions;
 293    CSADDR_INFO  csaBuffer;
 294    WCHAR  tmpWStr[100];
 295
 296    MultiByteToWideChar (CP_ACP, MB_PRECOMPOSED, sap, -1, tmpWStr, 100);
 297
 298    csaBuffer.LocalAddr.iSockaddrLength = sizeof (struct sockaddr_atm);
 299    csaBuffer.LocalAddr.lpSockaddr = (struct sockaddr *)&atm_addr_;
 300    csaBuffer.RemoteAddr.iSockaddrLength = sizeof (struct sockaddr_atm);
 301    csaBuffer.RemoteAddr.lpSockaddr = (struct sockaddr *)&atm_addr_;
 302
 303    qsRestrictions.dwSize                  = sizeof (WSAQUERYSETW);
 304    qsRestrictions.lpszServiceInstanceName = 0;
 305    qsRestrictions.lpServiceClassId        = &FORE_NAME_CLASS;
 306    qsRestrictions.lpVersion               = 0;
 307    qsRestrictions.lpszComment             = 0;
 308    qsRestrictions.dwNameSpace             = FORE_NAME_SPACE;
 309    qsRestrictions.lpNSProviderId          = 0;
 310    qsRestrictions.lpszContext             = L"";
 311    qsRestrictions.dwNumberOfProtocols     = 0;
 312    qsRestrictions.lpafpProtocols          = 0;
 313    qsRestrictions.lpszQueryString         = tmpWStr;
 314    qsRestrictions.dwNumberOfCsAddrs       = 1;
 315    qsRestrictions.lpcsaBuffer             = &csaBuffer;
 316    qsRestrictions.lpBlob                  = 0; //&blob;
 317
 318    if (::WSALookupServiceBeginW (&qsRestrictions, LUP_RETURN_ALL, &hLookup)
 319         == SOCKET_ERROR) {
 320      ACE_OS::printf ("Error: WSALookupServiceBeginW failed! %d\n",
 321                      ::WSAGetLastError ());
 322            return -1;
 323    }
 324
 325    dwValue = sizeof (WSAQUERYSETW);
 326
 327    if (::WSALookupServiceNextW (hLookup, 0, &dwValue, &qsRestrictions)
 328         == SOCKET_ERROR) {
 329      if (WSAGetLastError () != WSA_E_NO_MORE) {
 330        ACE_OS::printf ("Error: WSALookupServiceNextW failed! %d\n",
 331                        ::WSAGetLastError ());
 332              return -1;
 333      }
 334    }
 335
 336    if (WSALookupServiceEnd (hLookup) == SOCKET_ERROR) {
 337      ACE_OS::printf ("Error : WSALookupServiceEnd failed! %d\n",
 338                      ::WSAGetLastError ());
 339       errno = EINVAL;
 340       return -1;
 341    }
 342 #elif defined (ACE_HAS_LINUX_ATM)
 343    if (sap == 0 || !ACE_OS::strcmp (sap,"")) {
 344      errno = EINVAL;
 345      return -1;
 346    }
 347
 348    if (text2atm ((ACE_TCHAR *)sap,
 349  (struct sockaddr *)& (atm_addr_.sockaddratmsvc),
 350                  sizeof (atm_addr_.sockaddratmsvc),
 351                  T2A_SVC | T2A_NAME) < 0) {
 352      ACELIB_DEBUG (LM_DEBUG,
 353                "Error : text2atm failed!\n");
 354      errno = EINVAL;
 355      return -1;
 356    }
 357 #else
 358   ACE_UNUSED_ARG (sap);
 359
 360   return 0;
 361 #endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */
 362
 363 #if defined (ACE_HAS_FORE_ATM_XTI) || defined (ACE_HAS_FORE_ATM_WS2) || defined (ACE_HAS_LINUX_ATM)
 364   return 0;
 365 #endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 */
 366 }
 367
 368 // Transform the current address into string format.
 369
 370 int
 371 ACE_ATM_Addr::addr_to_string (ACE_TCHAR addr[],
 372                               size_t addrlen) const
 373 {
 374   ACE_TRACE ("ACE_ATM_Addr::addr_to_string");
 375
 376 #if defined (ACE_HAS_FORE_ATM_XTI)
 377   ACE_TCHAR buffer[MAXNAMELEN + 1];
 378   struct atmnsap_addr nsap;
 379   ACE_OS::memcpy (nsap.atmnsap,
 380                   atm_addr_.sap.t_atm_sap_addr.address,
 381                   ATMNSAP_ADDR_LEN);
 382   ACE_OS::sprintf (buffer,
 383                    ACE_TEXT ("%s"),
 384                    atmnsap_ntoa (nsap));
 385
 386   size_t total_len = ACE_OS::strlen (buffer) + sizeof ('\0');
 387
 388   if (addrlen < total_len)
 389     return -1;
 390   else
 391     ACE_OS::strcpy (addr, buffer);
 392
 393   return 0;
 394 #elif defined (ACE_HAS_FORE_ATM_WS2)
 395   ACE_TCHAR buffer[MAXNAMELEN + 1];
 396   int i;
 397
 398   if (addrlen < ATM_ADDR_SIZE + 1)
 399           return -1;
 400
 401   for (i = 0; i < ATM_ADDR_SIZE; i++) {
 402     buffer[ i * 3 ] = '\0';
 403           ACE_OS::sprintf (buffer, ACE_TEXT ("%s%02x."),
 404                      buffer,
 405                      atm_addr_.satm_number.Addr[ i ]);
 406   }
 407
 408   buffer[ ATM_ADDR_SIZE * 3 - 1 ] = '\0';
 409   ACE_OS::strcpy (addr, buffer);
 410
 411   return 0;
 412 #elif defined (ACE_HAS_LINUX_ATM)
 413   ACE_TCHAR buffer[MAX_ATM_ADDR_LEN + 1];
 414   int total_len;
 415   if ((total_len = atm2text (buffer,
 416                             sizeof buffer,
 417  (struct sockaddr *)& (atm_addr_.sockaddratmsvc),
 418                             A2T_PRETTY)) < 0) {
 419     ACELIB_DEBUG ((LM_DEBUG,"ACE_ATM_Addr (addr_to_string): atm2text failed\n"));
 420     return -1;
 421   }
 422   if (addrlen < (size_t)total_len)
 423     return -1;
 424   else
 425     ACE_OS::strcpy (addr,
 426                    buffer);
 427
 428   return 0;
 429 #else
 430   ACE_UNUSED_ARG (addr);
 431   ACE_UNUSED_ARG (addrlen);
 432   return -1;
 433 #endif /* ACE_HAS_FORE_ATM_XTI && ACE_HAS_FORE_ATM_WS2 */
 434 }
 435
 436 const ACE_TCHAR *
 437 ACE_ATM_Addr::addr_to_string (void) const
 438 {
 439   ACE_TRACE ("ACE_ATM_Addr::addr_to_string");
 440
 441   static ACE_TCHAR addr[MAXHOSTNAMELEN + 1];
 442   if (this->addr_to_string (addr,
 443                             MAXHOSTNAMELEN + 1) < 0)
 444     return 0;
 445
 446   return addr;
 447 }
 448
 449 // Set a pointer to the address.
 450 void
 451 ACE_ATM_Addr::set_addr (const void *addr, int len)
 452 {
 453   ACE_TRACE ("ACE_ATM_Addr::set_addr");
 454
 455 #if defined (ACE_HAS_FORE_ATM_XTI) || defined (ACE_HAS_FORE_ATM_WS2)
 456   this->ACE_Addr::base_set (AF_ATM,
 457 #elif defined (ACE_HAS_LINUX_ATM)
 458   this->ACE_Addr::base_set (PF_ATMSVC,
 459 #else
 460   this->ACE_Addr::base_set (AF_UNSPEC,
 461 #endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_WS2 */
 462                             len);
 463   ACE_OS::memcpy (&this->atm_addr_, addr, len);
 464 }
 465
 466 // Compare two addresses for inequality.
 467
 468 bool
 469 ACE_ATM_Addr::operator != (const ACE_ATM_Addr &sap) const
 470 {
 471   ACE_TRACE ("ACE_ATM_Addr::operator !=");
 472   return ! ((*this) == sap);
 473 }
 474
 475 // Compare two addresses for equality.
 476
 477 bool
 478 ACE_ATM_Addr::operator == (const ACE_ATM_Addr &sap) const
 479 {
 480   ACE_TRACE ("ACE_ATM_Addr::operator ==");
 481
 482 #if defined (ACE_HAS_LINUX_ATM)
 483   return (atm_equal ((const struct sockaddr *)& (this->atm_addr_.sockaddratmsvc),
 484  (const struct sockaddr *)& (sap.atm_addr_.sockaddratmsvc),
 485                     0,
 486                     0)
 487           &&
 488           sap_equal (& (this->atm_addr_.atmsap),
 489                     & (sap.atm_addr_.atmsap),
 490                     0));
 491 #else
 492   return ACE_OS::memcmp (&atm_addr_,
 493                          &sap.atm_addr_,
 494                          sizeof (ATM_Addr)) == 0;
 495 #endif /*  ACE_HAS_LINUX_ATM */
 496 }
 497
 498 void
 499 ACE_ATM_Addr::dump (void) const
 500 {
 501 #if defined (ACE_HAS_DUMP)
 502   ACE_TRACE ("ACE_ATM_Addr::dump");
 503
 504   ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
 505
 506   ACE_TCHAR s[ACE_MAX_FULLY_QUALIFIED_NAME_LEN + 16];
 507   ACE_OS::sprintf (s,
 508                    ACE_TEXT ("%s"),
 509                    this->addr_to_string ());
 510   ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("%s"), s));
 511   ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 512 #endif /* ACE_HAS_DUMP */
 513 }
 514
 515 ACE_END_VERSIONED_NAMESPACE_DECL
 516
 517 #endif /* ACE_HAS_ATM */