modules/fileserver/fileserver.module

<?php
// $Id: fileserver.module,v 1.3 2008/09/03 19:26:14 incanus Exp $

/**
 * @file
 * Provides WebDAV access to taxonomies and files.
 */

//////////////////////////////////////////////////////////////////////////////
// MODULE SETTINGS

define('FILESERVER_ADMIN_PATH', 'admin/settings/dav/fileserver');

define('FILESERVER_OG_VOCAB',   variable_get('fileserver_og_vocab', FALSE));

define('FILESERVER_VOCABULARY', 'taxonomy_vocabulary');
define('FILESERVER_CATEGORY',   'taxonomy_term');
define('FILESERVER_FILE',       'node_file');

define('FILESERVER_NODE_TYPE',  'file');

define('FILESERVER_SIG',        ' (WebDAV)');

//////////////////////////////////////////////////////////////////////////////
// CORE API HOOKS

/**
 * Implementation of hook_help().
 */
function fileserver_help($path, $arg) {
  switch ($path) {
    case 'admin/help#fileserver':
      return '<p>' . t('File taxonomy server provides WebDAV access to a site\'s taxonomies and files. You can add, remove, move, copy, and edit vocabularies, taxonomy terms, and their associated files using an ordinary WebDAV client.') . '</p>';
  }
}

/**
 * Implementation of hook_menu().
 */
function fileserver_menu() {
  return array(
    FILESERVER_ADMIN_PATH => array(
      'title' => 'File taxonomy server',
      'description' => 'Configure File taxonomy server settings.',
      'access arguments' => array('administer site configuration'),
      'page callback' => 'drupal_get_form',
      'page arguments' => array('fileserver_admin_settings_form'),
    )
  );
}

/**
 * Admin settings form, called by hook_menu().
 */
function fileserver_admin_settings_form() {
  $form = array();

  // Vocabulary settings
  $form['vocabs'] = array('#type' => 'fieldset', '#title' => t('Vocabulary settings'), '#collapsible' => TRUE, '#collapsed' => TRUE);
  $options = array_map(create_function('$vocab', 'return $vocab->name;'), taxonomy_get_vocabularies());
  $form['vocabs']['fileserver_vocabularies'] = array(
    '#type'          => 'select',
    '#title'         => t('Exported vocabularies'),
    '#default_value' => array_filter(variable_get('fileserver_vocabularies', array()), 'is_string'),
    '#options'       => $options,
    '#multiple'      => TRUE,
    '#description'   => t('Select which vocabularies will be made accessible via DAV as top-level collections (or "root folders"). Access to any other vocabularies will be prohibited.'),
  );

  // Organic groups integration
  if (module_exists('og_vocab')) {
    $form['og'] = array('#type' => 'fieldset', '#title' => t('Organic groups integration'), '#collapsible' => TRUE, '#collapsed' => TRUE);
    $form['og']['fileserver_og_vocab'] = array(
      '#type'          => 'radios',
      '#title'         => t('Only show vocabularies associated with the user\'s groups'),
      '#default_value' => FILESERVER_OG_VOCAB,
      '#options'       => array(FALSE => t('Disabled'), TRUE => t('Enabled')),
      '#description'   => t('Whether to enable access to the group vocabularies of those organic groups the user is subscribed to. Note that the exported vocabularies setting, above, has higher priority than this, meaning that the user is always granted access to any explicitly exported vocabularies.</em>'),
    );
  }

  return system_settings_form($form);
}

//////////////////////////////////////////////////////////////////////////////
// DAV API HOOKS (NAMESPACE/METADATA)

/**
 * Implementation of hook_dav_lookup().
 */
