xugu_sock_recv2.go 7.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306
  1. package xugu
  2. import (
  3. "bufio"
  4. "io"
  5. )
  6. // ----------------------------------------------------------------------------------------------------
  7. type SrvResponse struct {
  8. FormArgDescri []*FormArgDescri
  9. SelectResult []*SelectResult
  10. InsertResult []*InsertResult
  11. UpdateResult []*UpdateResult
  12. DeleteResult []*DeleteResult
  13. ProcRet []*ProcRet
  14. OutParamRet []*OutParamRet
  15. ErrInfo []*ErrInfo
  16. WarnInfo []*WarnInfo
  17. Message []*Message
  18. }
  19. type FormArgDescri struct {
  20. ArgNum int
  21. Args []ArgDescri
  22. }
  23. type ArgDescri struct {
  24. ArgNameLen int
  25. ArgName string
  26. ArgNo int
  27. ArgDType int
  28. ArgPreciScale int
  29. }
  30. type InsertResult struct {
  31. RowidLen int
  32. RowidData []byte
  33. }
  34. type UpdateResult struct {
  35. UpdateNum int
  36. }
  37. type DeleteResult struct {
  38. DeleteNum int
  39. }
  40. type ProcRet struct {
  41. RetDType int
  42. RetDataLen int
  43. RetData []byte
  44. }
  45. type OutParamRet struct {
  46. OutParamNo int
  47. OutParamDType int
  48. OutParamLen int
  49. OutParamData []byte
  50. }
  51. type ErrInfo struct {
  52. ErrStrLen int
  53. ErrStr string
  54. }
  55. type WarnInfo struct {
  56. WarnStrLen int
  57. WarnStr string
  58. }
  59. type Message struct {
  60. MsgStrLen int
  61. MsgStr string
  62. }
  63. // func parseResponse(conn net.Conn) (*SrvResponse, error) {
  64. // response := &SrvResponse{}
  65. // reader := bufio.NewReader(conn)
  66. // for {
  67. // msgType, err := reader.ReadByte()
  68. // if err != nil {
  69. // return nil, err
  70. // }
  71. // switch msgType {
  72. // case '$':
  73. // argDescri, err := parseFormArgDescri(reader)
  74. // if err != nil {
  75. // return nil, err
  76. // }
  77. // response.FormArgDescri = append(response.FormArgDescri, argDescri)
  78. // case 'I':
  79. // insertResult, err := parseInsertResult(reader)
  80. // if err != nil {
  81. // return nil, err
  82. // }
  83. // response.InsertResult = append(response.InsertResult, insertResult)
  84. // case 'U':
  85. // updateResult, err := parseUpdateResult(reader)
  86. // if err != nil {
  87. // return nil, err
  88. // }
  89. // response.UpdateResult = append(response.UpdateResult, updateResult)
  90. // case 'D':
  91. // deleteResult, err := parseDeleteResult(reader)
  92. // if err != nil {
  93. // return nil, err
  94. // }
  95. // response.DeleteResult = append(response.DeleteResult, deleteResult)
  96. // case 'O':
  97. // procRet, err := parseProcRet(reader)
  98. // if err != nil {
  99. // return nil, err
  100. // }
  101. // response.ProcRet = append(response.ProcRet, procRet)
  102. // case 'P':
  103. // outParamRet, err := parseOutParamRet(reader)
  104. // if err != nil {
  105. // return nil, err
  106. // }
  107. // response.OutParamRet = append(response.OutParamRet, outParamRet)
  108. // case 'E':
  109. // errInfo, err := parseErrInfo(reader)
  110. // if err != nil {
  111. // return nil, err
  112. // }
  113. // response.ErrInfo = append(response.ErrInfo, errInfo)
  114. // case 'W':
  115. // warnInfo, err := parseWarnInfo(reader)
  116. // if err != nil {
  117. // return nil, err
  118. // }
  119. // response.WarnInfo = append(response.WarnInfo, warnInfo)
  120. // case 'M':
  121. // message, err := parseMessage(reader)
  122. // if err != nil {
  123. // return nil, err
  124. // }
  125. // response.Message = append(response.Message, message)
  126. // case 'K':
  127. // return response, nil
  128. // default:
  129. // return nil, fmt.Errorf("未知的消息类型: %v", msgType)
  130. // }
  131. // }
  132. // }
  133. // 解析函数的实现,例如 parseFormArgDescri 等
  134. func parseFormArgDescri(reader *bufio.Reader) (*FormArgDescri, error) {
  135. argNum, err := readInt32(reader)
  136. if err != nil {
  137. return nil, err
  138. }
  139. formArgDescri := &FormArgDescri{ArgNum: argNum}
  140. for i := 0; i < argNum; i++ {
  141. argDescri := ArgDescri{}
  142. argDescri.ArgNameLen, err = readInt32(reader)
  143. if err != nil {
  144. return nil, err
  145. }
  146. argDescri.ArgName, err = readString(reader, argDescri.ArgNameLen)
  147. if err != nil {
  148. return nil, err
  149. }
  150. argDescri.ArgNo, err = readInt32(reader)
  151. if err != nil {
  152. return nil, err
  153. }
  154. argDescri.ArgDType, err = readInt32(reader)
  155. if err != nil {
  156. return nil, err
  157. }
  158. argDescri.ArgPreciScale, err = readInt32(reader)
  159. if err != nil {
  160. return nil, err
  161. }
  162. formArgDescri.Args = append(formArgDescri.Args, argDescri)
  163. }
  164. return formArgDescri, nil
  165. }
  166. func readString(reader *bufio.Reader, length int) (string, error) {
  167. bytes := make([]byte, length)
  168. _, err := reader.Read(bytes)
  169. return string(bytes), err
  170. }
  171. func parseFieldDescri(reader *bufio.Reader) (FieldDescri, error) {
  172. fieldDescri := FieldDescri{}
  173. var err error
  174. fieldDescri.FieldNameLen, err = readInt32(reader)
  175. if err != nil {
  176. return fieldDescri, err
  177. }
  178. fieldDescri.FieldName, err = readString(reader, fieldDescri.FieldNameLen)
  179. if err != nil {
  180. return fieldDescri, err
  181. }
  182. // fieldDescri.FieldType, err = fieldType(reader)
  183. // if err != nil {
  184. // return fieldDescri, err
  185. // }
  186. fieldDescri.FieldPreciScale, err = readInt32(reader)
  187. if err != nil {
  188. return fieldDescri, err
  189. }
  190. fieldDescri.FieldFlag, err = readInt32(reader)
  191. if err != nil {
  192. return fieldDescri, err
  193. }
  194. return fieldDescri, nil
  195. }
  196. func parseUpdateResult(reader *bufio.Reader) (*UpdateResult, error) {
  197. updateNum, err := readInt32(reader)
  198. if err != nil {
  199. return nil, err
  200. }
  201. return &UpdateResult{UpdateNum: updateNum}, nil
  202. }
  203. func parseDeleteResult(reader *bufio.Reader) (*DeleteResult, error) {
  204. deleteNum, err := readInt32(reader)
  205. if err != nil {
  206. return nil, err
  207. }
  208. return &DeleteResult{DeleteNum: deleteNum}, nil
  209. }
  210. func parseProcRet(reader *bufio.Reader) (*ProcRet, error) {
  211. retDType, err := readInt32(reader)
  212. if err != nil {
  213. return nil, err
  214. }
  215. retDataLen, err := readInt32(reader)
  216. if err != nil {
  217. return nil, err
  218. }
  219. retData := make([]byte, retDataLen)
  220. _, err = io.ReadFull(reader, retData)
  221. if err != nil {
  222. return nil, err
  223. }
  224. return &ProcRet{RetDType: retDType, RetDataLen: retDataLen, RetData: retData}, nil
  225. }
  226. func parseOutParamRet(reader *bufio.Reader) (*OutParamRet, error) {
  227. outParamNo, err := readInt32(reader)
  228. if err != nil {
  229. return nil, err
  230. }
  231. outParamDType, err := readInt32(reader)
  232. if err != nil {
  233. return nil, err
  234. }
  235. outParamLen, err := readInt32(reader)
  236. if err != nil {
  237. return nil, err
  238. }
  239. outParamData := make([]byte, outParamLen)
  240. _, err = io.ReadFull(reader, outParamData)
  241. if err != nil {
  242. return nil, err
  243. }
  244. return &OutParamRet{
  245. OutParamNo: outParamNo,
  246. OutParamDType: outParamDType,
  247. OutParamLen: outParamLen,
  248. OutParamData: outParamData,
  249. }, nil
  250. }
  251. func parseErrInfo(reader *bufio.Reader) (*ErrInfo, error) {
  252. errStrLen, err := readInt32(reader)
  253. if err != nil {
  254. return nil, err
  255. }
  256. errStr, err := readString(reader, errStrLen)
  257. if err != nil {
  258. return nil, err
  259. }
  260. return &ErrInfo{ErrStrLen: errStrLen, ErrStr: errStr}, nil
  261. }
  262. func parseWarnInfo(reader *bufio.Reader) (*WarnInfo, error) {
  263. warnStrLen, err := readInt32(reader)
  264. if err != nil {
  265. return nil, err
  266. }
  267. warnStr, err := readString(reader, warnStrLen)
  268. if err != nil {
  269. return nil, err
  270. }
  271. return &WarnInfo{WarnStrLen: warnStrLen, WarnStr: warnStr}, nil
  272. }
  273. func parseMessage(reader *bufio.Reader) (*Message, error) {
  274. msgStrLen, err := readInt32(reader)
  275. if err != nil {
  276. return nil, err
  277. }
  278. msgStr, err := readString(reader, msgStrLen)
  279. if err != nil {
  280. return nil, err
  281. }
  282. return &Message{MsgStrLen: msgStrLen, MsgStr: msgStr}, nil
  283. }