RubyGems - trisulrp - Versions diffs - 1.2.4 → 1.2.5 - Mend

trisulrp 1.2.4 → 1.2.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (11) hide show

data/README.rdoc CHANGED Viewed

@@ -1,13 +1,17 @@
 = trisulrp
-Trisul Remote Protocol
-This gem allows you to script advanced network security analysis tasks via Ruby.
+== Trisul Remote Protocol
+This gem allows you to automate incident response or network forensics tasks on the Trisul Network Metering and Forensics platform.
 Key Features :
 * Analysis done remotely (at Trisul server)
 * All communications over TLS
 * Strong authentication using Client Certificates
 * Easy to use
+* Can do everything from getting statistics, flows, and pcaps
@@ -23,6 +27,5 @@ Key Features :
 == Copyright
-Copyright (c) 2010 vivek. See LICENSE.txt for
-further details.
+Copyright (c) 2010-11 Unleash Networks. See LICENSE.txt for further details.

data/VERSION CHANGED Viewed

	@@ -1 +1 @@
1	- 1.2.4
1	+ 1.2.5

data/lib/trisulrp/protocol.rb CHANGED Viewed

@@ -7,22 +7,41 @@ require 'openssl'
 require 'socket'
 require 'time'
+# ==== TrisulRP::Protocol
+# Contains methods to help with common TRP tasks like
+# * creating connections
+# * interacting with Trisul via requests/responses
+# * helpers to create objects
+#
+#
 module TrisulRP::Protocol
 	include TrisulRP::Guids
-	# == TLS Connect to a Trisul instance
-	# => server : IP Address or hostname
-	# => port   : TRP port, typically 12001 (see trisulConfig.xml)
-	# => client_cert_file  : Client certificate file issued by admin
-	# => client_key_file  : Client key file issued by admin
+	# Establish a TLS connection to a Trisul instance
+	#
+	# [server]  IP Address or hostname
+	# [port]    TRP port, typically 12001 (see trisulConfig.xml)
+	# [client_cert_file]   Client certificate file issued by admin
+	# [client_key_file]   Client key file issued by admin
 	#
-	# yields or returns a connection object that can be used in subsequent
-	# calls to communicate to the trisul instance
 	#
+	# ==== Returns
+	# ==== Yields
+	# a connection object that can be used in subsequent calls
 	#
-	def    connect(server,port,client_cert_file,client_key_file)
+	# ==== On error
+	# If a connection cannot be established, an exception is thrown which can point
+	# to the actual cause. The most common causes are
+	#
+	# * Trisul is not running
+	# * Trisul is not running in trp mode (see the docs for runmode)
+	# * Using the wrong port ( check netstat to verify trisul remote protocol port - typically 12001)
+	# * The Access Control List does not permit connections from client IP
+	#
+	def connect(server,port,client_cert_file,client_key_file)
 		tcp_sock=TCPSocket.open(server,port)
-		ctx = OpenSSL::SSL::SSLContext.new
+		ctx = OpenSSL::SSL::SSLContext.new(:TLSv1)
 		ctx.cert = OpenSSL::X509::Certificate.new(File.read(client_cert_file))
 		ctx.key = OpenSSL::PKey::RSA.new(File.read(client_key_file))
 		ssl_sock = OpenSSL::SSL::SSLSocket.new(tcp_sock, ctx)
@@ -31,14 +50,20 @@ module TrisulRP::Protocol
 		return ssl_sock
 	end
-	# == Dispatch request & get response
-	# => trp_socket : socket previously opened via connect_trp
-	# => trp_request : a TRP request object
+	# Dispatch request to server & get response
+	# [conn]  TRP connection  previously opened via TrisulRP::Protocol::connect
+	# [trp_request]  a TRP request object, created directly or using the mk_request helper
 	#
-	# yields or returns a response object
-	# raises an error if the server returns an ErrorResponse
+	# ==== Returns
+	# ==== Yields
+	# a response object, you can then inspect the fields in the response and spawn additional
+	# requests if required
 	#
-	def     get_response(trp_socket,trp_request)
+	# ==== On error
+	# raises an error if the server returns an ErrorResponse - this contains an error_message field
+	# which can tell you what went wrong
+	#
+	def get_response(conn,trp_request)
 		outbuf=""
 		outbuf=trp_request.serialize_to_string
 		trp_socket.write([outbuf.length].pack("N*"))
@@ -55,49 +80,178 @@ module TrisulRP::Protocol
 	end
