Sipper 1.1.3

data/sipper/transport_manager.rb

@@ -0,0 +1,33 @@
+require 'transport/udp_transport'
+
+class TransportManager
+
+  attr_reader :transports
+    
+  def initialize
+    @transports = []
+  end
+  
+  def add_transport tp
+    @transports << tp
+  end  
+  
+  #["AF_INET", 33302, "localhost.localdomain", "127.0.0.1"]
+  def get_transport_for(transport_info)
+    @transports[0]   #todo have the MH logic here
+  end
+  
+  # todo find a way to return a different
+  # this return transport suitable for sending to ip / port
+  def get_udp_transport_for(ip, port)
+    @transports[0]
+  end
+  
+  # This returns a transport that matches the ip and port as given
+  def get_udp_transport_with(ip, port)
+    @transports.each do |tr|
+      return tr if (tr.ip == ip && tr.port == port)  
+    end
+  end
+  
+end

data/sipper/udp_session.rb

@@ -0,0 +1,17 @@
+require 'session'
+require 'sip_logger'
+
+class UdpSession < Session
+  include SipLogger
+  
+  def initialize(rip, rp, rs, session_limit=nil, specified_transport = nil)
+    if specified_transport
+      tp = SIP::Locator[:Tm].get_udp_transport_with(specified_transport[0], specified_transport[1])
+    else
+      tp = SIP::Locator[:Tm].get_udp_transport_for(rip, rp) if rip && rp  
+    end
+    
+    super(tp, rip, rp, rs, session_limit)  
+  end
+  
+end

data/sipper/util/command_element.rb

@@ -0,0 +1,62 @@
+# This is a generator helper class addding some commad level fucntionality in the generated
+# code from the generate module. 
+
+require 'sip_logger'
+require 'strscan'
+require 'util/sipper_util'
+require 'ruby_ext/string'
+require 'ruby_ext/object'
+
+require 'facets/core/string/first_char'
+
+module SipperUtil
+
+  # One command element is like "@sleep 500" where the requirement is to add a sleep element for 500ms
+  # in the genarted code. 
+  # Since a CommandElement is used alongside the ExpectationElement we have a direction attribute 
+  # returning "@" sign.
+  # There is no space after @ sign for commands. The commands are methods defined on this class.  
+  
+  class CommandElement
+    
+    include SipLogger
+    include SipperUtil
+      
+    # Command id is a general purpose id which can be used to identify/differentiate
+    # commands.
+    attr_reader  :command_str, :command, :command_id, :direction
+    
+    @@id_counter = 0
+    
+    def initialize(str)
+      s = StringScanner.new(str)
+      m = nil
+      @direction = s.getch
+      log_and_raise "Improper direction in cmd str", ArgumentError unless @direction == "@"
+      m = s.scan_until(/$/)
+      @command, *args = m.split
+      log_and_raise "Bad command str, no command", ArgumentError unless @command
+      @command_id = "id" + String(@@id_counter+=1)
+      @command_str = self.send @command.to_sym, *args
+    end
+  
+    # The command to make the flow sleep for specified amount of milliseconds. 
+    # e.g. "@sleep_ms 500"
+    def sleep_ms(ms) 
+      flt_ms = Float(ms)
+      log_and_raise "Negative argument is not allowed", ArgumentError if flt_ms < 0
+      "sleep #{flt_ms/1000.0}" 
+    end
+    
+    # Command to set a timer for this time, on expiration of this timer the next command or 
+    # action is taken.  
+    def set_timer(ms)
+      flt_ms = Float(ms)
+      log_and_raise "Negative argument is not allowed", ArgumentError if flt_ms < 0
+      "session.schedule_timer_for(\"#{@command_id}\", #{flt_ms})"
+    end
+      
+    
+  end
+  
+end  

data/sipper/util/compact_converter.rb

