← Back to branch summary

~azzar1/unity/add-show-desktop-key

« back to all changes in this revision

Viewing changes to www/php/phpBB3/includes/functions_upload.php

  • Committer: William Grant
  • Date: 2009-02-23 23:47:02 UTC
  • mfrom: (1099.1.211 new-dispatch)
  • Revision ID: grantw@unimelb.edu.au-20090223234702-db4b1llly46ignwo
Merge from lp:~ivle-dev/ivle/new-dispatch.

Pretty much everything changes. Reread the setup docs. Backup your databases.
Every file is now in a different installed location, the configuration system
is rewritten, the dispatch system is rewritten, URLs are different, the
database is different, worksheets and exercises are no longer on the
filesystem, we use a templating engine, jail service protocols are rewritten,
we don't repeat ourselves, we have authorization rewritten, phpBB is gone,
and probably lots of other things that I cannot remember.

This is certainly the biggest commit I have ever made, and hopefully
the largest I ever will.

Show diffs side-by-side

added added

removed removed

Lines of Context:
www/php/phpBB3/includes/functions_upload.php
1
 
<?php
2
 
/**
3
 
*
4
 
* @package phpBB3
5
 
* @version $Id: functions_upload.php,v 1.40 2007/10/05 14:30:11 acydburn Exp $
6
 
* @copyright (c) 2005 phpBB Group
7
 
* @license http://opensource.org/licenses/gpl-license.php GNU Public License
8
 
*
9
 
*/
10
 
 
11
 
/**
12
 
* @ignore
13
 
*/
14
 
if (!defined('IN_PHPBB'))
15
 
{
16
 
        exit;
17
 
}
18
 
 
19
 
/**
20
 
* Responsible for holding all file relevant information, as well as doing file-specific operations.
21
 
* The {@link fileupload fileupload class} can be used to upload several files, each of them being this object to operate further on.
22
 
* @package phpBB3
23
 
*/
24
 
class filespec
25
 
