Converter um Zip para o tipo Binário

[leohpaim]

Estou desenvolvendo a comunicação do meu sistema para enviar dados de Redução Z para o Fisco. No manual solicitaram que seja feito o envio do arquivo Xml Zipado. Com isso devemos converter esse Zip para o tipo Binário primeiramente. Alguém saberia como posso proceder para fazer essa conversão?

[leohpaim]

Amigos, consegui a implementação da função que faz a Codificação na base 64. Os passos que utilizei foram os seguintes:

• Importar o arquivo em anexo para o compilador. No meu caso inclui na pasta "...\Borland\BCC55\Include".
• Criar uma função em C contendo o seguinte código:

  Código: Selecionar todos

  /*
   * Proyecto: FARMACIA
   * Fichero: Module2.c
   * Descripción:
   * Autor:
   * Fecha: 05-18-2017
   */
  
  /*
   * $Id: base64.c 9999 2014-05-19 10:56:11Z zsaulius $
   */
  
  #define HB_THREAD_OPTIMIZE_STACK
  #ifndef HB_THREAD_SUPPORT
  #define HB_THREAD_STUB
  #endif
  
  // #include "thread.h"
  #include "base64.h"
  #include "hbapi.h"
  #include "hbapifs.h"
  
  #define XTY62  '+'
  #define XTY63  '/'
  #define XTYPAD '='
  
  static char Base64Table[ 64 ] = {
     'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',   'P',
     'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e',   'f',
     'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u',   'v',
     'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', XTY62, XTY63
  };
  
  char * Base64Encode( const unsigned char * pcCode, unsigned int uCodeLen )
  {
     unsigned int i, j = 0, tailCnt = uCodeLen % 3;
     char *       pRet = ( char * ) hb_xgrab( 4 * ( ( uCodeLen + 2 ) / 3 ) + 1 );
  
     //uCodeLen/3 segments.
     for( i = 0; i < uCodeLen / 3; i++, pcCode += 3 )
     {
        pRet[ j++ ] = Base64Table[     pcCode[ 0 ]          >> 2 ];
        pRet[ j++ ] = Base64Table[ ( ( pcCode[ 0 ] & 0x03 ) << 4 ) | ( pcCode[ 1 ] >> 4 ) ];
        pRet[ j++ ] = Base64Table[ ( ( pcCode[ 1 ] & 0x0F ) << 2 ) | ( pcCode[ 2 ] >> 6 ) ];
        pRet[ j++ ] = Base64Table[     pcCode[ 2 ] & 0x3F ];
     }
  
     if( tailCnt )
     {
        pRet[ j++ ] = Base64Table[ pcCode[ 0 ] >> 2 ];
  
        if( tailCnt == 1 )
        {
           pRet[ j++ ] = Base64Table[ ( pcCode[ 0 ] & 0x03 ) << 4 ];
           pRet[ j++ ] = XTYPAD;
        }
        else if( tailCnt == 2 )
        {
           pRet[ j++ ] = Base64Table[ ( ( pcCode[ 0 ] & 0x03 ) << 4 ) | ( pcCode[ 1 ] >> 4 ) ];
           pRet[ j++ ] = Base64Table[   ( pcCode[ 1 ] & 0x0F ) << 2 ];
        }
        pRet[ j++ ] = XTYPAD;
     }
  
     pRet[ j ] = '\0';
  
     return pRet;
  }
  
  //assume input != NULL.
  unsigned char * Base64Decode( const char * pcszInput, unsigned int * puOutLen )
  {
     int             iSize = strlen( pcszInput ) + 1;
     char            map[ 256 ], i, c, * pBuf = ( char * ) hb_xgrab( iSize );
     unsigned int    j, uBufLen;
     unsigned int    uSegCnt;
     unsigned int    uTailCnt;
     unsigned char * pRet, * pTmp;
     char *          ptr;
  
     memset( map, 0xFF, 256 );
     for( i = 'A', map[(unsigned char) 'A' ] =  0; i <  'Z'; map[(unsigned char) i + 1 ] = map[(unsigned char) i ] + 1, i++ );
     for( i = 'a', map[(unsigned char) 'a' ] = 26; i <= 'z'; map[ (unsigned char)i + 1 ] = map[(unsigned char) i ] + 1, i++ );
     for( i = '0', map[(unsigned char) '0' ] = 52; i <= '9'; map[ (unsigned char)i + 1 ] = map[(unsigned char) i ] + 1, i++ );
     map[ XTY62 ] = 62; map[ XTY63 ] = 63;
  
     uBufLen = 0;
     c       = pcszInput[ 0 ];
     while( c != '\0' && c != XTYPAD )
     {
        pBuf[ uBufLen ] = map[ (unsigned char)c ];
  
        if( pBuf[ uBufLen ] >= 0 )
           uBufLen++;
        c = *( ++pcszInput );
     }
  
     pBuf[ uBufLen ] = '\0';
  
     uSegCnt = uBufLen / 4;
     pRet    = ( unsigned char * ) hb_xgrab( ( uSegCnt + 1 ) * 3 );
     pTmp    = pRet;
  
     //full segments.
     ptr = pBuf;
     for( j = 0; j < uSegCnt; j++ )
     {
        *pTmp++ = ( ( ptr[ 0 ] << 2 ) | ( ptr[ 1 ] >> 4 ) );
        *pTmp++ = ( ( ptr[ 1 ] << 4 ) | ( ptr[ 2 ] >> 2 ) );
        *pTmp++ = ( unsigned char ) ( ( ptr[ 2 ] << 6 ) |   ptr[ 3 ] );
        ptr    += 4;
     }
  
     *puOutLen = uSegCnt * 3;
     uTailCnt  = uBufLen % 4;
  
     if( uTailCnt == 2 )
     {
        *pTmp = ( ( ptr[ 0 ] << 2 ) | ( ptr[ 1 ] >> 4 ) );
        ( *puOutLen )++;
     }
     else if( uTailCnt == 3 )
     {
        *pTmp++        = ( ( ptr[ 0 ] << 2 ) | ( ptr[ 1 ] >> 4 ) );
        *pTmp          = ( ( ptr[ 1 ] << 4 ) | ( ptr[ 2 ] >> 2 ) );
        ( *puOutLen ) += 2;
     }
  
     hb_xfree( pBuf );
  
     return pRet;
  }
  
  HB_FUNC( HB_BASE64ENCODE )
  {
     HB_THREAD_STUB
     const unsigned char * pcCode   = ( const unsigned char * ) hb_parcx( 1 );
     unsigned int          uCodeLen = hb_parni( 2 );
     char *                szBase64Encode;
  
     szBase64Encode = Base64Encode( pcCode, uCodeLen );
     hb_retcAdopt( szBase64Encode );
  }
  
  HB_FUNC( HB_BASE64DECODE )
  {
     HB_THREAD_STUB
     const char *    pcCode = hb_parcx( 1 );
     unsigned int    uCodeLen;
     unsigned char * szBase64Encode;
  
     szBase64Encode = Base64Decode( pcCode, &uCodeLen );
  
     hb_retclenAdopt( ( char * ) szBase64Encode, uCodeLen );
  }
  
  static long filelength( int handle )
  {
     long nEnd   = hb_fsSeek( handle, 0, 2 );
     long nStart = hb_fsSeek( handle, 0, 0 );
  
     return nEnd - nStart;
  }
  
  static char * filetoBuff( char * f, const char * s )
  {
  
     int i;
     int fh = hb_fsOpen( s, 2 );
  
     i      = hb_fsReadLarge( fh, ( BYTE * ) f, filelength( fh ) );
     f[ i ] = '\0';
     hb_fsClose( fh );
     return f;
  }
  
  HB_FUNC( HB_BASE64ENCODEFILE )
  {
     HB_THREAD_STUB
     const char *   szInFile    = hb_parcx( 1 );
     const char *   szOutFile   = hb_parcx( 2 );
     const char *   pcCode;
     char *         FromBuffer;
     int            fh;
     int            iSize;
     char *         szBase64Encode;
  
     fh             = hb_fsOpen( szInFile, 2 );
     iSize          = filelength( fh );
     FromBuffer     = ( char * ) hb_xgrab( iSize + 1 );
     hb_fsClose( fh );
     pcCode         = ( char * ) filetoBuff( FromBuffer, szInFile );
     szBase64Encode = Base64Encode( ( const unsigned char * ) pcCode, iSize );
     fh             = hb_fsCreate( szOutFile, 0 );
     hb_fsWriteLarge( fh, szBase64Encode, strlen( szBase64Encode ) );
     hb_fsClose( fh );
     hb_xfree( FromBuffer );
     hb_xfree( szBase64Encode );
  }
  
  HB_FUNC( HB_BASE64DECODEFILE )
  {
     HB_THREAD_STUB
     const char *   szInFile    = hb_parcx( 1 );
     const char *   szOutFile   = hb_parcx( 2 );
     const char *   pcCode;
     char *         FromBuffer;
     int            fh;
     unsigned int   iSize;
     char *         szBase64Encode;
  
     fh             = hb_fsOpen( szInFile, 2 );
     iSize          = filelength( fh );
     FromBuffer     = ( char * ) hb_xgrab( iSize + 1 );
     hb_fsClose( fh );
     pcCode         = ( char * ) filetoBuff( FromBuffer, szInFile );
     szBase64Encode = ( char * ) Base64Decode( pcCode, &iSize  );
     fh             = hb_fsCreate( szOutFile, 0 );
     hb_fsWriteLarge( fh, szBase64Encode, strlen( szBase64Encode ) );
     hb_fsClose( fh );
     hb_xfree( FromBuffer );
  }
  
  

