master/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 ?>