src/str_utils.c

   1 /*
   2  * This program is free software; you can redistribute it and/or
   3  * modify it under the terms of the GNU General Public License
   4  * as published by the Free Software Foundation; either version 2
   5  * of the License, or (at your option) any later version.
   6  *
   7  * This program is distributed in the hope that it will be useful,
   8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  * GNU General Public License for more details.
  11  *
  12  * You should have received a copy of the GNU General Public License
  13  * along with this program; if not, write to the Free Software
  14  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  15  *
  16  * See the COPYING file for license information.
  17  *
  18  * Guillaume Chazarain <guichaz@yahoo.fr>
  19  */
  20
  21 /*******************************************
  22  * UTF-8, filenames and mnemonics handling *
  23  *******************************************/
  24
  25 #include <string.h>             /* strstr(), strchr(), memcpy(), strcpy() */
  26 #include <stdlib.h>             /* getenv() */
  27
  28 #include "gliv.h"
  29 #include "str_utils.h"
  30
  31 /* If you can't stand string manipulations in C, just don't look there */
  32
  33 gint common_prefix_length(const gchar * str1, const gchar * str2)
  34 {
  35     const gchar *orig_str1 = str1;
  36
  37     if (NOT_ALIGNED(str1) == NOT_ALIGNED(str2)) {
  38         /* We can align both pointers. */
  39         while (NOT_ALIGNED(str1) && *str1 == *str2 && *str1 != '\0') {
  40             str1++;
  41             str2++;
  42         }
  43
  44         if (*str1 != '\0' && *str1 == *str2) {
  45             /* Both pointers are now aligned. */
  46             gulong *long_ptr1 = (gulong *) str1, *long_ptr2 = (gulong *) str2;
  47
  48             /* Skip identical blocks in the paths. */
  49             while (!HAS_ZERO(*long_ptr1) && *long_ptr1 == *long_ptr2) {
  50                 long_ptr1++;
  51                 long_ptr2++;
  52             }
  53
  54             str1 = (const gchar *) long_ptr1;
  55             str2 = (const gchar *) long_ptr2;
  56         }
  57     }
  58
  59     /* Skip identical characters in the paths. */
  60     while (*str1 != '\0' && *str1 == *str2) {
  61         str1++;
  62         str2++;
  63     }
  64
  65     return str1 - orig_str1;
  66 }
  67
  68 #define CHECK_BYTE(ptr)   \
  69     do {                  \
  70         if (*ptr == '\0') \
  71             return TRUE;  \
  72                           \
  73         if (*ptr >> 7)    \
  74             return FALSE; \
  75                           \
  76         ptr++;            \
  77     } while (0)
  78
  79 static gboolean str_is_ascii(const gchar * str)
  80 {
  81     gulong *long_ptr, long_int;
  82
  83     for (;;) {
  84         if (*str == '\0')
  85             return TRUE;
  86
  87         if (*str >> 7)
  88             return FALSE;
  89
  90         if (!NOT_ALIGNED(str))
  91             /* Aligned. */
  92             break;
  93
  94         str++;
  95     }
  96
  97     long_ptr = (gulong *) str;
  98
  99     for (;;) {
 100         long_int = *long_ptr;
 101         if (HAS_ZERO(long_int)) {
 102             /* A '\0' has been detected. */
 103             const gchar *char_ptr = (const gchar *) long_ptr;
 104             CHECK_BYTE(char_ptr);
 105             CHECK_BYTE(char_ptr);
 106             CHECK_BYTE(char_ptr);
 107             CHECK_BYTE(char_ptr);
 108             if (sizeof(gulong) > 4) {
 109                 /* 64-bit */
 110                 CHECK_BYTE(char_ptr);
 111                 CHECK_BYTE(char_ptr);
 112                 CHECK_BYTE(char_ptr);
 113                 CHECK_BYTE(char_ptr);
 114             }
 115         } else if (long_int & LONG_MASK(0x80808080L, 0x8080808080808080L))
 116             return FALSE;
 117
 118         long_ptr++;
 119     }
 120     return TRUE;
 121 }
 122
 123 /* From glib. */
 124 static gboolean have_broken_filenames(void)
 125 {
 126     static gboolean initialized = FALSE;
 127     static gboolean broken;
 128
 129     if (initialized)
 130         return broken;
 131
 132     broken = getenv("G_BROKEN_FILENAMES") != NULL;
 133     initialized = TRUE;
 134
 135     return broken;
 136 }
 137
 138 /* The returned string should not be freed. */
 139 const gchar *filename_to_utf8(const gchar * str)
 140 {
 141     static GStaticPrivate result_key = G_STATIC_PRIVATE_INIT;
 142     gchar **result;
 143     GError *err = NULL;
 144
 145     if (!have_broken_filenames() || g_get_charset(NULL) || str_is_ascii(str))
 146         return str;
 147
 148     result = g_static_private_get(&result_key);
 149     if (result == NULL) {
 150         /* First time in this thread. */
 151         result = g_new(gchar *, 1);
 152         g_static_private_set(&result_key, result, g_free);
 153         *result = NULL;
 154     }
 155
 156     g_free(*result);
 157
 158     *result = g_filename_to_utf8(str, -1, NULL, NULL, &err);
 159     if (err != NULL) {
 160         g_printerr("%s\n", err->message);
 161         g_error_free(err);
 162
 163         g_free(*result);
 164         *result = NULL;
 165         return str;
 166     }
 167
 168     return *result;
 169 }
 170
 171 static gboolean starts_dotslash(const gchar * str)
 172 {
 173     return str[0] == '.' && str[1] == '/';
 174 }
 175
 176 static gboolean is_clean(const gchar * filename)
 177 {
 178     if (filename[0] != '/' && !starts_dotslash(filename))
 179         return FALSE;
 180
 181     return strstr(filename, "//") == NULL && strstr(filename, "/./") == NULL;
 182 }
 183
 184 static gint count_errors(gchar * str, gint * len)
 185 {
 186     gint count = 0;
 187     gchar *prev_slash = str, *next_slash = NULL;
 188
 189     /*
 190      * "path1/./path2" is replaced with "path1///path2".
 191      * "./" and "//" are counted.
 192      */
 193     while ((next_slash = strchr(prev_slash + !!next_slash, '/')) != NULL) {
 194         *len += next_slash - prev_slash;
 195
 196         switch (next_slash[1]) {
 197         case '.':
 198             if (next_slash[2] == '/') {
 199                 next_slash[1] = '/';
 200                 count++;
 201             }
 202             break;
 203
 204         case '/':
 205             count++;
 206         }
 207
 208         prev_slash = next_slash;
 209     }
 210
 211     *len += strlen(prev_slash);
 212     return count;
 213 }
 214
 215 static gchar *remove_double_slash(gchar * str, gint new_len)
 216 {
 217     gchar *new, *new_ptr;
 218     gchar *prev_slash = str, *next_slash = NULL;
 219
 220     if (str[0] == '/' || starts_dotslash(str)) {
 221         new = g_new(gchar, new_len);
 222         new_ptr = new;
 223     } else {
 224         new = g_new(gchar, new_len + 2);
 225         new[0] = '.';
 226         new[1] = '/';
 227         new_ptr = new + 2;
 228     }
 229
 230     while ((next_slash = strchr(prev_slash + !!next_slash, '/')) != NULL) {
 231         memcpy(new_ptr, prev_slash, next_slash - prev_slash);
 232         new_ptr += next_slash - prev_slash;
 233
 234         while (next_slash[1] == '/')
 235             next_slash++;
 236
 237         prev_slash = next_slash;
 238     }
 239
 240     strcpy(new_ptr, prev_slash);
 241
 242     return new;
 243 }
 244
 245 gchar *clean_filename(const gchar * filename)
 246 {
 247     gchar *orig_copy, *copy, *new;
 248     gint count = 0, len = 0;
 249     gboolean absolute, finished = FALSE;
 250
 251     if (is_clean(filename))
 252         return g_strdup(filename);
 253
 254     /* We work on a copy as we may modify it. */
 255     orig_copy = copy = g_strdup(filename);
 256
 257     absolute = (copy[0] == '/');
 258     while (finished == FALSE) {
 259         switch (copy[0]) {
 260         case '.':
 261             if (copy[1] == '/')
 262                 copy += 2;
 263             else
 264                 finished = TRUE;
 265             break;
 266
 267         case '/':
 268             copy++;
 269             break;
 270
 271         default:
 272             finished = TRUE;
 273         }
 274     }
 275
 276     if (absolute)
 277         /* We keep the last leading '/' for absolute filenames. */
 278         copy--;
 279     else if (copy - orig_copy >= 2) {
 280         /* We add a './' for relative filenames. */
 281         copy -= 2;
 282         copy[0] = '.';
 283         copy[1] = '/';
 284     }
 285
 286     /* Count the '//' and '/./'. */
 287     count = count_errors(copy, &len);
 288
 289     if (count == 0) {
 290         /* The filename was clean. */
 291
 292         if (absolute) {
 293             if (orig_copy != copy)
 294                 /* The filename started with "//". */
 295                 g_memmove(orig_copy, copy, len + 1);
 296
 297             return orig_copy;
 298         }
 299
 300         if (starts_dotslash(copy)) {
 301             if (orig_copy != copy)
 302                 g_memmove(orig_copy, copy, len + 1);
 303             new = orig_copy;
 304         } else {
 305             /* The relative filename just lacked the "./" in the beginning. */
 306             new = g_strconcat("./", copy, NULL);
 307             g_free(orig_copy);
 308         }
 309
 310         return new;
 311     }
 312
 313     /* We now have to remove the "//". */
 314     new = remove_double_slash(copy, len - count + 1);
 315
 316     g_free(orig_copy);
 317
 318     return new;
 319 }