Eric Lee / smarc-ti-linux-kernel

1

/* SCTP kernel implementation

1

/* SCTP kernel implementation

2

* (C) Copyright IBM Corp. 2001, 2004

2

* (C) Copyright IBM Corp. 2001, 2004

3

4

5

6

7

*

7

*

8

* This file is part of the SCTP kernel implementation

8

* This file is part of the SCTP kernel implementation

9

*

9

*

10

* This module provides the abstraction for an SCTP association.

10

* This module provides the abstraction for an SCTP association.

11

*

11

*

12

* This SCTP implementation is free software;

12

* This SCTP implementation is free software;

13

* you can redistribute it and/or modify it under the terms of

13

* you can redistribute it and/or modify it under the terms of

14

* the GNU General Public License as published by

14

* the GNU General Public License as published by

15

* the Free Software Foundation; either version 2, or (at your option)

15

* the Free Software Foundation; either version 2, or (at your option)

16

* any later version.

16

* any later version.

17

*

17

*

18

* This SCTP implementation is distributed in the hope that it

18

* This SCTP implementation is distributed in the hope that it

19

* will be useful, but WITHOUT ANY WARRANTY; without even the implied

19

* will be useful, but WITHOUT ANY WARRANTY; without even the implied

20

* ************************

20

* ************************

21

* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

21

* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

22

* See the GNU General Public License for more details.

22

* See the GNU General Public License for more details.

23

*

23

*

24

* You should have received a copy of the GNU General Public License

24

* You should have received a copy of the GNU General Public License

25

* along with GNU CC; see the file COPYING. If not, see

25

* along with GNU CC; see the file COPYING. If not, see

26

* <http://www.gnu.org/licenses/>.

26

* <http://www.gnu.org/licenses/>.

27

*

27

*

28

* Please send any bug reports or fixes you make to the

28

* Please send any bug reports or fixes you make to the

29

* email address(es):

29

* email address(es):

30

* lksctp developers <linux-sctp@vger.kernel.org>

30

* lksctp developers <linux-sctp@vger.kernel.org>

31

*

31

*

32

* Written or modified by:

32

* Written or modified by:

33

* La Monte H.P. Yarroll <piggy@acm.org>

33

* La Monte H.P. Yarroll <piggy@acm.org>

34

* Karl Knutson <karl@athena.chicago.il.us>

34

* Karl Knutson <karl@athena.chicago.il.us>

35

* Jon Grimm <jgrimm@us.ibm.com>

35

* Jon Grimm <jgrimm@us.ibm.com>

36

* Xingang Guo <xingang.guo@intel.com>

36

* Xingang Guo <xingang.guo@intel.com>

37

* Hui Huang <hui.huang@nokia.com>

37

* Hui Huang <hui.huang@nokia.com>

38

* Sridhar Samudrala <sri@us.ibm.com>

38

* Sridhar Samudrala <sri@us.ibm.com>

39

* Daisy Chang <daisyc@us.ibm.com>

39

* Daisy Chang <daisyc@us.ibm.com>

40

* Ryan Layer <rmlayer@us.ibm.com>

40

* Ryan Layer <rmlayer@us.ibm.com>

41

* Kevin Gao <kevin.gao@intel.com>

41

* Kevin Gao <kevin.gao@intel.com>

42

*/

42

*/

43

44

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

44

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

45

46

#include <linux/types.h>

46

#include <linux/types.h>

47

#include <linux/fcntl.h>

47

#include <linux/fcntl.h>

48

#include <linux/poll.h>

48

#include <linux/poll.h>

49

#include <linux/init.h>

49

#include <linux/init.h>

50

51

#include <linux/slab.h>

51

#include <linux/slab.h>

52

#include <linux/in.h>

52

#include <linux/in.h>

53

#include <net/ipv6.h>

53

#include <net/ipv6.h>

54

#include <net/sctp/sctp.h>

54

#include <net/sctp/sctp.h>

55

#include <net/sctp/sm.h>

55

#include <net/sctp/sm.h>

56

57

/* Forward declarations for internal functions. */

57

/* Forward declarations for internal functions. */

58

static void sctp_select_active_and_retran_path(struct sctp_association *asoc);

58

static void sctp_select_active_and_retran_path(struct sctp_association *asoc);

59

static void sctp_assoc_bh_rcv(struct work_struct *work);

59

static void sctp_assoc_bh_rcv(struct work_struct *work);

60

static void sctp_assoc_free_asconf_acks(struct sctp_association *asoc);

60

static void sctp_assoc_free_asconf_acks(struct sctp_association *asoc);

61

static void sctp_assoc_free_asconf_queue(struct sctp_association *asoc);

61

static void sctp_assoc_free_asconf_queue(struct sctp_association *asoc);

62

63

/* 1st Level Abstractions. */

63

/* 1st Level Abstractions. */

64

65

/* Initialize a new association from provided memory. */

65

/* Initialize a new association from provided memory. */

66

static struct sctp_association *sctp_association_init(struct sctp_association *asoc,

66

static struct sctp_association *sctp_association_init(struct sctp_association *asoc,

67

const struct sctp_endpoint *ep,

67

const struct sctp_endpoint *ep,

68

const struct sock *sk,

68

const struct sock *sk,

69

sctp_scope_t scope,

69

sctp_scope_t scope,

70

gfp_t gfp)

70

gfp_t gfp)

71

{

71

{

72

struct net *net = sock_net(sk);

72

struct net *net = sock_net(sk);

73

struct sctp_sock *sp;

73

struct sctp_sock *sp;

74

int i;

74

int i;

75

sctp_paramhdr_t *p;

75

sctp_paramhdr_t *p;

76

int err;

76

int err;

77

78

/* Retrieve the SCTP per socket area. */

78

/* Retrieve the SCTP per socket area. */

79

sp = sctp_sk((struct sock *)sk);

79

sp = sctp_sk((struct sock *)sk);

80

81

/* Discarding const is appropriate here. */

81

/* Discarding const is appropriate here. */

82

asoc->ep = (struct sctp_endpoint *)ep;

82

asoc->ep = (struct sctp_endpoint *)ep;

83

asoc->base.sk = (struct sock *)sk;

83

asoc->base.sk = (struct sock *)sk;

84

85

sctp_endpoint_hold(asoc->ep);

85

sctp_endpoint_hold(asoc->ep);

86

sock_hold(asoc->base.sk);

86

sock_hold(asoc->base.sk);

87

88

/* Initialize the common base substructure. */

88

/* Initialize the common base substructure. */

89

asoc->base.type = SCTP_EP_TYPE_ASSOCIATION;

89

asoc->base.type = SCTP_EP_TYPE_ASSOCIATION;

90

91

/* Initialize the object handling fields. */

91

/* Initialize the object handling fields. */

92

atomic_set(&asoc->base.refcnt, 1);

92

atomic_set(&asoc->base.refcnt, 1);

93

94

/* Initialize the bind addr area. */

94

/* Initialize the bind addr area. */

95

sctp_bind_addr_init(&asoc->base.bind_addr, ep->base.bind_addr.port);

95

sctp_bind_addr_init(&asoc->base.bind_addr, ep->base.bind_addr.port);

96

97

asoc->state = SCTP_STATE_CLOSED;

97

asoc->state = SCTP_STATE_CLOSED;

98

asoc->cookie_life = ms_to_ktime(sp->assocparams.sasoc_cookie_life);

98

asoc->cookie_life = ms_to_ktime(sp->assocparams.sasoc_cookie_life);

99

asoc->user_frag = sp->user_frag;

99

asoc->user_frag = sp->user_frag;

100

101

/* Set the association max_retrans and RTO values from the

101

/* Set the association max_retrans and RTO values from the

102

* socket values.

102

* socket values.

103

*/

103

*/

104

asoc->max_retrans = sp->assocparams.sasoc_asocmaxrxt;

104

asoc->max_retrans = sp->assocparams.sasoc_asocmaxrxt;

105

asoc->pf_retrans = net->sctp.pf_retrans;

105

asoc->pf_retrans = net->sctp.pf_retrans;

106

107

asoc->rto_initial = msecs_to_jiffies(sp->rtoinfo.srto_initial);

107

asoc->rto_initial = msecs_to_jiffies(sp->rtoinfo.srto_initial);

108

asoc->rto_max = msecs_to_jiffies(sp->rtoinfo.srto_max);

108

asoc->rto_max = msecs_to_jiffies(sp->rtoinfo.srto_max);

109

asoc->rto_min = msecs_to_jiffies(sp->rtoinfo.srto_min);

109

asoc->rto_min = msecs_to_jiffies(sp->rtoinfo.srto_min);

110

111

/* Initialize the association's heartbeat interval based on the

111

/* Initialize the association's heartbeat interval based on the

112

* sock configured value.

112

* sock configured value.

113

*/

113

*/

114

asoc->hbinterval = msecs_to_jiffies(sp->hbinterval);

114

asoc->hbinterval = msecs_to_jiffies(sp->hbinterval);

115

116

/* Initialize path max retrans value. */

116

/* Initialize path max retrans value. */

117

asoc->pathmaxrxt = sp->pathmaxrxt;

117

asoc->pathmaxrxt = sp->pathmaxrxt;

118

119

/* Initialize default path MTU. */

119

/* Initialize default path MTU. */

120

asoc->pathmtu = sp->pathmtu;

120

asoc->pathmtu = sp->pathmtu;

121

122

/* Set association default SACK delay */

122

/* Set association default SACK delay */

123

asoc->sackdelay = msecs_to_jiffies(sp->sackdelay);

123

asoc->sackdelay = msecs_to_jiffies(sp->sackdelay);

124

asoc->sackfreq = sp->sackfreq;

124

asoc->sackfreq = sp->sackfreq;

125

126

/* Set the association default flags controlling

126

/* Set the association default flags controlling

127

* Heartbeat, SACK delay, and Path MTU Discovery.

127

* Heartbeat, SACK delay, and Path MTU Discovery.

128

*/

128

*/

129

asoc->param_flags = sp->param_flags;

129

asoc->param_flags = sp->param_flags;

130

131

/* Initialize the maximum number of new data packets that can be sent

131

/* Initialize the maximum number of new data packets that can be sent

132

* in a burst.

132

* in a burst.

133

*/

133

*/

134

asoc->max_burst = sp->max_burst;

134

asoc->max_burst = sp->max_burst;

135

136

/* initialize association timers */

136

/* initialize association timers */

137

asoc->timeouts[SCTP_EVENT_TIMEOUT_T1_COOKIE] = asoc->rto_initial;

137

asoc->timeouts[SCTP_EVENT_TIMEOUT_T1_COOKIE] = asoc->rto_initial;

138

asoc->timeouts[SCTP_EVENT_TIMEOUT_T1_INIT] = asoc->rto_initial;

138

asoc->timeouts[SCTP_EVENT_TIMEOUT_T1_INIT] = asoc->rto_initial;

139

asoc->timeouts[SCTP_EVENT_TIMEOUT_T2_SHUTDOWN] = asoc->rto_initial;

139

asoc->timeouts[SCTP_EVENT_TIMEOUT_T2_SHUTDOWN] = asoc->rto_initial;

140

141

/* sctpimpguide Section 2.12.2

141

/* sctpimpguide Section 2.12.2

142

* If the 'T5-shutdown-guard' timer is used, it SHOULD be set to the

142

* If the 'T5-shutdown-guard' timer is used, it SHOULD be set to the

143

* recommended value of 5 times 'RTO.Max'.

143

* recommended value of 5 times 'RTO.Max'.

144

*/

144

*/

145

asoc->timeouts[SCTP_EVENT_TIMEOUT_T5_SHUTDOWN_GUARD]

145

asoc->timeouts[SCTP_EVENT_TIMEOUT_T5_SHUTDOWN_GUARD]

146

= 5 * asoc->rto_max;

146

= 5 * asoc->rto_max;

147

148

asoc->timeouts[SCTP_EVENT_TIMEOUT_SACK] = asoc->sackdelay;

148

asoc->timeouts[SCTP_EVENT_TIMEOUT_SACK] = asoc->sackdelay;

149

asoc->timeouts[SCTP_EVENT_TIMEOUT_AUTOCLOSE] = sp->autoclose * HZ;

149

asoc->timeouts[SCTP_EVENT_TIMEOUT_AUTOCLOSE] = sp->autoclose * HZ;

150

151

/* Initializes the timers */

151

/* Initializes the timers */

152

for (i = SCTP_EVENT_TIMEOUT_NONE; i < SCTP_NUM_TIMEOUT_TYPES; ++i)

152

for (i = SCTP_EVENT_TIMEOUT_NONE; i < SCTP_NUM_TIMEOUT_TYPES; ++i)

153

setup_timer(&asoc->timers[i], sctp_timer_events[i],

153

setup_timer(&asoc->timers[i], sctp_timer_events[i],

154

(unsigned long)asoc);

154

(unsigned long)asoc);

155

156

/* Pull default initialization values from the sock options.

156

/* Pull default initialization values from the sock options.

157

* Note: This assumes that the values have already been

157

* Note: This assumes that the values have already been

158

* validated in the sock.

158

* validated in the sock.

159

*/

159

*/

160

asoc->c.sinit_max_instreams = sp->initmsg.sinit_max_instreams;

160

asoc->c.sinit_max_instreams = sp->initmsg.sinit_max_instreams;

161

asoc->c.sinit_num_ostreams = sp->initmsg.sinit_num_ostreams;

161

asoc->c.sinit_num_ostreams = sp->initmsg.sinit_num_ostreams;

162

asoc->max_init_attempts = sp->initmsg.sinit_max_attempts;

162

asoc->max_init_attempts = sp->initmsg.sinit_max_attempts;

163

164

asoc->max_init_timeo =

164

asoc->max_init_timeo =

165

msecs_to_jiffies(sp->initmsg.sinit_max_init_timeo);

165

msecs_to_jiffies(sp->initmsg.sinit_max_init_timeo);

166

167

/* Set the local window size for receive.

167

/* Set the local window size for receive.

168

* This is also the rcvbuf space per association.

168

* This is also the rcvbuf space per association.

169

* RFC 6 - A SCTP receiver MUST be able to receive a minimum of

169

* RFC 6 - A SCTP receiver MUST be able to receive a minimum of

170

* 1500 bytes in one SCTP packet.

170

* 1500 bytes in one SCTP packet.

171

*/

171

*/

172

if ((sk->sk_rcvbuf/2) < SCTP_DEFAULT_MINWINDOW)

172

if ((sk->sk_rcvbuf/2) < SCTP_DEFAULT_MINWINDOW)

173

asoc->rwnd = SCTP_DEFAULT_MINWINDOW;

173

asoc->rwnd = SCTP_DEFAULT_MINWINDOW;

174

else

174

else

175

asoc->rwnd = sk->sk_rcvbuf/2;

175

asoc->rwnd = sk->sk_rcvbuf/2;

176

177

asoc->a_rwnd = asoc->rwnd;

177

asoc->a_rwnd = asoc->rwnd;

178

179

/* Use my own max window until I learn something better. */

179

/* Use my own max window until I learn something better. */

180

asoc->peer.rwnd = SCTP_DEFAULT_MAXWINDOW;

180

asoc->peer.rwnd = SCTP_DEFAULT_MAXWINDOW;

181

182

/* Initialize the receive memory counter */

182

/* Initialize the receive memory counter */

183

atomic_set(&asoc->rmem_alloc, 0);

183

atomic_set(&asoc->rmem_alloc, 0);

184

185

init_waitqueue_head(&asoc->wait);

185

init_waitqueue_head(&asoc->wait);

186

187

asoc->c.my_vtag = sctp_generate_tag(ep);

187

asoc->c.my_vtag = sctp_generate_tag(ep);

188

asoc->c.my_port = ep->base.bind_addr.port;

188

asoc->c.my_port = ep->base.bind_addr.port;

189

190

asoc->c.initial_tsn = sctp_generate_tsn(ep);

190

asoc->c.initial_tsn = sctp_generate_tsn(ep);

191

192

asoc->next_tsn = asoc->c.initial_tsn;

192

asoc->next_tsn = asoc->c.initial_tsn;

193

194

asoc->ctsn_ack_point = asoc->next_tsn - 1;

194

asoc->ctsn_ack_point = asoc->next_tsn - 1;

195

asoc->adv_peer_ack_point = asoc->ctsn_ack_point;

195

asoc->adv_peer_ack_point = asoc->ctsn_ack_point;

196

asoc->highest_sacked = asoc->ctsn_ack_point;

196

asoc->highest_sacked = asoc->ctsn_ack_point;

197

asoc->last_cwr_tsn = asoc->ctsn_ack_point;

197

asoc->last_cwr_tsn = asoc->ctsn_ack_point;

198

199

/* ADDIP Section 4.1 Asconf Chunk Procedures

199

/* ADDIP Section 4.1 Asconf Chunk Procedures

200

*

200

*

201

* When an endpoint has an ASCONF signaled change to be sent to the

201

* When an endpoint has an ASCONF signaled change to be sent to the

202

* remote endpoint it should do the following:

202

* remote endpoint it should do the following:

203

* ...

203

* ...

204

* A2) a serial number should be assigned to the chunk. The serial

204

* A2) a serial number should be assigned to the chunk. The serial

205

* number SHOULD be a monotonically increasing number. The serial

205

* number SHOULD be a monotonically increasing number. The serial

206

* numbers SHOULD be initialized at the start of the

206

* numbers SHOULD be initialized at the start of the

207

* association to the same value as the initial TSN.

207

* association to the same value as the initial TSN.

208

*/

208

*/

209

asoc->addip_serial = asoc->c.initial_tsn;

209

asoc->addip_serial = asoc->c.initial_tsn;

210

211

INIT_LIST_HEAD(&asoc->addip_chunk_list);

211

INIT_LIST_HEAD(&asoc->addip_chunk_list);

212

INIT_LIST_HEAD(&asoc->asconf_ack_list);

212

INIT_LIST_HEAD(&asoc->asconf_ack_list);

213

214

/* Make an empty list of remote transport addresses. */

214

/* Make an empty list of remote transport addresses. */

215

INIT_LIST_HEAD(&asoc->peer.transport_addr_list);

215

INIT_LIST_HEAD(&asoc->peer.transport_addr_list);

216

217

/* RFC 2960 5.1 Normal Establishment of an Association

217

/* RFC 2960 5.1 Normal Establishment of an Association

218

*

218

*

219

* After the reception of the first data chunk in an

219

* After the reception of the first data chunk in an

220

* association the endpoint must immediately respond with a

220

* association the endpoint must immediately respond with a

221

* sack to acknowledge the data chunk. Subsequent

221

* sack to acknowledge the data chunk. Subsequent

222

* acknowledgements should be done as described in Section

222

* acknowledgements should be done as described in Section

223

* 6.2.

223

* 6.2.

224

*

224

*

225

* [We implement this by telling a new association that it

225

* [We implement this by telling a new association that it

226

* already received one packet.]

226

* already received one packet.]

227

*/

227

*/

228

asoc->peer.sack_needed = 1;

228

asoc->peer.sack_needed = 1;

229

asoc->peer.sack_generation = 1;

229

asoc->peer.sack_generation = 1;

230

231

/* Assume that the peer will tell us if he recognizes ASCONF

231

/* Assume that the peer will tell us if he recognizes ASCONF

232

* as part of INIT exchange.

232

* as part of INIT exchange.

233

* The sctp_addip_noauth option is there for backward compatibility

233

* The sctp_addip_noauth option is there for backward compatibility

234

* and will revert old behavior.

234

* and will revert old behavior.

235

*/

235

*/

236

if (net->sctp.addip_noauth)

236

if (net->sctp.addip_noauth)

237

asoc->peer.asconf_capable = 1;

237

asoc->peer.asconf_capable = 1;

238

239

/* Create an input queue. */

239

/* Create an input queue. */

240

sctp_inq_init(&asoc->base.inqueue);

240

sctp_inq_init(&asoc->base.inqueue);

241

sctp_inq_set_th_handler(&asoc->base.inqueue, sctp_assoc_bh_rcv);

241

sctp_inq_set_th_handler(&asoc->base.inqueue, sctp_assoc_bh_rcv);

242

243

/* Create an output queue. */

243

/* Create an output queue. */

244

sctp_outq_init(asoc, &asoc->outqueue);

244

sctp_outq_init(asoc, &asoc->outqueue);

245

246

if (!sctp_ulpq_init(&asoc->ulpq, asoc))

246

if (!sctp_ulpq_init(&asoc->ulpq, asoc))

247

goto fail_init;

247

goto fail_init;

248

249

/* Assume that peer would support both address types unless we are

249

/* Assume that peer would support both address types unless we are

250

* told otherwise.

250

* told otherwise.

251

*/

251

*/

252

asoc->peer.ipv4_address = 1;

252

asoc->peer.ipv4_address = 1;

253

if (asoc->base.sk->sk_family == PF_INET6)

253

if (asoc->base.sk->sk_family == PF_INET6)

254

asoc->peer.ipv6_address = 1;

254

asoc->peer.ipv6_address = 1;

255

INIT_LIST_HEAD(&asoc->asocs);

255

INIT_LIST_HEAD(&asoc->asocs);

256

257

asoc->default_stream = sp->default_stream;

257

asoc->default_stream = sp->default_stream;

258

asoc->default_ppid = sp->default_ppid;

258

asoc->default_ppid = sp->default_ppid;

259

asoc->default_flags = sp->default_flags;

259

asoc->default_flags = sp->default_flags;

260

asoc->default_context = sp->default_context;

260

asoc->default_context = sp->default_context;

261

asoc->default_timetolive = sp->default_timetolive;

261

asoc->default_timetolive = sp->default_timetolive;

262

asoc->default_rcv_context = sp->default_rcv_context;

262

asoc->default_rcv_context = sp->default_rcv_context;

263

264

/* AUTH related initializations */

264

/* AUTH related initializations */

265

INIT_LIST_HEAD(&asoc->endpoint_shared_keys);

265

INIT_LIST_HEAD(&asoc->endpoint_shared_keys);

266

err = sctp_auth_asoc_copy_shkeys(ep, asoc, gfp);

266

err = sctp_auth_asoc_copy_shkeys(ep, asoc, gfp);

267

if (err)

267

if (err)

268

goto fail_init;

268

goto fail_init;

269

270

asoc->active_key_id = ep->active_key_id;

270

asoc->active_key_id = ep->active_key_id;

271

272

/* Save the hmacs and chunks list into this association */

272

/* Save the hmacs and chunks list into this association */

273

if (ep->auth_hmacs_list)

273

if (ep->auth_hmacs_list)

274

memcpy(asoc->c.auth_hmacs, ep->auth_hmacs_list,

274

memcpy(asoc->c.auth_hmacs, ep->auth_hmacs_list,

275

ntohs(ep->auth_hmacs_list->param_hdr.length));

275

ntohs(ep->auth_hmacs_list->param_hdr.length));

276

if (ep->auth_chunk_list)

276

if (ep->auth_chunk_list)

277

memcpy(asoc->c.auth_chunks, ep->auth_chunk_list,

277

memcpy(asoc->c.auth_chunks, ep->auth_chunk_list,

278

ntohs(ep->auth_chunk_list->param_hdr.length));

278

ntohs(ep->auth_chunk_list->param_hdr.length));

279

280

/* Get the AUTH random number for this association */

280

/* Get the AUTH random number for this association */

281

p = (sctp_paramhdr_t *)asoc->c.auth_random;

281

p = (sctp_paramhdr_t *)asoc->c.auth_random;

282

p->type = SCTP_PARAM_RANDOM;

282

p->type = SCTP_PARAM_RANDOM;

283

p->length = htons(sizeof(sctp_paramhdr_t) + SCTP_AUTH_RANDOM_LENGTH);

283

p->length = htons(sizeof(sctp_paramhdr_t) + SCTP_AUTH_RANDOM_LENGTH);

284

get_random_bytes(p+1, SCTP_AUTH_RANDOM_LENGTH);

284

get_random_bytes(p+1, SCTP_AUTH_RANDOM_LENGTH);

285

286

return asoc;

286

return asoc;

287

288

fail_init:

288

fail_init:

289

sock_put(asoc->base.sk);

289

sock_put(asoc->base.sk);

290

sctp_endpoint_put(asoc->ep);

290

sctp_endpoint_put(asoc->ep);

291

return NULL;

291

return NULL;

292

}

292

}

