file.inc 56.8 KB
Newer Older
Dries's avatar
 
Dries committed
1
<?php
Kjartan's avatar
Kjartan committed
2

Dries's avatar
   
Dries committed
3
4
5
6
7
/**
 * @file
 * API for handling file uploads and server file management.
 */

8
use Drupal\Core\StreamWrapper\LocalStream;
9
use Drupal\Component\PhpStorage\FileStorage;
10
use Drupal\Component\Utility\Settings;
11
use Drupal\Component\Utility\String;
12
use Drupal\Core\StreamWrapper\PublicStream;
13

14
/**
webchick's avatar
webchick committed
15
 * Stream wrapper bit flags that are the basis for composite types.
16
 *
webchick's avatar
webchick committed
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
 * Note that 0x0002 is skipped, because it was the value of a constant that has
 * since been removed.
 */

/**
 * Stream wrapper bit flag -- a filter that matches all wrappers.
 */
const STREAM_WRAPPERS_ALL = 0x0000;

/**
 * Stream wrapper bit flag -- refers to a local file system location.
 */
const STREAM_WRAPPERS_LOCAL = 0x0001;

/**
 * Stream wrapper bit flag -- wrapper is readable (almost always true).
 */
const STREAM_WRAPPERS_READ = 0x0004;

/**
 * Stream wrapper bit flag -- wrapper is writeable.
 */
const STREAM_WRAPPERS_WRITE = 0x0008;

/**
 * Stream wrapper bit flag -- exposed in the UI and potentially web accessible.
 */
const STREAM_WRAPPERS_VISIBLE = 0x0010;

46
47
48
49
50
51
52
53
54
55
56

/**
 * Default mode for new directories. See drupal_chmod().
 */
const FILE_CHMOD_DIRECTORY = 0775;

/**
 * Default mode for new files. See drupal_chmod().
 */
const FILE_CHMOD_FILE = 0664;

webchick's avatar
webchick committed
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
89
90
91
92
/**
 * Composite stream wrapper bit flags that are usually used as the types.
 */

/**
 * Stream wrapper type flag -- not visible in the UI or accessible via web,
 * but readable and writable. E.g. the temporary directory for uploads.
 */
define('STREAM_WRAPPERS_HIDDEN', STREAM_WRAPPERS_READ | STREAM_WRAPPERS_WRITE);

/**
 * Stream wrapper type flag -- hidden, readable and writeable using local files.
 */
define('STREAM_WRAPPERS_LOCAL_HIDDEN', STREAM_WRAPPERS_LOCAL | STREAM_WRAPPERS_HIDDEN);

/**
 * Stream wrapper type flag -- visible, readable and writeable.
 */
define('STREAM_WRAPPERS_WRITE_VISIBLE', STREAM_WRAPPERS_READ | STREAM_WRAPPERS_WRITE | STREAM_WRAPPERS_VISIBLE);

/**
 * Stream wrapper type flag -- visible and read-only.
 */
define('STREAM_WRAPPERS_READ_VISIBLE', STREAM_WRAPPERS_READ | STREAM_WRAPPERS_VISIBLE);

/**
 * Stream wrapper type flag -- the default when 'type' is omitted from
 * hook_stream_wrappers(). This does not include STREAM_WRAPPERS_LOCAL,
 * because PHP grants a greater trust level to local files (for example, they
 * can be used in an "include" statement, regardless of the "allow_url_include"
 * setting), so stream wrappers need to explicitly opt-in to this.
 */
define('STREAM_WRAPPERS_NORMAL', STREAM_WRAPPERS_WRITE_VISIBLE);

/**
 * Stream wrapper type flag -- visible, readable and writeable using local files.
93
 */
webchick's avatar
webchick committed
94
define('STREAM_WRAPPERS_LOCAL_NORMAL', STREAM_WRAPPERS_LOCAL | STREAM_WRAPPERS_NORMAL);
95

Kjartan's avatar
Kjartan committed
96
/**
Kjartan's avatar
Kjartan committed
97
 * @defgroup file File interface
Kjartan's avatar
Kjartan committed
98
 * @{
Dries's avatar
   
Dries committed
99
 * Common file handling functions.
100
 *
101
 * Fields on the file entity:
102
103
104
 * - fid: File ID
 * - uid: The {users}.uid of the user who is associated with the file.
 * - filename: Name of the file with no path components. This may differ from
105
106
 *   the basename of the filepath if the file is renamed to avoid overwriting
 *   an existing file.
107
108
109
110
 * - uri: URI of the file.
 * - filemime: The file's MIME type.
 * - filesize: The size of the file in bytes.
 * - status: A bitmapped field indicating the status of the file. The first 8
111
 *   bits are reserved for Drupal core. The least significant bit indicates
112
113
 *   temporary (0) or permanent (1). Temporary files older than
 *   DRUPAL_MAXIMUM_TEMP_FILE_AGE will be removed during cron runs.
114
 * - timestamp: UNIX timestamp for the date the file was added to the database.
Dries's avatar
 
Dries committed
115
116
 */

117
/**
118
 * Flag used by file_prepare_directory() -- create directory if not present.
119
 */
120
const FILE_CREATE_DIRECTORY = 1;
121
122

/**
123
 * Flag used by file_prepare_directory() -- file permissions may be changed.
124
 */
125
const FILE_MODIFY_PERMISSIONS = 2;
126
127

/**
128
 * Flag for dealing with existing files: Appends number until name is unique.
129
 */
130
const FILE_EXISTS_RENAME = 0;
131
132
133
134

