Beesnest/DcRequest.cpp

Go to the documentation of this file.

/*
Copyright 2007 Erez Bibi (erezbibi@users.sourceforge.net)
This file is part of Beesnest.

Beesnest 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.

Beesnest 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 Beesnest; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/


/**
 * DcRequest.cpp: Implamentation of CdcRequst class.
 * for documentation see the header file.
 */

#include "DcRequest.h"

CdcRequest::CdcRequest (CdcSocket* psock)
{
    if (psock == NULL)
        throw (CdcException ("Socket pointer is null"));
    pSocket = psock;
    sBuffer.reserve (1024);
}


void CdcRequest::ReadNextRequest ()
{
    int place;
    ResetRequestFields ();
    pSocket->StartNewRequest ();
    /* Find end of header, if not found read from socket. */
    while ((place = sBuffer.Find (CRLFCRLF)) == -1)
        pSocket->Read (sBuffer);
    place += CRLFCRLF_SIZE;
    /* Parse header. */
    ParseHeader (sBuffer.Left (place));
    /* Trim buffer to rest of request. */
    if (place < sBuffer.GetLength ())
        sBuffer = sBuffer.Mid (place);
    else
        sBuffer = EMPTY_STR;
    /* if no body - return. */
    if (sMethod != POST) return;
    /* send the 100-Continue message anyway if it is required. */
    Handle100Continue ();
    /* Check if this is a chunk body. */
    CdcString ste = GetHeaderField ("Transfer-Encoding");
    ste.MakeLower ();
    CdcString msg_body;
    if (ste.Find ("chunked") != -1)
        DoChunkRequest (msg_body);  /* Will fill msg_body. */
    else
    {   /* The length of the body determent by "Content-Length". */
        CdcString slng = GetHeaderField ("Content-Length");
        if (slng.IsEmpty ())
            throw (CdcExceptionParse ("Cannot find the message length",
            DC_PARSE_EXP));
        /* Read entire body. */
        int lng = atoi (slng.GetBuffer ());
        while (sBuffer.GetLength () < lng)
            pSocket->Read (sBuffer);
        /* Extract body. */
        msg_body = sBuffer.Left (lng);
        /* Trim buffer to rest of request. */
        if (lng < sBuffer.GetLength ())
            sBuffer = sBuffer.Mid (lng);
        else
            sBuffer = EMPTY_STR;
    }
    /* Try to get variables from POST body (Ignore exceptions).
    Insert msg_body to vars map. */
    SetVariable ("BN_Body", msg_body);
    try { ParseQueryLine (msg_body); }
    catch (CdcExceptionParse& e) {e.GetExpCode ();}
}


void CdcRequest::Handle100Continue ()
{
    /* Don't send Continue message if HTTP 1.0 */
    if (sVersion == PROTOCOL10_VRS)
        return;

    if (GetHeaderField ("Expect") == "100-continue")
    {   /* Send the Continue message. */
        pSocket->Write (CONTINUE_MSG, strlen (CONTINUE_MSG));
        pSocket->Write (CRLFCRLF, CRLFCRLF_SIZE);
    }
    return;
}

void CdcRequest::DoChunkRequest (CdcString& msg_body) throw (CdcException)
{
PrintString ("Chunked Request", PS_DBG);
    int place = 0, lng;
    /* Read from the socket until a blank line. */
    while (sBuffer.Find (CRLFCRLF) == -1)
        pSocket->Read (sBuffer);
    /* Read first the "Length" line. */
    lng = strtoul (sBuffer.GetBuffer (), NULL, 16);
    place = sBuffer.Find (CRLF, place) + CRLF_SIZE;
    if (place == -1)
        throw (CdcExceptionParse ("Bad format of chuncked request",
        DC_CNT_PRS_CNK_EXP));
    /* Extract chunks. */
    while (lng > 0)
    {
        if (sBuffer.GetLength () - place < lng)
            throw (CdcExceptionParse ("Bad format of chuncked request",
            DC_CNT_PRS_CNK_EXP));
        /* Copy chunk of message. */
        msg_body += sBuffer.Mid (place, lng);
        place += lng + CRLF_SIZE;
        /* Read next "Length" line. */
        if (sBuffer.GetLength () < place)
            throw (CdcExceptionParse ("Bad format of chuncked request",
            DC_CNT_PRS_CNK_EXP));
        lng = strtoul (sBuffer.Mid (place).GetBuffer (), NULL, 16);
        place = sBuffer.Find (CRLF, place) + CRLF_SIZE;
        if (place == -1)
            throw (CdcExceptionParse ("Bad format of chuncked request",
            DC_CNT_PRS_CNK_EXP));
    }
    /* Extract trailer lines. */
    while (1)
    {   /* Until CRLF is in the beginning (end of request)... */
        lng = sBuffer.Find (CRLF, place) - place;
        if (lng < 0 || sBuffer.GetLength () - place < lng)
            throw (CdcExceptionParse ("Bad format of chuncked request",
            DC_CNT_PRS_CNK_EXP));
        if (lng == place)
            break;
        ParseHeaderLine (sBuffer.Mid (place, lng - place));
        place = lng + CRLF_SIZE;
    }
}


