C++ HttpReq::getPathInfoLen方法代码示例

int HttpCgiTool::buildCommonEnv( IEnv * pEnv, HttpConnection * pConn )
{
    int count = 0;
    HttpReq * pReq = pConn->getReq();
    const char * pTemp;
    int n;
    int i;
    char buf[128];

    pTemp = pReq->getAuthUser();
    if (  *pTemp )
    {
        //FIXME: only Basic is support now
        pEnv->add( "AUTH_TYPE", 9, "Basic", 5 );
        pEnv->add( "REMOTE_USER", 11, pTemp, strlen( pTemp ) );
        count += 2;
    }
    //ADD_ENV("REMOTE_IDENT", "" )        //FIXME: not supported yet
    //extensions of CGI/1.1
    const AutoStr2 * pDocRoot = pReq->getDocRoot();
    pEnv->add( "DOCUMENT_ROOT", 13,
            pDocRoot->c_str(), pDocRoot->len()-1 );
    pEnv->add( "REMOTE_ADDR", 11, pConn->getPeerAddrString(),
            pConn->getPeerAddrStrLen() );
    
    n = safe_snprintf( buf, 10, "%hu", pConn->getRemotePort() );
    pEnv->add( "REMOTE_PORT", 11, buf, n );

    n = pConn->getServerAddrStr( buf, 128 );
    
    pEnv->add( "SERVER_ADDR", 11, buf, n );
    
    pEnv->add( "SERVER_NAME", 11, pReq->getHostStr(),  pReq->getHostStrLen() );
    const AutoStr2 &sPort = pReq->getPortStr();
    pEnv->add( "SERVER_PORT", 11, sPort.c_str(), sPort.len() );
    pEnv->add( "REQUEST_URI", 11, pReq->getOrgReqURL(), pReq->getOrgReqURLLen() );
    count += 7;
    
    n = pReq->getPathInfoLen();
    if ( n > 0)
    {
        int m;
        char achTranslated[10240];
        m =  pReq->translatePath( pReq->getPathInfo(), n,
                        achTranslated, sizeof( achTranslated ) );
        if ( m != -1 );
        {
            pEnv->add( "PATH_TRANSLATED", 15, achTranslated, m );
            ++count;
        }
        pEnv->add( "PATH_INFO", 9, pReq->getPathInfo(), n);
        ++count;
    }
    
    //add geo IP env here
    if ( pReq->isGeoIpOn() )
    {
        GeoInfo * pInfo = pConn->getClientInfo()->getGeoInfo();
        if ( pInfo )
        {
            pEnv->add( "GEOIP_ADDR", 10, pConn->getPeerAddrString(),
                    pConn->getPeerAddrStrLen() );
            count += pInfo->addGeoEnv( pEnv )+1;
        }
    }    

    n = pReq->getEnvCount();
    count += n;
    for( i = 0; i < n; ++i )
    {
        const char * pKey;
        const char * pVal;
        int keyLen;
        int valLen;
        pKey = pReq->getEnvByIndex( i, keyLen, pVal, valLen );
        if ( pKey )
            pEnv->add( pKey, keyLen, pVal, valLen );
    }
    
    if ( pConn->isSSL() )
    {
        SSLConnection * pSSL = pConn->getSSL();
        pEnv->add( "HTTPS", 5, "on",  2 );
        const char * pVersion = pSSL->getVersion();
        n = strlen( pVersion );
        pEnv->add( "SSL_VERSION", 11, pVersion, n );
        count += 2;
        SSL_SESSION * pSession = pSSL->getSession();
        if ( pSession )
        {
            int idLen = SSLConnection::getSessionIdLen( pSession );
            n = idLen * 2;
            assert( n < (int)sizeof( buf ) );
            StringTool::hexEncode(
                (char *)SSLConnection::getSessionId( pSession ),
                idLen, buf );
            pEnv->add( "SSL_SESSION_ID", 14, buf, n );
            ++count;
        }

//.........这里部分代码省略.........

//Only for types from LSI_REQ_SSL_VERSION to LSI_REQ_PATH_TRANSLATED which are defined in ls.h
int RequestVars::getReqVar2( HttpSession *pSession, int type, char * &pValue, int bufLen)
{
    HttpReq * pReq = pSession->getReq();
    int ret = 0;
    
    if (type >= LSI_REQ_SSL_VERSION && type <= LSI_REQ_SSL_CLIENT_CERT)
    {
        if( !pSession->isSSL() )
            return 0;
        
        SSLConnection *pSSL = pSession->getSSL();
        if( type == LSI_REQ_SSL_VERSION)
        {
            pValue = (char *)pSSL->getVersion();
            ret = strlen( pValue );
            return ret;
        }    
        else if( type == LSI_REQ_SSL_SESSION_ID )
        {
            SSL_SESSION *pSession = pSSL->getSession();
            if ( pSession )
            {
                int idLen = SSLConnection::getSessionIdLen( pSession );
                ret = idLen * 2;
                if ( ret > bufLen )
                    ret = bufLen;
                StringTool::hexEncode((char *)SSLConnection::getSessionId( pSession ), ret / 2, pValue );
            }
            return ret;
        }
        else if( type == LSI_REQ_SSL_CLIENT_CERT )
        {
            X509 * pClientCert = pSSL->getPeerCertificate();
            if ( pClientCert )
                ret = SSLCert::PEMWriteCert( pClientCert, pValue, bufLen );
            
            return ret;
        }
        else
        {
            const SSL_CIPHER * pCipher = pSSL->getCurrentCipher();
            if ( pCipher )
            {
                if( type == LSI_REQ_SSL_CIPHER )
                {
                    pValue = (char *)pSSL->getCipherName();
                    ret = strlen( pValue );
                }
                else
                {
                    int algkeysize;
                    int keysize = SSLConnection::getCipherBits( pCipher, &algkeysize );
                    if( type == LSI_REQ_SSL_CIPHER_USEKEYSIZE )
                        ret = safe_snprintf( pValue, 20, "%d", keysize );
                    else //LSI_REQ_SSL_CIPHER_ALGKEYSIZE
                        ret = safe_snprintf( pValue, 20, "%d", algkeysize );
                }
            }
            return ret;
        }
    }
    else if( type == LSI_REQ_GEOIP_ADDR)
    {
        ret = pSession->getPeerAddrStrLen();
        pValue = (char *)pSession->getPeerAddrString();
        return ret;
    }
    else if( type == LSI_REQ_PATH_TRANSLATED)
    {
        int n = pReq->getPathInfoLen();
        if ( n > 0)
            ret =  pReq->translatePath( pReq->getPathInfo(), n, pValue, bufLen);
        return ret;
    }
    else
        return 0;
}

int SSIEngine::processSubReq(HttpSession *pSession, SubstItem *pItem)
{
    char achBuf[40960];
    char *p;
    int len;
    int attr;
    if (!pItem)
        return 0;
    SSIRuntime *pRuntime = pSession->getReq()->getSSIRuntime();
    attr = pItem->getSubType();
    p = achBuf;
    len = 40960;
    switch (attr)
    {
    case SSI_INC_FILE:
        {
            HttpReq *pReq = pSession->getReq();
            memmove(p, pReq->getURI(), pReq->getURILen());
            p = p + pReq->getURILen() - pReq->getPathInfoLen();
            while (p[-1] != '/')
                --p;
            *p = 0;
            len -= p - achBuf;
            break;
        }
    case SSI_EXEC_CGI:
        pRuntime->requireCGI();
        break;
    case SSI_EXEC_CMD:
        pRuntime->requireCmd();
        p += snprintf(achBuf, 40960, "%s",
                      pRuntime->getCurrentScript()->getPath());
        while (p[-1] != '/')
            --p;
        *p++ = '&';
        *p++ = ' ';
        *p++ = '-';
        *p++ = 'c';
        *p++ = ' ';
        len -= p - achBuf;
        // make the command looks like "/script/path/& command"
        // '&' tell cgid to execute it as shell command
        break;
    }
    RequestVars::appendSubst(pItem, pSession, p, len,
                             0, pRuntime->getRegexResult());
    if (attr == SSI_INC_FILE)
    {
        if (strstr(achBuf, "/../") != NULL)

            return 0;
    }
    else if (attr == SSI_EXEC_CMD)
    {

        if (pSession->execExtCmd(achBuf, p - achBuf) == 0)
            return -2;
        else
            return 0;
        //len = snprintf( achBuf, 40960, "'exec cmd' is not available, "
        //            "use 'include virutal' instead.\n" );
        //pSession->appendDynBody( achBuf, len );

        //return 0;
    }
    if ((achBuf[0] != '/') && (attr != SSI_EXEC_CMD))
    {
        if (achBuf[0] == 0)
        {
            len = snprintf(achBuf, 40960,
                           "[an error occurred while processing this directive]\n");
            pSession->appendDynBody(achBuf, len);
            return 0;
        }
        HttpReq *pReq = pSession->getReq();
        const char *pURI = pReq->getURI();
        const char *p1 = pURI + pReq->getURILen() - pReq->getPathInfoLen();
        while ((p1 > pURI) && p1[-1] != '/')
            --p1;
        int prefix_len = p1 - pURI;
        memmove(&achBuf[prefix_len], achBuf, p - achBuf);
        memmove(achBuf, pReq->getURI(), prefix_len);
        p += prefix_len;
    }
    if (achBuf[0] == '/')
    {
        pSession->getReq()->setLocation(achBuf, p - achBuf);
        pSession->changeHandler();
        pSession->continueWrite();
        return -2;
    }
    return 0;
}

//.........这里部分代码省略.........
        const AutoStr2 * psTemp = pReq->getRealPath();
        if ( psTemp )
        {
            struct stat& st = pReq->getFileStat();
            if ( type == REF_SCRIPT_UID )
            {
                return snprintf( pValue, bufLen, "%d", st.st_uid );
            }
            else if ( type == REF_SCRIPT_GID )
            {
                return snprintf( pValue, bufLen, "%d", st.st_gid );
            }
            else if ( type == REF_SCRIPT_MODE )
            {
                return snprintf( pValue, bufLen, "%o", st.st_mode );
            }
            else if ( type == REF_SCRIPT_USERNAME )
            {
                struct passwd * pw = getpwuid( st.st_uid );
                if ( pw )
                    return snprintf( pValue, bufLen, "%s", pw->pw_name );
            }
            else
            {
                struct group * gr = getgrgid( st.st_gid );
                if ( gr )
                    return snprintf( pValue, bufLen, "%s", gr->gr_name );
            }
        }
        return 0;
    }
    case REF_PATH_INFO:
        pValue = (char *)pReq->getPathInfo();
        return pReq->getPathInfoLen();

    case REF_SCRIPT_NAME:
        pValue = (char *)pReq->getURI();
        return pReq->getScriptNameLen();
    case REF_SCRIPT_URI:
        p = pValue;
        if ( pSession->isSSL() )
        {
            strcpy( p, "https://" );
            p += 8;
        }
        else
        {
            strcpy( p, "http://" );
            p += 7;
        }
        i = pReq->getHeaderLen( HttpHeader::H_HOST );
        memmove( p, pReq->getHeader( HttpHeader::H_HOST ), 
                    i );
        p += i;

        i = pReq->getOrgURILen();
        memmove( p, pReq->getOrgURI(), i );
        p += i;
        return p - pValue;

    case REF_ORG_REQ_URI:
        pValue = (char *)pReq->getOrgReqURL();
        return pReq->getOrgReqURILen();
    case REF_DOCUMENT_URI:
        return pReq->getDecodedOrgReqURI( pValue );
    case REF_REQ_URI:

int HttpCgiTool::buildCommonEnv(IEnv *pEnv, HttpSession *pSession)
{
    int count = 0;
    HttpReq *pReq = pSession->getReq();
    const char *pTemp;
    int n;
    char buf[128];
    RadixNode *pNode;

    pTemp = pReq->getAuthUser();
    if (pTemp)
    {
        //NOTE: only Basic is support now
        pEnv->add("AUTH_TYPE", 9, "Basic", 5);
        pEnv->add("REMOTE_USER", 11, pTemp, strlen(pTemp));
        count += 2;
    }
    //ADD_ENV("REMOTE_IDENT", "" )        //TODO: not supported yet
    //extensions of CGI/1.1
    const AutoStr2 *pDocRoot = pReq->getDocRoot();
    pEnv->add("DOCUMENT_ROOT", 13,
              pDocRoot->c_str(), pDocRoot->len() - 1);
    pEnv->add("REMOTE_ADDR", 11, pSession->getPeerAddrString(),
              pSession->getPeerAddrStrLen());

    n = ls_snprintf(buf, 10, "%hu", pSession->getRemotePort());
    pEnv->add("REMOTE_PORT", 11, buf, n);

    n = pSession->getServerAddrStr(buf, 128);

    pEnv->add("SERVER_ADDR", 11, buf, n);

    pEnv->add("SERVER_NAME", 11, pReq->getHostStr(),  pReq->getHostStrLen());
    const AutoStr2 &sPort = pReq->getPortStr();
    pEnv->add("SERVER_PORT", 11, sPort.c_str(), sPort.len());
    pEnv->add("REQUEST_URI", 11, pReq->getOrgReqURL(),
              pReq->getOrgReqURLLen());
    count += 7;

    n = pReq->getPathInfoLen();
    if (n > 0)
    {
        int m;
        char achTranslated[10240];
        m =  pReq->translatePath(pReq->getPathInfo(), n,
                                 achTranslated, sizeof(achTranslated));
        if (m != -1)
        {
            pEnv->add("PATH_TRANSLATED", 15, achTranslated, m);
            ++count;
        }
        pEnv->add("PATH_INFO", 9, pReq->getPathInfo(), n);
        ++count;
    }

    //add geo IP env here
    if (pReq->isGeoIpOn())
    {
        GeoInfo *pInfo = pSession->getClientInfo()->getGeoInfo();
        if (pInfo)
        {
            pEnv->add("GEOIP_ADDR", 10, pSession->getPeerAddrString(),
                      pSession->getPeerAddrStrLen());
            count += pInfo->addGeoEnv(pEnv) + 1;
        }
    }
    n = pReq->getEnvCount();
    count += n;
    if ((pNode = (RadixNode *)pReq->getEnvNode()) != NULL)
        pNode->for_each2(addEnv, pEnv);

    if (pSession->getStream()->isSpdy())
    {
        const char *pProto = HioStream::getProtocolName((HiosProtocol)
                             pSession->getStream()->getProtocol());
        pEnv->add("X_SPDY", 6, pProto, strlen(pProto));
        ++count;
    }

    if (pSession->isSSL())
    {
        SslConnection *pSSL = pSession->getSSL();
        pEnv->add("HTTPS", 5, "on",  2);
        const char *pVersion = pSSL->getVersion();
        n = strlen(pVersion);
        pEnv->add("SSL_VERSION", 11, pVersion, n);
        count += 2;
        SSL_SESSION *pSession = pSSL->getSession();
        if (pSession)
        {
            int idLen = SslConnection::getSessionIdLen(pSession);
            n = idLen * 2;
            assert(n < (int)sizeof(buf));
            StringTool::hexEncode(
                (char *)SslConnection::getSessionId(pSession),
                idLen, buf);
            pEnv->add("SSL_SESSION_ID", 14, buf, n);
            ++count;
        }

//.........这里部分代码省略.........