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 "absl/strings/str_cat.h"
32
33 #include <grpc/support/alloc.h>
34 #include <grpc/support/log.h>
35 #include <grpc/support/string_util.h>
36
37 #include "src/core/lib/gpr/useful.h"
38
gpr_strdup(const char * src)39 char* gpr_strdup(const char* src) {
40 char* dst;
41 size_t len;
42
43 if (!src) {
44 return nullptr;
45 }
46
47 len = strlen(src) + 1;
48 dst = static_cast<char*>(gpr_malloc(len));
49
50 memcpy(dst, src, len);
51
52 return dst;
53 }
54
gpr_format_timespec(gpr_timespec tm)55 std::string gpr_format_timespec(gpr_timespec tm) {
56 char time_buffer[35];
57 char ns_buffer[11]; // '.' + 9 digits of precision
58 struct tm* tm_info = localtime((const time_t*)&tm.tv_sec);
59 strftime(time_buffer, sizeof(time_buffer), "%Y-%m-%dT%H:%M:%S", tm_info);
60 snprintf(ns_buffer, 11, ".%09d", tm.tv_nsec);
61 // This loop trims off trailing zeros by inserting a null character that the
62 // right point. We iterate in chunks of three because we want 0, 3, 6, or 9
63 // fractional digits.
64 for (int i = 7; i >= 1; i -= 3) {
65 if (ns_buffer[i] == '0' && ns_buffer[i + 1] == '0' &&
66 ns_buffer[i + 2] == '0') {
67 ns_buffer[i] = '\0';
68 // Edge case in which all fractional digits were 0.
69 if (i == 1) {
70 ns_buffer[0] = '\0';
71 }
72 } else {
73 break;
74 }
75 }
76 return absl::StrCat(time_buffer, ns_buffer, "Z");
77 }
78
79 struct dump_out {
80 size_t capacity;
81 size_t length;
82 char* data;
83 };
84
dump_out_create(void)85 static dump_out dump_out_create(void) {
86 dump_out r = {0, 0, nullptr};
87 return r;
88 }
89
dump_out_append(dump_out * out,char c)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
hexdump(dump_out * out,const char * buf,size_t len)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
asciidump(dump_out * out,const char * buf,size_t len)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
gpr_dump_return_len(const char * buf,size_t len,uint32_t flags,size_t * out_len)129 char* gpr_dump_return_len(const char* buf, size_t len, uint32_t flags,
130 size_t* out_len) {
131 dump_out out = dump_out_create();
132 if (flags & GPR_DUMP_HEX) {
133 hexdump(&out, buf, len);
134 }
135 if (flags & GPR_DUMP_ASCII) {
136 asciidump(&out, buf, len);
137 }
138 dump_out_append(&out, 0);
139 *out_len = out.length;
140 return out.data;
141 }
142
gpr_dump(const char * buf,size_t len,uint32_t flags)143 char* gpr_dump(const char* buf, size_t len, uint32_t flags) {
144 size_t unused;
145 return gpr_dump_return_len(buf, len, flags, &unused);
146 }
147
gpr_parse_bytes_to_uint32(const char * buf,size_t len,uint32_t * result)148 int gpr_parse_bytes_to_uint32(const char* buf, size_t len, uint32_t* result) {
149 uint32_t out = 0;
150 uint32_t new_val;
151 size_t i;
152
153 if (len == 0) return 0; /* must have some bytes */
154
155 for (i = 0; i < len; i++) {
156 if (buf[i] < '0' || buf[i] > '9') return 0; /* bad char */
157 new_val = 10 * out + static_cast<uint32_t>(buf[i] - '0');
158 if (new_val < out) return 0; /* overflow */
159 out = new_val;
160 }
161
162 *result = out;
163 return 1;
164 }
165
gpr_reverse_bytes(char * str,int len)166 void gpr_reverse_bytes(char* str, int len) {
167 char *p1, *p2;
168 for (p1 = str, p2 = str + len - 1; p2 > p1; ++p1, --p2) {
169 char temp = *p1;
170 *p1 = *p2;
171 *p2 = temp;
172 }
173 }
174
gpr_ltoa(long value,char * string)175 int gpr_ltoa(long value, char* string) {
176 long sign;
177 int i = 0;
178
179 if (value == 0) {
180 string[0] = '0';
181 string[1] = 0;
182 return 1;
183 }
184
185 sign = value < 0 ? -1 : 1;
186 while (value) {
187 string[i++] = static_cast<char>('0' + sign * (value % 10));
188 value /= 10;
189 }
190 if (sign < 0) string[i++] = '-';
191 gpr_reverse_bytes(string, i);
192 string[i] = 0;
193 return i;
194 }
195
int64_ttoa(int64_t value,char * string)196 int int64_ttoa(int64_t value, char* string) {
197 int64_t sign;
198 int i = 0;
199
200 if (value == 0) {
201 string[0] = '0';
202 string[1] = 0;
203 return 1;
204 }
205
206 sign = value < 0 ? -1 : 1;
207 while (value) {
208 string[i++] = static_cast<char>('0' + sign * (value % 10));
209 value /= 10;
210 }
211 if (sign < 0) string[i++] = '-';
212 gpr_reverse_bytes(string, i);
213 string[i] = 0;
214 return i;
215 }
216
gpr_parse_nonnegative_int(const char * value)217 int gpr_parse_nonnegative_int(const char* value) {
218 char* end;
219 long result = strtol(value, &end, 10);
220 if (*end != '\0' || result < 0 || result > INT_MAX) return -1;
221 return static_cast<int>(result);
222 }
223
gpr_leftpad(const char * str,char flag,size_t length)224 char* gpr_leftpad(const char* str, char flag, size_t length) {
225 const size_t str_length = strlen(str);
226 const size_t out_length = str_length > length ? str_length : length;
227 char* out = static_cast<char*>(gpr_malloc(out_length + 1));
228 memset(out, flag, out_length - str_length);
229 memcpy(out + out_length - str_length, str, str_length);
230 out[out_length] = 0;
231 return out;
232 }
233
gpr_strjoin(const char ** strs,size_t nstrs,size_t * final_length)234 char* gpr_strjoin(const char** strs, size_t nstrs, size_t* final_length) {
235 return gpr_strjoin_sep(strs, nstrs, "", final_length);
236 }
237
gpr_strjoin_sep(const char ** strs,size_t nstrs,const char * sep,size_t * final_length)238 char* gpr_strjoin_sep(const char** strs, size_t nstrs, const char* sep,
239 size_t* final_length) {
240 const size_t sep_len = strlen(sep);
241 size_t out_length = 0;
242 size_t i;
243 char* out;
244 for (i = 0; i < nstrs; i++) {
245 out_length += strlen(strs[i]);
246 }
247 out_length += 1; /* null terminator */
248 if (nstrs > 0) {
249 out_length += sep_len * (nstrs - 1); /* separators */
250 }
251 out = static_cast<char*>(gpr_malloc(out_length));
252 out_length = 0;
253 for (i = 0; i < nstrs; i++) {
254 const size_t slen = strlen(strs[i]);
255 if (i != 0) {
256 memcpy(out + out_length, sep, sep_len);
257 out_length += sep_len;
258 }
259 memcpy(out + out_length, strs[i], slen);
260 out_length += slen;
261 }
262 out[out_length] = 0;
263 if (final_length != nullptr) {
264 *final_length = out_length;
265 }
266 return out;
267 }
268
gpr_strincmp(const char * a,const char * b,size_t n)269 int gpr_strincmp(const char* a, const char* b, size_t n) {
270 int ca, cb;
271 do {
272 ca = tolower(*a);
273 cb = tolower(*b);
274 ++a;
275 ++b;
276 --n;
277 } while (ca == cb && ca != 0 && cb != 0 && n != 0);
278 return ca - cb;
279 }
280
gpr_stricmp(const char * a,const char * b)281 int gpr_stricmp(const char* a, const char* b) {
282 return gpr_strincmp(a, b, SIZE_MAX);
283 }
284
add_string_to_split(const char * beg,const char * end,char *** strs,size_t * nstrs,size_t * capstrs)285 static void add_string_to_split(const char* beg, const char* end, char*** strs,
286 size_t* nstrs, size_t* capstrs) {
287 char* out =
288 static_cast<char*>(gpr_malloc(static_cast<size_t>(end - beg) + 1));
289 memcpy(out, beg, static_cast<size_t>(end - beg));
290 out[end - beg] = 0;
291 if (*nstrs == *capstrs) {
292 *capstrs = GPR_MAX(8, 2 * *capstrs);
293 *strs = static_cast<char**>(gpr_realloc(*strs, sizeof(*strs) * *capstrs));
294 }
295 (*strs)[*nstrs] = out;
296 ++*nstrs;
297 }
298
gpr_string_split(const char * input,const char * sep,char *** strs,size_t * nstrs)299 void gpr_string_split(const char* input, const char* sep, char*** strs,
300 size_t* nstrs) {
301 const char* next;
302 *strs = nullptr;
303 *nstrs = 0;
304 size_t capstrs = 0;
305 while ((next = strstr(input, sep))) {
306 add_string_to_split(input, next, strs, nstrs, &capstrs);
307 input = next + strlen(sep);
308 }
309 add_string_to_split(input, input + strlen(input), strs, nstrs, &capstrs);
310 }
311
gpr_memrchr(const void * s,int c,size_t n)312 void* gpr_memrchr(const void* s, int c, size_t n) {
313 if (s == nullptr) return nullptr;
314 char* b = (char*)s;
315 size_t i;
316 for (i = 0; i < n; i++) {
317 if (b[n - i - 1] == c) {
318 return &b[n - i - 1];
319 }
320 }
321 return nullptr;
322 }
323
gpr_parse_bool_value(const char * s,bool * dst)324 bool gpr_parse_bool_value(const char* s, bool* dst) {
325 const char* kTrue[] = {"1", "t", "true", "y", "yes"};
326 const char* kFalse[] = {"0", "f", "false", "n", "no"};
327 static_assert(sizeof(kTrue) == sizeof(kFalse), "true_false_equal");
328
329 if (s == nullptr) {
330 return false;
331 }
332 for (size_t i = 0; i < GPR_ARRAY_SIZE(kTrue); ++i) {
333 if (gpr_stricmp(s, kTrue[i]) == 0) {
334 *dst = true;
335 return true;
336 } else if (gpr_stricmp(s, kFalse[i]) == 0) {
337 *dst = false;
338 return true;
339 }
340 }
341 return false; // didn't match a legal input
342 }
343