fcgi/service.h

Go to the documentation of this file.

/*
 * Copyright 2006-2009 Savarese Software Research Corporation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     https://www.savarese.com/software/ApacheLicense-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef __SSRC_WSPR_FCGI_SERVICE_H
#define __SSRC_WSPR_FCGI_SERVICE_H

#include <ssrc/wispers/service/service.h>

#ifdef WSPR_DEBUG
#include <iostream>
#endif

__BEGIN_NS_SSRC_WSPR_FCGI

using NS_SSRC_WISP_PROTOCOL::GroupMembershipDisable;
using NS_SSRC_WSPR_SERVICE::EventLoop;
using NS_SSRC_WSPR_SERVICE::EventHandler;
using NS_SSRC_WSPR_SERVICE::EventInfo;
using NS_SSRC_WSPR_SERVICE::ServiceEventHandler;

const int FCGIDescriptorDefault = 0;

template<typename Processor>
class FCGIAcceptHandler : public EventHandler {

  int _descriptor;
  Processor & _service;

public:

  explicit FCGIAcceptHandler(Processor & service,
                             int descriptor = FCGIDescriptorDefault)
    SSRC_DECL_THROW(std::invalid_argument) :
    _descriptor(descriptor), _service(service)
  {
    if(descriptor < 0)
      throw std::invalid_argument("bad file descriptor");
  }

  virtual ~FCGIAcceptHandler() { }

  virtual int event_descriptor() const {
    return _descriptor;
  }

  virtual void handle_read(const EventInfo & info) {
    fcgx_request_ptr request = fcgx_request_ptr(new FCGI::FCGX_Request);

    FCGI::FCGX_InitRequest(request.get(), event_descriptor(), 0);

    if(FCGX_Accept_r(request.get()) == 0)
      _service.process_fcgi_request(request);
    else {
      // TODO: log this!
#ifdef WSPR_DEBUG
      std::cerr << "FCGX Accept Error!\n";
#endif
    }
  }
};

/*
// This no longer works with gcc 4.3 as a service_main type arg.
template<typename ProtocolProcessor,
         typename AcceptHandler = FCGIAcceptHandler<ProtocolProcessor> >
*/
template<typename ProtocolProcessor>
class FCGIServiceEventHandler : public ServiceEventHandler<ProtocolProcessor> {
  typedef ServiceEventHandler<ProtocolProcessor> super;

  string _socket;
  typedef FCGIAcceptHandler<ProtocolProcessor> AcceptHandler;
  AcceptHandler _accept_handler;

protected:

  virtual void remove_handler(EventLoop & loop) {
    super::remove_handler(loop);
    loop.remove_handler(_accept_handler);
  }

public:

  explicit FCGIServiceEventHandler(typename super::caller_type & caller)
    SSRC_DECL_THROW(std::invalid_argument) :
    super(caller), _accept_handler(super::protocol())
  { }

  template<typename Initializer>
  explicit FCGIServiceEventHandler(typename super::caller_type & caller,
                                   const Initializer & initializer)
    SSRC_DECL_THROW(std::invalid_argument) :
    super(caller, initializer),
    _socket(initializer.fcgi_socket),
    _accept_handler(super::protocol(),
                    (_socket.empty() ? FCGIDescriptorDefault :
                     FCGI::FCGX_OpenSocket(_socket.c_str(),
                                           initializer.fcgi_backlog)))
  { }

  virtual ~FCGIServiceEventHandler() {
    if(_accept_handler.event_descriptor() > 0) {
      if(_socket.find(':') >= _socket.size()) {
        ::unlink(_socket.c_str());
      }
      ::close(_accept_handler.event_descriptor());
    }
  }

  void start(EventLoop & loop, const unsigned int call_timeout) {
    super::start(loop, call_timeout);
    FCGI::FCGX_Init();
    loop.add_handler(_accept_handler, EventLoop::Read);
  }

};

__END_NS_SSRC_WSPR_FCGI

#endif