Sipper 1.1.3

data/sipper/media/sipper_media_event.rb

@@ -0,0 +1,43 @@
+
+# Media Event includes both the Events generated by the media
+# client as well as the responses to the requests sent.
+#
+module Media
+
+  class SipperMediaEvent
+    attr_accessor :session
+    def initialize(session)
+      @session = session  
+    end
+    
+    def short_to_s
+      self.to_s
+    end
+    
+  end
+  
+  class SmReply < SipperMediaEvent
+    attr_reader :cmd, :media_id, :reason, :recv_ip, :recv_port, :result, :otherparams
+    def initialize(session, cmd, result, mediaid=nil, reason=nil, recvip=nil, recvport=nil, otherparam=nil)
+      super(session)
+      @cmd = cmd
+      @result = result
+      @media_id = mediaid
+      @reason = reason
+      @recv_ip = recvip
+      @recv_port = recvport
+      @otherparams = otherparam
+    end
+  end
+  
+  class SmEvent < SipperMediaEvent
+    attr_reader :codec, :event, :dtmf, :media_id
+    def initialize(session, mediaid, codec, event, dtmf=nil)
+      super(session)
+      @codec = codec
+      @event = event
+      @dtmf = dtmf
+      @media_id = mediaid
+    end
+  end
+end

data/sipper/media/sipper_media_manager.rb

@@ -0,0 +1,145 @@
+require 'singleton'
+
+
+module Media
+  class SipperMediaManager
+  
+    include SipLogger
+
+    include Singleton
+
+    def initialize()
+       @cal = Monitor.new # command send lock
+
+       @csl = Monitor.new # command status lock
+       @csl_cmd = @csl.new_cond
+
+       @media_clients = {}
+       @media_clients.extend(MonitorMixin)
+
+       start
+    end
+    
+    def set_queue(q)
+      @q = q
+    end
+    
+    def enqueue_event(event)
+      @q << event
+    end
+    
+    def start
+      return false unless SipperConfigurator[:SipperMedia]
+      @t =  TCPSocket.new(SipperConfigurator[:LocalSipperIP], SIP::Locator[:Smd].controller_port) 
+      
+      Thread.new do
+        while true do
+          ready = select([@t], nil, nil, nil)        
+          next if not ready        
+          ready[0].each do |s|
+            next if s.eof         
+            msg_len = s.readpartial(4).unpack("N")[0]
+            r = s.readpartial(msg_len)
+
+            logd("Message received on socket Len[#{msg_len}] Msg[#{r}]")
+
+            if r.include?'TYPE=Result;'
+              cm = rs = md = rn = ri = rp = nil
+              otherparams={}
+              r.split(';').each do |x|
+                y = x.split('=')
+                case y[0]
+                when 'COMMAND'
+                  cm = y[1]
+                when 'MEDIAID'
+                  md = y[1]
+                when 'RESULT'
+                  rs = y[1]
+                when 'RECVIP'
+                  ri = y[1]
+                when 'RECVPORT'
+                  rp = y[1]
+                when 'REASON'
+                  rn = y[1]
+                else
+                  otherparams[y[0]] = y[1]
+                end  
+              end
+              
+              reply = Media::SmReply.new(nil, cm, rs, md, rn, ri, rp, otherparams)
+              _process_reply(reply)
+
+            elsif r.include?'TYPE=EVENT;' 
+              md = cd = ev = dt = nil
+              r.split(';').each do |x|
+                y = x.split('=')
+                case y[0]
+                when 'CODEC'
+                  cd = y[1]
+                when 'MEDIAID'
+                  md = y[1]
+                when 'EVENT'
+                  ev = y[1]
+                when 'DTMF'
+                  dt = y[1]
+                end  
+              end
+
+              event_client = nil
+
+              @media_clients.synchronize do
+                 event_client = @media_clients[md] 
+              end
+
+              if event_client == nil
+                 logd("Stray event received.#{r}")
+              else
+                 evt = Media::SmEvent.new(event_client.session, md, cd, ev, dt)
+                 enqueue_event(evt)
+              end
+            end
+          end
+        end #listener loop       
+      end # thread
+      return true
+    end
+
+    def _process_reply(reply)
+        @csl.synchronize do
+           @command_result = reply
+           @csl_cmd.signal
+        end
+    end
+
+    def send_command(mediaClient, commandStr)
+      @cal.synchronize do
+        @csl.synchronize do
+           logd("Sending media Len[#{commandStr.length}] Command[#{commandStr}]") 
+           @t << [commandStr.length].pack("N") << commandStr
+
+           5.times do
+              if @csl_cmd.wait(10)
+                 returnVal = @command_result
+                 @command_result = nil
+                 returnVal.session = mediaClient.session
+
+                 @media_clients.synchronize do
+                    if returnVal.cmd == "CREATE MEDIA" && returnVal.result == "Success"
+                       @media_clients[returnVal.media_id] = mediaClient
+                    end
+
+                    if returnVal.cmd == "DESTROY MEDIA" && returnVal.result == "Success"
+                       @media_clients.delete(returnVal.media_id)
+                    end
+                 end
+
+                 return returnVal
+              end
+           end
+           logd("Unable to get result after 5 retries 50Sec. Command: #{commandStr}")
+           Process.exit(1)
+        end
+      end
+    end
+  end
+end

