quaff 0.1.0

data/lib/call.rb

@@ -0,0 +1,230 @@
+# -*- coding: us-ascii -*-
+require_relative './utils.rb'
+require_relative './sources.rb'
+
+class CSeq
+  def initialize cseq_str
+    @num, @method = cseq_str.split
+    @num = @num.to_i
+  end
+
+  def increment
+    @num = @num +1
+    to_s
+  end
+
+  def to_s
+    "#{@num.to_s} #{@method}"
+  end
+  
+end
+
+class Call
+  attr_reader :cid
+
+  def initialize(cxn,
+                 cid,
+                 uri="sip:5557777888@#{QuaffUtils.local_ip}",
+                 destination=nil,
+                 target_uri=nil)
+    @cxn = cxn
+    change_cid cid
+    @uri = uri
+    @retrans = nil
+    @t1, @t2 = 0.5, 32
+    @last_From = "<#{uri}>"
+    update_branch
+    setdest(destination, recv_from_this: true) if destination
+    set_callee target_uri if target_uri
+    @routeset = []
+  end
+
+  def change_cid cid
+    @cid = cid
+    @cxn.add_call_id @cid
+  end
+
+  def update_branch
+    @last_Via = "SIP/2.0/#{@cxn.transport} #{QuaffUtils.local_ip}:#{@cxn.local_port};rport;branch=#{QuaffUtils.new_branch}"
+  end
+  
+  def create_dialog msg
+    set_callee msg.first_header("Contact")
+    @routeset = msg.all_headers("Record-Route")
+    if msg.type == :request
+      @routeset = @routeset.reverse
+    end
+  end
+
+  def recv_something
+    data = @cxn.get_new_message @cid
+    @retrans = nil
+    @src = data['source']
+    @last_To = data["message"].header("To")
+    @last_From = data["message"].header("From")
+    @sip_destination ||= data["message"].header("From")
+    @last_Via = data["message"].headers["Via"]
+    @last_CSeq = CSeq.new(data["message"].header("CSeq"))
+    data
+  end
+
+  def set_callee uri
+    if /<(.*)>/ =~ uri
+      uri = $1
+    end
+    
+    @sip_destination = "#{uri}"
+    @last_To = "<#{uri}>"
+  end
+
+  def setdest source, options={}
+    @src = source
+    if options[:recv_from_this] and source.sock
+      @cxn.add_sock source.sock
+    end
+  end
+
+  def recv_request(method)
+    begin
+      data = recv_something
+    rescue
+      raise "#{ @uri } timed out waiting for #{ method }"
+    end
+    unless data["message"].type == :request and Regexp.new(method) =~ data["message"].method
+      raise (data['message'].to_s || "Message is nil!")
+    end
+    data
+  end
+
+  def recv_response(code)
+    begin
+      data = recv_something
+    rescue
+      raise "#{ @uri } timed out waiting for #{ code }"
+    end
+    unless data["message"].type == :response and Regexp.new(code) =~ data["message"].status_code
+      raise "Expected #{ code}, got #{data["message"].status_code || data['message']}"
+    end
+    data
+  end
+
+  def send_response(code, retrans=nil, headers={})
+    msg = build_message headers, :response, code
+    send_something(msg, retrans)
+  end
+
+  def send_request(method, sdp=true, retrans=nil, headers={})
+    sdp="v=0
+      o=user1 53655765 2353687637 IN IP4 #{QuaffUtils.local_ip}
+      s=-
+      c=IN IP4 #{QuaffUtils.local_ip}
+      t=0 0
+      m=audio 7000 RTP/AVP 0
+      a=rtpmap:0 PCMU/8000"
+
+    msg = build_message headers, :request, method
+    send_something(msg, retrans)
+  end
+
+  def build_message headers, type, method_or_code
+    defaults = {
+      "From" => @last_From,
+      "To" => @last_To,
+      "Call-ID" => @cid,
+      "CSeq" => (/\d+/ =~ method_or_code) ? @last_CSeq.to_s : (method_or_code == "ACK") ? @last_CSeq.increment : "1 #{method_or_code}",
+      "Via" => @last_Via,
+      "Max-Forwards" => "70",
+      "Content-Length" => "0",
+      "User-Agent" => "Quaff SIP Scripting Engine",
+      "Contact" => "<sip:quaff@#{QuaffUtils.local_ip}:#{@cxn.local_port};transport=#{@cxn.transport};ob>",
+    }
+
+    if type == :request
+      defaults['Route'] = @routeset
+    else
+      defaults['Record-Route'] = @routeset
+    end
+
+    defaults.merge! headers
+
+
+    if type == :request
+      msg = "#{method_or_code} #{@sip_destination} SIP/2.0\r\n"
+    else
+      msg = "SIP/2.0 #{ method_or_code }\r\n"
+    end
+
+    defaults.each do |key, value|
+      if value.nil?
+      elsif not value.kind_of? Array
+        msg += "#{key}: #{value}\r\n"
+      else value.each do |subvalue|
+          msg += "#{key}: #{subvalue}\r\n"
+        end
+      end
+    end
+    msg += "\r\n"
+
+    msg
+  end
+
+  def send_something(msg, retrans)
+    @cxn.send(msg, @src)
+    if retrans and (@transport == "UDP") then
+      @retrans = true
+      Thread.new do
+        timer = @t1
+        sleep timer
+        while @retrans do
+          #puts "Retransmitting on call #{ @cid }"
+          @cxn.send(msg, @src)
+          timer *=2
+          if timer < @t2 then
+            raise "Too many retransmits!"
+          end
+          sleep timer
+        end
+      end
+    end
+  end
+
+  def end_call
+    @cxn.mark_call_dead @cid
+  end
+
+  def clear_tag str
+    str
+  end
+
+  def clone_details other_message
+    @headers['To'] = [clear_tag(other_message.header("To"))]
+    @headers['From'] = [clear_tag(other_message.header("From"))]
+    @headers['Route'] = [other_message.header("Route")]
+  end
+
+  def get_next_hop header
+    /<sip:(.+@)?(.+):(\d+);(.*)>/ =~ header
+    sock = TCPSocket.new $2, $3
+    return TCPSource.new sock
+  end
+
+  def register username=@username, password=@password, expires="3600"
+    @username, @password = username, password
+    set_callee(@uri)
+    send_request("REGISTER", nil, nil, { "Expires" => expires.to_s })
+    response_data = recv_response("401|200")
+    if response_data['message'].status_code == "401"
+      send_request("ACK")
+      auth_hdr = gen_auth_header response_data['message'].header("WWW-Authenticate"), username, password, "REGISTER", @uri
+      update_branch
+      send_request("REGISTER", nil, nil, {"Authorization" =>  auth_hdr, "Expires" => expires.to_s})
+      recv_response("200")
+    end
+    return true
+  end
+
+  def unregister
+    register @username, @password, 0
+  end
+
+end

