sipdialogp2t.cxx

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

				"transition_releasepend_idle",
				(bool (StateMachine<SipSMCommand,string>::*)(const SipSMCommand&)) &SipDialogP2T::a3_releasepend_idle, 
				s_release_pend, s_idle
				);


//	StateTransition<SipSMCommand,string> *transition_idle_listenreq=
		new StateTransition<SipSMCommand,string>(this,
				"transition_idle_listenreq",
				(bool (StateMachine<SipSMCommand,string>::*)(const SipSMCommand&)) &SipDialogP2T::a4_idle_listenreq,
				s_idle, s_listen_req
				);

//	StateTransition<SipSMCommand,string> *transition_listenreq_listen=
		new StateTransition<SipSMCommand,string>(this,
				"transition_listenreq_listen",
				(bool (StateMachine<SipSMCommand,string>::*)(const SipSMCommand&)) &SipDialogP2T::a5_listenreq_listen,
				s_listen_req, s_listen
				);

//	StateTransition<SipSMCommand,string> *transition_listen_idle=
		new StateTransition<SipSMCommand,string>(this,
				"transition_listen_idle",
				(bool (StateMachine<SipSMCommand,string>::*)(const SipSMCommand&)) &SipDialogP2T::a6_listen_idle,
				s_listen, s_idle
				);

//	StateTransition<SipSMCommand,string> *transition_talkreq_listenreq=
		new StateTransition<SipSMCommand,string>(this,
				"transition_talkreq_listenreq",
				(bool (StateMachine<SipSMCommand,string>::*)(const SipSMCommand&)) &SipDialogP2T::a7_talkreq_listenreq,
				s_talk_req, s_listen_req
				);
	
//	StateTransition<SipSMCommand,string> *transition_talkreq_collision=
		new StateTransition<SipSMCommand,string>(this,
				"transition_talkreq_collision",
				(bool (StateMachine<SipSMCommand,string>::*)(const SipSMCommand&)) &SipDialogP2T::a8_talkreq_collision,
				s_talk_req, s_collision
				);
	
//	StateTransition<SipSMCommand,string> *transition_collision_listenreq=
		new StateTransition<SipSMCommand,string>(this,
				"transition_collision_listenreq",
				(bool (StateMachine<SipSMCommand,string>::*)(const SipSMCommand&)) &SipDialogP2T::a9_collision_listenreq,
				s_collision, s_listen_req
				);
				
//	StateTransition<SipSMCommand,string> *transition_collision_resent_timer=
		new StateTransition<SipSMCommand,string>(this,
				"transition_collision_resent_timer",
				(bool (StateMachine<SipSMCommand,string>::*)(const SipSMCommand&)) &SipDialogP2T::a10_collision_resent_timer,
				s_collision, s_resent
				);
				
//	StateTransition<SipSMCommand,string> *transition_resent_collision_collision=
		new StateTransition<SipSMCommand,string>(this,
				"transition_resent_collision_collision",
				(bool (StateMachine<SipSMCommand,string>::*)(const SipSMCommand&)) &SipDialogP2T::a11_resent_collision_collision,
				s_resent, s_collision
				);
				
//	StateTransition<SipSMCommand,string> *transition_resent_talk=
		new StateTransition<SipSMCommand,string>(this,
				"transition_resent_talk",
				(bool (StateMachine<SipSMCommand,string>::*)(const SipSMCommand&)) &SipDialogP2T::a12_resent_talk,
				s_resent, s_talk
				);

//	StateTransition<SipSMCommand,string> *transition_resent_resent=
		new StateTransition<SipSMCommand,string>(this,
				"transition_resent_resent",
				(bool (StateMachine<SipSMCommand,string>::*)(const SipSMCommand&)) &SipDialogP2T::a13_resent_resent,
				s_resent, s_resent
				);	

	
//	StateTransition<SipSMCommand,string> *transition_listen_listen=
		new StateTransition<SipSMCommand,string>(this,
				"transition_listen_listen",
				(bool (StateMachine<SipSMCommand,string>::*)(const SipSMCommand&)) &SipDialogP2T::a14_listen_listen,
				s_listen, s_listen
				);
	
//	StateTransition<SipSMCommand,string> *transition_talkreq_talkreq=
		new StateTransition<SipSMCommand,string>(this,
				"transition_talkreq_talkreq",
				(bool (StateMachine<SipSMCommand,string>::*)(const SipSMCommand&)) &SipDialogP2T::a15_talkreq_talkreq,
				s_talk_req, s_talk_req
				);

//	StateTransition<SipSMCommand,string> *transition_releasepend_releasepend=
		new StateTransition<SipSMCommand,string>(this,
				"transition_releasepend_releasepend",
				(bool (StateMachine<SipSMCommand,string>::*)(const SipSMCommand&)) &SipDialogP2T::a16_releasepend_releasepend,
				s_release_pend, s_release_pend
				);
				