293

294

/* Allocate and initialize a new association */

294

/* Allocate and initialize a new association */

295

struct sctp_association *sctp_association_new(const struct sctp_endpoint *ep,

295

struct sctp_association *sctp_association_new(const struct sctp_endpoint *ep,

296

const struct sock *sk,

296

const struct sock *sk,

297

sctp_scope_t scope,

297

sctp_scope_t scope,

298

gfp_t gfp)

298

gfp_t gfp)

299

{

299

{

300

struct sctp_association *asoc;

300

struct sctp_association *asoc;

301

302

asoc = kzalloc(sizeof(*asoc), gfp);

302

asoc = kzalloc(sizeof(*asoc), gfp);

303

if (!asoc)

303

if (!asoc)

304

goto fail;

304

goto fail;

305

306

if (!sctp_association_init(asoc, ep, sk, scope, gfp))

306

if (!sctp_association_init(asoc, ep, sk, scope, gfp))

307

goto fail_init;

307

goto fail_init;

308

309

SCTP_DBG_OBJCNT_INC(assoc);

309

SCTP_DBG_OBJCNT_INC(assoc);

310

311

pr_debug("Created asoc %p\n", asoc);

311

pr_debug("Created asoc %p\n", asoc);

312

313

return asoc;

313

return asoc;

314

315

fail_init:

315

fail_init:

316

kfree(asoc);

316

kfree(asoc);

317

fail:

317

fail:

318

return NULL;

318

return NULL;

319

}

319

}

320

321

/* Free this association if possible. There may still be users, so

321

/* Free this association if possible. There may still be users, so

322

* the actual deallocation may be delayed.

322

* the actual deallocation may be delayed.

323

*/

323

*/

324

void sctp_association_free(struct sctp_association *asoc)

324

void sctp_association_free(struct sctp_association *asoc)

325

{

325

{

326

struct sock *sk = asoc->base.sk;

326

struct sock *sk = asoc->base.sk;

327

struct sctp_transport *transport;

327

struct sctp_transport *transport;

328

struct list_head *pos, *temp;

328

struct list_head *pos, *temp;

329

int i;

329

int i;

330

331

/* Only real associations count against the endpoint, so

331

/* Only real associations count against the endpoint, so

332

* don't bother for if this is a temporary association.

332

* don't bother for if this is a temporary association.

333

*/

333

*/

334

if (!list_empty(&asoc->asocs)) {

334

if (!list_empty(&asoc->asocs)) {

335

list_del(&asoc->asocs);

335

list_del(&asoc->asocs);

336

337

/* Decrement the backlog value for a TCP-style listening

337

/* Decrement the backlog value for a TCP-style listening

338

* socket.

338

* socket.

339

*/

339

*/

340

if (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING))

340

if (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING))

341

sk->sk_ack_backlog--;

341

sk->sk_ack_backlog--;

342

}

342

}

343

344

/* Mark as dead, so other users can know this structure is

344

/* Mark as dead, so other users can know this structure is

345

* going away.

345

* going away.

346

*/

346

*/

347

asoc->base.dead = true;

347

asoc->base.dead = true;

348

349

/* Dispose of any data lying around in the outqueue. */

349

/* Dispose of any data lying around in the outqueue. */

350

sctp_outq_free(&asoc->outqueue);

350

sctp_outq_free(&asoc->outqueue);

351

352

/* Dispose of any pending messages for the upper layer. */

352

/* Dispose of any pending messages for the upper layer. */

353

sctp_ulpq_free(&asoc->ulpq);

353

sctp_ulpq_free(&asoc->ulpq);

354

355

/* Dispose of any pending chunks on the inqueue. */

355

/* Dispose of any pending chunks on the inqueue. */

356

sctp_inq_free(&asoc->base.inqueue);

356

sctp_inq_free(&asoc->base.inqueue);

357

358

sctp_tsnmap_free(&asoc->peer.tsn_map);

358

sctp_tsnmap_free(&asoc->peer.tsn_map);

359

360

/* Free ssnmap storage. */

360

/* Free ssnmap storage. */

361

sctp_ssnmap_free(asoc->ssnmap);

361

sctp_ssnmap_free(asoc->ssnmap);

362

363

/* Clean up the bound address list. */

363

/* Clean up the bound address list. */

364

sctp_bind_addr_free(&asoc->base.bind_addr);

364

sctp_bind_addr_free(&asoc->base.bind_addr);

365

366

/* Do we need to go through all of our timers and

366

/* Do we need to go through all of our timers and

367

* delete them? To be safe we will try to delete all, but we

367

* delete them? To be safe we will try to delete all, but we

368

* should be able to go through and make a guess based

368

* should be able to go through and make a guess based

369

* on our state.

369

* on our state.

370

*/

370

*/

371

for (i = SCTP_EVENT_TIMEOUT_NONE; i < SCTP_NUM_TIMEOUT_TYPES; ++i) {

371

for (i = SCTP_EVENT_TIMEOUT_NONE; i < SCTP_NUM_TIMEOUT_TYPES; ++i) {

372

if (del_timer(&asoc->timers[i]))

372

if (del_timer(&asoc->timers[i]))

373

sctp_association_put(asoc);

373

sctp_association_put(asoc);

374

}

374

}

375

376

/* Free peer's cached cookie. */

376

/* Free peer's cached cookie. */

377

kfree(asoc->peer.cookie);

377

kfree(asoc->peer.cookie);

378

kfree(asoc->peer.peer_random);

378

kfree(asoc->peer.peer_random);

379

kfree(asoc->peer.peer_chunks);

379

kfree(asoc->peer.peer_chunks);

380

kfree(asoc->peer.peer_hmacs);

380

kfree(asoc->peer.peer_hmacs);

381

382

/* Release the transport structures. */

382

/* Release the transport structures. */

383

list_for_each_safe(pos, temp, &asoc->peer.transport_addr_list) {

383

list_for_each_safe(pos, temp, &asoc->peer.transport_addr_list) {

384

transport = list_entry(pos, struct sctp_transport, transports);

384

transport = list_entry(pos, struct sctp_transport, transports);

385

list_del_rcu(pos);

385

list_del_rcu(pos);

386

sctp_transport_free(transport);

386

sctp_transport_free(transport);

387

}

387

}

388

389

asoc->peer.transport_count = 0;

389

asoc->peer.transport_count = 0;

390

391

sctp_asconf_queue_teardown(asoc);

391

sctp_asconf_queue_teardown(asoc);

392

393

/* Free pending address space being deleted */

393

/* Free pending address space being deleted */

394

if (asoc->asconf_addr_del_pending != NULL)

394

if (asoc->asconf_addr_del_pending != NULL)

395

kfree(asoc->asconf_addr_del_pending);

395

kfree(asoc->asconf_addr_del_pending);

396

397

/* AUTH - Free the endpoint shared keys */

397

/* AUTH - Free the endpoint shared keys */

398

sctp_auth_destroy_keys(&asoc->endpoint_shared_keys);

398

sctp_auth_destroy_keys(&asoc->endpoint_shared_keys);

399

400

/* AUTH - Free the association shared key */

400

/* AUTH - Free the association shared key */

401

sctp_auth_key_put(asoc->asoc_shared_key);

401

sctp_auth_key_put(asoc->asoc_shared_key);

402

403

sctp_association_put(asoc);

403

sctp_association_put(asoc);

404

}

404

}

405

406

/* Cleanup and free up an association. */

406

/* Cleanup and free up an association. */

407

static void sctp_association_destroy(struct sctp_association *asoc)

407

static void sctp_association_destroy(struct sctp_association *asoc)

408

{

408

{

409

if (unlikely(!asoc->base.dead)) {

409

if (unlikely(!asoc->base.dead)) {

410

WARN(1, "Attempt to destroy undead association %p!\n", asoc);

410

WARN(1, "Attempt to destroy undead association %p!\n", asoc);

411

return;

411

return;

412

}

412

}

413

414

sctp_endpoint_put(asoc->ep);

414

sctp_endpoint_put(asoc->ep);

415

sock_put(asoc->base.sk);

415

sock_put(asoc->base.sk);

416

417

if (asoc->assoc_id != 0) {

417

if (asoc->assoc_id != 0) {

418

spin_lock_bh(&sctp_assocs_id_lock);

418

spin_lock_bh(&sctp_assocs_id_lock);

419

idr_remove(&sctp_assocs_id, asoc->assoc_id);

419

idr_remove(&sctp_assocs_id, asoc->assoc_id);

420

spin_unlock_bh(&sctp_assocs_id_lock);

420

spin_unlock_bh(&sctp_assocs_id_lock);

421

}

421

}

422

423

WARN_ON(atomic_read(&asoc->rmem_alloc));

423

WARN_ON(atomic_read(&asoc->rmem_alloc));

424

425

kfree(asoc);

425

kfree(asoc);

426

SCTP_DBG_OBJCNT_DEC(assoc);

426

SCTP_DBG_OBJCNT_DEC(assoc);

427

}

427

}

428

429

/* Change the primary destination address for the peer. */

429

/* Change the primary destination address for the peer. */

430

void sctp_assoc_set_primary(struct sctp_association *asoc,

430

void sctp_assoc_set_primary(struct sctp_association *asoc,

431

struct sctp_transport *transport)

431

struct sctp_transport *transport)

432

{

432

{

433

int changeover = 0;

433

int changeover = 0;

434

435

/* it's a changeover only if we already have a primary path

435

/* it's a changeover only if we already have a primary path

436

* that we are changing

436

* that we are changing

437

*/

437

*/

438

if (asoc->peer.primary_path != NULL &&

438

if (asoc->peer.primary_path != NULL &&

439

asoc->peer.primary_path != transport)

439

asoc->peer.primary_path != transport)

440

changeover = 1 ;

440

changeover = 1 ;

441

442

asoc->peer.primary_path = transport;

442

asoc->peer.primary_path = transport;

443

444

/* Set a default msg_name for events. */

444

/* Set a default msg_name for events. */

445

memcpy(&asoc->peer.primary_addr, &transport->ipaddr,

445

memcpy(&asoc->peer.primary_addr, &transport->ipaddr,

446

sizeof(union sctp_addr));

446

sizeof(union sctp_addr));

447

448

/* If the primary path is changing, assume that the

448

/* If the primary path is changing, assume that the

449

* user wants to use this new path.

449

* user wants to use this new path.

450

*/

450

*/

451

if ((transport->state == SCTP_ACTIVE) ||

451

if ((transport->state == SCTP_ACTIVE) ||

452

(transport->state == SCTP_UNKNOWN))

452

(transport->state == SCTP_UNKNOWN))

453

asoc->peer.active_path = transport;

453

asoc->peer.active_path = transport;

454

455

/*

455

/*

456

* SFR-CACC algorithm:

456

* SFR-CACC algorithm:

457

* Upon the receipt of a request to change the primary

457

* Upon the receipt of a request to change the primary

458

* destination address, on the data structure for the new

458

* destination address, on the data structure for the new

459

* primary destination, the sender MUST do the following:

459

* primary destination, the sender MUST do the following:

460

*

460

*

461

* 1) If CHANGEOVER_ACTIVE is set, then there was a switch

461

* 1) If CHANGEOVER_ACTIVE is set, then there was a switch

462

* to this destination address earlier. The sender MUST set

462

* to this destination address earlier. The sender MUST set

463

* CYCLING_CHANGEOVER to indicate that this switch is a

463

* CYCLING_CHANGEOVER to indicate that this switch is a

464

* double switch to the same destination address.

464

* double switch to the same destination address.

465

*

465

*

466

* Really, only bother is we have data queued or outstanding on

466

* Really, only bother is we have data queued or outstanding on

467

* the association.

467

* the association.

468

*/

468

*/

469

if (!asoc->outqueue.outstanding_bytes && !asoc->outqueue.out_qlen)

469

if (!asoc->outqueue.outstanding_bytes && !asoc->outqueue.out_qlen)

470

return;

470

return;

471

472

if (transport->cacc.changeover_active)

472

if (transport->cacc.changeover_active)

473

transport->cacc.cycling_changeover = changeover;

473

transport->cacc.cycling_changeover = changeover;

474

475

/* 2) The sender MUST set CHANGEOVER_ACTIVE to indicate that

475

/* 2) The sender MUST set CHANGEOVER_ACTIVE to indicate that

476

* a changeover has occurred.

476

* a changeover has occurred.

477

*/

477

*/

478

transport->cacc.changeover_active = changeover;

478

transport->cacc.changeover_active = changeover;

479

480

/* 3) The sender MUST store the next TSN to be sent in

480

/* 3) The sender MUST store the next TSN to be sent in

481

* next_tsn_at_change.

481

* next_tsn_at_change.

482

*/

482

*/

483

transport->cacc.next_tsn_at_change = asoc->next_tsn;

483

transport->cacc.next_tsn_at_change = asoc->next_tsn;

484

}

484

}

485

486

/* Remove a transport from an association. */

486

/* Remove a transport from an association. */

487

void sctp_assoc_rm_peer(struct sctp_association *asoc,

487

void sctp_assoc_rm_peer(struct sctp_association *asoc,

488

struct sctp_transport *peer)

488

struct sctp_transport *peer)

489

{

489

{

490

struct list_head *pos;

490

struct list_head *pos;

491

struct sctp_transport *transport;

491

struct sctp_transport *transport;

492

493

pr_debug("%s: association:%p addr:%pISpc\n",

493

pr_debug("%s: association:%p addr:%pISpc\n",

494

__func__, asoc, &peer->ipaddr.sa);

494

__func__, asoc, &peer->ipaddr.sa);

495

496

/* If we are to remove the current retran_path, update it

496

/* If we are to remove the current retran_path, update it

497

* to the next peer before removing this peer from the list.

497

* to the next peer before removing this peer from the list.

498

*/

498

*/

499

if (asoc->peer.retran_path == peer)

499

if (asoc->peer.retran_path == peer)

500

sctp_assoc_update_retran_path(asoc);

500

sctp_assoc_update_retran_path(asoc);

501

502

/* Remove this peer from the list. */

502

/* Remove this peer from the list. */

503

list_del_rcu(&peer->transports);

503

list_del_rcu(&peer->transports);

504

505

/* Get the first transport of asoc. */

505

/* Get the first transport of asoc. */

506

pos = asoc->peer.transport_addr_list.next;

506

pos = asoc->peer.transport_addr_list.next;

507

transport = list_entry(pos, struct sctp_transport, transports);

507

transport = list_entry(pos, struct sctp_transport, transports);

508

509

/* Update any entries that match the peer to be deleted. */

509

/* Update any entries that match the peer to be deleted. */

510

if (asoc->peer.primary_path == peer)

510

if (asoc->peer.primary_path == peer)

511

sctp_assoc_set_primary(asoc, transport);

511

sctp_assoc_set_primary(asoc, transport);

512

if (asoc->peer.active_path == peer)

512

if (asoc->peer.active_path == peer)

513

asoc->peer.active_path = transport;

513

asoc->peer.active_path = transport;

514

if (asoc->peer.retran_path == peer)

514

if (asoc->peer.retran_path == peer)

515

asoc->peer.retran_path = transport;

515

asoc->peer.retran_path = transport;

516

if (asoc->peer.last_data_from == peer)

516

if (asoc->peer.last_data_from == peer)

517

asoc->peer.last_data_from = transport;

517

asoc->peer.last_data_from = transport;

518

519

/* If we remove the transport an INIT was last sent to, set it to

519

/* If we remove the transport an INIT was last sent to, set it to

520

* NULL. Combined with the update of the retran path above, this

520

* NULL. Combined with the update of the retran path above, this

521

* will cause the next INIT to be sent to the next available

521

* will cause the next INIT to be sent to the next available

522

* transport, maintaining the cycle.

522

* transport, maintaining the cycle.

523

*/

523

*/

524

if (asoc->init_last_sent_to == peer)

524

if (asoc->init_last_sent_to == peer)

525

asoc->init_last_sent_to = NULL;

525

asoc->init_last_sent_to = NULL;

526

527

/* If we remove the transport an SHUTDOWN was last sent to, set it

527

/* If we remove the transport an SHUTDOWN was last sent to, set it

528

* to NULL. Combined with the update of the retran path above, this

528

* to NULL. Combined with the update of the retran path above, this

529

* will cause the next SHUTDOWN to be sent to the next available

529

* will cause the next SHUTDOWN to be sent to the next available

530

* transport, maintaining the cycle.

530

* transport, maintaining the cycle.

531

*/

531

*/

532

if (asoc->shutdown_last_sent_to == peer)

532

if (asoc->shutdown_last_sent_to == peer)

533

asoc->shutdown_last_sent_to = NULL;

533

asoc->shutdown_last_sent_to = NULL;

534

535

/* If we remove the transport an ASCONF was last sent to, set it to

535

/* If we remove the transport an ASCONF was last sent to, set it to

536

* NULL.

536

* NULL.

537

*/

537

*/

538

if (asoc->addip_last_asconf &&

538

if (asoc->addip_last_asconf &&

539

asoc->addip_last_asconf->transport == peer)

539

asoc->addip_last_asconf->transport == peer)

540

asoc->addip_last_asconf->transport = NULL;

540

asoc->addip_last_asconf->transport = NULL;

541

542

/* If we have something on the transmitted list, we have to

542

/* If we have something on the transmitted list, we have to

543

* save it off. The best place is the active path.

543

* save it off. The best place is the active path.

544

*/

544

*/

545

if (!list_empty(&peer->transmitted)) {

545

if (!list_empty(&peer->transmitted)) {

546

struct sctp_transport *active = asoc->peer.active_path;

546

struct sctp_transport *active = asoc->peer.active_path;

547

struct sctp_chunk *ch;

547

struct sctp_chunk *ch;

548

549

/* Reset the transport of each chunk on this list */

549

/* Reset the transport of each chunk on this list */

550

list_for_each_entry(ch, &peer->transmitted,

550

list_for_each_entry(ch, &peer->transmitted,

551

transmitted_list) {

551

transmitted_list) {

552

ch->transport = NULL;

552

ch->transport = NULL;

553

ch->rtt_in_progress = 0;

553

ch->rtt_in_progress = 0;

554

}

554

}

555

556

list_splice_tail_init(&peer->transmitted,

556

list_splice_tail_init(&peer->transmitted,

557

&active->transmitted);

557

&active->transmitted);

558

559

/* Start a T3 timer here in case it wasn't running so

559

/* Start a T3 timer here in case it wasn't running so

560

* that these migrated packets have a chance to get

560

* that these migrated packets have a chance to get

561

* retransmitted.

561

* retransmitted.

562

*/

562

*/

563

if (!timer_pending(&active->T3_rtx_timer))

563

if (!timer_pending(&active->T3_rtx_timer))

564

if (!mod_timer(&active->T3_rtx_timer,

564

if (!mod_timer(&active->T3_rtx_timer,

565

jiffies + active->rto))

565

jiffies + active->rto))

566

sctp_transport_hold(active);

566

sctp_transport_hold(active);

567

}

567

}

568

569

asoc->peer.transport_count--;

569

asoc->peer.transport_count--;

570

571

sctp_transport_free(peer);

571

sctp_transport_free(peer);

572

}

572

}

573

574

/* Add a transport address to an association. */

574

/* Add a transport address to an association. */

575

struct sctp_transport *sctp_assoc_add_peer(struct sctp_association *asoc,

575

struct sctp_transport *sctp_assoc_add_peer(struct sctp_association *asoc,

576

const union sctp_addr *addr,

576

const union sctp_addr *addr,

577

const gfp_t gfp,

577

const gfp_t gfp,

578

const int peer_state)

578

const int peer_state)

579

