pix_handle_stats.c

Exemplo de configuração do cache de conexões HTTP do PIX e leitura dos contadores do handle e do cache.

Veja Nota sobre os exemplos.

#include <string.h>
#include <stdlib.h>
#include <stdio.h>
 
#include <dinamo.h> /* header do Dinamo */
 
#define HOST_ADDR       "127.0.0.1"
#define USER_ID         "master"
#define USER_PWD        "12345678"
 
int main()
{
    int nRet = 0;
    struct AUTH_PWD authPwd;
    HPIXSESSIONCTX hPIXSession = NULL;
 
    const char szKeyId[] = "key";
    const char szKeyCert[] = "key_cert";
    const char szPIXChain[] = "pix_chain";
 
    const char szUrl[] = "https://127.0.0.1:8000";
 
    BYTE pbTestData[] = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?><xml>sdfsdf</xml>";
 
    DWORD dwMaxHandles = 6;   //Teto de conexões simultâneas. Zero, o padrão, é sem limite.
    DWORD dwIdleTTL = 300;    //Segundos até uma conexão ociosa do cache ser fechada.
 
    PIX_REQUEST stRequest;
    PIX_RESPONSE stResponse;
    PIX_HANDLE_STATS stHandleStats;
    PIX_POOL_STATS stPoolStats;
    PIX_HTTP_REQUEST_DETAILS stDetails;
    DWORD dwDataLen = 0;
    ND_uint64_t nHttpRet = 0;
 
    //Inicializa as bibliotecas do Dinamo
    nRet = DInitialize(0);
 
    if (nRet) {
        printf("Falha na funcao: DInitialize \nCodigo de erro: %d\n", nRet);
        goto clean;
    }
 
    printf("Bibliotecas inicializadas.\n");
 
    /*
        O cache é de escopo da biblioteca, então é configurado antes de qualquer tráfego.
        Como cada conexão do cache é um handle, PIXCP_MAX_HANDLES é o próprio limite de
        conexões apresentado ao peer.
    */
    nRet = DPIXSetCacheParam(PIXCP_MAX_HANDLES, (BYTE *)&dwMaxHandles, sizeof(dwMaxHandles), 0);
 
    if (nRet) {
        printf("Falha na funcao: DPIXSetCacheParam \nCodigo de erro: %d\n", nRet);
        goto clean;
    }
 
    nRet = DPIXSetCacheParam(PIXCP_IDLE_TTL, (BYTE *)&dwIdleTTL, sizeof(dwIdleTTL), 0);
 
    if (nRet) {
        printf("Falha na funcao: DPIXSetCacheParam \nCodigo de erro: %d\n", nRet);
        goto clean;
    }
 
    printf("Cache de conexoes HTTP configurado.\n");
 
    //Inicializa a estrutura para conexão com o HSM
    memset(&authPwd, 0, sizeof(authPwd));
    strncpy(authPwd.szAddr, HOST_ADDR, sizeof(authPwd.szAddr));
    authPwd.nPort = DEFAULT_PORT;
    strncpy(authPwd.szUserId, USER_ID, sizeof(authPwd.szUserId));
    strncpy(authPwd.szPassword, USER_PWD, sizeof(authPwd.szPassword));
 
    nRet = DPIXOpenHandle(&hPIXSession,
                          szKeyId,
                          szKeyCert,
                          szPIXChain,
                          SS_USER_PWD,
                          (BYTE *)&authPwd,
                          sizeof(authPwd),
                          ENCRYPTED_CONN,
                          0);
    if (nRet) {
        printf("Falha na funcao: DPIXOpenHandle \nCodigo de erro: %d\n", nRet);
        goto clean;
    }
 
    memset(&stRequest, 0, sizeof(stRequest));
    stRequest.dwVersion = PIX_REQUEST_VERSION;
    stRequest.dwMethod = PIX_HTTP_POST;
    stRequest.szURL = szUrl;
    stRequest.pbBody = pbTestData;
    stRequest.dwBodyLen = sizeof(pbTestData) - 1;
    stRequest.dwTimeOut = 30000;
 
    memset(&stResponse, 0, sizeof(stResponse));
    stResponse.dwVersion = PIX_RESPONSE_VERSION;
 
    nRet = DPIXRequest(hPIXSession, &stRequest, &stResponse, 0);
 
    if (nRet) {
        printf("Falha na funcao: DPIXRequest \nCodigo de erro: %d\n", nRet);
        goto clean;
    }
 
    DPIXFreeResponse(&stResponse);
 
    printf("PIX post executado com sucesso.\n");
 
    /* ---- Contadores do handle ---------------------------------------------------- */
 
    //Código HTTP da última requisição feita com este handle.
    dwDataLen = sizeof(nHttpRet);
    nRet = DPIXGetHandleParam(hPIXSession, PIXP_HTTP_RET, (BYTE *)&nHttpRet, &dwDataLen, 0);
 
    if (nRet) {
        printf("Falha na funcao: DPIXGetHandleParam \nCodigo de erro: %d\n", nRet);
        goto clean;
    }
 
    printf("Codigo HTTP da ultima requisicao: %llu\n", nHttpRet);
 
    //Tempos da última requisição.
    memset(&stDetails, 0, sizeof(stDetails));
    dwDataLen = sizeof(stDetails);
    nRet = DPIXGetHandleParam(hPIXSession, PIXP_HTTP_REQ_DETAILS, (BYTE *)&stDetails, &dwDataLen, 0);
 
    if (nRet) {
        printf("Falha na funcao: DPIXGetHandleParam \nCodigo de erro: %d\n", nRet);
        goto clean;
    }
 
    printf("Tempo total: %llu ms, handshake TLS: %llu ms.\n",
           (unsigned long long)stDetails.total_time,
           (unsigned long long)stDetails.appconnect_time);
 
    /*
        Contadores acumulados deste handle. Assim como em PIX_POOL_STATS, dwVersion informa
        à biblioteca qual leiaute o chamador conhece, e precisa ser preenchida antes da
        chamada.
    */
    memset(&stHandleStats, 0, sizeof(stHandleStats));
    stHandleStats.dwVersion = PIX_HANDLE_STATS_VERSION;
    dwDataLen = sizeof(stHandleStats);
    nRet = DPIXGetHandleParam(hPIXSession, PIXP_STATS, (BYTE *)&stHandleStats, &dwDataLen, 0);
 
    if (nRet) {
        printf("Falha na funcao: DPIXGetHandleParam \nCodigo de erro: %d\n", nRet);
        goto clean;
    }
 
    printf("Handle: %llu handshake(s) TLS, %llu assinatura(s) no HSM.\n",
           (unsigned long long)stHandleStats.ssl_hook_count,
           (unsigned long long)stHandleStats.hsm_sign_count);
 
    /* ---- Contadores do cache ------------------------------------------------------ */
 
    //Aqui dwVersion precisa ser informada antes da chamada.
    memset(&stPoolStats, 0, sizeof(stPoolStats));
    stPoolStats.dwVersion = PIX_POOL_STATS_VERSION;
    dwDataLen = sizeof(stPoolStats);
    nRet = DPIXGetCacheParam(PIXCP_STATS, (BYTE *)&stPoolStats, &dwDataLen, 0);
 
    if (nRet) {
        printf("Falha na funcao: DPIXGetCacheParam \nCodigo de erro: %d\n", nRet);
        goto clean;
    }
 
    printf("Cache: %llu conexao(oes) viva(s), maximo ja atingido %llu.\n",
           (unsigned long long)stPoolStats.handles_live,
           (unsigned long long)stPoolStats.handles_high_water);
 
    /*
        Uma assinatura no HSM acontece a cada handshake completo. Quando hsm_sign_count
        fica abaixo de ssl_hook_count, a diferença são as sessões TLS retomadas: o
        handshake retomado não envia CertificateVerify e portanto não usa a chave do HSM.
    */
    printf("Cache: %llu handshake(s) TLS, %llu assinatura(s) no HSM, %llu retomada(s).\n",
           (unsigned long long)stPoolStats.ssl_hook_count,
           (unsigned long long)stPoolStats.hsm_sign_count,
           (unsigned long long)(stPoolStats.ssl_hook_count - stPoolStats.hsm_sign_count));
 
    /*
        Marca as conexões do cache para serem fechadas.
    */
    nRet = DPIXSetCacheParam(PIXCP_CLEAR, NULL, 0, 0);
 
    if (nRet) {
        printf("Falha na funcao: DPIXSetCacheParam \nCodigo de erro: %d\n", nRet);
        goto clean;
    }
 
    printf("Cache de conexoes HTTP marcado para fechamento.\n");
 
clean:
 
    if (hPIXSession) {
        DPIXCloseHandle(&hPIXSession, 0);
        printf("Handle PIX encerrado.\n");
    }
 
    DFinalize();
    printf("Bibliotecas finalizada.\n");
 
    return nRet;
}