diff --git a/ipv4/frame.go b/ipv4/frame.go index 3cf13f2..a90f1e9 100644 --- a/ipv4/frame.go +++ b/ipv4/frame.go @@ -127,7 +127,13 @@ func (ifrm Frame) SetCRC(cs uint16) { binary.BigEndian.PutUint16(ifrm.buf[10:12], cs) } -// CalculateHeaderCRC calculates the CRC for this IPv4 frame. +// CalculateHeaderCRC calculates the CRC for this IPv4 frame including CRC field. +// If the result of this function is 0 then the CRC is valid for the frame. +// To calculate the CRC for a frame set the CRC field to zero and then call this function: +// +// ifrm.SetCRC(0) +// crcValue := ifrm.CalculateHeaderCRC() +// ifrm.SetCRC(crcValue) func (ifrm Frame) CalculateHeaderCRC() uint16 { var crc lneto.CRC791 ifrm.CRCWriteHeader(&crc) @@ -138,6 +144,12 @@ func (ifrm Frame) CRCWriteHeader(crc *lneto.CRC791) { crc.WriteEven(ifrm.buf[:20]) } +// CRCWriteTCPPseudo is used to calculate the TCP checksum for IPv4 framed packets. +// To calculate the CRC of a TCP frame: +// +// ifrm.CRCWriteTCPPseudo(&crc) +// // tfrm.SetCRC(0) // Zero if calculating frame for sending out. +// crcValue := crc.PayloadSum16(ifrm.Payload()) // If validating a received frame crcValue should be zero here. func (ifrm Frame) CRCWriteTCPPseudo(crc *lneto.CRC791) { crc.WriteEven(ifrm.sourceAndDestinationAddr()) crc.AddUint16(ifrm.TotalLength() - uint16(ifrm.HeaderLength())) diff --git a/tcp/conn.go b/tcp/conn.go index 06f0798..6ae16e6 100644 --- a/tcp/conn.go +++ b/tcp/conn.go @@ -386,6 +386,7 @@ func (conn *Conn) Encapsulate(carrierData []byte, offsetToIP, offsetToFrame int) // RFC 6298 §5.1: check RTO before sending new data. if conn.h.ShouldRetransmit() { conn.h.triggerRetransmit() + conn.h.dupACKs = 0 // RTO is a new loss event; reset dup-ACK counter. } n, err = conn.h.Send(carrierData[offsetToFrame:]) if err != nil || n == 0 { diff --git a/tcp/control.go b/tcp/control.go index 1830660..5a6cc9c 100644 --- a/tcp/control.go +++ b/tcp/control.go @@ -438,7 +438,8 @@ func (tcb *ControlBlock) validateIncomingSegment(seg Segment) (err error) { // Short circuit SEQ checks if SYN present in pre-established states only. // In synchronized states SYN must pass normal SEQ validation (RFC 9293 §3.10.7.4). preestablished := tcb._state.IsPreestablished() - checkSEQ := !flags.HasAny(FlagSYN) || !preestablished + // LISTEN has no receive window context; RFC 9293 §3.10.7.1 step 1: "no checking in LISTEN state." + checkSEQ := (!flags.HasAny(FlagSYN) || !preestablished) && tcb._state != StateListen established := tcb._state == StateEstablished acksOld := hasAck && !tcb.snd.UNA.LessThan(seg.ACK) acksUnsentData := hasAck && !seg.ACK.LessThanEq(tcb.snd.NXT) @@ -493,24 +494,15 @@ func (tcb *ControlBlock) validateIncomingSegment(seg Segment) (err error) { } case established && acksUnsentData: - // After Retransmit() rewinds snd.NXT to snd.UNA, the remote may ACK - // data it received pre-rewind — a valid cumulative ACK that exceeds - // the rewound snd.NXT. Detect this case (NXT==UNA means rewind active) - // and accept the ACK if within the send window. - retransmitActive := tcb.snd.NXT == tcb.snd.UNA - if retransmitActive && seg.ACK.InWindow(tcb.snd.UNA, tcb.snd.WND) { - tcb.snd.NXT = seg.ACK - if isDebug { - tcb.debug("rcv:ACK-advance-nxt", slog.String("state", tcb._state.String()), - slog.Uint64("seg.ack", uint64(seg.ACK)), slog.Uint64("snd.nxt", uint64(tcb.snd.NXT))) - } - } else { - err = errDropSegment - tcb.pending[0] |= FlagACK // Send ACK for unsent data; |= preserves any pending FIN. - if isDebug { - tcb.debug("rcv:ACK-unsent", slog.String("state", tcb._state.String()), - slog.Uint64("seg.ack", uint64(seg.ACK)), slog.Uint64("snd.nxt", uint64(tcb.snd.NXT))) - } + // ACK for data we haven't sent. Drop and send challenge ACK. + // Note: after Retransmit() rewinds snd.NXT, a cumulative ACK may exceed + // the rewound NXT. That case is handled by Handler.RecoveryACK, not here — + // NXT==UNA is ambiguous (also true when no data is in flight). + err = errDropSegment + tcb.pending[0] |= FlagACK // Send ACK for unsent data; |= preserves any pending FIN. + if isDebug { + tcb.debug("rcv:ACK-unsent", slog.String("state", tcb._state.String()), + slog.Uint64("seg.ack", uint64(seg.ACK)), slog.Uint64("snd.nxt", uint64(tcb.snd.NXT))) } case preestablished && (acksOld || acksUnsentData): @@ -581,6 +573,19 @@ func (tcb *ControlBlock) rstJump() Value { // Implements RFC 9293 §3.10.8 (RETRANSMISSION TIMEOUT). func (tcb *ControlBlock) Retransmit() { tcb.snd.NXT = tcb.snd.UNA } +// RecoveryACK accepts a cumulative ACK that covers data sent before a retransmit +// rewind. After Retransmit() rewinds snd.NXT, the remote may ACK data it received +// pre-rewind — a valid cumulative ACK that exceeds the rewound snd.NXT. This method +// advances snd.UNA, snd.NXT and updates the send window from the segment. +// The caller must verify that seg.ACK is within the pre-rewind NXT range. +func (tcb *ControlBlock) RecoveryACK(seg Segment) { + tcb.snd.UNA = seg.ACK + tcb.snd.NXT = seg.ACK + tcb.snd.WND = seg.WND + // Clear any pending ACK that validateIncomingSegment queued on rejection. + tcb.pending[0] &^= FlagACK +} + // Abort sets ControlBlock state to Closed and resets all sequence numbers and pending flag. // No more data can be sent nor received after the connection is aborted until opened again. // An abort call prepares the connection for opening an active connection via a diff --git a/tcp/control_rcvhandlers.go b/tcp/control_rcvhandlers.go index b088cf2..2660752 100644 --- a/tcp/control_rcvhandlers.go +++ b/tcp/control_rcvhandlers.go @@ -97,7 +97,12 @@ func (tcb *ControlBlock) rcvFinWait1(seg Segment) (pending Flags, err error) { default: return 0, errFinwaitExpectedACK } - pending = FlagACK + // Only queue ACK when there is data or FIN to acknowledge. + // Bare ACKs must not elicit an ACK response; doing so creates an + // infinite ACK ping-pong when the peer sends challenge ACKs. + if seg.DATALEN > 0 || hasFin { + pending = FlagACK + } return pending, nil } diff --git a/tcp/handler.go b/tcp/handler.go index 2d9db61..a031b04 100644 --- a/tcp/handler.go +++ b/tcp/handler.go @@ -30,7 +30,10 @@ type Handler struct { optcodec OptionCodec closing bool - + // dupACKs counts consecutive duplicate ACKs for fast retransmit (RFC 5681 §3.2). + dupACKs uint8 + // nRetx counts consecutive retransmissions for exponential backoff (RFC 6298 §5.5). + nRetx uint8 // Retransmission timer state — all uint32 milliseconds, no time package needed. // rto is the current retransmission timeout in ms; starts at 1000 per RFC 6298 §2.1. rto uint32 @@ -38,10 +41,11 @@ type Handler struct { now uint32 // lastACK is the last ACK value seen, for duplicate ACK detection (RFC 5681 §3.2). lastACK Value - // dupACKs counts consecutive duplicate ACKs for fast retransmit (RFC 5681 §3.2). - dupACKs uint8 - // nRetx counts consecutive retransmissions for exponential backoff (RFC 6298 §5.5). - nRetx uint8 + + // retransmitNXT is the pre-rewind value of snd.NXT, saved when fast retransmit + // fires. A cumulative ACK with seg.ACK <= retransmitNXT is valid even if it + // exceeds the rewound snd.NXT. Zero means not in recovery. + retransmitNXT Value } func (h *Handler) SetLoggers(handler, scb *slog.Logger) { @@ -188,11 +192,30 @@ func (h *Handler) Recv(incomingPacket []byte) error { prevUNA := h.scb.snd.UNA // Capture before Recv updates snd.UNA (RFC 6298 §5.3). err = h.scb.Recv(segIncoming) if err != nil { - if h.scb.State() == StateClosed { - // TODO(soypat): Should return EOF/ErrClosed? - err = net.ErrClosed //err // Connection closed by reset. + // Recovery path: after fast retransmit rewinds snd.NXT, a cumulative ACK + // for data sent pre-rewind exceeds the rewound NXT. The ControlBlock rejects + // it, but we know it's valid if ACK <= retransmitNXT (pre-rewind high water mark). + if h.retransmitNXT != 0 && segIncoming.Flags.HasAny(FlagACK) && + h.scb.snd.NXT.LessThan(segIncoming.ACK) && + segIncoming.ACK.LessThanEq(h.retransmitNXT) { + // TODO: This is a very hacky workaround. It'd be great + // to detect recover acks in Handler before calling ControlBlock.Recv + // and handle it cleanly instead of with an error. + h.scb.RecoveryACK(segIncoming) + h.bufTx.RecoveryACK(segIncoming.ACK) + h.retransmitNXT = 0 + h.rto = rtoInitial + h.nRetx = 0 + h.dupACKs = 0 + h.lastACK = segIncoming.ACK + err = nil // Accept the segment. + } else { + if h.scb.State() == StateClosed { + // TODO(soypat): Should return EOF/ErrClosed? + err = net.ErrClosed //err // Connection closed by reset. + } + return err } - return err } if h.scb.State() == StateClosed { // TCB aborted, likely because it received an ACK in LastAck state. @@ -486,6 +509,11 @@ func (h *Handler) ShouldRetransmit() bool { // triggerRetransmit rewinds the transmit queue and control block so the next // Send call retransmits from snd.UNA. Per RFC 9293 §3.10.8, RFC 6298 §5.4–5.5. func (h *Handler) triggerRetransmit() { + // Save the high-water mark of NXT before rewinding so that cumulative ACKs + // for data sent pre-rewind can still be accepted (see Recv recovery path). + if h.retransmitNXT == 0 || h.retransmitNXT.LessThan(h.scb.snd.NXT) { + h.retransmitNXT = h.scb.snd.NXT + } h.scb.Retransmit() h.bufTx.RetransmitFromUNA() // RFC 6298 §5.5: "The host MUST set RTO <- RTO * 2 ('back off the timer')." @@ -494,7 +522,6 @@ func (h *Handler) triggerRetransmit() { if h.rto > rtoMax { h.rto = rtoMax } - h.dupACKs = 0 h.debug("tcp.Handler:retransmit", slog.Uint64("port", uint64(h.localPort)), slog.Uint64("rto", uint64(h.rto)), slog.Uint64("nRetx", uint64(h.nRetx))) } diff --git a/tcp/handler_retransmit_test.go b/tcp/handler_retransmit_test.go index 9baea99..127b7ad 100644 --- a/tcp/handler_retransmit_test.go +++ b/tcp/handler_retransmit_test.go @@ -145,3 +145,530 @@ func TestPostRetransmitACKAccepted(t *testing.T) { t.Fatalf("snd.UNA not advanced: got %d, want %d", client.scb.snd.UNA, preRewindNXT) } } + +// TestRecoveryACKSkipsSpuriousRetransmit verifies that after fast retransmit +// rewinds snd.NXT and the client re-sends the lost segment, a cumulative ACK +// from the remote (acknowledging all data received before and after the hole) +// is accepted — even though it exceeds the rewound snd.NXT. +// +// Without this fix, lneto rejects the cumulative ACK as "acks unsent data" +// and then spuriously retransmits data that was already received by the remote. +// +// Timeline: +// 1. Client sends packets 0..N; packet 1 is lost (the "hole") +// 2. Server ACKs packet 0; sends 3 dup ACKs → fast retransmit fires +// 3. Client rewinds to snd.UNA, re-sends lost segment → snd.NXT advances by 1 MSS +// 4. Server (having received all other packets) sends cumulative ACK for ALL data +// 5. Client should accept this ACK (not reject it) and NOT send spurious retransmissions +func TestRecoveryACKSkipsSpuriousRetransmit(t *testing.T) { + const mtu = 60 // 20-byte header + 40-byte payload per packet. + const txBuf = 2048 + const maxpackets = 10 + rng := rand.New(rand.NewSource(59)) + + client := new(Handler) + server := new(Handler) + err := client.SetBuffers(make([]byte, txBuf), make([]byte, txBuf), maxpackets) + if err != nil { + t.Fatal(err) + } + client.rto = rtoInitial + err = server.SetBuffers(make([]byte, txBuf), make([]byte, txBuf), maxpackets) + if err != nil { + t.Fatal(err) + } + server.rto = rtoInitial + + err = server.OpenListen(uint16(rng.Uint32()), 0) + if err != nil { + t.Fatal(err) + } + err = client.OpenActive(uint16(rng.Uint32()), server.LocalPort(), 0) + if err != nil { + t.Fatal(err) + } + + var rawbuf [mtu]byte + establish(t, client, server, rawbuf[:]) + + // Send enough data to fill several packets (MSS=40). + data := make([]byte, 40*6) // 6 packets worth of data. + for i := range data { + data[i] = byte(i) + } + written := 0 + var packets [][]byte + for written < len(data) { + n, werr := client.Write(data[written:]) + if werr != nil { + t.Fatal("client write:", werr) + } + written += n + for { + clear(rawbuf[:]) + ns, serr := client.Send(rawbuf[:]) + if serr != nil { + t.Fatal("client send:", serr) + } + if ns == 0 { + break + } + packets = append(packets, append([]byte(nil), rawbuf[:ns]...)) + } + } + if len(packets) < 4 { + t.Fatalf("need at least 4 data packets, got %d", len(packets)) + } + t.Logf("sent %d data packets", len(packets)) + + // Record the sequence endpoint: this is the ACK value the server will + // send once it receives all data (including the "lost" packet). + preRewindNXT := client.scb.snd.NXT + t.Logf("pre-rewind snd.NXT=%d, snd.UNA=%d", preRewindNXT, client.scb.snd.UNA) + + // Server receives only packet 0 → ACKs it. This establishes lastACK on client. + err = server.Recv(packets[0]) + if err != nil { + t.Fatal("server recv pkt0:", err) + } + clear(rawbuf[:]) + n, err := server.Send(rawbuf[:]) + if err != nil { + t.Fatal("server send ACK:", err) + } + if n == 0 { + t.Fatal("expected server to send ACK") + } + err = client.Recv(rawbuf[:n]) + if err != nil { + t.Fatal("client recv ACK:", err) + } + dupACKValue := client.lastACK + t.Logf("lastACK=%d after first ACK", dupACKValue) + + // Craft 3 dup ACKs (packet 1 is "lost", server keeps acking dupACKValue). + for i := 0; i < 3; i++ { + var buf [mtu]byte + frm, ferr := NewFrame(buf[:]) + if ferr != nil { + t.Fatal(ferr) + } + frm.SetSourcePort(server.LocalPort()) + frm.SetDestinationPort(client.LocalPort()) + frm.SetSegment(Segment{ + SEQ: server.scb.snd.NXT, + ACK: dupACKValue, + Flags: FlagACK, + WND: 65535, + }, 5) + rerr := client.Recv(buf[:sizeHeaderTCP]) + if rerr != nil { + t.Logf("dup ACK %d recv err (expected): %v", i+1, rerr) + } + } + if client.nRetx == 0 { + t.Fatal("fast retransmit did not fire after 3 dup ACKs") + } + t.Logf("fast retransmit fired: snd.NXT=%d, snd.UNA=%d", client.scb.snd.NXT, client.scb.snd.UNA) + + // Client re-sends the lost segment. After this, snd.NXT > snd.UNA + // (advanced by one MSS), but still < preRewindNXT. + clear(rawbuf[:]) + n, err = client.Send(rawbuf[:]) + if err != nil { + t.Fatal("client retransmit send:", err) + } + if n == 0 { + t.Fatal("expected client to send retransmit packet") + } + if client.scb.snd.NXT == client.scb.snd.UNA { + t.Fatal("expected snd.NXT to advance past snd.UNA after re-send") + } + t.Logf("after retransmit send: snd.NXT=%d, snd.UNA=%d (preRewind=%d)", + client.scb.snd.NXT, client.scb.snd.UNA, preRewindNXT) + + // Craft cumulative ACK from server for ALL data (as if server had received + // everything and the lost packet just arrived, filling the hole). + { + var buf [mtu]byte + frm, ferr := NewFrame(buf[:]) + if ferr != nil { + t.Fatal(ferr) + } + frm.SetSourcePort(server.LocalPort()) + frm.SetDestinationPort(client.LocalPort()) + frm.SetSegment(Segment{ + SEQ: server.scb.snd.NXT, + ACK: preRewindNXT, // ACKs all data sent before the rewind. + Flags: FlagACK, + WND: 65535, + }, 5) + + err = client.Recv(buf[:sizeHeaderTCP]) + if err != nil { + t.Fatalf("BUG: cumulative recovery ACK rejected: %v\n"+ + "After fast retransmit rewound snd.NXT and client re-sent one packet,\n"+ + "the remote's cumulative ACK (seg.ACK=%d) exceeds the current snd.NXT=%d\n"+ + "and is incorrectly rejected as 'acks unsent data'.\n"+ + "This causes spurious retransmissions of already-received data.", + err, preRewindNXT, client.scb.snd.NXT) + } + } + + // snd.UNA should have advanced to cover all original data. + if client.scb.snd.UNA != preRewindNXT { + t.Fatalf("snd.UNA not advanced: got %d, want %d", client.scb.snd.UNA, preRewindNXT) + } + // snd.NXT should be at least preRewindNXT. + if client.scb.snd.NXT.LessThan(preRewindNXT) { + t.Fatalf("snd.NXT behind preRewindNXT: got %d, want >= %d", client.scb.snd.NXT, preRewindNXT) + } + + // No more data should be sent — any Send() output here is a spurious retransmission. + clear(rawbuf[:]) + n, err = client.Send(rawbuf[:]) + if err != nil { + t.Fatal("client send after recovery:", err) + } + if n != 0 { + t.Fatalf("BUG: spurious retransmission after recovery ACK: sent %d bytes.\n"+ + "All data was already acknowledged by the cumulative ACK, but the client\n"+ + "still has 'unsent' data in the TX buffer that was actually received.", n) + } +} + +// TestFastRetransmitOncePerLoss is a regression test for +// https://github.com/soypat/lneto/issues/58 +// where fast retransmit was triggered multiple times for the same lost segment. +// +// When N packets are in flight and one is lost, up to N dup ACKs arrive. +// The bug: triggerRetransmit() reset dupACKs to 0, so every 3 dup ACKs +// triggered another fast retransmit of the same sequence. With 10 packets +// in flight, a single loss caused 3 retransmissions instead of 1. +// +// Per RFC 5681 §3.2, fast retransmit should fire once per loss event. +// Subsequent dup ACKs (beyond the 3rd) should NOT re-trigger it. +func TestFastRetransmitOncePerLoss(t *testing.T) { + const mtu = 60 // Small MTU: 20 byte header + 40 bytes payload per packet. + const txBuf = 2048 + const maxpackets = 10 + rng := rand.New(rand.NewSource(58)) + + client := new(Handler) + server := new(Handler) + err := client.SetBuffers(make([]byte, txBuf), make([]byte, txBuf), maxpackets) + if err != nil { + t.Fatal(err) + } + client.rto = rtoInitial + err = server.SetBuffers(make([]byte, txBuf), make([]byte, txBuf), maxpackets) + if err != nil { + t.Fatal(err) + } + server.rto = rtoInitial + + err = server.OpenListen(uint16(rng.Uint32()), 0) + if err != nil { + t.Fatal(err) + } + err = client.OpenActive(uint16(rng.Uint32()), server.LocalPort(), 0) + if err != nil { + t.Fatal(err) + } + + var rawbuf [mtu]byte + establish(t, client, server, rawbuf[:]) + + // With MSS=40 (mtu-20), write enough to fill several packets. + data := make([]byte, 40*maxpackets) + for i := range data { + data[i] = byte(i) + } + // Write in chunks since TX buffer may limit us. + written := 0 + var packets [][]byte + for written < len(data) { + n, werr := client.Write(data[written:]) + if werr != nil { + t.Fatal("client write:", werr) + } + written += n + // Send as many packets as possible. + for { + clear(rawbuf[:]) + ns, serr := client.Send(rawbuf[:]) + if serr != nil { + t.Fatal("client send:", serr) + } + if ns == 0 { + break + } + packets = append(packets, append([]byte(nil), rawbuf[:ns]...)) + } + } + if len(packets) < 6 { + t.Fatal("need at least 6 data packets, got", len(packets)) + } + t.Logf("sent %d data packets", len(packets)) + + // Server receives only the first packet so it ACKs it, advancing client's lastACK. + err = server.Recv(packets[0]) + if err != nil { + t.Fatal("server recv first packet:", err) + } + clear(rawbuf[:]) + n, err := server.Send(rawbuf[:]) + if err != nil { + t.Fatal("server send ACK:", err) + } + if n == 0 { + t.Fatal("expected server to send ACK") + } + // Client receives the ACK for the first packet, establishing lastACK. + err = client.Recv(rawbuf[:n]) + if err != nil { + t.Fatal("client recv ACK:", err) + } + dupACKValue := client.lastACK + t.Logf("lastACK established at %d, client.dupACKs=%d", dupACKValue, client.dupACKs) + + // Craft 9 identical dup ACKs: same ACK value, no data, no SYN/FIN. + // These simulate what the server would send on receiving out-of-order packets. + const numDupAcks = 9 + var dupAcks [numDupAcks][]byte + for i := range dupAcks { + var buf [mtu]byte + frm, ferr := NewFrame(buf[:]) + if ferr != nil { + t.Fatal("new frame:", ferr) + } + frm.SetSourcePort(server.LocalPort()) + frm.SetDestinationPort(client.LocalPort()) + frm.SetSegment(Segment{ + SEQ: server.scb.snd.NXT, + ACK: dupACKValue, + Flags: FlagACK, + WND: 65535, + }, 5) + dupAcks[i] = append([]byte(nil), buf[:sizeHeaderTCP]...) + } + t.Logf("crafted %d dup ACKs", numDupAcks) + + // Feed all dup ACKs to client, counting how many times fast retransmit fires. + // Between dup ACKs, call Send() to transmit retransmitted packets (as a real + // stack would do). This makes BufferedSent > 0 again, which is required for + // the dup ACK condition to be met. + retransmitCount := 0 + prevNRetx := client.nRetx + for i, ack := range dupAcks[:] { + rerr := client.Recv(ack) + if rerr != nil { + continue + } + if client.nRetx > prevNRetx { + retransmitCount++ + t.Logf("fast retransmit #%d triggered at dup ACK %d (nRetx=%d)", retransmitCount, i+1, client.nRetx) + prevNRetx = client.nRetx + } + // Simulate real behavior: Send() is called between receives, + // which re-sends retransmitted data and makes BufferedSent > 0. + clear(rawbuf[:]) + client.Send(rawbuf[:]) + } + + if retransmitCount == 0 { + t.Fatal("fast retransmit never triggered (expected exactly 1)") + } + if retransmitCount > 1 { + t.Fatalf("BUG (issue #58): fast retransmit triggered %d times for a single loss event, want 1.\n"+ + "triggerRetransmit() resets dupACKs to 0, causing every 3rd dup ACK to\n"+ + "re-trigger fast retransmit for the same lost sequence.", retransmitCount) + } +} + +// TestFastRetransmitResetsOnNewACK verifies that after recovering from a loss +// event (new data ACKed), the dup-ACK counter resets so that a subsequent loss +// can trigger fast retransmit again. +// +// Without the dupACKs=0 reset on new ACK (handler.go line 219), the counter +// would stay above 3 after the first loss event and never reach ==3 again, +// disabling fast retransmit for all subsequent losses. +func TestFastRetransmitResetsOnNewACK(t *testing.T) { + const mtu = 60 // Small MTU: 20 byte header + 40 bytes payload per packet. + const txBuf = 2048 + const maxpackets = 10 + rng := rand.New(rand.NewSource(59)) + + client := new(Handler) + server := new(Handler) + err := client.SetBuffers(make([]byte, txBuf), make([]byte, txBuf), maxpackets) + if err != nil { + t.Fatal(err) + } + client.rto = rtoInitial + err = server.SetBuffers(make([]byte, txBuf), make([]byte, txBuf), maxpackets) + if err != nil { + t.Fatal(err) + } + server.rto = rtoInitial + + err = server.OpenListen(uint16(rng.Uint32()), 0) + if err != nil { + t.Fatal(err) + } + err = client.OpenActive(uint16(rng.Uint32()), server.LocalPort(), 0) + if err != nil { + t.Fatal(err) + } + + var rawbuf [mtu]byte + establish(t, client, server, rawbuf[:]) + + // Helper: craft a dup ACK packet from server to client for the given ACK value. + craftDupACK := func(ackVal Value) []byte { + var buf [mtu]byte + frm, ferr := NewFrame(buf[:]) + if ferr != nil { + t.Fatal("new frame:", ferr) + } + frm.SetSourcePort(server.LocalPort()) + frm.SetDestinationPort(client.LocalPort()) + frm.SetSegment(Segment{ + SEQ: server.scb.snd.NXT, + ACK: ackVal, + Flags: FlagACK, + WND: 65535, + }, 5) + return append([]byte(nil), buf[:sizeHeaderTCP]...) + } + + // Helper: write data, send packets, return them. + sendPackets := func(payload []byte) [][]byte { + written := 0 + var pkts [][]byte + for written < len(payload) { + n, werr := client.Write(payload[written:]) + if werr != nil { + t.Fatal("client write:", werr) + } + written += n + for { + clear(rawbuf[:]) + ns, serr := client.Send(rawbuf[:]) + if serr != nil { + t.Fatal("client send:", serr) + } + if ns == 0 { + break + } + pkts = append(pkts, append([]byte(nil), rawbuf[:ns]...)) + } + } + return pkts + } + + // Helper: deliver packet to server, get ACK, deliver ACK to client. + deliverAndACK := func(pkt []byte) { + rerr := server.Recv(pkt) + if rerr != nil { + t.Fatal("server recv:", rerr) + } + clear(rawbuf[:]) + n, serr := server.Send(rawbuf[:]) + if serr != nil { + t.Fatal("server send:", serr) + } + if n == 0 { + t.Fatal("expected server to send ACK") + } + rerr = client.Recv(rawbuf[:n]) + if rerr != nil { + t.Fatal("client recv ACK:", rerr) + } + } + + // === Loss event #1 === + packets1 := sendPackets(make([]byte, 40*4)) + if len(packets1) < 4 { + t.Fatal("need at least 4 packets for loss event #1, got", len(packets1)) + } + // Deliver the first packet to establish lastACK. + deliverAndACK(packets1[0]) + ackVal1 := client.lastACK + + // Send 3 dup ACKs to trigger fast retransmit. + for i := 0; i < 3; i++ { + err = client.Recv(craftDupACK(ackVal1)) + if err != nil { + t.Fatalf("loss #1: dup ACK %d recv: %v", i+1, err) + } + clear(rawbuf[:]) + client.Send(rawbuf[:]) // Keep BufferedSent > 0. + } + if client.nRetx != 1 { + t.Fatalf("loss #1: expected nRetx=1 after 3 dup ACKs, got %d", client.nRetx) + } + t.Logf("loss #1: fast retransmit triggered (nRetx=%d)", client.nRetx) + + // === Recovery: retransmit the lost packet, server ACKs all data === + // Re-send all the packets that server missed (client retransmits from UNA). + for { + clear(rawbuf[:]) + n, serr := client.Send(rawbuf[:]) + if serr != nil { + t.Fatal("client retransmit send:", serr) + } + if n == 0 { + break + } + _ = server.Recv(rawbuf[:n]) // Deliver retransmitted + new data. + } + // Deliver remaining original packets too. + for i := 1; i < len(packets1); i++ { + _ = server.Recv(packets1[i]) + } + // Server sends cumulative ACK for all received data. + clear(rawbuf[:]) + n, serr := server.Send(rawbuf[:]) + if serr != nil { + t.Fatal("server send recovery ACK:", serr) + } + if n == 0 { + t.Fatal("expected server to send recovery ACK") + } + err = client.Recv(rawbuf[:n]) + if err != nil { + t.Fatal("client recv recovery ACK:", err) + } + t.Logf("recovery: nRetx=%d, lastACK=%d", client.nRetx, client.lastACK) + + // === Loss event #2 === + packets2 := sendPackets(make([]byte, 40*4)) + if len(packets2) < 4 { + t.Fatal("need at least 4 packets for loss event #2, got", len(packets2)) + } + // Deliver the first packet to advance lastACK. + deliverAndACK(packets2[0]) + ackVal2 := client.lastACK + if ackVal2 == ackVal1 { + t.Fatal("lastACK did not advance between loss events") + } + + // Send 3 dup ACKs — fast retransmit should trigger again. + prevNRetx := client.nRetx + for i := 0; i < 3; i++ { + err = client.Recv(craftDupACK(ackVal2)) + if err != nil { + t.Fatalf("loss #2: dup ACK %d recv: %v", i+1, err) + } + clear(rawbuf[:]) + client.Send(rawbuf[:]) // Keep BufferedSent > 0. + } + if client.nRetx <= prevNRetx { + t.Fatalf("BUG: fast retransmit did NOT trigger for loss event #2.\n"+ + "nRetx=%d (was %d).\n"+ + "The dup-ACK counter was not reset after recovery from loss event #1,\n"+ + "so it never reached the threshold again.", client.nRetx, prevNRetx) + } + t.Logf("loss #2: fast retransmit triggered (nRetx=%d)", client.nRetx) +} diff --git a/tcp/tcp_legacy_test.go b/tcp/tcp_legacy_test.go index 28b1345..67ad52f 100644 --- a/tcp/tcp_legacy_test.go +++ b/tcp/tcp_legacy_test.go @@ -231,8 +231,8 @@ func TestExchange_rfc9293_figure12(t *testing.T) { Incoming: &tcp.Segment{SEQ: issB, ACK: issA + 1, Flags: tcp.FlagACK, WND: windowB}, WantState: tcp.StateFinWait2, WantPeerState: tcp.StateCloseWait, - // TODO(soypat): WantPending should be nil here? Perhaps fix test by modifying rcvFinWait1 pending result. - WantPending: &tcp.Segment{SEQ: issA + 1, ACK: issB, Flags: tcp.FlagACK, WND: windowA}, + // RFC Figure 12: no response from A here — bare ACK must not elicit ACK. + WantPending: nil, }, 2: { // A receives FIN|ACK from B. Incoming: &tcp.Segment{SEQ: issB, ACK: issA + 1, Flags: FINACK, WND: windowB}, @@ -496,7 +496,7 @@ func TestExchange_helloworld(t *testing.T) { 11: { // A receives B's ACK of FIN. Incoming: &tcp.Segment{SEQ: issB + 1 + 2*datalen, ACK: issA + 2 + 2*datalen, Flags: tcp.FlagACK, WND: windowB}, WantState: tcp.StateFinWait2, - WantPending: &tcp.Segment{SEQ: issA + 2 + 2*datalen, ACK: issB + 1 + 2*datalen, Flags: tcp.FlagACK, WND: windowA}, + WantPending: nil, // Bare ACK must not elicit ACK (same as Figure 12 fix). WantPeerState: tcp.StateCloseWait, }, } diff --git a/tcp/tcp_test.go b/tcp/tcp_test.go index 4d6524b..b4b3019 100644 --- a/tcp/tcp_test.go +++ b/tcp/tcp_test.go @@ -91,7 +91,7 @@ func TestExchangeTest_figure12(t *testing.T) { Action: tcp.StepBSends, AState: tcp.StateFinWait2, BState: tcp.StateCloseWait, - APending: &tcp.Segment{SEQ: issA + 1, ACK: issB, Flags: tcp.FlagACK, WND: windowA}, // TODO: should be nil? + APending: nil, // RFC Figure 12 shows no response from A here — bare ACK must not elicit ACK. }, 2: { // B calls Close() (RFC 9293 Figure 12 step 4). B goes to LAST-ACK. Action: tcp.StepBCloses, diff --git a/tcp/txqueue.go b/tcp/txqueue.go index 019d56b..9f96192 100644 --- a/tcp/txqueue.go +++ b/tcp/txqueue.go @@ -233,6 +233,34 @@ func (rtx *ringTx) RetransmitFromUNA() { rtx.slist.Reset(cap(rtx.slist.pkts), unaSeq) } +// RecoveryACK processes a cumulative ACK that covers data sent before a +// retransmit rewind. After RetransmitFromUNA merged sent→unsent and cleared +// the sentlist, a recovery ACK may exceed what's currently in the sentlist. +// This method acks any sentlist entries, then skips unsent bytes that were +// implicitly acknowledged (they were received by the remote before the rewind). +func (rtx *ringTx) RecoveryACK(ack Value) { + size := rtx.Size() + // First, ack everything in the sentlist (if any packets were re-sent). + if newest := rtx.slist.Newest(); newest != nil { + rtx.slist.RecvAck(newest.endSeq(), size) + } + rtx.sentoff = 0 + rtx.sentend = 0 + + // Skip unsent data that was implicitly acked. The sequence of the first + // unsent byte is slist.ssn (the end-seq of the last acked packet). + excess := int32(ack - rtx.slist.ssn) + if excess > 0 && rtx.unsentend != 0 { + rtx.unsentoff = addOff(rtx.unsentoff, int(excess), size) + if rtx.unsentoff == rtx.unsentend { + rtx.unsentoff = 0 + rtx.unsentend = 0 + } + } + rtx.slist.Reset(cap(rtx.slist.pkts), ack) + rtx.consolidateBufs() +} + func (rtx *ringTx) consolidateBufs() { unsentEmpty := rtx.unsentend == 0 sentEmpty := rtx.sentend == 0 diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/02ee3bcf7f01f6f9 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/02ee3bcf7f01f6f9 new file mode 100644 index 0000000..b53b149 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/02ee3bcf7f01f6f9 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00'\xff\xff@\x05@\x06%\xce\n\x00\x00\x00\n\x00\x00\xff0000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/077a08960d630c24 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/077a08960d630c24 new file mode 100644 index 0000000..2cff72e --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/077a08960d630c24 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(2) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00(\x00\x04@\x00@\x06%\xce\n\x00\x00\x00\n\x00\x00\xff\x059\x00P\x00\a\xc0?\x00\x04 #P\x10\xfaܵ\x02\x05\x00") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/081540455bb09469 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/081540455bb09469 new file mode 100644 index 0000000..cbbb07d --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/081540455bb09469 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x02000000\x06000000\n\x00\x00\xff00\x00P00000000XB000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\n000000000000000000000000000000000000000000000000000000000000: 00000000000000\n0000000000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/083707fa2abfc07f b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/083707fa2abfc07f new file mode 100644 index 0000000..d7defec --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/083707fa2abfc07f @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x02000000\x06000000\n\x00\x00\xff00\x00P00000000XB00000000000\n00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 00000:00000000000000000000000000000000000000000000000000000000000\n0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/09553dbd2aa18004 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/09553dbd2aa18004 new file mode 100644 index 0000000..06471ff --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/09553dbd2aa18004 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(2) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00(\x00\x04@\x00@\x06%\xce\n\x00\x00\x00\n\x00\x00\xff\x059\x00P\x00\a\xc0@\x00\x04 #P\x10\x05ܯ\x02\x00\x00") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/0969bd6880a6ef9b b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/0969bd6880a6ef9b new file mode 100644 index 0000000..39c4216 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/0969bd6880a6ef9b @@ -0,0 +1,3 @@ +go test fuzz v1 +int(2) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00 000000000000\n\x00\x00\xff00000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/0a5f0448eb3e9abe b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/0a5f0448eb3e9abe new file mode 100644 index 0000000..a0a60ba --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/0a5f0448eb3e9abe @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00G0\x00 00000\x01000000\n\x00\x00\xff000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/0c8437a514767543 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/0c8437a514767543 new file mode 100644 index 0000000..d6a89ed --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/0c8437a514767543 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00(00000\x06000000\n\x00\x00\xff\x00\x00\x00P0000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/0dcd828e06e3ef5f b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/0dcd828e06e3ef5f new file mode 100644 index 0000000..828c8a2 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/0dcd828e06e3ef5f @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00000000\x06000000\n\x00\x00\xff00\x00P00000000XB00000000 0 0\n0") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/0ea236fdc685c79d b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/0ea236fdc685c79d new file mode 100644 index 0000000..c723fc9 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/0ea236fdc685c79d @@ -0,0 +1,3 @@ +go test fuzz v1 +int(6) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00(\x00\x04@\x00@\x06%\xce\n\x00\x00\x00\n\x00\x00\xff\x059\x00\x00\x00\x10\xc0@\x00\x04 #P\x02\x05ܯ\a\x00P") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/0ec280cd1f1c4303 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/0ec280cd1f1c4303 new file mode 100644 index 0000000..c0f6597 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/0ec280cd1f1c4303 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00(\x00\x04@\x00@\x06%\xce\n\x00\x00\x00\n\x00\x00\xff\x059\x00P\x00\x10\xc0@\x00\x04 #P\x02\x05ܯ\a\x00\x00") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/0f312f810f1360db b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/0f312f810f1360db new file mode 100644 index 0000000..35b148b --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/0f312f810f1360db @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00000000\x06000000\n\x00\x00\xff00\x00P00000000aB000000\x01\x01\x01\x010000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/0f679d4da0ef31d1 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/0f679d4da0ef31d1 new file mode 100644 index 0000000..ff67492 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/0f679d4da0ef31d1 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x02000000\x06000000\n\x00\x00\xff00\x00P00000000\xf3B0000000000000000000000000000000000000000000000\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/0fe1ab022b0153c5 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/0fe1ab022b0153c5 new file mode 100644 index 0000000..2bd5734 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/0fe1ab022b0153c5 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00(00000\x06000000\n\x00\x00\xff000000000000X0000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/11918331a63b7235 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/11918331a63b7235 new file mode 100644 index 0000000..0e22f28 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/11918331a63b7235 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00000000\x06000000\n\x00\x00\xff00\x00P00000000XB000000\r0000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/1213eb42115d8c03 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/1213eb42115d8c03 new file mode 100644 index 0000000..1b35b01 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/1213eb42115d8c03 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(6) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00(\x00\x04@\x00@\x06%\xce\n\x00\x00\x00\n\x00\x00\xff\x059\x00P\x00\x10\xc0@\x00\x04 #P\x02\x05ܯ\a\x00\x00") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/123d9910e5e3632b b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/123d9910e5e3632b new file mode 100644 index 0000000..a95fd51 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/123d9910e5e3632b @@ -0,0 +1,3 @@ +go test fuzz v1 +int(6) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00(\x00\x04@\x00@\x06%\xce\n\x00\x00\x00\n\x00\x00\xff\x059\x00P\x00\a\xc0@\x00\x04 #P\x02\x05ܯ\x10\x00\x00") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/13b9c72d7d8a0975 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/13b9c72d7d8a0975 new file mode 100644 index 0000000..825419a --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/13b9c72d7d8a0975 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00(\x00\x04@\x05@>%\x81\n\x00\x00\x10\n\x00\x00\xff00000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/1434fdbdc0e519c9 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/1434fdbdc0e519c9 new file mode 100644 index 0000000..c194427 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/1434fdbdc0e519c9 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00000000\x06000000\n\x00\x00\xff00\x00P00000000aB000000\x02\x04\x00\x020000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/145007e008963a21 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/145007e008963a21 new file mode 100644 index 0000000..e89deca --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/145007e008963a21 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(7) +[]byte("0") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/15c3b0a9a2146d15 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/15c3b0a9a2146d15 new file mode 100644 index 0000000..43f3d1f --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/15c3b0a9a2146d15 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00(\x00\x04@\x00@\x06%\xce\n\xff\xff\x00\n\x00\x00\xff\x059\x00P\x00\a\xc0@\x00\x04 #P\x10\x05ܯ\x02\x00\x00") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/15dcc5908ccfec14 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/15dcc5908ccfec14 new file mode 100644 index 0000000..b9d6784 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/15dcc5908ccfec14 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00(00000\x06000000\n\x00\x00\xff00000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/163d58aa211f0ec9 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/163d58aa211f0ec9 new file mode 100644 index 0000000..26c32af --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/163d58aa211f0ec9 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(6) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00$00000\x1100\n\x00\x00\x00\n\x00\x00\xff\x059\x00P\x00\x10\xc0@\x00\x04 #\xff\x02\x05\xdc0000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/172b101f2d6355e1 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/172b101f2d6355e1 new file mode 100644 index 0000000..f101ea3 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/172b101f2d6355e1 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x06") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/17465131e7262168 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/17465131e7262168 new file mode 100644 index 0000000..515f26a --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/17465131e7262168 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00\xff00000\x06000000\n\x00\x00\xff00\x00P00000000XB00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/1b4767fdfc56dd72 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/1b4767fdfc56dd72 new file mode 100644 index 0000000..040fb50 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/1b4767fdfc56dd72 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00 00000\x01000000\n\x00\x00\xff00000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/1b69470ced789248 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/1b69470ced789248 new file mode 100644 index 0000000..164e672 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/1b69470ced789248 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xff\xff\xff\xff\xff000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/1c17bb675da4127c b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/1c17bb675da4127c new file mode 100644 index 0000000..85b3a7a --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/1c17bb675da4127c @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xff0000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/20cf8cd30f86e1b8 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/20cf8cd30f86e1b8 new file mode 100644 index 0000000..f087ad7 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/20cf8cd30f86e1b8 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x02000000\x06000000\n\x00\x00\xff00\x00P00000000\xf3B000000\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x0100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/2296e5db71348b3b b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/2296e5db71348b3b new file mode 100644 index 0000000..a94ea1f --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/2296e5db71348b3b @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x02000000\x06000000\n\x00\x00\xff00\x00P00000000\xf3B000000\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/2323bd9129992584 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/2323bd9129992584 new file mode 100644 index 0000000..bc2e1ac --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/2323bd9129992584 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x02000000\x06000000\n\x00\x00\xff00\x00P00000000XB00000000000\n00000000000000000000000000000:0\n000000000000000000000000000000000000000000000000000000000000000000000:00000000000000000000000000000000000000000000000000000000000\n000000000000000000000000000000000000000:0\n000000000000000000000000000:0\n000000000000000000000000000000000000000000000000000000000000000000000:00000000000000000000000000000000000000000000000000000000000\n000000000000000000000000000000000000000:0\n000000000000000000000000000:0\n00000000000000000000000000000000000:0\n0000000000000000000000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/26d1b3327832e8ec b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/26d1b3327832e8ec new file mode 100644 index 0000000..f96368a --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/26d1b3327832e8ec @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x0000\x00 000000000000\n\x00\x00\xff00000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/26e9c5d81839dbf8 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/26e9c5d81839dbf8 new file mode 100644 index 0000000..38cdbd8 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/26e9c5d81839dbf8 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00(00000\x06000000\n\x00\x00\xff000000000000X0000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/272c93c42f190328 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/272c93c42f190328 new file mode 100644 index 0000000..aa0817a --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/272c93c42f190328 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(6) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00(\x00\x04@\x00@\x06%\xce\n\x00\x00\x00\n\x00\x00\xff\x059\x00P\x00\a\xc0?\x00\x04 #P\x10\xfaܵ\x02\x05\x00") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/275441286fd27802 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/275441286fd27802 new file mode 100644 index 0000000..711e6ab --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/275441286fd27802 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00000000\x06000000\n\x00\x00\xff00\x00P00000000XB00000000000\n\r0") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/2a706a1a8544ff69 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/2a706a1a8544ff69 new file mode 100644 index 0000000..502ea00 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/2a706a1a8544ff69 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00000000\x06000000\n\x00\x00\xff00\x00P00000000aB0000000\x03000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/2a9a107da4822791 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/2a9a107da4822791 new file mode 100644 index 0000000..a8c3d8f --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/2a9a107da4822791 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(2) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00 00000>000000\n\x00\x00\xff000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/2b73b1de5d914315 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/2b73b1de5d914315 new file mode 100644 index 0000000..beac337 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/2b73b1de5d914315 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x02000000\x06000000\n\x00\x00\xff00\x00P00000000XB000000\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/30656e67eb0c8d91 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/30656e67eb0c8d91 new file mode 100644 index 0000000..efcba56 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/30656e67eb0c8d91 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00000000\x06000000\n\x00\x00\xff00\x00P00000000XB00000000000\n:\n") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/31b89e5e52e2767e b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/31b89e5e52e2767e new file mode 100644 index 0000000..3d66dc7 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/31b89e5e52e2767e @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00(00000\x0600\n\x00\x00\x00\n\x00\x00\xff\x059\x00P\x00\a\xc0?0000XA\x00\x000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/33703f8daaf99da4 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/33703f8daaf99da4 new file mode 100644 index 0000000..f24f01f --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/33703f8daaf99da4 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x02000000\x06000000\n\x00\x00\xff00\x00P00000000\xf3B0000000\n00000000\x03\x030\x03\x030000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/33c24b2f3377ca93 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/33c24b2f3377ca93 new file mode 100644 index 0000000..f3fab9a --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/33c24b2f3377ca93 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x06\x00\x01\b\x00\x06\x04\x00\x0200000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/342ec9d14498c6ae b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/342ec9d14498c6ae new file mode 100644 index 0000000..3a7a185 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/342ec9d14498c6ae @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x02000000\x06000000\n\x00\x00\xff00\x00P00000000XB0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\n000000000000000000000000000000000000000000000000000000000000: 0000000000\n000000000000000000000000000000000000000000000000: 0000000000\n0000000000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/3752be2c2339a529 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/3752be2c2339a529 new file mode 100644 index 0000000..8fb6fb4 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/3752be2c2339a529 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(7) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x060000000000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/37910ab910f16949 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/37910ab910f16949 new file mode 100644 index 0000000..9c0fd65 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/37910ab910f16949 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x02000000\x06000000\n\x00\x00\xff00\x00P00000000\xf3B0000000\n000000000\x0300\x0300\x0300\x0300\x0300\x030000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/38310498ee61353b b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/38310498ee61353b new file mode 100644 index 0000000..e1dfa7e --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/38310498ee61353b @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00(\x00\x04@\x00@\x06%\xce\n\x00\x00\x00\n\x00\x00\xff\x059\x00P\x00\x10\xc0@\x00\x04 #\xaf\xdcP\a\x05\x02\x00\x00") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/38350bc801c6cdc1 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/38350bc801c6cdc1 new file mode 100644 index 0000000..7165941 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/38350bc801c6cdc1 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00H0\x00 00000\x06000000\n\x00\x00\xff00000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/385ed2fa5fa76ed0 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/385ed2fa5fa76ed0 new file mode 100644 index 0000000..d16b9a2 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/385ed2fa5fa76ed0 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(6) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00(\x00\x04@\x00@\x06%\xce\n\x00\x00\x00\n\x00\x00\xff\x059\x00P\x00\a\xc0@\x00\x02 #P\x00\x05ܯ\x10\x00\x04") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/38d4dee50f2b846e b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/38d4dee50f2b846e new file mode 100644 index 0000000..1b50df3 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/38d4dee50f2b846e @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x02000000\x06000000\n\x00\x00\xff00\x00P00000000XB00000000000\n000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000:00000000000000000000000000000000000000000000000000000000000\n000000000000000000000000000000000000000000000000000000000000000000000000000000:0\n000000000000000000000000000000000000000000000000000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/38e5df2bcd06764f b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/38e5df2bcd06764f new file mode 100644 index 0000000..cbc9315 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/38e5df2bcd06764f @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00000000\x06000000\n\x00\x00\xff00\x00P00000000aB000000\x03\x03000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/396abf0b737a01cf b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/396abf0b737a01cf new file mode 100644 index 0000000..638b7e4 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/396abf0b737a01cf @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00(\x00\x04@\x00@\x06%\xce\n\x00\x00\x00\n\x00\x00\xff\x059\x00P\x00\a\xc0@\x00\x04 #P\x10\x05ܯ\x02\x00\x00") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/3a812b5130e8ea4a b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/3a812b5130e8ea4a new file mode 100644 index 0000000..4c6123a --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/3a812b5130e8ea4a @@ -0,0 +1,3 @@ +go test fuzz v1 +int(2) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00(00000\x0600\n\x00\x00\x00\n\x00\x00\xff\x059\x00P0000\x00\x04 \"X2000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/3dcfba61e48395a9 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/3dcfba61e48395a9 new file mode 100644 index 0000000..c302c75 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/3dcfba61e48395a9 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00)00000\x0600\n\x00\x00\x00\n\x00\x00\xff\x059\x00P\x00\a\xc0?0000X 0000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/41945720275cf570 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/41945720275cf570 new file mode 100644 index 0000000..7220de5 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/41945720275cf570 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000\x00\x00") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/438a21f18348ddb3 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/438a21f18348ddb3 new file mode 100644 index 0000000..18dca39 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/438a21f18348ddb3 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x0000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/43ca0072937b2002 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/43ca0072937b2002 new file mode 100644 index 0000000..517ddbe --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/43ca0072937b2002 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00(00000\x0600\n\x00\x00\x00\n\x00\x00\xff\x059\x00P\x00\a\xc0?\xfa000X1000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/4412b7faa38e0153 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/4412b7faa38e0153 new file mode 100644 index 0000000..a831b35 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/4412b7faa38e0153 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00000000\x06000000\n\x00\x00\xff00\x00P00000000XB000000\r\r\r\r\r\r\r\r") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/44e970e552fbb21b b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/44e970e552fbb21b new file mode 100644 index 0000000..4aeea35 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/44e970e552fbb21b @@ -0,0 +1,3 @@ +go test fuzz v1 +int(1) +[]byte("00000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/4550823342495417 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/4550823342495417 new file mode 100644 index 0000000..e62ae11 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/4550823342495417 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00*00000\x0600\n\x00\x00\x00\n\x00\x00\xff\x059\x00P\x00\a\xc0?0000XA\x00\x00000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/4559c0a1d6085566 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/4559c0a1d6085566 new file mode 100644 index 0000000..f1ae7a2 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/4559c0a1d6085566 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00800000\x06000000\n\x00\x00\xff00\x00P00000000XB000000\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/46b75392da5f7cfe b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/46b75392da5f7cfe new file mode 100644 index 0000000..13296cf --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/46b75392da5f7cfe @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00000000\x06000000\n\x00\x00\xff00\x00P00000000aB0000000\x020\x020000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/46d1961b32d5cb9f b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/46d1961b32d5cb9f new file mode 100644 index 0000000..633cdfb --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/46d1961b32d5cb9f @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00(\x00\x04@\x00@\x06%\xce\n\x00\x00\x00\n\x00\x00\xff\x059\x00P\x00\x10\xc0\x02\x00\x04 #P@\x05ܯ\a\x00\x00") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/478d693097378327 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/478d693097378327 new file mode 100644 index 0000000..7d2634f --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/478d693097378327 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00)00000\x06000000\n\x00\x00\xff000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/47f19a40024b8cb1 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/47f19a40024b8cb1 new file mode 100644 index 0000000..acaf36a --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/47f19a40024b8cb1 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x0600000N00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/480056564c5f416b b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/480056564c5f416b new file mode 100644 index 0000000..5688ae7 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/480056564c5f416b @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00000000\x06000000\n\x00\x00\xff00\x00P00000000XB00000000000\r\n0") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/49664281f0c7d6ae b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/49664281f0c7d6ae new file mode 100644 index 0000000..b96ea8e --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/49664281f0c7d6ae @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00 00000\x01000000\n\x00\x00\xff0000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/49fa803a8051b0b2 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/49fa803a8051b0b2 new file mode 100644 index 0000000..3d8614e --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/49fa803a8051b0b2 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00(00000\x0600\n\x00\x00\x00\n\x00\x00\xff\x059\x00P\x00\a\xc0?0000X\x01000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/4b48919d576a3a2d b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/4b48919d576a3a2d new file mode 100644 index 0000000..2e2aa22 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/4b48919d576a3a2d @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00(00000\x0600\n\x00\x00\x00\n\x00\x00\xff\x059\x00P\x00\a\xc0@\x00\x04 #P\x10\x05ܯ\x02\x00\x00") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/4c97d23b2c3c3baf b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/4c97d23b2c3c3baf new file mode 100644 index 0000000..d956d12 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/4c97d23b2c3c3baf @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00(\x00\x04@\x00@\x06%\xce\n\x00\x00\x00\n\x00\x00\xff\x059\x00P\x00\a\xc0?\x00\xdc #P\x10\xfa\x04\xb5\x02\x05\x00") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/4d779050267d6a33 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/4d779050267d6a33 new file mode 100644 index 0000000..d015641 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/4d779050267d6a33 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(2) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00(\x00\x04@\x00@\x06%\xce\n\x00\x00\x00\n\x00\x00\xff\x059\x00P\x00\x10\xc0@\x00\x04 #P\a\x05ܯ\x02\x00\x00") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/50907d0be878c4a4 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/50907d0be878c4a4 new file mode 100644 index 0000000..2975ba0 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/50907d0be878c4a4 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x04\x0000000\x0600\n\x00\x00\x00\n\x00\x00\xff\x059\x00P00000000XB000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/50e74d0d01f18bfb b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/50e74d0d01f18bfb new file mode 100644 index 0000000..6014022 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/50e74d0d01f18bfb @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000 0") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/510fca6994c6aaea b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/510fca6994c6aaea new file mode 100644 index 0000000..29ac033 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/510fca6994c6aaea @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00(00000\x06000000\n\x00\x00\xff000000000000a0000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/5157b512027871a1 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/5157b512027871a1 new file mode 100644 index 0000000..4d1eda7 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/5157b512027871a1 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00000000\x06000000\n\x00\x00\xff00\x00P00000000aB000000\x02\x04000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/523a71b2c3589276 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/523a71b2c3589276 new file mode 100644 index 0000000..84028a8 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/523a71b2c3589276 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00(\x00\x04@\x00@\x06%\xce\n\x00\x00\x00\n\x00\x00\xff\x059\xff\xff\x00\x10\xc0@\x00\x04 #P\x02\x05ܯ\a\x00P") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/551f1b5748ff590a b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/551f1b5748ff590a new file mode 100644 index 0000000..69272d2 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/551f1b5748ff590a @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00000000\x06000000\n\x00\x00\xff00\x00P00000000aB000000\x02\x04\x00\x000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/568931e65f633c06 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/568931e65f633c06 new file mode 100644 index 0000000..550bcab --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/568931e65f633c06 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000\x81\x000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/5c475e95b27afb5b b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/5c475e95b27afb5b new file mode 100644 index 0000000..bd75150 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/5c475e95b27afb5b @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00*00000\x0600\n\x00\x00\x00\n\x00\x00\xff\x059\x00P\x00\a\xc0?0000X 00000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/5e62eb22ac20ee72 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/5e62eb22ac20ee72 new file mode 100644 index 0000000..35c3ef9 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/5e62eb22ac20ee72 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(2) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00(00000\x0600\n\x00\x00\x00\n\x00\x00\xff\x059\x00P0000\x00\x04 \"Y\xfb000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/5ef46c16ddd5f36c b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/5ef46c16ddd5f36c new file mode 100644 index 0000000..6b4f9de --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/5ef46c16ddd5f36c @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00000000\x06000000\n\x00\x00\xff00\x00P00000000aB000000\x010000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/62170998841481ad b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/62170998841481ad new file mode 100644 index 0000000..ee1ef8a --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/62170998841481ad @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00\xff00000\x06000000\n\x00\x00\xff0000000000000B00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/6279be4fdf184603 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/6279be4fdf184603 new file mode 100644 index 0000000..7dd63c8 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/6279be4fdf184603 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000\x81\x00") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/62bae9070ab5f211 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/62bae9070ab5f211 new file mode 100644 index 0000000..b3baf47 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/62bae9070ab5f211 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x06\x00\x01\b\x00\x06\x04\x00\x0100000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/62fa0aef0468129c b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/62fa0aef0468129c new file mode 100644 index 0000000..50684e7 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/62fa0aef0468129c @@ -0,0 +1,3 @@ +go test fuzz v1 +int(2) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00(\x00\x04@\x00@\x06%\xce\n\x00\x00\x00\n\x00\x00\xff\x059\x00P\x00\x10\xc0@\x00\x04 #P\x02\x05ܯ\a\x00\x00") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/65bcea75bb8022c8 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/65bcea75bb8022c8 new file mode 100644 index 0000000..f02c2d6 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/65bcea75bb8022c8 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(7) +[]byte("\xbe\xef\x00\x00\x00\xff000000\x00\b0E\x00 00000p000000\n\x00\x00\xff00000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/66c82de98452d219 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/66c82de98452d219 new file mode 100644 index 0000000..4ec5fbb --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/66c82de98452d219 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(2) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00(\x00\x04@\x00@\x11%\xc3\n\x00\x00\x00\n\x00\x00\xff0000\x00\x1100000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/67ecded90b404b67 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/67ecded90b404b67 new file mode 100644 index 0000000..a5efdd8 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/67ecded90b404b67 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00 00000\x11000000\n\x00\x00\xff0000\x00\x00000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/684047813c13eba9 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/684047813c13eba9 new file mode 100644 index 0000000..d46dec6 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/684047813c13eba9 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00(\x00\x04@\x00@\x06%\xce\n\x00\x00\x00\n\x00\x00\xff\x059\x00P\x00\a\xc0@\x00\x02 #P\x04\x05ܯ\x10\x00\x00") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/69d095c5cacf477a b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/69d095c5cacf477a new file mode 100644 index 0000000..2c249df --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/69d095c5cacf477a @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00(\x00\x04@\x00@\x06%\xce\n\x00\x00\x00\n\x00\x00\xff\x059\x00P\x00\a\xc0?\xfa\x04 #P\x00\x05ܵ\x10\x00\x02") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/6a5b08d57ec3bbed b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/6a5b08d57ec3bbed new file mode 100644 index 0000000..a663117 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/6a5b08d57ec3bbed @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00(\x00\x04@\x00@\x06%\xce\n\x00\x00\x00\n\x00\x00\xff\x059\x00P\x00\b\xc0@\x00\x04 \x02P+\x05ܯ\a\x00\x00") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/6b016f7f24be24e2 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/6b016f7f24be24e2 new file mode 100644 index 0000000..b61ea16 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/6b016f7f24be24e2 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x06\x00\x01\b\x00\x06\x040000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/6c660dc66b4396d7 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/6c660dc66b4396d7 new file mode 100644 index 0000000..07cfebc --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/6c660dc66b4396d7 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x02000000\x06000000\n\x00\x00\xff00\x00P00000000\xf3B0000000\n00000000\x03\x030\x03\x030\x03\x030\x03\x030000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/6c840e28c3cda436 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/6c840e28c3cda436 new file mode 100644 index 0000000..9ac7eae --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/6c840e28c3cda436 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x02000000\x06000000\n\x00\x00\xff00\x00P00000000XB00000000000\n00000000000000000000000000000:0\n000000000000000000000000000000000000000000000000000000000000000000000:00000000000000000000000000000000000000000000000000000000000\n000000000000000000000000000000000000000:0\n000000000000000000000000000:0\n000000000000000000000000000000000000000000000000000000000000000000000:00000000000000000000000000000000000000000000000000000000000\n000000000000000000000000000000000000000:0\n000000000000000000000000000000000000000000000000000000000000:0\n000000000000000000000000000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/6c9433353b45a3c5 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/6c9433353b45a3c5 new file mode 100644 index 0000000..e1ba292 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/6c9433353b45a3c5 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x02000000\x06000000\n\x00\x00\xff00\x00P00000000XB00000000000\n00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000:00000000000000000000000000000000000000000000000000000000000\n00000000000000000000000000000000000000000000000000000000000000000000000000000000\n0000000000000000000000000000000000000000000000000000000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/6efd20290df138d5 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/6efd20290df138d5 new file mode 100644 index 0000000..14487e1 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/6efd20290df138d5 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00000000\x06000000\n\x00\x00\xff00\x00P00000000aB000000\x02\x04\x0000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/706ec4d0027ffd16 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/706ec4d0027ffd16 new file mode 100644 index 0000000..50bfb6b --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/706ec4d0027ffd16 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(4) +[]byte("") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/727529b57474fca4 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/727529b57474fca4 new file mode 100644 index 0000000..8376e4d --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/727529b57474fca4 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x02000000\x06000000\n\x00\x00\xff00\x00P00000000\xf3B0000000\n000000000\x0300\x0300\x020\x0300\x0300\x0300\x0300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/72f6b0b56269283e b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/72f6b0b56269283e new file mode 100644 index 0000000..43a928e --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/72f6b0b56269283e @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00800000\x06000000\n\x00\x00\xff00\x00P00000000XB000000\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/732ccf3c65cb1e1a b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/732ccf3c65cb1e1a new file mode 100644 index 0000000..cf2efae --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/732ccf3c65cb1e1a @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00(\x00\x04@\x05@\x01%\xce\n\x00\x00\x00\n\x00\x00\xff0000000000000????000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/7596dc7fa176af1f b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/7596dc7fa176af1f new file mode 100644 index 0000000..ab4e71d --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/7596dc7fa176af1f @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x02000000\x06000000\n\x00\x00\xff00\x00P00000000\xf3B0000000\n000000000\n000000000\n000000000\n00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/79510d17fda0d2d6 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/79510d17fda0d2d6 new file mode 100644 index 0000000..6bc91fc --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/79510d17fda0d2d6 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(2) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00(00000\x0600\n\x00\x00\x00\n\x00\x00\xff\x059\x00P0000\x00\x04 \"X\x12000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/7bda3c48707023fa b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/7bda3c48707023fa new file mode 100644 index 0000000..12d926c --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/7bda3c48707023fa @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00(\x00\x04@\x05@N%\x81\n\x00\x00\x00\n\x00\x00\xff00000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/7c2177f0a84b8170 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/7c2177f0a84b8170 new file mode 100644 index 0000000..08fda55 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/7c2177f0a84b8170 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(2) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00(\x00\x04@\x00@\x06%\xce\n\x00\x00\x00\n\x00\x00\xff\x059\x00P\x00\a\xc0?\xfa\x04 #P\x10\x00ܵ\x02\x05\x00") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/7c63a546ab0079a8 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/7c63a546ab0079a8 new file mode 100644 index 0000000..364cb5e --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/7c63a546ab0079a8 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(6) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00(\x00\x04@\x00@\x06%\xce\n\x00\x00\x00\n\x00\x00\xff\x059\x00P\x00\a\xc0@\x00\x02 #P\x04\x05ܯ\x10\x00\x00") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/7d0b272cc90984ce b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/7d0b272cc90984ce new file mode 100644 index 0000000..b83bb2a --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/7d0b272cc90984ce @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00000000\x06000000\n\x00\x00\xff00\x00P00000000XB000000\n\n\n00000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/7dcd1a915866ce41 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/7dcd1a915866ce41 new file mode 100644 index 0000000..26bc1ff --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/7dcd1a915866ce41 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x02000000\x06000000\n\x00\x00\xff00\x00P00000000XB00000000000\n000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000:0\n000000000000000000000000000000000000000000000000000000000000000000000:00000000000000000000000000000000000000000000000000000000000\n000000000000000000000000000000000000000:0\n000000000000000000000000000000000000000000000000000000000000:0\n000000000000000000000000000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/816026a04e401c40 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/816026a04e401c40 new file mode 100644 index 0000000..2a3ea9c --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/816026a04e401c40 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x02000000\x06000000\n\x00\x00\xff00\x00P00000000XB0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\n\r000000000000000000000000000000000000000000000:0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\n\r000000000000000000000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/81de82b5ba6aa4de b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/81de82b5ba6aa4de new file mode 100644 index 0000000..cd884b2 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/81de82b5ba6aa4de @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x02000000\x06000000\n\x00\x00\xff00\x00P00000000XB000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\n000000000000000000000000000000000000000000000000000000000000: 0000000000\n0000000000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/8321f0d4f3c80586 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/8321f0d4f3c80586 new file mode 100644 index 0000000..886c1ae --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/8321f0d4f3c80586 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00(\x00\x00\x05\x00\x04@\x81N%@\x00\n\n\x00\x00\xff00000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/84db82c39b5afc75 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/84db82c39b5afc75 new file mode 100644 index 0000000..c3a59cb --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/84db82c39b5afc75 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00000000\x06000000\n\x00\x00\xff00\x00P00000000aB000000\x04\x02\x04\x020000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/8528fcdb411164ff b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/8528fcdb411164ff new file mode 100644 index 0000000..d30dd23 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/8528fcdb411164ff @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xff\xff\xff\xff0000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/874c9691fcd1e3aa b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/874c9691fcd1e3aa new file mode 100644 index 0000000..22c0368 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/874c9691fcd1e3aa @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00(\x00\x04@\x00@\x06%\xce\n\x00\x00\x00\n\x00\x00\xff\x059\x00P\x00\x10\xc0@\x00\x04 \x02P#\x05ܯ\a\x00\x00") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/8950b4a43902cb72 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/8950b4a43902cb72 new file mode 100644 index 0000000..92f860e --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/8950b4a43902cb72 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(2) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00 00000X000000\n\x00\x00\xff000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/8a3aee83558ec9d5 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/8a3aee83558ec9d5 new file mode 100644 index 0000000..592847a --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/8a3aee83558ec9d5 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00000000\x06000000\n\x00\x00\xff00\x00P00000000XB00000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/8b0fbca55c58481b b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/8b0fbca55c58481b new file mode 100644 index 0000000..570e716 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/8b0fbca55c58481b @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00000000\x06000000\n\x00\x00\xff00\x00P00000000XB000000\r\r\r\r\r\r\r0") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/8b1fe6d72d34a646 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/8b1fe6d72d34a646 new file mode 100644 index 0000000..0ba63dd --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/8b1fe6d72d34a646 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00(\x00\x04@\x00@\x06%\xce\n\x00\x00\x00\n\x00\x00\xff\x05\xdc\x00P\x00\x10\xc0@\x00\x04 #P\a\x059\xaf\x02\x00\x00") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/90baf4c702e9f9cc b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/90baf4c702e9f9cc new file mode 100644 index 0000000..a1acaa4 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/90baf4c702e9f9cc @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff\xbe\xef\x00\x00\x00\x00\b\x00E\x00\x00\nm/@\x00@\x06%\xce\n\x00\x00\x00\n\x00\x00\xff\x059\x00P\x00\a\xc0@\x00\x04 #P\x10\x05ܯ\x02\x00\x00\x00\x00\x00\x00\x00\x00") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/9402e593b770c689 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/9402e593b770c689 new file mode 100644 index 0000000..a7032e6 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/9402e593b770c689 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x02000000\x06000000\n\x00\x00\xff00\x00P00000000XB000000\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/95d7d467efe7927b b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/95d7d467efe7927b new file mode 100644 index 0000000..d7b434d --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/95d7d467efe7927b @@ -0,0 +1,3 @@ +go test fuzz v1 +int(6) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00(\x00\x04@\x00@\x11%\xc3\n\x00\x00\x00\n\x00\x00\xff00000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/9644f35ccaee170b b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/9644f35ccaee170b new file mode 100644 index 0000000..3a126cf --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/9644f35ccaee170b @@ -0,0 +1,3 @@ +go test fuzz v1 +int(7) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00 00000x000000\n\x00\x00\xff000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/9848fa03d19bca27 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/9848fa03d19bca27 new file mode 100644 index 0000000..66084db --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/9848fa03d19bca27 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00(\x00\x04@\x00@\x06%\xce\n\x00\x00\x00\n\x00\x00\xff\x059\x00\x00\x00\x10\xc0@\x00\x04 #P\x02\x05ܯ\a\x00P") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/9869ec2b2b52a60d b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/9869ec2b2b52a60d new file mode 100644 index 0000000..2495d6d --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/9869ec2b2b52a60d @@ -0,0 +1,3 @@ +go test fuzz v1 +int(6) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00(\x00\x04@\x00@\xce%\x06\n\x00\x00\x00\n\x00\x00\xff00000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/99e474202bda5676 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/99e474202bda5676 new file mode 100644 index 0000000..a703ddd --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/99e474202bda5676 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(7) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00 00000p000000\n\x00\x00\xff00000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/9a9d4ae5884526fd b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/9a9d4ae5884526fd new file mode 100644 index 0000000..9a37e28 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/9a9d4ae5884526fd @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\x020") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/9b1be708d1df1e9e b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/9b1be708d1df1e9e new file mode 100644 index 0000000..5197e71 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/9b1be708d1df1e9e @@ -0,0 +1,3 @@ +go test fuzz v1 +int(6) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00(00000\x0600\n\x00\x00\x00\n\x00\x00\xff\x059\x00P\x00\a\xc0@\x80\x00\x00\x00X0000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/9b8369e98aef350d b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/9b8369e98aef350d new file mode 100644 index 0000000..173eacf --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/9b8369e98aef350d @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x01\x0500000\x06000000\n\x00\x00\xff0000000000000B00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/9bcedbf047a63f27 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/9bcedbf047a63f27 new file mode 100644 index 0000000..1e764e0 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/9bcedbf047a63f27 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x02000000\x06000000\n\x00\x00\xff00\x00P00000000XB00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\n000000000000000000000000000000000000000000000000000000000000:0\n 0000\n 00000000000000000000000000000000000000000000000000000000000000000\n 0000\n 000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\n 0000\n 00000000000000000000000000000000000000000000000000000000000000000\n 0000\n 00000000000000000000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/9c4a99464a69a05a b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/9c4a99464a69a05a new file mode 100644 index 0000000..8c90c8b --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/9c4a99464a69a05a @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00(\x00\x04@\x00@\xce%\x06\n\x00\x00\x00\n\x00\x00\xff00000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/9fb8a87b7036019f b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/9fb8a87b7036019f new file mode 100644 index 0000000..3dc52a0 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/9fb8a87b7036019f @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00(\x00\x04@\x00@\x06%\xce\n\x00\x00\x00\n\x00\x00\xff\x059\x00P\x00\a\xc0?\xfa\x04 #P\x02\x05ܵ\x10\x00\x00") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/a09c7ae173f26c15 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/a09c7ae173f26c15 new file mode 100644 index 0000000..9a789aa --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/a09c7ae173f26c15 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x06\x00\x0100\x06\x000000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/a1d507be96724f0b b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/a1d507be96724f0b new file mode 100644 index 0000000..67d3bd4 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/a1d507be96724f0b @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00(\x00\x04@\x00@\x06%\xce\n\x00\x00\x00\n\x00\x00\xff\x059\x00\x04\x00\a\xc0@\x00P #P\x10\x05ܯ\x02\x00\x00") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/a236a65273d75d28 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/a236a65273d75d28 new file mode 100644 index 0000000..93ad290 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/a236a65273d75d28 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x02000000\x06000000\n\x00\x00\xff00\x00P00000000\xf3B0000000000000000000000000000000000000000000000\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/a65eb32415672da4 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/a65eb32415672da4 new file mode 100644 index 0000000..1e7a560 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/a65eb32415672da4 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00000000\x06000000\n\x00\x00\xff00\x00P00000000aB00000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/a6ba3f4a78f64558 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/a6ba3f4a78f64558 new file mode 100644 index 0000000..f91de2b --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/a6ba3f4a78f64558 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x02000000\x06000000\n\x00\x00\xff00\x00P00000000XB00000000000\n00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000:00000000000000000000000000000000000000000000000000000000000\n0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/a6ffa36a71eca289 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/a6ffa36a71eca289 new file mode 100644 index 0000000..c304557 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/a6ffa36a71eca289 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(2) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\xcb\xcb\xcb\x00\x04@\x00@\x06%\xce\n\x00\x00\x00\n\x00\x00\xff\x059\x00\x01\x00\a\xc0@\x00d\xff#P\x10\x05ܯ\x02\x00\x00") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/a7575b975df3f926 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/a7575b975df3f926 new file mode 100644 index 0000000..62a8183 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/a7575b975df3f926 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(6) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00(\x00\x04@\x00@\x06%\xce\n\x00\x00\x00\n\x00\x00\xff\x059\x00P\x00\a\xc0?\xfa\x04 #P\x02\x05ܵ\x10\x00\x00") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/a78f44ea84a8c68d b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/a78f44ea84a8c68d new file mode 100644 index 0000000..feb00d1 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/a78f44ea84a8c68d @@ -0,0 +1,3 @@ +go test fuzz v1 +int(4) +[]byte("0") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/a9ef77fb22dc3b80 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/a9ef77fb22dc3b80 new file mode 100644 index 0000000..dd0398e --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/a9ef77fb22dc3b80 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00000000\x06000000\n\x00\x00\xff00\x00P00000000aB000000\x01\x01\x0100000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/af070c755a7646e2 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/af070c755a7646e2 new file mode 100644 index 0000000..10b3b45 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/af070c755a7646e2 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00(\x00\x04@\x05@\x81%N\n\x00\x00\x00\n\x00\x00\xff00000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/b11be55787553336 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/b11be55787553336 new file mode 100644 index 0000000..25a5482 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/b11be55787553336 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(1) +[]byte("") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/b14ebb8a964aa260 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/b14ebb8a964aa260 new file mode 100644 index 0000000..77b5cb8 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/b14ebb8a964aa260 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x02000000\x06000000\n\x00\x00\xff00\x00P00000000XB00000000000\n000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000:0000000000000000000000000000000000000000000000000000000000\r\n000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/b2700d447a89c7d1 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/b2700d447a89c7d1 new file mode 100644 index 0000000..15cb29e --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/b2700d447a89c7d1 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00(\x00\x04@\x00@\x06%\xce\n\x00\x00\x00\n\x00\x00\xff\x059\x00P\x00\a\xc0@\x00\x04 #P\x10\x05ܯ\x02\x00\x00") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/b3be69f5cac93979 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/b3be69f5cac93979 new file mode 100644 index 0000000..4fb8198 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/b3be69f5cac93979 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(7) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00 00000A000000\n\x00\x00\xff000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/b5090ae6e41396ed b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/b5090ae6e41396ed new file mode 100644 index 0000000..a579d17 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/b5090ae6e41396ed @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x0070\x00 000000000000\n\x00\x00\xff000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/b5e752dfbe0975ce b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/b5e752dfbe0975ce new file mode 100644 index 0000000..1c8660a --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/b5e752dfbe0975ce @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00000000\x06000000\n\x00\x00\xff00\x00P00000000XB000000000000\n0") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/b9011866043059c9 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/b9011866043059c9 new file mode 100644 index 0000000..78e62eb --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/b9011866043059c9 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x06\x00\x01\b\x00\x06\x010000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/b9a300ea13345da6 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/b9a300ea13345da6 new file mode 100644 index 0000000..57d541b --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/b9a300ea13345da6 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(2) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00)00000\x0600\n\x00\x00\x00\n\x00\x00\xff\x059\x00P0000\x00\x04 \"X20000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/ba5c54babbd58a18 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/ba5c54babbd58a18 new file mode 100644 index 0000000..6e7354a --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/ba5c54babbd58a18 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00(00000\x06000000\n\x00\x00\xff00000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/baaaa1f744b9534a b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/baaaa1f744b9534a new file mode 100644 index 0000000..23f2e12 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/baaaa1f744b9534a @@ -0,0 +1,3 @@ +go test fuzz v1 +int(2) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00(\x00\x04@\x00@\x06%\xce\n\x00\x00\x00\n\x00\x00\xff\x059\x00P\x00\a\xc0?\xfa\x04 #P\x10\x00\x00\xb5\x02\x05\xdc") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/bb5910e976ca3593 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/bb5910e976ca3593 new file mode 100644 index 0000000..85aad98 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/bb5910e976ca3593 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00(\x00\x04@\x00@\x06%\xce\n\x00\x00\x00\n\x00\x00\xff\x059\x00P\x00\x10\xc0@\x00\x04 #P\a\x05ܯ\x02\x00\x00") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/bc9e4ecf587a3bd4 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/bc9e4ecf587a3bd4 new file mode 100644 index 0000000..9d9540a --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/bc9e4ecf587a3bd4 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xff\xff000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/bd5b71d5e92e91a8 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/bd5b71d5e92e91a8 new file mode 100644 index 0000000..fa9a72f --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/bd5b71d5e92e91a8 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(2) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00I\x00\x00(\x00\x04@\x00@\x11%\xc3\x06\x00\x00\x00\n\x00\x00\xff00000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/bd5f70ad97b16e78 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/bd5f70ad97b16e78 new file mode 100644 index 0000000..51df80c --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/bd5f70ad97b16e78 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x02000000\x06000000\n\x00\x00\xff00\x00P00000000XB00000000000\n00\n0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000:00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/beb5413b1bb2bf49 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/beb5413b1bb2bf49 new file mode 100644 index 0000000..d1234bb --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/beb5413b1bb2bf49 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00(\x00\x04@\x00@\x06%\xce\n\x00\x00\x00\n\x00\x00\xff00000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/bef5b3a3e70396a7 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/bef5b3a3e70396a7 new file mode 100644 index 0000000..ee511ac --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/bef5b3a3e70396a7 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00000000\x06000000\n\x00\x00\xff00\x00P00000000XB000000\n0000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/bf208c4e16cbb819 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/bf208c4e16cbb819 new file mode 100644 index 0000000..9544333 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/bf208c4e16cbb819 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x04\x0000000\x0600\n\x00\x00\x00\n\x00\x00\xff\x059\x00P00000000X\x02000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/bfb83a6669743c70 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/bfb83a6669743c70 new file mode 100644 index 0000000..8bb6b44 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/bfb83a6669743c70 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(6) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00(\x00\x04@\x00@\x06%\xce\n\x00\x00\x00\n\x00\x00\xff\x059\x00P\x00\a\xc0?\xfa\x04 #P\x10\x00ܵ\x02\x05\x00") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/c1f911fe6fb852c4 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/c1f911fe6fb852c4 new file mode 100644 index 0000000..6cecf6a --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/c1f911fe6fb852c4 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/c2e6e0c38ec2143a b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/c2e6e0c38ec2143a new file mode 100644 index 0000000..325eaa3 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/c2e6e0c38ec2143a @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00(\x00\x04@\x00@\x06%\xce\n\x00\x00\x00\n\x00\x00\xff\x059\x00P\x00\a\xc0@\x00ܯ\x02\x00\x10\x05\x04 #P\x00") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/c32477fdc6227f08 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/c32477fdc6227f08 new file mode 100644 index 0000000..0d4ff75 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/c32477fdc6227f08 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00(\x00\x04@\x00@\x06%\xce\n\x00\x00\x00\n\x00\x00\xff\x059\x00P\x00\a\xc0?\x00\x04 @P\xf3\xf9ܵ\x02\x05\x00") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/c482bfdc65d9421d b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/c482bfdc65d9421d new file mode 100644 index 0000000..9629c55 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/c482bfdc65d9421d @@ -0,0 +1,3 @@ +go test fuzz v1 +int(1) +[]byte("\xbe\xef\x00\x00\x00\x00000000\b\x00") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/c931a068613f8e16 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/c931a068613f8e16 new file mode 100644 index 0000000..c69022c --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/c931a068613f8e16 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00000000\x06000000\n\x00\x00\xff00\x00P00000000XB000000000\n0000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/ca9823eb82daec9a b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/ca9823eb82daec9a new file mode 100644 index 0000000..1d97880 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/ca9823eb82daec9a @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00000000\x06000000\n\x00\x00\xff00\x00P00000000XB000000\r\r\r00000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/cc6c777235685775 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/cc6c777235685775 new file mode 100644 index 0000000..3712402 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/cc6c777235685775 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(6) +[]byte("\xbe\xef\x00\x00\x00\xff00000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/ce4e95e144d2ba3a b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/ce4e95e144d2ba3a new file mode 100644 index 0000000..852740e --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/ce4e95e144d2ba3a @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00(\x00\x04@\x00@\x06%\xce\n\x00\x00\x00\n\x00\x00\xff\x059\x00P\x00\x10\xc0@\x00\x04 #P\a\x05ܯ\x02\x00\x00") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/ce835f162554eae4 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/ce835f162554eae4 new file mode 100644 index 0000000..6e23d54 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/ce835f162554eae4 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00000000\x06000000\n\x00\x00\xff00\x00P00000000XB00000000 0\n00") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/cf473be2ecb04ed9 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/cf473be2ecb04ed9 new file mode 100644 index 0000000..8cf10c4 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/cf473be2ecb04ed9 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(2) +[]byte("000000000000\b\x00E00000000\x060000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/d0bfcc849b413c1f b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/d0bfcc849b413c1f new file mode 100644 index 0000000..2889b52 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/d0bfcc849b413c1f @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00(00000\x06000000\n\x00\x00\xff00\x00P00000000X\xab000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/d2bf9d2b744c5cfe b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/d2bf9d2b744c5cfe new file mode 100644 index 0000000..17a685a --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/d2bf9d2b744c5cfe @@ -0,0 +1,3 @@ +go test fuzz v1 +int(2) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00'00000\x0600\n\x00\x00\x00\n\x00\x00\xff\x059\x00P\x00\a\xc0@\x00\x04\x00#P\x10\x05ݯ\x02 ") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/d4293d15fdd44f28 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/d4293d15fdd44f28 new file mode 100644 index 0000000..ce098ac --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/d4293d15fdd44f28 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x02000000\x06000000\n\x00\x00\xff00\x00P00000000XB000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\n000000000000000000000000000000000000000000000000000000000000: \n000000000000000000000000000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/d4f1a601a429ca78 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/d4f1a601a429ca78 new file mode 100644 index 0000000..16315c7 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/d4f1a601a429ca78 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00(00000\x0600\n\x00\x00\x00\n\x00\x00\xff\x059\x00P\x00\a\xc0?\xfa000X\x19000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/d69c7ec9b7be4852 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/d69c7ec9b7be4852 new file mode 100644 index 0000000..26ba7d8 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/d69c7ec9b7be4852 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x02000000\x06000000\n\x00\x00\xff00\x00P00000000XB000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\n000000000000000000000000000000000000000000000000000000000000:0\n 0000\n 00000000000000000000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/d710120c38620112 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/d710120c38620112 new file mode 100644 index 0000000..46f8414 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/d710120c38620112 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00000000\x06000000\n\x00\x00\xff00\x00P00000000XB00000000000\n0\n") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/d720e02374c902c3 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/d720e02374c902c3 new file mode 100644 index 0000000..d26f694 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/d720e02374c902c3 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x02000000\x06000000\n\x00\x00\xff00\x00P00000000\xf3B0000000\n000000000\x0300\x0300\x02\x01\x01\x01\x01\x01\x01\x01\x010\x0300\x0300\x03000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/db9a75ae42f34861 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/db9a75ae42f34861 new file mode 100644 index 0000000..77e1d78 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/db9a75ae42f34861 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00000000\x06000000\n\x00\x00\xff00\x00P00000000XB00000000000\n\n0") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/dbbc8d03fba1a531 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/dbbc8d03fba1a531 new file mode 100644 index 0000000..6c05a88 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/dbbc8d03fba1a531 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00 00000\xff000000\n\x00\x00\xff00000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/dcbaaf212c3f561a b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/dcbaaf212c3f561a new file mode 100644 index 0000000..081dbdb --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/dcbaaf212c3f561a @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00(\x00\x04@\x00@\x06%\xce\n\x00\x00\x00\n\x00\x00\xff\x059\x00P\x00\a\xc0?\x00\x04 #P\x10\xfaܵ\x02\x05\x00") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/dd5242384fbb1522 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/dd5242384fbb1522 new file mode 100644 index 0000000..01efba2 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/dd5242384fbb1522 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00000000\x06000000\n\x00\x00\xff00\x00P00000000aB000000\x04\x04000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/de78c27b764e5125 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/de78c27b764e5125 new file mode 100644 index 0000000..9f92f4c --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/de78c27b764e5125 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00(\x00\x04@\x00@\x06%\xce\n\x00\x00\x00\n\x00\x00\xff\x059\x00P\x00\x10\xc0@\x00\x04 #P\x02\x00\x00\xaf\xdc\x05\a") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/deced0a70ff9358e b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/deced0a70ff9358e new file mode 100644 index 0000000..880d2a4 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/deced0a70ff9358e @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x02000000\x06000000\n\x00\x00\xff00\x00P00000000\xf3B0000000000000000000000000000000000000000000000\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/e0a10ce609157d09 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/e0a10ce609157d09 new file mode 100644 index 0000000..c83aabb --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/e0a10ce609157d09 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x06") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/e102c4903a67269b b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/e102c4903a67269b new file mode 100644 index 0000000..c053d7b --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/e102c4903a67269b @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x060000000000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/e1813161fc53241e b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/e1813161fc53241e new file mode 100644 index 0000000..b24d424 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/e1813161fc53241e @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00(\x00\x04@\x00@\x06%\xce\n\x00\x00\x00\n\x00\x00\xff00000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/e60c7369bbfe9111 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/e60c7369bbfe9111 new file mode 100644 index 0000000..4abe363 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/e60c7369bbfe9111 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("0") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/e61499a0b70150e2 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/e61499a0b70150e2 new file mode 100644 index 0000000..9466ca7 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/e61499a0b70150e2 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00000000\x06000000\n\x00\x00\xff00\x00P00000000aB000000\x01\x02\x0200000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/e80a4c049b27ccfe b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/e80a4c049b27ccfe new file mode 100644 index 0000000..e52175c --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/e80a4c049b27ccfe @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x060000\x00\x000000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/e9e9a5120f70a605 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/e9e9a5120f70a605 new file mode 100644 index 0000000..1121307 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/e9e9a5120f70a605 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x02000000\x06000000\n\x00\x00\xff00\x00P00000000XB000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\n000000000000000000000000000000000000000000000000000000000000:0\n 00000000000000000000000000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/ea32d4c02d4a539f b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/ea32d4c02d4a539f new file mode 100644 index 0000000..2a10284 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/ea32d4c02d4a539f @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00(\x00\x04@\x00@\x06%\xce\n\x00\x00\x00\n\x00\x00\xff\x059\x00\x00\x00\x10\xc0@\x00\x04 #P\x02\x05ܯ\a\x00P") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/ead5dae0a3a1175d b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/ead5dae0a3a1175d new file mode 100644 index 0000000..c369b4c --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/ead5dae0a3a1175d @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00(\x00\x04@\x05@\x01%\xce\n\x00\x00\x00\n\x00\x00\xff00000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/eddd53a473c23f90 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/eddd53a473c23f90 new file mode 100644 index 0000000..beeef92 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/eddd53a473c23f90 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00000000\x06000000\n\x00\x00\xff00\x00P00000000XB000000\n\n000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/ef229893fc778237 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/ef229893fc778237 new file mode 100644 index 0000000..ec40230 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/ef229893fc778237 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00000000\x06000000\n\x00\x00\xff00\x00P00000000XB00000000000\n\r\n") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/efe90093d59f6819 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/efe90093d59f6819 new file mode 100644 index 0000000..6c2b351 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/efe90093d59f6819 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x02000000\x06000000\n\x00\x00\xff00\x00P00000000\xf3B0000000\n000000000\x0300\x030\x03\x030\x03\x030\x03\x030\x03\x030\x03\x030\x03\x030\x03\x030\x03\x030000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/f0682c5f3c91f3e6 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/f0682c5f3c91f3e6 new file mode 100644 index 0000000..b0eb3de --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/f0682c5f3c91f3e6 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x02000000\x06000000\n\x00\x00\xff00\x00P00000000XB00000000000\n000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000:00000000000000000000000000000000000000000000000000000000000\n000000000000000000000000000000000000000:0\n000000000000000000000000000000000000000000000000000000000000:0\n000000000000000000000000000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/f090ec6f663961a7 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/f090ec6f663961a7 new file mode 100644 index 0000000..b80d4cc --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/f090ec6f663961a7 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x06\x00\x0100\x00\x000000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/f1177ac50df037fb b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/f1177ac50df037fb new file mode 100644 index 0000000..7edab36 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/f1177ac50df037fb @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x02000000\x06000000\n\x00\x00\xff00\x00P00000000XB00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\n000000000000000000000000000000000000000000000000000000000000:0\n 0000\n 00000000000000000000000000000000000000000000000000000000000000000\n 0000\n 00000000000000000000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/f25cb169384e8c1e b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/f25cb169384e8c1e new file mode 100644 index 0000000..ca864dc --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/f25cb169384e8c1e @@ -0,0 +1,3 @@ +go test fuzz v1 +int(6) +[]byte("0") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/f3a4deacd097de54 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/f3a4deacd097de54 new file mode 100644 index 0000000..a572751 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/f3a4deacd097de54 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00(\x00\x04@\x05@o%`\n\x00\x00\x00\n\x00\x00\xff00000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/f461bd24486a92be b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/f461bd24486a92be new file mode 100644 index 0000000..9703223 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/f461bd24486a92be @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x02000000\x06000000\n\x00\x00\xff00\x00P00000000XB000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\n000000000000000000000000000000000000000000000000000000000000: 0000000000\n000000000000000000000000000000000000000000000000: 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\n000000000000000000000000000000000000000000000000000000000000: 0000000000\n000000000000000000000000000000000000000000000000: 0000000000\n0000000000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/f5abf4771627c0e7 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/f5abf4771627c0e7 new file mode 100644 index 0000000..ddfb185 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/f5abf4771627c0e7 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(2) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00(\x00\x04@\x00@\x11%\xc3\n\x00\x00\x00\n\x00\x00\xff0000\x00\x0000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/f5c23cc8b5729c94 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/f5c23cc8b5729c94 new file mode 100644 index 0000000..b496406 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/f5c23cc8b5729c94 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00000000\x06000000\n\x00\x00\xff00\x00P00000000aB000000\x01\b\x0200000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/f76385c8d8fcdbeb b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/f76385c8d8fcdbeb new file mode 100644 index 0000000..0e30dfb --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/f76385c8d8fcdbeb @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x02000000\x06000000\n\x00\x00\xff00\x00P00000000XB000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\n000000000000000000000000000000000000000000000000000000000000: 0000000000000000\n0000000000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/f8244fec867b6879 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/f8244fec867b6879 new file mode 100644 index 0000000..d97b652 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/f8244fec867b6879 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/f84591800c501277 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/f84591800c501277 new file mode 100644 index 0000000..4ddb412 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/f84591800c501277 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x02000000\x06000000\n\x00\x00\xff00\x00P00000000XB00000000000\n0000000000000000:0000000000000000000000000000000000000000000000000000000000\r\n00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000:0000000000000000000000000000000000000000000000000000000000\r\n00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/facaca1c4d5bc72c b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/facaca1c4d5bc72c new file mode 100644 index 0000000..c5f1e9b --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/facaca1c4d5bc72c @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00000000\x06000000\n\x00\x00\xff00\x00P00000000XB00000000000\n00") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/fc43e9028cd810d0 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/fc43e9028cd810d0 new file mode 100644 index 0000000..b557ad7 --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/fc43e9028cd810d0 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(3) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E0\x00)00000\x0600\n\x00\x00\x00\n\x00\x00\xff\x059\x00P\x00\a\xc0?0000XA0000000") diff --git a/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/ff5d241908bbd215 b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/ff5d241908bbd215 new file mode 100644 index 0000000..92b9d9f --- /dev/null +++ b/x/xnet/testdata/fuzz/FuzzStackAsyncHTTP/ff5d241908bbd215 @@ -0,0 +1,3 @@ +go test fuzz v1 +int(0) +[]byte("\xbe\xef\x00\x00\x00\xff000000\b\x00E\x00\x00(\x00\x04@\x00@\x06%\xce\n\x00\x00\x00\n\x00\x00\xff\x059\x00P\x00\x10\xc0\x00\x00\x04 #PB\x05ܯ\a\x00\x00") diff --git a/x/xnet/xnet_fuzz_test.go b/x/xnet/xnet_fuzz_test.go index d7cecb5..c8a1c1b 100644 --- a/x/xnet/xnet_fuzz_test.go +++ b/x/xnet/xnet_fuzz_test.go @@ -4,8 +4,10 @@ import ( "net/netip" "testing" + "github.com/soypat/lneto" "github.com/soypat/lneto/ethernet" "github.com/soypat/lneto/http/httpraw" + "github.com/soypat/lneto/ipv4" "github.com/soypat/lneto/tcp" ) @@ -93,6 +95,7 @@ func FuzzStackAsyncHTTP(f *testing.F) { if n1 > 0 { if pkt == pktnum { n1 = copy(buf[:], a) + fixIPTCPCRCs(buf[:n1]) } s2.Demux(buf[:n1], 0) pkt++ @@ -105,6 +108,7 @@ func FuzzStackAsyncHTTP(f *testing.F) { if n2 > 0 { if pkt == pktnum { n2 = copy(buf[:], a) + fixIPTCPCRCs(buf[:n2]) } pkt++ s1.Demux(buf[:n2], 0) @@ -129,3 +133,40 @@ func FuzzStackAsyncHTTP(f *testing.F) { } }) } + +// fixIPTCPCRCs corrects CRCs of IP and TCP headers so that +// fuzzed packets are not discarded 99.9999% of the time. +func fixIPTCPCRCs(pkt []byte) (fixable bool) { + efrm, err := ethernet.NewFrame(pkt) + if err != nil || efrm.EtherTypeOrSize() != ethernet.TypeIPv4 { + return false + } + ifrm, err := ipv4.NewFrame(efrm.Payload()) + if err != nil { + return false + } + v, ihl := ifrm.VersionAndIHL() + tl := ifrm.TotalLength() + if v != 4 || ihl < 5 || tl < uint16(ihl)*4 || int(tl) > len(pkt) { + return false // Invalid frame + } + var crc lneto.CRC791 + ifrm.SetCRC(0) + ifrm.CRCWriteHeader(&crc) + ifrm.SetCRC(crc.Sum16()) + if ifrm.Protocol() != lneto.IPProtoTCP { + return false + } + IPpayload := ifrm.Payload() + tfrm, err := tcp.NewFrame(IPpayload) + if err != nil { + return false + } + crc.Reset() + ifrm.CRCWriteTCPPseudo(&crc) + // Zero the CRC field so its value does not add to the final result. + tfrm.SetCRC(0) + crcValue := crc.PayloadSum16(IPpayload) + tfrm.SetCRC(crcValue) + return true +}