Sipper 1.1.3

data/sipper/transaction/state_machine_wrapper.rb

@@ -0,0 +1,58 @@
+require 'delegate'
+require 'monitor'
+
+module SIP
+  module Transaction
+    SM_PROCEED = 9000
+    SM_PROCEED_NO_ACTION = 9001
+    SM_DO_NOT_PROCEED = 9002
+    
+    class StateMachineWrapper < SimpleDelegator
+      include MonitorMixin   # all state transitions are synchronized
+      
+      @@machines_covered = {}  # names of machines handled.  
+
+      def initialize(ctxt, txn_callback, sm_name)  # the context is the object that is driving the state machine
+        super(sm_name.new(ctxt))
+        @txn_callback = txn_callback
+        @ctxt = ctxt
+      end #initialize
+      
+      def self.bootstrap_machine(ctxt, sm_name)
+        unless @@machines_covered[sm_name]
+          ctxt.state_machine_transitions.each do |m|
+            before = ("before_"+m).to_sym
+            after  = ("after_"+m).to_sym
+            self.class_eval do
+              define_method(before) do
+                if @txn_callback && @txn_callback.respond_to?(before)
+                  return @txn_callback.send(before, @ctxt)
+                else
+                  SIP::Transaction::SM_PROCEED
+                end
+              end
+              define_method(after) do
+                if @txn_callback && @txn_callback.respond_to?(after)
+                  @txn_callback.send(after, @ctxt)
+                end
+              end
+              define_method(m.to_sym) do
+                ret = self.send(before)
+                return if ret == SIP::Transaction::SM_DO_NOT_PROCEED
+                @ctxt.mask_actions if ret == SIP::Transaction::SM_PROCEED_NO_ACTION
+                self.synchronize do  # all transitions are lock protected
+                  super
+                end
+                @ctxt.unmask_actions if ret == SIP::Transaction::SM_PROCEED_NO_ACTION
+                self.send(after)
+              end  
+            end 
+          end # transition methods
+          @@machines_covered[sm_name] = sm_name
+        end  
+        
+      end #bootstrap
+      
+    end #class
+  end
+end

data/sipper/transaction/transaction.rb

