FCGIRequest.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_FCGI_REQUEST_H
#define __SSRC_WSPR_FCGI_FCGI_REQUEST_H

#include <ssrc/wispers/fcgi/HTTPRequest.h>
#include <ssrc/wispers/utility/CircularFind.h>

#include <boost/shared_ptr.hpp>

#include <stdexcept>
#include <cctype>
#include <cstring>

__BEGIN_NS_FCGI_INCLUDE
#include <fcgi/fcgiapp.h>
__END_NS_FCGI_INCLUDE

__BEGIN_NS_SSRC_WSPR_FCGI

using NS_SSRC_WSPR_UTILITY::CircularFind;

const int PORT_HTTP = 80;
const int PORT_HTTPS = 443;

typedef boost::shared_ptr<FCGI::FCGX_Request> fcgx_request_ptr;

class FCGIRequest : public HTTPRequest {
  friend class FCGIResponse;

  const fcgx_request_ptr _fcgx_request;
  bool _https;
  HTTPRequestMethod _method;
  string _session_id;

  static string header_to_http_env(const string & header) {
    string key("HTTP_");

    key.append(header);

    for(unsigned int i = 5; i < key.size(); ++i) {
      if(key[i] == '-')
        key[i] = '_';
      else
        key[i] = std::toupper(key[i]);
    }

    return key;
  }

  struct StrCmp {
    const char * const str;

    StrCmp(const char *str) : str(str) { }

    bool operator()(const char *c_str) const {
      return (std::strcmp(str, c_str) == 0);
    }
  };

  typedef CircularFind<const char * const *> HTTPRequestMethodMap;
  static const HTTPRequestMethodMap RequestMethodMap;

  void set_session_id();

public:

  explicit FCGIRequest(const fcgx_request_ptr & request) :
    _fcgx_request(request), _https(false), _method(MethodUndefined)
  {
    char *val = FCGI::FCGX_GetParam("HTTPS", _fcgx_request->envp);

    if(val)
      _https = (*val == 'o' && *(val + 1) == 'n');

    HTTPRequestMethodMap::iterator it =
      RequestMethodMap.find_if(StrCmp(FCGI::FCGX_GetParam("REQUEST_METHOD", _fcgx_request->envp)));

    if(it != RequestMethodMap.end())
      _method = static_cast<HTTPRequestMethod>(it - RequestMethodMap.begin());

    set_session_id();
  }

  virtual ~FCGIRequest() { }

  const string & session_id() { return _session_id; }

# define CGI_GET_VALUE(key) \
  char *val = FCGI::FCGX_GetParam(#key, _fcgx_request->envp); \
  return (val ? val : "")

# define CGI_GET_INT_VALUE(int_type, key) \
  int_type result = -1; \
  char *str = FCGI::FCGX_GetParam(#key, _fcgx_request->envp); \
 \
  if(str) { \
    char *end(0); \
    result = std::strtol(str, &end, 10); \
 \
    if(end == str) \
      result = -1; \
  } \
 \
  return result

  virtual string auth_type() const {
    CGI_GET_VALUE(AUTH_TYPE);
  }
  virtual string content_type() const {
    CGI_GET_VALUE(CONTENT_TYPE);
  }
  virtual long content_length() const {
    CGI_GET_INT_VALUE(long, CONTENT_LENGTH);
  }
  virtual string document_root() const {
    CGI_GET_VALUE(DOCUMENT_ROOT);
  }
  virtual string gateway_interface() const {
    CGI_GET_VALUE(GATEWAY_INTERFACE);
  }
  virtual string path_info() const { 
    CGI_GET_VALUE(PATH_INFO);
  }
  virtual string path_translated() const {
    CGI_GET_VALUE(PATH_TRANSLATED);
  }
  virtual string query_string() const {
    CGI_GET_VALUE(QUERY_STRING);
  }
  virtual string redirect_request() const {
    CGI_GET_VALUE(REDIRECT_REQUEST);
  }
  virtual string redirect_query_string() const {
    CGI_GET_VALUE(REDIRECT_QUERY_STRING);
  }
  virtual string redirect_status() const {
    CGI_GET_VALUE(REDIRECT_STATUS);
  }
  virtual string redirect_url() const {
    CGI_GET_VALUE(REDIRECT_URL);
  }
  virtual string remote_address() const {
    CGI_GET_VALUE(REMOTE_ADDR);
  }
  virtual string remote_host() const {
    CGI_GET_VALUE(REMOTE_HOST);
  }
  virtual string remote_ident() const {
    CGI_GET_VALUE(REMOTE_IDENT);
  }
  virtual int remote_port() const {
    CGI_GET_INT_VALUE(int, REMOTE_PORT);
  }
  virtual string remote_user() const { 
    CGI_GET_VALUE(REMOTE_USER);
  }
  virtual string remote_group() const {
    CGI_GET_VALUE(REMOTE_GROUP);
  }

  virtual HTTPRequestMethod http_request_method() const { return _method; }

  virtual string request_method() const {
    CGI_GET_VALUE(REQUEST_METHOD);
  }
  virtual string request_uri() const {
    CGI_GET_VALUE(REQUEST_URI);
  }
  virtual string script_filename() const {
    CGI_GET_VALUE(SCRIPT_FILENAME);
  }
  virtual string script_name() const {
    CGI_GET_VALUE(SCRIPT_NAME);
  }
  virtual string server_address() const {
    CGI_GET_VALUE(SERVER_ADDR);
  }
  virtual string server_admin() const {
    CGI_GET_VALUE(SERVER_ADMIN);
  }
  // The raw server name.  Lighttpd includes the port number, which is
  // incorrect, so we postprocess it in server_name().
  string raw_server_name() const {
    CGI_GET_VALUE(SERVER_NAME);
  }
  virtual string server_name() const {
    string name = raw_server_name();
    string::size_type pos = name.find(':');

    if(pos < name.size())
      name.resize(pos);

    return name;
  }
  virtual int server_port() const {
    CGI_GET_INT_VALUE(int, SERVER_PORT);
  }
  virtual string server_root() const {
    CGI_GET_VALUE(SERVER_ROOT);
  }
  virtual string server_protocol() const {
    CGI_GET_VALUE(SERVER_PROTOCOL);
  }
  virtual string server_software() const {
    CGI_GET_VALUE(SERVER_SOFTWARE);
  }

  virtual bool https() const {
    return _https;
  }

  virtual string scheme() const {
    return (_https ? "https" : "http");
  }

  virtual string header_value(const string & header) const {
    const char *result =
      FCGI::FCGX_GetParam(header_to_http_env(header).c_str(),
                          _fcgx_request->envp);
    return (result ? result : "");
  }

  string env_value(const char *key) {
    const char *result = FCGI::FCGX_GetParam(key, _fcgx_request->envp);
    return (result ? result : string());
  }

  const char * fcgx_get_param(const char *key) const {
    return FCGI::FCGX_GetParam(key, _fcgx_request->envp);
  }

  // Should this really be const?  _fcgx_request state changes.
  int fcgx_get_str(char *str, int n) const {
    return FCGI::FCGX_GetStr(str, n, _fcgx_request->in);
  }

# undef CGI_GET_VALUE
# undef CGI_GET_INT_VALUE

  string to_absolute_url(const string & url) const
    SSRC_DECL_THROW(std::invalid_argument);
};

__END_NS_SSRC_WSPR_FCGI

#endif