//	StateTransition<SipSMCommand,string> *transition_listen_idle_revoke=
		new StateTransition<SipSMCommand,string>(this,
				"transition_listen_idle_revoke",
				(bool (StateMachine<SipSMCommand,string>::*)(const SipSMCommand&)) &SipDialogP2T::a17_listen_idle_revoke,
				s_listen, s_idle
				);
				
//	StateTransition<SipSMCommand,string> *transition_talk_talk_revoke=
		new StateTransition<SipSMCommand,string>(this,
				"transition_talk_talk_revoke",
				(bool (StateMachine<SipSMCommand,string>::*)(const SipSMCommand&)) &SipDialogP2T::a18_talk_talk_revoke,
				s_talk, s_talk
				);
	
//	StateTransition<SipSMCommand,string> *transition_listenreq_listenreq=
		new StateTransition<SipSMCommand,string>(this,
				"transition_listenreq_listenreq",
				(bool (StateMachine<SipSMCommand,string>::*)(const SipSMCommand&)) &SipDialogP2T::a19_listenreq_listenreq,
				s_listen_req, s_listen_req
				);
				
//	StateTransition<SipSMCommand,string> *transition_idle_terminated=
		new StateTransition<SipSMCommand,string>(this,
				"transition_idle_terminated",
				(bool (StateMachine<SipSMCommand,string>::*)(const SipSMCommand&)) &SipDialogP2T::a80_idle_terminated,
				s_idle, s_terminated
				);						

//	StateTransition<SipSMCommand,string> *transition_talkreq_terminated=
		new StateTransition<SipSMCommand,string>(this,
				"transition_talkreq_terminated",
				(bool (StateMachine<SipSMCommand,string>::*)(const SipSMCommand&)) &SipDialogP2T::a81_talkreq_terminated,
				s_talk_req, s_terminated
				);
//	StateTransition<SipSMCommand,string> *transition_listenreq_terminated=
		new StateTransition<SipSMCommand,string>(this,
				"transition_listenreq_terminated",
				(bool (StateMachine<SipSMCommand,string>::*)(const SipSMCommand&)) &SipDialogP2T::a82_listenreq_terminated,
				s_listen_req, s_terminated
				);
				
//	StateTransition<SipSMCommand,string> *transition_talk_terminated=
		new StateTransition<SipSMCommand,string>(this,
				"transition_talk_terminated",
				(bool (StateMachine<SipSMCommand,string>::*)(const SipSMCommand&)) &SipDialogP2T::a83_talk_terminated,
				s_talk, s_terminated
				);
				
//	StateTransition<SipSMCommand,string> *transition_collision_terminated=
		new StateTransition<SipSMCommand,string>(this,
				"transition_collision_terminated",
				(bool (StateMachine<SipSMCommand,string>::*)(const SipSMCommand&)) &SipDialogP2T::a84_collision_terminated,
				s_collision, s_terminated
				);
				
//	StateTransition<SipSMCommand,string> *transition_listen_terminated=
		new StateTransition<SipSMCommand,string>(this,
				"transition_listen_terminated",
				(bool (StateMachine<SipSMCommand,string>::*)(const SipSMCommand&)) &SipDialogP2T::a85_listen_terminated,
				s_listen, s_terminated
				);
				
//	StateTransition<SipSMCommand,string> *transition_releasepend_terminated=
		new StateTransition<SipSMCommand,string>(this,
				"transition_releasepend_terminated",
				(bool (StateMachine<SipSMCommand,string>::*)(const SipSMCommand&)) &SipDialogP2T::a86_releasepend_terminated,
				s_release_pend, s_terminated
				);	
	
//	StateTransition<SipSMCommand,string> *transition_resent_terminated=
		new StateTransition<SipSMCommand,string>(this,
				"transition_resent_terminated",
				(bool (StateMachine<SipSMCommand,string>::*)(const SipSMCommand&)) &SipDialogP2T::a87_resent_terminated,
				s_resent, s_terminated
				);

	//used for development
	//forces the local UA to produce a collision, if the p2tCollisioner
	//variable is set.	
//	StateTransition<SipSMCommand,string> *transition_idle_talkreq_collisioner=
		new StateTransition<SipSMCommand,string>(this,
				"transition_idle_talkreq_collisioner",
				(bool (StateMachine<SipSMCommand,string>::*)(const SipSMCommand&)) &SipDialogP2T::a97_idle_talkreq_collisioner,
				s_idle, s_talk_req
				);
	
	//used for development. 
	//can be used to set the p2tPerformance variable			