-  # returns an array of [Time_from, Time_to] representing time window available on Trisul
-  def get_available_time(conn)
+    # Query the total time window available in Trisul
+	#
+	# [conn]  TRP connection  previously opened via connect
+	#
+	# ==== Returns
+	# returns an array of two Time objects [Time_from, Time_to] representing start and end time
+	#
+	# ==== Typical usage
+	#
+	# You pass the output of this method to mk_time_interval to get an object you can attach to a
+	# TRP request.
+	#
+	# <code>
+	#
+	#  tmarr = TrisulRP::Protocol::get_avaiable_time(conn)
+    #  req =TrisulRP::Protocol.mk_request( :source_ip => target_ip,...
+    #            :time_interval => TrisulRP::Protocol::mk_time_interval(tm_arr))
+    #
+	# </code>
+	#
+  	def get_available_time(conn)
 		from_tm=to_tm=nil
 		req=mk_request(TRP::Message::Command::COUNTER_GROUP_INFO_REQUEST,
-					  :counter_group => TrisulRP::Guids::CG_AGGREGATE)
+      							:counter_group => TrisulRP::Guids::CG_AGGREGATE)
 		get_response(conn,req) do |resp|
 			from_tm =  Time.at(resp.counter_group_info_response.group_details[0].time_interval.from.tv_sec)
 			to_tm =  Time.at(resp.counter_group_info_response.group_details[0].time_interval.to.tv_sec)
 		end
 		return [from_tm,to_tm]
