ruby-mysql 2.9.14 → 3.0.0

data/lib/mysql/protocol.rb

@@ -1,11 +1,11 @@
 # coding: ascii-8bit
-# Copyright (C) 2008-2012 TOMITA Masahiro
+# Copyright (C) 2008 TOMITA Masahiro
 # mailto:tommy@tmtm.org
 
 require "socket"
-require "timeout"
-require "digest/sha1"
 require "stringio"
+require "openssl"
+require_relative 'authenticator.rb'
 
 class Mysql
   # MySQL network protocol
@@ -15,12 +15,10 @@ class Mysql
     MAX_PACKET_LENGTH = 2**24-1
 
     # Convert netdata to Ruby value
-    # === Argument
-    # data :: [Packet] packet data
-    # type :: [Integer] field type
-    # unsigned :: [true or false] true if value is unsigned
-    # === Return
-    # Object :: converted value.
+    # @param data [Packet] packet data
+    # @param type [Integer] field type
+    # @param unsigned [true or false] true if value is unsigned
+    # @return [Object] converted value.
     def self.net2value(pkt, type, unsigned)
       case type
       when Field::TYPE_STRING, Field::TYPE_VAR_STRING, Field::TYPE_NEWDECIMAL, Field::TYPE_BLOB, Field::TYPE_JSON
@@ -45,17 +43,18 @@ class Mysql
       when Field::TYPE_DATE
         len = pkt.utiny
         y, m, d = pkt.read(len).unpack("vCC")
-        t = Mysql::Time.new(y, m, d, nil, nil, nil)
+        t = Time.new(y, m, d) rescue nil
         return t
       when Field::TYPE_DATETIME, Field::TYPE_TIMESTAMP
         len = pkt.utiny
         y, m, d, h, mi, s, sp = pkt.read(len).unpack("vCCCCCV")
-        return Mysql::Time.new(y, m, d, h, mi, s, false, sp)
+        return Time.new(y, m, d, h, mi, Rational((s.to_i*1000000+sp.to_i)/1000000)) rescue nil
       when Field::TYPE_TIME
         len = pkt.utiny
         sign, d, h, mi, s, sp = pkt.read(len).unpack("CVCCCV")
-        h = d.to_i * 24 + h.to_i
-        return Mysql::Time.new(0, 0, 0, h, mi, s, sign!=0, sp)
+        r = d.to_i*86400 + h.to_i*3600 + mi.to_i*60 + s.to_i + sp.to_f/1000000
+        r *= -1 if sign != 0
+        return r
       when Field::TYPE_YEAR
         return pkt.ushort
       when Field::TYPE_BIT
@@ -66,13 +65,10 @@ class Mysql
     end
 
     # convert Ruby value to netdata
-    # === Argument
-    # v :: [Object] Ruby value.
-    # === Return
-    # Integer :: type of column. Field::TYPE_*
-    # String :: netdata
-    # === Exception
-    # ProtocolError :: value too large / value is not supported
+    # @param v [Object] Ruby value.
+    # @return [Integer] type of column. Field::TYPE_*
+    # @return [String] netdata
+    # @raise [ProtocolError] value too large / value is not supported
     def self.value2net(v)
       case v
       when nil
@@ -97,12 +93,9 @@ class Mysql
       when String
         type = Field::TYPE_STRING
         val = Packet.lcs(v)
-      when ::Time
+      when Time
         type = Field::TYPE_DATETIME
         val = [11, v.year, v.month, v.day, v.hour, v.min, v.sec, v.usec].pack("CvCCCCCV")
-      when Mysql::Time
-        type = Field::TYPE_DATETIME
-        val = [11, v.year, v.month, v.day, v.hour, v.min, v.sec, v.second_part].pack("CvCCCCCV")
       else
         raise ProtocolError, "class #{v.class} is not supported"
       end
@@ -112,12 +105,14 @@ class Mysql
     attr_reader :server_info
     attr_reader :server_version
     attr_reader :thread_id
+    attr_reader :client_flags
     attr_reader :sqlstate
     attr_reader :affected_rows
     attr_reader :insert_id
     attr_reader :server_status
     attr_reader :warning_count
     attr_reader :message
