lib/util/substitute.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     2005
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  22 */
  23
  24 #include "replace.h"
  25 #include "debug.h"
  26 #ifndef SAMBA_UTIL_CORE_ONLY
  27 #include "charset/charset.h"
  28 #else
  29 #include "charset_compat.h"
  30 #endif
  31 #include "substitute.h"
  32
  33 /**
  34  * @file
  35  * @brief Substitute utilities.
  36  **/
  37
  38 /**
  39  Substitute a string for a pattern in another string. Make sure there is
  40  enough room!
  41
  42  This routine looks for pattern in s and replaces it with
  43  insert. It may do multiple replacements or just one.
  44
  45  Any of " ; ' $ or ` in the insert string are replaced with _
  46  if len==0 then the string cannot be extended. This is different from the old
  47  use of len==0 which was for no length checks to be done.
  48 **/
  49
  50 static void string_sub2(char *s,const char *pattern, const char *insert, size_t len,
  51                         bool remove_unsafe_characters, bool replace_once,
  52                         bool allow_trailing_dollar)
  53 {
  54         char *p;
  55         ssize_t ls, lp, li, i;
  56
  57         if (!insert || !pattern || !*pattern || !s)
  58                 return;
  59
  60         ls = (ssize_t)strlen(s);
  61         lp = (ssize_t)strlen(pattern);
  62         li = (ssize_t)strlen(insert);
  63
  64         if (len == 0)
  65                 len = ls + 1; /* len is number of *bytes* */
  66
  67         while (lp <= ls && (p = strstr_m(s,pattern))) {
  68                 if (ls + (li-lp) >= len) {
  69                         DEBUG(0,("ERROR: string overflow by "
  70                                 "%d in string_sub(%.50s, %d)\n",
  71                                  (int)(ls + (li-lp) - len),
  72                                  pattern, (int)len));
  73                         break;
  74                 }
  75                 if (li != lp) {
  76                         memmove(p+li,p+lp,strlen(p+lp)+1);
  77                 }
  78                 for (i=0;i<li;i++) {
  79                         switch (insert[i]) {
  80                         case '$':
  81                                 /* allow a trailing $
  82                                  * (as in machine accounts) */
  83                                 if (allow_trailing_dollar && (i == li - 1 )) {
  84                                         p[i] = insert[i];
  85                                         break;
  86                                 }
  87                         case '`':
  88                         case '"':
  89                         case '\'':
  90                         case ';':
  91                         case '%':
  92                         case '\r':
  93                         case '\n':
  94                                 if ( remove_unsafe_characters ) {
  95                                         p[i] = '_';
  96                                         /* yes this break should be here
  97                                          * since we want to fall throw if
  98                                          * not replacing unsafe chars */
  99                                         break;
 100                                 }
 101                         default:
 102                                 p[i] = insert[i];
 103                         }
 104                 }
 105                 s = p + li;
 106                 ls += (li-lp);
 107
 108                 if (replace_once)
 109                         break;
 110         }
 111 }
 112
 113 void string_sub_once(char *s, const char *pattern,
 114                 const char *insert, size_t len)
 115 {
 116         string_sub2( s, pattern, insert, len, true, true, false );
 117 }
 118
 119 void string_sub(char *s,const char *pattern, const char *insert, size_t len)
 120 {
 121         string_sub2( s, pattern, insert, len, true, false, false );
 122 }
 123
 124 /**
 125  * Talloc'ed version of string_sub
 126  */
 127 _PUBLIC_ char *string_sub_talloc(TALLOC_CTX *mem_ctx, const char *s,
 128                                 const char *pattern, const char *insert)
 129 {
 130         const char *p;
 131         char *ret;
 132         size_t len, alloc_len;
 133
 134         if (insert == NULL || pattern == NULL || !*pattern || s == NULL)
 135                 return NULL;
 136
 137         /* determine length needed */
 138         len = strlen(s);
 139
 140         for (p = strstr(s, pattern); p != NULL;
 141              p = strstr(p+strlen(pattern), pattern)) {
 142                 len += strlen(insert) - strlen(pattern);
 143         }
 144
 145         alloc_len = MAX(len, strlen(s))+1;
 146         ret = talloc_array(mem_ctx, char, alloc_len);
 147         if (ret == NULL)
 148                 return NULL;
 149         strncpy(ret, s, alloc_len);
 150         string_sub(ret, pattern, insert, alloc_len);
 151
 152         ret = talloc_realloc(mem_ctx, ret, char, len+1);
 153         if (ret == NULL)
 154                 return NULL;
 155
 156         if (ret[len] != '\0') {
 157                 DEBUG(0,("Internal error at %s(%d): string not terminated\n",
 158                          __FILE__, __LINE__));
 159                 abort();
 160         }
 161
 162         talloc_set_name_const(ret, ret);
 163
 164         return ret;
 165 }
 166
 167 /**
 168  Similar to string_sub() but allows for any character to be substituted.
 169  Use with caution!
 170  if len==0 then the string cannot be extended. This is different from the old
 171  use of len==0 which was for no length checks to be done.
 172 **/
 173
 174 _PUBLIC_ void all_string_sub(char *s,const char *pattern,const char *insert, size_t len)
 175 {
 176         char *p;
 177         ssize_t ls,lp,li;
 178
 179         if (!insert || !pattern || !s)
 180                 return;
 181
 182         ls = (ssize_t)strlen(s);
 183         lp = (ssize_t)strlen(pattern);
 184         li = (ssize_t)strlen(insert);
 185
 186         if (!*pattern)
 187                 return;
 188
 189         if (len == 0)
 190                 len = ls + 1; /* len is number of *bytes* */
 191
 192         while (lp <= ls && (p = strstr_m(s,pattern))) {
 193                 if (ls + (li-lp) >= len) {
 194                         DEBUG(0,("ERROR: string overflow by "
 195                                 "%d in all_string_sub(%.50s, %d)\n",
 196                                  (int)(ls + (li-lp) - len),
 197                                  pattern, (int)len));
 198                         break;
 199                 }
 200                 if (li != lp) {
 201                         memmove(p+li,p+lp,strlen(p+lp)+1);
 202                 }
 203                 memcpy(p, insert, li);
 204                 s = p + li;
 205                 ls += (li-lp);
 206         }
 207 }