@@ -0,0 +1,212 @@
+require 'sipper_configurator'
+require 'statemap'
+
+module SIP
+  module Transaction
+    
+    T1 = 500 
+    T2 = 4000
+    T4 = 5000
+    Td = 32000  # 17.1.1.2
+    
+    Transactions = [:Ict, :Nict, :Ist, :Nist]
+    
+    
+    class BaseTransaction
+      attr_accessor :branch_id, :transport, :t1, :t2, :t4, :ta, :tb, :td, 
+                    :tg, :th, :ti, :tz, :te, :tf, :tk, :tj, :ty,
+                    :transaction_name, :txn_handler, 
+                    :message # the message is the message being sent or received by this transactions
+      
+      
+      def initialize(&block)
+        instance_eval(&block) if block_given? 
+      end
+      
+      
+      #------------------
+      # The two methods txn_send and txn_received are two general purpose methods
+      # that will be called by the TU as against the transcation type specific 
+      # methods defined on each type of transaction. 
+      def txn_send(msg)
+        raise "Unimplemented method txn_send by #{self}"
+      end
+      
+      def txn_received(msg)
+        raise "Unimplemented method txn_received by #{self}"
+      end
+      
+      # called when the session is being invalidated
+      def invalidate
+        @invalidated = true
+      end
+      #------------------ 
+      
+      # rewrite SM callbacks for masking
+      # each callback has to start with a "__"
+      def self.mask_callbacks 
+        self.instance_methods(false).grep(/^__/).each do |m|
+          mask = ("mask_"+m)
+          alias_method mask, m
+          define_method(m.to_sym) do |*args|
+            self.send(mask.to_sym, *args)  unless @mask_actions
+          end
+        end
+      end
+      
+      #---------SM Wrapper calls------
+      def mask_actions
+        @mask_actions = true
+      end
+      
+      def unmask_actions
+        @mask_actions = false
+      end
+      #------------------------------
+      
+        
+      def state
+        if @sm
+          @sm.getState.getName
+        else
+          nil
+        end
+      end
+      
+      # Returns the current value and resets the value to false (default).
+      def consume?
+        c = @consume
+        @consume = false
+        return c
+      end
+      
+      
+       # Returns the transition methods of the state machine. 
+      def state_machine_transitions
+        @transitions if @transitions 
+        @transitions = 
+        Kernel.const_get(@transaction_name.to_s + "State").instance_methods(false) - 
+          ["Default", "Entry", "Exit"]
+      end
+      
+      # Timer callback
+      def on_timer_expiration(timer_task)
+        if @invalidated
+         logi("This txn #{self} is invalidated, not firing timer #{timer_task}")
+         return
+        end
+      end
+        
+      def t1
+        return @t1 if @t1
+        @t1 = @t1 || SipperConfigurator[:TransactionTimers][:t1] || SIP::Transaction::T1
+      end
+      
+      def t2
+        return @t2 if @t2
+        @t2 = @t2 || SipperConfigurator[:TransactionTimers][:t2] || SIP::Transaction::T2
+      end
+      
+      def t4
+        return @t4 if @t4
+        @t4 = @t4 || SipperConfigurator[:TransactionTimers][:t4] || SIP::Transaction::T4
+      end
+      
+      # the starting value of timerA. <ICT> 
+      def ta
+        return @ta if @ta
+        @ta = self.t1 || SipperConfigurator[:TransactionTimers][:ta]
+      end
+      
+      # the value of timerB <ICT>
+      def tb
+        return @tb if @tb
+        @tb = self.t1*64 || SipperConfigurator[:TransactionTimers][:tb]
+      end
+      
+      # <ICT>
+      def td 
+        return @td if @td
+        @td = @td || SipperConfigurator[:TransactionTimers][:td] || SIP::Transaction::Td 
+      end
+      
+      # the value if timerY <IST>
+      # After having sent CANCEL the INVITE transaction also times out - 
+      #  However, a UAC canceling a request cannot rely on receiving a 487 
+      #  (Request Terminated) response for the original request, as an 
+      #  RFC 2543-compliant UAS will not generate such a response.  
+      #  If there is no final response for the original request in 
+      #  64*T1 seconds (T1 is defined in Section 17.1.1.1), the client 
+      #  SHOULD then consider the   original transaction cancelled and 
+      #  SHOULD destroy the client transaction handling the original request. 
+      def ty
+        return @ty if @ty
+        @ty = self.t1*64 || SipperConfigurator[:TransactionTimers][:ty]
+      end
+      
+      # the starting value of timerG <IST>
+      def tg
+        return @tg if @tg
+        @tg = self.t1 || SipperConfigurator[:TransactionTimers][:tg]
+      end
+      
+      # the value of timerH <IST>
+      def th
+        return @th if @th
+        @th = self.t1*64 || SipperConfigurator[:TransactionTimers][:th]
+      end
+      
+      # the value if timerI <IST>
+      def ti
+        return @ti if @ti
+        @ti = self.t4 || SipperConfigurator[:TransactionTimers][:ti]
+      end
+           
+      # the value if timerZ <IST>
+      # have a look at sipit bug http://bugs.sipit.net/show_bug.cgi?id=769
+      def tz
+        return @tz if @tz
+        @tz = self.t4 || SipperConfigurator[:TransactionTimers][:tz]
+      end
+      
+      #--- <NICT>-------
+      def te
+        return @te if @te
+        @te = self.t1 || SipperConfigurator[:TransactionTimers][:te]
+      end
+      
+      def tf
+        return @tf if @tf
+        @tf = self.t1*64 || SipperConfigurator[:TransactionTimers][:tf]
+      end
+      
+      def tk
+        return @tk if @tk
+        @tk = self.t4 || SipperConfigurator[:TransactionTimers][:tk]
+      end
+      #--------
+      
+      # the value if timerJ <NIST>
+      def tj
+        return @tj if @tj
+        @tj = self.t1*64 || SipperConfigurator[:TransactionTimers][:tj]
+      end
+      
+      def _send_to_transport(msg)
+        if msg.is_request?
+          rd = @tu.get_request_destination()
+        else
+          rd = @tu.get_response_destination(msg)
+        end
+        @transport = rd[0] if rd[0]
+        @msg_sent = @transport.send(msg, @tp_flags, rd[1], rd[2])
+        logd("Now record the outgoing message from #{self.transaction_name}") 
+        @tu.transaction_record("out", msg)
+      rescue 
+        @transport_err = true
+      end
+      
+      protected :_send_to_transport  
+    end
+  end
+end

data/sipper/transport/base_transport.rb

