Newer
Older
f_setHeadersOnReceiptOfBYE(v_BYE_Request);
f_send200OK();
}
}
} // end f_awaitingBYE_sendReply
/**
*
* @desc function awaiting BYE and sending 200OK response
* @param p_BYE expected BYE
*/
function f_awaitingBYE_sendReply_PassOnTimeout(in template BYE_Request p_BYE) runs on SipComponent
{
var BYE_Request v_BYE_Request;
tc_wait.start(PX_SIP_TWAIT);
alt
{
[]SIPP.receive (p_BYE) -> value v_BYE_Request sender vc_sent_label
{
vc_ignore_bye:= true;
vc_boo_request := true;
f_setHeadersOnReceiptOfBYE(v_BYE_Request);
f_send200OK();
}
{
vc_boo_request := false;
}
} // end f_awaitingBYE_sendReply_PassOnTimeout
/**
*
* @desc function awaiting CANCEL
* @param p_CANCEL expected CANCEL
*/
function f_awaitingCANCEL(in template CANCEL_Request p_CANCEL) runs on SipComponent
{
var CANCEL_Request v_MSG;
tc_wait.start(PX_SIP_TWAIT);
alt
{
[]SIPP.receive (p_CANCEL) -> value v_MSG sender vc_sent_label
{
f_setHeadersOnReceiptOfRequest(v_MSG);
}
}
} // end f_awaitingCANCEL
/**
* @desc await MESSAGE request
*/
function f_awaitingMESSAGE(in template MESSAGE_Request p_MSG) runs on SipComponent
{
var MESSAGE_Request v_MSG;
tc_wait.start(PX_SIP_TWAIT);
alt
{
[] SIPP.receive(p_MSG)-> value v_MSG sender vc_sent_label
{
f_setHeadersOnReceiptOfRequest(v_MSG);
}
[] SIPP.receive(mw_MESSAGE_Request_Base)-> value v_MSG sender vc_sent_label
{
f_setHeadersOnReceiptOfRequest(v_MSG);
log("Received MESSAGE not as expected!");
setverdict (fail);
}
}
} // end of f_awaitingMESSAGE
/**
* @desc await MESSAGE request
* reply with 200 OK
*/
function f_awaitingMESSAGE_sendReply() runs on SipComponent
{
var MESSAGE_Request v_MSG;
tc_wait.start(PX_SIP_TWAIT);
[] SIPP.receive(mw_MESSAGE_Request_Base)-> value v_MSG sender vc_sent_label
f_setHeadersOnReceiptOfRequest(v_MSG);
//Answer to the MESSAGE
f_send200OK();
}
}
} // end of f_awaitingMESSAGE_sendReply
/**
* @desc await MESSAGE request
*/
function f_awaitingMESSAGE_sendReply_PassOnTimeout(in template MESSAGE_Request p_MSG) runs on SipComponent
{
var MESSAGE_Request v_MSG;
tc_wait.start(PX_SIP_TWAIT);
alt
{
[] SIPP.receive(p_MSG)-> value v_MSG sender vc_sent_label
{
f_setHeadersOnReceiptOfRequest(v_MSG);
//Answer to the MESSAGE
//f_send200OK();
vc_boo_request := true;
f_send200OK();
//setverdict (pass);
}
{
vc_boo_request := false;
//setverdict (pass);
}
}
} // end of f_awaitingMESSAGE_PassOnTimeout
/**
* @desc await NOTIFY request
*/
function f_awaitingNOTIFY(in template NOTIFY_Request p_MSG) runs on SipComponent
{
var NOTIFY_Request v_MSG;
tc_wait.start(PX_SIP_TWAIT);
alt
{
[] SIPP.receive(p_MSG)-> value v_MSG sender vc_sent_label
{
tc_wait.stop;
f_getRouteMapIntoRecordRoute(vc_cSeq, v_MSG);
f_setHeadersOnReceiptOfRequest(v_MSG);
}
}
} // end of f_awaitingNOTIFY
/**
* @desc await NOTIFY request
* reply with 200 OK
*/
function f_awaitingNOTIFY_sendReply(in template NOTIFY_Request p_MSG) runs on SipComponent
{
var NOTIFY_Request v_MSG;
tc_wait.start(PX_SIP_TWAIT);
alt
{
[] SIPP.receive(p_MSG)-> value v_MSG sender vc_sent_label
{
f_getRouteMapIntoRecordRoute(vc_cSeq, v_MSG);
f_setHeadersOnReceiptOfRequest(v_MSG);
//Answer to the NOTIFY
f_send200OK();
}
}
} // end of f_awaitingNOTIFY_sendReply
/**
* @desc await PRACK request
* reply with 200 OK
*/
function f_awaitingPRACK_sendReply(in template PRACK_Request p_MSG) runs on SipComponent
{
var PRACK_Request v_MSG;
tc_wait.start(PX_SIP_TWAIT);
[] SIPP.receive(p_MSG)-> value v_MSG sender vc_sent_label
f_setHeadersOnReceiptOfRequest(v_MSG);
//Answer to the PRACK
f_send200OK();
}
}
} // end of f_awaitingPRACK_sendReply
/**
* @desc await PUBLISH request
* reply with 200 OK
*/
function f_awaitingPUBLISH_sendReply(in template PUBLISH_Request p_MSG) runs on SipComponent
{
var PUBLISH_Request v_MSG;
tc_wait.start(PX_SIP_TWAIT);
alt
{
[] SIPP.receive(p_MSG)-> value v_MSG sender vc_sent_label
{
f_setHeadersOnReceiptOfRequest(v_MSG);
//Answer to the PUBLISH
f_send200OK();
}
}
} // end of f_awaitingPUBLISH_sendReply
/**
* @desc await UPDATE request
*/
function f_awaitingUPDATE(in template UPDATE_Request p_MSG) runs on SipComponent
{
var UPDATE_Request v_MSG;
tc_wait.start(PX_SIP_TWAIT);
[] SIPP.receive(p_MSG)-> value v_MSG sender vc_sent_label
f_setHeadersOnReceiptOfRequest(v_MSG);
}
}
} // end of f_awaitingUPDATE
/**
* @desc await UPDATE request
* reply with 200 OK
*/
function f_awaitingUPDATE_sendReply(in template UPDATE_Request p_MSG) runs on SipComponent
{
var UPDATE_Request v_MSG;
tc_wait.start(PX_SIP_TWAIT);
alt
{
[] SIPP.receive(p_MSG)-> value v_MSG sender vc_sent_label
f_setHeadersOnReceiptOfRequest(v_MSG);
//Answer to the UPDATE
f_send200OK();
}
}
} // end of f_awaitingUPDATE_sendReply
/**
* @desc await REFER request
*/
function f_awaitingREFER(in template REFER_Request p_MSG) runs on SipComponent
{
var REFER_Request v_MSG;
tc_wait.start(PX_SIP_TWAIT);
alt
{
[] SIPP.receive(p_MSG)-> value v_MSG sender vc_sent_label
f_setHeadersOnReceiptOfREFER(v_MSG);
}
} // end of f_awaitingUPDATE
} // end AwaitingMessage
group SendMessage {
/**
*
* @desc send ACK message, update the route and recordRoute header fields depending on boolean flags
* @param p_request template of the message to be sent
*/
function f_SendACK(template ACK_Request p_request) runs on SipComponent
{
//p_request.msgHeader.route := f_route(); // update the route header field depending on vc_boo_route
3284
3285
3286
3287
3288
3289
3290
3291
3292
3293
3294
3295
3296
3297
3298
3299
3300
3301
3302
3303
3304
3305
3306
// n/a p_request.msgHeader.recordRoute := f_recordroute(); // update the route header field depending on vc_boo_route
SIPP.send(p_request) to vc_sent_label;
}
/**
*
* @desc send BYE message, update the route and recordRoute header fields depending on boolean flags
* @param p_request template of the message to be sent
*/
function f_SendBYE(template BYE_Request p_request) runs on SipComponent
{
SIPP.send(p_request) to vc_sent_label;
}
/**
*
* @desc send CANCEL message
* @param p_request template of the message to be sent
*/
function f_SendCANCEL(template CANCEL_Request p_request) runs on SipComponent
{
SIPP.send(p_request) to vc_sent_label;
}
/**
*
* @desc send INFO message
* @param p_request template of the message to be sent
*/
function f_SendINFO(template INFO_Request p_request) runs on SipComponent
{
f_setHeadersGeneral(vc_cSeq, "INFO"); // cseq, contact, branch, via
SIPP.send(p_request) to vc_sent_label;
}
/**
*
* @desc send INVITE message
* @param p_request template of the message to be sent
*/
function f_SendINVITE(template INVITE_Request p_request) runs on SipComponent
{
vc_requestFor407 := valueof(p_request);
SIPP.send(p_request) to vc_sent_label;
vc_request := valueof(p_request);
if(PX_SIP_INVITE_AUTHENTICATION_ENABLED) {a_altstep_401or407();};
}
/**
*
* @desc send PRACK message
* @param p_request template of the message to be sent
*/
vc_rAck := valueof(m_RAck(vc_response.msgHeader.rSeq.responseNum, vc_cSeq.seqNumber, vc_cSeq.method));
f_setHeadersGeneral(vc_cSeq, "PRACK"); // cseq, contact, branch, via
SIPP.send(m_PRACK_Request_Base(
vc_requestUri,
vc_callId,
vc_cSeq,
vc_from,
vc_to,
vc_via,
vc_rAck
)) to vc_sent_label;
3351
3352
3353
3354
3355
3356
3357
3358
3359
3360
3361
3362
3363
3364
3365
3366
3367
3368
3369
3370
3371
3372
3373
3374
3375
3376
3377
3378
3379
3380
3381
3382
3383
3384
3385
3386
3387
3388
3389
3390
}
/**
*
* @desc send PUBLISH message
* @param p_request template of the message to be sent
*/
function f_SendPUBLISH(template PUBLISH_Request p_request) runs on SipComponent
{
SIPP.send(p_request) to vc_sent_label;
}
/**
*
* @desc send REGISTER message
* @param p_request template of the message to be sent
*/
function f_SendREGISTER(template REGISTER_Request p_request) runs on SipComponent
{
SIPP.send(p_request) to vc_sent_label;
}
/**
*
* @desc send SUBSCRIBE message
* @param p_request template of the message to be sent
*/
function f_SendSUBSCRIBE(template SUBSCRIBE_Request p_request) runs on SipComponent
{
SIPP.send(p_request) to vc_sent_label;
}
/**
*
* @desc send UPDATE message
* @param p_request template of the message to be sent
*/
function f_SendUPDATE(template UPDATE_Request p_request) runs on SipComponent
{
f_setHeadersGeneral(vc_cSeq, "UPDATE"); // cseq, contact, branch, via
p_request.msgHeader.cSeq := vc_cSeq;
p_request.msgHeader.contact := vc_contact;
p_request.msgHeader.via := vc_via;
SIPP.send(p_request) to vc_sent_label;
if(PX_SIP_INVITE_AUTHENTICATION_ENABLED) {a_altstep_401or407();};
*
* @desc function send MESSAGE message
* @param p_request template of the message to be sent
*/
function f_SendMESSAGE(template MESSAGE_Request p_request) runs on SipComponent
{
SIPP.send(p_request) to vc_sent_label;
}
/**
*
* @desc function send NOTIFY message
* @param p_request template of the notify to be sent
*/
function f_SendNOTIFY(template NOTIFY_Request p_request) runs on SipComponent
{
SIPP.send(p_request) to vc_sent_label;
}
/**
*
* @desc send REFER message
* @param p_request template of the message to be sent
*/
function f_SendREFER(template REFER_Request p_request) runs on SipComponent
{
SIPP.send(p_request) to vc_sent_label;
}
/**
*
* @desc send 200 OK
*/
function f_send200OK() runs on SipComponent
{
f_sendResponse(m_Response_Base(c_statusLine200, vc_callId, vc_cSeq, vc_caller_From, vc_caller_To, vc_via));
}
/**
*
* @desc send response
* @param p_request template of the message to be sent
*/
function f_sendResponse(template Response p_response) runs on SipComponent
{
//p_response.msgHeader.route := f_route(); // update the route header field depending on vc_boo_route//TODO check if route header is needed in responses
p_response.msgHeader.recordRoute := f_recordroute(); // update the route header field depending on vc_boo_route
SIPP.send(p_response) to vc_sent_label;
}
} // end SendMessage
group GlobalSteps {
/**
* @desc component initialization
* @param p_cSeq_s cSeq value to be assigned to the component variable
*/
function f_init_component(inout CSeq p_cSeq_s) runs on SipComponent
{
//Variables
vc_cSeq := p_cSeq_s;
//Defaults
vc_def_catchSyncStop := activate(a_Sip_catchSyncStop());
vc_default := activate (a_clearRegistration());
}
/**
* @desc component termination
*/
function f_terminate_component() runs on SipComponent
{
log("component terminated - forced!");
deactivate;
stop;
}
/**
*
* @desc component termination
*/
function f_componentStop() runs on SipComponent
{
syncPort.send(m_syncClientStop);
SIPP.clear;
stop;
}
3490
3491
3492
3493
3494
3495
3496
3497
3498
3499
3500
3501
3502
3503
3504
3505
3506
3507
3508
3509
3510
3511
3512
3513
3514
3515
3516
3517
3518
3519
3520
3521
3522
3523
3524
3525
3526
3527
3528
3529
3530
/**
*
* @desc setting of user parameters with PIXIT values
* @param p_user identifies the selected user configuration and location
*/
function f_init_userprofile(in integer p_user) runs on SipComponent
{
vc_userprofile.id := p_user;
select(p_user){
case (c_userProfile_SIP1_home) { //variant c_userProfile_SIP1_home
vc_userprofile.currPort := PX_SIP_TS1_PORT;
vc_userprofile.currIpaddr := PX_SIP_TS1_IPADDR;
vc_userprofile.contactPort := PX_SIP_TS1_PORT;
vc_userprofile.contactIpaddr := PX_SIP_TS1_IPADDR;
vc_userprofile.bearerIpaddr := PX_SIP_TS1_BEARER_IPADDR;
vc_userprofile.homeDomain := PX_SIP_TS1_LOCAL_DOMAIN;
vc_userprofile.publUsername := PX_SIP_TS1_LOCAL_USER;
vc_userprofile.qop := PX_SIP_SUT_UE1_QOP;
vc_userprofile.privUsername := PX_SIP_SUT_UE1_USERNAME;
vc_userprofile.passwd := PX_SIP_SUT_UE1_PASSWD;
vc_userprofile.registrarDomain := PX_SIP_SUT_REGISTRAR_DOMAIN;
}
case (c_userProfile_SIP2_home) { //variant c_userProfile_SIP2_home
vc_userprofile.currPort := PX_SIP_TS2_PORT;
vc_userprofile.currIpaddr := PX_SIP_TS2_IPADDR;
vc_userprofile.contactPort := PX_SIP_TS2_PORT;
vc_userprofile.contactIpaddr := PX_SIP_TS2_IPADDR;
vc_userprofile.bearerIpaddr := PX_SIP_TS2_BEARER_IPADDR;
vc_userprofile.homeDomain := PX_SIP_TS2_LOCAL_DOMAIN;
vc_userprofile.publUsername := PX_SIP_TS2_LOCAL_USER;
vc_userprofile.qop := PX_SIP_SUT_UE2_QOP;
vc_userprofile.privUsername := PX_SIP_SUT_UE2_USERNAME;
vc_userprofile.passwd := PX_SIP_SUT_UE2_PASSWD;
vc_userprofile.registrarDomain := PX_SIP_SUT_REGISTRAR_DOMAIN;
}
}
}
/**
3532
3533
3534
3535
3536
3537
3538
3539
3540
3541
3542
3543
3544
3545
3546
3547
3548
3549
3550
3551
3552
3553
3554
3555
* @desc function waits for particular time that allows the SUT to return to idle state
*/
function f_awaitSUTidle() runs on SipComponent
{
vc_ignore4xx := true; // allow 4xx in default
tc_noAct.start;
alt {
[] tc_noAct.timeout{}
}
}
/**
*
* @desc function waits for particular time before next expected message
*/
function f_wait(float p_time) runs on SipComponent
{
tc_noAct.start(p_time);
alt {
[] tc_noAct.timeout{}
}
}
/**
*
* @desc function cause termination of a PTC
* @param p_syncPoint dummy parameter (copied from the common lib)
*/
function f_check2Null(in charstring p_syncPoint) runs on SipComponent
{
//!= pass does not work, because in case of "none" execution shall continue
if (getverdict == inconc or getverdict == fail){
log("**** f_check2Null: Verdict evaluated to fail or inconc. Stopping test execution now ");
f_selfOrClientSyncAndVerdict (p_syncPoint, e_error) ;
}//end if
}
rennoch
committed
/*
rennoch
committed
* @desc original copied from older LibCommon_VerdictControl
*/
function f_getVerdict()
return FncRetCode {
var FncRetCode v_ret := e_error;
if (getverdict == pass or getverdict == none) {
v_ret := e_success;
}
return v_ret;
}
}// end group GlobalSteps
group Registration {
/**
*
* @desc registration and authentication with MD5
* @param p_cSeq_s cseq parameter
* @param p_register register template
* @param p_auth flag indicating if authentication is needed
*/
function f_Registration(inout CSeq p_cSeq_s, out template REGISTER_Request p_register, in boolean p_auth) runs on SipComponent
{
if (PX_SIP_REGISTRATION)
{
f_setHeaders_REGISTER(p_cSeq_s); //TODO need if p_register not set
p_register := m_REGISTER_Request_Base(vc_requestUri, vc_callId, p_cSeq_s, vc_from, vc_to, vc_via_REG, vc_contact, vc_authorization);
f_SendREGISTER(p_register); //LibSip
//awaiting of 401 and sending 2nd REGISTER and awaiting 200 OK REGISTER
if (p_auth)
{
// receiving 401 Unauthorized response.
// and Re-send REGISTER request with Authorization header
tc_resp.start(PX_SIP_TRESP);
alt
{
[] SIPP.receive (mw_Response_Base(c_statusLine401, vc_callId, p_cSeq_s)) -> value vc_response
{
f_setHeadersOnReceiptOfResponse(p_cSeq_s, vc_response);
// set headers via, cseq and authorization
f_setHeaders_2ndREGISTER(p_cSeq_s);
p_register := m_REGISTER_Request_Base(vc_requestUri, vc_callId, p_cSeq_s, vc_from, vc_to, vc_via_REG, vc_contact, vc_authorization);
// Re-send protected REGISTER
f_SendREGISTER(p_register);//LibSip
// awaiting 200 OK REGISTER
f_awaitingOkResponse(p_cSeq_s);
f_getServiceRouteMapIntoRouteInRegistration(p_cSeq_s, vc_response);
}
[] SIPP.receive (mw_Response_Base(c_statusLine200, vc_callId, p_cSeq_s)) -> value vc_response
f_setHeadersOnReceiptOfResponse(vc_cSeq, vc_response);
f_getServiceRouteMapIntoRouteInRegistration(p_cSeq_s, vc_response);
log ("Authorization was not requested as expected");
}
}
}
else
{
f_awaitingOkResponse(p_cSeq_s);
f_getServiceRouteMapIntoRouteInRegistration(p_cSeq_s, vc_response);
}
};
}//end function f_Registration
3640
3641
3642
3643
3644
3645
3646
3647
3648
3649
3650
3651
3652
3653
3654
3655
3656
3657
3658
3659
3660
3661
3662
3663
3664
3665
3666
3667
3668
3669
3670
3671
3672
3673
3674
3675
3676
3677
3678
3679
3680
3681
3682
3683
3684
3685
3686
3687
3688
3689
3690
3691
3692
3693
3694
3695
3696
3697
3698
/**
*
* @desc registration and authentication with MD5
* @param p_cSeq_s cseq parameter
* @param p_register register template
* @param p_auth flag indicating if authentication is needed
*/
function f_Registration_withTemplate(inout CSeq p_cSeq_s, inout template REGISTER_Request p_register, in boolean p_auth) runs on SipComponent
{
if (PX_SIP_REGISTRATION)
{
//f_setHeaders_REGISTER(p_cSeq_s); TODO need if p_register not set
//p_register := m_REGISTER_Request_Base(vc_requestUri, vc_callId, p_cSeq_s, vc_from, vc_to, vc_via_REG, vc_contact, vc_authorization);
f_SendREGISTER(p_register); //LibSip
//awaiting of 401 and sending 2nd REGISTER and awaiting 200 OK REGISTER
if (p_auth)
{
// receiving 401 Unauthorized response.
// and Re-send REGISTER request with Authorization header
tc_resp.start(PX_SIP_TRESP);
alt
{
[] SIPP.receive (mw_Response_Base(c_statusLine401, vc_callId, p_cSeq_s)) -> value vc_response
{
tc_resp.stop;
f_setHeadersOnReceiptOfResponse(p_cSeq_s, vc_response);
// set headers via, cseq and authorization
f_setHeaders_2ndREGISTER(p_cSeq_s);
//p_register := m_REGISTER_Request_Base(vc_requestUri, vc_callId, p_cSeq_s, vc_from, vc_to, vc_via_REG, vc_contact, vc_authorization);
// Re-send protected REGISTER
p_register.requestLine.requestUri := vc_requestUri;
p_register.msgHeader.cSeq := vc_cSeq;
p_register.msgHeader.via := vc_via_REG;
p_register.msgHeader.authorization := vc_authorization;
f_SendREGISTER(p_register);//LibSip
// awaiting 200 OK REGISTER
f_awaitingOkResponse(p_cSeq_s);
f_getServiceRouteMapIntoRouteInRegistration(p_cSeq_s, vc_response);
}
[] SIPP.receive (mw_Response_Base(c_statusLine200, vc_callId, p_cSeq_s)) -> value vc_response
{
tc_resp.stop;
f_setHeadersOnReceiptOfResponse(vc_cSeq, vc_response);
f_getServiceRouteMapIntoRouteInRegistration(p_cSeq_s, vc_response);
log ("Authorization was not requested as expected");
}
}
}
else
{
f_awaitingOkResponse(p_cSeq_s);
f_getServiceRouteMapIntoRouteInRegistration(p_cSeq_s, vc_response);
}
};
}//end function f_Registration_withTemplate
/**
*
* @desc remove registration
* @param p_cSeq_s cseq parameter
*/
function f_RemoveRegistration(inout CSeq p_cSeq) runs on SipComponent
{
var CommaParam_List v_challenge;
var Credentials v_credentials;
//
if(vc_DeregDone)
{
f_componentStop();
}
else {vc_DeregDone := true;}
if (PX_SIP_REGISTRATION)
{
f_setHeaders_deREGISTER(p_cSeq);
v_request := m_REGISTER_Request_expires(vc_requestUri, vc_callIdReg,
p_cSeq, vc_from, vc_to, vc_via, vc_contact, vc_authorization, "0");
//v_request.msgHeader.route := f_route();
f_SendREGISTER(v_request);
if (PX_SIP_REGISTER_AUTHENTICATION_ENABLED)
{
// receiving 401 Unauthorized response.
// and Re-send REGISTER request with Authorization header
tc_resp.start(PX_SIP_TRESP);
[] SIPP.receive (mw_Response_Base(c_statusLine401, vc_callIdReg, p_cSeq)) -> value vc_response
// set headers via, cseq and authorization
f_setHeaders_2ndREGISTER(p_cSeq);
v_request := m_REGISTER_Request_expires(vc_requestUri, vc_callIdReg,
p_cSeq, vc_from, vc_to, vc_via, vc_contact, vc_authorization, "0");
//v_request.msgHeader.route := f_route();
// Re-send protected REGISTER
f_SendREGISTER(v_request);//LibSip
// awaiting 200 OK REGISTER
f_awaitingResponse(mw_Response_Base(c_statusLine200, vc_callIdReg, p_cSeq));
[] SIPP.receive (mw_Response_Base(c_statusLine200, vc_callIdReg, p_cSeq))-> value vc_response
f_setHeadersOnReceiptOfResponse(vc_cSeq, vc_response);
//log ("Authorization was not requested as expected");
}
}
}
else
{
f_awaitingResponse(mw_Response_Base(c_statusLine200, vc_callIdReg, p_cSeq));
}
}
} // end f_RemoveRegistration
/**
*
* @desc remove registration without authorization
* @param p_cSeq_s cseq parameter
*/
function f_RemoveRegistration_wo_authorization(inout CSeq p_cSeq) runs on SipComponent
{
var SemicolonParam_List tmp_params;
if (PX_SIP_REGISTRATION)
{
f_setHeaders_deREGISTER(p_cSeq);
f_SendREGISTER(m_REGISTER_Request_expires(vc_requestUri, vc_callIdReg, p_cSeq,
vc_from, vc_to, vc_via, vc_contact, vc_authorization, "0" ));
f_awaitingResponse(mw_Response_Base(c_statusLine200, vc_callIdReg, p_cSeq));
}
} // end f_RemoveRegistration_wo_authorization
}//end group Registration
group Subscription {
/**
*
* @desc UE send subscrbe, await on 200 OK, await notify and send 200 OK
* @param p_cSeq_s cseq parameter
function f_Subscription(inout CSeq p_cSeq_s,template SUBSCRIBE_Request p_subscribe) runs on SipComponent
//f_setHeaders_SUBSCRIBE(p_cSeq_s);
//send SUBSCRIBE
f_SendSUBSCRIBE(p_subscribe);
// awaiting 200 OK SUBSCRIBE
f_awaitingOkResponse(p_cSeq_s);
//await NOTIFY and send reply 200 OK
f_awaitingNOTIFY_sendReply(mw_NOTIFY_Request_Base(vc_callId));
}//end function f_Subscription
/**
*
* @desc UE send subscrbe, await on 200 OK, await notify and send 200 OK
* @param p_cSeq_s cseq parameter
* @param p_subscribe subscribe template
* @param p_notify notify template
*/
function f_SubscriptionWithNotification(inout CSeq p_cSeq_s, template SUBSCRIBE_Request p_subscribe, template NOTIFY_Request p_notify) runs on SipComponent
{
f_setHeaders_SUBSCRIBE(p_cSeq_s);
//send SUBSCRIBE
f_SendSUBSCRIBE(p_subscribe);
// awaiting 200 OK SUBSCRIBE
f_awaitingOkResponse(p_cSeq_s);
//await NOTIFY and send reply 200 OK
f_awaitingNOTIFY_sendReply(p_notify);
}//end function f_Subscription
3823
3824
3825
3826
3827
3828
3829
3830
3831
3832
3833
3834
3835
3836
3837
3838
3839
3840
3841
3842
3843
3844
3845
3846
3847
3848
3849
3850
3851
3852
3853
3854
3855
3856
3857
3858
/**
*
* @desc UE await subscrbe, send on 200 OK; possibility to handle also other SUBSCRIBE methods where event is different than reg
* @param p_cSeq_s cseq parameter
* @param p_subscribe subscribe template
*/
function f_awaitingSubscription(inout CSeq p_cSeq_s, template SUBSCRIBE_Request p_subscribe) runs on SipComponent
{
var Request v_request;
tc_wait.start(2.0);//awaiting of all SUBSCRIBES
alt
{
[] SIPP.receive(p_subscribe)-> value v_request sender vc_sent_label
{
f_setHeadersOnReceiptOfSUBSCRIBE(v_request);
f_send200OK();
repeat;
}
[] SIPP.receive(mw_SUBSCRIBE_Request_Base)-> value v_request sender vc_sent_label
{
f_setHeadersOnReceiptOfSUBSCRIBE(v_request);
f_send200OK();
repeat;
}
[] tc_wait.timeout
{
setverdict(pass);
}
}
// TODO check how to solve sending of NOTIFY on SUBSCRIBE
}//end function f_awaitingSubscription
3859
3860
3861
3862
3863
3864
3865
3866
3867
3868
3869
3870
3871
3872
3873
3874
3875
3876
3877
3878
3879
3880
3881
3882
3883
3884
3885
3886
3887
3888
3889
3890
3891
3892
3893
3894
3895
3896
3897
3898
3899
}//end group Subscription
group Preambles {
/**
*
* @desc Set variables and default initialization for user profile
* @param p_userprofile user profile of call
* @param p_cSeq_s cseq parameter
*/
function f_SIP_preamble_woREG(in integer p_userprofile, inout CSeq p_cSeq_s) runs on SipComponent
{
//varables and altsteps
f_init_component(p_cSeq_s);
//Preamble
f_init_userprofile(p_userprofile); // assignment of PIXIT values to component variable
vc_sdp_local := valueof(m_SDP_bandwidth(valueof(m_media_dynPT(PX_SIP_SDP_dyn, PX_SIP_SDP_encoding)), vc_userprofile));
}
/**
*
* @desc Set variables and default initialization for user profile and handle registration and authentication with MD5
* @param p_userprofile user profile of call
* @param p_cSeq_s cseq parameter
* @param p_register register template
*/
function f_SIP_preamble_withREG(in integer p_userprofile, inout CSeq p_cSeq_s, template REGISTER_Request p_register) runs on SipComponent
{
//preamble
f_SIP_preamble_woREG(p_userprofile, p_cSeq_s);
//Registration, Awaiting
f_Registration(p_cSeq_s, p_register, PX_SIP_REGISTER_AUTHENTICATION_ENABLED);
}
}// end group Preambles
group Postambles {
/**
*
* @desc function send BYE and awaits reponse
* @param p_CallId parameter for outgoing BYE
* @param p_cSeq parameter for outgoing BYE
* @param p_from parameter for outgoing BYE
* @param p_to parameter for outgoing BYE
3906
3907
3908
3909
3910
3911
3912
3913
3914
3915
3916
3917
3918
3919
3920
3921
3922
3923
3924
3925
3926
3927
3928
3929
3930
3931
3932
3933
3934
* @param p_reqHostPort parameter for outgoing BYE
*/
function f_terminateCall(SipUrl p_requestUri, CallId p_CallId, inout CSeq p_cSeq, From p_from,
template To p_to) runs on SipComponent
{
// Sending of a BYE request to release the call and expect a final response
f_SendBYE(m_BYE_Request_cause(p_requestUri, p_CallId, p_cSeq, p_from, valueof(p_to), vc_via, PX_SIP_BYE_CAUSE));
tc_resp.start(PX_SIP_TRESP);
alt
{
[] SIPP.receive (mw_Response_Base(mw_statusLine1xx, p_CallId, p_cSeq))
{
repeat;
}
[] SIPP.receive (mw_Response_Base(mw_statusLineFinal, p_CallId, p_cSeq))
{
tc_resp.stop;
}
}
} // end function f_terminateCall
function f_cancelCall(template CANCEL_Request p_request)
runs on SipComponent
{
// This function is called to bring back the IUT in idle condition
// in case of errors or unexpected behaviour.
// Sending of a CANCEL request with the same Cseq
f_setHeadersCANCEL(vc_cSeq);
f_SendCANCEL(p_request);
tc_resp.start(PX_SIP_TRESP);
alt
{
[] SIPP.receive (mw_Response_Base(c_statusLine200, vc_callId, vc_cSeq))
{
tc_resp.stop;
}
}
}
3947
3948
3949
3950
3951
3952
3953
3954
3955
3956
3957
3958
3959
3960
3961
3962
3963
3964
3965
3966
3967
3968
3969
3970
3971
3972
3973
3974
3975
3976
3977
function f_cancelCall_await487(template CANCEL_Request p_request)
runs on SipComponent
{
// This function is called to bring back the IUT in idle condition
// in case of errors or unexpected behaviour.
// Sending of a CANCEL request with the same Cseq
f_cancelCall(p_request);
// set method on INVITE
vc_cSeq.method := "INVITE";
//await on 487 response and send ACK
f_awaitingResponse(mw_Response_Base(c_statusLine487, vc_callId, vc_cSeq));
f_SendACK(m_ACK_Request_Base(vc_requestUri, vc_callId, vc_cSeq, vc_from, vc_to, vc_via));
}
function f_awaitCancelCall_send487(template CANCEL_Request p_request)
runs on SipComponent
{
f_awaitingCANCEL(p_request);
f_sendResponse(m_Response_Base(c_statusLine200, vc_callId, vc_cSeq,vc_caller_From, vc_caller_To, vc_via));
// set method on INVITE
vc_cSeq.method := "INVITE";
//send 487 response and await ACK
f_sendResponse(m_Response_Base(c_statusLine487, vc_callId, vc_cSeq,vc_caller_From, vc_caller_To, vc_via));
// await ACK
f_awaitingACK(mw_ACK_Request_Base(vc_callId));
}
3978
3979
3980
3981
3982
3983
3984
3985
3986
3987
3988
3989
3990
3991
3992
3993
3994
3995
3996
3997
3998
3999
4000
} // end group Postambles
group SipChecks
{
/*
* @desc check the presence of conversation at SIP side
*
*/
function f_check_Conversation() runs on SipComponent
{
var boolean v_result;
var charstring v_question := "confirm if conversation at SIP port";
if (PX_SIP_CheckConversation) {
opPort.call(s_SIP_conversation:{v_question, -})
{[] opPort.getreply(s_SIP_conversation:{-, true}) {}
[] opPort.getreply(s_SIP_conversation:{-, false})
{all timer.stop;
setverdict(fail);
syncPort.send(m_syncClientStop);
stop;}