/builddir/build/BUILD/libutil++-1.4.0/src/sella/net/Port.cpp

/*
** libutil++
** $Id: Port.cpp 1197 2014-10-14 22:26:11Z sella $
** Copyright (c) 2011-2014 Digital Genesis, LLC. All Rights Reserved.
** Released under the LGPL Version 2.1 License.
** http://www.digitalgenesis.com
*/

static const char rcsid[] __attribute__((used)) = "$Id: Port.cpp 1197 2014-10-14 22:26:11Z sella $";

#include "Port.h"
#include "PortException.h"

#include <sys/socket.h>
#include <string.h>
#include <stdint.h>
#include <stdlib.h>
#include <netdb.h>

#define HASH_ALGO_INT1

union __sockaddr_union {
        struct sockaddr_storage         *ss;
        struct sockaddr                         *sa;
        struct sockaddr_in                      *sa_in;
        struct sockaddr_in6                     *sa_in6;
};

using namespace sella::net;

Port::Port(const std::string &service, int protocol) throw (PortException) :
        port(0),
        protocol(0),
        hcache(0)
{
        switch (protocol) {
                case UDPPreferred:
                        if (this->parseUDPPreferred(this->port, this->protocol, service) == false) {
                                THROW(PortException, "unable to parse port: '%s' does not represent valid UDP or TCP port", service.c_str());
                        }
                        break;

                case UDPRequired:
                        if (this->parseUDPRequired(this->port, this->protocol, service) == false) {
                                THROW(PortException, "unable to parse port: '%s' does not represent valid UDP port", service.c_str());
                        }
                        break;

                case TCPPreferred:
                        if (this->parseTCPPreferred(this->port, this->protocol, service) == false) {
                                THROW(PortException, "unable to parse port: '%s' does not represent valid TCP or UDP port", service.c_str());
                        }
                        break;

                case TCPRequired:
                        if (this->parseTCPRequired(this->port, this->protocol, service) == false) {
                                THROW(PortException, "unable to parse port: '%s' does not represent valid TCP port", service.c_str());
                        }
                        break;

                default:
                        THROW(PortException, "unable to parse port: unknown protocol supplied for port '%s'", service.c_str());
        }
}

Port::Port(uint16_t port, int protocol) throw (PortException) :
        port(port),
        protocol(0)
{
        switch (protocol) {
                case UDPPreferred:
                case UDPRequired:
                        this->protocol = UDPProtocol;
                        break;

                case TCPPreferred:
                case TCPRequired:
                        this->protocol = TCPProtocol;
                        break;

                default:
                        THROW(PortException, "unable to parse port: unknown protocol supplied for port '%d'", protocol);
        }
}

Port::Port(const struct sockaddr_storage *ss, int protocol) throw (PortException) :
        protocol(0),
        hcache(0)
{
        union __sockaddr_union u;
        u.ss = (struct sockaddr_storage*) ss;

        if (ss == NULL) {
                THROW(PortException, "passed sockaddr_storage is null");
        }

        port = ntohs(u.sa_in->sin_port);

        switch (protocol) {
                case UDPPreferred:
                case UDPRequired:
                        this->protocol = UDPProtocol;
                        break;

                case TCPPreferred:
                case TCPRequired:
                        this->protocol = TCPProtocol;
                        break;

                default:
                        THROW(PortException, "unable to parse port: unknown protocol supplied for port '%d'", protocol);
        }
}

Port::Port(const struct sockaddr *sa, int protocol) throw (PortException) :
        protocol(0),
        hcache(0)
{
        union __sockaddr_union u;
        u.sa = (struct sockaddr*) sa;

        if (sa == NULL) {
                THROW(PortException, "passed sockaddr is null");
        }

        port = ntohs(u.sa_in->sin_port);

        switch (protocol) {
                case UDPPreferred:
                case UDPRequired:
                        this->protocol = UDPProtocol;
                        break;

                case TCPPreferred:
                case TCPRequired:
                        this->protocol = TCPProtocol;
                        break;

                default:
                        THROW(PortException, "unable to parse port: unknown protocol supplied for port '%d'", protocol);
        }
}

Port::Port(const Port &other) throw () :
        port(other.port),
        protocol(other.protocol),
        scache(other.scache),
        hcache(other.hcache)
{ }

Port::Port(const Port &&other) throw () :
        port(other.port),
        protocol(other.protocol),
        scache(std::move(other.scache)),
        hcache(other.hcache)
{ }

Port::~Port() throw () { }

Port& Port::operator=(const Port &other) throw () {
        if (this != &other) {
                this->port = other.port;
                this->protocol = other.protocol;
                this->scache= other.scache;
                this->hcache = other.hcache;
        }

        return *this;
}

Port& Port::operator=(const Port &&other) throw () {
        if (this != &other) {
                this->port = other.port;
                this->protocol = other.protocol;
                this->scache= std::move(other.scache);
                this->hcache = other.hcache;
        }

        return *this;
}

