FileUtils.cpp

Go to the documentation of this file.

#include "FileUtils.h"
#include "Certificate.h"
#include "ToolkitUtils.h"
#include "components.h"
#include "PKIFException.h"
#include "PKIFErrors.h"
#include "Buffer.h"

#include "boost/filesystem/path.hpp"
#include "boost/filesystem/operations.hpp"
#include "boost/filesystem/fstream.hpp"
#include <iostream>
#include <sstream>

#include "boost/numeric/conversion/cast.hpp"
#include "boost/numeric/conversion/bounds.hpp"
#include "boost/limits.hpp"

using boost::numeric_cast;
using boost::bad_numeric_cast;

using namespace std;
namespace fs = boost::filesystem;

CPKIFBufferPtr CAC_API ReadFileIntoBuffer(
    const std::string & filename) throw(CPKIFException)
{
    fs::path filepath;
    boost::intmax_t filelen = 0;
    try {
        filepath = fs::path(filename,fs::native);
        //file_size() will throw if it's not a valid file
        filelen = fs::file_size(filepath);
    } catch(...) {
        throw CPKIFException(TOOLKIT_UTILS_SUBCOMPONENT, COMMON_INVALID_INPUT,
            "Invalid filename passed to DecodeCertFromFile()");
    }

    int tmpST = 0;
    try 
    {
        tmpST = numeric_cast<int>(filelen);
    }
    catch(bad_numeric_cast &) 
    {
        throw CPKIFException(TOOLKIT_UTILS, COMMON_INVALID_INPUT, "File size too big.");
    }

    fs::ifstream infile;
    try {
        // on windows ios_base::binary definitely matters
        infile.open(filepath,ios_base::binary);
    } catch(std::exception & e) {
        ostringstream os;
        os << "Error opening " << filename << " for reading: " << e.what();
        throw CPKIFException(TOOLKIT_UTILS_SUBCOMPONENT, COMMON_INVALID_INPUT,
            os.str().c_str());
    }
    unsigned char * filebuf = new unsigned char[tmpST];
    infile.read((char *)filebuf,tmpST);
    infile.close();
    // the returned buffer gets ownership and will delete filebuf
    CPKIFBufferPtr returnbuf(new CPKIFBuffer(true,filebuf,tmpST));
    return returnbuf;
}


CPKIFCertificatePtr DecodeCertFromFile(
    const std::string & filename) throw(CPKIFException)
{
    CPKIFBufferPtr fileBuf = ReadFileIntoBuffer(filename);
    CPKIFCertificatePtr cert(new CPKIFCertificate());
    cert->Decode(fileBuf->GetBuffer(),fileBuf->GetLength());
    return cert;
}
void WriteBufferToFile(
    const std::string & filename,
    CPKIFBufferPtr &buf)
{
    fs::path filepath;
    size_t filelen = 0;
    try {
        filepath = fs::path(filename,fs::native);
    } catch(...) {
        throw CPKIFException(TOOLKIT_UTILS_SUBCOMPONENT, COMMON_INVALID_INPUT,
            "Invalid filename passed to WriteBufferToFile()");
    }
    fs::ofstream outfile;
    try {
        // on windows ios_base::binary definitely matters
        outfile.open(filepath,ios_base::binary | ios::out );
    } catch(std::exception & e) {
        ostringstream os;
        os << "Error opening " << filename << " for writing: " << e.what();
        throw CPKIFException(TOOLKIT_UTILS_SUBCOMPONENT, COMMON_INVALID_INPUT,
            os.str().c_str());
    }
    try {
        outfile.write((char *)buf->GetBuffer(),buf->GetLength());
        outfile.close();
    } catch(std::exception & e) {
        ostringstream os;
        os << "Error writing to " << filename << " : " << e.what();
        throw CPKIFException(TOOLKIT_UTILS_SUBCOMPONENT, COMMON_OPERATION_NOT_SUCCESSFUL,
            os.str().c_str());
    }
}