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

/**

    14

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

    15

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

    16

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

    17

 * getnameinfo() when the address is updated).

    18

 *

    19

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

    20

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

    21

 * required.

    22

 *

    25

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

    26

 * an associated TCP connection.

    27

 */

    28

class NetworkAddress : public NetworkEndpoint {

    29

    protected:

    30

        /**

    31

         * The machine-readable address

    32

         */

    33

        sockaddr_storage address;

    34

    35

        /**

    36

         * The address length

    37

         */

    38

        socklen_t address_length;

    39

    40

    public:

    41

        /**

    42

         * Construct an empty SockAddr for later update()

    43

         */

    44

        NetworkAddress (void);

    45

    46

        /**

    47

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

    48

         */

    49

        NetworkAddress (const sockaddr *addr, socklen_t len);

    50

    51

        /**

    52

         * Get a const sockaddr* in this address

    53

         *

    54

         * @return read-only sockaddr pointer

    55

         */

    56

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

    57

    58

        /**

    59

         * Get a mutable sockaddr* in this address

    60

         *

    61

         * @return writeable sockaddr pointer

    62

         */

    63

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

    64

    65

        /**

    66

         * Get the current address length

    67

         *

    68

         * @return address length

    69

         */

    70

        socklen_t get_socklen (void) const { return address_length; }

    71

    72

        /**

    73

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

    74

         *

    75

         * @return address length pointer

    76

         */

    77

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

    78

    79

        /**

    80

         * Copy given sockaddr/len + update

    81

         */

    82

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

    83

    84

        /**

    85

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

    86

         */

    87

        void update (void);

    88

    89

        /**

    90

         * Returns a "fake" addrinfo

    91

         */

    92

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

    93

    94

        /**

    95

         * Free an addrinfo returned by get_addrinfo

    96

         */

    97

        virtual void free_addrinfo (addrinfo *info) const;

    98

    99

        /**

   100

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

   101

         *

   102

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

   103

         */

   104

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

   105

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

   106

        }

   107

   108

        /**

   109

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

   110

         */

   111

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

   112

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

   113

        }

   114

   115

        /**

   116

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

   117

         */

   118

        bool operator< (const NetworkAddress &other) const {

   119

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

   120

        }

   121

   122

        /**

   123

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

   124

         */

   125

        bool operator> (const NetworkAddress &other) const {

   126

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

   127

        }

   128

};

   129

   130

#endif