sipmessage.cxx

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

		}
		size_t r_end = ln.find("\"",r_pos+7);
		size_t n_end = ln.find("\"",n_pos+7);
		string sub = ln.substr(n_pos+7, n_end-(n_pos+7));
		setNonce(sub);
		cerr << "MM: Settin nonce to "<< sub<<endl;
		sub = ln.substr(r_pos+7, r_end-(r_pos+7));
		setRealm( sub );
		cerr << "MM: Settin realm to "<< sub<<endl;
	}
#endif
	return true;
}


void SipMessage::setContent(MRef<SipMessageContent*> content){
	this->content=content;
	if( content ){
		string contentType = content->getContentType();
		if( contentType != "" ){
			MRef<SipHeaderValueContentType*> contenttypep = new SipHeaderValueContentType( contentType );
			addHeader(new SipHeader(*contenttypep));
		}
	}
}

MRef<SipMessageContent*> SipMessage::getContent(){
	return content;
}

string SipMessage::getCallId(){
	for (int32_t i=0; i< headers.size(); i++){
		MRef<SipHeaderValueCallID*> id;
		if ((headers[i])->getType() == SIP_HEADER_TYPE_CALLID){
			id = MRef<SipHeaderValueCallID*>((SipHeaderValueCallID*)*(headers[i]->getHeaderValue(0)));
			return id->getString();
		}
	}
	return "";
}

int32_t  SipMessage::getCSeq(){
	for (int32_t i=0; i< headers.size(); i++){
		MRef<SipHeaderValueCSeq*> seq;
		if ((headers[i])->getType() == SIP_HEADER_TYPE_CSEQ){
			seq = MRef<SipHeaderValueCSeq*>((SipHeaderValueCSeq *)*(headers[i]->getHeaderValue(0)));
			return seq->getCSeq();
		}
	}
	merr << "ERROR: Could not find command sequence number in sip Message."<< end;
	return -1;
}

string SipMessage::getViaHeaderBranch(bool first){
	string b;
	MRef<SipHeaderValueVia*> via = getViaHeader(first);

	if( !via.isNull() ){
		b = via->getParameter("branch");
	}
	
	return b;
}

MRef<SipHeaderValueVia*> SipMessage::getViaHeader(bool first){
	MRef<SipHeaderValueVia*> via;
	
	for (int32_t i=0; i< headers.size(); i++){
		if ((headers[i])->getType() == SIP_HEADER_TYPE_VIA){
			via = MRef<SipHeaderValueVia*>((SipHeaderValueVia*)*(headers[i]->getHeaderValue(0)));
			if (first)
				return via;
		}
	}
	return via;
}


MRef<SipHeaderValueVia*> SipMessage::getFirstVia(){
	return getViaHeader(true);
}

MRef<SipHeaderValueVia*> SipMessage::getLastVia(){
	return getViaHeader(false);
}

string SipMessage::getFirstViaBranch(){
	return getViaHeaderBranch(true);
}

string SipMessage::getLastViaBranch(){
	return getViaHeaderBranch(false);
}

string SipMessage::getDestinationBranch(){
	return branch;
}

string SipMessage::getCSeqMethod(){
	for (int32_t i=0; i < headers.size(); i++){
		MRef<SipHeaderValueCSeq*> seq;
		if ((headers[i])->getType() == SIP_HEADER_TYPE_CSEQ){
			seq = MRef<SipHeaderValueCSeq*>((SipHeaderValueCSeq *)*(headers[i]->getHeaderValue(0)));
			return seq->getMethod();
		}
	
	}
	merr << "ERROR: Could not find command sequence method in sip Message."<< end;
	return "";
}

SipUri SipMessage::getFrom(){
	SipUri ret;
	MRef<SipHeaderValueFrom*> hfrom = getHeaderValueFrom();
	if (hfrom)
		ret = hfrom->getUri();

	return ret;
}

SipUri SipMessage::getTo(){
	SipUri ret;
	MRef<SipHeaderValueTo*> hto = getHeaderValueTo();
	if (hto)
		ret = hto->getUri();

	return ret;
}

void SipMessage::removeAllViaHeaders(){
	bool done=false;
	int n=0;
	while (!done){
		done=true;

		for (int i=0; i<headers.size(); i++){
			if ((headers[i])->getType()==SIP_HEADER_TYPE_VIA){
				headers.remove(i);
				done=false;
				n++;
				i--;
				break;
			}
			
		}
	}
}

MRef<SipHeaderValueFrom*> SipMessage::getHeaderValueFrom(){
	MRef<SipHeader*> from = getHeaderOfType( SIP_HEADER_TYPE_FROM );

	if( from ){
		return MRef<SipHeaderValueFrom*>( (SipHeaderValueFrom*)*(from->getHeaderValue(0)) );
	}

	return NULL;
}

