modules/webdav/webdav.module

<?php

/* This file is part of "WebDav for Drupal Module".
 *    Copyright 2009, arNuméral
 *    Author : Yoran Brault
 *    eMail  : yoran.brault@bad_arnumeral.fr (remove bad_ before sending an email)
 *    Site   : http://www.arnumeral.fr/node/5
 *
 * "WebDav for Drupal Module" is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2.1 of
 * the License, or (at your option) any later version.
 *
 * "WebDav for Drupal Module" is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public
 * License along with "Broken Anchor for Node comments Module"; if not, write to the Free
 * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
 */


require_once "server.inc";

define('WEBDAV_ROOT_MENU', 'webdav');
define('WEBDAV_VERSION', '6.x-1.0-rc7');


/* permissions */
define('WEBDAV_PERMS_WEBDAV_ACCESS', "WebDAV access");


define('WEBDAV_STATUS_OK',"200 OK");
define('WEBDAV_STATUS_CREATED',"201 Created");
define('WEBDAV_STATUS_NO_CONTENT',"204 No Content");
define('WEBDAV_STATUS_NOT_FOUND', "404 Not Found");
define('WEBDAV_STATUS_FORBIDDEN', "403 Forbidden");
define('WEBDAV_STATUS_INTERNAL_SERVER_ERROR',"500 Internal Server Error");
define('WEBDAV_STATUS_NOT_IMPLEMENTED',"501 Not Implemented");
define('WEBDAV_STATUS_CONFLICT',"409 Conflict");
define('WEBDAV_STATUS_MOVED_PERMANENTLY', '301 Moved Permanently');
define('WEBDAV_STATUS_UNAUTHORIZED', '401 Unauthorized');

define('WEBDAV_CONTENT_XML',0);
define('WEBDAV_CONTENT_DRUPAL',1);
define('WEBDAV_CONTENT_BINARY',2);


function webdav_parse_path($path) {
  $path=trim($path,"/");
  if (strlen($path)>0) {
    $route=explode("/",$path);
  } else {
    $route=array();
  }
  array_unshift($route, "root");
  return $route;
}

/**
 * Session is basicaly a wrapper arround
 * and exploded path called as 'arguments'
 *
 * @param $path ressource path
 * @return session array
 */
function webdav_session_create($path) {
  $tmp=webdav_parse_path($path);

  // Decode the path as it comes from real URL
  for($i=0; $i < count($tmp); $i++) {
    if ($i!=1) {
      $route[]=webdav_url_decode($tmp[$i]);
    }
  }

  // build the context
  return (object)array(
    'path'=>$path,
    'route'=>$route,
    'error'=>false,
  );
}

function webdav_url_decode($source) {
  $result=rawurldecode($source);
  $result=strtr($result,array("[NB]"=>"#"));
  return $result;
}

function webdav_url_encode($source) {
  $result=rawurlencode($source);
  $result=strtr($result,array("#"=>"[NB]"));
  if (webdav_client_is_gnome()) {
    // GVFS don't like to have encoded version for those characters...
    $result=strtr($result,array("%27"=>"'", "%2C"=>",", ";"=>"%59"));
  }
  return $result;
}

function webdav_mime_type($file_path)
{
  $mtype = '';
  if (function_exists('mime_content_type')){
    $mtype = mime_content_type($file_path);
  }
  else if (function_exists('finfo_file')){
    $finfo = finfo_open(FILEINFO_MIME);
    $mtype = finfo_file($finfo, $file_path);
    finfo_close($finfo);
  }
  if ($mtype == ''){
    $mtype = "application/force-download";
  }
  return $mtype;
}

function webdav_user_authenticate($form_values = array()) {
  global $user;

  // Name and pass keys are required.
  if (!empty($form_values['name']) && !empty($form_values['pass']) &&
  $account = user_load(array('name' => $form_values['name'], 'pass' => trim($form_values['pass']), 'status' => 1))) {
    $user = $account;
    webdav_user_authenticate_finalize($form_values);
    return $user;
  }
}

/**
 * This is a copy of original Drupal Core function.
 *
 * @param unknown_type $edit
 */
function webdav_user_authenticate_finalize(&$edit) {
  global $user;

  /**
   * We don't want to be logged like this as there is no such a thing as
   * WebDAV session. So each query would log something here...
   */
  //  watchdog('user', 'Session opened for %name.', array('%name' => $user->name));
  //  // Update the user table timestamp noting user has logged in.
  //  // This is also used to invalidate one-time login links.
  //  $user->login = time();
  //  db_query("UPDATE {users} SET login = %d WHERE uid = %d", $user->login, $user->uid);

  /*
   * We Don't need to regenarate session as we just don't use this. Cookie will be clean
   * anyway in webdav_handler
   */
  // Regenerate the session ID to prevent against session fixation attacks.
  //  sess_regenerate();
  user_module_invoke('login', $edit, $user);
}