/**
 * Flag for dealing with existing files: Replace the existing file.
 */
135
const FILE_EXISTS_REPLACE = 1;
136
137
138
139

/**
 * Flag for dealing with existing files: Do nothing and return FALSE.
 */
140
const FILE_EXISTS_ERROR = 2;
Dries's avatar
 
Dries committed
141

142
/**
143
144
145
146
147
 * Indicates that the file is permanent and should not be deleted.
 *
 * Temporary files older than DRUPAL_MAXIMUM_TEMP_FILE_AGE will be removed
 * during cron runs, but permanent files will not be removed during the file
 * garbage collection process.
148
 */
149
const FILE_STATUS_PERMANENT = 1;
150

151
/**
152
 * Provides Drupal stream wrapper registry.
153
154
155
156
157
158
159
160
161
162
163
164
165
166
 *
 * A stream wrapper is an abstraction of a file system that allows Drupal to
 * use the same set of methods to access both local files and remote resources.
 *
 * Provide a facility for managing and querying user-defined stream wrappers
 * in PHP. PHP's internal stream_get_wrappers() doesn't return the class
 * registered to handle a stream, which we need to be able to find the handler
 * for class instantiation.
 *
 * If a module registers a scheme that is already registered with PHP, the
 * existing scheme will be unregistered and replaced with the specified class.
 *
 * A stream is referenced as "scheme://target".
 *
167
168
169
170
 * The optional $filter parameter can be used to retrieve only the stream
 * wrappers that are appropriate for particular usage. For example, this returns
 * only stream wrappers that use local file storage:
 * @code
171
 *   $local_stream_wrappers = file_get_stream_wrappers(STREAM_WRAPPERS_LOCAL);
172
173
174
175
176
177
178
179
180
 * @endcode
 *
 * The $filter parameter can only filter to types containing a particular flag.
 * In some cases, you may want to filter to types that do not contain a
 * particular flag. For example, you may want to retrieve all stream wrappers
 * that are not writable, or all stream wrappers that are not local. PHP's
 * array_diff_key() function can be used to help with this. For example, this
 * returns only stream wrappers that do not use local file storage:
 * @code
181
 *   $remote_stream_wrappers = array_diff_key(file_get_stream_wrappers(STREAM_WRAPPERS_ALL), file_get_stream_wrappers(STREAM_WRAPPERS_LOCAL));
182
183
 * @endcode
 *
184
 * @param $filter
185
186
187
188
189
190
 *   (Optional) Filters out all types except those with an on bit for each on
 *   bit in $filter. For example, if $filter is STREAM_WRAPPERS_WRITE_VISIBLE,
 *   which is equal to (STREAM_WRAPPERS_READ | STREAM_WRAPPERS_WRITE |
 *   STREAM_WRAPPERS_VISIBLE), then only stream wrappers with all three of these
 *   bits set are returned. Defaults to STREAM_WRAPPERS_ALL, which returns all
 *   registered stream wrappers.
191
 *
192
 * @return
193
194
195
196
197
 *   An array keyed by scheme, with values containing an array of information
 *   about the stream wrapper, as returned by hook_stream_wrappers(). If $filter
 *   is omitted or set to STREAM_WRAPPERS_ALL, the entire Drupal stream wrapper
 *   registry is returned. Otherwise only the stream wrappers whose 'type'
 *   bitmask has an on bit for each bit specified in $filter are returned.
198
 *
199
200
201
 * @see hook_stream_wrappers()
 * @see hook_stream_wrappers_alter()
 */
202
function file_get_stream_wrappers($filter = STREAM_WRAPPERS_ALL) {
203
  $wrappers_storage = &drupal_static(__FUNCTION__, array());
204

205
206
207
208
  if (empty($wrappers_storage)) {
    // Initialize $wrappers_storage, so that we are not calling this method
    // repeatedly if no stream wrappers exist.
    $wrappers_storage[STREAM_WRAPPERS_ALL] = array();
209
    $wrappers = array();
210
    if (\Drupal::hasService('module_handler')) {
211
212
213
214
215
216
      $wrappers = \Drupal::moduleHandler()->invokeAll('stream_wrappers');
      foreach ($wrappers as $scheme => $info) {
        // Add defaults.
        $wrappers[$scheme] += array('type' => STREAM_WRAPPERS_NORMAL);
      }
      \Drupal::moduleHandler()->alter('stream_wrappers', $wrappers);
217
    }
218
219
220
    $existing = stream_get_wrappers();
    foreach ($wrappers as $scheme => $info) {
      // We only register classes that implement our interface.
webchick's avatar
webchick committed
221
      if (in_array('Drupal\Core\StreamWrapper\StreamWrapperInterface', class_implements($info['class']), TRUE)) {
222
223
224
225
226
227
228
229
        // Record whether we are overriding an existing scheme.
        if (in_array($scheme, $existing, TRUE)) {
          $wrappers[$scheme]['override'] = TRUE;
          stream_wrapper_unregister($scheme);
        }
        else {
          $wrappers[$scheme]['override'] = FALSE;
        }
230
231
        if (($info['type'] & STREAM_WRAPPERS_LOCAL) == STREAM_WRAPPERS_LOCAL) {
          stream_wrapper_register($scheme, $info['class']);
232
233
        }
        else {
234
          stream_wrapper_register($scheme, $info['class'], STREAM_IS_URL);
235
        }
236
      }
237
238
239
240
241
      // Pre-populate the static cache with the filters most typically used.
      $wrappers_storage[STREAM_WRAPPERS_ALL][$scheme] = $wrappers[$scheme];
      if (($info['type'] & STREAM_WRAPPERS_WRITE_VISIBLE) == STREAM_WRAPPERS_WRITE_VISIBLE) {
        $wrappers_storage[STREAM_WRAPPERS_WRITE_VISIBLE][$scheme] = $wrappers[$scheme];
      }
242
243
    }
  }
244
245
246
247
248

  if (!isset($wrappers_storage[$filter])) {
    $wrappers_storage[$filter] = array();
    foreach ($wrappers_storage[STREAM_WRAPPERS_ALL] as $scheme => $info) {
      // Bit-wise filter.
249
      if (($info['type'] & $filter) == $filter) {
250
251
252
253
254
255
        $wrappers_storage[$filter][$scheme] = $info;
      }
    }
  }

  return $wrappers_storage[$filter];
256
257
258
259
260
261
262
}