+    attr_reader :get_server_public_key
     attr_accessor :charset
 
     # @state variable keep state for connection.
@@ -127,72 +122,101 @@ class Mysql
     # :RESULT :: After retr_fields(), retr_all_records() or stmt_retr_all_records() is needed.
 
     # make socket connection to server.
-    # === Argument
-    # host :: [String] if "localhost" or "" nil then use UNIXSocket. Otherwise use TCPSocket
-    # port :: [Integer] port number using by TCPSocket
-    # socket :: [String] socket file name using by UNIXSocket
-    # conn_timeout :: [Integer] connect timeout (sec).
-    # read_timeout :: [Integer] read timeout (sec).
-    # write_timeout :: [Integer] write timeout (sec).
-    # === Exception
-    # [ClientError] :: connection timeout
-    def initialize(host, port, socket, conn_timeout, read_timeout, write_timeout)
+    # @param opts [Hash]
+    # @option :host [String] hostname mysqld running
+    # @option :username [String] username to connect to mysqld
+    # @option :password [String] password to connect to mysqld
+    # @option :database [String] initial database name
+    # @option :port [String] port number (used if host is not 'localhost' or nil)
+    # @option :socket [String] socket filename (used if host is 'localhost' or nil)
+    # @option :flags [Integer] connection flag. Mysql::CLIENT_* ORed
+    # @option :charset [Mysql::Charset] character set
+    # @option :connect_timeout [Numeric, nil]
+    # @option :read_timeout [Numeric, nil]
+    # @option :write_timeout [Numeric, nil]
+    # @option :local_infile [Boolean]
+    # @option :load_data_local_dir [String]
+    # @option :ssl_mode [Integer]
+    # @option :get_server_public_key [Boolean]
+    # @raise [ClientError] connection timeout
+    def initialize(opts)
+      @opts = opts
+      @charset = Mysql::Charset.by_name("utf8mb4")
       @insert_id = 0
       @warning_count = 0
       @gc_stmt_queue = []   # stmt id list which GC destroy.
       set_state :INIT
-      @read_timeout = read_timeout
-      @write_timeout = write_timeout
+      @get_server_public_key = @opts[:get_server_public_key]
       begin
-        Timeout.timeout conn_timeout do
-          if host.nil? or host.empty? or host == "localhost"
-            socket ||= ENV["MYSQL_UNIX_PORT"] || MYSQL_UNIX_PORT
-            @sock = UNIXSocket.new socket
-          else
-            port ||= ENV["MYSQL_TCP_PORT"] || (Socket.getservbyname("mysql","tcp") rescue MYSQL_TCP_PORT)
-            @sock = TCPSocket.new host, port
-          end
+        if @opts[:host].nil? or @opts[:host].empty? or @opts[:host] == "localhost"
+          socket = @opts[:socket] || ENV["MYSQL_UNIX_PORT"] || MYSQL_UNIX_PORT
+          @socket = Socket.unix(socket)
+        else
+          port = @opts[:port] || ENV["MYSQL_TCP_PORT"] || (Socket.getservbyname("mysql","tcp") rescue MYSQL_TCP_PORT)
+          @socket = Socket.tcp(@opts[:host], port, connect_timeout: @opts[:connect_timeout])
         end
-      rescue Timeout::Error
+      rescue Errno::ETIMEDOUT
         raise ClientError, "connection timeout"
       end
     end
 
     def close
-      @sock.close
+      @socket.close
     end
 
     # initial negotiate and authenticate.
-    # === Argument
-    # user    :: [String / nil] username
-    # passwd  :: [String / nil] password
-    # db      :: [String / nil] default database name. nil: no default.
-    # flag    :: [Integer] client flag
-    # charset :: [Mysql::Charset / nil] charset for connection. nil: use server's charset
-    # === Exception
-    # ProtocolError :: The old style password is not supported
-    def authenticate(user, passwd, db, flag, charset)
+    # @param charset [Mysql::Charset, nil] charset for connection. nil: use server's charset
+    # @raise [ProtocolError] The old style password is not supported
+    def authenticate
       check_state :INIT
