openssl_streambuf::int_type openssl_streambuf::overflow(openssl_streambuf::int_type c)
{
try
{
if (pptr() != pbase())
{
int n = _stream.sslWrite(pbase(), pptr() - pbase());
if (n <= 0)
return traits_type::eof();
}
setp(_buffer, _buffer + _bufsize);
if (c != traits_type::eof())
{
*pptr() = (char_type)c;
pbump(1);
}
return 0;
}
catch (const std::exception& e)
{
log_error("error int openssl_streambuf::overflow: " << e.what());
return traits_type::eof();
}
}
_STLP_EXP_DECLSPEC void strstreambuf::freeze(bool frozenflag)
{
#ifdef __SYMBIAN32__
if (_M_dynamic)
{
//
if (frozenflag && !_M_frozen)
{ // disable writing
_M_frozen = frozenflag;
_pfrozenendsave = epptr();
_pgetfrozenendsave = pptr();
setp(pbase(), eback());
}
else if (!frozenflag && _M_frozen)
{ // re-enable writing
_M_frozen = frozenflag;
if(_pfrozenendsave != NULL)
{
setp(pbase(), _pfrozenendsave);
setg(pbase(), pbase(), _pgetfrozenendsave);
}
}
}
#else
if (_M_dynamic)
_M_frozen = frozenflag;
#endif
}
strstreambuf::pos_type
strstreambuf::seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __which)
{
off_type __p(-1);
bool pos_in = (__which & ios::in) != 0;
bool pos_out = (__which & ios::out) != 0;
bool legal = false;
switch (__way)
{
case ios::beg:
case ios::end:
if (pos_in || pos_out)
legal = true;
break;
case ios::cur:
if (pos_in != pos_out)
legal = true;
break;
}
if (pos_in && gptr() == nullptr)
legal = false;
if (pos_out && pptr() == nullptr)
legal = false;
if (legal)
{
off_type newoff;
char* seekhigh = epptr() ? epptr() : egptr();
switch (__way)
{
case ios::beg:
newoff = 0;
break;
case ios::cur:
newoff = (pos_in ? gptr() : pptr()) - eback();
break;
case ios::end:
newoff = seekhigh - eback();
break;
default:
return pos_type(off_type(-1));
}
newoff += __off;
if (0 <= newoff && newoff <= seekhigh - eback())
{
char* newpos = eback() + newoff;
if (pos_in)
setg(eback(), newpos, _VSTD::max(newpos, egptr()));
if (pos_out)
{
// min(pbase, newpos), newpos, epptr()
__off = epptr() - newpos;
setp(min(pbase(), newpos), epptr());
pbump(static_cast<int>((epptr() - pbase()) - __off));
}
__p = newoff;
}
}
return pos_type(__p);
}
int server_streambuf::flush(bool end) {
std::error_code e;
// wait for previous responses in the pipeline to complete:
{
std::unique_lock<std::mutex> out_lock(act_mutex);
while (!active)
act_cond.wait(out_lock);
}
// flush headers if not already written:
if (!hdrs_written) {
size_t content_len;
if (!query_headers_content_length(out_hdrs, content_len)) {
chunked = true;
#ifdef CLANE_HAVE_STD_MULTIMAP_EMPLACE
out_hdrs.emplace("transfer-encoding", "chunked");
#else
out_hdrs.insert(header("transfer-encoding", "chunked"));
#endif
}
std::ostringstream ss;
ss << "HTTP/" << major_ver << '.' << minor_ver << ' ' << static_cast<int>(out_stat_code) << ' ' <<
what(out_stat_code) << "\r\n";
for (auto i = out_hdrs.begin(); i != out_hdrs.end(); ++i)
ss << canonize_1x_header_name(i->first) << ": " << i->second << "\r\n";
ss << "\r\n";
std::string hdr_lines = ss.str();
sock.send(hdr_lines.data(), hdr_lines.size(), net::all, e);
if (e)
return -1; // connection error
hdrs_written = true;
}
// send:
size_t chunk_len = pptr() - pbase();
if (chunk_len) {
if (chunked) {
std::ostringstream ss;
ss << std::hex << chunk_len << "\r\n";
std::string chunk_line = ss.str();
sock.send(chunk_line.data(), chunk_line.size(), net::all, e);
if (e)
return -1; // connection error
}
sock.send(pbase(), chunk_len, net::all, e);
if (e)
return -1; // connection error
if (chunked) {
sock.send("\r\n", 2, net::all, e);
if (e)
return -1; // connection error
}
}
// final chunk:
if (end && chunked) {
sock.send("0\r\n\r\n", 5, net::all, e);
if (e)
return -1; // connection error
}
return 0; // success
}
void doSync()
{
uint64_t n = pptr()-pbase();
pbump(-n);
char * p = pbase();
while ( n )
{
ssize_t const w = ::write(fd,p,n);
if ( w < 0 )
{
int const error = errno;
switch ( error )
{
case EINTR:
case EAGAIN:
break;
default:
{
libmaus2::exception::LibMausException se;
se.getStream() << "LinuxStreamingPosixFdOutputStreamBuffer::doSync(): write() failed: " << strerror(error) << std::endl;
se.finish();
throw se;
}
}
}
else
{
assert ( w <= static_cast<int64_t>(n) );
#if defined(__GLIBC__)
#if __GLIBC_PREREQ(2,6)
// non block buffer cache flush request for range we have just written
if ( w )
{
::sync_file_range(fd, prevwrite.first+prevwrite.second, w, SYNC_FILE_RANGE_WRITE);
}
if ( prevwrite.second )
{
// blocking buffer cache flush request for previous buffer
::sync_file_range(fd, prevwrite.first, prevwrite.second, SYNC_FILE_RANGE_WAIT_BEFORE|SYNC_FILE_RANGE_WRITE|SYNC_FILE_RANGE_WAIT_AFTER);
// tell kernel we no longer need the pages
::posix_fadvise(fd, prevwrite.first, prevwrite.second, POSIX_FADV_DONTNEED);
}
#endif
#endif
prevwrite.first = prevwrite.first + prevwrite.second;
prevwrite.second = w;
n -= w;
}
}
assert ( ! n );
}
int sync() override {
std::ptrdiff_t n = pptr() - pbase();
for (auto ptr = pbase(); ptr != pptr(); ptr++) {
push(*ptr);
}
pbump(-n);
return 0;
}
int TCPStream::overflow(int c)
{
unsigned char ch;
ssize_t rlen, req;
if(bufsize == 1) {
if(c == EOF)
return 0;
ch = (unsigned char)(c);
if(Socket::state == STREAM)
rlen = ::write((int)so, (const char *)&ch, 1);
else
rlen = writeData(&ch, 1);
if(rlen < 1) {
if(rlen < 0) {
iostream::clear(ios::failbit | rdstate());
error(errOutput,(char *)"Could not write to socket",socket_errno);
}
return EOF;
}
else
return c;
}
if(!pbase())
return EOF;
req = (ssize_t)(pptr() - pbase());
if(req) {
if(Socket::state == STREAM)
rlen = ::write((int)so, (const char *)pbase(), req);
else
rlen = writeData(pbase(), req);
if(rlen < 1) {
if(rlen < 0) {
iostream::clear(ios::failbit | rdstate());
error(errOutput,(char *)"Could not write to socket",socket_errno);
}
return EOF;
}
req -= rlen;
}
// if write "partial", rebuffer remainder
if(req)
// memmove(pbuf, pptr() + rlen, req);
memmove(pbuf, pbuf + rlen, req);
setp(pbuf, pbuf + bufsize);
pbump(req);
if(c != EOF) {
*pptr() = (unsigned char)c;
pbump(1);
}
return c;
}
/***
*virtual int filebuf::sync() - synchronize buffers with external file postion.
*
*Purpose:
* Synchronizes buffer with external file, by flushing any output and/or
* discarding any unread input data. Discards any get or put area(s).
*
*Entry:
* None.
*
*Exit:
* Returns EOF if error, else 0.
*
*Exceptions:
* Returns EOF if error.
*
*******************************************************************************/
int filebuf::sync()
{
long count, nout;
char * p;
if (x_fd==-1)
return(EOF);
if (!unbuffered())
{
if ((count=out_waiting())!=0)
{
if ((nout =_write(x_fd,(void *) pbase(),(unsigned int)count)) != count)
{
if (nout > 0) {
// should set _pptr -= nout
pbump(-(int)nout);
memmove(pbase(), pbase()+nout, (int)(count-nout));
}
return(EOF);
}
}
setp(0,0); // empty put area
if ((count=in_avail()) > 0)
{
// can't use seekoff here!!
#ifdef _WIN32
if (_osfile(x_fd) & FTEXT)
#else
if (_osfile[x_fd] & FTEXT)
#endif
{
// If text mode, need to account for CR/LF etc.
for (p = gptr(); p < egptr(); p++)
if (*p == '\n')
count++;
// account for EOF if read, not counted by _read
#ifdef _WIN32
if ((_osfile(x_fd) & FEOFLAG))
#else
if ((_osfile[x_fd] & FEOFLAG))
#endif
count++;
}
if (_lseek(x_fd, -count, SEEK_CUR)==-1L)
{
// unlock();
return (EOF);
}
}
setg(0,0,0); // empty get area
}
// unlock();
return(0);
}
int sync()
{
output();
for(SyncStreamSet::iterator i = sync_stream_set_.begin(); i != sync_stream_set_.end(); ++i) {
(*i)->sputn(pbase(), (std::streamsize)(pptr()-pbase()));
}
setp(__buf, __buf+(BUF_LEN-1));
return 0;
}
int ClientSocket::StreamBuf::sync()
{
if(pbase() != pptr())
{
conn->write(pbase(), pptr() - pbase());
setp(outBuffer, outBuffer + sizeof(outBuffer) - 1);
}
return 1;
}
int filedescbuf::sync()
{
if (pbase() && pptr() > pbase())
{
(void)::write(_fd, pbase(), pptr() - pbase()) ;
setp(buffer, buffer + sizeof(buffer)) ;
}
return 0 ;
}
int gzstreambuf::flush_buffer() {
// Separate the writing of the buffer from overflow() and
// sync() operation.
int w = pptr() - pbase();
if ( gzwrite( file, pbase(), w) != w)
return EOF;
pbump( -w);
return w;
}
void EncryptBuffer::encryptAndFlush() {
std::ptrdiff_t n = pptr() - pbase();
if (n > 0) {
Slice slice = buffer_(0, n);
encrypt_.write(slice, slice);
pbump(-n);
sink_.sputn(pbase(), n);
}
}
bool doFlush(){
if(!port.isOpen())
return false;
const std::ptrdiff_t bytesAvailable = pptr()-pbase();
const std::ptrdiff_t bytesWritten = port.write(reinterpret_cast<const uint8_t*>(pbase()), bytesAvailable);
if(bytesWritten!=bytesAvailable)
throw std::runtime_error("SerialProvider: Error writing to serial port.");
// std::cout << "Bytes to serial: "<<bytesWritten<<std::endl;
pbump(-bytesWritten);
return true;
}
CT_INT_TYPE CConn_Streambuf::overflow(CT_INT_TYPE c)
{
if (!m_Conn)
return CT_EOF;
size_t n_written;
size_t n_towrite = (size_t)(pptr() - pbase());
if (n_towrite) {
// send buffer
do {
m_Status = CONN_Write(m_Conn, pbase(),
n_towrite, &n_written, eIO_WritePlain);
_ASSERT(n_written <= n_towrite);
if (!n_written) {
_ASSERT(m_Status != eIO_Success);
break;
}
// update buffer content (get rid of the data just sent)
memmove(pbase(), pbase() + n_written, n_towrite - n_written);
x_PPos += (CT_OFF_TYPE) n_written;
pbump(-int(n_written));
// store char
if (!CT_EQ_INT_TYPE(c, CT_EOF))
return sputc(CT_TO_CHAR_TYPE(c));
n_towrite -= n_written;
} while (n_towrite && m_Status == eIO_Success);
if (n_towrite) {
_ASSERT(m_Status != eIO_Success);
ERR_POST_X(4, x_Message("overflow(): CONN_Write() failed"));
return CT_EOF;
}
} else if (!CT_EQ_INT_TYPE(c, CT_EOF)) {
// send char
CT_CHAR_TYPE b = CT_TO_CHAR_TYPE(c);
m_Status = CONN_Write(m_Conn, &b, 1, &n_written, eIO_WritePlain);
_ASSERT(n_written <= 1);
if (!n_written) {
_ASSERT(m_Status != eIO_Success);
ERR_POST_X(5, x_Message("overflow(): CONN_Write(1) failed"));
return CT_EOF;
}
x_PPos += (CT_OFF_TYPE) 1;
return c;
}
_ASSERT(CT_EQ_INT_TYPE(c, CT_EOF));
if ((m_Status = CONN_Flush(m_Conn)) != eIO_Success) {
ERR_POST_X(9, x_Message("overflow(): CONN_Flush() failed"));
return CT_EOF;
}
return CT_NOT_EOF(CT_EOF);
}
int streambuf::sync ()
{
// Ouput all contents of put buffer.
const std::streamsize count = myStream.write(
pbase(), ::ULONG(pptr()-pbase())
);
// Adjust put buffer pointers.
setp(pptr(),epptr());
// Indicate status (failure/success).
return ((count == 0)? 0 : 1);
}
int sync() override {
std::ptrdiff_t n = pptr() - pbase();
int real_n = ::MultiByteToWideChar(CP_UTF8, 0, pbase(), n, 0, 0);
::MultiByteToWideChar(CP_UTF8, 0, pbase(), n, _console_temp.data(), real_n);
DWORD written;
::WriteConsoleW(_handle, _console_temp.data(), real_n, &written, NULL);
//::WriteConsoleA(_handle, pbase(), n, &written, NULL);
assert(written == real_n);
pbump(-n);
return 0;
}
inline typename basic_dbgstreambuf<elem_t, traits_t>::int_type
basic_dbgstreambuf<elem_t, traits_t>::overflow(int_type c_)
{
if (traits_t::eq_int_type(traits_t::eof(), c_))
return traits_t::eof();
const elem_t c = traits_t::to_char_type(c_);
//sync();
//NOTE: No, we can't do this here, since dbgview will
//break the text across lines when the auto-scroll
//option is enabled.
const ptrdiff_t oldlen = epptr() - pbase();
const ptrdiff_t newlen = oldlen ? 2 * oldlen : 1;
if (elem_t* const newbuf = new (std::nothrow) elem_t[newlen + 1])
{
const std::streamsize pos = ppos();
#if _MSC_VER >= 1400
const size_t size_in_bytes = newlen * sizeof(elem_t);
traits_t::_Copy_s(newbuf, size_in_bytes, pbase(), pos);
#else
traits_t::copy(newbuf, pbase(), pos);
#endif
setp(newbuf, newbuf + pos, newbuf + newlen);
delete[] m_buf;
m_buf = newbuf;
*pptr() = c;
pbump(1);
return traits_t::not_eof(c_);
}
if (oldlen)
{
sync();
*pbase() = c;
pbump(1);
}
else
{
const elem_t str[2] = { c, elem_t() };
OutputDebugStringX(str);
}
return traits_t::not_eof(c_);
}
void Socket::setOutputBufferSize(std::streamsize n) {
if(pbase()) {
delete [] pbase();
setp(NULL, NULL);
}
if(n == 0) return;
if(type == TCP_SERVER)
throw Exception(Exception::BAD_TYPE);
char_type* writeBuffer = new char_type[n];
setp(writeBuffer, writeBuffer+n);
}
int
impl::systembuf::sync(void)
{
ssize_t cnt = pptr() - pbase();
bool ok;
ok = ::write(m_handle, pbase(), cnt) == cnt;
if (ok)
pbump(-cnt);
return ok ? 0 : -1;
}
int Process::sync()
// ------------------------------------------------------------------------
// Overriding std::streambuf::sync(), write data to process
// ------------------------------------------------------------------------
{
if (pbase() != pptr())
{
QProcess::write(pbase(), pptr() - pbase());
setp(pbase(), epptr());
}
return 0;
}
void HWNDstreambuf::putBuffer() {
if(pbase() != pptr()) {
__w64 int len = (pptr() - pbase());
char *str = new char[len + 1];
strncpy(str, pbase(), len);
str[len] = 0;
addToWindow(str);
setp(pbase(), epptr());
delete [] str;
}
}
bool CCompressionStreambuf::ProcessStreamWrite()
{
const char* in_buf = pbase();
const size_t count = pptr() - pbase();
size_t in_avail = count;
// Nothing was written into processor yet
if ( m_Writer->m_State == CSP::eInit ) {
if ( !count )
return false;
// Reset state to eActive
m_Writer->m_State = CSP::eActive;
}
// End of stream has been detected
if ( m_Writer->m_LastStatus == CP::eStatus_EndOfData ) {
return false;
}
// Flush remaining data from compression stream if it is finalized
if ( m_Writer->m_State == CSP::eFinalize ) {
return Flush(CCompressionStream::eWrite) == 0;
}
// Loop until no data is left
while ( in_avail ) {
// Process next data portion
size_t out_avail = 0;
size_t out_size = m_Writer->m_OutBuf +
m_Writer->m_OutBufSize - m_Writer->m_End;
m_Writer->m_LastStatus = m_Writer->m_Processor->Process(
in_buf + count - in_avail, in_avail, m_Writer->m_End, out_size,
&in_avail, &out_avail);
// Check on error / small output buffer
if ( m_Writer->m_LastStatus == CP::eStatus_Error ) {
return false;
}
// No more data -- automaticaly finalize stream
if ( m_Writer->m_LastStatus == CP::eStatus_EndOfData ) {
m_Writer->m_State = CSP::eFinalize;
}
// Update the output buffer pointer
m_Writer->m_End += out_avail;
// Write data to the underlying stream only if the output buffer
// is full or an overflow occurs.
if ( !WriteOutBufToStream() ) {
return false;
}
}
// Decrease the put pointer
pbump(-(int)count);
return true;
}
_ALControlStream::sync()
{
int i = out_waiting();
if ( i != 0 && pbase() != 0 ) {
pbase()[ i ] = '\0';
SendMessage( hWindow,
EM_REPLACESEL,
0,
(LPARAM) ( (LPSTR) pbase() ) );
}
setp( 0, 0 );
return 0;
}
bool LogStreamBuf<charT,traits>::ContainsEndl() const
{ bool result = pptr() - pbase()>0 ? false : true;
charT* m = pptr();
for( charT* i = pbase();i<m;i++ )
if( *i==_T('\n') )
{ result = true;
break;
} // of if
return result;
}
int ostreambuf::sync ()
{
// Ouput all contents of put buffer.
const std::streamsize count = myStream.put(
reinterpret_cast<const uint8*>(pbase()),
std::streamsize(pptr()-pbase())
);
// Adjust put buffer pointers.
setp(pptr(),epptr());
// Indicate status (failure/success).
return ((count == 0)? 0 : 1);
}
int scgi_outbuffer::overflow(int c)
{
int len=pptr()-pbase();
if(len) {
int n=safe_write(fd,pbase(),len);
pbump(-n);
}
if(c!=EOF) {
char b=c;
if(safe_write(fd,&b,1)<1)
return EOF;
}
return 0;
}
void strstreambuf::freeze(bool freezeit)
{ // freeze or unfreeze writing
if (freezeit && !(_Strmode & _Frozen))
{ // disable writing
_Strmode |= _Frozen;
_Pendsave = epptr();
setp(pbase(), pptr(), eback());
}
else if (!freezeit && _Strmode & _Frozen)
{ // re-enable writing
_Strmode &= ~_Frozen;
setp(pbase(), pptr(), _Pendsave);
}
}
int Socket::sync() {
if(getOutputBufferSize() <= 0) //No output buffer
return EOF;
if(pptr() == pbase()) //Allready in sync
return 0;
try {
setp(pbase(), pptr()+send(pbase(), pptr()-pbase()));
return 0;
} catch(Exception err) {
return EOF;
}
}
int Md5streambuf::sync()
{
if (pptr() != pbase())
{
// konsumiere Zeichen aus dem Puffer
log_debug("process " << (pptr() - pbase()) << " bytes of data");
cxxtools_MD5Update(context, (const unsigned char*)pbase(), pptr() - pbase());
// leere Ausgabepuffer
setp(buffer, buffer + bufsize);
}
return 0;
}
