sipdialogvoipserver.cxx

MiniSip Client with DomainKeys Authentication, Sip, Audio communications, Echo Cancel

		MRef<SipRequest*> cancel =
			(SipRequest*)*command.getCommandPacket();
		const string branch = cancel->getLastViaBranch();

		if (getLastInvite()->getLastViaBranch() != branch)
			return false;

#if 0
		// Create CANCEL transaction and handle the request
		MRef<SipTransaction*> cr( 
			new SipTransactionNonInviteServer(sipStack, 
				//MRef<SipDialog*>(this), 
				command.getCommandPacket()->getCSeq(), 
				command.getCommandPacket()->getCSeqMethod(), 
				command.getCommandPacket()->getLastViaBranch(), 
				dialogState.callId) );
		dispatcher->getLayerTransaction()->addTransaction(cr);
		registerTransactionToDialog(cr);

		SipSMCommand cmd(command);
		cmd.setDestination(SipSMCommand::transaction_layer);

		cr->handleCommand(cmd);
#endif

		// Send 487 Request Cancelled for INVITE
		MRef<SipResponse*> cancelledResp = new SipResponse( 
				branch, 
				487,
				"Request Cancelled", 
				*getLastInvite() 
				);
		cancelledResp->getHeaderValueTo()->setParameter("tag",dialogState.localTag);
		MRef<SipMessage*> cancelledMsg(*cancelledResp);
		SipSMCommand cancelledCmd( cancelledMsg, SipSMCommand::dialog_layer,
				  SipSMCommand::transaction_layer);
		dispatcher->enqueueCommand(cancelledCmd, HIGH_PRIO_QUEUE/*, PRIO_LAST_IN_QUEUE*/);

		// Send 200 OK for CANCEL
		MRef<SipResponse*> okResp = new SipResponse( branch, 200,"OK", MRef<SipMessage*>(*cancel) );
		okResp->getHeaderValueTo()->setParameter("tag",dialogState.localTag);
		MRef<SipMessage*> okMsg(*okResp);
		SipSMCommand okCmd( okMsg, SipSMCommand::dialog_layer,
				  SipSMCommand::transaction_layer);
		//cr->handleCommand(okCmd);
		dispatcher->enqueueCommand(okCmd, HIGH_PRIO_QUEUE);

		/* Tell the GUI */
		CommandString cmdstr(dialogState.callId, SipCommandString::remote_cancelled_invite,"");
		dispatcher->getCallback()->handleCommand("gui", cmdstr );

		getMediaSession()->stop();
		signalIfNoTransactions();
		return true;
	}else{
		return false;
	}
}

bool SipDialogVoipServer::a3005_ringing_termwait_reject( const SipSMCommand &command)
{
	
	if (		transitionMatch(command, 
				SipCommandString::reject_invite,
				SipSMCommand::dialog_layer,
				SipSMCommand::dialog_layer) || 
			transitionMatch(command,
				SipCommandString::hang_up,
				SipSMCommand::dialog_layer,
				SipSMCommand::dialog_layer)){


		sendReject( getLastInvite()->getDestinationBranch() );

		getMediaSession()->stop();
		signalIfNoTransactions();
		return true;
	}else{
		return false;
	}
}

//In case a3001 does not accept the invite
bool SipDialogVoipServer::a3006_start_termwait_INVITE( const SipSMCommand &command)
{	
	if (transitionMatch("INVITE", command, SipSMCommand::transaction_layer, SipSMCommand::dialog_layer)){

		setLastInvite(MRef<SipRequest*>((SipRequest *)*command.getCommandPacket()));
		
		dialogState.updateState( getLastInvite() );

#if 0
		MRef<SipTransaction*> ir( new SipTransactionInviteServerUA(sipStack, 
						//MRef<SipDialog*>(this), 
						command.getCommandPacket()->getCSeq(), 
						command.getCommandPacket()->getCSeqMethod(), 
						command.getCommandPacket()->getLastViaBranch(), 
						dialogState.callId ));

		dispatcher->getLayerTransaction()->addTransaction(ir);
		registerTransactionToDialog(ir);

		SipSMCommand cmd(command);
		cmd.setDestination(SipSMCommand::transaction_layer);

		dispatcher->enqueueCommand(cmd, HIGH_PRIO_QUEUE/*, PRIO_LAST_IN_QUEUE*/);
#endif
		sendNotAcceptable( command.getCommandPacket()->getDestinationBranch() );

		signalIfNoTransactions();
		return true;
	}else{
		return false;
	}
}

