libexfat/utf.c

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