libexfat/utf.c

   1 /*
   2         utf.c (13.09.09)
   3         exFAT file system implementation library.
   4
   5         Free exFAT implementation.
   6         Copyright (C) 2010-2014  Andrew Nayenko
   7
   8         This program is free software; you can redistribute it and/or modify
   9         it under the terms of the GNU General Public License as published by
  10         the Free Software Foundation, either version 2 of the License, or
  11         (at your option) any later version.
  12
  13         This program is distributed in the hope that it will be useful,
  14         but WITHOUT ANY WARRANTY; without even the implied warranty of
  15         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16         GNU General Public License for more details.
  17
  18         You should have received a copy of the GNU General Public License along
  19         with this program; if not, write to the Free Software Foundation, Inc.,
  20         51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  21 */
  22
  23 #include "exfat.h"
  24 #include <errno.h>
  25
  26 static char* wchar_to_utf8(char* output, wchar_t wc, size_t outsize)
  27 {
  28         if (wc <= 0x7f)
  29         {
  30                 if (outsize < 1)
  31                         return NULL;
  32                 *output++ = (char) wc;
  33         }
  34         else if (wc <= 0x7ff)
  35         {
  36                 if (outsize < 2)
  37                         return NULL;
  38                 *output++ = 0xc0 | (wc >> 6);
  39                 *output++ = 0x80 | (wc & 0x3f);
  40         }
  41         else if (wc <= 0xffff)
  42         {
  43                 if (outsize < 3)
  44                         return NULL;
  45                 *output++ = 0xe0 | (wc >> 12);
  46                 *output++ = 0x80 | ((wc >> 6) & 0x3f);
  47                 *output++ = 0x80 | (wc & 0x3f);
  48         }
  49         else if (wc <= 0x1fffff)
  50         {
  51                 if (outsize < 4)
  52                         return NULL;
  53                 *output++ = 0xf0 | (wc >> 18);
  54                 *output++ = 0x80 | ((wc >> 12) & 0x3f);
  55                 *output++ = 0x80 | ((wc >> 6) & 0x3f);
  56                 *output++ = 0x80 | (wc & 0x3f);
  57         }
  58         else if (wc <= 0x3ffffff)
  59         {
  60                 if (outsize < 5)
  61                         return NULL;
  62                 *output++ = 0xf8 | (wc >> 24);
  63                 *output++ = 0x80 | ((wc >> 18) & 0x3f);
  64                 *output++ = 0x80 | ((wc >> 12) & 0x3f);
  65                 *output++ = 0x80 | ((wc >> 6) & 0x3f);
  66                 *output++ = 0x80 | (wc & 0x3f);
  67         }
  68         else if (wc <= 0x7fffffff)
  69         {
  70                 if (outsize < 6)
  71                         return NULL;
  72                 *output++ = 0xfc | (wc >> 30);
  73                 *output++ = 0x80 | ((wc >> 24) & 0x3f);
  74                 *output++ = 0x80 | ((wc >> 18) & 0x3f);
  75                 *output++ = 0x80 | ((wc >> 12) & 0x3f);
  76                 *output++ = 0x80 | ((wc >> 6) & 0x3f);
  77                 *output++ = 0x80 | (wc & 0x3f);
  78         }
  79         else
  80                 return NULL;
  81
  82         return output;
  83 }
  84
  85 static const le16_t* utf16_to_wchar(const le16_t* input, wchar_t* wc,
  86                 size_t insize)
  87 {
  88         if ((le16_to_cpu(input[0]) & 0xfc00) == 0xd800)
  89         {
  90                 if (insize < 2 || (le16_to_cpu(input[1]) & 0xfc00) != 0xdc00)
  91                         return NULL;
  92                 *wc = ((wchar_t) (le16_to_cpu(input[0]) & 0x3ff) << 10);
  93                 *wc |= (le16_to_cpu(input[1]) & 0x3ff);
  94                 *wc += 0x10000;
  95                 return input + 2;
  96         }
  97         else
  98         {
  99                 *wc = le16_to_cpu(*input);
 100                 return input + 1;
 101         }
 102 }
 103
 104 int utf16_to_utf8(char* output, const le16_t* input, size_t outsize,
 105                 size_t insize)
 106 {
 107         const le16_t* inp = input;
 108         char* outp = output;
 109         wchar_t wc;
 110
 111         while (inp - input < insize && le16_to_cpu(*inp))
 112         {
 113                 inp = utf16_to_wchar(inp, &wc, insize - (inp - input));
 114                 if (inp == NULL)
 115                 {
 116                         exfat_error("illegal UTF-16 sequence");
 117                         return -EILSEQ;
 118                 }
 119                 outp = wchar_to_utf8(outp, wc, outsize - (outp - output));
 120                 if (outp == NULL)
 121                 {
 122                         exfat_error("name is too long");
 123                         return -ENAMETOOLONG;
 124                 }
 125         }
 126         *outp = '\0';
 127         return 0;
 128 }
 129
 130 static const char* utf8_to_wchar(const char* input, wchar_t* wc,
 131                 size_t insize)
 132 {
 133         if ((input[0] & 0x80) == 0 && insize >= 1)
 134         {
 135                 *wc = (wchar_t) input[0];
 136                 return input + 1;
 137         }
 138         if ((input[0] & 0xe0) == 0xc0 && insize >= 2)
 139         {
 140                 *wc = (((wchar_t) input[0] & 0x1f) << 6) |
 141                        ((wchar_t) input[1] & 0x3f);
 142                 return input + 2;
 143         }
 144         if ((input[0] & 0xf0) == 0xe0 && insize >= 3)
 145         {
 146                 *wc = (((wchar_t) input[0] & 0x0f) << 12) |
 147                       (((wchar_t) input[1] & 0x3f) << 6) |
 148                        ((wchar_t) input[2] & 0x3f);
 149                 return input + 3;
 150         }
 151         if ((input[0] & 0xf8) == 0xf0 && insize >= 4)
 152         {
 153                 *wc = (((wchar_t) input[0] & 0x07) << 18) |
 154                       (((wchar_t) input[1] & 0x3f) << 12) |
 155                       (((wchar_t) input[2] & 0x3f) << 6) |
 156                        ((wchar_t) input[3] & 0x3f);
 157                 return input + 4;
 158         }
 159         if ((input[0] & 0xfc) == 0xf8 && insize >= 5)
 160         {
 161                 *wc = (((wchar_t) input[0] & 0x03) << 24) |
 162                       (((wchar_t) input[1] & 0x3f) << 18) |
 163                       (((wchar_t) input[2] & 0x3f) << 12) |
 164                       (((wchar_t) input[3] & 0x3f) << 6) |
 165                        ((wchar_t) input[4] & 0x3f);
 166                 return input + 5;
 167         }
 168         if ((input[0] & 0xfe) == 0xfc && insize >= 6)
 169         {
 170                 *wc = (((wchar_t) input[0] & 0x01) << 30) |
 171                       (((wchar_t) input[1] & 0x3f) << 24) |
 172                       (((wchar_t) input[2] & 0x3f) << 18) |
 173                       (((wchar_t) input[3] & 0x3f) << 12) |
 174                       (((wchar_t) input[4] & 0x3f) << 6) |
 175                        ((wchar_t) input[5] & 0x3f);
 176                 return input + 6;
 177         }
 178         return NULL;
 179 }
 180
 181 static le16_t* wchar_to_utf16(le16_t* output, wchar_t wc, size_t outsize)
 182 {
 183         if (wc <= 0xffff) /* if character is from BMP */
 184         {
 185                 if (outsize == 0)
 186                         return NULL;
 187                 output[0] = cpu_to_le16(wc);
 188                 return output + 1;
 189         }
 190         if (outsize < 2)
 191                 return NULL;
 192         wc -= 0x10000;
 193         output[0] = cpu_to_le16(0xd800 | ((wc >> 10) & 0x3ff));
 194         output[1] = cpu_to_le16(0xdc00 | (wc & 0x3ff));
 195         return output + 2;
 196 }
 197
 198 int utf8_to_utf16(le16_t* output, const char* input, size_t outsize,
 199                 size_t insize)
 200 {
 201         const char* inp = input;
 202         le16_t* outp = output;
 203         wchar_t wc;
 204
 205         while (inp - input < insize && *inp)
 206         {
 207                 inp = utf8_to_wchar(inp, &wc, insize - (inp - input));
 208                 if (inp == NULL)
 209                 {
 210                         exfat_error("illegal UTF-8 sequence");
 211                         return -EILSEQ;
 212                 }
 213                 outp = wchar_to_utf16(outp, wc, outsize - (outp - output));
 214                 if (outp == NULL)
 215                 {
 216                         exfat_error("name is too long");
 217                         return -ENAMETOOLONG;
 218                 }
 219         }
 220         *outp = cpu_to_le16(0);
 221         return 0;
 222 }
 223
 224 size_t utf16_length(const le16_t* str)
 225 {
 226         size_t i = 0;
 227
 228         while (le16_to_cpu(str[i]))
 229                 i++;
 230         return i;
 231 }