{

579

{

580

struct net *net = sock_net(asoc->base.sk);

580

struct net *net = sock_net(asoc->base.sk);

581

struct sctp_transport *peer;

581

struct sctp_transport *peer;

582

struct sctp_sock *sp;

582

struct sctp_sock *sp;

583

unsigned short port;

583

unsigned short port;

584

585

sp = sctp_sk(asoc->base.sk);

585

sp = sctp_sk(asoc->base.sk);

586

587

/* AF_INET and AF_INET6 share common port field. */

587

/* AF_INET and AF_INET6 share common port field. */

588

port = ntohs(addr->v4.sin_port);

588

port = ntohs(addr->v4.sin_port);

589

590

pr_debug("%s: association:%p addr:%pISpc state:%d\n", __func__,

590

pr_debug("%s: association:%p addr:%pISpc state:%d\n", __func__,

591

asoc, &addr->sa, peer_state);

591

asoc, &addr->sa, peer_state);

592

593

/* Set the port if it has not been set yet. */

593

/* Set the port if it has not been set yet. */

594

if (0 == asoc->peer.port)

594

if (0 == asoc->peer.port)

595

asoc->peer.port = port;

595

asoc->peer.port = port;

596

597

/* Check to see if this is a duplicate. */

597

/* Check to see if this is a duplicate. */

598

peer = sctp_assoc_lookup_paddr(asoc, addr);

598

peer = sctp_assoc_lookup_paddr(asoc, addr);

599

if (peer) {

599

if (peer) {

600

/* An UNKNOWN state is only set on transports added by

600

/* An UNKNOWN state is only set on transports added by

601

* user in sctp_connectx() call. Such transports should be

601

* user in sctp_connectx() call. Such transports should be

602

* considered CONFIRMED per RFC 4960, Section 5.4.

602

* considered CONFIRMED per RFC 4960, Section 5.4.

603

*/

603

*/

604

if (peer->state == SCTP_UNKNOWN) {

604

if (peer->state == SCTP_UNKNOWN) {

605

peer->state = SCTP_ACTIVE;

605

peer->state = SCTP_ACTIVE;

606

}

606

}

607

return peer;

607

return peer;

608

}

608

}

609

610

peer = sctp_transport_new(net, addr, gfp);

610

peer = sctp_transport_new(net, addr, gfp);

611

if (!peer)

611

if (!peer)

612

return NULL;

612

return NULL;

613

614

sctp_transport_set_owner(peer, asoc);

614

sctp_transport_set_owner(peer, asoc);

615

616

/* Initialize the peer's heartbeat interval based on the

616

/* Initialize the peer's heartbeat interval based on the

617

* association configured value.

617

* association configured value.

618

*/

618

*/

619

peer->hbinterval = asoc->hbinterval;

619

peer->hbinterval = asoc->hbinterval;

620

621

/* Set the path max_retrans. */

621

/* Set the path max_retrans. */

622

peer->pathmaxrxt = asoc->pathmaxrxt;

622

peer->pathmaxrxt = asoc->pathmaxrxt;

623

624

/* And the partial failure retrans threshold */

624

/* And the partial failure retrans threshold */

625

peer->pf_retrans = asoc->pf_retrans;

625

peer->pf_retrans = asoc->pf_retrans;

626

627

/* Initialize the peer's SACK delay timeout based on the

627

/* Initialize the peer's SACK delay timeout based on the

628

* association configured value.

628

* association configured value.

629

*/

629

*/

630

peer->sackdelay = asoc->sackdelay;

630

peer->sackdelay = asoc->sackdelay;

631

peer->sackfreq = asoc->sackfreq;

631

peer->sackfreq = asoc->sackfreq;

632

633

/* Enable/disable heartbeat, SACK delay, and path MTU discovery

633

/* Enable/disable heartbeat, SACK delay, and path MTU discovery

634

* based on association setting.

634

* based on association setting.

635

*/

635

*/

636

peer->param_flags = asoc->param_flags;

636

peer->param_flags = asoc->param_flags;

637

638

sctp_transport_route(peer, NULL, sp);

638

sctp_transport_route(peer, NULL, sp);

639

640

/* Initialize the pmtu of the transport. */

640

/* Initialize the pmtu of the transport. */

641

if (peer->param_flags & SPP_PMTUD_DISABLE) {

641

if (peer->param_flags & SPP_PMTUD_DISABLE) {

642

if (asoc->pathmtu)

642

if (asoc->pathmtu)

643

peer->pathmtu = asoc->pathmtu;

643

peer->pathmtu = asoc->pathmtu;

644

else

644

else

645

peer->pathmtu = SCTP_DEFAULT_MAXSEGMENT;

645

peer->pathmtu = SCTP_DEFAULT_MAXSEGMENT;

646

}

646

}

647

648

/* If this is the first transport addr on this association,

648

/* If this is the first transport addr on this association,

649

* initialize the association PMTU to the peer's PMTU.

649

* initialize the association PMTU to the peer's PMTU.

650

* If not and the current association PMTU is higher than the new

650

* If not and the current association PMTU is higher than the new

651

* peer's PMTU, reset the association PMTU to the new peer's PMTU.

651

* peer's PMTU, reset the association PMTU to the new peer's PMTU.

652

*/

652

*/

653

if (asoc->pathmtu)

653

if (asoc->pathmtu)

654

asoc->pathmtu = min_t(int, peer->pathmtu, asoc->pathmtu);

654

asoc->pathmtu = min_t(int, peer->pathmtu, asoc->pathmtu);

655

else

655

else

656

asoc->pathmtu = peer->pathmtu;

656

asoc->pathmtu = peer->pathmtu;

657

658

pr_debug("%s: association:%p PMTU set to %d\n", __func__, asoc,

658

pr_debug("%s: association:%p PMTU set to %d\n", __func__, asoc,

659

asoc->pathmtu);

659

asoc->pathmtu);

660

661

peer->pmtu_pending = 0;

661

peer->pmtu_pending = 0;

662

663

asoc->frag_point = sctp_frag_point(asoc, asoc->pathmtu);

663

asoc->frag_point = sctp_frag_point(asoc, asoc->pathmtu);

664

665

/* The asoc->peer.port might not be meaningful yet, but

665

/* The asoc->peer.port might not be meaningful yet, but

666

* initialize the packet structure anyway.

666

* initialize the packet structure anyway.

667

*/

667

*/

668

sctp_packet_init(&peer->packet, peer, asoc->base.bind_addr.port,

668

sctp_packet_init(&peer->packet, peer, asoc->base.bind_addr.port,

669

asoc->peer.port);

669

asoc->peer.port);

670

671

/* 7.2.1 Slow-Start

671

/* 7.2.1 Slow-Start

672

*

672

*

673

* o The initial cwnd before DATA transmission or after a sufficiently

673

* o The initial cwnd before DATA transmission or after a sufficiently

674

* long idle period MUST be set to

674

* long idle period MUST be set to

675

* min(4*MTU, max(2*MTU, 4380 bytes))

675

* min(4*MTU, max(2*MTU, 4380 bytes))

676

*

676

*

677

* o The initial value of ssthresh MAY be arbitrarily high

677

* o The initial value of ssthresh MAY be arbitrarily high

678

* (for example, implementations MAY use the size of the

678

* (for example, implementations MAY use the size of the

679

* receiver advertised window).

679

* receiver advertised window).

680

*/

680

*/

681

peer->cwnd = min(4*asoc->pathmtu, max_t(__u32, 2*asoc->pathmtu, 4380));

681

peer->cwnd = min(4*asoc->pathmtu, max_t(__u32, 2*asoc->pathmtu, 4380));

682

683

/* At this point, we may not have the receiver's advertised window,

683

/* At this point, we may not have the receiver's advertised window,

684

* so initialize ssthresh to the default value and it will be set

684

* so initialize ssthresh to the default value and it will be set

685

* later when we process the INIT.

685

* later when we process the INIT.

686

*/

686

*/

687

peer->ssthresh = SCTP_DEFAULT_MAXWINDOW;

687

peer->ssthresh = SCTP_DEFAULT_MAXWINDOW;

688

689

peer->partial_bytes_acked = 0;

689

peer->partial_bytes_acked = 0;

690

peer->flight_size = 0;

690

peer->flight_size = 0;

691

peer->burst_limited = 0;

691

peer->burst_limited = 0;

692

693

/* Set the transport's RTO.initial value */

693

/* Set the transport's RTO.initial value */

694

peer->rto = asoc->rto_initial;

694

peer->rto = asoc->rto_initial;

695

sctp_max_rto(asoc, peer);

695

sctp_max_rto(asoc, peer);

696

697

/* Set the peer's active state. */

697

/* Set the peer's active state. */

698

peer->state = peer_state;

698

peer->state = peer_state;

699

700

/* Attach the remote transport to our asoc. */

700

/* Attach the remote transport to our asoc. */

701

list_add_tail_rcu(&peer->transports, &asoc->peer.transport_addr_list);

701

list_add_tail_rcu(&peer->transports, &asoc->peer.transport_addr_list);

702

asoc->peer.transport_count++;

702

asoc->peer.transport_count++;

703

704

/* If we do not yet have a primary path, set one. */

704

/* If we do not yet have a primary path, set one. */

705

if (!asoc->peer.primary_path) {

705

if (!asoc->peer.primary_path) {

706

sctp_assoc_set_primary(asoc, peer);

706

sctp_assoc_set_primary(asoc, peer);

707

asoc->peer.retran_path = peer;

707

asoc->peer.retran_path = peer;

708

}

708

}

709

710

if (asoc->peer.active_path == asoc->peer.retran_path &&

710

if (asoc->peer.active_path == asoc->peer.retran_path &&

711

peer->state != SCTP_UNCONFIRMED) {

711

peer->state != SCTP_UNCONFIRMED) {

712

asoc->peer.retran_path = peer;

712

asoc->peer.retran_path = peer;

713

}

713

}

714

715

return peer;

715

return peer;

716

}

716

}

717

718

/* Delete a transport address from an association. */

718

/* Delete a transport address from an association. */

719

void sctp_assoc_del_peer(struct sctp_association *asoc,

719

void sctp_assoc_del_peer(struct sctp_association *asoc,

720

const union sctp_addr *addr)

720

const union sctp_addr *addr)

721

{

721

{

722

struct list_head *pos;

722

struct list_head *pos;

723

struct list_head *temp;

723

struct list_head *temp;

724

struct sctp_transport *transport;

724

struct sctp_transport *transport;

725

726

list_for_each_safe(pos, temp, &asoc->peer.transport_addr_list) {

726

list_for_each_safe(pos, temp, &asoc->peer.transport_addr_list) {

727

transport = list_entry(pos, struct sctp_transport, transports);

727

transport = list_entry(pos, struct sctp_transport, transports);

728

if (sctp_cmp_addr_exact(addr, &transport->ipaddr)) {

728

if (sctp_cmp_addr_exact(addr, &transport->ipaddr)) {

729

/* Do book keeping for removing the peer and free it. */

729

/* Do book keeping for removing the peer and free it. */

730

sctp_assoc_rm_peer(asoc, transport);

730

sctp_assoc_rm_peer(asoc, transport);

731

break;

731

break;

732

}

732

}

733

}

733

}

734

}

734

}

735

736

/* Lookup a transport by address. */

736

/* Lookup a transport by address. */

737

struct sctp_transport *sctp_assoc_lookup_paddr(

737

struct sctp_transport *sctp_assoc_lookup_paddr(

738

const struct sctp_association *asoc,

738

const struct sctp_association *asoc,

739

const union sctp_addr *address)

739

const union sctp_addr *address)

740

{

740

{

741

struct sctp_transport *t;

741

struct sctp_transport *t;

742

743

/* Cycle through all transports searching for a peer address. */

743

/* Cycle through all transports searching for a peer address. */

744

745

list_for_each_entry(t, &asoc->peer.transport_addr_list,

745

list_for_each_entry(t, &asoc->peer.transport_addr_list,

746

transports) {

746

transports) {

747

if (sctp_cmp_addr_exact(address, &t->ipaddr))

747

if (sctp_cmp_addr_exact(address, &t->ipaddr))

748

return t;

748

return t;

749

}

749

}

750

751

return NULL;

751

return NULL;

752

}

752

}

753

754

/* Remove all transports except a give one */

754

/* Remove all transports except a give one */

755

void sctp_assoc_del_nonprimary_peers(struct sctp_association *asoc,

755

void sctp_assoc_del_nonprimary_peers(struct sctp_association *asoc,

756

struct sctp_transport *primary)

756

struct sctp_transport *primary)

757

{

757

{

758

struct sctp_transport *temp;

758

struct sctp_transport *temp;

759

struct sctp_transport *t;

759

struct sctp_transport *t;

760

761

list_for_each_entry_safe(t, temp, &asoc->peer.transport_addr_list,

761

list_for_each_entry_safe(t, temp, &asoc->peer.transport_addr_list,

762

transports) {

762

transports) {

763

/* if the current transport is not the primary one, delete it */

763

/* if the current transport is not the primary one, delete it */

764

if (t != primary)

764

if (t != primary)

765

sctp_assoc_rm_peer(asoc, t);

765

sctp_assoc_rm_peer(asoc, t);

766

}

766

}

767

}

767

}

768

769

/* Engage in transport control operations.

769

/* Engage in transport control operations.

770

* Mark the transport up or down and send a notification to the user.

770

* Mark the transport up or down and send a notification to the user.

771

* Select and update the new active and retran paths.

771

* Select and update the new active and retran paths.

772

*/

772

*/

773

void sctp_assoc_control_transport(struct sctp_association *asoc,

773

void sctp_assoc_control_transport(struct sctp_association *asoc,

774

struct sctp_transport *transport,

774

struct sctp_transport *transport,

775

sctp_transport_cmd_t command,

775

sctp_transport_cmd_t command,

776

sctp_sn_error_t error)

776

sctp_sn_error_t error)

777

{

777

{

778

struct sctp_ulpevent *event;

778

struct sctp_ulpevent *event;

779

struct sockaddr_storage addr;

779

struct sockaddr_storage addr;

780

int spc_state = 0;

780

int spc_state = 0;

781

bool ulp_notify = true;

781

bool ulp_notify = true;

782

783

/* Record the transition on the transport. */

783

/* Record the transition on the transport. */

784

switch (command) {

784

switch (command) {

785

case SCTP_TRANSPORT_UP:

785

case SCTP_TRANSPORT_UP:

786

/* If we are moving from UNCONFIRMED state due

786

/* If we are moving from UNCONFIRMED state due

787

* to heartbeat success, report the SCTP_ADDR_CONFIRMED

787

* to heartbeat success, report the SCTP_ADDR_CONFIRMED

788

* state to the user, otherwise report SCTP_ADDR_AVAILABLE.

788

* state to the user, otherwise report SCTP_ADDR_AVAILABLE.

789

*/

789

*/

790

if (SCTP_UNCONFIRMED == transport->state &&

790

if (SCTP_UNCONFIRMED == transport->state &&

791

SCTP_HEARTBEAT_SUCCESS == error)

791

SCTP_HEARTBEAT_SUCCESS == error)

792

spc_state = SCTP_ADDR_CONFIRMED;

792

spc_state = SCTP_ADDR_CONFIRMED;

793

else

793

else

794

spc_state = SCTP_ADDR_AVAILABLE;

794

spc_state = SCTP_ADDR_AVAILABLE;

795

/* Don't inform ULP about transition from PF to

795

/* Don't inform ULP about transition from PF to

796

* active state and set cwnd to 1 MTU, see SCTP

796

* active state and set cwnd to 1 MTU, see SCTP

797

* Quick failover draft section 5.1, point 5

797

* Quick failover draft section 5.1, point 5

798

*/

798

*/

799

if (transport->state == SCTP_PF) {

799

if (transport->state == SCTP_PF) {

800

ulp_notify = false;

800

ulp_notify = false;

801

transport->cwnd = asoc->pathmtu;

801

transport->cwnd = asoc->pathmtu;

802

}

802

}

803

transport->state = SCTP_ACTIVE;

803

transport->state = SCTP_ACTIVE;

804

break;

804

break;

805

806

case SCTP_TRANSPORT_DOWN:

806

case SCTP_TRANSPORT_DOWN:

807

/* If the transport was never confirmed, do not transition it

807

/* If the transport was never confirmed, do not transition it

808

* to inactive state. Also, release the cached route since

808

* to inactive state. Also, release the cached route since

809

* there may be a better route next time.

809

* there may be a better route next time.

810

*/

810

*/

811

if (transport->state != SCTP_UNCONFIRMED)

811

if (transport->state != SCTP_UNCONFIRMED)

812

transport->state = SCTP_INACTIVE;

812

transport->state = SCTP_INACTIVE;

813

else {

813

else {

814

dst_release(transport->dst);

814

dst_release(transport->dst);

815

transport->dst = NULL;

815

transport->dst = NULL;

816

ulp_notify = false;

816

ulp_notify = false;

817

}

817

}

818

819

spc_state = SCTP_ADDR_UNREACHABLE;

819

spc_state = SCTP_ADDR_UNREACHABLE;

820

break;

820

break;

821

822

case SCTP_TRANSPORT_PF:

822

case SCTP_TRANSPORT_PF:

823

transport->state = SCTP_PF;

823

transport->state = SCTP_PF;

824

ulp_notify = false;

824

ulp_notify = false;

825

break;

825

break;

826

827

default:

827

default:

828

return;

828

return;

829

}

829

}

830

831

/* Generate and send a SCTP_PEER_ADDR_CHANGE notification

831

/* Generate and send a SCTP_PEER_ADDR_CHANGE notification

832

* to the user.

832

* to the user.

833

*/

833

*/

834

if (ulp_notify) {

834

if (ulp_notify) {

835

memset(&addr, 0, sizeof(struct sockaddr_storage));

835

memset(&addr, 0, sizeof(struct sockaddr_storage));

836

memcpy(&addr, &transport->ipaddr,

836

memcpy(&addr, &transport->ipaddr,

837

transport->af_specific->sockaddr_len);

837

transport->af_specific->sockaddr_len);

838

839

event = sctp_ulpevent_make_peer_addr_change(asoc, &addr,

839

event = sctp_ulpevent_make_peer_addr_change(asoc, &addr,

840

0, spc_state, error, GFP_ATOMIC);

840

0, spc_state, error, GFP_ATOMIC);

841

if (event)

841

if (event)

842

sctp_ulpq_tail_event(&asoc->ulpq, event);

842

sctp_ulpq_tail_event(&asoc->ulpq, event);

843

}

843

}

844

845

/* Select new active and retran paths. */

845

/* Select new active and retran paths. */

846

sctp_select_active_and_retran_path(asoc);

846

sctp_select_active_and_retran_path(asoc);

847

}

847

}

848

849

/* Hold a reference to an association. */

849

/* Hold a reference to an association. */

850

void sctp_association_hold(struct sctp_association *asoc)

850

void sctp_association_hold(struct sctp_association *asoc)

851

{

851

{

852

atomic_inc(&asoc->base.refcnt);

852

atomic_inc(&asoc->base.refcnt);

853

}

853

}

854

855

/* Release a reference to an association and cleanup

855

/* Release a reference to an association and cleanup

856

* if there are no more references.

856

* if there are no more references.

857

*/

857

*/

858

void sctp_association_put(struct sctp_association *asoc)

858

void sctp_association_put(struct sctp_association *asoc)

859

{

859

{

860

if (atomic_dec_and_test(&asoc->base.refcnt))

860

if (atomic_dec_and_test(&asoc->base.refcnt))

861

sctp_association_destroy(asoc);

861

sctp_association_destroy(asoc);

862

}

862

}

863

864

/* Allocate the next TSN, Transmission Sequence Number, for the given

864

/* Allocate the next TSN, Transmission Sequence Number, for the given

865

* association.

865

* association.

866

*/

866

*/

867

__u32 sctp_association_get_next_tsn(struct sctp_association *asoc)

867

__u32 sctp_association_get_next_tsn(struct sctp_association *asoc)

868

{

868

{

869

/* From Section 1.6 Serial Number Arithmetic:

869

/* From Section 1.6 Serial Number Arithmetic:

870

* Transmission Sequence Numbers wrap around when they reach

870

* Transmission Sequence Numbers wrap around when they reach

871

* 2**32 - 1. That is, the next TSN a DATA chunk MUST use

871

* 2**32 - 1. That is, the next TSN a DATA chunk MUST use

872

* after transmitting TSN = 2*32 - 1 is TSN = 0.

872

* after transmitting TSN = 2*32 - 1 is TSN = 0.

873

*/

873

*/

874

__u32 retval = asoc->next_tsn;

874

__u32 retval = asoc->next_tsn;

875

asoc->next_tsn++;

875

asoc->next_tsn++;

876

asoc->unack_data++;

876

asoc->unack_data++;

877

878

return retval;

878

return retval;

879

}

879

}

880

881

/* Compare two addresses to see if they match. Wildcard addresses

881

/* Compare two addresses to see if they match. Wildcard addresses

882

* only match themselves.

882

* only match themselves.

883

*/

883

*/

884

int sctp_cmp_addr_exact(const union sctp_addr *ss1,

884

int sctp_cmp_addr_exact(const union sctp_addr *ss1,

885

const union sctp_addr *ss2)

885

const union sctp_addr *ss2)

886

{

886

{

887

struct sctp_af *af;

887

struct sctp_af *af;

888

889

af = sctp_get_af_specific(ss1->sa.sa_family);

889

af = sctp_get_af_specific(ss1->sa.sa_family);

890

if (unlikely(!af))

890

if (unlikely(!af))

891

return 0;

891

return 0;

892

893

return af->cmp_addr(ss1, ss2);

893

return af->cmp_addr(ss1, ss2);

894

}

894

}

895

896

/* Return an ecne chunk to get prepended to a packet.

896

/* Return an ecne chunk to get prepended to a packet.

897

* Note: We are sly and return a shared, prealloced chunk. FIXME:

897

* Note: We are sly and return a shared, prealloced chunk. FIXME:

898

* No we don't, but we could/should.

898

* No we don't, but we could/should.

899

*/

899

*/

900

struct sctp_chunk *sctp_get_ecne_prepend(struct sctp_association *asoc)

900

struct sctp_chunk *sctp_get_ecne_prepend(struct sctp_association *asoc)

901

{

901

{

902

if (!asoc->need_ecne)

902

if (!asoc->need_ecne)

903

return NULL;

903

return NULL;

904

905

/* Send ECNE if needed.

905

/* Send ECNE if needed.

906

* Not being able to allocate a chunk here is not deadly.

906

* Not being able to allocate a chunk here is not deadly.

907

*/

907

*/

908

return sctp_make_ecne(asoc, asoc->last_ecne_tsn);

908

return sctp_make_ecne(asoc, asoc->last_ecne_tsn);

909

}

909

}

910

911

/*

911

/*

912

* Find which transport this TSN was sent on.

912

* Find which transport this TSN was sent on.

913

*/

913

*/

914

struct sctp_transport *sctp_assoc_lookup_tsn(struct sctp_association *asoc,

914

struct sctp_transport *sctp_assoc_lookup_tsn(struct sctp_association *asoc,

915

__u32 tsn)

915

__u32 tsn)

916

{

916

{

917

struct sctp_transport *active;

917

struct sctp_transport *active;

918

struct sctp_transport *match;

918

struct sctp_transport *match;

919

struct sctp_transport *transport;

919

struct sctp_transport *transport;

920

struct sctp_chunk *chunk;

920

struct sctp_chunk *chunk;

921

__be32 key = htonl(tsn);

921

__be32 key = htonl(tsn);

922

923

match = NULL;

923

match = NULL;

924

925

/*

925

/*

926

* FIXME: In general, find a more efficient data structure for

926

* FIXME: In general, find a more efficient data structure for

927

* searching.

927

* searching.

928

*/

928

*/

929

930

/*

930

/*

931

* The general strategy is to search each transport's transmitted

931

* The general strategy is to search each transport's transmitted

932

* list. Return which transport this TSN lives on.

932

* list. Return which transport this TSN lives on.

933

*

933

*

934

* Let's be hopeful and check the active_path first.

934

* Let's be hopeful and check the active_path first.

935

* Another optimization would be to know if there is only one

935

* Another optimization would be to know if there is only one

936

* outbound path and not have to look for the TSN at all.

936

* outbound path and not have to look for the TSN at all.

937

*

937

*

938

*/

938

*/

939

940

active = asoc->peer.active_path;

940

active = asoc->peer.active_path;

941

942

list_for_each_entry(chunk, &active->transmitted,

942

list_for_each_entry(chunk, &active->transmitted,

943

transmitted_list) {

943

transmitted_list) {

944

945

if (key == chunk->subh.data_hdr->tsn) {

945

if (key == chunk->subh.data_hdr->tsn) {

946

match = active;

946

match = active;

947

goto out;

947

goto out;

948

}

948

}

949

}

949

}

950

951

/* If not found, go search all the other transports. */

951

/* If not found, go search all the other transports. */

952

list_for_each_entry(transport, &asoc->peer.transport_addr_list,

952

list_for_each_entry(transport, &asoc->peer.transport_addr_list,

953

transports) {

953

transports) {

954

955

if (transport == active)

955

if (transport == active)

956

continue;

956

continue;

957

list_for_each_entry(chunk, &transport->transmitted,

957

list_for_each_entry(chunk, &transport->transmitted,

958

transmitted_list) {

958

transmitted_list) {

959

if (key == chunk->subh.data_hdr->tsn) {

959

if (key == chunk->subh.data_hdr->tsn) {

960

match = transport;

960

match = transport;

961

goto out;

961

goto out;

962

}

962

}

963

}

963

}

964

}

964

}

965

out:

965

out:

966

return match;

966

return match;

967

}

967

}

968

969

/* Is this the association we are looking for? */

969

/* Is this the association we are looking for? */

970

struct sctp_transport *sctp_assoc_is_match(struct sctp_association *asoc,

970

struct sctp_transport *sctp_assoc_is_match(struct sctp_association *asoc,

971

struct net *net,

971

struct net *net,

972

const union sctp_addr *laddr,

972

const union sctp_addr *laddr,

973

const union sctp_addr *paddr)

973

const union sctp_addr *paddr)

974