@@ -0,0 +1,50 @@
+require 'facets/core/hash/inverse'
+require 'util/sipper_util'
+
+module SipperUtil
+
+  class CompactConverter
+    # Ref : http://www.iana.org/assignments/sip-parameters
+    COMP_TO_EXPANDED = {
+      "a" => "accept_contact",  
+      "u" => "allow_events",
+      "i" => "call_id",
+      "m" => "contact",
+      "e" => "content_encoding",
+      "l" => "content_length", 
+      "c" => "content_type",
+      "o" => "event",
+      "f" => "from",
+      "y" => "identity",   
+      "n" => "identity_info",
+      "r" => "refer_to",
+      "b" => "referred_by",
+      "j" => "reject_contact",
+      "d" => "request_disposition",
+      "x" => "session_expires",
+      "s" => "subject",
+      "k" => "supported",
+      "t" => "to",
+      "v" => "via"  
+    }
+    
+    EXPANDED_TO_COMP = COMP_TO_EXPANDED.invert
+    
+    def self.get_compact(ex_hdr)
+      EXPANDED_TO_COMP[SipperUtil.methodize(ex_hdr.to_s)]
+    end
+    
+    def self.get_expanded(c_hdr)
+      SipperUtil.headerize(COMP_TO_EXPANDED[c_hdr.to_s.downcase])
+    end
+    
+    def self.has_compact_form?(ex_hdr)
+      EXPANDED_TO_COMP.has_key?(SipperUtil.methodize(ex_hdr.to_s))
+    end
+    
+    def self.has_expanded_form?(c_hdr)
+      COMP_TO_EXPANDED.has_key?(c_hdr.to_s.downcase)
+    end
+    
+  end
+end

data/sipper/util/counter.rb

@@ -0,0 +1,26 @@
+require 'monitor'
+require 'singleton'
+
+module SipperUtil
+  class Counter
+    include Singleton
+    
+    def initialize
+      @@class_lock = Monitor.new
+      @@counter = 0
+    end
+    
+    def next
+      @@class_lock.synchronize do
+        @@counter += 1
+      end
+    end
+    
+    def reset
+      @@class_lock.synchronize do
+        @@counter = 0
+      end
+    end 
+    
+  end
+end

data/sipper/util/digest/digest_authorizer.rb

