基础知识

MySQL数据类型

定长整型

MySQL整型有1，2，4，6，8字节长度，使用小字节序传输。以4字节长度为例说明打包和解包过程：

解包过程:

/**
 * @param buff 解包的字节流
 * @param cursor 当前解析位置指针
 * @return （int，uint32）= （解析后位置，读到的整型值）
 */
func ReadUB4(buff []byte, cursor int) (int, uint32) {
    i := uint32(buff[cursor])
    i |= uint32(buff[cursor + 1]) << 8
    i |= uint32(buff[cursor + 2]) << 16
    i |= uint32(buff[cursor + 3]) << 24
    return cursor + 4, i
}

打包过程:

/**
 * @param buff 当前字节流
 * @param i 整型
 * @return 打包后的字节流
 */
func WriteUB4(buf []byte, i uint32) []byte {
    buf = append(buf, byte(i & 0xFF))
    buf = append(buf, byte((i >> 8) & 0xFF))
    buf = append(buf, byte((i >> 16) & 0xFF))
    buf = append(buf, byte((i >> 24) & 0xFF))
    return buf
}

不定长整型

数据长度不固定，长度值由数据前的1-9个字节决定，其中长度值所占的字节数不定，字节数由第1个字节决定，如下表：

第一个字节	后续字节数	长度值说明
0-250	0	第一个字节值即为数据的真实长度
251	0	空数据，数据的真实长度为零
252	2	后续额外2个字节标识了数据的真实长度
253	3	后续额外3个字节标识了数据的真实长度
254	8	后续额外8个字节标识了数据的真实长度

解包过程：

func ReadLength(buff []byte, cursor int) (int, uint64) {
    length := buff[cursor]
    cursor++
    switch length {
    case 251:
        return cursor, 0
    case 252:
        cursor, u16 := ReadUB2(buff, cursor)
        return cursor, uint64(u16)
    case 253:
        cursor, u24 := ReadUB3(buff, cursor)
        return cursor, uint64(u24)
    case 254:
        cursor, u64 := ReadUB8(buff, cursor)
        return cursor, u64
    default:
        return cursor, uint64(length)

    }
}

打包过程：

func WriteLength(buf []byte, length int64) []byte {
    if length <= 251 {
        buf = WriteByte(buf, byte(length))
    } else if length < 0x10000 {
        buf = WriteByte(buf,252)
        buf = WriteUB2(buf, uint16(length))
    } else if length < 0x1000000 {
        buf = WriteByte(buf,253)
        buf = WriteUB3(buf, uint32(length))
    } else {
        buf = WriteByte(buf,254)
        buf = WriteUB8(buf, uint64(length))
    }
    return buf
}

字符串

字符串有两种，一种是以\0结尾的字符串，一种是被称为Length Coded String

以\0结尾的字符串

解包过程：

func ReadWithNull(buff []byte, cursor int) (int, []byte) {
    ret := []byte{}
    for ; ;  {
        if buff[cursor] != 0 {
            ret = append(ret, buff[cursor])
            cursor++
        } else {
            cursor++
            break
        }
    }
    return cursor, ret
}

打包过程：

func WriteWithNull(buf []byte, from []byte) []byte {
    buf = WriteBytes(buf, from)
    buf = append(buf, byte(0))
    return buf
}

Length Coded String

通俗的说，这种string有两部分组成，string头，string体，string头标注了string体的长度，string头采用不定长整型编码。

打包过程：

func WriteWithLength(buf []byte, from []byte) []byte {
    length := len(from)
    buf = WriteLength(buf, int64(length))
    buf = WriteBytes(buf, from)
    return buf
}

解包过程：

func ReadLengthString(buff []byte, cursor int) (int, string) {
    cursor, strLen := ReadLength(buff, cursor)
    cursor, tmp := ReadBytes(buff, cursor, int(strLen))
    return cursor, string(tmp)
}

包基本格式

一个Packet含了，两部分：

• 包头 包含3个字节的包体长度，一个字节的包序
• 包体 长度在包头指定

具体格式如下：

包体长度(3字节)	包序（1字节）	包体（长度不定）

包体长度和包序组成了PacketHead，包体为PacketBody

和MySQL通讯（以发送SHOW TABLES查询为例）

注意：下面的实例中没有包头，是因为包头在socket发送或者接受数据的时候已经加上或者去掉

建立socket连接后，MySQL返回HandsharkProtocol 握手协议

当我们使用socket和mysql建立通讯后，mysql第一步就会发送这个协议给客户端

type HandsharkProtocol struct {
    ProtocolVersion                 byte
    ServerVersion                   string
    ServerThreadID                  uint32
    Seed                            []byte
    ServerCapabilitiesLow       uint16
    CharSet                         byte
    ServerStatus                    uint16
    ServerCapabilitiesHeight   uint16
    RestOfScrambleBuff          []byte
    Auth_plugin_name            string
}

