File.php

Go to the documentation of this file.

<?php
 
namespace Rsi\Fred\Controller\Widget;
 
use \Rsi\Qr;
 
class File extends \Rsi\Fred\Controller\Widget{
 
  const TYPES = 'types'; //!< Allowed file types (mime or extension; mime can have asterisk wildcards or even be a complete
    // regex; all lower case).
  const FILENAME = 'filename'; //!< Fixed filename for the upload. If everything is OK, file will be overwitten directly, and
    // can also be deleted (if not required).
  const MULTI = 'multi'; //!< Allow multiple files to be uploaded.
  const PREVIEW_SIZE = 'previewSize'; //!< Size (width) of preview image (false = no preview).
  const USER_FILES = 'userFiles'; //!< Show user files.
 
  const EVENT_UPLOAD = 'controller:widget:file:upload';
 
  const TUS_VERSION = '1.0.0';
  const TUS_EXTENSIONS = 'creation,termination,checksum';
 
  public $types = [];
  public $filename = null;
  public $multi = false;
  public $previewSize = false;
  public $previewTtl = null;
  public $previewKeyPrefix = 'fred-controller-widget-file-preview-';
  public $previewMax = 3; //!< Maximum number of preview images.
  public $memoryMargin = 20 * 1048576; //!< Spare memory for async file upload processing.
  public $memoryFactor = 0.5; //!< Factor memory for async file upload processing
  public $userFiles = false;
 
  public $sideloadControllerName = null; //!< Controller that provides the sideloading.
  public $sideloadPath = null; //!< Path to temporarily store sideload files.
  public $sideloadExt = '.side'; //!< Extension for sideload files.
  public $sideloadMode = 0666; //!< File mode for sideload files.
  public $sideloadTokenLength = 32; //!< Length of the sideload token.
  public $sideloadHint = null; //!< Hint to show during sideloading (translated).
  public $sideloadInterval = 5; //!< Poll interval for sideloading check (seconds).
  public $sideloadGarbageChance = 100; //!< Clear sideloading path once every ... times.
  public $sideloadSkip = 5; //!< Stop scanning for new files after this number of misses.
 
  public $tusPath = null; //!< Path to temporarily store TUS data.
  public $tusExt = '.tus'; //!< Extension for TUS data files.
  public $tusTempExt = '.file'; //!< Extension for TUS partial file upload.
  public $tusMode = 0666; //!< File mode for TUS data files.
  public $tusTokenLength = 32; //!< Length of the TUS token.
  public $tusTimeout = 3600; //!< Time after which an inactive upload is removed (seconds).
  public $tusGarbageChance = 100; //!< Clear TUS path once every ... times.
  public $tusChunkSize = null; //!< Upload chunk size for TUS upload (empty = calculate).
  public $tusScriptSrc = '/fred/js/tus.min.js'; //!< Script to load for TUS upload (set to empty when already loaded).
 
  protected $_raw = null;
  protected $_multiRaw = null;
 
  public function clientConfig(){
    $config = array_merge(parent::clientConfig(),$this->get([self::TYPES]));
    if(!$this->max) $config[self::MAX] = \Rsi\Number::shorthandBytes(ini_get('post_max_size'));
    if($this->trailer === null) $config[self::TRAILER] = '%n (%s %u)';
    if($this->filename){
      $config[self::FILENAME] = \Rsi\File::basename($this->filename);
      $config['fileExists'] = is_file($this->filename) || $this->filenames;
      if($this->sideloadControllerName && $this->sideloadPath && !$this->_controller->component('client')->mobile){
        $image = !$this->types;
        foreach($this->types as $type) if($image = preg_match('/^(image|jpe?g)/i',$type)) break;
        if($image) $config['sideloadInterval'] = $this->sideloadInterval;
      }
      if($this->tusPath && (($this->max > ($limit = min(
        \Rsi\Number::shorthandBytes(ini_get('upload_max_filesize')),
        $chunk = \Rsi::memoryLimit() * $this->memoryFactor - $this->memoryMargin
      ))) || !$this->max)){
        $config['asyncLimit'] = $limit;
        $config['tusChunkSize'] = $this->tusChunkSize ?: min($chunk,\Rsi\Number::shorthandBytes(ini_get('post_max_size')));
        $config['tusScriptSrc'] = $this->tusScriptSrc;
      }
//TODO: user files werkt nu alleen met een direct lokale filename (dus niet "classic" POST - via een hidden met name ofzo)
      if($this->userFiles && $this->_controller->component('user')->id) $config[self::USER_FILES] = true;
    }
    if($this->multi) $config[self::MULTI] = true;
    return $config;
  }
  /**
   * Purge uploaded filename from possible array construction.
   * If all details are needed you can call fred->request->file(['widget','id']) (where \$id can also be multiple levels
   * deep).
   */
  protected function purgeBase($value){
    if(is_array($value)) $value = array_filter($value,function($file){
      return !is_array($file) || (($file['error'] ?? null) != 4) || array_filter(['error' => null] + $file);
    });
    if($value && is_array($value)) $value = $this->multi //classic upload
      ? array_column($this->_multiRaw = $value,'tmp_name')
      : \Rsi\Record::get($this->_raw = $value,'tmp_name');
    elseif(!$value && $this->filename && (is_array($value = $this->filenames) || is_file($value = $this->filename))); //earlier async upload
    else $value = null; //no upload; clear any value
    return parent::purgeBase($value);
  }
 
