Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright (C) 2015 Intel Corporation.
3 : : * Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES.
4 : : * All rights reserved.
5 : : */
6 : :
7 : : #include "spdk/stdinc.h"
8 : :
9 : : #include "spdk/string.h"
10 : :
11 : : char *
12 : 12799 : spdk_vsprintf_append_realloc(char *buffer, const char *format, va_list args)
13 : : {
14 : 6276 : va_list args_copy;
15 : : char *new_buffer;
16 : 12799 : int orig_size = 0, new_size;
17 : :
18 : : /* Original buffer size */
19 [ + + ]: 12799 : if (buffer) {
20 [ - + ]: 25 : orig_size = strlen(buffer);
21 : : }
22 : :
23 : : /* Necessary buffer size */
24 : 12799 : va_copy(args_copy, args);
25 [ - + ]: 12799 : new_size = vsnprintf(NULL, 0, format, args_copy);
26 : 12799 : va_end(args_copy);
27 : :
28 [ - + ]: 12799 : if (new_size < 0) {
29 : 0 : return NULL;
30 : : }
31 : 12799 : new_size += orig_size + 1;
32 : :
33 : 12799 : new_buffer = realloc(buffer, new_size);
34 [ - + ]: 12799 : if (new_buffer == NULL) {
35 : 0 : return NULL;
36 : : }
37 : :
38 [ - + ]: 12799 : vsnprintf(new_buffer + orig_size, new_size - orig_size, format, args);
39 : :
40 : 12799 : return new_buffer;
41 : : }
42 : :
43 : : char *
44 : 35 : spdk_sprintf_append_realloc(char *buffer, const char *format, ...)
45 : : {
46 : 28 : va_list args;
47 : : char *ret;
48 : :
49 : 35 : va_start(args, format);
50 : 35 : ret = spdk_vsprintf_append_realloc(buffer, format, args);
51 : 35 : va_end(args);
52 : :
53 : 35 : return ret;
54 : : }
55 : :
56 : : char *
57 : 12764 : spdk_vsprintf_alloc(const char *format, va_list args)
58 : : {
59 : 12764 : return spdk_vsprintf_append_realloc(NULL, format, args);
60 : : }
61 : :
62 : : char *
63 : 11567 : spdk_sprintf_alloc(const char *format, ...)
64 : : {
65 : 5694 : va_list args;
66 : : char *ret;
67 : :
68 : 11567 : va_start(args, format);
69 : 11567 : ret = spdk_vsprintf_alloc(format, args);
70 : 11567 : va_end(args);
71 : :
72 : 11567 : return ret;
73 : : }
74 : :
75 : : char *
76 : 1158 : spdk_strlwr(char *s)
77 : : {
78 : : char *p;
79 : :
80 [ - + ]: 1158 : if (s == NULL) {
81 : 0 : return NULL;
82 : : }
83 : :
84 : 1158 : p = s;
85 [ + + ]: 50603 : while (*p != '\0') {
86 : 49445 : *p = tolower(*p);
87 : 49445 : p++;
88 : : }
89 : :
90 : 1158 : return s;
91 : : }
92 : :
93 : : char *
94 : 8418 : spdk_strsepq(char **stringp, const char *delim)
95 : : {
96 : : char *p, *q, *r;
97 : 8418 : int quoted = 0, bslash = 0;
98 : :
99 : 8418 : p = *stringp;
100 [ + + ]: 8418 : if (p == NULL) {
101 : 245 : return NULL;
102 : : }
103 : :
104 : 8173 : r = q = p;
105 [ + + + - ]: 38120 : while (*q != '\0' && *q != '\n') {
106 : : /* eat quoted characters */
107 [ - + ]: 33825 : if (bslash) {
108 : 0 : bslash = 0;
109 : 0 : *r++ = *q++;
110 : 0 : continue;
111 [ - + ]: 33825 : } else if (quoted) {
112 [ # # # # ]: 0 : if (quoted == '"' && *q == '\\') {
113 : 0 : bslash = 1;
114 : 0 : q++;
115 : 0 : continue;
116 [ # # ]: 0 : } else if (*q == quoted) {
117 : 0 : quoted = 0;
118 : 0 : q++;
119 : 0 : continue;
120 : : }
121 : 0 : *r++ = *q++;
122 : 0 : continue;
123 [ - + ]: 33825 : } else if (*q == '\\') {
124 : 0 : bslash = 1;
125 : 0 : q++;
126 : 0 : continue;
127 [ + - - + ]: 33825 : } else if (*q == '"' || *q == '\'') {
128 : 0 : quoted = *q;
129 : 0 : q++;
130 : 0 : continue;
131 : : }
132 : :
133 : : /* separator? */
134 [ + + + + ]: 33825 : if (strchr(delim, *q) == NULL) {
135 : 29947 : *r++ = *q++;
136 : 29947 : continue;
137 : : }
138 : :
139 : : /* new string */
140 : 3878 : q++;
141 : 3878 : break;
142 : : }
143 : 8173 : *r = '\0';
144 : :
145 : : /* skip tailer */
146 [ + + - + : 8173 : while (*q != '\0' && strchr(delim, *q) != NULL) {
- + ]
147 : 0 : q++;
148 : : }
149 [ + + ]: 8173 : if (*q != '\0') {
150 : 3698 : *stringp = q;
151 : : } else {
152 : 4475 : *stringp = NULL;
153 : : }
154 : :
155 : 8173 : return p;
156 : : }
157 : :
158 : : char *
159 : 1728 : spdk_str_trim(char *s)
160 : : {
161 : : char *p, *q;
162 : :
163 [ - + ]: 1728 : if (s == NULL) {
164 : 0 : return NULL;
165 : : }
166 : :
167 : : /* remove header */
168 : 1728 : p = s;
169 [ + - - + ]: 1728 : while (*p != '\0' && isspace(*p)) {
170 : 0 : p++;
171 : : }
172 : :
173 : : /* remove tailer */
174 [ - + ]: 1728 : q = p + strlen(p);
175 [ + - + + ]: 15093 : while (q - 1 >= p && isspace(*(q - 1))) {
176 : 13365 : q--;
177 : 13365 : *q = '\0';
178 : : }
179 : :
180 : : /* if remove header, move */
181 [ - + ]: 1728 : if (p != s) {
182 : 0 : q = s;
183 [ # # ]: 0 : while (*p != '\0') {
184 : 0 : *q++ = *p++;
185 : : }
186 : 0 : *q = '\0';
187 : : }
188 : :
189 : 1728 : return s;
190 : : }
191 : :
192 : : void
193 : 125662 : spdk_strcpy_pad(void *dst, const char *src, size_t size, int pad)
194 : : {
195 : : size_t len;
196 : :
197 [ - + ]: 125662 : len = strlen(src);
198 [ + + ]: 125662 : if (len < size) {
199 [ - + - + ]: 120058 : memcpy(dst, src, len);
200 [ - + ]: 120058 : memset((char *)dst + len, pad, size - len);
201 : : } else {
202 [ - + - + ]: 5604 : memcpy(dst, src, size);
203 : : }
204 : 125662 : }
205 : :
206 : : size_t
207 : 204 : spdk_strlen_pad(const void *str, size_t size, int pad)
208 : : {
209 : : const uint8_t *start;
210 : : const uint8_t *iter;
211 : : uint8_t pad_byte;
212 : :
213 : 204 : pad_byte = (uint8_t)pad;
214 : 204 : start = (const uint8_t *)str;
215 : :
216 [ - + ]: 204 : if (size == 0) {
217 : 0 : return 0;
218 : : }
219 : :
220 : 204 : iter = start + size - 1;
221 : : while (1) {
222 [ + + ]: 26861 : if (*iter != pad_byte) {
223 : 204 : return iter - start + 1;
224 : : }
225 : :
226 [ - + ]: 26657 : if (iter == start) {
227 : : /* Hit the start of the string finding only pad_byte. */
228 : 0 : return 0;
229 : : }
230 : 26657 : iter--;
231 : : }
232 : : }
233 : :
234 : : int
235 : 25 : spdk_parse_ip_addr(char *ip, char **host, char **port)
236 : : {
237 : : char *p;
238 : :
239 [ - + ]: 25 : if (ip == NULL) {
240 : 0 : return -EINVAL;
241 : : }
242 : :
243 : 25 : *host = NULL;
244 : 25 : *port = NULL;
245 : :
246 [ + + ]: 25 : if (ip[0] == '[') {
247 : : /* IPv6 */
248 [ - + ]: 15 : p = strchr(ip, ']');
249 [ - + ]: 15 : if (p == NULL) {
250 : 0 : return -EINVAL;
251 : : }
252 : 15 : *host = &ip[1];
253 : 15 : *p = '\0';
254 : :
255 : 15 : p++;
256 [ + + ]: 15 : if (*p == '\0') {
257 : 5 : return 0;
258 [ - + ]: 10 : } else if (*p != ':') {
259 : 0 : return -EINVAL;
260 : : }
261 : :
262 : 10 : p++;
263 [ + + ]: 10 : if (*p == '\0') {
264 : 5 : return 0;
265 : : }
266 : :
267 : 5 : *port = p;
268 : : } else {
269 : : /* IPv4 */
270 [ - + ]: 10 : p = strchr(ip, ':');
271 [ + + ]: 10 : if (p == NULL) {
272 : 5 : *host = ip;
273 : 5 : return 0;
274 : : }
275 : :
276 : 5 : *host = ip;
277 : 5 : *p = '\0';
278 : :
279 : 5 : p++;
280 [ - + ]: 5 : if (*p == '\0') {
281 : 0 : return 0;
282 : : }
283 : :
284 : 5 : *port = p;
285 : : }
286 : :
287 : 10 : return 0;
288 : : }
289 : :
290 : : size_t
291 : 251 : spdk_str_chomp(char *s)
292 : : {
293 [ - + ]: 251 : size_t len = strlen(s);
294 : 251 : size_t removed = 0;
295 : :
296 [ + + ]: 293 : while (len > 0) {
297 [ + + + + ]: 283 : if (s[len - 1] != '\r' && s[len - 1] != '\n') {
298 : 241 : break;
299 : : }
300 : :
301 : 42 : s[len - 1] = '\0';
302 : 42 : len--;
303 : 42 : removed++;
304 : : }
305 : :
306 : 251 : return removed;
307 : : }
308 : :
309 : : void
310 : 1895 : spdk_strerror_r(int errnum, char *buf, size_t buflen)
311 : : {
312 : : int rc;
313 : :
314 : : #if defined(__USE_GNU)
315 : : char *new_buffer;
316 [ - + ]: 1895 : new_buffer = strerror_r(errnum, buf, buflen);
317 [ + + ]: 1895 : if (new_buffer == buf) {
318 : 87 : rc = 0;
319 [ + - ]: 1808 : } else if (new_buffer != NULL) {
320 [ - + ]: 1808 : snprintf(buf, buflen, "%s", new_buffer);
321 : 1808 : rc = 0;
322 : : } else {
323 : 0 : rc = 1;
324 : : }
325 : : #else
326 : : rc = strerror_r(errnum, buf, buflen);
327 : : #endif
328 : :
329 [ - + ]: 1895 : if (rc != 0) {
330 [ # # ]: 0 : snprintf(buf, buflen, "Unknown error %d", errnum);
331 : : }
332 : 1895 : }
333 : :
334 : : int
335 : 803 : spdk_parse_capacity(const char *cap_str, uint64_t *cap, bool *has_prefix)
336 : : {
337 : : int rc;
338 : 241 : char bin_prefix;
339 : :
340 : 803 : rc = sscanf(cap_str, "%"SCNu64"%c", cap, &bin_prefix);
341 [ + + ]: 803 : if (rc == 1) {
342 [ + + ]: 702 : if (has_prefix != NULL) {
343 : 119 : *has_prefix = false;
344 : : }
345 : 702 : return 0;
346 [ + + ]: 101 : } else if (rc == 0) {
347 [ + + ]: 10 : if (errno == 0) {
348 : : /* No scanf matches - the string does not start with a digit */
349 : 6 : return -EINVAL;
350 : : } else {
351 : : /* Parsing error */
352 : 4 : return -errno;
353 : : }
354 : : }
355 : :
356 [ + + ]: 91 : if (has_prefix != NULL) {
357 : 40 : *has_prefix = true;
358 : : }
359 : :
360 [ + + + - ]: 91 : switch (bin_prefix) {
361 : 56 : case 'k':
362 : : case 'K':
363 : 56 : *cap *= 1024;
364 : 56 : break;
365 : 30 : case 'm':
366 : : case 'M':
367 : 30 : *cap *= 1024 * 1024;
368 : 30 : break;
369 : 5 : case 'g':
370 : : case 'G':
371 : 5 : *cap *= 1024 * 1024 * 1024;
372 : 5 : break;
373 : 0 : default:
374 : 0 : return -EINVAL;
375 : : }
376 : :
377 : 91 : return 0;
378 : : }
379 : :
380 : : bool
381 : 191258 : spdk_mem_all_zero(const void *data, size_t size)
382 : : {
383 : 191258 : const uint8_t *buf = data;
384 : :
385 [ + + ]: 448193074 : while (size--) {
386 [ + + ]: 448007738 : if (*buf++ != 0) {
387 : 5922 : return false;
388 : : }
389 : : }
390 : :
391 : 185336 : return true;
392 : : }
393 : :
394 : : long int
395 : 19643 : spdk_strtol(const char *nptr, int base)
396 : : {
397 : : long val;
398 : 1065 : char *endptr;
399 : :
400 : : /* Since strtoll() can legitimately return 0, LONG_MAX, or LONG_MIN
401 : : * on both success and failure, the calling program should set errno
402 : : * to 0 before the call.
403 : : */
404 : 19643 : errno = 0;
405 : :
406 [ - + ]: 19643 : val = strtol(nptr, &endptr, base);
407 : :
408 [ + + + + ]: 19643 : if (!errno && *endptr != '\0') {
409 : : /* Non integer character was found. */
410 : 84 : return -EINVAL;
411 [ + + + + : 19559 : } else if (errno == ERANGE && (val == LONG_MAX || val == LONG_MIN)) {
+ - ]
412 : : /* Overflow occurred. */
413 : 10 : return -ERANGE;
414 [ + + + - ]: 19549 : } else if (errno != 0 && val == 0) {
415 : : /* Other error occurred. */
416 : 5 : return -errno;
417 [ + + ]: 19544 : } else if (val < 0) {
418 : : /* Input string was negative number. */
419 : 18 : return -ERANGE;
420 : : }
421 : :
422 : 19526 : return val;
423 : : }
424 : :
425 : : long long int
426 : 819 : spdk_strtoll(const char *nptr, int base)
427 : : {
428 : : long long val;
429 : 324 : char *endptr;
430 : :
431 : : /* Since strtoll() can legitimately return 0, LLONG_MAX, or LLONG_MIN
432 : : * on both success and failure, the calling program should set errno
433 : : * to 0 before the call.
434 : : */
435 : 819 : errno = 0;
436 : :
437 [ - + ]: 819 : val = strtoll(nptr, &endptr, base);
438 : :
439 [ + + + + ]: 819 : if (!errno && *endptr != '\0') {
440 : : /* Non integer character was found. */
441 : 16 : return -EINVAL;
442 [ + + + + : 803 : } else if (errno == ERANGE && (val == LLONG_MAX || val == LLONG_MIN)) {
+ - ]
443 : : /* Overflow occurred. */
444 : 10 : return -ERANGE;
445 [ + + + - ]: 793 : } else if (errno != 0 && val == 0) {
446 : : /* Other error occurred. */
447 : 5 : return -errno;
448 [ + + ]: 788 : } else if (val < 0) {
449 : : /* Input string was negative number. */
450 : 10 : return -ERANGE;
451 : : }
452 : :
453 : 778 : return val;
454 : : }
455 : :
456 : : void
457 : 4217 : spdk_strarray_free(char **strarray)
458 : : {
459 : : size_t i;
460 : :
461 [ + + ]: 4217 : if (strarray == NULL) {
462 : 4152 : return;
463 : : }
464 : :
465 [ + + ]: 230 : for (i = 0; strarray[i] != NULL; i++) {
466 : 165 : free(strarray[i]);
467 : : }
468 : 65 : free(strarray);
469 : : }
470 : :
471 : : char **
472 : 60 : spdk_strarray_from_string(const char *str, const char *delim)
473 : : {
474 : 60 : const char *c = str;
475 : 60 : size_t count = 0;
476 : : char **result;
477 : : size_t i;
478 : :
479 [ - + ]: 60 : assert(str != NULL);
480 [ - + ]: 60 : assert(delim != NULL);
481 : :
482 : : /* Count number of entries. */
483 : 80 : for (;;) {
484 [ - + - + ]: 140 : const char *next = strpbrk(c, delim);
485 : :
486 : 140 : count++;
487 : :
488 [ + + ]: 140 : if (next == NULL) {
489 : 60 : break;
490 : : }
491 : :
492 : 80 : c = next + 1;
493 : : }
494 : :
495 : : /* Account for the terminating NULL entry. */
496 : 60 : result = calloc(count + 1, sizeof(char *));
497 [ - + ]: 60 : if (result == NULL) {
498 : 0 : return NULL;
499 : : }
500 : :
501 : 60 : c = str;
502 : :
503 [ + + ]: 200 : for (i = 0; i < count; i++) {
504 [ - + - + ]: 140 : const char *next = strpbrk(c, delim);
505 : :
506 [ + + ]: 140 : if (next == NULL) {
507 [ - + ]: 60 : result[i] = strdup(c);
508 : : } else {
509 [ - + ]: 80 : result[i] = strndup(c, next - c);
510 : : }
511 : :
512 [ - + ]: 140 : if (result[i] == NULL) {
513 : 0 : spdk_strarray_free(result);
514 : 0 : return NULL;
515 : : }
516 : :
517 [ + + ]: 140 : if (next != NULL) {
518 : 80 : c = next + 1;
519 : : }
520 : : }
521 : :
522 : 60 : return result;
523 : : }
524 : :
525 : : char **
526 : 45 : spdk_strarray_dup(const char **strarray)
527 : : {
528 : : size_t count, i;
529 : : char **result;
530 : :
531 [ - + ]: 45 : assert(strarray != NULL);
532 : :
533 [ + + ]: 150 : for (count = 0; strarray[count] != NULL; count++)
534 : : ;
535 : :
536 : 45 : result = calloc(count + 1, sizeof(char *));
537 [ - + ]: 45 : if (result == NULL) {
538 : 0 : return NULL;
539 : : }
540 : :
541 [ + + ]: 150 : for (i = 0; i < count; i++) {
542 [ - + ]: 105 : result[i] = strdup(strarray[i]);
543 [ - + ]: 105 : if (result[i] == NULL) {
544 : 0 : spdk_strarray_free(result);
545 : 0 : return NULL;
546 : : }
547 : : }
548 : :
549 : 45 : return result;
550 : : }
551 : :
552 : : int
553 : 117 : spdk_strcpy_replace(char *dst, size_t size, const char *src, const char *search,
554 : : const char *replace)
555 : : {
556 : : const char *p, *q;
557 : : char *r;
558 : : size_t c, search_size, replace_size, dst_size;
559 : :
560 [ + + + - : 117 : if (dst == NULL || src == NULL || search == NULL || replace == NULL) {
+ - - + ]
561 : 5 : return -EINVAL;
562 : : }
563 : :
564 [ - + ]: 112 : search_size = strlen(search);
565 [ - + ]: 112 : replace_size = strlen(replace);
566 : :
567 : 112 : c = 0;
568 [ + + - + : 203 : for (p = strstr(src, search); p != NULL; p = strstr(p + search_size, search)) {
- + - + +
+ ]
569 : 91 : c++;
570 : : }
571 : :
572 [ - + ]: 112 : dst_size = strlen(src) + (replace_size - search_size) * c;
573 [ + + ]: 112 : if (dst_size >= size) {
574 : 5 : return -EINVAL;
575 : : }
576 : :
577 : 107 : q = src;
578 : 107 : r = dst;
579 : :
580 [ + + - + : 193 : for (p = strstr(src, search); p != NULL; p = strstr(p + search_size, search)) {
- + - + +
+ ]
581 [ - + - + ]: 86 : memcpy(r, q, p - q);
582 : 86 : r += p - q;
583 : :
584 [ - + - + ]: 86 : memcpy(r, replace, replace_size);
585 : 86 : r += replace_size;
586 : :
587 : 86 : q = p + search_size;
588 : : }
589 : :
590 [ - + - + : 107 : memcpy(r, q, strlen(q));
- + ]
591 [ - + ]: 107 : r += strlen(q);
592 : :
593 : 107 : *r = '\0';
594 : :
595 : 107 : return 0;
596 : : }
|