-  end
+  	end
-  # returns a hash of key => label
-  def get_labels_for_keys(conn, cgguid, key_arr)
-	req = mk_request(TRP::Message::Command::KEY_LOOKUP_REQUEST,
-	                 :counter_group  => cgguid, :keys => key_arr.uniq )
-	h = key_arr.inject({}) { |m,i| m.store(i,i); m }
-	get_response(conn,req) do |resp|
-			resp.key_lookup_response.key_details.each { |d| h.store(d.key,d.label) }
-	end
-	return h
-  end
+    # convert a set of keys into labels
+	#
+	# This method accepts an array of keys (which are references to counter items in Trisul) and sends
+	# a key lookup request to Trisul.  Trisul responds with labels for those keys that had labels. Finally a
+	# ready to use map is constructed and returned to the caller.
+	#
+	# [conn]    a TRP connection opened earlier via connect(..)
+	# [cgguid]  a counter group id. See TrisulRP::Guids for a list of common guids
+	# [key_arr] an array of keys, possibly obtained as a result of an earlier command
+	#
+	# ==== Returns
+	# a hash of Key => Label. All keys in the incoming array will have a hash entry. If Trisul could not
+	# find a label for a key, it will store the key itself as the hash value.
+	#
+	# ==== Typical usage
+	#
+	# You use this method as a bulk resolving mechanism.
+	# <code>
+	#
+	#  host_keys = ["0A.0A.18.E0", "B1.01.8F.01",...]
+    #  host_names   = TrisulRP::Protocol.get_labels_for_keys(conn,
+	#                       TrisulRP::Guids::CG_HOSTS, host_keys)
+	#
+	#  host_names["0A.0A.18.E0"] = "demo.trisul.org"   # ok
+	#  host_names["B1.01.8F.01"] = "B1.01.8F.01"       # no label for this key
+	#
+	# </code>
+	#
+	def get_labels_for_keys(conn, cgguid, key_arr)
+		req = mk_request(TRP::Message::Command::KEY_LOOKUP_REQUEST,
+		  :counter_group  => cgguid, :keys => key_arr.uniq )
+		h = key_arr.inject({}) { |m,i| m.store(i,i); m }
+		get_response(conn,req) do |resp|
+				resp.key_lookup_response.key_details.each { |d| h.store(d.key,d.label) }
+		end
+		return h
+	  end
-  # fill up time_interval
-  def mk_time_interval(tmarr)
-     tint=TRP::TimeInterval.new
-     tint.from=TRP::Timestamp.new(:tv_sec => tmarr[0].tv_sec, :tv_usec => 0)
-     tint.to=TRP::Timestamp.new(:tv_sec => tmarr[1].tv_sec, :tv_usec => 0)
-	 return tint
-  end
+     # Helper to create a TRP TimeInterval object
+	 #
+	 # [tmarr]	An array of two Time objects representing a window
+	 #
+	 # ==== Returns
+	 # A TRP::TimeInterval object which can be attached to any :time_interval field of a TRP request
+	 #
+     def mk_time_interval(tmarr)
+		tint=TRP::TimeInterval.new
+		tint.from=TRP::Timestamp.new(:tv_sec => tmarr[0].tv_sec, :tv_usec => 0)
+		tint.to=TRP::Timestamp.new(:tv_sec => tmarr[1].tv_sec, :tv_usec => 0)
+		return  tint
+     end
-  # shortcut to make a request
-  def mk_request(cmd_id,params)
-	req = TRP::Message.new(:trp_command => cmd_id )
-	case cmd_id
-		when TRP::Message::Command::COUNTER_GROUP_INFO_REQUEST
-			req.counter_group_info_request = TRP::CounterGroupInfoRequest.new(params)
+     # Helper to create a TRP request object
+	 #
+	 # Read the TRP documentation wiki for a description of each command.
+	 #
+	 # [cmd_id]	The command ID.
+	 # [params] A hash containing command parameters
+	 #
+	 # ==== Typical usage
+	 #
+	 # <code>
+	 #
+	 #  # create a new command of type KeySessionActivityRequest
+     #  req = TrisulRP::Protocol.mk_request(TRP::Message::Command::KEY_SESS_ACTIVITY_REQUEST,
+     #            :key => target_key ,
+	 #            :time_interval => mk_time_interval(tmarr))
+	 #
+	 #  ... now you can use the req object ...
+	 #
+	 # </code>
+	 #
+	 # You can also create the request objects directly, just a little too verbose for our liking
+	 #
+	 # <code>
+	 #
+	 #  # create a new command of type CounterItemRequest
+	 #  req =TRP::Message.new(:trp_command => TRP::Message::Command::KEY_SESS_ACTIVITY_REQUEST )
+	 #  req.key_session_activity_request = TRP::KeySessionActivityRequest.new(
+	 #    				:key =>  target_key ,
+	 #                  :time_interval => mk_time_interval(tmarr))
+	 #
+	 #  ... now you can use the req object ...
+	 #
+	 # </code>
+	 #
+	 #
+     def mk_request(cmd_id,params)
+		req = TRP::Message.new(:trp_command => cmd_id)
+		case cmd_id
+		when TRP::Message::Command::HELLO_REQUEST
+		  req.hello_request = TRP::HelloRequest.new(params)
+		when TRP::Message::Command::COUNTER_GROUP_REQUEST
+		  req.counter_group_request = TRP::CounterGroupRequest.new(params)
+		when TRP::Message::Command::COUNTER_ITEM_REQUEST
+		  req.counter_item_request = TRP::CounterItemRequest.new(params)
+		when TRP::Message::Command::RELEASE_RESOURCE_REQUEST
+		  req.release_resource_request = TRP::ReleaseResourceRequest.new(params)
+		when TRP::Message::Command::CONTROLLED_COUNTER_GROUP_REQUEST
+		  req.controlled_counter_group_request = TRP::ControlledCounterGroupRequest.new(params)
+		when TRP::Message::Command::FILTERED_DATAGRAMS_REQUEST
+		  req.filtered_datagrams_request = TRP::FilteredDatagramsRequest.new(params)
+		when TRP::Message::Command::CONTROLLED_CONTEXT_REQUEST
+		  req.controlled_context_request = TRP::ControlledContextRequest.new(params)
+		when TRP::Message::Command::SEARCH_KEYS_REQUEST
+		  req.search_keys_request = TRP::SearchKeysRequest.new(params)
+		when TRP::Message::Command::BULK_COUNTER_ITEM_REQUEST
+		  req.bulk_counter_item_request = TRP::BulkItemRequest.new(params)
+		when TRP::Message::Command:: CGMONITOR_REQUEST
+		  req.cgmonitor_request = TRP::CgmonitorRequest.new(params)
+		when TRP::Message::Command::TOPPER_SNAPSHOT_REQUEST
+		  req.topper_snapshot_request = TRP::TopperSnapshotRequest.new(params)
+		when TRP::Message::Command::UPDATE_KEY_REQUEST
+		  req.update_key_request = TRP::UpdateKeyRequest.new(params)
+		when TRP::Message::Command::RING_STATS_REQUEST
+		  req.ring_stats_request = TRP::RingStatsRequest.new(params)
+		when TRP::Message::Command::SERVER_STATS_REQUEST
+		  req.server_stats_request = TRP::ServerStatsRequest.new(params)
+		when TRP::Message::Command::SESSION_ITEM_REQUEST
+		  req.session_item_request = TRP::SessionItemRequest.new(params)
+		when TRP::Message::Command::SESSION_GROUP_REQUEST
+		  req.session_group_request = TRP::SessionGroupRequest.new(params)
+		when TRP::Message::Command::ALERT_ITEM_REQUEST
+		  req.alert_item_request = TRP::AlertItemRequest.new(params)
+		when TRP::Message::Command::ALERT_GROUP_REQUEST
+		  req.alert_group_request = TRP::AlertGroupRequest.new(params)
+		when TRP::Message::Command::RESOURCE_ITEM_REQUEST
+		  req.resource_item_request = TRP::ResourceItemRequest.new(params)
+		when TRP::Message::Command::RESOURCE_GROUP_REQUEST
+		  req.resource_group_request = TRP::ResourceGroupRequest.new(params)
 		when TRP::Message::Command::KEY_LOOKUP_REQUEST
