lib/strutil/strescape.c

   1 /*
   2    Functions for escaping and unescaping strings
   3
   4    Copyright (C) 2009, 2011
   5    The Free Software Foundation, Inc.
   6
   7    Written by:
   8    Slava Zanko <slavazanko@gmail.com>, 2009;
   9    Patrick Winnertz <winnie@debian.org>, 2009
  10
  11    This file is part of the Midnight Commander.
  12
  13    The Midnight Commander is free software: you can redistribute it
  14    and/or modify it under the terms of the GNU General Public License as
  15    published by the Free Software Foundation, either version 3 of the License,
  16    or (at your option) any later version.
  17
  18    The Midnight Commander is distributed in the hope that it will be useful,
  19    but WITHOUT ANY WARRANTY; without even the implied warranty of
  20    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21    GNU General Public License for more details.
  22
  23    You should have received a copy of the GNU General Public License
  24    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  25  */
  26
  27 #include <config.h>
  28
  29 #include "lib/strescape.h"
  30
  31 /*** global variables ****************************************************************************/
  32
  33 /*** file scope macro definitions ****************************************************************/
  34
  35 /*** file scope type declarations ****************************************************************/
  36
  37 /*** file scope variables ************************************************************************/
  38
  39 static const char ESCAPE_SHELL_CHARS[] = " !#$%()&{}[]`?|<>;*\\\"'";
  40 static const char ESCAPE_REGEX_CHARS[] = "^!#$%()&{}[]`?|<>;*.\\";
  41 static const char ESCAPE_GLOB_CHARS[] = "$*\\?";
  42
  43 /*** file scope functions ************************************************************************/
  44
  45 /*** public functions ****************************************************************************/
  46
  47 char *
  48 strutils_escape (const char *src, gsize src_len, const char *escaped_chars,
  49                  gboolean escape_non_printable)
  50 {
  51     GString *ret;
  52     gsize curr_index;
  53     /* do NOT break allocation semantics */
  54     if (src == NULL)
  55         return NULL;
  56
  57     if (*src == '\0')
  58         return strdup ("");
  59
  60     ret = g_string_new ("");
  61
  62     if (src_len == (gsize) - 1)
  63         src_len = strlen (src);
  64
  65     for (curr_index = 0; curr_index < src_len; curr_index++)
  66     {
  67         if (escape_non_printable)
  68         {
  69             switch (src[curr_index])
  70             {
  71             case '\n':
  72                 g_string_append (ret, "\\n");
  73                 continue;
  74             case '\t':
  75                 g_string_append (ret, "\\t");
  76                 continue;
  77             case '\b':
  78                 g_string_append (ret, "\\b");
  79                 continue;
  80             case '\0':
  81                 g_string_append (ret, "\\0");
  82                 continue;
  83             }
  84         }
  85
  86         if (strchr (escaped_chars, (int) src[curr_index]))
  87             g_string_append_c (ret, '\\');
  88
  89         g_string_append_c (ret, src[curr_index]);
  90     }
  91     return g_string_free (ret, FALSE);
  92 }
  93
  94 /* --------------------------------------------------------------------------------------------- */
  95 char *
  96 strutils_unescape (const char *src, gsize src_len, const char *unescaped_chars,
  97                    gboolean unescape_non_printable)
  98 {
  99     GString *ret;
 100     gsize curr_index;
 101
 102     if (src == NULL)
 103         return NULL;
 104
 105     if (*src == '\0')
 106         return strdup ("");
 107
 108     ret = g_string_sized_new (16);
 109
 110     if (src_len == (gsize) (-1))
 111         src_len = strlen (src);
 112     src_len--;
 113
 114     for (curr_index = 0; curr_index < src_len; curr_index++)
 115     {
 116         if (src[curr_index] != '\\')
 117         {
 118             g_string_append_c (ret, src[curr_index]);
 119             continue;
 120         }
 121
 122         curr_index++;
 123
 124         if (unescaped_chars == ESCAPE_SHELL_CHARS && src[curr_index] == '$')
 125         {
 126             /* special case: \$ is used to disallow variable substitution */
 127             g_string_append_c (ret, '\\');
 128         }
 129         else
 130         {
 131             if (unescape_non_printable)
 132             {
 133                 switch (src[curr_index])
 134                 {
 135                 case 'n':
 136                     g_string_append_c (ret, '\n');
 137                     continue;
 138                 case 't':
 139                     g_string_append_c (ret, '\t');
 140                     continue;
 141                 case 'b':
 142                     g_string_append_c (ret, '\b');
 143                     continue;
 144                 case '0':
 145                     g_string_append_c (ret, '\0');
 146                     continue;
 147                 }
 148             }
 149
 150             if (strchr (unescaped_chars, (int) src[curr_index]) == NULL)
 151                 g_string_append_c (ret, '\\');
 152         }
 153
 154         g_string_append_c (ret, src[curr_index]);
 155     }
 156     g_string_append_c (ret, src[curr_index]);
 157
 158     return g_string_free (ret, FALSE);
 159 }
 160
 161 /* --------------------------------------------------------------------------------------------- */
 162
 163 /** To be compatible with the general posix command lines we have to escape
 164  strings for the command line
 165
 166  \param src
 167  string for escaping
 168
 169  \returns
 170  return escaped string (which needs to be freed later)
 171         or NULL when NULL string is passed.
 172  */
 173 char *
 174 strutils_shell_escape (const char *src)
 175 {
 176     return strutils_escape (src, -1, ESCAPE_SHELL_CHARS, FALSE);
 177 }
 178
 179 /* --------------------------------------------------------------------------------------------- */
 180
 181 char *
 182 strutils_glob_escape (const char *src)
 183 {
 184     return strutils_escape (src, -1, ESCAPE_GLOB_CHARS, TRUE);
 185 }
 186
 187 /* --------------------------------------------------------------------------------------------- */
 188
 189 char *
 190 strutils_regex_escape (const char *src)
 191 {
 192     return strutils_escape (src, -1, ESCAPE_REGEX_CHARS, TRUE);
 193 }
 194
 195 /* --------------------------------------------------------------------------------------------- */
 196
 197 /** Unescape paths or other strings for e.g the internal cd
 198     shell-unescape within a given buffer (writing to it!)
 199
 200  \param text
 201  string for unescaping
 202
 203  \returns
 204  return unescaped string (which needs to be freed)
 205  */
 206 char *
 207 strutils_shell_unescape (const char *text)
 208 {
 209     return strutils_unescape (text, -1, ESCAPE_SHELL_CHARS, TRUE);
 210 }
 211
 212 /* --------------------------------------------------------------------------------------------- */
 213
 214 char *
 215 strutils_glob_unescape (const char *text)
 216 {
 217     return strutils_unescape (text, -1, ESCAPE_GLOB_CHARS, TRUE);
 218 }
 219
 220 /* --------------------------------------------------------------------------------------------- */
 221 char *
 222 strutils_regex_unescape (const char *text)
 223 {
 224     return strutils_unescape (text, -1, ESCAPE_REGEX_CHARS, TRUE);
 225 }
 226
 227 /* --------------------------------------------------------------------------------------------- */
 228
 229 /** Check if char in pointer contain escape'd chars
 230
 231  \param start
 232  string for checking
 233
 234  \param current
 235  pointer to checked character
 236
 237  \returns
 238  return TRUE if string contain escaped chars
 239  otherwise return FALSE
 240  */
 241 gboolean
 242 strutils_is_char_escaped (const char *start, const char *current)
 243 {
 244     int num_esc = 0;
 245
 246     if (start == NULL || current == NULL || current <= start)
 247         return FALSE;
 248
 249     current--;
 250     while (current >= start && *current == '\\')
 251     {
 252         num_esc++;
 253         current--;
 254     }
 255     return (gboolean) num_esc % 2;
 256 }
 257
 258 /* --------------------------------------------------------------------------------------------- */