nmap-parser 0.3

data/BUGS

@@ -0,0 +1,2 @@
+If you find any bugs, please report them to me: katterjohn@gmail.com
+

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2007, 2008 Kris Katterjohn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+

data/README

@@ -0,0 +1,43 @@
+===============================================================================
+== Ruby Nmap::Parser                         http://rubynmap.sourceforge.net ==
+== Kris Katterjohn                                      katterjohn@gmail.com ==
+===============================================================================
+
+$Id: README 70 2008-04-22 23:13:01Z kjak $
+
+
+OVERVIEW
+========
+
+This library provides a Ruby interface to Nmap's scan data.  It can run Nmap
+and parse it's XML output directly from the scan, parse a file containing the
+XML data from a separate scan, parse a String of XML data from a scan, or parse
+XML data from an object via its read() method.  This information is presented
+in an easy-to-use and intuitive fashion for storing and manipulating.
+
+
+REQUIREMENTS and RECOMMENDATIONS
+================================
+
+Things Required:
+
+- Nmap (http://nmap.org) [Only required for parsescan()]
+
+- REXML Ruby Library [In standard library with Ruby >= 1.8]
+
+Things Recommended:
+
+- Open3 Ruby Library [In standard library]
+
+
+HELP
+====
+
+The website has detailed RDoc documentation available.  You can create a quick
+set of these docs yourself by issuing the following command from the base
+directory:
+
+$ rdoc lib
+
+A "doc" directory will be created.  Just point your browser to doc/index.html
+

data/lib/nmap/parser.rb

@@ -0,0 +1,1602 @@
+# Ruby library for parsing Nmap's XML output
+#
+# http://rubynmap.sourceforge.net
+#
+# Author: Kris Katterjohn <katterjohn@gmail.com>
+#
+# Copyright (c) 2007, 2008 Kris Katterjohn
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+# $Id: parser.rb 77 2008-04-24 22:19:29Z kjak $
+# https://rubynmap.svn.sourceforge.net/svnroot/rubynmap
+
+require 'rexml/document'
+
+begin
+	require 'open3'
+rescue LoadError
+	# We'll resort to IO.popen()
+end
+
+# Just holds the big Parser class.
+module Nmap
+end
+
+=begin rdoc
+
+== What Is This Library For?
+
+This library provides a Ruby interface to Nmap's scan data.  It can run Nmap
+and parse it's XML output directly from the scan, parse a file containing the
+XML data from a separate scan, parse a String of XML data from a scan, or parse
+XML data from an object via its read() method.  This information is presented
+in an easy-to-use and intuitive fashion for storing and manipulating.
+
+The Nmap Security Scanner is a great program written and maintained by
+Fyodor <fyodor@insecure.org>.  Its main function is port scanning, but it also
+has service and operating system detection, it's own scripting engine and a
+whole lot more.  One of it's many available output formats is XML, which allows
+machines to handle all of the information instead of us slowly sifting through
+tons of output!
+
+If you've ever used Anthony Persaud's Perl Nmap::Parser, you'll notice some
+similarities and should pick up on this API quickly.  Just remember, it's far
+from exactly the same!  There are more classes, many different methods, and
+blocks are used extensively (or available for use).
+
+== Conventions
+
+Depending on the data type, unavailable information is presented differently:
+
+  - Arrays are empty
+  - Non-arrays are nil, unless it's a method that returns the size of one of
+    the previously mentioned empty arrays.  In this case they still return the
+    size (which would be 0).
+
+All information available as arrays are presented via methods.  These methods
+not only return the array, but they also yield each element to a block if one
+is given.
+
+== Module Hierarchy
+
+  Nmap::Parser
+  |
+  + ::Session             <- Scan session information
+  |
+  + ::Host                <- General host information
+     |
+     + ::ExtraPorts       <- Ports consolidated in an "ignored" state
+     |
+     + ::Port             <- General port information
+     |  |
+     |  + ::Service       <- Port Service information
+     |
+     + ::Script           <- NSE Script information (both host and port)
+     |
+     + ::Times            <- Timimg information (srtt, etc)
+     |
+     + ::Traceroute       <- General Traceroute information
+     |  |
+     |  + ::Hop           <- Individual Hop information
+     |
+     + ::OS               <- OS Detection information
+        |
+        + ::OSClass       <- OS Class information
+        |
+        + ::OSMatch       <- OS Match information
+
+== Parsing XML Data Already Available
+
+	require 'nmap/parser'
+
+	parser = Nmap::Parser.new(xml) # String of XML data
+
+== Reading and Parsing from a File
+
+	require 'nmap/parser'
+
+	parser = Nmap::Parser.parsefile("log.xml")
+
+== Reading and Parsing from an Object
+
+The parseread() function isn't limited to IO objects like $stdin is
+in the example: it can read from any object that responds to a read()
+method that returns a String.
+
+	require 'nmap/parser'
+
+	parser = Nmap::Parser.parseread($stdin)
+
+== Scanning and Parsing
+
+This is the only parser option that requires Nmap to be available
+
+	require 'nmap/parser'
+
+	parser = Nmap::Parser.parsescan("sudo nmap", "--script all 192.168.1.0/24")
+
+== Actually Doing Something
+
+After printing a little session information, this example will cycle
+through all of the up hosts, printing service information on the
+open TCP ports, along with the name and output of any scripts that
+ran (on the host and individual ports).
+
+	puts "Nmap args: #{parser.session.scan_args}"
+
+	puts "Runtime: #{parser.session.scan_time} seconds"
+
+	puts
+
+	parser.hosts("up") do |host|
+		puts "** Host #{host.addr} is up **"
+		puts
+
+		host.tcp_ports("open") do |port|
+			srv = port.service
+
+			puts "Port ##{port.num} is open (#{port.reason})"
+			puts "\tService: #{srv.name}" if srv.name
+			puts "\tProduct: #{srv.product}" if srv.product
+			puts "\tVersion: #{srv.product}" if srv.version
+			puts
+
+			port.scripts do |script|
+				puts "\tScript Name: #{script.id}"
+				puts "\tScript Output: #{script.output}"
+				puts
+			end
+		end
+
+		if host.scripts.any?
+			puts "Host Scripts Run:"
+			puts
+
+			host.scripts do |script|
+				puts "\tScript Name: #{script.id}"
+				puts "\tScript Output: #{script.output}"
+				puts
+			end
+		end
+
+		puts
+	end
+
+=end
+class Nmap::Parser
+	# Holds the raw XML output from Nmap
+	attr_reader :rawxml
+	# ::Session object for this scan
+	attr_reader :session
+
+	# Read and parse XML from the +obj+.  +obj+ can be any object type
+	# that responds to a read() method that returns a String.  IO and
+	# File are just a couple of examples.
+	#
+	# Returns a new Nmap::Parser object, and passes it to a block if
+	# one is given
+	def self.parseread(obj) # :yields: parser
+		if not obj.respond_to?("read")
+			raise "Object must respond to read()"
+		end
+
+		r = obj.read
+
+		raise "read() returned #{r.class} type!" if not r.is_a?String
+
+		p = new(r)
+
+		yield p if block_given?
+
+		p
+	end
+
+	# Read and parse contents of the Nmap XML file +filename+
+	#
+	# Returns a new Nmap::Parser object, and passes it to a block if
+	# one is given
+	def self.parsefile(filename) # :yields: parser
+		begin
+			p = parseread(File.open(filename))
+		rescue
+			raise "Error parsing \"#{filename}\": #{$!}"
+		end
+
+		yield p if block_given?
+
+		p
+	end
+
+	# Runs "+nmap+ -d +args+ +targets+"; returns a new Nmap::Parser object,
+	# and passes it to a block if one is given.
+	#
+	# +nmap+ is here to allow you to do things like:
+	#
+	# parser = Nmap::Parser.parsescan("sudo ./nmap", ....)
+	#
+	# and still make it easy for me to inject the options for XML
+	# output and debugging.
+	#
+	# +args+ can't contain arguments like -oA, -oX, etc. as these can
+	# interfere with Parser's processing.  If you need that other output,
+	# just run Nmap yourself and pass -oX output to Parser via new.  Or,
+	# you can use rawxml to grab the whole XML (as a String) and save it
+	# to a different file.
+	#
+	# +targets+ is an array of targets which will be split and appended to
+	# the command.  It's optional and only for convenience because you can
+	# put any targets you want scanned in +args+.
+	def self.parsescan(nmap, args, targets = []) # :yields: parser
+		if args =~ /[^-]-o|^-o/
+			raise "Output option (-o*) passed to parsescan()"
+		end
+
+		# Enable debugging, give us our XML output, pass args
+		command = nmap + " -d -oX - " + args + " "
+
+		command += targets.join(" ") if targets.any?
+
+		p = nil
+
+		begin
+			# First try popen3() if it loaded successfully..
+			Open3.popen3(command) do |sin, sout, serr|
+				p = parseread(sout)
+			end
+		rescue NameError
+			# ..but fall back to popen() if not
+			IO.popen(command) do |io|
+				p = parseread(io)
+			end
+		end
+
+		yield p if block_given?
+
+		p
+	end
+
+	# Returns an array of Host objects, and passes them each to a block if
+	# one is given
+	#
+	# If an argument is given, only hosts matching +status+ are given
+	def hosts(status = "") # :yields: host
+		shosts = []
+
+		@hosts.each do |host|
+			if status.empty? or host.status == status
+				shosts << host
+				yield host if block_given?
+			end
+		end
+
+		shosts
+	end
+
+	# Returns a Host object for the host with the specified IP address
+	# or hostname +hostip+
+	def host(hostip)
+		@hosts.find do |host|
+			host.addr == hostip or host.hostname == hostip
+		end
+	end
+
+	alias get_host host
+
+	# Deletes host with the specified IP address or hostname +hostip+
+	#
+	# Note: From inside of a block given to a method like hosts() or
+	# get_ips(), calling this method on a host passed to the block may
+	# lead to adverse effects:
+	#
+	# parser.hosts { |x| puts x.addr; del_host(x) } # Don't do this!
+	def del_host(hostip)
+		@hosts.delete_if do |host|
+			host.addr == hostip or host.hostname == hostip
+		end
+	end
+
+	alias delete_host del_host
+
+	# Returns an array of IPs scanned, and passes them each to a
+	# block if one is given
+	#
+	# If an argument is given, only hosts matching +status+ are given
+	def get_ips(status = "") # :yields: host.addr
+		ips = []
+
+		@hosts.each do |host|
+			if status.empty? or host.status == status
+				ips << host.addr
+				yield host.addr if block_given?
+			end
+		end
+
+		ips
+	end
+
+	# This operator compares the rawxml members
+	def ==(parser)
+		@rawxml == parser.rawxml
+	end
+
+	private
+
+	def initialize(xml) # :yields: parser
+		if not xml.is_a?String
+			raise "Invalid input: new() should be passed a String"
+		end
+
+		parse(xml)
+
+		yield self if block_given?
+	end
+
+	def parse(xml)
+		@rawxml = xml
+
+		begin
+			root = REXML::Document.new(xml).root
+		rescue
+			raise "Error parsing XML: #{$!}"
+		end
+
+		raise "Error in XML data" if root.nil?
+
+		@session = Session.new(root)
+
+		@hosts = []
+
+		root.each_element('host') do |host|
+			@hosts << Host.new(host)
+		end
+	end
+end
+
+# This holds session information, such as runtime, Nmap's arguments,
+# and verbosity/debugging
+class Nmap::Parser::Session
+	# Holds the command run to initiate the scan
+	attr_reader :scan_args
+	# The Nmap version number used to scan
+	attr_reader :nmap_version
+	# XML version of Nmap's output
+	attr_reader :xml_version
+	# Starting time
+	attr_reader :start_str, :start_time
+	# Ending time
+	attr_reader :stop_str, :stop_time
+	# How long the scan took (in seconds).  Same as stop_time - start_time
+	attr_reader :scan_time
+	# Amount of verbosity (-v) used while scanning
+	attr_reader :verbose
+	# Amount of debugging (-d) used while scanning
+	attr_reader :debug
+
+	alias verbosity verbose
+	alias debugging debug
+
+	# Returns the total number of services that were scanned or, if an
+	# argument is given, returns the number of services scanned for +type+
+	# (e.g. "syn")
+	def numservices(type = "")
+		total = 0
+
+		@scaninfo.each do |info|
+			if type.empty?
+				total += info.numservices
+			elsif info.type == type
+				return info.numservices
+			end
+		end
+
+		total
+	end
+
+	# Returns the protocol associated with the specified scan +type+
+	# (e.g. "tcp" for type "syn")
+	def scan_type_proto(type)
+		@scaninfo.each do |info|
+			return info.proto if info.type == type
+		end
+
+		nil
+	end
+
+	# Returns an array of all the scan types performed, and passes them
+	# each to a block if one if given
+	def scan_types() # :yields: scantype
+		types = []
+
+		@scaninfo.each do |info|
+			types << info.type
+			yield info.type if block_given?
+		end
+
+		types
+	end
+
+	private
+
+	def initialize(root)
+		parse(root)
+	end
+
+	def parse(root)
+		@scan_args = root.attributes['args']
+
+		@nmap_version = root.attributes['version']
+
+		@xml_version = root.attributes['xmloutputversion'].to_f
+
+		@start_str = root.attributes['startstr']
+		@start_time = root.attributes['start'].to_i
+
+		@stop_str = root.elements['runstats/finished'].attributes['timestr']
+		@stop_time = root.elements['runstats/finished'].attributes['time'].to_i
+
+		@scan_time = @stop_time - @start_time
+
+		@verbose = root.elements['verbose'].attributes['level'].to_i
+		@debug = root.elements['debugging'].attributes['level'].to_i
+
+		@scaninfo = []
+
+		root.each_element('scaninfo') do |info|
+			@scaninfo << ScanInfo.new(info)
+		end
+	end
+end
+
+class Nmap::Parser::Session::ScanInfo # :nodoc: all
+	attr_reader :type, :proto, :numservices
+
+	private
+
+	def initialize(info)
+		parse(info)
+	end
+
+	def parse(info)
+		@type = info.attributes['type']
+		@proto = info.attributes['protocol']
+		@numservices = info.attributes['numservices'].to_i
+	end
+end
+
+# This holds all of the information about a target host.
+#
+# Status, IP/MAC addresses, hostnames, all that.  Port information is
+# available in this class; either accessed through here or directly
+# from a Port object.
+class Nmap::Parser::Host
+	# The status of the host, typically "up" or "down"
+	attr_reader :status
+	# The reason for the status
+	attr_reader :reason
+	# The IPv4 address
+	attr_reader :ip4_addr
+	# The IPv6 address
+	attr_reader :ip6_addr
+	# The MAC address
+	attr_reader :mac_addr
+	# The MAC vendor
+	attr_reader :mac_vendor
+	# ::OS object holding Operating System information
+	attr_reader :os
+	# The number of "weird responses"
+	attr_reader :smurf
+	# TCP Sequence Number information
+	attr_reader :tcpsequence_index, :tcpsequence_class
+	# TCP Sequence Number information
+	attr_reader :tcpsequence_values, :tcpsequence_difficulty
+	# IPID Sequence Number information
+	attr_reader :ipidsequence_class, :ipidsequence_values
+	# TCP Timestamp Sequence Number information
+	attr_reader :tcptssequence_class, :tcptssequence_values
+	# Uptime information
+	attr_reader :uptime_seconds, :uptime_lastboot
+	# ::Traceroute object
+	attr_reader :traceroute
+	# Network distance (not necessarily the same as from traceroute)
+	attr_reader :distance
+	# ::Times object holding timing information
+	attr_reader :times
+
+	alias ipv4_addr ip4_addr
+	alias ipv6_addr ip6_addr
+
+	# Returns the IPv4 or IPv6 address of host
+	def addr
+		@ip4_addr or @ip6_addr
+	end
+
+	# Returns an array containing all of the hostnames for this host,
+	# and passes them each to a block if one is given
+	def all_hostnames
+		if block_given?
+			@hostnames.each do |hostname|
+				yield hostname
+			end
+		end
+
+		@hostnames
+	end
+
+	alias hostnames all_hostnames
+
+	# Returns the first hostname, or nil if unavailable
+	def hostname
+		@hostnames[0]
+	end
+
+	# Returns an array of ExtraPorts objects, and passes them each to a
+	# block if one if given
+	def extraports
+		if block_given?
+			@extraports.each do |extraports|
+				yield extraports
+			end
+		end
+
+		@extraports
+	end
+
+	# Returns the Port object for the TCP port +portnum+, and passes it to
+	# a block if one is given
+	def tcp_port(portnum) # :yields: port
+		yield @tcpPorts[portnum.to_s] if block_given?
+
+		@tcpPorts[portnum.to_s]
+	end
+
+	# Returns an array of Port objects for each TCP port, and passes them
+	# each to a block if one is given
+	#
+	# If an argument is given, only ports matching +state+ are given.
+	# Note:  "open" will also match "open|filtered", but not vice versa.
+	def tcp_ports(state = "")
+		list = []
+
+		@tcpPorts.invert.each_key do |port|
+			list << port if state.empty? or port.state >= state
+		end
+
+		list.sort!
+
+		if block_given?
+			list.each do |port|
+				yield port
+			end
+		end
+
+		list
+	end
+
+	# Returns an array of TCP port numbers, and passes them each to a block
+	# if one given
+	#
+	# If an argument is given, only ports matching +state+ are given.
+	# Note:  "open" will also match "open|filtered", but not vice versa.
+	def tcp_port_list(state = "")
+		list = []
+
+		@tcpPorts.invert.each_key do |port|
+			list << port.num if state.empty? or port.state >= state
+		end
+
+		list.sort!
+
+		if block_given?
+			list.each do |port|
+				yield port
+			end
+		end
+
+		list
+	end
+
+	# Returns state reason of TCP port +portnum+
+	def tcp_reason(portnum)
+		return nil if @tcpPorts[portnum.to_s].nil?
+
+		@tcpPorts[portnum.to_s].reason
+	end
+
+	# Returns the Script object for the script +name+ run against the
+	# TCP port +portnum+
+	def tcp_script(portnum, name)
+		return nil if @tcpPorts[portnum.to_s].nil?
+
+		@tcpPorts[portnum.to_s].script(name)
+	end
+
+	# Returns an array of Script objects for each script run on the
+	# TCP port +portnum+, and passes them each to a block if given
+	def tcp_scripts(portnum)
+		return nil if @tcpPorts[portnum.to_s].nil?
+
+		if block_given?
+			@tcpPorts[portnum.to_s].scripts do |script|
+				yield script
+			end
+		end
+
+		@tcpPorts[portnum.to_s].scripts
+	end
+
+	# Returns the output of the script +name+ on the TCP port +portnum+
+	def tcp_script_output(portnum, name)
+		return nil if @tcpPorts[portnum.to_s].nil?
+
+		@tcpPorts[portnum.to_s].script_output(name)
+	end
+
+	# Returns a Port::Service object for TCP port +portnum+
+	def tcp_service(portnum)
+		return nil if @tcpPorts[portnum.to_s].nil?
+
+		@tcpPorts[portnum.to_s].service
+	end
+
+	# Returns state of TCP port +portnum+
+	def tcp_state(portnum)
+		return nil if @tcpPorts[portnum.to_s].nil?
+
+		@tcpPorts[portnum.to_s].state
+	end
+
+	# Returns the Port object for the UDP port +portnum+, and passes it to
+	# a block if one is given
+	def udp_port(portnum) # :yields: port
+		yield @udpPorts[portnum.to_s] if block_given?
+
+		@udpPorts[portnum.to_s]
+	end
+
+	# Returns an array of Port objects for each UDP port, and passes them
+	# each to a block if one is given
+	#
+	# If an argument is given, only ports matching +state+ are given.
+	# Note:  "open" will also match "open|filtered", but not vice versa.
+	def udp_ports(state = "")
+		list = []
+
+		@udpPorts.invert.each_key do |port|
+			list << port if state.empty? or port.state >= state
+		end
+
+		list.sort!
+
+		if block_given?
+			list.each do |port|
+				yield port
+			end
+		end
+
+		list
+	end
+
+	# Returns an array of UDP port numbers, and passes them each to a block
+	# if one is given
+	#
+	# If an argument is given, only ports matching +state+ are given.
+	# Note:  "open" will also match "open|filtered", but not vice versa.
+	def udp_port_list(state = "")
+		list = []
+
+		@udpPorts.invert.each_key do |port|
+			list << port.num if state.empty? or port.state >= state
+		end
+
+		list.sort!
+
+		if block_given?
+			list.each do |port|
+				yield port
+			end
+		end
+
+		list
+	end
+
+	# Returns state reason of UDP port +portnum+
+	def udp_reason(portnum)
+		return nil if @udpPorts[portnum.to_s].nil?
+
+		@udpPorts[portnum.to_s].reason
+	end
+
+	# Returns the Script object for the script +name+ run against the
+	# UDP port +portnum+
+	def udp_script(portnum, name)
+		return nil if @udpPorts[portnum.to_s].nil?
+
+		@udpPorts[portnum.to_s].script(name)
+	end
+
+	# Returns an array of Script objects for each script run on the
+	# UDP port +portnum+, and passes them each to a block if given
+	def udp_scripts(portnum)
+		return nil if @udpPorts[portnum.to_s].nil?
+
+		if block_given?
+			@udpPorts[portnum.to_s].scripts do |script|
+				yield script
+			end
+		end
+
+		@udpPorts[portnum.to_s].scripts
+	end
+
+	# Returns the output of the script +name+ on the UDP port +portnum+
+	def udp_script_output(portnum, name)
+		return nil if @udpPorts[portnum.to_s].nil?
+
+		@udpPorts[portnum.to_s].script_output(name)
+	end
+
+	# Returns a Port::Service object for UDP port +portnum+
+	def udp_service(portnum)
+		return nil if @udpPorts[portnum.to_s].nil?
+
+		@udpPorts[portnum.to_s].service
+	end
+
+	# Returns state of UDP port +portnum+
+	def udp_state(portnum)
+		return nil if @udpPorts[portnum.to_s].nil?
+
+		@udpPorts[portnum.to_s].state
+	end
+
+	# Returns the Port object for the IP protocol +protonum+, and passes it
+	# to a block if one is given
+	def ip_proto(protonum) # :yields: proto
+		yield @ipProtos[protonum.to_s] if block_given?
+
+		@ipProtos[protonum.to_s]
+	end
+
+	# Returns an array of Port objects for each IP protocol, and passes
+	# them each to a block if one is given
+	#
+	# If an argument is given, only protocols matching +state+ are given.
+	# Note:  "open" will also match "open|filtered", but not vice versa.
+	def ip_protos(state = "")
+		list = []
+
+		@ipProtos.invert.each_key do |proto|
+			list << proto if state.empty? or proto.state >= state
+		end
+
+		list.sort!
+
+		if block_given?
+			list.each do |proto|
+				yield proto
+			end
+		end
+
+		list
+	end
+
+	# Returns an array of IP protocol numbers, and passes them each to a
+	# block if one given
+	#
+	# If an argument is given, only protocols matching +state+ are given.
+	# Note:  "open" will also match "open|filtered", but not vice versa.
+	def ip_proto_list(state = "")
+		list = []
+
+		@ipProtos.invert.each_key do |proto|
+			list << proto.num if state.empty? or proto.state >= state
+		end
+
+		list.sort!
+
+		if block_given?
+			list.each do |proto|
+				yield proto
+			end
+		end
+
+		list
+	end
+
+	# Returns state reason of IP protocol +protonum+
+	def ip_reason(protonum)
+		return nil if @ipProtos[protonum.to_s].nil?
+
+		@ipProtos[protonum.to_s].reason
+	end
+
+	# Returns a Port::Service object for IP protocol +protonum+
+	def ip_service(protonum)
+		return nil if @ipProtos[protonum.to_s].nil?
+
+		@ipProtos[protonum.to_s].service
+	end
+
+	# Returns state of IP protocol +protonum+
+	def ip_state(protonum)
+		return nil if @ipProtos[protonum.to_s].nil?
+
+		@ipProtos[protonum.to_s].state
+	end
+
+	# Returns the Script object for the specified host script +name+
+	def script(name)
+		@scripts.find do |script|
+			script.id == name
+		end
+	end
+
+	# Returns an array of Script objects for each host script run, and
+	# passes them each to a block if given
+	def scripts
+		if block_given?
+			@scripts.each do |script|
+				yield script
+			end
+		end
+
+		@scripts
+	end
+
+	# Returns the output of the specified host script +name+
+	def script_output(name)
+		@scripts.each do |script|
+			return script.output if script.id == name
+		end
+
+		nil
+	end
+
+	private
+
+	def initialize(hostinfo)
+		parse(hostinfo)
+	end
+
+	# Convert a string like '22-25,80,110-900' into
+	# an array with all the uncondensed elements, e.g.
+	# [ '22', '23', '24', '25, '80', '110', '111' ... ]
+	def parsePortlist(ports)
+		list = []
+
+		ports.split(",").each do |set|
+			pa = set.split("-")
+
+			if pa.length > 1
+				pa[0].upto(pa[1]) do |p|
+					list << p
+				end
+			else
+				list << portc
+			end
+		end
+
+		list
+	end
+
+	def parseAddr(elem)
+		case elem.attributes['addrtype']
+		when "mac"
+			@mac_addr = elem.attributes['addr']
+			@mac_vendor = elem.attributes['vendor']
+		when "ipv4"
+			@ip4_addr = elem.attributes['addr']
+		when "ipv6"
+			@ip6_addr = elem.attributes['addr']
+		end
+	end
+
+	def parseHostnames(elem)
+		@hostnames = []
+
+		return nil if elem.nil?
+
+		elem.each_element('hostname') do |name|
+			@hostnames << name.attributes['name']
+		end
+	end
+
+	def parsePorts(ports)
+		@tcpPorts = {}
+		@udpPorts = {}
+		@ipProtos = {}
+
+		return nil if ports.nil?
+
+		ports.each_element('port') do |port|
+			num = port.attributes['portid']
+			proto = port.attributes['protocol']
+
+			if proto == "tcp"
+				@tcpPorts[num] = Port.new(port)
+			elsif proto == "udp"
+				@udpPorts[num] = Port.new(port)
+			elsif proto == "ip"
+				@ipProtos[num] = Port.new(port)
+			end
+		end
+	end
+
+	def parseExtraPorts(ports)
+		@extraports = []
+
+		return nil if ports.nil?
+
+		ports.each_element('extraports') do |e|
+			@extraports << ExtraPorts.new(e)
+		end
+
+		@extraports.sort! do |x, y|
+			x.count <=> y.count
+		end
+	end
+
+	def parseScripts(scriptlist)
+		@scripts = []
+
+		return nil if scriptlist.nil?
+
+		scriptlist.each_element('script') do |script|
+			@scripts << Script.new(script)
+		end
+	end
+
+	def tcpseq(seq)
+		return nil if seq.nil?
+
+		@tcpsequence_index = seq.attributes['index']
+		@tcpsequence_class = seq.attributes['class']
+		@tcpsequence_values = seq.attributes['values']
+		@tcpsequence_difficulty = seq.attributes['difficulty']
+	end
+
+	def ipidseq(seq)
+		return nil if seq.nil?
+
+		@ipidsequence_class = seq.attributes['class']
+		@ipidsequence_values = seq.attributes['values']
+	end
+
+	def tcptsseq(seq)
+		return nil if seq.nil?
+
+		@tcptssequence_class = seq.attributes['class']
+		@tcptssequence_values = seq.attributes['values']
+	end
+
+	def uptime(time)
+		return nil if time.nil?
+
+		@uptime_seconds = time.attributes['seconds'].to_i
+		@uptime_lastboot = time.attributes['lastboot']
+	end
+
+	def parse(host)
+		status = host.elements['status']
+
+		@status = status.attributes['state']
+
+		@reason = status.attributes['reason']
+
+		@os = OS.new(host.elements['os'])
+
+		host.each_element('address') do |elem|
+			parseAddr(elem)
+		end
+
+		parseHostnames(host.elements['hostnames'])
+
+		smurf = host.elements['smurf']
+		@smurf = smurf.attributes['responses'] if smurf
+
+		ports = host.elements['ports']
+
+		parsePorts(ports)
+
+		parseExtraPorts(ports)
+
+		parseScripts(host.elements['hostscript'])
+
+		if trace = host.elements['trace']
+			@traceroute = Traceroute.new(trace)
+		end
+
+		tcpseq(host.elements['tcpsequence'])
+
+		ipidseq(host.elements['ipidsequence'])
+
+		tcptsseq(host.elements['tcptssequence'])
+
+		uptime(host.elements['uptime'])
+
+		distance = host.elements['distance']
+		@distance = distance.attributes['value'].to_i if distance
+
+		@times = Times.new(host.elements['times'])
+	end
+end
+
+# This holds information on the time statistics for this host
+class Nmap::Parser::Host::Times
+	# Smoothed round-trip time
+	attr_reader :srtt
+	# Round-trip time variance / deviation
+	attr_reader :rttvar
+	# How long before giving up on a probe (timeout)
+	attr_reader :to
+
+	private
+
+	def initialize(times)
+		parse(times)
+	end
+
+	def parse(times)
+		return nil if times.nil?
+
+		@srtt = times.attributes['srtt'].to_i
+		@rttvar = times.attributes['rttvar'].to_i
+		@to = times.attributes['to'].to_i
+	end
+end
+
+# This holds the information about an NSE script run against a host or port
+class Nmap::Parser::Host::Script
+	# NSE Script name
+	attr_reader :id
+	# NSE Script output
+	attr_reader :output
+
+	alias name id
+
+	private
+
+	def initialize(script)
+		parse(script)
+	end
+
+	def parse(script)
+		return nil if script.nil?
+
+		@id = script.attributes['id']
+		@output = script.attributes['output']
+	end
+end
+
+# This holds the information about an individual port or protocol
+class Nmap::Parser::Host::Port
+	# Port number
+	attr_reader :num
+	# ::Service object for this port
+	attr_reader :service
+	# Port state ("open", "closed", "filtered", etc)
+	attr_reader :state
+	# Why the port is in the state
+	attr_reader :reason
+	# The host that responded, if different than the target
+	attr_reader :reason_ip
+	# TTL from the responding host
+	attr_reader :reason_ttl
+
+	# Returns the Script object with the specified +name+
+	def script(name)
+		@scripts.find do |script|
+			script.id == name
+		end
+	end
+
+	# Returns an array of Script objects associated with this port, and
+	# passes them each to a block if one is given
+	def scripts
+		if block_given?
+			@scripts.each do |script|
+				yield script
+			end
+		end
+
+		@scripts
+	end
+
+	# Returns the output of the script +name+
+	def script_output(name)
+		@scripts.each do |script|
+			return script.output if script.id == name
+		end
+
+		nil
+	end
+
+	# Compares port numbers
+	def <=>(port)
+		@num <=> port.num
+	end
+
+	private
+
+	def initialize(portinfo)
+		parse(portinfo)
+	end
+
+	def parse(port)
+		@num = port.attributes['portid'].to_i
+
+		state = port.elements['state']
+		@state = state.attributes['state']
+		@reason = state.attributes['reason']
+		@reason_ttl = state.attributes['reason_ttl'].to_i
+		@reason_ip = state.attributes['reason_ip']
+
+		@service = Service.new(port)
+
+		@scripts = []
+
+		port.each_element('script') do |script|
+			@scripts << Nmap::Parser::Host::Script.new(script)
+		end
+	end
+end
+
+# This holds the information about "extra ports": groups of ports which have
+# the same state.
+class Nmap::Parser::Host::ExtraPorts
+	# Total number of ports in this state
+	attr_reader :count
+	# What state the ports are in
+	attr_reader :state
+
+	# Returns an array of arrays, each of which are in the form of:
+	#
+	# [ <port count>, reason ]
+	#
+	# for each set of reasons, and passes them each to a block if one is
+	# given
+	def reasons
+		if block_given?
+			@reasons.each do |reason|
+				yield reason
+			end
+		end
+
+		@reasons
+	end
+
+	private
+
+	def initialize(extraports)
+		parse(extraports)
+	end
+
+	def parse(extraports)
+		@count = extraports.attributes['count'].to_i
+		@state = extraports.attributes['state']
+
+		@reasons = []
+
+		extraports.each_element('extrareasons') do |extra|
+			ecount = extra.attributes['count'].to_i
+			ereason = extra.attributes['reason']
+			@reasons << [ ecount, ereason ]
+		end
+	end
+end
+
+# This holds information on a traceroute, such as the port and protocol used
+# and an array of responsive hops
+class Nmap::Parser::Host::Traceroute
+	# The port used during traceroute
+	attr_reader :port
+	# The protocol used during traceroute
+	attr_reader :proto
+
+	# Returns the Hop object for the given TTL
+	def hop(ttl)
+		@hops.find do |h|
+			h.ttl == ttl.to_i
+		end
+	end
+
+	# Returns an array of Hop objects, which are each a responsive hop,
+	# and passes them each to a block if one if given.
+	def hops
+		if block_given?
+			@hops.each do |h|
+				yield h
+			end
+		end
+
+		@hops
+	end
+
+	private
+
+	def initialize(trace)
+		parse(trace)
+	end
+
+	def parse(trace)
+		@port = trace.attributes['port'].to_i
+		@proto = trace.attributes['proto']
+
+		@hops = []
+
+		trace.each_element('hop') do |hop|
+			@hops << Hop.new(hop)
+		end
+	end
+end
+
+# This holds information on an individual traceroute hop
+class Nmap::Parser::Host::Traceroute::Hop
+	# How many hops away the host is
+	attr_reader :ttl
+	# The round-trip time of the host
+	attr_reader :rtt
+	# The IP address of the host
+	attr_reader :addr
+	# The hostname of the host
+	attr_reader :hostname
+
+	alias host hostname 
+	alias ipaddr addr
+
+	private
+
+	def initialize(hop)
+		parse(hop)
+	end
+
+	def parse(hop)
+		@ttl = hop.attributes['ttl'].to_i
+		@rtt = hop.attributes['rtt'].to_f
+		@addr = hop.attributes['ipaddr']
+		@hostname = hop.attributes['host']
+	end
+end
+
+# This holds the service information for a port
+class Nmap::Parser::Host::Port::Service
+	# The name of the service
+	attr_reader :name
+	# Vendor name
+	attr_reader :product
+	# Version number
+	attr_reader :version
+	# How this information was obtained, such as "table" or "probed"
+	attr_reader :method
+	# Service owner
+	attr_reader :owner
+	# Any tunnelling used, like "ssl"
+	attr_reader :tunnel
+	# RPC program number
+	attr_reader :rpcnum
+	# Range of RPC version numbers
+	attr_reader :lowver, :highver
+	# How confident the version detection is
+	attr_reader :confidence
+	# Protocol, such as "rpc"
+	attr_reader :proto
+	# Extra misc. information about the service
+	attr_reader :extra
+	# The type of device the service is running on
+	attr_reader :devicetype
+	# The OS the service is running on
+	attr_reader :ostype
+	# The service fingerprint
+	attr_reader :fingerprint
+
+	alias extrainfo extra
+
+	private
+
+	def initialize(port)
+		parse(port)
+	end
+
+	def parse(port)
+		return nil if port.nil?
+
+		service = port.elements['service']
+
+		return nil if service.nil?
+
+		@name = service.attributes['name']
+		@product = service.attributes['product']
+		@version = service.attributes['version']
+		@method = service.attributes['method']
+		owner = port.elements['owner']
+		@owner = owner.attributes['name'] if owner
+		@tunnel = service.attributes['tunnel']
+		rpcnum = service.attributes['rpcnum']
+		@rpcnum = rpcnum.to_i if rpcnum
+		lowver = service.attributes['lowver']
+		@lowver = lowver.to_i if lowver
+		highver = service.attributes['highver']
+		@highver = highver.to_i if highver
+		conf = service.attributes['conf']
+		@confidence = conf.to_i if conf
+		@proto = service.attributes['proto']
+		@extra = service.attributes['extrainfo']
+		@devicetype = service.attributes['devicetype']
+		@ostype = service.attributes['ostype']
+		@fingerprint = service.attributes['servicefp']
+	end
+end
+
+# This holds the OS information from OS Detection
+class Nmap::Parser::Host::OS
+	# OS fingerprint
+	attr_reader :fingerprint
+
+	# Returns an array of OSClass objects, and passes them each to a
+	# block if one is given
+	def osclasses
+		if block_given?
+			@osclasses.each do |osclass|
+				yield osclass
+			end
+		end
+
+		@osclasses
+	end
+
+	# Returns an array of OSMatch objects, and passes them each to a
+	# block if one is given
+	def osmatches
+		if block_given?
+			@osmatches.each do |osmatch|
+				yield osmatch
+			end
+		end
+
+		@osmatches
+	end
+
+	# Returns the number of OS class records
+	def class_count
+		@osclasses.size
+	end
+
+	# Returns OS class accuracy of the first OS class record, or Nth record
+	# as specified by +index+
+	def class_accuracy(index = 0)
+		return nil if @osclasses.empty?
+
+		@osclasses[index.to_i].accuracy
+	end
+
+	# Returns OS family information of first OS class record, or Nth record
+	# as specified by +index+
+	def osfamily(index = 0)
+		return nil if @osclasses.empty?
+
+		@osclasses[index.to_i].osfamily
+	end
+
+	# Returns OS generation information of first OS class record, or Nth
+	# record as specified by +index+
+	def osgen(index = 0)
+		return nil if @osclasses.empty?
+
+		@osclasses[index.to_i].osgen
+	end
+
+	# Returns OS type information of the first OS class record, or Nth
+	# record as specified by +index+
+	def ostype(index = 0)
+		return nil if @osclasses.empty?
+
+		@osclasses[index.to_i].ostype
+	end
+
+	# Returns OS vendor information of the first OS class record, or Nth
+	# record as specified by +index+
+	def osvendor(index = 0)
+		return nil if @osclasses.empty?
+
+		@osclasses[index.to_i].osvendor
+	end
+
+	# Returns the number of OS match records
+	def name_count
+		@osmatches.size
+	end
+
+	# Returns name of first OS match record, or Nth record as specified by
+	# +index+
+	def name(index = 0)
+		return nil if @osmatches.empty?
+
+		@osmatches[index.to_i].name
+	end
+
+	# Returns OS name accuracy of the first OS match record, or Nth record
+	# as specified by +index+
+	def name_accuracy(index = 0)
+		return nil if @osmatches.empty?
+
+		@osmatches[index.to_i].accuracy
+	end
+
+	# Returns an array of names from all OS records, and passes them each
+	# to a block if one is given
+	def all_names() # :yields: name
+		names = []
+
+		@osmatches.each do |match|
+			names << match.name
+			yield match.name if block_given?
+		end
+
+		names
+	end
+
+	alias names all_names
+
+	# Returns the closed TCP port used for this OS Detection run
+	def tcpport_closed
+		return nil if @portsused.nil?
+
+		@portsused.each do |port|
+			if port.proto == "tcp" and port.state == "closed"
+				return port.num
+			end
+		end
+
+		nil
+	end
+
+	# Returns the open TCP port used for this OS Detection run
+	def tcpport_open
+		return nil if @portsused.nil?
+
+		@portsused.each do |port|
+			if port.proto == "tcp" and port.state == "open"
+				return port.num
+			end
+		end
+
+		nil
+	end
+
+	# Returns the closed UDP port used for this OS Detection run
+	def udpport_closed
+		return nil if @portsused.nil?
+
+		@portsused.each do |port|
+			if port.proto == "udp" and port.state == "closed"
+				return port.num
+			end
+		end
+
+		nil
+	end
+
+	private
+
+	def initialize(os)
+		parse(os)
+	end
+
+	def parse(os)
+		@portsused = []
+		@osclasses = []
+		@osmatches = []
+
+		return nil if os.nil?
+
+		os.each_element('portused') do |port|
+			@portsused << PortUsed.new(port)
+		end
+
+		os.each_element('osclass') do |osclass|
+			@osclasses << OSClass.new(osclass)
+		end
+
+		@osclasses.sort!.reverse!
+
+		os.each_element('osmatch') do |match|
+			@osmatches << OSMatch.new(match)
+		end
+
+		@osmatches.sort!.reverse!
+
+		fp = os.elements['osfingerprint']
+		@fingerprint = fp.attributes['fingerprint'] if fp
+	end
+end
+
+class Nmap::Parser::Host::OS::PortUsed # :nodoc: all
+	attr_reader :state, :proto, :num
+
+	private
+
+	def initialize(ports)
+		parse(ports)
+	end
+
+	def parse(ports)
+		@state = ports.attributes['state']
+		@proto = ports.attributes['proto']
+		@num = ports.attributes['portid'].to_i
+	end
+end
+
+# Holds information for an individual OS class record
+class Nmap::Parser::Host::OS::OSClass
+	# Device type, like "router" or "general purpose"
+	attr_reader :ostype
+	# Company that makes the OS, like "Apple" or "Microsoft"
+	attr_reader :osvendor
+	# Product name, like "Linux" or "Windows"
+	attr_reader :osfamily
+	# A more precise description, like "2.6.X" for Linux
+	attr_reader :osgen
+	# Accuracy of this information
+	attr_reader :accuracy
+
+	# Compares accuracy
+	def <=>(osclass)
+		@accuracy <=> osclass.accuracy
+	end
+
+	private
+
+	def initialize(osclass)
+		parse(osclass)
+	end
+
+	def parse(osclass)
+		@ostype = osclass.attributes['type']
+		@osvendor = osclass.attributes['vendor']
+		@osfamily = osclass.attributes['osfamily']
+		@osgen = osclass.attributes['osgen']
+		@accuracy = osclass.attributes['accuracy'].to_i
+	end
+end
+
+# Holds information for an individual OS match record
+class Nmap::Parser::Host::OS::OSMatch
+	# Operating System name
+	attr_reader :name
+	# Accuracy of this match
+	attr_reader :accuracy
+
+	# Compares accuracy
+	def <=>(osmatch)
+		@accuracy <=> osmatch.accuracy
+	end
+
+	private
+
+	def initialize(os)
+		parse(os)
+	end
+
+	def parse(os)
+		@name = os.attributes['name']
+		@accuracy = os.attributes['accuracy'].to_i
+	end
+end
+