transceiver.hpp

Go to the documentation of this file.

/***************************************************************************
* Copyright (C) 2007 Eddie Carle [eddie@erctech.org]                       *
*                                                                          *
* 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 TRANSCEIVER_HPP
#define TRANSCEIVER_HPP

#include <map>
#include <list>
#include <queue>
#include <algorithm>
#include <map>
#include <vector>
#include <functional>

#include <boost/function.hpp>
#include <boost/bind.hpp>
#include <boost/shared_array.hpp>

#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <poll.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <signal.h>

#include <fastcgi++/protocol.hpp>
#include <fastcgi++/exceptions.hpp>

namespace Fastcgipp
{

   struct Block
   {

      Block(char* data_, size_t size_): data(data_), size(size_) { }
      Block(const Block& block): data(block.data), size(block.size) { }
      const Block& operator=(const Block& block) { data=block.data; size=block.size; return *this; }
      char* data;
      size_t size;
   };


   class Transceiver
   {
   public:

      bool handler();

      Block requestWrite(size_t size) { return buffer.requestWrite(size); }
      void secureWrite(size_t size, Protocol::FullId id, bool kill)  { buffer.secureWrite(size, id, kill); transmit(); }

      Transceiver(int fd_, boost::function<void(Protocol::FullId, Message)> sendMessage_);
      void sleep()
      {
         poll(&pollFds.front(), pollFds.size(), -1);
      }
      
      void wake();

   private:
      struct fdBuffer
      {
         Protocol::Header headerBuffer;
         Message messageBuffer;
      };


      class Buffer
      {
         struct Frame
         {

            Frame(size_t size_, bool closeFd_, Protocol::FullId id_): size(size_), closeFd(closeFd_), id(id_) { }
            size_t size;
            bool closeFd;
            Protocol::FullId id;
         };
         std::queue<Frame> frames;
         const static unsigned int minBlockSize = 256;
         struct Chunk
         {
            const static unsigned int size = 131072;
            boost::shared_array<char> data;
            char* end;
            Chunk(): data(new char[size]), end(data.get()) { }
            ~Chunk() { } 
            Chunk(const Chunk& chunk): data(chunk.data), end(data.get()) { } 
         };

         std::list<Chunk> chunks;
         std::list<Chunk>::iterator writeIt;

         char* pRead;

         std::vector<pollfd>& pollFds;
         std::map<int, fdBuffer>& fdBuffers;
         void freeFd(int fd_) { Fastcgipp::Transceiver::freeFd(fd_, pollFds, fdBuffers);  }
      public:

         Buffer(std::vector<pollfd>& pollFds_, std::map<int, fdBuffer>& fdBuffers_): chunks(1), writeIt(chunks.begin()), pRead(chunks.begin()->data.get()), pollFds(pollFds_), fdBuffers(fdBuffers_)  { }


         Block requestWrite(size_t size)
         {
            return Block(writeIt->end, std::min(size, (size_t)(writeIt->data.get()+Chunk::size-writeIt->end)));
         }

         void secureWrite(size_t size, Protocol::FullId id, bool kill);

         struct SendBlock
         {

            SendBlock(const char* data_, size_t size_, int fd_): data(data_), size(size_), fd(fd_) { }
            SendBlock(const SendBlock& sendBlock): data(sendBlock.data), size(sendBlock.size), fd(sendBlock.fd) { }
            const char* data;
            size_t size;
            int fd;
         };


         SendBlock requestRead()
         {
            return SendBlock(pRead, frames.empty()?0:frames.front().size, frames.empty()?-1:frames.front().id.fd);
         }

         void freeRead(size_t size);


         bool empty()
         {
            return pRead==writeIt->end;
         }
      };

      Buffer buffer;
      boost::function<void(Protocol::FullId, Message)> sendMessage;
      
      std::vector<pollfd> pollFds;
      int socket;
      int wakeUpFdIn;
      int wakeUpFdOut;
      
      std::map<int, fdBuffer> fdBuffers;
      
      int transmit();

   public:

      static void freeFd(int fd, std::vector<pollfd>& pollFds, std::map<int, fdBuffer>& fdBuffers);

      void freeFd(int fd_) { freeFd(fd_, pollFds, fdBuffers);  }
   };
   
   struct equalsFd : public std::unary_function<pollfd, bool>
   {
      int fd;
      explicit equalsFd(int fd_): fd(fd_) {}
      bool operator()(const pollfd& x) const { return x.fd==fd; };
   };
   
   inline bool reventsZero(const pollfd& x)
   {
      return x.revents;
   }

   namespace Exceptions
   {
      struct Socket: public CodedException
      {

         Socket(const int& fd_, const int& erno_): CodedException(0, erno_), fd(fd_) { }
         const int fd;
      };
      
      struct SocketWrite: public Socket
      {

         SocketWrite(int fd_, int erno_);
      };
      
      struct SocketRead: public Socket
      {

         SocketRead(int fd_, int erno_);
      };
      
      struct SocketPoll: public CodedException
      {

         SocketPoll(int erno_);
      };
   }
}

#endif