Class: Rex::Proto::IAX2::Call

Inherits:
Object
  • Object
show all
Defined in:
lib/rex/proto/iax2/call.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(client, src_id) ⇒ Call

Returns a new instance of Call.



24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
# File 'lib/rex/proto/iax2/call.rb', line 24

def initialize(client, src_id)
	self.client = client
	self.scall  = src_id
	self.dcall  = 0
	self.iseq   = 0
	self.oseq   = 0
	self.state  = nil

	self.itime  = ::Time.now
	self.queue  = ::Queue.new

	self.audio_buff = []

	self.busy = false
	self.dtmf = ''
end

Instance Attribute Details

#audio_buff ⇒ Object

Returns the value of attribute audio_buff.



15
16
17
 
# File 'lib/rex/proto/iax2/call.rb', line 15

def audio_buff
  @audio_buff
end

#audio_hook ⇒ Object

Returns the value of attribute audio_hook.



14
15
16
 
# File 'lib/rex/proto/iax2/call.rb', line 14

def audio_hook
  @audio_hook
end

#busy ⇒ Object

Returns the value of attribute busy.



17
18
19
 
# File 'lib/rex/proto/iax2/call.rb', line 17

def busy
  @busy
end

#caller_name ⇒ Object

Returns the value of attribute caller_name.



19
20
21
 
# File 'lib/rex/proto/iax2/call.rb', line 19

def caller_name
  @caller_name
end

#caller_number ⇒ Object

Returns the value of attribute caller_number.



20
21
22
 
# File 'lib/rex/proto/iax2/call.rb', line 20

def caller_number
  @caller_number
end

#client ⇒ Object

Returns the value of attribute client.



7
8
9
 
# File 'lib/rex/proto/iax2/call.rb', line 7

def client
  @client
end

#codec ⇒ Object

Returns the value of attribute codec.



10
11
12
 
# File 'lib/rex/proto/iax2/call.rb', line 10

def codec
  @codec
end

#dcall ⇒ Object

Returns the value of attribute dcall.



9
10
11
 
# File 'lib/rex/proto/iax2/call.rb', line 9

def dcall
  @dcall
end

#dtmf ⇒ Object

Returns the value of attribute dtmf.



21
22
23
 
# File 'lib/rex/proto/iax2/call.rb', line 21

def dtmf
  @dtmf
end

#iseq ⇒ Object

Returns the value of attribute iseq.



8
9
10
 
# File 'lib/rex/proto/iax2/call.rb', line 8

def iseq
  @iseq
end

#itime ⇒ Object

Returns the value of attribute itime.



12
13
14
 
# File 'lib/rex/proto/iax2/call.rb', line 12

def itime
  @itime
end

#oseq ⇒ Object

Returns the value of attribute oseq.



8
9
10
 
# File 'lib/rex/proto/iax2/call.rb', line 8

def oseq
  @oseq
end

#queue ⇒ Object

Returns the value of attribute queue.



13
14
15
 
# File 'lib/rex/proto/iax2/call.rb', line 13

def queue
  @queue
end

#ring_finish ⇒ Object

Returns the value of attribute ring_finish.



11
12
13
 
# File 'lib/rex/proto/iax2/call.rb', line 11

def ring_finish
  @ring_finish
end

#ring_start ⇒ Object

Returns the value of attribute ring_start.



11
12
13
 
# File 'lib/rex/proto/iax2/call.rb', line 11

def ring_start
  @ring_start
end

#scall ⇒ Object

Returns the value of attribute scall.



9
10
11
 
# File 'lib/rex/proto/iax2/call.rb', line 9

def scall
  @scall
end

#state ⇒ Object

Returns the value of attribute state.



10
11
12
 
# File 'lib/rex/proto/iax2/call.rb', line 10

def state
  @state
end

#time_limit ⇒ Object

Returns the value of attribute time_limit.



16
17
18
 
# File 'lib/rex/proto/iax2/call.rb', line 16

def time_limit
  @time_limit
end

Instance Method Details

#audio_packet_data(pkt) ⇒ Object 



314
315
316
 
# File 'lib/rex/proto/iax2/call.rb', line 314

def audio_packet_data(pkt)
	(pkt[0,1].unpack("C")[0] & 0x80 == 0) ? pkt[4,pkt.length-4] : pkt[12,pkt.length-12]
end

#decode_audio_frame(buff) ⇒ Object 



292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
 
# File 'lib/rex/proto/iax2/call.rb', line 292