-      @authinfo = [user, passwd, db, flag, charset]
       reset
       init_packet = InitialPacket.parse read
       @server_info = init_packet.server_version
       @server_version = init_packet.server_version.split(/\D/)[0,3].inject{|a,b|a.to_i*100+b.to_i}
+      @server_capabilities = init_packet.server_capabilities
       @thread_id = init_packet.thread_id
-      client_flags = CLIENT_LONG_PASSWORD | CLIENT_LONG_FLAG | CLIENT_TRANSACTIONS | CLIENT_PROTOCOL_41 | CLIENT_SECURE_CONNECTION
-      client_flags |= CLIENT_CONNECT_WITH_DB if db
-      client_flags |= flag
-      @charset = charset
-      unless @charset
+      @client_flags = CLIENT_LONG_PASSWORD | CLIENT_LONG_FLAG | CLIENT_TRANSACTIONS | CLIENT_PROTOCOL_41 | CLIENT_SECURE_CONNECTION | CLIENT_PLUGIN_AUTH
+      @client_flags |= CLIENT_LOCAL_FILES if @opts[:local_infile] || @opts[:load_data_local_dir]
+      @client_flags |= CLIENT_CONNECT_WITH_DB if @opts[:database]
+      @client_flags |= @opts[:flags]
+      if @opts[:charset]
+        @charset = @opts[:charset].is_a?(Charset) ? @opts[:charset] : Charset.by_name(@opts[:charset])
+      else
         @charset = Charset.by_number(init_packet.server_charset)
         @charset.encoding       # raise error if unsupported charset
       end
-      netpw = encrypt_password passwd, init_packet.scramble_buff
-      write AuthenticationPacket.serialize(client_flags, 1024**3, @charset.number, user, netpw, db)
-      raise ProtocolError, 'The old style password is not supported' if read.to_s == "\xfe"
+      enable_ssl
+      Authenticator.new(self).authenticate(@opts[:username], @opts[:password].to_s, @opts[:database], init_packet.scramble_buff, init_packet.auth_plugin)
       set_state :READY
     end
 
+    def enable_ssl
+      case @opts[:ssl_mode]
+      when SSL_MODE_DISABLED, '1', 'disabled'
+        return
+      when SSL_MODE_PREFERRED, '2', 'preferred'
+        return if @socket.local_address.unix?
+        return if @server_capabilities & CLIENT_SSL == 0
+      when SSL_MODE_REQUIRED, '3', 'required'
+        if @server_capabilities & CLIENT_SSL == 0
+          raise ClientError::SslConnectionError, "SSL is required but the server doesn't support it"
+        end
+      else
+        raise ClientError, "ssl_mode #{@opts[:ssl_mode]} is not supported"
+      end
+      begin
+        @client_flags |= CLIENT_SSL
+        write Protocol::TlsAuthenticationPacket.serialize(@client_flags, 1024**3, @charset.number)
+        @socket = OpenSSL::SSL::SSLSocket.new(@socket)
+        @socket.sync_close = true
+        @socket.connect
+      rescue => e
+        @client_flags &= ~CLIENT_SSL
+        return if @opts[:ssl_mode] == SSL_MODE_PREFERRED
+        raise e
+      end
+    end
+
     # Quit command
     def quit_command
       synchronize do
@@ -203,10 +227,8 @@ class Mysql
     end
 
     # Query command
-    # === Argument
-    # query :: [String] query string
-    # === Return
-    # [Integer / nil] number of fields of results. nil if no results.
+    # @param query [String] query string
+    # @return [Integer, nil] number of fields of results. nil if no results.
     def query_command(query)
       check_state :READY
       begin
@@ -220,8 +242,7 @@ class Mysql
     end
 
     # get result of query.
-    # === Return
-    # [integer / nil] number of fields of results. nil if no results.
+    # @return [integer, nil] number of fields of results. nil if no results.
     def get_result
       begin
         res_packet = ResultPacket.parse read
