LCOV - code coverage report
Current view: top level - spdk/lib/util - string.c (source / functions) Hit Total Coverage
Test: Combined Lines: 246 291 84.5 %
Date: 2024-07-11 17:06:07 Functions: 20 20 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 186 276 67.4 %

           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                 :      19281 : spdk_vsprintf_append_realloc(char *buffer, const char *format, va_list args)
      13                 :            : {
      14                 :      11866 :         va_list args_copy;
      15                 :            :         char *new_buffer;
      16                 :      19281 :         int orig_size = 0, new_size;
      17                 :            : 
      18                 :            :         /* Original buffer size */
      19         [ +  + ]:      19281 :         if (buffer) {
      20         [ -  + ]:         30 :                 orig_size = strlen(buffer);
      21                 :            :         }
      22                 :            : 
      23                 :            :         /* Necessary buffer size */
      24                 :      19281 :         va_copy(args_copy, args);
      25         [ -  + ]:      19281 :         new_size = vsnprintf(NULL, 0, format, args_copy);
      26                 :      19281 :         va_end(args_copy);
      27                 :            : 
      28         [ -  + ]:      19281 :         if (new_size < 0) {
      29                 :          0 :                 return NULL;
      30                 :            :         }
      31                 :      19281 :         new_size += orig_size + 1;
      32                 :            : 
      33                 :      19281 :         new_buffer = realloc(buffer, new_size);
      34         [ -  + ]:      19281 :         if (new_buffer == NULL) {
      35                 :          0 :                 return NULL;
      36                 :            :         }
      37                 :            : 
      38         [ -  + ]:      19281 :         vsnprintf(new_buffer + orig_size, new_size - orig_size, format, args);
      39                 :            : 
      40                 :      19281 :         return new_buffer;
      41                 :            : }
      42                 :            : 
      43                 :            : char *
      44                 :         42 : spdk_sprintf_append_realloc(char *buffer, const char *format, ...)
      45                 :            : {
      46                 :         35 :         va_list args;
      47                 :            :         char *ret;
      48                 :            : 
      49                 :         42 :         va_start(args, format);
      50                 :         42 :         ret = spdk_vsprintf_append_realloc(buffer, format, args);
      51                 :         42 :         va_end(args);
      52                 :            : 
      53                 :         42 :         return ret;
      54                 :            : }
      55                 :            : 
      56                 :            : char *
      57                 :      19239 : spdk_vsprintf_alloc(const char *format, va_list args)
      58                 :            : {
      59                 :      19239 :         return spdk_vsprintf_append_realloc(NULL, format, args);
      60                 :            : }
      61                 :            : 
      62                 :            : char *
      63                 :      15996 : spdk_sprintf_alloc(const char *format, ...)
      64                 :            : {
      65                 :       9196 :         va_list args;
      66                 :            :         char *ret;
      67                 :            : 
      68                 :      15996 :         va_start(args, format);
      69                 :      15996 :         ret = spdk_vsprintf_alloc(format, args);
      70                 :      15996 :         va_end(args);
      71                 :            : 
      72                 :      15996 :         return ret;
      73                 :            : }
      74                 :            : 
      75                 :            : char *
      76                 :       1138 : spdk_strlwr(char *s)
      77                 :            : {
      78                 :            :         char *p;
      79                 :            : 
      80         [ -  + ]:       1138 :         if (s == NULL) {
      81                 :          0 :                 return NULL;
      82                 :            :         }
      83                 :            : 
      84                 :       1138 :         p = s;
      85         [ +  + ]:      49905 :         while (*p != '\0') {
      86                 :      48767 :                 *p = tolower(*p);
      87                 :      48767 :                 p++;
      88                 :            :         }
      89                 :            : 
      90                 :       1138 :         return s;
      91                 :            : }
      92                 :            : 
      93                 :            : char *
      94                 :       8567 : spdk_strsepq(char **stringp, const char *delim)
      95                 :            : {
      96                 :            :         char *p, *q, *r;
      97                 :       8567 :         int quoted = 0, bslash = 0;
      98                 :            : 
      99                 :       8567 :         p = *stringp;
     100         [ +  + ]:       8567 :         if (p == NULL) {
     101                 :        242 :                 return NULL;
     102                 :            :         }
     103                 :            : 
     104                 :       8325 :         r = q = p;
     105   [ +  +  +  - ]:      39212 :         while (*q != '\0' && *q != '\n') {
     106                 :            :                 /* eat quoted characters */
     107         [ -  + ]:      34869 :                 if (bslash) {
     108                 :          0 :                         bslash = 0;
     109                 :          0 :                         *r++ = *q++;
     110                 :          0 :                         continue;
     111         [ -  + ]:      34869 :                 } 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         [ -  + ]:      34869 :                 } else if (*q == '\\') {
     124                 :          0 :                         bslash = 1;
     125                 :          0 :                         q++;
     126                 :          0 :                         continue;
     127   [ +  -  -  + ]:      34869 :                 } else if (*q == '"' || *q == '\'') {
     128                 :          0 :                         quoted = *q;
     129                 :          0 :                         q++;
     130                 :          0 :                         continue;
     131                 :            :                 }
     132                 :            : 
     133                 :            :                 /* separator? */
     134   [ +  +  +  + ]:      34869 :                 if (strchr(delim, *q) == NULL) {
     135                 :      30887 :                         *r++ = *q++;
     136                 :      30887 :                         continue;
     137                 :            :                 }
     138                 :            : 
     139                 :            :                 /* new string */
     140                 :       3982 :                 q++;
     141                 :       3982 :                 break;
     142                 :            :         }
     143                 :       8325 :         *r = '\0';
     144                 :            : 
     145                 :            :         /* skip tailer */
     146   [ +  +  -  +  :       8325 :         while (*q != '\0' && strchr(delim, *q) != NULL) {
                   -  + ]
     147                 :          0 :                 q++;
     148                 :            :         }
     149         [ +  + ]:       8325 :         if (*q != '\0') {
     150                 :       3757 :                 *stringp = q;
     151                 :            :         } else {
     152                 :       4568 :                 *stringp = NULL;
     153                 :            :         }
     154                 :            : 
     155                 :       8325 :         return p;
     156                 :            : }
     157                 :            : 
     158                 :            : char *
     159                 :       3675 : spdk_str_trim(char *s)
     160                 :            : {
     161                 :            :         char *p, *q;
     162                 :            : 
     163         [ -  + ]:       3675 :         if (s == NULL) {
     164                 :          0 :                 return NULL;
     165                 :            :         }
     166                 :            : 
     167                 :            :         /* remove header */
     168                 :       3675 :         p = s;
     169   [ +  -  -  + ]:       3675 :         while (*p != '\0' && isspace(*p)) {
     170                 :          0 :                 p++;
     171                 :            :         }
     172                 :            : 
     173                 :            :         /* remove tailer */
     174         [ -  + ]:       3675 :         q = p + strlen(p);
     175   [ +  -  +  + ]:      27981 :         while (q - 1 >= p && isspace(*(q - 1))) {
     176                 :      24306 :                 q--;
     177                 :      24306 :                 *q = '\0';
     178                 :            :         }
     179                 :            : 
     180                 :            :         /* if remove header, move */
     181         [ -  + ]:       3675 :         if (p != s) {
     182                 :          0 :                 q = s;
     183         [ #  # ]:          0 :                 while (*p != '\0') {
     184                 :          0 :                         *q++ = *p++;
     185                 :            :                 }
     186                 :          0 :                 *q = '\0';
     187                 :            :         }
     188                 :            : 
     189                 :       3675 :         return s;
     190                 :            : }
     191                 :            : 
     192                 :            : void
     193                 :     168743 : spdk_strcpy_pad(void *dst, const char *src, size_t size, int pad)
     194                 :            : {
     195                 :            :         size_t len;
     196                 :            : 
     197         [ -  + ]:     168743 :         len = strlen(src);
     198         [ +  + ]:     168743 :         if (len < size) {
     199   [ -  +  -  + ]:     162564 :                 memcpy(dst, src, len);
     200         [ -  + ]:     162564 :                 memset((char *)dst + len, pad, size - len);
     201                 :            :         } else {
     202   [ -  +  -  + ]:       6179 :                 memcpy(dst, src, size);
     203                 :            :         }
     204                 :     168743 : }
     205                 :            : 
     206                 :            : size_t
     207                 :        182 : 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                 :        182 :         pad_byte = (uint8_t)pad;
     214                 :        182 :         start = (const uint8_t *)str;
     215                 :            : 
     216         [ -  + ]:        182 :         if (size == 0) {
     217                 :          0 :                 return 0;
     218                 :            :         }
     219                 :            : 
     220                 :        182 :         iter = start + size - 1;
     221                 :            :         while (1) {
     222         [ +  + ]:      23527 :                 if (*iter != pad_byte) {
     223                 :        182 :                         return iter - start + 1;
     224                 :            :                 }
     225                 :            : 
     226         [ -  + ]:      23345 :                 if (iter == start) {
     227                 :            :                         /* Hit the start of the string finding only pad_byte. */
     228                 :          0 :                         return 0;
     229                 :            :                 }
     230                 :      23345 :                 iter--;
     231                 :            :         }
     232                 :            : }
     233                 :            : 
     234                 :            : int
     235                 :         30 : spdk_parse_ip_addr(char *ip, char **host, char **port)
     236                 :            : {
     237                 :            :         char *p;
     238                 :            : 
     239         [ -  + ]:         30 :         if (ip == NULL) {
     240                 :          0 :                 return -EINVAL;
     241                 :            :         }
     242                 :            : 
     243                 :         30 :         *host = NULL;
     244                 :         30 :         *port = NULL;
     245                 :            : 
     246         [ +  + ]:         30 :         if (ip[0] == '[') {
     247                 :            :                 /* IPv6 */
     248         [ -  + ]:         18 :                 p = strchr(ip, ']');
     249         [ -  + ]:         18 :                 if (p == NULL) {
     250                 :          0 :                         return -EINVAL;
     251                 :            :                 }
     252                 :         18 :                 *host = &ip[1];
     253                 :         18 :                 *p = '\0';
     254                 :            : 
     255                 :         18 :                 p++;
     256         [ +  + ]:         18 :                 if (*p == '\0') {
     257                 :          6 :                         return 0;
     258         [ -  + ]:         12 :                 } else if (*p != ':') {
     259                 :          0 :                         return -EINVAL;
     260                 :            :                 }
     261                 :            : 
     262                 :         12 :                 p++;
     263         [ +  + ]:         12 :                 if (*p == '\0') {
     264                 :          6 :                         return 0;
     265                 :            :                 }
     266                 :            : 
     267                 :          6 :                 *port = p;
     268                 :            :         } else {
     269                 :            :                 /* IPv4 */
     270         [ -  + ]:         12 :                 p = strchr(ip, ':');
     271         [ +  + ]:         12 :                 if (p == NULL) {
     272                 :          6 :                         *host = ip;
     273                 :          6 :                         return 0;
     274                 :            :                 }
     275                 :            : 
     276                 :          6 :                 *host = ip;
     277                 :          6 :                 *p = '\0';
     278                 :            : 
     279                 :          6 :                 p++;
     280         [ -  + ]:          6 :                 if (*p == '\0') {
     281                 :          0 :                         return 0;
     282                 :            :                 }
     283                 :            : 
     284                 :          6 :                 *port = p;
     285                 :            :         }
     286                 :            : 
     287                 :         12 :         return 0;
     288                 :            : }
     289                 :            : 
     290                 :            : size_t
     291                 :        241 : spdk_str_chomp(char *s)
     292                 :            : {
     293         [ -  + ]:        241 :         size_t len = strlen(s);
     294                 :        241 :         size_t removed = 0;
     295                 :            : 
     296         [ +  + ]:        294 :         while (len > 0) {
     297   [ +  +  +  + ]:        282 :                 if (s[len - 1] != '\r' && s[len - 1] != '\n') {
     298                 :        229 :                         break;
     299                 :            :                 }
     300                 :            : 
     301                 :         53 :                 s[len - 1] = '\0';
     302                 :         53 :                 len--;
     303                 :         53 :                 removed++;
     304                 :            :         }
     305                 :            : 
     306                 :        241 :         return removed;
     307                 :            : }
     308                 :            : 
     309                 :            : void
     310                 :     264221 : 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         [ -  + ]:     264221 :         new_buffer = strerror_r(errnum, buf, buflen);
     317         [ +  + ]:     264221 :         if (new_buffer == buf) {
     318                 :        102 :                 rc = 0;
     319         [ +  - ]:     264119 :         } else if (new_buffer != NULL) {
     320         [ -  + ]:     264119 :                 snprintf(buf, buflen, "%s", new_buffer);
     321                 :     264119 :                 rc = 0;
     322                 :            :         } else {
     323                 :          0 :                 rc = 1;
     324                 :            :         }
     325                 :            : #else
     326                 :            :         rc = strerror_r(errnum, buf, buflen);
     327                 :            : #endif
     328                 :            : 
     329         [ -  + ]:     264221 :         if (rc != 0) {
     330         [ #  # ]:          0 :                 snprintf(buf, buflen, "Unknown error %d", errnum);
     331                 :            :         }
     332                 :     264221 : }
     333                 :            : 
     334                 :            : int
     335                 :        798 : spdk_parse_capacity(const char *cap_str, uint64_t *cap, bool *has_prefix)
     336                 :            : {
     337                 :            :         int rc;
     338                 :        335 :         char bin_prefix;
     339                 :            : 
     340                 :        798 :         rc = sscanf(cap_str, "%"SCNu64"%c", cap, &bin_prefix);
     341         [ +  + ]:        798 :         if (rc == 1) {
     342         [ +  + ]:        577 :                 if (has_prefix != NULL) {
     343                 :        128 :                         *has_prefix = false;
     344                 :            :                 }
     345                 :        577 :                 return 0;
     346         [ +  + ]:        221 :         } else if (rc == 0) {
     347         [ +  + ]:         12 :                 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                 :          6 :                         return -errno;
     353                 :            :                 }
     354                 :            :         }
     355                 :            : 
     356         [ +  + ]:        209 :         if (has_prefix != NULL) {
     357                 :         48 :                 *has_prefix = true;
     358                 :            :         }
     359                 :            : 
     360   [ +  +  +  - ]:        209 :         switch (bin_prefix) {
     361                 :        132 :         case 'k':
     362                 :            :         case 'K':
     363                 :        132 :                 *cap *= 1024;
     364                 :        132 :                 break;
     365                 :         71 :         case 'm':
     366                 :            :         case 'M':
     367                 :         71 :                 *cap *= 1024 * 1024;
     368                 :         71 :                 break;
     369                 :          6 :         case 'g':
     370                 :            :         case 'G':
     371                 :          6 :                 *cap *= 1024 * 1024 * 1024;
     372                 :          6 :                 break;
     373                 :          0 :         default:
     374                 :          0 :                 return -EINVAL;
     375                 :            :         }
     376                 :            : 
     377                 :        209 :         return 0;
     378                 :            : }
     379                 :            : 
     380                 :            : bool
     381                 :     218236 : spdk_mem_all_zero(const void *data, size_t size)
     382                 :            : {
     383                 :     218236 :         const uint8_t *buf = data;
     384                 :            : 
     385         [ +  + ]:  536439698 :         while (size--) {
     386         [ +  + ]:  536227360 :                 if (*buf++ != 0) {
     387                 :       5933 :                         return false;
     388                 :            :                 }
     389                 :            :         }
     390                 :            : 
     391                 :     212303 :         return true;
     392                 :            : }
     393                 :            : 
     394                 :            : long int
     395                 :      23181 : spdk_strtol(const char *nptr, int base)
     396                 :            : {
     397                 :            :         long val;
     398                 :       1660 :         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                 :      23181 :         errno = 0;
     405                 :            : 
     406         [ -  + ]:      23181 :         val = strtol(nptr, &endptr, base);
     407                 :            : 
     408   [ +  +  +  + ]:      23181 :         if (!errno && *endptr != '\0') {
     409                 :            :                 /* Non integer character was found. */
     410                 :         88 :                 return -EINVAL;
     411   [ +  +  +  +  :      23093 :         } else if (errno == ERANGE && (val == LONG_MAX || val == LONG_MIN)) {
                   +  - ]
     412                 :            :                 /* Overflow occurred. */
     413                 :         12 :                 return -ERANGE;
     414   [ +  +  +  - ]:      23081 :         } else if (errno != 0 && val == 0) {
     415                 :            :                 /* Other error occurred. */
     416                 :          6 :                 return -errno;
     417         [ +  + ]:      23075 :         } else if (val < 0) {
     418                 :            :                 /* Input string was negative number. */
     419                 :         39 :                 return -ERANGE;
     420                 :            :         }
     421                 :            : 
     422                 :      23036 :         return val;
     423                 :            : }
     424                 :            : 
     425                 :            : long long int
     426                 :       1190 : spdk_strtoll(const char *nptr, int base)
     427                 :            : {
     428                 :            :         long long val;
     429                 :        608 :         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                 :       1190 :         errno = 0;
     436                 :            : 
     437         [ -  + ]:       1190 :         val = strtoll(nptr, &endptr, base);
     438                 :            : 
     439   [ +  +  +  + ]:       1190 :         if (!errno && *endptr != '\0') {
     440                 :            :                 /* Non integer character was found. */
     441                 :         19 :                 return -EINVAL;
     442   [ +  +  +  +  :       1171 :         } else if (errno == ERANGE && (val == LLONG_MAX || val == LLONG_MIN)) {
                   +  - ]
     443                 :            :                 /* Overflow occurred. */
     444                 :         12 :                 return -ERANGE;
     445   [ +  +  +  - ]:       1159 :         } else if (errno != 0 && val == 0) {
     446                 :            :                 /* Other error occurred. */
     447                 :          6 :                 return -errno;
     448         [ +  + ]:       1153 :         } else if (val < 0) {
     449                 :            :                 /* Input string was negative number. */
     450                 :         12 :                 return -ERANGE;
     451                 :            :         }
     452                 :            : 
     453                 :       1141 :         return val;
     454                 :            : }
     455                 :            : 
     456                 :            : void
     457                 :       5901 : spdk_strarray_free(char **strarray)
     458                 :            : {
     459                 :            :         size_t i;
     460                 :            : 
     461         [ +  + ]:       5901 :         if (strarray == NULL) {
     462                 :       5826 :                 return;
     463                 :            :         }
     464                 :            : 
     465         [ +  + ]:        267 :         for (i = 0; strarray[i] != NULL; i++) {
     466                 :        192 :                 free(strarray[i]);
     467                 :            :         }
     468                 :         75 :         free(strarray);
     469                 :            : }
     470                 :            : 
     471                 :            : char **
     472                 :         69 : spdk_strarray_from_string(const char *str, const char *delim)
     473                 :            : {
     474                 :         69 :         const char *c = str;
     475                 :         69 :         size_t count = 0;
     476                 :            :         char **result;
     477                 :            :         size_t i;
     478                 :            : 
     479         [ -  + ]:         69 :         assert(str != NULL);
     480         [ -  + ]:         69 :         assert(delim != NULL);
     481                 :            : 
     482                 :            :         /* Count number of entries. */
     483                 :         93 :         for (;;) {
     484   [ -  +  -  + ]:        162 :                 const char *next = strpbrk(c, delim);
     485                 :            : 
     486                 :        162 :                 count++;
     487                 :            : 
     488         [ +  + ]:        162 :                 if (next == NULL) {
     489                 :         69 :                         break;
     490                 :            :                 }
     491                 :            : 
     492                 :         93 :                 c = next + 1;
     493                 :            :         }
     494                 :            : 
     495                 :            :         /* Account for the terminating NULL entry. */
     496                 :         69 :         result = calloc(count + 1, sizeof(char *));
     497         [ -  + ]:         69 :         if (result == NULL) {
     498                 :          0 :                 return NULL;
     499                 :            :         }
     500                 :            : 
     501                 :         69 :         c = str;
     502                 :            : 
     503         [ +  + ]:        231 :         for (i = 0; i < count; i++) {
     504   [ -  +  -  + ]:        162 :                 const char *next = strpbrk(c, delim);
     505                 :            : 
     506         [ +  + ]:        162 :                 if (next == NULL) {
     507         [ -  + ]:         69 :                         result[i] = strdup(c);
     508                 :            :                 } else {
     509         [ -  + ]:         93 :                         result[i] = strndup(c, next - c);
     510                 :            :                 }
     511                 :            : 
     512         [ -  + ]:        162 :                 if (result[i] == NULL) {
     513                 :          0 :                         spdk_strarray_free(result);
     514                 :          0 :                         return NULL;
     515                 :            :                 }
     516                 :            : 
     517         [ +  + ]:        162 :                 if (next != NULL) {
     518                 :         93 :                         c = next + 1;
     519                 :            :                 }
     520                 :            :         }
     521                 :            : 
     522                 :         69 :         return result;
     523                 :            : }
     524                 :            : 
     525                 :            : char **
     526                 :         48 : spdk_strarray_dup(const char **strarray)
     527                 :            : {
     528                 :            :         size_t count, i;
     529                 :            :         char **result;
     530                 :            : 
     531         [ -  + ]:         48 :         assert(strarray != NULL);
     532                 :            : 
     533         [ +  + ]:        162 :         for (count = 0; strarray[count] != NULL; count++)
     534                 :            :                 ;
     535                 :            : 
     536                 :         48 :         result = calloc(count + 1, sizeof(char *));
     537         [ -  + ]:         48 :         if (result == NULL) {
     538                 :          0 :                 return NULL;
     539                 :            :         }
     540                 :            : 
     541         [ +  + ]:        162 :         for (i = 0; i < count; i++) {
     542         [ -  + ]:        114 :                 result[i] = strdup(strarray[i]);
     543         [ -  + ]:        114 :                 if (result[i] == NULL) {
     544                 :          0 :                         spdk_strarray_free(result);
     545                 :          0 :                         return NULL;
     546                 :            :                 }
     547                 :            :         }
     548                 :            : 
     549                 :         48 :         return result;
     550                 :            : }
     551                 :            : 
     552                 :            : int
     553                 :        126 : 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   [ +  +  +  -  :        126 :         if (dst == NULL || src == NULL || search == NULL || replace == NULL) {
             +  -  -  + ]
     561                 :          6 :                 return -EINVAL;
     562                 :            :         }
     563                 :            : 
     564         [ -  + ]:        120 :         search_size = strlen(search);
     565         [ -  + ]:        120 :         replace_size = strlen(replace);
     566                 :            : 
     567                 :        120 :         c = 0;
     568   [ +  +  -  +  :        222 :         for (p = strstr(src, search); p != NULL; p = strstr(p + search_size, search)) {
          -  +  -  +  +  
                      + ]
     569                 :        102 :                 c++;
     570                 :            :         }
     571                 :            : 
     572         [ -  + ]:        120 :         dst_size = strlen(src) + (replace_size - search_size) * c;
     573         [ +  + ]:        120 :         if (dst_size >= size) {
     574                 :          6 :                 return -EINVAL;
     575                 :            :         }
     576                 :            : 
     577                 :        114 :         q = src;
     578                 :        114 :         r = dst;
     579                 :            : 
     580   [ +  +  -  +  :        210 :         for (p = strstr(src, search); p != NULL; p = strstr(p + search_size, search)) {
          -  +  -  +  +  
                      + ]
     581   [ -  +  -  + ]:         96 :                 memcpy(r, q, p - q);
     582                 :         96 :                 r += p - q;
     583                 :            : 
     584   [ -  +  -  + ]:         96 :                 memcpy(r, replace, replace_size);
     585                 :         96 :                 r += replace_size;
     586                 :            : 
     587                 :         96 :                 q = p + search_size;
     588                 :            :         }
     589                 :            : 
     590   [ -  +  -  +  :        114 :         memcpy(r, q, strlen(q));
                   -  + ]
     591         [ -  + ]:        114 :         r += strlen(q);
     592                 :            : 
     593                 :        114 :         *r = '\0';
     594                 :            : 
     595                 :        114 :         return 0;
     596                 :            : }

Generated by: LCOV version 1.14