function fileserver_dav_lookup($collection, $name) {
  list($type, $key) = $collection;

  switch ($type) {
    case DAV_ROOT_COLLECTION:
      if ($vocabulary = _fileserver_lookup_vocabulary($name))
        return array(FILESERVER_VOCABULARY, $vocabulary->vid);
      break;

    case FILESERVER_VOCABULARY:
      if ($term = _fileserver_lookup_term($name, $key))
        return array(FILESERVER_CATEGORY, $term->tid);
      break;

    case FILESERVER_CATEGORY:
      //if ($term = _fileserver_lookup_term($name, $parent->vid, $parent->tid))
      if ($term = _fileserver_lookup_term($name, NULL, $key))
        return array(FILESERVER_CATEGORY, $term->tid);
      if ($node = _fileserver_lookup_file($name, $key))
        return array(FILESERVER_FILE, $node->nid);
      break;

    case FILESERVER_FILE:
      break;
  }
}

/**
 * Implementation of hook_dav_list().
 */
function fileserver_dav_list($collection) {
  list($type, $key) = $collection;
  $resources = array();

  switch ($type) {
    case DAV_ROOT_COLLECTION:
      // top level: list vocabularies
      foreach (taxonomy_get_vocabularies(FILESERVER_NODE_TYPE) as $vocabulary) {
        if (_fileserver_include_vocabulary($vocabulary->vid)) {
          $resources[$vocabulary->name] = array(FILESERVER_VOCABULARY, $vocabulary->vid);
        }
      }
      break;

    case FILESERVER_VOCABULARY:
      // one level deep: list categories under this vocabulary
      if (_fileserver_include_vocabulary($key)) {
        foreach (taxonomy_get_children(NULL, $key) as $term) {
          $resources[$term->name] = array(FILESERVER_CATEGORY, $term->tid);
        }
      }
      break;

    case FILESERVER_CATEGORY:
      // two or more levels deep: list categories and files under this category
      foreach (taxonomy_get_children($key) as $term) {
        $resources[$term->name] = array(FILESERVER_CATEGORY, $term->tid);
      }
      $result = taxonomy_select_nodes(array((int)$key), 'or', 0, FALSE);
      while ($node = db_fetch_object($result)) {
        $node = node_load($node->nid);
        if ($node->type == FILESERVER_NODE_TYPE && _fileserver_node_access('view', $node) /*&& !empty($node->file)*/) { // FIXME
          $resources[$node->title] = array(FILESERVER_FILE, $node->nid);
        }
      }
      break;

    case FILESERVER_FILE:
      break;
  }

  return $resources;
}

/**
 * Implementation of hook_dav_propfind().
 */
function fileserver_dav_propfind($resource) {
  list($type, $key) = $resource;
  $props = array();

  switch ($type) {
    // As DAV collections, we support taxonomy.module vocabularies and terms.
    case FILESERVER_VOCABULARY:
    case FILESERVER_CATEGORY:
      // Note that vocabulary terms don't store any creation/modification
      // date information in the database, so we have to use the current
      // time by default.  One way to fix this would be to add additional
      // columns to the core Drupal tables, and watch on hook_taxonomy() in
      // order to update their values. Nasty, but useful; this could be
      // provided as a separate add-on since we check whether the term has
      // 'created' and 'changed' attributes.
      $term = ($type == FILESERVER_VOCABULARY) ? taxonomy_vocabulary_load($key) : taxonomy_get_term($key);
      $props['displayname']      = $term->name;
      $props['creationdate']     = !empty($term->created) ? $term->created : time();
      $props['getlastmodified']  = !empty($term->changed) ? $term->changed : time();
      $props['resourcetype']     = 'collection';
      $props['getcontenttype']   = 'httpd/unix-directory';
      break;

    // As DAV files, we support file.module nodes.
    case FILESERVER_FILE:
      if (($node = node_load($key)) && ($file = $node->file) && _fileserver_node_access('view', $node)) {
        $props['displayname']      = $node->title; // TODO: give suffix automatically?
        $props['creationdate']     = $node->created;
        $props['getlastmodified']  = $node->changed;
        $props['resourcetype']     = '';
        $props['getcontenttype']   = $file->type;
        $props['getcontentlength'] = (int)$file->size;
      }
      break;
  }

  return $props;
}

//////////////////////////////////////////////////////////////////////////////
// DAV API HOOKS (VERBS)

/**
 * Implementation of hook_dav_get().
 */
