session.cxx

来自「MiniSip Client with DomainKeys Authentic」· CXX 代码 · 共 635 行 · 第 1/2 页

	MRef<MediaStreamReceiver *> receiver;
	MRef<SdpPacket *> packet;
	IPAddress * remoteAddress;
	// Not used
	int port;
	string keyMgmtMessage;
	std::list<std::string>::iterator iAttribute;
	std::list<std::string> attributes;
	std::list<MRef<Codec *> > codecs;
	std::list<MRef<Codec *> >::iterator iC;
// 	uint8_t payloadType;
	string rtpmap;

	this->peerUri = peerUri;
// 	cerr << "Session::setSdpOffer" << endl;

	keyMgmtMessage = offer->getSessionLevelAttribute( "key-mgmt" );

	if( keyMgmtMessage != "" ){
		if( !responderAuthenticate( keyMgmtMessage ) ){
			errorString =  "Incoming key management message could not be authenticated";
			if( ka ){
				errorString += ": " + ka->authError();
			}
			return false;
		}
		else //Here we set the offer in ka
			setMikeyOffer();
	}
	else{
		securityConfig.secured = false;
		securityConfig.ka_type = KEY_MGMT_METHOD_NULL;
	}
		

	remoteAddress = offer->getRemoteAddr( port );

	sdpAnswer = emptySdp();

	for( i = 0; i < offer->getHeaders().size(); i++ ){

		if( offer->getHeaders()[i]->getType() == SDP_HEADER_TYPE_M ){
			MRef<SdpHeaderM *> offerM = (SdpHeaderM*)*(offer->getHeaders()[i]);

			const string &transport = offerM->getTransport();

			if (transport != "RTP/AVP" &&
			    !securityConfig.secured &&
			    transport == "RTP/SAVP") {
				errorString += "No supported SRTP key exchange method";
				return false;
			}


			MRef<SdpHeaderM *> answerM = new SdpHeaderM(
					offerM->getMedia(), 0, 0,
					offerM->getTransport() );

			sdpAnswer->addHeader( *answerM );

			for( j = 0; j < offerM->getNrFormats(); j++ ){
				receiver = matchFormat( offerM, j, remoteAddress );

				if( receiver ){
					if( answerM->getPort() == 0 ){
						answerM->setPort( receiver->getPort() );
					}
					else{
						/* This media has already been treated */
						continue;
					}
					
					/* found a receiver, accept the offer */
					//add the payload type to the offer, as accepted ...
					int payloadTypeAccepted = offerM->getFormat( j );
					string payloadStr = itoa( payloadTypeAccepted );
					answerM->addFormat( payloadTypeAccepted );
					MRef<SdpHeaderA*> rtpmap = new SdpHeaderA("a=X");
					MRef<SdpHeaderA*> fmtp = new SdpHeaderA("a=X");
					       
					rtpmap->setAttributes( "fmtp:" + payloadStr
								 + " " + offerM->getRtpMap( payloadTypeAccepted ) );
					fmtp->setAttributes(   "rtpmap:" + payloadStr
								+ " " + offerM->getRtpMap( payloadTypeAccepted ) );
					
					answerM->addAttribute( *rtpmap );
					answerM->addAttribute( *fmtp );
					
					/* Additional attributes (framesize, ...) */
					attributes = receiver->getSdpAttributes();
					for( iAttribute = attributes.begin(); iAttribute != attributes.end(); iAttribute ++ ){
						MRef<SdpHeaderA*> a = new SdpHeaderA("a=X");
						a->setAttributes( *iAttribute );
						answerM->addAttribute( *a );
					}
				}
			}
		}
	}
	return true;
}

MRef<SdpPacket *> Session::getSdpAnswer(){
// 	cerr << "Session::getSdpAnswer" << endl;
	if( securityConfig.secured ){
		string keyMgmtAnswer;
		// Generate the key management answer message
		keyMgmtAnswer = responderParse();
		
		if( !securityConfig.secured ){
			// Something went wrong
			errorString = "Could not parse key management message.";
			fprintf(stderr, "responderParse failed\n" );
			return NULL;
		}
		/*
		else{
			if( ka && ka->type() == KEY_AGREEMENT_TYPE_DH ){
				((KeyAgreementDH *)*ka)->computeTgk();
			}
		}
		*/
		
		sdpAnswer->setSessionLevelAttribute( "key-mgmt", "mikey "+keyMgmtAnswer );
	}
	
	return sdpAnswer;
}

void Session::start(){
	list< MRef<MediaStreamSender * > >::iterator iS;
	list< MRef<MediaStreamReceiver * > >::iterator iR;

	if( securityConfig.secured && ka && ka->type() == KEY_AGREEMENT_TYPE_DH ){
#ifdef ENABLE_TS
	ts.save( TGK_START );
#endif
	((KeyAgreementDH *)*ka)->computeTgk();
#ifdef ENABLE_TS
	ts.save( TGK_END );
#endif
	}

	for( iR = mediaStreamReceivers.begin(); iR != mediaStreamReceivers.end(); iR++ ){
		if( ! (*iR)->disabled ){
			if( securityConfig.secured ){
				(*iR)->setKeyAgreement( ka );
			}
			(*iR)->start();
		}
	}
	
	mediaStreamSendersLock.lock();
	for( iS = mediaStreamSenders.begin(); iS != mediaStreamSenders.end(); iS++ ){
		if( (*iS)->getPort() ){
			if( securityConfig.secured ){
				(*iS)->setKeyAgreement( ka );
			}
			(*iS)->start();
		}
	}
	mediaStreamSendersLock.unlock();
}

