Sipper 1.1.3

data/sipper/sip_headers/sipuri.rb

@@ -0,0 +1,352 @@
+
+=begin
+SIP-URI          =  "sip:" [ userinfo ] hostport
+                    uri-parameters [ headers ]
+SIPS-URI         =  "sips:" [ userinfo ] hostport
+                    uri-parameters [ headers ]
+userinfo         =  ( user / telephone-subscriber ) [ ":" password ] "@"
+user             =  1*( unreserved / escaped / user-unreserved )
+user-unreserved  =  "&" / "=" / "+" / "$" / "," / ";" / "?" / "/"
+password         =  *( unreserved / escaped /
+                    "&" / "=" / "+" / "$" / "," )
+hostport         =  host [ ":" port ]
+host             =  hostname / IPv4address / IPv6reference
+hostname         =  *( domainlabel "." ) toplabel [ "." ]
+domainlabel      =  alphanum
+                    / alphanum *( alphanum / "-" ) alphanum
+toplabel         =  ALPHA / ALPHA *( alphanum / "-" ) alphanum
+IPv4address    =  1*3DIGIT "." 1*3DIGIT "." 1*3DIGIT "." 1*3DIGIT
+IPv6reference  =  "[" IPv6address "]"
+IPv6address    =  hexpart [ ":" IPv4address ]
+hexpart        =  hexseq / hexseq "::" [ hexseq ] / "::" [ hexseq ]
+hexseq         =  hex4 *( ":" hex4)
+hex4           =  1*4HEXDIG
+port           =  1*DIGIT
+
+The BNF for telephone-subscriber can be found in RFC 2806 [9].  Note, however, that 
+any characters allowed there that are not allowed in the user part of the SIP URI MUST be escaped.
+
+uri-parameters    =  *( ";" uri-parameter)
+uri-parameter     =  transport-param / user-param / method-param
+                     / ttl-param / maddr-param / lr-param / other-param
+transport-param   =  "transport="
+                     ( "udp" / "tcp" / "sctp" / "tls"
+                     / other-transport)
+other-transport   =  token
+user-param        =  "user=" ( "phone" / "ip" / other-user)
+other-user        =  token
+method-param      =  "method=" Method
+ttl-param         =  "ttl=" ttl
+maddr-param       =  "maddr=" host
+lr-param          =  "lr"
+other-param       =  pname [ "=" pvalue ]
+pname             =  1*paramchar
+pvalue            =  1*paramchar
+paramchar         =  param-unreserved / unreserved / escaped
+param-unreserved  =  "[" / "]" / "/" / ":" / "&" / "+" / "$"
+
+headers         =  "?" header *( "&" header )
+header          =  hname "=" hvalue
+hname           =  1*( hnv-unreserved / unreserved / escaped )
+hvalue          =  *( hnv-unreserved / unreserved / escaped )
+hnv-unreserved  =  "[" / "]" / "/" / "?" / ":" / "+" / "$"
+
+=end
+
+# General form sip:user:password@host:port;uri-parameters?headers
+# user:password = userinfo component
+# 
+
+require 'uri'
+require 'util/sipper_util'
+require 'ruby_ext/object'
+require 'facets/core/hash/reverse_merge'
+require 'sip_logger'
+require 'ruby_ext/mutable_class'
+require 'cgi'
+
+module URI                   
+  
+  class SipUri
+    include SipLogger
+    
+    attr_accessor  :proto, :user, :password, :host, :port, 
+    :uri_params, :headers, :frozen_str
+    
+    
+    alias_method :old_dup, :dup
+    
+    ASSIGN = /=$/.freeze
+    
+    COLON = /:/.freeze
+    SCOLON = /;/.freeze
+    AMP = /&/.freeze
+    QUES = /\?/.freeze
+    AT = /@/.freeze
+    EQL = /=/.freeze
+    DQ = /\"/.freeze
+    
+    def dup
+      obj = self.old_dup  
+      obj.frozen_str = self.frozen_str.dup 
+      obj.proto = self.proto.dup 
+      obj.user = self.user.dup
+      obj.password = self.password.dup
+      obj.host = self.host.dup
+      obj.port = self.port.dup
+      obj.uri_params = self.uri_params.dup
+      obj.headers = self.headers.dup
+      obj
+    end
+    
+    def ==(other)
+      return true if self.object_id==other.object_id   
+      self.to_s == other.to_s
+    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)
+      self.to_s == other.to_s
+    end
+    
+    # Returns the complete formatted URI
+    # this is the default format method.
+    # sip:user:password@host:port;uri-parameters?headers
+    def _format
+      return nil unless self.host  
+      str = self.proto.dup
+      str << ":"
+      str << self.user if self.user
+      if self.user && self.password
+        str << ":"
+        str << self.password
+      end  
+      str << "@" if self.user
+      str << self.host
+      if self.port
+        str << ":"
+        str << self.port.to_s
+      end
+      if self.uri_params
+        self.uri_params.each do |k,v|
+          if v
+            if v == ""
+              str << ";" << k 
+            else
+              str << ";" << k << "=" << v 
+            end
+          end
+        end
+      end
+      
+      if self.headers
+        first = true
+        self.headers.each do |k,v|
+          if v
+            if v == ""
+              if first
+                str << "?" << k
+                first = false
+              else
+                str << "&" << k
+              end
+            else
+              if first
+                str << "?" << SipperUtil.headerize(k) << "=" <<  CGI.escape(v.to_s) 
+                first = false
+              else
+                str << "&" << SipperUtil.headerize(k) << "=" << CGI.escape(v.to_s)
+              end              
+            end
+          end
+        end
+      end
+      str
+    end
+    private :_format
+    
+    
+    
+    def cache_and_clear(val_str, iv_arr)
+      @frozen_str = val_str
+      @headers = {}
+      @uri_params = {}
+      clear_ivs(iv_arr)
+    end
+    protected :cache_and_clear
+    
+    #  sip:user:password@host:port;uri-parameters?headers
+    def assign(val_str, parse=true)
+      if (!parse || val_str=="*")
+        cache_and_clear(val_str, [:@proto, :@user, :@password, :@host, :@port])
+      else
+        @frozen_str = nil
+        str = val_str
+        @headers = {}
+        @uri_params = {}
+        hsa = str.split(QUES)  # done to avoid a COLON appearing in a header
+        _extract_headers(hsa[1]) if hsa.length > 1
+        csa = hsa[0].split(COLON) #colon separated array
+        
+        
+        case csa.length
+          # sip:host;uri-parameters
+          # sip:user@host;uri-parameters
+        when 2     
+          @proto = csa[0] 
+          if idx=csa[1].index(SCOLON)
+            if aidx=csa[1].index(AT)
+              @user = csa[1][0...aidx]
+              @host = csa[1][aidx+1...idx]
+            else
+              @host = csa[1][0...idx]
+            end  
+            _extract_params(csa[1])
+          else
+            if aidx=csa[1].index(AT)
+              @user = csa[1][0...aidx]
+              @host = csa[1][aidx+1..-1]
+            else
+              @host = csa[1]
+            end
+          end
+          
+          # <1> sip:user@host:port;uri-parameters  
+          # or <2> sip:user:password@host;uri-parameters
+          # or <3> sip:host:port;uri-parameters
+        when 3     
+          @proto = csa[0]
+          if idx=csa[1].index(AT) #first form
+            @user = csa[1][0...idx]
+            @host = csa[1][idx+1..-1]
+            if idx=csa[2].index(SCOLON)
+              @port = csa[2][0...idx]
+              _extract_params(csa[2])
+            else
+              @port = csa[2]
+            end
+          elsif  idx=csa[2].index(AT) #second form
+            @user = csa[1]
+            asa = csa[2].split(AT)
+            @password = asa[0]
+            if idx=asa[1].index(SCOLON)
+              @host = asa[1][0...idx]
+              _extract_params(asa[1])
+            else
+              @host = asa[1]
+            end
+          else  #third form
+            @host = csa[1]
+            if idx=csa[2].index(SCOLON)
+              @port = csa[2][0...idx]
+              _extract_params(csa[2])
+            else
+              @port = csa[2]
+            end
+          end
+          
+          #  sip:user:password@host:port;uri-parameters?headers  
+        when 4
+          @proto = csa[0]
+          @user = csa[1]
+          asa = csa[2].split(AT)
+          @password = asa[0]
+          @host = asa[1]
+          if idx=csa[3].index(SCOLON)
+            @port = csa[3][0...idx]
+            _extract_params(csa[3])
+          end    
+        end  
+      end 
+      self
+    end
+    
+    
+    # out of xyz;uri-parameters?headers
+    # takes xyz;uri-parameters
+    def _extract_params(str)
+      @uri_params = SipperUtil.parameterize_header(str)[1]    
+    end
+    private :_extract_params
+    
+    # out of xyz;uri-parameters?headers
+    # takes 'headers'
+    def _extract_headers(str)
+      
+      asa = str.split(AMP)
+      @headers = {}
+      asa.each do |hdr|
+        esa = hdr.split(EQL)
+        hname = SipperUtil.methodize(esa[0])
+        if esa[1]
+          
+          if esa[1] =~ DQ
+            hv = esa[1][1...-1]
+          else
+            hv = esa[1]
+          end
+          hv = CGI.unescape(hv)
+          @headers[hname] = SipperUtil.find_parser_and_parse(hname, hv, true)
+        end  
+      end  
+    end
+    private :_extract_headers
+    
+    
+    
+    def get_param(param)
+      @uri_params[param.to_s]  
+    end
+    
+    def add_param(param, val)
+      @uri_params[param.to_s] = val
+    end
+    
+    def has_param?(key)
+      @uri_params.has_key?(key.to_s)
+    end
+    
+    def remove_param(param)
+      @uri_params.delete(param.to_s)  
+    end
+    
+    
+    
+    def get_header(hdr)
+      @headers[SipperUtil.methodize(hdr)]  
+    end
+    
+    def add_header(hdr, val)
+      hname = SipperUtil.methodize(hdr)
+      @headers[hname] = SipperUtil.find_parser_and_parse(hname, val, true)
+    end
+    
+    def has_header?(key)
+      @headers.has_key?(SipperUtil.methodize(key))
+    end
+    
+    def remove_header(hdr)
+      @headers.delete(SipperUtil.methodize(hdr))  
+    end
+    
+    
+  end
+  
+end  

