sipcall.cpp

kphone-4.2,SHELL协议的VOIP电话

{
	parent->deleteCall( this );
	transactions.clear();
	members.clear();
}

void SipCall::addMember( SipCallMember *newmember )
{
	members.append( newmember );
}

SipTransaction *SipCall::newRequest( SipCallMember *member, Sip::Method meth,
	const QString &body, const MimeContentType &bodytype, const SipUri &transferto,
	const QString &proxyauthentication, int expiresTime )
{
	SipTransaction *trans = new SipTransaction( lastseq++, member, this );
	if( trans->sendRequest( meth, body, bodytype, transferto, proxyauthentication, expiresTime ) ) {
		transactions.clear();
		transactions.append( trans );

		// Audit the call
		auditCall();

		// Return the transaction object for tracking
		return trans;
	} else {
		delete trans;
		return 0;
	}
}

SipTransaction *SipCall::newRegister( const SipUri &registerserver, int expiresTime, const QString &authentication,
	const QString &proxyauthentication, const QString &qvalue, const QString &body, const MimeContentType &bodytype )
{
	transactions.clear();
	localuri.setTag( QString::null );
	SipTransaction *trans = new SipTransaction( lastseq++, new SipCallMember( this, localuri ), this );
	transactions.append( trans );
	trans->sendRegister( registerserver, expiresTime, authentication, proxyauthentication, body, bodytype, qvalue );
	return trans;
}

bool SipCall::sendRequest( SipMessage *reqmsg, bool contact, const SipUri &proxy, const QString &branch )
{
	reqmsg->insertHeader( SipHeader::From, localuri.nameAddr() );
	reqmsg->insertHeader( SipHeader::Call_ID, callid );
	if( ( reqmsg->getMethod() == Sip::INVITE ) || ( reqmsg->getMethod() == Sip::MSG ) ) {
		reqmsg->insertHeader( SipHeader::Subject, getSubject() );
	}
	if( hasroute ) {
		if( route.getHead().uri().contains( ";lr" ) ) {
			reqmsg->insertHeader( SipHeader::Route, route.getUriList() );
		} else {
			reqmsg->setRequestUri( route.getHead() );
			SipUriList routewithouthead = route;
			routewithouthead.removeHead();
			reqmsg->insertHeader( SipHeader::Route, routewithouthead.getUriList() );
		}
	}
	if( parent->getExplicitProxyMode() ) {
		if( reqmsg->getMethod() == Sip::REGISTER || reqmsg->getMethod() == Sip::INVITE ||
				reqmsg->getMethod() == Sip::SUBSCRIBE || reqmsg->getMethod() == Sip::ACK ) {
			if( parent->isLooseRoute() ) {
				if( reqmsg->getMethod() == Sip::REGISTER ) {
					reqmsg->setRequestUri(
						SipUri( reqmsg->getHeaderData( SipHeader::To ) ).getRegisterUri() );
				}
				reqmsg->insertHeader( SipHeader::Route, parent->getExplicitProxyAddress() );
			} else if( parent->isStrictRoute() ) {
				if( reqmsg->getMethod() == Sip::REGISTER ) {
					reqmsg->insertHeader(
						SipHeader::Route, SipUri(
						reqmsg->getHeaderData( SipHeader::To ) ).getRouteUri() );
				} else {
					reqmsg->insertHeader(
						SipHeader::Route, "<" + reqmsg->getRequestUri().reqUri() + ">" );
				}
				reqmsg->setRequestUri( parent->getExplicitProxyAddress() );
			} else {
				if( reqmsg->getMethod() == Sip::REGISTER ) {
					reqmsg->setRequestUri(
						SipUri( reqmsg->getHeaderData( SipHeader::To ) ).getRegisterUri() );
				}
			}
		}
	}
	return parent->sendRequest( reqmsg, contact, proxy, branch );
}

void SipCall::sendResponse( SipMessage *responsemsg, bool contact )
{
	responsemsg->insertHeader( SipHeader::Call_ID, callid );
	responsemsg->insertHeader( SipHeader::To, localuri.nameAddr() );
	if( hasrecordroute ) {
		responsemsg->setRecordRoute( recordroute );
	}
	parent->sendResponse( responsemsg, contact );
}

void SipCall::sendRaw( SipMessage *msg )
{
	parent->sendRaw( msg );
}

