xugu_driver_go/xugu/xugu_sock_recv.go

package xugu

import (
	"bufio"
	"encoding/binary"
	"errors"
	"fmt"
	"net"
)

func xgSockRecvCommand(pConn *xuguConn) {

}

func xgSockRecvData(conn net.Conn, buffer *[]byte) (int, error) {
	// 接收服务器的返回消息
	n, err := conn.Read(*buffer)
	if err != nil {
		fmt.Println("接收服务器消息错误Error reading from server:", err)
		return 0, err
	}
	return n, nil
}

// TODO : pConn.bkChar != 0x0  这一部分代码需要修改
func rhRecv(pConn *xuguConn, buff []byte, dLen uint32) error {
	//old_len := dLen
	if pConn.bkChar != 0x0 {
		buff[0] = pConn.bkChar
		pConn.bkChar = 0x0
		//buff = buff[1:]
		dLen--
	}
	//接收加密登录信息
	if dLen != 0 {
		for dLen != 0 {
			if pConn.useSSL {
				buffer := make([]byte, 1024)
				n, err := pConn.conn.Read(buffer)
				if err != nil {
					return err
				} else {
					//xgCacheRecv(pConn, buffer, int32(n))
				}
				if n <= 0 {
					return errors.New("read error")
				}

			}
		}
		//	DECRYPT(p_conn, buff, old_len); //解密缓冲
	}
	return nil
}

// 接收单个字符
func rhRecvChar(pConn *xuguConn, valp *byte) (bool, error) {

	var ch [1]byte
	err := rhRecv(pConn, ch[:], 1)
	if err != nil {
		return false, err
	}
	fmt.Println("ch[] = ", ch[:])
	*valp = ch[0]
	return true, nil

}

//读取检查一个字符

func rhRecvStr(pConn *xuguConn, valp *[]byte) (int, error) {
	var len uint32
	if err := rhRecvInt32(pConn, &len); err != nil {
		return -4, err
	}
	pBuff := make([]byte, len+1)
	if err := rhRecv(pConn, pBuff, len); err != nil {
		return -4, err
	}
	pBuff[len] = 0x0
	*valp = pBuff
	return 0, nil
}
func rhRecvInt32(pconn *xuguConn, i *uint32) error {
	var buff [4]byte
	err := rhRecv(pconn, buff[:], 4)
	if err != nil {
		return err
	}

	// 将大端字节序转换为主机字节序
	*i = binary.BigEndian.Uint32(buff[:])

	return nil
}

// // 从连接中接收字段信息，并将其存储在 Result 结构体中。
// func recvFiledsInfo(pConn *xuguConn, pRes *Result) (int, error) {
// 	var fieldNum uint32

// 	//var pRet *FieldInfo
// 	if err := rhRecvInt32(pConn, &fieldNum); err != nil {
// 		return XG_NET_ERROR, err
// 	}
// 	if fieldNum > 4000 {
// 		return XG_NET_ERROR, errors.New("fieldNum >4000")
// 	}

// 	pRes.FieldNum = fieldNum

// 	pRet := make([]FieldInfo, fieldNum)
// 	//接收字段详细信息
// 	for n := uint32(0); n < fieldNum; n++ {
// 		if ret, err := recvAttrDesItem(pConn, &pRet[n]); err != nil {
// 			return ret, err
// 		}
// 	}

// 	bytesN := (fieldNum*2 + 7) / 8
// 	for n := uint32(0); n < fieldNum; n++ {
// 		pRet[n].Offset = bytesN
// 		bytesN += uint32(getSQLCType(pRet[n].TypeID))
// 	}
// 	// TODO : 这里需要重新修改
// 	// 在c代码中这里还加上了 ROW_HEAD_SIZE
// 	pRes.RowSize = bytesN + 24
// 	pRes.ColInfos = pRet

// 	return 0, nil
// }

// // 接收字段属性描述
// func recvAttrDesItem(pConn *xuguConn, pItem *FieldInfo) (int, error) {
// 	var nameLen uint32
// 	var tabName []byte
// 	var alias []byte

// 	if err := rhRecvInt32(pConn, &nameLen); err != nil {
// 		return XG_NET_ERROR, err
// 	}
// 	if nameLen > 1024 {
// 		return XG_NET_ERROR, errors.New("nameLen >1024")
// 	}
// 	var name []byte
// 	if err := rhRecv(pConn, name, nameLen); err != nil {
// 		return XG_NET_ERROR, err
// 	}

// 	if ret := bytes.IndexByte(name, '%'); ret != -1 {
// 		alias = name[ret+1:]
// 		name = name[:ret-1]
// 	}

