EmuProxyZA / base64.c

From TivoZA

Back to emuProxyZA.
Download source (You will need to rename it to: base64.c)

To update the below source file, select Upload file and upload your new base64.c file (there is no need to upload it as a .txt). If you do upload a new version, please add a brief description to the change log at the bottom of this page indicating what changes you made and why.

[edit]

Source

  1. /*
  2.  * base64.c
  3.  *
  4.  * Base64 encoding/decoding command line filter
  5.  * http://www.rtner.de/software/base64.html
  6.  *
  7.  * Copyright (c) 2002 Matthias Gaertner 29.06.2002
  8.  *
  9.  * This program is free software; you can redistribute it and/or modify
  10.  * it under the terms of the GNU General Public License as published by
  11.  * the Free Software Foundation; either version 2 of the License, or
  12.  * (at your option) any later version.
  13.  *
  14.  * This program is distributed in the hope that it will be useful,
  15.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17.  * GNU General Public License for more details.
  18.  *
  19.  * You should have received a copy of the GNU General Public License
  20.  * along with this program; if not, write to the Free Software
  21.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22.  */
  23.  
  24. /*
  25.  * Small dedicated Base64 encoder and decoder for the command line.
  26.  *
  27.  * Usage examples:
  28.  *
  29.  * Encode CRL file to Base64 on stdout
  30.  *  base64 foo.crl
  31.  *  base64 -e foo.crl
  32.  *  base64 -in foo.crl
  33.  *  base64 -e -in foo.crl
  34.  *
  35.  * Encode certificate file to PEM-ish Base64 output file foo.pem
  36.  *  base64 -E "CERTIFICATE" foo.crt foo.pem
  37.  *
  38.  * Encode file, output no line breaks in Base64 area. Not recommended with -E.
  39.  *  base64 -n 0 foo.crt
  40.  *
  41.  * Encode file, maximum number of characters per line is 32.
  42.  *  base64 -n 32 foo.crt
  43.  *
  44.  * Decode file to output file
  45.  *  base64 -d foo.pem foo.crt
  46.  *  base64 -d -i foo.pem foo.crt
  47.  *  base64 -d -i foo.pem -o foo.crt
  48.  *
  49.  * Decode file and pipe to next program
  50.  *  base64 -d foo.pem | md5sum
  51.  *  ls / | base64 | base64 -d
  52.  *
  53.  * Invoke as b642bin: decoding is the default.
  54.  *  b642bin foo.pem foo.bin
  55.  *
  56.  * Note: when decoding, this decoder ignores all non-Base64 caharcters.
  57.  * After a hyphen (-) all characters are ignored up to the next \n.
  58.  * The first non-ignored equals sign (=) indicates the end of b64 data.
  59.  */
  60.  
  61. /*
  62.  * Installation:
  63.  * Simply compile with
  64.  *  gcc -O2 -o base64 base64.c
  65.  * then install the executable somewhere on your PATH.
  66.  * Optionally, make a symbolic link to it under the name b642bin
  67.  *  ln -s base64 b642bin
  68.  *
  69.  * De-installation:
  70.  * Remove the installade program and the optional link.
  71.  *
  72.  * Other files are neither needed nor created.
  73.  */
  74.  
  75. #include <stdio.h>
  76. #include <string.h>
  77. #include <stdlib.h>
  78.  
  79. #ifdef WIN32
  80. #ifndef _WIN32
  81. #define _WIN32 1
  82. #endif
  83. #endif
  84.  
  85. #ifdef _WIN32
  86. #include <io.h>
  87. #include <fcntl.h>
  88. #endif
  89.  
  90.  
  91. #ifdef _WIN32
  92. #define STRCMP strcmp
  93. #define USE_CRLF 1
  94. #else
  95. #define STRCMP strcmp
  96. #define USE_LF 1
  97. #endif
  98.  
  99. #ifndef TRUE
  100. #define TRUE 1
  101. #endif
  102. #ifndef FALSE
  103. #define FALSE 0
  104. #endif
  105. #ifndef NULL
  106. #define NULL ((void*)0)
  107. #endif
  108.  
  109.  
  110. #define B64_OK             0
  111. #define B64_ERR_CMDLINE    1
  112. #define B64_ERR_INPUT      2
  113. #define B64_ERR_OUTPUT     3
  114. #define B64_ERR_MEMORY     4
  115. #define B64_ERR_READING    5
  116. #define B64_ERR_WRITING    6
  117. #define B64_ERR_SYNTAX     7
  118.  
  119. #define ENCODE_BUFFER_SIZE_IN (8192*3)
  120. #define ENCODE_BUFFER_SIZE_OUT (8192*6)
  121.  
  122. #define DECODE_BUFFER_SIZE_IN (8192*4)
  123. #define DECODE_BUFFER_SIZE_OUT (8192*3)
  124.  
  125.  
  126. /* Option variables */
  127. static int g_fDecode = FALSE;
  128. static int g_fUseCRLF = FALSE;
  129.  
  130. static char *g_pszFilenameIn = NULL;
  131. static FILE *g_fIn = NULL;
  132.  
  133. static char *g_pszFilenameOut = NULL;
  134. static FILE *g_fOut = NULL;
  135.  
  136. static char *g_pszCharsPerLine = NULL;
  137. static unsigned int g_nCharsPerLine = 64;
  138.  
  139. static char *g_pszHeaderLine = NULL;
  140. static unsigned int g_nHeaderLine = 0;
  141.  
  142.  
  143. static void help( void )
  144. {
  145.     fprintf(stderr,"Base64 [options] [input file] [output file]\n");
  146.     fprintf(stderr,"  options are:\n");
  147.     fprintf(stderr,"  -i <filename> input file (default: stdin)\n");
  148.     fprintf(stderr,"  -o <filename> output file (default: stdout)\n");
  149.     fprintf(stderr,"  -e            encode binary to Base64 (default)\n");
  150.     fprintf(stderr,"  -d            decode Base64 to binary\n");
  151.     fprintf(stderr,"  -n <n>        encode n characters per line (0:no line breaks,default:64)\n");
  152.     fprintf(stderr,"  -E <STRING>   encode and put -----BEGIN/END <STRING>----- around output\n");
  153.     fprintf(stderr,"  --            indicate end of options\n");
  154.     fprintf(stderr,"Call as b642bin to preselect decoding\n");
  155.     fprintf(stderr,"(c) Matthias Gaertner 2002 - v1.00\n\n");
  156.     fprintf(stderr,"This program is distributed in the hope that it will be useful,\n");
  157.     fprintf(stderr,"but WITHOUT ANY WARRANTY; without even the implied warranty of\n");
  158.     fprintf(stderr,"MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n");
  159.     fprintf(stderr,"GNU General Public License for more details.\n");
  160. }
  161.  
  162. static int parseCmdLine( int argc, char **argv )
  163. {
  164.     int r = B64_OK;
  165.     int n = 1;
  166.     int z = 0;  // 0: normal, 1: 2nd argument expected,
  167.                 // 4: end of params detected (--)
  168.     char **ppSecondArg = NULL;
  169.  
  170.     while( n < argc )
  171.     {
  172.         if( z == 4 )
  173.         {
  174.             if( g_pszFilenameIn == NULL )
  175.             {
  176.                 g_pszFilenameIn = argv[n];
  177.             }
  178.             else if( g_pszFilenameIn != NULL && g_pszFilenameOut == NULL )
  179.             {
  180.                 g_pszFilenameOut = argv[n];
  181.             }
  182.         }
  183.         else if( z > 0 )
  184.         {
  185.             *ppSecondArg = argv[n];
  186.             if( z == 2 )
  187.             {
  188.                 // decode bytes per line
  189.                 char *p = *ppSecondArg;
  190.                 g_nCharsPerLine = 0;
  191.                 while( *p >= '0' && *p <= '9' )
  192.                 {
  193.                     g_nCharsPerLine = (g_nCharsPerLine*10)+(*p-'0');
  194.                     p++;
  195.                 }
  196.                 if( *p != '\0' || p == *ppSecondArg )
  197.                 {
  198.                     r = B64_ERR_CMDLINE;
  199.                     break;
  200.                 }
  201.                 if( g_nCharsPerLine > 0 && g_nCharsPerLine < 4 )
  202.                 {
  203.                     g_nCharsPerLine = 4;
  204.                 }
  205.             }
  206.             if( z == 3 )
  207.             {
  208.                 g_nHeaderLine = strlen( *ppSecondArg );
  209.             }
  210.             z = 0;
  211.         }
  212.         else if( STRCMP( argv[n], "-?" ) == 0 )
  213.         {
  214.             help();
  215.             r = B64_ERR_CMDLINE;
  216.             break;
  217.         }
  218.         else if( STRCMP( argv[n], "--help" ) == 0 )
  219.         {
  220.             help();
  221.             r = B64_ERR_CMDLINE;
  222.             break;
  223.         }
  224.         else if( STRCMP( argv[n], "-i" ) == 0 )
  225.         {
  226.             z=1;
  227.             ppSecondArg = &g_pszFilenameIn;
  228.         }
  229.         else if( STRCMP( argv[n], "-o" ) == 0 )
  230.         {
  231.             z=1;
  232.             ppSecondArg = &g_pszFilenameOut;
  233.         }
  234.         else if( STRCMP( argv[n], "-e" ) == 0 )
  235.         {
  236.             g_fDecode = FALSE;
  237.         }
  238.         else if( STRCMP( argv[n], "-E" ) == 0 )
  239.         {
  240.             g_fDecode = FALSE;
  241.             z = 3;
  242.             ppSecondArg = &g_pszHeaderLine;
  243.         }
  244.         else if( STRCMP( argv[n], "-d" ) == 0 )
  245.         {
  246.             g_fDecode = TRUE;
  247.         }
  248.         else if( STRCMP( argv[n], "-n" ) == 0 )
  249.         {
  250.             z = 2;
  251.             ppSecondArg = &g_pszCharsPerLine;
  252.         }
  253.         else if( STRCMP( argv[n], "--" ) == 0 )
  254.         {
  255.             z = 4;
  256.         }
  257.         else if( argv[n][0] == '-' )
  258.         {
  259.             help();
  260.             r = B64_ERR_CMDLINE;
  261.             break;
  262.         }
  263.         else if( g_pszFilenameIn == NULL )
  264.         {
  265.             g_pszFilenameIn = argv[n];
  266.         }
  267.         else if( g_pszFilenameIn != NULL && g_pszFilenameOut == NULL )
  268.         {
  269.             g_pszFilenameOut = argv[n];
  270.         }
  271.         else
  272.         {
  273.             help();
  274.             r = B64_ERR_CMDLINE;
  275.             break;
  276.         }
  277.         n++;
  278.     }
  279.     if( z > 0 )
  280.     {
  281.         r = B64_ERR_CMDLINE;
  282.     }
  283.     return r;
  284. }
  285.  
  286. static int openFiles()
  287. {
  288.     if( g_pszFilenameIn != NULL )
  289.     {
  290.         g_fIn = fopen( g_pszFilenameIn, "rb" );
  291.         if( g_fIn == NULL )
  292.         {
  293.             return B64_ERR_INPUT;
  294.         }
  295.     }
  296.     else
  297.     {
  298.         g_fIn = stdin;
  299. #ifdef WIN32
  300.         _setmode(fileno(stdin), _O_BINARY);
  301. #endif
  302.     }
  303.  
  304.     if( g_pszFilenameOut != NULL )
  305.     {
  306.         g_fOut = fopen( g_pszFilenameOut, "wb" );
  307.         if( g_fOut == NULL )
  308.         {
  309.             return B64_ERR_OUTPUT;
  310.         }
  311.     }
  312.     else
  313.     {
  314.         g_fOut = stdout;
  315. #ifdef WIN32
  316.         setmode(fileno(stdout), O_BINARY);
  317. #endif
  318.     }
  319.  
  320.     return B64_OK;
  321. }
  322.  
  323. static void closeFiles( int r )
  324. {
  325.     if( g_fIn != NULL && g_pszFilenameIn != NULL )
  326.     {
  327.         fclose(g_fIn);
  328.         g_fIn = NULL;
  329.     }
  330.  
  331.     if( g_fOut != NULL && g_pszFilenameOut != NULL )
  332.     {
  333.         fclose(g_fOut);
  334.         g_fOut = NULL;
  335.         if( r != B64_OK )
  336.         {
  337.             unlink( g_pszFilenameOut );
  338.         }
  339.     }
  340. }
  341.  
  342. static const char* to_b64 =
  343.     "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  344.  
  345.  
  346. static int encodeB64(unsigned char* pIn, char *pbBufferOut, unsigned long nRem)
  347. {
  348.             unsigned long nDiv = 0;
  349.             //unsigned long nRem = 0;
  350.             unsigned long nChars = 0;
  351.             //unsigned char* pIn; // = (unsigned char*) pbBufferIn;
  352.  
  353.             unsigned int nOut = 0;
  354.  
  355. 			size_t nRead = strlen(pIn); //???
  356.  
  357.             nDiv = ((unsigned long)nRead) / 3;
  358.             nRem = ((unsigned long)nRead) % 3;
  359.             nChars = 0;
  360.  
  361.             while( nDiv > 0 )
  362.             {
  363.                 pbBufferOut[nOut+0] = to_b64[ (pIn[0] >> 2) & 0x3f];
  364.                 pbBufferOut[nOut+1] = to_b64[((pIn[0] << 4) & 0x30) + ((pIn[1] >> 4) & 0xf)];
  365.                 pbBufferOut[nOut+2] = to_b64[((pIn[1] << 2) & 0x3c) + ((pIn[2] >> 6) & 0x3)];
  366.                 pbBufferOut[nOut+3] = to_b64[  pIn[2] & 0x3f];
  367.                 pIn += 3;
  368.                 nOut += 4;
  369.                 nDiv--;
  370.                 nChars += 4;
  371.                 if( nChars >= g_nCharsPerLine && g_nCharsPerLine != 0 )
  372.                 {
  373.                     nChars = 0;
  374.                     if( g_fUseCRLF )
  375.                     {
  376.                         pbBufferOut[nOut++] = '\r';
  377.                     }
  378.                     pbBufferOut[nOut++] = '\n';
  379.                 }
  380.             }
  381.  
  382.             switch( nRem )
  383.             {
  384.                 case 2:
  385.                     pbBufferOut[nOut+0] = to_b64[ (pIn[0] >> 2) & 0x3f];
  386.                     pbBufferOut[nOut+1] = to_b64[((pIn[0] << 4) & 0x30) + ((pIn[1] >> 4) & 0xf)];
  387.                     pbBufferOut[nOut+2] = to_b64[ (pIn[1] << 2) & 0x3c];
  388.                     pbBufferOut[nOut+3] = '=';
  389.                     nOut += 4;
  390.                     nChars += 4;
  391.                     if( nChars >= g_nCharsPerLine && g_nCharsPerLine != 0 )
  392.                     {
  393.                         nChars = 0;
  394.                         if( g_fUseCRLF )
  395.                         {
  396.                             pbBufferOut[nOut++] = '\r';
  397.                         }
  398.                         pbBufferOut[nOut++] = '\n';
  399.                     }
  400.                     break;
  401.                 case 1:
  402.                     pbBufferOut[nOut+0] = to_b64[ (pIn[0] >> 2) & 0x3f];
  403.                     pbBufferOut[nOut+1] = to_b64[ (pIn[0] << 4) & 0x30];
  404.                     pbBufferOut[nOut+2] = '=';
  405.                     pbBufferOut[nOut+3] = '=';
  406.                     nOut += 4;
  407.                     nChars += 4;
  408.                     if( nChars >= g_nCharsPerLine && g_nCharsPerLine != 0 )
  409.                     {
  410.                         nChars = 0;
  411.                         if( g_fUseCRLF )
  412.                         {
  413.                             pbBufferOut[nOut++] = '\r';
  414.                         }
  415.                         pbBufferOut[nOut++] = '\n';
  416.                     }
  417.                     break;
  418.             }
  419.  
  420. /*            if( nRem > 0 || feof( g_fIn ) )
  421.             {
  422.                 if( nChars > 0 )
  423.                 {
  424.                     nChars = 0;
  425.                     if( g_fUseCRLF )
  426.                     {
  427.                         pbBufferOut[nOut++] = '\r';
  428.                     }
  429.                     pbBufferOut[nOut++] = '\n';
  430.                 }
  431.             }*/
  432.  
  433.             return nOut;
  434.  
  435. }
  436.  
  437.  
  438. static char *encodeB64str(const char* pbBufferIn)
  439. {
  440. 	    char *pbBufferOut = (char*) malloc( ENCODE_BUFFER_SIZE_OUT );
  441.  
  442. //	    pbBufferOut = strdup(pbBufferIn);
  443.  
  444. //        for(;;)
  445.         {
  446.             unsigned long nRem = 0;
  447.             unsigned char* pIn = (unsigned char*) pbBufferIn;
  448.             size_t nWritten = 0;
  449.  
  450. 			nWritten = encodeB64(pIn, pbBufferOut, nRem);
  451. /*            if( nWritten > 0 )
  452. 	            break;
  454.             if( nRem > 0 || feof( g_fIn ) )
  455.                 break;*/
  456.         }
  457.  
  458.         return pbBufferOut;
  459. }
  460.  
  461. static int encodeB64file()
  462. {
  463.     int r = B64_OK;
  464.     char *pbBufferIn = (char*) malloc( ENCODE_BUFFER_SIZE_IN );
  465.     char *pbBufferOut = (char*) malloc( ENCODE_BUFFER_SIZE_OUT );
  466.  
  467.     for(;;)
  468.     {
  469.         if( pbBufferIn == NULL || pbBufferOut == NULL )
  470.         {
  471.             r = B64_ERR_MEMORY;
  472.             break;
  473.         }
  474.  
  475.         if( g_nHeaderLine > 0 )
  476.         {
  477.             size_t n = fwrite( (void*)"-----BEGIN ", 1, 11, g_fOut );
  478.             if( ferror( g_fOut ) || n < 11 )
  479.             {
  480.                 r = B64_ERR_WRITING;
  481.                 break;
  482.             }
  483.             n = fwrite( (void*)g_pszHeaderLine, 1, g_nHeaderLine, g_fOut );
  484.             if( ferror( g_fOut ) || n < g_nHeaderLine )
  485.             {
  486.                 r = B64_ERR_WRITING;
  487.                 break;
  488.             }
  489.             n = fwrite( (void*)"-----", 1, 5, g_fOut );
  490.             if( ferror( g_fOut ) || n < 5 )
  491.             {
  492.                 r = B64_ERR_WRITING;
  493.                 break;
  494.             }
  495.             if( g_fUseCRLF )
  496.             {
  497.                 n = fwrite( (void*)"\r", 1, 1, g_fOut );
  498.                 if( ferror( g_fOut ) || n < 1 )
  499.                 {
  500.                     r = B64_ERR_WRITING;
  501.                     break;
  502.                 }
  503.             }
  504.             n = fwrite( (void*)"\n", 1, 1, g_fOut );
  505.             if( ferror( g_fOut ) || n < 1 )
  506.             {
  507.                 r = B64_ERR_WRITING;
  508.                 break;
  509.             }
  510.         }
  511.  
  512.         for(;;)
  513.         {
  514.             unsigned long nRem = 0;
  515.             unsigned char* pIn = (unsigned char*) pbBufferIn;
  516.             size_t nWritten = 0;
  517.  
  518.             size_t nRead = fread( (void*)pIn, 1, ENCODE_BUFFER_SIZE_IN, g_fIn );
  519.             if( ferror( g_fIn ) )
  520.             {
  521.                 r = B64_ERR_READING;
  522.                 break;
  523.             }
  524.             if( nRead == 0 )
  525.             {
  526.                 break;
  527.             }
  528.  
  529. 			nWritten = encodeB64(pIn, pbBufferOut, nRem);
  530.             if( nWritten > 0 )
  531.             {
  532.                 size_t n = fwrite( (void*)pbBufferOut, 1, nWritten, g_fOut );
  533.                 if( ferror( g_fOut ) || n < nWritten )
  534.                 {
  535.                     r = B64_ERR_WRITING;
  536.                     break;
  537.                 }
  538.             }
  539.  
  540.             if( nRem > 0 || feof( g_fIn ) )
  541.             {
  542.                 break;
  543.             }
  544.         }
  545.         break;
  546.     }
  547.  
  548.     if( r == B64_OK )
  549.     {
  550.         while( g_nHeaderLine > 0 )
  551.         {
  552.             size_t n = fwrite( (void*)"-----END ", 1, 9, g_fOut );
  553.             if( ferror( g_fOut ) || n < 9 )
  554.             {
  555.                 r = B64_ERR_WRITING;
  556.                 break;
  557.             }
  558.             n = fwrite( (void*)g_pszHeaderLine, 1, g_nHeaderLine, g_fOut );
  559.             if( ferror( g_fOut ) || n < g_nHeaderLine )
  560.             {
  561.                 r = B64_ERR_WRITING;
  562.                 break;
  563.             }
  564.             n = fwrite( (void*)"-----", 1, 5, g_fOut );
  565.             if( ferror( g_fOut ) || n < 5 )
  566.             {
  567.                 r = B64_ERR_WRITING;
  568.                 break;
  569.             }
  570.             if( g_fUseCRLF )
  571.             {
  572.                 n = fwrite( (void*)"\r", 1, 1, g_fOut );
  573.                 if( ferror( g_fOut ) || n < 1 )
  574.                 {
  575.                     r = B64_ERR_WRITING;
  576.                     break;
  577.                 }
  578.             }
  579.             n = fwrite( (void*)"\n", 1, 1, g_fOut );
  580.             if( ferror( g_fOut ) || n < 1 )
  581.             {
  582.                 r = B64_ERR_WRITING;
  583.                 break;
  584.             }
  585.             break;
  586.         }
  587.     }
  588.  
  589.     if( pbBufferIn != NULL )
  590.     {
  591.         free( pbBufferIn );
  592.     }
  593.     if( pbBufferOut != NULL )
  594.     {
  595.         free( pbBufferOut );
  596.     }
  597.     return r;
  598. }
  599.  
  600. static int decodeB64file()
  601. {
  602.     int r = B64_OK;
  603.     int z = 0;  // 0 Normal, 1 skip MIME separator (---) to end of line
  604.     char c = '\0';
  605.     unsigned char data[3];
  606.     unsigned int nData = 0;
  607.  
  608.     for(;;)
  609.     {
  610.         unsigned char bits = 'z';
  611.         size_t nRead = fread( (void*)&c, 1, 1, g_fIn );
  612.         if( ferror( g_fIn ) )
  613.         {
  614.             r = B64_ERR_READING;
  615.             break;
  616.         }
  617.         if( nRead == 0 )
  618.         {
  619.             break;
  620.         }
  621.  
  622.         if( z > 0 )
  623.         {
  624.             if( c == '\n' )
  625.             {
  626.                 z = 0;
  627.             }
  628.         }
  629.         else if( c >= 'A' && c <= 'Z' )
  630.         {
  631.             bits = (unsigned char) (c - 'A');
  632.         }
  633.         else if( c >= 'a' && c <= 'z' )
  634.         {
  635.             bits = (unsigned char) (c - 'a' + (char)26);
  636.         }
  637.         else if( c >= '0' && c <= '9' )
  638.         {
  639.             bits = (unsigned char) (c - '0' + (char)52);
  640.         }
  641.         else if( c == '+' )
  642.         {
  643.             bits = (unsigned char) 62;
  644.         }
  645.         else if( c == '/' )
  646.         {
  647.             bits = (unsigned char) 63;
  648.         }
  649.         else if( c == '-' )
  650.         {
  651.             z = 1;
  652.         }
  653.         else if( c == '=' )
  654.         {
  655.             break;
  656.         }
  657.         else
  658.         {
  659.             bits = (unsigned char) 'y';
  660.         }
  661.  
  662.         if( bits < (unsigned char) 64 )
  663.         {
  664.             switch(nData++)
  665.             {
  666.                 case 0:
  667.                     data[0] = (bits << 2) & 0xfc;
  668.                     break;
  669.                 case 1:
  670.                     data[0] |= (bits >> 4) & 0x03;
  671.                     data[1] = (bits << 4) & 0xf0;
  672.                     break;
  673.                 case 2:
  674.                     data[1] |= (bits >> 2) & 0x0f;
  675.                     data[2] = (bits << 6) & 0xc0;
  676.                     break;
  677.                 case 3:
  678.                     data[2] |= bits & 0x3f;
  679.                     break;
  680.             }
  681.  
  682.             if( nData == 4 )
  683.             {
  684.                 size_t n = fwrite( (void*)data, 1, 3, g_fOut );
  685.                 if( ferror( g_fOut ) || n < 3 )
  686.                 {
  687.                     r = B64_ERR_WRITING;
  688.                     break;
  689.                 }
  690.  
  691.                 nData = 0;
  692.             }
  693.         }
  694.  
  695.         if( feof( g_fIn ) )
  696.         {
  697.             break;
  698.         }
  699.     }
  700.     if( r == B64_OK && nData > 0 )
  701.     {
  702.         if( nData == 1 )
  703.         {
  704.             r = B64_ERR_SYNTAX;
  705.         }
  706.         else
  707.         {
  708.             size_t n = fwrite( (void*)data, 1, nData-1, g_fOut );
  709.             if( ferror( g_fOut ) || n < (nData-1) )
  710.             {
  711.                 r = B64_ERR_WRITING;
  712.             }
  713.         }
  714.     }
  715.     return r;
  716. }
  717.  
  718. static void setOptionsFromProgname( char *fn )
  719. {
  720. #ifdef _WIN32
  721.     char c = '\\';
  722.     char *pn = "b642bin.exe";
  723. #else
  724.     char c = '/';
  725.     char *pn = "b642bin";
  726. #endif
  727.  
  728.     char *p = strrchr( fn, c );
  729.     if( p == NULL )
  730.     {
  731.         p = fn;
  732.     }
  733.     else
  734.     {
  735.         p++;
  736.     }
  737.     if( STRCMP( p, pn ) == 0 )
  738.     {
  739.         g_fDecode = TRUE;
  740.     }
  741. }
  742.  
  743. /*
  744. int main( int argc, char ** argv )
  745. {
  746.     int r = B64_OK;
  747.     int nArgv = 1;
  748.     for(;;)
  749.     {
  750. #ifdef USE_CRLF
  751.         g_fUseCRLF = TRUE;
  752. #endif
  753.         setOptionsFromProgname( argv[0] );
  754.         if( (r=parseCmdLine( argc, argv )) != 0 )
  755.         {
  756.             break;
  757.         }
  758.         if( (r=openFiles()) != 0 )
  759.         {
  760.             break;
  761.         }
  763.         if( g_fDecode != TRUE )
  764.         {
  765.             if( (r=encodeB64file()) != 0 )
  766.             {
  767.                 break;
  768.             }
  769.         }
  770.         else
  771.         {
  772.             if( (r=decodeB64file()) != 0 )
  773.             {
  774.                 break;
  775.             }
  776.         }
  778.         break;
  779.     }
  780.     closeFiles(r);
  781.     return r;
  782. }
  784. */
  785.
[edit]

Change Log

20 Oct 2006 - TivoZA: Uploaded the file

Retrieved from "http://tivoza.nanfo.com/wiki/index.php/EmuProxyZA_/_base64.c"
Advertisement
external links