{

974

{

975

struct sctp_transport *transport;

975

struct sctp_transport *transport;

976

977

if ((htons(asoc->base.bind_addr.port) == laddr->v4.sin_port) &&

977

if ((htons(asoc->base.bind_addr.port) == laddr->v4.sin_port) &&

978

(htons(asoc->peer.port) == paddr->v4.sin_port) &&

978

(htons(asoc->peer.port) == paddr->v4.sin_port) &&

979

net_eq(sock_net(asoc->base.sk), net)) {

979

net_eq(sock_net(asoc->base.sk), net)) {

980

transport = sctp_assoc_lookup_paddr(asoc, paddr);

980

transport = sctp_assoc_lookup_paddr(asoc, paddr);

981

if (!transport)

981

if (!transport)

982

goto out;

982

goto out;

983

984

if (sctp_bind_addr_match(&asoc->base.bind_addr, laddr,

984

if (sctp_bind_addr_match(&asoc->base.bind_addr, laddr,

985

sctp_sk(asoc->base.sk)))

985

sctp_sk(asoc->base.sk)))

986

goto out;

986

goto out;

987

}

987

}

988

transport = NULL;

988

transport = NULL;

989

990

out:

990

out:

991

return transport;

991

return transport;

992

}

992

}

993

994

/* Do delayed input processing. This is scheduled by sctp_rcv(). */

994

/* Do delayed input processing. This is scheduled by sctp_rcv(). */

995

static void sctp_assoc_bh_rcv(struct work_struct *work)

995

static void sctp_assoc_bh_rcv(struct work_struct *work)

996

{

996

{

997

struct sctp_association *asoc =

997

struct sctp_association *asoc =

998

container_of(work, struct sctp_association,

998

container_of(work, struct sctp_association,

999

base.inqueue.immediate);

999

base.inqueue.immediate);

1000

struct net *net = sock_net(asoc->base.sk);

1000

struct net *net = sock_net(asoc->base.sk);

1001

struct sctp_endpoint *ep;

1001

struct sctp_endpoint *ep;

1002

struct sctp_chunk *chunk;

1002

struct sctp_chunk *chunk;

1003

struct sctp_inq *inqueue;

1003

struct sctp_inq *inqueue;

1004

int state;

1004

int state;

1005

sctp_subtype_t subtype;

1005

sctp_subtype_t subtype;

1006

int error = 0;

1006

int error = 0;

1007

1008

/* The association should be held so we should be safe. */

1008

/* The association should be held so we should be safe. */

1009

ep = asoc->ep;

1009

ep = asoc->ep;

1010

1011

inqueue = &asoc->base.inqueue;

1011

inqueue = &asoc->base.inqueue;

1012

sctp_association_hold(asoc);

1012

sctp_association_hold(asoc);

1013

while (NULL != (chunk = sctp_inq_pop(inqueue))) {

1013

while (NULL != (chunk = sctp_inq_pop(inqueue))) {

1014

state = asoc->state;

1014

state = asoc->state;

1015

subtype = SCTP_ST_CHUNK(chunk->chunk_hdr->type);

1015

subtype = SCTP_ST_CHUNK(chunk->chunk_hdr->type);

1016

1017

/* SCTP-AUTH, Section 6.3:

1017

/* SCTP-AUTH, Section 6.3:

1018

* The receiver has a list of chunk types which it expects

1018

* The receiver has a list of chunk types which it expects

1019

* to be received only after an AUTH-chunk. This list has

1019

* to be received only after an AUTH-chunk. This list has

1020

* been sent to the peer during the association setup. It

1020

* been sent to the peer during the association setup. It

1021

* MUST silently discard these chunks if they are not placed

1021

* MUST silently discard these chunks if they are not placed

1022

* after an AUTH chunk in the packet.

1022

* after an AUTH chunk in the packet.

1023

*/

1023

*/

1024

if (sctp_auth_recv_cid(subtype.chunk, asoc) && !chunk->auth)

1024

if (sctp_auth_recv_cid(subtype.chunk, asoc) && !chunk->auth)

1025

continue;

1025

continue;

1026

1027

/* Remember where the last DATA chunk came from so we

1027

/* Remember where the last DATA chunk came from so we

1028

* know where to send the SACK.

1028

* know where to send the SACK.

1029

*/

1029

*/

1030

if (sctp_chunk_is_data(chunk))

1030

if (sctp_chunk_is_data(chunk))

1031

asoc->peer.last_data_from = chunk->transport;

1031

asoc->peer.last_data_from = chunk->transport;

1032

else {

1032

else {

1033

SCTP_INC_STATS(net, SCTP_MIB_INCTRLCHUNKS);

1033

SCTP_INC_STATS(net, SCTP_MIB_INCTRLCHUNKS);

1034

asoc->stats.ictrlchunks++;

1034

asoc->stats.ictrlchunks++;

1035

if (chunk->chunk_hdr->type == SCTP_CID_SACK)

1035

if (chunk->chunk_hdr->type == SCTP_CID_SACK)

1036

asoc->stats.isacks++;

1036

asoc->stats.isacks++;

1037

}

1037

}

1038

1039

if (chunk->transport)

1039

if (chunk->transport)

1040

chunk->transport->last_time_heard = ktime_get();

1040

chunk->transport->last_time_heard = ktime_get();

1041

1042

/* Run through the state machine. */

1042

/* Run through the state machine. */

1043

error = sctp_do_sm(net, SCTP_EVENT_T_CHUNK, subtype,

1043

error = sctp_do_sm(net, SCTP_EVENT_T_CHUNK, subtype,

1044

state, ep, asoc, chunk, GFP_ATOMIC);

1044

state, ep, asoc, chunk, GFP_ATOMIC);

1045

1046

/* Check to see if the association is freed in response to

1046

/* Check to see if the association is freed in response to

1047

* the incoming chunk. If so, get out of the while loop.

1047

* the incoming chunk. If so, get out of the while loop.

1048

*/

1048

*/

1049

if (asoc->base.dead)

1049

if (asoc->base.dead)

1050

break;

1050

break;

1051

1052

/* If there is an error on chunk, discard this packet. */

1052

/* If there is an error on chunk, discard this packet. */

1053

if (error && chunk)

1053

if (error && chunk)

1054

chunk->pdiscard = 1;

1054

chunk->pdiscard = 1;

1055

}

1055

}

1056

sctp_association_put(asoc);

1056

sctp_association_put(asoc);

1057

}

1057

}

1058

1059

/* This routine moves an association from its old sk to a new sk. */

1059

/* This routine moves an association from its old sk to a new sk. */

1060

void sctp_assoc_migrate(struct sctp_association *assoc, struct sock *newsk)

1060

void sctp_assoc_migrate(struct sctp_association *assoc, struct sock *newsk)

1061

{

1061

{

1062

struct sctp_sock *newsp = sctp_sk(newsk);

1062

struct sctp_sock *newsp = sctp_sk(newsk);

1063

struct sock *oldsk = assoc->base.sk;

1063

struct sock *oldsk = assoc->base.sk;

1064

1065

/* Delete the association from the old endpoint's list of

1065

/* Delete the association from the old endpoint's list of

1066

* associations.

1066

* associations.

1067

*/

1067

*/

1068

list_del_init(&assoc->asocs);

1068

list_del_init(&assoc->asocs);

1069

1070

/* Decrement the backlog value for a TCP-style socket. */

1070

/* Decrement the backlog value for a TCP-style socket. */

1071

if (sctp_style(oldsk, TCP))

1071

if (sctp_style(oldsk, TCP))

1072

oldsk->sk_ack_backlog--;

1072

oldsk->sk_ack_backlog--;

1073

1074

/* Release references to the old endpoint and the sock. */

1074

/* Release references to the old endpoint and the sock. */

1075

sctp_endpoint_put(assoc->ep);

1075

sctp_endpoint_put(assoc->ep);

1076

sock_put(assoc->base.sk);

1076

sock_put(assoc->base.sk);

1077

1078

/* Get a reference to the new endpoint. */

1078

/* Get a reference to the new endpoint. */

1079

assoc->ep = newsp->ep;

1079

assoc->ep = newsp->ep;

1080

sctp_endpoint_hold(assoc->ep);

1080

sctp_endpoint_hold(assoc->ep);

1081

1082

/* Get a reference to the new sock. */

1082

/* Get a reference to the new sock. */

1083

assoc->base.sk = newsk;

1083

assoc->base.sk = newsk;

1084

sock_hold(assoc->base.sk);

1084

sock_hold(assoc->base.sk);

1085

1086

/* Add the association to the new endpoint's list of associations. */

1086

/* Add the association to the new endpoint's list of associations. */

1087

sctp_endpoint_add_asoc(newsp->ep, assoc);

1087

sctp_endpoint_add_asoc(newsp->ep, assoc);

1088

}

1088

}

1089

1090

/* Update an association (possibly from unexpected COOKIE-ECHO processing). */

1090

/* Update an association (possibly from unexpected COOKIE-ECHO processing). */

1091

void sctp_assoc_update(struct sctp_association *asoc,

1091

void sctp_assoc_update(struct sctp_association *asoc,

1092

struct sctp_association *new)

1092

struct sctp_association *new)

1093

{

1093

{

1094

struct sctp_transport *trans;

1094

struct sctp_transport *trans;

1095

struct list_head *pos, *temp;

1095

struct list_head *pos, *temp;

1096

1097

/* Copy in new parameters of peer. */

1097

/* Copy in new parameters of peer. */

1098

asoc->c = new->c;

1098

asoc->c = new->c;

1099

asoc->peer.rwnd = new->peer.rwnd;

1099

asoc->peer.rwnd = new->peer.rwnd;

1100

asoc->peer.sack_needed = new->peer.sack_needed;

1100

asoc->peer.sack_needed = new->peer.sack_needed;

1101

asoc->peer.auth_capable = new->peer.auth_capable;

1101

asoc->peer.auth_capable = new->peer.auth_capable;

1102

asoc->peer.i = new->peer.i;

1102

asoc->peer.i = new->peer.i;

1103

sctp_tsnmap_init(&asoc->peer.tsn_map, SCTP_TSN_MAP_INITIAL,

1103

sctp_tsnmap_init(&asoc->peer.tsn_map, SCTP_TSN_MAP_INITIAL,

1104

asoc->peer.i.initial_tsn, GFP_ATOMIC);

1104

asoc->peer.i.initial_tsn, GFP_ATOMIC);

1105

1106

/* Remove any peer addresses not present in the new association. */

1106

/* Remove any peer addresses not present in the new association. */

1107

list_for_each_safe(pos, temp, &asoc->peer.transport_addr_list) {

1107

list_for_each_safe(pos, temp, &asoc->peer.transport_addr_list) {

1108

trans = list_entry(pos, struct sctp_transport, transports);

1108

trans = list_entry(pos, struct sctp_transport, transports);

1109

if (!sctp_assoc_lookup_paddr(new, &trans->ipaddr)) {

1109

if (!sctp_assoc_lookup_paddr(new, &trans->ipaddr)) {

1110

sctp_assoc_rm_peer(asoc, trans);

1110

sctp_assoc_rm_peer(asoc, trans);

1111

continue;

1111

continue;

1112

}

1112

}

1113

1114

if (asoc->state >= SCTP_STATE_ESTABLISHED)

1114

if (asoc->state >= SCTP_STATE_ESTABLISHED)

1115

sctp_transport_reset(trans);

1115

sctp_transport_reset(trans);

1116

}

1116

}

1117

1118

/* If the case is A (association restart), use

1118

/* If the case is A (association restart), use

1119

* initial_tsn as next_tsn. If the case is B, use

1119

* initial_tsn as next_tsn. If the case is B, use

1120

* current next_tsn in case data sent to peer

1120

* current next_tsn in case data sent to peer

1121

* has been discarded and needs retransmission.

1121

* has been discarded and needs retransmission.

1122

*/

1122

*/

1123

if (asoc->state >= SCTP_STATE_ESTABLISHED) {

1123

if (asoc->state >= SCTP_STATE_ESTABLISHED) {

1124

asoc->next_tsn = new->next_tsn;

1124

asoc->next_tsn = new->next_tsn;

1125

asoc->ctsn_ack_point = new->ctsn_ack_point;

1125

asoc->ctsn_ack_point = new->ctsn_ack_point;

1126

asoc->adv_peer_ack_point = new->adv_peer_ack_point;

1126

asoc->adv_peer_ack_point = new->adv_peer_ack_point;

1127

1128

/* Reinitialize SSN for both local streams

1128

/* Reinitialize SSN for both local streams

1129

* and peer's streams.

1129

* and peer's streams.

1130

*/

1130

*/

1131

sctp_ssnmap_clear(asoc->ssnmap);

1131

sctp_ssnmap_clear(asoc->ssnmap);

1132

1133

/* Flush the ULP reassembly and ordered queue.

1133

/* Flush the ULP reassembly and ordered queue.

1134

* Any data there will now be stale and will

1134

* Any data there will now be stale and will

1135

* cause problems.

1135

* cause problems.

1136

*/

1136

*/

1137

sctp_ulpq_flush(&asoc->ulpq);

1137

sctp_ulpq_flush(&asoc->ulpq);

1138

1139

/* reset the overall association error count so

1139

/* reset the overall association error count so

1140

* that the restarted association doesn't get torn

1140

* that the restarted association doesn't get torn

1141

* down on the next retransmission timer.

1141

* down on the next retransmission timer.

1142

*/

1142

*/

1143

asoc->overall_error_count = 0;

1143

asoc->overall_error_count = 0;

1144

1145

} else {

1145

} else {

1146

/* Add any peer addresses from the new association. */

1146

/* Add any peer addresses from the new association. */

1147

list_for_each_entry(trans, &new->peer.transport_addr_list,

1147

list_for_each_entry(trans, &new->peer.transport_addr_list,

1148

transports) {

1148

transports) {

1149

if (!sctp_assoc_lookup_paddr(asoc, &trans->ipaddr))

1149

if (!sctp_assoc_lookup_paddr(asoc, &trans->ipaddr))

1150

sctp_assoc_add_peer(asoc, &trans->ipaddr,

1150

sctp_assoc_add_peer(asoc, &trans->ipaddr,

1151

GFP_ATOMIC, trans->state);

1151

GFP_ATOMIC, trans->state);

1152

}

1152

}

1153

1154

asoc->ctsn_ack_point = asoc->next_tsn - 1;

1154

asoc->ctsn_ack_point = asoc->next_tsn - 1;

1155

asoc->adv_peer_ack_point = asoc->ctsn_ack_point;

1155

asoc->adv_peer_ack_point = asoc->ctsn_ack_point;

1156

if (!asoc->ssnmap) {

1156

if (!asoc->ssnmap) {

1157

/* Move the ssnmap. */

1157

/* Move the ssnmap. */

1158

asoc->ssnmap = new->ssnmap;

1158

asoc->ssnmap = new->ssnmap;

1159

new->ssnmap = NULL;

1159

new->ssnmap = NULL;

1160

}

1160

}

1161

1162

if (!asoc->assoc_id) {

1162

if (!asoc->assoc_id) {

1163

/* get a new association id since we don't have one

1163

/* get a new association id since we don't have one

1164

* yet.

1164

* yet.

1165

*/

1165

*/

1166

sctp_assoc_set_id(asoc, GFP_ATOMIC);

1166

sctp_assoc_set_id(asoc, GFP_ATOMIC);

1167

}

1167

}

1168

}

1168

}

1169

1170

/* SCTP-AUTH: Save the peer parameters from the new associations

1170

/* SCTP-AUTH: Save the peer parameters from the new associations

1171

* and also move the association shared keys over

1171

* and also move the association shared keys over

1172

*/

1172

*/

1173

kfree(asoc->peer.peer_random);

1173

kfree(asoc->peer.peer_random);

1174

asoc->peer.peer_random = new->peer.peer_random;

1174

asoc->peer.peer_random = new->peer.peer_random;

1175

new->peer.peer_random = NULL;

1175

new->peer.peer_random = NULL;

1176

1177

kfree(asoc->peer.peer_chunks);

1177

kfree(asoc->peer.peer_chunks);

1178

asoc->peer.peer_chunks = new->peer.peer_chunks;

1178

asoc->peer.peer_chunks = new->peer.peer_chunks;

1179

new->peer.peer_chunks = NULL;

1179

new->peer.peer_chunks = NULL;

1180

1181

kfree(asoc->peer.peer_hmacs);

1181

kfree(asoc->peer.peer_hmacs);

1182

asoc->peer.peer_hmacs = new->peer.peer_hmacs;

1182

asoc->peer.peer_hmacs = new->peer.peer_hmacs;

1183

new->peer.peer_hmacs = NULL;

1183

new->peer.peer_hmacs = NULL;

1184

1185

sctp_auth_key_put(asoc->asoc_shared_key);

1186

sctp_auth_asoc_init_active_key(asoc, GFP_ATOMIC);

1185

sctp_auth_asoc_init_active_key(asoc, GFP_ATOMIC);

1187

}

1186

}

1188

1187

1189

/* Update the retran path for sending a retransmitted packet.

1188

/* Update the retran path for sending a retransmitted packet.

1190

* See also RFC4960, 6.4. Multi-Homed SCTP Endpoints:

1189

* See also RFC4960, 6.4. Multi-Homed SCTP Endpoints:

1191

*

1190

*

1192

* When there is outbound data to send and the primary path

1191

* When there is outbound data to send and the primary path

1193

* becomes inactive (e.g., due to failures), or where the

1192

* becomes inactive (e.g., due to failures), or where the

1194

* SCTP user explicitly requests to send data to an

1193

* SCTP user explicitly requests to send data to an

1195

* inactive destination transport address, before reporting

1194

* inactive destination transport address, before reporting

1196

* an error to its ULP, the SCTP endpoint should try to send

1195

* an error to its ULP, the SCTP endpoint should try to send

1197

* the data to an alternate active destination transport

1196

* the data to an alternate active destination transport

1198

* address if one exists.

1197

* address if one exists.

1199

*

1198

*

1200

* When retransmitting data that timed out, if the endpoint

1199

* When retransmitting data that timed out, if the endpoint

1201

* is multihomed, it should consider each source-destination

1200

* is multihomed, it should consider each source-destination

1202

* address pair in its retransmission selection policy.

1201

* address pair in its retransmission selection policy.

1203

* When retransmitting timed-out data, the endpoint should

1202

* When retransmitting timed-out data, the endpoint should

1204

* attempt to pick the most divergent source-destination

1203

* attempt to pick the most divergent source-destination

1205

* pair from the original source-destination pair to which

1204

* pair from the original source-destination pair to which

1206

* the packet was transmitted.

1205

* the packet was transmitted.

1207

*

1206

*

1208

* Note: Rules for picking the most divergent source-destination

1207

* Note: Rules for picking the most divergent source-destination

1209

* pair are an implementation decision and are not specified

1208

* pair are an implementation decision and are not specified

1210

* within this document.

1209

* within this document.

1211

*

1210

*

1212

* Our basic strategy is to round-robin transports in priorities

1211

* Our basic strategy is to round-robin transports in priorities

1213

* according to sctp_state_prio_map[] e.g., if no such

1212

* according to sctp_state_prio_map[] e.g., if no such

1214

* transport with state SCTP_ACTIVE exists, round-robin through

1213

* transport with state SCTP_ACTIVE exists, round-robin through

1215

* SCTP_UNKNOWN, etc. You get the picture.

1214

* SCTP_UNKNOWN, etc. You get the picture.

1216

*/

1215

*/

1217

static const u8 sctp_trans_state_to_prio_map[] = {

1216

static const u8 sctp_trans_state_to_prio_map[] = {

1218

[SCTP_ACTIVE] = 3, /* best case */

1217

[SCTP_ACTIVE] = 3, /* best case */

1219

[SCTP_UNKNOWN] = 2,

1218

[SCTP_UNKNOWN] = 2,

1220

[SCTP_PF] = 1,

1219

[SCTP_PF] = 1,

1221

[SCTP_INACTIVE] = 0, /* worst case */

1220

[SCTP_INACTIVE] = 0, /* worst case */

1222

};

1221

};

1223

1222

1224

static u8 sctp_trans_score(const struct sctp_transport *trans)

1223

static u8 sctp_trans_score(const struct sctp_transport *trans)

1225

{

1224

{

1226

return sctp_trans_state_to_prio_map[trans->state];

1225

return sctp_trans_state_to_prio_map[trans->state];

1227

}

1226

}

1228

1227

1229

static struct sctp_transport *sctp_trans_elect_tie(struct sctp_transport *trans1,

1228

static struct sctp_transport *sctp_trans_elect_tie(struct sctp_transport *trans1,

1230

struct sctp_transport *trans2)

1229

struct sctp_transport *trans2)

1231

{

1230

{

1232

if (trans1->error_count > trans2->error_count) {

1231

if (trans1->error_count > trans2->error_count) {

1233

return trans2;

1232

return trans2;

1234

} else if (trans1->error_count == trans2->error_count &&

1233

} else if (trans1->error_count == trans2->error_count &&

1235

ktime_after(trans2->last_time_heard,

1234

ktime_after(trans2->last_time_heard,

1236

trans1->last_time_heard)) {

1235

trans1->last_time_heard)) {

1237

return trans2;

1236

return trans2;

1238

} else {

1237

} else {

1239

return trans1;

1238

return trans1;

1240

}

1239

}

1241

}

1240

}

1242

1241

1243

static struct sctp_transport *sctp_trans_elect_best(struct sctp_transport *curr,

1242

static struct sctp_transport *sctp_trans_elect_best(struct sctp_transport *curr,

1244

struct sctp_transport *best)

1243

struct sctp_transport *best)

1245

{

1244

{

1246

u8 score_curr, score_best;

1245

u8 score_curr, score_best;

1247

1246

1248

if (best == NULL || curr == best)

1247

if (best == NULL || curr == best)

1249

return curr;

1248

return curr;

1250

1249

1251

score_curr = sctp_trans_score(curr);

1250

score_curr = sctp_trans_score(curr);

1252

score_best = sctp_trans_score(best);

1251

score_best = sctp_trans_score(best);

1253

1252

1254

/* First, try a score-based selection if both transport states

1253

/* First, try a score-based selection if both transport states

1255

* differ. If we're in a tie, lets try to make a more clever

1254

* differ. If we're in a tie, lets try to make a more clever

1256

* decision here based on error counts and last time heard.

1255

* decision here based on error counts and last time heard.

1257

*/

1256

*/

1258

if (score_curr > score_best)

1257

if (score_curr > score_best)

1259

return curr;

1258

return curr;

1260

else if (score_curr == score_best)

1259

else if (score_curr == score_best)

1261

return sctp_trans_elect_tie(curr, best);

1260

return sctp_trans_elect_tie(curr, best);

1262

else

1261

else

1263

return best;

1262

return best;

1264

}

1263

}

1265

1264

1266

void sctp_assoc_update_retran_path(struct sctp_association *asoc)

1265

void sctp_assoc_update_retran_path(struct sctp_association *asoc)

1267