具体协议格式如下：
[图片上传失败...(image-9e5aec-1517473706232)]

解包过程如下：

func DecodeHandshark(buff []byte) HandsharkProtocol {
    var cursor int
    var tmp []byte
    hs := new(HandsharkProtocol)

    cursor, hs.ProtocolVersion = util.ReadByte(buff, cursor)
    cursor, tmp = util.ReadWithNull(buff, cursor)
    hs.ServerVersion = string(tmp)
    cursor, hs.ServerThreadID = util.ReadUB4(buff, cursor)
    cursor, hs.Seed = util.ReadWithNull(buff, cursor)
    cursor, hs.ServerCapabilitiesLow = util.ReadUB2(buff, cursor)
    cursor, hs.CharSet = util.ReadByte(buff, cursor)
    cursor, hs.ServerStatus = util.ReadUB2(buff, cursor)
    cursor, hs.ServerCapabilitiesHeight = util.ReadUB2(buff, cursor)
    cursor, _ = util.ReadBytes(buff, cursor, 11)
    cursor, hs.RestOfScrambleBuff = util.ReadWithNull(buff, cursor)
    cursor, tmp = util.ReadWithNull(buff, cursor)
    hs.Auth_plugin_name = string(tmp)

    fmt.Printf("DecodeHanshark: %+v\n", hs)

    return *hs
}

客户端发送AuthProtocol 登录验证协议

客户端收到HandsharkProtocol后，就可以发送AuthProtocol给服务端了，协议定义如下：

[图片上传失败...(image-361c5c-1517473706232)]

打包过程如下：

func EncodeLogin(hs HandsharkProtocol, uname string, password string, dbname string) []byte {
    buf := []byte{}

    capabilities := GetCapabilities(hs)
    capabilities |= common.CLIENT_CONNECT_WITH_DB

    buf = util.WriteUB4(buf, capabilities)
    buf = util.WriteUB4(buf, 1024 * 1024 * 16)
    buf = util.WriteByte(buf, hs.CharSet)
    for i := 0; i < 23 ; i++  {
        buf = append(buf, 0)
    }
    if len(uname) == 0 {
        buf = append(buf, 0)
    } else {
        buf = util.WriteWithNull(buf, []byte(uname))
    }

    encryPass := util.GetPassword([]byte(password), hs.Seed, hs.RestOfScrambleBuff)
    if (capabilities & common.CLIENT_SECURE_CONNECTION) > 0 {
        buf = util.WriteWithLength(buf, encryPass)
    } else {
        buf = util.WriteBytes(buf, encryPass)
        buf = util.WriteByte(buf, 0)
    }

    buf = util.WriteWithNull(buf, []byte(dbname))
    buf = util.WriteWithNull(buf, []byte(hs.Auth_plugin_name))

    return buf
}

里面password的计算方式我们特殊说一下：

伪代码为：

stage1_hash = SHA1(password), using the password that the user has entered.
token = SHA1(SHA1(stage1_hash), scramble) XOR stage1_hash

go代码为：

func GetPassword(pass []byte, seed []byte, restOfScrambleBuff []byte) []byte {
    salt := []byte{}
    for _,v := range seed {
        salt = append(salt, v)
    }
    for _,v := range restOfScrambleBuff {
        salt = append(salt, v)
    }

    sh := sha1.New()
    sh.Write(pass)
    stage1_hash := sh.Sum(nil)


    sh.Reset()
    sh.Write(stage1_hash)
    stage2_hash := sh.Sum(nil)

    sh.Reset()
    for _, v := range stage2_hash {
        salt = append(salt, v)
    }
    sh.Write(salt)

    stage3_hash := sh.Sum(nil)

    ret := []byte{}
    for k,_ := range stage3_hash  {
        ret = append(ret, stage1_hash[k] ^ stage3_hash[k])
    }
    return ret
}

登录成功后，客户端会收到OkPacket 成功协议

字节	说明
1	OK报文，值恒为0x00
1-9	受影响行数（Length Coded Binary）
1-9	索引ID值（Length Coded Binary）
2	服务器状态
2	告警计数
n	服务器消息（字符串到达消息尾部时结束，无结束符，可选）

解包代码为：

func DecodeOk(buff []byte) OK {
    var cursor int
    ok := new(OK)
    cursor, ok.PacketType   = util.ReadByte(buff, 0)
    cursor, ok.AffectedRows = util.ReadLength(buff, cursor)
    cursor, ok.InsertID     = util.ReadLength(buff, cursor)
    cursor, ok.ServerStatus = util.ReadUB2(buff, cursor)
    cursor, ok.WarningNum   = util.ReadUB2(buff, cursor)
    return *ok
}

恭喜，到了这一步就成功了80%

