Commit | Line | Data |
---|---|---|
7c657876 ACM |
1 | /* |
2 | * net/dccp/minisocks.c | |
3 | * | |
4 | * An implementation of the DCCP protocol | |
5 | * Arnaldo Carvalho de Melo <acme@conectiva.com.br> | |
6 | * | |
7 | * This program is free software; you can redistribute it and/or | |
8 | * modify it under the terms of the GNU General Public License | |
9 | * as published by the Free Software Foundation; either version | |
10 | * 2 of the License, or (at your option) any later version. | |
11 | */ | |
12 | ||
13 | #include <linux/config.h> | |
14 | #include <linux/dccp.h> | |
15 | #include <linux/skbuff.h> | |
16 | #include <linux/timer.h> | |
17 | ||
18 | #include <net/sock.h> | |
19 | #include <net/xfrm.h> | |
20 | #include <net/inet_timewait_sock.h> | |
21 | ||
22 | #include "ccid.h" | |
23 | #include "dccp.h" | |
24 | ||
25 | void dccp_time_wait(struct sock *sk, int state, int timeo) | |
26 | { | |
27 | /* FIXME: Implement */ | |
28 | dccp_pr_debug("Want to help? Start here\n"); | |
29 | dccp_set_state(sk, state); | |
30 | } | |
31 | ||
32 | /* This is for handling early-kills of TIME_WAIT sockets. */ | |
33 | void dccp_tw_deschedule(struct inet_timewait_sock *tw) | |
34 | { | |
35 | dccp_pr_debug("Want to help? Start here\n"); | |
36 | __inet_twsk_kill(tw, &dccp_hashinfo); | |
37 | } | |
38 | ||
39 | struct sock *dccp_create_openreq_child(struct sock *sk, | |
40 | const struct request_sock *req, | |
41 | const struct sk_buff *skb) | |
42 | { | |
43 | /* | |
44 | * Step 3: Process LISTEN state | |
45 | * | |
46 | * // Generate a new socket and switch to that socket | |
47 | * Set S := new socket for this port pair | |
48 | */ | |
49 | struct sock *newsk = inet_csk_clone(sk, req, GFP_ATOMIC); | |
50 | ||
51 | if (newsk != NULL) { | |
52 | const struct dccp_request_sock *dreq = dccp_rsk(req); | |
53 | struct inet_connection_sock *newicsk = inet_csk(sk); | |
54 | struct dccp_sock *newdp = dccp_sk(newsk); | |
55 | ||
56 | newdp->dccps_hc_rx_ackpkts = NULL; | |
57 | newdp->dccps_role = DCCP_ROLE_SERVER; | |
58 | newicsk->icsk_rto = TCP_TIMEOUT_INIT; | |
59 | ||
60 | if (newdp->dccps_options.dccpo_send_ack_vector) { | |
61 | newdp->dccps_hc_rx_ackpkts = dccp_ackpkts_alloc(DCCP_MAX_ACK_VECTOR_LEN, | |
62 | GFP_ATOMIC); | |
63 | /* | |
64 | * XXX: We're using the same CCIDs set on the parent, i.e. sk_clone | |
65 | * copied the master sock and left the CCID pointers for this child, | |
66 | * that is why we do the __ccid_get calls. | |
67 | */ | |
68 | if (unlikely(newdp->dccps_hc_rx_ackpkts == NULL)) | |
69 | goto out_free; | |
70 | } | |
71 | ||
72 | if (unlikely(ccid_hc_rx_init(newdp->dccps_hc_rx_ccid, newsk) != 0 || | |
73 | ccid_hc_tx_init(newdp->dccps_hc_tx_ccid, newsk) != 0)) { | |
74 | dccp_ackpkts_free(newdp->dccps_hc_rx_ackpkts); | |
75 | ccid_hc_rx_exit(newdp->dccps_hc_rx_ccid, newsk); | |
76 | ccid_hc_tx_exit(newdp->dccps_hc_tx_ccid, newsk); | |
77 | out_free: | |
78 | /* It is still raw copy of parent, so invalidate | |
79 | * destructor and make plain sk_free() */ | |
80 | newsk->sk_destruct = NULL; | |
81 | sk_free(newsk); | |
82 | return NULL; | |
83 | } | |
84 | ||
85 | __ccid_get(newdp->dccps_hc_rx_ccid); | |
86 | __ccid_get(newdp->dccps_hc_tx_ccid); | |
87 | ||
88 | /* | |
89 | * Step 3: Process LISTEN state | |
90 | * | |
91 | * Choose S.ISS (initial seqno) or set from Init Cookie | |
92 | * Set S.ISR, S.GSR, S.SWL, S.SWH from packet or Init Cookie | |
93 | */ | |
94 | ||
95 | /* See dccp_v4_conn_request */ | |
96 | newdp->dccps_options.dccpo_sequence_window = req->rcv_wnd; | |
97 | ||
98 | newdp->dccps_gar = newdp->dccps_isr = dreq->dreq_isr; | |
99 | dccp_update_gsr(newsk, dreq->dreq_isr); | |
100 | ||
101 | newdp->dccps_iss = dreq->dreq_iss; | |
102 | dccp_update_gss(newsk, dreq->dreq_iss); | |
103 | ||
104 | dccp_init_xmit_timers(newsk); | |
105 | ||
106 | DCCP_INC_STATS_BH(DCCP_MIB_PASSIVEOPENS); | |
107 | } | |
108 | return newsk; | |
109 | } | |
110 | ||
111 | /* | |
112 | * Process an incoming packet for RESPOND sockets represented | |
113 | * as an request_sock. | |
114 | */ | |
115 | struct sock *dccp_check_req(struct sock *sk, struct sk_buff *skb, | |
116 | struct request_sock *req, | |
117 | struct request_sock **prev) | |
118 | { | |
119 | struct sock *child = NULL; | |
120 | ||
121 | /* Check for retransmitted REQUEST */ | |
122 | if (dccp_hdr(skb)->dccph_type == DCCP_PKT_REQUEST) { | |
123 | if (after48(DCCP_SKB_CB(skb)->dccpd_seq, dccp_rsk(req)->dreq_isr)) { | |
124 | struct dccp_request_sock *dreq = dccp_rsk(req); | |
125 | ||
126 | dccp_pr_debug("Retransmitted REQUEST\n"); | |
127 | /* Send another RESPONSE packet */ | |
128 | dccp_set_seqno(&dreq->dreq_iss, dreq->dreq_iss + 1); | |
129 | dccp_set_seqno(&dreq->dreq_isr, DCCP_SKB_CB(skb)->dccpd_seq); | |
130 | req->rsk_ops->rtx_syn_ack(sk, req, NULL); | |
131 | } | |
132 | /* Network Duplicate, discard packet */ | |
133 | return NULL; | |
134 | } | |
135 | ||
136 | DCCP_SKB_CB(skb)->dccpd_reset_code = DCCP_RESET_CODE_PACKET_ERROR; | |
137 | ||
138 | if (dccp_hdr(skb)->dccph_type != DCCP_PKT_ACK && | |
139 | dccp_hdr(skb)->dccph_type != DCCP_PKT_DATAACK) | |
140 | goto drop; | |
141 | ||
142 | /* Invalid ACK */ | |
143 | if (DCCP_SKB_CB(skb)->dccpd_ack_seq != dccp_rsk(req)->dreq_iss) { | |
144 | dccp_pr_debug("Invalid ACK number: ack_seq=%llu, dreq_iss=%llu\n", | |
f6ccf554 DM |
145 | (unsigned long long) |
146 | DCCP_SKB_CB(skb)->dccpd_ack_seq, | |
147 | (unsigned long long) | |
148 | dccp_rsk(req)->dreq_iss); | |
7c657876 ACM |
149 | goto drop; |
150 | } | |
151 | ||
152 | child = dccp_v4_request_recv_sock(sk, skb, req, NULL); | |
153 | if (child == NULL) | |
154 | goto listen_overflow; | |
155 | ||
156 | /* FIXME: deal with options */ | |
157 | ||
158 | inet_csk_reqsk_queue_unlink(sk, req, prev); | |
159 | inet_csk_reqsk_queue_removed(sk, req); | |
160 | inet_csk_reqsk_queue_add(sk, req, child); | |
161 | out: | |
162 | return child; | |
163 | listen_overflow: | |
164 | dccp_pr_debug("listen_overflow!\n"); | |
165 | DCCP_SKB_CB(skb)->dccpd_reset_code = DCCP_RESET_CODE_TOO_BUSY; | |
166 | drop: | |
167 | if (dccp_hdr(skb)->dccph_type != DCCP_PKT_RESET) | |
168 | req->rsk_ops->send_reset(skb); | |
169 | ||
170 | inet_csk_reqsk_queue_drop(sk, req, prev); | |
171 | goto out; | |
172 | } | |
173 | ||
174 | /* | |
175 | * Queue segment on the new socket if the new socket is active, | |
176 | * otherwise we just shortcircuit this and continue with | |
177 | * the new socket. | |
178 | */ | |
179 | int dccp_child_process(struct sock *parent, struct sock *child, | |
180 | struct sk_buff *skb) | |
181 | { | |
182 | int ret = 0; | |
183 | const int state = child->sk_state; | |
184 | ||
185 | if (!sock_owned_by_user(child)) { | |
186 | ret = dccp_rcv_state_process(child, skb, dccp_hdr(skb), skb->len); | |
187 | ||
188 | /* Wakeup parent, send SIGIO */ | |
189 | if (state == DCCP_RESPOND && child->sk_state != state) | |
190 | parent->sk_data_ready(parent, 0); | |
191 | } else { | |
192 | /* Alas, it is possible again, because we do lookup | |
193 | * in main socket hash table and lock on listening | |
194 | * socket does not protect us more. | |
195 | */ | |
196 | sk_add_backlog(child, skb); | |
197 | } | |
198 | ||
199 | bh_unlock_sock(child); | |
200 | sock_put(child); | |
201 | return ret; | |
202 | } |