  protected function uploadEvent($name){
    return $this->_controller->component('event')->trigger(self::EVENT_UPLOAD,$this,$name);
  }
 
  protected function checkMin($value,$index = null){
    return parent::checkMin(filesize($value));
  }
 
  protected function checkMax($value,$index = null){
    return parent::checkMax(filesize($value));
  }
 
  protected function checkUpload($value,$index = null){
    return !$this->_raw || (is_uploaded_file($value) && !$this->_raw['error']); //http://php.net/manual/en/features.file-upload.errors.php
  }
 
  protected function checkTypes($value,$index = null){
    if($this->_raw) $value = $this->_raw['name'];
    if(!$this->types || in_array(\Rsi\File::ext($value),$this->types)) return true;
    $mime = \Rsi\File::mime($value);
    foreach($this->types as $type)
      if(preg_match(substr($type,0,1) == '/' ? $type : '/^' . str_replace('*','.*',$type) . '$/',$mime)) return true;
    return false;
  }
 
  public function check($value,$index = null){
    if(is_array($value) && $this->filename){
      foreach($value as $filename) if($error = parent::check($filename,$index)) break;
    }
    elseif($this->_multiRaw){
      foreach($this->_multiRaw as $this->_raw) if($error = parent::check($this->_raw['tmp_name'],$index)) break;
    }
    else $error = parent::check($value,$index);
    if(!$error && $value && !is_array($value) && $this->filename && $this->_raw){
      if(!move_uploaded_file($value,$this->filename))
        throw new \Exception("Can not move uploaded file from '$value' to '{$this->filename}'");
      else $error = $this->uploadEvent($this->_raw['name']);
    }
    return $error;
  }
 
