Sipper 1.1.3

data/sipper/modified_pattern_formatter.rb

@@ -0,0 +1,119 @@
+# :include: ../rdoc/patternformatter
+#
+# == Other Info
+#
+# Version:: $Id: modified_pattern_formatter.rb,v 1.2 2007/06/23 07:26:56 rnakhan Exp $
+# Author::  Leon Torres <leon@ugcs.caltech.edu>
+
+require "log4r/formatter/formatter"
+  
+module Log4r
+  # See log4r/formatter/patternformatter.rb
+  class PatternFormatter < BasicFormatter
+  
+    # to get rid of warnings
+    remove_const :DirectiveTable
+    remove_const :DirectiveRegexp
+    remove_const :ISO8601
+    
+    # Arguments to sprintf keyed to directive letters
+    DirectiveTable = {
+      "c" => 'event.name',
+      "C" => 'event.fullname',
+      "d" => 'format_date',
+      "t" => 'event.tracer[0]',
+      "m" => 'event.data',
+      "h" => 'thread_name',
+      "M" => 'format_object(event.data)',
+      "l" => 'LNAMES[event.level]',
+      "%" => '"%"'
+    }
+  
+    # Matches the first directive encountered and the stuff around it.
+    #
+    # * $1 is the stuff before directive or "" if not applicable
+    # * $2 is the directive group or nil if there's none
+    # * $3 is the %#.# match within directive group
+    # * $4 is the .# match which we don't use (it's there to match properly)
+    # * $5 is the directive letter
+    # * $6 is the stuff after the directive or "" if not applicable
+  
+    DirectiveRegexp = /([^%]*)((%-?\d*(\.\d+)?)([cCdtmhMl%]))?(.*)/
+  
+    # default date format
+    ISO8601 = "%Y-%m-%d %H:%M:%S"
+    
+    attr_reader :pattern, :date_pattern, :date_method
+  
+    # Accepts the following hash arguments (either a string or a symbol):
+    #
+    # [<tt>pattern</tt>]         A pattern format string.
+    # [<tt>date_pattern</tt>]    A Time#strftime format string. See the
+    #                            Ruby Time class for details.
+    # [+date_method+]     
+    #   As an option to date_pattern, specify which
+    #   Time.now method to call. For 
+    #   example, +usec+ or +to_s+.
+    #   Specify it as a String or Symbol.
+    #
+    # The default date format is ISO8601, which looks like this:
+    # 
+    #   yyyy-mm-dd hh:mm:ss    =>    2001-01-12 13:15:50
+  
+    def initialize(hash={})
+      super(hash)
+      @pattern = (hash['pattern'] or hash[:pattern] or nil)
+      @date_pattern = (hash['date_pattern'] or hash[:date_pattern] or nil)
+      @date_method = (hash['date_method'] or hash[:date_method] or nil)
+      @date_pattern = ISO8601 if @date_pattern.nil? and @date_method.nil?
+      PatternFormatter.create_format_methods(self)
+    end
+
+    def thread_name
+      Thread.current[:name] || Thread.current.to_s
+    end
+
+    # PatternFormatter works by dynamically defining a <tt>format</tt> method
+    # based on the supplied pattern format. This method contains a call to 
+    # Kernel#sptrintf with arguments containing the data requested in
+    # the pattern format.
+    #
+    # How is this magic accomplished? First, we visit each directive
+    # and change the %#.# component to  %#.#s. The directive letter is then 
+    # used to cull an appropriate entry from the DirectiveTable for the
+    # sprintf argument list. After assembling the method definition, we
+    # run module_eval on it, and voila.
+    
+    def PatternFormatter.create_format_methods(pf) #:nodoc:
+      # first, define the format_date method
+      if pf.date_method
+        module_eval "def pf.format_date; Time.now.#{pf.date_method}; end"
+      else
+        module_eval <<-EOS
+          def pf.format_date
+            Time.now.strftime "#{pf.date_pattern}"
+          end
+        EOS
+      end
+      # and now the main format method
+      ebuff = "def pf.format(event)\n sprintf(\""
+      _pattern = pf.pattern.dup
+      args = [] # the args to sprintf which we'll append to ebuff lastly
+      while true # work on each match in turn
+        match = DirectiveRegexp.match _pattern
+        ebuff += match[1] unless match[1].empty?
+        break if match[2].nil?
+        # deal with the directive by inserting a %#.#s where %#.# is copied
+        # directy from the match
+        ebuff += match[3] + "s"
+        args << DirectiveTable[match[5]] # cull the data for our argument list
+        break if match[6].empty?
+        _pattern = match[6]
+      end
+      ebuff += '\n", ' + args.join(', ') + ")\n"
+      ebuff += "end\n"
+      module_eval ebuff
+    end
+  end
+end
+

