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) :

    26

{

    28

}

    29

    30

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

    35

{

    37

}

    38

    39

NetworkSocket::~NetworkSocket (void) {

    40

    // close any remaining socket

    41

    if (fd >= 0)

    42

        force_close();

    43

    44

    // unregister from reactor?

    45

    if (registered)

    46

        reactor->remove_socket(this);

    47

}

    48

    49

void NetworkSocket::reset (void) {

    51

    bound = false;

    52

}

    53

    54

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

    55

    // if we already have a socket, good

    56

    // XXX: should we check family/socktype/protocol against sock_type?

    57

    if (fd >= 0)

    58

        return;

    59

    60

    // ignore if we've requested a specific sock_type

    61

    if (

    62

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

    63

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

    64

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

    65

    )

    66

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

    67

    68

    // create the socket or fail

    69

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

    70

        throw NetworkSocketErrno(*this, "socket");

    71

    72

    // update our family/type/protocol

    73

    type.family = family;

    74

    type.socktype = socktype;

    75

    type.protocol = protocol;

    76

}

    77

    78

void NetworkSocket::force_close (void) {

    79

    // use closesocket

    80

    if (::closesocket(fd))

    81

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

    82

    84

    reset();

    85

}

    86

    87

void NetworkSocket::bind (const NetworkEndpoint &addr) {

    88

    // get our addrinfo

    89

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

    90

    91

    // find the right address to bind to

    92

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

    93

        // create socket if needed, warn on errors

    94

        try {

    95

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

    96

    97

        } catch (NetworkSocketError &e) {

    98

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

    99

            continue;

   100

        }

   101

   102

        // bind it, warn on errors

   103

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

   104

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

   105

   106

            // close the bad socket

   107

            force_close();

   108

   109

            continue;

   110

   111

        } else {

   112

            // we have a bound socket, break

   113

            break;

   114

        }

   115

    }

   116

   117

    // release our addrinfo

   118

    addr.free_addrinfo(results);

   119

   120

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

   121

    if (r == NULL)

   122

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

   123

   124

    // mark ourselves as bound

   125

    bound = true;

   126

}

   127

   128

void NetworkSocket::listen (int backlog) {

   129

    // just call listen

   130

    if (::listen(fd, backlog))

   131

        throw NetworkSocketErrno(*this, "listen");

   132

}

   133

   134

NetworkAddress NetworkSocket::get_local_address (void) {

   135

    NetworkAddress addr;

   136

   137

    // do getsockname()

   138

    if (::getsockname(fd, addr.get_sockaddr(), addr.get_socklen_ptr()))

   139

        throw NetworkSocketErrno(*this, "getsockname");

   140

   142

    addr.update();

   143

   144

    return addr;

   145

}

   146

   147

NetworkAddress NetworkSocket::get_remote_address (void) {

   148

    NetworkAddress addr;

   149

   150

    // do getpeername()

   151

    if (::getpeername(fd, addr.get_sockaddr(), addr.get_socklen_ptr()))

   152

        throw NetworkSocketErrno(*this, "getpeername");

   153

   155

    addr.update();

   156

   157

    return addr;

   158

}

   159

   160

void NetworkSocket::set_nonblocking (bool nonblocking) {

   161

    // linux-specific

   162

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

   163

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

   164

}

   165

   166

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

   167

    int new_fd;

   168

   169

    // try and get the FD

   170

    // pass src sock* pointers if provided

   171

    if ((new_fd = ::accept(

   172

            fd, 

   173

            src ? src->get_sockaddr() : NULL,

   174

            src ? src->get_socklen_ptr() : NULL

   175

    )) < 0)

   176

        throw NetworkSocketErrno(*this, "accept");

   177

   178

    // allocate new NetworkSocket for new_fd

   179

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

   180

   181

    // update src

   182

    if (src)

   183

        src->update();

   184

   185

    return socket;

   186

}

   187

   188

void NetworkSocket::connect (const NetworkEndpoint &addr) {

   189

    // get our addrinfo

   190

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

   191

   192

    // find the right address to bind to

   193

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

   194

        // create socket if needed, warn on errors

   195

        try {

   196

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

   197

   198

        } catch (NetworkSocketError &e) {

   199

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

   200

            continue;

   201

        }

   202

   203

        // connect it, warn on errors

   204

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

   205

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

   206

   207

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

   208

            if (!bound)

   209

                force_close();

   210

   211

            continue;

   212

   213

        } else {

   214

            // we have a connected socket, break

   215

            break;

   216

        }

   217

    }

   218

   219

    // release our addrinfo

   220

    addr.free_addrinfo(results);

   221

   222

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

   223

    if (r == NULL)

   224

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

   225

}

   226

   227

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

   228

    ssize_t ret;

   229

   230

    // use send or sendto?

   231

    if (dest) {

   232

        // sendto()

   233

        if ((ret = ::sendto(fd, buf, size, 0, dest->get_sockaddr(), dest->get_socklen())) < 0 && errno != EAGAIN)

   234

            throw NetworkSocketErrno(*this, "sendto");

   235

   236

    } else {

   237

        // send()

   238

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

   239

            throw NetworkSocketErrno(*this, "send");

   240

   241

    }

   242

   243

    // sanity-check

   244

    if (ret == 0) {

   245

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

   246

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

   247

        return 0;

   248

    }

   249

   250

    // EAGAIN? 

   251

    if (ret < 0) {

   252

        // set want_write so we get a sig_write

   253

        // XXX: this is the job of the user

   254

        // want_write = true;

   255

   256

        return 0;

   257

    }

   258

   259

    // return number of bytes sent

   260

    return ret;

   261

}

   262

   263

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

   264

    ssize_t ret;

   265

   266

    // use recv or recvfrom?

   267

    if (src) {

   268

        // recvfrom()

   269

        if ((ret = ::recvfrom(fd, buf, size, 0, src->get_sockaddr(), src->get_socklen_ptr())) < 0 && errno != EAGAIN)

   270

            throw NetworkSocketErrno(*this, "recvfrom");

   271

   272

        // update if valid

   273

        if (ret > 0)

   274

            src->update();

   275

   276

    } else {

   277

        // recv

   278

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

   279

            throw NetworkSocketErrno(*this, "recv");

   280

   281

    }

   282

   283

    // EOF?

   284

    if (ret == 0)

   285

        throw NetworkSocketEOFError(*this, "recv");

   286

   287

    // EAGAIN?

   288

    if (ret < 0)

   289

        return 0;

   290

   291

    // return number of bytes received

   292

    return ret;

   293

}

   294

   295

void NetworkSocket::close (void) {

   296

    // use closesocket

   297

    if (::closesocket(fd))

   298

        throw NetworkSocketErrno(*this, "close");

   299

   301

    reset();

   302

}

   303

   304

void NetworkSocket::register_poll (void) { 

   305

    if (registered) return; 

   306

   307

    reactor->add_socket(this); 

   308

    registered = true; 

   309

}

   310

   311

/*

   312

 * NetworkSocketError

   313

 */

   314

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

   315

    std::stringstream ss;

   316

   317

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

   318

   319

    return ss.str();

   320

}

   321

   322

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

   323

    Error(build_str(socket, op, err)) 

   324

{

   325

    // nothing

   326

}

   327

   328

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

   329

    NetworkSocketError(socket, op, strerror(errno)) 

   330

{ 

   331

   332

}

   333