SipCallMember *SipCall::incomingMessage( SipMessage *message )
{
	if( message->getType() == SipMessage::Request ) {
		return incomingRequest( message );
	} else if( message->getType() == SipMessage::Response ) {
		incomingResponse( message );
	} else {
		printf( "SipCall: Incoming message dropped (bad message type)\n" );
		delete message;
	}
	return 0;
}


void SipCall::incomingResponse( SipMessage *message )
{
	SipUri incominguri( message->getHeaderData( SipHeader::To ) );
	QString cseq = message->getHeaderData( SipHeader::CSeq );
	unsigned int seqnum = cseq.left( cseq.find( " " ) ).toUInt();
	printf( "SipCall: Incoming response\n" );
	SipTransaction *curtrans;
	for ( curtrans = transactions.first(); curtrans != 0; curtrans = transactions.next() ) {
		if (( incominguri == curtrans->getCallMember()->getUri()) &&
		    ( seqnum == curtrans->getSeqNum() ) &&
		    ( curtrans->getDirection() == SipTransaction::LocalRequest ) ) {
			SipCallMember *member = getMember( incominguri );
			if( member == NULL ) {
				printf( "SipCall: Billy, you really messed something up\n" );
			} else if( message->getStatus().getCode() == 200 || message->getStatus().getCode() == 202 ) {
				printf( "SipCall: Checking for Contact and Record-Route\n" );

				// Update the Contact for this member
				if( message->getContactList().getListLength() > 0 ) {
					printf( "SipCall: Setting Contact for this Call Member\n" );
					member->setContactUri( message->getContactList().getHead() );
				}

				// Update the route
				if( message->getRecordRoute().getListLength() > 0 ) {
					hasroute = true;
					route = message->getRecordRoute();
					route.reverseList();
					if( !route.getHead().uri().contains( ";lr" ) ) {
						route.addToEnd( member->getContactUri() );
					}
				}
			}
			curtrans->incomingResponse( message );
			return;
		}
	}
	printf( "SipCall: Response dropped: No transaction found\n" );
	delete message;
}


SipCallMember *SipCall::incomingRequest( SipMessage *message )
{
	SipUri incominguri( message->getHeaderData( SipHeader::From ) );
	QString cseq = message->getHeaderData( SipHeader::CSeq );
	unsigned int seqnum = cseq.left( cseq.find( " " ) ).toUInt();
	QString seqmethod = cseq.right( cseq.find( " " ) + 1 );
	SipTransaction *curtrans;
	printf( "SipCall: Incoming request\n" );

	// Update our identity if necessary
	SipUri touri( message->getHeaderData( SipHeader::To ) );
	if( touri != localuri ) {
		localuri = touri;
		if( !localuri.hasTag() ) {
			localuri.generateTag();
		}
	}

	if( ( message->getMethod() == Sip::ACK ) || ( message->getMethod() == Sip::CANCEL ) ) {
		for( curtrans = transactions.first(); curtrans != 0; curtrans = transactions.next() ) {
			if( ( incominguri == curtrans->getCallMember()->getUri() ) &&
			    ( seqnum == curtrans->getSeqNum() ) &&
			    ( curtrans->getDirection() == SipTransaction::RemoteRequest ) ) {
				curtrans->incomingRequest( message );
				return 0;
			}
		}
		printf( "SipCall: ACK/CANCEL recieved, but no matching transaction found\n" );
		delete message;
		return 0;
	}
	for( curtrans = transactions.first(); curtrans != 0; curtrans = transactions.next() ) {
		if( ( incominguri == curtrans->getCallMember()->getUri() ) && ( seqnum == curtrans->getSeqNum() ) && 
		    ( seqmethod == curtrans->getSeqMethod() ) &&
		    ( curtrans->getDirection() == SipTransaction::RemoteRequest ) ) {
			curtrans->incomingRequestRetransmission( message );
			return 0;
		}
	}

	// Find or create a member for this request
	SipCallMember *member = getMember( incominguri );
	if ( member == NULL ) {
          printf("SipCall: Create a new incominguri \n");
		member = new SipCallMember( this, incominguri );
		if ( message->getMethod() == Sip::INVITE ) {
			member->setCallMemberType( SipCallMember::Invite );
		} else if ( message->getMethod() == Sip::SUBSCRIBE ) {
			member->setCallMemberType( SipCallMember::Subscribe );
		} else if ( message->getMethod() == Sip::NOTIFY ) {
			member->setCallMemberType( SipCallMember::Notify );
		} else if ( message->getMethod() == Sip::MESSAGE ) {
			member->setCallMemberType( SipCallMember::Message );
		}
	}

	// Update the Contact for this member
	if( message->getContactList().getListLength() > 0 ) {
		member->setContactUri( message->getContactList().getHead() );
	}

	// Update the route
	if( message->getRecordRoute().getListLength() > 0 ) {
		hasrecordroute = true;
		recordroute = message->getRecordRoute();
		hasroute = true;
		route = recordroute;
		if( !route.getHead().uri().contains( ";lr" ) ) {
			route.addToEnd( member->getContactUri() );
		}
	}

	// Create a new transaction and process it
	printf( "SipCall: New transaction created\n" );
	SipTransaction *transaction = new SipTransaction( seqnum, member, this );
	transactions.append( transaction );
	transaction->incomingRequest( message );

	// Update member status based on this transaction
	member->incomingTransaction( transaction );
	return member;
}