data/sipper/sip_logger.rb

@@ -0,0 +1,65 @@
+require 'log4r'
+require 'log4r/configurator'
+require 'modified_pattern_formatter'
+require 'sipper_configurator'
+require 'bin/common'
+
+module SipLogger
+  include Log4r
+  SipperUtil::Common.set_environment()
+  Configurator['logpath'] = SipperConfigurator[:LogPath]||(SipperConfigurator[:LogPath]= File.join(File.dirname(__FILE__), "logs"))
+  Configurator['pid'] = Process.pid.to_s
+  Configurator['udfname'] = $ULOGNAME || ""
+  if SipperConfigurator[:ConfigPath]
+    Configurator.load_xml_file File.join(SipperConfigurator[:ConfigPath],"log4r.xml")
+  else
+    Configurator.load_xml_file File.join(File.dirname(__FILE__), "config", "log4r.xml")  
+  end
+  
+  @@class_named_loggers = {}  #configured loggers only
+  
+  Logger.each_logger do |logger|
+    @@class_named_loggers[logger.name] = logger 
+  end
+   
+  # look up logger by full name eg. siplog::request
+  def SipLogger.[](arg)
+    Logger[arg]
+  end
+  
+  def SipLogger.each &block
+    Logger.each_logger(&block)
+  end
+  
+  # gets the class named logger
+  def logger
+    @@class_named_loggers[self.class_name.downcase]
+  end
+  
+  # the log methods
+  def logd(arg)
+    logger.debug(arg) if logger.debug?  
+  end
+  
+  def logi(arg)
+    logger.info(arg) if logger.info?  
+  end
+  
+  def logw(arg)
+    logger.warn(arg) if logger.warn?  
+  end
+  
+  def loge(arg)
+    logger.error(arg) if logger.error?  
+  end
+  
+  def logf(arg)
+    logger.fatal(arg) if logger.fatal?  
+  end
+  # Direction I/O (incoming/outgoing), remore ip, remote port, message
+  def logsip(direction, rip, rp, lip, lp, msg)
+    SipLogger['sipmsgtracelog'].debug("\nremote #{rip}:#{rp}\nlocal #{lip}:#{lp}\n----------#{direction}----------\n#{msg}\n---------------------\n")
+  end
+  
+  
+end