  protected function previewFile($filename){
    $preview = [];
    $rotate = false;
    try{
      $image = new \Rsi\Wrapper\Image(file_get_contents($filename));
      $factor = min($this->previewSize / ($width = $image->width),$this->previewSize / ($height = $image->height));
      $image->_scale(round($factor * $width),round($factor * $height));
      ob_start();
      $image->png();
      $preview[] = ob_get_clean();
      $rotate = function_exists('image' . $image->ext($filename));
    }
    catch(\Exception $e){
      $this->log->info($e);
      if(class_exists('Imagick')){
        $temp = \Rsi\File::tempFile('png');
        try{
          $image = new \Imagick($filename);
          foreach($image as $page) if($count++ < $this->previewMax){
            $page->setImageBackgroundColor('white');
            $page->setImageFormat('png');
            $page->thumbnailImage($this->previewSize,0);
            $page->writeImage($temp);
            $preview[] = file_get_contents($temp);
          }
          $image->destroy();
        }
        catch(\Exception $e){
          $this->log->info($e);
        }
        \Rsi\File::unlink($temp);
      }
      else try{
        if($preview = $this->services->preview($filename,$this->previewSize,$this->previewMax)['preview'] ?? null)
          $preview = array_map('base64_decode',$preview);
      }
      catch(\Exception $e){
        $this->log->info($e);
      }
    }
    return $preview ? compact('preview','rotate') : null;
  }
  /**
   * Generate a preview.
   * @param string $filename  File to generate a preview for (empty = fixed upload filename).
   * @param int $count  Will be set to the number of pages in the file.
   * @param bool $rotate  Will be set to true if the image can be rotated.
   * @return array  Preview PNG images.
   */
  public function preview($filename = null,&$count = null,&$rotate = null){
    if($filename || !is_array($filenames = $this->filenames)) $filenames = [$filename ?: $this->filename];
    $count = 0;
    $preview = [];
    session_write_close();
    if($rotate = boolval($this->previewSize)) foreach($filenames as $filename) if(is_file($filename)){
      $key = null;
      if(
        $this->previewTtl &&
        ($file = $this->fred->cache->fetch($key = $this->previewKeyPrefix . $filename . '@' . $this->previewSize)) &&
        ($file['time'] > filemtime($filename))
      ) $key = false;
      else $file = $this->previewFile($filename);
      if($file){
        $preview = array_merge($preview,$file['preview']);
        if(!$file['rotate']) $rotate = false;
        if($key) $this->fred->cache->save($key,$file + ['time' => time()],$this->previewTtl);
      }
    }
    session_start();
    $count = count($preview);
    return array_slice($preview,0,$this->previewMax);
  }
  /**
   * Rotate a file.
   * @param int $angle  Rotation angle (positive: degrees clockwise; -1: flip horizontal, -2: flip vertical).
   * @param string $filename  File to rotate (empty = fixed upload filename).
   * @return bool  True if the operation was successful (file will be replaced).
   */
  public function rotate($angle = 90,$filename = null){
    if(!$filename) $filename = is_array($filenames = $this->filenames) ? array_shift($filenames) : $this->filename;
    $result = !$angle;
    if($angle && $filename && is_file($filename)) try{
      $image = new \Rsi\Wrapper\Image($filename);
      if($angle > 0) $image->_rotate(-$angle,$image->colorAllocate(255,255,255));
      else switch($angle){
        case -1: $image->flip(IMG_FLIP_HORIZONTAL); break;
        case -2: $image->flip(IMG_FLIP_VERTICAL); break;
      }
      $result = $image->save($filename);
    }
    catch(\Exception $e){
      $this->log->info($e);
    }
    return $result;
  }
  /**
   * Process upload data.
   * @param mixed $temp  Temporarily file with uploaded data.
   * @param string $name  Original filename.
   */
  protected function processUpload($temp,$name){
    try{
      $size = filesize($temp);
      if($error = $this->check($temp)) \Rsi\File::unlink($temp);
      elseif(!\Rsi\File::rename($temp,$filename = str_replace('*',microtime(true),$this->filename)))
        throw new \Exception("Could not rename('$temp','$filename')");
      else $error = $this->uploadEvent($name);
      $preview = [];
      foreach($this->preview(null,$count,$rotate) as $image) $preview[] = base64_encode($image);
      $this->request->result = compact('error','name','size','preview','count','rotate') + ['fileExists' => $error ? false : is_file($filename)];
    }
    finally{
      \Rsi\File::unlink($temp);
    }
  }
  /**
   * Filename for a sideload file.
   * @param string $token  Sideload token.
   * @param int $index  Upload index.
   * @return string
   */
  protected function sideloadFilename($token,$index = null){
    return $this->sideloadPath . $token . ($index === null ? '' : '-' . $index) . $this->sideloadExt;
  }
  /**
   * Sideload URL.
   * @param string $token  Sideload token.
   * @return string  Full URL.
   */
  protected function sideloadUrl($token){
    return \Rsi\Http::host(true) . $this->_controller->component('router')->reverse($this->sideloadControllerName,null,compact('token'));
  }
  /**
   * Clear old sideload tokens.
   */
  protected function sideloadGarbage(){
    if($this->sideloadPath && !rand(0,$this->sideloadGarbageChance)) try{
      foreach((new \GlobIterator($this->sideloadPath . '*' . $this->sideloadExt)) as $filename => $file)
        if($file->getMTime() < time() - 2 * $this->sideloadInterval) \Rsi\File::unlink($filename);
      $session = $this->_controller->session;
      if($tokens = $session->sideloadTokens){
        foreach($tokens as $token => $time) if(!is_file($this->sideloadFilename($token))) unset($tokens[$token]);
        $session->sideloadTokens = $tokens;
      }
    }
    catch(\Exception $e){
      $this->log->error($e);
    }
  }
 
