HttpServletRequestImpl.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2004 by Ilya A. Volynets-Evenbakh                       *
 *   ilya@total-knowledge.com                                              *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program 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 General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
#ifndef HTTPCSERVIMPLSERVLETREQUESTIMPL_H
#define HTTPCSERVIMPLSERVLETREQUESTIMPL_H

#include <servlet/HttpServletRequest.h>
#include <servlet/UploadedFile.h>
#include <connection.h>
#include <serverconfig/appcontext.h>
#include <util.h>

#include <string>
#include <map>
namespace container {

class HttpServletResponseImpl;
class UploadedFileImpl;

class HttpServletRequestImpl : public servlet::HttpServletRequest
{
private:
    typedef std::map<std::string,servlet::UploadedFile*> filelist_t;
    filelist_t m_files;

    std::string m_localAddr;
    mutable std::string m_localName;
    unsigned short m_localPort;
    std::string m_remoteAddr;
    mutable std::string m_remoteHost;
    unsigned short m_remotePort;
    std::string m_serverName;
    unsigned short m_serverPort;
    std::string m_scheme;
    std::string m_characterEncoding;
    long m_contentLength;
    std::string m_contentType;
    util::attr_t m_attributes;
    util::mparam_t m_parameters;
    util::mparam_t m_headers;
    std::string m_method;
    std::string m_uri;
    std::string m_queryString;
    cookielist_t m_cookies;
    std::string m_sessionId;
    bool m_isSecure;
    std::string m_pathInfo;
    std::string m_remoteUser;
    std::string m_servletPath;
    std::string m_protocol;
    servlet::HttpSession* m_session;
    size_t m_maxRequestSize;
    size_t m_maxFileSize;
    bool m_inputStreamTaken;
private:
    class CookieSeparator
    {
    private:
        struct char_eq
        {
            char e;
            char_eq(char e):e(e) {}
            bool operator()(char c)
            {
                return (e==c);
            }
        };
        std::string m_escape;
        std::string m_sep_drop;
        std::string m_sep_return;
        std::string m_quote;
        char m_cur_quote;
        bool is_escape(char e)
        {
            char_eq f(e);
            return std::find_if(m_escape.begin(),m_escape.end(),f)!=m_escape.end();
        }
        static bool is_sep(char e, const std::string& c_)
        {
            char_eq f(e);
            return std::find_if(c_.begin(),c_.end(),f)!=c_.end();
        }
        bool is_quote(char e)
        {
            if(m_cur_quote != 0) {
                if (e==m_cur_quote)
                    return true;
                else
                    return false;
            }
            char_eq f(e);
            return std::find_if(m_quote.begin(),m_quote.end(),f)!=m_quote.end();
        }
        void do_escape(std::string::const_iterator next,std::string::const_iterator end,std::string& tok);
    public:
        // For now I just hardcode escape code, quotes, and separators
        CookieSeparator()
            : m_escape("\\")
            , m_sep_drop(" \t;,")
            , m_sep_return("=")
            , m_quote("\"'")
            , m_cur_quote(0)
        {}
        void reset() {m_cur_quote=0;}
        bool operator()(std::string::const_iterator& next,std::string::const_iterator end,std::string& tok);
    };
private:
    static void parseAddr(const std::string& addr, std::string& name, unsigned short& port);
    static void addr2host(const std::string& addr, std::string& name);

public:
    HttpServletRequestImpl(Connection& con,serverconfig::AppContext* ctx,
        const std::string& servletPath, size_t maxRequestSize, size_t maxFileSize);
    ~HttpServletRequestImpl();
    void load();

    //virtual servlet::HttpSession* getSession() throw (servlet::IllegalStateException);
    void setRespRef(HttpServletResponseImpl* resp);
    virtual bool isRequestedSessionIdValid();

private:
    void getHeaders();
    void getParams();
    void parseQueryString(std::istream& queryString);
    void parseMultipartData(std::istream& data);
protected:
    Connection& m_con;
    serverconfig::AppContext* m_ctx;
    HttpServletResponseImpl* m_resp;
    std::istream m_inputStream;
private:
    void parseCookieHeader(const std::string& data);
    void parsePart(const std::string& data);
public:
    void addUploadedFile(const std::string& name, UploadedFileImpl* file);
    void addParam(const std::string& name, const std::string& value);
    std::string getFileSaveTemplate() const {return m_ctx->getFileSaveTemplate();}
public:
    virtual boost::shared_ptr<void> getAttribute(const std::string& name);
    virtual bool hasAttribute(const std::string& name) const;
    virtual std::auto_ptr< std::vector<std::string> > getAttributeNames() const;
    virtual void  setAttribute(const std::string& name, boost::shared_ptr<void>);
    virtual void  removeAttribute(const std::string& name);
    virtual std::string  getCharacterEncoding() const;
    virtual void  setCharacterEncoding(const std::string& env) ;
    virtual int  getContentLength() const;
    virtual std::string  getContentType() const;
    virtual std::istream&  getInputStream();
    virtual std::string  getParameter(const std::string& name) const;
    virtual std::auto_ptr< std::vector<std::string> > getParameterNames() const;
    virtual std::auto_ptr< std::vector<std::string> > getParameterValues(const std::string& name) const;
    virtual std::auto_ptr< std::multimap<std::string,std::string> > getParameterMap() const;
    virtual std::string  getProtocol() const;
    virtual std::string  getScheme() const;
    virtual std::string  getServerName() const;
    virtual int  getServerPort() const;
    virtual std::string  getRemoteAddr() const;
    virtual std::string  getRemoteHost() const;
    virtual bool  isSecure() const;
    virtual servlet::RequestDispatcher* getRequestDispatcher(const std::string& path);
    virtual int  getRemotePort() const;
    virtual std::string  getLocalName() const;
    virtual std::string  getLocalAddr() const;
    virtual int  getLocalPort() const;

public:
    virtual std::string  getAuthType() const ;
    virtual std::auto_ptr<cookielist_t> getCookies() const;
    virtual long  getDateHeader(const std::string& name) const ;
    virtual std::string  getHeader(const std::string& name) const ;
    virtual std::auto_ptr< std::vector<std::string> > getHeaders(const std::string& name) const ;
    virtual std::auto_ptr< std::vector<std::string> > getHeaderNames() const ;
    virtual int  getIntHeader(const std::string& name) const ;
    virtual std::string  getMethod() const ;
    virtual std::string  getPathInfo() const ;
    virtual std::string  getPathTranslated() const ;
    virtual std::string  getContextPath() const ;
    virtual std::string  getQueryString() const ;
    virtual std::string  getRemoteUser() const ;
    virtual bool isUserInRole(const std::string& role) const ;
    virtual std::string  getRequestedSessionId() const ;
    virtual std::string  getRequestURI() const ;
    virtual std::string  getRequestURL() const ;
    virtual std::string  getServletPath() const ;
    virtual servlet::HttpSession* getSession(bool create = true);
    virtual bool  isRequestedSessionIdValid() const ;
    virtual bool  isRequestedSessionIdFromCookie() const ;
    virtual bool  isRequestedSessionIdFromURL() const ;
    virtual servlet::UploadedFile* getUploadedFile(const std::string&);
};

}

#endif