@@ -230,10 +251,7 @@ class Mysql
           return res_packet.field_count
         end
         if res_packet.field_count.nil?      # LOAD DATA LOCAL INFILE
-          filename = res_packet.message
-          File.open(filename){|f| write f}
-          write nil  # EOF mark
-          read
+          send_local_file(res_packet.message)
         end
         @affected_rows, @insert_id, @server_status, @warning_count, @message =
           res_packet.affected_rows, res_packet.insert_id, res_packet.server_status, res_packet.warning_count, res_packet.message
@@ -245,11 +263,22 @@ class Mysql
       end
     end
 
+    # send local file to server
+    def send_local_file(filename)
+      filename = File.absolute_path(filename)
+      if @opts[:local_infile] || @opts[:load_data_local_dir] && filename.start_with?(@opts[:load_data_local_dir])
+        File.open(filename){|f| write f}
+      else
+        raise ClientError::LoadDataLocalInfileRejected, 'LOAD DATA LOCAL INFILE file request rejected due to restrictions on access.'
+      end
+    ensure
+      write nil # EOF mark
+      read
+    end
+
     # Retrieve n fields
-    # === Argument
-    # n :: [Integer] number of fields
-    # === Return
-    # [Array of Mysql::Field] field list
+    # @param n [Integer] number of fields
+    # @return [Array<Mysql::Field>] field list
     def retr_fields(n)
       check_state :FIELD
       begin
@@ -264,10 +293,8 @@ class Mysql
     end
 
     # Retrieve all records for simple query
-    # === Argument
-    # fields :: [Array<Mysql::Field>] number of fields
-    # === Return
-    # [Array of Array of String] all records
+    # @param fields [Array<Mysql::Field>] number of fields
+    # @return [Array<Array<String>>] all records
     def retr_all_records(fields)
       check_state :RESULT
       enc = charset.encoding
@@ -284,43 +311,6 @@ class Mysql
       end
     end
 
-    # Field list command
-    # === Argument
-    # table :: [String] table name.
-    # field :: [String / nil] field name that may contain wild card.
-    # === Return
-    # [Array of Field] field list
-    def field_list_command(table, field)
-      synchronize do
-        reset
-        write [COM_FIELD_LIST, table, 0, field].pack("Ca*Ca*")
-        fields = []
-        until (data = read).eof?
-          fields.push Field.new(FieldPacket.parse(data))
-        end
-        return fields
-      end
-    end
-
-    # Process info command
-    # === Return
-    # [Array of Field] field list
-    def process_info_command
-      check_state :READY
-      begin
-        reset
-        write [COM_PROCESS_INFO].pack("C")
-        field_count = read.lcb
-        fields = field_count.times.map{Field.new FieldPacket.parse(read)}
-        read_eof_packet
-        set_state :RESULT
-        return fields
-      rescue
-        set_state :READY
-        raise
-      end
-    end
-
     # Ping command
     def ping_command
       simple_command [COM_PING].pack("C")
@@ -352,12 +342,8 @@ class Mysql
     end
 
     # Stmt prepare command
-    # === Argument
-    # stmt :: [String] prepared statement
-    # === Return
-    # [Integer] statement id
-    # [Integer] number of parameters
-    # [Array of Field] field list
+    # @param stmt [String] prepared statement
+    # @return [Array<Integer, Integer, Array<Field>>] statement id, number of parameters, field list
     def stmt_prepare_command(stmt)
       synchronize do
         reset
@@ -378,11 +364,9 @@ class Mysql
     end
 
     # Stmt execute command
-    # === Argument
-    # stmt_id :: [Integer] statement id
-    # values  :: [Array] parameters
-    # === Return
-    # [Integer] number of fields
+    # @param stmt_id [Integer] statement id
+    # @param values [Array] parameters
+    # @return [Integer] number of fields
     def stmt_execute_command(stmt_id, values)
       check_state :READY
       begin
@@ -396,11 +380,9 @@ class Mysql
     end
 
     # Retrieve all records for prepared statement