function webdav_check_collection_perms($handler) {
  if ($handler===false) {
    return true;
  }

  // If no access defined, we juste drop any attempt to access
  if (!$handler['access']) {
    if (webdav_is_debug()) webdav_debug("No access perms defined for '".webdav_format_route($handler['route'])."' collection.");
    webdav_session_set_status(WEBDAV_STATUS_FORBIDDEN);
    return false;
  }

  // Lets get authentication stuff
  $auth_type = isset($_SERVER["AUTH_TYPE"])? $_SERVER["AUTH_TYPE"]: null;
  $user_name = isset($_SERVER["PHP_AUTH_USER"])? $_SERVER["PHP_AUTH_USER"]: null;
  $password   = isset($_SERVER["PHP_AUTH_PW"])? $_SERVER["PHP_AUTH_PW"]: null;

  // We are still anonymous, so let's authentify if we can
  global $user;
  if ($user->uid==0 && $user_name && $password) {
    if (webdav_is_debug()) webdav_debug("Checking user:".webdav_format_var($user_name)." password:".webdav_format_var($password, false));
    $user= webdav_user_authenticate(array('name'=>$user_name, 'pass'=>$password));
    if (user_access(WEBDAV_PERMS_WEBDAV_ACCESS, $user) == TRUE) {
      if (webdav_is_debug()) webdav_debug("Login succeed for ".$user_name);
      return true;
    }

    if (dav_is_debug) webdav_debug("Login failed for ".$user_name);
    return false;
  }

  // From this point we are authentified if we can, anonymous else
  // but webdav resource can be accessed by anonymous, so let's try
  $ok=true;
  foreach ($handler['access'] as $access) {
    if (!user_access($access)) {
      webdav_session_set_status(WEBDAV_STATUS_FORBIDDEN);
      $ok=false;
      break;
    }
  }
  if ($ok) {
    return true;
  }

  // Nothing works, so we need authentication
  $site_name=variable_get('site_name', null);
  if ($site_name) {
    $site_name=" for '".$site_name."'";
  }
  $http_auth_realm = "Drupal WebDav Access"; // for ".$site_name;
  if (dav_is_debug) webdav_debug("   Need authentication, for ".$http_auth_realm);

  // RFC2518 says we must use Digest instead of Basic
  // but Microsoft Clients do not support Digest
  // and we don't support NTLM and Kerberos
  // so we are stuck with Basic here
  header('WWW-Authenticate: Basic realm="'.$http_auth_realm.'"');
  header("HTTP/1.1 401 Unauthorized", true);
  header("X-WebDAV-Status: 401 Unauthorized", true);
  webdav_session_close(WEBDAV_STATUS_UNAUTHORIZED);
  exit();
}

/**
 * Implementation of hook_menu
 */
function webdav_menu() {

  // Webdav Query callback
  $items = array (
  WEBDAV_ROOT_MENU => array (
			'page callback' => 'webdav_handler',
			'page arguments' => array (1),
			'type' => MENU_CALLBACK,
  // We should do this in order not to let drupal handle authentication. See check_auth.
			'access arguments' => array ('access content'),
  ),

  // Webdav server settings
	'admin/settings/webdav' => array (
			'title' => 'Server', 
			'description' => 'Configure WebDAV server settings.', 
			'page callback' => 'drupal_get_form',
			'page arguments' => array ('webdav_admin_settings'),
			'access arguments' => array ('administer site configuration'),
      		'file' => 'webdav.admin.inc',
  ),

  // Main settings tab (for other modules to hook on)
  'admin/settings/webdav/main' => array(
    'title' => 'Server settings',
    'type' => MENU_DEFAULT_LOCAL_TASK,
    'weight' => -10,
  ),
  );
  return $items;
}


/**
 * hook_perm implementation.
 *
 * @return permission array.
 */
function webdav_perm() {

  return array (
  WEBDAV_PERMS_WEBDAV_ACCESS,
  );
}

/**
 * redirect to the right collection URL is ending slash is mission
 *
 * @param $item the corresponding item
 */
function webdav_redirect_wrong_collection($item) {
  if (!webdav_redirect()) return;
  // redirection if leading / is missing for a folder
  $path=webdav_session('path');
  if ($item['type']=='collection' && !webdav_is_slashied($path)) {
    if (webdav_is_debug()) {
      webdav_debug("Collection URL is mission ending slash, sending redirection...");
    }
    webdav_session_close(WEBDAV_STATUS_MOVED_PERMANENTLY);
    drupal_goto(trim($path,'/').'/', NULL, NULL, 301);
    exit;
  }
}

/**
 * Entry point for any DAV request
 */
