3

     5

     6

/*

     7

 * Platform-specific includes

     8

 */

     9

#ifndef WIN32

    10

    // linux

    11

    #include <netinet/in.h>

    12

#else

    13

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

    14

#endif

    15

    16

/**

    17

 * This represents a `struct sockaddr` as used by the socket API.

    18

 *

    19

 * It can be used like a NetworkEndpoint, but it's also suitable for use with recvfrom/sendto

    20

 */

    21

class NetworkAddress : public NetworkEndpoint {

    22

    protected:

    23

        /**

    24

         * The machine-readable address

    25

         */

    26

        sockaddr_storage address;

    27

    28

        /**

    29

         * The address length

    30

         */

    31

        socklen_t address_length;

    32

    33

    public:

    34

        /**

    35

         * Construct an empty SockAddr for later update()

    36

         */

    37

        NetworkAddress (void);

    38

    39

        /**

    40

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

    41

         */

    42

        NetworkAddress (const sockaddr *addr, socklen_t len);

    43

    44

        /**

    45

         * Get a const sockaddr* in this address

    46

         *

    47

         * @return read-only sockaddr pointer

    48

         */

    49

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

    50

    51

        /**

    52

         * Get a mutable sockaddr* in this address

    53

         *

    54

         * @return writeable sockaddr pointer

    55

         */

    56

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

    57

    58

        /**

    59

         * Get the current address length

    60

         *

    61

         * @return address length

    62

         */

    63

        socklen_t get_socklen (void) const { return address_length; }

    64

    65

        /**

    66

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

    67

         *

    68

         * @return address length pointer

    69

         */

    70

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

    71

    72

        /**

    73

         * Copy given sockaddr/len + update

    74

         */

    75

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

    76

    77

        /**

    78

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

    79

         */

    80

        void update (void);

    81

    82

        /**

    83

         * Returns a "fake" addrinfo

    84

         */

    85

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

    86

    87

        /**

    88

         * Free an addrinfo returned by get_addrinfo

    89

         */

    90

        virtual void free_addrinfo (addrinfo *info) const;

    91

    92

        /**

    93

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

    94

         */

    95

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

    96

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

    97

        }

    98

    99

        /**

   100

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

   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

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

   108

         */

   109

        bool operator< (const NetworkAddress &other) const {

   110

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

   111

        }

   112

   113

        /**

   114

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

   115

         */

   116

        bool operator> (const NetworkAddress &other) const {

   117

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

   118

        }

   119

};

   120

   121

#endif