Directory: | cvmfs/ |
---|---|
File: | cvmfs/util/string.cc |
Date: | 2025-10-19 02:35:28 |
Exec | Total | Coverage | |
---|---|---|---|
Lines: | 319 | 332 | 96.1% |
Branches: | 273 | 392 | 69.6% |
Line | Branch | Exec | Source |
---|---|---|---|
1 | /** | ||
2 | * This file is part of the CernVM File System. | ||
3 | * | ||
4 | * Some common functions. | ||
5 | */ | ||
6 | |||
7 | #ifndef __STDC_FORMAT_MACROS | ||
8 | // NOLINTNEXTLINE | ||
9 | #define __STDC_FORMAT_MACROS | ||
10 | #endif | ||
11 | |||
12 | #include "string.h" | ||
13 | |||
14 | #include <cctype> | ||
15 | #include <cstdio> | ||
16 | #include <cstdlib> | ||
17 | #include <cstring> | ||
18 | #include <ctime> | ||
19 | #include <algorithm> | ||
20 | #include <vector> | ||
21 | #include <map> | ||
22 | #include <stdio.h> | ||
23 | #include <errno.h> | ||
24 | #include <fcntl.h> | ||
25 | #include <inttypes.h> | ||
26 | #include <stdint.h> | ||
27 | #include <time.h> | ||
28 | #include <string> | ||
29 | #include <unistd.h> | ||
30 | |||
31 | |||
32 | using namespace std; // NOLINT | ||
33 | |||
34 | #ifdef CVMFS_NAMESPACE_GUARD | ||
35 | namespace CVMFS_NAMESPACE_GUARD { | ||
36 | #endif | ||
37 | |||
38 | const char b64_table[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', | ||
39 | 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', | ||
40 | 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', | ||
41 | 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', | ||
42 | 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', | ||
43 | '3', '4', '5', '6', '7', '8', '9', '+', '/'}; | ||
44 | |||
45 | /** | ||
46 | * Decode Base64 and Base64Url | ||
47 | */ | ||
48 | const int8_t db64_table[] = { | ||
49 | -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, | ||
50 | -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, | ||
51 | -1, -1, -1, -1, -1, 62, -1, 62, -1, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, | ||
52 | 61, -1, -1, -1, 0, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, | ||
53 | 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, | ||
54 | 63, -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, | ||
55 | 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1, | ||
56 | |||
57 | -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, | ||
58 | -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, | ||
59 | -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, | ||
60 | -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, | ||
61 | -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, | ||
62 | -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, | ||
63 | -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, | ||
64 | }; | ||
65 | |||
66 | namespace { | ||
67 | |||
68 | /** | ||
69 | * Used for cas insensitive HasSuffix | ||
70 | */ | ||
71 | struct IgnoreCaseComperator { | ||
72 | 23121 | IgnoreCaseComperator() { } | |
73 | 360 | bool operator()(const std::string::value_type a, | |
74 | const std::string::value_type b) const { | ||
75 | 360 | return std::tolower(a) == std::tolower(b); | |
76 | } | ||
77 | }; | ||
78 | |||
79 | } // anonymous namespace | ||
80 | |||
81 |
3/4✓ Branch 1 taken 72 times.
✓ Branch 2 taken 3524 times.
✓ Branch 4 taken 3596 times.
✗ Branch 5 not taken.
|
3596 | string StringifyBool(const bool value) { return value ? "yes" : "no"; } |
82 | |||
83 | 34034361 | string StringifyInt(const int64_t value) { | |
84 | char buffer[48]; | ||
85 | 34034361 | snprintf(buffer, sizeof(buffer), "%" PRId64, value); | |
86 |
1/2✓ Branch 2 taken 34028998 times.
✗ Branch 3 not taken.
|
34034361 | return string(buffer); |
87 | } | ||
88 | |||
89 | 14664808 | std::string StringifyUint(const uint64_t value) { | |
90 | char buffer[48]; | ||
91 | 14664808 | snprintf(buffer, sizeof(buffer), "%" PRIu64, value); | |
92 |
1/2✓ Branch 2 taken 14664808 times.
✗ Branch 3 not taken.
|
14664808 | return string(buffer); |
93 | } | ||
94 | |||
95 | 16 | string StringifyByteAsHex(const unsigned char value) { | |
96 | char buffer[3]; | ||
97 | 16 | snprintf(buffer, sizeof(buffer), "%02x", value); | |
98 |
1/2✓ Branch 2 taken 16 times.
✗ Branch 3 not taken.
|
16 | return string(buffer); |
99 | } | ||
100 | |||
101 | 220 | string StringifyDouble(const double value) { | |
102 | char buffer[64]; | ||
103 | 220 | snprintf(buffer, sizeof(buffer), "%.03f", value); | |
104 |
1/2✓ Branch 2 taken 220 times.
✗ Branch 3 not taken.
|
220 | return string(buffer); |
105 | } | ||
106 | |||
107 | /** | ||
108 | * Converts seconds since UTC 0 into something readable | ||
109 | */ | ||
110 | 2347 | string StringifyTime(const time_t seconds, const bool utc) { | |
111 | struct tm timestamp; | ||
112 |
2/2✓ Branch 0 taken 1284 times.
✓ Branch 1 taken 1063 times.
|
2347 | if (utc) { |
113 | 1284 | localtime_r(&seconds, ×tamp); | |
114 | } else { | ||
115 | 1063 | gmtime_r(&seconds, ×tamp); | |
116 | } | ||
117 | |||
118 | 2347 | const char *months[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", | |
119 | "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"}; | ||
120 | char buffer[21]; | ||
121 | 2347 | snprintf(buffer, sizeof(buffer), "%d %s %d %02d:%02d:%02d", timestamp.tm_mday, | |
122 | 2347 | months[timestamp.tm_mon], timestamp.tm_year + 1900, | |
123 | timestamp.tm_hour, timestamp.tm_min, timestamp.tm_sec); | ||
124 | |||
125 |
1/2✓ Branch 2 taken 2347 times.
✗ Branch 3 not taken.
|
2347 | return string(buffer); |
126 | } | ||
127 | |||
128 | /** | ||
129 | * Converts seconds since UTC 0 into something like 12 Sep 14:59:37 CDT | ||
130 | */ | ||
131 | 778 | string StringifyLocalTime(const time_t seconds) { | |
132 | struct tm timestamp; | ||
133 | 778 | localtime_r(&seconds, ×tamp); | |
134 | |||
135 | 778 | const char *months[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", | |
136 | "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"}; | ||
137 | char buffer[26]; | ||
138 | (void)/* cast to void ignores return and placates clang-tidy */ | ||
139 | 778 | snprintf(buffer, sizeof(buffer), "%d %s %d %02d:%02d:%02d %s", | |
140 | 778 | timestamp.tm_mday, months[timestamp.tm_mon], | |
141 | 778 | timestamp.tm_year + 1900, timestamp.tm_hour, timestamp.tm_min, | |
142 | timestamp.tm_sec, timestamp.tm_zone); | ||
143 | |||
144 |
1/2✓ Branch 2 taken 778 times.
✗ Branch 3 not taken.
|
778 | return string(buffer); |
145 | } | ||
146 | |||
147 | |||
148 | /** | ||
149 | * Current time in format Wed, 01 Mar 2006 12:00:00 GMT | ||
150 | */ | ||
151 | 41591 | std::string RfcTimestamp() { | |
152 | 41591 | const char *months[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", | |
153 | "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"}; | ||
154 | 41591 | const char *day_of_week[] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"}; | |
155 | |||
156 | struct tm timestamp; | ||
157 | 41591 | const time_t now = time(NULL); | |
158 | 41591 | gmtime_r(&now, ×tamp); | |
159 | |||
160 | char buffer[30]; | ||
161 | 41591 | snprintf(buffer, sizeof(buffer), "%s, %02d %s %d %02d:%02d:%02d %s", | |
162 | 41591 | day_of_week[timestamp.tm_wday], timestamp.tm_mday, | |
163 | 41591 | months[timestamp.tm_mon], timestamp.tm_year + 1900, | |
164 | timestamp.tm_hour, timestamp.tm_min, timestamp.tm_sec, | ||
165 | timestamp.tm_zone); | ||
166 |
1/2✓ Branch 2 taken 41591 times.
✗ Branch 3 not taken.
|
41591 | return string(buffer); |
167 | } | ||
168 | |||
169 | |||
170 | /** | ||
171 | * Current time in format YYYYMMDDTHHMMSSZ. Used in AWS4 requests. | ||
172 | */ | ||
173 | 21 | std::string IsoTimestamp() { | |
174 | struct tm timestamp; | ||
175 | 21 | const time_t now = time(NULL); | |
176 | 21 | gmtime_r(&now, ×tamp); | |
177 | |||
178 | char buffer[17]; | ||
179 | 21 | snprintf(buffer, sizeof(buffer), "%04d%02d%02dT%02d%02d%02dZ", | |
180 | 21 | timestamp.tm_year + 1900, timestamp.tm_mon + 1, timestamp.tm_mday, | |
181 | timestamp.tm_hour, timestamp.tm_min, timestamp.tm_sec); | ||
182 |
1/2✓ Branch 2 taken 21 times.
✗ Branch 3 not taken.
|
21 | return string(buffer); |
183 | } | ||
184 | |||
185 | |||
186 | /** | ||
187 | * UTC time in format YYYYMMDDHHMMSS. Used in cvmfs whitelists. | ||
188 | */ | ||
189 | 198 | std::string WhitelistTimestamp(time_t when) { | |
190 | struct tm timestamp; | ||
191 | 198 | gmtime_r(&when, ×tamp); | |
192 | |||
193 | char buffer[15]; | ||
194 | 198 | snprintf(buffer, sizeof(buffer), "%04d%02d%02d%02d%02d%02d", | |
195 | 198 | timestamp.tm_year + 1900, timestamp.tm_mon + 1, timestamp.tm_mday, | |
196 | timestamp.tm_hour, timestamp.tm_min, timestamp.tm_sec); | ||
197 |
1/2✓ Branch 2 taken 198 times.
✗ Branch 3 not taken.
|
198 | return string(buffer); |
198 | } | ||
199 | |||
200 | |||
201 | 11551553 | string StringifyTimeval(const timeval value) { | |
202 | char buffer[64]; | ||
203 | 11551553 | int64_t msec = value.tv_sec * 1000; | |
204 | 11551553 | msec += value.tv_usec / 1000; | |
205 | 11551553 | snprintf(buffer, sizeof(buffer), "%" PRId64 ".%03d", msec, | |
206 | 11551553 | static_cast<int>(value.tv_usec % 1000)); | |
207 |
1/2✓ Branch 2 taken 11551553 times.
✗ Branch 3 not taken.
|
11551553 | return string(buffer); |
208 | } | ||
209 | |||
210 | /** | ||
211 | * Parses a timestamp of the form YYYY-MM-DDTHH:MM:SSZ | ||
212 | * Return 0 on error | ||
213 | */ | ||
214 | 3947 | time_t IsoTimestamp2UtcTime(const std::string &iso8601) { | |
215 | 3947 | time_t utc_time = 0; | |
216 | 3947 | const unsigned length = iso8601.length(); | |
217 | |||
218 |
2/2✓ Branch 0 taken 8 times.
✓ Branch 1 taken 3939 times.
|
3947 | if (length != 20) |
219 | 8 | return utc_time; | |
220 |
2/4✓ Branch 2 taken 3939 times.
✗ Branch 3 not taken.
✓ Branch 5 taken 3939 times.
✗ Branch 6 not taken.
|
7878 | if ((iso8601[4] != '-') || (iso8601[7] != '-') || (iso8601[10] != 'T') |
221 |
5/10✓ Branch 0 taken 3939 times.
✗ Branch 1 not taken.
✓ Branch 3 taken 3939 times.
✗ Branch 4 not taken.
✓ Branch 6 taken 3939 times.
✗ Branch 7 not taken.
✗ Branch 9 not taken.
✓ Branch 10 taken 3939 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 3939 times.
|
7878 | || (iso8601[13] != ':') || (iso8601[16] != ':') || (iso8601[19] != 'Z')) { |
222 | ✗ | return utc_time; | |
223 | } | ||
224 | |||
225 | struct tm tm_wl; | ||
226 | 3939 | memset(&tm_wl, 0, sizeof(struct tm)); | |
227 |
2/4✓ Branch 1 taken 3939 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 3939 times.
✗ Branch 5 not taken.
|
3939 | tm_wl.tm_year = static_cast<int>(String2Int64(iso8601.substr(0, 4))) - 1900; |
228 |
2/4✓ Branch 1 taken 3939 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 3939 times.
✗ Branch 5 not taken.
|
3939 | tm_wl.tm_mon = static_cast<int>(String2Int64(iso8601.substr(5, 2))) - 1; |
229 |
2/4✓ Branch 1 taken 3939 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 3939 times.
✗ Branch 5 not taken.
|
3939 | tm_wl.tm_mday = static_cast<int>(String2Int64(iso8601.substr(8, 2))); |
230 |
2/4✓ Branch 1 taken 3939 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 3939 times.
✗ Branch 5 not taken.
|
3939 | tm_wl.tm_hour = static_cast<int>(String2Int64(iso8601.substr(11, 2))); |
231 |
2/4✓ Branch 1 taken 3939 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 3939 times.
✗ Branch 5 not taken.
|
3939 | tm_wl.tm_min = static_cast<int>(String2Int64(iso8601.substr(14, 2))); |
232 |
2/4✓ Branch 1 taken 3939 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 3939 times.
✗ Branch 5 not taken.
|
3939 | tm_wl.tm_sec = static_cast<int>(String2Int64(iso8601.substr(17, 2))); |
233 | 3939 | utc_time = timegm(&tm_wl); | |
234 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 3935 times.
|
3939 | if (utc_time < 0) |
235 | 4 | return 0; | |
236 | |||
237 | 3935 | return utc_time; | |
238 | } | ||
239 | |||
240 | 49053 | int64_t String2Int64(const string &value) { | |
241 | int64_t result; | ||
242 | 49053 | sscanf(value.c_str(), "%" PRId64, &result); | |
243 | 49053 | return result; | |
244 | } | ||
245 | |||
246 | 393679 | uint64_t String2Uint64(const string &value) { | |
247 | uint64_t result; | ||
248 |
2/2✓ Branch 1 taken 393547 times.
✓ Branch 2 taken 132 times.
|
393679 | if (sscanf(value.c_str(), "%" PRIu64, &result) == 1) { |
249 | 393547 | return result; | |
250 | } | ||
251 | 132 | return 0; | |
252 | } | ||
253 | |||
254 | /** | ||
255 | * Parse a string into a a uint64_t. | ||
256 | * | ||
257 | * Unlike String2Uint64, this: | ||
258 | * - Checks to make sure the full string is parsed | ||
259 | * - Can indicate an error occurred. | ||
260 | * | ||
261 | * If an error occurs, this returns false and sets errno appropriately. | ||
262 | */ | ||
263 | 1298 | bool String2Uint64Parse(const std::string &value, uint64_t *result) { | |
264 | 1298 | char *endptr = NULL; | |
265 | 1298 | errno = 0; | |
266 | 1298 | long long myval = strtoll(value.c_str(), &endptr, 10); // NOLINT | |
267 |
2/2✓ Branch 3 taken 657 times.
✓ Branch 4 taken 457 times.
|
2412 | if ((value.size() == 0) || (endptr != (value.c_str() + value.size())) |
268 |
6/6✓ Branch 0 taken 1114 times.
✓ Branch 1 taken 184 times.
✓ Branch 2 taken 12 times.
✓ Branch 3 taken 645 times.
✓ Branch 4 taken 653 times.
✓ Branch 5 taken 645 times.
|
2412 | || (myval < 0)) { |
269 | 653 | errno = EINVAL; | |
270 | 653 | return false; | |
271 | } | ||
272 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 645 times.
|
645 | if (errno) { |
273 | ✗ | return false; | |
274 | } | ||
275 |
2/2✓ Branch 0 taken 633 times.
✓ Branch 1 taken 12 times.
|
645 | if (result) { |
276 | 633 | *result = myval; | |
277 | } | ||
278 | 645 | return true; | |
279 | } | ||
280 | |||
281 | 16 | void String2Uint64Pair(const string &value, uint64_t *a, uint64_t *b) { | |
282 | 16 | sscanf(value.c_str(), "%" PRIu64 " %" PRIu64, a, b); | |
283 | 16 | } | |
284 | |||
285 | 272793 | bool HasPrefix(const string &str, const string &prefix, | |
286 | const bool ignore_case) { | ||
287 |
2/2✓ Branch 2 taken 53801 times.
✓ Branch 3 taken 218992 times.
|
272793 | if (prefix.length() > str.length()) |
288 | 53801 | return false; | |
289 | |||
290 |
2/2✓ Branch 1 taken 805895 times.
✓ Branch 2 taken 70511 times.
|
876406 | for (unsigned i = 0, l = prefix.length(); i < l; ++i) { |
291 |
2/2✓ Branch 0 taken 136198 times.
✓ Branch 1 taken 669697 times.
|
805895 | if (ignore_case) { |
292 |
2/2✓ Branch 2 taken 73559 times.
✓ Branch 3 taken 62639 times.
|
136198 | if (toupper(str[i]) != toupper(prefix[i])) |
293 | 73559 | return false; | |
294 | } else { | ||
295 |
2/2✓ Branch 2 taken 74922 times.
✓ Branch 3 taken 594775 times.
|
669697 | if (str[i] != prefix[i]) |
296 | 74922 | return false; | |
297 | } | ||
298 | } | ||
299 | 70511 | return true; | |
300 | } | ||
301 | |||
302 | 23323 | bool HasSuffix(const std::string &str, const std::string &suffix, | |
303 | const bool ignore_case) { | ||
304 |
2/2✓ Branch 2 taken 202 times.
✓ Branch 3 taken 23121 times.
|
23323 | if (suffix.size() > str.size()) |
305 | 202 | return false; | |
306 | 23121 | const IgnoreCaseComperator icmp; | |
307 | return (ignore_case) | ||
308 |
3/4✓ Branch 0 taken 283 times.
✓ Branch 1 taken 22838 times.
✓ Branch 6 taken 283 times.
✗ Branch 7 not taken.
|
23121 | ? std::equal(suffix.rbegin(), suffix.rend(), str.rbegin(), icmp) |
309 |
1/2✓ Branch 4 taken 22838 times.
✗ Branch 5 not taken.
|
23121 | : std::equal(suffix.rbegin(), suffix.rend(), str.rbegin()); |
310 | } | ||
311 | |||
312 | 55180 | vector<string> SplitString(const string &str, char delim) { | |
313 | 55180 | return SplitStringBounded(0, str, delim); | |
314 | } | ||
315 | |||
316 | 55306 | vector<string> SplitStringBounded(unsigned max_chunks, const string &str, | |
317 | char delim) { | ||
318 | 55306 | vector<string> result; | |
319 | |||
320 | // edge case... one chunk is always the whole string | ||
321 |
2/2✓ Branch 0 taken 21 times.
✓ Branch 1 taken 55285 times.
|
55306 | if (1 == max_chunks) { |
322 |
1/2✓ Branch 1 taken 21 times.
✗ Branch 2 not taken.
|
21 | result.push_back(str); |
323 | 21 | return result; | |
324 | } | ||
325 | |||
326 | // split the string | ||
327 | 55285 | const unsigned size = str.size(); | |
328 | 55285 | unsigned marker = 0; | |
329 | 55285 | unsigned chunks = 1; | |
330 | unsigned i; | ||
331 |
2/2✓ Branch 0 taken 1315316 times.
✓ Branch 1 taken 55243 times.
|
1370559 | for (i = 0; i < size; ++i) { |
332 |
2/2✓ Branch 1 taken 73222 times.
✓ Branch 2 taken 1242094 times.
|
1315316 | if (str[i] == delim) { |
333 |
2/4✓ Branch 1 taken 73222 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 73222 times.
✗ Branch 5 not taken.
|
73222 | result.push_back(str.substr(marker, i - marker)); |
334 | 73222 | marker = i + 1; | |
335 | |||
336 | // we got what we want... good bye | ||
337 |
2/2✓ Branch 0 taken 42 times.
✓ Branch 1 taken 73180 times.
|
73222 | if (++chunks == max_chunks) |
338 | 42 | break; | |
339 | } | ||
340 | } | ||
341 | |||
342 | // push the remainings of the string and return | ||
343 |
2/4✓ Branch 1 taken 55285 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 55285 times.
✗ Branch 5 not taken.
|
55285 | result.push_back(str.substr(marker)); |
344 | 55285 | return result; | |
345 | } | ||
346 | |||
347 | 12 | vector<string> SplitStringMultiChar(const string &str, const string &delim) { | |
348 | 12 | size_t pos_start = 0, pos_end = 0, delim_len = delim.length(); | |
349 | 12 | std::string substring; | |
350 | 12 | std::vector<std::string> result; | |
351 | |||
352 |
2/2✓ Branch 1 taken 44 times.
✓ Branch 2 taken 12 times.
|
56 | while ((pos_end = str.find(delim, pos_start)) != string::npos) { |
353 |
1/2✓ Branch 1 taken 44 times.
✗ Branch 2 not taken.
|
44 | substring = str.substr(pos_start, pos_end - pos_start); |
354 | 44 | pos_start = pos_end + delim_len; | |
355 |
1/2✓ Branch 1 taken 44 times.
✗ Branch 2 not taken.
|
44 | result.push_back(substring); |
356 | } | ||
357 | |||
358 |
2/4✓ Branch 1 taken 12 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 12 times.
✗ Branch 5 not taken.
|
12 | result.push_back(str.substr(pos_start)); |
359 | 24 | return result; | |
360 | 12 | } | |
361 | |||
362 | 11775 | string JoinStrings(const vector<string> &strings, const string &joint) { | |
363 |
1/2✓ Branch 2 taken 11775 times.
✗ Branch 3 not taken.
|
11775 | string result = ""; |
364 | 11775 | const unsigned size = strings.size(); | |
365 | |||
366 |
2/2✓ Branch 0 taken 8643 times.
✓ Branch 1 taken 3132 times.
|
11775 | if (size > 0) { |
367 |
1/2✓ Branch 2 taken 8643 times.
✗ Branch 3 not taken.
|
8643 | result = strings[0]; |
368 |
2/2✓ Branch 0 taken 929 times.
✓ Branch 1 taken 8643 times.
|
9572 | for (unsigned i = 1; i < size; ++i) |
369 |
2/4✓ Branch 2 taken 929 times.
✗ Branch 3 not taken.
✓ Branch 5 taken 929 times.
✗ Branch 6 not taken.
|
929 | result += joint + strings[i]; |
370 | } | ||
371 | |||
372 | 11775 | return result; | |
373 | } | ||
374 | |||
375 | 4416 | void ParseKeyvalMem(const unsigned char *buffer, const unsigned buffer_size, | |
376 | map<char, string> *content) { | ||
377 | 4416 | string line; | |
378 | 4416 | unsigned pos = 0; | |
379 |
2/2✓ Branch 0 taken 331303 times.
✓ Branch 1 taken 62 times.
|
331365 | while (pos < buffer_size) { |
380 |
2/2✓ Branch 0 taken 27409 times.
✓ Branch 1 taken 303894 times.
|
331303 | if (static_cast<char>(buffer[pos]) == '\n') { |
381 |
2/2✓ Branch 1 taken 4354 times.
✓ Branch 2 taken 23055 times.
|
27409 | if (line == "--") |
382 | 4354 | return; | |
383 | |||
384 |
1/2✓ Branch 1 taken 23055 times.
✗ Branch 2 not taken.
|
23055 | if (line != "") { |
385 |
3/11✗ Branch 1 not taken.
✓ Branch 2 taken 23055 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✓ Branch 8 taken 23055 times.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✓ Branch 11 taken 23055 times.
✗ Branch 12 not taken.
✗ Branch 13 not taken.
|
23055 | const string tail = (line.length() == 1) ? "" : line.substr(1); |
386 | // Special handling of 'Z' key because it can exist multiple times | ||
387 |
3/4✓ Branch 1 taken 23055 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 23009 times.
✓ Branch 4 taken 46 times.
|
23055 | if (line[0] != 'Z') { |
388 |
3/6✓ Branch 1 taken 23009 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 23009 times.
✗ Branch 5 not taken.
✓ Branch 7 taken 23009 times.
✗ Branch 8 not taken.
|
23009 | (*content)[line[0]] = tail; |
389 | } else { | ||
390 |
4/7✓ Branch 2 taken 46 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 46 times.
✗ Branch 6 not taken.
✓ Branch 8 taken 23 times.
✓ Branch 9 taken 23 times.
|
46 | if (content->find(line[0]) == content->end()) { |
391 |
3/6✓ Branch 1 taken 23 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 23 times.
✗ Branch 5 not taken.
✓ Branch 7 taken 23 times.
✗ Branch 8 not taken.
|
23 | (*content)[line[0]] = tail; |
392 | } else { | ||
393 |
6/12✓ Branch 1 taken 23 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 23 times.
✗ Branch 5 not taken.
✓ Branch 7 taken 23 times.
✗ Branch 8 not taken.
✓ Branch 10 taken 23 times.
✗ Branch 11 not taken.
✓ Branch 13 taken 23 times.
✗ Branch 14 not taken.
✓ Branch 16 taken 23 times.
✗ Branch 17 not taken.
|
23 | (*content)[line[0]] = (*content)[line[0]] + "|" + tail; |
394 | } | ||
395 | } | ||
396 | 23055 | } | |
397 |
1/2✓ Branch 1 taken 23055 times.
✗ Branch 2 not taken.
|
23055 | line = ""; |
398 | } else { | ||
399 |
1/2✓ Branch 1 taken 303894 times.
✗ Branch 2 not taken.
|
303894 | line += static_cast<char>(buffer[pos]); |
400 | } | ||
401 | 326949 | pos++; | |
402 | } | ||
403 |
2/2✓ Branch 1 taken 62 times.
✓ Branch 2 taken 4354 times.
|
4416 | } |
404 | |||
405 | 399 | bool ParseKeyvalPath(const string &filename, map<char, string> *content) { | |
406 |
1/2✓ Branch 2 taken 399 times.
✗ Branch 3 not taken.
|
399 | const int fd = open(filename.c_str(), O_RDONLY); |
407 |
2/2✓ Branch 0 taken 19 times.
✓ Branch 1 taken 380 times.
|
399 | if (fd < 0) |
408 | 19 | return false; | |
409 | |||
410 | unsigned char buffer[4096]; | ||
411 |
1/2✓ Branch 1 taken 380 times.
✗ Branch 2 not taken.
|
380 | const ssize_t num_bytes = read(fd, buffer, sizeof(buffer)); |
412 |
1/2✓ Branch 1 taken 380 times.
✗ Branch 2 not taken.
|
380 | close(fd); |
413 | |||
414 |
3/4✓ Branch 0 taken 361 times.
✓ Branch 1 taken 19 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 361 times.
|
380 | if ((num_bytes <= 0) || (unsigned(num_bytes) >= sizeof(buffer))) |
415 | 19 | return false; | |
416 | |||
417 |
1/2✓ Branch 1 taken 361 times.
✗ Branch 2 not taken.
|
361 | ParseKeyvalMem(buffer, unsigned(num_bytes), content); |
418 | 361 | return true; | |
419 | } | ||
420 | |||
421 | 302906 | string GetLineMem(const char *text, const int text_size) { | |
422 | 302906 | int pos = 0; | |
423 |
4/4✓ Branch 0 taken 12752397 times.
✓ Branch 1 taken 675 times.
✓ Branch 2 taken 12450166 times.
✓ Branch 3 taken 302231 times.
|
12753072 | while ((pos < text_size) && (text[pos] != '\n')) |
424 | 12450166 | pos++; | |
425 |
1/2✓ Branch 2 taken 302906 times.
✗ Branch 3 not taken.
|
302906 | return string(text, pos); |
426 | } | ||
427 | |||
428 | 11584456 | bool GetLineFile(FILE *f, std::string *line) { | |
429 | int retval; | ||
430 | 11584456 | line->clear(); | |
431 | while (true) { | ||
432 | 825865876 | retval = fgetc(f); | |
433 |
2/6✗ Branch 1 not taken.
✓ Branch 2 taken 825865876 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✓ Branch 6 taken 825865876 times.
|
825865876 | if (ferror(f) && (errno == EINTR)) { |
434 | ✗ | clearerr(f); | |
435 | ✗ | continue; | |
436 |
2/2✓ Branch 0 taken 5615 times.
✓ Branch 1 taken 825860261 times.
|
825865876 | } else if (retval == EOF) { |
437 | 5615 | break; | |
438 | } | ||
439 | 825860261 | const char c = static_cast<char>(retval); | |
440 |
2/2✓ Branch 0 taken 11578841 times.
✓ Branch 1 taken 814281420 times.
|
825860261 | if (c == '\n') |
441 | 11578841 | break; | |
442 | 814281420 | line->push_back(c); | |
443 | 814281420 | } | |
444 |
4/4✓ Branch 0 taken 5615 times.
✓ Branch 1 taken 11578841 times.
✓ Branch 3 taken 691 times.
✓ Branch 4 taken 4924 times.
|
11584456 | return (retval != EOF) || !line->empty(); |
445 | } | ||
446 | |||
447 | 6097 | bool GetLineFd(const int fd, std::string *line) { | |
448 | ssize_t retval; | ||
449 | char c; | ||
450 | 6097 | line->clear(); | |
451 | while (true) { | ||
452 |
1/2✓ Branch 1 taken 281402 times.
✗ Branch 2 not taken.
|
281402 | retval = read(fd, &c, 1); |
453 |
2/2✓ Branch 0 taken 57 times.
✓ Branch 1 taken 281345 times.
|
281402 | if (retval == 0) { |
454 | 57 | break; | |
455 | } | ||
456 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 281345 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
281345 | if ((retval == -1) && (errno == EINTR)) { |
457 | ✗ | continue; | |
458 | } | ||
459 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 281345 times.
|
281345 | if (retval == -1) { |
460 | ✗ | break; | |
461 | } | ||
462 |
2/2✓ Branch 0 taken 6040 times.
✓ Branch 1 taken 275305 times.
|
281345 | if (c == '\n') |
463 | 6040 | break; | |
464 |
1/2✓ Branch 1 taken 275305 times.
✗ Branch 2 not taken.
|
275305 | line->push_back(c); |
465 | } | ||
466 |
4/4✓ Branch 0 taken 57 times.
✓ Branch 1 taken 6040 times.
✓ Branch 3 taken 44 times.
✓ Branch 4 taken 13 times.
|
6097 | return (retval == 1) || !line->empty(); |
467 | } | ||
468 | |||
469 | /** | ||
470 | * Removes leading and trailing whitespaces. | ||
471 | */ | ||
472 | 31238 | string Trim(const string &raw, bool trim_newline) { | |
473 |
2/2✓ Branch 1 taken 2647 times.
✓ Branch 2 taken 28591 times.
|
31238 | if (raw.empty()) |
474 |
1/2✓ Branch 2 taken 2647 times.
✗ Branch 3 not taken.
|
2647 | return ""; |
475 | |||
476 | 28591 | unsigned start_pos = 0; | |
477 | 31017 | for (; (start_pos < raw.length()) | |
478 |
7/8✓ Branch 0 taken 30537 times.
✓ Branch 1 taken 480 times.
✓ Branch 3 taken 29089 times.
✓ Branch 4 taken 1448 times.
✓ Branch 6 taken 29089 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 2426 times.
✓ Branch 9 taken 28591 times.
|
60106 | && (raw[start_pos] == ' ' || raw[start_pos] == '\t' |
479 |
2/2✓ Branch 0 taken 3640 times.
✓ Branch 1 taken 25449 times.
|
29089 | || (trim_newline |
480 |
4/4✓ Branch 1 taken 3160 times.
✓ Branch 2 taken 480 times.
✓ Branch 4 taken 498 times.
✓ Branch 5 taken 2662 times.
|
3640 | && (raw[start_pos] == '\n' || raw[start_pos] == '\r'))); |
481 | ++start_pos) { | ||
482 | } | ||
483 | 28591 | unsigned end_pos = raw.length() - 1; // at least one character in raw | |
484 | 35851 | for (; | |
485 | (end_pos >= start_pos) | ||
486 |
7/8✓ Branch 0 taken 35371 times.
✓ Branch 1 taken 480 times.
✓ Branch 3 taken 33709 times.
✓ Branch 4 taken 1662 times.
✓ Branch 6 taken 33709 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 7260 times.
✓ Branch 9 taken 28591 times.
|
69560 | && (raw[end_pos] == ' ' || raw[end_pos] == '\t' |
487 |
6/6✓ Branch 0 taken 8260 times.
✓ Branch 1 taken 25449 times.
✓ Branch 3 taken 5150 times.
✓ Branch 4 taken 3110 times.
✓ Branch 6 taken 2488 times.
✓ Branch 7 taken 2662 times.
|
33709 | || (trim_newline && (raw[end_pos] == '\n' || raw[end_pos] == '\r'))); |
488 | --end_pos) { | ||
489 | } | ||
490 | |||
491 | 28591 | return raw.substr(start_pos, end_pos - start_pos + 1); | |
492 | } | ||
493 | |||
494 | 160 | std::string TrimString(const std::string &path, | |
495 | const std::string &toTrim, | ||
496 | const int trimMode) { | ||
497 | 160 | std::string trimmed = path; | |
498 |
1/2✓ Branch 1 taken 160 times.
✗ Branch 2 not taken.
|
160 | if (trimmed != toTrim) { |
499 |
3/4✓ Branch 1 taken 320 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 240 times.
✓ Branch 4 taken 80 times.
|
480 | while ((trimMode & kTrimLeading) && HasPrefix(trimmed, toTrim, true) |
500 |
5/6✓ Branch 0 taken 320 times.
✓ Branch 1 taken 80 times.
✓ Branch 4 taken 240 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 240 times.
✓ Branch 7 taken 160 times.
|
720 | && (trimmed.size() > toTrim.size())) { |
501 |
1/2✓ Branch 2 taken 240 times.
✗ Branch 3 not taken.
|
240 | trimmed = trimmed.substr(toTrim.size()); |
502 | } | ||
503 |
3/4✓ Branch 1 taken 240 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 160 times.
✓ Branch 4 taken 80 times.
|
400 | while ((trimMode & kTrimTrailing) && HasSuffix(trimmed, toTrim, true) |
504 |
5/6✓ Branch 0 taken 240 times.
✓ Branch 1 taken 80 times.
✓ Branch 4 taken 160 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 160 times.
✓ Branch 7 taken 160 times.
|
560 | && (trimmed.size() > toTrim.size())) { |
505 |
1/2✓ Branch 3 taken 160 times.
✗ Branch 4 not taken.
|
160 | trimmed = trimmed.substr(0, trimmed.size() - toTrim.size()); |
506 | } | ||
507 | } | ||
508 | 160 | return trimmed; | |
509 | } | ||
510 | |||
511 | /** | ||
512 | * Converts all characters to upper case | ||
513 | */ | ||
514 | 3797 | string ToUpper(const string &mixed_case) { | |
515 | 3797 | string result(mixed_case); | |
516 |
2/2✓ Branch 1 taken 8940 times.
✓ Branch 2 taken 3797 times.
|
12737 | for (unsigned i = 0, l = result.length(); i < l; ++i) { |
517 |
2/4✓ Branch 1 taken 8940 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 8940 times.
✗ Branch 5 not taken.
|
8940 | result[i] = static_cast<char>(toupper(result[i])); |
518 | } | ||
519 | 3797 | return result; | |
520 | } | ||
521 | |||
522 | 3817 | string ReplaceAll(const string &haystack, const string &needle, | |
523 | const string &replace_by) { | ||
524 | 3817 | string result(haystack); | |
525 | 3817 | size_t pos = 0; | |
526 | 3817 | const unsigned needle_size = needle.size(); | |
527 |
2/2✓ Branch 1 taken 4 times.
✓ Branch 2 taken 3813 times.
|
3817 | if (needle == "") |
528 | 4 | return result; | |
529 | |||
530 |
2/2✓ Branch 1 taken 2160 times.
✓ Branch 2 taken 3813 times.
|
5973 | while ((pos = result.find(needle, pos)) != string::npos) |
531 |
1/2✓ Branch 1 taken 2160 times.
✗ Branch 2 not taken.
|
2160 | result.replace(pos, needle_size, replace_by); |
532 | 3813 | return result; | |
533 | } | ||
534 | |||
535 | 420884 | static inline void Base64Block(const unsigned char input[3], const char *table, | |
536 | char output[4]) { | ||
537 | 420884 | output[0] = table[(input[0] & 0xFD) >> 2]; | |
538 | 420884 | output[1] = table[((input[0] & 0x03) << 4) | ((input[1] & 0xF0) >> 4)]; | |
539 | 420884 | output[2] = table[((input[1] & 0x0F) << 2) | ((input[2] & 0xD0) >> 6)]; | |
540 | 420884 | output[3] = table[input[2] & 0x3F]; | |
541 | 420884 | } | |
542 | |||
543 | 58370 | string Base64(const string &data) { | |
544 | 58370 | string result; | |
545 |
1/2✓ Branch 2 taken 58370 times.
✗ Branch 3 not taken.
|
58370 | result.reserve((data.length() + 3) * 4 / 3); |
546 | 58370 | unsigned pos = 0; | |
547 | const unsigned char *data_ptr = reinterpret_cast<const unsigned char *>( | ||
548 | 58370 | data.data()); | |
549 | 58370 | const unsigned length = data.length(); | |
550 |
2/2✓ Branch 0 taken 363069 times.
✓ Branch 1 taken 58370 times.
|
421439 | while (pos + 2 < length) { |
551 | char encoded_block[4]; | ||
552 | 363069 | Base64Block(data_ptr + pos, b64_table, encoded_block); | |
553 |
1/2✓ Branch 1 taken 363069 times.
✗ Branch 2 not taken.
|
363069 | result.append(encoded_block, 4); |
554 | 363069 | pos += 3; | |
555 | } | ||
556 |
2/2✓ Branch 0 taken 57815 times.
✓ Branch 1 taken 555 times.
|
58370 | if (length % 3 != 0) { |
557 | unsigned char input[3]; | ||
558 | 57815 | input[0] = data_ptr[pos]; | |
559 |
2/2✓ Branch 0 taken 38561 times.
✓ Branch 1 taken 19254 times.
|
57815 | input[1] = ((length % 3) == 2) ? data_ptr[pos + 1] : 0; |
560 | 57815 | input[2] = 0; | |
561 | char encoded_block[4]; | ||
562 | 57815 | Base64Block(input, b64_table, encoded_block); | |
563 |
1/2✓ Branch 1 taken 57815 times.
✗ Branch 2 not taken.
|
57815 | result.append(encoded_block, 2); |
564 |
3/4✓ Branch 0 taken 38561 times.
✓ Branch 1 taken 19254 times.
✓ Branch 3 taken 57815 times.
✗ Branch 4 not taken.
|
57815 | result.push_back(((length % 3) == 2) ? encoded_block[2] : '='); |
565 |
1/2✓ Branch 1 taken 57815 times.
✗ Branch 2 not taken.
|
57815 | result.push_back('='); |
566 | } | ||
567 | |||
568 | 58370 | return result; | |
569 | } | ||
570 | |||
571 | /** | ||
572 | * Safe encoding for URIs and path names: replace + by - and / by _ | ||
573 | */ | ||
574 | 215 | string Base64Url(const string &data) { | |
575 | 215 | string base64 = Base64(data); | |
576 |
2/2✓ Branch 1 taken 18060 times.
✓ Branch 2 taken 215 times.
|
18275 | for (unsigned i = 0, l = base64.length(); i < l; ++i) { |
577 |
3/4✓ Branch 1 taken 18060 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 258 times.
✓ Branch 4 taken 17802 times.
|
18060 | if (base64[i] == '+') { |
578 |
1/2✓ Branch 1 taken 258 times.
✗ Branch 2 not taken.
|
258 | base64[i] = '-'; |
579 |
3/4✓ Branch 1 taken 17802 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 172 times.
✓ Branch 4 taken 17630 times.
|
17802 | } else if (base64[i] == '/') { |
580 |
1/2✓ Branch 1 taken 172 times.
✗ Branch 2 not taken.
|
172 | base64[i] = '_'; |
581 | } | ||
582 | } | ||
583 | 215 | return base64; | |
584 | } | ||
585 | |||
586 | 911840 | static bool Debase64Block(const unsigned char input[4], | |
587 | unsigned char output[3]) { | ||
588 | int32_t dec[4]; | ||
589 |
2/2✓ Branch 0 taken 3647231 times.
✓ Branch 1 taken 911797 times.
|
4559028 | for (int i = 0; i < 4; ++i) { |
590 | 3647231 | dec[i] = db64_table[input[i]]; | |
591 |
2/2✓ Branch 0 taken 43 times.
✓ Branch 1 taken 3647188 times.
|
3647231 | if (dec[i] < 0) |
592 | 43 | return false; | |
593 | } | ||
594 | |||
595 | 911797 | output[0] = (dec[0] << 2) | (dec[1] >> 4); | |
596 | 911797 | output[1] = ((dec[1] & 0x0F) << 4) | (dec[2] >> 2); | |
597 | 911797 | output[2] = ((dec[2] & 0x03) << 6) | dec[3]; | |
598 | 911797 | return true; | |
599 | } | ||
600 | |||
601 | /** | ||
602 | * Can decode both base64 and base64url | ||
603 | */ | ||
604 | 5354 | bool Debase64(const string &data, string *decoded) { | |
605 | 5354 | decoded->clear(); | |
606 | 5354 | decoded->reserve((data.length() + 4) * 3 / 4); | |
607 | 5354 | unsigned pos = 0; | |
608 | const unsigned char *data_ptr = reinterpret_cast<const unsigned char *>( | ||
609 | 5354 | data.data()); | |
610 | 5354 | const unsigned length = data.length(); | |
611 |
2/2✓ Branch 0 taken 43 times.
✓ Branch 1 taken 5311 times.
|
5354 | if (length == 0) |
612 | 43 | return true; | |
613 |
2/2✓ Branch 0 taken 86 times.
✓ Branch 1 taken 5225 times.
|
5311 | if ((length % 4) != 0) |
614 | 86 | return false; | |
615 | |||
616 |
2/2✓ Branch 0 taken 911840 times.
✓ Branch 1 taken 5182 times.
|
917022 | while (pos < length) { |
617 | unsigned char decoded_block[3]; | ||
618 | 911840 | const bool retval = Debase64Block(data_ptr + pos, decoded_block); | |
619 |
2/2✓ Branch 0 taken 43 times.
✓ Branch 1 taken 911797 times.
|
911840 | if (!retval) |
620 | 43 | return false; | |
621 |
1/2✓ Branch 1 taken 911797 times.
✗ Branch 2 not taken.
|
911797 | decoded->append(reinterpret_cast<char *>(decoded_block), 3); |
622 | 911797 | pos += 4; | |
623 | } | ||
624 | |||
625 |
2/2✓ Branch 0 taken 10364 times.
✓ Branch 1 taken 5182 times.
|
15546 | for (int i = 0; i < 2; ++i) { |
626 | 10364 | pos--; | |
627 |
2/2✓ Branch 1 taken 1828 times.
✓ Branch 2 taken 8536 times.
|
10364 | if (data[pos] == '=') |
628 | 1828 | decoded->erase(decoded->length() - 1); | |
629 | } | ||
630 | 5182 | return true; | |
631 | } | ||
632 | |||
633 | /** | ||
634 | * Assumes that source is terminated by a newline | ||
635 | */ | ||
636 | 84 | string Tail(const string &source, unsigned num_lines) { | |
637 |
6/6✓ Branch 1 taken 60 times.
✓ Branch 2 taken 24 times.
✓ Branch 3 taken 12 times.
✓ Branch 4 taken 48 times.
✓ Branch 5 taken 36 times.
✓ Branch 6 taken 48 times.
|
84 | if (source.empty() || (num_lines == 0)) |
638 |
1/2✓ Branch 2 taken 36 times.
✗ Branch 3 not taken.
|
36 | return ""; |
639 | |||
640 | 48 | const int l = static_cast<int>(source.length()); | |
641 | 48 | int i = l - 1; | |
642 |
2/2✓ Branch 0 taken 192 times.
✓ Branch 1 taken 36 times.
|
228 | for (; i >= 0; --i) { |
643 | 192 | const char c = source.data()[i]; | |
644 |
2/2✓ Branch 0 taken 60 times.
✓ Branch 1 taken 132 times.
|
192 | if (c == '\n') { |
645 |
2/2✓ Branch 0 taken 12 times.
✓ Branch 1 taken 48 times.
|
60 | if (num_lines == 0) { |
646 | 12 | return source.substr(i + 1); | |
647 | } | ||
648 | 48 | num_lines--; | |
649 | } | ||
650 | } | ||
651 | 36 | return source; | |
652 | } | ||
653 | |||
654 | /** | ||
655 | * Get UTC Time. | ||
656 | * | ||
657 | * @param format format if timestamp (YYYY-MM-DD HH:MM:SS by default) | ||
658 | * @return a timestamp string on success, empty string on failure | ||
659 | */ | ||
660 | ✗ | std::string GetGMTimestamp(const std::string &format) { | |
661 | struct tm time_ptr; | ||
662 | char date_and_time[100]; | ||
663 | ✗ | const time_t t = time(NULL); | |
664 | ✗ | gmtime_r(&t, &time_ptr); // take UTC | |
665 | // return empty string if formatting fails | ||
666 | ✗ | if (!strftime(date_and_time, 100, format.c_str(), &time_ptr)) { | |
667 | ✗ | return ""; | |
668 | } | ||
669 | ✗ | std::string timestamp(date_and_time); | |
670 | ✗ | return timestamp; | |
671 | } | ||
672 | |||
673 | #ifdef CVMFS_NAMESPACE_GUARD | ||
674 | } // namespace CVMFS_NAMESPACE_GUARD | ||
675 | #endif | ||
676 |