  protected function tusError($code,$message){
    http_response_code($code);
    header('Content-Type: text/plain');
    print($message);
    $this->fred->log->info("TUS error ($code): $message");
  }
 
  protected function tusIndex($header){
    if(($index = $_SERVER['HTTP_' . strtoupper(str_replace('-','_',$header))] ?? null) === null) $this->tusError(400,"Missing $header header");
    elseif(($index = filter_var($index,FILTER_VALIDATE_INT,['options' => ['min_range' => 0]])) === false) $this->tusError(400,"Invalid $header header");
    else return $index;
    return false;
  }
 
  protected function tusFilename($token){
    return $this->tusPath . $token . $this->tusExt;
  }
 
  protected function tusGarbage(){
    if($this->tusPath && !rand(0,$this->tusGarbageChance)) try{
      foreach((new \GlobIterator($this->tusPath . '*' . $this->tusExt)) as $filename => $file)
        if($file->getMTime() < time() - $this->tusTimeout){
          \Rsi\File::unlink($filename . $this->tusTempExt);
          \Rsi\File::unlink($filename);
        }
    }
    catch(\Exception $e){
      $this->log->error($e);
    }
  }
 
  protected function actionPreview(){
    $preview = [];
    $count = $rotate = false;
    if($this->_display >= self::DISPLAY_READABLE)
      foreach($this->preview(null,$count,$rotate) as $image) $preview[] = base64_encode($image);
    $this->request->result = compact('preview','count','rotate');
  }
 
  protected function actionDownload(){
    if($this->_display >= self::DISPLAY_READABLE){
      if(!is_array($filenames = $this->filenames)) $filenames = [$this->filename];
      if(($filename = $filenames[intval($this->request->index)] ?? null) && is_file($filename)){
        \Rsi\Http::downloadHeaders($filename,null,filesize($filename));
        readfile($filename);
        $this->fred->halt();
      }
    }
  }
 
  protected function actionUpload(){
    if(
      ($this->_display >= self::DISPLAY_WRITEABLE) &&
      $this->filename &&
      ($temp = \Rsi\Record::get($this->request->file('data'),'tmp_name'))
    ) $this->processUpload($temp,$this->request->name);
  }
 
  protected function actionRotate(){
    if($this->_display >= self::DISPLAY_WRITEABLE){
      session_write_close();
      $this->rotate((int)$this->request->angle);
      $preview = [];
      foreach($this->preview(null,$count,$rotate) as $image) $preview[] = base64_encode($image);
      clearstatcache(false,$this->filename);
      $this->request->result = compact('preview','count','rotate') + ['size' => \Rsi\File::size($this->filename)];
    }
  }
 
  protected function actionDelete(){
    if(($this->_display >= self::DISPLAY_WRITEABLE) && !$this->required && $this->filename){
      if(!is_array($filenames = $this->filenames)) $filenames = [$this->filename];
      $this->request->result = ['deleted' => $filenames ? array_sum(array_map('\Rsi\File::unlink',$filenames)) : true];
    }
  }
 
  protected function actionUserFiles(){
    if(($this->_display >= self::DISPLAY_WRITEABLE) && $this->userFiles) $this->request->result = [
      'files' => $this->_controller->component('user')->files->list($this->types),
      'preview' => (bool)$this->previewSize
    ];
  }
 
  protected function actionUserFilePreview(){
    if($data = $this->_controller->component('user')->files->fetch($this->request->name)){
      session_write_close();
      $temp = \Rsi\File::tempFile('tmp',$data);
      $preview = [];
      foreach($this->preview($temp) as $image) $preview[] = base64_encode($image);
      unlink($temp);
      $this->request->result = $preview;
    }
  }
 
