Doug / smarc-fsl-linux-kernel

1

/*

1

/*

2

* Neighbour Discovery for IPv6

2

* Neighbour Discovery for IPv6

3

* Linux INET6 implementation

3

* Linux INET6 implementation

4

*

4

*

5

* Authors:

5

* Authors:

6

* Pedro Roque <roque@di.fc.ul.pt>

6

* Pedro Roque <roque@di.fc.ul.pt>

7

* Mike Shaver <shaver@ingenia.com>

7

* Mike Shaver <shaver@ingenia.com>

8

*

8

*

9

* This program is free software; you can redistribute it and/or

9

* This program is free software; you can redistribute it and/or

10

* modify it under the terms of the GNU General Public License

10

* modify it under the terms of the GNU General Public License

11

* as published by the Free Software Foundation; either version

11

* as published by the Free Software Foundation; either version

12

* 2 of the License, or (at your option) any later version.

12

* 2 of the License, or (at your option) any later version.

13

*/

13

*/

14

15

/*

15

/*

16

* Changes:

16

* Changes:

17

*

17

*

18

* Lars Fenneberg : fixed MTU setting on receipt

18

* Lars Fenneberg : fixed MTU setting on receipt

19

* of an RA.

19

* of an RA.

20

*

20

*

21

* Janos Farkas : kmalloc failure checks

21

* Janos Farkas : kmalloc failure checks

22

* Alexey Kuznetsov : state machine reworked

22

* Alexey Kuznetsov : state machine reworked

23

* and moved to net/core.

23

* and moved to net/core.

24

* Pekka Savola : RFC2461 validation

24

* Pekka Savola : RFC2461 validation

25

* YOSHIFUJI Hideaki @USAGI : Verify ND options properly

25

* YOSHIFUJI Hideaki @USAGI : Verify ND options properly

26

*/

26

*/

27

28

/* Set to 3 to get tracing... */

28

/* Set to 3 to get tracing... */

29

#define ND_DEBUG 1

29

#define ND_DEBUG 1

30

31

#define ND_PRINTK(fmt, args...) do { if (net_ratelimit()) { printk(fmt, ## args); } } while(0)

31

#define ND_PRINTK(fmt, args...) do { if (net_ratelimit()) { printk(fmt, ## args); } } while(0)

32

#define ND_NOPRINTK(x...) do { ; } while(0)

32

#define ND_NOPRINTK(x...) do { ; } while(0)

33

#define ND_PRINTK0 ND_PRINTK

33

#define ND_PRINTK0 ND_PRINTK

34

#define ND_PRINTK1 ND_NOPRINTK

34

#define ND_PRINTK1 ND_NOPRINTK

35

#define ND_PRINTK2 ND_NOPRINTK

35

#define ND_PRINTK2 ND_NOPRINTK

36

#define ND_PRINTK3 ND_NOPRINTK

36

#define ND_PRINTK3 ND_NOPRINTK

37

#if ND_DEBUG >= 1

37

#if ND_DEBUG >= 1

38

#undef ND_PRINTK1

38

#undef ND_PRINTK1

39

#define ND_PRINTK1 ND_PRINTK

39

#define ND_PRINTK1 ND_PRINTK

40

#endif

40

#endif

41

#if ND_DEBUG >= 2

41

#if ND_DEBUG >= 2

42

#undef ND_PRINTK2

42

#undef ND_PRINTK2

43

#define ND_PRINTK2 ND_PRINTK

43

#define ND_PRINTK2 ND_PRINTK

44

#endif

44

#endif

45

#if ND_DEBUG >= 3

45

#if ND_DEBUG >= 3

46

#undef ND_PRINTK3

46

#undef ND_PRINTK3

47

#define ND_PRINTK3 ND_PRINTK

47

#define ND_PRINTK3 ND_PRINTK

48

#endif

48

#endif

49

50

#include <linux/module.h>

50

#include <linux/module.h>

51

#include <linux/config.h>

51

#include <linux/config.h>

52

#include <linux/errno.h>

52

#include <linux/errno.h>

53

#include <linux/types.h>

53

#include <linux/types.h>

54

#include <linux/socket.h>

54

#include <linux/socket.h>

55

#include <linux/sockios.h>

55

#include <linux/sockios.h>

56

#include <linux/sched.h>

56

#include <linux/sched.h>

57

#include <linux/net.h>

57

#include <linux/net.h>

58

#include <linux/in6.h>

58

#include <linux/in6.h>

59

#include <linux/route.h>

59

#include <linux/route.h>

60

#include <linux/init.h>

60

#include <linux/init.h>

61

#include <linux/rcupdate.h>

61

#include <linux/rcupdate.h>

62

#ifdef CONFIG_SYSCTL

62

#ifdef CONFIG_SYSCTL

63

#include <linux/sysctl.h>

63

#include <linux/sysctl.h>

64

#endif

64

#endif

65

66

#include <linux/if_arp.h>

66

#include <linux/if_arp.h>

67

#include <linux/ipv6.h>

67

#include <linux/ipv6.h>

68

#include <linux/icmpv6.h>

68

#include <linux/icmpv6.h>

69

#include <linux/jhash.h>

69

#include <linux/jhash.h>

70

71

#include <net/sock.h>

71

#include <net/sock.h>

72

#include <net/snmp.h>

72

#include <net/snmp.h>

73

74

#include <net/ipv6.h>

74

#include <net/ipv6.h>

75

#include <net/protocol.h>

75

#include <net/protocol.h>

76

#include <net/ndisc.h>

76

#include <net/ndisc.h>

77

#include <net/ip6_route.h>

77

#include <net/ip6_route.h>

78

#include <net/addrconf.h>

78

#include <net/addrconf.h>

79

#include <net/icmp.h>

79

#include <net/icmp.h>

80

81

#include <net/flow.h>

81

#include <net/flow.h>

82

#include <net/ip6_checksum.h>

82

#include <net/ip6_checksum.h>

83

#include <linux/proc_fs.h>

83

#include <linux/proc_fs.h>

84

85

#include <linux/netfilter.h>

85

#include <linux/netfilter.h>

86

#include <linux/netfilter_ipv6.h>

86

#include <linux/netfilter_ipv6.h>

87

88

static struct socket *ndisc_socket;

88

static struct socket *ndisc_socket;

89

90

static u32 ndisc_hash(const void *pkey, const struct net_device *dev);

90

static u32 ndisc_hash(const void *pkey, const struct net_device *dev);

91

static int ndisc_constructor(struct neighbour *neigh);

91

static int ndisc_constructor(struct neighbour *neigh);

92

static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb);

92

static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb);

93

static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb);

93

static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb);

94

static int pndisc_constructor(struct pneigh_entry *n);

94

static int pndisc_constructor(struct pneigh_entry *n);

95

static void pndisc_destructor(struct pneigh_entry *n);

95

static void pndisc_destructor(struct pneigh_entry *n);

96

static void pndisc_redo(struct sk_buff *skb);

96

static void pndisc_redo(struct sk_buff *skb);

97

98

static struct neigh_ops ndisc_generic_ops = {

98

static struct neigh_ops ndisc_generic_ops = {

99

.family = AF_INET6,

99

.family = AF_INET6,

100

.solicit = ndisc_solicit,

100

.solicit = ndisc_solicit,

101

.error_report = ndisc_error_report,

101

.error_report = ndisc_error_report,

102

.output = neigh_resolve_output,

102

.output = neigh_resolve_output,

103

.connected_output = neigh_connected_output,

103

.connected_output = neigh_connected_output,

104

.hh_output = dev_queue_xmit,

104

.hh_output = dev_queue_xmit,

105

.queue_xmit = dev_queue_xmit,

105

.queue_xmit = dev_queue_xmit,

106

};

106

};

107

108

static struct neigh_ops ndisc_hh_ops = {

108

static struct neigh_ops ndisc_hh_ops = {

109

.family = AF_INET6,

109

.family = AF_INET6,

110

.solicit = ndisc_solicit,

110

.solicit = ndisc_solicit,

111

.error_report = ndisc_error_report,

111

.error_report = ndisc_error_report,

112

.output = neigh_resolve_output,

112

.output = neigh_resolve_output,

113

.connected_output = neigh_resolve_output,

113

.connected_output = neigh_resolve_output,

114

.hh_output = dev_queue_xmit,

114

.hh_output = dev_queue_xmit,

115

.queue_xmit = dev_queue_xmit,

115

.queue_xmit = dev_queue_xmit,

116

};

116

};

117

118

119

static struct neigh_ops ndisc_direct_ops = {

119

static struct neigh_ops ndisc_direct_ops = {

120

.family = AF_INET6,

120

.family = AF_INET6,

121

.output = dev_queue_xmit,

121

.output = dev_queue_xmit,

122

.connected_output = dev_queue_xmit,

122

.connected_output = dev_queue_xmit,

123

.hh_output = dev_queue_xmit,

123

.hh_output = dev_queue_xmit,

124

.queue_xmit = dev_queue_xmit,

124

.queue_xmit = dev_queue_xmit,

125

};

125

};

126

127

struct neigh_table nd_tbl = {

127

struct neigh_table nd_tbl = {

128

.family = AF_INET6,

128

.family = AF_INET6,

129

.entry_size = sizeof(struct neighbour) + sizeof(struct in6_addr),

129

.entry_size = sizeof(struct neighbour) + sizeof(struct in6_addr),

130

.key_len = sizeof(struct in6_addr),

130

.key_len = sizeof(struct in6_addr),

131

.hash = ndisc_hash,

131

.hash = ndisc_hash,

132

.constructor = ndisc_constructor,

132

.constructor = ndisc_constructor,

133

.pconstructor = pndisc_constructor,

133

.pconstructor = pndisc_constructor,

134

.pdestructor = pndisc_destructor,

134

.pdestructor = pndisc_destructor,

135

.proxy_redo = pndisc_redo,

135

.proxy_redo = pndisc_redo,

136

.id = "ndisc_cache",

136

.id = "ndisc_cache",

137

.parms = {

137

.parms = {

138

.tbl = &nd_tbl,

138

.tbl = &nd_tbl,

139

.base_reachable_time = 30 * HZ,

139

.base_reachable_time = 30 * HZ,

140

.retrans_time = 1 * HZ,

140

.retrans_time = 1 * HZ,

141

.gc_staletime = 60 * HZ,

141

.gc_staletime = 60 * HZ,

142

.reachable_time = 30 * HZ,

142

.reachable_time = 30 * HZ,

143

.delay_probe_time = 5 * HZ,

143

.delay_probe_time = 5 * HZ,

144

.queue_len = 3,

144

.queue_len = 3,

145

.ucast_probes = 3,

145

.ucast_probes = 3,

146

.mcast_probes = 3,

146

.mcast_probes = 3,

147

.anycast_delay = 1 * HZ,

147

.anycast_delay = 1 * HZ,

148

.proxy_delay = (8 * HZ) / 10,

148

.proxy_delay = (8 * HZ) / 10,

149

.proxy_qlen = 64,

149

.proxy_qlen = 64,

150

},

150

},

151

.gc_interval = 30 * HZ,

151

.gc_interval = 30 * HZ,

152

.gc_thresh1 = 128,

152

.gc_thresh1 = 128,

153

.gc_thresh2 = 512,

153

.gc_thresh2 = 512,

154

.gc_thresh3 = 1024,

154

.gc_thresh3 = 1024,

155

};

155

};

156

157

/* ND options */

157

/* ND options */

158

struct ndisc_options {

158

struct ndisc_options {

159

struct nd_opt_hdr *nd_opt_array[__ND_OPT_MAX];

159

struct nd_opt_hdr *nd_opt_array[__ND_OPT_MAX];

160

};

160

};

161

162

#define nd_opts_src_lladdr nd_opt_array[ND_OPT_SOURCE_LL_ADDR]

162

#define nd_opts_src_lladdr nd_opt_array[ND_OPT_SOURCE_LL_ADDR]

163

#define nd_opts_tgt_lladdr nd_opt_array[ND_OPT_TARGET_LL_ADDR]

163

#define nd_opts_tgt_lladdr nd_opt_array[ND_OPT_TARGET_LL_ADDR]

164

#define nd_opts_pi nd_opt_array[ND_OPT_PREFIX_INFO]

164

#define nd_opts_pi nd_opt_array[ND_OPT_PREFIX_INFO]

165

#define nd_opts_pi_end nd_opt_array[__ND_OPT_PREFIX_INFO_END]

165

#define nd_opts_pi_end nd_opt_array[__ND_OPT_PREFIX_INFO_END]

166

#define nd_opts_rh nd_opt_array[ND_OPT_REDIRECT_HDR]

166

#define nd_opts_rh nd_opt_array[ND_OPT_REDIRECT_HDR]

167

#define nd_opts_mtu nd_opt_array[ND_OPT_MTU]

167

#define nd_opts_mtu nd_opt_array[ND_OPT_MTU]

168

169

#define NDISC_OPT_SPACE(len) (((len)+2+7)&~7)

169

#define NDISC_OPT_SPACE(len) (((len)+2+7)&~7)

170

171

/*

171

/*

172

* Return the padding between the option length and the start of the

172

* Return the padding between the option length and the start of the

173

* link addr. Currently only IP-over-InfiniBand needs this, although

173

* link addr. Currently only IP-over-InfiniBand needs this, although

174

* if RFC 3831 IPv6-over-Fibre Channel is ever implemented it may

174

* if RFC 3831 IPv6-over-Fibre Channel is ever implemented it may

175

* also need a pad of 2.

175

* also need a pad of 2.

176

*/

176

*/

177

static int ndisc_addr_option_pad(unsigned short type)

177

static int ndisc_addr_option_pad(unsigned short type)

178

{

178

{

179

switch (type) {

179

switch (type) {

180

case ARPHRD_INFINIBAND: return 2;

180

case ARPHRD_INFINIBAND: return 2;

181

default: return 0;

181

default: return 0;

182

}

182

}

183

}

183

}

184

185

static inline int ndisc_opt_addr_space(struct net_device *dev)

185

static inline int ndisc_opt_addr_space(struct net_device *dev)

186

{

186

{

187

return NDISC_OPT_SPACE(dev->addr_len + ndisc_addr_option_pad(dev->type));

187

return NDISC_OPT_SPACE(dev->addr_len + ndisc_addr_option_pad(dev->type));

188

}

188

}

189

190

static u8 *ndisc_fill_addr_option(u8 *opt, int type, void *data, int data_len,

190

static u8 *ndisc_fill_addr_option(u8 *opt, int type, void *data, int data_len,

191

unsigned short addr_type)

191

unsigned short addr_type)

192

{

192

{

193

int space = NDISC_OPT_SPACE(data_len);

193

int space = NDISC_OPT_SPACE(data_len);

194

int pad = ndisc_addr_option_pad(addr_type);

194

int pad = ndisc_addr_option_pad(addr_type);

195

196

opt[0] = type;

196

opt[0] = type;

197

opt[1] = space>>3;

197

opt[1] = space>>3;

198

199

memset(opt + 2, 0, pad);

199

memset(opt + 2, 0, pad);

200

opt += pad;

200

opt += pad;

201

space -= pad;

201

space -= pad;

202

203

memcpy(opt+2, data, data_len);

203

memcpy(opt+2, data, data_len);

204

data_len += 2;

204

data_len += 2;

205

opt += data_len;

205

opt += data_len;

206

if ((space -= data_len) > 0)

206

if ((space -= data_len) > 0)

207

memset(opt, 0, space);

207

memset(opt, 0, space);

208

return opt + space;

208

return opt + space;

209

}

209

}

210

211

static struct nd_opt_hdr *ndisc_next_option(struct nd_opt_hdr *cur,

211

static struct nd_opt_hdr *ndisc_next_option(struct nd_opt_hdr *cur,

212

struct nd_opt_hdr *end)

212

struct nd_opt_hdr *end)

213

