Web alhem.net

Web.cpp

Go to the documentation of this file.

// Web.cpp
/*
Copyright (C) 2003  Anders Hedstrom

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.
*/

#ifdef _WIN32
#pragma warning(disable:4786)
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#ifdef WIN32
#include <winsock2.h>
#else
#include <sys/time.h>
#include <unistd.h>
#endif
//#include <string>
#include <sys/types.h>
#include <sys/stat.h>

#include "Form.h"
#include "Cookies.h"
//#include "WebForm.h"

//#include <vector>
#include "WebForm.h"
#include "Web.h"
#include "Parse.h"
#include "Base64.h"

#ifdef WIN32
#define strcasecmp stricmp
#endif


namespace Cgi {

Web::Web()
:m_pclForm(NULL)
,m_pclCookies(NULL)
,m_strCookieDomain("")
,m_strCookiePath("")
,m_lastmodified("")
,m_bValid(false)
,m_contentType("text/html; charset=ISO-8859-1")
{
        time_t t = time(NULL);
        struct tm * tp = localtime(&t);
        char date[40];

        sprintf(date,"%d-%02d-%02d %02d:%02d:%02d",
                tp -> tm_year + 1900,
                tp -> tm_mon + 1,
                tp -> tm_mday,
                tp -> tm_hour,
                tp -> tm_min,
                tp -> tm_sec);
        m_date = date;

//      Init();
}


Web::Web(const std::string &strd,const std::string &strp,const std::string& id)
:m_pclForm(NULL)
,m_pclCookies(NULL)
,m_strCookieDomain(strd)
,m_strCookiePath(strp)
,m_lastmodified("")
,m_bValid(false)
,m_contentType("text/html; charset=ISO-8859-1")
{
        time_t t = time(NULL);
        struct tm * tp = localtime(&t);
        char date[40];

        sprintf(date,"%d-%02d-%02d %02d:%02d:%02d",
                tp -> tm_year + 1900,
                tp -> tm_mon + 1,
                tp -> tm_mday,
                tp -> tm_hour,
                tp -> tm_min,
                tp -> tm_sec);
        m_date = date;

        Init(id);
}


Web::Web(int ,char *argv[],const std::string &strd,const std::string &strp,const std::string& id)
:m_pclForm(NULL)
,m_pclCookies(NULL)
,m_strCookieDomain(strd)
,m_strCookiePath(strp)
,m_lastmodified("")
,m_bValid(false)
,m_contentType("text/html; charset=ISO-8859-1")
{
        time_t t = time(NULL);
        struct tm * tp = localtime(&t);
        char date[40];

        sprintf(date,"%d-%02d-%02d %02d:%02d:%02d",
                tp -> tm_year + 1900,
                tp -> tm_mon + 1,
                tp -> tm_mday,
                tp -> tm_hour,
                tp -> tm_min,
                tp -> tm_sec);
        m_date = date;

        Init(id);

        struct stat st;
        if (stat(argv[0], &st) != -1)
        {
                time_t t = st.st_mtime; // st_atime, st_mtime, st_ctime
                struct tm *tp = localtime(&t);
                sprintf(date,"%d-%02d-%02d %02d:%02d:%02d",
                        tp -> tm_year + 1900,
                        tp -> tm_mon + 1,
                        tp -> tm_mday,
                        tp -> tm_hour,
                        tp -> tm_min,
                        tp -> tm_sec);
                m_lastmodified = date;
        }
}


void Web::RegWebForm(WebForm *pclForm)
{
        m_forms.insert(m_forms.end(), pclForm);
}


void Web::Init(const std::string& id)
{
        char *r_m = getenv("REQUEST_METHOD");
//      char *c_l = getenv("CONTENT_LENGTH");
        char *q_s = getenv("QUERY_STRING");
//      char *r_a = getenv("REMOTE_ADDR");
        char *h_c = getenv("HTTP_COOKIE");

        if (q_s)
                m_query_string = q_s;

#ifdef WIN32
#else
        struct timeval tv;

        gettimeofday(&tv,NULL);
        srandom( (tv.tv_sec % 1000000) * 1000 + tv.tv_usec);
#endif

        if (!r_m)
        {
                fprintf(stderr,"This is a cgi program\n");
                exit(-1);
        }
        m_method = r_m;
        if (!strcasecmp(r_m,"get"))
        {
                if (q_s)
                {
                        m_pclForm = new Form(q_s,strlen(q_s));
                }
                else
                {
#ifdef WIN32
                        // IIS won't set QUERY_STRING if it's empty
                        m_pclForm = new Form("",0);
#else
                        fprintf(stderr,"QUERY_STRING undefined\n");
                        exit(-1);
#endif
                }
        }
        else
        if (id.size())
        {
                FILE *fil = fopen(id.c_str(),"rb");
                m_pclForm = new Form(fil);
                fclose(fil);
        }
        else
        if (!strcasecmp(r_m,"post"))
        {
                m_pclForm = new Form;
        }
        else
        {
                fprintf(stderr,"Unknown request method: '%s'\n",r_m);
                exit(-1);
        }
        // Retrieve cookies
        m_pclCookies = new Cookies(h_c ? h_c : (char *)"");
}


Web::~Web()
{
        if (m_pclForm)
        {
                delete m_pclForm;
        }
        if (m_pclCookies)
        {
                delete m_pclCookies;
        }
}


void Web::Execute()
{
        GetEnvironment();
        ReadCookies();
        FormInput();
        ValidateAuth();
        CreateHeader();
        GenerateDocument();
}


void Web::GetEnvironment()
{
}


void Web::ReadCookies()
{
}


void Web::FormInput()
{
        std::list<WebForm *>::iterator it;
        
        for (it = m_forms.begin(); it != m_forms.end(); it++)
        {
                WebForm *pclForm = static_cast<WebForm *>(*it);
                pclForm -> Process();
        }
}


void Web::ValidateAuth()
{
        if (m_realm.size())
        {
                char *auth = getenv("HTTP_AUTHORIZATION");
                if (auth)
                {
                        Parse pa(auth);
                        pa.getword(); // 'basic'
                        char slask[1000];
                        pa.getword(slask); // base64(user:pw)
                        Base64 b;
                        std::string tmp = slask;
                        b.decode_to_buffer(tmp, slask, 1000);
                        Parse pa2(slask, ":");
                        pa2.getword(slask);
                        m_user = slask;
                        pa2.getword(slask);
                        if (ValidateUser(m_user, slask))
                        {
                                m_bValid = true;
                        }
                }
        }
}


void Web::CreateHeader()
{
        // character set
        printf("Content-type: %s\n", m_contentType.c_str());
        if (m_contentDisposition.size())
        {
                printf("Content-disposition: %s\n", m_contentDisposition.c_str());
        }
        if (m_realm.size())
        {
                printf("WWW-Authenticate: Basic realm=\"%s\"\n", m_realm.c_str());
                if (!m_bValid)
                {
                        printf("Status: 401 Forbidden\n");
                }
        }
        if (m_location.size())
        {
                printf("Location: %s\n", m_location.c_str());
        }
        printf("\n");
        fflush(stdout);

        // 4.01 strict
//      printf("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01//EN\" \"http://www.w3.org/TR/html4/strict.dtd\">\n");
        // 4.01 transitional
//      printf("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/1999/REC-html401-19991224/loose.dtd\">\n");
        fflush(stdout);
}


void Web::GenerateDocument()
{
}


void Web::SetCookieDomain(const std::string &str)
{
        m_strCookieDomain = str;
}


void Web::SetCookiePath(const std::string &str)
{
        m_strCookiePath = str;
}


void Web::SetCookie(const std::string &name,const std::string &value)
{
        m_pclCookies -> setcookie( (char *)m_strCookieDomain.c_str(),
                (char *)m_strCookiePath.c_str(),
                (char *)name.c_str(),
                (char *)value.c_str());
}


void Web::SetCookie(const std::string &name,long value)
{
        m_pclCookies -> setcookie( (char *)m_strCookieDomain.c_str(),
                (char *)m_strCookiePath.c_str(),
                (char *)name.c_str(),
                value);
}


void Web::SetCookie(const std::string &name,int value)
{
        m_pclCookies -> setcookie( (char *)m_strCookieDomain.c_str(),
                (char *)m_strCookiePath.c_str(),
                (char *)name.c_str(),
                value);
}


void Web::SetCgiName(const std::string &name)
{
        m_strCgiName = name;
}


std::string Web::GetCgiName()
{
        return m_strCgiName;
}


Form *Web::GetForm()
{
        return m_pclForm;
}


Cookies *Web::GetCookies()
{
        return m_pclCookies;
}


std::string Web::GetDate() 
{ 
        return m_date; 
}


std::string Web::GetRequestMethod() 
{ 
        return m_method; 
}


void Web::UpdateModified(const std::string& str)
{
        if (!m_lastmodified.size() || strcmp(str.c_str(),m_lastmodified.c_str()) > 0)
        {
                if (str.size())
                        m_lastmodified = str;
        }
}


std::string Web::datetime2httpdate(const std::string& dt)
{
/* time_t mktime(struct tm *) */
        char slask[8];
        struct tm tp;
        time_t t;
        char *days[] = { "Sun","Mon","Tue","Wed","Thu","Fri","Sat" };
/*
        char *months[] = { "Jan","Feb","Mar","Apr","May","Jun",
                           "Jul","Aug","Sep","Oct","Nov","Dec" };
*/
        char *months[] = { "Jan","Feb","Mar","Apr","May","Jun",
                           "Jul","Aug","Sep","Oct","Nov","Dec" };
        int i;
        char s[40];

/* 1997-12-16 09:50:40 */

        if (dt.size() == 19) // && (int)strlen(dt) == 19)
        {
                slask[4] = 0;
                tp.tm_year = atoi(strncpy(slask,dt.c_str(),4)) - 1900;
                slask[2] = 0;
                i = atoi(strncpy(slask,dt.c_str() + 5,2)) - 1;
                tp.tm_mon = i >= 0 ? i : 0;
                tp.tm_mday = atoi(strncpy(slask,dt.c_str() + 8,2));
                tp.tm_hour = atoi(strncpy(slask,dt.c_str() + 11,2));
                tp.tm_min = atoi(strncpy(slask,dt.c_str() + 14,2));
                tp.tm_sec = atoi(strncpy(slask,dt.c_str() + 17,2));
                tp.tm_wday = 0;
                tp.tm_yday = 0;
                tp.tm_isdst = 0;
                t = mktime(&tp);
                if (t == -1)
                {
                        printf("datetime2httpdate() failed\n");
                }

                sprintf(s,"%s, %02d %s %d %02d:%02d:%02d GMT",
                 days[tp.tm_wday],
                 tp.tm_mday,
                 months[tp.tm_mon],
                 tp.tm_year + 1900,
                 tp.tm_hour,tp.tm_min,tp.tm_sec);
        } 
        else
        {
                *s = 0;
        }
        return s;
}


void Web::SetRealm(const std::string& session_id)
{
        m_realm = session_id;
}


bool Web::ValidateUser(const std::string& ,const std::string& )
{
        return false;
}


const std::string& Web::GetUser()
{
        return m_user;
}


bool Web::Valid()
{
        return m_bValid;
}


} // namespace

---

Page, code, and content Copyright (C) 2004 by Anders Hedström