Sucheinstellungen (Seite 1 von 60)

#ifndef CGIIN_H
 
 #include <cstdlib>
 
 class CgiIn {
     const char **names;
     const char **values;
     int number;
     char *input;
     static const char * const TRUE, * const EMPTY;
 public:
     /*
     CgiIn::CgiIn(const char **, size_t)
 
     This is the constructor for our CgiIn object. It takes two parameters:
     - a list of strings
     - the size of the list
     This list contains the recognized names.
     */
     CgiIn(const char **s, std::size_t n);
 
     ~CgiIn() { 
         delete [] input; 
         delete [] values;
     }
     const char *get(int i) const { 
         return values[i] ? values[i] : EMPTY; 
     }
     const char *operator[](int i) const { return values[i]; }
 private:
     void readInput();
     void parseInput();
     CgiIn(const CgiIn &) {}
 };
 
 #endif
  

#include <stdexcept>
 #include <iostream>
 #include <cstdlib>
 #include <cstring>
 #include <cstdio>
 #include <cctype>
 #include "cgiin.h"
 
 using namespace std;
 
 const char * const CgiIn::TRUE = "TRUE";
 const char * const CgiIn::EMPTY = "";
 
 namespace {
     inline int hexval(char c) {
         c = toupper(c);
         if (c >= '0' && c <= '9')
             return c - '0';
         else
             return c - 'A' + 10;
     }
 
     void unescape(char *in) {
         char *buf = in;
         while (*in) 
             switch (*in) {
             case '%':
                 *buf++ = hexval(in[1]) * 16 + hexval(in[2]);
                 in += 3;    
                 break;
             case '+':
                 *buf++ = ' ';
                 ++in;
                 break;
             default:
                 *buf++ = *in++;
             }
         *buf = 0;
     }
 }
 
 CgiIn::CgiIn(const char **s, size_t n) 
 : names(s), values(new const char *[n]), number(n) {
     for (int i = 0; i < number; ++i)
         values[i] = 0;
     readInput();
     parseInput();
 }
 
 /*
 [private] CgiIn::readInput
 
 This reads in the CGI data.
 */
 void CgiIn::readInput() {
     const char *meth_s = getenv("REQUEST_METHOD");
 
         if (meth_s == 0)
                 throw runtime_error("Invocation in non-CGI context");
 
         enum { GET, POST } method =
                 strcmp(meth_s, "GET") == 0 ? GET : POST;
 
         if (method == GET) {
                 const char *query = getenv("QUERY_STRING");
                 input = new char[strlen(query)];
                 strcpy(input, query);
         } else if (method == POST) {
                 int len = atoi(getenv("CONTENT_LENGTH"));
                 input = new char[len+1];
                 fread(input, 1, len, stdin);
         input[len] = 0;
         }
 }
 
 /*
 [private] CgiIn::parseInput()
 
 This function parses the member input of the form:
 name=value&name2=value2&name3
 
 The first token is a name. If there is a '=' appended, the next token is considered
 a value otherwise a name. If there is a '&' then the next token is considered a name
 etcetera.
 */
 void CgiIn::parseInput() {
     enum mode_t { NAME, VALUE } mode = NAME;
     char *p = input;
     int val;
 
     while (*p) {
         char *begin = p; 
 
         // Read in one token
         while (*p != '&' && *p != '=' && *p)
             ++p;
 
         enum mode_t next_mode = 
             (*p == '&' || *p == 0) ? NAME : VALUE;
 
         *p++ = 0;
 
         unescape(begin);
 
         if (mode == NAME) { // a name
             // Find the index of the string.
             val = -1;
             for (int i = 0; i < number; i++) 
                 if (strncmp(names[i], begin, p - begin) == 0) {
                     val = i;
                     break;
                 }
 
             // If the next mode is NAME, then remember that the name
             // was found.
             if (next_mode == NAME && val != -1) 
                 values[val] = TRUE;
         } else if (val != -1) // a value
             values[val] = begin;
 
         mode = next_mode;
     }
 }