C++ Url::getHostWithPort方法代码示例

void SignedUrl::sign( Url& urlToSign )
{
    UtlString existingUrlSignature;
    UtlString urlString;

    urlToSign.toString( urlString );
    if( urlToSign.getUrlParameter( SignatureUrlParamName, existingUrlSignature ) == TRUE )
    {
        OsSysLog::add(FAC_SIP, PRI_DEBUG,
                      "SignedUrl::sign URL '%s' already signed - updating signature",
                      urlString.data() );
    }
    UtlString userInfo;
    UtlString hostPort;
    UtlString strSignature;

    urlToSign.getUserId( userInfo );
    urlToSign.getHostWithPort( hostPort );

    computeSignature( userInfo, hostPort, strSignature );
    urlToSign.setUrlParameter( SignatureUrlParamName, strSignature.data() );

    OsSysLog::add(FAC_SIP, PRI_DEBUG,
                  "SignedUrl::sign URL signed: '%s' with signature '%s'",
                  urlString.data(), strSignature.data() );
}

UtlBoolean SignedUrl::isUrlSigned( Url& signedUrl )
{
    UtlBoolean bUrlProperlySigned;
    UtlString existingUrlSignature;
    UtlString urlString;

    signedUrl.toString( urlString );
    if( signedUrl.getUrlParameter( SignatureUrlParamName, existingUrlSignature ) == FALSE )
    {
        bUrlProperlySigned = FALSE;
        OsSysLog::add(FAC_SIP, PRI_DEBUG,
                      "SignedUrl::isUrlSigned URL '%s' not signed",
                      urlString.data() );
    }
    else
    {
        UtlString userInfo;
        UtlString hostPort;
        UtlString strReferenceSignature;

        signedUrl.getUserId( userInfo );
        signedUrl.getHostWithPort( hostPort );
        computeSignature( userInfo, hostPort, strReferenceSignature );

        if( strReferenceSignature.compareTo( existingUrlSignature ) == 0 )
        {
            bUrlProperlySigned = TRUE;
            OsSysLog::add(FAC_SIP, PRI_DEBUG,
                          "SignedUrl::isUrlSigned URL '%s' is properly signed",
                          urlString.data() );
        }
        else
        {
            bUrlProperlySigned = FALSE;
            OsSysLog::add(FAC_SIP, PRI_DEBUG,
                          "SignedUrl::isUrlSigned URL '%s' does not have a valid signature. "
                          "Expected signature: '%s'", urlString.data(), strReferenceSignature.data() );
        }
    }
    return bUrlProperlySigned;
}

