I imitated part of the code of the tun2sockets protocol stack, and used ab to test the number of new connections, but gvisor crashed, can you give me some help?

[wzyxdwll]

The comments say that TCP is not SYN-SENT or SYN-RECV, and *handshark is nil, but I don’t know why this happens. The following is my code, can you give me some pointers?

type Netstack struct {
	s              *stack.Stack
	endpoint       *channel.Endpoint
	acceptQueue    chan net.Conn
	packetQueue    chan *N.Packet
	tupeToEndpoint sync.Map
	ctx            Ctx.Context
	log            logger.CtxLoggerApi
}

func NewNetstack(ctx Ctx.Context) *Netstack {
	n := &Netstack{
		ctx:         ctx,
		log:         ctx.NewLogger(),
		acceptQueue: make(chan net.Conn, DEFAULT_SIZE/10),
		packetQueue: make(chan *N.Packet, DEFAULT_SIZE),
	}

	return n
}

func (n *Netstack) getEndpoint(p *N.Packet) *channel.Endpoint {
	v, ok := n.tupeToEndpoint.Load(p.Tuple)
	if ok {
		return v.(*channel.Endpoint)
	}

	e := n.endpoint
	n.tupeToEndpoint.Store(p.Tuple, e)

	return e
}

func (n *Netstack) WriteIPPacket(p *N.Packet) error {
	ep := n.getEndpoint(p)

	if !ep.IsAttached() {
		return fmt.Errorf("wirte ip packet: [%s] error, cannot attached gvisor endpoint", p.String())
	}

	pkt := stack.NewPacketBuffer(stack.PacketBufferOptions{
		Payload: buffer.MakeWithData(p.Buf),
	})

	ep.InjectInbound(ipv4.ProtocolNumber, pkt)
	pkt.DecRef()

	return nil
}

func (n *Netstack) ReadIPPacket() (*N.Packet, error) {
	p := <-n.packetQueue
	return p, nil
}

func (n *Netstack) Accept() (net.Conn, error) {
	conn := <-n.acceptQueue
	return conn, nil
}

func (n *Netstack) InitNetstatck() error {

	opts := stack.Options{
		NetworkProtocols: []stack.NetworkProtocolFactory{
			ipv4.NewProtocol,
			ipv6.NewProtocol,
		},
		TransportProtocols: []stack.TransportProtocolFactory{
			tcp.NewProtocol,
		},
	}

	// 初始化协议栈
	n.s = stack.New(opts)

	// 初始化ncid
	nicID := tcpip.NICID(n.s.UniqueID())

	// 设置网络协议栈选项
	ops := []Option{WithDefault()}
	for _, op := range ops {
		_ = op(n.s)
	}

	opt := tcpip.TCPModerateReceiveBufferOption(true)

	if err := n.s.SetTransportProtocolOption(tcp.ProtocolNumber, &opt); err != nil {
		return fmt.Errorf("init netstack failed, err: %v", err)
	}

	// 设置路由表
	router := tcpip.Route{
		Destination: header.IPv4EmptySubnet,
		//Destination: subnetForRouter,
		NIC: nicID,
	}
	n.s.SetRouteTable([]tcpip.Route{router})

	n.endpoint = channel.New(DEFAULT_SIZE, DEFAULT_MTU, DEFAULT_MAC)

	var wq waiter.Queue

	forwarder := tcp.NewForwarder(n.s, 10*1024*1024, 2<<10, func(r *tcp.ForwarderRequest) {
		var (
			ep  tcpip.Endpoint
			err tcpip.Error
			// id  := r.ID()
		)

		ep, err = r.CreateEndpoint(&wq)
		if err != nil {
			r.Complete(true)
			return
		}
		defer r.Complete(false)

		conn := gonet.NewTCPConn(&wq, ep)
		n.acceptQueue <- conn

	})

	n.s.SetNICForwarding(nicID, ipv4.ProtocolNumber, true)
	// s.s[i].SetForwardingDefaultAndAllNICs(ipv4.ProtocolNumber, true)
	n.s.SetTransportProtocolHandler(tcp.ProtocolNumber, forwarder.HandlePacket)
	e := n.s.CreateNICWithOptions(nicID, n.endpoint, stack.NICOptions{
		Disabled: false,
		QDisc:    nil,
	})
	n.s.EnableNIC(nicID)
	if e != nil {
		return fmt.Errorf("init netstarck failed, err: %s", e.String())
	}
	n.s.SetSpoofing(nicID, true)
	n.s.SetPromiscuousMode(nicID, true)
	go n.readIPPacketLoop()

	return nil
}

func (n *Netstack) readIPPacketLoop() {
	for {
		pkt := n.endpoint.ReadContext(context.TODO())
		b := pkt.ToView()

		pkt.DecRef()
		p, err := N.Parse(b.AsSlice())
		if err != nil {
			n.log.Warn(tag, logger.WHAT("netstack read ip packet buf failed"),
				logger.REASON("packet buf parse err: %v", err))
			continue
		}

		select {
		case n.packetQueue <- p:
		default:
		}
	}
}

[xjasonlyu]

Hi, please use English in Discussions.

[wzyxdwll]

sorry, i translated it use english