]> git.mxchange.org Git - quix0rs-gnu-social.git/blob - classes/File.php
If profile fullname is 0 chars use nickname
[quix0rs-gnu-social.git] / classes / File.php
1 <?php
2 /*
3  * StatusNet - the distributed open-source microblogging tool
4  * Copyright (C) 2008, 2009, StatusNet, Inc.
5  *
6  * This program is free software: you can redistribute it and/or modify
7  * it under the terms of the GNU Affero General Public License as published by
8  * the Free Software Foundation, either version 3 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.     See the
14  * GNU Affero General Public License for more details.
15  *
16  * You should have received a copy of the GNU Affero General Public License
17  * along with this program.     If not, see <http://www.gnu.org/licenses/>.
18  */
19
20 if (!defined('GNUSOCIAL')) { exit(1); }
21
22 /**
23  * Table Definition for file
24  */
25 class File extends Managed_DataObject
26 {
27     public $__table = 'file';                            // table name
28     public $id;                              // int(4)  primary_key not_null
29     public $urlhash;                         // varchar(64)  unique_key
30     public $url;                             // text
31     public $filehash;                        // varchar(64)     indexed
32     public $mimetype;                        // varchar(50)
33     public $size;                            // int(4)
34     public $title;                           // text()
35     public $date;                            // int(4)
36     public $protected;                       // int(4)
37     public $filename;                        // text()
38     public $width;                           // int(4)
39     public $height;                          // int(4)
40     public $modified;                        // timestamp()   not_null default_CURRENT_TIMESTAMP
41
42     const URLHASH_ALG = 'sha256';
43     const FILEHASH_ALG = 'sha256';
44
45     public static function schemaDef()
46     {
47         return array(
48             'fields' => array(
49                 'id' => array('type' => 'serial', 'not null' => true),
50                 'urlhash' => array('type' => 'varchar', 'length' => 64, 'not null' => true, 'description' => 'sha256 of destination URL (url field)'),
51                 'url' => array('type' => 'text', 'description' => 'destination URL after following possible redirections'),
52                 'filehash' => array('type' => 'varchar', 'length' => 64, 'not null' => false, 'description' => 'sha256 of the file contents, only for locally stored files of course'),
53                 'mimetype' => array('type' => 'varchar', 'length' => 50, 'description' => 'mime type of resource'),
54                 'size' => array('type' => 'int', 'description' => 'size of resource when available'),
55                 'title' => array('type' => 'text', 'description' => 'title of resource when available'),
56                 'date' => array('type' => 'int', 'description' => 'date of resource according to http query'),
57                 'protected' => array('type' => 'int', 'description' => 'true when URL is private (needs login)'),
58                 'filename' => array('type' => 'text', 'description' => 'if file is stored locally (too) this is the filename'),
59                 'width' => array('type' => 'int', 'description' => 'width in pixels, if it can be described as such and data is available'),
60                 'height' => array('type' => 'int', 'description' => 'height in pixels, if it can be described as such and data is available'),
61
62                 'modified' => array('type' => 'timestamp', 'not null' => true, 'description' => 'date this record was modified'),
63             ),
64             'primary key' => array('id'),
65             'unique keys' => array(
66                 'file_urlhash_key' => array('urlhash'),
67             ),
68             'indexes' => array(
69                 'file_filehash_idx' => array('filehash'),
70             ),
71         );
72     }
73
74     public static function isProtected($url) {
75
76                 $protected_urls_exps = array(
77                         'https://www.facebook.com/login.php',
78                 common_path('main/login')
79                 );
80
81                 foreach ($protected_urls_exps as $protected_url_exp) {
82                         if (preg_match('!^'.preg_quote($protected_url_exp).'(.*)$!i', $url) === 1) {
83                                 return true;
84                         }
85                 }
86
87                 return false;
88     }
89
90     /**
91      * Save a new file record.
92      *
93      * @param array $redir_data lookup data eg from File_redirection::where()
94      * @param string $given_url
95      * @return File
96      */
97     public static function saveNew(array $redir_data, $given_url)
98     {
99         $file = null;
100         try {
101             // I don't know why we have to keep doing this but we run a last check to avoid
102             // uniqueness bugs.
103             $file = File::getByUrl($given_url);
104             return $file;
105         } catch (NoResultException $e) {
106             // We don't have the file's URL since before, so let's continue.
107         }
108
109         $file = new File;
110         $file->url = $given_url;
111         if (!empty($redir_data['protected'])) $file->protected = $redir_data['protected'];
112         if (!empty($redir_data['title'])) $file->title = $redir_data['title'];
113         if (!empty($redir_data['type'])) $file->mimetype = $redir_data['type'];
114         if (!empty($redir_data['size'])) $file->size = intval($redir_data['size']);
115         if (isset($redir_data['time']) && $redir_data['time'] > 0) $file->date = intval($redir_data['time']);
116         $file->saveFile();
117         return $file;
118     }
119
120     public function saveFile() {
121         $this->urlhash = self::hashurl($this->url);
122
123         if (!Event::handle('StartFileSaveNew', array(&$this))) {
124             throw new ServerException('File not saved due to an aborted StartFileSaveNew event.');
125         }
126
127         $this->id = $this->insert();
128
129         if ($this->id === false) {
130             throw new ServerException('File/URL metadata could not be saved to the database.');
131         }
132
133         Event::handle('EndFileSaveNew', array($this));
134     }
135
136     /**
137      * Go look at a URL and possibly save data about it if it's new:
138      * - follow redirect chains and store them in file_redirection
139      * - if a thumbnail is available, save it in file_thumbnail
140      * - save file record with basic info
141      * - optionally save a file_to_post record
142      * - return the File object with the full reference
143      *
144      * @param string $given_url the URL we're looking at
145      * @param Notice $notice (optional)
146      * @param bool $followRedirects defaults to true
147      *
148      * @return mixed File on success, -1 on some errors
149      *
150      * @throws ServerException on failure
151      */
152     public static function processNew($given_url, Notice $notice=null, $followRedirects=true) {
153         if (empty($given_url)) {
154             throw new ServerException('No given URL to process');
155         }
156
157         $given_url = File_redirection::_canonUrl($given_url);
158         if (empty($given_url)) {
159             throw new ServerException('No canonical URL from given URL to process');
160         }
161
162         $redir = File_redirection::where($given_url);
163         $file = $redir->getFile();
164
165         if (!$file instanceof File || empty($file->id)) {
166             // This should not happen
167             throw new ServerException('URL processing failed without new File object');
168         }
169
170         if ($notice instanceof Notice) {
171             File_to_post::processNew($file, $notice);
172         }
173
174         return $file;
175     }
176
177     public static function respectsQuota(Profile $scoped, $fileSize) {
178         if ($fileSize > common_config('attachments', 'file_quota')) {
179             // TRANS: Message used to be inserted as %2$s in  the text "No file may
180             // TRANS: be larger than %1$d byte and the file you sent was %2$s.".
181             // TRANS: %1$d is the number of bytes of an uploaded file.
182             $fileSizeText = sprintf(_m('%1$d byte','%1$d bytes',$fileSize),$fileSize);
183
184             $fileQuota = common_config('attachments', 'file_quota');
185             // TRANS: Message given if an upload is larger than the configured maximum.
186             // TRANS: %1$d (used for plural) is the byte limit for uploads,
187             // TRANS: %2$s is the proper form of "n bytes". This is the only ways to have
188             // TRANS: gettext support multiple plurals in the same message, unfortunately...
189             throw new ClientException(
190                     sprintf(_m('No file may be larger than %1$d byte and the file you sent was %2$s. Try to upload a smaller version.',
191                               'No file may be larger than %1$d bytes and the file you sent was %2$s. Try to upload a smaller version.',
192                               $fileQuota),
193                     $fileQuota, $fileSizeText));
194         }
195
196         $file = new File;
197
198         $query = "select sum(size) as total from file join file_to_post on file_to_post.file_id = file.id join notice on file_to_post.post_id = notice.id where profile_id = {$scoped->id} and file.url like '%/notice/%/file'";
199         $file->query($query);
200         $file->fetch();
201         $total = $file->total + $fileSize;
202         if ($total > common_config('attachments', 'user_quota')) {
203             // TRANS: Message given if an upload would exceed user quota.
204             // TRANS: %d (number) is the user quota in bytes and is used for plural.
205             throw new ClientException(
206                     sprintf(_m('A file this large would exceed your user quota of %d byte.',
207                               'A file this large would exceed your user quota of %d bytes.',
208                               common_config('attachments', 'user_quota')),
209                     common_config('attachments', 'user_quota')));
210         }
211         $query .= ' AND EXTRACT(month FROM file.modified) = EXTRACT(month FROM now()) and EXTRACT(year FROM file.modified) = EXTRACT(year FROM now())';
212         $file->query($query);
213         $file->fetch();
214         $total = $file->total + $fileSize;
215         if ($total > common_config('attachments', 'monthly_quota')) {
216             // TRANS: Message given id an upload would exceed a user's monthly quota.
217             // TRANS: $d (number) is the monthly user quota in bytes and is used for plural.
218             throw new ClientException(
219                     sprintf(_m('A file this large would exceed your monthly quota of %d byte.',
220                               'A file this large would exceed your monthly quota of %d bytes.',
221                               common_config('attachments', 'monthly_quota')),
222                     common_config('attachments', 'monthly_quota')));
223         }
224         return true;
225     }
226
227     public function getFilename()
228     {
229         if (!self::validFilename($this->filename)) {
230             // TRANS: Client exception thrown if a file upload does not have a valid name.
231             throw new ClientException(_("Invalid filename."));
232         }
233         return $this->filename;
234     }
235
236     // where should the file go?
237
238     static function filename(Profile $profile, $origname, $mimetype)
239     {
240         $ext = self::guessMimeExtension($mimetype);
241
242         // Normalize and make the original filename more URL friendly.
243         $origname = basename($origname, ".$ext");
244         if (class_exists('Normalizer')) {
245             // http://php.net/manual/en/class.normalizer.php
246             // http://www.unicode.org/reports/tr15/
247             $origname = Normalizer::normalize($origname, Normalizer::FORM_KC);
248         }
249         $origname = preg_replace('/[^A-Za-z0-9\.\_]/', '_', $origname);
250
251         $nickname = $profile->getNickname();
252         $datestamp = strftime('%Y%m%d', time());
253         do {
254             // generate new random strings until we don't run into a filename collision.
255             $random = strtolower(common_confirmation_code(16));
256             $filename = "$nickname-$datestamp-$origname-$random.$ext";
257         } while (file_exists(self::path($filename)));
258         return $filename;
259     }
260
261     static function guessMimeExtension($mimetype)
262     {
263         try {
264             $ext = common_supported_mime_to_ext($mimetype);
265         } catch (Exception $e) {
266             // We don't support this mimetype, but let's guess the extension
267             $matches = array();
268             if (!preg_match('/\/([a-z0-9]+)/', mb_strtolower($mimetype), $matches)) {
269                 throw new Exception('Malformed mimetype: '.$mimetype);
270             }
271             $ext = $matches[1];
272         }
273         return mb_strtolower($ext);
274     }
275
276     /**
277      * Validation for as-saved base filenames
278      */
279     static function validFilename($filename)
280     {
281         return preg_match('/^[A-Za-z0-9._-]+$/', $filename);
282     }
283
284     /**
285      * @throws ClientException on invalid filename
286      */
287     static function path($filename)
288     {
289         if (!self::validFilename($filename)) {
290             // TRANS: Client exception thrown if a file upload does not have a valid name.
291             throw new ClientException(_("Invalid filename."));
292         }
293         $dir = common_config('attachments', 'dir');
294
295         if ($dir[strlen($dir)-1] != '/') {
296             $dir .= '/';
297         }
298
299         return $dir . $filename;
300     }
301
302     static function url($filename)
303     {
304         if (!self::validFilename($filename)) {
305             // TRANS: Client exception thrown if a file upload does not have a valid name.
306             throw new ClientException(_("Invalid filename."));
307         }
308
309         if (common_config('site','private')) {
310
311             return common_local_url('getfile',
312                                 array('filename' => $filename));
313
314         }
315
316         if (GNUsocial::useHTTPS()) {
317
318             $sslserver = common_config('attachments', 'sslserver');
319
320             if (empty($sslserver)) {
321                 // XXX: this assumes that background dir == site dir + /file/
322                 // not true if there's another server
323                 if (is_string(common_config('site', 'sslserver')) &&
324                     mb_strlen(common_config('site', 'sslserver')) > 0) {
325                     $server = common_config('site', 'sslserver');
326                 } else if (common_config('site', 'server')) {
327                     $server = common_config('site', 'server');
328                 }
329                 $path = common_config('site', 'path') . '/file/';
330             } else {
331                 $server = $sslserver;
332                 $path   = common_config('attachments', 'sslpath');
333                 if (empty($path)) {
334                     $path = common_config('attachments', 'path');
335                 }
336             }
337
338             $protocol = 'https';
339         } else {
340             $path = common_config('attachments', 'path');
341             $server = common_config('attachments', 'server');
342
343             if (empty($server)) {
344                 $server = common_config('site', 'server');
345             }
346
347             $ssl = common_config('attachments', 'ssl');
348
349             $protocol = ($ssl) ? 'https' : 'http';
350         }
351
352         if ($path[strlen($path)-1] != '/') {
353             $path .= '/';
354         }
355
356         if ($path[0] != '/') {
357             $path = '/'.$path;
358         }
359
360         return $protocol.'://'.$server.$path.$filename;
361     }
362
363     static $_enclosures = array();
364
365     function getEnclosure(){
366         if (isset(self::$_enclosures[$this->getID()])) {
367             return self::$_enclosures[$this->getID()];
368         }
369
370         $enclosure = (object) array();
371         foreach (array('title', 'url', 'date', 'modified', 'size', 'mimetype', 'width', 'height') as $key) {
372             if ($this->$key !== '') {
373                 $enclosure->$key = $this->$key;
374             }
375         }
376
377         $needMoreMetadataMimetypes = array(null, 'application/xhtml+xml', 'text/html');
378
379         if (!isset($this->filename) && in_array(common_bare_mime($enclosure->mimetype), $needMoreMetadataMimetypes)) {
380             // This fetches enclosure metadata for non-local links with unset/HTML mimetypes,
381             // which may be enriched through oEmbed or similar (implemented as plugins)
382             Event::handle('FileEnclosureMetadata', array($this, &$enclosure));
383         }
384         if (empty($enclosure->mimetype)) {
385             // This means we either don't know what it is, so it can't
386             // be shown as an enclosure, or it is an HTML link which
387             // does not link to a resource with further metadata.
388             throw new ServerException('Unknown enclosure mimetype, not enough metadata');
389         }
390
391         self::$_enclosures[$this->getID()] = $enclosure;
392         return $enclosure;
393     }
394
395     public function hasThumbnail()
396     {
397         try {
398             $this->getThumbnail();
399         } catch (Exception $e) {
400             return false;
401         }
402         return true;
403     }
404
405     /**
406      * Get the attachment's thumbnail record, if any.
407      * Make sure you supply proper 'int' typed variables (or null).
408      *
409      * @param $width  int   Max width of thumbnail in pixels. (if null, use common_config values)
410      * @param $height int   Max height of thumbnail in pixels. (if null, square-crop to $width)
411      * @param $crop   bool  Crop to the max-values' aspect ratio
412      *
413      * @return File_thumbnail
414      *
415      * @throws UseFileAsThumbnailException  if the file is considered an image itself and should be itself as thumbnail
416      * @throws UnsupportedMediaException    if, despite trying, we can't understand how to make a thumbnail for this format
417      * @throws ServerException              on various other errors
418      */
419     public function getThumbnail($width=null, $height=null, $crop=false, $force_still=true, $upscale=null)
420     {
421         // Get some more information about this file through our ImageFile class
422         $image = ImageFile::fromFileObject($this);
423         if ($image->animated && !common_config('thumbnail', 'animated')) {
424             // null  means "always use file as thumbnail"
425             // false means you get choice between frozen frame or original when calling getThumbnail
426             if (is_null(common_config('thumbnail', 'animated')) || !$force_still) {
427                 throw new UseFileAsThumbnailException($this->id);
428             }
429         }
430
431         return $image->getFileThumbnail($width, $height, $crop,
432                                         !is_null($upscale) ? $upscale : common_config('thumbnail', 'upscale'));
433     }
434
435     public function getPath()
436     {
437         $filepath = self::path($this->filename);
438         if (!file_exists($filepath)) {
439             throw new FileNotFoundException($filepath);
440         }
441         return $filepath;
442     }
443
444     public function getUrl($prefer_local=true)
445     {
446         if ($prefer_local && !empty($this->filename)) {
447             // A locally stored file, so let's generate a URL for our instance.
448             return self::url($this->filename);
449         }
450
451         // No local filename available, return the URL we have stored
452         return $this->url;
453     }
454
455     static public function getByUrl($url)
456     {
457         $file = new File();
458         $file->urlhash = self::hashurl($url);
459         if (!$file->find(true)) {
460             throw new NoResultException($file);
461         }
462         return $file;
463     }
464
465     /**
466      * @param   string  $hashstr    String of (preferrably lower case) hexadecimal characters, same as result of 'hash_file(...)'
467      */
468     static public function getByHash($hashstr)
469     {
470         $file = new File();
471         $file->filehash = strtolower($hashstr);
472         if (!$file->find(true)) {
473             throw new NoResultException($file);
474         }
475         return $file;
476     }
477
478     public function updateUrl($url)
479     {
480         $file = File::getKV('urlhash', self::hashurl($url));
481         if ($file instanceof File) {
482             throw new ServerException('URL already exists in DB');
483         }
484         $sql = 'UPDATE %1$s SET urlhash=%2$s, url=%3$s WHERE urlhash=%4$s;';
485         $result = $this->query(sprintf($sql, $this->tableName(),
486                                              $this->_quote((string)self::hashurl($url)),
487                                              $this->_quote((string)$url),
488                                              $this->_quote((string)$this->urlhash)));
489         if ($result === false) {
490             common_log_db_error($this, 'UPDATE', __FILE__);
491             throw new ServerException("Could not UPDATE {$this->tableName()}.url");
492         }
493
494         return $result;
495     }
496
497     /**
498      * Blow the cache of notices that link to this URL
499      *
500      * @param boolean $last Whether to blow the "last" cache too
501      *
502      * @return void
503      */
504
505     function blowCache($last=false)
506     {
507         self::blow('file:notice-ids:%s', $this->id);
508         if ($last) {
509             self::blow('file:notice-ids:%s;last', $this->id);
510         }
511         self::blow('file:notice-count:%d', $this->id);
512     }
513
514     /**
515      * Stream of notices linking to this URL
516      *
517      * @param integer $offset   Offset to show; default is 0
518      * @param integer $limit    Limit of notices to show
519      * @param integer $since_id Since this notice
520      * @param integer $max_id   Before this notice
521      *
522      * @return array ids of notices that link to this file
523      */
524
525     function stream($offset=0, $limit=NOTICES_PER_PAGE, $since_id=0, $max_id=0)
526     {
527         $stream = new FileNoticeStream($this);
528         return $stream->getNotices($offset, $limit, $since_id, $max_id);
529     }
530
531     function noticeCount()
532     {
533         $cacheKey = sprintf('file:notice-count:%d', $this->id);
534         
535         $count = self::cacheGet($cacheKey);
536
537         if ($count === false) {
538
539             $f2p = new File_to_post();
540
541             $f2p->file_id = $this->id;
542
543             $count = $f2p->count();
544
545             self::cacheSet($cacheKey, $count);
546         } 
547
548         return $count;
549     }
550
551     public function isLocal()
552     {
553         return !empty($this->filename);
554     }
555
556     public function delete($useWhere=false)
557     {
558         // Delete the file, if it exists locally
559         if (!empty($this->filename) && file_exists(self::path($this->filename))) {
560             $deleted = @unlink(self::path($this->filename));
561             if (!$deleted) {
562                 common_log(LOG_ERR, sprintf('Could not unlink existing file: "%s"', self::path($this->filename)));
563             }
564         }
565
566         // Clear out related things in the database and filesystem, such as thumbnails
567         if (Event::handle('FileDeleteRelated', array($this))) {
568             $thumbs = new File_thumbnail();
569             $thumbs->file_id = $this->id;
570             if ($thumbs->find()) {
571                 while ($thumbs->fetch()) {
572                     $thumbs->delete();
573                 }
574             }
575
576             $f2p = new File_to_post();
577             $f2p->file_id = $this->id;
578             if ($f2p->find()) {
579                 while ($f2p->fetch()) {
580                     $f2p->delete();
581                 }
582             }
583         }
584
585         // And finally remove the entry from the database
586         return parent::delete($useWhere);
587     }
588
589     public function getTitle()
590     {
591         $title = $this->title ?: $this->filename;
592
593         return $title ?: null;
594     }
595
596     static public function hashurl($url)
597     {
598         if (empty($url)) {
599             throw new Exception('No URL provided to hash algorithm.');
600         }
601         return hash(self::URLHASH_ALG, $url);
602     }
603
604     static public function beforeSchemaUpdate()
605     {
606         $table = strtolower(get_called_class());
607         $schema = Schema::get();
608         $schemadef = $schema->getTableDef($table);
609
610         // 2015-02-19 We have to upgrade our table definitions to have the urlhash field populated
611         if (isset($schemadef['fields']['urlhash']) && isset($schemadef['unique keys']['file_urlhash_key'])) {
612             // We already have the urlhash field, so no need to migrate it.
613             return;
614         }
615         echo "\nFound old $table table, upgrading it to contain 'urlhash' field...";
616
617         $file = new File();
618         $file->query(sprintf('SELECT id, LEFT(url, 191) AS shortenedurl, COUNT(*) AS c FROM %1$s WHERE LENGTH(url)>191 GROUP BY shortenedurl HAVING c > 1', $schema->quoteIdentifier($table)));
619         print "\nFound {$file->N} URLs with too long entries in file table\n";
620         while ($file->fetch()) {
621             // We've got a URL that is too long for our future file table
622             // so we'll cut it. We could save the original URL, but there is
623             // no guarantee it is complete anyway since the previous max was 255 chars.
624             $dupfile = new File();
625             // First we find file entries that would be duplicates of this when shortened
626             // ... and we'll just throw the dupes out the window for now! It's already so borken.
627             $dupfile->query(sprintf('SELECT * FROM file WHERE LEFT(url, 191) = "%1$s"', $file->shortenedurl));
628             // Leave one of the URLs in the database by using ->find(true) (fetches first entry)
629             if ($dupfile->find(true)) {
630                 print "\nShortening url entry for $table id: {$file->id} [";
631                 $orig = clone($dupfile);
632                 $dupfile->url = $file->shortenedurl;    // make sure it's only 191 chars from now on
633                 $dupfile->update($orig);
634                 print "\nDeleting duplicate entries of too long URL on $table id: {$file->id} [";
635                 // only start deleting with this fetch.
636                 while($dupfile->fetch()) {
637                     print ".";
638                     $dupfile->delete();
639                 }
640                 print "]\n";
641             } else {
642                 print "\nWarning! URL suddenly disappeared from database: {$file->url}\n";
643             }
644         }
645         echo "...and now all the non-duplicates which are longer than 191 characters...\n";
646         $file->query('UPDATE file SET url=LEFT(url, 191) WHERE LENGTH(url)>191');
647
648         echo "\n...now running hacky pre-schemaupdate change for $table:";
649         // We have to create a urlhash that is _not_ the primary key,
650         // transfer data and THEN run checkSchema
651         $schemadef['fields']['urlhash'] = array (
652                                               'type' => 'varchar',
653                                               'length' => 64,
654                                               'not null' => false,  // this is because when adding column, all entries will _be_ NULL!
655                                               'description' => 'sha256 of destination URL (url field)',
656                                             );
657         $schemadef['fields']['url'] = array (
658                                               'type' => 'text',
659                                               'description' => 'destination URL after following possible redirections',
660                                             );
661         unset($schemadef['unique keys']);
662         $schema->ensureTable($table, $schemadef);
663         echo "DONE.\n";
664
665         $classname = ucfirst($table);
666         $tablefix = new $classname;
667         // urlhash is hash('sha256', $url) in the File table
668         echo "Updating urlhash fields in $table table...";
669         // Maybe very MySQL specific :(
670         $tablefix->query(sprintf('UPDATE %1$s SET %2$s=%3$s;',
671                             $schema->quoteIdentifier($table),
672                             'urlhash',
673                             // The line below is "result of sha256 on column `url`"
674                             'SHA2(url, 256)'));
675         echo "DONE.\n";
676         echo "Resuming core schema upgrade...";
677     }
678 }