void CdcRequest::FindHost () throw (CdcException)
{
    /* Check if not HTTP 1.0. */
    sHost = "Default-Host";
    sReqHost = EMPTY_STR;
    if (sVersion == PROTOCOL10_VRS) return;
    /* Get the Host: header field. */
    sReqHost = GetHeaderField ("Host");
    if (sReqHost.IsEmpty ()) throw (CdcExceptionParse (
        "HTTP 1.1 request MUST include the Host: header", DC_PARSE_EXP));
    /* Don't take the port number (if exist). */
    int place = sReqHost.Find (':');
    if (place != -1) sReqHost = sReqHost.Left (place);

    CdcString tmp = sReqHost;
    while (1)
    {
        sHost = CdcParameters::GetParam ("Server->Aliases->" + tmp);
        if (sHost.IsEmpty () == false) return;
        if (tmp == "*") break;
        if (tmp[0] == '*' && tmp[1] == '.')
            tmp = tmp.Mid (2);  /* Drop *. if exist. */
        place = tmp.Find (".");
        if (place != -1)
            tmp = "*." + tmp.Mid (place + 1);
        else
            tmp = '*';
    }
    throw (CdcExceptionParse (
        "Wrong host name in the Host: header.", DC_PARSE_EXP));
}


void CdcRequest::ResetRequestFields ()
{
    mHeaderFields.clear ();
    mVariables.clear ();

    sMethod = EMPTY_STR;
    sURL = EMPTY_STR;
    sVersion = EMPTY_STR;

    /* Set the client IP address. */
    SetVariable ("BN_ClinetIP", pSocket->GetClientAddress ());
    SetVariable ("BN_AppPath", CdcFileUtil::GetProgramPath ());
    SetVariable ("BN_Server", SERVER_NAME);
    SetVariable ("BN_Port", CdcParameters::GetParam ("Server->Port"));
}

/* Parsing section. */

void CdcRequest::ParseHeader (CdcString& msg) throw (CdcException)
{
    int endline, place;
    /* Extract Request Line. */
    place = msg.Find (CRLF);
    if (place == -1)
        throw (CdcExceptionParse ("Cannot parse the Request message",
        DC_CNT_PRS_REQ_EXP));
    ParseRequsetLine (msg.Left (place));
    /* Extract header lines. */
    place += CRLF_SIZE;
    while ((endline = msg.Find (CRLF, place)) > place)
    {
        CdcString header = msg.Mid (place, endline - place);
        if (header.Left (6).CompareNoCase ("Cookie") == 0)
            ParseCookiesHeader (header);
        ParseHeaderLine (header);
        place = endline + CRLF_SIZE;
    }
    if (endline == -1)
        throw (CdcExceptionParse ("Cannot parse the Request message",
        DC_CNT_PRS_REQ_EXP));
    /* Find the host this request refer to (multi-hosts system). */
    FindHost ();
    /* Set special request variables */
    SetVariable ("BN_RootPath", CdcFileUtil::GetWorkPath (
        CdcParameters::GetParam ("Server->Hosts->" + sHost + "->Root")));
    SetVariable ("BN_Host", sHost);
    SetVariable ("BN_Alias", sReqHost);
    SetVariable ("BN_Version", sVersion);
    SetVariable ("BN_Method", sMethod);
    SetVariable ("BN_Protocol", sProtocol);
    SetVariable ("BN_URL", sURL);
    SetVariable ("BN_FullURL", sFullURL);
    SetVariable ("BN_Address", sProtocol + "://" + sReqHost + sFullURL);
}


void CdcRequest::ParseRequsetLine (CdcString& line) throw (CdcException)
{
    int place;
    /* Extract the three parts of the line. */
    place = line.Find (' ');
    if (place == -1)
        throw (CdcExceptionParse ("Cannot find the url part of request line",
        DC_CNT_PRS_REQ_LINE_EXP));
    sMethod = line.Left (place);
    sMethod.TrimLeft ();
    /* Check the request method. */
    if (!(sMethod == GET || sMethod == POST || sMethod == HEAD))
        throw (CdcExceptionParse ("Method not Implemented", DC_NOT_SUPPORT));
    /* Extract the version. */
    line = line.Mid (place + 1);
    place = line.Find (' ');
    if (place == -1)
        throw (CdcExceptionParse ("Cannot find the version part of request line",
        DC_CNT_PRS_REQ_LINE_EXP));
    sFullURL = line.Left (place);
    sVersion = line.Mid (place + 1);
    sVersion.TrimLeft ();
    /* Parse the URL. Separate the URL from the query, host ,port
        and protocol */
    /* Discard the protocol part. */
    place = sFullURL.Find ("://");
    if (place == -1) /* if not found 'place' should be 0. */
        place = -3;
    place += 3;
    if (place  > 0 && sFullURL.Left (place) != "http://")
        throw (CdcExceptionParse ("Server Support just HTTP protocol",
        DC_CNT_PRS_REQ_LINE_EXP));
    sProtocol = "http";
    /* Find the starting of the path part. */
    place = sFullURL.Find ('/', place);
    if (place == -1)
        throw (CdcExceptionParse ("Cannot find '/' in the url",
        DC_CNT_PRS_REQ_LINE_EXP));
    sURL = sFullURL.Mid (place);
    /* Extract the query if exists. */
    place = sURL.Find ('?');
    if (place != -1)
    {   /* Parse query w/o '?'. */
        CdcString tmp = sURL.Mid (place + 1);
        SetVariable ("BN_Query", tmp);
        ParseQueryLine (tmp);
        sURL = sURL.Left (place);
    }
}


