[BACK]Return to pa_request.C CVS log [TXT] [DIR] Up to [parser3project] / parser3 / src / main

Diff for /parser3/src/main/pa_request.C between versions 1.71 and 1.76

version 1.71, 2001/03/23 19:25:16 version 1.76, 2001/03/24 14:30:59
Line 22 Line 22
 #include "pa_vmframe.h"  #include "pa_vmframe.h"
 #include "pa_types.h"  #include "pa_types.h"
   
   /// $limits.post_max_size default 10M
   const size_t MAX_POST_SIZE_DEFAULT=10*0x400*400;
   
   //
 Request::Request(Pool& apool,  Request::Request(Pool& apool,
                                  Info& ainfo,                                   Info& ainfo,
                                  String::Untaint_lang adefault_lang) : Pooled(apool),                                   String::Untaint_lang adefault_lang) : Pooled(apool),
Line 35  Request::Request(Pool& apool, Line 39  Request::Request(Pool& apool,
         fclasses(apool),          fclasses(apool),
         fdefault_lang(adefault_lang), flang(adefault_lang),          fdefault_lang(adefault_lang), flang(adefault_lang),
         info(ainfo),          info(ainfo),
         fdefault_content_type(0)          default_content_type(0),
           used_files(apool)
 {  {
         // root superclass,           // root superclass, 
         //   parent of all classes,           //   parent of all classes, 
Line 97  void Request::core(const char *root_auto Line 102  void Request::core(const char *root_auto
                                 main_class_name, main_class);                                  main_class_name, main_class);
                 }                  }
   
                 // loading site auto.p  
                 if(site_auto_path) {  
                         strncpy(auto_filespec, site_auto_path, MAX_STRING-strlen("/" AUTO_FILE_NAME));  
                         strcat(auto_filespec, "/" AUTO_FILE_NAME);  
                         main_class=use_file(  
                                 auto_filespec, site_auto_fail,  
                                 main_class_name, main_class);  
                 }  
   
                 Value *element;  
                 // $MAIN:limits hash used here,                  // $MAIN:limits hash used here,
                 //      until someone with less privileges have overriden them                  //      until someone with less privileges have overriden them
                 Value *limits=main_class?main_class->get_element(*limits_name):0;                  Value *limits=main_class?main_class->get_element(*limits_name):0;
                   Value *element;
                 // $limits.post_max_size default 10M                  // $limits.post_max_size default 10M
                 element=limits?limits->get_element(*post_max_size_name):0;                  element=limits?limits->get_element(*post_max_size_name):0;
                 int value=element?(size_t)element->get_double():0;                  size_t value=element?(size_t)element->get_double():0;
                 int post_max_size=value?value:10*0x400*400;                  size_t post_max_size=value?value:MAX_POST_SIZE_DEFAULT;
   
                 form.fill_fields(*this, post_max_size);                  form.fill_fields(*this, post_max_size);
                 cookie.fill_fields(*this);                  cookie.fill_fields(*this);
   
                 // TODO: load site auto.p files, all assigned bases from upper dir                  // loading site auto.p
                 /*char *site_auto_file="Y:\\parser3\\src\\auto.p";                  if(site_auto_path) {
                 main_class=use_file(                          strncpy(auto_filespec, site_auto_path, MAX_STRING-strlen("/" AUTO_FILE_NAME));
                         site_auto_file, false/*ignore possible read problem* /,                          strcat(auto_filespec, "/" AUTO_FILE_NAME);
                         main_class_name, main_class);*/                          main_class=use_file(
                                   auto_filespec, site_auto_fail,
                                   main_class_name, main_class);
                   }
   
                 // $MAIN:defaults                  // loading auto.p files from document_root/.. 
                 Value *defaults=main_class?main_class->get_element(*defaults_name):0;                  // to the one beside requested file.
                 fdefault_content_type=defaults?defaults->get_element(*content_type_name):0;                  // all assigned bases from upper dir
                   {
                           /* /document/root */
                           char *monkey_auto_path=
                                   (char *)malloc(strlen(info.path_translated)+strlen(AUTO_FILE_NAME)+1);
                           strcpy(monkey_auto_path, info.document_root);
   
                           /* /requested/file.html */
                           char *branches=(char *)malloc(strlen(info.path_translated)+1);
                           strcpy(branches, info.path_translated+strlen(info.document_root));
                           char *next=branches;
   
                           char *append_here=monkey_auto_path+strlen(monkey_auto_path);
                           size_t slash_auto_p_size=strlen("/" AUTO_FILE_NAME);
                           while(true) {
                                   char *step=lsplit(&next, '/');
                                   if(next) { // not 'file.html' part
                                           size_t step_size=strlen(step);
                                           memcpy(append_here, step, step_size);
                                           append_here+=step_size;
                                           memcpy(append_here, "/" AUTO_FILE_NAME, slash_auto_p_size+1);
                                           append_here++/* / */;
   
                                           main_class=use_file(monkey_auto_path, false/*ignore read problem*/,
                                                   main_class_name, main_class);
                                   } else
                                           break;
                           }
                   }
   
                 // compiling requested file                  // compiling requested file
                 main_class=use_file(info.path_translated, true/*don't ignore read problem*/,                  main_class=use_file(info.path_translated, true/*don't ignore read problem*/,
                         main_class_name, main_class);                          main_class_name, main_class);
   
                   // $MAIN:defaults
                   Value *defaults=main_class?main_class->get_element(*defaults_name):0;
                   // value must be allocated on request's pool for that pool used on
                   // meaning constructing @see attributed_meaning_to_string
                   default_content_type=defaults?
                           defaults->get_element(*content_type_name)
                           :NEW VString(*NEW String(pool(), "text/html"));
   
                 // execute @main[]                  // execute @main[]
                 const String *body_string=execute_method(*main_class, *main_method_name);                  const String *body_string=execute_method(*main_class, *main_method_name);
                 if(!body_string)                  if(!body_string)
Line 148  void Request::core(const char *root_auto Line 183  void Request::core(const char *root_auto
                 // OK. write out the result                  // OK. write out the result
                 output_result(*body_string, header_only);                  output_result(*body_string, header_only);
         }           } 
         CATCH(e) {          CATCH(e) { // request handling problem
                   // we're returning not result, but error explanation
                 TRY {                  TRY {
                         // we're returning not result, but error explanation                          // log the beast
                           const String *problem_source=e.problem_source();
                           if(problem_source)
                                   SAPI::log(pool(),
   #ifndef NO_STRING_ORIGIN
                                           "%s(%d): "
   #endif
                                           "'%s' %s [%s %s]",
   #ifndef NO_STRING_ORIGIN
                                           problem_source->origin().file?problem_source->origin().file:"global",
                                           problem_source->origin().line,
   #endif
                                           problem_source->cstr(),
                                           e.comment(),
                                           e.type()?e.type()->cstr():"-",
                                           e.code()?e.code()->cstr():"-"
                                   );
                           else
                                   SAPI::log(pool(),
                                           "%s [%s %s]",
                                           e.comment(),
                                           e.type()?e.type()->cstr():"-",
                                           e.code()?e.code()->cstr():"-"
                                           );
   
                         // reset language to default                          // reset language to default
                         flang=fdefault_lang;                          flang=fdefault_lang;
Line 295  void Request::core(const char *root_auto Line 354  void Request::core(const char *root_auto
   
 }  }
   
 /// @todo find|solve cyclic dependences  
 VStateless_class *Request::use_file(const char *file, bool fail_on_read_problem,  VStateless_class *Request::use_file(const char *file, bool fail_on_read_problem,
                                                                         const String *name,                                                                           const String *name, 
                                                                         VStateless_class *base_class) {                                                                          VStateless_class *base_class) {
           // cyclic dependence check
           String& sfile=*NEW String(pool(), file);
           if(used_files.get(sfile))
                   return base_class;
           used_files.put(sfile, (Hash::Val *)true);
   
   
         char *source=file_read_text(pool(), file, fail_on_read_problem);          char *source=file_read_text(pool(), file, fail_on_read_problem);
         if(!source)          if(!source)
                 return base_class;                  return base_class;
Line 354  void Request::output_result(const String Line 419  void Request::output_result(const String
         cookie.output_result();          cookie.output_result();
                   
         // set default content-type          // set default content-type
         if(fdefault_content_type)          response.fields().put_dont_replace(*content_type_name, default_content_type);
                 response.fields().put_dont_replace(*content_type_name, fdefault_content_type);  
   
         // prepare header: $response:fields without :body          // prepare header: $response:fields without :body
         response.fields().foreach(add_header_attribute, /*excluding*/ body_name);          response.fields().for_each(add_header_attribute, /*excluding*/ body_name);
   
         // prepare...          // prepare...
         const char *body=body_string.cstr();          const char *body=body_string.cstr();
Removed from v.1.71  
changed lines
  Added in v.1.76

E-mail: