1

     2

#include "Socket.hh"

     3

#include "../Engine.hh"

     4

     5

#include <cerrno>

     6

#include <cstring>

     7

#include <sstream>

     8

     9

static std::string dump_addrinfo (addrinfo *r) {

    10

    std::stringstream ss;

    11

    12

    ss << "ai_family=" << r->ai_family << ", ai_canonname=" << r->ai_canonname << ": " << strerror(errno);

    13

    14

    return ss.str();

    15

}

    16

    17

static std::string dump_errno (void) {

    18

    return std::string(strerror(errno));

    19

}

    20

    21

NetworkSocket::NetworkSocket (int family, int socktype, int protocol, NetworkReactor *reactor) :

    22

    sock_type(family, socktype, protocol), fd(-1), type(family, socktype, protocol), registered(0), reactor(reactor ? reactor : NetworkReactor::current)

    23

{

    24

    reset();

    25

}

    26

    27

NetworkSocket::NetworkSocket (int fd, socket_type type, NetworkReactor *reactor) :

    28

    sock_type(type), fd(fd), type(type), registered(0), reactor(reactor ? reactor : NetworkReactor::current)

    29

{

    30

    reset();

    31

}

    32

    33

NetworkSocket::~NetworkSocket (void) {

    34

    // close any remaining socket

    35

    if (fd >= 0)

    36

        force_close();

    37

    38

    // unregister from reactor?

    39

    if (registered)

    40

        reactor->remove_socket(this);

    41

}

    42

    43

void NetworkSocket::reset (void) {

    44

    bound = false;

    45

    want_read = false;

    46

    want_write = false;

    47

}

    48

    49

void NetworkSocket::lazy_socket (int family, int socktype, int protocol) {

    50

    // if we already have a socket, exit

    51

    if (fd >= 0)

    52

        return;

    53

    54

    // ignore if we've requested a specific sock_type

    55

    if (

    56

        (sock_type.family && family != sock_type.family) || 

    57

        (sock_type.socktype && socktype != sock_type.socktype) || 

    58

        (sock_type.protocol && protocol != sock_type.protocol)

    59

    )

    60

        throw NetworkSocketError(*this, "socket.create", "family/socktype/protocol mismatch");

    61

    62

    // create the socket or fail

    63

    if ((fd = ::socket(family, socktype, protocol)) < 0)

    64

        throw NetworkSocketErrno(*this, "socket");

    65

    66

    // update our family/type/protocol

    67

    type.family = family;

    68

    type.socktype = socktype;

    69

    type.protocol = protocol;

    70

}

    71

    72

void NetworkSocket::force_close (void) {

    73

    // use closesocket

    74

    if (::closesocket(fd))

    75

        Engine::log(WARN, "socket.force_close") << "error closing socket: " << dump_errno();

    76

    77

    // reset state

    78

    fd = -1;

    79

    reset();

    80

}

    81

    83

    // get our addrinfo

    84

    addrinfo *r, *results = addr.get_addrinfo(type.family, type.socktype, type.protocol, AI_PASSIVE);

    85

    86

    // find the right address to bind to

    87

    for (r = results; r; r = r->ai_next) {

    88

        // create socket if needed, warn on errors

    89

        try {

    90

            lazy_socket(r->ai_family, r->ai_socktype, r->ai_protocol);

    91

    92

        } catch (NetworkSocketError &e) {

    93

            Engine::log(WARN, "socket.bind") << "unable to create socket for " << dump_addrinfo(r) << ": " << e.what();

    94

            continue;

    95

        }

    96

    97

        // bind it, warn on errors

    98

        if (::bind(fd, r->ai_addr, r->ai_addrlen)) {

    99

            Engine::log(WARN, "socket.bind") << "unable to bind on " << dump_addrinfo(r) << ": " << dump_errno();

   100

   101

            // close the bad socket

   102

            force_close();

   103

   104

            continue;

   105

   106

        } else {

   107

            // we have a bound socket, break

   108

            break;

   109

        }

   110

    }

   111

   112

    // release our addrinfo

   114

   115

    // if we failed to bind, r is a NULL pointer

   116

    if (r == NULL)

   117

        throw NetworkSocketError(*this, "bind", "unable to bind on any addresses");

   118

   119

    // mark ourselves as bound

   120

    bound = true;

   121

}

   122

   123

void NetworkSocket::listen (int backlog) {

   124

    // just call listen

   125

    if (::listen(fd, backlog))

   126

        throw NetworkSocketErrno(*this, "listen");

   127

}

   128

   129

NetworkAddress NetworkSocket::get_local_address (void) {

   131

   132

    // do getsockname()

   134

        throw NetworkSocketErrno(*this, "getsockname");

   135

   139

    // return addr

   141

}

   142

   143

NetworkAddress NetworkSocket::get_remote_address (void) {

   145

   146

    // do getpeername()

   148

        throw NetworkSocketErrno(*this, "getpeername");

   149

   153

    // return addr

   155

}

   156

   157

