Class: OverSIP::SIP::InviteClientTransaction

Inherits:
ClientTransaction show all
Defined in:
lib/oversip/sip/client_transaction.rb

Instance Attribute Summary

Attributes inherited from ClientTransaction

#connection, #core, #request, #state

Instance Method Summary collapse

Methods inherited from ClientTransaction

get_class

Methods included from Logger

fg_system_msg2str, load_methods, #log_id

Constructor Details

#initialize(core, request, transaction_conf, transport, ip = nil, ip_type = nil, port = nil) ⇒ InviteClientTransaction

Returns a new instance of InviteClientTransaction.



78
79
80
81
82
83
84
 
# File 'lib/oversip/sip/client_transaction.rb', line 78

def initialize core, request, transaction_conf, transport, ip=nil, ip_type=nil, port=nil
  super
  @log_id = "ICT #{@transaction_id}"

  # Can be :calling, :proceeding, :completed, :accepted or :terminated.
  @state = :calling
end

Instance Method Details

#connection_failed ⇒ Object 



257
258
259
260
261
262
263
264
265
266
267
268
269
 
# File 'lib/oversip/sip/client_transaction.rb', line 257

def connection_failed
  # This avoid the case in which the TCP connection timeout raises after the transaction timeout.
  # Neither we react if the transaction has been canceled and the CANCEL cannot be sent due to
  # TCP disconnection.
  return unless @state == :calling or not @cancel

  @timer_A.cancel  if @timer_A
  @timer_B.cancel
  @timer_C.cancel
  terminate_transaction

  @core.connection_failed
end

#do_cancel(cancel = nil) ⇒ Object

It receives the received CANCEL request as parameter so it can check the existence of Reason header and act according (RFC 3326). This method is also called (without argument) when Timer C expires (INVITE).



312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
 
# File 'lib/oversip/sip/client_transaction.rb', line 312

def do_cancel cancel=nil
  return if @cancel

  @cancel = "CANCEL #{@request.ruri} SIP/2.0\r\n"
  @cancel << "Via: #{@top_via}\r\n"

  @request.hdr_route.each do |route|
    @cancel << "Route: " << route << CRLF
  end  if @request.hdr_route

  # RFC 3326. Copy Reason headers if present in the received CANCEL.
  cancel.header_all("Reason").each do |reason|
    @cancel << "Reason: " << reason << CRLF
  end  if cancel

  @cancel << "From: " << @request.hdr_from << CRLF
  @cancel << "To: " << @request.hdr_to << CRLF
  @cancel << "Call-ID: " << @request.call_id << CRLF
  @cancel << "CSeq: " << @request.cseq.to_s << " CANCEL\r\n"
  @cancel << "Content-Length: 0\r\n"
  @cancel << HDR_USER_AGENT << CRLF
  @cancel << CRLF

  # Just send the ACK inmediately if the branch has replied a 1XX response.
  send_cancel  if @state == :proceeding
end

#receive_response(response) ⇒ Object 



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
 
# File 'lib/oversip/sip/client_transaction.rb', line 184

def receive_response response
  # Set the request attribute to the response so we can access the related outgoing request.
  response.request = @request

  # Set server transaction variables to the response.
  response.tvars = @request.tvars

  # Provisional response
  if response.status_code < 200
    case @state
    when :calling
      @state = :proceeding
      @timer_A.cancel  if @timer_A
      @timer_B.cancel
      @core.receive_response(response) unless response.status_code == 100
      # RFC 3261 - 9.1 states that a CANCEL must be sent after receiving a 1XX response.
      send_cancel if @cancel
      return true
    when :proceeding
      @core.receive_response(response) unless response.status_code == 100
      return true
    else
      log_system_notice "received a provisional response #{response.status_code} while in #{@state} state"
      return false
    end

  # [3456]XX final response.
  elsif response.status_code >= 300
    case @state
    when :calling, :proceeding
      @state = :completed
      @timer_A.cancel  if @timer_A
      @timer_B.cancel
      @timer_C.cancel
      if @transport == :udp
        start_timer_D
      else
        terminate_transaction
      end
      send_ack(response)
      @core.receive_response(response)
      return true
    when :completed
      send_ack(response)
      return false
    when :accepted
      log_system_notice "received a [3456]XX response while in accepted state, ignoring it"
      return false
    end

  # 2XX final response.
  else
    case @state
    when :calling, :proceeding
      @state = :accepted
      @timer_A.cancel  if @timer_A
      @timer_B.cancel
      @timer_C.cancel
      start_timer_M
      @core.receive_response(response)
      return true
    when :accepted
      @core.receive_response(response)
      return true
    when :completed
      ### NOTE: It could be accepted and bypassed to the UAC, but makes no sense.
      log_system_notice "received 2XX response while in completed state, ignoring it"
      return false
    end

  end
