[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.122.2.1 and 1.130

version 1.122.2.1, 2001/04/27 15:19:30 version 1.130, 2001/05/15 10:01:25
Line 25 Line 25
 #include "pa_vtable.h"  #include "pa_vtable.h"
 #include "pa_vfile.h"  #include "pa_vfile.h"
   
 /// $LIMITS.post_max_size default 10M  
 const size_t MAX_POST_SIZE_DEFAULT=10*0x400*400;  
   
 /// content type of exception response, when no @MAIN:exception handler defined  /// content type of exception response, when no @MAIN:exception handler defined
 const char *UNHANDLED_EXCEPTION_CONTENT_TYPE="text/plain";  const char *UNHANDLED_EXCEPTION_CONTENT_TYPE="text/plain";
   
 /// content type of response when no $MAIN:defaults.content-type defined  /// content type of response when no $MAIN:defaults.content-type defined
 const char *DEFAULT_CONTENT_TYPE="text/html";  const char *DEFAULT_CONTENT_TYPE="text/html";
   
 MOP_create(Pool&);  Methoded *MOP_create(Pool&);
   
 //  //
 Request::Request(Pool& apool,  Request::Request(Pool& apool,
Line 54  Request::Request(Pool& apool, Line 51  Request::Request(Pool& apool,
         used_files(apool),          used_files(apool),
         default_content_type(0),          default_content_type(0),
         mime_types(0),          mime_types(0),
         connection(0), protocol2library(0),          main_class(0),
         mail(0),           connection(0),
         pcre_tables(0)          pcre_tables(0),
           classes_conf(apool) 
 {  {
           /// directly used
         // operators          // operators
         OP.register_directly_used(r);          OP.register_directly_used(*this);
           // classes:
           // table, file, random, mail, image, ...
           methoded_array->register_directly_used(*this);
   
           /// methodless
         // env class          // env class
         classes().put(NEW String(ENV_CLASS_NAME), &env);          classes().put(*NEW String(pool(), ENV_CLASS_NAME), &env);
         // form class  
         classes().put(form.get_class().name(), &form);    
         // request class          // request class
         classes().put(NEW String(REQUEST_CLASS_NAME), &request);                  classes().put(*NEW String(pool(), REQUEST_CLASS_NAME), &request);       
         // response class  
         classes().put(response.get_class().name(), &response);    
         // cookie class          // cookie class
         classes().put(NEW String(COOKIE_CLASS_NAME), &cookie);          classes().put(*NEW String(pool(), COOKIE_CLASS_NAME), &cookie);
   
         // classes:          /// methoded
         // table, file, random, mail, image          // response class
         methoded_array->register_directly_used(*this);          classes().put(response.get_class()->name(), &response); 
   
           /// bases used
           // form class
           classes().put(form.get_class()->base()->name(), &form); 
 }  }
   
 static void element2ctypes(unsigned char *tables,   static void element2ctypes(unsigned char *tables, 
Line 147  void Request::core(const char *root_auto Line 151  void Request::core(const char *root_auto
                                    const char *site_auto_path, bool site_auto_fail,                                     const char *site_auto_path, bool site_auto_fail,
                                    bool header_only) {                                     bool header_only) {
         //_asm { int 3 }          //_asm { int 3 }
         VStateless_class *main_class=0;  
         bool need_rethrow=false;  Exception rethrow_me;          bool need_rethrow=false;  Exception rethrow_me;
         TRY {          TRY {
                 char *auto_filespec=(char *)malloc(MAX_STRING);                  char *auto_filespec=(char *)malloc(MAX_STRING);
Line 162  void Request::core(const char *root_auto Line 165  void Request::core(const char *root_auto
                                 main_class_name, main_class);                                  main_class_name, main_class);
                 }                  }
   
                 // $MAIN:LIMITS hash used here,                  // configure root options
                 //      until someone with less privileges have overriden them                  //      until someone with less privileges have overriden them
                 {                  OP.configure_admin(*this);
                         Value *limits=main_class?main_class->get_element(*limits_name):0;                  methoded_array->configure_admin(*this);
                         if(info.method && StrEqNc(info.method, "post", true)) {  
                                 // $limits.post_max_size default 10M  
                                 Value *element=limits?limits->get_element(*post_max_size_name):0;  
                                 size_t value=element?(size_t)element->as_double():0;  
                                 size_t post_max_size=value?value:MAX_POST_SIZE_DEFAULT;  
                                   
                                 if(size_t limit=max(0, min(info.content_length, post_max_size))) {  
                                         // read POST data  
                                         post_data=(char *)malloc(limit);  
                                         post_size=SAPI::read_post(pool(), post_data, limit);  
                                         if(post_size!=limit)  
                                                 THROW(0, 0,   
                                                         0,   
                                                         "post_size(%d)!=limit(%d)",   
                                                                 post_size, limit);  
                                 }  
                         }  
   
                         form.fill_fields(*this);  
                 }  
   
                 // filling cookies  
                 cookie.fill_fields(*this);  
   
                 // loading site auto.p                  // loading site auto.p
                 if(site_auto_path) {                  if(site_auto_path) {
Line 231  void Request::core(const char *root_auto Line 211  void Request::core(const char *root_auto
                         }                          }
                 }                  }
   
                 // compiling requested file                  // compile requested file
                 String& spath_translated=*NEW String(pool());                  String& spath_translated=*NEW String(pool());
                 spath_translated.APPEND_CLEAN(info.path_translated, 0, "user-request", 0);                  spath_translated.APPEND_CLEAN(info.path_translated, 0, "user-request", 0);
                 main_class=use_file(spath_translated, true/*don't ignore read problem*/,                  main_class=use_file(spath_translated, true/*don't ignore read problem*/,
                         main_class_name, main_class);                          main_class_name, main_class);
   
                   // configure not-root=user options
                   OP.configure_user(*this);
                   methoded_array->configure_user(*this);
   
                 // $MAIN:DEFAULTS                  // $MAIN:DEFAULTS
                 Value *defaults=main_class->get_element(*defaults_name);                  Value *defaults=main_class->get_element(*defaults_name);
                 // value must be allocated on request's pool for that pool used on                  // value must be allocated on request's pool for that pool used on
Line 246  void Request::core(const char *root_auto Line 230  void Request::core(const char *root_auto
                         if(Table *table=element->get_table())                          if(Table *table=element->get_table())
                                 pool().set_tag(table);                                  pool().set_tag(table);
   
                 // $MAIN:SQL.drivers  
                 if(Value *sql=main_class->get_element(*main_sql_name))  
                         if(Value *element=sql->get_element(*main_sql_drivers_name))  
                                 protocol2library=element->get_table();            
   
                 // $MAIN:MIME-TYPES                  // $MAIN:MIME-TYPES
                 if(Value *element=main_class->get_element(*mime_types_name))                  if(Value *element=main_class->get_element(*mime_types_name))
                         if(Table *table=element->get_table())                          if(Table *table=element->get_table())
Line 268  void Request::core(const char *root_auto Line 247  void Request::core(const char *root_auto
                                         ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz]                                          ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz]
                                 $word[                                  $word[
                                         0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz]                                          0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz]
                                 $meta[  
                                         ^#00$()*+.?[^{|]  
   
                                 $lowercase[                                  $lowercase[
                                         AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz]                                          AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz]
Line 290  void Request::core(const char *root_auto Line 267  void Request::core(const char *root_auto
                         element2case(pcre_tables, *ctype, *ctype_lowercase_name);                          element2case(pcre_tables, *ctype, *ctype_lowercase_name);
                 }                  }
   
                 // $MAIN:MAIL[$SMTP[mail.design.ru]]                  // filling form fields
                 if(Value *mail_element=main_class->get_element(*mail_name))                  form.fill_fields(*this);
                         if(!(mail=mail_element->get_hash()))  
                                 THROW(0, 0,  
                                         0,  
                                         "$MAIN:MAIL is not hash");  
   
                   // filling cookies
                   cookie.fill_fields(*this);
   
                 // 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);
Line 314  void Request::core(const char *root_auto Line 289  void Request::core(const char *root_auto
                                 if(const Method *method=junction->method) {                                  if(const Method *method=junction->method) {
                                         // preparing to pass parameters to                                           // preparing to pass parameters to 
                                         //      @postprocess[data]                                          //      @postprocess[data]
                                         VMethodFrame frame(pool(), *junction, false);                                          VMethodFrame frame(pool(), value->name(), *junction, false);
                                         frame.set_self(*main_class);                                          frame.set_self(*main_class);
   
                                         frame.store_param(method->name,                                           frame.store_param(method->name, 
Line 379  void Request::core(const char *root_auto Line 354  void Request::core(const char *root_auto
                                                 if(const Method *method=junction->method) {                                                  if(const Method *method=junction->method) {
                                                         // preparing to pass parameters to                                                           // preparing to pass parameters to 
                                                         //      @exception[origin;source;comment;type;code]                                                          //      @exception[origin;source;comment;type;code]
                                                         VMethodFrame frame(pool(), *junction, false);                                                          VMethodFrame frame(pool(), value->name(), *junction, false);
                                                         frame.set_self(*main_class);                                                          frame.set_self(*main_class);
   
                                                         const String *problem_source=e.problem_source();                                                          const String *problem_source=e.problem_source();
Removed from v.1.122.2.1  
changed lines
  Added in v.1.130

E-mail: