Sipper 1.1.3

data/sipper/session_state/dialog_routes.rb

@@ -0,0 +1,141 @@
+require 'request'
+require 'response'
+require 'sipper_configurator'
+require 'util/sipper_util'
+require 'sip_headers/header'
+
+# Maintains the route set and remote target for the dialog, also encapsulating the logic for 
+# target refresh and strict router manipulation. 
+
+class DialogRoutes
+
+  LRREGX = /;lr/.freeze
+  
+  def initialize(pre_existing=nil)
+     prex = pre_existing || SipperConfigurator[:PreExistingRouteSet]
+     if prex
+       prex.each do |rt|
+         raise ArgumentError, "Only loose routes can be preloaded routes" unless rt.to_s =~ LRREGX    
+       end
+     end
+    _assign_route_set(prex || [])
+    @remote_target = nil
+    @route_learned = false
+    @target_refreshed = false
+  end
+  
+  def _assign_route_set(rarr)
+    @route_set = rarr.map do |r|
+      unless r.class ==  SipHeaders::Route
+        SipHeaders::Route.new.assign(r.to_s)
+      else
+        r
+      end
+    end
+  end
+  
+  def request_received(request)
+    if SipperConfigurator[:TargetRefreshMethods].include? request.method
+      _update_rt(request)
+    end
+    return if @route_learned
+    if SipperConfigurator[:DialogCreatingMethods].include? request.method
+      if request[:record_route]
+        _assign_route_set(request.record_routes) 
+      else
+        _assign_route_set([])
+      end
+      @route_learned = true
+    end
+  end
+  
+  
+  def response_received(response)
+    if SipperConfigurator[:TargetRefreshMethods].include?(response.get_request_method)  && response.code != 100
+      _update_rt(response)
+    end
+    return if @route_learned
+    if SipperConfigurator[:DialogCreatingMethods].include? response.get_request_method
+      if response[:record_route]
+        _assign_route_set(response.record_routes.reverse)  
+      else
+        _assign_route_set([])
+      end
+      @route_learned = true if response.code >= 200
+    end
+  end
+  
+
+  
+  # Returns the Request URI and route header values. [remote_target, [routes]], if there is no
+  # route set then an empty array for routes is returned. 
+  # e.g. [remote_target, [], bool]
+  # The last element of the array is a boolean use_ruri which is true of the request uri should
+  # be used to determine the destination of the request, otherwise top route header should be 
+  # used. 
+  # 
+  # RFC 3261 12.2.1.1
+  # The UAC uses the remote target and route set to build the Request-URI and Route header field 
+  # of the request. 
+  # 
+  # If the route set is empty, the UAC MUST place the remote target URI into the 
+  # Request-URI.  The UAC MUST NOT add a Route header field to the request.
+  # 
+  # If the route set is not empty, and the first URI in the route set contains the lr parameter 
+  # (see Section 19.1.1), the UAC MUST place the remote target URI into the Request-URI and MUST 
+  # include a Route header field containing the route set values in order, including all parameters.
+  # 
+  # If the route set is not empty, and its first URI does not contain the lr parameter, the UAC MUST 
+  # place the first URI from the route set into the Request-URI, stripping any parameters that are 
+  # not allowed in a Request-URI.  The UAC MUST add a Route header field containing the remainder 
+  # of the route set values in order, including all parameters.  
+  # The UAC MUST then place the remote target URI into the Route header field as the last value.
+  # todo - see what needs to be stripped while placing top route in ruri
+  def get_ruri_and_routes
+    _find_targets(@remote_target, @route_set) 
+  end
+  
+  # This will typically be used for initial request only when the controller changes the 
+  # route headers or pushes new route headers. Here we completely ignore the @route_set and
+  # just go by the route headers. Note that the pre_existing route headers would already
+  # have been added to the request when the request was first created. 
+  def get_ruri_and_routes_for_pushed_routes(request)
+    if rs=request[:route]
+      return _find_targets(@remote_target, rs)
+    else
+      return get_ruri_and_routes
+    end
+  end
+  
+  def _find_targets(rt, rs)
+    if rs.empty?
+      [rt, [], true]
+    else
+      if rs[0].uri.has_param?(:lr)  
+        [rt, rs, false]  
+      else
+        [rs[0].uri, rs[1..-1]+[rt], true]
+      end  
+    end   
+  end
+  
+  def _update_rt(msg)
+    self.remote_target = msg.contact.uri if msg.contact    
+  end
+  
+  def remote_target=(rt)
+    if @remote_target && @remote_target==rt
+      @target_refreshed = false
+      return
+    end
+    @remote_target = rt
+    @target_refreshed = true
+  end
+  
+  def target_refreshed?
+    @target_refreshed  
+  end
+  
+  private :_update_rt, :_assign_route_set
+  
+end