data/lib/endpoint.rb

@@ -0,0 +1,175 @@
+# -*- coding: us-ascii -*-
+require 'socket'
+require 'thread'
+require 'timeout'
+require_relative './sip_parser.rb'
+require_relative './sources.rb'
+
+class BaseEndpoint
+    attr_accessor :msg_trace
+
+    def terminate
+    end
+
+    def add_sock sock
+    end
+
+    def new_call call_id=nil, *args
+      call_id ||= get_new_call_id
+      puts "Call-Id for endpoint on #{@lport} is #{call_id}" if @msg_trace
+      Call.new(self, call_id, *args)
+    end
+
+    def initialize(lport)
+        @lport = lport
+        initialize_connection lport
+        initialize_queues
+        start
+    end
+
+    def local_port
+        @lport
+    end
+
+    def initialize_queues
+        @messages = {}
+        @call_ids = Queue.new
+        @dead_calls = {}
+        @sockets
+    end
+
+    def start
+        Thread.new do
+            loop do
+                recv_msg
+            end
+        end
+    end
+
+    def queue_msg(msg, source)
+        puts "Endpoint on #{@lport} received #{msg} from #{source.inspect}" if @msg_trace
+        cid = @parser.message_identifier msg
+        if cid and not @dead_calls.has_key? cid then
+            unless @messages.has_key? cid then
+
+                add_call_id cid
+                @call_ids.enq cid
+            end
+        @messages[cid].enq({"message" => msg, "source" => source})
+        end
+    end
+
+    def add_call_id cid
+        @messages[cid] ||= Queue.new
+    end
+
+    def get_new_call_id time_limit=5
+        Timeout::timeout(time_limit) { @call_ids.deq }
+    end
+
+    def get_new_message(cid, time_limit=5)
+        Timeout::timeout(time_limit) { @messages[cid].deq }
+    end
+
+    def mark_call_dead(cid)
+        @messages.delete cid
+        now = Time.now
+        @dead_calls[cid] = now + 30
+        @dead_calls = @dead_calls.keep_if {|k, v| v > now}
+    end
+
+    def send(data, source)
+        puts "Endpoint on #{@lport} sending #{data} to #{source.inspect}" if @msg_trace
+        source.send(@cxn, data)
+    end
+
+end
+
+class TCPSIPEndpoint < BaseEndpoint
+    attr_accessor :sockets
+
+    def initialize_connection(lport)
+        @cxn = TCPServer.new(lport)
+        @parser = SipParser.new
+        @sockets = []
+    end
+
+    def transport
+      "TCP"
+    end
+
+    def new_source ip, port
+      return TCPSource.new ip, port
+    end
+
+    alias_method :new_connection, :new_source
+
+    def recv_msg
+        select_response = IO.select(@sockets, [], [], 0) || [[]]
+        readable = select_response[0]
+        for sock in readable do
+            recv_msg_from_sock sock
+        end
+        begin
+            if @cxn
+              sock = @cxn.accept_nonblock
+              @sockets.push sock if sock
+            end
+        rescue IO::WaitReadable, Errno::EINTR
+            sleep 0.3
+        end
+    end
+
+    def recv_msg_from_sock(sock)
+        @parser.parse_start
+        msg = nil
+        while msg.nil? and not sock.closed? do
+            line = sock.gets
+            msg = @parser.parse_partial line
+        end
+        queue_msg msg, TCPSourceFromSocket.new(sock)
+    end
+
+    def add_sock sock
+      @sockets.push sock
+    end
+
+    def terminate
+      oldsockets = @sockets.dup
+      @sockets = []
+      oldsockets.each do |s| s.close unless s.closed? end
+      mycxn = @cxn
+      @cxn = nil
+      mycxn.close
+    end
+
+end
+
+class UDPSIPEndpoint < BaseEndpoint
+
+    def recv_msg
+        data, addrinfo = @cxn.recvfrom(65535)
+        @parser.parse_start
+        msg = @parser.parse_partial(data)
+        queue_msg msg, UDPSourceFromAddrinfo.new(addrinfo) unless msg.nil?
+    end
+
+    def transport
+      "UDP"
+    end
+    
+    def new_source ip, port
+      return UDPSource.new ip, port
+    end
+    
+    alias_method :new_connection, :new_source
+    
+    def initialize_connection(lport)
+        @cxn = UDPSocket.new
+        @cxn.bind('0.0.0.0', lport)
+        @sockets = []
+        @parser = SipParser.new
+    end
+
+end
+

