sipcommand.cxx

SIP（Session Initiation Protocol）是由IETF定义

}


bool SipCommand::checkMaxForwards()
{
    return getMaxForwards().get() >= 0;
}

bool
SipCommand::decrementMaxForwards()
{
    Sptr<SipMaxForwards> maxForwards;
    myHeaderList.getParsedHeader(maxForwards, SIP_MAX_FORWARDS_HDR);
    
    return maxForwards->decrement() != -1;
}


/*--------------------------- SipOrganization ---------------------------*/


const SipOrganization& SipCommand::getOrganization() const
{
    Sptr<SipOrganization> x;
    myHeaderList.getParsedHeader(x, SIP_ORGANIZATION_HDR);
    return *x;
}

void SipCommand::setOrganization( const SipOrganization& neworganization)
{
    Sptr<SipOrganization> x;
    myHeaderList.getParsedHeader(x, SIP_ORGANIZATION_HDR);
    *x =  neworganization;
}
    
    
void SipCommand::setOrganization( const Data& neworganization)
{
    Sptr<SipOrganization> x;
    myHeaderList.getParsedHeader(x, SIP_ORGANIZATION_HDR);
    x->decode(neworganization);
}


/*--------------------------- SipPriority ---------------------------*/


const SipPriority& SipCommand::getPriority() const
{
    Sptr<SipPriority> x;
    myHeaderList.getParsedHeader(x, SIP_PRIORITY_HDR);
    return *x;
}


void SipCommand::setPriority( const SipPriority& newpriority)
{
    Sptr<SipPriority> x;
    myHeaderList.getParsedHeader(x, SIP_PRIORITY_HDR);
    *x = newpriority;
}
    
    
void SipCommand::setPriority( const Data& newpriority)
{
    Sptr<SipPriority> x;
    myHeaderList.getParsedHeader(x, SIP_PRIORITY_HDR);
    x->decode(newpriority);
}


/*--------------------------- SipProxyAuthorization ---------------------------*/


const SipProxyAuthorization& 
SipCommand::getProxyAuthorization() const
{
    Sptr<SipProxyAuthorization> x;
    myHeaderList.getParsedHeader(x, SIP_PROXY_AUTHORIZATION_HDR);
    return *x;
}


void
SipCommand::setProxyAuthorization( const SipProxyAuthorization& newproxyAuth)
{
    Sptr<SipProxyAuthorization> x;
    myHeaderList.getParsedHeader(x, SIP_PROXY_AUTHORIZATION_HDR);
    *x = newproxyAuth;
}
    
    
void
SipCommand::setProxyAuthorization( const Data& newproxyAuth)
{
    Sptr<SipProxyAuthorization> x;
    myHeaderList.getParsedHeader(x, SIP_PROXY_AUTHORIZATION_HDR);
    x->decode(newproxyAuth);
}
    

int 
SipCommand::getNumProxyRequire() const
{
    return myHeaderList.getNumHeaders(SIP_PROXY_REQUIRE_HDR);
}


const SipProxyRequire& 
SipCommand::getProxyRequire( int i /*Defalut Value*/) const
{
    Sptr<SipProxyRequire> x;
    myHeaderList.getParsedHeader(x, SIP_PROXY_REQUIRE_HDR, i);
    return *x;
}


void 
SipCommand::setProxyRequire(SipProxyRequire item, int index /*Default Value*/)
{
    Sptr<SipHeader> x = new SipProxyRequire(item);
    myHeaderList.appendHeader(SIP_PROXY_REQUIRE_HDR, x, index);
}
    
    
void 
SipCommand::setProxyRequire(const Data&item, int index /*Default Value*/)
{
    Sptr<SipHeader> x = new SipProxyRequire(item);
    myHeaderList.appendHeader(SIP_PROXY_REQUIRE_HDR, x, index);
}


void 
SipCommand::setNumProxyRequire(int index)
{
    myHeaderList.setNumHeaders(SIP_PROXY_REQUIRE_HDR, index);
}


//------------------------------ SipResponseKey ------------------------------


const SipResponseKey& 
SipCommand::getResponseKey() const
{
    Sptr<SipResponseKey> x;
    myHeaderList.getParsedHeader(x, SIP_RESPONSE_KEY_HDR);
    return *x;
}


