[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.331 and 1.348

version 1.331, 2012/05/24 12:50:20 version 1.348, 2015/10/20 18:17:19
Line 43  const char* UNHANDLED_EXCEPTION_CONTENT_ Line 43  const char* UNHANDLED_EXCEPTION_CONTENT_
   
 /// 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";
 const char* ORIGINS_CONTENT_TYPE="text/plain";  
   
 // defines for globals  // defines for globals
   
 #define MAIN_METHOD_NAME "main"  #define MAIN_METHOD_NAME "main"
 #define AUTO_METHOD_NAME "auto"  #define AUTO_METHOD_NAME "auto"
 #define AUTOUSE_METHOD_NAME "autouse"  #define AUTOUSE_METHOD_NAME "autouse"
 #define BODY_NAME "body"  
 #define EXCEPTION_TYPE_PART_NAME "type"  #define EXCEPTION_TYPE_PART_NAME "type"
 #define EXCEPTION_SOURCE_PART_NAME "source"  #define EXCEPTION_SOURCE_PART_NAME "source"
 #define EXCEPTION_COMMENT_PART_NAME "comment"  #define EXCEPTION_COMMENT_PART_NAME "comment"
Line 61  const String main_method_name(MAIN_METHO Line 59  const String main_method_name(MAIN_METHO
 const String auto_method_name(AUTO_METHOD_NAME);  const String auto_method_name(AUTO_METHOD_NAME);
 const String autouse_method_name(AUTOUSE_METHOD_NAME);  const String autouse_method_name(AUTOUSE_METHOD_NAME);
   
 const String body_name(BODY_NAME);  
 const String exception_type_part_name(EXCEPTION_TYPE_PART_NAME);  const String exception_type_part_name(EXCEPTION_TYPE_PART_NAME);
 const String exception_source_part_name(EXCEPTION_SOURCE_PART_NAME);  const String exception_source_part_name(EXCEPTION_SOURCE_PART_NAME);
 const String exception_comment_part_name(EXCEPTION_COMMENT_PART_NAME);  const String exception_comment_part_name(EXCEPTION_COMMENT_PART_NAME);
Line 72  const String exception_handled_part_name Line 69  const String exception_handled_part_name
 #define CHARSETS_NAME "CHARSETS"  #define CHARSETS_NAME "CHARSETS"
 #define MIME_TYPES_NAME "MIME-TYPES"  #define MIME_TYPES_NAME "MIME-TYPES"
 #define STRICT_VARS_NAME "STRICT-VARS"  #define STRICT_VARS_NAME "STRICT-VARS"
 #define ORIGINS_MODE_NAME "ORIGINS"  
 #define CONF_METHOD_NAME "conf"  #define CONF_METHOD_NAME "conf"
 #define POST_PROCESS_METHOD_NAME "postprocess"  #define POST_PROCESS_METHOD_NAME "postprocess"
 #define DOWNLOAD_NAME "download"  
 #define CLASS_PATH_NAME "CLASS_PATH"  #define CLASS_PATH_NAME "CLASS_PATH"
 #define RESPONSE_BODY_FILE_NAME "file"  #define RESPONSE_BODY_FILE_NAME "file"
   
   #define DOWNLOAD_NAME_UPPER "DOWNLOAD"
   #define BODY_NAME_UPPER "BODY"
   
 // statics  // statics
   
 static const String charsets_name(CHARSETS_NAME);  static const String charsets_name(CHARSETS_NAME);
 static const String main_class_name(MAIN_CLASS_NAME);  static const String main_class_name(MAIN_CLASS_NAME);
 static const String mime_types_name(MIME_TYPES_NAME);  static const String mime_types_name(MIME_TYPES_NAME);
 static const String strict_vars_name(STRICT_VARS_NAME);  static const String strict_vars_name(STRICT_VARS_NAME);
 static const String origins_mode_name(ORIGINS_MODE_NAME);  
 static const String conf_method_name(CONF_METHOD_NAME);  static const String conf_method_name(CONF_METHOD_NAME);
 static const String post_process_method_name(POST_PROCESS_METHOD_NAME);  static const String post_process_method_name(POST_PROCESS_METHOD_NAME);
 static const String download_name(DOWNLOAD_NAME);  
 static const String class_path_name(CLASS_PATH_NAME);  static const String class_path_name(CLASS_PATH_NAME);
 static const String response_body_file_name(RESPONSE_BODY_FILE_NAME);  static const String response_body_file_name(RESPONSE_BODY_FILE_NAME);
   
   static const String download_name_upper(DOWNLOAD_NAME_UPPER);
   static const String body_name_upper(BODY_NAME_UPPER);
   
   // more static
   
   static const String content_type_name_upper(HTTP_CONTENT_TYPE_UPPER);
   static const String content_disposition_name_upper(CONTENT_DISPOSITION_UPPER);
   static const String content_disposition_inline(CONTENT_DISPOSITION_INLINE);
   static const String content_disposition_attachment(CONTENT_DISPOSITION_ATTACHMENT);
   
 // defines  // defines
   
   #define CHARSET_NAME_UPPER "CHARSET"
   #define LAST_MODIFIED_NAME_UPPER "LAST-MODIFIED"
   
 // op.C  // op.C
 VStateless_class& VClassMAIN_create();  VStateless_class& VClassMAIN_create();
   
Line 102  Request::Request(SAPI_Info& asapi_info, Line 111  Request::Request(SAPI_Info& asapi_info,
                                  String::Language adefault_lang):                                   String::Language adefault_lang):
         // private          // private
         anti_endless_execute_recoursion(0),          anti_endless_execute_recoursion(0),
         anti_endless_json_string_recoursion(0),  
   
         // public          // public
           allow_class_replace(false),
         method_frame(0),          method_frame(0),
         rcontext(0),          rcontext(0),
         wcontext(0),          wcontext(0),
Line 115  Request::Request(SAPI_Info& asapi_info, Line 124  Request::Request(SAPI_Info& asapi_info,
         fin_cycle(0),          fin_cycle(0),
   
         // public          // public
 #ifdef RESOURCES_DEBUG  
         sql_connect_time(0),  
         sql_request_time(0),  
 #endif    
   
         // public  
         request_info(arequest_info),          request_info(arequest_info),
         sapi_info(asapi_info),          sapi_info(asapi_info),
         charsets(UTF8_charset, UTF8_charset, UTF8_charset), // default charsets          charsets(UTF8_charset, UTF8_charset, UTF8_charset), // default charsets
Line 143  Request::Request(SAPI_Info& asapi_info, Line 146  Request::Request(SAPI_Info& asapi_info,
         pa_register_thread_request(*this);          pa_register_thread_request(*this);
   
         // file_no=0 => unknown          // file_no=0 => unknown
         file_list+=String::Body("UNKNOWN");          file_list+="UNKNOWN";
         file_list+=String::Body("-body of process-"); // pseudo_file_no__process          file_list+="-body of process-"; // pseudo_file_no__process
   
         // maybe expire old caches          // maybe expire old caches
         cache_managers->maybe_expire();          cache_managers->maybe_expire();
Line 158  Request::Request(SAPI_Info& asapi_info, Line 161  Request::Request(SAPI_Info& asapi_info,
   
         /// methodless          /// methodless
         // env class          // env class
         classes().put(String::Body(ENV_CLASS_NAME), new VEnv(asapi_info));          classes().put(ENV_CLASS_NAME, new VEnv(asapi_info));
         // status class          // status class
         classes().put(String::Body(STATUS_CLASS_NAME), new VStatus());          classes().put(STATUS_CLASS_NAME, new VStatus());
         // request class          // request class
         classes().put(String::Body(REQUEST_CLASS_NAME), new VRequest(arequest_info, charsets, form));             classes().put(REQUEST_CLASS_NAME, new VRequest(arequest_info, charsets, form, asapi_info));
         // cookie class          // cookie class
         classes().put(String::Body(COOKIE_CLASS_NAME), &cookie);          classes().put(COOKIE_CLASS_NAME, &cookie);
         // console class          // console class
         classes().put(String::Body(CONSOLE_CLASS_NAME), &console);          classes().put(CONSOLE_CLASS_NAME, &console);
         /// methoded          /// methoded
         // response class          // response class
         classes().put(response.get_class()->name(), &response);          classes().put(response.get_class()->name(), &response);
Line 193  Request::~Request() { Line 196  Request::~Request() {
         // if for some strange reason xml generic errors failed to be reported, free them up          // if for some strange reason xml generic errors failed to be reported, free them up
         if(const char* xml_generic_errors=xmlGenericErrors()) {          if(const char* xml_generic_errors=xmlGenericErrors()) {
                 SAPI::log(sapi_info, "warning: unreported xmlGenericErrors: %s", xml_generic_errors);                  SAPI::log(sapi_info, "warning: unreported xmlGenericErrors: %s", xml_generic_errors);
                 free((void *)xml_generic_errors);                  pa_free((void *)xml_generic_errors);
         }          }
 #endif  #endif
 }  }
Line 241  void Request::configure_admin(VStateless Line 244  void Request::configure_admin(VStateless
                 ]                  ]
         */          */
         if(Value* vcharsets=conf_class.get_element(charsets_name)) {          if(Value* vcharsets=conf_class.get_element(charsets_name)) {
                 if(!vcharsets->is_string())                  if(!vcharsets->is_string()) {
                         if(HashStringValue* charsets=vcharsets->get_hash())                          if(HashStringValue* charsets=vcharsets->get_hash())
                                 charsets->for_each<Request_charsets*>(load_charset, &this->charsets);                                  charsets->for_each<Request_charsets*>(load_charset, &this->charsets);
                         else                          else
                                 throw Exception(PARSER_RUNTIME,                                  throw Exception(PARSER_RUNTIME,
                                         0,                                          0,
                                         "$" MAIN_CLASS_NAME ":" CHARSETS_NAME " must be hash");                                          "$" MAIN_CLASS_NAME ":" CHARSETS_NAME " must be hash");
                   }
         }          }
   
 #ifdef STRICT_VARS  #ifdef STRICT_VARS
           VVoid::strict_vars=false;
         if(Value* strict_vars=conf_class.get_element(strict_vars_name)) {          if(Value* strict_vars=conf_class.get_element(strict_vars_name)) {
                 if(strict_vars->is_bool())                  if(strict_vars->is_bool())
                         VVoid::strict_vars=strict_vars->as_bool();                          VVoid::strict_vars=strict_vars->as_bool();
Line 331  void Request::configure() { Line 336  void Request::configure() {
   
 */  */
 void Request::core(const char* config_filespec, bool config_fail_on_read_problem, bool header_only) {  void Request::core(const char* config_filespec, bool config_fail_on_read_problem, bool header_only) {
 #ifdef RESOURCES_DEBUG  
 //measures  
 struct timeval mt[10];  
 //measure:before all  
 gettimeofday(&mt[0],NULL);  
 #endif  
         try {          try {
                 // filling mail received  
                 mail.fill_received(*this);  
   
                 // loading config                  // loading config
                 if(config_filespec) {                  if(config_filespec) {
                         const String& filespec=*new String(config_filespec);                          const String& filespec=*new String(config_filespec);
Line 350  gettimeofday(&mt[0],NULL); Line 346  gettimeofday(&mt[0],NULL);
                                 true /*file must exist if 'fail on read problem' not set*/);                                  true /*file must exist if 'fail on read problem' not set*/);
                 }                  }
   
                   // filling mail received
                   mail.fill_received(*this);
   
                 // loading auto.p files from document_root/..                   // loading auto.p files from document_root/.. 
                 // to the one beside requested file.                  // to the one beside requested file.
                 // all assigned bases from upper dir                  // all assigned bases from upper dir
Line 391  gettimeofday(&mt[0],NULL); Line 390  gettimeofday(&mt[0],NULL);
                         rethrow;                          rethrow;
                 }                  }
   
 #ifdef RESOURCES_DEBUG  
 //measure:after compile  
 gettimeofday(&mt[1],NULL);  
 #endif  
                 // execute @main[]                  // execute @main[]
                 const String* body_string=execute_virtual_method(main_class, main_method_name);                  const String* body_string=execute_virtual_method(main_class, main_method_name);
                 if(!body_string)                  if(!body_string)
                         throw Exception(PARSER_RUNTIME,                          throw Exception(PARSER_RUNTIME,
                                 0,                                  0,
                                 "'"MAIN_METHOD_NAME"' method not found");                                  "'" MAIN_METHOD_NAME "' method not found");
   
 #ifdef RESOURCES_DEBUG  
                 //measure:after main  
 gettimeofday(&mt[2],NULL);  
 #endif  
   
                 // extract response body                  // extract response body
                 Value* body_value=response.fields().get(download_name); // $response:download?                  Value* body_value=response.fields().get(download_name_upper); // $response:download?
                 bool as_attachment=body_value!=0;                  bool as_attachment=body_value!=0;
                 if(!body_value)                  if(!body_value)
                         body_value=response.fields().get(body_name); // $response:body                          body_value=response.fields().get(body_name_upper); // $response:body
                 if(!body_value)                  if(!body_value)
                         body_value=new VString(*body_string); // just result of ^main[]                          body_value=new VString(*body_string); // just result of ^main[]
   
Line 431  gettimeofday(&mt[2],NULL); Line 421  gettimeofday(&mt[2],NULL);
   
                 VFile* body_file=body_value->as_vfile(flang, &charsets);                  VFile* body_file=body_value->as_vfile(flang, &charsets);
   
 #ifdef RESOURCES_DEBUG  
 //measure:after postprocess  
 gettimeofday(&mt[3],NULL);                
 #endif  
   
                 // OK. write out the result                  // OK. write out the result
                 output_result(body_file, header_only, as_attachment);                  output_result(body_file, header_only, as_attachment);
   
 #ifdef RESOURCES_DEBUG  
                 //measure:after output_result  
 gettimeofday(&mt[9],NULL);                
 t[9]=mt[9].tv_sec+mt[9].tv_usec/1000000.0;  
   
 double t[10];  
 for(int i=0;i<10;i++)  
     t[i]=mt[i].tv_sec+mt[i].tv_usec/1000000.0;  
 //measure:log2 compile,main,postprocess,output  
 SAPI::log("rmeasure: %s,%.2f,%.2f,%.2f %.2f,%.2f %.2f",   
 request_info.uri,  
 t[1]-t[0],  
 t[2]-t[1],  
 t[3]-t[2],  
 sql_connect_time,sql_request_time,  
 t[9]-t[3]  
 );  
 #endif  
         } catch(const Exception& e) { // request handling problem          } catch(const Exception& e) { // request handling problem
                 try {                  try {
                 // we're returning not result, but error explanation                  // we're returning not result, but error explanation
Line 522  t[9]-t[3] Line 489  t[9]-t[3]
                         // doing that ugly                          // doing that ugly
   
                         // future $response:content-type                          // future $response:content-type
                         response.fields().put(http_content_type, new VString(*new String(UNHANDLED_EXCEPTION_CONTENT_TYPE)));                          response.fields().put(content_type_name_upper, new VString(*new String(UNHANDLED_EXCEPTION_CONTENT_TYPE)));
                         // future $response:body                          // future $response:body
                         body_string=new String(exception_cstr);                          body_string=new String(exception_cstr);
                 }                  }
Line 657  void Request::use_buf(VStateless_class& Line 624  void Request::use_buf(VStateless_class&
                 execute_nonvirtual_method(cclass,                   execute_nonvirtual_method(cclass, 
                         auto_method_name, vfilespec,                          auto_method_name, vfilespec,
                         false/*no result needed*/);                          false/*no result needed*/);
   
                   cclass.enable_default_setter();
         }          }
 }  }
   
 const String& Request::relative(const char* apath, const String& relative_name) {  const String& Request::relative(const char* apath, const String& relative_name) {
         char *hpath=strdup(apath);          char *hpath=pa_strdup(apath);
         String& result=*new String;          String& result=*new String;
         if(rsplit(hpath, '/')) // if something/splitted          if(rsplit(hpath, '/')) // if something/splitted
                 result << hpath << "/";                  result << hpath << "/";
Line 671  const String& Request::relative(const ch Line 640  const String& Request::relative(const ch
   
 const String& Request::absolute(const String& relative_name) {  const String& Request::absolute(const String& relative_name) {
         if(relative_name.first_char()=='/') {          if(relative_name.first_char()=='/') {
                 String& result=*new String(strdup(request_info.document_root));                  String& result=*new String(pa_strdup(request_info.document_root));
                 result << relative_name;                  result << relative_name;
                 return result;                  return result;
         } else           } else 
Line 696  public: Line 665  public:
         bool add_last_modified;          bool add_last_modified;
 };  };
 #endif  #endif
 static void add_header_attribute(  static void add_header_attribute(HashStringValue::key_type name, HashStringValue::value_type value, Add_header_attribute_info* info) {
                                  HashStringValue::key_type name,           if(name==BODY_NAME_UPPER || name==DOWNLOAD_NAME_UPPER || name==CHARSET_NAME_UPPER)
                                  HashStringValue::value_type value,   
                                  Add_header_attribute_info* info) {  
         if(name==BODY_NAME  
                 || name==DOWNLOAD_NAME  
                 || name==CHARSET_NAME)  
                 return;                  return;
                   
           if(name==LAST_MODIFIED_NAME_UPPER)
                   info->add_last_modified=false;
   
         const char* aname=String(name, String::L_URI).untaint_and_transcode_cstr(String::L_URI, &info->r.charsets);          const char* aname=String(name, String::L_URI).untaint_and_transcode_cstr(String::L_URI, &info->r.charsets);
   
         SAPI::add_header_attribute(info->r.sapi_info,          SAPI::add_header_attribute(info->r.sapi_info,
                         aname,                           aname,
                         attributed_meaning_to_string(*value, String::L_URI, false).untaint_and_transcode_cstr(String::L_URI, &info->r.charsets)                          attributed_meaning_to_string(*value, String::L_URI, false).untaint_and_transcode_cstr(String::L_URI, &info->r.charsets)
                 );                  );
   
         if(strcasecmp(aname, "last-modified")==0)  
                 info->add_last_modified=false;  
 }  }
   
 static void output_sole_piece(Request& r,  static void output_sole_piece(Request& r,
Line 778  static void output_pieces(Request& r, Line 742  static void output_pieces(Request& r,
   
         const size_t BUFSIZE = 10*0x400;          const size_t BUFSIZE = 10*0x400;
         char buf[BUFSIZE];          char buf[BUFSIZE];
         const char *range = SAPI::get_env(r.sapi_info, "HTTP_RANGE");          const char *range = SAPI::Env::get(r.sapi_info, "HTTP_RANGE");
         size_t offset=0;          size_t offset=0;
         size_t part_length=content_length;          size_t part_length=content_length;
         if(range){          if(range){
Line 873  void Request::output_result(VFile* body_ Line 837  void Request::output_result(VFile* body_
                         VHash& hash=*new VHash();                          VHash& hash=*new VHash();
                         HashStringValue &h=hash.hash();                          HashStringValue &h=hash.hash();
                         h.put(value_name, new VString( as_attachment ? content_disposition_attachment : content_disposition_inline ));                          h.put(value_name, new VString( as_attachment ? content_disposition_attachment : content_disposition_inline ));
                         h.put(content_disposition_filename_name, new VString(String(sfile_name, String::L_HTTP_HEADER)));                          h.put(content_disposition_filename_name, new VString(*new String(sfile_name, String::L_HTTP_HEADER)));
   
                         response.fields().put(content_disposition, &hash);                          response.fields().put(content_disposition_name_upper, &hash);
   
                         if(!body_file_content_type)                          if(!body_file_content_type)
                                 body_file_content_type=new VString(mime_type_of(sfile_name.cstr()));                                  body_file_content_type=new VString(mime_type_of(sfile_name.cstr()));
Line 885  void Request::output_result(VFile* body_ Line 849  void Request::output_result(VFile* body_
         // set Content-Type          // set Content-Type
         if(body_file_content_type) {          if(body_file_content_type) {
                 // body file content type                  // body file content type
                 response.fields().put(content_type_name, body_file_content_type);                  response.fields().put(content_type_name_upper, body_file_content_type);
         } else {          } else {
                 // default content type                  // default content type
                 response.fields().put_dont_replace(content_type_name, new VString(*new String(DEFAULT_CONTENT_TYPE)));                  response.fields().put_dont_replace(content_type_name_upper, new VString(*new String(DEFAULT_CONTENT_TYPE)));
         }          }
   
         // prepare header: $response:fields without :body, :download and :charset          // prepare header: $response:fields without :body, :download and :charset
Line 912  void Request::output_result(VFile* body_ Line 876  void Request::output_result(VFile* body_
                                 throw Exception(PARSER_RUNTIME, 0, "mdate must be a date");                                  throw Exception(PARSER_RUNTIME, 0, "mdate must be a date");
                 }                  }
                 if(!vdate)                  if(!vdate)
                         vdate=new VDate(mtime);                          vdate=new VDate((pa_time_t)mtime);
   
                 output_pieces(*this, header_only,                   output_pieces(*this, header_only, 
                         sresponse_body_file,                          sresponse_body_file,
Line 938  const String& Request::mime_type_of(cons Line 902  const String& Request::mime_type_of(cons
                 if(const char* cext=strrchr(user_file_name_cstr, '.')) {                  if(const char* cext=strrchr(user_file_name_cstr, '.')) {
                         String sext(++cext);                          String sext(++cext);
                         Table::Action_options options;                          Table::Action_options options;
                         if(mime_types->locate(0, sext.change_case(charsets.source(), String::CC_LOWER), options))                          if(mime_types->locate(0, sext.change_case(charsets.source(), String::CC_LOWER), options)) {
                                 if(const String* result=mime_types->item(1))                                  if(const String* result=mime_types->item(1))
                                         return *result;                                          return *result;
                                 else                                  else
                                         throw Exception(PARSER_RUNTIME,                                          throw Exception(PARSER_RUNTIME,
                                                 0,                                                  0,
                                                 MIME_TYPES_NAME  " table column elements must not be empty");                                                  MIME_TYPES_NAME  " table column elements must not be empty");
                           }
                 }                  }
   
         return *new String("application/octet-stream");          return *new String("application/octet-stream");
Line 1009  Request::Exception_details Request::get_ Line 974  Request::Exception_details Request::get_
         // $.file lineno colno          // $.file lineno colno
         if(trace) {          if(trace) {
                 const Operation::Origin origin=trace.origin();                  const Operation::Origin origin=trace.origin();
                 hash.put(String::Body("file"),                  hash.put("file", new VString(*new String(file_list[origin.file_no], String::L_TAINTED)));
                         new VString(*new String(file_list[origin.file_no], String::L_TAINTED)));                  hash.put("lineno", new VInt(1+origin.line));
                 hash.put(String::Body("lineno"), new VInt(1+origin.line));                  hash.put("colno", new VInt(1+origin.col));
                 hash.put(String::Body("colno"), new VInt(1+origin.col));  
         }          }
   
         // $.comment          // $.comment
Line 1025  Request::Exception_details Request::get_ Line 989  Request::Exception_details Request::get_
   
         return Request::Exception_details(trace, problem_source, vhash);          return Request::Exception_details(trace, problem_source, vhash);
 }  }
   
   Temp_value_element::Temp_value_element(Request& arequest, Value& awhere, const String& aname, Value* awhat) :
           frequest(arequest),
           fwhere(awhere),
           fname(aname),
           saved(awhere.get_element(aname))
   {
           Junction* junction;
           if(saved && (junction=saved->get_junction()) && junction->is_getter)
                   saved=0;
           frequest.put_element(fwhere, aname, awhat);
   }
   
   Temp_value_element::~Temp_value_element() {
           frequest.put_element(fwhere, fname, saved ? saved : VVoid::get());
   }
Removed from v.1.331  
changed lines
  Added in v.1.348

E-mail: