diff options
| -rw-r--r-- | packages/vsftpd/vsftpd-charconv-2.0.5/.mtn2git_empty | 0 | ||||
| -rw-r--r-- | packages/vsftpd/vsftpd-charconv-2.0.5/vsftpd-charconv.patch | 4365 | ||||
| -rw-r--r-- | packages/vsftpd/vsftpd-charconv_2.0.5.bb | 50 |
3 files changed, 4415 insertions, 0 deletions
diff --git a/packages/vsftpd/vsftpd-charconv-2.0.5/.mtn2git_empty b/packages/vsftpd/vsftpd-charconv-2.0.5/.mtn2git_empty new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/packages/vsftpd/vsftpd-charconv-2.0.5/.mtn2git_empty diff --git a/packages/vsftpd/vsftpd-charconv-2.0.5/vsftpd-charconv.patch b/packages/vsftpd/vsftpd-charconv-2.0.5/vsftpd-charconv.patch new file mode 100644 index 0000000000..affdd32075 --- /dev/null +++ b/packages/vsftpd/vsftpd-charconv-2.0.5/vsftpd-charconv.patch @@ -0,0 +1,4365 @@ +This patch is extracted and cleaned up version of filename character +set conversion patches for vsftpd by Dmitriy Balashov, +http://vsftpd.devnet.ru/eng/ . It provides dirty-pragmatics approach +towards serving Windows codepages encoded filenames to Windows clients +out of normal utf-8 filesystem. + +These patches will never be accepted upstream, they should never be merged +to main vsftpd package, and they for sure void "vs" in "vsftpd". So again, +they are for users to prefer stone-dead pragmatics. Use at you own risk. + +- Paul Sokolovsky, pmiscml@gmail.com + +diff -urN vsftpd-2.0.5.org/charconv.c vsftpd-2.0.5/charconv.c +--- vsftpd-2.0.5.org/charconv.c 1970-01-01 03:00:00.000000000 +0300 ++++ vsftpd-2.0.5/charconv.c 2008-01-13 20:39:49.000000000 +0200 +@@ -0,0 +1,462 @@ ++/* ++ * Part of Very Secure FTPd ++ * Licence: GPL v2 ++ * Author: Dmitriy Balashov ++ * charconv.c ++ */ ++ ++#include "charconv.h" ++#include "tunables.h" ++#include "session.h" ++#include "str.h" ++#include "sysutil.h" ++ ++#include "char_maps/utf8.map" ++#ifdef VSFTP_CHARCONV_SUPPORT_CYRILLIC ++#include "char_maps/cyrillic.map" ++#endif ++#ifdef VSFTP_CHARCONV_SUPPORT_WESTERN ++#include "char_maps/western.map" ++#endif ++#ifdef VSFTP_CHARCONV_SUPPORT_CENTRAL ++#include "char_maps/central.map" ++#endif ++#ifdef VSFTP_CHARCONV_SUPPORT_SOUTERN ++#include "char_maps/soutern.map" ++#endif ++ ++/* Tables mapping supported codepage names to runtime variables */ ++static struct available_charsets ++{ ++ const char* p_charset_name; ++ int p_variable; ++} ++available_charsets_array[] = ++{ ++ { VSFTP_CP_NONE , VSFTP_C_NONE }, ++ // Cyrillic ++#ifdef VSFTP_CHARCONV_SUPPORT_CYRILLIC ++ { VSFTP_CP_UTF_8 , VSFTP_C_UTF8 }, ++ { VSFTP_CP_UTF8 , VSFTP_C_UTF8 }, ++ { VSFTP_CP_WIN_1251 , VSFTP_C_1251 }, ++ { VSFTP_CP_WIN1251 , VSFTP_C_1251 }, ++ { VSFTP_CP_CP1251 , VSFTP_C_1251 }, ++ { VSFTP_CP_1251 , VSFTP_C_1251 }, ++ { VSFTP_CP_KOI8_R , VSFTP_C_878R }, ++ { VSFTP_CP_KOI8R , VSFTP_C_878R }, ++ { VSFTP_CP_CP878 , VSFTP_C_878R }, ++ { VSFTP_CP_878 , VSFTP_C_878R }, ++ { VSFTP_CP_CP878R , VSFTP_C_878R }, ++ { VSFTP_CP_878R , VSFTP_C_878R }, ++ { VSFTP_CP_KOI8_U , VSFTP_C_878U }, ++ { VSFTP_CP_KOI8U , VSFTP_C_878U }, ++ { VSFTP_CP_CP878U , VSFTP_C_878U }, ++ { VSFTP_CP_878U , VSFTP_C_878U }, ++ { VSFTP_CP_IBM866 , VSFTP_C_866 }, ++ { VSFTP_CP_CP866 , VSFTP_C_866 }, ++ { VSFTP_CP_866 , VSFTP_C_866 }, ++ { VSFTP_CP_ISO8859_5 , VSFTP_C_ISO5 }, ++ { VSFTP_CP_ISO5 , VSFTP_C_ISO5 }, ++#endif ++ // Western European ++#ifdef VSFTP_CHARCONV_SUPPORT_WESTERN ++ { VSFTP_CP_ISO8859_1 , VSFTP_C_ISO1 }, ++ { VSFTP_CP_ISO1 , VSFTP_C_ISO1 }, ++ { VSFTP_CP_LATIN1 , VSFTP_C_ISO1 }, ++ { VSFTP_CP_ISO8859_15, VSFTP_C_ISO15 }, ++ { VSFTP_CP_ISO15 , VSFTP_C_ISO15 }, ++ { VSFTP_CP_LATIN9 , VSFTP_C_ISO15 }, ++ { VSFTP_CP_WIN_1252 , VSFTP_C_1252 }, ++ { VSFTP_CP_WIN1252 , VSFTP_C_1252 }, ++ { VSFTP_CP_CP1252 , VSFTP_C_1252 }, ++ { VSFTP_CP_1252 , VSFTP_C_1252 }, ++#endif ++ // Central European ++#ifdef VSFTP_CHARCONV_SUPPORT_CENTRAL ++ { VSFTP_CP_ISO8859_2 , VSFTP_C_ISO2 }, ++ { VSFTP_CP_ISO2 , VSFTP_C_ISO2 }, ++ { VSFTP_CP_LATIN2 , VSFTP_C_ISO2 }, ++ { VSFTP_CP_ISO8859_16, VSFTP_C_ISO16 }, ++ { VSFTP_CP_ISO16 , VSFTP_C_ISO16 }, ++ { VSFTP_CP_WIN_1250 , VSFTP_C_1250 }, ++ { VSFTP_CP_WIN1250 , VSFTP_C_1250 }, ++ { VSFTP_CP_CP1250 , VSFTP_C_1250 }, ++ { VSFTP_CP_1250 , VSFTP_C_1250 }, ++#endif ++ // Soutern European ++#ifdef VSFTP_CHARCONV_SUPPORT_SOUTERN ++ { VSFTP_CP_ISO8859_3 , VSFTP_C_ISO3 }, ++ { VSFTP_CP_ISO3 , VSFTP_C_ISO3 }, ++ { VSFTP_CP_LATIN3 , VSFTP_C_ISO3 }, ++#endif ++ { 0, 0 } ++}; ++ ++/* Available convertions */ ++static struct available_convertions ++{ ++ int local; ++ int remote; ++ int localCharset; ++ int remoteCharset; ++} ++available_convertions_array[] = ++{ // Cyrillic ++#ifdef VSFTP_CHARCONV_SUPPORT_CYRILLIC ++ { VSFTP_C_UTF8 , VSFTP_C_1251 , VSFTP_CS_UTF8CYR , VSFTP_CS_1251 }, ++ { VSFTP_C_UTF8 , VSFTP_C_878R , VSFTP_CS_UTF8CYR , VSFTP_CS_878R }, ++ { VSFTP_C_UTF8 , VSFTP_C_878U , VSFTP_CS_UTF8CYR , VSFTP_CS_878U }, ++ { VSFTP_C_UTF8 , VSFTP_C_866 , VSFTP_CS_UTF8CYR , VSFTP_CS_866 }, ++ { VSFTP_C_UTF8 , VSFTP_C_ISO5 , VSFTP_CS_UTF8CYR , VSFTP_CS_ISO5 }, ++ { VSFTP_C_1251 , VSFTP_C_UTF8 , VSFTP_CS_1251 , VSFTP_CS_UTF8CYR }, ++ { VSFTP_C_1251 , VSFTP_C_878R , VSFTP_CS_1251 , VSFTP_CS_878R }, ++ { VSFTP_C_1251 , VSFTP_C_878U , VSFTP_CS_1251 , VSFTP_CS_878U }, ++ { VSFTP_C_1251 , VSFTP_C_866 , VSFTP_CS_1251 , VSFTP_CS_866 }, ++ { VSFTP_C_1251 , VSFTP_C_ISO5 , VSFTP_CS_1251 , VSFTP_CS_ISO5 }, ++ { VSFTP_C_878R , VSFTP_C_UTF8 , VSFTP_CS_878R , VSFTP_CS_UTF8CYR }, ++ { VSFTP_C_878R , VSFTP_C_1251 , VSFTP_CS_878R , VSFTP_CS_1251 }, ++ { VSFTP_C_878R , VSFTP_C_878U , VSFTP_CS_878R , VSFTP_CS_878U }, ++ { VSFTP_C_878R , VSFTP_C_866 , VSFTP_CS_878R , VSFTP_CS_866 }, ++ { VSFTP_C_878R , VSFTP_C_ISO5 , VSFTP_CS_878R , VSFTP_CS_ISO5 }, ++ { VSFTP_C_866 , VSFTP_C_UTF8 , VSFTP_CS_866 , VSFTP_CS_UTF8CYR }, ++ { VSFTP_C_866 , VSFTP_C_1251 , VSFTP_CS_866 , VSFTP_CS_1251 }, ++ { VSFTP_C_866 , VSFTP_C_878R , VSFTP_CS_866 , VSFTP_CS_878R }, ++ { VSFTP_C_866 , VSFTP_C_878U , VSFTP_CS_866 , VSFTP_CS_878U }, ++ { VSFTP_C_866 , VSFTP_C_ISO5 , VSFTP_CS_866 , VSFTP_CS_ISO5 }, ++ { VSFTP_C_ISO5 , VSFTP_C_UTF8 , VSFTP_CS_ISO5 , VSFTP_CS_UTF8CYR }, ++ { VSFTP_C_ISO5 , VSFTP_C_1251 , VSFTP_CS_ISO5 , VSFTP_CS_1251 }, ++ { VSFTP_C_ISO5 , VSFTP_C_878R , VSFTP_CS_ISO5 , VSFTP_CS_878R }, ++ { VSFTP_C_ISO5 , VSFTP_C_878U , VSFTP_CS_ISO5 , VSFTP_CS_878U }, ++ { VSFTP_C_ISO5 , VSFTP_C_866 , VSFTP_CS_ISO5 , VSFTP_CS_866 }, ++#endif ++ // Western European ++#ifdef VSFTP_CHARCONV_SUPPORT_WESTERN ++ { VSFTP_C_UTF8 , VSFTP_C_ISO1 , VSFTP_CS_UTF8WEST , VSFTP_CS_ISO1 }, ++ { VSFTP_C_UTF8 , VSFTP_C_ISO15 , VSFTP_CS_UTF8WEST , VSFTP_CS_ISO15 }, ++ { VSFTP_C_UTF8 , VSFTP_C_1252 , VSFTP_CS_UTF8WEST , VSFTP_CS_1252 }, ++ { VSFTP_C_ISO1 , VSFTP_C_UTF8 , VSFTP_CS_ISO1 , VSFTP_CS_UTF8WEST }, ++ { VSFTP_C_ISO1 , VSFTP_C_ISO15 , VSFTP_CS_ISO1 , VSFTP_CS_ISO15 }, ++ { VSFTP_C_ISO1 , VSFTP_C_1252 , VSFTP_CS_ISO1 , VSFTP_CS_1252 }, ++ { VSFTP_C_ISO15 , VSFTP_C_UTF8 , VSFTP_CS_ISO15 , VSFTP_CS_UTF8WEST }, ++ { VSFTP_C_ISO15 , VSFTP_C_ISO1 , VSFTP_CS_ISO15 , VSFTP_CS_ISO1 }, ++ { VSFTP_C_ISO15 , VSFTP_C_1252 , VSFTP_CS_ISO15 , VSFTP_CS_1252 }, ++ { VSFTP_C_1252 , VSFTP_C_UTF8 , VSFTP_CS_1252 , VSFTP_CS_UTF8WEST }, ++ { VSFTP_C_1252 , VSFTP_C_ISO1 , VSFTP_CS_1252 , VSFTP_CS_ISO1 }, ++ { VSFTP_C_1252 , VSFTP_C_ISO15 , VSFTP_CS_1252 , VSFTP_CS_ISO15 }, ++#endif ++ // Central European ++#ifdef VSFTP_CHARCONV_SUPPORT_CENTRAL ++ { VSFTP_C_UTF8 , VSFTP_C_ISO2 , VSFTP_CS_UTF8CENT , VSFTP_CS_ISO2 }, ++ { VSFTP_C_UTF8 , VSFTP_C_ISO16 , VSFTP_CS_UTF8CENT , VSFTP_CS_ISO16 }, ++ { VSFTP_C_UTF8 , VSFTP_C_1250 , VSFTP_CS_UTF8CENT , VSFTP_CS_1250 }, ++ { VSFTP_C_ISO2 , VSFTP_C_UTF8 , VSFTP_CS_ISO2 , VSFTP_CS_UTF8CENT }, ++ { VSFTP_C_ISO2 , VSFTP_C_ISO16 , VSFTP_CS_ISO2 , VSFTP_CS_ISO16 }, ++ { VSFTP_C_ISO2 , VSFTP_C_1250 , VSFTP_CS_ISO2 , VSFTP_CS_1250 }, ++ { VSFTP_C_ISO16 , VSFTP_C_UTF8 , VSFTP_CS_ISO16 , VSFTP_CS_UTF8CENT }, ++ { VSFTP_C_ISO16 , VSFTP_C_ISO2 , VSFTP_CS_ISO16 , VSFTP_CS_ISO2 }, ++ { VSFTP_C_ISO16 , VSFTP_C_1250 , VSFTP_CS_ISO16 , VSFTP_CS_1250 }, ++ { VSFTP_C_1250 , VSFTP_C_UTF8 , VSFTP_CS_1250 , VSFTP_CS_UTF8CENT }, ++ { VSFTP_C_1250 , VSFTP_C_ISO2 , VSFTP_CS_1250 , VSFTP_CS_ISO2 }, ++ { VSFTP_C_1250 , VSFTP_C_ISO16 , VSFTP_CS_1250 , VSFTP_CS_ISO16 }, ++#endif ++ // Soutern European ++#ifdef VSFTP_CHARCONV_SUPPORT_SOUTERN ++ { VSFTP_C_UTF8 , VSFTP_C_ISO3 , VSFTP_CS_UTF8SOUT , VSFTP_CS_ISO3 }, ++ { VSFTP_C_ISO3 , VSFTP_C_UTF8 , VSFTP_CS_ISO3 , VSFTP_CS_UTF8SOUT }, ++#endif ++ ++ { 0, 0, 0, 0 } ++}; ++ ++map_ptr map_array[] = ++{ ++ 0, ++#ifdef VSFTP_CHARCONV_SUPPORT_CYRILLIC ++ codepage_utf8cyr_array, codepage_win1251_array, codepage_koi8r_array, ++ codepage_ibm866_array, codepage_iso5_array, codepage_koi8u_array, ++#else ++ 0, 0, 0, 0, 0, ++#endif ++ ++#ifdef VSFTP_CHARCONV_SUPPORT_WESTERN ++ codepage_utf8west_array, codepage_iso1_array, codepage_iso15_array, ++ codepage_win1252_array, ++#else ++ 0, 0, 0, 0, ++#endif ++ ++#ifdef VSFTP_CHARCONV_SUPPORT_CENTRAL ++ codepage_utf8cent_array, codepage_iso2_array, codepage_iso16_array, ++ codepage_win1250_array, ++#else ++ 0, 0, 0, 0, ++#endif ++ ++#ifdef VSFTP_CHARCONV_SUPPORT_SOUTERN ++ codepage_utf8sout_array, codepage_iso3_array, ++#else ++ 0, 0, ++#endif ++ ++ 0 ++}; ++ ++/* Initial table for work with unprintable chars */ ++map_ptr init_array[] = ++{ ++ 0, ++ codepage_utf8_array, ++#ifdef VSFTP_CHARCONV_SUPPORT_CYRILLIC ++ codepage_win1251_array, codepage_koi8r_array, codepage_ibm866_array, ++ codepage_iso5_array, codepage_koi8u_array, ++#else ++ 0, 0, 0, 0, ++#endif ++ ++#ifdef VSFTP_CHARCONV_SUPPORT_WESTERN ++ codepage_iso1_array, codepage_iso15_array, codepage_win1252_array, ++#else ++ 0, 0, 0, ++#endif ++ ++#ifdef VSFTP_CHARCONV_SUPPORT_CENTRAL ++ codepage_iso2_array, codepage_iso16_array, codepage_win1250_array, ++#else ++ 0, 0, 0, ++#endif ++ ++#ifdef VSFTP_CHARCONV_SUPPORT_SOUTERN ++ codepage_iso3_array, ++#else ++ 0, ++#endif ++ ++ 0 ++}; ++ ++map_ptr localMap = 0, remoteMap = 0; ++map_ptr localTbl = 0, remoteTbl = 0; ++ ++void char_convertion(struct mystr* p_str, int direction, char unprintable); ++void InitTables(map_ptr* map, map_ptr* table, int indexx); ++static int char_len(unsigned int s); ++static unsigned int bsearch_index(map_ptr map, unsigned int low, unsigned int high, unsigned int char_code); ++ ++const char* vsf_charconv_charset_name(int code) ++{ ++ int i = 0; ++ while (available_charsets_array [i].p_charset_name && available_charsets_array [i].p_variable != code) i++; ++ return available_charsets_array [i].p_charset_name; ++} ++ ++int vsf_charconv_codepage(const char* p_str) ++{ ++ const struct available_charsets* charsets = available_charsets_array; ++ ++ while (charsets->p_charset_name != 0) ++ { ++ if (!vsf_sysutil_strcmp(charsets->p_charset_name, p_str)) ++ { ++ return charsets->p_variable; ++ } ++ charsets++; ++ } ++ ++ return 0; ++} ++ ++int vsf_charconv_avail_convertion(int localCode, int remoteCode) ++{ ++ const struct available_convertions* aconv = available_convertions_array; ++ ++ while (aconv->local != 0) ++ { ++ if (localCode == aconv->local && remoteCode == aconv->remote) ++ { ++ InitTables(&localMap, &localTbl, aconv->localCharset); ++ InitTables(&remoteMap, &remoteTbl, aconv->remoteCharset); ++ return 1; ++ } ++ aconv++; ++ } ++ ++ return 0; ++} ++ ++void vsf_charconv_init_local_codepage(int localCode) ++{ ++ if (!localCode) ++ { ++ return; ++ } ++ ++ localTbl = init_array [localCode]; ++ localMap = vsf_sysutil_malloc((localTbl [0].order + 1) * sizeof(_codepage_map)); ++ localMap [0].char_code = localTbl [0].char_code; ++ localMap [0].order = localTbl [0].order; ++ ++ int indexx = 1; ++ while (localTbl [indexx].char_code) ++ { ++ if (localTbl [indexx].order) ++ { ++ localMap [localTbl [indexx].order].char_code = localTbl [indexx].char_code; ++ localMap [localTbl [indexx].order].order = indexx; ++ } ++ indexx++; ++ } ++ ++ return; ++} ++ ++void vsf_charconv_convert(struct vsf_session* p_sess, struct mystr* p_str, int direction) ++{ ++ if (!p_sess->enable_conversion || !p_sess->remote_charset || !tunable_local_codepage) return; ++ ++ char_convertion(p_str, direction, '?'); ++} ++ ++void vsf_charconv_replace_unprintable(struct mystr* p_str, char new_char) ++{ ++ if (localMap) char_convertion(p_str, VSFTP_CONVDIRECT_UNPRINTABLE, new_char); ++} ++ ++void InitTables(map_ptr* map, map_ptr* table, int indexx) ++{ ++ *table = map_array [indexx]; ++ ++ if (*map) vsf_sysutil_free(*map); ++ ++ *map = vsf_sysutil_malloc(((*table) [0].order + 1) * sizeof(_codepage_map)); ++ (*map) [0].char_code = (*table) [0].char_code; ++ (*map) [0].order = (*table) [0].order; ++ ++ indexx = 1; ++ while ((*table) [indexx].char_code) ++ { ++ if ((*table) [indexx].order) ++ { ++ (*map) [(*table) [indexx].order].char_code = (*table) [indexx].char_code; ++ (*map) [(*table) [indexx].order].order = indexx; ++ } ++ indexx++; ++ } ++ ++ return; ++} ++ ++static int char_len(unsigned int s) ++{ ++ int len = 1; ++ if ((s & 0x80) == 0x00) len = 1; ++ else if ((s & 0xe0) == 0xc0) len = 2; ++ else if ((s & 0xf0) == 0xe0) len = 3; ++ else if ((s & 0xf8) == 0xf0) len = 4; ++// else if ((s & 0xfc) == 0xf8) len = 5; ++// else if ((s & 0xfe) == 0xce) len = 6; ++ return (len); ++} ++ ++static unsigned int bsearch_index(map_ptr map, unsigned int low, unsigned int high, unsigned int char_code) ++{ ++ unsigned int m, l = low, r = high; ++ ++ m = (l + r) >> 1; ++ while ((m != 0) && (map [m].char_code != char_code)) ++ { ++ if (map [m].char_code < char_code) l = m + 1; ++ else ++ if (map [m].char_code > char_code) r = m - 1; ++ if (l > r) ++ return 0; ++ else ++ m = (l + r) >> 1; ++ } ++ ++ if (m) m = map [m].order; ++ return m; ++} ++ ++void char_convertion(struct mystr* p_str, int direction, char unprintable) ++{ ++ const char* srcbuf; ++ unsigned int srclen; ++ char* dstbuf; ++ map_ptr src, dst; ++ unsigned int sl; ++ unsigned int srcpos = 0, dstpos = 0; ++ unsigned int char_code = 0; ++ ++ srclen = str_getlen(p_str); // Len of source string ++ srcbuf = str_getbuf(p_str); ++ ++ if (direction == VSFTP_CONVDIRECT_FORWARD) ++ { ++ src = localMap; ++ dst = remoteTbl; ++ } ++ else ++ if (direction == VSFTP_CONVDIRECT_BACKWARD) ++ { ++ src = remoteMap; ++ dst = localTbl; ++ } ++ else ++ { ++ src = localMap; ++ dst = localTbl; ++ } ++ ++ if (!src || !dst) ++ { ++ return; ++ } ++ ++ dstbuf = vsf_sysutil_malloc(srclen * dst [0].char_code + dst [0].char_code); ++ ++ while (srcpos < srclen) ++ { ++ char_code = (unsigned char)srcbuf [srcpos++]; ++ if (src [0].char_code > 1) ++ { ++ sl = char_len (char_code); ++ while (sl-- > 1) ++ { ++ char_code = (char_code << 8) | (unsigned char)srcbuf [srcpos++]; ++ } ++ } ++ ++ if (char_code > 127) ++ { ++ sl = bsearch_index (src, 1, src [0].order, char_code); ++ char_code = 0; ++ if (sl) char_code = dst [sl].char_code; ++ } ++ ++ if (char_code == 13 || char_code == 10) ++ { ++ char_code = 0; ++ } ++ else ++ if (char_code < 32 && char_code != 9) ++ { ++ char_code = (unsigned int)unprintable; ++ } ++ ++ if (char_code > 0 || direction != VSFTP_CONVDIRECT_UNPRINTABLE) ++ { ++ if (char_code & 0xff000000) dstbuf [dstpos++] = (char)((char_code >> 24) & 0xff); ++ if (char_code & 0x00ff0000) dstbuf [dstpos++] = (char)((char_code >> 16) & 0xff); ++ if (char_code & 0x0000ff00) dstbuf [dstpos++] = (char)((char_code >> 8) & 0xff); ++ if (char_code & 0x000000ff) dstbuf [dstpos++] = (char)((char_code ) & 0xff); ++ } ++ } ++ ++ dstbuf [dstpos] = '\0'; ++ ++ str_empty(p_str); ++ str_append_text(p_str, dstbuf); ++ ++ vsf_sysutil_free(dstbuf); ++} ++ +diff -urN vsftpd-2.0.5.org/charconv.h vsftpd-2.0.5/charconv.h +--- vsftpd-2.0.5.org/charconv.h 1970-01-01 03:00:00.000000000 +0300 ++++ vsftpd-2.0.5/charconv.h 2008-01-13 19:32:11.000000000 +0200 +@@ -0,0 +1,182 @@ ++#ifndef VSF_CHARCONV_H ++#define VSF_CHARCONV_H ++ ++struct mystr; ++struct vsf_session; ++ ++#define VSFTP_CHARCONV_SUPPORT_CYRILLIC ++#define VSFTP_CHARCONV_SUPPORT_WESTERN ++#define VSFTP_CHARCONV_SUPPORT_CENTRAL ++#define VSFTP_CHARCONV_SUPPORT_SOUTERN ++ ++#define VSFTP_CONVDIRECT_FORWARD 1 ++#define VSFTP_CONVDIRECT_UNPRINTABLE 0 ++#define VSFTP_CONVDIRECT_BACKWARD -1 ++ ++/* Supported charset for convertion */ ++#define VSFTP_CP_NONE "NONE" ++#define VSFTP_CP_UTF_8 "UTF-8" ++#define VSFTP_CP_UTF8 "UTF8" ++#ifdef VSFTP_CHARCONV_SUPPORT_CYRILLIC ++#define VSFTP_CP_WIN_1251 "Win-1251" ++#define VSFTP_CP_WIN1251 "WIN1251" ++#define VSFTP_CP_CP1251 "CP1251" ++#define VSFTP_CP_1251 "1251" ++#define VSFTP_CP_KOI8_R "Koi8-R" ++#define VSFTP_CP_KOI8R "KOI8R" ++#define VSFTP_CP_KOI8_U "Koi8-U" ++#define VSFTP_CP_KOI8U "KOI8U" ++#define VSFTP_CP_CP878 "CP878" ++#define VSFTP_CP_878 "878" ++#define VSFTP_CP_CP878R "CP878R" ++#define VSFTP_CP_878R "878R" ++#define VSFTP_CP_CP878U "CP878U" ++#define VSFTP_CP_878U "878U" ++#define VSFTP_CP_IBM866 "IBM866" ++#define VSFTP_CP_CP866 "CP866" ++#define VSFTP_CP_866 "866" ++#define VSFTP_CP_ISO8859_5 "ISO-8859-5" ++#define VSFTP_CP_ISO5 "ISO5" ++#endif ++#ifdef VSFTP_CHARCONV_SUPPORT_WESTERN ++#define VSFTP_CP_ISO8859_1 "ISO-8859-1" ++#define VSFTP_CP_ISO1 "ISO1" ++#define VSFTP_CP_LATIN1 "LATIN1" ++#define VSFTP_CP_ISO8859_15 "ISO-8859-15" ++#define VSFTP_CP_ISO15 "ISO15" ++#define VSFTP_CP_LATIN9 "LATIN9" ++#define VSFTP_CP_WIN_1252 "Win-1252" ++#define VSFTP_CP_WIN1252 "WIN1252" ++#define VSFTP_CP_CP1252 "CP1252" ++#define VSFTP_CP_1252 "1252" ++#endif ++#ifdef VSFTP_CHARCONV_SUPPORT_CENTRAL ++#define VSFTP_CP_ISO8859_2 "ISO-8859-2" ++#define VSFTP_CP_ISO2 "ISO2" ++#define VSFTP_CP_LATIN2 "LATIN2" ++#define VSFTP_CP_ISO8859_16 "ISO-8859-16" ++#define VSFTP_CP_ISO16 "ISO16" ++#define VSFTP_CP_WIN_1250 "Win-1250" ++#define VSFTP_CP_WIN1250 "WIN1250" ++#define VSFTP_CP_CP1250 "CP1250" ++#define VSFTP_CP_1250 "1250" ++#endif ++#ifdef VSFTP_CHARCONV_SUPPORT_SOUTERN ++#define VSFTP_CP_ISO8859_3 "ISO-8859-3" ++#define VSFTP_CP_ISO3 "ISO3" ++#define VSFTP_CP_LATIN3 "LATIN3" ++#endif ++ ++#define VSFTP_C_NONE 0 ++#define VSFTP_C_UTF8 1 ++#ifdef VSFTP_CHARCONV_SUPPORT_CYRILLIC ++#define VSFTP_C_1251 2 ++#define VSFTP_C_878R 3 ++#define VSFTP_C_866 4 ++#define VSFTP_C_ISO5 5 ++#define VSFTP_C_878U 6 ++#endif ++#ifdef VSFTP_CHARCONV_SUPPORT_WESTERN ++#define VSFTP_C_ISO1 7 ++#define VSFTP_C_ISO15 8 ++#define VSFTP_C_1252 9 ++#endif ++#ifdef VSFTP_CHARCONV_SUPPORT_CENTRAL ++#define VSFTP_C_ISO2 10 ++#define VSFTP_C_ISO16 11 ++#define VSFTP_C_1250 12 ++#endif ++#ifdef VSFTP_CHARCONV_SUPPORT_SOUTERN ++#define VSFTP_C_ISO3 13 ++#endif ++ ++#define VSFTP_CS_NONE 0 ++#ifdef VSFTP_CHARCONV_SUPPORT_CYRILLIC ++#define VSFTP_CS_UTF8CYR 1 ++#define VSFTP_CS_1251 2 ++#define VSFTP_CS_878R 3 ++#define VSFTP_CS_866 4 ++#define VSFTP_CS_ISO5 5 ++#define VSFTP_CS_878U 6 ++#endif ++#ifdef VSFTP_CHARCONV_SUPPORT_WESTERN ++#define VSFTP_CS_UTF8WEST 7 ++#define VSFTP_CS_ISO1 8 ++#define VSFTP_CS_ISO15 9 ++#define VSFTP_CS_1252 10 ++#endif ++#ifdef VSFTP_CHARCONV_SUPPORT_CENTRAL ++#define VSFTP_CS_UTF8CENT 11 ++#define VSFTP_CS_ISO2 12 ++#define VSFTP_CS_ISO16 13 ++#define VSFTP_CS_1250 14 ++#endif ++#ifdef VSFTP_CHARCONV_SUPPORT_SOUTERN ++#define VSFTP_CS_UTF8SOUT 15 ++#define VSFTP_CS_ISO3 16 ++#endif ++ ++struct codepage_map ++{ ++ unsigned int char_code; // The first element is count bytes of char. ++ unsigned int order; ++} _codepage_map; ++ ++typedef struct codepage_map * map_ptr; ++ ++extern map_ptr localMap; ++ ++/* vsf_charconv_charset_name() ++ * PURPOSE ++ * Get charset name by code; ++ * PARAMETERS ++ * code - Internal charset code ++ * RETURNS ++ * Charset name ++ */ ++const char* vsf_charconv_charset_name(int code); ++ ++/* vsf_charconv_codepage() ++ * PURPOSE ++ * Get internal charset code ++ * PARAMETERS ++ * p_str - String value with code page ++ * RETURNS ++ * Internal charset code ++ */ ++int vsf_charconv_codepage(const char* p_str); ++ ++/* vsf_charconv_init_local_codepage(int localCode) ++ * PURPOSE ++ * Init local codepage for work with unprintable chars ++ * PARAMETERS ++ * localCode - source internal code page ++ */ ++void vsf_charconv_init_local_codepage(int localCode); ++ ++/* vsf_charconv_avail_convertion() ++ * PURPOS ++ * Checking for available convertion characters ++ * PARAMETERS ++ * localCode - source internal code page ++ * remoteCode - destination internal code page ++ * RETURNS ++ * Available ot not converion ++ */ ++int vsf_charconv_avail_convertion(int localCode, int remoteCode); ++ ++/* vsf_charconv_convert() ++ * PURPOSE ++ * Converting string via charsets ++ * PARAMETERS ++ * p_sess - the current session object ++ * p_str - string for convertin ++ * direction - converting from host to remoute charsetr or otherwise ++ */ ++void vsf_charconv_convert(struct vsf_session* p_sess, struct mystr* p_str, int direction); ++ ++/* vsf_charconv_replace_unprintable ++ */ ++void vsf_charconv_replace_unprintable(struct mystr* p_str, char new_char); ++ ++#endif +diff -urN vsftpd-2.0.5.org/char_maps/central.map vsftpd-2.0.5/char_maps/central.map +--- vsftpd-2.0.5.org/char_maps/central.map 1970-01-01 03:00:00.000000000 +0300 ++++ vsftpd-2.0.5/char_maps/central.map 2008-01-13 20:09:59.000000000 +0200 +@@ -0,0 +1,738 @@ ++/* ++ !!! WARNING !!! ++ DON'T CHANGE ORDER OF CHARS ++*/ ++ ++struct codepage_map codepage_utf8cent_array[] = ++ { ++ { 0x000003, 178 }, // max size , char count ++ { 0x00003f, 0 }, ++ { 0x00003f, 0 }, ++ { 0x00003f, 0 }, ++ { 0x00003f, 0 }, ++ { 0x00003f, 0 }, ++ { 0x00c280, 1 }, ++ { 0x00c281, 2 }, ++ { 0x00c282, 3 }, ++ { 0x00c283, 4 }, ++ { 0x00c284, 5 }, ++ { 0x00c285, 6 }, ++ { 0x00c286, 7 }, ++ { 0x00c287, 8 }, ++ { 0x00c288, 9 }, ++ { 0x00c289, 10 }, ++ { 0x00c28a, 11 }, ++ { 0x00c28b, 12 }, ++ { 0x00c28c, 13 }, ++ { 0x00c28d, 14 }, ++ { 0x00c28e, 15 }, ++ { 0x00c28f, 16 }, ++ { 0x00c290, 17 }, ++ { 0x00c291, 18 }, ++ { 0x00c292, 19 }, ++ { 0x00c293, 20 }, ++ { 0x00c294, 21 }, ++ { 0x00c295, 22 }, ++ { 0x00c296, 23 }, ++ { 0x00c297, 24 }, ++ { 0x00c298, 25 }, ++ { 0x00c299, 26 }, ++ { 0x00c29a, 27 }, ++ { 0x00c29b, 28 }, ++ { 0x00c29c, 29 }, ++ { 0x00c29d, 30 }, ++ { 0x00c29e, 31 }, ++ { 0x00c29f, 32 }, ++ { 0x00c2a0, 33 }, ++ { 0x00c2a4, 34 }, ++ { 0x00c2a6, 35 }, ++ { 0x00c2a7, 36 }, ++ { 0x00c2a8, 37 }, ++ { 0x00c2a9, 38 }, ++ { 0x00c2ab, 39 }, ++ { 0x00c2ad, 40 }, ++ { 0x00c2ad, 41 }, ++ { 0x00c2ae, 42 }, ++ { 0x00c2b0, 43 }, ++ { 0x00c2b1, 44 }, ++ { 0x00c2b4, 45 }, ++ { 0x00c2b5, 46 }, ++ { 0x00c2b6, 47 }, ++ { 0x00c2b7, 48 }, ++ { 0x00c2b8, 49 }, ++ { 0x00c2bb, 50 }, ++ { 0x00c380, 51 }, ++ { 0x00c381, 52 }, ++ { 0x00c382, 53 }, ++ { 0x00c384, 54 }, ++ { 0x00c386, 55 }, ++ { 0x00c387, 56 }, ++ { 0x00c388, 57 }, ++ { 0x00c389, 58 }, ++ { 0x00c38a, 59 }, ++ { 0x00c38b, 60 }, ++ { 0x00c38c, 61 }, ++ { 0x00c38d, 62 }, ++ { 0x00c38e, 63 }, ++ { 0x00c38f, 64 }, ++ { 0x00c392, 65 }, ++ { 0x00c393, 66 }, ++ { 0x00c394, 67 }, ++ { 0x00c396, 68 }, ++ { 0x00c397, 69 }, ++ { 0x00c399, 70 }, ++ { 0x00c39a, 71 }, ++ { 0x00c39b, 72 }, ++ { 0x00c39c, 73 }, ++ { 0x00c39d, 74 }, ++ { 0x00c39f, 75 }, ++ { 0x00c3a0, 76 }, ++ { 0x00c3a1, 77 }, ++ { 0x00c3a2, 78 }, ++ { 0x00c3a4, 79 }, ++ { 0x00c3a6, 80 }, ++ { 0x00c3a7, 81 }, ++ { 0x00c3a8, 82 }, ++ { 0x00c3a9, 83 }, ++ { 0x00c3aa, 84 }, ++ { 0x00c3ab, 85 }, ++ { 0x00c3ac, 86 }, ++ { 0x00c3ad, 87 }, ++ { 0x00c3ae, 88 }, ++ { 0x00c3af, 89 }, ++ { 0x00c3b2, 90 }, ++ { 0x00c3b3, 91 }, ++ { 0x00c3b4, 92 }, ++ { 0x00c3b6, 93 }, ++ { 0x00c3b7, 94 }, ++ { 0x00c3b9, 95 }, ++ { 0x00c3ba, 96 }, ++ { 0x00c3bb, 97 }, ++ { 0x00c3bc, 98 }, ++ { 0x00c3bd, 99 }, ++ { 0x00c3bf, 100 }, ++ { 0x00c482, 101 }, ++ { 0x00c483, 102 }, ++ { 0x00c484, 103 }, ++ { 0x00c485, 104 }, ++ { 0x00c486, 105 }, ++ { 0x00c487, 106 }, ++ { 0x00c48c, 107 }, ++ { 0x00c48d, 108 }, ++ { 0x00c48e, 109 }, ++ { 0x00c48f, 110 }, ++ { 0x00c490, 111 }, ++ { 0x00c491, 112 }, ++ { 0x00c498, 113 }, ++ { 0x00c499, 114 }, ++ { 0x00c49a, 115 }, ++ { 0x00c49b, 116 }, ++ { 0x00c4b9, 117 }, ++ { 0x00c4ba, 118 }, ++ { 0x00c4bd, 119 }, ++ { 0x00c4be, 120 }, ++ { 0x00c581, 121 }, ++ { 0x00c582, 122 }, ++ { 0x00c583, 123 }, ++ { 0x00c584, 124 }, ++ { 0x00c587, 125 }, ++ { 0x00c588, 126 }, ++ { 0x00c590, 127 }, ++ { 0x00c591, 128 }, ++ { 0x00c592, 129 }, ++ { 0x00c593, 130 }, ++ { 0x00c594, 131 }, ++ { 0x00c595, 132 }, ++ { 0x00c598, 133 }, ++ { 0x00c599, 134 }, ++ { 0x00c59a, 135 }, ++ { 0x00c59b, 136 }, ++ { 0x00c59e, 137 }, ++ { 0x00c59f, 138 }, ++ { 0x00c5a0, 139 }, ++ { 0x00c5a1, 140 }, ++ { 0x00c5a2, 141 }, ++ { 0x00c5a3, 142 }, ++ { 0x00c5a4, 143 }, ++ { 0x00c5a5, 144 }, ++ { 0x00c5ae, 145 }, ++ { 0x00c5af, 146 }, ++ { 0x00c5b0, 147 }, ++ { 0x00c5b1, 148 }, ++ { 0x00c5b8, 149 }, ++ { 0x00c5b9, 150 }, ++ { 0x00c5ba, 151 }, ++ { 0x00c5bb, 152 }, ++ { 0x00c5bc, 153 }, ++ { 0x00c5bd, 154 }, ++ { 0x00c5be, 155 }, ++ { 0x00cb87, 156 }, ++ { 0x00cb98, 157 }, ++ { 0x00cb99, 158 }, ++ { 0x00c89a, 159 }, ++ { 0x00cb9b, 160 }, ++ { 0x00cb9d, 161 }, ++ { 0xe28093, 162 }, ++ { 0xe28094, 163 }, ++ { 0xe28098, 164 }, ++ { 0xe28099, 165 }, ++ { 0xe2809a, 166 }, ++ { 0xe2809c, 167 }, ++ { 0xe2809d, 168 }, ++ { 0xe2809e, 169 }, ++ { 0xe280a0, 170 }, ++ { 0xe280a1, 171 }, ++ { 0xe280a2, 172 }, ++ { 0xe280a6, 173 }, ++ { 0xe280b0, 174 }, ++ { 0xe280b9, 175 }, ++ { 0xe280ba, 176 }, ++ { 0xe282ac, 177 }, ++ { 0xe284a2, 178 }, ++ { 0x000000, 0 } ++ }; ++ ++struct codepage_map codepage_iso2_array[] = ++ { ++ { 0x0001, 128 }, // max size , char count for control ++ { 0x003f, 0 }, ++ { 0x003f, 0 }, ++ { 0x003f, 0 }, ++ { 0x003f, 0 }, ++ { 0x003f, 0 }, ++ { 0x0080, 1 }, ++ { 0x0081, 2 }, ++ { 0x0082, 3 }, ++ { 0x0083, 4 }, ++ { 0x0084, 5 }, ++ { 0x0085, 6 }, ++ { 0x0086, 7 }, ++ { 0x0087, 8 }, ++ { 0x0088, 9 }, ++ { 0x0089, 10 }, ++ { 0x008a, 11 }, ++ { 0x008b, 12 }, ++ { 0x008c, 13 }, ++ { 0x008d, 14 }, ++ { 0x008e, 15 }, ++ { 0x008f, 16 }, ++ { 0x0090, 17 }, ++ { 0x0091, 18 }, ++ { 0x0092, 19 }, ++ { 0x0093, 20 }, ++ { 0x0094, 21 }, ++ { 0x0095, 22 }, ++ { 0x0096, 23 }, ++ { 0x0097, 24 }, ++ { 0x0098, 25 }, ++ { 0x0099, 26 }, ++ { 0x009a, 27 }, ++ { 0x009b, 28 }, ++ { 0x009c, 29 }, ++ { 0x009d, 30 }, ++ { 0x009e, 31 }, ++ { 0x009f, 32 }, ++ { 0x00a0, 33 }, ++ { 0x00a1, 34 }, ++ { 0x00a2, 35 }, ++ { 0x00a3, 36 }, ++ { 0x00a4, 37 }, ++ { 0x00a5, 38 }, ++ { 0x00a6, 39 }, ++ { 0x00a7, 40 }, ++ { 0x00a8, 41 }, ++ { 0x00a9, 42 }, ++ { 0x00aa, 43 }, ++ { 0x00ab, 44 }, ++ { 0x00ac, 45 }, ++ { 0x00ad, 46 }, ++ { 0x00ae, 47 }, ++ { 0x00af, 48 }, ++ { 0x00b0, 49 }, ++ { 0x00b1, 50 }, ++ { 0x00b2, 51 }, ++ { 0x00b3, 52 }, ++ { 0x00b4, 53 }, ++ { 0x00b5, 54 }, ++ { 0x00b6, 55 }, ++ { 0x00b7, 56 }, ++ { 0x00b8, 57 }, ++ { 0x00b9, 58 }, ++ { 0x00ba, 59 }, ++ { 0x00bb, 60 }, ++ { 0x00bc, 61 }, ++ { 0x00bd, 62 }, ++ { 0x00be, 63 }, ++ { 0x00bf, 64 }, ++ { 0x00c0, 65 }, ++ { 0x00c1, 66 }, ++ { 0x00c2, 67 }, ++ { 0x00c3, 68 }, ++ { 0x00c4, 69 }, ++ { 0x00c5, 70 }, ++ { 0x00c6, 71 }, ++ { 0x00c7, 72 }, ++ { 0x00c8, 73 }, ++ { 0x00c9, 74 }, ++ { 0x00ca, 75 }, ++ { 0x00cb, 76 }, ++ { 0x00cc, 77 }, ++ { 0x00cd, 78 }, ++ { 0x00ce, 79 }, ++ { 0x00cf, 80 }, ++ { 0x00d0, 81 }, ++ { 0x00d1, 82 }, ++ { 0x00d2, 83 }, ++ { 0x00d3, 84 }, ++ { 0x00d4, 85 }, ++ { 0x00d5, 86 }, ++ { 0x00d6, 87 }, ++ { 0x00d7, 88 }, ++ { 0x00d8, 89 }, ++ { 0x00d9, 90 }, ++ { 0x00da, 91 }, ++ { 0x00db, 92 }, ++ { 0x00dc, 93 }, ++ { 0x00dd, 94 }, ++ { 0x00de, 95 }, ++ { 0x00df, 96 }, ++ { 0x00e0, 97 }, ++ { 0x00e1, 98 }, ++ { 0x00e2, 99 }, ++ { 0x00e3, 100 }, ++ { 0x00e4, 101 }, ++ { 0x00e5, 102 }, ++ { 0x00e6, 103 }, ++ { 0x00e7, 104 }, ++ { 0x00e8, 105 }, ++ { 0x00e9, 106 }, ++ { 0x00ea, 107 }, ++ { 0x00eb, 108 }, ++ { 0x00ec, 109 }, ++ { 0x00ed, 110 }, ++ { 0x00ee, 111 }, ++ { 0x00ef, 112 }, ++ { 0x00f0, 113 }, ++ { 0x00f1, 114 }, ++ { 0x00f2, 115 }, ++ { 0x00f3, 116 }, ++ { 0x00f4, 117 }, ++ { 0x00f5, 118 }, ++ { 0x00f6, 119 }, ++ { 0x00f7, 120 }, ++ { 0x00f8, 121 }, ++ { 0x00f9, 122 }, ++ { 0x00fa, 123 }, ++ { 0x00fb, 124 }, ++ { 0x00fc, 125 }, ++ { 0x00fd, 126 }, ++ { 0x00fe, 127 }, ++ { 0x00ff, 128 }, ++ { 0x0000, 0 }, ++ { 0x003f, 0 }, ++ { 0x003f, 0 }, ++ { 0x003f, 0 }, ++ { 0x003f, 0 }, ++ { 0x003f, 0 }, ++ { 0x003f, 0 }, ++ { 0x003f, 0 }, ++ { 0x003f, 0 }, ++ { 0x003f, 0 }, ++ { 0x003f, 0 }, ++ { 0x003f, 0 }, ++ { 0x003f, 0 }, ++ { 0x003f, 0 }, ++ { 0x003f, 0 }, ++ { 0x003f, 0 }, ++ { 0x003f, 0 }, ++ { 0x003f, 0 }, ++ { 0x003f, 0 }, ++ { 0x003f, 0 }, ++ { 0x003f, 0 }, ++ { 0x003f, 0 }, ++ { 0x003f, 0 }, ++ { 0x003f, 0 }, ++ { 0x003f, 0 }, ++ { 0x003f, 0 }, ++ { 0x003f, 0 }, ++ { 0x0000, 0 } ++ }; ++ ++struct codepage_map codepage_iso16_array[] = ++ { ++ { 0x0001, 128 }, // max size , char count for control ++ { 0x003f, 0 }, ++ { 0x003f, 0 }, ++ { 0x003f, 0 }, ++ { 0x003f, 0 }, ++ { 0x003f, 0 }, ++ { 0x0080, 1 }, ++ { 0x0081, 2 }, ++ { 0x0082, 3 }, ++ { 0x0083, 4 }, ++ { 0x0084, 5 }, ++ { 0x0085, 6 }, ++ { 0x0086, 7 }, ++ { 0x0087, 8 }, ++ { 0x0088, 9 }, ++ { 0x0089, 10 }, ++ { 0x008a, 11 }, ++ { 0x008b, 12 }, ++ { 0x008c, 13 }, ++ { 0x008d, 14 }, ++ { 0x008e, 15 }, ++ { 0x008f, 16 }, ++ { 0x0090, 17 }, ++ { 0x0091, 18 }, ++ { 0x0092, 19 }, ++ { 0x0093, 20 }, ++ { 0x0094, 21 }, ++ { 0x0095, 22 }, ++ { 0x0096, 23 }, ++ { 0x0097, 24 }, ++ { 0x0098, 25 }, ++ { 0x0099, 26 }, ++ { 0x009a, 27 }, ++ { 0x009b, 28 }, ++ { 0x009c, 29 }, ++ { 0x009d, 30 }, ++ { 0x009e, 31 }, ++ { 0x009f, 32 }, ++ { 0x00a0, 33 }, ++ { 0x003f, 0 }, ++ { 0x003f, 0 }, ++ { 0x00a7, 40 }, ++ { 0x003f, 0 }, ++ { 0x00a9, 42 }, ++ { 0x00ab, 44 }, ++ { 0x00ad, 46 }, ++ { 0x003f, 0 }, ++ { 0x003f, 0 }, ++ { 0x00b0, 49 }, ++ { 0x00b1, 50 }, ++ { 0x003f, 0 }, ++ { 0x003f, 0 }, ++ { 0x00b6, 55 }, ++ { 0x00b7, 56 }, ++ { 0x003f, 0 }, ++ { 0x00bb, 60 }, ++ { 0x00c0, 65 }, ++ { 0x00c1, 66 }, ++ { 0x00c2, 67 }, ++ { 0x00c4, 69 }, ++ { 0x00c6, 71 }, ++ { 0x00c7, 72 }, ++ { 0x00c8, 73 }, ++ { 0x00c9, 74 }, ++ { 0x00ca, 75 }, ++ { 0x00cb, 76 }, ++ { 0x00cc, 77 }, ++ { 0x00cd, 78 }, ++ { 0x00ce, 79 }, ++ { 0x00cf, 80 }, ++ { 0x00d2, 83 }, ++ { 0x00d3, 84 }, ++ { 0x00d4, 85 }, ++ { 0x00d6, 87 }, ++ { 0x003f, 0 }, ++ { 0x00d9, 90 }, ++ { 0x00da, 91 }, ++ { 0x00db, 92 }, ++ { 0x00dc, 93 }, ++ { 0x003f, 0 }, ++ { 0x00df, 96 }, ++ { 0x00e0, 97 }, ++ { 0x00e1, 98 }, ++ { 0x00e2, 99 }, ++ { 0x00e4, 101 }, ++ { 0x00e6, 103 }, ++ { 0x00e7, 104 }, ++ { 0x00e8, 105 }, ++ { 0x00e9, 106 }, ++ { 0x00ea, 107 }, ++ { 0x00eb, 108 }, ++ { 0x00ec, 109 }, ++ { 0x00ed, 110 }, ++ { 0x00ee, 111 }, ++ { 0x00ef, 112 }, ++ { 0x00f2, 115 }, ++ { 0x00f3, 116 }, ++ { 0x00f4, 117 }, ++ { 0x00f6, 119 }, ++ { 0x003f, 0 }, ++ { 0x00f9, 122 }, ++ { 0x00fa, 123 }, ++ { 0x00fb, 124 }, ++ { 0x00fc, 125 }, ++ { 0x003f, 0 }, ++ { 0x00ff, 128 }, ++ { 0x00c3, 68 }, + |