henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2004 The WebRTC Project Authors. All rights reserved. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license |
| 5 | * that can be found in the LICENSE file in the root of the source |
| 6 | * tree. An additional intellectual property rights grant can be found |
| 7 | * in the file PATENTS. All contributing project authors may |
| 8 | * be found in the AUTHORS file in the root of the source tree. |
| 9 | */ |
| 10 | |
Steve Anton | 10542f2 | 2019-01-11 17:11:00 | [diff] [blame] | 11 | #include "rtc_base/string_encode.h" |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 | [diff] [blame] | 12 | |
Yves Gerey | 988cc08 | 2018-10-23 10:03:01 | [diff] [blame] | 13 | #include <cstdio> |
| 14 | |
Ali Tofigh | 7fa9057 | 2022-03-17 14:47:49 | [diff] [blame] | 15 | #include "absl/strings/string_view.h" |
Ali Tofigh | fd6a4d6 | 2022-03-31 08:36:48 | [diff] [blame] | 16 | #include "api/array_view.h" |
Jonas Olsson | 6b1985d | 2018-07-05 09:59:48 | [diff] [blame] | 17 | #include "rtc_base/arraysize.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 04:47:31 | [diff] [blame] | 18 | #include "rtc_base/checks.h" |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 | [diff] [blame] | 19 | |
| 20 | namespace rtc { |
| 21 | |
| 22 | ///////////////////////////////////////////////////////////////////////////// |
| 23 | // String Encoding Utilities |
| 24 | ///////////////////////////////////////////////////////////////////////////// |
| 25 | |
Niels Möller | e7e3601 | 2019-05-23 10:10:26 | [diff] [blame] | 26 | namespace { |
| 27 | const char HEX[] = "0123456789abcdef"; |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 | [diff] [blame] | 28 | |
Niels Möller | e7e3601 | 2019-05-23 10:10:26 | [diff] [blame] | 29 | // Convert an unsigned value from 0 to 15 to the hex character equivalent... |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 | [diff] [blame] | 30 | char hex_encode(unsigned char val) { |
henrikg | 91d6ede | 2015-09-17 07:24:34 | [diff] [blame] | 31 | RTC_DCHECK_LT(val, 16); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 | [diff] [blame] | 32 | return (val < 16) ? HEX[val] : '!'; |
| 33 | } |
| 34 | |
Niels Möller | e7e3601 | 2019-05-23 10:10:26 | [diff] [blame] | 35 | // ...and vice-versa. |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 | [diff] [blame] | 36 | bool hex_decode(char ch, unsigned char* val) { |
| 37 | if ((ch >= '0') && (ch <= '9')) { |
| 38 | *val = ch - '0'; |
Niels Möller | 12048c7 | 2018-10-29 11:58:48 | [diff] [blame] | 39 | } else if ((ch >= 'A') && (ch <= 'F')) { |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 | [diff] [blame] | 40 | *val = (ch - 'A') + 10; |
Niels Möller | 12048c7 | 2018-10-29 11:58:48 | [diff] [blame] | 41 | } else if ((ch >= 'a') && (ch <= 'f')) { |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 | [diff] [blame] | 42 | *val = (ch - 'a') + 10; |
| 43 | } else { |
| 44 | return false; |
| 45 | } |
| 46 | return true; |
| 47 | } |
| 48 | |
Niels Möller | f25df35 | 2019-05-24 07:14:13 | [diff] [blame] | 49 | size_t hex_encode_output_length(size_t srclen, char delimiter) { |
| 50 | return delimiter && srclen > 0 ? (srclen * 3 - 1) : (srclen * 2); |
| 51 | } |
| 52 | |
| 53 | // hex_encode shows the hex representation of binary data in ascii, with |
Artem Titov | 96e3b99 | 2021-07-26 14:03:14 | [diff] [blame] | 54 | // `delimiter` between bytes, or none if `delimiter` == 0. |
Niels Möller | f25df35 | 2019-05-24 07:14:13 | [diff] [blame] | 55 | void hex_encode_with_delimiter(char* buffer, |
Ali Tofigh | fd6a4d6 | 2022-03-31 08:36:48 | [diff] [blame] | 56 | absl::string_view source, |
Niels Möller | f25df35 | 2019-05-24 07:14:13 | [diff] [blame] | 57 | char delimiter) { |
| 58 | RTC_DCHECK(buffer); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 | [diff] [blame] | 59 | |
| 60 | // Init and check bounds. |
| 61 | const unsigned char* bsource = |
Ali Tofigh | fd6a4d6 | 2022-03-31 08:36:48 | [diff] [blame] | 62 | reinterpret_cast<const unsigned char*>(source.data()); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 | [diff] [blame] | 63 | size_t srcpos = 0, bufpos = 0; |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 | [diff] [blame] | 64 | |
Ali Tofigh | fd6a4d6 | 2022-03-31 08:36:48 | [diff] [blame] | 65 | size_t srclen = source.length(); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 | [diff] [blame] | 66 | while (srcpos < srclen) { |
| 67 | unsigned char ch = bsource[srcpos++]; |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 68 | buffer[bufpos] = hex_encode((ch >> 4) & 0xF); |
| 69 | buffer[bufpos + 1] = hex_encode((ch)&0xF); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 | [diff] [blame] | 70 | bufpos += 2; |
| 71 | |
| 72 | // Don't write a delimiter after the last byte. |
| 73 | if (delimiter && (srcpos < srclen)) { |
| 74 | buffer[bufpos] = delimiter; |
| 75 | ++bufpos; |
| 76 | } |
| 77 | } |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 | [diff] [blame] | 78 | } |
| 79 | |
Niels Möller | e7e3601 | 2019-05-23 10:10:26 | [diff] [blame] | 80 | } // namespace |
| 81 | |
Ali Tofigh | 7fa9057 | 2022-03-17 14:47:49 | [diff] [blame] | 82 | std::string hex_encode(absl::string_view str) { |
Ali Tofigh | fd6a4d6 | 2022-03-31 08:36:48 | [diff] [blame] | 83 | return hex_encode_with_delimiter(str, 0); |
Peter Thatcher | 1cf6f81 | 2015-05-15 17:40:45 | [diff] [blame] | 84 | } |
| 85 | |
Ali Tofigh | fd6a4d6 | 2022-03-31 08:36:48 | [diff] [blame] | 86 | std::string hex_encode_with_delimiter(absl::string_view source, |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 | [diff] [blame] | 87 | char delimiter) { |
Ali Tofigh | fd6a4d6 | 2022-03-31 08:36:48 | [diff] [blame] | 88 | std::string s(hex_encode_output_length(source.length(), delimiter), 0); |
| 89 | hex_encode_with_delimiter(&s[0], source, delimiter); |
Niels Möller | f25df35 | 2019-05-24 07:14:13 | [diff] [blame] | 90 | return s; |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 | [diff] [blame] | 91 | } |
| 92 | |
Ali Tofigh | fd6a4d6 | 2022-03-31 08:36:48 | [diff] [blame] | 93 | size_t hex_decode_with_delimiter(ArrayView<char> cbuffer, |
| 94 | absl::string_view source, |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 | [diff] [blame] | 95 | char delimiter) { |
Ali Tofigh | fd6a4d6 | 2022-03-31 08:36:48 | [diff] [blame] | 96 | if (cbuffer.empty()) |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 | [diff] [blame] | 97 | return 0; |
| 98 | |
| 99 | // Init and bounds check. |
Ali Tofigh | fd6a4d6 | 2022-03-31 08:36:48 | [diff] [blame] | 100 | unsigned char* bbuffer = reinterpret_cast<unsigned char*>(cbuffer.data()); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 | [diff] [blame] | 101 | size_t srcpos = 0, bufpos = 0; |
Ali Tofigh | fd6a4d6 | 2022-03-31 08:36:48 | [diff] [blame] | 102 | size_t srclen = source.length(); |
| 103 | |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 | [diff] [blame] | 104 | size_t needed = (delimiter) ? (srclen + 1) / 3 : srclen / 2; |
Ali Tofigh | fd6a4d6 | 2022-03-31 08:36:48 | [diff] [blame] | 105 | if (cbuffer.size() < needed) |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 | [diff] [blame] | 106 | return 0; |
| 107 | |
| 108 | while (srcpos < srclen) { |
| 109 | if ((srclen - srcpos) < 2) { |
| 110 | // This means we have an odd number of bytes. |
| 111 | return 0; |
| 112 | } |
| 113 | |
| 114 | unsigned char h1, h2; |
| 115 | if (!hex_decode(source[srcpos], &h1) || |
| 116 | !hex_decode(source[srcpos + 1], &h2)) |
| 117 | return 0; |
| 118 | |
| 119 | bbuffer[bufpos++] = (h1 << 4) | h2; |
| 120 | srcpos += 2; |
| 121 | |
| 122 | // Remove the delimiter if needed. |
| 123 | if (delimiter && (srclen - srcpos) > 1) { |
| 124 | if (source[srcpos] != delimiter) |
| 125 | return 0; |
| 126 | ++srcpos; |
| 127 | } |
| 128 | } |
| 129 | |
| 130 | return bufpos; |
| 131 | } |
| 132 | |
Ali Tofigh | fd6a4d6 | 2022-03-31 08:36:48 | [diff] [blame] | 133 | size_t hex_decode(ArrayView<char> buffer, absl::string_view source) { |
| 134 | return hex_decode_with_delimiter(buffer, source, 0); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 | [diff] [blame] | 135 | } |
| 136 | |
Niels Möller | 4420380 | 2021-09-16 13:39:16 | [diff] [blame] | 137 | size_t tokenize(absl::string_view source, |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 138 | char delimiter, |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 | [diff] [blame] | 139 | std::vector<std::string>* fields) { |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 | [diff] [blame] | 140 | fields->clear(); |
| 141 | size_t last = 0; |
| 142 | for (size_t i = 0; i < source.length(); ++i) { |
| 143 | if (source[i] == delimiter) { |
| 144 | if (i != last) { |
Niels Möller | 4420380 | 2021-09-16 13:39:16 | [diff] [blame] | 145 | fields->emplace_back(source.substr(last, i - last)); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 | [diff] [blame] | 146 | } |
| 147 | last = i + 1; |
| 148 | } |
| 149 | } |
| 150 | if (last != source.length()) { |
Niels Möller | 4420380 | 2021-09-16 13:39:16 | [diff] [blame] | 151 | fields->emplace_back(source.substr(last, source.length() - last)); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 | [diff] [blame] | 152 | } |
| 153 | return fields->size(); |
| 154 | } |
| 155 | |
Niels Möller | 4420380 | 2021-09-16 13:39:16 | [diff] [blame] | 156 | bool tokenize_first(absl::string_view source, |
Donald Curtis | 144d018 | 2015-05-15 20:14:24 | [diff] [blame] | 157 | const char delimiter, |
| 158 | std::string* token, |
| 159 | std::string* rest) { |
Donald Curtis | 0e07f92 | 2015-05-15 16:21:23 | [diff] [blame] | 160 | // Find the first delimiter |
| 161 | size_t left_pos = source.find(delimiter); |
Ali Tofigh | 7fa9057 | 2022-03-17 14:47:49 | [diff] [blame] | 162 | if (left_pos == absl::string_view::npos) { |
Donald Curtis | 0e07f92 | 2015-05-15 16:21:23 | [diff] [blame] | 163 | return false; |
| 164 | } |
| 165 | |
| 166 | // Look for additional occurrances of delimiter. |
| 167 | size_t right_pos = left_pos + 1; |
Niels Möller | 4420380 | 2021-09-16 13:39:16 | [diff] [blame] | 168 | while (right_pos < source.size() && source[right_pos] == delimiter) { |
Donald Curtis | 0e07f92 | 2015-05-15 16:21:23 | [diff] [blame] | 169 | right_pos++; |
| 170 | } |
| 171 | |
Niels Möller | 4420380 | 2021-09-16 13:39:16 | [diff] [blame] | 172 | *token = std::string(source.substr(0, left_pos)); |
| 173 | *rest = std::string(source.substr(right_pos)); |
Donald Curtis | 0e07f92 | 2015-05-15 16:21:23 | [diff] [blame] | 174 | return true; |
| 175 | } |
| 176 | |
Niels Möller | 2d3186e | 2022-01-24 13:15:03 | [diff] [blame] | 177 | std::vector<absl::string_view> split(absl::string_view source, char delimiter) { |
| 178 | std::vector<absl::string_view> fields; |
| 179 | size_t last = 0; |
| 180 | for (size_t i = 0; i < source.length(); ++i) { |
| 181 | if (source[i] == delimiter) { |
| 182 | fields.push_back(source.substr(last, i - last)); |
| 183 | last = i + 1; |
| 184 | } |
| 185 | } |
| 186 | fields.push_back(source.substr(last)); |
| 187 | return fields; |
| 188 | } |
| 189 | |
Jonas Olsson | 6b1985d | 2018-07-05 09:59:48 | [diff] [blame] | 190 | std::string ToString(const bool b) { |
| 191 | return b ? "true" : "false"; |
| 192 | } |
| 193 | |
Ali Tofigh | fd6a4d6 | 2022-03-31 08:36:48 | [diff] [blame] | 194 | std::string ToString(absl::string_view s) { |
Jonas Olsson | 6b1985d | 2018-07-05 09:59:48 | [diff] [blame] | 195 | return std::string(s); |
| 196 | } |
Ali Tofigh | 7fa9057 | 2022-03-17 14:47:49 | [diff] [blame] | 197 | |
Ali Tofigh | fd6a4d6 | 2022-03-31 08:36:48 | [diff] [blame] | 198 | std::string ToString(const char* s) { |
Ali Tofigh | 7fa9057 | 2022-03-17 14:47:49 | [diff] [blame] | 199 | return std::string(s); |
Jonas Olsson | 6b1985d | 2018-07-05 09:59:48 | [diff] [blame] | 200 | } |
| 201 | |
| 202 | std::string ToString(const short s) { |
| 203 | char buf[32]; |
| 204 | const int len = std::snprintf(&buf[0], arraysize(buf), "%hd", s); |
| 205 | RTC_DCHECK_LE(len, arraysize(buf)); |
| 206 | return std::string(&buf[0], len); |
| 207 | } |
| 208 | std::string ToString(const unsigned short s) { |
| 209 | char buf[32]; |
| 210 | const int len = std::snprintf(&buf[0], arraysize(buf), "%hu", s); |
| 211 | RTC_DCHECK_LE(len, arraysize(buf)); |
| 212 | return std::string(&buf[0], len); |
| 213 | } |
| 214 | std::string ToString(const int s) { |
| 215 | char buf[32]; |
| 216 | const int len = std::snprintf(&buf[0], arraysize(buf), "%d", s); |
| 217 | RTC_DCHECK_LE(len, arraysize(buf)); |
| 218 | return std::string(&buf[0], len); |
| 219 | } |
| 220 | std::string ToString(const unsigned int s) { |
| 221 | char buf[32]; |
| 222 | const int len = std::snprintf(&buf[0], arraysize(buf), "%u", s); |
| 223 | RTC_DCHECK_LE(len, arraysize(buf)); |
| 224 | return std::string(&buf[0], len); |
| 225 | } |
| 226 | std::string ToString(const long int s) { |
| 227 | char buf[32]; |
| 228 | const int len = std::snprintf(&buf[0], arraysize(buf), "%ld", s); |
| 229 | RTC_DCHECK_LE(len, arraysize(buf)); |
| 230 | return std::string(&buf[0], len); |
| 231 | } |
| 232 | std::string ToString(const unsigned long int s) { |
| 233 | char buf[32]; |
| 234 | const int len = std::snprintf(&buf[0], arraysize(buf), "%lu", s); |
| 235 | RTC_DCHECK_LE(len, arraysize(buf)); |
| 236 | return std::string(&buf[0], len); |
| 237 | } |
| 238 | std::string ToString(const long long int s) { |
| 239 | char buf[32]; |
| 240 | const int len = std::snprintf(&buf[0], arraysize(buf), "%lld", s); |
| 241 | RTC_DCHECK_LE(len, arraysize(buf)); |
| 242 | return std::string(&buf[0], len); |
| 243 | } |
| 244 | std::string ToString(const unsigned long long int s) { |
| 245 | char buf[32]; |
| 246 | const int len = std::snprintf(&buf[0], arraysize(buf), "%llu", s); |
| 247 | RTC_DCHECK_LE(len, arraysize(buf)); |
| 248 | return std::string(&buf[0], len); |
| 249 | } |
| 250 | |
| 251 | std::string ToString(const double d) { |
| 252 | char buf[32]; |
| 253 | const int len = std::snprintf(&buf[0], arraysize(buf), "%g", d); |
| 254 | RTC_DCHECK_LE(len, arraysize(buf)); |
| 255 | return std::string(&buf[0], len); |
| 256 | } |
| 257 | |
Jonas Olsson | 88e1848 | 2018-09-03 08:15:08 | [diff] [blame] | 258 | std::string ToString(const long double d) { |
| 259 | char buf[32]; |
| 260 | const int len = std::snprintf(&buf[0], arraysize(buf), "%Lg", d); |
| 261 | RTC_DCHECK_LE(len, arraysize(buf)); |
| 262 | return std::string(&buf[0], len); |
| 263 | } |
| 264 | |
Jonas Olsson | 6b1985d | 2018-07-05 09:59:48 | [diff] [blame] | 265 | std::string ToString(const void* const p) { |
| 266 | char buf[32]; |
| 267 | const int len = std::snprintf(&buf[0], arraysize(buf), "%p", p); |
| 268 | RTC_DCHECK_LE(len, arraysize(buf)); |
| 269 | return std::string(&buf[0], len); |
| 270 | } |
| 271 | |
Ali Tofigh | fd6a4d6 | 2022-03-31 08:36:48 | [diff] [blame] | 272 | bool FromString(absl::string_view s, bool* b) { |
Jonas Olsson | 6b1985d | 2018-07-05 09:59:48 | [diff] [blame] | 273 | if (s == "false") { |
| 274 | *b = false; |
| 275 | return true; |
| 276 | } |
| 277 | if (s == "true") { |
| 278 | *b = true; |
| 279 | return true; |
| 280 | } |
| 281 | return false; |
| 282 | } |
| 283 | |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 | [diff] [blame] | 284 | } // namespace rtc |