pix_handle_no_cache.c

Example of a caller-specific (uncached) ` PIX ` handle that maintains its own HTTP connection with a GET request.

See Note on examples.

#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";
 
    PIX_REQUEST stRequest;
    PIX_RESPONSE stResponse;
 
    //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");
 
    //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));
 
    /*
        DN_PIX_NO_CACHE: o handle é exclusivo deste chamador e mantém a própria conexão
        HTTP até DPIXCloseHandle(), em vez de pegar uma emprestada do cache a cada
        requisição.
 
        É o que o SPI precisa: como cada handle é exatamente uma conexão, a contagem de
        handles abertos é a contagem de conexões apresentada ao BACEN. Para manter N
        conexões, abra N handles e conserve-os.
    */
    nRet = DPIXOpenHandle(&hPIXSession,
                          szKeyId,
                          szKeyCert,
                          szPIXChain,
                          SS_USER_PWD,
                          (BYTE *)&authPwd,
                          sizeof(authPwd),
                          ENCRYPTED_CONN,
                          DN_PIX_NO_CACHE);
    if (nRet) {
        printf("Falha na funcao: DPIXOpenHandle \nCodigo de erro: %d\n", nRet);
        goto clean;
    }
 
    printf("Handle PIX exclusivo criado.\n");
 
    memset(&stRequest, 0, sizeof(stRequest));
    stRequest.dwVersion = PIX_REQUEST_VERSION;
    stRequest.dwMethod = PIX_HTTP_GET;
    stRequest.szURL = szUrl;
    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;
    }
 
    printf("PIX GET executado com sucesso. HTTP %llu, %u bytes de corpo.\n",
           stResponse.nHttpCode,
           stResponse.dwBodyLen);
 
    DPIXFreeResponse(&stResponse);
 
clean:
 
    /*
        Fechar o handle encerra a conexão HTTP que ele mantinha. Em um handle com cache
        a conexão continuaria no cache, disponível para o próximo handle.
    */
    if (hPIXSession) {
        DPIXCloseHandle(&hPIXSession, 0);
        printf("Handle PIX encerrado.\n");
    }
 
    DFinalize();
    printf("Bibliotecas finalizada.\n");
 
    return nRet;
}