Roxen.git/ server/ base_server/ module.pike > 265ca4ebf0f8f56628d5e55a63644c9efd3ec486 [Annotate]

// This file is part of Roxen WebServer. 

// Copyright © 1996 - 2001, Roxen IS. 

// $Id: module.pike,v 1.134 2003/06/02 12:06:31 grubba Exp $ 

#include <module_constants.h> 

#include <module.h> 

#include <request_trace.h> 

constant __pragma_save_parent__ = 1; 

inherit "basic_defvar"; 

mapping(string:array(int)) error_log=([]); 

constant is_module = 1; 

// constant module_type = MODULE_ZERO; 

// constant module_name    = "Unnamed module"; 

// constant module_doc     = "Undocumented"; 

constant module_unique  = 1; 

private Configuration _my_configuration; 

private string _module_local_identifier; 

private string _module_identifier = 

  lambda() { 

    mixed init_info = roxen->bootstrap_info->get(); 

    if (arrayp (init_info)) { 

      [_my_configuration, _module_local_identifier] = init_info; 

      return _my_configuration->name + "/" + _module_local_identifier; 

    } 

  }(); 

static mapping _api_functions = ([]); 

string|array(string) module_creator; 

string module_url; 

RXML.TagSet module_tag_set; 

/* These functions exists in here because otherwise the messages in 

 * the event log does not always end up in the correct 

 * module/configuration.  And the reason for that is that if the 

 * messages are logged from subclasses in the module, the DWIM in 

 * roxenlib.pike cannot see that they are logged from a module. This 

 * solution is not really all that beautiful, but it works. :-) 

 */ 

void report_fatal( mixed ... args )  { predef::report_fatal( @args );  } 

void report_error( mixed ... args )  { predef::report_error( @args );  } 

void report_notice( mixed ... args ) { predef::report_notice( @args ); } 

void report_debug( mixed ... args )  { predef::report_debug( @args );  } 

string module_identifier() 

//! Returns a string that uniquely identifies this module instance 

//! within the server. The identifier is the same as 

//! @[Roxen.get_module] and @[Roxen.get_modname] handles. 

{ 

#if 1 

  return _module_identifier; 

#else 

  if (!_module_identifier) { 

    string|mapping name = this_object()->register_module()[1]; 

    if (mappingp (name)) name = name->standard; 

    string cname = sprintf ("%O", my_configuration()); 

    if (sscanf (cname, "Configuration(%s", cname) == 1 && 

        sizeof (cname) && cname[-1] == ')') 

      cname = cname[..sizeof (cname) - 2]; 

    _module_identifier = sprintf ("%s,%s", 

                                  name||this_object()->module_name, cname); 

  } 

  return _module_identifier; 

#endif 

} 

string module_local_id() 

//! Returns a string that uniquely identifies this module instance 

//! within the configuration. The returned string is the same as the 

//! part after the first '/' in the one returned from 

//! @[module_identifier]. 

{ 

  return _module_local_identifier; 

} 

RoxenModule this_module() 

{ 

  return this_object(); // To be used from subclasses. 

} 

string _sprintf() 

{ 

  return sprintf ("RoxenModule(%s)", _module_identifier || "?"); 

} 

array register_module() 

{ 

  return ({ 

    this_object()->module_type, 

    this_object()->module_name, 

    this_object()->module_doc, 

    0, 

    module_unique, 

    this_object()->module_locked, 

  }); 

} 

string fix_cvs(string from) 

{ 

  from = replace(from, ({ "$", "Id: "," Exp $" }), ({"","",""})); 

  sscanf(from, "%*s,v %s", from); 

  return replace(from,"/","-"); 

} 

int module_dependencies(Configuration configuration, 

                        array (string) modules, 

                        int|void now) 

//! If your module depends on other modules present in the server, 

//! calling <pi>module_dependencies()</pi>, supplying an array of 

//! module identifiers. A module identifier is either the filename 

//! minus extension, or a string on the form that Roxen.get_modname 

//! returns. In the latter case, the <config name> and <copy> parts 

//! are ignored. 

{ 

  modules = map (modules, 

                 lambda (string modname) { 

                   sscanf ((modname / "/")[-1], "%[^#]", modname); 

                   return modname; 

                 }); 

  Configuration conf = configuration || my_configuration(); 

  if (!conf) 

    report_warning ("Configuration not resolved; module(s) %s that %s " 

                    "depend on weren't added.", String.implode_nicely (modules), 

                    module_identifier()); 

  else 

    conf->add_modules( modules, now ); 

  return 1; 

} 

