1

#ifndef NETWORK_ADDRESS_H

     2

#define NETWORK_ADDRESS_H

     3

     4

/**

     5

 * @file

     6

 *

     7

 * Binary NetworkAddress

     8

 */

     9

    10

#include "Platform.hh"

    11

#include "Endpoint.hh"

    12

    13

#include <cstring>

    14

    15

/**

    16

 * A NetworkAddress represents a single network address in the form of a `struct sockaddr`, as used by the OS's socket

    17

 * API. A NetworkAddress's value may only be constructed/manipulated in sockaddr form, and the class then emulates the

    18

 * get_addrinfo (by building our own addrinfo struct value) and get_hostname()/get_service() (by using libc's

    19

 * getnameinfo() when the address is updated).

    20

 *

    21

 * This means that a NetworkAddress can be used like a NetworkEndpoint (like a literal IP address), but can also be

    22

 * used in a more specifc fashion like NetworkSocket::send or NetworkSocket::accept, where a definitive address is

    23

 * required.

    24

 *

    25

 * The update() method does a blocking reverse-DNS lookup. XXX: only do the reverse lookup if get_hostname is called?

    26

 *

    27

 * XXX: currently, there is no way to form a NetworkAddress from a NetworkEndpoint for e.g. sending UDP packets without

    28

 * an associated TCP connection.

    29

 */

    30

class NetworkAddress : public NetworkEndpoint {

    31

    protected:

    32

        /**

    33

         * The machine-readable address

    34

         */

    35

        sockaddr_storage address;

    36

    37

        /**

    38

         * The address length

    39

         */

    40

        socklen_t address_length;

    41

    42

    public:

    43

        /**

    44

         * Construct an empty SockAddr for later update()

    45

         */

    46

        NetworkAddress (void);

    47

    48

        /**

    49

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

    50

         */

    51

        NetworkAddress (const sockaddr *addr, socklen_t len);

    52

    53

        /**

    54

         * Get a const sockaddr* in this address

    55

         *

    56

         * @return read-only sockaddr pointer

    57

         */

    58

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

    59

    60

        /**

    61

         * Get a mutable sockaddr* in this address

    62

         *

    63

         * @return writeable sockaddr pointer

    64

         */

    65

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

    66

    67

        /**

    68

         * Get the current address length

    69

         *

    70

         * @return address length

    71

         */

    72

        socklen_t get_socklen (void) const { return address_length; }

    73

    74

        /**

    75

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

    76

         *

    77

         * @return address length pointer

    78

         */

    79

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

    80

    81

        /**

    82

         * Copy given sockaddr/len + update

    83

         */

    84

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

    85

    86

        /**

    87

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

    88

         */

    89

        void update (void);

    90

    91

        /**

    92

         * Returns a "fake" addrinfo

    93

         */

    94

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

    95

    96

        /**

    97

         * Free an addrinfo returned by get_addrinfo

    98

         */

    99

        virtual void free_addrinfo (addrinfo *info) const;

   100

   101

        /**

   102

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

   103

         *

   104

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

   105

         */

   106

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

   107

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

   108

        }

   109

   110

        /**

   111

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

   112

         */

   113

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

   114

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

   115

        }

   116

   117

        /**

   118

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

   119

         */

   120

        bool operator< (const NetworkAddress &other) const {

   121

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

   122

        }

   123

   124

        /**

   125

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

   126

         */

   127

        bool operator> (const NetworkAddress &other) const {

   128

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

   129

        }

   130

};

   131

   132

#endif