end

#receive_response_to_cancel(response) ⇒ Object 



371
372
373
374
375
376
377
378
379
380
381
 
# File 'lib/oversip/sip/client_transaction.rb', line 371

def receive_response_to_cancel(response)
  unless @state == :terminated
    log_system_debug "our CANCEL got a #{response.status_code} response, transaction terminated"  if $oversip_debug

    @timer_E_cancel.cancel  if @timer_E_cancel
    @timer_F_cancel.cancel
    # We MUST ensure that we end the client transaction, so after sending a CANCEL and get a response
    # for it, ensure the transaction is terminated after a while.
    ::EM.add_timer(4) { terminate_transaction }
  end
end

#retransmit_cancel ⇒ Object 



367
368
369
 
# File 'lib/oversip/sip/client_transaction.rb', line 367

def retransmit_cancel
  @connection.send_sip_msg @cancel, @ip, @port
end

#retransmit_request ⇒ Object 



180
181
182
 
# File 'lib/oversip/sip/client_transaction.rb', line 180

def retransmit_request
  @connection.send_sip_msg @outgoing_request_str, @ip, @port
end

#send_ack(response) ⇒ Object 



282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
 
# File 'lib/oversip/sip/client_transaction.rb', line 282

def send_ack response
  unless @ack
    @ack = "ACK #{@request.ruri} SIP/2.0\r\n"
    @ack << "Via: #{@top_via}\r\n"

    @request.hdr_route.each do |route|
      @ack << "Route: " << route << CRLF
    end  if @request.hdr_route

    @ack << "From: " << @request.hdr_from << CRLF
    @ack << "To: " << @request.hdr_to
    unless @request.to_tag
      @ack << ";tag=#{response.to_tag}"  if response.to_tag
    end
    @ack << CRLF

    @ack << "Call-ID: " << @request.call_id << CRLF
    @ack << "CSeq: " << @request.cseq.to_s << " ACK\r\n"
    @ack << "Content-Length: 0\r\n"
    @ack << HDR_USER_AGENT << CRLF
    @ack << CRLF
  end

  log_system_debug "sending ACK for [3456]XX response"  if $oversip_debug
  @connection.send_sip_msg @ack, @ip, @port
end

#send_cancel ⇒ Object 



339
340
341
342
343
344
345
346
 
# File 'lib/oversip/sip/client_transaction.rb', line 339

def send_cancel
  log_system_debug "sending CANCEL"  if $oversip_debug

  @connection.send_sip_msg @cancel, @ip, @port

  start_timer_E_cancel  if @transport == :udp
  start_timer_F_cancel
end

#send_request ⇒ Object 



86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
 
# File 'lib/oversip/sip/client_transaction.rb', line 86

def send_request
  @client_transactions = @server_klass.invite_client_transactions
  # Store the new client transaction.
  @client_transactions[@transaction_id] = self

  @top_via = "#{@server_klass.via_core};branch=z9hG4bK#{@transaction_id};rport"
  @request.insert_header "Via", @top_via

  case @request.in_rr
  # Add a second Record-Route just in case there is transport change.
  when :rr
    unless @request.connection.is_a?(@server_klass)
      @out_rr = :rr
      @request.insert_header "Record-Route", @server_klass.record_route
    end
  # When there is outgoing Outbound always add a second Record-Route header.
  when :outgoing_outbound_rr
    @out_rr = :rr
    @request.insert_header "Record-Route", @server_klass.record_route
  # When there is incoming Outbound always add a second Record-Route header containing the flow token.
  when :incoming_outbound_rr
    @out_rr = :rr
    @request.insert_header "Record-Route", "<sip:" << @request.route_outbound_flow_token << @server_klass.outbound_record_route_fragment
  # When there is both incoming and outgoing Outbound always add a second Record-Route header containing the flow token.
  when :both_outbound_rr
    @out_rr = :rr
    @request.insert_header "Record-Route", "<sip:" << @request.route_outbound_flow_token << @server_klass.outbound_record_route_fragment
  end  if @request.in_rr

  @outgoing_request_str = @request.to_s

  @request.delete_header_top "Via"
  # TODO: I think this should be removed
  # https://github.com/versatica/OverSIP/issues/76
  if @out_rr == :rr
    @request.delete_header_top "Record-Route"
  end

  @connection.send_sip_msg @outgoing_request_str, @ip, @port

  start_timer_A  if @transport == :udp
  start_timer_B
  start_timer_C