• Chamar normalmente a função para Codificar o arquivo desejado. No meu caso utilizei somente a "HB_BASE64ENCODEFILE" mas pelo código é possível utilizar mais 3 funções de codificação e decodificação: "HB_BASE64DECODEFILE", "HB_BASE64ENCODE" e "HB_BASE64DECODE".

Fica aqui minha contribuição para o fórum.

[asimoes]

Obrigado pela contribuição.

Tem como postar um exemplo prático?

[asimoes]

Segue o seu exemplo modificado para funcionar com harbour 3.4 + MinGW

ROTINA.C

(5.83 KiB) Baixado 208 vezes

[leohpaim]

No meu caso precisei Zipar um arquivo XML, transformar esse arquivo em uma string para o formato binário na base de 64 e fazer o envio para o servidor.

Como exemplo realizei a chamada da Função "HB_BASE64ENCODEFILE" passando como parâmetro o nome do arquivo que seria codificado e o nome do arquivo que salva o código do zip convertido:

Um exemplo: Meu arquivo que será codificado está no diretório "D:", logo passo para o primeiro parâmetro da minha função o caminho "D:\XmlEnvioRZ.zip". A função de Encode gera um arquivo TXT contendo o código do zip codificado, logo o segundo parâmetro da função é o nome do arquivo que será gerado ao executá-la, utiliza-se por exemplo "D:\xmlCodificado.txt"

