blob: 45c880d32f8fd444e41662f06697cacff72683e1 [file] [log] [blame]
Matteo Scandoloa4285862020-12-01 18:10:10 -08001/*
2 * Licensed to the Apache Software Foundation (ASF) under one
3 * or more contributor license agreements. See the NOTICE file
4 * distributed with this work for additional information
5 * regarding copyright ownership. The ASF licenses this file
6 * to you under the Apache License, Version 2.0 (the
7 * "License"); you may not use this file except in compliance
8 * with the License. You may obtain a copy of the License at
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing,
13 * software distributed under the License is distributed on an
14 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15 * KIND, either express or implied. See the License for the
16 * specific language governing permissions and limitations
17 * under the License.
18 */
19
20package thrift
21
22import (
23 "bytes"
David K. Bainbridge06631892021-08-19 13:07:00 +000024 "context"
Matteo Scandoloa4285862020-12-01 18:10:10 -080025 "encoding/binary"
26 "errors"
27 "fmt"
28 "io"
29 "math"
30)
31
32type TBinaryProtocol struct {
33 trans TRichTransport
34 origTransport TTransport
David K. Bainbridge06631892021-08-19 13:07:00 +000035 cfg *TConfiguration
Matteo Scandoloa4285862020-12-01 18:10:10 -080036 buffer [64]byte
37}
38
39type TBinaryProtocolFactory struct {
David K. Bainbridge06631892021-08-19 13:07:00 +000040 cfg *TConfiguration
Matteo Scandoloa4285862020-12-01 18:10:10 -080041}
42
David K. Bainbridge06631892021-08-19 13:07:00 +000043// Deprecated: Use NewTBinaryProtocolConf instead.
Matteo Scandoloa4285862020-12-01 18:10:10 -080044func NewTBinaryProtocolTransport(t TTransport) *TBinaryProtocol {
David K. Bainbridge06631892021-08-19 13:07:00 +000045 return NewTBinaryProtocolConf(t, &TConfiguration{
46 noPropagation: true,
47 })
Matteo Scandoloa4285862020-12-01 18:10:10 -080048}
49
David K. Bainbridge06631892021-08-19 13:07:00 +000050// Deprecated: Use NewTBinaryProtocolConf instead.
Matteo Scandoloa4285862020-12-01 18:10:10 -080051func NewTBinaryProtocol(t TTransport, strictRead, strictWrite bool) *TBinaryProtocol {
David K. Bainbridge06631892021-08-19 13:07:00 +000052 return NewTBinaryProtocolConf(t, &TConfiguration{
53 TBinaryStrictRead: &strictRead,
54 TBinaryStrictWrite: &strictWrite,
55
56 noPropagation: true,
57 })
58}
59
60func NewTBinaryProtocolConf(t TTransport, conf *TConfiguration) *TBinaryProtocol {
61 PropagateTConfiguration(t, conf)
62 p := &TBinaryProtocol{
63 origTransport: t,
64 cfg: conf,
65 }
Matteo Scandoloa4285862020-12-01 18:10:10 -080066 if et, ok := t.(TRichTransport); ok {
67 p.trans = et
68 } else {
69 p.trans = NewTRichTransport(t)
70 }
Matteo Scandoloa4285862020-12-01 18:10:10 -080071 return p
72}
73
David K. Bainbridge06631892021-08-19 13:07:00 +000074// Deprecated: Use NewTBinaryProtocolFactoryConf instead.
Matteo Scandoloa4285862020-12-01 18:10:10 -080075func NewTBinaryProtocolFactoryDefault() *TBinaryProtocolFactory {
David K. Bainbridge06631892021-08-19 13:07:00 +000076 return NewTBinaryProtocolFactoryConf(&TConfiguration{
77 noPropagation: true,
78 })
Matteo Scandoloa4285862020-12-01 18:10:10 -080079}
80
David K. Bainbridge06631892021-08-19 13:07:00 +000081// Deprecated: Use NewTBinaryProtocolFactoryConf instead.
Matteo Scandoloa4285862020-12-01 18:10:10 -080082func NewTBinaryProtocolFactory(strictRead, strictWrite bool) *TBinaryProtocolFactory {
David K. Bainbridge06631892021-08-19 13:07:00 +000083 return NewTBinaryProtocolFactoryConf(&TConfiguration{
84 TBinaryStrictRead: &strictRead,
85 TBinaryStrictWrite: &strictWrite,
86
87 noPropagation: true,
88 })
89}
90
91func NewTBinaryProtocolFactoryConf(conf *TConfiguration) *TBinaryProtocolFactory {
92 return &TBinaryProtocolFactory{
93 cfg: conf,
94 }
Matteo Scandoloa4285862020-12-01 18:10:10 -080095}
96
97func (p *TBinaryProtocolFactory) GetProtocol(t TTransport) TProtocol {
David K. Bainbridge06631892021-08-19 13:07:00 +000098 return NewTBinaryProtocolConf(t, p.cfg)
99}
100
101func (p *TBinaryProtocolFactory) SetTConfiguration(conf *TConfiguration) {
102 p.cfg = conf
Matteo Scandoloa4285862020-12-01 18:10:10 -0800103}
104
105/**
106 * Writing Methods
107 */
108
David K. Bainbridge06631892021-08-19 13:07:00 +0000109func (p *TBinaryProtocol) WriteMessageBegin(ctx context.Context, name string, typeId TMessageType, seqId int32) error {
110 if p.cfg.GetTBinaryStrictWrite() {
Matteo Scandoloa4285862020-12-01 18:10:10 -0800111 version := uint32(VERSION_1) | uint32(typeId)
David K. Bainbridge06631892021-08-19 13:07:00 +0000112 e := p.WriteI32(ctx, int32(version))
Matteo Scandoloa4285862020-12-01 18:10:10 -0800113 if e != nil {
114 return e
115 }
David K. Bainbridge06631892021-08-19 13:07:00 +0000116 e = p.WriteString(ctx, name)
Matteo Scandoloa4285862020-12-01 18:10:10 -0800117 if e != nil {
118 return e
119 }
David K. Bainbridge06631892021-08-19 13:07:00 +0000120 e = p.WriteI32(ctx, seqId)
Matteo Scandoloa4285862020-12-01 18:10:10 -0800121 return e
122 } else {
David K. Bainbridge06631892021-08-19 13:07:00 +0000123 e := p.WriteString(ctx, name)
Matteo Scandoloa4285862020-12-01 18:10:10 -0800124 if e != nil {
125 return e
126 }
David K. Bainbridge06631892021-08-19 13:07:00 +0000127 e = p.WriteByte(ctx, int8(typeId))
Matteo Scandoloa4285862020-12-01 18:10:10 -0800128 if e != nil {
129 return e
130 }
David K. Bainbridge06631892021-08-19 13:07:00 +0000131 e = p.WriteI32(ctx, seqId)
Matteo Scandoloa4285862020-12-01 18:10:10 -0800132 return e
133 }
134 return nil
135}
136
David K. Bainbridge06631892021-08-19 13:07:00 +0000137func (p *TBinaryProtocol) WriteMessageEnd(ctx context.Context) error {
Matteo Scandoloa4285862020-12-01 18:10:10 -0800138 return nil
139}
140
David K. Bainbridge06631892021-08-19 13:07:00 +0000141func (p *TBinaryProtocol) WriteStructBegin(ctx context.Context, name string) error {
Matteo Scandoloa4285862020-12-01 18:10:10 -0800142 return nil
143}
144
David K. Bainbridge06631892021-08-19 13:07:00 +0000145func (p *TBinaryProtocol) WriteStructEnd(ctx context.Context) error {
Matteo Scandoloa4285862020-12-01 18:10:10 -0800146 return nil
147}
148
David K. Bainbridge06631892021-08-19 13:07:00 +0000149func (p *TBinaryProtocol) WriteFieldBegin(ctx context.Context, name string, typeId TType, id int16) error {
150 e := p.WriteByte(ctx, int8(typeId))
Matteo Scandoloa4285862020-12-01 18:10:10 -0800151 if e != nil {
152 return e
153 }
David K. Bainbridge06631892021-08-19 13:07:00 +0000154 e = p.WriteI16(ctx, id)
Matteo Scandoloa4285862020-12-01 18:10:10 -0800155 return e
156}
157
David K. Bainbridge06631892021-08-19 13:07:00 +0000158func (p *TBinaryProtocol) WriteFieldEnd(ctx context.Context) error {
Matteo Scandoloa4285862020-12-01 18:10:10 -0800159 return nil
160}
161
David K. Bainbridge06631892021-08-19 13:07:00 +0000162func (p *TBinaryProtocol) WriteFieldStop(ctx context.Context) error {
163 e := p.WriteByte(ctx, STOP)
Matteo Scandoloa4285862020-12-01 18:10:10 -0800164 return e
165}
166
David K. Bainbridge06631892021-08-19 13:07:00 +0000167func (p *TBinaryProtocol) WriteMapBegin(ctx context.Context, keyType TType, valueType TType, size int) error {
168 e := p.WriteByte(ctx, int8(keyType))
Matteo Scandoloa4285862020-12-01 18:10:10 -0800169 if e != nil {
170 return e
171 }
David K. Bainbridge06631892021-08-19 13:07:00 +0000172 e = p.WriteByte(ctx, int8(valueType))
Matteo Scandoloa4285862020-12-01 18:10:10 -0800173 if e != nil {
174 return e
175 }
David K. Bainbridge06631892021-08-19 13:07:00 +0000176 e = p.WriteI32(ctx, int32(size))
Matteo Scandoloa4285862020-12-01 18:10:10 -0800177 return e
178}
179
David K. Bainbridge06631892021-08-19 13:07:00 +0000180func (p *TBinaryProtocol) WriteMapEnd(ctx context.Context) error {
Matteo Scandoloa4285862020-12-01 18:10:10 -0800181 return nil
182}
183
David K. Bainbridge06631892021-08-19 13:07:00 +0000184func (p *TBinaryProtocol) WriteListBegin(ctx context.Context, elemType TType, size int) error {
185 e := p.WriteByte(ctx, int8(elemType))
Matteo Scandoloa4285862020-12-01 18:10:10 -0800186 if e != nil {
187 return e
188 }
David K. Bainbridge06631892021-08-19 13:07:00 +0000189 e = p.WriteI32(ctx, int32(size))
Matteo Scandoloa4285862020-12-01 18:10:10 -0800190 return e
191}
192
David K. Bainbridge06631892021-08-19 13:07:00 +0000193func (p *TBinaryProtocol) WriteListEnd(ctx context.Context) error {
Matteo Scandoloa4285862020-12-01 18:10:10 -0800194 return nil
195}
196
David K. Bainbridge06631892021-08-19 13:07:00 +0000197func (p *TBinaryProtocol) WriteSetBegin(ctx context.Context, elemType TType, size int) error {
198 e := p.WriteByte(ctx, int8(elemType))
Matteo Scandoloa4285862020-12-01 18:10:10 -0800199 if e != nil {
200 return e
201 }
David K. Bainbridge06631892021-08-19 13:07:00 +0000202 e = p.WriteI32(ctx, int32(size))
Matteo Scandoloa4285862020-12-01 18:10:10 -0800203 return e
204}
205
David K. Bainbridge06631892021-08-19 13:07:00 +0000206func (p *TBinaryProtocol) WriteSetEnd(ctx context.Context) error {
Matteo Scandoloa4285862020-12-01 18:10:10 -0800207 return nil
208}
209
David K. Bainbridge06631892021-08-19 13:07:00 +0000210func (p *TBinaryProtocol) WriteBool(ctx context.Context, value bool) error {
Matteo Scandoloa4285862020-12-01 18:10:10 -0800211 if value {
David K. Bainbridge06631892021-08-19 13:07:00 +0000212 return p.WriteByte(ctx, 1)
Matteo Scandoloa4285862020-12-01 18:10:10 -0800213 }
David K. Bainbridge06631892021-08-19 13:07:00 +0000214 return p.WriteByte(ctx, 0)
Matteo Scandoloa4285862020-12-01 18:10:10 -0800215}
216
David K. Bainbridge06631892021-08-19 13:07:00 +0000217func (p *TBinaryProtocol) WriteByte(ctx context.Context, value int8) error {
Matteo Scandoloa4285862020-12-01 18:10:10 -0800218 e := p.trans.WriteByte(byte(value))
219 return NewTProtocolException(e)
220}
221
David K. Bainbridge06631892021-08-19 13:07:00 +0000222func (p *TBinaryProtocol) WriteI16(ctx context.Context, value int16) error {
Matteo Scandoloa4285862020-12-01 18:10:10 -0800223 v := p.buffer[0:2]
224 binary.BigEndian.PutUint16(v, uint16(value))
David K. Bainbridge06631892021-08-19 13:07:00 +0000225 _, e := p.trans.Write(v)
Matteo Scandoloa4285862020-12-01 18:10:10 -0800226 return NewTProtocolException(e)
227}
228
David K. Bainbridge06631892021-08-19 13:07:00 +0000229func (p *TBinaryProtocol) WriteI32(ctx context.Context, value int32) error {
Matteo Scandoloa4285862020-12-01 18:10:10 -0800230 v := p.buffer[0:4]
231 binary.BigEndian.PutUint32(v, uint32(value))
David K. Bainbridge06631892021-08-19 13:07:00 +0000232 _, e := p.trans.Write(v)
Matteo Scandoloa4285862020-12-01 18:10:10 -0800233 return NewTProtocolException(e)
234}
235
David K. Bainbridge06631892021-08-19 13:07:00 +0000236func (p *TBinaryProtocol) WriteI64(ctx context.Context, value int64) error {
Matteo Scandoloa4285862020-12-01 18:10:10 -0800237 v := p.buffer[0:8]
238 binary.BigEndian.PutUint64(v, uint64(value))
David K. Bainbridge06631892021-08-19 13:07:00 +0000239 _, err := p.trans.Write(v)
Matteo Scandoloa4285862020-12-01 18:10:10 -0800240 return NewTProtocolException(err)
241}
242
David K. Bainbridge06631892021-08-19 13:07:00 +0000243func (p *TBinaryProtocol) WriteDouble(ctx context.Context, value float64) error {
244 return p.WriteI64(ctx, int64(math.Float64bits(value)))
Matteo Scandoloa4285862020-12-01 18:10:10 -0800245}
246
David K. Bainbridge06631892021-08-19 13:07:00 +0000247func (p *TBinaryProtocol) WriteString(ctx context.Context, value string) error {
248 e := p.WriteI32(ctx, int32(len(value)))
Matteo Scandoloa4285862020-12-01 18:10:10 -0800249 if e != nil {
250 return e
251 }
252 _, err := p.trans.WriteString(value)
253 return NewTProtocolException(err)
254}
255
David K. Bainbridge06631892021-08-19 13:07:00 +0000256func (p *TBinaryProtocol) WriteBinary(ctx context.Context, value []byte) error {
257 e := p.WriteI32(ctx, int32(len(value)))
Matteo Scandoloa4285862020-12-01 18:10:10 -0800258 if e != nil {
259 return e
260 }
David K. Bainbridge06631892021-08-19 13:07:00 +0000261 _, err := p.trans.Write(value)
Matteo Scandoloa4285862020-12-01 18:10:10 -0800262 return NewTProtocolException(err)
263}
264
265/**
266 * Reading methods
267 */
268
David K. Bainbridge06631892021-08-19 13:07:00 +0000269func (p *TBinaryProtocol) ReadMessageBegin(ctx context.Context) (name string, typeId TMessageType, seqId int32, err error) {
270 size, e := p.ReadI32(ctx)
Matteo Scandoloa4285862020-12-01 18:10:10 -0800271 if e != nil {
272 return "", typeId, 0, NewTProtocolException(e)
273 }
274 if size < 0 {
275 typeId = TMessageType(size & 0x0ff)
276 version := int64(int64(size) & VERSION_MASK)
277 if version != VERSION_1 {
278 return name, typeId, seqId, NewTProtocolExceptionWithType(BAD_VERSION, fmt.Errorf("Bad version in ReadMessageBegin"))
279 }
David K. Bainbridge06631892021-08-19 13:07:00 +0000280 name, e = p.ReadString(ctx)
Matteo Scandoloa4285862020-12-01 18:10:10 -0800281 if e != nil {
282 return name, typeId, seqId, NewTProtocolException(e)
283 }
David K. Bainbridge06631892021-08-19 13:07:00 +0000284 seqId, e = p.ReadI32(ctx)
Matteo Scandoloa4285862020-12-01 18:10:10 -0800285 if e != nil {
286 return name, typeId, seqId, NewTProtocolException(e)
287 }
288 return name, typeId, seqId, nil
289 }
David K. Bainbridge06631892021-08-19 13:07:00 +0000290 if p.cfg.GetTBinaryStrictRead() {
Matteo Scandoloa4285862020-12-01 18:10:10 -0800291 return name, typeId, seqId, NewTProtocolExceptionWithType(BAD_VERSION, fmt.Errorf("Missing version in ReadMessageBegin"))
292 }
293 name, e2 := p.readStringBody(size)
294 if e2 != nil {
295 return name, typeId, seqId, e2
296 }
David K. Bainbridge06631892021-08-19 13:07:00 +0000297 b, e3 := p.ReadByte(ctx)
Matteo Scandoloa4285862020-12-01 18:10:10 -0800298 if e3 != nil {
299 return name, typeId, seqId, e3
300 }
301 typeId = TMessageType(b)
David K. Bainbridge06631892021-08-19 13:07:00 +0000302 seqId, e4 := p.ReadI32(ctx)
Matteo Scandoloa4285862020-12-01 18:10:10 -0800303 if e4 != nil {
304 return name, typeId, seqId, e4
305 }
306 return name, typeId, seqId, nil
307}
308
David K. Bainbridge06631892021-08-19 13:07:00 +0000309func (p *TBinaryProtocol) ReadMessageEnd(ctx context.Context) error {
Matteo Scandoloa4285862020-12-01 18:10:10 -0800310 return nil
311}
312
David K. Bainbridge06631892021-08-19 13:07:00 +0000313func (p *TBinaryProtocol) ReadStructBegin(ctx context.Context) (name string, err error) {
Matteo Scandoloa4285862020-12-01 18:10:10 -0800314 return
315}
316
David K. Bainbridge06631892021-08-19 13:07:00 +0000317func (p *TBinaryProtocol) ReadStructEnd(ctx context.Context) error {
Matteo Scandoloa4285862020-12-01 18:10:10 -0800318 return nil
319}
320
David K. Bainbridge06631892021-08-19 13:07:00 +0000321func (p *TBinaryProtocol) ReadFieldBegin(ctx context.Context) (name string, typeId TType, seqId int16, err error) {
322 t, err := p.ReadByte(ctx)
Matteo Scandoloa4285862020-12-01 18:10:10 -0800323 typeId = TType(t)
324 if err != nil {
325 return name, typeId, seqId, err
326 }
327 if t != STOP {
David K. Bainbridge06631892021-08-19 13:07:00 +0000328 seqId, err = p.ReadI16(ctx)
Matteo Scandoloa4285862020-12-01 18:10:10 -0800329 }
330 return name, typeId, seqId, err
331}
332
David K. Bainbridge06631892021-08-19 13:07:00 +0000333func (p *TBinaryProtocol) ReadFieldEnd(ctx context.Context) error {
Matteo Scandoloa4285862020-12-01 18:10:10 -0800334 return nil
335}
336
337var invalidDataLength = NewTProtocolExceptionWithType(INVALID_DATA, errors.New("Invalid data length"))
338
David K. Bainbridge06631892021-08-19 13:07:00 +0000339func (p *TBinaryProtocol) ReadMapBegin(ctx context.Context) (kType, vType TType, size int, err error) {
340 k, e := p.ReadByte(ctx)
Matteo Scandoloa4285862020-12-01 18:10:10 -0800341 if e != nil {
342 err = NewTProtocolException(e)
343 return
344 }
345 kType = TType(k)
David K. Bainbridge06631892021-08-19 13:07:00 +0000346 v, e := p.ReadByte(ctx)
Matteo Scandoloa4285862020-12-01 18:10:10 -0800347 if e != nil {
348 err = NewTProtocolException(e)
349 return
350 }
351 vType = TType(v)
David K. Bainbridge06631892021-08-19 13:07:00 +0000352 size32, e := p.ReadI32(ctx)
Matteo Scandoloa4285862020-12-01 18:10:10 -0800353 if e != nil {
354 err = NewTProtocolException(e)
355 return
356 }
357 if size32 < 0 {
358 err = invalidDataLength
359 return
360 }
361 size = int(size32)
362 return kType, vType, size, nil
363}
364
David K. Bainbridge06631892021-08-19 13:07:00 +0000365func (p *TBinaryProtocol) ReadMapEnd(ctx context.Context) error {
Matteo Scandoloa4285862020-12-01 18:10:10 -0800366 return nil
367}
368
David K. Bainbridge06631892021-08-19 13:07:00 +0000369func (p *TBinaryProtocol) ReadListBegin(ctx context.Context) (elemType TType, size int, err error) {
370 b, e := p.ReadByte(ctx)
Matteo Scandoloa4285862020-12-01 18:10:10 -0800371 if e != nil {
372 err = NewTProtocolException(e)
373 return
374 }
375 elemType = TType(b)
David K. Bainbridge06631892021-08-19 13:07:00 +0000376 size32, e := p.ReadI32(ctx)
Matteo Scandoloa4285862020-12-01 18:10:10 -0800377 if e != nil {
378 err = NewTProtocolException(e)
379 return
380 }
381 if size32 < 0 {
382 err = invalidDataLength
383 return
384 }
385 size = int(size32)
386
387 return
388}
389
David K. Bainbridge06631892021-08-19 13:07:00 +0000390func (p *TBinaryProtocol) ReadListEnd(ctx context.Context) error {
Matteo Scandoloa4285862020-12-01 18:10:10 -0800391 return nil
392}
393
David K. Bainbridge06631892021-08-19 13:07:00 +0000394func (p *TBinaryProtocol) ReadSetBegin(ctx context.Context) (elemType TType, size int, err error) {
395 b, e := p.ReadByte(ctx)
Matteo Scandoloa4285862020-12-01 18:10:10 -0800396 if e != nil {
397 err = NewTProtocolException(e)
398 return
399 }
400 elemType = TType(b)
David K. Bainbridge06631892021-08-19 13:07:00 +0000401 size32, e := p.ReadI32(ctx)
Matteo Scandoloa4285862020-12-01 18:10:10 -0800402 if e != nil {
403 err = NewTProtocolException(e)
404 return
405 }
406 if size32 < 0 {
407 err = invalidDataLength
408 return
409 }
410 size = int(size32)
411 return elemType, size, nil
412}
413
David K. Bainbridge06631892021-08-19 13:07:00 +0000414func (p *TBinaryProtocol) ReadSetEnd(ctx context.Context) error {
Matteo Scandoloa4285862020-12-01 18:10:10 -0800415 return nil
416}
417
David K. Bainbridge06631892021-08-19 13:07:00 +0000418func (p *TBinaryProtocol) ReadBool(ctx context.Context) (bool, error) {
419 b, e := p.ReadByte(ctx)
Matteo Scandoloa4285862020-12-01 18:10:10 -0800420 v := true
421 if b != 1 {
422 v = false
423 }
424 return v, e
425}
426
David K. Bainbridge06631892021-08-19 13:07:00 +0000427func (p *TBinaryProtocol) ReadByte(ctx context.Context) (int8, error) {
Matteo Scandoloa4285862020-12-01 18:10:10 -0800428 v, err := p.trans.ReadByte()
429 return int8(v), err
430}
431
David K. Bainbridge06631892021-08-19 13:07:00 +0000432func (p *TBinaryProtocol) ReadI16(ctx context.Context) (value int16, err error) {
Matteo Scandoloa4285862020-12-01 18:10:10 -0800433 buf := p.buffer[0:2]
David K. Bainbridge06631892021-08-19 13:07:00 +0000434 err = p.readAll(ctx, buf)
Matteo Scandoloa4285862020-12-01 18:10:10 -0800435 value = int16(binary.BigEndian.Uint16(buf))
436 return value, err
437}
438
David K. Bainbridge06631892021-08-19 13:07:00 +0000439func (p *TBinaryProtocol) ReadI32(ctx context.Context) (value int32, err error) {
Matteo Scandoloa4285862020-12-01 18:10:10 -0800440 buf := p.buffer[0:4]
David K. Bainbridge06631892021-08-19 13:07:00 +0000441 err = p.readAll(ctx, buf)
Matteo Scandoloa4285862020-12-01 18:10:10 -0800442 value = int32(binary.BigEndian.Uint32(buf))
443 return value, err
444}
445
David K. Bainbridge06631892021-08-19 13:07:00 +0000446func (p *TBinaryProtocol) ReadI64(ctx context.Context) (value int64, err error) {
Matteo Scandoloa4285862020-12-01 18:10:10 -0800447 buf := p.buffer[0:8]
David K. Bainbridge06631892021-08-19 13:07:00 +0000448 err = p.readAll(ctx, buf)
Matteo Scandoloa4285862020-12-01 18:10:10 -0800449 value = int64(binary.BigEndian.Uint64(buf))
450 return value, err
451}
452
David K. Bainbridge06631892021-08-19 13:07:00 +0000453func (p *TBinaryProtocol) ReadDouble(ctx context.Context) (value float64, err error) {
Matteo Scandoloa4285862020-12-01 18:10:10 -0800454 buf := p.buffer[0:8]
David K. Bainbridge06631892021-08-19 13:07:00 +0000455 err = p.readAll(ctx, buf)
Matteo Scandoloa4285862020-12-01 18:10:10 -0800456 value = math.Float64frombits(binary.BigEndian.Uint64(buf))
457 return value, err
458}
459
David K. Bainbridge06631892021-08-19 13:07:00 +0000460func (p *TBinaryProtocol) ReadString(ctx context.Context) (value string, err error) {
461 size, e := p.ReadI32(ctx)
Matteo Scandoloa4285862020-12-01 18:10:10 -0800462 if e != nil {
463 return "", e
464 }
David K. Bainbridge06631892021-08-19 13:07:00 +0000465 err = checkSizeForProtocol(size, p.cfg)
466 if err != nil {
467 return
468 }
Matteo Scandoloa4285862020-12-01 18:10:10 -0800469 if size < 0 {
470 err = invalidDataLength
471 return
472 }
David K. Bainbridge06631892021-08-19 13:07:00 +0000473 if size == 0 {
474 return "", nil
475 }
476 if size < int32(len(p.buffer)) {
477 // Avoid allocation on small reads
478 buf := p.buffer[:size]
479 read, e := io.ReadFull(p.trans, buf)
480 return string(buf[:read]), NewTProtocolException(e)
481 }
Matteo Scandoloa4285862020-12-01 18:10:10 -0800482
483 return p.readStringBody(size)
484}
485
David K. Bainbridge06631892021-08-19 13:07:00 +0000486func (p *TBinaryProtocol) ReadBinary(ctx context.Context) ([]byte, error) {
487 size, e := p.ReadI32(ctx)
Matteo Scandoloa4285862020-12-01 18:10:10 -0800488 if e != nil {
489 return nil, e
490 }
David K. Bainbridge06631892021-08-19 13:07:00 +0000491 if err := checkSizeForProtocol(size, p.cfg); err != nil {
492 return nil, err
Matteo Scandoloa4285862020-12-01 18:10:10 -0800493 }
494
David K. Bainbridge06631892021-08-19 13:07:00 +0000495 buf, err := safeReadBytes(size, p.trans)
Matteo Scandoloa4285862020-12-01 18:10:10 -0800496 return buf, NewTProtocolException(err)
497}
498
David K. Bainbridge06631892021-08-19 13:07:00 +0000499func (p *TBinaryProtocol) Flush(ctx context.Context) (err error) {
500 return NewTProtocolException(p.trans.Flush(ctx))
Matteo Scandoloa4285862020-12-01 18:10:10 -0800501}
502
David K. Bainbridge06631892021-08-19 13:07:00 +0000503func (p *TBinaryProtocol) Skip(ctx context.Context, fieldType TType) (err error) {
504 return SkipDefaultDepth(ctx, p, fieldType)
Matteo Scandoloa4285862020-12-01 18:10:10 -0800505}
506
507func (p *TBinaryProtocol) Transport() TTransport {
508 return p.origTransport
509}
510
David K. Bainbridge06631892021-08-19 13:07:00 +0000511func (p *TBinaryProtocol) readAll(ctx context.Context, buf []byte) (err error) {
512 var read int
513 _, deadlineSet := ctx.Deadline()
514 for {
515 read, err = io.ReadFull(p.trans, buf)
516 if deadlineSet && read == 0 && isTimeoutError(err) && ctx.Err() == nil {
517 // This is I/O timeout without anything read,
518 // and we still have time left, keep retrying.
519 continue
520 }
521 // For anything else, don't retry
522 break
523 }
Matteo Scandoloa4285862020-12-01 18:10:10 -0800524 return NewTProtocolException(err)
525}
526
Matteo Scandoloa4285862020-12-01 18:10:10 -0800527func (p *TBinaryProtocol) readStringBody(size int32) (value string, err error) {
David K. Bainbridge06631892021-08-19 13:07:00 +0000528 buf, err := safeReadBytes(size, p.trans)
529 return string(buf), NewTProtocolException(err)
530}
531
532func (p *TBinaryProtocol) SetTConfiguration(conf *TConfiguration) {
533 PropagateTConfiguration(p.trans, conf)
534 PropagateTConfiguration(p.origTransport, conf)
535 p.cfg = conf
536}
537
538var (
539 _ TConfigurationSetter = (*TBinaryProtocolFactory)(nil)
540 _ TConfigurationSetter = (*TBinaryProtocol)(nil)
541)
542
543// This function is shared between TBinaryProtocol and TCompactProtocol.
544//
545// It tries to read size bytes from trans, in a way that prevents large
546// allocations when size is insanely large (mostly caused by malformed message).
547func safeReadBytes(size int32, trans io.Reader) ([]byte, error) {
Matteo Scandoloa4285862020-12-01 18:10:10 -0800548 if size < 0 {
David K. Bainbridge06631892021-08-19 13:07:00 +0000549 return nil, nil
Matteo Scandoloa4285862020-12-01 18:10:10 -0800550 }
551
David K. Bainbridge06631892021-08-19 13:07:00 +0000552 buf := new(bytes.Buffer)
553 _, err := io.CopyN(buf, trans, int64(size))
554 return buf.Bytes(), err
Matteo Scandoloa4285862020-12-01 18:10:10 -0800555}