/** \file
* IStream adapters.
*/
/*
* Copyright (C) 2013 Alexander Lamaison <alexander.lamaison@gmail.com>
*
* This material is provided "as is", with absolutely no warranty
* expressed or implied. Any use is at your own risk. Permission to
* use or copy this software for any purpose is hereby granted without
* fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is
* granted, provided the above notices are retained, and a notice that
* the code was modified is included with the above copyright notice.
*
* This header is part of Comet version 2.
* https://github.com/alamaison/comet
*/
#ifndef COMET_STREAM_H
#define COMET_STREAM_H
#include <comet/config.h>
#include <comet/bstr.h> // bstr_t
#include <comet/error.h> // com_error
#include <comet/handle_except.h> // COMET_CATCH_CLASS_INTERFACE_BOUNDARY
#include <comet/server.h> // simple_object
#include <cassert> // assert
#include <istream>
#include <limits> // numeric_limits
#include <ostream>
#include <strsafe.h> // StringCbCopyW
namespace comet {
namespace impl {
static const size_t COPY_CHUNK_SIZE = 512;
/**
* Used to clear stream failure on exiting a scope.
*
* Useful when trying an operation and converting any failure to an
* exception. In that case there is no need for the stream object to
* also retain evidence of the failure.
*
* Note, only clears `failbit`. `eofbit` is left alone as it is a
* valid consequence of operations performed by the wrapper. `badbit` is
* also left as these errors are unrecoverable and therefore the
* stream is as good as dead; a caller of the unwrapped stream needs
* to know that.
*/
template<typename Stream>
class stream_failure_cleanser
{
public:
explicit stream_failure_cleanser(Stream& stream)
: m_stream(stream)
{}
~stream_failure_cleanser() throw()
{
try
{
m_stream.clear(m_stream.rdstate() & ~std::ios_base::failbit);
}
catch (const std::exception&)
{}
}
private:
stream_failure_cleanser(const stream_failure_cleanser&);
stream_failure_cleanser& operator=(const stream_failure_cleanser&);
Stream& m_stream;
};
// These do_read/write helper functions dispatch the stream-type specific code
// so that we only need one class to implement all the stream adapters
inline void do_istream_read(
std::istream& stream, void* buffer, ULONG buffer_size_in_bytes,
ULONG& bytes_read_out)
{
typedef std::istream stream_type;
//
// IMPORTANT: The bytes_read_out count must be correct even in the
// error case, EVEN if that error is an exception, because the caller
// can treat an error as EOF (see Read method docs).
//
// However, in the error case it is acceptable to make the read count
// smaller than the actual number of bytes read (e.g. 0) because the
// caller is losing the unread part of the stream anyway. Losing a few
// extra bytes that are already in the buffer but not declared valid
// by the byte count will not make the situation worse.
bytes_read_out = 0U;
stream.read(
reinterpret_cast<char*>(buffer),
buffer_size_in_bytes / sizeof(std::istream::char_type));
// Any failure not caused by eof is a failure.
// Badbit is always a failure because, even if we are at eof, the stream
// encountered a problem that needs reporting.
if (stream.bad() || (stream.fail() && !stream.eof()))
{
throw std::runtime_error("Reading from stream failed");
}
else
{
if (stream.gcount() >= 0 &&
// temp conversion to unsigned larger than ULONG to catch
// values larger than ULONG
static_cast<ULONGLONG>(stream.gcount()) <
(std::numeric_limits<ULONG>::max)() /
sizeof(std::istream::char_type))
{
bytes_read_out = static_cast<ULONG>(
stream.gcount() * sizeof(std::istream::char_type));
}
assert(stream.eof() || bytes_read_out == buffer_size_in_bytes);
}
}
inline void do_ostream_write(
std::ostream& stream, const void* buffer, ULONG buffer_size_in_bytes,
ULONG& bytes_written_out)
{
// If there is an error we cannot get a reliable write count, even
// if we were to use stream.rdbuf()->sputn, because the failure
// might well happen during the flush operation which doesn't let
// us find out how much was flushed before failing.
typedef std::ostream stream_type;
bytes_written_out = 0U;
stream.write(
reinterpret_cast<const char*>(buffer),
buffer_size_in_bytes / sizeof(std::ostream::char_type));
try
{
stream.flush();
}
catch (const std::exception& e)
{
throw com_error(e.what(), STG_E_MEDIUMFULL);
}
if (stream.good())
{
bytes_written_out = buffer_size_in_bytes;
}
else
{
throw com_error("Writing to stream failed", STG_E_MEDIUMFULL);
}
}
/** Ensure read position updated even in case of exception */
template<typename Stream>
class read_position_finaliser
{
public:
read_position_finaliser(
Stream& stream, std::streampos& new_position_out)
: m_stream(stream), m_new_position_out(new_position_out)
{}
~read_position_finaliser() throw()
{
try
{
// we still want the read position if previous op failed
m_stream.clear();
std::streampos new_position = m_stream.tellg();
if (m_stream)
{
m_new_position_out = new_position;
}
else
{
m_new_position_out = std::streampos();
}
}
catch (...)
{
// We tried. Nothing else we can do
//
// We likely ended up here in the exception unwinding of a
// failed seek because a non-seekable stream chose to let us
// know by throwing an exception from the streambuf
// (e.g. Boost.IOStream). Non-seekable is also non-tellable so
// telgp does the same thing.
//
// We have prevent this exception propagating else we get an
// thrown while unwinding another exception causing terminate()
m_new_position_out = std::streampos(-1);
}
}
private:
read_position_finaliser(const read_position_finaliser&);
read_position_finaliser& operator=(const read_position_finaliser&);
Stream& m_stream;
std::streampos& m_new_position_out;
};
/** Ensure write position updated even in case of exception */
template<typename Stream>
class write_position_finaliser
{
public:
write_position_finaliser(
Stream& stream, std::streampos& new_position_out)
: m_stream(stream), m_new_position_out(new_position_out)
{}
~write_position_finaliser() throw()
{
try
{
// we still want the write position if previous op failed
m_stream.clear();
std::streampos new_position = m_stream.tellp();
if (m_stream)
{
m_new_position_out = new_position;
}
else
{
m_new_position_out = std::streampos();
}
}
catch (...)
{
// We tried. Nothing else we can do
//
// We likely ended up here in the exception unwinding of a
// failed seek because a non-seekable stream chose to let us
// know by throwing an exception from the streambuf
// (e.g. Boost.IOStream). Non-seekable is also non-tellable so
// tellp does the same thing.
//
// We have prevent this exception propagating else we get an
// thrown while unwinding another exception causing terminate()
m_new_position_out = std::streampos(-1);
}
}
private:
write_position_finaliser(const write_position_finaliser&);
write_position_finaliser& operator=(const write_position_finaliser&);
Stream& m_stream;
std::streampos& m_new_position_out;
};
/**
* Copies `streampos` out-parameter to ULARGE_INTEGER out parameter
* in the face of exceptions.
*
* Using this class means you can concentrate on keeping the `streampos`
* variable updated, confident in the knowledge the the COM-interface
* ULARGE_INTEGER parameter will eventually be updated to match it,
* no matter what.
*
* Assumes that the source out parameter is guaranteed to be valid at
* all times. Valid doesn't necessarily mean correct but that it always
* contains the value we want to set the out parameter to, even if that is
* wrong (for instance failure while calculating correct position).
*/
class position_out_converter
{
public:
position_out_converter(
std::streampos& source_out_parameter,
ULARGE_INTEGER* destination_out_parameter)
:
m_source(source_out_parameter),
m_destination(destination_out_parameter) {}
~position_out_converter()
{
if (m_destination)
{
try
{
// Convert to streamoff because streampos may not
// be an integer. streamoff is guaranteed to be.
std::streamoff offset_from_beginning = m_source;
if (offset_from_beginning < 0)
{
// Invalid offset, for example seeking not supported
// The error itself is dealt with right after seeking
// so this class just has to convert it to something
// reasonable for an unsigned value
m_destination->QuadPart = 0U;
}
else
{
m_destination->QuadPart = offset_from_beginning;
}
}
catch(const std::exception&)
{
// Only way this can happen is if streampos refuses to
// convert to streamoff in which case we really are screwed.
m_destination->QuadPart = 0U;
}
}
}
private:
position_out_converter(const position_out_converter&);
position_out_converter& operator=(const position_out_converter&);
std::streampos& m_source;
ULARGE_INTEGER* m_destination;
};
/**
* Increments a total counter with an increment are end of scope,
* regardless of how that scope is ended.
*
* Assumes the increment parameter is valid at all times.
*/
class byte_count_incrementer
{
public:
byte_count_incrementer(
ULARGE_INTEGER* total, ULONG& increment)
: m_total(total), m_increment(increment) {}
~byte_count_incrementer()
{
if (m_total)
{
m_total->QuadPart += m_increment;
}
}
private:
byte_count_incrementer(const byte_count_incrementer&);
byte_count_incrementer& operator=(const byte_count_incrementer&);
ULARGE_INTEGER* m_total;
ULONG& m_increment;
};
template<typename StreamTraits>
class position_resetter
{
public:
position_resetter(StreamTraits& traits, std::streampos position)
:
m_traits(traits), m_position(position) {}
~position_resetter()
{
try
{
std::streampos new_position;
m_traits.do_seek(
m_position, std::ios_base::beg, new_position);
assert(new_position == m_position);
}
catch (const std::exception&)
{}
}
private:
position_resetter(const position_resetter&);
position_resetter& operator=(const position_resetter&);
StreamTraits& m_traits;
std::streampos m_position;
};
/**
* Calculate offset of end of stream from start.
*/
template<typename StreamTraits>
inline std::streamoff stream_size(StreamTraits& traits)
{
position_resetter<StreamTraits>(traits, traits.do_tell());
std::streampos new_position;
traits.do_seek(0, std::ios_base::end, new_position);
return new_position;
}
template<typename Stream, bool is_istream, bool is_ostream>
class stream_traits;
template<typename Stream>
class stream_traits<Stream, true, false>
{
public:
explicit stream_traits(Stream& stream) : m_stream(stream) {}
void do_read(
void* buffer, ULONG buffer_size_in_bytes,
ULONG& bytes_read_out)
{
do_istream_read(
m_stream, buffer, buffer_size_in_bytes, bytes_read_out);
}
void do_write(
const void* /*buffer*/,
ULONG /*buffer_size_in_bytes*/, ULONG& bytes_written_out)
{
bytes_written_out = 0U;
throw com_error(
"std::istream does not support writing", STG_E_ACCESSDENIED);
}
void do_seek(
std::streamoff offset, std::ios_base::seekdir way,
std::streampos& new_position_out)
{
read_position_finaliser<Stream> position_out_updater(
m_stream, new_position_out);
if (!m_stream.seekg(offset, way))
{
throw std::runtime_error("Unable to change read position");
}
}
std::streampos do_tell()
{
std::streampos pos = m_stream.tellg();
if (!m_stream)
{
throw std::runtime_error("Stream position unavailable");
}
return pos;
}
void do_flush()
{
throw com_error(
"std::istream does not support committing data",
STG_E_ACCESSDENIED);
}
private:
stream_traits(const stream_traits&);
stream_traits& operator=(const stream_traits&);
Stream& m_stream;
};
template<typename Stream>
class stream_traits<Stream, false, true>
{
public:
explicit stream_traits(Stream& stream) : m_stream(stream) {}
void do_read(
void* /*buffer*/,
ULONG /*buffer_size_in_bytes*/, ULONG& bytes_read_out)
{
bytes_read_out = 0U;
throw com_error(
"std::ostream does not support reading", STG_E_ACCESSDENIED);
}
void do_write(
const void* buffer,
ULONG buffer_size_in_bytes, ULONG& bytes_written_out)
{
do_ostream_write(
m_stream, buffer, buffer_size_in_bytes, bytes_written_out);
}
void do_seek(
std::streamoff offset, std::ios_base::seekdir way,
std::streampos& new_position_out)
{
write_position_finaliser<Stream> position_out_updater(
m_stream, new_position_out);
if (!m_stream.seekp(offset, way))
{
throw std::runtime_error("Unable to change write position");
}
}
std::streampos do_tell()
{
std::streampos pos = m_stream.tellp();
if (!m_stream)
{
throw std::runtime_error("Stream position unavailable");
}
return pos;
}
void do_flush()
{
if (!m_stream.flush())
{
throw std::runtime_error(
"Unable to flush buffer to output sequence");
}
}
private:
stream_traits(const stream_traits&);
stream_traits& operator=(const stream_traits&);
Stream& m_stream;
};
template<typename Stream>
class stream_traits<Stream, true, true>
{
private:
enum last_stream_operation
{
read,
write
};
public:
explicit stream_traits(Stream& stream)
: m_stream(stream), m_last_op(read) {}
void do_read(
void* buffer, ULONG buffer_size_in_bytes, ULONG& bytes_read_out)
{
bytes_read_out = 0U;
// sync reading position with writing position, which was the last
// one used and is allowed to be different in C++ streams but
// not COM IStreams
if (m_last_op == write)
{
m_stream.seekg(m_stream.tellp());
// We ignore errors syncing the positions as even iostreams may
// not be seekable at all
m_last_op = read;
}
assert(m_last_op == read);
do_istream_read(
m_stream, buffer, buffer_size_in_bytes, bytes_read_out);
}
void do_write(
const void* buffer, ULONG buffer_size_in_bytes,
ULONG& bytes_written_out)
{
bytes_written_out = 0U;
// sync writing position with reading position, which was the last
// one used and is allowed to be different in C++ streams but
// not COM IStreams
if (m_last_op == read)
{
m_stream.seekp(m_stream.tellg());
// We ignore errors syncing the positions as even iostreams may
// not be seekable at all
m_last_op = write;
}
assert(m_last_op == write);
do_ostream_write(
m_stream, buffer, buffer_size_in_bytes, bytes_written_out);
}
void do_seek(
std::streamoff offset, std::ios_base::seekdir way,
std::streampos& new_position_out)
{
// Unlike with do_read/do_write, we do not ignore errors when
// trying to sync the read/write positions as, if the
// first seek succeeded, we know the stream supports
// seeking. Therefore a later error is really an error.
if (m_last_op == read)
{
read_position_finaliser<Stream> position_out_updater(
m_stream, new_position_out);
if (!m_stream.seekg(offset, way))
{
throw std::runtime_error("Unable to change read position");
}
else
{
if (!m_stream.seekp(m_stream.tellg()))
{
throw std::runtime_error(
"Unable to synchronise write position");
}
}
}
else
{
write_position_finaliser<Stream> position_out_updater(
m_stream, new_position_out);
if (!m_stream.seekp(offset, way))
{
throw std::runtime_error("Unable to change write position");
}
else
{
if (!m_stream.seekg(m_stream.tellp()))
{
throw std::runtime_error(
"Unable to synchronise read position");
}
}
}
}
std::streampos do_tell()
{
std::streampos pos;
if (m_last_op == read)
{
pos = m_stream.tellg();
}
else
{
pos = m_stream.tellp();
}
if (!m_stream)
{
throw std::runtime_error("Stream position unavailable");
}
return pos;
}
void do_flush()
{
if (!m_stream.flush())
{
throw std::runtime_error(
"Unable to flush buffer to output sequence");
}
}
private:
stream_traits(const stream_traits&);
stream_traits& operator=(const stream_traits&);
Stream& m_stream;
last_stream_operation m_last_op;
};
/**
* Wrap COM IStream interface around C++ IOStream.
*
* Unlike C++ streams which may have separate read and write positions that
* move independently, COM IStreams assume a single combined read/write head.
* Therefore this wrapper always starts the next read or write operation
* from the where the last operation finished, regardless of whether that
* operation was a call to `Read` or `Write`.
*
* @note This only applies for as long as the read/write positions are
* modified only via this wrapper. If the positions are modified by
* directly on the underlying IOStream, it is undefined whether the
* starting point for the next call to `Read`/`Write` is syncronised
* with the end of the previous operation.
*
* If operations on the inner stream results in failure (the `failbit`
* is set), this is communicated via the COM-interface return code. The
* `failbit` is cleared before the call returns. This allows further
* wrapper methods to be called without having the clear the bit directly
* on the underlying stream. Fatal errors (`badbit`) and end-of-file
* (`eofbit`) are left unchanged and remain visible in the underlying
* stream.
*/
template<typename Stream>
class adapted_stream : public simple_object<IStream>
{
private:
typedef impl::stream_traits<
Stream,
type_traits::super_sub_class<std::istream, Stream>::result,
type_traits::super_sub_class<std::ostream, Stream>::result
> stream_traits_type;
public:
adapted_stream(Stream& stream, const bstr_t& optional_name)
: m_stream(stream), m_traits(stream),
m_optional_name(optional_name) {}
/**
* Fill the given buffer with data read from the wrapped C++ stream.
*
* @param [in] buffer
* Destination of bytes to be read.
*
* @param [in] buffer_size
* Size of `buffer` and, therefore, the maximum number of bytes
* this method will read. The method may read fewer than this
* number of bytes if the request cannot be fulfilled
* (e.g. end-of-file, error), in which case only the portion of
* `buffer` up to `*read_count_out` bytes from the start
* may be considered valid.
*
* @param [out] read_count_out
* Number of bytes actually read into `buffer`. In other words,
* the extent of the valid bytes in `buffer` once this method
* returns. This value is correct whether the method returns
* success or an error code.
*
* @returns
* Error code indicating the success or failure of the method.
* @retval `S_OK`
* If `buffer` was completely filled.
* @retval `S_FALSE` if EOF reached before `buffer` was filled.
* `*read_count_out` gives the number of bytes that were read.
* @retval a COM error code
* If there was a read error.
*
* Error behaviour rationale
* -------------------------
*
* MSDN says that, if `read_count_out` < `buffer_size`, callers
* should treat both error codes and success codes as meaning
* the end-of-file was reached. However, doing so means they will be
* unable to distinguish EOF from a genuine read error. Therefore,
* we make the stronger guarantee that only `S_FALSE` means EOF
* while an error code always indicates a read error.
* To accommodate callers who follow the documentation on MSDN,
* we ensure that the read-count out-variable is correct even if the
* wrapped stream encountered an error (`failbit`, `badbit`) or
* threw an exception, because the caller may use the byte-count to
* decide which bytes of the partial read are valid.
*
* In the error case, `*read_count_out` may be less than the number
* of bytes actually read from the wrapped stream. This is for
* performance reasons: unless we read from the wrapped stream one
* byte at a time, there is no way to calculate the the exact number
* of bytes read if an exception is thrown part way through reading.
* Byte-by-byte reading is hopelessly slow for some applications, such
* as an unbuffered stream over a network, so our behaviour is a
* pragmatic compromise. We believe it is within the (vaguely)
* documented behaviour of `IStream` to treat the out-count in this way
* for error cases as the count still delimits a valid region of bytes.
*/
virtual HRESULT STDMETHODCALLTYPE Read(
void* buffer, ULONG buffer_size, ULONG* read_count_out)
{
impl::stream_failure_cleanser<Stream> state_resetter(m_stream);
if (read_count_out)
{
*read_count_out = 0U;
}
try
{
if (!buffer)
{
throw com_error("No buffer given", STG_E_INVALIDPOINTER);
}
// We use a dummy read count location if one is not given so
// that do_read can keep it updated correctly even if
// do_read throws an exception.
ULONG dummy_read_count = 0U;
if (!read_count_out)
{
read_count_out = &dummy_read_count;
}
m_traits.do_read(buffer, buffer_size, *read_count_out);
if (*read_count_out < buffer_size)
{
assert(m_stream.eof());
return S_FALSE;
}
else
{
assert(*read_count_out == buffer_size);
assert(m_stream.good());
return S_OK;
}
}
COMET_CATCH_CLASS_INTERFACE_BOUNDARY("Read", "adapted_stream");
}
/**
* Write the given data to the wrapped C++ stream's controlled sequence.
*
* The wrapped stream is flushed before this method returns to ensure
* the data is written to the controlled sequence (and any associated
* errors are detected) rather than just to the stream's buffer.
* Therefore, best performance is obtained if this method is called with
* as much data as possible for the fewest number of flushes.
*
* @param [in] data
* Bytes to write to the controlled sequence.
*
* @param [in] data_size
* Size of `data` and the number of bytes to write.
*
* @param [out] written_count_out
* Number of bytes guaranteed to be written to the controlled
* sequence. This will be `data_size` if writing succeeded. If
* an error occurred, this may be fewer than the actual number of
* bytes written to the sequence.
*
* @returns
* Error code indicating the success or failure of the method.
* @retval `S_OK`
* If `data` was completely written to the wrapped stream's
* controlled sequence.
* @retval a COM error code
* If there was a write error.
*
* Error behaviour rationale
* -------------------------
*
* If writing succeeds, `*written_count_out` equals `data_size`. If
* writing encountered an error `*written_count_out` will be set to zero,
* even if some bytes were written out. We do this for performance
* reasons: unless we write the data one byte at a time to the wrapped
* stream _and flush the stream after each byte_, the C++ streams don't
* provide a way to count the exact number of bytes written to the
* stream's controlled sequence. Byte-by-byte writing is hopelessly
* slow for some applications, such as a stream over a network, so our
* behaviour is a pragmatic compromise.
* We believe it is within the (vaguely) documented behaviour of
* `IStream` to treat the out-count in this way for error cases.
* It may seem strange that this method even has an out-count if it
* was no intended to be meaningful in the error case (the count would
* be equal to `data_size` in the success case), however we believe
* it was only intended to be meaningful for non-blocking writes to
* asynchronous stream (`E_PENDING` would be returned) which this
* wrapper is not (see http://bit.ly/1hZGy1L).
*/
virtual HRESULT STDMETHODCALLTYPE Write(
const void* data, ULONG data_size, ULONG* written_count_out)
{
stream_failure_cleanser<Stream> state_resetter(m_stream);
if (written_count_out)
{
*written_count_out = 0U;
}
try
{
if (!data)
{
throw com_error("Buffer not given", STG_E_INVALIDPOINTER);
}
// We use a dummy written count out location if one is not
// given so that do_write can keep it updated correctly even if
// do_write throws an exception.
ULONG dummy_written_count = 0U;
if (!written_count_out)
{
written_count_out = &dummy_written_count;
}
m_traits.do_write(data, data_size, *written_count_out);
if (*written_count_out < data_size)
{
throw com_error(
"Unable to complete write operation", STG_E_MEDIUMFULL);
}
else
{
assert(*written_count_out == data_size);
return S_OK;
}
}
COMET_CATCH_CLASS_INTERFACE_BOUNDARY("Write", "adapted_stream");
}
virtual HRESULT STDMETHODCALLTYPE Seek(
LARGE_INTEGER offset, DWORD origin,
ULARGE_INTEGER* new_position_out)
{
stream_failure_cleanser<Stream> state_resetter(m_stream);
std::streampos new_stream_position_out = std::streampos();
impl::position_out_converter out_param_guard(
new_stream_position_out, new_position_out);
try
{
std::ios_base::seekdir way;
if (origin == STREAM_SEEK_CUR)
{
way = std::ios_base::cur;
}
else if (origin == STREAM_SEEK_SET)
{
way = std::ios_base::beg;
}
else if (origin == STREAM_SEEK_END)
{
way = std::ios_base::end;
}
else
{
throw com_error(
"Unrecognised stream seek origin",
STG_E_INVALIDFUNCTION);
}
if (offset.QuadPart >
(std::numeric_limits<std::streamoff>::max)())
{
throw com_error(
"Seek offset too large", STG_E_INVALIDFUNCTION);
}
else if (offset.QuadPart <
(std::numeric_limits<std::streamoff>::min)())
{
throw com_error(
"Seek offset too small", STG_E_INVALIDFUNCTION);
}
else
{
try
{
m_traits.do_seek(
static_cast<std::streamoff>(offset.QuadPart),
way, new_stream_position_out);
}
// Translate logic_errors (and subtypes) as they
// correspond (very roughly) to the kinds of errors
// for which IStream::Seek is documented to return
// STG_E_INVALIDFUNCTION
catch(const std::logic_error& e)
{
throw com_error(e.what(), STG_E_INVALIDFUNCTION);
}
return S_OK;
}
}
COMET_CATCH_CLASS_INTERFACE_BOUNDARY("Seek", "adapted_stream");
}
/**
* Expand stream to given size.
*
* The will only increase a stream's size if it is smaller than the
* given size. If the stream size is already equal or bigger, it
* remains unchanged.
*
* Not all streams support changing size. In particular, `istream`s
* do not support this method.
*/
virtual HRESULT STDMETHODCALLTYPE SetSize(ULARGE_INTEGER new_size)
{
try
{
stream_failure_cleanser<Stream> state_resetter(m_stream);
position_resetter<stream_traits_type> resetter(
m_traits, m_traits.do_tell());
if (new_size.QuadPart > 0)
{
ULARGE_INTEGER new_end_position;
new_end_position.QuadPart = new_size.QuadPart - 1;
std::streamoff new_offset;
if ((std::numeric_limits<std::streamoff>::max)() < 0)
{
assert(!"Purely negative number!");
throw com_error(
"Seek offset too large", STG_E_INVALIDFUNCTION);
}
else if (new_end_position.QuadPart >
static_cast<ULONGLONG>(
(std::numeric_limits<std::streamoff>::max)()))
{
throw com_error(
"Seek offset too large", STG_E_INVALIDFUNCTION);
}
else
{
new_offset = static_cast<std::streamoff>(
new_end_position.QuadPart);
}
std::streamoff existing_end = stream_size(m_traits);
if (new_offset > existing_end)
{
std::streampos new_position;
m_traits.do_seek(
new_offset, std::ios_base::beg, new_position);
assert(std::streamoff(new_position) == new_offset);
// Force the stream to expand by writing NUL at
// new extent
ULONG bytes_written;
m_traits.do_write("\0", 1, bytes_written);
assert(bytes_written == 1);
}
}
return S_OK;
}
COMET_CATCH_CLASS_INTERFACE_BOUNDARY("SetSize", "adapted_stream");
}
virtual HRESULT STDMETHODCALLTYPE CopyTo(
IStream* destination, ULARGE_INTEGER amount,
ULARGE_INTEGER* bytes_read_out, ULARGE_INTEGER* bytes_written_out)
{
stream_failure_cleanser<Stream> state_resetter(m_stream);
ULARGE_INTEGER dummy_read_out;
if (!bytes_read_out)
{
bytes_read_out = &dummy_read_out;
}
bytes_read_out->QuadPart = 0U;
ULARGE_INTEGER dummy_written_out;
if (!bytes_written_out)
{
bytes_written_out = &dummy_written_out;
}
bytes_written_out->QuadPart = 0U;
try
{
if (!destination)
{
throw com_error(
"Destination stream not given", STG_E_INVALIDPOINTER);
}
std::vector<unsigned char> buffer(COPY_CHUNK_SIZE);
// Perform copy operation in chunks COPY_CHUNK bytes big
// The chunk must be less than the biggest ULONG in size
// because of the limits of the Read/Write API. Of course
// it will be in any case as it would be insane to use more
// memory than that, but we make sure anyway using the first
// min comparison
do {
ULONG next_chunk_size =
static_cast<ULONG>(
min(
(std::numeric_limits<ULONG>::max)(),
min(
amount.QuadPart - bytes_read_out->QuadPart,
buffer.size())));
ULONG read_this_round = 0U;
ULONG written_this_round = 0U;
// These two take care of updating the total on each pass
// round the loop as well as on termination, exception or
// natural.
//
// The means the out counts are valid even in the failure
// case. MSDN says they don't have to be but, as we can,
// we might as well
impl::byte_count_incrementer read_incrementer(
bytes_read_out, read_this_round);
impl::byte_count_incrementer write_incrementer(
bytes_written_out, written_this_round);
m_traits.do_read(
&buffer[0], next_chunk_size, read_this_round);
HRESULT hr = destination->Write(
&buffer[0], read_this_round, &written_this_round);
if (FAILED(hr))
{
com_error_from_interface(destination, hr);
}
if (read_this_round < next_chunk_size)
{
// EOF
break;
}
} while (amount.QuadPart > bytes_read_out->QuadPart);
return S_OK;
}
COMET_CATCH_CLASS_INTERFACE_BOUNDARY("CopyTo", "adapted_stream");
}
/**
* Flush data in the buffer to the controlled output sequence.
*
* This implementation doesn't support transactions so ignores
* the commit flags.
*
* Fails if called with an istream.
*/
virtual HRESULT STDMETHODCALLTYPE Commit(DWORD /*commit_flags*/)
{
stream_failure_cleanser<Stream> state_resetter(m_stream);
try
{
m_traits.do_flush();
return S_OK;
}
COMET_CATCH_CLASS_INTERFACE_BOUNDARY("Commit", "adapted_stream");
}
virtual HRESULT STDMETHODCALLTYPE Revert()
{
try
{
throw com_error("Transactions not supported", E_NOTIMPL);
}
COMET_CATCH_CLASS_INTERFACE_BOUNDARY("Revert", "adapted_stream");
}
virtual HRESULT STDMETHODCALLTYPE LockRegion(
ULARGE_INTEGER /*offset*/, ULARGE_INTEGER /*extent*/,
DWORD /*lock_type*/)
{
try
{
throw com_error(
"Locking not supported", STG_E_INVALIDFUNCTION);
}
COMET_CATCH_CLASS_INTERFACE_BOUNDARY("LockRegion", "adapted_stream");
}
virtual HRESULT STDMETHODCALLTYPE UnlockRegion(
ULARGE_INTEGER /*offset*/, ULARGE_INTEGER /*extent*/,
DWORD /*lock_type*/)
{
try
{
throw com_error(
"Locking not supported", STG_E_INVALIDFUNCTION);
}
COMET_CATCH_CLASS_INTERFACE_BOUNDARY("UnlockRegion", "adapted_stream");
}
/**
* Get some metadata about the stream.
*
* The name returned (if requested) is the name optionally given
* in the constructor. If not given in the constructor, an
* empty string is returned.
*
* Some fields, such as the date fields, are not valid as that data
* is not available for IOStreams.
*/
virtual HRESULT STDMETHODCALLTYPE Stat(
STATSTG* attributes_out, DWORD stat_flag)
{
try
{
if (!attributes_out)
{
throw com_error("STATSTG not given", STG_E_INVALIDPOINTER);
}
*attributes_out = STATSTG();
attributes_out->type = STGTY_STREAM;
try
{
attributes_out->cbSize.QuadPart =
impl::stream_size(m_traits);
}
catch (const std::exception&)
{
// Swallow non-bad errors as many stream are not seekable and
// therefore not sizeable
if (m_stream.bad())
throw;
}
// Must be last as, after we detach, any failure will leak
// memory
if (!(stat_flag & STATFLAG_NONAME))
{
// pwcsName is NOT a BSTR. It's a null-terminated OLESTR
// managed by the COM memory allocator
size_t buffer_size = m_optional_name.size() + 1;
size_t buffer_size_in_bytes =
buffer_size * sizeof(wchar_t);
attributes_out->pwcsName = static_cast<LPOLESTR>(
::CoTaskMemAlloc(buffer_size_in_bytes));
if (!attributes_out->pwcsName)
{
throw com_error(
"Unable to allocate memory for stream name",
STG_E_INSUFFICIENTMEMORY);
}
try
{
HRESULT hr = ::StringCbCopyW(
attributes_out->pwcsName, buffer_size_in_bytes,
m_optional_name.c_str());
if (FAILED(hr))
{
throw com_error(
"Unable to copy stream name to STATSTG", hr);
}
}
catch(...)
{
::CoTaskMemFree(attributes_out->pwcsName);
throw;
}
}
return S_OK;
}
COMET_CATCH_CLASS_INTERFACE_BOUNDARY("Stat", "adapted_stream");
}
/**
* Cloning not supported for IOStreams as they are not copyable.
*/
virtual HRESULT STDMETHODCALLTYPE Clone(IStream** stream_out)
{
if (stream_out)
{
*stream_out = NULL;
}
try
{
throw com_error(
"Cloning not supported", STG_E_INVALIDFUNCTION);
}
COMET_CATCH_CLASS_INTERFACE_BOUNDARY("Clone", "adapted_stream");
}
private:
Stream& m_stream;
stream_traits_type m_traits;
bstr_t m_optional_name;
};
template<typename StreamPtr>
class adapted_stream_pointer : public simple_object<IStream>
{
public:
adapted_stream_pointer(StreamPtr stream, const bstr_t& optional_name)
: m_stream(stream), m_inner(adapt_stream(*m_stream, optional_name))
{}
// The forwarded methods must return their HRESULT by throwing and
// catching in order to propagate the IErrorInfo upwards.
virtual HRESULT STDMETHODCALLTYPE Read(
void* buffer, ULONG buffer_size, ULONG* read_count_out)
{
if (read_count_out)
{
*read_count_out = 0U;
}
try
{
HRESULT hr = m_inner->Read(buffer, buffer_size, read_count_out);
if (FAILED(hr))
throw com_error_from_interface(m_inner, hr);
return hr;
}
COMET_CATCH_CLASS_INTERFACE_BOUNDARY(
"Read", "adapted_stream_pointer");
}
virtual HRESULT STDMETHODCALLTYPE Write(
const void* buffer, ULONG buffer_size, ULONG* written_count_out)
{
if (written_count_out)
{
*written_count_out = 0U;
}
try
{
HRESULT hr = m_inner->Write(
buffer, buffer_size, written_count_out);
if (FAILED(hr))
throw com_error_from_interface(m_inner, hr);
return hr;
}
COMET_CATCH_CLASS_INTERFACE_BOUNDARY(
"Write", "adapted_stream_pointer");
}
virtual HRESULT STDMETHODCALLTYPE Seek(
LARGE_INTEGER offset, DWORD origin,
ULARGE_INTEGER* new_position_out)
{
if (new_position_out)
{
new_position_out->QuadPart = 0U;
}
try
{
HRESULT hr = m_inner->Seek(offset, origin, new_position_out);
if (FAILED(hr))
throw com_error_from_interface(m_inner, hr);
return hr;
}
COMET_CATCH_CLASS_INTERFACE_BOUNDARY(
"Seek", "adapted_stream_pointer");
}
virtual HRESULT STDMETHODCALLTYPE SetSize(ULARGE_INTEGER new_size)
{
try
{
HRESULT hr = m_inner->SetSize(new_size);
if (FAILED(hr))
throw com_error_from_interface(m_inner, hr);
return hr;
}
COMET_CATCH_CLASS_INTERFACE_BOUNDARY(
"SetSize", "adapted_stream_pointer");
}
virtual HRESULT STDMETHODCALLTYPE CopyTo(
IStream* destination, ULARGE_INTEGER amount,
ULARGE_INTEGER* bytes_read_out, ULARGE_INTEGER* bytes_written_out)
{
if (bytes_read_out)
{
bytes_read_out->QuadPart = 0U;
}
if (bytes_written_out)
{
bytes_written_out->QuadPart = 0U;
}
try
{
HRESULT hr = m_inner->CopyTo(
destination, amount, bytes_read_out, bytes_written_out);
if (FAILED(hr))
throw com_error_from_interface(m_inner, hr);
return hr;
}
COMET_CATCH_CLASS_INTERFACE_BOUNDARY(
"CopyTo", "adapted_stream_pointer");
}
virtual HRESULT STDMETHODCALLTYPE Commit(DWORD commit_flags)
{
try
{
HRESULT hr = m_inner->Commit(commit_flags);
if (FAILED(hr))
throw com_error_from_interface(m_inner, hr);
return hr;
}
COMET_CATCH_CLASS_INTERFACE_BOUNDARY(
"Commit", "adapted_stream_pointer");
}
virtual HRESULT STDMETHODCALLTYPE Revert()
{
try
{
HRESULT hr = m_inner->Revert();
if (FAILED(hr))
throw com_error_from_interface(m_inner, hr);
return hr;
}
COMET_CATCH_CLASS_INTERFACE_BOUNDARY(
"Revert", "adapted_stream_pointer");
}
virtual HRESULT STDMETHODCALLTYPE LockRegion(
ULARGE_INTEGER offset, ULARGE_INTEGER extent, DWORD lock_type)
{
try
{
HRESULT hr = m_inner->LockRegion(offset, extent, lock_type);
if (FAILED(hr))
throw com_error_from_interface(m_inner, hr);
return hr;
}
COMET_CATCH_CLASS_INTERFACE_BOUNDARY(
"LockRegion", "adapted_stream_pointer");
}
virtual HRESULT STDMETHODCALLTYPE UnlockRegion(
ULARGE_INTEGER offset, ULARGE_INTEGER extent, DWORD lock_type)
{
try
{
HRESULT hr = m_inner->UnlockRegion(offset, extent, lock_type);
if (FAILED(hr))
throw com_error_from_interface(m_inner, hr);
return hr;
}
COMET_CATCH_CLASS_INTERFACE_BOUNDARY(
"UnlockRegion", "adapted_stream_pointer");
}
virtual HRESULT STDMETHODCALLTYPE Stat(
STATSTG* attributes_out, DWORD stat_flag)
{
if (attributes_out)
{
*attributes_out = STATSTG();
}
try
{
HRESULT hr = m_inner->Stat(attributes_out, stat_flag);
if (FAILED(hr))
throw com_error_from_interface(m_inner, hr);
return hr;
}
COMET_CATCH_CLASS_INTERFACE_BOUNDARY(
"Stat", "adapted_stream_pointer");
}
virtual HRESULT STDMETHODCALLTYPE Clone(IStream** stream_out)
{
if (stream_out)
{
*stream_out = NULL;
}
try
{
HRESULT hr = m_inner->Clone(stream_out);
if (FAILED(hr))
throw com_error_from_interface(m_inner, hr);
return hr;
}
COMET_CATCH_CLASS_INTERFACE_BOUNDARY(
"Clone", "adapted_stream_pointer");
}
private:
StreamPtr m_stream;
com_ptr<IStream> m_inner;
};
}
/**
* Wrap COM IStream interface around C++ IOStream.
*
* The caller must ensure that the C++ IOStream remains valid until the
* last reference to the returned wrapper is released.
*
* Unlike C++ streams which may have separate read and write positions that
* move independently, COM IStreams assume a single combined read/write head.
* Therefore this wrapper always starts the next read or write operation
* from the where the last operation finished, regardless of whether that
* operation was a call to `Read` or `Write`.
*
* @note This only applies for as long as the read/write positions are
* modified only via this wrapper. If the positions are modified by
* directly on the underlying IOStream, it is undefined whether the
* starting point for the next call to `Read`/`Write` is syncronised
* with the end of the previous operation.
*
* If operations on the inner stream results in failure (the `failbit`
* is set), this is communicated via the COM-interface return code. The
* `failbit` is cleared before the call returns. This allows further
* wrapper methods to be called without having the clear the bit directly
* on the underlying stream. Fatal errors (`badbit`) and end-of-file
* (`eofbit`) are left unchanged and remain visible in the underlying
* stream.
*/
template<typename Stream>
inline com_ptr<IStream> adapt_stream(
Stream& stream, const bstr_t& optional_name=bstr_t())
{
return new impl::adapted_stream<Stream>(stream, optional_name);
}
/**
* Wrap COM IStream interface around pointer (usually smart) to C++ IOStream.
*
* If the pointer type is a smart pointer, the caller need not must ensure
* the lifetime of the C++ IOStream exceeds that of the adapter; the smart
* pointer takes care of ensuring this.
*
* The main reason for having this function in addition to `adapt_stream` is
* support the common case where a COM stream is intended to be the sole owner
* of the C++ stream with which it is created. This allows the caller to
* create the IStream and forget about the C++ stream. Using `adapt_stream`
* they would have to manage the lifetime of both.
*
* When we support movable types (C++11 or Boost.Move emulation), this method
* would become unnecessary for this purpose as the C++ stream could simply
* be moved into the adapter
*/
template<typename StreamPtr>
inline com_ptr<IStream> adapt_stream_pointer(
StreamPtr stream_pointer, const bstr_t& optional_name=bstr_t())
{
return new impl::adapted_stream_pointer<StreamPtr>(
stream_pointer, optional_name);
}
}
#endif