Roxen.git/ server/ modules/ misc/ webdav.pike > 27d875b826745301ae6460d459f2991b8fb5fdc6 [Annotate]

// Protocol support for RFC 2518 and RFC 4918 

// 

// $Id$ 

// 

// 2003-09-17 Henrik Grubbström 

inherit "module"; 

#include <module.h> 

#include <request_trace.h> 

constant cvs_version = "$Id$"; 

constant thread_safe = 1; 

constant module_name = "WebDAV: Protocol support"; 

constant module_type = MODULE_FIRST; 

constant module_doc  = "Adds support for various HTTP extensions defined " 

  "in <a href='http://rfc.roxen.com/2518'>RFC 2518 (WEBDAV)</a>, such as " 

  "<b>PROPFIND</b> and <b>PROPPATCH</b>."; 

#ifdef DAV_DEBUG 

#define DAV_WERROR(X...)    werror(X) 

#else /* !DAV_DEBUG */ 

#define DAV_WERROR(X...) 

#endif /* DAV_DEBUG */ 

#ifdef IF_HEADER_DEBUG 

#define IF_HDR_MSG(X...) werror (X) 

#else 

#define IF_HDR_MSG(X...) 

#endif 

// Stuff from base_server/configuration.pike: 

#ifdef THREADS 

#define LOCK(X) key=id->conf->_lock(X) 

#define UNLOCK() do{key=0;}while(0) 

#else 

#define LOCK(X) 

#define UNLOCK() 

#endif 

Configuration conf; 

void create() 

{ 

  defvar( "lock-timeout", 3600, "Default lock timeout", TYPE_INT, 

          "Number of seconds a WebDAV lock should by default be valid for. " 

          "Negative disables locking. Zero means that locks default to " 

          "being valid for infinite duration." ); 

  defvar( "max-lock-timeout", 86400, "Maximum lock timeout", TYPE_INT, 

          "Maximum number of seconds a WebDAV lock should be valid for. " 

          "Negative disables the timeout header. " 

          "Zero enables infinite locks. " ); 

} 

void start(int q, Configuration c) 

{ 

  conf = c; 

} 

mapping(string:mixed)|int(-1..0) low_check_if_header(string path, 

                                                     array(array(array(string))) condition, 

                                                     RequestID id) 

{ 

  SIMPLE_TRACE_ENTER(this, "Checking \"If\" header for %O", path); 

  string|int(-1..0) etag; 

  mapping(string:DAVLock) locks; 

 next_condition: 

  foreach(condition, array(array(string)) sub_cond) { 

    SIMPLE_TRACE_ENTER(this, 

                       "Trying condition ( %{%s:%O %})...", sub_cond); 

    int negate; 

    foreach(sub_cond, array(string) token) { 

      switch(token[0]) { 

      case "not": 

        negate = !negate; 

        break; 

      case "etag": 

        if (!etag) { 

          // Get the etag for this resource (if any). 

          // FIXME: We only support straight strings as etag properties. 

          if (!stringp(etag = id->conf->query_property(path, 

                                                       "DAV:getetag", id))) { 

            etag = -1; 

          } 

          IF_HDR_MSG("IF: Etag: %O.\n", etag); 

        } 

        if (etag != token[1]) { 

          // No etag available for this resource, or mismatch. 

          if (!negate) { 

            TRACE_LEAVE("Etag mismatch."); 

            continue next_condition; 

          } 

        } else if (negate) { 

          // Etag match with negated expression. 

          TRACE_LEAVE("Matched negated etag."); 

          continue next_condition; 

        } 

        negate = 0; 

        break; 

      case "key": 

        if (!locks) { 

          locks = id->conf->find_locks(path, 0, 0, id); 

        } 

        if (negate) { 

          if (locks[token[1]]) { 

            TRACE_LEAVE("Matched negated lock."); 

            continue next_condition;        // Fail. 

          } 

        } else if (!locks[token[1]]) { 

          // Lock mismatch. 

          SIMPLE_TRACE_LEAVE("Lock mismatch for key %O.", token[1]); 

          continue next_condition;  // Fail. 

        } 

        negate = 0; 

        break; 

      default: 

        SIMPLE_TRACE_LEAVE("Unsupported condition: %s: %O.", 

                           token[0], token[1]); 

        continue next_condition;    // Fail. 

      } 

    } 

    // Found matching sub-condition. 

    TRACE_LEAVE("Found match."); 

    TRACE_LEAVE("Ok%s."); 

    return 0; 

  } 

  TRACE_LEAVE("Precondition failed."); 

  return Roxen.http_status(Protocols.HTTP.HTTP_PRECOND_FAILED); 

} 