  protected function actionUserFile(){
    if(($this->_display >= self::DISPLAY_WRITEABLE) && $this->filename && $this->userFiles){
      $data = $this->_controller->component('user')->files->fetch($filename = $this->request->name);
      if(($data !== false) && ($data !== null))
        $this->processUpload(\Rsi\File::tempFile(\Rsi\File::ext($this->filename),$data),basename($filename));
    }
  }
 
  protected function actionSideload(){
    if(($this->_display >= self::DISPLAY_WRITEABLE) && $this->filename && $this->sideloadPath && $this->sideloadControllerName){
      $this->sideloadGarbage();
      while(file_exists($filename = $this->sideloadFilename($token = \Rsi\Str::random($this->sideloadTokenLength))));
      \Rsi\File::serialize(
        $filename,
        [
          'token' => $token,
          'config' => array_merge($this->_config,[self::FILENAME => null]),
          'time' => $time = time()
        ],
        $this->sideloadMode
      );
      $session = $this->_controller->session;
      $tokens = $session->sideloadTokens ?: [];
      $tokens[$token] = $time;
      $session->sideloadTokens = $tokens;
      $url = $this->sideloadUrl($token);
      $this->request->result = [
        'token' => $token,
        'controller' => $this->sideloadControllerName,
        'url' => $url,
        'hint' => $this->trans->str($this->sideloadHint,compact('token','url'))
      ];
    }
  }
 
  protected function actionSideloadImage(){
    if($token = $this->sideloadToken){
      header('Content-Type: image/png');
      imagepng((new Qr(Qr::ECC_MEDIUM,null,10))->dataImage($this->sideloadUrl($token)));
      $this->fred->halt();
    }
  }
 
  protected function actionSideloadCheck(){
    if(($token = $this->sideloadToken) && is_file($filename = $this->sideloadFilename($token))){
      touch($filename);
      $index = $skip = 0;
      while($skip++ < $this->sideloadSkip)
        if(($data = \Rsi\File::unserialize($filename = $this->sideloadFilename($token,$index++))) !== false) try{
          \Rsi\File::unlink($filename);
          $this->processUpload(\Rsi\File::tempFile(\Rsi\File::ext($this->filename),$data['data']),$data['name']);
          $skip = 0;
        }
        catch(\Exception $e){
          $this->log->warning('Error while processig sideload file: ' . $e->getMessage(),__FILE__,__LINE__);
          \Rsi\File::unlink($filename);
        }
    }
    if(!$this->request->result) $this->sideloadGarbage();
  }
 