/**
 * Returns the stream wrapper class name for a given scheme.
 *
 * @param $scheme
 *   Stream scheme.
263
 *
264
265
266
267
268
269
270
271
272
273
274
275
276
 * @return
 *   Return string if a scheme has a registered handler, or FALSE.
 */
function file_stream_wrapper_get_class($scheme) {
  $wrappers = file_get_stream_wrappers();
  return empty($wrappers[$scheme]) ? FALSE : $wrappers[$scheme]['class'];
}

/**
 * Returns the scheme of a URI (e.g. a stream).
 *
 * @param $uri
 *   A stream, referenced as "scheme://target".
277
 *
278
279
280
 * @return
 *   A string containing the name of the scheme, or FALSE if none. For example,
 *   the URI "public://example.txt" would return "public".
281
282
 *
 * @see file_uri_target()
283
284
 */
function file_uri_scheme($uri) {
285
286
  $position = strpos($uri, '://');
  return $position ? substr($uri, 0, $position) : FALSE;
287
288
289
}

/**
290
 * Checks that the scheme of a stream URI is valid.
291
292
293
294
295
296
297
 *
 * Confirms that there is a registered stream handler for the provided scheme
 * and that it is callable. This is useful if you want to confirm a valid
 * scheme without creating a new instance of the registered handler.
 *
 * @param $scheme
 *   A URI scheme, a stream is referenced as "scheme://target".
298
 *
299
300
301
302
303
 * @return
 *   Returns TRUE if the string is the name of a validated stream,
 *   or FALSE if the scheme does not have a registered handler.
 */
function file_stream_wrapper_valid_scheme($scheme) {
304
  return $scheme && class_exists(file_stream_wrapper_get_class($scheme));
305
306
}

307

308
/**
309
 * Returns the part of a URI after the schema.
310
311
312
 *
 * @param $uri
 *   A stream, referenced as "scheme://target".
313
 *
314
315
316
317
 * @return
 *   A string containing the target (path), or FALSE if none.
 *   For example, the URI "public://sample/test.txt" would return
 *   "sample/test.txt".
318
319
 *
 * @see file_uri_scheme()
320
321
 */
function file_uri_target($uri) {
322
323
324
325
  $data = explode('://', $uri, 2);

  // Remove erroneous leading or trailing, forward-slashes and backslashes.
  return count($data) == 2 ? trim($data[1], '\/') : FALSE;
326
327
}

328
/**
329
 * Gets the default file stream implementation.
330
331
332
333
334
 *
 * @return
 *   'public', 'private' or any other file scheme defined as the default.
 */
function file_default_scheme() {
335
  return \Drupal::config('system.file')->get('default_scheme');
336
337
}

338
339
340
341
342
343
344
345
346
347
348
/**
 * Normalizes a URI by making it syntactically correct.
 *
 * A stream is referenced as "scheme://target".
 *
 * The following actions are taken:
 * - Remove trailing slashes from target
 * - Trim erroneous leading slashes from target. e.g. ":///" becomes "://".
 *
 * @param $uri
 *   String reference containing the URI to normalize.
349
 *
350
351
 * @return
 *   The normalized URI.
352
353
354
355
 */
function file_stream_wrapper_uri_normalize($uri) {
  $scheme = file_uri_scheme($uri);

356
  if (file_stream_wrapper_valid_scheme($scheme)) {
357
358
    $target = file_uri_target($uri);

359
360
361
    if ($target !== FALSE) {
      $uri = $scheme . '://' . $target;
    }
362
  }
363

364
365
366
367
  return $uri;
}

/**
368
 * Returns a reference to the stream wrapper class responsible for a given URI.
369
370
371
372
373
374
 *
 * The scheme determines the stream wrapper class that should be
 * used by consulting the stream wrapper registry.
 *
 * @param $uri
 *   A stream, referenced as "scheme://target".
375
 *
376
377
378
379
 * @return
 *   Returns a new stream wrapper object appropriate for the given URI or FALSE
 *   if no registered handler could be found. For example, a URI of
 *   "private://example.txt" would return a new private stream wrapper object
webchick's avatar
webchick committed
380
 *   (Drupal\Core\StreamWrapper\PrivateStream).
381
382
 */
function file_stream_wrapper_get_instance_by_uri($uri) {
383
384
385
386
387
388
389
  if ($scheme = file_uri_scheme($uri)) {
    $class = file_stream_wrapper_get_class($scheme);
    if (class_exists($class)) {
      $instance = new $class();
      $instance->setUri($uri);
      return $instance;
    }
390
  }
391
  return FALSE;
392
393
394
}