void SipDialogVoipServer::setUpStateMachine(){

	State<SipSMCommand,string> *s_start=new State<SipSMCommand,string>(this,"start");
	addState(s_start);

	State<SipSMCommand,string> *s_ringing=new State<SipSMCommand,string>(this,"ringing");
	addState(s_ringing);

	MRef<State<SipSMCommand,string> *> s_incall = getState("incall");
	MRef<State<SipSMCommand,string> *> s_termwait= getState("termwait");


	new StateTransition<SipSMCommand,string>(this, "transition_start_ringing_INVITE",
			(bool (StateMachine<SipSMCommand,string>::*)(const SipSMCommand&)) &SipDialogVoipServer::a3001_start_ringing_INVITE,
			s_start, s_ringing);

	new StateTransition<SipSMCommand,string>(this, "transition_ringing_incall_accept",
			(bool (StateMachine<SipSMCommand,string>::*)(const SipSMCommand&)) &SipDialogVoipServer::a3002_ringing_incall_accept,
			s_ringing, s_incall);

	new StateTransition<SipSMCommand,string>(this, "transition_incall_termwait_BYE",
			(bool (StateMachine<SipSMCommand,string>::*)(const SipSMCommand&)) &SipDialogVoipServer::a3003_ringing_termwait_BYE,
			s_ringing, s_termwait); 

	new StateTransition<SipSMCommand,string>(this, "transition_ringing_termwait_CANCEL",
			(bool (StateMachine<SipSMCommand,string>::*)(const SipSMCommand&)) &SipDialogVoipServer::a3004_ringing_termwait_CANCEL,
			s_ringing, s_termwait);
	
	new StateTransition<SipSMCommand,string>(this, "transition_ringing_termwait_reject",
			(bool (StateMachine<SipSMCommand,string>::*)(const SipSMCommand&)) &SipDialogVoipServer::a3005_ringing_termwait_reject,
			s_ringing, s_termwait);

	new StateTransition<SipSMCommand,string>(this, "transition_start_termwait_INVITEnothandled",
			(bool (StateMachine<SipSMCommand,string>::*)(const SipSMCommand&)) &SipDialogVoipServer::a3006_start_termwait_INVITE,
			s_start, s_termwait);

	
	setCurrentState(s_start);
}


#ifdef IPSEC_SUPPORT
SipDialogVoipServer::SipDialogVoipServer(MRef<SipStack*> stack, MRef<SipDialogConfig*> callconfig, MRef<SipSoftPhoneConfiguration*> pconf, MRef<Session *> mediaSession, string cid, MRef<MsipIpsecAPI *> ipsecSession) : 
		SipDialogVoip(stack,callconfig,pconf,mediaSession,cid,ipsecSession)
#else
SipDialogVoipServer::SipDialogVoipServer(MRef<SipStack*> stack, MRef<SipDialogConfig*> callconfig, MRef<SipSoftPhoneConfiguration*> pconf, MRef<Session *> mediaSession, string cid) : 
		SipDialogVoip(stack, callconfig, pconf, mediaSession, cid) 
#endif

{
	setUpStateMachine();
}

SipDialogVoipServer::~SipDialogVoipServer(){	
	mediaSession->unregister();
}