function fileserver_dav_get($resource, &$options) {
  list($type, $key) = $resource;

  switch ($type) {
    case FILESERVER_FILE:
      $node = node_load($key);
      $file = $node->file;
      $hash = file_get_hash($file);
      if (_fileserver_node_access('view', $node) && file_bitcache_access($hash, $node->vid)) {
        return array(
          'mtime'    => $node->changed,
          'mimetype' => $file->type,
          'size'     => (int)$file->size,
          'stream'   => bitcache_get_stream($hash),
        );
      }
      return FALSE;
  }
}

/**
 * Implementation of hook_dav_put().
 */
function fileserver_dav_put($container, $name, &$options, $filepath = NULL) {
  list($type, $key) = $container;

  switch ($type) {
    case DAV_ROOT_COLLECTION:
      return FALSE; // TODO: maybe we could provide some smarts here?

    case FILESERVER_VOCABULARY:
      return FALSE; // decline file upload to the vocabulary root

    case FILESERVER_CATEGORY:
      if (empty($filepath)) { // pre-process upload FIXME what does this mean?
        return TRUE; // accept file upload
      }
      else { // post-process upload
        $handler = $options['new'] ? '_fileserver_create_file' : '_fileserver_update_file';
        return $handler($key, $name, $options, $filepath);
      }
  }
}

/**
 * Implementation of hook_dav_mkcol().
 */
function fileserver_dav_mkcol($container, $name) {
  list($type, $key) = $container;

  switch ($type) {
    case DAV_ROOT_COLLECTION:
      if (!user_access('administer taxonomy'))
        return STATUS_403; // Forbidden

      if ($vocabulary = _fileserver_create_vocabulary($name)) {
        // Immediately add the new vocabulary to the exported list, or else
        // the user would never see it until an administrator were to
        // manually adjust the module's settings:
        _fileserver_export_vocabulary($vocabulary->vid);
        return array(FILESERVER_VOCABULARY, $vocabulary->vid);
      }
      return FALSE;

    case FILESERVER_VOCABULARY:
    case FILESERVER_CATEGORY:
      if (!user_access('administer taxonomy'))
        return STATUS_403; // Forbidden

      $parent = ($type == FILESERVER_VOCABULARY) ? taxonomy_vocabulary_load($key) : taxonomy_get_term($key);
      if ($term = _fileserver_create_term($name, $parent->vid, @$parent->tid))
        return array(FILESERVER_CATEGORY, $term->tid);
      return FALSE;
  }
}

/**
 * Implementation of hook_dav_delete().
 */
function fileserver_dav_delete($resource, $container, $move = FALSE) {
  list($type, $key) = $resource;

  switch ($type) {
    case FILESERVER_VOCABULARY:
      // NB: We need to be careful about the deletion of vocabularies...
      if (!user_access('administer taxonomy'))
        return STATUS_403; // Forbidden

      return taxonomy_del_vocabulary($key);

    case FILESERVER_CATEGORY:
      if (!user_access('administer taxonomy'))
        return STATUS_403; // Forbidden

      return taxonomy_del_term($key);

    case FILESERVER_FILE:
      $node = node_load($key);
      if (!_fileserver_node_access('update', $node) && !$move)
        return STATUS_403; // Forbidden

      list($parent_type, $parent_key) = $container;
      switch ($parent_type) {
        case FILESERVER_CATEGORY:
          $node = node_load($key);
          if (!$move) {
            // revision the about-to-be untagged node
            _fileserver_revision_node($node, 'delete', array(taxonomy_get_term($parent_key)->name));
          }
          else {
            // reload the (uncached) node (already revisioned in fileserver_dav_move())
            $node = node_load($key, NULL, TRUE);
          }
          // only modify the latest revision
          db_query('DELETE FROM {term_node} WHERE tid = %d AND nid = %d AND vid = %d', $parent_key, $key, $node->vid);
          // TODO: really delete when reference count reaches zero?
          // This would require _fileserver_node_access('delete', $node)
          //node_delete($key);
          return TRUE;
      }
      return NULL;
    }
}

/**
 * Implementation of hook_dav_rename().
 */