{

213

{

214

int type;

214

int type;

215

if (!cur || !end || cur >= end)

215

if (!cur || !end || cur >= end)

216

return NULL;

216

return NULL;

217

type = cur->nd_opt_type;

217

type = cur->nd_opt_type;

218

do {

218

do {

219

cur = ((void *)cur) + (cur->nd_opt_len << 3);

219

cur = ((void *)cur) + (cur->nd_opt_len << 3);

220

} while(cur < end && cur->nd_opt_type != type);

220

} while(cur < end && cur->nd_opt_type != type);

221

return (cur <= end && cur->nd_opt_type == type ? cur : NULL);

221

return (cur <= end && cur->nd_opt_type == type ? cur : NULL);

222

}

222

}

223

224

static struct ndisc_options *ndisc_parse_options(u8 *opt, int opt_len,

224

static struct ndisc_options *ndisc_parse_options(u8 *opt, int opt_len,

225

struct ndisc_options *ndopts)

225

struct ndisc_options *ndopts)

226

{

226

{

227

struct nd_opt_hdr *nd_opt = (struct nd_opt_hdr *)opt;

227

struct nd_opt_hdr *nd_opt = (struct nd_opt_hdr *)opt;

228

229

if (!nd_opt || opt_len < 0 || !ndopts)

229

if (!nd_opt || opt_len < 0 || !ndopts)

230

return NULL;

230

return NULL;

231

memset(ndopts, 0, sizeof(*ndopts));

231

memset(ndopts, 0, sizeof(*ndopts));

232

while (opt_len) {

232

while (opt_len) {

233

int l;

233

int l;

234

if (opt_len < sizeof(struct nd_opt_hdr))

234

if (opt_len < sizeof(struct nd_opt_hdr))

235

return NULL;

235

return NULL;

236

l = nd_opt->nd_opt_len << 3;

236

l = nd_opt->nd_opt_len << 3;

237

if (opt_len < l || l == 0)

237

if (opt_len < l || l == 0)

238

return NULL;

238

return NULL;

239

switch (nd_opt->nd_opt_type) {

239

switch (nd_opt->nd_opt_type) {

240

case ND_OPT_SOURCE_LL_ADDR:

240

case ND_OPT_SOURCE_LL_ADDR:

241

case ND_OPT_TARGET_LL_ADDR:

241

case ND_OPT_TARGET_LL_ADDR:

242

case ND_OPT_MTU:

242

case ND_OPT_MTU:

243

case ND_OPT_REDIRECT_HDR:

243

case ND_OPT_REDIRECT_HDR:

244

if (ndopts->nd_opt_array[nd_opt->nd_opt_type]) {

244

if (ndopts->nd_opt_array[nd_opt->nd_opt_type]) {

245

ND_PRINTK2(KERN_WARNING

245

ND_PRINTK2(KERN_WARNING

246

"%s(): duplicated ND6 option found: type=%d\n",

246

"%s(): duplicated ND6 option found: type=%d\n",

247

__FUNCTION__,

247

__FUNCTION__,

248

nd_opt->nd_opt_type);

248

nd_opt->nd_opt_type);

249

} else {

249

} else {

250

ndopts->nd_opt_array[nd_opt->nd_opt_type] = nd_opt;

250

ndopts->nd_opt_array[nd_opt->nd_opt_type] = nd_opt;

251

}

251

}

252

break;

252

break;

253

case ND_OPT_PREFIX_INFO:

253

case ND_OPT_PREFIX_INFO:

254

ndopts->nd_opts_pi_end = nd_opt;

254

ndopts->nd_opts_pi_end = nd_opt;

255

if (ndopts->nd_opt_array[nd_opt->nd_opt_type] == 0)

255

if (ndopts->nd_opt_array[nd_opt->nd_opt_type] == 0)

256

ndopts->nd_opt_array[nd_opt->nd_opt_type] = nd_opt;

256

ndopts->nd_opt_array[nd_opt->nd_opt_type] = nd_opt;

257

break;

257

break;

258

default:

258

default:

259

/*

259

/*

260

* Unknown options must be silently ignored,

260

* Unknown options must be silently ignored,

261

* to accommodate future extension to the protocol.

261

* to accommodate future extension to the protocol.

262

*/

262

*/

263

ND_PRINTK2(KERN_NOTICE

263

ND_PRINTK2(KERN_NOTICE

264

"%s(): ignored unsupported option; type=%d, len=%d\n",

264

"%s(): ignored unsupported option; type=%d, len=%d\n",

265

__FUNCTION__,

265

__FUNCTION__,

266

nd_opt->nd_opt_type, nd_opt->nd_opt_len);

266

nd_opt->nd_opt_type, nd_opt->nd_opt_len);

267

}

267

}

268

opt_len -= l;

268

opt_len -= l;

269

nd_opt = ((void *)nd_opt) + l;

269

nd_opt = ((void *)nd_opt) + l;

270

}

270

}

271

return ndopts;

271

return ndopts;

272

}

272

}

273

274

static inline u8 *ndisc_opt_addr_data(struct nd_opt_hdr *p,

274

static inline u8 *ndisc_opt_addr_data(struct nd_opt_hdr *p,

275

struct net_device *dev)

275

struct net_device *dev)

276

{

276

{

277

u8 *lladdr = (u8 *)(p + 1);

277

u8 *lladdr = (u8 *)(p + 1);

278

int lladdrlen = p->nd_opt_len << 3;

278

int lladdrlen = p->nd_opt_len << 3;

279

int prepad = ndisc_addr_option_pad(dev->type);

279

int prepad = ndisc_addr_option_pad(dev->type);

280

if (lladdrlen != NDISC_OPT_SPACE(dev->addr_len + prepad))

280

if (lladdrlen != NDISC_OPT_SPACE(dev->addr_len + prepad))

281

return NULL;

281

return NULL;

282

return (lladdr + prepad);

282

return (lladdr + prepad);

283

}

283

}

284

285

int ndisc_mc_map(struct in6_addr *addr, char *buf, struct net_device *dev, int dir)

285

int ndisc_mc_map(struct in6_addr *addr, char *buf, struct net_device *dev, int dir)

286

{

286

{

287

switch (dev->type) {

287

switch (dev->type) {

288

case ARPHRD_ETHER:

288

case ARPHRD_ETHER:

289

case ARPHRD_IEEE802: /* Not sure. Check it later. --ANK */

289

case ARPHRD_IEEE802: /* Not sure. Check it later. --ANK */

290

case ARPHRD_FDDI:

290

case ARPHRD_FDDI:

291

ipv6_eth_mc_map(addr, buf);

291

ipv6_eth_mc_map(addr, buf);

292

return 0;

292

return 0;

293

case ARPHRD_IEEE802_TR:

293

case ARPHRD_IEEE802_TR:

294

ipv6_tr_mc_map(addr,buf);

294

ipv6_tr_mc_map(addr,buf);

295

return 0;

295

return 0;

296

case ARPHRD_ARCNET:

296

case ARPHRD_ARCNET:

297

ipv6_arcnet_mc_map(addr, buf);

297

ipv6_arcnet_mc_map(addr, buf);

298

return 0;

298

return 0;

299

case ARPHRD_INFINIBAND:

299

case ARPHRD_INFINIBAND:

300

ipv6_ib_mc_map(addr, buf);

300

ipv6_ib_mc_map(addr, buf);

301

return 0;

301

return 0;

302

default:

302

default:

303

if (dir) {

303

if (dir) {

304

memcpy(buf, dev->broadcast, dev->addr_len);

304

memcpy(buf, dev->broadcast, dev->addr_len);

305

return 0;

305

return 0;

306

}

306

}

307

}

307

}

308

return -EINVAL;

308

return -EINVAL;

309

}

309

}

310

311

static u32 ndisc_hash(const void *pkey, const struct net_device *dev)

311

static u32 ndisc_hash(const void *pkey, const struct net_device *dev)

312

{

312

{

313

const u32 *p32 = pkey;

313

const u32 *p32 = pkey;

314

u32 addr_hash, i;

314

u32 addr_hash, i;

315

316

addr_hash = 0;

316

addr_hash = 0;

317

for (i = 0; i < (sizeof(struct in6_addr) / sizeof(u32)); i++)

317

for (i = 0; i < (sizeof(struct in6_addr) / sizeof(u32)); i++)

318

addr_hash ^= *p32++;

318

addr_hash ^= *p32++;

319

320

return jhash_2words(addr_hash, dev->ifindex, nd_tbl.hash_rnd);

320

return jhash_2words(addr_hash, dev->ifindex, nd_tbl.hash_rnd);

321

}

321

}

322

323

static int ndisc_constructor(struct neighbour *neigh)

323

static int ndisc_constructor(struct neighbour *neigh)

324

{

324

{

325

struct in6_addr *addr = (struct in6_addr*)&neigh->primary_key;

325

struct in6_addr *addr = (struct in6_addr*)&neigh->primary_key;

326

struct net_device *dev = neigh->dev;

326

struct net_device *dev = neigh->dev;

327

struct inet6_dev *in6_dev;

327

struct inet6_dev *in6_dev;

328

struct neigh_parms *parms;

328

struct neigh_parms *parms;

329

int is_multicast = ipv6_addr_is_multicast(addr);

329

int is_multicast = ipv6_addr_is_multicast(addr);

330

331

rcu_read_lock();

331

rcu_read_lock();

332

in6_dev = in6_dev_get(dev);

332

in6_dev = in6_dev_get(dev);

333

if (in6_dev == NULL) {

333

if (in6_dev == NULL) {

334

rcu_read_unlock();

334

rcu_read_unlock();

335

return -EINVAL;

335

return -EINVAL;

336

}

336

}

337

338

parms = in6_dev->nd_parms;

338

parms = in6_dev->nd_parms;

339

__neigh_parms_put(neigh->parms);

339

__neigh_parms_put(neigh->parms);

340

neigh->parms = neigh_parms_clone(parms);

340

neigh->parms = neigh_parms_clone(parms);

341

rcu_read_unlock();

341

rcu_read_unlock();

342

343

neigh->type = is_multicast ? RTN_MULTICAST : RTN_UNICAST;

343

neigh->type = is_multicast ? RTN_MULTICAST : RTN_UNICAST;

344

if (dev->hard_header == NULL) {

344

if (dev->hard_header == NULL) {

345

neigh->nud_state = NUD_NOARP;

345

neigh->nud_state = NUD_NOARP;

346

neigh->ops = &ndisc_direct_ops;

346

neigh->ops = &ndisc_direct_ops;

347

neigh->output = neigh->ops->queue_xmit;

347

neigh->output = neigh->ops->queue_xmit;

348

} else {

348

} else {

349

if (is_multicast) {

349

if (is_multicast) {

350

neigh->nud_state = NUD_NOARP;

350

neigh->nud_state = NUD_NOARP;

351

ndisc_mc_map(addr, neigh->ha, dev, 1);

351

ndisc_mc_map(addr, neigh->ha, dev, 1);

352

} else if (dev->flags&(IFF_NOARP|IFF_LOOPBACK)) {

352

} else if (dev->flags&(IFF_NOARP|IFF_LOOPBACK)) {

353

neigh->nud_state = NUD_NOARP;

353

neigh->nud_state = NUD_NOARP;

354

memcpy(neigh->ha, dev->dev_addr, dev->addr_len);

354

memcpy(neigh->ha, dev->dev_addr, dev->addr_len);

355

if (dev->flags&IFF_LOOPBACK)

355

if (dev->flags&IFF_LOOPBACK)

356

neigh->type = RTN_LOCAL;

356

neigh->type = RTN_LOCAL;

357

} else if (dev->flags&IFF_POINTOPOINT) {

357

} else if (dev->flags&IFF_POINTOPOINT) {

358

neigh->nud_state = NUD_NOARP;

358

neigh->nud_state = NUD_NOARP;

359

memcpy(neigh->ha, dev->broadcast, dev->addr_len);

359

memcpy(neigh->ha, dev->broadcast, dev->addr_len);

360

}

360

}

361

if (dev->hard_header_cache)

361

if (dev->hard_header_cache)

362

neigh->ops = &ndisc_hh_ops;

362

neigh->ops = &ndisc_hh_ops;

363

else

363

else

364

neigh->ops = &ndisc_generic_ops;

364

neigh->ops = &ndisc_generic_ops;

365

if (neigh->nud_state&NUD_VALID)

365

if (neigh->nud_state&NUD_VALID)

366

neigh->output = neigh->ops->connected_output;

366

neigh->output = neigh->ops->connected_output;

367

else

367

else

368

neigh->output = neigh->ops->output;

368

neigh->output = neigh->ops->output;

369

}

369

}

370

in6_dev_put(in6_dev);

370

in6_dev_put(in6_dev);

371

return 0;

371

return 0;

372

}

372

}

373

374

static int pndisc_constructor(struct pneigh_entry *n)

374

static int pndisc_constructor(struct pneigh_entry *n)

375

{

375

{

376

struct in6_addr *addr = (struct in6_addr*)&n->key;

376

struct in6_addr *addr = (struct in6_addr*)&n->key;

377

struct in6_addr maddr;

377

struct in6_addr maddr;

378

struct net_device *dev = n->dev;

378

struct net_device *dev = n->dev;

379

380

if (dev == NULL || __in6_dev_get(dev) == NULL)

380

if (dev == NULL || __in6_dev_get(dev) == NULL)

381

return -EINVAL;

381

return -EINVAL;

382

addrconf_addr_solict_mult(addr, &maddr);

382

addrconf_addr_solict_mult(addr, &maddr);

383

ipv6_dev_mc_inc(dev, &maddr);

383

ipv6_dev_mc_inc(dev, &maddr);

384

return 0;

384

return 0;

385

}

385

}

386

387

static void pndisc_destructor(struct pneigh_entry *n)

387

static void pndisc_destructor(struct pneigh_entry *n)

388

{

388

{

389

struct in6_addr *addr = (struct in6_addr*)&n->key;

389

struct in6_addr *addr = (struct in6_addr*)&n->key;

390

struct in6_addr maddr;

390

struct in6_addr maddr;

391

struct net_device *dev = n->dev;

391

struct net_device *dev = n->dev;

392

393

if (dev == NULL || __in6_dev_get(dev) == NULL)

393

if (dev == NULL || __in6_dev_get(dev) == NULL)

394

return;

394

return;

395

addrconf_addr_solict_mult(addr, &maddr);

395

addrconf_addr_solict_mult(addr, &maddr);

396

ipv6_dev_mc_dec(dev, &maddr);

396

ipv6_dev_mc_dec(dev, &maddr);

397

}

397

}

398

399

/*

399

/*

400

* Send a Neighbour Advertisement

400

* Send a Neighbour Advertisement

401

*/

401

*/

402

403

static inline void ndisc_flow_init(struct flowi *fl, u8 type,

403

static inline void ndisc_flow_init(struct flowi *fl, u8 type,

404

struct in6_addr *saddr, struct in6_addr *daddr)

404

struct in6_addr *saddr, struct in6_addr *daddr)

405

{

405

{

406

memset(fl, 0, sizeof(*fl));

406

memset(fl, 0, sizeof(*fl));

407

ipv6_addr_copy(&fl->fl6_src, saddr);

407

ipv6_addr_copy(&fl->fl6_src, saddr);

408

ipv6_addr_copy(&fl->fl6_dst, daddr);

408

ipv6_addr_copy(&fl->fl6_dst, daddr);

409

fl->proto = IPPROTO_ICMPV6;

409

fl->proto = IPPROTO_ICMPV6;

410

fl->fl_icmp_type = type;

410

fl->fl_icmp_type = type;

411

fl->fl_icmp_code = 0;

411

fl->fl_icmp_code = 0;

412

}

412

}

413

414

static void ndisc_send_na(struct net_device *dev, struct neighbour *neigh,

414

static void ndisc_send_na(struct net_device *dev, struct neighbour *neigh,

415

struct in6_addr *daddr, struct in6_addr *solicited_addr,

415

struct in6_addr *daddr, struct in6_addr *solicited_addr,

416

int router, int solicited, int override, int inc_opt)

416

int router, int solicited, int override, int inc_opt)

