filefield.module

   1 <?php
   2 // $Id$
   3
   4 /**
   5  * @file
   6  * FileField: Defines a CCK file field type.
   7  *
   8  * Uses content.module to store the fid and field specific metadata,
   9  * and Drupal's {files} table to store the actual file data.
  10  */
  11
  12 // FileField API hooks should always be available.
  13 include_once dirname(__FILE__) .'/field_file.inc';
  14
  15 /**
  16  * Implementation of hook_init().
  17  */
  18 function filefield_init() {
  19   // File hooks and callbacks may be used by any module.
  20   module_load_include('inc', 'filefield', 'filefield_widget');
  21   drupal_add_css(drupal_get_path('module', 'filefield') .'/filefield.css');
  22
  23   // Conditional module support.
  24   if (module_exists('token')) {
  25     module_load_include('inc', 'filefield', 'filefield.token');
  26   }
  27 }
  28
  29 /**
  30  * Implementation of hook_menu().
  31  */
  32 function filefield_menu() {
  33   $items = array();
  34
  35   $items['filefield/ahah/%/%/%'] = array(
  36     'page callback' => 'filefield_js',
  37     'page arguments' => array(2, 3, 4),
  38     'access callback' => 'filefield_edit_access',
  39     'access arguments' => array(3),
  40     'type' => MENU_CALLBACK,
  41   );
  42   $items['filefield/progress'] = array(
  43     'page callback' => 'filefield_progress',
  44     'access arguments' => array('access content'),
  45     'type' => MENU_CALLBACK,
  46   );
  47
  48   return $items;
  49 }
  50
  51 /**
  52  * Implementation of hook_elements().
  53  */
  54 function filefield_elements() {
  55   $elements = array();
  56   $elements['filefield_widget'] = array(
  57     '#input' => TRUE,
  58     '#columns' => array('fid', 'list', 'data'),
  59     '#process' => array('filefield_widget_process'),
  60     '#value_callback' => 'filefield_widget_value',
  61     '#element_validate' => array('filefield_widget_validate'),
  62   );
  63   return $elements;
  64 }
  65
  66 /**
  67  * Implementation of hook_theme().
  68  * @todo: autogenerate theme registry entrys for widgets.
  69  */
  70 function filefield_theme() {
  71   return array(
  72     'filefield_file' => array(
  73       'arguments' => array('file' => NULL),
  74       'file' => 'filefield_formatter.inc',
  75     ),
  76     'filefield_icon' => array(
  77       'arguments' => array('file' => NULL),
  78       'file' => 'filefield.theme.inc',
  79     ),
  80     'filefield_widget' => array(
  81       'arguments' => array('element' => NULL),
  82       'file' => 'filefield_widget.inc',
  83     ),
  84     'filefield_widget_item' => array(
  85       'arguments' => array('element' => NULL),
  86       'file' => 'filefield_widget.inc',
  87     ),
  88     'filefield_widget_preview' => array(
  89       'arguments' => array('element' => NULL),
  90       'file' => 'filefield_widget.inc',
  91     ),
  92     'filefield_widget_file' => array(
  93       'arguments' => array('element' => NULL),
  94       'file' => 'filefield_widget.inc',
  95     ),
  96
  97
  98     'filefield_formatter_default' => array(
  99       'arguments' => array('element' => NULL),
 100       'file' => 'filefield_formatter.inc',
 101     ),
 102     'filefield_formatter_url_plain' => array(
 103       'arguments' => array('element' => NULL),
 104       'file' => 'filefield_formatter.inc',
 105     ),
 106     'filefield_formatter_path_plain' => array(
 107       'arguments' => array('element' => NULL),
 108       'file' => 'filefield_formatter.inc',
 109     ),
 110     'filefield_item' => array(
 111       'arguments' => array('file' => NULL, 'field' => NULL),
 112       'file' => 'filefield_formatter.inc',
 113     ),
 114     'filefield_file' => array(
 115       'arguments' => array('file' => NULL),
 116       'file' => 'filefield_formatter.inc',
 117     ),
 118
 119  );
 120 }
 121
 122 /**
 123  * Implementation of hook_file_download(). Yes, *that* hook that causes
 124  * any attempt for file upload module interoperability to fail spectacularly.
 125  */
 126 function filefield_file_download($file) {
 127   $file = file_create_path($file);
 128
 129   $result = db_query("SELECT * FROM {files} WHERE filepath = '%s'", $file);
 130   if (!$file = db_fetch_object($result)) {
 131     // We don't really care about this file.
 132     return;
 133   }
 134
 135   // Find out if any filefield contains this file, and if so, which field
 136   // and node it belongs to. Required for later access checking.
 137   $cck_files = array();
 138   foreach (content_fields() as $field) {
 139     if ($field['type'] == 'filefield' || $field['type'] == 'image') {
 140       $db_info = content_database_info($field);
 141       $table = $db_info['table'];
 142       $fid_column = $db_info['columns']['fid']['column'];
 143
 144       $columns = array('vid', 'nid');
 145       foreach ($db_info['columns'] as $property_name => $column_info) {
 146         $columns[] = $column_info['column'] .' AS '. $property_name;
 147       }
 148       $result = db_query("SELECT ". implode(', ', $columns) ."
 149                           FROM {". $table ."}
 150                           WHERE ". $fid_column ." = %d", $file->fid);
 151
 152       while ($content = db_fetch_array($result)) {
 153         $content['field'] = $field;
 154         $cck_files[$field['field_name']][$content['vid']] = $content;
 155       }
 156     }
 157   }
 158   // If no filefield item is involved with this file, we don't care about it.
 159   if (empty($cck_files)) {
 160     return;
 161   }
 162
 163   // If any node includes this file but the user may not view this field,
 164   // then deny the download.
 165   foreach ($cck_files as $field_name => $field_files) {
 166     if (!filefield_view_access($field_name)) {
 167       return -1;
 168     }
 169   }
 170
 171   // So the overall field view permissions are not denied, but if access is
 172   // denied for a specific node containing the file, deny the download as well.
 173   // It's probably a little too restrictive, but I can't think of a
 174   // better way at the moment. Input appreciated.
 175   // (And yeah, node access checks also include checking for 'access content'.)
 176   $nodes = array();
 177   foreach ($cck_files as $field_name => $field_files) {
 178     foreach ($field_files as $revision_id => $content) {
 179       // Checking separately for each revision is probably not the best idea -
 180       // what if 'view revisions' is disabled? So, let's just check for the
 181       // current revision of that node.
 182       if (isset($nodes[$content['nid']])) {
 183         continue; // don't check the same node twice
 184       }
 185       $node = node_load($content['nid']);
 186       if (!node_access('view', $node)) {
 187         // You don't have permission to view the node this file is attached to.
 188         return -1;
 189       }
 190       $nodes[$content['nid']] = $node;
 191     }
 192   }
 193
 194   // Well I guess you can see this file.
 195   $name = mime_header_encode($file->filename);
 196   $type = mime_header_encode($file->filemime);
 197   // Serve images and text inline for the browser to display rather than download.
 198   $disposition = ereg('^(text/|image/)', $file->filemime) ? 'inline' : 'attachment';
 199   return array(
 200     'Content-Type: '. $type .'; name='. $name,
 201     'Content-Length: '. $file->filesize,
 202     'Content-Disposition: '. $disposition .'; filename='. $name,
 203     'Cache-Control: private',
 204   );
 205 }
 206
 207 /**
 208  * Implementation of hook_views_api().
 209  */
 210 function filefield_views_api() {
 211   return array(
 212     'api' => 2.0,
 213     'path' => drupal_get_path('module', 'filefield') . '/views',
 214   );
 215 }
 216
 217 /**
 218  * Implementation of hook_form_alter().
 219  *
 220  * Set the enctype on forms that need to accept file uploads.
 221  */
 222 function filefield_form_alter(&$form, $form_state, $form_id) {
 223   // Field configuration (for default images).
 224   if ($form_id == 'content_field_edit_form' && isset($form['#field']) && $form['#field']['type'] == 'filefield') {
 225     $form['#attributes']['enctype'] = 'multipart/form-data';
 226   }
 227
 228   // Node forms.
 229   if (preg_match('/_node_form$/', $form_id)) {
 230     $form['#attributes']['enctype'] = 'multipart/form-data';
 231   }
 232 }
 233
 234 /**
 235  * Implementation of CCK's hook_field_info().
 236  */
 237 function filefield_field_info() {
 238   return array(
 239     'filefield' => array(
 240       'label' => 'File',
 241       'description' => t('Store an arbitrary file.'),
 242     ),
 243   );
 244 }
 245
 246 /**
 247  * Implementation of hook_field_settings().
 248  */
 249 function filefield_field_settings($op, $field) {
 250   $return = array();
 251
 252   module_load_include('inc', 'filefield', 'filefield_field');
 253   $op = str_replace(' ', '_', $op);
 254   $function = 'filefield_field_settings_'. $op;
 255   if (function_exists($function)) {
 256     $result = $function($field);
 257     if (isset($result) && is_array($result)) {
 258       $return = $result;
 259     }
 260   }
 261
 262   return $return;
 263
 264 }
 265
 266 /**
 267  * Implementation of CCK's hook_field().
 268  */
 269 function filefield_field($op, $node, $field, &$items, $teaser, $page) {
 270   module_load_include('inc', 'filefield', 'filefield_field');
 271   $op = str_replace(' ', '_', $op);
 272   // add filefield specific handlers...
 273   $function = 'filefield_field_'. $op;
 274   if (function_exists($function)) {
 275     return $function($node, $field, $items, $teaser, $page);
 276   }
 277 }
 278
 279 /**
 280  * Implementation of CCK's hook_widget_settings().
 281  */
 282 function filefield_widget_settings($op, $widget) {
 283   switch ($op) {
 284     case 'form':
 285       return filefield_widget_settings_form($widget);
 286     case 'save':
 287       return filefield_widget_settings_save($widget);
 288   }
 289 }
 290
 291 /**
 292  * Implementation of hook_widget().
 293  */
 294 function filefield_widget(&$form, &$form_state, $field, $items, $delta = 0) {
 295   // CCK doesn't give a validate callback at the field level...
 296   // and FAPI's #require is naieve to complex structures...
 297   // we validate at the field level ourselves.
 298   if (empty($form['#validate']) || !in_array('filefield_node_form_validate', $form['#validate'])) {
 299     $form['#validate'][] = 'filefield_node_form_validate';
 300   }
 301   $form['#attributes'] = array('enctype' => 'multipart/form-data');
 302
 303   module_load_include('inc', 'filefield', 'field_widget');
 304   module_load_include('inc', $field['widget']['module'], $field['widget']['module'] .'_widget');
 305
 306   $item = array('fid' => 0, 'list' => $field['list_default'], 'data' => array('description' => ''));
 307   if (isset($items[$delta])) {
 308     $item = array_merge($item, $items[$delta]);
 309   }
 310   $element = array(
 311     '#title' => $field['widget']['label'],
 312     '#type' => $field['widget']['type'],
 313     '#default_value' => $item,
 314     '#upload_validators' => filefield_widget_upload_validators($field),
 315   );
 316
 317   return $element;
 318 }
 319
 320 /**
 321  * Get the upload validators for a file field.
 322  *
 323  * @param $field
 324  *   A CCK field array.
 325  * @return
 326  *   An array suitable for passing to file_save_upload() or the file field
 327  *   element's '#upload_validators' property.
 328  */
 329 function filefield_widget_upload_validators($field) {
 330   $max_filesize = parse_size(file_upload_max_size());
 331   if (!empty($field['widget']['max_filesize_per_file']) && parse_size($field['widget']['max_filesize_per_file']) < $max_filesize) {
 332     $max_filesize = parse_size($field['widget']['max_filesize_per_file']);
 333   }
 334
 335   $validators = array(
 336     // associate the field to the file on validation.
 337     'filefield_validate_associate_field' => array($field),
 338     'filefield_validate_size' => array($max_filesize),
 339     // Override core since it excludes uid 1 on the extension check.
 340     // Filefield only excuses uid 1 of quota requirements.
 341     'filefield_validate_extensions' => array($field['widget']['file_extensions']),
 342   );
 343   return $validators;
 344 }
 345
 346 /**
 347  * Implementation of CCK's hook_content_is_empty().
 348  *
 349  * The result of this determines whether content.module will save the value of
 350  * the field. Note that content module has some interesting behaviors for empty
 351  * values. It will always save at least one record for every node revision,
 352  * even if the values are all NULL. If it is a multi-value field with an
 353  * explicit limit, CCK will save that number of empty entries.
 354  */
 355 function filefield_content_is_empty($item, $field) {
 356   return empty($item['fid']) || (int)$item['fid'] == 0;
 357 }
 358
 359 /**
 360  * Implementation of CCK's hook_default_value().
 361  *
 362  * Note this is a widget-level hook, so it does not affect ImageField or other
 363  * modules that extend FileField.
 364  *
 365  * @see content_default_value()
 366  */
 367 function filefield_default_value(&$form, &$form_state, $field, $delta) {
 368   // Reduce the default number of upload fields to one.
 369   // CCK will automatically add one more field than necessary.
 370   if (!isset($form_state['item_count'][$field['field_name']])) {
 371     $form_state['item_count'][$field['field_name']] = 0;
 372   }
 373
 374   // The default value is actually handled in hook_widget().
 375   // hook_default_value() is only helpful for new nodes, and we need to affect
 376   // all widgets, such as when a new field is added via "Add another item".
 377   return array();
 378 }
 379
 380 /**
 381  * Implementation of CCK's hook_widget_info().
 382  */
 383 function filefield_widget_info() {
 384   return array(
 385     'filefield_widget' => array(
 386       'label' => t('File Upload'),
 387       'field types' => array('filefield'),
 388       'multiple values' => CONTENT_HANDLE_CORE,
 389       'callbacks' => array('default value' => CONTENT_CALLBACK_CUSTOM),
 390       'description' => t('A plain file upload widget.'),
 391     ),
 392   );
 393 }
 394
 395 /**
 396  * Implementation of CCK's hook_field_formatter_info().
 397  */
 398 function filefield_field_formatter_info() {
 399   return array(
 400     'default' => array(
 401       'label' => t('Generic files'),
 402       'field types' => array('filefield'),
 403       'multiple values' => CONTENT_HANDLE_CORE,
 404       'description' => t('Displays all kinds of files with an icon and a linked file description.'),
 405     ),
 406     'path_plain' => array(
 407       'label' => t('Path to file'),
 408       'field types' => array('filefield'),
 409       'description' => t('Displays the file system path to the file.'),
 410     ),
 411     'url_plain' => array(
 412       'label' => t('URL to file'),
 413       'field types' => array('filefield'),
 414       'description' => t('Displays a full URL to the file.'),
 415     ),
 416   );
 417 }
 418
 419 /**
 420  * Implementation of CCK's hook_content_generate(). Used by generate.module.
 421  */
 422 function filefield_content_generate($node, $field) {
 423   module_load_include('inc', 'filefield', 'filefield.devel');
 424
 425   if (content_handle('widget', 'multiple values', $field) == CONTENT_HANDLE_MODULE) {
 426     return content_devel_multiple('_filefield_content_generate', $node, $field);
 427   }
 428   else {
 429     return _filefield_content_generate($node, $field);
 430   }
 431 }
 432
 433 /**
 434  * Determine the most appropriate icon for the given file's mimetype.
 435  *
 436  * @param $file
 437  *   A file object.
 438  * @return
 439  *   The URL of the icon image file, or FALSE if no icon could be found.
 440  */
 441 function filefield_icon_url($file) {
 442   include_once(drupal_get_path('module', 'filefield') .'/filefield.theme.inc');
 443   return _filefield_icon_url($file);
 444 }
 445
 446 /**
 447  * Access callback for the JavaScript upload and deletion AHAH callbacks.
 448  *
 449  * The content_permissions module provides nice fine-grained permissions for
 450  * us to check, so we can make sure that the user may actually edit the file.
 451  */
 452 function filefield_edit_access($field_name) {
 453   if (module_exists('content_permissions')) {
 454     return user_access('edit '. $field_name);
 455   }
 456   // No content permissions to check, so let's fall back to a more general permission.
 457   return user_access('access content');
 458 }
 459
 460 /**
 461  * Access callback that checks if the current user may view the filefield.
 462  */
 463 function filefield_view_access($field_name) {
 464   if (module_exists('content_permissions')) {
 465     return user_access('view '. $field_name);
 466   }
 467   // No content permissions to check, so let's fall back to a more general permission.
 468   return user_access('access content');
 469 }
 470
 471 /**
 472  * Menu callback; Shared AHAH callback for uploads and deletions.
 473  *
 474  * This rebuilds the form element for a particular field item. As long as the
 475  * form processing is properly encapsulated in the widget element the form
 476  * should rebuild correctly using FAPI without the need for additional callbacks
 477  * or processing.
 478  */
 479 function filefield_js($type_name, $field_name, $delta) {
 480   $field = content_fields($field_name, $type_name);
 481
 482   if (empty($field) || empty($_POST['form_build_id'])) {
 483     // Invalid request.
 484     drupal_set_message(t('An unrecoverable error occurred. The uploaded file likely exceeded the maximum file size (@size) that this server supports.', array('@size' => format_size(file_upload_max_size()))), 'error');
 485     print drupal_to_js(array('data' => theme('status_messages')));
 486     exit;
 487   }
 488
 489   // Build the new form.
 490   $form_state = array('submitted' => FALSE);
 491   $form_build_id = $_POST['form_build_id'];
 492   $form = form_get_cache($form_build_id, $form_state);
 493
 494   if (!$form) {
 495     // Invalid form_build_id.
 496     drupal_set_message(t('An unrecoverable error occurred. This form was missing from the server cache. Try reloading the page and submitting again.'), 'error');
 497     print drupal_to_js(array('data' => theme('status_messages')));
 498     exit;
 499   }
 500
 501   // Build the form. This calls the file field's #value_callback function and
 502   // saves the uploaded file. Since this form is already marked as cached
 503   // (the #cache property is TRUE), the cache is updated automatically and we
 504   // don't need to call form_set_cache().
 505   $args = $form['#parameters'];
 506   $form_id = array_shift($args);
 507   $form['#post'] = $_POST;
 508   $form = form_builder($form_id, $form, $form_state);
 509
 510   // Update the cached form with the new element at the right place in the form.
 511   if (module_exists('fieldgroup') && ($group_name = _fieldgroup_field_get_group($type_name, $field_name))) {
 512     if (isset($form['#multigroups']) && isset($form['#multigroups'][$group_name][$field_name])) {
 513       $form_element = $form[$group_name][$delta][$field_name];
 514     }
 515     else {
 516       $form_element = $form[$group_name][$field_name][$delta];
 517     }
 518   }
 519   else {
 520     $form_element = $form[$field_name][$delta];
 521   }
 522
 523   if (isset($form_element['_weight'])) {
 524     unset($form_element['_weight']);
 525   }
 526
 527   $output = drupal_render($form_element);
 528
 529   // AHAH is not being nice to us and doesn't know the "other" button (that is,
 530   // either "Upload" or "Delete") yet. Which in turn causes it not to attach
 531   // AHAH behaviours after replacing the element. So we need to tell it first.
 532
 533   // Loop through the JS settings and find the settings needed for our buttons.
 534   $javascript = drupal_add_js(NULL, NULL);
 535   $filefield_ahah_settings = array();
 536   if (isset($javascript['setting'])) {
 537     foreach ($javascript['setting'] as $settings) {
 538       if (isset($settings['ahah'])) {
 539         foreach ($settings['ahah'] as $id => $ahah_settings) {
 540           if (strpos($id, 'filefield-upload') || strpos($id, 'filefield-remove')) {
 541             $filefield_ahah_settings[$id] = $ahah_settings;
 542           }
 543         }
 544       }
 545     }
 546   }
 547
 548   // Add the AHAH settings needed for our new buttons.
 549   if (!empty($filefield_ahah_settings)) {
 550     $output .= '<script type="text/javascript">jQuery.extend(Drupal.settings.ahah, '. drupal_to_js($filefield_ahah_settings) .');</script>';
 551   }
 552
 553   $output = theme('status_messages') . $output;
 554
 555   // For some reason, file uploads don't like drupal_json() with its manual
 556   // setting of the text/javascript HTTP header. So use this one instead.
 557   $GLOBALS['devel_shutdown'] = FALSE;
 558   print drupal_to_js(array('status' => TRUE, 'data' => $output));
 559   exit;
 560 }
 561
 562 /**
 563  * Menu callback for upload progress.
 564  */
 565 function filefield_progress($key) {
 566   $progress = array(
 567     'message' => t('Starting upload...'),
 568     'percentage' => -1,
 569   );
 570
 571   $implementation = filefield_progress_implementation();
 572   if ($implementation == 'uploadprogress') {
 573     $status = uploadprogress_get_info($key);
 574     if (isset($status['bytes_uploaded']) && !empty($status['bytes_total'])) {
 575       $progress['message'] = t('Uploading... (@current of @total)', array('@current' => format_size($status['bytes_uploaded']), '@total' => format_size($status['bytes_total'])));
 576       $progress['percentage'] = round(100 * $status['bytes_uploaded'] / $status['bytes_total']);
 577     }
 578   }
 579   elseif ($implementation == 'apc') {
 580     $status = apc_fetch('upload_' . $key);
 581     if (isset($status['current']) && !empty($status['total'])) {
 582       $progress['message'] = t('Uploading... (@current of @total)', array('@current' => format_size($status['current']), '@total' => format_size($status['total'])));
 583       $progress['percentage'] = round(100 * $status['current'] / $status['total']);
 584     }
 585   }
 586
 587   drupal_json($progress);
 588 }
 589
 590 /**
 591  * Determine which upload progress implementation to use, if any available.
 592  */
 593 function filefield_progress_implementation() {
 594   static $implementation;
 595   if (!isset($implementation)) {
 596     $implementation = FALSE;
 597
 598     // We prefer the PECL extension uploadprogress because it supports multiple
 599     // simultaneous uploads. APC only supports one at a time.
 600     if (extension_loaded('uploadprogress')) {
 601       $implementation = 'uploadprogress';
 602     }
 603     elseif (extension_loaded('apc') && ini_get('apc.rfc1867')) {
 604       $implementation = 'apc';
 605     }
 606   }
 607   return $implementation;
 608 }
 609
 610 /**
 611  * Implementation of hook_file_references().
 612  */
 613 function filefield_file_references($file) {
 614   $count = filefield_get_file_reference_count($file);
 615   return $count ? array('filefield' => $count) : NULL;
 616 }
 617
 618 /**
 619  * Implementation of hook_file_delete().
 620  */
 621 function filefield_file_delete($file) {
 622   // foreach  field... remove items referencing $file.
 623 }
 624
 625 /**
 626  * An #upload_validators callback. Check the file matches an allowed extension.
 627  *
 628  * If the mimedetect module is available, this will also validate that the
 629  * content of the file matches the extension. User #1 is included in this check.
 630  *
 631  * @param $file
 632  *   A Drupal file object.
 633  * @param $extensions
 634  *   A string with a space separated list of allowed extensions.
 635  * @return
 636  *   An array of any errors cause by this file if it failed validation.
 637  */
 638 function filefield_validate_extensions($file, $extensions) {
 639   global $user;
 640   $errors = array();
 641
 642   if (!empty($extensions)) {
 643     $regex = '/\.('. ereg_replace(' +', '|', preg_quote($extensions)) .')$/i';
 644     $matches = array();
 645     if (preg_match($regex, $file->filename, $matches)) {
 646       $extension = $matches[1];
 647       // If the extension validates, check that the mimetype matches.
 648       if (module_exists('mimedetect')) {
 649         $type = mimedetect_mime($file);
 650         if ($type != $file->filemime) {
 651           $errors[] = t('The file contents (@type) do not match its extension (@extension).', array('@type' => $type, '@extension' => $extension));
 652         }
 653       }
 654     }
 655     else {
 656       $errors[] = t('Only files with the following extensions are allowed: %files-allowed.', array('%files-allowed' => $extensions));
 657     }
 658   }
 659
 660   return $errors;
 661 }
 662
 663 /**
 664  * Help text automatically appended to fields that have extension validation.
 665  */
 666 function filefield_validate_extensions_help($extensions) {
 667   if (!empty($extensions)) {
 668     return t('Allowed Extensions: %ext', array('%ext' => $extensions));
 669   }
 670   else {
 671     return '';
 672   }
 673 }
 674
 675 /**
 676  * An #upload_validators callback. Check the file size does not exceed a limit.
 677  *
 678  * @param $file
 679  *   A Drupal file object.
 680  * @param $file_limit
 681  *   An integer value limiting the maximum file size in bytes.
 682  * @param $file_limit
 683  *   An integer value limiting the maximum size in bytes a user can upload on
 684  *   the entire site.
 685  * @return
 686  *   An array of any errors cause by this file if it failed validation.
 687  */
 688 function filefield_validate_size($file, $file_limit = 0, $user_limit = 0) {
 689   global $user;
 690
 691   $errors = array();
 692
 693   if ($file_limit && $file->filesize > $file_limit) {
 694     $errors[] = t('The file is %filesize exceeding the maximum file size of %maxsize.', array('%filesize' => format_size($file->filesize), '%maxsize' => format_size($file_limit)));
 695   }
 696
 697   // Bypass user limits for uid  = 1.
 698   if ($user->uid != 1) {
 699     $total_size = file_space_used($user->uid) + $file->filesize;
 700     if ($user_limit && $total_size > $user_limit) {
 701       $errors[] = t('The file is %filesize which would exceed your disk quota of %quota.', array('%filesize' => format_size($file->filesize), '%quota' => format_size($user_limit)));
 702     }
 703   }
 704   return $errors;
 705 }
 706
 707 /**
 708  * Automatic help text appended to fields that have file size validation.
 709  */
 710 function filefield_validate_size_help($size) {
 711   return t('Maximum Filesize: %size', array('%size' => format_size(parse_size($size))));
 712 }
 713
 714 /**
 715  * An #upload_validators callback. Check an image resolution.
 716  *
 717  * @param $file
 718  *   A Drupal file object.
 719  * @param $max_size
 720  *   A string in the format WIDTHxHEIGHT. If the image is larger than this size
 721  *   the image will be scaled to fit within these dimensions.
 722  * @param $min_size
 723  *   A string in the format WIDTHxHEIGHT. If the image is smaller than this size
 724  *   a validation error will be returned.
 725  * @return
 726  *   An array of any errors cause by this file if it failed validation.
 727  */
 728 function filefield_validate_image_resolution(&$file, $maximum_dimensions = 0, $minimum_dimensions = 0) {
 729   $errors = array();
 730
 731   list($max_width, $max_height) = explode('x', $maximum_dimensions);
 732   list($min_width, $min_height) = explode('x', $minimum_dimensions);
 733
 734   // Check first that the file is an image.
 735   if ($info = image_get_info($file->filepath)) {
 736     if ($maximum_dimensions) {
 737       // Check that it is smaller than the given dimensions.
 738       if ($info['width'] > $max_width || $info['height'] > $max_height) {
 739         $ratio = min($max_width/$info['width'], $max_height/$info['height']);
 740         // Check for exact dimension requirements (scaling allowed).
 741         if (strcmp($minimum_dimensions, $maximum_dimensions) == 0 && $info['width']/$max_width != $info['height']/$max_height) {
 742           $errors[] = t('The image must be exactly %dimensions pixels.', array('%dimensions' => $maximum_dimensions));
 743         }
 744         // Check that scaling won't drop the image below the minimum dimensions.
 745         elseif (image_get_toolkit() && (($info['width'] * $ratio < $min_width) || ($info['height'] * $ratio < $min_height))) {
 746           $errors[] = t('The image will not fit between the dimensions of %min_dimensions and %max_dimensions pixels.', array('%min_dimensions' => $minimum_dimensions, '%max_dimensions' => $maximum_dimensions));
 747         }
 748         // Try to resize the image to fit the dimensions.
 749         elseif (image_get_toolkit() && @image_scale($file->filepath, $file->filepath, $max_width, $max_height)) {
 750           drupal_set_message(t('The image was resized to fit within the maximum allowed dimensions of %dimensions pixels.', array('%dimensions' => $maximum_dimensions)));
 751
 752           // Clear the cached filesize and refresh the image information.
 753           clearstatcache();
 754           $info = image_get_info($file->filepath);
 755           $file->filesize = $info['file_size'];
 756         }
 757         else {
 758           $errors[] = t('The image is too large; the maximum dimensions are %dimensions pixels.', array('%dimensions' => $maximum_dimensions));
 759         }
 760       }
 761     }
 762
 763     if ($minimum_dimensions && empty($errors)) {
 764       // Check that it is larger than the given dimensions.
 765       if ($info['width'] < $min_width || $info['height'] < $min_height) {
 766         $errors[] = t('The image is too small; the minimum dimensions are %dimensions pixels.', array('%dimensions' => $minimum_dimensions));
 767       }
 768     }
 769   }
 770
 771   return $errors;
 772 }
 773
 774 /**
 775  * Automatic help text appended to fields that have image resolution validation.
 776  */
 777 function filefield_validate_image_resolution_help($max_size = '0', $min_size = '0') {
 778   if (!empty($max_size)) {
 779     if (!empty($min_size)) {
 780       if ($max_size == $min_size) {
 781         return t('Images must be exactly @min_size pixels', array('@min_size' => $min_size));
 782       }
 783       else {
 784         return t('Images must be between @min_size pixels and @max_size', array('@max_size' => $max_size, '@min_size' => $min_size));
 785       }
 786     }
 787     else {
 788       if (image_get_toolkit()) {
 789         return t('Images larger than @max_size pixels will be scaled', array('@max_size' => $max_size));
 790       }
 791       else {
 792         return t('Images must be smaller than @max_size pixels', array('@max_size' => $max_size));
 793       }
 794     }
 795   }
 796   if (!empty($min_size)) {
 797     return t('Images must be larger than @max_size pixels', array('@max_size' => $min_size));
 798   }
 799 }
 800
 801
 802 /**
 803  * An #upload_validators callback. Check that a file is an image.
 804  *
 805  * This check should allow any image that PHP can identify, including png, jpg,
 806  * gif, tif, bmp, psd, swc, iff, jpc, jp2, jpx, jb2, xbm, and wbmp.
 807  *
 808  * This check should be combined with filefield_validate_extensions() to ensure
 809  * only web-based images are allowed, however it provides a better check than
 810  * extension checking alone if the mimedetect module is not available.
 811  *
 812  * @param $file
 813  *   A Drupal file object.
 814  * @return
 815  *   An array of any errors cause by this file if it failed validation.
 816  */
 817 function filefield_validate_is_image(&$file) {
 818   $errors = array();
 819   $info = image_get_info($file->filepath);
 820   if (!$info || empty($info['extension'])) {
 821     $errors[] = t('The file is not a known image format.');
 822   }
 823   return $errors;
 824 }
 825
 826 /**
 827  * An #upload_validators callback. Add the field to the file object.
 828  *
 829  * This validation function adds the field to the file object for later
 830  * use in field aware modules implementing hook_file. It's not truly a
 831  * validation at all, rather a convient way to add properties to the uploaded
 832  * file.
 833  */
 834 function filefield_validate_associate_field(&$file, $field) {
 835   $file->field = $field;
 836   return array();
 837 }
 838
 839 /*******************************************************************************
 840  * Public API functions for FileField.
 841  ******************************************************************************/
 842
 843 /**
 844  * Return an array of file fields within a node type or by field name.
 845  *
 846  * @param $field
 847  *   Optional. May be either a field array or a field name.
 848  * @param $node_type
 849  *   Optional. The node type to filter the list of fields.
 850  */
 851 function filefield_get_field_list($node_type = NULL, $field = NULL) {
 852   // Build the list of fields to be used for retrieval.
 853   if (isset($field)) {
 854     if (is_string($field)) {
 855       $field = content_fields($field, $node_type);
 856     }
 857     $fields = array($field['field_name'] => $field);
 858   }
 859   elseif (isset($node_type)) {
 860     $type = content_types($node_type);
 861     $fields = $type['fields'];
 862   }
 863   else {
 864     $fields = content_fields();
 865   }
 866
 867   // Filter down the list just to file fields.
 868   foreach ($fields as $key => $field) {
 869     if ($field['type'] != 'filefield') {
 870       unset($fields[$key]);
 871     }
 872   }
 873
 874   return $fields;
 875 }
 876
 877 /**
 878  * Count the number of times the file is referenced within a field.
 879  *
 880  * @param $file
 881  *   A file object.
 882  * @param $field
 883  *   Optional. The CCK field array or field name as a string.
 884  * @return
 885  *   An integer value.
 886  */
 887 function filefield_get_file_reference_count($file, $field = NULL) {
 888   $fields = filefield_get_field_list(NULL, $field);
 889   $file = (object) $file;
 890
 891   $references = 0;
 892   foreach ($fields as $field) {
 893     $db_info = content_database_info($field);
 894     $references += db_result(db_query(
 895       'SELECT count('. $db_info['columns']['fid']['column'] .')
 896         FROM {'. $db_info['table'] .'}
 897         WHERE '. $db_info['columns']['fid']['column'] .' = %d', $file->fid
 898     ));
 899
 900     // If a field_name is present in the file object, the file is being deleted
 901     // from this field.
 902     if (isset($file->field_name) && $field['field_name'] == $file->field_name) {
 903       // If deleting the entire node, count how many references to decrement.
 904       if (isset($file->delete_nid)) {
 905         $node_references = db_result(db_query(
 906           'SELECT count('. $db_info['columns']['fid']['column'] .')
 907             FROM {'. $db_info['table'] .'}
 908             WHERE '. $db_info['columns']['fid']['column'] .' = %d AND nid = %d', $file->fid, $file->delete_nid
 909         ));
 910         $references = $references - $node_references;
 911       }
 912       else {
 913         $references = $references - 1;
 914       }
 915     }
 916   }
 917
 918   return $references;
 919 }
 920
 921 /**
 922  * Get a list of node IDs that reference a file.
 923  *
 924  * @param $file
 925  *   The file object for which to find references.
 926  * @param $field
 927  *   Optional. The CCK field array or field name as a string.
 928  * @return
 929  *   An array of IDs grouped by NID: array([nid] => array([vid1], [vid2])).
 930  */
 931 function filefield_get_file_references($file, $field = NULL) {
 932   $fields = filefield_get_field_list(NULL, $field);
 933   $file = (object) $file;
 934
 935   $references = array();
 936   foreach ($fields as $field) {
 937     $db_info = content_database_info($field);
 938     $sql = 'SELECT nid, vid FROM {'. $db_info['table'] .'} WHERE '. $db_info['columns']['fid']['column'] .' = %d';
 939     $result = db_query($sql, $file->fid);
 940     while ($row = db_fetch_object($result)) {
 941       $references[$row->nid][$row->vid] = $row->vid;
 942     }
 943   }
 944
 945   return $references;
 946 }
 947
 948 /**
 949  * Get all FileField files connected to a node ID.
 950  *
 951  * @param $nid
 952  *   The node object.
 953  * @param $field_name
 954  *   Optional. The CCK field array or field name as a string.
 955  * @return
 956  *   An array of all files attached to that field (or all fields).
 957  */
 958 function filefield_get_node_files($node, $field = NULL) {
 959   $fields = filefield_get_field_list($node->type, $field);
 960
 961   // Get the file rows.
 962   foreach ($fields as $field) {
 963     $db_info = content_database_info($field);
 964     $sql =  'SELECT f.* FROM {files} f INNER JOIN {' . $db_info['table'] . '} c ON f.fid = c.' . $db_info['columns']['fid']['column'] . ' AND c.vid = %d';
 965     $result = db_query($sql, $node->vid);
 966     while ($file = db_fetch_array($result)) {
 967       $files[$file['fid']] = $file;
 968     }
 969   }
 970
 971   return $files;
 972 }