1  /* String replacement in an argz vector
       2     Copyright (C) 1997-2023 Free Software Foundation, Inc.
       3     This file is part of the GNU C Library.
       4  
       5     The GNU C Library is free software; you can redistribute it and/or
       6     modify it under the terms of the GNU Lesser General Public
       7     License as published by the Free Software Foundation; either
       8     version 2.1 of the License, or (at your option) any later version.
       9  
      10     The GNU C Library is distributed in the hope that it will be useful,
      11     but WITHOUT ANY WARRANTY; without even the implied warranty of
      12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      13     Lesser General Public License for more details.
      14  
      15     You should have received a copy of the GNU Lesser General Public
      16     License along with the GNU C Library; if not, see
      17     <https://www.gnu.org/licenses/>.  */
      18  
      19  #include <stdlib.h>
      20  #include <string.h>
      21  #include <argz.h>
      22  
      23  /* Append BUF, of length BUF_LEN to *TO, of length *TO_LEN, reallocating and
      24     updating *TO & *TO_LEN appropriately.  If an allocation error occurs,
      25     *TO's old value is freed, and *TO is set to 0.  */
      26  static void
      27  str_append (char **to, size_t *to_len, const char *buf, const size_t buf_len)
      28  {
      29    size_t new_len = *to_len + buf_len;
      30    char *new_to = realloc (*to, new_len + 1);
      31  
      32    if (new_to)
      33      {
      34        *((char *) __mempcpy (new_to + *to_len, buf, buf_len)) = '\0';
      35        *to = new_to;
      36        *to_len = new_len;
      37      }
      38    else
      39      {
      40        free (*to);
      41        *to = 0;
      42      }
      43  }
      44  
      45  /* Replace any occurrences of the string STR in ARGZ with WITH, reallocating
      46     ARGZ as necessary.  If REPLACE_COUNT is non-zero, *REPLACE_COUNT will be
      47     incremented by number of replacements performed.  */
      48  error_t
      49  __argz_replace (char **argz, size_t *argz_len, const char *str, const char *with,
      50  		unsigned *replace_count)
      51  {
      52    error_t err = 0;
      53  
      54    if (str && *str)
      55      {
      56        char *arg = 0;
      57        char *src = *argz;
      58        size_t src_len = *argz_len;
      59        char *dst = 0;
      60        size_t dst_len = 0;
      61        int delayed_copy = 1;	/* True while we've avoided copying anything.  */
      62        size_t str_len = strlen (str), with_len = strlen (with);
      63  
      64        while (!err && (arg = argz_next (src, src_len, arg)))
      65  	{
      66  	  char *match = strstr (arg, str);
      67  	  if (match)
      68  	    {
      69  	      char *from = match + str_len;
      70  	      size_t to_len = match - arg;
      71  	      char *to = __strndup (arg, to_len);
      72  
      73  	      while (to && from)
      74  		{
      75  		  str_append (&to, &to_len, with, with_len);
      76  		  if (to)
      77  		    {
      78  		      match = strstr (from, str);
      79  		      if (match)
      80  			{
      81  			  str_append (&to, &to_len, from, match - from);
      82  			  from = match + str_len;
      83  			}
      84  		      else
      85  			{
      86  			  str_append (&to, &to_len, from, strlen (from));
      87  			  from = 0;
      88  			}
      89  		    }
      90  		}
      91  
      92  	      if (to)
      93  		{
      94  		  if (delayed_copy)
      95  		    /* We avoided copying SRC to DST until we found a match;
      96                         now that we've done so, copy everything from the start
      97                         of SRC.  */
      98  		    {
      99  		      if (arg > src)
     100  			err = __argz_append (&dst, &dst_len, src, (arg - src));
     101  		      delayed_copy = 0;
     102  		    }
     103  		  if (! err)
     104  		    err = __argz_add (&dst, &dst_len, to);
     105  		  free (to);
     106  		}
     107  	      else
     108  		err = ENOMEM;
     109  
     110  	      if (replace_count)
     111  		(*replace_count)++;
     112  	    }
     113  	  else if (! delayed_copy)
     114  	    err = __argz_add (&dst, &dst_len, arg);
     115  	}
     116  
     117        if (! err)
     118  	{
     119  	  if (! delayed_copy)
     120  	    /* We never found any instances of str.  */
     121  	    {
     122  	      free (src);
     123  	      *argz = dst;
     124  	      *argz_len = dst_len;
     125  	    }
     126  	}
     127        else if (dst_len > 0)
     128  	free (dst);
     129      }
     130  
     131    return err;
     132  }
     133  weak_alias (__argz_replace, argz_replace)