我想要从一个 std::istream 中安全地读取一行。这个流可以是任何东西，比如一个 Web 服务器上的连接或者处理来自未知来源的文件的程序。有许多回答开始执行与此代码道德等效的操作：
void read(std::istream& in) {
std::string line;
if (std::getline(in, line)) {
// process the line
}
}
考虑到in的来源可能不可靠，使用上述代码会导致一个漏洞：恶意代理可以使用巨大的行对这个代码进行拒绝服务攻击。因此，我希望将行长度限制在某个相当高的值，比如4百万个char。虽然可能会遇到一些很长的行，但为每个文件分配缓冲区并使用std::istream::getline()是不可行的。
如何限制最大行大小，最好不要过分扭曲代码，也不要预先分配大块内存？
你可以编写自己的 std::getline 版本，并带有一个最大读取字符数的参数，称为 getline_n 或其他名称。
#include <string>
#include <iostream>
template<typename CharT, typename Traits, typename Alloc>
auto getline_n(std::basic_istream<CharT, Traits>& in, std::basic_string<CharT, Traits, Alloc>& str, std::streamsize n) -> decltype(in) {
std::ios_base::iostate state = std::ios_base::goodbit;
bool extracted = false;
const typename std::basic_istream<CharT, Traits>::sentry s(in, true);
if(s) {
try {
str.erase();
typename Traits::int_type ch = in.rdbuf()->sgetc();
for(; ; ch = in.rdbuf()->snextc()) {
if(Traits::eq_int_type(ch, Traits::eof())) {
// eof spotted, quit
state |= std::ios_base::eofbit;
break;
}
else if(str.size() == n) {
// maximum number of characters met, quit
extracted = true;
in.rdbuf()->sbumpc();
break;
}
else if(str.max_size() <= str.size()) {
// string too big
state |= std::ios_base::failbit;
break;
}
else {
// character valid
str += Traits::to_char_type(ch);
extracted = true;
}
}
}
catch(...) {
in.setstate(std::ios_base::badbit);
}
}
if(!extracted) {
state |= std::ios_base::failbit;
}
in.setstate(state);
return in;
}
int main() {
std::string s;
getline_n(std::cin, s, 10); // maximum of 10 characters
std::cout << s << '\n';
}
可能有点过头了。
getline() 是一个选项（尤其是在过去，我已经实现了所有 IOStreams 库）。我不知道为什么没想到：也许我太专注于另外两个解决方案（其中只提到了一个）。 - Dietmar Kühlreserve的调用，因为原帖中提到需要4MB作为保护，但实际上字符串大小可能要小得多。让用户自己执行reserve可能更好。 - Dave Sreserve 调用，但我为了保险起见后来将其添加进去了。如果由我决定的话，我也不会这么做。我想我应该将其删除。 - Rapptz已经有一个作为istream成员函数的getline函数了，您只需要对其进行缓冲区管理包装。
#include <assert.h>
#include <istream>
#include <stddef.h> // ptrdiff_t
#include <string> // std::string, std::char_traits
typedef ptrdiff_t Size;
namespace my {
using std::istream;
using std::string;
using std::char_traits;
istream& getline(
istream& stream, string& s, Size const buf_size, char const delimiter = '\n'
)
{
s.resize( buf_size ); assert( s.size() > 1 );
stream.getline( &s[0], buf_size, delimiter );
if( !stream.fail() )
{
Size const n = char_traits<char>::length( &s[0] );
s.resize( n ); // Downsizing.
}
return stream;
}
} // namespace my
std::string中的数据不保证是连续的，只有.c_str()是。因此，在std::vector中使用&v[0]是可以的，但在std::string中则不完全适用。 - Inverse通过创建一个 std::istream::getline 的包装器来替换 std::getline：
std::istream& my::getline( std::istream& is, std::streamsize n, std::string& str, char delim )
{
try
{
str.resize(n);
is.getline(&str[0],n,delim);
str.resize(is.gcount());
return is;
}
catch(...) { str.resize(0); throw; }
}
如果你想避免过多的临时内存分配，可以使用一个循环来按需增加分配的内存空间（每次可能会翻倍增长）。不要忘记istream对象上可能启用或禁用异常。
这里是使用更高效分配策略的版本：
std::istream& my::getline( std::istream& is, std::streamsize n, std::string& str, char delim )
{
std::streamsize base=0;
do {
try
{
is.clear();
std::streamsize chunk=std::min(n-base,std::max(static_cast<std::streamsize>(2),base));
if ( chunk == 0 ) break;
str.resize(base+chunk);
is.getline(&str[base],chunk,delim);
}
catch( std::ios_base::failure ) { if ( !is.gcount () ) str.resize(0), throw; }
base += is.gcount();
} while ( is.fail() && is.gcount() );
str.resize(base);
return is;
}
try { my::getline( is, 4096, s, '\n' ); } catch ( std::ios::failure const & ) {} - Brent Bradburngetline()，可能在内部使用std::istream::getline()成员获取实际字符。std::string，而是使用具有自定义分配器的字符串实例化，限制存储在字符串中的内存量。std::ios_base::failbit和/或std::ios_base::bad_bit），并且由于读取失败，产生一个空字符串。显然，产生一个空字符串可以防止潜在地查看迄今为止已读取的字符串，以可能看到正在发生的事情。3.读取过长的行可以提供部分行读取，并在流上设置错误标志。这似乎是合理的行为，既检测到有问题，也提供了输入以供检查。虽然已经有多个代码示例实现了一个有限版本的getline()，但这里又有另一个！我认为它更简单（尽管可能更慢；当必要时可以处理性能），并保留了std::getline()的接口：它使用流的width()来通信限制（考虑到width()是对std::getline()的合理扩展）。template <typename cT, typename Traits, typename Alloc>
std::basic_istream<cT, Traits>&
safe_getline(std::basic_istream<cT, Traits>& in,
std::basic_string<cT, Traits, Alloc>& value,
cT delim)
{
typedef std::basic_string<cT, Traits, Alloc> string_type;
typedef typename string_type::size_type size_type;
typename std::basic_istream<cT, Traits>::sentry cerberos(in);
if (cerberos) {
value.clear();
size_type width(in.width(0));
if (width == 0) {
width = std::numeric_limits<size_type>::max();
}
std::istreambuf_iterator<char> it(in), end;
for (; value.size() != width && it != end; ++it) {
if (!Traits::eq(delim, *it)) {
value.push_back(*it);
}
else {
++it;
break;
}
}
if (value.size() == width) {
in.setstate(std::ios_base::failbit);
}
}
return in;
}
这个版本的getline()与std::getline()使用方式相同，但当需要限制读取的数据量时，可以设置width()，例如：
std::string line;
if (safe_getline(in >> std::setw(max_characters), line)) {
// do something with the input
}
template <typename cT, typename Traits = std::char_traits<char> >
class basic_limitbuf
: std::basic_streambuf <cT, Traits> {
public:
typedef Traits traits_type;
typedef typename Traits::int_type int_type;
private:
std::streamsize size;
std::streamsize max;
std::basic_istream<cT, Traits>* stream;
std::basic_streambuf<cT, Traits>* sbuf;
int_type underflow() {
if (this->size < this->max) {
return this->sbuf->sgetc();
}
else {
this->stream->setstate(std::ios_base::failbit);
return traits_type::eof();
}
}
int_type uflow() {
if (this->size < this->max) {
++this->size;
return this->sbuf->sbumpc();
}
else {
this->stream->setstate(std::ios_base::failbit);
return traits_type::eof();
}
}
public:
basic_limitbuf(std::streamsize max,
std::basic_istream<cT, Traits>& stream)
: size()
, max(max)
, stream(&stream)
, sbuf(this->stream->rdbuf(this)) {
}
~basic_limitbuf() {
std::ios_base::iostate state = this->stream->rdstate();
this->stream->rdbuf(this->sbuf);
this->stream->setstate(state);
}
};
这个流缓冲区已经设置好，可以在构造时插入自身，在销毁时删除自身。也就是说，它可以简单地像这样使用：
std::string line;
basic_limitbuf<char> sbuf(max_characters, in);
if (std::getline(in, line)) {
// do something with the input
}
std::basic_string。关于分配器的方法有两个有点尴尬的方面：
std::string的类型（尽管进行转换也不难）。template <typename T>
struct limit_alloc
{
private:
std::size_t max_;
public:
typedef T value_type;
limit_alloc(std::size_t max): max_(max) {}
template <typename S>
limit_alloc(limit_alloc<S> const& other): max_(other.max()) {}
std::size_t max() const { return this->max_; }
T* allocate(std::size_t size) {
return size <= max_
? static_cast<T*>(operator new[](size))
: throw std::bad_alloc();
}
void deallocate(void* ptr, std::size_t) {
return operator delete[](ptr);
}
};
template <typename T0, typename T1>
bool operator== (limit_alloc<T0> const& a0, limit_alloc<T1> const& a1) {
return a0.max() == a1.max();
}
template <typename T0, typename T1>
bool operator!= (limit_alloc<T0> const& a0, limit_alloc<T1> const& a1) {
return !(a0 == a1);
}
分配器将类似于以下用法（代码在最新版本的 clang 下编译正常，但在 gcc 下不行）：
std::basic_string<char, std::char_traits<char>, limit_alloc<char> >
tmp(limit_alloc<char>(max_chars));
if (std::getline(in, tmp)) {
std::string(tmp.begin(), tmp.end());
// do something with the input
}
总之，有多种方法可以限制基于过长行的拒绝服务攻击，每种方法都有自己的小缺点，但对于所述目标而言都是合理可行的：
getline() 需要更改读取代码。
basic_string对象，并将内容读入其中。 - Praetorianmax_size()函数？ - Collinstd::string的类型。 - Dietmar Kühlin的streambuf，该实现包装了原始的streambuf，并在读取一定数量的字符时发送一个'\n'。 - jrokif (in.rdbuf()->in_avail() > max_size) { /* end */ }... - mb84