ospsslref.c

mgcp协议源代码。支持多种编码：g711

}

SSLErr
    SSLREF_Free(
    SSLBuffer *ospvBuffer, 
    void      *ospvAllocRef)
{
    SSLErr sslref_errcode = SSLNoErr;

    OSPM_DBGENTER(("ENTER: SSLREF_Free() (%lx)\n",
        (unsigned long)ospvBuffer->data));

    OSPM_ARGUSED(ospvAllocRef);

    if (ospvBuffer != OSPC_OSNULL)
    {
        if (ospvBuffer->data != OSPC_OSNULL)
        {
            OSPM_FREE(ospvBuffer->data);
            ospvBuffer->data = OSPC_OSNULL;
        }
        ospvBuffer->length = 0;
    }
    OSPM_DBGEXIT(("EXIT : SSLREF_Free() (%d)\n", sslref_errcode));
    return sslref_errcode;
}

SSLErr
    SSLREF_Realloc(
    SSLBuffer *ospvBuffer, 
    uint32     ospvNewSize, 
    void      *ospvAllocRef)
{  
    unsigned char *newData        = OSPC_OSNULL;
    SSLErr         sslref_errcode = SSLNoErr;

    OSPM_DBGENTER(("ENTER: SSLREF_Realloc()\n"));

    OSPM_ARGUSED(ospvAllocRef);
    OSPM_REALLOC(newData, ospvBuffer->data, unsigned char, ospvNewSize);
    if (newData == OSPC_OSNULL)
    {
        sslref_errcode = SSLMemoryErr;
        OSPM_FREE(ospvBuffer->data);
        ospvBuffer->data=OSPC_OSNULL;
        ospvBuffer->length=0;
    }
    else
    {
        ospvBuffer->data=newData;
        ospvBuffer->length=ospvNewSize;
    }
    OSPM_DBGEXIT(("EXIT : SSLREF_Realloc() (%d)\n", sslref_errcode));
    return sslref_errcode;
}

SSLErr
    SSLREF_Random(
    SSLBuffer ospvBuffer, 
    void     *ospvRandomRef)
{   
    int    result         = 0;
    SSLErr sslref_errcode = SSLNoErr;

#if RSAREF
    R_RANDOM_STRUCT     *rsaRandom = (R_RANDOM_STRUCT*)ospvRandomRef;

    OSPM_DBGENTER(("ENTER: SSLREF_Random()\n"));
    if (ospvRandomRef == 0)
        sslref_errcode = SSLUnknownErr;

    if ((result = R_GenerateBytes(ospvBuffer.data, ospvBuffer.length, 
        rsaRandom)) != 0)
        sslref_errcode = SSLUnknownErr;

#elif BSAFE
    B_ALGORITHM_OBJ random = (B_ALGORITHM_OBJ)ospvRandomRef;

    OSPM_DBGENTER(("ENTER: SSLREF_Random()\n"));
    if ((result = B_GenerateRandomBytes(random, ospvBuffer.data, 
        ospvBuffer.length, (A_SURRENDER_CTX *)NULL_PTR)) != 0)
        sslref_errcode = SSLUnknownErr;
#endif /* BSAFE / RSAREF */

    OSPM_DBGEXIT(("EXIT : SSLREF_Random() (%d)\n", sslref_errcode));
    return sslref_errcode;
}

/* Seed the random number generator with the time. This is an
 *  extremely bad way to seed a secure random number generator
 *  and basically sacrifices all security, but suffices for
 *  an implementation example. In other words, CHANGE THIS!
 */
