1

     2

#include "Socket.hh"

     3

#include "../Engine.hh"

     4

     7

#include <sstream>

     8

    23

{

    25

}

    26

    29

{

    31

}

    32

    33

NetworkSocket::~NetworkSocket (void) {

    34

    // close any remaining socket

    35

    if (fd >= 0)

    36

        force_close();

    41

}

    42

    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

    55

    if (

    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)

    65

    66

    // update our family/type/protocol

    70

}

    71

    72

void NetworkSocket::force_close (void) {

    73

    // use closesocket

    74

    if (::closesocket(fd))

    76

    78

    fd = -1;

    80

}

    81

    82

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

    83

    // get our addrinfo

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

    94

            continue;

    95

        }

    96

    97

        // bind it, warn on errors

    98

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

   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

   113

    freeaddrinfo(results);

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

   127

}

   128

   129

NetworkAddress NetworkSocket::get_local_address (void) {

   130

    sockaddr_storage addr;

   131

    socklen_t addrlen = sizeof(addr);

   132

   133

    // do getsockname()

   134

    if (::getsockname(fd, (sockaddr *) &addr, &addrlen))

   136

   137

    // return addr

   138

    return NetworkAddress((sockaddr *) &addr, addrlen);

   139

}

   140

   141

NetworkAddress NetworkSocket::get_remote_address (void) {

   142

    sockaddr_storage addr;

   143

    socklen_t addrlen = sizeof(addr);

   144

   145

    // do getpeername()

   146

    if (::getpeername(fd, (sockaddr *) &addr, &addrlen))

   148

   149

    // return addr

   150

    return NetworkAddress((sockaddr *) &addr, addrlen);

   151

}

   152

   153

void NetworkSocket::set_nonblocking (bool nonblocking) {

   155

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

   157

}

   158

   159

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

   160

    int new_fd;

   161

    sockaddr_storage addr;

   162

    socklen_t addrlen = sizeof(addr);

   163

   164

    // try and get the FD

   167

   168

    // allocate new NetworkSocket for new_fd

   170

   171

    // update src

   172

    if (src)

   173

        src->set_sockaddr((sockaddr *) &addr, addrlen);    

   174

   175

    // done

   176

    return socket;

   177

}

   178

   179

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

   180

    // get our addrinfo

   182

   183

    // find the right address to bind to

   184

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

   185

        // create socket if needed, warn on errors

   186

        try {

   187

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

   188

   189

        } catch (NetworkSocketError &e) {

   191

            continue;

   192

        }

   193

   194

        // connect it, warn on errors

   195

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

   197

   198

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

   199

            if (!bound)

   200

                force_close();

   201

   202

            continue;

   203

   204

        } else {

   205

            // we have a connected socket, break

   206

            break;

   207

        }

   208

    }

   209

   210

    // release our addrinfo

   211

    freeaddrinfo(results);

   212

   213

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

   214

    if (r == NULL)

   215

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

   216

}

   217

   218

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

   219

    ssize_t ret;

   220

   221

    // use send or sendto?

   222

    if (dest) {

   223

        const sockaddr *addr;

   224

        socklen_t addr_len;

   225

   226

        // get destination address

   227

        addr = dest->get_sockaddr(addr_len);

   228

   229

        // sendto()

   230

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

   232

   233

    } else {

   234

        // send()

   235

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

   237

   238

    }

   239

   240

    // sanity-check

   241

    if (ret == 0) {

   242

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

   243

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

   244

        return 0;

   245

    }

   246

   252

        return 0;

   254

   255

    // return number of bytes sent

   256

    return ret;

   257

}

   258

   259

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

   260

    ssize_t ret;

   261

   262

    // use recv or recvfrom?

   263

    if (src) {

   264

        sockaddr_storage addr;

   265

        socklen_t addr_len = sizeof(addr);

   266

   267

        // recvfrom()

   268

        if ((ret = ::recvfrom(fd, buf, size, 0, (sockaddr *) &addr, &addr_len)) < 0 && errno != EAGAIN)

   270

   276

   277

    } else {

   278

        // recv

   279

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

   281

   282

    }

   283

   284

    // EOF?

   285

    if (ret == 0)

   286

        throw NetworkSocketEOFError(*this, "recv");

   287

   288

    // EAGAIN?

   289

    if (ret < 0)

   290

        return 0;

   291

   292

    // return number of bytes received

   293

    return ret;

   294

}

   295

   296

void NetworkSocket::close (void) {

   297

    // use closesocket

   298

    if (::closesocket(fd))

   300

   302

    fd = -1;

   304

}

   305

   316

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

   317

    std::stringstream ss;

   318

   319

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

   320

   321

    return ss.str();

   322

}

   323

   324

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

   327

    // nothing

   328

}

   329