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: