sockets.hpp

Go to the documentation of this file.

/*******************************************************************************
* Copyright (C) 2017 Eddie Carle [eddie@isatec.ca]                             *
*                                                                              *
* This file is part of fastcgi++.                                              *
*                                                                              *
* fastcgi++ is free software: you can redistribute it and/or modify it under   *
* the terms of the GNU Lesser General Public License as  published by the Free *
* Software Foundation, either version 3 of the License, or (at your option)    *
* any later version.                                                           *
*                                                                              *
* fastcgi++ 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 Lesser General Public License for     *
* more details.                                                                *
*                                                                              *
* You should have received a copy of the GNU Lesser General Public License     *
* along with fastcgi++.  If not, see <http://www.gnu.org/licenses/>.           *
*******************************************************************************/

#ifndef FASTCGIPP_SOCKETS_HPP
#define FASTCGIPP_SOCKETS_HPP

#include <memory>
#include <map>
#include <mutex>
#include <set>
#include <atomic>
#include <deque>
#include <string>

#include "fastcgi++/config.hpp"

#ifdef FASTCGIPP_UNIX
#include <vector>
#include <poll.h>
#endif

namespace Fastcgipp
{
    typedef int socket_t;

#ifdef FASTCGIPP_LINUX
    typedef const int poll_t;
#elif defined FASTCGIPP_UNIX
    typedef std::vector<pollfd> poll_t;
#endif

    class SocketGroup;


    class Socket
    {
    private:
        friend class SocketGroup;

        struct Data
        {
            const socket_t m_socket;

            bool m_valid;


            bool m_closing;

            SocketGroup& m_group;


            Data(
                    const socket_t& socket,
                    bool valid,
                    SocketGroup& group):
                m_socket(socket),
                m_valid(valid),
                m_closing(false),
                m_group(group)
            {}

            Data() =delete;
            Data(const Data&) =delete;
        };

        std::shared_ptr<Data> m_data;

        bool m_original;


        Socket(
                const socket_t& socket,
                SocketGroup& group,
                bool valid=true);

    public:

        ssize_t read(char* buffer, size_t size) const;


        ssize_t write(const char* buffer, size_t size) const;

        bool operator<(const Socket& x) const
        {
            return m_data < x.m_data;
        }

        bool operator==(const Socket& x) const
        {
            return m_data == x.m_data;
        }


        Socket(const Socket& x):
            m_data(x.m_data),
            m_original(false)
        {}


        Socket& operator=(const Socket& x)
        {
            m_data = x.m_data;
            m_original = false;
            return *this;
        }


        Socket(Socket&& x):
            m_data(x.m_data),
            m_original(x.m_original)
        {
            x.m_original=false;
        }

        ~Socket();

        bool valid() const
        {
            return m_data->m_valid;
        }


        void close() const;

        Socket();
    };


    class SocketGroup
    {
    public:
        SocketGroup();

        ~SocketGroup();


        bool listen();


        bool listen(
                const char* name,
                uint32_t permissions = 0xffffffffUL,
                const char* owner = nullptr,
                const char* group = nullptr);


        bool listen(
                const char* interface,
                const char* service);


        Socket connect(const char* name);


        Socket connect(
                const char* host,
                const char* service);


        Socket poll(bool block);


        void wake();

        size_t size() const
        {
            return m_sockets.size();
        }


        void accept(bool status);

    private:
        friend class Socket;

        std::set<socket_t> m_listeners;

        poll_t m_poll;

        socket_t m_wakeSockets[2];

        bool m_waking;

        std::atomic_bool m_accept;

        std::atomic_bool m_refreshListeners;

        std::mutex m_wakingMutex;

        std::map<socket_t, Socket> m_sockets;

        inline void createSocket(const socket_t listener);

        bool pollAdd(const socket_t socket);

        bool pollDel(const socket_t socket);

        std::deque<std::string> m_filenames;

#if FASTCGIPP_LOG_LEVEL > 3
        std::atomic_ullong m_incomingConnectionCount;

        std::atomic_ullong m_outgoingConnectionCount;

        std::atomic_ullong m_connectionKillCount;

        std::atomic_ullong m_connectionRDHupCount;

        std::atomic_ullong m_bytesSent;

        std::atomic_ullong m_bytesReceived;
#endif
    };
}

#endif