@@ -0,0 +1,84 @@
+require 'sipper_configurator'
+
+module Transport
+
+  # Pre filter : for incoming messages 
+  class TransportIngressFilter
+    
+    # Filter on anonymous Module because if the transport handler is defined inline then 
+    # we load the string twice, once in an anonymous module and once in top 
+    # level object. We do not want to register the transport handler twice. 
+    def self.inherited(child)
+      TransportIngressFilter.registered_filters << child.new unless child.to_s =~ /^#<Module/
+    end
+    
+    # default handler
+    def do_filter(msg)
+      msg
+    end
+    
+    @registered_filters = []
+    class << self; attr_reader :registered_filters end
+  end
+  
+  # Post filter : for outgoing messages
+  class TransportOutgressFilter
+  
+    def self.inherited(child)
+      TransportOutgressFilter.registered_filters << child.new unless child.to_s =~ /^#<Module/
+    end
+    
+    # default handler
+    def do_filter(msg)
+      msg
+    end
+    
+    @registered_filters = []
+    class << self; attr_reader :registered_filters end
+  end
+  
+  
+  class BaseTransport
+  
+    attr_reader :running, :ip, :port, :tid
+    
+    @@out_oa = nil
+    @@in_oa = nil
+    
+    def self.in_order=(order_arr)
+      @@in_oa = order_arr   
+    end
+    
+    def self.out_order=(order_arr)
+      @@out_oa = order_arr
+    end
+    
+    def self.in_filters
+      if @@in_oa
+        return TransportIngressFilter.registered_filters.sort do |x,y|
+            (@@in_oa.index(x.class.name)?@@in_oa.index(x.class.name):@@in_oa.length) <=> (@@in_oa.index(y.class.name)?@@in_oa.index(y.class.name):@@in_oa.length)
+        end
+      else
+        TransportIngressFilter.registered_filters
+      end     
+    end
+    
+    def self.out_filters
+      if @@out_oa
+        return TransportOutgressFilter.registered_filters.sort do |x,y|
+            (@@out_oa.index(x.class.name)?@@out_oa.index(x.class.name):@@out_oa.length) <=> (@@out_oa.index(y.class.name)?@@out_oa.index(y.class.name):@@out_oa.length)
+        end
+      else
+        TransportOutgressFilter.registered_filters
+      end
+    end
+    
+    def self.clear_all_filters
+      TransportIngressFilter.registered_filters.clear
+      TransportOutgressFilter.registered_filters.clear
+    end
+    
+    
+  end
+  
+end

data/sipper/transport/rel_unrel.rb

@@ -0,0 +1,19 @@
+module SIP
+  module Transport
+    
+    module ReliableTransport
+      def reliable?
+        true
+      end
+    end
+    
+    module UnreliableTransport
+      def reliable?
+        false
+      end
+    end
+    
+  end
+end
+  
+  

data/sipper/transport/transport_and_route_resolver.rb

@@ -0,0 +1,67 @@
+require 'ipaddr'
+
+module Transport
+
+  # This class resolves the address for the next hop destination, looking up the DNS 
+  # eventually and returning a tuple of addresses and transport to try. For now we just 
+  # do a simple name resolve of one address. 
+  # 
+  # RFC
+  # The destination for the request is then computed.  Unless there is local policy specifying 
+  # otherwise, the destination MUST be determined by applying the DNS procedures described in [4] 
+  # as follows.  If the first element in the route set indicated a strict router (resulting in 
+  # forming the request as described in Section 12.2.1.1), the procedures MUST be applied to the 
+  # Request-URI of the request .
+  # Otherwise, the procedures are applied to the first Route header field value in the request 
+  # (if one exists), or to the request's Request-URI if there is no Route header field present.  
+  # These procedures yield an ordered set of address, port, and transports to attempt. 
+  class TransportAndRouteResolver
+    
+    IP = /^(\d{1,3}\.){3}\d{1,3}$/.freeze
+    
+    def self.ascertain_transport_and_destination(msg)
+    
+      # if controller preference set then we chose the transport directly 
+      if stp = msg.attributes[:_sipper_controller_specified_transport]
+        tp = SIP::Locator[:Tm].get_udp_transport_with(stp[0], stp[1])  
+      end
+      
+      dest_uri = nil
+      if msg.is_request?
+        if msg.attributes[:_sipper_use_ruri_to_send]
+          dest_uri = msg.uri  
+        elsif msg[:route] && msg[:route].length > 0
+          dest_uri = msg.route.uri
+        else
+          dest_uri = msg.uri
+        end
+      end
+      # now find out rip, rp and transport from destination uri.
+      # check out http uri resolution.  Ruby URI library can be used here.
+      # Use the 3263 mechanism to look at the right destination and transport to use.
+      # For now fail if domain name is given.
+      # Assumptions-
+      # Assume 5060 if no port is given. 
+      # Assume sip:ip:port or sip:user@ip:port or sip:user@ip
+      # Assume UDP transport
+      
+      ip = dest_uri.host if dest_uri && dest_uri.respond_to?(:host)
+      
+      return [tp, nil, nil] unless IP =~ ip
+      
+      # simple valiadtion, todo must remove when you have 3263 lookup.
+      port = Integer((x=dest_uri.port) ? x : 5060)
+     
+      
+      # todo look for right transport, for now use udp
+      
+      # here we check if tp is already set as a result of controller specification
+      unless tp
+        tp = SIP::Locator[:Tm].get_udp_transport_for(ip, port) if ip && port
+      end  
+      [tp, ip, port]
+    end
+    
+  end
+  
+end

data/sipper/transport/udp_transport.rb