-			req.key_lookup_request = TRP::KeyLookupRequest.new(params)
+		  req.key_lookup_request = TRP::KeyLookupRequest.new(params)
+		when TRP::Message::Command::COUNTER_GROUP_INFO_REQUEST
+		  req.counter_group_info_request = TRP::CounterGroupInfoRequest.new(params)
+		when TRP::Message::Command::KEY_SESS_ACTIVITY_REQUEST
+		  req.key_session_activity_request = TRP::KeySessionActivityRequest.new(params)
 		else
 			raise "Unknown TRP command ID"
+		end
+		return req
 	end
-	return req
-  end
 end

data/lib/trisulrp/trp.proto CHANGED Viewed

@@ -76,7 +76,7 @@ enum  PcapFormat {
 }
 message Message {
-	enum Command {  HELLO_REQUEST=1;
+	enum Command {                  HELLO_REQUEST=1;
 					HELLO_RESPONSE=2;
 					OK_RESPONSE=3;
 					ERROR_RESPONSE=5;
@@ -105,7 +105,7 @@ message Message {
 					CGMONITOR_REQUEST=28;
 					CGMONITOR_RESPONSE=29;
 					TOPPER_SNAPSHOT_REQUEST=30;
-              		TOPPER_SNAPSHOT_RESPONSE=31;
+              		                TOPPER_SNAPSHOT_RESPONSE=31;
 					UPDATE_KEY_REQUEST=32;
 					UPDATE_KEY_RESPONSE=33;
 					KEY_SESS_ACTIVITY_REQUEST=34;
@@ -113,7 +113,7 @@ message Message {
 					RING_STATS_REQUEST=36;
 					RING_STATS_RESPONSE=37;
  					SERVER_STATS_REQUEST=38;
-                    SERVER_STATS_RESPONSE=39;
+                                        SERVER_STATS_RESPONSE=39;
 					SESSION_GROUP_REQUEST=40;
 					SESSION_GROUP_RESPONSE=41;
 					ALERT_ITEM_REQUEST=42;

data/test/test_alerts.rb CHANGED Viewed

@@ -4,81 +4,46 @@
 require 'rubygems'
 require './helper'
-include TRPLib
-GUID_CG_APP       = "{C51B48D4-7876-479E-B0D9-BD9EFF03CE2E}"
-AG_IDS   = "{9AFD8C08-07EB-47E0-BF05-28B4A7AE8DC9}"
-CG_SIGDS = "{A0FA9464-B496-4A20-A9AB-4D2D09AFF902}"
-CG_HOSTS = "{4CD742B1-C1CA-4708-BE78-0FCA2EB01A86}"
-CG_APPS  = "{C51B48D4-7876-479E-B0D9-BD9EFF03CE2E}"
+include TrisulRP::Protocol
+require guidmap
 class TestTrisulrp < Test::Unit::TestCase
-	def setup
-		if @trp_conn.nil?
-		@trp_conn=TRPLib::connect_trp("127.0.0.1",
-									  12001,
-									  "Demo_Client.crt",
-									  "Demo_Client.key")
-		end
-	end
 	def test_query_alerts
-		target_ip = "0A.02.C7.EB"  # 10.2.199.235"
-		tm_arr = TRPLib::get_available_time(@trp_conn)
-		# The Request
-		# ----------
-     	req =TRP::Message.new(:trp_command => TRP::Message::Command::ALERT_GROUP_REQUEST)
-     	req.alert_group_request =TRP::AlertGroupRequest.new( :context => 0,
-														     :alert_group  => AG_IDS,
-															 :source_ip => target_ip,
-															 :maxitems  => 1000,
-															 :time_interval => TRPLib.mk_time_interval(tm_arr)
-														   )
-		# The Response
-		# ------------
-		get_trp_response(@trp_conn,req) do |resp|
-			follow_up = TRP::Message.new(:trp_command => TRP::Message::Command::ALERT_ITEM_REQUEST)
-			follow_up.alert_item_request = TRP::AlertItemRequest.new(:alert_group  => AG_IDS)
-			resp.alert_group_response.alerts.each do |al|
-				follow_up.alert_item_request.alert_ids << TRP::AlertID.new(:slice_id => al.slice_id, :alert_id => al.alert_id)
-			end
-			get_trp_response(@trp_conn,follow_up) do | resp2 |
-				  resp=resp2.alert_item_response
-				  resolv_candidates = resp.items.collect { |item| [item.source_ip, item.source_port, item.destination_ip, item.destination_port,item.sigid]  }
-				  resolv_arr = resolv_candidates.transpose
-				  sip_names   = TRPLib::get_labels_for_keys(@trp_conn,CG_HOSTS, resolv_arr[0])
-				  sport_names = TRPLib::get_labels_for_keys(@trp_conn,CG_APPS,  resolv_arr[1])
-				  dip_names   = TRPLib::get_labels_for_keys(@trp_conn,CG_HOSTS, resolv_arr[2])
-				  dport_names = TRPLib::get_labels_for_keys(@trp_conn,CG_APPS,  resolv_arr[3])
-				  sigid_names = TRPLib::get_labels_for_keys(@trp_conn,CG_SIGDS, resolv_arr[4])
-				  resp.items.each do |item|
-							print "#{Time.at(item.time.tv_sec)} "
-							print "#{sip_names[item.source_ip]}".ljust(28)
-							print "#{sport_names[item.source_port]}".ljust(11)
-							print "#{dip_names[item.destination_ip]}".ljust(28)
-							print "#{dport_names[item.destination_port]}".ljust(11)
-							print "#{sigid_names[item.sigid]}".rjust(10)
-							print "\n"
-				  end
-			end
-		end
-	end
+    target_ip = "0A.02.C7.EB"  # 10.2.199.235"
+    TrisulRP::Protocol.connect("127.0.0.1",12001,"Demo_Client.crt","Demo_Client.key") do |conn|
+      tm_arr = TrisulRP::Protocol.get_available_time(conn)
+      req =TrisulRP::Protocol.mk_request(:context => 0,:alert_group  =>TrisulRP::Guids::AG_IDS,												       :source_ip => target_ip,
+        :maxitems  => 1000,
+        :time_interval => TRPLib.mk_time_interval(tm_arr))
+      TrisulRP::Protocol.get_response(conn,req) do |resp|
+        follow_up = TrisulRP::Protocol.mk_request(:alert_group  => TrisulRP::Guids::AG_IDS)
+		    resp.alert_group_response.alerts.each do |al|
+          follow_up.alert_item_request.alert_ids << TRP::AlertID.new(:slice_id => al.slice_id, :alert_id => al.alert_id)
+		    end
+		    TrisulRP::Protocol.getresponse(conn,follow_up) do | resp2 |
+          resp=resp2.alert_item_response
+          resolv_candidates = resp.items.collect { |item| [item.source_ip, item.source_port, item.destination_ip, item.destination_port,item.sigid]  }
+          resolv_arr = resolv_candidates.transpose
+          sip_names   = TrisulRP::Protocol.get_labels_for_keys(conn,TrisulRP::Guids::CG_HOSTS, resolv_arr[0])
+          sport_names = TrisulRP::Protocol.get_labels_for_keys(conn,TrisulRP::Guids::CG_APPS,  resolv_arr[1])
+          dip_names   = TrisulRP::Protocol.get_labels_for_keys(conn,TrisulRP::Guids::CG_HOSTS, resolv_arr[2])
+          dport_names = TrisulRP::Protocol.get_labels_for_keys(conn,TrisulRP::Guids::CG_APPS,  resolv_arr[3])
+          sigid_names = TrisulRP::Protocol.get_labels_for_keys(conn,TrisulRP::Guids::CG_SIGDS, resolv_arr[4])
+          resp.items.each do |item|
+		    	  print "#{Time.at(item.time.tv_sec)} "
+            print "#{sip_names[item.source_ip]}".ljust(28)
+            print "#{sport_names[item.source_port]}".ljust(11)
+            print "#{dip_names[item.destination_ip]}".ljust(28)
+            print "#{dport_names[item.destination_port]}".ljust(11)
+            print "#{sigid_names[item.sigid]}".rjust(10)
+            print "\n"
+          end
+		    end
+      end
+    end
+  end
 end

data/test/test_cap.rb CHANGED Viewed

@@ -2,54 +2,34 @@
 # Akhil.M & Dhinesh.K (c) 2010 Unleash Networks
 # Testing change
 require 'rubygems'
 require './helper'
-include TRPLib
+include TrisulRP::Protocol
 require 'guidmap'
 class TestCap < Test::Unit::TestCase
-	def setup
-		@trp_conn=TRPLib::connect("127.0.0.1",
-								  12001,
-								  "Demo_Client.crt",
-								  "Demo_Client.key")
-	end
-	def test_dpi
-	 target_sess = TRP::SessionID.new(:slice_id => 2, :session_id => 207)
-	 #target_sess = TRP::SessionID.new(:slice_id => 2, :session_id => 4375 )
-	 # get session time
-     req =TRP::Message.new(:trp_command => TRP::Message::Command::SESSION_ITEM_REQUEST )
-     req.session_item_request  =
-	 			TRP::SessionItemRequest.new(:session_ids  =>  [target_sess])
-	 resp=TRPLib::get_trp_response(@trp_conn,req) do |resp|
-	 	si = resp.session_item_response.items[0]
-	 	follow_up = TRP::Message.new(:trp_command => TRP::Message::Command::FILTERED_DATAGRAMS_REQUEST)
-		follow_up.filtered_datagram_request = TRP::FilteredDatagramRequest.new(
-							:filter_expression  => "#{GUIDMap::SG_TCP}=#{si.session_key}",
-							:time_interval => si.time_interval )
-	 	TRPLib::get_trp_response(@trp_conn,follow_up) do |resp|
-			fdr=resp.filtered_datagram_response
-			p "Number of bytes = #{fdr.num_bytes}\n"
-			p "Number of pkts  = #{fdr.num_datagrams}\n"
-			p "Hash            = #{fdr.sha1}\n"
-			File.open("t.pcap","wb") do |f|
-					f.write(fdr.contents)
-			end
-		end
-	 end
-end
+  def test_dpi
+    target_sess = TRP::SessionID.new(:slice_id => 2, :session_id => 207)
+    TrisulRP::Protocol.connect("127.0.0.1", 12001,"Demo_Client.crt","Demo_Client.key") do |conn|
+      req = TrisulRP::Protocol.mk_request(TRP::Message::Command::SESSION_ITEM_REQUEST,
+        :session_ids => [target_sess])
+      TrisulRP::Protocol.get_response(conn,req) do |resp|
+        si = resp.session_item_response.items[0]
+        follow_up = TrisulRP::Protocol.mk_request(:filter_expression  => "#{GUIDMap::SG_TCP}=#{si.session_key}",
+                                                  :time_interval => si.time_interval )
+        TrisulRP::Protocol.get_response(conn,follow_up) do |resp|
+          fdr=resp.filtered_datagram_response
+          p "Number of bytes = #{fdr.num_bytes}\n"
+          p "Number of pkts  = #{fdr.num_datagrams}\n"
+          p "Hash            = #{fdr.sha1}\n"
+          File.open("t.pcap","wb") do |f|
+            f.write(fdr.contents)
+          end
+        end
+      end
+    end
+  end
 end

data/test/test_key_flows.rb CHANGED Viewed

@@ -2,60 +2,43 @@
 # Akhil.M & Dhinesh.K (c) 2010 Unleash Networks
 # Testing change
 require 'rubygems'
 require './helper'
-include TRPLib
-GUID_CG_APP       = "{C51B48D4-7876-479E-B0D9-BD9EFF03CE2E}"
+include TrisulRP::Protocol
+require guidmap
 class TestTrisulrp < Test::Unit::TestCase
-	def setup
-		@trp_conn=TRPLib::connect_trp("127.0.0.1",
-									  12001,
-									  "Demo_Client.crt",
-									  "Demo_Client.key")
-	end
-	def test_flows_for_host
-	 target_key =  "0A.01.3C.BB"
-	 tmarr  = TRPLib::get_available_time(@trp_conn)
-     # create a new command of type CounterItemRequest
-     req =TRP::Message.new(:trp_command => TRP::Message::Command::KEY_SESS_ACTIVITY_REQUEST )
-     req.key_session_activity_request =
-	 			TRP::KeySessionActivityRequest.new( :key =>  target_key ,
-	 	                                            :time_interval => TRPLib::mk_time_interval(tmarr))
-	 TRPLib::get_trp_response(@trp_conn,req) do |resp|
-		all_sids = resp.key_session_activity_response.sessions.collect { |ai| TRP::SessionID.new(:slice_id => ai.slice_id, :session_id => ai.session_id ) }
-	 	follow_up = TRP::Message.new(:trp_command => TRP::Message::Command::SESSION_ITEM_REQUEST)
-		follow_up.session_item_request = TRP::SessionItemRequest.new(:session_ids => all_sids)
-	 	TRPLib::get_trp_response(@trp_conn,follow_up) do |resp|
-			resp.session_item_response.items.each do |item|
-				print "#{item.state} "
-				print "#{Time.at(item.time_interval.from.tv_sec)} "
-				print "#{item.time_interval.to.tv_sec-item.time_interval.from.tv_sec} ".rjust(8)
-				print "#{item.key1A.label}".ljust(28)
-				print "#{item.key2A.label}".ljust(11)
-				print "#{item.key1Z.label}".ljust(28)
-				print "#{item.key2Z.label}".ljust(11)
-				print "#{item.az_bytes}".rjust(10)
-				print "#{item.za_bytes}".rjust(10)
-				print "\n"
-			end
-		end
-	 end
-end
+  def test_flows_for_host
+    target_key =  "0A.01.3C.BB"
+		TrisulRP::Protocol.connect("127.0.0.1",12001,"Demo_Client.crt","Demo_Client.key") do |conn|
+      tmarr  = TrisulRP::Protocol.get_available_time(conn)
+      req = TrisulRP::Protocol.mk_request(TRP::Message::Command::KEY_SESS_ACTIVITY_REQUEST,
+        :key => target_key ,:time_interval =>TrisulRP::Protocol.mk_time_interval(tmarr))
+      TrisulRP::Protocol.get_response(conn,req) do |resp|
+        all_sids = resp.key_session_activity_response.sessions.collect{ |ai| TRP::SessionID.new(
+                     :slice_id => ai.slice_id,
+                     :session_id => ai.session_id ) }
+        follow_up = TrisulRP::Protocol.mk_request(:session_ids => all_sids)
+        TrisulRP::Protocol.get_response(conn,follow_up) do |resp|
+          resp.session_item_response.items.each do |item|
+            print "#{item.state} "
+            print "#{Time.at(item.time_interval.from.tv_sec)} "
+            print "#{item.time_interval.to.tv_sec-item.time_interval.from.tv_sec} ".rjust(8)
+            print "#{item.key1A.label}".ljust(28)
+            print "#{item.key2A.label}".ljust(11)
+            print "#{item.key1Z.label}".ljust(28)
+            print "#{item.key2Z.label}".ljust(11)
+            print "#{item.az_bytes}".rjust(10)
+            print "#{item.za_bytes}".rjust(10)
+            print "\n"
+          end
+        end
+      end
+    end
+  end
 end

data/test/test_resources.rb CHANGED Viewed

@@ -2,75 +2,52 @@
 # Akhil.M & Dhinesh.K (c) 2010 Unleash Networks
 # Testing change
 require 'rubygems'
 require './helper'
-include TRPLib
-GUID_CG_APP       = "{C51B48D4-7876-479E-B0D9-BD9EFF03CE2E}"
+include TrisulRP::Protocol
+require guidmap
 class TestTrisulrp < Test::Unit::TestCase
-	def setup
-		if @trp_conn.nil?
-		@trp_conn=TRPLib::connect_trp("127.0.0.1",
-									  12001,
-									  "Demo_Client.crt",
-									  "Demo_Client.key")
-		end
-	end
-	def itest_resource_items
-		req=TRPLib::mk_resource_item_request(1,[574,575])
-		get_trp_response(@trp_conn,req) do |resp|
-				TRPLib::print_resource_item_response(resp)
-		end
-	end
+	# demonstrates getting all HTTP requests getting a *DLL
 	def test_query_resources
-		target_ip = "0A.02.C7.EB"  # 10.2.199.235"
-		tm_arr = TRPLib::get_available_time(@trp_conn)
-		# The Request
-		# ----------
-     	req =TRP::Message.new(:trp_command => TRP::Message::Command::RESOURCE_GROUP_REQUEST)
-     	req.resource_group_request =TRP::ResourceGroupRequest.new( :context => 0,
-																   :resource_group => "{4EF9DEB9-4332-4867-A667-6A30C5900E9E}",
-																   :uri_pattern => "dll",
-																   :maxitems  => 1000,
-																   :time_interval => TRPLib.mk_time_interval(tm_arr)
-																  )
-		# The Response
-		# ------------
-		get_trp_response(@trp_conn,req) do |resp|
-			follow_up = TRP::Message.new(:trp_command => TRP::Message::Command::RESOURCE_ITEM_REQUEST)
-			follow_up.resource_item_request = TRP::ResourceItemRequest.new(:context => 0, :resource_group => "{4EF9DEB9-4332-4867-A667-6A30C5900E9E}")
-			resp.resource_group_response.resources.each do |res|
-				follow_up.resource_item_request.resource_ids << TRP::ResourceID.new(:slice_id => res.slice_id, :resource_id => res.resource_id)
-			end
-			get_trp_response(@trp_conn,follow_up) do | resp2 |
-				  resp=resp2.resource_item_response
-				  resp.items.each do |item|
-							print "#{Time.at(item.time.tv_sec)} "
-							print "#{item.source_ip}".ljust(28)
-							print "#{item.source_port}".ljust(11)
-							print "#{item.destination_ip}".ljust(28)
-							print "#{item.destination_port}".ljust(11)
-							print "#{item.uri}".rjust(10)
-							print "\n"
-				  end
-			end
-		end
-	end
-end
+    target_ip = "0A.02.C7.EB"  # 10.2.199.235"
+    TrisulRP::Protocol.connect_trp("127.0.0.1", 12001,"Demo_Client.crt","Demo_Client.key") do |conn|
+      tm_arr = TrisulRP::Protocol. get_available_time(conn)
+      req = TrisulRP::Protocol.mk_request(TRP::Message::Command::RESOURCE_GROUP_REQUEST,
+        :context => 0,
+        :resource_group => TrisulRP::Guids::RG_URL,
+        :uri_pattern => "dll",:maxitems  => 1000,                                                                                                                   :time_interval => mk_time_interval(tm_arr))
+      TrisulRP::Protocol.get_response(conn,req) do |resp|
+	     	# matching resource ids
+        resource_ids = resp.resource_group_response.resources.collect do   |res|
+          TRP::ResourceID.new(:slice_id => res.slice_id, :resource_id => res.resource_id)
+        end
+        follow_up = TrisulRP::Protocol.mk_request( TRP::Message::Command::RESOURCE_ITEM_REQUEST,
+          :context => 0, :resource_group => TrisulRP::Guids::RG_URL,
+          :resource_ids => resource_ids)
+        TrisulRP::Protocol.get_response(conn,follow_up) do | resp2 |
+          resp=resp2.resource_item_response
+          resp.items.each do |item|
+            print "#{Time.at(item.time.tv_sec)} "
+            print "#{item.source_ip}".ljust(28)
+            print "#{item.source_port}".ljust(11)
+            print "#{item.destination_ip}".ljust(28)
+            print "#{item.destination_port}".ljust(11)
+            print "#{item.uri}".rjust(10)
+            print "\n"
+          end
+        end
+      end
+    end
+  end
+end

data/test/test_trisulrp.rb CHANGED Viewed

@@ -6,8 +6,7 @@ class TestTrisulrp < Test::Unit::TestCase
 	def test_basic
-	    TrisulRP::Protocol.connect("127.0.0.1", 12001,
-								   "Demo_Client.crt", "Demo_Client.key") do |conn|
+	    TrisulRP::Protocol.connect("127.0.0.1", 12001,"Demo_Client.crt", "Demo_Client.key") do |conn|
 			TrisulRP::Protocol.get_available_time(conn)
 		end

data/trisulrp.gemspec CHANGED Viewed

@@ -5,11 +5,11 @@
 Gem::Specification.new do |s|
   s.name = %q{trisulrp}
-  s.version = "1.2.4"
+  s.version = "1.2.5"
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["vivek"]
-  s.date = %q{2011-01-06}
+  s.date = %q{2011-01-17}
   s.description = %q{This gem deals about the trisul remote protocol}
   s.email = %q{vivek_rajagopal@yahoo.com}
   s.extra_rdoc_files = [

metadata CHANGED Viewed

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments:
   - 1
   - 2
-  - 4
-  version: 1.2.4
+  - 5
+  version: 1.2.5
 platform: ruby
 authors:
 - vivek
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
-date: 2011-01-06 00:00:00 +05:30
+date: 2011-01-17 00:00:00 +05:30
 default_executable:
 dependencies:
 - !ruby/object:Gem::Dependency
@@ -149,7 +149,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      hash: -497000077
+      hash: 236447741
       segments:
       - 0
       version: "0"