gr1ffon/quic-go
1
0
Fork 0
forked from quic-go/quic-go
Code Pull Requests Activity

add DataLen function to StreamFrame

Browse Source
This commit is contained in:
Marten Seemann
2016-06-01 09:23:26 +07:00
parent 981d4e7fb8
commit 2f49a9525a
7 changed files with 38 additions and 24 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
frames/stream_frame.go
View File

@@ -203,3 +203,8 @@ func (f *StreamFrame) MinLength() (protocol.ByteCount, error) {
return length + 1, nil
}
// DataLen gives the length of data in bytes
func (f *StreamFrame) DataLen() protocol.ByteCount {
return protocol.ByteCount(len(f.Data))
}

9
frames/stream_frame_test.go
View File

@@ -377,4 +377,13 @@ var _ = Describe("StreamFrame", func() {
Expect(f.getOffsetLength()).To(Equal(protocol.ByteCount(8)))
})
})
Context("DataLen", func() {
It("determines the length of the data", func() {
frame := StreamFrame{
Data: []byte("foobar"),
}
Expect(frame.DataLen()).To(Equal(protocol.ByteCount(6)))
})
})
})

4
packet_packer.go
View File

@@ -212,9 +212,9 @@ func (p *packetPacker) composeNextPacket(stopWaitingFrame *frames.StopWaitingFra
frame.DataLenPresent = true // set the dataLen by default. Remove them later if applicable
frameMinLength, _ := frame.MinLength() // StreamFrame.MinLength *never* returns an error
payloadLength += frameMinLength - 1 + protocol.ByteCount(len(frame.Data))
payloadLength += frameMinLength - 1 + frame.DataLen()
blockedFrame := p.blockedManager.GetBlockedFrame(frame.StreamID, frame.Offset+protocol.ByteCount(len(frame.Data)))
blockedFrame := p.blockedManager.GetBlockedFrame(frame.StreamID, frame.Offset+frame.DataLen())
if blockedFrame != nil {
blockedLength, _ := blockedFrame.MinLength() // BlockedFrame.MinLength *never* returns an error
if payloadLength+blockedLength <= maxFrameSize {

4
session.go
View File

@@ -242,7 +242,7 @@ func (s *Session) handlePacketImpl(remoteAddr interface{}, hdr *publicHeader, da
var err error
switch frame := ff.(type) {
case *frames.StreamFrame:
utils.Debugf("\t<- &frames.StreamFrame{StreamID: %d, FinBit: %t, Offset: 0x%x, Data length: 0x%x, Offset + Data length: 0x%x}", frame.StreamID, frame.FinBit, frame.Offset, len(frame.Data), frame.Offset+protocol.ByteCount(len(frame.Data)))
utils.Debugf("\t<- &frames.StreamFrame{StreamID: %d, FinBit: %t, Offset: 0x%x, Data length: 0x%x, Offset + Data length: 0x%x}", frame.StreamID, frame.FinBit, frame.Offset, frame.DataLen(), frame.Offset+frame.DataLen())
err = s.handleStreamFrame(frame)
// TODO: send RstStreamFrame
case *frames.AckFrame:
@@ -563,7 +563,7 @@ func (s *Session) logPacket(packet *packedPacket) {
utils.Debugf("-> Sending packet 0x%x (%d bytes)", packet.number, len(packet.raw))
for _, frame := range packet.frames {
if streamFrame, isStreamFrame := frame.(*frames.StreamFrame); isStreamFrame {
utils.Debugf("\t-> &frames.StreamFrame{StreamID: %d, FinBit: %t, Offset: 0x%x, Data length: 0x%x, Offset + Data length: 0x%x}", streamFrame.StreamID, streamFrame.FinBit, streamFrame.Offset, len(streamFrame.Data), streamFrame.Offset+protocol.ByteCount(len(streamFrame.Data)))
utils.Debugf("\t-> &frames.StreamFrame{StreamID: %d, FinBit: %t, Offset: 0x%x, Data length: 0x%x, Offset + Data length: 0x%x}", streamFrame.StreamID, streamFrame.FinBit, streamFrame.Offset, streamFrame.DataLen(), streamFrame.Offset+streamFrame.DataLen())
} else {
utils.Debugf("\t-> %#v", frame)
}

8
stream.go
View File

@@ -99,7 +99,7 @@ func (s *stream) Read(p []byte) (int, error) {
}
if frame != nil {
// Pop and continue if the frame doesn't have any new data
if frame.Offset+protocol.ByteCount(len(frame.Data)) <= s.readOffset && !frame.FinBit {
if frame.Offset+frame.DataLen() <= s.readOffset && !frame.FinBit {
s.frameQueue.Pop()
frame = s.frameQueue.Head()
continue
@@ -123,7 +123,7 @@ func (s *stream) Read(p []byte) (int, error) {
return bytesRead, s.err
}
m := utils.Min(len(p)-bytesRead, len(frame.Data)-s.readPosInFrame)
m := utils.Min(len(p)-bytesRead, int(frame.DataLen())-s.readPosInFrame)
copy(p[bytesRead:], frame.Data[s.readPosInFrame:])
s.readPosInFrame += m
@@ -137,7 +137,7 @@ func (s *stream) Read(p []byte) (int, error) {
s.maybeTriggerWindowUpdate()
if s.readPosInFrame >= len(frame.Data) {
if s.readPosInFrame >= int(frame.DataLen()) {
fin := frame.FinBit
s.mutex.Lock()
s.frameQueue.Pop()
@@ -240,7 +240,7 @@ func (s *stream) Close() error {
// AddStreamFrame adds a new stream frame
func (s *stream) AddStreamFrame(frame *frames.StreamFrame) error {
maxOffset := frame.Offset + protocol.ByteCount(len(frame.Data))
maxOffset := frame.Offset + frame.DataLen()
increment := s.flowController.UpdateHighestReceived(maxOffset)
if s.contributesToConnectionFlowControl {
s.connectionFlowController.IncrementHighestReceived(increment)

8
stream_frame_queue.go
View File

@@ -46,7 +46,7 @@ func (q *streamFrameQueue) Push(frame *frames.StreamFrame, prio bool) {
}
}
q.byteLen += protocol.ByteCount(len(frame.Data))
q.byteLen += frame.DataLen()
q.len++
}
@@ -99,7 +99,7 @@ func (q *streamFrameQueue) Pop(maxLength protocol.ByteCount) (*frames.StreamFram
splitFrame := q.maybeSplitOffFrame(frame, maxLength)
if splitFrame != nil { // StreamFrame was split
q.byteLen -= protocol.ByteCount(len(splitFrame.Data))
q.byteLen -= splitFrame.DataLen()
return splitFrame, nil
}
@@ -110,7 +110,7 @@ func (q *streamFrameQueue) Pop(maxLength protocol.ByteCount) (*frames.StreamFram
q.frameMap[streamID] = q.frameMap[streamID][1:]
}
q.byteLen -= protocol.ByteCount(len(frame.Data))
q.byteLen -= frame.DataLen()
q.len--
return frame, nil
}
@@ -144,7 +144,7 @@ func (q *streamFrameQueue) getNextStream() (protocol.StreamID, error) {
// has to be called from a function that has already acquired the mutex
func (q *streamFrameQueue) maybeSplitOffFrame(frame *frames.StreamFrame, n protocol.ByteCount) *frames.StreamFrame {
minLength, _ := frame.MinLength() // StreamFrame.MinLength *never* errors
if n >= minLength-1+protocol.ByteCount(len(frame.Data)) {
if n >= minLength-1+frame.DataLen() {
return nil
}
n -= minLength - 1

24
stream_frame_queue_test.go
View File

@@ -76,15 +76,15 @@ var _ = Describe("streamFrameQueue", func() {
queue.Push(prioFrame1, true)
Expect(queue.ByteLen()).To(Equal(protocol.ByteCount(2)))
queue.Push(frame2, false)
Expect(queue.ByteLen()).To(Equal(protocol.ByteCount(len(prioFrame1.Data) + len(frame2.Data))))
Expect(queue.ByteLen()).To(Equal(prioFrame1.DataLen() + frame2.DataLen()))
})
It("returns the correct byte length when popping", func() {
queue.Push(prioFrame1, true)
queue.Push(frame1, false)
Expect(queue.ByteLen()).To(Equal(protocol.ByteCount(len(prioFrame1.Data) + len(frame1.Data))))
Expect(queue.ByteLen()).To(Equal(prioFrame1.DataLen() + frame1.DataLen()))
queue.Pop(1000)
Expect(queue.ByteLen()).To(Equal(protocol.ByteCount(len(frame1.Data))))
Expect(queue.ByteLen()).To(Equal(frame1.DataLen()))
queue.Pop(1000)
Expect(queue.ByteLen()).To(Equal(protocol.ByteCount(0)))
})
@@ -117,7 +117,7 @@ var _ = Describe("streamFrameQueue", func() {
It("does not change the byte length when using getNextStream()", func() {
queue.Push(prioFrame1, true)
queue.Push(frame1, false)
length := protocol.ByteCount(len(prioFrame1.Data) + len(frame1.Data))
length := prioFrame1.DataLen() + frame1.DataLen()
Expect(queue.ByteLen()).To(Equal(length))
_, err := queue.getNextStream()
Expect(err).ToNot(HaveOccurred())
@@ -275,13 +275,13 @@ var _ = Describe("streamFrameQueue", func() {
It("splits a frame", func() {
queue.Push(frame1, false)
origlen := len(frame1.Data)
origlen := frame1.DataLen()
frame, err := queue.Pop(6)
Expect(err).ToNot(HaveOccurred())
minLength, _ := frame.MinLength()
Expect(int(minLength) - 1 + len(frame.Data)).To(Equal(6))
Expect(queue.frameMap[frame1.StreamID][0].Data).To(HaveLen(origlen - len(frame.Data)))
Expect(queue.frameMap[frame1.StreamID][0].Offset).To(Equal(protocol.ByteCount(len(frame.Data))))
Expect(minLength - 1 + frame.DataLen()).To(Equal(protocol.ByteCount(6)))
Expect(queue.frameMap[frame1.StreamID][0].Data).To(HaveLen(int(origlen - frame.DataLen())))
Expect(queue.frameMap[frame1.StreamID][0].Offset).To(Equal(frame.DataLen()))
})
It("only removes a frame from the queue after return all split parts", func() {
@@ -298,7 +298,7 @@ var _ = Describe("streamFrameQueue", func() {
})
It("gets the whole data of a frame, when it was split", func() {
length := len(frame1.Data)
length := frame1.DataLen()
origdata := make([]byte, length)
copy(origdata, frame1.Data)
queue.Push(frame1, false)
@@ -306,10 +306,10 @@ var _ = Describe("streamFrameQueue", func() {
Expect(err).ToNot(HaveOccurred())
nextframe, err := queue.Pop(1000)
Expect(err).ToNot(HaveOccurred())
Expect(len(frame.Data) + len(nextframe.Data)).To(Equal(length))
Expect(frame.DataLen() + nextframe.DataLen()).To(Equal(length))
data := make([]byte, length)
copy(data, frame.Data)
copy(data[len(frame.Data):], nextframe.Data)
copy(data[int(frame.DataLen()):], nextframe.Data)
Expect(data).To(Equal(origdata))
})
@@ -320,7 +320,7 @@ var _ = Describe("streamFrameQueue", func() {
frame, err := queue.Pop(6)
Expect(err).ToNot(HaveOccurred())
Expect(frame.StreamID).To(Equal(frame1.StreamID)) // make sure the right frame was popped
Expect(queue.ByteLen()).To(Equal(startByteLength - protocol.ByteCount(len(frame.Data))))
Expect(queue.ByteLen()).To(Equal(startByteLength - frame.DataLen()))
})
It("does not change the length of the queue when returning a split frame", func() {