release/src/router/udev/udev_utils_string.c

   1 /*
   2  * Copyright (C) 2004-2005 Kay Sievers <kay.sievers@vrfy.org>
   3  *
   4  *      This program is free software; you can redistribute it and/or modify it
   5  *      under the terms of the GNU General Public License as published by the
   6  *      Free Software Foundation version 2 of the License.
   7  *
   8  *      This program is distributed in the hope that it will be useful, but
   9  *      WITHOUT ANY WARRANTY; without even the implied warranty of
  10  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11  *      General Public License for more details.
  12  *
  13  *      You should have received a copy of the GNU General Public License along
  14  *      with this program; if not, write to the Free Software Foundation, Inc.,
  15  *      51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  16  *
  17  */
  18
  19
  20 #include <stdlib.h>
  21 #include <stdio.h>
  22 #include <stddef.h>
  23 #include <unistd.h>
  24 #include <fcntl.h>
  25 #include <errno.h>
  26 #include <ctype.h>
  27 #include <dirent.h>
  28 #include <syslog.h>
  29 #include <sys/utsname.h>
  30
  31 #include "udev.h"
  32
  33 int string_is_true(const char *str)
  34 {
  35         if (strcasecmp(str, "true") == 0)
  36                 return 1;
  37         if (strcasecmp(str, "yes") == 0)
  38                 return 1;
  39         if (strcasecmp(str, "1") == 0)
  40                 return 1;
  41         return 0;
  42 }
  43
  44 void remove_trailing_chars(char *path, char c)
  45 {
  46         size_t len;
  47
  48         len = strlen(path);
  49         while (len > 0 && path[len-1] == c)
  50                 path[--len] = '\0';
  51 }
  52
  53 size_t path_encode(char *s, size_t len)
  54 {
  55         char t[(len * 3)+1];
  56         size_t i, j;
  57
  58         t[0] = '\0';
  59         for (i = 0, j = 0; s[i] != '\0'; i++) {
  60                 if (s[i] == '/') {
  61                         memcpy(&t[j], "\\x2f", 4);
  62                         j += 4;
  63                 } else if (s[i] == '\\') {
  64                         memcpy(&t[j], "\\x5c", 4);
  65                         j += 4;
  66                 } else {
  67                         t[j] = s[i];
  68                         j++;
  69                 }
  70         }
  71         t[j] = '\0';
  72         strncpy(s, t, len);
  73         return j;
  74 }
  75
  76 size_t path_decode(char *s)
  77 {
  78         size_t i, j;
  79
  80         for (i = 0, j = 0; s[i] != '\0'; j++) {
  81                 if (memcmp(&s[i], "\\x2f", 4) == 0) {
  82                         s[j] = '/';
  83                         i += 4;
  84                 }else if (memcmp(&s[i], "\\x5c", 4) == 0) {
  85                         s[j] = '\\';
  86                         i += 4;
  87                 } else {
  88                         s[j] = s[i];
  89                         i++;
  90                 }
  91         }
  92         s[j] = '\0';
  93         return j;
  94 }
  95
  96 /* count of characters used to encode one unicode char */
  97 static int utf8_encoded_expected_len(const char *str)
  98 {
  99         unsigned char c = (unsigned char)str[0];
 100
 101         if (c < 0x80)
 102                 return 1;
 103         if ((c & 0xe0) == 0xc0)
 104                 return 2;
 105         if ((c & 0xf0) == 0xe0)
 106                 return 3;
 107         if ((c & 0xf8) == 0xf0)
 108                 return 4;
 109         if ((c & 0xfc) == 0xf8)
 110                 return 5;
 111         if ((c & 0xfe) == 0xfc)
 112                 return 6;
 113         return 0;
 114 }
 115
 116 /* decode one unicode char */
 117 static int utf8_encoded_to_unichar(const char *str)
 118 {
 119         int unichar;
 120         int len;
 121         int i;
 122
 123         len = utf8_encoded_expected_len(str);
 124         switch (len) {
 125         case 1:
 126                 return (int)str[0];
 127         case 2:
 128                 unichar = str[0] & 0x1f;
 129                 break;
 130         case 3:
 131                 unichar = (int)str[0] & 0x0f;
 132                 break;
 133         case 4:
 134                 unichar = (int)str[0] & 0x07;
 135                 break;
 136         case 5:
 137                 unichar = (int)str[0] & 0x03;
 138                 break;
 139         case 6:
 140                 unichar = (int)str[0] & 0x01;
 141                 break;
 142         default:
 143                 return -1;
 144         }
 145
 146         for (i = 1; i < len; i++) {
 147                 if (((int)str[i] & 0xc0) != 0x80)
 148                         return -1;
 149                 unichar <<= 6;
 150                 unichar |= (int)str[i] & 0x3f;
 151         }
 152
 153         return unichar;
 154 }
 155
 156 /* expected size used to encode one unicode char */
 157 static int utf8_unichar_to_encoded_len(int unichar)
 158 {
 159         if (unichar < 0x80)
 160                 return 1;
 161         if (unichar < 0x800)
 162                 return 2;
 163         if (unichar < 0x10000)
 164                 return 3;
 165         if (unichar < 0x200000)
 166                 return 4;
 167         if (unichar < 0x4000000)
 168                 return 5;
 169         return 6;
 170 }
 171
 172 /* check if unicode char has a valid numeric range */
 173 static int utf8_unichar_valid_range(int unichar)
 174 {
 175         if (unichar > 0x10ffff)
 176                 return 0;
 177         if ((unichar & 0xfffff800) == 0xd800)
 178                 return 0;
 179         if ((unichar > 0xfdcf) && (unichar < 0xfdf0))
 180                 return 0;
 181         if ((unichar & 0xffff) == 0xffff)
 182                 return 0;
 183         return 1;
 184 }
 185
 186 /* validate one encoded unicode char and return its length */
 187 int utf8_encoded_valid_unichar(const char *str)
 188 {
 189         int len;
 190         int unichar;
 191         int i;
 192
 193         len = utf8_encoded_expected_len(str);
 194         if (len == 0)
 195                 return -1;
 196
 197         /* ascii is valid */
 198         if (len == 1)
 199                 return 1;
 200
 201         /* check if expected encoded chars are available */
 202         for (i = 0; i < len; i++)
 203                 if ((str[i] & 0x80) != 0x80)
 204                         return -1;
 205
 206         unichar = utf8_encoded_to_unichar(str);
 207
 208         /* check if encoded length matches encoded value */
 209         if (utf8_unichar_to_encoded_len(unichar) != len)
 210                 return -1;
 211
 212         /* check if value has valid range */
 213         if (!utf8_unichar_valid_range(unichar))
 214                 return -1;
 215
 216         return len;
 217 }
 218
 219 /* allow chars in whitelist, plain ascii, hex-escaping and valid utf8 */
 220 int replace_chars(char *str, const char *white)
 221 {
 222         size_t i = 0;
 223         int replaced = 0;
 224
 225         while (str[i] != '\0') {
 226                 int len;
 227
 228                 /* accept whitelist */
 229                 if (white != NULL && strchr(white, str[i]) != NULL) {
 230                         i++;
 231                         continue;
 232                 }
 233
 234                 /* accept plain ascii char */
 235                 if ((str[i] >= '0' && str[i] <= '9') ||
 236                     (str[i] >= 'A' && str[i] <= 'Z') ||
 237                     (str[i] >= 'a' && str[i] <= 'z')) {
 238                         i++;
 239                         continue;
 240                 }
 241
 242                 /* accept hex encoding */
 243                 if (str[i] == '\\' && str[i+1] == 'x') {
 244                         i += 2;
 245                         continue;
 246                 }
 247
 248                 /* accept valid utf8 */
 249                 len = utf8_encoded_valid_unichar(&str[i]);
 250                 if (len > 1) {
 251                         i += len;
 252                         continue;
 253                 }
 254
 255                 /* if space is allowed, replace whitespace with ordinary space */
 256                 if (isspace(str[i]) && strchr(white, ' ') != NULL) {
 257                         str[i] = ' ';
 258                         i++;
 259                         replaced++;
 260                         continue;
 261                 }
 262
 263                 /* everything else is replaced with '_' */
 264                 str[i] = '_';
 265                 i++;
 266                 replaced++;
 267         }
 268
 269         return replaced;
 270 }