data/sipper/sip_message_router.rb

@@ -0,0 +1,231 @@
+require 'transport/udp_transport'
+require 'sip_logger'
+require 'util/sipper_util'
+require 'message'
+require 'request'
+require 'response'
+require 'session'
+require 'udp_session'
+require 'util/timer/timer_task'
+require 'stray_message_manager'
+require 'sipper_http/sipper_http_response'
+
+class SipMessageRouter
+
+  include SipLogger
+  include SipperUtil
+  
+  attr_reader :tg, :running
+  
+  def initialize(queue, num_threads=5)
+    @q = queue
+    @num_threads = num_threads
+    @tg = ThreadGroup.new
+    @running = false  
+    @run = false
+    # todo running and run is not thread safe 
+    log_and_raise "Message Queue is not set", ArgumentError unless @q
+  end
+  
+  
+  def start
+    @run = true
+    1.upto(@num_threads) do |i|
+      @tg.add(
+        Thread.new do
+          Thread.current[:name] = "WorkerThread-"+i.to_s
+          while @run
+            msg = @q.pop
+            #logd("Message #{msg} picked up from queue")
+            logi("Message picked from queue, now parsing")
+            r = Message.parse(msg)
+            2.times do  # one optional retry
+              case r
+              when Request
+                logd("REQUEST RECEIVED #{r}")
+                logsip("I", r.rcvd_from_info[3], r.rcvd_from_info[1], r.rcvd_at_info[0], r.rcvd_at_info[1], r)
+                if r.to_tag && !r.attributes[:_sipper_initial]
+                  # call_id, local, remote
+                  s = SessionManager.find_session(r.call_id, r.to_tag, r.from_tag)  
+                  if s
+                    s.on_message r
+                    break
+                  else
+                    if hndlr = SIP::StrayMessageManager.stray_message_handler
+                      logd("Found a stray message handler for the request, invoking it")
+                      ret = hndlr.handle(r)
+                      case ret[0]
+                      when SIP::StrayMessageHandler::SMH_DROP
+                        logw("A stray request #{r.method} being dropped by SMH")
+                        break
+                      when SIP::StrayMessageHandler::SMH_HANDLED
+                        logd("A stray request #{r.method} handled by SMH")
+                        break
+                      when SIP::StrayMessageHandler::SMH_RETRY
+                        logd("A stray request #{r.method} received, SMH retries")
+                        r = ret[1] if ret[1]
+                        if r.attributes[:_sipper_retried]
+                          logw("Already retried request now dropping")
+                          break
+                        else
+                          r.attributes[:_sipper_retried] = true
+                          next
+                        end
+                      when SIP::StrayMessageHandler::SMH_TREAT_INITIAL
+                        logd("A stray request #{r.method} received, SMH treating as initial")
+                        r = ret[1] if ret[1]
+                        if r.attributes[:_sipper_initial]
+                          logw("Already retried request now dropping")
+                          break
+                        else
+                          r.attributes[:_sipper_initial] = true
+                          next
+                        end
+                      else
+                        logw("A stray request #{r.method} SMH response not understood, dropping")
+                        break
+                      end
+                    else
+                      logw("A stray request #{r.method} received, dropping as no handler")
+                      break
+                    end  
+                  end
+                else
+                  # call_id, local, remote
+                  s = SessionManager.find_session(r.call_id, r.to_tag, r.from_tag)
+                  if s
+                    logd("Matched session #{s}")
+                    s.on_message r
+                    break
+                  else  # create a new session
+                    logd("No matching session found")
+                    ctrs = SIP::Locator[:Cs].get_controllers(r)
+                    logd("Initial request, total controllers returned are #{ctrs.size}")
+                    ctrs.each do |c| 
+                      if c.interested?(r)
+                        logd("Controller #{c.name} is interested in #{r.method}")
+                        #["AF_INET", 33302, "localhost.localdomain", "127.0.0.1"]
+                        # todo tcp support here
+                        if stp = c.specified_transport
+                          logd("Controller #{c.name} specified #{stp} transport")
+                          unless (stp[0] == r.rcvd_at_info[0] &&  
+                                  stp[1] == r.rcvd_at_info[1])
+                            next        
+                          end        
+                        end
+                        if(r.rcvd_from_info[0] == "AF_INET") # todo need to identify the transport 
+                          s = c.create_udp_session(r.rcvd_from_info[3], r.rcvd_from_info[1])
+                        end
+                        s.pre_set_dialog_id(r)  # to facilitate addition in session manager 
+                        SessionManager.add_session(s, false)
+                        s.on_message(r)
+                        break
+                      end
+                    end  # controller loop
+                    # if no controller on initial request then respond with 502
+                    unless s
+                      if hndlr = SIP::StrayMessageManager.stray_message_handler
+                        logd("Found a stray message handler for the init request, invoking it")
+                        ret = hndlr.handle(r) 
+                        case ret[0]
+                        when SIP::StrayMessageHandler::SMH_DROP
+                          logw("A stray init request #{r.method} being dropped by SMH")
+                          break
+                        when SIP::StrayMessageHandler::SMH_HANDLED
+                          logd("A stray init request #{r.method} handled by SMH")
+                          break
+                        when SIP::StrayMessageHandler::SMH_RETRY
+                          logd("A stray init request #{r.method} received, SMH retries")
+                          r = ret[1] if ret[1]
+                          if r.attributes[:_sipper_retried]
+                            logw("Already retried init request now dropping")
+                            break
+                          else
+                            r.attributes[:_sipper_retried] = true
+                            next
+                          end
+                        else
+                          logw("A stray init request #{r.method} SMH response not understood, dropping")
+                          break
+                        end
+                      else
+                        # todo either send a 502 or cleanup the log
+                        logw("A stray init request #{r.method} received, sending 502")
+                        break
+                      end
+                    else
+                      break
+                    end
+                  end  # if session found
+                end  # r.to-tag
+  
+              when Response
+                logd("RESPONSE RECEIVED #{r}")
+                logsip("I", r.rcvd_from_info[3], r.rcvd_from_info[1],  r.rcvd_at_info[0], r.rcvd_at_info[1], r)
+                # call_id, local, remote
+                s = SessionManager.find_session(r.call_id, r.from_tag, r.to_tag, (SipperUtil::SUCC_RANGE.include?r.code))
+                if s
+                  logd("Session found, sending response to session")
+                  s.on_message r
+                  break
+                else
+                  if hndlr = SIP::StrayMessageManager.stray_message_handler
+                    logd("Found a stray message handler for the response, invoking it")
+                    ret = hndlr.handle(r)
+                    case ret[0]
+                    when SIP::StrayMessageHandler::SMH_DROP
+                      logw("A stray response #{r.code} being dropped by SMH")
+                      break
+                    when SIP::StrayMessageHandler::SMH_HANDLED
+                      logd("A stray response #{r.code} handled by SMH")
+                      break
+                    when SIP::StrayMessageHandler::SMH_RETRY
+                      logd("A stray response #{r.code} received, SMH retries")
+                      r = ret[1] if ret[1]
+                      if r.attributes[:_sipper_retried]
+                        logw("Already retried response now dropping")
+                        break
+                      else
+                        r.attributes[:_sipper_retried] = true
+                        next
+                      end
+                    else
+                      logw("A stray response #{r.code} SMH response not understood, dropping")
+                      break
+                    end
+                  else
+                    logw("A stray response #{r.code} received, dropping")
+                    break
+                  end
+                end
+                
+              when SIP::TimerTask
+                logd("TIMER RECEIVED #{r}")
+                r.invoke
+                break
+              when Media::SipperMediaEvent
+                logd("Media Response/Event received")
+                r.session.on_message r
+                break
+              when SipperHttp::SipperHttpResponse
+                logd("Sipper HTTP response received")
+                r.dispatch
+              else
+                logw("DONT KNOW WHAT YOU SENT")
+                break
+              end
+            end
+          end
+        end
+      )
+    end
+    @running = true
+  end
+  
+  def stop
+    @run = false
+    @running = false
+    @tg.list.each { |t| t.kill }
+  end
+  
+end