File SQUID_2016_2_port.patch of Package squid.1316
Index: squid-3.3.13/src/http.cc
===================================================================
--- squid-3.3.13.orig/src/http.cc
+++ squid-3.3.13/src/http.cc
@@ -173,6 +173,7 @@ void
HttpStateData::httpStateConnClosed(const CommCloseCbParams ¶ms)
{
debugs(11, 5, "httpStateFree: FD " << params.fd << ", httpState=" << params.data);
+ doneWithFwd = "httpStateConnClosed()"; // assume FwdState is monitoring too
mustStop("HttpStateData::httpStateConnClosed");
}
@@ -744,8 +745,7 @@ HttpStateData::processReplyHeader()
flags.headers_parsed = true;
newrep->sline.version = HttpVersion(1,1);
newrep->sline.status = error;
- HttpReply *vrep = setVirginReply(newrep);
- entry->replaceHttpReply(vrep);
+ setVirginReply(newrep);
ctx_exit(ctx);
return;
}
@@ -1769,7 +1769,8 @@ HttpStateData::httpBuildRequestHeader(Ht
String strFwd = hdr_in->getList(HDR_X_FORWARDED_FOR);
- if (strFwd.size() > 65536/2) {
+ // if we cannot double strFwd size, then it grew past 50% of the limit
+ if (!strFwd.canGrowBy(strFwd.size())) {
// There is probably a forwarding loop with Via detection disabled.
// If we do nothing, String will assert on overflow soon.
// TODO: Terminate all transactions with huge XFF?
@@ -2414,20 +2415,10 @@ HttpStateData::sentRequestBody(const Com
ServerStateData::sentRequestBody(io);
}
-// Quickly abort the transaction
-// TODO: destruction should be sufficient as the destructor should cleanup,
-// including canceling close handlers
void
HttpStateData::abortTransaction(const char *reason)
{
debugs(11,5, HERE << "aborting transaction for " << reason <<
"; " << serverConnection << ", this " << this);
-
- if (Comm::IsConnOpen(serverConnection)) {
- serverConnection->close();
- return;
- }
-
- fwd->handleUnregisteredServerEnd();
- mustStop("HttpStateData::abortTransaction");
+ mustStop(reason);
}
Index: squid-3.3.13/src/SquidString.h
===================================================================
--- squid-3.3.13.orig/src/SquidString.h
+++ squid-3.3.13/src/SquidString.h
@@ -146,6 +146,13 @@ public:
_SQUID_INLINE_ int caseCmp(char const *, size_type count) const;
_SQUID_INLINE_ int caseCmp(String const &) const;
+ /// Whether creating a totalLen-character string is safe (i.e., unlikely to assert).
+ /// Optional extras can be used for overflow-safe length addition.
+ /// Implementation has to add 1 because many String allocation methods do.
+ static bool CanGrowTo(size_type totalLen, const size_type extras = 0) { return SafeAdd(totalLen, extras) && SafeAdd(totalLen, 1); }
+ /// whether appending growthLen characters is safe (i.e., unlikely to assert)
+ bool canGrowBy(const size_type growthLen) const { return CanGrowTo(size(), growthLen); }
+
String substr(size_type from, size_type to) const;
_SQUID_INLINE_ void cut(size_type newLength);
@@ -162,10 +169,20 @@ private:
_SQUID_INLINE_ bool nilCmp(bool, bool, int &) const;
/* never reference these directly! */
- size_type size_; /* buffer size; 64K limit */
+ size_type size_; /* buffer size; limited by SizeMax_ */
size_type len_; /* current length */
+ static const size_type SizeMax_ = 65535; ///< 64K limit protects some fixed-size buffers
+ /// returns true after increasing the first argument by extra if the sum does not exceed SizeMax_
+ static bool SafeAdd(size_type &base, size_type extra) {
+ if (extra <= SizeMax_ && base <= SizeMax_ - extra) {
+ base += extra;
+ return true;
+ }
+ return false;
+ }
+
char *buf_;
_SQUID_INLINE_ void set(char const *loc, char const ch);
Index: squid-3.3.13/src/StrList.cc
===================================================================
--- squid-3.3.13.orig/src/StrList.cc
+++ squid-3.3.13/src/StrList.cc
@@ -33,20 +33,24 @@
#include "squid.h"
#include "SquidString.h"
#include "StrList.h"
+#include "base/TextException.h"
/** appends an item to the list */
void
strListAdd(String * str, const char *item, char del)
{
assert(str && item);
+ const String::size_type itemSize = strlen(item);
if (str->size()) {
char buf[3];
buf[0] = del;
buf[1] = ' ';
buf[2] = '\0';
+ Must(str->canGrowBy(2));
str->append(buf, 2);
}
- str->append(item, strlen(item));
+ Must(str->canGrowBy(itemSize));
+ str->append(item, itemSize);
}
/** returns true iff "m" is a member of the list */
Index: squid-3.3.13/src/String.cc
===================================================================
--- squid-3.3.13.orig/src/String.cc
+++ squid-3.3.13/src/String.cc
@@ -67,7 +67,7 @@ void
String::setBuffer(char *aBuf, String::size_type aSize)
{
assert(undefined());
- assert(aSize < 65536);
+ assert(aSize < SizeMax_);
buf_ = aBuf;
size_ = aSize;
}
@@ -198,7 +198,7 @@ String::append( char const *str, int len
} else {
// Create a temporary string and absorb it later.
String snew;
- assert(len_ + len < 65536); // otherwise snew.len_ overflows below
+ assert(canGrowBy(len)); // otherwise snew.len_ overflows below
snew.len_ = len_ + len;
snew.allocBuffer(snew.len_ + 1);
Index: squid-3.3.13/src/Server.cc
===================================================================
--- squid-3.3.13.orig/src/Server.cc
+++ squid-3.3.13/src/Server.cc
@@ -68,6 +68,7 @@ ServerStateData::ServerStateData(FwdStat
startedAdaptation(false),
#endif
receivedWholeRequestBody(false),
+ doneWithFwd(NULL),
theVirginReply(NULL),
theFinalReply(NULL)
{
@@ -94,8 +95,6 @@ ServerStateData::~ServerStateData()
HTTPMSGUNLOCK(theVirginReply);
HTTPMSGUNLOCK(theFinalReply);
- fwd = NULL; // refcounted
-
if (responseBodyBuffer != NULL) {
delete responseBodyBuffer;
responseBodyBuffer = NULL;
@@ -113,6 +112,14 @@ ServerStateData::swanSong()
cleanAdaptation();
#endif
+ if (!doneWithServer())
+ closeServer();
+
+ if (!doneWithFwd) {
+ doneWithFwd = "swanSong()";
+ fwd->handleUnregisteredServerEnd();
+ }
+
BodyConsumer::swanSong();
#if USE_ADAPTATION
Initiator::swanSong();
@@ -235,6 +242,7 @@ ServerStateData::completeForwarding()
{
debugs(11,5, HERE << "completing forwarding for " << fwd);
assert(fwd != NULL);
+ doneWithFwd = "completeForwarding()";
fwd->complete();
}
Index: squid-3.3.13/src/Server.h
===================================================================
--- squid-3.3.13.orig/src/Server.h
+++ squid-3.3.13/src/Server.h
@@ -192,6 +192,10 @@ protected:
#endif
bool receivedWholeRequestBody; ///< handleRequestBodyProductionEnded called
+ /// whether we should not be talking to FwdState; XXX: clear fwd instead
+ /// points to a string literal which is used only for debugging
+ const char *doneWithFwd;
+
private:
void sendBodyIsTooLargeError();
void maybePurgeOthers();
Index: squid-3.3.13/src/ftp.cc
===================================================================
--- squid-3.3.13.orig/src/ftp.cc
+++ squid-3.3.13/src/ftp.cc
@@ -466,6 +466,7 @@ FtpStateData::ctrlClosed(const CommClose
{
debugs(9, 4, HERE);
ctrl.clear();
+ doneWithFwd = "ctrlClosed()"; // assume FwdState is monitoring too
mustStop("FtpStateData::ctrlClosed");
}
@@ -3884,24 +3885,12 @@ FtpStateData::haveControlChannel(const c
return true;
}
-/**
- * Quickly abort the transaction
- *
- \todo destruction should be sufficient as the destructor should cleanup,
- * including canceling close handlers
- */
void
FtpStateData::abortTransaction(const char *reason)
{
debugs(9, 3, HERE << "aborting transaction for " << reason <<
"; FD " << (ctrl.conn!=NULL?ctrl.conn->fd:-1) << ", Data FD " << (data.conn!=NULL?data.conn->fd:-1) << ", this " << this);
- if (Comm::IsConnOpen(ctrl.conn)) {
- ctrl.conn->close();
- return;
- }
-
- fwd->handleUnregisteredServerEnd();
- mustStop("FtpStateData::abortTransaction");
+ mustStop(reason);
}
/// creates a data channel Comm close callback
Index: squid-3.3.13/src/esi/CustomParser.cc
===================================================================
--- squid-3.3.13.orig/src/esi/CustomParser.cc
+++ squid-3.3.13/src/esi/CustomParser.cc
@@ -110,9 +110,11 @@ ESICustomParser::parse(char const *dataT
}
size_t openESITags (0);
- //erring on the safe side. Probably rawBuf would be ok too
- char const *currentPos = content.termedBuf();
- size_t remainingCount = content.size();
+ // TODO: convert to Tokenizer parse
+ // erring on the safe side for now. Probably rawContent would be ok too
+ // note that operations below do *X='\0' ... altering the 'const' buffer content.
+ char const *currentPos = content.c_str();
+ SBuf::size_type remainingCount = content.length();
char const *tag = NULL;
while ((tag = findTag(currentPos, remainingCount))) {
Index: squid-3.3.13/src/esi/CustomParser.h
===================================================================
--- squid-3.3.13.orig/src/esi/CustomParser.h
+++ squid-3.3.13/src/esi/CustomParser.h
@@ -35,7 +35,7 @@ class Trie;
/* inherits from */
#include "esi/Parser.h"
-/* for String variables */
+#include "SBuf.h"
#include "SquidString.h"
/**
@@ -67,7 +67,7 @@ private:
ESIParserClient *theClient;
String error;
/* cheap n dirty - buffer it all */
- String content;
+ SBuf content;
/* TODO: make a class of this type code */
ESITAG_t lastTag;
};
Index: squid-3.3.13/src/SBuf.cc
===================================================================
--- /dev/null
+++ squid-3.3.13/src/SBuf.cc
@@ -0,0 +1,966 @@
+/*
+ * Copyright (C) 1996-2016 The Squid Software Foundation and contributors
+ *
+ * Squid software is distributed under GPLv2+ license and includes
+ * contributions from numerous individuals and organizations.
+ * Please see the COPYING and CONTRIBUTORS files for details.
+ */
+
+#include "squid.h"
+#include "base/CharacterSet.h"
+#include "RefCount.h"
+#include "Debug.h"
+#include "OutOfBoundsException.h"
+#include "SBuf.h"
+#include "SBufDetailedStats.h"
+#include "SBufExceptions.h"
+#include "util.h"
+
+#include <cstring>
+#include <iostream>
+#include <sstream>
+
+#ifdef VA_COPY
+#undef VA_COPY
+#endif
+#if defined HAVE_VA_COPY
+#define VA_COPY va_copy
+#elif defined HAVE___VA_COPY
+#define VA_COPY __va_copy
+#endif
+
+InstanceIdDefinitions(SBuf, "SBuf");
+
+SBufStats SBuf::stats;
+const SBuf::size_type SBuf::npos;
+const SBuf::size_type SBuf::maxSize;
+
+SBufStats::SBufStats()
+ : alloc(0), allocCopy(0), allocFromString(0), allocFromCString(0),
+ assignFast(0), clear(0), append(0), toStream(0), setChar(0),
+ getChar(0), compareSlow(0), compareFast(0), copyOut(0),
+ rawAccess(0), nulTerminate(0), chop(0), trim(0), find(0), scanf(0),
+ caseChange(0), cowFast(0), cowSlow(0), live(0)
+{}
+
+SBufStats&
+SBufStats::operator +=(const SBufStats& ss)
+{
+ alloc += ss.alloc;
+ allocCopy += ss.allocCopy;
+ allocFromString += ss.allocFromString;
+ allocFromCString += ss.allocFromCString;
+ assignFast += ss.assignFast;
+ clear += ss.clear;
+ append += ss.append;
+ toStream += ss.toStream;
+ setChar += ss.setChar;
+ getChar += ss.getChar;
+ compareSlow += ss.compareSlow;
+ compareFast += ss.compareFast;
+ copyOut += ss.copyOut;
+ rawAccess += ss.rawAccess;
+ nulTerminate += ss.nulTerminate;
+ chop += ss.chop;
+ trim += ss.trim;
+ find += ss.find;
+ scanf += ss.scanf;
+ caseChange += ss.caseChange;
+ cowFast += ss.cowFast;
+ cowSlow += ss.cowSlow;
+ live += ss.live;
+
+ return *this;
+}
+
+SBuf::SBuf()
+ : store_(GetStorePrototype()), off_(0), len_(0)
+{
+ debugs(24, 8, id << " created");
+ ++stats.alloc;
+ ++stats.live;
+}
+
+SBuf::SBuf(const SBuf &S)
+ : store_(S.store_), off_(S.off_), len_(S.len_)
+{
+ debugs(24, 8, id << " created from id " << S.id);
+ ++stats.alloc;
+ ++stats.allocCopy;
+ ++stats.live;
+}
+
+SBuf::SBuf(const String &S)
+ : store_(GetStorePrototype()), off_(0), len_(0)
+{
+ debugs(24, 8, id << " created from string");
+ assign(S.rawBuf(), S.size());
+ ++stats.alloc;
+ ++stats.allocFromString;
+ ++stats.live;
+}
+
+SBuf::SBuf(const std::string &s)
+ : store_(GetStorePrototype()), off_(0), len_(0)
+{
+ debugs(24, 8, id << " created from std::string");
+ lowAppend(s.data(),s.length());
+ ++stats.alloc;
+ ++stats.allocFromString;
+ ++stats.live;
+}
+
+SBuf::SBuf(const char *S, size_type n)
+ : store_(GetStorePrototype()), off_(0), len_(0)
+{
+ append(S,n);
+ ++stats.alloc;
+ ++stats.allocFromCString;
+ ++stats.live;
+}
+
+SBuf::~SBuf()
+{
+ debugs(24, 8, id << " destructed");
+ --stats.live;
+ recordSBufSizeAtDestruct(len_);
+}
+
+MemBlob::Pointer
+SBuf::GetStorePrototype()
+{
+ static MemBlob::Pointer InitialStore = new MemBlob(0);
+ return InitialStore;
+}
+
+SBuf&
+SBuf::assign(const SBuf &S)
+{
+ debugs(24, 7, "assigning " << id << " from " << S.id);
+ if (&S == this) //assignment to self. Noop.
+ return *this;
+ ++stats.assignFast;
+ store_ = S.store_;
+ off_ = S.off_;
+ len_ = S.len_;
+ return *this;
+}
+
+SBuf&
+SBuf::assign(const char *S, size_type n)
+{
+ const Locker blobKeeper(this, S);
+ debugs(24, 6, id << " from c-string, n=" << n << ")");
+ clear();
+ return append(S, n); //bounds checked in append()
+}
+
+void
+SBuf::reserveCapacity(size_type minCapacity)
+{
+ Must(minCapacity <= maxSize);
+ cow(minCapacity);
+}
+
+SBuf::size_type
+SBuf::reserve(const SBufReservationRequirements &req)
+{
+ debugs(24, 8, id << " was: " << off_ << '+' << len_ << '+' << spaceSize() <<
+ '=' << store_->capacity);
+
+ const bool mustRealloc = !req.allowShared && store_->LockCount() > 1;
+
+ if (!mustRealloc && spaceSize() >= req.minSpace)
+ return spaceSize(); // the caller is content with what we have
+
+ /* only reallocation can make the caller happy */
+
+ if (!mustRealloc && len_ >= req.maxCapacity)
+ return spaceSize(); // but we cannot reallocate
+
+ const size_type newSpace = std::min(req.idealSpace, maxSize - len_);
+ reserveCapacity(std::min(len_ + newSpace, req.maxCapacity));
+ debugs(24, 7, id << " now: " << off_ << '+' << len_ << '+' << spaceSize() <<
+ '=' << store_->capacity);
+ return spaceSize(); // reallocated and probably reserved enough space
+}
+
+char *
+SBuf::rawSpace(size_type minSpace)
+{
+ Must(length() <= maxSize - minSpace);
+ debugs(24, 7, "reserving " << minSpace << " for " << id);
+ ++stats.rawAccess;
+ // we're not concerned about RefCounts here,
+ // the store knows the last-used portion. If
+ // it's available, we're effectively claiming ownership
+ // of it. If it's not, we need to go away (realloc)
+ if (store_->canAppend(off_+len_, minSpace)) {
+ debugs(24, 7, id << " not growing");
+ return bufEnd();
+ }
+ // TODO: we may try to memmove before realloc'ing in order to avoid
+ // one allocation operation, if we're the sole owners of a MemBlob.
+ // Maybe some heuristic on off_ and length()?
+ cow(minSpace+length());
+ return bufEnd();
+}
+
+void
+SBuf::clear()
+{
+#if 0
+ //enabling this code path, the store will be freed and reinitialized
+ store_ = GetStorePrototype(); //uncomment to actually free storage upon clear()
+#else
+ //enabling this code path, we try to release the store without deallocating it.
+ // will be lazily reallocated if needed.
+ if (store_->LockCount() == 1)
+ store_->clear();
+#endif
+ len_ = 0;
+ off_ = 0;
+ ++stats.clear;
+}
+
+SBuf&
+SBuf::append(const SBuf &S)
+{
+ const Locker blobKeeper(this, S.buf());
+ return lowAppend(S.buf(), S.length());
+}
+
+SBuf &
+SBuf::append(const char * S, size_type Ssize)
+{
+ const Locker blobKeeper(this, S);
+ if (S == NULL)
+ return *this;
+ if (Ssize == SBuf::npos)
+ Ssize = strlen(S);
+ debugs(24, 7, "from c-string to id " << id);
+ // coverity[access_dbuff_in_call]
+ return lowAppend(S, Ssize);
+}
+
+SBuf &
+SBuf::append(const char c)
+{
+ return lowAppend(&c, 1);
+}
+
+SBuf&
+SBuf::Printf(const char *fmt, ...)
+{
+ // with printf() the fmt or an arg might be a dangerous char*
+ // NP: cant rely on vappendf() Locker because of clear()
+ const Locker blobKeeper(this, buf());
+
+ va_list args;
+ va_start(args, fmt);
+ clear();
+ vappendf(fmt, args);
+ va_end(args);
+ return *this;
+}
+
+SBuf&
+SBuf::appendf(const char *fmt, ...)
+{
+ va_list args;
+ va_start(args, fmt);
+ vappendf(fmt, args);
+ va_end(args);
+ return *this;
+}
+
+SBuf&
+SBuf::vappendf(const char *fmt, va_list vargs)
+{
+ // with (v)appendf() the fmt or an arg might be a dangerous char*
+ const Locker blobKeeper(this, buf());
+
+ Must(fmt != NULL);
+ int sz = 0;
+ //reserve twice the format-string size, it's a likely heuristic
+ size_type requiredSpaceEstimate = strlen(fmt)*2;
+
+ char *space = rawSpace(requiredSpaceEstimate);
+#ifdef VA_COPY
+ va_list ap;
+ VA_COPY(ap, vargs);
+ sz = vsnprintf(space, spaceSize(), fmt, ap);
+ va_end(ap);
+#else
+ sz = vsnprintf(space, spaceSize(), fmt, vargs);
+#endif
+
+ /* check for possible overflow */
+ /* snprintf on Linux returns -1 on output errors, or the size
+ * that would have been written if enough space had been available */
+ /* vsnprintf is standard in C99 */
+
+ if (sz >= static_cast<int>(spaceSize())) {
+ // not enough space on the first go, we now know how much we need
+ requiredSpaceEstimate = sz*2; // TODO: tune heuristics
+ space = rawSpace(requiredSpaceEstimate);
+ sz = vsnprintf(space, spaceSize(), fmt, vargs);
+ if (sz < 0) // output error in vsnprintf
+ throw TextException("output error in second-go vsnprintf",__FILE__,
+ __LINE__);
+ }
+
+ if (sz < 0) // output error in either vsnprintf
+ throw TextException("output error in vsnprintf",__FILE__, __LINE__);
+
+ // data was appended, update internal state
+ len_ += sz;
+
+ /* C99 specifies that the final '\0' is not counted in vsnprintf's
+ * return value. Older compilers/libraries might instead count it */
+ /* check whether '\0' was appended and counted */
+ static bool snPrintfTerminatorChecked = false;
+ static bool snPrintfTerminatorCounted = false;
+ if (!snPrintfTerminatorChecked) {
+ char testbuf[16];
+ snPrintfTerminatorCounted = snprintf(testbuf, sizeof(testbuf),
+ "%s", "1") == 2;
+ snPrintfTerminatorChecked = true;
+ }
+ if (snPrintfTerminatorCounted) {
+ --sz;
+ --len_;
+ }
+
+ store_->size += sz;
+ ++stats.append;
+
+ return *this;
+}
+
+std::ostream&
+SBuf::print(std::ostream &os) const
+{
+ os.write(buf(), length());
+ ++stats.toStream;
+ return os;
+}
+
+std::ostream&
+SBuf::dump(std::ostream &os) const
+{
+ os << id
+ << ": ";
+ store_->dump(os);
+ os << ", offset:" << off_
+ << ", len:" << len_
+ << ") : '";
+ print(os);
+ os << '\'' << std::endl;
+ return os;
+# if 0
+ // alternate implementation, based on Raw() API.
+ os << Raw("SBuf", buf(), length()) <<
+ ". id: " << id <<
+ ", offset:" << off_ <<
+ ", len:" << len_ <<
+ ", store: ";
+ store_->dump(os);
+ os << std::endl;
+ return os;
+#endif
+}
+
+void
+SBuf::setAt(size_type pos, char toset)
+{
+ checkAccessBounds(pos);
+ cow();
+ store_->mem[off_+pos] = toset;
+ ++stats.setChar;
+}
+
+static int
+memcasecmp(const char *b1, const char *b2, SBuf::size_type len)
+{
+ int rv=0;
+ while (len > 0) {
+ rv = tolower(*b1)-tolower(*b2);
+ if (rv != 0)
+ return rv;
+ ++b1;
+ ++b2;
+ --len;
+ }
+ return rv;
+}
+
+int
+SBuf::compare(const SBuf &S, const SBufCaseSensitive isCaseSensitive, const size_type n) const
+{
+ if (n != npos)
+ return substr(0,n).compare(S.substr(0,n),isCaseSensitive);
+
+ const size_type byteCompareLen = min(S.length(), length());
+ ++stats.compareSlow;
+ int rv = 0;
+ if (isCaseSensitive == caseSensitive) {
+ rv = memcmp(buf(), S.buf(), byteCompareLen);
+ } else {
+ rv = memcasecmp(buf(), S.buf(), byteCompareLen);
+ }
+ if (rv != 0)
+ return rv;
+ if (length() == S.length())
+ return 0;
+ if (length() > S.length())
+ return 1;
+ return -1;
+}
+
+int
+SBuf::compare(const char *s, const SBufCaseSensitive isCaseSensitive, const size_type n) const
+{
+ // 0-length comparison is always true regardless of buffer states
+ if (!n) {
+ ++stats.compareFast;
+ return 0;
+ }
+
+ // N-length compare MUST provide a non-NULL C-string pointer
+ assert(s);
+
+ // when this is a 0-length string, no need for any complexity.
+ if (!length()) {
+ ++stats.compareFast;
+ return '\0' - *s;
+ }
+
+ // brute-force scan in order to avoid ever needing strlen() on a c-string.
+ ++stats.compareSlow;
+ const char *left = buf();
+ const char *right = s;
+ int rv = 0;
+ // what area to scan.
+ // n may be npos, but we treat that as a huge positive value
+ size_type byteCount = min(length(), n);
+
+ // loop until we find a difference, a '\0', or reach the end of area to scan
+ if (isCaseSensitive == caseSensitive) {
+ while ((rv = *left - *right++) == 0) {
+ if (*left++ == '\0' || --byteCount == 0)
+ break;
+ }
+ } else {
+ while ((rv = tolower(*left) - tolower(*right++)) == 0) {
+ if (*left++ == '\0' || --byteCount == 0)
+ break;
+ }
+ }
+
+ // If we stopped scanning because we reached the end
+ // of buf() before we reached the end of s,
+ // pretend we have a 0-terminator there to compare.
+ // NP: the loop already incremented "right" ready for this comparison
+ if (!byteCount && length() < n)
+ return '\0' - *right;
+
+ // If we found a difference within the scan area,
+ // or we found a '\0',
+ // or all n characters were identical (and none was \0).
+ return rv;
+}
+
+bool
+SBuf::startsWith(const SBuf &S, const SBufCaseSensitive isCaseSensitive) const
+{
+ debugs(24, 8, id << " startsWith " << S.id << ", caseSensitive: " <<
+ isCaseSensitive);
+ if (length() < S.length()) {
+ debugs(24, 8, "no, too short");
+ ++stats.compareFast;
+ return false;
+ }
+ return (compare(S, isCaseSensitive, S.length()) == 0);
+}
+
+bool
+SBuf::operator ==(const SBuf & S) const
+{
+ debugs(24, 8, id << " == " << S.id);
+ if (length() != S.length()) {
+ debugs(24, 8, "no, different lengths");
+ ++stats.compareFast;
+ return false; //shortcut: must be equal length
+ }
+ if (store_ == S.store_ && off_ == S.off_) {
+ debugs(24, 8, "yes, same length and backing store");
+ ++stats.compareFast;
+ return true; //shortcut: same store, offset and length
+ }
+ ++stats.compareSlow;
+ const bool rv = (0 == memcmp(buf(), S.buf(), length()));
+ debugs(24, 8, "returning " << rv);
+ return rv;
+}
+
+bool
+SBuf::operator !=(const SBuf & S) const
+{
+ return !(*this == S);
+}
+
+SBuf
+SBuf::consume(size_type n)
+{
+ if (n == npos)
+ n = length();
+ else
+ n = min(n, length());
+ debugs(24, 8, id << " consume " << n);
+ SBuf rv(substr(0, n));
+ chop(n);
+ return rv;
+}
+
+const
+SBufStats& SBuf::GetStats()
+{
+ return stats;
+}
+
+SBuf::size_type
+SBuf::copy(char *dest, size_type n) const
+{
+ size_type toexport = min(n,length());
+ memcpy(dest, buf(), toexport);
+ ++stats.copyOut;
+ return toexport;
+}
+
+const char*
+SBuf::rawContent() const
+{
+ ++stats.rawAccess;
+ return buf();
+}
+
+void
+SBuf::forceSize(size_type newSize)
+{
+ debugs(24, 8, id << " force " << (newSize > length() ? "grow" : "shrink") << " to length=" << newSize);
+
+ Must(store_->LockCount() == 1);
+ if (newSize > min(maxSize,store_->capacity-off_))
+ throw SBufTooBigException(__FILE__,__LINE__);
+ len_ = newSize;
+ store_->size = newSize;
+}
+
+const char*
+SBuf::c_str()
+{
+ ++stats.rawAccess;
+ /* null-terminate the current buffer, by hand-appending a \0 at its tail but
+ * without increasing its length. May COW, the side-effect is to guarantee that
+ * the MemBlob's tail is availabe for us to use */
+ *rawSpace(1) = '\0';
+ ++store_->size;
+ ++stats.setChar;
+ ++stats.nulTerminate;
+ return buf();
+}
+
+SBuf&
+SBuf::chop(size_type pos, size_type n)
+{
+ if (pos == npos || pos > length())
+ pos = length();
+
+ if (n == npos || (pos+n) > length())
+ n = length() - pos;
+
+ // if there will be nothing left, reset the buffer while we can
+ if (pos == length() || n == 0) {
+ clear();
+ return *this;
+ }
+
+ ++stats.chop;
+ off_ += pos;
+ len_ = n;
+ return *this;
+}
+
+SBuf&
+SBuf::trim(const SBuf &toRemove, bool atBeginning, bool atEnd)
+{
+ ++stats.trim;
+ if (atEnd) {
+ const char *p = bufEnd()-1;
+ while (!isEmpty() && memchr(toRemove.buf(), *p, toRemove.length()) != NULL) {
+ //current end-of-buf is in the searched set
+ --len_;
+ --p;
+ }
+ }
+ if (atBeginning) {
+ const char *p = buf();
+ while (!isEmpty() && memchr(toRemove.buf(), *p, toRemove.length()) != NULL) {
+ --len_;
+ ++off_;
+ ++p;
+ }
+ }
+ if (isEmpty())
+ clear();
+ return *this;
+}
+
+SBuf
+SBuf::substr(size_type pos, size_type n) const
+{
+ SBuf rv(*this);
+ rv.chop(pos, n); //stats handled by callee
+ return rv;
+}
+
+SBuf::size_type
+SBuf::find(char c, size_type startPos) const
+{
+ ++stats.find;
+
+ if (startPos == npos) // can't find anything if we look past end of SBuf
+ return npos;
+
+ // std::string returns npos if needle is outside hay
+ if (startPos > length())
+ return npos;
+
+ const void *i = memchr(buf()+startPos, (int)c, (size_type)length()-startPos);
+
+ if (i == NULL)
+ return npos;
+
+ return (static_cast<const char *>(i)-buf());
+}
+
+SBuf::size_type
+SBuf::find(const SBuf &needle, size_type startPos) const
+{
+ if (startPos == npos) { // can't find anything if we look past end of SBuf
+ ++stats.find;
+ return npos;
+ }
+
+ // std::string allows needle to overhang hay but not start outside
+ if (startPos > length()) {
+ ++stats.find;
+ return npos;
+ }
+
+ // for empty needle std::string returns startPos
+ if (needle.length() == 0) {
+ ++stats.find;
+ return startPos;
+ }
+
+ // if needle length is 1 use the char search
+ if (needle.length() == 1)
+ return find(needle[0], startPos);
+
+ ++stats.find;
+
+ char *begin = buf()+startPos;
+ char *lastPossible = buf()+length()-needle.length()+1;
+ char needleBegin = needle[0];
+
+ debugs(24, 7, "looking for " << needle << "starting at " << startPos <<
+ " in id " << id);
+ while (begin < lastPossible) {
+ char *tmp;
+ debugs(24, 8, " begin=" << (void *) begin <<
+ ", lastPossible=" << (void*) lastPossible );
+ tmp = static_cast<char *>(memchr(begin, needleBegin, lastPossible-begin));
+ if (tmp == NULL) {
+ debugs(24, 8 , "First byte not found");
+ return npos;
+ }
+ // lastPossible guarrantees no out-of-bounds with memcmp()
+ if (0 == memcmp(needle.buf(), tmp, needle.length())) {
+ debugs(24, 8, "Found at " << (tmp-buf()));
+ return (tmp-buf());
+ }
+ begin = tmp+1;
+ }
+ debugs(24, 8, "not found");
+ return npos;
+}
+
+SBuf::size_type
+SBuf::rfind(const SBuf &needle, SBuf::size_type endPos) const
+{
+ // when the needle is 1 char, use the 1-char rfind()
+ if (needle.length() == 1)
+ return rfind(needle[0], endPos);
+
+ ++stats.find;
+
+ // needle is bigger than haystack, impossible find
+ if (length() < needle.length())
+ return npos;
+
+ // if startPos is npos, std::string scans from the end of hay
+ if (endPos == npos || endPos > length()-needle.length())
+ endPos = length()-needle.length();
+
+ // an empty needle found at the end of the haystack
+ if (needle.length() == 0)
+ return endPos;
+
+ char *bufBegin = buf();
+ char *cur = bufBegin+endPos;
+ const char needleBegin = needle[0];
+ while (cur >= bufBegin) {
+ if (*cur == needleBegin) {
+ if (0 == memcmp(needle.buf(), cur, needle.length())) {
+ // found
+ return (cur-buf());
+ }
+ }
+ --cur;
+ }
+ return npos;
+}
+
+SBuf::size_type
+SBuf::rfind(char c, SBuf::size_type endPos) const
+{
+ ++stats.find;
+
+ // shortcut: haystack is empty, can't find anything by definition
+ if (length() == 0)
+ return npos;
+
+ // on npos input std::string compares last octet of hay
+ if (endPos == npos || endPos >= length()) {
+ endPos = length();
+ } else {
+ // NP: off-by-one weirdness:
+ // endPos is an offset ... 0-based
+ // length() is a count ... 1-based
+ // memrhr() requires a 1-based count of space to scan.
+ ++endPos;
+ }
+
+ if (length() == 0)
+ return endPos;
+
+ const void *i = memrchr(buf(), (int)c, (size_type)endPos);
+
+ if (i == NULL)
+ return npos;
+
+ return (static_cast<const char *>(i)-buf());
+}
+
+SBuf::size_type
+SBuf::findFirstOf(const CharacterSet &set, size_type startPos) const
+{
+ ++stats.find;
+
+ if (startPos == npos)
+ return npos;
+
+ if (startPos >= length())
+ return npos;
+
+ debugs(24, 7, "first of characterset " << set.name << " in id " << id);
+ char *cur = buf()+startPos;
+ const char *end = bufEnd();
+ while (cur < end) {
+ if (set[*cur])
+ return cur-buf();
+ ++cur;
+ }
+ debugs(24, 7, "not found");
+ return npos;
+}
+
+SBuf::size_type
+SBuf::findFirstNotOf(const CharacterSet &set, size_type startPos) const
+{
+ ++stats.find;
+
+ if (startPos == npos)
+ return npos;
+
+ if (startPos >= length())
+ return npos;
+
+ debugs(24, 7, "first not of characterset " << set.name << " in id " << id);
+ char *cur = buf()+startPos;
+ const char *end = bufEnd();
+ while (cur < end) {
+ if (!set[*cur])
+ return cur-buf();
+ ++cur;
+ }
+ debugs(24, 7, "not found");
+ return npos;
+}
+
+/*
+ * TODO: borrow a sscanf implementation from Linux or similar?
+ * we'd really need a vsnscanf(3)... ? As an alternative, a
+ * light-regexp-like domain-specific syntax might be an idea.
+ */
+int
+SBuf::scanf(const char *format, ...)
+{
+ // with the format or an arg might be a dangerous char*
+ // that gets invalidated by c_str()
+ const Locker blobKeeper(this, buf());
+
+ va_list arg;
+ int rv;
+ ++stats.scanf;
+ va_start(arg, format);
+ rv = vsscanf(c_str(), format, arg);
+ va_end(arg);
+ return rv;
+}
+
+std::ostream &
+SBufStats::dump(std::ostream& os) const
+{
+ MemBlobStats ststats = MemBlob::GetStats();
+ os <<
+ "SBuf stats:\nnumber of allocations: " << alloc <<
+ "\ncopy-allocations: " << allocCopy <<
+ "\ncopy-allocations from SquidString: " << allocFromString <<
+ "\ncopy-allocations from C String: " << allocFromCString <<
+ "\nlive references: " << live <<
+ "\nno-copy assignments: " << assignFast <<
+ "\nclearing operations: " << clear <<
+ "\nappend operations: " << append <<
+ "\ndump-to-ostream: " << toStream <<
+ "\nset-char: " << setChar <<
+ "\nget-char: " << getChar <<
+ "\ncomparisons with data-scan: " << compareSlow <<
+ "\ncomparisons not requiring data-scan: " << compareFast <<
+ "\ncopy-out ops: " << copyOut <<
+ "\nraw access to memory: " << rawAccess <<
+ "\nNULL terminate C string: " << nulTerminate <<
+ "\nchop operations: " << chop <<
+ "\ntrim operations: " << trim <<
+ "\nfind: " << find <<
+ "\nscanf: " << scanf <<
+ "\ncase-change ops: " << caseChange <<
+ "\nCOW not actually requiring a copy: " << cowFast <<
+ "\nCOW: " << cowSlow <<
+ "\naverage store share factor: " <<
+ (ststats.live != 0 ? static_cast<float>(live)/ststats.live : 0) <<
+ std::endl;
+ return os;
+}
+
+void
+SBuf::toLower()
+{
+ debugs(24, 8, "\"" << *this << "\"");
+ for (size_type j = 0; j < length(); ++j) {
+ const int c = (*this)[j];
+ if (isupper(c))
+ setAt(j, tolower(c));
+ }
+ debugs(24, 8, "result: \"" << *this << "\"");
+ ++stats.caseChange;
+}
+
+void
+SBuf::toUpper()
+{
+ debugs(24, 8, "\"" << *this << "\"");
+ for (size_type j = 0; j < length(); ++j) {
+ const int c = (*this)[j];
+ if (islower(c))
+ setAt(j, toupper(c));
+ }
+ debugs(24, 8, "result: \"" << *this << "\"");
+ ++stats.caseChange;
+}
+
+/**
+ * checks whether the requested 'pos' is within the bounds of the SBuf
+ * \throw OutOfBoundsException if access is out of bounds
+ */
+void
+SBuf::checkAccessBounds(size_type pos) const
+{
+ if (pos >= length())
+ throw OutOfBoundsException(*this, pos, __FILE__, __LINE__);
+}
+
+String
+SBuf::toString() const
+{
+ String rv;
+ rv.limitInit(buf(), length());
+ ++stats.copyOut;
+ return rv;
+}
+
+/** re-allocate the backing store of the SBuf.
+ *
+ * If there are contents in the SBuf, they will be copied over.
+ * NO verifications are made on the size parameters, it's up to the caller to
+ * make sure that the new size is big enough to hold the copied contents.
+ * The re-allocated storage MAY be bigger than the requested size due to size-chunking
+ * algorithms in MemBlock, it is guarranteed NOT to be smaller.
+ */
+void
+SBuf::reAlloc(size_type newsize)
+{
+ debugs(24, 8, id << " new size: " << newsize);
+ if (newsize > maxSize)
+ throw SBufTooBigException(__FILE__, __LINE__);
+ MemBlob::Pointer newbuf = new MemBlob(newsize);
+ if (length() > 0)
+ newbuf->append(buf(), length());
+ store_ = newbuf;
+ off_ = 0;
+ ++stats.cowSlow;
+ debugs(24, 7, id << " new store capacity: " << store_->capacity);
+}
+
+SBuf&
+SBuf::lowAppend(const char * memArea, size_type areaSize)
+{
+ rawSpace(areaSize); //called method also checks n <= maxSize()
+ store_->append(memArea, areaSize);
+ len_ += areaSize;
+ ++stats.append;
+ return *this;
+}
+
+/**
+ * copy-on-write: make sure that we are the only holder of the backing store.
+ * If not, reallocate. If a new size is specified, and it is greater than the
+ * current length, the backing store will be extended as needed
+ */
+void
+SBuf::cow(SBuf::size_type newsize)
+{
+ debugs(24, 8, id << " new size:" << newsize);
+ if (newsize == npos || newsize < length())
+ newsize = length();
+
+ if (store_->LockCount() == 1 && newsize == length()) {
+ debugs(24, 8, id << " no cow needed");
+ ++stats.cowFast;
+ return;
+ }
+ reAlloc(newsize);
+}
+
Index: squid-3.3.13/src/SBuf.h
===================================================================
--- /dev/null
+++ squid-3.3.13/src/SBuf.h
@@ -0,0 +1,669 @@
+/*
+ * Copyright (C) 1996-2016 The Squid Software Foundation and contributors
+ *
+ * Squid software is distributed under GPLv2+ license and includes
+ * contributions from numerous individuals and organizations.
+ * Please see the COPYING and CONTRIBUTORS files for details.
+ */
+
+#ifndef SQUID_SBUF_H
+#define SQUID_SBUF_H
+
+#include "base/InstanceId.h"
+#include "MemBlob.h"
+#include "SBufExceptions.h"
+#include "SquidString.h"
+
+#include <climits>
+#include <cstdarg>
+#include <iosfwd>
+#if HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+/* SBuf placeholder for printf */
+#ifndef SQUIDSBUFPH
+#define SQUIDSBUFPH "%.*s"
+#define SQUIDSBUFPRINT(s) (s).plength(),(s).rawContent()
+#endif /* SQUIDSBUFPH */
+
+// TODO: move within SBuf and rename
+typedef enum {
+ caseSensitive,
+ caseInsensitive
+} SBufCaseSensitive;
+
+/**
+ * Container for various SBuf class-wide statistics.
+ *
+ * The stats are not completely accurate; they're mostly meant to
+ * understand whether Squid is leaking resources
+ * and whether SBuf is paying off the expected gains.
+ */
+class SBufStats
+{
+public:
+ uint64_t alloc; ///<number of calls to SBuf constructors
+ uint64_t allocCopy; ///<number of calls to SBuf copy-constructor
+ uint64_t allocFromString; ///<number of copy-allocations from Strings
+ uint64_t allocFromCString; ///<number of copy-allocations from c-strings
+ uint64_t assignFast; ///<number of no-copy assignment operations
+ uint64_t clear; ///<number of clear operations
+ uint64_t append; ///<number of append operations
+ uint64_t toStream; ///<number of write operations to ostreams
+ uint64_t setChar; ///<number of calls to setAt
+ uint64_t getChar; ///<number of calls to at() and operator[]
+ uint64_t compareSlow; ///<number of comparison operations requiring data scan
+ uint64_t compareFast; ///<number of comparison operations not requiring data scan
+ uint64_t copyOut; ///<number of data-copies to other forms of buffers
+ uint64_t rawAccess; ///<number of accesses to raw contents
+ uint64_t nulTerminate; ///<number of c_str() terminations
+ uint64_t chop; ///<number of chop operations
+ uint64_t trim; ///<number of trim operations
+ uint64_t find; ///<number of find operations
+ uint64_t scanf; ///<number of scanf operations
+ uint64_t caseChange; ///<number of toUpper and toLower operations
+ uint64_t cowFast; ///<number of cow operations not actually requiring a copy
+ uint64_t cowSlow; ///<number of cow operations requiring a copy
+ uint64_t live; ///<number of currently-allocated SBuf
+
+ ///Dump statistics to an ostream.
+ std::ostream& dump(std::ostream &os) const;
+ SBufStats();
+
+ SBufStats& operator +=(const SBufStats&);
+};
+
+class CharacterSet;
+class SBufReservationRequirements;
+
+/**
+ * A String or Buffer.
+ * Features: refcounted backing store, cheap copy and sub-stringing
+ * operations, copy-on-write to isolate change operations to each instance.
+ * Where possible, we're trying to mimic std::string's interface.
+ */
+class SBuf
+{
+public:
+ typedef MemBlob::size_type size_type;
+ static const size_type npos = 0xffffffff; // max(uint32_t)
+
+ /// Maximum size of a SBuf. By design it MUST be < MAX(size_type)/2. Currently 256Mb.
+ static const size_type maxSize = 0xfffffff;
+
+ /// create an empty (zero-size) SBuf
+ SBuf();
+ SBuf(const SBuf &S);
+
+ /** Constructor: import c-style string
+ *
+ * Create a new SBuf containing a COPY of the contents of the
+ * c-string
+ * \param S the c string to be copied
+ * \param n how many bytes to import into the SBuf. If it is npos
+ * or unspecified, imports to end-of-cstring
+ * \note it is the caller's responsibility not to go out of bounds
+ * \note bounds is 0 <= pos < length(); caller must pay attention to signedness
+ */
+ explicit SBuf(const char *S, size_type n = npos);
+
+ /** Constructor: import SquidString, copying contents.
+ *
+ * This method will be removed once SquidString has gone.
+ */
+ explicit SBuf(const String &S);
+
+ /// Constructor: import std::string. Contents are copied.
+ explicit SBuf(const std::string &s);
+
+ ~SBuf();
+
+ /** Explicit assignment.
+ *
+ * Current SBuf will share backing store with the assigned one.
+ */
+ SBuf& assign(const SBuf &S);
+
+ /** Assignment operator.
+ *
+ * Current SBuf will share backing store with the assigned one.
+ */
+ SBuf& operator =(const SBuf & S) {return assign(S);}
+
+ /** Import a c-string into a SBuf, copying the data.
+ *
+ * It is the caller's duty to free the imported string, if needed.
+ * \param S the c string to be copied
+ * \param n how many bytes to import into the SBuf. If it is npos
+ * or unspecified, imports to end-of-cstring
+ * \note it is the caller's responsibility not to go out of bounds
+ * \note to assign a std::string use the pattern:
+ * assign(stdstr.data(), stdstd.length())
+ */
+ SBuf& assign(const char *S, size_type n = npos);
+
+ /** Assignment operator. Copy a NULL-terminated c-style string into a SBuf.
+ *
+ * Copy a c-style string into a SBuf. Shortcut for SBuf.assign(S)
+ * It is the caller's duty to free the imported string, if needed.
+ * \note not \0-clean
+ */
+ SBuf& operator =(const char *S) {return assign(S);}
+
+ /** reset the SBuf as if it was just created.
+ *
+ * Resets the SBuf to empty, memory is freed lazily.
+ */
+ void clear();
+
+ /** Append operation
+ *
+ * Append the supplied SBuf to the current one; extend storage as needed.
+ */
+ SBuf& append(const SBuf & S);
+
+ /// Append a single character. The character may be NUL (\0).
+ SBuf& append(const char c);
+
+ /** Append operation for C-style strings.
+ *
+ * Append the supplied c-string to the SBuf; extend storage
+ * as needed.
+ *
+ * \param S the c string to be copied. Can be NULL.
+ * \param Ssize how many bytes to import into the SBuf. If it is npos
+ * or unspecified, imports to end-of-cstring. If S is NULL,
+ * Ssize is ignored.
+ * \note to append a std::string use the pattern
+ * cstr_append(stdstr.data(), stdstd.length())
+ */
+ SBuf& append(const char * S, size_type Ssize = npos);
+
+ /** Assignment operation with printf(3)-style definition
+ * \note arguments may be evaluated more than once, be careful
+ * of side-effects
+ */
+ SBuf& Printf(const char *fmt, ...);
+
+ /** Append operation with printf-style arguments
+ * \note arguments may be evaluated more than once, be careful
+ * of side-effects
+ */
+ SBuf& appendf(const char *fmt, ...);
+
+ /** Append operation, with vsprintf(3)-style arguments.
+ * \note arguments may be evaluated more than once, be careful
+ * of side-effects
+ */
+ SBuf& vappendf(const char *fmt, va_list vargs);
+
+ /// print the SBuf contents to the supplied ostream
+ std::ostream& print(std::ostream &os) const;
+
+ /** print SBuf contents and debug information about the SBuf to an ostream
+ *
+ * Debug function, dumps to a stream informations on the current SBuf,
+ * including low-level details and statistics.
+ */
+ std::ostream& dump(std::ostream &os) const;
+
+ /** random-access read to any char within the SBuf
+ *
+ * does not check access bounds. If you need that, use at()
+ */
+ char operator [](size_type pos) const {++stats.getChar; return store_->mem[off_+pos];}
+
+ /** random-access read to any char within the SBuf.
+ *
+ * \throw OutOfBoundsException when access is out of bounds
+ * \note bounds is 0 <= pos < length(); caller must pay attention to signedness
+ */
+ char at(size_type pos) const {checkAccessBounds(pos); return operator[](pos);}
+
+ /** direct-access set a byte at a specified operation.
+ *
+ * \param pos the position to be overwritten
+ * \param toset the value to be written
+ * \throw OutOfBoundsException when pos is of bounds
+ * \note bounds is 0 <= pos < length(); caller must pay attention to signedness
+ * \note performs a copy-on-write if needed.
+ */
+ void setAt(size_type pos, char toset);
+
+ /** compare to other SBuf, str(case)cmp-style
+ *
+ * \param isCaseSensitive one of caseSensitive or caseInsensitive
+ * \param n compare up to this many bytes. if npos (default), compare whole SBufs
+ * \retval >0 argument of the call is greater than called SBuf
+ * \retval <0 argument of the call is smaller than called SBuf
+ * \retval 0 argument of the call has the same contents of called SBuf
+ */
+ int compare(const SBuf &S, const SBufCaseSensitive isCaseSensitive, const size_type n = npos) const;
+
+ /// shorthand version for compare()
+ inline int cmp(const SBuf &S, const size_type n = npos) const {
+ return compare(S,caseSensitive,n);
+ }
+
+ /// shorthand version for case-insensitive compare()
+ inline int caseCmp(const SBuf &S, const size_type n = npos) const {
+ return compare(S,caseInsensitive,n);
+ }
+
+ /// Comparison with a C-string.
+ int compare(const char *s, const SBufCaseSensitive isCaseSensitive, const size_type n = npos) const;
+
+ /// Shorthand version for C-string compare().
+ inline int cmp(const char *S, const size_type n = npos) const {
+ return compare(S,caseSensitive,n);
+ }
+
+ /// Shorthand version for case-insensitive C-string compare().
+ inline int caseCmp(const char *S, const size_type n = npos) const {
+ return compare(S,caseInsensitive,n);
+ }
+
+ /** check whether the entire supplied argument is a prefix of the SBuf.
+ * \param S the prefix to match against
+ * \param isCaseSensitive one of caseSensitive or caseInsensitive
+ * \retval true argument is a prefix of the SBuf
+ */
+ bool startsWith(const SBuf &S, const SBufCaseSensitive isCaseSensitive = caseSensitive) const;
+
+ bool operator ==(const SBuf & S) const;
+ bool operator !=(const SBuf & S) const;
+ bool operator <(const SBuf &S) const {return (cmp(S) < 0);}
+ bool operator >(const SBuf &S) const {return (cmp(S) > 0);}
+ bool operator <=(const SBuf &S) const {return (cmp(S) <= 0);}
+ bool operator >=(const SBuf &S) const {return (cmp(S) >= 0);}
+
+ /** Consume bytes at the head of the SBuf
+ *
+ * Consume N chars at SBuf head, or to SBuf's end,
+ * whichever is shorter. If more bytes are consumed than available,
+ * the SBuf is emptied
+ * \param n how many bytes to remove; could be zero.
+ * npos (or no argument) means 'to the end of SBuf'
+ * \return a new SBuf containing the consumed bytes.
+ */
+ SBuf consume(size_type n = npos);
+
+ /// gets global statistic informations
+ static const SBufStats& GetStats();
+
+ /** Copy SBuf contents into user-supplied C buffer.
+ *
+ * Export a copy of the SBuf's contents into the user-supplied
+ * buffer, up to the user-supplied-length. No zero-termination is performed
+ * \return num the number of actually-copied chars.
+ */
+ size_type copy(char *dest, size_type n) const;
+
+ /** exports a pointer to the SBuf internal storage.
+ * \warning ACCESSING RAW STORAGE IS DANGEROUS!
+ *
+ * Returns a ead-only pointer to SBuf's content. No terminating null
+ * character is appended (use c_str() for that).
+ * The returned value points to an internal location whose contents
+ * are guaranteed to remain unchanged only until the next call
+ * to a non-constant member function of the SBuf object. Such a
+ * call may be implicit (e.g., when SBuf is destroyed
+ * upon leaving the current context).
+ * This is a very UNSAFE way of accessing the data.
+ * This call never returns NULL.
+ * \see c_str
+ * \note the memory management system guarantees that the exported region
+ * of memory will remain valid if the caller keeps holding
+ * a valid reference to the SBuf object and does not write or append to
+ * it. For example:
+ * \code
+ * SBuf foo("some string");
+ * const char *bar = foo.rawContent();
+ * doSomething(bar); //safe
+ * foo.append(" other string");
+ * doSomething(bar); //unsafe
+ * \endcode
+ */
+ const char* rawContent() const;
+
+ /** Exports a writable pointer to the SBuf internal storage.
+ * \warning Use with EXTREME caution, this is a dangerous operation.
+ *
+ * Returns a pointer to the first unused byte in the SBuf's storage,
+ * which can be be used for appending. At least minSize bytes will
+ * be available for writing.
+ * The returned pointer must not be stored by the caller, as it will
+ * be invalidated by the first call to a non-const method call
+ * on the SBuf.
+ * This call guarantees to never return NULL.
+ * \see reserveSpace
+ * \note Unlike reserveSpace(), this method does not guarantee exclusive
+ * buffer ownership. It is instead optimized for a one writer
+ * (appender), many readers scenario by avoiding unnecessary
+ * copying and allocations.
+ * \throw SBufTooBigException if the user tries to allocate too big a SBuf
+ */
+ char *rawSpace(size_type minSize);
+
+ /** Obtain how much free space is available in the backing store.
+ *
+ * \note: unless the client just cow()ed, it is not guaranteed that
+ * the free space can be used.
+ */
+ size_type spaceSize() const { return store_->spaceSize(); }
+
+ /** Force a SBuf's size
+ * \warning use with EXTREME caution, this is a dangerous operation
+ *
+ * Adapt the SBuf internal state after external interference
+ * such as writing into it via rawSpace.
+ * \throw TextException if SBuf doesn't have exclusive ownership of store
+ * \throw SBufTooBigException if new size is bigger than available store space
+ */
+ void forceSize(size_type newSize);
+
+ /** exports a null-terminated reference to the SBuf internal storage.
+ * \warning ACCESSING RAW STORAGE IS DANGEROUS! DO NOT EVER USE
+ * THE RETURNED POINTER FOR WRITING
+ *
+ * The returned value points to an internal location whose contents
+ * are guaranteed to remain unchanged only until the next call
+ * to a non-constant member function of the SBuf object. Such a
+ * call may be implicit (e.g., when SBuf is destroyed
+ * upon leaving the current context).
+ * This is a very UNSAFE way of accessing the data.
+ * This call never returns NULL.
+ * \see rawContent
+ * \note the memory management system guarantees that the exported region
+ * of memory will remain valid will remain valid only if the
+ * caller keeps holding a valid reference to the SBuf object and
+ * does not write or append to it
+ */
+ const char* c_str();
+
+ /// Returns the number of bytes stored in SBuf.
+ size_type length() const {return len_;}
+
+ /** Get the length of the SBuf, as a signed integer
+ *
+ * Compatibility function for printf(3) which requires a signed int
+ * \throw SBufTooBigException if the SBuf is too big for a signed integer
+ */
+ int plength() const {
+ if (length()>INT_MAX)
+ throw SBufTooBigException(__FILE__, __LINE__);
+ return static_cast<int>(length());
+ }
+
+ /** Check whether the SBuf is empty
+ *
+ * \return true if length() == 0
+ */
+ bool isEmpty() const {return (len_==0);}
+
+ /** Request to guarantee the SBuf's free store space.
+ *
+ * After the reserveSpace request, the SBuf is guaranteed to have at
+ * least minSpace bytes of unused backing store following the currently
+ * used portion and single ownership of the backing store.
+ * \throw SBufTooBigException if the user tries to allocate too big a SBuf
+ */
+ void reserveSpace(size_type minSpace) {
+ Must(minSpace <= maxSize);
+ Must(length() <= maxSize - minSpace);
+ reserveCapacity(length()+minSpace);
+ }
+
+ /** Request to guarantee the SBuf's store capacity
+ *
+ * After this method is called, the SBuf is guaranteed to have at least
+ * minCapacity bytes of total buffer size, including the currently-used
+ * portion; it is also guaranteed that after this call this SBuf
+ * has unique ownership of the underlying memory store.
+ * \throw SBufTooBigException if the user tries to allocate too big a SBuf
+ */
+ void reserveCapacity(size_type minCapacity);
+
+ /** Accommodate caller's requirements regarding SBuf's storage if possible.
+ *
+ * \return spaceSize(), which may be zero
+ */
+ size_type reserve(const SBufReservationRequirements &requirements);
+
+ /** slicing method
+ *
+ * Removes SBuf prefix and suffix, leaving a sequence of 'n'
+ * bytes starting from position 'pos', first byte is at pos 0.
+ * It is an in-place-modifying version of substr.
+ * \param pos start sub-stringing from this byte. If it is
+ * npos or it is greater than the SBuf length, the SBuf is cleared and
+ * an empty SBuf is returned.
+ * \param n maximum number of bytes of the resulting SBuf.
+ * npos means "to end of SBuf".
+ * if it is 0, the SBuf is cleared and an empty SBuf is returned.
+ * if it overflows the end of the SBuf, it is capped to the end of SBuf
+ * \see substr, trim
+ */
+ SBuf& chop(size_type pos, size_type n = npos);
+
+ /** Remove characters in the toremove set at the beginning, end or both
+ *
+ * \param toremove characters to be removed. Stops chomping at the first
+ * found char not in the set
+ * \param atBeginning if true (default), strips at the beginning of the SBuf
+ * \param atEnd if true (default), strips at the end of the SBuf
+ */
+ SBuf& trim(const SBuf &toRemove, bool atBeginning = true, bool atEnd = true);
+
+ /** Extract a part of the current SBuf.
+ *
+ * Return a fresh a fresh copy of a portion the current SBuf, which is
+ * left untouched. The same parameter convetions apply as for chop.
+ * \see trim, chop
+ */
+ SBuf substr(size_type pos, size_type n = npos) const;
+
+ /** Find first occurrence of character in SBuf
+ *
+ * Returns the index in the SBuf of the first occurrence of char c.
+ * \return npos if the char was not found
+ * \param startPos if specified, ignore any occurrences before that position
+ * if startPos is npos or greater than length() npos is always returned
+ * if startPos is less than zero, it is ignored
+ */
+ size_type find(char c, size_type startPos = 0) const;
+
+ /** Find first occurrence of SBuf in SBuf.
+ *
+ * Returns the index in the SBuf of the first occurrence of the
+ * sequence contained in the str argument.
+ * \param startPos if specified, ignore any occurrences before that position
+ * if startPos is npos or greater than length() npos is always returned
+ * \return npos if the SBuf was not found
+ */
+ size_type find(const SBuf & str, size_type startPos = 0) const;
+
+ /** Find last occurrence of character in SBuf
+ *
+ * Returns the index in the SBuf of the last occurrence of char c.
+ * \return npos if the char was not found
+ * \param endPos if specified, ignore any occurrences after that position.
+ * if npos or greater than length(), the whole SBuf is considered
+ */
+ size_type rfind(char c, size_type endPos = npos) const;
+
+ /** Find last occurrence of SBuf in SBuf
+ *
+ * Returns the index in the SBuf of the last occurrence of the
+ * sequence contained in the str argument.
+ * \return npos if the sequence was not found
+ * \param endPos if specified, ignore any occurrences after that position
+ * if npos or greater than length(), the whole SBuf is considered
+ */
+ size_type rfind(const SBuf &str, size_type endPos = npos) const;
+
+ /** Find first occurrence of character of set in SBuf
+ *
+ * Finds the first occurrence of ANY of the characters in the supplied set in
+ * the SBuf.
+ * \return npos if no character in the set could be found
+ * \param startPos if specified, ignore any occurrences before that position
+ * if npos, then npos is always returned
+ *
+ * TODO: rename to camelCase
+ */
+ size_type findFirstOf(const CharacterSet &set, size_type startPos = 0) const;
+
+ /** Find first occurrence character NOT in character set
+ *
+ * \return npos if all characters in the SBuf are from set
+ * \param startPos if specified, ignore any occurrences before that position
+ * if npos, then npos is always returned
+ *
+ * TODO: rename to camelCase
+ */
+ size_type findFirstNotOf(const CharacterSet &set, size_type startPos = 0) const;
+
+ /** sscanf-alike
+ *
+ * sscanf re-implementation. Non-const, and not \0-clean.
+ * \return same as sscanf
+ * \see man sscanf(3)
+ */
+ int scanf(const char *format, ...);
+
+ /// converts all characters to lower case; \see man tolower(3)
+ void toLower();
+
+ /// converts all characters to upper case; \see man toupper(3)
+ void toUpper();
+
+ /** String export function
+ * converts the SBuf to a legacy String, by copy.
+ * \deprecated
+ */
+ String toString() const;
+
+ /// std::string export function
+ std::string toStdString() const { return std::string(buf(),length()); }
+
+ // TODO: possibly implement erase() similar to std::string's erase
+ // TODO: possibly implement a replace() call
+private:
+
+ /**
+ * Keeps SBuf's MemBlob alive in a blob-destroying context where
+ * a seemingly unrelated memory pointer may belong to the same blob.
+ * For [an extreme] example, consider: a.append(a).
+ * Compared to an SBuf temporary, this class is optimized to
+ * preserve blobs only if needed and to reduce debugging noise.
+ */
+ class Locker
+ {
+ public:
+ Locker(SBuf *parent, const char *otherBuffer) {
+ // lock if otherBuffer intersects the parents buffer area
+ const MemBlob *blob = parent->store_.getRaw();
+ if (blob->mem <= otherBuffer && otherBuffer < (blob->mem + blob->capacity))
+ locket = blob;
+ }
+ private:
+ MemBlob::Pointer locket;
+ };
+ friend class Locker;
+
+ MemBlob::Pointer store_; ///< memory block, possibly shared with other SBufs
+ size_type off_; ///< our content start offset from the beginning of shared store_
+ size_type len_; ///< number of our content bytes in shared store_
+ static SBufStats stats; ///< class-wide statistics
+
+ /// SBuf object identifier; does not change when contents do,
+ /// including during assignment
+ const InstanceId<SBuf> id;
+
+ /** obtain prototype store
+ *
+ * Just-created SBufs all share to the same MemBlob.
+ * This call instantiates and returns it.
+ */
+ static MemBlob::Pointer GetStorePrototype();
+
+ /**
+ * obtains a char* to the beginning of this SBuf in memory.
+ * \note the obtained string is NOT null-terminated.
+ */
+ char * buf() const {return (store_->mem+off_);}
+
+ /** returns the pointer to the first char after this SBuf end
+ *
+ * No checks are made that the space returned is safe, checking that is
+ * up to the caller.
+ */
+ char * bufEnd() const {return (store_->mem+off_+len_);}
+
+ /**
+ * Try to guesstimate how big a MemBlob to allocate.
+ * The result is guarranteed to be to be at least the desired size.
+ */
+ size_type estimateCapacity(size_type desired) const {return (2*desired);}
+
+ void reAlloc(size_type newsize);
+
+ void cow(size_type minsize = npos);
+
+ void checkAccessBounds(size_type pos) const;
+
+ /** Low-level append operation
+ *
+ * Takes as input a contiguous area of memory and appends its contents
+ * to the SBuf, taking care of memory management. Does no bounds checking
+ * on the supplied memory buffer, it is the duty of the caller to ensure
+ * that the supplied area is valid.
+ */
+ SBuf& lowAppend(const char * memArea, size_type areaSize);
+};
+
+/// Named SBuf::reserve() parameters. Defaults ask for and restrict nothing.
+class SBufReservationRequirements
+{
+public:
+ typedef SBuf::size_type size_type;
+
+ SBufReservationRequirements() : idealSpace(0), minSpace(0), maxCapacity(SBuf::maxSize), allowShared(true) {}
+
+ /*
+ * Parameters are listed in the reverse order of importance: Satisfaction of
+ * the lower-listed requirements may violate the higher-listed requirements.
+ */
+ size_type idealSpace; ///< if allocating anyway, provide this much space
+ size_type minSpace; ///< allocate if spaceSize() is smaller
+ size_type maxCapacity; ///< do not allocate more than this
+ bool allowShared; ///< whether sharing our storage with others is OK
+};
+
+/// ostream output operator
+inline std::ostream &
+operator <<(std::ostream& os, const SBuf& S)
+{
+ return S.print(os);
+}
+
+/// Returns a lower-cased copy of its parameter.
+inline SBuf
+ToUpper(SBuf buf)
+{
+ buf.toUpper();
+ return buf;
+}
+
+/// Returns an upper-cased copy of its parameter.
+inline SBuf
+ToLower(SBuf buf)
+{
+ buf.toLower();
+ return buf;
+}
+
+#endif /* SQUID_SBUF_H */
+
Index: squid-3.3.13/src/SBufDetailedStats.cc
===================================================================
--- /dev/null
+++ squid-3.3.13/src/SBufDetailedStats.cc
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 1996-2016 The Squid Software Foundation and contributors
+ *
+ * Squid software is distributed under GPLv2+ license and includes
+ * contributions from numerous individuals and organizations.
+ * Please see the COPYING and CONTRIBUTORS files for details.
+ */
+
+#include "squid.h"
+#include "SBufDetailedStats.h"
+#include "StatHist.h"
+
+/*
+ * Implementation note: the purpose of this construct is to avoid adding
+ * external dependencies to the SBuf code
+ */
+
+static StatHist *
+newStatHist() {
+ StatHist *stats = new StatHist;
+ stats->logInit(100, 30.0, 128000.0);
+ return stats;
+}
+
+StatHist &
+collectSBufDestructTimeStats()
+{
+ static StatHist *stats = newStatHist();
+ return *stats;
+}
+
+StatHist &
+collectMemBlobDestructTimeStats()
+{
+ static StatHist *stats = newStatHist();
+ return *stats;
+}
+
+void
+recordSBufSizeAtDestruct(SBuf::size_type sz)
+{
+ collectSBufDestructTimeStats().count(static_cast<double>(sz));
+}
+
+void
+recordMemBlobSizeAtDestruct(SBuf::size_type sz)
+{
+ collectMemBlobDestructTimeStats().count(static_cast<double>(sz));
+}
+
Index: squid-3.3.13/src/SBufDetailedStats.h
===================================================================
--- /dev/null
+++ squid-3.3.13/src/SBufDetailedStats.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 1996-2016 The Squid Software Foundation and contributors
+ *
+ * Squid software is distributed under GPLv2+ license and includes
+ * contributions from numerous individuals and organizations.
+ * Please see the COPYING and CONTRIBUTORS files for details.
+ */
+
+#ifndef SQUID_SBUFDETAILEDSTATS_H
+#define SQUID_SBUFDETAILEDSTATS_H
+
+#include "SBuf.h"
+
+class StatHist;
+
+/// Record the size a SBuf had when it was destructed
+void recordSBufSizeAtDestruct(SBuf::size_type sz);
+
+/// the SBuf size-at-destruct-time histogram
+StatHist &collectSBufDestructTimeStats();
+
+/// Record the size a MemBlob had when it was destructed
+void recordMemBlobSizeAtDestruct(MemBlob::size_type sz);
+
+/// the MemBlob size-at-destruct-time histogram
+StatHist &collectMemBlobDestructTimeStats();
+
+#endif /* SQUID_SBUFDETAILEDSTATS_H */
+
Index: squid-3.3.13/src/SBufExceptions.cc
===================================================================
--- /dev/null
+++ squid-3.3.13/src/SBufExceptions.cc
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 1996-2016 The Squid Software Foundation and contributors
+ *
+ * Squid software is distributed under GPLv2+ license and includes
+ * contributions from numerous individuals and organizations.
+ * Please see the COPYING and CONTRIBUTORS files for details.
+ */
+
+#include "squid.h"
+#include "OutOfBoundsException.h"
+#include "SBuf.h"
+#include "SBufExceptions.h"
+
+OutOfBoundsException::OutOfBoundsException(const SBuf &throwingBuf,
+ SBuf::size_type &pos,
+ const char *aFileName, int aLineNo)
+ : TextException(NULL, aFileName, aLineNo),
+ theThrowingBuf(throwingBuf),
+ accessedPosition(pos)
+{
+ SBuf explanatoryText("OutOfBoundsException");
+ if (aLineNo != -1)
+ explanatoryText.appendf(" at line %d", aLineNo);
+ if (aFileName != NULL)
+ explanatoryText.appendf(" in file %s", aFileName);
+ explanatoryText.appendf(" while accessing position %d in a SBuf long %d",
+ pos, throwingBuf.length());
+ // we can safely alias c_str as both are local to the object
+ // and will not further manipulated.
+ message = xstrndup(explanatoryText.c_str(),explanatoryText.length());
+}
+
+OutOfBoundsException::~OutOfBoundsException() throw()
+{ }
+
+InvalidParamException::InvalidParamException(const char *aFilename, int aLineNo)
+ : TextException("Invalid parameter", aFilename, aLineNo)
+{ }
+
+SBufTooBigException::SBufTooBigException(const char *aFilename, int aLineNo)
+ : TextException("Trying to create an oversize SBuf", aFilename, aLineNo)
+{ }
+
Index: squid-3.3.13/src/SBufExceptions.h
===================================================================
--- /dev/null
+++ squid-3.3.13/src/SBufExceptions.h
@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 1996-2016 The Squid Software Foundation and contributors
+ *
+ * Squid software is distributed under GPLv2+ license and includes
+ * contributions from numerous individuals and organizations.
+ * Please see the COPYING and CONTRIBUTORS files for details.
+ */
+
+#ifndef SQUID_SBUFEXCEPTIONS_H
+#define SQUID_SBUFEXCEPTIONS_H
+
+#include "base/TextException.h"
+
+/**
+ * Exception raised when call parameters are not valid
+ * \todo move to an Exceptions.h?
+ */
+class InvalidParamException : public TextException
+{
+public:
+ explicit InvalidParamException(const char *aFilename = 0, int aLineNo = -1);
+};
+
+/**
+ * Exception raised when an attempt to resize a SBuf would cause it to reserve too big
+ */
+class SBufTooBigException : public TextException
+{
+public:
+ explicit SBufTooBigException(const char *aFilename = 0, int aLineNo = -1);
+};
+
+#endif /* SQUID_SBUFEXCEPTIONS_H */
+
Index: squid-3.3.13/src/Makefile.am
===================================================================
--- squid-3.3.13.orig/src/Makefile.am
+++ squid-3.3.13/src/Makefile.am
@@ -22,9 +22,14 @@ DNSSOURCE += \
DnsLookupDetails.cc
SBUF_SOURCE= \
+ base/CharacterSet.h \
base/InstanceId.h \
MemBlob.h \
- MemBlob.cc
+ MemBlob.cc \
+ SBuf.h \
+ SBuf.cc \
+ SBufExceptions.h \
+ SBufExceptions.cc
LOADABLE_MODULES_SOURCES = \
LoadableModule.h \
@@ -468,6 +473,8 @@ squid_SOURCES = \
send-announce.h \
send-announce.cc \
$(SBUF_SOURCE) \
+ SBufDetailedStats.h \
+ SBufDetailedStats.cc \
$(SNMP_SOURCE) \
SquidMath.h \
SquidMath.cc \
Index: squid-3.3.13/src/base/CharacterSet.cc
===================================================================
--- /dev/null
+++ squid-3.3.13/src/base/CharacterSet.cc
@@ -0,0 +1,117 @@
+/*
+ * Copyright (C) 1996-2016 The Squid Software Foundation and contributors
+ *
+ * Squid software is distributed under GPLv2+ license and includes
+ * contributions from numerous individuals and organizations.
+ * Please see the COPYING and CONTRIBUTORS files for details.
+ */
+
+#include "squid.h"
+#include "CharacterSet.h"
+
+#include <algorithm>
+#include <functional>
+
+CharacterSet &
+CharacterSet::operator +=(const CharacterSet &src)
+{
+ Storage::const_iterator s = src.chars_.begin();
+ const Storage::const_iterator e = src.chars_.end();
+ Storage::iterator d = chars_.begin();
+ while (s != e) {
+ if (*s)
+ *d = 1;
+ ++s;
+ ++d;
+ }
+ return *this;
+}
+
+CharacterSet
+CharacterSet::operator +(const CharacterSet &src) const
+{
+ CharacterSet rv(*this);
+ rv += src;
+ return rv;
+}
+
+CharacterSet &
+CharacterSet::add(const unsigned char c)
+{
+ chars_[static_cast<uint8_t>(c)] = 1;
+ return *this;
+}
+
+CharacterSet &
+CharacterSet::addRange(unsigned char low, unsigned char high)
+{
+ //manual loop splitting is needed to cover case where high is 255
+ // otherwise low will wrap, resulting in infinite loop
+ while (low < high) {
+ chars_[static_cast<uint8_t>(low)] = 1;
+ ++low;
+ }
+ chars_[static_cast<uint8_t>(high)] = 1;
+ return *this;
+}
+
+CharacterSet
+CharacterSet::complement(const char *label) const
+{
+ CharacterSet result((label ? label : "complement_of_some_other_set"), "");
+ // negate each of our elements and add them to the result storage
+ std::transform(chars_.begin(), chars_.end(), result.chars_.begin(),
+ std::logical_not<Storage::value_type>());
+ return result;
+}
+
+CharacterSet::CharacterSet(const char *label, const char * const c) :
+ name(label == NULL ? "anonymous" : label),
+ chars_(Storage(256,0))
+{
+ const size_t clen = strlen(c);
+ for (size_t i = 0; i < clen; ++i)
+ add(c[i]);
+}
+
+CharacterSet::CharacterSet(const char *label, unsigned char low, unsigned char high) :
+ name(label == NULL ? "anonymous" : label),
+ chars_(Storage(256,0))
+{
+ addRange(low,high);
+}
+
+const CharacterSet
+// RFC 5234
+CharacterSet::ALPHA("ALPHA", "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"),
+ CharacterSet::BIT("BIT","01"),
+ CharacterSet::CR("CR","\r"),
+#if __cplusplus == 201103L
+//CharacterSet::CTL("CTL",{{0x01,0x1f},{0x7f,0x7f}}),
+#endif
+ CharacterSet::DIGIT("DIGIT","0123456789"),
+ CharacterSet::DQUOTE("DQUOTE","\""),
+ CharacterSet::HEXDIG("HEXDIG","0123456789aAbBcCdDeEfF"),
+ CharacterSet::HTAB("HTAB","\t"),
+ CharacterSet::LF("LF","\n"),
+ CharacterSet::SP("SP"," "),
+ CharacterSet::VCHAR("VCHAR", 0x21, 0x7e),
+// RFC 7230
+ CharacterSet::WSP("WSP"," \t"),
+#if __cplusplus == 201103L
+//CharacterSet::CTEXT("ctext",{{0x09,0x09},{0x20,0x20},{0x2a,0x5b},{0x5d,0x7e},{0x80,0xff}}),
+#endif
+ CharacterSet::TCHAR("TCHAR","!#$%&'*+-.^_`|~0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"),
+ CharacterSet::SPECIAL("SPECIAL","()<>@,;:\\\"/[]?={}"),
+#if __cplusplus == 201103L
+//CharacterSet::QDTEXT("QDTEXT",{{0x09,0x09},{0x20,0x21},{0x23,0x5b},{0x5d,0x7e},{0x80,0xff}}),
+#endif
+ CharacterSet::OBSTEXT("OBSTEXT",0x80,0xff),
+// RFC 7232
+#if __cplusplus == 201103L
+//CharacterSet::ETAGC("ETAGC",{{0x21,0x21},{0x23,0x7e},{0x80,0xff}}),
+#endif
+// RFC 7235
+ CharacterSet::TOKEN68C("TOKEN68C","-._~+/0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
+ ;
+
Index: squid-3.3.13/src/base/CharacterSet.h
===================================================================
--- /dev/null
+++ squid-3.3.13/src/base/CharacterSet.h
@@ -0,0 +1,123 @@
+/*
+ * Copyright (C) 1996-2016 The Squid Software Foundation and contributors
+ *
+ * Squid software is distributed under GPLv2+ license and includes
+ * contributions from numerous individuals and organizations.
+ * Please see the COPYING and CONTRIBUTORS files for details.
+ */
+
+#ifndef _SQUID_SRC_PARSER_CHARACTERSET_H
+#define _SQUID_SRC_PARSER_CHARACTERSET_H
+
+#include <vector>
+
+/// optimized set of C chars, with quick membership test and merge support
+class CharacterSet
+{
+public:
+ typedef std::vector<uint8_t> Storage;
+
+ /// define a character set with the given label ("anonymous" if NULL)
+ /// with specified initial contents
+ CharacterSet(const char *label, const char * const initial);
+
+ /// define a character set with the given label ("anonymous" if NULL)
+ /// containing characters defined in the supplied ranges
+ /// \see addRange
+ CharacterSet(const char *label, unsigned char low, unsigned char high);
+
+ /// whether a given character exists in the set
+ bool operator[](unsigned char c) const {return chars_[static_cast<uint8_t>(c)] != 0;}
+
+ /// add a given character to the character set
+ CharacterSet & add(const unsigned char c);
+
+ /// add a list of character ranges, expressed as pairs [low,high], including both ends
+ CharacterSet & addRange(unsigned char low, unsigned char high);
+
+ /// add all characters from the given CharacterSet to this one
+ CharacterSet &operator +=(const CharacterSet &src);
+
+ /// return a new CharacterSet containing the union of two sets
+ CharacterSet operator +(const CharacterSet &src) const;
+
+ /// return a new CharacterSet containing characters not in this set
+ CharacterSet complement(const char *complementLabel = NULL) const;
+
+ /// change name; handy in const declarations that use operators
+ CharacterSet &rename(const char *label) { name = label; return *this; }
+
+ /// optional set label for debugging (default: "anonymous")
+ const char * name;
+
+ // common character sets, RFC 5234
+ // A-Za-z
+ static const CharacterSet ALPHA;
+ // 0-1
+ static const CharacterSet BIT;
+ // carriage return
+ static const CharacterSet CR;
+ // controls
+#if __cplusplus == 201103L
+ // ready but disabled as needs C++11 constructor
+ //static const CharacterSet CTL;
+#endif
+ // 0-9
+ static const CharacterSet DIGIT;
+ // double quote
+ static const CharacterSet DQUOTE;
+ // 0-9aAbBcCdDeEfF
+ static const CharacterSet HEXDIG;
+ // horizontal tab
+ static const CharacterSet HTAB;
+ // line feed
+ static const CharacterSet LF;
+ // white space
+ static const CharacterSet SP;
+ // visible (printable) characters
+ static const CharacterSet VCHAR;
+ // <space><tab>
+ static const CharacterSet WSP;
+
+ // HTTP character sets, RFC 7230
+ // ctext
+#if __cplusplus == 201103L
+ // ready but disabled as needs C++11 constructor
+ //static const CharacterSet CTEXT;
+#endif
+ // XXX: maybe field-vchar = VCHAR / obs-text
+ // any VCHAR except for SPECIAL
+ static const CharacterSet TCHAR;
+ // special VCHARs
+ static const CharacterSet SPECIAL;
+ // qdtext
+#if __cplusplus == 201103L
+ // ready but disabled as needs C++11 constructor
+ //static const CharacterSet QDTEXT;
+#endif
+ // obs-text
+ static const CharacterSet OBSTEXT;
+
+ // HTTP character sets, RFC 7232
+ // etagc
+#if __cplusplus == 201103L
+ // ready but disabled as needs C++11 constructor
+ //static const CharacterSet ETAGC;
+#endif
+
+ // HTTP character sets, RFC 7235
+ // token68 (internal charaters only, excludes '=' terminator)
+ static const CharacterSet TOKEN68C;
+
+private:
+ /** index of characters in this set
+ *
+ * \note guaranteed to be always 256 slots big, as forced in the
+ * constructor. This assumption is relied upon in operator[], add,
+ * operator+=
+ */
+ Storage chars_;
+};
+
+#endif /* _SQUID_SRC_PARSER_CHARACTERSET_H */
+
Index: squid-3.3.13/src/base/Makefile.am
===================================================================
--- squid-3.3.13.orig/src/base/Makefile.am
+++ squid-3.3.13/src/base/Makefile.am
@@ -14,6 +14,8 @@ libbase_la_SOURCES = \
AsyncCallQueue.cc \
AsyncCallQueue.h \
TidyPointer.h \
+ CharacterSet.h \
+ CharacterSet.cc \
CbcPointer.h \
InstanceId.h \
RunnersRegistry.cc \
Index: squid-3.3.13/src/OutOfBoundsException.h
===================================================================
--- /dev/null
+++ squid-3.3.13/src/OutOfBoundsException.h
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 1996-2016 The Squid Software Foundation and contributors
+ *
+ * Squid software is distributed under GPLv2+ license and includes
+ * contributions from numerous individuals and organizations.
+ * Please see the COPYING and CONTRIBUTORS files for details.
+ */
+
+#ifndef _SQUID_SRC_OUTOFBOUNDSEXCEPTION_H
+#define _SQUID_SRC_OUTOFBOUNDSEXCEPTION_H
+
+#include "base/TextException.h"
+#include "SBuf.h"
+
+/**
+ * Exception raised when the user is going out of bounds when accessing
+ * a char within the SBuf
+ */
+class OutOfBoundsException : public TextException
+{
+public:
+ OutOfBoundsException(const SBuf &buf, SBuf::size_type &pos, const char *aFileName = 0, int aLineNo = -1);
+ virtual ~OutOfBoundsException() throw();
+
+protected:
+ SBuf theThrowingBuf;
+ SBuf::size_type accessedPosition;
+};
+
+#endif /* _SQUID_SRC_OUTOFBOUNDSEXCEPTION_H */
+
Index: squid-3.3.13/include/RefCount.h
===================================================================
--- squid-3.3.13.orig/include/RefCount.h
+++ squid-3.3.13/include/RefCount.h
@@ -117,7 +117,7 @@ struct RefCountable_ {
++count_;
}
- unsigned RefCountDereference() const {
+ uint32_t RefCountDereference() const {
#if REFCOUNT_DEBUG
old_debug(0,1)("Decrementing this %p from count %u\n",this,count_);
#endif
@@ -125,10 +125,11 @@ struct RefCountable_ {
return --count_;
}
- unsigned RefCountCount() const { return count_; } // for debugging only
+ uint32_t RefCountCount() const { return count_; } // for debugging only
+ uint32_t LockCount() const { return count_; }
private:
- mutable unsigned count_;
+ mutable uint32_t count_;
};
#define RefCountable virtual RefCountable_