/**
395
 * Returns a reference to the stream wrapper class responsible for a scheme.
396
397
398
399
400
401
402
403
404
405
406
 *
 * This helper method returns a stream instance using a scheme. That is, the
 * passed string does not contain a "://". For example, "public" is a scheme
 * but "public://" is a URI (stream). This is because the later contains both
 * a scheme and target despite target being empty.
 *
 * Note: the instance URI will be initialized to "scheme://" so that you can
 * make the customary method calls as if you had retrieved an instance by URI.
 *
 * @param $scheme
 *   If the stream was "public://target", "public" would be the scheme.
407
 *
408
 * @return \Drupal\Core\StreamWrapper\StreamWrapperInterface
409
410
 *   Returns a new stream wrapper object appropriate for the given $scheme.
 *   For example, for the public scheme a stream wrapper object
webchick's avatar
webchick committed
411
 *   (Drupal\Core\StreamWrapper\PublicStream).
412
413
414
415
416
 *   FALSE is returned if no registered handler could be found.
 */
function file_stream_wrapper_get_instance_by_scheme($scheme) {
  $class = file_stream_wrapper_get_class($scheme);
  if (class_exists($class)) {
417
    $instance = new $class();
418
419
420
421
422
423
424
425
    $instance->setUri($scheme . '://');
    return $instance;
  }
  else {
    return FALSE;
  }
}

Dries's avatar
 
Dries committed
426
/**
427
 * Creates a web-accessible URL for a stream to an external or local file.
Dries's avatar
   
Dries committed
428
 *
429
 * Compatibility: normal paths and stream wrappers.
Dries's avatar
   
Dries committed
430
 *
431
 * There are two kinds of local files:
432
433
434
 * - "managed files", i.e. those stored by a Drupal-compatible stream wrapper.
 *   These are files that have either been uploaded by users or were generated
 *   automatically (for example through CSS aggregation).
435
436
437
 * - "shipped files", i.e. those outside of the files directory, which ship as
 *   part of Drupal core or contributed modules or themes.
 *
438
 * @param $uri
439
440
 *   The URI to a file for which we need an external URL, or the path to a
 *   shipped file.
441
 *
442
 * @return
443
 *   A string containing a URL that may be used to access the file.
444
445
446
 *   If the provided string already contains a preceding 'http', 'https', or
 *   '/', nothing is done and the same string is returned. If a stream wrapper
 *   could not be found to generate an external URL, then FALSE is returned.
447
448
 *
 * @see http://drupal.org/node/515192
449
 * @see file_url_transform_relative()
Dries's avatar
 
Dries committed
450
 */
451
function file_create_url($uri) {
452
453
  // Allow the URI to be altered, e.g. to serve a file from a CDN or static
  // file server.
454
  \Drupal::moduleHandler()->alter('file_url', $uri);
455

456
457
458
  $scheme = file_uri_scheme($uri);

  if (!$scheme) {
459
460
461
462
463
464
465
466
467
468
469
470
    // Allow for:
    // - root-relative URIs (e.g. /foo.jpg in http://example.com/foo.jpg)
    // - protocol-relative URIs (e.g. //bar.jpg, which is expanded to
    //   http://example.com/bar.jpg by the browser when viewing a page over
    //   HTTP and to https://example.com/bar.jpg when viewing a HTTPS page)
    // Both types of relative URIs are characterized by a leading slash, hence
    // we can use a single check.
    if (drupal_substr($uri, 0, 1) == '/') {
      return $uri;
    }
    else {
      // If this is not a properly formatted stream, then it is a shipped file.
471
472
      // Therefore, return the urlencoded URI with the base URL prepended.
      return $GLOBALS['base_url'] . '/' . drupal_encode_path($uri);
473
    }
474
475
  }
  elseif ($scheme == 'http' || $scheme == 'https') {
476
477
    // Check for HTTP so that we don't have to implement getExternalUrl() for
    // the HTTP wrapper.
478
479
480
481
482
483
484
485
486
487
488
    return $uri;
  }
  else {
    // Attempt to return an external URL using the appropriate wrapper.
    if ($wrapper = file_stream_wrapper_get_instance_by_uri($uri)) {
      return $wrapper->getExternalUrl();
    }
    else {
      return FALSE;
    }
  }
Dries's avatar
 
Dries committed
489
490
}

491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
/**
 * Transforms an absolute URL of a local file to a relative URL.
 *
 * May be useful to prevent problems on multisite set-ups and prevent mixed
 * content errors when using HTTPS + HTTP.
 *
 * @param string $file_url
 *   A file URL of a local file as generated by file_create_url().
 *
 * @return string
 *   If the file URL indeed pointed to a local file and was indeed absolute,
 *   then the transformed, relative URL to the local file. Otherwise: the
 *   original value of $file_url.
 *
 * @see file_create_url()
 */
function file_url_transform_relative($file_url) {
  // Unfortunately, we pretty much have to duplicate Symfony's
  // Request::getHttpHost() method because Request::getPort() may return NULL
  // instead of a port number.
  $http_host = '';
  $request = \Drupal::request();
  $host = $request->getHost();
  $scheme = $request->getScheme();
  $port = $request->getPort() ?: 80;
  if (('http' == $scheme && $port == 80) || ('https' == $scheme && $port == 443)) {
    $http_host = $host;
  }
  else {
    $http_host = $host . ':' . $port;
  }

  return preg_replace('|^https?://' . $http_host . '|', '', $file_url);
}

Dries's avatar
 
