Detaillierte Erklärung der Socket (TCP)-Bindung aus dem Linux-Quellcode

void start_server(){
    // Server-FD
    int sockfd_server;
    // FD akzeptieren 
    int sockfd;
    int call_err;
    Struktur sockaddr_in sock_addr;

    sockfd_server = socket(AF_INET,SOCK_STREAM,0);
    memset(&sock_addr,0,Größevon(sock_addr));
    sock_addr.sin_family = AF_INET;
    sock_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    sock_addr.sin_port = htons(SERVER_PORT);
    // Das ist unser heutiger Fokus, binden
    call_err = binden(sockfd_server, (Struktur sockaddr*)(&sock_addr), Größe von(sock_addr));
    wenn(call_err == -1){
        fprintf(stdout,"Bindungsfehler!\n");
        Ausgang (1);
    }
    // Hören
    call_err = abhören(sockfd_server,MAX_BACK_LOG);
    wenn(call_err == -1){
        fprintf(stdout,"Abhörfehler!\n");
        Ausgang (1);
    }
}

#include <sys/socket.h>
// Gibt 0 zurück, wenn erfolgreich, -1, wenn ein Fehler auftritt
int bind(int sockfd, const struct sockaddr *myaddr, socklen_t addrlen);

// Das System wählt zufällig eine verfügbare Portnummer aus sock_addr.sin_port = 0;
call_err = binden(sockfd_server, (Struktur sockaddr*)(&sock_addr), Größe von(sock_addr));

// Wenn snum als 0 angegeben ist, wird ein Port zufällig ausgewählt inet_csk_get_port(struct sock *sk, unsigned short snum)
{
	......
	// Hier verwendet net_random() prandom_u32, eine Pseudozufallszahl smallest_rover = rover = net_random() % remainder + low;
	kleinste_Größe = -1;
	// snum=0, wähle den Zweig des Ports zufällig aus, wenn (!sum) {
		// Den vom Kernel festgelegten Portnummernbereich abrufen, der dem Kernelparameter /proc/sys/net/ipv4/ip_local_port_range entspricht 
		inet_get_local_port_range(&niedrig,&hoch);
		......
		Tun{
			wenn (inet_ist_reservierter_lokaler_Port(rover)
				goto next_nonlock; // Wählen Sie nicht die reservierte Portnummer aus......
			inet_bind_bucket_for_each(tb, &Kopf->Kette)
				// Derselbe Port wie der Port Rover, den Sie auswählen möchten, existiert im selben Netzwerk-Namespace
				wenn (net_eq(ib_net(tb), net) und tb->port == Rover) {
					// Sowohl beim bestehenden als auch beim neuen Sock ist SO_REUSEADDR aktiviert und der aktuelle Sock-Status lautet „Nicht zuhören“
					// oder // Sowohl der vorhandene Sock als auch der neue Sock haben SO_REUSEPORT aktiviert und beide sind derselbe Benutzer, wenn (((tb->fastreuse > 0 &&
					      sk->sk_reuse &&
					      sk->sk_state != TCP_LISTEN) ||
					     (tb->Fastreueport > 0 &&
					      sk->sk_reuseport &&
					      uid_eq(tb->fastuid, uid))) &&
					    (tb->Anzahl_Besitzer < kleinste_Größe || kleinste_Größe == -1)) {
					   // Hier wählen wir einen Port mit den kleinsten num_owners aus, also einen Port mit der geringsten Anzahl gleichzeitiger Bind- oder Listen-Anfragen
					   // Weil eine Portnummer (Port) von mehreren Prozessen gleichzeitig verwendet werden kann, nachdem so_reuseaddr/so_reuseport aktiviert wurde, smallest_size = tb->num_owners;
						kleinster_rover = Rover;
						wenn (atomic_read(&hashinfo->bsockets) > (hoch - niedrig) + 1 &&
						    !inet_csk(sk)->icsk_af_ops->bind_conflict(sk, tb, false)) {
						    // Das Betreten dieses Zweigs zeigt an, dass die verfügbare Portnummer nicht ausreicht. Gleichzeitig steht die aktuelle Portnummer nicht im Konflikt mit dem zuvor verwendeten Port, daher wählen wir diese Portnummer (die kleinste).
							snum = kleinster_rover;
							gehe zu tb_found;
						}
					}
					// Wenn die Portnummer keinen Konflikt verursacht, wähle diesen Port aus, if (!inet_csk(sk)->icsk_af_ops->bind_conflict(sk, tb, false)) {
						snum = Rover;
						gehe zu tb_found;
					}
					gehe zum nächsten;
				}
			brechen;
			// Bis alle verfügbaren Ports durchlaufen sind
		} während (--restlich > 0);
	}
	.......
}