{

1266

{

1268

struct sctp_transport *trans = asoc->peer.retran_path;

1267

struct sctp_transport *trans = asoc->peer.retran_path;

1269

struct sctp_transport *trans_next = NULL;

1268

struct sctp_transport *trans_next = NULL;

1270

1269

1271

/* We're done as we only have the one and only path. */

1270

/* We're done as we only have the one and only path. */

1272

if (asoc->peer.transport_count == 1)

1271

if (asoc->peer.transport_count == 1)

1273

return;

1272

return;

1274

/* If active_path and retran_path are the same and active,

1273

/* If active_path and retran_path are the same and active,

1275

* then this is the only active path. Use it.

1274

* then this is the only active path. Use it.

1276

*/

1275

*/

1277

if (asoc->peer.active_path == asoc->peer.retran_path &&

1276

if (asoc->peer.active_path == asoc->peer.retran_path &&

1278

asoc->peer.active_path->state == SCTP_ACTIVE)

1277

asoc->peer.active_path->state == SCTP_ACTIVE)

1279

return;

1278

return;

1280

1279

1281

/* Iterate from retran_path's successor back to retran_path. */

1280

/* Iterate from retran_path's successor back to retran_path. */

1282

for (trans = list_next_entry(trans, transports); 1;

1281

for (trans = list_next_entry(trans, transports); 1;

1283

trans = list_next_entry(trans, transports)) {

1282

trans = list_next_entry(trans, transports)) {

1284

/* Manually skip the head element. */

1283

/* Manually skip the head element. */

1285

if (&trans->transports == &asoc->peer.transport_addr_list)

1284

if (&trans->transports == &asoc->peer.transport_addr_list)

1286

continue;

1285

continue;

1287

if (trans->state == SCTP_UNCONFIRMED)

1286

if (trans->state == SCTP_UNCONFIRMED)

1288

continue;

1287

continue;

1289

trans_next = sctp_trans_elect_best(trans, trans_next);

1288

trans_next = sctp_trans_elect_best(trans, trans_next);

1290

/* Active is good enough for immediate return. */

1289

/* Active is good enough for immediate return. */

1291

if (trans_next->state == SCTP_ACTIVE)

1290

if (trans_next->state == SCTP_ACTIVE)

1292

break;

1291

break;

1293

/* We've reached the end, time to update path. */

1292

/* We've reached the end, time to update path. */

1294

if (trans == asoc->peer.retran_path)

1293

if (trans == asoc->peer.retran_path)

1295

break;

1294

break;

1296

}

1295

}

1297

1296

1298

asoc->peer.retran_path = trans_next;

1297

asoc->peer.retran_path = trans_next;

1299

1298

1300

pr_debug("%s: association:%p updated new path to addr:%pISpc\n",

1299

pr_debug("%s: association:%p updated new path to addr:%pISpc\n",

1301

__func__, asoc, &asoc->peer.retran_path->ipaddr.sa);

1300

__func__, asoc, &asoc->peer.retran_path->ipaddr.sa);

1302

}

1301

}

1303

1302

1304

static void sctp_select_active_and_retran_path(struct sctp_association *asoc)

1303

static void sctp_select_active_and_retran_path(struct sctp_association *asoc)

1305

{

1304

{

1306

struct sctp_transport *trans, *trans_pri = NULL, *trans_sec = NULL;

1305

struct sctp_transport *trans, *trans_pri = NULL, *trans_sec = NULL;

1307

struct sctp_transport *trans_pf = NULL;

1306

struct sctp_transport *trans_pf = NULL;

1308

1307

1309

/* Look for the two most recently used active transports. */

1308

/* Look for the two most recently used active transports. */

1310

list_for_each_entry(trans, &asoc->peer.transport_addr_list,

1309

list_for_each_entry(trans, &asoc->peer.transport_addr_list,

1311

transports) {

1310

transports) {

1312

/* Skip uninteresting transports. */

1311

/* Skip uninteresting transports. */

1313

if (trans->state == SCTP_INACTIVE ||

1312

if (trans->state == SCTP_INACTIVE ||

1314

trans->state == SCTP_UNCONFIRMED)

1313

trans->state == SCTP_UNCONFIRMED)

1315

continue;

1314

continue;

1316

/* Keep track of the best PF transport from our

1315

/* Keep track of the best PF transport from our

1317

* list in case we don't find an active one.

1316

* list in case we don't find an active one.

1318

*/

1317

*/

1319

if (trans->state == SCTP_PF) {

1318

if (trans->state == SCTP_PF) {

1320

trans_pf = sctp_trans_elect_best(trans, trans_pf);

1319

trans_pf = sctp_trans_elect_best(trans, trans_pf);

1321

continue;

1320

continue;

1322

}

1321

}

1323

/* For active transports, pick the most recent ones. */

1322

/* For active transports, pick the most recent ones. */

1324

if (trans_pri == NULL ||

1323

if (trans_pri == NULL ||

1325

ktime_after(trans->last_time_heard,

1324

ktime_after(trans->last_time_heard,

1326

trans_pri->last_time_heard)) {

1325

trans_pri->last_time_heard)) {

1327

trans_sec = trans_pri;

1326

trans_sec = trans_pri;

1328

trans_pri = trans;

1327

trans_pri = trans;

1329

} else if (trans_sec == NULL ||

1328

} else if (trans_sec == NULL ||

1330

ktime_after(trans->last_time_heard,

1329

ktime_after(trans->last_time_heard,

1331

trans_sec->last_time_heard)) {

1330

trans_sec->last_time_heard)) {

1332

trans_sec = trans;

1331

trans_sec = trans;

1333

}

1332

}

1334

}

1333

}

1335

1334

1336

/* RFC 2960 6.4 Multi-Homed SCTP Endpoints

1335

/* RFC 2960 6.4 Multi-Homed SCTP Endpoints

1337

*

1336

*

1338

* By default, an endpoint should always transmit to the primary

1337

* By default, an endpoint should always transmit to the primary

1339

* path, unless the SCTP user explicitly specifies the

1338

* path, unless the SCTP user explicitly specifies the

1340

* destination transport address (and possibly source transport

1339

* destination transport address (and possibly source transport

1341

* address) to use. [If the primary is active but not most recent,

1340

* address) to use. [If the primary is active but not most recent,

1342

* bump the most recently used transport.]

1341

* bump the most recently used transport.]

1343

*/

1342

*/

1344

if ((asoc->peer.primary_path->state == SCTP_ACTIVE ||

1343

if ((asoc->peer.primary_path->state == SCTP_ACTIVE ||

1345

asoc->peer.primary_path->state == SCTP_UNKNOWN) &&

1344

asoc->peer.primary_path->state == SCTP_UNKNOWN) &&

1346

asoc->peer.primary_path != trans_pri) {

1345

asoc->peer.primary_path != trans_pri) {

1347

trans_sec = trans_pri;

1346

trans_sec = trans_pri;

1348

trans_pri = asoc->peer.primary_path;

1347

trans_pri = asoc->peer.primary_path;

1349

}

1348

}

1350

1349

1351

/* We did not find anything useful for a possible retransmission

1350

/* We did not find anything useful for a possible retransmission

1352

* path; either primary path that we found is the the same as

1351

* path; either primary path that we found is the the same as

1353

* the current one, or we didn't generally find an active one.

1352

* the current one, or we didn't generally find an active one.

1354

*/

1353

*/

1355

if (trans_sec == NULL)

1354

if (trans_sec == NULL)

1356

trans_sec = trans_pri;

1355

trans_sec = trans_pri;

1357

1356

1358

/* If we failed to find a usable transport, just camp on the

1357

/* If we failed to find a usable transport, just camp on the

1359

* active or pick a PF iff it's the better choice.

1358

* active or pick a PF iff it's the better choice.

1360

*/

1359

*/

1361

if (trans_pri == NULL) {

1360

if (trans_pri == NULL) {

1362

trans_pri = sctp_trans_elect_best(asoc->peer.active_path, trans_pf);

1361

trans_pri = sctp_trans_elect_best(asoc->peer.active_path, trans_pf);

1363

trans_sec = trans_pri;

1362

trans_sec = trans_pri;

1364

}

1363

}

1365

1364

1366

/* Set the active and retran transports. */

1365

/* Set the active and retran transports. */

1367

asoc->peer.active_path = trans_pri;

1366

asoc->peer.active_path = trans_pri;

1368

asoc->peer.retran_path = trans_sec;

1367

asoc->peer.retran_path = trans_sec;

1369

}

1368

}

1370

1369

1371

struct sctp_transport *

1370

struct sctp_transport *

1372

sctp_assoc_choose_alter_transport(struct sctp_association *asoc,

1371

sctp_assoc_choose_alter_transport(struct sctp_association *asoc,

1373

struct sctp_transport *last_sent_to)

1372

struct sctp_transport *last_sent_to)

1374

{

1373

{

1375

/* If this is the first time packet is sent, use the active path,

1374

/* If this is the first time packet is sent, use the active path,

1376

* else use the retran path. If the last packet was sent over the

1375

* else use the retran path. If the last packet was sent over the

1377

* retran path, update the retran path and use it.

1376

* retran path, update the retran path and use it.

1378

*/

1377

*/

1379

if (last_sent_to == NULL) {

1378

if (last_sent_to == NULL) {

1380

return asoc->peer.active_path;

1379

return asoc->peer.active_path;

1381

} else {

1380

} else {

1382

if (last_sent_to == asoc->peer.retran_path)

1381

if (last_sent_to == asoc->peer.retran_path)

1383

sctp_assoc_update_retran_path(asoc);

1382

sctp_assoc_update_retran_path(asoc);

1384

1383

1385

return asoc->peer.retran_path;

1384

return asoc->peer.retran_path;

1386

}

1385

}

1387

}

1386

}

1388

1387

1389

/* Update the association's pmtu and frag_point by going through all the

1388

/* Update the association's pmtu and frag_point by going through all the

1390

* transports. This routine is called when a transport's PMTU has changed.

1389

* transports. This routine is called when a transport's PMTU has changed.

1391

*/

1390

*/

1392

void sctp_assoc_sync_pmtu(struct sock *sk, struct sctp_association *asoc)

1391

void sctp_assoc_sync_pmtu(struct sock *sk, struct sctp_association *asoc)

1393

{

1392

{

1394

struct sctp_transport *t;

1393

struct sctp_transport *t;

1395

__u32 pmtu = 0;

1394

__u32 pmtu = 0;

1396

1395

1397

if (!asoc)

1396

if (!asoc)

1398

return;

1397

return;

1399

1398

1400

/* Get the lowest pmtu of all the transports. */

1399

/* Get the lowest pmtu of all the transports. */

1401

list_for_each_entry(t, &asoc->peer.transport_addr_list,

1400

list_for_each_entry(t, &asoc->peer.transport_addr_list,

1402

transports) {

1401

transports) {

1403

if (t->pmtu_pending && t->dst) {

1402

if (t->pmtu_pending && t->dst) {

1404

sctp_transport_update_pmtu(sk, t, dst_mtu(t->dst));

1403

sctp_transport_update_pmtu(sk, t, dst_mtu(t->dst));

1405

t->pmtu_pending = 0;

1404

t->pmtu_pending = 0;

1406

}

1405

}

1407

if (!pmtu || (t->pathmtu < pmtu))

1406

if (!pmtu || (t->pathmtu < pmtu))

1408

pmtu = t->pathmtu;

1407

pmtu = t->pathmtu;

1409

}

1408

}

1410

1409

1411

if (pmtu) {

1410

if (pmtu) {

1412

asoc->pathmtu = pmtu;

1411

asoc->pathmtu = pmtu;

1413

asoc->frag_point = sctp_frag_point(asoc, pmtu);

1412

asoc->frag_point = sctp_frag_point(asoc, pmtu);

1414

}

1413

}

1415

1414

1416

pr_debug("%s: asoc:%p, pmtu:%d, frag_point:%d\n", __func__, asoc,

1415

pr_debug("%s: asoc:%p, pmtu:%d, frag_point:%d\n", __func__, asoc,

1417

asoc->pathmtu, asoc->frag_point);

1416

asoc->pathmtu, asoc->frag_point);

1418

}

1417

}

1419

1418

1420

/* Should we send a SACK to update our peer? */

1419

/* Should we send a SACK to update our peer? */

1421

static inline bool sctp_peer_needs_update(struct sctp_association *asoc)

1420

static inline bool sctp_peer_needs_update(struct sctp_association *asoc)

1422

{

1421

{

1423

struct net *net = sock_net(asoc->base.sk);

1422

struct net *net = sock_net(asoc->base.sk);

1424

switch (asoc->state) {

1423

switch (asoc->state) {

1425

case SCTP_STATE_ESTABLISHED:

1424

case SCTP_STATE_ESTABLISHED:

1426

case SCTP_STATE_SHUTDOWN_PENDING:

1425

case SCTP_STATE_SHUTDOWN_PENDING:

1427

case SCTP_STATE_SHUTDOWN_RECEIVED:

1426

case SCTP_STATE_SHUTDOWN_RECEIVED:

1428

case SCTP_STATE_SHUTDOWN_SENT:

1427

case SCTP_STATE_SHUTDOWN_SENT:

1429

if ((asoc->rwnd > asoc->a_rwnd) &&

1428

if ((asoc->rwnd > asoc->a_rwnd) &&

1430

((asoc->rwnd - asoc->a_rwnd) >= max_t(__u32,

1429

((asoc->rwnd - asoc->a_rwnd) >= max_t(__u32,

1431

(asoc->base.sk->sk_rcvbuf >> net->sctp.rwnd_upd_shift),

1430

(asoc->base.sk->sk_rcvbuf >> net->sctp.rwnd_upd_shift),

1432

asoc->pathmtu)))

1431

asoc->pathmtu)))

1433

return true;

1432

return true;

1434

break;

1433

break;

1435

default:

1434

default:

1436

break;

1435

break;

1437

}

1436

}

1438

return false;

1437

return false;

1439

}

1438

}

1440

1439

1441

/* Increase asoc's rwnd by len and send any window update SACK if needed. */

1440

/* Increase asoc's rwnd by len and send any window update SACK if needed. */

1442

void sctp_assoc_rwnd_increase(struct sctp_association *asoc, unsigned int len)

1441

void sctp_assoc_rwnd_increase(struct sctp_association *asoc, unsigned int len)

1443

{

1442

{

1444

struct sctp_chunk *sack;

1443

struct sctp_chunk *sack;

1445

struct timer_list *timer;

1444

struct timer_list *timer;

1446

1445

1447

if (asoc->rwnd_over) {

1446

if (asoc->rwnd_over) {

1448

if (asoc->rwnd_over >= len) {

1447

if (asoc->rwnd_over >= len) {

1449

asoc->rwnd_over -= len;

1448

asoc->rwnd_over -= len;

1450

} else {

1449

} else {

1451

asoc->rwnd += (len - asoc->rwnd_over);

1450

asoc->rwnd += (len - asoc->rwnd_over);

1452

asoc->rwnd_over = 0;

1451

asoc->rwnd_over = 0;

1453

}

1452

}

1454

} else {

1453

} else {

1455

asoc->rwnd += len;

1454

asoc->rwnd += len;

1456

}

1455

}

1457

1456

1458

/* If we had window pressure, start recovering it

1457

/* If we had window pressure, start recovering it

1459

* once our rwnd had reached the accumulated pressure

1458

* once our rwnd had reached the accumulated pressure

1460

* threshold. The idea is to recover slowly, but up

1459

* threshold. The idea is to recover slowly, but up

1461

* to the initial advertised window.

1460

* to the initial advertised window.

1462

*/

1461

*/

1463

if (asoc->rwnd_press && asoc->rwnd >= asoc->rwnd_press) {

1462

if (asoc->rwnd_press && asoc->rwnd >= asoc->rwnd_press) {

1464

int change = min(asoc->pathmtu, asoc->rwnd_press);

1463

int change = min(asoc->pathmtu, asoc->rwnd_press);

1465

asoc->rwnd += change;

1464

asoc->rwnd += change;

1466

asoc->rwnd_press -= change;

1465

asoc->rwnd_press -= change;

1467

}

1466

}

1468

1467

1469

pr_debug("%s: asoc:%p rwnd increased by %d to (%u, %u) - %u\n",

1468

pr_debug("%s: asoc:%p rwnd increased by %d to (%u, %u) - %u\n",

1470

__func__, asoc, len, asoc->rwnd, asoc->rwnd_over,

1469

__func__, asoc, len, asoc->rwnd, asoc->rwnd_over,

1471

asoc->a_rwnd);

1470

asoc->a_rwnd);

1472

1471

1473

/* Send a window update SACK if the rwnd has increased by at least the

1472

/* Send a window update SACK if the rwnd has increased by at least the

1474

* minimum of the association's PMTU and half of the receive buffer.

1473

* minimum of the association's PMTU and half of the receive buffer.

1475

* The algorithm used is similar to the one described in

1474

* The algorithm used is similar to the one described in

1476

* Section 4.2.3.3 of RFC 1122.

1475

* Section 4.2.3.3 of RFC 1122.

1477

*/

1476

*/

1478

if (sctp_peer_needs_update(asoc)) {

1477

if (sctp_peer_needs_update(asoc)) {

1479

asoc->a_rwnd = asoc->rwnd;

1478

asoc->a_rwnd = asoc->rwnd;

1480

1479

1481

pr_debug("%s: sending window update SACK- asoc:%p rwnd:%u "

1480

pr_debug("%s: sending window update SACK- asoc:%p rwnd:%u "

1482

"a_rwnd:%u\n", __func__, asoc, asoc->rwnd,

1481

"a_rwnd:%u\n", __func__, asoc, asoc->rwnd,

1483

asoc->a_rwnd);

1482

asoc->a_rwnd);

1484

1483

1485

sack = sctp_make_sack(asoc);

1484

sack = sctp_make_sack(asoc);

1486

if (!sack)

1485

if (!sack)

1487

return;

1486

return;

1488

1487

1489

asoc->peer.sack_needed = 0;

1488

asoc->peer.sack_needed = 0;

1490

1489

1491

sctp_outq_tail(&asoc->outqueue, sack);

1490

sctp_outq_tail(&asoc->outqueue, sack);

1492

1491

1493

/* Stop the SACK timer. */

1492

/* Stop the SACK timer. */

1494

timer = &asoc->timers[SCTP_EVENT_TIMEOUT_SACK];

1493

timer = &asoc->timers[SCTP_EVENT_TIMEOUT_SACK];

1495

if (del_timer(timer))

1494

if (del_timer(timer))

1496

sctp_association_put(asoc);

1495

sctp_association_put(asoc);

1497

}

1496

}

1498

}

1497

}

1499

1498

1500

/* Decrease asoc's rwnd by len. */

1499

/* Decrease asoc's rwnd by len. */

1501

void sctp_assoc_rwnd_decrease(struct sctp_association *asoc, unsigned int len)

1500

void sctp_assoc_rwnd_decrease(struct sctp_association *asoc, unsigned int len)

1502

{

1501

{

1503

int rx_count;

1502

int rx_count;

1504

int over = 0;

1503

int over = 0;

1505

1504

1506

if (unlikely(!asoc->rwnd || asoc->rwnd_over))

1505

if (unlikely(!asoc->rwnd || asoc->rwnd_over))

1507

pr_debug("%s: association:%p has asoc->rwnd:%u, "

1506

pr_debug("%s: association:%p has asoc->rwnd:%u, "

1508

"asoc->rwnd_over:%u!\n", __func__, asoc,

1507

"asoc->rwnd_over:%u!\n", __func__, asoc,

1509

asoc->rwnd, asoc->rwnd_over);

1508

asoc->rwnd, asoc->rwnd_over);

1510

1509

1511

if (asoc->ep->rcvbuf_policy)

1510

if (asoc->ep->rcvbuf_policy)

1512

rx_count = atomic_read(&asoc->rmem_alloc);

1511

rx_count = atomic_read(&asoc->rmem_alloc);

1513

else

1512

else

1514

rx_count = atomic_read(&asoc->base.sk->sk_rmem_alloc);

1513

rx_count = atomic_read(&asoc->base.sk->sk_rmem_alloc);

1515

1514

1516

/* If we've reached or overflowed our receive buffer, announce

1515

/* If we've reached or overflowed our receive buffer, announce

1517

* a 0 rwnd if rwnd would still be positive. Store the

1516

* a 0 rwnd if rwnd would still be positive. Store the

1518

* the potential pressure overflow so that the window can be restored

1517

* the potential pressure overflow so that the window can be restored

1519

* back to original value.

1518

* back to original value.

1520

*/

1519

*/

1521

if (rx_count >= asoc->base.sk->sk_rcvbuf)

1520

if (rx_count >= asoc->base.sk->sk_rcvbuf)

1522

over = 1;

1521

over = 1;

1523

1522

1524

if (asoc->rwnd >= len) {

1523

if (asoc->rwnd >= len) {

1525

asoc->rwnd -= len;

1524

asoc->rwnd -= len;

1526

if (over) {

1525

if (over) {

1527

asoc->rwnd_press += asoc->rwnd;

1526

asoc->rwnd_press += asoc->rwnd;

1528

asoc->rwnd = 0;

1527

asoc->rwnd = 0;

1529

}

1528

}

1530

} else {

1529

} else {

1531

asoc->rwnd_over = len - asoc->rwnd;

1530

asoc->rwnd_over = len - asoc->rwnd;

1532

asoc->rwnd = 0;

1531

asoc->rwnd = 0;

1533

}

1532

}

1534

1533

1535

pr_debug("%s: asoc:%p rwnd decreased by %d to (%u, %u, %u)\n",

1534

pr_debug("%s: asoc:%p rwnd decreased by %d to (%u, %u, %u)\n",

1536

__func__, asoc, len, asoc->rwnd, asoc->rwnd_over,

1535

__func__, asoc, len, asoc->rwnd, asoc->rwnd_over,

1537

asoc->rwnd_press);

1536

asoc->rwnd_press);

1538

}

1537

}

1539

1538

1540

/* Build the bind address list for the association based on info from the

1539

/* Build the bind address list for the association based on info from the

1541

* local endpoint and the remote peer.

1540

* local endpoint and the remote peer.

1542

*/

1541

*/

1543

int sctp_assoc_set_bind_addr_from_ep(struct sctp_association *asoc,

1542

int sctp_assoc_set_bind_addr_from_ep(struct sctp_association *asoc,

1544

sctp_scope_t scope, gfp_t gfp)

1543

sctp_scope_t scope, gfp_t gfp)

1545

{

1544

{

1546

int flags;

1545

int flags;

1547

1546

1548

/* Use scoping rules to determine the subset of addresses from

1547

/* Use scoping rules to determine the subset of addresses from

1549

* the endpoint.

1548

* the endpoint.

1550

*/

1549

*/

1551

flags = (PF_INET6 == asoc->base.sk->sk_family) ? SCTP_ADDR6_ALLOWED : 0;

1550

flags = (PF_INET6 == asoc->base.sk->sk_family) ? SCTP_ADDR6_ALLOWED : 0;

1552

if (asoc->peer.ipv4_address)

1551

if (asoc->peer.ipv4_address)

1553

flags |= SCTP_ADDR4_PEERSUPP;

1552

flags |= SCTP_ADDR4_PEERSUPP;

1554

if (asoc->peer.ipv6_address)

1553

if (asoc->peer.ipv6_address)

1555

flags |= SCTP_ADDR6_PEERSUPP;

1554

flags |= SCTP_ADDR6_PEERSUPP;

1556

1555

1557

return sctp_bind_addr_copy(sock_net(asoc->base.sk),

1556

return sctp_bind_addr_copy(sock_net(asoc->base.sk),

1558

&asoc->base.bind_addr,

1557

&asoc->base.bind_addr,

1559

&asoc->ep->base.bind_addr,

1558

&asoc->ep->base.bind_addr,

1560

scope, gfp, flags);

1559

scope, gfp, flags);

1561

}

1560

}

1562

1561

1563

/* Build the association's bind address list from the cookie. */

1562

/* Build the association's bind address list from the cookie. */

1564

int sctp_assoc_set_bind_addr_from_cookie(struct sctp_association *asoc,

1563

int sctp_assoc_set_bind_addr_from_cookie(struct sctp_association *asoc,

1565

struct sctp_cookie *cookie,

1564

struct sctp_cookie *cookie,

1566

gfp_t gfp)

1565

gfp_t gfp)

1567

