1
|
<?php
|
2
|
|
3
|
/**
|
4
|
* @file
|
5
|
* API for handling file uploads and server file management.
|
6
|
*/
|
7
|
|
8
|
/**
|
9
|
* Manually include stream wrapper code.
|
10
|
*
|
11
|
* Stream wrapper code is included here because there are cases where
|
12
|
* File API is needed before a bootstrap, or in an alternate order (e.g.
|
13
|
* maintenance theme).
|
14
|
*/
|
15
|
require_once DRUPAL_ROOT . '/includes/stream_wrappers.inc';
|
16
|
|
17
|
/**
|
18
|
* @defgroup file File interface
|
19
|
* @{
|
20
|
* Common file handling functions.
|
21
|
*
|
22
|
* Fields on the file object:
|
23
|
* - fid: File ID
|
24
|
* - uid: The {users}.uid of the user who is associated with the file.
|
25
|
* - filename: Name of the file with no path components. This may differ from
|
26
|
* the basename of the filepath if the file is renamed to avoid overwriting
|
27
|
* an existing file.
|
28
|
* - uri: URI of the file.
|
29
|
* - filemime: The file's MIME type.
|
30
|
* - filesize: The size of the file in bytes.
|
31
|
* - status: A bitmapped field indicating the status of the file. The first 8
|
32
|
* bits are reserved for Drupal core. The least significant bit indicates
|
33
|
* temporary (0) or permanent (1). Temporary files older than
|
34
|
* DRUPAL_MAXIMUM_TEMP_FILE_AGE will be removed during cron runs.
|
35
|
* - timestamp: UNIX timestamp for the date the file was added to the database.
|
36
|
*/
|
37
|
|
38
|
/**
|
39
|
* Flag used by file_prepare_directory() -- create directory if not present.
|
40
|
*/
|
41
|
define('FILE_CREATE_DIRECTORY', 1);
|
42
|
|
43
|
/**
|
44
|
* Flag used by file_prepare_directory() -- file permissions may be changed.
|
45
|
*/
|
46
|
define('FILE_MODIFY_PERMISSIONS', 2);
|
47
|
|
48
|
/**
|
49
|
* Flag for dealing with existing files: Appends number until name is unique.
|
50
|
*/
|
51
|
define('FILE_EXISTS_RENAME', 0);
|
52
|
|
53
|
/**
|
54
|
* Flag for dealing with existing files: Replace the existing file.
|
55
|
*/
|
56
|
define('FILE_EXISTS_REPLACE', 1);
|
57
|
|
58
|
/**
|
59
|
* Flag for dealing with existing files: Do nothing and return FALSE.
|
60
|
*/
|
61
|
define('FILE_EXISTS_ERROR', 2);
|
62
|
|
63
|
/**
|
64
|
* Indicates that the file is permanent and should not be deleted.
|
65
|
*
|
66
|
* Temporary files older than DRUPAL_MAXIMUM_TEMP_FILE_AGE will be removed
|
67
|
* during cron runs, but permanent files will not be removed during the file
|
68
|
* garbage collection process.
|
69
|
*/
|
70
|
define('FILE_STATUS_PERMANENT', 1);
|
71
|
|
72
|
/**
|
73
|
* Provides Drupal stream wrapper registry.
|
74
|
*
|
75
|
* A stream wrapper is an abstraction of a file system that allows Drupal to
|
76
|
* use the same set of methods to access both local files and remote resources.
|
77
|
*
|
78
|
* Provide a facility for managing and querying user-defined stream wrappers
|
79
|
* in PHP. PHP's internal stream_get_wrappers() doesn't return the class
|
80
|
* registered to handle a stream, which we need to be able to find the handler
|
81
|
* for class instantiation.
|
82
|
*
|
83
|
* If a module registers a scheme that is already registered with PHP, the
|
84
|
* existing scheme will be unregistered and replaced with the specified class.
|
85
|
*
|
86
|
* A stream is referenced as "scheme://target".
|
87
|
*
|
88
|
* The optional $filter parameter can be used to retrieve only the stream
|
89
|
* wrappers that are appropriate for particular usage. For example, this returns
|
90
|
* only stream wrappers that use local file storage:
|
91
|
* @code
|
92
|
* $local_stream_wrappers = file_get_stream_wrappers(STREAM_WRAPPERS_LOCAL);
|
93
|
* @endcode
|
94
|
*
|
95
|
* The $filter parameter can only filter to types containing a particular flag.
|
96
|
* In some cases, you may want to filter to types that do not contain a
|
97
|
* particular flag. For example, you may want to retrieve all stream wrappers
|
98
|
* that are not writable, or all stream wrappers that are not local. PHP's
|
99
|
* array_diff_key() function can be used to help with this. For example, this
|
100
|
* returns only stream wrappers that do not use local file storage:
|
101
|
* @code
|
102
|
* $remote_stream_wrappers = array_diff_key(file_get_stream_wrappers(STREAM_WRAPPERS_ALL), file_get_stream_wrappers(STREAM_WRAPPERS_LOCAL));
|
103
|
* @endcode
|
104
|
*
|
105
|
* @param $filter
|
106
|
* (Optional) Filters out all types except those with an on bit for each on
|
107
|
* bit in $filter. For example, if $filter is STREAM_WRAPPERS_WRITE_VISIBLE,
|
108
|
* which is equal to (STREAM_WRAPPERS_READ | STREAM_WRAPPERS_WRITE |
|
109
|
* STREAM_WRAPPERS_VISIBLE), then only stream wrappers with all three of these
|
110
|
* bits set are returned. Defaults to STREAM_WRAPPERS_ALL, which returns all
|
111
|
* registered stream wrappers.
|
112
|
*
|
113
|
* @return
|
114
|
* An array keyed by scheme, with values containing an array of information
|
115
|
* about the stream wrapper, as returned by hook_stream_wrappers(). If $filter
|
116
|
* is omitted or set to STREAM_WRAPPERS_ALL, the entire Drupal stream wrapper
|
117
|
* registry is returned. Otherwise only the stream wrappers whose 'type'
|
118
|
* bitmask has an on bit for each bit specified in $filter are returned.
|
119
|
*
|
120
|
* @see hook_stream_wrappers()
|
121
|
* @see hook_stream_wrappers_alter()
|
122
|
*/
|
123
|
function file_get_stream_wrappers($filter = STREAM_WRAPPERS_ALL) {
|
124
|
$wrappers_storage = &drupal_static(__FUNCTION__);
|
125
|
|
126
|
if (!isset($wrappers_storage)) {
|
127
|
$wrappers = module_invoke_all('stream_wrappers');
|
128
|
foreach ($wrappers as $scheme => $info) {
|
129
|
// Add defaults.
|
130
|
$wrappers[$scheme] += array('type' => STREAM_WRAPPERS_NORMAL);
|
131
|
}
|
132
|
drupal_alter('stream_wrappers', $wrappers);
|
133
|
$existing = stream_get_wrappers();
|
134
|
foreach ($wrappers as $scheme => $info) {
|
135
|
// We only register classes that implement our interface.
|
136
|
if (in_array('DrupalStreamWrapperInterface', class_implements($info['class']), TRUE)) {
|
137
|
// Record whether we are overriding an existing scheme.
|
138
|
if (in_array($scheme, $existing, TRUE)) {
|
139
|
$wrappers[$scheme]['override'] = TRUE;
|
140
|
stream_wrapper_unregister($scheme);
|
141
|
}
|
142
|
else {
|
143
|
$wrappers[$scheme]['override'] = FALSE;
|
144
|
}
|
145
|
if (($info['type'] & STREAM_WRAPPERS_LOCAL) == STREAM_WRAPPERS_LOCAL) {
|
146
|
stream_wrapper_register($scheme, $info['class']);
|
147
|
}
|
148
|
else {
|
149
|
stream_wrapper_register($scheme, $info['class'], STREAM_IS_URL);
|
150
|
}
|
151
|
}
|
152
|
// Pre-populate the static cache with the filters most typically used.
|
153
|
$wrappers_storage[STREAM_WRAPPERS_ALL][$scheme] = $wrappers[$scheme];
|
154
|
if (($info['type'] & STREAM_WRAPPERS_WRITE_VISIBLE) == STREAM_WRAPPERS_WRITE_VISIBLE) {
|
155
|
$wrappers_storage[STREAM_WRAPPERS_WRITE_VISIBLE][$scheme] = $wrappers[$scheme];
|
156
|
}
|
157
|
}
|
158
|
}
|
159
|
|
160
|
if (!isset($wrappers_storage[$filter])) {
|
161
|
$wrappers_storage[$filter] = array();
|
162
|
foreach ($wrappers_storage[STREAM_WRAPPERS_ALL] as $scheme => $info) {
|
163
|
// Bit-wise filter.
|
164
|
if (($info['type'] & $filter) == $filter) {
|
165
|
$wrappers_storage[$filter][$scheme] = $info;
|
166
|
}
|
167
|
}
|
168
|
}
|
169
|
|
170
|
return $wrappers_storage[$filter];
|
171
|
}
|
172
|
|
173
|
/**
|
174
|
* Returns the stream wrapper class name for a given scheme.
|
175
|
*
|
176
|
* @param $scheme
|
177
|
* Stream scheme.
|
178
|
*
|
179
|
* @return
|
180
|
* Return string if a scheme has a registered handler, or FALSE.
|
181
|
*/
|
182
|
function file_stream_wrapper_get_class($scheme) {
|
183
|
$wrappers = file_get_stream_wrappers();
|
184
|
return empty($wrappers[$scheme]) ? FALSE : $wrappers[$scheme]['class'];
|
185
|
}
|
186
|
|
187
|
/**
|
188
|
* Returns the scheme of a URI (e.g. a stream).
|
189
|
*
|
190
|
* @param $uri
|
191
|
* A stream, referenced as "scheme://target".
|
192
|
*
|
193
|
* @return
|
194
|
* A string containing the name of the scheme, or FALSE if none. For example,
|
195
|
* the URI "public://example.txt" would return "public".
|
196
|
*
|
197
|
* @see file_uri_target()
|
198
|
*/
|
199
|
function file_uri_scheme($uri) {
|
200
|
$position = strpos($uri, '://');
|
201
|
return $position ? substr($uri, 0, $position) : FALSE;
|
202
|
}
|
203
|
|
204
|
/**
|
205
|
* Checks that the scheme of a stream URI is valid.
|
206
|
*
|
207
|
* Confirms that there is a registered stream handler for the provided scheme
|
208
|
* and that it is callable. This is useful if you want to confirm a valid
|
209
|
* scheme without creating a new instance of the registered handler.
|
210
|
*
|
211
|
* @param $scheme
|
212
|
* A URI scheme, a stream is referenced as "scheme://target".
|
213
|
*
|
214
|
* @return
|
215
|
* Returns TRUE if the string is the name of a validated stream,
|
216
|
* or FALSE if the scheme does not have a registered handler.
|
217
|
*/
|
218
|
function file_stream_wrapper_valid_scheme($scheme) {
|
219
|
// Does the scheme have a registered handler that is callable?
|
220
|
$class = file_stream_wrapper_get_class($scheme);
|
221
|
if (class_exists($class)) {
|
222
|
return TRUE;
|
223
|
}
|
224
|
else {
|
225
|
return FALSE;
|
226
|
}
|
227
|
}
|
228
|
|
229
|
|
230
|
/**
|
231
|
* Returns the part of a URI after the schema.
|
232
|
*
|
233
|
* @param $uri
|
234
|
* A stream, referenced as "scheme://target".
|
235
|
*
|
236
|
* @return
|
237
|
* A string containing the target (path), or FALSE if none.
|
238
|
* For example, the URI "public://sample/test.txt" would return
|
239
|
* "sample/test.txt".
|
240
|
*
|
241
|
* @see file_uri_scheme()
|
242
|
*/
|
243
|
function file_uri_target($uri) {
|
244
|
$data = explode('://', $uri, 2);
|
245
|
|
246
|
// Remove erroneous leading or trailing, forward-slashes and backslashes.
|
247
|
return count($data) == 2 ? trim($data[1], '\/') : FALSE;
|
248
|
}
|
249
|
|
250
|
/**
|
251
|
* Gets the default file stream implementation.
|
252
|
*
|
253
|
* @return
|
254
|
* 'public', 'private' or any other file scheme defined as the default.
|
255
|
*/
|
256
|
function file_default_scheme() {
|
257
|
return variable_get('file_default_scheme', 'public');
|
258
|
}
|
259
|
|
260
|
/**
|
261
|
* Normalizes a URI by making it syntactically correct.
|
262
|
*
|
263
|
* A stream is referenced as "scheme://target".
|
264
|
*
|
265
|
* The following actions are taken:
|
266
|
* - Remove trailing slashes from target
|
267
|
* - Trim erroneous leading slashes from target. e.g. ":///" becomes "://".
|
268
|
*
|
269
|
* @param $uri
|
270
|
* String reference containing the URI to normalize.
|
271
|
*
|
272
|
* @return
|
273
|
* The normalized URI.
|
274
|
*/
|
275
|
function file_stream_wrapper_uri_normalize($uri) {
|
276
|
// Inline file_uri_scheme() function call for performance reasons.
|
277
|
$position = strpos($uri, '://');
|
278
|
$scheme = $position ? substr($uri, 0, $position) : FALSE;
|
279
|
|
280
|
if ($scheme && file_stream_wrapper_valid_scheme($scheme)) {
|
281
|
$target = file_uri_target($uri);
|
282
|
|
283
|
if ($target !== FALSE) {
|
284
|
$uri = $scheme . '://' . $target;
|
285
|
}
|
286
|
}
|
287
|
return $uri;
|
288
|
}
|
289
|
|
290
|
/**
|
291
|
* Returns a reference to the stream wrapper class responsible for a given URI.
|
292
|
*
|
293
|
* The scheme determines the stream wrapper class that should be
|
294
|
* used by consulting the stream wrapper registry.
|
295
|
*
|
296
|
* @param $uri
|
297
|
* A stream, referenced as "scheme://target".
|
298
|
*
|
299
|
* @return
|
300
|
* Returns a new stream wrapper object appropriate for the given URI or FALSE
|
301
|
* if no registered handler could be found. For example, a URI of
|
302
|
* "private://example.txt" would return a new private stream wrapper object
|
303
|
* (DrupalPrivateStreamWrapper).
|
304
|
*/
|
305
|
function file_stream_wrapper_get_instance_by_uri($uri) {
|
306
|
$scheme = file_uri_scheme($uri);
|
307
|
$class = file_stream_wrapper_get_class($scheme);
|
308
|
if (class_exists($class)) {
|
309
|
$instance = new $class();
|
310
|
$instance->setUri($uri);
|
311
|
return $instance;
|
312
|
}
|
313
|
else {
|
314
|
return FALSE;
|
315
|
}
|
316
|
}
|
317
|
|
318
|
/**
|
319
|
* Returns a reference to the stream wrapper class responsible for a scheme.
|
320
|
*
|
321
|
* This helper method returns a stream instance using a scheme. That is, the
|
322
|
* passed string does not contain a "://". For example, "public" is a scheme
|
323
|
* but "public://" is a URI (stream). This is because the later contains both
|
324
|
* a scheme and target despite target being empty.
|
325
|
*
|
326
|
* Note: the instance URI will be initialized to "scheme://" so that you can
|
327
|
* make the customary method calls as if you had retrieved an instance by URI.
|
328
|
*
|
329
|
* @param $scheme
|
330
|
* If the stream was "public://target", "public" would be the scheme.
|
331
|
*
|
332
|
* @return
|
333
|
* Returns a new stream wrapper object appropriate for the given $scheme.
|
334
|
* For example, for the public scheme a stream wrapper object
|
335
|
* (DrupalPublicStreamWrapper).
|
336
|
* FALSE is returned if no registered handler could be found.
|
337
|
*/
|
338
|
function file_stream_wrapper_get_instance_by_scheme($scheme) {
|
339
|
$class = file_stream_wrapper_get_class($scheme);
|
340
|
if (class_exists($class)) {
|
341
|
$instance = new $class();
|
342
|
$instance->setUri($scheme . '://');
|
343
|
return $instance;
|
344
|
}
|
345
|
else {
|
346
|
return FALSE;
|
347
|
}
|
348
|
}
|
349
|
|
350
|
/**
|
351
|
* Creates a web-accessible URL for a stream to an external or local file.
|
352
|
*
|
353
|
* Compatibility: normal paths and stream wrappers.
|
354
|
*
|
355
|
* There are two kinds of local files:
|
356
|
* - "managed files", i.e. those stored by a Drupal-compatible stream wrapper.
|
357
|
* These are files that have either been uploaded by users or were generated
|
358
|
* automatically (for example through CSS aggregation).
|
359
|
* - "shipped files", i.e. those outside of the files directory, which ship as
|
360
|
* part of Drupal core or contributed modules or themes.
|
361
|
*
|
362
|
* @param $uri
|
363
|
* The URI to a file for which we need an external URL, or the path to a
|
364
|
* shipped file.
|
365
|
*
|
366
|
* @return
|
367
|
* A string containing a URL that may be used to access the file.
|
368
|
* If the provided string already contains a preceding 'http', 'https', or
|
369
|
* '/', nothing is done and the same string is returned. If a stream wrapper
|
370
|
* could not be found to generate an external URL, then FALSE is returned.
|
371
|
*
|
372
|
* @see http://drupal.org/node/515192
|
373
|
*/
|
374
|
function file_create_url($uri) {
|
375
|
// Allow the URI to be altered, e.g. to serve a file from a CDN or static
|
376
|
// file server.
|
377
|
drupal_alter('file_url', $uri);
|
378
|
|
379
|
$scheme = file_uri_scheme($uri);
|
380
|
|
381
|
if (!$scheme) {
|
382
|
// Allow for:
|
383
|
// - root-relative URIs (e.g. /foo.jpg in http://example.com/foo.jpg)
|
384
|
// - protocol-relative URIs (e.g. //bar.jpg, which is expanded to
|
385
|
// http://example.com/bar.jpg by the browser when viewing a page over
|
386
|
// HTTP and to https://example.com/bar.jpg when viewing a HTTPS page)
|
387
|
// Both types of relative URIs are characterized by a leading slash, hence
|
388
|
// we can use a single check.
|
389
|
if (drupal_substr($uri, 0, 1) == '/') {
|
390
|
return $uri;
|
391
|
}
|
392
|
else {
|
393
|
// If this is not a properly formatted stream, then it is a shipped file.
|
394
|
// Therefore, return the urlencoded URI with the base URL prepended.
|
395
|
return $GLOBALS['base_url'] . '/' . drupal_encode_path($uri);
|
396
|
}
|
397
|
}
|
398
|
elseif ($scheme == 'http' || $scheme == 'https') {
|
399
|
// Check for HTTP so that we don't have to implement getExternalUrl() for
|
400
|
// the HTTP wrapper.
|
401
|
return $uri;
|
402
|
}
|
403
|
else {
|
404
|
// Attempt to return an external URL using the appropriate wrapper.
|
405
|
if ($wrapper = file_stream_wrapper_get_instance_by_uri($uri)) {
|
406
|
return $wrapper->getExternalUrl();
|
407
|
}
|
408
|
else {
|
409
|
return FALSE;
|
410
|
}
|
411
|
}
|
412
|
}
|
413
|
|
414
|
/**
|
415
|
* Checks that the directory exists and is writable.
|
416
|
*
|
417
|
* Directories need to have execute permissions to be considered a directory by
|
418
|
* FTP servers, etc.
|
419
|
*
|
420
|
* @param $directory
|
421
|
* A string reference containing the name of a directory path or URI. A
|
422
|
* trailing slash will be trimmed from a path.
|
423
|
* @param $options
|
424
|
* A bitmask to indicate if the directory should be created if it does
|
425
|
* not exist (FILE_CREATE_DIRECTORY) or made writable if it is read-only
|
426
|
* (FILE_MODIFY_PERMISSIONS).
|
427
|
*
|
428
|
* @return
|
429
|
* TRUE if the directory exists (or was created) and is writable. FALSE
|
430
|
* otherwise.
|
431
|
*/
|
432
|
function file_prepare_directory(&$directory, $options = FILE_MODIFY_PERMISSIONS) {
|
433
|
if (!file_stream_wrapper_valid_scheme(file_uri_scheme($directory))) {
|
434
|
// Only trim if we're not dealing with a stream.
|
435
|
$directory = rtrim($directory, '/\\');
|
436
|
}
|
437
|
|
438
|
// Check if directory exists.
|
439
|
if (!is_dir($directory)) {
|
440
|
// Let mkdir() recursively create directories and use the default directory
|
441
|
// permissions.
|
442
|
if (($options & FILE_CREATE_DIRECTORY) && @drupal_mkdir($directory, NULL, TRUE)) {
|
443
|
return drupal_chmod($directory);
|
444
|
}
|
445
|
return FALSE;
|
446
|
}
|
447
|
// The directory exists, so check to see if it is writable.
|
448
|
$writable = is_writable($directory);
|
449
|
if (!$writable && ($options & FILE_MODIFY_PERMISSIONS)) {
|
450
|
return drupal_chmod($directory);
|
451
|
}
|
452
|
|
453
|
return $writable;
|
454
|
}
|
455
|
|
456
|
/**
|
457
|
* Creates a .htaccess file in each Drupal files directory if it is missing.
|
458
|
*/
|
459
|
function file_ensure_htaccess() {
|
460
|
file_create_htaccess('public://', FALSE);
|
461
|
if (variable_get('file_private_path', FALSE)) {
|
462
|
file_create_htaccess('private://', TRUE);
|
463
|
}
|
464
|
file_create_htaccess('temporary://', TRUE);
|
465
|
}
|
466
|
|
467
|
/**
|
468
|
* Creates a .htaccess file in the given directory.
|
469
|
*
|
470
|
* @param $directory
|
471
|
* The directory.
|
472
|
* @param $private
|
473
|
* FALSE indicates that $directory should be an open and public directory.
|
474
|
* The default is TRUE which indicates a private and protected directory.
|
475
|
* @param $force_overwrite
|
476
|
* Set to TRUE to attempt to overwrite the existing .htaccess file if one is
|
477
|
* already present. Defaults to FALSE.
|
478
|
*/
|
479
|
function file_create_htaccess($directory, $private = TRUE, $force_overwrite = FALSE) {
|
480
|
if (file_uri_scheme($directory)) {
|
481
|
$directory = file_stream_wrapper_uri_normalize($directory);
|
482
|
}
|
483
|
else {
|
484
|
$directory = rtrim($directory, '/\\');
|
485
|
}
|
486
|
$htaccess_path = $directory . '/.htaccess';
|
487
|
|
488
|
if (file_exists($htaccess_path) && !$force_overwrite) {
|
489
|
// Short circuit if the .htaccess file already exists.
|
490
|
return;
|
491
|
}
|
492
|
|
493
|
$htaccess_lines = file_htaccess_lines($private);
|
494
|
|
495
|
// Write the .htaccess file.
|
496
|
if (file_put_contents($htaccess_path, $htaccess_lines)) {
|
497
|
drupal_chmod($htaccess_path, 0444);
|
498
|
}
|
499
|
else {
|
500
|
$variables = array('%directory' => $directory, '!htaccess' => '<br />' . nl2br(check_plain($htaccess_lines)));
|
501
|
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);
|
502
|
}
|
503
|
}
|
504
|
|
505
|
/**
|
506
|
* Returns the standard .htaccess lines that Drupal writes to file directories.
|
507
|
*
|
508
|
* @param $private
|
509
|
* (Optional) Set to FALSE to return the .htaccess lines for an open and
|
510
|
* public directory. The default is TRUE, which returns the .htaccess lines
|
511
|
* for a private and protected directory.
|
512
|
*
|
513
|
* @return
|
514
|
* A string representing the desired contents of the .htaccess file.
|
515
|
*
|
516
|
* @see file_create_htaccess()
|
517
|
*/
|
518
|
function file_htaccess_lines($private = TRUE) {
|
519
|
$lines = <<<EOF
|
520
|
# Turn off all options we don't need.
|
521
|
Options None
|
522
|
Options +FollowSymLinks
|
523
|
|
524
|
# Set the catch-all handler to prevent scripts from being executed.
|
525
|
SetHandler Drupal_Security_Do_Not_Remove_See_SA_2006_006
|
526
|
<Files *>
|
527
|
# Override the handler again if we're run later in the evaluation list.
|
528
|
SetHandler Drupal_Security_Do_Not_Remove_See_SA_2013_003
|
529
|
</Files>
|
530
|
|
531
|
# If we know how to do it safely, disable the PHP engine entirely.
|
532
|
<IfModule mod_php5.c>
|
533
|
php_flag engine off
|
534
|
</IfModule>
|
535
|
EOF;
|
536
|
|
537
|
if ($private) {
|
538
|
$lines = <<<EOF
|
539
|
# Deny all requests from Apache 2.4+.
|
540
|
<IfModule mod_authz_core.c>
|
541
|
Require all denied
|
542
|
</IfModule>
|
543
|
|
544
|
# Deny all requests from Apache 2.0-2.2.
|
545
|
<IfModule !mod_authz_core.c>
|
546
|
Deny from all
|
547
|
</IfModule>
|
548
|
EOF
|
549
|
. "\n\n" . $lines;
|
550
|
}
|
551
|
|
552
|
return $lines;
|
553
|
}
|
554
|
|
555
|
/**
|
556
|
* Loads file objects from the database.
|
557
|
*
|
558
|
* @param $fids
|
559
|
* An array of file IDs.
|
560
|
* @param $conditions
|
561
|
* (deprecated) An associative array of conditions on the {file_managed}
|
562
|
* table, where the keys are the database fields and the values are the
|
563
|
* values those fields must have. Instead, it is preferable to use
|
564
|
* EntityFieldQuery to retrieve a list of entity IDs loadable by
|
565
|
* this function.
|
566
|
*
|
567
|
* @return
|
568
|
* An array of file objects, indexed by fid.
|
569
|
*
|
570
|
* @todo Remove $conditions in Drupal 8.
|
571
|
*
|
572
|
* @see hook_file_load()
|
573
|
* @see file_load()
|
574
|
* @see entity_load()
|
575
|
* @see EntityFieldQuery
|
576
|
*/
|
577
|
function file_load_multiple($fids = array(), $conditions = array()) {
|
578
|
return entity_load('file', $fids, $conditions);
|
579
|
}
|
580
|
|
581
|
/**
|
582
|
* Loads a single file object from the database.
|
583
|
*
|
584
|
* @param $fid
|
585
|
* A file ID.
|
586
|
*
|
587
|
* @return
|
588
|
* An object representing the file, or FALSE if the file was not found.
|
589
|
*
|
590
|
* @see hook_file_load()
|
591
|
* @see file_load_multiple()
|
592
|
*/
|
593
|
function file_load($fid) {
|
594
|
$files = file_load_multiple(array($fid), array());
|
595
|
return reset($files);
|
596
|
}
|
597
|
|
598
|
/**
|
599
|
* Saves a file object to the database.
|
600
|
*
|
601
|
* If the $file->fid is not set a new record will be added.
|
602
|
*
|
603
|
* @param $file
|
604
|
* A file object returned by file_load().
|
605
|
*
|
606
|
* @return
|
607
|
* The updated file object.
|
608
|
*
|
609
|
* @see hook_file_insert()
|
610
|
* @see hook_file_update()
|
611
|
*/
|
612
|
function file_save(stdClass $file) {
|
613
|
$file->timestamp = REQUEST_TIME;
|
614
|
$file->filesize = filesize($file->uri);
|
615
|
|
616
|
// Load the stored entity, if any.
|
617
|
if (!empty($file->fid) && !isset($file->original)) {
|
618
|
$file->original = entity_load_unchanged('file', $file->fid);
|
619
|
}
|
620
|
|
621
|
module_invoke_all('file_presave', $file);
|
622
|
module_invoke_all('entity_presave', $file, 'file');
|
623
|
|
624
|
if (empty($file->fid)) {
|
625
|
drupal_write_record('file_managed', $file);
|
626
|
// Inform modules about the newly added file.
|
627
|
module_invoke_all('file_insert', $file);
|
628
|
module_invoke_all('entity_insert', $file, 'file');
|
629
|
}
|
630
|
else {
|
631
|
drupal_write_record('file_managed', $file, 'fid');
|
632
|
// Inform modules that the file has been updated.
|
633
|
module_invoke_all('file_update', $file);
|
634
|
module_invoke_all('entity_update', $file, 'file');
|
635
|
}
|
636
|
|
637
|
// Clear internal properties.
|
638
|
unset($file->original);
|
639
|
// Clear the static loading cache.
|
640
|
entity_get_controller('file')->resetCache(array($file->fid));
|
641
|
|
642
|
return $file;
|
643
|
}
|
644
|
|
645
|
/**
|
646
|
* Determines where a file is used.
|
647
|
*
|
648
|
* @param $file
|
649
|
* A file object.
|
650
|
*
|
651
|
* @return
|
652
|
* A nested array with usage data. The first level is keyed by module name,
|
653
|
* the second by object type and the third by the object id. The value
|
654
|
* of the third level contains the usage count.
|
655
|
*
|
656
|
* @see file_usage_add()
|
657
|
* @see file_usage_delete()
|
658
|
*/
|
659
|
function file_usage_list(stdClass $file) {
|
660
|
$result = db_select('file_usage', 'f')
|
661
|
->fields('f', array('module', 'type', 'id', 'count'))
|
662
|
->condition('fid', $file->fid)
|
663
|
->condition('count', 0, '>')
|
664
|
->execute();
|
665
|
$references = array();
|
666
|
foreach ($result as $usage) {
|
667
|
$references[$usage->module][$usage->type][$usage->id] = $usage->count;
|
668
|
}
|
669
|
return $references;
|
670
|
}
|
671
|
|
672
|
/**
|
673
|
* Records that a module is using a file.
|
674
|
*
|
675
|
* This usage information will be queried during file_delete() to ensure that
|
676
|
* a file is not in use before it is physically removed from disk.
|
677
|
*
|
678
|
* Examples:
|
679
|
* - A module that associates files with nodes, so $type would be
|
680
|
* 'node' and $id would be the node's nid. Files for all revisions are stored
|
681
|
* within a single nid.
|
682
|
* - The User module associates an image with a user, so $type would be 'user'
|
683
|
* and the $id would be the user's uid.
|
684
|
*
|
685
|
* @param $file
|
686
|
* A file object.
|
687
|
* @param $module
|
688
|
* The name of the module using the file.
|
689
|
* @param $type
|
690
|
* The type of the object that contains the referenced file.
|
691
|
* @param $id
|
692
|
* The unique, numeric ID of the object containing the referenced file.
|
693
|
* @param $count
|
694
|
* (optional) The number of references to add to the object. Defaults to 1.
|
695
|
*
|
696
|
* @see file_usage_list()
|
697
|
* @see file_usage_delete()
|
698
|
*/
|
699
|
function file_usage_add(stdClass $file, $module, $type, $id, $count = 1) {
|
700
|
db_merge('file_usage')
|
701
|
->key(array(
|
702
|
'fid' => $file->fid,
|
703
|
'module' => $module,
|
704
|
'type' => $type,
|
705
|
'id' => $id,
|
706
|
))
|
707
|
->fields(array('count' => $count))
|
708
|
->expression('count', 'count + :count', array(':count' => $count))
|
709
|
->execute();
|
710
|
}
|
711
|
|
712
|
/**
|
713
|
* Removes a record to indicate that a module is no longer using a file.
|
714
|
*
|
715
|
* The file_delete() function is typically called after removing a file usage
|
716
|
* to remove the record from the file_managed table and delete the file itself.
|
717
|
*
|
718
|
* @param $file
|
719
|
* A file object.
|
720
|
* @param $module
|
721
|
* The name of the module using the file.
|
722
|
* @param $type
|
723
|
* (optional) The type of the object that contains the referenced file. May
|
724
|
* be omitted if all module references to a file are being deleted.
|
725
|
* @param $id
|
726
|
* (optional) The unique, numeric ID of the object containing the referenced
|
727
|
* file. May be omitted if all module references to a file are being deleted.
|
728
|
* @param $count
|
729
|
* (optional) The number of references to delete from the object. Defaults to
|
730
|
* 1. 0 may be specified to delete all references to the file within a
|
731
|
* specific object.
|
732
|
*
|
733
|
* @see file_usage_add()
|
734
|
* @see file_usage_list()
|
735
|
* @see file_delete()
|
736
|
*/
|
737
|
function file_usage_delete(stdClass $file, $module, $type = NULL, $id = NULL, $count = 1) {
|
738
|
// Delete rows that have a exact or less value to prevent empty rows.
|
739
|
$query = db_delete('file_usage')
|
740
|
->condition('module', $module)
|
741
|
->condition('fid', $file->fid);
|
742
|
if ($type && $id) {
|
743
|
$query
|
744
|
->condition('type', $type)
|
745
|
->condition('id', $id);
|
746
|
}
|
747
|
if ($count) {
|
748
|
$query->condition('count', $count, '<=');
|
749
|
}
|
750
|
$result = $query->execute();
|
751
|
|
752
|
// If the row has more than the specified count decrement it by that number.
|
753
|
if (!$result && $count > 0) {
|
754
|
$query = db_update('file_usage')
|
755
|
->condition('module', $module)
|
756
|
->condition('fid', $file->fid);
|
757
|
if ($type && $id) {
|
758
|
$query
|
759
|
->condition('type', $type)
|
760
|
->condition('id', $id);
|
761
|
}
|
762
|
$query->expression('count', 'count - :count', array(':count' => $count));
|
763
|
$query->execute();
|
764
|
}
|
765
|
}
|
766
|
|
767
|
/**
|
768
|
* Copies a file to a new location and adds a file record to the database.
|
769
|
*
|
770
|
* This function should be used when manipulating files that have records
|
771
|
* stored in the database. This is a powerful function that in many ways
|
772
|
* performs like an advanced version of copy().
|
773
|
* - Checks if $source and $destination are valid and readable/writable.
|
774
|
* - If file already exists in $destination either the call will error out,
|
775
|
* replace the file or rename the file based on the $replace parameter.
|
776
|
* - If the $source and $destination are equal, the behavior depends on the
|
777
|
* $replace parameter. FILE_EXISTS_REPLACE will error out. FILE_EXISTS_RENAME
|
778
|
* will rename the file until the $destination is unique.
|
779
|
* - Adds the new file to the files database. If the source file is a
|
780
|
* temporary file, the resulting file will also be a temporary file. See
|
781
|
* file_save_upload() for details on temporary files.
|
782
|
*
|
783
|
* @param $source
|
784
|
* A file object.
|
785
|
* @param $destination
|
786
|
* A string containing the destination that $source should be copied to.
|
787
|
* This must be a stream wrapper URI.
|
788
|
* @param $replace
|
789
|
* Replace behavior when the destination file already exists:
|
790
|
* - FILE_EXISTS_REPLACE - Replace the existing file. If a managed file with
|
791
|
* the destination name exists then its database entry will be updated. If
|
792
|
* no database entry is found then a new one will be created.
|
793
|
* - FILE_EXISTS_RENAME - Append _{incrementing number} until the filename is
|
794
|
* unique.
|
795
|
* - FILE_EXISTS_ERROR - Do nothing and return FALSE.
|
796
|
*
|
797
|
* @return
|
798
|
* File object if the copy is successful, or FALSE in the event of an error.
|
799
|
*
|
800
|
* @see file_unmanaged_copy()
|
801
|
* @see hook_file_copy()
|
802
|
*/
|
803
|
function file_copy(stdClass $source, $destination = NULL, $replace = FILE_EXISTS_RENAME) {
|
804
|
if (!file_valid_uri($destination)) {
|
805
|
if (($realpath = drupal_realpath($source->uri)) !== FALSE) {
|
806
|
watchdog('file', 'File %file (%realpath) could not be copied, because the destination %destination is invalid. This is often caused by improper use of file_copy() or a missing stream wrapper.', array('%file' => $source->uri, '%realpath' => $realpath, '%destination' => $destination));
|
807
|
}
|
808
|
else {
|
809
|
watchdog('file', 'File %file could not be copied, because the destination %destination is invalid. This is often caused by improper use of file_copy() or a missing stream wrapper.', array('%file' => $source->uri, '%destination' => $destination));
|
810
|
}
|
811
|
drupal_set_message(t('The specified file %file could not be copied, because the destination is invalid. More information is available in the system log.', array('%file' => $source->uri)), 'error');
|
812
|
return FALSE;
|
813
|
}
|
814
|
|
815
|
if ($uri = file_unmanaged_copy($source->uri, $destination, $replace)) {
|
816
|
$file = clone $source;
|
817
|
$file->fid = NULL;
|
818
|
$file->uri = $uri;
|
819
|
$file->filename = drupal_basename($uri);
|
820
|
// If we are replacing an existing file re-use its database record.
|
821
|
if ($replace == FILE_EXISTS_REPLACE) {
|
822
|
$existing_files = file_load_multiple(array(), array('uri' => $uri));
|
823
|
if (count($existing_files)) {
|
824
|
$existing = reset($existing_files);
|
825
|
$file->fid = $existing->fid;
|
826
|
$file->filename = $existing->filename;
|
827
|
}
|
828
|
}
|
829
|
// If we are renaming around an existing file (rather than a directory),
|
830
|
// use its basename for the filename.
|
831
|
elseif ($replace == FILE_EXISTS_RENAME && is_file($destination)) {
|
832
|
$file->filename = drupal_basename($destination);
|
833
|
}
|
834
|
|
835
|
$file = file_save($file);
|
836
|
|
837
|
// Inform modules that the file has been copied.
|
838
|
module_invoke_all('file_copy', $file, $source);
|
839
|
|
840
|
return $file;
|
841
|
}
|
842
|
return FALSE;
|
843
|
}
|
844
|
|
845
|
/**
|
846
|
* Determines whether the URI has a valid scheme for file API operations.
|
847
|
*
|
848
|
* There must be a scheme and it must be a Drupal-provided scheme like
|
849
|
* 'public', 'private', 'temporary', or an extension provided with
|
850
|
* hook_stream_wrappers().
|
851
|
*
|
852
|
* @param $uri
|
853
|
* The URI to be tested.
|
854
|
*
|
855
|
* @return
|
856
|
* TRUE if the URI is allowed.
|
857
|
*/
|
858
|
function file_valid_uri($uri) {
|
859
|
// Assert that the URI has an allowed scheme. Barepaths are not allowed.
|
860
|
$uri_scheme = file_uri_scheme($uri);
|
861
|
if (empty($uri_scheme) || !file_stream_wrapper_valid_scheme($uri_scheme)) {
|
862
|
return FALSE;
|
863
|
}
|
864
|
return TRUE;
|
865
|
}
|
866
|
|
867
|
/**
|
868
|
* Copies a file to a new location without invoking the file API.
|
869
|
*
|
870
|
* This is a powerful function that in many ways performs like an advanced
|
871
|
* version of copy().
|
872
|
* - Checks if $source and $destination are valid and readable/writable.
|
873
|
* - If file already exists in $destination either the call will error out,
|
874
|
* replace the file or rename the file based on the $replace parameter.
|
875
|
* - If the $source and $destination are equal, the behavior depends on the
|
876
|
* $replace parameter. FILE_EXISTS_REPLACE will error out. FILE_EXISTS_RENAME
|
877
|
* will rename the file until the $destination is unique.
|
878
|
* - Provides a fallback using realpaths if the move fails using stream
|
879
|
* wrappers. This can occur because PHP's copy() function does not properly
|
880
|
* support streams if safe_mode or open_basedir are enabled. See
|
881
|
* https://bugs.php.net/bug.php?id=60456
|
882
|
*
|
883
|
* @param $source
|
884
|
* A string specifying the filepath or URI of the source file.
|
885
|
* @param $destination
|
886
|
* A URI containing the destination that $source should be copied to. The
|
887
|
* URI may be a bare filepath (without a scheme). If this value is omitted,
|
888
|
* Drupal's default files scheme will be used, usually "public://".
|
889
|
* @param $replace
|
890
|
* Replace behavior when the destination file already exists:
|
891
|
* - FILE_EXISTS_REPLACE - Replace the existing file.
|
892
|
* - FILE_EXISTS_RENAME - Append _{incrementing number} until the filename is
|
893
|
* unique.
|
894
|
* - FILE_EXISTS_ERROR - Do nothing and return FALSE.
|
895
|
*
|
896
|
* @return
|
897
|
* The path to the new file, or FALSE in the event of an error.
|
898
|
*
|
899
|
* @see file_copy()
|
900
|
*/
|
901
|
function file_unmanaged_copy($source, $destination = NULL, $replace = FILE_EXISTS_RENAME) {
|
902
|
$original_source = $source;
|
903
|
|
904
|
// Assert that the source file actually exists.
|
905
|
if (!file_exists($source)) {
|
906
|
// @todo Replace drupal_set_message() calls with exceptions instead.
|
907
|
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');
|
908
|
if (($realpath = drupal_realpath($original_source)) !== FALSE) {
|
909
|
watchdog('file', 'File %file (%realpath) could not be copied because it does not exist.', array('%file' => $original_source, '%realpath' => $realpath));
|
910
|
}
|
911
|
else {
|
912
|
watchdog('file', 'File %file could not be copied because it does not exist.', array('%file' => $original_source));
|
913
|
}
|
914
|
return FALSE;
|
915
|
}
|
916
|
|
917
|
// Build a destination URI if necessary.
|
918
|
if (!isset($destination)) {
|
919
|
$destination = file_build_uri(drupal_basename($source));
|
920
|
}
|
921
|
|
922
|
|
923
|
// Prepare the destination directory.
|
924
|
if (file_prepare_directory($destination)) {
|
925
|
// The destination is already a directory, so append the source basename.
|
926
|
$destination = file_stream_wrapper_uri_normalize($destination . '/' . drupal_basename($source));
|
927
|
}
|
928
|
else {
|
929
|
// Perhaps $destination is a dir/file?
|
930
|
$dirname = drupal_dirname($destination);
|
931
|
if (!file_prepare_directory($dirname)) {
|
932
|
// The destination is not valid.
|
933
|
watchdog('file', 'File %file could not be copied, because the destination directory %destination is not configured correctly.', array('%file' => $original_source, '%destination' => $dirname));
|
934
|
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');
|
935
|
return FALSE;
|
936
|
}
|
937
|
}
|
938
|
|
939
|
// Determine whether we can perform this operation based on overwrite rules.
|
940
|
$destination = file_destination($destination, $replace);
|
941
|
if ($destination === FALSE) {
|
942
|
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');
|
943
|
watchdog('file', 'File %file could not be copied because a file by that name already exists in the destination directory (%directory)', array('%file' => $original_source, '%directory' => $destination));
|
944
|
return FALSE;
|
945
|
}
|
946
|
|
947
|
// Assert that the source and destination filenames are not the same.
|
948
|
$real_source = drupal_realpath($source);
|
949
|
$real_destination = drupal_realpath($destination);
|
950
|
if ($source == $destination || ($real_source !== FALSE) && ($real_source == $real_destination)) {
|
951
|
drupal_set_message(t('The specified file %file was not copied because it would overwrite itself.', array('%file' => $source)), 'error');
|
952
|
watchdog('file', 'File %file could not be copied because it would overwrite itself.', array('%file' => $source));
|
953
|
return FALSE;
|
954
|
}
|
955
|
// Make sure the .htaccess files are present.
|
956
|
file_ensure_htaccess();
|
957
|
// Perform the copy operation.
|
958
|
if (!@copy($source, $destination)) {
|
959
|
// If the copy failed and realpaths exist, retry the operation using them
|
960
|
// instead.
|
961
|
if ($real_source === FALSE || $real_destination === FALSE || !@copy($real_source, $real_destination)) {
|
962
|
watchdog('file', 'The specified file %file could not be copied to %destination.', array('%file' => $source, '%destination' => $destination), WATCHDOG_ERROR);
|
963
|
return FALSE;
|
964
|
}
|
965
|
}
|
966
|
|
967
|
// Set the permissions on the new file.
|
968
|
drupal_chmod($destination);
|
969
|
|
970
|
return $destination;
|
971
|
}
|
972
|
|
973
|
/**
|
974
|
* Constructs a URI to Drupal's default files location given a relative path.
|
975
|
*/
|
976
|
function file_build_uri($path) {
|
977
|
$uri = file_default_scheme() . '://' . $path;
|
978
|
return file_stream_wrapper_uri_normalize($uri);
|
979
|
}
|
980
|
|
981
|
/**
|
982
|
* Determines the destination path for a file.
|
983
|
*
|
984
|
* @param $destination
|
985
|
* A string specifying the desired final URI or filepath.
|
986
|
* @param $replace
|
987
|
* Replace behavior when the destination file already exists.
|
988
|
* - FILE_EXISTS_REPLACE - Replace the existing file.
|
989
|
* - FILE_EXISTS_RENAME - Append _{incrementing number} until the filename is
|
990
|
* unique.
|
991
|
* - FILE_EXISTS_ERROR - Do nothing and return FALSE.
|
992
|
*
|
993
|
* @return
|
994
|
* The destination filepath, or FALSE if the file already exists
|
995
|
* and FILE_EXISTS_ERROR is specified.
|
996
|
*
|
997
|
* @throws RuntimeException
|
998
|
* Thrown if the filename contains invalid UTF-8.
|
999
|
*/
|
1000
|
function file_destination($destination, $replace) {
|
1001
|
$basename = drupal_basename($destination);
|
1002
|
if (!drupal_validate_utf8($basename)) {
|
1003
|
throw new RuntimeException(sprintf("Invalid filename '%s'", $basename));
|
1004
|
}
|
1005
|
if (file_exists($destination)) {
|
1006
|
switch ($replace) {
|
1007
|
case FILE_EXISTS_REPLACE:
|
1008
|
// Do nothing here, we want to overwrite the existing file.
|
1009
|
break;
|
1010
|
|
1011
|
case FILE_EXISTS_RENAME:
|
1012
|
$directory = drupal_dirname($destination);
|
1013
|
$destination = file_create_filename($basename, $directory);
|
1014
|
break;
|
1015
|
|
1016
|
case FILE_EXISTS_ERROR:
|
1017
|
// Error reporting handled by calling function.
|
1018
|
return FALSE;
|
1019
|
}
|
1020
|
}
|
1021
|
return $destination;
|
1022
|
}
|
1023
|
|
1024
|
/**
|
1025
|
* Moves a file to a new location and update the file's database entry.
|
1026
|
*
|
1027
|
* Moving a file is performed by copying the file to the new location and then
|
1028
|
* deleting the original.
|
1029
|
* - Checks if $source and $destination are valid and readable/writable.
|
1030
|
* - Performs a file move if $source is not equal to $destination.
|
1031
|
* - If file already exists in $destination either the call will error out,
|
1032
|
* replace the file or rename the file based on the $replace parameter.
|
1033
|
* - Adds the new file to the files database.
|
1034
|
*
|
1035
|
* @param $source
|
1036
|
* A file object.
|
1037
|
* @param $destination
|
1038
|
* A string containing the destination that $source should be moved to.
|
1039
|
* This must be a stream wrapper URI.
|
1040
|
* @param $replace
|
1041
|
* Replace behavior when the destination file already exists:
|
1042
|
* - FILE_EXISTS_REPLACE - Replace the existing file. If a managed file with
|
1043
|
* the destination name exists then its database entry will be updated and
|
1044
|
* file_delete() called on the source file after hook_file_move is called.
|
1045
|
* If no database entry is found then the source files record will be
|
1046
|
* updated.
|
1047
|
* - FILE_EXISTS_RENAME - Append _{incrementing number} until the filename is
|
1048
|
* unique.
|
1049
|
* - FILE_EXISTS_ERROR - Do nothing and return FALSE.
|
1050
|
*
|
1051
|
* @return
|
1052
|
* Resulting file object for success, or FALSE in the event of an error.
|
1053
|
*
|
1054
|
* @see file_unmanaged_move()
|
1055
|
* @see hook_file_move()
|
1056
|
*/
|
1057
|
function file_move(stdClass $source, $destination = NULL, $replace = FILE_EXISTS_RENAME) {
|
1058
|
if (!file_valid_uri($destination)) {
|
1059
|
if (($realpath = drupal_realpath($source->uri)) !== FALSE) {
|
1060
|
watchdog('file', 'File %file (%realpath) could not be moved, because the destination %destination is invalid. This may be caused by improper use of file_move() or a missing stream wrapper.', array('%file' => $source->uri, '%realpath' => $realpath, '%destination' => $destination));
|
1061
|
}
|
1062
|
else {
|
1063
|
watchdog('file', 'File %file could not be moved, because the destination %destination is invalid. This may be caused by improper use of file_move() or a missing stream wrapper.', array('%file' => $source->uri, '%destination' => $destination));
|
1064
|
}
|
1065
|
drupal_set_message(t('The specified file %file could not be moved, because the destination is invalid. More information is available in the system log.', array('%file' => $source->uri)), 'error');
|
1066
|
return FALSE;
|
1067
|
}
|
1068
|
|
1069
|
if ($uri = file_unmanaged_move($source->uri, $destination, $replace)) {
|
1070
|
$delete_source = FALSE;
|
1071
|
|
1072
|
$file = clone $source;
|
1073
|
$file->uri = $uri;
|
1074
|
// If we are replacing an existing file re-use its database record.
|
1075
|
if ($replace == FILE_EXISTS_REPLACE) {
|
1076
|
$existing_files = file_load_multiple(array(), array('uri' => $uri));
|
1077
|
if (count($existing_files)) {
|
1078
|
$existing = reset($existing_files);
|
1079
|
$delete_source = TRUE;
|
1080
|
$file->fid = $existing->fid;
|
1081
|
}
|
1082
|
}
|
1083
|
// If we are renaming around an existing file (rather than a directory),
|
1084
|
// use its basename for the filename.
|
1085
|
elseif ($replace == FILE_EXISTS_RENAME && is_file($destination)) {
|
1086
|
$file->filename = drupal_basename($destination);
|
1087
|
}
|
1088
|
|
1089
|
$file = file_save($file);
|
1090
|
|
1091
|
// Inform modules that the file has been moved.
|
1092
|
module_invoke_all('file_move', $file, $source);
|
1093
|
|
1094
|
if ($delete_source) {
|
1095
|
// Try a soft delete to remove original if it's not in use elsewhere.
|
1096
|
file_delete($source);
|
1097
|
}
|
1098
|
|
1099
|
return $file;
|
1100
|
}
|
1101
|
return FALSE;
|
1102
|
}
|
1103
|
|
1104
|
/**
|
1105
|
* Moves a file to a new location without database changes or hook invocation.
|
1106
|
*
|
1107
|
* @param $source
|
1108
|
* A string specifying the filepath or URI of the original file.
|
1109
|
* @param $destination
|
1110
|
* A string containing the destination that $source should be moved to.
|
1111
|
* This must be a stream wrapper URI. If this value is omitted, Drupal's
|
1112
|
* default files scheme will be used, usually "public://".
|
1113
|
* @param $replace
|
1114
|
* Replace behavior when the destination file already exists:
|
1115
|
* - FILE_EXISTS_REPLACE - Replace the existing file.
|
1116
|
* - FILE_EXISTS_RENAME - Append _{incrementing number} until the filename is
|
1117
|
* unique.
|
1118
|
* - FILE_EXISTS_ERROR - Do nothing and return FALSE.
|
1119
|
*
|
1120
|
* @return
|
1121
|
* The URI of the moved file, or FALSE in the event of an error.
|
1122
|
*
|
1123
|
* @see file_move()
|
1124
|
*/
|
1125
|
function file_unmanaged_move($source, $destination = NULL, $replace = FILE_EXISTS_RENAME) {
|
1126
|
$filepath = file_unmanaged_copy($source, $destination, $replace);
|
1127
|
if ($filepath == FALSE || file_unmanaged_delete($source) == FALSE) {
|
1128
|
return FALSE;
|
1129
|
}
|
1130
|
return $filepath;
|
1131
|
}
|
1132
|
|
1133
|
/**
|
1134
|
* Modifies a filename as needed for security purposes.
|
1135
|
*
|
1136
|
* Munging a file name prevents unknown file extensions from masking exploit
|
1137
|
* files. When web servers such as Apache decide how to process a URL request,
|
1138
|
* they use the file extension. If the extension is not recognized, Apache
|
1139
|
* skips that extension and uses the previous file extension. For example, if
|
1140
|
* the file being requested is exploit.php.pps, and Apache does not recognize
|
1141
|
* the '.pps' extension, it treats the file as PHP and executes it. To make
|
1142
|
* this file name safe for Apache and prevent it from executing as PHP, the
|
1143
|
* .php extension is "munged" into .php_, making the safe file name
|
1144
|
* exploit.php_.pps.
|
1145
|
*
|
1146
|
* Specifically, this function adds an underscore to all extensions that are
|
1147
|
* between 2 and 5 characters in length, internal to the file name, and not
|
1148
|
* included in $extensions.
|
1149
|
*
|
1150
|
* Function behavior is also controlled by the Drupal variable
|
1151
|
* 'allow_insecure_uploads'. If 'allow_insecure_uploads' evaluates to TRUE, no
|
1152
|
* alterations will be made, if it evaluates to FALSE, the filename is 'munged'.
|
1153
|
*
|
1154
|
* @param $filename
|
1155
|
* File name to modify.
|
1156
|
* @param $extensions
|
1157
|
* A space-separated list of extensions that should not be altered.
|
1158
|
* @param $alerts
|
1159
|
* If TRUE, drupal_set_message() will be called to display a message if the
|
1160
|
* file name was changed.
|
1161
|
*
|
1162
|
* @return
|
1163
|
* The potentially modified $filename.
|
1164
|
*/
|
1165
|
function file_munge_filename($filename, $extensions, $alerts = TRUE) {
|
1166
|
$original = $filename;
|
1167
|
|
1168
|
// Allow potentially insecure uploads for very savvy users and admin
|
1169
|
if (!variable_get('allow_insecure_uploads', 0)) {
|
1170
|
// Remove any null bytes. See http://php.net/manual/security.filesystem.nullbytes.php
|
1171
|
$filename = str_replace(chr(0), '', $filename);
|
1172
|
|
1173
|
$whitelist = array_unique(explode(' ', strtolower(trim($extensions))));
|
1174
|
|
1175
|
// Split the filename up by periods. The first part becomes the basename
|
1176
|
// the last part the final extension.
|
1177
|
$filename_parts = explode('.', $filename);
|
1178
|
$new_filename = array_shift($filename_parts); // Remove file basename.
|
1179
|
$final_extension = array_pop($filename_parts); // Remove final extension.
|
1180
|
|
1181
|
// Loop through the middle parts of the name and add an underscore to the
|
1182
|
// end of each section that could be a file extension but isn't in the list
|
1183
|
// of allowed extensions.
|
1184
|
foreach ($filename_parts as $filename_part) {
|
1185
|
$new_filename .= '.' . $filename_part;
|
1186
|
if (!in_array(strtolower($filename_part), $whitelist) && preg_match("/^[a-zA-Z]{2,5}\d?$/", $filename_part)) {
|
1187
|
$new_filename .= '_';
|
1188
|
}
|
1189
|
}
|
1190
|
$filename = $new_filename . '.' . $final_extension;
|
1191
|
|
1192
|
if ($alerts && $original != $filename) {
|
1193
|
drupal_set_message(t('For security reasons, your upload has been renamed to %filename.', array('%filename' => $filename)));
|
1194
|
}
|
1195
|
}
|
1196
|
|
1197
|
return $filename;
|
1198
|
}
|
1199
|
|
1200
|
/**
|
1201
|
* Undoes the effect of file_munge_filename().
|
1202
|
*
|
1203
|
* @param $filename
|
1204
|
* String with the filename to be unmunged.
|
1205
|
*
|
1206
|
* @return
|
1207
|
* An unmunged filename string.
|
1208
|
*/
|
1209
|
function file_unmunge_filename($filename) {
|
1210
|
return str_replace('_.', '.', $filename);
|
1211
|
}
|
1212
|
|
1213
|
/**
|
1214
|
* Creates a full file path from a directory and filename.
|
1215
|
*
|
1216
|
* If a file with the specified name already exists, an alternative will be
|
1217
|
* used.
|
1218
|
*
|
1219
|
* @param $basename
|
1220
|
* String filename
|
1221
|
* @param $directory
|
1222
|
* String containing the directory or parent URI.
|
1223
|
*
|
1224
|
* @return
|
1225
|
* File path consisting of $directory and a unique filename based off
|
1226
|
* of $basename.
|
1227
|
*
|
1228
|
* @throws RuntimeException
|
1229
|
* Thrown if the $basename is not valid UTF-8 or another error occurs
|
1230
|
* stripping control characters.
|
1231
|
*/
|
1232
|
function file_create_filename($basename, $directory) {
|
1233
|
$original = $basename;
|
1234
|
// Strip control characters (ASCII value < 32). Though these are allowed in
|
1235
|
// some filesystems, not many applications handle them well.
|
1236
|
$basename = preg_replace('/[\x00-\x1F]/u', '_', $basename);
|
1237
|
if (preg_last_error() !== PREG_NO_ERROR) {
|
1238
|
throw new RuntimeException(sprintf("Invalid filename '%s'", $original));
|
1239
|
}
|
1240
|
|
1241
|
if (substr(PHP_OS, 0, 3) == 'WIN') {
|
1242
|
// These characters are not allowed in Windows filenames
|
1243
|
$basename = str_replace(array(':', '*', '?', '"', '<', '>', '|'), '_', $basename);
|
1244
|
}
|
1245
|
|
1246
|
// A URI or path may already have a trailing slash or look like "public://".
|
1247
|
if (substr($directory, -1) == '/') {
|
1248
|
$separator = '';
|
1249
|
}
|
1250
|
else {
|
1251
|
$separator = '/';
|
1252
|
}
|
1253
|
|
1254
|
$destination = $directory . $separator . $basename;
|
1255
|
|
1256
|
if (file_exists($destination)) {
|
1257
|
// Destination file already exists, generate an alternative.
|
1258
|
$pos = strrpos($basename, '.');
|
1259
|
if ($pos !== FALSE) {
|
1260
|
$name = substr($basename, 0, $pos);
|
1261
|
$ext = substr($basename, $pos);
|
1262
|
}
|
1263
|
else {
|
1264
|
$name = $basename;
|
1265
|
$ext = '';
|
1266
|
}
|
1267
|
|
1268
|
$counter = 0;
|
1269
|
do {
|
1270
|
$destination = $directory . $separator . $name . '_' . $counter++ . $ext;
|
1271
|
} while (file_exists($destination));
|
1272
|
}
|
1273
|
|
1274
|
return $destination;
|
1275
|
}
|
1276
|
|
1277
|
/**
|
1278
|
* Deletes a file and its database record.
|
1279
|
*
|
1280
|
* If the $force parameter is not TRUE, file_usage_list() will be called to
|
1281
|
* determine if the file is being used by any modules. If the file is being
|
1282
|
* used the delete will be canceled.
|
1283
|
*
|
1284
|
* @param $file
|
1285
|
* A file object.
|
1286
|
* @param $force
|
1287
|
* Boolean indicating that the file should be deleted even if the file is
|
1288
|
* reported as in use by the file_usage table.
|
1289
|
*
|
1290
|
* @return mixed
|
1291
|
* TRUE for success, FALSE in the event of an error, or an array if the file
|
1292
|
* is being used by any modules.
|
1293
|
*
|
1294
|
* @see file_unmanaged_delete()
|
1295
|
* @see file_usage_list()
|
1296
|
* @see file_usage_delete()
|
1297
|
* @see hook_file_delete()
|
1298
|
*/
|
1299
|
function file_delete(stdClass $file, $force = FALSE) {
|
1300
|
if (!file_valid_uri($file->uri)) {
|
1301
|
if (($realpath = drupal_realpath($file->uri)) !== FALSE) {
|
1302
|
watchdog('file', 'File %file (%realpath) could not be deleted because it is not a valid URI. This may be caused by improper use of file_delete() or a missing stream wrapper.', array('%file' => $file->uri, '%realpath' => $realpath));
|
1303
|
}
|
1304
|
else {
|
1305
|
watchdog('file', 'File %file could not be deleted because it is not a valid URI. This may be caused by improper use of file_delete() or a missing stream wrapper.', array('%file' => $file->uri));
|
1306
|
}
|
1307
|
drupal_set_message(t('The specified file %file could not be deleted, because it is not a valid URI. More information is available in the system log.', array('%file' => $file->uri)), 'error');
|
1308
|
return FALSE;
|
1309
|
}
|
1310
|
|
1311
|
// If any module still has a usage entry in the file_usage table, the file
|
1312
|
// will not be deleted, but file_delete() will return a populated array
|
1313
|
// that tests as TRUE.
|
1314
|
if (!$force && ($references = file_usage_list($file))) {
|
1315
|
return $references;
|
1316
|
}
|
1317
|
|
1318
|
// Let other modules clean up any references to the deleted file.
|
1319
|
module_invoke_all('file_delete', $file);
|
1320
|
module_invoke_all('entity_delete', $file, 'file');
|
1321
|
|
1322
|
// Make sure the file is deleted before removing its row from the
|
1323
|
// database, so UIs can still find the file in the database.
|
1324
|
if (file_unmanaged_delete($file->uri)) {
|
1325
|
db_delete('file_managed')->condition('fid', $file->fid)->execute();
|
1326
|
db_delete('file_usage')->condition('fid', $file->fid)->execute();
|
1327
|
entity_get_controller('file')->resetCache();
|
1328
|
return TRUE;
|
1329
|
}
|
1330
|
return FALSE;
|
1331
|
}
|
1332
|
|
1333
|
/**
|
1334
|
* Deletes a file without database changes or hook invocations.
|
1335
|
*
|
1336
|
* This function should be used when the file to be deleted does not have an
|
1337
|
* entry recorded in the files table.
|
1338
|
*
|
1339
|
* @param $path
|
1340
|
* A string containing a file path or (streamwrapper) URI.
|
1341
|
*
|
1342
|
* @return
|
1343
|
* TRUE for success or path does not exist, or FALSE in the event of an
|
1344
|
* error.
|
1345
|
*
|
1346
|
* @see file_delete()
|
1347
|
* @see file_unmanaged_delete_recursive()
|
1348
|
*/
|
1349
|
function file_unmanaged_delete($path) {
|
1350
|
if (is_dir($path)) {
|
1351
|
watchdog('file', '%path is a directory and cannot be removed using file_unmanaged_delete().', array('%path' => $path), WATCHDOG_ERROR);
|
1352
|
return FALSE;
|
1353
|
}
|
1354
|
if (is_file($path)) {
|
1355
|
return drupal_unlink($path);
|
1356
|
}
|
1357
|
// Return TRUE for non-existent file, but log that nothing was actually
|
1358
|
// deleted, as the current state is the intended result.
|
1359
|
if (!file_exists($path)) {
|
1360
|
watchdog('file', 'The file %path was not deleted, because it does not exist.', array('%path' => $path), WATCHDOG_NOTICE);
|
1361
|
return TRUE;
|
1362
|
}
|
1363
|
// We cannot handle anything other than files and directories. Log an error
|
1364
|
// for everything else (sockets, symbolic links, etc).
|
1365
|
watchdog('file', 'The file %path is not of a recognized type so it was not deleted.', array('%path' => $path), WATCHDOG_ERROR);
|
1366
|
return FALSE;
|
1367
|
}
|
1368
|
|
1369
|
/**
|
1370
|
* Deletes all files and directories in the specified filepath recursively.
|
1371
|
*
|
1372
|
* If the specified path is a directory then the function will call itself
|
1373
|
* recursively to process the contents. Once the contents have been removed the
|
1374
|
* directory will also be removed.
|
1375
|
*
|
1376
|
* If the specified path is a file then it will be passed to
|
1377
|
* file_unmanaged_delete().
|
1378
|
*
|
1379
|
* Note that this only deletes visible files with write permission.
|
1380
|
*
|
1381
|
* @param $path
|
1382
|
* A string containing either an URI or a file or directory path.
|
1383
|
*
|
1384
|
* @return
|
1385
|
* TRUE for success or if path does not exist, FALSE in the event of an
|
1386
|
* error.
|
1387
|
*
|
1388
|
* @see file_unmanaged_delete()
|
1389
|
*/
|
1390
|
function file_unmanaged_delete_recursive($path) {
|
1391
|
if (is_dir($path)) {
|
1392
|
$dir = dir($path);
|
1393
|
while (($entry = $dir->read()) !== FALSE) {
|
1394
|
if ($entry == '.' || $entry == '..') {
|
1395
|
continue;
|
1396
|
}
|
1397
|
$entry_path = $path . '/' . $entry;
|
1398
|
file_unmanaged_delete_recursive($entry_path);
|
1399
|
}
|
1400
|
$dir->close();
|
1401
|
|
1402
|
return drupal_rmdir($path);
|
1403
|
}
|
1404
|
return file_unmanaged_delete($path);
|
1405
|
}
|
1406
|
|
1407
|
/**
|
1408
|
* Determines total disk space used by a single user or the whole filesystem.
|
1409
|
*
|
1410
|
* @param $uid
|
1411
|
* Optional. A user id, specifying NULL returns the total space used by all
|
1412
|
* non-temporary files.
|
1413
|
* @param $status
|
1414
|
* Optional. The file status to consider. The default is to only
|
1415
|
* consider files in status FILE_STATUS_PERMANENT.
|
1416
|
*
|
1417
|
* @return
|
1418
|
* An integer containing the number of bytes used.
|
1419
|
*/
|
1420
|
function file_space_used($uid = NULL, $status = FILE_STATUS_PERMANENT) {
|
1421
|
$query = db_select('file_managed', 'f');
|
1422
|
$query->condition('f.status', $status);
|
1423
|
$query->addExpression('SUM(f.filesize)', 'filesize');
|
1424
|
if (isset($uid)) {
|
1425
|
$query->condition('f.uid', $uid);
|
1426
|
}
|
1427
|
return $query->execute()->fetchField();
|
1428
|
}
|
1429
|
|
1430
|
/**
|
1431
|
* Saves a file upload to a new location.
|
1432
|
*
|
1433
|
* The file will be added to the {file_managed} table as a temporary file.
|
1434
|
* Temporary files are periodically cleaned. To make the file a permanent file,
|
1435
|
* assign the status and use file_save() to save the changes.
|
1436
|
*
|
1437
|
* @param $form_field_name
|
1438
|
* A string that is the associative array key of the upload form element in
|
1439
|
* the form array.
|
1440
|
* @param $validators
|
1441
|
* An optional, associative array of callback functions used to validate the
|
1442
|
* file. See file_validate() for a full discussion of the array format.
|
1443
|
* If no extension validator is provided it will default to a limited safe
|
1444
|
* list of extensions which is as follows: "jpg jpeg gif png txt
|
1445
|
* doc xls pdf ppt pps odt ods odp". To allow all extensions you must
|
1446
|
* explicitly set the 'file_validate_extensions' validator to an empty array
|
1447
|
* (Beware: this is not safe and should only be allowed for trusted users, if
|
1448
|
* at all).
|
1449
|
* @param $destination
|
1450
|
* A string containing the URI that the file should be copied to. This must
|
1451
|
* be a stream wrapper URI. If this value is omitted, Drupal's temporary
|
1452
|
* files scheme will be used ("temporary://").
|
1453
|
* @param $replace
|
1454
|
* Replace behavior when the destination file already exists:
|
1455
|
* - FILE_EXISTS_REPLACE: Replace the existing file.
|
1456
|
* - FILE_EXISTS_RENAME: Append _{incrementing number} until the filename is
|
1457
|
* unique.
|
1458
|
* - FILE_EXISTS_ERROR: Do nothing and return FALSE.
|
1459
|
*
|
1460
|
* @return
|
1461
|
* An object containing the file information if the upload succeeded, FALSE
|
1462
|
* in the event of an error, or NULL if no file was uploaded. The
|
1463
|
* documentation for the "File interface" group, which you can find under
|
1464
|
* Related topics, or the header at the top of this file, documents the
|
1465
|
* components of a file object. In addition to the standard components,
|
1466
|
* this function adds:
|
1467
|
* - source: Path to the file before it is moved.
|
1468
|
* - destination: Path to the file after it is moved (same as 'uri').
|
1469
|
*/
|
1470
|
function file_save_upload($form_field_name, $validators = array(), $destination = FALSE, $replace = FILE_EXISTS_RENAME) {
|
1471
|
global $user;
|
1472
|
static $upload_cache;
|
1473
|
|
1474
|
// Return cached objects without processing since the file will have
|
1475
|
// already been processed and the paths in _FILES will be invalid.
|
1476
|
if (isset($upload_cache[$form_field_name])) {
|
1477
|
return $upload_cache[$form_field_name];
|
1478
|
}
|
1479
|
|
1480
|
// Make sure there's an upload to process.
|
1481
|
if (empty($_FILES['files']['name'][$form_field_name])) {
|
1482
|
return NULL;
|
1483
|
}
|
1484
|
|
1485
|
// Check for file upload errors and return FALSE if a lower level system
|
1486
|
// error occurred. For a complete list of errors:
|
1487
|
// See http://php.net/manual/features.file-upload.errors.php.
|
1488
|
switch ($_FILES['files']['error'][$form_field_name]) {
|
1489
|
case UPLOAD_ERR_INI_SIZE:
|
1490
|
case UPLOAD_ERR_FORM_SIZE:
|
1491
|
drupal_set_message(t('The file %file could not be saved, because it exceeds %maxsize, the maximum allowed size for uploads.', array('%file' => $_FILES['files']['name'][$form_field_name], '%maxsize' => format_size(file_upload_max_size()))), 'error');
|
1492
|
return FALSE;
|
1493
|
|
1494
|
case UPLOAD_ERR_PARTIAL:
|
1495
|
case UPLOAD_ERR_NO_FILE:
|
1496
|
drupal_set_message(t('The file %file could not be saved, because the upload did not complete.', array('%file' => $_FILES['files']['name'][$form_field_name])), 'error');
|
1497
|
return FALSE;
|
1498
|
|
1499
|
case UPLOAD_ERR_OK:
|
1500
|
// Final check that this is a valid upload, if it isn't, use the
|
1501
|
// default error handler.
|
1502
|
if (is_uploaded_file($_FILES['files']['tmp_name'][$form_field_name])) {
|
1503
|
break;
|
1504
|
}
|
1505
|
|
1506
|
// Unknown error
|
1507
|
default:
|
1508
|
drupal_set_message(t('The file %file could not be saved. An unknown error has occurred.', array('%file' => $_FILES['files']['name'][$form_field_name])), 'error');
|
1509
|
return FALSE;
|
1510
|
}
|
1511
|
|
1512
|
// Begin building file object.
|
1513
|
$file = new stdClass();
|
1514
|
$file->uid = $user->uid;
|
1515
|
$file->status = 0;
|
1516
|
$file->filename = trim(drupal_basename($_FILES['files']['name'][$form_field_name]), '.');
|
1517
|
$file->uri = $_FILES['files']['tmp_name'][$form_field_name];
|
1518
|
$file->filemime = file_get_mimetype($file->filename);
|
1519
|
$file->filesize = $_FILES['files']['size'][$form_field_name];
|
1520
|
|
1521
|
$extensions = '';
|
1522
|
if (isset($validators['file_validate_extensions'])) {
|
1523
|
if (isset($validators['file_validate_extensions'][0])) {
|
1524
|
// Build the list of non-munged extensions if the caller provided them.
|
1525
|
$extensions = $validators['file_validate_extensions'][0];
|
1526
|
}
|
1527
|
else {
|
1528
|
// If 'file_validate_extensions' is set and the list is empty then the
|
1529
|
// caller wants to allow any extension. In this case we have to remove the
|
1530
|
// validator or else it will reject all extensions.
|
1531
|
unset($validators['file_validate_extensions']);
|
1532
|
}
|
1533
|
}
|
1534
|
else {
|
1535
|
// No validator was provided, so add one using the default list.
|
1536
|
// Build a default non-munged safe list for file_munge_filename().
|
1537
|
$extensions = 'jpg jpeg gif png txt doc xls pdf ppt pps odt ods odp';
|
1538
|
$validators['file_validate_extensions'] = array();
|
1539
|
$validators['file_validate_extensions'][0] = $extensions;
|
1540
|
}
|
1541
|
|
1542
|
if (!empty($extensions)) {
|
1543
|
// Munge the filename to protect against possible malicious extension hiding
|
1544
|
// within an unknown file type (ie: filename.html.foo).
|
1545
|
$file->filename = file_munge_filename($file->filename, $extensions);
|
1546
|
}
|
1547
|
|
1548
|
// Rename potentially executable files, to help prevent exploits (i.e. will
|
1549
|
// rename filename.php.foo and filename.php to filename.php.foo.txt and
|
1550
|
// filename.php.txt, respectively). Don't rename if 'allow_insecure_uploads'
|
1551
|
// evaluates to TRUE.
|
1552
|
if (!variable_get('allow_insecure_uploads', 0) && preg_match('/\.(php|phar|pl|py|cgi|asp|js)(\.|$)/i', $file->filename) && (substr($file->filename, -4) != '.txt')) {
|
1553
|
$file->filemime = 'text/plain';
|
1554
|
// The destination filename will also later be used to create the URI.
|
1555
|
$file->filename .= '.txt';
|
1556
|
// The .txt extension may not be in the allowed list of extensions. We have
|
1557
|
// to add it here or else the file upload will fail.
|
1558
|
if (!empty($extensions)) {
|
1559
|
$validators['file_validate_extensions'][0] .= ' txt';
|
1560
|
drupal_set_message(t('For security reasons, your upload has been renamed to %filename.', array('%filename' => $file->filename)));
|
1561
|
}
|
1562
|
}
|
1563
|
|
1564
|
// If the destination is not provided, use the temporary directory.
|
1565
|
if (empty($destination)) {
|
1566
|
$destination = 'temporary://';
|
1567
|
}
|
1568
|
|
1569
|
// Assert that the destination contains a valid stream.
|
1570
|
$destination_scheme = file_uri_scheme($destination);
|
1571
|
if (!$destination_scheme || !file_stream_wrapper_valid_scheme($destination_scheme)) {
|
1572
|
drupal_set_message(t('The file could not be uploaded, because the destination %destination is invalid.', array('%destination' => $destination)), 'error');
|
1573
|
return FALSE;
|
1574
|
}
|
1575
|
|
1576
|
$file->source = $form_field_name;
|
1577
|
// A URI may already have a trailing slash or look like "public://".
|
1578
|
if (substr($destination, -1) != '/') {
|
1579
|
$destination .= '/';
|
1580
|
}
|
1581
|
try {
|
1582
|
$file->destination = file_destination($destination . $file->filename, $replace);
|
1583
|
}
|
1584
|
catch (RuntimeException $e) {
|
1585
|
drupal_set_message(t('The file %source could not be uploaded because the name is invalid.', array('%source' => $form_field_name)), 'error');
|
1586
|
return FALSE;
|
1587
|
}
|
1588
|
// If file_destination() returns FALSE then $replace == FILE_EXISTS_ERROR and
|
1589
|
// there's an existing file so we need to bail.
|
1590
|
if ($file->destination === FALSE) {
|
1591
|
drupal_set_message(t('The file %source could not be uploaded because a file by that name already exists in the destination %directory.', array('%source' => $form_field_name, '%directory' => $destination)), 'error');
|
1592
|
return FALSE;
|
1593
|
}
|
1594
|
|
1595
|
// Add in our check of the file name length.
|
1596
|
$validators['file_validate_name_length'] = array();
|
1597
|
|
1598
|
// Call the validation functions specified by this function's caller.
|
1599
|
$errors = file_validate($file, $validators);
|
1600
|
|
1601
|
// Check for errors.
|
1602
|
if (!empty($errors)) {
|
1603
|
$message = t('The specified file %name could not be uploaded.', array('%name' => $file->filename));
|
1604
|
if (count($errors) > 1) {
|
1605
|
$message .= theme('item_list', array('items' => $errors));
|
1606
|
}
|
1607
|
else {
|
1608
|
$message .= ' ' . array_pop($errors);
|
1609
|
}
|
1610
|
form_set_error($form_field_name, $message);
|
1611
|
return FALSE;
|
1612
|
}
|
1613
|
|
1614
|
// Move uploaded files from PHP's upload_tmp_dir to Drupal's temporary
|
1615
|
// directory. This overcomes open_basedir restrictions for future file
|
1616
|
// operations.
|
1617
|
$file->uri = $file->destination;
|
1618
|
if (!drupal_move_uploaded_file($_FILES['files']['tmp_name'][$form_field_name], $file->uri)) {
|
1619
|
form_set_error($form_field_name, t('File upload error. Could not move uploaded file.'));
|
1620
|
watchdog('file', 'Upload error. Could not move uploaded file %file to destination %destination.', array('%file' => $file->filename, '%destination' => $file->uri));
|
1621
|
return FALSE;
|
1622
|
}
|
1623
|
|
1624
|
// Set the permissions on the new file.
|
1625
|
drupal_chmod($file->uri);
|
1626
|
|
1627
|
// If we are replacing an existing file re-use its database record.
|
1628
|
if ($replace == FILE_EXISTS_REPLACE) {
|
1629
|
$existing_files = file_load_multiple(array(), array('uri' => $file->uri));
|
1630
|
if (count($existing_files)) {
|
1631
|
$existing = reset($existing_files);
|
1632
|
$file->fid = $existing->fid;
|
1633
|
}
|
1634
|
}
|
1635
|
|
1636
|
// If we made it this far it's safe to record this file in the database.
|
1637
|
if ($file = file_save($file)) {
|
1638
|
// Track non-public files in the session if they were uploaded by an
|
1639
|
// anonymous user. This allows modules such as the File module to only
|
1640
|
// grant view access to the specific anonymous user who uploaded the file.
|
1641
|
// See file_file_download().
|
1642
|
// The 'file_public_schema' variable is used to allow other publicly
|
1643
|
// accessible file schemes to be treated the same as the public:// scheme
|
1644
|
// provided by Drupal core and to avoid adding unnecessary data to the
|
1645
|
// session (and the resulting bypass of the page cache) in those cases. For
|
1646
|
// security reasons, only schemes that are completely publicly accessible,
|
1647
|
// with no download restrictions, should be added to this variable. See
|
1648
|
// file_managed_file_value().
|
1649
|
if (!$user->uid && !in_array($destination_scheme, variable_get('file_public_schema', array('public')))) {
|
1650
|
$_SESSION['anonymous_allowed_file_ids'][$file->fid] = $file->fid;
|
1651
|
}
|
1652
|
// Add file to the cache.
|
1653
|
$upload_cache[$form_field_name] = $file;
|
1654
|
return $file;
|
1655
|
}
|
1656
|
return FALSE;
|
1657
|
}
|
1658
|
|
1659
|
/**
|
1660
|
* Moves an uploaded file to a new location.
|
1661
|
*
|
1662
|
* PHP's move_uploaded_file() does not properly support streams if safe_mode
|
1663
|
* or open_basedir are enabled, so this function fills that gap.
|
1664
|
*
|
1665
|
* Compatibility: normal paths and stream wrappers.
|
1666
|
*
|
1667
|
* @param $filename
|
1668
|
* The filename of the uploaded file.
|
1669
|
* @param $uri
|
1670
|
* A string containing the destination URI of the file.
|
1671
|
*
|
1672
|
* @return
|
1673
|
* TRUE on success, or FALSE on failure.
|
1674
|
*
|
1675
|
* @see move_uploaded_file()
|
1676
|
* @see http://drupal.org/node/515192
|
1677
|
* @ingroup php_wrappers
|
1678
|
*/
|
1679
|
function drupal_move_uploaded_file($filename, $uri) {
|
1680
|
$result = @move_uploaded_file($filename, $uri);
|
1681
|
// PHP's move_uploaded_file() does not properly support streams if safe_mode
|
1682
|
// or open_basedir are enabled so if the move failed, try finding a real path
|
1683
|
// and retry the move operation.
|
1684
|
if (!$result) {
|
1685
|
if ($realpath = drupal_realpath($uri)) {
|
1686
|
$result = move_uploaded_file($filename, $realpath);
|
1687
|
}
|
1688
|
else {
|
1689
|
$result = move_uploaded_file($filename, $uri);
|
1690
|
}
|
1691
|
}
|
1692
|
|
1693
|
return $result;
|
1694
|
}
|
1695
|
|
1696
|
/**
|
1697
|
* Checks that a file meets the criteria specified by the validators.
|
1698
|
*
|
1699
|
* After executing the validator callbacks specified hook_file_validate() will
|
1700
|
* also be called to allow other modules to report errors about the file.
|
1701
|
*
|
1702
|
* @param $file
|
1703
|
* A Drupal file object.
|
1704
|
* @param $validators
|
1705
|
* An optional, associative array of callback functions used to validate the
|
1706
|
* file. The keys are function names and the values arrays of callback
|
1707
|
* parameters which will be passed in after the file object. The
|
1708
|
* functions should return an array of error messages; an empty array
|
1709
|
* indicates that the file passed validation. The functions will be called in
|
1710
|
* the order specified.
|
1711
|
*
|
1712
|
* @return
|
1713
|
* An array containing validation error messages.
|
1714
|
*
|
1715
|
* @see hook_file_validate()
|
1716
|
*/
|
1717
|
function file_validate(stdClass &$file, $validators = array()) {
|
1718
|
// Call the validation functions specified by this function's caller.
|
1719
|
$errors = array();
|
1720
|
foreach ($validators as $function => $args) {
|
1721
|
if (function_exists($function)) {
|
1722
|
array_unshift($args, $file);
|
1723
|
$errors = array_merge($errors, call_user_func_array($function, $args));
|
1724
|
}
|
1725
|
}
|
1726
|
|
1727
|
// Let other modules perform validation on the new file.
|
1728
|
return array_merge($errors, module_invoke_all('file_validate', $file));
|
1729
|
}
|
1730
|
|
1731
|
/**
|
1732
|
* Checks for files with names longer than we can store in the database.
|
1733
|
*
|
1734
|
* @param $file
|
1735
|
* A Drupal file object.
|
1736
|
*
|
1737
|
* @return
|
1738
|
* An array. If the file name is too long, it will contain an error message.
|
1739
|
*/
|
1740
|
function file_validate_name_length(stdClass $file) {
|
1741
|
$errors = array();
|
1742
|
|
1743
|
if (empty($file->filename)) {
|
1744
|
$errors[] = t("The file's name is empty. Please give a name to the file.");
|
1745
|
}
|
1746
|
if (strlen($file->filename) > 240) {
|
1747
|
$errors[] = t("The file's name exceeds the 240 characters limit. Please rename the file and try again.");
|
1748
|
}
|
1749
|
return $errors;
|
1750
|
}
|
1751
|
|
1752
|
/**
|
1753
|
* Checks that the filename ends with an allowed extension.
|
1754
|
*
|
1755
|
* @param $file
|
1756
|
* A Drupal file object.
|
1757
|
* @param $extensions
|
1758
|
* A string with a space separated list of allowed extensions.
|
1759
|
*
|
1760
|
* @return
|
1761
|
* An array. If the file extension is not allowed, it will contain an error
|
1762
|
* message.
|
1763
|
*
|
1764
|
* @see hook_file_validate()
|
1765
|
*/
|
1766
|
function file_validate_extensions(stdClass $file, $extensions) {
|
1767
|
$errors = array();
|
1768
|
|
1769
|
$regex = '/\.(' . preg_replace('/ +/', '|', preg_quote($extensions)) . ')$/i';
|
1770
|
if (!preg_match($regex, $file->filename)) {
|
1771
|
$errors[] = t('Only files with the following extensions are allowed: %files-allowed.', array('%files-allowed' => $extensions));
|
1772
|
}
|
1773
|
return $errors;
|
1774
|
}
|
1775
|
|
1776
|
/**
|
1777
|
* Checks that the file's size is below certain limits.
|
1778
|
*
|
1779
|
* @param $file
|
1780
|
* A Drupal file object.
|
1781
|
* @param $file_limit
|
1782
|
* An integer specifying the maximum file size in bytes. Zero indicates that
|
1783
|
* no limit should be enforced.
|
1784
|
* @param $user_limit
|
1785
|
* An integer specifying the maximum number of bytes the user is allowed.
|
1786
|
* Zero indicates that no limit should be enforced.
|
1787
|
*
|
1788
|
* @return
|
1789
|
* An array. If the file size exceeds limits, it will contain an error
|
1790
|
* message.
|
1791
|
*
|
1792
|
* @see hook_file_validate()
|
1793
|
*/
|
1794
|
function file_validate_size(stdClass $file, $file_limit = 0, $user_limit = 0) {
|
1795
|
global $user;
|
1796
|
$errors = array();
|
1797
|
|
1798
|
if ($file_limit && $file->filesize > $file_limit) {
|
1799
|
$errors[] = t('The file is %filesize exceeding the maximum file size of %maxsize.', array('%filesize' => format_size($file->filesize), '%maxsize' => format_size($file_limit)));
|
1800
|
}
|
1801
|
|
1802
|
// Save a query by only calling file_space_used() when a limit is provided.
|
1803
|
if ($user_limit && (file_space_used($user->uid) + $file->filesize) > $user_limit) {
|
1804
|
$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)));
|
1805
|
}
|
1806
|
|
1807
|
return $errors;
|
1808
|
}
|
1809
|
|
1810
|
/**
|
1811
|
* Checks that the file is recognized by image_get_info() as an image.
|
1812
|
*
|
1813
|
* @param $file
|
1814
|
* A Drupal file object.
|
1815
|
*
|
1816
|
* @return
|
1817
|
* An array. If the file is not an image, it will contain an error message.
|
1818
|
*
|
1819
|
* @see hook_file_validate()
|
1820
|
*/
|
1821
|
function file_validate_is_image(stdClass $file) {
|
1822
|
$errors = array();
|
1823
|
|
1824
|
$info = image_get_info($file->uri);
|
1825
|
if (!$info || empty($info['extension'])) {
|
1826
|
$errors[] = t('Only JPEG, PNG and GIF images are allowed.');
|
1827
|
}
|
1828
|
|
1829
|
return $errors;
|
1830
|
}
|
1831
|
|
1832
|
/**
|
1833
|
* Verifies that image dimensions are within the specified maximum and minimum.
|
1834
|
*
|
1835
|
* Non-image files will be ignored. If an image toolkit is available the image
|
1836
|
* will be scaled to fit within the desired maximum dimensions.
|
1837
|
*
|
1838
|
* @param $file
|
1839
|
* A Drupal file object. This function may resize the file affecting its
|
1840
|
* size.
|
1841
|
* @param $maximum_dimensions
|
1842
|
* An optional string in the form WIDTHxHEIGHT e.g. '640x480' or '85x85'. If
|
1843
|
* an image toolkit is installed the image will be resized down to these
|
1844
|
* dimensions. A value of 0 indicates no restriction on size, so resizing
|
1845
|
* will be attempted.
|
1846
|
* @param $minimum_dimensions
|
1847
|
* An optional string in the form WIDTHxHEIGHT. This will check that the
|
1848
|
* image meets a minimum size. A value of 0 indicates no restriction.
|
1849
|
*
|
1850
|
* @return
|
1851
|
* An array. If the file is an image and did not meet the requirements, it
|
1852
|
* will contain an error message.
|
1853
|
*
|
1854
|
* @see hook_file_validate()
|
1855
|
*/
|
1856
|
function file_validate_image_resolution(stdClass $file, $maximum_dimensions = 0, $minimum_dimensions = 0) {
|
1857
|
$errors = array();
|
1858
|
|
1859
|
// Check first that the file is an image.
|
1860
|
if ($info = image_get_info($file->uri)) {
|
1861
|
if ($maximum_dimensions) {
|
1862
|
// Check that it is smaller than the given dimensions.
|
1863
|
list($width, $height) = explode('x', $maximum_dimensions);
|
1864
|
if ($info['width'] > $width || $info['height'] > $height) {
|
1865
|
// Try to resize the image to fit the dimensions.
|
1866
|
if ($image = image_load($file->uri)) {
|
1867
|
image_scale($image, $width, $height);
|
1868
|
image_save($image);
|
1869
|
$file->filesize = $image->info['file_size'];
|
1870
|
drupal_set_message(t('The image was resized to fit within the maximum allowed dimensions of %dimensions pixels.', array('%dimensions' => $maximum_dimensions)));
|
1871
|
}
|
1872
|
else {
|
1873
|
$errors[] = t('The image is too large; the maximum dimensions are %dimensions pixels.', array('%dimensions' => $maximum_dimensions));
|
1874
|
}
|
1875
|
}
|
1876
|
}
|
1877
|
|
1878
|
if ($minimum_dimensions) {
|
1879
|
// Check that it is larger than the given dimensions.
|
1880
|
list($width, $height) = explode('x', $minimum_dimensions);
|
1881
|
if ($info['width'] < $width || $info['height'] < $height) {
|
1882
|
$errors[] = t('The image is too small; the minimum dimensions are %dimensions pixels.', array('%dimensions' => $minimum_dimensions));
|
1883
|
}
|
1884
|
}
|
1885
|
}
|
1886
|
|
1887
|
return $errors;
|
1888
|
}
|
1889
|
|
1890
|
/**
|
1891
|
* Saves a file to the specified destination and creates a database entry.
|
1892
|
*
|
1893
|
* @param $data
|
1894
|
* A string containing the contents of the file.
|
1895
|
* @param $destination
|
1896
|
* A string containing the destination URI. This must be a stream wrapper URI.
|
1897
|
* If no value is provided, a randomized name will be generated and the file
|
1898
|
* will be saved using Drupal's default files scheme, usually "public://".
|
1899
|
* @param $replace
|
1900
|
* Replace behavior when the destination file already exists:
|
1901
|
* - FILE_EXISTS_REPLACE - Replace the existing file. If a managed file with
|
1902
|
* the destination name exists then its database entry will be updated. If
|
1903
|
* no database entry is found then a new one will be created.
|
1904
|
* - FILE_EXISTS_RENAME - Append _{incrementing number} until the filename is
|
1905
|
* unique.
|
1906
|
* - FILE_EXISTS_ERROR - Do nothing and return FALSE.
|
1907
|
*
|
1908
|
* @return
|
1909
|
* A file object, or FALSE on error.
|
1910
|
*
|
1911
|
* @see file_unmanaged_save_data()
|
1912
|
*/
|
1913
|
function file_save_data($data, $destination = NULL, $replace = FILE_EXISTS_RENAME) {
|
1914
|
global $user;
|
1915
|
|
1916
|
if (empty($destination)) {
|
1917
|
$destination = file_default_scheme() . '://';
|
1918
|
}
|
1919
|
if (!file_valid_uri($destination)) {
|
1920
|
watchdog('file', 'The data could not be saved because the destination %destination is invalid. This may be caused by improper use of file_save_data() or a missing stream wrapper.', array('%destination' => $destination));
|
1921
|
drupal_set_message(t('The data could not be saved, because the destination is invalid. More information is available in the system log.'), 'error');
|
1922
|
return FALSE;
|
1923
|
}
|
1924
|
|
1925
|
if ($uri = file_unmanaged_save_data($data, $destination, $replace)) {
|
1926
|
// Create a file object.
|
1927
|
$file = new stdClass();
|
1928
|
$file->fid = NULL;
|
1929
|
$file->uri = $uri;
|
1930
|
$file->filename = drupal_basename($uri);
|
1931
|
$file->filemime = file_get_mimetype($file->uri);
|
1932
|
$file->uid = $user->uid;
|
1933
|
$file->status = FILE_STATUS_PERMANENT;
|
1934
|
// If we are replacing an existing file re-use its database record.
|
1935
|
if ($replace == FILE_EXISTS_REPLACE) {
|
1936
|
$existing_files = file_load_multiple(array(), array('uri' => $uri));
|
1937
|
if (count($existing_files)) {
|
1938
|
$existing = reset($existing_files);
|
1939
|
$file->fid = $existing->fid;
|
1940
|
$file->filename = $existing->filename;
|
1941
|
}
|
1942
|
}
|
1943
|
// If we are renaming around an existing file (rather than a directory),
|
1944
|
// use its basename for the filename.
|
1945
|
elseif ($replace == FILE_EXISTS_RENAME && is_file($destination)) {
|
1946
|
$file->filename = drupal_basename($destination);
|
1947
|
}
|
1948
|
|
1949
|
return file_save($file);
|
1950
|
}
|
1951
|
return FALSE;
|
1952
|
}
|
1953
|
|
1954
|
/**
|
1955
|
* Saves a string to the specified destination without invoking file API.
|
1956
|
*
|
1957
|
* This function is identical to file_save_data() except the file will not be
|
1958
|
* saved to the {file_managed} table and none of the file_* hooks will be
|
1959
|
* called.
|
1960
|
*
|
1961
|
* @param $data
|
1962
|
* A string containing the contents of the file.
|
1963
|
* @param $destination
|
1964
|
* A string containing the destination location. This must be a stream wrapper
|
1965
|
* URI. If no value is provided, a randomized name will be generated and the
|
1966
|
* file will be saved using Drupal's default files scheme, usually
|
1967
|
* "public://".
|
1968
|
* @param $replace
|
1969
|
* Replace behavior when the destination file already exists:
|
1970
|
* - FILE_EXISTS_REPLACE - Replace the existing file.
|
1971
|
* - FILE_EXISTS_RENAME - Append _{incrementing number} until the filename is
|
1972
|
* unique.
|
1973
|
* - FILE_EXISTS_ERROR - Do nothing and return FALSE.
|
1974
|
*
|
1975
|
* @return
|
1976
|
* A string with the path of the resulting file, or FALSE on error.
|
1977
|
*
|
1978
|
* @see file_save_data()
|
1979
|
*/
|
1980
|
function file_unmanaged_save_data($data, $destination = NULL, $replace = FILE_EXISTS_RENAME) {
|
1981
|
// Write the data to a temporary file.
|
1982
|
$temp_name = drupal_tempnam('temporary://', 'file');
|
1983
|
if (file_put_contents($temp_name, $data) === FALSE) {
|
1984
|
drupal_set_message(t('The file could not be created.'), 'error');
|
1985
|
return FALSE;
|
1986
|
}
|
1987
|
|
1988
|
// Move the file to its final destination.
|
1989
|
return file_unmanaged_move($temp_name, $destination, $replace);
|
1990
|
}
|
1991
|
|
1992
|
/**
|
1993
|
* Transfers a file to the client using HTTP.
|
1994
|
*
|
1995
|
* Pipes a file through Drupal to the client.
|
1996
|
*
|
1997
|
* @param $uri
|
1998
|
* String specifying the file URI to transfer.
|
1999
|
* @param $headers
|
2000
|
* An array of HTTP headers to send along with file.
|
2001
|
*/
|
2002
|
function file_transfer($uri, $headers) {
|
2003
|
if (ob_get_level()) {
|
2004
|
ob_end_clean();
|
2005
|
}
|
2006
|
|
2007
|
foreach ($headers as $name => $value) {
|
2008
|
drupal_add_http_header($name, $value);
|
2009
|
}
|
2010
|
drupal_send_headers();
|
2011
|
$scheme = file_uri_scheme($uri);
|
2012
|
// Transfer file in 1024 byte chunks to save memory usage.
|
2013
|
if ($scheme && file_stream_wrapper_valid_scheme($scheme) && $fd = fopen($uri, 'rb')) {
|
2014
|
while (!feof($fd)) {
|
2015
|
print fread($fd, 1024);
|
2016
|
}
|
2017
|
fclose($fd);
|
2018
|
}
|
2019
|
else {
|
2020
|
drupal_not_found();
|
2021
|
}
|
2022
|
drupal_exit();
|
2023
|
}
|
2024
|
|
2025
|
/**
|
2026
|
* Menu handler for private file transfers.
|
2027
|
*
|
2028
|
* Call modules that implement hook_file_download() to find out if a file is
|
2029
|
* accessible and what headers it should be transferred with. If one or more
|
2030
|
* modules returned headers the download will start with the returned headers.
|
2031
|
* If a module returns -1 drupal_access_denied() will be returned. If the file
|
2032
|
* exists but no modules responded drupal_access_denied() will be returned.
|
2033
|
* If the file does not exist drupal_not_found() will be returned.
|
2034
|
*
|
2035
|
* @see system_menu()
|
2036
|
*/
|
2037
|
function file_download() {
|
2038
|
// Merge remainder of arguments from GET['q'], into relative file path.
|
2039
|
$args = func_get_args();
|
2040
|
$scheme = array_shift($args);
|
2041
|
$target = implode('/', $args);
|
2042
|
$uri = $scheme . '://' . $target;
|
2043
|
if (file_stream_wrapper_valid_scheme($scheme) && file_exists($uri)) {
|
2044
|
$headers = file_download_headers($uri);
|
2045
|
if (count($headers)) {
|
2046
|
file_transfer($uri, $headers);
|
2047
|
}
|
2048
|
drupal_access_denied();
|
2049
|
}
|
2050
|
else {
|
2051
|
drupal_not_found();
|
2052
|
}
|
2053
|
drupal_exit();
|
2054
|
}
|
2055
|
|
2056
|
/**
|
2057
|
* Retrieves headers for a private file download.
|
2058
|
*
|
2059
|
* Calls all module implementations of hook_file_download() to retrieve headers
|
2060
|
* for files by the module that originally provided the file. The presence of
|
2061
|
* returned headers indicates the current user has access to the file.
|
2062
|
*
|
2063
|
* @param $uri
|
2064
|
* The URI for the file whose headers should be retrieved.
|
2065
|
*
|
2066
|
* @return
|
2067
|
* If access is allowed, headers for the file, suitable for passing to
|
2068
|
* file_transfer(). If access is not allowed, an empty array will be returned.
|
2069
|
*
|
2070
|
* @see file_transfer()
|
2071
|
* @see file_download_access()
|
2072
|
* @see hook_file_download()
|
2073
|
*/
|
2074
|
function file_download_headers($uri) {
|
2075
|
// Let other modules provide headers and control access to the file.
|
2076
|
// module_invoke_all() uses array_merge_recursive() which merges header
|
2077
|
// values into a new array. To avoid that and allow modules to override
|
2078
|
// headers instead, use array_merge() to merge the returned arrays.
|
2079
|
$headers = array();
|
2080
|
foreach (module_implements('file_download') as $module) {
|
2081
|
$function = $module . '_file_download';
|
2082
|
$result = $function($uri);
|
2083
|
if ($result == -1) {
|
2084
|
// Throw away the headers received so far.
|
2085
|
$headers = array();
|
2086
|
break;
|
2087
|
}
|
2088
|
if (isset($result) && is_array($result)) {
|
2089
|
$headers = array_merge($headers, $result);
|
2090
|
}
|
2091
|
}
|
2092
|
return $headers;
|
2093
|
}
|
2094
|
|
2095
|
/**
|
2096
|
* Checks that the current user has access to a particular file.
|
2097
|
*
|
2098
|
* The return value of this function hinges on the return value from
|
2099
|
* file_download_headers(), which is the function responsible for collecting
|
2100
|
* access information through hook_file_download().
|
2101
|
*
|
2102
|
* If immediately transferring the file to the browser and the headers will
|
2103
|
* need to be retrieved, the return value of file_download_headers() should be
|
2104
|
* used to determine access directly, so that access checks will not be run
|
2105
|
* twice.
|
2106
|
*
|
2107
|
* @param $uri
|
2108
|
* The URI for the file whose access should be retrieved.
|
2109
|
*
|
2110
|
* @return
|
2111
|
* Boolean TRUE if access is allowed. FALSE if access is not allowed.
|
2112
|
*
|
2113
|
* @see file_download_headers()
|
2114
|
* @see hook_file_download()
|
2115
|
*/
|
2116
|
function file_download_access($uri) {
|
2117
|
return count(file_download_headers($uri)) > 0;
|
2118
|
}
|
2119
|
|
2120
|
/**
|
2121
|
* Finds all files that match a given mask in a given directory.
|
2122
|
*
|
2123
|
* Directories and files beginning with a period are excluded; this
|
2124
|
* prevents hidden files and directories (such as SVN working directories)
|
2125
|
* from being scanned.
|
2126
|
*
|
2127
|
* @param $dir
|
2128
|
* The base directory or URI to scan, without trailing slash.
|
2129
|
* @param $mask
|
2130
|
* The preg_match() regular expression of the files to find.
|
2131
|
* @param $options
|
2132
|
* An associative array of additional options, with the following elements:
|
2133
|
* - 'nomask': The preg_match() regular expression of the files to ignore.
|
2134
|
* Defaults to '/(\.\.?|CVS)$/'.
|
2135
|
* - 'callback': The callback function to call for each match. There is no
|
2136
|
* default callback.
|
2137
|
* - 'recurse': When TRUE, the directory scan will recurse the entire tree
|
2138
|
* starting at the provided directory. Defaults to TRUE.
|
2139
|
* - 'key': The key to be used for the returned associative array of files.
|
2140
|
* Possible values are 'uri', for the file's URI; 'filename', for the
|
2141
|
* basename of the file; and 'name' for the name of the file without the
|
2142
|
* extension. Defaults to 'uri'.
|
2143
|
* - 'min_depth': Minimum depth of directories to return files from. Defaults
|
2144
|
* to 0.
|
2145
|
* @param $depth
|
2146
|
* Current depth of recursion. This parameter is only used internally and
|
2147
|
* should not be passed in.
|
2148
|
*
|
2149
|
* @return
|
2150
|
* An associative array (keyed on the chosen key) of objects with 'uri',
|
2151
|
* 'filename', and 'name' members corresponding to the matching files.
|
2152
|
*/
|
2153
|
function file_scan_directory($dir, $mask, $options = array(), $depth = 0) {
|
2154
|
// Default nomask option.
|
2155
|
$nomask = '/(\.\.?|CVS)$/';
|
2156
|
|
2157
|
// Overrides the $nomask variable accordingly if $options['nomask'] is set.
|
2158
|
//
|
2159
|
// Allow directories specified in settings.php to be ignored. You can use this
|
2160
|
// to not check for files in common special-purpose directories. For example,
|
2161
|
// node_modules and bower_components. Ignoring irrelevant directories is a
|
2162
|
// performance boost.
|
2163
|
if (!isset($options['nomask'])) {
|
2164
|
$ignore_directories = variable_get(
|
2165
|
'file_scan_ignore_directories',
|
2166
|
array()
|
2167
|
);
|
2168
|
|
2169
|
foreach ($ignore_directories as $index => $ignore_directory) {
|
2170
|
$ignore_directories[$index] = preg_quote($ignore_directory, '/');
|
2171
|
}
|
2172
|
|
2173
|
if (!empty($ignore_directories)) {
|
2174
|
$nomask = '/^(\.\.?)|CVS|' . implode('|', $ignore_directories) . '$/';
|
2175
|
}
|
2176
|
}
|
2177
|
|
2178
|
// Merge in defaults.
|
2179
|
$options += array(
|
2180
|
'nomask' => $nomask,
|
2181
|
'callback' => 0,
|
2182
|
'recurse' => TRUE,
|
2183
|
'key' => 'uri',
|
2184
|
'min_depth' => 0,
|
2185
|
);
|
2186
|
|
2187
|
$options['key'] = in_array($options['key'], array('uri', 'filename', 'name')) ? $options['key'] : 'uri';
|
2188
|
$files = array();
|
2189
|
if (is_dir($dir) && $handle = opendir($dir)) {
|
2190
|
while (FALSE !== ($filename = readdir($handle))) {
|
2191
|
if (!preg_match($options['nomask'], $filename) && $filename[0] != '.') {
|
2192
|
$uri = "$dir/$filename";
|
2193
|
$uri = file_stream_wrapper_uri_normalize($uri);
|
2194
|
if (is_dir($uri) && $options['recurse']) {
|
2195
|
// Give priority to files in this folder by merging them in after any subdirectory files.
|
2196
|
$files = array_merge(file_scan_directory($uri, $mask, $options, $depth + 1), $files);
|
2197
|
}
|
2198
|
elseif ($depth >= $options['min_depth'] && preg_match($mask, $filename)) {
|
2199
|
// Always use this match over anything already set in $files with the
|
2200
|
// same $$options['key'].
|
2201
|
$file = new stdClass();
|
2202
|
$file->uri = $uri;
|
2203
|
$file->filename = $filename;
|
2204
|
$file->name = pathinfo($filename, PATHINFO_FILENAME);
|
2205
|
$key = $options['key'];
|
2206
|
$files[$file->$key] = $file;
|
2207
|
if ($options['callback']) {
|
2208
|
$options['callback']($uri);
|
2209
|
}
|
2210
|
}
|
2211
|
}
|
2212
|
}
|
2213
|
|
2214
|
closedir($handle);
|
2215
|
}
|
2216
|
|
2217
|
return $files;
|
2218
|
}
|
2219
|
|
2220
|
/**
|
2221
|
* Determines the maximum file upload size by querying the PHP settings.
|
2222
|
*
|
2223
|
* @return
|
2224
|
* A file size limit in bytes based on the PHP upload_max_filesize and
|
2225
|
* post_max_size
|
2226
|
*/
|
2227
|
function file_upload_max_size() {
|
2228
|
static $max_size = -1;
|
2229
|
|
2230
|
if ($max_size < 0) {
|
2231
|
// Start with post_max_size.
|
2232
|
$max_size = parse_size(ini_get('post_max_size'));
|
2233
|
|
2234
|
// If upload_max_size is less, then reduce. Except if upload_max_size is
|
2235
|
// zero, which indicates no limit.
|
2236
|
$upload_max = parse_size(ini_get('upload_max_filesize'));
|
2237
|
if ($upload_max > 0 && $upload_max < $max_size) {
|
2238
|
$max_size = $upload_max;
|
2239
|
}
|
2240
|
}
|
2241
|
return $max_size;
|
2242
|
}
|
2243
|
|
2244
|
/**
|
2245
|
* Determines an Internet Media Type or MIME type from a filename.
|
2246
|
*
|
2247
|
* @param $uri
|
2248
|
* A string containing the URI, path, or filename.
|
2249
|
* @param $mapping
|
2250
|
* An optional map of extensions to their mimetypes, in the form:
|
2251
|
* - 'mimetypes': a list of mimetypes, keyed by an identifier,
|
2252
|
* - 'extensions': the mapping itself, an associative array in which
|
2253
|
* the key is the extension (lowercase) and the value is the mimetype
|
2254
|
* identifier. If $mapping is NULL file_mimetype_mapping() is called.
|
2255
|
*
|
2256
|
* @return
|
2257
|
* The internet media type registered for the extension or
|
2258
|
* application/octet-stream for unknown extensions.
|
2259
|
*
|
2260
|
* @see file_default_mimetype_mapping()
|
2261
|
*/
|
2262
|
function file_get_mimetype($uri, $mapping = NULL) {
|
2263
|
if ($wrapper = file_stream_wrapper_get_instance_by_uri($uri)) {
|
2264
|
return $wrapper->getMimeType($uri, $mapping);
|
2265
|
}
|
2266
|
else {
|
2267
|
// getMimeType() is not implementation specific, so we can directly
|
2268
|
// call it without an instance.
|
2269
|
return DrupalLocalStreamWrapper::getMimeType($uri, $mapping);
|
2270
|
}
|
2271
|
}
|
2272
|
|
2273
|
/**
|
2274
|
* Sets the permissions on a file or directory.
|
2275
|
*
|
2276
|
* This function will use the 'file_chmod_directory' and 'file_chmod_file'
|
2277
|
* variables for the default modes for directories and uploaded/generated
|
2278
|
* files. By default these will give everyone read access so that users
|
2279
|
* accessing the files with a user account without the webserver group (e.g.
|
2280
|
* via FTP) can read these files, and give group write permissions so webserver
|
2281
|
* group members (e.g. a vhost account) can alter files uploaded and owned by
|
2282
|
* the webserver.
|
2283
|
*
|
2284
|
* PHP's chmod does not support stream wrappers so we use our wrapper
|
2285
|
* implementation which interfaces with chmod() by default. Contrib wrappers
|
2286
|
* may override this behavior in their implementations as needed.
|
2287
|
*
|
2288
|
* @param $uri
|
2289
|
* A string containing a URI file, or directory path.
|
2290
|
* @param $mode
|
2291
|
* Integer value for the permissions. Consult PHP chmod() documentation for
|
2292
|
* more information.
|
2293
|
*
|
2294
|
* @return
|
2295
|
* TRUE for success, FALSE in the event of an error.
|
2296
|
*
|
2297
|
* @ingroup php_wrappers
|
2298
|
*/
|
2299
|
function drupal_chmod($uri, $mode = NULL) {
|
2300
|
if (!isset($mode)) {
|
2301
|
if (is_dir($uri)) {
|
2302
|
$mode = variable_get('file_chmod_directory', 0775);
|
2303
|
}
|
2304
|
else {
|
2305
|
$mode = variable_get('file_chmod_file', 0664);
|
2306
|
}
|
2307
|
}
|
2308
|
|
2309
|
// If this URI is a stream, pass it off to the appropriate stream wrapper.
|
2310
|
// Otherwise, attempt PHP's chmod. This allows use of drupal_chmod even
|
2311
|
// for unmanaged files outside of the stream wrapper interface.
|
2312
|
if ($wrapper = file_stream_wrapper_get_instance_by_uri($uri)) {
|
2313
|
if ($wrapper->chmod($mode)) {
|
2314
|
return TRUE;
|
2315
|
}
|
2316
|
}
|
2317
|
else {
|
2318
|
if (@chmod($uri, $mode)) {
|
2319
|
return TRUE;
|
2320
|
}
|
2321
|
}
|
2322
|
|
2323
|
watchdog('file', 'The file permissions could not be set on %uri.', array('%uri' => $uri), WATCHDOG_ERROR);
|
2324
|
return FALSE;
|
2325
|
}
|
2326
|
|
2327
|
/**
|
2328
|
* Deletes a file.
|
2329
|
*
|
2330
|
* PHP's unlink() is broken on Windows, as it can fail to remove a file
|
2331
|
* when it has a read-only flag set.
|
2332
|
*
|
2333
|
* @param $uri
|
2334
|
* A URI or pathname.
|
2335
|
* @param $context
|
2336
|
* Refer to http://php.net/manual/ref.stream.php
|
2337
|
*
|
2338
|
* @return
|
2339
|
* Boolean TRUE on success, or FALSE on failure.
|
2340
|
*
|
2341
|
* @see unlink()
|
2342
|
* @ingroup php_wrappers
|
2343
|
*/
|
2344
|
function drupal_unlink($uri, $context = NULL) {
|
2345
|
$scheme = file_uri_scheme($uri);
|
2346
|
if ((!$scheme || !file_stream_wrapper_valid_scheme($scheme)) && (substr(PHP_OS, 0, 3) == 'WIN')) {
|
2347
|
chmod($uri, 0600);
|
2348
|
}
|
2349
|
if ($context) {
|
2350
|
return unlink($uri, $context);
|
2351
|
}
|
2352
|
else {
|
2353
|
return unlink($uri);
|
2354
|
}
|
2355
|
}
|
2356
|
|
2357
|
/**
|
2358
|
* Resolves the absolute filepath of a local URI or filepath.
|
2359
|
*
|
2360
|
* The use of drupal_realpath() is discouraged, because it does not work for
|
2361
|
* remote URIs. Except in rare cases, URIs should not be manually resolved.
|
2362
|
*
|
2363
|
* Only use this function if you know that the stream wrapper in the URI uses
|
2364
|
* the local file system, and you need to pass an absolute path to a function
|
2365
|
* that is incompatible with stream URIs.
|
2366
|
*
|
2367
|
* @param string $uri
|
2368
|
* A stream wrapper URI or a filepath, possibly including one or more symbolic
|
2369
|
* links.
|
2370
|
*
|
2371
|
* @return string|false
|
2372
|
* The absolute local filepath (with no symbolic links), or FALSE on failure.
|
2373
|
*
|
2374
|
* @see DrupalStreamWrapperInterface::realpath()
|
2375
|
* @see http://php.net/manual/function.realpath.php
|
2376
|
* @ingroup php_wrappers
|
2377
|
*/
|
2378
|
function drupal_realpath($uri) {
|
2379
|
// If this URI is a stream, pass it off to the appropriate stream wrapper.
|
2380
|
// Otherwise, attempt PHP's realpath. This allows use of drupal_realpath even
|
2381
|
// for unmanaged files outside of the stream wrapper interface.
|
2382
|
if ($wrapper = file_stream_wrapper_get_instance_by_uri($uri)) {
|
2383
|
return $wrapper->realpath();
|
2384
|
}
|
2385
|
// Check that the URI has a value. There is a bug in PHP 5.2 on *BSD systems
|
2386
|
// that makes realpath not return FALSE as expected when passing an empty
|
2387
|
// variable.
|
2388
|
// @todo Remove when Drupal drops support for PHP 5.2.
|
2389
|
elseif (!empty($uri)) {
|
2390
|
return realpath($uri);
|
2391
|
}
|
2392
|
return FALSE;
|
2393
|
}
|
2394
|
|
2395
|
/**
|
2396
|
* Gets the name of the directory from a given path.
|
2397
|
*
|
2398
|
* PHP's dirname() does not properly pass streams, so this function fills
|
2399
|
* that gap. It is backwards compatible with normal paths and will use
|
2400
|
* PHP's dirname() as a fallback.
|
2401
|
*
|
2402
|
* Compatibility: normal paths and stream wrappers.
|
2403
|
*
|
2404
|
* @param $uri
|
2405
|
* A URI or path.
|
2406
|
*
|
2407
|
* @return
|
2408
|
* A string containing the directory name.
|
2409
|
*
|
2410
|
* @see dirname()
|
2411
|
* @see http://drupal.org/node/515192
|
2412
|
* @ingroup php_wrappers
|
2413
|
*/
|
2414
|
function drupal_dirname($uri) {
|
2415
|
$scheme = file_uri_scheme($uri);
|
2416
|
|
2417
|
if ($scheme && file_stream_wrapper_valid_scheme($scheme)) {
|
2418
|
return file_stream_wrapper_get_instance_by_scheme($scheme)->dirname($uri);
|
2419
|
}
|
2420
|
else {
|
2421
|
return dirname($uri);
|
2422
|
}
|
2423
|
}
|
2424
|
|
2425
|
/**
|
2426
|
* Gets the filename from a given path.
|
2427
|
*
|
2428
|
* PHP's basename() does not properly support streams or filenames beginning
|
2429
|
* with a non-US-ASCII character.
|
2430
|
*
|
2431
|
* @see http://bugs.php.net/bug.php?id=37738
|
2432
|
* @see basename()
|
2433
|
*
|
2434
|
* @ingroup php_wrappers
|
2435
|
*/
|
2436
|
function drupal_basename($uri, $suffix = NULL) {
|
2437
|
$separators = '/';
|
2438
|
if (DIRECTORY_SEPARATOR != '/') {
|
2439
|
// For Windows OS add special separator.
|
2440
|
$separators .= DIRECTORY_SEPARATOR;
|
2441
|
}
|
2442
|
// Remove right-most slashes when $uri points to directory.
|
2443
|
$uri = rtrim($uri, $separators);
|
2444
|
// Returns the trailing part of the $uri starting after one of the directory
|
2445
|
// separators.
|
2446
|
$filename = preg_match('@[^' . preg_quote($separators, '@') . ']+$@', $uri, $matches) ? $matches[0] : '';
|
2447
|
// Cuts off a suffix from the filename.
|
2448
|
if ($suffix) {
|
2449
|
$filename = preg_replace('@' . preg_quote($suffix, '@') . '$@', '', $filename);
|
2450
|
}
|
2451
|
return $filename;
|
2452
|
}
|
2453
|
|
2454
|
/**
|
2455
|
* Creates a directory using Drupal's default mode.
|
2456
|
*
|
2457
|
* PHP's mkdir() does not respect Drupal's default permissions mode. If a mode
|
2458
|
* is not provided, this function will make sure that Drupal's is used.
|
2459
|
*
|
2460
|
* Compatibility: normal paths and stream wrappers.
|
2461
|
*
|
2462
|
* @param $uri
|
2463
|
* A URI or pathname.
|
2464
|
* @param $mode
|
2465
|
* By default the Drupal mode is used.
|
2466
|
* @param $recursive
|
2467
|
* Default to FALSE.
|
2468
|
* @param $context
|
2469
|
* Refer to http://php.net/manual/ref.stream.php
|
2470
|
*
|
2471
|
* @return
|
2472
|
* Boolean TRUE on success, or FALSE on failure.
|
2473
|
*
|
2474
|
* @see mkdir()
|
2475
|
* @see http://drupal.org/node/515192
|
2476
|
* @ingroup php_wrappers
|
2477
|
*/
|
2478
|
function drupal_mkdir($uri, $mode = NULL, $recursive = FALSE, $context = NULL) {
|
2479
|
if (!isset($mode)) {
|
2480
|
$mode = variable_get('file_chmod_directory', 0775);
|
2481
|
}
|
2482
|
|
2483
|
if (!isset($context)) {
|
2484
|
return mkdir($uri, $mode, $recursive);
|
2485
|
}
|
2486
|
else {
|
2487
|
return mkdir($uri, $mode, $recursive, $context);
|
2488
|
}
|
2489
|
}
|
2490
|
|
2491
|
/**
|
2492
|
* Removes a directory.
|
2493
|
*
|
2494
|
* PHP's rmdir() is broken on Windows, as it can fail to remove a directory
|
2495
|
* when it has a read-only flag set.
|
2496
|
*
|
2497
|
* @param $uri
|
2498
|
* A URI or pathname.
|
2499
|
* @param $context
|
2500
|
* Refer to http://php.net/manual/ref.stream.php
|
2501
|
*
|
2502
|
* @return
|
2503
|
* Boolean TRUE on success, or FALSE on failure.
|
2504
|
*
|
2505
|
* @see rmdir()
|
2506
|
* @ingroup php_wrappers
|
2507
|
*/
|
2508
|
function drupal_rmdir($uri, $context = NULL) {
|
2509
|
$scheme = file_uri_scheme($uri);
|
2510
|
if ((!$scheme || !file_stream_wrapper_valid_scheme($scheme)) && (substr(PHP_OS, 0, 3) == 'WIN')) {
|
2511
|
chmod($uri, 0700);
|
2512
|
}
|
2513
|
if ($context) {
|
2514
|
return rmdir($uri, $context);
|
2515
|
}
|
2516
|
else {
|
2517
|
return rmdir($uri);
|
2518
|
}
|
2519
|
}
|
2520
|
|
2521
|
/**
|
2522
|
* Creates a file with a unique filename in the specified directory.
|
2523
|
*
|
2524
|
* PHP's tempnam() does not return a URI like we want. This function
|
2525
|
* will return a URI if given a URI, or it will return a filepath if
|
2526
|
* given a filepath.
|
2527
|
*
|
2528
|
* Compatibility: normal paths and stream wrappers.
|
2529
|
*
|
2530
|
* @param $directory
|
2531
|
* The directory where the temporary filename will be created.
|
2532
|
* @param $prefix
|
2533
|
* The prefix of the generated temporary filename.
|
2534
|
* Note: Windows uses only the first three characters of prefix.
|
2535
|
*
|
2536
|
* @return
|
2537
|
* The new temporary filename, or FALSE on failure.
|
2538
|
*
|
2539
|
* @see tempnam()
|
2540
|
* @see http://drupal.org/node/515192
|
2541
|
* @ingroup php_wrappers
|
2542
|
*/
|
2543
|
function drupal_tempnam($directory, $prefix) {
|
2544
|
$scheme = file_uri_scheme($directory);
|
2545
|
|
2546
|
if ($scheme && file_stream_wrapper_valid_scheme($scheme)) {
|
2547
|
$wrapper = file_stream_wrapper_get_instance_by_scheme($scheme);
|
2548
|
|
2549
|
if ($filename = tempnam($wrapper->getDirectoryPath(), $prefix)) {
|
2550
|
return $scheme . '://' . drupal_basename($filename);
|
2551
|
}
|
2552
|
else {
|
2553
|
return FALSE;
|
2554
|
}
|
2555
|
}
|
2556
|
else {
|
2557
|
// Handle as a normal tempnam() call.
|
2558
|
return tempnam($directory, $prefix);
|
2559
|
}
|
2560
|
}
|
2561
|
|
2562
|
/**
|
2563
|
* Gets the path of system-appropriate temporary directory.
|
2564
|
*/
|
2565
|
function file_directory_temp() {
|
2566
|
$temporary_directory = variable_get('file_temporary_path', NULL);
|
2567
|
|
2568
|
if (empty($temporary_directory)) {
|
2569
|
$directories = array();
|
2570
|
|
2571
|
// Has PHP been set with an upload_tmp_dir?
|
2572
|
if (ini_get('upload_tmp_dir')) {
|
2573
|
$directories[] = ini_get('upload_tmp_dir');
|
2574
|
}
|
2575
|
|
2576
|
// Operating system specific dirs.
|
2577
|
if (substr(PHP_OS, 0, 3) == 'WIN') {
|
2578
|
$directories[] = 'c:\\windows\\temp';
|
2579
|
$directories[] = 'c:\\winnt\\temp';
|
2580
|
}
|
2581
|
else {
|
2582
|
$directories[] = '/tmp';
|
2583
|
}
|
2584
|
// PHP may be able to find an alternative tmp directory.
|
2585
|
// This function exists in PHP 5 >= 5.2.1, but Drupal
|
2586
|
// requires PHP 5 >= 5.2.0, so we check for it.
|
2587
|
if (function_exists('sys_get_temp_dir')) {
|
2588
|
$directories[] = sys_get_temp_dir();
|
2589
|
}
|
2590
|
|
2591
|
foreach ($directories as $directory) {
|
2592
|
if (is_dir($directory) && is_writable($directory)) {
|
2593
|
$temporary_directory = $directory;
|
2594
|
break;
|
2595
|
}
|
2596
|
}
|
2597
|
|
2598
|
if (empty($temporary_directory)) {
|
2599
|
// If no directory has been found default to 'files/tmp'.
|
2600
|
$temporary_directory = variable_get('file_public_path', conf_path() . '/files') . '/tmp';
|
2601
|
|
2602
|
// Windows accepts paths with either slash (/) or backslash (\), but will
|
2603
|
// not accept a path which contains both a slash and a backslash. Since
|
2604
|
// the 'file_public_path' variable may have either format, we sanitize
|
2605
|
// everything to use slash which is supported on all platforms.
|
2606
|
$temporary_directory = str_replace('\\', '/', $temporary_directory);
|
2607
|
}
|
2608
|
// Save the path of the discovered directory.
|
2609
|
variable_set('file_temporary_path', $temporary_directory);
|
2610
|
}
|
2611
|
|
2612
|
return $temporary_directory;
|
2613
|
}
|
2614
|
|
2615
|
/**
|
2616
|
* Examines a file object and returns appropriate content headers for download.
|
2617
|
*
|
2618
|
* @param $file
|
2619
|
* A file object.
|
2620
|
*
|
2621
|
* @return
|
2622
|
* An associative array of headers, as expected by file_transfer().
|
2623
|
*/
|
2624
|
function file_get_content_headers($file) {
|
2625
|
$type = mime_header_encode($file->filemime);
|
2626
|
|
2627
|
return array(
|
2628
|
'Content-Type' => $type,
|
2629
|
'Content-Length' => $file->filesize,
|
2630
|
'Cache-Control' => 'private',
|
2631
|
);
|
2632
|
}
|
2633
|
|
2634
|
/**
|
2635
|
* @} End of "defgroup file".
|
2636
|
*/
|