//! Checks that all preconditions specified by any if-header hold true. 

//! 

//! @returns 

//!   Returns @expr{0@} (zero) if all conditions hold true, and typically 

//!   a @[Protocols.HTTP.HTTP_PRECOND_FAILED] error status if not. 

mapping(string:mixed)|int(-1..0) check_if_header(RequestID id) 

{ 

  mapping(string:array(array(array(string)))) if_data = 

    id->get_if_data(); 

  if (!if_data) return 0; 

  foreach(if_data; string path; array(array(array(string))) condition) { 

    if (!path) continue; 

    mapping(string:mixed)|int(-1..0) res = 

      low_check_if_header(path, condition, id); 

    if (res) return res; 

  } 

  return 0; 

} 

mapping(string:mixed)|int(-1..0) first_try(RequestID id) 

{ 

  if (id->misc->internal_get) return 0; 

  mapping(string:mixed)|int(-1..0) res = check_if_header(id); 

  if (res) { 

    return res; 

  } 

  switch(id->method) { 

  case "OPTIONS": 

    return ([ "type":"text/html", 

              "data":"", 

              "extra_heads":([ 

                "Allow":"CHMOD,COPY,DELETE,GET,HEAD,MKCOL,MKDIR,MOVE," 

                "MV,PING,POST,PROPFIND,PROPPATCH,PUT,OPTIONS", 

                "Public":"CHMOD,COPY,DELETE,GET,HEAD,MKCOL,MKDIR,MOVE," 

                "MV,PING,POST,PROPFIND,PROPPATCH,PUT,OPTIONS", 

                "Accept-Ranges":"bytes", 

                "DAV":"1,2", 

              ]), 

    ]); 

  case "LOCK": 

  case "UNLOCK": 

  case "COPY": 

  case "MOVE": 

  case "DELETE": 

  case "PROPFIND": 

  case "PROPPATCH": 

    // These need to be special cased, since they are recursive. 

    return handle_webdav(id); 

  } 

  return 0; 

} 

protected constant SimpleNode = Parser.XML.Tree.SimpleNode; 

protected constant SimpleRootNode = Parser.XML.Tree.SimpleRootNode; 

protected constant SimpleHeaderNode = Parser.XML.Tree.SimpleHeaderNode; 

protected constant SimpleElementNode = Parser.XML.Tree.SimpleElementNode; 

//! Implements PROPPATCH <DAV:set/>. 

class PatchPropertySetCmd 

{ 

  constant command="DAV:set"; 

  string property_name; 

  string|array(SimpleNode) value; 

  protected void create(SimpleNode prop_node) 

  { 

    property_name = prop_node->get_full_name(); 

    value = prop_node->get_children(); 

    if ((sizeof(value) == 1) && 

        (value[0]->get_node_type() == Parser.XML.Tree.XML_TEXT)) { 

      // Special case for a single text node. 

      value = value[0]->get_text(); 

    } 

  } 

  mapping(string:mixed) execute(PropertySet context) 

  { 

#ifdef REQUEST_TRACE 

    RequestID id = context->id; 

    SIMPLE_TRACE_ENTER (0, "Setting property %O to %O", property_name, value); 

#endif 

    mapping(string:mixed) res = context->set_property(property_name, value); 

#ifdef REQUEST_TRACE 

    SIMPLE_TRACE_LEAVE (res ? 

                        sprintf ("Got status %d: %O", res->error, res->rettext) : 

                        ""); 

#endif 

    return res; 

  } 

} 

