sippy_cup 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0bf8b63922a80ba9eb886d9ad0713f953376f6f6
-  data.tar.gz: df89e36db406772721fb83164372f1e7c7787261
+  metadata.gz: a6c679bd0c325ab8fb92408015dfacb1c5a88373
+  data.tar.gz: 557e222b71aa5286356bf63f37f63ba9233a46e3
 SHA512:
-  metadata.gz: 436f979aeee94dfbe201ec011ba339cf12977dc9929741bb07c9beee9fe4ccfda3d0f113263b0ca5ad1f003d475e9e2dc2e37c247cabe527cb549f4d26c164cc
-  data.tar.gz: 7c613e7768152d9e6a84d3145abfeca4396363fb2aaeaabec2927d45329ecf04f3a5ebc61f06b5a01dd71631aba37618ec05a5c6f2e1909586924986a18d36a6
+  metadata.gz: 2a3f0ef5f1ffcbe843918382fa318e34476c2e7ecdb0dff8fe762f27efd26339d34c7ceeb69ed1d409b45fb329ba687f2e6552c051def0cff88a222c5d972ca4
+  data.tar.gz: d8cbeeb69fde07e94936b5e20835a56c4df265f4ded018a6a3d051709d40ab5006df6f58e005ab165f10559dfab4e03d926a3370f76605aedba737c84dd202eb

data/.gitignore

@@ -1,2 +1,3 @@
 .*.sw*
 .DS_Store
+*.gem

data/Gemfile

@@ -1,5 +1,3 @@
 source 'https://rubygems.org'
 
 gemspec
-
-gem 'pcap', github: 'ahobson/ruby-pcap'

data/README.markdown