habe_snum:
	inet_bind_bucket_for_each(tb, &Kopf->Kette)
			wenn (net_eq(ib_net(tb), net) und tb->port == snum)
				gehe zu tb_found;
	}
	tb = NULL;
	gehe zu tb_not_found
tb_gefunden:
	// Wenn dieser Port gebunden wurde
	wenn (!hlist_empty(&tb->owners)) {
		// Wenn auf erzwungene Wiederverwendung eingestellt, ist es direkt erfolgreich, wenn (sk->sk_reuse == SK_FORCE_REUSE)
			gehe zum Erfolg;
	}
	wenn (((tb->fastreuse > 0 &&
		      sk->sk_reuse und sk->sk_state != TCP_LISTEN) ||
		     (tb->Fastreueport > 0 &&
		      sk->sk_reuseport && uid_eq(tb->fastuid, uid))) &&
		    kleinste_Größe == -1) {
		    // Dieser Zweig zeigt an, dass der zuvor gebundene Port und der aktuelle Sock beide auf Wiederverwendung eingestellt sind und der aktuelle Sock-Status nicht abhört
			// Oder sowohl Reuseport als auch UID werden gleichzeitig festgelegt (beachten Sie, dass Sie nach dem Festlegen von Reuseport gleichzeitig auf demselben Port lauschen können).
			gehe zum Erfolg;
	} anders {
			ret = 1;
			// Überprüfen Sie, ob ein Portkonflikt vorliegt, if (inet_csk(sk)->icsk_af_ops->bind_conflict(sk, tb, true)) {
				wenn (((sk->sk_reuse && sk->sk_state != TCP_LISTEN) ||
				     (tb->Fastreueport > 0 &&
				      sk->sk_reuseport && uid_eq(tb->fastuid, uid))) &&
				    kleinste_Größe != -1 und --Versuche >= 0) {
				    // Wenn ein Konflikt vorliegt, aber der Reuse-Nicht-Listen-Status gesetzt ist oder der Reuse-Port gesetzt ist und es sich um denselben Benutzer handelt, // können Sie spin_unlock(&head->lock); erneut versuchen.
					gehe nochmal zu;
				}

				gehe zu fail_unlock;
			}
			// Kein Konflikt, folgen Sie der folgenden Logik }
tb_nicht_gefunden:
	wenn (!tb && (tb = inet_bind_bucket_create(hashinfo->bind_bucket_cachep,
					net, head, snum)) == NULL)
			gehe zu fail_unlock;
	// Fastreuse einrichten
	//Fastreuseport festlegen
Erfolg:
	......
	// Verknüpfen Sie den aktuellen Sock mit tb->owner und tb->num_owners++
	inet_bind_hash(sk, tb, snum);
	ret = 0;
	// Gib Bind (Bindung) erfolgreich zurück return ret;