{
26
 
        var $filename = '';
27
 
        var $realname = '';
28
 
        var $uploadname = '';
29
 
        var $mimetype = '';
30
 
        var $extension = '';
31
 
        var $filesize = 0;
32
 
        var $width = 0;
33
 
        var $height = 0;
34
 
        var $image_info = array();
35
 
 
36
 
        var $destination_file = '';
37
 
        var $destination_path = '';
38
 
 
39
 
        var $file_moved = false;
40
 
        var $init_error = false;
41
 
        var $local = false;
42
 
 
43
 
        var $error = array();
44
 
 
45
 
        var $upload = '';
46
 
 
47
 
        /**
48
 
        * File Class
49
 
        * @access private
50
 
        */
51
 
        function filespec($upload_ary, $upload_namespace)
52
 
        {
53
 
                if (!isset($upload_ary))
54
 
                {
55
 
                        $this->init_error = true;
56
 
                        return;
57
 
                }
58
 
 
59
 
                $this->filename = $upload_ary['tmp_name'];
60
 
                $this->filesize = $upload_ary['size'];
61
 
                $name = trim(htmlspecialchars(basename($upload_ary['name'])));
62
 
                $this->realname = $this->uploadname = (STRIP) ? stripslashes($name) : $name;
63
 
                $this->mimetype = $upload_ary['type'];
64
 
 
65
 
                // Opera adds the name to the mime type
66
 
                $this->mimetype = (strpos($this->mimetype, '; name') !== false) ? str_replace(strstr($this->mimetype, '; name'), '', $this->mimetype) : $this->mimetype;
67
 
 
68
 
                if (!$this->mimetype)
69
 
                {
70
 
                        $this->mimetype = 'application/octetstream';
71
 
                }
72
 
 
73
 
                $this->extension = strtolower($this->get_extension($this->realname));
74
 
 
75
 
                // Try to get real filesize from temporary folder (not always working) ;)
76
 
                $this->filesize = (@filesize($this->filename)) ? @filesize($this->filename) : $this->filesize;
77
 
 
78
 
                $this->width = $this->height = 0;
79
 
                $this->file_moved = false;
80
 
 
81
 
                $this->local = (isset($upload_ary['local_mode'])) ? true : false;
82
 
                $this->upload = $upload_namespace;
83
 
        }
84
 
 
85
 
        /**
86
 
        * Cleans destination filename
87
 
        *
88
 
        * @param real|unique|unique_ext $mode real creates a realname, filtering some characters, lowering every character. Unique creates an unique filename
89
 
        * @param string $prefix Prefix applied to filename
90
 
        * @access public
91
 
        */
92
 
        function clean_filename($mode = 'unique', $prefix = '', $user_id = '')
93
 
        {
94
 
                if ($this->init_error)
95
 
                {
96
 
                        return;
97
 
                }
98
 
 
99
 
                switch ($mode)
100
 
                {
101
 
                        case 'real':
102
 
                                // Remove every extension from filename (to not let the mime bug being exposed)
103
 
                                if (strpos($this->realname, '.') !== false)
104
 
                                {
105
 
                                        $this->realname = substr($this->realname, 0, strpos($this->realname, '.'));
106
 
                                }
107
 
 
108
 
                                // Replace any chars which may cause us problems with _
109
 
                                $bad_chars = array("'", "\\", ' ', '/', ':', '*', '?', '"', '<', '>', '|');
110
 
 
111
 
                                $this->realname = rawurlencode(str_replace($bad_chars, '_', strtolower($this->realname)));
112
 
                                $this->realname = preg_replace("/%(\w{2})/", '_', $this->realname);
113
 
 
114
 
                                $this->realname = $prefix . $this->realname . '.' . $this->extension;
115
 
                        break;
116
 
 
117
 
                        case 'unique':
118
 
                                $this->realname = $prefix . md5(unique_id());
119
 
                        break;
120
 
 
121
 
                        case 'avatar':
122
 
                                $this->extension = strtolower($this->extension);
123
 
                                $this->realname = $prefix . $user_id . '.' . $this->extension;
124
 
                                
125
 
                        break;
126
 
                        
127
 
                        case 'unique_ext':
128
 
                        default:
129
 
                                $this->realname = $prefix . md5(unique_id()) . '.' . $this->extension;
130
 
                        break;
131
 
                }
132
 
        }
133
 
 
134
 
        /**
135
 
        * Get property from file object
136
 
        */
137
 
        function get($property)
138
 
        {
139
 
                if ($this->init_error || !isset($this->$property))
140
 
                {
141
 
                        return false;
142
 
                }
143
 
 
144
 
                return $this->$property;
145
 
        }
146
 
 
147
 
        /**
148
 
        * Check if file is an image (mimetype)
149
 
        *
150
 
        * @return true if it is an image, false if not
151
 
        */
152
 
        function is_image()
153
 
        {
154
 
                return (strpos($this->mimetype, 'image/') !== false) ? true : false;
155
 
        }
156
 
 
157
 
        /**
158
 
        * Check if the file got correctly uploaded
159
 
        *
160
 
        * @return true if it is a valid upload, false if not
161
 
        */
162
 
        function is_uploaded()
163
 
        {
164
 
                if (!$this->local && !is_uploaded_file($this->filename))
165
 
                {
166
 
                        return false;
167
 
                }
168
 
 
169
 
                if ($this->local && !file_exists($this->filename))
170
 
                {
171
 
                        return false;
172
 
                }
173
 
 
174
 
                return true;
175
 
        }
176
 
 
177
 
        /**
178
 
        * Remove file
179
 
        */
180
 
        function remove()
181
 
        {
182
 
                if ($this->file_moved)
183
 
                {
184
 
                        @unlink($this->destination_file);
185
 
                }
186
 
        }
187
 
 
188
 
        /**
189
 
        * Get file extension
190
 
        */
191
 
        function get_extension($filename)
192
 
        {
193
 
                if (strpos($filename, '.') === false)
194
 
                {
195
 
                        return '';
196
 
                }
197
 
 
198
 
                $filename = explode('.', $filename);
199
 
                return array_pop($filename);
200
 
        }
201
 
 
202
 
        /**
203
 
        * Get mimetype. Utilize mime_content_type if the function exist.
204
 
        * Not used at the moment...
205
 
        */
206
 
        function get_mimetype($filename)
207
 
        {
208
 
                $mimetype = '';
209
 
 
210
 
                if (function_exists('mime_content_type'))
211
 
                {
212
 
                        $mimetype = mime_content_type($filename);
213
 
                }
214
 
 
215
 
                // Some browsers choke on a mimetype of application/octet-stream
216
 
                if (!$mimetype || $mimetype == 'application/octet-stream')
217
 
                {
218
 
                        $mimetype = 'application/octetstream';
219
 
                }
220
 
 
221
 
                return $mimetype;
222
 
        }
223
 
 
224
 
        /**
225
 
        * Get filesize
226
 
        */
227
 
        function get_filesize($filename)
228
 
        {
229
 
                return @filesize($filename);
230
 
        }
231
 
 
232
 
        /**
233
 
        * Move file to destination folder
234
 
        * The phpbb_root_path variable will be applied to the destination path
235
 
        *
236
 
        * @param string $destination_path Destination path, for example $config['avatar_path']
237
 
        * @param bool $overwrite If set to true, an already existing file will be overwritten
238
 
        * @param octal $chmod Permission mask for chmodding the file after a successful move
239
 
        * @access public
240
 
        */
241
 
        function move_file($destination, $overwrite = false, $skip_image_check = false, $chmod = 0666)
242
 
        {
243
 
                global $user, $phpbb_root_path;
244
 
 
245
 
                if (sizeof($this->error))
246
 
                {
247
 
                        return false;
248
 
                }
249
 
 
250
 
                // We need to trust the admin in specifying valid upload directories and an attacker not being able to overwrite it...
251
 
                $this->destination_path = $phpbb_root_path . $destination;
252
 
 
253
 
                // Check if the destination path exist...
254
 
                if (!file_exists($this->destination_path))
255
 
                {
256
 
                        @unlink($this->filename);
257
 
                        return false;
258
 
                }
259
 
 
260
 
                $upload_mode = (@ini_get('open_basedir') || @ini_get('safe_mode')) ? 'move' : 'copy';
261
 
                $upload_mode = ($this->local) ? 'local' : $upload_mode;
262
 
                $this->destination_file = $this->destination_path . '/' . basename($this->realname);
263
 
 
264
 
                // Check if the file already exist, else there is something wrong...
265
 
                if (file_exists($this->destination_file) && !$overwrite)
266
 
                {
267
 
                        @unlink($this->filename);
268
 
                }
269
 
                else
270
 
                {
271
 
                        if (file_exists($this->destination_file))
272
 
                        {
273
 
                                @unlink($this->destination_file);
274
 
                        }
275
 
 
276
 
                        switch ($upload_mode)
277
 
                        {
278
 
                                case 'copy':
279
 
 
280
 
                                        if (!@copy($this->filename, $this->destination_file))
281
 
                                        {
282
 
                                                if (!@move_uploaded_file($this->filename, $this->destination_file))
283
 
                                                {
284
 
                                                        $this->error[] = sprintf($user->lang[$this->upload->error_prefix . 'GENERAL_UPLOAD_ERROR'], $this->destination_file);
285
 
                                                        return false;
286
 
                                                }
287
 
                                        }
288
 
 
289
 
                                        @unlink($this->filename);
290
 
 
291
 
                                break;
292
 
 
293
 
                                case 'move':
294
 
 
295
 
                                        if (!@move_uploaded_file($this->filename, $this->destination_file))
296
 
                                        {
297
 
                                                if (!@copy($this->filename, $this->destination_file))
298
 
                                                {
299
 
                                                        $this->error[] = sprintf($user->lang[$this->upload->error_prefix . 'GENERAL_UPLOAD_ERROR'], $this->destination_file);
300
 
                                                        return false;
301
 
                                                }
302
 
                                        }
303
 
 
304
 
                                        @unlink($this->filename);
305
 
 
306
 
                                break;
307
 
 
308
 
                                case 'local':
309
 
 
310
 
                                        if (!@copy($this->filename, $this->destination_file))
311
 
                                        {
312
 
                                                $this->error[] = sprintf($user->lang[$this->upload->error_prefix . 'GENERAL_UPLOAD_ERROR'], $this->destination_file);
313
 
                                                return false;
314
 
                                        }
315
 
                                        @unlink($this->filename);
316
 
 
317
 
                                break;
318
 
                        }
319
 
 
320
 
                        @chmod($this->destination_file, $chmod);
321
 
                }
322
 
 
323
 
                // Try to get real filesize from destination folder
324
 
                $this->filesize = (@filesize($this->destination_file)) ? @filesize($this->destination_file) : $this->filesize;
325
 
 
326
 
                if ($this->is_image() && !$skip_image_check)
327
 
                {
328
 
                        $this->width = $this->height = 0;
329
 
 
330
 
                        if (($this->image_info = @getimagesize($this->destination_file)) !== false)
331
 
                        {
332
 
                                $this->width = $this->image_info[0];
333
 
                                $this->height = $this->image_info[1];
334
 
 
335
 
                                if (!empty($this->image_info['mime']))
336
 
                                {
337
 
                                        $this->mimetype = $this->image_info['mime'];
338
 
                                }
339
 
 
340
 
                                // Check image type
341
 
                                $types = $this->upload->image_types();
342
 
 
343
 
                                if (!isset($types[$this->image_info[2]]) || !in_array($this->extension, $types[$this->image_info[2]]))
344
 
                                {
345
 
                                        if (!isset($types[$this->image_info[2]]))
346
 
                                        {
347
 
                                                $this->error[] = sprintf($user->lang['IMAGE_FILETYPE_INVALID'], $this->image_info[2], $this->mimetype);
348
 
                                        }
349
 
                                        else
350
 
                                        {
351
 
                                                $this->error[] = sprintf($user->lang['IMAGE_FILETYPE_MISMATCH'], $types[$this->image_info[2]][0], $this->extension);
352
 
                                        }
353
 
                                }
354
 
 
355
 
                                // Make sure the dimensions match a valid image
356
 
                                if (empty($this->width) || empty($this->height))
357
 
                                {
358
 
                                        $this->error[] = $user->lang['ATTACHED_IMAGE_NOT_IMAGE'];
359
 
                                }
360
 
                        }
361
 
                        else
362
 
                        {
363
 
                                $this->error[] = $user->lang['UNABLE_GET_IMAGE_SIZE'];
364
 
                        }
365
 
                }
366
 
 
367
 
                $this->file_moved = true;
368
 
                $this->additional_checks();
369
 
                unset($this->upload);
370
 
 
371
 
                return true;
372
 
        }
373
 
 
374
 
        /**
375
 
        * Performing additional checks
376
 
        */
377
 
        function additional_checks()
378
 
        {
379
 
                global $user;
380
 
 
381
 
                if (!$this->file_moved)
382
 
                {
383
 
                        return false;
384
 
                }
385
 
 
386
 
                // Filesize is too big or it's 0 if it was larger than the maxsize in the upload form
387
 
                if ($this->upload->max_filesize && ($this->get('filesize') > $this->upload->max_filesize || $this->filesize == 0))
388
 
                {
389
 
                        $size_lang = ($this->upload->max_filesize >= 1048576) ? $user->lang['MB'] : (($this->upload->max_filesize >= 1024) ? $user->lang['KB'] : $user->lang['BYTES'] );
390
 
                        $max_filesize = ($this->upload->max_filesize >= 1048576) ? round($this->upload->max_filesize / 1048576 * 100) / 100 : (($this->upload->max_filesize >= 1024) ? round($this->upload->max_filesize / 1024 * 100) / 100 : $this->upload->max_filesize);
391
 
        
392
 
                        $this->error[] = sprintf($user->lang[$this->upload->error_prefix . 'WRONG_FILESIZE'], $max_filesize, $size_lang);
393
 
 
394
 
                        return false;
395
 
                }
396
 
 
397
 
                if (!$this->upload->valid_dimensions($this))
398
 
                {
399
 
                        $this->error[] = sprintf($user->lang[$this->upload->error_prefix . 'WRONG_SIZE'], $this->upload->min_width, $this->upload->min_height, $this->upload->max_width, $this->upload->max_height, $this->width, $this->height);
400
 
 
401
 
                        return false;
402
 
                }
403
 
 
404
 
                return true;
405
 
        }
406
 
}
407
 
 
408
 
