mirror/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-01-29 02:05:57 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

A cleanup for: MDEV-18010 Add classes Inet4 and Inet6

Browse source 
- Moving the implementations of class Inet4 and class Inet6 into separate
  files sql_type_inet.h and sql_type_inet.cc, in order to reuse them
  for the INET6 data type and inet function collection.
- Adding a warning in the case when IS_IPV4_MAPPED() and IS_IPV4_COMPAT()
  erroneously gets an IPv4 address instead of the expected IPv6 address.
This commit is contained in:
Alexander Barkov 2019-10-07 19:23:09 +04:00
parent cbf6beba40
commit e0117f1120
6 changed files with 849 additions and 714 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
libmysqld/CMakeLists.txt
View file

@ -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

3
mysql-test/main/func_misc.result
View file

@ -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'))

1
sql/CMakeLists.txt
View file

@ -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

715
sql/item_inetfunc.cc
View file

@ -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);
}
///////////////////////////////////////////////////////////////////////////

540
sql/sql_type_inet.cc Normal file
View file

@ -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;
};

303
sql/sql_type_inet.h Normal file
View file

@ -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 */