CernVM-FS  2.12.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
string.cc
Go to the documentation of this file.
1 
7 #ifndef __STDC_FORMAT_MACROS
8 // NOLINTNEXTLINE
9 #define __STDC_FORMAT_MACROS
10 #endif
11 
12 #include "string.h"
13 #include "cvmfs_config.h"
14 
15 #include <errno.h>
16 #include <fcntl.h>
17 #include <inttypes.h>
18 #include <stdint.h>
19 #include <unistd.h>
20 
21 #include <cstdio>
22 #include <cstdlib>
23 #include <cstring>
24 #include <ctime>
25 #include <string>
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 
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 
68  bool operator()(const std::string::value_type a,
69  const std::string::value_type b) const {
70  return std::tolower(a) == std::tolower(b);
71  }
72 };
73 
74 } // anonymous namespace
75 
76 string StringifyBool(const bool value) { return value ? "yes" : "no"; }
77 
78 string StringifyInt(const int64_t value) {
79  char buffer[48];
80  snprintf(buffer, sizeof(buffer), "%" PRId64, value);
81  return string(buffer);
82 }
83 
84 std::string StringifyUint(const uint64_t value) {
85  char buffer[48];
86  snprintf(buffer, sizeof(buffer), "%" PRIu64, value);
87  return string(buffer);
88 }
89 
90 string StringifyByteAsHex(const unsigned char value) {
91  char buffer[3];
92  snprintf(buffer, sizeof(buffer), "%02x", value);
93  return string(buffer);
94 }
95 
96 string StringifyDouble(const double value) {
97  char buffer[64];
98  snprintf(buffer, sizeof(buffer), "%.03f", value);
99  return string(buffer);
100 }
101 
105 string StringifyTime(const time_t seconds, const bool utc) {
106  struct tm timestamp;
107  if (utc) {
108  localtime_r(&seconds, &timestamp);
109  } else {
110  gmtime_r(&seconds, &timestamp);
111  }
112 
113  const char *months[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
114  "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
115  char buffer[21];
116  snprintf(buffer, sizeof(buffer), "%d %s %d %02d:%02d:%02d", timestamp.tm_mday,
117  months[timestamp.tm_mon], timestamp.tm_year + 1900,
118  timestamp.tm_hour, timestamp.tm_min, timestamp.tm_sec);
119 
120  return string(buffer);
121 }
122 
123 
127 std::string RfcTimestamp() {
128  const char *months[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
129  "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
130  const char *day_of_week[] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
131 
132  struct tm timestamp;
133  time_t now = time(NULL);
134  gmtime_r(&now, &timestamp);
135 
136  char buffer[30];
137  snprintf(buffer, sizeof(buffer), "%s, %02d %s %d %02d:%02d:%02d %s",
138  day_of_week[timestamp.tm_wday], timestamp.tm_mday,
139  months[timestamp.tm_mon], timestamp.tm_year + 1900,
140  timestamp.tm_hour, timestamp.tm_min, timestamp.tm_sec,
141  timestamp.tm_zone);
142  return string(buffer);
143 }
144 
145 
149 std::string IsoTimestamp() {
150  struct tm timestamp;
151  time_t now = time(NULL);
152  gmtime_r(&now, &timestamp);
153 
154  char buffer[17];
155  snprintf(buffer, sizeof(buffer), "%04d%02d%02dT%02d%02d%02dZ",
156  timestamp.tm_year + 1900,
157  timestamp.tm_mon + 1,
158  timestamp.tm_mday,
159  timestamp.tm_hour,
160  timestamp.tm_min,
161  timestamp.tm_sec);
162  return string(buffer);
163 }
164 
165 
169 std::string WhitelistTimestamp(time_t when) {
170  struct tm timestamp;
171  gmtime_r(&when, &timestamp);
172 
173  char buffer[15];
174  snprintf(buffer, sizeof(buffer), "%04d%02d%02d%02d%02d%02d",
175  timestamp.tm_year + 1900,
176  timestamp.tm_mon + 1,
177  timestamp.tm_mday,
178  timestamp.tm_hour,
179  timestamp.tm_min,
180  timestamp.tm_sec);
181  return string(buffer);
182 }
183 
184 
185 string StringifyTimeval(const timeval value) {
186  char buffer[64];
187  int64_t msec = value.tv_sec * 1000;
188  msec += value.tv_usec / 1000;
189  snprintf(buffer, sizeof(buffer), "%" PRId64 ".%03d", msec,
190  static_cast<int>(value.tv_usec % 1000));
191  return string(buffer);
192 }
193 
198 time_t IsoTimestamp2UtcTime(const std::string &iso8601) {
199  time_t utc_time = 0;
200  unsigned length = iso8601.length();
201 
202  if (length != 20) return utc_time;
203  if ((iso8601[4] != '-') || (iso8601[7] != '-') || (iso8601[10] != 'T') ||
204  (iso8601[13] != ':') || (iso8601[16] != ':') || (iso8601[19] != 'Z')) {
205  return utc_time;
206  }
207 
208  struct tm tm_wl;
209  memset(&tm_wl, 0, sizeof(struct tm));
210  tm_wl.tm_year = static_cast<int>(String2Int64(iso8601.substr(0, 4))) - 1900;
211  tm_wl.tm_mon = static_cast<int>(String2Int64(iso8601.substr(5, 2))) - 1;
212  tm_wl.tm_mday = static_cast<int>(String2Int64(iso8601.substr(8, 2)));
213  tm_wl.tm_hour = static_cast<int>(String2Int64(iso8601.substr(11, 2)));
214  tm_wl.tm_min = static_cast<int>(String2Int64(iso8601.substr(14, 2)));
215  tm_wl.tm_sec = static_cast<int>(String2Int64(iso8601.substr(17, 2)));
216  utc_time = timegm(&tm_wl);
217  if (utc_time < 0) return 0;
218 
219  return utc_time;
220 }
221 
222 int64_t String2Int64(const string &value) {
223  int64_t result;
224  sscanf(value.c_str(), "%" PRId64, &result);
225  return result;
226 }
227 
228 uint64_t String2Uint64(const string &value) {
229  uint64_t result;
230  if (sscanf(value.c_str(), "%" PRIu64, &result) == 1) {
231  return result;
232  }
233  return 0;
234 }
235 
245 bool String2Uint64Parse(const std::string &value, uint64_t *result) {
246  char *endptr = NULL;
247  errno = 0;
248  long long myval = strtoll(value.c_str(), &endptr, 10); // NOLINT
249  if ((value.size() == 0) || (endptr != (value.c_str() + value.size())) ||
250  (myval < 0)) {
251  errno = EINVAL;
252  return false;
253  }
254  if (errno) {
255  return false;
256  }
257  if (result) {
258  *result = myval;
259  }
260  return true;
261 }
262 
263 void String2Uint64Pair(const string &value, uint64_t *a, uint64_t *b) {
264  sscanf(value.c_str(), "%" PRIu64 " %" PRIu64, a, b);
265 }
266 
267 bool HasPrefix(const string &str, const string &prefix,
268  const bool ignore_case) {
269  if (prefix.length() > str.length()) return false;
270 
271  for (unsigned i = 0, l = prefix.length(); i < l; ++i) {
272  if (ignore_case) {
273  if (toupper(str[i]) != toupper(prefix[i])) return false;
274  } else {
275  if (str[i] != prefix[i]) return false;
276  }
277  }
278  return true;
279 }
280 
281 bool HasSuffix(const std::string &str, const std::string &suffix,
282  const bool ignore_case) {
283  if (suffix.size() > str.size()) return false;
284  const IgnoreCaseComperator icmp;
285  return (ignore_case)
286  ? std::equal(suffix.rbegin(), suffix.rend(), str.rbegin(), icmp)
287  : std::equal(suffix.rbegin(), suffix.rend(), str.rbegin());
288 }
289 
290 vector<string> SplitString(const string &str, char delim) {
291  return SplitStringBounded(0, str, delim);
292 }
293 
294 vector<string> SplitStringBounded(
295  unsigned max_chunks, const string &str, char delim)
296 {
297  vector<string> result;
298 
299  // edge case... one chunk is always the whole string
300  if (1 == max_chunks) {
301  result.push_back(str);
302  return result;
303  }
304 
305  // split the string
306  const unsigned size = str.size();
307  unsigned marker = 0;
308  unsigned chunks = 1;
309  unsigned i;
310  for (i = 0; i < size; ++i) {
311  if (str[i] == delim) {
312  result.push_back(str.substr(marker, i - marker));
313  marker = i + 1;
314 
315  // we got what we want... good bye
316  if (++chunks == max_chunks) break;
317  }
318  }
319 
320  // push the remainings of the string and return
321  result.push_back(str.substr(marker));
322  return result;
323 }
324 
325 string JoinStrings(const vector<string> &strings, const string &joint) {
326  string result = "";
327  const unsigned size = strings.size();
328 
329  if (size > 0) {
330  result = strings[0];
331  for (unsigned i = 1; i < size; ++i) result += joint + strings[i];
332  }
333 
334  return result;
335 }
336 
337 void ParseKeyvalMem(const unsigned char *buffer, const unsigned buffer_size,
338  map<char, string> *content) {
339  string line;
340  unsigned pos = 0;
341  while (pos < buffer_size) {
342  if (static_cast<char>(buffer[pos]) == '\n') {
343  if (line == "--") return;
344 
345  if (line != "") {
346  const string tail = (line.length() == 1) ? "" : line.substr(1);
347  // Special handling of 'Z' key because it can exist multiple times
348  if (line[0] != 'Z') {
349  (*content)[line[0]] = tail;
350  } else {
351  if (content->find(line[0]) == content->end()) {
352  (*content)[line[0]] = tail;
353  } else {
354  (*content)[line[0]] = (*content)[line[0]] + "|" + tail;
355  }
356  }
357  }
358  line = "";
359  } else {
360  line += static_cast<char>(buffer[pos]);
361  }
362  pos++;
363  }
364 }
365 
366 bool ParseKeyvalPath(const string &filename, map<char, string> *content) {
367  int fd = open(filename.c_str(), O_RDONLY);
368  if (fd < 0) return false;
369 
370  unsigned char buffer[4096];
371  ssize_t num_bytes = read(fd, buffer, sizeof(buffer));
372  close(fd);
373 
374  if ((num_bytes <= 0) || (unsigned(num_bytes) >= sizeof(buffer))) return false;
375 
376  ParseKeyvalMem(buffer, unsigned(num_bytes), content);
377  return true;
378 }
379 
380 string GetLineMem(const char *text, const int text_size) {
381  int pos = 0;
382  while ((pos < text_size) && (text[pos] != '\n')) pos++;
383  return string(text, pos);
384 }
385 
386 bool GetLineFile(FILE *f, std::string *line) {
387  int retval;
388  line->clear();
389  while (true) {
390  retval = fgetc(f);
391  if (ferror(f) && (errno == EINTR)) {
392  clearerr(f);
393  continue;
394  } else if (retval == EOF) {
395  break;
396  }
397  char c = static_cast<char>(retval);
398  if (c == '\n') break;
399  line->push_back(c);
400  }
401  return (retval != EOF) || !line->empty();
402 }
403 
404 bool GetLineFd(const int fd, std::string *line) {
405  ssize_t retval;
406  char c;
407  line->clear();
408  while (true) {
409  retval = read(fd, &c, 1);
410  if (retval == 0) {
411  break;
412  }
413  if ((retval == -1) && (errno == EINTR)) {
414  continue;
415  }
416  if (retval == -1) {
417  break;
418  }
419  if (c == '\n') break;
420  line->push_back(c);
421  }
422  return (retval == 1) || !line->empty();
423 }
424 
428 string Trim(const string &raw, bool trim_newline) {
429  if (raw.empty()) return "";
430 
431  unsigned start_pos = 0;
432  for (; (start_pos < raw.length()) &&
433  (raw[start_pos] == ' ' || raw[start_pos] == '\t' ||
434  (trim_newline && (raw[start_pos] == '\n' || raw[start_pos] == '\r')));
435  ++start_pos)
436  {
437  }
438  unsigned end_pos = raw.length() - 1; // at least one character in raw
439  for (;
440  (end_pos >= start_pos) &&
441  (raw[end_pos] == ' ' || raw[end_pos] == '\t' ||
442  (trim_newline && (raw[end_pos] == '\n' || raw[end_pos] == '\r')));
443  --end_pos)
444  {
445  }
446 
447  return raw.substr(start_pos, end_pos - start_pos + 1);
448 }
449 
450 std::string TrimString(
451  const std::string& path,
452  const std::string& toTrim,
453  const int trimMode)
454 {
455  std::string trimmed = path;
456  if (trimmed != toTrim) {
457  while ((trimMode & kTrimLeading) &&
458  HasPrefix(trimmed, toTrim, true) &&
459  (trimmed.size() > toTrim.size()))
460  {
461  trimmed = trimmed.substr(toTrim.size());
462  }
463  while ((trimMode & kTrimTrailing) &&
464  HasSuffix(trimmed, toTrim, true) &&
465  (trimmed.size() > toTrim.size()))
466  {
467  trimmed = trimmed.substr(0, trimmed.size() - toTrim.size());
468  }
469  }
470  return trimmed;
471 }
472 
476 string ToUpper(const string &mixed_case) {
477  string result(mixed_case);
478  for (unsigned i = 0, l = result.length(); i < l; ++i) {
479  result[i] = static_cast<char>(toupper(result[i]));
480  }
481  return result;
482 }
483 
484 string ReplaceAll(const string &haystack, const string &needle,
485  const string &replace_by) {
486  string result(haystack);
487  size_t pos = 0;
488  const unsigned needle_size = needle.size();
489  if (needle == "") return result;
490 
491  while ((pos = result.find(needle, pos)) != string::npos)
492  result.replace(pos, needle_size, replace_by);
493  return result;
494 }
495 
496 static inline void Base64Block(const unsigned char input[3], const char *table,
497  char output[4]) {
498  output[0] = table[(input[0] & 0xFD) >> 2];
499  output[1] = table[((input[0] & 0x03) << 4) | ((input[1] & 0xF0) >> 4)];
500  output[2] = table[((input[1] & 0x0F) << 2) | ((input[2] & 0xD0) >> 6)];
501  output[3] = table[input[2] & 0x3F];
502 }
503 
504 string Base64(const string &data) {
505  string result;
506  result.reserve((data.length() + 3) * 4 / 3);
507  unsigned pos = 0;
508  const unsigned char *data_ptr =
509  reinterpret_cast<const unsigned char *>(data.data());
510  const unsigned length = data.length();
511  while (pos + 2 < length) {
512  char encoded_block[4];
513  Base64Block(data_ptr + pos, b64_table, encoded_block);
514  result.append(encoded_block, 4);
515  pos += 3;
516  }
517  if (length % 3 != 0) {
518  unsigned char input[3];
519  input[0] = data_ptr[pos];
520  input[1] = ((length % 3) == 2) ? data_ptr[pos + 1] : 0;
521  input[2] = 0;
522  char encoded_block[4];
523  Base64Block(input, b64_table, encoded_block);
524  result.append(encoded_block, 2);
525  result.push_back(((length % 3) == 2) ? encoded_block[2] : '=');
526  result.push_back('=');
527  }
528 
529  return result;
530 }
531 
535 string Base64Url(const string &data) {
536  string base64 = Base64(data);
537  for (unsigned i = 0, l = base64.length(); i < l; ++i) {
538  if (base64[i] == '+') {
539  base64[i] = '-';
540  } else if (base64[i] == '/') {
541  base64[i] = '_';
542  }
543  }
544  return base64;
545 }
546 
547 static bool Debase64Block(const unsigned char input[4], unsigned char output[3])
548 {
549  int32_t dec[4];
550  for (int i = 0; i < 4; ++i) {
551  dec[i] = db64_table[input[i]];
552  if (dec[i] < 0) return false;
553  }
554 
555  output[0] = (dec[0] << 2) | (dec[1] >> 4);
556  output[1] = ((dec[1] & 0x0F) << 4) | (dec[2] >> 2);
557  output[2] = ((dec[2] & 0x03) << 6) | dec[3];
558  return true;
559 }
560 
564 bool Debase64(const string &data, string *decoded) {
565  decoded->clear();
566  decoded->reserve((data.length() + 4) * 3 / 4);
567  unsigned pos = 0;
568  const unsigned char *data_ptr =
569  reinterpret_cast<const unsigned char *>(data.data());
570  const unsigned length = data.length();
571  if (length == 0) return true;
572  if ((length % 4) != 0) return false;
573 
574  while (pos < length) {
575  unsigned char decoded_block[3];
576  bool retval = Debase64Block(data_ptr + pos, decoded_block);
577  if (!retval) return false;
578  decoded->append(reinterpret_cast<char *>(decoded_block), 3);
579  pos += 4;
580  }
581 
582  for (int i = 0; i < 2; ++i) {
583  pos--;
584  if (data[pos] == '=') decoded->erase(decoded->length() - 1);
585  }
586  return true;
587 }
588 
592 string Tail(const string &source, unsigned num_lines) {
593  if (source.empty() || (num_lines == 0)) return "";
594 
595  int l = static_cast<int>(source.length());
596  int i = l - 1;
597  for (; i >= 0; --i) {
598  char c = source.data()[i];
599  if (c == '\n') {
600  if (num_lines == 0) {
601  return source.substr(i + 1);
602  }
603  num_lines--;
604  }
605  }
606  return source;
607 }
608 
615 std::string GetGMTimestamp(const std::string &format) {
616  struct tm time_ptr;
617  char date_and_time[100];
618  time_t t = time(NULL);
619  gmtime_r(&t, &time_ptr); // take UTC
620  // return empty string if formatting fails
621  if (!strftime(date_and_time, 100, format.c_str(), &time_ptr)) {
622  return "";
623  }
624  std::string timestamp(date_and_time);
625  return timestamp;
626 }
627 
628 #ifdef CVMFS_NAMESPACE_GUARD
629 } // namespace CVMFS_NAMESPACE_GUARD
630 #endif
string GetLineMem(const char *text, const int text_size)
Definition: string.cc:380
std::string GetGMTimestamp(const std::string &format)
Definition: string.cc:615
std::string IsoTimestamp()
Definition: string.cc:149
string Trim(const string &raw, bool trim_newline)
Definition: string.cc:428
string ReplaceAll(const string &haystack, const string &needle, const string &replace_by)
Definition: string.cc:484
static void Base64Block(const unsigned char input[3], const char *table, char output[4])
Definition: string.cc:496
string JoinStrings(const vector< string > &strings, const string &joint)
Definition: string.cc:325
const int kTrimLeading
Definition: string.h:19
string Tail(const string &source, unsigned num_lines)
Definition: string.cc:592
const int kTrimTrailing
Definition: string.h:20
string StringifyTime(const time_t seconds, const bool utc)
Definition: string.cc:105
string StringifyDouble(const double value)
Definition: string.cc:96
std::string StringifyUint(const uint64_t value)
Definition: string.cc:84
bool Debase64(const string &data, string *decoded)
Definition: string.cc:564
string StringifyByteAsHex(const unsigned char value)
Definition: string.cc:90
string StringifyBool(const bool value)
Definition: string.cc:76
bool String2Uint64Parse(const std::string &value, uint64_t *result)
Definition: string.cc:245
string Base64Url(const string &data)
Definition: string.cc:535
std::string RfcTimestamp()
Definition: string.cc:127
int64_t String2Int64(const string &value)
Definition: string.cc:222
bool GetLineFile(FILE *f, std::string *line)
Definition: string.cc:386
string ToUpper(const string &mixed_case)
Definition: string.cc:476
vector< string > SplitString(const string &str, char delim)
Definition: string.cc:290
bool HasSuffix(const std::string &str, const std::string &suffix, const bool ignore_case)
Definition: string.cc:281
std::string WhitelistTimestamp(time_t when)
Definition: string.cc:169
vector< string > SplitStringBounded(unsigned max_chunks, const string &str, char delim)
Definition: string.cc:294
string StringifyInt(const int64_t value)
Definition: string.cc:78
bool HasPrefix(const string &str, const string &prefix, const bool ignore_case)
Definition: string.cc:267
const int const char * format
Definition: logging.h:23
time_t IsoTimestamp2UtcTime(const std::string &iso8601)
Definition: string.cc:198
bool GetLineFd(const int fd, std::string *line)
Definition: string.cc:404
string Base64(const string &data)
Definition: string.cc:504
uint64_t String2Uint64(const string &value)
Definition: string.cc:228
bool operator()(const std::string::value_type a, const std::string::value_type b) const
Definition: string.cc:68
bool ParseKeyvalPath(const string &filename, map< char, string > *content)
Definition: string.cc:366
std::string TrimString(const std::string &path, const std::string &toTrim, const int trimMode)
Definition: string.cc:450
static bool Debase64Block(const unsigned char input[4], unsigned char output[3])
Definition: string.cc:547
const char b64_table[]
Definition: string.cc:33
string StringifyTimeval(const timeval value)
Definition: string.cc:185
const int8_t db64_table[]
Definition: string.cc:43
static void size_t size
Definition: smalloc.h:54
void ParseKeyvalMem(const unsigned char *buffer, const unsigned buffer_size, map< char, string > *content)
Definition: string.cc:337
void String2Uint64Pair(const string &value, uint64_t *a, uint64_t *b)
Definition: string.cc:263