  protected function actionTus(){
    if(($this->_display < self::DISPLAY_WRITEABLE) || !$this->filename || !$this->tusPath) http_response_code(404);
    elseif(($method = \Rsi\Http::method()) == \Rsi\Http::METHOD_OPTIONS){ //capabilities
      header('Tus-Resumable: ' . self::TUS_VERSION);
      header('Tus-Version: ' . self::TUS_VERSION);
      header('Tus-Extension: ' . self::TUS_EXTENSIONS);
      if($this->max) header('Tus-Max-Size: ' . $this->max);
      header('Tus-Checksum-Algorithm: ' . implode(',',hash_algos()));
      http_response_code(204);
    }
    elseif($this->request->server->http->tusResumable != self::TUS_VERSION){
      header('Tus-Version: ' . self::TUS_VERSION);
      $this->tusError(412,'Unsupported Tus-Resumable version. Server supports ' . self::TUS_VERSION);
    }
    elseif($method == \Rsi\Http::METHOD_POST){ //start new upload
//CHECK: Komen deze meldingen nog ergens in beeld? Anders vertaalbaar maken (ala sideloadHint)
//CHECK: bestand van 0 bytes proberen (direct klaar)
      if(($length = $this->tusIndex('Upload-Length')) !== false){
        if($this->max && ($length > $this->max)) $this->tusError(413,"Upload-Length exceeds maximum allowed size of {$this->max} bytes");
//TODO: hier ook meteen een evt ->min controleren (alhoewel dat client-side ook al gebeurd, en hier achter ook nog eens)
        else{
          $this->tusGarbage();
          $meta = [];
          foreach(array_filter(explode(',',$this->request->server->http->uploadMetadata)) as $data){
            $data = explode(' ',$data,2);
            $meta[$data[0]] = count($data) > 1 ? base64_decode($data[1]) : null;
          }
          while(file_exists($filename = $this->tusFilename($token = \Rsi\Str::random($this->tusTokenLength))));
          \Rsi\File::serialize(
            $filename,
            [
              'length' => $length,
              'offset' => 0,
              'meta' => $meta,
              'complete' => false
            ],
            $this->tusMode
          );
          file_put_contents($filename . $this->tusTempExt,null);
          header("Location: {$this->request->server->requestUri}&token=$token");
          header('Tus-Resumable: ' . self::TUS_VERSION);
          http_response_code(201);
        }
      }
    }
    elseif(
      ($token = $this->request->token) &&
      ($data = \Rsi\File::unserialize($filename = $this->tusFilename($token))) &&
      is_file($temp = $filename . $this->tusTempExt)
    ) switch($method){
      case \Rsi\Http::METHOD_HEAD: //get upload info
        header('Upload-Offset: ' . $data['offset']);
        header('Upload-Length: '   . $data['length']);
        header('Cache-Control: no-store');
        header('Tus-Resumable: ' . self::TUS_VERSION);
        $meta = [];
        foreach($data['meta'] as $key => $value) $meta[] = $key . ($value === null ? null : ' ' . base64_encode($value));
        if($meta) header('Upload-Metadata: ' . implode(',',$meta));
        http_response_code(200);
        break;
      case \Rsi\Http::METHOD_PATCH: //add chunk to file
        if($data['complete']) $this->tusError(400,'Upload already complete');
        elseif(($_SERVER['CONTENT_TYPE'] ?? null) != 'application/offset+octet-stream') $this->tusError(415,'Content-Type must be application/offset+octet-stream');
        elseif(($offset = $this->tusIndex('Upload-Offset')) !== false){
          if($offset != $data['offset']) $this->tusError(409,"Offset mismatch: expected {$info['offset']}, got $offset");
          elseif($offset != filesize($temp)) $this->tusError(500,'Upload file wrong size');
          elseif(($chunk = file_get_contents('php://input')) === false) $this->tusError(500,'Failed to read request body');
          else{
            $error = false;
            if($checksum = $this->request->server->http->uploadChecksum){
              if($error = (count($checksum = explode(' ',$checksum)) != 2)) $this->tusError(400,'Invalid Upload-Checksum header');
              elseif($error = !in_array($algo = strtolower($checksum[0]),hash_algos())) $this->tusError(400,'Checksum algorithm not supported');
              elseif($error = !hash_equals(base64_encode(hash($algo,$chunk,true)),$checksum[1])) $this->tusError(460,'Checksum mismatch');
            }
            if(!$error){
              if(($length = $data['offset'] + strlen($chunk)) > $data['length']) $tusError(416,'Resulting file size over total length');
              else{
                file_put_contents($temp,$chunk,FILE_APPEND);
                if($data['complete'] = ($data['offset'] = $length) == $data['length']){
                  $this->processUpload($temp,$meta['filename'] ?? null);
                  header('Upload-Info: ' . json_encode($this->request->result));
                }
                \Rsi\File::serialize($filename,$data);
                header('Upload-Offset: ' . $length);
                header('Tus-Resumable: ' . self::TUS_VERSION);
                http_response_code(204);
              }
            }
          }
        }
        break;
      case \Rsi\Http::METHOD_DELETE: //cancel upload
        \Rsi\File::unlink($filename . $this->tusTempExt);
        \Rsi\File::unlink($filename);
        header('Tus-Resumable: ' . self::TUS_VERSION);
        http_response_code(204);
        break;
      default:
        http_response_code(404);
    }
    else http_response_code(404);
    $this->fred->halt();
  }
 
  protected function getFilenames(){
    return $this->multi && strpos($this->filename,'*')
      ? \Rsi\Record::sort(\Rsi\File::dir(dirname($this->filename),basename($this->filename)))
      : false;
  }
 
  protected function getSideloadToken(){
    $session = $this->_controller->session;
    if(
      ($tokens = $session->sideloadTokens) &&
      array_key_exists($token = $this->request->token,$tokens) &&
      ($tokens[$token] > ($time = time()) - 2 * $this->sideloadInterval)
    ){
      $tokens[$token] = $time;
      $session->sideloadTokens = $tokens;
      return $token;
    }
  }
 
}