field_file.inc 10.1 KB
Newer Older
1
<?php
2
// $Id$
3 4 5 6
/**
 * @file
 * Common functionality for file handling CCK field modules.
 */
7 8 9 10 11 12 13 14 15 16 17

/**
 * Load a file object from the database.
 *
 * @param $fid
 *   A numeric file id or string containing the file path.
 *
 * @param $reset
 *   Whether to reset the internal file_load cache.
 */
function field_file_load($fid, $reset = NULL) {
18 19 20
  // Reset internal cache.
  if (isset($reset)) {
    _field_file_cache(NULL, TRUE);
21 22
  }

23
  if (empty($fid)) {
24
    return array('fid' => 0, 'filepath' => '', 'filename' => '', 'filemime' => '', 'filesize' => 0);
25
  }
26

27
  $files = _field_file_cache();
28 29

  // Serve file from internal cache if available.
30 31 32 33 34 35 36
  if (empty($files[$fid])) {
    if (is_numeric($fid)) {
      $file = db_fetch_object(db_query('SELECT f.* FROM {files} f WHERE f.fid = %d', $fid));
    }
    else {
      $file = db_fetch_object(db_query("SELECT f.* FROM {files} f WHERE f.filepath = '%s'", $fid));
    }
37

38
    if (!$file) {
39
      $file = array('fid' => 0, 'filepath' => '', 'filename' => '', 'filemime' => '', 'filesize' => 0);
40
    }
41

42 43 44
    foreach (module_implements('file_load') as $module) {
      $function =  $module .'_file_load';
      $function($file);
45
    }
46

47 48
    // Cache the fully loaded file for later reusability.
    $files = _field_file_cache($file);
49
  }
50

51 52
  // Cast to array for field. hook_file() expects objects as well as
  // core file functions.
53
  return (array)$files[$fid];
54 55
}

56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88
/**
 * Save a file upload to a new location. The source file is validated as a
 * proper upload and handled as such. By implementing hook_file($op = 'insert'),
 * modules are able to act on the file upload and to add their own properties
 * to the file.
 *
 * The file will be added to the files table as a temporary file. Temporary files
 * are periodically cleaned. To make the file permanent file call
 * file_set_status() to change its status.
 *
 * @param $source
 *   A string specifying the name of the upload field to save.
 * @param $validators
 *   An optional, associative array of callback functions used to validate the
 *   file. The keys are function names and the values arrays of callback
 *   parameters which will be passed in after the user and file objects. The
 *   functions should return an array of error messages, an empty array
 *   indicates that the file passed validation. The functions will be called in
 *   the order specified.
 * @param $dest
 *   A string containing the directory $source should be copied to. If this is
 *   not provided or is not writable, the temporary directory will be used.
 * @param $replace
 *   A boolean indicating whether an existing file of the same name in the
 *   destination directory should overwritten. A false value will generate a
 *   new, unique filename in the destination directory.
 * @return
 *   An array containing the file information, or 0 in the event of an error.
 */
function field_file_save_upload($source, $validators = array(), $dest = FALSE, $replace = FILE_EXISTS_RENAME) {
  if (!$file = file_save_upload($source, $validators, $dest, $replace)) {
    return 0;
  }
89
  // Let modules add additional properties to the yet barebone file object.
90 91 92
  foreach (module_implements('file_insert') as $module) {
    $function =  $module .'_file_insert';
    $function($file);
93
  }
94
  _field_file_cache($file); // cache the file in order to minimize load queries
95
  return (array)$file;
96
}
97 98 99 100 101 102 103 104 105 106 107 108 109

/**
 * Update an field item file. Delete marked items if neccessary and set new items as permamant.
 *
 * @param $node
 *    Node object this file is be associated with.
 * @param $file
 *    File to be inserted, passed by reference since fid should be attached.
 * @return array
 */
function field_file_save($node, &$file) {
  // If this item is marked for deletion.
  if (!empty($file['delete'])) {
110 111 112
    // If we're creating a new revision, return an empty array so CCK will
    // remove the item.
    if (!empty($node->old_vid)) {
113 114
      return array();
    }
115
    // Otherwise delete the file and return an empty array.
116 117 118 119 120
    if (field_file_delete($file)) {
      return array();
    }
  }

121 122 123
  // Cast to object since core functions use objects.
  $file = (object)$file;

124
  // Set permanent status on files if unset.
125
  if (empty($file->status)) {
126 127
    file_set_status($file, FILE_STATUS_PERMANENT);
  }
128 129

  // Let modules update their additional file properties too.
130 131 132
  foreach (module_implements('file_update') as $module) {
    $function =  $module .'_file_update';
    $function($file);
133
  }
134 135
  _field_file_cache($file); // update the cache, in case the file has changed

136
  $file = (array)$file;
137 138 139 140 141 142
  return $file;
}

/**
 * Delete a field file and its database record.
 *
143
 * @param $path
144 145 146
 *   A file object.
 * @param $force
 *   Force File Deletion ignoring reference counting.
147
 * @return mixed
148 149 150 151 152 153 154
 *   TRUE for success, Array for reference count block, or FALSE in the event of an error.
 */