function webdav_handler() {
  // We don't handle POST and this arrives when someone is connecting via Drupal
  if ($_SERVER['REQUEST_METHOD']=='POST') return "";

  // Default output type for WebDAV is XML
  webdav_set_output_type(WEBDAV_CONTENT_XML);;
  global $session_time_start;
  $session_time_start = microtime(true);


  // Everything from now is buffered
  ob_start();
  ob_implicit_flush(0);

  // Lets mess u with paths...
  $_SERVER['SCRIPT_NAME'] = ""; // In order to be modified by autopath system & co.
  $_SERVER['PATH_INFO'] = $_GET['q'];

  // PATH_INFO should always start with /
  if (strlen($_SERVER['PATH_INFO'])==0 || $_SERVER['PATH_INFO'][0]!='/') {
    $_SERVER['PATH_INFO'] = "/".$_SERVER['PATH_INFO'];
  }

  // we need our last slash if we had it...
  if ( webdav_is_slashied($_SERVER['REQUEST_URI']) &&
  !webdav_is_slashied($_SERVER['PATH_INFO']) )  {
    $_SERVER['PATH_INFO'].="/";
  }


  // Debugging stuff
  $depth=$_SERVER['HTTP_DEPTH']==''?'infinite':$_SERVER['HTTP_DEPTH'];
  if (webdav_is_debug()) {
    error_log('');
    error_log('******************************************************');
    error_log('* RM:'.$_SERVER['REQUEST_METHOD']." DP:".$depth." SN:".$_SERVER['SCRIPT_NAME']." PI:".$_SERVER['PATH_INFO']);
    if (webdav_is_debug(2)) {
      error_log('* RU:'.$_SERVER['REQUEST_URI']. " DQ:?q=".$_GET['q']);
    }
    error_log('* WD:'.WEBDAV_VERSION.' WS:'.$_SERVER['SERVER_SOFTWARE']." PHP:".PHP_VERSION." GW:".PHP_SAPI." OS:".PHP_OS);
    error_log('* UA:'.$_SERVER['HTTP_USER_AGENT']);
    error_log('******************************************************');
  } else {
    //  error_log('WebDAV '.WEBDAV_VERSION." : ".$_SERVER['REQUEST_METHOD']." [".$depth.", ".$_SERVER['HTTP_USER_AGENT']."] : ".$_SERVER['PATH_INFO']);
  }


  // Call server request
  $server = new DrupalDavServer();
  $server->ServeRequest();
  // If we are not in webdav pure mode (binary or drupal embeded, we should handle errors)
  if (webdav_get_output_type()!=WEBDAV_CONTENT_XML && webdav_session_failed()) {
    error_log("Error in embeded mode : ".webdav_session('status'));
    if (webdav_session('status')==WEBDAV_STATUS_NOT_FOUND) {
      drupal_not_found();
    } else {
      drupal_access_denied();
    }
    exit;
  }

  // If this is drupal embeded content we should act as a kind menu handler
  if (webdav_get_output_type()==WEBDAV_CONTENT_DRUPAL) {
    $contents = ob_get_contents();
    ob_end_clean();
    return $contents;
  }

  // We don't need this anymore
  //  session_destroy();
  header("Set-Cookie:",TRUE); // Someone ? a better way to really clean-up header ?
  header("Expires:",TRUE);
  header("Last-Modified:",TRUE);
  header("Cache-Control:",TRUE);
  header("Cache-Control:",TRUE);
  //header("ETag: $etag");

  // select the right encoding for our content
  if(  (webdav_get_output_type()==WEBDAV_CONTENT_BINARY) || !webdav_http_compression() || headers_sent() || $_SERVER['REQUEST_METHOD']=="OPTIONS" || !function_exists("gzencode")){
    $encoding = false;
  }elseif( strpos($_SERVER['HTTP_ACCEPT_ENCODING'], 'x-gzip') !== false ){
    $encoding = 'x-gzip';
  }elseif( strpos($_SERVER['HTTP_ACCEPT_ENCODING'],'gzip') !== false ){
    $encoding = 'gzip';
  }else{
    $encoding = false;
  }

  $contents = ob_get_contents();
  if (webdav_get_output_type()!=WEBDAV_CONTENT_BINARY ) {
    if (webdav_is_debug(3)) webdav_debug($contents);
  }
  $original_size=round(strlen($contents)/1024);
  ob_end_clean();
  if( $encoding ){
    header('Content-Encoding: '.$encoding);
    $contents = gzencode($contents, 9);
    if (webdav_is_debug()) {
      $final_size=round(strlen($contents)/1024);
      if ($final_size==0) {
        $ratio=0;
      } else {
        $ratio=round($original_size/$final_size);
      }
      webdav_debug("Sending compressed data from ".$original_size."ko to ".$final_size."ko (Ratio:".$ratio.")");
    }
    print($contents);
  }else{
    print $contents;
  }
  exit();
}

/**
 * Slashify - make sure path ends in a slash
 *
 * @param   string directory path
 * @returns string directory path wiht trailing slash
 */
function webdav_slashify($path) {
  if ($path[strlen($path)-1] != '/') {
    $path = $path."/";
  }
  return $path;
}

function webdav_unslashify($path) {
  if ($path[strlen($path)-1] == '/') {
    $path = substr($path,0,strlen($path)-1);
  }
  return $path;
}

function webdav_is_slashied($path) {
  return ($path[strlen($path)-1] == '/');
}

function _webdav_has_last_slash($path) {
  return ($path[strlen($path)-1] == '/');
}

function webdav_route_to_path($route) {
  for ($i=0; $i<count($route); $i++) {
    $route[$i]=webdav_url_encode($route[$i]);
  }
  return implode("/",$route);
}

/**
 * Enumerate items for a collection using hook_dav_items
 *
 * @param $handler
 * @return members
 */
function webdav_members($handler) {
  if (webdav_cache_routes() && $handler['cached'] && $data=cache_get('webdav_'.$handler['id'])) {
    return $data->data;
  }
  if (webdav_is_debug()) webdav_debug("Getting members for ".webdav_format_route($handler['route'])." collection." );
  $members = webdav_operation($handler, "members");
  if (webdav_is_debug()) webdav_debug("We found ".count($members)." members.");
  if (webdav_cache_routes() && $handler['cached']) {
    cache_set('webdav_'.$handler['id'],$members, 'cache',CACHE_TEMPORARY);
  }
  return $members;
}