def decode_audio_frame(buff)
	case self.codec

	# Convert u-law into signed PCM
	when IAX_CODEC_G711_MULAW
		Rex::Proto::IAX2::Codecs::MuLaw.decode(buff)

	# Convert a-law into signed PCM
	when IAX_CODEC_G711_ALAW
		Rex::Proto::IAX2::Codecs::ALaw.decode(buff)

	# Linear little-endian signed PCM is our native format
	when IAX_CODEC_LINEAR_PCM
		buff

	# Unsupported codec, return empty
	else
		dprint("UNKNOWN CODEC: #{self.codec.inspect}")
		''
	end
end

#dial(number) ⇒ Object 



104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
 
# File 'lib/rex/proto/iax2/call.rb', line 104

def dial(number)
	self.client.send_new(self, number)
	res = wait_for(IAX_SUBTYPE_AUTHREQ, IAX_SUBTYPE_ACCEPT)
	return if not res

	# Handle authentication if its requested
	if res[1] == IAX_SUBTYPE_AUTHREQ
		chall = nil
		if res[2][14] == "\x00\x03" and res[1][15]
			self.dcall = res[0][0]
			chall = res[2][15]
		end

		self.client.send_authrep_chall_response(self, chall)
		res = wait_for( IAX_SUBTYPE_ACCEPT)
		return if not res
	end

	self.codec = res[2][IAX_IE_DESIRED_CODEC].unpack("N")[0]
	self.state = :ringing
	self.ring_start = ::Time.now.to_i
	self.client.send_ack(self)
	true
end

#dprint(msg) ⇒ Object 



42
43
44
 
# File 'lib/rex/proto/iax2/call.rb', line 42

def dprint(msg)
	self.client.dprint(msg)
end

#each_audio_frame(&block) ⇒ Object 



286
287
288
289
290
 
# File 'lib/rex/proto/iax2/call.rb', line 286

def each_audio_frame(&block)
	self.audio_buff.each do |frame|
		block.call(frame)
	end
end

#handle_audio(pkt) ⇒ Object

Encoded audio from the client



267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
 
# File 'lib/rex/proto/iax2/call.rb', line 267

def handle_audio(pkt)
	# Ignore audio received before the call is answered (ring ring)
	return if self.state != :answered

	# Extract the data from the packet (full or mini)
	data = audio_packet_data(pkt)

	# Decode the data into linear PCM frames
	buff = decode_audio_frame(data)

	# Call the caller-provided hook if its exists
	if self.audio_hook
		self.audio_buff(buff)
	# Otherwise append the frame to the buffer
	else
		self.audio_buff << buff
	end
end

#handle_control(pkt) ⇒ Object

Handling incoming control packets TODO: Enforce sequence order to prevent duplicates from breaking our state



156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
 
# File 'lib/rex/proto/iax2/call.rb', line 156

def handle_control(pkt)
	src_call, dst_call, tstamp, out_seq, inp_seq, itype = pkt.unpack('nnNCCC')

	# Scrub the high bits out of the call IDs
	src_call ^= 0x8000 if (src_call & 0x8000 != 0)
	dst_call ^= 0x8000 if (dst_call & 0x8000 != 0)

	phdr = [ src_call, dst_call, tstamp, out_seq, inp_seq, itype ]

	info  = nil
	stype = pkt[11,1].unpack("C")[0]
	info  = process_elements(pkt, 12) if [IAX_TYPE_IAX, IAX_TYPE_CONTROL].include?(itype)

	if dst_call != self.scall
		dprint("Incoming packet to inactive call: #{dst_call} vs #{self.scall}: #{phdr.inspect} #{stype.inspect} #{info.inspect}")
		return
	end

	# Increment the received sequence number
	self.iseq = (self.iseq + 1) & 0xff

	if self.state == :hangup
		dprint("Packet received after hangup, replying with invalid")
		self.client.send_invalid(self)
		return
	end

	# Technically these all require an ACK reply
	# NEW, HANGUP, REJECT, ACCEPT, PONG, AUTHREP, REGREL, REGACK, REGREJ, TXREL

	case itype
	when IAX_TYPE_DTMF_BEGIN
		self.dprint("DTMF BEG: #{pkt[11,1]}")
		self.dtmf << pkt[11,1]

	when IAX_TYPE_DTMF_END
		self.dprint("DTMF END: #{pkt[11,1]}")

	when IAX_TYPE_CONTROL
		case stype
		when IAX_CTRL_HANGUP
			dprint("HANGUP")
			self.client.send_ack(self)
			self.state = :hangup

		when IAX_CTRL_RINGING
			dprint("RINGING")
			self.client.send_ack(self)

		when IAX_CTRL_BUSY
			dprint("BUSY")
			self.busy  = true
			self.state = :hangup
			self.client.send_ack(self)

		when IAX_CTRL_ANSWER
			dprint("ANSWER")
			if self.state == :ringing
				self.state = :answered
				self.ring_finish = ::Time.now.to_i
			end
			self.client.send_ack(self)

		when IAX_CTRL_PROGRESS
			dprint("PROGRESS")

		when IAX_CTRL_PROCEED
			dprint("PROCEED")

		when 255
			dprint("STOP SOUNDS")
		end
		# Acknowledge all control packets
		# self.client.send_ack(self)

	when IAX_TYPE_IAX

		dprint( ["RECV", phdr, stype, info].inspect )
		case stype
		when IAX_SUBTYPE_HANGUP
			self.state = :hangup
			self.client.send_ack(self)
		when IAX_SUBTYPE_LAGRQ
			# Lagrps echo the timestamp
			self.client.send_lagrp(self, tstamp)
		when IAX_SUBTYPE_ACK
			# Nothing to do here
		when IAX_SUBTYPE_PING
			# Pongs echo the timestamp
			self.client.send_pong(self, tstamp)
		when IAX_SUBTYPE_PONG
			self.client.send_ack(self)
		else
			dprint( ["RECV-QUEUE", phdr, stype, info].inspect )
			self.queue.push( [phdr, stype, info ] )
		end

	when IAX_TYPE_VOICE
		v_codec = stype
		if self.state == :answered
			handle_audio(pkt)
		end
		self.client.send_ack(self)

	when nil
		dprint("Invalid control packet: #{pkt.unpack("H*")[0]}")
	end