@@ -0,0 +1,204 @@
+require 'util/sipper_util'
+require 'digest/md5'
+require 'base64'
+require 'sipper_configurator'
+require 'sip_headers/header'
+
+
+# Digest authorizer is a stateful entity that maintains the state from previous challenges and
+# calculates the digest according to RFC. 
+module SipperUtil
+  class DigestAuthorizer
+    
+    attr_writer :salt
+    
+    def initialize(salt=nil)
+      @same_challenge = true
+      @salt = salt || SipperConfigurator[:DigestSalt] || "sipper_rocks"
+      @nonce_count_table = {}
+    end
+    
+    # Generated by UAC to respond to the challenge
+    def create_authorization_header(c, proxy, u, p, lsr)
+      @same_challenge = (@c.nonce == c.nonce)  if @c
+      @c = c
+      @u = u
+      @p = p 
+      @lsr = lsr
+      @cnonce = create_nonce
+      if @nonce_count_table[@c.nonce]
+        @nonce_count_table[@c.nonce] += 1
+      else  
+        @nonce_count_table[@c.nonce] = 1
+      end
+      if proxy
+        atn_hdr = SipHeaders::ProxyAuthorization.new
+      else
+        atn_hdr = SipHeaders::Authorization.new
+      end
+      atn_hdr.scheme = @c.scheme 
+      atn_hdr.username = quote_str @u 
+      atn_hdr.realm = @c.realm 
+      atn_hdr.nonce = @c.nonce 
+      atn_hdr.uri = quote_str @lsr.uri.to_s
+      atn_hdr.nc = nonce_count()
+      atn_hdr.opaque = @c.opaque 
+      atn_hdr.algorithm = @c.algorithm
+      atn_hdr.qop = @c.qop 
+      atn_hdr.cnonce = quote_str @cnonce 
+      atn_hdr.response = quote_str digest_response()
+      return atn_hdr
+    end
+    
+    
+    private
+    
+    def concat(*args) 
+      args.join ':' 
+    end
+    
+    # Calculate H() as specified, this is just a simple hash.
+    # RFC 2617 : For the "MD5" and "MD5-sess" algorithms
+    # H(data) = MD5(data)
+    def h(data)
+      Digest::MD5.hexdigest data 
+    end
+    
+    
+    # RFC 2617 :  KD(secret, data) = H(concat(secret, ":", data)
+    def kd(secret, data)
+      h concat(secret, data)
+    end
+    
+    
+    def user_string
+      concat(@u, unquote_str(@c.realm), @p)
+    end
+    
+    
+    # A1
+    # RFC 2617 3.2.2.2 A1
+    
+    #   If the "algorithm" directive's value is "MD5" or is unspecified, then
+    #   A1 is:
+    #
+    #      A1       = unq(username-value) ":" unq(realm-value) ":" passwd
+    #   where
+    #      passwd   = < user's password >
+    #
+    #   If the "algorithm" directive's value is "MD5-sess", then A1 is
+    #   calculated only once - on the first request by the client following
+    #   receipt of a WWW-Authenticate challenge from the server.  It uses the
+    #   server nonce from that challenge, and the first client nonce value to
+    #   construct A1 as follows:
+    #
+    #      A1       = H( unq(username-value) ":" unq(realm-value)
+    #                     ":" passwd )
+    #                     ":" unq(nonce-value) ":" unq(cnonce-value)
+    #
+    #   This creates a 'session key' for the authentication of subsequent
+    #   requests and responses which is different for each "authentication
+    #   session", thus limiting the amount of material hashed with any one
+    #   key. 
+    def a1
+      if @c.algorithm == 'MD5-sess'
+        if @same_challenge
+          @a1_sess = concat(h(user_string), unquote_str(@c.nonce), unquote_str(@cnonce))  unless  @a1_sess  
+          @a1_sess
+        else
+          @a1_sess = concat(h(user_string), unquote_str(@c.nonce), unquote_str(@cnonce)) 
+        end
+      else
+        user_string
+      end
+      
+    end
+    
+    # 3.2.2.3 A2
+    
+    # If the "qop" directive's value is "auth" or is unspecified, then A2
+    # is:
+    #
+    # A2       = Method ":" digest-uri-value
+    #  If the "qop" value is "auth-int", then A2 is:
+    #
+    # A2       = Method ":" digest-uri-value ":" H(entity-body)    
+    #
+    # From 3261
+    # As a clarification to the calculation of the A2 value for
+    # message integrity assurance in the Digest authentication
+    # scheme, implementers should assume, when the entity-body is
+    # empty (that is, when SIP messages have no body) that the hash
+    # of the entity-body resolves to the MD5 hash of an empty
+    # string, or:
+    # H(entity-body) = MD5("") =
+    # "d41d8cd98f00b204e9800998ecf8427e"
+    def a2
+      if @c.qop && @c.qop == 'auth-int'
+        concat(@lsr.method, @lsr.uri.to_s, h(b=@lsr.body ? b : ""))
+      else
+        concat(@lsr.method, @lsr.uri.to_s)
+      end
+    end
+    
+    
+    
+    # If the "qop" value is "auth" or "auth-int":
+    # request-digest = <"> < KD ( H(A1), unq(nonce-value)
+    # ":" nc-value
+    # ":" unq(cnonce-value)
+    # ":" unq(qop-value)
+    # ":" H(A2)
+    # ) <">
+    # If the "qop" directive is not present (this construction is for
+    # compatibility with RFC 2069):
+    # request-digest =
+    # <"> < KD ( H(A1), unq(nonce-value) ":" H(A2) ) >
+    # <">
+    def digest_response
+      if @c.qop.nil?
+        kd(h(a1), concat(unquote_str(@c.nonce), h(a2)))
+      else
+        kd(h(a1), concat(unquote_str(@c.nonce), 
+                         nonce_count(), 
+                         unquote_str(@cnonce), unquote_str(@c.qop), h(a2)))
+      end
+    end
+    
+    
+    def create_nonce
+      now = Time.now
+      time = now.strftime("%Y-%m-%d %H:%M:%S").to_s + ':' + now.usec.to_s
+      Base64.encode64(
+                      concat(time, h(concat(time, @salt)))
+      ).gsub("\n", '')[0..-3]
+    end
+    
+    def create_opaque
+      s = []; 16.times { s << rand(127).chr }
+      h s.join
+    end
+    
+
+    
+    def nonce_count
+      (@nonce_count_table[@c.nonce]).to_s(16).rjust 8, '0'
+    end
+    
+    def quote_str(str)
+      qs = '"' 
+      qs << str << '"'
+      qs
+    end
+    
+    def unquote_str(str)
+      if str[0].chr == '"'
+        str[1...-1]
+      else
+        str
+      end
+    end
+
+  end  # class
+  
+end  # module

data/sipper/util/expectation_parser.rb