string file_name_and_stuff() 

{ 

  return ("<b>Loaded from:</b> "+(roxen->filename(this_object()))+"<br>"+ 

          (this_object()->cvs_version? 

           "<b>CVS Version: </b>"+ 

           fix_cvs(this_object()->cvs_version)+"\n":"")); 

} 

Configuration my_configuration() 

//! Returns the Configuration object of the virtual server the module 

//! belongs to. 

{ 

  return _my_configuration; 

} 

nomask void set_configuration(Configuration c) 

{ 

  if(_my_configuration && _my_configuration != c) 

    error("set_configuration() called twice.\n"); 

  _my_configuration = c; 

} 

void set_module_creator(string|array(string) c) 

//! Set the name and optionally email address of the author of the 

//! module. Names on the format "author name <author_email>" will 

//! end up as links on the module's information page in the admin 

//! interface. In the case of multiple authors, an array of such 

//! strings can be passed. 

{ 

  module_creator = c; 

} 

void set_module_url(string to) 

//! A common way of referring to a location where you maintain 

//! information about your module or similar. The URL will turn up 

//! on the module's information page in the admin interface, 

//! referred to as the module's home page. 

{ 

  module_url = to; 

} 

void free_some_sockets_please(){} 

void start(void|int num, void|Configuration conf) {} 

string status() {} 

string info(Configuration conf) 

{ 

 return (this_object()->register_module()[2]); 

} 

string sname( ) 

{ 

  return my_configuration()->otomod[ this_object() ]; 

} 

ModuleInfo my_moduleinfo( ) 

//! Returns the associated @[ModuleInfo] object 

{ 

  string f = sname(); 

  if( f ) return roxen.find_module( (f/"#")[0] ); 

} 

void save_me() 

{ 

  my_configuration()->save_one( this_object() ); 

  my_configuration()->module_changed( my_moduleinfo(), this_object() ); 

} 

void save()      { save_me(); } 

string comment() { return ""; } 

string query_internal_location() 

//! Returns the internal mountpoint, where <ref>find_internal()</ref> 

//! is mounted. 

{ 

  if(!_my_configuration) 

    error("Please do not call this function from create()!\n"); 

  return _my_configuration->query_internal_location(this_object()); 

} 

string query_absolute_internal_location(RequestID id) 

//! Returns the internal mountpoint as an absolute path. 

{ 

  return (id->misc->site_prefix_path || "") + query_internal_location(); 

} 

string query_location() 

//! Returns the mountpoint as an absolute path. The default 

//! implementation uses the "location" configuration variable in the 

//! module. 

{ 

  string s; 

  catch{s = query("location");}; 

  return s; 

} 

array(string) location_urls() 

//! Returns an array of all locations where the module is mounted. 

