1 /* 2 * 3 * Copyright 2015 gRPC authors. 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 * 17 */ 18 19 #include <grpc/support/port_platform.h> 20 21 #include "src/core/lib/gpr/string.h" 22 23 #include <ctype.h> 24 #include <limits.h> 25 #include <stddef.h> 26 #include <stdio.h> 27 #include <stdlib.h> 28 #include <string.h> 29 #include <time.h> 30 31 #include <grpc/support/alloc.h> 32 #include <grpc/support/log.h> 33 #include <grpc/support/string_util.h> 34 35 #include "src/core/lib/gpr/useful.h" 36 37 char* gpr_strdup(const char* src) { 38 char* dst; 39 size_t len; 40 41 if (!src) { 42 return nullptr; 43 } 44 45 len = strlen(src) + 1; 46 dst = static_cast<char*>(gpr_malloc(len)); 47 48 memcpy(dst, src, len); 49 50 return dst; 51 } 52 53 typedef struct { 54 size_t capacity; 55 size_t length; 56 char* data; 57 } dump_out; 58 59 char* gpr_format_timespec(gpr_timespec tm) { 60 char time_buffer[35]; 61 char ns_buffer[11]; // '.' + 9 digits of precision 62 struct tm* tm_info = localtime((const time_t*)&tm.tv_sec); 63 strftime(time_buffer, sizeof(time_buffer), "%Y-%m-%dT%H:%M:%S", tm_info); 64 snprintf(ns_buffer, 11, ".%09d", tm.tv_nsec); 65 // This loop trims off trailing zeros by inserting a null character that the 66 // right point. We iterate in chunks of three because we want 0, 3, 6, or 9 67 // fractional digits. 68 for (int i = 7; i >= 1; i -= 3) { 69 if (ns_buffer[i] == '0' && ns_buffer[i + 1] == '0' && 70 ns_buffer[i + 2] == '0') { 71 ns_buffer[i] = '\0'; 72 // Edge case in which all fractional digits were 0. 73 if (i == 1) { 74 ns_buffer[0] = '\0'; 75 } 76 } else { 77 break; 78 } 79 } 80 char* full_time_str; 81 gpr_asprintf(&full_time_str, "%s%sZ", time_buffer, ns_buffer); 82 return full_time_str; 83 } 84 85 static dump_out dump_out_create(void) { 86 dump_out r = {0, 0, nullptr}; 87 return r; 88 } 89 90 static void dump_out_append(dump_out* out, char c) { 91 if (out->length == out->capacity) { 92 out->capacity = GPR_MAX(8, 2 * out->capacity); 93 out->data = static_cast<char*>(gpr_realloc(out->data, out->capacity)); 94 } 95 out->data[out->length++] = c; 96 } 97 98 static void hexdump(dump_out* out, const char* buf, size_t len) { 99 static const char* hex = "0123456789abcdef"; 100 101 const uint8_t* const beg = reinterpret_cast<const uint8_t*>(buf); 102 const uint8_t* const end = beg + len; 103 const uint8_t* cur; 104 105 for (cur = beg; cur != end; ++cur) { 106 if (cur != beg) dump_out_append(out, ' '); 107 dump_out_append(out, hex[*cur >> 4]); 108 dump_out_append(out, hex[*cur & 0xf]); 109 } 110 } 111 112 static void asciidump(dump_out* out, const char* buf, size_t len) { 113 const uint8_t* const beg = reinterpret_cast<const uint8_t*>(buf); 114 const uint8_t* const end = beg + len; 115 const uint8_t* cur; 116 int out_was_empty = (out->length == 0); 117 if (!out_was_empty) { 118 dump_out_append(out, ' '); 119 dump_out_append(out, '\''); 120 } 121 for (cur = beg; cur != end; ++cur) { 122 dump_out_append(out, (isprint(*cur) ? *(char*)cur : '.')); 123 } 124 if (!out_was_empty) { 125 dump_out_append(out, '\''); 126 } 127 } 128 129 char* gpr_dump(const char* buf, size_t len, uint32_t flags) { 130 dump_out out = dump_out_create(); 131 if (flags & GPR_DUMP_HEX) { 132 hexdump(&out, buf, len); 133 } 134 if (flags & GPR_DUMP_ASCII) { 135 asciidump(&out, buf, len); 136 } 137 dump_out_append(&out, 0); 138 return out.data; 139 } 140 141 int gpr_parse_bytes_to_uint32(const char* buf, size_t len, uint32_t* result) { 142 uint32_t out = 0; 143 uint32_t new_val; 144 size_t i; 145 146 if (len == 0) return 0; /* must have some bytes */ 147 148 for (i = 0; i < len; i++) { 149 if (buf[i] < '0' || buf[i] > '9') return 0; /* bad char */ 150 new_val = 10 * out + static_cast<uint32_t>(buf[i] - '0'); 151 if (new_val < out) return 0; /* overflow */ 152 out = new_val; 153 } 154 155 *result = out; 156 return 1; 157 } 158 159 void gpr_reverse_bytes(char* str, int len) { 160 char *p1, *p2; 161 for (p1 = str, p2 = str + len - 1; p2 > p1; ++p1, --p2) { 162 char temp = *p1; 163 *p1 = *p2; 164 *p2 = temp; 165 } 166 } 167 168 int gpr_ltoa(long value, char* string) { 169 long sign; 170 int i = 0; 171 172 if (value == 0) { 173 string[0] = '0'; 174 string[1] = 0; 175 return 1; 176 } 177 178 sign = value < 0 ? -1 : 1; 179 while (value) { 180 string[i++] = static_cast<char>('0' + sign * (value % 10)); 181 value /= 10; 182 } 183 if (sign < 0) string[i++] = '-'; 184 gpr_reverse_bytes(string, i); 185 string[i] = 0; 186 return i; 187 } 188 189 int int64_ttoa(int64_t value, char* string) { 190 int64_t sign; 191 int i = 0; 192 193 if (value == 0) { 194 string[0] = '0'; 195 string[1] = 0; 196 return 1; 197 } 198 199 sign = value < 0 ? -1 : 1; 200 while (value) { 201 string[i++] = static_cast<char>('0' + sign * (value % 10)); 202 value /= 10; 203 } 204 if (sign < 0) string[i++] = '-'; 205 gpr_reverse_bytes(string, i); 206 string[i] = 0; 207 return i; 208 } 209 210 int gpr_parse_nonnegative_int(const char* value) { 211 char* end; 212 long result = strtol(value, &end, 0); 213 if (*end != '\0' || result < 0 || result > INT_MAX) return -1; 214 return static_cast<int>(result); 215 } 216 217 char* gpr_leftpad(const char* str, char flag, size_t length) { 218 const size_t str_length = strlen(str); 219 const size_t out_length = str_length > length ? str_length : length; 220 char* out = static_cast<char*>(gpr_malloc(out_length + 1)); 221 memset(out, flag, out_length - str_length); 222 memcpy(out + out_length - str_length, str, str_length); 223 out[out_length] = 0; 224 return out; 225 } 226 227 char* gpr_strjoin(const char** strs, size_t nstrs, size_t* final_length) { 228 return gpr_strjoin_sep(strs, nstrs, "", final_length); 229 } 230 231 char* gpr_strjoin_sep(const char** strs, size_t nstrs, const char* sep, 232 size_t* final_length) { 233 const size_t sep_len = strlen(sep); 234 size_t out_length = 0; 235 size_t i; 236 char* out; 237 for (i = 0; i < nstrs; i++) { 238 out_length += strlen(strs[i]); 239 } 240 out_length += 1; /* null terminator */ 241 if (nstrs > 0) { 242 out_length += sep_len * (nstrs - 1); /* separators */ 243 } 244 out = static_cast<char*>(gpr_malloc(out_length)); 245 out_length = 0; 246 for (i = 0; i < nstrs; i++) { 247 const size_t slen = strlen(strs[i]); 248 if (i != 0) { 249 memcpy(out + out_length, sep, sep_len); 250 out_length += sep_len; 251 } 252 memcpy(out + out_length, strs[i], slen); 253 out_length += slen; 254 } 255 out[out_length] = 0; 256 if (final_length != nullptr) { 257 *final_length = out_length; 258 } 259 return out; 260 } 261 262 void gpr_strvec_init(gpr_strvec* sv) { memset(sv, 0, sizeof(*sv)); } 263 264 void gpr_strvec_destroy(gpr_strvec* sv) { 265 size_t i; 266 for (i = 0; i < sv->count; i++) { 267 gpr_free(sv->strs[i]); 268 } 269 gpr_free(sv->strs); 270 } 271 272 void gpr_strvec_add(gpr_strvec* sv, char* str) { 273 if (sv->count == sv->capacity) { 274 sv->capacity = GPR_MAX(sv->capacity + 8, sv->capacity * 2); 275 sv->strs = static_cast<char**>( 276 gpr_realloc(sv->strs, sizeof(char*) * sv->capacity)); 277 } 278 sv->strs[sv->count++] = str; 279 } 280 281 char* gpr_strvec_flatten(gpr_strvec* sv, size_t* final_length) { 282 return gpr_strjoin((const char**)sv->strs, sv->count, final_length); 283 } 284 285 int gpr_stricmp(const char* a, const char* b) { 286 int ca, cb; 287 do { 288 ca = tolower(*a); 289 cb = tolower(*b); 290 ++a; 291 ++b; 292 } while (ca == cb && ca && cb); 293 return ca - cb; 294 } 295 296 static void add_string_to_split(const char* beg, const char* end, char*** strs, 297 size_t* nstrs, size_t* capstrs) { 298 char* out = 299 static_cast<char*>(gpr_malloc(static_cast<size_t>(end - beg) + 1)); 300 memcpy(out, beg, static_cast<size_t>(end - beg)); 301 out[end - beg] = 0; 302 if (*nstrs == *capstrs) { 303 *capstrs = GPR_MAX(8, 2 * *capstrs); 304 *strs = static_cast<char**>(gpr_realloc(*strs, sizeof(*strs) * *capstrs)); 305 } 306 (*strs)[*nstrs] = out; 307 ++*nstrs; 308 } 309 310 void gpr_string_split(const char* input, const char* sep, char*** strs, 311 size_t* nstrs) { 312 const char* next; 313 *strs = nullptr; 314 *nstrs = 0; 315 size_t capstrs = 0; 316 while ((next = strstr(input, sep))) { 317 add_string_to_split(input, next, strs, nstrs, &capstrs); 318 input = next + strlen(sep); 319 } 320 add_string_to_split(input, input + strlen(input), strs, nstrs, &capstrs); 321 } 322 323 void* gpr_memrchr(const void* s, int c, size_t n) { 324 if (s == nullptr) return nullptr; 325 char* b = (char*)s; 326 size_t i; 327 for (i = 0; i < n; i++) { 328 if (b[n - i - 1] == c) { 329 return &b[n - i - 1]; 330 } 331 } 332 return nullptr; 333 } 334 335 bool gpr_is_true(const char* s) { 336 size_t i; 337 if (s == nullptr) { 338 return false; 339 } 340 static const char* truthy[] = {"yes", "true", "1"}; 341 for (i = 0; i < GPR_ARRAY_SIZE(truthy); i++) { 342 if (0 == gpr_stricmp(s, truthy[i])) { 343 return true; 344 } 345 } 346 return false; 347 } 348