inet_csk(sk)->icsk_af_ops->bind_conflict, auch bekannt als inet_csk_bind_conflict
int inet_csk_bind_conflict(const struct sock *sk,
			   const struct inet_bind_bucket *tb, bool relax){
	......
	sk_for_each_bound(sk2, &tb->Besitzer) {
			// Diese Beurteilung zeigt, dass für den nächsten internen Zweig dieselbe Schnittstelle (dev_if) verwendet werden muss, d. h. Ports, die sich nicht auf derselben Schnittstelle befinden, geraten nicht in Konflikt, wenn (sk != sk2 &&
		    !inet_v6_ipv6only(sk2) &&
		    (!sk->sk_bound_dev_if ||
		     !sk2->sk_bound_dev_if ||
		     sk->sk_bound_dev_if == sk2->sk_bound_dev_if)) 
		     {
		     	wenn ((!wiederverwenden || !sk2->sk_wiederverwenden ||
			    sk2->sk_state == TCP_LISTEN) &&
			    (!reuseport || !sk2->sk_reuseport ||
			    (sk2->sk_state != TCP_TIME_WAIT &&
			     !uid_eq(uid, sock_i_uid(sk2))))) {
			   // Wenn eine Partei die Wiederverwendung nicht festlegt und Sock2 sich im Listenzustand befindet // Gleichzeitig legt eine Partei den Wiederverwendungsport nicht fest und Sock2 befindet sich nicht im Time_Wait-Zustand und die UIDs der beiden sind unterschiedlich const __be32 sk2_rcv_saddr = sk_rcv_saddr(sk2);
				wenn (!sk2_rcv_saddr || !sk_rcv_saddr(sk) ||
				 	 // Die IP-Adressen sind gleich, was als Konflikt betrachtet wird sk2_rcv_saddr == sk_rcv_saddr(sk))
					brechen;
			}
			// Im nicht entspannten Modus wird es nur dann als Konflikt betrachtet, wenn die IP-Adressen gleich sind …
		  	gibt sk2 zurück != NULL;
	}
	......
}

 setockopt(sockfd_server, SOL_SOCKET, SO_REUSEADDR, &(int){ 1 }, sizeof(int));
 setsockopt(sockfd_server, SOL_SOCKET, SO_REUSEPORT, &(int){ 1 }, sizeof(int));

 // In Java 8 unterstützen native Sockets so_reuseport nicht
 ServerSocket-Server = neuer ServerSocket(Port);
 server.setReuseAddress(true);

(!wiederverwenden || !sk2->sk_wiederverwenden ||
			    sk2->sk_state == TCP_LISTEN) /* Reuseport vorübergehend ignorieren */){
	//Eine Partei hat es nicht festgelegt}

wenn(!reuseport || !sk2->sk_reuseport ||
			    (sk2->sk_state != TCP_TIME_WAIT &&
			     !uid_eq(uid, sock_i_uid(sk2))

tcp_v4_rcv
	|->__inet_lookup_skb 
		|->__inet_lookup
			|->__inet_lookup_listener
 /* Verwende Punkte und Pseudozufallszahlen, um einen Listen-Sock auszuwählen */
Struktur sock *__inet_lookup_listener(......)
{
	......
	wenn (Punktzahl > höchster Punktestand) {
			Ergebnis = sk;
			hiscore = Punktzahl;
			Wiederverwendungsport = sk->sk_wiederverwendungsport;
			if (Wiederverwendungsport) {
				phash = inet_ehashfn(net, daddr, hnum,
						     saddr, Sport);
				Übereinstimmungen = 1;
			}
		} sonst wenn (Punktzahl == Höchstpunktzahl && Wiederverwendungsbericht) {
			Streichhölzer++;
			wenn (((u64)phash * übereinstimmt) >> 32 == 0)
				Ergebnis = sk;
			phash = nächster_pseudo_random32(phash);
		}
	......
}

http {
     Server {
          hören Sie 80 Wiederverwendungsport;
          Servername localhost;
          # ...
     }
}

Strom {
     Server {
          hören Sie 12345 Wiederverwendungsport;
          # ...
     }
}