spbencdec.c

Exemplo de SPB para encode e decode de mensagens.

Veja Nota sobre os exemplos.

#include <stdio.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <dinamo.h>

#ifdef WIN32
    #include <process.h>
    #define FSTAT(x,y)  _fstat(_fileno(x), y)
    #define STAT        _stat
#else
    #define FSTAT(x,y)  fstat(fileno(x),y)
    #define STAT        stat
#endif

/* Parametros da conexao */
#define   HSM_USR   "user"
#define   HSM_IP   "10.0.62.10"
#define   HSM_PWD   "12345678"


int main(void)
{
    int      nRet                          = 0;

    /* parametros de origem e destino da mensagem  */

    char   *szSrcISPB                      = "12345678";
    char   *szDstISPB                      = "12345678";
    char   *szFileClear                    = "message.txt";
    char   *szFileEncoded                  = "message.txt.enc";
    char   *szFileDecoded                  = "message.txt.dec";

    BYTE   *pbMsgOutDec                    = NULL;
    DWORD   dwMsgOutDecLen                 = 0;
    HSPBCTX   hEncSPB                      = NULL;
    HSPBCTX   hDecSPB                      = NULL;

    FILE *pfFileClear                      = NULL;
    struct STAT stClearStat;
    DWORD   dwFileClearLen                 = 0;

    FILE *pfFileEncoded                    = NULL;
    struct STAT stEncodedStat;
    DWORD   dwFileEncodedLen               = 0;

    FILE *pfFileDecoded                    = NULL;

    BYTE   pbBufferRead[ND_SPB_MAX_NOTIFY_DATA_SEG]   = {0};
    DWORD   dwBufferReadLen                = 0;
    BYTE   pbBufferWrite[ND_SPB_MAX_NOTIFY_DATA_SEG]   = {0};
    DWORD   dwBufferWriteLen               = 0;

    struct AUTH_PWD_EX stAUTPWD           = {0};
    HSESSIONCTX   hSession                = NULL;

    // Preenche a estrutura de usuario
    strncpy(stAUTPWD.szAddr, HSM_IP, sizeof(stAUTPWD.szAddr));
    strncpy(stAUTPWD.szUserId, HSM_USR, sizeof(stAUTPWD.szUserId));
    strncpy(stAUTPWD.szPassword, HSM_PWD, sizeof(stAUTPWD.szPassword));
    stAUTPWD.nPort = DEFAULT_PORT;
    stAUTPWD.nStrongAuthLen = 0;
    stAUTPWD.pbStrongAuth = NULL;
    stAUTPWD.dwAuthType = SA_AUTH_NONE;

    DInitialize(0);

    nRet = DOpenSession(&hSession, SS_USR_PWD_EX, (BYTE *) &stAUTPWD, sizeof(struct AUTH_PWD_EX), CACHE_BYPASS | LB_BYPASS | ENCRYPTED_CONN  );
    
    if(nRet) {
        printf("DOpenSession : Failed! %d.\n", nRet);
        goto clean;
    }

    /*  Encode  */

    pfFileClear = fopen(szFileClear, "rb");
    if (NULL == pfFileClear) {
        printf("fopen : Failed! %s.\n", szFileClear);
        goto clean;
    }

    pfFileEncoded = fopen(szFileEncoded, "wb");
    if (NULL == pfFileEncoded) {
        printf("fopen : Failed! %s.\n", szFileEncoded);
        goto clean;
    }

    FSTAT(pfFileClear, &stClearStat);
    dwFileClearLen = stClearStat.st_size;

    nRet = DSPBEncodeInit (hSession, szSrcISPB, szDstISPB, dwFileClearLen, 0x00, 0x00, &hEncSPB,0);

    if( nRet ) {
        printf("DSPBEncodeInit : Failed! %d.\n", nRet);
        goto clean;
    }

    //Reserve header memory space in output file
    if( 1 > fwrite(pbBufferWrite, ND_SPB_MSG_HEADER_V2_LEN, 1, pfFileEncoded) ) {
        printf("fwrite(%s) : Failed!\n", szFileEncoded);
        goto clean;
    }

    //Read, Encode and Write
    while( !feof(pfFileClear) ) {

        dwBufferWriteLen = sizeof(pbBufferWrite);
        dwBufferReadLen = (DWORD)fread(pbBufferRead, 1, sizeof(pbBufferRead), pfFileClear);
        nRet = DSPBEncodeCont (   hEncSPB, pbBufferRead, dwBufferReadLen, pbBufferWrite, &dwBufferWriteLen );

        if( nRet ) {
            printf("DSPBEncodeCont : Failed! %d.\n", nRet);
            goto clean;
        }

        if(1 < fwrite(pbBufferWrite, dwBufferWriteLen, 1, pfFileEncoded) ) {
            printf("fwrite(%s) : Failed!\n", szFileEncoded);
            goto clean;
        }
    }

    fclose(pfFileClear);
    pfFileClear = NULL;

    dwBufferWriteLen = ND_SPB_MSG_HEADER_V2_LEN;
    nRet = DSPBEncodeEnd (&hEncSPB,  pbBufferWrite, &dwBufferWriteLen );

    if( nRet ) {
        printf("DSPBEncodeEnd : Failed! %d.\n", nRet);
        goto clean;
    }

    //Write header at the beginning
    if( fseek(pfFileEncoded, 0, SEEK_SET) ) {
        printf("fseek(%s) : Failed!\n", szFileEncoded);
        goto clean;
    }

    if(1 < fwrite(pbBufferWrite, dwBufferWriteLen, 1, pfFileEncoded) ) {
        printf("fwrite(%s) : Failed!\n", szFileEncoded);
        goto clean;
    }

    fclose(pfFileEncoded);
    pfFileEncoded = NULL;

    /*  Decode  */

    pfFileEncoded = fopen(szFileEncoded, "rb");

    if (NULL == pfFileEncoded) {
        printf("fopen : Failed! %s.\n", szFileEncoded);
        goto clean;
    }

    pfFileDecoded = fopen(szFileDecoded, "wb");

    if (NULL == pfFileDecoded) {
        printf("fopen : Failed! %s.\n", szFileDecoded);
        goto clean;
    }

    FSTAT(pfFileEncoded, &stEncodedStat);
    dwFileEncodedLen = stEncodedStat.st_size;

    dwBufferReadLen = (DWORD)fread(pbBufferRead, 1, ND_SPB_MSG_HEADER_V2_LEN, pfFileEncoded);
    if(dwBufferReadLen < ND_SPB_MSG_HEADER_V2_LEN ) {
        printf("fread(%s) : Failed!\n", szFileEncoded);
        goto clean;
    }

    nRet = DSPBDecodeInit (hSession, szSrcISPB, szDstISPB, pbBufferRead, ND_SPB_MSG_HEADER_V2_LEN, TRUE, FALSE, dwFileEncodedLen - ND_SPB_MSG_HEADER_V2_LEN, &hDecSPB, 0 );
    if( nRet ) {
        printf("DSPBDecodeInit : Failed! %d.\n", nRet);
        goto clean;
    }

    //Read, Decode, Write
    while( !feof(pfFileEncoded) ) {
        dwBufferWriteLen = sizeof(pbBufferWrite);
        dwBufferReadLen = (DWORD)fread(pbBufferRead, 1, sizeof(pbBufferRead), pfFileEncoded);
        nRet = DSPBDecodeCont ( hDecSPB, pbBufferRead, dwBufferReadLen, &pbMsgOutDec, &dwMsgOutDecLen );
        if( nRet ) {
            printf("DSPBDecodeCont : Failed! %d.\n", nRet);
            goto clean;
        }

        if(1 < fwrite(pbMsgOutDec, dwMsgOutDecLen, 1, pfFileDecoded) ) {
            printf("fwrite(%s) : Failed!\n", szFileDecoded);
            goto clean;
        }
    }

    nRet = DSPBDecodeEnd ( &hDecSPB );
    if( nRet ) {
        printf("DSPBDecodeEnd : Failed! %d.\n", nRet);
        goto clean;
    }
      
    clean:

    if( hSession ) {
        DCloseSession(&hSession, 0);
    }

    if( pfFileEncoded ) {
        fclose(pfFileEncoded);
    }

    if( pfFileDecoded ) {
        fclose(pfFileDecoded);
    }

    if( pfFileClear ) {
        fclose(pfFileClear);
    }

    DFinalize();

    return nRet;
}