OSDN Git Service

1a44d4cc854003b5327fdf213778052ae03d8c45
[nucleus-jp/nucleus-jp-ancient.git] / nucleus / libs / MEDIA.php
1 <?php
2 /*
3  * Nucleus: PHP/MySQL Weblog CMS (http://nucleuscms.org/)
4  * Copyright (C) 2002-2011 The Nucleus Group
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  * (see nucleus/documentation/index.html#license for more info)
11  */
12 /**
13  * Media classes for nucleus
14  *
15  * @license http://nucleuscms.org/license.txt GNU General Public License
16  * @copyright Copyright (C) 2002-2011 The Nucleus Group
17  * @version $Id$
18  * $NucleusJP: MEDIA.php,v 1.5 2006/07/17 20:03:44 kimitake Exp $
19  */
20
21 define('PRIVATE_COLLECTION', 'Private Collection');
22 define('READ_ONLY_MEDIA_FOLDER', '(Read Only)');
23
24 /**
25   * Represents the media objects for a certain member
26   */
27 class MEDIA {
28
29         /**
30           * Gets the list of collections available to the currently logged
31           * in member
32           *
33           * @returns array of dirname => display name
34           */
35         function getCollectionList($exceptReadOnly = false) {
36                 global $member, $DIR_MEDIA;
37
38                 $collections = array();
39
40                 // add private directory for member
41                 $collections[$member->getID()] = PRIVATE_COLLECTION;
42                 
43                 // add global collections
44                 if (!is_dir($DIR_MEDIA)) return $collections;
45
46                 $dirhandle = opendir($DIR_MEDIA);
47                 while ($dirname = readdir($dirhandle)) {
48                         // only add non-numeric (numeric=private) dirs
49                         if (@is_dir($DIR_MEDIA . $dirname) &&
50                                 ($dirname != '.') &&
51                                 ($dirname != '..') &&
52                                 ($dirname != 'CVS') &&
53                                 (!is_numeric($dirname)))  {
54                                 if (@is_writable($DIR_MEDIA . $dirname))
55                                         $collections[$dirname] = $dirname;
56                                 else if ($exceptReadOnly == false)
57                                         $collections[$dirname] = $dirname . ' ' . READ_ONLY_MEDIA_FOLDER;
58                         }
59                 }
60                 closedir($dirhandle);
61
62                 return $collections;
63
64         }
65
66         /**
67           * Returns an array of MEDIAOBJECT objects for a certain collection
68           *
69           * @param $collection
70           *             name of the collection
71           * @param $filter
72           *             filter on filename (defaults to none)
73           */
74         function getMediaListByCollection($collection, $filter = '') {
75                 global $DIR_MEDIA;
76
77                 $filelist = array();
78
79                 // 1. go through all objects and add them to the filelist
80
81                 $mediadir = $DIR_MEDIA . $collection . '/';
82
83                 // return if dir does not exist
84                 if (!is_dir($mediadir)) return $filelist;
85
86                 $dirhandle = opendir($mediadir);
87                 while ($filename = readdir($dirhandle)) {
88                         // only add files that match the filter
89                         if (!@is_dir($filename) && MEDIA::checkFilter($filename, $filter))
90                                 array_push($filelist, new MEDIAOBJECT($collection, $filename, filemtime($mediadir . $filename)));
91                 }
92                 closedir($dirhandle);
93
94                 // sort array so newer files are shown first
95                 usort($filelist, 'sort_media');
96
97                 return $filelist;
98         }
99
100         function checkFilter($strText, $strFilter) {
101                 if ($strFilter == '')
102                         return 1;
103                 else
104                         return is_integer(strpos(strtolower($strText), strtolower($strFilter)));
105         }
106
107         /**
108           * checks if a collection exists with the given name, and if it's
109           * allowed for the currently logged in member to upload files to it
110           */
111         function isValidCollection($collectionName, $exceptReadOnly = false) {
112                 global $member, $DIR_MEDIA;
113
114                 // allow creating new private directory
115                 if ($collectionName === (string)$member->getID())
116                         return true;
117                         
118                 $collections = MEDIA::getCollectionList($exceptReadOnly);
119                 $dirname = $collections[$collectionName];
120                 if ($dirname == NULL || $dirname === PRIVATE_COLLECTION)
121                         return false;  
122
123                 // other collections should exist and be writable
124                 $collectionDir = $DIR_MEDIA . $collectionName;
125                 if ($exceptReadOnly)
126                         return (@is_dir($collectionDir) && @is_writable($collectionDir));
127
128                 // other collections should exist
129                 return @is_dir($collectionDir);
130         }
131
132         /**
133           * Adds an uploaded file to the media archive
134           *
135           * @param collection
136           *             collection
137           * @param uploadfile
138           *             the postFileInfo(..) array
139           * @param filename
140           *             the filename that should be used to save the file as
141           *             (date prefix should be already added here)
142           */
143         function addMediaObject($collection, $uploadfile, $filename) {
144                 global $DIR_MEDIA, $manager;
145                 
146                 // clean filename of characters that may cause trouble in a filename using cleanFileName() function from globalfunctions.php
147                 $filename = cleanFileName($filename);
148                 // should already have tested for allowable types before calling this method. This will only catch files with no extension at all
149                 if ($filename === false) 
150                         return _ERROR_BADFILETYPE;
151                 
152                 $manager->notify('PreMediaUpload',array('collection' => &$collection, 'uploadfile' => $uploadfile, 'filename' => &$filename));
153                 
154                 // don't allow uploads to unknown or forbidden collections
155                 $exceptReadOnly = true;
156                 if (!MEDIA::isValidCollection($collection,$exceptReadOnly))
157                         return _ERROR_DISALLOWED;
158
159                 // check dir permissions (try to create dir if it does not exist)
160                 $mediadir = $DIR_MEDIA . $collection;
161
162                 // try to create new private media directories if needed
163                 if (!@is_dir($mediadir) && is_numeric($collection)) {
164                         $oldumask = umask(0000);
165                         if (!@mkdir($mediadir, 0777))
166                                 return _ERROR_BADPERMISSIONS;
167                         umask($oldumask);
168                 }
169
170                 // if dir still not exists, the action is disallowed
171                 if (!@is_dir($mediadir))
172                         return _ERROR_DISALLOWED;
173
174                 if (!is_writeable($mediadir))
175                         return _ERROR_BADPERMISSIONS;
176
177                 // add trailing slash (don't add it earlier since it causes mkdir to fail on some systems)
178                 $mediadir .= '/';
179
180                 if (file_exists($mediadir . $filename))
181                         return _ERROR_UPLOADDUPLICATE;
182
183                 // move file to directory
184                 if (is_uploaded_file($uploadfile)) {
185                         if (!@move_uploaded_file($uploadfile, $mediadir . $filename))
186                                 return _ERROR_UPLOADMOVEP;
187                 } else {
188                         if (!copy($uploadfile, $mediadir . $filename))
189                                 return _ERROR_UPLOADCOPY ;
190                 }
191
192                 // chmod uploaded file
193                 $oldumask = umask(0000);
194                 @chmod($mediadir . $filename, 0644);
195                 umask($oldumask);
196
197                 $manager->notify('PostMediaUpload',array('collection' => $collection, 'mediadir' => $mediadir, 'filename' => $filename));
198
199                 return '';
200
201         }
202
203         /**
204          * Adds an uploaded file to the media dir.
205          *
206          * @param $collection
207          *              collection to use
208          * @param $filename
209          *              the filename that should be used to save the file as
210          *              (date prefix should be already added here)
211          * @param &$data
212          *              File data (binary)
213          *
214          * NOTE: does not check if $collection is valid.
215          */
216         function addMediaObjectRaw($collection, $filename, &$data) {
217                 global $DIR_MEDIA;
218
219                 // check dir permissions (try to create dir if it does not exist)
220                 $mediadir = $DIR_MEDIA . $collection;
221
222                 // try to create new private media directories if needed
223                 if (!@is_dir($mediadir) && is_numeric($collection)) {
224                         $oldumask = umask(0000);
225                         if (!@mkdir($mediadir, 0777))
226                                 return _ERROR_BADPERMISSIONS;
227                         umask($oldumask);
228                 }
229
230                 // if dir still not exists, the action is disallowed
231                 if (!@is_dir($mediadir))
232                         return _ERROR_DISALLOWED;
233
234                 if (!is_writeable($mediadir))
235                         return _ERROR_BADPERMISSIONS;
236
237                 // add trailing slash (don't add it earlier since it causes mkdir to fail on some systems)
238                 $mediadir .= '/';
239
240                 if (file_exists($mediadir . $filename))
241                         return _ERROR_UPLOADDUPLICATE;
242
243                 // create file
244                 $fh = @fopen($mediadir . $filename, 'wb');
245                 if (!$fh)
246                         return _ERROR_UPLOADFAILED;
247                 $ok = @fwrite($fh, $data);
248                 @fclose($fh);
249                 if (!$ok)
250                         return _ERROR_UPLOADFAILED;
251
252                 // chmod uploaded file
253                 $oldumask = umask(0000);
254                 @chmod($mediadir . $filename, 0644);
255                 umask($oldumask);
256
257                 return '';
258
259         }
260
261 }
262
263 /**
264   * Represents the characteristics of one single media-object
265   *
266   * Description of properties:
267   *  - filename: filename, without paths
268   *  - timestamp: last modification (unix timestamp)
269   *  - collection: collection to which the file belongs (can also be a owner ID, for private collections)
270   *  - private: true if the media belongs to a private member collection
271   */
272 class MEDIAOBJECT {
273
274         var $private;
275         var $collection;
276         var $filename;
277         var $timestamp;
278
279         function MEDIAOBJECT($collection, $filename, $timestamp) {
280                 $this->private = is_numeric($collection);
281                 $this->collection = $collection;
282                 $this->filename = $filename;
283                 $this->timestamp = $timestamp;
284         }
285
286 }
287
288 /**
289   * User-defined sort method to sort an array of MEDIAOBJECTS
290   */
291 function sort_media($a, $b) {
292         if ($a->timestamp == $b->timestamp) return 0;
293         return ($a->timestamp > $b->timestamp) ? -1 : 1;
294 }
295
296 ?>