{ 

  string loc = query_location(); 

  if (!loc) return ({}); 

  if(!_my_configuration) 

    error("Please do not call this function from create()!\n"); 

  array(string) urls = copy_value(_my_configuration->query("URLs")); 

  string hostname; 

  if (string world_url = _my_configuration->query ("MyWorldLocation")) 

    sscanf (world_url, "%*s://%s%*[:/]", hostname); 

  if (!hostname) hostname = gethostname(); 

  for (int i = 0; i < sizeof (urls); i++) 

  { 

    urls[i] = (urls[i]/"#")[0]; 

    if (sizeof (urls[i]/"*") == 2) 

      urls[i] = replace(urls[i], "*", hostname); 

  } 

  return map (urls, `+, loc[1..]); 

} 

/* By default, provide nothing. */ 

string query_provides() { return 0; } 

function(RequestID:int|mapping) query_seclevels() 

{ 

  if(catch(query("_seclevels")) || (query("_seclevels") == 0)) 

    return 0; 

  return roxen.compile_security_pattern(query("_seclevels"),this_object()); 

} 

Stat stat_file(string f, RequestID id){} 

array(string) find_dir(string f, RequestID id){} 

mapping(string:Stat) find_dir_stat(string f, RequestID id) 

{ 

  TRACE_ENTER("find_dir_stat(): \""+f+"\"", 0); 

  array(string) files = find_dir(f, id); 

  mapping(string:Stat) res = ([]); 

  foreach(files || ({}), string fname) { 

    TRACE_ENTER("stat()'ing "+ f + "/" + fname, 0); 

    Stat st = stat_file(replace(f + "/" + fname, "//", "/"), id); 

    if (st) { 

      res[fname] = st; 

      TRACE_LEAVE("OK"); 

    } else { 

      TRACE_LEAVE("No stat info"); 

    } 

  } 

  TRACE_LEAVE(""); 

  return(res); 

} 

// ISO 8601 Date and Time 

// RFC 2518 23.2 

// No fraction, UTC only. 

static string iso8601_date_time(int ts) 

{ 

  mapping(string:int) gmt = gmtime(ts); 

  return sprintf("%04d-%02d-%02dT%02d:%02d:%02dZ", 

                 1900 + gmt->year, gmt->mon, gmt->mday, 

                 gmt->hour, gmt->min, gmt->sec); 

} 

//! Returns a multiset with the names off all supported properties. 

multiset(string) query_all_properties(string path, RequestID id) 

{ 

  Stat st = stat_file(path, id); 

  if (!st) return (<>); 

  multiset(string) res = (< 

    "DAV:creationdate",             // 13.1 

    "DAV:displayname",              // 13.2 

    "DAV:getlastmodified",  // 13.7 

  >); 

  if (st->isreg) { 

    res += (< 

      "DAV:getcontentlength",       // 13.4 

      "DAV:getcontenttype", // 13.5 

    >); 

  } 

  return res; 

} 

//! Returns the value of the specified property, or an error code 

//! mapping. 

//! 

//! @note 

//!   Returning a string is shorthand for returning an array 

//!   with a single text node. 

string|array(Parser.XML.Tree.Node)|mapping(string:mixed) 

  query_property(string path, string prop_name, RequestID id) 

{ 

  Stat st = stat_file(path, id); 

  if (!st) return 0;            // FIXME: No such file. 

  switch(prop_name) { 

  case "DAV:creationdate":      // 13.1 

    return iso8601_date_time(st->ctime); 

  case "DAV:displayname":       // 13.2 

    return combine_path(query_location(), path); 

  case "DAV:getcontentlength":  // 13.4 

    if (st->isreg) { 

      return (string)st->size; 

    } 

    break; 

  case "DAV:getcontenttype":    // 13.5 

    if (st->isreg) { 

      return id->conf-> 

        type_from_filename(path, 0, 

                           lower_case(Roxen.extension(path, id))); 

    } 

    break; 

  case "DAV:getlastmodified":   // 13.7 

    return iso8601_date_time(st->mtime); 

  default: 

    break; 

  } 

  return 0; // FIXME: No such property. 

} 

//! Attempt to set property @[prop_name] for @[path] to @[value]. 

//! 

//! @param value 

//!   Value to set the node to. 

//!   The case of an array of a single text node is special cased, 

//!   and is sent as a @expr{string@}. 

//! 

//! @returns 

//!   Returns a result mapping. May return @expr{0@} (zero) on success. 

//! 

//! @note 

//!   Actual changing of the property should be done first 

//!   when @[patch_property_commit()] is called, or unrolled 

//!   when @[patch_property_unroll()] is called. 

//! 

//! @note 

//!   Overloaded variants should only set live properties; 

//!   setting of dead properties should be done throuh 

//!   overloading of @[set_dead_property()]. 

mapping(string:mixed) set_property(string path, string prop_name, 

                                   string|array(Parser.XML.Tree.Node) value, 

                                   RequestID id) 

{ 

  switch(prop_name) { 

  case "DAV:creationdate":      // 13.1 

  case "DAV:displayname":       // 13.2 

  case "DAV:getcontentlength":  // 13.4 

  case "DAV:getcontenttype":    // 13.5 

  case "DAV:getlastmodified":   // 13.7 

    return Roxen.http_low_answer(409, 

                                 "Attempt to set read-only property."); 

  } 

  return set_dead_property(path, prop_name, value, id); 

} 

//! Attempt to set dead property @[prop_name] for @[path] to @[value]. 

//! 

//! @returns 

//!   Returns a result mapping. May return @expr{0@} (zero) on success. 

//! 

//! @note 

//!   Actual changing of the property should be done first 

//!   when @[patch_property_commit()] is called, or unrolled 

//!   when @[patch_property_unroll()] is called. 

//! 

//! @note 

//!   This function is called as a fallback by @[set_property()] 

//!   if all else fails. 

//! 

//! @note 

//!   The default implementation currently does not support setting 

//!   of dead properties, and will return an error code. 

mapping(string:mixed) set_dead_property(string path, string prop_name, 

                                        array(Parser.XML.Tree.Node) value, 

                                        RequestID id) 

{ 

  return Roxen.http_low_answer(405, 

                               "Setting of dead properties is not supported."); 

} 

//! Attempt to remove the property @[prop_name] for @[path]. 

//! 

//! @note 

//!   Actual removal of the property should be done first 

//!   when @[patch_property_commit()] is called, or unrolled 

//!   when @[patch_property_unroll()] is called. 

//! 

//! @returns 

//!   Returns a result mapping. May return @expr{0@} (zero) on success. 

//! 

//! @note 

//!   The default implementation does not support deletion. 

mapping(string:mixed) remove_property(string path, string prop_name, 

                                      RequestID id) 

{ 

  switch(prop_name) { 

  case "DAV:creationdate":      // 13.1 

  case "DAV:displayname":       // 13.2 

  case "DAV:getcontentlength":  // 13.4 

  case "DAV:getcontenttype":    // 13.5 

  case "DAV:getlastmodified":   // 13.7 

    return Roxen.http_low_answer(409, 

                                 "Attempt to remove a read-only property."); 

  } 

  return Roxen.http_low_answer(404, 

                               "Attempt to remove an unknown property."); 

} 

//! Default implementation of some RFC 2518 properties. 

//! 

//! @param path 

//!   @[query_location()]-relative path. 

//! @param mode 

//!   Query-mode. Currently one of 

//!   @string mode 

//!     @value "DAV:propname" 

//!       Query after names of supported properties. 

//!     @value "DAV:allprop" 

//!       Query after all properties and their values. 

//!     @value "DAV:prop" 

//!       Query after properties specified by @[filt] and 

//!       their values. 

//!   @endstring 

//! @param result 

//!   Result object. 

//! @param id 

//!   Id of the current request. 

//! @param filt 

//!   Optional multiset of requested properties. If this parameter 

//!   is @expr{0@} (zero) then all available properties are requested. 

//! 

//! @note 

//!   id->not_query() does not necessarily contain the same value as @[path]. 

void find_properties(string path, string mode, MultiStatus result, 

                     RequestID id, multiset(string)|void filt) 

{ 

  Stat st = stat_file(path, id); 

  if (!st) return; 

  switch(mode) { 

  case "DAV:propname": 

    foreach(indices(query_all_properties(path, id)), string prop_name) { 

      result->add_property(path, prop_name, ""); 

    } 

    return; 

  case "DAV:allprop": 

    filt = query_all_properties(path, id); 

    // FALL_THROUGH 

  case "DAV:prop": 

    foreach(indices(filt), string prop_name) { 

      result->add_property(path, prop_name, 

                           query_property(path, prop_name, id)); 

    } 

    return; 

  } 

  // FIXME: Unsupported DAV operation. 

  return; 

} 

void recurse_find_properties(string path, string mode, int depth, 

                             MultiStatus result, 

                             RequestID id, multiset(string)|void filt) 

{ 

  Stat st = stat_file(path, id); 

  if (!st) return; 

  find_properties(path, mode, result, id, filt); 

  if ((depth <= 0) || !st->isdir) return; 

  depth--; 

  foreach(find_dir(path, id), string filename) { 

    recurse_find_properties(combine_path(path, filename), mode, depth, 

                            result, id, filt); 

  } 

} 

// RFC 2518 8.2 

//   Instructions MUST either all be executed or none executed. 

//   Thus if any error occurs during procesing all executed 

//   instructions MUST be undone and a proper error result 

//   returned. 

//! Signal start of patching of properties for @[path]. 

void patch_property_start(string path, RequestID id) 

{ 

} 

//! Patching of the properties for @[path] failed. 

//! Restore the state to what it was when @[patch_property_start()] 

//! was called. 

void patch_property_unroll(string path, RequestID id) 

{ 

} 

//! Patching of the properties for @[path] succeeded. 

void patch_property_commit(string path, RequestID id) 

{ 

} 

void patch_properties(string path, array(PatchPropertyCommand) instructions, 

                      MultiStatus result, RequestID id) 

{ 

  patch_property_start(path, id); 

  array(mapping(string:mixed)) results; 

  mixed err = catch { 

    results = instructions->execute(path, this_object(), id); 

  }; 

  if (err) { 

    report_debug("patch_properties() failed:\n" 

                 "%s\n", 

                 describe_backtrace(err)); 

    mapping(string:mixed) answer =