A platform for community discussion. Free, open, simple.
# 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