@@ -0,0 +1,164 @@
+
+# 1. Wilcard for responses only 2xx, 1xx, 18x etc for responses 
+# 2. Alteration "< INVITE|SUBSCRIBE" optional request
+# 3. Repetition "> INVITE  {2,2}" have exactly 2. "< 18x {2,3}" have 2 or 3.  "> 18x {,3}" at most 3" 
+#   "> INVITE  {0,}" variable. "< BYE {1,} at least 1.
+# 4. For wildcard responses the first character in the message MUST be a number like 1xx is valid as
+#    is 41x but xxx or x00 is not valid. Character 'x' is used a wildcard.
+# 5. The neutral expectation, the one recorded by the controller is recorded with the direction element
+#    "!" and  the string should not contain any spaces.    
+# An element is satisfied if the minimum requirement is met for that. 
+# BNF Grammar is "DIRECTION  MSGEXPRESSION|MSGEXPREESION  REPETITION"
+
+require 'sip_logger'
+require 'strscan'
+require 'util/sipper_util'
+require 'ruby_ext/string'
+require 'ruby_ext/object'
+
+require 'facets/core/string/first_char'
+
+module SipperUtil
+
+  # one expectation element is like "< INVITE {1,2}" or "> 1xx {0,}"
+  class ExpectationElement
+    
+    include SipLogger
+    include SipperUtil
+      
+    Directions = ["<", ">", "!", "@"]
+    MAX_REPEAT = 10000
+    
+    attr_accessor  :messages, :direction, :range, :satisfied
+    
+    def initialize(str)
+      s = StringScanner.new(str)
+      m = nil
+      @direction = s.getch
+      log_and_raise "Improper direction in exp str", ArgumentError unless Directions.include?(@direction)
+      log_and_raise "Bad exp str, no space", ArgumentError unless s.scan(/\s+/) # space
+      if s.exist?(/\s+/)
+        m = s.scan_until(/\s+/).strip
+      else
+        m = s.scan_until(/$/)
+      end
+      @messages = m.split("|")
+      log_and_raise "Bad exp str, no message", ArgumentError unless @messages
+      # Enforce that wildcard is used rather than a check for say 200|202 etc for responses
+      if @messages[0] =~ /^\d/ && @messages.length>0
+        1.upto @messages.length-1  do |n|
+          log_and_raise "Bad exp str, use wildcard instead of |", ArgumentError  if @messages[0][0] == @messages[n][0]  
+        end
+      end
+      if s.eos?
+        @range = Range.new(1,1)
+      else
+        rep = s.scan_until(/$/)
+        log_and_raise "Bad repetition in exp str", ArgumentError unless(rep.first_char(1)=="{" && rep.last_char(1)=="}")  
+        rep_str = rep[1...-1]
+        min, max = rep_str.split(",")
+        min = 0 unless (min && min.size>0)
+        max = MAX_REPEAT unless (max && max.size>0)
+        min = Integer(min)
+        max = Integer(max)
+        @range = Range.new(min, max)
+      end
+      @satisfied = false
+    end
+  
+  end
+  
+  
+  
+  class ExpectationParser
+    # expectations
+    attr_accessor :exps
+  
+    def parse(ex_ary)
+      @exps = []
+      ex_ary.each {|str| @exps << ExpectationElement.new(str) } 
+      @idx = 0
+      @match_count = 0
+    end
+  
+    # input string is "> INVITE" or "< 100" etc. 
+    def match(str)
+      d, m = str.split(" ")
+      _match(d, m) 
+    end
+    
+    # A recorded message will have a direction and message itself. 
+    def _match(dir, message)
+      return [false, nil] if @idx >= @exps.length
+      matched = true
+      matched = false if dir != @exps[@idx].direction
+      if matched
+        if dir == ::SipperUtil::ExpectationElement::Directions[2]  # "!" 
+          matched = _match_neutral(message)
+        elsif message.first_char(1).int?
+          matched = _match_response(message)
+        else
+          matched = _match_request(message)
+        end
+      end
+      if matched
+        @match_count += 1
+        return [true, nil] if @match_count < @exps[@idx].range.min
+        return [false,_unmatched_expectation] if @match_count > @exps[@idx].range.max
+        if @exps[@idx].range.include? @match_count
+          @exps[@idx].satisfied = true 
+          return [true, nil]
+        end
+      else
+        if (@exps[@idx].satisfied || @exps[@idx].range.min == 0)
+          @idx += 1
+          @match_count = 0
+          return _match(dir, message)  # match next
+        else
+          return [false,_unmatched_expectation]
+        end
+      end        
+    end
+  
+    def _match_response(res)
+      return false if res.length != 3
+      matched = true
+      @exps[@idx].messages.each do |m|
+        return false unless m.first_char(1).int? 
+        matched = true
+        0.upto(2) do |n|
+          unless m[n,1]=="x"
+             if m[n] != res[n]
+               matched = false 
+               break
+             end
+          end
+        end
+        return true if matched
+      end
+      return matched
+    end
+    
+    def _match_request(req)
+      @exps[@idx].messages.each do |m|
+        return true if m == req
+      end
+      return false
+    end
+    
+    def _match_neutral(txt)
+      @exps[@idx].messages.each do |m|
+        return true if m == txt
+      end
+      return false
+    end
+    
+    def _unmatched_expectation
+      "#{@exps[@idx].direction} #{@exps[@idx].messages.join(' or ')} between #{@exps[@idx].range.min} and #{@exps[@idx].range.max}"
+    end
+    
+    private :_unmatched_expectation, :_match_response, :_match_request, :_match
+    
+  end
+  
+end