[help-cgicc] cant create cookie, please help

[Ben Kuang]

Hi: 

I am using the HTTPCookie class in cgicc/HTTPCookie.h, however, after
I do the following:

HTTPCookie lib;
lib.setName("Honey");
lib.setValue("Hello");

I dont see a cookie created in the browser's cookie directory.  Do any
of you know why this is happening?  Thank you very much.

the whole program C++ file is as follows:

/************************************************
* CCGIItem::GetLength                           *
* Retrieves the length of the value             *
* Return value: the length of the value, 0 if   *
* there was no parseable value                  *
************************************************/

int CCGIItem::GetLength()
{
        return strlen(m_lpszValue);
}

/************************************************
* CCGIItem::GetNameLength                       *
* Retrieves the length of the name              *
* Return value: the length of the name, 0 if    *
* there was no parseable name                   *
************************************************/

int CCGIItem::GetNameLength()
{
        return strlen(m_lpszName);
}

/************************************************
* CCGIItem::GetValue                            *
* Retrieves the value                           *
* Parameters: lpszBuffer - pointer to buffer to *
*                          receive value        *
*             cbBufferLength - length in bytes  *
*                              of lpszBuffer    *
* Return value: 0 if success, -1 if failure     *
************************************************/

int CCGIItem::GetValue(char* lpszBuffer, int cbBufferLength)
{
        if(m_lpszValue == NULL)         // die if the value of this
item has not been set
                return -1;

        if(cbBufferLength < GetLength())        // die of lpszBuffer
is too small
                return -1;

        strcpy(lpszBuffer, m_lpszValue);        // copy value into lpszBuffer

        return 0;       // success
}

/************************************************
* CCGIItem::GetName                             *
* Retrieves the name of this item               *
* Parameters: lpszBuffer - buffer to be filled  *
*                          with item name       *
*             cbBufferLength - length, in bytes,*
*                              of lpszBuffer    *
* Return value: 0 if success, -1 if error       *
************************************************/

int CCGIItem::GetName(char* lpszBuffer, int cbBufferLength)
{
        if(m_lpszName == NULL)  // die if the name of this item has not been set
                return -1;

        if(cbBufferLength < GetNameLength())    // die if lpszBuffer
is too small
                return -1;

        strcpy(lpszBuffer, m_lpszName); // copy name into lpszBuffer

        return 0;       // success
}

/************************************************
* CCGIItem::SetValue                            *
* Sets this item's value                        *
* Parameters: lpszBuffer - pointer to string    *
*                          containing value     *
* Return value: 0 if success, -1 if error       *
************************************************/

int CCGIItem::SetValue(char* lpszBuffer)
{
        int cbBufferLength;

        if(m_lpszValue)                 // if a value for this item
has already been set,
                free(m_lpszValue);      // deallocate it

        cbBufferLength = strlen(lpszBuffer);    // get length of value

        if(cbBufferLength == 0)         // die if we couldn't get the
length for whatever reason
                return -1;

        m_lpszValue = (char*) malloc(cbBufferLength + 1);       //
allocate a buffer

        if(m_lpszValue == NULL) // die if allocation failed
                return -1;

        strcpy(m_lpszValue, lpszBuffer);        // copy value into buffer

        return 0;       // success
}

/************************************************
* CCGIItem::SetName                             *
* Sets the name of this item                    *
* Parameters: lpszBuffer - pointer to string    *
*                          containing name      *
* Return value: 0 if success, -1 if failure     *
************************************************/

int CCGIItem::SetName(char* lpszBuffer)
{
        int cbBufferLength;

        if(m_lpszName)                  // if a name has already been
set, deallocate it
                free(m_lpszName);

        cbBufferLength = strlen(lpszBuffer);    // get length of name

        if(cbBufferLength == 0) // die if we couldn't get the length
for whatever reason
                return -1;

        m_lpszName = (char*) malloc(cbBufferLength + 1); // allocate a buffer

        if(m_lpszValue == NULL) // die if allocation failed
                return -1;

        strcpy(m_lpszName, lpszBuffer); // copy name into buffer

        return 0;
}




/* CCGI Constructor */

CCGI::CCGI()
{
        m_lpszRawData = NULL;
}

/* CCGI Deconstructor */

CCGI::~CCGI()
{
        if(m_lpszRawData)       // if a buffer was allocated for data,
deallocate it
                free(m_lpszRawData);
}

/************************************************
* CCGI::Load                                    *
* Retrieves CGI input data from stdin           *
* Return value: 0 if success, -1 if error       *
************************************************/

