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