/**
 * Invoke a hook on a collection owner.
 *
 * @param $handler target collection
 * @param $operation
 * @return hook result, null if nothing returned
 */
function webdav_operation() {
  $args=func_get_args();
  $handler=array_shift($args);
  $operation=array_shift($args);

  if (webdav_is_debug()) webdav_debug("Invoking callbacks for '".$operation."' on ".webdav_format_route($handler['route_pattern']));

  $single=$operation!='members';
  $functions=array();
  foreach($handler['definitions'] as $definition) {
    if (isset($definition[$operation.' callback'])) {
      if (function_exists($definition[$operation.' callback'])) {
        $functions[]=$definition[$operation.' callback'];
      }
    }
  }

  if (count($functions)==0) {
    if (webdav_is_debug(2)) {
      webdav_debug("No callback defined for '".$operation."' with ".webdav_format_route($handler['route_pattern']));
    }
    webdav_session_set_status(WEBDAV_STATUS_NOT_IMPLEMENTED);
    return;
  }

  if ($single && count($functions)>1) {
    webdav_session_set_status(WEBDAV_STATUS_INTERNAL_SERVER_ERROR);
    return;
  }

  $parameters=array();
  array_unshift($args, $handler);
  foreach ($args as $arg) {
    if (is_array($arg['route'])) { // this is a handler !!
      foreach ($arg['parameters'] as $parameter) {
        $parameters[]=$parameter;
      }
    } else {
      $parameters[]=$arg;
    }
  }

  $result=array();
  foreach ($functions as $function) {
    $function_result= call_user_func_array($function, $parameters);
    if (webdav_is_debug(2)) {
      webdav_debug("  -> ".$function."(".webdav_format_parameters($parameters).") : ".webdav_format_var($function_result, false));
    }
    if ($single) {
      return $function_result;
    }
    if (isset($function_result) && is_array($function_result)) {
      $result = array_merge_recursive($result, $function_result);
    }
  }
  return $result;
}


/**
 * Implementation of hook_cron().
 */
function webdav_cron() {
  if (webdav_is_debug()) webdav_debug("CRON: cleaning webdav expired locks");
  db_query("DELETE FROM {webdav_locks} WHERE expires < %d", time());
}

/**
 * Implementation of hook_help().
 */
function webdav_help($path, $arg = NULL) {
  switch ($path) {
    case 'admin/settings/dav':
      return '<p>' . t('') . '</p>';
  }
}

/**
 * Implementation of hook_theme()
 */
function webdav_theme() {
  return array(
    'webdav_listing' => array(
      'arguments' => array('root' => NULL, 'items' => NULL),
      'template' => 'webdav_listing',
  ),
    'webdav_page' => array(
      'arguments' => array('root' => NULL, 'items' => NULL, 'listing'=>NULL),
      'template' => 'webdav_page',
  ),
  );
}

/**
 * Check if debug logging is enabled.
 *
 * @return true if enabled.
 */
function webdav_http_compression() {
  return variable_get("webdav_compression", true);
}

/**
 * Look up an item from a collection. If no 'hook_webdav_item' can help us, we enumerate
 * items from parents and search for its name.
 *
 * @param $handler handler used to search the item
 * @return a resource
 */
function webdav_resource($handler) {
  if ($handler==false) {
    return false;
  }
  // First we try to find a hook for item look up
  if (webdav_is_debug()) webdav_debug("Searching ".webdav_format_route($handler['route'])." resource.");

  // A very special case... the root resource
  // TODO use a 'resource callback' is path handler for this.
  $route=$handler['route'];
  if (count($route)==1 && $route[0]=='root') {
    return array (
        'id' => '',
        'type' => 'collection',
    );
  }

  $item=false;
  // We get parent name
  $resource_id = array_pop($route);

  if (webdav_is_debug()) webdav_debug("Searching '".$resource_id."' in ".webdav_format_route($route)." members.");
  $parent_handler=webdav_route_resolve($route);
  if ($parent_handler===false) {
    return false;
  }
  $members = webdav_members($parent_handler);

  foreach ($members as & $_item) {
    if ($_item['id'] == $resource_id) {
      $item=$_item;
      break;
    }
  }

  if (webdav_is_debug()) {
    if ($item) {
      webdav_debug("Lookup result is a '".$item['type']."' called '".$item['id']."'");
    } else {
      $item=false;
      webdav_debug("No resource found...");
    }
  }
  return $item;
}


/**
 * Timeout for locks expriration.
 *
 * @return seconds
 */

function webdav_lock_timeout() {
  return variable_get("webdav_lock_timeout", 500);
}

/**
 * Resolve a given arguments list according to a specific collection.
 *
 * @param $source route to resolve
 * @param $path collection path
 * @return If collection is resoled, an array of wildcards=>according argument; false else.
 */
