aboutsummaryrefslogtreecommitdiff
path: root/web/apache
diff options
context:
space:
mode:
Diffstat (limited to 'web/apache')
-rw-r--r--web/apache/log50
-rw-r--r--web/apache/request228
-rw-r--r--web/apache/request.cxx186
-rw-r--r--web/apache/request.ixx218
-rw-r--r--web/apache/service94
-rw-r--r--web/apache/stream161
6 files changed, 928 insertions, 9 deletions
diff --git a/web/apache/log b/web/apache/log
index 0e39420..151efb4 100644
--- a/web/apache/log
+++ b/web/apache/log
@@ -5,7 +5,11 @@
#ifndef WEB_APACHE_LOG
#define WEB_APACHE_LOG
-#include <cstdint> // uint64_t
+#include <algorithm> // min()
+#include <cstdint> // uint64_t
+
+#include <httpd/httpd.h> // request_rec
+#include <httpd/http_log.h>
#include <web/module>
@@ -16,7 +20,8 @@ namespace web
class log: public web::log
{
public:
- // ...
+
+ log (request_rec* req) noexcept : req_ (req) {}
virtual void
write (const char* msg) {write (APLOG_ERR, msg);}
@@ -24,13 +29,48 @@ namespace web
// Apache-specific interface.
//
void
- write (int level, const char* msg) {write (nullptr, 0, level, msg);}
+ write (int level, const char* msg)
+ {
+ write (nullptr, 0, nullptr, level, msg);
+ }
void
- write (const char* file, std::uint64_t line, int level, const char* msg);
+ write (const char* file,
+ std::uint64_t line,
+ const char* func,
+ int level,
+ const char* msg)
+ {
+ if (file && *file)
+ file = nullptr; // skip file/line placeholder from log line.
+
+ level = std::min (level, APLOG_TRACE8);
+
+ if (func)
+ ap_log_rerror (file,
+ line,
+ APLOG_NO_MODULE,
+ level,
+ 0,
+ req_,
+ "[%s]: %s",
+ func,
+ msg);
+ else
+ // skip function name placeholder from log line
+ //
+ ap_log_rerror (file,
+ line,
+ APLOG_NO_MODULE,
+ level,
+ 0,
+ req_,
+ ": %s",
+ msg);
+ }
private:
- // ...
+ request_rec* req_;
};
}
}
diff --git a/web/apache/request b/web/apache/request
new file mode 100644
index 0000000..ab5c765
--- /dev/null
+++ b/web/apache/request
@@ -0,0 +1,228 @@
+// file : web/apache/request -*- C++ -*-
+// copyright : Copyright (c) 2014-2015 Code Synthesis Tools CC
+// license : MIT; see accompanying LICENSE file
+
+#ifndef WEB_APACHE_REQUEST
+#define WEB_APACHE_REQUEST
+
+#include <stdexcept>
+#include <exception>
+#include <string>
+#include <ios>
+#include <istream>
+#include <ostream>
+#include <streambuf>
+#include <memory> // unique_ptr
+#include <algorithm> // move
+#include <chrono>
+#include <cassert>
+
+#include <apr_strings.h>
+
+#include <httpd/httpd.h>
+#include <httpd/http_core.h>
+#include <httpd/util_script.h>
+
+#include <web/module>
+#include <web/apache/stream>
+
+namespace web
+{
+ namespace apache
+ {
+ class request : public web::request, public web::response
+ {
+ friend class service;
+
+ request (request_rec* rec) noexcept: rec_ (rec) {}
+
+ // Flush of buffered content.
+ //
+ int
+ flush ();
+
+ // Get request body data stream.
+ //
+ virtual std::istream&
+ data ()
+ {
+ if (write_flag ())
+ {
+ throw sequence_error ("::web::apache::request::data");
+ }
+
+ if (!in_)
+ {
+ std::unique_ptr<std::streambuf> in_buf (new istreambuf (rec_));
+ in_.reset (new std::istream (in_buf.get ()));
+ in_buf_ = std::move (in_buf);
+ in_->exceptions (std::ios::failbit | std::ios::badbit);
+
+ // Save form data now otherwise will not be available to do later
+ // when data read from stream.
+ //
+ form_data ();
+ }
+
+ return *in_;
+ }
+
+ // Get request parameters.
+ //
+ virtual const name_values&
+ parameters ()
+ {
+ if (!parameters_)
+ {
+ parameters_.reset (new name_values());
+
+ try
+ {
+ parse_parameters(rec_->args);
+ parse_parameters(form_data ()->c_str ());
+ }
+ catch(const std::invalid_argument& )
+ {
+ throw invalid_request();
+ }
+ }
+
+ return *parameters_;
+ }
+
+ // Get request cookies.
+ //
+ virtual const name_values&
+ cookies ();
+
+ // Get response status code.
+ //
+ status_code status () const noexcept {return status_;}
+
+ // Set response status code.
+ //
+ virtual void
+ status (status_code status)
+ {
+ if (status != status_)
+ {
+ // Setting status code in exception handler is a common usecase
+ // where no sense to throw but still need to signal apache a
+ // proper status code.
+ //
+ if (write_flag () && !std::current_exception ())
+ {
+ throw sequence_error ("::web::apache::request::status");
+ }
+
+ status_ = status;
+ type_.clear ();
+ buffer_ = true;
+ out_.reset ();
+ out_buf_.reset ();
+ set_content_type ();
+ }
+ }
+
+ // Set response status code, content type and get body stream.
+ //
+ virtual std::ostream&
+ content (status_code status,
+ const std::string& type,
+ bool buffer = true);
+
+ // Add response cookie.
+ //
+ virtual void
+ cookie (const char* name,
+ const char* value,
+ const std::chrono::seconds* max_age = 0,
+ const char* path = 0,
+ const char* domain = 0,
+ bool secure = false);
+
+ private:
+ using string_ptr = std::unique_ptr<std::string>;
+
+ // Get application/x-www-form-urlencoded form data.
+ //
+ const string_ptr&
+ form_data ();
+
+ void
+ parse_parameters (const char* args);
+
+ static void
+ mime_url_encode (const char* v, std::ostream& o);
+
+ static std::string
+ mime_url_decode (const char* b, const char* e, bool trim = false);
+
+ // Save content type to apache internals.
+ //
+ void
+ set_content_type () const noexcept
+ {
+ if (type_.empty ())
+ ap_set_content_type (rec_, nullptr);
+ else
+ {
+ if(status_ == HTTP_OK)
+ {
+ ap_set_content_type (rec_,
+ apr_pstrdup (rec_->pool, type_.c_str ()));
+ }
+ else
+ {
+ // Unfortunatelly there is no way to set a proper content type
+ // for error custom response. Depending on presense of
+ // "suppress-error-charset" key in request_rec::subprocess_env
+ // table content type is set to "text/html" otherwise to
+ // "text/html; charset=iso-8859-1" (read http_protocol.c for
+ // details). I have chosen the first one as it is better not to
+ // specify charset than to set a wrong one. Ensure to put
+ // a proper encoding to
+ // <meta http-equiv="Content-Type" content="text/html;charset=...">
+ // tag so browser can render the page properly.
+ // The clean solution would be patching apache but let's leave this
+ // troublesome option untill really required.
+ //
+ apr_table_set (rec_->subprocess_env, "suppress-error-charset", "");
+ }
+ }
+ }
+
+ bool
+ write_flag () const noexcept
+ {
+ if (!buffer_)
+ {
+ assert (out_buf_);
+ auto b = dynamic_cast<ostreambuf*> (out_buf_.get ());
+ assert (b);
+ return b->write_flag ();
+ }
+
+ return false;
+ }
+
+ private:
+
+ request_rec* rec_;
+ status_code status_ {HTTP_OK};
+ std::string type_;
+ bool buffer_ {true};
+ std::unique_ptr<std::streambuf> out_buf_;
+ std::unique_ptr<std::ostream> out_;
+ std::unique_ptr<std::streambuf> in_buf_;
+ std::unique_ptr<std::istream> in_;
+ std::unique_ptr<name_values> parameters_;
+ std::unique_ptr<name_values> cookies_;
+ string_ptr form_data_;
+ };
+ }
+}
+
+#include <web/apache/request.ixx>
+
+#endif // WEB_APACHE_REQUEST
diff --git a/web/apache/request.cxx b/web/apache/request.cxx
new file mode 100644
index 0000000..6f043bc
--- /dev/null
+++ b/web/apache/request.cxx
@@ -0,0 +1,186 @@
+// file : web/apache/request.cxx -*- C++ -*-
+// copyright : Copyright (c) 2014-2015 Code Synthesis Tools CC
+// license : MIT; see accompanying LICENSE file
+
+#include <web/apache/request>
+
+#include <stdexcept>
+#include <ios>
+#include <streambuf>
+#include <sstream>
+#include <ostream>
+#include <memory> // unique_ptr
+#include <algorithm> // move()
+#include <chrono>
+#include <ctime>
+
+#include <strings.h> // strcasecmp()
+
+#include <apr_tables.h>
+
+using namespace std;
+
+namespace web
+{
+ namespace apache
+ {
+ const name_values& request::
+ cookies ()
+ {
+ if (!cookies_)
+ {
+ cookies_.reset (new name_values ());
+
+ const apr_array_header_t* ha = apr_table_elts (rec_->headers_in);
+ size_t n = ha->nelts;
+
+ for (auto h (reinterpret_cast<const apr_table_entry_t *> (ha->elts));
+ n--; ++h)
+ {
+ if (!::strcasecmp (h->key, "Cookie"))
+ {
+ for (const char* n (h->val); n != 0; )
+ {
+ const char* v = strchr (n, '=');
+ const char* e = strchr (n, ';');
+
+ if (e && e < v)
+ v = 0;
+
+ string name (
+ v ? mime_url_decode (n, v, true) :
+ (e ? mime_url_decode (n, e, true) :
+ mime_url_decode (n, n + strlen (n), true)));
+
+ string value;
+
+ if (v++)
+ {
+ value = e ? mime_url_decode (v, e, true) :
+ mime_url_decode (v, v + strlen (v), true);
+ }
+
+ if (!name.empty () || !value.empty ())
+ cookies_->emplace_back (move (name), move (value));
+
+ n = e ? e + 1 : 0;
+ }
+ }
+ }
+ }
+
+ return *cookies_;
+ }
+
+ ostream& request::
+ content (status_code status, const std::string& type, bool buffer)
+ {
+ if (type.empty ())
+ {
+ // Getting content stream for writing assumes type to be provided.
+ //
+ throw std::invalid_argument (
+ "::web::apache::request::content invalid type");
+ }
+
+ // Due to apache implementation of error custom response there is no
+ // way to make it unbuffered.
+ //
+ buffer = buffer || status != HTTP_OK;
+
+ if ((status != status_ || type != type_ || buffer != buffer_) &
+ write_flag ())
+ {
+ throw sequence_error ("::web::apache::request::content");
+ }
+
+ if (status == status_ && type == type_ && buffer == buffer_)
+ {
+ assert (out_);
+ return *out_;
+ }
+
+ if (!buffer)
+ // Request body will be discarded prior first byte of content is
+ // written. Save form data now to make it available for furture
+ // parameters () call.
+ //
+ form_data ();
+
+ std::unique_ptr<std::streambuf> out_buf(
+ buffer ? static_cast<std::streambuf*> (new std::stringbuf ()) :
+ static_cast<std::streambuf*> (new ostreambuf (rec_)));
+
+ out_.reset (new std::ostream (out_buf.get ()));
+
+ out_buf_ = std::move (out_buf);
+
+ out_->exceptions (
+ std::ios::eofbit | std::ios::failbit | std::ios::badbit);
+
+ status_ = status;
+ type_ = type;
+ buffer_ = buffer;
+
+ if (!buffer_)
+ set_content_type ();
+
+ return *out_;
+ }
+
+ void request::
+ cookie (const char* name,
+ const char* value,
+ const std::chrono::seconds* max_age,
+ const char* path,
+ const char* domain,
+ bool secure)
+ {
+ if (write_flag ())
+ {
+ throw sequence_error ("::web::apache::request::cookie");
+ }
+
+ std::ostringstream s;
+ mime_url_encode (name, s);
+ s << "=";
+ mime_url_encode (value, s);
+
+ if (max_age)
+ {
+ std::chrono::system_clock::time_point tp =
+ std::chrono::system_clock::now () + *max_age;
+
+ std::time_t t = std::chrono::system_clock::to_time_t (tp);
+
+ // Assume global "C" locale is not changed.
+ //
+ char b[100];
+ std::strftime (b,
+ sizeof (b),
+ "%a, %d-%b-%Y %H:%M:%S GMT",
+ std::gmtime (&t));
+
+ s << "; Expires=" << b;
+ }
+
+ if (path)
+ {
+ s << ";Path=" << path;
+ }
+
+ if (domain)
+ {
+ s << ";Domain=" << domain;
+ }
+
+ if (secure)
+ {
+ s << ";Secure";
+ }
+
+ apr_table_add (rec_->err_headers_out, "Set-Cookie", s.str ().c_str ());
+ }
+
+ }
+}
diff --git a/web/apache/request.ixx b/web/apache/request.ixx
new file mode 100644
index 0000000..a427fd4
--- /dev/null
+++ b/web/apache/request.ixx
@@ -0,0 +1,218 @@
+// file : web/apache/request.ixx -*- C++ -*-
+// copyright : Copyright (c) 2014-2015 Code Synthesis Tools CC
+// license : MIT; see accompanying LICENSE file
+
+#include <iomanip>
+#include <sstream>
+#include <cstring>
+#include <cstdlib>
+
+#include <strings.h> // strcasecmp()
+
+namespace web
+{
+ namespace apache
+ {
+ inline int request::
+ flush ()
+ {
+ if (buffer_ && out_buf_)
+ {
+ set_content_type ();
+
+ auto b = dynamic_cast<std::stringbuf*> (out_buf_.get ());
+ assert(b);
+
+ std::string s (b->str ());
+
+ if (!s.empty ())
+ {
+ // Before writing response read and discard request body if any.
+ //
+ int r = ap_discard_request_body (rec_);
+
+ if (r == OK)
+ {
+ if (status_ == HTTP_OK)
+ {
+ if (ap_rwrite (s.c_str (), s.length (), rec_) < 0)
+ {
+ status_ = HTTP_REQUEST_TIME_OUT;
+ }
+ }
+ else
+ {
+ ap_custom_response (rec_, status_, s.c_str ());
+ }
+ }
+ else
+ status_ = r;
+ }
+
+ out_.reset ();
+ out_buf_.reset ();
+ }
+
+ return status_ == HTTP_OK ? OK : status_;
+ }
+
+ inline const request::string_ptr& request::
+ form_data ()
+ {
+ if (!form_data_)
+ {
+ form_data_.reset (new std::string ());
+ const char *ct = apr_table_get (rec_->headers_in, "Content-Type");
+
+ if (ct && !strncasecmp ("application/x-www-form-urlencoded", ct, 33))
+ {
+ std::istream& istr (data ());
+ std::getline (istr, *form_data_);
+
+ // Make request data still be available.
+ //
+
+ std::unique_ptr<std::streambuf> in_buf (
+ new std::stringbuf (*form_data_));
+
+ in_.reset (new std::istream (in_buf.get ()));
+ in_buf_ = std::move (in_buf);
+ in_->exceptions (std::ios::failbit | std::ios::badbit);
+ }
+ }
+
+ return form_data_;
+ }
+
+ inline void request::
+ parse_parameters (const char* args)
+ {
+ for (auto n (args); n != 0; )
+ {
+ const char* v = strchr (n, '=');
+ const char* e = strchr (n, '&');
+
+ if (e && e < v)
+ v = 0;
+
+ std::string name (v
+ ? mime_url_decode (n, v) :
+ (e
+ ? mime_url_decode (n, e)
+ : mime_url_decode (n, n + std::strlen (n))));
+
+ std::string value;
+
+ if (v++)
+ {
+ value = e
+ ? mime_url_decode (v, e)
+ : mime_url_decode (v, v + std::strlen (v));
+ }
+
+ if (!name.empty () || !value.empty ())
+ parameters_->emplace_back (std::move (name), std::move (value));
+
+ n = e ? e + 1 : 0;
+ }
+ }
+
+ inline void request::
+ mime_url_encode (const char* v, std::ostream& o)
+ {
+ char f = o.fill ();
+ std::ios_base::fmtflags g = o.flags ();
+ o << std::hex << std::uppercase << std::right << std::setfill ('0');
+ char c;
+
+ while ((c = *v++) != '\0')
+ {
+ if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') ||
+ (c >= '0' && c <= '9'))
+ {
+ o << c;
+ }
+ else
+ switch (c)
+ {
+ case ' ': o << '+'; break;
+ case '.':
+ case '_':
+ case '-':
+ case '~': o << c; break;
+ default: o << "%" << std::setw (2) << (unsigned short)c;
+ }
+ }
+
+ o.flags (g);
+ o.fill (f);
+ }
+
+ inline std::string request::
+ mime_url_decode (const char* b, const char* e, bool trim)
+ {
+ if (trim)
+ {
+ b += std::strspn (b, " ");
+
+ if (b >= e)
+ return std::string();
+
+ while (*--e == ' ');
+ ++e;
+ }
+
+ std::string value;
+ value.reserve (e - b);
+
+ char bf[3];
+ bf[2] = '\0';
+
+ while (b != e)
+ {
+ char c = *b++;
+
+ switch (c)
+ {
+ case '+':
+ {
+ value.append (" ");
+ break;
+ }
+ case '%':
+ {
+ if (*b == '\0' || b[1] == '\0')
+ {
+ throw std::invalid_argument (
+ "::web::apache::request::mime_url_decode short");
+ }
+
+ *bf = *b;
+ bf[1] = b[1];
+
+ char* ebf = 0;
+ size_t vl = std::strtoul (bf, &ebf, 16);
+
+ if (*ebf != '\0')
+ {
+ throw std::invalid_argument (
+ "::web::apache::request::mime_url_decode wrong");
+ }
+
+ value.append (1, (char)vl);
+ b += 2;
+ break;
+ }
+ default:
+ {
+ value.append (1, c);
+ break;
+ }
+ }
+ }
+
+ return value;
+ }
+
+ }
+}
diff --git a/web/apache/service b/web/apache/service
index 8dd21d8..688f8f1 100644
--- a/web/apache/service
+++ b/web/apache/service
@@ -5,22 +5,106 @@
#ifndef WEB_APACHE_SERVICE
#define WEB_APACHE_SERVICE
+#include <exception>
#include <string>
+#include <cassert>
+
+#include <httpd/httpd.h>
+#include <httpd/http_config.h>
#include <web/module>
+#include <web/apache/log>
+#include <web/apache/request>
+
namespace web
{
namespace apache
{
- class service
+ class service : ::module
{
public:
// Note that the module exemplar is stored by-reference.
//
template <typename M>
service (const std::string& name, const M& exemplar)
- : exemplar_ (exemplar), handle_ (&handle_impl<M>) {}
+ : ::module
+ {
+ STANDARD20_MODULE_STUFF,
+ nullptr,
+ nullptr,
+ nullptr,
+ nullptr,
+ nullptr,
+ &register_hooks<M>
+ },
+ name_ (name),
+ exemplar_ (exemplar)
+
+// Doesn't look like handle_ member is required at all.
+// handle_ (&handle_impl<M>)
+ {
+ // instance<M> () invented to delegate processing from apache request
+ // handler C function to service non static member function.
+ // This appoach resticts number of service objects per module
+ // implementation class with just one instance.
+ //
+ service*& srv = instance<M> ();
+ assert (srv == nullptr);
+ srv = this;
+ }
+
+ template <typename M>
+ static service*&
+ instance () noexcept
+ {
+ static service* instance;
+ return instance;
+ }
+
+ template <typename M>
+ static void
+ register_hooks (apr_pool_t *pool) noexcept
+ {
+ ap_hook_handler (&request_handler<M>, NULL, NULL, APR_HOOK_LAST);
+ }
+
+ template <typename M>
+ static int
+ request_handler (request_rec* r) noexcept
+ {
+ auto srv = instance<M> ();
+
+ if (!r->handler || srv->name_ != r->handler)
+ return DECLINED;
+
+ request req (r);
+ log l(r);
+
+ // As soons as M (), handle () and flush () can throw need to handle
+ // exceptions here.
+ //
+ try
+ {
+ M m (static_cast<const M&> (srv->exemplar_));
+ static_cast<module&> (m).handle (req, req, l);
+ return req.flush();
+ }
+ catch (const std::exception& e)
+ {
+ l.write (nullptr, 0, __PRETTY_FUNCTION__, APLOG_ERR, e.what ());
+ }
+ catch (...)
+ {
+ l.write (nullptr,
+ 0,
+ __PRETTY_FUNCTION__,
+ APLOG_ERR,
+ "unknown error");
+ }
+
+ return HTTP_INTERNAL_SERVER_ERROR;
+ }
//@@ Implementation calls handle_ function pointer below:
//
@@ -28,6 +112,7 @@ namespace web
//
private:
+/*
template <typename M>
static void
handle_impl (request& rq, response& rs, log& l, const module& exemplar)
@@ -35,9 +120,10 @@ namespace web
M m (static_cast<const M&> (exemplar));
static_cast<module&> (m).handle (rq, rs, l);
}
-
+*/
+ std::string name_;
const module& exemplar_;
- void (*handle_) (request&, response&, log&, const module&);
+// void (*handle_) (request&, response&, log&, const module&);
};
}
}
diff --git a/web/apache/stream b/web/apache/stream
new file mode 100644
index 0000000..eb62b85
--- /dev/null
+++ b/web/apache/stream
@@ -0,0 +1,161 @@
+// file : web/apache/stream -*- C++ -*-
+// copyright : Copyright (c) 2014-2015 Code Synthesis Tools CC
+// license : MIT; see accompanying LICENSE file
+
+#ifndef WEB_APACHE_STREAM
+#define WEB_APACHE_STREAM
+
+#include <streambuf>
+#include <ios> // streamsize
+#include <algorithm> // min(), max()
+#include <cstring> // memmove()
+#include <memory> // unique_ptr
+
+#include <httpd/httpd.h>
+#include <httpd/http_protocol.h>
+
+#include <web/module>
+
+namespace web
+{
+ namespace apache
+ {
+ class ostreambuf : public std::streambuf
+ {
+ public:
+ ostreambuf (request_rec* rec) : rec_ (rec) {}
+
+ bool
+ write_flag () const noexcept {return write_;}
+
+ private:
+ virtual int_type
+ overflow (int_type c)
+ {
+ if (c != traits_type::eof ())
+ {
+ flag_write ();
+
+ char chr = c;
+
+ // Throwing allows to distinguish comm failure from other IO error
+ // conditions.
+ //
+ if (ap_rwrite (&chr, sizeof (chr), rec_) == -1)
+ throw invalid_request (HTTP_REQUEST_TIME_OUT);
+ }
+
+ return c;
+ }
+
+ virtual std::streamsize
+ xsputn (const char* s, std::streamsize num)
+ {
+ flag_write ();
+
+ if (ap_rwrite (s, num, rec_) < 0)
+ {
+ throw invalid_request (HTTP_REQUEST_TIME_OUT);
+ }
+
+ return num;
+ }
+
+ virtual int
+ sync ()
+ {
+ if(ap_rflush (rec_) < 0)
+ {
+ throw invalid_request (HTTP_REQUEST_TIME_OUT);
+ }
+
+ return 0;
+ }
+
+ void
+ flag_write () noexcept
+ {
+ if (!write_)
+ {
+ // Preparing to write a response read and discard request
+ // body if any.
+ //
+ int r = ap_discard_request_body (rec_);
+
+ if (r != OK)
+ {
+ throw invalid_request (r);
+ }
+
+ write_ = true;
+ }
+ }
+
+ private:
+
+ request_rec* rec_;
+ bool write_ {false};
+ };
+
+ class istreambuf : public std::streambuf
+ {
+ public:
+ istreambuf (request_rec* rec, size_t bufsize = 1024, size_t putback = 1)
+ : rec_ (rec),
+ bufsize_ (std::max (bufsize, (size_t)1)),
+ putback_ (std::min (putback, bufsize_ - 1)),
+ buf_ (new char[bufsize_])
+ {
+ char* p = buf_.get () + putback_;
+ setg (p, p, p);
+
+ int status = ap_setup_client_block (rec_, REQUEST_CHUNKED_DECHUNK);
+
+ if (status != OK)
+ {
+ throw invalid_request (status);
+ }
+ }
+
+ private:
+ virtual int_type
+ underflow ()
+ {
+ if (gptr () < egptr ())
+ return traits_type::to_int_type (*gptr ());
+
+ size_t pb = std::min ((size_t)(gptr () - eback ()), putback_);
+ std::memmove (buf_.get () + putback_ - pb, gptr () - pb, pb);
+
+ char* p = buf_.get () + putback_;
+ int rb = ap_get_client_block (rec_, p, bufsize_ - putback_);
+
+ if (rb == 0)
+ {
+ return traits_type::eof ();
+ }
+
+ if (rb < 0)
+ {
+ throw invalid_request (HTTP_REQUEST_TIME_OUT);
+ }
+
+ setg (p - pb, p, p + rb);
+ return traits_type::to_int_type (*gptr ());
+ }
+
+ bool error () const noexcept {return error_;}
+
+ private:
+
+ request_rec* rec_;
+ size_t bufsize_;
+ size_t putback_;
+ std::unique_ptr<char[]> buf_;
+ bool error_ {false};
+ };
+
+ }
+}
+
+#endif // WEB_APACHE_STREAM