Detailed explanation of Socket (TCP) bind from Linux source code

void start_server(){
    // server fd
    int sockfd_server;
    // accept fd 
    int sockfd;
    int call_err;
    struct sockaddr_in sock_addr;

    sockfd_server = socket(AF_INET,SOCK_STREAM,0);
    memset(&sock_addr,0,sizeof(sock_addr));
    sock_addr.sin_family = AF_INET;
    sock_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    sock_addr.sin_port = htons(SERVER_PORT);
    // This is our focus today, bind
    call_err = bind(sockfd_server, (struct sockaddr*)(&sock_addr), sizeof(sock_addr));
    if(call_err == -1){
        fprintf(stdout,"bind error!\n");
        exit(1);
    }
    // listen
    call_err = listen(sockfd_server,MAX_BACK_LOG);
    if(call_err == -1){
        fprintf(stdout,"listen error!\n");
        exit(1);
    }
}

#include <sys/socket.h>
// Returns 0 if successful, -1 if an error occurs
int bind(int sockfd, const struct sockaddr *myaddr, socklen_t addrlen);

// Let the system randomly select an available port number sock_addr.sin_port = 0;
call_err = bind(sockfd_server, (struct sockaddr*)(&sock_addr), sizeof(sock_addr));

// If snum is specified as 0, a port is randomly selected inet_csk_get_port(struct sock *sk, unsigned short snum)
{
	......
	// Here net_random() uses prandom_u32, which is a pseudo random number smallest_rover = rover = net_random() % remaining + low;
	smallest_size = -1;
	// snum=0, randomly select the branch of the port if(!sum){
		// Get the port number range set by the kernel, corresponding to the kernel parameter /proc/sys/net/ipv4/ip_local_port_range 
		inet_get_local_port_range(&low,&high);
		......
		do{
			if(inet_is_reserved_local_port(rover)
				goto next_nonlock; // Do not select the reserved port number......
			inet_bind_bucket_for_each(tb, &head->chain)
				// The same port as the port rover you want to select exists in the same network namespace
				if (net_eq(ib_net(tb), net) && tb->port == rover) {
					// Both the existing sock and the new sock have SO_REUSEADDR enabled, and the current sock status is not listen
					// or // The existing sock and the new sock both have SO_REUSEPORT enabled, and both are the same user if (((tb->fastreuse > 0 &&
					      sk->sk_reuse &&
					      sk->sk_state != TCP_LISTEN) ||
					     (tb->fastreuseport > 0 &&
					      sk->sk_reuseport &&
					      uid_eq(tb->fastuid, uid))) &&
					    (tb->num_owners < smallest_size || smallest_size == -1)) {
					   // Here we select a port with the smallest num_owners, that is, a port with the smallest number of simultaneous bind or listen requests
					   // Because a port number (port) can be used by multiple processes at the same time after so_reuseaddr/so_reuseport is enabled smallest_size = tb->num_owners;
						smallest_rover = rover;
						if (atomic_read(&hashinfo->bsockets) > (high - low) + 1 &&
						    !inet_csk(sk)->icsk_af_ops->bind_conflict(sk, tb, false)) {
						    // Entering this branch indicates that the available port number is insufficient. At the same time, the current port number does not conflict with the previously used port, so we choose this port number (the smallest one)
							snum = smallest_rover;
							goto tb_found;
						}
					}
					// If the port number does not conflict, select this port if (!inet_csk(sk)->icsk_af_ops->bind_conflict(sk, tb, false)) {
						snum = rover;
						goto tb_found;
					}
					goto next;
				}
			break;
			// Until all available ports are traversed
		} while (--remaining > 0);
	}
	.......
}

have_snum:
	inet_bind_bucket_for_each(tb, &head->chain)
			if (net_eq(ib_net(tb), net) && tb->port == snum)
				goto tb_found;
	}
	tb = NULL;
	goto tb_not_found