int CCGI::Load()
{
        char* lpszContentLength;
        int nContentLength;

        lpszContentLength = getenv("CONTENT_LENGTH");   // retrieve
CONTENT_LENGTH environment variable

        if(lpszContentLength == NULL)   // die if we couldn't get it
                return -1;                                      //
this probably means the program is NOT being run under CGI

        nContentLength = atoi(lpszContentLength);       // atoi it

        if(nContentLength == 0) // die if it's 0
                return -1;

        m_lpszRawData = (char*) malloc(nContentLength+1);       //
allocate a buffer

        if(m_lpszRawData == NULL)       // die if allocation failed
                return -1;

        memset(m_lpszRawData, 0, nContentLength+1);     // zero out the buffer

        if(fread(m_lpszRawData, 1, nContentLength, stdin) == 0) // get the data
                return -1;

        if(ferror(stdin))       // die if there was an fread error
                return -1;

        return 0;       // success
}

/************************************************
* CCGI::GetItemCount                            *
* Retrieve number of items                      *
* Return value: number of items, or -1 if error *
************************************************/

int CCGI::GetItemCount()
{
        if(m_lpszRawData == NULL)       // die if there is no data
                return -1;

        char* pbuf = m_lpszRawData;     // get a working pointer to data
        int nItemCount = 1;

        while(pbuf = strchr(pbuf,'&'))  // as long as we can find a '&'
        {
                pbuf++;                                         // put
pbuf to start of next item
                nItemCount++;                           // increment nItemCount
        }

        return nItemCount;      // success, return count
}

/************************************************
* CCGI::GetItem                                 *
* Retrieves an item                             *
* Parameters: nItemIndex - zero-based index of  *
*                          item to retrieve     *
*             pItem - pointer to CCGIItem object*
*                     that will be filled       *
* Return value: 0 if success, -1 if error       *
************************************************/

int CCGI::GetItem(int nItemIndex, CCGIItem* pItem)
{
        // working pointers
        char *lpszItem,*lpszItemEnd,*lpszItemBuf,*lpszNameBuf,*lpszValueBuf;
        int i,nItemLength,nNameLength;

        lpszItem = m_lpszRawData;       // get working pointer to data

        // move to the requested item

        for(i=0; i<nItemIndex; i++)
        {
                lpszItem = strchr(lpszItem,'&');        // find '&'

                if(lpszItem == NULL)                            // if
we couldn't find it, then the index is invalid
                        return -1;

                lpszItem++;             // move pointer to start of next item
        }

        // find the end of the item

        lpszItemEnd = strchr(lpszItem,'&');

        if(lpszItemEnd == 0)                                    // if
there's no end, this is the last item...
                nItemLength = strlen(lpszItem);         // set it to
the length of the remaining string
        else                                                          
         // otherwise, get length via pointer subtraction
                nItemLength = lpszItemEnd - lpszItem;

        lpszItemBuf = (char*) malloc(nItemLength+1);    // allocate a
buffer for the item

        if(lpszItemBuf == NULL) // die if allocation failed
                return -1;

        memset(lpszItemBuf, 0, nItemLength+1);          // zero out the buffer

        memcpy(lpszItemBuf, lpszItem, nItemLength);     // copy item into buffer

        lpszValueBuf = strchr(lpszItemBuf,'=');         // now, find
the = separating name and value

        if(lpszValueBuf == NULL)        // if we couldn't find the =,
this is not valid CGI input; die
        {
                free(lpszItemBuf);
                return -1;
        }

        nNameLength = lpszValueBuf - lpszItemBuf;       // get the
length of the name

        lpszValueBuf++; // increment the value pointer past the =

        lpszNameBuf = (char*) malloc(nNameLength + 1);  // allocate a
buffer for the name

        if(lpszNameBuf == NULL) // die if allocation failed
        {
                free(lpszItemBuf);
                return -1;
        }

        memset(lpszNameBuf, 0, nNameLength + 1);        // zero out the buffer

        memcpy(lpszNameBuf, lpszItemBuf, nNameLength);  // copy name into buffer

        // set the value and name of the CCGIItem passed to us

        if((pItem->SetValue(lpszValueBuf) == -1) ||
(pItem->SetName(lpszNameBuf) == -1))
        {
                // free buffers and die if this failed

                free(lpszItemBuf);
                free(lpszNameBuf);
                return -1;
        }

        // free buffers

        free(lpszNameBuf);
        free(lpszItemBuf);

        return 0; // success
}