417

{

417

{

418

struct in6_addr tmpaddr;

418

struct in6_addr tmpaddr;

419

struct inet6_ifaddr *ifp;

419

struct inet6_ifaddr *ifp;

420

struct inet6_dev *idev;

420

struct inet6_dev *idev;

421

struct flowi fl;

421

struct flowi fl;

422

struct dst_entry* dst;

422

struct dst_entry* dst;

423

struct sock *sk = ndisc_socket->sk;

423

struct sock *sk = ndisc_socket->sk;

424

struct in6_addr *src_addr;

424

struct in6_addr *src_addr;

425

struct nd_msg *msg;

425

struct nd_msg *msg;

426

int len;

426

int len;

427

struct sk_buff *skb;

427

struct sk_buff *skb;

428

int err;

428

int err;

429

430

len = sizeof(struct icmp6hdr) + sizeof(struct in6_addr);

430

len = sizeof(struct icmp6hdr) + sizeof(struct in6_addr);

431

432

/* for anycast or proxy, solicited_addr != src_addr */

432

/* for anycast or proxy, solicited_addr != src_addr */

433

ifp = ipv6_get_ifaddr(solicited_addr, dev, 1);

433

ifp = ipv6_get_ifaddr(solicited_addr, dev, 1);

434

if (ifp) {

434

if (ifp) {

435

src_addr = solicited_addr;

435

src_addr = solicited_addr;

436

in6_ifa_put(ifp);

436

in6_ifa_put(ifp);

437

} else {

437

} else {

438

if (ipv6_dev_get_saddr(dev, daddr, &tmpaddr))

438

if (ipv6_dev_get_saddr(dev, daddr, &tmpaddr))

439

return;

439

return;

440

src_addr = &tmpaddr;

440

src_addr = &tmpaddr;

441

}

441

}

442

443

ndisc_flow_init(&fl, NDISC_NEIGHBOUR_ADVERTISEMENT, src_addr, daddr);

443

ndisc_flow_init(&fl, NDISC_NEIGHBOUR_ADVERTISEMENT, src_addr, daddr);

444

445

dst = ndisc_dst_alloc(dev, neigh, daddr, ip6_output);

445

dst = ndisc_dst_alloc(dev, neigh, daddr, ip6_output);

446

if (!dst)

446

if (!dst)

447

return;

447

return;

448

449

err = xfrm_lookup(&dst, &fl, NULL, 0);

449

err = xfrm_lookup(&dst, &fl, NULL, 0);

450

if (err < 0)

450

if (err < 0)

451

return;

451

return;

452

453

if (inc_opt) {

453

if (inc_opt) {

454

if (dev->addr_len)

454

if (dev->addr_len)

455

len += ndisc_opt_addr_space(dev);

455

len += ndisc_opt_addr_space(dev);

456

else

456

else

457

inc_opt = 0;

457

inc_opt = 0;

458

}

458

}

459

460

skb = sock_alloc_send_skb(sk, MAX_HEADER + len + LL_RESERVED_SPACE(dev),

460

skb = sock_alloc_send_skb(sk, MAX_HEADER + len + LL_RESERVED_SPACE(dev),

461

1, &err);

461

1, &err);

462

463

if (skb == NULL) {

463

if (skb == NULL) {

464

ND_PRINTK0(KERN_ERR

464

ND_PRINTK0(KERN_ERR

465

"ICMPv6 NA: %s() failed to allocate an skb.\n",

465

"ICMPv6 NA: %s() failed to allocate an skb.\n",

466

__FUNCTION__);

466

__FUNCTION__);

467

dst_release(dst);

467

dst_release(dst);

468

return;

468

return;

469

}

469

}

470

471

skb_reserve(skb, LL_RESERVED_SPACE(dev));

471

skb_reserve(skb, LL_RESERVED_SPACE(dev));

472

ip6_nd_hdr(sk, skb, dev, src_addr, daddr, IPPROTO_ICMPV6, len);

472

ip6_nd_hdr(sk, skb, dev, src_addr, daddr, IPPROTO_ICMPV6, len);

473

474

msg = (struct nd_msg *)skb_put(skb, len);

474

msg = (struct nd_msg *)skb_put(skb, len);

475

skb->h.raw = (unsigned char*)msg;

475

skb->h.raw = (unsigned char*)msg;

476

477

msg->icmph.icmp6_type = NDISC_NEIGHBOUR_ADVERTISEMENT;

477

msg->icmph.icmp6_type = NDISC_NEIGHBOUR_ADVERTISEMENT;

478

msg->icmph.icmp6_code = 0;

478

msg->icmph.icmp6_code = 0;

479

msg->icmph.icmp6_cksum = 0;

479

msg->icmph.icmp6_cksum = 0;

480

481

msg->icmph.icmp6_unused = 0;

481

msg->icmph.icmp6_unused = 0;

482

msg->icmph.icmp6_router = router;

482

msg->icmph.icmp6_router = router;

483

msg->icmph.icmp6_solicited = solicited;

483

msg->icmph.icmp6_solicited = solicited;

484

msg->icmph.icmp6_override = !!override;

484

msg->icmph.icmp6_override = !!override;

485

486

/* Set the target address. */

486

/* Set the target address. */

487

ipv6_addr_copy(&msg->target, solicited_addr);

487

ipv6_addr_copy(&msg->target, solicited_addr);

488

489

if (inc_opt)

489

if (inc_opt)

490

ndisc_fill_addr_option(msg->opt, ND_OPT_TARGET_LL_ADDR, dev->dev_addr,

490

ndisc_fill_addr_option(msg->opt, ND_OPT_TARGET_LL_ADDR, dev->dev_addr,

491

dev->addr_len, dev->type);

491

dev->addr_len, dev->type);

492

493

/* checksum */

493

/* checksum */

494

msg->icmph.icmp6_cksum = csum_ipv6_magic(src_addr, daddr, len,

494

msg->icmph.icmp6_cksum = csum_ipv6_magic(src_addr, daddr, len,

495

IPPROTO_ICMPV6,

495

IPPROTO_ICMPV6,

496

csum_partial((__u8 *) msg,

496

csum_partial((__u8 *) msg,

497

len, 0));

497

len, 0));

498

499

skb->dst = dst;

499

skb->dst = dst;

500

idev = in6_dev_get(dst->dev);

500

idev = in6_dev_get(dst->dev);

501

IP6_INC_STATS(IPSTATS_MIB_OUTREQUESTS);

501

IP6_INC_STATS(IPSTATS_MIB_OUTREQUESTS);

502

err = NF_HOOK(PF_INET6, NF_IP6_LOCAL_OUT, skb, NULL, dst->dev, dst_output);

502

err = NF_HOOK(PF_INET6, NF_IP6_LOCAL_OUT, skb, NULL, dst->dev, dst_output);

503

if (!err) {

503

if (!err) {

504

ICMP6_INC_STATS(idev, ICMP6_MIB_OUTNEIGHBORADVERTISEMENTS);

504

ICMP6_INC_STATS(idev, ICMP6_MIB_OUTNEIGHBORADVERTISEMENTS);

505

ICMP6_INC_STATS(idev, ICMP6_MIB_OUTMSGS);

505

ICMP6_INC_STATS(idev, ICMP6_MIB_OUTMSGS);

506

}

506

}

507

508

if (likely(idev != NULL))

508

if (likely(idev != NULL))

509

in6_dev_put(idev);

509

in6_dev_put(idev);

510

}

510

}

511

512

void ndisc_send_ns(struct net_device *dev, struct neighbour *neigh,

512

void ndisc_send_ns(struct net_device *dev, struct neighbour *neigh,

513

struct in6_addr *solicit,

513

struct in6_addr *solicit,

514

struct in6_addr *daddr, struct in6_addr *saddr)

514

struct in6_addr *daddr, struct in6_addr *saddr)

515

{

515

{

516

struct flowi fl;

516

struct flowi fl;

517

struct dst_entry* dst;

517

struct dst_entry* dst;

518

struct inet6_dev *idev;

518

struct inet6_dev *idev;

519

struct sock *sk = ndisc_socket->sk;

519

struct sock *sk = ndisc_socket->sk;

520

struct sk_buff *skb;

520

struct sk_buff *skb;

521

struct nd_msg *msg;

521

struct nd_msg *msg;

522

struct in6_addr addr_buf;

522

struct in6_addr addr_buf;

523

int len;

523

int len;

524

int err;

524

int err;

525

int send_llinfo;

525

int send_llinfo;

526

527

if (saddr == NULL) {

527

if (saddr == NULL) {

528

if (ipv6_get_lladdr(dev, &addr_buf))

528

if (ipv6_get_lladdr(dev, &addr_buf))

529

return;

529

return;

530

saddr = &addr_buf;

530

saddr = &addr_buf;

531

}

531

}

532

533

ndisc_flow_init(&fl, NDISC_NEIGHBOUR_SOLICITATION, saddr, daddr);

533

ndisc_flow_init(&fl, NDISC_NEIGHBOUR_SOLICITATION, saddr, daddr);

534

535

dst = ndisc_dst_alloc(dev, neigh, daddr, ip6_output);

535

dst = ndisc_dst_alloc(dev, neigh, daddr, ip6_output);

536

if (!dst)

536

if (!dst)

537

return;

537

return;

538

539

err = xfrm_lookup(&dst, &fl, NULL, 0);

539

err = xfrm_lookup(&dst, &fl, NULL, 0);

540

if (err < 0)

540

if (err < 0)

541

return;

541

return;

542

543

len = sizeof(struct icmp6hdr) + sizeof(struct in6_addr);

543

len = sizeof(struct icmp6hdr) + sizeof(struct in6_addr);

544

send_llinfo = dev->addr_len && !ipv6_addr_any(saddr);

544

send_llinfo = dev->addr_len && !ipv6_addr_any(saddr);

545

if (send_llinfo)

545

if (send_llinfo)

546

len += ndisc_opt_addr_space(dev);

546

len += ndisc_opt_addr_space(dev);

547

548

skb = sock_alloc_send_skb(sk, MAX_HEADER + len + LL_RESERVED_SPACE(dev),

548

skb = sock_alloc_send_skb(sk, MAX_HEADER + len + LL_RESERVED_SPACE(dev),

549

1, &err);

549

1, &err);

550

if (skb == NULL) {

550

if (skb == NULL) {

551

ND_PRINTK0(KERN_ERR

551

ND_PRINTK0(KERN_ERR

552

"ICMPv6 NA: %s() failed to allocate an skb.\n",

552

"ICMPv6 NA: %s() failed to allocate an skb.\n",

553

__FUNCTION__);

553

__FUNCTION__);

554

dst_release(dst);

554

dst_release(dst);

555

return;

555

return;

556

}

556

}

557

558

skb_reserve(skb, LL_RESERVED_SPACE(dev));

558

skb_reserve(skb, LL_RESERVED_SPACE(dev));

559

ip6_nd_hdr(sk, skb, dev, saddr, daddr, IPPROTO_ICMPV6, len);

559

ip6_nd_hdr(sk, skb, dev, saddr, daddr, IPPROTO_ICMPV6, len);

560

561

msg = (struct nd_msg *)skb_put(skb, len);

561

msg = (struct nd_msg *)skb_put(skb, len);

562

skb->h.raw = (unsigned char*)msg;

562

skb->h.raw = (unsigned char*)msg;

563

msg->icmph.icmp6_type = NDISC_NEIGHBOUR_SOLICITATION;

563

msg->icmph.icmp6_type = NDISC_NEIGHBOUR_SOLICITATION;

564

msg->icmph.icmp6_code = 0;

564

msg->icmph.icmp6_code = 0;

565

msg->icmph.icmp6_cksum = 0;

565

msg->icmph.icmp6_cksum = 0;

566

msg->icmph.icmp6_unused = 0;

566

msg->icmph.icmp6_unused = 0;

567

568

/* Set the target address. */

568

/* Set the target address. */

569

ipv6_addr_copy(&msg->target, solicit);

569

ipv6_addr_copy(&msg->target, solicit);

570

571

if (send_llinfo)

571

if (send_llinfo)

572

ndisc_fill_addr_option(msg->opt, ND_OPT_SOURCE_LL_ADDR, dev->dev_addr,

572

ndisc_fill_addr_option(msg->opt, ND_OPT_SOURCE_LL_ADDR, dev->dev_addr,

573

dev->addr_len, dev->type);

573

dev->addr_len, dev->type);

574

575

/* checksum */

575

/* checksum */

576

msg->icmph.icmp6_cksum = csum_ipv6_magic(&skb->nh.ipv6h->saddr,

576

msg->icmph.icmp6_cksum = csum_ipv6_magic(&skb->nh.ipv6h->saddr,

577

daddr, len,

577

daddr, len,

578

IPPROTO_ICMPV6,

578

IPPROTO_ICMPV6,

579

csum_partial((__u8 *) msg,

579

csum_partial((__u8 *) msg,

580

len, 0));

580

len, 0));

581

/* send it! */

581

/* send it! */

582

skb->dst = dst;

582

skb->dst = dst;

583

idev = in6_dev_get(dst->dev);

583

idev = in6_dev_get(dst->dev);

584

IP6_INC_STATS(IPSTATS_MIB_OUTREQUESTS);

584

IP6_INC_STATS(IPSTATS_MIB_OUTREQUESTS);

585

err = NF_HOOK(PF_INET6, NF_IP6_LOCAL_OUT, skb, NULL, dst->dev, dst_output);

585

err = NF_HOOK(PF_INET6, NF_IP6_LOCAL_OUT, skb, NULL, dst->dev, dst_output);

586

if (!err) {

586

if (!err) {

587

ICMP6_INC_STATS(idev, ICMP6_MIB_OUTNEIGHBORSOLICITS);

587

ICMP6_INC_STATS(idev, ICMP6_MIB_OUTNEIGHBORSOLICITS);

588

ICMP6_INC_STATS(idev, ICMP6_MIB_OUTMSGS);

588

ICMP6_INC_STATS(idev, ICMP6_MIB_OUTMSGS);

589

}

589

}

590

591

if (likely(idev != NULL))

591

if (likely(idev != NULL))

592

in6_dev_put(idev);

592

in6_dev_put(idev);

593

}

593

}

594

595

void ndisc_send_rs(struct net_device *dev, struct in6_addr *saddr,

595

void ndisc_send_rs(struct net_device *dev, struct in6_addr *saddr,

596

struct in6_addr *daddr)

596

struct in6_addr *daddr)

597

