socketsession.h

Go to the documentation of this file.

// Copyright (C) 2011-2015 Internet Systems Consortium, Inc. ("ISC")
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#ifndef SOCKETSESSION_H
#define SOCKETSESSION_H 1

#include <boost/noncopyable.hpp>

#include <exceptions/exceptions.h>

#include <string>

#include <sys/socket.h>

namespace isc {
namespace util {
namespace io {


class SocketSessionError: public Exception {
public:
    SocketSessionError(const char *file, size_t line, const char *what):
        isc::Exception(file, line, what) {}
};

class BaseSocketSessionForwarder  {
protected:
    BaseSocketSessionForwarder() {}

public:
    virtual ~BaseSocketSessionForwarder() {}
    virtual void connectToReceiver() = 0;
    virtual void close() = 0;
    virtual void push(int sock, int family, int type, int protocol,
                      const struct sockaddr& local_end,
                      const struct sockaddr& remote_end,
                      const void* data, size_t data_len) = 0;
};

class SocketSessionForwarder : boost::noncopyable,
                               public BaseSocketSessionForwarder
{
public:
    explicit SocketSessionForwarder(const std::string& unix_file);

    virtual ~SocketSessionForwarder();

    virtual void connectToReceiver();

    virtual void close();

    virtual void push(int sock, int family, int type, int protocol,
                      const struct sockaddr& local_end,
                      const struct sockaddr& remote_end,
                      const void* data, size_t data_len);

private:
    struct ForwarderImpl;
    ForwarderImpl* impl_;
};

class SocketSession {
public:
    SocketSession(int sock, int family, int type, int protocol,
                  const sockaddr* local_end, const sockaddr* remote_end,
                  const void* data, size_t data_len);

    int getSocket() const { return (sock_); }

    int getFamily() const { return (family_); }

    int getType() const { return (type_); }

    int getProtocol() const { return (protocol_); }

    const sockaddr& getLocalEndpoint() const { return (*local_end_); }

    const sockaddr& getRemoteEndpoint() const { return (*remote_end_); }

    const void* getData() const { return (data_); }

    size_t getDataLength() const { return (data_len_); }

private:
    const int sock_;
    const int family_;
    const int type_;
    const int protocol_;
    const sockaddr* local_end_;
    const sockaddr* remote_end_;
    const void* const data_;
    const size_t data_len_;
};

class SocketSessionReceiver : boost::noncopyable {
public:
    explicit SocketSessionReceiver(int fd);

    ~SocketSessionReceiver();

    SocketSession pop();

private:
    struct ReceiverImpl;
    ReceiverImpl* impl_;
};

}
}
}

#endif  // SOCKETSESSION_H

// Local Variables:
// mode: c++
// End: