CascadiaDigitalCollective/gxg-framework
CascadiaDigitalCollective/gxg-framework
2
0
Fork 0
mirror of https://github.com/mistergibson/gxg-framework.git synced 2026-08-15 03:46:00 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions
gxg-framework/lib/gxg/gxg_entities.rb
G. Gibson 4bb9f2f2ea Initial Commit
2021-11-16 08:41:53 -08:00

2169 lines
No EOL
118 KiB
Ruby
Raw Blame History

#
# ---------------------------------------------------------------------------------------------------------------------
# Preliminary Entity supports
module GxG
#
def find_local(the_key)
nil
end
#
module Entity
# SysInfo
# provide default filesystem object
class LocalSystem
#
def initialize(bootstrap_data={})
# Rather than only using RUBY_PLATFORM, I want to define the *specific* environment on that platform to help further characterize what is at hand.
super()
# @thread_safety = ::Mutex.new
@thread_safety = ::Mutex.new
@details = {}
#
@details[:architecture] = bootstrap_data.delete(:architecture)
#
# ### Process bootstrap_data regarding platform and environment
@details[:platform] = bootstrap_data.delete(:platform)
@details[:platform_version] = GxG::Version.new(bootstrap_data.delete(:platform_version))
@details[:platform_configuration] = {:process => {}, :flags => {}}
@details[:environment] = bootstrap_data.delete(:environment)
@details[:environment_variant] = bootstrap_data.delete(:environment_variant)
if bootstrap_data[:environment_version]
@details[:environment_version] = GxG::Version.new(bootstrap_data.delete(:environment_version))
else
@details[:environment_version] = nil
end
@details[:environment_configuration] = {}
#
# ### Process CPU info
@details[:processors] = bootstrap_data.delete(:processors)
@details[:processors].process! do |item, selector, container|
if selector.is_any?(::String, ::Symbol)
# hash/struct processing
if selector.is_a?(Symbol)
key = selector
else
key = selector.to_s.to_sym
end
# massage data by key
# [:processor, :vendor_id, :cpu_family, :model, :model_name, :stepping, :cpu_mhz, :cache_size, :physical_id, :siblings, :core_id, :cpu_cores, :apicid, :initial_apicid, ::fpu, :fpu_exception, :cpuid_level, :wp, :flags, :bogomips, :clflush_size, :cache_alignment, :address_sizes, :power_management]
entry = nil
case key
when :processor, :cpu_family, :model, :stepping, :physical_id, :siblings, :core_id, :cpu_cores, :apicid, :initial_apicid, :cpuid_level, :clflush_size, :cache_alignment
entry = item.to_s.numeric_values()
if entry.is_a?(Hash)
item = entry[:integer]
end
when :cpu_mhz, :bogomips
entry = item.to_s.numeric_values()
if entry.is_a?(Hash)
item = entry[:float]
end
when :cache_size
entry = item.to_s.numeric_values([:byte])
if entry.is_a?(Hash)
item = entry[:byte]
end
when :address_sizes
entry = item.to_s.numeric_values([:bit],",")
if entry.is_a?(Array)
item = {:physical_bits => (entry[0][:bit] || entry[0][:integer]), :virtual_bits => (entry[1][:bit] || entry[1][:integer])}
end
when :flags
item = item.to_s.split(" ").to_enum.map do |flag|
flag.to_sym
end
end
if item
if container.is_a?(::Hash)
container.delete(selector)
container[(key)] = item
end
end
end
nil
end
# TODO: Build up a list of flags that the cpu supports and are *actually* in use (i.e. PAE, ...)
@details[:platform_flags] = {}
# Gather platform kernel configuration data for processing.
case @details[:platform]
when :linux
release = (`uname -r`.split("\n")[0])
likely_paths = ["/proc/config.gz",("/lib/modules/#{release}/build/.config"),("/usr/src/linux-#{release}/.config"),("/usr/src/linux-#{release}/configs/#{release}-#{@details[:architecture]}.config"),("/boot/config-#{release}")]
raw_data = ""
likely_paths.to_enum.each do |the_path|
if ::File.exist?(the_path)
# Note: at this point in everything it is ok for file io that blocks.
if the_path == "/proc/config.gz"
::Zlib::GzipReader.open(the_path) { |gz| raw_data = gz.read }
else
::File.open(the_path, "r") { |i| raw_data = i.read }
end
break
end
end
# process raw_data (each line)
raw_flags = {}
raw_data.to_enum(:each_line).each do |line_text|
flag = nil
setting = nil
if line_text.size > 0
if line_text[0] == "#"
if line_text.include?("is not set")
# cull unset thing and make its value nil.
flag = line_text[1..-1].scan(/[A-Z_]*/)[0]
if flag.size > 0
# exclude redundant 'CONFIG' portion
flag = flag.split("_")[1..-1].join("_")
else
flag = nil
end
end
else
flag, setting = line_text.split("=")
# exclude redundant 'CONFIG' portion
flag = flag.split("_")[1..-1].join("_")
if (setting == "y" || setting == "y\n")
setting = true
end
if (setting == "n" || setting == "n\n")
setting = false
end
end
end
if (flag)
raw_flags[(flag)] = setting
end
end
raw_data = nil
# Note: I am *loathe* to use strings instead of symbols in hashes generally, but I don't like what ruby does
# with symbols and memory for temporary data sets (looking at you matz and my slapping hand twitches).
universal_synonyms = {"X86_PAE" => "physical_address_extension"}
universal_synonyms["X86_32_SMP"] = "symetric_multiprocessing"
universal_synonyms["X86_64_SMP"] = "symetric_multiprocessing"
universal_synonyms["X86_HT"] = "hyperthreading"
universal_synonyms["SWAP"] = "virtual_memory"
#
raw_flags.each_pair do |selector,value|
#
if universal_synonyms[(selector)]
# include the flag ONLY if it is actually enabled (in use) on this build of the kernel
if value
@details[:platform_configuration][:flags][(universal_synonyms[(selector)].to_sym)] = value
end
end
end
# end linux area
end
#
# ### Memory crap:
#
# Set computational and storage/memory limits by platform and environment:
# See (with respect to Ruby) : http://www.rubynotes.net/uk/operating-systems/windows/item/82-physical-memory-limits.html
# Note: RVALUE size (consumption size) is determined in a completely separate manner than the limit size (according to cpu virtual addressing bits used).
# default for 32 bit OS used:
system_memory = self.memory()
per_process_max = 2147483648
case @details[:platform]
when :linux
# for :linux : See http://linuxfollies.blogspot.com/2010/10/linux-memory-limits-rlimits.html
# Note: Process::getrlimit("AS") does not reflect the reality of total ram + total swap space as a limit.
if @details[:processors][0][:address_sizes].is_a?(::Hash)
if @details[:processors][0][:address_sizes][:virtual_bits] == 32
if @details[:platform_configuration][:flags][:physical_address_extension]
# ??? what does that do to the memory limit under 32 bits
# 3.12GB rumored: 3350074490.88 (rounded-down)
per_process_max = 3350074490
else
per_process_max = 3221225472
end
end
end
if @details[:processors][0][:address_sizes].is_a?(::Hash)
if @details[:processors][0][:address_sizes][:virtual_bits] == 64
# odd thing: they built 64bit computers that only have slots enough for 2GB max ram (imagine!)
# So... to deal with this dilemma, I'm going to set the per_process_max to system_memory[:actual][:total] (:actual=RAM) unless it is really a full 8TB+.
if system_memory[:actual][:total] >= 8796093022208
per_process_max = 8796093022208
else
per_process_max = system_memory[:actual][:total]
end
end
else
# virtual bits reading NOT supported:
if ([ -1 ].pack('l!').length * 8) == 32
if @details[:platform_configuration][:flags][:physical_address_extension]
# ??? what does that do to the memory limit under 32 bits
# 3.12GB rumored: 3350074490.88 (rounded-down)
per_process_max = 3350074490
else
per_process_max = 3221225472
end
end
if ([ -1 ].pack('l!').length * 8) == 64
if system_memory[:actual][:total] >= 8796093022208
per_process_max = 8796093022208
else
per_process_max = system_memory[:actual][:total]
end
end
end
when :windows
# for :windows : See http://msdn.microsoft.com/en-us/library/windows/desktop/aa366778%28v=vs.85%29.aspx
# And "4GB-tuning' at http://msdn.microsoft.com/en-us/library/windows/desktop/bb613473%28v=vs.85%29.aspx
# And "BCDEdit /set' at http://msdn.microsoft.com/en-us/library/ff542202.aspx
# TODO: :windows : find a way to test if IMAGE_FILE_LARGE_ADDRESS_AWARE is set, whether os runs in PAE mode, and
# what BCDEdit /set Increaseuserva (gigabytes-as-megabytes) was set to. (kernel_mode address space = 4GB-(2048MB-to-3072MB value of it))
# on infamous /3GB switch in boot.ini : http://www.ditii.com/2007/04/14/memory-management-demystifying-3gb/
# if @details[:processors][0][:address_sizes][:virtual_bits] == 32
# # :windows 32-bit : 2GB per process memory limit (non-contiguous-only)
# per_process_max = 2147483648
# end
# if @details[:processors][0][:address_sizes][:virtual_bits] == 64
# # :if IMAGE_FILE_LARGE_ADDRESS_AWARE is set on process image, then 8TB max per 64-bit process, except on Intel Itanium-based systems (7TB)
# # otherwise (if unset, and since we have no F'n way to tell within ruby):
# per_process_max = 2147483648
# end
# Review : Since I am only supporting 64-bit Windows (and don't know how to survey cpu info) -- skip prior tests
per_process_max = 2147483648
end
#
if system_memory[:total][:total] >= per_process_max
@details[:memory_limits]={:process => ((per_process_max)..(system_memory[:total][:total]))}
else
@details[:memory_limits]={:process => ((system_memory[:total][:total])..(system_memory[:total][:total]))}
end
# stock setrlimit will ignore the 'hard-wired' limit reset to actual available memory (both kinds), but the overridden GxG::Engine::getrlimit(:AS) will respect it.
# GxG::Engine::memory_available() is built around these limits to ensure you do not encounter an issue without some warning (no Exabyte delusions).
# ::Process::setrlimit(:AS,@details[:memory_limits][:process].min,@details[:memory_limits][:process].max)
#
# ### Initial Buffer Sizes
# TODO: find a clever way to determine the platform's maximum buffer size (after linux 2.6.14 (I think) buffers are now 16x4KiB).
@details[:memory_limits][:buffers] = {:default => 4096, :terminal => 1024,:socket => {:ipc => {}}, :ipv4 => {:tcp => {}, :udp => {}}}
# Attribution: http://www.psc.edu/networking/projects/tcptune/#detailed and
# http://www.psc.edu/networking/projects/tcptune/#tutorial
#
case @details[:platform]
when :linux
# TODO: provide for better version comparisons: create >, <. etc methods that accept a string to interperet or a value instance.
# See: http://www.pixelbeat.org/programming/stdio_buffering/
platform_version = @details[:platform_version].value
if platform_version[:major] > 2
@details[:memory_limits][:buffers][:default] = 65536
end
if platform_version[:major] == 2
if platform_version[:minor] >= 6
if platform_version[:teeny] >= 14
@details[:memory_limits][:buffers][:default] = 65536
end
end
end
end
#
# ### The Ruby runtime itself
# Now defined in GxG::Engine as a chance to correct some 'free-form-jazz-ensemble-a-la-SpinalTap' stuff from the guys at Ruby Core! :)
#
# ### Network stuff
# node (or host) name:
@details[:nodename] = ::Socket.gethostname
@details[:network] = {}
begin
address = ::TCPSocket.getaddress(@details[:nodename])
rescue Exception
# raise Exception, "You need to edit your host file, and add an alias for this host."
# exit 1
address = nil
end
# netstat --interfaces --all --verbose --extend
#
@details[:network][:hostname] = @details[:nodename]
# TODO: @gather localhost info: convert ip address info to std. ip_addr objects
@details[:network][:address] = address
@details[:network][:hosts] = []
# raw_list = Sys::Host.info
# raw_list.to_enum.each do |entry|
# new_entry = {}
# entry.each_pair do |key,item|
# # TODO: @gather hosts info: convert ip address info to std. ip_addr objects
# new_entry[(key.to_sym)] = item
# end
# @details[:network][:hosts] << new_entry
# #
# end
#
# TODO: inventory each network interface and host address of the system
# then, attach active, kernel supported, protocols
# then, use self["a/setting/path"] to set the data for each setting of each protocol of each nic that is supported and active.
protocols = {
:ipv4=>{:settings=>{:tcp => {}, :udp => {}}, :aliases=>["IP"], :proto=>0},
:icmp=>{:settings=>{}, :aliases=>["ICMP"], :proto=>1},
:igmp=>{:settings=>{}, :aliases=>["IGMP"], :proto=>2},
:ggp=>{:settings=>{}, :aliases=>["GGP"], :proto=>3},
:ipencap=>{:settings=>{}, :aliases=>["IP-ENCAP"], :proto=>4},
:st=>{:settings=>{}, :aliases=>["ST"], :proto=>5},
:tcp=>{:settings=>{}, :aliases=>["TCP"], :proto=>6},
:egp=>{:settings=>{}, :aliases=>["EGP"], :proto=>8},
:igp=>{:settings=>{}, :aliases=>["IGP"], :proto=>9},
:pup=>{:settings=>{}, :aliases=>["PUP"], :proto=>12},
:udp=>{:settings=>{}, :aliases=>["UDP"], :proto=>17},
:hmp=>{:settings=>{}, :aliases=>["HMP"], :proto=>20},
:"xns-idp"=>{:settings=>{}, :aliases=>["XNS-IDP"], :proto=>22},
:rdp=>{:settings=>{}, :aliases=>["RDP"], :proto=>27},
:"iso-tp4"=>{:settings=>{}, :aliases=>["ISO-TP4"], :proto=>29},
:dccp=>{:settings=>{}, :aliases=>["DCCP"], :proto=>33},
:xtp=>{:settings=>{}, :aliases=>["XTP"], :proto=>36},
:ddp=>{:settings=>{}, :aliases=>["DDP"], :proto=>37},
:"idpr-cmtp"=>{:settings=>{}, :aliases=>["IDPR-CMTP"], :proto=>38},
:ipv6=>{:settings=>{:tcp=>{}, :udp=>{}}, :aliases=>["IPv6"], :proto=>41},
:"ipv6-route"=>{:settings=>{}, :aliases=>["IPv6-Route"], :proto=>43},
:"ipv6-frag"=>{:settings=>{}, :aliases=>["IPv6-Frag"], :proto=>44},
:idrp=>{:settings=>{}, :aliases=>["IDRP"], :proto=>45},
:rsvp=>{:settings=>{}, :aliases=>["RSVP"], :proto=>46},
:gre=>{:settings=>{}, :aliases=>["GRE"], :proto=>47},
:esp=>{:settings=>{}, :aliases=>["IPSEC-ESP"], :proto=>50},
:ah=>{:settings=>{}, :aliases=>["IPSEC-AH"], :proto=>51},
:skip=>{:settings=>{}, :aliases=>["SKIP"], :proto=>57},
:"ipv6-icmp"=>{:settings=>{}, :aliases=>["IPv6-ICMP"], :proto=>58},
:"ipv6-nonxt"=>{:settings=>{}, :aliases=>["IPv6-NoNxt"], :proto=>59},
:"ipv6-opts"=>{:settings=>{}, :aliases=>["IPv6-Opts"], :proto=>60},
:rspf=>{:settings=>{}, :aliases=>["RSPF", "CPHB"], :proto=>73},
:vmtp=>{:settings=>{}, :aliases=>["VMTP"], :proto=>81},
:eigrp=>{:settings=>{}, :aliases=>["EIGRP"], :proto=>88},
:ospf=>{:settings=>{}, :aliases=>["OSPFIGP"], :proto=>89},
:"ax.25"=>{:settings=>{}, :aliases=>["AX.25"], :proto=>93},
:ipip=>{:settings=>{}, :aliases=>["IPIP"], :proto=>94},
:etherip=>{:settings=>{}, :aliases=>["ETHERIP"], :proto=>97},
:encap=>{:settings=>{}, :aliases=>["ENCAP"], :proto=>98},
:pim=>{:settings=>{}, :aliases=>["PIM"], :proto=>103},
:ipcomp=>{:settings=>{}, :aliases=>["IPCOMP"], :proto=>108},
:vrrp=>{:settings=>{}, :aliases=>["VRRP"], :proto=>112},
:l2tp=>{:settings=>{}, :aliases=>["L2TP"], :proto=>115},
:isis=>{:settings=>{}, :aliases=>["ISIS"], :proto=>124},
:sctp=>{:settings=>{}, :aliases=>["SCTP"], :proto=>132},
:fc=>{:settings=>{}, :aliases=>["FC"], :proto=>133},
:"mobility-header"=>{:settings=>{}, :aliases=>["Mobility-Header"], :proto=>135},
:udplite=>{:settings=>{}, :aliases=>["UDPLite"], :proto=>136},
:"mpls-in-ip"=>{:settings=>{}, :aliases=>["MPLS-in-IP"], :proto=>137},
:manet=>{:settings=>{}, :aliases=>[], :proto=>138},
:hip=>{:settings=>{}, :aliases=>["HIP"], :proto=>139},
:shim6=>{:settings=>{}, :aliases=>["Shim6"], :proto=>140},
:wesp=>{:settings=>{}, :aliases=>["WESP"], :proto=>141},
:rohc=>{:settings=>{}, :aliases=>["ROHC"], :proto=>142}
}
#
@details[:network][:protocols] = protocols
# if @details[:platform] == :windows
# # TODO: find suitable alternative to Net::Proto.getprotoent (breaks under rbx)
# else
# raw_list = Net::Proto.getprotoent
# raw_list.to_enum.each do |entry|
# new_entry = {:settings => {}}
# proto_name = :unknown
# entry.each_pair do |key,item|
# if key.to_s.to_sym == :name
# if item.to_s.to_sym == :ip
# proto_name = :ipv4
# else
# proto_name = item.to_s.to_sym
# end
# else
# new_entry[(key)] = item
# end
# end
# if [:ipv4,:ipv6].include?(proto_name)
# new_entry[:settings][:tcp] = {}
# new_entry[:settings][:udp] = {}
# end
# @details[:network][:protocols][(proto_name)] = new_entry
# #
# end
# end
# Read in Sysctl-style keys and set @details data.
get_system_data(detail_mapping())
#
#
# File descriptor reservation and release support, reserving $stdin, $stdout, and $stderr, etc.
# TODO: get a *complete* list of getconf variables *and their meanings* and incorporate them into sysctl-style path system.
# See: http://www.lainoox.com/system-wide-config-getconf/
# self["configuration.process.maximum_file_descriptors"]
# LATER: add lsof to requirements list within installer.
case @details[:platform]
when :linux, :aix, :solaris, :bsd, :darwin
# TODO: research -F option of lsof
# See: http://geek00l.blogspot.com/2006/03/openbsd-fstat-vs-lsof.html
end
#
case @details[:platform]
when :bsd
# See: fstat vs lsof : http://geek00l.blogspot.com/2006/03/openbsd-fstat-vs-lsof.html
#
# if EventMachine::kqueue?
# ?
# @details[:maximum_descriptors][:events] = 1000000
# end
when :linux
# if EventMachine::epoll?
# ?
# @details[:maximum_descriptors][:events] = 1000000
# end
end
# ###
@valid_modes = {}
# Internal Services to Port Usage mapping
@details[:service_ports] = {
:tcpmux=>{:aliases=>[], :clients=>[], :description=>"TCP port service multiplexer", :uses=>{:tcp=>[1]}},
:echo=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:tcp=>[7], :udp=>[7], :ddp=>[4]}},
:discard=>{:aliases=>["sink", "null"], :clients=>[], :description=>"", :uses=>{:tcp=>[9], :udp=>[9]}},
:systat=>{:aliases=>["users"], :clients=>[], :description=>"", :uses=>{:tcp=>[11]}},
:daytime=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:tcp=>[13], :udp=>[13]}},
:netstat=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:tcp=>[15]}},
:qotd=>{:aliases=>["quote"], :clients=>[], :description=>"", :uses=>{:tcp=>[17]}},
:msp=>{:aliases=>[], :clients=>[], :description=>"message send protocol", :uses=>{:tcp=>[18], :udp=>[18]}},
:chargen=>{:aliases=>["ttytst", "source"], :clients=>[], :description=>"", :uses=>{:tcp=>[19], :udp=>[19]}},
:"ftp-data"=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:tcp=>[20]}},
:ftp=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:tcp=>[21]}},
:fsp=>{:aliases=>["fspd"], :clients=>[], :description=>"", :uses=>{:udp=>[21]}},
:ssh=>{:aliases=>[], :clients=>[], :description=>"SSH Remote Login Protocol", :uses=>{:tcp=>[22], :udp=>[22]}},
:telnet=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:tcp=>[23]}},
:smtp=>{:aliases=>["mail"], :clients=>[], :description=>"", :uses=>{:tcp=>[25]}},
:time=>{:aliases=>["timserver"], :clients=>[], :description=>"", :uses=>{:tcp=>[37], :udp=>[37]}},
:rlp=>{:aliases=>["resource"], :clients=>[], :description=>"resource location", :uses=>{:udp=>[39]}},
:nameserver=>{:aliases=>["name"], :clients=>[], :description=>"IEN 116", :uses=>{:tcp=>[42]}},
:whois=>{:aliases=>["nicname"], :clients=>[], :description=>"", :uses=>{:tcp=>[43]}},
:tacacs=>{:aliases=>[], :clients=>[], :description=>"Login Host Protocol (TACACS)", :uses=>{:tcp=>[49], :udp=>[49]}},
:"re-mail-ck"=>{:aliases=>[], :clients=>[], :description=>"Remote Mail Checking Protocol", :uses=>{:tcp=>[50], :udp=>[50]}},
:domain=>{:aliases=>[], :clients=>[], :description=>"name-domain server", :uses=>{:tcp=>[53], :udp=>[53]}},
:mtp=>{:aliases=>[], :clients=>[], :description=>"deprecated", :uses=>{:tcp=>[57]}},
:"tacacs-ds"=>{:aliases=>[], :clients=>[], :description=>"TACACS-Database Service", :uses=>{:tcp=>[65], :udp=>[65]}},
:bootps=>{:aliases=>[], :clients=>[], :description=>"BOOTP server", :uses=>{:tcp=>[67], :udp=>[67]}},
:bootpc=>{:aliases=>[], :clients=>[], :description=>"BOOTP client", :uses=>{:tcp=>[68], :udp=>[68]}},
:tftp=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:udp=>[69]}},
:gopher=>{:aliases=>[], :clients=>[], :description=>"Internet Gopher", :uses=>{:tcp=>[70], :udp=>[70]}},
:rje=>{:aliases=>["netrjs"], :clients=>[], :description=>"", :uses=>{:tcp=>[77]}},
:finger=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:tcp=>[79]}},
:www=>{:aliases=>["http"], :clients=>[], :description=>"WorldWideWeb HTTP", :uses=>{:tcp=>[80], :udp=>[80]}},
:link=>{:aliases=>["ttylink"], :clients=>[], :description=>"", :uses=>{:tcp=>[87]}},
:kerberos=>{:aliases=>["kerberos5", "krb5", "kerberos-sec"], :clients=>[], :description=>"Kerberos v5", :uses=>{:tcp=>[88], :udp=>[88]}},
:supdup=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:tcp=>[95]}},
:hostnames=>{:aliases=>["hostname"], :clients=>[], :description=>"usually from sri-nic", :uses=>{:tcp=>[101]}},
:"iso-tsap"=>{:aliases=>["tsap"], :clients=>[], :description=>"part of ISODE", :uses=>{:tcp=>[102]}},
:"acr-nema"=>{:aliases=>["dicom"], :clients=>[], :description=>"Digital Imag. & Comm. 300", :uses=>{:tcp=>[104], :udp=>[104]}},
:"csnet-ns"=>{:aliases=>["cso-ns"], :clients=>[], :description=>"also used by CSO name server", :uses=>{:tcp=>[105], :udp=>[105]}},
:rtelnet=>{:aliases=>[], :clients=>[], :description=>"Remote Telnet", :uses=>{:tcp=>[107], :udp=>[107]}},
:pop2=>{:aliases=>["postoffice", "pop-2"], :clients=>[], :description=>"POP version 2", :uses=>{:tcp=>[109], :udp=>[109]}},
:pop3=>{:aliases=>["pop-3"], :clients=>[], :description=>"POP version 3", :uses=>{:tcp=>[110], :udp=>[110]}},
:sunrpc=>{:aliases=>["portmapper"], :clients=>[], :description=>"RPC 4.0 portmapper", :uses=>{:tcp=>[111], :udp=>[111]}},
:auth=>{:aliases=>["authentication", "tap", "ident"], :clients=>[], :description=>"", :uses=>{:tcp=>[113]}},
:sftp=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:tcp=>[115]}},
:"uucp-path"=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:tcp=>[117]}},
:nntp=>{:aliases=>["readnews", "untp"], :clients=>[], :description=>"USENET News Transfer Protocol", :uses=>{:tcp=>[119]}},
:ntp=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:tcp=>[123], :udp=>[123]}},
:pwdgen=>{:aliases=>[], :clients=>[], :description=>"PWDGEN service", :uses=>{:tcp=>[129], :udp=>[129]}},
:"loc-srv"=>{:aliases=>["epmap"], :clients=>[], :description=>"Location Service", :uses=>{:tcp=>[135], :udp=>[135]}},
:"netbios-ns"=>{:aliases=>[], :clients=>[], :description=>"NETBIOS Name Service", :uses=>{:tcp=>[137], :udp=>[137]}},
:"netbios-dgm"=>{:aliases=>[], :clients=>[], :description=>"NETBIOS Datagram Service", :uses=>{:tcp=>[138], :udp=>[138]}},
:"netbios-ssn"=>{:aliases=>[], :clients=>[], :description=>"NETBIOS session service", :uses=>{:tcp=>[139], :udp=>[139]}},
:imap2=>{:aliases=>["imap"], :clients=>[], :description=>"Interim Mail Access P 2 and 4", :uses=>{:tcp=>[143], :udp=>[143]}},
:snmp=>{:aliases=>[], :clients=>[], :description=>"Simple Net Mgmt Protocol", :uses=>{:tcp=>[161], :udp=>[161]}},
:"snmp-trap"=>{:aliases=>["snmptrap"], :clients=>[], :description=>"Traps for SNMP", :uses=>{:tcp=>[162], :udp=>[162]}},
:"cmip-man"=>{:aliases=>[], :clients=>[], :description=>"ISO mgmt over IP (CMOT)", :uses=>{:tcp=>[163], :udp=>[163]}},
:"cmip-agent"=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:tcp=>[164], :udp=>[164]}},
:mailq=>{:aliases=>[], :clients=>[], :description=>"Mailer transport queue for Zmailer", :uses=>{:tcp=>[174], :udp=>[174]}},
:xdmcp=>{:aliases=>[], :clients=>[], :description=>"X Display Mgr. Control Proto", :uses=>{:tcp=>[177], :udp=>[177]}},
:nextstep=>{:aliases=>["NeXTStep", "NextStep"], :clients=>[], :description=>"NeXTStep window", :uses=>{:tcp=>[178], :udp=>[178]}},
:bgp=>{:aliases=>[], :clients=>[], :description=>"Border Gateway Protocol", :uses=>{:tcp=>[179], :udp=>[179]}},
:prospero=>{:aliases=>[], :clients=>[], :description=>"Cliff Neuman's Prospero", :uses=>{:tcp=>[191], :udp=>[191]}},
:irc=>{:aliases=>[], :clients=>[], :description=>"Internet Relay Chat", :uses=>{:tcp=>[194], :udp=>[194]}},
:smux=>{:aliases=>[], :clients=>[], :description=>"SNMP Unix Multiplexer", :uses=>{:tcp=>[199], :udp=>[199]}},
:"at-rtmp"=>{:aliases=>[], :clients=>[], :description=>"AppleTalk routing", :uses=>{:tcp=>[201], :udp=>[201]}},
:"at-nbp"=>{:aliases=>[], :clients=>[], :description=>"AppleTalk name binding", :uses=>{:tcp=>[202], :udp=>[202]}},
:"at-echo"=>{:aliases=>[], :clients=>[], :description=>"AppleTalk echo", :uses=>{:tcp=>[204], :udp=>[204]}},
:"at-zis"=>{:aliases=>[], :clients=>[], :description=>"AppleTalk zone information", :uses=>{:tcp=>[206], :udp=>[206]}},
:qmtp=>{:aliases=>[], :clients=>[], :description=>"Quick Mail Transfer Protocol", :uses=>{:tcp=>[209], :udp=>[209]}},
:z3950=>{:aliases=>["wais"], :clients=>[], :description=>"NISO Z39.50 database", :uses=>{:tcp=>[210], :udp=>[210]}},
:ipx=>{:aliases=>[], :clients=>[], :description=>"IPX", :uses=>{:tcp=>[213], :udp=>[213]}},
:imap3=>{:aliases=>[], :clients=>[], :description=>"Interactive Mail Access", :uses=>{:tcp=>[220], :udp=>[220]}},
:pawserv=>{:aliases=>[], :clients=>[], :description=>"Perf Analysis Workbench", :uses=>{:tcp=>[345], :udp=>[345]}},
:zserv=>{:aliases=>[], :clients=>[], :description=>"Zebra server", :uses=>{:tcp=>[346], :udp=>[346]}},
:fatserv=>{:aliases=>[], :clients=>[], :description=>"Fatmen Server", :uses=>{:tcp=>[347], :udp=>[347]}},
:rpc2portmap=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:tcp=>[369], :udp=>[369]}},
:codaauth2=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:tcp=>[370], :udp=>[370]}},
:clearcase=>{:aliases=>["Clearcase"], :clients=>[], :description=>"", :uses=>{:tcp=>[371], :udp=>[371]}},
:ulistserv=>{:aliases=>[], :clients=>[], :description=>"UNIX Listserv", :uses=>{:tcp=>[372], :udp=>[372]}},
:ldap=>{:aliases=>[], :clients=>[], :description=>"Lightweight Directory Access Protocol", :uses=>{:tcp=>[389], :udp=>[389]}},
:imsp=>{:aliases=>[], :clients=>[], :description=>"Interactive Mail Support Protocol", :uses=>{:tcp=>[406], :udp=>[406]}},
:svrloc=>{:aliases=>[], :clients=>[], :description=>"Server Location", :uses=>{:tcp=>[427], :udp=>[427]}},
:https=>{:aliases=>[], :clients=>[], :description=>"http protocol over TLS/SSL", :uses=>{:tcp=>[443], :udp=>[443]}},
:snpp=>{:aliases=>[], :clients=>[], :description=>"Simple Network Paging Protocol", :uses=>{:tcp=>[444], :udp=>[444]}},
:"microsoft-ds"=>{:aliases=>[], :clients=>[], :description=>"Microsoft Naked CIFS", :uses=>{:tcp=>[445], :udp=>[445]}},
:kpasswd=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:tcp=>[464], :udp=>[464]}},
:saft=>{:aliases=>[], :clients=>[], :description=>"Simple Asynchronous File Transfer", :uses=>{:tcp=>[487], :udp=>[487]}},
:isakmp=>{:aliases=>[], :clients=>[], :description=>"IPsec - Internet Security Association", :uses=>{:tcp=>[500], :udp=>[500]}},
:rtsp=>{:aliases=>[], :clients=>[], :description=>"Real Time Stream Control Protocol", :uses=>{:tcp=>[554], :udp=>[554]}},
:nqs=>{:aliases=>[], :clients=>[], :description=>"Network Queuing system", :uses=>{:tcp=>[607], :udp=>[607]}},
:"npmp-local"=>{:aliases=>["dqs313_qmaster"], :clients=>[], :description=>"npmp-local / DQS", :uses=>{:tcp=>[610], :udp=>[610]}},
:"npmp-gui"=>{:aliases=>["dqs313_execd"], :clients=>[], :description=>"npmp-gui / DQS", :uses=>{:tcp=>[611], :udp=>[611]}},
:"hmmp-ind"=>{:aliases=>["dqs313_intercell"], :clients=>[], :description=>"HMMP Indication / DQS", :uses=>{:tcp=>[612], :udp=>[612]}},
:qmqp=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:tcp=>[628], :udp=>[628]}},
:ipp=>{:aliases=>[], :clients=>[], :description=>"Internet Printing Protocol", :uses=>{:tcp=>[631], :udp=>[631]}},
:exec=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:tcp=>[512]}},
:biff=>{:aliases=>["comsat"], :clients=>[], :description=>"", :uses=>{:udp=>[512]}},
:login=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:tcp=>[513]}},
:who=>{:aliases=>["whod"], :clients=>[], :description=>"", :uses=>{:udp=>[513]}},
:shell=>{:aliases=>["cmd"], :clients=>[], :description=>"no passwords used", :uses=>{:tcp=>[514]}},
:syslog=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:udp=>[514]}},
:printer=>{:aliases=>["spooler"], :clients=>[], :description=>"line printer spooler", :uses=>{:tcp=>[515]}},
:talk=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:udp=>[517]}},
:ntalk=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:udp=>[518]}},
:route=>{:aliases=>["router", "routed"], :clients=>[], :description=>"RIP", :uses=>{:udp=>[520]}},
:timed=>{:aliases=>["timeserver"], :clients=>[], :description=>"", :uses=>{:udp=>[525]}},
:tempo=>{:aliases=>["newdate"], :clients=>[], :description=>"", :uses=>{:tcp=>[526]}},
:courier=>{:aliases=>["rpc"], :clients=>[], :description=>"", :uses=>{:tcp=>[530]}},
:conference=>{:aliases=>["chat"], :clients=>[], :description=>"", :uses=>{:tcp=>[531]}},
:netnews=>{:aliases=>["readnews"], :clients=>[], :description=>"", :uses=>{:tcp=>[532]}},
:netwall=>{:aliases=>[], :clients=>[], :description=>"for emergency broadcasts", :uses=>{:udp=>[533]}},
:gdomap=>{:aliases=>[], :clients=>[], :description=>"GNUstep distributed objects", :uses=>{:tcp=>[538], :udp=>[538]}},
:uucp=>{:aliases=>["uucpd"], :clients=>[], :description=>"uucp daemon", :uses=>{:tcp=>[540]}},
:klogin=>{:aliases=>[], :clients=>[], :description=>"Kerberized `rlogin' (v5)", :uses=>{:tcp=>[543]}},
:kshell=>{:aliases=>["krcmd"], :clients=>[], :description=>"Kerberized `rsh' (v5)", :uses=>{:tcp=>[544]}},
:"dhcpv6-client"=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:tcp=>[546], :udp=>[546]}},
:"dhcpv6-server"=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:tcp=>[547], :udp=>[547]}},
:afpovertcp=>{:aliases=>[], :clients=>[], :description=>"AFP over TCP", :uses=>{:tcp=>[548], :udp=>[548]}},
:idfp=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:tcp=>[549], :udp=>[549]}},
:remotefs=>{:aliases=>["rfs_server", "rfs"], :clients=>[], :description=>"Brunhoff remote filesystem", :uses=>{:tcp=>[556]}},
:nntps=>{:aliases=>["snntp"], :clients=>[], :description=>"NNTP over SSL", :uses=>{:tcp=>[563], :udp=>[563]}},
:submission=>{:aliases=>[], :clients=>[], :description=>"Submission [RFC4409]", :uses=>{:tcp=>[587], :udp=>[587]}},
:ldaps=>{:aliases=>[], :clients=>[], :description=>"LDAP over SSL", :uses=>{:tcp=>[636], :udp=>[636]}},
:tinc=>{:aliases=>[], :clients=>[], :description=>"tinc control port", :uses=>{:tcp=>[655], :udp=>[655]}},
:silc=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:tcp=>[706], :udp=>[706]}},
:"kerberos-adm"=>{:aliases=>[], :clients=>[], :description=>"Kerberos `kadmin' (v5)", :uses=>{:tcp=>[749]}},
:webster=>{:aliases=>[], :clients=>[], :description=>"Network dictionary", :uses=>{:tcp=>[765], :udp=>[765]}},
:rsync=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:tcp=>[873], :udp=>[873]}},
:"ftps-data"=>{:aliases=>[], :clients=>[], :description=>"FTP over SSL (data)", :uses=>{:tcp=>[989]}},
:ftps=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:tcp=>[990]}},
:telnets=>{:aliases=>[], :clients=>[], :description=>"Telnet over SSL", :uses=>{:tcp=>[992], :udp=>[992]}},
:imaps=>{:aliases=>[], :clients=>[], :description=>"IMAP over SSL", :uses=>{:tcp=>[993], :udp=>[993]}},
:ircs=>{:aliases=>[], :clients=>[], :description=>"IRC over SSL", :uses=>{:tcp=>[994], :udp=>[994]}},
:pop3s=>{:aliases=>[], :clients=>[], :description=>"POP-3 over SSL", :uses=>{:tcp=>[995], :udp=>[995]}},
:socks=>{:aliases=>[], :clients=>[], :description=>"socks proxy server", :uses=>{:tcp=>[1080], :udp=>[1080]}},
:proofd=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:tcp=>[1093], :udp=>[1093]}},
:rootd=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:tcp=>[1094], :udp=>[1094]}},
:openvpn=>{:aliases=>["vpn"], :clients=>[], :description=>"", :uses=>{:tcp=>[1194], :udp=>[1194]}, :uses_preference => :udp},
:rmiregistry=>{:aliases=>[], :clients=>[], :description=>"Java RMI Registry", :uses=>{:tcp=>[1099], :udp=>[1099]}},
:kazaa=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:tcp=>[1214], :udp=>[1214]}},
:nessus=>{:aliases=>[], :clients=>[], :description=>"Nessus vulnerability", :uses=>{:tcp=>[1241], :udp=>[1241]}},
:lotusnote=>{:aliases=>[], :clients=>[], :description=>"Lotus Note", :uses=>{:tcp=>[1352], :udp=>[1352]}},
:"ms-sql-s"=>{:aliases=>[], :clients=>[], :description=>"Microsoft SQL Server", :uses=>{:tcp=>[1433], :udp=>[1433]}},
:"ms-sql-m"=>{:aliases=>[], :clients=>[], :description=>"Microsoft SQL Monitor", :uses=>{:tcp=>[1434], :udp=>[1434]}},
:ingreslock=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:tcp=>[1524], :udp=>[1524]}},
:"prospero-np"=>{:aliases=>[], :clients=>[], :description=>"Prospero non-privileged", :uses=>{:tcp=>[1525], :udp=>[1525]}},
:datametrics=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:tcp=>[1645], :udp=>[1645]}},
:"sa-msg-port"=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:tcp=>[1646], :udp=>[1646]}},
:kermit=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:tcp=>[1649], :udp=>[1649]}},
:l2f=>{:aliases=>["l2tp"], :clients=>[], :description=>"", :uses=>{:tcp=>[1701], :udp=>[1701]}},
:radius=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:tcp=>[1812], :udp=>[1812]}},
:"radius-acct"=>{:aliases=>[], :clients=>[], :description=>"Radius Accounting", :uses=>{:tcp=>[1813], :udp=>[1813]}},
:msnp=>{:aliases=>[], :clients=>[], :description=>"MSN Messenger", :uses=>{:tcp=>[1863], :udp=>[1863]}},
:"unix-status"=>{:aliases=>[], :clients=>[], :description=>"remstats unix-status server", :uses=>{:tcp=>[1957]}},
:"log-server"=>{:aliases=>[], :clients=>[], :description=>"remstats log server", :uses=>{:tcp=>[1958]}},
:remoteping=>{:aliases=>[], :clients=>[], :description=>"remstats remoteping server", :uses=>{:tcp=>[1959]}},
:"cisco-sccp"=>{:aliases=>[], :clients=>[], :description=>"Cisco SCCP", :uses=>{:tcp=>[2000], :udp=>[2000]}},
:search=>{:aliases=>["ndtp"], :clients=>[], :description=>"", :uses=>{:tcp=>[2010]}},
:pipe_server=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:tcp=>[2010]}},
:nfs=>{:aliases=>[], :clients=>[], :description=>"Network File System", :uses=>{:tcp=>[2049], :udp=>[2049]}},
:gnunet=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:tcp=>[2086], :udp=>[2086]}},
:"rtcm-sc104"=>{:aliases=>[], :clients=>[], :description=>"RTCM SC-104 IANA 1/29/99", :uses=>{:tcp=>[2101], :udp=>[2101]}},
:gsigatekeeper=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:tcp=>[2119], :udp=>[2119]}},
:gris=>{:aliases=>[], :clients=>[], :description=>"Grid Resource Information Server", :uses=>{:tcp=>[2135], :udp=>[2135]}},
:cvspserver=>{:aliases=>[], :clients=>[], :description=>"CVS client/server operations", :uses=>{:tcp=>[2401], :udp=>[2401]}},
:venus=>{:aliases=>[], :clients=>[], :description=>"codacon port", :uses=>{:tcp=>[2430], :udp=>[2430]}},
:"venus-se"=>{:aliases=>[], :clients=>[], :description=>"tcp side effects", :uses=>{:tcp=>[2431], :udp=>[2431]}},
:codasrv=>{:aliases=>[], :clients=>[], :description=>"not used", :uses=>{:tcp=>[2432], :udp=>[2432]}},
:"codasrv-se"=>{:aliases=>[], :clients=>[], :description=>"tcp side effects", :uses=>{:tcp=>[2433], :udp=>[2433]}},
:mon=>{:aliases=>[], :clients=>[], :description=>"MON traps", :uses=>{:tcp=>[2583], :udp=>[2583]}},
:dict=>{:aliases=>[], :clients=>[], :description=>"Dictionary server", :uses=>{:tcp=>[2628], :udp=>[2628]}},
:gsiftp=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:tcp=>[2811], :udp=>[2811]}},
:gpsd=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:tcp=>[2947], :udp=>[2947]}},
:gds_db=>{:aliases=>[], :clients=>[], :description=>"InterBase server", :uses=>{:tcp=>[3050], :udp=>[3050]}},
:icpv2=>{:aliases=>["icp"], :clients=>[], :description=>"Internet Cache Protocol", :uses=>{:tcp=>[3130], :udp=>[3130]}},
:mysql=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:tcp=>[3306], :udp=>[3306]}},
:nut=>{:aliases=>[], :clients=>[], :description=>"Network UPS Tools", :uses=>{:tcp=>[3493], :udp=>[3493]}},
:distcc=>{:aliases=>[], :clients=>[], :description=>"distributed compiler", :uses=>{:tcp=>[3632], :udp=>[3632]}},
:daap=>{:aliases=>[], :clients=>[], :description=>"Digital Audio Access Protocol", :uses=>{:tcp=>[3689], :udp=>[3689]}},
:svn=>{:aliases=>["subversion"], :clients=>[], :description=>"Subversion protocol", :uses=>{:tcp=>[3690], :udp=>[3690]}},
:suucp=>{:aliases=>[], :clients=>[], :description=>"UUCP over SSL", :uses=>{:tcp=>[4031], :udp=>[4031]}},
:sysrqd=>{:aliases=>[], :clients=>[], :description=>"sysrq daemon", :uses=>{:tcp=>[4094], :udp=>[4094]}},
:sieve=>{:aliases=>[], :clients=>[], :description=>"ManageSieve Protocol", :uses=>{:tcp=>[4190]}},
:epmd=>{:aliases=>[], :clients=>[], :description=>"Erlang Port Mapper Daemon", :uses=>{:tcp=>[4369], :udp=>[4369]}},
:remctl=>{:aliases=>[], :clients=>[], :description=>"Remote Authenticated Command Service", :uses=>{:tcp=>[4373], :udp=>[4373]}},
:iax=>{:aliases=>[], :clients=>[], :description=>"Inter-Asterisk eXchange", :uses=>{:tcp=>[4569], :udp=>[4569]}},
:mtn=>{:aliases=>[], :clients=>[], :description=>"monotone Netsync Protocol", :uses=>{:tcp=>[4691], :udp=>[4691]}},
:"radmin-port"=>{:aliases=>[], :clients=>[], :description=>"RAdmin Port", :uses=>{:tcp=>[4899], :udp=>[4899]}},
:rfe=>{:aliases=>[], :clients=>[], :description=>"Radio Free Ethernet", :uses=>{:udp=>[5002], :tcp=>[5002]}},
:mmcc=>{:aliases=>[], :clients=>[], :description=>"multimedia conference control tool (Yahoo IM)", :uses=>{:tcp=>[5050], :udp=>[5050]}},
:sip=>{:aliases=>[], :clients=>[], :description=>"Session Initiation Protocol", :uses=>{:tcp=>[5060], :udp=>[5060]}},
:"sip-tls"=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:tcp=>[5061], :udp=>[5061]}},
:aol=>{:aliases=>[], :clients=>[], :description=>"AIM", :uses=>{:tcp=>[5190], :udp=>[5190]}},
:"xmpp-client"=>{:aliases=>[], :clients=>[], :description=>"Jabber Client Connection", :uses=>{:tcp=>[5222], :udp=>[5222]}},
:"xmpp-server"=>{:aliases=>[], :clients=>[], :description=>"Jabber Server Connection", :uses=>{:tcp=>[5269], :udp=>[5269]}},
:cfengine=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:tcp=>[5308], :udp=>[5308]}},
:mdns=>{:aliases=>[], :clients=>[], :description=>"Multicast DNS", :uses=>{:tcp=>[5353], :udp=>[5353]}},
:postgresql=>{:aliases=>[], :clients=>[], :description=>"PostgreSQL Database", :uses=>{:tcp=>[5432], :udp=>[5432]}},
:freeciv=>{:aliases=>["rptp"], :clients=>[], :description=>"Freeciv gameplay", :uses=>{:tcp=>[5556], :udp=>[5556]}},
:amqp=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:tcp=>[5672], :udp=>[5672], :sctp=>[5672]}},
:ggz=>{:aliases=>[], :clients=>[], :description=>"GGZ Gaming Zone", :uses=>{:tcp=>[5688], :udp=>[5688]}},
:x11=>{:aliases=>["x11-0"], :clients=>[], :description=>"X Window System", :uses=>{:tcp=>[6000], :udp=>[6000]}},
:"x11-1"=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:tcp=>[6001], :udp=>[6001]}},
:"x11-2"=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:tcp=>[6002], :udp=>[6002]}},
:"x11-3"=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:tcp=>[6003], :udp=>[6003]}},
:"x11-4"=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:tcp=>[6004], :udp=>[6004]}},
:"x11-5"=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:tcp=>[6005], :udp=>[6005]}},
:"x11-6"=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:tcp=>[6006], :udp=>[6006]}},
:"x11-7"=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:tcp=>[6007], :udp=>[6007]}},
:"gnutella-svc"=>{:aliases=>[], :clients=>[], :description=>"gnutella", :uses=>{:tcp=>[6346], :udp=>[6346]}},
:"gnutella-rtr"=>{:aliases=>[], :clients=>[], :description=>"gnutella", :uses=>{:tcp=>[6347], :udp=>[6347]}},
:sge_qmaster=>{:aliases=>[], :clients=>[], :description=>"Grid Engine Qmaster Service", :uses=>{:tcp=>[6444], :udp=>[6444]}},
:sge_execd=>{:aliases=>[], :clients=>[], :description=>"Grid Engine Execution Service", :uses=>{:tcp=>[6445], :udp=>[6445]}},
:"mysql-proxy"=>{:aliases=>[], :clients=>[], :description=>"MySQL Proxy", :uses=>{:tcp=>[6446], :udp=>[6446]}},
:"afs3-fileserver" => {:aliases => ["bbs"], :clients => [], :description => "file server itself", :uses => {:tcp => [7000], :udp => [7000]}},
:"afs3-callback"=>{:aliases=>[], :clients=>[], :description=>"callbacks to cache managers", :uses=>{:tcp=>[7001], :udp=>[7001]}},
:"afs3-prserver"=>{:aliases=>[], :clients=>[], :description=>"users & groups database", :uses=>{:tcp=>[7002], :udp=>[7002]}},
:"afs3-vlserver"=>{:aliases=>[], :clients=>[], :description=>"volume location database", :uses=>{:tcp=>[7003], :udp=>[7003]}},
:"afs3-kaserver"=>{:aliases=>[], :clients=>[], :description=>"AFS/Kerberos authentication", :uses=>{:tcp=>[7004], :udp=>[7004]}},
:"afs3-volser"=>{:aliases=>[], :clients=>[], :description=>"volume managment server", :uses=>{:tcp=>[7005], :udp=>[7005]}},
:"afs3-errors"=>{:aliases=>[], :clients=>[], :description=>"error interpretation service", :uses=>{:tcp=>[7006], :udp=>[7006]}},
:"afs3-bos"=>{:aliases=>[], :clients=>[], :description=>"basic overseer process", :uses=>{:tcp=>[7007], :udp=>[7007]}},
:"afs3-update"=>{:aliases=>[], :clients=>[], :description=>"server-to-server updater", :uses=>{:tcp=>[7008], :udp=>[7008]}},
:"afs3-rmtsys"=>{:aliases=>[], :clients=>[], :description=>"remote cache manager service", :uses=>{:tcp=>[7009], :udp=>[7009]}},
:"font-service"=>{:aliases=>[], :clients=>[], :description=>"X Font Service", :uses=>{:tcp=>[7100], :udp=>[7100]}},
:"http-alt"=>{:aliases=>[], :clients=>[], :description=>"WWW caching service", :uses=>{:tcp=>[8080], :udp=>[8080]}},
:"bacula-dir"=>{:aliases=>[], :clients=>[], :description=>"Bacula Director", :uses=>{:tcp=>[9101], :udp=>[9101]}},
:"bacula-fd"=>{:aliases=>[], :clients=>[], :description=>"Bacula File Daemon", :uses=>{:tcp=>[9102], :udp=>[9102]}},
:"bacula-sd"=>{:aliases=>[], :clients=>[], :description=>"Bacula Storage Daemon", :uses=>{:tcp=>[9103], :udp=>[9103]}},
:xmms2=>{:aliases=>[], :clients=>[], :description=>"Cross-platform Music Multiplexing System", :uses=>{:tcp=>[9667], :udp=>[9667]}},
:nbd=>{:aliases=>[], :clients=>[], :description=>"Linux Network Block Device", :uses=>{:tcp=>[10809]}},
:"zabbix-agent"=>{:aliases=>[], :clients=>[], :description=>"Zabbix Agent", :uses=>{:tcp=>[10050], :udp=>[10050]}},
:"zabbix-trapper"=>{:aliases=>[], :clients=>[], :description=>"Zabbix Trapper", :uses=>{:tcp=>[10051], :udp=>[10051]}},
:amanda=>{:aliases=>[], :clients=>[], :description=>"amanda backup services", :uses=>{:tcp=>[10080], :udp=>[10080]}},
:hkp=>{:aliases=>[], :clients=>[], :description=>"OpenPGP HTTP Keyserver", :uses=>{:tcp=>[11371], :udp=>[11371]}},
:bprd=>{:aliases=>[], :clients=>[], :description=>"VERITAS NetBackup", :uses=>{:tcp=>[13720], :udp=>[13720]}},
:bpdbm=>{:aliases=>[], :clients=>[], :description=>"VERITAS NetBackup", :uses=>{:tcp=>[13721], :udp=>[13721]}},
:"bpjava-msvc"=>{:aliases=>[], :clients=>[], :description=>"BP Java MSVC Protocol", :uses=>{:tcp=>[13722], :udp=>[13722]}},
:vnetd=>{:aliases=>[], :clients=>[], :description=>"Veritas Network Utility", :uses=>{:tcp=>[13724], :udp=>[13724]}},
:bpcd=>{:aliases=>[], :clients=>[], :description=>"VERITAS NetBackup", :uses=>{:tcp=>[13782], :udp=>[13782]}},
:vopied=>{:aliases=>[], :clients=>[], :description=>"VERITAS NetBackup", :uses=>{:tcp=>[13783], :udp=>[13783]}},
:dcap=>{:aliases=>[], :clients=>[], :description=>"dCache Access Protocol", :uses=>{:tcp=>[22125]}},
:gsidcap=>{:aliases=>[], :clients=>[], :description=>"GSI dCache Access Protocol", :uses=>{:tcp=>[22128]}},
:wnn6=>{:aliases=>[], :clients=>[], :description=>"wnn6", :uses=>{:tcp=>[22273], :udp=>[22273]}},
:rtmp=>{:aliases=>[], :clients=>[], :description=>"Routing Table Maintenance Protocol", :uses=>{:ddp=>[1]}},
:nbp=>{:aliases=>[], :clients=>[], :description=>"Name Binding Protocol", :uses=>{:ddp=>[2]}},
:zip=>{:aliases=>[], :clients=>[], :description=>"Zone Information Protocol", :uses=>{:ddp=>[6]}},
:kerberos4=>{:aliases=>["kerberos-iv", "kdc"], :clients=>[], :description=>"Kerberos (server)", :uses=>{:udp=>[750], :tcp=>[750]}},
:kerberos_master=>{:aliases=>[], :clients=>[], :description=>"Kerberos authentication", :uses=>{:udp=>[751], :tcp=>[751]}},
:passwd_server=>{:aliases=>[], :clients=>[], :description=>"Kerberos passwd server", :uses=>{:udp=>[752]}},
:krb_prop=>{:aliases=>["krb5_prop", "hprop"], :clients=>[], :description=>"Kerberos slave propagation", :uses=>{:tcp=>[754]}},
:krbupdate=>{:aliases=>["kreg"], :clients=>[], :description=>"Kerberos registration", :uses=>{:tcp=>[760]}},
:swat=>{:aliases=>[], :clients=>[], :description=>"swat", :uses=>{:tcp=>[901]}},
:kpop=>{:aliases=>[], :clients=>[], :description=>"Pop with Kerberos", :uses=>{:tcp=>[1109]}},
:knetd=>{:aliases=>[], :clients=>[], :description=>"Kerberos de-multiplexor", :uses=>{:tcp=>[2053]}},
:"zephyr-srv"=>{:aliases=>[], :clients=>[], :description=>"Zephyr server", :uses=>{:udp=>[2102]}},
:"zephyr-clt"=>{:aliases=>[], :clients=>[], :description=>"Zephyr serv-hm connection", :uses=>{:udp=>[2103]}},
:"zephyr-hm"=>{:aliases=>[], :clients=>[], :description=>"Zephyr hostmanager", :uses=>{:udp=>[2104]}},
:eklogin=>{:aliases=>[], :clients=>[], :description=>"Kerberos encrypted rlogin", :uses=>{:tcp=>[2105]}},
:kx=>{:aliases=>[], :clients=>[], :description=>"X over Kerberos", :uses=>{:tcp=>[2111]}},
:iprop=>{:aliases=>[], :clients=>[], :description=>"incremental propagation", :uses=>{:tcp=>[2121]}},
:supfilesrv=>{:aliases=>[], :clients=>[], :description=>"SUP server", :uses=>{:tcp=>[871]}},
:supfiledbg=>{:aliases=>[], :clients=>[], :description=>"SUP debugging", :uses=>{:tcp=>[1127]}},
:linuxconf=>{:aliases=>[], :clients=>[], :description=>"LinuxConf", :uses=>{:tcp=>[98]}},
:poppassd=>{:aliases=>[], :clients=>[], :description=>"Eudora", :uses=>{:tcp=>[106], :udp=>[106]}},
:ssmtp=>{:aliases=>["smtps"], :clients=>[], :description=>"SMTP over SSL", :uses=>{:tcp=>[465]}},
:moira_db=>{:aliases=>[], :clients=>[], :description=>"Moira database", :uses=>{:tcp=>[775]}},
:moira_update=>{:aliases=>[], :clients=>[], :description=>"Moira update protocol", :uses=>{:tcp=>[777]}},
:moira_ureg=>{:aliases=>[], :clients=>[], :description=>"Moira user registration", :uses=>{:udp=>[779]}},
:spamd=>{:aliases=>[], :clients=>[], :description=>"spamassassin daemon", :uses=>{:tcp=>[783]}},
:omirr=>{:aliases=>["omirrd"], :clients=>[], :description=>"online mirror", :uses=>{:tcp=>[808], :udp=>[808]}},
:customs=>{:aliases=>[], :clients=>[], :description=>"pmake customs server", :uses=>{:tcp=>[1001], :udp=>[1001]}},
:skkserv=>{:aliases=>[], :clients=>[], :description=>"skk jisho server port", :uses=>{:tcp=>[1178]}},
:predict=>{:aliases=>[], :clients=>[], :description=>"predict -- satellite tracking", :uses=>{:udp=>[1210]}},
:rmtcfg=>{:aliases=>[], :clients=>[], :description=>"Gracilis Packeten remote config server", :uses=>{:tcp=>[1236]}},
:wipld=>{:aliases=>[], :clients=>[], :description=>"Wipl network monitor", :uses=>{:tcp=>[1300]}},
:xtel=>{:aliases=>[], :clients=>[], :description=>"french minitel", :uses=>{:tcp=>[1313]}},
:xtelw=>{:aliases=>[], :clients=>[], :description=>"french minitel", :uses=>{:tcp=>[1314]}},
:support=>{:aliases=>[], :clients=>[], :description=>"GNATS", :uses=>{:tcp=>[1529]}},
:cfinger=>{:aliases=>[], :clients=>[], :description=>"GNU Finger", :uses=>{:tcp=>[2003]}},
:frox=>{:aliases=>[], :clients=>[], :description=>"frox: caching ftp proxy", :uses=>{:tcp=>[2121]}},
:ninstall=>{:aliases=>[], :clients=>[], :description=>"ninstall service", :uses=>{:tcp=>[2150], :udp=>[2150]}},
:zebrasrv=>{:aliases=>[], :clients=>[], :description=>"zebra service", :uses=>{:tcp=>[2600]}},
:zebra=>{:aliases=>[], :clients=>[], :description=>"zebra vty", :uses=>{:tcp=>[2601]}},
:ripd=>{:aliases=>[], :clients=>[], :description=>"ripd vty (zebra)", :uses=>{:tcp=>[2602]}},
:ripngd=>{:aliases=>[], :clients=>[], :description=>"ripngd vty (zebra)", :uses=>{:tcp=>[2603]}},
:ospfd=>{:aliases=>[], :clients=>[], :description=>"ospfd vty (zebra)", :uses=>{:tcp=>[2604]}},
:bgpd=>{:aliases=>[], :clients=>[], :description=>"bgpd vty (zebra)", :uses=>{:tcp=>[2605]}},
:ospf6d=>{:aliases=>[], :clients=>[], :description=>"ospf6d vty (zebra)", :uses=>{:tcp=>[2606]}},
:ospfapi=>{:aliases=>[], :clients=>[], :description=>"OSPF-API", :uses=>{:tcp=>[2607]}},
:isisd=>{:aliases=>[], :clients=>[], :description=>"ISISd vty (zebra)", :uses=>{:tcp=>[2608]}},
:afbackup=>{:aliases=>[], :clients=>[], :description=>"Afbackup system", :uses=>{:tcp=>[2988], :udp=>[2988]}},
:afmbackup=>{:aliases=>[], :clients=>[], :description=>"Afmbackup system", :uses=>{:tcp=>[2989], :udp=>[2989]}},
:xtell=>{:aliases=>[], :clients=>[], :description=>"xtell server", :uses=>{:tcp=>[4224]}},
:fax=>{:aliases=>[], :clients=>[], :description=>"FAX transmission service (old)", :uses=>{:tcp=>[4557]}},
:hylafax=>{:aliases=>[], :clients=>[], :description=>"HylaFAX client-server protocol (new)", :uses=>{:tcp=>[4559]}},
:distmp3=>{:aliases=>[], :clients=>[], :description=>"distmp3host daemon", :uses=>{:tcp=>[4600]}},
:munin=>{:aliases=>["lrrd"], :clients=>[], :description=>"Munin", :uses=>{:tcp=>[4949]}},
:"enbd-cstatd"=>{:aliases=>[], :clients=>[], :description=>"ENBD client statd", :uses=>{:tcp=>[5051]}},
:"enbd-sstatd"=>{:aliases=>[], :clients=>[], :description=>"ENBD server statd", :uses=>{:tcp=>[5052]}},
:pcrd=>{:aliases=>[], :clients=>[], :description=>"PCR-1000 Daemon", :uses=>{:tcp=>[5151]}},
:noclog=>{:aliases=>[], :clients=>[], :description=>"noclogd with TCP (nocol)", :uses=>{:tcp=>[5354], :udp=>[5354]}},
:hostmon=>{:aliases=>[], :clients=>[], :description=>"hostmon uses TCP (nocol)", :uses=>{:tcp=>[5355], :udp=>[5355]}},
:rplay=>{:aliases=>[], :clients=>[], :description=>"RPlay audio service", :uses=>{:udp=>[5555]}},
:nrpe=>{:aliases=>[], :clients=>[], :description=>"Nagios Remote Plugin Executor", :uses=>{:tcp=>[5666]}},
:nsca=>{:aliases=>[], :clients=>[], :description=>"Nagios Agent - NSCA", :uses=>{:tcp=>[5667]}},
:mrtd=>{:aliases=>[], :clients=>[], :description=>"MRT Routing Daemon", :uses=>{:tcp=>[5674]}},
:bgpsim=>{:aliases=>[], :clients=>[], :description=>"MRT Routing Simulator", :uses=>{:tcp=>[5675]}},
:canna=>{:aliases=>[], :clients=>[], :description=>"cannaserver", :uses=>{:tcp=>[5680]}},
:"sane-port"=>{:aliases=>[], :clients=>[], :description=>"SANE network scanner daemon", :uses=>{:tcp=>[6566]}},
:ircd=>{:aliases=>[], :clients=>[], :description=>"Internet Relay Chat", :uses=>{:tcp=>[6667]}},
:"zope-ftp"=>{:aliases=>[], :clients=>[], :description=>"zope management by ftp", :uses=>{:tcp=>[8021]}},
:tproxy=>{:aliases=>[], :clients=>[], :description=>"Transparent Proxy", :uses=>{:tcp=>[8081]}},
:omniorb=>{:aliases=>[], :clients=>[], :description=>"OmniORB", :uses=>{:tcp=>[8088], :udp=>[8088]}},
:xinetd=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:tcp=>[9098]}},
:mandelspawn=>{:aliases=>[], :clients=>[], :description=>"network mandelbrot", :uses=>{:udp=>[9359]}},
:git=>{:aliases=>[], :clients=>[], :description=>"Git Version Control System", :uses=>{:tcp=>[9418]}},
:zope=>{:aliases=>[], :clients=>[], :description=>"zope server", :uses=>{:tcp=>[9673]}},
:webmin=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:tcp=>[10000]}},
:kamanda=>{:aliases=>[], :clients=>[], :description=>"amanda backup services (Kerberos)", :uses=>{:tcp=>[10081], :udp=>[10081]}},
:amandaidx=>{:aliases=>[], :clients=>[], :description=>"amanda backup services", :uses=>{:tcp=>[10082]}},
:amidxtape=>{:aliases=>[], :clients=>[], :description=>"amanda backup services", :uses=>{:tcp=>[10083]}},
:smsqp=>{:aliases=>[], :clients=>[], :description=>"Alamin SMS gateway", :uses=>{:tcp=>[11201], :udp=>[11201]}},
:xpilot=>{:aliases=>[], :clients=>[], :description=>"XPilot Contact Port", :uses=>{:tcp=>[15345], :udp=>[15345]}},
:"sgi-cmsd"=>{:aliases=>[], :clients=>[], :description=>"Cluster membership services daemon", :uses=>{:udp=>[17001]}},
:"sgi-crsd"=>{:aliases=>[], :clients=>[], :description=>"", :uses=>{:udp=>[17002]}},
:"sgi-gcd"=>{:aliases=>[], :clients=>[], :description=>"SGI Group membership daemon", :uses=>{:udp=>[17003]}},
:"sgi-cad"=>{:aliases=>[], :clients=>[], :description=>"Cluster Admin daemon", :uses=>{:tcp=>[17004]}},
:isdnlog=>{:aliases=>[], :clients=>[], :description=>"isdn logging system", :uses=>{:tcp=>[20011], :udp=>[20011]}},
:vboxd=>{:aliases=>[], :clients=>[], :description=>"voice box system", :uses=>{:tcp=>[20012], :udp=>[20012]}},
:binkp=>{:aliases=>[], :clients=>[], :description=>"binkp fidonet protocol", :uses=>{:tcp=>[24554]}},
:asp=>{:aliases=>[], :clients=>[], :description=>"Address Search Protocol", :uses=>{:tcp=>[27374], :udp=>[27374]}},
:csync2=>{:aliases=>[], :clients=>[], :description=>"cluster synchronization tool", :uses=>{:tcp=>[30865]}},
:dircproxy=>{:aliases=>[], :clients=>[], :description=>"Detachable IRC Proxy", :uses=>{:tcp=>[57000]}},
:tfido=>{:aliases=>[], :clients=>[], :description=>"fidonet EMSI over telnet", :uses=>{:tcp=>[60177]}},
:fido=>{:aliases=>[], :clients=>[], :description=>"fidonet EMSI over TCP", :uses=>{:tcp=>[60179]}}
}
#
#
# ### end of SYSTEM detail initialization
end
#
def gxg_root()
@thread_safety.synchronize { @details[:gxg_root].to_s }
end
#
def gxg_root=(the_path=nil)
if the_path.is_a?(::String)
@thread_safety.synchronize { @details[:gxg_root] = the_path }
end
end
#
def server_paths()
result = {}
# Define Server directories
gxg_root_dir = ::GxG::SYSTEM.gxg_root()
public_dir = File.expand_path("./Public",gxg_root_dir)
services_dir = File.expand_path("./Services",gxg_root_dir)
app_dir = File.expand_path("./Applications",gxg_root_dir)
system_dir = File.expand_path("./System",gxg_root_dir)
sys_config_dir = "#{system_dir}/Configuration"
sys_db_dir = "#{system_dir}/Databases"
sys_ext_dir = "#{system_dir}/Extensions"
sys_gem_dir = "#{system_dir}/Gems"
sys_lib_dir = "#{system_dir}/Libraries"
tmp_dir = "#{system_dir}/Temporary"
log_dir = "#{system_dir}/Logs"
result = {:root => gxg_root_dir, :system => system_dir, :services => services_dir, :temporary => tmp_dir, :logs => log_dir, :applications => app_dir, :users => nil, :public => public_dir, :configuration => sys_config_dir, :databases => sys_db_dir, :extensions => sys_ext_dir, :gems => sys_gem_dir, :libraries => sys_lib_dir}
result
end
#
def application_paths(application_name=nil)
result = {}
if application_name.is_a?(::String)
result = {:file_system => "/", :user => ::ENV['HOME']}
case GxG::SYSTEM.platform[:platform]
when :windows
result[:file_system] = (ENV["HOMEDRIVE"] + "/")
result[:user] = File.join(ENV["HOME"].split("\\"))
result[:shared] = File.join(ENV["PUBLIC"].split("\\"))
result[:temporary] = File.join(ENV["TEMP"].split("\\"))
result[:application_data] = (File.join(ENV["LOCALAPPDATA"].split("\\")) + "/GxG/" + application_name)
result[:preferences] = (result[:application_data] + "/Preferences")
result[:logs] = (result[:application_data] + "/Logs")
result[:projects] = (result[:user] + "/GxG")
result[:fonts] = (result[:projects] + "/Fonts")
result[:desktop] = (result[:user] + "/Desktop")
result[:documents] = (result[:user] + "/Documents")
result[:downloads] = (result[:user] + "/Downloads")
result[:audio] = (result[:user] + "/Music")
result[:images] = (result[:user] + "/Pictures")
result[:video] = (result[:user] + "/Videos")
when :linux
case GxG::SYSTEM.environment[:environment]
when :ubuntu
result[:user] = ENV['HOME']
result[:shared] = "/tmp"
result[:temporary] = "/tmp"
result[:application_data] = (result[:user] + "/.local/share/GxG/" + application_name)
result[:preferences] = (result[:user] + "/.config/GxG/" + application_name)
result[:logs] = (result[:application_data] + "/Logs")
result[:projects] = (result[:user] + "/GxG")
result[:fonts] = (result[:user] + "/.fonts")
result[:desktop] = (result[:user] + "/Desktop")
result[:documents] = (result[:user] + "/Documents")
result[:downloads] = (result[:user] + "/Downloads")
result[:audio] = (result[:user] + "/Music")
result[:images] = (result[:user] + "/Pictures")
result[:video] = (result[:user] + "/Videos")
when :redhat
end
when :darwin
case GxG::SYSTEM.environment[:environment]
when :darwin
when :macos
result[:user] = ENV['HOME']
result[:shared] = "/Users/Shared"
result[:temporary] = "/tmp"
result[:application_data] = (result[:user] + "/Library/Application Support/GxG/" + application_name)
result[:preferences] = (result[:user] + "/Library/Preferences/GxG/" + application_name)
result[:logs] = (result[:user] + "/Library/Logs/GxG/" + application_name)
result[:projects] = (result[:user] + "/GxG")
result[:fonts] = (result[:user] + "/Library/Fonts")
result[:desktop] = (result[:user] + "/Desktop")
result[:documents] = (result[:user] + "/Documents")
result[:downloads] = (result[:user] + "/Downloads")
result[:audio] = (result[:user] + "/Music")
result[:images] = (result[:user] + "/Pictures")
result[:video] = (result[:user] + "/Movies")
end
end
end
result
end
#
def gxg_cpu_add(cpu_record=nil)
# Review : part of a monkey-patch solution to extremely long data-fetch times for using wmic for cpu data
if cpu_record.is_a?(::Hash)
@thread_safety.synchronize { @details[:processors] << cpu_record }
end
end
#
def detail_mapping()
# Maps universal system data keys to @details hash paths (cached data from system)
# TCP tuning: http://www.psc.edu/networking/projects/tcptune/#tutorial
#
result = []
#
@thread_safety.synchronize {
if @details[:network][:protocols][:ipv4]
result << {:key => "net.ipv4.tcp.autotune", :path => "/:network/:protocols/:ipv4/:settings/:tcp/:autotune"}
result << {:key => "net.ipv4.tcp.timestamps", :path => "/:network/:protocols/:ipv4/:settings/:tcp/:timestamps"}
result << {:key => "net.ipv4.tcp.window_scaling", :path => "/:network/:protocols/:ipv4/:settings/:tcp/:window_scaling"}
result << {:key => "net.ipv4.tcp.selective_ack", :path => "/:network/:protocols/:ipv4/:settings/:tcp/:selective_ack"}
end
}
result << {:key => "net.ipv4.tcp.read", :path => "/:memory_limits/:buffers/:ipv4/:tcp/:read"}
result << {:key => "net.ipv4.tcp.write", :path => "/:memory_limits/:buffers/:ipv4/:tcp/:write"}
result << {:key => "net.socket.ipc.read", :path => "/:memory_limits/:buffers/:socket/:ipc/:read"}
result << {:key => "net.socket.ipc.write", :path => "/:memory_limits/:buffers/:socket/:ipc/:write"}
result << {:key => "net.ipv4.udp.read", :path => "/:memory_limits/:buffers/:ipv4/:udp/:read"}
result << {:key => "net.ipv4.udp.write", :path => "/:memory_limits/:buffers/:ipv4/:udp/:write"}
result << {:key => "configuration.process.maximum_file_descriptors", :path => "/:platform_configuration/:process/:maximum_file_descriptors"}
#
result
end
private :detail_mapping
#
def system_data_keys(other_platform=nil)
# Lists known techniques per-universal-key for gathering system data (not necessarily cached)
# Linux getconf : http://publib.boulder.ibm.com/infocenter/iseries/v7r1m0/index.jsp?topic=%2Frzahz%2Frzahzgetconf.htm
# Linux configuration files : http://www.ibm.com/developerworks/linux/library/l-config/index.html
#
result = []
data = []
#
data << {:key => "net.ipv4.tcp.autotune", :platforms => [:linux], :operation => {:sysctl => "net.ipv4.tcp_moderate_rcvbuf", :format => :zerofalse}}
# RFC1323 extensions support
data << {:key => "net.ipv4.tcp.timestamps", :platforms => [:linux], :operation => {:sysctl => "net.ipv4.tcp_timestamps", :format => :zerofalse}}
data << {:key => "net.ipv4.tcp.window_scaling", :platforms => [:linux], :operation => {:sysctl => "net.ipv4.tcp_window_scaling", :format => :zerofalse}}
# RFC2108 extension support
data << {:key => "net.ipv4.tcp.selective_ack", :platforms => [:linux], :operation => {:sysctl => "net.ipv4.tcp_sack", :format => :zerofalse}}
data << {:key => "net.ipv4.tcp.read", :platforms => [:linux], :operation => {:sysctl => "net.ipv4.tcp_rmem", :format => :valid_with_initial}}
data << {:key => "net.ipv4.tcp.write", :platforms => [:linux], :operation => {:sysctl => "net.ipv4.tcp_wmem", :format => :valid_with_initial}}
# net.ipv4.tcp.(rmem/wmem) sets the buffer sizing for unix domains and non-tcp sockets
data << {:key => "net.socket.ipc.read", :platforms => [:linux], :operation => {:sysctl => "net.ipv4.tcp_rmem", :format => :valid_with_initial}}
data << {:key => "net.socket.ipc.write", :platforms => [:linux], :operation => {:sysctl => "net.ipv4.tcp_wmem", :format => :valid_with_initial}}
# LATER: confirm udp read and write mem is symmetric.
data << {:key => "net.ipv4.udp.read", :platforms => [:linux], :operation => {:sysctl => "net.ipv4.udp_mem", :format => :valid_with_initial}}
data << {:key => "net.ipv4.udp.write", :platforms => [:linux], :operation => {:sysctl => "net.ipv4.udp_mem", :format => :valid_with_initial}}
# TODO: Research sysctl keys for Path MTU Discovery (RFC1191, RFC1981, RFC4821)
# System-wide maximum threads available on this system: (per-process on Windows)
data << {:key => "kernel.threads_max", :platforms => [:windows], :operation => {:literal => "2000", :format => :to_int}}
data << {:key => "kernel.threads_max", :platforms => [:linux], :operation => {:sysctl => "kernel.threads-max", :format => :to_int}}
# Review : FORNOW using kern.maxproc but that's not right --> research actual method.
data << {:key => "kernel.threads_max", :platforms => [:bsd, :darwin], :operation => {:sysctl => "kern.maxproc", :format => :to_int}}
# #
# getconf variable meanings:
# Attribution: http://www.lainoox.com/system-wide-config-getconf/
#ARG_MAX Maximum length, in bytes, of the arguments for one of the exec subroutines, including environment data.
#CHAR_BIT Number of bits in a type character.
#CHAR_MAX Maximum value of a type character.
#CHAR_MIN Minimum value of a type character.
#CHILD_MAX Maximum number of simultaneous processes for each real user ID.
#CLK_TCK Number of clock ticks per second returned by the time subroutine.
#INT_MAX Maximum value of a type int.
#INT_MIN Minimum value of a type int.
#LONG_BIT Number of bits in a type long int.
#LONG_MAX Maximum value of a type long int.
#LONG_MIN Minimum value of a type long int.
#MB_LEN_MAX Maximum number of bytes in a character for any supported locale.
#NGROUPS_MAX Maximum number of simultaneous supplementary group IDs for each process.
#NL_ARGMAX Maximum value of digit in calls to the printf and scanf subroutines.
#NL_LANGMAX Maximum number of bytes in a LANG name.
#NL_MSGMAX Maximum message number.
#NL_NMAX Maximum number of bytes in an N-to-1 collation mapping.
#NL_SETMAX Maximum set number.
#NL_TEXTMAX Maximum number of bytes in a message string.
#NZERO Default process priority.
#OPEN_MAX Maximum number of files that one process can have open at one time.
#SCHAR_MAX Maximum value of a type signed char.
#SCHAR_MIN Minimum value of a type signed char.
#SHRT_MAX Maximum value of a type short.
#SHRT_MIN Minimum value of a type short.
#SSIZE_MAX Maximum value of an object of type ssize_t.
#TZNAME_MAX Maximum number of bytes supported for the name of a time zone (not the length of the TZ environment variable).
#UCHAR_MAX Maximum value of a type unsigned char.
#UINT_MAX Maximum value of a type unsigned int.
#ULONG_MAX Maximum value of a type unsigned long int.
#USHRT_MAX Maximum value of a type unsigned short int.
#WORD_BIT Number of bits in a word or type int.
data << {:key => "configuration.process.maximum_file_descriptors", :platforms => [:linux], :operation => {:getconf => "OPEN_MAX", :format => :to_int}}
# TODO: Research maximum limit under epoll/kqueue: See: http://news.ycombinator.com/item?id=1740823
# Also : http://stackoverflow.com/questions/651665/how-many-socket-connections-possible
# inventory the various platform variables that affect what threshold of max_socket_count a given system would end up with.
# See: http://www.metabrew.com/article/a-million-user-comet-application-with-mochiweb-part-3
# Sysctl tuning: http://www.metabrew.com/article/a-million-user-comet-application-with-mochiweb-part-1
# LATER: develop a series of formulas for calculating approx. how many clients one can support under one 'cluster' controller (session manager).
data.to_enum.each do |entry|
if entry[:platforms].include?((other_platform || @details[:platform]))
result << entry
end
end
#
result
end
private :system_data_keys
#
def get_system_data(keys=[])
# Support for <SYSTEM>.refresh_data_for(a_path) (private_method)
# some sort of sysctl + config + etc for *all* platforms:
# "sysctl -n net.ipv4.tcp_sack" becomes: "/net/ipv4/tcp/selective_ack" (external use path)
# @details[:memory_limits][:buffers][:socket][:ipc] becomes colllection_point = @details.at_path(":memory_limits/:buffers/:socket/:ipc");collection_point[(key)]=value
# procs for gathering data, and formatting for use.
# by_platform key between sysctl/config-key and @details hash path.
# {:synonyms => ["external-path"], :sysctl => "key-string', :format => :proc-name, :location => "hash-path", :location_key => (:sym or int)}
#
unless keys.is_a?(::Array)
keys = [(keys)]
end
result = {}
format_to_int = Proc.new do |the_string|
(the_string.numeric_values()[:integer] || 0)
end
format_to_float = Proc.new do |the_string|
(the_string.numeric_values()[:float] || 0.0)
end
format_zerofalse = Proc.new do |the_string|
( format_to_int.call(the_string) > 0 )
end
format_valid_with_initial = Proc.new do |the_string|
raw_data = the_string.split(" ")
{:initial => format_to_int.call(raw_data[1]), :valid => ((format_to_int.call(raw_data[0]))..(format_to_int.call(raw_data[2])))}
end
sysctl_read = Proc.new do |a_key,the_formatter|
( the_formatter.call(`sysctl -n #{a_key.to_s}`.split("\n")[0]) )
end
getconf_read = Proc.new do |a_key, the_formatter|
( the_formatter.call(`getconf #{a_key.to_s}`.split("\n")[0]) )
end
#
reference = system_data_keys()
#
fetch_data = Proc.new do |the_key|
data = nil
reference.to_enum.each do |entry|
if entry[:key] == the_key
case entry[:operation][:format]
when :zerofalse
the_formatter = format_zerofalse
when :to_int
the_formatter = format_to_int
when :to_float
the_formatter = format_to_float
when :valid_with_initial
the_formatter = format_valid_with_initial
end
begin
if entry[:operation][:sysctl]
data = sysctl_read.call(entry[:operation][:sysctl],the_formatter)
else
if entry[:operation][:getconf]
data = getconf_read.call(entry[:operation][:getconf],the_formatter)
else
if entry[:operation][:literal]
data = the_formatter.call(entry[:operation][:literal])
end
end
end
rescue Exception
#
end
if data
break
end
end
end
data
end
#
keys.to_enum.each do |specifier|
if specifier.is_a?(::String)
# if element is String: serves as result Hash key to hold result value.
# single result with this result key
result[(specifier)] = fetch_data.call(specifier)
else
if specifier.is_a?(::Hash)
# if element is Hash: {ukey => hash_path}, {:key => <keystring>, :path => <hash_path>}
# if hash_path supplied, read the data; set the @details hash element, and return the formatted data
if specifier[:key]
# {:key => <keystring>, :path => <hash_path>}
result[(specifier[:key])] = fetch_data.call(specifier[:key])
if specifier[:path]
@thread_safety.synchronize {
@details.set_at_path(specifier[:path],result[(specifier[:key])])
}
end
else
# {ukey => hash_path}
subkeys = specifier.keys
subkeys.to_enum.each do |a_key|
result[(a_key)] = fetch_data.call(a_key)
@thread_safety.synchronize {
@details.set_at_path(specifier[(a_key)],result[(a_key)])
}
end
end
end
end
end
#
result
end
private :get_system_data
#
def set_system_data(keys=[])
# LATER: when you figure out system(sudo) authentication - use this for ops that require elevated privs to set system parameters.
# Define a set of universal_keys that affect what other keys; upon setting any one, unique-list a set of keys to read back in w/ hash paths.
result = nil
if nil
get_system_data(nil,nil)
# compare hash value to the_value; return true if successful
end
result
end
private :set_system_data
#
def keys()
result = []
reference = detail_mapping()
reference.to_enum.each do |mapping|
result << mapping[:key]
end
result
end
#
def [](the_path="")
# Public interface for accessing system keyed values.
# access cached or system-read values on /proc (sysctl-style) keys. (frankly missing from BSD, etc)
result = nil
reference = detail_mapping()
#
reference.to_enum.each do |mapping|
if mapping[:key] == the_path
@thread_safety.synchronize {
result = @details.get_at_path(mapping[:path]).clone
}
break
end
end
unless result
# attempt to fetch the data from the system somehow.
result = get_system_data(the_path)
unless result.keys.size > 0
result = nil
end
end
#
result
end
#
def architecture()
@thread_safety.synchronize {
{:architecture => @details[:architecture], :processors => @details[:processors]}.clone
}
end
#
def platform()
@thread_safety.synchronize {
{:platform => @details[:platform], :version => @details[:platform_version], :configuration => @details[:platform_configuration]}.clone
}
end
#
def environment()
@thread_safety.synchronize {
{:environment => @details[:environment], :version => @details[:environment_version], :variant => @details[:environment_variant]}.clone
}
end
#
def engine()
# ??? just info ??? GxG::Engine::profile()
::GxG::Engine
end
#
def network()
@thread_safety.synchronize {
@details[:network].clone
}
end
#
def load_average()
# this or cpuload ??
this_platform = @details[:platform]
case this_platform
when :linux
result = (`uptime`.split(":")[-1].chomp.split(","))
result.to_enum(:each_index).each do |indexer|
result[(indexer)] = result[(indexer)].to_f
end
else
result = []
end
result
end
#
def cpuload
# this or load_average ??
average = Sys::CPU.load_avg
{ :minute1 => average[0], :minute5 => average[1], :minute15 => average[2] }
end
#
def valid_modes()
result = {}
result.merge(GxG::IO::IO::valid_modes())
@thread_safety.synchronize {
result.merge(@valid_modes)
}
result
end
def memory_limits()
# See: http://linux-mm.org/LinuxMM
# http://linux.die.net/man/2/mlock
# https://answers.launchpad.net/graphite/+question/191807
#
@thread_safety.synchronize {
@details[:memory_limits].clone
}
end
def maximum_buffer_size()
self.memory_limits()[:buffers]
end
#
def memory()
result = {}
this_platform = nil
@thread_safety.synchronize { this_platform = @details[:platform] }
case this_platform
# TODO: GxG::SYSTEM.memory : research free mem discovery for Winderz and BSD
when :windows
# No known way to get this info. MEM is dosbox only style memory counting. :P
# Might have to bind to a C or C++ lib for this kind of data (PITA)
# FORNOW: just pretend upper theoretical limit on a process is all you have (sucks)
# mem_limit = ::GxG::SYSTEM.memory_limits()[:process].max
# Total Physical Memory: 8,192 MB
# Available Physical Memory: 5,053 MB
# Virtual Memory: Max Size: 9,472 MB
# Virtual Memory: Available: 4,932 MB
# Virtual Memory: In Use: 4,540 MB
raw_system_info = `systeminfo /FO LIST`
data = {:mem_limit => nil, :mem_free => nil, :vmem_limit => nil, :vmem_used => nil, :vmem_free => nil}
raw_system_info.each_line do |the_line|
if the_line.include?("Total Physical Memory")
data[:mem_limit] = the_line.gsub(",","").numeric_values()[:byte]
end
if the_line.include?("Available Physical Memory")
data[:mem_free] = the_line.gsub(",","").numeric_values()[:byte]
end
if the_line.include?("Virtual Memory: Max Size")
data[:vmem_limit] = the_line.gsub(",","").numeric_values()[:byte]
end
if the_line.include?("Virtual Memory: In Use")
data[:vmem_used] = the_line.gsub(",","").numeric_values()[:byte]
end
if the_line.include?("Virtual Memory: Available")
data[:vmem_free] = the_line.gsub(",","").numeric_values()[:byte]
end
end
result[:actual] = {:total => data[:mem_limit].to_i, :used => (data[:mem_limit].to_i - data[:mem_free].to_i), :free => data[:mem_free].to_i, :shared => 0, :buffers => 0, :cached => 0}
result[:buffers] = {:used => 0, :free => 0}
result[:virtual] = {:total => data[:vmem_limit].to_i, :used => data[:vmem_used].to_i, :free => data[:vmem_free].to_i}
when :bsd, :darwin, :macos
# Inspired by: http://www.cyberciti.biz/faq/freebsd-command-to-get-ram-information/ by Ralf S. Engelschall
# ported to Ruby:
env = self.environment()
case env[:environment]
when :freebsd, :dragonfly, :pcbsd
# TODO: GxG::SYSTEM.memory() : test under freebsd, dragonfly and pcbsd
page_size = (`sysctl hw.pagesize`.to_s.split(":")[1].numeric_values()[:integer] || 0)
mem_phys = (`sysctl hw.physmem`.to_s.split(":")[1].numeric_values()[:integer] || 0) * page_size
mem_all = (`sysctl vm.stats.vm.v_page_count`.to_s.split(":")[1].numeric_values()[:integer] || 0) * page_size
mem_wire = (`sysctl vm.stats.vm.v_wire_count`.to_s.split(":")[1].numeric_values()[:integer] || 0) * page_size
mem_active = (`sysctl vm.stats.vm.v_active_count`.to_s.split(":")[1].numeric_values()[:integer] || 0) * page_size
mem_inactive = (`sysctl vm.stats.vm.v_inactive_count`.to_s.split(":")[1].numeric_values()[:integer] || 0) * page_size
mem_cache = (`sysctl vm.stats.vm.v_cache_count`.to_s.split(":")[1].numeric_values()[:integer] || 0) * page_size
mem_free = (`sysctl vm.stats.vm.v_free_count`.to_s.split(":")[1].numeric_values()[:integer] || 0) * page_size
mem_vm_total = (`sysctl vm.swap_total`.to_s.split(":")[1].numeric_values()[:integer] || 0)
mem_vm_used = (`pstat -s`.to_s.split(" ")[2].numeric_values()[:integer] || 0)
when :netbsd
# TODO: GxG::SYSTEM.memory() : test under netbsd
page_size = 0
mem_phys = 0
mem_all = 0
mem_wire = 0
mem_active = 0
mem_inactive = 0
mem_cache = 0
mem_free = 0
mem_vm_total = 0
mem_vm_used = 0
#
raw_data = `vmstat -s`
raw_data.to_enum(:each_line).each do |the_line|
if the_line.include?("bytes per page")
page_size = (the_line.split(" ")[0].to_s.numeric_values()[:integer] || 0)
break
end
end
if page_size > 0
raw_data.to_enum(:each_line).each do |the_line|
if the_line.include?("pages managed")
mem_phys = ((the_line.split(" ")[0].to_s.numeric_values()[:integer] || 0) * page_size)
mem_all = mem_phys
end
if the_line.include?("pages wired")
mem_wire = ((the_line.split(" ")[0].to_s.numeric_values()[:integer] || 0) * page_size)
end
if the_line.include?("pages active")
mem_active = ((the_line.split(" ")[0].to_s.numeric_values()[:integer] || 0) * page_size)
end
if the_line.include?("pages inactive")
mem_inactive = ((the_line.split(" ")[0].to_s.numeric_values()[:integer] || 0) * page_size)
end
if the_line.include?("pages free")
mem_free = ((the_line.split(" ")[0].to_s.numeric_values()[:integer] || 0) * page_size)
end
if the_line.include?("swap pages in use")
mem_vm_used = ((the_line.split(" ")[0].to_s.numeric_values()[:integer] || 0) * page_size)
end
if the_line.split(" ")[(1..-1)].join(" ") == "swap pages"
mem_vm_total = ((the_line.split(" ")[0].to_s.numeric_values()[:integer] || 0) * page_size)
end
end
end
when :darwin, :macos
# TODO: GxG::SYSTEM.memory() : test under darwin
raw_data = `top -l 1`
page_size = (`sysctl hw.pagesize`.to_s.split(":")[1].numeric_values()[:integer] || 0)
# gives a byte-count, not a page count : hw.physmem
mem_phys = (`sysctl hw.physmem`.to_s.split(":")[1].numeric_values()[:integer] || 0)
mem_all = mem_phys
# virtual memory usage:
raw_data = (`sysctl vm.swapusage`.to_s.split(":")[1].split(" "))
mem_vm_total = ((raw_data[5].to_s.numeric_values()[:float] || 0.0) * (1024**2)).to_i
mem_vm_used = ((raw_data[2].to_s.numeric_values()[:float] || 0.0) * (1024**2)).to_i
#SharedLibs: num = 146, resident = 22.9M code, 3.40M data, 8.36M LinkEdit
#MemRegions: num = 7213, resident = 344M + 4.92M private, 22.5M shared
#PhysMem: 59.1M wired, 285M active, 138M inactive, 483M used, 28.3M free
raw_data.to_enum(:each_line).each do |the_line|
if the_line.include?("PhysMem:")
data = the_line.split(":")[1].to_s.split(",")
data.to_enum(:each).each do |the_param|
numeric_string = the_param.split(" ")[0]
if numeric_string.include?(".")
numeric_string.gsub!("M","")
else
numeric_string.gsub!("M",".0")
end
case the_param.split(" ")[1]
when /wired/
mem_wire = ((numeric_string.numeric_values()[:float] || 0.0) * (1024**2)).to_i
when /active/
mem_active = ((numeric_string.numeric_values()[:float] || 0.0) * (1024**2)).to_i
when /inactive/
mem_inactive = ((numeric_string.numeric_values()[:float] || 0.0) * (1024**2)).to_i
when /free/
mem_free = ((numeric_string.numeric_values()[:float] || 0.0) * (1024**2)).to_i
end
end
break
end
end
else
# default BSD behavior ??? Seems like everyone does their own special thing.
end
#
chip_size = 1
chip_guess = ((mem_phys / 8) - 1)
while (chip_guess != 0)
chip_guess >>= 1
chip_size <<= 1
end
mem_hw = (((mem_phys / chip_size).to_i + 1) * chip_size)
#
mem_gap_vm = (mem_all - (mem_wire + mem_active + mem_inactive + mem_cache + mem_free))
mem_gap_sys = (mem_phys - mem_all)
mem_gap_hw = (mem_hw - mem_phys)
#
mem_available = (mem_inactive + mem_cache + mem_free)
mem_used = (mem_hw - mem_available)
# format result:
result[:actual] = {:total => mem_hw, :used => mem_used, :free => mem_available, :shared => 0, :buffers => 0, :cached => 0}
result[:buffers] = {:used => 0, :free => 0}
result[:virtual] = {:total => mem_vm_total, :used => mem_vm_used, :free => (mem_vm_total - mem_vm_used)}
#
when :linux, :solaris
# total used free shared buffers cached
raw_text = `free -b`
raw_text.to_enum(:each_line).each do |text_line|
if text_line.include?("Mem:")
stats = text_line.split(" ")
result[:actual] = {:total => stats[1].to_i, :used => stats[2].to_i, :free => stats[3].to_i, :shared => stats[4].to_i, :buffers => stats[5].to_i, :cached => stats[6].to_i}
end
if text_line.include?("-/+ buffers/cache:")
stats = text_line.split(" ")
result[:buffers] = {:used => stats[2].to_i, :free => stats[3].to_i}
end
if text_line.include?("Swap:")
stats = text_line.split(" ")
result[:virtual] = {:total => stats[1].to_i, :used => stats[2].to_i, :free => stats[3].to_i}
end
end
end
result.process! do |entry,selector,container|
if entry.is_a?(::String)
item = entry.numeric_values()
if item.is_a?(::Hash)
if item[:integer]
container[(selector)] = item[:integer].to_i
end
if item[:float]
container[(selector)] = item[:float].to_f
end
end
if item.is_a?(::Array)
item.each do |the_data|
if the_data.is_a?(::Hash)
if the_data[:integer]
container[(selector)] = the_data[:integer].to_i
end
if the_data[:float]
container[(selector)] = the_data[:float].to_f
end
end
if the_data.is_a?(::Array)
data = the_data[0]
if data.is_a?(::Hash)
if data[:integer]
container[(selector)] = data[:integer].to_i
end
if data[:float]
container[(selector)] = data[:float].to_f
end
break
end
end
end
end
end
nil
end
result[:total] = {:total => (result[:actual][:total].to_i + result[:virtual][:total].to_i), :used => (result[:actual][:used].to_i + result[:virtual][:used].to_i), :free => (result[:actual][:free].to_i + result[:virtual][:free].to_i)}
result
end
#
def processes(params={})
results = []
columns = [:cmdline, :cwd, :environ, :exe, :fd, :root, :pid, :comm, :state, :ppid, :pgrp, :session, :tty_nr, :tpgid,
:flags, :minflt, :cminflt, :majflt, :cmajflt, :utime, :stime, :cutime, :cstime, :priority, :nice, :itrealvalue, :starttime,
:vsize, :rss, :rlim, :startcode, :endcode, :startstack, :kstkesp, :kstkeip, :signal, :blocked, :sigignore, :sigcatch, :wchan,
:nswap, :cnswap, :exit_signal, :processor, :rt_priority, :policy, :name, :uid, :euid, :gid, :egid, :pctcpu, :pctmem]
include_columns = []
if params[:columns].respond_to?(:each)
params[:columns].to_enum.each do |entry|
if columns.include?(entry.to_s.to_sym)
include_columns << entry.to_s.to_sym
end
end
else
include_columns = columns
end
params.delete(:columns)
#
search_for = {}
if params.respond_to?(:each_pair)
params.each_pair do |key,entry|
if columns.include?(key.to_s.to_sym)
search_for[(key.to_s.to_sym)] = entry
end
end
end
#
if (params[:pid])
raw_data = (Sys::ProcTable.ps(params[:pid]) || [])
else
raw_data = (Sys::ProcTable.ps() || [])
end
raw_data.to_enum.each do |entry|
new_entry = {}
process = true
if search_for.keys.size > 0
search_for.each_pair do |search_key,search_value|
unless (entry[(search_key)] == search_value)
process = false
end
end
end
if process
entry.each_pair do |key,item|
if include_columns.include?(key.to_s.to_sym)
new_entry[(key.to_sym)] = item
end
end
end
if new_entry.keys.size > 0
results << new_entry
end
end
#
results
end
#
def current_user()
::ENV["USER"]
end
#
def network_status()
# LATER: find out how to get the PID for AF_UNIX output of bsd-netstat -f unix
# goal: lsof given a path, find the PID associated
# lsof -Rt -t path (have to have read permissions)
# OK, I give up (F-U bsd guys for not having a PID field in netstat unix output :P )
# no unix socket info until I can figure a hooley-hoop set to jump through on this -- F'n Dorks!
data = []
local_data = []
case ::GxG::SYSTEM.platform()[:platform]
when :bsd
predata = []
raw_data = `netstat -an`
raw_data.to_enum(:each_line).each do |the_line|
["tcp4 ", "tcp6 ", "udp4 ", "udp6 "].to_enum(:each).each do |entry|
if the_line.include?(entry)
predata << the_line.split(" ")
break
end
end
#
end
predata.to_enum(:each).each do |the_entry|
new_entry = {}
addressing = nil
case the_entry[0].downcase
when "tcp4", "tcp"
addressing = {:family => ::Socket::AF_INET, :protocol => :tcp}
when "tcp6"
addressing = {:family => ::Socket::AF_INET6, :protocol => :tcp6}
when "udp4", "udp"
addressing = {:family => ::Socket::AF_INET, :protocol => :udp}
when "udp6"
addressing = {:family => ::Socket::AF_INET6, :protocol => :udp6}
end
if addressing
new_entry[:protocol] = addressing[:protocol]
if addressing[:family] == ::Socket::AF_INET6
chunks = the_entry[3].split(".")
unless chunks[1] == "*"
chunks[1] = chunks[1].to_i
end
else
if the_entry[3].include?("*")
chunks = the_entry[3].split(".")
if chunks[0] == "*"
chunks = ["0.0.0.0",(the_entry[3].split(".").last)]
else
chunks = [(the_entry[3].split(".")[0..3].join(".")),(the_entry[3].split(".")[4])]
end
unless chunks[1] == "*"
chunks[1] = chunks[1].to_i
end
else
chunks = [(the_entry[3].split(".")[0..3].join(".")),(the_entry[3].split(".")[4].to_i)]
end
end
# bug fix:
if chunks[1] == "*"
chunks[1] = 0
end
# ##
if addressing[:protocol] == :udp || addressing[:protocol] == :udp6
new_entry[:local_address] = Addrinfo.udp(chunks[0],chunks[1])
else
new_entry[:local_address] = Addrinfo.tcp(chunks[0],chunks[1])
end
#
if addressing[:family] == ::Socket::AF_INET6
chunks = the_entry[4].split(".")
unless chunks[1] == "*"
chunks[1] = chunks[1].to_i
end
else
if the_entry[4].include?("*")
chunks = the_entry[4].split(".")
if chunks[0] == "*"
chunks = ["0.0.0.0",(the_entry[4].split(".").last)]
else
chunks = [(the_entry[4].split(".")[0..3].join(".")),(the_entry[4].split(".")[4])]
end
unless chunks[1] == "*"
chunks[1] = chunks[1].to_i
end
else
chunks = [(the_entry[4].split(".")[0..3].join(".")),(the_entry[4].split(".")[4].to_i)]
end
end
# bug fix:
if chunks[1] == "*"
chunks[1] = 0
end
# ##
if addressing[:protocol] == :udp || addressing[:protocol] == :udp6
new_entry[:foreign_address] = Addrinfo.udp(chunks[0],chunks[1])
else
new_entry[:foreign_address] = Addrinfo.tcp(chunks[0],chunks[1])
end
#
if the_entry[5].to_s.size > 0
new_entry[:status] = the_entry[5].to_sym
else
new_entry[:status] = nil
end
#
data << new_entry
end
#
end
when :linux
predata = []
raw_data = `netstat -an`
raw_data.to_enum(:each_line).each do |the_line|
["tcp ", "tcp6 ", "udp ", "udp6 "].to_enum(:each).each do |entry|
if the_line.include?(entry)
predata << the_line.split(" ")
break
end
end
#
end
predata.to_enum(:each).each do |the_entry|
the_error = nil
new_entry = {}
addressing = nil
case the_entry[0].downcase
when "tcp"
addressing = {:family => ::Socket::AF_INET, :protocol => :tcp}
when "tcp6"
addressing = {:family => ::Socket::AF_INET6, :protocol => :tcp6}
when "udp"
addressing = {:family => ::Socket::AF_INET, :protocol => :udp}
when "udp6"
addressing = {:family => ::Socket::AF_INET6, :protocol => :udp6}
end
if addressing
new_entry[:protocol] = addressing[:protocol]
if addressing[:family] == ::Socket::AF_INET6
chunks = the_entry[3].split(":")
unless chunks[-1] == "*"
chunks[-1] = chunks[-1].to_i
end
chunks = [(chunks[0..-2]).join(":"),(chunks.last)]
else
# Odd bug work-around
addr = the_entry[3].split(":")[0]
port = the_entry[3].split(":")[1]
unless port == "*"
port = port.to_i
end
chunks = [(addr.split(":")[0]),(port)]
end
# bug fix:
if chunks[1] == "*"
chunks[1] = 0
end
#
begin
if addressing[:protocol] == :udp || addressing[:protocol] == :udp6
new_entry[:local_address] = Addrinfo.udp(chunks[0],chunks[1])
else
new_entry[:local_address] = Addrinfo.tcp(chunks[0],chunks[1])
end
rescue Exception => the_error
end
# ##
if addressing[:family] == ::Socket::AF_INET6
# IPV6
chunks = the_entry[4].split(":")
unless chunks[-1] == "*"
chunks[-1] = chunks[-1].to_i
end
chunks = [(chunks[0..-2]).join(":"),(chunks.last)]
else
# IPV4
# Odd bug work-around
addr = the_entry[4].split(":")[0]
port = the_entry[4].split(":")[1]
unless port == "*"
port = port.to_i
end
chunks = [(addr.split(":")[0]),(port)]
# puts "Got: #{chunks.inspect}"
end
# if chunks[1].is_a?(::String)
# if chunks[1].numeric_values(:integer)
# chunks[1] = chunks[1].numeric_values(:integer)[:integer]
# end
# end
# bug fix:
if chunks[1] == "*"
chunks[1] = 0
end
#
begin
if addressing[:protocol] == :udp || addressing[:protocol] == :udp6
new_entry[:foreign_address] = Addrinfo.udp(chunks[0],chunks[1])
else
new_entry[:foreign_address] = Addrinfo.tcp(chunks[0],chunks[1])
end
rescue Exception => the_error
end
# ##
if the_entry[5].to_s.size > 0
new_entry[:status] = the_entry[5].to_sym
else
new_entry[:status] = nil
end
#
unless the_error
data << new_entry
end
#
end
end
#
when :windows
predata = []
raw_data = `netstat /a`
raw_data.to_enum(:each_line).each do |the_line|
["TCP ", "UDP "].to_enum(:each).each do |entry|
if the_line.include?(entry)
item = the_line.split(" ")
if item[0] == "TCP"
# ["tcp6", "0", "0", "::1:631", ":::*", "LISTEN"]
if item[1].include?("[") && item[1].include?("]")
item = ["tcp6", "0", "0", item[1], item[2], (item[3] || "")]
else
item = ["tcp", "0", "0", item[1], item[2], (item[3] || "")]
end
end
if item[0] == "UDP"
# ["udp", "0", "0", "224.0.0.251:5353", "0.0.0.0:*"]
if item[1].include?("[") && item[1].include?("]")
item = ["udp6", "0", "0", item[1], item[2]]
else
item = ["udp", "0", "0", item[1], item[2]]
end
end
predata << item
break
end
end
#
end
predata.to_enum(:each).each do |the_entry|
the_error = nil
new_entry = {}
addressing = nil
case the_entry[0].downcase
when "tcp"
addressing = {:family => ::Socket::AF_INET, :protocol => :tcp}
when "tcp6"
addressing = {:family => ::Socket::AF_INET6, :protocol => :tcp6}
when "udp"
addressing = {:family => ::Socket::AF_INET, :protocol => :udp}
when "udp6"
addressing = {:family => ::Socket::AF_INET6, :protocol => :udp6}
end
if addressing
new_entry[:protocol] = addressing[:protocol]
if addressing[:family] == ::Socket::AF_INET6
chunks = the_entry[3].split(":")
unless chunks[-1] == "*"
chunks[-1] = chunks[-1].to_i
end
chunks = [(chunks[0..-2]).join(":"),(chunks.last)]
else
# Odd bug work-around
addr = the_entry[3].split(":")[0]
port = the_entry[3].split(":")[1]
unless port == "*"
port = port.to_i
end
chunks = [(addr.split(":")[0]),(port)]
end
# bug fix:
if chunks[1] == "*"
chunks[1] = 0
end
#
begin
if addressing[:protocol] == :udp || addressing[:protocol] == :udp6
new_entry[:local_address] = Addrinfo.udp(chunks[0],chunks[1])
else
new_entry[:local_address] = Addrinfo.tcp(chunks[0],chunks[1])
end
rescue Exception => the_error
end
# ##
if addressing[:family] == ::Socket::AF_INET6
# IPV6
chunks = the_entry[4].split(":")
unless chunks[-1] == "*"
chunks[-1] = chunks[-1].to_i
end
chunks = [(chunks[0..-2]).join(":"),(chunks.last)]
else
# IPV4
# Odd bug work-around
addr = the_entry[4].split(":")[0]
port = the_entry[4].split(":")[1]
unless port == "*"
port = port.to_i
end
chunks = [(addr.split(":")[0]),(port)]
# puts "Got: #{chunks.inspect}"
end
# if chunks[1].is_a?(::String)
# if chunks[1].numeric_values(:integer)
# chunks[1] = chunks[1].numeric_values(:integer)[:integer]
# end
# end
# bug fix:
if chunks[1] == "*"
chunks[1] = 0
end
#
begin
if addressing[:protocol] == :udp || addressing[:protocol] == :udp6
new_entry[:foreign_address] = Addrinfo.udp(chunks[0],chunks[1])
else
new_entry[:foreign_address] = Addrinfo.tcp(chunks[0],chunks[1])
end
rescue Exception => the_error
end
# ##
if the_entry[5].to_s.size > 0
new_entry[:status] = the_entry[5].to_sym
else
new_entry[:status] = nil
end
#
unless the_error
data << new_entry
end
#
end
end
end
{:internet => data, :local => local_data}
end
#
def network_port_used?(the_port=0, the_address="0.0.0.0")
if the_port.is_a?(::Addrinfo)
the_address = the_port.ip_address()
the_port = the_port.ip_port()
end
if the_address == "*" || the_address == nil
the_address = "0.0.0.0"
end
unless the_address.is_a?(::String)
raise ArgumentError, "address needs to be specified as a String, you provided #{the_address.class}"
end
if the_port == "*" || the_port == nil
the_port = 0
else
if the_port.is_any?(::String, ::Numeric)
the_port = the_port.to_i
else
raise ArgumentError, "port needs to be specified by an Integer or a String of an Integer or asterisk character, you provided #{the_port.class}"
end
end
current = {:internet => [], :local => []}
if the_port == 0
found = true
else
found = false
current = self.network_status()
end
#
unless found
current[:internet].to_enum(:each).each do |entry|
if ((entry[:local_address].ip_address() == the_address && entry[:local_address].ip_port() == the_port) || (entry[:foreign_address].ip_address() == the_address && entry[:foreign_address].ip_port() == the_port))
found = true
break
end
end
end
unless found
current[:local].to_enum(:each).each do |entry|
# pending further Research and hefty work-arounds within self.network_status().
end
end
#
found
end
#
def network_next_port(the_address="0.0.0.0", honor_conventions=true)
# finds next available port on given interface, by default respecting common port usage conventions.
if the_address.is_a?(::Addrinfo)
the_address = the_address.ip_address()
end
if the_address == "*" || the_address == nil
the_address = "0.0.0.0"
end
unless the_address.is_a?(::String)
raise ArgumentError, "address needs to be specified as a String, you provided #{the_address.class}"
end
#
if honor_conventions
commonly_available = (49152..65535)
else
commonly_available = (1..65535)
end
#
found = nil
currently_used_ports = []
current = self.network_status()
current[:internet].to_enum(:each).each do |entry|
if entry[:local_address].ip_address() == the_address
currently_used_ports << entry[:local_address].ip_port()
end
if entry[:foreign_address].ip_address() == the_address
currently_used_ports << entry[:foreign_address].ip_port()
end
end
#
commonly_available.to_enum(:each).each do |the_port|
unless currently_used_ports.include?(the_port)
found = the_port
break
end
end
#
found
end
# ## Services general port usage reference data
def service_ports()
@details[:service_ports]
end
#
def service_ports_register_alias(service,alias_name)
result = false
if @details[:service_ports][(service.to_sym)]
if alias_name.to_s.size > 0
unless @details[:service_ports][(service.to_sym)][:aliases].include?(alias_name.to_s)
@details[:service_ports][(service.to_sym)][:aliases] << alias_name.to_s
result = true
end
end
end
result
end
#
def service_ports_remove_alias(service,alias_name)
result = false
if @details[:service_ports][(service.to_sym)]
if @details[:service_ports][(service.to_sym)][:aliases].include?(alias_name.to_s)
position = @details[:service_ports][(service.to_sym)][:aliases].index(alias_name.to_s)
if position
@details[:service_ports][(service.to_sym)][:aliases].delete_at(position)
result = true
end
end
end
result
end
#
def service_ports_register_client(service,client_scheme)
result = false
if @details[:service_ports][(service.to_sym)]
if client_scheme.to_s.size > 0
unless @details[:service_ports][(service.to_sym)][:clients].include?(client_scheme)
@details[:service_ports][(service.to_sym)][:clients] << client_scheme.to_s
result = true
end
end
end
result
end
#
def service_ports_remove_client(service,client_scheme)
result = false
if @details[:service_ports][(service.to_sym)]
if @details[:service_ports][(service.to_sym)][:clients].include?(client_scheme.to_s)
position = @details[:service_ports][(service.to_sym)][:clients].index(client_scheme.to_s)
if position
@details[:service_ports][(service.to_sym)][:clients].delete_at(position)
result = true
end
end
end
result
end
#
def service_ports_usage_preference(service,preference=nil)
result = false
if @details[:service_ports][(service.to_sym)]
if preference
if [:tcp, :udp, :icmp, :snmp].include?(preference)
if @details[:service_ports][(service.to_sym)][:uses][(preference)]
@details[:service_ports][(service.to_sym)][:uses_preference] = preference
result = true
end
end
else
@details[:service_ports][(service.to_sym)].delete(:uses_preference)
result = true
end
end
result
end
#
def service_ports_register_usage(service,the_protocol,the_entry_port)
# the_entry_port can be an Integer or a Range
result = false
if @details[:service_ports][(service.to_sym)]
if @details[:service_ports][(service)][:uses].keys.include?(the_protocol)
included = false
@details[:service_ports][(service)][:uses][(the_protocol)].to_enum(:each).each do |the_result_port|
if the_entry_port.is_a?(::Range)
if the_result_port.is_a?(::Range)
if (the_result_port.include?(the_entry_port.first) && the_result_port.include?(the_entry_port.last))
included = true
break
end
else
if the_entry_port.include?(the_result_port)
included = true
break
end
end
else
if the_result_port.is_a?(::Range)
if the_result_port.include?(the_entry_port)
included = true
break
end
else
if the_result_port == the_entry_port
included = true
break
end
end
end
end
unless included
@details[:service_ports][(service)][:uses][(the_protocol)] << the_entry_port
end
else
@details[:service_ports][(service)][:uses][(the_protocol)] = the_entry_port
end
result = true
#
end
result
end
#
def service_ports_register(service, entry={})
unless service.to_s.size > 0
raise ArgumentError, "you must specify a service symbol (i.e. :www ...), you provided #{service.inspect}"
end
unless service.is_a?(::Symbol)
service = service.to_s.to_sym
end
unless entry.is_a?(::Hash)
entry = {}
end
unless entry[:aliases].is_a?(::Array)
entry[:aliases] = []
end
unless entry[:clients].is_a?(::Array)
entry[:clients] = []
end
unless entry[:description].is_a?(::String)
entry[:description] = ""
end
unless entry[:uses].is_a?(::Hash)
entry[:uses] = {}
end
result = false
#
if @details[:service_ports][(service)]
entry[:aliases].to_enum(:each).each do |the_alias|
unless @details[:service_ports][(service)][:aliases].include?(the_alias)
@details[:service_ports][(service)][:aliases] << the_alias.to_s
end
end
entry[:clients].to_enum(:each).each do |the_client|
unless @details[:service_ports][(service)][:clients].include?(the_client.to_s)
@details[:service_ports][(service)][:clients] << the_client.to_s
end
end
entry[:uses].keys.to_enum(:each).each do |the_protocol|
if @details[:service_ports][(service)][:uses].keys.include?(the_protocol)
entry[:uses][(the_protocol)].to_enum(:each).each do |the_entry_port|
included = false
@details[:service_ports][(service)][:uses][(the_protocol)].each do |the_result_port|
if the_entry_port.is_a?(::Range)
if the_result_port.is_a?(::Range)
if (the_result_port.include?(the_entry_port.first) && the_result_port.include?(the_entry_port.last))
included = true
break
end
else
if the_entry_port.include?(the_result_port)
included = true
break
end
end
else
if the_result_port.is_a?(::Range)
if the_result_port.include?(the_entry_port)
included = true
break
end
else
if the_result_port == the_entry_port
included = true
break
end
end
end
end
unless included
@details[:service_ports][(service)][:uses][(the_protocol)] << the_entry_port
end
end
else
@details[:service_ports][(service)][:uses][(the_protocol)] = entry[:uses][(the_protocol)]
end
#
end
#
else
@details[:service_ports][(service.to_sym)] = entry
result = true
end
#
result
end
#
def service_ports_search(criteria={})
# search by client-scheme, and/or protocol and port-number/range.
result = {}
#
@details[:service_ports].keys.to_enum(:each).each do |service|
if (criteria[:scheme].to_s.to_sym == service || (@details[:service_ports][(service)][:aliases].include?(criteria[:scheme].to_s)) || (@details[:service_ports][(service)][:clients].include?(criteria[:scheme].to_s)))
result[(service)] = @details[:service_ports][(service)].clone
end
unless result[(service)]
the_protocol = criteria[:protocol]
the_entry_port = criteria[:port]
if (the_entry_port.is_any?(::Numeric, ::Range) && [:tcp, :udp, :icmp, :snmp].include?(the_protocol))
if @details[:service_ports][(service)][:uses][(the_protocol)].is_a?(::Array)
included = false
@details[:service_ports][(service)][:uses][(the_protocol)].to_enum(:each).each do |the_result_port|
if the_entry_port.is_a?(::Range)
if the_result_port.is_a?(::Range)
if (the_result_port.include?(the_entry_port.first) && the_result_port.include?(the_entry_port.last))
included = true
break
end
else
if the_entry_port.include?(the_result_port)
included = true
break
end
end
else
if the_result_port.is_a?(::Range)
if the_result_port.include?(the_entry_port)
included = true
break
end
else
if the_result_port == the_entry_port
included = true
break
end
end
end
end
if included
result[(service)] = @details[:service_ports][(service)].clone
end
#
end
end
end
end
#
result
end
#
end
#
class RemoteSystem
#
end
#
end # end-GxG::Entity
end
module GxG
# setup constants, dispose of BOOTSTRAP data.
if const_defined?(:BOOTSTRAP)
SYSTEM = GxG::Entity::LocalSystem.new(BOOTSTRAP)
SYSTEM.freeze
remove_const(:BOOTSTRAP)
end
end
#
Reference in a new issue View git blame Copy permalink