/home/dko/Projects/mobilec/src/libb64-1.2/base64/base64.cc

Go to the documentation of this file.

/*
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 <b64/encode.h>
#include <b64/decode.h>

#include <iostream>
#include <fstream>
#include <string>

#include <stdlib.h>

// 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<<message<<std::endl;
}

int main(int argc, char** argv)
{
        // Quick check for valid arguments
        if (argc == 1)
        {
                usage();
                exit(-1);
        }
        if (argc != 4)
        {
                usage("Wrong number of arguments!");
                exit(-1);
        }
        
        // So far so good; try to open the input file
        std::string input = argv[2];
        // Note that we have to open the input in binary mode.
        // This is due to some operating systems not using binary mode by default.
        // Since we will most likely be dealing with binary files when encoding, we
        // have to be able to deal with zeros (and other invalid chars) in the input stream.
        std::ifstream instream(input.c_str(), std::ios_base::in | std::ios_base::binary);
        if (!instream.is_open())
        {
                usage("Could not open input file!");
                exit(-1);
        }
        
        // Now try to open the output file
        std::string output = argv[3];
        // Again, note that we have to open the ouput in binary mode.
        // Similiarly, we will most likely need to deal with zeros in the output stream when we
        // are decoding, and the output stream has to be able to use these invalid text chars.
        std::ofstream outstream(output.c_str(), std::ios_base::out | std::ios_base::binary);
        if (!outstream.is_open())
        {
                usage("Could not open output file!");
                exit(-1);
        }

        // determine whether we need to encode or decode:
        std::string choice = argv[1];
        if (choice == "-d")
        {
                base64::decoder D;
                D.decode(instream, outstream);
        }
        else if (choice == "-e")
        {
                base64::encoder E;
                E.encode(instream, outstream);
        }
        else
        {
                std::cout<<"["<<choice<<"]"<<std::endl;
                usage("Please specify -d or -e as first argument!");
        }

        return 0;
}

---