Web alhem.net

Header.cpp

Go to the documentation of this file.

// Header.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)
#define strcasecmp stricmp
#endif
#include <string.h>
#include <ctype.h>

#include "Header.h"
#include "Parse.h"
//#include "list.h"


namespace Cgi {

Header::Header()
{
//      headerbase = NULL;
//      current = NULL;
        m_current = m_headers.end();
        dataindex = 0;
}

Header::Header(char *s,int l)
{
        HEADER *c = NULL; //,*tmp;
        Cgi::Parse *pa = new Cgi::Parse(s,";");
        Cgi::Parse *pa2;
        char *slask = new char[l + 1];
        char *name = new char[l + 1];
        char *value = new char[l + 1];
        int i,ok = 1;

//      headerbase = NULL;
//      current = NULL;
        m_current = m_headers.end();
        dataindex = 0;

        pa -> getline(slask);
        while (*slask)
        {
                for (i = 0; i < (int)strlen(slask); i++)
                        if (!isprint(slask[i]) && slask[i] != 13 && slask[i] != 10 && slask[i] != 9)
                        {
//printf("Don't like char %d\n",slask[i]);
                                ok = 0;
                        }

                pa2 = new Cgi::Parse(slask);
                pa2 -> getword(name);
                pa2 -> getrest(value);
                delete pa2;
                c = new HEADER;
                c -> name = new char[strlen(name) + 1];
                strcpy(c -> name,name);
                c -> value = new char[strlen(value) + 1];
                strcpy(c -> value,value);
//              addlistl(&headerbase,c);
                m_headers.push_back(c);
                //
                pa -> getline(slask);
        }
        dataindex = pa -> getptr(); // 1st char after last empty header line
        delete pa;
        delete[] slask;
        delete[] name;
        delete[] value;

        if (!ok)
        {
//              for (c = headerbase; c; c = tmp)
                for (header_v::iterator it = m_headers.begin(); it != m_headers.end(); it++)
                {
                        c = *it;
                        delete[] c -> name;
                        delete[] c -> value;
//                      tmp = c -> next;
                        delete c;
                }
                while (m_headers.size())
                        m_headers.erase(m_headers.begin());
//              headerbase = NULL;
        }
}

Header::~Header()
{
        HEADER *c = NULL; //,*tmp;

//      for (c = headerbase; c; c = tmp)
        for (header_v::iterator it = m_headers.begin(); it != m_headers.end(); it++)
        {
                c = *it;
                delete[] c -> name;
                delete[] c -> value;
//              tmp = c -> next;
                delete c;
        }
}

int Header::getvalue(char *name,char *buffer,short length)
{
        HEADER *c = NULL;

//      for (c = headerbase; c; c = c -> next)
        for (header_v::iterator it = m_headers.begin(); it != m_headers.end(); it++)
        {
                c = *it;
                if (!strcasecmp(c -> name,name))
                        break;
        }
        if (c)
        {
                if ((short)strlen(c -> value) >= length)
                {
                        strncpy(buffer,c -> value,length - 1);
                        buffer[length - 1] = 0;
                } else
                        strcpy(buffer,c -> value);
                return 1;
        } else
        {
                *buffer = 0;
                return 0;
        }
}

void Header::replacevalue(char *name,char *value)
{
        HEADER *c = NULL;
        
//      for (c = headerbase; c; c = c -> next)
        for (header_v::iterator it = m_headers.begin(); it != m_headers.end(); it++)
        {
                c = *it;
                if (!strcasecmp(c -> name,name))
                        break;
        }

        if (c)
        {
                if (strlen(value) > strlen(c -> value))
                {
                        delete[] c -> value;
                        c -> value = new char[strlen(value) + 1];
                }
                strcpy(c -> value,value);
        } else
        {
                c = new HEADER;
                c -> name = new char[strlen(name) + 1];
                strcpy(c -> name,name);
                c -> value = new char[strlen(value) + 1];
                strcpy(c -> value,value);
//              addlistl(&headerbase,c);
                m_headers.push_back(c);
        }
}

int Header::getlength(char *name)
{
        HEADER *c = NULL;

//      for (c = headerbase; c; c = c -> next)
        for (header_v::iterator it = m_headers.begin(); it != m_headers.end(); it++)
        {
                c = *it;
                if (!strcasecmp(c -> name,name))
                        break;
        }
        return c ? strlen(c -> value) : 0;
}

/* get names */

void Header::getfirst(char *n,short len)
{
        m_current = m_headers.begin(); //current = headerbase;
        getnext(n,len);
}

void Header::getnext(char *n,short len)
{
        if (m_current != m_headers.end())
        {
                HEADER *current = *m_current;
                strncpy(n,current -> name,len - 1);
                n[len - 1] = 0;
                m_current++; //current = current -> next;
        } else
                *n = 0;
}

Header::Header(const Header& ) 
{
}

Header& Header::operator=(const Header& ) 
{ 
  return *this; 
}

} // namespace

---

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