function fileserver_dav_rename($resource, $source_name, $target_name) {
  list($type, $key) = $resource;

  switch ($type) {
    case FILESERVER_VOCABULARY:
      if (user_access('administer taxonomy')) {
        $edit = (array)taxonomy_vocabulary_load($key);
        $edit['name'] = $target_name;
        db_query("UPDATE {vocabulary} SET name = '%s' WHERE vid = %d", $edit['name'], $edit['vid']);
        //module_invoke_all('taxonomy', 'update', 'vocabulary', $edit);
        return TRUE;
      }

    case FILESERVER_CATEGORY:
      if (user_access('administer taxonomy')) {
        $edit = (array)taxonomy_get_term($key);
        $edit['name'] = $target_name;
        db_query("UPDATE {term_data} SET name = '%s' WHERE tid = %d", $edit['name'], $edit['tid']);
        //module_invoke_all('taxonomy', 'update', 'term', $edit);
        return TRUE;
      }

    case FILESERVER_FILE:
      $node = node_load($key);
      if (_fileserver_node_access('update', $node) && 
          _fileserver_revision_node($node, 'rename', array($node->title, $target_name))) {
        db_query("UPDATE {node} SET title = '%s' WHERE nid = %d", $target_name, $node->nid);
        db_query("UPDATE {node_revisions} SET title = '%s' WHERE vid = %d", $target_name, $node->vid);
        //node_invoke($node, 'update');
        //node_invoke_nodeapi($node, 'update');
        return TRUE;
      }
  }
  
  return FALSE; // catch-all
}

/**
 * Implementation of hook_dav_move().
 */
function fileserver_dav_move($resource, $source_path, $target_path) {
  list($type, $key) = $resource;

  switch ($type) {
    case FILESERVER_VOCABULARY:
      // Vocabularies can't be moved (only created, renamed and deleted)
      return FALSE;

    case FILESERVER_CATEGORY:
      if (user_access('administer taxonomy')) {
        $edit = (array)taxonomy_get_term($key);
        $edit['name'] = $name = array_pop($target_path);
        list($type, $parent) = _dav_resolve($target_path);
        switch ($type) {
          // Convert/promote a category into a vocabulary, reparenting all its
          // sub-categories to the newly-created vocabulary
          case DAV_ROOT_COLLECTION:
            if ($vocabulary = _fileserver_create_vocabulary($name)) {
              _fileserver_reparent_tree($edit['vid'], $edit['tid'], $vocabulary->vid, 0);
              taxonomy_del_term($edit['tid']);
              _fileserver_export_vocabulary($vocabulary->vid);
              return TRUE; //array(FILESERVER_VOCABULARY, $vocabulary->vid);
            }
            return FALSE;
        
          // Move a category to another vocabulary
          case FILESERVER_VOCABULARY:
            _fileserver_reparent_tree($edit['vid'], $edit['tid'], $parent, $edit['tid']);
            $edit['vid'] = $parent;
            db_query("UPDATE {term_data} SET name = '%s', vid = %d WHERE tid = %d", $edit['name'], $edit['vid'], $edit['tid']);
            _fileserver_reparent_category($edit['tid'], 0);
            module_invoke_all('taxonomy', 'update', 'term', $edit);
            return TRUE;
        
          // Move a category to another parent category within the same vocabulary
          case FILESERVER_CATEGORY:
            // TODO: Check that the vocabulary IDs actually match?
            // Prevent moving a term inside one of its own subterms, which
            // would unlink that entire branch due to a circular reference
            $tids = array_map('array_shift', array_map('get_object_vars', taxonomy_get_parents_all($parent)));
            if (in_array($edit['tid'], $tids))
              return FALSE; // Conflict
            $edit['parent'] = $parent;
            taxonomy_save_term($edit);
            return TRUE;
        }
        return NULL; // we don't know how to handle the given parent type
      }

    case FILESERVER_FILE:
      $source_name = array_pop($source_path);
      list($source_type, $source) = _dav_resolve($source_path);
      $target_name = array_pop($target_path);
      list($target_type, $target) = _dav_resolve($target_path);

      switch ($target_type) {
        case DAV_ROOT_COLLECTION:
        case FILESERVER_VOCABULARY:
          return FALSE; // No can do, sorry.

        case FILESERVER_CATEGORY:
          // NB: we need to insert the new relation before deleting the
          // existing association to prevent possible node deletion if its
          // reference count reaches zero. The good ol' retain/release
          // dance, Web 2.0 version.
          $node = node_load($key);
          if (_fileserver_node_access('update', $node) && 
              _fileserver_revision_node($node, 'move', array(taxonomy_get_term($source)->name, taxonomy_get_term($target)->name))) {
            // associate with the latest node revision
            db_query('INSERT INTO {term_node} (nid, vid, tid) VALUES (%d, %d, %d)', $key, $node->vid, $target);
            return fileserver_dav_delete($resource, array($source_type, $source), TRUE);
          }
          else {
            return FALSE;
          }
      }
      return NULL; // we don't know how to handle the given parent type
  }
  
  return FALSE; // catch-all
}