bool Port::operator == (const Port &other) const throw () {
        return (this->port == other.port) ? ((this->protocol == other.protocol) ? true : false) : false;
}

bool Port::operator != (const Port &other) const throw () {
        return !(*this == other);
}

bool Port::operator >= (const Port &other) const throw () {
        return (this->port < other.port) ? false : ((this->port > other.port) ? true : (this->protocol >= other.protocol) ? true : false);
}

bool Port::operator <= (const Port &other) const throw () {
        return (this->port > other.port) ? false : ((this->port < other.port) ? true : (this->protocol <= other.protocol) ? true : false);
}

bool Port::operator >  (const Port &other) const throw () {
        return (this->port > other.port) ? true : ((this->port < other.port) ? false : (this->protocol > other.protocol) ? true : false);
}

bool Port::operator <  (const Port &other) const throw () {
        return (this->port < other.port) ? true : ((this->port > other.port) ? false : (this->protocol < other.protocol) ? true : false);
}

uint16_t Port::get(void) const throw () {
        return this->port;
}

uint16_t Port::getPort(void) const throw () {
        return this->port;
}

int Port::getProtocol(void) const throw () {
        return this->protocol;
}

const std::string& Port::str(void) const throw () {
        char buf[31];

        if (scache.empty()) {
                snprintf(buf, sizeof(buf), "%u", this->port);
                scache = buf;
        }

        return scache;
}

const char* Port::c_str(void) const throw () {
        return str().c_str();
}

uint32_t Port::getU32(void) const throw () {
        return (port | (port << 16)) ^ 0xB4B4D2D2;
}

uint32_t Port::getHash(void) const throw () {
        if (hcache != 0) {
                return hcache;
        }

#if defined HASH_ALGO_INT1 /* Fast. Nibble swap. */
        uint32_t k = getU32();

        hcache = ((k & 0xF0F0F0F0) >> 4) | ((k & 0x0F0F0F0F) << 4);
#elif defined HASH_ALGO_INT2
        uint32_t k = getU32();

        hcache = (k<<16)^(k>>16)^k; /* Fast. Mix by XOR shifting.. */
#elif defined HASH_ALGO_INT3 /* Very fast, but not good. */
        hcache = getU32();
#else
        #error No hash algo selected.
#endif

        return hcache;
}

bool Port::empty(void) const throw () {
        return (port == 0);
}

void Port::clear(void) throw () {
        port = 0;
        protocol = 0;
        scache.clear();
        hcache = 0;
}

const Port::shared Port::shared_ptr(const std::string &service, int protocol) throw (PortException) {
        return std::make_shared<Port>(service, protocol);
}

const Port::shared Port::shared_ptr(uint16_t port, int protocol) throw (PortException) {
        return std::make_shared<Port>(port, protocol);
}

const Port::shared Port::shared_ptr(const struct sockaddr_storage *ss, int protocol) throw (PortException) {
        return std::make_shared<Port>(ss, protocol);
}

const Port::shared Port::shared_ptr(const struct sockaddr *sa, int protocol) throw (PortException) {
        return std::make_shared<Port>(sa, protocol);
}

bool Port::parseUDPRequired(uint16_t &port, int &protocol, const std::string &service) throw () {
        struct servent  entry_buf, *entry;
        char                            buf[4096], *end;

        port = strtol(service.c_str(), &end, 10);

        if ((*end) != '\0') {
                if (getservbyname_r(service.c_str(), "udp", &entry_buf, buf, sizeof(buf), &entry) == 0) {
                        protocol = UDPProtocol;
                        port = entry->s_port;
                } else {
                        return false;
                }
        }
        return true;
}

bool Port::parseTCPRequired(uint16_t &port, int &protocol, const std::string &service) throw () {
        struct servent  entry_buf, *entry;
        char                            buf[4096], *end;

        port = strtol(service.c_str(), &end, 10);

        if ((*end) != '\0') {
                if (getservbyname_r(service.c_str(), "tcp", &entry_buf, buf, sizeof(buf), &entry) == 0) {
                        protocol = UDPProtocol;
                        port = entry->s_port;
                } else {
                        return false;
                }
        }
        return true;
}

bool Port::parseUDPPreferred(uint16_t &port, int &protocol, const std::string &service) throw () {
        if (this->parseUDPRequired(port, protocol, service) == false) {
                return this->parseTCPRequired(port, protocol, service);
        }
        return true;
}

bool Port::parseTCPPreferred(uint16_t &port, int &protocol, const std::string &service) throw () {
        if (this->parseTCPRequired(port, protocol, service) == false) {
                return this->parseUDPRequired(port, protocol, service);
        }
        return true;
}

/*
** vim: noet ts=3 sw=3
*/

---