@@ -0,0 +1,156 @@
+require 'socket'
+require 'thread'
+require 'monitor'
+require 'util/message_fill'
+require 'sip_logger'
+require 'ruby_ext/object'
+require 'transport/rel_unrel'
+require 'transport/base_transport'
+require 'message'
+
+# todo have a base transport class and also have module Transport
+module Transport
+  class UdpTransport < BaseTransport
+  
+    include SipLogger
+    include SIP::Transport::UnreliableTransport  # returns false for reliable? check.
+    
+    private_class_method :new
+    
+    MAX_RECV_BUFFER = 65500
+      
+    @@instance = {}
+    @@class_lock = Monitor.new
+    
+    # comment : need to synchronize on queue and running paramaters
+    
+    
+    def initialize(ip, port, external_q)
+      @tid = "UDP"
+      if external_q
+        @queue = external_q
+      else 
+        @queue = Queue.new 
+      end
+      @ip = ip
+      @port = port
+      @running = false
+      @running_lock = Monitor.new 
+      logi("Created a new udptransport with #{@ip} and #{@port}")
+    end
+    
+    
+    def to_s
+      @str = "udptransport ip=#{@ip}, port=#{@port}" unless @str
+      @str
+    end
+    
+    def UdpTransport.instance(i, p, q=nil)
+      @@class_lock.synchronize do 
+        k = i.to_s + ":" + p.to_s
+        @@instance[k] = new(i, p, q) unless @@instance[k]
+        @@instance[k]  
+      end
+    end
+    
+    
+    def start_transport
+      logi("Starting the transport #{self}")
+      #@running_lock.synchronize do
+        fail "Already running" if @running
+        @running = true
+      #end
+      t = Thread.new do
+        Thread.current[:name] = "UDPThread-"+@ip.to_s+"-"+@port.to_s
+        @sock = UDPSocket.new
+        @sock.bind(@ip, @port)
+        logd "binded ..#{@port}"
+        begin 
+          loop do
+            #puts "starting the select loop.."
+            IO.select([@sock])
+            mesg = @sock.recvfrom_nonblock(MAX_RECV_BUFFER)
+            BaseTransport.in_filters.each do |in_filter|
+              logd("Ingress filter applied is #{in_filter.class.name}")
+              mesg[0] = in_filter.do_filter(mesg[0])
+              break unless mesg[0]
+            end
+            #["msg", ["AF_INET", 33302, "localhost.localdomain", "127.0.0.1"]]
+            if logger.debug?
+              logd("Message received is - ")
+              mesg.each_with_index {|x,i| logd(" > mesg[#{i}]=#{x}")}    
+            end
+            if mesg[0]
+              mesg << [@ip, @port]
+              @queue << mesg
+              #logi("Message recvd on transport and enqueued on #{@queue}")
+            else
+              logi("Message recvd on transport does not have the payload or is consumed by a filter, not enquing")
+            end
+            break if mesg[0] =~ /poison dart/
+          end  # loop
+          rescue  => detail
+            logd detail.backtrace.join("\n") 
+            loge("Exception #{detail} occured for #{self}")
+            @sock.close
+            break
+        end  # exception
+      end 
+      @t_thread = t
+      return t
+    end 
+    
+    def stop_transport
+      logi("Stopping transport #{self}")
+      #@running_lock.synchronize do
+        fail "Already stopped" unless @running
+        @running = false
+      #end
+      @sock.close
+      @t_thread.kill
+      k = @ip.to_s + ":" + @port.to_s
+      @@instance[k] = nil
+    end
+    
+   
+    def send(mesg, flags, *ipport)
+      if mesg.class <= ::Message 
+        smesg = mesg.to_s
+      else
+        smesg = mesg
+      end 
+      logi("Sending message #{smesg} using #{self} to ip=#{ipport[0]} and port=#{ipport[1]}")
+      if smesg =~ /_PH_/
+        logd("Now filling in message of class #{smesg.class}")
+        SipperUtil::MessageFill.sub(smesg, :trans=>@tid, :lip=>@ip, :lp=>@port.to_s) 
+      else
+        logd("Nothing to fill in message of class #{smesg.class}")
+      end
+      
+      BaseTransport.out_filters.each do |out_filter|
+        logd("Outgress filter applied is #{out_filter.class.name}")
+        smesg = out_filter.do_filter(smesg)
+        break unless smesg
+      end
+      logsip("O", ipport[0], ipport[1], @ip, @port, smesg)
+      if smesg
+        @sock.send(smesg, flags, *ipport)
+      else
+        logi("Not sending the message as it has probably been nilled out by a filter")
+      end
+      smesg  # returns for recorder etc.
+    end
+    
+    def get_next_message
+      @queue.pop
+    end
+    
+    
+    def running
+      @running_lock.synchronize do
+        return @running
+      end
+    end
+    
+  end
+end