{

597

{

598

struct flowi fl;

598

struct flowi fl;

599

struct dst_entry* dst;

599

struct dst_entry* dst;

600

struct inet6_dev *idev;

600

struct inet6_dev *idev;

601

struct sock *sk = ndisc_socket->sk;

601

struct sock *sk = ndisc_socket->sk;

602

struct sk_buff *skb;

602

struct sk_buff *skb;

603

struct icmp6hdr *hdr;

603

struct icmp6hdr *hdr;

604

__u8 * opt;

604

__u8 * opt;

605

int len;

605

int len;

606

int err;

606

int err;

607

608

ndisc_flow_init(&fl, NDISC_ROUTER_SOLICITATION, saddr, daddr);

608

ndisc_flow_init(&fl, NDISC_ROUTER_SOLICITATION, saddr, daddr);

609

610

dst = ndisc_dst_alloc(dev, NULL, daddr, ip6_output);

610

dst = ndisc_dst_alloc(dev, NULL, daddr, ip6_output);

611

if (!dst)

611

if (!dst)

612

return;

612

return;

613

614

err = xfrm_lookup(&dst, &fl, NULL, 0);

614

err = xfrm_lookup(&dst, &fl, NULL, 0);

615

if (err < 0)

615

if (err < 0)

616

return;

616

return;

617

618

len = sizeof(struct icmp6hdr);

618

len = sizeof(struct icmp6hdr);

619

if (dev->addr_len)

619

if (dev->addr_len)

620

len += ndisc_opt_addr_space(dev);

620

len += ndisc_opt_addr_space(dev);

621

622

skb = sock_alloc_send_skb(sk, MAX_HEADER + len + LL_RESERVED_SPACE(dev),

622

skb = sock_alloc_send_skb(sk, MAX_HEADER + len + LL_RESERVED_SPACE(dev),

623

1, &err);

623

1, &err);

624

if (skb == NULL) {

624

if (skb == NULL) {

625

ND_PRINTK0(KERN_ERR

625

ND_PRINTK0(KERN_ERR

626

"ICMPv6 RS: %s() failed to allocate an skb.\n",

626

"ICMPv6 RS: %s() failed to allocate an skb.\n",

627

__FUNCTION__);

627

__FUNCTION__);

628

dst_release(dst);

628

dst_release(dst);

629

return;

629

return;

630

}

630

}

631

632

skb_reserve(skb, LL_RESERVED_SPACE(dev));

632

skb_reserve(skb, LL_RESERVED_SPACE(dev));

633

ip6_nd_hdr(sk, skb, dev, saddr, daddr, IPPROTO_ICMPV6, len);

633

ip6_nd_hdr(sk, skb, dev, saddr, daddr, IPPROTO_ICMPV6, len);

634

635

hdr = (struct icmp6hdr *)skb_put(skb, len);

635

hdr = (struct icmp6hdr *)skb_put(skb, len);

636

skb->h.raw = (unsigned char*)hdr;

636

skb->h.raw = (unsigned char*)hdr;

637

hdr->icmp6_type = NDISC_ROUTER_SOLICITATION;

637

hdr->icmp6_type = NDISC_ROUTER_SOLICITATION;

638

hdr->icmp6_code = 0;

638

hdr->icmp6_code = 0;

639

hdr->icmp6_cksum = 0;

639

hdr->icmp6_cksum = 0;

640

hdr->icmp6_unused = 0;

640

hdr->icmp6_unused = 0;

641

642

opt = (u8*) (hdr + 1);

642

opt = (u8*) (hdr + 1);

643

644

if (dev->addr_len)

644

if (dev->addr_len)

645

ndisc_fill_addr_option(opt, ND_OPT_SOURCE_LL_ADDR, dev->dev_addr,

645

ndisc_fill_addr_option(opt, ND_OPT_SOURCE_LL_ADDR, dev->dev_addr,

646

dev->addr_len, dev->type);

646

dev->addr_len, dev->type);

647

648

/* checksum */

648

/* checksum */

649

hdr->icmp6_cksum = csum_ipv6_magic(&skb->nh.ipv6h->saddr, daddr, len,

649

hdr->icmp6_cksum = csum_ipv6_magic(&skb->nh.ipv6h->saddr, daddr, len,

650

IPPROTO_ICMPV6,

650

IPPROTO_ICMPV6,

651

csum_partial((__u8 *) hdr, len, 0));

651

csum_partial((__u8 *) hdr, len, 0));

652

653

/* send it! */

653

/* send it! */

654

skb->dst = dst;

654

skb->dst = dst;

655

idev = in6_dev_get(dst->dev);

655

idev = in6_dev_get(dst->dev);

656

IP6_INC_STATS(IPSTATS_MIB_OUTREQUESTS);

656

IP6_INC_STATS(IPSTATS_MIB_OUTREQUESTS);

657

err = NF_HOOK(PF_INET6, NF_IP6_LOCAL_OUT, skb, NULL, dst->dev, dst_output);

657

err = NF_HOOK(PF_INET6, NF_IP6_LOCAL_OUT, skb, NULL, dst->dev, dst_output);

658

if (!err) {

658

if (!err) {

659

ICMP6_INC_STATS(idev, ICMP6_MIB_OUTROUTERSOLICITS);

659

ICMP6_INC_STATS(idev, ICMP6_MIB_OUTROUTERSOLICITS);

660

ICMP6_INC_STATS(idev, ICMP6_MIB_OUTMSGS);

660

ICMP6_INC_STATS(idev, ICMP6_MIB_OUTMSGS);

661

}

661

}

662

663

if (likely(idev != NULL))

663

if (likely(idev != NULL))

664

in6_dev_put(idev);

664

in6_dev_put(idev);

665

}

665

}

666

667

668

static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb)

668

static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb)

669

{

669

{

670

/*

670

/*

671

* "The sender MUST return an ICMP

671

* "The sender MUST return an ICMP

672

* destination unreachable"

672

* destination unreachable"

673

*/

673

*/

674

dst_link_failure(skb);

674

dst_link_failure(skb);

675

kfree_skb(skb);

675

kfree_skb(skb);

676

}

676

}

677

678

/* Called with locked neigh: either read or both */

678

/* Called with locked neigh: either read or both */

679

680

static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb)

680

static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb)

681

{

681

{

682

struct in6_addr *saddr = NULL;

682

struct in6_addr *saddr = NULL;

683

struct in6_addr mcaddr;

683

struct in6_addr mcaddr;

684

struct net_device *dev = neigh->dev;

684

struct net_device *dev = neigh->dev;

685

struct in6_addr *target = (struct in6_addr *)&neigh->primary_key;

685

struct in6_addr *target = (struct in6_addr *)&neigh->primary_key;

686

int probes = atomic_read(&neigh->probes);

686

int probes = atomic_read(&neigh->probes);

687

688

if (skb && ipv6_chk_addr(&skb->nh.ipv6h->saddr, dev, 1))

688

if (skb && ipv6_chk_addr(&skb->nh.ipv6h->saddr, dev, 1))

689

saddr = &skb->nh.ipv6h->saddr;

689

saddr = &skb->nh.ipv6h->saddr;

690

691

if ((probes -= neigh->parms->ucast_probes) < 0) {

691

if ((probes -= neigh->parms->ucast_probes) < 0) {

692

if (!(neigh->nud_state & NUD_VALID)) {

692

if (!(neigh->nud_state & NUD_VALID)) {

693

ND_PRINTK1(KERN_DEBUG

693

ND_PRINTK1(KERN_DEBUG

694

"%s(): trying to ucast probe in NUD_INVALID: "

694

"%s(): trying to ucast probe in NUD_INVALID: "

695

"%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x\n",

695

"%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x\n",

696

__FUNCTION__,

696

__FUNCTION__,

697

NIP6(*target));

697

NIP6(*target));

698

}

698

}

699

ndisc_send_ns(dev, neigh, target, target, saddr);

699

ndisc_send_ns(dev, neigh, target, target, saddr);

700

} else if ((probes -= neigh->parms->app_probes) < 0) {

700

} else if ((probes -= neigh->parms->app_probes) < 0) {

701

#ifdef CONFIG_ARPD

701

#ifdef CONFIG_ARPD

702

neigh_app_ns(neigh);

702

neigh_app_ns(neigh);

703

#endif

703

#endif

704

} else {

704

} else {

705

addrconf_addr_solict_mult(target, &mcaddr);

705

addrconf_addr_solict_mult(target, &mcaddr);

706

ndisc_send_ns(dev, NULL, target, &mcaddr, saddr);

706

ndisc_send_ns(dev, NULL, target, &mcaddr, saddr);

707

}

707

}

708

}

708

}

709

710

static void ndisc_recv_ns(struct sk_buff *skb)

710

static void ndisc_recv_ns(struct sk_buff *skb)

711

{

711

{

712

struct nd_msg *msg = (struct nd_msg *)skb->h.raw;

712

struct nd_msg *msg = (struct nd_msg *)skb->h.raw;

713

struct in6_addr *saddr = &skb->nh.ipv6h->saddr;

713

struct in6_addr *saddr = &skb->nh.ipv6h->saddr;

714

struct in6_addr *daddr = &skb->nh.ipv6h->daddr;

714

struct in6_addr *daddr = &skb->nh.ipv6h->daddr;

715

u8 *lladdr = NULL;

715

u8 *lladdr = NULL;

716

u32 ndoptlen = skb->tail - msg->opt;

716

u32 ndoptlen = skb->tail - msg->opt;

717

struct ndisc_options ndopts;

717

struct ndisc_options ndopts;

718

struct net_device *dev = skb->dev;

718

struct net_device *dev = skb->dev;

719

struct inet6_ifaddr *ifp;

719

struct inet6_ifaddr *ifp;

720

struct inet6_dev *idev = NULL;

720

struct inet6_dev *idev = NULL;

721

struct neighbour *neigh;

721

struct neighbour *neigh;

722

int dad = ipv6_addr_any(saddr);

722

int dad = ipv6_addr_any(saddr);

723

int inc;

723

int inc;

724

725

if (ipv6_addr_is_multicast(&msg->target)) {

725

if (ipv6_addr_is_multicast(&msg->target)) {

726

ND_PRINTK2(KERN_WARNING

726

ND_PRINTK2(KERN_WARNING

727

"ICMPv6 NS: multicast target address");

727

"ICMPv6 NS: multicast target address");

728

return;

728

return;

729

}

729

}

730

731

/*

731

/*

732

* RFC2461 7.1.1:

732

* RFC2461 7.1.1:

733

* DAD has to be destined for solicited node multicast address.

733

* DAD has to be destined for solicited node multicast address.

734

*/

734

*/

735

if (dad &&

735

if (dad &&

736

!(daddr->s6_addr32[0] == htonl(0xff020000) &&

736

!(daddr->s6_addr32[0] == htonl(0xff020000) &&

737

daddr->s6_addr32[1] == htonl(0x00000000) &&

737

daddr->s6_addr32[1] == htonl(0x00000000) &&

738

daddr->s6_addr32[2] == htonl(0x00000001) &&

738

daddr->s6_addr32[2] == htonl(0x00000001) &&

739

daddr->s6_addr [12] == 0xff )) {

739

daddr->s6_addr [12] == 0xff )) {

740

ND_PRINTK2(KERN_WARNING

740

ND_PRINTK2(KERN_WARNING

741

"ICMPv6 NS: bad DAD packet (wrong destination)\n");

741

"ICMPv6 NS: bad DAD packet (wrong destination)\n");

742

return;

742

return;

743

}

743

}

744

745

if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {

745

if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {

746

ND_PRINTK2(KERN_WARNING

746

ND_PRINTK2(KERN_WARNING

747

"ICMPv6 NS: invalid ND options\n");

747

"ICMPv6 NS: invalid ND options\n");

748

return;

748

return;

749

}

749

}

750

751

if (ndopts.nd_opts_src_lladdr) {

751

if (ndopts.nd_opts_src_lladdr) {

752

lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr, dev);

752

lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr, dev);

753

if (!lladdr) {

753

if (!lladdr) {

754

ND_PRINTK2(KERN_WARNING

754

ND_PRINTK2(KERN_WARNING

755

"ICMPv6 NS: invalid link-layer address length\n");

755

"ICMPv6 NS: invalid link-layer address length\n");

756

return;

756

return;

757

}

757

}

758

759

/* RFC2461 7.1.1:

759

/* RFC2461 7.1.1:

760

* If the IP source address is the unspecified address,

760

* If the IP source address is the unspecified address,

761

* there MUST NOT be source link-layer address option

761

* there MUST NOT be source link-layer address option

762

* in the message.

762

* in the message.

763

*/

763

*/

764

if (dad) {

764

if (dad) {

765

ND_PRINTK2(KERN_WARNING

765

ND_PRINTK2(KERN_WARNING

766

"ICMPv6 NS: bad DAD packet (link-layer address option)\n");

766

"ICMPv6 NS: bad DAD packet (link-layer address option)\n");

767

return;

767

return;

768

}

768

}

769

}

769

}

770

771

inc = ipv6_addr_is_multicast(daddr);

771

inc = ipv6_addr_is_multicast(daddr);

772

773

if ((ifp = ipv6_get_ifaddr(&msg->target, dev, 1)) != NULL) {

773

if ((ifp = ipv6_get_ifaddr(&msg->target, dev, 1)) != NULL) {

774

if (ifp->flags & IFA_F_TENTATIVE) {

774

if (ifp->flags & IFA_F_TENTATIVE) {

775

/* Address is tentative. If the source

775

/* Address is tentative. If the source

776

is unspecified address, it is someone

776

is unspecified address, it is someone

777

does DAD, otherwise we ignore solicitations

777

does DAD, otherwise we ignore solicitations

778

until DAD timer expires.

778

until DAD timer expires.

779

*/

779

*/

780

if (!dad)

780

if (!dad)

781

goto out;

781

goto out;

782

if (dev->type == ARPHRD_IEEE802_TR) {

782

if (dev->type == ARPHRD_IEEE802_TR) {

783

unsigned char *sadr = skb->mac.raw;

783

unsigned char *sadr = skb->mac.raw;

784

if (((sadr[8] ^ dev->dev_addr[0]) & 0x7f) == 0 &&

784

if (((sadr[8] ^ dev->dev_addr[0]) & 0x7f) == 0 &&

785

sadr[9] == dev->dev_addr[1] &&

785

sadr[9] == dev->dev_addr[1] &&

786

sadr[10] == dev->dev_addr[2] &&

786

sadr[10] == dev->dev_addr[2] &&

787

sadr[11] == dev->dev_addr[3] &&

787

sadr[11] == dev->dev_addr[3] &&

788

sadr[12] == dev->dev_addr[4] &&

788

sadr[12] == dev->dev_addr[4] &&

789

sadr[13] == dev->dev_addr[5]) {

789

sadr[13] == dev->dev_addr[5]) {

790

/* looped-back to us */

790

/* looped-back to us */

791

goto out;

791

goto out;

792

}

792

}

793

}

793

}

794

addrconf_dad_failure(ifp);

794

addrconf_dad_failure(ifp);

795

return;

795

return;

796

}

796

}

797

798

idev = ifp->idev;

798

idev = ifp->idev;

799

} else {

799

} else {

800

idev = in6_dev_get(dev);

800

idev = in6_dev_get(dev);

801

if (!idev) {

801

if (!idev) {

802

/* XXX: count this drop? */

802

/* XXX: count this drop? */

803

return;

803

return;

804

}

804

}

805

806

if (ipv6_chk_acast_addr(dev, &msg->target) ||

806

if (ipv6_chk_acast_addr(dev, &msg->target) ||

807

(idev->cnf.forwarding &&

807

(idev->cnf.forwarding &&

808

pneigh_lookup(&nd_tbl, &msg->target, dev, 0))) {

808

pneigh_lookup(&nd_tbl, &msg->target, dev, 0))) {

809

if (!(NEIGH_CB(skb)->flags & LOCALLY_ENQUEUED) &&

809

if (!(NEIGH_CB(skb)->flags & LOCALLY_ENQUEUED) &&

810

skb->pkt_type != PACKET_HOST &&

810

skb->pkt_type != PACKET_HOST &&

811

inc != 0 &&

811

inc != 0 &&

812

idev->nd_parms->proxy_delay != 0) {

812

idev->nd_parms->proxy_delay != 0) {

813

/*

813

/*

814

* for anycast or proxy,

814

* for anycast or proxy,

815

* sender should delay its response

815

* sender should delay its response

816

* by a random time between 0 and

816

* by a random time between 0 and

817

* MAX_ANYCAST_DELAY_TIME seconds.

817

* MAX_ANYCAST_DELAY_TIME seconds.

818

* (RFC2461) -- yoshfuji

818

* (RFC2461) -- yoshfuji

819

*/

819

*/

820

struct sk_buff *n = skb_clone(skb, GFP_ATOMIC);

820

struct sk_buff *n = skb_clone(skb, GFP_ATOMIC);

821

if (n)

821

if (n)

822

pneigh_enqueue(&nd_tbl, idev->nd_parms, n);

822

pneigh_enqueue(&nd_tbl, idev->nd_parms, n);

823

goto out;

823

goto out;

824

}

824

}

825

} else

825

} else

826

goto out;

826

goto out;

827

}

827

}

828

829