data/lib/quaff.rb

@@ -0,0 +1,2 @@
+require_relative './call.rb'
+require_relative './endpoint.rb'

data/lib/sip_parser.rb

@@ -0,0 +1,133 @@
+# -*- coding: us-ascii -*-
+require 'digest/md5'
+
+class SipMessage
+    attr_accessor :type, :method, :requri, :reason, :status_code, :headers, :body
+
+    def initialize
+        @headers = {}
+        @method, @status_code, @reason, @req_uri = nil
+        @body = ""
+    end
+
+    def all_headers hdr
+        return @headers[hdr]
+    end
+
+    def header hdr
+        return @headers[hdr][0] unless @headers[hdr].nil?
+    end
+
+    alias_method :first_header, :header
+
+    def to_s
+       "#{@method} #{@status_code} #{@headers}"
+    end
+
+end
+
+  class SipParser
+    attr_reader :state
+    def parse_start
+        @buf = ""
+        @msg = SipMessage.new
+        @state = :blank
+    end
+
+    def parse_partial(data)
+        return nil if data.nil?
+        data.lines.each do |line|
+            if @state == :blank
+                parse_line_blank line
+            elsif @state == :parsing_body
+                parse_line_body line
+            else
+                parse_line_first_line_parsed line
+            end
+        end
+            if @state == :done
+                return @msg
+            else
+                return nil
+            end
+    end
+
+    def message_identifier(msg)
+        msg.header("Call-ID")
+    end
+
+    def parse_line_blank line
+        if line =~ %r!^([A-Z]+) (.+) SIP/2.0\r$!
+            @msg.type = :request
+            @msg.method = $1
+            @msg.requri = $2
+            @state = :first_line_parsed
+        elsif line =~ %r!^SIP/2.0 (\d+) (.+)\r$!
+            @msg.type = :response
+            @msg.status_code = $1
+            @msg.reason = $3 || ""
+            @state = :first_line_parsed
+        elsif line == "\r" or line == "\r\n"
+            # skip empty lines
+        else
+            raise line.inspect
+        end
+    end
+
+    def parse_line_first_line_parsed line
+        if line =~ /^\s+(.+)\r/
+            @msg.headers[@cur_hdr][-1] += " "
+            @msg.headers[@cur_hdr][-1] += $1
+            if $1 == "Content-Length"
+                @state = :got_content_length
+            else
+                @state = :middle_of_headers
+            end
+        elsif line =~ /^([-\w]+)\s*:\s*(.+)\r/
+            @msg.headers[$1] ||= []
+            @msg.headers[$1].push $2
+            @cur_hdr = $1
+            if $1 == "Content-Length"
+                @state = :got_content_length
+            else
+                @state = :middle_of_headers
+            end
+        elsif line == "\r" or line == "\r\n"
+            if @state == :got_content_length and @msg.header("Content-Length").to_i > 0
+               @state = :parsing_body
+            else
+               @state = :done
+            end
+        else raise line.inspect
+        end
+    end
+
+    def parse_line_body line
+       @msg.body << line
+       if line == "\r" or @msg.body.length >= @msg.header("Content-Length").to_i
+         @state = :done
+       end
+    end
+
+end
+
+  def gen_nonce auth_pairs, username, passwd, method, sip_uri         
+    a1 = username + ":" + auth_pairs["realm"] + ":" + passwd
+    a2 = method + ":" + sip_uri
+    ha1 = Digest::MD5::hexdigest(a1)
+    ha2 = Digest::MD5::hexdigest(a2)
+    digest = Digest::MD5.hexdigest(ha1 + ":" + auth_pairs["nonce"] + ":" + ha2)
+    return digest
+  end
+
+  def gen_auth_header auth_line, username, passwd, method, sip_uri
+    # Split auth line on commas
+    auth_pairs = {}
+    auth_line.sub("Digest ", "").split(",") .each do |pair| 
+      key, value = pair.split "="
+      auth_pairs[key.gsub(" ", "")] = value.gsub("\"", "").gsub(" ", "")
+    end
+    digest = gen_nonce auth_pairs, username, passwd, method, sip_uri         
+    return %Q!Digest username="#{username}",realm="#{auth_pairs['realm']}",nonce="#{auth_pairs['nonce']}",uri="#{sip_uri}",response="#{digest}",algorithm="#{auth_pairs['algorithm']}",opaque="#{auth_pairs['opaque']}"!
+    # Return Authorization header with fields username, realm, nonce, uri, nc, cnonce, response, opaque
+  end