Dries committed
526
/**
527
 * Checks that the directory exists and is writable.
528
529
530
531
 *
 * Directories need to have execute permissions to be considered a directory by
 * FTP servers, etc.
 *
532
 * @param $directory
533
534
535
 *   A string reference containing the name of a directory path or URI. A
 *   trailing slash will be trimmed from a path.
 * @param $options
536
537
538
 *   A bitmask to indicate if the directory should be created if it does
 *   not exist (FILE_CREATE_DIRECTORY) or made writable if it is read-only
 *   (FILE_MODIFY_PERMISSIONS).
539
 *
540
 * @return
541
542
 *   TRUE if the directory exists (or was created) and is writable. FALSE
 *   otherwise.
Dries's avatar
 
Dries committed
543
 */
544
function file_prepare_directory(&$directory, $options = FILE_MODIFY_PERMISSIONS) {
545
546
547
548
  if (!file_stream_wrapper_valid_scheme(file_uri_scheme($directory))) {
    // Only trim if we're not dealing with a stream.
    $directory = rtrim($directory, '/\\');
  }
Dries's avatar
   
Dries committed
549
550
551

  // Check if directory exists.
  if (!is_dir($directory)) {
552
553
    // Let mkdir() recursively create directories and use the default directory
    // permissions.
554
    if ($options & FILE_CREATE_DIRECTORY) {
555
      return @drupal_mkdir($directory, NULL, TRUE);
Dries's avatar
   
Dries committed
556
    }
557
    return FALSE;
Dries's avatar
   
Dries committed
558
  }
559
560
561
  // The directory exists, so check to see if it is writable.
  $writable = is_writable($directory);
  if (!$writable && ($options & FILE_MODIFY_PERMISSIONS)) {
562
    return drupal_chmod($directory);
Dries's avatar
   
Dries committed
563
564
  }

565
  return $writable;
Dries's avatar
 
Dries committed
566
567
568
}

/**
569
 * Creates a .htaccess file in each Drupal files directory if it is missing.
Dries's avatar
 
Dries committed
570
 */
571
function file_ensure_htaccess() {
572
  file_save_htaccess('public://', FALSE);
573
  $private_path = \Drupal::config('system.file')->get('path.private');
574
  if (!empty($private_path)) {
575
    file_save_htaccess('private://', TRUE);
576
  }
577
  file_save_htaccess('temporary://', TRUE);
578
  file_save_htaccess(config_get_config_directory(), TRUE);
579
  file_save_htaccess(config_get_config_directory(CONFIG_STAGING_DIRECTORY), TRUE);
Dries's avatar
 
Dries committed
580
581
582
}

/**
583
 * Creates a .htaccess file in the given directory.
Dries's avatar
 
Dries committed
584
 *
585
 * @param string $directory
586
 *   The directory.
587
588
589
590
591
592
593
594
 * @param bool $private
 *   (Optional) FALSE indicates that $directory should be a web-accessible
 *   directory. Defaults to TRUE which indicates a private directory.
 * @param bool $force_overwrite
 *   (Optional) Set to TRUE to attempt to overwrite the existing .htaccess file
 *   if one is already present. Defaults to FALSE.
 */
function file_save_htaccess($directory, $private = TRUE, $force_overwrite = FALSE) {
595
  if (file_uri_scheme($directory)) {
596
    $htaccess_path = file_stream_wrapper_uri_normalize($directory . '/.htaccess');
597
598
  }
  else {
599
    $directory = rtrim($directory, '/\\');
600
    $htaccess_path = $directory . '/.htaccess';
601
  }
602

603
  if (file_exists($htaccess_path) && !$force_overwrite) {
604
    // Short circuit if the .htaccess file already exists.
605
    return TRUE;
606
  }
607
  $htaccess_lines = file_htaccess_lines($private);
608
609

  // Write the .htaccess file.
610
611
  if (file_exists($directory) && is_writable($directory) && file_put_contents($htaccess_path, $htaccess_lines)) {
    return drupal_chmod($htaccess_path, 0444);
612
613
  }
  else {
614
    $variables = array('%directory' => $directory, '!htaccess' => '<br />' . nl2br(String::checkPlain($htaccess_lines)));
615
    watchdog('security', "Security warning: Couldn't write .htaccess file. Please create a .htaccess file in your %directory directory which contains the following lines: <code>!htaccess</code>", $variables, WATCHDOG_ERROR);
616
    return FALSE;
Dries's avatar
 
Dries committed
617
618
619
  }
}

620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
/**
 * Returns the standard .htaccess lines that Drupal writes to file directories.
 *
 * @param bool $private
 *   (Optional) Set to FALSE to return the .htaccess lines for a web-accessible
 *   public directory. The default is TRUE, which returns the .htaccess lines
 *   for a private directory that should not be web-accessible.
 *
 * @return string
 *   The desired contents of the .htaccess file.
 *
 * @see file_create_htaccess()
 */
function file_htaccess_lines($private = TRUE) {
  return FileStorage::htaccessLines($private);
}

637
/**
638
 * Determines whether the URI has a valid scheme for file API operations.
639
640
641
642
643
644
645
646
647
648
649
650
651
652
 *
 * There must be a scheme and it must be a Drupal-provided scheme like
 * 'public', 'private', 'temporary', or an extension provided with
 * hook_stream_wrappers().
 *
 * @param $uri
 *   The URI to be tested.
 *
 * @return
 *   TRUE if the URI is allowed.
 */
function file_valid_uri($uri) {
  // Assert that the URI has an allowed scheme. Barepaths are not allowed.
  $uri_scheme = file_uri_scheme($uri);
653
  if (!file_stream_wrapper_valid_scheme($uri_scheme)) {
654
655
656
657
658
    return FALSE;
  }
  return TRUE;
}

