| /********** |
| This library is free software; you can redistribute it and/or modify it under |
| the terms of the GNU Lesser General Public License as published by the |
| Free Software Foundation; either version 3 of the License, or (at your |
| option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.) |
| |
| This library is distributed in the hope that it will be useful, but WITHOUT |
| ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS |
| FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for |
| more details. |
| |
| You should have received a copy of the GNU Lesser General Public License |
| along with this library; if not, write to the Free Software Foundation, Inc., |
| 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
| **********/ |
| // "mTunnel" multicast access service |
| // Copyright (c) 1996-2020 Live Networks, Inc. All rights reserved. |
| // Network Addresses |
| // Implementation |
| |
| #include "NetAddress.hh" |
| #include "GroupsockHelper.hh" |
| |
| #include <stddef.h> |
| #include <stdio.h> |
| #if defined(__WIN32__) || defined(_WIN32) |
| #define USE_GETHOSTBYNAME 1 /*because at least some Windows don't have getaddrinfo()*/ |
| #else |
| #ifndef INADDR_NONE |
| #define INADDR_NONE 0xFFFFFFFF |
| #endif |
| #endif |
| |
| ////////// NetAddress ////////// |
| |
| NetAddress::NetAddress(u_int8_t const* data, unsigned length) { |
| assign(data, length); |
| } |
| |
| NetAddress::NetAddress(unsigned length) { |
| fData = new u_int8_t[length]; |
| if (fData == NULL) { |
| fLength = 0; |
| return; |
| } |
| |
| for (unsigned i = 0; i < length; ++i) fData[i] = 0; |
| fLength = length; |
| } |
| |
| NetAddress::NetAddress(NetAddress const& orig) { |
| assign(orig.data(), orig.length()); |
| } |
| |
| NetAddress& NetAddress::operator=(NetAddress const& rightSide) { |
| if (&rightSide != this) { |
| clean(); |
| assign(rightSide.data(), rightSide.length()); |
| } |
| return *this; |
| } |
| |
| NetAddress::~NetAddress() { |
| clean(); |
| } |
| |
| void NetAddress::assign(u_int8_t const* data, unsigned length) { |
| fData = new u_int8_t[length]; |
| if (fData == NULL) { |
| fLength = 0; |
| return; |
| } |
| |
| for (unsigned i = 0; i < length; ++i) fData[i] = data[i]; |
| fLength = length; |
| } |
| |
| void NetAddress::clean() { |
| delete[] fData; fData = NULL; |
| fLength = 0; |
| } |
| |
| |
| ////////// NetAddressList ////////// |
| |
| NetAddressList::NetAddressList(char const* hostname) |
| : fNumAddresses(0), fAddressArray(NULL) { |
| // First, check whether "hostname" is an IP address string: |
| netAddressBits addr = our_inet_addr((char*)hostname); |
| if (addr != INADDR_NONE) { |
| // Yes, it was an IP address string. Return a 1-element list with this address: |
| fNumAddresses = 1; |
| fAddressArray = new NetAddress*[fNumAddresses]; |
| if (fAddressArray == NULL) return; |
| |
| fAddressArray[0] = new NetAddress((u_int8_t*)&addr, sizeof (netAddressBits)); |
| return; |
| } |
| |
| // "hostname" is not an IP address string; try resolving it as a real host name instead: |
| #if defined(USE_GETHOSTBYNAME) || defined(VXWORKS) |
| struct hostent* host; |
| #if defined(VXWORKS) |
| char hostentBuf[512]; |
| |
| host = (struct hostent*)resolvGetHostByName((char*)hostname, (char*)&hostentBuf, sizeof hostentBuf); |
| #else |
| host = gethostbyname((char*)hostname); |
| #endif |
| if (host == NULL || host->h_length != 4 || host->h_addr_list == NULL) return; // no luck |
| |
| u_int8_t const** const hAddrPtr = (u_int8_t const**)host->h_addr_list; |
| // First, count the number of addresses: |
| u_int8_t const** hAddrPtr1 = hAddrPtr; |
| while (*hAddrPtr1 != NULL) { |
| ++fNumAddresses; |
| ++hAddrPtr1; |
| } |
| |
| // Next, set up the list: |
| fAddressArray = new NetAddress*[fNumAddresses]; |
| if (fAddressArray == NULL) return; |
| |
| for (unsigned i = 0; i < fNumAddresses; ++i) { |
| fAddressArray[i] = new NetAddress(hAddrPtr[i], host->h_length); |
| } |
| #else |
| // Use "getaddrinfo()" (rather than the older, deprecated "gethostbyname()"): |
| struct addrinfo addrinfoHints; |
| memset(&addrinfoHints, 0, sizeof addrinfoHints); |
| addrinfoHints.ai_family = AF_INET; // For now, we're interested in IPv4 addresses only |
| struct addrinfo* addrinfoResultPtr = NULL; |
| int result = getaddrinfo(hostname, NULL, &addrinfoHints, &addrinfoResultPtr); |
| if (result != 0 || addrinfoResultPtr == NULL) return; // no luck |
| |
| // First, count the number of addresses: |
| const struct addrinfo* p = addrinfoResultPtr; |
| while (p != NULL) { |
| if (p->ai_addrlen < 4) continue; // sanity check: skip over addresses that are too small |
| ++fNumAddresses; |
| p = p->ai_next; |
| } |
| |
| // Next, set up the list: |
| fAddressArray = new NetAddress*[fNumAddresses]; |
| if (fAddressArray == NULL) return; |
| |
| unsigned i = 0; |
| p = addrinfoResultPtr; |
| while (p != NULL) { |
| if (p->ai_addrlen < 4) continue; |
| fAddressArray[i++] = new NetAddress((u_int8_t const*)&(((struct sockaddr_in*)p->ai_addr)->sin_addr.s_addr), 4); |
| p = p->ai_next; |
| } |
| |
| // Finally, free the data that we had allocated by calling "getaddrinfo()": |
| freeaddrinfo(addrinfoResultPtr); |
| #endif |
| } |
| |
| NetAddressList::NetAddressList(NetAddressList const& orig) { |
| assign(orig.numAddresses(), orig.fAddressArray); |
| } |
| |
| NetAddressList& NetAddressList::operator=(NetAddressList const& rightSide) { |
| if (&rightSide != this) { |
| clean(); |
| assign(rightSide.numAddresses(), rightSide.fAddressArray); |
| } |
| return *this; |
| } |
| |
| NetAddressList::~NetAddressList() { |
| clean(); |
| } |
| |
| void NetAddressList::assign(unsigned numAddresses, NetAddress** addressArray) { |
| fAddressArray = new NetAddress*[numAddresses]; |
| if (fAddressArray == NULL) { |
| fNumAddresses = 0; |
| return; |
| } |
| |
| for (unsigned i = 0; i < numAddresses; ++i) { |
| fAddressArray[i] = new NetAddress(*addressArray[i]); |
| } |
| fNumAddresses = numAddresses; |
| } |
| |
| void NetAddressList::clean() { |
| while (fNumAddresses-- > 0) { |
| delete fAddressArray[fNumAddresses]; |
| } |
| delete[] fAddressArray; fAddressArray = NULL; |
| } |
| |
| NetAddress const* NetAddressList::firstAddress() const { |
| if (fNumAddresses == 0) return NULL; |
| |
| return fAddressArray[0]; |
| } |
| |
| ////////// NetAddressList::Iterator ////////// |
| NetAddressList::Iterator::Iterator(NetAddressList const& addressList) |
| : fAddressList(addressList), fNextIndex(0) {} |
| |
| NetAddress const* NetAddressList::Iterator::nextAddress() { |
| if (fNextIndex >= fAddressList.numAddresses()) return NULL; // no more |
| return fAddressList.fAddressArray[fNextIndex++]; |
| } |
| |
| |
| ////////// Port ////////// |
| |
| Port::Port(portNumBits num /* in host byte order */) { |
| fPortNum = htons(num); |
| } |
| |
| UsageEnvironment& operator<<(UsageEnvironment& s, const Port& p) { |
| return s << ntohs(p.num()); |
| } |
| |
| |
| ////////// AddressPortLookupTable ////////// |
| |
| AddressPortLookupTable::AddressPortLookupTable() |
| : fTable(HashTable::create(3)) { // three-word keys are used |
| } |
| |
| AddressPortLookupTable::~AddressPortLookupTable() { |
| delete fTable; |
| } |
| |
| void* AddressPortLookupTable::Add(netAddressBits address1, |
| netAddressBits address2, |
| Port port, void* value) { |
| int key[3]; |
| key[0] = (int)address1; |
| key[1] = (int)address2; |
| key[2] = (int)port.num(); |
| return fTable->Add((char*)key, value); |
| } |
| |
| void* AddressPortLookupTable::Lookup(netAddressBits address1, |
| netAddressBits address2, |
| Port port) { |
| int key[3]; |
| key[0] = (int)address1; |
| key[1] = (int)address2; |
| key[2] = (int)port.num(); |
| return fTable->Lookup((char*)key); |
| } |
| |
| Boolean AddressPortLookupTable::Remove(netAddressBits address1, |
| netAddressBits address2, |
| Port port) { |
| int key[3]; |
| key[0] = (int)address1; |
| key[1] = (int)address2; |
| key[2] = (int)port.num(); |
| return fTable->Remove((char*)key); |
| } |
| |
| AddressPortLookupTable::Iterator::Iterator(AddressPortLookupTable& table) |
| : fIter(HashTable::Iterator::create(*(table.fTable))) { |
| } |
| |
| AddressPortLookupTable::Iterator::~Iterator() { |
| delete fIter; |
| } |
| |
| void* AddressPortLookupTable::Iterator::next() { |
| char const* key; // dummy |
| return fIter->next(key); |
| } |
| |
| |
| ////////// isMulticastAddress() implementation ////////// |
| |
| Boolean IsMulticastAddress(netAddressBits address) { |
| // Note: We return False for addresses in the range 224.0.0.0 |
| // through 224.0.0.255, because these are non-routable |
| // Note: IPv4-specific ##### |
| netAddressBits addressInNetworkOrder = htonl(address); |
| return addressInNetworkOrder > 0xE00000FF && |
| addressInNetworkOrder <= 0xEFFFFFFF; |
| } |
| |
| |
| ////////// AddressString implementation ////////// |
| |
| AddressString::AddressString(struct sockaddr_in const& addr) { |
| init(addr.sin_addr.s_addr); |
| } |
| |
| AddressString::AddressString(struct in_addr const& addr) { |
| init(addr.s_addr); |
| } |
| |
| AddressString::AddressString(netAddressBits addr) { |
| init(addr); |
| } |
| |
| void AddressString::init(netAddressBits addr) { |
| fVal = new char[16]; // large enough for "abc.def.ghi.jkl" |
| netAddressBits addrNBO = htonl(addr); // make sure we have a value in a known byte order: big endian |
| sprintf(fVal, "%u.%u.%u.%u", (addrNBO>>24)&0xFF, (addrNBO>>16)&0xFF, (addrNBO>>8)&0xFF, addrNBO&0xFF); |
| } |
| |
| AddressString::~AddressString() { |
| delete[] fVal; |
| } |