diff options
| -rw-r--r-- | libmysqld/CMakeLists.txt | 1 | ||||
| -rw-r--r-- | mysql-test/main/func_misc.result | 3 | ||||
| -rw-r--r-- | sql/CMakeLists.txt | 1 | ||||
| -rw-r--r-- | sql/item_inetfunc.cc | 715 | ||||
| -rw-r--r-- | sql/sql_type_inet.cc | 540 | ||||
| -rw-r--r-- | sql/sql_type_inet.h | 303 |
6 files changed, 849 insertions, 714 deletions
diff --git a/libmysqld/CMakeLists.txt b/libmysqld/CMakeLists.txt index f2759f19d7d..7e75669daa6 100644 --- a/libmysqld/CMakeLists.txt +++ b/libmysqld/CMakeLists.txt @@ -116,6 +116,7 @@ SET(SQL_EMBEDDED_SOURCES emb_qcache.cc libmysqld.c lib_sql.cc ../sql/sql_mode.cc ../sql/sql_type_json.cc ../sql/sql_type_geom.cc + ../sql/sql_type_inet.cc ../sql/table_cache.cc ../sql/mf_iocache_encr.cc ../sql/item_inetfunc.cc ../sql/wsrep_dummy.cc ../sql/encryption.cc diff --git a/mysql-test/main/func_misc.result b/mysql-test/main/func_misc.result index f4645ed089d..a54da192e9c 100644 --- a/mysql-test/main/func_misc.result +++ b/mysql-test/main/func_misc.result @@ -1345,6 +1345,9 @@ SELECT IS_IPV4_MAPPED(INET6_ATON('1.2.3.4')), IS_IPV4_COMPAT(INET6_ATON('1.2.3.4')); IS_IPV4_MAPPED(INET6_ATON('1.2.3.4')) IS_IPV4_COMPAT(INET6_ATON('1.2.3.4')) 0 0 +Warnings: +Warning 1292 Incorrect inet6 value: '\x01\x02\x03\x04' +Warning 1292 Incorrect inet6 value: '\x01\x02\x03\x04' SELECT IS_IPV4_MAPPED(INET6_ATON('::1.2.3.4')), IS_IPV4_COMPAT(INET6_ATON('::1.2.3.4')); IS_IPV4_MAPPED(INET6_ATON('::1.2.3.4')) IS_IPV4_COMPAT(INET6_ATON('::1.2.3.4')) diff --git a/sql/CMakeLists.txt b/sql/CMakeLists.txt index 2591f21174b..801805c9a2a 100644 --- a/sql/CMakeLists.txt +++ b/sql/CMakeLists.txt @@ -137,6 +137,7 @@ SET (SQL_SOURCE semisync_master_ack_receiver.cc sql_type.cc sql_mode.cc sql_type_json.cc sql_type_geom.cc + sql_type_inet.cc item_windowfunc.cc sql_window.cc sql_cte.cc item_vers.cc diff --git a/sql/item_inetfunc.cc b/sql/item_inetfunc.cc index 082584181a4..93608dd0d2c 100644 --- a/sql/item_inetfunc.cc +++ b/sql/item_inetfunc.cc @@ -16,25 +16,7 @@ #include "mariadb.h" #include "item_inetfunc.h" - -#include "my_net.h" - -/////////////////////////////////////////////////////////////////////////// - -static const size_t IN_ADDR_SIZE= 4; -static const size_t IN_ADDR_MAX_CHAR_LENGTH= 15; - -static const size_t IN6_ADDR_SIZE= 16; -static const size_t IN6_ADDR_NUM_WORDS= IN6_ADDR_SIZE / 2; - -/** - Non-abbreviated syntax is 8 groups, up to 4 digits each, - plus 7 delimiters between the groups. - Abbreviated syntax is even shorter. -*/ -static const uint IN6_ADDR_MAX_CHAR_LENGTH= 8 * 4 + 7; - -static const char HEX_DIGITS[]= "0123456789abcdef"; +#include "sql_type_inet.h" /////////////////////////////////////////////////////////////////////////// @@ -145,701 +127,6 @@ String* Item_func_inet_ntoa::val_str(String* str) return str; } -/////////////////////////////////////////////////////////////////////////// - - -class Inet4 -{ - char m_buffer[IN_ADDR_SIZE]; -protected: - bool ascii_to_ipv4(const char *str, size_t length); - bool character_string_to_ipv4(const char *str, size_t str_length, - CHARSET_INFO *cs) - { - if (cs->state & MY_CS_NONASCII) - { - char tmp[IN_ADDR_MAX_CHAR_LENGTH]; - String_copier copier; - uint length= copier.well_formed_copy(&my_charset_latin1, tmp, sizeof(tmp), - cs, str, str_length); - return ascii_to_ipv4(tmp, length); - } - return ascii_to_ipv4(str, str_length); - } - bool binary_to_ipv4(const char *str, size_t length) - { - if (length != sizeof(m_buffer)) - return true; - memcpy(m_buffer, str, length); - return false; - } - // Non-initializing constructor - Inet4() { } -public: - void to_binary(char *dst, size_t dstsize) const - { - DBUG_ASSERT(dstsize >= sizeof(m_buffer)); - memcpy(dst, m_buffer, sizeof(m_buffer)); - } - bool to_binary(String *to) const - { - return to->copy(m_buffer, sizeof(m_buffer), &my_charset_bin); - } - size_t to_string(char *dst, size_t dstsize) const; - bool to_string(String *to) const - { - to->set_charset(&my_charset_latin1); - if (to->alloc(INET_ADDRSTRLEN)) - return true; - to->length((uint32) to_string((char*) to->ptr(), INET_ADDRSTRLEN)); - return false; - } -}; - - -class Inet4_null: public Inet4, public Null_flag -{ -public: - // Initialize from a text representation - Inet4_null(const char *str, size_t length, CHARSET_INFO *cs) - :Null_flag(character_string_to_ipv4(str, length, cs)) - { } - Inet4_null(const String &str) - :Inet4_null(str.ptr(), str.length(), str.charset()) - { } - // Initialize from a binary representation - Inet4_null(const char *str, size_t length) - :Null_flag(binary_to_ipv4(str, length)) - { } - Inet4_null(const Binary_string &str) - :Inet4_null(str.ptr(), str.length()) - { } -public: - const Inet4& to_inet4() const - { - DBUG_ASSERT(!is_null()); - return *this; - } - void to_binary(char *dst, size_t dstsize) const - { - to_inet4().to_binary(dst, dstsize); - } - bool to_binary(String *to) const - { - return to_inet4().to_binary(to); - } - size_t to_string(char *dst, size_t dstsize) const - { - return to_inet4().to_string(dst, dstsize); - } - bool to_string(String *to) const - { - return to_inet4().to_string(to); - } -}; - - -class Inet6 -{ - char m_buffer[IN6_ADDR_SIZE]; -protected: - bool make_from_item(Item *item); - bool ascii_to_ipv6(const char *str, size_t str_length); - bool character_string_to_ipv6(const char *str, size_t str_length, - CHARSET_INFO *cs) - { - if (cs->state & MY_CS_NONASCII) - { - char tmp[IN6_ADDR_MAX_CHAR_LENGTH]; - String_copier copier; - uint length= copier.well_formed_copy(&my_charset_latin1, tmp, sizeof(tmp), - cs, str, str_length); - return ascii_to_ipv6(tmp, length); - } - return ascii_to_ipv6(str, str_length); - } - bool binary_to_ipv6(const char *str, size_t length) - { - if (length != sizeof(m_buffer)) - return true; - memcpy(m_buffer, str, length); - return false; - } - // Non-initializing constructor - Inet6() { } -public: - bool to_binary(String *to) const - { - return to->copy(m_buffer, sizeof(m_buffer), &my_charset_bin); - } - size_t to_string(char *dst, size_t dstsize) const; - bool to_string(String *to) const - { - to->set_charset(&my_charset_latin1); - if (to->alloc(INET6_ADDRSTRLEN)) - return true; - to->length((uint32) to_string((char*) to->ptr(), INET6_ADDRSTRLEN)); - return false; - } - bool is_v4compat() const - { - static_assert(sizeof(in6_addr) == IN6_ADDR_SIZE, "unexpected in6_addr size"); - return IN6_IS_ADDR_V4COMPAT((struct in6_addr *) m_buffer); - } - bool is_v4mapped() const - { - static_assert(sizeof(in6_addr) == IN6_ADDR_SIZE, "unexpected in6_addr size"); - return IN6_IS_ADDR_V4MAPPED((struct in6_addr *) m_buffer); - } -}; - - -class Inet6_null: public Inet6, public Null_flag -{ -public: - // Initialize from a text representation - Inet6_null(const char *str, size_t length, CHARSET_INFO *cs) - :Null_flag(character_string_to_ipv6(str, length, cs)) - { } - Inet6_null(const String &str) - :Inet6_null(str.ptr(), str.length(), str.charset()) - { } - // Initialize from a binary representation - Inet6_null(const char *str, size_t length) - :Null_flag(binary_to_ipv6(str, length)) - { } - Inet6_null(const Binary_string &str) - :Inet6_null(str.ptr(), str.length()) - { } - // Initialize from an Item - Inet6_null(Item *item) - :Null_flag(make_from_item(item)) - { } -public: - const Inet6& to_inet6() const - { - DBUG_ASSERT(!is_null()); - return *this; - } - bool to_binary(String *to) const - { - DBUG_ASSERT(!is_null()); - return to_inet6().to_binary(to); - } - size_t to_string(char *dst, size_t dstsize) const - { - return to_inet6().to_string(dst, dstsize); - } - bool to_string(String *to) const - { - return to_inet6().to_string(to); - } - bool is_v4compat() const - { - return to_inet6().is_v4compat(); - } - bool is_v4mapped() const - { - return to_inet6().is_v4mapped(); - } -}; - - -bool Inet6::make_from_item(Item *item) -{ - String tmp(m_buffer, sizeof(m_buffer), &my_charset_bin); - String *str= item->val_str(&tmp); - /* - Charset could be tested in item->collation.collation before the val_str() - call, but traditionally Inet6 functions still call item->val_str() - for non-binary arguments and therefore execute side effects. - */ - if (!str || str->length() != sizeof(m_buffer) || - str->charset() != &my_charset_bin) - return true; - if (str->ptr() != m_buffer) - memcpy(m_buffer, str->ptr(), sizeof(m_buffer)); - return false; -}; - - -/** - Tries to convert given string to binary IPv4-address representation. - This is a portable alternative to inet_pton(AF_INET). - - @param str String to convert. - @param str_length String length. - - @return Completion status. - @retval true - error, the given string does not represent an IPv4-address. - @retval false - ok, the string has been converted sucessfully. - - @note The problem with inet_pton() is that it treats leading zeros in - IPv4-part differently on different platforms. -*/ - -bool Inet4::ascii_to_ipv4(const char *str, size_t str_length) -{ - if (str_length < 7) - { - DBUG_PRINT("error", ("ascii_to_ipv4(%.*s): " - "invalid IPv4 address: too short.", - (int) str_length, str)); - return true; - } - - if (str_length > IN_ADDR_MAX_CHAR_LENGTH) - { - DBUG_PRINT("error", ("ascii_to_ipv4(%.*s): " - "invalid IPv4 address: too long.", - (int) str_length, str)); - return true; - } - - unsigned char *ipv4_bytes= (unsigned char *) &m_buffer; - const char *str_end= str + str_length; - const char *p= str; - int byte_value= 0; - int chars_in_group= 0; - int dot_count= 0; - char c= 0; - - while (p < str_end && *p) - { - c= *p++; - - if (my_isdigit(&my_charset_latin1, c)) - { - ++chars_in_group; - - if (chars_in_group > 3) - { - DBUG_PRINT("error", ("ascii_to_ipv4(%.*s): invalid IPv4 address: " - "too many characters in a group.", - (int) str_length, str)); - return true; - } - - byte_value= byte_value * 10 + (c - '0'); - - if (byte_value > 255) - { - DBUG_PRINT("error", ("ascii_to_ipv4(%.*s): invalid IPv4 address: " - "invalid byte value.", - (int) str_length, str)); - return true; - } - } - else if (c == '.') - { - if (chars_in_group == 0) - { - DBUG_PRINT("error", ("ascii_to_ipv4(%.*s): invalid IPv4 address: " - "too few characters in a group.", - (int) str_length, str)); - return true; - } - - ipv4_bytes[dot_count]= (unsigned char) byte_value; - - ++dot_count; - byte_value= 0; - chars_in_group= 0; - - if (dot_count > 3) - { - DBUG_PRINT("error", ("ascii_to_ipv4(%.*s): invalid IPv4 address: " - "too many dots.", (int) str_length, str)); - return true; - } - } - else - { - DBUG_PRINT("error", ("ascii_to_ipv4(%.*s): invalid IPv4 address: " - "invalid character at pos %d.", - (int) str_length, str, (int) (p - str))); - return true; - } - } - - if (c == '.') - { - DBUG_PRINT("error", ("ascii_to_ipv4(%.*s): invalid IPv4 address: " - "ending at '.'.", (int) str_length, str)); - return true; - } - - if (dot_count != 3) - { - DBUG_PRINT("error", ("ascii_to_ipv4(%.*s): invalid IPv4 address: " - "too few groups.", - (int) str_length, str)); - return true; - } - - ipv4_bytes[3]= (unsigned char) byte_value; - - DBUG_PRINT("info", ("ascii_to_ipv4(%.*s): valid IPv4 address: %d.%d.%d.%d", - (int) str_length, str, - ipv4_bytes[0], ipv4_bytes[1], - ipv4_bytes[2], ipv4_bytes[3])); - return false; -} - - -/** - Tries to convert given string to binary IPv6-address representation. - This is a portable alternative to inet_pton(AF_INET6). - - @param str String to convert. - @param str_length String length. - - @return Completion status. - @retval true - error, the given string does not represent an IPv6-address. - @retval false - ok, the string has been converted sucessfully. - - @note The problem with inet_pton() is that it treats leading zeros in - IPv4-part differently on different platforms. -*/ - -bool Inet6::ascii_to_ipv6(const char *str, size_t str_length) -{ - if (str_length < 2) - { - DBUG_PRINT("error", ("ascii_to_ipv6(%.*s): invalid IPv6 address: too short.", - (int) str_length, str)); - return true; - } - - if (str_length > IN6_ADDR_MAX_CHAR_LENGTH) - { - DBUG_PRINT("error", ("ascii_to_ipv6(%.*s): invalid IPv6 address: too long.", - (int) str_length, str)); - return true; - } - - memset(m_buffer, 0, sizeof(m_buffer)); - - const char *p= str; - - if (*p == ':') - { - ++p; - - if (*p != ':') - { - DBUG_PRINT("error", ("ascii_to_ipv6(%.*s): invalid IPv6 address: " - "can not start with ':x'.", (int) str_length, str)); - return true; - } - } - - const char *str_end= str + str_length; - char *ipv6_bytes_end= m_buffer + sizeof(m_buffer); - char *dst= m_buffer; - char *gap_ptr= NULL; - const char *group_start_ptr= p; - int chars_in_group= 0; - int group_value= 0; - - while (p < str_end && *p) - { - char c= *p++; - - if (c == ':') - { - group_start_ptr= p; - - if (!chars_in_group) - { - if (gap_ptr) - { - DBUG_PRINT("error", ("ascii_to_ipv6(%.*s): invalid IPv6 address: " - "too many gaps(::).", (int) str_length, str)); - return true; - } - - gap_ptr= dst; - continue; - } - - if (!*p || p >= str_end) - { - DBUG_PRINT("error", ("ascii_to_ipv6(%.*s): invalid IPv6 address: " - "ending at ':'.", (int) str_length, str)); - return true; - } - - if (dst + 2 > ipv6_bytes_end) - { - DBUG_PRINT("error", ("ascii_to_ipv6(%.*s): invalid IPv6 address: " - "too many groups (1).", (int) str_length, str)); - return true; - } - - dst[0]= (unsigned char) (group_value >> 8) & 0xff; - dst[1]= (unsigned char) group_value & 0xff; - dst += 2; - - chars_in_group= 0; - group_value= 0; - } - else if (c == '.') - { - if (dst + IN_ADDR_SIZE > ipv6_bytes_end) - { - DBUG_PRINT("error", ("ascii_to_ipv6(%.*s): invalid IPv6 address: " - "unexpected IPv4-part.", (int) str_length, str)); - return true; - } - - Inet4_null tmp(group_start_ptr, (size_t) (str_end - group_start_ptr), - &my_charset_latin1); - if (tmp.is_null()) - { - DBUG_PRINT("error", ("ascii_to_ipv6(%.*s): invalid IPv6 address: " - "invalid IPv4-part.", (int) str_length, str)); - return true; - } - - tmp.to_binary(dst, IN_ADDR_SIZE); - dst += IN_ADDR_SIZE; - chars_in_group= 0; - - break; - } - else - { - const char *hdp= strchr(HEX_DIGITS, my_tolower(&my_charset_latin1, c)); - - if (!hdp) - { - DBUG_PRINT("error", ("ascii_to_ipv6(%.*s): invalid IPv6 address: " - "invalid character at pos %d.", - (int) str_length, str, (int) (p - str))); - return true; - } - - if (chars_in_group >= 4) - { - DBUG_PRINT("error", ("ascii_to_ipv6(%.*s): invalid IPv6 address: " - "too many digits in group.", - (int) str_length, str)); - return true; - } - - group_value <<= 4; - group_value |= hdp - HEX_DIGITS; - - DBUG_ASSERT(group_value <= 0xffff); - - ++chars_in_group; - } - } - - if (chars_in_group > 0) - { - if (dst + 2 > ipv6_bytes_end) - { - DBUG_PRINT("error", ("ascii_to_ipv6(%.*s): invalid IPv6 address: " - "too many groups (2).", (int) str_length, str)); - return true; - } - - dst[0]= (unsigned char) (group_value >> 8) & 0xff; - dst[1]= (unsigned char) group_value & 0xff; - dst += 2; - } - - if (gap_ptr) - { - if (dst == ipv6_bytes_end) - { - DBUG_PRINT("error", ("ascii_to_ipv6(%.*s): invalid IPv6 address: " - "no room for a gap (::).", (int) str_length, str)); - return true; - } - - int bytes_to_move= (int)(dst - gap_ptr); - - for (int i= 1; i <= bytes_to_move; ++i) - { - ipv6_bytes_end[-i]= gap_ptr[bytes_to_move - i]; - gap_ptr[bytes_to_move - i]= 0; - } - - dst= ipv6_bytes_end; - } - - if (dst < ipv6_bytes_end) - { - DBUG_PRINT("error", ("ascii_to_ipv6(%.*s): invalid IPv6 address: " - "too few groups.", (int) str_length, str)); - return true; - } - - return false; -} - - -/** - Converts IPv4-binary-address to a string. This function is a portable - alternative to inet_ntop(AF_INET). - - @param[in] ipv4 IPv4-address data (byte array) - @param[out] dst A buffer to store string representation of IPv4-address. - @param[in] dstsize Number of bytes avaiable in "dst" - - @note The problem with inet_ntop() is that it is available starting from - Windows Vista, but the minimum supported version is Windows 2000. -*/ - -size_t Inet4::to_string(char *dst, size_t dstsize) const -{ - return (size_t) my_snprintf(dst, dstsize, "%d.%d.%d.%d", - (uchar) m_buffer[0], (uchar) m_buffer[1], - (uchar) m_buffer[2], (uchar) m_buffer[3]); -} - - -/** - Converts IPv6-binary-address to a string. This function is a portable - alternative to inet_ntop(AF_INET6). - - @param[in] ipv6 IPv6-address data (byte array) - @param[out] dst A buffer to store string representation of IPv6-address. - It must be at least of INET6_ADDRSTRLEN. - @param[in] dstsize Number of bytes available dst. - - @note The problem with inet_ntop() is that it is available starting from - Windows Vista, but out the minimum supported version is Windows 2000. -*/ - -size_t Inet6::to_string(char *dst, size_t dstsize) const -{ - struct Region - { - int pos; - int length; - }; - - const char *ipv6= m_buffer; - char *dstend= dst + dstsize; - const unsigned char *ipv6_bytes= (const unsigned char *) ipv6; - - // 1. Translate IPv6-address bytes to words. - // We can't just cast to short, because it's not guaranteed - // that sizeof (short) == 2. So, we have to make a copy. - - uint16 ipv6_words[IN6_ADDR_NUM_WORDS]; - - DBUG_ASSERT(dstsize > 0); // Need a space at least for the trailing '\0' - for (size_t i= 0; i < IN6_ADDR_NUM_WORDS; ++i) - ipv6_words[i]= (ipv6_bytes[2 * i] << 8) + ipv6_bytes[2 * i + 1]; - - // 2. Find "the gap" -- longest sequence of zeros in IPv6-address. - - Region gap= { -1, -1 }; - - { - Region rg= { -1, -1 }; - - for (size_t i= 0; i < IN6_ADDR_NUM_WORDS; ++i) - { - if (ipv6_words[i] != 0) - { - if (rg.pos >= 0) - { - if (rg.length > gap.length) - gap= rg; - - rg.pos= -1; - rg.length= -1; - } - } - else - { - if (rg.pos >= 0) - { - ++rg.length; - } - else - { - rg.pos= (int) i; - rg.length= 1; - } - } - } - - if (rg.pos >= 0) - { - if (rg.length > gap.length) - gap= rg; - } - } - - // 3. Convert binary data to string. - - char *p= dst; - - for (int i= 0; i < (int) IN6_ADDR_NUM_WORDS; ++i) - { - DBUG_ASSERT(dstend >= p); - size_t dstsize_available= dstend - p; - if (dstsize_available < 5) - break; - if (i == gap.pos) - { - // We're at the gap position. We should put trailing ':' and jump to - // the end of the gap. - - if (i == 0) - { - // The gap starts from the beginning of the data -- leading ':' - // should be put additionally. - - *p= ':'; - ++p; - } - - *p= ':'; - ++p; - - i += gap.length - 1; - } - else if (i == 6 && gap.pos == 0 && - (gap.length == 6 || // IPv4-compatible - (gap.length == 5 && ipv6_words[5] == 0xffff) // IPv4-mapped - )) - { - // The data represents either IPv4-compatible or IPv4-mapped address. - // The IPv6-part (zeros or zeros + ffff) has been already put into - // the string (dst). Now it's time to dump IPv4-part. - - return (size_t) (p - dst) + - Inet4_null((const char *) (ipv6_bytes + 12), 4). - to_string(p, dstsize_available); - } - else - { - // Usual IPv6-address-field. Print it out using lower-case - // hex-letters without leading zeros (recommended IPv6-format). - // - // If it is not the last field, append closing ':'. - - p += sprintf(p, "%x", ipv6_words[i]); - - if (i + 1 != IN6_ADDR_NUM_WORDS) - { - *p= ':'; - ++p; - } - } - } - - *p= 0; - return (size_t) (p - dst); -} /////////////////////////////////////////////////////////////////////////// diff --git a/sql/sql_type_inet.cc b/sql/sql_type_inet.cc new file mode 100644 index 00000000000..f4432571199 --- /dev/null +++ b/sql/sql_type_inet.cc @@ -0,0 +1,540 @@ +/* Copyright (c) 2011, 2013, Oracle and/or its affiliates. All rights reserved. + Copyright (c) 2014 MariaDB Foundation + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; version 2 of the License. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */ + +#include "mariadb.h" +#include "my_net.h" +#include "sql_class.h" // THD, SORT_FIELD_ATTR +#include "opt_range.h" // SEL_ARG +#include "sql_type_inet.h" + +/////////////////////////////////////////////////////////////////////////// + +static const char HEX_DIGITS[]= "0123456789abcdef"; + + +/////////////////////////////////////////////////////////////////////////// + +/** + Tries to convert given string to binary IPv4-address representation. + This is a portable alternative to inet_pton(AF_INET). + + @param str String to convert. + @param str_length String length. + + @return Completion status. + @retval true - error, the given string does not represent an IPv4-address. + @retval false - ok, the string has been converted sucessfully. + + @note The problem with inet_pton() is that it treats leading zeros in + IPv4-part differently on different platforms. +*/ + +bool Inet4::ascii_to_ipv4(const char *str, size_t str_length) +{ + if (str_length < 7) + { + DBUG_PRINT("error", ("ascii_to_ipv4(%.*s): " + "invalid IPv4 address: too short.", + (int) str_length, str)); + return true; + } + + if (str_length > IN_ADDR_MAX_CHAR_LENGTH) + { + DBUG_PRINT("error", ("ascii_to_ipv4(%.*s): " + "invalid IPv4 address: too long.", + (int) str_length, str)); + return true; + } + + unsigned char *ipv4_bytes= (unsigned char *) &m_buffer; + const char *str_end= str + str_length; + const char *p= str; + int byte_value= 0; + int chars_in_group= 0; + int dot_count= 0; + char c= 0; + + while (p < str_end && *p) + { + c= *p++; + + if (my_isdigit(&my_charset_latin1, c)) + { + ++chars_in_group; + + if (chars_in_group > 3) + { + DBUG_PRINT("error", ("ascii_to_ipv4(%.*s): invalid IPv4 address: " + "too many characters in a group.", + (int) str_length, str)); + return true; + } + + byte_value= byte_value * 10 + (c - '0'); + + if (byte_value > 255) + { + DBUG_PRINT("error", ("ascii_to_ipv4(%.*s): invalid IPv4 address: " + "invalid byte value.", + (int) str_length, str)); + return true; + } + } + else if (c == '.') + { + if (chars_in_group == 0) + { + DBUG_PRINT("error", ("ascii_to_ipv4(%.*s): invalid IPv4 address: " + "too few characters in a group.", + (int) str_length, str)); + return true; + } + + ipv4_bytes[dot_count]= (unsigned char) byte_value; + + ++dot_count; + byte_value= 0; + chars_in_group= 0; + + if (dot_count > 3) + { + DBUG_PRINT("error", ("ascii_to_ipv4(%.*s): invalid IPv4 address: " + "too many dots.", (int) str_length, str)); + return true; + } + } + else + { + DBUG_PRINT("error", ("ascii_to_ipv4(%.*s): invalid IPv4 address: " + "invalid character at pos %d.", + (int) str_length, str, (int) (p - str))); + return true; + } + } + + if (c == '.') + { + DBUG_PRINT("error", ("ascii_to_ipv4(%.*s): invalid IPv4 address: " + "ending at '.'.", (int) str_length, str)); + return true; + } + + if (dot_count != 3) + { + DBUG_PRINT("error", ("ascii_to_ipv4(%.*s): invalid IPv4 address: " + "too few groups.", + (int) str_length, str)); + return true; + } + + ipv4_bytes[3]= (unsigned char) byte_value; + + DBUG_PRINT("info", ("ascii_to_ipv4(%.*s): valid IPv4 address: %d.%d.%d.%d", + (int) str_length, str, + ipv4_bytes[0], ipv4_bytes[1], + ipv4_bytes[2], ipv4_bytes[3])); + return false; +} + + +/** + Tries to convert given string to binary IPv6-address representation. + This is a portable alternative to inet_pton(AF_INET6). + + @param str String to convert. + @param str_length String length. + + @return Completion status. + @retval true - error, the given string does not represent an IPv6-address. + @retval false - ok, the string has been converted sucessfully. + + @note The problem with inet_pton() is that it treats leading zeros in + IPv4-part differently on different platforms. +*/ + +bool Inet6::ascii_to_ipv6(const char *str, size_t str_length) +{ + if (str_length < 2) + { + DBUG_PRINT("error", ("ascii_to_ipv6(%.*s): invalid IPv6 address: too short.", + (int) str_length, str)); + return true; + } + + if (str_length > IN6_ADDR_MAX_CHAR_LENGTH) + { + DBUG_PRINT("error", ("ascii_to_ipv6(%.*s): invalid IPv6 address: too long.", + (int) str_length, str)); + return true; + } + + memset(m_buffer, 0, sizeof(m_buffer)); + + const char *p= str; + + if (*p == ':') + { + ++p; + + if (*p != ':') + { + DBUG_PRINT("error", ("ascii_to_ipv6(%.*s): invalid IPv6 address: " + "can not start with ':x'.", (int) str_length, str)); + return true; + } + } + + const char *str_end= str + str_length; + char *ipv6_bytes_end= m_buffer + sizeof(m_buffer); + char *dst= m_buffer; + char *gap_ptr= NULL; + const char *group_start_ptr= p; + int chars_in_group= 0; + int group_value= 0; + + while (p < str_end && *p) + { + char c= *p++; + + if (c == ':') + { + group_start_ptr= p; + + if (!chars_in_group) + { + if (gap_ptr) + { + DBUG_PRINT("error", ("ascii_to_ipv6(%.*s): invalid IPv6 address: " + "too many gaps(::).", (int) str_length, str)); + return true; + } + + gap_ptr= dst; + continue; + } + + if (!*p || p >= str_end) + { + DBUG_PRINT("error", ("ascii_to_ipv6(%.*s): invalid IPv6 address: " + "ending at ':'.", (int) str_length, str)); + return true; + } + + if (dst + 2 > ipv6_bytes_end) + { + DBUG_PRINT("error", ("ascii_to_ipv6(%.*s): invalid IPv6 address: " + "too many groups (1).", (int) str_length, str)); + return true; + } + + dst[0]= (unsigned char) (group_value >> 8) & 0xff; + dst[1]= (unsigned char) group_value & 0xff; + dst += 2; + + chars_in_group= 0; + group_value= 0; + } + else if (c == '.') + { + if (dst + IN_ADDR_SIZE > ipv6_bytes_end) + { + DBUG_PRINT("error", ("ascii_to_ipv6(%.*s): invalid IPv6 address: " + "unexpected IPv4-part.", (int) str_length, str)); + return true; + } + + Inet4_null tmp(group_start_ptr, (size_t) (str_end - group_start_ptr), + &my_charset_latin1); + if (tmp.is_null()) + { + DBUG_PRINT("error", ("ascii_to_ipv6(%.*s): invalid IPv6 address: " + "invalid IPv4-part.", (int) str_length, str)); + return true; + } + + tmp.to_binary(dst, IN_ADDR_SIZE); + dst += IN_ADDR_SIZE; + chars_in_group= 0; + + break; + } + else + { + const char *hdp= strchr(HEX_DIGITS, my_tolower(&my_charset_latin1, c)); + + if (!hdp) + { + DBUG_PRINT("error", ("ascii_to_ipv6(%.*s): invalid IPv6 address: " + "invalid character at pos %d.", + (int) str_length, str, (int) (p - str))); + return true; + } + + if (chars_in_group >= 4) + { + DBUG_PRINT("error", ("ascii_to_ipv6(%.*s): invalid IPv6 address: " + "too many digits in group.", + (int) str_length, str)); + return true; + } + + group_value <<= 4; + group_value |= hdp - HEX_DIGITS; + + DBUG_ASSERT(group_value <= 0xffff); + + ++chars_in_group; + } + } + + if (chars_in_group > 0) + { + if (dst + 2 > ipv6_bytes_end) + { + DBUG_PRINT("error", ("ascii_to_ipv6(%.*s): invalid IPv6 address: " + "too many groups (2).", (int) str_length, str)); + return true; + } + + dst[0]= (unsigned char) (group_value >> 8) & 0xff; + dst[1]= (unsigned char) group_value & 0xff; + dst += 2; + } + + if (gap_ptr) + { + if (dst == ipv6_bytes_end) + { + DBUG_PRINT("error", ("ascii_to_ipv6(%.*s): invalid IPv6 address: " + "no room for a gap (::).", (int) str_length, str)); + return true; + } + + int bytes_to_move= (int)(dst - gap_ptr); + + for (int i= 1; i <= bytes_to_move; ++i) + { + ipv6_bytes_end[-i]= gap_ptr[bytes_to_move - i]; + gap_ptr[bytes_to_move - i]= 0; + } + + dst= ipv6_bytes_end; + } + + if (dst < ipv6_bytes_end) + { + DBUG_PRINT("error", ("ascii_to_ipv6(%.*s): invalid IPv6 address: " + "too few groups.", (int) str_length, str)); + return true; + } + + return false; +} + + +/** + Converts IPv4-binary-address to a string. This function is a portable + alternative to inet_ntop(AF_INET). + + @param[in] ipv4 IPv4-address data (byte array) + @param[out] dst A buffer to store string representation of IPv4-address. + @param[in] dstsize Number of bytes avaiable in "dst" + + @note The problem with inet_ntop() is that it is available starting from + Windows Vista, but the minimum supported version is Windows 2000. +*/ + +size_t Inet4::to_string(char *dst, size_t dstsize) const +{ + return (size_t) my_snprintf(dst, dstsize, "%d.%d.%d.%d", + (uchar) m_buffer[0], (uchar) m_buffer[1], + (uchar) m_buffer[2], (uchar) m_buffer[3]); +} + + +/** + Converts IPv6-binary-address to a string. This function is a portable + alternative to inet_ntop(AF_INET6). + + @param[in] ipv6 IPv6-address data (byte array) + @param[out] dst A buffer to store string representation of IPv6-address. + It must be at least of INET6_ADDRSTRLEN. + @param[in] dstsize Number of bytes available dst. + + @note The problem with inet_ntop() is that it is available starting from + Windows Vista, but out the minimum supported version is Windows 2000. +*/ + +size_t Inet6::to_string(char *dst, size_t dstsize) const +{ + struct Region + { + int pos; + int length; + }; + + const char *ipv6= m_buffer; + char *dstend= dst + dstsize; + const unsigned char *ipv6_bytes= (const unsigned char *) ipv6; + + // 1. Translate IPv6-address bytes to words. + // We can't just cast to short, because it's not guaranteed + // that sizeof (short) == 2. So, we have to make a copy. + + uint16 ipv6_words[IN6_ADDR_NUM_WORDS]; + + DBUG_ASSERT(dstsize > 0); // Need a space at least for the trailing '\0' + for (size_t i= 0; i < IN6_ADDR_NUM_WORDS; ++i) + ipv6_words[i]= (ipv6_bytes[2 * i] << 8) + ipv6_bytes[2 * i + 1]; + + // 2. Find "the gap" -- longest sequence of zeros in IPv6-address. + + Region gap= { -1, -1 }; + + { + Region rg= { -1, -1 }; + + for (size_t i= 0; i < IN6_ADDR_NUM_WORDS; ++i) + { + if (ipv6_words[i] != 0) + { + if (rg.pos >= 0) + { + if (rg.length > gap.length) + gap= rg; + + rg.pos= -1; + rg.length= -1; + } + } + else + { + if (rg.pos >= 0) + { + ++rg.length; + } + else + { + rg.pos= (int) i; + rg.length= 1; + } + } + } + + if (rg.pos >= 0) + { + if (rg.length > gap.length) + gap= rg; + } + } + + // 3. Convert binary data to string. + + char *p= dst; + + for (int i= 0; i < (int) IN6_ADDR_NUM_WORDS; ++i) + { + DBUG_ASSERT(dstend >= p); + size_t dstsize_available= dstend - p; + if (dstsize_available < 5) + break; + if (i == gap.pos) + { + // We're at the gap position. We should put trailing ':' and jump to + // the end of the gap. + + if (i == 0) + { + // The gap starts from the beginning of the data -- leading ':' + // should be put additionally. + + *p= ':'; + ++p; + } + + *p= ':'; + ++p; + + i += gap.length - 1; + } + else if (i == 6 && gap.pos == 0 && + (gap.length == 6 || // IPv4-compatible + (gap.length == 5 && ipv6_words[5] == 0xffff) // IPv4-mapped + )) + { + // The data represents either IPv4-compatible or IPv4-mapped address. + // The IPv6-part (zeros or zeros + ffff) has been already put into + // the string (dst). Now it's time to dump IPv4-part. + + return (size_t) (p - dst) + + Inet4_null((const char *) (ipv6_bytes + 12), 4). + to_string(p, dstsize_available); + } + else + { + // Usual IPv6-address-field. Print it out using lower-case + // hex-letters without leading zeros (recommended IPv6-format). + // + // If it is not the last field, append closing ':'. + + p += sprintf(p, "%x", ipv6_words[i]); + + if (i + 1 != IN6_ADDR_NUM_WORDS) + { + *p= ':'; + ++p; + } + } + } + + *p= 0; + return (size_t) (p - dst); +} + + +bool Inet6::make_from_item(Item *item) +{ + StringBufferInet6 tmp; + String *str= item->val_str(&tmp); + return str ? make_from_character_or_binary_string(str) : true; +} + + +bool Inet6::make_from_character_or_binary_string(const String *str) +{ + static Name name= Name(STRING_WITH_LEN("inet6")); + if (str->charset() != &my_charset_bin) + { + bool rc= character_string_to_ipv6(str->ptr(), str->length(), + str->charset()); + if (rc) + current_thd->push_warning_wrong_value(Sql_condition::WARN_LEVEL_WARN, + name.ptr(), + ErrConvString(str).ptr()); + return rc; + } + if (str->length() != sizeof(m_buffer)) + { + current_thd->push_warning_wrong_value(Sql_condition::WARN_LEVEL_WARN, + name.ptr(), + ErrConvString(str).ptr()); + return true; + } + DBUG_ASSERT(str->ptr() != m_buffer); + memcpy(m_buffer, str->ptr(), sizeof(m_buffer)); + return false; +}; diff --git a/sql/sql_type_inet.h b/sql/sql_type_inet.h new file mode 100644 index 00000000000..db3349c2581 --- /dev/null +++ b/sql/sql_type_inet.h @@ -0,0 +1,303 @@ +#ifndef SQL_TYPE_INET_H +#define SQL_TYPE_INET_H +/* Copyright (c) 2011, 2013, Oracle and/or its affiliates. All rights reserved. + Copyright (c) 2014 MariaDB Foundation + Copyright (c) 2019 MariaDB Corporation + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; version 2 of the License. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */ + + +static const size_t IN_ADDR_SIZE= 4; +static const size_t IN_ADDR_MAX_CHAR_LENGTH= 15; + +static const size_t IN6_ADDR_SIZE= 16; +static const size_t IN6_ADDR_NUM_WORDS= IN6_ADDR_SIZE / 2; + +/** + Non-abbreviated syntax is 8 groups, up to 4 digits each, + plus 7 delimiters between the groups. + Abbreviated syntax is even shorter. +*/ +static const uint IN6_ADDR_MAX_CHAR_LENGTH= 8 * 4 + 7; + + +class NativeBufferInet6: public NativeBuffer<IN6_ADDR_SIZE+1> +{ +}; + +class StringBufferInet6: public StringBuffer<IN6_ADDR_MAX_CHAR_LENGTH+1> +{ +}; + +/***********************************************************************/ + +class Inet4 +{ + char m_buffer[IN_ADDR_SIZE]; +protected: + bool ascii_to_ipv4(const char *str, size_t length); + bool character_string_to_ipv4(const char *str, size_t str_length, + CHARSET_INFO *cs) + { + if (cs->state & MY_CS_NONASCII) + { + char tmp[IN_ADDR_MAX_CHAR_LENGTH]; + String_copier copier; + uint length= copier.well_formed_copy(&my_charset_latin1, tmp, sizeof(tmp), + cs, str, str_length); + return ascii_to_ipv4(tmp, length); + } + return ascii_to_ipv4(str, str_length); + } + bool binary_to_ipv4(const char *str, size_t length) + { + if (length != sizeof(m_buffer)) + return true; + memcpy(m_buffer, str, length); + return false; + } + // Non-initializing constructor + Inet4() { } +public: + void to_binary(char *dst, size_t dstsize) const + { + DBUG_ASSERT(dstsize >= sizeof(m_buffer)); + memcpy(dst, m_buffer, sizeof(m_buffer)); + } + bool to_binary(String *to) const + { + return to->copy(m_buffer, sizeof(m_buffer), &my_charset_bin); + } + size_t to_string(char *dst, size_t dstsize) const; + bool to_string(String *to) const + { + to->set_charset(&my_charset_latin1); + if (to->alloc(INET_ADDRSTRLEN)) + return true; + to->length((uint32) to_string((char*) to->ptr(), INET_ADDRSTRLEN)); + return false; + } +}; + + +class Inet4_null: public Inet4, public Null_flag +{ +public: + // Initialize from a text representation + Inet4_null(const char *str, size_t length, CHARSET_INFO *cs) + :Null_flag(character_string_to_ipv4(str, length, cs)) + { } + Inet4_null(const String &str) + :Inet4_null(str.ptr(), str.length(), str.charset()) + { } + // Initialize from a binary representation + Inet4_null(const char *str, size_t length) + :Null_flag(binary_to_ipv4(str, length)) + { } + Inet4_null(const Binary_string &str) + :Inet4_null(str.ptr(), str.length()) + { } +public: + const Inet4& to_inet4() const + { + DBUG_ASSERT(!is_null()); + return *this; + } + void to_binary(char *dst, size_t dstsize) const + { + to_inet4().to_binary(dst, dstsize); + } + bool to_binary(String *to) const + { + return to_inet4().to_binary(to); + } + size_t to_string(char *dst, size_t dstsize) const + { + return to_inet4().to_string(dst, dstsize); + } + bool to_string(String *to) const + { + return to_inet4().to_string(to); + } +}; + + +class Inet6 +{ +protected: + char m_buffer[IN6_ADDR_SIZE]; + bool make_from_item(Item *item); + bool ascii_to_ipv6(const char *str, size_t str_length); + bool character_string_to_ipv6(const char *str, size_t str_length, + CHARSET_INFO *cs) + { + if (cs->state & MY_CS_NONASCII) + { + char tmp[IN6_ADDR_MAX_CHAR_LENGTH]; + String_copier copier; + uint length= copier.well_formed_copy(&my_charset_latin1, tmp, sizeof(tmp), + cs, str, str_length); + return ascii_to_ipv6(tmp, length); + } + return ascii_to_ipv6(str, str_length); + } + bool make_from_character_or_binary_string(const String *str); + bool binary_to_ipv6(const char *str, size_t length) + { + if (length != sizeof(m_buffer)) + return true; + memcpy(m_buffer, str, length); + return false; + } + + Inet6() { } + +public: + static uint binary_length() { return IN6_ADDR_SIZE; } + /** + Non-abbreviated syntax is 8 groups, up to 4 digits each, + plus 7 delimiters between the groups. + Abbreviated syntax is even shorter. + */ + static uint max_char_length() { return IN6_ADDR_MAX_CHAR_LENGTH; } + + static bool only_zero_bytes(const char *ptr, uint length) + { + for (uint i= 0 ; i < length; i++) + { + if (ptr[i] != 0) + return false; + } + return true; + } + +public: + + Inet6(Item *item, bool *error) + { + *error= make_from_item(item); + } + void to_binary(char *str, size_t str_size) const + { + DBUG_ASSERT(str_size >= sizeof(m_buffer)); + memcpy(str, m_buffer, sizeof(m_buffer)); + } + bool to_binary(String *to) const + { + return to->copy(m_buffer, sizeof(m_buffer), &my_charset_bin); + } + bool to_native(Native *to) const + { + return to->copy(m_buffer, sizeof(m_buffer)); + } + size_t to_string(char *dst, size_t dstsize) const; + bool to_string(String *to) const + { + to->set_charset(&my_charset_latin1); + if (to->alloc(INET6_ADDRSTRLEN)) + return true; + to->length((uint32) to_string((char*) to->ptr(), INET6_ADDRSTRLEN)); + return false; + } + bool is_v4compat() const + { + static_assert(sizeof(in6_addr) == IN6_ADDR_SIZE, "unexpected in6_addr size"); + return IN6_IS_ADDR_V4COMPAT((struct in6_addr *) m_buffer); + } + bool is_v4mapped() const + { + static_assert(sizeof(in6_addr) == IN6_ADDR_SIZE, "unexpected in6_addr size"); + return IN6_IS_ADDR_V4MAPPED((struct in6_addr *) m_buffer); + } + int cmp(const char *str, size_t length) const + { + DBUG_ASSERT(length == sizeof(m_buffer)); + return memcmp(m_buffer, str, length); + } + int cmp(const Binary_string &other) const + { + return cmp(other.ptr(), other.length()); + } + int cmp(const Inet6 &other) const + { + return memcmp(m_buffer, other.m_buffer, sizeof(m_buffer)); + } +}; + + +class Inet6_zero: public Inet6 +{ +public: + Inet6_zero() + { + bzero(&m_buffer, sizeof(m_buffer)); + } +}; + + +class Inet6_null: public Inet6, public Null_flag +{ +public: + // Initialize from a text representation + Inet6_null(const char *str, size_t length, CHARSET_INFO *cs) + :Null_flag(character_string_to_ipv6(str, length, cs)) + { } + Inet6_null(const String &str) + :Inet6_null(str.ptr(), str.length(), str.charset()) + { } + // Initialize from a binary representation + Inet6_null(const char *str, size_t length) + :Null_flag(binary_to_ipv6(str, length)) + { } + Inet6_null(const Binary_string &str) + :Inet6_null(str.ptr(), str.length()) + { } + // Initialize from an Item + Inet6_null(Item *item) + :Null_flag(make_from_item(item)) + { } +public: + const Inet6& to_inet6() const + { + DBUG_ASSERT(!is_null()); + return *this; + } + void to_binary(char *str, size_t str_size) const + { + to_inet6().to_binary(str, str_size); + } + bool to_binary(String *to) const + { + return to_inet6().to_binary(to); + } + size_t to_string(char *dst, size_t dstsize) const + { + return to_inet6().to_string(dst, dstsize); + } + bool to_string(String *to) const + { + return to_inet6().to_string(to); + } + bool is_v4compat() const + { + return to_inet6().is_v4compat(); + } + bool is_v4mapped() const + { + return to_inet6().is_v4mapped(); + } +}; + + +#endif /* SQL_TYPE_INET_H */ |