Sipper 1.1.3

data/sipper/session_manager.rb

@@ -0,0 +1,170 @@
+require 'monitor'
+
+require 'session'
+require 'sip_logger'
+
+class SessionManager
+  include SipLogger
+    
+  # When a new call is created and the request is sent out only From tag
+  # is present, at this time the entry is local_tag+call_id and the session
+  # gets in the half_dialogs hash.  
+  # 
+  # When a response is received, the full_dialogs is searched first, if not 
+  # found then half_dialogs is searched. If the response is final and has a To tag  
+  # we transition the session from half_dialogs hash to full_dialogs
+  # hash with the key as local_tag+call_id+remote_tag, actually half dialog entry still
+  # remains to absorb retransmissions. 
+  # 
+  # When request is received and it contains no To tag then a new session is
+  # created and entry goes to half dialogs when a response is sent out the session 
+  # transitions to full_dialogs hash if the response is final.
+  # 
+  # We do not remove the entry from the half dialog maps even when getting or receiving 
+  # final responses. Instead we record the half dialog key in the session object and also
+  # add the session in the full dialog map. This is to take care of retransmission of both 
+  # Request and Responses (if we retransmitted request before). Then entry shall be removed 
+  # from the half dialog map when the transaction completes or on session termination.  
+  # 
+  # If a request is received with a To tag, only full_dialogs is searched.
+  # 
+  # The session is removed either explicitly by calling invalidate or when
+  # timeout happens todo timeouts
+  # 
+  @@full_dialogs = {}
+  # both local and remote dialogs are half dialogs
+  # local is for requests generated by us and remote
+  # or the far end UA. We transition to full map on dialog establishment from 
+  # both of these.
+  @@half_dialogs = {}                     
+  @@sm_lock = Monitor.new
+  
+  
+  # Invoked on all incoming responses with or w/out remote tag
+  # and incoming requests with or without both tags. 
+  # For requests without to tag a new session is created and when 
+  # responded to, it transitions to full_dialogs from half dialogs
+  # 
+  def SessionManager.find_session call_id, local, remote, final=false
+    SipLogger['siplog::sessionmanager'].info("Finding session for key |#{local}|#{call_id}|#{remote}|")
+    #SipLogger['siplog::sessionmanager'].debug("Half map at this time is #{@@half_dialogs.keys.join(',')}")
+    #SipLogger['siplog::sessionmanager'].debug("Full map at this time is #{@@full_dialogs.keys.join(',')}")
+    s = nil
+    key = sprintf("|%s|%s|%s|",local, call_id, remote)
+    @@sm_lock.synchronize do
+      if remote
+        if local 
+          s = @@full_dialogs[key]
+          unless s
+            SipLogger['siplog::sessionmanager'].info("Not found in full dialog map looking in half")
+            key_l = sprintf("|%s|%s|%s|",local, call_id, nil)
+            if (s = @@half_dialogs[key_l])
+              if final
+                #@@half_dialogs[key_l] = nil #instead of removing from half, just record half dialog.
+                s.half_dialog_key = key_l
+                s.session_map = :full
+                s.session_key = key 
+                SipLogger['siplog::sessionmanager'].info("Found in half copying to full")
+              else
+                SipLogger['siplog::sessionmanager'].info("Found in half NOT copying to full")
+              end
+              @@full_dialogs[key] = s
+            end
+          else
+            SipLogger['siplog::sessionmanager'].info("Found in the full dialogs map")
+            # cleaning up in case a NOTIFY came before 2xx and now we have 2xx
+            if final
+              key_l = sprintf("|%s|%s|%s|",local, call_id, nil)
+              #@@half_dialogs[key_l] = nil  #instead of removing from half, just record half dialog.
+              s.half_dialog_key = key_l
+              s.session_map = :full
+              s.session_key = key
+              SipLogger['siplog::sessionmanager'].info("Found in full NOW moving to full")
+            end
+          end
+        else  #local not present but remote present
+          s = @@half_dialogs[key]
+        end
+      else #remote not present      
+        s = @@half_dialogs[key]
+      end
+    end
+    return s
+  end
+    
+  
+  # addition of session happens on new req out, resp out for new req,
+  # But this is called whenever any message is being sent out. If both the  
+  # local and remote tags are present then add in the full_dialogs hash, otherwise 
+  # just add in the half_dialogs hash, in both cases mark in the session
+  # if the session was in half dialog hash and you are adding in full then remove
+  # from HD Map. If the session is already in full then do not do anything.
+  
+  def SessionManager.add_session session, final=false
+    SipLogger['siplog::sessionmanager'].debug("Trying to add session with session.session_map #{session.session_map} local_tag=#{session.local_tag} and remote_tag=#{session.remote_tag}")
+    if session.session_map == :full && !session.force_update_session_map
+        SipLogger['siplog::sessionmanager'].info("Already in full map")
+      return
+    end
+    if ((session.session_map == :half) && 
+        !(session.remote_tag && session.local_tag)) && 
+        !session.force_update_session_map
+      SipLogger['siplog::sessionmanager'].info("Already in half map, nothing new")
+      return  
+    end
+    key = sprintf("|%s|%s|%s|", session.local_tag, session.call_id, session.remote_tag)
+    if session.remote_tag
+      if session.local_tag
+        @@sm_lock.synchronize do
+          @@full_dialogs[key] = session
+          #@@half_dialogs[session.session_key] = nil if ((session.session_map == :half) && final)
+          session.half_dialog_key = session.session_key
+        end
+        session.session_map = :full
+      else  # incoming request and 100 responses out   
+        @@sm_lock.synchronize do
+          @@half_dialogs[key] = session
+        end
+        session.session_map = :half
+      end
+    else
+      @@sm_lock.synchronize do
+        @@half_dialogs[key] = session
+      end
+      session.session_map = :half
+    end
+    SipLogger['siplog::sessionmanager'].debug("Setting the session_key as #{key}")
+    session.session_key = key
+  end
+  
+  
+  def SessionManager.remove_session session, half_only=false
+    @@sm_lock.synchronize do
+      @@half_dialogs[session.half_dialog_key] = nil if session.half_dialog_key
+      SipLogger['siplog::sessionmanager'].info("Removed session with key #{session.half_dialog_key} from half_dialogs map")
+      return if half_only
+    end
+    if session.session_map == :full
+      @@sm_lock.synchronize do
+        @@full_dialogs[session.session_key] = nil
+      end    
+      SipLogger['siplog::sessionmanager'].info("Removed session with key #{session.session_key} from full_dialogs map")
+    elsif session.session_map == :half
+      @@sm_lock.synchronize do
+        @@half_dialogs[session.session_key] = nil
+      end 
+      SipLogger['siplog::sessionmanager'].info("Removed session with key #{session.session_key} from half_dialogs map")
+    else
+      SipLogger['siplog::sessionmanager'].warn("Session with call_id #{session.call_id } does not have any map information")
+    end
+  end
+  
+  def SessionManager.clean_all
+    @@sm_lock.synchronize do
+      @@full_dialogs = {}
+      @@half_dialogs = {}
+    end
+  end
+  
+  
+end

