1

#ifndef NETWORK_ENDPOINT_HH

     2

#define NETWORK_ENDPOINT_HH

     3

     4

/**

     5

 * @file

     6

 *

     7

 * Textual NetworkEndpoint addresses

     8

 */

     9

    10

#include "../Error.hh"

    11

#include "Platform.hh"

    12

    13

#include <string>

    14

    15

// assume...

    16

#if INET6_ADDRSTRLEN < INET_ADDRSTRLEN

    17

    #error INET6_ADDRSTRLEN is smaller than INET_ADDRSTRLEN

    18

#endif

    19

    20

/**

    21

 * Length of a network address in text form

    22

 */

    23

const socklen_t NETWORK_ADDRESS_LENGTH = INET6_ADDRSTRLEN;

    24

    25

/**

    26

 * NetworkEndpoint is mostly used to pass addresses from the (human) user to NetworkSocket's bind()/connect(). The 

    27

 * constructor accepts a textual service name (port) and hostname (literal IP adddress or hostname), and can then

    28

 * provide a list of resolved addresses for use by NetworkSocket (using the libc getaddrinfo). Additionally,

    29

 * methods/operators are defined for textual output of the address.

    30

 *

    31

 * It may be of value to note that the hostname/service is only interpreted by the get_addrinfo() method, which means

    32

 * that invalid/non-existant hostnames/services will only raise an error once the NetworkEndpoint is passed to

    33

 * NetworkSocket.

    34

 *

    35

 * All DNS lookups are blocking.

    36

 */ 

    37

class NetworkEndpoint {

    38

    protected:

    39

        /**

    40

         * Our human-readable hostname

    41

         */

    42

        std::string hostname;

    43

    44

        /**

    45

         * Our human-readable service

    46

         */

    47

        std::string service;

    48

    49

    public:

    50

        /**

    51

         * Construct an empty NetworkEndpoint

    52

         */

    53

        NetworkEndpoint (void);

    54

    55

        /**

    56

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

    57

         */

    58

        explicit NetworkEndpoint (std::string service);

    59

    60

        /**

    61

         * Construct a NetworkEndpoint on a specific hostname and service

    62

         */

    63

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

    64

    65

        /*

    66

         * We can use the default copy-constructor and assignment operator

    67

         */

    68

    69

    public:    

    70

        /**

    71

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

    72

         *

    73

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

    74

         *

    75

         * @param family the socket family for hints.ai_family

    76

         * @param socktype the socket type for hints.ai_socktype

    77

         * @param protoocl the socket protocol for hints.ai_protocol

    78

         * @param flags the flags for hints.ai_flags

    79

         * @return linked list of addrinfo's

    80

         * @throw NetworkAddressError if resolving this address fails

    81

         */

    82

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

    83

    84

        /**

    85

         * Free an addrinfo returned by get_addrinfo

    86

         */

    87

        virtual void free_addrinfo (addrinfo *info) const;

    88

    89

        /**

    90

         * Get the human-readable hostname

    91

         */

    92

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

    93

    94

        /**

    95

         * Get the human-readable service name

    96

         */

    97

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

    98

};

    99

   100

/**

   101

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

   102

 */

   103

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

   104

   105

/**

   106

 * Errors raised by NetworkEndpoint, so e.g. DNS errors (hostname not found etc.)

   107

 */

   108

class NetworkAddressError : public Error {

   109

    protected:

   110

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

   111

   112

    public:

   113

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

   114

};

   115

   116

#endif /* NETWORK_ADDRESS_HH */