@@ -3,3 +3,52 @@ Sippy Cup
 
 Sippy Cup is a tool to generate [SIPp](http://sipp.sourceforge.net/) load test profiles. The goal is to take an input document that describes a load test in a very simple way (call this number, wait this many seconds, send this digit, wait a few more seconds, etc).  The ideas are taken from [LoadBot](https://github.com/mojolingo/ahn-loadbot), but the goal is for a more performant load generating tool with no dependency on Asterisk.
 
+
+Example
+=======
+
+```Ruby
+require 'sippy_cup'
+
+scenario = SippyCup::Scenario.new 'Sippy Cup', source: '192.168.5.5:10001', destination: '10.10.0.3:19995' do |s|
+  s.invite
+  s.receive_trying
+  s.receive_ringing
+  s.receive_progress
+
+  s.receive_answer
+  s.ack_answer
+
+  s.sleep 3
+  s.send_digits '3125551234'
+  s.sleep 5
+  s.send_digits '#'
+
+  s.receive_bye
+  s.ack_bye
+end
+
+# Create the scenario XML and PCAP media. File will be named after the scenario name, in our case:
+# * sippy_cup.xml
+# * sippy_cup.pcap
+scenario.compile!
+```
+
+Customize Your Scenarios
+========================
+
+With Sippy Cup, you can add additional attributes to each step of the scenario:
+```Ruby
+
+#This limits the amount of time the server has to reply to an invite (3 seconds)
+s.receive_answer timeout: 3000
+
+#You can override the default 'optional' parameters
+s.receive_ringing optional: false
+s.receive_answer optional: true
+
+#Let's combine multiple attributes...
+s.receive_answer timeout: 3000, crlf: true
+```
+
+For more information on possible attributes, visit the [SIPp Documentation](http://sipp.sourceforge.net/doc/reference.html)

data/lib/sippy_cup.rb

@@ -1,4 +1,7 @@
-require 'sippy_cup/scenario'
+%w{
+  scenario
+  media
+}.each {|r| require "sippy_cup/#{r}"}
 
 module SippyCup
 

data/lib/sippy_cup/media.rb

@@ -0,0 +1,120 @@
+require 'ipaddr'
+require 'sippy_cup/media/pcmu_payload'
+require 'sippy_cup/media/dtmf_payload'
+
+module SippyCup
+  class Media
+    VALID_STEPS = %w{silence dtmf}.freeze
+    USEC = 1_000_000
+    MSEC = 1_000
+    attr_accessor :sequence
+    attr_reader :packets
+
+    def initialize(from_addr, from_port, to_addr, to_port, generator = PCMUPayload)
+      @from_addr, @to_addr = IPAddr.new(from_addr), IPAddr.new(to_addr)
+      @from_port, @to_port, @generator = from_port, to_port, generator
+      reset!
+    end
+
+    def reset!
+      @sequence = []
+      @packets = []
+    end
+
+    def <<(input)
+      get_step input # validation
+      @sequence << input
+    end
+
+    def compile!
+      sequence_number = 0
+      start_time = Time.now
+      @pcap_file = PacketFu::PcapFile.new
+      timestamp = 0
+      elapsed = 0
+      ssrc_id = rand 2147483648
+      first_audio = true
+
+      @sequence.each do |input|
+        action, value = get_step input
+        
+        case action
+        when 'silence'
+          # value is the duration in milliseconds
+          # append that many milliseconds of silent RTP audio
+          (value.to_i / @generator::PTIME).times do
+            packet = new_packet
+            rtp_frame = @generator.new
+
+            # The first RTP audio packet should have the marker bit set
+            if first_audio
+              rtp_frame.rtp_marker = 1
+              first_audio = false
+            end
+
+            rtp_frame.rtp_timestamp = timestamp += rtp_frame.timestamp_interval
+            elapsed += rtp_frame.ptime
+            rtp_frame.rtp_sequence_num = sequence_number += 1
+            rtp_frame.rtp_ssrc_id = ssrc_id
+            packet.headers.last.body = rtp_frame.to_bytes
+            packet.recalc
+            @pcap_file.body << get_pcap_packet(packet, next_ts(start_time, elapsed))
+          end
+        when 'dtmf'
+          # value is the DTMF digit to send
+          # append that RFC2833 digit
+          # Assume 0.25 second duration for now
+          count = 250 / DTMFPayload::PTIME
+          count.times do |i|
+            packet = new_packet
+            dtmf_frame = DTMFPayload.new value
+            dtmf_frame.rtp_marker = 1 if i == 0
+            dtmf_frame.rtp_timestamp = timestamp # Is this correct? This is what Blink does...
+            #dtmf_frame.rtp_timestamp = timestamp += dtmf_frame.timestamp_interval
+            dtmf_frame.rtp_sequence_num = sequence_number += 1
+            dtmf_frame.rtp_ssrc_id = ssrc_id
+            dtmf_frame.end_of_event = (count == i) # Last packet?
+            packet.headers.last.body = dtmf_frame.to_bytes
+            packet.recalc
+            @pcap_file.body << get_pcap_packet(packet, next_ts(start_time, elapsed))
+          end
+          # Now bump up the timestamp to cover the gap
+          timestamp += count * DTMFPayload::TIMESTAMP_INTERVAL
+        else
+        end
+      end
+      @pcap_file
+    end
+  private
+    def get_step(input)
+      action, value = input.split ':'
+      raise "Invalid Sequence: #{input}" unless VALID_STEPS.include? action
+
+      [action, value]
+    end
+
+
+    def get_pcap_packet(packet, timestamp)
+      PacketFu::PcapPacket.new :timestamp => timestamp,
+                               :incl_len => packet.to_s.size,
+                               :orig_len => packet.to_s.size,
+                               :data => packet.to_s
+    end
+
+    def next_ts(start_time, offset)
+      distance = offset * MSEC
+      sec = start_time.to_i + (distance / USEC)
+      usec = distance % USEC
+      PacketFu::Timestamp.new(sec: sec, usec: usec).to_s
+    end
+
+    def new_packet
+      packet = PacketFu::UDPPacket.new
+      packet.ip_src = @from_addr.to_i
+      packet.ip_dst = @to_addr.to_i
+      packet.udp_src = @from_port
+      packet.udp_dst = @to_port
+      packet
+    end
+  end
+end

data/lib/sippy_cup/media/dtmf_payload.rb

@@ -0,0 +1,54 @@
+require 'sippy_cup/media/rtp_payload'
+
+module SippyCup
+  class Media
+    class DTMFPayload < RTPPayload
+      RTP_PAYLOAD_ID = 101
+      PTIME = 20 # in milliseconds
+      TIMESTAMP_INTERVAL = 160
+      END_OF_EVENT = 1 << 7
+      DTMF = %w{0 1 2 3 4 5 6 7 8 9 * # A B C D}.freeze
+      attr_accessor :ptime
+
+      def initialize(digit, opts = {})
+        super RTP_PAYLOAD_ID
+        @flags = 0
+        @digit = atoi digit
+        @ptime = opts[:ptime] || PTIME
+
+        volume opts[:volume] || 10
+      end
+
+      def end_of_event=(bool)
+        if bool
+          @flags |= END_OF_EVENT
+        else
+          @flags &= (0xf - END_OF_EVENT)
+        end
+      end
+
+      def atoi(digit)
+        DTMF.index digit.to_s
+      end
+
+      def volume(value)
+        value = [value, 0x3f].min # Cap to 6 bits
+        @flags &= 0xc0 # zero out old volume
+        @flags += value
+      end
+
+      def end_of_event
+        @flags & END_OF_EVENT
+      end
+
+      def media
+        [@digit, @flags, timestamp_interval].pack 'CCn'
+      end
+
+      def timestamp_interval
+        TIMESTAMP_INTERVAL
+      end
+    end
+  end
+end
+

data/lib/sippy_cup/media/pcmu_payload.rb

@@ -0,0 +1,27 @@
+require 'sippy_cup/media/rtp_payload'
+
+module SippyCup
+  class Media
+    class PCMUPayload < RTPPayload
+      RTP_PAYLOAD_ID = 0x0
+      SILENT_BYTE = 0xff.chr
+      PTIME = 20 # in milliseconds
+      RATE = 8 # in KHz
+      attr_accessor :ptime
+
+      def initialize(opts = {})
+        super RTP_PAYLOAD_ID
+        @ptime = opts[:ptime] || PTIME
+        @rate  = opts[:rate]  || RATE
+      end
+
+      def media
+        SILENT_BYTE * timestamp_interval
+      end
+
+      def timestamp_interval
+        @rate * @ptime
+      end
+    end
+  end
+end

data/lib/sippy_cup/media/rtp_header.rb

@@ -0,0 +1,69 @@
+# encoding: utf-8
+require 'packetfu'
+
+module SippyCup
+  class Media
+    class RTPHeader < Struct.new(:version, :padding, :extension, :marker, :payload_id, :sequence_num, :timestamp, :ssrc_id, :csrc_ids)
+      VERSION    = 2
+
+      include StructFu
+
+      def initialize(args = {})
+        # TODO: Support Extension Header
+        super(
+          (args[:version] ? args[:version] : VERSION),
+          (args[:padding] ? args[:padding] : 0),
+          (args[:extension] ? args[:extension] : 0),
+          (args[:marker] ? args[:marker] : 0),
+          (args[:payload_id] ? args[:payload_id] : 0),
+          Int16.new(args[:sequence_num] ? args[:sequence_num] : 0),
+          Int32.new(args[:timestamp] ? args[:timestamp] : 0),
+          Int32.new(args[:ssrc_id] ? args[:ssrc_id] : 0),
+          (args[:csrc_ids] ? Array(args[:csrc_ids]) : []),
+        )
+      end
+
+      def read(str)
+        self[:version] = str[0].ord >> 6
+        self[:padding] = (str[0].ord >> 5) & 1
+        self[:extension] = (str[0].ord >> 4) & 1
+        num_csrcs = str[0].ord & 0xf
+        self[:marker] = str[1] >> 7
+        self[:payload_id] = str[1] & 0x7f
+        self[:sequence_num].read str[2,2]
+        self[:timestamp].read str[4,4]
+        self[:ssrc_id].read str[8,4]
+        i = 8
+        num_csrcs.times do
+          self[:csrc_ids] << Int32.new(str[i += 4, 4])
+        end
+        self[:body] = str[i, str.length - i]
+      end
+
+      def csrc_count
+        csrc_ids.count
+      end
+
+      def csrc_ids_readable
+        csrc_ids.to_s
+      end
+
+      def to_s
+        bytes = [
+          (version << 6) + (padding << 5) + (extension << 4) + (csrc_count),
+          (marker << 7) + (payload_id),
+          sequence_num,
+          timestamp,
+          ssrc_id
+        ].pack 'CCnNN'
+
+        csrc_ids.each do |csrc_id|
+          bytes << [csrc_id].pack('N')
+        end
+
+        bytes
+      end
+    end
+  end
+end
+

data/lib/sippy_cup/media/rtp_payload.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+require 'packetfu'
+require 'sippy_cup/media/rtp_header'
+
+module SippyCup
+  class Media
+    class RTPPayload
+      attr_reader :header
+
+      def initialize(payload_id = 0)
+        @header = RTPHeader.new payload_id: payload_id
+      end
+
+      def to_bytes
+        @header.to_s + media
+      end
+
+      def method_missing(method, *args)
+        if method.to_s =~ /^rtp_/
+          method = method.to_s.sub(/^rtp_/, '').to_sym
+          @header.send method, *args
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/sippy_cup/rtp_generator.rb

@@ -0,0 +1,19 @@
+require 'pcap'
+
+module SippyCup
+  class RTPGenerator
+    DEFAULT_DATALINK = 1 # Corresponds to DLT_EN10MB, Ethernet (10Mb) from pcap/bpf.h
+
+    def initialize
+      @output = Pcap::Capture.open_dead DEFAULT_DATALINK, 65535
+
+
+
+    def save!(file)
+      pcap_file = Pcap::Dumper.open @output, file
+      @output.loop(-1) do |packet|
+        pcap_file.dump packet
+      end
+    end
+  end
+end

data/lib/sippy_cup/scenario.rb

@@ -2,33 +2,56 @@ require 'nokogiri'
 
 module SippyCup
   class Scenario
-    def initialize(name, &block)
+    VALID_DTMF = %w{0 1 2 3 4 5 6 7 8 9 0 * # A B C D}.freeze
+    MSEC = 1_000
+
+    def initialize(name, args = {}, &block)
       builder = Nokogiri::XML::Builder.new do |xml|
         xml.scenario name: name
       end
 
+      parse_args args
+
+      @filename = name.downcase.gsub(/\W+/, '_')
       @doc = builder.doc
+      @media = Media.new @from_addr, @from_port, @to_addr, @to_port
       @scenario = @doc.xpath('//scenario').first
 
       instance_eval &block
     end
 
+    def parse_args(args)
+      raise ArgumentError, "Must include source IP:PORT" unless args.keys.include? :source
+      raise ArgumentError, "Must include destination IP:PORT" unless args.keys.include? :destination
+
+      @from_addr, @from_port = args[:source].split ':'
+      @to_addr, @to_port = args[:destination].split ':'
+      @from_user = args[:from_user] || "sipp"
+    end
+
+    def compile_media
+      @media.compile!
+    end
+
     def sleep(seconds)
       # TODO play silent audio files to the server to fill the gap
-      pause = Nokogiri::XML::Node.new 'pause', @doc
-      pause['milliseconds'] = seconds
-      @scenario.add_child pause
+      pause seconds * MSEC
+      @media << "silence:#{seconds * MSEC}"
     end
 
-    def invite
+    def invite(opts = {})
+      opts[:retrans] ||= 500
+      # FIXME: The DTMF mapping (101) is hard-coded. It would be better if we could
+      # get this from the DTMF payload generator
       msg = <<-INVITE
+
         INVITE sip:[service]@[remote_ip]:[remote_port] SIP/2.0
         Via: SIP/2.0/[transport] [local_ip]:[local_port];branch=[branch]
-        From: sipp <sip:[field0]@[local_ip]>;tag=[call_number]
+        From: sipp <sip:#{@from_user}@[local_ip]>;tag=[call_number]
         To: <sip:[service]@[remote_ip]:[remote_port]>
         Call-ID: [call_id]
         CSeq: [cseq] INVITE
-        Contact: sip:[field0]@[local_ip]:[local_port]
+        Contact: sip:#{@from_user}@[local_ip]:[local_port]
         Max-Forwards: 100
         Content-Type: application/sdp
         Content-Length: [len]
@@ -38,61 +61,111 @@ module SippyCup
         s=-
         c=IN IP[media_ip_type] [media_ip]
         t=0 0
-        m=audio [media_port] RTP/AVP 0
+        m=audio [media_port] RTP/AVP 0 101
         a=rtpmap:0 PCMU/8000
+        a=rtpmap:101 telephone-event/8000
+        a=fmtp:101 0-15
       INVITE
-      send = new_send msg
-      # FIXME: Does this need to be configurable?
-      send['retrans'] = 500
-
+      send = new_send msg, opts
       @scenario << send
     end
 
-    def receive_trying(optional = true)
-      @scenario.add_child new_recv response: 100, optional: optional
+    def receive_trying(opts = {})
+      opts[:optional] = true if opts[:optional].nil?
+      opts.merge! response: 100
+      @scenario << new_recv(opts)
     end
     alias :receive_100 :receive_trying
       
-    def receive_ringing(optional = true)
-      @scenario.add_child new_recv response: 180, optional: optional
+    def receive_ringing(opts = {})
+      opts[:optional] = true if opts[:optional].nil?
+      opts.merge! response: 180
+      @scenario << new_recv(opts)
     end
     alias :receive_180 :receive_ringing
       
-    def receive_progress(optional = true)
-      @scenario.add_child new_recv response: 183, optional: optional
+    def receive_progress(opts = {})
+      opts[:optional] = true if opts[:optional].nil?
+      opts.merge! response: 183
+      @scenario << new_recv(opts)
     end
     alias :receive_183 :receive_progress
 
-    def receive_answer
-      recv = new_recv response: 200, optional: false
+    def receive_answer(opts = {})
+      opts.merge! response: 200
+      recv = new_recv opts
       # Record Record Set: Make the Route headers available via [route] later
       recv['rrs'] = true
-      @scenario.add_child recv
+      @scenario << recv
     end
     alias :receive_200 :receive_answer
 
-    def ack_answer
+    def ack_answer(opts = {})
       msg = <<-ACK
+
         ACK [next_url] SIP/2.0
         Via: SIP/2.0/[transport] [local_ip]:[local_port];branch=[branch]
-        From: <sip:[field0]@[local_ip]>;tag=[call_number]
+        From: <sip:#{@from_user}@[local_ip]>;tag=[call_number]
         [last_To:]
         [routes]
         Call-ID: [call_id]
         CSeq: [cseq] ACK
-        Contact: sip:[field0]@[local_ip]:[local_port]
+        Contact: sip:#{@from_user}@[local_ip]:[local_port]
         Max-Forwards: 100
         Content-Length: 0
       ACK
-      @scenario << new_send(msg)
+      @scenario << new_send(msg, opts)
+      start_media
+    end
+
+    def start_media
+      nop = Nokogiri::XML::Node.new 'nop', @doc
+      action = Nokogiri::XML::Node.new 'action', @doc
+      nop << action
+      exec = Nokogiri::XML::Node.new 'exec', @doc
+      exec['play_pcap_audio'] = "#{@filename}.pcap"
+      action << exec
+      @scenario << nop
     end
 
-    def receive_bye
-      @scenario.add_child new_recv response: 'BYE'
+    ##
+    # Send DTMF digits
+    # @param[String] DTMF digits to send. Must be 0-9, *, # or A-D
+    def send_digits(digits, delay = 0.250)
+      delay = 0.250 * MSEC # FIXME: Need to pass this down to the media layer
+      digits.split('').each do |digit|
+        raise ArgumentError, "Invalid DTMF digit requested: #{digit}" unless VALID_DTMF.include? digit
+
+        @media << "dtmf:#{digit}"
+        @media << "silence:#{delay}"
+        pause delay * 2
+      end
     end
 
-    def ack_bye
+    def send_bye(opts = {})
+      msg = <<-MSG
+
+        BYE sip:[service]@[remote_ip]:[remote_port] SIP/2.0
+        [last_Via:]
+        [last_From:]
+        [last_To:]
+        [last_Call-ID]
+        CSeq: [cseq] BYE
+        Contact: <sip:[local_ip]:[local_port];transport=[transport]>
+        Max-Forwards: 100
+        Content-Length: 0
+      MSG
+      @scenario << new_send(msg, opts)
+    end
+
+    def receive_bye(opts = {})
+      opts.merge! request: 'BYE'
+      @scenario << new_recv(opts)
+    end
+
+    def ack_bye(opts = {})
       msg = <<-ACK
+
         SIP/2.0 200 OK
         [last_Via:]
         [last_From:]
@@ -104,27 +177,47 @@ module SippyCup
         Max-Forwards: 100
         Content-Length: 0
       ACK
-      @scenario << new_send(msg)
+      @scenario << new_send(msg, opts)
     end
 
     def to_xml
       @doc.to_xml
     end
 
+    def compile!
+      xml_file = File.open "#{@filename}.xml", 'w' do |file|
+        file.write @doc.to_xml
+      end
+      compile_media.to_file filename: "#{@filename}.pcap"
+    end
+
   private
+    def pause(msec)
+      pause = Nokogiri::XML::Node.new 'pause', @doc
+      pause['milliseconds'] = msec.to_i
+      @scenario << pause
+    end
 
-    def new_send(msg)
+    def new_send(msg, opts = {})
       send = Nokogiri::XML::Node.new 'send', @doc
-      send << Nokogiri::XML::Text.new(msg, @doc)
+      opts.each do |k,v|
+        send[k.to_s] = v
+      end
+      send << "\n"
+      send << Nokogiri::XML::CDATA.new(@doc, msg)
+      send << "\n" #Newlines are required before and after CDATA so SIPp will parse properly
       send
     end
 
     def new_recv(opts = {})
       raise ArgumentError, "Receive must include either a response or a request" unless opts.keys.include?(:response) || opts.keys.include?(:request)
       recv = Nokogiri::XML::Node.new 'recv', @doc
-      recv['request']  = opts[:request]  if opts.keys.include? :request
-      recv['response'] = opts[:response] if opts.keys.include? :response
-      recv['optional'] = !!opts[:optional]
+      recv['request']  = opts.delete :request  if opts.keys.include? :request
+      recv['response'] = opts.delete :response if opts.keys.include? :response
+      recv['optional'] = !!opts.delete(:optional)
+      opts.each do |k,v|
+        recv[k.to_s] = v
+      end
       recv
     end
   end

data/lib/sippy_cup/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module SippyCup
-  VERSION = '0.0.1'
+  VERSION = '0.1.0'
 end

data/sippy_cup.gemspec

@@ -6,8 +6,8 @@ Gem::Specification.new do |s|
   s.name        = "sippy_cup"
   s.version     = SippyCup::VERSION
   s.platform    = Gem::Platform::RUBY
-  s.authors     = ["Ben Klang"]
-  s.email       = "bklang&mojolingo.com"
+  s.authors     = ["Ben Klang", "Will Drexler"]
+  s.email       = ["bklang&mojolingo.com", "wdrexler&mojolingo.com"]
   s.homepage    = "https://github.com/bklang/sippy_cup"
   s.summary     = "SIPp profile and RTP stream generator"
   s.description = "This tool makes it easier to generate SIPp load tests with DTMF interactions."
@@ -17,7 +17,7 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_runtime_dependency 'pcap'
+  s.add_runtime_dependency 'packetfu'
   s.add_runtime_dependency 'nokogiri', ["~> 1.5.0"]
 
   s.add_development_dependency 'guard-rspec'

metadata

@@ -1,17 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: sippy_cup
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Ben Klang
+- Will Drexler
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-13 00:00:00.000000000 Z
+date: 2013-07-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: pcap
+  name: packetfu
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
@@ -95,7 +96,9 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 description: This tool makes it easier to generate SIPp load tests with DTMF interactions.
-email: bklang&mojolingo.com
+email:
+- bklang&mojolingo.com
+- wdrexler&mojolingo.com
 executables:
 - sippy_cup
 extensions: []
@@ -108,6 +111,12 @@ files:
 - README.markdown
 - bin/sippy_cup
 - lib/sippy_cup.rb
+- lib/sippy_cup/media.rb
+- lib/sippy_cup/media/dtmf_payload.rb
+- lib/sippy_cup/media/pcmu_payload.rb
+- lib/sippy_cup/media/rtp_header.rb
+- lib/sippy_cup/media/rtp_payload.rb
+- lib/sippy_cup/rtp_generator.rb
 - lib/sippy_cup/scenario.rb
 - lib/sippy_cup/version.rb
 - sippy_cup.gemspec