common/socklistener.cc

Go to the documentation of this file.

extern "C" {
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <netinet/in.h>
}

#include <sstream>
#include <typeinfo>

#include "consmgr.h"
#include "socklistener.h"
#include "fdconnector.h"
#include "guard.h"

SocketListener::SocketListener(SocketAddressP &addr)
        : sock_addr(addr)
{
    // Instantiate our mutex
    Guard::initialize_mutex(mutex);
    MUTEX_LOG("initialized mutex " << &mutex);

#warning "SocketListener is calling make_incoming_socket() before the object is fully constructed.  Subclasses will never have their make_incoming_socket invoked!"
    // Allocate the socket on which we will await connections
    sock_fd = make_incoming_socket();
}

SocketListener::~SocketListener()
{
    // Call disconnect() to do any cleanup/closedown.
    disconnect();

    // Destroy our mutex
    MUTEX_LOG("destroying mutex " << &mutex);
    Guard::destroy_mutex(mutex);
}

void
SocketListener::disconnect()
{
    MUTEX_LOG("SocketListener::disconnect() locking mutex " << &mutex);
    Guard       locker(&mutex);

    if (sock_fd != -1) {
        close(sock_fd);
        sock_fd = -1;
    }
    MUTEX_LOG("SocketListener::disconnect() unlocking mutex " << &mutex << " upon return");
}

int
SocketListener::make_incoming_socket(void)
{
    // XXX - Is locking this mutex really necessary? We just return the new
    // socket fd, and we don't change our internal state, so perhaps we don't
    // need to lock it at all. The only thing we do is change *external*
    // state; the creation and listening on a socket, and we don't even check
    // to see whether we've already done that. So, I don't think this mutex
    // locking actually buys us anything at all at the moment.
    MUTEX_LOG("SocketListener::make_incoming_socket() locking mutex " << &mutex);
    Guard       locker(&mutex);

    // Open a socket fd of the right family
    int new_s = ::socket(sock_addr->family(), SOCK_STREAM, 0);
    if (new_s < 0)
        throw(CMFailure("socket(2) call in "
                        "SocketListener::make_incoming_socket", true));

    // Bind it to the SocketAddress we were given at construction
    if (::bind(new_s, sock_addr->get_addr(), sock_addr->length()) < 0) {
        clog << "Thread id " << pthread_self() << " throwing bind(2) failure"
             << endl;
        throw(CMFailure("bind(2) call in "
                        "SocketListener::make_incoming_socket", true));
    }
    
    // Indicate an intention to accept connections
    ::listen(new_s, 1);         // XXX - should we use more than 1 here?

    clog << this->get_id() << " fd#" << new_s << " bound, ready to accept()"
         << endl;

    MUTEX_LOG("SocketListener::make_incoming_socket() unlocking mutex " << &mutex << " upon return");
    // And, return the new configured fd to our caller
    return new_s;
}

ConnectorP
SocketListener::listen_for_incoming(void)
{
    int                 s;
    FDConnector         *new_sc;
#if 0
    sockaddr            *other;
    socklen_t           other_len;
#endif

    if (sock_fd < 0)
        throw(CMUnsupported("Unable to listen for incoming connection; no socket available."));

    MUTEX_LOG("SocketListener::listen_for_incoming() locking mutex " << &mutex);
    Guard               locker(&mutex);
    int                 ret, prev_canceltype;
    
    /* Set thread cancellability */
    ret = pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &prev_canceltype);
    PTHREAD_CHECK_AND_THROW(ret,"pthread_setcanceltype");
#if 0
    // Use the "right" sockaddr...
    switch (sock_addr->family()) {
      case AF_LOCAL:
        other = (sockaddr *)new sockaddr_un;
        break;
      case AF_INET:
        other = (sockaddr *)new sockaddr_in;
        break;
#ifdef INET6
      case AF_INET6:
        other = (sockaddr *)new sockaddr_in6;
        break;
#endif
      default:
        throw(fireball(17, "Ugh.  Unknown socket address family in SocketListener::listen_for_incoming()"));
        break;
    }

    try {
        // ::accept() will block (with nutex locked) until
        // a new connection comes in.
        clog << "Calling accept(" << sock_fd << ") ... " << std::flush;
        if ((s = ::accept(sock_fd, other, &other_len)) < 0) {
#else
    try {
        // ::accept() will block (with nutex locked) until
        // a new connection comes in.
        clog << "Calling accept(" << sock_fd << ") ... " << std::flush;
        if ((s = ::accept(sock_fd, NULL, NULL)) < 0) {
#endif
            clog << "error from ::accept!  What do we do?!?" << endl;
            sleep(2);
            throw(fireball(15, "SocketListener::listen_for_incoming accept", true));
        }
        clog << "back from accept, returned fd " << s << endl;
    } catch (std::exception &e) {
        clog << "Got an exception (" << typeid(&e).name() << "): " << e.what() << endl;
        pthread_setcanceltype(prev_canceltype, NULL);
        throw;
    } catch (...) {
        cerr << "Caught an unknown exception from ::accept, rethrowing" << endl;
        pthread_setcanceltype(prev_canceltype, NULL);
        throw;
    }
    pthread_setcanceltype(prev_canceltype, NULL);

    // Excellent!  We have a connection!  Create a new Connector to manage
    // the connection we've just established...
    new_sc = new FDConnector(s);

    if (!new_sc) {
        throw (fireball(29, "Ack!  Unable to allocate a new FDConnector!"));
    }
    clog << this->get_id() << " spawned a new Connector: " << new_sc << ": "
         << new_sc->get_id() << endl;

    MUTEX_LOG("SocketListener::listen_for_incoming() unlocking mutex " << &mutex<< " upon return");
    // Return this new Connection to our caller.  It's ready to have it's
    // manager turned on, but we'll let the caller do that so it can keep
    // the pthread_t for it...
    return (ConnectorP(new_sc));
}

std::string
SocketListener::get_id(void) const
{
    std::ostringstream  id_str;

    id_str << "SocketListener[" << sock_addr->get_id() << "]";
    // XXX - Should we include the fd (sock_fd) if one has been set?

    return(id_str.str());
}

---