GCC Code Coverage Report

Directory: cvmfs/
File: cvmfs/util/string.cc
Date: 2026-09-20 02:39:58
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 #include "string.h"
8
9 #include <cctype>
10 #include <cstdio>
11 #include <cstdlib>
12 #include <cstring>
13 #include <ctime>
14 #include <algorithm>
15 #include <vector>
16 #include <map>
17 #include <stdio.h>
18 #include <errno.h>
19 #include <fcntl.h>
20 #include <inttypes.h>
21 #include <stdint.h>
22 #include <time.h>
23 #include <string>
24 #include <unistd.h>
25
26
27 using namespace std; // NOLINT
28
29 #ifdef CVMFS_NAMESPACE_GUARD
30 namespace CVMFS_NAMESPACE_GUARD {
31 #endif
32
33 const char b64_table[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K',
34 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
35 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g',
36 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r',
37 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2',
38 '3', '4', '5', '6', '7', '8', '9', '+', '/'};
39
40 /**
41 * Decode Base64 and Base64Url
42 */
43 const int8_t db64_table[] = {
44 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
45 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
46 -1, -1, -1, -1, -1, 62, -1, 62, -1, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60,
47 61, -1, -1, -1, 0, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
48 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1,
49 63, -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
50 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1,
51
52 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
53 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
54 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
55 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
56 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
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,
59 };
60
61 namespace {
62
63 /**
64 * Used for cas insensitive HasSuffix
65 */
66 struct IgnoreCaseComperator {
67 20239 IgnoreCaseComperator() { }
68 295 bool operator()(const std::string::value_type a,
69 const std::string::value_type b) const {
70 295 return std::tolower(a) == std::tolower(b);
71 }
72 };
73
74 } // anonymous namespace
75
76
3/4
✓ Branch 1 taken 64 times.
✓ Branch 2 taken 4326 times.
✓ Branch 4 taken 4390 times.
✗ Branch 5 not taken.
 4390 string StringifyBool(const bool value) { return value ? "yes" : "no"; }
77
78 36537565 string StringifyInt(const int64_t value) {
79 char buffer[48];
80 36537565 snprintf(buffer, sizeof(buffer), "%" PRId64, value);
81
1/2
✓ Branch 2 taken 36574511 times.
✗ Branch 3 not taken.
 36537565 return string(buffer);
82 }
83
84 368928 std::string StringifyUint(const uint64_t value) {
85 char buffer[48];
86 368928 snprintf(buffer, sizeof(buffer), "%" PRIu64, value);
87
1/2
✓ Branch 2 taken 368928 times.
✗ Branch 3 not taken.
 368928 return string(buffer);
88 }
89
90 44 string StringifyByteAsHex(const unsigned char value) {
91 char buffer[3];
92 44 snprintf(buffer, sizeof(buffer), "%02x", value);
93
1/2
✓ Branch 2 taken 44 times.
✗ Branch 3 not taken.
 44 return string(buffer);
94 }
95
96 184 string StringifyDouble(const double value) {
97 char buffer[64];
98 184 snprintf(buffer, sizeof(buffer), "%.03f", value);
99
1/2
✓ Branch 2 taken 184 times.
✗ Branch 3 not taken.
 184 return string(buffer);
100 }
101
102 /**
103 * Converts seconds since UTC 0 into something readable
104 */
105 2433 string StringifyTime(const time_t seconds, const bool utc) {
106 struct tm timestamp;
107
2/2
✓ Branch 0 taken 1318 times.
✓ Branch 1 taken 1115 times.
 2433 if (utc) {
108 1318 localtime_r(&seconds, &timestamp);
109 } else {
110 1115 gmtime_r(&seconds, &timestamp);
111 }
112
113 2433 const char *months[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
114 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
115 char buffer[21];
116 2433 snprintf(buffer, sizeof(buffer), "%d %s %d %02d:%02d:%02d", timestamp.tm_mday,
117 2433 months[timestamp.tm_mon], timestamp.tm_year + 1900,
118 timestamp.tm_hour, timestamp.tm_min, timestamp.tm_sec);
119
120
1/2
✓ Branch 2 taken 2433 times.
✗ Branch 3 not taken.
 2433 return string(buffer);
121 }
122
123 /**
124 * Converts seconds since UTC 0 into something like 12 Sep 14:59:37 CDT
125 */
126 753 string StringifyLocalTime(const time_t seconds) {
127 struct tm timestamp;
128 753 localtime_r(&seconds, &timestamp);
129
130 753 const char *months[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
131 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
132 char buffer[26];
133 (void)/* cast to void ignores return and placates clang-tidy */
134 753 snprintf(buffer, sizeof(buffer), "%d %s %d %02d:%02d:%02d %s",
135 753 timestamp.tm_mday, months[timestamp.tm_mon],
136 753 timestamp.tm_year + 1900, timestamp.tm_hour, timestamp.tm_min,
137 timestamp.tm_sec, timestamp.tm_zone);
138
139
1/2
✓ Branch 2 taken 753 times.
✗ Branch 3 not taken.
 753 return string(buffer);
140 }
141
142
143 /**
144 * Current time in format Wed, 01 Mar 2006 12:00:00 GMT
145 */
146 33802 std::string RfcTimestamp() {
147 33802 const char *months[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
148 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
149 33802 const char *day_of_week[] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
150
151 struct tm timestamp;
152 33802 const time_t now = time(NULL);
153 33802 gmtime_r(&now, &timestamp);
154
155 char buffer[30];
156 33802 snprintf(buffer, sizeof(buffer), "%s, %02d %s %d %02d:%02d:%02d %s",
157 33802 day_of_week[timestamp.tm_wday], timestamp.tm_mday,
158 33802 months[timestamp.tm_mon], timestamp.tm_year + 1900,
159 timestamp.tm_hour, timestamp.tm_min, timestamp.tm_sec,
160 timestamp.tm_zone);
161
1/2
✓ Branch 2 taken 33802 times.
✗ Branch 3 not taken.
 33802 return string(buffer);
162 }
163
164
165 /**
166 * Current time in format YYYYMMDDTHHMMSSZ. Used in AWS4 requests.
167 */
168 11 std::string IsoTimestamp() {
169 struct tm timestamp;
170 11 const time_t now = time(NULL);
171 11 gmtime_r(&now, &timestamp);
172
173 char buffer[17];
174 11 snprintf(buffer, sizeof(buffer), "%04d%02d%02dT%02d%02d%02dZ",
175 11 timestamp.tm_year + 1900, timestamp.tm_mon + 1, timestamp.tm_mday,
176 timestamp.tm_hour, timestamp.tm_min, timestamp.tm_sec);
177
1/2
✓ Branch 2 taken 11 times.
✗ Branch 3 not taken.
 11 return string(buffer);
178 }
179
180
181 /**
182 * UTC time in format YYYYMMDDHHMMSS. Used in cvmfs whitelists.
183 */
184 179 std::string WhitelistTimestamp(time_t when) {
185 struct tm timestamp;
186 179 gmtime_r(&when, &timestamp);
187
188 char buffer[15];
189 179 snprintf(buffer, sizeof(buffer), "%04d%02d%02d%02d%02d%02d",
190 179 timestamp.tm_year + 1900, timestamp.tm_mon + 1, timestamp.tm_mday,
191 timestamp.tm_hour, timestamp.tm_min, timestamp.tm_sec);
192
1/2
✓ Branch 2 taken 179 times.
✗ Branch 3 not taken.
 179 return string(buffer);
193 }
194
195
196 10806310 string StringifyTimeval(const timeval value) {
197 char buffer[64];
198 10806310 int64_t msec = value.tv_sec * 1000;
199 10806310 msec += value.tv_usec / 1000;
200 10806310 snprintf(buffer, sizeof(buffer), "%" PRId64 ".%03d", msec,
201 10806310 static_cast<int>(value.tv_usec % 1000));
202
1/2
✓ Branch 2 taken 10806310 times.
✗ Branch 3 not taken.
 10806310 return string(buffer);
203 }
204
205 /**
206 * Parses a timestamp of the form YYYY-MM-DDTHH:MM:SSZ
207 * Return 0 on error
208 */
209 3297 time_t IsoTimestamp2UtcTime(const std::string &iso8601) {
210 3297 time_t utc_time = 0;
211 3297 const unsigned length = iso8601.length();
212
213
2/2
✓ Branch 0 taken 32 times.
✓ Branch 1 taken 3265 times.
 3297 if (length != 20)
214 32 return utc_time;
215
2/4
✓ Branch 2 taken 3265 times.
✗ Branch 3 not taken.
✓ Branch 5 taken 3265 times.
✗ Branch 6 not taken.
 6530 if ((iso8601[4] != '-') || (iso8601[7] != '-') || (iso8601[10] != 'T')
216
5/10
✓ Branch 0 taken 3265 times.
✗ Branch 1 not taken.
✓ Branch 3 taken 3265 times.
✗ Branch 4 not taken.
✓ Branch 6 taken 3265 times.
✗ Branch 7 not taken.
✗ Branch 9 not taken.
✓ Branch 10 taken 3265 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 3265 times.
 6530 || (iso8601[13] != ':') || (iso8601[16] != ':') || (iso8601[19] != 'Z')) {
217 ✗ return utc_time;
218 }
219
220 struct tm tm_wl;
221 3265 memset(&tm_wl, 0, sizeof(struct tm));
222
2/4
✓ Branch 1 taken 3265 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 3265 times.
✗ Branch 5 not taken.
 3265 tm_wl.tm_year = static_cast<int>(String2Int64(iso8601.substr(0, 4))) - 1900;
223
2/4
✓ Branch 1 taken 3265 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 3265 times.
✗ Branch 5 not taken.
 3265 tm_wl.tm_mon = static_cast<int>(String2Int64(iso8601.substr(5, 2))) - 1;
224
2/4
✓ Branch 1 taken 3265 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 3265 times.
✗ Branch 5 not taken.
 3265 tm_wl.tm_mday = static_cast<int>(String2Int64(iso8601.substr(8, 2)));
225
2/4
✓ Branch 1 taken 3265 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 3265 times.
✗ Branch 5 not taken.
 3265 tm_wl.tm_hour = static_cast<int>(String2Int64(iso8601.substr(11, 2)));
226
2/4
✓ Branch 1 taken 3265 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 3265 times.
✗ Branch 5 not taken.
 3265 tm_wl.tm_min = static_cast<int>(String2Int64(iso8601.substr(14, 2)));
227
2/4
✓ Branch 1 taken 3265 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 3265 times.
✗ Branch 5 not taken.
 3265 tm_wl.tm_sec = static_cast<int>(String2Int64(iso8601.substr(17, 2)));
228 3265 utc_time = timegm(&tm_wl);
229
2/2
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 3249 times.
 3265 if (utc_time < 0)
230 16 return 0;
231
232 3249 return utc_time;
233 }
234
235 41699 int64_t String2Int64(const string &value) {
236 int64_t result;
237 41699 sscanf(value.c_str(), "%" PRId64, &result);
238 41699 return result;
239 }
240
241 440804 uint64_t String2Uint64(const string &value) {
242 uint64_t result;
243
2/2
✓ Branch 1 taken 440620 times.
✓ Branch 2 taken 184 times.
 440804 if (sscanf(value.c_str(), "%" PRIu64, &result) == 1) {
244 440620 return result;
245 }
246 184 return 0;
247 }
248
249 /**
250 * Parse a string into a a uint64_t.
251 *
252 * Unlike String2Uint64, this:
253 * - Checks to make sure the full string is parsed
254 * - Can indicate an error occurred.
255 *
256 * If an error occurs, this returns false and sets errno appropriately.
257 */
258 3698 bool String2Uint64Parse(const std::string &value, uint64_t *result) {
259 3698 char *endptr = NULL;
260 3698 errno = 0;
261 3698 long long myval = strtoll(value.c_str(), &endptr, 10); // NOLINT
262
2/2
✓ Branch 3 taken 3040 times.
✓ Branch 4 taken 526 times.
 7264 if ((value.size() == 0) || (endptr != (value.c_str() + value.size()))
263
6/6
✓ Branch 0 taken 3566 times.
✓ Branch 1 taken 132 times.
✓ Branch 2 taken 20 times.
✓ Branch 3 taken 3020 times.
✓ Branch 4 taken 678 times.
✓ Branch 5 taken 3020 times.
 7264 || (myval < 0)) {
264 678 errno = EINVAL;
265 678 return false;
266 }
267
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3020 times.
 3020 if (errno) {
268 ✗ return false;
269 }
270
2/2
✓ Branch 0 taken 3000 times.
✓ Branch 1 taken 20 times.
 3020 if (result) {
271 3000 *result = myval;
272 }
273 3020 return true;
274 }
275
276 84 void String2Uint64Pair(const string &value, uint64_t *a, uint64_t *b) {
277 84 sscanf(value.c_str(), "%" PRIu64 " %" PRIu64, a, b);
278 84 }
279
280 275275 bool HasPrefix(const string &str, const string &prefix,
281 const bool ignore_case) {
282
2/2
✓ Branch 2 taken 47794 times.
✓ Branch 3 taken 227481 times.
 275275 if (prefix.length() > str.length())
283 47794 return false;
284
285
2/2
✓ Branch 1 taken 855472 times.
✓ Branch 2 taken 70277 times.
 925749 for (unsigned i = 0, l = prefix.length(); i < l; ++i) {
286
2/2
✓ Branch 0 taken 159127 times.
✓ Branch 1 taken 696345 times.
 855472 if (ignore_case) {
287
2/2
✓ Branch 2 taken 89364 times.
✓ Branch 3 taken 69763 times.
 159127 if (toupper(str[i]) != toupper(prefix[i]))
288 89364 return false;
289 } else {
290
2/2
✓ Branch 2 taken 67840 times.
✓ Branch 3 taken 628505 times.
 696345 if (str[i] != prefix[i])
291 67840 return false;
292 }
293 }
294 70277 return true;
295 }
296
297 20397 bool HasSuffix(const std::string &str, const std::string &suffix,
298 const bool ignore_case) {
299
2/2
✓ Branch 2 taken 158 times.
✓ Branch 3 taken 20239 times.
 20397 if (suffix.size() > str.size())
300 158 return false;
301 20239 const IgnoreCaseComperator icmp;
302 return (ignore_case)
303
3/4
✓ Branch 0 taken 239 times.
✓ Branch 1 taken 20000 times.
✓ Branch 6 taken 239 times.
✗ Branch 7 not taken.
 20239 ? std::equal(suffix.rbegin(), suffix.rend(), str.rbegin(), icmp)
304
1/2
✓ Branch 4 taken 20000 times.
✗ Branch 5 not taken.
 20239 : std::equal(suffix.rbegin(), suffix.rend(), str.rbegin());
305 }
306
307 68315 vector<string> SplitString(const string &str, char delim) {
308 68315 return SplitStringBounded(0, str, delim);
309 }
310
311 68423 vector<string> SplitStringBounded(unsigned max_chunks, const string &str,
312 char delim) {
313 68423 vector<string> result;
314
315 // edge case... one chunk is always the whole string
316
2/2
✓ Branch 0 taken 18 times.
✓ Branch 1 taken 68405 times.
 68423 if (1 == max_chunks) {
317
1/2
✓ Branch 1 taken 18 times.
✗ Branch 2 not taken.
 18 result.push_back(str);
318 18 return result;
319 }
320
321 // split the string
322 68405 const unsigned size = str.size();
323 68405 unsigned marker = 0;
324 68405 unsigned chunks = 1;
325 unsigned i;
326
2/2
✓ Branch 0 taken 1606383 times.
✓ Branch 1 taken 68369 times.
 1674752 for (i = 0; i < size; ++i) {
327
2/2
✓ Branch 1 taken 99313 times.
✓ Branch 2 taken 1507070 times.
 1606383 if (str[i] == delim) {
328
2/4
✓ Branch 1 taken 99313 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 99313 times.
✗ Branch 5 not taken.
 99313 result.push_back(str.substr(marker, i - marker));
329 99313 marker = i + 1;
330
331 // we got what we want... good bye
332
2/2
✓ Branch 0 taken 36 times.
✓ Branch 1 taken 99277 times.
 99313 if (++chunks == max_chunks)
333 36 break;
334 }
335 }
336
337 // push the remainings of the string and return
338
2/4
✓ Branch 1 taken 68405 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 68405 times.
✗ Branch 5 not taken.
 68405 result.push_back(str.substr(marker));
339 68405 return result;
340 }
341
342 165 vector<string> SplitStringMultiChar(const string &str, const string &delim) {
343 165 size_t pos_start = 0, pos_end = 0, delim_len = delim.length();
344 165 std::string substring;
345 165 std::vector<std::string> result;
346
347
2/2
✓ Branch 1 taken 145 times.
✓ Branch 2 taken 165 times.
 310 while ((pos_end = str.find(delim, pos_start)) != string::npos) {
348
1/2
✓ Branch 1 taken 145 times.
✗ Branch 2 not taken.
 145 substring = str.substr(pos_start, pos_end - pos_start);
349 145 pos_start = pos_end + delim_len;
350
1/2
✓ Branch 1 taken 145 times.
✗ Branch 2 not taken.
 145 result.push_back(substring);
351 }
352
353
2/4
✓ Branch 1 taken 165 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 165 times.
✗ Branch 5 not taken.
 165 result.push_back(str.substr(pos_start));
354 330 return result;
355 165 }
356
357 13323 string JoinStrings(const vector<string> &strings, const string &joint) {
358
1/2
✓ Branch 2 taken 13323 times.
✗ Branch 3 not taken.
 13323 string result = "";
359 13323 const unsigned size = strings.size();
360
361
2/2
✓ Branch 0 taken 9757 times.
✓ Branch 1 taken 3566 times.
 13323 if (size > 0) {
362
1/2
✓ Branch 2 taken 9757 times.
✗ Branch 3 not taken.
 9757 result = strings[0];
363
2/2
✓ Branch 0 taken 1022 times.
✓ Branch 1 taken 9757 times.
 10779 for (unsigned i = 1; i < size; ++i)
364
2/4
✓ Branch 2 taken 1022 times.
✗ Branch 3 not taken.
✓ Branch 5 taken 1022 times.
✗ Branch 6 not taken.
 1022 result += joint + strings[i];
365 }
366
367 13323 return result;
368 }
369
370 4870 void ParseKeyvalMem(const unsigned char *buffer, const unsigned buffer_size,
371 map<char, string> *content) {
372 4870 string line;
373 4870 unsigned pos = 0;
374
2/2
✓ Branch 0 taken 375937 times.
✓ Branch 1 taken 145 times.
 376082 while (pos < buffer_size) {
375
2/2
✓ Branch 0 taken 30593 times.
✓ Branch 1 taken 345344 times.
 375937 if (static_cast<char>(buffer[pos]) == '\n') {
376
2/2
✓ Branch 1 taken 4725 times.
✓ Branch 2 taken 25868 times.
 30593 if (line == "--")
377 4725 return;
378
379
1/2
✓ Branch 1 taken 25868 times.
✗ Branch 2 not taken.
 25868 if (line != "") {
380
3/11
✗ Branch 1 not taken.
✓ Branch 2 taken 25868 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✓ Branch 8 taken 25868 times.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✓ Branch 11 taken 25868 times.
✗ Branch 12 not taken.
✗ Branch 13 not taken.
 25868 const string tail = (line.length() == 1) ? "" : line.substr(1);
381 // Special handling of 'Z' key because it can exist multiple times
382
3/4
✓ Branch 1 taken 25868 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 25800 times.
✓ Branch 4 taken 68 times.
 25868 if (line[0] != 'Z') {
383
3/6
✓ Branch 1 taken 25800 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 25800 times.
✗ Branch 5 not taken.
✓ Branch 7 taken 25800 times.
✗ Branch 8 not taken.
 25800 (*content)[line[0]] = tail;
384 } else {
385
4/7
✓ Branch 2 taken 68 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 68 times.
✗ Branch 6 not taken.
✓ Branch 8 taken 34 times.
✓ Branch 9 taken 34 times.
 68 if (content->find(line[0]) == content->end()) {
386
3/6
✓ Branch 1 taken 34 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 34 times.
✗ Branch 5 not taken.
✓ Branch 7 taken 34 times.
✗ Branch 8 not taken.
 34 (*content)[line[0]] = tail;
387 } else {
388
6/12
✓ Branch 1 taken 34 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 34 times.
✗ Branch 5 not taken.
✓ Branch 7 taken 34 times.
✗ Branch 8 not taken.
✓ Branch 10 taken 34 times.
✗ Branch 11 not taken.
✓ Branch 13 taken 34 times.
✗ Branch 14 not taken.
✓ Branch 16 taken 34 times.
✗ Branch 17 not taken.
 34 (*content)[line[0]] = (*content)[line[0]] + "|" + tail;
389 }
390 }
391 25868 }
392
1/2
✓ Branch 1 taken 25868 times.
✗ Branch 2 not taken.
 25868 line = "";
393 } else {
394
1/2
✓ Branch 1 taken 345344 times.
✗ Branch 2 not taken.
 345344 line += static_cast<char>(buffer[pos]);
395 }
396 371212 pos++;
397 }
398
2/2
✓ Branch 1 taken 145 times.
✓ Branch 2 taken 4725 times.
 4870 }
399
400 534 bool ParseKeyvalPath(const string &filename, map<char, string> *content) {
401
1/2
✓ Branch 2 taken 534 times.
✗ Branch 3 not taken.
 534 const int fd = open(filename.c_str(), O_RDONLY);
402
2/2
✓ Branch 0 taken 20 times.
✓ Branch 1 taken 514 times.
 534 if (fd < 0)
403 20 return false;
404
405 unsigned char buffer[4096];
406
1/2
✓ Branch 1 taken 514 times.
✗ Branch 2 not taken.
 514 const ssize_t num_bytes = read(fd, buffer, sizeof(buffer));
407
1/2
✓ Branch 1 taken 514 times.
✗ Branch 2 not taken.
 514 close(fd);
408
409
3/4
✓ Branch 0 taken 494 times.
✓ Branch 1 taken 20 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 494 times.
 514 if ((num_bytes <= 0) || (unsigned(num_bytes) >= sizeof(buffer)))
410 20 return false;
411
412
1/2
✓ Branch 1 taken 494 times.
✗ Branch 2 not taken.
 494 ParseKeyvalMem(buffer, unsigned(num_bytes), content);
413 494 return true;
414 }
415
416 335515 string GetLineMem(const char *text, const int text_size) {
417 335515 int pos = 0;
418
4/4
✓ Branch 0 taken 14029604 times.
✓ Branch 1 taken 617 times.
✓ Branch 2 taken 13694706 times.
✓ Branch 3 taken 334898 times.
 14030221 while ((pos < text_size) && (text[pos] != '\n'))
419 13694706 pos++;
420
1/2
✓ Branch 2 taken 335515 times.
✗ Branch 3 not taken.
 335515 return string(text, pos);
421 }
422
423 10847520 bool GetLineFile(FILE *f, std::string *line) {
424 int retval;
425 10847520 line->clear();
426 while (true) {
427 772797347 retval = fgetc(f);
428
2/6
✗ Branch 1 not taken.
✓ Branch 2 taken 772797347 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✓ Branch 6 taken 772797347 times.
 772797347 if (ferror(f) && (errno == EINTR)) {
429 ✗ clearerr(f);
430 ✗ continue;
431
2/2
✓ Branch 0 taken 7486 times.
✓ Branch 1 taken 772789861 times.
 772797347 } else if (retval == EOF) {
432 7486 break;
433 }
434 772789861 const char c = static_cast<char>(retval);
435
2/2
✓ Branch 0 taken 10840034 times.
✓ Branch 1 taken 761949827 times.
 772789861 if (c == '\n')
436 10840034 break;
437 761949827 line->push_back(c);
438 761949827 }
439
4/4
✓ Branch 0 taken 7486 times.
✓ Branch 1 taken 10840034 times.
✓ Branch 3 taken 1275 times.
✓ Branch 4 taken 6211 times.
 10847520 return (retval != EOF) || !line->empty();
440 }
441
442 6977 bool GetLineFd(const int fd, std::string *line) {
443 ssize_t retval;
444 char c;
445 6977 line->clear();
446 while (true) {
447
1/2
✓ Branch 1 taken 253515 times.
✗ Branch 2 not taken.
 253515 retval = read(fd, &c, 1);
448
2/2
✓ Branch 0 taken 21 times.
✓ Branch 1 taken 253494 times.
 253515 if (retval == 0) {
449 21 break;
450 }
451
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 253494 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 253494 if ((retval == -1) && (errno == EINTR)) {
452 ✗ continue;
453 }
454
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 253494 times.
 253494 if (retval == -1) {
455 ✗ break;
456 }
457
2/2
✓ Branch 0 taken 6956 times.
✓ Branch 1 taken 246538 times.
 253494 if (c == '\n')
458 6956 break;
459
1/2
✓ Branch 1 taken 246538 times.
✗ Branch 2 not taken.
 246538 line->push_back(c);
460 }
461
4/4
✓ Branch 0 taken 21 times.
✓ Branch 1 taken 6956 times.
✓ Branch 3 taken 11 times.
✓ Branch 4 taken 10 times.
 6977 return (retval == 1) || !line->empty();
462 }
463
464 /**
465 * Removes leading and trailing whitespaces.
466 */
467 53299 string Trim(const string &raw, bool trim_newline) {
468
2/2
✓ Branch 1 taken 4289 times.
✓ Branch 2 taken 49010 times.
 53299 if (raw.empty())
469
1/2
✓ Branch 2 taken 4289 times.
✗ Branch 3 not taken.
 4289 return "";
470
471 49010 unsigned start_pos = 0;
472 53239 for (; (start_pos < raw.length())
473
7/8
✓ Branch 0 taken 52687 times.
✓ Branch 1 taken 552 times.
✓ Branch 3 taken 49575 times.
✓ Branch 4 taken 3112 times.
✓ Branch 6 taken 49575 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 4229 times.
✓ Branch 9 taken 49010 times.
 102814 && (raw[start_pos] == ' ' || raw[start_pos] == '\t'
474
2/2
✓ Branch 0 taken 15742 times.
✓ Branch 1 taken 33833 times.
 49575 || (trim_newline
475
4/4
✓ Branch 1 taken 15190 times.
✓ Branch 2 taken 552 times.
✓ Branch 4 taken 565 times.
✓ Branch 5 taken 14625 times.
 15742 && (raw[start_pos] == '\n' || raw[start_pos] == '\r')));
476 ++start_pos) {
477 }
478 49010 unsigned end_pos = raw.length() - 1; // at least one character in raw
479 68838 for (;
480 (end_pos >= start_pos)
481
7/8
✓ Branch 0 taken 68286 times.
✓ Branch 1 taken 552 times.
✓ Branch 3 taken 66300 times.
✓ Branch 4 taken 1986 times.
✓ Branch 6 taken 66300 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 19828 times.
✓ Branch 9 taken 49010 times.
 135138 && (raw[end_pos] == ' ' || raw[end_pos] == '\t'
482
6/6
✓ Branch 0 taken 32467 times.
✓ Branch 1 taken 33833 times.
✓ Branch 3 taken 17436 times.
✓ Branch 4 taken 15031 times.
✓ Branch 6 taken 2811 times.
✓ Branch 7 taken 14625 times.
 66300 || (trim_newline && (raw[end_pos] == '\n' || raw[end_pos] == '\r')));
483 --end_pos) {
484 }
485
486 49010 return raw.substr(start_pos, end_pos - start_pos + 1);
487 }
488
489 144 std::string TrimString(const std::string &path,
490 const std::string &toTrim,
491 const int trimMode) {
492 144 std::string trimmed = path;
493
1/2
✓ Branch 1 taken 144 times.
✗ Branch 2 not taken.
 144 if (trimmed != toTrim) {
494
3/4
✓ Branch 1 taken 288 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 216 times.
✓ Branch 4 taken 72 times.
 432 while ((trimMode & kTrimLeading) && HasPrefix(trimmed, toTrim, true)
495
5/6
✓ Branch 0 taken 288 times.
✓ Branch 1 taken 72 times.
✓ Branch 4 taken 216 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 216 times.
✓ Branch 7 taken 144 times.
 648 && (trimmed.size() > toTrim.size())) {
496
1/2
✓ Branch 2 taken 216 times.
✗ Branch 3 not taken.
 216 trimmed = trimmed.substr(toTrim.size());
497 }
498
3/4
✓ Branch 1 taken 216 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 144 times.
✓ Branch 4 taken 72 times.
 360 while ((trimMode & kTrimTrailing) && HasSuffix(trimmed, toTrim, true)
499
5/6
✓ Branch 0 taken 216 times.
✓ Branch 1 taken 72 times.
✓ Branch 4 taken 144 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 144 times.
✓ Branch 7 taken 144 times.
 504 && (trimmed.size() > toTrim.size())) {
500
1/2
✓ Branch 3 taken 144 times.
✗ Branch 4 not taken.
 144 trimmed = trimmed.substr(0, trimmed.size() - toTrim.size());
501 }
502 }
503 144 return trimmed;
504 }
505
506 /**
507 * Converts all characters to upper case
508 */
509 4365 string ToUpper(const string &mixed_case) {
510 4365 string result(mixed_case);
511
2/2
✓ Branch 1 taken 9941 times.
✓ Branch 2 taken 4365 times.
 14306 for (unsigned i = 0, l = result.length(); i < l; ++i) {
512
2/4
✓ Branch 1 taken 9941 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 9941 times.
✗ Branch 5 not taken.
 9941 result[i] = static_cast<char>(toupper(result[i]));
513 }
514 4365 return result;
515 }
516
517 4279 string ReplaceAll(const string &haystack, const string &needle,
518 const string &replace_by) {
519 4279 string result(haystack);
520 4279 size_t pos = 0;
521 4279 const unsigned needle_size = needle.size();
522
2/2
✓ Branch 1 taken 20 times.
✓ Branch 2 taken 4259 times.
 4279 if (needle == "")
523 20 return result;
524
525
2/2
✓ Branch 1 taken 2567 times.
✓ Branch 2 taken 4259 times.
 6826 while ((pos = result.find(needle, pos)) != string::npos)
526
1/2
✓ Branch 1 taken 2567 times.
✗ Branch 2 not taken.
 2567 result.replace(pos, needle_size, replace_by);
527 4259 return result;
528 }
529
530 406065 static inline void Base64Block(const unsigned char input[3], const char *table,
531 char output[4]) {
532 406065 output[0] = table[(input[0] & 0xFD) >> 2];
533 406065 output[1] = table[((input[0] & 0x03) << 4) | ((input[1] & 0xF0) >> 4)];
534 406065 output[2] = table[((input[1] & 0x0F) << 2) | ((input[2] & 0xD0) >> 6)];
535 406065 output[3] = table[input[2] & 0x3F];
536 406065 }
537
538 46046 string Base64(const string &data) {
539 46046 string result;
540
1/2
✓ Branch 2 taken 46046 times.
✗ Branch 3 not taken.
 46046 result.reserve((data.length() + 3) * 4 / 3);
541 46046 unsigned pos = 0;
542 const unsigned char *data_ptr = reinterpret_cast<const unsigned char *>(
543 46046 data.data());
544 46046 const unsigned length = data.length();
545
2/2
✓ Branch 0 taken 360653 times.
✓ Branch 1 taken 46046 times.
 406699 while (pos + 2 < length) {
546 char encoded_block[4];
547 360653 Base64Block(data_ptr + pos, b64_table, encoded_block);
548
1/2
✓ Branch 1 taken 360653 times.
✗ Branch 2 not taken.
 360653 result.append(encoded_block, 4);
549 360653 pos += 3;
550 }
551
2/2
✓ Branch 0 taken 45412 times.
✓ Branch 1 taken 634 times.
 46046 if (length % 3 != 0) {
552 unsigned char input[3];
553 45412 input[0] = data_ptr[pos];
554
2/2
✓ Branch 0 taken 30242 times.
✓ Branch 1 taken 15170 times.
 45412 input[1] = ((length % 3) == 2) ? data_ptr[pos + 1] : 0;
555 45412 input[2] = 0;
556 char encoded_block[4];
557 45412 Base64Block(input, b64_table, encoded_block);
558
1/2
✓ Branch 1 taken 45412 times.
✗ Branch 2 not taken.
 45412 result.append(encoded_block, 2);
559
3/4
✓ Branch 0 taken 30242 times.
✓ Branch 1 taken 15170 times.
✓ Branch 3 taken 45412 times.
✗ Branch 4 not taken.
 45412 result.push_back(((length % 3) == 2) ? encoded_block[2] : '=');
560
1/2
✓ Branch 1 taken 45412 times.
✗ Branch 2 not taken.
 45412 result.push_back('=');
561 }
562
563 46046 return result;
564 }
565
566 /**
567 * Safe encoding for URIs and path names: replace + by - and / by _
568 */
569 220 string Base64Url(const string &data) {
570 220 string base64 = Base64(data);
571
2/2
✓ Branch 1 taken 15920 times.
✓ Branch 2 taken 220 times.
 16140 for (unsigned i = 0, l = base64.length(); i < l; ++i) {
572
3/4
✓ Branch 1 taken 15920 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 216 times.
✓ Branch 4 taken 15704 times.
 15920 if (base64[i] == '+') {
573
1/2
✓ Branch 1 taken 216 times.
✗ Branch 2 not taken.
 216 base64[i] = '-';
574
3/4
✓ Branch 1 taken 15704 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 144 times.
✓ Branch 4 taken 15560 times.
 15704 } else if (base64[i] == '/') {
575
1/2
✓ Branch 1 taken 144 times.
✗ Branch 2 not taken.
 144 base64[i] = '_';
576 }
577 }
578 220 return base64;
579 }
580
581 1180716 static bool Debase64Block(const unsigned char input[4],
582 unsigned char output[3]) {
583 int32_t dec[4];
584
2/2
✓ Branch 0 taken 4722756 times.
✓ Branch 1 taken 1180680 times.
 5903436 for (int i = 0; i < 4; ++i) {
585 4722756 dec[i] = db64_table[input[i]];
586
2/2
✓ Branch 0 taken 36 times.
✓ Branch 1 taken 4722720 times.
 4722756 if (dec[i] < 0)
587 36 return false;
588 }
589
590 1180680 output[0] = (dec[0] << 2) | (dec[1] >> 4);
591 1180680 output[1] = ((dec[1] & 0x0F) << 4) | (dec[2] >> 2);
592 1180680 output[2] = ((dec[2] & 0x03) << 6) | dec[3];
593 1180680 return true;
594 }
595
596 /**
597 * Can decode both base64 and base64url
598 */
599 5819 bool Debase64(const string &data, string *decoded) {
600 5819 decoded->clear();
601 5819 decoded->reserve((data.length() + 4) * 3 / 4);
602 5819 unsigned pos = 0;
603 const unsigned char *data_ptr = reinterpret_cast<const unsigned char *>(
604 5819 data.data());
605 5819 const unsigned length = data.length();
606
2/2
✓ Branch 0 taken 36 times.
✓ Branch 1 taken 5783 times.
 5819 if (length == 0)
607 36 return true;
608
2/2
✓ Branch 0 taken 72 times.
✓ Branch 1 taken 5711 times.
 5783 if ((length % 4) != 0)
609 72 return false;
610
611
2/2
✓ Branch 0 taken 1180716 times.
✓ Branch 1 taken 5675 times.
 1186391 while (pos < length) {
612 unsigned char decoded_block[3];
613 1180716 const bool retval = Debase64Block(data_ptr + pos, decoded_block);
614
2/2
✓ Branch 0 taken 36 times.
✓ Branch 1 taken 1180680 times.
 1180716 if (!retval)
615 36 return false;
616
1/2
✓ Branch 1 taken 1180680 times.
✗ Branch 2 not taken.
 1180680 decoded->append(reinterpret_cast<char *>(decoded_block), 3);
617 1180680 pos += 4;
618 }
619
620
2/2
✓ Branch 0 taken 11350 times.
✓ Branch 1 taken 5675 times.
 17025 for (int i = 0; i < 2; ++i) {
621 11350 pos--;
622
2/2
✓ Branch 1 taken 1957 times.
✓ Branch 2 taken 9393 times.
 11350 if (data[pos] == '=')
623 1957 decoded->erase(decoded->length() - 1);
624 }
625 5675 return true;
626 }
627
628 /**
629 * Assumes that source is terminated by a newline
630 */
631 70 string Tail(const string &source, unsigned num_lines) {
632
6/6
✓ Branch 1 taken 50 times.
✓ Branch 2 taken 20 times.
✓ Branch 3 taken 10 times.
✓ Branch 4 taken 40 times.
✓ Branch 5 taken 30 times.
✓ Branch 6 taken 40 times.
 70 if (source.empty() || (num_lines == 0))
633
1/2
✓ Branch 2 taken 30 times.
✗ Branch 3 not taken.
 30 return "";
634
635 40 const int l = static_cast<int>(source.length());
636 40 int i = l - 1;
637
2/2
✓ Branch 0 taken 160 times.
✓ Branch 1 taken 30 times.
 190 for (; i >= 0; --i) {
638 160 const char c = source.data()[i];
639
2/2
✓ Branch 0 taken 50 times.
✓ Branch 1 taken 110 times.
 160 if (c == '\n') {
640
2/2
✓ Branch 0 taken 10 times.
✓ Branch 1 taken 40 times.
 50 if (num_lines == 0) {
641 10 return source.substr(i + 1);
642 }
643 40 num_lines--;
644 }
645 }
646 30 return source;
647 }
648
649 /**
650 * Get UTC Time.
651 *
652 * @param format format if timestamp (YYYY-MM-DD HH:MM:SS by default)
653 * @return a timestamp string on success, empty string on failure
654 */
655 ✗ std::string GetGMTimestamp(const std::string &format) {
656 struct tm time_ptr;
657 char date_and_time[100];
658 ✗ const time_t t = time(NULL);
659 ✗ gmtime_r(&t, &time_ptr); // take UTC
660 // return empty string if formatting fails
661 ✗ if (!strftime(date_and_time, 100, format.c_str(), &time_ptr)) {
662 ✗ return "";
663 }
664 ✗ std::string timestamp(date_and_time);
665 ✗ return timestamp;
666 }
667
668 #ifdef CVMFS_NAMESPACE_GUARD
669 } // namespace CVMFS_NAMESPACE_GUARD
670 #endif
671