nexpose 0.0.9 → 0.0.91

data/lib/nexpose.rb

@@ -53,3244 +53,22 @@ require 'net/https'
 require 'net/http'
 require 'uri'
 require 'rex/mime'
+require 'nexpose/error'
+require 'nexpose/util'
+require 'nexpose/api_request'
+require 'nexpose/misc'
+require 'nexpose/report'
+require 'nexpose/scan'
+require 'nexpose/scan_engine'
+require 'nexpose/silo'
+require 'nexpose/site'
+require 'nexpose/ticket'
+require 'nexpose/vuln'
+require 'nexpose/creds'
+require 'nexpose/connection'
 
 module Nexpose
 
-module Sanitize
-	def replace_entities(str)
-		ret = str.dup
-		ret.gsub!(/&/, "&")
-		ret.gsub!(/'/, "'")
-		ret.gsub!(/"/, """)
-		ret.gsub!(/</, "&lt;")
-		ret.gsub!(/>/, "&gt;")
-		ret
-	end
-end
-
-class APIError < ::RuntimeError
-	attr_accessor :req, :reason
-	def initialize(req, reason = '')
-		self.req = req
-		self.reason = reason
-	end
-	def to_s
-		"NexposeAPI: #{self.reason}"
-	end
-end
-
-class AuthenticationFailed < APIError
-	def initialize(req)
-		self.req = req
-		self.reason = "Login Failed"
-	end
-end
-
-module XMLUtils
-	def parse_xml(xml)
-		::REXML::Document.new(xml.to_s)
-	end
-end
-
-class APIRequest
-	include XMLUtils
-
-	attr_reader :http
-	attr_reader :uri
-	attr_reader :headers
-	attr_reader :retry_count
-	attr_reader :time_out
-	attr_reader :pause
-
-	attr_reader :req
-	attr_reader :res
-	attr_reader :sid
-	attr_reader :success
-
-	attr_reader :error
-	attr_reader :trace
-
-	attr_reader :raw_response
-	attr_reader :raw_response_data
-
-	def initialize(req, url, api_version='1.1')
-		@url = url
-		@req = req
-		@api_version = api_version
-		@url = @url.sub('API_VERSION', @api_version)
-		prepare_http_client
-	end
-
-	def prepare_http_client
-		@retry_count = 0
-		@retry_count_max = 10
-		@time_out = 30
-		@pause = 2
-		@uri = URI.parse(@url)
-		@http = Net::HTTP.new(@uri.host, @uri.port)
-		@http.use_ssl = true
-		#
-		# XXX: This is obviously a security issue, however, we handle this at the client level by forcing
-		#      a confirmation when the nexpose host is not localhost. In a perfect world, we would present
-		#      the server signature before accepting it, but this requires either a direct callback inside
-		#      of this module back to whatever UI, or opens a race condition between accept and attempt.
-		#
-		@http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-		@headers = {'Content-Type' => 'text/xml'}
-		@success = false
-	end
-
-	def execute
-		@conn_tries = 0
-
-		begin
-		prepare_http_client
-		@raw_response = @http.post(@uri.path, @req, @headers)
-		@raw_response_data = @raw_response.read_body
-		@res = parse_xml(@raw_response_data)
-
-		if(not @res.root)
-			@error = "NeXpose service returned invalid XML"
-			return @sid
-		end
-
-		@sid = attributes['session-id']
-
-		if(attributes['success'] and attributes['success'].to_i == 1)
-			@success = true
-		elsif @api_version =~ /1.2/  and @res and 	(@res.get_elements '//Exception').count < 1
-			@success = true
-		else
-			@success = false
-			@res.elements.each('//Failure/Exception') do |s|
-				s.elements.each('message') do |m|
-					@error = m.text
-				end
-				s.elements.each('stacktrace') do |m|
-					@trace = m.text
-				end
-			end
-		end
-		# This is a hack to handle corner cases where a heavily loaded NeXpose instance
-		# drops our HTTP connection before processing. We try 5 times to establish a
-		# connection in these situations. The actual exception occurs in the Ruby
-		# http library, which is why we use such generic error classes.
-		rescue ::ArgumentError, ::NoMethodError
-			if @conn_tries < 5
-				@conn_tries += 1
-				retry
-			end
-		rescue ::Timeout::Error
-			if @conn_tries < 5
-				@conn_tries += 1
-				retry
-			end
-			@error = "NeXpose host did not respond"
-		rescue ::Errno::EHOSTUNREACH,::Errno::ENETDOWN,::Errno::ENETUNREACH,::Errno::ENETRESET,::Errno::EHOSTDOWN,::Errno::EACCES,::Errno::EINVAL,::Errno::EADDRNOTAVAIL
-			@error = "NeXpose host is unreachable"
-		# Handle console-level interrupts
-		rescue ::Interrupt
-			@error = "received a user interrupt"
-		rescue ::Errno::ECONNRESET,::Errno::ECONNREFUSED,::Errno::ENOTCONN,::Errno::ECONNABORTED
-			@error = "NeXpose service is not available"
-		rescue ::REXML::ParseException
-			@error = "NeXpose has not been properly licensed"
-		end
-
-		if ! (@success or @error)
-			@error = "NeXpose service returned an unrecognized response: #{@raw_response_data.inspect}"
-		end
-
-		@sid
-	end
-
-	def attributes(*args)
-		return if not @res.root
-		@res.root.attributes(*args)
-	end
-
-	def self.execute(url, req, api_version='1.1')
-		obj = self.new(req, url, api_version)
-		obj.execute
-		if(not obj.success)
-			raise APIError.new(obj, "Action failed: #{obj.error}")
-		end
-		obj
-	end
-
-end
-
-module NexposeAPI
-
-	def make_xml(name, opts={}, data='', append_session_id=true)
-		xml = REXML::Element.new(name)
-		if(@session_id and append_session_id)
-			xml.attributes['session-id'] = @session_id
-		end
-
-		opts.keys.each do |k|
-			xml.attributes[k] = "#{opts[k]}"
-		end
-		
-		xml.text = data
-
-		xml
-	end
-
-	def scan_stop(param)
-		r = execute(make_xml('ScanStopRequest', { 'scan-id' => param }))
-		r.success
-	end
-
-	def scan_status(param)
-		r = execute(make_xml('ScanStatusRequest', { 'scan-id' => param }))
-		r.success ? r.attributes['status'] : nil
-	end
-
-	def scan_activity
-		r = execute(make_xml('ScanActivityRequest', { }))
-		if(r.success)
-			res = []
-			r.res.elements.each("//ScanSummary") do |scan|
-				res << {
-					:scan_id    => scan.attributes['scan-id'].to_i,
-					:site_id    => scan.attributes['site-id'].to_i,
-					:engine_id  => scan.attributes['engine-id'].to_i,
-					:status     => scan.attributes['status'].to_s,
-					:start_time => Date.parse(scan.attributes['startTime'].to_s).to_time
-				}
-			end
-			return res
-		else
-			return false
-		end
-	end
-
-	def scan_statistics(param)
-		r = execute(make_xml('ScanStatisticsRequest', {'scan-id' => param }))
-		if(r.success)
-			res = {}
-			r.res.elements.each("//ScanSummary/nodes") do |node|
-				res[:nodes] = {}
-				node.attributes.keys.each do |k|
-					res[:nodes][k] = node.attributes[k].to_i
-				end
-			end
-			r.res.elements.each("//ScanSummary/tasks") do |task|
-				res[:task] = {}
-				task.attributes.keys.each do |k|
-					res[:task][k] = task.attributes[k].to_i
-				end
-			end
-			r.res.elements.each("//ScanSummary/vulnerabilities") do |vuln|
-				res[:vulns] ||= {}
-				k = vuln.attributes['status'] + (vuln.attributes['severity'] ? ("-" + vuln.attributes['severity']) : '')
-				res[:vulns][k] = vuln.attributes['count'].to_i
-			end
-			r.res.elements.each("//ScanSummary") do |summ|
-				res[:summary] = {}
-				summ.attributes.keys.each do |k|
-					res[:summary][k] = summ.attributes[k]
-					if (res[:summary][k] =~ /^\d+$/)
-						res[:summary][k] = res[:summary][k].to_i
-					end
-				end
-			end
-			r.res.elements.each("//ScanSummary/message") do |message|
-				res[:message] = message.text
-			end
-			return res
-		else
-			return false
-		end
-	end
-
-	def report_generate(param)
-		r = execute(make_xml('ReportGenerateRequest', { 'report-id' => param }))
-		r.success
-	end
-
-	def report_last(param)
-		r = execute(make_xml('ReportHistoryRequest', { 'reportcfg-id' => param }))
-		res = nil
-		if(r.success)
-			stk = []
-			r.res.elements.each("//ReportSummary") do |rep|
-				stk << [ rep.attributes['id'].to_i, rep.attributes['report-URI'] ]
-			end
-			if (stk.length > 0)
-				stk.sort!{|a,b| b[0] <=> a[0]}
-				res = stk[0][1]
-			end
-		end
-		res
-	end
-
-	def report_history(param)
-		execute(make_xml('ReportHistoryRequest', { 'reportcfg-id' => param }))
-	end
-
-	def report_config_delete(param)
-		r = execute(make_xml('ReportDeleteRequest', { 'reportcfg-id' => param }))
-		r.success
-	end
-
-	def report_delete(param)
-		r = execute(make_xml('ReportDeleteRequest', { 'report-id' => param }))
-		r.success
-	end
-
-	def device_delete(param)
-		r = execute(make_xml('DeviceDeleteRequest', { 'site-id' => param }))
-		r.success
-	end
-
-	def asset_group_delete(connection, id, debug = false)
-		r = execute(make_xml('AssetGroupDeleteRequest', { 'group-id' => param }))
-		r.success
-	end
-
-	#
-	# Create a NeXpose ticket
-	#
-	# ticket_info: A hash of the data to be used to create a ticket in NeXpose:
-	# :name        => The name of the ticket (Required)
-	# :device_id   => The NeXpose device ID for the device being ticketed (Required)
-	# :assigned_to => The NeXpose user to whom this ticket is assigned (Required)
-	# :priority    => "low,moderate,normal,high,critical" (Required)
-	#
-	# :vulnerabilities => An array of NeXpose vuln IDs. This is NOT the same as vuln ID.  (Required)
-	# :comments        => An array of comments to accompany this ticket
-	#
-	# @return The ticket ID if the ticket creation was successful, {@code false} otherwise
-	#
-	def create_ticket ticket_info
-		ticket_name = ticket_info[:name]
-		unless ticket_name
-			raise ArgumentError.new 'Ticket name is required'
-		end
-
-		device_id = ticket_info[:device_id]
-		unless device_id
-			raise ArgumentError.new 'Device ID is required'
-		end
-
-		assigned_to = ticket_info[:assigned_to]
-		unless assigned_to
-			raise ArgumentError.new 'Assignee name is required'
-		end
-
-		priority = ticket_info[:priority]
-		unless priority
-			raise ArgumentError.new 'Ticket priority is required'
-		end
-
-		vulnerabilities = ticket_info[:vulnerabilities]
-		if not vulnerabilities or vulnerabilities.count < 1
-			raise ArgumentError.new 'Vulnerabilities are required'
-		end
-
-		comments = ticket_info[:comments]
-		base_xml = make_xml 'TicketCreateRequest'
-
-		required_attributes = {
-			'name'        => ticket_name,
-			'priority'    => priority,
-			'device-id'   => device_id,
-			'assigned-to' => assigned_to
-		}
-
-		create_request_xml = REXML::Element.new 'TicketCreate'
-		create_request_xml.add_attributes required_attributes
-
-	  # Add vulnerabilities
-		vulnerabilities_xml = REXML::Element.new 'Vulnerabilities'
-		vulnerabilities.each do |vuln_id|
-			vulnerabilities_xml.add_element 'Vulnerability', {'id' => vuln_id}
-		end
-		create_request_xml.add_element vulnerabilities_xml
-
-		# Add comments
-		if comments and comments.count > 0
-			comments_xml = REXML::Element.new 'Comments'
-			comments.each do |comment|
-				comment_xml = REXML::Element.new 'Comment'
-				comment_xml.add_text comment
-				comments_xml.add_element comment_xml
-			end
-
-			create_request_xml.add_element comments_xml
-		end
-
-		base_xml.add_element create_request_xml
-		r = execute base_xml, '1.2'
-		if r.success
-			r.res.elements.each('TicketCreateResponse') do |group|
-				return group.attributes['id'].to_i
-			end
-		else
-			false
-		end
-	end
-
-	#
-	# Deletes a NeXpose ticket.
-	#
-	# ticket_ids: An array of ticket IDs to be deleted.
-	#
-	# @returns {@code true} iff the call was successfull. {@code false} otherwise.
-	#
-	def delete_ticket ticket_ids
-		if not ticket_ids or ticket_ids.count < 1
-			raise ArgumentError.new 'The tickets to delete should not be null or empty'
-		end
-
-		base_xml = make_xml 'TicketDeleteRequest'
-		ticket_ids.each do |id|
-			base_xml.add_element 'Ticket', {'id' => id}
-		end
-
-		(execute base_xml, '1.2').success
-	end
-
-	#-------------------------------------------------------------------------
-	# Returns all asset group information
-	#-------------------------------------------------------------------------
-	def asset_groups_listing()
-		r = execute(make_xml('AssetGroupListingRequest'))
-
-		if r.success
-			res = []
-			r.res.elements.each('//AssetGroupSummary') do |group|
-				res << {
-						:asset_group_id => group.attributes['id'].to_i,
-						:name => group.attributes['name'].to_s,
-						:description => group.attributes['description'].to_s,
-						:risk_score => group.attributes['riskscore'].to_f,
-				}
-			end
-			res
-		else
-			false
-		end
-	end
-
-	#-------------------------------------------------------------------------
-	# Returns an asset group configuration information for a specific group ID
-	#-------------------------------------------------------------------------
-	def asset_group_config(group_id)
-		r = execute(make_xml('AssetGroupConfigRequest', {'group-id' => group_id}))
-
-		if r.success
-			res = []
-			r.res.elements.each('//Devices/device') do |device_info|
-				res << {
-						:device_id => device_info.attributes['id'].to_i,
-						:site_id => device_info.attributes['site-id'].to_i,
-						:address => device_info.attributes['address'].to_s,
-						:riskfactor => device_info.attributes['riskfactor'].to_f,
-				}
-			end
-			res
-		else
-			false
-		end
-	end
-
-	#-----------------------------------------------------------------------
-	# Starts device specific site scanning.
-	#
-	# devices - An Array of device IDs
-	# hosts - An Array of Hashes [o]=>{:range=>"to,from"} [1]=>{:host=>host}
-	#-----------------------------------------------------------------------
-	def site_device_scan_start(site_id, devices, hosts)
-
-		if hosts == nil and devices == nil
-			raise ArgumentError.new("Both the device and host list is nil")
-		end
-
-		xml = make_xml('SiteDevicesScanRequest', {'site-id' => site_id})
-
-		if devices != nil
-			inner_xml = REXML::Element.new 'Devices'
-			for device_id in devices
-				inner_xml.add_element 'device', {'id' => "#{device_id}"}
-			end
-			xml.add_element inner_xml
-		end
-
-		if hosts != nil
-			inner_xml = REXML::Element.new 'Hosts'
-			hosts.each_index do |x|
-				if hosts[x].key? :range
-					to = hosts[x][:range].split(',')[0]
-					from = hosts[x][:range].split(',')[1]
-					inner_xml.add_element 'range', {'to' => "#{to}", 'from' => "#{from}"}
-				end
-				if hosts[x].key? :host
-					host_element = REXML::Element.new 'host'
-					host_element.text = "#{hosts[x][:host]}"
-					inner_xml.add_element host_element
-				end
-			end
-			xml.add_element inner_xml
-		end
-
-		r = execute xml
-		if r.success
-			r.res.elements.each('//Scan') do |scan_info|
-				return {
-						:scan_id => scan_info.attributes['scan-id'].to_i,
-						:engine_id => scan_info.attributes['engine-id'].to_i
-				}
-			end
-		else
-			false
-		end
-	end
-
-	#
-	# Lists all the users for the NSC along with the user details.
-	#
-	def list_users
-		r = execute(make_xml('UserListingRequest'))
-		if r.success
-			res = []
-			r.res.elements.each('//UserSummary') do |user_summary|
-				res << {
-					:auth_source 	=> user_summary.attributes['authSource'],
-					:auth_module 	=> user_summary.attributes['authModule'],
-					:user_name 		=> user_summary.attributes['userName'],
-					:full_name 		=> user_summary.attributes['fullName'],
-					:email 			=> user_summary.attributes['email'],
-					:is_admin 		=> user_summary.attributes['isAdmin'].to_s.chomp.eql?('1'),
-					:is_disabled 	=> user_summary.attributes['disabled'].to_s.chomp.eql?('1'),
-					:site_count 	=> user_summary.attributes['siteCount'],
-					:group_count 	=> user_summary.attributes['groupCount']
-				}
-			end
-			res
-		else
-			false
-		end
-	end
-
-	def site_delete(param)
-		r = execute(make_xml('SiteDeleteRequest', { 'site-id' => param }))
-		r.success
-	end
-		
-	def site_listing
-		r = execute(make_xml('SiteListingRequest', { }))
-		
-		if(r.success)
-			res = []
-			r.res.elements.each("//SiteSummary") do |site|
-				res << {
-					:site_id       => site.attributes['id'].to_i,
-					:name          => site.attributes['name'].to_s,
-					:risk_factor   => site.attributes['riskfactor'].to_f,
-					:risk_score    => site.attributes['riskscore'].to_f,
-				}
-			end
-			return res
-		else
-			return false
-		end
-	end
-
-	#-----------------------------------------------------------------------
-	# TODO: Needs to be expanded to included details
-	#-----------------------------------------------------------------------
-	def site_scan_history(site_id)
-		r = execute(make_xml('SiteScanHistoryRequest', {'site-id' => site_id.to_s}))
-
-		if (r.success)
-			res = []
-			r.res.elements.each("//ScanSummary") do |site_scan_history|
-				res << {
-						:site_id => site_scan_history.attributes['site-id'].to_i,
-						:scan_id => site_scan_history.attributes['scan-id'].to_i,
-						:engine_id => site_scan_history.attributes['engine-id'].to_i,
-						:start_time => site_scan_history.attributes['startTime'].to_s,
-						:end_time => site_scan_history.attributes['endTime'].to_s
-				}
-			end
-			res
-		else
-			false
-		end
-	end
-
-	###################
-	# VULN EXCEPTIONS #
-	###################
-
-	#-----------------------------------------------------------------------
-	# Returns an array of vulnerability exceptions and their associated
-	# attributes.
-	#
-	# @param status - (optional) The status of the vulnerability exception:
-	# "Under Review", "Approved", "Rejected"
-	#-----------------------------------------------------------------------
-	def vuln_listing status=nil
-		option = {}
-
-		if status && !status.empty?
-			if status =~ /Under Review|Approved|Rejected/
-				option['status'] = status
-			else
-				raise ArgumentError.new 'The vulnerability status passed in is invalid!'
-			end
-		end
-
-		xml = make_xml('VulnerabilityExceptionListingRequest', option)
-		r = execute xml, '1.2'
-
-		if r.success
-			res = []
-			r.res.elements.each("//VulnerabilityException") do |ve|
-				submitter_comment = ve.elements['submitter-comment']
-				reviewer_comment = ve.elements['reviewer-comment']
-				res << {
-					:vuln_id 			=> ve.attributes['vuln-id'],
-					:exception_id 		=> ve.attributes['exception-id'],
-					:submitter 			=> ve.attributes['submitter'],
-					:reviewer 			=> ve.attributes['reviewer'],
-					:status 			=> ve.attributes['status'],
-					:reason 			=> ve.attributes['reason'],
-					:scope 				=> ve.attributes['scope'],
-					:device_id 			=> ve.attributes['device-id'],
-					:port_no 			=> ve.attributes['port-no'],
-					:expiration_date 	=> ve.attributes['expiration-date'],
-					:vuln_key 			=> ve.attributes['vuln-key'],
-					:submitter_comment	=> submitter_comment.nil? ? '' : submitter_comment.text,
-					:reviewer_comment	=> reviewer_comment.nil? ? '' : reviewer_comment.text
-				}
-			end
-			res
-		else
-			false
-		end
-	end
-
-	#-------------------------------------------------------------------------------------------------------------------
-	# Creates a vulnerability exception.
-	#
-	# @param input - data used to create the vulnerability exception:
-	# :vuln_id - The Nexpose vulnerability ID.
-	# :reason - The reason for the exception
-	#         values - "False Positive", "Compensating Control", "Acceptable Use", "Acceptable Risk", "Other"
-	# :scope - The scope type  (NOTE: The case is important)
-	#        values - "All Instances", "All Instances on a Specific Asset", "Specific Instance of a specific Asset"
-	# :comment - A user comment
-	# :device-id - Used for specific instances related to "All Instances on a Specific Asset" AND "Specific Instance of Specific Asset"
-	# :port - All assets on this port related to "Specific Instance of a specific Asset"
-	# :vuln-key - The vulnerability key related to the "Specific Instance of a specific Asset"
-	#
-	# @returns exception-id - The Id associated with this create request
-	#-------------------------------------------------------------------------------------------------------------------
-	def vuln_exception_create input
-		options = {}
-
-		if input.nil?
-			raise ArgumentError.new 'The input element cannot be null'
-		end
-
-		vuln_id = input[:vuln_id]
-		if !vuln_id
-			raise ArgumentError.new 'The vulnerability ID is required'
-		end
-		options['vuln-id'] = vuln_id
-
-		reason = input[:reason]
-		if reason.nil? || reason.empty?
-			raise ArgumentError.new 'The reason is required'
-		end
-
-		unless reason =~ /False Positive|Compensating Control|Acceptable Use|Acceptable Risk|Other/
-			raise ArgumentError.new 'The reason type is invalid'
-		end
-		options['reason'] = reason
-
-		scope = input[:scope]
-		if scope.nil? || scope.empty?
-			raise ArgumentError.new 'The scope is required'
-		end
-
-		# For scope case matters.
-		unless scope =~ /All Instances|All Instances on a Specific Asset|Specific Instance of Specific Asset/
-			raise ArgumentError.new 'The scope type is invalid'
-		end
-
-		if scope =~ /All Instances on a Specific Asset|Specific Instance of Specific Asset/
-			device_id = input[:device_id]
-			vuln_key = input[:vuln_key]
-			port = input[:port]
-			if device_id
-				options['device-id'] = device_id
-			end
-
-			if (scope =~  /All Instances on a Specific Asset/ && (vuln_key || port))
-				raise ArgumentError.new "Vulnerability key or port cannot be used with the scope specified"
-			end
-
-			if vuln_key
-				options['vuln-key'] = vuln_key
-			end
-
-			if port
-				options['port-no'] = port
-			end
-		end
-		options['scope'] = scope
-
-		xml = make_xml('VulnerabilityExceptionCreateRequest', options)
-
-		comment = input[:comment]
-		if comment && !comment.empty?
-			comment_xml = make_xml('comment', {}, comment, false)
-			xml.add_element comment_xml
-		else
-			raise ArgumentError.new 'The comment cannot be empty'
-		end
-
-		r = execute xml, '1.2'
-		if r.success
-			r.res.elements.each("//VulnerabilityExceptionCreateResponse") do |vecr|
-				return vecr.attributes['exception-id']
-			end
-		else
-			false
-		end
-	end
-
-	#-------------------------------------------------------------------------------------------------------------------
-	# Resubmit a vulnerability exception.
-	#
-	# @param input - data used to create the vulnerability exception:
-	# :vuln_id - The Nexpose vulnerability ID. (required)
-	# :reason - The reason for the exception (optional)
-	#         values - "False Positive", "Compensating Control", "Acceptable Use", "Acceptable Risk", "Other"
-	# :comment - A user comment  (required)
-	#-------------------------------------------------------------------------------------------------------------------
-	def vuln_exception_resubmit input
-	   	options = {}
-
-		if input.nil?
-			raise ArgumentError.new 'The input element cannot be null'
-		end
-
-		exception_id = input[:exception_id]
-		if !exception_id
-			raise ArgumentError.new 'The exception ID is required'
-		end
-		options['exception-id'] = exception_id
-
-		reason = input[:reason]
-		if !reason.nil? && !reason.empty?
-			unless reason =~ /False Positive|Compensating Control|Acceptable Use|Acceptable Risk|Other/
-				raise ArgumentError.new 'The reason type is invalid'
-			end
-			options['reason'] = reason
-
-		end
-
-		xml = make_xml('VulnerabilityExceptionResubmitRequest', options)
-
-		comment = input[:comment]
-		if comment && !comment.empty?
-			comment_xml = make_xml('comment', {}, comment, false)
-			xml.add_element comment_xml
-		end
-
-		r = execute xml, '1.2'
-		r.success
-	end
-
-	#-------------------------------------------------------------------------------------------------------------------
-	# Allows a previously submitted exception that has not been approved to be withdrawn.
-	#
-	# @param exception_id - The exception id returned after the vuln exception was submitted for creation.
-	#-------------------------------------------------------------------------------------------------------------------
-	def vuln_exception_recall exception_id
-		xml = make_xml('VulnerabilityExceptionRecallRequest', {'exception-id' => exception_id})
-		r = execute xml, '1.2'
-		r.success
-	end
-
-
-	#-------------------------------------------------------------------------------------------------------------------
-	# Allows a submitted vulnerability exception to be approved.
-	#
-	# @param input:
-	# :exception_id - The exception id returned after the vuln exception was submitted for creation.
-	# :comment - An optional comment
-	#-------------------------------------------------------------------------------------------------------------------
-	def vuln_exception_approve input
-		exception_id = input[:exception_id]
-		if !exception_id
-			raise ArgumentError.new 'Exception Id is required'
-		end
-
-		xml = make_xml('VulnerabilityExceptionApproveRequest', {'exception-id' => exception_id})
-		comment = input[:comment]
-		if comment && !comment.empty?
-			comment_xml = make_xml('comment', {}, comment, false)
-			xml.add_element comment_xml
-		end
-
-		r = execute xml, '1.2'
-		r.success
-	end
-
-	#-------------------------------------------------------------------------------------------------------------------
-	# Rejects a submitted vulnerability exception to be approved.
-	#
-	# @param input:
-	# :exception_id - The exception id returned after the vuln exception was submitted for creation.
-	# :comment - An optional comment
-	#-------------------------------------------------------------------------------------------------------------------
-	def vuln_exception_reject input
-		exception_id = input[:exception_id]
-		if !exception_id
-			raise ArgumentError.new 'Exception Id is required'
-		end
-
-		xml = make_xml('VulnerabilityExceptionRejectRequest', {'exception-id' => exception_id})
-		comment = input[:comment]
-		if comment && !comment.empty?
-			comment_xml = make_xml('comment', {}, comment, false)
-			xml.add_element comment_xml
-		end
-
-		r = execute xml, '1.2'
-		r.success
-	end
-
-	#-------------------------------------------------------------------------------------------------------------------
-	# Updates a vulnerability exception comment.
-	#
-	# @param input:
-	# :exception_id - The exception id returned after the vuln exception was submitted for creation.
-	# :submitter_comment - The submitter comment
-	# :reviewer_comment - The reviewer comment
-	#-------------------------------------------------------------------------------------------------------------------
-	def vuln_exception_update_comment input
-		exception_id = input[:exception_id]
-		if !exception_id
-			raise ArgumentError.new 'Exception Id is required'
-		end
-
-		xml = make_xml('VulnerabilityExceptionUpdateCommentRequest', {'exception-id' => exception_id})
-		submitter_comment = input[:submitter_comment]
-		if submitter_comment && !submitter_comment.empty?
-			comment_xml = make_xml('submitter-comment', {}, submitter_comment, false)
-			xml.add_element comment_xml
-		end
-
-		reviewer_comment = input[:reviewer_comment]
-		if reviewer_comment && !reviewer_comment.empty?
-			comment_xml = make_xml('reviewer-comment', {}, reviewer_comment, false)
-			xml.add_element comment_xml
-		end
-
-		r = execute xml, '1.2'
-		r.success
-	end
-
-	#-------------------------------------------------------------------------------------------------------------------
-	# Update the expiration date for a vulnerability exception.
-	#
-	# @param input
-	# :exception_id - The exception id returned after the vulnerability exception was submitted for creation.
-	# :expiration_date - The new expiration date format: YYYY-MM-DD
-	#-------------------------------------------------------------------------------------------------------------------
-	def vuln_exception_update_expiration_date input
-		exception_id = input[:exception_id]
-		if !exception_id
-			raise ArgumentError.new 'Exception Id is required'
-		end
-
-		expiration_date = input[:expiration_date]
-		if expiration_date && !expiration_date.empty? && expiration_date =~ /\A\d{4}-(\d{2})-(\d{2})\z/
-			if $1.to_i > 12
-				raise ArgumentError.new 'The expiration date month value is invalid'
-			end
-
-			if $2.to_i > 31
-				raise ArgumentError.new 'The expiration date day value is invalid'
-			end
-		else
-			raise ArgumentError.new 'Expiration date is invalid'
-		end
-
-		options = {}
-		options['exception-id'] = exception_id
-		options['expiration-date'] = expiration_date
-		xml = make_xml('VulnerabilityExceptionUpdateExpirationDateRequest', options)
-		r = execute xml, '1.2'
-		r.success
-	end
-
-	#-------------------------------------------------------------------------------------------------------------------
-	# Deletes a submitted vulnerability exception to be approved.
-	#
-	# @param exception_id - The exception id returned after the vuln exception was submitted for creation.
-	#-------------------------------------------------------------------------------------------------------------------
-	def vuln_exception_delete exception_id
-		if !exception_id
-			raise ArgumentError.new 'Exception Id is required'
-		end
-
-		xml = make_xml('VulnerabilityExceptionDeleteRequest', {'exception-id' => exception_id})
-		r = execute xml, '1.2'
-		r.success
-	end
-
-	###################
-	# SILO MANAGEMENT #
-	###################
-
-	#########################
-	# MULTI-TENANT USER OPS #
-	#########################
-
-	#-------------------------------------------------------------------------
-	# Creates a multi-tenant user
-	#
-	# user_config - A map of the user data.
-	#
-	# REQUIRED PARAMS
-	# user-id, authsrcid, user-name, full-name, enabled, superuser
-	#
-	# OPTIONAL PARAMS
-	# email, password
-	#
-	# silo_configs - An array of maps of silo specific data
-	#
-	# REQUIRED PARAMS
-	# silo-id, role-name, all-groups, all-sites, default-silo
-	#
-	# allowed_groups/allowed_sites - An array of ids
-	#-------------------------------------------------------------------------
-	def create_multi_tenant_user(user_config, silo_configs)
-		xml = make_xml('MultiTenantUserCreateRequest')
-		mtu_config_xml = make_xml('MultiTenantUserConfig', user_config, '', false)
-
-		# Add the silo access
-		silo_xml = make_xml('SiloAccesses', {}, '', false)
-		silo_config_xml = make_xml('SiloAccess', {}, '', false)
-		silo_configs.keys.each do |k|
-			if k.eql? 'allowed_sites'
-				allowed_sites_xml = make_xml('AllowedSites', {}, '', false)
-				silo_configs['allowed_sites'].each do |allowed_site|
-					allowed_sites_xml.add_element make_xml('AllowedSite', {'id' => allowed_site}, '', false)
-				end
-				silo_config_xml.add_element allowed_sites_xml
-			elsif k.eql? 'allowed_groups'
-				allowed_groups_xml = make_xml('AllowedGroups', {}, '', false)
-				silo_configs['allowed_groups'].each do |allowed_group|
-					allowed_groups_xml.add_element make_xml('AllowedGroup', {'id' => allowed_group}, '', false)
-				end
-				silo_config_xml.add_element allowed_groups_xml
-			else
-				silo_config_xml.attributes[k] = silo_configs[k]
-			end
-		end
-		silo_xml.add_element silo_config_xml
-		mtu_config_xml.add_element silo_xml
-		xml.add_element mtu_config_xml
-		r = execute xml, '1.2'
-		r.success
-	end
-
-
-	#-------------------------------------------------------------------------
-	# Lists all the multi-tenant users and their attributes.
-	#-------------------------------------------------------------------------
-	def list_mtu
-		xml = make_xml('MultiTenantUserListingRequest')
-		r = execute xml, '1.2'
-
-		if r.success
-			res = []
-			r.res.elements.each("//MultiTenantUserSummary") do |mtu|
-				res << {
-					:id => mtu.attributes['id'],
-					:full_name => mtu.attributes['full-name'],
-					:user_name => mtu.attributes['user-name'],
-					:email => mtu.attributes['email'],
-					:super_user => mtu.attributes['superuser'],
-					:enabled => mtu.attributes['enabled'],
-					:auth_module => mtu.attributes['auth-module'],
-					:silo_count => mtu.attributes['silo-count'],
-					:locked => mtu.attributes['locked']
-				}
-			end
-			res
-		else
-			false
-		end
-	end
-
-	#-------------------------------------------------------------------------
-	# Delete a multi-tenant user
-	#-------------------------------------------------------------------------
-	def delete_mtu user_name, user_id
-		using_user_name = (user_name and not user_name.empty?)
-		xml = make_xml('MultiTenantUserDeleteRequest', (using_user_name ? {'user-name' => user_name} : {'user-id' => user_id}))
-		r = execute xml, '1.2'
-		r.success
-	end
-
-	####################
-	# SILO PROFILE OPS #
-	####################
-
-	#-------------------------------------------------------------------------
-	# Creates a silo profile
-	#
-	# silo_config - A map of the silo data.
-	#
-	# REQUIRED PARAMS
-	# id, name, all‐licensed-modules, all‐global-engines, all-global-report-templates, all‐global-scan‐templates
-	#
-	# OPTIONAL PARAMS
-	# description
-	#
-	# permissions - A map of an array of maps of silo specific data
-	#
-	# REQUIRED PARAMS
-	# silo-id, role-name, all-groups, all-sites, default-silo
-	#
-	# allowed_groups/allowed_sites - An array of ids
-	#-------------------------------------------------------------------------
-	def create_silo_profile silo_profile_config, permissions
-		xml = make_xml 'SiloProfileCreateRequest'
-		spc_xml = make_xml('SiloProfileConfig', silo_profile_config, '', false)
-
-		# Add the permissions
-		if permissions['global_report_templates']
-			grt_xml = make_xml('GlobalReportTemplates', {}, '', false)
-			permissions['global_report_templates'].each do |name|
-				grt_xml.add_element make_xml('GlobalReportTemplate', {'name' => name}, '', false)
-			end
-			spc_xml.add_element grt_xml
-		end
-
-		if permissions['global_scan_engines']
-			gse_xml = make_xml('GlobalScanEngines', {}, '', false)
-			permissions['global_scan_engines'].each do |name|
-				gse_xml.add_element make_xml('GlobalScanEngine', {'name' => name}, '', false)
-			end
-			spc_xml.add_element gse_xml
-		end
-
-		if permissions['global_scan_templates']
-			gst_xml = make_xml('GlobalScanTemplates', {}, '', false)
-			permissions['global_scan_templates'].each do |name|
-				gst_xml.add_element make_xml('GlobalScanTemplate', {'name' => name}, '', false)
-			end
-			spc_xml.add_element gst_xml
-		end
-
-		if permissions['licensed_modules']
-			lm_xml = make_xml('LicensedModules', {}, '', false)
-			permissions['licensed_modules'].each do |name|
-				lm_xml.add_element make_xml('LicensedModule', {'name' => name}, '', false)
-			end
-			spc_xml.add_element lm_xml
-		end
-
-		if permissions['restricted_report_formats']
-			rrf_xml = make_xml('RestrictedReportFormats', {}, '', false)
-			permissions['restricted_report_formats'].each do |name|
-				rrf_xml.add_element make_xml('RestrictedReportFormat', {'name' => name}, '', false)
-			end
-			spc_xml.add_element rrf_xml
-		end
-
-		if permissions['restricted_report_sections']
-			rrs_xml = make_xml('RestrictedReportSections', {}, '', false)
-			permissions['restricted_report_sections'].each do |name|
-				rrs_xml.add_element make_xml('RestrictedReportSection', {'name' => name}, '', false)
-			end
-			spc_xml.add_element rrs_xml
-		end
-
-		xml.add_element spc_xml
-		r = execute xml, '1.2'
-		r.success
-	end
-
-	#-------------------------------------------------------------------------
-	# Lists all the silo profiles and their attributes.
-	#-------------------------------------------------------------------------
-	def list_silo_profiles
-		xml = make_xml('SiloProfileListingRequest')
-		r = execute xml, '1.2'
-
-		if r.success
-			res = []
-			r.res.elements.each("//SiloProfileSummary") do |silo_profile|
-				res << {
-					:id => silo_profile.attributes['id'],
-					:name => silo_profile.attributes['name'],
-					:description => silo_profile.attributes['description'],
-					:global_report_template_count => silo_profile.attributes['global-report-template-count'],
-					:global_scan_engine_count => silo_profile.attributes['global-scan-engine-count'],
-					:global_scan_template_count => silo_profile.attributes['global-scan-template-count'],
-					:licensed_module_count => silo_profile.attributes['licensed-module-count'],
-					:restricted_report_section_count => silo_profile.attributes['restricted-report-section-count'],
-					:all_licensed_modules => silo_profile.attributes['all-licensed-modules'],
-					:all_global_engines => silo_profile.attributes['all-global-engines'],
-					:all_global_report_templates => silo_profile.attributes['all-global-report-templates'],
-					:all_global_scan_templates => silo_profile.attributes['all-global-scan-templates']
-				}
-			end
-			res
-		else
-			false
-		end
-	end
-
-	#-------------------------------------------------------------------------
-	# Delete a silo profile
-	#-------------------------------------------------------------------------
-	def delete_silo_profile name, id
-		using_name = (name and not name.empty?)
-		xml = make_xml('SiloProfileDeleteRequest', (using_name ? {'name' => name} : {'silo-profile-id' => id}))
-		r = execute xml, '1.2'
-		r.success
-	end
-
-	####################
-	# SILO OPS #
-	####################
-
-	#-------------------------------------------------------------------------
-	# Creates a silo
-	#
-	# silo_config - A map of the silo creation data.
-	#
-	# REQUIRED PARAMS
-	# id, name, silo-profile-id, max-assets, max-hosted-assets, max-users
-	#
-	# OPTIONAL PARAMS
-	# description
-	#-------------------------------------------------------------------------
-	def create_silo silo_config
-		xml = make_xml 'SiloCreateRequest'
-		silo_config_xml = make_xml 'SiloConfig', {}, '', false
-
-		# Add the attributes
-		silo_config.keys.each do |key|
-			if not 'merchant'.eql? key and not 'organization'.eql? key
-				silo_config_xml.attributes[key] = silo_config[key]
-			end
-		end
-
-		# Add Organization info
-		if silo_config['organization']
-			org_xml = make_xml 'Organization', {}, '', false
-			silo_config['organization'].keys.each do |key|
-				if not 'address'.eql? key
-					org_xml.attributes[key] = silo_config['organization'][key]
-				end
-			end
-
-			address_xml = make_xml 'Address', silo_config['organization']['address'], '', false
-			org_xml.add_element address_xml
-			silo_config_xml.add_element org_xml
-		end
-
-		# Add Merchant info
-		if silo_config['merchant']
-		 	merchant_xml = make_xml 'Merchant', {}, '', false
-
-			silo_config['merchant'].keys.each do |key|
-				if not 'dba'.eql? key and not 'other_industries'.eql? key and not 'qsa'.eql? key and not 'address'.eql? key
-					merchant_xml.attributes[key] = silo_config['merchant'][key]
-				end
-			end
-
-			 # Add the merchant address
-			 merchant_address_xml = make_xml 'Address', silo_config['merchant']['address'], '', false
-			 merchant_xml.add_element merchant_address_xml
-
-			 #Now add the complex data types
-			 if silo_config['merchant']['dba']
-				 dba_xml = make_xml 'DBAs', {}, '', false
-				 silo_config['merchant']['dba'].each do |name|
-					dba_xml.add_element make_xml('DBA', {'name' => name}, '', false)
-				end
-				merchant_xml.add_element dba_xml
-			end
-
-			if silo_config['merchant']['other_industries']
-				ois_xml = make_xml 'OtherIndustries', {}, '', false
-				silo_config['merchant']['other_industries'].each do |name|
-					ois_xml.add_element make_xml('Industry', {'name' => name}, '', false)
-				end
-				merchant_xml.add_element ois_xml
-			end
-
-			if silo_config['merchant']['qsa']
-				qsa_xml = make_xml 'QSA', {}, '', false
-				silo_config['merchant']['qsa'].keys.each do |key|
-					if not 'address'.eql? key
-						qsa_xml.attributes[key] = silo_config['merchant']['qsa'][key]
-					end
-				end
-
-				# Add the address for this QSA
-				address_xml = make_xml 'Address', silo_config['merchant']['qsa']['address'], '', false
-
-				qsa_xml.add_element address_xml
-				merchant_xml.add_element qsa_xml
-			end
-			silo_config_xml.add_element merchant_xml
-		end
-
-		xml.add_element silo_config_xml
-		r = execute xml, '1.2'
-		r.success
-	end
-
-	#-------------------------------------------------------------------------
-	# Lists all the silos and their attributes.
-	#-------------------------------------------------------------------------
-	def list_silos
-		xml = make_xml('SiloListingRequest')
-		r = execute xml, '1.2'
-
-		if r.success
-			res = []
-			r.res.elements.each("//SiloSummary") do |silo_profile|
-				res << {
-					:id => silo_profile.attributes['id'],
-					:name => silo_profile.attributes['name'],
-					:description => silo_profile.attributes['description']
-				}
-			end
-			res
-		else
-			false
-		end
-	end
-
-	#-------------------------------------------------------------------------
-	# Delete a silo
-	#-------------------------------------------------------------------------
-	def delete_silo name, id
-		using_name = (name and not name.empty?)
-		xml = make_xml('SiloDeleteRequest', (using_name ? {'silo-name' => name} : {'silo-id' => id}))
-		r = execute xml, '1.2'
-		r.success
-	end
-
-	def site_device_listing(site_id)
-		r = execute(make_xml('SiteDeviceListingRequest', { 'site-id' => site_id.to_s }))
-	
-		if(r.success)
-			res = []
-			r.res.elements.each("//device") do |device|
-				res << {
-					:device_id     => device.attributes['id'].to_i,
-					:address       => device.attributes['address'].to_s,
-					:risk_factor   => device.attributes['risk_factor'].to_f,
-					:risk_score    => device.attributes['risk_score'].to_f,
-				}
-			end
-			return res
-		else
-			return false
-		end
-	end
-
-	def report_template_listing
-		r = execute(make_xml('ReportTemplateListingRequest', { }))
-
-		if(r.success)
-			res = []
-			r.res.elements.each("//ReportTemplateSummary") do |template|
-				desc = ''
-				template.elements.each("//description") do |ent|
-					desc = ent.text
-				end
-				
-				res << {
-					:template_id   => template.attributes['id'].to_s,
-					:name          => template.attributes['name'].to_s,
-					:description   => desc.to_s
-				}
-			end
-			return res
-		else
-			return false
-		end
-	end	
-
-
-	def console_command(cmd_string)
-		xml = make_xml('ConsoleCommandRequest', {  })
-		cmd = REXML::Element.new('Command')
-		cmd.text = cmd_string
-		xml << cmd
-		
-		r = execute(xml)
-
-		if(r.success)
-			res = ""
-			r.res.elements.each("//Output") do |out|
-				res << out.text.to_s
-			end
-			
-			return res
-		else
-			return false
-		end
-	end	
-
-	def system_information
-		r = execute(make_xml('SystemInformationRequest', { }))
-
-		if(r.success)
-			res = {}
-			r.res.elements.each("//Statistic") do |stat|
-				res[ stat.attributes['name'].to_s ] = stat.text.to_s
-			end
-			
-			return res
-		else
-			return false
-		end
-	end		
-		
-end
-
-# === Description
-# Object that represents a connection to a NeXpose Security Console.
-#
-# === Examples
-#   # Create a new Nexpose Connection on the default port
-#   nsc = Connection.new("10.1.40.10","nxadmin","password")
-#
-#   # Login to NSC and Establish a Session ID
-#   nsc.login()
-#
-#   # Check Session ID
-#   if (nsc.session_id)
-#       puts "Login Successful"
-#   else
-#       puts "Login Failure"
-#   end
-#
-#   # //Logout
-#   logout_success = nsc.logout()
-#   if (! logout_success)
-#       puts "Logout Failure" + "<p>" + nsc.error_msg.to_s
-#   end
-#
-class Connection
-	include XMLUtils
-	include NexposeAPI
-
-	# true if an error condition exists; false otherwise
-	attr_reader :error
-	# Error message string
-	attr_reader :error_msg
-	# The last XML request sent by this object
-	attr_reader :request_xml
-	# The last XML response received by this object
-	attr_reader :response_xml
-	# Session ID of this connection
-	attr_reader :session_id
-	# The hostname or IP Address of the NSC
-	attr_reader :host
-	# The port of the NSC (default is 3780)
-	attr_reader :port
-	# The username used to login to the NSC
-	attr_reader :username
-	# The password used to login to the NSC
-	attr_reader :password
-	# The URL for communication
-	attr_reader :url
-
-	# Constructor for Connection
-	def initialize(ip, user, pass, port = 3780, silo_id = nil)
-		@host = ip
-		@port = port
-		@username = user
-		@password = pass
-		@silo_id = silo_id
-		@session_id = nil
-		@error = false
-		@url = "https://#{@host}:#{@port}/api/API_VERSION/xml"
-	end
-
-	# Establish a new connection and Session ID
-	def login
-		begin
-			login_hash = { 'sync-id' => 0, 'password' => @password, 'user-id' => @username }
-			unless @silo_id.nil?
-				login_hash['silo-id'] = @silo_id
-			end
-			r = execute(make_xml('LoginRequest', login_hash))
-		rescue APIError
-			raise AuthenticationFailed.new(r)
-		end
-		if(r.success)
-			@session_id = r.sid
-			return true
-		end
-	end
-
-	# Logout of the current connection
-	def logout
-		r = execute(make_xml('LogoutRequest', {'sync-id' => 0}))
-		if(r.success)
-			return true
-		end
-		raise APIError.new(r, 'Logout failed')
-	end
-
-	# Execute an API request
-	def execute(xml, version = '1.1')
-		@api_version = version
-		APIRequest.execute(@url,xml.to_s, @api_version)
-	end
-
-	# Download a specific URL
-	def download(url)
-		uri = URI.parse(url)
-		http = Net::HTTP.new(@host, @port)
-		http.use_ssl = true
-		http.verify_mode = OpenSSL::SSL::VERIFY_NONE            # XXX: security issue
-		headers = {'Cookie' => "nexposeCCSessionID=#{@session_id}"}
-		resp, data = http.get(uri.path, headers)
-		data
-	end
-end
-
-# === Description
-# Object that represents a listing of all of the sites available on an NSC.
-#
-# === Example
-#   # Create a new Nexpose Connection on the default port and Login
-#   nsc = Connection.new("10.1.40.10","nxadmin","password")
-#   nsc->login();
-#
-#   # Get Site Listing
-#   sitelisting = SiteListing.new(nsc)
-#
-#   # Enumerate through all of the SiteSummaries
-#   sitelisting.sites.each do |sitesummary|
-#       # Do some operation on each site
-#   end
-#
-class SiteListing
-	# true if an error condition exists; false otherwise
-	attr_reader :error
-	# Error message string
-	attr_reader :error_msg
-	# The last XML request sent by this object
-	attr_reader :request_xml
-	# The last XML response received by this object
-	attr_reader :response_xml
-	# The NSC Connection associated with this object
-	attr_reader :connection
-	# Array containing SiteSummary objects for each site in the connection
-	attr_reader :sites
-	# The number of sites
-	attr_reader :site_count
-
-	# Constructor
-	# SiteListing (connection)
-	def initialize(connection)
-		@sites = []
-
-		@connection = connection
-
-		r = @connection.execute('<SiteListingRequest session-id="' + @connection.session_id.to_s + '"/>')
-
-		if (r.success)
-			parse(r.res)
-		else
-			raise APIError.new(r, "Failed to get site listing")
-		end
-	end
-
-	def parse(r)
-		r.elements.each('SiteListingResponse/SiteSummary') do |s|
-			site_summary = SiteSummary.new(
-				s.attributes['id'].to_s,
-				s.attributes['name'].to_s,
-				s.attributes['description'].to_s,
-				s.attributes['riskfactor'].to_s
-			)
-			@sites.push(site_summary)
-		end
-		@site_count = @sites.length
-	end
-end
-
-# === Description
-# Object that represents the summary of a NeXpose Site.
-#
-class SiteSummary
-	# The Site ID
-	attr_reader :id
-	# The Site Name
-	attr_reader :site_name
-	# A Description of the Site
-	attr_reader :description
-	# User assigned risk multiplier
-	attr_reader :riskfactor
-
-	# Constructor
-	# SiteSummary(id, site_name, description, riskfactor = 1)
-	def initialize(id, site_name, description, riskfactor = 1)
-		@id = id
-		@site_name = site_name
-		@description = description
-		@riskfactor = riskfactor
-	end
-
-	def _set_id(id)
-		@id = id
-	end
-end
-
-# === Description
-# Object that represents a single IP address or an inclusive range of IP addresses. If to is nil then the from field will be used to specify a single IP Address only.
-#
-class IPRange
-	# Start of Range *Required
-	attr_reader :from;
-	# End of Range *Optional (If Null then IPRange is a single IP Address)
-	attr_reader :to;
-
-	def initialize(from, to = nil)
-		@from = from
-		@to = to
-	end
-
-	include Sanitize
-	def to_xml
-		if (to and not to.empty?)
-			return %Q{<range from="#{from}" to="#{to}"/>}
-		else
-			return %Q{<range from="#{from}"/>}
-		end
-	end
-end
-
-# === Description
-# Object that represents a hostname to be added to a site.
-class HostName
-
-	# The hostname
-	attr_reader :hostname
-
-	def initialize(hostname)
-		@hostname = hostname
-	end
-
-	include Sanitize
-	def to_xml
-		"<hostname>#{replace_entities(hostname)}</hostname>"
-	end
-end
-
-# === Description
-# Object that represents the configuration of a Site. This object is automatically created when a new Site object is instantiated.
-#
-class SiteConfig
-	# true if an error condition exists; false otherwise
-	attr_reader :error
-	# Error message string
-	attr_reader :error_msg
-	# The last XML request sent by this object
-	attr_reader :request_xml
-	# The last XML response received by this object
-	attr_reader :response_xml
-	# The NSC Connection associated with this object
-	attr_reader :connection
-	# The Site ID
-	attr_reader :site_id
-	# The Site Name
-	attr_reader :site_name
-	# A Description of the Site
-	attr_reader :description
-	# User assigned risk multiplier
-	attr_reader :riskfactor
-	# Array containing ((IPRange|HostName)*)
-	attr_reader :hosts
-	# Array containing (AdminCredentials*)
-	attr_reader :credentials
-	# Array containing ((SmtpAlera|SnmpAlert|SyslogAlert)*)
-	attr_reader :alerts
-	# ScanConfig object which holds Schedule and ScanTrigger Objects
-	attr_reader :scanConfig
-
-	def initialize()
-		@xml_tag_stack = Array.new()
-		@hosts = Array.new()
-		@credentials = Array.new()
-		@alerts = Array.new()
-		@error = false
-	end
-
-	# Adds a new host to the hosts array
-	def addHost(host)
-		@hosts.push(host)
-	end
-
-	# Adds a new alert to the alerts array
-	def addAlert(alert)
-		@alerts.push(alert)
-	end
-
-	# Adds a new set of credentials to the credentials array
-	def addCredentials(credential)
-		@credentials.push(credential)
-	end
-
-	# TODO
-	def getSiteConfig(connection,site_id)
-		@connection = connection
-		@site_id = site_id
-
-		r = APIRequest.execute(@connection.url,'<SiteConfigRequest session-id="' + @connection.session_id + '" site-id="' + @site_id + '"/>')
-		parse(r.res)
-	end
-
-	def _set_site_id(site_id)
-		@site_id = site_id
-	end
-
-	def _set_site_name(site_name)
-		@site_name = site_name
-	end
-
-	def _set_description(description)
-		@description = description
-	end
-
-	def _set_riskfactor(riskfactor)
-		@riskfactor = riskfactor
-	end
-
-	def _set_scanConfig(scanConfig)
-		@scanConfig = scanConfig
-	end
-
-	def _set_connection(connection)
-		@connection = connection
-	end
-=begin
-<SiteConfigResponse success='1'>
-<Site name='Site1' id='243' description='' riskfactor='1.0'>
-<Hosts>
-<range from='127.0.0.1'/>
-</Hosts>
-<Credentials>
-</Credentials>
-<Alerting>
-</Alerting>
-<ScanConfig configID='243' name='Full audit' configVersion='3' engineID='2' templateID='full-audit'>
-<Schedules>
-</Schedules>
-<ScanTriggers>
-</ScanTriggers>
-</ScanConfig>
-</Site>
-
-=end
-
-	def parse(response)
-		response.elements.each('SiteConfigResponse/Site') do |s|
-			@site_id = s.attributes['id']
-			@site_name = s.attributes['name']
-			@description = s.attributes['description']
-			@riskfactor = s.attributes['riskfactor']
-			s.elements.each('Hosts/range') do |r|
-				@hosts.push(IPRange.new(r.attributes['from'],r.attributes['to']))
-			end
-			s.elements.each('ScanConfig') do |c|
-				@scanConfig = ScanConfig.new(c.attributes['configID'],
-											c.attributes['name'],
-											c.attributes['configVersion'],
-											c.attributes['templateID'])
-				s.elements.each('Schedule') do |schedule|
-					schedule = new Schedule(schedule.attributes["type"], schedule.attributes["interval"], schedule.attributes["start"], schedule.attributes["enabled"])
-					@scanConfig.addSchedule(schedule)
-				end
-			end
-
-			s.elements.each('Alerting/Alert') do |a|
-
-				a.elements.each('smtpAlert') do |smtp|
-					smtp_alert = SmtpAlert.new(a.attributes["name"], smtp.attributes["sender"], smtp.attributes["limitText"], a.attributes["enabled"])
-
-					smtp.elements.each('recipient') do |recipient|
-						smtp_alert.addRecipient(recipient.text)
-					end
-					@alerts.push(smtp_alert)
-				end
-
-				a.elements.each('snmpAlert') do |snmp|
-					snmp_alert = SnmpAlert.new(a.attributes["name"], snmp.attributes["community"], snmp.attributes["server"], a.attributes["enabled"])
-					@alerts.push(snmp_alert)
-				end
-				a.elements.each('syslogAlert') do |syslog|
-					syslog_alert = SyslogAlert.new(a.attributes["name"], syslog.attributes["server"], a.attributes["enabled"])
-					@alerts.push(syslog_alert)
-				end
-
-				a.elements.each('vulnFilter') do |vulnFilter|
-
-					#vulnfilter = new VulnFilter.new(a.attributes["typemask"], a.attributes["severityThreshold"], $attrs["MAXALERTS"])
-					# Pop off the top alert on the stack
-					#$alert = @alerts.pop()
-					# Add the new recipient string to the Alert Object
-					#$alert.setVulnFilter($vulnfilter)
-					# Push the alert back on to the alert stack
-					#array_push($this->alerts, $alert)
-				end
-
-				a.elements.each('scanFilter') do |scanFilter|
-					#<scanFilter scanStop='0' scanFailed='0' scanStart='1'/>
-					#scanfilter = ScanFilter.new(scanFilter.attributes['scanStop'],scanFilter.attributes['scanFailed'],scanFilter.attributes['scanStart'])
-					#alert = @alerts.pop()
-					#alert.setScanFilter(scanfilter)
-					#@alerts.push(alert)
-				end
-			end
-		end
-	end
-end
-
-# === Description
-# Object that represents the scan history of a site.
-#
-class SiteScanHistory
-	# true if an error condition exists; false otherwise
-	attr_reader :error
-	# Error message string
-	attr_reader :error_msg
-	# The last XML request sent by this object
-	attr_reader :request_xml
-	# The last XML response received by this object
-	attr_reader :response_xml
-	# The NSC Connection associated with this object
-	attr_reader :connection
-	# The Site ID
-	attr_reader :site_id
-	# //Array containing (ScanSummary*)
-	attr_reader :scan_summaries
-
-	def initialize(connection, id)
-		@site_id = id
-		@error = false
-		@connection = connection
-		@scan_summaries = Array.new()
-
-		r = @connection.execute('<SiteScanHistoryRequest' + ' session-id="' + @connection.session_id + '" site-id="' + @site_id + '"/>')
-		status = r.success
-	end
-end
-
-# === Description
-# Object that represents a listing of devices for a site or the entire NSC. Note that only devices which are accessible to the account used to create the connection object will be returned. This object is created and populated automatically with the instantiation of a new Site object.
-#
-class SiteDeviceListing
-
-	# true if an error condition exists; false otherwise
-	attr_reader :error
-	# Error message string
-	attr_reader :error_msg
-	# The last XML request sent by this object
-	attr_reader :request_xml
-	# The last XML response received by this object
-	attr_reader :response_xml
-	# The NSC Connection associated with this object
-	attr_reader :connection
-	# The Site ID. 0 if all sites are specified.
-	attr_reader :site_id
-	# //Array of (Device)*
-	attr_reader :devices
-
-	def initialize(connection, site_id = 0)
-
-		@site_id = site_id
-		@error = false
-		@connection = connection
-		@devices = Array.new()
-
-		r = nil
-		if (@site_id)
-			r = @connection.execute('<SiteDeviceListingRequest session-id="' + connection.session_id + '" site-id="' + @site_id + '"/>')
-		else
-			r = @connection.execute('<SiteDeviceListingRequest session-id="' + connection.session_id + '"/>')
-		end
-
-		if(r.success)
-			response.elements.each('SiteDeviceListingResponse/SiteDevices/device') do |d|
-				@devices.push(Device.new(d.attributes['id'],@site_id,d.attributes["address"],d.attributes["riskfactor"],d.attributes['riskscore']))
-			end
-		end
-	end
-end
-
-# === Description
-# Object that represents a site, including the site configuration, scan history, and device listing.
-#
-# === Example
-#   # Create a new Nexpose Connection on the default port and Login
-#   nsc = Connection.new("10.1.40.10","nxadmin","password")
-#   nsc.login()
-#
-#   # Get an Existing Site
-#   site_existing = Site.new(nsc,184)
-#
-#   # Create a New Site, add some hosts, and save it to the NSC
-#   site = Site.new(nsc)
-#   site.setSiteConfig("New Site", "New Site Created in the API")
-#
-#   # Add the hosts
-#   site.site_config.addHost(HostName.new("localhost"))
-#   site.site_config.addHost(IPRange.new("192.168.7.1","192.168.7.255"))
-#   site.site_config.addHost(IPRange.new("10.1.20.30"))
-#
-#   status = site.saveSite()
-#
-class Site
-	# true if an error condition exists; false otherwise
-	attr_reader :error
-	# Error message string
-	attr_reader :error_msg
-	# The last XML request sent by this object
-	attr_reader :request_xml
-	# The last XML response received by this object
-	attr_reader :response_xml
-	# The NSC Connection associated with this object
-	attr_reader :connection
-	# The Site ID
-	# site_id = -1 means create a new site. The NSC will assign a new site_id on SiteSave.
-	attr_reader :site_id
-	# A summary overview of this site
-	# SiteSummary Object
-	attr_reader :site_summary
-	# The configuration of this site
-	# SiteConfig Object
-	attr_reader :site_config
-	# The device listing for this site
-	# SiteDeviceListing Object
-	attr_reader :site_device_listing
-	# The scan history of this site
-	# SiteScanHistory Object
-	attr_reader :site_scan_history
-
-	def initialize(connection, site_id = -1)
-		@error = false
-		@connection = connection
-		@site_id = site_id
-
-		# If site_id > 0 then get SiteConfig
-		if (@site_id.to_i > 0)
-			# Create new SiteConfig object
-			@site_config = SiteConfig.new()
-			# Populate SiteConfig Obect with Data from the NSC
-			@site_config.getSiteConfig(@connection,@site_id)
-			@site_summary = SiteSummary.new(@site_id, @site_config.site_name, @site_config.description, @site_config.riskfactor)
-			@site_scan_history = SiteScanHistory.new(@connection,@site_id)
-			@site_device_listing = SiteDeviceListing.new(@connection,@site_id)
-
-		else
-			# Just in case user enters a number > -1 or = 0
-			@site_id = -1
-
-			@site_config = SiteConfig.new()
-			setSiteConfig("New Site " + rand(999999999999).to_s,"")
-			@site_summary = nil
-
-		end
-
-	end
-
-	# Creates a new site summary
-	def setSiteSummary(site_name, description, riskfactor = 1)
-		@site_summary = SiteSummary.new(-1,site_name,description,riskfactor)
-
-	end
-
-	# Creates a new site configuration
-	def setSiteConfig(site_name, description, riskfactor = 1)
-		setSiteSummary(site_name,description,riskfactor)
-		@site_config = SiteConfig.new()
-		@site_config._set_site_id(-1)
-		@site_config._set_site_name(site_name)
-		@site_config._set_description(description)
-		@site_config._set_riskfactor(riskfactor)
-		@site_config._set_scanConfig(ScanConfig.new(-1,"tmp","full-audit"))
-		@site_config._set_connection(@connection)
-
-	end
-
-	# Initiates a scan of this site. If successful returns scan_id and engine_id in an associative array. Returns false if scan is unsuccessful.
-	def scanSite()
-		r = @connection.execute('<SiteScanRequest session-id="' + "#{@connection.session_id}" + '" site-id="' + "#{@site_id}" + '"/>')
-		if(r.success)
-			res = {}
-			r.res.elements.each('//Scan/') do |s|
-				res[:scan_id]   = s.attributes['scan-id']
-				res[:engine_id] = s.attributes['engine-id']
-			end
-			return res
-		else
-			return false
-		end
-	end
-
-	# Saves this site in the NSC
-	def saveSite()
-		r = @connection.execute('<SiteSaveRequest session-id="' + @connection.session_id + '">' + getSiteXML() + ' </SiteSaveRequest>')
-		if (r.success)
-			@site_id =  r.attributes['site-id']
-			@site_config._set_site_id(@site_id)
-			@site_config.scanConfig._set_configID(@site_id)
-			@site_config.scanConfig._set_name(@site_id)
-			return true
-		else
-			return false
-		end
-	end
-
-	def deleteSite()
-		r = @connection.execute('<SiteDeleteRequest session-id="' + @connection.session_id.to_s + '" site-id="' + @site_id + '"/>')
-		r.success
-	end
-
-
-	def printSite()
-		puts "Site ID: " + @site_summary.id
-		puts "Site Name: " + @site_summary.site_name
-		puts "Site Description: " + @site_summary.description
-		puts "Site Risk Factor: " + @site_summary.riskfactor
-	end
-
-	def getSiteXML()
-
-		xml = '<Site id="' + "#{@site_config.site_id}" + '" name="' + "#{@site_config.site_name}" + '" description="' + "#{@site_config.description}" + '" riskfactor="' + "#{@site_config.riskfactor}" + '">'
-
-		xml << ' <Hosts>'
-		@site_config.hosts.each do |h|
-			xml << h.to_xml if h.respond_to? :to_xml
-		end
-		xml << '</Hosts>'
-
-		xml << '<Credentials>'
-		@site_config.credentials.each do |c|
-			xml << c.to_xml if c.respond_to? :to_xml
-		end
-		xml << ' </Credentials>'
-
-		xml << ' <Alerting>'
-		@site_config.alerts.each do |a|
-			xml << a.to_xml if a.respond_to? :to_xml
-		end
-		xml << ' </Alerting>'
-
-		xml << ' <ScanConfig configID="' + "#{@site_config.scanConfig.configID}" + '" name="' + "#{@site_config.scanConfig.name}" + '" templateID="' + "#{@site_config.scanConfig.templateID}" + '" configVersion="' + "#{@site_config.scanConfig.configVersion}" + '">'
-
-		xml << ' <Schedules>'
-		@site_config.scanConfig.schedules.each do |s|
-			xml << ' <Schedule enabled="' + s.enabled + '" type="' + s.type + '" interval="' + s.interval + '" start="' + s.start + '"/>'
-		end
-		xml << ' </Schedules>'
-
-		xml << ' <ScanTriggers>'
-		@site_config.scanConfig.scanTriggers.each do |s|
-
-			if (s.class.to_s == "Nexpose::AutoUpdate")
-				xml << ' <autoUpdate enabled="' + s.enabled + '" incremental="' + s.incremental + '"/>'
-			end
-		end
-
-		xml << ' </ScanTriggers>'
-
-		xml << ' </ScanConfig>'
-
-		xml << ' </Site>'
-
-		return xml
-	end
-end
-
-# === Description
-# Object that represents administrative credentials to be used during a scan. When retrived from an existing site configuration the credentials will be returned as a security blob and can only be passed back as is during a Site Save operation. This object can only be used to create a new set of credentials.
-#
-class AdminCredentials
-	# Security blob for an existing set of credentials
-	attr_reader :securityblob
-	# Designates if this object contains user defined credentials or a security blob
-	attr_reader :isblob
-	# The service for these credentials. Can be All.
-	attr_reader :service
-	# The host for these credentials. Can be Any.
-	attr_reader :host
-	# The port on which to use these credentials.
-	attr_reader :port
-	# The user id or username
-	attr_reader :userid
-	# The password
-	attr_reader :password
-	# The realm for these credentials
-	attr_reader :realm
-
-
-	def initialize(isblob = false)
-		@isblob = isblob
-	end
-
-	# Sets the credentials information for this object.
-	def setCredentials(service, host, port, userid, password, realm)
-		@isblob = false
-		@securityblob = nil
-		@service = service
-		@host = host
-		@port = port
-		@userid = userid
-		@password = password
-		@realm = realm
-	end
-
-	# TODO: add description
-	def setService(service)
-		@service = service
-	end
-
-	def setHost(host)
-		@host = host
-	end
-
-	# TODO: add description
-	def setBlob(securityblob)
-		@isblob = true
-		@securityblob = securityblob
-	end
-
-	include Sanitize
-	def to_xml
-		xml = ''
-		xml << '<adminCredentials'
-		xml << %Q{ service="#{replace_entities(service)}"} if (service)
-		xml << %Q{ userid="#{replace_entities(userid)}"} if (userid)
-		xml << %Q{ password="#{replace_entities(password)}"} if (password)
-		xml << %Q{ realm="#{replace_entities(realm)}"} if (realm)
-		xml << %Q{ host="#{replace_entities(host)}"} if (host)
-		xml << %Q{ port="#{replace_entities(port)}"} if (port)
-		xml << '>'
-		xml << replace_entities(securityblob) if (isblob)
-		xml << '</adminCredentials>'
-
-		xml
-	end
-end
-
-
-# === Description
-# Object that represents an SMTP (Email) Alert.
-#
-class SmtpAlert
-	# A unique name for this alert
-	attr_reader :name
-	# If this alert is enabled or not
-	attr_reader :enabled
-	# The email address of the sender
-	attr_reader :sender
-	# Limit the text for mobile devices
-	attr_reader :limitText
-	# Array containing Strings of email addresses
-	# Array of strings with the email addresses of the intended recipients
-	attr_reader :recipients
-	# The vulnerability filter to trigger the alert
-	attr_reader :vulnFilter
-	# The alert type
-	attr_reader :type
-
-	def initialize(name, sender, limitText, enabled = 1)
-		@type = :smtp
-		@name = name
-		@sender = sender
-		@enabled = enabled
-		@limitText = limitText
-		@recipients = Array.new()
-		# Sets default vuln filter - All Events
-		setVulnFilter(VulnFilter.new("50790400",1))
-	end
-
-	# Adds a new Recipient to the recipients array
-	def addRecipient(recipient)
-		@recipients.push(recipient)
-	end
-
-	# Sets the Vulnerability Filter for this alert.
-	def setVulnFilter(vulnFilter)
-		@vulnFilter = vulnFilter
-	end
-
-	include Sanitize
-	def to_xml
-		xml = "<smtpAlert"
-		xml << %Q{ name="#{replace_entities(name)}"}
-		xml << %Q{ enabled="#{replace_entities(enabled)}"}
-		xml << %Q{ sender="#{replace_entities(sender)}"}
-		xml << %Q{ limitText="#{replace_entities(limitText)}">}
-		recipients.each do |recpt|
-			xml << "<recipient>#{replace_entities(recpt)}</recipient>"
-		end
-		xml << vulnFilter.to_xml
-		xml << "</smtpAlert>"
-		xml
-	end
-end
-
-# === Description
-# Object that represents an SNMP Alert.
-#
-class SnmpAlert
-
-	# A unique name for this alert
-	attr_reader :name
-	# If this alert is enabled or not
-	attr_reader :enabled
-	# The community string
-	attr_reader :community
-	# The SNMP server to sent this alert
-	attr_reader :server
-	# The vulnerability filter to trigger the alert
-	attr_reader :vulnFilter
-	# The alert type
-	attr_reader :type
-
-	def initialize(name, community, server, enabled = 1)
-		@type = :snmp
-		@name = name
-		@community = community
-		@server = server
-		@enabled = enabled
-		# Sets default vuln filter - All Events
-		setVulnFilter(VulnFilter.new("50790400",1))
-	end
-
-	# Sets the Vulnerability Filter for this alert.
-	def setVulnFilter(vulnFilter)
-		@vulnFilter = vulnFilter
-	end
-
-	include Sanitize
-	def to_xml
-		xml = "<snmpAlert"
-		xml << %Q{ name="#{replace_entities(name)}"}
-		xml << %Q{ enabled="#{replace_entities(enabled)}"}
-		xml << %Q{ community="#{replace_entities(community)}"}
-		xml << %Q{ server="#{replace_entities(server)}">}
-		xml << vulnFilter.to_xml
-		xml << "</snmpAlert>"
-		xml
-	end
-
-end
-
-# === Description
-# Object that represents a Syslog Alert.
-#
-class SyslogAlert
-
-	# A unique name for this alert
-	attr_reader :name
-	# If this alert is enabled or not
-	attr_reader :enabled
-	# The Syslog server to sent this alert
-	attr_reader :server
-	# The vulnerability filter to trigger the alert
-	attr_reader :vulnFilter
-	# The alert type
-	attr_reader :type
-
-	def initialize(name, server, enabled = 1)
-		@type = :syslog
-		@name = name
-		@server = server
-		@enabled = enabled
-		# Sets default vuln filter - All Events
-		setVulnFilter(VulnFilter.new("50790400",1))
-
-	end
-
-	# Sets the Vulnerability Filter for this alert.
-	def setVulnFilter(vulnFilter)
-		@vulnFilter = vulnFilter
-	end
-
-	include Sanitize
-	def to_xml
-		xml = "<syslogAlert"
-		xml << %Q{ name="#{replace_entities(name)}"}
-		xml << %Q{ enabled="#{replace_entities(enabled)}"}
-		xml << %Q{ server="#{replace_entities(server)}">}
-		xml << vulnFilter.to_xml
-		xml << "</syslogAlert>"
-		xml
-	end
-
-end
-
-# TODO: review
-# <scanFilter scanStop='0' scanFailed='0' scanStart='1'/>
-# === Description
-#
-class ScanFilter
-
-	attr_reader :scanStop
-	attr_reader :scanFailed
-	attr_reader :scanStart
-
-	def initialize(scanstop, scanFailed, scanStart)
-
-		@scanStop = scanStop
-		@scanFailed = scanFailed
-		@scanStart = scanStart
-
-	end
-
-end
-
-# TODO: review
-# === Description
-#
-class VulnFilter
-
-	attr_reader :typeMask
-	attr_reader :maxAlerts
-	attr_reader :severityThreshold
-
-	def initialize(typeMask, severityThreshold, maxAlerts = -1)
-		@typeMask = typeMask
-		@maxAlerts = maxAlerts
-		@severityThreshold = severityThreshold
-	end
-
-	include Sanitize
-	def to_xml
-		xml = "<vulnFilter "
-		xml << %Q{ typeMask="#{replace_entities(typeMask)}"}
-		xml << %Q{ maxAlerts="#{replace_entities(maxAlerts)}"}
-		xml << %Q{ severityThreshold="#{replace_entities(severityThreshold)}"}
-		xml << "/>"
-
-		xml
-	end
-
-end
-
-# TODO add engineID
-# === Description
-# Object that represents the scanning configuration for a Site.
-#
-class ScanConfig
-	# A unique ID for this scan configuration
-	attr_reader :configID
-	# The name of the scan template
-	attr_reader :name
-	# The ID of the scan template used full-audit, exhaustive-audit, web-audit, dos-audit, internet-audit, network-audit
-	attr_reader :templateID
-	# The configuration version (default is 2)
-	attr_reader :configVersion
-	# Array of (Schedule)*
-	attr_reader :schedules
-	# Array of (ScanTrigger)*
-	attr_reader :scanTriggers
-
-	def initialize(configID, name, templateID, configVersion = 2)
-
-		@configID = configID
-		@name = name
-		@templateID = templateID
-		@configVersion = configVersion
-		@schedules = Array.new()
-		@scanTriggers = Array.new()
-
-	end
-
-	# Adds a new Schedule for this ScanConfig
-	def addSchedule(schedule)
-		@schedules.push(schedule)
-	end
-
-	# Adds a new ScanTrigger to the scanTriggers array
-	def addScanTrigger(scanTrigger)
-		@scanTriggers.push(scanTrigger)
-	end
-
-	def _set_configID(configID)
-		@configID = configID
-	end
-
-	def _set_name(name)
-		@name = name
-	end
-
-end
-
-# === Description
-# Object that holds a scan schedule
-#
-class Schedule
-	# Type of Schedule (daily|hourly|monthly|weekly)
-	attr_reader :type
-	# The schedule interval
-	attr_reader :interval
-	# The date and time to start the first scan
-	attr_reader :start
-	# Enable or disable this schedule
-	attr_reader :enabled
-	# The date and time to disable to schedule. If null then the schedule will run forever.
-	attr_reader :notValidAfter
-	# Scan on the same date each time
-	attr_reader :byDate
-
-	def initialize(type, interval, start, enabled = 1)
-
-		@type = type
-		@interval = interval
-		@start = start
-		@enabled = enabled
-
-	end
-
-
-
-end
-
-# === Description
-# Object that holds an event that triggers the start of a scan.
-#
-class ScanTrigger
-	# Type of Trigger (AutoUpdate)
-	attr_reader :type
-	# Enable or disable this scan trigger
-	attr_reader :enabled
-	# Sets the trigger to start an incremental scan or a full scan
-	attr_reader :incremental
-
-	def initialize(type, incremental, enabled = 1)
-
-		@type = type
-		@incremental = incremental
-		@enabled = enabled
-
-	end
-
-end
-
-# === Description
-# Object that represents a single device in an NSC.
-#
-class Device
-
-	# A unique device ID (assigned by the NSC)
-	attr_reader :id
-	# The site ID of this devices site
-	attr_reader :site_id
-	# IP Address or Hostname of this device
-	attr_reader :address
-	# User assigned risk multiplier
-	attr_reader :riskfactor
-	# NeXpose risk score
-	attr_reader :riskscore
-
-	def initialize(id, site_id, address, riskfactor=1, riskscore=0)
-		@id = id
-		@site_id = site_id
-		@address = address
-		@riskfactor = riskfactor
-		@riskscore = riskscore
-
-	end
-
-end
-
-
-# === Description
-# Object that represents a summary of a scan.
-#
-class ScanSummary
-	# The Scan ID of the Scan
-	attr_reader :scan_id
-	# The Engine ID used to perform the scan
-	attr_reader :engine_id
-	# TODO: add description
-	attr_reader :name
-	# The scan start time
-	attr_reader :startTime
-	# The scan finish time
-	attr_reader :endTime
-	# The scan status (running|finished|stopped|error| dispatched|paused|aborted|uknown)
-	attr_reader :status
-	# The number of pending tasks
-	attr_reader :tasks_pending
-	# The number of active tasks
-	attr_reader :tasks_active
-	# The number of completed tasks
-	attr_reader :tasks_completed
-	# The number of "live" nodes
-	attr_reader :nodes_live
-	# The number of "dead" nodes
-	attr_reader :nodes_dead
-	# The number of filtered nodes
-	attr_reader :nodes_filtered
-	# The number of unresolved nodes
-	attr_reader :nodes_unresolved
-	# The number of "other" nodes
-	attr_reader :nodes_other
-	# Confirmed vulnerabilities found (indexed by severity)
-	# Associative array, indexed by severity
-	attr_reader :vuln_exploit
-	# Unconfirmed vulnerabilities found (indexed by severity)
-	# Associative array, indexed by severity
-	attr_reader :vuln_version
-	# Not vulnerable checks run (confirmed)
-	attr_reader :not_vuln_exploit
-	# Not vulnerable checks run (unconfirmed)
-	attr_reader :not_vuln_version
-	# Vulnerability check errors
-	attr_reader :vuln_error
-	# Vulnerability checks disabled
-	attr_reader :vuln_disabled
-	# Vulnerability checks other
-	attr_reader :vuln_other
-
-	# Constructor
-	# ScanSummary(can_id, $engine_id, $name, tartTime, $endTime, tatus)
-	def initialize(scan_id, engine_id, name, startTime, endTime, status)
-
-		@scan_id = scan_id
-		@engine_id = engine_id
-		@name = name
-		@startTime = startTime
-		@endTime = endTime
-		@status = status
-
-	end
-
-end
-
-# TODO
-# === Description
-# Object that represents the overview statistics for a particular scan.
-#
-# === Examples
-#
-#   # Create a new Nexpose Connection on the default port and Login
-#   nsc = Connection.new("10.1.40.10","nxadmin","password")
-#   nsc.login()
-#
-#   # Get a Site (Site ID = 12) from the NSC
-#   site = new Site(nsc,12)
-#
-#   # Start a Scan of this site and pause for 1 minute
-#   scan1 = site.scanSite()
-#   sleep(60)
-#
-#   # Get the Scan Statistics for this scan
-#   scanStatistics = new ScanStatistics(nsc,scan1["scan_id"])
-#
-#   # Print out number of confirmed vulnerabilities with a 10 severity
-#   puts scanStatistics.scansummary.vuln_exploit[10]
-#
-#   # Print out the number of pending tasks left in the scan
-#   puts scanStatistics.scan_summary.tasks_pending
-#
-class ScanStatistics
-	# true if an error condition exists; false otherwise
-	attr_reader :error
-	# Error message string
-	attr_reader :error_msg
-	# The last XML request sent by this object
-	attr_reader :request_xml
-	# The last XML response received by this object
-	attr_reader :reseponse_xml
-	# The Scan ID
-	attr_reader :scan_id
-	# The ScanSummary of the scan
-	attr_reader :scan_summary
-	# The NSC Connection associated with this object
-	attr_reader :connection
-
-	# Vulnerability checks other
-	attr_reader :vuln_other
-	def initialize(connection, scan_id)
-		@error = false
-		@connection = connection
-		@scan_id = scan_id
-	end
-end
-
-# ==== Description
-# Object that represents a listing of all of the scan engines available on to an NSC.
-#
-class EngineListing
-	# true if an error condition exists; false otherwise
-	attr_reader :error
-	# Error message string
-	attr_reader :error_msg
-	# The last XML request sent by this object
-	attr_reader :request_xml
-	# The last XML response received by this object
-	attr_reader :response_xml
-	# The NSC Connection associated with this object
-	attr_reader :connection
-	# Array containing (EngineSummary*)
-	attr_reader :engines
-	# The number of scan engines
-	attr_reader :engine_count
-
-	# Constructor
-	# EngineListing (connection)
-	def initialize(connection)
-		@connection = connection
-		@engines = []
-		@engine_count = 0
-		@error = false
-		r = @connection.execute('<EngineListingRequest session-id="' + @connection.session_id + '"/>', '1.2')
-
-		if (r.success)
-			r.res.elements.each('EngineListingResponse/EngineSummary') do |v|
-				@engines.push(EngineSummary.new(v.attributes['id'], v.attributes['name'], v.attributes['address'],
-												v.attributes['port'], v.attributes['status']))
-			end
-		else
-			@error = true
-			@error_msg = 'EngineListingRequest Parse Error'
-		end
-		@engine_count = @engines.length
-	end
-end
-
-# ==== Description
-# Object that represents the summary of a scan engine.
-#
-# ==== Examples
-#
-#   # Create a new Nexpose Connection on the default port and Login
-#   nsc = Connection.new("10.1.40.10","nxadmin","password")
-#   nsc.login()
-#
-#   # Get the engine listing for the connection
-#   enginelisting = EngineListing.new(nsc)
-#
-#   # Print out the status of the first scan engine
-#   puts enginelisting.engines[0].status
-#
-class EngineSummary
-	# A unique ID that identifies this scan engine
-	attr_reader :id
-	# The name of this scan engine
-	attr_reader :name
-	# The hostname or IP address of the engine
-	attr_reader :address
-	# The port there the engine is listening
-	attr_reader :port
-	# The engine status (active|pending-auth| incompatible|not-responding|unknown)
-	attr_reader :status
-
-	# Constructor
-	# EngineSummary(id, name, address, port, status)
-	def initialize(id, name, address, port, status)
-		@id = id
-		@name = name
-		@address = address
-		@port = port
-		@status = status
-	end
-
-end
-
-
-# TODO
-class EngineActivity
-	# true if an error condition exists; false otherwise
-	attr_reader :error
-	# Error message string
-	attr_reader :error_msg
-	# The last XML request sent by this object
-	attr_reader :request_xml
-	# The last XML response received by this object
-	attr_reader :response_xml
-	# The NSC Connection associated with this object
-	attr_reader :connection
-	# The Engine ID
-	attr_reader :engine_id
-	# Array containing (ScanSummary*)
-	attr_reader :scan_summaries
-
-
-end
-
-# === Description
-# Object that represents a listing of all of the vulnerabilities in the vulnerability database
-#
-class VulnerabilityListing
-
-	# true if an error condition exists; false otherwise
-	attr_reader :error
-	# Error message string
-	attr_reader :error_msg
-	# The last XML request sent by this object
-	attr_reader :request_xml
-	# The last XML response received by this object
-	attr_reader :response_xml
-	# The NSC Connection associated with this object
-	attr_reader :connection
-	# Array containing (VulnerabilitySummary*)
-	attr_reader :vulnerability_summaries
-	# The number of vulnerability definitions
-	attr_reader :vulnerability_count
-
-	# Constructor
-	# VulnerabilityListing(connection)
-	def initialize(connection)
-		@error = false
-		@vulnerability_summaries = []
-		@connection = connection
-
-		r = @connection.execute('<VulnerabilityListingRequest session-id="' + @connection.session_id + '"/>')
-
-		if (r.success)
-			r.res.elements.each('VulnerabilityListingResponse/VulnerabilitySummary') do |v|
-				@vulnerability_summaries.push(VulnerabilitySummary.new(v.attributes['id'],v.attributes["title"],v.attributes["severity"]))
-			end
-		else
-			@error = true
-			@error_msg = 'VulnerabilitySummaryRequest Parse Error'
-		end
-		@vulnerability_count = @vulnerability_summaries.length
-	end
-end
-
-# === Description
-# Object that represents the summary of an entry in the vulnerability database
-#
-class VulnerabilitySummary
-
-	# The unique ID string for this vulnerability
-	attr_reader :id
-	# The title of this vulnerability
-	attr_reader :title
-	# The severity of this vulnerability (1 – 10)
-	attr_reader :severity
-
-	# Constructor
-	# VulnerabilitySummary(id, title, severity)
-	def initialize(id, title, severity)
-		@id = id
-		@title = title
-		@severity = severity
-
-	end
-
-end
-
-# === Description
-#
-class Reference
-
-	attr_reader :source
-	attr_reader :reference
-
-	def initialize(source, reference)
-		@source = source
-		@reference = reference
-	end
-end
-
-# === Description
-# Object that represents the details for an entry in the vulnerability database
-#
-class VulnerabilityDetail
-	# true if an error condition exists; false otherwise
-	attr_reader :error
-	# Error message string
-	attr_reader :error_msg
-	# The last XML request sent by this object
-	attr_reader :request_xml
-	# The last XML response received by this object
-	attr_reader :response_xml
-	# The NSC Connection associated with this object
-	attr_reader :connection
-	# The unique ID string for this vulnerability
-	attr_reader :id
-	# The title of this vulnerability
-	attr_reader :title
-	# The severity of this vulnerability (1 – 10)
-	attr_reader :severity
-	# The pciSeverity of this vulnerability
-	attr_reader :pciSeverity
-	# The CVSS score of this vulnerability
-	attr_reader :cvssScore
-	# The CVSS vector of this vulnerability
-	attr_reader :cvssVector
-	# The date this vulnerability was published
-	attr_reader :published
-	# The date this vulnerability was added to NeXpose
-	attr_reader :added
-	# The last date this vulnerability was modified
-	attr_reader :modified
-	# The HTML Description of this vulnerability
-	attr_reader :description
-	# External References for this vulnerability
-	# Array containing (Reference)
-	attr_reader :references
-	# The HTML Solution for this vulnerability
-	attr_reader :solution
-
-	# Constructor
-	# VulnerabilityListing(connection,id)
-	def initialize(connection, id)
-
-		@error = false
-		@connection = connection
-		@id = id
-		@references = []
-
-		r = @connection.execute('<VulnerabilityDetailsRequest session-id="' + @connection.session_id + '" vuln-id="' + @id + '"/>')
-
-		if (r.success)
-			r.res.elements.each('VulnerabilityDetailsResponse/Vulnerability') do |v|
-				@id = v.attributes['id']
-				@title = v.attributes["title"]
-				@severity = v.attributes["severity"]
-				@pciSeverity = v.attributes['pciSeverity']
-				@cvssScore = v.attributes['cvssScore']
-				@cvssVector = v.attributes['cvssVector']
-				@published = v.attributes['published']
-				@added = v.attributes['added']
-				@modified = v.attributes['modified']
-
-				v.elements.each('description') do |d|
-					@description = d.to_s.gsub(/\<\/?description\>/i, '')
-				end
-
-				v.elements.each('solution') do |s|
-					@solution = s.to_s.gsub(/\<\/?solution\>/i, '')
-				end
-
-				v.elements.each('references/reference') do |r|
-					@references.push(Reference.new(r.attributes['source'],r.text))
-				end
-			end
-		else
-			@error = true
-			@error_msg = 'VulnerabilitySummaryRequest Parse Error'
-		end
-
-	end
-end
-
-# === Description
-# Object that represents the summary of a Report Configuration.
-#
-class ReportConfigSummary
-	# The Report Configuration ID
-	attr_reader :id
-	# A unique name for the Report
-	attr_reader :name
-	# The report format
-	attr_reader :format
-	# The date of the last report generation
-	attr_reader :last_generated_on
-	# Relative URI of the last generated report
-	attr_reader :last_generated_uri
-
-	# Constructor
-	# ReportConfigSummary(id, name, format, last_generated_on, last_generated_uri)
-	def initialize(id, name, format, last_generated_on, last_generated_uri)
-
-		@id = id
-		@name = name
-		@format = format
-		@last_generated_on = last_generated_on
-		@last_generated_uri = last_generated_uri
-
-	end
-
-end
-
-# === Description
-# Object that represents the schedule on which to automatically generate new reports.
-class ReportHistory
-
-	# true if an error condition exists; false otherwise
-	attr_reader :error
-	# Error message string
-	attr_reader :error_msg
-	# The last XML request sent by this object
-	attr_reader :request_xml
-	# The last XML response received by this object
-	attr_reader :response_xml
-	# The NSC Connection associated with this object
-	attr_reader :connection
-	# The report definition (report config) ID
-	# Report definition ID
-	attr_reader :config_id
-	# Array (ReportSummary*)
-	attr_reader :report_summaries
-
-
-	def initialize(connection, config_id)
-
-		@error = false
-		@connection = connection
-		@config_id = config_id
-		@report_summaries = []
-
-		reportHistory_request = APIRequest.new('<ReportHistoryRequest session-id="' + "#{connection.session_id}" + '" reportcfg-id="' + "#{@config_id}" + '"/>',@connection.geturl())
-		reportHistory_request.execute()
-		@response_xml = reportHistory_request.response_xml
-		@request_xml = reportHistory_request.request_xml
-
-	end
-
-	def xml_parse(response)
-		response = REXML::Document.new(response.to_s)
-		status =  response.root.attributes['success']
-		if (status == '1')
-			response.elements.each('ReportHistoryResponse/ReportSummary') do |r|
-				@report_summaries.push(ReportSummary.new(r.attributes["id"], r.attributes["cfg-id"], r.attributes["status"], r.attributes["generated-on"],r.attributes['report-uri']))
-			end
-		else
-			@error = true
-			@error_msg = 'Error ReportHistoryReponse'
-		end
-	end
-
-end
-
-# === Description
-# Object that represents the summary of a single report.
-class ReportSummary
-
-	# The Report ID
-	attr_reader :id
-	# The Report Configuration ID
-	attr_reader :cfg_id
-	# The status of this report
-	# available | generating | failed
-	attr_reader :status
-	# The date on which this report was generated
-	attr_reader :generated_on
-	# The relative URI of the report
-	attr_reader :report_uri
-
-	def initialize(id, cfg_id, status, generated_on, report_uri)
-
-		@id = id
-		@cfg_id = cfg_id
-		@status = status
-		@generated_on = generated_on
-		@report_uri = report_uri
-
-	end
-
-end
-
-# === Description
-#
-	class ReportAdHoc
-		include XMLUtils
-
-		attr_reader :error
-		attr_reader :error_msg
-		attr_reader :connection
-		# Report Template ID strong e.g. full-audit
-		attr_reader :template_id
-		# pdf|html|xml|text|csv|raw-xml
-		attr_reader :format
-		# Array of (ReportFilter)*
-		attr_reader :filters
-		attr_reader :request_xml
-		attr_reader :response_xml
-		attr_reader :report_decoded
-
-
-		def initialize(connection, template_id = 'full-audit', format = 'raw-xml')
-
-			@error = false
-			@connection = connection
-			@filters = Array.new()
-			@template_id = template_id
-			@format = format
-
-		end
-
-		def addFilter(filter_type, id)
-
-			# filter_type can be site|group|device|scan
-			# id is the ID number. For scan, you can use 'last' for the most recently run scan
-			filter = ReportFilter.new(filter_type, id)
-			filters.push(filter)
-
-		end
-
-		def generate()
-			request_xml = '<ReportAdhocGenerateRequest session-id="' + @connection.session_id + '">'
-			request_xml += '<AdhocReportConfig template-id="' + @template_id + '" format="' + @format + '">'
-			request_xml += '<Filters>'
-			@filters.each do |f|
-				request_xml += '<filter type="' + f.type + '" id="'+ f.id.to_s + '"/>'
-			end
-			request_xml += '</Filters>'
-			request_xml += '</AdhocReportConfig>'
-			request_xml += '</ReportAdhocGenerateRequest>'
-
-			ad_hoc_request = APIRequest.new(request_xml, @connection.url)
-			ad_hoc_request.execute()
-
-			content_type_response = ad_hoc_request.raw_response.header['Content-Type']
-			if content_type_response =~ /multipart\/mixed;\s*boundary=([^\s]+)/
-				# NeXpose sends an incorrect boundary format which breaks parsing
-				# Eg: boundary=XXX; charset=XXX
-				# Fix by removing everything from the last semi-colon onward
-				last_semi_colon_index = content_type_response.index(/;/, content_type_response.index(/boundary/))
-				content_type_response = content_type_response[0, last_semi_colon_index]
-
-				data = "Content-Type: " + content_type_response + "\r\n\r\n" + ad_hoc_request.raw_response_data
-				doc = Rex::MIME::Message.new data
-				doc.parts.each do |part|
-					if /.*base64.*/ =~ part.header.to_s
-						return parse_xml(part.content.unpack("m*")[0])
-					end
-				end
-			end
-		end
-
-	end
-
-# === Description
-# Object that represents the configuration of a report definition.
-#
-class ReportConfig
-
-	# true if an error condition exists; false otherwise
-	attr_reader :error
-	# Error message string
-	attr_reader :error_msg
-	# The last XML request sent by this object
-	attr_reader :request_xml
-	# The last XML response received by this object
-	attr_reader :response_xml
-	# The NSC Connection associated with this object
-	attr_reader :connection
-	# The ID for this report definition
-	attr_reader :config_id
-	# A unique name for this report definition
-	attr_reader :name
-	# The template ID used for this report definition
-	attr_reader :template_id
-	# html, db, txt, xml, raw-xml, csv, pdf
-	attr_reader :format
-	# XXX new
-	attr_reader :timezone
-	# XXX new
-	attr_reader :owner
-	# Array of (ReportFilter)* - The Sites, Asset Groups, or Devices to run the report against
-	attr_reader :filters
-	# Automatically generate a new report at the conclusion of a scan
-	# 1 or 0
-	attr_reader :generate_after_scan
-	# Schedule to generate reports
-	# ReportSchedule Object
-	attr_reader :schedule
-	# Store the reports on the server
-	# 1 or 0
-	attr_reader :storeOnServer
-	# Location to store the report on the server
-	attr_reader :store_location
-	# Form to send the report via email
-	# "file", "zip", "url", or NULL (don’t send email)
-	attr_reader :email_As
-	# Send the Email to all Authorized Users
-	# boolean - Send the Email to all Authorized Users
-	attr_reader :email_to_all
-	# Array containing the email addresses of the recipients
-	attr_reader :email_recipients
-	# IP Address or Hostname of SMTP Relay Server
-	attr_reader :smtp_relay_server
-	# Sets the FROM field of the Email
-	attr_reader :sender
-	# TODO
-	attr_reader :db_export
-	# TODO
-	attr_reader :csv_export
-	# TODO
-	attr_reader :xml_export
-
-
-	def initialize(connection, config_id = -1)
-
-		@error = false
-		@connection = connection
-		@config_id = config_id
-		@xml_tag_stack = Array.new()
-		@filters = Array.new()
-		@email_recipients = Array.new()
-		@name = "New Report " + rand(999999999).to_s
-
-		r = @connection.execute('<ReportConfigRequest session-id="' + @connection.session_id.to_s + '" reportcfg-id="' + @config_id.to_s + '"/>')
-		if (r.success)
-			r.res.elements.each('ReportConfigResponse/ReportConfig') do |r|
-				@name = r.attributes['name']
-				@format = r.attributes['format']
-				@timezone = r.attributes['timezone']
-				@id = r.attributes['id']
-				@template_id = r.attributes['template-id']
-				@owner = r.attributes['owner']
-			end
-		else
-			@error = true
-			@error_msg = 'Error ReportHistoryReponse'
-		end
-	end
-
-	# === Description
-	# Generate a new report on this report definition. Returns the new report ID.
-	def generateReport(debug = false)
-		return generateReport(@connection, @config_id, debug)
-	end
-
-	# === Description
-	# Save the report definition to the NSC.
-	# Returns the config-id.
-	def saveReport()
-		r = @connection.execute('<ReportSaveRequest session-id="' + @connection.session_id.to_s + '">' + getXML().to_s + ' </ReportSaveRequest>')
-		if(r.success)
-			@config_id = r.attributes['reportcfg-id']
-			return true
-		end
-		return false
-	end
-
-	# === Description
-	# Adds a new filter to the report config
-	def addFilter(filter_type, id)
-		filter = ReportFilter.new(filter_type,id)
-		@filters.push(filter)
-	end
-
-	# === Description
-	# Adds a new email recipient
-	def addEmailRecipient(recipient)
-		@email_recipients.push(recipient)
-	end
-
-	# === Description
-	# Sets the schedule for this report config
-	def setSchedule(schedule)
-		@schedule = schedule
-	end
-
-	def getXML()
-
-		xml = '<ReportConfig id="' + @config_id.to_s + '" name="' + @name.to_s + '" template-id="' + @template_id.to_s + '" format="' + @format.to_s + '">'
-
-		xml += ' <Filters>'
-
-		@filters.each do |f|
-			xml += ' <' + f.type.to_s + ' id="' + f.id.to_s + '"/>'
-		end
-
-		xml += ' </Filters>'
-
-		xml += ' <Generate after-scan="' + @generate_after_scan.to_s + '">'
-
-		if (@schedule)
-			xml += ' <Schedule type="' + @schedule.type.to_s + '" interval="' + @schedule.interval.to_s + '" start="' + @schedule.start.to_s + '"/>'
-		end
-
-		xml += ' </Generate>'
-
-		xml += ' <Delivery>'
-
-		xml += ' <Storage storeOnServer="' + @storeOnServer.to_s + '">'
-
-		if (@store_location and @store_location.length > 0)
-			xml += ' <location>' + @store_location.to_s + '</location>'
-		end
-
-		xml += ' </Storage>'
-
-
-		xml += ' </Delivery>'
-
-		xml += ' </ReportConfig>'
-
-		return xml
-	end
-
-	def set_name(name)
-		@name = name
-	end
-
-	def set_template_id(template_id)
-		@template_id = template_id
-	end
-
-	def set_format(format)
-		@format = format
-	end
-
-	def set_email_As(email_As)
-		@email_As = email_As
-	end
-
-	def set_storeOnServer(storeOnServer)
-		@storeOnServer = storeOnServer
-	end
-
-	def set_smtp_relay_server(smtp_relay_server)
-		@smtp_relay_server = smtp_relay_server
-	end
-
-	def set_sender(sender)
-		@sender = sender
-	end
-
-	def set_generate_after_scan(generate_after_scan)
-		@generate_after_scan = generate_after_scan
-	end
-end
-
-# === Description
-# Object that represents a report filter which determines which sites, asset
-# groups, and/or devices that a report is run against.  gtypes are
-# "SiteFilter", "AssetGroupFilter", "DeviceFilter", or "ScanFilter".  gid is
-# the site-id, assetgroup-id, or devce-id.  ScanFilter, if used, specifies
-# a specifies a specific scan to use as the data source for the report. The gid
-# can be a specific scan-id or "first" for the first run scan, or “last” for
-# the last run scan.
-#
-class ReportFilter
-
-	attr_reader :type
-	attr_reader :id
-
-	def initialize(type, id)
-
-		@type = type
-		@id = id
-
-	end
-
-end
-
-# === Description
-# Object that represents the schedule on which to automatically generate new reports.
-#
-class ReportSchedule
-
-	# The type of schedule
-	# (daily, hourly, monthly, weekly)
-	attr_reader :type
-	# The frequency with which to run the scan
-	attr_reader :interval
-	# The earliest date to generate the report
-	attr_reader :start
-
-	def initialize(type, interval, start)
-
-		@type = type
-		@interval = interval
-		@start = start
-
-	end
-
-
-end
-
-class ReportTemplateListing
-
-	attr_reader :error_msg
-	attr_reader :error
-	attr_reader :request_xml
-	attr_reader :response_xml
-	attr_reader :connection
-	attr_reader :xml_tag_stack
-	attr_reader :report_template_summaries#;  //Array (ReportTemplateSummary*)
-
-
-	def ReportTemplateListing(connection)
-
-		@error = nil
-		@connection = connection
-		@report_template_summaries = Array.new()
-
-		r = @connection.execute('<ReportTemplateListingRequest session-id="' + connection.session_id.to_s + '"/>')
-		if (r.success)
-			r.res.elements.each('ReportTemplateListingResponse/ReportTemplateSummary') do |r|
-				@report_template_summaries.push(ReportTemplateSumary.new(r.attributes['id'],r.attributes['name']))
-			end
-		else
-			@error = true
-			@error_msg = 'ReportTemplateListingRequest Parse Error'
-		end
-
-	end
-
-end
-
-
-class ReportTemplateSummary
-
-	attr_reader :id
-	attr_reader :name
-	attr_reader :description
-
-	def ReportTemplateSummary(id, name, description)
-
-		@id = id
-		@name = name
-		@description = description
-
-	end
-
-end
-
-
-class ReportSection
-
-	attr_reader :name
-	attr_reader :properties
-
-	def ReportSection(name)
-
-		@properties = Array.new()
-		@name = name
-	end
-
-
-	def addProperty(name, value)
-
-		@properties[name.to_s] = value
-	end
-
-end
-
-
 	# TODO add
 	def self.site_device_scan(connection, site_id, device_array, host_array, debug = false)
 
@@ -3348,5 +126,4 @@ end
 		end
 	end
 
-
 end