From 9de9ee9f176af04d5068104600632b2af7bc086b Mon Sep 17 00:00:00 2001 From: Justin Bastress Date: Mon, 4 Dec 2017 10:19:47 -0500 Subject: [PATCH] Remove underscores --- lib/mysql/mysql.go | 90 +++++++++++++++++++++++----------------------- 1 file changed, 45 insertions(+), 45 deletions(-) diff --git a/lib/mysql/mysql.go b/lib/mysql/mysql.go index 122eda0..949c00e 100644 --- a/lib/mysql/mysql.go +++ b/lib/mysql/mysql.go @@ -27,10 +27,10 @@ const ( // After the TCP connection is completed STATE_CONNECTED = "CONNECTED" - // After reading a Handshake_Packet with SSL capabilities, before sending the SSL_Request packet + // After reading a HandshakePacket with SSL capabilities, before sending the SSLRequest packet STATE_SSL_REQUEST = "SSL_REQUEST" - // After sending an SSL_Request packet, before peforming an SSL handshake + // After sending an SSLRequest packet, before peforming an SSL handshake STATE_SSL_HANDSHAKE = "SSL_HANDSHAKE" // After connection has been negotiated (from either CONNECTED or SSL_HANDSHAKE) @@ -142,7 +142,7 @@ type Connection struct { // The sequence number used with the server to number packets SequenceNumber uint8 // The "Handshake" packet sent by the server, holding flags used in future calls - Handshake *Handshake_Packet + Handshake *HandshakePacket // If this is true, the Connection is a TLS connection object and there should be a TLSHandshake log. IsSecure bool @@ -184,9 +184,9 @@ type PacketLogEntry struct { Parsed PacketInfo `json:"parsed,omitempty"` } -// Handshake_Packet defined at https://web.archive.org/web/20160316105725/https://dev.mysql.com/doc/internals/en/connection-phase-packets.html +// HandshakePacket defined at https://web.archive.org/web/20160316105725/https://dev.mysql.com/doc/internals/en/connection-phase-packets.html // @TODO @FIXME: This is protocol version 10; handle previous / future versions -type Handshake_Packet struct { +type HandshakePacket struct { // protocol_version: int<1> ProtocolVersion byte `json:"protocol_version"` // server_version: string @@ -222,7 +222,7 @@ type Handshake_Packet struct { CapabilityFlags uint32 `json:"capability_flags"` } -func (p *Handshake_Packet) GetDescription() string { +func (p *HandshakePacket) GetDescription() string { jsonStr, err := json.Marshal(p) if err != nil { return string(jsonStr) @@ -230,13 +230,13 @@ func (p *Handshake_Packet) GetDescription() string { return fmt.Sprintf("Error getting description: %s", err.Error()) } -func (p *Handshake_Packet) GetType() PacketType { +func (p *HandshakePacket) GetType() PacketType { return PACKET_TYPE_HANDSHAKE } -func (c *Connection) read_Handshake_Packet(body []byte) (*Handshake_Packet, error) { +func (c *Connection) readHandshakePacket(body []byte) (*HandshakePacket, error) { var rest []byte - ret := new(Handshake_Packet) + ret := new(HandshakePacket) ret.ProtocolVersion = body[0] ret.ServerVersion, rest = readNulString(body[1:]) ret.ConnectionID = binary.LittleEndian.Uint32(rest[0:4]) @@ -244,7 +244,7 @@ func (c *Connection) read_Handshake_Packet(body []byte) (*Handshake_Packet, erro ret.Filler1 = rest[12] ret.CapabilityFlags = uint32(binary.LittleEndian.Uint16(rest[13:15])) - // Unlike the ERR_Packet case, the docs explicitly say to go by the body length here + // Unlike the ERRPacket case, the docs explicitly say to go by the body length here if len(body) > 8 { ret.ShortHandshake = false ret.CharacterSet = rest[15] @@ -269,7 +269,7 @@ func (c *Connection) read_Handshake_Packet(body []byte) (*Handshake_Packet, erro return ret, nil } -type OK_Packet struct { +type OKPacket struct { // header: 0xfe or 0x00 Header byte `json:"header"` // affected_rows: int @@ -294,7 +294,7 @@ type OK_Packet struct { // } } -func (p *OK_Packet) GetDescription() string { +func (p *OKPacket) GetDescription() string { jsonStr, err := json.Marshal(p) if err != nil { return string(jsonStr) @@ -302,35 +302,35 @@ func (p *OK_Packet) GetDescription() string { return fmt.Sprintf("Error getting description: %s", err.Error()) } -func (p *OK_Packet) GetType() PacketType { +func (p *OKPacket) GetType() PacketType { return PACKET_TYPE_OK } -func (c *Connection) read_OK_Packet(body []byte) (*OK_Packet, error) { +func (c *Connection) readOKPacket(body []byte) (*OKPacket, error) { var rest []byte var err error - ret := new(OK_Packet) + ret := new(OKPacket) ret.Header = body[0] ret.AffectedRows, rest, err = readLenInt(body[1:]) if err != nil { - return nil, fmt.Errorf("Error reading OK_Packet.AffectedRows: %s", err) + return nil, fmt.Errorf("Error reading OKPacket.AffectedRows: %s", err) } ret.LastInsertId, rest, err = readLenInt(rest) if err != nil { - return nil, fmt.Errorf("Error reading OK_Packet.LastInsertId: %s", err) + return nil, fmt.Errorf("Error reading OKPacket.LastInsertId: %s", err) } flags := uint32(0) if c.Handshake != nil { flags = c.Handshake.CapabilityFlags } else { - log.Warnf("read_OK_Packet: Received OK_Packet before Handshake") + log.Warnf("readOKPacket: Received OKPacket before Handshake") } if flags&(CLIENT_PROTOCOL_41|CLIENT_TRANSACTIONS) != 0 { - log.Debugf("read_OK_Packet: CapabilityFlags = 0x%x, so reading status flags", flags) + log.Debugf("readOKPacket: CapabilityFlags = 0x%x, so reading status flags", flags) ret.StatusFlags = binary.LittleEndian.Uint16(rest[0:2]) rest = rest[2:] if flags&CLIENT_PROTOCOL_41 != 0 { - log.Debugf("read_OK_Packet: CapabilityFlags = 0x%x, so reading WarningFlags / Warnings") + log.Debugf("readOKPacket: CapabilityFlags = 0x%x, so reading WarningFlags / Warnings") ret.WarningFlags = binary.LittleEndian.Uint16(rest[0:2]) ret.Warnings = binary.LittleEndian.Uint16(rest[2:4]) rest = rest[4:] @@ -338,24 +338,24 @@ func (c *Connection) read_OK_Packet(body []byte) (*OK_Packet, error) { } ret.Info, rest, err = readLenString(rest[:]) if err != nil { - return nil, fmt.Errorf("Error reading OK_Packet.Info: %s", err) + return nil, fmt.Errorf("Error reading OKPacket.Info: %s", err) } if len(rest) > 0 { - log.Debugf("read_OK_Packet: %d bytes left after Info, reading SessionStateChanges", len(rest)) + log.Debugf("readOKPacket: %d bytes left after Info, reading SessionStateChanges", len(rest)) ret.SessionStateChanges, rest, err = readLenString(rest) if err != nil { - return nil, fmt.Errorf("Error reading OK_Packet.SessionStateChanges: %s", err) + return nil, fmt.Errorf("Error reading OKPacket.SessionStateChanges: %s", err) } } if len(rest) > 0 { - log.Debugf("read_OK_Packet: decode failure: body = %s", base64.StdEncoding.EncodeToString(body)) - return nil, fmt.Errorf("Error reading OK_Packet: %d bytes left in body (CapabilityFlags = 0x%x)", len(rest), flags) + log.Debugf("readOKPacket: decode failure: body = %s", base64.StdEncoding.EncodeToString(body)) + return nil, fmt.Errorf("Error reading OKPacket: %d bytes left in body (CapabilityFlags = 0x%x)", len(rest), flags) } return ret, nil } -// ERR_Packet defined at https://web.archive.org/web/20160316124241/https://dev.mysql.com/doc/internals/en/packet-ERR_Packet.html -type ERR_Packet struct { +// ERRPacket defined at https://web.archive.org/web/20160316124241/https://dev.mysql.com/doc/internals/en/packet-ERRPacket.html +type ERRPacket struct { // header: int<1> Header byte `json:"header"` // error_code: int<2> @@ -370,16 +370,16 @@ type ERR_Packet struct { ErrorMessage string `json:"error_message"` } -func (p *ERR_Packet) GetDescription() string { - return fmt.Sprintf("ERR_Packet: error_code = 0x%x, error_message = %s", p.ErrorCode, p.ErrorMessage) +func (p *ERRPacket) GetDescription() string { + return fmt.Sprintf("ERRPacket: error_code = 0x%x, error_message = %s", p.ErrorCode, p.ErrorMessage) } -func (p *ERR_Packet) GetType() PacketType { +func (p *ERRPacket) GetType() PacketType { return PACKET_TYPE_ERROR } -func (c *Connection) read_ERR_Packet(body []byte) (*ERR_Packet, error) { - ret := new(ERR_Packet) +func (c *Connection) readERRPacket(body []byte) (*ERRPacket, error) { + ret := new(ERRPacket) ret.Header = body[0] ret.ErrorCode = binary.LittleEndian.Uint16(body[1:3]) rest := body[3:] @@ -398,9 +398,9 @@ func (c *Connection) read_ERR_Packet(body []byte) (*ERR_Packet, error) { return ret, nil } -// SSL_Request packet type defined at https://web.archive.org/web/20160316105725/https://dev.mysql.com/doc/internals/en/connection-phase-packets.html#packet-Protocol::SSLRequest -type SSL_Request_Packet struct { - // capability_flags int<4>: Would be weird to not set CLIENT_SSL (0x0800) in your SSL_Request packet +// SSLRequest packet type defined at https://web.archive.org/web/20160316105725/https://dev.mysql.com/doc/internals/en/connection-phase-packets.html#packet-Protocol::SSLRequest +type SSLRequestPacket struct { + // capability_flags int<4>: Would be weird to not set CLIENT_SSL (0x0800) in your SSLRequest packet CapabilityFlags uint32 `json:"capability_flags"` // max_packet_size int<4> MaxPacketSize uint32 `json:"max_packet_size"` @@ -410,7 +410,7 @@ type SSL_Request_Packet struct { Reserved []byte `json:"reserved"` } -func (p *SSL_Request_Packet) EncodeBody() []byte { +func (p *SSLRequestPacket) EncodeBody() []byte { var ret [32]byte binary.LittleEndian.PutUint32(ret[0:], p.CapabilityFlags) binary.LittleEndian.PutUint32(ret[4:], p.MaxPacketSize) @@ -420,7 +420,7 @@ func (p *SSL_Request_Packet) EncodeBody() []byte { return ret[:] } -func (p *SSL_Request_Packet) GetDescription() string { +func (p *SSLRequestPacket) GetDescription() string { jsonStr, err := json.Marshal(p) if err != nil { return string(jsonStr) @@ -428,7 +428,7 @@ func (p *SSL_Request_Packet) GetDescription() string { return fmt.Sprintf("Error getting description: %s", err.Error()) } -func (p *SSL_Request_Packet) GetType() PacketType { +func (p *SSLRequestPacket) GetType() PacketType { return PACKET_TYPE_SSL_REQUEST } @@ -473,13 +473,13 @@ func (c *Connection) decodePacket(body []byte) (PacketInfo, error) { header := body[0] switch header { case 0xff: - return c.read_ERR_Packet(body) + return c.readERRPacket(body) case 0x0a: - return c.read_Handshake_Packet(body) + return c.readHandshakePacket(body) case 0x00: - return c.read_OK_Packet(body) + return c.readOKPacket(body) case 0xfe: - return c.read_OK_Packet(body) + return c.readOKPacket(body) default: return nil, fmt.Errorf("Unrecognized packet type 0x%02x", header) } @@ -569,7 +569,7 @@ func (c *Connection) Connect() error { default: return fmt.Errorf("Server returned unexpected packet type %s after connecting: %s", packet.GetType(), packet.GetDescription()) } - handshakePacket := packet.(*Handshake_Packet) + handshakePacket := packet.(*HandshakePacket) c.Handshake = handshakePacket // How to handle mismatched reserved? It will be available in the output, but should it trigger a 'failure'? @@ -578,13 +578,13 @@ func (c *Connection) Connect() error { c.IsSecure = false if (handshakePacket.CapabilityFlags & c.Config.ClientCapabilities & CLIENT_SSL) != 0 { c.State = STATE_SSL_REQUEST - sslRequest := SSL_Request_Packet{ + sslRequest := SSLRequestPacket{ CapabilityFlags: c.Config.ClientCapabilities, MaxPacketSize: c.Config.MaxPacketSize, CharacterSet: c.Config.CharSet, Reserved: c.Config.ReservedData} if c.sendPacket(&sslRequest) != nil { - return fmt.Errorf("Error sending SSL_Request packet: %s", err) + return fmt.Errorf("Error sending SSLRequest packet: %s", err) } c.State = STATE_SSL_HANDSHAKE