void SipDialogVoipServer::sendInviteOk(const string &branch){
	MRef<SipResponse*> ok= new SipResponse(branch, 200,"OK", MRef<SipMessage*>(*getLastInvite()));	
	ok->getHeaderValueTo()->setParameter("tag",dialogState.localTag);
	
	MRef<SipHeaderValue *> contact = 
		new SipHeaderValueContact( 
			getDialogConfig()->inherited->sipIdentity->getSipUri(),
			getDialogConfig()->inherited->externalContactIP,
			getDialogConfig()->inherited->getLocalSipPort(phoneconf->useSTUN),
			"", getDialogConfig()->inherited->getTransport(),
			-1); //set expires to -1, we do not use it (only in register)
	ok->addHeader( new SipHeader(*contact) );
	
	//There might be so that there are no SDP. Check!
	MRef<SdpPacket *> sdp;
	if (mediaSession){
#ifdef ENABLE_TS
		ts.save("getSdpAnswer");
#endif
		sdp = mediaSession->getSdpAnswer();
#ifdef ENABLE_TS
		ts.save("getSdpAnswer");
#endif
		if( !sdp ){
		// FIXME: this most probably means that the
		// creation of the MIKEY message failed, it 
		// should not happen
		merr << "Sdp was NULL in sendInviteOk" << end;
		return; 
		}
	}
	
	/* Add the latter to the INVITE message */ // If it exists
	

//-------------------------------------------------------------------------------------------------------------//
#ifdef IPSEC_SUPPORT	
	// Create a MIKEY message for IPSEC if stated in the config file.
	MRef<SipMimeContent*> mikey;
	if (getIpsecSession()->required()){
		ts.save("getMikeyIpsecAnswer");
		mikey = ipsecSession->getMikeyIpsecAnswer();
		ts.save("getMikeyIpsecAnswer");
		if (!mikey){
			merr << "Mikey was NULL in sendInviteOk" << end;
			merr << "Still some errors with IPSEC" << end;
			//return; 
		}
	}
	else
		mikey = NULL;
	MRef<SipMimeContent*> multi;
	if (mikey && mediaSession){
		multi = new SipMimeContent("multipart/mixed");
		multi->addPart(*mikey);
		multi->addPart(*sdp);
		ok->setContent( *multi);
	}
	if (mikey && !mediaSession)
		ok->setContent( *mikey);
	if (!mikey && mediaSession)
		ok->setContent( *sdp );
#else
	
	ok->setContent( *sdp );
#endif
//-------------------------------------------------------------------------------------------------------------//
//	/* Get the SDP Answer from the MediaSession */
//	MRef<SdpPacket *> sdpAnswer = mediaSession->getSdpAnswer();
//
//	if( sdpAnswer ){
//		ok->setContent( *sdpAnswer );
//	}
//	/* if sdp is NULL, the offer was refused, send 606 */
//	// FIXME
//	else return; 

	MRef<SipMessage*> pref(*ok);
	SipSMCommand cmd( pref, SipSMCommand::dialog_layer, SipSMCommand::transaction_layer);
	dispatcher->enqueueCommand(cmd, HIGH_PRIO_QUEUE/*, PRIO_LAST_IN_QUEUE*/);
}

void SipDialogVoipServer::sendReject(const string &branch){
	MRef<SipResponse*> ringing = new SipResponse(branch,486,"Temporary unavailable", MRef<SipMessage*>(*getLastInvite()));	
	ringing->getHeaderValueTo()->setParameter("tag",dialogState.localTag);
	MRef<SipMessage*> pref(*ringing);
	SipSMCommand cmd( pref,SipSMCommand::dialog_layer, SipSMCommand::transaction_layer);
	dispatcher->enqueueCommand(cmd, HIGH_PRIO_QUEUE/*, PRIO_LAST_IN_QUEUE*/);
}

void SipDialogVoipServer::sendRinging(const string &branch, bool use100Rel){
	MRef<SipResponse*> ringing = new SipResponse(branch,180,"Ringing", MRef<SipMessage*>(*getLastInvite()));	

	if (use100Rel){
		ringing->addHeader(new SipHeader(new SipHeaderValueRequire("100rel")));
	}
	
	ringing->getHeaderValueTo()->setParameter("tag",dialogState.localTag);
	
	MRef<SipHeaderValue *> contact = 
		new SipHeaderValueContact( 
			getDialogConfig()->inherited->sipIdentity->getSipUri(),
			getDialogConfig()->inherited->externalContactIP,
			getDialogConfig()->inherited->getLocalSipPort(phoneconf->useSTUN),
			"", getDialogConfig()->inherited->getTransport(),
			-1); //set expires to -1, we do not use it (only in register)
	ringing->addHeader( new SipHeader(*contact) );

	MRef<SipMessage*> pref(*ringing);
	SipSMCommand cmd( pref, SipSMCommand::dialog_layer, SipSMCommand::transaction_layer);
	dispatcher->enqueueCommand(cmd, HIGH_PRIO_QUEUE/*, PRIO_LAST_IN_QUEUE*/);
}

void SipDialogVoipServer::sendNotAcceptable(const string &branch){
	MRef<SipResponse*> not_acceptable = new SipResponse(branch,606,"Not Acceptable", MRef<SipMessage*>(*getLastInvite()));	
	if( mediaSession && mediaSession->getErrorString() != "" ){
		not_acceptable->addHeader( 
			new SipHeader(
				new SipHeaderValueWarning(
					getDialogConfig()->inherited->externalContactIP, 
					399, 
					mediaSession->getErrorString() ) ));
	}

	not_acceptable->getHeaderValueTo()->setParameter("tag",dialogState.localTag);
	MRef<SipMessage*> pref(*not_acceptable);
	SipSMCommand cmd( pref, SipSMCommand::dialog_layer, SipSMCommand::transaction_layer);
	dispatcher->enqueueCommand(cmd, HIGH_PRIO_QUEUE/*, PRIO_LAST_IN_QUEUE*/);
}