//! Implements PROPPATCH <DAV:remove/>. 

class PatchPropertyRemoveCmd(string property_name) 

{ 

  constant command="DAV:remove"; 

  mapping(string:mixed) execute(PropertySet context) 

  { 

#ifdef REQUEST_TRACE 

    RequestID id = context->id; 

    SIMPLE_TRACE_ENTER (0, "Removing property %O", property_name); 

#endif 

    mapping(string:mixed) res = context->remove_property(property_name); 

#ifdef REQUEST_TRACE 

    SIMPLE_TRACE_LEAVE (res ? 

                        sprintf ("Got status %d: %O", res->error, res->rettext) : 

                        ""); 

#endif 

    return res; 

  } 

} 

//! Handle WEBDAV requests. 

mapping(string:mixed)|int(-1..0) handle_webdav(RequestID id) 

{ 

  SimpleNode xml_data; 

  SIMPLE_TRACE_ENTER(this, "Handle WEBDAV request %s...", id->method); 

  if (catch { xml_data = id->get_xml_data(); }) { 

    // RFC 2518 8: 

    //   If a server receives ill-formed XML in a request it MUST reject 

    //   the entire request with a 400 (Bad Request). 

    TRACE_LEAVE("Malformed XML."); 

    return Roxen.http_status(400, "Malformed XML data."); 

  } 

  if (!(< "LOCK", "UNLOCK", "COPY", "MOVE", "DELETE", 

          "PROPFIND", "PROPPATCH">)[id->method]) { 

    TRACE_LEAVE("Not implemented."); 

    return Roxen.http_status(501, "Not implemented."); 

  } 

  // RFC 2518 9.2: 

  //   The Depth header is only supported if a method's definition 

  //   explicitly provides for such support. 

  int depth; 

  if ((<"PROPFIND", "COPY", "MOVE", "DELETE", "LOCK">)[id->method]) { 

    depth = ([ "0":0, "1":1, "infinity":0x7fffffff, 0:0x7fffffff ]) 

      [id->request_headers->depth && 

       String.trim_whites(id->request_headers->depth)]; 

    if (zero_type(depth)) { 

      TRACE_LEAVE(sprintf("Bad depth header: %O.", 

                          id->request_headers->depth)); 

      return Roxen.http_status(400, "Unsupported depth."); 

    } 

    switch(id->method) { 

    case "DELETE": 

    case "MOVE": 

      // RFC 4918 9.6.1: 

      // The DELETE method on a collection MUST act as if a "Depth: 

      // infinity" header was used on it. A client MUST NOT submit a 

      // Depth header with a DELETE on a collection with any value but 

      // infinity. 

      // 

      // RFC 4918 9.9.2: 

      // The MOVE method on a collection MUST act as if a "Depth: 

      // infinity" header was used on it. A client MUST NOT submit a 

      // Depth header on a MOVE on a collection with any value but 

      // "infinity". 

      if (depth != 0x7fffffff) { 

        TRACE_LEAVE(sprintf("Bad depth header: %O.", 

                            id->request_headers->depth)); 

        return Roxen.http_status(400, "Unsupported depth."); 

      } 

      break; 

    case "COPY": 

      // RFC 4918 9.8.3: 

      // The COPY method on a collection without a Depth header MUST 

      // act as if a Depth header with value "infinity" was 

      // included. A client may submit a Depth header on a COPY on a 

      // collection with a value of "0" or "infinity". Servers MUST 

      // support the "0" and "infinity" Depth header behaviors on 

      // WebDAV-compliant resources. 

      if (depth == 1) { 

        TRACE_LEAVE(sprintf("Bad depth header: %O.", 

                            id->request_headers->depth)); 

        return Roxen.http_status(400, "Unsupported depth."); 

      } 

      break; 

    } 

  } else if (id->request_headers->depth) { 

    // Depth header not supported in this case. 

  } 

#ifdef URL_MODULES 

  // Check URL modules (eg htaccess). 

  // Ripped from base_server/configuration.pike. 

  foreach(conf->url_modules(), function funp) 

  { 

    PROF_ENTER(Roxen.get_owning_module(funp)->module_name,"url module"); 

#ifdef THREADS 

    Thread.MutexKey key; 

#endif 

    LOCK(funp); 

    TRACE_ENTER("URL module", funp); 

    mapping(string:mixed)|object tmp=funp( id, id->not_query ); 

    UNLOCK(); 

    PROF_LEAVE(Roxen.get_owning_module(funp)->module_name,"url module"); 

    if(mappingp(tmp)) 

    { 

      TRACE_LEAVE(""); 

      TRACE_LEAVE("Returning data"); 

      return tmp; 

    } 

    if(objectp( tmp )) 

    { 

      mixed err; 

      err = catch { 

          tmp = id->conf->low_get_file( tmp, 1 ); 

        }; 

      if(err) throw(err); 

      TRACE_LEAVE(""); 

      TRACE_LEAVE("Returning data"); 

      return tmp; 

    } 

    TRACE_LEAVE(""); 

  } 

#endif 

  // Function to call for matching location modules. 

  // 

  // Arguments: 

  //   string path 

  //   int d 

  //   RoxenModule module 

  //   RequestID id 

  //   mixed ... extras 

  function(string,string,int,RoxenModule,RequestID, 

           mixed ...:mapping(string:mixed)) recur_func; 

  array(mixed) extras = ({}); 

  mapping(string:mixed) empty_result; 

  switch(id->method) { 

  case "LOCK": 

    DAVLock lock; 

    if (!xml_data) { 

      // Refresh. 

      int/*LockFlag*/|DAVLock state = 

        id->conf->check_locks(id->not_query, 0, id); 

      if (intp(state)) { 

        if (state) { 

          TRACE_LEAVE("LOCK: Refresh: locked by other user."); 

          return Roxen.http_status(423, "Locked by other user"); 

        } else { 

          TRACE_LEAVE("LOCK: Refresh: Lock not found."); 

          return Roxen.http_status(424, "Couldn't refresh missing lock."); 

        } 

      } 

      id->conf->refresh_lock(lock = state); 

    } else { 

      // New lock. 

      SimpleNode lock_info_node = 

        xml_data->get_first_element("DAV:lockinfo", 1); 

      if (!lock_info_node) { 

        TRACE_LEAVE("LOCK: No DAV:lockinfo."); 

        return Roxen.http_status(422, "Missing DAV:lockinfo."); 

      } 

      SimpleNode lock_scope_node = 

        lock_info_node->get_first_element("DAV:lockscope", 1); 

      if (!lock_scope_node) { 

        TRACE_LEAVE("LOCK: No DAV:lockscope."); 

        return Roxen.http_status(422, "Missing DAV:lockscope."); 

      } 

      string lockscope; 

      if (lock_scope_node->get_first_element("DAV:exclusive", 1)) { 

        lockscope = "DAV:exclusive"; 

      } 

      if (lock_scope_node->get_first_element("DAV:shared", 1)) { 

        if (lockscope) { 

          TRACE_LEAVE("LOCK: Both DAV:exclusive and DAV:shared."); 

          return Roxen.http_status(422, "Both DAV:exclusive and DAV:shared."); 

        } 

        lockscope = "DAV:shared"; 

      } 

      if (!lockscope) { 

        TRACE_LEAVE("LOCK: Both DAV:lockscope."); 

        return Roxen.http_status(422, "Unsupported DAV:lockscope."); 

      } 

      SimpleNode lock_type_node = 

          lock_info_node->get_first_element("DAV:locktype", 1); 

      if (!lock_type_node) { 

        TRACE_LEAVE("LOCK: Both DAV:locktype."); 

        return Roxen.http_status(422, "Missing DAV:locktype."); 

      } 

      if (!lock_type_node->get_first_element("DAV:write", 1)) { 

        // We only support DAV:write locks. 

        TRACE_LEAVE("LOCK: No DAV:write."); 

        return Roxen.http_status(422, "Missing DAV:write."); 

      } 

      string locktype = "DAV:write"; 

      int expiry_delta = query("lock-timeout"); // Default timeout. 

      if (expiry_delta < 0) { 

        // Locks disabled. 

        TRACE_LEAVE("LOCK: Locks disabled."); 

        return Roxen.http_status(403, "Locking not allowed."); 

      } 

      if (id->request_headers->timeout) { 

        // Parse the timeout header, and use the first valid timeout. 

        foreach(MIME.tokenize(id->request_headers->timeout), 

                string|int entry) { 

          if (intp(entry)) continue;    // ',' etc. 

          if (entry == "Infinite") { 

            if (!query("max-lock-timeout")) { 

              expiry_delta = 0; 

              break; 

            } 

          } else if (has_prefix(entry, "Second-")) { 

            int t; 

            if (sscanf(entry, "Second-%d", t) && (t > 0)) { 

              if (!query("max-lock-timeout") || 

                  (t < query("max-lock-timeout"))) { 

                expiry_delta = t; 

                break; 

              } 

            } 

          } 

        } 

      } 

      array(SimpleNode) owner; 

      if (SimpleNode owner_node = lock_info_node->get_first_element("DAV:owner", 1)) 

        owner = owner_node->get_children(); 

      // Parameters OK, try to create a lock. 

      TRACE_ENTER(sprintf("LOCK: Creating a %s%s lock on %O.", 

                          depth?"recursive ":"", lockscope, id->not_query), 

                  this); 

      mapping(string:mixed)|DAVLock new_lock = 

        id->conf->lock_file(id->not_query, 

                            depth != 0, 

                            lockscope, 

                            "DAV:write", 

                            expiry_delta, 

                            owner, 

                            id); 

      if (mappingp(new_lock)) { 

        // Error 

        // FIXME: Should probably generate a MultiStatus response. 

        //        cf RFC 2518 8.10.10. 

        TRACE_LEAVE("Failed."); 

        TRACE_LEAVE("Returning failure code."); 

        return new_lock; 

      } 

      TRACE_LEAVE("Ok."); 

      lock = new_lock; 

    } 

    string xml = SimpleRootNode()-> 

      add_child(SimpleHeaderNode((["version":"1.0", "encoding":"utf-8"])))-> 

      add_child(SimpleElementNode("DAV:prop", 

                                  ([ "xmlns:DAV":"DAV:", 

                                     "xmlns:MS": 

                                     "urn:schemas-microsoft-com:datatypes" 

                                  ]))-> 

                add_child(SimpleElementNode("DAV:lockdiscovery", ([]))-> 

                          add_child(lock->get_xml())))->render_xml(); 

    TRACE_LEAVE("Returning XML."); 

    return ([ 

      "error":200, 

      "data":xml, 

      "len":sizeof(xml), 

      "type":"text/xml; charset=\"utf-8\"", 

      "extra_heads":([ "Lock-Token":lock->locktoken ]), 

    ]); 

  case "UNLOCK": 

    string locktoken; 

    if (!(locktoken = id->request_headers["lock-token"])) { 

      TRACE_LEAVE("UNLOCK: No lock-token."); 

      return Roxen.http_status(400, "UNLOCK: Missing lock-token header."); 

    } 

    // The lock-token header is a Coded-URL. 

    sscanf(locktoken, "<%s>", locktoken); 

    if (!objectp(lock = id->conf->check_locks(id->not_query, 0, id))) { 

      TRACE_LEAVE(sprintf("UNLOCK: Lock-token %O not found.", locktoken)); 

      return Roxen.http_status(403, "UNLOCK: Lock not found."); 

    }