data/sipper/media/sipper_media_proxy.rb

@@ -0,0 +1,60 @@
+require 'sipper_configurator'
+require 'util/sipper_util'
+
+
+module Media
+  class SipperMediaProxy
+    
+    include SipLogger
+    attr_reader :controller_port
+    
+    def initialize(controller_port=nil)
+      @controller_port = controller_port || SipperConfigurator[:SipperMediaDefaultControlPort]
+
+      return if SipperConfigurator[:SipperMediaProcessReuse] && self.ping
+
+      if self.ping
+        loop do
+          self.shutdown  
+          sleep 2
+          break unless self.ping
+        end
+      end
+      Thread.new do
+        x = system(File.join(SipperConfigurator[:SipperBasePath], "sipper", "bin", "SipperMedia") +" -p " + "#{@controller_port.to_s}")
+      end
+      loop do
+        sleep 2
+        break if self.ping
+      end
+    end
+    
+    def ping
+      begin
+        t =  TCPSocket.new(SipperConfigurator[:LocalSipperIP], @controller_port)
+      rescue SystemCallError
+        return false
+      end
+      t.close
+      return true
+    end
+    
+    def shutdown
+      begin
+        t =  TCPSocket.new(SipperConfigurator[:LocalSipperIP], @controller_port)
+        #t.setsockopt(Socket::IPPROTO_TCP, Socket::NONBLOCK, true)
+        t.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, true)
+      rescue SystemCallError
+        return
+      end     
+      command = "COMMAND=SHUTDOWN"
+      t << [command.length].pack("N") << command
+      len = t.readpartial(4).unpack("N")[0]
+      reply = t.readpartial(len)
+      logd ("Received media shutdown Reply #{reply}")
+      t.close
+    end
+        
+    
+  end
+end

data/sipper/media/sipper_offer_answer.rb

