端口管理器 和 传输层 基础框架

tcpip/stack/nic.go

@@ -344,7 +344,7 @@ func (n *NIC) getRef(protocol tcpip.NetworkProtocolNumber, dst tcpip.Address) *r
 	return nil
 }
 
-// 当 NIC 从物理接口接收数据包时，将调用函数 DeliverNetworkPacket，用来分发网络层数据包。
+// DeliverNetworkPacket 当 NIC 从物理接口接收数据包时，将调用函数 DeliverNetworkPacket，用来分发网络层数据包。
 // 比如 protocol 是 arp 协议号，那么会找到arp.HandlePacket来处理数据报。
 // 简单来说就是根据网络层协议和目的地址来找到相应的网络层端，将网络层数据发给它，
 // 当前实现的网络层协议有 arp、ipv4 和 ipv6。
@@ -387,9 +387,13 @@ func (n *NIC) DeliverNetworkPacket(linkEP LinkEndpoint, remoteLinkAddr, localLin
 // DeliverTransportPacket delivers packets to the appropriate
 // transport protocol endpoint.
 func (n *NIC) DeliverTransportPacket(r *Route, protocol tcpip.TransportProtocolNumber, vv buffer.VectorisedView) {
-	log.Println("准备分发传输层数据报")
-	hdr := buffer.NewPrependable(header.EthernetMinimumSize + header.IPv4MinimumSize)
-	r.ref.ep.WritePacket(r, hdr, vv, protocol, 255)
+	// 先查找协议栈是否注册了该传输层协议
+	_, ok := n.stack.transportProtocols[protocol]
+	if !ok {
+		n.stack.stats.UnknownProtocolRcvdPackets.Increment()
+		return
+	}
+	log.Println("准备分发传输层数据报", n.stack.transportProtocols)
 
 }
 

tcpip/stack/registration.go

@@ -4,6 +4,7 @@ import (
 	"netstack/sleep"
 	"netstack/tcpip"
 	"netstack/tcpip/buffer"
+	"netstack/waiter"
 	"sync"
 )
 
@@ -88,14 +89,16 @@ type NetworkDispatcher interface {
 
 type LinkEndpointCapabilities uint
 
-// type TransportProtocolFactory func() TransportProtocol TODO
+// TransportProtocolFactory 传输层实现工厂
+type TransportProtocolFactory func() TransportProtocol
 
+// NetworkProtocolFactory 网络层实现工厂
 type NetworkProtocolFactory func() NetworkProtocol
 
 var (
 	// 以下两个map需要在init函数中注册
-	// 传输层协议的注册存储结构 TODO
-	//transportProtocols = make(map[string]TransportProtocolFactory)
+	// 传输层协议的注册存储结构
+	transportProtocols = make(map[string]TransportProtocolFactory)
 	// 网络层协议的注册存储结构
 	networkProtocols = make(map[string]NetworkProtocolFactory)
 
@@ -191,17 +194,49 @@ const (
 	ControlUnknown
 )
 
-// TODO 需要解读
+// TransportEndpoint 传输层实现接口
 type TransportEndpoint interface {
 	HandlePacket(r *Route, id TransportEndpointID, vv buffer.VectorisedView)
 	HandleControlPacker(id TransportEndpointID, typ ControlType, extra uint32, vv buffer.VectorisedView)
 }
 
-// 传输层协议 TCP OR UDP
+// TransportProtocol 传输层协议 TCP OR UDP
 type TransportProtocol interface {
+	// Number returns the transport protocol number.
+	Number() tcpip.TransportProtocolNumber
+
+	// NewEndpoint creates a new endpoint of the transport protocol.
+	NewEndpoint(stack *Stack, netProto tcpip.NetworkProtocolNumber, waitQueue *waiter.Queue) (tcpip.Endpoint, *tcpip.Error)
+
+	// MinimumPacketSize returns the minimum valid packet size of this
+	// transport protocol. The stack automatically drops any packets smaller
+	// than this targeted at this protocol.
+	MinimumPacketSize() int
+
+	// ParsePorts returns the source and destination ports stored in a
+	// packet of this protocol.
+	ParsePorts(v buffer.View) (src, dst uint16, err *tcpip.Error)
+
+	// HandleUnknownDestinationPacket handles packets targeted at this
+	// protocol but that don't match any existing endpoint. For example,
+	// it is targeted at a port that have no listeners.
+	//
+	// The return value indicates whether the packet was well-formed (for
+	// stats purposes only).
+	HandleUnknownDestinationPacket(r *Route, id TransportEndpointID, vv buffer.VectorisedView) bool
+
+	// SetOption allows enabling/disabling protocol specific features.
+	// SetOption returns an error if the option is not supported or the
+	// provided option value is invalid.
+	SetOption(option interface{}) *tcpip.Error
+
+	// Option allows retrieving protocol specific option values.
+	// Option returns an error if the option is not supported or the
+	// provided option value is invalid.
+	Option(option interface{}) *tcpip.Error
 }
 
-// 传输层调度器
+// TransportDispatcher 传输层调度器
 type TransportDispatcher interface {
 	// DeliverTransportPacket delivers packets to the appropriate
 	// transport protocol endpoint.
@@ -213,12 +248,17 @@ type TransportDispatcher interface {
 		trans tcpip.TransportProtocolNumber, typ ControlType, extra uint32, vv buffer.VectorisedView)
 }
 
-// 注册一个新的网络协议工厂
+// RegisterTransportProtocolFactory 注册一个新的传输层协议工厂
+func RegisterTransportProtocolFactory(name string, p TransportProtocolFactory) {
+	transportProtocols[name] = p
+}
+
+// RegisterNetworkProtocolFactory 注册一个新的网络协议工厂
 func RegisterNetworkProtocolFactory(name string, p NetworkProtocolFactory) {
 	networkProtocols[name] = p
 }
 
-// 注册一个链路层设备
+// RegisterLinkEndpoint 注册一个链路层设备
 func RegisterLinkEndpoint(linkEP LinkEndpoint) tcpip.LinkEndpointID {
 	linkEPMu.Lock()
 	defer linkEPMu.Unlock()

tcpip/stack/stack.go

@@ -4,7 +4,9 @@ import (
 	"log"
 	"netstack/sleep"
 	"netstack/tcpip"
+	"netstack/tcpip/buffer"
 	"netstack/tcpip/ports"
+	"netstack/waiter"
 	"sync"
 	"time"
 )
@@ -26,14 +28,17 @@ type TcpEndpointState struct {
 	// TODO 需要添加
 }
 
+// 传输层协议状态机 包含传输层协议以及默认处理方法
 type transportProtocolState struct {
+	proto          TransportProtocol
+	defaultHandler func(*Route, TransportEndpointID, buffer.VectorisedView) bool
 }
 
 // Stack 是一个网络堆栈，具有所有支持的协议、NIC 和路由表。
 type Stack struct {
 	transportProtocols map[tcpip.TransportProtocolNumber]*transportProtocolState // 各种传输层协议
 	networkProtocols   map[tcpip.NetworkProtocolNumber]NetworkProtocol           // 各种网络层协议
-	linkAddrResolvers  map[tcpip.NetworkProtocolNumber]LinkAddressResolver       // 各种传输层协议
+	linkAddrResolvers  map[tcpip.NetworkProtocolNumber]LinkAddressResolver       // 各种链接解析器
 
 	demux *transportDemuxer // 传输层的复用器
 
@@ -83,9 +88,9 @@ func New(network []string, transport []string, opts Options) *Stack {
 		linkAddrResolvers:  make(map[tcpip.NetworkProtocolNumber]LinkAddressResolver),
 		nics:               make(map[tcpip.NICID]*NIC),
 		linkAddrCache:      newLinkAddrCache(ageLimit, resolutionTimeout, resolutionAttempts),
-		//PortManager:        ports.NewPortManager(),
-		clock: clock,
-		stats: opts.Stats.FillIn(),
+		PortManager:        ports.NewPortManager(),
+		clock:              clock,
+		stats:              opts.Stats.FillIn(),
 	}
 
 	// 添加指定的网络端协议 必须已经在init中注册过
@@ -100,7 +105,17 @@ func New(network []string, transport []string, opts Options) *Stack {
 	}
 
 	// 添加指定的传输层协议 必已经在init中注册过
-	// TODO
+	for _, name := range transport {
+		transProtoFactory, ok := transportProtocols[name]
+		if !ok {
+			continue
+		}
+		transProto := transProtoFactory() // 新建一个传输层协议
+		s.transportProtocols[transProto.Number()] = &transportProtocolState{
+			proto: transProto,
+		}
+	}
+	// TODO 添加传输层分流器
 	return s
 }
 
@@ -140,6 +155,17 @@ func (s *Stack) GetRouteTable() []tcpip.Route {
 	return append([]tcpip.Route(nil), s.routeTable...)
 }
 
+// NewEndpoint 根据给定的网络层协议号和传输层协议号新建一个传输层实现
+func (s *Stack) NewEndpoint(transport tcpip.TransportProtocolNumber,
+	network tcpip.NetworkProtocolNumber, waiterQueue *waiter.Queue) (tcpip.Endpoint, *tcpip.Error) {
+	t, ok := s.transportProtocols[transport]
+	if !ok {
+		return nil, tcpip.ErrUnknownProtocol
+	}
+	return t.proto.NewEndpoint(s, network, waiterQueue)
+}
+
+// CreateNIC 根据给定的网卡号 和 链路层设备号 创建一个网卡对象
 func (s *Stack) CreateNIC(id tcpip.NICID, linkEP tcpip.LinkEndpointID) *tcpip.Error {
 	return s.createNIC(id, "", linkEP, true)
 }