[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.219 and 1.245.2.1

version 1.219, 2002/08/01 11:41:19 version 1.245.2.1, 2003/01/28 11:38:50
Line 1 Line 1
 /** @file  /** @file
         Parser: request class main part. @see compile.C and execute.C.          Parser: request class main part. @see compile.C and execute.C.
   
         Copyright (c) 2001, 2002 ArtLebedev Group (http://www.artlebedev.com)          Copyright (c) 2001, 2003 ArtLebedev Group (http://www.artlebedev.com)
         Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)          Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
 */  */
   
Line 32  const char *UNHANDLED_EXCEPTION_CONTENT_ Line 32  const char *UNHANDLED_EXCEPTION_CONTENT_
 const char *DEFAULT_CONTENT_TYPE="text/html";  const char *DEFAULT_CONTENT_TYPE="text/html";
 const char *ORIGINS_CONTENT_TYPE="text/plain";  const char *ORIGINS_CONTENT_TYPE="text/plain";
   
 Methoded *MOP_create(Pool&);  // op.C
   VClass& VClassMAIN_create(Pool& pool);
 // op.C  // op.C
 VHash& exception2vhash(Pool& pool, const Exception& e);  VHash& exception2vhash(Pool& pool, const Exception& e);
   
Line 43  Request::Request(Pool& apool, Line 44  Request::Request(Pool& apool,
                                  bool status_allowed) : Pooled(apool),                                   bool status_allowed) : Pooled(apool),
         main_method_name(apool, MAIN_METHOD_NAME),          main_method_name(apool, MAIN_METHOD_NAME),
         stack(apool),          stack(apool),
         OP(*MOP_create(apool)),          main_class(VClassMAIN_create(apool)),
         env(apool),          env(apool),
         status(apool),          status(apool),
         form(apool),          form(apool),
Line 60  Request::Request(Pool& apool, Line 61  Request::Request(Pool& apool,
         configure_admin_done(false),          configure_admin_done(false),
         default_content_type(0),          default_content_type(0),
         mime_types(0),          mime_types(0),
         main_class(0),  
         fconnection(0),          fconnection(0),
         classes_conf(apool),          classes_conf(apool),
         anti_endless_execute_recoursion(0),          anti_endless_execute_recoursion(0),
Line 68  Request::Request(Pool& apool, Line 68  Request::Request(Pool& apool,
 #ifdef RESOURCES_DEBUG  #ifdef RESOURCES_DEBUG
         , sql_connect_time(0),sql_request_time(0)          , sql_connect_time(0),sql_request_time(0)
 #endif  #endif
         , self(0), root(0), rcontext(0), wcontext(0)          , method_frame(0), rcontext(0), wcontext(0),
           finterrupted(false)
 {  {
         // default charsets          // default charsets
         pool().set_source_charset(*utf8_charset);          pool().set_source_charset(UTF8_charset);
         pool().set_client_charset(*utf8_charset);          pool().set_client_charset(UTF8_charset);
   
         // maybe expire old caches          // maybe expire old caches
         cache_managers->maybe_expire();          cache_managers->maybe_expire();
                   
         /// directly used          /// directly used
         // operators          // MAIN class, operators
         OP.register_directly_used(*this);          classes().put(main_class.name(), &main_class);
         // classes:          // classes:
         // table, file, random, mail, image, ...          // table, file, random, mail, image, ...
         methoded_array->register_directly_used(*this);          methoded_array->register_directly_used(*this);
Line 101  Request::Request(Pool& apool, Line 102  Request::Request(Pool& apool,
   
         /// bases used          /// bases used
         // form class          // form class
         classes().put(form.get_class()->base()->name(), &form);           classes().put(form.get_class()->base_class()->name(), &form);   
         // mail class          // mail class
         classes().put(mail.get_class()->base()->name(), &mail);           classes().put(mail.get_class()->base_class()->name(), &mail);   
         // math class          // math class
         classes().put(math.get_class()->base()->name(), &math);           classes().put(math.get_class()->base_class()->name(), &math);   
 }  }
   
 Request::~Request() {  Request::~Request() {
Line 118  Request::~Request() { Line 119  Request::~Request() {
 #endif  #endif
 }  }
   
   Value *Request::get_self() { return method_frame?&method_frame->self():0; }
   
 static void load_charset(const Hash::Key& akey, Hash::Val *avalue, void *) {  static void load_charset(const Hash::Key& akey, Hash::Val *avalue, void *) {
         charsets->load_charset(akey, static_cast<Value *>(avalue)->as_string());          charsets->load_charset(akey, static_cast<Value *>(avalue)->as_string());
 }  }
Line 128  void Request::configure_admin(VStateless Line 131  void Request::configure_admin(VStateless
                 "parser already configured");                  "parser already configured");
         configure_admin_done=true;          configure_admin_done=true;
                   
         // charsets must only be specified in root config          // charsets must only be specified in method_frame config
         // so that users would not interfere          // so that users would not interfere
   
         /* $MAIN:CHARSETS[          /* $MAIN:CHARSETS[
Line 136  void Request::configure_admin(VStateless Line 139  void Request::configure_admin(VStateless
                         ...                          ...
                 ]                  ]
         */          */
         if(Value *vcharsets=conf_class.get_element(*charsets_name)) {          if(Value *vcharsets=conf_class.get_element(*charsets_name, conf_class, false)) {
                 if(Hash *charsets=vcharsets->get_hash(0))                  if(!vcharsets->is_string())
                         charsets->for_each(load_charset);                          if(Hash *charsets=vcharsets->get_hash(0))
                 else if(!vcharsets->get_string())                                  charsets->for_each(load_charset);
                         throw Exception("parser.runtime",                          else
                                 0,                                  throw Exception("parser.runtime",
                                 "$" MAIN_CLASS_NAME ":" CHARSETS_NAME " must be hash");                                          0,
                                           "$" MAIN_CLASS_NAME ":" CHARSETS_NAME " must be hash");
         }          }
   
         // configure root options          // configure method_frame options
         //      until someone with less privileges have overriden them          //      until someone with less privileges have overriden them
         OP.configure_admin(*this);  
         methoded_array->configure_admin(*this);          methoded_array->configure_admin(*this);
 }  }
   
Line 179  gettimeofday(&mt[0],NULL); Line 182  gettimeofday(&mt[0],NULL);
                 if(config_filespec) {                  if(config_filespec) {
                         String& filespec=*NEW String(pool());                          String& filespec=*NEW String(pool());
                         filespec.APPEND_CLEAN(config_filespec, 0, "config", 0);                          filespec.APPEND_CLEAN(config_filespec, 0, "config", 0);
                         main_class=use_file(                          use_file(main_class,
                                 filespec,                                   filespec, true/* ignore class_path */, 
                                 true/*ignore class_path*/, config_fail_on_read_problem,                                  config_fail_on_read_problem, true/* file must exist if 'fail on read problem' not set */);
                                 main_class_name, main_class);  
                 }                  }
   
                 // loading auto.p files from document_root/..                   // loading auto.p files from document_root/.. 
Line 206  gettimeofday(&mt[0],NULL); Line 208  gettimeofday(&mt[0],NULL);
                                                 "path-translated-scanned", step++);                                                  "path-translated-scanned", step++);
                                         sfile_spec << "/" AUTO_FILE_NAME;                                          sfile_spec << "/" AUTO_FILE_NAME;
   
                                         main_class=use_file(sfile_spec,                                           use_file(main_class,
                                                 true/*ignore class_path*/, false/*ignore read problem*/,                                                  sfile_spec, true/* ignore class_path */, 
                                                 main_class_name, main_class);                                                  true/* fail on read problem */, false/* but ignore absence, sole user */);
                                 }                                  }
                                 after=before+1;                                  after=before+1;
                         }                          }
Line 217  gettimeofday(&mt[0],NULL); Line 219  gettimeofday(&mt[0],NULL);
                 // compile requested file                  // compile requested file
                 String& spath_translated=*NEW String(pool());                  String& spath_translated=*NEW String(pool());
                 spath_translated.APPEND_TAINTED(info.path_translated, 0, "user-request", 0);                  spath_translated.APPEND_TAINTED(info.path_translated, 0, "user-request", 0);
                 main_class=use_file(spath_translated,                   use_file(main_class,
                         true/*ignore class_path*/, true/*don't ignore read problem*/,                          spath_translated, true/* ignore class_path */, 
                         main_class_name, main_class);                          true/* fail on read problem*/, true/* fail on abscence */);
   
                 // configure root options if not configured yet                  // configure method_frame options if not configured yet
                 if(!configure_admin_done)                  if(!configure_admin_done)
                         configure_admin(*main_class, 0);                          configure_admin(main_class, 0);
   
                 // configure not-root=user options                  // configure not-method_frame=user options
                 OP.configure_user(*this);  
                 methoded_array->configure_user(*this);                  methoded_array->configure_user(*this);
   
                 // $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, main_class, false))
                         if(Table *table=element->get_table())                          if(Table *table=element->get_table())
                                 mime_types=table;                                                         mime_types=table;                       
   
Line 248  gettimeofday(&mt[0],NULL); Line 249  gettimeofday(&mt[0],NULL);
 gettimeofday(&mt[1],NULL);  gettimeofday(&mt[1],NULL);
 #endif  #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, 
Line 262  gettimeofday(&mt[2],NULL); Line 263  gettimeofday(&mt[2],NULL);
                 VString body_vstring_before_post_process(*body_string);                  VString body_vstring_before_post_process(*body_string);
                 VString *body_vstring_after_post_process=&body_vstring_before_post_process;                  VString *body_vstring_after_post_process=&body_vstring_before_post_process;
                 // @postprocess                  // @postprocess
                 if(Value *value=main_class->get_element(*NEW String(pool(), POST_PROCESS_METHOD_NAME)))                  if(Value *value=main_class.get_element(
                                   *NEW String(pool(), POST_PROCESS_METHOD_NAME), 
                                   main_class, 
                                   false))
                         if(Junction *junction=value->get_junction())                          if(Junction *junction=value->get_junction())
                                 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(), method->name, *junction);                                          VMethodFrame frame(pool(), method->name, *junction, 0/*no parent*/);
                                         frame.set_self(*main_class);                                          frame.set_self(main_class);
   
                                         frame.store_param(&body_vstring_before_post_process);                                          frame.store_param(&body_vstring_before_post_process);
                                         body_vstring_after_post_process=                                          body_vstring_after_post_process=