data/sipper/session_recorder.rb

@@ -0,0 +1,190 @@
+require 'yaml'
+require 'sipper_configurator'
+require 'message'
+
+# Recording of a session happens, either when you have 
+# the global setting for recording :SessionRecord= true or you
+# get the P header P-Session-Record, the values for the global
+# var or the header can be "msg-info" or "msg-debug"  
+# msg-info just records the in-out messages and msg-debug records 
+# full SIP messages.
+# 
+
+require 'sip_logger'
+require 'stringio'
+require 'monitor'
+
+class SessionRecorder
+  include SipLogger
+  
+  attr_accessor :level
+  
+  private_class_method :new
+  
+  @@count = 0
+  @@val = 0
+  @@base = 0
+  @@class_lock = Monitor.new
+  
+  def SessionRecorder.get_new_count
+    @@class_lock.synchronize do
+      @@count += 1
+      if @@count == 10
+        @@count = 0
+        @@base = @@val*10
+      end
+      @@val = @@base + @@count
+    end
+  end
+  
+  def SessionRecorder.create_and_record(io, msg, msg_s, direction, session_setting=nil)
+    if msg[:p_session_record]
+      level = msg.p_session_record.to_s
+    elsif session_setting
+      level = session_setting
+    else
+      level = SipperConfigurator[:SessionRecord]
+    end
+    if level
+      if io
+        sr = new(nil, io, level) 
+      else
+        sr = new(SessionRecorder.get_new_count.to_s+"_"+msg.call_id.to_s+"_"+direction , nil, level) 
+      end 
+    end
+    sr.record(direction, msg, msg_s) if sr
+    return sr
+  end
+  
+  
+  def initialize(f, io, l="msg-info")
+    @messages = []
+    @io = io
+    @level = l
+    path = SipperConfigurator[:SessionRecordPath]||SipperConfigurator[:LogPath]
+    @filename = File.join(path, f)  if f
+    @recordable = true
+  end
+  
+  def io=(io)
+    ensure_recordable
+    @io.close if @io
+    @io = io  
+  end
+  
+  def open_file_if_unopened
+    return if @io
+    io = File.new(@filename, "w+")
+    io.flock(File::LOCK_EX)  if SipperConfigurator[:EnableRecordingLock]
+    self.io = io
+  end
+  
+  # Record takes both sip message and also the optional string representation of 
+  # the message as the message is filled as we go along the stack and populate the 
+  # message. The string representation is the final string that goes out from the 
+  # transport. 
+  
+  def record(direction, msg, msg_s=nil )
+    ensure_recordable
+    open_file_if_unopened
+    case @level
+    when "msg-info"
+      if msg.class == Request
+        m = msg.method  
+      elsif msg.class == Response
+        m = msg.code.to_s
+      else
+        m = msg.to_s
+      end
+    when "msg-debug"
+      m = msg_s.nil? ? msg.to_s : msg_s
+    else
+      m = "Unknown_record_level #{@level}, I know only msg-info and msg-debug"
+    end
+    if direction == "in"
+      m = "< " + m
+    elsif  direction == "out"
+      m = "> " + m
+    elsif direction == "neutral"
+      m = "! " + m
+    else
+      m = "UNKNOWN DIRECTION " + m
+    end
+    @messages << m
+  end 
+  
+  def get_recording
+    @messages
+  end
+  
+  def get_info_only_recording
+    return @messages if @level == "msg-info"
+    @messages.map do |msg|
+      prefix = msg[0..1]
+      message = msg[2..-1]
+      unless prefix == "! "  #neutral
+        begin
+          m = Message.parse([message, ["AF_INET", 33302, "localhost.localdomain", "127.0.0.1"]])
+          if m.class == Request
+            prefix + m.method  
+          elsif m.class == Response
+            prefix + m.code.to_s
+          end
+        rescue ArgumentError
+          msg
+        end
+      else
+        msg  
+      end
+    end
+  end
+  
+  
+  def save
+    ensure_recordable
+    logd("Trying to save the recording in #{@io.path||@io}")
+    @recordable = false
+    begin
+      @io.write(YAML::dump(self)) 
+      @io.flush
+    ensure
+      @io.flock(File::LOCK_UN) if @io.class == File if SipperConfigurator[:EnableRecordingLock]
+      @io.close unless @io.class == StringIO
+    end
+    logd("Saved the recording in #{@io.path||@io}")
+  end
+  
+  def SessionRecorder.load(f)
+    SipLogger['siplog::sessionrecorder'].debug("Reading the recording from #{f}")
+    begin
+      case f
+      when String
+        io = File.new(f, "r")
+        io.flock(File::LOCK_EX) if SipperConfigurator[:EnableRecordingLock]
+      when StringIO
+        io = f   
+      end
+      obj = YAML::load(io)
+      if obj.class == SessionRecorder
+        return obj
+      else
+        msg = "Object read from file #{f} is not a recording"
+        SipLogger['siplog::sessionrecorder'].error(msg)
+        raise TypeError, msg
+      end
+    rescue IOError
+      msg = "#{f} is not a proper file"
+      SipLogger['siplog::sessionrecorder'].error(msg)
+      raise TypeError, msg
+    ensure
+      io.flock(File::LOCK_UN) if io.class == File if SipperConfigurator[:EnableRecordingLock]
+      io.close  if io  
+    end
+  end
+  
+  def ensure_recordable
+    raise RuntimeError, "This recorder is now closed for recording" unless @recordable
+  end
+  
+  private :open_file_if_unopened, :ensure_recordable
+end