/**
 * Implementation of hook_dav_copy().
 */
function fileserver_dav_copy($resource, $source_path, $target_path) {
  list($type, $key) = $resource;

  switch ($type) {
    case FILESERVER_VOCABULARY:
      // Vocabularies can't be copied (only created, renamed and deleted)
      return FALSE;

    case FILESERVER_CATEGORY:
      // FIXME: We'll prevent the copying of categories until the exact semantics are sorted out
      return FALSE;

      $edit = (array)taxonomy_get_term($key);
      unset($edit['tid']);
      $edit['name'] = $name = array_pop($target_path);
      list($type, $parent) = _dav_resolve($target_path);
      switch ($type) {

        case DAV_ROOT_COLLECTION:
          // TODO: convert/promote the taxonomy term into a vocabulary
          return FALSE;

        case FILESERVER_VOCABULARY:
          // Reparent a taxonomy term to a vocabulary
          $edit['vid'] = $parent;
          $edit['parent'] = 0;
          if (taxonomy_save_term($edit) == SAVED_NEW)
            return array(FILESERVER_CATEGORY, (int)$edit['tid']);
          return FALSE;

        case FILESERVER_CATEGORY:
          // Reparent a taxonomy term to another term
          $edit['parent'] = $parent;
          taxonomy_save_term($edit);
          return TRUE;
      }
      return NULL; // we don't know how to handle the given parent type

    case FILESERVER_FILE:
      $source_name = array_pop($source_path);
      list($source_type, $source) = _dav_resolve($source_path);
      $target_name = array_pop($target_path);
      list($target_type, $target) = _dav_resolve($target_path);

      switch ($target_type) {
        case DAV_ROOT_COLLECTION:
        case FILESERVER_VOCABULARY:
          return FALSE; // No can do

        case FILESERVER_CATEGORY:
          // Create a "shallow copy" by simply associating the node with the target category
          $node = node_load($key);
          if (_fileserver_node_access('update', $node) && 
              _fileserver_revision_node($node, 'copy', array(taxonomy_get_term($target)->name))) {
            // associate with the current node revision
            db_query('INSERT INTO {term_node} (nid, vid, tid) VALUES (%d, %d, %d)', $key, $node->vid, $target);
            return TRUE;
          }
          else {
            return FALSE;
          }
      }
      return NULL; // we don't know how to handle the given parent type
  }
}

//////////////////////////////////////////////////////////////////////////////
// HELPERS

function _fileserver_create_vocabulary($name) {
  $edit = array('name' => $name, 'description' => '', 'help' => '', 'multiple' => 0, 'required' => 0, 'hierarchy' => 0, 'relations' => 0, 'tags' => 0, 'weight' => 0);
  $edit['nodes'] = array('file' => 'file');
  return (taxonomy_save_vocabulary($edit) == SAVED_NEW) ?
    taxonomy_vocabulary_load($edit['vid']) : FALSE;
}

function _fileserver_create_term($name, $vid, $parent = NULL) {
  $edit = array('vid' => $vid, 'parent' => $parent, 'name' => $name);
  return (taxonomy_save_term($edit) == SAVED_NEW) ?
    taxonomy_get_term($edit['tid']) : FALSE;
}

