/*
* Peek into a stream
*/
size_t DataSource_Stream::peek(byte out[], size_t length, size_t offset) const
{
if(end_of_data())
throw Invalid_State("DataSource_Stream: Cannot peek when out of data");
size_t got = 0;
if(offset)
{
secure_vector<byte> buf(offset);
source.read(reinterpret_cast<char*>(&buf[0]), buf.size());
if(source.bad())
throw Stream_IO_Error("DataSource_Stream::peek: Source failure");
got = source.gcount();
}
if(got == offset)
{
source.read(reinterpret_cast<char*>(out), length);
if(source.bad())
throw Stream_IO_Error("DataSource_Stream::peek: Source failure");
got = source.gcount();
}
if(source.eof())
source.clear();
source.seekg(total_read, std::ios::beg);
return got;
}
/*************************************************
* Peek into a stream *
*************************************************/
u32bit DataSource_Stream::peek(byte out[], u32bit length, u32bit offset) const
{
if(end_of_data())
throw Invalid_State("DataSource_Stream: Cannot peek when out of data");
u32bit got = 0;
if(offset)
{
SecureVector<byte> buf(offset);
source->read((char*)buf.begin(), buf.size());
if(source->bad())
throw Stream_IO_Error("DataSource_Stream::peek: Source failure");
got = source->gcount();
}
if(got == offset)
{
source->read((char*)out, length);
if(source->bad())
throw Stream_IO_Error("DataSource_Stream::peek: Source failure");
got = source->gcount();
}
if(source->eof())
source->clear();
source->seekg(total_read, std::ios::beg);
return got;
}
/*
* Write to a stream
*/
void DataSink_Stream::write(const byte out[], size_t length)
{
sink.write(reinterpret_cast<const char*>(out), length);
if(!sink.good())
throw Stream_IO_Error("DataSink_Stream: Failure writing to " +
identifier);
}
/*
* TLS Server Constructor
*/
TLS_Server::TLS_Server(std::tr1::function<size_t (byte[], size_t)> input_fn,
std::tr1::function<void (const byte[], size_t)> output_fn,
const TLS_Policy& policy,
RandomNumberGenerator& rng,
const X509_Certificate& cert,
const Private_Key& cert_key) :
input_fn(input_fn),
policy(policy),
rng(rng),
writer(output_fn)
{
state = 0;
cert_chain.push_back(cert);
private_key = PKCS8::copy_key(cert_key, rng);
try {
active = false;
writer.set_version(TLS_V10);
do_handshake();
active = true;
}
catch(std::exception& e)
{
if(state)
{
delete state;
state = 0;
}
writer.alert(FATAL, HANDSHAKE_FAILURE);
throw Stream_IO_Error(std::string("TLS_Server: Handshake failed: ") +
e.what());
}
}
/*************************************************
* Read from a stream *
*************************************************/
u32bit DataSource_Stream::read(byte out[], u32bit length)
{
source->read((char*)out, length);
if(source->bad())
throw Stream_IO_Error("DataSource_Stream::read: Source failure");
u32bit got = source->gcount();
total_read += got;
return (u32bit)got;
}
/*
* Read from a stream
*/
size_t DataSource_Stream::read(byte out[], size_t length)
{
source.read(reinterpret_cast<char*>(out), length);
if(source.bad())
throw Stream_IO_Error("DataSource_Stream::read: Source failure");
size_t got = source.gcount();
total_read += got;
return got;
}
/*
* Do heuristic tests for BER data
*/
bool maybe_BER(DataSource& source)
{
byte first_byte;
if(!source.peek_byte(first_byte))
throw Stream_IO_Error("ASN1::maybe_BER: Source was empty");
if(first_byte == (SEQUENCE | CONSTRUCTED))
return true;
return false;
}
/*
* DataSink_Stream Constructor
*/
DataSink_Stream::DataSink_Stream(const std::string& path,
bool use_binary) :
m_identifier(path),
m_sink_memory(new std::ofstream(path, use_binary ? std::ios::binary : std::ios::out)),
m_sink(*m_sink_memory)
{
if(!m_sink.good())
{
throw Stream_IO_Error("DataSink_Stream: Failure opening " + path);
}
}
/*
* Write data from a pipe into an ostream
*/
std::ostream& operator<<(std::ostream& stream, Pipe& pipe)
{
secure_vector<uint8_t> buffer(DEFAULT_BUFFERSIZE);
while(stream.good() && pipe.remaining())
{
const size_t got = pipe.read(buffer.data(), buffer.size());
stream.write(cast_uint8_ptr_to_char(buffer.data()), got);
}
if(!stream.good())
throw Stream_IO_Error("Pipe output operator (iostream) has failed");
return stream;
}
/*************************************************
* DataSource_Stream Constructor *
*************************************************/
DataSource_Stream::DataSource_Stream(const std::string& file,
bool use_binary) : fsname(file)
{
if(use_binary)
source = new std::ifstream(fsname.c_str(), std::ios::binary);
else
source = new std::ifstream(fsname.c_str());
if(!source->good())
throw Stream_IO_Error("DataSource_Stream: Failure opening " + fsname);
total_read = 0;
}
/*
* Write data from a pipe into an ostream
*/
std::ostream& operator<<(std::ostream& stream, Pipe& pipe)
{
secure_vector<byte> buffer(DEFAULT_BUFFERSIZE);
while(stream.good() && pipe.remaining())
{
size_t got = pipe.read(buffer.data(), buffer.size());
stream.write(reinterpret_cast<const char*>(buffer.data()), got);
}
if(!stream.good())
throw Stream_IO_Error("Pipe output operator (iostream) has failed");
return stream;
}
/*
* Do heuristic tests for BER data
*/
bool maybe_BER(DataSource& source)
{
uint8_t first_u8;
if(!source.peek_byte(first_u8))
{
BOTAN_ASSERT_EQUAL(source.read_byte(first_u8), 0, "Expected EOF");
throw Stream_IO_Error("ASN1::maybe_BER: Source was empty");
}
if(first_u8 == (SEQUENCE | CONSTRUCTED))
return true;
return false;
}
/*
* DataSink_Stream Constructor
*/
DataSink_Stream::DataSink_Stream(const std::string& path,
bool use_binary) :
identifier(path),
sink_p(new std::ofstream(
path.c_str(),
use_binary ? std::ios::binary : std::ios::out)),
sink(*sink_p)
{
if(!sink.good())
{
delete sink_p;
throw Stream_IO_Error("DataSink_Stream: Failure opening " + path);
}
}
/*
* DataSource_Stream Constructor
*/
DataSource_Stream::DataSource_Stream(const std::string& path,
bool use_binary) :
identifier(path),
source_p(new std::ifstream(
path.c_str(),
use_binary ? std::ios::binary : std::ios::in)),
source(*source_p),
total_read(0)
{
if(!source.good())
{
delete source_p;
throw Stream_IO_Error("DataSource: Failure opening file " + path);
}
}
/**
* Peek at the pipe contents
*/
u32bit DataSource_Command::peek(byte[], u32bit, u32bit) const
{
if(end_of_data())
throw Invalid_State("DataSource_Command: Cannot peek when out of data");
throw Stream_IO_Error("Cannot peek/seek on a command pipe");
}
