libplumbing/endpoint.cc

Go to the documentation of this file.

//
// plumbing - C++ wrapper facades for Berkeley sockets
// Copyright (C) 2009, 2010 Peter Miller
//
// This program is free software; you can redistribute it and/or modify it
// under the terms of the GNU General Public License, version 3, as published
// by the Free Software Foundation.
//
// This program is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
// more details.
//
// You should have received a copy of the GNU General Public License along with
// this program. If not, see <http://www.gnu.org/licenses/>.
//

#include <libplumbing/config.h>
#include <cassert>
#include <cerrno>
#include <cstring>
#include <arpa/inet.h>
#include <netdb.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <libexplain/close.h>
#include <libexplain/getpeername.h>

#include <libplumbing/reactor.h>
#include <libplumbing/endpoint.h>
#include <libplumbing/logging.h>
#include <libplumbing/time_value.h>


plumbing::endpoint::~endpoint()
{
    close();
}


void
plumbing::endpoint::close()
{
    for (;;)
    {
        if (::close(fd) == 0)
            break;
        if (errno == EBADF)
            break;
        log().warning("%s", explain_errno_close(errno, fd));
        usleep(10);
    }
    fd = -1;
}


plumbing::endpoint::endpoint(int a_fd) :
    fd(a_fd),
    ready_to_die(false)
{
    // Get the details of the other end.
    set_peer_name();
}


plumbing::endpoint::endpoint(int a_fd, const void *sadr, int sadr_len) :
    fd(a_fd),
    ready_to_die(false)
{
    // Get the details of the other end.
    set_peer_name(sadr, sadr_len);
}


void
plumbing::endpoint::set_peer_name(const char *s)
{
    if (s && *s)
        peer_name = s;
}


void
plumbing::endpoint::set_peer_name(const std::string &s)
{
    if (!s.empty())
        peer_name = s;
}


void
plumbing::endpoint::set_peer_name(const void *addr_p, int addr_len)
{
    if (addr_len != sizeof(sockaddr_in))
        return;
    sockaddr_in *addr = (sockaddr_in *)addr_p;
    in_addr_t *ap = &addr->sin_addr.s_addr;
    hostent *he = gethostbyaddr(ap, sizeof(*ap), AF_INET);
    if (!he)
    {
        set_peer_name(inet_ntoa(addr->sin_addr));
        return;
    }
    set_peer_name(he->h_name);
}


void
plumbing::endpoint::set_peer_name()
{
    if (fd < 0)
        return;
    struct sockaddr_in sa;
    memset(&sa, 0, sizeof(sa));
    unsigned sa_len = sizeof(sa);
    if (getpeername(fd, (struct sockaddr *)&sa, &sa_len))
    {
        if (errno != ENOTSOCK)
        {
            warning
            (
                "%s",
                explain_errno_getpeername
                (
                    errno,
                    fd,
                    (struct sockaddr *)&sa,
                    &sa_len
                )
            );
        }
    }
    set_peer_name(&sa, sa_len);
}


bool
plumbing::endpoint::is_ready_to_die()
    const
{
    return ready_to_die;
}


void
plumbing::endpoint::kill_me_now()
{
    ready_to_die = true;
}


int
plumbing::endpoint::get_read_file_descriptor()
{
    return fd;
}


int
plumbing::endpoint::get_write_file_descriptor()
{
    return -1;
}


void
plumbing::endpoint::process_read()
{
    assert(!"derived class must override this method");
}


void
plumbing::endpoint::process_write()
{
    assert(!"derived class must override this method");
}


void
plumbing::endpoint::fatal_error(const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
    fatal_error_v(fmt, ap);
    va_end(ap);
}


void
plumbing::endpoint::fatal_error_v(const char *fmt, va_list ap)
{
    const char *name = get_peer_name();
    if (!name || !*name)
    {
        log().fatal_error_v(fmt, ap);
        return;
    }

    char buffer[1000];
    vsnprintf(buffer, sizeof(buffer), fmt, ap);
    log().fatal_error("%s: %s", name, buffer);
}


void
plumbing::endpoint::warning(const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
    warning_v(fmt, ap);
    va_end(ap);
}


void
plumbing::endpoint::warning_v(const char *fmt, va_list ap)
{
    const char *name = get_peer_name();
    if (!name || !*name)
    {
        log().warning_v(fmt, ap);
        return;
    }

    char buffer[1000];
    vsnprintf(buffer, sizeof(buffer), fmt, ap);
    log().warning("%s: %s", name, buffer);
}


plumbing::time_value
plumbing::endpoint::get_maximum_sleep()
    const
{
    return time_value(60);
}


void
plumbing::endpoint::process_timeout()
{
}


int
plumbing::endpoint::parse_port_number(const std::string &text)
{
    struct servent *sp = getservbyname(text.c_str(), "tcp");
    if (sp)
        return ntohs(sp->s_port);
    char *ep = 0;
    long n = strtol(text.c_str(), &ep, 0);
    if (ep == text.c_str() || *ep)
        return -1;
    return n;
}


int
plumbing::endpoint::parse_port_number_or_die(const std::string &text,
    bool empty_is_ok)
{
    if (text.empty() && empty_is_ok)
        return -1;
    int n = parse_port_number(text);
    if (n < 0)
    {
        log().fatal_error
        (
            "unable to interpret \"%s\" as a port number",
            text.c_str()
        );
    }
    return n;
}


// vim: ts=4:et

---