function webdav_is_route_matching($source, $handler)  {
  $route=$handler['route'];
  if (webdav_is_debug(3)) webdav_debug("  + Checking ".webdav_format_route($route).' route handler.');
  $result=array();
  $match=true;

  // Special case for "match all" ending pattern. We normalize it in order to
  // get extra data and carry on with standard matching method
  if (preg_match('/^%%([a-z_]+)$/', $route[count($route)-1], $matches)) {
    array_pop($route); // we don't nee this any more
    if (count($source)<(count($route)-1)) { // this will never happen...
      return false;
    }
    $count=count($source)-count($route);
    if ($count>0) { // we have data to store
      $tmp=array();
      for ($i=0; $i<$count; $i++) {
        array_unshift($tmp, array_pop($source));
      }
      $result[$matches[1]]=implode("/",$tmp);
    } else {
      $result[$matches[1]]="/";
    }
  }

  if (count($route)==count($source)) {
    for ($i=0; $i < count($route); $i++) {
      if (preg_match('/^%([a-z_]+)$/', $route[$i], $matches)) {
        $result[$matches[1]]=$source[$i];
      } elseif ($route[$i]!=$source[$i]) {
        $match=false;
        break;
      }
    }
    if ($match) {
      return $result;
    }
  }
  return false;
}


function webdav_dump_structure($array, $ident="") {
  foreach ($array as $key=>$value) {
    $result.=$ident;
    if (!is_numeric($key)) $result.="'".$key."' => ";
    if (is_array($value)) {
      $result.="array (\n".webdav_dump_structure($value, $ident."  ");
      $result.=$ident."),\n";
    } elseif (is_object($value)) {
      $result.="object,\n";
    } else {
      if (is_string($value)) {
        $result.="'".$value."'";
      } else {
        $result.=$value;
      }
      $result.=",\n";
    }
  }
  return $result;
}
function webdav_need_route_handlers() {
  global $webdav_need_route_handlers;

  if (empty($webdav_need_route_handlers)) {
    if(webdav_cache_routes() && $data=cache_get('webdav_routes', 'cache', CACHE_PERMANENT)) {
      $webdav_need_route_handlers=$data->data;
      return $webdav_need_route_handlers;
    }
    if (webdav_is_debug()) webdav_debug("  Route handlers cache is empty : let's find all the mutants");
    $by_path=array();
    foreach (module_implements('webdav_definitions') as $module) {
      $tmp=module_invoke($module,'webdav_definitions');
      foreach ($tmp as $path=>$definition) {
        $path=trim($path,"/");
        $by_path[$path]['definitions'][]=$definition;

        // we move owner data to root definition
        // FIXME we can have conflict here...
        foreach (array('module', 'access', 'arguments', 'cached') as $field) {
          if (!isset($by_path[$path][$field])) {
            if ($field=='module' && !isset($definition[$field])) {
              $definition[$field]=$module;
            }
            if (!is_null($definition[$field])) {
              $by_path[$path][$field]=$definition[$field];
              unset($definition[$field]);
            }
          }
        }
        if (!isset($by_path[$path]['route'])) {
          $by_path[$path]['route']=webdav_parse_path($path);
        }
      }
    }
    uasort($by_path, _webdav_collection_sorter); //
    $webdav_need_route_handlers=array_values($by_path);
    if (webdav_is_debug(2)) {
      foreach ($webdav_need_route_handlers as $handler) {
        webdav_debug("  + ".webdav_format_route($handler['route']));
        if (webdav_is_debug(3)) {
          foreach($handler["definitions"] as $definition) {
            foreach ($definition as $key=>$value) {
              webdav_debug("     - ".$key." = > ".webdav_format_var($value));
            }
          }
        }
      }
    }
    if (webdav_is_debug(2)) webdav_debug("  End of route handlers cache building");
  }
  if (webdav_cache_routes()) {
    cache_set('webdav_routes',$webdav_need_route_handlers,'cache',CACHE_PERMANENT);
  }
  return $webdav_need_route_handlers;
}

function _webdav_collection_sorter($a, $b) {
  return count($a['route'])-count($b['route']);
}

/**
 * Try to resolve collection arguments with known collections as given by hook_webdav_collections.
 *
 * @param $route route to resolve
 * @return if a route is found, an array containing route handler, else false.
 */
