1

#ifndef NETWORK_SOCKET_HH

     2

#define NETWORK_SOCKET_HH

     3

     7

#include "../Error.hh"

     8

#include "Address.hh"

    10

    11

/*

    12

 * Platform-specific includes

    13

 */

    14

#ifndef WIN32

    15

    // linux

    16

    #include <sys/types.h>

    17

    #include <sys/socket.h>

    18

    #include <unistd.h>

    19

    #include <fcntl.h>

    20

    21

    #define closesocket close

    22

#else

    23

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

    24

#endif

    25

    26

/**

    27

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

    28

 */

    29

class NetworkSocket {

    30

    private:

    51

        /** The file descriptor */

    52

        int fd;

    53

    56

    57

        /** 

    58

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

    59

         */

    81

    82

        /**

    83

         * Read/write signals

    84

         */

    85

        CL_Signal_v0 _sig_read, _sig_write;

    86

    87

    public:

    88

        /**

    89

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

    91

         */

    93

    94

        /**

    95

         * Create a socket from the given pre-existing fd

    96

         */

    98

    99

        /**

   100

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

   101

         */

   102

        ~NetworkSocket (void);

   103

   104

    private:

   105

        // XXX: nocopy

   106

   107

        /**

   113

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

   114

         */

   115

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

   116

   117

        /**

   119

         */

   120

        void force_close (void);

   121

   122

    public:

   123

        /**

   124

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

   125

         */

   126

        int get_socket (void) const { return fd; }

   127

   128

        /**

   129

         * Bind to a specific local address

   130

         */ 

   131

        void bind (const NetworkAddress &addr);

   132

   133

        /**

   134

         * Put socket into listen mode

   135

         */

   136

        void listen (int backlog);

   137

   138

        /**

   139

         * Get local address

   140

         */

   141

        NetworkAddress get_local_address (void); 

   142

   143

        /**

   144

         * Get remote address

   145

         */

   146

        NetworkAddress get_remote_address (void); 

   147

   148

        /**

   149

         * Make send/recv/connect non-blocking

   150

         */

   151

        void set_nonblocking (bool nonblocking);

   152

   153

        /**

   154

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

   155

         */

   156

        NetworkSocket* accept (NetworkAddress *src);

   157

   158

        /**

   159

         * Establish a new connection

   160

         */

   161

        void connect (const NetworkAddress &addr);

   162

   163

        /**

   164

         * Send, optionally using the specific destination

   165

         *

   166

         * @return number of bytes sent, zero if busy

   167

         * @throw NetworkSocketError on error

   168

         */

   169

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

   170

   171

        /**

   172

         * Recv, optionally storing the source in src

   173

         *

   174

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

   175

         * @throw NetworkSocketEOFError if the connection was closed

   176

         * @throw NetworkSocketError on error

   177

         */

   178

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

   179

   180

        /**

   182

         */

   183

        void close (void);

   184

   185

        /**

   186

         * Triggered when socket becomes readable

   187

         */

   188

        CL_Signal_v0& sig_read (void) { return _sig_read; }

   189

   190

        /**

   191

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

   192

         */

   193

        CL_Signal_v0& sig_write (void) { return _sig_write; }

   224

};

   225

   226

/**

   227

 * Base class for expcetions thrown by socket methods

   228

 */

   229

class NetworkSocketError : public Error {

   230

    protected:

   231

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

   232

   233

    public:

   234

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

   235

};

   236

   237

/**

   238

 * Errno-enabled exception, most common type of NetworkSocketError

   239

 */

   241

    public:

   243

};

   244

   245

/**

   246

 * Recv returned EOF

   247

 */

   248

class NetworkSocketEOFError : public NetworkSocketError {

   249

    public:

   250

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

   251

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

   252

};

   253

   254

#endif /* NETWORK_SOCKET_HH */