InetAddr.h

Go to the documentation of this file.

/*
 * Copyright (C) 2007-2015 Hypertable, Inc.
 *
 * This file is part of Hypertable.
 *
 * Hypertable is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 3
 * of the License, or any later version.
 *
 * Hypertable 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA.
 */

#ifndef Hypertable_Common_InetAddr_h
#define Hypertable_Common_InetAddr_h

#include <Common/String.h>

#include <cstring>

extern "C" {
#include <netinet/in.h>
}

namespace Hypertable {

  struct Endpoint {
    Endpoint(const String &host, uint16_t port)
      : host(host), port(port) {
    }

    Endpoint()
      : port(0) {
    }

    String host;
    uint16_t port;
  };

  std::ostream &operator<<(std::ostream &, const Endpoint &);

  class InetAddr : public sockaddr_in {

  public:

    InetAddr();

    InetAddr(const String &host, uint16_t port);

    InetAddr(const String &endpoint);

    InetAddr(uint32_t ip32, uint16_t port);

    InetAddr(const sockaddr_in &addr) { operator=(addr); }

    InetAddr &operator=(const sockaddr_in &addr) {
      if (this != &addr)
        memcpy(this, &addr, sizeof(sockaddr_in));

      return *this;
    }

    bool operator==(const InetAddr &other) const {
      return (bool)!memcmp(this, &other, sizeof(InetAddr));
    }

    bool operator!=(const InetAddr &other) const {
      return !(*this == other);
    }

    bool operator<(const InetAddr &other) const {
      if (sin_family != other.sin_family)
        return sin_family < other.sin_family;
      if (sin_addr.s_addr != other.sin_addr.s_addr)
        return sin_addr.s_addr < other.sin_addr.s_addr;
      return sin_port < other.sin_port;
    }

    String format(int sep = ':') const { return InetAddr::format(*this, sep); }

    String format_ipaddress() { return InetAddr::format_ipaddress(*this); }

    String hex(int sep = ':') { return InetAddr::hex(*this, sep); }

    // convenient/legacy static methods
    static bool initialize(sockaddr_in *addr, const char *host, uint16_t port);

    static bool initialize(sockaddr_in *addr, const char *addr_str);

    static bool initialize(sockaddr_in *addr, uint32_t haddr, uint16_t port);

    static Endpoint parse_endpoint(const char *endpoint, int defport = 0);

    static Endpoint parse_endpoint(const String &endpoint, int defport = 0) {
      return parse_endpoint(endpoint.c_str(), defport);
    }

    static bool parse_ipv4(const char *ip, uint16_t port, sockaddr_in &addr,
                           int base = 0);

    static bool is_ipv4(const char *ip);

    static String format(const sockaddr_in &addr, int sep = ':');

    static String format_ipaddress(const sockaddr_in &addr);

    static String hex(const sockaddr_in &addr, int sep = ':');

    size_t encoded_length() const;

    void encode(uint8_t **bufp) const;

    void decode(const uint8_t **bufp, size_t *remainp);

    void legacy_decode(const uint8_t **bufp, size_t *remainp);

  private:

    uint8_t encoding_version() const;

    size_t encoded_length_internal() const;

    void encode_internal(uint8_t **bufp) const;

    void decode_internal(uint8_t version, const uint8_t **bufp, size_t *remainp);


  };

  std::ostream &operator<<(std::ostream &, const sockaddr_in &);

}

#endif // Hypertable_Common_InetAddr_h