function _fileserver_reparent_category($tid, $parent = 0) {
  db_query('DELETE FROM {term_hierarchy} WHERE tid = %d', $tid);
  db_query('INSERT INTO {term_hierarchy} (tid, parent) VALUES (%d, %d)', $tid, $parent);
}

function _fileserver_reparent_tree($old_vid, $old_parent, $new_vid, $new_parent = 0) {
  // TODO: call taxonomy hooks?

  $tids = array();
  foreach (taxonomy_get_tree($old_vid, $old_parent) as $term) {
    $tids[] = $term->tid;
    if (empty($term->depth) && $old_parent != $new_parent) {
      _fileserver_reparent_category($term->tid, $new_parent);
    }
  }

  if (!empty($tids)) {
    $args = array_merge(array($new_vid), $tids);
    db_query('UPDATE {term_data} SET vid = %d WHERE tid IN (' . db_placeholders($tids) . ')', $args);
  }
  return TRUE;
}

function _fileserver_include_vocabulary($vid) {
  static $vocabs = NULL;
  if (is_null($vocabs)) {
    $vocabs = array_filter(variable_get('fileserver_vocabularies', array()), 'is_string');
  }

  // Filter by administrator-selected vocabularies
  if (is_array($vocabs) && array_key_exists($vid, $vocabs)) {
    return TRUE;
  }

  // Filter by OG vocabularies, if enabled by administrator
  if (FILESERVER_OG_VOCAB && module_exists('og_vocab')) {
    global $user;
    // NOTE: no need to cache this since og_get_subscriptions() memorizes the result.
    $groups = og_get_subscriptions($user->uid);
    if (count($groups)) {
      foreach ($groups as $group) {
        $nids[] = (int)$group['nid'];
      }
      $args = array_merge(array($vid), $nids);
      $count = db_result(db_query('SELECT COUNT(nid) FROM {og_vocab} WHERE vid = %d AND nid IN (' . db_placeholders($nids) . ')', $args));
      return !empty($count);
    }
  }

  return FALSE;
}

function _fileserver_export_vocabulary($vid) {
  $vocabs = array_filter(variable_get('fileserver_vocabularies', array()), 'is_string');
  $vocabs[$vid] = $vid;
  variable_set('fileserver_vocabularies', $vocabs);
}

function _fileserver_lookup_vocabulary($name) {
  foreach (taxonomy_get_vocabularies(FILESERVER_NODE_TYPE) as $vocabulary) {
    if ($vocabulary->name == $name && _fileserver_include_vocabulary($vocabulary->vid)) {
      return $vocabulary;
    }
  }
  return NULL;
}

function _fileserver_lookup_term($name, $vid, $tid = NULL) {
  $terms = !$tid ?
    taxonomy_get_children(NULL, $vid, 'name') :
    taxonomy_get_children($tid, NULL, 'name');
  return array_key_exists($name, $terms) ? $terms[$name] : NULL;
}

function _fileserver_lookup_file($name, $tid) {
  // TODO: this could be significantly optimized yet...
  $result = taxonomy_select_nodes(array((int)$tid), 'or', 0, FALSE);
  while ($node = db_fetch_object($result)) {
    $node = node_load($node->nid);
    if ($node->type == FILESERVER_NODE_TYPE && _fileserver_node_access('view', $node) && $node->title == $name) {
      return $node;
    }
  }
  return NULL;
}