data/sipper/sip_headers/header.rb

@@ -0,0 +1,632 @@
+require 'util/sipper_util'
+require 'ruby_ext/object'
+require 'facets/core/hash/reverse_merge'
+require 'sip_logger'
+require 'ruby_ext/mutable_class'
+require 'sip_headers/sipuri'
+
+module SipHeaders
+  
+  # Base Header class
+  class Header
+    include SipLogger
+    # name is set in Message
+    attr_accessor :name
+    attr_accessor :frozen_str, :header_value, :header_params, :default_parse
+    protected :header_value, :header_params, :default_parse
+    
+    alias_method :old_dup, :dup
+    
+    ASSIGN = /=$/.freeze
+    
+    def dup
+      obj = self.old_dup  
+      obj.frozen_str = self.frozen_str.dup 
+      obj.header_value = self.header_value.dup 
+      obj.header_params = self.header_params.dup  
+      obj.default_parse = self.default_parse.dup 
+      obj
+    end
+    
+    
+    def to_s
+      if @frozen_str
+        @frozen_str
+      else
+        _format
+      end
+    end 
+    
+    def to_str
+      to_s
+    end
+    
+    def freeze
+      @frozen_str = _format unless @frozen_str
+      super
+    end
+    
+    def ==(other)
+      return true if self.object_id==other.object_id 
+      self.to_s == other.to_s
+    end
+    
+    # Returns the complete formatted header
+    # this is the default format method.
+    def _format
+      return nil unless self.header_value  
+      str = self.header_value.dup
+      if self.header_params
+        self.header_params.each do |k,v|
+          if v
+            if v == ""
+              str << ";" << k 
+            else
+              str << ";" << k << "=" << v.to_s 
+            end
+          end
+        end
+      end
+      str
+    end
+    private :_format
+    
+    
+    # returns just the value of the header, sans params
+    def header_value
+      @header_value
+    end
+    
+    # returns a hash of parameters
+    def header_params
+      @header_params
+    end
+    
+    def cache_and_clear(val_str, iv_arr)
+      @frozen_str = val_str
+      @header_params = {}
+      clear_ivs(iv_arr)
+    end
+    protected :cache_and_clear
+    
+    def assign(val_str, parse=true)
+      @default_parse = true
+      unless parse
+        cache_and_clear(val_str, [:@header_value])
+      else
+        @frozen_str = nil
+        @header_value, @header_params = SipperUtil.parameterize_header(val_str)
+      end 
+      self
+    end
+    
+    def default_parse?
+      @default_parse
+    end
+    
+    def method_missing(m, *a)
+      if (md=(ASSIGN.match(m.to_s)))
+        name = md.pre_match
+      else
+        name = m.to_s
+      end
+      meta = class << self; self; end
+      meta.send(:define_method, name) { self.header_params[name] }
+      meta.send(:define_method, :"#{name}=") { |x| self.header_params[name] = x }
+      self.send m, *a
+    rescue => e
+      loge(e.backtrace.join("\n"))
+    end
+    
+    def [](param)
+      @header_params[param.to_s]
+    end
+    
+    def []= (param, val)
+      @header_params[param.to_s] = val
+    end
+    
+    def has_param?(key)
+      @header_params.has_key?(key.to_s)
+    end
+    
+    
+    # for logging
+    def classname
+      "sipheaders_header"
+    end
+    
+  end  #Header Class
+  
+  # To implement a new header have a method 
+  # - assign() which parses the val_str, have 
+  # - header_value() that returns a formatted value of the header without any params
+  # - in addition to have any specfic attribute accessor special to the header.
+  
+  
+  #  Via class
+  #  ---------
+  #  Via               =  ( "Via" / "v" ) HCOLON via-parm *(COMMA via-parm)
+  #  via-parm          =  sent-protocol LWS sent-by *( SEMI via-params )
+  #  via-params        =  via-ttl / via-maddr
+  #                       / via-received / via-branch
+  #                       / via-extension
+  #  via-ttl           =  "ttl" EQUAL ttl
+  #  via-maddr         =  "maddr" EQUAL host
+  #  via-received      =  "received" EQUAL (IPv4address / IPv6address)
+  #  via-branch        =  "branch" EQUAL token
+  #  via-extension     =  generic-param
+  #  sent-protocol     =  protocol-name SLASH protocol-version
+  #                       SLASH transport
+  #  protocol-name     =  "SIP" / token
+  #  protocol-version  =  token
+  #  transport         =  "UDP" / "TCP" / "TLS" / "SCTP"
+  #                       / other-transport
+  #  sent-by           =  host [ COLON port ]
+  #  ttl               =  1*3DIGIT ; 0 to 255
+  #  -----------
+  #  Example  -  Via: SIP/2.0/UDP 172.17.31.207:6062;branch=z9hG4bK-1-0
+  
+  class Via < Header
+    
+    attr_accessor :protocol, :version, :transport, :sent_by_ip, :sent_by_port
+    
+    PROTO_REGX        = /(.+?)\/(.+?)\/(.+)$/
+    SENT_WPORT_REGX   = /(.+?):(.+?);/
+    SENT_WOPORT_REGX  = /(.+?);/
+    
+    def initialize
+      @name = "Via"
+      super
+    end
+    
+     def dup
+      obj = super
+      obj.protocol = self.protocol.dup
+      obj.version  = self.version.dup
+      obj.transport = self.transport.dup
+      obj.sent_by_ip = self.sent_by_ip.dup
+      obj.sent_by_port = self.sent_by_port.dup
+      obj
+    end
+    
+    def header_value
+      return nil unless @protocol
+      str = sprintf("%s/%s/%s %s", @protocol, @version, @transport, @sent_by_ip)
+      str << ":" << @sent_by_port if @sent_by_port 
+      str
+    end
+    
+    
+    def assign(val_str, parse=true)
+      unless parse
+        cache_and_clear(val_str, 
+                        [:@protocol, :@version, :@transport, :@sent_by_ip, :@sent_by_port])
+      else
+        @frozen_str = nil
+        sent_protocol, sent_by_plus = val_str.split(" ")
+        m = PROTO_REGX.match(sent_protocol.strip)
+        @protocol = m[1] 
+        @version = m[2] 
+        @transport = m[3] 
+        m = SENT_WPORT_REGX.match(sent_by_plus.strip)
+        if m
+          @sent_by_ip = m[1] 
+          @sent_by_port = m[2] 
+        else
+          m = SENT_WOPORT_REGX.match(sent_by_plus.strip)
+          if m
+            @sent_by_ip = m[1]  
+          end
+        end
+        @header_params = SipperUtil.parameterize_header(val_str)[1]
+      end  # parse or do not parse
+      self 
+    end    # assign method
+  end      # via class
+  
+  
+  # Address header like To, From, Contact, Reply-To etc. 
+  # 
+  # To header 
+  # ---------
+  # To        =  ( "To" / "t" ) HCOLON ( name-addr
+  #           / addr-spec ) *( SEMI to-param )
+  #           to-param  =  tag-param / generic-param
+  # name-addr      =  [ display-name ] LAQUOT addr-spec RAQUOT
+  # addr-spec      =  SIP-URI / SIPS-URI / absoluteURI
+  # 
+  # --------------
+  # Example
+  # To: Bob <sip:bob@biloxi.com>;tag=a6c85cf     
+  #     
+  class AddressHeader < Header
+    attr_accessor :display_name, :uri
+    attr_accessor :only_addr_spec
+    protected :only_addr_spec
+    
+    DISPLAY_NAME_REGX = /^[\w ]*?</
+    URI_EXTRACT_REGX  = /<.+?>/
+    
+    def dup
+      obj = super
+      obj.display_name = self.display_name.dup
+      obj.uri  = self.uri.dup
+      obj.only_addr_spec = self.only_addr_spec.dup
+      obj
+    end
+    
+    def header_value
+      return nil unless @uri
+      if @display_name && @display_name.length>0
+        sprintf("%s <%s>", @display_name, @uri.to_s) 
+      else
+        sprintf("<%s>", @uri.to_s)
+      end
+    end
+    
+    
+    def assign(val_str, parse=true)
+      unless parse
+        cache_and_clear(val_str, 
+                        [:@display_name, :@uri ])
+      else  
+        @frozen_str = nil      
+        m = DISPLAY_NAME_REGX.match(val_str)
+        if m
+          @display_name = m[0][0...-1].strip  if m[0].length > 1
+        else
+          @display_name = ""
+        end
+        @uri, remainder = _extract_uri(val_str) 
+        if remainder
+          @header_params = SipperUtil.parameterize_header(remainder)[1]
+        else
+          @header_params = {}
+        end
+      end  # parse or assign
+      self 
+    end    # assign method
+    
+    def _extract_uri(str)
+      if m = URI_EXTRACT_REGX.match(str)
+        #[m[0][1...-1], m.post_match]
+        [URI::SipUri.new.assign(m[0][1...-1]), m.post_match] 
+      else
+        @only_addr_spec = true
+        #[str, nil]
+        [URI::SipUri.new.assign(str), nil] 
+      end   
+    end
+    
+    private :_extract_uri
+    
+  end
+  
+  class To < AddressHeader
+    def initialize
+      @name = "To"
+      super
+    end
+  end
+  
+  class From < AddressHeader
+    def initialize
+      @name = "From"
+      super
+    end
+  end
+  
+  
+  class Route < AddressHeader
+    def initialize
+      @name = "Route"
+      super
+    end
+  end
+  
+  class RecordRoute < AddressHeader
+    def initialize
+      @name = "Record-Route"
+      super
+    end
+  end
+  
+  class ReferTo < AddressHeader
+    def initialize
+      @name = "Refer-To"
+      super
+    end
+  end
+  
+  
+  
+  class Contact < AddressHeader
+    
+    def initialize
+      @name = "Contact"
+      super
+    end
+    
+    def header_value
+      return nil unless @uri
+      if @display_name && @display_name.length>0
+        sprintf("%s <%s>", @display_name, @uri.to_s) 
+      else
+        if @uri.to_s == "*"
+          "*"
+        else 
+          sprintf("<%s>", @uri.to_s)
+        end
+      end
+    end
+  end
+  
+  class PAssertedIdentity < AddressHeader
+    
+    def initialize
+      @name = "P-Asserted-Identity"
+      super
+    end
+    
+  end
+  
+  # From RFC 2617
+  # challenge = "Digest" digest-challenge
+  # digest-challenge = 1#( realm | [ domain ] | nonce |
+  #[ opaque ] |[ stale ] | [ algorithm ] |
+  #[ qop-options ] | [auth-param] )
+  #domain = "domain" "=" <"> URI ( 1*SP URI ) <">
+  #URI = absoluteURI | abs_path
+  #nonce = "nonce" "=" nonce-value
+  #nonce-value = quoted-string  
+  #opaque = "opaque" "=" quoted-string
+  #stale = "stale" "=" ( "true" | "false" )
+  #algorithm = "algorithm" "=" ( "MD5" | "MD5-sess" |
+  #token )
+  #qop-options = "qop" "=" <"> 1#qop-value <">
+  #qop-value = "auth" | "auth-int" | token
+  #
+  # Example --
+  # WWW-Authenticate: Digest realm="atlanta.com",
+  # domain="sip:boxesbybob.com", qop="auth",
+  # nonce="f84f1cec41e6cbe5aea9c8e88d359",
+  # opaque="", stale=FALSE, algorithm=MD5
+  # ------
+  # Example --
+  # Proxy-Authenticate: Digest realm="atlanta.com",
+  # domain="sip:ss1.carrier.com", qop="auth",
+  # nonce="f84f1cec41e6cbe5aea9c8e88d359",
+  # opaque="", stale=FALSE, algorithm=MD5
+  
+  class Authenticate < Header
+    attr_accessor :scheme, :realm, :domain, :nonce, :opaque, :stale, :algorithm,
+    :qop
+    
+    def initialize
+      @name = "Authenticate"
+      super
+    end
+    
+     def dup
+      obj = super
+      obj.scheme = self.scheme.dup
+      obj.realm  = self.realm.dup
+      obj.domain = self.domain.dup
+      obj.nonce = self.nonce.dup
+      obj.opaque = self.opaque.dup
+      obj.stale = self.stale.dup
+      obj.algorithm = self.algorithm.dup
+      obj.qop = self.qop.dup
+      obj
+    end
+    
+    def header_value
+      return nil unless self.realm
+      str = sprintf("%s realm=%s", @scheme, self.realm)
+      str << ", domain=" << self.domain if self.domain
+      str << ", qop=" << self.qop if self.qop
+      str << ", nonce=" << self.nonce if self.nonce
+      str << ", opaque=" << self.opaque if self.opaque
+      str << ", stale=" << self.stale.to_s.upcase if self.stale
+      str << ", algorithm=" << self.algorithm if self.algorithm
+      str
+    end
+    
+    
+    def assign(val_str, parse=true)
+      unless parse
+        cache_and_clear(val_str, 
+                        [:realm, :domain, :nonce, :opaque, :stale, :algorithm, :qop])
+      else  
+        @frozen_str = nil      
+        @scheme, challenge = val_str.split(" ", 2)
+        challenge.split(",").each do |x|
+          k, v = x.split("=", 2)   
+          self.send((k.strip+"=").to_sym, v.strip)
+        end
+        @header_params = {}
+        
+      end  # parse or assign
+      self 
+    end    # assign method
+  end
+  
+  # -- See SipperUtil.classify
+  # ++
+  class  WwwAuthenticate < Authenticate
+    def initialize
+      @name = "WWW-Authenticate"
+      super
+    end
+  end
+  
+  class ProxyAuthenticate < Authenticate  
+    
+    def initialize
+      @name = "Proxy-Authenticate"
+      super
+    end
+    
+  end
+  
+  
+  # Authorization header
+  # credentials = "Digest" digest-response
+  # digest-response = 1#( username | realm | nonce | digest-uri
+  # | response | [ algorithm ] | [cnonce] |
+  # [opaque] | [message-qop] |
+  # [nonce-count] | [auth-param] )
+  # username = "username" "=" username-value
+  # username-value = quoted-string
+  # digest-uri = "uri" "=" digest-uri-value
+  # digest-uri-value = request-uri ; As specified by HTTP/1.1
+  # message-qop = "qop" "=" qop-value
+  # cnonce = "cnonce" "=" cnonce-value
+  # cnonce-value = nonce-value
+  # nonce-count = "nc" "=" nc-value
+  # nc-value = 8LHEX
+  # response = "response" "=" request-digest
+  # request-digest = <"> 32LHEX <">
+  # LHEX = "0" | "1" | "2" | "3" |
+  # "4" | "5" | "6" | "7" |
+  # "8" | "9" | "a" | "b" |
+  # "c" | "d" | "e" | "f"
+  #
+  # Example -------------------
+  # Authorization: Digest username="bob",
+  # realm="biloxi.com",
+  # nonce="dcd98b7102dd2f0e8b11d0f600bfb0c093",
+  # uri="sip:bob@biloxi.com",
+  # qop=auth,
+  # nc=00000001,
+  # cnonce="0a4f113b",
+  # response="6629fae49393a05397450978507c4ef1",
+  # opaque="5ccc069c403ebaf9f0171e9517f40e41"
+  # ------------------------------
+  class Authorization < Header
+    attr_accessor :scheme, :username, :realm, :nonce, :uri, :nc, :opaque, :algorithm,
+    :qop, :cnonce, :response
+    
+    def initialize
+      @name = "Authorization"
+      super
+    end
+    
+    def dup
+      obj = super
+      obj.scheme = self.scheme.dup
+      obj.username = self.username.dup
+      obj.realm  = self.realm.dup
+      obj.nonce = self.nonce.dup
+      obj.uri = self.uri.dup
+      obj.nc = self.nc.dup
+      obj.opaque = self.opaque.dup
+      obj.algorithm = self.algorithm.dup
+      obj.qop = self.qop.dup
+      obj.cnonce = self.cnonce.dup
+      obj.response = self.response.dup
+      obj
+    end
+    
+    def header_value
+      return nil unless self.username
+      str = sprintf("%s username=%s", @scheme, self.username)
+      str << ", realm=" << self.realm if self.realm
+      str << ", nonce=" << self.nonce if self.nonce
+      str << ", uri=" << self.uri.to_s if self.uri.to_s
+      str << ", qop=" << self.qop if self.qop
+      str << ", nc=" << self.nc if self.nc
+      str << ", cnonce=" << self.cnonce if self.cnonce
+      str << ", response=" << self.response if self.response
+      str << ", opaque=" << self.opaque if self.opaque
+      str << ", algorithm=" << self.algorithm if self.algorithm
+      str
+    end
+    
+    
+    def assign(val_str, parse=true)
+      unless parse
+        cache_and_clear(val_str, 
+                        [:realm, :username, :nonce, :uri, :nc, :opaque, :algorithm, :qop, :cnonce, :response])
+      else  
+        @frozen_str = nil      
+        @scheme, rest = val_str.split(" ", 2)
+        rest.split(",").each do |x|
+          k, v = x.split("=", 2)  
+          if k =~ /uri/
+            self.send((k.strip+"=").to_sym, URI::SipUri.new.assign(v.strip))  
+          else
+            self.send((k.strip+"=").to_sym, v.strip)
+          end  
+        end
+        @header_params = {}
+      end  # parse or assign
+      self 
+    end    # assign method
+    
+  end
+  
+  class ProxyAuthorization < Authorization 
+    def initialize
+      @name = "Proxy-Authorization"
+      super
+    end
+  end
+  
+  # AuthenticationInfo = "Authentication-Info" ":" auth-info
+  # auth-info = 1#(nextnonce | [ message-qop ]
+  # | [ response-auth ] | [ cnonce ]
+  # | [nonce-count] )
+  # nextnonce = "nextnonce" "=" nonce-value
+  # response-auth = "rspauth" "=" response-digest
+  # response-digest = <"> *LHEX <">
+  # example Authentication-Info: nextnonce="47364c23432d2e131a5fb210812c"
+  class AuthenticationInfo < Header
+    attr_accessor :nextnonce, :nc, :rspauth, :qop, :cnonce
+    
+    def initialize
+      @name = "Authentication-Info"
+      super
+    end
+    def dup
+      obj = super
+      obj.nextnonce = self.nextnonce.dup
+      obj.nc = self.nc.dup
+      obj.rspauth = self.rspauth.dup
+      obj.qop = self.qop.dup
+      obj.cnonce = self.cnonce.dup
+      obj
+    end
+    
+    def header_value
+      return nil unless self.nextnonce
+      str = ""
+      str << "nextnonce=" << self.nextnonce if self.nextnonce
+      str << ", qop=" << self.qop if self.qop
+      str << ", nc=" << self.nc if self.nc
+      str << ", cnonce=" << self.cnonce if self.cnonce
+      str << ", response=" << self.response if self.response
+      str << ", rspauth=" << self.rspauth if self.rspauth
+      str
+    end
+    
+    
+    def assign(val_str, parse=true)
+      unless parse
+        cache_and_clear(val_str, 
+                        [:nextnonce, :nc, :rspauth, :qop, :cnonce])
+      else  
+        @frozen_str = nil      
+        val_str.split(",").each do |x|
+          k, v = x.split("=", 2)   
+          self.send((k.strip+"=").to_sym, v.strip)
+        end
+        @header_params = {}
+      end  # parse or assign
+      self 
+    end    # assign method
+    
+  end # auth info header
+  
+end   # module