function webdav_route_resolve($route, $level=0) {
  for ($i=0; $i < $level; $i++) {
    array_pop($route);
  }
  $handler_id=implode("_",$route);
  global $webdav_resolved_routes;
  if (isset($webdav_resolved_routes[$handler_id])) {
    $result=$webdav_resolved_routes[$handler_id];
    if (webdav_is_debug()) webdav_debug("Route resolved using cache : ".webdav_format_var($result));
    return $result;
  }

  if (webdav_is_debug()) webdav_debug("Resolving ".webdav_format_route($route)."...");

  $matches=array();
  foreach (webdav_need_route_handlers() as $handler) {
    $parameters = webdav_is_route_matching($route, $handler);
    if ($parameters !== false) {
      $match=$handler;
      $match['parameters']=$parameters;
      $match['route']=$route;
      $match['route_pattern']=$handler['route'];
      $matches[]=$match;
    }
  }

  usort($matches, webdav_best_matches);

  // search for the better match
  if (webdav_is_debug(2)) {
    webdav_debug("Resolved routes are (first is best) :");
    foreach ($matches as $match) {
      webdav_debug("  * ".webdav_format_route($match['route_pattern'])." : ".count($match['parameters']));
    }
  }

  if (count($matches)>0) {
    $result=$matches[0];
    $parameters=array();
    if (count($result['arguments'])>0) {
      foreach ($result['arguments'] as $index) {
        $index++; // we skip root
        $item=$result['route_pattern'][$index];
        $value=$result['route'][$index];
        if ($item[0]=='%') {
          $item=trim($item, '%');
          $value=$result['parameters'][$item];
          $loader=$result['module'].'_'.$item."_load";
          if (function_exists($loader)) {
            if (webdav_is_debug(2)) webdav_debug("  -> invoking ".$loader.'('.webdav_format_parameters(array($value)).")");
            $loader_result = $loader($value);
            if ($loader_result===false) {
              if (webdav_is_debug()) webdav_debug("Error while loading '".$value."' with ".$loader);
              return false;
            } else {
              $value=$loader_result;
            }
          }
        }
        $parameters[]=$value;
      }
    }
    $result['parameters']=$parameters;
    if (webdav_is_debug()) {
      webdav_debug("Found a ".webdav_format_route($handler['route'])." handler owned by '".$result['module']."'");
      if (webdav_is_debug(2)) {
        foreach ($result['parameters'] as $key=>$value) {
          webdav_debug("  * arguments['".$key."'] => ".webdav_format_var($value));
        }
      }
    }
    $result['id']=$handler_id;
    $webdav_resolved_routes[$handler_id]=$result;
    return $result;
  }

  if (webdav_is_debug()) {
    webdav_debug("We didn't found any handler.");
  }
  $webdav_resolved_routes[$handler_id]=false;
  return false;
}

function webdav_best_matches($a, $b) {
  return count($a['parameters'])-count($b['parameters']);
}

/**
 * output a debug message (syslog).
 *
 * @param $message message
 */
function webdav_debug($message) {
  $lines=explode("\n", $message);
  foreach ($lines as $line) {
    error_log($line);
  }
}


/**
 * Show closing session query, ainly used to log access in watchdog .
 */
function webdav_debug_close_query(&$session){
  global $session_time_start;
  $time = round(1000*(microtime(true) - $session_time_start));
  if (webdav_is_debug() ) {
    webdav_debug("Closing session with ".(webdav_session_failed()?"error":"status")." : ".(empty($session->status)?"OK":$session->status));
    webdav_debug('Request served in ' .$time." ms");
  } else {
    error_log($_SERVER['REQUEST_METHOD']." [".($_SERVER['HTTP_DEPTH']==''?'infinite':$_SERVER['HTTP_DEPTH'])."] ".$_SERVER['PATH_INFO']." : ".(empty($session->status)?"OK":$session->status)." (".$time." ms)");
  }
  if (webdav_watch_dog()) {
    if ($_SERVER['REQUEST_METHOD']!="PROPFIND" && $_SERVER['REQUEST_METHOD']!="OPTIONS") {
      watchdog('webdav', "WebDAV access to @query method<br/>status:@status", array(
    '@query' => $_SERVER['REQUEST_METHOD'],
     '@status' => $session->status,
      )
      ,webdav_session_failed()?WATCHDOG_ERROR:WATCHDOG_NOTICE);
    }
  }
}

/**
 * Check if watchdog logging is enabled.
 *
 * @return true if enabled.
 */
function webdav_watch_dog() {
  return variable_get("webdav_watch_dog", false);
}

/**
 * Check if watchdog logging is enabled.
 *
 * @return true if enabled.
 */
function webdav_debug_level() {
  return variable_get("webdav_debug_level", 1);
}
function webdav_format_route($array) {
  $result="";
  $iCount=0;
  foreach ($array as $item) {
    if ($result!="") {
      $result.=", ";
    }
    $result.=$item;
    $iCount++;
  }
  return "{ ".$result." }";
}

function webdav_format_var($var,$expand=true) {
  if (is_object($var)) {
    return 'OBJECT';
  } elseif (is_string($var)) {
    return  !$expand?"STRING[".strlen($var)."]":"'".$var."'";
  } elseif (is_bool($var)) {
    return $var?"TRUE":"FALSE";
  }elseif (is_array($var)) {
    return "ARRAY[".count($var)."]";
  }
  return $var;
}

function webdav_format_parameters($array) {
  $result="";
  $iCount=0;
  foreach ($array as $item) {
    if ($result!="") {
      $result.=", ";
    }
    $result.=webdav_format_var($item);
    $iCount++;
  }
  return $result;
}
/**
 * Check if debug logging is enabled.
 *
 * @return true if enabled.
 */
function webdav_is_debug($level=1) {
  return (webdav_debug_level()>=$level);
}


function webdav_set_output_type($type) {
  global $webdav_drupal_content;
  $webdav_drupal_content=$type;
  if (webdav_is_debug(2)) webdav_debug("Selecting a new output type : ".$type);
}

function webdav_get_output_type() {
  global $webdav_drupal_content;
  return $webdav_drupal_content;
}

/**
 * Originaly a file.inc Drupal function modified.
 *
 * @param unknown_type $filename
 * @param unknown_type $mapping
 */
