ACE/ace/Multihomed_INET_Addr.cpp

   1 // Extends ACE_INET_Addr with support for multi-homed addresses.
   2
   3 #include "ace/Multihomed_INET_Addr.h"
   4 #include "ace/Log_Category.h"
   5
   6 #if !defined (__ACE_INLINE__)
   7 #  include "ace/Multihomed_INET_Addr.inl"
   8 #endif /* __ACE_INLINE__ */
   9
  10 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  11
  12 ACE_ALLOC_HOOK_DEFINE(ACE_Multihomed_INET_Addr)
  13
  14 // Default constructor
  15
  16 ACE_Multihomed_INET_Addr::ACE_Multihomed_INET_Addr (void)
  17   : secondaries_ (0)
  18 {
  19   ACE_TRACE ("ACE_Multihomed_INET_Addr::ACE_Multihomed_INET_Addr");
  20 }
  21
  22 ACE_Multihomed_INET_Addr::ACE_Multihomed_INET_Addr (const char address[])
  23  : ACE_INET_Addr (address),
  24    secondaries_ (0)
  25 {
  26 }
  27
  28 ACE_Multihomed_INET_Addr::ACE_Multihomed_INET_Addr(u_short port_number,
  29                                                    const char host_name[],
  30                                                    int encode,
  31                                                    int address_family,
  32                                                    const char *(secondary_host_names[]),
  33                                                    size_t size){
  34
  35   // Initialize the primary INET addr
  36   ACE_INET_Addr::set(port_number, host_name, encode, address_family);
  37
  38   // check for secondary INET addrs
  39   if (secondary_host_names && size){
  40     // we have a non-zero pointer and size
  41     this->secondaries_.size(size); // size the array
  42
  43     size_t next_empty_slot = 0;
  44     for (size_t i = 0; i < size; ++i) {
  45       int ret = this->secondaries_[next_empty_slot].set(port_number,
  46                                                        secondary_host_names[i],
  47                                                        encode,
  48                                                        address_family);
  49       if (ret) {
  50         ACELIB_DEBUG ((LM_DEBUG,
  51                     ACE_TEXT ("Invalid INET addr (%C:%u) will be ignored\n"),
  52                     secondary_host_names[i], port_number));
  53         this->secondaries_.size(this->secondaries_.size() - 1);
  54       }
  55       else
  56         ++next_empty_slot;
  57     }
  58   }
  59
  60   return;
  61 }
  62
  63 #if defined (ACE_HAS_WCHAR)
  64 ACE_Multihomed_INET_Addr::ACE_Multihomed_INET_Addr(u_short port_number,
  65                                                    const wchar_t host_name[],
  66                                                    int encode,
  67                                                    int address_family,
  68                                                    const wchar_t *(secondary_host_names[]),
  69                                                    size_t size){
  70
  71   // Initialize the primary INET addr
  72   ACE_INET_Addr::set(port_number, host_name, encode, address_family);
  73
  74   // check for secondary INET addrs
  75   if (secondary_host_names && size){
  76     // we have a non-zero pointer and size
  77     this->secondaries_.size(size); // size the array
  78
  79     size_t next_empty_slot = 0;
  80     for (size_t i = 0; i < size; ++i) {
  81       int ret = this->secondaries_[next_empty_slot].set(port_number,
  82                                                        secondary_host_names[i],
  83                                                        encode,
  84                                                        address_family);
  85       if (ret) {
  86         ACELIB_DEBUG ((LM_DEBUG,
  87                     ACE_TEXT ("Invalid INET addr (%s:%u) will be ignored\n"),
  88                     ACE_TEXT_WCHAR_TO_TCHAR (secondary_host_names[i]), port_number));
  89         this->secondaries_.size(this->secondaries_.size() - 1);
  90       }
  91       else
  92         ++next_empty_slot;
  93     }
  94   }
  95
  96   return;
  97 }
  98 #endif /* ACE_HAS_WCHAR */
  99
 100 ACE_Multihomed_INET_Addr::ACE_Multihomed_INET_Addr(u_short port_number,
 101                                                    ACE_UINT32 primary_ip_addr,
 102                                                    int encode,
 103                                                    const ACE_UINT32 *secondary_ip_addrs,
 104                                                    size_t size){
 105
 106   // Initialize the primary INET addr
 107   ACE_INET_Addr::set(port_number, primary_ip_addr, encode);
 108
 109   // check for secondary INET addrs
 110   if (secondary_ip_addrs && size){
 111     // we have a non-zero pointer and size
 112     this->secondaries_.size(size); // size the array
 113
 114     size_t next_empty_slot = 0;
 115     for (size_t i = 0; i < size; ++i) {
 116       int const ret = this->secondaries_[next_empty_slot].set(port_number,
 117                                                               secondary_ip_addrs[i],
 118                                                               encode);
 119
 120       if (ret) {
 121         ACELIB_DEBUG ((LM_DEBUG,
 122                     "Invalid INET addr (%u:%u) will be ignored\n",
 123                     secondary_ip_addrs[i], port_number));
 124         this->secondaries_.size(this->secondaries_.size() - 1);
 125       }
 126       else
 127         ++next_empty_slot;
 128     }
 129   }
 130
 131   return;
 132 }
 133
 134 // Set implementations  (NEED BETTER COMMENT HERE)
 135 int
 136 ACE_Multihomed_INET_Addr::set (u_short port_number,
 137                                const char host_name[],
 138                                int encode,
 139                                int address_family,
 140                                const char *(secondary_host_names[]),
 141                                size_t size)
 142 {
 143   this->secondaries_.size(size);
 144
 145   for (size_t i = 0; i < size; ++i) {
 146
 147     int const ret = this->secondaries_[i].set(port_number,
 148                                               secondary_host_names[i],
 149                                               encode,
 150                                               address_family);
 151     if (ret) {
 152       return ret;
 153     }
 154   }
 155
 156   return ACE_INET_Addr::set(port_number, host_name, encode, address_family);
 157 }
 158
 159 #if defined (ACE_HAS_WCHAR)
 160 //
 161 // WCHAR version of ::set
 162 //
 163 int
 164 ACE_Multihomed_INET_Addr::set (u_short port_number,
 165                                const wchar_t host_name[],
 166                                int encode,
 167                                int address_family,
 168                                const wchar_t *(secondary_host_names[]),
 169                                size_t size)
 170 {
 171   this->secondaries_.size(size);
 172
 173   for (size_t i = 0; i < size; ++i) {
 174
 175     int ret = this->secondaries_[i].set(port_number,
 176                                        secondary_host_names[i],
 177                                        encode,
 178                                        address_family);
 179     if (ret) {
 180       return ret;
 181     }
 182   }
 183
 184   return ACE_INET_Addr::set(port_number, host_name, encode, address_family);
 185 }
 186 #endif /* ACE_HAS_WCHAR */
 187
 188 int
 189 ACE_Multihomed_INET_Addr::set (u_short port_number,
 190                                ACE_UINT32 primary_ip_addr,
 191                                int encode,
 192                                const ACE_UINT32 *secondary_ip_addrs,
 193                                size_t size)
 194 {
 195   this->secondaries_.size(size);
 196
 197   for (size_t i = 0; i < size; ++i) {
 198
 199     int ret = this->secondaries_[i].set(port_number,
 200                                        secondary_ip_addrs[i],
 201                                        encode);
 202
 203     if (ret) {
 204       return ret;
 205     }
 206   }
 207
 208   return ACE_INET_Addr::set(port_number, primary_ip_addr, encode);
 209 }
 210
 211 void
 212 ACE_Multihomed_INET_Addr::set_port_number (u_short port_number, int encode)
 213 {
 214   size_t i = 0;
 215   while (i < secondaries_.size())
 216     secondaries_[i++].set_port_number(port_number, encode);
 217
 218   this->ACE_INET_Addr::set_port_number(port_number, encode);
 219 }
 220
 221 int
 222 ACE_Multihomed_INET_Addr::get_secondary_addresses(ACE_INET_Addr *secondary_addrs,
 223                                                   size_t size) const
 224 {
 225   size_t top =
 226     size < this->secondaries_.size() ?
 227     size : this->secondaries_.size();
 228
 229   for (size_t i = 0; i < top; ++i)
 230     {
 231
 232       int ret =
 233         secondary_addrs[i].set (this->secondaries_[i]);
 234
 235       if (ret)
 236         return ret;
 237     }
 238
 239   return 0;
 240 }
 241
 242 void
 243 ACE_Multihomed_INET_Addr::get_addresses(sockaddr_in *addrs,
 244                                         size_t size) const
 245 {
 246   if (size == 0)
 247     return;
 248   // Copy primary address(es) to the first slot(s) of the user-supplied array
 249   ACE_INET_Addr me (*this);
 250   size_t i = 0;
 251   for (i = 0; i < size; ++i)
 252     {
 253       sockaddr_in *in4 = reinterpret_cast<sockaddr_in*> (me.get_addr ());
 254       if (in4->sin_family == AF_INET)
 255         {
 256           addrs[i] = *in4;
 257           ++i;
 258         }
 259       if (!me.next ())
 260         break;
 261     }
 262
 263   // Copy secondary addresses to remaining slots of the user-supplied
 264   // array.  Secondary address [i] is copied to slot [i+1]
 265   for (size_t j = 0; j < this->secondaries_.size (); ++j)
 266     {
 267       ACE_INET_Addr copy (this->secondaries_[j]);
 268       for (; i < size; ++i)
 269         {
 270           sockaddr_in *in4 = reinterpret_cast<sockaddr_in*> (copy.get_addr ());
 271           if (in4->sin_family == AF_INET)
 272             {
 273               addrs[i] = *in4;
 274               ++i;
 275             }
 276              if (!copy.next ())
 277             break;
 278         }
 279     }
 280 }
 281
 282 #if defined (ACE_HAS_IPV6)
 283 void
 284 ACE_Multihomed_INET_Addr::get_addresses(sockaddr_in6 *addrs,
 285                                         size_t size) const
 286 {
 287   if (size == 0)
 288     return;
 289   // Copy primary address(es) to the first slot(s) of the user-supplied array
 290   ACE_INET_Addr me (*this);
 291   size_t i = 0;
 292   for (i = 0; i < size; ++i)
 293     {
 294       sockaddr_in6 *in6 = reinterpret_cast<sockaddr_in6*> (me.get_addr ());
 295       if (in6->sin6_family == AF_INET6)
 296         {
 297           addrs[i] = *in6;
 298           ++i;
 299         }
 300       if (!me.next ())
 301         break;
 302     }
 303
 304   // Copy secondary addresses to remaining slots of the user-supplied
 305   // array.  Secondary address [i] is copied to slot [i+1]
 306   for (size_t j = 0; j < this->secondaries_.size (); ++j)
 307     {
 308       ACE_INET_Addr copy (this->secondaries_[j]);
 309       for (; i < size; ++i)
 310         {
 311           sockaddr_in6 *in6 =
 312             reinterpret_cast<sockaddr_in6*> (copy.get_addr ());
 313           if (in6->sin6_family == AF_INET6)
 314             {
 315               addrs[i] = *in6;
 316               ++i;
 317             }
 318           if (!copy.next ())
 319             break;
 320         }
 321     }
 322 }
 323 #endif /* ACE_HAS_IPV6 */
 324
 325
 326 ACE_Multihomed_INET_Addr::~ACE_Multihomed_INET_Addr (void)
 327 {
 328
 329 }
 330
 331 ACE_END_VERSIONED_NAMESPACE_DECL