root/trunk/whisperlib/net/base/address.h

// Copyright (c) 2009, Whispersoft s.r.l.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Whispersoft s.r.l. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Author: Cosmin Tudorache & Catalin Popescu
//
#ifndef __NET_BASE_ADDRESS_H__
#define __NET_BASE_ADDRESS_H__

#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <string>
#include <map>
#include <whisperlib/common/base/types.h>
#include <whisperlib/common/base/log.h>

struct in_addr;

namespace net {

class IpAddress {
 public:
  static const int32 kInvalidIpV4 = 0;
  static const uint8 kInvalidIpV6[16];

  IpAddress()
      : is_ipv4_(true) {
    memset(&addr_, 0, sizeof(&addr_));
  }
  //  ip: 4 bytes containing the IP address
  //      (host byte order: b1.b2.b3.b4 <==> 0xb1b2b3b4)
  explicit IpAddress(int32 ip)
      : is_ipv4_(true) {
    addr_.ipv4_ = ip;
  }
  // parsing constructor
  explicit IpAddress(const char* addr) {
    bool error = false;
    if ( strchr(addr, ':') ) {
      is_ipv4_ = false;
      //NOTE: inet_pton delivers address in network byte order
      error = inet_pton(AF_INET6, addr, addr_.ipv6_) <= 0;
      // we keep addr_.ipv6_ in network byte order
    } else {
      is_ipv4_ = true;
      //NOTE: inet_pton delivers address in network byte order
      error = inet_pton(AF_INET, addr, &addr_.ipv4_) <= 0;
      // we keep addr_.ipv4_ in host byte order
      addr_.ipv4_ = ntohl(addr_.ipv4_);
      }
    if ( error ) {
      memset(&addr_, 0, sizeof(&addr_));
    }
  }
  IpAddress& operator=(const IpAddress& addr) {
    is_ipv4_ = addr.is_ipv4_;
    memcpy(&addr_, &addr.addr_, sizeof(addr_));
    return *this;
  }
  IpAddress& operator=(int32 ip) {
    is_ipv4_ = true;
    addr_.ipv4_ = ip;
    return *this;
  }

  bool IsInvalid() const {
    if ( is_ipv4_ )
      return addr_.ipv4_ == kInvalidIpV4;
    else
      return (0 == memcmp(addr_.ipv6_, kInvalidIpV6, sizeof(addr_.ipv6_)));
  }
  bool is_ipv4() const {
    return is_ipv4_;
  }
  int32 ipv4() const {
    CHECK(is_ipv4_);
    return addr_.ipv4_;
  }
  void set_ipv4(int32 ip) {
    is_ipv4_ = true;
    addr_.ipv4_ = ip;
  }
  void set_ipv6(const uint8* ip) {
    is_ipv4_ = false;
    memcpy(addr_.ipv6_, ip, 16);
  }

  // returns the ip address in structure..
  void Addr(sockaddr_storage* addr) const;


  // Generates a text representation of the ip (ex. "10.205.9.85") in
  // the given "buf". If the buf is too small, it will contain a truncated
  // string.
  const char* ToString(char* buf, size_t buf_len) const;

  // Same as above, but returns a string;
  string ToString() const;

 private:
  bool is_ipv4_;
  union {
    int32 ipv4_;         // "b1.b2.b3.b4" <==> 0xb1b2b3b4 . host byte order
    uint8 ipv6_[16];     // {b1,b2,b3,..,b16} . network byte order
  } addr_;
};


class HostPort {
 public:
  static const uint16 kInvalidPort = 0;
  HostPort()
      : ip_(), port_(kInvalidPort) {
  }
  HostPort(int32 ip, uint16 port)
      : ip_(ip), port_(port) {
  }
  // Parsing constructor
  // @example: "10.205.9.85:2345" -> set IP=10.205.9.85 & PORT=2345
  // @example: "10.205.9.85" -> set only IP=10.205.9.85 & PORT=0
  explicit HostPort(const char* addr) {
    Parse(addr, this);
  }
  // Parsing constructor (just for the ip)
  HostPort(const IpAddress& addr, uint16 port)
      : ip_(addr), port_(port) {
  }
  // Parsing constructor (just for the ip)
  HostPort(const char* addr, uint16 port)
      : ip_(addr), port_(port) {
  }
  // From net order of addr converts to machine order in HostPort
  explicit HostPort(const struct sockaddr_storage* addr);

  HostPort& operator=(const HostPort& hp) {
    ip_ = hp.ip_;
    port_ = hp.port_;
    return *this;
  }

  // Accesors / settors
  const IpAddress& ip_object() const { return ip_; }
  IpAddress* mutable_ip_object() { return &ip_; }

  // int32 ip() const { return ip_.ip(); }
  void set_ipv4(int32 ip) { ip_ = ip; }

  void set_ip(const IpAddress& ip) { ip_ = ip; }

  uint16 port() const { return port_; }
  void set_port(uint16 port) { port_ = port; }

  bool IsInvalid() const {
    return ip_.IsInvalid() || (port_ == kInvalidPort);
  }

  // Parses host and port into provided hp structure
  // @example: "10.205.9.85:2345" -> set IP=10.205.9.85 & PORT=2345
  // @example: "10.205.9.85" -> set only IP=10.205.9.85 & PORT remains unchanged
  static void Parse(const char* addr, HostPort* hp);

  // Returns  ip address in network byte order
  void Addr(sockaddr_storage* addr) const {ip_.Addr(addr); }
  void SockAddr(struct sockaddr_storage* addr) const;

  // Generates a text representation of the ip (ex. "10.205.9.85")
  // in the given "buffer". If buffer is too smal, it truncates the
  // answer
  const char* ToString(char* buffer, size_t len) const;

  // Same as above, but generates a string
  string ToString() const;

 private:
  IpAddress ip_;
  uint16 port_;
};

inline ostream& operator<<(ostream& os, const IpAddress& ip) {
  return os << ip.ToString();
}
inline ostream& operator<<(ostream& os, const HostPort& hp) {
  return os << hp.ip_object() << ":" << hp.port();
}

// This is a filter of addresses. Add ip strings like "12.23.4.2" or
// range specification "192.168.2.23/24" or IPV4Address -es, then
// check with a test IP if it matches.
class IpV4Filter {
 public:
  IpV4Filter() {
  }
  ~IpV4Filter() {
  }

  // Adds an ip or a range to the filter. Returns true on OK
  bool Add(const char* p);
  bool Add(const IpAddress& ip, int32 bits = 32);

  // Matching function - returns true if it matches
  bool Matches(const IpAddress& ip) const;

 private:
  enum ElemType {
    MARK_BEGIN = 1,
    MARK_END = 2,
    MARK_BOTH = 3,
  };
  typedef map<uint32, int32> FilterMap;
  FilterMap filter_;
};
}

#endif  // __NET_BASE_ADDRESS_H__