/**
409
 
* Class for assigning error messages before a real filespec class can be assigned
410
 
*
411
 
* @package phpBB3
412
 
*/
413
 
class fileerror extends filespec
414
 
{
415
 
        function fileerror($error_msg)
416
 
        {
417
 
                $this->error[] = $error_msg;
418
 
        }
419
 
}
420
 
 
421
 
/**
422
 
* File upload class
423
 
* Init class (all parameters optional and able to be set/overwritten separately) - scope is global and valid for all uploads
424
 
*
425
 
* @package phpBB3
426
 
*/
427
 
class fileupload
428
 
{
429
 
        var $allowed_extensions = array();
430
 
        var $max_filesize = 0;
431
 
        var $min_width = 0;
432
 
        var $min_height = 0;
433
 
        var $max_width = 0;
434
 
        var $max_height = 0;
435
 
        var $error_prefix = '';
436
 
 
437
 
        /**
438
 
        * Init file upload class.
439
 
        *
440
 
        * @param string $error_prefix Used error messages will get prefixed by this string
441
 
        * @param array $allowed_extensions Array of allowed extensions, for example array('jpg', 'jpeg', 'gif', 'png')
442
 
        * @param int $max_filesize Maximum filesize
443
 
        * @param int $min_width Minimum image width (only checked for images)
444
 
        * @param int $min_height Minimum image height (only checked for images)
445
 
        * @param int $max_width Maximum image width (only checked for images)
446
 
        * @param int $max_height Maximum image height (only checked for images)
447
 
        *
448
 
        */
449
 
        function fileupload($error_prefix = '', $allowed_extensions = false, $max_filesize = false, $min_width = false, $min_height = false, $max_width = false, $max_height = false)
450
 
        {
451
 
                $this->set_allowed_extensions($allowed_extensions);
452
 
                $this->set_max_filesize($max_filesize);
453
 
                $this->set_allowed_dimensions($min_width, $min_height, $max_width, $max_height);
454
 
                $this->set_error_prefix($error_prefix);
455
 
        }
456
 
 
457
 
        /**
458
 
        * Reset vars
459
 
        */
460
 
        function reset_vars()
461
 
        {
462
 
                $this->max_filesize = 0;
463
 
                $this->min_width = $this->min_height = $this->max_width = $this->max_height = 0;
464
 
                $this->error_prefix = '';
465
 
                $this->allowed_extensions = array();
466
 
        }
467
 
 
468
 
        /**
469
 
        * Set allowed extensions
470
 
        */
471
 
        function set_allowed_extensions($allowed_extensions)
472
 
        {
473
 
                if ($allowed_extensions !== false && is_array($allowed_extensions))
474
 
                {
475
 
                        $this->allowed_extensions = $allowed_extensions;
476
 
                }
477
 
        }
478
 
 
479
 
        /**
480
 
        * Set allowed dimensions
481
 
        */
482
 
        function set_allowed_dimensions($min_width, $min_height, $max_width, $max_height)
483
 
        {
484
 
                $this->min_width = (int) $min_width;
485
 
                $this->min_height = (int) $min_height;
486
 
                $this->max_width = (int) $max_width;
487
 
                $this->max_height = (int) $max_height;
488
 
        }
489
 
 
490
 
        /**
491
 
        * Set maximum allowed filesize
492
 
        */
493
 
        function set_max_filesize($max_filesize)
494
 
        {
495
 
                if ($max_filesize !== false && (int) $max_filesize)
496
 
                {
497
 
                        $this->max_filesize = (int) $max_filesize;
498
 
                }
499
 
        }
500
 
 
501
 
        /**
502
 
        * Set error prefix
503
 
        */
504
 
        function set_error_prefix($error_prefix)
505
 
        {
506
 
                $this->error_prefix = $error_prefix;
507
 
        }
508
 
 
509
 
        /**
510
 
        * Form upload method
511
 
        * Upload file from users harddisk
512
 
        *
513
 
        * @param string $form_name Form name assigned to the file input field (if it is an array, the key has to be specified)
514
 
        * @return object $file Object "filespec" is returned, all further operations can be done with this object
515
 
        * @access public
516
 
        */
517
 
        function form_upload($form_name)
518
 
        {
519
 
                global $user;
520
 
 
521
 
                unset($_FILES[$form_name]['local_mode']);
522
 
                $file = new filespec($_FILES[$form_name], $this);
523
 
 
524
 
                if ($file->init_error)
525
 
                {
526
 
                        $file->error[] = '';
527
 
                        return $file;
528
 
                }
529
 
 
530
 
                // Error array filled?
531
 
                if (isset($_FILES[$form_name]['error']))
532
 
                {
533
 
                        $error = $this->assign_internal_error($_FILES[$form_name]['error']);
534
 
 
535
 
                        if ($error !== false)
536
 
                        {
537
 
                                $file->error[] = $error;
538
 
                                return $file;
539
 
                        }
540
 
                }
541
 
 
542
 
                // Check if empty file got uploaded (not catched by is_uploaded_file)
543
 
                if (isset($_FILES[$form_name]['size']) && $_FILES[$form_name]['size'] == 0)
544
 
                {
545
 
                        $file->error[] = $user->lang[$this->error_prefix . 'EMPTY_FILEUPLOAD'];
546
 
                        return $file;
547
 
                }
548
 
 
549
 
                // PHP Upload filesize exceeded
550
 
                if ($file->get('filename') == 'none')
551
 
                {
552
 
                        $file->error[] = (@ini_get('upload_max_filesize') == '') ? $user->lang[$this->error_prefix . 'PHP_SIZE_NA'] : sprintf($user->lang[$this->error_prefix . 'PHP_SIZE_OVERRUN'], @ini_get('upload_max_filesize'));
553
 
                        return $file;
554
 
                }
555
 
 
556
 
                // Not correctly uploaded
557
 
                if (!$file->is_uploaded())
558
 
                {
559
 
                        $file->error[] = $user->lang[$this->error_prefix . 'NOT_UPLOADED'];
560
 
                        return $file;
561
 
                }
562
 
 
563
 
                $this->common_checks($file);
564
 
 
565
 
                return $file;
566
 
        }
567
 
 
568
 
        /**
569
 
        * Move file from another location to phpBB
570
 
        */
571
 
        function local_upload($source_file, $filedata = false)
572
 
        {
573
 
                global $user;
574
 
 
575
 
                $form_name = 'local';
576
 
 
577
 
                $_FILES[$form_name]['local_mode'] = true;
578
 
                $_FILES[$form_name]['tmp_name'] = $source_file;
579
 
 
580
 
                if ($filedata === false)
581
 
                {
582
 
                        $_FILES[$form_name]['name'] = basename($source_file);
583
 
                        $_FILES[$form_name]['size'] = 0;
584
 
                        $mimetype = '';
585
 
 
586
 
                        if (function_exists('mime_content_type'))
587
 
                        {
588
 
                                $mimetype = mime_content_type($source_file);
589
 
                        }
590
 
 
591
 
                        // Some browsers choke on a mimetype of application/octet-stream
592
 
                        if (!$mimetype || $mimetype == 'application/octet-stream')
593
 
                        {
594
 
                                $mimetype = 'application/octetstream';
595
 
                        }
596
 
 
597
 
                        $_FILES[$form_name]['type'] = $mimetype;
598
 
                }
599
 
                else
600
 
                {
601
 
                        $_FILES[$form_name]['name'] = $filedata['realname'];
602
 
                        $_FILES[$form_name]['size'] = $filedata['size'];
603
 
                        $_FILES[$form_name]['type'] = $filedata['type'];
604
 
                }
605
 
 
606
 
                $file = new filespec($_FILES[$form_name], $this);
607
 
 
608
 
                if ($file->init_error)
609
 
                {
610
 
                        $file->error[] = '';
611
 
                        return $file;
612
 
                }
613
 
 
614
 
                if (isset($_FILES[$form_name]['error']))
615
 
                {
616
 
                        $error = $this->assign_internal_error($_FILES[$form_name]['error']);
617
 
 
618
 
                        if ($error !== false)
619
 
                        {
620
 
                                $file->error[] = $error;
621
 
                                return $file;
622
 
                        }
623
 
                }
624
 
 
625
 
                // PHP Upload filesize exceeded
626
 
                if ($file->get('filename') == 'none')
627
 
                {
628
 
                        $file->error[] = (@ini_get('upload_max_filesize') == '') ? $user->lang[$this->error_prefix . 'PHP_SIZE_NA'] : sprintf($user->lang[$this->error_prefix . 'PHP_SIZE_OVERRUN'], @ini_get('upload_max_filesize'));
629
 
                        return $file;
630
 
                }
631
 
 
632
 
                // Not correctly uploaded
633
 
                if (!$file->is_uploaded())
634
 
                {
635
 
                        $file->error[] = $user->lang[$this->error_prefix . 'NOT_UPLOADED'];
636
 
                        return $file;
637
 
                }
638
 
 
639
 
                $this->common_checks($file);
640
 
 
641
 
                return $file;
642
 
        }
643
 
 
644
 
        /**
645
 
        * Remote upload method
646
 
        * Uploads file from given url
647
 
        *
648
 
        * @param string $upload_url URL pointing to file to upload, for example http://www.foobar.com/example.gif
649
 
        * @return object $file Object "filespec" is returned, all further operations can be done with this object
650
 
        * @access public
651
 
        */
652
 
        function remote_upload($upload_url)
653
 
        {
654
 
                global $user, $phpbb_root_path;
655
 
 
656
 
                $upload_ary = array();
657
 
                $upload_ary['local_mode'] = true;
658
 
 
659
 
                if (!preg_match('#^(https?://).*?\.(' . implode('|', $this->allowed_extensions) . ')$#i', $upload_url, $match))
660
 
                {
661
 
                        $file = new fileerror($user->lang[$this->error_prefix . 'URL_INVALID']);
662
 
                        return $file;
663
 
                }
664
 
 
665
 
                if (empty($match[2]))
666
 
                {
667
 
                        $file = new fileerror($user->lang[$this->error_prefix . 'URL_INVALID']);
668
 
                        return $file;
669
 
                }
670
 
 
671
 
                $url = parse_url($upload_url);
672
 
 
673
 
                $host = $url['host'];
674
 
                $path = $url['path'];
675
 
                $port = (!empty($url['port'])) ? (int) $url['port'] : 80;
676
 
 
677
 
                $upload_ary['type'] = 'application/octet-stream';
678
 
 
679
 
                $url['path'] = explode('.', $url['path']);
680
 
                $ext = array_pop($url['path']);
681
 
 
682
 
                $url['path'] = implode('', $url['path']);
683
 
                $upload_ary['name'] = basename($url['path']) . (($ext) ? '.' . $ext : '');
684
 
                $filename = $url['path'];
685
 
                $filesize = 0;
686
 
 
687
 
                $errno = 0;
688
 
                $errstr = '';
689
 
 
690
 
                if (!($fsock = @fsockopen($host, $port, $errno, $errstr)))
691
 
                {
692
 
                        $file = new fileerror($user->lang[$this->error_prefix . 'NOT_UPLOADED']);
693
 
                        return $file;
694
 
                }
695
 
 
696
 
                // Make sure $path not beginning with /
697
 
                if (strpos($path, '/') === 0)
698
 
                {
699
 
                        $path = substr($path, 1);
700
 
                }
701
 
 
702
 
                fputs($fsock, 'GET /' . $path . " HTTP/1.1\r\n");
703
 
                fputs($fsock, "HOST: " . $host . "\r\n");
704
 
                fputs($fsock, "Connection: close\r\n\r\n");
705
 
 
706
 
                $get_info = false;
707
 
                $data = '';
708
 
                while (!@feof($fsock))
709
 
                {
710
 
                        if ($get_info)
711
 
                        {
712
 
                                $data .= @fread($fsock, 1024);
713
 
                        }
714
 
                        else
715
 
                        {
716
 
                                $line = @fgets($fsock, 1024);
717
 
 
718
 
                                if ($line == "\r\n")
719
 
                                {
720
 
                                        $get_info = true;
721
 
                                }
722
 
                                else
723
 
                                {
724
 
                                        if (stripos($line, 'content-type: ') !== false)
725
 
                                        {
726
 
                                                $upload_ary['type'] = rtrim(str_replace('content-type: ', '', strtolower($line)));
727
 
                                        }
728
 
                                        else if (stripos($line, '404 not found') !== false)
729
 
                                        {
730
 
                                                $file = new fileerror($user->lang[$this->error_prefix . 'URL_NOT_FOUND']);
731
 
                                                return $file;
732
 
                                        }
733
 
                                }
734
 
                        }
735
 
                }
736
 
                @fclose($fsock);
737
 
 
738
 
                if (empty($data))
739
 
                {
740
 
                        $file = new fileerror($user->lang[$this->error_prefix . 'EMPTY_REMOTE_DATA']);
741
 
                        return $file;
742
 
                }
743
 
 
744
 
                $tmp_path = (!@ini_get('safe_mode')) ? false : $phpbb_root_path . 'cache';
745
 
                $filename = tempnam($tmp_path, unique_id() . '-');
746
 
 
747
 
                if (!($fp = @fopen($filename, 'wb')))
748
 
                {
749
 
                        $file = new fileerror($user->lang[$this->error_prefix . 'NOT_UPLOADED']);
750
 
                        return $file;
751
 
                }
752
 
 
753
 
                $upload_ary['size'] = fwrite($fp, $data);
754
 
                fclose($fp);
755
 
                unset($data);
756
 
 
757
 
                $upload_ary['tmp_name'] = $filename;
758
 
 
759
 
                $file = new filespec($upload_ary, $this);
760
 
                $this->common_checks($file);
761
 
 
762
 
                return $file;
763
 
        }
764
 
 
765
 
        /**
766
 
        * Assign internal error
767
 
        * @access private
768
 
        */
769
 
        function assign_internal_error($errorcode)
770
 
        {
771
 
                global $user;
772
 
 
773
 
                switch ($errorcode)
774
 
                {
775
 
                        case 1:
776
 
                                $error = (@ini_get('upload_max_filesize') == '') ? $user->lang[$this->error_prefix . 'PHP_SIZE_NA'] : sprintf($user->lang[$this->error_prefix . 'PHP_SIZE_OVERRUN'], @ini_get('upload_max_filesize'));
777
 
                        break;
778
 
 
779
 
                        case 2:
780
 
                                $size_lang = ($this->max_filesize >= 1048576) ? $user->lang['MB'] : (($this->max_filesize >= 1024) ? $user->lang['KB'] : $user->lang['BYTES'] );
781
 
                                $max_filesize = ($this->max_filesize >= 1048576) ? round($this->max_filesize / 1048576 * 100) / 100 : (($this->max_filesize >= 1024) ? round($this->max_filesize / 1024 * 100) / 100 : $this->max_filesize);
782
 
 
783
 
                                $error = sprintf($user->lang[$this->error_prefix . 'WRONG_FILESIZE'], $max_filesize, $size_lang);
784
 
                        break;
785
 
 
786
 
                        case 3:
787
 
                                $error = $user->lang[$this->error_prefix . 'PARTIAL_UPLOAD'];
788
 
                        break;
789
 
 
790
 
                        case 4:
791
 
                                $error = $user->lang[$this->error_prefix . 'NOT_UPLOADED'];
792
 
                        break;
793
 
 
794
 
                        case 6:
795
 
                                $error = 'Temporary folder could not be found. Please check your PHP installation.';
796
 
                        break;
797
 
 
798
 
                        default:
799
 
                                $error = false;
800
 
                        break;
801
 
                }
802
 
 
803
 
                return $error;
804
 
        }
805
 
 
806
 
        /**
807
 
        * Perform common checks
808
 
        */
809
 
        function common_checks(&$file)
810
 
        {
811
 
                global $user;
812
 
 
813
 
                // Filesize is too big or it's 0 if it was larger than the maxsize in the upload form
814
 
                if ($this->max_filesize && ($file->get('filesize') > $this->max_filesize || $file->get('filesize') == 0))
815
 
                {
816
 
                        $size_lang = ($this->max_filesize >= 1048576) ? $user->lang['MB'] : (($this->max_filesize >= 1024) ? $user->lang['KB'] : $user->lang['BYTES'] );
817
 
                        $max_filesize = ($this->max_filesize >= 1048576) ? round($this->max_filesize / 1048576 * 100) / 100 : (($this->max_filesize >= 1024) ? round($this->max_filesize / 1024 * 100) / 100 : $this->max_filesize);
818
 
 
819
 
                        $file->error[] = sprintf($user->lang[$this->error_prefix . 'WRONG_FILESIZE'], $max_filesize, $size_lang);
820
 
                }
821
 
 
822
 
                // check Filename
823
 
                if (preg_match("#[\\/:*?\"<>|]#i", $file->get('realname')))
824
 
                {
825
 
                        $file->error[] = sprintf($user->lang[$this->error_prefix . 'INVALID_FILENAME'], $file->get('realname'));
826
 
                }
827
 
 
828
 
                // Invalid Extension
829
 
                if (!$this->valid_extension($file))
830
 
                {
831
 
                        $file->error[] = sprintf($user->lang[$this->error_prefix . 'DISALLOWED_EXTENSION'], $file->get('extension'));
832
 
                }
833
 
        }
834
 
 
835
 
        /**
836
 
        * Check for allowed extension
837
 
        */
838
 
        function valid_extension(&$file)
839
 
        {
840
 
                return (in_array($file->get('extension'), $this->allowed_extensions)) ? true : false;
841
 
        }
842
 
 
843
 
        /**
844
 
        * Check for allowed dimension
845
 
        */
846
 
        function valid_dimensions(&$file)
847
 
        {
848
 
                if (!$this->max_width && !$this->max_height && !$this->min_width && !$this->min_height)
849
 
                {
850
 
                        return true;
851
 
                }
852
 
 
853
 
                if (($file->get('width') > $this->max_width && $this->max_width) ||
854
 
                        ($file->get('height') > $this->max_height && $this->max_height) ||
855
 
                        ($file->get('width') < $this->min_width && $this->min_width) ||
856
 
                        ($file->get('height') < $this->min_height && $this->min_height))
857
 
                {
858
 
                        return false;
859
 
                }
860
 
 
861
 
                return true;
862
 
        }
863
 
 
864
 
        /**
865
 
        * Check if form upload is valid
866
 
        */
867
 
        function is_valid($form_name)
868
 
        {
869
 
                return (isset($_FILES[$form_name]) && $_FILES[$form_name]['name'] != 'none') ? true : false;
870
 
        }
871
 
 
872
 
        /**
873
 
        * Return image type/extension mapping
874
 
        */
875
 
        function image_types()
876
 
        {
877
 
                return array(
878
 
                        1 => array('gif'),
879
 
                        2 => array('jpg', 'jpeg'),
880
 
                        3 => array('png'),
881
 
                        4 => array('swf'),
882
 
                        5 => array('psd'),
883
 
                        6 => array('bmp'),
884
 
                        7 => array('tif', 'tiff'),
885
 
                        8 => array('tif', 'tiff'),
886
 
                        9 => array('jpg', 'jpeg'),
887
 
                        10 => array('jpg', 'jpeg'),
888
 
                        11 => array('jpg', 'jpeg'),
889
 
                        12 => array('jpg', 'jpeg'),
890
 
                        13 => array('swc'),
891
 
                        14 => array('iff'),
892
 
                        15 => array('wbmp'),
893
 
                        16 => array('xbm'),
894
 
                );
895
 
        }
896
 
}
897
 
 
898
 
?>
 
 
b'\\ No newline at end of file'