data/sipper/proxy_controller.rb

@@ -0,0 +1,143 @@
+# WARNING: This is an experimental proxy controller, to be used for internal Sipper
+# UA testing functionality. 
+# This is not fully compliant yet. 
+
+require 'b2bua_controller'
+
+module SIP
+  class ProxyController < SIP::B2buaController
+    
+    t2xx_usage false
+    
+    def self.record_route(val)
+      @record_route = val
+    end
+    
+    def self.get_record_route
+      @record_route
+    end
+    
+    # Creates the proxy request based on the original request. Also creates the 
+    # peer session if it does not already exist. 
+    def create_proxy_request(session, orig_request=session.irequest, rip=SipperConfigurator[:DefaultRIP], 
+                             rp=SipperConfigurator[:DefaultRP])
+      peer_session = get_or_create_peer_session(session, rip, rp)
+      if peer_session.initial_state?
+        r = peer_session.create_initial_request(orig_request.method, orig_request.uri)
+        if self.class.get_record_route
+          r.record_route = "<sip:" + SipperConfigurator[:LocalSipperIP]+":"+ SipperConfigurator[:LocalSipperPort].to_s+";lr>"  
+        end
+      else
+        if(orig_request.method == "CANCEL")
+          r = peer_session.create_cancel
+        elsif(orig_request.method == "ACK")
+          r = peer_session.create_ack
+        else
+          r = peer_session.create_subsequent_request(orig_request.method)
+        end  
+      end
+       
+      my_via = r.via
+     
+      unless (orig_request.method == "CANCEL" || 
+       (orig_request.method == "ACK" && peer_session.iresponse.code >= 400))
+        r.copy_from(orig_request, :_sipper_all)
+        r.push_via(my_via)
+        r.format_as_separate_headers_for_mv(:via)
+        if (mf_hdr = r[:max_forwards])
+          mf = Integer(mf_hdr.to_s)
+          mf -= 1
+          r.max_forwards = mf.to_s
+        else
+          r.max_forwards = "70"
+        end
+      end
+      if  r[:route]
+        rt = r.route
+        if rt.uri.host = SipperConfigurator[:LocalSipperIP] && 
+          rt.uri.port == SipperConfigurator[:LocalSipperPort].to_s
+          r.pop_route  
+        end 
+      end
+      return r
+    end
+    
+    def create_proxy_response(session, orig_response=session.iresponse)
+      peer_session = get_peer_session(session)
+      if peer_session
+        r = peer_session.create_response(orig_response.code)
+        r.copy_from(orig_response,  :_sipper_all)
+        r.pop_via
+        return r
+      else
+        raise "Unable to create response"
+      end 
+    end
+    
+    def proxy_to(session, host, port)
+       get_or_create_peer_session(session, host, port)
+       relay_request(session)
+    end
+    
+    # Transparently passes / relays the request given a peer session 
+    # exists. 
+    def relay_request(session)
+      peer_session = get_peer_session(session)
+      if peer_session
+        r = create_proxy_request(session)
+        peer_session.send(r)
+      else
+        raise "Unable to relay the request" 
+      end
+    end
+    
+    # Transparently passes / relays the response given a peer session 
+    # exists. 
+    def relay_response(session)
+      peer_session = get_peer_session(session)
+      if peer_session
+        r = create_proxy_response(session)
+        peer_session.send(r)
+      else
+        raise "Unable to relay the response" 
+      end
+    end
+    
+    # Marks this b2bua as transparent which allows the relaying of requests and 
+    # responses between legs without any controller involvement. 
+    def go_transparent(session, state=true)
+      session[:_sipper_proxy_transparent] = state
+      peer_session = get_peer_session(session)
+      peer_session[:_sipper_proxy_transparent] = state if peer_session
+    end
+    
+    
+    # if there exists a peer session then we transparently send the request as a b2bua
+    # if transparent flag is on. 
+    def on_request(session)
+      peer_session = get_peer_session(session)
+      if peer_session && session[:_sipper_proxy_transparent]
+        relay_request(session)
+      else
+        super
+      end
+    end
+    
+    
+    # if there exists a peer session then we transparently pass the response as a b2bua
+    # if transparent flag is true 
+    def on_response(session)
+      peer_session = get_peer_session(session)
+      if peer_session && session[:_sipper_proxy_transparent]
+        if session.iresponse.code == 100
+          tr_hash = self.class.get_transaction_usage
+          return if tr_hash[:use_transactions] || tr_hash[:use_ict] 
+        end
+        relay_response(session)
+      else
+        super
+      end
+    end
+    
+  end
+end

