libpurple/protocols/gg/lib/encoding.c

   1 /*
   2  *  (C) Copyright 2008-2009 Jakub Zawadzki <darkjames@darkjames.ath.cx>
   3  *                          Wojtek Kaniewski <wojtekka@irc.pl>
   4  *
   5  *  This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU Lesser General Public License Version
   7  *  2.1 as published by the Free Software Foundation.
   8  *
   9  *  This program is distributed in the hope that it will be useful,
  10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  *  GNU Lesser General Public License for more details.
  13  *
  14  *  You should have received a copy of the GNU Lesser General Public
  15  *  License along with this program; if not, write to the Free Software
  16  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307,
  17  *  USA.
  18  */
  19
  20 #include "strman.h"
  21 #include <stdlib.h>
  22 #include <errno.h>
  23
  24 #include "libgadu.h"
  25 #include "encoding.h"
  26
  27 /**
  28  * \file encoding.c
  29  *
  30  * \brief Funkcje konwersji kodowania tekstu
  31  */
  32
  33 /**
  34  * \internal Tablica konwersji CP1250 na Unikod.
  35  */
  36 static const uint16_t table_cp1250[] =
  37 {
  38         0x20ac, '?',    0x201a, '?',    0x201e, 0x2026, 0x2020, 0x2021,
  39         '?',    0x2030, 0x0160, 0x2039, 0x015a, 0x0164, 0x017d, 0x0179,
  40         '?',    0x2018, 0x2019, 0x201c, 0x201d, 0x2022, 0x2013, 0x2014,
  41         '?',    0x2122, 0x0161, 0x203a, 0x015b, 0x0165, 0x017e, 0x017a,
  42         0x00a0, 0x02c7, 0x02d8, 0x0141, 0x00a4, 0x0104, 0x00a6, 0x00a7,
  43         0x00a8, 0x00a9, 0x015e, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x017b,
  44         0x00b0, 0x00b1, 0x02db, 0x0142, 0x00b4, 0x00b5, 0x00b6, 0x00b7,
  45         0x00b8, 0x0105, 0x015f, 0x00bb, 0x013d, 0x02dd, 0x013e, 0x017c,
  46         0x0154, 0x00c1, 0x00c2, 0x0102, 0x00c4, 0x0139, 0x0106, 0x00c7,
  47         0x010c, 0x00c9, 0x0118, 0x00cb, 0x011a, 0x00cd, 0x00ce, 0x010e,
  48         0x0110, 0x0143, 0x0147, 0x00d3, 0x00d4, 0x0150, 0x00d6, 0x00d7,
  49         0x0158, 0x016e, 0x00da, 0x0170, 0x00dc, 0x00dd, 0x0162, 0x00df,
  50         0x0155, 0x00e1, 0x00e2, 0x0103, 0x00e4, 0x013a, 0x0107, 0x00e7,
  51         0x010d, 0x00e9, 0x0119, 0x00eb, 0x011b, 0x00ed, 0x00ee, 0x010f,
  52         0x0111, 0x0144, 0x0148, 0x00f3, 0x00f4, 0x0151, 0x00f6, 0x00f7,
  53         0x0159, 0x016f, 0x00fa, 0x0171, 0x00fc, 0x00fd, 0x0163, 0x02d9,
  54 };
  55
  56 /**
  57  * \internal Zamienia tekst kodowany CP1250 na UTF-8.
  58  *
  59  * \param src Tekst źródłowy w CP1250.
  60  * \param src_length Długość ciągu źródłowego (nigdy ujemna).
  61  * \param dst_length Długość ciągu docelowego (jeśli -1, nieograniczona).
  62  *
  63  * \return Zaalokowany bufor z tekstem w UTF-8.
  64  */
  65 static char *gg_encoding_convert_cp1250_utf8(const char *src, int src_length, int dst_length)
  66 {
  67         int i, j, len;
  68         char *result = NULL;
  69
  70         for (i = 0, len = 0; (src[i] != 0) && (i < src_length); i++) {
  71                 uint16_t uc;
  72
  73                 if ((unsigned char) src[i] < 0x80)
  74                         uc = (unsigned char) src[i];
  75                 else
  76                         uc = table_cp1250[(unsigned char) src[i] - 128];
  77
  78                 if (uc < 0x80)
  79                         len += 1;
  80                 else if (uc < 0x800)
  81                         len += 2;
  82                 else
  83                         len += 3;
  84         }
  85
  86         if ((dst_length != -1) && (len > dst_length))
  87                 len = dst_length;
  88
  89         result = malloc(len + 1);
  90
  91         if (result == NULL)
  92                 return NULL;
  93
  94         for (i = 0, j = 0; (src[i] != 0) && (i < src_length) && (j < len); i++) {
  95                 uint16_t uc;
  96
  97                 if ((unsigned char) src[i] < 0x80)
  98                         uc = (unsigned char) src[i];
  99                 else
 100                         uc = table_cp1250[(unsigned char) src[i] - 128];
 101
 102                 if (uc < 0x80)
 103                         result[j++] = (char) uc;
 104                 else if (uc < 0x800) {
 105                         if (j + 1 > len)
 106                                 break;
 107                         result[j++] = 0xc0 | ((uc >> 6) & 0x1f);
 108                         result[j++] = 0x80 | (uc & 0x3f);
 109                 } else {
 110                         if (j + 2 > len)
 111                                 break;
 112                         result[j++] = 0xe0 | ((uc >> 12) & 0x1f);
 113                         result[j++] = 0x80 | ((uc >> 6) & 0x3f);
 114                         result[j++] = 0x80 | (uc & 0x3f);
 115                 }
 116         }
 117
 118         result[j] = 0;
 119
 120         return result;
 121 }
 122
 123 /**
 124  * \internal Zamienia tekst kodowany UTF-8 na CP1250.
 125  *
 126  * \param src Tekst źródłowy w UTF-8.
 127  * \param src_length Długość ciągu źródłowego (nigdy ujemna).
 128  * \param dst_length Długość ciągu docelowego (jeśli -1, nieograniczona).
 129  *
 130  * \return Zaalokowany bufor z tekstem w CP1250.
 131  */
 132 static char *gg_encoding_convert_utf8_cp1250(const char *src, int src_length, int dst_length)
 133 {
 134         char *result;
 135         int i, j, len, uc_left = 0;
 136         uint32_t uc = 0, uc_min = 0;
 137
 138         for (i = 0, len = 0; (src[i] != 0) && (i < src_length); i++) {
 139                 if ((src[i] & 0xc0) != 0x80)
 140                         len++;
 141         }
 142
 143         if ((dst_length != -1) && (len > dst_length))
 144                 len = dst_length;
 145
 146         result = malloc(len + 1);
 147
 148         if (result == NULL)
 149                 return NULL;
 150
 151         for (i = 0, j = 0; (src[i] != 0) && (i < src_length) && (j < len); i++) {
 152                 if ((unsigned char) src[i] >= 0xf5) {
 153                         if (uc_left != 0)
 154                                 result[j++] = '?';
 155                         /* Restricted sequences */
 156                         result[j++] = '?';
 157                         uc_left = 0;
 158                 } else if ((src[i] & 0xf8) == 0xf0) {
 159                         if (uc_left != 0)
 160                                 result[j++] = '?';
 161                         uc = src[i] & 0x07;
 162                         uc_left = 3;
 163                         uc_min = 0x10000;
 164                 } else if ((src[i] & 0xf0) == 0xe0) {
 165                         if (uc_left != 0)
 166                                 result[j++] = '?';
 167                         uc = src[i] & 0x0f;
 168                         uc_left = 2;
 169                         uc_min = 0x800;
 170                 } else if ((src[i] & 0xe0) == 0xc0) {
 171                         if (uc_left != 0)
 172                                 result[j++] = '?';
 173                         uc = src[i] & 0x1f;
 174                         uc_left = 1;
 175                         uc_min = 0x80;
 176                 } else if ((src[i] & 0xc0) == 0x80) {
 177                         if (uc_left > 0) {
 178                                 uc <<= 6;
 179                                 uc |= src[i] & 0x3f;
 180                                 uc_left--;
 181
 182                                 if (uc_left == 0) {
 183                                         int valid = 0;
 184                                         int k;
 185
 186                                         if (uc >= uc_min) {
 187                                                 for (k = 0; k < 128; k++) {
 188                                                         if (uc == table_cp1250[k]) {
 189                                                                 result[j++] = k + 128;
 190                                                                 valid = 1;
 191                                                                 break;
 192                                                         }
 193                                                 }
 194                                         }
 195
 196                                         if (!valid && uc != 0xfeff)     /* Byte Order Mark */
 197                                                 result[j++] = '?';
 198                                 }
 199                         }
 200                 } else {
 201                         if (uc_left != 0) {
 202                                 result[j++] = '?';
 203                                 uc_left = 0;
 204                         }
 205                         result[j++] = src[i];
 206                 }
 207         }
 208
 209         if ((uc_left != 0) && (src[i] == 0))
 210                 result[j++] = '?';
 211
 212         result[j] = 0;
 213
 214         return result;
 215 }
 216
 217 /**
 218  * \internal Zamienia kodowanie tekstu.
 219  *
 220  * \param src Tekst źródłowy.
 221  * \param src_encoding Kodowanie tekstu źródłowego.
 222  * \param dst_encoding Kodowanie tekstu docelowego.
 223  * \param src_length Długość ciągu źródłowego w bajtach (jeśli -1, zostanie obliczona na podstawie zawartości \p src).
 224  * \param dst_length Długość ciągu docelowego w bajtach (jeśli -1, nieograniczona).
 225  *
 226  * \return Zaalokowany bufor z tekstem w kodowaniu docelowym.
 227  */
 228 char *gg_encoding_convert(const char *src, gg_encoding_t src_encoding,
 229         gg_encoding_t dst_encoding, int src_length, int dst_length)
 230 {
 231         char *result;
 232
 233         if (src == NULL) {
 234                 errno = EINVAL;
 235                 return NULL;
 236         }
 237
 238         /* specjalny przypadek obsługiwany ekspresowo */
 239         if ((dst_encoding == src_encoding) && (dst_length == -1) && (src_length == -1))
 240                 return strdup(src);
 241
 242         if (src_length == -1)
 243                 src_length = strlen(src);
 244
 245         if (dst_encoding == src_encoding) {
 246                 int len;
 247
 248                 if (dst_length == -1)
 249                         len = src_length;
 250                 else
 251                         len = (src_length < dst_length) ? src_length : dst_length;
 252
 253                 result = malloc(len + 1);
 254
 255                 if (result == NULL)
 256                         return NULL;
 257
 258                 strncpy(result, src, len);
 259                 result[len] = 0;
 260
 261                 return result;
 262         }
 263
 264         if (dst_encoding == GG_ENCODING_CP1250 && src_encoding == GG_ENCODING_UTF8)
 265                 return gg_encoding_convert_utf8_cp1250(src, src_length, dst_length);
 266
 267         if (dst_encoding == GG_ENCODING_UTF8 && src_encoding == GG_ENCODING_CP1250)
 268                 return gg_encoding_convert_cp1250_utf8(src, src_length, dst_length);
 269
 270         errno = EINVAL;
 271         return NULL;
 272 }