tb_found:
	// If this port has been bound
	if (!hlist_empty(&tb->owners)) {
		// If set to force reuse, it will succeed directly if (sk->sk_reuse == SK_FORCE_REUSE)
			goto success;
	}
	if (((tb->fastreuse > 0 &&
		      sk->sk_reuse && sk->sk_state != TCP_LISTEN) ||
		     (tb->fastreuseport > 0 &&
		      sk->sk_reuseport && uid_eq(tb->fastuid, uid))) &&
		    smallest_size == -1) {
		    // This branch indicates that the previously bound port and the current sock are both set to reuse and the current sock state is not listen
			// Or both reuseport and uid are set at the same time (note that after setting reuseport, you can listen to the same port at the same time)
			goto success;
	} else {
			ret = 1;
			// Check if the port conflicts if (inet_csk(sk)->icsk_af_ops->bind_conflict(sk, tb, true)) {
				if (((sk->sk_reuse && sk->sk_state != TCP_LISTEN) ||
				     (tb->fastreuseport > 0 &&
				      sk->sk_reuseport && uid_eq(tb->fastuid, uid))) &&
				    smallest_size != -1 && --attempts >= 0) {
				    // If there is a conflict, but the reuse non-listen state is set or the reuseport is set and it is under the same user // then you can retry spin_unlock(&head->lock);
					goto again;
				}

				goto fail_unlock;
			}
			// No conflict, follow the following logic }
tb_not_found:
	if (!tb && (tb = inet_bind_bucket_create(hashinfo->bind_bucket_cachep,
					net, head, snum)) == NULL)
			goto fail_unlock;
	// Set up fastreuse
	//Set fastreuseport
success:
	......
	// Link the current sock to tb->owner, and tb->num_owners++
	inet_bind_hash(sk, tb, snum);
	ret = 0;
	// Return bind (binding) success return ret;

inet_csk(sk)->icsk_af_ops->bind_conflict, also known as 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->owners) {
			// This judgment shows that the same interface (dev_if) must be used to enter the next internal branch, that is, ports that are not on the same interface do not conflict if (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)) 
		     {
		     	if ((!reuse || !sk2->sk_reuse ||
			    sk2->sk_state == TCP_LISTEN) &&
			    (!reuseport || !sk2->sk_reuseport ||
			    (sk2->sk_state != TCP_TIME_WAIT &&
			     !uid_eq(uid, sock_i_uid(sk2))))) {
			   // When one party does not set reuse and sock2 is in listen state // At the same time, one party does not set reuseport and sock2 is not in time_wait state and the uids of the two are different const __be32 sk2_rcv_saddr = sk_rcv_saddr(sk2);
				if (!sk2_rcv_saddr || !sk_rcv_saddr(sk) ||
				 	 // The IP addresses are the same, which is considered a conflict sk2_rcv_saddr == sk_rcv_saddr(sk))
					break;
			}
			// In non-relaxed mode, only when the IP addresses are the same will it be considered a conflict......
		  	return sk2 != NULL;
	}
	......
}

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

 // In Java 8, native sockets do not support so_reuseport
 ServerSocket server = new ServerSocket(port);
 server.setReuseAddress(true);

(!reuse || !sk2->sk_reuse ||
			    sk2->sk_state == TCP_LISTEN) /* temporarily ignore reuseport */){
	// One party has not set it}

if(!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
 /* Use scoring and pseudo-random numbers to select a listen sock */
struct sock *__inet_lookup_listener(......)
{
	......
	if (score > hiscore) {
			result = sk;
			hiscore = score;
			reuseport = sk->sk_reuseport;
			if (reuseport) {
				phash = inet_ehashfn(net, daddr, hnum,
						     saddr, sport);
				matches = 1;
			}
		} else if (score == hiscore && reuseport) {
			matches++;
			if (((u64)phash * matches) >> 32 == 0)
				result = sk;
			phash = next_pseudo_random32(phash);
		}
	......
}

http {
     server {
          listen 80 reuseport;
          server_name localhost;
          # ...
     }
}

stream {
     server {
          listen 12345 reuseport;
          # ...
     }
}