data/sipper/registration.rb

@@ -0,0 +1,52 @@
+require 'session'
+require 'sip_logger'
+
+class Registration
+  include SipLogger
+  
+  class RegistrationData
+    attr_accessor :contact_uri, :expires, :q, :timestamp, :contact
+    def initialize(contact)
+      @contact = contact  
+    end
+  end
+  
+  def Registration.add_registration_data(contact, request)
+    reg_data = RegistrationData.new(contact.to_s)
+    reg_data.contact_uri = contact.uri
+        
+    if contact[:expires] : reg_data.expires = contact.expires
+    elsif request[:expires] : reg_data.expires = request.expires.header_value
+    else reg_data.expires = "3600"
+    end
+    
+    reg_data.q = contact[:q] ? contact.q : 0
+    reg_data.timestamp = Time.now
+    return reg_data
+  end
+  
+  def Registration.update_registration_data(contact, reg_list, request)
+    updated = false
+    reg_list.each do |registration|
+      if registration.contact_uri == contact.uri
+        index = reg_list.index(registration)
+        if contact[:expires] : registration.expires = contact.expires 
+        elsif request[:expires] : registration.expires = request.expires.header_value
+        else registration.expires = "3600"
+        end
+        registration.q = contact[:q] ? contact.q : 0
+        registration.timestamp = Time.now
+        if registration.expires.to_i == 0
+          reg_list.delete_at(index)
+        else  
+          reg_list[index] = registration
+        end  
+        updated =true
+      end
+    end  
+    return updated
+  end
+  
+  
+  
+end

data/sipper/request.rb

@@ -0,0 +1,109 @@
+require 'util/counter'
+require 'message'
+require 'sip_logger'
+require 'util/sipper_util'
+require 'sip_headers/sipuri'
+
+class Request < Message
+
+  include SipLogger
+  
+  # Headers can be added by an argument hash :to=>"mytoheader" 
+  # any "-" in the header replaced by a "_". The other way is to directly 
+  # set the header like invite.contact = "blah" in this case also you must also replace 
+  # any "-" in header with "_".
+ 
+  attr_accessor :method, :uri, :initial, :session_state_snapshot, :local_cseq_before_send
+  
+  # system headers
+  @str = %q{ @h = {
+           :call_id => sprintf("_PH_GCNT_-%d@_PH_LIP_",  Process.pid),
+           :from => "Sipper <sip:sipper@_PH_LIP_:_PH_LP_>;tag=_PH_LCTG_",
+           :to => "Sut <sip:sut@_PH_RIP_:_PH_RP_>",
+           :cseq => sprintf("_PH_LCNTS_ %s", @method),
+           :via => "SIP/2.0/_PH_TRANS_ _PH_LIP_:_PH_LP_;branch=z9hG4bK-_PH_LCNTS_-_PH_LCNTR_-_PH_GCNT_-_PH_RND_",
+           :contact => "<sip:_PH_LIP_:_PH_LP_;transport=_PH_TRANS_>",
+           :max_forwards => "70"
+          } }
+  
+  
+  class <<self
+    attr_reader :str
+  end
+  
+  Request.class_eval Request.str 
+  
+  
+  def Request.sys_hdrs
+    @h.keys
+  end
+  
+  
+  def initialize(method, uri, *hh)
+    super(*hh)
+    @method = method.to_s.upcase
+    if uri.class == URI::SipUri
+      @uri = uri.dup
+    else
+      @uri = URI::SipUri.new.assign(uri.to_s)
+    end
+    logi("Creating a new #{method} request for #{uri}")
+  end
+
+  # This is a low level method and allows the caller to custom 
+  # create the initial requests. If you do not want to create 
+  # (and manage) all individual headers then you should use
+  # Session#create_initial_request.
+  def Request.create_initial *args
+    r = new(*args)
+    r.initial = true
+    r.incoming = false
+    r.create_system_headers
+    r.define_from_hash(args[2]) if args[2]
+    return r
+  end
+  
+  # This method should not be used if all you want is to create 
+  # a subsequent request from a controller. This is a low level 
+  # method and allows the caller to custom create the subsequent
+  # requests. If you do not want to manipulate (and manage) all 
+  # individual headers then you should use Session#create_subsequent_request.
+  def Request.create_subsequent *args
+    r = new(*args)
+    r.initial = false
+    r.incoming = false
+    return r
+  end
+  
+  
+  def Request.parse(req_arr, recvd_options)
+    str = req_arr[0].split     # INVITE sip:sut@202.17.31.207:5060 SIP/2.0
+    r = new(str[0].strip, str[1].strip)
+    r.parse_headers req_arr[1..-1]
+    r.incoming = true
+    # According to 3581
+    # In fact, the server MUST insert a "received" parameter
+    # containing the source IP address that the request came from, even if
+    # it is identical to the value of the "sent-by" component.  Note that
+    # this processing takes place independent of the transport protocol.
+    if r.via 
+      r.via.received = recvd_options[:received_ip]
+      if r.via.has_param?(:rport)
+        r.via.rport = recvd_options[:received_port].to_s
+      end
+    end
+    return r
+  end
+  
+  
+  def to_s
+    msg = sprintf("%s %s SIP/2.0\r\n", @method, @uri.to_s)
+    msg = _format_message(msg)
+  end
+
+  def create_system_headers
+    instance_eval Request.str
+    define_from_hash @h
+  end
+  
+end