-    # === Argument
-    # fields  :: [Array of Mysql::Fields] field list
-    # charset :: [Mysql::Charset]
-    # === Return
-    # [Array of Array of Object] all records
+    # @param fields [Array of Mysql::Fields] field list
+    # @param charset [Mysql::Charset]
+    # @return [Array<Array<Object>>] all records
     def stmt_retr_all_records(fields, charset)
       check_state :RESULT
       enc = charset.encoding
@@ -416,8 +398,7 @@ class Mysql
     end
 
     # Stmt close command
-    # === Argument
-    # stmt_id :: [Integer] statement id
+    # @param stmt_id [Integer] statement id
     def stmt_close_command(stmt_id)
       synchronize do
         reset
@@ -429,15 +410,13 @@ class Mysql
       @gc_stmt_queue.push stmt_id
     end
 
-    private
-
     def check_state(st)
       raise 'command out of sync' unless @state == st
     end
 
     def set_state(st)
       @state = st
-      if st == :READY
+      if st == :READY && !@gc_stmt_queue.empty?
         gc_disabled = GC.disable
         begin
           while st = @gc_stmt_queue.shift
@@ -465,28 +444,24 @@ class Mysql
     end
 
     # Read one packet data
-    # === Return
-    # [Packet] packet data
-    # === Exception
-    # [ProtocolError] invalid packet sequence number
+    # @return [Packet] packet data
+    # @rails [ProtocolError] invalid packet sequence number
     def read
       data = ''
       len = nil
       begin
-        Timeout.timeout @read_timeout do
-          header = @sock.read(4)
-          raise EOFError unless header && header.length == 4
-          len1, len2, seq = header.unpack("CvC")
-          len = (len2 << 8) + len1
-          raise ProtocolError, "invalid packet: sequence number mismatch(#{seq} != #{@seq}(expected))" if @seq != seq
-          @seq = (@seq + 1) % 256
-          ret = @sock.read(len)
-          raise EOFError unless ret && ret.length == len
-          data.concat ret
-        end
+        header = read_timeout(4, @opts[:read_timeout])
+        raise EOFError unless header && header.length == 4
+        len1, len2, seq = header.unpack("CvC")
+        len = (len2 << 8) + len1
+        raise ProtocolError, "invalid packet: sequence number mismatch(#{seq} != #{@seq}(expected))" if @seq != seq
+        @seq = (@seq + 1) % 256
+        ret = read_timeout(len, @opts[:read_timeout])
+        raise EOFError unless ret && ret.length == len
+        data.concat ret
       rescue EOFError
         raise ClientError::ServerGoneError, 'MySQL server has gone away'
-      rescue Timeout::Error
+      rescue Errno::ETIMEDOUT
         raise ClientError, "read timeout"
       end while len == MAX_PACKET_LENGTH
 
@@ -494,64 +469,95 @@ class Mysql
 
       # Error packet
       if data[0] == ?\xff
-        f, errno, marker, @sqlstate, message = data.unpack("Cvaa5a*")
+        _, errno, marker, @sqlstate, message = data.unpack("Cvaa5a*")
         unless marker == "#"
-          f, errno, message = data.unpack("Cva*")    # Version 4.0 Error
+          _, errno, message = data.unpack("Cva*")    # Version 4.0 Error
           @sqlstate = ""
         end
         message.force_encoding(@charset.encoding)
         if Mysql::ServerError::ERROR_MAP.key? errno
           raise Mysql::ServerError::ERROR_MAP[errno].new(message, @sqlstate)
         end
-        raise Mysql::ServerError.new(message, @sqlstate)
+        raise Mysql::ServerError.new(message, @sqlstate, errno)
       end
       Packet.new(data)
     end
 
+    def read_timeout(len, timeout)
+      return @socket.read(len) if timeout.nil? || timeout == 0
+      result = ''
+      e = Time.now + timeout
+      while result.size < len
+        now = Time.now
+        raise Errno::ETIMEDOUT if now > e
+        r = @socket.read_nonblock(len - result.size, exception: false)
+        case r
+        when :wait_readable
+          IO.select([@socket], nil, nil, e - now)
+          next
+        when :wait_writable
+          IO.select(nil, [@socket], nil, e - now)
+          next
+        else
+          result << r
+        end
+      end
+      return result
+    end
+
     # Write one packet data
