mirror of
https://github.com/buger/goreplay.git
synced 2024-04-21 12:32:02 +00:00
Urban IshimweandGitHub
fdc8b094f0
### performance - handling of the very big packet(any size that can be buffered) - speeding up TCP sessions by using message hints: Added **proto.HasFullPayload** that helps to validate the entire HTTP request, it supports `Chunked` encoding too! Added **proto.HasRequestTitle** and **proto.HasResponseTitle** for validating the beginning of HTTP request. Those methods are used `input_raw.go` with `TCP`. - supports Keep-Alive: the above functions helps to support keep-alive ### Packaging - **capture:** engines(capture/doc.go) - **tcp:** tcp message parser (tcp/doc.go) ### benchmarking - **capture.BenchmarkPcapDump:** the benchmarks regarding dumping packets in a pcap file - **capture.BenchmarkPcapFile:** the benchmarks of reading packets from a pcap file - **capture.BenchmarkPcap:** the benchmarks of parsing packets from the loopback interface with pcap handles - **proto.BenchmarkHasFullPayload:**: benchmarking this function which validates the HTTP payload - **tcp.BenchmarkPacketParseAndSort:** benchmarks of parsing and sorting packets - **tcp.BenchmarkMessageParserWithoutHint:** benchmarks of message reasembling by using `SYN` and `FIN` flag - **tcp.BenchmarkMessageParserWithHint:** benchmarks of message reasembling by using `proto.HasRequestTitle` and `proto.HasFullPayload` flag ### issues see linked issues ### tests - fixed input raw and engine tests **Most of the changed of the files, was about using functionalities of** `tcp` **and** `capture` **in existing functionalities**
57 lines
1.2 KiB
Go
57 lines
1.2 KiB
Go
// Package byteutils provides helpers for working with byte slices
|
|
package byteutils
|
|
|
|
import (
|
|
"reflect"
|
|
"unsafe"
|
|
)
|
|
|
|
// Cut elements from slice for a given range
|
|
func Cut(a []byte, from, to int) []byte {
|
|
copy(a[from:], a[to:])
|
|
a = a[:len(a)-to+from]
|
|
|
|
return a
|
|
}
|
|
|
|
// Insert new slice at specified position
|
|
func Insert(a []byte, i int, b []byte) []byte {
|
|
a = append(a, make([]byte, len(b))...)
|
|
copy(a[i+len(b):], a[i:])
|
|
copy(a[i:i+len(b)], b)
|
|
|
|
return a
|
|
}
|
|
|
|
// Replace function unlike bytes.Replace allows you to specify range
|
|
func Replace(a []byte, from, to int, new []byte) []byte {
|
|
lenDiff := len(new) - (to - from)
|
|
|
|
if lenDiff > 0 {
|
|
// Extend if new segment bigger
|
|
a = append(a, make([]byte, lenDiff)...)
|
|
copy(a[to+lenDiff:], a[to:])
|
|
copy(a[from:from+len(new)], new)
|
|
|
|
return a
|
|
}
|
|
|
|
if lenDiff < 0 {
|
|
copy(a[from:], new)
|
|
copy(a[from+len(new):], a[to:])
|
|
return a[:len(a)+lenDiff]
|
|
}
|
|
|
|
// same size
|
|
copy(a[from:], new)
|
|
return a
|
|
}
|
|
|
|
// SliceToString preferred for large body payload (zero allocation and faster)
|
|
func SliceToString(buf *[]byte, s *string) {
|
|
bHeader := (*reflect.SliceHeader)(unsafe.Pointer(buf))
|
|
sHeader := (*reflect.StringHeader)(unsafe.Pointer(s))
|
|
sHeader.Data = bHeader.Data
|
|
sHeader.Len = bHeader.Len
|
|
}
|