function field_file_delete($file, $force = FALSE) {
  $file = (object)$file;
  // If any module returns a value from the reference hook, the
  // file will not be deleted from Drupal, but file_delete will
  // return a populated array that tests as TRUE.
155
  if (!$force && $references = module_invoke_all('file_references', $file)) {
156 157 158 159
    $references = array_filter($references); // only keep positive values
    if (!empty($references)) {
      return $references;
    }
160 161 162
  }

  // Let other modules clean up on delete.
163
  module_invoke_all('file_delete', $file);
164

165
  // Make sure the file is deleted before removing its row from the
166 167 168
  // database, so UIs can still find the file in the database.
  if (file_delete($file->filepath)) {
    db_query('DELETE FROM {files} WHERE fid = %d', $file->fid);
169
    _field_file_cache(NULL, $file); // delete the file from the cache
170 171 172 173 174
    return TRUE;
  }
  return FALSE;
}

175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198
/**
 * Internal cache, in order to minimize database queries for loading files.
 */
function _field_file_cache($file = NULL, $reset = FALSE) {
  static $files = array();

  // Reset internal cache.
  if (is_object($reset)) { // file object, uncache just that one
    unset($files[$reset->fid]);
    unset($files[$reset->filepath]);
  }
  else if ($reset) { // TRUE, delete the whole cache
    $files = array();
  }

  // Cache the file by both fid and filepath.
  // Use non-copying objects to save memory.
  if (isset($file)) {
    $files[$file->fid] = $file;
    $files[$file->filepath] = $file;
  }
  return $files;
}

199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217
/**
 * A silent version of file.inc:file_check_directory it's only talkative
 * on errors.
 *
 * Check that the directory exists and is writable. Directories need to
 * have execute permissions to be considered a directory by FTP servers, etc.
 *
 * @param $directory A string containing the name of a directory path.
 * @param $mode A Boolean value to indicate if the directory should be created
 *   if it does not exist or made writable if it is read-only.
 * @param $form_item An optional string containing the name of a form item that
 *   any errors will be attached to. This is useful for settings forms that
 *   require the user to specify a writable directory. If it can't be made to
 *   work, a form error will be set preventing them from saving the settings.
 * @return FALSE when directory not found, or TRUE when directory exists.
 */
function field_file_check_directory(&$directory, $mode = 0, $form_item = NULL) {
  $directory = rtrim($directory, '/\\');

218 219 220 221 222 223 224 225 226 227 228 229
  // error if dir is a file. 
  if (is_file($directory)) {
    watchdog('file system',  'check_directory: The path  %directory is a file.',  array('%directory' => $directory), WATCHDOG_ERROR);
    if ($form_item)  form_set_error($form_item, t('The directory %directory is a file!', array('%directory' => $directory)));
    return FALSE;
  }

  // create the directory if it is missing.
  if (!is_dir($directory) && $mode & FILE_CREATE_DIRECTORY && !@mkdir($directory, 0775, true)) {
    watchdog('file system', 'The directory %directory does not exist.', array('%directory' => $directory), WATCHDOG_ERROR);
    if ($form_item) form_set_error($form_item, t('The directory %directory does not exist.', array('%directory' => $directory)));
    return FALSE;
230 231 232
  }

  // Check to see if the directory is writable.
233 234 235 236
  if (!is_writable($directory) && $mode & FILE_MODIFY_PERMISSIONS && !@chmod($directory, 0775)) {
    watchdog('file system', 'The directory %directory is not writable, because it does not have the correct permissions set.', array('%directory' => $directory), WATCHDOG_ERROR);
    if ($form_item) form_set_error($form_item, t('The directory %directory is not writable', array('%directory' => $directory)));
    return FALSE;
237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255
  }

  if ((file_directory_path() == $directory || file_directory_temp() == $directory) && !is_file("$directory/.htaccess")) {
    $htaccess_lines = "SetHandler Drupal_Security_Do_Not_Remove_See_SA_2006_006\nOptions None\nOptions +FollowSymLinks";
    if (($fp = fopen("$directory/.htaccess", 'w')) && fputs($fp, $htaccess_lines)) {
      fclose($fp);
      chmod($directory .'/.htaccess', 0664);
    }
    else {
      $message =  "Security warning: Couldn't write .htaccess file. Please create a .htaccess file in your %directory directory which contains the following lines: <code>!htaccess</code>";
      $repl =  array('%directory' => $directory, '!htaccess' => '<br />'. nl2br(check_plain($htaccess_lines)));
      form_set_error($form_item, t($message, $repl));
      watchdog('security', $message, $repl, WATCHDOG_ERROR);
    }
  }

  return TRUE;
}

256 257 258 259 260
/**
 * Remove a possible leading file directory path from the given path.
 */
function field_file_strip_path($path) {
  $dirpath = file_directory_path();
261 262 263
  $dirlen = drupal_strlen($dirpath);
  if (drupal_substr($path, 0, $dirlen + 1) == $dirpath .'/') {
    $path = drupal_substr($path, $dirlen + 1);
264 265 266
  }
  return $path;
}
267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284


/**
 * return references to a file by a single field.
 */

function field_file_references($file, $field) {
  $db_info = content_database_info($field);
  $references += db_result(db_query(
    'SELECT count('. $db_info['columns']['fid']['column'] .')
      FROM {'. $db_info['table'] .'}
      WHERE '. $db_info['columns']['fid']['column'] .' = %d', $file->fid
  ));
  if (isset($file->field_name) && $field['field_name'] == $file->field_name) {
    --$references; // doesn't count as it's being deleted
  }
  return $references;
}