cgi_in.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
class CGI_Interface {
public:
   CGI_Interface();               // 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
protected:
   char InputBuffer[MAXINPUTLEN]; // stores all input
   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_Interface::CGI_Interface() {
   //cout << "CGI INTERFACE CONSTRUCTOR" << endl;
   char * p; int len;
   //if it wasn't passed in (as a hack)
   // read input from cin
   cin.get(InputBuffer, MAXINPUTLEN, 0);
   // append input from QUERY_STRING
   p = getenv("QUERY_STRING"); 
   len = strlen(InputBuffer);

     
   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";
}

   /*
#else // not compiled under unix. Assume it is compiled on PC for testing only

#include <PC fstream.h>
// PC test version of constructor
CGI_Interface::CGI_Interface() {
   int len, spaceleft = MAXINPUTLEN-1; char * p, * q;
   NumKeys = KeyIndex = 0;
   // get input from file named input.txt
   ifstream inputfile("input.txt", ios::in);
   if (inputfile) {
      p = InputBuffer;
      // read from inputfile until end of file or InputBuffer full
      while (!inputfile.eof() && spaceleft > 1) {
         *p = 0;
         inputfile.getline(p, spaceleft);
         if (*p) {
            len = strlen(p);
            keys[NumKeys] = p;           // point to key
            q = strchr(p, '=');          // find '='
            if (q) {
               values[NumKeys++] = q+1;  // value comes after '='
               *q = 0;}                  // end key string
            p += len; spaceleft -= len;}}
      inputfile.close();}
   else {
      cout << "\nFile input.txt not found<p>\n";}}
#endif
*/

// get input as string
char * CGI_Interface::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_Interface::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_Interface::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_Interface::NumberOfKeys() {
   return NumKeys;
}

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

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

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

---