if (dad) {

829

if (dad) {

830

struct in6_addr maddr;

830

struct in6_addr maddr;

831

832

ipv6_addr_all_nodes(&maddr);

832

ipv6_addr_all_nodes(&maddr);

833

ndisc_send_na(dev, NULL, &maddr, &msg->target,

833

ndisc_send_na(dev, NULL, &maddr, &msg->target,

834

idev->cnf.forwarding, 0, (ifp != NULL), 1);

834

idev->cnf.forwarding, 0, (ifp != NULL), 1);

835

goto out;

835

goto out;

836

}

836

}

837

838

if (inc)

838

if (inc)

839

NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_mcast);

839

NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_mcast);

840

else

840

else

841

NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_ucast);

841

NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_ucast);

842

843

/*

843

/*

844

* update / create cache entry

844

* update / create cache entry

845

* for the source address

845

* for the source address

846

*/

846

*/

847

neigh = __neigh_lookup(&nd_tbl, saddr, dev,

847

neigh = __neigh_lookup(&nd_tbl, saddr, dev,

848

!inc || lladdr || !dev->addr_len);

848

!inc || lladdr || !dev->addr_len);

849

if (neigh)

849

if (neigh)

850

neigh_update(neigh, lladdr, NUD_STALE,

850

neigh_update(neigh, lladdr, NUD_STALE,

851

NEIGH_UPDATE_F_WEAK_OVERRIDE|

851

NEIGH_UPDATE_F_WEAK_OVERRIDE|

852

NEIGH_UPDATE_F_OVERRIDE);

852

NEIGH_UPDATE_F_OVERRIDE);

853

if (neigh || !dev->hard_header) {

853

if (neigh || !dev->hard_header) {

854

ndisc_send_na(dev, neigh, saddr, &msg->target,

854

ndisc_send_na(dev, neigh, saddr, &msg->target,

855

idev->cnf.forwarding,

855

idev->cnf.forwarding,

856

1, (ifp != NULL && inc), inc);

856

1, (ifp != NULL && inc), inc);

857

if (neigh)

857

if (neigh)

858

neigh_release(neigh);

858

neigh_release(neigh);

859

}

859

}

860

861

out:

861

out:

862

if (ifp)

862

if (ifp)

863

in6_ifa_put(ifp);

863

in6_ifa_put(ifp);

864

else

864

else

865

in6_dev_put(idev);

865

in6_dev_put(idev);

866

867

return;

867

return;

868

}

868

}

869

870

static void ndisc_recv_na(struct sk_buff *skb)

870

static void ndisc_recv_na(struct sk_buff *skb)

871

{

871

{

872

struct nd_msg *msg = (struct nd_msg *)skb->h.raw;

872

struct nd_msg *msg = (struct nd_msg *)skb->h.raw;

873

struct in6_addr *saddr = &skb->nh.ipv6h->saddr;

873

struct in6_addr *saddr = &skb->nh.ipv6h->saddr;

874

struct in6_addr *daddr = &skb->nh.ipv6h->daddr;

874

struct in6_addr *daddr = &skb->nh.ipv6h->daddr;

875

u8 *lladdr = NULL;

875

u8 *lladdr = NULL;

876

u32 ndoptlen = skb->tail - msg->opt;

876

u32 ndoptlen = skb->tail - msg->opt;

877

struct ndisc_options ndopts;

877

struct ndisc_options ndopts;

878

struct net_device *dev = skb->dev;

878

struct net_device *dev = skb->dev;

879

struct inet6_ifaddr *ifp;

879

struct inet6_ifaddr *ifp;

880

struct neighbour *neigh;

880

struct neighbour *neigh;

881

882

if (skb->len < sizeof(struct nd_msg)) {

882

if (skb->len < sizeof(struct nd_msg)) {

883

ND_PRINTK2(KERN_WARNING

883

ND_PRINTK2(KERN_WARNING

884

"ICMPv6 NA: packet too short\n");

884

"ICMPv6 NA: packet too short\n");

885

return;

885

return;

886

}

886

}

887

888

if (ipv6_addr_is_multicast(&msg->target)) {

888

if (ipv6_addr_is_multicast(&msg->target)) {

889

ND_PRINTK2(KERN_WARNING

889

ND_PRINTK2(KERN_WARNING

890

"ICMPv6 NA: target address is multicast.\n");

890

"ICMPv6 NA: target address is multicast.\n");

891

return;

891

return;

892

}

892

}

893

894

if (ipv6_addr_is_multicast(daddr) &&

894

if (ipv6_addr_is_multicast(daddr) &&

895

msg->icmph.icmp6_solicited) {

895

msg->icmph.icmp6_solicited) {

896

ND_PRINTK2(KERN_WARNING

896

ND_PRINTK2(KERN_WARNING

897

"ICMPv6 NA: solicited NA is multicasted.\n");

897

"ICMPv6 NA: solicited NA is multicasted.\n");

898

return;

898

return;

899

}

899

}

900

901

if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {

901

if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {

902

ND_PRINTK2(KERN_WARNING

902

ND_PRINTK2(KERN_WARNING

903

"ICMPv6 NS: invalid ND option\n");

903

"ICMPv6 NS: invalid ND option\n");

904

return;

904

return;

905

}

905

}

906

if (ndopts.nd_opts_tgt_lladdr) {

906

if (ndopts.nd_opts_tgt_lladdr) {

907

lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr, dev);

907

lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr, dev);

908

if (!lladdr) {

908

if (!lladdr) {

909

ND_PRINTK2(KERN_WARNING

909

ND_PRINTK2(KERN_WARNING

910

"ICMPv6 NA: invalid link-layer address length\n");

910

"ICMPv6 NA: invalid link-layer address length\n");

911

return;

911

return;

912

}

912

}

913

}

913

}

914

if ((ifp = ipv6_get_ifaddr(&msg->target, dev, 1))) {

914

if ((ifp = ipv6_get_ifaddr(&msg->target, dev, 1))) {

915

if (ifp->flags & IFA_F_TENTATIVE) {

915

if (ifp->flags & IFA_F_TENTATIVE) {

916

addrconf_dad_failure(ifp);

916

addrconf_dad_failure(ifp);

917

return;

917

return;

918

}

918

}

919

/* What should we make now? The advertisement

919

/* What should we make now? The advertisement

920

is invalid, but ndisc specs say nothing

920

is invalid, but ndisc specs say nothing

921

about it. It could be misconfiguration, or

921

about it. It could be misconfiguration, or

922

an smart proxy agent tries to help us :-)

922

an smart proxy agent tries to help us :-)

923

*/

923

*/

924

ND_PRINTK1(KERN_WARNING

924

ND_PRINTK1(KERN_WARNING

925

"ICMPv6 NA: someone advertises our address on %s!\n",

925

"ICMPv6 NA: someone advertises our address on %s!\n",

926

ifp->idev->dev->name);

926

ifp->idev->dev->name);

927

in6_ifa_put(ifp);

927

in6_ifa_put(ifp);

928

return;

928

return;

929

}

929

}

930

neigh = neigh_lookup(&nd_tbl, &msg->target, dev);

930

neigh = neigh_lookup(&nd_tbl, &msg->target, dev);

931

932

if (neigh) {

932

if (neigh) {

933

u8 old_flags = neigh->flags;

933

u8 old_flags = neigh->flags;

934

935

if (neigh->nud_state & NUD_FAILED)

935

if (neigh->nud_state & NUD_FAILED)

936

goto out;

936

goto out;

937

938

neigh_update(neigh, lladdr,

938

neigh_update(neigh, lladdr,

939

msg->icmph.icmp6_solicited ? NUD_REACHABLE : NUD_STALE,

939

msg->icmph.icmp6_solicited ? NUD_REACHABLE : NUD_STALE,

940

NEIGH_UPDATE_F_WEAK_OVERRIDE|

940

NEIGH_UPDATE_F_WEAK_OVERRIDE|

941

(msg->icmph.icmp6_override ? NEIGH_UPDATE_F_OVERRIDE : 0)|

941

(msg->icmph.icmp6_override ? NEIGH_UPDATE_F_OVERRIDE : 0)|

942

NEIGH_UPDATE_F_OVERRIDE_ISROUTER|

942

NEIGH_UPDATE_F_OVERRIDE_ISROUTER|

943

(msg->icmph.icmp6_router ? NEIGH_UPDATE_F_ISROUTER : 0));

943

(msg->icmph.icmp6_router ? NEIGH_UPDATE_F_ISROUTER : 0));

944

945

if ((old_flags & ~neigh->flags) & NTF_ROUTER) {

945

if ((old_flags & ~neigh->flags) & NTF_ROUTER) {

946

/*

946

/*

947

* Change: router to host

947

* Change: router to host

948

*/

948

*/

949

struct rt6_info *rt;

949

struct rt6_info *rt;

950

rt = rt6_get_dflt_router(saddr, dev);

950

rt = rt6_get_dflt_router(saddr, dev);

951

if (rt)

951

if (rt)

952

ip6_del_rt(rt, NULL, NULL, NULL);

952

ip6_del_rt(rt, NULL, NULL, NULL);

953

}

953

}

954

955

out:

955

out:

956

neigh_release(neigh);

956

neigh_release(neigh);

957

}

957

}

958

}

958

}

959

960

static void ndisc_recv_rs(struct sk_buff *skb)

960

static void ndisc_recv_rs(struct sk_buff *skb)

961

{

961

{

962

struct rs_msg *rs_msg = (struct rs_msg *) skb->h.raw;

962

struct rs_msg *rs_msg = (struct rs_msg *) skb->h.raw;

963

unsigned long ndoptlen = skb->len - sizeof(*rs_msg);

963

unsigned long ndoptlen = skb->len - sizeof(*rs_msg);

964

struct neighbour *neigh;

964

struct neighbour *neigh;

965

struct inet6_dev *idev;

965

struct inet6_dev *idev;

966

struct in6_addr *saddr = &skb->nh.ipv6h->saddr;

966

struct in6_addr *saddr = &skb->nh.ipv6h->saddr;

967

struct ndisc_options ndopts;

967

struct ndisc_options ndopts;

968

u8 *lladdr = NULL;

968

u8 *lladdr = NULL;

969

970

if (skb->len < sizeof(*rs_msg))

970

if (skb->len < sizeof(*rs_msg))

971

return;

971

return;

972

973

idev = in6_dev_get(skb->dev);

973

idev = in6_dev_get(skb->dev);

974

if (!idev) {

974

if (!idev) {

975

if (net_ratelimit())

975

if (net_ratelimit())

976

ND_PRINTK1("ICMP6 RS: can't find in6 device\n");

976

ND_PRINTK1("ICMP6 RS: can't find in6 device\n");

977

return;

977

return;

978

}

978

}

979

980

/* Don't accept RS if we're not in router mode */

980

/* Don't accept RS if we're not in router mode */

981

if (!idev->cnf.forwarding)

981

if (!idev->cnf.forwarding)

982

goto out;

982

goto out;

983

984

/*

984

/*

985

* Don't update NCE if src = ::;

985

* Don't update NCE if src = ::;

986

* this implies that the source node has no ip address assigned yet.

986

* this implies that the source node has no ip address assigned yet.

987

*/

987

*/

988

if (ipv6_addr_any(saddr))

988

if (ipv6_addr_any(saddr))

989

goto out;

989

goto out;

990

991

/* Parse ND options */

991

/* Parse ND options */

992

if (!ndisc_parse_options(rs_msg->opt, ndoptlen, &ndopts)) {

992

if (!ndisc_parse_options(rs_msg->opt, ndoptlen, &ndopts)) {

993

if (net_ratelimit())

993

if (net_ratelimit())

994

ND_PRINTK2("ICMP6 NS: invalid ND option, ignored\n");

994

ND_PRINTK2("ICMP6 NS: invalid ND option, ignored\n");

995

goto out;

995

goto out;

996

}

996

}

997

998

if (ndopts.nd_opts_src_lladdr) {

998

if (ndopts.nd_opts_src_lladdr) {

999

lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,

999

lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,

1000

skb->dev);

1000

skb->dev);

1001

if (!lladdr)

1001

if (!lladdr)

1002

goto out;

1002

goto out;

1003

}

1003

}

1004

1005

neigh = __neigh_lookup(&nd_tbl, saddr, skb->dev, 1);

1005

neigh = __neigh_lookup(&nd_tbl, saddr, skb->dev, 1);

1006

if (neigh) {

1006

if (neigh) {

1007

neigh_update(neigh, lladdr, NUD_STALE,

1007

neigh_update(neigh, lladdr, NUD_STALE,

1008

NEIGH_UPDATE_F_WEAK_OVERRIDE|

1008

NEIGH_UPDATE_F_WEAK_OVERRIDE|

1009

NEIGH_UPDATE_F_OVERRIDE|

1009

NEIGH_UPDATE_F_OVERRIDE|

1010

NEIGH_UPDATE_F_OVERRIDE_ISROUTER);

1010

NEIGH_UPDATE_F_OVERRIDE_ISROUTER);

1011

neigh_release(neigh);

1011

neigh_release(neigh);

1012

}

1012

}

1013

out:

1013

out:

1014

in6_dev_put(idev);

1014

in6_dev_put(idev);

1015

}

1015

}

1016

1017

static void ndisc_router_discovery(struct sk_buff *skb)

1017

static void ndisc_router_discovery(struct sk_buff *skb)

1018

{

1018

{

1019

struct ra_msg *ra_msg = (struct ra_msg *) skb->h.raw;

1019

struct ra_msg *ra_msg = (struct ra_msg *) skb->h.raw;

1020

struct neighbour *neigh = NULL;

1020

struct neighbour *neigh = NULL;

1021

struct inet6_dev *in6_dev;

1021

struct inet6_dev *in6_dev;

1022

struct rt6_info *rt;

1022

struct rt6_info *rt;

1023

int lifetime;

1023

int lifetime;

1024

struct ndisc_options ndopts;

1024

struct ndisc_options ndopts;

1025

int optlen;

1025

int optlen;

1026

1027

__u8 * opt = (__u8 *)(ra_msg + 1);

1027

__u8 * opt = (__u8 *)(ra_msg + 1);

1028

1029

optlen = (skb->tail - skb->h.raw) - sizeof(struct ra_msg);

1029

optlen = (skb->tail - skb->h.raw) - sizeof(struct ra_msg);

1030

1031

if (!(ipv6_addr_type(&skb->nh.ipv6h->saddr) & IPV6_ADDR_LINKLOCAL)) {

1031

if (!(ipv6_addr_type(&skb->nh.ipv6h->saddr) & IPV6_ADDR_LINKLOCAL)) {

1032

ND_PRINTK2(KERN_WARNING

1032

ND_PRINTK2(KERN_WARNING

1033

"ICMPv6 RA: source address is not link-local.\n");

1033

"ICMPv6 RA: source address is not link-local.\n");

1034

return;

1034

return;

1035

}

1035

}

1036

if (optlen < 0) {

1036

if (optlen < 0) {

1037

ND_PRINTK2(KERN_WARNING

1037

ND_PRINTK2(KERN_WARNING

1038

"ICMPv6 RA: packet too short\n");

1038

"ICMPv6 RA: packet too short\n");

1039

return;

1039

return;

1040

}

1040

}

1041

1042

/*

1042

/*

1043

* set the RA_RECV flag in the interface

1043

* set the RA_RECV flag in the interface

1044

*/

1044

*/

1045

1046

in6_dev = in6_dev_get(skb->dev);

1046

in6_dev = in6_dev_get(skb->dev);

1047

if (in6_dev == NULL) {

1047

if (in6_dev == NULL) {

1048

ND_PRINTK0(KERN_ERR

1048

ND_PRINTK0(KERN_ERR

1049

"ICMPv6 RA: can't find inet6 device for %s.\n",

1049

"ICMPv6 RA: can't find inet6 device for %s.\n",

1050

skb->dev->name);

1050

skb->dev->name);

1051

return;

1051

return;

1052

}

1052

}

1053

if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_ra) {

1053

if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_ra) {

1054

in6_dev_put(in6_dev);

1054

in6_dev_put(in6_dev);

1055

return;

1055

return;

1056

}

1056

}

