1

#ifndef NETWORK_ADDRESS_HH

     2

#define NETWORK_ADDRESS_HH

     3

     4

#include "../Error.hh"

     5

     6

/*

     7

 * Platform-specific includes

     8

 */

     9

#ifndef WIN32

    10

    // linux

    11

    #include <sys/types.h>

    12

    #include <sys/socket.h>

    13

    #include <netdb.h>

    14

#else

    15

    #error "This network code won't compile on win32 :)"

    16

#endif

    17

    18

#include <string>

    19

    20

// assume...

    21

#if INET6_ADDRSTRLEN < INET_ADDRSTRLEN

    22

    #error INET6_ADDRSTRLEN is smaller than INET_ADDRSTRLEN

    23

#endif

    24

    25

/**

    26

 * Length of a network address

    27

 */

    28

const socklen_t NETWORK_ADDRESS_LENGTH = INET6_ADDRSTRLEN;

    29

    30

/**

    31

 * We use ClanLib's IPAddress API, but with our own name

    32

 */ 

    33

class NetworkAddress {

    34

    private:

    35

        /**

    36

         * Our human-readable hostname

    37

         */

    38

        std::string hostname;

    39

    40

        /**

    41

         * Our human-readable service

    42

         */

    43

        std::string service;

    44

    45

        /**

    46

         * Our machine-readable address and its length

    47

         */

    48

        sockaddr_storage address;

    49

        socklen_t address_length;

    50

    51

    public:

    52

        /**

    53

         * Construct an empty NetworkAddress

    54

         */

    55

        NetworkAddress (void);

    56

    57

        /**

    58

         * Construct a NetworkAddress with a NULL hostname, and a specific service

    59

         */

    60

        NetworkAddress (std::string service);

    61

    62

        /**

    63

         * Construct a NetworkAddress on a specific hostname and service

    64

         */

    65

        NetworkAddress (std::string hostname, std::string service);

    66

    67

        /**

    68

         * Construct a NetworkAddress from a machine-readable address of the given length

    69

         */

    70

        NetworkAddress (const sockaddr *addr, socklen_t len);

    75

    76

    public:    

    77

        /**

    78

         * Get a addrinfo* for this address using the given family/type/protocol/flags.

    79

         *

    80

         * Remember to free the returned pointer using freeaddrinfo() after use.

    81

         *

    82

         * @param family the socket family for hints.ai_family

    83

         * @param socktype the socket type for hints.ai_socktype

    84

         * @param protoocl the socket protocol for hints.ai_protocol

    85

         * @param flags the flags for hints.ai_flags

    86

         * @return linked list of addrinfo's

    87

         * @throw NetworkAddressError if resolving this address fails

    88

         */

    89

        addrinfo* get_addrinfo (int family, int socktype, int protocol = 0, int flags = 0) const;

    90

    91

        /**

    92

         * Get a sockaddr* for this address. This is only valid for NetworkAddress's which have had set_sockaddr called

    93

         * on them.

    94

         *

    95

         * @param len_ref updated to the sockaddr length

    96

         * @return borrowed sockaddr pointer

    97

         */

    98

        const sockaddr* get_sockaddr (socklen_t &len_ref) const;

    99

   100

        /**

   101

         * Set a sockaddr for this address

   102

         *

   103

         * @param addr the address to copy, of len bytes

   104

         * @param len the size of the sockaddr

   105

         */

   106

        void set_sockaddr (const sockaddr *addr, socklen_t len);

   107

   108

        /**

   109

         * Get the human-readable hostname

   110

         */

   111

        std::string get_hostname (void) const { return hostname; }

   112

   113

        /**

   114

         * Get the human-readable service name

   115

         */

   116

        std::string get_service (void) const { return service; }

   117

   118

        /**

   119

         * Equal-to comparison operator. This requires that the machine-readable address be available.

   120

         */

   121

        bool operator== (const NetworkAddress &other) const {

   122

            return (address_length == other.address_length) && memcmp(&address, &other.address, address_length) == 0;

   123

        }

   124

   125

        /**

   126

         * Not-qqual-to comparison operator. This requires that the machine-readable address be available.

   127

         */

   128

        bool operator!= (const NetworkAddress &other) const {

   129

            return (address_length != other.address_length) || memcmp(&address, &other.address, address_length) != 0;

   130

        }

   131

   132

        /**

   133

         * Less-than comparison operator. Smaller addresses are always lesser.

   134

         */

   135

        bool operator< (const NetworkAddress &other) const {

   136

            return (address_length < other.address_length) || memcmp(&address, &other.address, other.address_length) < 0;

   137

        }

   138

   139

        /**

   140

         * Greater-than comparison operator. Bigger addresses are always greater.

   141

         */

   142

        bool operator> (const NetworkAddress &other) const {

   143

            return (address_length > other.address_length) || memcmp(&address, &other.address, address_length) > 0;

   144

        }

   145

};

   146

   147

/**

   148

 * Formatted as  [<addr>:<port>]

   149

 */

   150

std::ostream& operator<< (std::ostream &s, const NetworkAddress &addr);

   151

   152

/**

   153

 *

   154

 */

   155

class NetworkAddressError : public Error {

   156

    protected:

   157

        static std::string build_str (const NetworkAddress &addr, const char *op, const char *msg);

   158

   159

    public:

   160

        NetworkAddressError (const NetworkAddress &addr, const char *op, const char *msg);

   161

};

   162

   163

#endif /* NETWORK_ADDRESS_HH */