data/lib/sources.rb

@@ -0,0 +1,60 @@
+require 'socket'
+
+class Source
+    def remote_ip
+        @ip
+    end
+
+    def remote_port
+        @port
+    end
+
+    def close cxn
+    end
+
+    def sock
+      nil
+    end
+end
+
+class UDPSource < Source
+    def initialize ip, port
+        @ip, @port = ip, port
+    end
+
+    def send cxn, data
+        cxn.send(data, 0, @ip, @port)
+    end
+end
+
+class UDPSourceFromAddrinfo < UDPSource
+    def initialize addrinfo
+        @ip, @port = addrinfo[3], addrinfo[1]
+    end
+end
+
+
+class TCPSource < Source
+	attr_reader :sock
+
+    def initialize ip, port
+        @sock = TCPSocket.new ip, port 
+        @port, @ip = port, ip
+    end
+
+    def send _, data
+        @sock.puts data
+    end
+
+    def close cxn
+        @sock.close
+        cxn.sockets.delete(@sock)
+    end
+end
+
+class TCPSourceFromSocket < TCPSource
+    def initialize sock
+      @sock = sock
+      @port, @ip = Socket.unpack_sockaddr_in(@sock.getpeername)
+    end
+end

data/lib/utils.rb

@@ -0,0 +1,23 @@
+require 'socket'
+
+module QuaffUtils
+def QuaffUtils.local_ip
+    Socket.ip_address_list.select {|i| !(i.ipv6? || i.ipv4_loopback?)}[0].ip_address
+end
+
+def local_ipv6
+    Socket.ip_address_list.select {|i| !(i.ipv4? || i.ipv6_loopback?)}[0].ip_address
+end
+
+def pid
+    Process.pid
+end
+
+def new_call_id
+    "#{pid}_#{Time.new.to_i}@#{local_ipv4}"
+end
+
+def QuaffUtils.new_branch
+    "z9hG4bK#{Time.new.to_f}"
+end
+end

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification
+name: quaff
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Rob Day
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-24 00:00:00.000000000 Z
+dependencies: []
+description: A Ruby library for writing SIP test scenarios
+email: rkd@rkd.me.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/quaff.rb
+- lib/utils.rb
+- lib/call.rb
+- lib/sources.rb
+- lib/sip_parser.rb
+- lib/endpoint.rb
+homepage: http://github.com/rkd91/quaff
+licenses:
+- GPL3
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Quaff
+test_files: []