1057

1058

if (!ndisc_parse_options(opt, optlen, &ndopts)) {

1058

if (!ndisc_parse_options(opt, optlen, &ndopts)) {

1059

in6_dev_put(in6_dev);

1059

in6_dev_put(in6_dev);

1060

ND_PRINTK2(KERN_WARNING

1060

ND_PRINTK2(KERN_WARNING

1061

"ICMP6 RA: invalid ND options\n");

1061

"ICMP6 RA: invalid ND options\n");

1062

return;

1062

return;

1063

}

1063

}

1064

1065

if (in6_dev->if_flags & IF_RS_SENT) {

1065

if (in6_dev->if_flags & IF_RS_SENT) {

1066

/*

1066

/*

1067

* flag that an RA was received after an RS was sent

1067

* flag that an RA was received after an RS was sent

1068

* out on this interface.

1068

* out on this interface.

1069

*/

1069

*/

1070

in6_dev->if_flags |= IF_RA_RCVD;

1070

in6_dev->if_flags |= IF_RA_RCVD;

1071

}

1071

}

1072

1073

/*

1073

/*

1074

* Remember the managed/otherconf flags from most recently

1074

* Remember the managed/otherconf flags from most recently

1075

* received RA message (RFC 2462) -- yoshfuji

1075

* received RA message (RFC 2462) -- yoshfuji

1076

*/

1076

*/

1077

in6_dev->if_flags = (in6_dev->if_flags & ~(IF_RA_MANAGED |

1077

in6_dev->if_flags = (in6_dev->if_flags & ~(IF_RA_MANAGED |

1078

IF_RA_OTHERCONF)) |

1078

IF_RA_OTHERCONF)) |

1079

(ra_msg->icmph.icmp6_addrconf_managed ?

1079

(ra_msg->icmph.icmp6_addrconf_managed ?

1080

IF_RA_MANAGED : 0) |

1080

IF_RA_MANAGED : 0) |

1081

(ra_msg->icmph.icmp6_addrconf_other ?

1081

(ra_msg->icmph.icmp6_addrconf_other ?

1082

IF_RA_OTHERCONF : 0);

1082

IF_RA_OTHERCONF : 0);

1083

1084

lifetime = ntohs(ra_msg->icmph.icmp6_rt_lifetime);

1084

lifetime = ntohs(ra_msg->icmph.icmp6_rt_lifetime);

1085

1086

rt = rt6_get_dflt_router(&skb->nh.ipv6h->saddr, skb->dev);

1086

rt = rt6_get_dflt_router(&skb->nh.ipv6h->saddr, skb->dev);

1087

1088

if (rt)

1088

if (rt)

1089

neigh = rt->rt6i_nexthop;

1089

neigh = rt->rt6i_nexthop;

1090

1091

if (rt && lifetime == 0) {

1091

if (rt && lifetime == 0) {

1092

neigh_clone(neigh);

1092

neigh_clone(neigh);

1093

ip6_del_rt(rt, NULL, NULL, NULL);

1093

ip6_del_rt(rt, NULL, NULL, NULL);

1094

rt = NULL;

1094

rt = NULL;

1095

}

1095

}

1096

1097

if (rt == NULL && lifetime) {

1097

if (rt == NULL && lifetime) {

1098

ND_PRINTK3(KERN_DEBUG

1098

ND_PRINTK3(KERN_DEBUG

1099

"ICMPv6 RA: adding default router.\n");

1099

"ICMPv6 RA: adding default router.\n");

1100

1101

rt = rt6_add_dflt_router(&skb->nh.ipv6h->saddr, skb->dev);

1101

rt = rt6_add_dflt_router(&skb->nh.ipv6h->saddr, skb->dev);

1102

if (rt == NULL) {

1102

if (rt == NULL) {

1103

ND_PRINTK0(KERN_ERR

1103

ND_PRINTK0(KERN_ERR

1104

"ICMPv6 RA: %s() failed to add default route.\n",

1104

"ICMPv6 RA: %s() failed to add default route.\n",

1105

__FUNCTION__);

1105

__FUNCTION__);

1106

in6_dev_put(in6_dev);

1106

in6_dev_put(in6_dev);

1107

return;

1107

return;

1108

}

1108

}

1109

1110

neigh = rt->rt6i_nexthop;

1110

neigh = rt->rt6i_nexthop;

1111

if (neigh == NULL) {

1111

if (neigh == NULL) {

1112

ND_PRINTK0(KERN_ERR

1112

ND_PRINTK0(KERN_ERR

1113

"ICMPv6 RA: %s() got default router without neighbour.\n",

1113

"ICMPv6 RA: %s() got default router without neighbour.\n",

1114

__FUNCTION__);

1114

__FUNCTION__);

1115

dst_release(&rt->u.dst);

1115

dst_release(&rt->u.dst);

1116

in6_dev_put(in6_dev);

1116

in6_dev_put(in6_dev);

1117

return;

1117

return;

1118

}

1118

}

1119

neigh->flags |= NTF_ROUTER;

1119

neigh->flags |= NTF_ROUTER;

1120

}

1120

}

1121

1122

if (rt)

1122

if (rt)

1123

rt->rt6i_expires = jiffies + (HZ * lifetime);

1123

rt->rt6i_expires = jiffies + (HZ * lifetime);

1124

1125

if (ra_msg->icmph.icmp6_hop_limit) {

1125

if (ra_msg->icmph.icmp6_hop_limit) {

1126

in6_dev->cnf.hop_limit = ra_msg->icmph.icmp6_hop_limit;

1126

in6_dev->cnf.hop_limit = ra_msg->icmph.icmp6_hop_limit;

1127

if (rt)

1127

if (rt)

1128

rt->u.dst.metrics[RTAX_HOPLIMIT-1] = ra_msg->icmph.icmp6_hop_limit;

1128

rt->u.dst.metrics[RTAX_HOPLIMIT-1] = ra_msg->icmph.icmp6_hop_limit;

1129

}

1129

}

1130

1131

/*

1131

/*

1132

* Update Reachable Time and Retrans Timer

1132

* Update Reachable Time and Retrans Timer

1133

*/

1133

*/

1134

1135

if (in6_dev->nd_parms) {

1135

if (in6_dev->nd_parms) {

1136

unsigned long rtime = ntohl(ra_msg->retrans_timer);

1136

unsigned long rtime = ntohl(ra_msg->retrans_timer);

1137

1138

if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/HZ) {

1138

if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/HZ) {

1139

rtime = (rtime*HZ)/1000;

1139

rtime = (rtime*HZ)/1000;

1140

if (rtime < HZ/10)

1140

if (rtime < HZ/10)

1141

rtime = HZ/10;

1141

rtime = HZ/10;

1142

in6_dev->nd_parms->retrans_time = rtime;

1142

in6_dev->nd_parms->retrans_time = rtime;

1143

in6_dev->tstamp = jiffies;

1143

in6_dev->tstamp = jiffies;

1144

inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);

1144

inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);

1145

}

1145

}

1146

1147

rtime = ntohl(ra_msg->reachable_time);

1147

rtime = ntohl(ra_msg->reachable_time);

1148

if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/(3*HZ)) {

1148

if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/(3*HZ)) {

1149

rtime = (rtime*HZ)/1000;

1149

rtime = (rtime*HZ)/1000;

1150

1151

if (rtime < HZ/10)

1151

if (rtime < HZ/10)

1152

rtime = HZ/10;

1152

rtime = HZ/10;

1153

1154

if (rtime != in6_dev->nd_parms->base_reachable_time) {

1154

if (rtime != in6_dev->nd_parms->base_reachable_time) {

1155

in6_dev->nd_parms->base_reachable_time = rtime;

1155

in6_dev->nd_parms->base_reachable_time = rtime;

1156

in6_dev->nd_parms->gc_staletime = 3 * rtime;

1156

in6_dev->nd_parms->gc_staletime = 3 * rtime;

1157

in6_dev->nd_parms->reachable_time = neigh_rand_reach_time(rtime);

1157

in6_dev->nd_parms->reachable_time = neigh_rand_reach_time(rtime);

1158

in6_dev->tstamp = jiffies;

1158

in6_dev->tstamp = jiffies;

1159

inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);

1159

inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);

1160

}

1160

}

1161

}

1161

}

1162

}

1162

}

1163

1164

/*

1164

/*

1165

* Process options.

1165

* Process options.

1166

*/

1166

*/

1167

1168

if (!neigh)

1168

if (!neigh)

1169

neigh = __neigh_lookup(&nd_tbl, &skb->nh.ipv6h->saddr,

1169

neigh = __neigh_lookup(&nd_tbl, &skb->nh.ipv6h->saddr,

1170

skb->dev, 1);

1170

skb->dev, 1);

1171

if (neigh) {

1171

if (neigh) {

1172

u8 *lladdr = NULL;

1172

u8 *lladdr = NULL;

1173

if (ndopts.nd_opts_src_lladdr) {

1173

if (ndopts.nd_opts_src_lladdr) {

1174

lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,

1174

lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,

1175

skb->dev);

1175

skb->dev);

1176

if (!lladdr) {

1176

if (!lladdr) {

1177

ND_PRINTK2(KERN_WARNING

1177

ND_PRINTK2(KERN_WARNING

1178

"ICMPv6 RA: invalid link-layer address length\n");

1178

"ICMPv6 RA: invalid link-layer address length\n");

1179

goto out;

1179

goto out;

1180

}

1180

}

1181

}

1181

}

1182

neigh_update(neigh, lladdr, NUD_STALE,

1182

neigh_update(neigh, lladdr, NUD_STALE,

1183

NEIGH_UPDATE_F_WEAK_OVERRIDE|

1183

NEIGH_UPDATE_F_WEAK_OVERRIDE|

1184

NEIGH_UPDATE_F_OVERRIDE|

1184

NEIGH_UPDATE_F_OVERRIDE|

1185

NEIGH_UPDATE_F_OVERRIDE_ISROUTER|

1185

NEIGH_UPDATE_F_OVERRIDE_ISROUTER|

1186

NEIGH_UPDATE_F_ISROUTER);

1186

NEIGH_UPDATE_F_ISROUTER);

1187

}

1187

}

1188

1189

if (ndopts.nd_opts_pi) {

1189

if (ndopts.nd_opts_pi) {

1190

struct nd_opt_hdr *p;

1190

struct nd_opt_hdr *p;

1191

for (p = ndopts.nd_opts_pi;

1191

for (p = ndopts.nd_opts_pi;

1192

p;

1192

p;

1193

p = ndisc_next_option(p, ndopts.nd_opts_pi_end)) {

1193

p = ndisc_next_option(p, ndopts.nd_opts_pi_end)) {

1194

addrconf_prefix_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3);

1194

addrconf_prefix_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3);

1195

}

1195

}

1196

}

1196

}

1197

1198

if (ndopts.nd_opts_mtu) {

1198

if (ndopts.nd_opts_mtu) {

1199

u32 mtu;

1199

u32 mtu;

1200

1201

memcpy(&mtu, ((u8*)(ndopts.nd_opts_mtu+1))+2, sizeof(mtu));

1201

memcpy(&mtu, ((u8*)(ndopts.nd_opts_mtu+1))+2, sizeof(mtu));

1202

mtu = ntohl(mtu);

1202

mtu = ntohl(mtu);

1203

1204

if (mtu < IPV6_MIN_MTU || mtu > skb->dev->mtu) {

1204

if (mtu < IPV6_MIN_MTU || mtu > skb->dev->mtu) {

1205

ND_PRINTK2(KERN_WARNING

1205

ND_PRINTK2(KERN_WARNING

1206

"ICMPv6 RA: invalid mtu: %d\n",

1206

"ICMPv6 RA: invalid mtu: %d\n",

1207

mtu);

1207

mtu);

1208

} else if (in6_dev->cnf.mtu6 != mtu) {

1208

} else if (in6_dev->cnf.mtu6 != mtu) {

1209

in6_dev->cnf.mtu6 = mtu;

1209

in6_dev->cnf.mtu6 = mtu;

1210

1211

if (rt)

1211

if (rt)

1212

rt->u.dst.metrics[RTAX_MTU-1] = mtu;

1212

rt->u.dst.metrics[RTAX_MTU-1] = mtu;

1213

1214

rt6_mtu_change(skb->dev, mtu);

1214

rt6_mtu_change(skb->dev, mtu);

1215

}

1215

}

1216

}

1216

}

1217

1218

if (ndopts.nd_opts_tgt_lladdr || ndopts.nd_opts_rh) {

1218

if (ndopts.nd_opts_tgt_lladdr || ndopts.nd_opts_rh) {

1219

ND_PRINTK2(KERN_WARNING

1219

ND_PRINTK2(KERN_WARNING

1220

"ICMPv6 RA: invalid RA options");

1220

"ICMPv6 RA: invalid RA options");

1221

}

1221

}

1222

out:

1222

out:

1223

if (rt)

1223

if (rt)

1224

dst_release(&rt->u.dst);

1224

dst_release(&rt->u.dst);

1225

else if (neigh)

1225

else if (neigh)

1226

neigh_release(neigh);

1226

neigh_release(neigh);

1227

in6_dev_put(in6_dev);

1227

in6_dev_put(in6_dev);

1228

}

1228

}

1229

1230

static void ndisc_redirect_rcv(struct sk_buff *skb)

1230

static void ndisc_redirect_rcv(struct sk_buff *skb)

1231

{

1231

{

1232

struct inet6_dev *in6_dev;

1232

struct inet6_dev *in6_dev;

1233

struct icmp6hdr *icmph;

1233

struct icmp6hdr *icmph;

1234

struct in6_addr *dest;

1234

struct in6_addr *dest;

1235

struct in6_addr *target; /* new first hop to destination */

1235

struct in6_addr *target; /* new first hop to destination */

1236

struct neighbour *neigh;

1236

struct neighbour *neigh;

1237

int on_link = 0;

1237

int on_link = 0;

1238

struct ndisc_options ndopts;

1238

struct ndisc_options ndopts;

1239

int optlen;

1239

int optlen;

1240

u8 *lladdr = NULL;

1240

u8 *lladdr = NULL;

1241

1242

if (!(ipv6_addr_type(&skb->nh.ipv6h->saddr) & IPV6_ADDR_LINKLOCAL)) {

1242

if (!(ipv6_addr_type(&skb->nh.ipv6h->saddr) & IPV6_ADDR_LINKLOCAL)) {

1243

ND_PRINTK2(KERN_WARNING

1243

ND_PRINTK2(KERN_WARNING

1244

"ICMPv6 Redirect: source address is not link-local.\n");

1244

"ICMPv6 Redirect: source address is not link-local.\n");

1245

return;

1245

return;

1246

}

1246

}

1247

1248

optlen = skb->tail - skb->h.raw;

1248

optlen = skb->tail - skb->h.raw;

1249

optlen -= sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr);

1249

optlen -= sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr);

1250

1251

if (optlen < 0) {

1251

if (optlen < 0) {

1252

ND_PRINTK2(KERN_WARNING

1252

ND_PRINTK2(KERN_WARNING

1253

"ICMPv6 Redirect: packet too short\n");

1253

"ICMPv6 Redirect: packet too short\n");

1254

return;

1254

return;

1255

}

1255

}

1256

1257

icmph = (struct icmp6hdr *) skb->h.raw;

1257

icmph = (struct icmp6hdr *) skb->h.raw;

1258

target = (struct in6_addr *) (icmph + 1);

1258

target = (struct in6_addr *) (icmph + 1);

1259

dest = target + 1;

1259

dest = target + 1;

1260

1261

if (ipv6_addr_is_multicast(dest)) {

1261

if (ipv6_addr_is_multicast(dest)) {

1262

ND_PRINTK2(KERN_WARNING

1262

ND_PRINTK2(KERN_WARNING

1263

"ICMPv6 Redirect: destination address is multicast.\n");

1263

"ICMPv6 Redirect: destination address is multicast.\n");

1264

return;

1264

return;

1265

}

1265

}