SSLErr
    SSLREF_SeedRandom(void **ospvRandomRef)
{  
    time_t t              = 0;
    int    rsaResult      = 0;
    SSLErr sslref_errcode = SSLNoErr;

#if RSAREF
    unsigned int            bytesNeeded;
    static R_RANDOM_STRUCT  rsaRandom;

    OSPM_DBGENTER(("ENTER: SSLREF_SeedRandom()\n"));
    *ospvRandomRef = 0;
    t = time(0);

    if (R_RandomInit(&rsaRandom) != 0)
    {
        sslref_errcode = SSLUnknownErr;
    }
    else
    {
        if (R_GetRandomBytesNeeded(&bytesNeeded, &rsaRandom) != 0)
        {
            sslref_errcode = SSLUnknownErr;
        }
        else
        { 
            while (bytesNeeded > 0)
            {   
                if ((rsaResult = R_RandomUpdate(&rsaRandom, (unsigned char*)&t, 
                    sizeof(time_t))) != 0)
                {
                    sslref_errcode = SSLUnknownErr;
                    break;
                }

                if (bytesNeeded >= sizeof(time_t))
                    bytesNeeded -= sizeof(time_t);
                else
                    bytesNeeded = 0;
            }

            *ospvRandomRef = &rsaRandom;
        }
    }
#elif BSAFE
    static B_ALGORITHM_OBJ  random;
    B_ALGORITHM_METHOD      *chooser[] = { &AM_MD5_RANDOM, 0 };

    OSPM_DBGENTER(("ENTER: SSLREF_SeedRandom()\n"));
    if ((rsaResult = B_CreateAlgorithmObject(&random)) != 0)
    {
        sslref_errcode = SSLUnknownErr;
    }
    else
    {
        if ((rsaResult = B_SetAlgorithmInfo(random, AI_MD5Random, 0)) != 0)
        {
            sslref_errcode = SSLUnknownErr;
        }
        else
        {
            if ((rsaResult = B_RandomInit(random, chooser, NO_SURR)) != 0)
            {
                sslref_errcode = SSLUnknownErr;
            }
            else
            { 
                t = time(0);

                if ((rsaResult = B_RandomUpdate(random, (unsigned char*)&t, sizeof(t), 
                    NO_SURR)) != 0)
                {
                    sslref_errcode = SSLUnknownErr;
                }
                else
                    *ospvRandomRef = &random;
            }
        }
    }
#endif /* BSAFE / RSAREF */

    OSPM_DBGEXIT(("EXIT : SSLREF_SeedRandom() (%d)\n", sslref_errcode));
    return sslref_errcode;
}

SSLErr
    SSLREF_Time( 
    uint32 *ospvTimeResult, 
    void   *ospvTimeRef)
{   
    OSPTTIME t;

    OSPM_DBGENTER(("ENTER: SSLREF_Time()\n"));
    OSPM_ARGUSED(ospvTimeRef);
    t = time(0);
    *ospvTimeResult = (uint32)t;
    OSPM_DBGEXIT(("EXIT : SSLREF_Time()\n"));
    return SSLNoErr;
}

SSLErr
    SSLREF_ConvertTime(
    uint32 *ospvTime, 
    void   *ospvTimeRef)
{
    OSPM_DBGENTER(("ENTER: SSLREF_ConvertTime()\n"));
    *ospvTime -= 20000;
    OSPM_ARGUSED(ospvTimeRef);
    OSPM_DBGEXIT(("EXIT : SSLREF_ConvertTime()\n"));
    return SSLNoErr;
}

SSLErr
    SSLREF_ClientRead(
    SSLBuffer ospvBuffer, 
    uint32   *ospvProcessed, 
    void     *ospvConnection)
{
    int      errorcode      = OSPC_ERR_NO_ERROR;
    SSLErr   sslref_errcode = SSLNoErr;

    OSPM_DBGENTER(("ENTER: SSLREF_ClientRead()\n"));
    errorcode = OSPPSockRead((OSPTHTTP *)ospvConnection, ospvBuffer.data, 
        (unsigned int *)&ospvBuffer.length);

    *ospvProcessed = ospvBuffer.length;

    if (errorcode != OSPC_ERR_NO_ERROR)
        sslref_errcode = SSLIOErr;

    OSPM_DBGEXIT(("EXIT : SSLREF_ClientRead() (%d)\n", sslref_errcode));
    return sslref_errcode;
}

SSLErr
    SSLREF_ClientWrite(
    SSLBuffer ospvBuffer, 
    uint32   *ospvProcessed, 
    void     *ospvConnection)
{
    int      errorcode      = OSPC_ERR_NO_ERROR;
    SSLErr   sslref_errcode = SSLNoErr;

    OSPM_DBGENTER(("ENTER: SSLREF_ClientWrite()\n"));
    errorcode = OSPPSockWrite((OSPTHTTP *)ospvConnection, ospvBuffer.data, 
        (unsigned int *)&ospvBuffer.length);

    *ospvProcessed = ospvBuffer.length;

    if (errorcode != OSPC_ERR_NO_ERROR)
        sslref_errcode = SSLIOErr;

    OSPM_DBGEXIT(("EXIT : SSLREF_ClientWrite() (%d)\n", sslref_errcode));
    return sslref_errcode;
}