@@ -0,0 +1,285 @@
+require 'media/sipper_media_client'
+
+module Media
+class SipperOfferAnswer
+   include SipLogger
+   attr_accessor :peerSdp, :ourSdp,
+                 :playspec, :recspec, :dtmfspec
+
+=begin
+  state values
+     0 = None
+     1 = Stable (After Offer and Answer.)
+     2 = PeerOffered
+     3 = OurOffered
+     4 = OfferGenerated
+=end
+
+   def initialize(session)
+      @session = session
+      @state = 0
+      @client = []
+   end
+
+   def close()
+      logd("Media close called.")
+      @client.each do |curr|
+         logd("Calling close on #{curr}")
+         curr.destroy_media if curr
+      end
+   end
+
+   def setup_media_spec(playspec, recspec, dtmfspec)
+      @playspec = playspec
+      @recspec = recspec
+      @dtmfspec = dtmfspec
+
+      @client.each do |currclient|
+         if currclient
+            currclient.set_dtmf_command(dtmfspec) if dtmfspec
+         end
+      end
+   end
+
+   def make_new_offer(codecs = nil, status = "sendrecv")
+      return if @state == 2 || @state == 3
+      codecs = SipperMediaClient::get_supported_codecs unless codecs
+
+      unless @client[0]
+         @client[0] = SipperMediaClient.new(@session) if SipperConfigurator[:SipperMedia]
+         @client[0] = SipperDummyMediaClient.new(@session) unless @client[0]
+      end
+
+      if @state == 0
+         @ourSdp = SDP::SdpGenerator.make_sdp(nil, @client[0].recv_ip, @client[0].recv_port, codecs, status)
+      else
+         currversion = @ourSdp.get_owner_version
+         @ourSdp = SDP::SdpGenerator.make_sdp(@ourSdp.session_lines, @client[0].recv_ip, @client[0].recv_port, codecs, status)
+         @ourSdp.set_owner_version(currversion + 1)
+      end
+
+      @state = 4
+   end
+
+   def _make_our_answer()
+      logd("Client making new answer")
+      peerMediaLines = @peerSdp.media_lines
+      unless @client[0]
+         @client[0] = SipperMediaClient.new(@session) if SipperConfigurator[:SipperMedia]
+         @client[0] = SipperDummyMediaClient.new(@session) unless @client[0]
+      end
+
+      @ourSdp = SDP::SdpGenerator.make_no_media_sdp(nil, @client[0].recv_ip) unless @ourSdp 
+      @ourSdp.media_lines = [] unless @ourSdp.media_lines
+
+      versionchange = false
+
+      length = 0
+      length = peerMediaLines.length if peerMediaLines
+
+      (0..length - 1).each do |idx|
+         unless @client[idx]
+            @client[idx] = SipperMediaClient.new(@session) if SipperConfigurator[:SipperMedia]
+            @client[idx] = SipperDummyMediaClient.new(@session) unless @client[idx]
+         end
+
+         @client[idx].play_spec = @playspec
+         @client[idx].record_file = @recspec
+         @client[idx].dtmf_play_spec = @dtmfspec
+
+         currPeerM = peerMediaLines[idx]
+         peerCodecs = SDP::get_codecs_in_media(currPeerM)
+         ourCodecs = peerCodecs
+
+         ourCodecs.delete("G711A") if ourCodecs.include?("G711U")
+         ourMediaStatus = SDP::get_answer_status(SDP::get_media_status(currPeerM))
+
+         ourMedia = SDP::SdpGenerator.make_sdp_media(nil, @client[idx].recv_port, ourCodecs, ourMediaStatus)
+         SDP.copy_media_type_transport(currPeerM, ourMedia)
+
+         if @ourSdp.media_lines[idx]
+            unless SDP::is_media_equal(ourMedia, @ourSdp.media_lines[idx])
+               @ourSdp.media_lines[idx] = ourMedia
+               versionchange = true
+            end
+         else
+            @ourSdp.media_lines[idx] = ourMedia
+            versionchange = true
+         end
+      end
+
+      if(versionchange)
+         @ourSdp.increment_owner_version
+      end
+   end
+
+   def refresh_sipper_media()
+      return unless SipperConfigurator[:SipperMedia]
+
+      peerMediaLines = @peerSdp.media_lines
+      ourMediaLines = @ourSdp.media_lines
+
+      length = peerMediaLines.length
+      (0..length - 1).each do |idx|
+         @client[idx].play_spec = @playspec
+         @client[idx].record_file = @recspec
+         @client[idx].dtmf_play_spec = @dtmfspec
+         @client[idx].set_sdp_media(ourMediaLines[idx], peerMediaLines[idx]) if @client[idx]
+      end
+      length = 1 if length == 0
+      (length..@client.length - 1).each do |idx|
+         @client[idx].destroy_media if @client[idx]
+         @client[idx] = nil
+      end
+   end
+
+   def update_sipper_media()
+      return unless SipperConfigurator[:SipperMedia]
+
+      logd("update_sipper_media PeerSDP:\n#{@peerSdp}\nOurSDP:\n#{ourSdp}\n")
+      peerMediaLines = @peerSdp.media_lines
+      ourMediaLines = @ourSdp.media_lines
+
+      length = peerMediaLines.length
+      (0..length - 1).each do |idx|
+         @client[idx].update_sdp_media(peerMediaLines[idx], ourMediaLines[idx]) if @client[idx]
+      end
+      length = 1 if length == 0
+      (length..@client.length - 1).each do |idx|
+         @client[idx].destroy_media if @client[idx]
+         @client[idx] = nil
+      end
+   end
+
+   def _check_peer_offer(inPeerSdp)
+      @state = 2
+      if @peerSdp == nil
+         @peerSdp = inPeerSdp.clone()
+         _make_our_answer() 
+      elsif (inPeerSdp.get_owner_version() == @peerSdp.get_owner_version())
+         return
+      else
+         @peerSdp = inPeerSdp.clone()
+         _make_our_answer()
+      end
+
+      update_sipper_media()
+   end
+
+   def _check_peer_answer(peerSdp)
+      currVersion = @ourSdp.get_owner_version
+      _check_peer_offer(peerSdp)
+      @ourSdp.set_owner_version(currVersion)
+      @state = 1
+   end
+
+   def handle_incoming_request(request)
+      if request.method == "INVITE"
+         @last_recv_invite = request
+      end
+
+      return unless request.sdp
+      return unless (request.method == "INVITE" || request.method == "ACK" || request.method == "UPDATE" || request.method == "PRACK")
+      return unless (@state != 2)
+
+      case @state
+      when 0
+         return if request.method != "INVITE"
+         _check_peer_offer(request.sdp)
+      when 1
+         return if request.method == "ACK"
+         _check_peer_offer(request.sdp)
+      when 3
+         return if request.method == "UPDATE" || request.method == "INVITE"
+         _check_peer_answer(request.sdp)
+      when 4
+         return if request.method == "ACK" && @peerSdp
+         return if request.method != "INVITE" && (@peerSdp == nil)
+         _check_peer_offer(request.sdp)
+      end
+   end
+
+   def handle_incoming_response(response)
+      return unless response.sdp 
+      return unless (response.get_request_method == "INVITE" || response.get_request_method == "PRACK" || response.get_request_method == "UPDATE")
+      return unless (@state != 2)
+
+      return if response.code <= 100
+      return if response.code > 300
+      if response.code < 200
+         return unless response["require".to_sym]
+         return unless response.require.to_s.include?("100rel")
+      end
+
+      case @state
+      when 0
+         return if response.get_request_method != "INVITE"
+         _check_peer_offer(response.sdp)
+      when 1
+         return if response.get_request_method != "INVITE"
+         _check_peer_offer(response.sdp)
+      when 3
+         _check_peer_answer(response.sdp)
+      when 4
+         return if response.get_request_method != "INVITE"
+         _check_peer_offer(response.sdp)
+      end
+   end
+
+   def handle_outgoing_request(request)
+      return if request.sdp 
+      return unless (request.method == "INVITE" || request.method == "PRACK" || request.method == "UPDATE" || request.method == "ACK")
+
+      case @state
+      when 0
+         return
+      when 1
+         return
+      when 2
+         return if request.method == "INVITE" || request.method == "UPDATE"
+         request.sdp = @ourSdp.clone()
+         @state = 1
+      when 3
+         return
+      when 4
+         return if request.method == "ACK"
+         request.sdp = @ourSdp.clone()
+         @state = 3
+      end
+   end
+
+   def handle_outgoing_response(response)
+      
+      return if response.sdp 
+      return unless (response.get_request_method == "INVITE" || response.get_request_method == "PRACK" || response.get_request_method == "UPDATE")
+
+      return if response.code <= 100
+      return if response.code > 300
+      if response.code < 200
+         return unless response["require".to_sym]
+         return unless response.require.to_s.include?("100rel")
+      end
+
+      logd("Outgoing response checking state #{@state}")
+      case @state
+      when 0
+         return
+      when 1
+         return if response.get_request_method != "INVITE"
+         return if @last_recv_invite.sdp 
+         response.sdp = @ourSdp.clone()
+         @state = 3
+         return
+      when 2
+         response.sdp = @ourSdp.clone()
+         @state = 1
+      when 3
+         return
+      when 4
+         return if response.get_request_method != "INVITE"
+         response.sdp = @ourSdp.clone()
+         @state = 3
+      end
+   end
+end
+end