1266

1267

if (ipv6_addr_equal(dest, target)) {

1267

if (ipv6_addr_equal(dest, target)) {

1268

on_link = 1;

1268

on_link = 1;

1269

} else if (!(ipv6_addr_type(target) & IPV6_ADDR_LINKLOCAL)) {

1269

} else if (!(ipv6_addr_type(target) & IPV6_ADDR_LINKLOCAL)) {

1270

ND_PRINTK2(KERN_WARNING

1270

ND_PRINTK2(KERN_WARNING

1271

"ICMPv6 Redirect: target address is not link-local.\n");

1271

"ICMPv6 Redirect: target address is not link-local.\n");

1272

return;

1272

return;

1273

}

1273

}

1274

1275

in6_dev = in6_dev_get(skb->dev);

1275

in6_dev = in6_dev_get(skb->dev);

1276

if (!in6_dev)

1276

if (!in6_dev)

1277

return;

1277

return;

1278

if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_redirects) {

1278

if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_redirects) {

1279

in6_dev_put(in6_dev);

1279

in6_dev_put(in6_dev);

1280

return;

1280

return;

1281

}

1281

}

1282

1283

/* RFC2461 8.1:

1283

/* RFC2461 8.1:

1284

* The IP source address of the Redirect MUST be the same as the current

1284

* The IP source address of the Redirect MUST be the same as the current

1285

* first-hop router for the specified ICMP Destination Address.

1285

* first-hop router for the specified ICMP Destination Address.

1286

*/

1286

*/

1287

1288

if (!ndisc_parse_options((u8*)(dest + 1), optlen, &ndopts)) {

1288

if (!ndisc_parse_options((u8*)(dest + 1), optlen, &ndopts)) {

1289

ND_PRINTK2(KERN_WARNING

1289

ND_PRINTK2(KERN_WARNING

1290

"ICMPv6 Redirect: invalid ND options\n");

1290

"ICMPv6 Redirect: invalid ND options\n");

1291

in6_dev_put(in6_dev);

1291

in6_dev_put(in6_dev);

1292

return;

1292

return;

1293

}

1293

}

1294

if (ndopts.nd_opts_tgt_lladdr) {

1294

if (ndopts.nd_opts_tgt_lladdr) {

1295

lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr,

1295

lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr,

1296

skb->dev);

1296

skb->dev);

1297

if (!lladdr) {

1297

if (!lladdr) {

1298

ND_PRINTK2(KERN_WARNING

1298

ND_PRINTK2(KERN_WARNING

1299

"ICMPv6 Redirect: invalid link-layer address length\n");

1299

"ICMPv6 Redirect: invalid link-layer address length\n");

1300

in6_dev_put(in6_dev);

1300

in6_dev_put(in6_dev);

1301

return;

1301

return;

1302

}

1302

}

1303

}

1303

}

1304

1305

neigh = __neigh_lookup(&nd_tbl, target, skb->dev, 1);

1305

neigh = __neigh_lookup(&nd_tbl, target, skb->dev, 1);

1306

if (neigh) {

1306

if (neigh) {

1307

rt6_redirect(dest, &skb->nh.ipv6h->saddr, neigh, lladdr,

1307

rt6_redirect(dest, &skb->nh.ipv6h->saddr, neigh, lladdr,

1308

on_link);

1308

on_link);

1309

neigh_release(neigh);

1309

neigh_release(neigh);

1310

}

1310

}

1311

in6_dev_put(in6_dev);

1311

in6_dev_put(in6_dev);

1312

}

1312

}

1313

1314

void ndisc_send_redirect(struct sk_buff *skb, struct neighbour *neigh,

1314

void ndisc_send_redirect(struct sk_buff *skb, struct neighbour *neigh,

1315

struct in6_addr *target)

1315

struct in6_addr *target)

1316

{

1316

{

1317

struct sock *sk = ndisc_socket->sk;

1317

struct sock *sk = ndisc_socket->sk;

1318

int len = sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr);

1318

int len = sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr);

1319

struct sk_buff *buff;

1319

struct sk_buff *buff;

1320

struct icmp6hdr *icmph;

1320

struct icmp6hdr *icmph;

1321

struct in6_addr saddr_buf;

1321

struct in6_addr saddr_buf;

1322

struct in6_addr *addrp;

1322

struct in6_addr *addrp;

1323

struct net_device *dev;

1323

struct net_device *dev;

1324

struct rt6_info *rt;

1324

struct rt6_info *rt;

1325

struct dst_entry *dst;

1325

struct dst_entry *dst;

1326

struct inet6_dev *idev;

1326

struct inet6_dev *idev;

1327

struct flowi fl;

1327

struct flowi fl;

1328

u8 *opt;

1328

u8 *opt;

1329

int rd_len;

1329

int rd_len;

1330

int err;

1330

int err;

1331

int hlen;

1331

int hlen;

1332

u8 ha_buf[MAX_ADDR_LEN], *ha = NULL;

1332

u8 ha_buf[MAX_ADDR_LEN], *ha = NULL;

1333

1334

dev = skb->dev;

1334

dev = skb->dev;

1335

1336

if (ipv6_get_lladdr(dev, &saddr_buf)) {

1336

if (ipv6_get_lladdr(dev, &saddr_buf)) {

1337

ND_PRINTK2(KERN_WARNING

1337

ND_PRINTK2(KERN_WARNING

1338

"ICMPv6 Redirect: no link-local address on %s\n",

1338

"ICMPv6 Redirect: no link-local address on %s\n",

1339

dev->name);

1339

dev->name);

1340

return;

1340

return;

1341

}

1341

}

1342

1343

ndisc_flow_init(&fl, NDISC_REDIRECT, &saddr_buf, &skb->nh.ipv6h->saddr);

1343

ndisc_flow_init(&fl, NDISC_REDIRECT, &saddr_buf, &skb->nh.ipv6h->saddr);

1344

1345

dst = ip6_route_output(NULL, &fl);

1345

dst = ip6_route_output(NULL, &fl);

1346

if (dst == NULL)

1346

if (dst == NULL)

1347

return;

1347

return;

1348

1349

err = xfrm_lookup(&dst, &fl, NULL, 0);

1349

err = xfrm_lookup(&dst, &fl, NULL, 0);

1350

if (err)

1350

if (err)

1351

return;

1351

return;

1352

1353

rt = (struct rt6_info *) dst;

1353

rt = (struct rt6_info *) dst;

1354

1355

if (rt->rt6i_flags & RTF_GATEWAY) {

1355

if (rt->rt6i_flags & RTF_GATEWAY) {

1356

ND_PRINTK2(KERN_WARNING

1356

ND_PRINTK2(KERN_WARNING

1357

"ICMPv6 Redirect: destination is not a neighbour.\n");

1357

"ICMPv6 Redirect: destination is not a neighbour.\n");

1358

dst_release(dst);

1358

dst_release(dst);

1359

return;

1359

return;

1360

}

1360

}

1361

if (!xrlim_allow(dst, 1*HZ)) {

1361

if (!xrlim_allow(dst, 1*HZ)) {

1362

dst_release(dst);

1362

dst_release(dst);

1363

return;

1363

return;

1364

}

1364

}

1365

1366

if (dev->addr_len) {

1366

if (dev->addr_len) {

1367

read_lock_bh(&neigh->lock);

1367

read_lock_bh(&neigh->lock);

1368

if (neigh->nud_state & NUD_VALID) {

1368

if (neigh->nud_state & NUD_VALID) {

1369

memcpy(ha_buf, neigh->ha, dev->addr_len);

1369

memcpy(ha_buf, neigh->ha, dev->addr_len);

1370

read_unlock_bh(&neigh->lock);

1370

read_unlock_bh(&neigh->lock);

1371

ha = ha_buf;

1371

ha = ha_buf;

1372

len += ndisc_opt_addr_space(dev);

1372

len += ndisc_opt_addr_space(dev);

1373

} else

1373

} else

1374

read_unlock_bh(&neigh->lock);

1374

read_unlock_bh(&neigh->lock);

1375

}

1375

}

1376

1377

rd_len = min_t(unsigned int,

1377

rd_len = min_t(unsigned int,

1378

IPV6_MIN_MTU-sizeof(struct ipv6hdr)-len, skb->len + 8);

1378

IPV6_MIN_MTU-sizeof(struct ipv6hdr)-len, skb->len + 8);

1379

rd_len &= ~0x7;

1379

rd_len &= ~0x7;

1380

len += rd_len;

1380

len += rd_len;

1381

1382

buff = sock_alloc_send_skb(sk, MAX_HEADER + len + LL_RESERVED_SPACE(dev),

1382

buff = sock_alloc_send_skb(sk, MAX_HEADER + len + LL_RESERVED_SPACE(dev),

1383

1, &err);

1383

1, &err);

1384

if (buff == NULL) {

1384

if (buff == NULL) {

1385

ND_PRINTK0(KERN_ERR

1385

ND_PRINTK0(KERN_ERR

1386

"ICMPv6 Redirect: %s() failed to allocate an skb.\n",

1386

"ICMPv6 Redirect: %s() failed to allocate an skb.\n",

1387

__FUNCTION__);

1387

__FUNCTION__);

1388

dst_release(dst);

1388

dst_release(dst);

1389

return;

1389

return;

1390

}

1390

}

1391

1392

hlen = 0;

1392

hlen = 0;

1393

1394

skb_reserve(buff, LL_RESERVED_SPACE(dev));

1394

skb_reserve(buff, LL_RESERVED_SPACE(dev));

1395

ip6_nd_hdr(sk, buff, dev, &saddr_buf, &skb->nh.ipv6h->saddr,

1395

ip6_nd_hdr(sk, buff, dev, &saddr_buf, &skb->nh.ipv6h->saddr,

1396

IPPROTO_ICMPV6, len);

1396

IPPROTO_ICMPV6, len);

1397

1398

icmph = (struct icmp6hdr *)skb_put(buff, len);

1398

icmph = (struct icmp6hdr *)skb_put(buff, len);

1399

buff->h.raw = (unsigned char*)icmph;

1399

buff->h.raw = (unsigned char*)icmph;

1400

1401

memset(icmph, 0, sizeof(struct icmp6hdr));

1401

memset(icmph, 0, sizeof(struct icmp6hdr));

1402

icmph->icmp6_type = NDISC_REDIRECT;

1402

icmph->icmp6_type = NDISC_REDIRECT;

1403

1404

/*

1404

/*

1405

* copy target and destination addresses

1405

* copy target and destination addresses

1406

*/

1406

*/

1407

1408

addrp = (struct in6_addr *)(icmph + 1);

1408

addrp = (struct in6_addr *)(icmph + 1);

1409

ipv6_addr_copy(addrp, target);

1409

ipv6_addr_copy(addrp, target);

1410

addrp++;

1410

addrp++;

1411

ipv6_addr_copy(addrp, &skb->nh.ipv6h->daddr);

1411

ipv6_addr_copy(addrp, &skb->nh.ipv6h->daddr);

1412

1413

opt = (u8*) (addrp + 1);

1413

opt = (u8*) (addrp + 1);

1414

1415

/*

1415

/*

1416

* include target_address option

1416

* include target_address option

1417

*/

1417

*/

1418

1419

if (ha)

1419

if (ha)

1420

opt = ndisc_fill_addr_option(opt, ND_OPT_TARGET_LL_ADDR, ha,

1420

opt = ndisc_fill_addr_option(opt, ND_OPT_TARGET_LL_ADDR, ha,

1421

dev->addr_len, dev->type);

1421

dev->addr_len, dev->type);

1422

1423

/*

1423

/*

1424

* build redirect option and copy skb over to the new packet.

1424

* build redirect option and copy skb over to the new packet.

1425

*/

1425

*/

1426

1427

memset(opt, 0, 8);

1427

memset(opt, 0, 8);

1428

*(opt++) = ND_OPT_REDIRECT_HDR;

1428

*(opt++) = ND_OPT_REDIRECT_HDR;

1429

*(opt++) = (rd_len >> 3);

1429

*(opt++) = (rd_len >> 3);

1430

opt += 6;

1430

opt += 6;

1431

1432

memcpy(opt, skb->nh.ipv6h, rd_len - 8);

1432

memcpy(opt, skb->nh.ipv6h, rd_len - 8);

1433

1434

icmph->icmp6_cksum = csum_ipv6_magic(&saddr_buf, &skb->nh.ipv6h->saddr,

1434

icmph->icmp6_cksum = csum_ipv6_magic(&saddr_buf, &skb->nh.ipv6h->saddr,

1435

len, IPPROTO_ICMPV6,

1435

len, IPPROTO_ICMPV6,

1436

csum_partial((u8 *) icmph, len, 0));

1436

csum_partial((u8 *) icmph, len, 0));

1437

1438

buff->dst = dst;

1438

buff->dst = dst;

1439

idev = in6_dev_get(dst->dev);

1439

idev = in6_dev_get(dst->dev);

1440

IP6_INC_STATS(IPSTATS_MIB_OUTREQUESTS);

1440

IP6_INC_STATS(IPSTATS_MIB_OUTREQUESTS);

1441

err = NF_HOOK(PF_INET6, NF_IP6_LOCAL_OUT, buff, NULL, dst->dev, dst_output);

1441

err = NF_HOOK(PF_INET6, NF_IP6_LOCAL_OUT, buff, NULL, dst->dev, dst_output);

1442

if (!err) {

1442

if (!err) {

1443

ICMP6_INC_STATS(idev, ICMP6_MIB_OUTREDIRECTS);

1443

ICMP6_INC_STATS(idev, ICMP6_MIB_OUTREDIRECTS);

1444

ICMP6_INC_STATS(idev, ICMP6_MIB_OUTMSGS);

1444

ICMP6_INC_STATS(idev, ICMP6_MIB_OUTMSGS);

1445

}

1445

}

1446

1447

if (likely(idev != NULL))

1447

if (likely(idev != NULL))

1448

in6_dev_put(idev);

1448

in6_dev_put(idev);

1449

}

1449

}

1450

1451

static void pndisc_redo(struct sk_buff *skb)

1451

static void pndisc_redo(struct sk_buff *skb)

1452

{

1452

{

1453

ndisc_rcv(skb);

1453

ndisc_recv_ns(skb);

1454

kfree_skb(skb);

1454

kfree_skb(skb);

1455

}

1455

}

1456

1457

int ndisc_rcv(struct sk_buff *skb)

1457

int ndisc_rcv(struct sk_buff *skb)

1458

{

1458

{

1459

struct nd_msg *msg;

1459

struct nd_msg *msg;

1460

1461

if (!pskb_may_pull(skb, skb->len))

1461

if (!pskb_may_pull(skb, skb->len))

1462

return 0;

1462

return 0;

1463

1464

msg = (struct nd_msg *) skb->h.raw;

1464

msg = (struct nd_msg *) skb->h.raw;

1465

1466

__skb_push(skb, skb->data-skb->h.raw);

1466

__skb_push(skb, skb->data-skb->h.raw);

1467

1468

if (skb->nh.ipv6h->hop_limit != 255) {

1468

if (skb->nh.ipv6h->hop_limit != 255) {

1469

ND_PRINTK2(KERN_WARNING

1469

ND_PRINTK2(KERN_WARNING

1470

"ICMPv6 NDISC: invalid hop-limit: %d\n",

1470

"ICMPv6 NDISC: invalid hop-limit: %d\n",

1471

skb->nh.ipv6h->hop_limit);

1471

skb->nh.ipv6h->hop_limit);

1472

return 0;

1472

return 0;

1473

}

1473

}

1474

1475

if (msg->icmph.icmp6_code != 0) {

1475

if (msg->icmph.icmp6_code != 0) {

1476

ND_PRINTK2(KERN_WARNING

1476

ND_PRINTK2(KERN_WARNING

1477

"ICMPv6 NDISC: invalid ICMPv6 code: %d\n",

1477

"ICMPv6 NDISC: invalid ICMPv6 code: %d\n",

1478

msg->icmph.icmp6_code);

1478

msg->icmph.icmp6_code);

1479

return 0;

1479

return 0;

1480

}

1480

}

1481

1482

memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb));