659
/**
660
 * Copies a file to a new location without invoking the file API.
Dries's avatar
 
Dries committed
661
 *
662
663
664
665
666
 * This is a powerful function that in many ways performs like an advanced
 * version of copy().
 * - Checks if $source and $destination are valid and readable/writable.
 * - If file already exists in $destination either the call will error out,
 *   replace the file or rename the file based on the $replace parameter.
667
 * - If the $source and $destination are equal, the behavior depends on the
668
 *   $replace parameter. FILE_EXISTS_REPLACE will error out. FILE_EXISTS_RENAME
669
 *   will rename the file until the $destination is unique.
670
671
 * - Provides a fallback using realpaths if the move fails using stream
 *   wrappers. This can occur because PHP's copy() function does not properly
672
 *   support streams if open_basedir is enabled. See
673
 *   https://bugs.php.net/bug.php?id=60456
674
675
 *
 * @param $source
676
 *   A string specifying the filepath or URI of the source file.
677
 * @param $destination
678
 *   A URI containing the destination that $source should be copied to. The
679
680
 *   URI may be a bare filepath (without a scheme). If this value is omitted,
 *   Drupal's default files scheme will be used, usually "public://".
681
682
683
684
 * @param $replace
 *   Replace behavior when the destination file already exists:
 *   - FILE_EXISTS_REPLACE - Replace the existing file.
 *   - FILE_EXISTS_RENAME - Append _{incrementing number} until the filename is
685
 *       unique.
686
 *   - FILE_EXISTS_ERROR - Do nothing and return FALSE.
687
 *
688
689
 * @return
 *   The path to the new file, or FALSE in the event of an error.
690
 *
691
 * @see file_copy()
Dries's avatar
 
Dries committed
692
 */
693
function file_unmanaged_copy($source, $destination = NULL, $replace = FILE_EXISTS_RENAME) {
694
695
  $original_source = $source;

696
  // Assert that the source file actually exists.
697
  if (!file_exists($source)) {
698
    // @todo Replace drupal_set_message() calls with exceptions instead.
699
    drupal_set_message(t('The specified file %file could not be copied because no file by that name exists. Please check that you supplied the correct filename.', array('%file' => $original_source)), 'error');
700
701
702
703
704
705
    if (($realpath = drupal_realpath($original_source)) !== FALSE) {
      watchdog('file', 'File %file (%realpath) could not be copied because it does not exist.', array('%file' => $original_source, '%realpath' => $realpath));
    }
    else {
      watchdog('file', 'File %file could not be copied because it does not exist.', array('%file' => $original_source));
    }
706
707
    return FALSE;
  }
Dries's avatar
 
Dries committed
708

709
710
  // Build a destination URI if necessary.
  if (!isset($destination)) {
711
    $destination = file_build_uri(drupal_basename($source));
712
  }
Dries's avatar
 
Dries committed
713
714


715
716
717
  // Prepare the destination directory.
  if (file_prepare_directory($destination)) {
    // The destination is already a directory, so append the source basename.
718
    $destination = file_stream_wrapper_uri_normalize($destination . '/' . drupal_basename($source));
719
720
721
722
723
724
  }
  else {
    // Perhaps $destination is a dir/file?
    $dirname = drupal_dirname($destination);
    if (!file_prepare_directory($dirname)) {
      // The destination is not valid.
725
726
      watchdog('file', 'File %file could not be copied because the destination directory %destination is not configured correctly.', array('%file' => $original_source, '%destination' => $dirname));
      drupal_set_message(t('The specified file %file could not be copied because the destination directory is not properly configured. This may be caused by a problem with file or directory permissions. More information is available in the system log.', array('%file' => $original_source)), 'error');
727
728
729
      return FALSE;
    }
  }
730

731
732
  // Determine whether we can perform this operation based on overwrite rules.
  $destination = file_destination($destination, $replace);
733
  if ($destination === FALSE) {
734
    drupal_set_message(t('The file %file could not be copied because a file by that name already exists in the destination directory.', array('%file' => $original_source)), 'error');
735
    watchdog('file', 'File %file could not be copied because a file by that name already exists in the destination directory (%destination)', array('%file' => $original_source, '%destination' => $destination));
736
    return FALSE;
Dries's avatar
 
Dries committed
737
  }
738
739

  // Assert that the source and destination filenames are not the same.
740
741
742
  $real_source = drupal_realpath($source);
  $real_destination = drupal_realpath($destination);
  if ($source == $destination || ($real_source !== FALSE) && ($real_source == $real_destination)) {
743
    drupal_set_message(t('The specified file %file was not copied because it would overwrite itself.', array('%file' => $source)), 'error');
744
    watchdog('file', 'File %file could not be copied because it would overwrite itself.', array('%file' => $source));
745
    return FALSE;
Dries's avatar
 
Dries committed
746
  }
747
748
749
  // Make sure the .htaccess files are present.
  file_ensure_htaccess();
  // Perform the copy operation.
750
  if (!@copy($source, $destination)) {
751
752
753
754
755
756
    // If the copy failed and realpaths exist, retry the operation using them
    // instead.
    if ($real_source === FALSE || $real_destination === FALSE || !@copy($real_source, $real_destination)) {
      watchdog('file', 'The specified file %file could not be copied to %destination.', array('%file' => $source, '%destination' => $destination), WATCHDOG_ERROR);
      return FALSE;
    }
Dries's avatar
 
Dries committed
757
  }
Dries's avatar
   
Dries committed
758

759
760
  // Set the permissions on the new file.
  drupal_chmod($destination);
761
762

  return $destination;
Dries's avatar
 
Dries committed
763
764
}