function webdav_file_get_mimetype($filename, $mapping = NULL) {
  if (!is_array($mapping)) {
    $mapping = variable_get('mime_extension_mapping', array(
    'ez' => 'application/andrew-inset',
    'atom' => 'application/atom',
    'atomcat' => 'application/atomcat+xml',
    'atomsrv' => 'application/atomserv+xml',
    'cap|pcap' => 'application/cap',
    'cu' => 'application/cu-seeme',
    'tsp' => 'application/dsptype',
    'spl' => 'application/x-futuresplash',
    'hta' => 'application/hta',
    'jar' => 'application/java-archive',
    'ser' => 'application/java-serialized-object',
    'class' => 'application/java-vm',
    'hqx' => 'application/mac-binhex40',
    'cpt' => 'image/x-corelphotopaint',
    'nb' => 'application/mathematica',
    'mdb' => 'application/msaccess',
    'doc|dot' => 'application/msword',
    'bin' => 'application/octet-stream',
    'oda' => 'application/oda',
    'ogg|ogx' => 'application/ogg',
    'pdf' => 'application/pdf',
    'key' => 'application/pgp-keys',
    'pgp' => 'application/pgp-signature',
    'prf' => 'application/pics-rules',
    'ps|ai|eps' => 'application/postscript',
    'rar' => 'application/rar',
    'rdf' => 'application/rdf+xml',
    'rss' => 'application/rss+xml',
    'rtf' => 'application/rtf',
    'smi|smil' => 'application/smil',
    'wpd' => 'application/wordperfect',
    'wp5' => 'application/wordperfect5.1',
    'xhtml|xht' => 'application/xhtml+xml',
    'xml|xsl' => 'application/xml',
    'zip' => 'application/zip',
    'cdy' => 'application/vnd.cinderella',
    'kml' => 'application/vnd.google-earth.kml+xml',
    'kmz' => 'application/vnd.google-earth.kmz',
    'xul' => 'application/vnd.mozilla.xul+xml',
    'xls|xlb|xlt' => 'application/vnd.ms-excel',
    'cat' => 'application/vnd.ms-pki.seccat',
    'stl' => 'application/vnd.ms-pki.stl',
    'ppt|pps' => 'application/vnd.ms-powerpoint',
    'odc' => 'application/vnd.oasis.opendocument.chart',
    'odb' => 'application/vnd.oasis.opendocument.database',
    'odf' => 'application/vnd.oasis.opendocument.formula',
    'odg' => 'application/vnd.oasis.opendocument.graphics',
    'otg' => 'application/vnd.oasis.opendocument.graphics-template',
    'odi' => 'application/vnd.oasis.opendocument.image',
    'odp' => 'application/vnd.oasis.opendocument.presentation',
    'otp' => 'application/vnd.oasis.opendocument.presentation-template',
    'ods' => 'application/vnd.oasis.opendocument.spreadsheet',
    'ots' => 'application/vnd.oasis.opendocument.spreadsheet-template',
    'odt' => 'application/vnd.oasis.opendocument.text',
    'odm' => 'application/vnd.oasis.opendocument.text-master',
    'ott' => 'application/vnd.oasis.opendocument.text-template',
    'oth' => 'application/vnd.oasis.opendocument.text-web',
    'docm' => 'application/vnd.ms-word.document.macroEnabled.12',
    'docx' => 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
    'dotm' => 'application/vnd.ms-word.template.macroEnabled.12',
    'dotx' => 'application/vnd.openxmlformats-officedocument.wordprocessingml.template',
    'potm' => 'application/vnd.ms-powerpoint.template.macroEnabled.12',
    'potx' => 'application/vnd.openxmlformats-officedocument.presentationml.template',
    'ppam' => 'application/vnd.ms-powerpoint.addin.macroEnabled.12',
    'ppsm' => 'application/vnd.ms-powerpoint.slideshow.macroEnabled.12',
    'ppsx' => 'application/vnd.openxmlformats-officedocument.presentationml.slideshow',
    'pptm' => 'application/vnd.ms-powerpoint.presentation.macroEnabled.12',
    'pptx' => 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
    'xlam' => 'application/vnd.ms-excel.addin.macroEnabled.12',
    'xlsb' => 'application/vnd.ms-excel.sheet.binary.macroEnabled.12',
    'xlsm' => 'application/vnd.ms-excel.sheet.macroEnabled.12',
    'xlsx' => 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
    'xltm' => 'application/vnd.ms-excel.template.macroEnabled.12',
    'xltx' => 'application/vnd.openxmlformats-officedocument.spreadsheetml.template',
    'cod' => 'application/vnd.rim.cod',
    'mmf' => 'application/vnd.smaf',
    'sdc' => 'application/vnd.stardivision.calc',
    'sds' => 'application/vnd.stardivision.chart',
    'sda' => 'application/vnd.stardivision.draw',
    'sdd' => 'application/vnd.stardivision.impress',
    'sdf' => 'application/vnd.stardivision.math',
    'sdw' => 'application/vnd.stardivision.writer',
    'sgl' => 'application/vnd.stardivision.writer-global',
    'sxc' => 'application/vnd.sun.xml.calc',
    'stc' => 'application/vnd.sun.xml.calc.template',
    'sxd' => 'application/vnd.sun.xml.draw',
    'std' => 'application/vnd.sun.xml.draw.template',
    'sxi' => 'application/vnd.sun.xml.impress',
    'sti' => 'application/vnd.sun.xml.impress.template',
    'sxm' => 'application/vnd.sun.xml.math',
    'sxw' => 'application/vnd.sun.xml.writer',
    'sxg' => 'application/vnd.sun.xml.writer.global',
    'stw' => 'application/vnd.sun.xml.writer.template',
    'sis' => 'application/vnd.symbian.install',
    'vsd' => 'application/vnd.visio',
    'wbxml' => 'application/vnd.wap.wbxml',
    'wmlc' => 'application/vnd.wap.wmlc',
    'wmlsc' => 'application/vnd.wap.wmlscriptc',
    'wk' => 'application/x-123',
    '7z' => 'application/x-7z-compressed',
    'abw' => 'application/x-abiword',
    'dmg' => 'application/x-apple-diskimage',
    'bcpio' => 'application/x-bcpio',
    'torrent' => 'application/x-bittorrent',
    'cab' => 'application/x-cab',
    'cbr' => 'application/x-cbr',
    'cbz' => 'application/x-cbz',
    'cdf' => 'application/x-cdf',
    'vcd' => 'application/x-cdlink',
    'pgn' => 'application/x-chess-pgn',
    'cpio' => 'application/x-cpio',
    'csh' => 'text/x-csh',
    'deb|udeb' => 'application/x-debian-package',
    'dcr|dir|dxr' => 'application/x-director',
    'dms' => 'application/x-dms',
    'wad' => 'application/x-doom',
    'dvi' => 'application/x-dvi',
    'rhtml' => 'application/x-httpd-eruby',
    'flac' => 'application/x-flac',
    'pfa|pfb|gsf|pcf|pcf.Z' => 'application/x-font',
    'mm' => 'application/x-freemind',
    'gnumeric' => 'application/x-gnumeric',
    'sgf' => 'application/x-go-sgf',
    'gcf' => 'application/x-graphing-calculator',
    'gtar|tgz|taz' => 'application/x-compressed-tar', // YB
    'bz2'=>'application/x-bzip',
    'hdf' => 'application/x-hdf',
    'phtml|pht|php' => 'application/x-httpd-php',
    'phps' => 'application/x-httpd-php-source',
    'php3' => 'application/x-httpd-php3',
    'php3p' => 'application/x-httpd-php3-preprocessed',
    'php4' => 'application/x-httpd-php4',
    'ica' => 'application/x-ica',
    'ins|isp' => 'application/x-internet-signup',
    'iii' => 'application/x-iphone',
    'iso' => 'application/x-iso9660-image',
    'jnlp' => 'application/x-java-jnlp-file',
    'js' => 'application/x-javascript',
    'jmz' => 'application/x-jmol',
    'chrt' => 'application/x-kchart',
    'kil' => 'application/x-killustrator',
    'skp|skd|skt|skm' => 'application/x-koan',
    'kpr|kpt' => 'application/x-kpresenter',
    'ksp' => 'application/x-kspread',
    'kwd|kwt' => 'application/x-kword',
    'latex' => 'application/x-latex',
    'lha' => 'application/x-lha',
    'lyx' => 'application/x-lyx',
    'lzh' => 'application/x-lzh',
    'lzx' => 'application/x-lzx',
    'frm|maker|frame|fm|fb|book|fbdoc' => 'application/x-maker',
    'mif' => 'application/x-mif',
    'wmd' => 'application/x-ms-wmd',
    'wmz' => 'application/x-ms-wmz',
    'com|exe|bat|dll' => 'application/x-msdos-program',
    'msi' => 'application/x-msi',
    'nc' => 'application/x-netcdf',
    'pac' => 'application/x-ns-proxy-autoconfig',
    'nwc' => 'application/x-nwc',
    'o' => 'application/x-object',
    'oza' => 'application/x-oz-application',
    'p7r' => 'application/x-pkcs7-certreqresp',
    'crl' => 'application/x-pkcs7-crl',
    'pyc|pyo' => 'application/x-python-code',
    'qtl' => 'application/x-quicktimeplayer',
    'rpm' => 'application/x-redhat-package-manager',
    'sh' => 'text/x-sh',
    'shar' => 'application/x-shar',
    'swf|swfl' => 'application/x-shockwave-flash',
    'sit|sitx' => 'application/x-stuffit',
    'sv4cpio' => 'application/x-sv4cpio',
    'sv4crc' => 'application/x-sv4crc',
    'tar' => 'application/x-tar',
    'tcl' => 'application/x-tcl',
    'gf' => 'application/x-tex-gf',
    'pk' => 'application/x-tex-pk',
    'texinfo|texi' => 'application/x-texinfo',
    '~|%|bak|old|sik' => 'application/x-trash',
    't|tr|roff' => 'application/x-troff',
    'man' => 'application/x-troff-man',
    'me' => 'application/x-troff-me',
    'ms' => 'application/x-troff-ms',
    'ustar' => 'application/x-ustar',
    'src' => 'application/x-wais-source',
    'wz' => 'application/x-wingz',
    'crt' => 'application/x-x509-ca-cert',
    'xcf' => 'application/x-xcf',
    'fig' => 'application/x-xfig',
    'xpi' => 'application/x-xpinstall',
    'au|snd' => 'audio/basic',
    'mid|midi|kar' => 'audio/midi',
    'mpga|mpega|mp2|mp3|m4a' => 'audio/mpeg',