: Basic support for passive-close

@@ -55,6 +55,9 @@ EXPORT_SYMBOL_GPL(dccp_hashinfo);
 /* the maximum queue length for tx in packets. 0 is no limit */
 int sysctl_dccp_tx_qlen __read_mostly = 5;
 
+/* Forward Declarations. */
+static void dccp_handle_passive_close(struct sock *sk);
+
 void dccp_set_state(struct sock *sk, const int state)
 {
 	const int oldstate = sk->sk_state;

@@ -71,7 +74,8 @@ void dccp_set_state(struct sock *sk, con
 		break;
 
 	case DCCP_CLOSED:
-		if (oldstate = DCCP_CLOSING || oldstate = DCCP_OPEN)
+		if (oldstate = DCCP_CLOSING  ||
+		    oldstate = DCCP_CLOSEREQ || oldstate = DCCP_OPEN)
 			DCCP_INC_STATS(DCCP_MIB_ESTABRESETS);
 
 		sk->sk_prot->unhash(sk);

@@ -721,19 +725,26 @@ int dccp_recvmsg(struct kiocb *iocb, str
 
 		dh = dccp_hdr(skb);
 
-		if (dh->dccph_type = DCCP_PKT_DATA ||
-		    dh->dccph_type = DCCP_PKT_DATAACK)
+		switch (dh->dccph_type) {
+		case DCCP_PKT_DATA:
+		case DCCP_PKT_DATAACK:
 			goto found_ok_skb;
 
-		if (dh->dccph_type = DCCP_PKT_RESET ||
-		    dh->dccph_type = DCCP_PKT_CLOSE) {
-			dccp_pr_debug("found fin ok!\n");
+		case DCCP_PKT_CLOSE:
+		case DCCP_PKT_CLOSEREQ:
+			if (!(flags & MSG_PEEK))
+				dccp_handle_passive_close(sk);
+			/* fall through */
+		case DCCP_PKT_RESET:
+			dccp_pr_debug("found fin (%s) ok!\n",
+				      dccp_packet_name(dh->dccph_type));
 			len = 0;
 			goto found_fin_ok;
+		default:
+			dccp_pr_debug("packet_type=%s\n",
+				      dccp_packet_name(dh->dccph_type));
+			sk_eat_skb(sk, skb, 0);
 		}
-		dccp_pr_debug("packet_type=%s\n",
-			      dccp_packet_name(dh->dccph_type));
-		sk_eat_skb(sk, skb, 0);
 verify_sock_status:
 		if (sock_flag(sk, SOCK_DONE)) {
 			len = 0;

@@ -835,28 +846,64 @@ out:
 
 EXPORT_SYMBOL_GPL(inet_dccp_listen);
 
-static const unsigned char dccp_new_state[] = {
-	/* current state:   new state:      action:	*/
-	[0]		  = DCCP_CLOSED,
-	[DCCP_OPEN]	  = DCCP_CLOSING | DCCP_ACTION_FIN,
-	[DCCP_REQUESTING] = DCCP_CLOSED,
-	[DCCP_PARTOPEN]	  = DCCP_CLOSING | DCCP_ACTION_FIN,
-	[DCCP_LISTEN]	  = DCCP_CLOSED,
-	[DCCP_RESPOND]	  = DCCP_CLOSED,
-	[DCCP_CLOSING]	  = DCCP_CLOSED,
-	[DCCP_TIME_WAIT]  = DCCP_CLOSED,
-	[DCCP_CLOSED]	  = DCCP_CLOSED,
-};
-
-static int dccp_close_state(struct sock *sk)
+void dccp_handle_passive_close(struct sock *sk)
 {
-	const int next = dccp_new_state[sk->sk_state];
-	const int ns = next & DCCP_STATE_MASK;
+	switch (sk->sk_state) {
+	case DCCP_PASSIVE_1:
+		/* Node (client or server) has received Close packet. */
+		dccp_set_state(sk, DCCP_CLOSED);
+		dccp_send_reset(sk, DCCP_RESET_CODE_CLOSED);
+		break;
+	case DCCP_PASSIVE_2:
+		/*
+		 * Client passive-close by receiving a CloseReq packet.
+		 * We need to set `active' when sending the Close, since 8.3 in
+		 * RFC 4340 requires nodes in the CLOSING state to retransmit
+		 * the Close/CloseReq packets. A conforming peer implementation
+		 * will in turn retransmit its CloseReq packets as well.
+		 */
+		dccp_set_state(sk, DCCP_CLOSING);
+		dccp_send_close(sk, 1);
+		break;
+	default:
+		return;
+	}
+}
 
-	if (ns != sk->sk_state)
-		dccp_set_state(sk, ns);
+static void dccp_handle_close(struct sock *sk)
+{
+	u8 next_state = DCCP_CLOSED;
 
-	return next & DCCP_ACTION_FIN;
+	switch (sk->sk_state) {
+	case DCCP_CLOSED:
+		return;
+	case DCCP_PASSIVE_1:
+	case DCCP_PASSIVE_2:
+		dccp_handle_passive_close(sk);
+		break;
+	case DCCP_PARTOPEN:
+		/*
+		 * Clear PARTOPEN timer [RFC 4340, 8.1.5]; we will be sending a
+		 * Close presently, which will be (re-)transmitted anyhow (8.3).
+		 */
+		dccp_pr_debug("Stop PARTOPEN timer (%p)\n", sk);
+		inet_csk_clear_xmit_timer(sk, ICSK_TIME_DACK);
+		/* fall through */
+	case DCCP_OPEN:
+		/*
+		 * An active close need only be sent in these two states
+		 */
+		dccp_send_close(sk, 1);
+
+		if (dccp_sk(sk)->dccps_role = DCCP_ROLE_SERVER)
+			next_state = DCCP_CLOSEREQ;
+		else
+			next_state = DCCP_CLOSING;
+		/* fall through */
+	default:
+		dccp_set_state(sk, next_state);
+		break;
+	}
 }
 
 void dccp_close(struct sock *sk, long timeout)

@@ -893,9 +940,8 @@ void dccp_close(struct sock *sk, long ti
 	if (sock_flag(sk, SOCK_LINGER) && !sk->sk_lingertime) {
 		/* Check zero linger _after_ checking for unread data. */
 		sk->sk_prot->disconnect(sk, 0);
-	} else if (dccp_close_state(sk)) {
-		dccp_send_close(sk, 1);
-	}
+	} else	/* Passive/active close after all data has been read. */
+		dccp_handle_close(sk);
 
 	sk_stream_wait_close(sk, timeout);
 

@@ -31,10 +31,23 @@ static void dccp_fin(struct sock *sk, st
 
 static void dccp_rcv_close(struct sock *sk, struct sk_buff *skb)
 {
-	dccp_send_reset(sk, DCCP_RESET_CODE_CLOSED);
-	dccp_fin(sk, skb);
-	dccp_set_state(sk, DCCP_CLOSED);
-	sk_wake_async(sk, 1, POLL_HUP);
+	if (sk->sk_state = DCCP_CLOSEREQ) {
+		/* Server performed active close */
+		dccp_send_reset(sk, DCCP_RESET_CODE_CLOSED);
+		dccp_done(sk);
+	} else {
+		/*
+		 * Passive-close: Only the first Close is enqueued, there is no
+		 * point in putting several Closes on the queue - in case of an
+		 * application bug, the input queue may not be emptied at all.
+		 * In this case we wait until the peer sends the terminal Reset.
+		 */
+		if (sk->sk_state != DCCP_PASSIVE_1) {
+			dccp_fin(sk, skb);
+			dccp_set_state(sk, DCCP_PASSIVE_1);
+		}
+		sk_wake_async(sk, 1, POLL_HUP);
+	}
 }
 
 static void dccp_rcv_closereq(struct sock *sk, struct sk_buff *skb)

@@ -50,9 +63,12 @@ static void dccp_rcv_closereq(struct soc
 		return;
 	}
 
-	if (sk->sk_state != DCCP_CLOSING)
-		dccp_set_state(sk, DCCP_CLOSING);
-	dccp_send_close(sk, 0);
+	/* Do not enqueue CloseReq twice: see comments above for PASSIVE_1 */
+	if (sk->sk_state != DCCP_PASSIVE_2) {
+		dccp_fin(sk, skb);
+		dccp_set_state(sk, DCCP_PASSIVE_2);
+	}
+	sk_wake_async(sk, 1, POLL_HUP);
 }
 
 static void dccp_event_ack_recv(struct sock *sk, struct sk_buff *skb)

@@ -181,7 +197,7 @@ static int __dccp_rcv_established(struct
 		return 0;
 	case DCCP_PKT_CLOSEREQ:
 		dccp_rcv_closereq(sk, skb);
-		goto discard;
+		return 0;
 	case DCCP_PKT_CLOSE:
 		dccp_rcv_close(sk, skb);
 		return 0;

@@ -534,7 +550,7 @@ int dccp_rcv_state_process(struct sock *
 		goto discard;
 	} else if (dh->dccph_type = DCCP_PKT_CLOSEREQ) {
 		dccp_rcv_closereq(sk, skb);
-		goto discard;
+		return 0;
 	} else if (dh->dccph_type = DCCP_PKT_CLOSE) {
 		dccp_rcv_close(sk, skb);
 		return 0;

@@ -259,7 +259,6 @@ enum dccp_state {
 };
 
 #define DCCP_STATE_MASK 0x1f
-#define DCCP_ACTION_FIN (1<<7)
 
 enum {
 	DCCPF_OPEN	 = TCPF_ESTABLISHED,