765
/**
766
 * Constructs a URI to Drupal's default files location given a relative path.
767
768
 */
function file_build_uri($path) {
769
  $uri = file_default_scheme() . '://' . $path;
770
771
772
  return file_stream_wrapper_uri_normalize($uri);
}

773
/**
774
 * Determines the destination path for a file.
775
 *
776
 * @param $destination
777
 *   A string specifying the desired final URI or filepath.
778
779
 * @param $replace
 *   Replace behavior when the destination file already exists.
780
 *   - FILE_EXISTS_REPLACE - Replace the existing file.
781
 *   - FILE_EXISTS_RENAME - Append _{incrementing number} until the filename is
782
 *       unique.
783
 *   - FILE_EXISTS_ERROR - Do nothing and return FALSE.
784
 *
785
 * @return
786
787
 *   The destination filepath, or FALSE if the file already exists
 *   and FILE_EXISTS_ERROR is specified.
788
789
790
791
 */
function file_destination($destination, $replace) {
  if (file_exists($destination)) {
    switch ($replace) {
792
793
794
795
      case FILE_EXISTS_REPLACE:
        // Do nothing here, we want to overwrite the existing file.
        break;

796
      case FILE_EXISTS_RENAME:
797
        $basename = drupal_basename($destination);
798
        $directory = drupal_dirname($destination);
799
800
801
802
        $destination = file_create_filename($basename, $directory);
        break;

      case FILE_EXISTS_ERROR:
803
        // Error reporting handled by calling function.
804
805
806
807
808
809
        return FALSE;
    }
  }
  return $destination;
}

810
/**
811
 * Moves a file to a new location without database changes or hook invocation.
Dries's avatar
   
Dries committed
812
 *
813
 * @param $source
814
 *   A string specifying the filepath or URI of the original file.
815
 * @param $destination
816
817
818
 *   A string containing the destination that $source should be moved to.
 *   This must be a stream wrapper URI. If this value is omitted, Drupal's
 *   default files scheme will be used, usually "public://".
819
820
821
822
 * @param $replace
 *   Replace behavior when the destination file already exists:
 *   - FILE_EXISTS_REPLACE - Replace the existing file.
 *   - FILE_EXISTS_RENAME - Append _{incrementing number} until the filename is
823
 *       unique.
824
 *   - FILE_EXISTS_ERROR - Do nothing and return FALSE.
825
 *
826
 * @return
827
 *   The URI of the moved file, or FALSE in the event of an error.
828
 *
829
 * @see file_move()
Dries's avatar
   
Dries committed
830
 */
831
832
833
function file_unmanaged_move($source, $destination = NULL, $replace = FILE_EXISTS_RENAME) {
  $filepath = file_unmanaged_copy($source, $destination, $replace);
  if ($filepath == FALSE || file_unmanaged_delete($source) == FALSE) {
834
    return FALSE;
Dries's avatar
 
Dries committed
835
  }
836
  return $filepath;
Dries's avatar
 
Dries committed
837
838
}

839
/**
840
 * Modifies a filename as needed for security purposes.
841
 *
842
843
844
845
846
847
848
849
850
851
852
 * Munging a file name prevents unknown file extensions from masking exploit
 * files. When web servers such as Apache decide how to process a URL request,
 * they use the file extension. If the extension is not recognized, Apache
 * skips that extension and uses the previous file extension. For example, if
 * the file being requested is exploit.php.pps, and Apache does not recognize
 * the '.pps' extension, it treats the file as PHP and executes it. To make
 * this file name safe for Apache and prevent it from executing as PHP, the
 * .php extension is "munged" into .php_, making the safe file name
 * exploit.php_.pps.
 *
 * Specifically, this function adds an underscore to all extensions that are
853
 * between 2 and 5 characters in length, internal to the file name, and not
854
855
 * included in $extensions.
 *
856
857
858
 * Function behavior is also controlled by the configuration
 * 'system.file:allow_insecure_uploads'. If it evaluates to TRUE, no alterations
 * will be made, if it evaluates to FALSE, the filename is 'munged'. *
859
 * @param $filename
860
 *   File name to modify.
861
 * @param $extensions
862
 *   A space-separated list of extensions that should not be altered.
863
 * @param $alerts
864
865
866
 *   If TRUE, drupal_set_message() will be called to display a message if the
 *   file name was changed.
 *
867
 * @return string
868
 *   The potentially modified $filename.
869
870
871
872
873
 */
function file_munge_filename($filename, $extensions, $alerts = TRUE) {
  $original = $filename;

  // Allow potentially insecure uploads for very savvy users and admin
874
  if (!\Drupal::config('system.file')->get('allow_insecure_uploads')) {
875
876
877
    // Remove any null bytes. See http://php.net/manual/en/security.filesystem.nullbytes.php
    $filename = str_replace(chr(0), '', $filename);

878
879
880
881
882
883
884
885
886
887
888
889
    $whitelist = array_unique(explode(' ', trim($extensions)));

    // Split the filename up by periods. The first part becomes the basename
    // the last part the final extension.
    $filename_parts = explode('.', $filename);
    $new_filename = array_shift($filename_parts); // Remove file basename.
    $final_extension = array_pop($filename_parts); // Remove final extension.

    // Loop through the middle parts of the name and add an underscore to the
    // end of each section that could be a file extension but isn't in the list
    // of allowed extensions.
    foreach ($filename_parts as $filename_part) {
890
      $new_filename .= '.' . $filename_part;
891
892
893
894
      if (!in_array($filename_part, $whitelist) && preg_match("/^[a-zA-Z]{2,5}\d?$/", $filename_part)) {
        $new_filename .= '_';
      }
    }
895
    $filename = $new_filename . '.' . $final_extension;
896
897
898
899
900
901
902
903
904
905

    if ($alerts && $original != $filename) {
      drupal_set_message(t('For security reasons, your upload has been renamed to %filename.', array('%filename' => $filename)));
    }
  }

  return $filename;
}

