libb64-1.2.orig/0000755000000000000000000000000011405646456012106 5ustar rootrootlibb64-1.2.orig/TODO0000644000000000000000000000000011405646434012560 0ustar rootrootlibb64-1.2.orig/src/0000755000000000000000000000000011405646456012675 5ustar rootrootlibb64-1.2.orig/src/Makefile0000644000000000000000000000123011405646436014327 0ustar rootrootLIBRARIES = libb64.a # Build flags (uncomment one) ############################# # Release build flags CFLAGS += -O3 ############################# # Debug build flags #CFLAGS += -g ############################# SOURCES = cdecode.c cencode.c TARGETS = $(LIBRARIES) LINK.o = gcc CFLAGS += -Werror -pedantic CFLAGS += -I../include vpath %.h ../include/b64 .PHONY : clean all: $(TARGETS) #strip libb64.a: cencode.o cdecode.o $(AR) $(ARFLAGS) $@ $^ strip: strip $(BINARIES) *.exe clean: rm -f *.exe* *.o $(TARGETS) *.bak *~ distclean: clean rm -f depend depend: $(SOURCES) makedepend -f- $(CFLAGS) $(SOURCES) 2> /dev/null 1> depend -include depend libb64-1.2.orig/src/cencode.c0000644000000000000000000000477511405646436014454 0ustar rootroot/* cencoder.c - c source to a base64 encoding algorithm implementation This is part of the libb64 project, and has been placed in the public domain. For details, see http://sourceforge.net/projects/libb64 */ #include const int CHARS_PER_LINE = 72; void base64_init_encodestate(base64_encodestate* state_in) { state_in->step = step_A; state_in->result = 0; state_in->stepcount = 0; } char base64_encode_value(char value_in) { static const char* encoding = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; if (value_in > 63) return '='; return encoding[(int)value_in]; } int base64_encode_block(const char* plaintext_in, int length_in, char* code_out, base64_encodestate* state_in) { const char* plainchar = plaintext_in; const char* const plaintextend = plaintext_in + length_in; char* codechar = code_out; char result; char fragment; result = state_in->result; switch (state_in->step) { while (1) { case step_A: if (plainchar == plaintextend) { state_in->result = result; state_in->step = step_A; return codechar - code_out; } fragment = *plainchar++; result = (fragment & 0x0fc) >> 2; *codechar++ = base64_encode_value(result); result = (fragment & 0x003) << 4; case step_B: if (plainchar == plaintextend) { state_in->result = result; state_in->step = step_B; return codechar - code_out; } fragment = *plainchar++; result |= (fragment & 0x0f0) >> 4; *codechar++ = base64_encode_value(result); result = (fragment & 0x00f) << 2; case step_C: if (plainchar == plaintextend) { state_in->result = result; state_in->step = step_C; return codechar - code_out; } fragment = *plainchar++; result |= (fragment & 0x0c0) >> 6; *codechar++ = base64_encode_value(result); result = (fragment & 0x03f) >> 0; *codechar++ = base64_encode_value(result); ++(state_in->stepcount); if (state_in->stepcount == CHARS_PER_LINE/4) { *codechar++ = '\n'; state_in->stepcount = 0; } } } /* control should not reach here */ return codechar - code_out; } int base64_encode_blockend(char* code_out, base64_encodestate* state_in) { char* codechar = code_out; switch (state_in->step) { case step_B: *codechar++ = base64_encode_value(state_in->result); *codechar++ = '='; *codechar++ = '='; break; case step_C: *codechar++ = base64_encode_value(state_in->result); *codechar++ = '='; break; case step_A: break; } *codechar++ = '\n'; return codechar - code_out; } libb64-1.2.orig/src/cdecode.c0000644000000000000000000000470611405646436014434 0ustar rootroot/* cdecoder.c - c source to a base64 decoding algorithm implementation This is part of the libb64 project, and has been placed in the public domain. For details, see http://sourceforge.net/projects/libb64 */ #include int base64_decode_value(char value_in) { static const char decoding[] = {62,-1,-1,-1,63,52,53,54,55,56,57,58,59,60,61,-1,-1,-1,-2,-1,-1,-1,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,-1,-1,-1,-1,-1,-1,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51}; static const char decoding_size = sizeof(decoding); value_in -= 43; if (value_in < 0 || value_in > decoding_size) return -1; return decoding[(int)value_in]; } void base64_init_decodestate(base64_decodestate* state_in) { state_in->step = step_a; state_in->plainchar = 0; } int base64_decode_block(const char* code_in, const int length_in, char* plaintext_out, base64_decodestate* state_in) { const char* codechar = code_in; char* plainchar = plaintext_out; char fragment; *plainchar = state_in->plainchar; switch (state_in->step) { while (1) { case step_a: do { if (codechar == code_in+length_in) { state_in->step = step_a; state_in->plainchar = *plainchar; return plainchar - plaintext_out; } fragment = (char)base64_decode_value(*codechar++); } while (fragment < 0); *plainchar = (fragment & 0x03f) << 2; case step_b: do { if (codechar == code_in+length_in) { state_in->step = step_b; state_in->plainchar = *plainchar; return plainchar - plaintext_out; } fragment = (char)base64_decode_value(*codechar++); } while (fragment < 0); *plainchar++ |= (fragment & 0x030) >> 4; *plainchar = (fragment & 0x00f) << 4; case step_c: do { if (codechar == code_in+length_in) { state_in->step = step_c; state_in->plainchar = *plainchar; return plainchar - plaintext_out; } fragment = (char)base64_decode_value(*codechar++); } while (fragment < 0); *plainchar++ |= (fragment & 0x03c) >> 2; *plainchar = (fragment & 0x003) << 6; case step_d: do { if (codechar == code_in+length_in) { state_in->step = step_d; state_in->plainchar = *plainchar; return plainchar - plaintext_out; } fragment = (char)base64_decode_value(*codechar++); } while (fragment < 0); *plainchar++ |= (fragment & 0x03f); } } /* control should not reach here */ return plainchar - plaintext_out; } libb64-1.2.orig/README0000644000000000000000000001137711405646434012773 0ustar rootrootb64: Base64 Encoding/Decoding Routines ====================================== Overview: -------- libb64 is a library of ANSI C routines for fast encoding/decoding data into and from a base64-encoded format. C++ wrappers are included, as well as the source code for standalone encoding and decoding executables. base64 consists of ASCII text, and is therefore a useful encoding for storing binary data in a text file, such as xml, or sending binary data over text-only email. References: ---------- * Wikipedia article: http://en.wikipedia.org/wiki/Base64 * base64, another implementation of a commandline en/decoder: http://www.fourmilab.ch/webtools/base64/ Why? --- I did this because I need an implementation of base64 encoding and decoding, without any licensing problems. Most OS implementations are released under either the GNU/GPL, or a BSD-variant, which is not what I require. Also, the chance to actually use the co-routine implementation in code is rare, and its use here is fitting. I couldn't pass up the chance. For more information on this technique, see "Coroutines in C", by Simon Tatham, which can be found online here: http://www.chiark.greenend.org.uk/~sgtatham/coroutines.html So then, under which license do I release this code? On to the next section... License: ------- This work is released under into the Public Domain. It basically boils down to this: I put this work in the public domain, and you can take it and do whatever you want with it. An example of this "license" is the Creative Commons Public Domain License, a copy of which can be found in the LICENSE file, and also online at http://creativecommons.org/licenses/publicdomain/ Commandline Use: --------------- There is a new executable available, it is simply called base64. It can encode and decode files, as instructed by the user. To encode a file: $ ./base64 -e filea fileb fileb will now be the base64-encoded version of filea. To decode a file: $ ./base64 -d fileb filec filec will now be identical to filea. Programming: ----------- Some C++ wrappers are provided as well, so you don't have to get your hands dirty. Encoding from standard input to standard output is as simple as #include #include int main() { base64::encoder E; E.encode(std::cin, std::cout); return 0; } Both standalone executables and a static library is provided in the package, Implementation: -------------- It is DAMN fast, if I may say so myself. The C code uses a little trick which has been used to implement coroutines, of which one can say that this implementation is an example. (To see how the libb64 codebase compares with some other BASE64 implementations available, see the BENCHMARKS file) The trick involves the fact that a switch-statement may legally cross into sub-blocks. A very thorough and enlightening essay on co-routines in C, using this method, can be found in the above mentioned "Coroutines in C", by Simon Tatham: http://www.chiark.greenend.org.uk/~sgtatham/coroutines.html For example, an RLE decompressing routine, adapted from the article: 1 static int STATE = 0; 2 static int len, c; 3 switch (STATE) 4 { 5 while (1) 6 { 7 c = getchar(); 8 if (c == EOF) return EOF; 9 if (c == 0xFF) { 10 len = getchar(); 11 c = getchar(); 12 while (len--) 13 { 14 STATE = 0; 15 return c; 16 case 0: 17 } 18 } else 19 STATE = 1; 20 return c; 21 case 1: 22 } 23 } 24 } As can be seen from this example, a coroutine depends on a state variable, which it sets directly before exiting (lines 14 and 119). The next time the routine is entered, the switch moves control to the specific point directly after the previous exit (lines 16 and 21).hands (As an aside, in the mentioned article the combination of the top-level switch, the various setting of the state, the return of a value, and the labelling of the exit point is wrapped in #define macros, making the structure of the routine even clearer.) The obvious problem with any such routine is the static keyword. Any static variables in a function spell doom for multithreaded applications. Also, in situations where this coroutine is used by more than one other coroutines, the consistency is disturbed. What is needed is a structure for storing these variabled, which is passed to the routine seperately. This obviously breaks the modularity of the function, since now the caller has to worry about and care for the internal state of the routine (the callee). This allows for a fast, multithreading-enabled implementation, which may (obviously) be wrapped in a C++ object for ease of use. The base64 encoding and decoding functionality in this package is implemented in exactly this way, providing both a high-speed high-maintanence C interface, and a wrapped C++ which is low-maintanence and only slightly less performant. libb64-1.2.orig/Makefile0000644000000000000000000000062511405646434013545 0ustar rootrootall: all_src all_base64 all_src: $(MAKE) -C src all_base64: all_src $(MAKE) -C base64 clean: clean_src clean_base64 clean_include rm -f *~ *.bak clean_include: rm -f include/b64/*~ clean_src: $(MAKE) -C src clean; clean_base64: $(MAKE) -C base64 clean; distclean: clean distclean_src distclean_base64 distclean_src: $(MAKE) -C src distclean; distclean_base64: $(MAKE) -C base64 distclean; libb64-1.2.orig/LICENSE0000644000000000000000000000321711405646434013112 0ustar rootrootCopyright-Only Dedication (based on United States law) or Public Domain Certification The person or persons who have associated work with this document (the "Dedicator" or "Certifier") hereby either (a) certifies that, to the best of his knowledge, the work of authorship identified is in the public domain of the country from which the work is published, or (b) hereby dedicates whatever copyright the dedicators holds in the work of authorship identified below (the "Work") to the public domain. A certifier, moreover, dedicates any copyright interest he may have in the associated work, and for these purposes, is described as a "dedicator" below. A certifier has taken reasonable steps to verify the copyright status of this work. Certifier recognizes that his good faith efforts may not shield him from liability if in fact the work certified is not in the public domain. Dedicator makes this dedication for the benefit of the public at large and to the detriment of the Dedicator's heirs and successors. Dedicator intends this dedication to be an overt act of relinquishment in perpetuity of all present and future rights under copyright law, whether vested or contingent, in the Work. Dedicator understands that such relinquishment of all rights includes the relinquishment of all rights to enforce (by lawsuit or otherwise) those copyrights in the Work. Dedicator recognizes that, once placed in the public domain, the Work may be freely reproduced, distributed, transmitted, used, modified, built upon, or otherwise exploited by anyone for any purpose, commercial or non-commercial, and in any way, including by methods that have not yet been invented or conceived.libb64-1.2.orig/INSTALL0000644000000000000000000000234111405646434013133 0ustar rootrootlibb64: Base64 Encoding/Decoding Routines ====================================== Requirements: ------------ This piece of software has minimal requirements. I have tested it on the following systems: - a Linux machine, with the following specs: (this was the original development machine) * FedoraCore 4 * kernel v. 2.6.11 (stock FC4 kernel) * gcc version 4.0.1 20050727 (Red Hat 4.0.1-5) * glibc-2.3.5-10 * make v. 3.80 * some arb version of makedepend - Windows XP machine * MSYS 1.0 * MinGW 5.1.4 * gcc version 3.4.5 (mingw-vista special r3) - Windows XP machine (same as above) * Microsoft Visual Studio 2010, Version 10.0.30319.1 RTMRel Barring any serious screwups on my part, this code should compile and run sweetly under Cygwin and other systems too. If you DO get it running under some weird arch/os setup, send me a mail, please. Compiling: --------- There is no configure. It would be overkill for something so simple... Run make in the root directory. Installing: ---------- Since the current targets are a standalone executable and a static library (fancy name for archive) with some headers, an install script has not been implemented yet. Simply copy the executable into your path, and use it. -- peace out Chris libb64-1.2.orig/include/0000755000000000000000000000000011405646456013531 5ustar rootrootlibb64-1.2.orig/include/b64/0000755000000000000000000000000011405646456014124 5ustar rootrootlibb64-1.2.orig/include/b64/encode.h0000644000000000000000000000300511405646436015526 0ustar rootroot// :mode=c++: /* encode.h - c++ wrapper for a base64 encoding algorithm This is part of the libb64 project, and has been placed in the public domain. For details, see http://sourceforge.net/projects/libb64 */ #ifndef BASE64_ENCODE_H #define BASE64_ENCODE_H #include namespace base64 { extern "C" { #include "cencode.h" } struct encoder { base64_encodestate _state; int _buffersize; encoder(int buffersize_in = BUFFERSIZE) : _buffersize(buffersize_in) {} int encode(char value_in) { return base64_encode_value(value_in); } int encode(const char* code_in, const int length_in, char* plaintext_out) { return base64_encode_block(code_in, length_in, plaintext_out, &_state); } int encode_end(char* plaintext_out) { return base64_encode_blockend(plaintext_out, &_state); } void encode(std::istream& istream_in, std::ostream& ostream_in) { base64_init_encodestate(&_state); // const int N = _buffersize; char* plaintext = new char[N]; char* code = new char[2*N]; int plainlength; int codelength; do { istream_in.read(plaintext, N); plainlength = istream_in.gcount(); // codelength = encode(plaintext, plainlength, code); ostream_in.write(code, codelength); } while (istream_in.good() && plainlength > 0); codelength = encode_end(code); ostream_in.write(code, codelength); // base64_init_encodestate(&_state); delete [] code; delete [] plaintext; } }; } // namespace base64 #endif // BASE64_ENCODE_H libb64-1.2.orig/include/b64/decode.h0000644000000000000000000000253511405646436015523 0ustar rootroot// :mode=c++: /* decode.h - c++ wrapper for a base64 decoding algorithm This is part of the libb64 project, and has been placed in the public domain. For details, see http://sourceforge.net/projects/libb64 */ #ifndef BASE64_DECODE_H #define BASE64_DECODE_H #include namespace base64 { extern "C" { #include "cdecode.h" } struct decoder { base64_decodestate _state; int _buffersize; decoder(int buffersize_in = BUFFERSIZE) : _buffersize(buffersize_in) {} int decode(char value_in) { return base64_decode_value(value_in); } int decode(const char* code_in, const int length_in, char* plaintext_out) { return base64_decode_block(code_in, length_in, plaintext_out, &_state); } void decode(std::istream& istream_in, std::ostream& ostream_in) { base64_init_decodestate(&_state); // const int N = _buffersize; char* code = new char[N]; char* plaintext = new char[N]; int codelength; int plainlength; do { istream_in.read((char*)code, N); codelength = istream_in.gcount(); plainlength = decode(code, codelength, plaintext); ostream_in.write((const char*)plaintext, plainlength); } while (istream_in.good() && codelength > 0); // base64_init_decodestate(&_state); delete [] code; delete [] plaintext; } }; } // namespace base64 #endif // BASE64_DECODE_H libb64-1.2.orig/include/b64/cencode.h0000644000000000000000000000132311405647070015665 0ustar rootroot/* cencode.h - c header for a base64 encoding algorithm This is part of the libb64 project, and has been placed in the public domain. For details, see http://sourceforge.net/projects/libb64 */ #ifndef BASE64_CENCODE_H #define BASE64_CENCODE_H typedef enum { step_A, step_B, step_C } base64_encodestep; typedef struct { base64_encodestep step; char result; int stepcount; } base64_encodestate; void base64_init_encodestate(base64_encodestate* state_in); char base64_encode_value(char value_in); int base64_encode_block(const char* plaintext_in, int length_in, char* code_out, base64_encodestate* state_in); int base64_encode_blockend(char* code_out, base64_encodestate* state_in); #endif /* BASE64_CENCODE_H */ libb64-1.2.orig/include/b64/cdecode.h0000644000000000000000000000121011405647042015645 0ustar rootroot/* cdecode.h - c header for a base64 decoding algorithm This is part of the libb64 project, and has been placed in the public domain. For details, see http://sourceforge.net/projects/libb64 */ #ifndef BASE64_CDECODE_H #define BASE64_CDECODE_H typedef enum { step_a, step_b, step_c, step_d } base64_decodestep; typedef struct { base64_decodestep step; char plainchar; } base64_decodestate; void base64_init_decodestate(base64_decodestate* state_in); int base64_decode_value(char value_in); int base64_decode_block(const char* code_in, const int length_in, char* plaintext_out, base64_decodestate* state_in); #endif /* BASE64_CDECODE_H */ libb64-1.2.orig/CHANGELOG0000644000000000000000000000127511405646434013321 0ustar rootrootlibb64: Base64 Encoding/Decoding Routines ====================================== ## Changelog ## Version 1.2 Release ------------------- Removed the b64dec, b64enc, encoder and decoder programs in favour of a better example, called base64, which encodes and decodes depending on its arguments. Created a solution for Microsoft Visual Studio C++ Express 2010 edition, which simply builds the base64 example as a console application. Version 1.1 Release ------------------- Modified encode.h to (correctly) read from the iostream argument, instead of std::cin. Thanks to Peter K. Lee for the heads-up. No API changes. Version 1.0 Release ------------------- The current content is the changeset. libb64-1.2.orig/BENCHMARKS0000644000000000000000000000356011405646434013446 0ustar rootroot-- Intro Some people have expressed opinions about how fast libb64's encoding and decoding routines are, as compared to some other BASE64 packages out there. This document shows the result of a short and sweet benchmark, which takes a large-ish file and encodes/decodes it a number of times. The winner is the executable that does this task the quickest. -- Platform The tests were all run on a Fujitsu-Siemens laptop, with a Pentium M processor running at 2GHz, with 1GB of RAM, running Ubuntu 10.4. -- Packages The following BASE64 packages were used in this benchmark: - libb64-1.2 (libb64-base64) From libb64.sourceforge.net Size of executable: 18808 bytes Compiled with: CFLAGS += -O3 BUFFERSIZE = 16777216 - base64-1.5 (fourmilab-base64) From http://www.fourmilab.ch/webtools/base64/ Size of executable: 20261 bytes Compiled with Default package settings - coreutils 7.4-2ubuntu2 (coreutils-base64) From http://www.gnu.org/software/coreutils/ Size of executable: 38488 bytes Default binary distributed with Ubuntu 10.4 -- Input File Using blender-2.49b-linux-glibc236-py25-i386.tar.bz2 from http://www.blender.org/download/get-blender/ Size: 18285329 bytes (approx. 18MB) -- Method Encode and Decode the Input file 50 times in a loop, using a simple shell script, and get the running time. -- Results $ time ./benchmark-libb64.sh real 0m28.389s user 0m14.077s sys 0m12.309s $ time ./benchmark-fourmilab.sh real 1m43.160s user 1m23.769s sys 0m8.737s $ time ./benchmark-coreutils.sh real 0m36.288s user 0m24.746s sys 0m8.181s 28.389 for 18MB * 50 = 28.389 for 900 -- Conclusion libb64 is the fastest encoder/decoder, and has the smallest executable size. On average it will encode and decode at roughly 31.7MB/second. The closest "competitor" is base64 from GNU coreutils, which reaches only 24.8MB/second. -- 14/06/2010 chris.venter@gmail.com libb64-1.2.orig/base64/0000755000000000000000000000000011405646456013172 5ustar rootrootlibb64-1.2.orig/base64/VisualStudioProject/0000755000000000000000000000000011405646456017154 5ustar rootrootlibb64-1.2.orig/base64/VisualStudioProject/Makefile0000644000000000000000000000017411405646434020612 0ustar rootrootDEBRIS = base64.sdf base64.suo base64.vcxproj.user all: clean: rm -rf Debug Release distclean: clean rm -f $(DEBRIS) libb64-1.2.orig/base64/VisualStudioProject/base64.vcxproj.filters0000644000000000000000000000227011405646436023323 0ustar rootroot {12b9f2a2-b899-409a-a507-8cefe9c39b25} {ce5598bd-67f3-430f-890b-cefa880e9405} Source Files Source Files Source Files Header Files Header Files Header Files Header Files libb64-1.2.orig/base64/VisualStudioProject/base64.vcxproj0000644000000000000000000001063011405646434021651 0ustar rootroot Debug Win32 Release Win32 {0B094121-DC64-4D74-AFA0-750B83F800D0} Win32Proj base64 Application true Unicode Application false true Unicode true false Level3 Disabled BUFFERSIZE=16777216;WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) H:\builds\libb64\working.libb64\include;%(AdditionalIncludeDirectories) Console true Level3 MaxSpeed true true BUFFERSIZE=16777216;WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) H:\builds\libb64\working.libb64\include;%(AdditionalIncludeDirectories) Console true true true libb64-1.2.orig/base64/VisualStudioProject/base64.sln0000644000000000000000000000153711405646434020760 0ustar rootroot Microsoft Visual Studio Solution File, Format Version 11.00 # Visual C++ Express 2010 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "base64", "base64.vcxproj", "{0B094121-DC64-4D74-AFA0-750B83F800D0}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Win32 = Debug|Win32 Release|Win32 = Release|Win32 EndGlobalSection GlobalSection(ProjectConfigurationPlatforms) = postSolution {0B094121-DC64-4D74-AFA0-750B83F800D0}.Debug|Win32.ActiveCfg = Debug|Win32 {0B094121-DC64-4D74-AFA0-750B83F800D0}.Debug|Win32.Build.0 = Debug|Win32 {0B094121-DC64-4D74-AFA0-750B83F800D0}.Release|Win32.ActiveCfg = Release|Win32 {0B094121-DC64-4D74-AFA0-750B83F800D0}.Release|Win32.Build.0 = Release|Win32 EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE EndGlobalSection EndGlobal libb64-1.2.orig/base64/Makefile0000644000000000000000000000204111405646434014623 0ustar rootrootBINARIES = base64 # Build flags (uncomment one) ############################# # Release build flags CFLAGS += -O3 ############################# # Debug build flags #CFLAGS += -g ############################# # select a buffersize # a larger size should be faster, but takes more runtime memory #BUFFERSIZE = 4096 #BUFFERSIZE = 65536 BUFFERSIZE = 16777216 SOURCES = base64.cc TARGETS = $(BINARIES) LINK.o = g++ CFLAGS += -Werror -pedantic CFLAGS += -DBUFFERSIZE=$(BUFFERSIZE) CFLAGS += -I../include CXXFLAGS += $(CFLAGS) vpath %.h ../include/b64 vpath %.a ../src .PHONY : clean all: $(TARGETS) #strip base64: libb64.a strip: strip $(BINARIES) *.exe clean: clean_VisualStudioProject rm -f *.exe* *.o $(TARGETS) *.bak *~ clean_VisualStudioProject: $(MAKE) -C VisualStudioProject clean distclean: clean distclean_VisualStudioProject rm -f depend distclean_VisualStudioProject: clean_VisualStudioProject $(MAKE) -C VisualStudioProject distclean depend: $(SOURCES) makedepend -f- $(CFLAGS) $(SOURCES) 2> /dev/null 1> depend -include depend libb64-1.2.orig/base64/base64.cc0000644000000000000000000000476111405646434014571 0ustar rootroot/* base64.cc - c++ source to a base64 reference encoder and decoder This is part of the libb64 project, and has been placed in the public domain. For details, see http://sourceforge.net/projects/libb64 */ #include #include #include #include #include #include // Function which prints the usage of this executable void usage() { std::cerr<< \ "base64: Encodes and Decodes files using base64\n" \ "Usage: base64 [-e|-d] [input] [output]\n" \ " Where [-e] will encode the input file into the output file,\n" \ " [-d] will decode the input file into the output file, and\n" \ " [input] and [output] are the input and output files, respectively.\n"; } // Function which prints the usage of this executable, plus a short message void usage(const std::string& message) { usage(); std::cerr<<"Incorrect invocation of base64:\n"; std::cerr<