data/sipper/response.rb

@@ -0,0 +1,123 @@
+require 'util/counter'
+require 'message'
+require 'sip_logger'
+
+class Response < Message
+
+  include SipLogger
+ 
+  attr_accessor :code, :status
+  attr_writer :local
+  STATUS_MESSAGES = {
+    100 => "Trying",
+    180 => "Ringing",
+    182 => "Queued",
+    183 => "Session Progress",
+    200 => "OK",
+    202 => "Accepted",
+    300 => "Multiple Choices",
+    301 => "Moved Permanently", 
+    302 => "Moved Temporarily", 
+    305 => "Use Proxy", 
+    380 => "Alternative Service", 
+    400 => "Bad Request",
+    401 => "Unauthorized",  
+    402 => "Payment Required", 
+    403 => "Forbidden", 
+    404 => "Not Found",  
+    405 => "Method Not Allowed", 
+    406 => "Not Acceptable", 
+    407 => "Proxy Authentication Required", 
+    408 => "Request Timeout", 
+    409 => "Conflict", 
+    410 => "Gone", 
+    413 => "Request Entity Too Large", 
+    414 => "Request-URI Too Long", 
+    415 => "Unsupported Media Type", 
+    416 => "Unsupported URI Scheme", 
+    420 => "Bad Extension", 
+    421 => "Extension Required", 
+    423 => "Interval Too Brief", 
+    480 => "Temporarily Unavailable", 
+    481 => "Call/Transaction Does Not Exist", 
+    482 => "Loop Detected", 
+    483 => "Too Many Hops", 
+    484 => "Address Incomplete", 
+    485 => "Ambiguous", 
+    486 => "Busy Here", 
+    487 => "Transaction Canceled", 
+    488 => "Not Acceptable Here", 
+    491 => "Request Pending", 
+    493 => "Undecipherable",
+    500 => "Server Error",
+    501 => "Not Implemented", 
+    502 => "Bad Gateway", 
+    503 => "Service Unavailable", 
+    504 => "Server Time-out", 
+    505 => "Version Not Supported", 
+    513 => "Message Too Large", 
+    503 => "Service Unavailable",
+    600 => "Busy Everywhere",
+    603 => "Decline", 
+    604 => "Does Not Exist Anywhere", 
+    606 => "Not Acceptable" 
+  }  
+  
+  def initialize(code, status=nil, *hh)
+    super(*hh)
+    @code = code
+    if status && status != "SELECT"
+      @status = status
+    else
+      @status = STATUS_MESSAGES[code] 
+      unless @status
+        @status = STATUS_MESSAGES[(code/100)*100]
+      end
+    end
+    logi("Creating a new #{code} response")
+  end
+  
+  # A low level method that allows to custom create the responses.
+  def Response.create *args
+    r = new(*args)
+    r.incoming = false
+    return r
+  end
+  
+  
+  def Response.parse(res_arr)
+    md = SIP_VER_PATT.match(res_arr[0]) #SIP/2.0 180 Ringing
+    str =  md.post_match.strip          # 180 Ringing
+    md = /\d+/.match(str)
+    r = new(md[0].to_i, md.post_match.strip)
+    r.parse_headers res_arr[1..-1]
+    r.incoming = true
+    return r
+  end
+  
+  def locally_generated?
+    @local
+  end
+  
+  def to_s
+    msg = sprintf("SIP/2.0 %s %s\r\n", @code, @status)
+    msg = _format_message(msg)
+  end
+  
+  # The method is to find out the corresponding request method of the received response.
+  def get_request_method
+    SipperUtil.cseq_method(self.cseq)  
+  end
+
+  def set_request(inRequest)
+     @request = inRequest
+  end
+
+  def get_request()
+     raise "No associated request." unless @request
+     return @request
+  end
+  
+end
+
+