Changeset 155 for trunk/gsdl/src/recpt/cgiutils.cpp

Timestamp:

1999-02-08T14:28:04+13:00 (25 years ago)

Author:

rjmcnab

Message:

Got the receptionist producing something using the statusaction.

File:

• trunk/gsdl/src/recpt/cgiutils.cpp (modified) (3 diffs)

trunk/gsdl/src/recpt/cgiutils.cpp

@@ -12 +12 @@
 /*
    $Log$
+   Revision 1.3  1999/02/08 01:28:00  rjmcnab
+
+   Got the receptionist producing something using the statusaction.
+
    Revision 1.2  1999/02/05 10:42:43  rjmcnab
 
@@ -92 +96 @@
 
 // split up the cgi arguments
-void parse_cgi_args (text_t argstr, cgiargsclass &args) {
+void split_cgi_args (text_t argstr, cgiargsclass &args) {
   args.clear();
   
@@ -143 +147 @@
   return outtext;
 }
+
+
+
+
+static text_t::const_iterator get_next_save_arg (text_t::const_iterator first, 
+                       text_t::const_iterator last,
+                       text_t &argname) {
+  first = getdelimitstr (first, last, '-', argname);
+  return first;
+}
+
+
+// check_save_conf_str checks the configuration string for
+// the saved args and makes sure it does not conflict with
+// the information about the arguments. If an error is encountered
+// it will return false and the program should not produce any
+// output.
+bool check_save_conf_str (const text_t &saveconf, 
+              const cgiargsinfoclass &argsinfo,
+              ostream &logout) {
+  outconvertclass text_t2ascii;
+
+  text_tset argsset;
+  text_t::const_iterator saveconfhere = saveconf.begin ();
+  text_t::const_iterator saveconfend = saveconf.end ();
+  text_t argname;
+  const cgiarginfo *info;
+
+  // first check to make sure all saved arguments can be saved
+  
+  while (saveconfhere != saveconfend) {
+    saveconfhere = get_next_save_arg (saveconfhere, saveconfend, argname);
+
+    if (!argname.empty()) {
+      // save the argument name for later
+      argsset.insert (argname);
+
+      // check the argument
+      info =  argsinfo.getarginfo (argname);
+      if (info == NULL) {
+    logout << text_t2ascii << "Error: the cgi argument \"" << argname 
+           << "\" is used in the configuration string for the\n"
+           << "saved arguments but does not exist as a valid argument.\n\n";
+    return false;
+      }
+      if (info->savedarginfo == cgiarginfo::mustnot) {
+    logout << text_t2ascii << "Error: the cgi argument \"" << argname
+           << "\" is used in the configuration string for the\n"
+           << "saved arguments but has been specified as an argument whose\n"
+           << "state must not be saved.\n\n";
+    return false;
+      }
+    }
+  }
+
+
+  // next check that all saved arguments that should be saved
+  // are saved
+  cgiargsinfoclass::const_iterator argsinfohere = argsinfo.begin ();
+  cgiargsinfoclass::const_iterator argsinfoend = argsinfo.end ();
+
+  while (argsinfohere != argsinfoend) {
+    if (((*argsinfohere).second.savedarginfo == cgiarginfo::must) &&
+    (argsset.find((*argsinfohere).second.shortname) == argsset.end())) {
+      logout << text_t2ascii << "Error: the cgi argument \"" 
+         << (*argsinfohere).second.shortname << "\" was specified as needing to\n"
+         << "be save but was not listed in the saved arguments.\n\n";
+      return false;
+    }
+
+    argsinfohere++;
+  }
+  
+  return true; // made it, no clashes
+}
+
+
+// create_save_conf_str will create a configuration string
+// based on the information in argsinfo. This method of configuration
+// is not recomended as small changes can produce large changes in
+// the resulting configuration string (for instance a totally different
+// ordering). Only arguments which "must" be saved are included in
+// the resulting string.
+text_t create_save_conf_str (const cgiargsinfoclass &argsinfo,
+                 ostream &/*logout*/) {
+  cgiargsinfoclass::const_iterator argsinfohere = argsinfo.begin ();
+  cgiargsinfoclass::const_iterator argsinfoend = argsinfo.end ();
+  text_t saveconf;
+  bool first = true;
+
+  while (argsinfohere != argsinfoend) {
+    // save this argument if it must be saved
+    if ((*argsinfohere).second.savedarginfo == cgiarginfo::must) {
+      if (!first) saveconf.push_back ('-');
+      else first = false;
+      saveconf += (*argsinfohere).second.shortname;
+    }
+
+    argsinfohere++;
+  }
+  
+  return saveconf;
+}
+
+
+// expand_save_args will expand the saved arguments based
+// on saveconf placing the results in args if they are not
+// already defined. If it encounters an error it will return false
+// and output more information to logout.
+bool expand_save_args (const cgiargsinfoclass &argsinfo,
+               const text_t &saveconf, 
+               cgiargsclass &args,
+               ostream &logout) {
+  outconvertclass text_t2ascii;
+
+  text_t *arg_e = args.getarg("e");
+  if (arg_e == NULL) return true; // no compressed arguments
+  if (arg_e->empty()) return true; // no compressed arguments
+
+  text_t argname, argvalue;
+  const cgiarginfo *argnameinfo;
+  
+  text_t::const_iterator saveconfhere = saveconf.begin();
+  text_t::const_iterator saveconfend = saveconf.end();
+  
+  text_t::iterator arg_ehere = arg_e->begin();
+  text_t::iterator arg_eend = arg_e->end();
+  while (saveconfhere != saveconfend && arg_ehere != arg_eend) {
+    saveconfhere = get_next_save_arg (saveconfhere, saveconfend, argname);
+
+    if (!argname.empty()) {
+      // found another entry
+      argnameinfo = argsinfo.getarginfo (argname);
+
+      if (argnameinfo == NULL) {
+    // no information about the argument could be found
+    // we can't keep going because we don't know whether
+    // this argument is a single or multiple character value
+    logout << text_t2ascii << "Error: the cgi argument \"" << argname
+           << "\" was specified as being a compressed argument\n"
+           << "but no information about it could be found within the "
+           << "cgiargsinfoclass.\n";
+    return false;
+
+      } else {
+    // found the argument information
+    if (argnameinfo->multiplechar) {
+      arg_ehere = getdelimitstr (arg_ehere, arg_eend, '-', argvalue);
+      if (!argvalue.empty()) args.setdefaultarg (argname, argvalue);
+    } else {
+      args.setdefaultcarg (argname,*arg_ehere);
+      arg_ehere++;
+    }
+      }
+    }
+  }
+
+  return true;
+}
+
+
+// adds the default values for those arguments which have not
+// been specified
+void add_default_args (const cgiargsinfoclass &argsinfo,
+               cgiargsclass &args,
+               ostream &/*logout*/) {
+  cgiargsinfoclass::const_iterator argsinfohere = argsinfo.begin ();
+  cgiargsinfoclass::const_iterator argsinfoend = argsinfo.end ();
+
+  while (argsinfohere != argsinfoend) {
+    if ((*argsinfohere).second.defaultstatus != cgiarginfo::none) {
+      args.setdefaultarg ((*argsinfohere).second.shortname,
+              (*argsinfohere).second.argdefault);
+    }
+    argsinfohere++;
+  }
+}
+
+
+// compress_save_args will compress the arguments and return
+// them in compressed_args. If an error was encountered
+// compressed_args will be set to to "", an error will be
+// written to logout, and the function will return false.
+bool compress_save_args (const cgiargsinfoclass &argsinfo,
+             const text_t &saveconf,
+             cgiargsclass &args,
+             text_t &compressed_args,
+             ostream &logout) {
+  outconvertclass text_t2ascii;
+
+  compressed_args.clear();
+
+  text_t argname, argvalue;
+  const cgiarginfo *argnameinfo;
+  
+  text_t::const_iterator saveconfhere = saveconf.begin();
+  text_t::const_iterator saveconfend = saveconf.end();
+  
+  while (saveconfhere != saveconfend) {
+    saveconfhere = get_next_save_arg (saveconfhere, saveconfend, argname);
+
+    if (!argname.empty()) {
+      // found another entry
+      argnameinfo = argsinfo.getarginfo (argname);
+
+      if (argnameinfo == NULL) {
+    // no information about the argument could be found
+    // we can't keep going because we don't know whether
+    // this argument is a single or multiple character value
+    logout << text_t2ascii << "Error: the cgi argument \"" << argname
+           << "\" was specified as being a compressed argument\n"
+           << "but no information about it could be found within the "
+           << "cgiargsinfoclass.\n";
+    compressed_args.clear();
+    return false;
+
+      } else {
+    // found the argument information
+    if (argnameinfo->multiplechar) {
+      // multiple character argument
+      compressed_args += args[argname];
+      if (saveconfhere != saveconfend) compressed_args.push_back ('-');
+
+    } else {
+      // single character argument
+      if (args[argname].size() == 0) {
+        logout << text_t2ascii << "Error: the cgi argument \"" << argname
+           << "\" was specified as being a compressed argument which\n"
+           << "should have a one character value but it was empty.\n\n";
+        compressed_args.clear ();
+        return false;
+
+      } else if (args[argname].size() > 1) {
+        logout << text_t2ascii << "Error: the cgi argument \"" << argname
+           << "\" was specified as being a compressed argument which\n"
+           << "should have a one character value but it had multiple characters.\n\n";
+        compressed_args.clear ();
+        return false;
+      }
+
+      // everything is ok
+      compressed_args += args[argname];
+    }
+      }
+    }
+  }
+
+  return true;
+}
+
+
+// args_tounicode converts any arguments which are not in unicode
+// to unicode using inconvert
+void args_tounicode (cgiargsclass &args, inconvertclass &inconvert) {
+  cgiargsclass::iterator here = args.begin();
+  cgiargsclass::iterator end = args.end();
+
+  while (here != end) {
+    if ((*here).second.getencoding() > 0) {
+      (*here).second = inconvert.convert((*here).second);
+    }
+    
+    here++;
+  }
+}