The Tor Browser: comparison security/sandbox/chromium/base/strings/stringprintf.cc

--1:000000000000
+:e0178a97afc3
+// Copyright 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+#include "base/strings/stringprintf.h"
+#include <errno.h>
+#include "base/scoped_clear_errno.h"
+#include "base/strings/string_util.h"
+#include "base/strings/utf_string_conversions.h"
+namespace base {
+namespace {
+// Overloaded wrappers around vsnprintf and vswprintf. The buf_size parameter
+// is the size of the buffer. These return the number of characters in the
+// formatted string excluding the NUL terminator. If the buffer is not
+// large enough to accommodate the formatted string without truncation, they
+// return the number of characters that would be in the fully-formatted string
+// (vsnprintf, and vswprintf on Windows), or -1 (vswprintf on POSIX platforms).
+inline int vsnprintfT(char* buffer,
+size_t buf_size,
+const char* format,
+va_list argptr) {
+return base::vsnprintf(buffer, buf_size, format, argptr);
+}
+#if !defined(OS_ANDROID)
+inline int vsnprintfT(wchar_t* buffer,
+size_t buf_size,
+const wchar_t* format,
+va_list argptr) {
+return base::vswprintf(buffer, buf_size, format, argptr);
+}
+#endif
+// Templatized backend for StringPrintF/StringAppendF. This does not finalize
+// the va_list, the caller is expected to do that.
+template <class StringType>
+static void StringAppendVT(StringType* dst,
+const typename StringType::value_type* format,
+va_list ap) {
+// First try with a small fixed size buffer.
+// This buffer size should be kept in sync with StringUtilTest.GrowBoundary
+// and StringUtilTest.StringPrintfBounds.
+typename StringType::value_type stack_buf[1024];
+va_list ap_copy;
+GG_VA_COPY(ap_copy, ap);
+#if !defined(OS_WIN)
+ScopedClearErrno clear_errno;
+#endif
+int result = vsnprintfT(stack_buf, arraysize(stack_buf), format, ap_copy);
+va_end(ap_copy);
+if (result >= 0 && result < static_cast<int>(arraysize(stack_buf))) {
+// It fit.
+dst->append(stack_buf, result);
+return;
+}
+// Repeatedly increase buffer size until it fits.
+int mem_length = arraysize(stack_buf);
+while (true) {
+if (result < 0) {
+#if !defined(OS_WIN)
+// On Windows, vsnprintfT always returns the number of characters in a
+// fully-formatted string, so if we reach this point, something else is
+// wrong and no amount of buffer-doubling is going to fix it.
+if (errno != 0 && errno != EOVERFLOW)
+#endif
+{
+// If an error other than overflow occurred, it's never going to work.
+DLOG(WARNING) << "Unable to printf the requested string due to error.";
+return;
+}
+// Try doubling the buffer size.
+mem_length *= 2;
+} else {
+// We need exactly "result + 1" characters.
+mem_length = result + 1;
+}
+if (mem_length > 32 * 1024 * 1024) {
+// That should be plenty, don't try anything larger.  This protects
+// against huge allocations when using vsnprintfT implementations that
+// return -1 for reasons other than overflow without setting errno.
+DLOG(WARNING) << "Unable to printf the requested string due to size.";
+return;
+}
+std::vector<typename StringType::value_type> mem_buf(mem_length);
+// NOTE: You can only use a va_list once.  Since we're in a while loop, we
+// need to make a new copy each time so we don't use up the original.
+GG_VA_COPY(ap_copy, ap);
+result = vsnprintfT(&mem_buf[0], mem_length, format, ap_copy);
+va_end(ap_copy);
+if ((result >= 0) && (result < mem_length)) {
+// It fit.
+dst->append(&mem_buf[0], result);
+return;
+}
+}
+}
+}  // namespace
+std::string StringPrintf(const char* format, ...) {
+va_list ap;
+va_start(ap, format);
+std::string result;
+StringAppendV(&result, format, ap);
+va_end(ap);
+return result;
+}
+#if !defined(OS_ANDROID)
+std::wstring StringPrintf(const wchar_t* format, ...) {
+va_list ap;
+va_start(ap, format);
+std::wstring result;
+StringAppendV(&result, format, ap);
+va_end(ap);
+return result;
+}
+#endif
+std::string StringPrintV(const char* format, va_list ap) {
+std::string result;
+StringAppendV(&result, format, ap);
+return result;
+}
+const std::string& SStringPrintf(std::string* dst, const char* format, ...) {
+va_list ap;
+va_start(ap, format);
+dst->clear();
+StringAppendV(dst, format, ap);
+va_end(ap);
+return *dst;
+}
+#if !defined(OS_ANDROID)
+const std::wstring& SStringPrintf(std::wstring* dst,
+const wchar_t* format, ...) {
+va_list ap;
+va_start(ap, format);
+dst->clear();
+StringAppendV(dst, format, ap);
+va_end(ap);
+return *dst;
+}
+#endif
+void StringAppendF(std::string* dst, const char* format, ...) {
+va_list ap;
+va_start(ap, format);
+StringAppendV(dst, format, ap);
+va_end(ap);
+}
+#if !defined(OS_ANDROID)
+void StringAppendF(std::wstring* dst, const wchar_t* format, ...) {
+va_list ap;
+va_start(ap, format);
+StringAppendV(dst, format, ap);
+va_end(ap);
+}
+#endif
+void StringAppendV(std::string* dst, const char* format, va_list ap) {
+StringAppendVT(dst, format, ap);
+}
+#if !defined(OS_ANDROID)
+void StringAppendV(std::wstring* dst, const wchar_t* format, va_list ap) {
+StringAppendVT(dst, format, ap);
+}
+#endif
+}  // namespace base

The Tor Browser / file comparison

comparison: security/sandbox/chromium/base/strings/stringprintf.cc

security/sandbox/chromium/base/strings/stringprintf.cc