end

#start_timer_A ⇒ Object 



131
132
133
134
135
136
137
138
 
# File 'lib/oversip/sip/client_transaction.rb', line 131

def start_timer_A
  @timer_A_interval = TIMER_A
  @timer_A = ::EM::PeriodicTimer.new(@timer_A_interval) do
    log_system_debug "timer A expires, retransmitting request"  if $oversip_debug
    retransmit_request
    @timer_A_interval = @timer_A.interval = 2*@timer_A_interval
  end
end

#start_timer_B ⇒ Object 



140
141
142
143
144
145
146
147
148
 
# File 'lib/oversip/sip/client_transaction.rb', line 140

def start_timer_B
  @timer_B = ::EM::Timer.new(@transaction_conf[:timer_B] || TIMER_B) do
    log_system_debug "timer B expires, transaction timeout"  if $oversip_debug
    @timer_A.cancel  if @timer_A
    @timer_C.cancel
    terminate_transaction
    @core.client_timeout
  end
end

#start_timer_C ⇒ Object 



150
151
152
153
154
155
156
157
158
 
# File 'lib/oversip/sip/client_transaction.rb', line 150

def start_timer_C
  @timer_C = ::EM::Timer.new(@transaction_conf[:timer_C] || TIMER_C) do
    log_system_debug "timer C expires, transaction timeout"  if $oversip_debug
    @timer_A.cancel  if @timer_A
    @timer_B.cancel
    do_cancel
    @core.invite_timeout
  end
end

#start_timer_D ⇒ Object 



160
161
162
163
164
165
 
# File 'lib/oversip/sip/client_transaction.rb', line 160

def start_timer_D
  ::EM.add_timer(TIMER_D_UDP) do
    log_system_debug "timer D expires, transaction terminated"  if $oversip_debug
    terminate_transaction
  end
end

#start_timer_E_cancel ⇒ Object 



348
349
350
351
352
353
354
355
 
# File 'lib/oversip/sip/client_transaction.rb', line 348

def start_timer_E_cancel
  @timer_E_cancel_interval = TIMER_E
  @timer_E_cancel = ::EM::PeriodicTimer.new(@timer_E_cancel_interval) do
    log_system_debug "timer E expires, retransmitting CANCEL"  if $oversip_debug
    retransmit_cancel
    @timer_E_cancel_interval = @timer_E_cancel.interval = [2*@timer_E_cancel_interval, T2].min
  end
end

#start_timer_F_cancel ⇒ Object 



357
358
359
360
361
362
363
364
365
 
# File 'lib/oversip/sip/client_transaction.rb', line 357

def start_timer_F_cancel
  @timer_F_cancel = ::EM::Timer.new(@transaction_conf[:timer_F] || TIMER_F) do
    unless @state == :terminated
      log_system_debug "timer F expires, CANCEL timeout, transaction terminated"  if $oversip_debug
      @timer_E_cancel.cancel  if @timer_E_cancel
      terminate_transaction
    end
  end
end

#start_timer_M ⇒ Object 



167
168
169
170
171
172
 
# File 'lib/oversip/sip/client_transaction.rb', line 167

def start_timer_M
  ::EM.add_timer(TIMER_M) do
    log_system_debug "timer M expires, transaction terminated"  if $oversip_debug
    terminate_transaction
  end
end

#terminate_transaction ⇒ Object

Terminate current transaction and delete from the list of transactions.



175
176
177
178
 
# File 'lib/oversip/sip/client_transaction.rb', line 175

def terminate_transaction
  @state = :terminated
  @client_transactions.delete(@transaction_id)
end

#tls_validation_failed ⇒ Object 



271
272
273
274
275
276
277
278
279
280
 
# File 'lib/oversip/sip/client_transaction.rb', line 271

def tls_validation_failed
  return unless @state == :calling or not @cancel

  @timer_A.cancel  if @timer_A
  @timer_B.cancel
  @timer_C.cancel
  terminate_transaction

  @core.tls_validation_failed
end