到了这一步，我们完成mysql的验证，并且完成了大部分的util函数，剩下的工作就变得简单有趣。
MySQL Client发送给MySQL Server的命令都是统一格式的（注意哈，这里特指PacketBody是统一格式的）

格式如下：

命令(1字节)	参数（长度不定，具体长度可以有PacketHead.BodySize - 1确定）

我们简单列举几个命令：

类型值	命令	功能
0x02	COM_INIT_DB	切换数据库
0x03	COM_QUERY	查询SQL
0x05	COM_CREATE_DB	创建数据库
0x06	COM_DROP_DB	删除数据库

还有很多很多很多。。自己需要的话不妨看一下MySQL Document, 或者百度，谷歌一下也能解决问题

发送COM_QUERY命令

这个命令如此简单，以至于我们只要发送下面的字符串就好了：

0x03 "SHOW TABLES".toBytes()

代码如下：

func EncodeQuery(sql string) []byte {
    buff := []byte{}
    buff = append(buff, 0x03)
    for _,v := range []byte(sql)  {
        buff = append(buff, v)
    }
    buff = append(buff, 0)
    return buff
}

发送COM_QUERY命令后，MySQL返回ResultSet包

包格式如下：

结构	说明
Result Set Header	1字节，列数量，采用不定长整型编码
Field	列信息（多个）
EOF	列结束
Row Data	行数据（多个）
EOF	数据结束

Field结构

字节	说明
n	目录名称（Length Coded String）
n	数据库名称（Length Coded String）
n	数据表名称（Length Coded String）
n	数据表原始名称（Length Coded String）
n	列（字段）名称（Length Coded String）
4	列（字段）原始名称（Length Coded String）
1	填充值
2	字符编码
4	列（字段）长度
1	列（字段）类型
2	列（字段）标志
1	整型值精度
2	填充值（0x00）
n	默认值（Length Coded String）

RowData结构

在Result Set消息中，会包含多个Row Data结构，每个Row Data结构又包含多个字段值，这些字段值组成一行数据。

字节	说明
n	字段值（Length Coded String）
...	（一行数据中包含多个字段值）

字段值：行数据中的字段值，字符串形式

解包过程

整体解包

func DecodeResultSet(conn net.Conn) ResultSet {
    var body []byte
    var resultSet ResultSet
    resultSet.Fields = make([]Field, 0)
    resultSet.Data = make([]RowData, 0)

    //reset header
    _, _, body = socket.ReadPacket(conn)
    _, resultSet.RowNum = util.ReadLength(body, 0)

    //fields
    _, _, body = socket.ReadPacket(conn)
    for ; ; {
        if body[0] == 0xFE {
            break
        }
        resultSet.Fields = append(resultSet.Fields, DecodeField(body))
        _, _, body = socket.ReadPacket(conn)
    }

    //rowdata
    _, _, body = socket.ReadPacket(conn)
    for ; ;  {
        if body[0] == 0xFE {
            break
        }
        resultSet.Data = append(resultSet.Data, DecodeRowData(body))
        _, _, body = socket.ReadPacket(conn)
    }
    return resultSet
}

解Field包

func DecodeField(buf []byte) Field {
    f := new(Field)
    cursor, tmp := util.ReadLengthString(buf, 0)
    f.DirName = string(tmp)
    cursor, tmp = util.ReadLengthString(buf, cursor)
    f.DatabaseName = string(tmp)
    cursor, tmp = util.ReadLengthString(buf, cursor)
    f.TableName = string(tmp)
    cursor, tmp = util.ReadLengthString(buf, cursor)
    f.TablePreName = string(tmp)
    cursor, tmp = util.ReadLengthString(buf, cursor)
    f.ColumnName = string(tmp)
    cursor, tmp = util.ReadLengthString(buf, cursor)
    f.ColumnPreName = string(tmp)
    cursor, _ = util.ReadByte(buf, cursor)
    cursor, f.CharSet = util.ReadUB2(buf, cursor)
    cursor, f.ColumnLength = util.ReadUB4(buf, cursor)
    cursor, f.ColumnType = util.ReadByte(buf, cursor)
    cursor, f.ColumnSign = util.ReadUB2(buf, cursor)
    cursor, f.IntDegree = util.ReadByte(buf, cursor)
    cursor, _ = util.ReadUB2(buf, cursor)
    if cursor < len(buf) {
        cursor, f.DefaultValue = util.ReadLengthString(buf, cursor)
    }
    return *f
}

解RowData

func DecodeRowData(buf []byte) RowData {
    var c int = 0
    var s string
    var rowData RowData

    rowData.Data = make([]string, 0)
    for ; ;  {
        if c >= len(buf) {
            break
        }
        c, s = util.ReadLengthString(buf, c)
        rowData.Data = append(rowData.Data, s)
    }
    return rowData
}

至此，我们发送给MySQL Server的命令show tables执行完成。

我的文档也讲完了。。。

不足之处，请大家谅解。

谢谢