{

1566

{

1568

int var_size2 = ntohs(cookie->peer_init->chunk_hdr.length);

1567

int var_size2 = ntohs(cookie->peer_init->chunk_hdr.length);

1569

int var_size3 = cookie->raw_addr_list_len;

1568

int var_size3 = cookie->raw_addr_list_len;

1570

__u8 *raw = (__u8 *)cookie->peer_init + var_size2;

1569

__u8 *raw = (__u8 *)cookie->peer_init + var_size2;

1571

1570

1572

return sctp_raw_to_bind_addrs(&asoc->base.bind_addr, raw, var_size3,

1571

return sctp_raw_to_bind_addrs(&asoc->base.bind_addr, raw, var_size3,

1573

asoc->ep->base.bind_addr.port, gfp);

1572

asoc->ep->base.bind_addr.port, gfp);

1574

}

1573

}

1575

1574

1576

/* Lookup laddr in the bind address list of an association. */

1575

/* Lookup laddr in the bind address list of an association. */

1577

int sctp_assoc_lookup_laddr(struct sctp_association *asoc,

1576

int sctp_assoc_lookup_laddr(struct sctp_association *asoc,

1578

const union sctp_addr *laddr)

1577

const union sctp_addr *laddr)

1579

{

1578

{

1580

int found = 0;

1579

int found = 0;

1581

1580

1582

if ((asoc->base.bind_addr.port == ntohs(laddr->v4.sin_port)) &&

1581

if ((asoc->base.bind_addr.port == ntohs(laddr->v4.sin_port)) &&

1583

sctp_bind_addr_match(&asoc->base.bind_addr, laddr,

1582

sctp_bind_addr_match(&asoc->base.bind_addr, laddr,

1584

sctp_sk(asoc->base.sk)))

1583

sctp_sk(asoc->base.sk)))

1585

found = 1;

1584

found = 1;

1586

1585

1587

return found;

1586

return found;

1588

}

1587

}

1589

1588

1590

/* Set an association id for a given association */

1589

/* Set an association id for a given association */

1591

int sctp_assoc_set_id(struct sctp_association *asoc, gfp_t gfp)

1590

int sctp_assoc_set_id(struct sctp_association *asoc, gfp_t gfp)

1592

{

1591

{

1593

bool preload = !!(gfp & __GFP_WAIT);

1592

bool preload = !!(gfp & __GFP_WAIT);

1594

int ret;

1593

int ret;

1595

1594

1596

/* If the id is already assigned, keep it. */

1595

/* If the id is already assigned, keep it. */

1597

if (asoc->assoc_id)

1596

if (asoc->assoc_id)

1598

return 0;

1597

return 0;

1599

1598

1600

if (preload)

1599

if (preload)

1601

idr_preload(gfp);

1600

idr_preload(gfp);

1602

spin_lock_bh(&sctp_assocs_id_lock);

1601

spin_lock_bh(&sctp_assocs_id_lock);

1603

/* 0 is not a valid assoc_id, must be >= 1 */

1602

/* 0 is not a valid assoc_id, must be >= 1 */

1604

ret = idr_alloc_cyclic(&sctp_assocs_id, asoc, 1, 0, GFP_NOWAIT);

1603

ret = idr_alloc_cyclic(&sctp_assocs_id, asoc, 1, 0, GFP_NOWAIT);

1605

spin_unlock_bh(&sctp_assocs_id_lock);

1604

spin_unlock_bh(&sctp_assocs_id_lock);

1606

if (preload)

1605

if (preload)

1607

idr_preload_end();

1606

idr_preload_end();

1608

if (ret < 0)

1607

if (ret < 0)

1609

return ret;

1608

return ret;

1610

1609

1611

asoc->assoc_id = (sctp_assoc_t)ret;

1610

asoc->assoc_id = (sctp_assoc_t)ret;

1612

return 0;

1611

return 0;

1613

}

1612

}

1614

1613

1615

/* Free the ASCONF queue */

1614

/* Free the ASCONF queue */

1616

static void sctp_assoc_free_asconf_queue(struct sctp_association *asoc)

1615

static void sctp_assoc_free_asconf_queue(struct sctp_association *asoc)

1617

{

1616

{

1618

struct sctp_chunk *asconf;

1617

struct sctp_chunk *asconf;

1619

struct sctp_chunk *tmp;

1618

struct sctp_chunk *tmp;

1620

1619

1621

list_for_each_entry_safe(asconf, tmp, &asoc->addip_chunk_list, list) {

1620

list_for_each_entry_safe(asconf, tmp, &asoc->addip_chunk_list, list) {

1622

list_del_init(&asconf->list);

1621

list_del_init(&asconf->list);

1623

sctp_chunk_free(asconf);

1622

sctp_chunk_free(asconf);

1624

}

1623

}

1625

}

1624

}

1626

1625

1627

/* Free asconf_ack cache */

1626

/* Free asconf_ack cache */

1628

static void sctp_assoc_free_asconf_acks(struct sctp_association *asoc)

1627

static void sctp_assoc_free_asconf_acks(struct sctp_association *asoc)

1629

{

1628

{

1630

struct sctp_chunk *ack;

1629

struct sctp_chunk *ack;

1631

struct sctp_chunk *tmp;

1630

struct sctp_chunk *tmp;

1632

1631

1633

list_for_each_entry_safe(ack, tmp, &asoc->asconf_ack_list,

1632

list_for_each_entry_safe(ack, tmp, &asoc->asconf_ack_list,

1634

transmitted_list) {

1633

transmitted_list) {

1635

list_del_init(&ack->transmitted_list);

1634

list_del_init(&ack->transmitted_list);

1636

sctp_chunk_free(ack);

1635

sctp_chunk_free(ack);

1637

}

1636

}

1638

}

1637

}

1639

1638

1640

/* Clean up the ASCONF_ACK queue */

1639

/* Clean up the ASCONF_ACK queue */

1641

void sctp_assoc_clean_asconf_ack_cache(const struct sctp_association *asoc)

1640

void sctp_assoc_clean_asconf_ack_cache(const struct sctp_association *asoc)

1642

{

1641

{

1643

struct sctp_chunk *ack;

1642

struct sctp_chunk *ack;

1644

struct sctp_chunk *tmp;

1643

struct sctp_chunk *tmp;

1645

1644

1646

/* We can remove all the entries from the queue up to

1645

/* We can remove all the entries from the queue up to

1647

* the "Peer-Sequence-Number".

1646

* the "Peer-Sequence-Number".

1648

*/

1647

*/

1649

list_for_each_entry_safe(ack, tmp, &asoc->asconf_ack_list,

1648

list_for_each_entry_safe(ack, tmp, &asoc->asconf_ack_list,

1650

transmitted_list) {

1649

transmitted_list) {

1651

if (ack->subh.addip_hdr->serial ==

1650

if (ack->subh.addip_hdr->serial ==

1652

htonl(asoc->peer.addip_serial))

1651

htonl(asoc->peer.addip_serial))

1653

break;

1652

break;

1654

1653

1655

list_del_init(&ack->transmitted_list);

1654

list_del_init(&ack->transmitted_list);

1656

sctp_chunk_free(ack);

1655

sctp_chunk_free(ack);

1657

}

1656

}

1658

}

1657

}

1659

1658

1660

/* Find the ASCONF_ACK whose serial number matches ASCONF */

1659

/* Find the ASCONF_ACK whose serial number matches ASCONF */

1661

struct sctp_chunk *sctp_assoc_lookup_asconf_ack(

1660

struct sctp_chunk *sctp_assoc_lookup_asconf_ack(

1662

const struct sctp_association *asoc,

1661

const struct sctp_association *asoc,

1663

__be32 serial)

1662

__be32 serial)

1664

{

1663

{

1665

struct sctp_chunk *ack;

1664

struct sctp_chunk *ack;

1666

1665

1667

/* Walk through the list of cached ASCONF-ACKs and find the

1666

/* Walk through the list of cached ASCONF-ACKs and find the

1668

* ack chunk whose serial number matches that of the request.

1667

* ack chunk whose serial number matches that of the request.

1669

*/

1668

*/

1670

list_for_each_entry(ack, &asoc->asconf_ack_list, transmitted_list) {

1669

list_for_each_entry(ack, &asoc->asconf_ack_list, transmitted_list) {

1671

if (sctp_chunk_pending(ack))

1670

if (sctp_chunk_pending(ack))

1672

continue;

1671

continue;

1673

if (ack->subh.addip_hdr->serial == serial) {

1672

if (ack->subh.addip_hdr->serial == serial) {

1674

sctp_chunk_hold(ack);

1673

sctp_chunk_hold(ack);

1675

return ack;

1674

return ack;

1676

}

1675

}

1677

}

1676

}

1678

1677

1679

return NULL;

1678

return NULL;

1680

}

1679

}

1681

1680

1682

void sctp_asconf_queue_teardown(struct sctp_association *asoc)

1681

void sctp_asconf_queue_teardown(struct sctp_association *asoc)

1683

{

1682

{

1684

/* Free any cached ASCONF_ACK chunk. */

1683

/* Free any cached ASCONF_ACK chunk. */

1685

sctp_assoc_free_asconf_acks(asoc);

1684

sctp_assoc_free_asconf_acks(asoc);

1686

1685

1687

/* Free the ASCONF queue. */

1686

/* Free the ASCONF queue. */

1688

sctp_assoc_free_asconf_queue(asoc);

1687

sctp_assoc_free_asconf_queue(asoc);

1689

1688

1690

/* Free any cached ASCONF chunk. */

1689

/* Free any cached ASCONF chunk. */

1691

if (asoc->addip_last_asconf)

1690

if (asoc->addip_last_asconf)

1692

sctp_chunk_free(asoc->addip_last_asconf);

1691

sctp_chunk_free(asoc->addip_last_asconf);

1693

}

1692

}

1694

1693

GITLAB

