Beispiel #1
0
// getRingSlice returns a byte slice from the ring buffer given the head
// and tail of the ring segment AND the slice indexes for head and tail.
// That is, for head's byte slice, sliceStart is the a slice start index.
// For tail's byte slice, sliceEnd is the slice end index.
func getRingSlice(head, tail *types.Ring, sliceStart, sliceEnd int) []byte {
	var overlapBytes []byte
	if sliceStart < 0 || sliceEnd < 0 {
		log.Printf("sliceStart %d sliceEnd %d", sliceStart, sliceEnd)
		panic("getRingSlice: sliceStart < 0 || sliceEnd < 0")
	}
	if sliceStart >= len(head.Reassembly.Bytes) {
		panic(fmt.Sprintf("getRingSlice: sliceStart %d >= head len %d", sliceStart, len(head.Reassembly.Bytes)))
	}
	if sliceEnd > len(tail.Reassembly.Bytes) {
		panic("getRingSlice: impossible; sliceEnd is greater than ring segment")
	}
	if head == nil || tail == nil {
		panic("getRingSlice: head or tail is nil")
	}
	if head == tail {
		panic("getRingSlice: head == tail")
	}
	overlapBytes = append(overlapBytes, head.Reassembly.Bytes[sliceStart:]...)
	current := head.Next()
	for current.Reassembly.Seq != tail.Reassembly.Seq {
		overlapBytes = append(overlapBytes, current.Reassembly.Bytes...)
		current = current.Next()
	}
	overlapBytes = append(overlapBytes, tail.Reassembly.Bytes[:sliceEnd]...)
	return overlapBytes
}
Beispiel #2
0
// getTailFromRing returns the oldest ring element that contains the beginning of
// our sequence range (start - end) and whose range of ring segments all
// have their Reassembly.Skip value set to 0 (zero).
func getTailFromRing(head *types.Ring, end types.Sequence) *types.Ring {
	var ret *types.Ring

	for r := head; r != head.Prev(); r = r.Next() {
		if r.Reassembly == nil {
			ret = r.Prev()
			break
		}
		if len(r.Reassembly.Bytes) == 0 {
			log.Print("getTailFromRing: zero payload ring segment encountered.")
			ret = r.Prev()
			break
		}
		if r.Reassembly.Skip != 0 {
			log.Print("getTailFromRing: stream skip encountered.")
			ret = r.Prev()
			break
		}
		diff := r.Reassembly.Seq.Difference(end)
		if diff < 0 {
			return r.Prev()
		}
	}

	// XXX
	// prevent bug where the above sets ret to head.Prev()
	if ret == head.Prev() {
		return nil
	} else {
		return ret
	}
	return nil
}
Beispiel #3
0
func displayRingSummary(ringHeadPtr *types.Ring) {
	log.Print("displayRingSummary:")
	i := 0
	current := ringHeadPtr.Next()
	for current != ringHeadPtr {
		if current.Reassembly != nil {
			log.Printf("index: %d TCP.Seq %d Skip %d payload len %d\n", i, current.Reassembly.Seq, current.Reassembly.Skip, len(current.Reassembly.Bytes))
		} else {
			log.Printf("index: %d nil\n", i)
		}
		current = current.Next()
		i += 1
	}
}
Beispiel #4
0
// getHeadFromRing returns a pointer to the oldest ring element that
// contains the beginning of our sequence range (start - end) AND
// whose Reassembly.Skip value is 0 (zero).
func getHeadFromRing(ringPtr *types.Ring, start, end types.Sequence) *types.Ring {
	var head *types.Ring
	current := ringPtr.Prev()
	if current.Reassembly == nil {
		return nil
	}
	if start.Difference(current.Reassembly.Seq.Add(len(current.Reassembly.Bytes)-1)) < 0 {
		log.Printf("lastestSeq %d < newStartSeq %d\n", current.Reassembly.Seq.Add(len(current.Reassembly.Bytes)-1), start)
		return nil
	}
	head = nil
	var candidate *types.Ring = nil

	for current := ringPtr.Prev(); current != ringPtr && current.Reassembly != nil; current = current.Prev() {
		if len(current.Reassembly.Bytes) == 0 {
			continue
		}

		startDiff := current.Reassembly.Seq.Difference(start)
		if startDiff == 0 {
			return current
		}
		if startDiff < 0 {
			finishEndDiff := current.Reassembly.Seq.Difference(end)
			if finishEndDiff >= 0 {
				candidate = current
			}

			continue
		} else {
			endDiff := start.Difference(current.Reassembly.Seq.Add(len(current.Reassembly.Bytes) - 1))
			if endDiff >= 0 {
				head = current
				break
			}
		}
	}
	if head == nil && candidate != nil {
		head = candidate
	}
	return head
}
Beispiel #5
0
func TestGetStartSequence(t *testing.T) {
	var start types.Sequence = 4
	var head *types.Ring = types.NewRing(10)
	head.Reassembly = &types.Reassembly{
		Seq:   3,
		Bytes: []byte{1, 2, 3, 4, 5, 6, 7},
	}
	startSeq := getStartSequence(head, start)
	if startSeq.Difference(start) != 0 {
		t.Errorf("startSeq %d != start %d\n", startSeq, start)
		t.Fail()
	}

	start = 2
	startSeq = getStartSequence(head, start)
	if startSeq != start.Add(1) {
		t.Errorf("startSeq %d != start %d\n", startSeq, start.Add(1))
		t.Fail()
	}
}