/** @file Parser: request class main part. @see compile.C and execute.C. Copyright (c) 2001-2026 Art. Lebedev Studio (https://www.artlebedev.com) Authors: Konstantin Morshnev , Alexandr Petrosian */ #include "pa_sapi.h" #include "pa_common.h" #include "pa_os.h" #include "pa_request.h" #include "pa_wwrapper.h" #include "pa_vclass.h" #include "pa_globals.h" #include "pa_vint.h" #include "pa_vmethod_frame.h" #include "pa_types.h" #include "pa_venv.h" #include "pa_vmath.h" #include "pa_vstatus.h" #include "pa_vrequest.h" #include "pa_vtable.h" #include "pa_vfile.h" #include "pa_dictionary.h" #include "pa_charset.h" #include "pa_charsets.h" #include "pa_cache_managers.h" #include "pa_http.h" #include "pa_websocket.h" #include "pa_vmail.h" #include "pa_vform.h" #include "pa_vcookie.h" #include "pa_vresponse.h" #include "pa_vmemory.h" #include "pa_vconsole.h" #include "pa_vdate.h" #include "pa_varray.h" #include "pa_code_cache.h" volatile const char * IDENT_PA_REQUEST_C="$Id: pa_request.C,v 1.474 2026/10/28 01:37:15 moko Exp $" IDENT_PA_REQUEST_H IDENT_PA_REQUEST_CHARSETS_H IDENT_PA_REQUEST_INFO_H IDENT_PA_VCONSOLE_H; // consts #define UNHANDLED_EXCEPTION_METHOD_NAME "unhandled_exception" /// content type of response when no $MAIN:defaults.content-type defined const char* DEFAULT_CONTENT_TYPE="text/html"; // One recursion level uses ~0.85KB of stack under linux/gcc, ~1KB under win32 and ~2KB under win64. // MSVC win64 exception handling requires an extra ~10KB !!! for each throw, and execute() catches and // rethrows on every level to provide a stack trace. // So 1000 levels need ~1MB under linux (default 8MB stack is enough) and ~2+10=12MB under win64. // Worse, win64 keeps the unwound frames until the catch block returns, so a handler running away // in its turn starts on top of them and needs one more such budget. The stack is set to 40MB in // the MSVC project settings to allow nested three runaways. const int EXECUTE_RECURSION_LIMIT=1000; const int EXECUTE_RECURSION_RESERVE=100; const int LOOP_LIMIT=100000; const int ARRAY_LIMIT=1000000; const int HTTPD_TIMEOUT=4; const size_t FILE_SIZE_LIMIT=512*0x400*0x400; // 512MB const size_t POST_MAX_SIZE=10*0x400*0x400; // 10MB // defines for globals #define MAIN_METHOD_NAME "main" #define AUTO_METHOD_NAME "auto" #define USE_METHOD_NAME "use" #define AUTOUSE_METHOD_NAME "autouse" #define ORIGIN_KEY "origin" // globals const String main_method_name(MAIN_METHOD_NAME); const String auto_method_name(AUTO_METHOD_NAME); static const String use_method_name(USE_METHOD_NAME); static const String autouse_method_name(AUTOUSE_METHOD_NAME); static const String origin_key(ORIGIN_KEY); int pa_loop_limit=LOOP_LIMIT; int pa_array_limit=ARRAY_LIMIT; int pa_execute_recursion_limit=EXECUTE_RECURSION_LIMIT; int pa_httpd_timeout=HTTPD_TIMEOUT; THREAD_LOCAL size_t pa_file_size_limit=FILE_SIZE_LIMIT; THREAD_LOCAL size_t pa_post_max_size=POST_MAX_SIZE; // defines for statics #define MIME_TYPES_NAME "MIME-TYPES" #define CLASS_PATH_NAME "CLASS_PATH" #define DOWNLOAD_NAME_UPPER "DOWNLOAD" #define BODY_NAME_UPPER "BODY" // statics static const String main_class_name(MAIN_CLASS_NAME); static const String mime_types_name(MIME_TYPES_NAME); static const String class_path_name(CLASS_PATH_NAME); static const String charsets_name("CHARSETS"); static const String strict_vars_name("STRICT-VARS"); static const String prototype_name("OBJECT-PROTOTYPE"); static const String getter_protected_name("CLASS-GETTER-PROTECTED"); static const String locals_name("LOCALS"); static const String limits_name("LIMITS"); static const String loop_limit_name("max_loop"); static const String array_limit_name("max_array_size"); static const String recursion_limit_name("max_recursion"); static const String file_size_limit_name("max_file_size"); static const String post_max_size_name("post_max_size"); static const String lock_wait_timeout_name("lock_wait_timeout"); static const String httpd_name("HTTPD"); static const String httpd_timeout_name("timeout"); static const String httpd_mode_name("mode"); static const String httpd_max_connections_name("max-connections"); #ifdef CODE_CACHE static const String httpd_code_cache_name("code-cache"); #endif static const String conf_method_name("conf"); static const String post_process_method_name("postprocess"); static const String response_body_file_name("file"); 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); const String content_disposition_filename_name(CONTENT_DISPOSITION_FILENAME_NAME); const String content_disposition_filename_name_asterisk("filename*"); // defines #define CHARSET_NAME_UPPER "CHARSET" #define LAST_MODIFIED_NAME_UPPER "LAST-MODIFIED" // op.C VStateless_class& VClassMAIN_create(); // void Request::recursion_limit_reached() { if(execute_recursion_limit>pa_execute_recursion_limit) throw Recursion_limit_exception(); execute_recursion_limit+=EXECUTE_RECURSION_RESERVE; throw Exception(PARSER_RUNTIME, 0, "call canceled - endless recursion detected"); } void Request::throw_interrupted() { finterrupted=0; set_skip(SKIP_NOTHING); throw Interrupted_exception(response.timeout); } Request::Request(SAPI_Info& asapi_info, Request_info& arequest_info, String::Language adefault_lang): // private anti_endless_execute_recursion(0), execute_recursion_limit(pa_execute_recursion_limit), // public allow_class_replace(false), method_frame(0), rcontext(0), wcontext(0), fconnection(0), fin_cycle(0), fskip(SKIP_NOTHING), finterrupted(0), // public request_info(arequest_info), sapi_info(asapi_info), charsets(pa_UTF8_charset, pa_UTF8_charset, pa_UTF8_charset), // default charsets main_class(VClassMAIN_create()), form(*new VForm(charsets, arequest_info)), mail(*new VMail), response(*new VResponse(arequest_info, charsets, adefault_lang)), cookie(*new VCookie(charsets, arequest_info)), console(*new VConsole), websocket(0), // private configure_admin_done(false), // private mime types mime_types(0) { // file_no=0 => unknown file_list+=String::Body("UNKNOWN"); file_list+=String::Body("-body of process-"); // pseudo_file_no__process #ifdef CODE_CACHE Code_cache_manager::add_files(file_list); #endif // maybe expire old caches cache_managers->maybe_expire(); /// directly used // MAIN class, operators put_class(&main_class); // classes: // table, file, random, mail, image, ... methoded_array().register_directly_used(*this); /// methodless // env class put_class(new VEnv(asapi_info)); // status class put_class(new VStatus()); // request class put_class(new VRequest(arequest_info, charsets, form, asapi_info)); // cookie class put_class(&cookie); // console class put_class(&console); /// methoded // response class put_class(&response); // form class put_class(&form); // mail class put_class(&mail); // math class put_class(new VMath); // memory class put_class(new VMemory); // the last: the destructor is not called if the constructor throws thread_request=this; } Request::~Request() { thread_request=0; #ifdef XML // if for some strange reason xml generic errors failed to be reported, free them up if(const char* xml_generic_errors=xmlGenericErrors()) { SAPI::log(sapi_info, "warning: unreported xmlGenericErrors: %s", xml_generic_errors); pa_free((void *)xml_generic_errors); } #endif } Value& Request::get_self() { return method_frame/*always have!*/->self(); } VStateless_class* Request::get_class(const String& name){ VStateless_class* result=classes().get(name); if(!result) if(const Method *method=main_class.get_element_method(autouse_method_name)){ Value *vname=new VString(name); CONSTRUCTOR_FRAME_ACTION(*method, 0 /*no parent*/, main_class, { frame.store_params(&vname, 1); // we don't need the result call(frame); }); result=classes().get(name); } return result; } VStateless_class& Request::get_class_ref(const String& name){ VStateless_class* result=get_class(name); if(!result) throw Exception(PARSER_RUNTIME, &name, "class is undefined"); return *result; } bool Request::add_class(const char* atype, VStateless_class *aclass){ if(!classes().put_dont_replace(String::Body(atype), aclass)) return true; if(!allow_class_replace && strcmp(atype, VARRAY_TYPE)) return false; classes().remove(String::Body(atype)); classes().put(atype, aclass); return true; } static void load_charset(HashStringValue::key_type akey, HashStringValue::value_type avalue, Request_charsets* charsets) { pa_charsets.load_charset(*charsets, akey, avalue->as_string()); } #define CONF_OPTION(config, name, code, exception_name) \ if(config) \ if(Value* option=config->get_element(name)) { \ if(option->is_evaluated_expr()) { \ code; \ } else \ throw Exception(PARSER_RUNTIME, 0, "$MAIN:" exception_name, name.cstr()); \ } void Request::configure_admin(VStateless_class& conf_class) { if(configure_admin_done) throw Exception(PARSER_RUNTIME, 0, "parser already configured"); configure_admin_done=true; // charsets must only be specified in method_frame config // so that users would not interfere /* $MAIN:CHARSETS[ $.charsetname1[/full/path/to/charset/file.cfg] ... ] */ if(Value* vcharsets=conf_class.get_element(charsets_name)) { if(!vcharsets->is_string()) { if(HashStringValue* charsets=vcharsets->get_hash()) charsets->for_each(load_charset, &this->charsets); else throw Exception(PARSER_RUNTIME, 0, "$MAIN:%s must be hash", charsets_name.cstr()); } } Value* conf=&conf_class; #ifdef STRICT_VARS bool strict_vars=false; CONF_OPTION(conf, strict_vars_name, { strict_vars=option->as_bool(); }, "%s must be bool"); VVoid::strict_vars=strict_vars; #endif #ifdef OBJECT_PROTOTYPE bool prototype=true; CONF_OPTION(conf, prototype_name, { prototype=option->as_bool(); }, "%s must be bool"); VClass::prototype=prototype; #endif #ifdef CLASS_GETTER_UNPROTECTED bool getter_protected=true; CONF_OPTION(conf, getter_protected_name, { getter_protected=option->as_bool(); }, "%s must be bool"); VClass::getter_protected=getter_protected; // thread local: changes in Temp_getter_protected #endif bool all_vars_local=false; CONF_OPTION(conf, locals_name, { all_vars_local=option->as_bool(); if(all_vars_local) main_class.set_all_vars_local(); }, "%s must be bool"); VStateless_class::gall_vars_local=all_vars_local; Value* limits=conf_class.get_element(limits_name); int loop_limit=LOOP_LIMIT; CONF_OPTION(limits, loop_limit_name, { loop_limit=option->as_int(); if(loop_limit==0) loop_limit=INT_MAX; }, "LIMITS.%s must be int"); pa_loop_limit=loop_limit; int array_limit=ARRAY_LIMIT; CONF_OPTION(limits, array_limit_name, { array_limit=option->as_int(); if(array_limit==0) array_limit=INT_MAX; }, "LIMITS.%s must be int"); pa_array_limit=array_limit; execute_recursion_limit=EXECUTE_RECURSION_LIMIT; CONF_OPTION(limits, recursion_limit_name, { execute_recursion_limit=option->as_int(); if(execute_recursion_limit<=0) execute_recursion_limit=INT_MAX; execute_recursion_limit=min(execute_recursion_limit, INT_MAX-EXECUTE_RECURSION_RESERVE); }, "LIMITS.%s must be int"); pa_execute_recursion_limit=execute_recursion_limit; size_t file_size_limit=FILE_SIZE_LIMIT; CONF_OPTION(limits, file_size_limit_name, { double limit=option->as_double(); if(limit >= (double)SSIZE_MAX) throw Exception(PARSER_RUNTIME, 0, "$MAIN:LIMITS.%s must be less than %s", file_size_limit_name.cstr(), pa_itoa(SSIZE_MAX)); file_size_limit=(size_t)limit; if(file_size_limit==0) file_size_limit=SSIZE_MAX; }, "LIMITS.%s must be number"); pa_file_size_limit=file_size_limit; // thread local: url-dependent size_t post_max_size=POST_MAX_SIZE; CONF_OPTION(limits, post_max_size_name, { double limit=option->as_double(); if(limit >= (double)SSIZE_MAX) throw Exception(PARSER_RUNTIME, 0, "$MAIN:LIMITS.%s must be less than %s", post_max_size_name.cstr(), pa_itoa(SSIZE_MAX)); if(limit > 0) post_max_size=(size_t)limit; }, "LIMITS.%s must be number"); pa_post_max_size=post_max_size; // thread local: url-dependent unsigned int lock_attempts=PA_LOCK_ATTEMPTS; CONF_OPTION(limits, lock_wait_timeout_name, { double limit=option->as_double(); if(limit >= 3600*24) throw Exception(PARSER_RUNTIME, 0, "$MAIN:LIMITS.%s must be less than %d", lock_wait_timeout_name.cstr(), 3600*24); lock_attempts=(unsigned int)(limit*2)+1; }, "LIMITS.%s must be number"); pa_lock_attempts=lock_attempts; Value* httpd=conf_class.get_element(httpd_name); #ifdef CODE_CACHE CONF_OPTION(httpd, httpd_code_cache_name, { Code_cache_manager::set_enabled(option->as_bool()); }, "HTTPD.%s must be bool"); #endif int httpd_timeout=HTTPD_TIMEOUT; CONF_OPTION(httpd, httpd_timeout_name, { httpd_timeout=option->as_int(); if(httpd_timeout==0) httpd_timeout=INT_MAX; }, "HTTPD.%s must be int"); pa_httpd_timeout=httpd_timeout; int httpd_max_connections=INT_MAX; CONF_OPTION(httpd, httpd_max_connections_name, { httpd_max_connections=option->as_int(); if(httpd_max_connections<=0) httpd_max_connections=INT_MAX; }, "HTTPD.%s must be int"); HTTPD_Server::max_connections=httpd_max_connections; if(httpd) if(Value* option=httpd->get_element(httpd_mode_name)) { if(option->get_junction()) throw Exception(PARSER_RUNTIME, 0, "$MAIN:HTTPD:mode must be string"); HTTPD_Server::set_mode(option->as_string()); } // configure method_frame options // until someone with less privileges have overriden them methoded_array().configure_admin(*this); } const char* Request::get_exception_cstr(const Exception& e, VException& details) { #define PA_URI_FORMAT "%s: " #define PA_COMMENT_TYPE_FORMAT "%s [%s]" #define PA_ORIGIN_FILE_POS_FORMAT "%s(%d:%d): " #define PA_SOURCE_FORMAT "'%s' " #define PA_ORIGIN_FILE_POS_VALUE file_list[details.origin.file_no].cstr(), 1+details.origin.line, 1+details.origin.col, #define PA_SOURCE_VALUE details.problem_source->cstr(), #define EXCEPTION_CSTR(f1,v1,f2,v2) \ pa_snprintf(result, MAX_STRING, \ PA_URI_FORMAT \ f1 f2 \ PA_COMMENT_TYPE_FORMAT, \ request_info.uri, \ v1 v2 \ e.comment(), e.type() \ ); char* result=new(PointerFreeGC) char[MAX_STRING]; if(details.problem_source) { // do we know the guy? if(details.origin.file_no) // do whe know where he came from? EXCEPTION_CSTR(PA_ORIGIN_FILE_POS_FORMAT, PA_ORIGIN_FILE_POS_VALUE, PA_SOURCE_FORMAT, PA_SOURCE_VALUE) else EXCEPTION_CSTR(PA_SOURCE_FORMAT, PA_SOURCE_VALUE,,) } else { if(details.origin.file_no) // do whe know where he came from? EXCEPTION_CSTR(PA_ORIGIN_FILE_POS_FORMAT, PA_ORIGIN_FILE_POS_VALUE,,) else EXCEPTION_CSTR(,,,) } return result; } Table &Request::Exception_trace::table(Request &r, const String* problem_source, size_t bottom, size_t top){ // $stack[^table::create{name file lineno colno}] Table::columns_type stack_trace_columns(new ArrayString); *stack_trace_columns+=new String("name"); *stack_trace_columns+=new String("file"); *stack_trace_columns+=new String("lineno"); *stack_trace_columns+=new String("colno"); Table& stack_trace=*new Table(stack_trace_columns); if(bottomclose(); // graceful: waits for the Close of the client // ignore the result in websocket or stream mode if(response.started) return; // extract response body Value* body_value=response.fields().get(download_name_upper); // $response:download? bool as_attachment=body_value!=0; if(!body_value) body_value=response.fields().get(body_name_upper); // $response:body if(!body_value) body_value=new VString(*body_string); // just result of ^main[] // @postprocess if(const Method *method=main_class.get_method(post_process_method_name)) { METHOD_FRAME_ACTION(*method, 0 /*no parent*/, main_class, { frame.store_params(&body_value, 1); call(frame); body_value=&frame.result(); }); } // can throw exceptions while handling $response:download[] output_result(body_value->as_vfile(response.lang, &charsets), header_only, as_attachment); } catch(const Exception& e) { // request handling problem // OK, as native execution stack has unwound anti_endless_execute_recursion=0; // we're returning not result, but error explanation VException& details=*new VException(*this, e); const char* exception_cstr=get_exception_cstr(e, details); // reset response response.fields().clear(); response.lang=response.default_lang; SAPI::clear_headers(sapi_info); // this is what we'd return in $response:body const String* body_string=0; try { // maybe we'd be lucky enough as to report an error in a gracefull way... if(const Method *method=main_class.get_method(*new String(UNHANDLED_EXCEPTION_METHOD_NAME))) { // preparing parameters to @unhandled_exception[exception;stack] Table& stack_trace=exception_trace.table(*this, details.problem_source); details.expire_trace(); exception_trace.clear(); // forget all about previous life, in case there would be error inside of this method, error handled would not be mislead by old stack contents (see extract_origin) Value *params[]={&details, new VTable(&stack_trace)}; METHOD_FRAME_ACTION(*method, 0 /*no caller*/, main_class, { frame.store_params(params, 2); call(frame); body_string=&frame.result().as_string(); }); } // conditionally log it Value* vhandled=details.handled(); if(!vhandled || !vhandled->as_bool()) { SAPI::log(sapi_info, "%s", exception_cstr); } } catch(const Exception& e) { // exception in @unhandled_exception VException& details=*new VException(*this, e); // logging both initial and new exceptions SAPI::log(sapi_info, "%s", exception_cstr); SAPI::log(sapi_info, "Exception in @unhandled_exception at %s", get_exception_cstr(e, details)); if(!response.started) SAPI::send_error(sapi_info, "Exception in @unhandled_exception, details are available in Parser error log."); return; } if(body_string) { // could report an error beautifully? VString body_vstring(*body_string); output_result(body_vstring.as_vfile(response.lang, &charsets), header_only, false); } else if(!response.started) { // doing that ugly SAPI::send_error(sapi_info, exception_cstr, strcmp(e.type(), "file.missing") ? "500" : "404"); } } } uint Request::register_file(String::Body file_spec) { file_list+=file_spec; return file_list.count()-1; } void Request::use_file_directly(const String& file_spec, bool fail_on_file_absence, bool with_auto_p) { // cyclic dependence check if(used_files.get(file_spec)) return; used_files.put(file_spec, true); if(!fail_on_file_absence && !entry_exists(file_spec)) // ignore file absence if asked for return; if(with_auto_p) { // loading auto.p files from document_root/.. // to the one beside requested file. // all assigned bases from upper dir const char* target=file_spec.cstr(); // all relative paths are calculated from main document request_info.path_translated=target; const char* after=target; size_t drlen=strlen(request_info.document_root_path); if(path_cmp(after, request_info.document_root_path, drlen)==0) after+=drlen; // to start from document_root/auto.p while(const char* before=strchr(after, '/')) { String& sfile_spec=*new String; if(after!=target) { sfile_spec.append_strdup(target, before-target, String::L_CLEAN); sfile_spec << "/" AUTO_FILE_NAME; use_file_directly(sfile_spec, false /*ignore absence, sole user*/); } for(after=before+1;*after=='/';after++); } } Code_cache* code=0; #ifdef CODE_CACHE if(Code_cache* cached=Code_cache_manager::get(file_spec)) { use_buf(main_class, 0, 0, cached->file_no, 0, cached); return; } // to record the compilation; only while the httpd config runs code=Code_cache_manager::create(file_spec); #endif if(const char* source=file_read_text(charsets, file_spec, true)) use_buf(main_class, source, 0, register_file(file_spec), 0, code); } void Request::use_file(const String& afile_name, const String* use_filespec/*absolute*/, bool with_auto_p) { if(afile_name.is_empty()) throw Exception(PARSER_RUNTIME, 0, "usage failed - no filename was specified"); const String* filespec=0; const String& file_name=backslashes_to_slashes(afile_name); if(file_name.first_char()=='/' || path_scheme(afile_name) || is_os_absolute_path(afile_name)) // path is not relative, no need to scan MAIN:CLASS_PATH filespec=&full_disk_path(afile_name); else if(use_filespec){ // search in current dir first size_t last_slash_pos=use_filespec->strrchr('/'); if(last_slash_pos!=STRING_NOT_FOUND) filespec=file_exist(use_filespec->mid(0, last_slash_pos), file_name); // found in current dir? } if(!filespec){ // prevent multiple scan CLASS_PATH for searching one file if(searched_along_class_path.get(file_name)) return; searched_along_class_path.put(file_name, true); if(Value* element=main_class.get_element(class_path_name)) { if(element->is_string()) { filespec=file_exist(full_disk_path(element->as_string()), file_name); // found at class_path? } else if(Table *table=element->get_table()) { for(size_t i=table->count(); i--; ) { const String& path=*(*table->get(i))[0]; if(filespec=file_exist(full_disk_path(path), file_name)) break; // found along class_path } } else throw Exception(PARSER_RUNTIME, 0, "$" CLASS_PATH_NAME " must be string or table"); if(!filespec) throw Exception(PARSER_RUNTIME, &file_name, "not found along $MAIN:" CLASS_PATH_NAME); } else throw Exception(PARSER_RUNTIME, &file_name, "usage failed - no $MAIN:" CLASS_PATH_NAME " were specified"); } use_file_directly(*filespec, true, with_auto_p); } void Request::use_file(const String& file_name, const String* use_filespec/*absolute*/, Operation::Origin origin) { static String use("USE"); try { static VHash* voptions=new VHash(); if(const Method *method=main_class.get_method(use_method_name)){ Value *params[]={new VString(file_name), voptions}; voptions->hash().put(origin_key, new VString(*use_filespec)); CONSTRUCTOR_FRAME_ACTION(*method, 0 /*no parent*/, main_class, { frame.store_params(params, 2); // we don't need the result call(frame); }); } } catch (...) { exception_trace.push(Trace(&use, origin)); rethrow; } } void Request::use_buf(VStateless_class& aclass, const char* source, const String* main_alias, uint file_no, int line_no_offset, Code_cache* code) { // temporary zero @conf to avoid it second execution Temp_method temp_method_conf(aclass, conf_method_name, 0); // temporary zero @auto to avoid it second execution Temp_method temp_method_auto(aclass, auto_method_name, 0); // compile loaded classes ArrayClass& cclasses= #ifdef CODE_CACHE !source ? code->replay(*this, aclass) : #endif compile(&aclass, source, main_alias, file_no, line_no_offset, code); VString* vfilespec= new VString(file_list[file_no]); for(size_t i=0; iname*/); // locate and execute possible @auto[] static execute_auto_method_if_exists(cclass, auto_method_name, vfilespec); cclass.enable_default_setter(); } } const String& Request::relative(const char* apath, const String& relative_name) { // apath is a URI or a path already normalized by the target, always slash separated char *hpath=pa_strdup(apath); String& result=*new String; if(rsplit(hpath, '/')) // if something/splitted result << hpath << "/"; result << relative_name; return result; } void Request_info::set_document_root(const char* adocument_root) { document_root=adocument_root; char* path=backslashes_to_slashes(adocument_root); if(path) { size_t length=strlen(path); while(length && path[length-1]=='/') path[--length]=0; } document_root_path=path; } const String& Request::full_disk_path(const String& relative_name, uint allowed) { if(relative_name.first_char()!='/') { if(uint scheme=path_scheme(relative_name)) { check_path_scheme(scheme, relative_name, allowed); if(scheme!=PA_SCHEME_FILE) return relative_name; // an allowed uri is passed through if(const String* path=file_uri_to_path(relative_name)) return backslashes_to_slashes(*path); #ifdef WIN32 throw Exception(PARSER_RUNTIME, &relative_name, "must be file:///path, file://localhost/path or file://server/share/path"); #else throw Exception(PARSER_RUNTIME, &relative_name, "must be file:///path or file://localhost/path"); #endif } // before '\' becomes '/', to avoid mixing the UNC path \\server with web path //server if(is_os_absolute_path(relative_name)) return backslashes_to_slashes(relative_name); } const String& path=backslashes_to_slashes(relative_name); if(path.first_char()!='/') return relative(request_info.path_translated ? request_info.path_translated : pa_strcat(request_info.document_root_path, "/"), path); String& result=*new String(request_info.document_root_path); result << path; return result; } const String* Request::real_disk_path(const String& name) { switch(path_scheme(name)) { case PA_SCHEME_NONE: return &full_disk_path(name); case PA_SCHEME_FILE: { const String* path=clean_path_scheme(PA_SCHEME_FILE, name) ? file_uri_to_path(name) : 0; return path ? &backslashes_to_slashes(*path) : 0; } default: return 0; // not a disk path } } #ifndef DOXYGEN class Add_header_attribute_info { public: Add_header_attribute_info(Request& ar) : r(ar), add_last_modified(true) {} Request& r; bool add_last_modified; }; #endif static void add_header_attribute(HashStringValue::key_type name, HashStringValue::value_type value, Add_header_attribute_info* info) { if(name==BODY_NAME_UPPER || name==DOWNLOAD_NAME_UPPER || name==CHARSET_NAME_UPPER) 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); SAPI::add_header_attribute(info->r.sapi_info, aname, attributed_meaning_to_string(*value, String::L_URI, false).untaint_and_transcode_cstr(String::L_URI, &info->r.charsets) ); } static void output_sole_piece(Request& r, bool header_only, VFile& body_file, Value* body_file_content_type) { // transcode text body when "text/*" or simple result String::C output(body_file.value_ptr(), body_file.value_size()); if(!body_file_content_type/*vstring.as_vfile*/ || body_file_content_type->as_string().pos("text/")==0) output=Charset::transcode(output, r.charsets.source(), r.charsets.client()); // prepare header: Content-Length SAPI::add_header_attribute(r.sapi_info, HTTP_CONTENT_LENGTH, pa_uitoa(output.length)); // send header SAPI::send_headers(r.sapi_info); // send body if(!header_only) SAPI::send_body(r.sapi_info, output.str, output.length); } #ifndef DOXYGEN struct Range { uint64_t start; uint64_t end; }; #endif #define UNSET ((uint64_t)-1) static void parse_range(const String* s, Array &ar) { const char *p = s->cstr(); if(s->starts_with("bytes=")) p += 6; Range r; while(*p){ r.start = UNSET; r.end = UNSET; while(*p==' ' || *p=='\t') p++; if(*p >= '0' && *p <= '9'){ const char *n=p; while(*p>='0' && *p<='9') p++; r.start = pa_atoul(pa_strdup(n, p-n)); // ((uint64_t)-1) is treated as UNSET } while(*p==' ' || *p=='\t') p++; if(*p++ != '-') break; while(*p==' ' || *p=='\t') p++; if(*p >= '0' && *p <= '9'){ const char *n=p; while(*p>='0' && *p<='9') p++; r.end = pa_atoul(pa_strdup(n, p-n)); // ((uint64_t)-1) is treated as UNSET } while(*p==' ' || *p=='\t') p++; if(*p) if(*p++ != ',') break; ar += r; } } struct Send_range_action_info { Request *r; uint64_t offset; uint64_t part_length; }; static void send_range(struct stat& /*finfo*/, int f, const String& /*file_spec*/, void *context){ Send_range_action_info &info = *(Send_range_action_info*)context; SAPI::send_headers(info.r->sapi_info); pa_lseek(f, info.offset, SEEK_SET); char buf[FILE_BUFFER_SIZE]; do{ size_t to_read = info.part_length < FILE_BUFFER_SIZE ? (size_t)info.part_length : FILE_BUFFER_SIZE; size_t to_write = file_block_read(f, buf, to_read); if(to_write == 0) break; size_t size = SAPI::send_body(info.r->sapi_info, buf, to_write); if(size != to_write) break; info.part_length -= to_write; } while (info.part_length); } static void output_pieces(Request& r, bool header_only, const String& filename, uint64_t content_length, Value& date, bool add_last_modified) { SAPI::add_header_attribute(r.sapi_info, "accept-ranges", "bytes"); const char *range = SAPI::Env::get(r.sapi_info, "HTTP_RANGE"); uint64_t offset=0; uint64_t part_length=content_length; if(range && content_length){ Array ar; parse_range(new String(range), ar); int count = ar.count(); if(count == 1){ Range &rg = ar.get_ref(0); if(rg.start == UNSET && rg.end == UNSET) return SAPI::send_error(r.sapi_info, "", "416"); if(rg.start == UNSET && rg.end != UNSET){ if(rg.end == 0) return SAPI::send_error(r.sapi_info, "", "416"); if(rg.end > content_length) rg.end = content_length; rg.start = content_length - rg.end; rg.end = content_length-1; } else if(rg.start != UNSET && rg.end == UNSET){ if(rg.start >= content_length) return SAPI::send_error(r.sapi_info, "", "416"); rg.end = content_length-1; } else { if(rg.start >= content_length || rg.start > rg.end) return SAPI::send_error(r.sapi_info, "", "416"); if(rg.end >= content_length) rg.end = content_length-1; } offset = rg.start; part_length = rg.end-rg.start+1; char buf[MAX_STRING]; pa_snprintf(buf, MAX_STRING, "bytes %s-%s/%s", pa_uitoa(rg.start), pa_uitoa(rg.end), pa_uitoa(content_length)); SAPI::add_header_attribute(r.sapi_info, HTTP_STATUS, "206"); SAPI::add_header_attribute(r.sapi_info, "content-range", buf); } else { return SAPI::send_error(r.sapi_info, count ? "Multiple ranges are not supported" : "Invalid range", count ? "501" : "400"); } } SAPI::add_header_attribute(r.sapi_info, HTTP_CONTENT_LENGTH, pa_uitoa(part_length)); if(add_last_modified) SAPI::add_header_attribute(r.sapi_info, "last-modified", attributed_meaning_to_string(date, String::L_AS_IS, true).cstr()); if(header_only){ SAPI::send_headers(r.sapi_info); } else { Send_range_action_info info = { &r, offset, part_length}; file_read_action_under_lock(r.full_disk_path(filename), "send", send_range, &info); } } void Request::output_result(VFile* body_file, bool header_only, bool as_attachment) { if(response.started) return; // header: cookies cookie.output_result(sapi_info); // $.file and $.name (when body is real vfile) Value* vfile = body_file->fields().get(response_body_file_name); Value* vname = body_file->fields().get(name_name); const String* sfile = vfile ? &vfile->as_string() : NULL; const String* sname = vname ? &vname->as_string() : NULL; if(sname && *sname == NONAME_DAT) sname = NULL; // Content-Disposition, use $.name[] to avoid const String* disposition_name = sname ? sname->is_empty() ? NULL : sname : sfile; if(disposition_name) { String& filename = *new String(pa_filename(disposition_name->cstr()), String::L_URI); String& filename_asterisk = *new String(charsets.client().NAME(), String::L_CLEAN) << (*new String("''")) << filename; VHash& hash=*new VHash(); hash.hash().put(value_name, new VString(as_attachment ? content_disposition_attachment : content_disposition_inline)); hash.hash().put(content_disposition_filename_name, new VString(filename)); hash.hash().put(content_disposition_filename_name_asterisk, new VString(filename_asterisk)); response.fields().put(content_disposition_name_upper, &hash); } // _file_ content-type might be specified Value* body_file_content_type = body_file->fields().get(content_type_name); if(!body_file_content_type){ const String* scontent_name = sname && !sname->is_empty() ? sname : sfile; if(scontent_name) body_file_content_type = new VString(mime_type_of(scontent_name->cstr())); } // set Content-Type if(body_file_content_type) { // body file content type response.fields().put(content_type_name_upper, body_file_content_type); } else { // 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 Add_header_attribute_info info(*this); response.fields().for_each(add_header_attribute, &info); if(sfile) { // $response:[download|body][$.file[filespec]] -- optput specified file uint64_t content_length=0; time_t atime=0, mtime=0, ctime=0; file_stat(full_disk_path(*sfile), content_length, atime, mtime, ctime); VDate* vdate=0; if(Value* v=body_file->fields().get("mdate")) { vdate=dynamic_cast(v); if(!vdate) throw Exception(PARSER_RUNTIME, 0, "mdate must be a date"); } if(!vdate) vdate=new VDate((pa_time_t)mtime); output_pieces(*this, header_only, *sfile, content_length, *vdate, info.add_last_modified); } else { if(body_file_content_type) if(HashStringValue *hash=body_file_content_type->get_hash()) body_file_content_type=hash->get(value_name); output_sole_piece(*this, header_only, *body_file, body_file_content_type); } } void Request::start(VResponse::Started mode) { // the headers: cookies and $response:fields, without Content-Length // prepare before response.started is set: after that an exception is not reported to the client cookie.output_result(sapi_info); Add_header_attribute_info info(*this); response.fields().for_each(add_header_attribute, &info); response.started=mode; SAPI::send_headers(sapi_info); } void Request::stream(Value& part) { if(response.started==VResponse::WEBSOCKET) throw Exception("websocket", 0, "unable to stream: websocket is active"); // convert before response.started is set: after that an exception is not reported to the client VFile* file=dynamic_cast(&part); String::C output=file ? String::C(file->value_ptr(), file->value_size()) : String::C(part.get_string()->cstr_to_string_body_untaint(response.lang, 0, &charsets)); if(!file || file->is_text_mode()) output=Charset::transcode(output, charsets.source(), charsets.client()); if(!response.started) { response.fields().put_dont_replace(content_type_name_upper, new VString(*new String(DEFAULT_CONTENT_TYPE))); start(VResponse::STREAM); } if(!is_header_only(request_info)) SAPI::send_body(sapi_info, output.str, output.length); } const String& Request::mime_type_of(const String* file_name) { return mime_type_of(file_name?file_name->taint_cstr(String::L_FILE_SPEC):0); } const String& Request::mime_type_of(const char* user_file_name_cstr) { // built at the first use: $MAIN:MIME-TYPES (table or @GET_MIME-TYPES[] property) if(!mime_types) { Value* element=main_class.get_element(mime_types_name); TEMP_GETTER_PROTECTED(false); // @GET_MIME-TYPES[] assigns $MIME-TYPES, which replaces the getter with the table Table *table=element ? process(*element).get_table() : 0; mime_types=table ? table : new Table(0); // empty if nothing is defined } if(const char* cext=strrchr(user_file_name_cstr, '.')) { String sext(++cext); Table::Action_options options; if(mime_types->locate(0, sext.change_case(charsets.source(), String::CC_LOWER), options)) { if(const String* result=mime_types->item(1)) return *result; else throw Exception(PARSER_RUNTIME, 0, MIME_TYPES_NAME " table column elements must not be empty"); } } return *new String("application/octet-stream"); } const String* Request::get_used_filespec(uint file_no){ if(file_no < file_list.count()) return new String(file_list[file_no], String::L_TAINTED); return 0; } #ifdef XML xmlChar* Request::transcode(const String& s) { return charsets.source().transcode(s); } xmlChar* Request::transcode(const String::Body s) { return charsets.source().transcode(s); } const String& Request::transcode(const xmlChar* s) { return charsets.source().transcode(s); } #endif VException::VException(Request& r, const Exception& e): fexception(e), fhandled(&VBool::get(false)), ftrace_bottom(r.exception_trace.bottom_index()), ftrace_top(r.exception_trace.top_index()), origin(Operation::Origin::create(0, 0, 0)), problem_source(e.problem_source()) { Request::Exception_trace& exception_trace=r.exception_trace; if(!exception_trace.is_empty()) { Request::Trace bottom=exception_trace.bottom_value(); origin=bottom.origin(); if(!problem_source) // we don't know who trigged the bug problem_source=bottom.name(); // we usually know source of next-from-throw-point exception did that } if(origin.file_no) ffile=r.file_list[origin.file_no]; } Value* VException::handled() { return fhash ? fhash->get(Symbols::HANDLED_SYMBOL) : fhandled; } Table& VException::stack(Request& r) { if(ftrace_top==size_t(-1)) throw Exception(PARSER_RUNTIME, 0, "exception stack used outside of context"); return r.exception_trace.table(r, problem_source, ftrace_bottom, ftrace_top); } Value* VException::get_element(const String& name) { if(!fhash) { if(SYMBOLS_EQ(name,HANDLED_SYMBOL)) return fhandled; if(SYMBOLS_EQ(name,TYPE_SYMBOL)) return fexception.type(true) ? new VString(*new String(fexception.type())) : 0; if(SYMBOLS_EQ(name,SOURCE_SYMBOL)) return problem_source ? new VString(*problem_source) : 0; if(SYMBOLS_EQ(name,COMMENT_SYMBOL)) return fexception.comment(true) ? new VString(fexception.comment()) : 0; if(SYMBOLS_EQ(name,FILE_SYMBOL)) return origin.file_no ? new VString(ffile) : 0; if(SYMBOLS_EQ(name,LINENO_SYMBOL)) return origin.file_no ? new VInt(1+origin.line) : 0; if(SYMBOLS_EQ(name,COLNO_SYMBOL)) return origin.file_no ? new VInt(1+origin.col) : 0; if(SYMBOLS_EQ(name,FIELDS_SYMBOL)) return this; } // Computed field names need not be interned: use ordinary hash lookup. return VHashReference::get_element(name); } const VJunction* VException::put_element(const String& name, Value* value) { if(!fhash && SYMBOLS_EQ(name,HANDLED_SYMBOL)) { fhandled=value; return 0; } return VHashReference::put_element(name, value); } HashStringValue& VException::hash() { if(fhash) return *fhash; HashStringValue& result=*new HashStringValue; if(const char* type=fexception.type(true)) result.put(Symbols::TYPE_SYMBOL, new VString(*new String(type))); if(problem_source) result.put(Symbols::SOURCE_SYMBOL, new VString(*problem_source)); if(origin.file_no) { result.put(Symbols::FILE_SYMBOL, new VString(ffile)); result.put(Symbols::LINENO_SYMBOL, new VInt(1+origin.line)); result.put(Symbols::COLNO_SYMBOL, new VInt(1+origin.col)); } if(const char* comment=fexception.comment(true)) result.put(Symbols::COMMENT_SYMBOL, new VString(comment)); result.put(Symbols::HANDLED_SYMBOL, fhandled); fhash=&result; return result; } 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()); }