/**
906
 * Undoes the effect of file_munge_filename().
907
 *
908
909
 * @param $filename
 *   String with the filename to be unmunged.
910
 *
911
912
 * @return
 *   An unmunged filename string.
913
914
915
916
917
 */
function file_unmunge_filename($filename) {
  return str_replace('_.', '.', $filename);
}

918
/**
919
 * Creates a full file path from a directory and filename.
920
921
922
 *
 * If a file with the specified name already exists, an alternative will be
 * used.
923
 *
924
925
926
 * @param $basename
 *   String filename
 * @param $directory
927
 *   String containing the directory or parent URI.
928
 *
929
 * @return
930
931
 *   File path consisting of $directory and a unique filename based off
 *   of $basename.
932
 */
Dries's avatar
   
Dries committed
933
function file_create_filename($basename, $directory) {
934
935
936
  // Strip control characters (ASCII value < 32). Though these are allowed in
  // some filesystems, not many applications handle them well.
  $basename = preg_replace('/[\x00-\x1F]/u', '_', $basename);
937
938
939
940
  if (substr(PHP_OS, 0, 3) == 'WIN') {
    // These characters are not allowed in Windows filenames
    $basename = str_replace(array(':', '*', '?', '"', '<', '>', '|'), '_', $basename);
  }
941

942
943
944
945
946
947
948
949
950
  // A URI or path may already have a trailing slash or look like "public://".
  if (substr($directory, -1) == '/') {
    $separator = '';
  }
  else {
    $separator = '/';
  }

  $destination = $directory . $separator . $basename;
Dries's avatar
   
Dries committed
951

952
  if (file_exists($destination)) {
Dries's avatar
   
Dries committed
953
    // Destination file already exists, generate an alternative.
954
955
    $pos = strrpos($basename, '.');
    if ($pos !== FALSE) {
Dries's avatar
   
Dries committed
956
957
958
959
960
      $name = substr($basename, 0, $pos);
      $ext = substr($basename, $pos);
    }
    else {
      $name = $basename;
961
      $ext = '';
Dries's avatar
   
Dries committed
962
963
964
965
    }

    $counter = 0;
    do {
966
      $destination = $directory . $separator . $name . '_' . $counter++ . $ext;
967
    } while (file_exists($destination));
Dries's avatar
   
Dries committed
968
969
  }

970
  return $destination;
Dries's avatar
   
Dries committed
971
972
}

973
/**
974
 * Deletes a file and its database record.
975
 *
976
977
978
 * Instead of directly deleting a file, it is strongly recommended to delete
 * file usages instead. That will automatically mark the file as temporary and
 * remove it during cleanup.
979
 *
980
981
 * @param $fid
 *   The file id.
982
 *
983
 * @see file_unmanaged_delete()
984
 * @see \Drupal\file\FileUsage\FileUsageBase::delete()
985
 */
986
987
988
function file_delete($fid) {
  return file_delete_multiple(array($fid));
}
989

990
991
992
993
994
995
996
997
998
999
1000
/**
 * Deletes files.
 *
 * Instead of directly deleting a file, it is strongly recommended to delete
 * file usages instead. That will automatically mark the file as temporary and
 * remove it during cleanup.
 *
 * @param $fid
 *   The file id.
 *
 * @see file_unmanaged_delete()
1001
 * @see \Drupal\file\FileUsage\FileUsageBase::delete()
1002
1003
1004
 */
function file_delete_multiple(array $fids) {
  entity_delete_multiple('file', $fids);
1005
1006
1007
}

/**
1008
 * Deletes a file without database changes or hook invocations.
1009
1010
1011
 *
 * This function should be used when the file to be deleted does not have an
 * entry recorded in the files table.
1012
 *
1013
 * @param $path
1014
 *   A string containing a file path or (streamwrapper) URI.
1015
 *
1016
1017
1018
 * @return
 *   TRUE for success or path does not exist, or FALSE in the event of an
 *   error.
1019
 *
1020
 * @see file_delete()
1021
 * @see file_unmanaged_delete_recursive()
1022
 */
1023
function file_unmanaged_delete($path) {
1024
  if (is_dir($path)) {
1025
    watchdog('file', '%path is a directory and cannot be removed using file_unmanaged_delete().', array('%path' => $path), WATCHDOG_ERROR);
1026
1027
    return FALSE;
  }
1028
  if (is_file($path)) {
1029
    return drupal_unlink($path);
1030
  }
1031
  // Return TRUE for non-existent file, but log that nothing was actually
1032
  // deleted, as the current state is the intended result.
1033
  if (!file_exists($path)) {
1034
    watchdog('file', 'The file %path was not deleted because it does not exist.', array('%path' => $path), WATCHDOG_NOTICE);
1035
1036
    return TRUE;
  }
1037
1038
  // We cannot handle anything other than files and directories. Log an error
  // for everything else (sockets, symbolic links, etc).
1039
  watchdog('file', 'The file %path is not of a recognized type so it was not deleted.', array('%path' => $path), WATCHDOG_ERROR);