source3/lib/substitute_generic.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Samba utility functions
   4
   5    Copyright (C) Andrew Tridgell 1992-2001
   6    Copyright (C) Simo Sorce      2001-2002
   7    Copyright (C) Martin Pool     2003
   8    Copyright (C) James Peach     2006
   9    Copyright (C) Jeremy Allison  1992-2007
  10
  11    This program is free software; you can redistribute it and/or modify
  12    it under the terms of the GNU General Public License as published by
  13    the Free Software Foundation; either version 3 of the License, or
  14    (at your option) any later version.
  15
  16    This program is distributed in the hope that it will be useful,
  17    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19    GNU General Public License for more details.
  20
  21    You should have received a copy of the GNU General Public License
  22    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  23 */
  24
  25 #include "includes.h"
  26
  27 /**
  28  Similar to string_sub2, but it will accept only allocated strings
  29  and may realloc them so pay attention at what you pass on no
  30  pointers inside strings, no const may be passed
  31  as string.
  32 **/
  33
  34 char *realloc_string_sub2(char *string,
  35                         const char *pattern,
  36                         const char *insert,
  37                         bool remove_unsafe_characters,
  38                         bool allow_trailing_dollar)
  39 {
  40         char *p, *in;
  41         char *s;
  42         ssize_t ls,lp,li,ld, i;
  43
  44         if (!insert || !pattern || !*pattern || !string || !*string)
  45                 return NULL;
  46
  47         s = string;
  48
  49         in = talloc_strdup(talloc_tos(), insert);
  50         if (!in) {
  51                 DEBUG(0, ("realloc_string_sub: out of memory!\n"));
  52                 return NULL;
  53         }
  54         ls = (ssize_t)strlen(s);
  55         lp = (ssize_t)strlen(pattern);
  56         li = (ssize_t)strlen(insert);
  57         ld = li - lp;
  58         for (i=0;i<li;i++) {
  59                 switch (in[i]) {
  60                         case '$':
  61                                 /* allow a trailing $
  62                                  * (as in machine accounts) */
  63                                 if (allow_trailing_dollar && (i == li - 1 )) {
  64                                         break;
  65                                 }
  66                                 FALL_THROUGH;
  67                         case '`':
  68                         case '"':
  69                         case '\'':
  70                         case ';':
  71                         case '%':
  72                         case '\r':
  73                         case '\n':
  74                                 if ( remove_unsafe_characters ) {
  75                                         in[i] = '_';
  76                                         break;
  77                                 }
  78                                 FALL_THROUGH;
  79                         default:
  80                                 /* ok */
  81                                 break;
  82                 }
  83         }
  84
  85         while ((p = strstr_m(s,pattern))) {
  86                 if (ld > 0) {
  87                         int offset = PTR_DIFF(s,string);
  88                         string = talloc_realloc(NULL, string, char, ls + ld + 1);
  89                         if (!string) {
  90                                 DEBUG(0, ("realloc_string_sub: "
  91                                         "out of memory!\n"));
  92                                 talloc_free(in);
  93                                 return NULL;
  94                         }
  95                         p = string + offset + (p - s);
  96                 }
  97                 if (li != lp) {
  98                         memmove(p+li,p+lp,strlen(p+lp)+1);
  99                 }
 100                 memcpy(p, in, li);
 101                 s = p + li;
 102                 ls += ld;
 103         }
 104         talloc_free(in);
 105         return string;
 106 }
 107
 108 char *realloc_string_sub(char *string,
 109                         const char *pattern,
 110                         const char *insert)
 111 {
 112         return realloc_string_sub2(string, pattern, insert, true, false);
 113 }