Debian Codegraph @

protolib/src/common/protoAddress.cpp

raw
1
2 #include "protoAddress.h"
3 #include "protoSocket.h" // for ProtoSocket::GetInterfaceAddress() routines
4 #include "protoDebug.h" // for print out of warnings, etc
5 /**
6 * @file protoAddress.cpp
7 * @brief Network address container class.
8 */
9
10
11 #ifdef UNIX
12 #include <sys/types.h>
13 #include <sys/socket.h>
14 #include <sys/ioctl.h>
15 #include <net/if.h>
16 #include <netdb.h>
17 #include <unistd.h> // for gethostname()
18
19 #if !defined(SIOCGIFHWADDR) && !(defined(SOLARIS) || defined(IRIX))
20 #define HAVE_IFDL
21 #include <net/if_types.h> // for IFT_ETHER
22 #include <net/if_dl.h> // for sockaddr_dl
23 #endif
24
25
26 #ifdef SOLARIS
27 #include <sys/sockio.h> // for SIOCGIFADDR ioctl
28 #endif // SOLARIS
29 #endif // UNIX
30
31 #include <stdlib.h> // for atoi()
32 #include <stdio.h> // for sprintf()
33 #include <string.h> // for memset()
34
35 const ProtoAddress PROTO_ADDR_NONE;
36
37 const ProtoAddress PROTO_ADDR_BROADCAST("ff:ff:ff:ff:ff:ff");
38
39 ProtoAddress::ProtoAddress()
40 : type(INVALID), length(0)
41 {
42 memset(&addr, 0, sizeof(addr));
43 }
44
45 ProtoAddress::ProtoAddress(const ProtoAddress& theAddr)
46 {
47 *this = theAddr;
48 }
49
50 ProtoAddress::ProtoAddress(const char* theAddr)
51 {
52 ConvertFromString(theAddr);
53 }
54
55 ProtoAddress::~ProtoAddress()
56 {
57 }
58
59 // This infers the ProtoAddress::Type from length (in bytes)
60 ProtoAddress::Type ProtoAddress::GetType(UINT8 addrLength)
61 {
62 #ifdef SIMULATE
63 // Note 'SIM' case takes precedence
64 if (sizeof(SIMADDR) == addrLength)
65 return SIM;
66 #endif // SIMULATE
67 switch (addrLength)
68 {
69 case 4:
70 return IPv4;
71 case 16:
72 return IPv6;
73 case 6:
74 return ETH;
75 default:
76 return INVALID;
77 }
78 } // end ProtoAddress::GetType()
79
80 bool ProtoAddress::IsMulticast() const
81 {
82 switch(type)
83 {
84 case IPv4:
85 {
86 UINT32 addrVal = (UINT32)(((struct sockaddr_in*)&addr)->sin_addr.s_addr);
87 return (((UINT32)(htonl(0xf0000000) & addrVal)) == htonl(0xe0000000));
88 }
89
90 #ifdef HAVE_IPV6
91 case IPv6:
92 {
93 if (IN6_IS_ADDR_V4MAPPED(&(((struct sockaddr_in6*)&addr)->sin6_addr)))
94 {
95 return (htonl(0xe0000000) ==
96 ((UINT32)(htonl(0xf0000000) &
97 IN6_V4MAPPED_ADDR(&(((struct sockaddr_in6*)&addr)->sin6_addr)))));
98 }
99 else
100 {
101 return (0 != IN6_IS_ADDR_MULTICAST(&(((struct sockaddr_in6*)&addr)->sin6_addr)) ? true : false);
102 }
103 }
104 #endif // HAVE_IPV6
105 case ETH:
106 // ethernet broadcast also considered mcast here
107 return (0 != (0x01 & ((char*)&addr)[0]));
108
109 #ifdef SIMULATE
110 case SIM:
111 #ifdef NS2
112 return (0 != (addr.addr & 0x80000000));
113 // && (addr.addr != 0xffffffff);
114 #endif // NS2
115 #ifdef OPNET
116 return (0xe0000000 == (0xf0000000 & addr.addr));
117 #endif // OPNET
118 #endif // SIMULATE
119 default:
120 return false;
121 }
122 } // end IsMulticast()
123
124 bool ProtoAddress::IsBroadcast() const
125 {
126 switch(type)
127 {
128 case IPv4:
129 {
130 UINT32 addrVal = (UINT32)(((struct sockaddr_in*)&addr)->sin_addr.s_addr);
131 return (addrVal == htonl(0xffffffff));
132 }
133
134 #ifdef HAVE_IPV6
135 case IPv6:
136 {
137 return false; // no IPv6 broadcast address
138 }
139 #endif // HAVE_IPV6
140
141 case ETH:
142 {
143 const unsigned char temp[6] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
144 return (0 == memcmp((const char*)&addr, temp, 6));
145 }
146
147 #ifdef SIMULATE
148 case SIM:
149 #ifdef NS2
150 return ((int)0xffffffff == addr.addr);
151 #endif // NS2
152 #ifdef OPNET
153 return (0xffffffff == addr.addr);
154 #endif // OPNET
155 #endif // SIMULATE
156 default:
157 return false;
158 }
159 } // end IsBroadcast()
160
161 bool ProtoAddress::IsLoopback() const
162 {
163 switch(type)
164 {
165 case IPv4:
166 {
167 // This was changed since any 127.X.X.X is a loopback address
168 // and many Linux configs have started using this fact for some purpose
169 UINT32 addrVal = (UINT32)((struct sockaddr_in*)&addr)->sin_addr.s_addr;
170 return (0x7f == (ntohl(addrVal) >> 24));
171 }
172 #ifdef HAVE_IPV6
173 case IPv6:
174 {
175 if (IN6_IS_ADDR_V4MAPPED(&(((struct sockaddr_in6*)&addr)->sin6_addr)))
176 return (htonl(0x7f000001) ==
177 IN6_V4MAPPED_ADDR(&(((struct sockaddr_in6*)&addr)->sin6_addr)));
178 else
179 return (0 != IN6_IS_ADDR_LOOPBACK(&(((struct sockaddr_in6*)&addr)->sin6_addr)) ? true : false);
180 }
181 #endif // HAVE_IPV6
182 case ETH:
183 return false;
184 #ifdef SIMULATE
185 case SIM:
186 return false;
187 #endif // SIMULATE
188 default:
189 return false;
190 }
191 } // end ProtoAddress::IsLoopback()
192
193 bool ProtoAddress::IsUnspecified() const
194 {
195 switch(type)
196 {
197 case IPv4:
198 {
199 UINT32 addrVal = (UINT32)(((struct sockaddr_in*)&addr)->sin_addr.s_addr);
200 return (0x00000000 == addrVal);
201 }
202 #ifdef HAVE_IPV6
203 case IPv6:
204 {
205 if (IN6_IS_ADDR_V4MAPPED(&(((struct sockaddr_in6*)&addr)->sin6_addr)))
206 {
207 return (0x0000000 ==
208 IN6_V4MAPPED_ADDR(&(((struct sockaddr_in6*)&addr)->sin6_addr)));
209 }
210 else
211 {
212 return (0 != IN6_IS_ADDR_UNSPECIFIED(&(((struct sockaddr_in6*)&addr)->sin6_addr)) ? true : false);
213 }
214 }
215 #endif // HAVE_IPV6
216 case ETH:
217 return false;
218 #ifdef SIMULATE
219 case SIM:
220 return false;
221 #endif // SIMULATE
222 default:
223 return false;
224 }
225 } // end IsUnspecified()
226
227 bool ProtoAddress::IsLinkLocal() const
228 {
229 switch(type)
230 {
231 #ifdef HAVE_IPV6
232 case IPv6:
233 {
234 struct in6_addr* a = &(((struct sockaddr_in6*)&addr)->sin6_addr);
235 return (0 != IN6_IS_ADDR_MULTICAST(a) ?
236 (0 != IN6_IS_ADDR_MC_LINKLOCAL(a) ? true : false) :
237 (0 != IN6_IS_ADDR_LINKLOCAL(a) ? true : false));
238 }
239 #endif // HAVE_IPV6
240 case IPv4:
241 {
242 UINT32 addrVal = (UINT32)(((struct sockaddr_in*)&addr)->sin_addr.s_addr);
243 if (((UINT32)(htonl(0xffffff00) & addrVal))
244 == (UINT32)htonl(0xe0000000))
245 {
246 // Address is 224.0.0/24 multicast.
247 return true;
248 }
249 else if (((UINT32)(htonl(0xffff0000) & addrVal))
250 == (UINT32)htonl(0xa9fe0000))
251 {
252 // Address is 169.254/16 unicast.
253 return true;
254 }
255 return false;
256 }
257 case ETH:
258 return false; // or return true???
259 default:
260 return false;
261 }
262 } // end ProtoAddress::IsLinkLocal()
263
264 bool ProtoAddress::IsSiteLocal() const
265 {
266 switch(type)
267 {
268 #ifdef HAVE_IPV6
269 case IPv6:
270 {
271 struct in6_addr* a = &(((struct sockaddr_in6*)&addr)->sin6_addr);
272 return (IN6_IS_ADDR_MULTICAST(a) ?
273 (0 != IN6_IS_ADDR_MC_SITELOCAL(a) ? true : false) :
274 (0 != IN6_IS_ADDR_SITELOCAL(a) ? true : false));
275 }
276 #endif // HAVE_IPV6
277 case IPv4:
278 case ETH:
279 return false;
280 default:
281 return false;
282 }
283 } // end ProtoAddress::IsSiteLocal()
284
285 /**
286 *
287 * @brief Translates the address to a host string
288 *
289 * @param buffer
290 * @param buflen
291 *
292 * @retval Returns the address as a host string
293 */
294 const char* ProtoAddress::GetHostString(char* buffer, unsigned int buflen) const
295 {
296 static char altBuffer[256];
297 altBuffer[255] = '\0';
298 buflen = (NULL != buffer) ? buflen : 255;
299 #ifdef _UNICODE
300 buflen /= 2;
301 #endif // _UNICODE
302 buffer = (NULL != buffer) ? buffer : altBuffer;
303 switch (type)
304 {
305 #ifdef WIN32
306 case IPv4:
307 #ifdef HAVE_IPV6
308 case IPv6:
309 #endif // HAVE_IPV6
310 {
311 // Startup WinSock for name lookup
312 if (!Win32Startup())
313 {
314 PLOG(PL_ERROR, "ProtoAddress: GetHostString(): Error initializing WinSock!\n");
315 return NULL;
316 }
317 unsigned long len = buflen;
318 if (0 != WSAAddressToString((SOCKADDR*)&addr, sizeof(addr), NULL, (LPTSTR)buffer, &len))
319 PLOG(PL_ERROR, "ProtoAddress::GetHostString() WSAAddressToString() error\n");
320 Win32Cleanup();
321 #ifdef _UNICODE
322 // Convert from unicode
323 wcstombs(buffer, (wchar_t*)buffer, len);
324 #endif // _UNICODE
325 // Get rid of trailing port number
326 if (IPv4 == type)
327 {
328 char* ptr = strrchr(buffer, ':');
329 if (ptr) *ptr = '\0';
330 }
331 #ifdef HAVE_IPV6
332 else if (IPv6 == type)
333 {
334 char* ptr = strchr(buffer, '['); // nuke start bracket
335 if (ptr)
336 {
337 char * pch;
338 size_t len = strlen(buffer);
339 if (len > buflen) len = buflen;
340 ptr++;
341 memmove(buffer, ptr, len - (ptr-buffer));
342 }
343 ptr = strrchr(buffer, '%'); // nuke if index, if applicable
344 if (!ptr) ptr = strrchr(buffer, ']'); // nuke end bracket
345 ptr = (char *)memchr(buffer, ']', strlen(buffer));
346 if (ptr)
347 buffer[ptr - buffer] = '\0';
348
349 }
350 #endif // HAVE_IPV6
351 return buffer ? buffer : "(null)";
352 }
353 #else
354 #ifdef HAVE_IPV6
355 case IPv4:
356 {
357 const char* result = inet_ntop(AF_INET, &((struct sockaddr_in*)&addr)->sin_addr, buffer, buflen);
358 return result ? result : "(bad address)";
359 }
360 case IPv6:
361 {
362 const char* result = inet_ntop(AF_INET6, &((struct sockaddr_in6*)&addr)->sin6_addr, buffer, buflen);
363 return result ? result : "(bad address)";
364 }
365 #else
366 case IPv4:
367 strncpy(buffer, inet_ntoa(((struct sockaddr_in *)&addr)->sin_addr), buflen);
368 return buffer;
369 #endif // HAVE_IPV6
370 #endif // if/else WIN32/UNIX
371 case ETH:
372 {
373 // Print as a hexadecimal number
374 unsigned int len = 0;
375 for (int i = 0; i < 6; i++)
376 {
377 if (len < buflen)
378 {
379 if (i < 1)
380 len += sprintf(buffer+len, "%02x", ((unsigned char*)&addr)[i]);
381 else
382 len += sprintf(buffer+len, ":%02x", ((unsigned char*)&addr)[i]);
383 }
384 else
385 {
386 break;
387 }
388 }
389 return buffer;
390 }
391 #ifdef SIMULATE
392 case SIM:
393 {
394 char text[32];
395 #ifndef OPNET // JPH 5/22/06
396 sprintf(text, "%u", ((struct sockaddr_sim*)&addr)->addr);
397 #else
398 ip_address_print(text,(IpT_Address)((struct sockaddr_sim*)&addr)->addr);
399 #endif // OPNET
400 strncpy(buffer, text, buflen);
401 return buffer ? buffer : "(null)";
402 }
403 #endif // SIMULATE
404 default:
405 PLOG(PL_ERROR, "ProtoAddress: GetHostString(): Invalid address type!\n");
406 return "(invalid address)";
407 } // end switch(type)
408 } // end ProtoAddress::GetHostString()
409
410 void ProtoAddress::PortSet(UINT16 thePort) {SetPort(thePort);}
411
412 void ProtoAddress::SetPort(UINT16 thePort)
413 {
414 switch(type)
415 {
416 case IPv4:
417 ((struct sockaddr_in*)&addr)->sin_port = htons(thePort);
418 break;
419 #ifdef HAVE_IPV6
420 case IPv6:
421 ((struct sockaddr_in6*)&addr)->sin6_port = htons(thePort);
422 break;
423 #endif // HAVE_IPV6
424 #ifdef SIMULATE
425 case SIM:
426 ((struct sockaddr_sim*)&addr)->port = thePort;
427 break;
428 #endif // SIMULATE
429 case ETH:
430 break;
431 default:
432 Reset(IPv4);
433 SetPort(thePort);
434 break;
435 }
436 } // end ProtoAddress::SetPort()
437
438 UINT16 ProtoAddress::GetPort() const
439 {
440 switch(type)
441 {
442 case IPv4:
443 return ntohs(((struct sockaddr_in *)&addr)->sin_port);
444 #ifdef HAVE_IPV6
445 case IPv6:
446 return ntohs(((struct sockaddr_in6 *)&addr)->sin6_port);
447 #endif // HAVE_IPV6
448 #ifdef SIMULATE
449 case SIM:
450 return (((struct sockaddr_sim*)&addr)->port);
451 #endif // SIMULATE
452 case ETH:
453 default:
454 return 0; // port 0 is an invalid port
455 }
456 } // end ProtoAddress::Port()
457 /**
458 *
459 * @brief Resets the address to zero or high values.
460 *
461 * @param theType
462 * @param zero
463 *
464 */
465 void ProtoAddress::Reset(ProtoAddress::Type theType, bool zero)
466 {
467 char value = zero ? 0x00 : 0xff;
468 char fill[16];
469 switch (theType)
470 {
471 case IPv4:
472 memset(fill, value, 4);
473 SetRawHostAddress(IPv4, fill, 4);
474 break;
475 #ifdef HAVE_IPV6
476 case IPv6:
477 memset(fill, value, 16);
478 SetRawHostAddress(IPv6, fill, 16);
479 break;
480 #endif // HAVE_IPV6
481 case ETH:
482 memset(fill, value, 6);
483 SetRawHostAddress(ETH, fill, 6);
484 break;
485 #ifdef SIMULATE
486 case SIM:
487 type = SIM;
488 length = sizeof(SIMADDR);
489 memset(&((struct sockaddr_sim*)&addr)->addr, value, sizeof(SIMADDR));
490 break;
491 #endif // SIMULATE
492 default:
493 PLOG(PL_ERROR, "ProtoAddress::Reset() Invalid address type!\n");
494 break;
495 }
496 SetPort(0);
497 } // end ProtoAddress::Reset();
498
499 /**
500 *
501 * @brief Initializes the address (incl. port) from the provided sockaddr struct.
502 *
503 * @param theAddr
504 *
505 * @retval Returns success/failure
506 */
507 bool ProtoAddress::SetSockAddr(const struct sockaddr& theAddr)
508 {
509 switch (theAddr.sa_family)
510 {
511 case AF_INET:
512 //((struct sockaddr_in&)addr) = ((struct sockaddr_in&)theAddr);
513 // memcpy() safer here due to memory alignment issues on
514 // some compilers / platforms (e.g. Android ARM)??
515 memcpy(&addr, &theAddr, sizeof(struct sockaddr_in));
516 type = IPv4;
517 length = 4;
518 return true;
519 #ifdef HAVE_IPV6
520 case AF_INET6:
521 //((struct sockaddr_in6&)addr) = ((struct sockaddr_in6&)theAddr);
522 // memcpy() safer here due to memory alignment issues on
523 // some compilers / platforms (e.g. Android ARM)??
524 memcpy(&addr, &theAddr, sizeof(struct sockaddr_in6));
525 type = IPv6;
526 length = 16;
527 return true;
528 #endif // HAVE_IPV6
529 #ifdef HAVE_IFDL
530 case AF_LINK:
531 {
532 // The (void*) cast here avoid cast-align warning. TBD - may need to revisit this.
533 struct sockaddr_dl* sdl = (struct sockaddr_dl*)((void*)&theAddr);
534 if (IFT_ETHER != sdl->sdl_type)
535 {
536 PLOG(PL_WARN, "ProtoNet::SetSockAddr() error: non-Ethertype link address!\n");
537 return false;
538 }
539 SetRawHostAddress(ETH, sdl->sdl_data + sdl->sdl_nlen, sdl->sdl_alen);
540 return true;
541 }
542 #endif // HAVE_IFDL
543 default:
544 PLOG(PL_ERROR, "ProtoAddress::SetSockAddr() warning: Invalid address type: %d\n", theAddr.sa_family);
545 type = INVALID;
546 length = 0;
547 return false;
548 }
549 } // end ProtoAddress:SetAddress()
550
551 /**
552 *
553 * @brief Initializes the address from the buffer contents
554 *
555 * @param theType
556 * @param buffer
557 * @param buflen
558 *
559 * @retval Returns success/failure
560 */
561 bool ProtoAddress::SetRawHostAddress(ProtoAddress::Type theType,
562 const char* buffer,
563 UINT8 buflen)
564 {
565 UINT16 thePort = GetPort();
566 switch (theType)
567 {
568 case IPv4:
569 if (buflen > 4) return false;
570 type = IPv4;
571 length = 4;
572 memset(&((struct sockaddr_in*)&addr)->sin_addr, 0, 4);
573 memcpy(&((struct sockaddr_in*)&addr)->sin_addr, buffer, buflen);
574 #if defined(_SOCKLEN_T) || defined(_SOCKLEN_T_DECLARED) // for BSD systems
575 ((struct sockaddr_in*)&addr)->sin_len = sizeof(sockaddr_in);
576 #endif // defined(_SOCKLENT_T) || defined(_SOCKLEN_T_DECLARED)
577 ((struct sockaddr_in*)&addr)->sin_family = AF_INET;
578 break;
579 #ifdef HAVE_IPV6
580 case IPv6:
581 if (buflen > 16) return false;
582 type = IPv6;
583 length = 16;
584 memset(&((struct sockaddr_in6*)&addr)->sin6_addr, 0, 16);
585 memcpy(&((struct sockaddr_in6*)&addr)->sin6_addr, buffer, buflen);
586 #if defined(_SOCKLEN_T) || defined(_SOCKLEN_T_DECLARED) // for BSD systems
587 ((struct sockaddr_in6*)&addr)->sin6_len = sizeof(sockaddr_in6);
588 #endif // defined(_SOCKLENT_T) || defined(_SOCKLEN_T_DECLARED)
589 ((struct sockaddr_in6*)&addr)->sin6_family = AF_INET6;
590 break;
591 #endif // HAVE_IPV6
592 case ETH:
593 if (buflen > 6) return false;
594 type = ETH;
595 length = 6;
596 memset((char*)&addr, 0, 6);
597 memcpy((char*)&addr, buffer, buflen);
598 break;
599 #ifdef SIMULATE
600 case SIM:
601 if (buflen > sizeof(SIMADDR)) return false;
602 type = SIM;
603 length = sizeof(SIMADDR);
604 memset(&((struct sockaddr_sim*)&addr)->addr, 0, sizeof(SIMADDR));
605 memcpy(&((struct sockaddr_sim*)&addr)->addr, buffer, buflen);
606 break;
607 #endif // SIMULATE
608 default:
609 PLOG(PL_ERROR, "ProtoAddress::SetRawHostAddress() Invalid address type!\n");
610 return false;
611 }
612 SetPort(thePort);
613 return true;
614 } // end ProtoAddress::SetRawHostAddress()
615
616
617 const char* ProtoAddress::GetRawHostAddress() const
618 {return AccessRawHostAddress();}
619
620 char* ProtoAddress::AccessRawHostAddress() const
621 {
622 switch (type)
623 {
624 case IPv4:
625 return ((char*)&((struct sockaddr_in*)&addr)->sin_addr);
626 #ifdef HAVE_IPV6
627 case IPv6:
628 return ((char*)&((struct sockaddr_in6*)&addr)->sin6_addr);
629 #endif // HAVE_IPV6
630 case ETH:
631 return ((char*)&addr);
632 #ifdef SIMULATE
633 case SIM:
634 return ((char*)&((struct sockaddr_sim*)&addr)->addr);
635 #endif // SIMULATE
636 default:
637 PLOG(PL_ERROR, "ProtoAddress::RawHostAddress() Invalid address type!\n");
638 return NULL;
639 }
640 } // end ProtoAddress::GetRawHostAddress()
641
642 unsigned int ProtoAddress::SetCommonHead(const ProtoAddress& theAddr)
643 {
644 unsigned int commonBytes = 0;
645 if((GetType() != theAddr.GetType()) && (!IsValid()))
646 {
647 Reset(GetType());
648 return commonBytes;
649 }
650 const char *myRawHost = GetRawHostAddress();
651 const char *theirRawHost = theAddr.GetRawHostAddress();
652 for(commonBytes = 1 ; commonBytes <= GetLength() ; commonBytes++)
653 {
654 if(memcmp(myRawHost,theirRawHost,commonBytes))
655 {
656 commonBytes--;
657 ApplyPrefixMask(commonBytes*8); //ApplyPrefixMask takes size in bits
658 return commonBytes;
659 }
660 }
661 return GetLength();
662 } // end ProtoAddress::SetCommonHead()
663
664 unsigned int ProtoAddress::SetCommonTail(const ProtoAddress& theAddr)
665 {
666 unsigned int commonBytes = 0;
667 if((GetType() != theAddr.GetType()) && (!IsValid()))
668 {
669 Reset(GetType());
670 return commonBytes;
671 }
672 const char *myRawHost = GetRawHostAddress();
673 const char *theirRawHost = theAddr.GetRawHostAddress();
674 for(commonBytes = 1 ; commonBytes <= GetLength() ; commonBytes++)
675 {
676 if(memcmp(myRawHost-commonBytes+GetLength(),theirRawHost-commonBytes+GetLength(),commonBytes))
677 {
678 commonBytes--;
679 ApplySuffixMask(commonBytes*8);
680 return commonBytes;
681 }
682 }
683 return GetLength();
684 } // end ProtoAddress::SetCommonTail()
685
686
687 bool ProtoAddress::PrefixIsEqual(const ProtoAddress& theAddr, UINT8 prefixLen) const
688 {
689 // Compare address "type" and "prefixLen" bits of address
690 if (!IsValid() && !theAddr.IsValid()) return true;
691 if (type == theAddr.type)
692 {
693 const char* ptr1 = GetRawHostAddress();
694 const char* ptr2 = theAddr.GetRawHostAddress();
695 size_t nbyte = prefixLen >> 3;
696 if ((0 == nbyte) || (0 == memcmp(ptr1, ptr2, nbyte)))
697 {
698 UINT8 nbit = prefixLen & 0x07;
699 if (0 == nbit) return true;
700 char mask = 0xff << (8 - nbit);
701 if ((mask & ptr1[nbyte]) == (mask & ptr2[nbyte]))
702 return true;
703 }
704 }
705 return false;
706 } // end ProtoAddress::PrefixIsEqual()
707
708
709 UINT8 ProtoAddress::GetPrefixLength() const
710 {
711 UINT8* ptr = NULL;
712 UINT8 maxBytes = 0;
713 switch (type)
714 {
715 case IPv4:
716 ptr = ((UINT8*)&((struct sockaddr_in*)&addr)->sin_addr);
717 maxBytes = 4;
718 break;
719 #ifdef HAVE_IPV6
720 case IPv6:
721 ptr = ((UINT8*)&((struct sockaddr_in6*)&addr)->sin6_addr);
722 maxBytes = 16;
723 break;
724 #endif // HAVE_IPV6
725 #ifdef SIMULATE
726 case SIM:
727 ptr = ((UINT8*)&((struct sockaddr_sim*)&addr)->addr);
728 maxBytes = sizeof(SIMADDR);
729 break;
730 #endif // SIMULATE
731 case ETH:
732 default:
733 PLOG(PL_ERROR, "ProtoAddress::PrefixLength() Invalid address type of %d!\n",type);
734 return 0;
735 }
736 UINT8 prefixLen = 0;
737 for (UINT8 i = 0; i < maxBytes; i++)
738 {
739 if (0xff == *ptr)
740 {
741 prefixLen += 8;
742 ptr++;
743 }
744 else
745 {
746 UINT8 bit = 0x80;
747 while (0 != (bit & *ptr))
748 {
749 bit >>= 1;
750 prefixLen += 1;
751 }
752 break;
753 }
754 }
755 return prefixLen;
756 } // end ProtoAddress::GetPrefixLength()
757
758 void ProtoAddress::GeneratePrefixMask(ProtoAddress::Type type, UINT8 prefixLen)
759 {
760 unsigned char* ptr;
761 switch (type)
762 {
763 case IPv4:
764 ptr = ((unsigned char*)&((struct sockaddr_in*)&addr)->sin_addr);
765 break;
766 #ifdef HAVE_IPV6
767 case IPv6:
768 ptr = ((unsigned char*)&((struct sockaddr_in6*)&addr)->sin6_addr);
769 break;
770 #endif // HAVE_IPV6
771 case ETH:
772 ptr = ((unsigned char*)&addr);
773 break;
774 #ifdef SIMULATE
775 case SIM:
776 ptr = ((unsigned char*)&((struct sockaddr_sim*)&addr)->addr);
777 break;
778 #endif // SIMULATE
779 default:
780 PLOG(PL_ERROR, "ProtoAddress::GeneratePrefixMask() Invalid address type!\n");
781 return ;
782 }
783 Reset(type, true); // init to zero
784 if (prefixLen > GetLength())
785 prefixLen = GetLength();
786 while (0 != prefixLen)
787 {
788 if (prefixLen < 8)
789 {
790 *ptr = 0xff << (8 - prefixLen);
791 return;
792 }
793 else
794 {
795 *ptr++ = 0xff;
796 prefixLen -= 8;
797 }
798 }
799 } // end ProtoAddress::GeneratePrefixMask()
800
801 void ProtoAddress::ApplyPrefixMask(UINT8 prefixLen)
802 {
803 UINT8* ptr = NULL;
804 UINT8 maxLen = 0;
805 switch (type)
806 {
807 case IPv4:
808 ptr = ((UINT8*)&((struct sockaddr_in*)&addr)->sin_addr);
809 maxLen = 32;
810 break;
811 #ifdef HAVE_IPV6
812 case IPv6:
813 ptr = ((UINT8*)&((struct sockaddr_in6*)&addr)->sin6_addr);
814 maxLen = 128;
815 break;
816 #endif // HAVE_IPV6
817 #ifdef SIMULATE
818 case SIM:
819 ptr = ((UINT8*)&((struct sockaddr_sim*)&addr)->addr);
820 maxLen = sizeof(SIMADDR) << 3;
821 break;
822 #endif // SIMULATE
823 case ETH:
824 default:
825 PLOG(PL_ERROR, "ProtoAddress::ApplyPrefixMask() Invalid address type!\n");
826 return;
827 }
828 if (prefixLen >= maxLen) return;
829 UINT8 nbytes = prefixLen >> 3;
830 UINT8 remainder = prefixLen & 0x07;
831 if (remainder)
832 {
833 ptr[nbytes] &= (UINT8)(0x00ff << (8 - remainder));
834 nbytes++;
835 }
836 memset(ptr + nbytes, 0, length - nbytes);
837 } // end ProtoAddress::ApplyPrefixMask()
838
839 void ProtoAddress::ApplySuffixMask(UINT8 suffixLen)
840 {
841 UINT8* ptr = NULL;
842 UINT8 maxLen = 0;
843 switch (type)
844 {
845 case IPv4:
846 ptr = ((UINT8*)&((struct sockaddr_in*)&addr)->sin_addr);
847 maxLen = 32;
848 break;
849 #ifdef HAVE_IPV6
850 case IPv6:
851 ptr = ((UINT8*)&((struct sockaddr_in6*)&addr)->sin6_addr);
852 maxLen = 128;
853 break;
854 #endif // HAVE_IPV6
855 #ifdef SIMULATE
856 case SIM:
857 ptr = ((UINT8*)&((struct sockaddr_sim*)&addr)->addr);
858 maxLen = sizeof(SIMADDR) << 3;
859 break;
860 #endif // SIMULATE
861 case ETH:
862 default:
863 PLOG(PL_ERROR, "ProtoAddress::ApplyPrefixMask() Invalid address type!\n");
864 return;
865 }
866 if (suffixLen >= maxLen) return;
867 UINT8 nbytes = suffixLen >> 3;
868 UINT8 remainder = suffixLen & 0x07;
869 if (remainder)
870 {
871 ptr[(maxLen >> 3)-nbytes-1] &= (UINT8)(0x00ff >> (8-remainder));
872 nbytes++;
873 }
874 memset(ptr, 0, length - nbytes);
875 }
876 void ProtoAddress::GetSubnetAddress(UINT8 prefixLen,
877 ProtoAddress& subnetAddr) const
878 {
879 subnetAddr = *this;
880 UINT8* ptr = NULL;
881 UINT8 maxLen = 0;
882 switch (type)
883 {
884 case IPv4:
885 ptr = ((UINT8*)&((struct sockaddr_in*)&subnetAddr.addr)->sin_addr);
886 maxLen = 32;
887 break;
888 #ifdef HAVE_IPV6
889 case IPv6:
890 ptr = ((UINT8*)&((struct sockaddr_in6*)&subnetAddr.addr)->sin6_addr);
891 maxLen = 128;
892 break;
893 #endif // HAVE_IPV6
894 case ETH:
895 return;
896 #ifdef SIMULATE
897 case SIM:
898 ptr = ((UINT8*)&((struct sockaddr_sim*)&subnetAddr.addr)->addr);
899 maxLen = sizeof(SIMADDR) << 3;
900 break;
901 #endif // SIMULATE
902 default:
903 PLOG(PL_ERROR, "ProtoAddress::GetSubnetAddress() Invalid address type!\n");
904 return;
905 }
906 if (prefixLen >= maxLen) return;
907 UINT8 nbytes = prefixLen >> 3;
908 UINT8 remainder = prefixLen & 0x07;
909 if (remainder)
910 {
911 ptr[nbytes] &= (UINT8)(0xff << (8 - remainder));
912 nbytes++;
913 }
914 memset(ptr + nbytes, 0, length - nbytes);
915 } // end ProtoAddress::GetSubnetAddress()
916
917 bool ProtoAddress::Increment()
918 {
919 if (!IsValid())
920 {
921 PLOG(PL_ERROR, "ProtoAddress::Increment() error: invalid address\n");
922 return false;
923 }
924 int index = GetLength() - 1;
925 UINT8* byte = (UINT8*)AccessRawHostAddress();
926 while (index >= 0)
927 {
928 if (255 != byte[index])
929 {
930 byte[index] += 1;
931 return true;
932 }
933 byte[index--] = 0;
934 }
935 return false;
936 } // end ProtoAddress::Increment()
937
938
939 void ProtoAddress::GetBroadcastAddress(UINT8 prefixLen,
940 ProtoAddress& broadcastAddr) const
941 {
942 broadcastAddr = *this;
943 UINT8* ptr = NULL;
944 UINT8 maxLen = 0;
945 switch (type)
946 {
947 case IPv4:
948 ptr = ((UINT8*)&((struct sockaddr_in*)&broadcastAddr.addr)->sin_addr);
949 maxLen = 32;
950 break;
951 #ifdef HAVE_IPV6
952 case IPv6:
953 ptr = ((UINT8*)&((struct sockaddr_in6*)&broadcastAddr.addr)->sin6_addr);
954 maxLen = 128;
955 break;
956 #endif // HAVE_IPV6
957 case ETH:
958 ptr = (UINT8*)&broadcastAddr.addr;
959 maxLen = 48;
960 prefixLen = 0;
961 break;
962 #ifdef SIMULATE
963 case SIM:
964 ptr = ((UINT8*)&((struct sockaddr_sim*)&broadcastAddr.addr)->addr);
965 maxLen = sizeof(SIMADDR) << 3;
966 break;
967 #endif // SIMULATE
968 default:
969 PLOG(PL_ERROR, "ProtoAddress::GetBroadcastAddress() Invalid address type!\n");
970 return;
971 }
972 if (prefixLen >= maxLen) return;
973 UINT8 nbytes = prefixLen >> 3;
974 UINT8 remainder = prefixLen & 0x07;
975 if (remainder)
976 {
977 ptr[nbytes] |= (0x00ff >> remainder);
978 nbytes++;
979 }
980 memset(ptr + nbytes, 0xff, length - nbytes);
981 } // end ProtoAddress::GetBroadcastAddress()
982
983 ProtoAddress& ProtoAddress::GetEthernetMulticastAddress(const ProtoAddress& ipMcastAddr)
984 {
985 if (!ipMcastAddr.IsMulticast())
986 {
987 Invalidate();
988 return *this;
989 }
990 // Ethernet mcast addr begins with 00:00:5e ...
991 UINT8 ethMcastAddr[6];
992 const UINT8* ipAddrPtr;
993 switch (ipMcastAddr.GetType())
994 {
995 // Point to lower 24-bits of IP mcast address
996 case IPv4:
997 ethMcastAddr[0] = 0x01;
998 ethMcastAddr[1] = 0x00;
999 ethMcastAddr[2] = 0x5e;
1000 ipAddrPtr = (const UINT8*)(ipMcastAddr.GetRawHostAddress() + 1);
1001 ethMcastAddr[3] = (0x7f & ipAddrPtr[0]);
1002 ethMcastAddr[4] = ipAddrPtr[1];
1003 ethMcastAddr[5] = ipAddrPtr[2];
1004 break;
1005 case IPv6:
1006 ethMcastAddr[0] = 0x33;
1007 ethMcastAddr[1] = 0x33;
1008 ipAddrPtr = (const UINT8*)(ipMcastAddr.GetRawHostAddress() + 12);
1009 ethMcastAddr[2] = ipAddrPtr[0];
1010 ethMcastAddr[3] = ipAddrPtr[1];
1011 ethMcastAddr[4] = ipAddrPtr[2];
1012 ethMcastAddr[5] = ipAddrPtr[3];
1013 break;
1014 default:
1015 PLOG(PL_ERROR, "ProtoAddress::GetEthernetMulticastAddress() error : non-IP address!\n");
1016 Invalidate();
1017 return *this;
1018 }
1019 SetRawHostAddress(ETH, (char*)ethMcastAddr, 6);
1020 return *this;
1021 } // end ProtoAddress::GetEthernetMulticastAddress()
1022
1023 void ProtoAddress::SetEndIdentifier(UINT32 endIdentifier)
1024 {
1025 endIdentifier = htonl(endIdentifier);
1026 switch(type)
1027 {
1028 case IPv4:
1029 SetRawHostAddress(IPv4, (char*)&endIdentifier, 4);
1030 break;
1031 #ifdef HAVE_IPV6
1032 case IPv6:
1033 // Set lowest 4 bytes to endIdentifier
1034 memcpy(((char*)&(((struct sockaddr_in6&)addr).sin6_addr))+12, &endIdentifier, 4);
1035 #endif // HAVE_IPV6
1036 break;
1037 case ETH:
1038 {
1039 UINT8 vendorHash;
1040 memcpy(&vendorHash, (char*)&endIdentifier, 1);
1041 UINT8* addrPtr = (UINT8*)&addr;
1042 addrPtr[0] = addrPtr[1] = addrPtr[2] = vendorHash;
1043 memcpy(addrPtr+3, (((char*)&endIdentifier)+1), 3);
1044 break;
1045 }
1046 #ifdef SIMULATE
1047 case SIM:
1048 ((struct sockaddr_sim*)&addr)->addr = endIdentifier;
1049 break;
1050 #endif // SIMULATE
1051 default:
1052 SetRawHostAddress(IPv4, (char*)&endIdentifier, 4);
1053 break;
1054 }
1055 } // end ProtoAddress::SetEndIdentifier()
1056
1057 UINT32 ProtoAddress::GetEndIdentifier() const
1058 {
1059 switch(type)
1060 {
1061 case IPv4:
1062 {
1063 return ntohl(((struct sockaddr_in*)&addr)->sin_addr.s_addr);
1064
1065 }
1066 #ifdef HAVE_IPV6
1067 case IPv6:
1068 {
1069 return ntohl(IN6_V4MAPPED_ADDR(&(((struct sockaddr_in6*)&addr)->sin6_addr)));
1070 }
1071 #endif // HAVE_IPV6
1072 case ETH:
1073 {
1074 // a dumb little hash: MSB is randomized vendor id, 3 LSB's is device id
1075 UINT8* addrPtr = (UINT8*)&addr;
1076 UINT8 vendorHash = addrPtr[0] ^ addrPtr[1] ^ addrPtr[2];
1077 UINT32 temp32;
1078 memcpy((char*)&temp32, &vendorHash, 1);
1079 memcpy((((char*)&temp32)+1), addrPtr+3, 3);
1080 return ntohl(temp32);
1081 }
1082 #ifdef SIMULATE
1083 case SIM:
1084 return ((UINT32)((struct sockaddr_sim*)&addr)->addr);
1085 #endif // SIMULATE
1086 default:
1087 PLOG(PL_ERROR, "ProtoAddress::GetEndIdentifier(): Invalid address type!\n");
1088 return INADDR_NONE;
1089 }
1090 } // end ProtoAddress:GetEndIdentifier()
1091
1092 bool ProtoAddress::HostIsEqual(const ProtoAddress& theAddr) const
1093 {
1094 if (!IsValid() && !theAddr.IsValid()) return true;
1095 switch(type)
1096 {
1097 case IPv4:
1098 {
1099 struct in_addr myAddrIn = ((struct sockaddr_in *)&addr)->sin_addr;
1100 struct in_addr theAddrIn = ((struct sockaddr_in *)&(theAddr.addr))->sin_addr;
1101 if ((IPv4 == theAddr.type) &&
1102 (myAddrIn.s_addr == theAddrIn.s_addr))
1103 return true;
1104 else
1105 return false;
1106 }
1107 #ifdef HAVE_IPV6
1108 case IPv6:
1109 if ((IPv6 == theAddr.type) &&
1110 (0 == memcmp(((struct sockaddr_in6*)&addr)->sin6_addr.s6_addr,
1111 ((struct sockaddr_in6*)&(theAddr.addr))->sin6_addr.s6_addr,
1112 4*sizeof(UINT32))))
1113 return true;
1114 else
1115 return false;
1116 #endif // HAVE_IPV6
1117 case ETH:
1118 if ((ETH == theAddr.type) &&
1119 0 == memcmp((char*)&addr, (char*)&theAddr.addr, 6))
1120 return true;
1121 else
1122 return false;
1123 #ifdef SIMULATE
1124 case SIM:
1125 if ((SIM == theAddr.type) &&
1126 (((struct sockaddr_sim*)&addr)->addr ==
1127 ((struct sockaddr_sim*)&(theAddr.addr))->addr))
1128 return true;
1129 else
1130 return false;
1131 #endif // SIMULATE
1132
1133 default:
1134 PLOG(PL_ERROR, "ProtoAddress::HostIsEqual(): Invalid address type!\n");
1135 return false;
1136 }
1137 } // end ProtoAddress::HostIsEqual()
1138
1139 int ProtoAddress::CompareHostAddr(const ProtoAddress& theAddr) const
1140 {
1141 switch(type)
1142 {
1143 case IPv4:
1144 return memcmp(&((struct sockaddr_in *)&addr)->sin_addr,
1145 &((struct sockaddr_in *)&theAddr.addr)->sin_addr,
1146 4);
1147 #ifdef HAVE_IPV6
1148 case IPv6:
1149 return memcmp(&((struct sockaddr_in6*)&addr)->sin6_addr,
1150 &((struct sockaddr_in6*)&theAddr.addr)->sin6_addr,
1151 16);
1152 #endif // HAVE_IPV6
1153 case ETH:
1154 return memcmp((char*)&addr, (char*)&theAddr.addr, 6);
1155 #ifdef SIMULATE
1156 case SIM:
1157 {
1158 SIMADDR addr1 = ((struct sockaddr_sim*)&addr)->addr;
1159 SIMADDR addr2 = ((struct sockaddr_sim*)&(theAddr.addr))->addr;
1160 if (addr1 < addr2)
1161 return -1;
1162 else if (addr1 > addr2)
1163 return 1;
1164 else
1165 return 0;
1166 }
1167 #endif // SIMULATE
1168 default:
1169 PLOG(PL_ERROR, "ProtoAddress: CompareHostAddr(): Invalid address type!\n");
1170 return -1;
1171 }
1172 } // end ProtoAddress::CompareHostAddress()
1173
1174 bool ProtoAddress::ResolveEthFromString(const char* text)
1175 {
1176 unsigned int a[6];
1177 char b[6];
1178 if (6 != sscanf(text, "%x:%x:%x:%x:%x:%x", &a[0], &a[1], &a[2], &a[3], &a[4], &a[5]))
1179 {
1180 PLOG(PL_DEBUG, "ProtoAddress: ResolveEthFromString(%s): Invalid ETH address type!\n", text);
1181 return false;
1182 }
1183 for (int i=0;i<=5;i++)
1184 b[i] = (char) a[i];
1185 SetRawHostAddress(ETH, b, 6);
1186 return true;
1187 } // end ProtoAddress::ResolveEthFromString()
1188
1189 // non-DNS (i.e numeric address notation)
1190 bool ProtoAddress::ConvertFromString(const char* text)
1191 {
1192 #ifdef SIMULATE
1193 return ResolveFromString(text);
1194 #else
1195 // inet_pton not available below Vista
1196 #ifdef WIN32
1197 // Initialize the address family
1198 // Startup WinSock for name lookup
1199 if (!Win32Startup())
1200 {
1201 PLOG(PL_ERROR, "ProtoAddress: GetHostString(): Error initializing WinSock!\n");
1202 return NULL;
1203 }
1204 struct sockaddr_in sa = (struct sockaddr_in&)addr;
1205 sa.sin_family = AF_INET;
1206 int addrSize = sizeof(struct sockaddr_storage);
1207
1208 #ifdef _UNICODE
1209 WCHAR theString[256];
1210 mbstowcs(theString, text, 255);
1211 #else
1212 const char* theString = text;
1213 #endif // if/else _UNICODE
1214
1215 if (0 == WSAStringToAddress((LPTSTR)theString, AF_INET, NULL,(LPSOCKADDR)&sa,&addrSize))
1216 {
1217 addr = (struct sockaddr_storage&)sa;
1218 length = 4;
1219 Win32Cleanup();
1220 return true;
1221 }
1222
1223 // See if it's an ipv6 address
1224 struct sockaddr_in6 sa6 = (struct sockaddr_in6&)addr;
1225 sa6.sin6_family = AF_INET6;
1226 addrSize = sizeof(struct sockaddr_storage);
1227
1228 if (0 == WSAStringToAddress((LPTSTR)theString, AF_INET6, NULL,(LPSOCKADDR)&sa6,&addrSize))
1229 {
1230 addr = (struct sockaddr_storage&)sa6;
1231 type = IPv6;
1232 length = 16;
1233 Win32Cleanup();
1234 return true;
1235 }
1236 Win32Cleanup();
1237 // Finally, see if it's an Ethertype addr string
1238 return ResolveEthFromString(text);
1239 #else
1240 // First try for IPv4 addr
1241 struct sockaddr_in sa;
1242 if (1 == inet_pton(AF_INET, text, &sa.sin_addr))
1243 {
1244 sa.sin_family = AF_INET;
1245 return SetSockAddr((struct sockaddr&)sa);
1246 }
1247 // Next try for an IPv6 addr
1248 struct sockaddr_in6 sa6;
1249 if (1 == inet_pton(AF_INET6, text, &sa6.sin6_addr))
1250 {
1251 sa6.sin6_family = AF_INET6;
1252 return SetSockAddr((struct sockaddr&)sa6);
1253 }
1254 // Finally, see if it's an Ethertype addr string
1255 return ResolveEthFromString(text);
1256 #endif // if/else WIN32
1257 #endif // if/else SIMULATE
1258 } // end ProtoAddress::ConvertFromString()
1259
1260 // (TBD) Provide a mechanism for async lookup with optional user interaction
1261 bool ProtoAddress::ResolveFromString(const char* text)
1262 {
1263 UINT16 thePort = GetPort();
1264 #ifdef SIMULATE
1265 // Assume no DNS for simulations
1266 SIMADDR theAddr;
1267 #ifndef OPNET // JPH 2/8/06
1268 if (1 == sscanf(text, "%i", &theAddr))
1269 #else
1270 if (theAddr = ip_address_create(text))
1271 #endif // OPNET
1272 {
1273 ((struct sockaddr_sim*)&addr)->addr = theAddr;
1274 type = SIM;
1275 length = sizeof(SIMADDR);
1276 SetPort(thePort); // restore port number
1277 return true;
1278 }
1279 else
1280 {
1281 PLOG(PL_ERROR, "ProtoAddress::ResolveFromString() Invalid simulator address: \"%s\"\n", text);
1282 return false;
1283 }
1284 #else
1285 // Use DNS to look it up
1286 // Get host address, looking up by hostname if necessary
1287 #ifdef WIN32
1288 // Startup WinSock for name lookup
1289 if (!Win32Startup())
1290 {
1291 PLOG(PL_ERROR, "ProtoAddress::ResolveFromString() Error initializing WinSock!\n");
1292 return false;
1293 }
1294 #endif //WIN32
1295 #if defined(HAVE_IPV6)// Try to get address using getaddrinfo()
1296 struct addrinfo* addrInfoPtr = NULL;
1297 if(0 == getaddrinfo(text, NULL, NULL, &addrInfoPtr))
1298 {
1299 #ifdef WIN32
1300 Win32Cleanup();
1301 #endif // WIN32
1302 struct addrinfo* ptr = addrInfoPtr;
1303 bool result = false;
1304 //while (NULL != ptr) // We just use the first addr returned for now
1305 {
1306 if (ptr->ai_family == PF_INET)
1307 {
1308 SetSockAddr(*(ptr->ai_addr));
1309 type = IPv4;
1310 length = 4; // IPv4 host addresses are always 4 bytes in length
1311 result = true;
1312 }
1313 else if (ptr->ai_family == PF_INET6)
1314 {
1315 SetSockAddr(*(ptr->ai_addr));
1316 type = IPv6;
1317 length = 16; // IPv6 host addresses are always 16 bytes in length
1318 result = true;
1319 }
1320 else
1321 {
1322 PLOG(PL_ERROR, "ProtoAddress::ResolveFromString() getaddrinfo() returned unsupported address family!\n");
1323 }
1324 ptr = ptr->ai_next;
1325 } // end while
1326 freeaddrinfo(addrInfoPtr);
1327 SetPort(thePort); // restore port number
1328 return result;
1329 }
1330 else
1331 {
1332 if (NULL != addrInfoPtr) freeaddrinfo(addrInfoPtr);
1333 PLOG(PL_WARN, "ProtoAddress::ResolveFromString() getaddrinfo() error: %s\n", GetErrorString());
1334 #ifdef WIN32
1335 // on WinNT 4.0, getaddrinfo() doesn't work, so we check the OS version
1336 // to decide what to do. Try "gethostbyaddr()" if it's an old OS (e.g. NT 4.0 or earlier)
1337 OSVERSIONINFO vinfo;
1338 vinfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
1339 GetVersionEx(&vinfo);
1340 if ((VER_PLATFORM_WIN32_NT == vinfo.dwPlatformId) &&
1341 ((vinfo.dwMajorVersion > 4) ||
1342 ((vinfo.dwMajorVersion == 4) && (vinfo.dwMinorVersion > 0))))
1343 return false; // it's a modern OS where getaddrinfo() should work!
1344 #else
1345 return false;
1346 #endif // if/else WIN32/UNIX
1347 }
1348 #endif // HAVE_IPV6
1349 #if defined(WIN32) || !defined(HAVE_IPV6)
1350 // Use this approach as a backup for NT-4 or if !HAVE_IPV6
1351 // 1) is it a "dotted decimal" address?
1352 struct sockaddr_in* addrPtr = (struct sockaddr_in*)&addr;
1353 if (INADDR_NONE != (addrPtr->sin_addr.s_addr = inet_addr(text)))
1354 {
1355 addrPtr->sin_family = AF_INET;
1356 }
1357 else
1358 {
1359 // 2) Use "gethostbyname()" to lookup IPv4 address
1360 struct hostent *hp = gethostbyname(text);
1361 #ifdef WIN32
1362 Win32Cleanup();
1363 #endif // WIN32
1364 if(hp)
1365 {
1366 addrPtr->sin_family = hp->h_addrtype;
1367 #if defined(_SOCKLEN_T) || defined(_SOCKLEN_T_DECLARED) // for BSD systems
1368 addrPtr->sin_len = hp->h_length;
1369 #endif // defined(_SOCKLENT_T) || defined(_SOCKLEN_T_DECLARED)
1370 memcpy((char*)&addrPtr->sin_addr, hp->h_addr, hp->h_length);
1371 }
1372 else
1373 {
1374 PLOG(PL_WARN, "ProtoAddress::ResolveFromString() gethostbyname() error: %s\n",
1375 GetErrorString());
1376 return false;
1377 }
1378 }
1379 if (addrPtr->sin_family == AF_INET)
1380 {
1381 type = IPv4;
1382 length = 4; // IPv4 addresses are always 4 bytes in length
1383 SetPort(thePort); // restore port number
1384 return true;
1385 }
1386 else
1387 {
1388 PLOG(PL_ERROR, "ProtoAddress::ResolveFromString gethostbyname() returned unsupported address family!\n");
1389 return false;
1390 }
1391 #endif // WIN32 || !HAVE_IPV6
1392 #endif // !SIMULATE
1393
1394 } // end ProtoAddress::ResolveFromString()
1395 #ifdef USE_GETHOSTBYADDR
1396 bool ProtoAddress::ResolveToName(char* buffer, unsigned int buflen) const
1397 {
1398 #ifdef WIN32
1399 if (!Win32Startup())
1400 {
1401 PLOG(PL_ERROR, "ProtoAddress::ResolveToName() Error initializing WinSock!\n");
1402 GetHostString(buffer, buflen);
1403 return false;
1404 }
1405 #endif // WIN32
1406 struct hostent* hp = NULL;
1407 switch (type)
1408 {
1409 case IPv4:
1410 hp = gethostbyaddr((char*)&(((struct sockaddr_in*)&addr)->sin_addr),
1411 4, AF_INET);
1412 break;
1413 #ifdef HAVE_IPV6
1414 case IPv6:
1415 hp = gethostbyaddr((char*)&(((struct sockaddr_in*)&addr)->sin_addr),
1416 16, AF_INET6);
1417 break;
1418 #endif // HAVE_IPV6
1419 #ifdef SIMULATE
1420 case SIM:
1421 GetHostString(buffer, buflen);
1422 return true;
1423 #endif // SIMULATE
1424 case ETH:
1425 GetHostString(buffer, buflen);
1426 return true;
1427 default:
1428 PLOG(PL_ERROR, "ProtoAddress::ResolveToName(): Invalid address type!\n");
1429 return false;
1430 } // end switch(type)
1431 #ifdef WIN32
1432 Win32Cleanup();
1433 #endif // WIN32
1434
1435 if (hp)
1436 {
1437 // Use the hp->h_name hostname by default
1438 size_t nameLen = 0;
1439 unsigned int dotCount = 0;
1440 strncpy(buffer, hp->h_name, buflen);
1441 nameLen = strlen(hp->h_name);
1442 nameLen = nameLen < buflen ? nameLen : buflen;
1443 const char* ptr = hp->h_name;
1444 while ((ptr = strchr(ptr, '.')))
1445 {
1446 ptr++;
1447 dotCount++;
1448 }
1449
1450 char** alias = hp->h_aliases;
1451 // Use first alias by default
1452 if (alias && *alias && buffer)
1453 {
1454 // Try to find the fully-qualified name
1455 // (longest alias with most '.')
1456 while (NULL != *alias)
1457 {
1458 unsigned int dc = 0;
1459 ptr = *alias;
1460 bool isArpa = false;
1461 while (NULL != (ptr = strchr(ptr, '.')))
1462 {
1463 ptr++;
1464 // don't let ".arpa" aliases override
1465 isArpa = (0 == strcmp(ptr, "arpa"));
1466 dc++;
1467 }
1468 size_t alen = strlen(*alias);
1469 bool override = (dc > dotCount) ||
1470 ((dc == dotCount) && (alen >nameLen));
1471 if (isArpa) override = false;
1472 if (override)
1473 {
1474 strncpy(buffer, *alias, buflen);
1475 nameLen = alen;
1476 dotCount = dc;
1477 nameLen = nameLen < buflen ? nameLen : buflen;
1478 }
1479 alias++;
1480 }
1481 }
1482 return true;
1483 }
1484 else
1485 {
1486 PLOG(PL_WARN, "ProtoAddress::ResolveToName() gethostbyaddr() error: %s\n",
1487 GetErrorString());
1488 GetHostString(buffer, buflen);
1489 return false;
1490 }
1491 } // end ProtoAddress::ResolveToName()
1492
1493 #else // Use newer getnameinfo rather than legacy gethostbyaddr
1494 bool ProtoAddress::ResolveToName(char* buffer, unsigned int buflen) const
1495 {
1496 #ifdef WIN32
1497 if (!Win32Startup())
1498 {
1499 PLOG(PL_ERROR, "ProtoAddress::ResolveToName() Error initializing WinSock!\n");
1500 GetHostString(buffer, buflen);
1501 return false;
1502 }
1503 DWORD retval = 0;
1504 #else // WIN32
1505 int retval = 0;
1506 #endif // endif WIN32
1507 switch (type)
1508 {
1509 case IPv4:
1510 case IPv6:
1511 retval = getnameinfo((struct sockaddr *) &addr,
1512 sizeof(addr),
1513 buffer,
1514 buflen,NULL,0,NI_NAMEREQD);
1515 break;
1516 #ifdef SIMULATE
1517 case SIM:
1518 GetHostString(buffer, buflen);
1519 return true;
1520 #endif // SIMULATE
1521 case ETH:
1522 GetHostString(buffer, buflen);
1523 return true;
1524 default:
1525 PLOG(PL_ERROR, "ProtoAddress::ResolveToName(): Invalid address type!\n");
1526 return false;
1527 } // end switch(type)
1528 #ifdef WIN32
1529 Win32Cleanup();
1530 #endif // WIN32
1531 if (retval != 0)
1532 {
1533 PLOG(PL_ERROR, "ProtoAddress::ResolveToName() error: %s\n", gai_strerror(retval));
1534 return false;
1535 }
1536
1537 return true;
1538 } // end ProtoAddress::ResolveToName()
1539 #endif // endif USE_GETHOSTBYADDR
1540
1541 bool ProtoAddress::ResolveLocalAddress(char* buffer, unsigned int buflen)
1542 {
1543 UINT16 thePort = GetPort(); // save port number
1544 // Try to get fully qualified host name if possible
1545 char hostName[256];
1546 hostName[0] = '\0';
1547 hostName[255] = '\0';
1548 #ifdef WIN32
1549 if (!Win32Startup())
1550 {
1551 PLOG(PL_ERROR, "ProtoAddress::ResolveLocalAddress() error startup WinSock!\n");
1552 return false;
1553 }
1554 #endif // WIN32
1555 int result = gethostname(hostName, 255);
1556 #ifdef WIN32
1557 Win32Cleanup();
1558 #endif // WIN32
1559 if (result)
1560 {
1561 PLOG(PL_ERROR, "ProtoAddress::ResolveLocalAddress(): gethostname() error: %s\n", GetErrorString());
1562 return false;
1563 }
1564 else
1565 {
1566 // Terminate at first '.' in name, if any (e.g. MacOS .local)
1567 char* dotPtr = strchr(hostName, '.');
1568 if (NULL != dotPtr) *dotPtr = '\0';
1569 bool lookupOK = ResolveFromString(hostName);
1570 if (lookupOK)
1571 {
1572 // Invoke ResolveToName() to get fully qualified name and use that address
1573 ResolveToName(hostName, 255);
1574 lookupOK = ResolveFromString(hostName);
1575 }
1576 if (!lookupOK || IsLoopback())
1577 {
1578 // darn it! lookup failed or we got the loopback address ...
1579 // So, try to troll interfaces for a decent address
1580 // using our handy-dandy ProtoSocket::GetInterfaceInfo routines
1581 gethostname(hostName, 255);
1582 if (!lookupOK)
1583 {
1584 // Set IPv4 loopback address as fallback id if no good address is found
1585 UINT32 loopbackAddr = htonl(0x7f000001);
1586 SetRawHostAddress(IPv4, (char*)&loopbackAddr, 4);
1587 }
1588
1589 // Use "ProtoSocket::FindLocalAddress()" that trolls through network interfaces
1590 // looking for an interface with a non-loopback address assigned.
1591 if (!ProtoSocket::FindLocalAddress(IPv4, *this))
1592 {
1593 #ifdef HAVE_IPV6
1594 // Try IPv6 if IPv4 wasn't assigned
1595 if (!ProtoSocket::FindLocalAddress(IPv6, *this))
1596 {
1597 PLOG(PL_WARN, "ProtoAddress::ResolveLocalAddress() warning: no assigned addresses found\n");
1598 }
1599 #endif // HAVE_IPV6
1600 }
1601 if (IsLoopback() || IsUnspecified())
1602 PLOG(PL_ERROR, "ProtoAddress::ResolveLocalAddress() warning: only loopback address found!\n");
1603 }
1604 SetPort(thePort); // restore port number
1605 buflen = buflen < 255 ? buflen : 255;
1606 if (buffer) strncpy(buffer, hostName, buflen);
1607 return true;
1608 }
1609 } // end ProtoAddress::ResolveLocalAddress()
1610
1611
1612 ProtoAddressList::ProtoAddressList()
1613 {
1614 }
1615
1616 ProtoAddressList::~ProtoAddressList()
1617 {
1618 Destroy();
1619 }
1620
1621 void ProtoAddressList::Destroy()
1622 {
1623 Item* entry;
1624 while (NULL != (entry = static_cast<Item*>(addr_tree.GetRoot())))
1625 {
1626 addr_tree.Remove(*entry);
1627 delete entry;
1628 }
1629 } // end ProtoAddressList::Destroy()
1630
1631 bool ProtoAddressList::Insert(const ProtoAddress& theAddress, const void* userData)
1632 {
1633 if (!theAddress.IsValid())
1634 {
1635 PLOG(PL_ERROR, "ProtoAddressList::Insert() error: invalid address\n");
1636 return false;
1637 }
1638 Item* entry = static_cast<Item*>(addr_tree.Find(theAddress.GetRawHostAddress(), theAddress.GetLength() << 3));
1639 if (NULL != entry)
1640 {
1641 // Just update user data
1642 entry->SetUserData(userData);
1643 }
1644 else
1645 {
1646 Item* entry = new Item(theAddress, userData);
1647 if (NULL == entry)
1648 {
1649 PLOG(PL_ERROR, "ProtoAddressList::Insert() new ProtoTree::Item error: %s\n", GetErrorString());
1650 return false;
1651 }
1652 addr_tree.Insert(*entry);
1653 }
1654 return true;
1655 } // end ProtoAddressList::Insert()
1656
1657 void ProtoAddressList::Remove(const ProtoAddress& addr)
1658 {
1659 Item* entry = static_cast<Item*>(addr_tree.Find(addr.GetRawHostAddress(), addr.GetLength() << 3));
1660 if (NULL != entry)
1661 {
1662 addr_tree.Remove(*entry);
1663 delete entry;
1664 }
1665 } // end ProtoAddressList::Remove()
1666
1667 bool ProtoAddressList::AddList(ProtoAddressList& addrList)
1668 {
1669 ProtoAddressList::Iterator iterator(addrList);
1670 ProtoAddress addr;
1671 while (iterator.GetNextAddress(addr))
1672 {
1673 if (!Insert(addr)) return false;
1674 }
1675 return true;
1676 } // end ProtoAddressList::AddList()
1677
1678 void ProtoAddressList::RemoveList(ProtoAddressList& addrList)
1679 {
1680 ProtoAddressList::Iterator iterator(addrList);
1681 ProtoAddress addr;
1682 while (iterator.GetNextAddress(addr))
1683 Remove(addr);
1684 } // end ProtoAddressList::RemoveList()
1685
1686
1687 // Returns the root of the addr_tree
1688 bool ProtoAddressList::GetFirstAddress(ProtoAddress& firstAddr) const
1689 {
1690 Item* rootItem = static_cast<Item*>(addr_tree.GetRoot());
1691 if (NULL != rootItem)
1692 {
1693 firstAddr = rootItem->GetAddress();
1694 return true;
1695 }
1696 else
1697 {
1698 firstAddr.Invalidate();
1699 return false;
1700 }
1701 } // end ProtoAddressList::GetFirstAddress()
1702
1703
1704 /*
1705 ProtoAddressList::Item* ProtoAddressList::GetFirstItem()
1706 {
1707 Item* rootItem = static_cast<Item*>(addr_tree.GetRoot());
1708 return rootItem;
1709 } // end ProtoAddressList::GetFirstItem()
1710 */
1711
1712
1713 ProtoAddressList::Item::Item(const ProtoAddress& theAddr, const void* userData)
1714 : addr(theAddr), user_data(userData)
1715 {
1716 }
1717
1718 ProtoAddressList::Item::~Item()
1719 {
1720 }
1721
1722
1723 ProtoAddressList::Iterator::Iterator(ProtoAddressList& addrList)
1724 : ptree_iterator(addrList.addr_tree)
1725 {
1726 }
1727
1728 ProtoAddressList::Iterator::~Iterator()
1729 {
1730 }
1731
1732 bool ProtoAddressList::Iterator::GetNextAddress(ProtoAddress& nextAddr)
1733 {
1734 Item* nextItem = static_cast<Item*>(ptree_iterator.GetNextItem());
1735 if (NULL != nextItem)
1736 {
1737 nextAddr = nextItem->GetAddress();
1738 return true;
1739 }
1740 else
1741 {
1742 nextAddr.Invalidate();
1743 return false;
1744 }
1745 } // end ProtoAddressList::Iterator::GetNextAddress()
1746
1747 bool ProtoAddressList::Iterator::PeekNextAddress(ProtoAddress& nextAddr)
1748 {
1749 Item* nextItem = static_cast<Item*>(ptree_iterator.PeekNextItem());
1750 if (NULL != nextItem)
1751 {
1752 nextAddr = nextItem->GetAddress();
1753 return true;
1754 }
1755 else
1756 {
1757 nextAddr.Invalidate();
1758 return false;
1759 }
1760 } // end ProtoAddressList::Iterator::PeekNextAddress()