void 
SipCommand::setResponseKey( const SipResponseKey& newResponseKey)
{
    Sptr<SipResponseKey> x;
    myHeaderList.getParsedHeader(x, SIP_RESPONSE_KEY_HDR);
    *x = newResponseKey;
}


/*------------------------------ SipRequire ----------------------------------*/


int 
SipCommand::getNumRequire() const
{
    return myHeaderList.getNumHeaders(SIP_REQUIRE_HDR);

}


const SipRequire& 
SipCommand::getRequire( int i /*Default Value*/) const
{
    Sptr<SipRequire> x;
    myHeaderList.getParsedHeader(x, SIP_REQUIRE_HDR, i);
    return *x;
}


void 
SipCommand::setRequire(const SipRequire& item, int index /*default value*/)
{
    Sptr<SipHeader> x = new SipRequire(item);
    myHeaderList.appendHeader(SIP_REQUIRE_HDR, x, index);
}
    
    
void 
SipCommand::setRequire(const Data& item, int index /*default value*/)
{
    Sptr<SipHeader> x = new SipRequire(item);
    myHeaderList.appendHeader(SIP_REQUIRE_HDR, x, index);
}


void 
SipCommand::setNumRequire(int index)
{
    myHeaderList.setNumHeaders(SIP_REQUIRE_HDR, index);
}


/*--------------------------------- SipRoute -------------------------------*/


void 
SipCommand::flushrouteList()
{
    myHeaderList.setNumHeaders(SIP_ROUTE_HDR, 0);
}


const vector < Sptr<SipRoute> > 
SipCommand::getRouteList() const
{
    vector < Sptr<SipRoute> > routes;
    int cnt = myHeaderList.getNumHeaders(SIP_ROUTE_HDR);
    for (int i=0; i < cnt; i++)
    {
        Sptr<SipRoute> x;
        myHeaderList.getParsedHeader(x, SIP_ROUTE_HDR, i);
        routes.push_back(x);
    }
    return routes;
}

void 
SipCommand::setRouteList(const vector < SipRoute* > sipRouteList)
{
    flushrouteList();
    vector < SipRoute* > ::const_iterator iter = sipRouteList.begin();
    while ( iter != sipRouteList.end() )
    {
	myHeaderList.appendHeader(SIP_ROUTE_HDR, new SipRoute( *(*iter) ));
        iter++;
    }
}

void 
SipCommand::setRouteList(const vector < Sptr<SipRoute> > sipRouteList)
{
    flushrouteList();
    vector < Sptr<SipRoute> > ::const_iterator iter = sipRouteList.begin();
    while ( iter != sipRouteList.end() )
    {
	myHeaderList.appendHeader(SIP_ROUTE_HDR, *iter);
        iter++;
    }
}


int 
SipCommand::getNumRoute() const
{
    return myHeaderList.getNumHeaders(SIP_ROUTE_HDR);
}


const SipRoute& 
SipCommand::getRoute( int i /*Default Values*/) const
{
    Sptr<SipRoute> x;
    myHeaderList.getParsedHeader(x, SIP_ROUTE_HDR, i);
    return *x;
}


void 
SipCommand::setRoute(const SipRoute& item, int index /*Default values*/)
{
    Sptr<SipHeader> x = new SipRoute(item);
    myHeaderList.appendHeader(SIP_ROUTE_HDR, x, index);
}
    
    
void 
SipCommand::setRoute(const Data&item, int index /*Default values*/)
{
    Sptr<SipHeader> x = new SipRoute(item);
    myHeaderList.appendHeader(SIP_ROUTE_HDR, x, index);
}
    

void 
SipCommand::removeRoute(int index /*Default value*/)
{
    myHeaderList.removeHeader(SIP_ROUTE_HDR, index);
}


void 
SipCommand::setNumRoute(int index)
{
    myHeaderList.setNumHeaders(SIP_ROUTE_HDR, index);
}

void 
SipCommand::routePushFront(const SipRoute& item)
{
    int n = getNumRoute();
    setRoute(item, 0);
    assert (getNumRoute() == n+1);
}