-    # === Argument
-    # data :: [String / IO] packet data. If data is nil, write empty packet.
+    # @param data [String, IO, nil] packet data. If data is nil, write empty packet.
     def write(data)
       begin
-        @sock.sync = false
+        @socket.sync = false
         if data.nil?
-          Timeout.timeout @write_timeout do
-            @sock.write [0, 0, @seq].pack("CvC")
-          end
+          write_timeout([0, 0, @seq].pack("CvC"), @opts[:write_timeout])
           @seq = (@seq + 1) % 256
         else
           data = StringIO.new data if data.is_a? String
           while d = data.read(MAX_PACKET_LENGTH)
-            Timeout.timeout @write_timeout do
-              @sock.write [d.length%256, d.length/256, @seq].pack("CvC")
-              @sock.write d
-            end
+            write_timeout([d.length%256, d.length/256, @seq].pack("CvC")+d, @opts[:write_timeout])
             @seq = (@seq + 1) % 256
           end
         end
-        @sock.sync = true
-        Timeout.timeout @write_timeout do
-          @sock.flush
-        end
+        @socket.sync = true
+        @socket.flush
       rescue Errno::EPIPE
         raise ClientError::ServerGoneError, 'MySQL server has gone away'
-      rescue Timeout::Error
+      rescue Errno::ETIMEDOUT
         raise ClientError, "write timeout"
       end
     end
 
+    def write_timeout(data, timeout)
+      return @socket.write(data) if timeout.nil? || timeout == 0
+      len = 0
+      e = Time.now + timeout
+      while len < data.size
+        now = Time.now
+        raise Errno::ETIMEDOUT if now > e
+        l = @socket.write_nonblock(data[len..-1], exception: false)
+        case l
+        when :wait_readable
+          IO.select([@socket], nil, nil, e - now)
+        when :wait_writable
+          IO.select(nil, [@socket], nil, e - now)
+        else
+          len += l
+        end
+      end
+      return len
+    end
+
     # Read EOF packet
-    # === Exception
-    # [ProtocolError] packet is not EOF
+    # @raise [ProtocolError] packet is not EOF
     def read_eof_packet
       raise ProtocolError, "packet is not EOF" unless read.eof?
     end
 
     # Send simple command
-    # === Argument
-    # packet :: [String] packet data
-    # === Return
-    # [String] received data
+    # @param packet :: [String] packet data
+    # @return [String] received data
     def simple_command(packet)
       synchronize do
         reset
@@ -560,19 +566,6 @@ class Mysql
       end
     end
 
-    # Encrypt password
-    # === Argument
-    # plain    :: [String] plain password.
-    # scramble :: [String] scramble code from initial packet.
-    # === Return
-    # [String] encrypted password
-    def encrypt_password(plain, scramble)
-      return "" if plain.nil? or plain.empty?
-      hash_stage1 = Digest::SHA1.digest plain
-      hash_stage2 = Digest::SHA1.digest hash_stage1
-      return hash_stage1.unpack("C*").zip(Digest::SHA1.digest(scramble+hash_stage2).unpack("C*")).map{|a,b| a^b}.pack("C*")
-    end
-
     # Initial packet
     class InitialPacket
       def self.parse(pkt)
@@ -584,18 +577,26 @@ class Mysql
         server_capabilities = pkt.ushort
         server_charset = pkt.utiny
         server_status = pkt.ushort
-        _f1 = pkt.read(13)
+        server_capabilities2 = pkt.ushort
+        scramble_length = pkt.utiny
+        _f1 = pkt.read(10)
         rest_scramble_buff = pkt.string
+        auth_plugin = pkt.string
+
+        server_capabilities |= server_capabilities2 << 16
+        scramble_buff.concat rest_scramble_buff
+
         raise ProtocolError, "unsupported version: #{protocol_version}" unless protocol_version == VERSION
         raise ProtocolError, "invalid packet: f0=#{f0}" unless f0 == 0