1482

memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb));

1483

1484

switch (msg->icmph.icmp6_type) {

1484

switch (msg->icmph.icmp6_type) {

1485

case NDISC_NEIGHBOUR_SOLICITATION:

1485

case NDISC_NEIGHBOUR_SOLICITATION:

1486

ndisc_recv_ns(skb);

1486

ndisc_recv_ns(skb);

1487

break;

1487

break;

1488

1489

case NDISC_NEIGHBOUR_ADVERTISEMENT:

1489

case NDISC_NEIGHBOUR_ADVERTISEMENT:

1490

ndisc_recv_na(skb);

1490

ndisc_recv_na(skb);

1491

break;

1491

break;

1492

1493

case NDISC_ROUTER_SOLICITATION:

1493

case NDISC_ROUTER_SOLICITATION:

1494

ndisc_recv_rs(skb);

1494

ndisc_recv_rs(skb);

1495

break;

1495

break;

1496

1497

case NDISC_ROUTER_ADVERTISEMENT:

1497

case NDISC_ROUTER_ADVERTISEMENT:

1498

ndisc_router_discovery(skb);

1498

ndisc_router_discovery(skb);

1499

break;

1499

break;

1500

1501

case NDISC_REDIRECT:

1501

case NDISC_REDIRECT:

1502

ndisc_redirect_rcv(skb);

1502

ndisc_redirect_rcv(skb);

1503

break;

1503

break;

1504

};

1504

};

1505

1506

return 0;

1506

return 0;

1507

}

1507

}

1508

1509

static int ndisc_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)

1509

static int ndisc_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)

1510

{

1510

{

1511

struct net_device *dev = ptr;

1511

struct net_device *dev = ptr;

1512

1513

switch (event) {

1513

switch (event) {

1514

case NETDEV_CHANGEADDR:

1514

case NETDEV_CHANGEADDR:

1515

neigh_changeaddr(&nd_tbl, dev);

1515

neigh_changeaddr(&nd_tbl, dev);

1516

fib6_run_gc(~0UL);

1516

fib6_run_gc(~0UL);

1517

break;

1517

break;

1518

case NETDEV_DOWN:

1518

case NETDEV_DOWN:

1519

neigh_ifdown(&nd_tbl, dev);

1519

neigh_ifdown(&nd_tbl, dev);

1520

fib6_run_gc(~0UL);

1520

fib6_run_gc(~0UL);

1521

break;

1521

break;

1522

default:

1522

default:

1523

break;

1523

break;

1524

}

1524

}

1525

1526

return NOTIFY_DONE;

1526

return NOTIFY_DONE;

1527

}

1527

}

1528

1529

static struct notifier_block ndisc_netdev_notifier = {

1529

static struct notifier_block ndisc_netdev_notifier = {

1530

.notifier_call = ndisc_netdev_event,

1530

.notifier_call = ndisc_netdev_event,

1531

};

1531

};

1532

1533

#ifdef CONFIG_SYSCTL

1533

#ifdef CONFIG_SYSCTL

1534

static void ndisc_warn_deprecated_sysctl(struct ctl_table *ctl,

1534

static void ndisc_warn_deprecated_sysctl(struct ctl_table *ctl,

1535

const char *func, const char *dev_name)

1535

const char *func, const char *dev_name)

1536

{

1536

{

1537

static char warncomm[TASK_COMM_LEN];

1537

static char warncomm[TASK_COMM_LEN];

1538

static int warned;

1538

static int warned;

1539

if (strcmp(warncomm, current->comm) && warned < 5) {

1539

if (strcmp(warncomm, current->comm) && warned < 5) {

1540

strcpy(warncomm, current->comm);

1540

strcpy(warncomm, current->comm);

1541

printk(KERN_WARNING

1541

printk(KERN_WARNING

1542

"process `%s' is using deprecated sysctl (%s) "

1542

"process `%s' is using deprecated sysctl (%s) "

1543

"net.ipv6.neigh.%s.%s; "

1543

"net.ipv6.neigh.%s.%s; "

1544

"Use net.ipv6.neigh.%s.%s_ms "

1544

"Use net.ipv6.neigh.%s.%s_ms "

1545

"instead.\n",

1545

"instead.\n",

1546

warncomm, func,

1546

warncomm, func,

1547

dev_name, ctl->procname,

1547

dev_name, ctl->procname,

1548

dev_name, ctl->procname);

1548

dev_name, ctl->procname);

1549

warned++;

1549

warned++;

1550

}

1550

}

1551

}

1551

}

1552

1553

int ndisc_ifinfo_sysctl_change(struct ctl_table *ctl, int write, struct file * filp, void __user *buffer, size_t *lenp, loff_t *ppos)

1553

int ndisc_ifinfo_sysctl_change(struct ctl_table *ctl, int write, struct file * filp, void __user *buffer, size_t *lenp, loff_t *ppos)

1554

{

1554

{

1555

struct net_device *dev = ctl->extra1;

1555

struct net_device *dev = ctl->extra1;

1556

struct inet6_dev *idev;

1556

struct inet6_dev *idev;

1557

int ret;

1557

int ret;

1558

1559

if (ctl->ctl_name == NET_NEIGH_RETRANS_TIME ||

1559

if (ctl->ctl_name == NET_NEIGH_RETRANS_TIME ||

1560

ctl->ctl_name == NET_NEIGH_REACHABLE_TIME)

1560

ctl->ctl_name == NET_NEIGH_REACHABLE_TIME)

1561

ndisc_warn_deprecated_sysctl(ctl, "syscall", dev ? dev->name : "default");

1561

ndisc_warn_deprecated_sysctl(ctl, "syscall", dev ? dev->name : "default");

1562

1563

switch (ctl->ctl_name) {

1563

switch (ctl->ctl_name) {

1564

case NET_NEIGH_RETRANS_TIME:

1564

case NET_NEIGH_RETRANS_TIME:

1565

ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);

1565

ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);

1566

break;

1566

break;

1567

case NET_NEIGH_REACHABLE_TIME:

1567

case NET_NEIGH_REACHABLE_TIME:

1568

ret = proc_dointvec_jiffies(ctl, write,

1568

ret = proc_dointvec_jiffies(ctl, write,

1569

filp, buffer, lenp, ppos);

1569

filp, buffer, lenp, ppos);

1570

break;

1570

break;

1571

case NET_NEIGH_RETRANS_TIME_MS:

1571

case NET_NEIGH_RETRANS_TIME_MS:

1572

case NET_NEIGH_REACHABLE_TIME_MS:

1572

case NET_NEIGH_REACHABLE_TIME_MS:

1573

ret = proc_dointvec_ms_jiffies(ctl, write,

1573

ret = proc_dointvec_ms_jiffies(ctl, write,

1574

filp, buffer, lenp, ppos);

1574

filp, buffer, lenp, ppos);

1575

break;

1575

break;

1576

default:

1576

default:

1577

ret = -1;

1577

ret = -1;

1578

}

1578

}

1579

1580

if (write && ret == 0 && dev && (idev = in6_dev_get(dev)) != NULL) {

1580

if (write && ret == 0 && dev && (idev = in6_dev_get(dev)) != NULL) {

1581

if (ctl->ctl_name == NET_NEIGH_REACHABLE_TIME ||

1581

if (ctl->ctl_name == NET_NEIGH_REACHABLE_TIME ||

1582

ctl->ctl_name == NET_NEIGH_REACHABLE_TIME_MS)

1582

ctl->ctl_name == NET_NEIGH_REACHABLE_TIME_MS)

1583

idev->nd_parms->reachable_time = neigh_rand_reach_time(idev->nd_parms->base_reachable_time);

1583

idev->nd_parms->reachable_time = neigh_rand_reach_time(idev->nd_parms->base_reachable_time);

1584

idev->tstamp = jiffies;

1584

idev->tstamp = jiffies;

1585

inet6_ifinfo_notify(RTM_NEWLINK, idev);

1585

inet6_ifinfo_notify(RTM_NEWLINK, idev);

1586

in6_dev_put(idev);

1586

in6_dev_put(idev);

1587

}

1587

}

1588

return ret;

1588

return ret;

1589

}

1589

}

1590

1591

static int ndisc_ifinfo_sysctl_strategy(ctl_table *ctl, int __user *name,

1591

static int ndisc_ifinfo_sysctl_strategy(ctl_table *ctl, int __user *name,

1592

int nlen, void __user *oldval,

1592

int nlen, void __user *oldval,

1593

size_t __user *oldlenp,

1593

size_t __user *oldlenp,

1594

void __user *newval, size_t newlen,

1594

void __user *newval, size_t newlen,

1595

void **context)

1595

void **context)

1596

{

1596

{

1597

struct net_device *dev = ctl->extra1;

1597

struct net_device *dev = ctl->extra1;

1598

struct inet6_dev *idev;

1598

struct inet6_dev *idev;

1599

int ret;

1599

int ret;

1600

1601

if (ctl->ctl_name == NET_NEIGH_RETRANS_TIME ||

1601

if (ctl->ctl_name == NET_NEIGH_RETRANS_TIME ||

1602

ctl->ctl_name == NET_NEIGH_REACHABLE_TIME)

1602

ctl->ctl_name == NET_NEIGH_REACHABLE_TIME)

1603

ndisc_warn_deprecated_sysctl(ctl, "procfs", dev ? dev->name : "default");

1603

ndisc_warn_deprecated_sysctl(ctl, "procfs", dev ? dev->name : "default");

1604

1605

switch (ctl->ctl_name) {

1605

switch (ctl->ctl_name) {

1606

case NET_NEIGH_REACHABLE_TIME:

1606

case NET_NEIGH_REACHABLE_TIME:

1607

ret = sysctl_jiffies(ctl, name, nlen,

1607

ret = sysctl_jiffies(ctl, name, nlen,

1608

oldval, oldlenp, newval, newlen,

1608

oldval, oldlenp, newval, newlen,

1609

context);

1609

context);

1610

break;

1610

break;

1611

case NET_NEIGH_RETRANS_TIME_MS:

1611

case NET_NEIGH_RETRANS_TIME_MS:

1612

case NET_NEIGH_REACHABLE_TIME_MS:

1612

case NET_NEIGH_REACHABLE_TIME_MS:

1613

ret = sysctl_ms_jiffies(ctl, name, nlen,

1613

ret = sysctl_ms_jiffies(ctl, name, nlen,

1614

oldval, oldlenp, newval, newlen,

1614

oldval, oldlenp, newval, newlen,

1615

context);

1615

context);

1616

break;

1616

break;

1617

default:

1617

default:

1618

ret = 0;

1618

ret = 0;

1619

}

1619

}

1620

1621

if (newval && newlen && ret > 0 &&

1621

if (newval && newlen && ret > 0 &&

1622

dev && (idev = in6_dev_get(dev)) != NULL) {

1622

dev && (idev = in6_dev_get(dev)) != NULL) {

1623

if (ctl->ctl_name == NET_NEIGH_REACHABLE_TIME ||

1623

if (ctl->ctl_name == NET_NEIGH_REACHABLE_TIME ||

1624

ctl->ctl_name == NET_NEIGH_REACHABLE_TIME_MS)

1624

ctl->ctl_name == NET_NEIGH_REACHABLE_TIME_MS)

1625

idev->nd_parms->reachable_time = neigh_rand_reach_time(idev->nd_parms->base_reachable_time);

1625

idev->nd_parms->reachable_time = neigh_rand_reach_time(idev->nd_parms->base_reachable_time);

1626

idev->tstamp = jiffies;

1626

idev->tstamp = jiffies;

1627

inet6_ifinfo_notify(RTM_NEWLINK, idev);

1627

inet6_ifinfo_notify(RTM_NEWLINK, idev);

1628

in6_dev_put(idev);

1628

in6_dev_put(idev);

1629

}

1629

}

1630

1631

return ret;

1631

return ret;

1632

}

1632

}

1633

1634

#endif

1634

#endif

1635

1636

int __init ndisc_init(struct net_proto_family *ops)

1636

int __init ndisc_init(struct net_proto_family *ops)

1637

{

1637

{

1638

struct ipv6_pinfo *np;

1638

struct ipv6_pinfo *np;

1639

struct sock *sk;

1639

struct sock *sk;

1640

int err;

1640

int err;

1641

1642

err = sock_create_kern(PF_INET6, SOCK_RAW, IPPROTO_ICMPV6, &ndisc_socket);

1642

err = sock_create_kern(PF_INET6, SOCK_RAW, IPPROTO_ICMPV6, &ndisc_socket);

1643

if (err < 0) {

1643

if (err < 0) {

1644

ND_PRINTK0(KERN_ERR

1644

ND_PRINTK0(KERN_ERR

1645

"ICMPv6 NDISC: Failed to initialize the control socket (err %d).\n",

1645

"ICMPv6 NDISC: Failed to initialize the control socket (err %d).\n",

1646

err);

1646

err);

1647

ndisc_socket = NULL; /* For safety. */

1647

ndisc_socket = NULL; /* For safety. */

1648

return err;

1648

return err;

1649

}

1649

}

1650

1651

sk = ndisc_socket->sk;

1651

sk = ndisc_socket->sk;

1652

np = inet6_sk(sk);

1652

np = inet6_sk(sk);

1653

sk->sk_allocation = GFP_ATOMIC;

1653

sk->sk_allocation = GFP_ATOMIC;

1654

np->hop_limit = 255;

1654

np->hop_limit = 255;

1655

/* Do not loopback ndisc messages */

1655

/* Do not loopback ndisc messages */

1656

np->mc_loop = 0;

1656

np->mc_loop = 0;

1657

sk->sk_prot->unhash(sk);

1657

sk->sk_prot->unhash(sk);

1658

1659

/*

1659

/*

1660

* Initialize the neighbour table

1660

* Initialize the neighbour table

1661

*/

1661

*/

1662

1663

neigh_table_init(&nd_tbl);

1663

neigh_table_init(&nd_tbl);

1664

1665

#ifdef CONFIG_SYSCTL

1665

#ifdef CONFIG_SYSCTL

1666

neigh_sysctl_register(NULL, &nd_tbl.parms, NET_IPV6, NET_IPV6_NEIGH,

1666

neigh_sysctl_register(NULL, &nd_tbl.parms, NET_IPV6, NET_IPV6_NEIGH,

1667

"ipv6",

1667

"ipv6",

1668

&ndisc_ifinfo_sysctl_change,

1668

&ndisc_ifinfo_sysctl_change,

1669

&ndisc_ifinfo_sysctl_strategy);

1669

&ndisc_ifinfo_sysctl_strategy);

1670

#endif

1670

#endif

1671

1672

register_netdevice_notifier(&ndisc_netdev_notifier);

1672

register_netdevice_notifier(&ndisc_netdev_notifier);

1673

return 0;

1673

return 0;

1674

}

1674

}

1675

1676

void ndisc_cleanup(void)

1676

void ndisc_cleanup(void)

1677

{

1677

{

1678

#ifdef CONFIG_SYSCTL

1678

#ifdef CONFIG_SYSCTL

1679

neigh_sysctl_unregister(&nd_tbl.parms);

1679

neigh_sysctl_unregister(&nd_tbl.parms);

1680

#endif

1680

#endif

1681

neigh_table_clear(&nd_tbl);

1681

neigh_table_clear(&nd_tbl);

1682

sock_release(ndisc_socket);

1682

sock_release(ndisc_socket);

1683

ndisc_socket = NULL; /* For safety. */

1683

ndisc_socket = NULL; /* For safety. */

1684

}

1684

}

1685

GITLAB

[IPV6]: Fix NS handing for proxy/anycast address