Caso utilize um método de decodificação o resultado é novamente o arquivo zipado.

[card0z0]

Boa, vou utilizar e depois deixo meu comentário. Obrigado
_____________________________________________________________________________________________________
"Cada um trabalha como quer, mas pagar imposto temos que ser iguais! nesse país não há trégua..."

[Mario Mesquita]

Boa noite a todos.

Não tem função nativa do Harbour para realizar essa conversão?

Precisando dessa dica, tenho que converter um .zip e um .pdf para um tal de Encode 64.

Desde já agradeço a ajuda.

Sds,
Mario.

[Mario Mesquita]

Boa tarde.

Aliás, vi que existe uma função chamada Hb_Base64EncodeFile() que converte arquivos para esse formato "Encode 64" se é que é assim que se chama.

Pergunta: Tem essa função no Harbour? Procurando em manuais on-line não estou encontrando.

Não é uma coisa nova, deve haver algo similiar, se não tem a função no Harbour.

Desde já, agradeço a dica.

Abraço a todos,
Mario.

[Mario Mesquita]

Boa tarde.

Tentei usar a função Hb_Base64EncodeFile(), mas ela não deve mesmo fazer parte do Harbour. Mas tem no xHarbour... Incrível não ter isso pronto pra uso.

Essa alternativa postada, como posso colar no meu programa? Compila em C ou pode compilar no Harbour mesmo? Pra variar, não tenho experiência com isso, se alguém puder dar uma dica, desde já agradeço.

Saudações,
Mario.

[Mario Mesquita]

Boa tarde a todos.

Consegui um utilitário que faz a conversão de arquivos para binário. Testei com um PDF e funcionou bem. Por ser um .exe dá pra embutir no programa e executar com o Run.

Se quiserem, anexo ele pra galera testar. Vai me resolver um problemão.

Sds,
Mario.