283 lines
6.3 KiB
Go
283 lines
6.3 KiB
Go
// Go MySQL Driver - A MySQL-Driver for Go's database/sql package
|
|
//
|
|
// Copyright 2016 The Go-MySQL-Driver Authors. All rights reserved.
|
|
//
|
|
// This Source Code Form is subject to the terms of the Mozilla Public
|
|
// License, v. 2.0. If a copy of the MPL was not distributed with this file,
|
|
// You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
|
|
package mysql
|
|
|
|
import (
|
|
"database/sql/driver"
|
|
"errors"
|
|
"net"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
var (
|
|
errConnClosed = errors.New("connection is closed")
|
|
errConnTooManyReads = errors.New("too many reads")
|
|
errConnTooManyWrites = errors.New("too many writes")
|
|
)
|
|
|
|
// struct to mock a net.Conn for testing purposes
|
|
type mockConn struct {
|
|
laddr net.Addr
|
|
raddr net.Addr
|
|
data []byte
|
|
closed bool
|
|
read int
|
|
written int
|
|
reads int
|
|
writes int
|
|
maxReads int
|
|
maxWrites int
|
|
}
|
|
|
|
func (m *mockConn) Read(b []byte) (n int, err error) {
|
|
if m.closed {
|
|
return 0, errConnClosed
|
|
}
|
|
|
|
m.reads++
|
|
if m.maxReads > 0 && m.reads > m.maxReads {
|
|
return 0, errConnTooManyReads
|
|
}
|
|
|
|
n = copy(b, m.data)
|
|
m.read += n
|
|
m.data = m.data[n:]
|
|
return
|
|
}
|
|
func (m *mockConn) Write(b []byte) (n int, err error) {
|
|
if m.closed {
|
|
return 0, errConnClosed
|
|
}
|
|
|
|
m.writes++
|
|
if m.maxWrites > 0 && m.writes > m.maxWrites {
|
|
return 0, errConnTooManyWrites
|
|
}
|
|
|
|
n = len(b)
|
|
m.written += n
|
|
return
|
|
}
|
|
func (m *mockConn) Close() error {
|
|
m.closed = true
|
|
return nil
|
|
}
|
|
func (m *mockConn) LocalAddr() net.Addr {
|
|
return m.laddr
|
|
}
|
|
func (m *mockConn) RemoteAddr() net.Addr {
|
|
return m.raddr
|
|
}
|
|
func (m *mockConn) SetDeadline(t time.Time) error {
|
|
return nil
|
|
}
|
|
func (m *mockConn) SetReadDeadline(t time.Time) error {
|
|
return nil
|
|
}
|
|
func (m *mockConn) SetWriteDeadline(t time.Time) error {
|
|
return nil
|
|
}
|
|
|
|
// make sure mockConn implements the net.Conn interface
|
|
var _ net.Conn = new(mockConn)
|
|
|
|
func TestReadPacketSingleByte(t *testing.T) {
|
|
conn := new(mockConn)
|
|
mc := &mysqlConn{
|
|
buf: newBuffer(conn),
|
|
}
|
|
|
|
conn.data = []byte{0x01, 0x00, 0x00, 0x00, 0xff}
|
|
conn.maxReads = 1
|
|
packet, err := mc.readPacket()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(packet) != 1 {
|
|
t.Fatalf("unexpected packet lenght: expected %d, got %d", 1, len(packet))
|
|
}
|
|
if packet[0] != 0xff {
|
|
t.Fatalf("unexpected packet content: expected %x, got %x", 0xff, packet[0])
|
|
}
|
|
}
|
|
|
|
func TestReadPacketWrongSequenceID(t *testing.T) {
|
|
conn := new(mockConn)
|
|
mc := &mysqlConn{
|
|
buf: newBuffer(conn),
|
|
}
|
|
|
|
// too low sequence id
|
|
conn.data = []byte{0x01, 0x00, 0x00, 0x00, 0xff}
|
|
conn.maxReads = 1
|
|
mc.sequence = 1
|
|
_, err := mc.readPacket()
|
|
if err != ErrPktSync {
|
|
t.Errorf("expected ErrPktSync, got %v", err)
|
|
}
|
|
|
|
// reset
|
|
conn.reads = 0
|
|
mc.sequence = 0
|
|
mc.buf = newBuffer(conn)
|
|
|
|
// too high sequence id
|
|
conn.data = []byte{0x01, 0x00, 0x00, 0x42, 0xff}
|
|
_, err = mc.readPacket()
|
|
if err != ErrPktSyncMul {
|
|
t.Errorf("expected ErrPktSyncMul, got %v", err)
|
|
}
|
|
}
|
|
|
|
func TestReadPacketSplit(t *testing.T) {
|
|
conn := new(mockConn)
|
|
mc := &mysqlConn{
|
|
buf: newBuffer(conn),
|
|
}
|
|
|
|
data := make([]byte, maxPacketSize*2+4*3)
|
|
const pkt2ofs = maxPacketSize + 4
|
|
const pkt3ofs = 2 * (maxPacketSize + 4)
|
|
|
|
// case 1: payload has length maxPacketSize
|
|
data = data[:pkt2ofs+4]
|
|
|
|
// 1st packet has maxPacketSize length and sequence id 0
|
|
// ff ff ff 00 ...
|
|
data[0] = 0xff
|
|
data[1] = 0xff
|
|
data[2] = 0xff
|
|
|
|
// mark the payload start and end of 1st packet so that we can check if the
|
|
// content was correctly appended
|
|
data[4] = 0x11
|
|
data[maxPacketSize+3] = 0x22
|
|
|
|
// 2nd packet has payload length 0 and squence id 1
|
|
// 00 00 00 01
|
|
data[pkt2ofs+3] = 0x01
|
|
|
|
conn.data = data
|
|
conn.maxReads = 3
|
|
packet, err := mc.readPacket()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(packet) != maxPacketSize {
|
|
t.Fatalf("unexpected packet lenght: expected %d, got %d", maxPacketSize, len(packet))
|
|
}
|
|
if packet[0] != 0x11 {
|
|
t.Fatalf("unexpected payload start: expected %x, got %x", 0x11, packet[0])
|
|
}
|
|
if packet[maxPacketSize-1] != 0x22 {
|
|
t.Fatalf("unexpected payload end: expected %x, got %x", 0x22, packet[maxPacketSize-1])
|
|
}
|
|
|
|
// case 2: payload has length which is a multiple of maxPacketSize
|
|
data = data[:cap(data)]
|
|
|
|
// 2nd packet now has maxPacketSize length
|
|
data[pkt2ofs] = 0xff
|
|
data[pkt2ofs+1] = 0xff
|
|
data[pkt2ofs+2] = 0xff
|
|
|
|
// mark the payload start and end of the 2nd packet
|
|
data[pkt2ofs+4] = 0x33
|
|
data[pkt2ofs+maxPacketSize+3] = 0x44
|
|
|
|
// 3rd packet has payload length 0 and squence id 2
|
|
// 00 00 00 02
|
|
data[pkt3ofs+3] = 0x02
|
|
|
|
conn.data = data
|
|
conn.reads = 0
|
|
conn.maxReads = 5
|
|
mc.sequence = 0
|
|
packet, err = mc.readPacket()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(packet) != 2*maxPacketSize {
|
|
t.Fatalf("unexpected packet lenght: expected %d, got %d", 2*maxPacketSize, len(packet))
|
|
}
|
|
if packet[0] != 0x11 {
|
|
t.Fatalf("unexpected payload start: expected %x, got %x", 0x11, packet[0])
|
|
}
|
|
if packet[2*maxPacketSize-1] != 0x44 {
|
|
t.Fatalf("unexpected payload end: expected %x, got %x", 0x44, packet[2*maxPacketSize-1])
|
|
}
|
|
|
|
// case 3: payload has a length larger maxPacketSize, which is not an exact
|
|
// multiple of it
|
|
data = data[:pkt2ofs+4+42]
|
|
data[pkt2ofs] = 0x2a
|
|
data[pkt2ofs+1] = 0x00
|
|
data[pkt2ofs+2] = 0x00
|
|
data[pkt2ofs+4+41] = 0x44
|
|
|
|
conn.data = data
|
|
conn.reads = 0
|
|
conn.maxReads = 4
|
|
mc.sequence = 0
|
|
packet, err = mc.readPacket()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(packet) != maxPacketSize+42 {
|
|
t.Fatalf("unexpected packet lenght: expected %d, got %d", maxPacketSize+42, len(packet))
|
|
}
|
|
if packet[0] != 0x11 {
|
|
t.Fatalf("unexpected payload start: expected %x, got %x", 0x11, packet[0])
|
|
}
|
|
if packet[maxPacketSize+41] != 0x44 {
|
|
t.Fatalf("unexpected payload end: expected %x, got %x", 0x44, packet[maxPacketSize+41])
|
|
}
|
|
}
|
|
|
|
func TestReadPacketFail(t *testing.T) {
|
|
conn := new(mockConn)
|
|
mc := &mysqlConn{
|
|
buf: newBuffer(conn),
|
|
}
|
|
|
|
// illegal empty (stand-alone) packet
|
|
conn.data = []byte{0x00, 0x00, 0x00, 0x00}
|
|
conn.maxReads = 1
|
|
_, err := mc.readPacket()
|
|
if err != driver.ErrBadConn {
|
|
t.Errorf("expected ErrBadConn, got %v", err)
|
|
}
|
|
|
|
// reset
|
|
conn.reads = 0
|
|
mc.sequence = 0
|
|
mc.buf = newBuffer(conn)
|
|
|
|
// fail to read header
|
|
conn.closed = true
|
|
_, err = mc.readPacket()
|
|
if err != driver.ErrBadConn {
|
|
t.Errorf("expected ErrBadConn, got %v", err)
|
|
}
|
|
|
|
// reset
|
|
conn.closed = false
|
|
conn.reads = 0
|
|
mc.sequence = 0
|
|
mc.buf = newBuffer(conn)
|
|
|
|
// fail to read body
|
|
conn.maxReads = 1
|
|
_, err = mc.readPacket()
|
|
if err != driver.ErrBadConn {
|
|
t.Errorf("expected ErrBadConn, got %v", err)
|
|
}
|
|
}
|