void CdcRequest::ParseQueryLine (CdcString& line, char limit) throw (CdcException)
{
    CdcString name, val;
    int place, end;

    do
    {   /* Find the name of the variable. */
        place = line.Find ('=');
        if (place == -1)
            throw (CdcExceptionParse ("Cannot parse the query part of the url.",
            DC_CNT_PRS_QUERY_EXP));
        name = line.Left (place);
        name.TrimLeft ();
        name.TrimRight ();
        URIDecode (name);
        place++;
        while (place < line.GetLength () && line[place] == '=')
            ++place; /* That is for cookies. */
        /* Find the value of the variable. */
        end = line.Find (limit, place);
        if (end == -1)
            val = line.Mid (place);
        else
            val = line.Mid (place, end - place);
        val.TrimLeft ();
        val.TrimRight ();
        URIDecode (val);
        /* insert to the variables map. */
        if (mVariables.find (name) == mVariables.end ())
            mVariables [name] = val;
        else
            mVariables [name] += ',' + val;
        /* Trim the line to the next variable,
            if no '&' sign this line does nothing. */
        line = line.Mid (end + 1);
    }
    while (end != -1);
}


void CdcRequest::ParseCookiesHeader (CdcString& line)
{
    /* Discard header name. */
    int place = line.Find (':');
    if (place == -1) return;
    ++place;

    CdcString tmp = line.Mid (place);
    SetVariable ("BN_Cookies", tmp);
    /* Parse the line (ignore exceptions). */
    try
    { ParseQueryLine (tmp, ';'); }
    catch (CdcExceptionParse& e)
    { e.GetExpCode (); }
}

void CdcRequest::URIDecode (CdcString& str)
{
    char* stop;
    CdcString new_str;
    int place, old_place = 0;
    /* Replace all '+' to space. */
    str.Replace ('+', ' ');
    while (1)
    {   /* Find next '%'. */
        place = str.Find ('%', old_place);
        if (place == -1)
        {   /* If not found - copy rest of string and exit. */
            new_str += str.Mid (old_place);
            str = new_str;
            return;
        }
        else
        {   /* If found - copy string until '%', add char, and continue. */
            new_str += str.Mid (old_place, place - old_place);
            new_str += (char) strtol (str.Mid (place + 1, 2), &stop, 16);
            old_place = place + 3;
        }
    }
}


void CdcRequest::ParseHeaderLine (CdcString& line) throw (CdcException)
{
    int place = line.Find (':');
    if (place == -1)
        throw (CdcExceptionParse ("Cannot parse the header field",
        DC_CNT_PRS_HEADER_EXP));
    /* Get the header field name. */
    CdcString name = line.Left (place);
    name.TrimLeft ();
    name.TrimRight ();
    name.MakeLower ();
    /* Get the header field value. */
    CdcString val = line.Mid (place + 1);
    val.TrimLeft ();
    val.TrimRight ();
    /* Insert to Header Fields map. */
    mHeaderFields [name] = val;
}

void CdcRequest::EraseHeaderField (const CdcString& name)
{
    CdcString temp = name;
    temp.MakeLower ();
    mHeaderFields.erase (temp);
}

const string& CdcRequest::__GetHeaderField (const CdcString& name) const
{
    CdcString temp = name;
    temp.MakeLower ();
    t_const_itr itr = mHeaderFields.find (temp);
    if (itr == mHeaderFields.end ())
        return EMPTY_STR;
    return itr->second;
}

const string& CdcRequest::__GetVariable (const CdcString& name) const
{
    t_const_itr itr = mVariables.find (name);
    if (itr == mVariables.end ())
        return EMPTY_STR;
    return itr->second;
}

BufferHolder CdcRequest::GetRequestVarsNamesList (BufferHolder sep)
{
    sVarList.clear ();
    CdcString s_sep (sep);
    t_map* pmap;
    t_map::const_iterator pos;

    if (s_sep[0] == 'H')
    {
        pmap = &mHeaderFields;
        s_sep = s_sep.Mid (1);
    }
    else
        pmap = &mVariables;

    for (pos = pmap->begin ();
         pos != pmap->end (); ++pos)
    {
        if (sVarList.empty () == false)
            sVarList += s_sep;
        sVarList += pos->first;
    }

    return BufferHolder (sVarList.c_str ());
}