data/sipper/session_state/DialogState.sm

@@ -0,0 +1,54 @@
+// Dialog state machine, refer to RFC 4235
+// This is not being used currently, put here for future 
+
+%class Dsm
+
+%start DsmMap::Trying
+
+%map DsmMap
+
+%%
+
+Trying
+{
+  one_xx_no_tag       Proceeding {}
+  one_xx_tag          Early {}
+  two_xx	          Confirmed {}
+  cancelled_rejected  Terminated {}
+  three_xx			  Terminated {}
+}
+
+
+Proceeding
+{
+  one_xx_tag          Early {}
+  two_xx	          Confirmed {}
+  cancelled_rejected  Terminated {}
+  three_xx			  Terminated {}
+}
+
+Early
+{
+  replaced			  Terminated {}
+  two_xx			  Confirmed {}
+  one_xx_tag          nil {}
+  three_xx			  Terminated {}
+}
+
+Confirmed
+{
+  error		          Terminated {}
+  timeout			  Terminated {}
+  replaced			  Terminated {}
+  bye				  Terminated {}
+  two_xx              nil {}
+}
+
+Terminated
+{
+  timeout			  nil {}
+  bye 		        nil {}
+}
+
+
+%%

data/sipper/session_state/DialogState_sm.rb

@@ -0,0 +1,337 @@
+# DO NOT EDIT.
+# generated by smc (http://smc.sourceforge.net/)
+# from file : DialogState.sm
+
+require 'statemap'
+
+class DsmState < Statemap::State
+
+    def Entry(fsm) end
+
+    def Exit(fsm) end
+
+    def bye(fsm)
+        Default(fsm)
+    end
+
+    def cancelled_rejected(fsm)
+        Default(fsm)
+    end
+
+    def error(fsm)
+        Default(fsm)
+    end
+
+    def one_xx_no_tag(fsm)
+        Default(fsm)
+    end
+
+    def one_xx_tag(fsm)
+        Default(fsm)
+    end
+
+    def replaced(fsm)
+        Default(fsm)
+    end
+
+    def three_xx(fsm)
+        Default(fsm)
+    end
+
+    def timeout(fsm)
+        Default(fsm)
+    end
+
+    def two_xx(fsm)
+        Default(fsm)
+    end
+
+    def Default(fsm)
+        if fsm.getDebugFlag then
+            fsm.getDebugStream.write("TRANSITION   : Default\n")
+        end
+        msg = "\nState: " + fsm.getState.getName +
+            "\nTransition: " + fsm.getTransition + "\n"
+        raise Statemap::TransitionUndefinedException, msg
+    end
+
+end
+
+class DsmMap_Default < DsmState
+
+end
+
+class DsmMap_Trying < DsmMap_Default
+
+    def cancelled_rejected(fsm)
+        if fsm.getDebugFlag then
+            fsm.getDebugStream.write("TRANSITION   : DsmMap::Trying.cancelled_rejected\n")
+        end
+        fsm.getState.Exit(fsm)
+        fsm.setState(DsmMap::Terminated)
+        fsm.getState.Entry(fsm)
+    end
+
+    def one_xx_no_tag(fsm)
+        if fsm.getDebugFlag then
+            fsm.getDebugStream.write("TRANSITION   : DsmMap::Trying.one_xx_no_tag\n")
+        end
+        fsm.getState.Exit(fsm)
+        fsm.setState(DsmMap::Proceeding)
+        fsm.getState.Entry(fsm)
+    end
+
+    def one_xx_tag(fsm)
+        if fsm.getDebugFlag then
+            fsm.getDebugStream.write("TRANSITION   : DsmMap::Trying.one_xx_tag\n")
+        end
+        fsm.getState.Exit(fsm)
+        fsm.setState(DsmMap::Early)
+        fsm.getState.Entry(fsm)
+    end
+
+    def three_xx(fsm)
+        if fsm.getDebugFlag then
+            fsm.getDebugStream.write("TRANSITION   : DsmMap::Trying.three_xx\n")
+        end
+        fsm.getState.Exit(fsm)
+        fsm.setState(DsmMap::Terminated)
+        fsm.getState.Entry(fsm)
+    end
+
+    def two_xx(fsm)
+        if fsm.getDebugFlag then
+            fsm.getDebugStream.write("TRANSITION   : DsmMap::Trying.two_xx\n")
+        end
+        fsm.getState.Exit(fsm)
+        fsm.setState(DsmMap::Confirmed)
+        fsm.getState.Entry(fsm)
+    end
+
+end
+
+class DsmMap_Proceeding < DsmMap_Default
+
+    def cancelled_rejected(fsm)
+        if fsm.getDebugFlag then
+            fsm.getDebugStream.write("TRANSITION   : DsmMap::Proceeding.cancelled_rejected\n")
+        end
+        fsm.getState.Exit(fsm)
+        fsm.setState(DsmMap::Terminated)
+        fsm.getState.Entry(fsm)
+    end
+
+    def one_xx_tag(fsm)
+        if fsm.getDebugFlag then
+            fsm.getDebugStream.write("TRANSITION   : DsmMap::Proceeding.one_xx_tag\n")
+        end
+        fsm.getState.Exit(fsm)
+        fsm.setState(DsmMap::Early)
+        fsm.getState.Entry(fsm)
+    end
+
+    def three_xx(fsm)
+        if fsm.getDebugFlag then
+            fsm.getDebugStream.write("TRANSITION   : DsmMap::Proceeding.three_xx\n")
+        end
+        fsm.getState.Exit(fsm)
+        fsm.setState(DsmMap::Terminated)
+        fsm.getState.Entry(fsm)
+    end
+
+    def two_xx(fsm)
+        if fsm.getDebugFlag then
+            fsm.getDebugStream.write("TRANSITION   : DsmMap::Proceeding.two_xx\n")
+        end
+        fsm.getState.Exit(fsm)
+        fsm.setState(DsmMap::Confirmed)
+        fsm.getState.Entry(fsm)
+    end
+
+end
+
+class DsmMap_Early < DsmMap_Default
+
+    def one_xx_tag(fsm)
+        if fsm.getDebugFlag then
+            fsm.getDebugStream.write("TRANSITION   : DsmMap::Early.one_xx_tag\n")
+        end
+    end
+
+    def replaced(fsm)
+        if fsm.getDebugFlag then
+            fsm.getDebugStream.write("TRANSITION   : DsmMap::Early.replaced\n")
+        end
+        fsm.getState.Exit(fsm)
+        fsm.setState(DsmMap::Terminated)
+        fsm.getState.Entry(fsm)
+    end
+
+    def three_xx(fsm)
+        if fsm.getDebugFlag then
+            fsm.getDebugStream.write("TRANSITION   : DsmMap::Early.three_xx\n")
+        end
+        fsm.getState.Exit(fsm)
+        fsm.setState(DsmMap::Terminated)
+        fsm.getState.Entry(fsm)
+    end
+
+    def two_xx(fsm)
+        if fsm.getDebugFlag then
+            fsm.getDebugStream.write("TRANSITION   : DsmMap::Early.two_xx\n")
+        end
+        fsm.getState.Exit(fsm)
+        fsm.setState(DsmMap::Confirmed)
+        fsm.getState.Entry(fsm)
+    end
+
+end
+
+class DsmMap_Confirmed < DsmMap_Default
+
+    def bye(fsm)
+        if fsm.getDebugFlag then
+            fsm.getDebugStream.write("TRANSITION   : DsmMap::Confirmed.bye\n")
+        end
+        fsm.getState.Exit(fsm)
+        fsm.setState(DsmMap::Terminated)
+        fsm.getState.Entry(fsm)
+    end
+
+    def error(fsm)
+        if fsm.getDebugFlag then
+            fsm.getDebugStream.write("TRANSITION   : DsmMap::Confirmed.error\n")
+        end
+        fsm.getState.Exit(fsm)
+        fsm.setState(DsmMap::Terminated)
+        fsm.getState.Entry(fsm)
+    end
+
+    def replaced(fsm)
+        if fsm.getDebugFlag then
+            fsm.getDebugStream.write("TRANSITION   : DsmMap::Confirmed.replaced\n")
+        end
+        fsm.getState.Exit(fsm)
+        fsm.setState(DsmMap::Terminated)
+        fsm.getState.Entry(fsm)
+    end
+
+    def timeout(fsm)
+        if fsm.getDebugFlag then
+            fsm.getDebugStream.write("TRANSITION   : DsmMap::Confirmed.timeout\n")
+        end
+        fsm.getState.Exit(fsm)
+        fsm.setState(DsmMap::Terminated)
+        fsm.getState.Entry(fsm)
+    end
+
+    def two_xx(fsm)
+        if fsm.getDebugFlag then
+            fsm.getDebugStream.write("TRANSITION   : DsmMap::Confirmed.two_xx\n")
+        end
+    end
+
+end
+
+class DsmMap_Terminated < DsmMap_Default
+
+    def bye(fsm)
+        if fsm.getDebugFlag then
+            fsm.getDebugStream.write("TRANSITION   : DsmMap::Terminated.bye\n")
+        end
+    end
+
+    def timeout(fsm)
+        if fsm.getDebugFlag then
+            fsm.getDebugStream.write("TRANSITION   : DsmMap::Terminated.timeout\n")
+        end
+    end
+
+end
+
+module DsmMap
+
+    Trying = DsmMap_Trying::new('DsmMap.Trying', 0).freeze
+    Proceeding = DsmMap_Proceeding::new('DsmMap.Proceeding', 1).freeze
+    Early = DsmMap_Early::new('DsmMap.Early', 2).freeze
+    Confirmed = DsmMap_Confirmed::new('DsmMap.Confirmed', 3).freeze
+    Terminated = DsmMap_Terminated::new('DsmMap.Terminated', 4).freeze
+    Default = DsmMap_Default::new('DsmMap.Default', -1).freeze
+
+end
+
+class Dsm_sm < Statemap::FSMContext
+
+    def initialize(owner)
+        super()
+        @_owner = owner
+        setState(DsmMap::Trying)
+        DsmMap::Trying.Entry(self)
+    end
+
+    def bye()
+        @_transition = 'bye'
+        getState.bye(self)
+        @_transition = nil
+    end
+
+    def cancelled_rejected()
+        @_transition = 'cancelled_rejected'
+        getState.cancelled_rejected(self)
+        @_transition = nil
+    end
+
+    def error()
+        @_transition = 'error'
+        getState.error(self)
+        @_transition = nil
+    end
+
+    def one_xx_no_tag()
+        @_transition = 'one_xx_no_tag'
+        getState.one_xx_no_tag(self)
+        @_transition = nil
+    end
+
+    def one_xx_tag()
+        @_transition = 'one_xx_tag'
+        getState.one_xx_tag(self)
+        @_transition = nil
+    end
+
+    def replaced()
+        @_transition = 'replaced'
+        getState.replaced(self)
+        @_transition = nil
+    end
+
+    def three_xx()
+        @_transition = 'three_xx'
+        getState.three_xx(self)
+        @_transition = nil
+    end
+
+    def timeout()
+        @_transition = 'timeout'
+        getState.timeout(self)
+        @_transition = nil
+    end
+
+    def two_xx()
+        @_transition = 'two_xx'
+        getState.two_xx(self)
+        @_transition = nil
+    end
+
+    def getState()
+        if @_state.nil? then
+            raise Statemap::StateUndefinedException
+        end
+        return @_state
+    end
+
+    def getOwner()
+        return @_owner
+    end
+
+end