MRef<SipHeaderValueTo*> SipMessage::getHeaderValueTo(){
	MRef<SipHeader*> to = getHeaderOfType( SIP_HEADER_TYPE_TO );

	if( to ){
		return MRef<SipHeaderValueTo*>( (SipHeaderValueTo*)*(to->getHeaderValue(0)) );
	}

	return NULL;
}

MRef<SipHeaderValueContact*> SipMessage::getHeaderValueContact(){
	MRef<SipHeader *> h = getHeaderOfType( SIP_HEADER_TYPE_CONTACT );

	if( h ){
		return MRef<SipHeaderValueContact*>( 
			(SipHeaderValueContact*)*(h->getHeaderValue(0) ) );
	}
	return NULL;
}

MRef<SipHeader *> SipMessage::getHeaderOfType(int t, int i){
	
	for (int32_t j=0; j< headers.size(); j++){
		if ((headers[j])->getType() == t){
			if (i==0)
				return headers[j];
			else
				i--;
		}
	}
	MRef<SipHeader*> nullhdr;
	return nullhdr; 
}


MRef<SipHeaderValue*> SipMessage::getHeaderValueNo(int type, int i){
	int headerindex=0;
	int valueindex=0;
	do{
		MRef<SipHeader *> h = getHeaderOfType(type, headerindex);
		if (h){
			int nval = h->getNoValues();
			if (i < valueindex+nval){	//the value we want is in this header
				return h->getHeaderValue(i-valueindex);
			}
			valueindex += nval;
			headerindex++;
		}else{
			MRef<SipHeaderValue*> nullhdr;
			
			return nullhdr;
		}
	}while(true);

}

string SipMessage::getWarningMessage(){
	for (uint32_t i = 0; i< (uint32_t)headers.size(); i++)
		if ((headers[i])->getType() == SIP_HEADER_TYPE_WARNING){
			string warning = ((SipHeaderValueWarning *)*(headers[i]->getHeaderValue(0)))->getWarning();
			return warning;
		}
	return "";
}

list<string> SipMessage::getRouteSet() {
	list<string> set;

	//merr << "CESC: SipMessage::getRouteSet() " << end;
	for( int i=0; i<headers.size(); i++ ) {
		if( headers[i]->getType() == SIP_HEADER_TYPE_RECORDROUTE ) {
			for( int j=0; j<headers[i]->getNoValues(); j++ ) {
				MRef<SipHeaderValueRecordRoute *> rr = (MRef<SipHeaderValueRecordRoute *>) ((SipHeaderValueRecordRoute *)*headers[i]->getHeaderValue(j));
				//merr << "CESC: SipMessage: Record-Route: (" << i << "," << j << ") : " << rr->getStringWithParameters() << end;
				set.push_back( rr->getStringWithParameters() );	
			}
			//merr << "CESC: SipMessage: Record-Route: " << headers[i]->getString() << end;
		} 
	}
	return set;
}


void SipMessage::setSocket(MRef<Socket*> sock)
{
	this->sock = sock;
}

MRef<Socket*> SipMessage::getSocket()
{
	return sock;
}


string SipMessage::getAuthenticateProperty(string prop){
        MRef<SipHeaderValue*> hdr;
        int i=0;

        do{
                hdr=getHeaderValueNo(SIP_HEADER_TYPE_WWWAUTHENTICATE, i++);
                if (hdr){
                        MRef<SipHeaderValueWWWAuthenticate*> whdr = (SipHeaderValueWWWAuthenticate*)*hdr;
                        if (whdr->getProperty()==prop)
                                return whdr->getValue();
                }
        }while(hdr);

        i=0;
        do{
                hdr=getHeaderValueNo(SIP_HEADER_TYPE_PROXYAUTHENTICATE, i++);
                if (hdr){
                        MRef<SipHeaderValueProxyAuthenticate*> phdr = (SipHeaderValueProxyAuthenticate*)*hdr;
                        if (phdr->getProperty()==prop)
                                return phdr->getValue();
                }
        }while(hdr);


        return "";
}


bool SipMessage::requires(string extension){
	MRef<SipHeaderValue*> hval;
	bool ret=false;
	int i=0;
	bool done=false;

	do{
		hval = getHeaderValueNo(SIP_HEADER_TYPE_REQUIRE, i);
		if (hval){
			string e= ((SipHeaderValueRequire*)*hval)->getString();
			if (e==extension){
				ret=true;
				done=true;
			}
		}
		i++;
	}while(!done && hval);

	return ret;
}


bool SipMessage::supported(string extension){
	MRef<SipHeaderValue*> hval;
	bool ret=false;
	int i=0;
	bool done=false;

	do{
		hval = getHeaderValueNo(SIP_HEADER_TYPE_SUPPORTED, i);
		if (hval){
			string e= ((SipHeaderValueSupported*)*hval)->getString();
			if (e==extension){
				ret=true;
				done=true;
			}
		}
		i++;
	}while(!done && hval);

	return ret;
}