1

#ifndef NETWORK_SOCKET_HH

     2

#define NETWORK_SOCKET_HH

     3

     4

// forward-declare

     5

class NetworkSocket;

     6

     7

#include "../Error.hh"

     8

#include "Address.hh"

    10

#include "Reactor.hh"

    11

    12

/*

    13

 * Platform-specific includes

    14

 */

    15

#ifndef WIN32

    16

    // linux

    17

    #include <sys/types.h>

    18

    #include <sys/socket.h>

    19

    #include <unistd.h>

    20

    #include <fcntl.h>

    21

    22

    #define closesocket close

    23

#else

    24

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

    25

#endif

    26

    27

/**

    28

 * We use ClanLib's Socket API, but with our own extensions...

    29

 */

    30

class NetworkSocket {

    31

    private:

    32

        /**

    33

         * Socket family/type/protocol

    34

         */

    35

        struct socket_type {

    36

            /** Socket domain */

    37

            int family;

    38

    39

            /** Socket type */

    40

            int socktype;

    41

    42

            /** Socket protocol */

    43

            int protocol;

    44

    45

            /** Simple constructor */

    46

            socket_type (int family = 0, int socktype = 0, int protocol = 0) : family(family), socktype(socktype), protocol(protocol) { }

    47

        };

    48

    49

        /** These are nonzero if given via the constructor, used to filter out unwanted addrinfos */

    50

        socket_type sock_type;

    51

    52

        /** The file descriptor */

    53

        int fd;

    54

    55

        /** Our current type, intialized via constructor, but updated by lazy_socket */

    56

        socket_type type;

    57

    58

        /** 

    59

         * Has the socket been explicitly bind()'d? If so, force ourselves to use this socket in connect().

    60

         */

    61

        bool bound : 1;

    62

    63

        /**

    64

         * Registered to reactor?

    65

         */

    66

        bool registered : 1;

    67

    68

        /**

    69

         * Do we want to know about recv()s?

    70

         */

    71

        bool want_read : 1;

    72

    73

        /**

    74

         * Is the write buffer full?

    75

         */

    76

        bool want_write : 1;

    77

    78

        /**

    79

         * The reactor that we use, defaults to NetworkReactor::current

    80

         */

    81

        NetworkReactor *reactor;

    82

    83

        /**

    84

         * Read/write signals

    85

         */

    86

        CL_Signal_v0 _sig_read, _sig_write;

    87

    88

    public:

    89

        /**

    90

         * Construct a socket of the specific type. Family and protocol can be left as NULL, but type should usually

    91

         * be specified. The given reactor is used for polling, defaults to NetworkReactor::current

    92

         */

    93

        NetworkSocket (int family, int socktype, int protocol = 0, NetworkReactor *reactor = NULL);

    94

    95

        /**

    96

         * Create a socket from the given pre-existing fd

    97

         */

    98

        NetworkSocket (int fd, socket_type type, NetworkReactor *reactor = NULL);

    99

   100

        /**

   101

         * Force-close the socket if it's still open

   102

         */

   103

        ~NetworkSocket (void);

   104

   105

    private:

   106

        // XXX: nocopy

   107

   108

        /**

   109

         * Reset bound+poll

   110

         */ 

   111

        void reset (void);

   112

   113

        /**

   114

         * Create a new socket of the given type, unless we already have one

   115

         */

   116

        void lazy_socket (int family, int type, int protocol);

   117

   118

        /**

   119

         * Close and reset, ignoring errors

   120

         */

   121

        void force_close (void);

   122

   123

    public:

   124

        /**

   125

         * Get the socket fd... promise not to break it

   126

         */

   127

        int get_socket (void) const { return fd; }

   128

   129

        /**

   130

         * Bind to a specific local address

   131

         */ 

   133

   134

        /**

   135

         * Put socket into listen mode

   136

         */

   137

        void listen (int backlog);

   138

   139

        /**

   140

         * Get local address

   141

         */

   142

        NetworkAddress get_local_address (void); 

   143

   144

        /**

   145

         * Get remote address

   146

         */

   147

        NetworkAddress get_remote_address (void); 

   148

   149

        /**

   150

         * Make send/recv/connect non-blocking

   151

         */

   152

        void set_nonblocking (bool nonblocking);

   153

   154

        /**

   155

         * Accept a new connection, optionally giving the connection's source address

   156

         */

   157

        NetworkSocket* accept (NetworkAddress *src);

   158

   159

        /**

   160

         * Establish a new connection

   161

         */

   163

   164

        /**

   165

         * Send, optionally using the specific destination

   166

         *

   170

         * @return number of bytes sent, zero if busy

   171

         * @throw NetworkSocketError on error

   172

         */

   173

        size_t send (const char *buf, size_t size, const NetworkAddress *dest = NULL);

   174

   175

        /**

   176

         * Recv, optionally storing the source in src

   177

         *

   181

         * @return number of bytes received, zero if none available

   182

         * @throw NetworkSocketEOFError if the connection was closed

   183

         * @throw NetworkSocketError on error

   184

         */

   185

        size_t recv (char *buf, size_t size, NetworkAddress *src = NULL);

   186

   187

        /**

   188

         * Close and reset the socket

   189

         */

   190

        void close (void);

   191

   192

        /**

   193

         * Triggered when socket becomes readable

   194

         */

   195

        CL_Signal_v0& sig_read (void) { return _sig_read; }

   196

   197

        /**

   198

         * Triggered when socket becomes writeable after a send that returned zero

   199

         */

   200

        CL_Signal_v0& sig_write (void) { return _sig_write; }

   201

   202

        /**

   203

         * Register to NetworkReactor unless already registered

   204

         */

   205

        void register_poll (void);

   206

   207

        /**

   208

         * Trigger sig_read() once socket is ready for recv?

   209

         */

   210

        void set_poll_read (bool want_read) { this->want_read = want_read; if (!registered) register_poll(); }

   211

   212

        /**

   213

         * Trigger sig_write() once socket is ready for send?

   214

         */

   215

        void set_poll_write (bool want_write) { this->want_write = want_write; if (!registered) register_poll(); }

   216

   217

        /**

   218

         * What events this socket is interested in.

   219

         */

   220

        NetworkPollMask get_poll (void) { 

   221

            return (want_read ? POLL_READ : 0) | (want_write ? POLL_WRITE : 0); 

   222

        }

   223

   224

        /**

   225

         * Notify of events

   226

         */

   227

        void notify (NetworkPollMask mask) { 

   228

            if (mask & POLL_READ) _sig_read();

   229

            if (mask & POLL_WRITE) _sig_write();

   230

        }

   231

};

   232

   233

/**

   234

 * Base class for expcetions thrown by socket methods

   235

 */

   236

class NetworkSocketError : public Error {

   237

    protected:

   238

        static std::string build_str (const NetworkSocket &socket, const char *op, const char *err);

   239

   240

    public:

   241

        NetworkSocketError (const NetworkSocket &socket, const char *op, const char *err);

   242

};

   243

   244

/**

   245

 * Errno-enabled exception, most common type of NetworkSocketError

   246

 */

   247

class NetworkSocketErrno : public NetworkSocketError {

   248

    public:

   249

        NetworkSocketErrno (const NetworkSocket &socket, const char *op);

   250

};

   251

   252

/**

   253

 * Recv returned EOF

   254

 */

   255

class NetworkSocketEOFError : public NetworkSocketError {

   256

    public:

   257

        NetworkSocketEOFError (const NetworkSocket &socket, const char *op) :

   258

            NetworkSocketError(socket, op, "EOF") { }

   259

};

   260

   261

#endif /* NETWORK_SOCKET_HH */