function _fileserver_create_file($tid, $name, $options, $filepath) {
  global $user;

  // Ensure the user has privileges to create nodes of this type. This is
  // the last chance for access controls to fail, unless some node module
  // does weird things in hook_validate(), hook_submit() or hook_save().
  if (!user_access('create file content'))
    return STATUS_403; // Forbidden

  // manually create an upload object, saving conversions for the cron step
  $upload = (object)array(
    'filename'  => $name,
    'filepath'  => $filepath,
    'filemime'  => $options['content_type'],
    'filesize'  => filesize($filepath),
    'noconvert' => TRUE,
  );

  // according to FileFramework API, make it 'nosave'
  $node = (object)array(
    'nosave' => TRUE,
  );

  // save into Bitcache and RDF
  if (file_node_save($node, $upload)) {
    // Organic group vocabularies (og_vocab.module) integration: implicit
    // audience selection if the currently-selected taxonomy category is
    // related to an organic group.
    $og_groups = array();
    if (module_exists('og_vocab')) {
      if ($term = taxonomy_get_term($tid)) {
        if ($og_group = db_result(db_query('SELECT nid FROM {og_vocab} WHERE vid = %d', $term->vid))) {
          $og_groups[$og_group] = (string)$og_group;
        }
      }
    }

    // actually create the file node
    $node = file_node_create(array(
      'file'      => $node->file,
      'taxonomy'  => array($tid),
      'og_groups' => $og_groups,
    ));

    return (bool)$node;
  }

  return FALSE; // Something must've gone wrong
}

function _fileserver_update_file($tid, $name, $options, $filepath) {
  // fetch the node by this name for this term
  if (($node = _fileserver_lookup_file($name, $tid)) && _fileserver_node_access('update', $node)) {
    // manually create an upload object for the new version
    $upload = (object)array(
      'filename' => $name,
      'filepath' => $filepath,
      'filemime' => $options['content_type'],
      'filesize' => filesize($filepath),
      'noconvert' => TRUE,
    );

    // save a new revision if required; success even if files aren't versioned
    if (_fileserver_revision_node($node, 'update', array($node->file->size, filesize($filepath)))) {
      // use FileFramework to update the upload on the revision
      return (bool)file_node_save($node, $upload);
    }
  }

  return FALSE; // couldn't lookup the old node
}

function _fileserver_term_has_contents($tid) {
  return (bool)(taxonomy_term_count_nodes($tid, 'file') || count(taxonomy_get_children($tid)));
}

function _fileserver_node_access($op, $node) {
  global $user;
  switch ($op) {
    case 'view':
      return node_access('view', $node);
    case 'update':
      if ($node->uid == $user->uid && user_access('edit own file content'))
        return TRUE;
      else
        return user_access('edit any file content');
    case 'delete':
      if ($node->uid == $user->uid && user_access('delete own file content'))
        return TRUE;
      else
        return user_access('delete any file content');
  }
  
  return FALSE; // catch-all
}

function _fileserver_revision_node(&$node, $op = NULL, $args = array()) {
  // get default file node options
  $node_options = variable_get('node_options_' . FILESERVER_NODE_TYPE, array('status', 'promote'));
  // set node flag
  $node->revision = in_array('revision', $node_options);
  // save a new revision (uploaded file stays the same; gets updated by later calls to file_node_save())
  if ($node->revision) {
    // save old vid for comparison
    $old_vid = $node->vid;
    // create log message
    switch ($op) {
      case 'delete':
        $node->log = t('Tag %tag removed', array('%tag' => $args[0])) . FILESERVER_SIG;
        break;
      case 'rename':
        $node->log = t('Renamed from %old to %new', array('%old' => $args[0], '%new' => $args[1])) . FILESERVER_SIG;
        break;
      case 'move':
        $node->log = t('Tag %src removed; tag %dst added', array('%src' => $args[0], '%dst' => $args[1])) . FILESERVER_SIG;
        break;
      case 'copy':
        $node->log = t('Tag %tag added', array('%tag' => $args[0])) . FILESERVER_SIG;
        break;
      case 'update':
        $node->log = t('Contents edited');
        if ($args[0] != $args[1])
          $node->log .= t('; size changed from !old to !new', array('!old' => format_size($args[0]), '!new' => format_size($args[1])));
        $node->log .= FILESERVER_SIG;
        break;
    }
    // save a new revision
    node_save($node);
    // unset the revision flag & log message
    unset($node->revision);
    unset($node->log);
    // return success if revisioned
    return ($node->vid > $old_vid ? TRUE : FALSE);
  }
  
  return TRUE; // no need for revision
}

//////////////////////////////////////////////////////////////////////////////