src/strescape.c

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