cgi_in2.H

Go to the documentation of this file.

/******************************************************************************
*                          cgi_in.h                            2000-10-31 AgF *
*                CGI interface for C++ programs                               *
*******************************************************************************

This header file defines the class CGI_Interface and the object cgi to
facilitate web interface through CGI (Comman Gateway Interface).

The constructor outputs a cgi header and reads input parameters from both
POST and GET methods.

Instructions:
-------------
Write #include <cgi_in.h> in the beginning of your C++ program to get easy
access to input parameters.

The member functions cgi.GetString(char * key), cgi.GetInt(char * key),
and cgi.GetFloat(char * key) are used for getting the values for any input
parameter, where key is the name of the parameter (case sensitive).

Using with multiple modules:
----------------------------
If your C++ program consists of multiple modules compiled separately,
then #define NOTMAIN in all but one of the modules to avoid multiple
instances of the object cgi.

Testing on a PC:
----------------
If the program is compiled on a PC (DOS or Windows) it will not attempt to
read CGI input, which only exists on a web server. Instead, it will read
the input from a file named input.txt. This file should have the format:
PARAMETER1=VALUE1
PARAMETER2=VALUE2
PARAMETER3=VALUE3

modified by Dan Spinosa 2005

*****************************************************************************/

#include <iostream>
#include <string.h>
#include <stdlib.h>

//const int MAXKEYS = 1000;          // max. number input parameters
//const int MAXINPUTLEN = 13000;    // max. total length of all inputs and keys

using namespace std;

// class CGI_Interface facilitates input/output through CGI.
class CGI_Interface2 {
public:
   CGI_Interface2( char*, int);               // constructor
   char * GetString(char * key);  // get input parameter named 'key' as string
   int GetInt(char * key);        // get input parameter named 'key' as integer
   float GetFloat(char * key);    // get input parameter named 'key' as float
   int NumberOfKeys();            // get number of keys
   char * GetNextKey();           // call repeatedly to get all key names
   void BeginKey();               // reset GetNextKey

   char *InputBuffer; // stores all input
   int InputBufferLen;
   char * keys[MAXKEYS];          // all keys (= field names)
   char * values[MAXKEYS];        // corresponding values
   int NumKeys;                   // number of keys
   int KeyIndex;                  // index for GetNextKey
};

//#ifdef __unix__  // check if compiled under unix (this is normal use)
// constructor
CGI_Interface2::CGI_Interface2(char* inputStr, int inputLen) {
   //cout << "CGI INTERFACE CONSTRUCTOR" << endl;
   char * p; int len;
   // read input from cin
   InputBuffer = (char*)malloc( inputLen + 100 );
   memcpy( InputBuffer, inputStr, inputLen );
   //cin.get(InputBuffer, MAXINPUTLEN, 0);
   // append input from QUERY_STRING
   p = getenv("QUERY_STRING"); 
   //len = strlen(InputBuffer);
   len = inputLen;
   InputBufferLen = len;

     
   if (p && *p && len + 4 < MAXINPUTLEN) {
      if (len > 1) strcat(InputBuffer,"&");
      strncat(InputBuffer, p, MAXINPUTLEN-len-1);
   }
   // InputBuffer has the form:
   // key1=value1&key2=value2&key3=value3 ...
   // split the string into keys and values:
   NumKeys = KeyIndex = 0; p = InputBuffer;
   while (NumKeys < MAXKEYS) {
      keys[NumKeys] = p;                 // pointer to key
      p = strchr (p, '=');               // search for '='
      if (p==0) break;                   // stop if '=' not found
      *p = 0;                            // end key string
      values[NumKeys++] = ++p;           // point to value
      p = strchr (p, '&');               // search for '&' separator
      if (p==0) break;                   // stop if '&' not found
      *p = 0; p++;                       // end value string
   }
   
   // translate special characters in values:
   for (int i=0; i<NumKeys; i++) {
      // replace all '+' with space
      p = values[i];
      while (1) {
         p = strchr(p,'+');
         if (p==0) break;
         *p = ' ';
      }
      // replace %XX with character that has hexadecimal code XX
      p = values[i];
      while (1) {
         p = strchr(p,'%');
         if (p==0) break;
         int hi = p[1] | 0x20;
         int lo = p[2] | 0x20;
         if (hi > '9') hi -= 87; else hi -= 48;
         if (lo > '9') lo -= 87; else lo -= 48;
         *p = (char)(hi * 16 + lo);
         strcpy (p+1, p+3); p++;
      }
   }
   // write cgi header to tell that the output is html:
   //cout << "Content-type: text/html\n\n";
}


// get input as string
char * CGI_Interface2::GetString(char * key) {
   for (int i=0; i<NumKeys; i++) {
      if (strcmp(keys[i],key)==0) {
         return values[i];
      }
   }
   return "";
}

// get input as integer
int CGI_Interface2::GetInt(char * key) {
   for (int i=0; i<NumKeys; i++) {
      if (strcmp(keys[i],key)==0) {
         return atoi(values[i]);
      }
   }
   return 0;
}

// get input as float
float CGI_Interface2::GetFloat(char * key) {
   for (int i=0; i<NumKeys; i++) {
      if (strcmp(keys[i],key)==0) {
         return float(atof(values[i]));
      }
   }
   return 0.;
}

// get number of keys
int CGI_Interface2::NumberOfKeys() {
   return NumKeys;
}

// call repeatedly to get all keys
char * CGI_Interface2::GetNextKey() {
   if (KeyIndex >= NumKeys) return 0;
   return keys[KeyIndex++];
}

// reset GetNextKey
void CGI_Interface2::BeginKey() {
   KeyIndex = 0;
}

// define cgi interface object and call constructor
#ifndef NOTMAIN
//CGI_Interface cgi;
#endif

---