SSLErr
    SSLREF_AddSessionId(
    SSLBuffer  ospvKey, 
    SSLBuffer  ospvData, 
    void      *ospvSessionRef)
{
    OSPTSEC           *security       = OSPC_OSNULL;
    OSPTSVCPT         *servicepoint   = OSPC_OSNULL;
    SSLErr             sslref_errcode = SSLNoErr;
    int                errorcode      = OSPC_ERR_NO_ERROR;

    OSPM_DBGENTER(("ENTER: SSLREF_AddSessionId()\n"));
    OSPM_ARGUSED(ospvKey);

    if (ospvSessionRef == OSPC_OSNULL)
    {
        sslref_errcode = SSLMemoryErr;
    }
    else
    {
        servicepoint = ((OSPTHTTP *)ospvSessionRef)->ServicePoint;
        security = OSPPHttpGetSecurity((OSPTHTTP *)ospvSessionRef);

        if (servicepoint == OSPC_OSNULL || security == OSPC_OSNULL)
        {
            sslref_errcode = SSLMemoryErr;
        }
        else
        {
            errorcode = OSPPSecSSLSessionIdNew(security, ospvData.length, ospvData.data,
                servicepoint->HostName, servicepoint->Port);
            if (errorcode != OSPC_ERR_NO_ERROR)
            {
                sslref_errcode = SSLMemoryErr;
            }
        }
    }
    OSPM_DBGEXIT(("EXIT : SSLREF_AddSessionId() (%d)\n", sslref_errcode));
    return sslref_errcode;
}

SSLErr
    SSLREF_GetSessionId(
    SSLBuffer  ospvKey, 
    SSLBuffer *ospvData, 
    void      *ospvSessionRef)
{
    OSPTSEC        *security       = OSPC_OSNULL;
    OSPTSVCPT      *servicepoint   = OSPC_OSNULL;
    SSLErr          sslref_errcode = SSLNoErr;
    int             errorcode      = OSPC_ERR_NO_ERROR;

    OSPM_DBGENTER(("ENTER: SSLREF_GetSessionId()\n"));
    OSPM_ARGUSED(ospvKey);

    if (ospvSessionRef == OSPC_OSNULL)
    {
        sslref_errcode = SSLMemoryErr;
    }
    else
    {
        servicepoint = ((OSPTHTTP *)ospvSessionRef)->ServicePoint;
        security = OSPPHttpGetSecurity((OSPTHTTP *)ospvSessionRef);

        if (servicepoint == OSPC_OSNULL || security == OSPC_OSNULL)
        {
            sslref_errcode = SSLMemoryErr;
        }
        else
        {
            errorcode = OSPPSecSSLSessionIdGet(security, &(ospvData->length), 
                &(ospvData->data), servicepoint->HostName, servicepoint->Port);
            if (errorcode != OSPC_ERR_NO_ERROR)
            {
                sslref_errcode = SSLSessionNotFoundErr;
            }
        }
    }
    OSPM_DBGEXIT(("EXIT : SSLREF_GetSessionId() (%d)\n", sslref_errcode));
    return sslref_errcode;
}

SSLErr
    SSLREF_DeleteSessionId(
    SSLBuffer  ospvKey, 
    void      *ospvSessionRef)
{    
    OSPTSEC          *security       = OSPC_OSNULL;
    OSPTSSLSESSION   *session        = OSPC_OSNULL;
    SSLErr            sslref_errcode = SSLNoErr;

    OSPM_DBGENTER(("ENTER: SSLREF_DeleteSessionId()\n"));
    OSPM_ARGUSED(ospvKey);

    if (ospvSessionRef == OSPC_OSNULL)
    {
        sslref_errcode = SSLMemoryErr;
    }
    else
    {
        security = OSPPHttpGetSecurity((OSPTHTTP *)ospvSessionRef);
        session  = ((OSPTHTTP *)ospvSessionRef)->SSLSession;

        if (security != OSPC_OSNULL && OSPPSSLSessionHasSessionId(session))
        {
            OSPPSecSSLSessionIdDelete(security, &(session->SessionId), OSPC_TRUE);
        } 
        else
        {
            sslref_errcode = SSLSessionNotFoundErr;
        }
    }
    OSPM_DBGEXIT(("EXIT : SSLREF_DeleteSessionId() (%d)\n", sslref_errcode));
    return sslref_errcode;
}