void NetworkSocket::set_nonblocking (bool nonblocking) {

   158

    // linux-specific

   159

    if (fcntl(fd, F_SETFL, O_NONBLOCK, nonblocking ? 1 : 0) == -1)

   160

        throw NetworkSocketErrno(*this, "fcntl(F_SETFL, O_NONBLOCK)");

   161

}

   162

   163

NetworkSocket* NetworkSocket::accept (NetworkAddress *src) {

   164

    int new_fd;

   165

   166

    // try and get the FD

   173

        throw NetworkSocketErrno(*this, "accept");

   174

   175

    // allocate new NetworkSocket for new_fd

   176

    NetworkSocket *socket = new NetworkSocket(new_fd, type, reactor);

   177

   178

    // update src

   179

    if (src)

   181

   182

    // done

   183

    return socket;

   184

}

   185

   187

    // get our addrinfo

   188

    addrinfo *r, *results = addr.get_addrinfo(type.family, type.socktype, type.protocol);

   189

   190

    // find the right address to bind to

   191

    for (r = results; r; r = r->ai_next) {

   192

        // create socket if needed, warn on errors

   193

        try {

   194

            lazy_socket(r->ai_family, r->ai_socktype, r->ai_protocol);

   195

   196

        } catch (NetworkSocketError &e) {

   197

            Engine::log(WARN, "socket.connect") << "unable to create socket for " << dump_addrinfo(r) << ": " << e.what();

   198

            continue;

   199

        }

   200

   201

        // connect it, warn on errors

   202

        if (::connect(fd, r->ai_addr, r->ai_addrlen)) {

   203

            Engine::log(WARN, "socket.connect") << "unable to connect to " << dump_addrinfo(r) << ": " << dump_errno();

   204

   205

            // close unless bound, to not keep invalid sockets hanging around

   206

            if (!bound)

   207

                force_close();

   208

   209

            continue;

   210

   211

        } else {

   212

            // we have a connected socket, break

   213

            break;

   214

        }

   215

    }

   216

   217

    // release our addrinfo

   219

   220

    // if we failed to connect, r is a NULL pointer

   221

    if (r == NULL)

   222

        throw NetworkSocketError(*this, "connect", "unable to connect to any addresses");

   223

}

   224

   225

size_t NetworkSocket::send (const char *buf, size_t size, const NetworkAddress *dest) {

   226

    ssize_t ret;

   227

   228

    // use send or sendto?

   229

    if (dest) {

   230

        // sendto()

   232

            throw NetworkSocketErrno(*this, "sendto");

   233

   234

    } else {

   235

        // send()

   236

        if ((ret = ::send(fd, buf, size, 0)) < 0 && errno != EAGAIN)

   237

            throw NetworkSocketErrno(*this, "send");

   238

   239

    }

   240

   241

    // sanity-check

   242

    if (ret == 0) {

   243

        // XXX: not sure what this means...

   244

        Engine::log(ERROR, "socket.send") << "send[to] returned zero, trying again...";

   245

        return 0;

   246

    }

   247

   248

    // EAGAIN? 

   249

    if (ret < 0) {

   250

        // set want_write so we get a sig_write

   251

        want_write = true;

   252

   253

        return 0;

   254

    }

   255

   256

    // return number of bytes sent

   257

    return ret;

   258

}

   259

   260

size_t NetworkSocket::recv (char *buf, size_t size, NetworkAddress *src) {

   261

    ssize_t ret;

   262

   263

    // use recv or recvfrom?

   264

    if (src) {

   265

        // recvfrom()

   267

            throw NetworkSocketErrno(*this, "recvfrom");

   272

   273

    } else {

   274

        // recv

   275

        if ((ret = ::recv(fd, buf, size, 0)) < 0 && errno != EAGAIN)

   276

            throw NetworkSocketErrno(*this, "recv");

   277

   278

    }

   279

   280

    // EOF?

   281

    if (ret == 0)

   282

        throw NetworkSocketEOFError(*this, "recv");

   283

   284

    // EAGAIN?

   285

    if (ret < 0)

   286

        return 0;

   287

   288

    // return number of bytes received

   289

    return ret;

   290

}

   291

   292

void NetworkSocket::close (void) {

   293

    // use closesocket

   294

    if (::closesocket(fd))

   295

        throw NetworkSocketErrno(*this, "close");

   296

   297

    // reset

   298

    fd = -1;

   299

    reset();

   300

}

   301

   302

void NetworkSocket::register_poll (void) { 

   303

    if (registered) return; 

   304

   305

    reactor->add_socket(this); 

   306

    registered = true; 

   307

}

   308

   309

/*

   310

 * NetworkSocketError

   311

 */

   312

std::string NetworkSocketError::build_str (const NetworkSocket &socket, const char *op, const char *err) {

   313

    std::stringstream ss;

   314

   315

    ss << "socket #" << socket.get_socket() << " " << op << ": " << err;

   316

   317

    return ss.str();

   318

}

   319

   320

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

   321

    Error(build_str(socket, op, err)) 

   322

{

   323

    // nothing

   324

}

   325

   326

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

   327

    NetworkSocketError(socket, op, strerror(errno)) 

   328

{ 

   329

   330

}

   331