void 
SipCommand::routePushBack(const SipRoute& item)
{
    int n = getNumRoute();
    setRoute(item, -1);
    assert (getNumRoute() == n+1);
}

void 
SipCommand::routePopFront()
{
    assert(!routeEmpty());
    int n = getNumRoute();
    removeRoute(0);
    assert (getNumRoute() == n-1);
}

void 
SipCommand::routePopBack()
{
    assert(!routeEmpty());
    int n = getNumRoute();
    removeRoute(-1);
    assert (getNumRoute() == n-1);
}

const SipRoute&
SipCommand::routeFront() const
{
    assert(!routeEmpty());
    return getRoute(0);
}

const SipRoute& 
SipCommand::routeBack() const
{
    assert(!routeEmpty());
    return getRoute(-1);
}

bool
SipCommand::routeEmpty() const
{
    return getNumRoute() == 0;
}


/*--------------------------------- SipSubject -------------------------------*/


const SipSubject& 
SipCommand::getSubject() const
{
    Sptr<SipSubject> x;
    myHeaderList.getParsedHeader(x, SIP_SUBJECT_HDR);
    return *x;
}
    

void 
SipCommand::setSubject( const SipSubject& newsubject)
{
    Sptr<SipSubject> x;
    myHeaderList.getParsedHeader(x, SIP_SUBJECT_HDR);
    *x = newsubject;
}
    
    
void 
SipCommand::setSubject( const Data& newsubject)
{
    Sptr<SipSubject> x;
    myHeaderList.getParsedHeader(x, SIP_SUBJECT_HDR);
    x->decode(newsubject);
}


/*----------------------------- SipOspAuthorization ----------------------------*/


const SipOspAuthorization& 
SipCommand::getSipOspAuthorization() const
{
    Sptr<SipOspAuthorization> x;
    myHeaderList.getParsedHeader(x, SIP_OSP_AUTHORIZATION_HDR);
    return *x;
}


void 
SipCommand::setSipOspAuthorization( const SipOspAuthorization& newosp)
{
    Sptr<SipOspAuthorization> x;
    myHeaderList.getParsedHeader(x, SIP_OSP_AUTHORIZATION_HDR);
    *x = newosp;
}

    
void 
SipCommand::setSipOspAuthorization( const Data& data)
{
    Sptr<SipOspAuthorization> x;
    myHeaderList.getParsedHeader(x, SIP_OSP_AUTHORIZATION_HDR);
    x->decode(data);
}


/*--------------------------------- SipAuthBasic -------------------------------*/

void 
SipCommand::setAuthBasic(const Data& data, const Data& pwd)
{
    Data cookie;

    if (pwd.length())
    {
        //form the basic cookie., treating data as username, and pwd as password
        SipBasic basic;
        cookie = basic.formSIPBasic(data, pwd);
    }
    else
    {
        cookie = data;
    }

    //get proxyAuthorization and set the basic cookie.
    Sptr<SipAuthorization> authorization;
    myHeaderList.getParsedHeader(authorization, SIP_AUTHORIZATION_HDR);

    authorization->setAuthScheme(AUTH_BASIC);
    authorization->setBasicCookie(cookie);
}


/*--------------------------------- SipAuthBasic -------------------------------*/

void 
SipCommand::setProxyAuth(const Data& data, const Data& pwd)
{
    Data cookie;

    if (pwd.length())
    {
        //form the basic cookie., treating data as username, and pwd as password
        SipBasic basic;
        cookie = basic.formSIPBasic(data, pwd);
    }
    else
    {
        cookie = data;
    }

    //get proxyAuthorization and set the basic cookie.
    Sptr<SipProxyAuthorization> proxyAuth;
    myHeaderList.getParsedHeader(proxyAuth, SIP_PROXY_AUTHORIZATION_HDR);

    proxyAuth->setAuthScheme(AUTH_BASIC);
    proxyAuth->setBasicCookie(cookie);
}


bool 
SipCommand::checkProxyAuth(const Data& data, const Data& pwd)
{
    Sptr<SipProxyAuthorization> proxyAuth;
    myHeaderList.getParsedHeader(proxyAuth, SIP_PROXY_AUTHORIZATION_HDR);
    Data cookie;