1 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "base/stringprintf.h"
6
7 #include <errno.h>
8
9 #include "base/string_util.h"
10 #include "base/utf_string_conversions.h"
11
12 namespace base {
13
14 namespace {
15
16 // Overloaded wrappers around vsnprintf and vswprintf. The buf_size parameter
17 // is the size of the buffer. These return the number of characters in the
18 // formatted string excluding the NUL terminator. If the buffer is not
19 // large enough to accommodate the formatted string without truncation, they
20 // return the number of characters that would be in the fully-formatted string
21 // (vsnprintf, and vswprintf on Windows), or -1 (vswprintf on POSIX platforms).
vsnprintfT(char * buffer,size_t buf_size,const char * format,va_list argptr)22 inline int vsnprintfT(char* buffer,
23 size_t buf_size,
24 const char* format,
25 va_list argptr) {
26 return base::vsnprintf(buffer, buf_size, format, argptr);
27 }
28
vsnprintfT(wchar_t * buffer,size_t buf_size,const wchar_t * format,va_list argptr)29 inline int vsnprintfT(wchar_t* buffer,
30 size_t buf_size,
31 const wchar_t* format,
32 va_list argptr) {
33 return base::vswprintf(buffer, buf_size, format, argptr);
34 }
35
36 // Templatized backend for StringPrintF/StringAppendF. This does not finalize
37 // the va_list, the caller is expected to do that.
38 template <class StringType>
StringAppendVT(StringType * dst,const typename StringType::value_type * format,va_list ap)39 static void StringAppendVT(StringType* dst,
40 const typename StringType::value_type* format,
41 va_list ap) {
42 // First try with a small fixed size buffer.
43 // This buffer size should be kept in sync with StringUtilTest.GrowBoundary
44 // and StringUtilTest.StringPrintfBounds.
45 typename StringType::value_type stack_buf[1024];
46
47 va_list ap_copy;
48 GG_VA_COPY(ap_copy, ap);
49
50 #if !defined(OS_WIN)
51 errno = 0;
52 #endif
53 int result = vsnprintfT(stack_buf, arraysize(stack_buf), format, ap_copy);
54 va_end(ap_copy);
55
56 if (result >= 0 && result < static_cast<int>(arraysize(stack_buf))) {
57 // It fit.
58 dst->append(stack_buf, result);
59 return;
60 }
61
62 // Repeatedly increase buffer size until it fits.
63 int mem_length = arraysize(stack_buf);
64 while (true) {
65 if (result < 0) {
66 #if !defined(OS_WIN)
67 // On Windows, vsnprintfT always returns the number of characters in a
68 // fully-formatted string, so if we reach this point, something else is
69 // wrong and no amount of buffer-doubling is going to fix it.
70 if (errno != 0 && errno != EOVERFLOW)
71 #endif
72 {
73 // If an error other than overflow occurred, it's never going to work.
74 DLOG(WARNING) << "Unable to printf the requested string due to error.";
75 return;
76 }
77 // Try doubling the buffer size.
78 mem_length *= 2;
79 } else {
80 // We need exactly "result + 1" characters.
81 mem_length = result + 1;
82 }
83
84 if (mem_length > 32 * 1024 * 1024) {
85 // That should be plenty, don't try anything larger. This protects
86 // against huge allocations when using vsnprintfT implementations that
87 // return -1 for reasons other than overflow without setting errno.
88 DLOG(WARNING) << "Unable to printf the requested string due to size.";
89 return;
90 }
91
92 std::vector<typename StringType::value_type> mem_buf(mem_length);
93
94 // NOTE: You can only use a va_list once. Since we're in a while loop, we
95 // need to make a new copy each time so we don't use up the original.
96 GG_VA_COPY(ap_copy, ap);
97 result = vsnprintfT(&mem_buf[0], mem_length, format, ap_copy);
98 va_end(ap_copy);
99
100 if ((result >= 0) && (result < mem_length)) {
101 // It fit.
102 dst->append(&mem_buf[0], result);
103 return;
104 }
105 }
106 }
107
108 } // namespace
109
StringPrintf(const char * format,...)110 std::string StringPrintf(const char* format, ...) {
111 va_list ap;
112 va_start(ap, format);
113 std::string result;
114 StringAppendV(&result, format, ap);
115 va_end(ap);
116 return result;
117 }
118
StringPrintf(const wchar_t * format,...)119 std::wstring StringPrintf(const wchar_t* format, ...) {
120 va_list ap;
121 va_start(ap, format);
122 std::wstring result;
123 StringAppendV(&result, format, ap);
124 va_end(ap);
125 return result;
126 }
127
StringPrintV(const char * format,va_list ap)128 std::string StringPrintV(const char* format, va_list ap) {
129 std::string result;
130 StringAppendV(&result, format, ap);
131 return result;
132 }
133
SStringPrintf(std::string * dst,const char * format,...)134 const std::string& SStringPrintf(std::string* dst, const char* format, ...) {
135 va_list ap;
136 va_start(ap, format);
137 dst->clear();
138 StringAppendV(dst, format, ap);
139 va_end(ap);
140 return *dst;
141 }
142
SStringPrintf(std::wstring * dst,const wchar_t * format,...)143 const std::wstring& SStringPrintf(std::wstring* dst,
144 const wchar_t* format, ...) {
145 va_list ap;
146 va_start(ap, format);
147 dst->clear();
148 StringAppendV(dst, format, ap);
149 va_end(ap);
150 return *dst;
151 }
152
StringAppendF(std::string * dst,const char * format,...)153 void StringAppendF(std::string* dst, const char* format, ...) {
154 va_list ap;
155 va_start(ap, format);
156 StringAppendV(dst, format, ap);
157 va_end(ap);
158 }
159
StringAppendF(std::wstring * dst,const wchar_t * format,...)160 void StringAppendF(std::wstring* dst, const wchar_t* format, ...) {
161 va_list ap;
162 va_start(ap, format);
163 StringAppendV(dst, format, ap);
164 va_end(ap);
165 }
166
StringAppendV(std::string * dst,const char * format,va_list ap)167 void StringAppendV(std::string* dst, const char* format, va_list ap) {
168 StringAppendVT(dst, format, ap);
169 }
170
StringAppendV(std::wstring * dst,const wchar_t * format,va_list ap)171 void StringAppendV(std::wstring* dst, const wchar_t* format, va_list ap) {
172 StringAppendVT(dst, format, ap);
173 }
174
175 } // namespace base
176