//	StateTransition<SipSMCommand,string> *transition_idle_idle_performance=
		new StateTransition<SipSMCommand,string>(this,
				"transition_idle_idle_performance",
				(bool (StateMachine<SipSMCommand,string>::*)(const SipSMCommand&)) &SipDialogP2T::a98_idle_idle_performance,
				s_idle, s_idle
				);
	
	//used for development.
	//can be used to set the p2tCollisioner variable.
//	StateTransition<SipSMCommand,string> *transition_idle_idle_collisioner=
		new StateTransition<SipSMCommand,string>(this,
				"transition_idle_idle_collisioner",
				(bool (StateMachine<SipSMCommand,string>::*)(const SipSMCommand&)) &SipDialogP2T::a99_idle_idle_collisioner,
				s_idle, s_idle
				);	
	setCurrentState(s_idle);
}


SipDialogP2T::SipDialogP2T(MRef<SipStack*> stack, MRef<SipDialogConfig*> callconfig, MRef<SipSoftPhoneConfiguration*> pconf) : 
		SipDialog(stack,callconfig),
		phoneconf(pconf)
{
	
#ifdef OLD_MEDIA
	soundReceiver = new SoundReceiver(getPhoneConfig()->soundcard, NULL, getPhoneConfig());
	soundSender = new SoundSender(soundReceiver->getSocket(), 
			getPhoneConfig()->soundcard, 
			//getPhoneConfig()->inherited->codecs[0], //FIXME
			NULL);
	soundSender->setDialog(this);
	soundReceiver->setDialog(this);
#endif

	
	floorControlReceiver = new RtcpReceiver(getPhoneConfig(), 0/* soundReceiver->getContactPort()*/);
	floorControlSender = new RtcpSender(floorControlReceiver->getSocket());
	floorControlReceiver->start();
	floorControlSender->setCall(this);
	floorControlReceiver->setCall(this);
	//floorControlReceiver->flush();
					
	//generate GroupIdentity
	/*getDialogConfig().callId*/ dialogState.callId = itoa(rand())+"@"+getDialogConfig()->inherited->externalContactIP;
	
	//initialize sequence number
	dialogState.seqNo = 0;
	
	counterRevoke=0;
	counterCollision=0;
	
	p2tCollisioner=false;
	p2tPerformance=false;
		
	//start state machine
	setUpStateMachine();
}

SipDialogP2T::~SipDialogP2T(){	
#ifdef DEBUG_OUTPUT
	mdbg << "SipDialogP2T::~SipDialogP2T invoked"<< end;
#endif
}


bool SipDialogP2T::handleCommand(const SipSMCommand &c){
	
	//check CallId resp. GroupID
	
	
	
	return SipDialog::handleCommand(c);
}



bool SipDialogP2T::modifyUser(string uri, IPAddress *ip, int RTPport, int RTCPport, Codec *codec, string callId) {
	
	mdbg<<"-------------------------"<<end;
	mdbg<<"SipDialogP2T::modifyUser:"<<end;
	mdbg<<"User data arrived for "<<uri<<":"<<end;
	mdbg<<"RTPport="<<itoa(RTPport)<<end;
	mdbg<<"RTCPport="<<itoa(RTCPport)<<end;
	mdbg<<"-------------------------"<<end;
		
	
	if(grpList->isParticipant(uri)){
		MRef<GroupListUserElement *> ue = grpList->getUser(uri);
		
		//modify only if callIds are correct
		if(ue->getCallId()==callId){
			ue->setAddress(ip);
			ue->setRTPport(RTPport);
			ue->setRTCPport(RTCPport);
			ue->setCodec(codec);
			ue->setStatus(P2T::STATUS_CONNECTED);
			
			
			//check codec
			//getSoundSender()->setCodec(codec);
			
			//add to SoundSender
			//getSoundSender()->addRemoteAddress(uri, ip, RTPport);
			
		
			//inform GUI
			CommandString cmdstr(getCallId(), "p2tModifyUser", uri, itoa(ue->getStatus()) );
			getDialogContainer()->getCallback()->sipcb_handleCommand(cmdstr);
			return true;
		}
	}

	return false;	
}


bool SipDialogP2T::removeUser(string uri, string reason, string callId) {
	if(grpList->isParticipant(uri)){
		
		
	mdbg<<"-------------------------"<<end;
	mdbg<<"SipDialogP2T::removeUser:"<<end;
	mdbg<<"Remove user "<<uri<<":"<<end;
	mdbg<<"reason="<<reason<<end;
	mdbg<<"callID="<<callId<<"#"<<end;
	mdbg<<"GrplistCallID="<<grpList->getUser(uri)->getCallId()<<"#"<<end;
	mdbg<<"-------------------------"<<end;
		
		//remove only if callIds are correct
		if(grpList->getUser(uri)->getCallId()==callId){
			grpList->removeUser(uri);
			
			//remove user from SoundSender
			//not implemented
		
			//inform GUI
			CommandString cmdstr(getCallId(), "p2tRemoveUser", uri, reason);
			getDialogContainer()->getCallback()->sipcb_handleCommand(cmdstr);
			return true;
		}
	}
	
	return false;
}

