sipcall.cpp

KphoneSI (kpsi) is a SIP (Session Initiation Protocol) user agent for Linux, with which you can in

	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 {
		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();
	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 ) {
			} else if( message->getStatus().getCode() == 200 || message->getStatus().getCode() == 202 ) {
				// Update the Contact for this member
					if( message->getContactList().getListLength() > 0 ) {
					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;
		}
	}
	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;
	// 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 ) ) {
//Request found
				curtrans->incomingRequest( message, true );
				return 0;
			}
		}
		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;
		}
	}
// We catch the NOTIFY refer contents
	if (  (message->getMethod() == Sip::NOTIFY) && loadCall() ) {
	    if (message->messageBody().contains("SIP/2.0") ) {
		    setRefNoti(message->messageBody());
	    }
	}
	// Find or create a member for this request
	SipCallMember *member = getMember( incominguri );
	if ( member == NULL ) {
		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() );
		}
	}
	SipTransaction *transaction = new SipTransaction( seqnum, member, this );
	transactions.append( transaction );
	transaction->incomingRequest( message,this->getHoldMaster() );

	// 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;
	}
}

//hallo
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();
}

void SipCall::terminateSubscribes( int mess )
{
	parent->terminateSubscribes(mess, this);
}


QString SipCall::getTrPresenceStatus( void ) {

 QString state;
  if( presenceStatus == "online" ) {
		state = "Online";
	} else if( presenceStatus == "busy" ) {
		state = "Busy";
	} else if( presenceStatus == "berightback" ) {
		state = "Be Right Back";
	} else if( presenceStatus == "away" ) {
		state = "Away";
 	} else if( presenceStatus == "permanent-absence") {
		state = "Permanent absent";
	} else if( presenceStatus == "appointment") {
		state ="Appointment";
	} else if( presenceStatus == "breakfast") {
		state ="On Breakfast";
	} else if( presenceStatus == "dinner") {
		state = "On Dinner" ;
	} else if( presenceStatus == "holiday") {
		state =  "On Holidays";
	} else if( presenceStatus == "lunch") {
		state ="On Lunch";
	} else if( presenceStatus == "meal") {
		state ="Having a Meal";
	} else if( presenceStatus == "meeting") {
		state ="On Meeting";
	} else if( presenceStatus == "travel") {
		state ="Travelling";
	} else if( presenceStatus =="in-transit") {
		state = "In Transit";
	} else if( presenceStatus =="steering") {
		state = "Steering";
	} else if( presenceStatus =="shopping") {
		state = "Shopping";
	} else if( presenceStatus =="sleeping") {
		state = "Sleeping";
	} else if( presenceStatus =="tv") {
		state = "Looking TV";
	} else if( presenceStatus == "vacation") {
		state ="On Vacation";
	} else if( presenceStatus == "onthephone") {
		state = "On The Phone" ;
	} else if( presenceStatus == "offline" ) {
		state = "Offline";
	}  else {
		state = presenceStatus;
	}
  return state;
}


//transient data handling methods

void SipCall::setInvoker( QString toexec ) {

	Inumber = toexec;
}

QString SipCall::getInvoker( void ) {
	return Inumber;
}

void SipCall::setNoHold(bool nohold)
{
    noHold=nohold;
}


void SipCall::setHoldMaster(bool hmaster)
{
    masterHold=hmaster;
}

bool SipCall::getHoldMaster(void)
{
    return masterHold;
}


void SipCall::onlyMeActive(bool me)
{
    activeOnly = me;
}

//used for CT in the new call control concept
void SipCall::setCallTrType( int newtype )
{

  switch (newtype)
    {

    case (int)StandardCall:
      calltype = StandardCall;
      break;
    case (int)videoCall:
      calltype = videoCall;
      break;
    case (int)auviCall:
      calltype = auviCall;
      break;
    case (int)extCall1:
      calltype = extCall1;
      break;
    case (int)extCall2:
      calltype = extCall2;
      break;
    case (int)extCall3:
      calltype = extCall3;
      break;
    case (int)extCall4:
      calltype = extCall4;
      break;
    default:
      calltype = GarKeinCall;
    break;
    }
    parent->callTypeUpdated();
}



int  SipCall::saveLoadType (int load) {
	if((StandardCall <= load) && (load < putMeOnHold) ) {
	    calltype = (CallType)load;
	}
	return (int) calltype; 
	
}





/****************************************************************
* call/load type handling routines, they must be adapted,
* if new types are added
*****************************************************************/

bool SipCall::loadCall(void) {
	bool scB=((calltype>=StandardCall)&&(calltype<=auviCall));
	bool pvB=(calltype >= extCall1);
	return (scB||pvB);
}

bool SipCall::blockCall(void) {
	bool scB=((calltype>=StandardCall)&&(calltype<=auviCall));
	return (scB||activeOnly );
}


bool SipCall::withAudioCall(void) {
	bool scB=((calltype==StandardCall)||(calltype==auviCall));
	return scB;
}

bool SipCall::withExtCall(void) {
	bool scB=((calltype>=videoCall)&&(calltype<=auviCall));
	bool pvB=(calltype >= extCall1);
	return (scB||pvB );
}

bool SipCall::isExtCall(void) {
return (calltype >= extCall1);
}