-        scramble_buff.concat rest_scramble_buff
-        self.new protocol_version, server_version, thread_id, server_capabilities, server_charset, server_status, scramble_buff
+        raise ProtocolError, "invalid packet: scramble_length(#{scramble_length}) != length of scramble(#{scramble_buff.size + 1})" unless scramble_length == scramble_buff.size + 1
+
+        self.new protocol_version, server_version, thread_id, server_capabilities, server_charset, server_status, scramble_buff, auth_plugin
       end
 
-      attr_reader :protocol_version, :server_version, :thread_id, :server_capabilities, :server_charset, :server_status, :scramble_buff
+      attr_reader :protocol_version, :server_version, :thread_id, :server_capabilities, :server_charset, :server_status, :scramble_buff, :auth_plugin
 
       def initialize(*args)
-        @protocol_version, @server_version, @thread_id, @server_capabilities, @server_charset, @server_status, @scramble_buff = args
+        @protocol_version, @server_version, @thread_id, @server_capabilities, @server_charset, @server_status, @scramble_buff, @auth_plugin = args
       end
     end
 
@@ -675,16 +676,35 @@ class Mysql
 
     # Authentication packet
     class AuthenticationPacket
-      def self.serialize(client_flags, max_packet_size, charset_number, username, scrambled_password, databasename)
-        [
+      def self.serialize(client_flags, max_packet_size, charset_number, username, scrambled_password, databasename, auth_plugin)
+        data = [
           client_flags,
           max_packet_size,
-          Packet.lcb(charset_number),
+          charset_number,
           "",                   # always 0x00 * 23
           username,
           Packet.lcs(scrambled_password),
-          databasename
-        ].pack("VVa*a23Z*A*Z*")
+        ]
+        pack = "VVCa23Z*A*"
+        if databasename
+          data.push databasename
+          pack.concat "Z*"
+        end
+        data.push auth_plugin
+        pack.concat "Z*"
+        data.pack(pack)
+      end
+    end
+
+    # TLS Authentication packet
+    class TlsAuthenticationPacket
+      def self.serialize(client_flags, max_packet_size, charset_number)
+        [
+          client_flags,
+          max_packet_size,
+          charset_number,
+          "",                   # always 0x00 * 23
+        ].pack("VVCa23")
       end
     end
 
@@ -712,6 +732,21 @@ class Mysql
       end
 
     end
+
+    class AuthenticationResultPacket
+      def self.parse(pkt)
+        result = pkt.utiny
+        auth_plugin = pkt.string
+        scramble = pkt.string
+        self.new(result, auth_plugin, scramble)
+      end
+
+      attr_reader :result, :auth_plugin, :scramble
+
+      def initialize(*args)
+        @result, @auth_plugin, @scramble = args
+      end
+    end
   end
 
   class RawRecord
@@ -732,17 +767,15 @@ class Mysql
   end
 
   class StmtRawRecord
-    # === Argument
-    # pkt     :: [Packet]
-    # fields  :: [Array of Fields]
-    # encoding:: [Encoding]
+    # @param pkt [Packet]
+    # @param fields [Array of Fields]
+    # @param encoding [Encoding]
     def initialize(packet, fields, encoding)
       @packet, @fields, @encoding = packet, fields, encoding
     end
 
     # Parse statement result packet
-    # === Return
-    # [Array of Object] one record
+    # @return [Array<Object>] one record
     def parse_record_packet
       @packet.utiny  # skip first byte
       null_bit_map = @packet.read((@fields.length+7+2)/8).unpack("b*").first
@@ -752,7 +785,7 @@ class Mysql
         else
           unsigned = f.flags & Field::UNSIGNED_FLAG != 0
           v = Protocol.net2value(@packet, f.type, unsigned)
-          if v.is_a? Numeric or v.is_a? Mysql::Time
+          if v.nil? or v.is_a? Numeric or v.is_a? Time
             v
           elsif f.type == Field::TYPE_BIT or f.charsetnr == Charset::BINARY_CHARSET_NUMBER
             Charset.to_binary(v)