void Session::stop(){
	list< MRef<MediaStreamSender * > >::iterator iS;
	list< MRef<MediaStreamReceiver * > >::iterator iR;

	for( iR = mediaStreamReceivers.begin(); iR != mediaStreamReceivers.end(); iR++ ){
		if( ! (*iR)->disabled ){
			(*iR)->stop();
		}
	}
	
	mediaStreamSendersLock.lock();
	for( iS = mediaStreamSenders.begin(); iS != mediaStreamSenders.end(); iS++ ){
		if( (*iS)->getPort() ){
			(*iS)->stop();
		}
	}
	mediaStreamSendersLock.unlock();

}


void Session::addMediaStreamReceiver( MRef<MediaStreamReceiver *> mediaStream ){
	mediaStreamReceivers.push_back( *mediaStream );
	silenceSources( silencedSources );
}

void Session::addMediaStreamSender( MRef<MediaStreamSender *> mediaStream ){
	mediaStreamSendersLock.lock();
	mediaStream->setMuted( mutedSenders );
	mediaStreamSenders.push_back( *mediaStream );
	mediaStreamSendersLock.unlock();
}

string Session::getErrorString(){
	return errorString;
}

uint16_t Session::getErrorCode(){
	return errorCode;
}

bool Session::isSecure(){
	return securityConfig.secured;
}

string Session::getCallId(){
	return callId;
}

void Session::setCallId( const string callId ){
	this->callId = callId;
}

void Session::sendDtmf( uint8_t symbol ){
	MRef<DtmfSender *> dtmfSender = new DtmfSender( this );
	uint32_t * ts = new uint32_t;
	*ts = 0;
	dtmfTOProvider->request_timeout( 0, dtmfSender, new DtmfEvent( symbol, 10, 0, false, true, ts ) );
	dtmfTOProvider->request_timeout( 5, dtmfSender, new DtmfEvent( symbol, 10, 0, false, false, ts ) );
	dtmfTOProvider->request_timeout( 10, dtmfSender, new DtmfEvent( symbol, 10, 0, false, false, ts ) );
	
	dtmfTOProvider->request_timeout( 15, dtmfSender, new DtmfEvent( symbol, 10, 800, true, false, ts ) );
	dtmfTOProvider->request_timeout( 20, dtmfSender, new DtmfEvent( symbol, 10, 800, true, false, ts ) );
	dtmfTOProvider->request_timeout( 25, dtmfSender, new DtmfEvent( symbol, 10, 800, true, false, ts, true ) );
	
}

void Session::muteSenders (bool mute) {
	mutedSenders = mute;
	mediaStreamSendersLock.lock();
	for( std::list< MRef<MediaStreamSender *> >::iterator it =  mediaStreamSenders.begin();
				it !=  mediaStreamSenders.end(); it++ ) {
		(*it)->setMuted( mute );
	}
	mediaStreamSendersLock.unlock();
	
}

void Session::silenceSources ( bool silence ) {
#ifdef DEBUG_OUTPUT
/*	if( silence )
		cerr << "Session::SilenceSources - true" << endl;
	else 
		cerr << "Session::SilenceSources - false" << endl;
*/
#endif
	silencedSources = silence;
	for( std::list< MRef<MediaStreamReceiver *> >::iterator it =  mediaStreamReceivers.begin();
				it !=  mediaStreamReceivers.end(); it++ ) {
		list<uint32_t> ssrcList;
		list<uint32_t>::iterator ssrcIt;
		MRef<AudioMedia *> audioMedia;
		MRef<AudioMediaSource *> audioSource;
		
		//obtain the media object used by the media stream, and try to cast it to
		//an audiomedia ... 
		audioMedia = dynamic_cast<AudioMedia *>( *( (*it)->getMedia() ) );
		//if it is not audiomedia, we are not interested
		if( !audioMedia ) {
			continue;
		}
		
		ssrcList = (*it)->getSsrcList();
		
		for( ssrcIt = ssrcList.begin(); ssrcIt != ssrcList.end(); ssrcIt++ ) {
			audioSource = audioMedia->getSource( *ssrcIt );
			if( !audioSource ) {
// 				cerr << "Session::SilenceSources - skipping ssrc ... no source found" << endl;
				continue;
			} else {
				audioSource->setSilenced( silence );
// 				cerr << "Session::SilenceSources - silencing source " << itoa(*ssrcIt) << endl;
			}
		}
	}
}

#ifdef DEBUG_OUTPUT
string Session::getDebugString() {
	string ret;
	ret = getMemObjectType() + ": this=" + itoa((int64_t)this) +
		"\n;          callid=" + getCallId() +
		"; peerUri=" + peerUri;
		
	ret += "\n          ";
	if( mutedSenders )
		ret += "; mutedSenders = true";
	else 
		ret += "; mutedSenders = false";	
	
	ret += "\n          ";
	if( silencedSources )
		ret += "; silencedSources = true";
	else 
		ret += "; silencedSources = false";	
	
	for( std::list< MRef<MediaStreamReceiver *> >::iterator it = mediaStreamReceivers.begin();
				it != mediaStreamReceivers.end(); it++ ) {
		ret += "\n" + (*it)->getDebugString();
	}
	for( std::list< MRef<MediaStreamSender *> >::iterator it2 =  mediaStreamSenders.begin();
				it2 !=  mediaStreamSenders.end(); it2++ ) {
		ret += "\n" + (*it2)->getDebugString();
	}
	return ret;
}
#endif

void Session::clearMediaStreamReceivers() {
	mediaStreamReceivers.clear();
}