64BASE编解码(转载)

case 9 Stress:
All files in a working directory encoded/decoded
and compared with file comparison utility to
ensure that multiple runs do not cause problems
such as exhausting file handles, tmp storage, etc.
-------------
Syntax, operation and failure:
All options/switches tested. Performs as
expected.
case 10:
No Args -- Shows Usage Screen
Return Code 1 (Invalid Syntax)
case 11:
One Arg (invalid) -- Shows Usage Screen
Return Code 1 (Invalid Syntax)
case 12:
One Arg Help (-?) -- Shows detailed Usage Screen.
Return Code 0 (Success -- help request is valid).
case 13:
One Arg Help (-h) -- Shows detailed Usage Screen.
Return Code 0 (Success -- help request is valid).
case 14:
One Arg (valid) -- Uses stdin/stdout (filter)
Return Code 0 (Sucess)
case 15:
Two Args (invalid file) -- shows system error.
Return Code 2 (File Error)
case 16:
Encode non-existent file -- shows system error.
Return Code 2 (File Error)
case 17:
Out of disk space -- shows system error.
Return Code 3 (File I/O Error)
-------------
Compile/Regression test:
gcc compiled binary under Cygwin
Microsoft Visual Studio under Windows 2000
Microsoft Version 6.0 C under Windows 2000
DEPENDENCIES: None
LICENCE: Copyright (c) 2001 Bob Trower, Trantor Standard Systems Inc.
Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated
documentation files (the "Software"), to deal in the
Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute,
sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so,
subject to the following conditions:
The above copyright notice and this permission notice shall
be included in all copies or substantial portions of the
Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS
OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
VERSION HISTORY:
Bob Trower 08/04/01 -- Create Version 0.00.00B
LAST MODIFIED: cheungmine@gmail.com 2009-08-17
\******************************************************************* */
#include < stdio.h >
#include < stdlib.h >
#define B64_DEF_LINE_SIZE 72
#define B64_MIN_LINE_SIZE 4
/*
** Translation Table as described in RFC1113
*/
static const char cb64[] = " ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/ " ;
/*
** Translation Table to decode (created by author)
*/
static const char cd64[] = " |$$$}rstuvwxyz{$$$$$$$>?@ABCDEFGHIJKLMNOPQRSTUVW$$$$$$XYZ[\\]^_`abcdefghijklmnopq " ;
/*
** encodeblock
**
** encode 3 8-bit binary bytes as 4 '6-bit' characters
*/
static void encodeblock( unsigned char in [ 3 ], unsigned char out [ 4 ], int len )
{
out [ 0 ] = cb64[ in [ 0 ] >> 2 ];
out [ 1 ] = cb64[ (( in [ 0 ] & 0x03 ) << 4 ) | (( in [ 1 ] & 0xf0 ) >> 4 ) ];
out [ 2 ] = (unsigned char ) (len > 1 ? cb64[ (( in [ 1 ] & 0x0f ) << 2 ) | (( in [ 2 ] & 0xc0 ) >> 6 ) ] : ' = ' );
out [ 3 ] = (unsigned char ) (len > 2 ? cb64[ in [ 2 ] & 0x3f ] : ' = ' );
}
/*
** encode
**
** base64 encode a stream adding padding and line breaks as per spec.
*/
static void b64_encode_stream( FILE * infile, FILE * outfile, int linesize )
{
unsigned char in [ 3 ], out [ 4 ];
int i, len, blocksout = 0 ;
while ( ! feof( infile ) ) {
len = 0 ;
for ( i = 0 ; i < 3 ; i ++ ) {
in [i] = (unsigned char ) getc( infile );
if ( ! feof( infile ) ) {
len ++ ;
}
else {
in [i] = 0 ;
}
}
if ( len ) {
encodeblock( in , out , len );
for ( i = 0 ; i < 4 ; i ++ ) {
putc( out [i], outfile );
}
blocksout ++ ;
}
if ( blocksout >= (linesize / 4 ) || feof( infile ) ) {
if ( blocksout ) {
fprintf( outfile, " \r\n " );
}
blocksout = 0 ;
}
}
}
/*
** encode
**
** base64 encode bytes
** by cheungmine
** outstr is allocated by caller
** length of encoded string is returned (not including end closing '\0')
*/
static int b64_encode_string( const unsigned char * instr, int inlen, unsigned char * outstr )
{
unsigned char in [ 3 ], out [ 4 ];
int inc = 0 , outc = 0 , i, len;
/* only size of buffer required */
if ( ! outstr){
while ( inc < inlen ) {
len = 0 ;
for ( i = 0 ; i < 3 ; i ++ ) {
if ( inc ++< inlen ){
len ++ ;
}
}
if ( len ) {
outc += 4 ;
}
}
return outc;
}
assert(outstr);
while ( inc < inlen ) {
len = 0 ;

for ( i = 0 ; i < 3 ; i ++ ) {
in [i] = instr[inc];
if ( inc ++< inlen ){
len ++ ;
}
else {
in [i] = 0 ;
}
}
if ( len ) {
encodeblock( in , out , len );
for ( i = 0 ; i < 4 ; i ++ ) {
outstr[outc ++ ] = out [i];
}
}
}
return outc;
}
/*
** decodeblock
**
** decode 4 '6-bit' characters into 3 8-bit binary bytes
*/
static void decodeblock( unsigned char in [ 4 ], unsigned char out [ 3 ] )
{
out [ 0 ] = (unsigned char ) ( in [ 0 ] << 2 | in [ 1 ] >> 4 );
out [ 1 ] = (unsigned char ) ( in [ 1 ] << 4 | in [ 2 ] >> 2 );
out [ 2 ] = (unsigned char ) ((( in [ 2 ] << 6 ) & 0xc0 ) | in [ 3 ]);
}
/*
** decode
**
** decode a base64 encoded stream discarding padding, line breaks and noise
*/
static void b64_decode_stream( FILE * infile, FILE * outfile )
{
unsigned char in [ 4 ], out [ 3 ], v;
int i, len;
while ( ! feof( infile ) ) {
for ( len = 0 , i = 0 ; i < 4 && ! feof( infile ); i ++ ) {
v = 0 ;
while ( ! feof( infile ) && v == 0 ) {
v = (unsigned char ) getc( infile );
v = (unsigned char ) ((v < 43 || v > 122 ) ? 0 : cd64[ v - 43 ]);
if ( v ) {
v = (unsigned char ) ((v == ' $ ' ) ? 0 : v - 61 );
}
}
if ( ! feof( infile ) ) {
len ++ ;
if ( v ) {
in [ i ] = (unsigned char ) (v - 1 );
}
}
else {
in [i] = 0 ;
}
}
if ( len ) {
decodeblock( in , out );
for ( i = 0 ; i < len - 1 ; i ++ ) {
putc( out [i], outfile );
}
}
}
}
/*
* add by cheungmine
*/
static int b64_decode_string( const unsigned char * instr, int inlen, unsigned char * outstr )
{
unsigned char in [ 4 ], out [ 3 ], v;
int inc = 0 , outc = 0 , i, len;
/* only size of buffer required */
if ( ! outstr){
while ( inc < inlen ) {
for ( len = 0 , i = 0 ; i < 4 && inc < inlen; i ++ ) {
v = 0 ;
while ( (inc < inlen) && (v == 0 ) ) {
v = instr[inc ++ ];
v = (unsigned char ) ((v < 43 || v > 122 ) ? 0 : cd64[ v - 43 ]);
if ( v ) {
v = (unsigned char ) ((v == ' $ ' ) ? 0 : v - 61 );
}
}
if ( inc < inlen ) {
len ++ ;
}
}
if ( len > 1 ) {
outc += (len - 1 );
}
}
return outc;
}
assert(outstr);
while ( inc < inlen ) {
for ( len = 0 , i = 0 ; i < 4 && inc < inlen; i ++ ) {
v = 0 ;
while ( (inc < inlen) && (v == 0 ) ) {
v = instr[inc ++ ];
v = (unsigned char ) ((v < 43 || v > 122 ) ? 0 : cd64[ v - 43 ]);
if ( v ) {
v = (unsigned char ) ((v == ' $ ' ) ? 0 : v - 61 );
}
}
if ( inc < inlen ) {
len ++ ;
if ( v ) {
in [ i ] = (unsigned char ) (v - 1 );
}
}
else {
in [i] = 0 ;
}
}
if ( len ) {
decodeblock( in , out );
for ( i = 0 ; i < len - 1 ; i ++ ) {
outstr[outc ++ ] = out [i];
}
}
}
return outc;
}
/*
** returnable errors
**
** Error codes returned to the operating system.
**
*/
#define B64_SYNTAX_ERROR 1
#define B64_FILE_ERROR 2
#define B64_FILE_IO_ERROR 3
#define B64_ERROR_OUT_CLOSE 4
#define B64_LINE_SIZE_TO_MIN 5
/*
** b64_message
**
** Gather text messages in one place.
**
*/
static char * b64_message( int errcode )
{
#define B64_MAX_MESSAGES 6

char * msgs[ B64_MAX_MESSAGES ] = {
" b64:000:Invalid Message Code. " ,
" b64:001:Syntax Error -- check help for usage. " ,
" b64:002:File Error Opening/Creating Files. " ,
" b64:003:File I/O Error -- Note: output file not removed. " ,
" b64:004:Error on output file close. " ,
" b64:004:linesize set to minimum. "
};
char * msg = msgs[ 0 ];
if ( errcode > 0 && errcode < B64_MAX_MESSAGES ) {
msg = msgs[ errcode ];
}
return ( msg );
}
/*
* Example by cheungmine
*
int main()
{
int size_out;
int size_ret;
char *b64_out;
char *b64_outB;
char b64_in[] = "hello world shanghai";
// Base64 编码字符串
size_out = b64_encode_string((const unsigned char*)b64_in, (int)strlen(b64_in), 0);
b64_out = (char*) malloc(size_out+1);
size_ret = b64_encode_string((const unsigned char*)b64_in, (int)strlen(b64_in), (unsigned char*)b64_out);
b64_out[size_ret] = 0;
assert(size_ret==size_out);
// Base64 解码字符串
size_out = b64_decode_string((const unsigned char*)b64_out, size_ret, 0);
b64_outB = (char*) malloc(size_out+1);
size_ret = b64_decode_string((const unsigned char*)b64_out, size_ret, (unsigned char*)b64_outB);
b64_outB[size_ret] = 0;
assert(size_ret==size_out);
assert(strcmp(b64_outB, b64_in)==0);

free(b64_out);
free(b64_outB);
return 0;
}
*/