1

#ifndef NETWORK_ADDRESS_H

     2

#define NETWORK_ADDRESS_H

     3

    11

#include "Endpoint.hh"

    12

    13

/**

    18

 *

    25

 */

    26

class NetworkAddress : public NetworkEndpoint {

    27

    protected:

    28

        /**

    29

         * The machine-readable address

    30

         */

    31

        sockaddr_storage address;

    32

    33

        /**

    34

         * The address length

    35

         */

    36

        socklen_t address_length;

    37

    38

    public:

    39

        /**

    40

         * Construct an empty SockAddr for later update()

    41

         */

    42

        NetworkAddress (void);

    43

    44

        /**

    45

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

    46

         */

    47

        NetworkAddress (const sockaddr *addr, socklen_t len);

    48

    49

        /**

    50

         * Get a const sockaddr* in this address

    51

         *

    52

         * @return read-only sockaddr pointer

    53

         */

    54

        const sockaddr* get_sockaddr (void) const { return (const sockaddr *) &address; }

    55

    56

        /**

    57

         * Get a mutable sockaddr* in this address

    58

         *

    59

         * @return writeable sockaddr pointer

    60

         */

    61

        sockaddr* get_sockaddr (void) { return (sockaddr *) &address; }

    62

    63

        /**

    64

         * Get the current address length

    65

         *

    66

         * @return address length

    67

         */

    68

        socklen_t get_socklen (void) const { return address_length; }

    69

    70

        /**

    71

         * Get a the address length pointer, initialized to the size of our sockaddr_storage.

    72

         *

    73

         * @return address length pointer

    74

         */

    75

        socklen_t* get_socklen_ptr (void) { address_length = sizeof(address); return &address_length; }

    76

    77

        /**

    78

         * Copy given sockaddr/len + update

    79

         */

    80

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

    81

    82

        /**

    83

         * Update internal state for NetworkAddress after sockaddr/socklen_ptr have been modified.

    84

         */

    85

        void update (void);

    86

    87

        /**

    88

         * Returns a "fake" addrinfo

    89

         */

    90

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

    91

    92

        /**

    93

         * Free an addrinfo returned by get_addrinfo

    94

         */

    95

        virtual void free_addrinfo (addrinfo *info) const;

    96

    97

        /**

    98

         * Equal-to comparison operator. Invalid addresses compare equal and are always smaller.

    99

         *

   100

         * XXX: use of memcmp is broken... there's garbage in the padding

   101

         */

   102

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

   103

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

   104

        }

   105

   106

        /**

   107

         * Not-equal-to comparison operator. Invalid addresses compare equal and are always smaller.

   108

         */

   109

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

   110

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

   111

        }

   112

   113

        /**

   114

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

   115

         */

   116

        bool operator< (const NetworkAddress &other) const {

   117

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

   118

        }

   119

   120

        /**

   121

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

   122

         */

   123

        bool operator> (const NetworkAddress &other) const {

   124

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

   125

        }

   126

};

   127

   128

#endif