void SipDialogP2T::setGroupList(MRef<GroupList*> GrpList){
	this->grpList = GrpList;
#ifdef MINISIP_MEMDEBUG 
	this->grpList.setUser("SipDialogP2T");
#endif

}

bool SipDialogP2T::checkStates(int status){
	bool ret=true;
	
	for(uint32_t k=0; k<grpList->getAllUser().size();k++){
		
		//filter out own user
		//if(grpList->getAllUser().at(k)->getUri()==getDialogConfig().inherited->userUri)
		if(grpList->getAllUser()[k]->getUri()==getDialogConfig()->inherited->sipIdentity->getSipUri())
				continue;
		
		if(grpList->getAllUser()[k]->getStatus()==status 
			|| grpList->getAllUser()[k]->getStatus()==P2T::STATUS_NOTAVAILABLE)
			continue;
		else
			ret=false;
	}
	
	return ret;
}

bool SipDialogP2T::allAnswered(){
	bool ret=true;
	
	//merr<<end<<"*****************************"<<end;
	//merr<<"SipDialogP2T::allAnswered()"<<end;
	
	for(uint32_t k=0; k<grpList->getAllUser().size();k++){
		
		//filter out own user
		//if(grpList->getAllUser().at(k)->getUri()==getDialogConfig().inherited->userUri)
		if(grpList->getAllUser()[k]->getUri()==getDialogConfig()->inherited->sipIdentity->getSipUri())
				continue;
		
		//merr<<grpList->getAllUser().at(k)->getUri()<<"="<<P2T::getStatus(grpList->getAllUser().at(k)->getStatus())<<end;
				
				
		if(grpList->getAllUser()[k]->getStatus()== P2T::STATUS_COLLISION
			|| grpList->getAllUser()[k]->getStatus()==P2T::STATUS_GRANT
			|| grpList->getAllUser()[k]->getStatus()==P2T::STATUS_RELEASED
			|| grpList->getAllUser()[k]->getStatus()==P2T::STATUS_NOTAVAILABLE){
			
			continue;
		}
		else {
			ret=false;
			break;
		}
	}
	//merr<<"return="<<itoa(ret)<<end;
	//merr<<"***************************"<<end;
	return ret;
}

void SipDialogP2T::setStates(int status){
	for(uint32_t k=0; k<grpList->getAllUser().size();k++)
		grpList->getAllUser()[k]->setStatus(status);
}

void SipDialogP2T::terminateSession(){


	for(uint32_t k=0; k<grpList->getAllUser().size();k++){
		
		
	
		//filter out own username
		//if(grpList->getAllUser().at(k)->getUri()==getDialogConfig().inherited->userUri)
		if(grpList->getAllUser()[k]->getUri()==getDialogConfig()->inherited->sipIdentity->getSipUri())
			continue;
		
		//send hang_up message to all SipDialogP2Tuser dialogs
		CommandString hup(grpList->getAllUser()[k]->getCallId(), SipCommandString::hang_up);
		SipSMCommand scmd(hup, SipSMCommand::remote, SipSMCommand::TU);
		getDialogContainer()->enqueueCommand(scmd, HIGH_PRIO_QUEUE, PRIO_LAST_IN_QUEUE);
		
		
	}
	

}

bool SipDialogP2T::highestPrio(int status,vector<string> &users){
	bool ret=false;
	int prio=0;
		
	//find my priority
	//int myPrio = getGroupList()->getUser(getDialogConfig().inherited->userUri)->getPriority();
	int myPrio = getGroupList()->getUser(getDialogConfig()->inherited->sipIdentity->getSipUri())->getPriority();
		
	//find highest priority from the other users
	for(uint32_t k=0; k<grpList->getAllUser().size();k++){
		//filter out own user 
		//if(grpList->getAllUser().at(k)->getUri()==getDialogConfig().inherited->userUri)
		if(grpList->getAllUser()[k]->getUri()==getDialogConfig()->inherited->sipIdentity->getSipUri())
			continue;
		
		if(grpList->getAllUser()[k]->getStatus()==status ){
			//higher prio found
			if(grpList->getAllUser()[k]->getPriority()>prio){
				//set new prio
				prio=grpList->getAllUser()[k]->getPriority();
				//clear vector
				users.clear();
				//add user
				users.push_back(grpList->getAllUser()[k]->getUri());
				
			}
			else if(grpList->getAllUser()[k]->getPriority()==prio){
				//add user to vector
				users.push_back(grpList->getAllUser()[k]->getUri());
			}
		}
	}
	
	if(myPrio>prio){
		ret=true;
		users.clear();
	}
	else if(myPrio==prio)
		ret=true;

	
	return ret;


}