// 	if ret := bytes.IndexByte(name, '.'); ret != -1 {
// 		//如果 return_schema_on 为真，那么这里将得到 schema_name.tab_name。
// 		tabName = name[:ret-1]
// 		name = name[ret+1:]
// 	}

// 	pItem.TabName = string(tabName)
// 	pItem.Name = string(name)
// 	pItem.Alias = string(alias)

// 	if err := rhRecvInt32(pConn, &pItem.TypeID); err != nil {
// 		return XG_NET_ERROR, err
// 	}
// 	if err := rhRecvInt32(pConn, &pItem.Modi); err != nil {
// 		return XG_NET_ERROR, err
// 	}
// 	if err := rhRecvInt32(pConn, &pItem.Flags); err != nil {
// 		return XG_NET_ERROR, err
// 	}

// 	pItem.CTypeID = uint32(getSQLCType(pItem.TypeID))

// 	return 0, nil
// }

func readInt32(reader *bufio.Reader) (int, error) {
	var value int32
	err := binary.Read(reader, binary.BigEndian, &value)
	return int(value), err
}

func recvParamsInfo2(pConn *xuguConn, params *XGCSParam) (int, error) {
	var paramNum uint32
	var i_ord []uint32
	var i_type []uint32
	var i_prescale []uint32
	pNames := make([][]byte, paramNum)
	rhRecvInt32(pConn, &paramNum)
	params.ParamNum = paramNum

	for n := uint32(0); n < paramNum; n++ {
		// 读取名称
		rhRecvStr(pConn, &pNames[n])
		// 读取序号
		rhRecvInt32(pConn, &i_ord[n])
		// 读取类型
		rhRecvInt32(pConn, &i_type[n])
		// 读取预缩放值
		rhRecvInt32(pConn, &i_prescale[n])
	}

	params.VParamName = pNames
	params.VParamNo = i_ord
	params.VType = i_type
	params.VParamSize = i_prescale

	return 0, nil
}

//接收结果集
//int  recv_Query_Rs(Conn_Attrs* p_conn,Result** pp_res,int*field_num,int64* rowcount,int* effected_num)
/* recv_Query_Rs :
* p_conn conn inout
* pp_res  output
 */
// func recvQueryRs(pConn *xuguConn, ppRes **Result) int {
// 	ret := 0
// 	pres := &Result{}
// 	pres_H := &Result{}
// 	for {
// 		var ch byte
// 		rhRecvChar(pConn, &ch)
// 		switch ch {
// 		case 'k':
// 			if pres_H != nil {
// 				*ppRes = pres_H
// 			} else {
// 				*ppRes = pres
// 			}
// 			return ret

// 		case 'E', 'F':
// 			var errStr []byte
// 			rhRecvStr(pConn, &errStr)
// 			fmt.Printf("[EC031]Error in recv result :%s \n", errStr)
// 			pConn.errStr = errStr
// 			ret = XG_ERROR
// 			continue

// 		case 'W', 'M':
// 			var errStr []byte
// 			rhRecvStr(pConn, &errStr)
// 			fmt.Printf("[EC032]Server Warning in recv result :%s \n", errStr)
// 			pConn.errStr = errStr
// 			ret = XG_ERROR // cyj 是否有点错误
// 		case 'I':
// 			//var len uint32
// 			// if !rhRecvInt32(pConn, &len) {

// 			// }

// 		case 'U', 'D':
// 		case 'A':
// 			if pres == nil {
// 				pres := &Result{}
// 				pres.Type = HT_RS
// 			} else {
// 				var prev = &Result{}
// 				if pres_H != nil {
// 					prev = pres_H
// 					for prev.NextResult != nil {
// 						prev = prev.NextResult
// 					}
// 				} else {
// 					pres_H = pres
// 					prev = pres_H
// 				}
// 				pres = &Result{}
// 				pres.Type = HT_RS
// 				prev.NextResult = pres
// 			}
// 			pres.SQLType = SQL_SELECT
// 			pres.DbcFlob = pConn

// 			// _, err := recvFiledsInfo(pConn, pres)
// 			// if err != nil {
// 			// 	return XG_SOCKET_ERROR,
// 			// }

// 		}

// 	}
// 	return 0
// }

// recv_record
// func recvRecords20000(p_conn *Conn_Attrs, p_res *Result) int {
// 	pRow := RhRow{}

// 	// if p_res.PBlokmemls == nil{
// 	// 	p_res.PBlokmemls =
// 	// }

// 	for i := 0; i < 20000; i++ {
// 		//recvRecord(p_conn, p_res, &pRow)
// 	}
// }

func recvRecord() {

}