Line 282  gettimeofday(&mt[2],NULL); Line 286  gettimeofday(&mt[2],NULL);
   
                 // extract response body                  // extract response body
                 Value *body_value=static_cast<Value *>(                  Value *body_value=static_cast<Value *>(
                         response.fields().get(*body_name));                          response.fields().get(*download_name));
                   bool as_attachment=body_value!=0;
                   if(!body_value)
                           body_value=static_cast<Value *>(
                                   response.fields().get(*body_name));
   
                 if(body_value) // there is some $response:body                  if(body_value) // there is some $response:body
                         body_file=body_value->as_vfile();                          body_file=body_value->as_vfile();
                 else if(lorigins_mode)                  else if(lorigins_mode)
Line 295  gettimeofday(&mt[3],NULL); Line 304  gettimeofday(&mt[3],NULL);
 #endif  #endif
   
                 // OK. write out the result                  // OK. write out the result
                 output_result(*body_file, header_only);                  output_result(*body_file, header_only, as_attachment);
   
 #ifdef RESOURCES_DEBUG  #ifdef RESOURCES_DEBUG
                 //measure:after output_result                  //measure:after output_result
Line 352  t[9]-t[3] Line 361  t[9]-t[3]
                         // this is what we'd return in $response:body                          // this is what we'd return in $response:body
                         const String *body_string=0;                          const String *body_string=0;
   
                         if(main_class) { // we've managed to end up with some main_class                          // maybe we'd be lucky enough as to report an error
                                 // maybe we'd be lucky enough as to report an error                          // in a gracefull way...
                                 // in a gracefull way...                          if(Value *value=main_class.get_element(
                                 if(Value *value=main_class->get_element(                                          *NEW String(pool(), UNHANDLED_EXCEPTION_METHOD_NAME), 
                                         *NEW String(pool(), UNHANDLED_EXCEPTION_METHOD_NAME)))                                          main_class,
                                         if(Junction *junction=value->get_junction())                                          false)) {
                                                 if(const Method *method=junction->method) {                                  if(Junction *junction=value->get_junction()) {
                                                         // preparing to pass parameters to                                           if(const Method *method=junction->method) {
                                                         //      @unhandled_exception[exception;stack]                                                  // preparing to pass parameters to 
                                                         VMethodFrame frame(pool(), method->name, *junction);                                                  //      @unhandled_exception[exception;stack]
                                                         frame.set_self(*main_class);                                                  VMethodFrame frame(pool(), method->name, *junction, 0/*no caller*/);
                                                   frame.set_self(main_class);
                                                         // $exception  
                                                         frame.store_param(&exception2vhash(pool(), e));                                                  // $exception
                                                         // $stack[^table::set{name      origin}]                                                  frame.store_param(&exception2vhash(pool(), e));
                                                         Array& stack_trace_columns=*NEW Array(pool());                                                  // $stack[^table::set{name      origin}]
                                                         stack_trace_columns+=NEW String(pool(), "name");                                                  Array& stack_trace_columns=*NEW Array(pool());
                                                         stack_trace_columns+=NEW String(pool(), "file");                                                  stack_trace_columns+=NEW String(pool(), "name");
                                                         stack_trace_columns+=NEW String(pool(), "lineno");                                                  stack_trace_columns+=NEW String(pool(), "file");
                                                         Table& stack_trace=*NEW Table(pool(), 0, &stack_trace_columns);                                                  stack_trace_columns+=NEW String(pool(), "lineno");
                                                         Array_iter tracei(exception_trace);                                                  Table& stack_trace=*NEW Table(pool(), 0, &stack_trace_columns);
                                                         while(tracei.has_next()) {                                                  Array_iter tracei(exception_trace);
                                                                 Array& row=*NEW Array(pool());                                                  while(tracei.has_next()) {
                                                           Array& row=*NEW Array(pool());
   
                                                                 const String *name=(const String *)tracei.next();                                                          const String *name=(const String *)tracei.next();
                                                                 row+=name; // name column                                                          row+=name; // name column
 #ifndef NO_STRING_ORIGIN  #ifndef NO_STRING_ORIGIN
                                                                 const Origin& origin=name->origin();                                                          const Origin& origin=name->origin();
                                                                 if(origin.file) {                                                          if(origin.file) {
                                                                         row+=NEW String(pool(), origin.file, 0, true); // file column                                                                  row+=NEW String(pool(), origin.file, 0, true); // file column
                                                                         char *buf=(char *)malloc(MAX_NUMBER);                                                                  char *buf=(char *)malloc(MAX_NUMBER);
                                                                         size_t buf_size=snprintf(buf, MAX_NUMBER, "%d", 1+origin.line);                                                                  size_t buf_size=snprintf(buf, MAX_NUMBER, "%d", 1+origin.line);
                                                                         row+=NEW String(pool(), buf, buf_size, true); // line column                                                                  row+=NEW String(pool(), buf, buf_size, true); // line column
                                                                 }  
 #endif  
                                                                 stack_trace+=&row;  
                                                         }                                                          }
                                                         frame.store_param(NEW VTable(pool(), &stack_trace));  #endif
                                                           stack_trace+=&row;
                                                         // future $response:body=  
                                                         //   execute ^exception[origin;source;comment;type;code;stack]  
                                                         body_string=&execute_method(frame, *method);  
                                                 }                                                  }
                                                   frame.store_param(NEW VTable(pool(), &stack_trace));
   
                                                   // future $response:body=
                                                   //   execute ^unhandled_exception[exception;stack]
                                                   body_string=&execute_method(frame, *method);
                                           }
                                   }
                         }                          }
                                                   
                         if(!body_string) {  // couldn't report an error beautifully?                          if(!body_string) {  // couldn't report an error beautifully?
Line 431  t[9]-t[3] Line 442  t[9]-t[3]
                         const VFile *body_file=body_vstring.as_vfile();                          const VFile *body_file=body_vstring.as_vfile();
   
                         // ERROR. write it out                          // ERROR. write it out
                         output_result(*body_file, header_only);                          output_result(*body_file, header_only, false);
                 } catch(const Exception& ) {                  } catch(const Exception& ) {
                         /*re*/throw;                          /*re*/throw;
                 }                  }
         }          }
 }  }
   
 VStateless_class *Request::use_file(const String& file_name,   VStateless_class *Request::use_file(VStateless_class& aclass,
                                                                         bool ignore_class_path, bool fail_on_read_problem,                                                                          const String& file_name, bool ignore_class_path, 
                                                                         const String *name,                                                                           bool fail_on_read_problem, bool fail_on_file_absence) {
                                                                         VStateless_class *base_class) {  
         // cyclic dependence check          // cyclic dependence check
         if(used_files.get(file_name))          if(used_files.get(file_name))
                 return base_class;                  return 0;
         used_files.put(file_name, (Hash::Val *)true);          used_files.put(file_name, (Hash::Val *)true);
   
         const String *file_spec;          const String *file_spec;
Line 454  VStateless_class *Request::use_file(cons Line 464  VStateless_class *Request::use_file(cons
                 file_spec=&absolute(file_name);                  file_spec=&absolute(file_name);
         else {          else {
                 file_spec=0;                  file_spec=0;
                 if(main_class)                  if(Value *element=main_class.get_element(*class_path_name, main_class, false)) {
                         if(Value *element=main_class->get_element(*class_path_name)) {                          if(element->is_string()) {
                                 if(element->is_string()) {                                  file_spec=file_readable(absolute(element->as_string()), file_name); // found at class_path?
                                         file_spec=file_readable(absolute(element->as_string()), file_name); // found at class_path?                          } else if(Table *table=element->get_table()) {
                                 } else if(Table *table=element->get_table()) {                                  int size=table->size();
                                         int size=table->size();                                  for(int i=size; i--; ) {
                                         for(int i=size; i--; ) {                                          const String& path=*static_cast<Array *>(table->get(i))->get_string(0);
                                                 const String& path=*static_cast<Array *>(table->get(i))->get_string(0);                                          if(file_spec=file_readable(absolute(path), file_name))
                                                 if(file_spec=file_readable(absolute(path), file_name))                                                  break; // found along class_path
                                                         break; // found along class_path                                  }
                                         }                          } else
                                 } else                                  throw Exception("parser.runtime",
                                         throw Exception("parser.runtime",                                          0,
                                                 0,                                          "$" CLASS_PATH_NAME " must be string or table");
                                                 "$" CLASS_PATH_NAME " must be string or table");                          if(!file_spec)
                                 if(!file_spec)                                  throw Exception("parser.runtime",
                                         throw Exception("parser.runtime",                                          &file_name,
                                                 &file_name,                                          "not found along " MAIN_CLASS_NAME ":" CLASS_PATH_NAME);
                                                 "not found along " MAIN_CLASS_NAME ":" CLASS_PATH_NAME);                  }
                         }  
                 if(!file_spec)                  if(!file_spec)
                         throw Exception("parser.runtime",                          throw Exception("parser.runtime",
                                 &file_name,                                  &file_name,
                                 "usage failed - no $" MAIN_CLASS_NAME  ":" CLASS_PATH_NAME " were specified");                                  "usage failed - no $" MAIN_CLASS_NAME  ":" CLASS_PATH_NAME " were specified");
         }          }
   
           if(fail_on_read_problem && !fail_on_file_absence) // ignore file absence if asked for
                   if(!entry_exists(*file_spec))
                           return 0;
   
         char *source=file_read_text(pool(), *file_spec, fail_on_read_problem);          char *source=file_read_text(pool(), *file_spec, fail_on_read_problem);
         if(!source)          if(!source)
                 return base_class;                  return 0;
   
         return use_buf(source, *file_spec, file_spec->cstr(), 0/*new class*/, name, base_class);          return use_buf(aclass, source, *file_spec, file_spec->cstr());
 }  }
   
   
 VStateless_class *Request::use_buf(const char *source,   VStateless_class *Request::use_buf(VStateless_class& aclass,
                                                                    const String& filespec, const char *filespec_cstr,                                                                     const char *source, 
                                                                    VStateless_class *aclass, const String *name,                                                                      const String& filespec, const char *filespec_cstr) {
                                                                    VStateless_class *base_class) {          // temporary zero @conf so to maybe-replace it in compiled code
         // compile loaded class          Temp_method temp_method_conf(aclass, *conf_method_name, 0);
         VStateless_class& cclass=COMPILE(source, aclass, name, base_class, filespec_cstr);          // temporary zero @auto so to maybe-replace it in compiled code
           Temp_method temp_method_auto(aclass, *auto_method_name, 0);
   
         VString *vfilespec=NEW VString(filespec);          // compile loaded class
           VStateless_class& cclass=COMPILE(aclass, source, filespec_cstr);
   
         // locate and execute possible @conf[] static          // locate and execute possible @conf[] static
           VString *vfilespec=NEW VString(filespec);
         const Method *method_called;          const Method *method_called;
         execute_nonvirtual_method(cclass,           execute_nonvirtual_method(cclass, 
                 *conf_method_name, vfilespec,                  *conf_method_name, vfilespec,
                 0/*no result needed*/, &method_called);                  0/*no result needed*/, &method_called);
         if(method_called) {          if(method_called)
                 if(!main_class)  
                         main_class=&cclass; // for root auto.p, when main_class not assigned yet  
                 configure_admin(cclass, &method_called->name);                  configure_admin(cclass, &method_called->name);
         }  
   
         // locate and execute possible @auto[] static          // locate and execute possible @auto[] static
         execute_nonvirtual_method(cclass,           execute_nonvirtual_method(cclass, 
Line 532  const String& Request::absolute(const St Line 545  const String& Request::absolute(const St
                 result << relative_name;                  result << relative_name;
                 return result;                  return result;
         } else           } else 
                 return relative(info.path_translated, relative_name);                  return relative_name.pos("://")<0? relative(info.path_translated, relative_name)
                           :relative_name; // something like "http://xxx"
 }  }
   
 static void add_header_attribute(const Hash::Key& aattribute, Hash::Val *ameaning,   static void add_header_attribute(const Hash::Key& aattribute, Hash::Val *ameaning, 
                                                                  void *info) {                                                                   void *info) {
         Request& r=*static_cast<Request *>(info);          Request& r=*static_cast<Request *>(info);
         if(aattribute==BODY_NAME          if(aattribute==BODY_NAME
                   || aattribute==DOWNLOAD_NAME
                 || aattribute==CHARSET_NAME)                  || aattribute==CHARSET_NAME)
                 return;                  return;
   
Line 547  static void add_header_attribute(const H Line 562  static void add_header_attribute(const H
   
         SAPI::add_header_attribute(pool,          SAPI::add_header_attribute(pool,
                 aattribute.cstr(),                   aattribute.cstr(), 
                 attributed_meaning_to_string(lmeaning, String::UL_HTTP_HEADER).cstr());                  attributed_meaning_to_string(lmeaning, String::UL_HTTP_HEADER, false)
                           .cstr(String::UL_UNSPECIFIED));
 }  }
 void Request::output_result(const VFile& body_file, bool header_only) {  void Request::output_result(const VFile& body_file, bool header_only, bool as_attachment) {
         // header: cookies          // header: cookies
         cookie.output_result();          cookie.output_result();
                   
           Value *body_file_content_type;
         // set content-type          // set content-type
         if(String *body_file_content_type=static_cast<String *>(          if(body_file_content_type=static_cast<Value *>(
                 body_file.fields().get(*vfile_mime_type_name))) {                  body_file.fields().get(*content_type_name))) {
                 // body file content type                  // body file content type
                 response.fields().put(*content_type_name, body_file_content_type);                  response.fields().put(*content_type_name, body_file_content_type);
         } else {          } else {
Line 569  void Request::output_result(const VFile& Line 586  void Request::output_result(const VFile&
         if(VString *vfile_name=static_cast<VString *>(body_file.fields().get(*name_name)))          if(VString *vfile_name=static_cast<VString *>(body_file.fields().get(*name_name)))
                 if(vfile_name->string()!=NONAME_DAT) {                  if(vfile_name->string()!=NONAME_DAT) {
                         VHash& vhash=*NEW VHash(pool());                          VHash& vhash=*NEW VHash(pool());
                         vhash.hash(0).put(*content_disposition_filename_name, vfile_name);                          Hash& hash=vhash.hash(0);
                           if(as_attachment)
                                   hash.put(*value_name, NEW VString(*content_disposition_value));
                           hash.put(*content_disposition_filename_name, vfile_name);
                         response.fields().put(*content_disposition_name, &vhash);                          response.fields().put(*content_disposition_name, &vhash);
                 }                  }
   
         // prepare header: $response:fields without :body          // prepare header: $response:fields without :body
         response.fields().for_each(add_header_attribute, this);          response.fields().for_each(add_header_attribute, this);
   
         // transcode  
         const void *client_body;          const void *client_body;
         size_t client_content_length;          size_t client_content_length;
         Charset::transcode(pool(),          // transcode text body when "text/*" or simple result
                 pool().get_source_charset(), body_file.value_ptr(), body_file.value_size(),          if(body_file_content_type)
                 pool().get_client_charset(), client_body, client_content_length                  if(Hash *hash=body_file_content_type->get_hash(0))
         );                          body_file_content_type=static_cast<Value *>(hash->get(*value_name));
           if(!body_file_content_type/*vstring.as_vfile*/ || body_file_content_type->as_string().pos("text/")==0) {
                   Charset::transcode(pool(),
                           pool().get_source_charset(), body_file.value_ptr(), body_file.value_size(),
                           pool().get_client_charset(), client_body, client_content_length
                   );
           } else {
                   client_body=body_file.value_ptr();
                   client_content_length=body_file.value_size();
           }
   
         // prepare header: content-length          // prepare header: content-length
         char content_length_cstr[MAX_NUMBER];          char content_length_cstr[MAX_NUMBER];
Line 601  const String& Request::mime_type_of(cons Line 629  const String& Request::mime_type_of(cons
         if(mime_types)          if(mime_types)
                 if(const char *cext=strrchr(user_file_name_cstr, '.')) {                  if(const char *cext=strrchr(user_file_name_cstr, '.')) {
                         String sext(pool(), ++cext);                          String sext(pool(), ++cext);
                         if(mime_types->locate(0, sext))                          if(mime_types->locate(0, sext.change_case(pool(), String::CC_LOWER)))
                                 if(const String *result=mime_types->item(1))                                  if(const String *result=mime_types->item(1))
                                         return *result;                                          return *result;
                                 else                                  else
Line 611  const String& Request::mime_type_of(cons Line 639  const String& Request::mime_type_of(cons
                 }                  }
         return *NEW String(pool(), "application/octet-stream");          return *NEW String(pool(), "application/octet-stream");
 }  }
   
   bool Request::origins_mode() {
           return main_class.get_element(*origins_mode_name, main_class, false)!=0;  // $ORIGINS mode
   }
Removed from v.1.219  
changed lines
  Added in v.1.245.2.1

E-mail: