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