Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2026-03-21 15:53
📄 ansi_colors.rb # Phusion Passenger - https://www.phusionpassenger.com/ # Copyright (c) 2010-2025 Asynchronous B.V. # # "Passenger", "Phusion Passenger" and "Union Station" are registered # trademarks of Asynchronous B.V. # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in # all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN # THE SOFTWARE. module PhusionPassenger module Utils module AnsiColors RESET = "\e[0m".freeze BOLD = "\e[1m".freeze GRAY = "\e[38;5;248m".freeze DGRAY = "\e[90m".freeze RED = "\e[31m".freeze ORANGE = "\e[38;5;214m".freeze GREEN = "\e[32m".freeze YELLOW = "\e[33m".freeze WHITE = "\e[37m".freeze BLACK_BG = "\e[40m".freeze BLUE_BG = "\e[44m".freeze DEFAULT_TERMINAL_COLOR = "#{RESET}#{WHITE}#{BLACK_BG}".freeze extend self # Make methods available as class methods. def self.new(type = :auto) AnsiColorsPrinter.new(type) end def self.included(klass) # When included into another class, make sure that Utils # methods are made private. public_instance_methods(false).each do \|method_name\| klass.send(:private, method_name) end end def ansi_colorize(text) text = text.gsub(%r{<b>(.?)</b>}m, "#{BOLD}\\1#{DEFAULT_TERMINAL_COLOR}") text.gsub!(%r{<dgray>(.?)</dgray>}m, "#{BOLD}#{DGRAY}\\1#{DEFAULT_TERMINAL_COLOR}") text.gsub!(%r{<gray>(.?)</gray>}m, "#{BOLD}#{GRAY}\\1#{DEFAULT_TERMINAL_COLOR}") text.gsub!(%r{<red>(.?)</red>}m, "#{BOLD}#{RED}\\1#{DEFAULT_TERMINAL_COLOR}") text.gsub!(%r{<orange>(.?)</orange>}m, "#{BOLD}#{ORANGE}\\1#{DEFAULT_TERMINAL_COLOR}") text.gsub!(%r{<green>(.?)</green>}m, "#{BOLD}#{GREEN}\\1#{DEFAULT_TERMINAL_COLOR}") text.gsub!(%r{<yellow>(.?)</yellow>}m, "#{BOLD}#{YELLOW}\\1#{DEFAULT_TERMINAL_COLOR}") text.gsub!(%r{<banner>(.?)</banner>}m, "#{BOLD}#{BLUE_BG}#{YELLOW}\\1#{DEFAULT_TERMINAL_COLOR}") text end def strip_color_tags(text) text = text.gsub(%r{<b>(.?)</b>}m, "\\1") text = text.gsub(%r{<dgray>(.?)</dgray>}m, "\\1") text = text.gsub(%r{<gray>(.?)</gray>}m, "\\1") text.gsub!(%r{<red>(.?)</red>}m, "\\1") text.gsub!(%r{<orange>(.?)</orange>}m, "\\1") text.gsub!(%r{<green>(.?)</green>}m, "\\1") text.gsub!(%r{<yellow>(.?)</yellow>}m, "\\1") text.gsub!(%r{<banner>(.?)</banner>}m, "\\1") text end end class AnsiColorsPrinter def initialize(enabled = :auto) @enabled = enabled end def reset maybe_colorize(AnsiColors::RESET) end def bold maybe_colorize(AnsiColors::BOLD) end def dgray maybe_colorize(AnsiColors::DGRAY) end def gray maybe_colorize(AnsiColors::GRAY) end def red maybe_colorize(AnsiColors::RED) end def orange maybe_colorize(AnsiColors::ORANGE) end def green maybe_colorize(AnsiColors::GREEN) end def yellow maybe_colorize(AnsiColors::YELLOW) end def white maybe_colorize(AnsiColors::WHITE) end def black_bg maybe_colorize(AnsiColors::BLACK_BG) end def blue_bg maybe_colorize(AnsiColors::BLUE_BG) end def default_terminal_color maybe_colorize(AnsiColors::DEFAULT_TERMINAL_COLOR) end def ansi_colorize(text) if should_output_color? AnsiColors.ansi_colorize(text) else AnsiColors.strip_color_tags(text) end end private def maybe_colorize(ansi_color) if should_output_color? ansi_color else "" end end def should_output_color? if @enabled == :auto STDOUT.tty? else @enabled end end end end # module Utils end # module PhusionPassenger	4.87 KB	2025-11-20 11:36
📄 download.rb # encoding: utf-8 # Phusion Passenger - https://www.phusionpassenger.com/ # Copyright (c) 2013-2025 Asynchronous B.V. # # "Passenger", "Phusion Passenger" and "Union Station" are registered # trademarks of Asynchronous B.V. # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in # all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN # THE SOFTWARE. PhusionPassenger.require_passenger_lib 'platform_info' PhusionPassenger.require_passenger_lib 'utils/shellwords' require 'fileutils' module PhusionPassenger module Utils module Download extend self # Make methods available as class methods. def self.included(klass) # When included into another class, make sure that Utils # methods are made private. public_instance_methods(false).each do \|method_name\| klass.send(:private, method_name) end end # Downloads a file from the given URL and saves it to the given filename. # Returns whether the download succeeded. # # Options: # # show_progress: whether to show download progress. Default: false. # logger: the logger to use. If not given, this function will log to STDERR. # cacert: a CA certificate file to use for verifying SSL websites. # The default is to use the download tool's down CA database. # use_cache: Whether to copy the file from the download cache, if available. # Default: false. # connect_timeout: The maximum amount of time to spend on DNS lookup # and establishing the TCP connection. Set to nil to # disable this timeout. Default: 4. # idle_timeout: The maximum idle read time. Set to nil to set this timeout # to the default wget value, 900. Set to nil to disable this # timeout. Default: 5. # total_timeout: The maximum amount of time spent on the whole download # operation, including connection time. Only has effect on curl. # Set to nil to disable this timeout. Default: nil. def download(url, output, options = {}) options = { :connect_timeout => 4, :idle_timeout => 5 }.merge(options) logger = options[:logger] \|\| Logger.new(STDERR) if options[:use_cache] && cache_dir = PhusionPassenger.download_cache_dir basename = basename_from_url(url) if File.exist?("#{cache_dir}/#{basename}") logger.info "Copying #{basename} from #{cache_dir}..." FileUtils.cp("#{cache_dir}/#{basename}", output) return true end end if PlatformInfo.find_command("curl") return download_with_curl(logger, url, output, options) elsif PlatformInfo.find_command("wget") return download_with_wget(logger, url, output, options) else logger.error "Could not download #{url}: no download tool found (curl or wget required)" return false end end private def basename_from_url(url) return url.sub(/.\//, '') end def download_with_curl(logger, url, output, options) command = ["curl", "-f", "-L", "-o", output] if options[:show_progress] command << "-#" else command << "-s" command << "-S" end if options[:cacert] command << "--cacert" command << options[:cacert] end if options[:connect_timeout] command << "--connect-timeout" command << options[:connect_timeout].to_s end if options[:idle_timeout] command << "--speed-time" command << options[:idle_timeout].to_s command << "--speed-limit" command << "1" end if options[:total_timeout] command << "--max-time" command << options[:total_timeout].to_s end command << url command_str = Shellwords.join(command) logger.info("Invoking: #{command_str}") if options[:show_progress] # If curl errors out we don't want it to display 'curl: ' prefixes, # so we parse its output. begin io = IO.popen("#{command_str} 2>&1", "r") rescue SystemCallError => e logger.error("Could not invoke curl: #{e}") return false end begin non_empty_line_encountered = false while !io.eof? # We split on "\r" because progress bar lines do not contain "\n". data = io.gets("\r") data = remove_curl_output_prefix(data) # If an error occurs then the first few lines may be empty. # Skip those. if !non_empty_line_encountered && data =~ /\A\n+/ data.gsub!(/\A\n+/, '') end non_empty_line_encountered = true STDERR.write(data) STDERR.flush end ensure io.close end result = $?.exitstatus == 0 else begin output = `#{command_str} 2>&1` rescue SystemCallError => e logger.error("Could not invoke curl: #{e}") return false end result = $?.exitstatus == 0 if !result output = remove_curl_output_prefix(output) output.chomp! logger.error("Could not download #{url}: #{output}") end end return result end def remove_curl_output_prefix(line) return line.gsub(/^curl: (\([0-9]+\) )?/, '') end def download_with_wget(logger, url, output, options) command = ["wget", "--tries=1", "-O", output] if !options[:show_progress] command << "-nv" end if options[:cacert] command << "--ca-certificate=#{options[:cacert]}" end if options[:connect_timeout] command << "--dns-timeout=#{options[:connect_timeout]}" command << "--connect-timeout=#{options[:connect_timeout]}" end if options[:idle_timeout] command << "--timeout=#{options[:idle_timeout]}" end command << url command_str = Shellwords.join(command) logger.info("Invoking: #{command_str}") if options[:show_progress] begin result = system(command) rescue SystemCallError => e logger.error("Could not invoke wget: #{e}") return false end if !result logger.error("Could not download #{url}: #{output}") end else begin output = `#{command_str} 2>&1` rescue SystemCallError => e logger.error("Could not invoke wget: #{e}") return false end result = $?.exitstatus == 0 if !result # Error output may begin with "<URL>:\n" which is redundant. output.gsub!(/\A#{Regexp.escape url}:\n/, '') output.chomp! logger.error("Could not download #{url}: #{output}") end end return result end end end # module Utils end # module PhusionPassenger	8.13 KB	2025-11-20 11:36
📄 file_system_watcher.rb # Phusion Passenger - https://www.phusionpassenger.com/ # Copyright (c) 2010-2025 Asynchronous B.V. # # "Passenger", "Phusion Passenger" and "Union Station" are registered # trademarks of Asynchronous B.V. # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in # all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN # THE SOFTWARE. PhusionPassenger.require_passenger_lib 'native_support' module PhusionPassenger module Utils # Watches changes on one or more files or directories. To use this class, # construct an object, passing it file or directory names to watch, then # call #wait_for_change. #wait_for_change waits until one of the following # events has happened since the constructor was called: # # - One of the specified files has been renamed, deleted, or its access # revoked. This will cause +true+ to be returned. # - One of the specified directories has been modified, renamed, deleted, # or its access revoked. This will cause +true+ to be returned. # - +termination_pipe+ (as passed to the constructor) becomes readable. # This will cause +nil+ to be returned. # - The thread is interrupted. This will cause +nil+ to be returned. # # The constructor will attempt to stat and possibly also open all specified # files/directories. If one of them cannot be statted or opened, then # +false+ will be returned by #wait_for_change. # # #wait_for_change may only be called once. After calling it one should # create a new object if one wishes to watch the filesystem again. # # Always call #close when a FileSystemWatcher object is no longer needed # in order to free resources. # # This class tries to use kqueue for efficient filesystem watching on # platforms that support it. On other platforms it'll fallback to stat # polling instead. if defined?(NativeSupport::FileSystemWatcher) FileSystemWatcher = NativeSupport::FileSystemWatcher FileSystemWatcher.class_eval do def self.new(filenames, termination_pipe = nil) # Default parameter values, type conversion and exception # handling in C is too much of a pain. filenames = filenames.map do \|filename\| filename.to_s end return _new(filenames, termination_pipe) end def self.opens_files? return true end end else class FileSystemWatcher attr_accessor :poll_interval def self.opens_files? return false end def initialize(filenames, termination_pipe = nil) @poll_interval = 3 @termination_pipe = termination_pipe @dirs = [] @files = [] begin filenames.each do \|filename\| stat = File.stat(filename) if stat.directory? @dirs << DirInfo.new(filename, stat) else @files << FileInfo.new(filename, stat) end end rescue Errno::EACCES, Errno::ENOENT @dirs = @files = nil end end def wait_for_change if !@dirs return false end while true if changed? return true elsif select([@termination_pipe], nil, nil, @poll_interval) return nil end end end def close end private class DirInfo DOT = "." DOTDOT = ".." def initialize(filename, stat) @filename = filename @stat = stat @subfiles = {} Dir.foreach(filename) do \|entry\| next if entry == DOT \|\| entry == DOTDOT subfilename = "#{filename}/#{entry}" @subfiles[entry] = FileInfo.new(subfilename, File.stat(subfilename)) end end def changed? new_stat = File.stat(@filename) if @stat.ino != new_stat.ino \|\| !new_stat.directory? \|\| @stat.mtime != new_stat.mtime return true end count = 0 Dir.foreach(@filename) do \|entry\| next if entry == DOT \|\| entry == DOTDOT subfilename = "#{@filename}/#{entry}" file_info = @subfiles[entry] if !file_info \|\| file_info.changed?(false) return true else count += 1 end end return count != @subfiles.size rescue Errno::EACCES, Errno::ENOENT return true end end class FileInfo def initialize(filename, stat) @filename = filename @stat = stat end def changed?(check_mtime = true) new_stat = File.stat(@filename) if check_mtime mtime_changed = @stat.mtime != new_stat.mtime \|\| @stat.size != new_stat.size else mtime_changed = false end return @stat.ino != new_stat.ino \|\| @stat.ftype != new_stat.ftype \|\| mtime_changed rescue Errno::EACCES, Errno::ENOENT return true end end def changed? return @dirs.any? { \|dir_info\| dir_info.changed? } \|\| @files.any? { \|file_info\| file_info.changed? } end end end end # module Utils end # module PhusionPassenger	6.3 KB	2025-11-20 11:36
📄 hosts_file_parser.rb # encoding: binary # Phusion Passenger - https://www.phusionpassenger.com/ # Copyright (c) 2010-2025 Asynchronous B.V. # # "Passenger", "Phusion Passenger" and "Union Station" are registered # trademarks of Asynchronous B.V. # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in # all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN # THE SOFTWARE. PhusionPassenger.require_passenger_lib 'platform_info/operating_system' module PhusionPassenger module Utils # A /etc/hosts parser. Also supports writing groups of data to the file. class HostsFileParser def self.flush_dns_cache! if PlatformInfo.os_name_simple == "macosx" system("dscacheutil -flushcache") end end def initialize(filename_or_io = "/etc/hosts") if filename_or_io.respond_to?(:readline) read_and_parse(filename_or_io) else File.open(filename_or_io, "rb") do \|f\| read_and_parse(f) end end end def ip_count return @ips.size end def host_count return @host_names.size end def resolve(host_name) if host_name.downcase == "localhost" return "127.0.0.1" else return @host_names[host_name.downcase] end end def resolves_to_localhost?(hostname) ip = resolve(hostname) return ip == "127.0.0.1" \|\| ip == "::1" \|\| ip == "0.0.0.0" end def add_group_data(marker, data) begin_index = find_line(0, "###### BEGIN #{marker} ######") end_index = find_line(begin_index + 1, "###### END #{marker} ######") if begin_index if begin_index && end_index @lines[begin_index + 1 .. end_index - 1] = data.split("\n") else @lines << "###### BEGIN #{marker} ######" @lines.concat(data.split("\n")) @lines << "###### END #{marker} ######" end end def write(io) @lines.each do \|line\| io.puts(line) end end private def read_and_parse(io) lines = [] ips = {} all_host_names = {} while !io.eof? line = io.readline line.sub!(/\n\Z/m, '') lines << line ip, host_names = parse_line(line) if ip ips[ip] \|\|= [] ips[ip].concat(host_names) host_names.each do \|host_name\| all_host_names[host_name.downcase] = ip end end end @lines = lines @ips = ips @host_names = all_host_names end def parse_line(line) return nil if line =~ /^[\s\t]#/ line = line.strip return nil if line.empty? ip, host_names = line.split(/[ \t]+/) return [ip, host_names] end def find_line(start_index, content) i = start_index while i < @lines.size if @lines[i] == content return i else i += 1 end end return nil end end end end	3.95 KB	2025-11-20 11:36
📄 json.rb # encoding: utf-8 # ## Stupid small pure Ruby JSON parser & generator. # # Copyright © 2013 Mislav Marohnić # # Permission is hereby granted, free of charge, to any person obtaining a copy of this # software and associated documentation files (the “Software”), to deal in the Software # without restriction, including without limitation the rights to use, copy, modify, # merge, publish, distribute, sublicense, and/or sell copies of the Software, and to # permit persons to whom the Software is furnished to do so, subject to the following # conditions: # # The above copyright notice and this permission notice shall be included in all copies or # substantial portions of the Software. # # THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, # INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR # PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE # LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT # OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR # OTHER DEALINGS IN THE SOFTWARE. # We use this in Phusion Passenger at places where we cannot depend on the JSON # gem being available, for example in 'passenger start' before the RuntimeInstaller # has run. PhusionPassenger.require_passenger_lib 'utils/strscan' require 'forwardable' module PhusionPassenger module Utils # Usage: # # JSON.parse(json_string) => Array/Hash # JSON.generate(object) => json string # # Run tests by executing this file directly. Pipe standard input to the script to have it # parsed as JSON and to display the result in Ruby. # class JSON def self.parse(data) new(data).parse end WSP = /(\s\|\/\/.?\n\|\/\.?\\/)+/m OBJ = /[{\[]/; HEN = /\}/; AEN = /\]/ COL = /\s:\s/; KEY = /\s,\s/ NUM = /-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?/ BOL = /true\|false/; NUL = /null/ extend Forwardable attr_reader :scanner alias_method :s, :scanner def_delegators :scanner, :scan, :matched private :s, :scan, :matched def initialize data @scanner = PhusionPassenger::Utils::StringScanner.new data.to_s end def parse object end private def space() scan WSP end def endkey() scan(KEY) or space end def object matched == '{' ? hash : array if scan(OBJ) end def value object or string or scan(NUL) ? nil : scan(BOL) ? matched.size == 4: scan(NUM) ? eval(matched) : error end def hash obj = {} space repeat_until(HEN) do space k = string scan(COL) obj[k] = value endkey end obj end def array ary = [] space repeat_until(AEN) do space ary << value endkey end ary end SPEC = {'b' => "\b", 'f' => "\f", 'n' => "\n", 'r' => "\r", 't' => "\t"} UNI = 'u'; CODE = /[a-fA-F0-9]{4}/ STR = /"/; STE = '"' ESC = '\\' def string if scan(STR) str, esc = '', false while c = s.getch if esc str << (c == UNI ? (s.scan(CODE) \|\| error).to_i(16).chr : SPEC[c] \|\| c) esc = false else case c when ESC then esc = true when STE then break else str << c end end end str end end def error raise "parse error at: #{scan(/.{1,20}/m).inspect}" end def repeat_until reg until scan(reg) pos = s.pos yield error unless s.pos > pos end end module Generator def generate(obj) raise ArgumentError unless obj.is_a? Array or obj.is_a? Hash generate_type(obj) end alias dump generate private def generate_type(obj) type = obj.is_a?(Numeric) ? :Numeric : obj.class.name.split('::').last begin send(:"generate_#{type}", obj) rescue NoMethodError; raise ArgumentError, "can't serialize #{type}" end end ESC_MAP = Hash.new {\|h,k\| k }.update \ "\r" => 'r', "\n" => 'n', "\f" => 'f', "\t" => 't', "\b" => 'b' def quote(str) %("#{str}") end def generate_String(str) quote str.gsub(/[\r\n\f\t\b"\\]/) { "\\#{ESC_MAP[$&]}"} end def generate_VersionComparer(vc) generate_String(vc) end def generate_simple(obj) obj.inspect end alias generate_Numeric generate_simple alias generate_TrueClass generate_simple alias generate_FalseClass generate_simple def generate_Symbol(sym) generate_String(sym.to_s) end def generate_Time(time) quote time.strftime(time.utc? ? "%F %T UTC" : "%F %T %z") end def generate_Date(date) quote date.to_s end def generate_NilClass(*) 'null' end def generate_Array(ary) '[%s]' % ary.map {\|o\| generate_type(o) }.join(', ') end def generate_Hash(hash) '{%s}' % hash.map { \|key, value\| "#{generate_String(key.to_s)}: #{generate_type(value)}" }.join(', ') end end extend Generator end end # module Utils end # module PhusionPassenger	4.94 KB	2025-11-20 11:36
📄 lock.rb # Phusion Passenger - https://www.phusionpassenger.com/ # Copyright (c) 2010-2025 Asynchronous B.V. # # "Passenger", "Phusion Passenger" and "Union Station" are registered # trademarks of Asynchronous B.V. # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in # all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN # THE SOFTWARE. module PhusionPassenger module Utils class Lock def initialize(mutex) @mutex = mutex @locked = false end def reset(mutex, lock_now = true) unlock if @locked @mutex = mutex lock if lock_now end def synchronize lock if !@locked begin yield(self) ensure unlock if @locked end end def lock raise if @locked @mutex.lock @locked = true end def unlock raise if !@locked @mutex.unlock @locked = false end end end # module Utils end # module PhusionPassenger	1.91 KB	2025-11-20 11:36
📄 native_support_utils.rb # Phusion Passenger - https://www.phusionpassenger.com/ # Copyright (c) 2010-2025 Asynchronous B.V. # # "Passenger", "Phusion Passenger" and "Union Station" are registered # trademarks of Asynchronous B.V. # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in # all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN # THE SOFTWARE. PhusionPassenger.require_passenger_lib 'native_support' module PhusionPassenger module Utils # Utility functions that can potentially be accelerated by native_support functions. module NativeSupportUtils extend self if defined?(PhusionPassenger::NativeSupport) # Split the given string into an hash. Keys and values are obtained by splitting the # string using the null character as the delimitor. def split_by_null_into_hash(data) return PhusionPassenger::NativeSupport.split_by_null_into_hash(data) end # Wrapper for getrusage(). def process_times return PhusionPassenger::NativeSupport.process_times end else NULL = "\0".freeze class ProcessTimes < Struct.new(:utime, :stime) end def split_by_null_into_hash(data) args = data.split(NULL, -1) args.pop return Hash[args] end def process_times times = Process.times return ProcessTimes.new((times.utime 1_000_000).to_i, (times.stime * 1_000_000).to_i) end end end end # module Utils end # module PhusionPassenger	2.43 KB	2025-11-20 11:36
📄 progress_bar.rb # Phusion Passenger - https://www.phusionpassenger.com/ # Copyright (c) 2014-2025 Asynchronous B.V. # # "Passenger", "Phusion Passenger" and "Union Station" are registered # trademarks of Asynchronous B.V. # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in # all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN # THE SOFTWARE. module PhusionPassenger class ProgressBar THROBBLER = ["-", "\\", "\|", "/", "-"] def initialize(output = STDOUT) @output = output @tty = output.tty? @throbbler_index = 0 end def set(percentage) if @tty width = (percentage * 50).to_i bar = "" width space = " " * (50 - width) text = sprintf("[%s%s] %s", bar, space, THROBBLER[@throbbler_index]) @throbbler_index = (@throbbler_index + 1) % THROBBLER.size @output.write("#{text}\r") @output.flush else @output.write(".") @output.flush end end def finish @output.write("\n") @output.flush end end end # module PhusionPassenger	1.97 KB	2025-11-20 11:36
📄 shellwords.rb # Polyfill for the shellwords library on Ruby 1.8.5. require 'shellwords' if !Shellwords.respond_to?(:escape) Shellwords.class_eval do def self.escape(str) # An empty argument will be skipped, so return empty quotes. return "''" if str.empty? str = str.dup # Treat multibyte characters as is. It is caller's responsibility # to encode the string in the right encoding for the shell # environment. str.gsub!(/([^A-Za-z0-9_\-.,:\/@\n])/, "\\\\\\1") # A LF cannot be escaped with a backslash because a backslash + LF # combo is regarded as line continuation and simply ignored. str.gsub!(/\n/, "'\n'") return str end end end if !Shellwords.respond_to?(:join) Shellwords.class_eval do def self.join(array) array.map { \|arg\| escape(arg) }.join(' ') end end end	856 B	2025-11-20 11:36
📄 strscan.rb # encoding: utf-8 # Phusion Passenger - https://www.phusionpassenger.com/ # Copyright (c) 2024-2025 Asynchronous B.V. # # "Passenger", "Phusion Passenger" and "Union Station" are registered # trademarks of Asynchronous B.V. # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in # all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN # THE SOFTWARE. module PhusionPassenger module Utils # A minimal pure-Ruby StringScanner implementation so that # PhusionPassenger::Utils::JSON doesn't have to depend on the 'strscan' gem. class StringScanner attr_reader :pos, :matched def initialize(data) @data = data @pos = 0 @matched = nil end def getch @matched = if @pos < @data.size @pos += 1 @data[@pos - 1] else nil end end def scan(pattern) md = @data[@pos .. -1].match(/\A#{pattern}/) @matched = if md @pos += md[0].size @matched = md[0] else nil end end def reset @pos = 0 end end end # module Utils end # module PhusionPassenger	1.97 KB	2025-11-20 11:36
📄 tee_input.rb # encoding: binary # # This file is taken from Unicorn. The following license applies to this file # (and this file only, not to the rest of Phusion Passenger): # # 1. You may make and give away verbatim copies of the source form of the # software without restriction, provided that you duplicate all of the # original copyright notices and associated disclaimers. # # 2. You may modify your copy of the software in any way, provided that # you do at least ONE of the following: # # a) place your modifications in the Public Domain or otherwise make them # Freely Available, such as by posting said modifications to Usenet or an # equivalent medium, or by allowing the author to include your # modifications in the software. # # b) use the modified software only within your corporation or # organization. # # c) rename any non-standard executables so the names do not conflict with # standard executables, which must also be provided. # # d) make other distribution arrangements with the author. # # 3. You may distribute the software in object code or executable # form, provided that you do at least ONE of the following: # # a) distribute the executables and library files of the software, # together with instructions (in the manual page or equivalent) on where # to get the original distribution. # # b) accompany the distribution with the machine-readable source of the # software. # # c) give non-standard executables non-standard names, with # instructions on where to get the original software distribution. # # d) make other distribution arrangements with the author. # # 4. You may modify and include the part of the software into any other # software (possibly commercial). But some files in the distribution # are not written by the author, so that they are not under this terms. # # 5. The scripts and library files supplied as input to or produced as # output from the software do not automatically fall under the # copyright of the software, but belong to whomever generated them, # and may be sold commercially, and may be aggregated with this # software. # # 6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR # IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED # WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR # PURPOSE. require 'stringio' PhusionPassenger.require_passenger_lib 'utils/tmpio' module PhusionPassenger module Utils # acts like tee(1) on an input input to provide a input-like stream # while providing rewindable semantics through a File/StringIO backing # store. On the first pass, the input is only read on demand so your # Rack application can use input notification (upload progress and # like). This should fully conform to the Rack::Lint::InputWrapper # specification on the public API. This class is intended to be a # strict interpretation of Rack::Lint::InputWrapper functionality and # will not support any deviations from it. # # When processing uploads, Unicorn exposes a TeeInput object under # "rack.input" of the Rack environment. class TeeInput CONTENT_LENGTH = "CONTENT_LENGTH".freeze HTTP_TRANSFER_ENCODING = "HTTP_TRANSFER_ENCODING".freeze CHUNKED = "chunked".freeze # The maximum size (in +bytes+) to buffer in memory before # resorting to a temporary file. Default is 112 kilobytes. @@client_body_buffer_size = 112 * 1024 # sets the maximum size of request bodies to buffer in memory, # amounts larger than this are buffered to the filesystem def self.client_body_buffer_size=(bytes) @@client_body_buffer_size = bytes end # returns the maximum size of request bodies to buffer in memory, # amounts larger than this are buffered to the filesystem def self.client_body_buffer_size @@client_body_buffer_size end # Initializes a new TeeInput object. You normally do not have to call # this unless you are writing an HTTP server. def initialize(socket, env) if @len = env[CONTENT_LENGTH] @len = @len.to_i elsif env[HTTP_TRANSFER_ENCODING] != CHUNKED @len = 0 end @socket = socket @bytes_read = 0 if @len && @len <= @@client_body_buffer_size @tmp = StringIO.new("") else @tmp = TmpIO.new("PassengerTeeInput") end @tmp.binmode end def close @tmp.close end def size if @len @len else pos = @tmp.pos consume! @tmp.pos = pos @len = @tmp.size end end def read(len = nil, buf = "") buf \|\|= "" if len if len < 0 raise ArgumentError, "negative length #{len} given" elsif len == 0 buf.replace('') buf else if socket_drained? @tmp.read(len, buf) else tee(read_exact(len, buf)) end end else if socket_drained? @tmp.read(nil, buf) else tee(read_all(buf)) end end end def gets if socket_drained? @tmp.gets else if @bytes_read == @len nil elsif line = @socket.gets if @len max_len = @len - @bytes_read line.slice!(max_len, line.size - max_len) end @bytes_read += line.size tee(line) else nil end end end def seek(args) if !socket_drained? # seek may be forward, or relative to the end, so we need to consume the socket fully into tmp pos = @tmp.pos # save/restore tmp.pos, to not break relative seeks consume! @tmp.pos = pos end @tmp.seek(args) end def rewind return 0 if 0 == @tmp.size consume! if !socket_drained? @tmp.rewind # Rack does not specify what the return value is here end def each while line = gets yield line end self # Rack does not specify what the return value is here end # Rack repeatedly introduces bugs that rely on this method existing # https://github.com/rack/rack/pull/1201 def eof? socket_drained? end private def socket_drained? if @socket if @socket.eof? @socket = nil true else false end else true end end # consumes the stream of the socket def consume! junk = "" nil while read(16 * 1024, junk) @socket = nil end def tee(buffer) if buffer && buffer.size > 0 @tmp.write(buffer) end buffer end def read_exact(len, buf) if @len max_len = @len - @bytes_read len = max_len if len > max_len return nil if len == 0 end ret = @socket.read(len, buf) @bytes_read += ret.size if ret ret end def read_all(buf) if @len ret = @socket.read(@len - @bytes_read, buf) if ret @bytes_read += ret.size ret else buf.replace("") buf end else ret = @socket.read(nil, buf) @bytes_read += ret.size ret end end end end # module Utils end # module PhusionPassenger	6.88 KB	2025-11-20 11:36
📄 terminal_choice_menu.rb # encoding: utf-8 # Phusion Passenger - https://www.phusionpassenger.com/ # Copyright (c) 2013-2025 Asynchronous B.V. # # "Passenger", "Phusion Passenger" and "Union Station" are registered # trademarks of Asynchronous B.V. # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in # all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN # THE SOFTWARE. module PhusionPassenger module Utils class TerminalChoiceMenu class Choice attr_reader :name attr_accessor :checked alias checked? checked def self.create(choice) if choice.is_a?(Choice) return choice else return Choice.new(choice) end end def initialize(name, checked = false) @name = name @checked = checked end def toggle! @checked = !@checked end end def initialize(choices, mode = :multiple_choice) @choices = choices.map { \|choice\| Choice.create(choice) } @mode = mode @pointer = 0 @index = index_choices end def display_choices display(render_to_string) end def query if STDIN.tty? done = false begin raw_no_echo_mode hide_cursor while !done display_choices done = process_input clear_screen if !done end if @mode == :single_choice [@pointer, @choices[@pointer].name] else nil end ensure restore_mode show_cursor puts end else display_choices puts nil end end def [](name) return @index[name] end def selected_choices @choices.find_all{ \|c\| c.checked? }.map{ \|c\| c.name } end private JRUBY = defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby' def index_choices index = {} @choices.each do \|choice\| index[choice.name] = choice end return index end def process_input case getchar(STDIN) when "\x1b" process_cursor_move false when " " if @mode == :multiple_choice process_toggle end false when "!" process_disable_utf8 false when "\r" true else false end end def process_cursor_move if getchar(STDIN) == "[" case getchar(STDIN) when "A" # up @pointer = [@pointer - 1, 0].max when "B" # down @pointer = [@pointer + 1, @choices.size - 1].min end end end def process_toggle @choices[@pointer].toggle! end def process_disable_utf8 ENV['UTF8_MENUS'] = '0' end def render_to_string str = "" @choices.each_with_index do \|choice, i\| pointer = render_pointer(i) checkbox = render_checkbox(choice.checked) str << " #{pointer} #{checkbox} #{choice.name}\r\n" end str.chomp! str end def render_pointer(index) @pointer == index ? maybe_utf8("‣", ">") : " " end def render_checkbox(checked) if @mode == :multiple_choice if checked maybe_utf8("⬢", "(*)") else maybe_utf8("⬡", "( )") end else nil end end def display(str) STDOUT.write(str) STDOUT.flush end def clear_screen number_of_lines = render_to_string.split("\n").size display("\r") (number_of_lines - 1).times do display(move_up) end end def maybe_utf8(utf8, plain) if ENV['UTF8_MENUS'] == '0' return plain else return utf8 end end def hide_cursor display("\x1b[?25l") end def show_cursor display("\x1b[?25h") end def move_up return "\x1b[0A" end def getchar(io) char = io.getc char = char.chr if char.is_a?(Integer) return char end if JRUBY require 'java' require 'readline' java_import 'jline.console.ConsoleReader' def raw_no_echo_mode input = STDIN.to_inputstream output = STDOUT.to_outputstream @console = ConsoleReader.new(input, output) @console.set_history_enabled(false) @console.set_bell_enabled(true) @console.set_pagination_enabled(false) @terminal_state = @console.getEchoCharacter @console.setEchoCharacter(0) end def restore_mode @console.setEchoCharacter(@terminal_state) @console.get_terminal.restore end else def raw_no_echo_mode @terminal_state = `stty -g` system("stty raw -echo -icanon isig") end def restore_mode system("stty #{@terminal_state}") end end end end # module Utils end # module PhusionPassenger	6.09 KB	2025-11-20 11:36
📄 tmpio.rb require 'tmpdir' require 'fileutils' module PhusionPassenger module Utils # some versions of Ruby had a broken Tempfile which didn't work # well with unlinked files. This one is much shorter, easier # to understand, and slightly faster. class TmpIO < File # creates and returns a new File object. The File is unlinked # immediately, switched to binary mode, and userspace output # buffering is disabled def self.new(namespace, options = nil) if options mode = options[:mode] \|\| RDWR binary = options.fetch(:binary, true) suffix = options[:suffix] unlink_immediately = options.fetch(:unlink_immediately, true) else mode = RDWR binary = true suffix = nil unlink_immediately = true end fp = begin super("#{Dir::tmpdir}/#{namespace}-#{rand(0x100000000).to_s(36)}#{suffix}", mode \| CREAT \| EXCL, 0600) rescue Errno::EEXIST retry end unlink(fp.path) if unlink_immediately fp.binmode if binary fp.sync = true fp end # for easier env["rack.input"] compatibility with Rack <= 1.1 def size stat.size end unless File.method_defined?(:size) end # Like Dir.mktmpdir, but creates shorter filenames. def self.mktmpdir(prefix_suffix=nil, tmpdir=nil) case prefix_suffix when nil prefix = "d" suffix = "" when String prefix = prefix_suffix suffix = "" when Array prefix = prefix_suffix[0] suffix = prefix_suffix[1] else raise ArgumentError, "unexpected prefix_suffix: #{prefix_suffix.inspect}" end tmpdir \|\|= Dir.tmpdir begin path = "#{tmpdir}/#{prefix}#{rand(0x100000000).to_s(36)}" path << suffix Dir.mkdir(path, 0700) rescue Errno::EEXIST retry end if block_given? begin yield path ensure FileUtils.remove_entry_secure path end else path end end end # module Utils end # module PhusionPassenger	1.87 KB	2025-11-20 11:36
📄 unseekable_socket.rb # Phusion Passenger - https://www.phusionpassenger.com/ # Copyright (c) 2010-2025 Asynchronous B.V. # # "Passenger", "Phusion Passenger" and "Union Station" are registered # trademarks of Asynchronous B.V. # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in # all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN # THE SOFTWARE. PhusionPassenger.require_passenger_lib 'utils' # So that we can know whether #writev is supported. # https://www.ruby-lang.org/en/news/2019/12/12/separation-of-positional-and-keyword-arguments-in-ruby-3-0/ def ruby2_keywords() end if RUBY_VERSION < "2.7" module PhusionPassenger module Utils # Some frameworks (e.g. Merb) call `seek` and `rewind` on the input stream # if it responds to these methods. In case of Phusion Passenger, the input # stream is a socket, and altough socket objects respond to `seek` and # `rewind`, calling these methods will raise an exception. We don't want # this to happen so in AbstractRequestHandler we wrap the client socket # into an UnseekableSocket wrapper, which doesn't respond to these methods. # # We used to dynamically undef `seek` and `rewind` on sockets, but this # blows the Ruby interpreter's method cache and made things slower. # Wrapping a socket is faster despite extra method calls. # # Furthermore, all exceptions originating from the wrapped socket will # be annotated. One can check whether a certain exception originates # from the wrapped socket by calling #source_of_exception? class UnseekableSocket def self.wrap(socket) return new.wrap(socket) end def wrap(socket) # Some people report that sometimes their Ruby (MRI/REE) # processes get stuck with 100% CPU usage. Upon further # inspection with strace, it turns out that these Ruby # processes are continuously calling lseek() on a socket, # which of course returns ESPIPE as error. gdb reveals # lseek() is called by fwrite(), which in turn is called # by rb_fwrite(). The affected socket is the # AbstractRequestHandler client socket. # # I inspected the MRI source code and didn't find # anything that would explain this behavior. This makes # me think that it's a glibc bug, but that's very # unlikely. # # The rb_fwrite() implementation takes an entirely # different code path if I set 'sync' to true: it will # skip fwrite() and use write() instead. So here we set # 'sync' to true in the hope that this will work around # the problem. socket.sync = true # There's no need to set the encoding for Ruby 1.9 because # abstract_request_handler.rb is tagged with 'encoding: binary'. @socket = socket return self end # Don't allow disabling of sync. def sync=(value) end # Socket is sync'ed so flushing shouldn't do anything. def flush end # Already set to binary mode. def binmode end # This makes select() work. def to_io @socket end def simulate_eof! @simulate_eof = true end def stop_simulating_eof! @simulate_eof = false end def fileno @socket.fileno end def addr @socket.addr rescue => e raise annotate(e) end def write(string) @socket.write(string) rescue => e raise annotate(e) end ruby2_keywords def write_nonblock(string, args) @socket.write_nonblock(string, args) rescue => e raise annotate(e) end def writev(components) @socket.writev(components) rescue => e raise annotate(e) end if IO.method_defined?(:writev) def writev2(components, components2) @socket.writev2(components, components2) rescue => e raise annotate(e) end if IO.method_defined?(:writev2) def writev3(components, components2, components3) @socket.writev3(components, components2, components3) rescue => e raise annotate(e) end if IO.method_defined?(:writev3) ruby2_keywords def send(args) @socket.send(args) rescue => e raise annotate(e) end ruby2_keywords def sendmsg(args) @socket.sendmsg(args) rescue => e raise annotate(e) end ruby2_keywords def sendmsg_nonblock(args) @socket.sendmsg_nonblock(args) rescue => e raise annotate(e) end ruby2_keywords def puts(args) @socket.puts(args) rescue => e raise annotate(e) end def gets return nil if @simulate_eof @socket.gets rescue => e raise annotate(e) end ruby2_keywords def read(args) if @simulate_eof length, buffer = args if buffer buffer.replace(binary_string("")) else buffer = binary_string("") end if length return nil else return buffer end end @socket.read(args) rescue => e raise annotate(e) end ruby2_keywords def read_nonblock(args) raise EOFError, "end of file reached" if @simulate_eof @socket.read_nonblock(args) rescue => e raise annotate(e) end ruby2_keywords def readpartial(args) raise EOFError, "end of file reached" if @simulate_eof @socket.readpartial(args) rescue => e raise annotate(e) end def readline raise EOFError, "end of file reached" if @simulate_eof @socket.readline rescue => e raise annotate(e) end ruby2_keywords def recv(args) raise EOFError, "end of file reached" if @simulate_eof @socket.recv(args) rescue => e raise annotate(e) end ruby2_keywords def recvfrom(args) raise EOFError, "end of file reached" if @simulate_eof @socket.recvfrom(args) rescue => e raise annotate(e) end ruby2_keywords def recvfrom_nonblock(args) raise EOFError, "end of file reached" if @simulate_eof @socket.recvfrom_nonblock(*args) rescue => e raise annotate(e) end def each(&block) return if @simulate_eof @socket.each(&block) rescue => e raise annotate(e) end def eof? return true if @simulate_eof @socket.eof? rescue => e raise annotate(e) end def closed? @socket.closed? rescue => e raise annotate(e) end def close @socket.close rescue => e raise annotate(e) end def close_read @socket.close_read rescue => e raise annotate(e) end def close_write @socket.close_write rescue => e raise annotate(e) end def source_of_exception?(exception) return exception.instance_variable_get(:"@from_unseekable_socket") == @socket.object_id end def to_hash { :socket => "Not JSON Encodable", :eof => @simulate_eof } end private def annotate(exception) exception.instance_variable_set(:"@from_unseekable_socket", @socket.object_id) return exception end def raise_error_because_activity_disallowed! raise IOError, "It is not possible to read or write from the client socket because the current." end if ''.respond_to?(:force_encoding) def binary_string(str) return ''.force_encoding('binary') end else def binary_string(str) return '' end end end end # module Utils end # module PhusionPassenger	8.7 KB	2025-11-20 11:36

Terminal