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
📄 apache.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' PhusionPassenger.require_passenger_lib 'platform_info/compiler' PhusionPassenger.require_passenger_lib 'platform_info/operating_system' PhusionPassenger.require_passenger_lib 'platform_info/linux' PhusionPassenger.require_passenger_lib 'utils/shellwords' module PhusionPassenger # Wow, I can't believe in how many ways one can build Apache in OS # X! We have to resort to all sorts of tricks to make Passenger build # out of the box on OS X. :-( # # In the name of usability and the "end user is the king" line of thought, # I shall suffer the horrible faith of writing tons of autodetection code! # Users can change the detection behavior by setting the environment variable # <tt>APXS2</tt> to the correct 'apxs' (or 'apxs2') binary, as provided by # Apache. module PlatformInfo ################ Programs ################ # The absolute path to the 'apxs' or 'apxs2' executable, or nil if not found. def self.apxs2 if env_defined?("APXS2") if ENV['APXS2'] == 'none' # This is a special value indicating that we should pretend as if # apxs2 is not found. It is applicable when the user is running # macOS >= 10.13 High Sierra, where apxs2 is not included in the OS. # When the user runs 'passenger-config about detect-apache2', # that command will tell the way to install against this specific # Apache is to run passenger-install-apache2-module --apxs2-path='none' return nil else return ENV["APXS2"] end end ['apxs2', 'apxs'].each do \|name\| command = find_command(name) if !command.nil? return command end end return nil end memoize :apxs2 # The absolute path to the 'apachectl' or 'apache2ctl' binary, or nil if # not found. def self.apache2ctl(options = {}) return find_apache2_executable('apache2ctl', 'apachectl2', 'apachectl', options) end memoize :apache2ctl # The absolute path to the Apache binary (that is, 'httpd', 'httpd2', 'apache' # or 'apache2'), or nil if not found. def self.httpd(options = {}) apxs2 = options.fetch(:apxs2, self.apxs2) if env_defined?('HTTPD') return ENV['HTTPD'] elsif apxs2.nil? ["apache2", "httpd2", "apache", "httpd"].each do \|name\| command = find_command(name) if !command.nil? return command end end return nil else return find_apache2_executable(`#{apxs2} -q TARGET`.strip, options) end end memoize :httpd # The Apache version, or nil if Apache is not found. def self.httpd_version(options = nil) if options httpd = options[:httpd] \|\| self.httpd(options) else httpd = self.httpd end if httpd `#{httpd} -v` =~ %r{Apache/([\d\.]+)} return $1 else return nil end end memoize :httpd_version # Run `apache2ctl -V` and return its output, or nil on failure. # # We used to run `httpd -V`, but on systems like Ubuntu it depends on various # environment variables or directories, wich apache2ctl loads or initializes. # # Because on some systems (mostly Ubuntu) `apache2ctl -V` attempts to parse # and load the config file, this command can fail because of configuration file # errors. def self.apache2ctl_V(options = nil) if options apache2ctl = options[:apache2ctl] \|\| self.apache2ctl(options) else apache2ctl = self.apache2ctl end if os_name_simple == "linux" && linux_distro_tags.include?(:gentoo) && apache2ctl == "/usr/sbin/apache2ctl" # On Gentoo, `apache2ctl -V` doesn't forward the command to `apache2 -V`, # but instead prints the OpenRC init system's version. # https://github.com/phusion/passenger/issues/1510 if options httpd = options[:httpd] \|\| self.httpd(options) else httpd = self.httpd end version_command = httpd else version_command = apache2ctl end if version_command create_temp_file("apache2ctl_V") do \|filename, f\| e_filename = Shellwords.escape(filename) output = `#{version_command} -V 2>#{e_filename}` if $? && $?.exitstatus == 0 stderr_text = File.open(filename, "rb") do \|f2\| f2.read end # This stderr message shows up on Ubuntu. We ignore it. stderr_text.sub!(/.Could not reliably determine the server's fully qualified domain name.\r?\n?/, "") # But we print the rest of stderr. STDERR.write(stderr_text) STDERR.flush output else nil end end else nil end end memoize :apache2ctl_V # The Apache executable's architectural bits. Returns 32 or 64, # or nil if unable to detect. def self.httpd_architecture_bits(options = nil) if options info = apache2ctl_V(options) else info = apache2ctl_V end if info info =~ %r{Architecture:(.)} text = $1 if text =~ /32/ 32 elsif text =~ /64/ 64 else nil end else nil end end memoize :httpd_architecture_bits # The default Apache root directory, as specified by its compilation parameters. # This may be different from the value of the ServerRoot directive. def self.httpd_default_root(options = nil) if options info = apache2ctl_V(options) else info = apache2ctl_V end if info info =~ / -D HTTPD_ROOT="(.+)"$/ return $1 else return nil end end memoize :httpd_default_root # The default Apache configuration file, or nil if Apache is not found. def self.httpd_default_config_file(options = nil) if options info = apache2ctl_V(options) else info = apache2ctl_V end if info info =~ /-D SERVER_CONFIG_FILE="(.+)"$/ filename = $1 if filename =~ /\A\// return filename else # Not an absolute path. Infer from default root. if root = httpd_default_root(options) return "#{root}/#{filename}" else return nil end end else return nil end end memoize :httpd_default_config_file # Given an Apache config file, returns the a hash with the following elements: # # `:files` - An array containing `config_file`, as well as all config files # included from that config file, including recursively included # ones. Only filenames that actually exist are put here. # * `:unreadable_files` - All config files that this function was unable # to read. def self.httpd_included_config_files(config_file, options = nil) state = { :files => { config_file => true }, :unreadable_files => [], :root => httpd_default_root(options) } scan_for_included_apache2_config_files(config_file, state, options) return { :files => state[:files].keys, :unreadable_files => state[:unreadable_files] } end # The default Apache error log's filename, as it is compiled into the Apache # main executable. This may not be the actual error log that is used. The actual # error log depends on the configuration file. # # Returns nil if Apache is not detected, or if the default error log filename # cannot be detected. def self.httpd_default_error_log(options = nil) if info = apache2ctl_V(options) info =~ /-D DEFAULT_ERRORLOG="(.+)"$/ filename = $1 if filename =~ /\A\// return filename else # Not an absolute path. Infer from default root. if root = httpd_default_root(options) return "#{root}/#{filename}" else return nil end end else return nil end end memoize :httpd_default_error_log def self.httpd_actual_error_log(options = nil) if config_file = httpd_default_config_file(options) begin contents = File.open(config_file, "rb") { \|f\| f.read } rescue Errno::ENOENT log "#{config_file} does not exist" return nil rescue Errno::EACCES log "Unable to open #{config_file} for reading" return nil end # We don't want to match comments contents.gsub!(/^[ \t]#./, '') if contents =~ /^[ \t]ErrorLog[ \t]+(.+)[ \t]$/i filename = unescape_apache_config_value($1, options) if filename && filename !~ /\A\// # Not an absolute path. Infer from root. if root = httpd_default_root(options) return "#{root}/#{filename}" else return nil end else return filename end elsif contents =~ /ErrorLog/i # The user apparently has ErrorLog set somewhere but # we can't parse it. The default error log location, # as reported by `apache2ctl -V`, may be wrong (it is on OS X). # So to be safe, let's assume that we don't know. log "Unable to parse ErrorLog directive in Apache configuration file" return nil else log "No ErrorLog directive in Apache configuration file" return httpd_default_error_log(options) end else return nil end end memoize :httpd_actual_error_log # The location of the Apache envvars file, which exists on some systems such as Ubuntu. # Returns nil if Apache is not found or if the envvars file is not found. def self.httpd_envvars_file(options = nil) if options httpd = options[:httpd] \|\| self.httpd(options) else httpd = self.httpd end httpd_dir = File.dirname(httpd) if httpd_dir == "/usr/bin" \|\| httpd_dir == "/usr/sbin" if File.exist?("/etc/apache2/envvars") return "/etc/apache2/envvars" elsif File.exist?("/etc/httpd/envvars") return "/etc/httpd/envvars" end end conf_dir = File.expand_path(File.dirname(httpd) + "/../conf") if File.exist?("#{conf_dir}/envvars") return "#{conf_dir}/envvars" end return nil end def self.httpd_infer_envvar(varname, options = nil) if envfile = httpd_envvars_file(options) result = `. '#{envfile}' && echo $#{varname}`.strip if $? && $?.exitstatus == 0 return result else return nil end else return nil end end # Returns the path to the Apache `mods-available` subdirectory, # or nil if it's not supported by this Apache. def self.httpd_mods_available_directory(options = nil) config_file = httpd_default_config_file(options) return nil if !config_file # mods-available is supposed to be a Debian extension that only works # on the APT-installed Apache, so only return non-nil if we're # working against the APT-installed Apache. config_dir = File.dirname(config_file) if config_dir == "/etc/httpd" \|\| config_dir == "/etc/apache2" if File.exist?("#{config_dir}/mods-available") && File.exist?("#{config_dir}/mods-enabled") return "#{config_dir}/mods-available" else return nil end else return nil end end memoize :httpd_mods_available_directory # Returns the path to the Apache `mods-enabled` subdirectory, # or nil if it's not supported by this Apache. def self.httpd_mods_enabled_directory(options = nil) config_file = httpd_default_config_file(options) return nil if !config_file # mods-enabled is supposed to be a Debian extension that only works # on the APT-installed Apache, so only return non-nil if we're # working against the APT-installed Apache. config_dir = File.dirname(config_file) if config_dir == "/etc/httpd" \|\| config_dir == "/etc/apache2" if File.exist?("#{config_dir}/mods-available") && File.exist?("#{config_dir}/mods-enabled") return "#{config_dir}/mods-enabled" else return nil end else return nil end end memoize :httpd_mods_enabled_directory # The absolute path to the 'a2enmod' executable. def self.a2enmod(options = {}) apxs2 = options.fetch(:apxs2, self.apxs2) dir = File.dirname(apxs2) if apxs2 # a2enmod is supposed to be a Debian extension that only works # on the APT-installed Apache, so only return non-nil if we're # working against the APT-installed Apache. if dir == "/usr/bin" \|\| dir == "/usr/sbin" if env_defined?('A2ENMOD') log "Using $A2ENMOD (= #{ENV['A2ENMOD']})" return ENV['A2ENMOD'] else return find_apache2_executable("a2enmod", options) end else log "Not applicable" nil end end memoize :a2enmod # The absolute path to the 'a2enmod' executable. def self.a2dismod(options = {}) apxs2 = options.fetch(:apxs2, self.apxs2) dir = File.dirname(apxs2) if apxs2 # a2dismod is supposed to be a Debian extension that only works # on the APT-installed Apache, so only return non-nil if we're # working against the APT-installed Apache. if dir == "/usr/bin" \|\| dir == "/usr/sbin" if env_defined?('A2DISMOD') log "Using $A2DISMOD (= #{ENV['A2DISMOD']})" return ENV['A2DISMOD'] else return find_apache2_executable("a2dismod", options) end else log "Not applicable" nil end end memoize :a2dismod # The absolute path to the 'apr-config' or 'apr-1-config' executable, # or nil if not found. def self.apr_config if env_defined?('APR_CONFIG') return ENV['APR_CONFIG'] elsif apxs2.nil? return nil else filename = `#{apxs2} -q APR_CONFIG 2>/dev/null`.strip if filename.empty? apr_bindir = `#{apxs2} -q APR_BINDIR 2>/dev/null`.strip if apr_bindir.empty? return nil else return select_executable(apr_bindir, "apr-1-config", "apr-config") end elsif File.exist?(filename) return filename else return nil end end end memoize :apr_config # The absolute path to the 'apu-config' or 'apu-1-config' executable, or nil # if not found. def self.apu_config if env_defined?('APU_CONFIG') return ENV['APU_CONFIG'] elsif apxs2.nil? return nil else filename = `#{apxs2} -q APU_CONFIG 2>/dev/null`.strip if filename.empty? apu_bindir = `#{apxs2} -q APU_BINDIR 2>/dev/null`.strip if apu_bindir.empty? return nil else return select_executable(apu_bindir, "apu-1-config", "apu-config") end elsif File.exist?(filename) return filename else return nil end end end memoize :apu_config # Find an executable in the Apache 'bin' and 'sbin' directories. # Returns nil if not found. def self.find_apache2_executable(possible_names) if possible_names.last.is_a?(Hash) options = possible_names.pop options = nil if options.empty? end if options dirs = options[:dirs] \|\| [apache2_bindir(options), apache2_sbindir(options)] else dirs = [apache2_bindir, apache2_sbindir] end dirs.each do \|bindir\| if bindir.nil? next end possible_names.each do \|name\| filename = "#{bindir}/#{name}" if !File.exist?(filename) log "Looking for #{filename}: not found" elsif !File.file?(filename) log "Looking for #{filename}: found, but is not a file" elsif !File.executable?(filename) log "Looking for #{filename}: found, but is not executable" else log "Looking for #{filename}: found" return filename end end end return nil end ################ Directories ################ # The absolute path to the Apache 2 'bin' directory, or nil if unknown. def self.apache2_bindir(options = {}) apxs2 = options.fetch(:apxs2, self.apxs2) if apxs2.nil? # macOS >= 10.13 High Sierra no longer ships apxs2, so we'll use # a hardcoded default. if os_name_simple == 'macosx' && os_version >= '10.13' \ && httpd(:apxs2 => apxs2) == '/usr/sbin/httpd' '/usr/bin' else nil end else return `#{apxs2} -q BINDIR 2>/dev/null`.strip end end memoize :apache2_bindir # The absolute path to the Apache 2 'sbin' directory, or nil if unknown. def self.apache2_sbindir(options = {}) apxs2 = options.fetch(:apxs2, self.apxs2) if apxs2.nil? # macOS >= 10.13 High Sierra no longer ships apxs2, so we'll use # a hardcoded default. if os_name_simple == 'macosx' && os_version >= '10.13' \ && httpd(:apxs2 => apxs2) == '/usr/sbin/httpd' '/usr/sbin' else nil end else return `#{apxs2} -q SBINDIR`.strip end end memoize :apache2_sbindir def self.apache2_modulesdir(options = {}) apxs2 = options.fetch(:apxs2, self.apxs2) if apxs2.nil? # macOS >= 10.13 High Sierra no longer ships apxs2, so we'll use # a hardcoded default. if os_name_simple == 'macosx' && os_version >= '10.13' \ && httpd(:apxs2 => apxs2) == '/usr/sbin/httpd' '/usr/libexec/apache2' else nil end else `#{apxs2} -q LIBEXECDIR`.strip end end memoize :apache2_modulesdir ################ Compiler and linker flags ################ def self.apache2_module_cflags(with_apr_flags = true) return apache2_module_c_or_cxxflags(:c, with_apr_flags) end memoize :apache2_module_cflags, true def self.apache2_module_cxxflags(with_apr_flags = true) return apache2_module_c_or_cxxflags(:cxx, with_apr_flags) end memoize :apache2_module_cxxflags, true # The C compiler flags that are necessary to compile an Apache module. # Also includes APR and APU compiler flags if with_apr_flags is true. def self.apache2_module_c_or_cxxflags(language, with_apr_flags = true) flags = [""] if (language == :c && cc_is_sun_studio?) \|\| (language == :cxx && cxx_is_sun_studio?) flags << "-KPIC" else flags << "-fPIC" end if with_apr_flags if language == :c flags << apr_cflags flags << apu_cflags else flags << apr_cxxflags flags << apu_cxxflags end end if apxs2.nil? # macOS >= 10.13 High Sierra no longer includes apxs2 # so we'll use hardcoded paths here. if os_name_simple == 'macosx' && os_version >= '10.13' && httpd == '/usr/sbin/httpd' # High Sierra doesn't have a consistent location for the Apache header # files. On Hongli's and Camden's systems it's inside the Xcode directory, # while on https://github.com/phusion/passenger/issues/1986 it's inside # /Library/Developer/CommandLineTools. flags << "-I#{`xcrun --show-sdk-path`.strip}/usr/include/apache2" end else apxs2_flags = `#{apxs2} -q CFLAGS`.strip << " -I" << `#{apxs2} -q INCLUDEDIR`.strip apxs2_flags.gsub!(/-O\d? /, '') if os_name_simple == "solaris" if (language == :c && !cc_is_sun_studio?) \|\| (language == :cxx && !cxx_is_sun_studio?) # Remove flags not supported by GCC # The big problem is Coolstack apxs includes a bunch of solaris -x directives. options = apxs2_flags.split options.reject! { \|f\| f =~ /^\-x/ } options.reject! { \|f\| f =~ /^\-Xa/ } options.reject! { \|f\| f =~ /^\-fast/ } options.reject! { \|f\| f =~ /^\-mt/ } options.reject! { \|f\| f =~ /^\-W2/ } apxs2_flags = options.join(' ') apxs2_flags.gsub!(/ ?-Qoption cg ?/, " ") end end if os_name_simple == "linux" && linux_distro_tags.include?(:redhat) && apxs2 == "/usr/sbin/apxs" && httpd_architecture_bits == 64 # The Apache package in CentOS 5 x86_64 is broken. # 'apxs -q CFLAGS' contains directives for compiling # the module as 32-bit, even though httpd itself # is 64-bit. Fix this. apxs2_flags.gsub!('-m32 -march=i386 -mtune=generic', '') end # Some Apache installations include '-pie' in CFLAGS, which # won't work on shared libraries. # https://github.com/phusion/passenger/issues/1756 apxs2_flags.gsub!('-pie', '') # macOS >= 10.12 Sierra no longer includes apr-config # so we'll use a hardcoded path here. if os_name_simple == 'macosx' && os_version >= '10.12' && httpd == '/usr/sbin/httpd' apxs2_flags << " -I#{`xcrun --show-sdk-path`.strip}/usr/include/apr-1" end apxs2_flags.strip! flags << apxs2_flags end if !httpd.nil? && os_name_simple == "macosx" # The default Apache install on OS X is a universal binary. # Figure out which architectures it's compiled for and do the same # thing for mod_passenger. We use the 'file' utility to do this. # # Running 'file' on the Apache executable usually outputs something # like this: # # /usr/sbin/httpd: Mach-O universal binary with 5 architectures # /usr/sbin/httpd (for architecture ppc7400): Mach-O executable ppc # /usr/sbin/httpd (for architecture ppc64): Mach-O 64-bit executable ppc64 # /usr/sbin/httpd (for architecture i386): Mach-O executable i386 # /usr/sbin/httpd (for architecture x86_64): Mach-O 64-bit executable x86_64 # /usr/sbin/httpd (for architecture arm64e): Mach-O 64-bit executable arm64 # # But on some machines, it may output just: # # /usr/sbin/httpd: Mach-O fat file with 4 architectures # # (http://code.google.com/p/phusion-passenger/issues/detail?id=236) output = `file "#{httpd}"`.strip if output =~ /Mach-O fat file/ && output !~ /for architecture/ architectures = ["i386", "ppc", "x86_64", "ppc64", "arm64"] else architectures = [] output.split("\n").grep(/for architecture/).each do \|line\| line =~ /for architecture (.?)\)/ arch = $1 arch = "arm64" if arch.start_with?("arm64") architectures << arch end end # The compiler may not support all architectures in the binary. # XCode 4 seems to have removed support for the PPC architecture # even though there are still plenty of Apache binaries around # containing PPC components. architectures.reject! do \|arch\| !compiler_supports_architecture?(arch) end architectures.map! do \|arch\| "-arch #{arch}" end flags << architectures.compact.join(' ') end return flags.compact.join(' ').strip end # Linker flags that are necessary for linking an Apache module. # Already includes APR and APU linker flags. def self.apache2_module_cxx_ldflags flags = "" if !apxs2.nil? flags << `#{apxs2} -q LDFLAGS`.strip end # We must include the cxxflags in the linker flags. On some multilib # Solaris systems, `apxs -q CFLAGS` outputs a flag that tells the compiler # which architecture to compile against, while `apxs -q LDFLAGS` doesn't. flags << " #{apache2_module_cxxflags} #{apr_cxx_ldflags} #{apu_cxx_ldflags}" if cxx_is_sun_studio? flags.gsub!("-fPIC", "-KPIC") flags << " -KPIC" if !flags.include?("-KPIC") else flags << " -fPIC" if !flags.include?("-fPIC") end flags.strip! flags end memoize :apache2_module_cxx_ldflags # The C compiler flags that are necessary for programs that use APR. def self.apr_cflags determine_apr_c_info[0] end # The C++ compiler flags that are necessary for programs that use APR. def self.apr_cxxflags determine_apr_c_info[0] end # The linker flags that are necessary for linking programs that use APR. def self.apr_c_ldflags determine_apr_c_info[1] end # The linker flags that are necessary for linking C++ programs that use APR. def self.apr_cxx_ldflags determine_apr_cxx_info[1] end # The C compiler flags that are necessary for programs that use APR-Util. def self.apu_cflags determine_apu_c_info[0] end # The C++ compiler flags that are necessary for programs that use APR-Util. def self.apu_cxxflags determine_apu_cxx_info[0] end # The linker flags that are necessary for linking C programs that use APR-Util. def self.apu_c_ldflags determine_apu_c_info[1] end # The linker flags that are necessary for linking C++ programs that use APR-Util. def self.apu_cxx_ldflags determine_apu_cxx_info[1] end ################ Miscellaneous information ################ # Returns whether it is necessary to use information outputted by 'apxs2' # in order to compile an Apache module. # # Since macOS 10.13 High Sierra apxs2 is no longer included in the # operating system, so we return false in that case. We'll fallback # to hardcoded paths. def self.apxs2_needed_for_building_apache_modules? !(os_name_simple == 'macosx' && os_version >= '10.13' && httpd == '/usr/sbin/httpd') end # Returns whether it is necessary to use information outputted by # 'apr-config' and 'apu-config' in order to compile an Apache module. # # When Apache is installed with --with-included-apr, the APR/APU # headers are placed into the same directory as the Apache headers, # and so 'apr-config' and 'apu-config' won't be necessary in that case. # # Also, since macOS 10.12 Sierra apr-config is no longer included # in the operating system, so we also return false in that case. # We'll fallback to hardcoded paths. def self.apr_config_needed_for_building_apache_modules? !( os_name_simple == 'macosx' && os_version >= '10.13' && httpd == '/usr/sbin/httpd' ) && !try_compile("whether APR is needed for building Apache modules", :c, "#include <apr.h>\n", apache2_module_cflags(false)) end memoize :apr_config_needed_for_building_apache_modules?, true private def self.determine_apr_info(language) if apr_config.nil? if os_name_simple == 'macosx' && httpd == '/usr/sbin/httpd' # macOS >= 10.12 Sierra does not supply apr-config, so # we use hardcoded defaults. if os_version >= '10.13' # On macOS >= 10.13 High Sierra /usr/include no longer # exists. # High Sierra doesn't have a consistent location for the Apache header # files. On Hongli's and Camden's systems it's inside the Xcode directory, # while on https://github.com/phusion/passenger/issues/1986 it's inside # /Library/Developer/CommandLineTools. ["-I#{`xcrun --show-sdk-path`.strip}/usr/include/apr-1", '-lapr-1'] else ['-I/usr/include/apr-1', '-lapr-1'] end else [nil, nil] end else flags = `#{apr_config} --cppflags --includes`.strip libs = `#{apr_config} --link-ld`.strip flags.gsub!(/-O\d? /, '') if os_name_simple == "solaris" if (language == :c && !cc_is_sun_studio?) \|\| (language == :cxx && !cxx_is_sun_studio?) # Remove flags not supported by non-Sun Studio compilers flags = flags.split(/ +/).reject do \|f\| f =~ /^\-mt/ end flags = flags.join(' ') end elsif os_name_simple == "aix" libs << " -Wl,-G -Wl,-brtl" end [flags, libs] end end private_class_method :determine_apr_info def self.determine_apr_c_info determine_apr_info(:c) end private_class_method :determine_apr_c_info memoize :determine_apr_c_info, true def self.determine_apr_cxx_info determine_apr_info(:cxx) end private_class_method :determine_apr_cxx_info memoize :determine_apr_cxx_info, true def self.determine_apu_info(language) if apu_config.nil? if os_name_simple == 'macosx' && httpd == '/usr/sbin/httpd' # macOS >= 10.12 Sierra does not supply apu-config, so # we use hardcoded defaults. if os_version >= '10.13' # On macOS >= 10.13 High Sierra /usr/include no longer # exists. ["-I#{`xcrun --show-sdk-path`.strip}/usr/include/apr-1", '-laprutil-1'] else ['-I/usr/include/apr-1', '-laprutil-1'] end else [nil, nil] end else flags = `#{apu_config} --includes`.strip libs = `#{apu_config} --link-ld`.strip flags.gsub!(/-O\d? /, '') if os_name_simple == "solaris" if (language == :c && !cc_is_sun_studio?) \|\| (language == :cxx && !cxx_is_sun_studio?) # Remove flags not supported by non-Sun Studio compilers flags = flags.split(/ +/).reject do \|f\| f =~ /^\-mt/ end flags = flags.join(' ') end end [flags, libs] end end private_class_method :determine_apu_info def self.determine_apu_c_info determine_apu_info(:c) end private_class_method :determine_apu_c_info memoize :determine_apu_c_info, true def self.determine_apu_cxx_info determine_apu_info(:cxx) end private_class_method :determine_apu_cxx_info memoize :determine_apu_cxx_info, true def self.scan_for_included_apache2_config_files(config_file, state, options = nil) begin config = File.open(config_file, "rb") do \|f\| f.read end rescue Errno::EACCES state[:unreadable_files] << config_file return end found_filenames = [] config.scan(/^[ \t](Include(Optional)?\|ServerRoot)[ \t]+(.+?)[ \t]$/i) do \|match\| if match[0].downcase == "serverroot" new_root = unescape_apache_config_value(match[2], options) state[:root] = new_root if new_root else filename = unescape_apache_config_value(match[2], options) next if filename.nil? \|\| filename.empty? if filename !~ /\A\// # Not an absolute path. Infer from root. filename = "#{state[:root]}/#{filename}" end expand_apache2_glob(filename).each do \|filename2\| if !state[:files].has_key?(filename2) state[:files][filename2] = true scan_for_included_apache2_config_files(filename2, state, options) end end end end end private_class_method :scan_for_included_apache2_config_files def self.expand_apache2_glob(glob) if File.directory?(glob) glob = glob.sub(/\/$/, '') result = Dir["#{glob}//"] else result = [] Dir[glob].each do \|filename\| if File.directory?(filename) result.concat(Dir["#{filename}/*/"]) else result << filename end end end result.reject! do \|filename\| File.directory?(filename) end return result end private_class_method :expand_apache2_glob def self.unescape_apache_config_value(value, options = nil) if value =~ /^"(.*)"$/ value = unescape_c_string($1) end if value.include?("${") log "Attempting to substitute environment variables in Apache config value #{value.inspect}..." end # The Apache config file supports environment variable # substitution. Ubuntu uses this extensively. value.gsub!(/\$\{(.+?)\}/) do \|varname\| if substitution = httpd_infer_envvar($1, options) log "Substituted \"#{varname}\" -> \"#{substitution}\"" substitution else log "Cannot substitute \"#{varname}\"" varname end end if value.include?("${") # We couldn't substitute everything. return nil else return value end end private_class_method :unescape_apache_config_value def self.unescape_c_string(s) state = 0 res = '' backslash = "\\" s.each_char do \|c\| case state when 0 case c when backslash then state = 1 else res << c end when 1 case c when 'n' then res << "\n"; state = 0 when 't' then res << "\t"; state = 0 when backslash then res << backslash; state = 0 else res << backslash; res << c; state = 0 end end end return res end private_class_method :unescape_c_string end end	34.71 KB	2025-11-20 11:36
📄 apache_detector.rb # 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 'constants' PhusionPassenger.require_passenger_lib 'platform_info' PhusionPassenger.require_passenger_lib 'platform_info/ruby' PhusionPassenger.require_passenger_lib 'platform_info/apache' PhusionPassenger.require_passenger_lib 'utils/ansi_colors' require 'pathname' module PhusionPassenger module PlatformInfo # Detects all possible Apache installations on the system, and presents the # autodetection information to the user in a friendly way. It turns out too # many people have multiple Apache installations on their system, but they # don't know about that, or they don't know how to compile against the # correct Apache installation. This tool helps them. # # If you use this class to log things to the terminal, then be sure to set # the terminal color to Utils::AnsiColors::DEFAULT_TERMINAL_COLOR. class ApacheDetector class Result # These are required and are never nil. attr_accessor :apxs2, :httpd, :ctl, :version # These are optional and may be nil. attr_accessor :a2enmod, :a2dismod # Ttis may be nil. It depends on whether 'apache2ctl -V' succeeds. attr_accessor :config_file # This may be nil. It depends on how well we can infer information from the config file. attr_accessor :error_log attr_writer :config_file_broken def initialize(detector) @detector = detector end def config_file_broken? @config_file_broken end def report log " <b>* Found Apache #{version}!</b>" log " Information:" log " apxs2 : #{apxs2 \|\| 'N/A'}" log " Main executable: #{httpd}" log " Control command: #{ctl}" log " Config file : #{config_file \|\| 'unknown'}" log " Error log file : #{error_log \|\| 'unknown'}" if config_file_broken? log "" log " WARNING:" log " <red>The configuration file seems to be broken! Please double-check it by running:</red>" log " <red>#{ctl} -t</red>" end log "" log " To install #{PROGRAM_NAME} against this specific Apache version:" log " #{PlatformInfo.ruby_command} #{PhusionPassenger.bin_dir}/passenger-install-apache2-module --apxs2-path='#{apxs2 \|\| 'none'}'" log "" log " To start, stop or restart this specific Apache version:" log " #{ctl} start" log " #{ctl} stop" log " #{ctl} restart" log "" if error_log log " To troubleshoot, please read the logs in this file:" log " #{error_log}" log "" end end private def log(message) @detector.send(:log, message) end end attr_reader :results def initialize(output) @output = output @results = [] @failures = 0 PlatformInfo.verbose = true PlatformInfo.log_implementation = lambda do \|message\| if message =~ /: found$/ log("<green> --> #{message}</green>") else log(" --> #{message}") end end end def finish PlatformInfo.verbose = false PlatformInfo.log_implementation = nil end def detect_all log "<banner>Looking for possible Apache installations...</banner>" apxses = PlatformInfo.find_all_commands("apxs2") + PlatformInfo.find_all_commands("apxs") if PlatformInfo.apxs2 && !apxses.include?(PlatformInfo.apxs2) PlatformInfo.send(:log, "Looking for #{PlatformInfo.apxs2}: found") apxses << PlatformInfo.apxs2 end apxses = remove_symlink_duplications(apxses) log "" apxses.each do \|apxs2\| detect_one(apxs2) end # macOS >= 10.13 High Sierra no longer ships apxs2, but we'll want to perform # an autodetection run against the OS-provided Apache installation anyway. if PlatformInfo.os_name_simple == 'macosx' && PlatformInfo.os_version >= '10.13' detect_one(nil) end end def detect_one(apxs2) # Note: apxs2 is nil on macOS 10.13 High Sierra. See comment in #detect_all. apxs2_description = apxs2 \|\| 'OS-default Apache installation' log "<banner>Analyzing #{apxs2_description}...</banner>" add_result do \|result\| result.apxs2 = apxs2 log "Detecting main Apache executable..." result.httpd = PlatformInfo.httpd(:apxs2 => apxs2) if result.httpd log "Detecting version..." if result.version = PlatformInfo.httpd_version(:httpd => result.httpd) log " --> #{result.version}" else log "<red> --> Cannot detect version!</red>" result.httpd = nil end end if result.httpd log "Detecting control command..." result.ctl = PlatformInfo.apache2ctl(:apxs2 => apxs2) result.httpd = nil if !result.ctl end if result.httpd log "Detecting configuration file location..." result.config_file = PlatformInfo.httpd_default_config_file( :httpd => result.httpd, :apache2ctl => result.ctl) if result.config_file log " --> #{result.config_file}" else log "<red> --> Cannot detect default config file location!</red>" end end if result.httpd log "Detecting error log file..." result.error_log = PlatformInfo.httpd_actual_error_log( :httpd => result.httpd, :apache2ctl => result.ctl) if result.error_log log " --> #{result.error_log}" else log "<red> --> Cannot detect error log file!</red>" end end if result.httpd log "Detecting a2enmod and a2dismod..." result.a2enmod = PlatformInfo.a2enmod(:apxs2 => apxs2) result.a2dismod = PlatformInfo.a2dismod(:apxs2 => apxs2) end if result.httpd result.config_file_broken = PlatformInfo.apache2ctl_V(:apxs2 => apxs2, :apache2ctl => result.ctl).nil? end if result.httpd log "<green>Found a usable Apache installation using #{apxs2_description}.</green>" true else log "<yellow>Cannot find a usable Apache installation using #{apxs2_description}.</yellow>" false end end log "" end def report if @failures > 0 && Process.uid != 0 user = `whoami`.strip sudo_s_e = PhusionPassenger::PlatformInfo.ruby_sudo_shell_command("-E") ruby = PhusionPassenger::PlatformInfo.ruby_command log "" log "----------------------------" log "" log "<red>Permission problems</red>" log "" log "Sorry, this program doesn't have enough permissions to autodetect all your" log "Apache installations, because it's running as the <b>#{`whoami`.strip}</b> user." log "Please re-run this program with root privileges:" log "" log " <b>export ORIG_PATH=\"$PATH\"</b>" log " <b>#{sudo_s_e}</b>" log " <b>export PATH=\"$ORIG_PATH\"</b>" log " <b>#{ruby} #{PhusionPassenger.bin_dir}/passenger-config --detect-apache2</b>" return end log "<banner>Final autodetection results</banner>" @results.each do \|result\| result.report end if @results.empty? PhusionPassenger.require_passenger_lib 'platform_info/depcheck' PlatformInfo::Depcheck.load("depcheck_specs/apache2") apache2 = PlatformInfo::Depcheck.find("apache2") apache2_install_instructions = apache2.install_instructions.split("\n").join("\n ") # apxs2 is part of the development headers. apache2_dev = PlatformInfo::Depcheck.find("apache2-dev") apache2_dev_install_instructions = apache2_dev.install_instructions.split("\n").join("\n ") log "<red>Sorry, this program cannot find an Apache installation.</red>" log "" log "Please install Apache and its development headers." log "" log " <yellow>* To install Apache:</yellow>" log " #{apache2_install_instructions}" log "" log " <yellow>* To install Apache development headers:</yellow>" log " #{apache2_dev_install_instructions}" log "" log "If you are sure that you have Apache installed, please read the documentation:" log "<b>https://www.phusionpassenger.com/library/install/apache/customizing_compilation_process.html#forcing-location-of-command-line-tools-and-dependencies</b>" elsif @results.size > 1 log "<yellow>WARNING: You have multiple Apache installations on your system!</yellow>" log "You are strongly recommended to read this section of the documentation:" log "<b>https://www.phusionpassenger.com/library/install/apache/multiple_apache_installs.html</b>" end end def result_for(apxs2) # All the results use realpaths, so the input must too. apxs2 = try_realpath(apxs2) return @results.find { \|r\| r.apxs2 == apxs2 } end private def log(message) if @output.tty? @output.puts(Utils::AnsiColors.ansi_colorize(message)) else @output.puts(Utils::AnsiColors.strip_color_tags(message)) end end # On Ubuntu, /usr/bin/apxs2 is a symlink to /usr/bin/apxs. # On recent Arch Linux releases, /bin, /sbin etc are symlinks to # /usr/bin and /usr/sbin. # We're only supposed to detect one Apache in that case so we need to # resolve symlinks. def remove_symlink_duplications(filenames) old_size = filenames.size filenames = filenames.map do \|filename\| try_realpath(filename) end filenames.uniq! if old_size != filenames.size log "#{old_size - filenames.size} symlink duplicate(s) detected; ignoring them." end return filenames end def add_result result = Result.new(self) if yield(result) @results << result else @failures += 1 end end def try_realpath(path) if path begin Pathname.new(path).realpath.to_s rescue Errno::ENOENT, Errno::EACCES, Errno::ENOTDIR path end else nil end end end end end # module Phusion Passenger	12.01 KB	2025-11-20 11:36
📄 binary_compatibility.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. require 'rbconfig' PhusionPassenger.require_passenger_lib 'platform_info' PhusionPassenger.require_passenger_lib 'platform_info/ruby' PhusionPassenger.require_passenger_lib 'platform_info/operating_system' module PhusionPassenger module PlatformInfo # Returns a string that describes the current Ruby # interpreter's extension binary compatibility. A Ruby extension # compiled for a certain Ruby interpreter can also be loaded on # a different Ruby interpreter with the same binary compatibility # identifier. # # The result depends on the following factors: # - Ruby engine name. # - Ruby extension version. # This is not the same as the Ruby language version, which # identifies language-level compatibility. This is rather about # binary compatibility of extensions. # MRI seems to break source compatibility between tiny releases, # though patchlevel releases tend to be source and binary # compatible. # - Ruby extension architecture. # This is not necessarily the same as the operating system # runtime architecture or the CPU architecture. # For example, in case of JRuby, the extension architecture is # just "java" because all extensions target the Java platform; # the architecture the JVM was compiled for has no effect on # compatibility. # On systems with universal binaries support there may be multiple # architectures. In this case the architecture is "universal" # because extensions must be able to support all of the Ruby # executable's architectures. # - The operating system for which the Ruby interpreter was compiled. def self.ruby_extension_binary_compatibility_id ruby_engine = defined?(RUBY_ENGINE) ? RUBY_ENGINE : "ruby" ruby_ext_version = RUBY_VERSION if RUBY_PLATFORM =~ /darwin/ if RUBY_PLATFORM =~ /universal/ ruby_arch = "universal" else # OS X often prints something like: # "/opt/ruby-enterprise/bin/ruby: Mach-O 64-bit executable x86_64" output = `file -L "#{ruby_executable}"`.lines.first.strip ruby_arch = output.split.last if ruby_arch == "executable" # some OS X print something like: # "/opt/ruby-enterprise/bin/ruby: Mach-O 64-bit executable" if output =~ /arm64/ ruby_arch = "arm64" elsif output =~ /Mach-O 64-bit/ ruby_arch = "x86_64" else raise "Cannot autodetect the Ruby interpreter's architecture" end end end elsif RUBY_PLATFORM == "java" ruby_arch = "java" else ruby_arch = cpu_architectures[0] end return "#{ruby_engine}-#{ruby_ext_version}-#{ruby_arch}-#{os_name_simple}" end memoize :ruby_extension_binary_compatibility_id # Returns an identifier string that describes the current # platform's binary compatibility with regard to C/C++ # binaries. Two systems with the same binary compatibility # identifiers should be able to run the same C/C++ binaries. # # The the string depends on the following factors: # - The operating system name. # - Operating system runtime identifier. # This may include the kernel version, libc version, C++ ABI version, # etc. Everything that is of interest for binary compatibility with # regard to C/C++ binaries. # - Operating system default runtime architecture. # This is not the same as the CPU architecture; some CPUs support # multiple architectures, e.g. Intel Core 2 Duo supports x86 and # x86_64. Some operating systems actually support multiple runtime # architectures: a lot of x86_64 Linux distributions also include # 32-bit runtimes, and OS X Snow Leopard is x86_64 by default but # all system libraries also support x86. # This component identifies the architecture that is used when # compiling a binary with the system's C++ compiler with its default # options. def self.cxx_binary_compatibility_id if os_name_simple == "macosx" # RUBY_PLATFORM gives us the kernel version, but we want # the OS X version. # sw_vers returns something like "10.6.2". We're only # interested in the first two digits (MAJOR.MINOR) since # tiny releases tend to be binary compatible with each # other. After macOS 10.15 Apple switched to bumping major # versions (like 11.0, 12.0) so we need to look at that. # However, if the env var SYSTEM_VERSION_COMPAT=1 then # macOS 11 reports as 10.16 (and so on), so we need to deal with that too. major, minor, *rest = os_version.split(".").map(&:to_i) os_version_string = if major >= 11 major elsif minor >= 16 # 10.16 -> 11 # 10.17 -> 12 minor - 5 else "#{major}.#{minor}" end os_runtime = os_version_string.to_s else os_runtime = nil end os_arch = cpu_architectures[0] return [os_arch, os_name_simple, os_runtime].compact.join("-") end memoize :cxx_binary_compatibility_id end end # module PhusionPassenger	6.52 KB	2025-11-20 11:36
📄 compiler.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 'platform_info' PhusionPassenger.require_passenger_lib 'platform_info/operating_system' module PhusionPassenger module PlatformInfo private def self.detect_language_extension(language) case language when :c return "c" when :cxx return "cpp" else raise ArgumentError, "Unsupported language #{language.inspect}" end end private_class_method :detect_language_extension def self.detect_compiler_type_name(language) case language when :c return "C" when :cxx return "C++" else raise ArgumentError, "Unsupported language #{language.inspect}" end end private_class_method :detect_compiler_type_name def self.create_compiler_command(language, flags1, flags2, link = false) case language when :c result = [cc, link ? ENV['EXTRA_PRE_LDFLAGS'] : nil, ENV['EXTRA_PRE_CFLAGS'], flags1, flags2, ENV['EXTRA_CFLAGS'], ENV['EXTRA_LDFLAGS']] when :cxx result = [cxx, link ? ENV['EXTRA_PRE_LDFLAGS'] : nil, ENV['EXTRA_PRE_CXXFLAGS'], flags1, flags2, ENV['EXTRA_CXXFLAGS'], ENV['EXTRA_LDFLAGS']] else raise ArgumentError, "Unsupported language #{language.inspect}" end return result.compact.join(" ").strip end private_class_method :create_compiler_command def self.run_compiler(description, command, source_file, source, capture_output = false) if verbose? message = "#{description}\n" << "Running: #{command}\n" if source.strip.empty? message << "Source file is empty." else message << "Source file contains:\n" << "-------------------------\n" << unindent(source) << "\n-------------------------" end log(message) end if capture_output begin output = `#{command} 2>&1` result = $?.exitstatus == 0 rescue SystemCallError => e result = nil exec_error_reason = e.message end log("Output:\n" << "-------------------------\n" << output.to_s << "\n-------------------------") elsif verbose? result = system(command) else result = system("(#{command}) >/dev/null 2>/dev/null") end if result.nil? log("Command could not be executed! #{exec_error_reason}".strip) return false elsif result log("Check succeeded") if capture_output return { :result => true, :output => output } else return true end else log("Check failed with exit status #{$?.exitstatus}") if capture_output == :always return { :result => false, :output => output } else return false end end end private_class_method :run_compiler def self.cc_or_cxx_supports_feliminate_unused_debug?(language) ext = detect_language_extension(language) compiler_type_name = detect_compiler_type_name(language) create_temp_file("passenger-compile-check.#{ext}") do \|filename, f\| f.close begin command = create_compiler_command(language, "-c '#{filename}' -o '#{filename}.o'", '-feliminate-unused-debug-symbols -feliminate-unused-debug-types') result = run_compiler("Checking for #{compiler_type_name} compiler '-feliminate-unused-debug-{symbols,types}' support", command, filename, '', true) return result && result[:output].empty? ensure File.unlink("#{filename}.o") rescue nil end end end private_class_method :cc_or_cxx_supports_feliminate_unused_debug? def self.cc_or_cxx_supports_blocks?(language) command = create_compiler_command(language,"-E -dM",'- </dev/null') result = `#{command}` return result.include? "__BLOCKS__" end private_class_method :cc_or_cxx_supports_blocks? public def self.cc return string_env('CC', default_cc) end memoize :cc def self.cxx return string_env('CXX', default_cxx) end memoize :cxx def self.default_cc # On most platforms, we'll want to use the same compiler as what the rest # of the system uses, so that we generate compatible binaries. That's # most likely the 'cc' command. We used to use 'gcc' by default. # # See for example this issue with OS X Mavericks (10.9). They switched from # GCC to Clang as the default compiler. Since the Nginx by default uses 'cc' # as the compiler, we'll have to do that too. Otherwise we'll get C++ linker # errors because Nginx is compiled with Clang while Phusion Passenger is # compiled with GCC. # https://code.google.com/p/phusion-passenger/issues/detail?id=950 if PlatformInfo.find_command('cc') return 'cc' else return 'gcc' end end def self.default_cxx if PlatformInfo.find_command('c++') return 'c++' else return 'g++' end end def self.cc_is_gcc? `#{cc} -v 2>&1` =~ /gcc version/ end memoize :cc_is_gcc? def self.cxx_is_gcc? `#{cxx} -v 2>&1` =~ /gcc version/ end memoize :cxx_is_gcc? def self.cc_is_clang? `#{cc} --version 2>&1` =~ /clang( version\|-)/ end memoize :cc_is_clang? def self.cxx_is_clang? `#{cxx} --version 2>&1` =~ /clang( version\|-)/ end memoize :cxx_is_clang? def self.cc_is_sun_studio? `#{cc} -V 2>&1` =~ /Sun C/ \|\| `#{cc} -flags 2>&1` =~ /Sun C/ end memoize :cc_is_sun_studio? def self.cxx_is_sun_studio? `#{cxx} -V 2>&1` =~ /Sun C/ \|\| `#{cxx} -flags 2>&1` =~ /Sun C/ end memoize :cxx_is_sun_studio? # Looks for the given C or C++ header. This works by invoking the compiler and # searching in the compiler's header search path. Returns its full filename, # or true if this function knows that the header exists but can't find it (e.g. # because the compiler cannot tell us what its header search path is). # Returns nil if the header cannot be found. def self.find_header(header_name, language, flags = nil) extension = detect_language_extension(language) create_temp_file("passenger-compile-check.#{extension}") do \|filename, f\| source = %Q{ #include <#{header_name}> } f.puts(source) f.close begin command = create_compiler_command(language, "-v -c '#{filename}' -o '#{filename}.o'", flags) if result = run_compiler("Checking for #{header_name}", command, filename, source, true) result[:output] =~ /^#include <...> search starts here:$(.+?)^End of search list\.$/m search_paths = $1.to_s.strip.split("\n").map{ \|line\| line.strip } search_paths.each do \|dir\| if File.file?("#{dir}/#{header_name}") return "#{dir}/#{header_name}" end end return true else return nil end ensure File.unlink("#{filename}.o") rescue nil end end end def self.try_compile(description, language, source, flags = nil) extension = detect_language_extension(language) create_temp_file("passenger-compile-check.#{extension}") do \|filename, f\| f.puts(source) f.close command = create_compiler_command(language, "-c '#{filename}' -o '#{filename}.o'", flags) return run_compiler(description, command, filename, source) end end # Like try_compile, but designed for checking whether a warning flag is # supported. Compilers sometimes do not error out upon encountering an # unsupported warning flag, but merely print a warning. This method checks # for that too. def self.try_compile_with_warning_flag(description, language, source, flags = nil) extension = detect_language_extension(language) result = nil create_temp_file("passenger-compile-check.#{extension}") do \|filename, f\| f.puts(source) f.close command = create_compiler_command(language, "-c '#{filename}' -o '#{filename}.o'", flags) result = run_compiler(description, command, filename, source, true) result = result && result[:result] && result[:output] !~ /unknown warning option\|unrecognized command line option/i end return false if !result # For some reason, GCC does not complain about a warning flag # not being supported unless the source contains another error. So we # check for this. create_temp_file("passenger-compile-check.#{extension}") do \|filename, f\| source = %Q{ void foo() { return error; } } f.puts(source) f.close command = create_compiler_command(language, "-c '#{filename}' -o '#{filename}.o'", flags) result = run_compiler("#{description} (really)", command, filename, source, :always) end result && !result[:output].include?(flags) end def self.try_link(description, language, source, flags = nil) extension = detect_language_extension(language) create_temp_file("passenger-link-check.#{extension}") do \|filename, f\| f.puts(source) f.close command = create_compiler_command(language, "'#{filename}' -o '#{filename}.out'", flags, true) return run_compiler(description, command, filename, source) end end def self.try_compile_and_run(description, language, source, flags = nil) extension = detect_language_extension(language) create_temp_file("passenger-run-check.#{extension}", tmpexedir) do \|filename, f\| f.puts(source) f.close command = create_compiler_command(language, "'#{filename}' -o '#{filename}.out'", flags, true) if run_compiler(description, command, filename, source) log("Running #{filename}.out") begin output = `'#{filename}.out' 2>&1` rescue SystemCallError => e log("Command failed: #{e}") return false end status = $?.exitstatus log("Command exited with status #{status}. Output:\n--------------\n#{output}\n--------------") return status == 0 else return false end end end # Checks whether the compiler supports "-arch #{arch}". def self.compiler_supports_architecture?(arch) return try_compile("Checking for C compiler '-arch' support", :c, '', "-arch #{arch}") end def self.cc_supports_visibility_flag? return false if os_name_simple == "aix" return try_compile("Checking for C compiler '-fvisibility' support", :c, '', '-fvisibility=hidden') end memoize :cc_supports_visibility_flag?, true def self.cc_supports_fno_limit_debug_info_flag? try_compile_with_warning_flag( "Checking for C compiler '-fno-limit-debug-info' support", :c, '', '-fno-limit-debug-info') end memoize :cc_supports_fno_limit_debug_info_flag? def self.cc_supports_fno_optimize_sibling_calls_flag? try_compile_with_warning_flag( "Checking for C compiler '-fno-optimize-sibling-calls' support", :c, '', '-fno-optimize-sibling-calls') end memoize :cc_supports_fno_optimize_sibling_calls_flag? def self.cxx_supports_visibility_flag? return false if os_name_simple == "aix" return try_compile("Checking for C++ compiler '-fvisibility' support", :cxx, '', '-fvisibility=hidden') end memoize :cxx_supports_visibility_flag?, true def self.cc_supports_wno_attributes_flag? return try_compile_with_warning_flag( "Checking for C compiler '-Wno-attributes' support", :c, '', '-Wno-attributes') end memoize :cc_supports_wno_attributes_flag?, true def self.cxx_supports_wno_attributes_flag? return try_compile_with_warning_flag( "Checking for C++ compiler '-Wno-attributes' support", :cxx, '', '-Wno-attributes') end memoize :cxx_supports_wno_attributes_flag?, true def self.cc_supports_wno_missing_field_initializers_flag? return try_compile_with_warning_flag( "Checking for C compiler '-Wno-missing-field-initializers' support", :c, '', '-Wno-missing-field-initializers') end memoize :cc_supports_wno_missing_field_initializers_flag?, true def self.cxx_supports_wno_missing_field_initializers_flag? return try_compile_with_warning_flag( "Checking for C++ compiler '-Wno-missing-field-initializers' support", :cxx, '', '-Wno-missing-field-initializers') end memoize :cxx_supports_wno_missing_field_initializers_flag?, true def self.cc_supports_wno_unknown_pragmas_flag? return try_compile_with_warning_flag( "Checking for C compiler '-Wno-unknown-pragmas' support", :c, '', '-Wno-unknown-pragmas') end memoize :cc_supports_wno_unknown_pragmas_flag?, true def self.cxx_supports_wno_unknown_pragmas_flag? return try_compile_with_warning_flag( "Checking for C++ compiler '-Wno-unknown-pragmas' support", :cxx, '', '-Wno-unknown-pragmas') end memoize :cxx_supports_wno_unknown_pragmas_flag?, true def self.cxx_supports_wno_unused_local_typedefs_flag? return try_compile_with_warning_flag( "Checking for C++ compiler '-Wno-unused-local-typedefs' support", :cxx, '', '-Wno-unused-local-typedefs') end memoize :cxx_supports_wno_unused_local_typedefs_flag?, true def self.cxx_supports_wno_format_nonliteral_flag? return try_compile_with_warning_flag( "Checking for C++ compiler '-Wno-format-nonliteral' support", :cxx, '', '-Wno-format-nonliteral') end memoize :cxx_supports_wno_format_nonliteral_flag?, true def self.cxx_supports_fno_limit_debug_info_flag? try_compile_with_warning_flag( "Checking for C++ compiler '-fno-limit-debug-info' support", :cxx, '', '-fno-limit-debug-info') end memoize :cxx_supports_fno_limit_debug_info_flag? def self.cxx_supports_fno_optimize_sibling_calls_flag? try_compile_with_warning_flag( "Checking for C++ compiler '-fno-optimize-sibling-calls' support", :cxx, '', '-fno-optimize-sibling-calls') end memoize :cxx_supports_fno_optimize_sibling_calls_flag? def self.cc_supports_no_tls_direct_seg_refs_option? return try_compile("Checking for C compiler '-mno-tls-direct-seg-refs' support", :c, '', '-mno-tls-direct-seg-refs') end memoize :cc_supports_no_tls_direct_seg_refs_option?, true def self.cxx_supports_no_tls_direct_seg_refs_option? return try_compile("Checking for C++ compiler '-mno-tls-direct-seg-refs' support", :cxx, '', '-mno-tls-direct-seg-refs') end memoize :cxx_supports_no_tls_direct_seg_refs_option?, true def self.compiler_supports_wno_ambiguous_member_template? try_compile_with_warning_flag( "Checking for C++ compiler '-Wno-ambiguous-member-template' support", :cxx, '', '-Wno-ambiguous-member-template') end memoize :compiler_supports_wno_ambiguous_member_template?, true def self.cc_supports_feliminate_unused_debug? return cc_or_cxx_supports_feliminate_unused_debug?(:c) end memoize :cc_supports_feliminate_unused_debug?, true def self.cxx_supports_feliminate_unused_debug? return cc_or_cxx_supports_feliminate_unused_debug?(:cxx) end memoize :cxx_supports_feliminate_unused_debug?, true def self.cc_block_support_ok? return (os_name_simple != 'macosx' \|\| cc_or_cxx_supports_blocks?(:c) \|\| os_version >= "10.13" ) end memoize :cc_block_support_ok?, true def self.cxx_block_support_ok? return (os_name_simple != 'macosx' \|\| cc_or_cxx_supports_blocks?(:cxx) \|\| os_version >= "10.13" ) end memoize :cxx_block_support_ok?, true # Returns whether compiling C++ with -fvisibility=hidden might result # in tons of useless warnings, like this: # http://code.google.com/p/phusion-passenger/issues/detail?id=526 # This appears to be a bug in older g++ versions: # http://gcc.gnu.org/ml/gcc-patches/2006-07/msg00861.html # Warnings should be suppressed with -Wno-attributes. def self.cc_visibility_flag_generates_warnings? if os_name_simple == "linux" && `#{cc} -v 2>&1` =~ /gcc version (.?)/ return $1 <= "4.1.2" else return false end end memoize :cc_visibility_flag_generates_warnings?, true def self.cxx_visibility_flag_generates_warnings? if os_name_simple == "linux" && `#{cxx} -v 2>&1` =~ /gcc version (.?)/ return $1 <= "4.1.2" else return false end end memoize :cxx_visibility_flag_generates_warnings?, true def self.address_sanitizer_flags if cc_is_clang? if `#{cc} --help` =~ /-fsanitize=/ "-fsanitize=address -fsanitize-address-use-after-return=always -fsanitize-address-use-after-scope" else "-faddress-sanitizer" end else nil end end def self.undefined_behavior_sanitizer_flags if cc_is_clang? "-fsanitize=undefined" else nil end end def self.cxx_11_flag # C++11 support on FreeBSD 10.0 + Clang seems to be bugged. # http://llvm.org/bugs/show_bug.cgi?id=18310 return nil if os_name_simple == "freebsd" source = %{ struct Foo { Foo(Foo &&f) { } }; } if try_compile("Checking for C++ -std=gnu++11 compiler flag", :cxx, source, '-std=gnu++11') return "-std=gnu++11" elsif try_compile("Checking for C++ -std=c++11 compiler flag", :cxx, source, '-std=c++11') return "-std=c++11" else return nil end end memoize :cxx_11_flag, true def self.has_rt_library? return try_link("Checking for -lrt support", :c, "int main() { return 0; }\n", '-lrt') end memoize :has_rt_library?, true def self.has_math_library? return try_link("Checking for -lmath support", :c, "int main() { return 0; }\n", '-lmath') end memoize :has_math_library?, true def self.has_dl_library? return try_link("Checking for -ldl support", :c, "int main() { return 0; }\n", '-ldl') end memoize :has_dl_library?, true def self.has_alloca_h? return try_compile("Checking for alloca.h", :c, '#include <alloca.h>') end memoize :has_alloca_h?, true def self.has_accept4? return try_compile("Checking for accept4()", :c, %Q{ #define _GNU_SOURCE #include <sys/socket.h> static void *foo = accept4; }) end memoize :has_accept4?, true # C compiler flags that should be passed in order to enable debugging information. def self.debugging_cflags # According to OpenBSD's pthreads man page, pthreads do not work # correctly when an app is compiled with -g. It recommends using # -ggdb instead. # # In any case we'll always want to use -ggdb for better GDB debugging. if cc_is_gcc? result = '-ggdb' else result = '-g' end if cc_supports_fno_limit_debug_info_flag? result << ' -fno-limit-debug-info' end result end # C++ compiler flags that should be passed in order to enable debugging information. def self.debugging_cxxflags # According to OpenBSD's pthreads man page, pthreads do not work # correctly when an app is compiled with -g. It recommends using # -ggdb instead. # # In any case we'll always want to use -ggdb for better GDB debugging. if cc_is_gcc? result = '-ggdb' else result = '-g' end if cxx_supports_fno_limit_debug_info_flag? result << ' -fno-limit-debug-info' end result end def self.export_dynamic_flags if os_name_simple == "linux" return '-rdynamic' else return nil end end def self.precompiled_header_extension if cxx_is_gcc? 'gch' else 'pch' end end def self.make return string_env('MAKE', find_command('make')) end memoize :make, true def self.gnu_make if result = string_env('GMAKE') return result else result = find_command('gmake') if !result result = find_command('make') if result if `#{result} --version 2>&1` =~ /GNU/ return result else return nil end else return nil end else return result end end end memoize :gnu_make, true def self.xcode_select_version if find_command('xcode-select') `xcode-select --version` =~ /version (.+)\./ return $1 else return nil end end end end # module PhusionPassenger	22.21 KB	2025-11-20 11:36
📄 crypto.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 'platform_info' PhusionPassenger.require_passenger_lib 'platform_info/operating_system' PhusionPassenger.require_passenger_lib 'platform_info/openssl' module PhusionPassenger module PlatformInfo def self.crypto_libs prefix = ' -framework CoreFoundation -framework Security' suffix = ' -lcrypto' if os_name_simple == "macosx" if os_version < '10.13' return prefix else return "#{prefix} #{openssl_extra_ldflags} #{suffix}" end else return suffix end end memoize :crypto_libs def self.crypto_extra_cflags if os_name_simple == "macosx" if os_version < '10.13' return ' -Wno-deprecated-declarations' else return " -Wno-deprecated-declarations #{openssl_extra_cflags}" end else return '' end end memoize :crypto_extra_cflags end end # module PhusionPassenger	2.21 KB	2025-11-20 11:36
📄 curl.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 'platform_info' module PhusionPassenger module PlatformInfo def self.curl_flags result = `(curl-config --cflags) 2>/dev/null`.strip if result.empty? return nil else version = `curl-config --vernum`.strip if version >= '070c01' # Curl >= 7.12.1 supports curl_easy_reset() result << " -DHAS_CURL_EASY_RESET" end return result end end memoize :curl_flags def self.curl_libs result = `(curl-config --libs) 2>/dev/null`.strip if os_name_simple == "macosx" result << ' -framework Foundation -framework SystemConfiguration' end if result.empty? return nil else return result end end memoize :curl_libs def self.curl_supports_ssl? features = `(curl-config --feature) 2>/dev/null` return features =~ /SSL/ end memoize :curl_supports_ssl? end end # module PhusionPassenger	2.23 KB	2025-11-20 11:36
📄 cxx_portability.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 'platform_info' PhusionPassenger.require_passenger_lib 'platform_info/compiler' PhusionPassenger.require_passenger_lib 'platform_info/operating_system' module PhusionPassenger module PlatformInfo # Extra flags that should always be passed to the C compiler # when linking, to be included last in the command string. def self.portability_c_ldflags return portability_c_or_cxx_ldflags(:c) end memoize :portability_c_ldflags # Extra flags that should always be passed to the C++ compiler # when linking, to be included last in the command string. def self.portability_cxx_ldflags return portability_c_or_cxx_ldflags(:cxx) end memoize :portability_cxx_ldflags # Extra compiler flags that should always be passed to the C compiler, # last in the command string. def self.default_extra_cflags return default_extra_c_or_cxxflags(:cc) end memoize :default_extra_cflags, true # Extra compiler flags that should always be passed to the C++ compiler, # last in the command string. def self.default_extra_cxxflags return default_extra_c_or_cxxflags(:cxx) end memoize :default_extra_cxxflags, true private def self.check_unordered_map(flags, class_name, header_name, macro_name) ok = try_compile("Checking for unordered_map", :cxx, %Q{ #include <#{header_name}> int main() { #{class_name}<int, int> m; return 0; } }) flags << "-D#{macro_name}" if ok return ok end private_class_method :check_unordered_map def self.check_hash_map(flags) hash_namespace = nil ok = false ['__gnu_cxx', '', 'std', 'stdext'].each do \|namespace\| ['hash_map', 'ext/hash_map'].each do \|hash_map_header\| ok = try_compile("Checking for #{hash_map_header}", :cxx, %Q{ #include <#{hash_map_header}> int main() { #{namespace}::hash_map<int, int> m; return 0; } }) if ok hash_namespace = namespace flags << "-DHASH_NAMESPACE=\"#{namespace}\"" flags << "-DHASH_MAP_HEADER=\"<#{hash_map_header}>\"" flags << "-DHASH_MAP_CLASS=\"hash_map\"" break end end break if ok end ['ext/hash_fun.h', 'functional', 'tr1/functional', 'ext/stl_hash_fun.h', 'hash_fun.h', 'stl_hash_fun.h', 'stl/_hash_fun.h'].each do \|hash_function_header\| ok = try_compile("Checking for #{hash_function_header}", :cxx, %Q{ #include <#{hash_function_header}> int main() { #{hash_namespace}::hash<int>()(5); return 0; } }) if ok flags << "-DHASH_FUN_H=\"<#{hash_function_header}>\"" break end end end private_class_method :check_hash_map def self.default_extra_c_or_cxxflags(cc_or_cxx) flags = ["-D_REENTRANT", "-I/usr/local/include"] if !send("#{cc_or_cxx}_is_sun_studio?") flags << "-Wall -Wextra -Wno-unused-parameter -Wno-parentheses -Wpointer-arith -Wwrite-strings -Wno-long-long" if send("#{cc_or_cxx}_supports_wno_missing_field_initializers_flag?") flags << "-Wno-missing-field-initializers" end if send("#{cc_or_cxx}_supports_wno_unknown_pragmas_flag?") flags << "-Wno-unknown-pragmas" end if requires_no_tls_direct_seg_refs? && send("#{cc_or_cxx}_supports_no_tls_direct_seg_refs_option?") flags << "-mno-tls-direct-seg-refs" end # Work around Clang warnings in ev++.h. if send("#{cc_or_cxx}_is_clang?") && compiler_supports_wno_ambiguous_member_template? flags << "-Wno-ambiguous-member-template" end end if !send("#{cc_or_cxx}_is_sun_studio?") if send("#{cc_or_cxx}_supports_feliminate_unused_debug?") flags << "-feliminate-unused-debug-symbols -feliminate-unused-debug-types" end if send("#{cc_or_cxx}_supports_visibility_flag?") flags << "-fvisibility=hidden -DVISIBILITY_ATTRIBUTE_SUPPORTED" if send("#{cc_or_cxx}_visibility_flag_generates_warnings?") && send("#{cc_or_cxx}_supports_wno_attributes_flag?") flags << "-Wno-attributes" end end end flags << '-DHAS_ALLOCA_H' if has_alloca_h? flags << '-DHAVE_ACCEPT4' if has_accept4? flags << '-DHAS_SFENCE' if supports_sfence_instruction? flags << '-DHAS_LFENCE' if supports_lfence_instruction? flags << "-DPASSENGER_DEBUG -DBOOST_DISABLE_ASSERTS" if cc_or_cxx == :cxx flags << debugging_cxxflags flags << cxx_11_flag if cxx_11_flag if cxx_supports_wno_unused_local_typedefs_flag? # Avoids some compilaton warnings with Boost on Ubuntu 14.04. flags << "-Wno-unused-local-typedefs" end if cxx_supports_wno_format_nonliteral_flag? # SystemTools/UserDatabase.cpp uses snprintf() with a non-literal # format string. flags << '-Wno-format-nonliteral' end # There are too many implementations of of the hash map! # Figure out the right one. check_unordered_map(flags, "std::unordered_map", "unordered_map", "HAS_UNORDERED_MAP") \|\| check_unordered_map(flags, "std::tr1::unordered_map", "unordered_map", "HAS_TR1_UNORDERED_MAP") \|\| check_hash_map(flags) else flags << debugging_cflags end if os_name_simple == "solaris" if send("#{cc_or_cxx}_is_sun_studio?") flags << '-mt' else flags << '-pthreads' end if os_name_full =~ /solaris2\.11/ # skip the _XOPEN_SOURCE and _XPG4_2 definitions in later versions of Solaris / OpenIndiana flags << '-D__EXTENSIONS__ -D__SOLARIS__ -D_FILE_OFFSET_BITS=64' else flags << '-D_XOPEN_SOURCE=500 -D_XPG4_2 -D__EXTENSIONS__ -D__SOLARIS__ -D_FILE_OFFSET_BITS=64' flags << '-D__SOLARIS9__ -DBOOST__STDC_CONSTANT_MACROS_DEFINED' if os_name_full =~ /solaris2\.9/ end flags << '-DBOOST_HAS_STDINT_H' unless os_name_full =~ /solaris2\.(9\|10\|11)/ if send("#{cc_or_cxx}_is_sun_studio?") flags << '-xtarget=ultra' if RUBY_PLATFORM =~ /sparc/ else flags << '-mcpu=ultrasparc' if RUBY_PLATFORM =~ /sparc/ end elsif os_name_simple == "openbsd" flags << '-DBOOST_HAS_STDINT_H -D_GLIBCPP__PTHREADS' elsif os_name_simple == "aix" flags << '-pthread' flags << '-DOXT_DISABLE_BACKTRACES' elsif RUBY_PLATFORM =~ /(sparc-linux\|arm-linux\|^arm.*-linux\|sh4-linux)/ # http://code.google.com/p/phusion-passenger/issues/detail?id=200 # http://groups.google.com/group/phusion-passenger/t/6b904a962ee28e5c # http://groups.google.com/group/phusion-passenger/browse_thread/thread/aad4bd9d8d200561 flags << '-DBOOST_SP_USE_PTHREADS' elsif linux_distro == :centos && os_version >= "8" # _FORTIFY_SOURCE requires compiling with optimization (-O) flags << '-O' end return flags.compact.map{ \|str\| str.strip }.join(" ").strip end private_class_method :default_extra_c_or_cxxflags def self.portability_c_or_cxx_ldflags(cc_or_cxx) result = '' result << cxx_11_flag if cc_or_cxx == :cxx && cxx_11_flag if os_name_simple == "solaris" result << ' -lxnet -lsocket -lnsl -lpthread' else result << ' -lpthread' end result << ' -lrt' if has_rt_library? result << ' -lmath' if has_math_library? result << ' -ldl' if has_dl_library? result.strip! return result end private_class_method :portability_c_or_cxx_ldflags end end # module PhusionPassenger	9.03 KB	2025-11-20 11:36
📄 depcheck.rb # encoding: utf-8 PhusionPassenger.require_passenger_lib 'platform_info/ruby' PhusionPassenger.require_passenger_lib 'platform_info/linux' PhusionPassenger.require_passenger_lib 'platform_info/compiler' PhusionPassenger.require_passenger_lib 'platform_info/openssl' PhusionPassenger.require_passenger_lib 'platform_info/curl' PhusionPassenger.require_passenger_lib 'platform_info/operating_system' PhusionPassenger.require_passenger_lib 'utils/ansi_colors' module PhusionPassenger module PlatformInfo # Almost all software require other software in order to run. We call those # other software 'dependencies'. Reliably checking for dependencies can be # difficult. Helping the user in case a dependency is not installed (or # doesn't seem to be installed) is more difficult still. # # The Depcheck framework seeks to make all this easier. It allows the programmer # to write "specs" which contain dependency checking code in a structured way. # The programmer defines a dependency's basic information (name, website, etc), # defines installation instructions (which may be customized per platform) and # defines code for checking whether the dependency actually exists. The Depcheck # framework: # # * Provides helpers for checking for the existance of commands, libraries, # headers, etc. # * Registers all dependency specs in a way that can be easily accessed # structurally. # * Allows user-friendly display of dependency checking progress and user help # instructions. # # Most dependency checking code (e.g. autoconf) is very straightforward: they # just check for the existance of a command, library, header, etc and either # report "found" or "not found". In our experience the world is unfortunately # not that simple. Users can have multiple versions of a dependency installed, # where some dependencies are suitable while others are not. Therefore specs # should print as many details about the dependency as possible (location, version, # etc) so that the user can override any decisions if necessary. module Depcheck THIS_DIR = File.expand_path(File.dirname(__FILE__)) @@loaded = {} @@database = {} def self.load(partial_filename) if !@@loaded[partial_filename] filename = "#{THIS_DIR}/#{partial_filename}.rb" content = File.read(filename) instance_eval(content, filename) @@loaded[partial_filename] = true end end def self.define(identifier, &block) @@database[identifier.to_s] = block end def self.find(identifier) # We lazy-initialize everything in order to save resources. This also # allows blocks to perform relatively expensive checks without hindering # startup time. identifier = identifier.to_s result = @@database[identifier] if result.is_a?(Proc) result = Dependency.new(&result) @@database[identifier] = result end result end class Dependency def initialize(&block) instance_eval(&block) check_syntax_aspect("Name must be given") { !!@name } check_syntax_aspect("A checker must be given") { !!@checker } end def check @install_comments = nil @check_result \|\|= @checker.call end ### DSL for specs ### def name(value = nil) value ? @name = value : @name end def website(value = nil) value ? @website = value : @website end def website_comments(value = nil) value ? @website_comments = value : @website_comments end def install_instructions(value = nil) if value @install_instructions = value else if @install_instructions @install_instructions elsif @website result = "Please download it from <b>#{@website}</b>" result << "\n(#{@website_comments})" if @website_comments result else "Search Google for '#{@name}'." end end end def append_install_instructions(value) @install_instructions << "\n#{value}" if value end def install_comments(value = nil) value ? @install_comments = value : @install_comments end private def check_syntax_aspect(description) if !yield raise description end end ### DSL for specs ### def define_checker(&block) @checker = block end def check_for_command(name, args) result = find_command(name, args) if result { :found => true, "Location" => result } else false end end def check_for_ruby_tool(name) result = locate_ruby_tool(name) if result { :found => true, "Location" => result } else false end end def check_for_header(header_name, language = :c, flags = nil) if result = PlatformInfo.find_header(header_name, language, flags) { :found => true, "Location" => result } else false end end # def check_for_library(name) # check_by_compiling("int main() { return 0; }", :cxx, nil, "-l#{name}") # end # def check_by_compiling(source, language = :c, cflags = nil, linkflags = nil) # case language # when :c # source_file = "#{PlatformInfo.tmpexedir}/depcheck-#{Process.pid}-#{Thread.current.object_id}.c" # compiler = "gcc" # compiler_flags = ENV['CFLAGS'] # when :cxx # source_file = "#{PlatformInfo.tmpexedir}/depcheck-#{Process.pid}-#{Thread.current.object_id}.cpp" # compiler = "g++" # compiler_flags = "#{ENV['CFLAGS']} #{ENV['CXXFLAGS']}".strip # else # raise ArgumentError, "Unknown language '#{language}" # end # output_file = "#{PlatformInfo.tmpexedir}/depcheck-#{Process.pid}-#{Thread.current.object_id}" # begin # File.open(source_file, 'w') do \|f\| # f.puts(source) # end # if find_command(compiler) # command = "#{compiler} #{compiler_flags} #{cflags} " + # "#{source_file} -o #{output_file} #{linkflags}" # [!!system(command)] # else # [:unknown, "Cannot check: compiler '#{compiler}' not found."] # end # ensure # File.unlink(source_file) rescue nil # File.unlink(output_file) rescue nil # end # end def check_for_ruby_library(name) begin require(name) { :found => true } rescue LoadError if defined?(Gem) false else begin require 'rubygems' require(name) { :found => true } rescue LoadError false end end end end def on(platform) return if @on_invoked invoke = false if (linux_distro_tags \|\| []).include?(platform) invoke = true else case platform when :linux invoke = true if PlatformInfo.os_name_simple == "linux" when :freebsd invoke = true if PlatformInfo.os_name_simple == "freebsd" when :macosx invoke = true if PlatformInfo.os_name_simple == "macosx" when :solaris invoke = true if PlatformInfo.os_name_simple == "solaris" when :other_platforms invoke = true end end if invoke yield @on_invoked = true end end def apt_get_install(package_name) install_instructions("Please install it with <b>apt-get install #{package_name}</b>") end def urpmi(package_name) install_instructions("Please install it with <b>urpmi #{package_name}</b>") end def yum_install(package_name, options = {}) if options[:epel] install_instructions("Please enable <b>EPEL</b>, then install with <b>yum install #{package_name}</b>") else install_instructions("Please install it with <b>yum install #{package_name}</b>") end end def emerge(package_name) install_instructions("Please install it with <b>emerge -av #{package_name}</b>") end def gem_install(package_name) install_instructions("Please make sure RubyGems is installed, then run " + "<b>#{gem_command} install #{package_name}</b>") end def brew_install(package_name) install_instructions("Please install it with <b>brew install #{package_name}</b>") end def brew_link(package_name) append_install_instructions("Please link it with <b>brew link --force #{package_name}</b>") end def install_osx_command_line_tools PhusionPassenger.require_passenger_lib 'platform_info/compiler' if PlatformInfo.xcode_select_version.to_s >= "2333" install_instructions "Please install the Xcode command line tools: " + "<b>sudo xcode-select --install</b>" else install_instructions "Please install Xcode, then install the command line tools " + "though the menu <b>Xcode -> Preferences -> Downloads -> Components</b>" end end def ruby_command PlatformInfo.ruby_command end def gem_command PlatformInfo.gem_command(:sudo => true) \|\| 'gem' end def find_command(command, args) PlatformInfo.find_command(command, args) end def linux_distro_tags PlatformInfo.linux_distro_tags end def locate_ruby_tool(name) PlatformInfo.locate_ruby_tool(name) end end # class Dependency class ConsoleRunner attr_reader :missing_dependencies def initialize(colors) @colors = colors \|\| Utils::AnsiColors.new(:auto) @stdout = STDOUT @dep_identifiers = [] end def add(identifier) @dep_identifiers << identifier end def check_all old_log_impl = PlatformInfo.log_implementation begin PlatformInfo.log_implementation = lambda do \|message\| message = PlatformInfo.send(:reindent, message, 10) message.sub!(/^ /, '') STDOUT.puts " -> #{message}" end @missing_dependencies = [] @dep_identifiers.each do \|identifier\| dep = Depcheck.find(identifier) raise "Cannot find depcheck spec #{identifier.inspect}" if !dep puts_header "Checking for #{dep.name}..." result = dep.check result = { :found => false } if !result if result[:found] && !result[:error] puts_detail "Found: <green>yes</green>" else if result[:error] puts_detail "Found: #{result[:found] ? "<yellow>yes, but there was an error</yellow>" : "<red>no</red>"}" puts_detail "Error: <red>#{result[:error]}</red>" else puts_detail "Found: #{result[:found] ? "<green>yes</green>" : "<red>no</red>"}" end @missing_dependencies << dep end result.each_pair do \|key, value\| if key.is_a?(String) puts_detail "#{key}: #{value}" end end end return @missing_dependencies.empty? ensure PlatformInfo.log_implementation = old_log_impl end end def print_installation_instructions_for_missing_dependencies @missing_dependencies.each do \|dep\| puts " * To install <yellow>#{dep.name}</yellow>:" puts " #{dep.install_instructions}" if dep.install_comments puts " #{dep.install_comments}" end puts end end private def puts(text = nil) if text @stdout.puts(@colors.ansi_colorize(text)) else @stdout.puts end @stdout.flush end def puts_header(text) puts " <b>* #{text}</b>" end def puts_detail(text) puts " #{text}" end end # class ConsoleRunner end # module Depcheck end # module PlatformInfo end # module PhusionPassenger	12.9 KB	2025-11-20 11:36
📁 depcheck_specs	-	2026-03-21 15:53
📄 linux.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' PhusionPassenger.require_passenger_lib 'platform_info/operating_system' module PhusionPassenger module PlatformInfo # An identifier for the current Linux distribution. nil if the operating system is not Linux. def self.linux_distro tags = linux_distro_tags if tags return tags.first else return nil end end # Autodetects the current Linux distribution and return a number of identifier tags. # The first tag identifies the distribution while the other tags indicate which # distributions it is likely compatible with. # Returns nil if the operating system is not Linux. def self.linux_distro_tags if os_name_simple != "linux" return nil end lsb_release = read_file("/etc/lsb-release") if lsb_release =~ /Ubuntu/ return [:ubuntu, :debian] elsif File.exist?("/etc/debian_version") return [:debian] elsif File.exist?("/etc/redhat-release") redhat_release = read_file("/etc/redhat-release") if redhat_release =~ /CentOS\|AlmaLinux\|Rocky Linux/ # For now treat all non-RHEL enterprise linux distros the same return [:centos, :redhat] elsif redhat_release =~ /Fedora/ return [:fedora, :redhat] elsif redhat_release =~ /Mandriva/ return [:mandriva, :redhat] else # On official RHEL distros, the content is in the form of # "Red Hat Enterprise Linux Server release 5.1 (Tikanga)" return [:rhel, :redhat] end elsif File.exist?("/etc/system-release") system_release = read_file("/etc/system-release") if system_release =~ /Amazon Linux/ return [:amazon, :redhat] else return [:unknown] end elsif File.exist?("/etc/suse-release") return [:suse] elsif File.exist?("/etc/gentoo-release") return [:gentoo] else return [:unknown] end # TODO: Slackware end memoize :linux_distro_tags end end # PhusionPassenger	3.35 KB	2025-11-20 11:36
📄 networking.rb # frozen_string_literal: true # Phusion Passenger - https://www.phusionpassenger.com/ # Copyright (c) 2017-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 'platform_info/operating_system' PhusionPassenger.require_passenger_lib 'utils/shellwords' module PhusionPassenger module PlatformInfo # Returns a list of network interfaces active on the current system, or # nil if unable to autodetect. # # [ # { # :device => 'en0', # :type => :ethernet, # :flags => [:promisc, :broadcast, :multicast], # :ipv4 => ['127.0.0.1'], # :ipv6 => ['::1'] # }, # ... # ] def self.network_interfaces case os_name_simple when 'linux' network_interfaces_linux when 'macosx', 'freebsd' network_interfaces_bsd else nil end end # Returns the names of the network interfaces used for public # Internet IPv4 and IPv6 traffic. This is autodetected # by checking which interfaces can route to Google. # # The format is: # # { # :ipv4 => "device name" \| nil \| :unknown, # :ipv6 => "device name" \| nil \| :unknown # } # # A value of nil means that there is no interface that supports # the corresponding IP traffic. # A value of :unknown means that the information cannot be # autodetected. def self.default_network_interfaces case os_name_simple when 'linux' { :ipv4 => default_network_interface_linux_for_ip_type(:ipv4), :ipv6 => default_network_interface_linux_for_ip_type(:ipv6) } when 'macosx', 'freebsd' { :ipv4 => default_network_interface_bsd_for_ip_type(:ipv4), :ipv6 => default_network_interface_bsd_for_ip_type(:ipv6) } else { :ipv4 => :unknown, :ipv6 => :unknown } end end private def self.network_interfaces_linux result = {} ip_command = find_system_command('ip') if ip_command current_iface = nil output = `#{Shellwords.escape ip_command} addr show` output.split("\n").each do \|line\| elems = line.split if line =~ /^[0-9]+: / # Format: # <NUMBER>: <DEVICE>: <<FLAGS>> ... device = elems[1].sub(/:$/, '') flags = parse_bsd_or_linux_ifconfig_flags(elems[2]) current_iface = { :device => device, :type => flags.include?(:loopback) ? :loopback : :unknown, :flags => flags, :ipv4 => [], :ipv6 => [] } result[device] = current_iface elsif elems[0] == 'link/ether' current_iface[:type] = :ethernet elsif elems[0] == 'inet' # Format: inet <IP[/CIDR PREFIX]> ... <ACTUAL DEVICE> device = elems.last ip = elems[1].sub(%r{/.}, '') if current_iface[:device] == device actual_iface = current_iface else actual_iface = (result[device] \|\|= { :device => device, :type => :unknown, :flags => [], :ipv4 => [], :ipv6 => [] }) end actual_iface[:ipv4] << ip elsif elems[0] == 'inet6' # Format: inet6 <IP[/CIDR PREFIX]> ... ip = elems[1].sub(%r{/.}, '') current_iface[:ipv6] << ip end end end Dir['/sys/class/net/*'].each do \|path\| next if !File.directory?(path) device = File.basename(path) iface = (result[device] \|\|= { :device => device, :type => :unknown, :flags => [], :ipv4 => [], :ipv6 => [] }) if iface[:type] == :unknown && File.exist?("#{path}/type") case File.read("#{path}/type").strip when '1' iface[:type] = :ethernet when '772' iface[:type] = :loopback end end if File.exist?("#{path}/flags") flags = File.read("#{path}/flags").to_i(16) if flags & 0x0100 && !iface[:flags].include?(:promisc) iface[:flags] << :promisc end end end result.values end def self.default_network_interface_linux_for_ip_type(type) ip_command = PlatformInfo.find_system_command('ip') return :unknown if ip_command.nil? # See the comments for default_network_interface_bsd_for_ip_type if type == :ipv4 address = '8.8.8.8' output = `#{Shellwords.escape ip_command} -4 route get #{address} 2>/dev/null` else address = '2404:6800:400a:800::1012' output = `#{Shellwords.escape ip_command} -6 route get #{address} 2>/dev/null` end first_line = output.split("\n").first elems = (first_line \|\| '').split if elems[0] == address first_line =~ / dev (.+?) / $1 else nil end end def self.network_interfaces_bsd ifconfig = find_system_command('ifconfig') return nil if ifconfig.nil? result = [] current_interface = nil lines = `#{Shellwords.escape ifconfig} -a`.split("\n") lines.each do \|line\| elems = line.split if line =~ /^[a-z0-9\-_]+:/ device = elems[0].chomp(':') flags = parse_bsd_or_linux_ifconfig_flags(elems[1]) current_interface = { :device => device, :type => flags.include?(:loopback) ? :loopback : :unknown, :flags => flags, :ipv4 => [], :ipv6 => [] } result << current_interface elsif elems[0] == 'ether' current_interface[:type] = :ethernet elsif elems[0] == 'inet' \|\| elems[0] == 'inet6' # Format: # inet [alias] <IP ADDRESS[/CIDR PREFIX]> ... if elems[1] == 'alias' ip = elems[2] else ip = elems[1] end if ip.include?('/') ip = ip.split('/', 2)[0] end if elems[0] == 'inet' current_interface[:ipv4] << ip else current_interface[:ipv6] << ip end end end result end def self.default_network_interface_bsd_for_ip_type(type) route = PlatformInfo.find_system_command('route') return :unknown if route.nil? # We ping a public server to test which of our interfaces # is used for outgoing Internet traffic. # 8.8.8.8 = Google's public DNS # 2404:6800:400a:800::1012 = ipv6.google.com # This should work for everybody outside Google's cluster infrastructure, # and who didn't block Google on the network routing level. # # Note that this even works for mainland Chinese users, as the GFW # blocks on the TCP level. # # We redirect stderr to /dev/null because we don't want routing # errors to be printed. if type == :ipv4 output = `#{Shellwords.escape route} -n get 8.8.8.8 2>/dev/null` else output = `#{Shellwords.escape route} -n get -inet6 2404:6800:400a:800::1012 2>/dev/null` end lines = output.split("\n") lines.each do \|line\| elems = line.split if elems[0] == 'interface:' && elems[1] return elems[1] end end nil end def self.parse_bsd_or_linux_ifconfig_flags(flags) if flags =~ /<(.+)>/ $1.split(',').map { \|x\| x.downcase.to_sym } else [] end end end end # module PhusionPassenger	8.83 KB	2025-11-20 11:36
📄 openssl.rb # Phusion Passenger - https://www.phusionpassenger.com/ # Copyright (c) 2015-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 'platform_info/operating_system' module PhusionPassenger module PlatformInfo def self.openssl_extra_cflags if PlatformInfo.os_name_simple == "macosx" if File.exist?("/usr/include/openssl") "" # OS X >= 10.11 El Capitan no longer include # OpenSSL development headers. elsif File.exist?("/usr/local/opt/openssl/include") # Use the one from Homebrew. "-I/usr/local/opt/openssl/include" elsif File.exist?("/opt/homebrew/opt/openssl/include") # Use the one from Homebrew on Apple Silicon "-I/opt/homebrew/opt/openssl/include" else # Use the one from Macports. "-I/opt/local/include" end else "" end end memoize :openssl_extra_cflags def self.openssl_extra_ldflags if PlatformInfo.os_name_simple == "macosx" if File.exist?("/usr/include/openssl") "" elsif File.exist?("/usr/local/opt/openssl/include") "-L/usr/local/opt/openssl/lib" elsif File.exist?("/opt/homebrew/opt/openssl/include") "-L/opt/homebrew/opt/openssl/lib" else "-L/opt/local/lib" end else "" end end memoize :openssl_extra_ldflags end end # module PhusionPassenger	2.63 KB	2025-11-20 11:36
📄 operating_system.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. require 'rbconfig' require 'rubygems' PhusionPassenger.require_passenger_lib 'platform_info' module PhusionPassenger module PlatformInfo class VersionComparer < String def <=>(other) Gem::Version.new(self) <=> Gem::Version.new(other.to_s) end end # Returns the operating system's name in as simple a form as possible. For example, # Linux is always identified as "linux". OS X is always identified as "macosx" (despite # the actual os name being something like "darwin"). This is useful as a stable indicator # of the os without having to worry about version numbers, etc. # N.B. unrecognized os names will just be returned as-is. def self.os_name_simple if rb_config['target_os'] =~ /darwin/ && (sw_vers = find_command('sw_vers')) 'macosx' elsif rb_config['target_os'] =~ /^linux-/ 'linux' elsif rb_config['target_os'] =~ /solaris/ 'solaris' elsif rb_config['target_os'] =~ /freebsd/ 'freebsd' elsif rb_config['target_os'] =~ /aix/ 'aix' else rb_config['target_os'] end end memoize :os_name_simple # Returns the operating system's name exactly as advertised by the system. While it is # in lowercase and contains no spaces, it can contain things like version number or # may be less intuitive (e.g. "darwin" for OS X). def self.os_name_full rb_config['target_os'] end memoize :os_name_full # Returns the operating system's version number, or nil if unknown. # This includes the patch version, so for example on macOS Sierra # it could return "10.12.5". # # On Debian/Ubuntu, this returns the version number (e.g. "16.04") # as opposed to the codename ("Trusty"). def self.os_version case os_name_simple when 'macosx' VersionComparer.new(`/usr/bin/sw_vers -productVersion`.strip.split.last) when 'linux' # Parse LSB (applicable to e.g. Ubuntu) if read_file('/etc/lsb-release') =~ /DISTRIB_RELEASE=(.+)/ version = $1.delete(%q['"]) return VersionComparer.new(version) if !version.empty? end # Parse CentOS/RedHat data = read_file('/etc/centos-release') data = read_file('/etc/redhat-release') if data.empty? if !data.empty? data =~ /^(.+?) (Linux \|Stream )?(release \|version )?(.+?)( \|$)/i return VersionComparer.new($4) if $4 end # Parse Debian if File.exist?('/etc/debian_version') return VersionComparer.new(read_file('/etc/debian_version').strip) end nil else nil end end # The current platform's shared library extension ('so' on most Unices). def self.library_extension if os_name_simple == "macosx" return "bundle" else return "so" end end # Returns the `uname` command, or nil if `uname` cannot be found. # In addition to looking for `uname` in `PATH`, this method also looks # for `uname` in /bin and /usr/bin, just in case the user didn't # configure its PATH properly. def self.uname_command if result = find_command("uname") result elsif File.exist?("/bin/uname") return "/bin/uname" elsif File.exist?("/usr/bin/uname") return "/usr/bin/uname" else return nil end end # Returns a list of all CPU architecture names that the current machine CPU # supports. If there are multiple such architectures then the first item in # the result denotes that OS runtime's main/preferred architecture. # # This function normalizes some names. For example x86 is always reported # as "x86" regardless of whether the OS reports it as "i386" or "i686". # x86_64 is always reported as "x86_64" even if the OS reports it as "amd64". # # Please note that even if the CPU supports multiple architectures, the # operating system might not. For example most x86 CPUs nowadays also # support x86_64, but x86_64 Linux systems require various x86 compatibility # libraries to be installed before x86 executables can be run. This function # does not detect whether these compatibility libraries are installed. # The only guarantee that you have is that the OS can run executables in # the architecture denoted by the first item in the result. # # For example, on x86_64 Linux this function can return ["x86_64", "x86"]. # This indicates that the CPU supports both of these architectures, and that # the OS's main/preferred architecture is x86_64. Most executables on the # system are thus be x86_64. It is guaranteed that the OS can run x86_64 # executables, but not x86 executables per se. # # Another example: on MacOS X this function will return some subset of # "x86_64", "x86", and "arm". def self.cpu_architectures if os_name_simple == "macosx" # Macs were intel from around 2006 until 2022. # All but the first 3 Intel Macs' CPUs supported both x86_64 and x86, # and every OS X version from 10.4 to 10.14 had both x86 and x86_64 runtimes installed, # from 10.15 on x86 was dropped, and from (11/10.16) on arm (aarch64) was added. major, minor, *rest = os_version.split(".").map(&:to_i) if major >= 11 \|\| (major == 10 && minor >= 16) # Since Big Sur aarch64 is supported, and default on m1 macs. if `#{uname_command} -m` =~ /arm64/ ["arm64", "x86_64"] elsif `sysctl -in sysctl.proc_translated` == "1" ["arm64", "x86_64"] else ["x86_64", "arm64"] end elsif minor == 15 # Since Catalina x86 is gone. ["x86_64"] elsif minor >= 6 # Since Snow Leopard x86_64 is the default on intel macs. ["x86_64", "x86"] else # Before Snow Leopard x86 was the default. ["x86", "x86_64"] end else uname = uname_command raise "The 'uname' command cannot be found" if !uname arch = `#{uname} -p`.strip # On some systems 'uname -p' returns something like # 'Intel(R) Pentium(R) M processor 1400MHz' or # 'Intel(R)_Xeon(R)_CPU___________X7460__@_2.66GHz'. if arch == "unknown" \|\| arch =~ / / \|\| arch =~ /Hz$/ arch = `#{uname} -m`.strip end if arch =~ /^i.86$/ arch = "x86" elsif arch == "amd64" arch = "x86_64" end if arch == "x86" # Most x86 operating systems nowadays are probably running on # a CPU that supports both x86 and x86_64, but we're not gonna # go through the trouble of checking that. The main architecture # is what we usually care about. ["x86"] elsif arch == "x86_64" # I don't think there's a single x86_64 CPU out there # that doesn't support x86 as well. ["x86_64", "x86"] else [arch] end end end memoize :cpu_architectures, true # Returns whether the flock() function is supported on this OS. def self.supports_flock? defined?(File::LOCK_EX) && os_name_simple != 'solaris' end # Returns whether the OS's main CPU architecture supports the # x86/x86_64 sfence instruction. def self.supports_sfence_instruction? arch = cpu_architectures[0] return arch == "x86_64" \|\| (arch == "x86" && try_compile_and_run("Checking for sfence instruction support", :c, %Q{ int main() { __asm__ __volatile__ ("sfence" ::: "memory"); return 0; } })) end memoize :supports_sfence_instruction?, true # Returns whether the OS's main CPU architecture supports the # x86/x86_64 lfence instruction. def self.supports_lfence_instruction? arch = cpu_architectures[0] return arch == "x86_64" \|\| (arch == "x86" && try_compile_and_run("Checking for lfence instruction support", :c, %Q{ int main() { __asm__ __volatile__ ("lfence" ::: "memory"); return 0; } })) end memoize :supports_lfence_instruction?, true def self.requires_no_tls_direct_seg_refs? return File.exist?("/proc/xen/capabilities") && cpu_architectures[0] == "x86" end memoize :requires_no_tls_direct_seg_refs?, true # Returns true if the current os is running in Windows Subsystem for Linux def self.windows_subsystem? uname = uname_command raise "The 'uname' command cannot be found" if !uname `#{uname} -r`.include?("Microsoft") end memoize :windows_subsystem?, true end end # module PhusionPassenger	9.9 KB	2025-11-20 11:36
📄 pcre.rb # Phusion Passenger - https://www.phusionpassenger.com/ # Copyright (c) 2021-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 'platform_info/operating_system' module PhusionPassenger module PlatformInfo def self.pcre_extra_cflags cflags = "" if PlatformInfo.os_name_simple == "macosx" brew_path = "#{`/usr/bin/env -P /usr/local/bin:/opt/homebrew/bin brew --prefix pcre2`.strip}/include" if File.exist?(brew_path) # Use the one from Homebrew. cflags = "-I#{brew_path}" else # Use the one from Macports. cflags = "-I/opt/local/include" end end return "#{cflags} -DPCRE2_CODE_UNIT_WIDTH=8" end memoize :pcre_extra_cflags def self.pcre_extra_ldflags if PlatformInfo.os_name_simple == "macosx" brew_path = "#{`/usr/bin/env -P /usr/local/bin:/opt/homebrew/bin brew --prefix pcre2`.strip}/lib" if File.exist?(brew_path) # Use the one from Homebrew. "-L#{brew_path}" else # Use the one from Macports. "-L/opt/local/lib" end else "" end end memoize :pcre_extra_ldflags end end # module PhusionPassenger	2.41 KB	2025-11-20 11:36
📄 ruby.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. require 'rbconfig' require 'etc' PhusionPassenger.require_passenger_lib 'platform_info' PhusionPassenger.require_passenger_lib 'platform_info/operating_system' module PhusionPassenger module PlatformInfo # Store original $GEM_HOME value so that even if the app customizes # $GEM_HOME we can still work with the original value. gem_home = ENV['GEM_HOME'] if gem_home gem_home = gem_home.strip.freeze gem_home = nil if gem_home.empty? end GEM_HOME = gem_home # Ditto for $GEM_PATH gem_path = ENV['GEM_PATH'] if gem_path gem_path = gem_path.strip.freeze gem_path = nil if gem_path.empty? end GEM_PATH = gem_path # 'bundle exec' modifies $GEM_HOME and $GEM_PATH so let's # store the values that we had before Bundler's modifications. gem_home = ENV['BUNDLER_ORIG_GEM_HOME'] if gem_home gem_home = gem_home.strip.freeze gem_home = nil if gem_home.empty? end BUNDLER_ORIG_GEM_HOME = gem_home gem_path = ENV['BUNDLER_ORIG_GEM_PATH'] if gem_path gem_path = gem_path.strip.freeze gem_path = nil if gem_path.empty? end BUNDLER_ORIG_GEM_PATH = gem_path if defined?(::RUBY_ENGINE) RUBY_ENGINE = ::RUBY_ENGINE else RUBY_ENGINE = "ruby" end # Returns correct command for invoking the current Ruby interpreter. # In case of RVM this function will return the path to the RVM wrapper script # that executes the current Ruby interpreter in the currently active gem set. def self.ruby_command # Detect usage of gem-wrappers: https://github.com/rvm/gem-wrappers # This is currently used by RVM >= 1.25, although it's not exclusive to RVM. if GEM_HOME && File.exist?("#{GEM_HOME}/wrappers/ruby") return "#{GEM_HOME}/wrappers/ruby" end if in_rvm? # Detect old-school RVM wrapper script location. name = rvm_ruby_string dirs = rvm_paths if name && dirs dirs.each do \|dir\| filename = "#{dir}/wrappers/#{name}/ruby" if File.exist?(filename) contents = File.open(filename, 'rb') do \|f\| f.read end # Old wrapper scripts reference $HOME which causes # things to blow up when run by a different user. if contents.include?("$HOME") filename = nil end else filename = nil end if filename return filename end end # Correctness of these commands are confirmed by mpapis. # If we ever encounter a case for which this logic is not sufficient, # try mpapis' pseudo code: # # rvm_update_prefix = write_to rvm_path ? "" : "rvmsudo" # rvm_gemhome_prefix = write_to GEM_HOME ? "" : "rvmsudo" # repair_command = "#{rvm_update_prefix} rvm get stable && rvm reload && #{rvm_gemhome_prefix} rvm repair all" # wrapper_command = "#{rvm_gemhome_prefix} rvm wrapper #{rvm_ruby_string} --no-prefix --all" case rvm_installation_mode when :single repair_command = "rvm get stable && rvm reload && rvm repair all" wrapper_command = "rvm wrapper #{rvm_ruby_string} --no-prefix --all" when :multi repair_command = "rvmsudo rvm get stable && rvm reload && rvmsudo rvm repair all" wrapper_command = "rvmsudo rvm wrapper #{rvm_ruby_string} --no-prefix --all" when :mixed repair_command = "rvmsudo rvm get stable && rvm reload && rvm repair all" wrapper_command = "rvm wrapper #{rvm_ruby_string} --no-prefix --all" end STDERR.puts "Your RVM wrapper scripts are too old, or some " + "wrapper scripts are missing. Please update/regenerate " + "them first by running:\n\n" + " #{repair_command}\n\n" + "If that doesn't seem to work, please run:\n\n" + " #{wrapper_command}" exit 1 else # Something's wrong with the user's RVM installation. # Raise an error so that the user knows this instead of # having things fail randomly later on. # 'name' is guaranteed to be non-nil because rvm_ruby_string # already raises an exception on error. STDERR.puts "Your RVM installation appears to be broken: the RVM " + "path cannot be found. Please fix your RVM installation " + "or contact the RVM developers for support." exit 1 end else return ruby_executable end end memoize :ruby_command # Returns the full path to the current Ruby interpreter's executable file. # This might not be the actual correct command to use for invoking the Ruby # interpreter; use ruby_command instead. def self.ruby_executable @@ruby_executable \|\|= rb_config['bindir'] + '/' + rb_config['RUBY_INSTALL_NAME'] + rb_config['EXEEXT'] end # Returns whether the Ruby interpreter supports process forking. def self.ruby_supports_fork? # MRI >= 1.9.2's respond_to? returns false for methods # that are not implemented. return Process.respond_to?(:fork) && RUBY_ENGINE != "jruby" && RUBY_ENGINE != "macruby" && rb_config['target_os'] !~ /mswin\|windows\|mingw/ end # Returns whether Phusion Passenger needs Ruby development headers to # be available for the current Ruby implementation. def self.passenger_needs_ruby_dev_header? # Too much of a trouble for JRuby. We can do without it. return RUBY_ENGINE != "jruby" end # Returns the correct 'gem' command for this Ruby interpreter. # If `:sudo => true` is given, then the gem command is prefixed by a # sudo command if filesystem permissions require this. def self.gem_command(options = {}) command = ruby_tool_command('gem') if options[:sudo] && gem_install_requires_sudo? command = "#{ruby_sudo_command} #{command}" end return command end memoize :gem_command # Returns whether running 'gem install' as the current user requires sudo. def self.gem_install_requires_sudo? `#{gem_command} env` =~ /INSTALLATION DIRECTORY: (.+)/ if install_dir = $1 return !File.writable?(install_dir) else return nil end end memoize :gem_install_requires_sudo? # Returns the absolute path to the Rake executable that # belongs to the current Ruby interpreter. Returns nil if it # doesn't exist. # # The return value may not be the actual correct invocation # for Rake. Use `rake_command` for that. def self.rake return locate_ruby_tool('rake') end memoize :rake # Returns the correct command string for invoking the Rake executable # that belongs to the current Ruby interpreter. Returns nil if Rake is # not found. def self.rake_command ruby_tool_command('rake') end memoize :rake_command # Returns the absolute path to the RSpec runner program that # belongs to the current Ruby interpreter. Returns nil if it # doesn't exist. def self.rspec return locate_ruby_tool('rspec') end memoize :rspec # Returns whether the current Ruby interpreter is managed by RVM. def self.in_rvm? bindir = rb_config['bindir'] return bindir.include?('/.rvm/') \|\| bindir.include?('/rvm/') end # If the current Ruby interpreter is managed by RVM, returns all # directories in which RVM places its working files. This is usually # ~/.rvm or /usr/local/rvm, but in mixed-mode installations there # can be multiple such paths. # # Otherwise returns nil. def self.rvm_paths if in_rvm? result = [] [ENV['rvm_path'], "#{PhusionPassenger.home_dir}/.rvm", "/usr/local/rvm"].each do \|path\| next if path.nil? rubies_path = File.join(path, 'rubies') wrappers_path = File.join(path, 'wrappers') gems_path = File.join(path, 'gems') if File.directory?(path) && (File.directory?(rubies_path) \|\| File.directory?(wrappers_path) \|\| File.directory?(gems_path)) result << path end end if result.empty? # Failure to locate the RVM path is probably caused by the # user customizing $rvm_path. Older RVM versions don't # export $rvm_path, making us unable to detect its value. STDERR.puts "Unable to locate the RVM path. Your RVM installation " + "is probably too old. Please update it with " + "'rvm get head && rvm reload && rvm repair all'." exit 1 else return result end else return nil end end memoize :rvm_paths # If the current Ruby interpreter is managed by RVM, returns the # RVM name which identifies the current Ruby interpreter plus the # currently active gemset, e.g. something like this: # "ruby-1.9.2-p0@mygemset" # # Returns nil otherwise. def self.rvm_ruby_string if in_rvm? # Getting the RVM name of the Ruby interpreter ("ruby-1.9.2") # isn't so hard, we can extract it from the #ruby_executable # string. Getting the gemset name is a bit harder, so let's # try various strategies... # $GEM_HOME usually contains the gem set name. # It may be something like: # /Users/hongli/.rvm/gems/ruby-1.9.3-p392 # But also: # /home/bitnami/.rvm/gems/ruby-1.9.3-p385-perf@njist325/ruby/1.9.1 # # Caveat when we're executed through 'bundle exec': # if `bundle install` was run with `--path=`, then `bundle exec` # will modify $GEM_HOME to the --path directory. That's # why we need to parse the version of $GEM_HOME before # `bundle exec` had modified it. [GEM_HOME, BUNDLER_ORIG_GEM_HOME].each do \|gem_home\| if gem_home && gem_home =~ %r{rvm/gems/(.+)} return $1.sub(/\/./, '') end end # User might have explicitly set GEM_HOME to a custom directory, # or might have nuked $GEM_HOME. Extract info from $GEM_PATH. [GEM_PATH, BUNDLER_ORIG_GEM_PATH].each do \|gem_path\| if gem_path gem_path.split(':').each do \|gem_path_part\| if gem_path_part =~ %r{rvm/gems/(.+)} return $1.sub(/\/./, '') end end end end # That failed too. Try extracting info from from $LOAD_PATH. matching_path = $LOAD_PATH.find_all do \|item\| item.include?("rvm/gems/") \|\| item.include?("rvm/rubies/") end if matching_path && !matching_path.empty? subpath = matching_path.to_s.gsub(/^.rvm\/(gems\|rubies)\//, '') result = subpath.split('/').first return result if result end # On Ruby 1.9, $LOAD_PATH does not contain any gem paths until # at least one gem has been required so the above can fail. # We're out of options now, we can't detect the gem set. # Raise an exception so that the user knows what's going on # instead of having things fail in obscure ways later. STDERR.puts "Unable to autodetect the currently active RVM gem " + "set name. This could happen if you ran this program using 'sudo' " + "instead of 'rvmsudo'. When using RVM, you're always supposed to " + "use 'rvmsudo' instead of 'sudo!'.\n\n" + "Please try rerunning this program using 'rvmsudo'. If that " + "doesn't help, please contact this program's author for support." exit 1 end return nil end memoize :rvm_ruby_string # Returns the RVM installation mode: # :single - RVM is installed in single-user mode. # :multi - RVM is installed in multi-user mode. # :mixed - RVM is in a mixed-mode installation. # nil - The current Ruby interpreter is not using RVM. def self.rvm_installation_mode if in_rvm? if ENV['rvm_path'] =~ /\.rvm/ return :single else if GEM_HOME =~ /\.rvm/ return :mixed else return :multi end end else return nil end end # Returns either 'sudo' or 'rvmsudo' depending on whether the current # Ruby interpreter is managed by RVM. def self.ruby_sudo_command if in_rvm? return "rvmsudo" else return "sudo" end end # Returns a `sudo` or `rvmsudo` command that spawns a shell, depending # on whether the current Ruby interpreter is managed by RVM. def self.ruby_sudo_shell_command(args = nil) if in_rvm? shell = ENV['SHELL'].to_s if shell.empty? begin user = Etc.getpwuid(0) rescue ArgumentError user = nil end shell = user.shell if user shell = "bash" if !shell \|\| shell.empty? end result = "rvmsudo " result << "#{args} " if args result << shell return result else return "sudo -s #{args}".strip end end # Locates a Ruby tool, e.g. 'gem', 'rake', 'bundle', etc. Instead of # naively looking in $PATH, this function uses a variety of search heuristics # to find the tool that's really associated with the current Ruby interpreter. # It should never locate a tool that's actually associated with a different # Ruby interpreter. # Returns nil when nothing's found. # # This method only returns the path to the tool script. Running this script # directly does not necessarily mean that it's run under the correct Ruby # interpreter. You may have to prepend it with the Ruby command. Use # `ruby_tool_command` if you want to get a command that you can execute. def self.locate_ruby_tool(name) result = locate_ruby_tool_by_basename(name) if !result exeext = rb_config['EXEEXT'] exeext = nil if exeext.empty? if exeext result = locate_ruby_tool_by_basename("#{name}#{exeext}") end if !result result = locate_ruby_tool_by_basename(transform_according_to_ruby_exec_format(name)) end if !result && exeext result = locate_ruby_tool_by_basename(transform_according_to_ruby_exec_format(name) + exeext) end end return result end # Locates a Ruby tool command, e.g. 'gem', 'rake', 'bundle', etc. Instead of # naively looking in $PATH, this function uses a variety of search heuristics # to find the command that's really associated with the current Ruby interpreter. # It should never locate a command that's actually associated with a different # Ruby interpreter. # Returns nil when nothing's found. # # Unlike `locate_ruby_tool`, which only returns the path to the tool script, # this method returns a full command that you can execute. The returned command # guarantees that the tool is run under the correct Ruby interpreter. def self.ruby_tool_command(name) path = locate_ruby_tool(name) if path if is_ruby_program?(path) "#{ruby_command} #{path}" else # The found tool is a wrapper script, e.g. in RVM's ~/.rvm/wrappers. # In this case, don't include the Ruby command in the result. path end else nil end end private def self.locate_ruby_tool_by_basename(name) if os_name_simple == "macosx" && ruby_command =~ %r(\A/System/Library/Frameworks/Ruby.framework/Versions/.?/usr/bin/ruby\Z) # On OS X we must look for Ruby binaries in /usr/bin. # RubyGems puts executables (e.g. 'rake') in there, not in # /System/Libraries/(...)/bin. filename = "/usr/bin/#{name}" else filename = File.dirname(ruby_command) + "/#{name}" end if !File.file?(filename) \|\| !File.executable?(filename) # RubyGems might put binaries in a directory other # than Ruby's bindir. Debian packaged RubyGems and # DebGem packaged RubyGems are the prime examples. begin require 'rubygems' unless defined?(Gem) filename = Gem.bindir + "/#{name}" rescue LoadError filename = nil end end if !filename \|\| !File.file?(filename) \|\| !File.executable?(filename) # Looks like it's not in the RubyGems bindir. Search in $PATH, but # be very careful about this because whatever we find might belong # to a different Ruby interpreter than the current one. ENV['PATH'].split(':').each do \|dir\| filename = "#{dir}/#{name}" if File.file?(filename) && File.executable?(filename) shebang = File.open(filename, 'rb') do \|f\| f.readline.strip end if shebang == "#!#{ruby_command}" # Looks good. break end end # Not found. Try next path. filename = nil end end filename end private_class_method :locate_ruby_tool_by_basename def self.is_ruby_program?(filename) File.open(filename, 'rb') do \|f\| return f.readline =~ /ruby/ end rescue EOFError return false end private_class_method :is_ruby_program? # Deduce Ruby's --program-prefix and --program-suffix from its install name # and transforms the given input name accordingly. # # transform_according_to_ruby_exec_format("rake") => "jrake", "rake1.8", etc def self.transform_according_to_ruby_exec_format(name) install_name = rb_config['RUBY_INSTALL_NAME'] if install_name.include?('ruby') format = install_name.sub('ruby', '%s') return sprintf(format, name) else return name end end private_class_method :transform_according_to_ruby_exec_format end end # module PhusionPassenger	19.16 KB	2025-11-20 11:36
📄 zlib.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 'platform_info' module PhusionPassenger module PlatformInfo def self.zlib_flags return nil end def self.zlib_libs return '-lz' end end end # module PhusionPassenger	1.49 KB	2025-11-20 11:36

Terminal