void SipCall::setSubject( const QString& newsubject )
{
	subject = newsubject;
	subjectChanged();
}

SipUri SipCall::getContactUri( void )
{
	return parent->getContactUri();
}

SipCallMember *SipCall::getMember( const SipUri &uri )
{
	SipCallMember *m;
	for( m = members.first(); m != 0; m = members.next() ) {
		if ( uri == m->getUri() ) {
			return m;
		}
	}

	return NULL;
}

void SipCall::setCallType( CallType newtype )
{
	calltype = newtype;
	parent->callTypeUpdated();
}

void SipCall::auditCall( void )
{
	bool foundmemb = false;

	// If there are no active call members, set the call status to 'Dead'
	for( SipCallMember *memb = members.first(); memb != 0; memb = members.next() ) {
		if( ( memb->getState() != SipCallMember::state_Disconnecting ) &&
		    ( memb->getState() != SipCallMember::state_Disconnected ) ) {
			foundmemb = true;
		}
	}
	if( !foundmemb ) {
		callstatus = callDead;
		callStatusUpdated();
	}
}

QString SipCall::getProxyUsername( void )
{
	SipUser *u = parent->getUser( localuri );
	if( u != NULL ) {
		SipUri *uri = u->getMyUri();
		if( uri->hasProxyUsername() ) {
			return uri->getProxyUsername();
		} else {
			return QString::null;
		}
	} else {
		return QString::null;
	}
}

QString SipCall::getHostname( void )
{
	SipUser *u = parent->getUser( localuri );
	if( u != NULL ) {
		SipUri *uri = u->getMyUri();
		return uri->getHostname();
	} else {
		return QString::null;
	}
}

QString SipCall::getSipProxy( void )
{
	SipUser *u = parent->getUser( localuri );
	if( u != NULL ) {
		SipClient *c = u->parent();
		QString proxy = c->getSipProxy();
		if( !proxy.isEmpty() ) {
			return proxy;
		} else {
			if( c->getProxyMode() ) {
				return c->getSipProxySrv( u->getMyUri()->getHostname() );
			}
		}
	} 
	return QString::null;
}

void SipCall::setProxyUsername( QString newUsername )
{
	SipUser *u = parent->getUser( localuri );
	if( u != NULL ) {
		SipUri *uri = u->getMyUri();
		uri->setProxyUsername( newUsername );
	}
}

QString SipCall::getPassword( void )
{
	SipUser *u = parent->getUser( localuri );
	if( u != NULL ) {
		SipUri *uri = u->getMyUri();
		if( uri->hasPassword() ) {
			return uri->getPassword();
		} else {
			return QString::null;
		}
	} else {
		return QString::null;
	}
}

void SipCall::setPassword( QString newPassword )
{
	SipUser *u = parent->getUser( localuri );
	if( u != NULL ) {
		SipUri *uri = u->getMyUri();
		uri->setPassword( newPassword );
	}
}

void SipCall::hideCallWidget( void )
{
	parent->hideCallWidget( this );
}

void SipCall::updateSubscribes( void )
{
	parent->updateSubscribes();
}