bool
SipRegistrar::isValidDomain(const Url& uri) const
{
bool isValid = false;
UtlString domain;
uri.getHostAddress(domain);
domain.toLower();
int port = uri.getHostPort();
if (port == PORT_NONE)
{
port = SIP_PORT;
}
char portNum[15];
sprintf(portNum,"%d",port);
domain.append(":");
domain.append(portNum);
if ( mValidDomains.contains(&domain) )
{
isValid = true;
Os::Logger::instance().log(FAC_AUTH, PRI_DEBUG,
"SipRegistrar::isValidDomain(%s) VALID",
domain.data()) ;
}
return isValid;
}
void HttpConnectionMap::getPersistentUriKey(const Url& url, UtlString& key)
{
UtlString urlType;
UtlString httpHost;
UtlString httpPort;
url.getUrlType(urlType);
url.getHostAddress(httpHost);
int tempPort = url.getHostPort();
UtlString httpType = (url.getScheme() == Url::HttpsUrlScheme) ? "https" : "http";
if (tempPort == PORT_NONE)
{
if (httpType == "https")
{
httpPort = "443";
}
else
{
httpPort = "80";
}
}
else
{
char t[10];
sprintf(t, "%d", tempPort);
httpPort = t;
}
key = httpType + ":" + httpHost + ":" + httpPort;
key.toLower();
}
OsStatus ForwardRules::parseRouteMatchContainer(const Url& requestUri,
const SipMessage& request,
UtlString& routeToString,
UtlString& mappingType,
bool& authRequired,
TiXmlNode* routesNode,
TiXmlNode* previousRouteMatchNode)
{
UtlString testHost;
requestUri.getHostAddress(testHost);
int testPort = requestUri.getHostPort();
if(testPort == SIP_PORT)
{
testPort = PORT_NONE;
}
UtlBoolean routeMatchFound = false;
OsStatus methodMatchFound = OS_FAILED;
TiXmlElement* routesElement = routesNode->ToElement();
TiXmlNode* routeMatchNode = previousRouteMatchNode;
// Iterate through routes container children looking for
// route tags
while ( (routeMatchNode = routesElement->IterateChildren(routeMatchNode))
&& methodMatchFound != OS_SUCCESS)
{
// Skip non-elements
if(routeMatchNode && routeMatchNode->Type() != TiXmlNode::ELEMENT)
{
continue;
}
// Skip non-route elements
TiXmlElement* routeMatchElement = routeMatchNode->ToElement();
UtlString tagValue = routeMatchElement->Value();
if(tagValue.compareTo(XML_TAG_ROUTEMATCH) != 0 )
{
continue;
}
mappingType.remove(0);
routeToString.remove(0);
const char* mappingTypePtr =
routeMatchElement->Attribute(XML_ATT_MAPPINGTYPE);
//get the mapping Type attribute
mappingType.append(mappingTypePtr ? mappingTypePtr : "");
// Iterate through the route container's children looking
// for routeFrom, routeIPv4subnet, or routeDnsWildcard elements
TiXmlNode* routeFromPatternNode = NULL;
for( routeFromPatternNode = routeMatchElement->FirstChildElement();
routeFromPatternNode;
routeFromPatternNode = routeFromPatternNode->NextSiblingElement() )
{
// Skip elements that aren't of the "domainMatches" family
enum {ret_from, ret_ip, ret_dns} routeElementType ;
const char *name = routeFromPatternNode->Value() ;
if (strcmp(name, XML_TAG_ROUTEFROM) == 0)
{
routeElementType = ret_from;
}
else if (strcmp(name, XML_TAG_ROUTEIPV4SUBNET) == 0)
{
routeElementType = ret_ip;
}
else if (strcmp(name, XML_TAG_ROUTEDNSWILDCARD) == 0)
{
routeElementType = ret_dns;
}
else
{
continue ;
}
//found "domainMatches" pattern tag
TiXmlElement* routeFromPatternElement = routeFromPatternNode->ToElement();
//get the text value from it
TiXmlNode* routeFromPatternText = routeFromPatternElement->FirstChild();
if(routeFromPatternText && routeFromPatternText->Type() == TiXmlNode::TEXT)
{
TiXmlText* Xmlpattern = routeFromPatternText->ToText();
if (Xmlpattern)
{
UtlString pattern = Xmlpattern->Value();
switch(routeElementType)
{
case ret_from: // a routeFrom element matches host and port
{
Url xmlUrl(pattern.data());
UtlString xmlHost;
xmlUrl.getHostAddress(xmlHost);
int xmlPort = xmlUrl.getHostPort();
// See if the host and port of the routeFrom elelment
// match that of the URI
if( (xmlHost.compareTo(testHost, UtlString::ignoreCase) == 0) &&
((xmlPort == SIP_PORT && testPort == PORT_NONE) ||
xmlPort == testPort) )
{
routeMatchFound = true;
Os::Logger::instance().log(FAC_SIP, PRI_DEBUG, "ForwardRules::parseRouteMatchContainer - routeFrom %s matches %s", testHost.data(), pattern.data());
}
}
break ;
case ret_ip: // a routeIPv4subnet matches if the subnet does
{
// "pattern" is a subnet in CIDR notation (x.y.z.q/size)
// "testHost is supposed to be an IPv4 dotted quad
routeMatchFound = mPatterns->
IPv4subnet(testHost, pattern);
}
break ;
case ret_dns: // a routeDnsWildcard matches if the domain name does
{
// "pattern" is a wildcard DNS (*.pingtel.com)
// "testHost is a FQDN
routeMatchFound = mPatterns->
DnsWildcard(testHost, pattern);
}
break ;
}
if (routeMatchFound)
{
previousRouteMatchNode = routeMatchNode;
// Find a match to the request method and recurse
// to find child element field(s) matches and
// get the routeTo value
methodMatchFound = parseMethodMatchContainer(request,
routeToString,
authRequired,
routeMatchNode);
if( methodMatchFound == OS_SUCCESS)
break;
}
}
}
}
}
return methodMatchFound;
}