net: sctp: fix slab corruption from use after free on INIT collisions

 /* SCTP kernel implementation
  * (C) Copyright IBM Corp. 2001, 2004
  * Copyright (c) 1999-2000 Cisco, Inc.
  * Copyright (c) 1999-2001 Motorola, Inc.
  * Copyright (c) 2001 Intel Corp.
  * Copyright (c) 2001 La Monte H.P. Yarroll
  *
  * This file is part of the SCTP kernel implementation
  *
  * This module provides the abstraction for an SCTP association.
  *
  * This SCTP implementation is free software;
  * you can redistribute it and/or modify it under the terms of
  * the GNU General Public License as published by
  * the Free Software Foundation; either version 2, or (at your option)
  * any later version.
  *
  * This SCTP implementation is distributed in the hope that it
  * will be useful, but WITHOUT ANY WARRANTY; without even the implied
  *                 ************************
  * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  * See the GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with GNU CC; see the file COPYING.  If not, see
  * <http://www.gnu.org/licenses/>.
  *
  * Please send any bug reports or fixes you make to the
  * email address(es):
  *    lksctp developers <linux-sctp@vger.kernel.org>
  *
  * Written or modified by:
  *    La Monte H.P. Yarroll <piggy@acm.org>
  *    Karl Knutson          <karl@athena.chicago.il.us>
  *    Jon Grimm             <jgrimm@us.ibm.com>
  *    Xingang Guo           <xingang.guo@intel.com>
  *    Hui Huang             <hui.huang@nokia.com>
  *    Sridhar Samudrala	    <sri@us.ibm.com>
  *    Daisy Chang	    <daisyc@us.ibm.com>
  *    Ryan Layer	    <rmlayer@us.ibm.com>
  *    Kevin Gao             <kevin.gao@intel.com>
  */
 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 #include <linux/types.h>
 #include <linux/fcntl.h>
 #include <linux/poll.h>
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/in.h>
 #include <net/ipv6.h>
 #include <net/sctp/sctp.h>
 #include <net/sctp/sm.h>
 /* Forward declarations for internal functions. */
 static void sctp_select_active_and_retran_path(struct sctp_association *asoc);
 static void sctp_assoc_bh_rcv(struct work_struct *work);
 static void sctp_assoc_free_asconf_acks(struct sctp_association *asoc);
 static void sctp_assoc_free_asconf_queue(struct sctp_association *asoc);
 /* 1st Level Abstractions. */
 /* Initialize a new association from provided memory. */
 static struct sctp_association *sctp_association_init(struct sctp_association *asoc,
 					  const struct sctp_endpoint *ep,
 					  const struct sock *sk,
 					  sctp_scope_t scope,
 					  gfp_t gfp)
 {
 	struct net *net = sock_net(sk);
 	struct sctp_sock *sp;
 	int i;
 	sctp_paramhdr_t *p;
 	int err;
 	/* Retrieve the SCTP per socket area.  */
 	sp = sctp_sk((struct sock *)sk);
 	/* Discarding const is appropriate here.  */
 	asoc->ep = (struct sctp_endpoint *)ep;
 	asoc->base.sk = (struct sock *)sk;
 	sctp_endpoint_hold(asoc->ep);
 	sock_hold(asoc->base.sk);
 	/* Initialize the common base substructure.  */
 	asoc->base.type = SCTP_EP_TYPE_ASSOCIATION;
 	/* Initialize the object handling fields.  */
 	atomic_set(&asoc->base.refcnt, 1);
 	/* Initialize the bind addr area.  */
 	sctp_bind_addr_init(&asoc->base.bind_addr, ep->base.bind_addr.port);
 	asoc->state = SCTP_STATE_CLOSED;
 	asoc->cookie_life = ms_to_ktime(sp->assocparams.sasoc_cookie_life);
 	asoc->user_frag = sp->user_frag;
 	/* Set the association max_retrans and RTO values from the
 	 * socket values.
 	 */
 	asoc->max_retrans = sp->assocparams.sasoc_asocmaxrxt;
 	asoc->pf_retrans  = net->sctp.pf_retrans;
 	asoc->rto_initial = msecs_to_jiffies(sp->rtoinfo.srto_initial);
 	asoc->rto_max = msecs_to_jiffies(sp->rtoinfo.srto_max);
 	asoc->rto_min = msecs_to_jiffies(sp->rtoinfo.srto_min);
 	/* Initialize the association's heartbeat interval based on the
 	 * sock configured value.
 	 */
 	asoc->hbinterval = msecs_to_jiffies(sp->hbinterval);
 	/* Initialize path max retrans value. */
 	asoc->pathmaxrxt = sp->pathmaxrxt;
 	/* Initialize default path MTU. */
 	asoc->pathmtu = sp->pathmtu;
 	/* Set association default SACK delay */
 	asoc->sackdelay = msecs_to_jiffies(sp->sackdelay);
 	asoc->sackfreq = sp->sackfreq;
 	/* Set the association default flags controlling
 	 * Heartbeat, SACK delay, and Path MTU Discovery.
 	 */
 	asoc->param_flags = sp->param_flags;
 	/* Initialize the maximum number of new data packets that can be sent
 	 * in a burst.
 	 */
 	asoc->max_burst = sp->max_burst;
 	/* initialize association timers */
 	asoc->timeouts[SCTP_EVENT_TIMEOUT_T1_COOKIE] = asoc->rto_initial;
 	asoc->timeouts[SCTP_EVENT_TIMEOUT_T1_INIT] = asoc->rto_initial;
 	asoc->timeouts[SCTP_EVENT_TIMEOUT_T2_SHUTDOWN] = asoc->rto_initial;
 	/* sctpimpguide Section 2.12.2
 	 * If the 'T5-shutdown-guard' timer is used, it SHOULD be set to the
 	 * recommended value of 5 times 'RTO.Max'.
 	 */
 	asoc->timeouts[SCTP_EVENT_TIMEOUT_T5_SHUTDOWN_GUARD]
 		= 5 * asoc->rto_max;
 	asoc->timeouts[SCTP_EVENT_TIMEOUT_SACK] = asoc->sackdelay;
 	asoc->timeouts[SCTP_EVENT_TIMEOUT_AUTOCLOSE] = sp->autoclose * HZ;
 	/* Initializes the timers */
 	for (i = SCTP_EVENT_TIMEOUT_NONE; i < SCTP_NUM_TIMEOUT_TYPES; ++i)
 		setup_timer(&asoc->timers[i], sctp_timer_events[i],
 				(unsigned long)asoc);
 	/* Pull default initialization values from the sock options.
 	 * Note: This assumes that the values have already been
 	 * validated in the sock.
 	 */
 	asoc->c.sinit_max_instreams = sp->initmsg.sinit_max_instreams;
 	asoc->c.sinit_num_ostreams  = sp->initmsg.sinit_num_ostreams;
 	asoc->max_init_attempts	= sp->initmsg.sinit_max_attempts;
 	asoc->max_init_timeo =
 		 msecs_to_jiffies(sp->initmsg.sinit_max_init_timeo);
 	/* Set the local window size for receive.
 	 * This is also the rcvbuf space per association.
 	 * RFC 6 - A SCTP receiver MUST be able to receive a minimum of
 	 * 1500 bytes in one SCTP packet.
 	 */
 	if ((sk->sk_rcvbuf/2) < SCTP_DEFAULT_MINWINDOW)
 		asoc->rwnd = SCTP_DEFAULT_MINWINDOW;
 	else
 		asoc->rwnd = sk->sk_rcvbuf/2;
 	asoc->a_rwnd = asoc->rwnd;
 	/* Use my own max window until I learn something better.  */
 	asoc->peer.rwnd = SCTP_DEFAULT_MAXWINDOW;
 	/* Initialize the receive memory counter */
 	atomic_set(&asoc->rmem_alloc, 0);
 	init_waitqueue_head(&asoc->wait);
 	asoc->c.my_vtag = sctp_generate_tag(ep);
 	asoc->c.my_port = ep->base.bind_addr.port;
 	asoc->c.initial_tsn = sctp_generate_tsn(ep);
 	asoc->next_tsn = asoc->c.initial_tsn;
 	asoc->ctsn_ack_point = asoc->next_tsn - 1;
 	asoc->adv_peer_ack_point = asoc->ctsn_ack_point;
 	asoc->highest_sacked = asoc->ctsn_ack_point;
 	asoc->last_cwr_tsn = asoc->ctsn_ack_point;
 	/* ADDIP Section 4.1 Asconf Chunk Procedures
 	 *
 	 * When an endpoint has an ASCONF signaled change to be sent to the
 	 * remote endpoint it should do the following:
 	 * ...
 	 * A2) a serial number should be assigned to the chunk. The serial
 	 * number SHOULD be a monotonically increasing number. The serial
 	 * numbers SHOULD be initialized at the start of the
 	 * association to the same value as the initial TSN.
 	 */
 	asoc->addip_serial = asoc->c.initial_tsn;
 	INIT_LIST_HEAD(&asoc->addip_chunk_list);
 	INIT_LIST_HEAD(&asoc->asconf_ack_list);
 	/* Make an empty list of remote transport addresses.  */
 	INIT_LIST_HEAD(&asoc->peer.transport_addr_list);
 	/* RFC 2960 5.1 Normal Establishment of an Association
 	 *
 	 * After the reception of the first data chunk in an
 	 * association the endpoint must immediately respond with a
 	 * sack to acknowledge the data chunk.  Subsequent
 	 * acknowledgements should be done as described in Section
 	 * 6.2.
 	 *
 	 * [We implement this by telling a new association that it
 	 * already received one packet.]
 	 */
 	asoc->peer.sack_needed = 1;
 	asoc->peer.sack_generation = 1;
 	/* Assume that the peer will tell us if he recognizes ASCONF
 	 * as part of INIT exchange.
 	 * The sctp_addip_noauth option is there for backward compatibility
 	 * and will revert old behavior.
 	 */
 	if (net->sctp.addip_noauth)
 		asoc->peer.asconf_capable = 1;
 	/* Create an input queue.  */
 	sctp_inq_init(&asoc->base.inqueue);
 	sctp_inq_set_th_handler(&asoc->base.inqueue, sctp_assoc_bh_rcv);
 	/* Create an output queue.  */
 	sctp_outq_init(asoc, &asoc->outqueue);
 	if (!sctp_ulpq_init(&asoc->ulpq, asoc))
 		goto fail_init;
 	/* Assume that peer would support both address types unless we are
 	 * told otherwise.
 	 */
 	asoc->peer.ipv4_address = 1;
 	if (asoc->base.sk->sk_family == PF_INET6)
 		asoc->peer.ipv6_address = 1;
 	INIT_LIST_HEAD(&asoc->asocs);
 	asoc->default_stream = sp->default_stream;
 	asoc->default_ppid = sp->default_ppid;
 	asoc->default_flags = sp->default_flags;
 	asoc->default_context = sp->default_context;
 	asoc->default_timetolive = sp->default_timetolive;
 	asoc->default_rcv_context = sp->default_rcv_context;
 	/* AUTH related initializations */
 	INIT_LIST_HEAD(&asoc->endpoint_shared_keys);
 	err = sctp_auth_asoc_copy_shkeys(ep, asoc, gfp);
 	if (err)
 		goto fail_init;
 	asoc->active_key_id = ep->active_key_id;
 	/* Save the hmacs and chunks list into this association */
 	if (ep->auth_hmacs_list)
 		memcpy(asoc->c.auth_hmacs, ep->auth_hmacs_list,
 			ntohs(ep->auth_hmacs_list->param_hdr.length));
 	if (ep->auth_chunk_list)
 		memcpy(asoc->c.auth_chunks, ep->auth_chunk_list,
 			ntohs(ep->auth_chunk_list->param_hdr.length));
 	/* Get the AUTH random number for this association */
 	p = (sctp_paramhdr_t *)asoc->c.auth_random;
 	p->type = SCTP_PARAM_RANDOM;
 	p->length = htons(sizeof(sctp_paramhdr_t) + SCTP_AUTH_RANDOM_LENGTH);
 	get_random_bytes(p+1, SCTP_AUTH_RANDOM_LENGTH);
 	return asoc;
 fail_init:
 	sock_put(asoc->base.sk);
 	sctp_endpoint_put(asoc->ep);
 	return NULL;
 }
 /* Allocate and initialize a new association */
 struct sctp_association *sctp_association_new(const struct sctp_endpoint *ep,
 					 const struct sock *sk,
 					 sctp_scope_t scope,
 					 gfp_t gfp)
 {
 	struct sctp_association *asoc;
 	asoc = kzalloc(sizeof(*asoc), gfp);
 	if (!asoc)
 		goto fail;
 	if (!sctp_association_init(asoc, ep, sk, scope, gfp))
 		goto fail_init;
 	SCTP_DBG_OBJCNT_INC(assoc);
 	pr_debug("Created asoc %p\n", asoc);
 	return asoc;
 fail_init:
 	kfree(asoc);
 fail:
 	return NULL;
 }
 /* Free this association if possible.  There may still be users, so
  * the actual deallocation may be delayed.
  */
 void sctp_association_free(struct sctp_association *asoc)
 {
 	struct sock *sk = asoc->base.sk;
 	struct sctp_transport *transport;
 	struct list_head *pos, *temp;
 	int i;
 	/* Only real associations count against the endpoint, so
 	 * don't bother for if this is a temporary association.
 	 */
 	if (!list_empty(&asoc->asocs)) {
 		list_del(&asoc->asocs);
 		/* Decrement the backlog value for a TCP-style listening
 		 * socket.
 		 */
 		if (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING))
 			sk->sk_ack_backlog--;
 	}
 	/* Mark as dead, so other users can know this structure is
 	 * going away.
 	 */
 	asoc->base.dead = true;
 	/* Dispose of any data lying around in the outqueue. */
 	sctp_outq_free(&asoc->outqueue);
 	/* Dispose of any pending messages for the upper layer. */
 	sctp_ulpq_free(&asoc->ulpq);
 	/* Dispose of any pending chunks on the inqueue. */
 	sctp_inq_free(&asoc->base.inqueue);
 	sctp_tsnmap_free(&asoc->peer.tsn_map);
 	/* Free ssnmap storage. */
 	sctp_ssnmap_free(asoc->ssnmap);
 	/* Clean up the bound address list. */
 	sctp_bind_addr_free(&asoc->base.bind_addr);
 	/* Do we need to go through all of our timers and
 	 * delete them?   To be safe we will try to delete all, but we
 	 * should be able to go through and make a guess based
 	 * on our state.
 	 */
 	for (i = SCTP_EVENT_TIMEOUT_NONE; i < SCTP_NUM_TIMEOUT_TYPES; ++i) {
 		if (del_timer(&asoc->timers[i]))
 			sctp_association_put(asoc);
 	}
 	/* Free peer's cached cookie. */
 	kfree(asoc->peer.cookie);
 	kfree(asoc->peer.peer_random);
 	kfree(asoc->peer.peer_chunks);
 	kfree(asoc->peer.peer_hmacs);
 	/* Release the transport structures. */
 	list_for_each_safe(pos, temp, &asoc->peer.transport_addr_list) {
 		transport = list_entry(pos, struct sctp_transport, transports);
 		list_del_rcu(pos);
 		sctp_transport_free(transport);
 	}
 	asoc->peer.transport_count = 0;
 	sctp_asconf_queue_teardown(asoc);
 	/* Free pending address space being deleted */
 	if (asoc->asconf_addr_del_pending != NULL)
 		kfree(asoc->asconf_addr_del_pending);
 	/* AUTH - Free the endpoint shared keys */
 	sctp_auth_destroy_keys(&asoc->endpoint_shared_keys);
 	/* AUTH - Free the association shared key */
 	sctp_auth_key_put(asoc->asoc_shared_key);
 	sctp_association_put(asoc);
 }
 /* Cleanup and free up an association. */
 static void sctp_association_destroy(struct sctp_association *asoc)
 {
 	if (unlikely(!asoc->base.dead)) {
 		WARN(1, "Attempt to destroy undead association %p!\n", asoc);
 		return;
 	}
 	sctp_endpoint_put(asoc->ep);
 	sock_put(asoc->base.sk);
 	if (asoc->assoc_id != 0) {
 		spin_lock_bh(&sctp_assocs_id_lock);
 		idr_remove(&sctp_assocs_id, asoc->assoc_id);
 		spin_unlock_bh(&sctp_assocs_id_lock);
 	}
 	WARN_ON(atomic_read(&asoc->rmem_alloc));
 	kfree(asoc);
 	SCTP_DBG_OBJCNT_DEC(assoc);
 }
 /* Change the primary destination address for the peer. */
 void sctp_assoc_set_primary(struct sctp_association *asoc,
 			    struct sctp_transport *transport)
 {
 	int changeover = 0;
 	/* it's a changeover only if we already have a primary path
 	 * that we are changing
 	 */
 	if (asoc->peer.primary_path != NULL &&
 	    asoc->peer.primary_path != transport)
 		changeover = 1 ;
 	asoc->peer.primary_path = transport;
 	/* Set a default msg_name for events. */
 	memcpy(&asoc->peer.primary_addr, &transport->ipaddr,
 	       sizeof(union sctp_addr));
 	/* If the primary path is changing, assume that the
 	 * user wants to use this new path.
 	 */
 	if ((transport->state == SCTP_ACTIVE) ||
 	    (transport->state == SCTP_UNKNOWN))
 		asoc->peer.active_path = transport;
 	/*
 	 * SFR-CACC algorithm:
 	 * Upon the receipt of a request to change the primary
 	 * destination address, on the data structure for the new
 	 * primary destination, the sender MUST do the following:
 	 *
 	 * 1) If CHANGEOVER_ACTIVE is set, then there was a switch
 	 * to this destination address earlier. The sender MUST set
 	 * CYCLING_CHANGEOVER to indicate that this switch is a
 	 * double switch to the same destination address.
 	 *
 	 * Really, only bother is we have data queued or outstanding on
 	 * the association.
 	 */
 	if (!asoc->outqueue.outstanding_bytes && !asoc->outqueue.out_qlen)
 		return;
 	if (transport->cacc.changeover_active)
 		transport->cacc.cycling_changeover = changeover;
 	/* 2) The sender MUST set CHANGEOVER_ACTIVE to indicate that
 	 * a changeover has occurred.
 	 */
 	transport->cacc.changeover_active = changeover;
 	/* 3) The sender MUST store the next TSN to be sent in
 	 * next_tsn_at_change.
 	 */
 	transport->cacc.next_tsn_at_change = asoc->next_tsn;
 }
 /* Remove a transport from an association.  */
 void sctp_assoc_rm_peer(struct sctp_association *asoc,
 			struct sctp_transport *peer)
 {
 	struct list_head	*pos;
 	struct sctp_transport	*transport;
 	pr_debug("%s: association:%p addr:%pISpc\n",
 		 __func__, asoc, &peer->ipaddr.sa);
 	/* If we are to remove the current retran_path, update it
 	 * to the next peer before removing this peer from the list.
 	 */
 	if (asoc->peer.retran_path == peer)
 		sctp_assoc_update_retran_path(asoc);
 	/* Remove this peer from the list. */
 	list_del_rcu(&peer->transports);
 	/* Get the first transport of asoc. */
 	pos = asoc->peer.transport_addr_list.next;
 	transport = list_entry(pos, struct sctp_transport, transports);
 	/* Update any entries that match the peer to be deleted. */
 	if (asoc->peer.primary_path == peer)
 		sctp_assoc_set_primary(asoc, transport);
 	if (asoc->peer.active_path == peer)
 		asoc->peer.active_path = transport;
 	if (asoc->peer.retran_path == peer)
 		asoc->peer.retran_path = transport;
 	if (asoc->peer.last_data_from == peer)
 		asoc->peer.last_data_from = transport;
 	/* If we remove the transport an INIT was last sent to, set it to
 	 * NULL. Combined with the update of the retran path above, this
 	 * will cause the next INIT to be sent to the next available
 	 * transport, maintaining the cycle.
 	 */
 	if (asoc->init_last_sent_to == peer)
 		asoc->init_last_sent_to = NULL;
 	/* If we remove the transport an SHUTDOWN was last sent to, set it
 	 * to NULL. Combined with the update of the retran path above, this
 	 * will cause the next SHUTDOWN to be sent to the next available
 	 * transport, maintaining the cycle.
 	 */
 	if (asoc->shutdown_last_sent_to == peer)
 		asoc->shutdown_last_sent_to = NULL;
 	/* If we remove the transport an ASCONF was last sent to, set it to
 	 * NULL.
 	 */
 	if (asoc->addip_last_asconf &&
 	    asoc->addip_last_asconf->transport == peer)
 		asoc->addip_last_asconf->transport = NULL;
 	/* If we have something on the transmitted list, we have to
 	 * save it off.  The best place is the active path.
 	 */
 	if (!list_empty(&peer->transmitted)) {
 		struct sctp_transport *active = asoc->peer.active_path;
 		struct sctp_chunk *ch;
 		/* Reset the transport of each chunk on this list */
 		list_for_each_entry(ch, &peer->transmitted,
 					transmitted_list) {
 			ch->transport = NULL;
 			ch->rtt_in_progress = 0;
 		}
 		list_splice_tail_init(&peer->transmitted,
 					&active->transmitted);
 		/* Start a T3 timer here in case it wasn't running so
 		 * that these migrated packets have a chance to get
 		 * retransmitted.
 		 */
 		if (!timer_pending(&active->T3_rtx_timer))
 			if (!mod_timer(&active->T3_rtx_timer,
 					jiffies + active->rto))
 				sctp_transport_hold(active);
 	}
 	asoc->peer.transport_count--;
 	sctp_transport_free(peer);
 }
 /* Add a transport address to an association.  */
 struct sctp_transport *sctp_assoc_add_peer(struct sctp_association *asoc,
 					   const union sctp_addr *addr,
 					   const gfp_t gfp,
 					   const int peer_state)
 {
 	struct net *net = sock_net(asoc->base.sk);
 	struct sctp_transport *peer;
 	struct sctp_sock *sp;
 	unsigned short port;
 	sp = sctp_sk(asoc->base.sk);
 	/* AF_INET and AF_INET6 share common port field. */
 	port = ntohs(addr->v4.sin_port);
 	pr_debug("%s: association:%p addr:%pISpc state:%d\n", __func__,
 		 asoc, &addr->sa, peer_state);
 	/* Set the port if it has not been set yet.  */
 	if (0 == asoc->peer.port)
 		asoc->peer.port = port;
 	/* Check to see if this is a duplicate. */
 	peer = sctp_assoc_lookup_paddr(asoc, addr);
 	if (peer) {
 		/* An UNKNOWN state is only set on transports added by
 		 * user in sctp_connectx() call.  Such transports should be
 		 * considered CONFIRMED per RFC 4960, Section 5.4.
 		 */
 		if (peer->state == SCTP_UNKNOWN) {
 			peer->state = SCTP_ACTIVE;
 		}
 		return peer;
 	}
 	peer = sctp_transport_new(net, addr, gfp);
 	if (!peer)
 		return NULL;
 	sctp_transport_set_owner(peer, asoc);
 	/* Initialize the peer's heartbeat interval based on the
 	 * association configured value.
 	 */
 	peer->hbinterval = asoc->hbinterval;
 	/* Set the path max_retrans.  */
 	peer->pathmaxrxt = asoc->pathmaxrxt;
 	/* And the partial failure retrans threshold */
 	peer->pf_retrans = asoc->pf_retrans;
 	/* Initialize the peer's SACK delay timeout based on the
 	 * association configured value.
 	 */
 	peer->sackdelay = asoc->sackdelay;
 	peer->sackfreq = asoc->sackfreq;
 	/* Enable/disable heartbeat, SACK delay, and path MTU discovery
 	 * based on association setting.
 	 */
 	peer->param_flags = asoc->param_flags;
 	sctp_transport_route(peer, NULL, sp);
 	/* Initialize the pmtu of the transport. */
 	if (peer->param_flags & SPP_PMTUD_DISABLE) {
 		if (asoc->pathmtu)
 			peer->pathmtu = asoc->pathmtu;
 		else
 			peer->pathmtu = SCTP_DEFAULT_MAXSEGMENT;
 	}
 	/* If this is the first transport addr on this association,
 	 * initialize the association PMTU to the peer's PMTU.
 	 * If not and the current association PMTU is higher than the new
 	 * peer's PMTU, reset the association PMTU to the new peer's PMTU.
 	 */
 	if (asoc->pathmtu)
 		asoc->pathmtu = min_t(int, peer->pathmtu, asoc->pathmtu);
 	else
 		asoc->pathmtu = peer->pathmtu;
 	pr_debug("%s: association:%p PMTU set to %d\n", __func__, asoc,
 		 asoc->pathmtu);
 	peer->pmtu_pending = 0;
 	asoc->frag_point = sctp_frag_point(asoc, asoc->pathmtu);
 	/* The asoc->peer.port might not be meaningful yet, but
 	 * initialize the packet structure anyway.
 	 */
 	sctp_packet_init(&peer->packet, peer, asoc->base.bind_addr.port,
 			 asoc->peer.port);
 	/* 7.2.1 Slow-Start
 	 *
 	 * o The initial cwnd before DATA transmission or after a sufficiently
 	 *   long idle period MUST be set to
 	 *      min(4*MTU, max(2*MTU, 4380 bytes))
 	 *
 	 * o The initial value of ssthresh MAY be arbitrarily high
 	 *   (for example, implementations MAY use the size of the
 	 *   receiver advertised window).
 	 */
 	peer->cwnd = min(4*asoc->pathmtu, max_t(__u32, 2*asoc->pathmtu, 4380));
 	/* At this point, we may not have the receiver's advertised window,
 	 * so initialize ssthresh to the default value and it will be set
 	 * later when we process the INIT.
 	 */
 	peer->ssthresh = SCTP_DEFAULT_MAXWINDOW;
 	peer->partial_bytes_acked = 0;
 	peer->flight_size = 0;
 	peer->burst_limited = 0;
 	/* Set the transport's RTO.initial value */
 	peer->rto = asoc->rto_initial;
 	sctp_max_rto(asoc, peer);
 	/* Set the peer's active state. */
 	peer->state = peer_state;
 	/* Attach the remote transport to our asoc.  */
 	list_add_tail_rcu(&peer->transports, &asoc->peer.transport_addr_list);
 	asoc->peer.transport_count++;
 	/* If we do not yet have a primary path, set one.  */
 	if (!asoc->peer.primary_path) {
 		sctp_assoc_set_primary(asoc, peer);
 		asoc->peer.retran_path = peer;
 	}
 	if (asoc->peer.active_path == asoc->peer.retran_path &&
 	    peer->state != SCTP_UNCONFIRMED) {
 		asoc->peer.retran_path = peer;
 	}
 	return peer;
 }
 /* Delete a transport address from an association.  */
 void sctp_assoc_del_peer(struct sctp_association *asoc,
 			 const union sctp_addr *addr)
 {
 	struct list_head	*pos;
 	struct list_head	*temp;
 	struct sctp_transport	*transport;
 	list_for_each_safe(pos, temp, &asoc->peer.transport_addr_list) {
 		transport = list_entry(pos, struct sctp_transport, transports);
 		if (sctp_cmp_addr_exact(addr, &transport->ipaddr)) {
 			/* Do book keeping for removing the peer and free it. */
 			sctp_assoc_rm_peer(asoc, transport);
 			break;
 		}
 	}
 }
 /* Lookup a transport by address. */
 struct sctp_transport *sctp_assoc_lookup_paddr(
 					const struct sctp_association *asoc,
 					const union sctp_addr *address)
 {
 	struct sctp_transport *t;
 	/* Cycle through all transports searching for a peer address. */
 	list_for_each_entry(t, &asoc->peer.transport_addr_list,
 			transports) {
 		if (sctp_cmp_addr_exact(address, &t->ipaddr))
 			return t;
 	}
 	return NULL;
 }
 /* Remove all transports except a give one */
 void sctp_assoc_del_nonprimary_peers(struct sctp_association *asoc,
 				     struct sctp_transport *primary)
 {
 	struct sctp_transport	*temp;
 	struct sctp_transport	*t;
 	list_for_each_entry_safe(t, temp, &asoc->peer.transport_addr_list,
 				 transports) {
 		/* if the current transport is not the primary one, delete it */
 		if (t != primary)
 			sctp_assoc_rm_peer(asoc, t);
 	}
 }
 /* Engage in transport control operations.
  * Mark the transport up or down and send a notification to the user.
  * Select and update the new active and retran paths.
  */
 void sctp_assoc_control_transport(struct sctp_association *asoc,
 				  struct sctp_transport *transport,
 				  sctp_transport_cmd_t command,
 				  sctp_sn_error_t error)
 {
 	struct sctp_ulpevent *event;
 	struct sockaddr_storage addr;
 	int spc_state = 0;
 	bool ulp_notify = true;
 	/* Record the transition on the transport.  */
 	switch (command) {
 	case SCTP_TRANSPORT_UP:
 		/* If we are moving from UNCONFIRMED state due
 		 * to heartbeat success, report the SCTP_ADDR_CONFIRMED
 		 * state to the user, otherwise report SCTP_ADDR_AVAILABLE.
 		 */
 		if (SCTP_UNCONFIRMED == transport->state &&
 		    SCTP_HEARTBEAT_SUCCESS == error)
 			spc_state = SCTP_ADDR_CONFIRMED;
 		else
 			spc_state = SCTP_ADDR_AVAILABLE;
 		/* Don't inform ULP about transition from PF to
 		 * active state and set cwnd to 1 MTU, see SCTP
 		 * Quick failover draft section 5.1, point 5
 		 */
 		if (transport->state == SCTP_PF) {
 			ulp_notify = false;
 			transport->cwnd = asoc->pathmtu;
 		}
 		transport->state = SCTP_ACTIVE;
 		break;
 	case SCTP_TRANSPORT_DOWN:
 		/* If the transport was never confirmed, do not transition it
 		 * to inactive state.  Also, release the cached route since
 		 * there may be a better route next time.
 		 */
 		if (transport->state != SCTP_UNCONFIRMED)
 			transport->state = SCTP_INACTIVE;
 		else {
 			dst_release(transport->dst);
 			transport->dst = NULL;
 			ulp_notify = false;
 		}
 		spc_state = SCTP_ADDR_UNREACHABLE;
 		break;
 	case SCTP_TRANSPORT_PF:
 		transport->state = SCTP_PF;
 		ulp_notify = false;
 		break;
 	default:
 		return;
 	}
 	/* Generate and send a SCTP_PEER_ADDR_CHANGE notification
 	 * to the user.
 	 */
 	if (ulp_notify) {
 		memset(&addr, 0, sizeof(struct sockaddr_storage));
 		memcpy(&addr, &transport->ipaddr,
 		       transport->af_specific->sockaddr_len);
 		event = sctp_ulpevent_make_peer_addr_change(asoc, &addr,
 					0, spc_state, error, GFP_ATOMIC);
 		if (event)
 			sctp_ulpq_tail_event(&asoc->ulpq, event);
 	}
 	/* Select new active and retran paths. */
 	sctp_select_active_and_retran_path(asoc);
 }
 /* Hold a reference to an association. */
 void sctp_association_hold(struct sctp_association *asoc)
 {
 	atomic_inc(&asoc->base.refcnt);
 }
 /* Release a reference to an association and cleanup
  * if there are no more references.
  */
 void sctp_association_put(struct sctp_association *asoc)
 {
 	if (atomic_dec_and_test(&asoc->base.refcnt))
 		sctp_association_destroy(asoc);
 }
 /* Allocate the next TSN, Transmission Sequence Number, for the given
  * association.
  */
 __u32 sctp_association_get_next_tsn(struct sctp_association *asoc)
 {
 	/* From Section 1.6 Serial Number Arithmetic:
 	 * Transmission Sequence Numbers wrap around when they reach
 	 * 2**32 - 1.  That is, the next TSN a DATA chunk MUST use
 	 * after transmitting TSN = 2*32 - 1 is TSN = 0.
 	 */
 	__u32 retval = asoc->next_tsn;
 	asoc->next_tsn++;
 	asoc->unack_data++;
 	return retval;
 }
 /* Compare two addresses to see if they match.  Wildcard addresses
  * only match themselves.
  */
 int sctp_cmp_addr_exact(const union sctp_addr *ss1,
 			const union sctp_addr *ss2)
 {
 	struct sctp_af *af;
 	af = sctp_get_af_specific(ss1->sa.sa_family);
 	if (unlikely(!af))
 		return 0;
 	return af->cmp_addr(ss1, ss2);
 }
 /* Return an ecne chunk to get prepended to a packet.
  * Note:  We are sly and return a shared, prealloced chunk.  FIXME:
  * No we don't, but we could/should.
  */
 struct sctp_chunk *sctp_get_ecne_prepend(struct sctp_association *asoc)
 {
 	if (!asoc->need_ecne)
 		return NULL;
 	/* Send ECNE if needed.
 	 * Not being able to allocate a chunk here is not deadly.
 	 */
 	return sctp_make_ecne(asoc, asoc->last_ecne_tsn);
 }
 /*
  * Find which transport this TSN was sent on.
  */
 struct sctp_transport *sctp_assoc_lookup_tsn(struct sctp_association *asoc,
 					     __u32 tsn)
 {
 	struct sctp_transport *active;
 	struct sctp_transport *match;
 	struct sctp_transport *transport;
 	struct sctp_chunk *chunk;
 	__be32 key = htonl(tsn);
 	match = NULL;
 	/*
 	 * FIXME: In general, find a more efficient data structure for
 	 * searching.
 	 */
 	/*
 	 * The general strategy is to search each transport's transmitted
 	 * list.   Return which transport this TSN lives on.
 	 *
 	 * Let's be hopeful and check the active_path first.
 	 * Another optimization would be to know if there is only one
 	 * outbound path and not have to look for the TSN at all.
 	 *
 	 */
 	active = asoc->peer.active_path;
 	list_for_each_entry(chunk, &active->transmitted,
 			transmitted_list) {
 		if (key == chunk->subh.data_hdr->tsn) {
 			match = active;
 			goto out;
 		}
 	}
 	/* If not found, go search all the other transports. */
 	list_for_each_entry(transport, &asoc->peer.transport_addr_list,
 			transports) {
 		if (transport == active)
 			continue;
 		list_for_each_entry(chunk, &transport->transmitted,
 				transmitted_list) {
 			if (key == chunk->subh.data_hdr->tsn) {
 				match = transport;
 				goto out;
 			}
 		}
 	}
 out:
 	return match;
 }
 /* Is this the association we are looking for? */
 struct sctp_transport *sctp_assoc_is_match(struct sctp_association *asoc,
 					   struct net *net,
 					   const union sctp_addr *laddr,
 					   const union sctp_addr *paddr)
 {
 	struct sctp_transport *transport;
 	if ((htons(asoc->base.bind_addr.port) == laddr->v4.sin_port) &&
 	    (htons(asoc->peer.port) == paddr->v4.sin_port) &&
 	    net_eq(sock_net(asoc->base.sk), net)) {
 		transport = sctp_assoc_lookup_paddr(asoc, paddr);
 		if (!transport)
 			goto out;
 		if (sctp_bind_addr_match(&asoc->base.bind_addr, laddr,
 					 sctp_sk(asoc->base.sk)))
 			goto out;
 	}
 	transport = NULL;
 out:
 	return transport;
 }
 /* Do delayed input processing.  This is scheduled by sctp_rcv(). */
 static void sctp_assoc_bh_rcv(struct work_struct *work)
 {
 	struct sctp_association *asoc =
 		container_of(work, struct sctp_association,
 			     base.inqueue.immediate);
 	struct net *net = sock_net(asoc->base.sk);
 	struct sctp_endpoint *ep;
 	struct sctp_chunk *chunk;
 	struct sctp_inq *inqueue;
 	int state;
 	sctp_subtype_t subtype;
 	int error = 0;
 	/* The association should be held so we should be safe. */
 	ep = asoc->ep;
 	inqueue = &asoc->base.inqueue;
 	sctp_association_hold(asoc);
 	while (NULL != (chunk = sctp_inq_pop(inqueue))) {
 		state = asoc->state;
 		subtype = SCTP_ST_CHUNK(chunk->chunk_hdr->type);
 		/* SCTP-AUTH, Section 6.3:
 		 *    The receiver has a list of chunk types which it expects
 		 *    to be received only after an AUTH-chunk.  This list has
 		 *    been sent to the peer during the association setup.  It
 		 *    MUST silently discard these chunks if they are not placed
 		 *    after an AUTH chunk in the packet.
 		 */
 		if (sctp_auth_recv_cid(subtype.chunk, asoc) && !chunk->auth)
 			continue;
 		/* Remember where the last DATA chunk came from so we
 		 * know where to send the SACK.
 		 */
 		if (sctp_chunk_is_data(chunk))
 			asoc->peer.last_data_from = chunk->transport;
 		else {
 			SCTP_INC_STATS(net, SCTP_MIB_INCTRLCHUNKS);
 			asoc->stats.ictrlchunks++;
 			if (chunk->chunk_hdr->type == SCTP_CID_SACK)
 				asoc->stats.isacks++;
 		}
 		if (chunk->transport)
 			chunk->transport->last_time_heard = ktime_get();
 		/* Run through the state machine. */
 		error = sctp_do_sm(net, SCTP_EVENT_T_CHUNK, subtype,
 				   state, ep, asoc, chunk, GFP_ATOMIC);
 		/* Check to see if the association is freed in response to
 		 * the incoming chunk.  If so, get out of the while loop.
 		 */
 		if (asoc->base.dead)
 			break;
 		/* If there is an error on chunk, discard this packet. */
 		if (error && chunk)
 			chunk->pdiscard = 1;
 	}
 	sctp_association_put(asoc);
 }
 /* This routine moves an association from its old sk to a new sk.  */
 void sctp_assoc_migrate(struct sctp_association *assoc, struct sock *newsk)
 {
 	struct sctp_sock *newsp = sctp_sk(newsk);
 	struct sock *oldsk = assoc->base.sk;
 	/* Delete the association from the old endpoint's list of
 	 * associations.
 	 */
 	list_del_init(&assoc->asocs);
 	/* Decrement the backlog value for a TCP-style socket. */
 	if (sctp_style(oldsk, TCP))
 		oldsk->sk_ack_backlog--;
 	/* Release references to the old endpoint and the sock.  */
 	sctp_endpoint_put(assoc->ep);
 	sock_put(assoc->base.sk);
 	/* Get a reference to the new endpoint.  */
 	assoc->ep = newsp->ep;
 	sctp_endpoint_hold(assoc->ep);
 	/* Get a reference to the new sock.  */
 	assoc->base.sk = newsk;
 	sock_hold(assoc->base.sk);
 	/* Add the association to the new endpoint's list of associations.  */
 	sctp_endpoint_add_asoc(newsp->ep, assoc);
 }
 /* Update an association (possibly from unexpected COOKIE-ECHO processing).  */
 void sctp_assoc_update(struct sctp_association *asoc,
 		       struct sctp_association *new)
 {
 	struct sctp_transport *trans;
 	struct list_head *pos, *temp;
 	/* Copy in new parameters of peer. */
 	asoc->c = new->c;
 	asoc->peer.rwnd = new->peer.rwnd;
 	asoc->peer.sack_needed = new->peer.sack_needed;
 	asoc->peer.auth_capable = new->peer.auth_capable;
 	asoc->peer.i = new->peer.i;
 	sctp_tsnmap_init(&asoc->peer.tsn_map, SCTP_TSN_MAP_INITIAL,
 			 asoc->peer.i.initial_tsn, GFP_ATOMIC);
 	/* Remove any peer addresses not present in the new association. */
 	list_for_each_safe(pos, temp, &asoc->peer.transport_addr_list) {
 		trans = list_entry(pos, struct sctp_transport, transports);
 		if (!sctp_assoc_lookup_paddr(new, &trans->ipaddr)) {
 			sctp_assoc_rm_peer(asoc, trans);
 			continue;
 		}
 		if (asoc->state >= SCTP_STATE_ESTABLISHED)
 			sctp_transport_reset(trans);
 	}
 	/* If the case is A (association restart), use
 	 * initial_tsn as next_tsn. If the case is B, use
 	 * current next_tsn in case data sent to peer
 	 * has been discarded and needs retransmission.
 	 */
 	if (asoc->state >= SCTP_STATE_ESTABLISHED) {
 		asoc->next_tsn = new->next_tsn;
 		asoc->ctsn_ack_point = new->ctsn_ack_point;
 		asoc->adv_peer_ack_point = new->adv_peer_ack_point;
 		/* Reinitialize SSN for both local streams
 		 * and peer's streams.
 		 */
 		sctp_ssnmap_clear(asoc->ssnmap);
 		/* Flush the ULP reassembly and ordered queue.
 		 * Any data there will now be stale and will
 		 * cause problems.
 		 */
 		sctp_ulpq_flush(&asoc->ulpq);
 		/* reset the overall association error count so
 		 * that the restarted association doesn't get torn
 		 * down on the next retransmission timer.
 		 */
 		asoc->overall_error_count = 0;
 	} else {
 		/* Add any peer addresses from the new association. */
 		list_for_each_entry(trans, &new->peer.transport_addr_list,
 				transports) {
 			if (!sctp_assoc_lookup_paddr(asoc, &trans->ipaddr))
 				sctp_assoc_add_peer(asoc, &trans->ipaddr,
 						    GFP_ATOMIC, trans->state);
 		}
 		asoc->ctsn_ack_point = asoc->next_tsn - 1;
 		asoc->adv_peer_ack_point = asoc->ctsn_ack_point;
 		if (!asoc->ssnmap) {
 			/* Move the ssnmap. */
 			asoc->ssnmap = new->ssnmap;
 			new->ssnmap = NULL;
 		}
 		if (!asoc->assoc_id) {
 			/* get a new association id since we don't have one
 			 * yet.
 			 */
 			sctp_assoc_set_id(asoc, GFP_ATOMIC);
 		}
 	}
 	/* SCTP-AUTH: Save the peer parameters from the new associations
 	 * and also move the association shared keys over
 	 */
 	kfree(asoc->peer.peer_random);
 	asoc->peer.peer_random = new->peer.peer_random;
 	new->peer.peer_random = NULL;
 	kfree(asoc->peer.peer_chunks);
 	asoc->peer.peer_chunks = new->peer.peer_chunks;
 	new->peer.peer_chunks = NULL;
 	kfree(asoc->peer.peer_hmacs);
 	asoc->peer.peer_hmacs = new->peer.peer_hmacs;
 	new->peer.peer_hmacs = NULL;
-	sctp_auth_key_put(asoc->asoc_shared_key);
 	sctp_auth_asoc_init_active_key(asoc, GFP_ATOMIC);
 }
 /* Update the retran path for sending a retransmitted packet.
  * See also RFC4960, 6.4. Multi-Homed SCTP Endpoints:
  *
  *   When there is outbound data to send and the primary path
  *   becomes inactive (e.g., due to failures), or where the
  *   SCTP user explicitly requests to send data to an
  *   inactive destination transport address, before reporting
  *   an error to its ULP, the SCTP endpoint should try to send
  *   the data to an alternate active destination transport
  *   address if one exists.
  *
  *   When retransmitting data that timed out, if the endpoint
  *   is multihomed, it should consider each source-destination
  *   address pair in its retransmission selection policy.
  *   When retransmitting timed-out data, the endpoint should
  *   attempt to pick the most divergent source-destination
  *   pair from the original source-destination pair to which
  *   the packet was transmitted.
  *
  *   Note: Rules for picking the most divergent source-destination
  *   pair are an implementation decision and are not specified
  *   within this document.
  *
  * Our basic strategy is to round-robin transports in priorities
  * according to sctp_state_prio_map[] e.g., if no such
  * transport with state SCTP_ACTIVE exists, round-robin through
  * SCTP_UNKNOWN, etc. You get the picture.
  */
 static const u8 sctp_trans_state_to_prio_map[] = {
 	[SCTP_ACTIVE]	= 3,	/* best case */
 	[SCTP_UNKNOWN]	= 2,
 	[SCTP_PF]	= 1,
 	[SCTP_INACTIVE] = 0,	/* worst case */
 };
 static u8 sctp_trans_score(const struct sctp_transport *trans)
 {
 	return sctp_trans_state_to_prio_map[trans->state];
 }
 static struct sctp_transport *sctp_trans_elect_tie(struct sctp_transport *trans1,
 						   struct sctp_transport *trans2)
 {
 	if (trans1->error_count > trans2->error_count) {
 		return trans2;
 	} else if (trans1->error_count == trans2->error_count &&
 		   ktime_after(trans2->last_time_heard,
 			       trans1->last_time_heard)) {
 		return trans2;
 	} else {
 		return trans1;
 	}
 }
 static struct sctp_transport *sctp_trans_elect_best(struct sctp_transport *curr,
 						    struct sctp_transport *best)
 {
 	u8 score_curr, score_best;
 	if (best == NULL || curr == best)
 		return curr;
 	score_curr = sctp_trans_score(curr);
 	score_best = sctp_trans_score(best);
 	/* First, try a score-based selection if both transport states
 	 * differ. If we're in a tie, lets try to make a more clever
 	 * decision here based on error counts and last time heard.
 	 */
 	if (score_curr > score_best)
 		return curr;
 	else if (score_curr == score_best)
 		return sctp_trans_elect_tie(curr, best);
 	else
 		return best;
 }
 void sctp_assoc_update_retran_path(struct sctp_association *asoc)
 {
 	struct sctp_transport *trans = asoc->peer.retran_path;
 	struct sctp_transport *trans_next = NULL;
 	/* We're done as we only have the one and only path. */
 	if (asoc->peer.transport_count == 1)
 		return;
 	/* If active_path and retran_path are the same and active,
 	 * then this is the only active path. Use it.
 	 */
 	if (asoc->peer.active_path == asoc->peer.retran_path &&
 	    asoc->peer.active_path->state == SCTP_ACTIVE)
 		return;
 	/* Iterate from retran_path's successor back to retran_path. */
 	for (trans = list_next_entry(trans, transports); 1;
 	     trans = list_next_entry(trans, transports)) {
 		/* Manually skip the head element. */
 		if (&trans->transports == &asoc->peer.transport_addr_list)
 			continue;
 		if (trans->state == SCTP_UNCONFIRMED)
 			continue;
 		trans_next = sctp_trans_elect_best(trans, trans_next);
 		/* Active is good enough for immediate return. */
 		if (trans_next->state == SCTP_ACTIVE)
 			break;
 		/* We've reached the end, time to update path. */
 		if (trans == asoc->peer.retran_path)
 			break;
 	}
 	asoc->peer.retran_path = trans_next;
 	pr_debug("%s: association:%p updated new path to addr:%pISpc\n",
 		 __func__, asoc, &asoc->peer.retran_path->ipaddr.sa);
 }
 static void sctp_select_active_and_retran_path(struct sctp_association *asoc)
 {
 	struct sctp_transport *trans, *trans_pri = NULL, *trans_sec = NULL;
 	struct sctp_transport *trans_pf = NULL;
 	/* Look for the two most recently used active transports. */
 	list_for_each_entry(trans, &asoc->peer.transport_addr_list,
 			    transports) {
 		/* Skip uninteresting transports. */
 		if (trans->state == SCTP_INACTIVE ||
 		    trans->state == SCTP_UNCONFIRMED)
 			continue;
 		/* Keep track of the best PF transport from our
 		 * list in case we don't find an active one.
 		 */
 		if (trans->state == SCTP_PF) {
 			trans_pf = sctp_trans_elect_best(trans, trans_pf);
 			continue;
 		}
 		/* For active transports, pick the most recent ones. */
 		if (trans_pri == NULL ||
 		    ktime_after(trans->last_time_heard,
 				trans_pri->last_time_heard)) {
 			trans_sec = trans_pri;
 			trans_pri = trans;
 		} else if (trans_sec == NULL ||
 			   ktime_after(trans->last_time_heard,
 				       trans_sec->last_time_heard)) {
 			trans_sec = trans;
 		}
 	}
 	/* RFC 2960 6.4 Multi-Homed SCTP Endpoints
 	 *
 	 * By default, an endpoint should always transmit to the primary
 	 * path, unless the SCTP user explicitly specifies the
 	 * destination transport address (and possibly source transport
 	 * address) to use. [If the primary is active but not most recent,
 	 * bump the most recently used transport.]
 	 */
 	if ((asoc->peer.primary_path->state == SCTP_ACTIVE ||
 	     asoc->peer.primary_path->state == SCTP_UNKNOWN) &&
 	     asoc->peer.primary_path != trans_pri) {
 		trans_sec = trans_pri;
 		trans_pri = asoc->peer.primary_path;
 	}
 	/* We did not find anything useful for a possible retransmission
 	 * path; either primary path that we found is the the same as
 	 * the current one, or we didn't generally find an active one.
 	 */
 	if (trans_sec == NULL)
 		trans_sec = trans_pri;
 	/* If we failed to find a usable transport, just camp on the
 	 * active or pick a PF iff it's the better choice.
 	 */
 	if (trans_pri == NULL) {
 		trans_pri = sctp_trans_elect_best(asoc->peer.active_path, trans_pf);
 		trans_sec = trans_pri;
 	}
 	/* Set the active and retran transports. */
 	asoc->peer.active_path = trans_pri;
 	asoc->peer.retran_path = trans_sec;
 }
 struct sctp_transport *
 sctp_assoc_choose_alter_transport(struct sctp_association *asoc,
 				  struct sctp_transport *last_sent_to)
 {
 	/* If this is the first time packet is sent, use the active path,
 	 * else use the retran path. If the last packet was sent over the
 	 * retran path, update the retran path and use it.
 	 */
 	if (last_sent_to == NULL) {
 		return asoc->peer.active_path;
 	} else {
 		if (last_sent_to == asoc->peer.retran_path)
 			sctp_assoc_update_retran_path(asoc);
 		return asoc->peer.retran_path;
 	}
 }
 /* Update the association's pmtu and frag_point by going through all the
  * transports. This routine is called when a transport's PMTU has changed.
  */
 void sctp_assoc_sync_pmtu(struct sock *sk, struct sctp_association *asoc)
 {
 	struct sctp_transport *t;
 	__u32 pmtu = 0;
 	if (!asoc)
 		return;
 	/* Get the lowest pmtu of all the transports. */
 	list_for_each_entry(t, &asoc->peer.transport_addr_list,
 				transports) {
 		if (t->pmtu_pending && t->dst) {
 			sctp_transport_update_pmtu(sk, t, dst_mtu(t->dst));
 			t->pmtu_pending = 0;
 		}
 		if (!pmtu || (t->pathmtu < pmtu))
 			pmtu = t->pathmtu;
 	}
 	if (pmtu) {
 		asoc->pathmtu = pmtu;
 		asoc->frag_point = sctp_frag_point(asoc, pmtu);
 	}
 	pr_debug("%s: asoc:%p, pmtu:%d, frag_point:%d\n", __func__, asoc,
 		 asoc->pathmtu, asoc->frag_point);
 }
 /* Should we send a SACK to update our peer? */
 static inline bool sctp_peer_needs_update(struct sctp_association *asoc)
 {
 	struct net *net = sock_net(asoc->base.sk);
 	switch (asoc->state) {
 	case SCTP_STATE_ESTABLISHED:
 	case SCTP_STATE_SHUTDOWN_PENDING:
 	case SCTP_STATE_SHUTDOWN_RECEIVED:
 	case SCTP_STATE_SHUTDOWN_SENT:
 		if ((asoc->rwnd > asoc->a_rwnd) &&
 		    ((asoc->rwnd - asoc->a_rwnd) >= max_t(__u32,
 			   (asoc->base.sk->sk_rcvbuf >> net->sctp.rwnd_upd_shift),
 			   asoc->pathmtu)))
 			return true;
 		break;
 	default:
 		break;
 	}
 	return false;
 }
 /* Increase asoc's rwnd by len and send any window update SACK if needed. */
 void sctp_assoc_rwnd_increase(struct sctp_association *asoc, unsigned int len)
 {
 	struct sctp_chunk *sack;
 	struct timer_list *timer;
 	if (asoc->rwnd_over) {
 		if (asoc->rwnd_over >= len) {
 			asoc->rwnd_over -= len;
 		} else {
 			asoc->rwnd += (len - asoc->rwnd_over);
 			asoc->rwnd_over = 0;
 		}
 	} else {
 		asoc->rwnd += len;
 	}
 	/* If we had window pressure, start recovering it
 	 * once our rwnd had reached the accumulated pressure
 	 * threshold.  The idea is to recover slowly, but up
 	 * to the initial advertised window.
 	 */
 	if (asoc->rwnd_press && asoc->rwnd >= asoc->rwnd_press) {
 		int change = min(asoc->pathmtu, asoc->rwnd_press);
 		asoc->rwnd += change;
 		asoc->rwnd_press -= change;
 	}
 	pr_debug("%s: asoc:%p rwnd increased by %d to (%u, %u) - %u\n",
 		 __func__, asoc, len, asoc->rwnd, asoc->rwnd_over,
 		 asoc->a_rwnd);
 	/* Send a window update SACK if the rwnd has increased by at least the
 	 * minimum of the association's PMTU and half of the receive buffer.
 	 * The algorithm used is similar to the one described in
 	 * Section 4.2.3.3 of RFC 1122.
 	 */
 	if (sctp_peer_needs_update(asoc)) {
 		asoc->a_rwnd = asoc->rwnd;
 		pr_debug("%s: sending window update SACK- asoc:%p rwnd:%u "
 			 "a_rwnd:%u\n", __func__, asoc, asoc->rwnd,
 			 asoc->a_rwnd);
 		sack = sctp_make_sack(asoc);
 		if (!sack)
 			return;
 		asoc->peer.sack_needed = 0;
 		sctp_outq_tail(&asoc->outqueue, sack);
 		/* Stop the SACK timer.  */
 		timer = &asoc->timers[SCTP_EVENT_TIMEOUT_SACK];
 		if (del_timer(timer))
 			sctp_association_put(asoc);
 	}
 }
 /* Decrease asoc's rwnd by len. */
 void sctp_assoc_rwnd_decrease(struct sctp_association *asoc, unsigned int len)
 {
 	int rx_count;
 	int over = 0;
 	if (unlikely(!asoc->rwnd || asoc->rwnd_over))
 		pr_debug("%s: association:%p has asoc->rwnd:%u, "
 			 "asoc->rwnd_over:%u!\n", __func__, asoc,
 			 asoc->rwnd, asoc->rwnd_over);
 	if (asoc->ep->rcvbuf_policy)
 		rx_count = atomic_read(&asoc->rmem_alloc);
 	else
 		rx_count = atomic_read(&asoc->base.sk->sk_rmem_alloc);
 	/* If we've reached or overflowed our receive buffer, announce
 	 * a 0 rwnd if rwnd would still be positive.  Store the
 	 * the potential pressure overflow so that the window can be restored
 	 * back to original value.
 	 */
 	if (rx_count >= asoc->base.sk->sk_rcvbuf)
 		over = 1;
 	if (asoc->rwnd >= len) {
 		asoc->rwnd -= len;
 		if (over) {
 			asoc->rwnd_press += asoc->rwnd;
 			asoc->rwnd = 0;
 		}
 	} else {
 		asoc->rwnd_over = len - asoc->rwnd;
 		asoc->rwnd = 0;
 	}
 	pr_debug("%s: asoc:%p rwnd decreased by %d to (%u, %u, %u)\n",
 		 __func__, asoc, len, asoc->rwnd, asoc->rwnd_over,
 		 asoc->rwnd_press);
 }
 /* Build the bind address list for the association based on info from the
  * local endpoint and the remote peer.
  */
 int sctp_assoc_set_bind_addr_from_ep(struct sctp_association *asoc,
 				     sctp_scope_t scope, gfp_t gfp)
 {
 	int flags;
 	/* Use scoping rules to determine the subset of addresses from
 	 * the endpoint.
 	 */
 	flags = (PF_INET6 == asoc->base.sk->sk_family) ? SCTP_ADDR6_ALLOWED : 0;
 	if (asoc->peer.ipv4_address)
 		flags |= SCTP_ADDR4_PEERSUPP;
 	if (asoc->peer.ipv6_address)
 		flags |= SCTP_ADDR6_PEERSUPP;
 	return sctp_bind_addr_copy(sock_net(asoc->base.sk),
 				   &asoc->base.bind_addr,
 				   &asoc->ep->base.bind_addr,
 				   scope, gfp, flags);
 }
 /* Build the association's bind address list from the cookie.  */
 int sctp_assoc_set_bind_addr_from_cookie(struct sctp_association *asoc,
 					 struct sctp_cookie *cookie,
 					 gfp_t gfp)
 {
 	int var_size2 = ntohs(cookie->peer_init->chunk_hdr.length);
 	int var_size3 = cookie->raw_addr_list_len;
 	__u8 *raw = (__u8 *)cookie->peer_init + var_size2;
 	return sctp_raw_to_bind_addrs(&asoc->base.bind_addr, raw, var_size3,
 				      asoc->ep->base.bind_addr.port, gfp);
 }
 /* Lookup laddr in the bind address list of an association. */
 int sctp_assoc_lookup_laddr(struct sctp_association *asoc,
 			    const union sctp_addr *laddr)
 {
 	int found = 0;
 	if ((asoc->base.bind_addr.port == ntohs(laddr->v4.sin_port)) &&
 	    sctp_bind_addr_match(&asoc->base.bind_addr, laddr,
 				 sctp_sk(asoc->base.sk)))
 		found = 1;
 	return found;
 }
 /* Set an association id for a given association */
 int sctp_assoc_set_id(struct sctp_association *asoc, gfp_t gfp)
 {
 	bool preload = !!(gfp & __GFP_WAIT);
 	int ret;
 	/* If the id is already assigned, keep it. */
 	if (asoc->assoc_id)
 		return 0;
 	if (preload)
 		idr_preload(gfp);
 	spin_lock_bh(&sctp_assocs_id_lock);
 	/* 0 is not a valid assoc_id, must be >= 1 */
 	ret = idr_alloc_cyclic(&sctp_assocs_id, asoc, 1, 0, GFP_NOWAIT);
 	spin_unlock_bh(&sctp_assocs_id_lock);
 	if (preload)
 		idr_preload_end();
 	if (ret < 0)
 		return ret;
 	asoc->assoc_id = (sctp_assoc_t)ret;
 	return 0;
 }
 /* Free the ASCONF queue */
 static void sctp_assoc_free_asconf_queue(struct sctp_association *asoc)
 {
 	struct sctp_chunk *asconf;
 	struct sctp_chunk *tmp;
 	list_for_each_entry_safe(asconf, tmp, &asoc->addip_chunk_list, list) {
 		list_del_init(&asconf->list);
 		sctp_chunk_free(asconf);
 	}
 }
 /* Free asconf_ack cache */
 static void sctp_assoc_free_asconf_acks(struct sctp_association *asoc)
 {
 	struct sctp_chunk *ack;
 	struct sctp_chunk *tmp;
 	list_for_each_entry_safe(ack, tmp, &asoc->asconf_ack_list,
 				transmitted_list) {
 		list_del_init(&ack->transmitted_list);
 		sctp_chunk_free(ack);
 	}
 }
 /* Clean up the ASCONF_ACK queue */
 void sctp_assoc_clean_asconf_ack_cache(const struct sctp_association *asoc)
 {
 	struct sctp_chunk *ack;
 	struct sctp_chunk *tmp;
 	/* We can remove all the entries from the queue up to
 	 * the "Peer-Sequence-Number".
 	 */
 	list_for_each_entry_safe(ack, tmp, &asoc->asconf_ack_list,
 				transmitted_list) {
 		if (ack->subh.addip_hdr->serial ==
 				htonl(asoc->peer.addip_serial))
 			break;
 		list_del_init(&ack->transmitted_list);
 		sctp_chunk_free(ack);
 	}
 }
 /* Find the ASCONF_ACK whose serial number matches ASCONF */
 struct sctp_chunk *sctp_assoc_lookup_asconf_ack(
 					const struct sctp_association *asoc,
 					__be32 serial)
 {
 	struct sctp_chunk *ack;
 	/* Walk through the list of cached ASCONF-ACKs and find the
 	 * ack chunk whose serial number matches that of the request.
 	 */
 	list_for_each_entry(ack, &asoc->asconf_ack_list, transmitted_list) {
 		if (sctp_chunk_pending(ack))
 			continue;
 		if (ack->subh.addip_hdr->serial == serial) {
 			sctp_chunk_hold(ack);
 			return ack;
 		}
 	}
 	return NULL;
 }
 void sctp_asconf_queue_teardown(struct sctp_association *asoc)
 {
 	/* Free any cached ASCONF_ACK chunk. */
 	sctp_assoc_free_asconf_acks(asoc);
 	/* Free the ASCONF queue. */
 	sctp_assoc_free_asconf_queue(asoc);
 	/* Free any cached ASCONF chunk. */
 	if (asoc->addip_last_asconf)
 		sctp_chunk_free(asoc->addip_last_asconf);
 }