end

#hangup ⇒ Object 



129
130
131
132
133
 
# File 'lib/rex/proto/iax2/call.rb', line 129

def hangup
	self.client.send_hangup(self)
	self.state = :hangup
	true
end

#process_elements(data, off = 0) ⇒ Object 



143
144
145
146
147
148
149
150
151
152
 
# File 'lib/rex/proto/iax2/call.rb', line 143

def process_elements(data,off=0)
	res = {}
	while( off < data.length )
		ie_type = data[off    ,1].unpack("C")[0]
		ie_len  = data[off + 1,2].unpack("C")[0]
		res[ie_type] = data[off + 2, ie_len]
		off += ie_len + 2
	end
	res
end

#register ⇒ Object

Register with the IAX endpoint



61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
 
# File 'lib/rex/proto/iax2/call.rb', line 61

def register
	self.client.send_regreq(self)
	res = wait_for( IAX_SUBTYPE_REGAUTH, IAX_SUBTYPE_REGREJ )
	return if not res

	if res[1] == IAX_SUBTYPE_REGREJ
		reason = res[2][IAX_IE_REGREJ_CAUSE] || "Unknown Reason"
		dprint("REGREJ: #{reason}")
		# Acknowledge the REGREJ
		self.client.send_ack(self)
		return
	end

	chall = nil
	if res[2][14] == "\x00\x03" and res[2][IAX_IE_CHALLENGE_DATA]
		self.dcall = res[0][0]
		chall = res[2][IAX_IE_CHALLENGE_DATA]
	end

	self.client.send_regreq_chall_response(self, chall)
	res = wait_for( IAX_SUBTYPE_REGACK, IAX_SUBTYPE_REGREJ )
	return if not res

	if res[1] == IAX_SUBTYPE_REGREJ
		reason = res[2][IAX_IE_REGREJ_CAUSE] || "Unknown Reason"
		dprint("REGREJ: #{reason}")
		return
	end

	if res[2][IAX_IE_APPARENT_ADDR]
		r_fam, r_port, r_addr = res[2][IAX_IE_APPARENT_ADDR].unpack('nnA4')
		r_addr = r_addr.unpack("C*").map{|x| x.to_s }.join(".")
		dprint("REGACK: Registered from address #{r_addr}:#{r_port}")
	end

	# Acknowledge the REGACK
	self.client.send_ack(self)

	self.state = :registered

	true
end

#ring_time ⇒ Object 



135
136
137
 
# File 'lib/rex/proto/iax2/call.rb', line 135

def ring_time
	(self.ring_finish || Time.now).to_i - self.ring_start.to_i
end

#timestamp ⇒ Object 



139
140
141
 
# File 'lib/rex/proto/iax2/call.rb', line 139

def timestamp
	(( ::Time.now - self.itime) * 1000.0 ).to_i & 0xffffffff
end

#wait_for(*stypes) ⇒ Object 



46
47
48
49
50
51
52
53
54
55
56
57
58
 
# File 'lib/rex/proto/iax2/call.rb', line 46

def wait_for(*stypes)
	begin
		::Timeout.timeout( IAX_DEFAULT_TIMEOUT ) do
			while (res = self.queue.pop )
				if stypes.include?(res[1])
					return res
				end
			end
		end
	rescue ::Timeout::Error
		return nil
	end
end