Skip to content

A platform for community discussion. Free, open, simple.

7.4 KB
Raw Blame
# frozen_string_literal: true

require "final_destination"
require "image_processing/instrumentation"
require "mini_mime"
require "open-uri"
require "tempfile"

class FileHelper
  def self.log(log_level, message)
    Rails.logger.public_send(
      log_level,
      "#{RailsMultisite::ConnectionManagement.current_db}: #{message}",
    )
  end

  def self.is_supported_image?(filename)
    filename.match?(supported_images_regexp)
  end

  def self.is_supported_video?(filename)
    filename.match?(supported_video_regexp)
  end

  def self.is_supported_audio?(filename)
    filename.match?(supported_audio_regexp)
  end

  def self.is_inline_image?(filename)
    filename.match?(inline_images_regexp)
  end

  def self.is_svg?(filename)
    filename.match?(/\.svg\z/i)
  end

  def self.is_supported_media?(filename)
    filename.match?(supported_media_regexp)
  end

  def self.is_supported_playable_media?(filename)
    filename.match?(supported_playable_media_regexp)
  end

  # https://guides.rubyonrails.org/security.html#file-uploads
  def self.sanitize_filename(filename)
    filename.strip.tap do |name|
      # NOTE: File.basename doesn't work right with Windows paths on Unix
      # get only the filename, not the whole path
      name.sub! %r{\A.*(\\|/)}, ""
      # Replace all non alphanumeric, underscore
      # or periods with underscore
      name.gsub! /[^\w\.\-]/, "_"
      # Finally, replace all double underscores with a single one
      name.gsub! /_+/, "_"
    end
  end

  class FakeIO
    attr_accessor :status, :meta
  end

  def self.download(
    url,
    max_file_size:,
    tmp_file_name:,
    follow_redirect: false,
    read_timeout: 5,
    skip_rate_limit: false,
    verbose: false,
    validate_uri: true,
    retain_on_max_file_size_exceeded: false,
    include_port_in_host_header: false,
    extra_headers: {}
  )
    url = "https:" + url if url.start_with?("//")
    raise Discourse::InvalidParameters.new(:url) unless url =~ %r{\Ahttps?://}

    tmp = nil

    fd =
      FinalDestination.new(
        url,
        max_redirects: follow_redirect ? 5 : 0,
        skip_rate_limit: skip_rate_limit,
        verbose: verbose,
        validate_uri: validate_uri,
        timeout: read_timeout,
        include_port_in_host_header: include_port_in_host_header,
        headers: extra_headers,
      )

    fd.get do |response, chunk, uri|
      if tmp.nil?
        # error handling
        if uri.blank?
          if response.code.to_i >= 400
            # attempt error API compatibility
            io = FakeIO.new
            io.status = [response.code, ""]
            io.meta = response.each_header.to_h
            raise OpenURI::HTTPError.new("#{response.code} Error", io)
          else
            log(:error, "FinalDestination did not work for: #{url}") if verbose
            throw :done
          end
        end

        if response.content_type.present?
          ext = MiniMime.lookup_by_content_type(response.content_type)&.extension
          ext = "jpg" if ext == "jpe"
          tmp_file_ext = "." + ext if ext.present?
        end

        tmp_file_ext ||= File.extname(uri.path)
        tmp = Tempfile.new([tmp_file_name, tmp_file_ext])
        tmp.binmode
      end

      tmp.write(chunk)

      if tmp.size > max_file_size
        unless retain_on_max_file_size_exceeded
          tmp.close
          tmp = nil
        end

        throw :done
      end
    end

    tmp&.rewind
    tmp
  end

  def self.optimize_image!(filename, allow_pngquant: false)
    ImageProcessing::Instrumentation.instrument(operation: :image_optim) do
      commands =
        case FastImage.type(filename)
        when :png
          oxipng = %w[oxipng --opt 3 --interlace 0 --quiet --stdout]
          oxipng.concat(%w[--strip all]) if SiteSetting.strip_image_metadata
          [oxipng].tap do |pipeline|
            if allow_pngquant
              pipeline << %w[
                pngquant
                --quality=0-100
                --speed=3
                --output=-
                --skip-if-larger
                --force
                256
              ]
            end
          end
        when :jpeg
          jpegoptim = %w[jpegoptim --quiet --stdout --force]
          jpegoptim << (SiteSetting.strip_image_metadata ? "--strip-all" : "--strip-none")
          [jpegoptim]
        else
          next
        end

      result = nil
      input = File.expand_path(filename)
      commands.each do |command|
        Tempfile.create(
          ["image-optimization-", File.extname(filename)],
          File.dirname(input),
        ) do |temporary|
          begin
            Discourse::SafeExec.capture(
              "sh",
              "-c",
              'exec "$@" > "$0"',
              temporary.path,
              "nice",
              "-n",
              "10",
              *command,
              "--",
              input,
              env: {
                **ENV.slice("PATH"),
                "MALLOC_ARENA_MAX" => "2",
              },
              unsetenv_others: true,
              read: [*Discourse::SafeExec.default_read_paths, input],
              write: [temporary.path],
              execute: Discourse::SafeExec.default_execute_paths,
              timeout: 15,
              rlimits: ImageMagick::RLIMITS,
              seccomp_deny_network: true,
              seccomp_deny_child_processes: true,
            )
          rescue Discourse::Utils::CommandError, Errno::ENOENT
            next
          end
          next if temporary.size.zero? || temporary.size >= File.size(input)

          temporary.chmod(File.stat(input).mode)
          File.rename(temporary.path, input)
          result = filename
        end
      end
      result
    end
  end

  def self.supported_gravatar_extensions
    @@supported_gravatar_images ||= Set.new(%w[jpg jpeg png gif])
  end

  def self.supported_images
    @@supported_images ||= Set.new %w[jpg jpeg png gif svg ico webp avif heic heif jxl]
  end

  def self.inline_images
    # SVG cannot safely be shown as a document
    @@inline_images ||= supported_images - %w[svg]
  end

  # files which are safe to serve inline (no script execution risk)
  def self.inline_safe_files
    @@inline_safe_files ||= inline_images | Set.new(%w[pdf]) | supported_video | supported_audio
  end

  def self.is_inline_safe?(filename)
    return false if filename.blank?
    filename.downcase.end_with?(*inline_safe_files.map { |ext| ".#{ext}" })
  end

  def self.supported_audio
    @@supported_audio ||= Set.new %w[mp3 ogg oga opus wav m4a m4b m4p m4r aac flac]
  end

  def self.supported_video
    @@supported_video ||= Set.new %w[mov mp4 webm ogv m4v 3gp avi mpeg]
  end

  def self.supported_video_regexp
    @@supported_video_regexp ||= /\.(#{supported_video.to_a.join("|")})\z/i
  end

  def self.supported_audio_regexp
    @@supported_audio_regexp ||= /\.(#{supported_audio.to_a.join("|")})\z/i
  end

  def self.supported_images_regexp
    @@supported_images_regexp ||= /\.(#{supported_images.to_a.join("|")})\z/i
  end

  def self.inline_images_regexp
    @@inline_images_regexp ||= /\.(#{inline_images.to_a.join("|")})\z/i
  end

  def self.supported_media_regexp
    @@supported_media_regexp ||=
      begin
        media = supported_images | supported_audio | supported_video
        /\.(#{media.to_a.join("|")})\z/i
      end
  end

  def self.supported_playable_media_regexp
    @@supported_playable_media_regexp ||=
      begin
        media = supported_audio | supported_video
        /\.(#{media.to_a.join("|")})\z/i
      end
  end
end