AuthPlugin::AuthResult
MSFT_ExchangeTransferHack::authorizeAndModify(const UtlString& id,
                                              const Url&  requestUri,
                                              RouteState& routeState,
                                              const UtlString& method,
                                              AuthResult  priorResult,
                                              SipMessage& request,
                                              bool bSpiralingRequest,  
                                              UtlString&  reason
                                              )
{
   AuthResult result = CONTINUE; // we modify, but never make an authorization decision

   if (mUserAgentRegEx) // if not configured, do nothing
   {
      // get the call-id to use in logging
      UtlString callId;
      request.getCallIdField(&callId);

      /*
       * Note: a REFER from Exchange, with the bug we are hunting here, will always look like
       * it is tranferring to some foreign domain.  This will cause the TransferControl AuthPlugin
       * to ALLOW it.  If TransferControl starts challenging REFER from Exchange, that may mean
       * that MSFT has fixed the bug this plugin is meant to compensate for.
       */
      if (DENY != priorResult) // ignore anything some other plugin has already nixed
      {
         if (method.compareTo(SIP_REFER_METHOD) == 0) // we only care about REFER
         {
            UtlString userAgent;
            request.getUserAgentField( &userAgent );

            if (mUserAgentRegEx->Search(userAgent)) // does this look like Exchange?
            {
               UtlString targetStr;
               if (request.getReferToField(targetStr)) // get the address of the transfer target
               {
                  Url target(targetStr);
                  if (Url::SipUrlScheme == target.getScheme()) // target address parsed ok?
                  {
                     // check whether or not this is REFER with Replaces
                     UtlString targetDialog;
                     if (!target.getHeaderParameter(SIP_REPLACES_FIELD, targetDialog))
                     {
                        /*
                         * This is a REFER without Replaces from Exchange
                         * so check the domain parts of the two URIs to see if they match.
                         */

                        // Get the domain part of the transfer-target URI
                        UtlString targetDomain;
                        target.getHostWithPort(targetDomain);

                        // Get the domain part of the request URI
                        UtlString requestDomain;
                        requestUri.getHostWithPort(requestDomain);

                        if (targetDomain.compareTo(requestDomain, UtlString::ignoreCase) == 0)
                        {
                           // The domains are the same; this is the bug we're looking for...

                           UtlString correctDomain;
                           mpSipRouter->getDomain(correctDomain);
                           target.setHostAddress(correctDomain);
                           target.setHostPort(PORT_NONE);

                           UtlString modifiedTarget;
                           target.toString(modifiedTarget);
                           request.setReferToField(modifiedTarget.data());

                           Os::Logger::instance().log(FAC_AUTH, PRI_INFO,
                                         "MSFT_ExchangeTransferHack[%s]::authorizeAndModify "
                                         "corrected transfer target domain in call '%s'\n"
                                         "changed '@%s' -> '@%s'",
                                         mInstanceName.data(), callId.data(),
                                         targetDomain.data(), correctDomain.data()
                                         );
                        }
                        else
                        {
                           // oh my god... did MSFT fix Exchange?
                           Os::Logger::instance().log(FAC_AUTH, PRI_DEBUG,
                                         "MSFT_ExchangeTransferHack[%s]::authorizeAndModify "
                                         "request and target domain differ in '%s'; not modified",
                                         mInstanceName.data(), callId.data()
                                         );
                        }
                     }
                     else
                     {
                        // This is a REFER with Replaces from Exchange
                        // I don't expect this to happen, but if it does then don't mess with it.
                        Os::Logger::instance().log(FAC_AUTH, PRI_INFO,
                                      "MSFT_ExchangeTransferHack[%s]::authorizeAndModify "
                                      "allowing REFER with Replaces in call '%s' to '%s'; no action",
                                      mInstanceName.data(), callId.data(), targetDialog.data()
                                      );
                     }
                  }
                  else
//.........这里部分代码省略.........

//.........这里部分代码省略.........
               break;
            }

            /*
             * Determine whether the identity is one for which this proxy
             * is authoritative; if not, we will not use wildcard matches.
             */
            bool identityIsLocal = mpSipRouter->isLocalDomain(fromUrl);
            
            // now we have callerIdentity set; use for looking up each contact.
            Os::Logger::instance().log(FAC_SIP, PRI_DEBUG,
                          "CallerAlias[%s]::check4andApplyAlias "
                          "\n  caller '%s' %s",
                          mInstanceName.data(),
                          callerIdentity.data(),
                          identityIsLocal ? "is local" : "is not local"
                          );

            /*
             * Examine the request URI,
             * checking for a caller alias set for its domain(including asssociated gateway sipxecsLineid)  with callerIdentity
             */

            UtlString sipxecsLineIdField;
            requestUri.getUrlParameter(SIPX_SIPXECS_LINEID_URI_PARAM, sipxecsLineIdField);

            Os::Logger::instance().log(FAC_SIP, PRI_DEBUG,
                             "getUrlParameter: sipxecsLineid[%s]"
                             " in CallerAlias",
                             sipxecsLineIdField.data()
                             );

            UtlString targetDomain;
            requestUri.getHostWithPort(targetDomain);

            if (!(sipxecsLineIdField.isNull()))
            {
                targetDomain.append(";").append(SIPX_SIPXECS_LINEID_URI_PARAM).append("=").append(sipxecsLineIdField.data());
            }

            Os::Logger::instance().log(FAC_SIP, PRI_DEBUG,
                          "CallerAlias::targetDomain [%s]",
                          targetDomain.data()
                          );

            // look up any caller alias for this identity and contact domain
            UtlString callerAlias;
            if (identityIsLocal && getCallerAlias(callerIdentity, targetDomain, callerAlias) )
            {
               // found a caller alias, so rewrite the From information
               /*
                * The From header requires special handling
                * - we need to preserve the tag, if any, from the original header
                */
               originalFromUrl.getFieldParameter("tag", originalFromTag);

               Url newFromUrl(callerAlias.data());
               newFromUrl.removeFieldParameter("tag"); // specifying a tag is a no-no
               if ( !originalFromTag.isNull() )
               {
                  newFromUrl.setFieldParameter("tag", originalFromTag.data());
               }
               UtlString newFromFieldValue;
               newFromUrl.toString(newFromFieldValue);
                   
               // log the change we are making before stripping the tag from the field values