Eric Lee / smarc-ti-linux-kernel

1

/*

1

/*

2

* Linux INET6 implementation

2

* Linux INET6 implementation

3

* FIB front-end.

3

* FIB front-end.

4

*

4

*

5

* Authors:

5

* Authors:

6

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

6

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

7

*

7

*

8

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

8

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

9

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

9

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

10

* as published by the Free Software Foundation; either version

10

* as published by the Free Software Foundation; either version

11

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

11

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

12

*/

12

*/

13

14

/* Changes:

14

/* Changes:

15

*

15

*

16

* YOSHIFUJI Hideaki @USAGI

16

* YOSHIFUJI Hideaki @USAGI

17

* reworked default router selection.

17

* reworked default router selection.

18

* - respect outgoing interface

18

* - respect outgoing interface

19

* - select from (probably) reachable routers (i.e.

19

* - select from (probably) reachable routers (i.e.

20

* routers in REACHABLE, STALE, DELAY or PROBE states).

20

* routers in REACHABLE, STALE, DELAY or PROBE states).

21

* - always select the same router if it is (probably)

21

* - always select the same router if it is (probably)

22

* reachable. otherwise, round-robin the list.

22

* reachable. otherwise, round-robin the list.

23

* Ville Nuorvala

23

* Ville Nuorvala

24

* Fixed routing subtrees.

24

* Fixed routing subtrees.

25

*/

25

*/

26

27

#define pr_fmt(fmt) "IPv6: " fmt

27

#define pr_fmt(fmt) "IPv6: " fmt

28

29

#include <linux/capability.h>

29

#include <linux/capability.h>

30

#include <linux/errno.h>

30

#include <linux/errno.h>

31

#include <linux/export.h>

31

#include <linux/export.h>

32

#include <linux/types.h>

32

#include <linux/types.h>

33

#include <linux/times.h>

33

#include <linux/times.h>

34

#include <linux/socket.h>

34

#include <linux/socket.h>

35

#include <linux/sockios.h>

35

#include <linux/sockios.h>

36

#include <linux/net.h>

36

#include <linux/net.h>

37

#include <linux/route.h>

37

#include <linux/route.h>

38

#include <linux/netdevice.h>

38

#include <linux/netdevice.h>

39

#include <linux/in6.h>

39

#include <linux/in6.h>

40

#include <linux/mroute6.h>

40

#include <linux/mroute6.h>

41

#include <linux/init.h>

41

#include <linux/init.h>

42

#include <linux/if_arp.h>

42

#include <linux/if_arp.h>

43

#include <linux/proc_fs.h>

43

#include <linux/proc_fs.h>

44

#include <linux/seq_file.h>

44

#include <linux/seq_file.h>

45

#include <linux/nsproxy.h>

45

#include <linux/nsproxy.h>

46

#include <linux/slab.h>

46

#include <linux/slab.h>

47

#include <net/net_namespace.h>

47

#include <net/net_namespace.h>

48

#include <net/snmp.h>

48

#include <net/snmp.h>

49

#include <net/ipv6.h>

49

#include <net/ipv6.h>

50

#include <net/ip6_fib.h>

50

#include <net/ip6_fib.h>

51

#include <net/ip6_route.h>

51

#include <net/ip6_route.h>

52

#include <net/ndisc.h>

52

#include <net/ndisc.h>

53

#include <net/addrconf.h>

53

#include <net/addrconf.h>

54

#include <net/tcp.h>

54

#include <net/tcp.h>

55

#include <linux/rtnetlink.h>

55

#include <linux/rtnetlink.h>

56

#include <net/dst.h>

56

#include <net/dst.h>

57

#include <net/xfrm.h>

57

#include <net/xfrm.h>

58

#include <net/netevent.h>

58

#include <net/netevent.h>

59

#include <net/netlink.h>

59

#include <net/netlink.h>

60

#include <net/nexthop.h>

60

#include <net/nexthop.h>

61

62

#include <asm/uaccess.h>

62

#include <asm/uaccess.h>

63

64

#ifdef CONFIG_SYSCTL

64

#ifdef CONFIG_SYSCTL

65

#include <linux/sysctl.h>

65

#include <linux/sysctl.h>

66

#endif

66

#endif

67

68

enum rt6_nud_state {

68

enum rt6_nud_state {

69

RT6_NUD_FAIL_HARD = -3,

69

RT6_NUD_FAIL_HARD = -3,

70

RT6_NUD_FAIL_PROBE = -2,

70

RT6_NUD_FAIL_PROBE = -2,

71

RT6_NUD_FAIL_DO_RR = -1,

71

RT6_NUD_FAIL_DO_RR = -1,

72

RT6_NUD_SUCCEED = 1

72

RT6_NUD_SUCCEED = 1

73

};

73

};

74

75

static struct rt6_info *ip6_rt_copy(struct rt6_info *ort,

75

static struct rt6_info *ip6_rt_copy(struct rt6_info *ort,

76

const struct in6_addr *dest);

76

const struct in6_addr *dest);

77

static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie);

77

static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie);

78

static unsigned int ip6_default_advmss(const struct dst_entry *dst);

78

static unsigned int ip6_default_advmss(const struct dst_entry *dst);

79

static unsigned int ip6_mtu(const struct dst_entry *dst);

79

static unsigned int ip6_mtu(const struct dst_entry *dst);

80

static struct dst_entry *ip6_negative_advice(struct dst_entry *);

80

static struct dst_entry *ip6_negative_advice(struct dst_entry *);

81

static void ip6_dst_destroy(struct dst_entry *);

81

static void ip6_dst_destroy(struct dst_entry *);

82

static void ip6_dst_ifdown(struct dst_entry *,

82

static void ip6_dst_ifdown(struct dst_entry *,

83

struct net_device *dev, int how);

83

struct net_device *dev, int how);

84

static int ip6_dst_gc(struct dst_ops *ops);

84

static int ip6_dst_gc(struct dst_ops *ops);

85

86

static int ip6_pkt_discard(struct sk_buff *skb);

86

static int ip6_pkt_discard(struct sk_buff *skb);

87

static int ip6_pkt_discard_out(struct sock *sk, struct sk_buff *skb);

87

static int ip6_pkt_discard_out(struct sock *sk, struct sk_buff *skb);

88

static int ip6_pkt_prohibit(struct sk_buff *skb);

88

static int ip6_pkt_prohibit(struct sk_buff *skb);

89

static int ip6_pkt_prohibit_out(struct sock *sk, struct sk_buff *skb);

89

static int ip6_pkt_prohibit_out(struct sock *sk, struct sk_buff *skb);

90

static void ip6_link_failure(struct sk_buff *skb);

90

static void ip6_link_failure(struct sk_buff *skb);

91

static void ip6_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,

91

static void ip6_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,

92

struct sk_buff *skb, u32 mtu);

92

struct sk_buff *skb, u32 mtu);

93

static void rt6_do_redirect(struct dst_entry *dst, struct sock *sk,

93

static void rt6_do_redirect(struct dst_entry *dst, struct sock *sk,

94

struct sk_buff *skb);

94

struct sk_buff *skb);

95

static int rt6_score_route(struct rt6_info *rt, int oif, int strict);

95

static int rt6_score_route(struct rt6_info *rt, int oif, int strict);

96

97

#ifdef CONFIG_IPV6_ROUTE_INFO

97

#ifdef CONFIG_IPV6_ROUTE_INFO

98

static struct rt6_info *rt6_add_route_info(struct net *net,

98

static struct rt6_info *rt6_add_route_info(struct net *net,

99

const struct in6_addr *prefix, int prefixlen,

99

const struct in6_addr *prefix, int prefixlen,

100

const struct in6_addr *gwaddr, int ifindex,

100

const struct in6_addr *gwaddr, int ifindex,

101

unsigned int pref);

101

unsigned int pref);

102

static struct rt6_info *rt6_get_route_info(struct net *net,

102

static struct rt6_info *rt6_get_route_info(struct net *net,

103

const struct in6_addr *prefix, int prefixlen,

103

const struct in6_addr *prefix, int prefixlen,

104

const struct in6_addr *gwaddr, int ifindex);

104

const struct in6_addr *gwaddr, int ifindex);

105

#endif

105

#endif

106

107

static void rt6_bind_peer(struct rt6_info *rt, int create)

107

static void rt6_bind_peer(struct rt6_info *rt, int create)

108

{

108

{

109

struct inet_peer_base *base;

109

struct inet_peer_base *base;

110

struct inet_peer *peer;

110

struct inet_peer *peer;

111

112

base = inetpeer_base_ptr(rt->_rt6i_peer);

112

base = inetpeer_base_ptr(rt->_rt6i_peer);

113

if (!base)

113

if (!base)

114

return;

114

return;

115

116

peer = inet_getpeer_v6(base, &rt->rt6i_dst.addr, create);

116

peer = inet_getpeer_v6(base, &rt->rt6i_dst.addr, create);

117

if (peer) {

117

if (peer) {

118

if (!rt6_set_peer(rt, peer))

118

if (!rt6_set_peer(rt, peer))

119

inet_putpeer(peer);

119

inet_putpeer(peer);

120

}

120

}

121

}

121

}

122

123

static struct inet_peer *__rt6_get_peer(struct rt6_info *rt, int create)

123

static struct inet_peer *__rt6_get_peer(struct rt6_info *rt, int create)

124

{

124

{

125

if (rt6_has_peer(rt))

125

if (rt6_has_peer(rt))

126

return rt6_peer_ptr(rt);

126

return rt6_peer_ptr(rt);

127

128

rt6_bind_peer(rt, create);

128

rt6_bind_peer(rt, create);

129

return (rt6_has_peer(rt) ? rt6_peer_ptr(rt) : NULL);

129

return (rt6_has_peer(rt) ? rt6_peer_ptr(rt) : NULL);

130

}

130

}

131

132

static struct inet_peer *rt6_get_peer_create(struct rt6_info *rt)

132

static struct inet_peer *rt6_get_peer_create(struct rt6_info *rt)

133

{

133

{

134

return __rt6_get_peer(rt, 1);

134

return __rt6_get_peer(rt, 1);

135

}

135

}

136

137

static u32 *ipv6_cow_metrics(struct dst_entry *dst, unsigned long old)

137

static u32 *ipv6_cow_metrics(struct dst_entry *dst, unsigned long old)

138

{

138

{

139

struct rt6_info *rt = (struct rt6_info *) dst;

139

struct rt6_info *rt = (struct rt6_info *) dst;

140

struct inet_peer *peer;

140

struct inet_peer *peer;

141

u32 *p = NULL;

141

u32 *p = NULL;

142

143

if (!(rt->dst.flags & DST_HOST))

143

if (!(rt->dst.flags & DST_HOST))

144

return NULL;

144

return NULL;

145

146

peer = rt6_get_peer_create(rt);

146

peer = rt6_get_peer_create(rt);

147

if (peer) {

147

if (peer) {

148

u32 *old_p = __DST_METRICS_PTR(old);

148

u32 *old_p = __DST_METRICS_PTR(old);

149

unsigned long prev, new;

149

unsigned long prev, new;

150

151

p = peer->metrics;

151

p = peer->metrics;

152

if (inet_metrics_new(peer) ||

152

if (inet_metrics_new(peer) ||

153

(old & DST_METRICS_FORCE_OVERWRITE))

153

(old & DST_METRICS_FORCE_OVERWRITE))

154

memcpy(p, old_p, sizeof(u32) * RTAX_MAX);

154

memcpy(p, old_p, sizeof(u32) * RTAX_MAX);

155

156

new = (unsigned long) p;

156

new = (unsigned long) p;

157

prev = cmpxchg(&dst->_metrics, old, new);

157

prev = cmpxchg(&dst->_metrics, old, new);

158

159

if (prev != old) {

159

if (prev != old) {

160

p = __DST_METRICS_PTR(prev);

160

p = __DST_METRICS_PTR(prev);

161

if (prev & DST_METRICS_READ_ONLY)

161

if (prev & DST_METRICS_READ_ONLY)

162

p = NULL;

162

p = NULL;

163

}

163

}

164

}

164

}

165

return p;

165

return p;

166

}

166

}

167

168

static inline const void *choose_neigh_daddr(struct rt6_info *rt,

168

static inline const void *choose_neigh_daddr(struct rt6_info *rt,

169

struct sk_buff *skb,

169

struct sk_buff *skb,

170

const void *daddr)

170

const void *daddr)

171

{

171

{

172

struct in6_addr *p = &rt->rt6i_gateway;

172

struct in6_addr *p = &rt->rt6i_gateway;

173

174

if (!ipv6_addr_any(p))

174

if (!ipv6_addr_any(p))

175

return (const void *) p;

175

return (const void *) p;

176

else if (skb)

176

else if (skb)

177

return &ipv6_hdr(skb)->daddr;

177

return &ipv6_hdr(skb)->daddr;

178

return daddr;

178

return daddr;

179

}

179

}

180

181

static struct neighbour *ip6_neigh_lookup(const struct dst_entry *dst,

181

static struct neighbour *ip6_neigh_lookup(const struct dst_entry *dst,

182

struct sk_buff *skb,

182

struct sk_buff *skb,

183

const void *daddr)

183

const void *daddr)

184

{

184

{

185

struct rt6_info *rt = (struct rt6_info *) dst;

185

struct rt6_info *rt = (struct rt6_info *) dst;

186

struct neighbour *n;

186

struct neighbour *n;

187

188

daddr = choose_neigh_daddr(rt, skb, daddr);

188

daddr = choose_neigh_daddr(rt, skb, daddr);

189

n = __ipv6_neigh_lookup(dst->dev, daddr);

189

n = __ipv6_neigh_lookup(dst->dev, daddr);

190

if (n)

190

if (n)

191

return n;

191

return n;

192

return neigh_create(&nd_tbl, daddr, dst->dev);

192

return neigh_create(&nd_tbl, daddr, dst->dev);

193

}

193

}

194

195

static struct dst_ops ip6_dst_ops_template = {

195

static struct dst_ops ip6_dst_ops_template = {

196

.family = AF_INET6,

196

.family = AF_INET6,

197

.protocol = cpu_to_be16(ETH_P_IPV6),

197

.protocol = cpu_to_be16(ETH_P_IPV6),

198

.gc = ip6_dst_gc,

198

.gc = ip6_dst_gc,

199

.gc_thresh = 1024,

199

.gc_thresh = 1024,

200

.check = ip6_dst_check,

200

.check = ip6_dst_check,

201

.default_advmss = ip6_default_advmss,

201

.default_advmss = ip6_default_advmss,

202

.mtu = ip6_mtu,

202

.mtu = ip6_mtu,

203

.cow_metrics = ipv6_cow_metrics,

203

.cow_metrics = ipv6_cow_metrics,

204

.destroy = ip6_dst_destroy,

204

.destroy = ip6_dst_destroy,

205

.ifdown = ip6_dst_ifdown,

205

.ifdown = ip6_dst_ifdown,

206

.negative_advice = ip6_negative_advice,

206

.negative_advice = ip6_negative_advice,

207

.link_failure = ip6_link_failure,

207

.link_failure = ip6_link_failure,

208

.update_pmtu = ip6_rt_update_pmtu,

208

.update_pmtu = ip6_rt_update_pmtu,

209

.redirect = rt6_do_redirect,

209

.redirect = rt6_do_redirect,

210

.local_out = __ip6_local_out,

210

.local_out = __ip6_local_out,

211

.neigh_lookup = ip6_neigh_lookup,

211

.neigh_lookup = ip6_neigh_lookup,

212

};

212

};

213

214

static unsigned int ip6_blackhole_mtu(const struct dst_entry *dst)

214

static unsigned int ip6_blackhole_mtu(const struct dst_entry *dst)

215

{

215

{

216

unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);

216

unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);

217

218

return mtu ? : dst->dev->mtu;

218

return mtu ? : dst->dev->mtu;

219

}

219

}

220

221

static void ip6_rt_blackhole_update_pmtu(struct dst_entry *dst, struct sock *sk,

221

static void ip6_rt_blackhole_update_pmtu(struct dst_entry *dst, struct sock *sk,

222

struct sk_buff *skb, u32 mtu)

222

struct sk_buff *skb, u32 mtu)

223

{

223

{

224

}

224

}

225

226

static void ip6_rt_blackhole_redirect(struct dst_entry *dst, struct sock *sk,

226

static void ip6_rt_blackhole_redirect(struct dst_entry *dst, struct sock *sk,

227

struct sk_buff *skb)

227

struct sk_buff *skb)

228

{

228

{

229

}

229

}

230

231

static u32 *ip6_rt_blackhole_cow_metrics(struct dst_entry *dst,

231

static u32 *ip6_rt_blackhole_cow_metrics(struct dst_entry *dst,

232

unsigned long old)

232

unsigned long old)

233

{

233

{

234

return NULL;

234

return NULL;

235

}

235

}

236

237

static struct dst_ops ip6_dst_blackhole_ops = {

237

static struct dst_ops ip6_dst_blackhole_ops = {

238

.family = AF_INET6,

238

.family = AF_INET6,

239

.protocol = cpu_to_be16(ETH_P_IPV6),

239

.protocol = cpu_to_be16(ETH_P_IPV6),

240

.destroy = ip6_dst_destroy,

240

.destroy = ip6_dst_destroy,

241

.check = ip6_dst_check,

241

.check = ip6_dst_check,

242

.mtu = ip6_blackhole_mtu,

242

.mtu = ip6_blackhole_mtu,

243

.default_advmss = ip6_default_advmss,

243

.default_advmss = ip6_default_advmss,

244

.update_pmtu = ip6_rt_blackhole_update_pmtu,

244

.update_pmtu = ip6_rt_blackhole_update_pmtu,

245

.redirect = ip6_rt_blackhole_redirect,

245

.redirect = ip6_rt_blackhole_redirect,

246

.cow_metrics = ip6_rt_blackhole_cow_metrics,

246

.cow_metrics = ip6_rt_blackhole_cow_metrics,

247

.neigh_lookup = ip6_neigh_lookup,

247

.neigh_lookup = ip6_neigh_lookup,

248

};

248

};

249

250

static const u32 ip6_template_metrics[RTAX_MAX] = {

250

static const u32 ip6_template_metrics[RTAX_MAX] = {

251

[RTAX_HOPLIMIT - 1] = 0,

251

[RTAX_HOPLIMIT - 1] = 0,

252

};

252

};

253

254

static const struct rt6_info ip6_null_entry_template = {

254

static const struct rt6_info ip6_null_entry_template = {

255

.dst = {

255

.dst = {

256

.__refcnt = ATOMIC_INIT(1),

256

.__refcnt = ATOMIC_INIT(1),

257

.__use = 1,

257

.__use = 1,

258

.obsolete = DST_OBSOLETE_FORCE_CHK,

258

.obsolete = DST_OBSOLETE_FORCE_CHK,

259

.error = -ENETUNREACH,

259

.error = -ENETUNREACH,

260

.input = ip6_pkt_discard,

260

.input = ip6_pkt_discard,

261

.output = ip6_pkt_discard_out,

261

.output = ip6_pkt_discard_out,

262

},

262

},

263

.rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),

263

.rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),

264

.rt6i_protocol = RTPROT_KERNEL,

264

.rt6i_protocol = RTPROT_KERNEL,

265

.rt6i_metric = ~(u32) 0,

265

.rt6i_metric = ~(u32) 0,

266

.rt6i_ref = ATOMIC_INIT(1),

266

.rt6i_ref = ATOMIC_INIT(1),

267

};

267

};

268

269

#ifdef CONFIG_IPV6_MULTIPLE_TABLES

269

#ifdef CONFIG_IPV6_MULTIPLE_TABLES

270

271

static const struct rt6_info ip6_prohibit_entry_template = {

271

static const struct rt6_info ip6_prohibit_entry_template = {

272

.dst = {

272

.dst = {

273

.__refcnt = ATOMIC_INIT(1),

273

.__refcnt = ATOMIC_INIT(1),

274

.__use = 1,

274

.__use = 1,

275

.obsolete = DST_OBSOLETE_FORCE_CHK,

275

.obsolete = DST_OBSOLETE_FORCE_CHK,

276

.error = -EACCES,

276

.error = -EACCES,

277

.input = ip6_pkt_prohibit,

277

.input = ip6_pkt_prohibit,

278

.output = ip6_pkt_prohibit_out,

278

.output = ip6_pkt_prohibit_out,

279

},

279

},

280

.rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),

280

.rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),

281

.rt6i_protocol = RTPROT_KERNEL,

281

.rt6i_protocol = RTPROT_KERNEL,

282

.rt6i_metric = ~(u32) 0,

282

.rt6i_metric = ~(u32) 0,

283

.rt6i_ref = ATOMIC_INIT(1),

283

.rt6i_ref = ATOMIC_INIT(1),

284

};

284

};

285

286

static const struct rt6_info ip6_blk_hole_entry_template = {

286

static const struct rt6_info ip6_blk_hole_entry_template = {

287

.dst = {

287

.dst = {

288

.__refcnt = ATOMIC_INIT(1),

288

.__refcnt = ATOMIC_INIT(1),

289

.__use = 1,

289

.__use = 1,

290

.obsolete = DST_OBSOLETE_FORCE_CHK,

290

.obsolete = DST_OBSOLETE_FORCE_CHK,

291

.error = -EINVAL,

291

.error = -EINVAL,

292

.input = dst_discard,

292

.input = dst_discard,

293

.output = dst_discard_sk,

293

.output = dst_discard_sk,

294

},

294

},

295

.rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),

295

.rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),

296

.rt6i_protocol = RTPROT_KERNEL,

296

.rt6i_protocol = RTPROT_KERNEL,

297

.rt6i_metric = ~(u32) 0,

297

.rt6i_metric = ~(u32) 0,

298

.rt6i_ref = ATOMIC_INIT(1),

298

.rt6i_ref = ATOMIC_INIT(1),

299

};

299

};

300

301

#endif

301

#endif

302

303

/* allocate dst with ip6_dst_ops */

303

/* allocate dst with ip6_dst_ops */

304

static inline struct rt6_info *ip6_dst_alloc(struct net *net,

304

static inline struct rt6_info *ip6_dst_alloc(struct net *net,

305

struct net_device *dev,

305

struct net_device *dev,

306

int flags,

306

int flags,

307

struct fib6_table *table)

307

struct fib6_table *table)

308

{

308

{

309

struct rt6_info *rt = dst_alloc(&net->ipv6.ip6_dst_ops, dev,

309

struct rt6_info *rt = dst_alloc(&net->ipv6.ip6_dst_ops, dev,

310

0, DST_OBSOLETE_FORCE_CHK, flags);

310

0, DST_OBSOLETE_FORCE_CHK, flags);

311

312

if (rt) {

312

if (rt) {

313

struct dst_entry *dst = &rt->dst;

313

struct dst_entry *dst = &rt->dst;

314

315

memset(dst + 1, 0, sizeof(*rt) - sizeof(*dst));

315

memset(dst + 1, 0, sizeof(*rt) - sizeof(*dst));

316

rt6_init_peer(rt, table ? &table->tb6_peers : net->ipv6.peers);

316

rt6_init_peer(rt, table ? &table->tb6_peers : net->ipv6.peers);

317

INIT_LIST_HEAD(&rt->rt6i_siblings);

317

INIT_LIST_HEAD(&rt->rt6i_siblings);

318

}

318

}

319

return rt;

319

return rt;

320

}

320

}

321

322

static void ip6_dst_destroy(struct dst_entry *dst)

322

static void ip6_dst_destroy(struct dst_entry *dst)

323

{

323

{

324

struct rt6_info *rt = (struct rt6_info *)dst;

324

struct rt6_info *rt = (struct rt6_info *)dst;

325

struct inet6_dev *idev = rt->rt6i_idev;

325

struct inet6_dev *idev = rt->rt6i_idev;

326

struct dst_entry *from = dst->from;

326

struct dst_entry *from = dst->from;

327

328

if (!(rt->dst.flags & DST_HOST))

328

if (!(rt->dst.flags & DST_HOST))

329

dst_destroy_metrics_generic(dst);

329

dst_destroy_metrics_generic(dst);

330

331

if (idev) {

331

if (idev) {

332

rt->rt6i_idev = NULL;

332

rt->rt6i_idev = NULL;

333

in6_dev_put(idev);

333

in6_dev_put(idev);

334

}

334

}

335

336

dst->from = NULL;

336

dst->from = NULL;

337

dst_release(from);

337

dst_release(from);

338

339

if (rt6_has_peer(rt)) {

339

if (rt6_has_peer(rt)) {

340

struct inet_peer *peer = rt6_peer_ptr(rt);

340

struct inet_peer *peer = rt6_peer_ptr(rt);

341

inet_putpeer(peer);

341

inet_putpeer(peer);

342

}

342

}

343

}

343

}

344

345

static void ip6_dst_ifdown(struct dst_entry *dst, struct net_device *dev,

345

static void ip6_dst_ifdown(struct dst_entry *dst, struct net_device *dev,

346

int how)

346

int how)

347

{

347

{

348

struct rt6_info *rt = (struct rt6_info *)dst;

348

struct rt6_info *rt = (struct rt6_info *)dst;

349

struct inet6_dev *idev = rt->rt6i_idev;

349

struct inet6_dev *idev = rt->rt6i_idev;

350

struct net_device *loopback_dev =

350

struct net_device *loopback_dev =

351

dev_net(dev)->loopback_dev;

351

dev_net(dev)->loopback_dev;

352

353

if (dev != loopback_dev) {

353

if (dev != loopback_dev) {

354

if (idev && idev->dev == dev) {

354

if (idev && idev->dev == dev) {

355

struct inet6_dev *loopback_idev =

355

struct inet6_dev *loopback_idev =

356

in6_dev_get(loopback_dev);

356

in6_dev_get(loopback_dev);

357

if (loopback_idev) {

357

if (loopback_idev) {

358

rt->rt6i_idev = loopback_idev;

358

rt->rt6i_idev = loopback_idev;

359

in6_dev_put(idev);

359

in6_dev_put(idev);

360

}

360

}

361

}

361

}

362

}

362

}

363

}

363

}

364

365

static bool rt6_check_expired(const struct rt6_info *rt)

365

static bool rt6_check_expired(const struct rt6_info *rt)

366

{

366

{

367

if (rt->rt6i_flags & RTF_EXPIRES) {

367

if (rt->rt6i_flags & RTF_EXPIRES) {

368

if (time_after(jiffies, rt->dst.expires))

368

if (time_after(jiffies, rt->dst.expires))

369

return true;

369

return true;

370

} else if (rt->dst.from) {

370

} else if (rt->dst.from) {

371

return rt6_check_expired((struct rt6_info *) rt->dst.from);

371

return rt6_check_expired((struct rt6_info *) rt->dst.from);

372

}

372

}

373

return false;

373

return false;

374

}

374

}

375

376

/* Multipath route selection:

376

/* Multipath route selection:

377

* Hash based function using packet header and flowlabel.

377

* Hash based function using packet header and flowlabel.

378

* Adapted from fib_info_hashfn()

378

* Adapted from fib_info_hashfn()

379

*/

379

*/

380

static int rt6_info_hash_nhsfn(unsigned int candidate_count,

380

static int rt6_info_hash_nhsfn(unsigned int candidate_count,

381

const struct flowi6 *fl6)

381

const struct flowi6 *fl6)

382

{

382

{

383

unsigned int val = fl6->flowi6_proto;

383

unsigned int val = fl6->flowi6_proto;

384

385

val ^= ipv6_addr_hash(&fl6->daddr);

385

val ^= ipv6_addr_hash(&fl6->daddr);

386

val ^= ipv6_addr_hash(&fl6->saddr);

386

val ^= ipv6_addr_hash(&fl6->saddr);

387

388

/* Work only if this not encapsulated */

388

/* Work only if this not encapsulated */

389

switch (fl6->flowi6_proto) {

389

switch (fl6->flowi6_proto) {

390

case IPPROTO_UDP:

390

case IPPROTO_UDP:

391

case IPPROTO_TCP:

391

case IPPROTO_TCP:

392

case IPPROTO_SCTP:

392

case IPPROTO_SCTP:

393

val ^= (__force u16)fl6->fl6_sport;

393

val ^= (__force u16)fl6->fl6_sport;

394

val ^= (__force u16)fl6->fl6_dport;

394

val ^= (__force u16)fl6->fl6_dport;

395

break;

395

break;

396

397

case IPPROTO_ICMPV6:

397

case IPPROTO_ICMPV6:

398

val ^= (__force u16)fl6->fl6_icmp_type;

398

val ^= (__force u16)fl6->fl6_icmp_type;

399

val ^= (__force u16)fl6->fl6_icmp_code;

399

val ^= (__force u16)fl6->fl6_icmp_code;

400

break;

400

break;

401

}

401

}

402

/* RFC6438 recommands to use flowlabel */

402

/* RFC6438 recommands to use flowlabel */

403

val ^= (__force u32)fl6->flowlabel;

403

val ^= (__force u32)fl6->flowlabel;

404

405

/* Perhaps, we need to tune, this function? */

405

/* Perhaps, we need to tune, this function? */

406

val = val ^ (val >> 7) ^ (val >> 12);

406

val = val ^ (val >> 7) ^ (val >> 12);

407

return val % candidate_count;

407

return val % candidate_count;

408

}

408

}

409

410

static struct rt6_info *rt6_multipath_select(struct rt6_info *match,

410

static struct rt6_info *rt6_multipath_select(struct rt6_info *match,

411

struct flowi6 *fl6, int oif,

411

struct flowi6 *fl6, int oif,

412

int strict)

412

int strict)

413

{

413

{

414

struct rt6_info *sibling, *next_sibling;

414

struct rt6_info *sibling, *next_sibling;

415

int route_choosen;

415

int route_choosen;

416

417

route_choosen = rt6_info_hash_nhsfn(match->rt6i_nsiblings + 1, fl6);

417

route_choosen = rt6_info_hash_nhsfn(match->rt6i_nsiblings + 1, fl6);

418

/* Don't change the route, if route_choosen == 0

418

/* Don't change the route, if route_choosen == 0

419

* (siblings does not include ourself)

419

* (siblings does not include ourself)

420

*/

420

*/

421

if (route_choosen)

421

if (route_choosen)

422

list_for_each_entry_safe(sibling, next_sibling,

422

list_for_each_entry_safe(sibling, next_sibling,

423

&match->rt6i_siblings, rt6i_siblings) {

423

&match->rt6i_siblings, rt6i_siblings) {

424

route_choosen--;

424

route_choosen--;

425

if (route_choosen == 0) {

425

if (route_choosen == 0) {

426

if (rt6_score_route(sibling, oif, strict) < 0)

426

if (rt6_score_route(sibling, oif, strict) < 0)

427

break;

427

break;

428

match = sibling;

428

match = sibling;

429

break;

429

break;

430

}

430

}

431

}

431

}

432

return match;

432

return match;

433

}

433

}

434

435

/*

435

/*

436

* Route lookup. Any table->tb6_lock is implied.

436

* Route lookup. Any table->tb6_lock is implied.

437

*/

437

*/

438

439

static inline struct rt6_info *rt6_device_match(struct net *net,

439

static inline struct rt6_info *rt6_device_match(struct net *net,

440

struct rt6_info *rt,

440

struct rt6_info *rt,

441

const struct in6_addr *saddr,

441

const struct in6_addr *saddr,

442

int oif,

442

int oif,

443

int flags)

443

int flags)

444

{

444

{

445

struct rt6_info *local = NULL;

445

struct rt6_info *local = NULL;

446

struct rt6_info *sprt;

446

struct rt6_info *sprt;

447

448

if (!oif && ipv6_addr_any(saddr))

448

if (!oif && ipv6_addr_any(saddr))

449

goto out;

449

goto out;

450

451

for (sprt = rt; sprt; sprt = sprt->dst.rt6_next) {

451

for (sprt = rt; sprt; sprt = sprt->dst.rt6_next) {

452

struct net_device *dev = sprt->dst.dev;

452

struct net_device *dev = sprt->dst.dev;

453

454

if (oif) {

454

if (oif) {

455

if (dev->ifindex == oif)

455

if (dev->ifindex == oif)

456

return sprt;

456

return sprt;

457

if (dev->flags & IFF_LOOPBACK) {

457

if (dev->flags & IFF_LOOPBACK) {

458

if (!sprt->rt6i_idev ||

458

if (!sprt->rt6i_idev ||

459

sprt->rt6i_idev->dev->ifindex != oif) {

459

sprt->rt6i_idev->dev->ifindex != oif) {

460

if (flags & RT6_LOOKUP_F_IFACE && oif)

460

if (flags & RT6_LOOKUP_F_IFACE && oif)

461

continue;

461

continue;

462

if (local && (!oif ||

462

if (local && (!oif ||

463

local->rt6i_idev->dev->ifindex == oif))

463

local->rt6i_idev->dev->ifindex == oif))

464

continue;

464

continue;

465

}

465

}

466

local = sprt;

466

local = sprt;

467

}

467

}

468

} else {

468

} else {

469

if (ipv6_chk_addr(net, saddr, dev,

469

if (ipv6_chk_addr(net, saddr, dev,

470

flags & RT6_LOOKUP_F_IFACE))

470

flags & RT6_LOOKUP_F_IFACE))

471

return sprt;

471

return sprt;

472

}

472

}

473

}

473

}

474

475

if (oif) {

475

if (oif) {

476

if (local)

476

if (local)

477

return local;

477

return local;

478

479

if (flags & RT6_LOOKUP_F_IFACE)

479

if (flags & RT6_LOOKUP_F_IFACE)

480

return net->ipv6.ip6_null_entry;

480

return net->ipv6.ip6_null_entry;

481

}

481

}

482

out:

482

out:

483

return rt;

483

return rt;

484

}

484

}

485

486

#ifdef CONFIG_IPV6_ROUTER_PREF

486

#ifdef CONFIG_IPV6_ROUTER_PREF

487

struct __rt6_probe_work {

487

struct __rt6_probe_work {

488

struct work_struct work;

488

struct work_struct work;

489

struct in6_addr target;

489

struct in6_addr target;

490

struct net_device *dev;

490

struct net_device *dev;

491

};

491

};

492

493

static void rt6_probe_deferred(struct work_struct *w)

493

static void rt6_probe_deferred(struct work_struct *w)

494

{

494

{

495

struct in6_addr mcaddr;

495

struct in6_addr mcaddr;

496

struct __rt6_probe_work *work =

496

struct __rt6_probe_work *work =

497

container_of(w, struct __rt6_probe_work, work);

497

container_of(w, struct __rt6_probe_work, work);

498

499

addrconf_addr_solict_mult(&work->target, &mcaddr);

499

addrconf_addr_solict_mult(&work->target, &mcaddr);

500

ndisc_send_ns(work->dev, NULL, &work->target, &mcaddr, NULL);

500

ndisc_send_ns(work->dev, NULL, &work->target, &mcaddr, NULL);

501

dev_put(work->dev);

501

dev_put(work->dev);

502

kfree(w);

502

kfree(w);

503

}

503

}

504

505

static void rt6_probe(struct rt6_info *rt)

505

static void rt6_probe(struct rt6_info *rt)

506

{

506

{

507

struct neighbour *neigh;

507

struct neighbour *neigh;

508

/*

508

/*

509

* Okay, this does not seem to be appropriate

509

* Okay, this does not seem to be appropriate

510

* for now, however, we need to check if it

510

* for now, however, we need to check if it

511

* is really so; aka Router Reachability Probing.

511

* is really so; aka Router Reachability Probing.

512

*

512

*

513

* Router Reachability Probe MUST be rate-limited

513

* Router Reachability Probe MUST be rate-limited

514

* to no more than one per minute.

514

* to no more than one per minute.

515

*/

515

*/

516

if (!rt || !(rt->rt6i_flags & RTF_GATEWAY))

516

if (!rt || !(rt->rt6i_flags & RTF_GATEWAY))

517

return;

517

return;

518

rcu_read_lock_bh();

518

rcu_read_lock_bh();

519

neigh = __ipv6_neigh_lookup_noref(rt->dst.dev, &rt->rt6i_gateway);

519

neigh = __ipv6_neigh_lookup_noref(rt->dst.dev, &rt->rt6i_gateway);

520

if (neigh) {

520

if (neigh) {

521

write_lock(&neigh->lock);

521

write_lock(&neigh->lock);

522

if (neigh->nud_state & NUD_VALID)

522

if (neigh->nud_state & NUD_VALID)

523

goto out;

523

goto out;

524

}

524

}

525

526

if (!neigh ||

526

if (!neigh ||

527

time_after(jiffies, neigh->updated + rt->rt6i_idev->cnf.rtr_probe_interval)) {

527

time_after(jiffies, neigh->updated + rt->rt6i_idev->cnf.rtr_probe_interval)) {

528

struct __rt6_probe_work *work;

528

struct __rt6_probe_work *work;

529

530

work = kmalloc(sizeof(*work), GFP_ATOMIC);

530

work = kmalloc(sizeof(*work), GFP_ATOMIC);

531

532

if (neigh && work)

532

if (neigh && work)

533

__neigh_set_probe_once(neigh);

533

__neigh_set_probe_once(neigh);

534

535

if (neigh)

535

if (neigh)

536

write_unlock(&neigh->lock);

536

write_unlock(&neigh->lock);

537

538

if (work) {

538

if (work) {

539

INIT_WORK(&work->work, rt6_probe_deferred);

539

INIT_WORK(&work->work, rt6_probe_deferred);

540

work->target = rt->rt6i_gateway;

540

work->target = rt->rt6i_gateway;

541

dev_hold(rt->dst.dev);

541

dev_hold(rt->dst.dev);

542

work->dev = rt->dst.dev;

542

work->dev = rt->dst.dev;

543

schedule_work(&work->work);

543

schedule_work(&work->work);

544

}

544

}

545

} else {

545

} else {

546

out:

546

out:

547

write_unlock(&neigh->lock);

547

write_unlock(&neigh->lock);

548

}

548

}

549

rcu_read_unlock_bh();

549

rcu_read_unlock_bh();

550

}

550

}

551

#else

551

#else

552

static inline void rt6_probe(struct rt6_info *rt)

552

static inline void rt6_probe(struct rt6_info *rt)

553

{

553

{

554

}

554

}

555

#endif

555

#endif

556

557

/*

557

/*

558

* Default Router Selection (RFC 2461 6.3.6)

558

* Default Router Selection (RFC 2461 6.3.6)

559

*/

559

*/

560

static inline int rt6_check_dev(struct rt6_info *rt, int oif)

560

static inline int rt6_check_dev(struct rt6_info *rt, int oif)

561

{

561

{

562

struct net_device *dev = rt->dst.dev;

562

struct net_device *dev = rt->dst.dev;

563

if (!oif || dev->ifindex == oif)

563

if (!oif || dev->ifindex == oif)

564

return 2;

564

return 2;

565

if ((dev->flags & IFF_LOOPBACK) &&

565

if ((dev->flags & IFF_LOOPBACK) &&

566

rt->rt6i_idev && rt->rt6i_idev->dev->ifindex == oif)

566

rt->rt6i_idev && rt->rt6i_idev->dev->ifindex == oif)

567

return 1;

567

return 1;

568

return 0;

568

return 0;

569

}

569

}

570

571

static inline enum rt6_nud_state rt6_check_neigh(struct rt6_info *rt)

571

static inline enum rt6_nud_state rt6_check_neigh(struct rt6_info *rt)

572

{

572

{

573

struct neighbour *neigh;

573

struct neighbour *neigh;

574

enum rt6_nud_state ret = RT6_NUD_FAIL_HARD;

574

enum rt6_nud_state ret = RT6_NUD_FAIL_HARD;

575

576

if (rt->rt6i_flags & RTF_NONEXTHOP ||

576

if (rt->rt6i_flags & RTF_NONEXTHOP ||

577

!(rt->rt6i_flags & RTF_GATEWAY))

577

!(rt->rt6i_flags & RTF_GATEWAY))

578

return RT6_NUD_SUCCEED;

578

return RT6_NUD_SUCCEED;

579

580

rcu_read_lock_bh();

580

rcu_read_lock_bh();

581

neigh = __ipv6_neigh_lookup_noref(rt->dst.dev, &rt->rt6i_gateway);

581

neigh = __ipv6_neigh_lookup_noref(rt->dst.dev, &rt->rt6i_gateway);

582

if (neigh) {

582

if (neigh) {

583

read_lock(&neigh->lock);

583

read_lock(&neigh->lock);

584

if (neigh->nud_state & NUD_VALID)

584

if (neigh->nud_state & NUD_VALID)

585

ret = RT6_NUD_SUCCEED;

585

ret = RT6_NUD_SUCCEED;

586

#ifdef CONFIG_IPV6_ROUTER_PREF

586

#ifdef CONFIG_IPV6_ROUTER_PREF

587

else if (!(neigh->nud_state & NUD_FAILED))

587

else if (!(neigh->nud_state & NUD_FAILED))

588

ret = RT6_NUD_SUCCEED;

588

ret = RT6_NUD_SUCCEED;

589

else

589

else

590

ret = RT6_NUD_FAIL_PROBE;

590

ret = RT6_NUD_FAIL_PROBE;

591

#endif

591

#endif

592

read_unlock(&neigh->lock);

592

read_unlock(&neigh->lock);

593

} else {

593

} else {

594

ret = IS_ENABLED(CONFIG_IPV6_ROUTER_PREF) ?

594

ret = IS_ENABLED(CONFIG_IPV6_ROUTER_PREF) ?

595

RT6_NUD_SUCCEED : RT6_NUD_FAIL_DO_RR;

595

RT6_NUD_SUCCEED : RT6_NUD_FAIL_DO_RR;

596

}

596

}

597

rcu_read_unlock_bh();

597

rcu_read_unlock_bh();

598

599

return ret;

599

return ret;

600

}

600

}

601

602

static int rt6_score_route(struct rt6_info *rt, int oif,

602

static int rt6_score_route(struct rt6_info *rt, int oif,

603

int strict)

603

int strict)

604

{

604

{

605

int m;

605

int m;

606

607

m = rt6_check_dev(rt, oif);

607

m = rt6_check_dev(rt, oif);

608

if (!m && (strict & RT6_LOOKUP_F_IFACE))

608

if (!m && (strict & RT6_LOOKUP_F_IFACE))

609

return RT6_NUD_FAIL_HARD;

609

return RT6_NUD_FAIL_HARD;

610

#ifdef CONFIG_IPV6_ROUTER_PREF

610

#ifdef CONFIG_IPV6_ROUTER_PREF

611

m |= IPV6_DECODE_PREF(IPV6_EXTRACT_PREF(rt->rt6i_flags)) << 2;

611

m |= IPV6_DECODE_PREF(IPV6_EXTRACT_PREF(rt->rt6i_flags)) << 2;

612

#endif

612

#endif

613

if (strict & RT6_LOOKUP_F_REACHABLE) {

613

if (strict & RT6_LOOKUP_F_REACHABLE) {

614

int n = rt6_check_neigh(rt);

614

int n = rt6_check_neigh(rt);

615

if (n < 0)

615

if (n < 0)

616

return n;

616

return n;

617

}

617

}

618

return m;

618

return m;

619

}

619

}

620

621

static struct rt6_info *find_match(struct rt6_info *rt, int oif, int strict,

621

static struct rt6_info *find_match(struct rt6_info *rt, int oif, int strict,

622

int *mpri, struct rt6_info *match,

622

int *mpri, struct rt6_info *match,

623

bool *do_rr)

623

bool *do_rr)

624

{

624

{

625

int m;

625

int m;

626

bool match_do_rr = false;

626

bool match_do_rr = false;

627

628

if (rt6_check_expired(rt))

628

if (rt6_check_expired(rt))

629

goto out;

629

goto out;

630

631

m = rt6_score_route(rt, oif, strict);

631

m = rt6_score_route(rt, oif, strict);

632

if (m == RT6_NUD_FAIL_DO_RR) {

632

if (m == RT6_NUD_FAIL_DO_RR) {

633

match_do_rr = true;

633

match_do_rr = true;

634

m = 0; /* lowest valid score */

634

m = 0; /* lowest valid score */

635

} else if (m == RT6_NUD_FAIL_HARD) {

635

} else if (m == RT6_NUD_FAIL_HARD) {

636

goto out;

636

goto out;

637

}

637

}

638

639

if (strict & RT6_LOOKUP_F_REACHABLE)

639

if (strict & RT6_LOOKUP_F_REACHABLE)

640

rt6_probe(rt);

640

rt6_probe(rt);

641

642

/* note that m can be RT6_NUD_FAIL_PROBE at this point */

642

/* note that m can be RT6_NUD_FAIL_PROBE at this point */

643

if (m > *mpri) {

643

if (m > *mpri) {

644

*do_rr = match_do_rr;

644

*do_rr = match_do_rr;

645

*mpri = m;

645

*mpri = m;

646

match = rt;

646

match = rt;

647

}

647

}

648

out:

648

out:

649

return match;

649

return match;

650

}

650

}

651

652

static struct rt6_info *find_rr_leaf(struct fib6_node *fn,

652

static struct rt6_info *find_rr_leaf(struct fib6_node *fn,

653

struct rt6_info *rr_head,

653

struct rt6_info *rr_head,

654

u32 metric, int oif, int strict,

654

u32 metric, int oif, int strict,

655

bool *do_rr)

655

bool *do_rr)

656

{

656

{

657

struct rt6_info *rt, *match;

657

struct rt6_info *rt, *match;

658

int mpri = -1;

658

int mpri = -1;

659

660

match = NULL;

660

match = NULL;

661

for (rt = rr_head; rt && rt->rt6i_metric == metric;

661

for (rt = rr_head; rt && rt->rt6i_metric == metric;

662

rt = rt->dst.rt6_next)

662

rt = rt->dst.rt6_next)

663

match = find_match(rt, oif, strict, &mpri, match, do_rr);

663

match = find_match(rt, oif, strict, &mpri, match, do_rr);

664

for (rt = fn->leaf; rt && rt != rr_head && rt->rt6i_metric == metric;

664

for (rt = fn->leaf; rt && rt != rr_head && rt->rt6i_metric == metric;

665

rt = rt->dst.rt6_next)

665

rt = rt->dst.rt6_next)

666

match = find_match(rt, oif, strict, &mpri, match, do_rr);

666

match = find_match(rt, oif, strict, &mpri, match, do_rr);

667

668

return match;

668

return match;

669

}

669

}

670

671

static struct rt6_info *rt6_select(struct fib6_node *fn, int oif, int strict)

671

static struct rt6_info *rt6_select(struct fib6_node *fn, int oif, int strict)

672

{

672

{

673

struct rt6_info *match, *rt0;

673

struct rt6_info *match, *rt0;

674

struct net *net;

674

struct net *net;

675

bool do_rr = false;

675

bool do_rr = false;

676

677

rt0 = fn->rr_ptr;

677

rt0 = fn->rr_ptr;

678

if (!rt0)

678

if (!rt0)

679

fn->rr_ptr = rt0 = fn->leaf;

679

fn->rr_ptr = rt0 = fn->leaf;

680

681

match = find_rr_leaf(fn, rt0, rt0->rt6i_metric, oif, strict,

681

match = find_rr_leaf(fn, rt0, rt0->rt6i_metric, oif, strict,

682

&do_rr);

682

&do_rr);

683

684

if (do_rr) {

684

if (do_rr) {

685

struct rt6_info *next = rt0->dst.rt6_next;

685

struct rt6_info *next = rt0->dst.rt6_next;

686

687

/* no entries matched; do round-robin */

687

/* no entries matched; do round-robin */

688

if (!next || next->rt6i_metric != rt0->rt6i_metric)

688

if (!next || next->rt6i_metric != rt0->rt6i_metric)

689

next = fn->leaf;

689

next = fn->leaf;

690

691

if (next != rt0)

691

if (next != rt0)

692

fn->rr_ptr = next;

692

fn->rr_ptr = next;

693

}

693

}

694

695

net = dev_net(rt0->dst.dev);

695

net = dev_net(rt0->dst.dev);

696

return match ? match : net->ipv6.ip6_null_entry;

696

return match ? match : net->ipv6.ip6_null_entry;

697

}

697

}

698

699

#ifdef CONFIG_IPV6_ROUTE_INFO

699

#ifdef CONFIG_IPV6_ROUTE_INFO

700

int rt6_route_rcv(struct net_device *dev, u8 *opt, int len,

700

int rt6_route_rcv(struct net_device *dev, u8 *opt, int len,

701

const struct in6_addr *gwaddr)

701

const struct in6_addr *gwaddr)

702

{

702

{

703

struct net *net = dev_net(dev);

703

struct net *net = dev_net(dev);

704

struct route_info *rinfo = (struct route_info *) opt;

704

struct route_info *rinfo = (struct route_info *) opt;

705

struct in6_addr prefix_buf, *prefix;

705

struct in6_addr prefix_buf, *prefix;

706

unsigned int pref;

706

unsigned int pref;

707

unsigned long lifetime;

707

unsigned long lifetime;

708

struct rt6_info *rt;

708

struct rt6_info *rt;

709

710

if (len < sizeof(struct route_info)) {

710

if (len < sizeof(struct route_info)) {

711

return -EINVAL;

711

return -EINVAL;

712

}

712

}

713

714

/* Sanity check for prefix_len and length */

714

/* Sanity check for prefix_len and length */

715

if (rinfo->length > 3) {

715

if (rinfo->length > 3) {

716

return -EINVAL;

716

return -EINVAL;

717

} else if (rinfo->prefix_len > 128) {

717

} else if (rinfo->prefix_len > 128) {

718

return -EINVAL;

718

return -EINVAL;

719

} else if (rinfo->prefix_len > 64) {

719

} else if (rinfo->prefix_len > 64) {

720

if (rinfo->length < 2) {

720

if (rinfo->length < 2) {

721

return -EINVAL;

721

return -EINVAL;

722

}

722

}

723

} else if (rinfo->prefix_len > 0) {

723

} else if (rinfo->prefix_len > 0) {

724

if (rinfo->length < 1) {

724

if (rinfo->length < 1) {

725

return -EINVAL;

725

return -EINVAL;

726

}

726

}

727

}

727

}

728

729

pref = rinfo->route_pref;

729

pref = rinfo->route_pref;

730

if (pref == ICMPV6_ROUTER_PREF_INVALID)

730

if (pref == ICMPV6_ROUTER_PREF_INVALID)

731

return -EINVAL;

731

return -EINVAL;

732

733

lifetime = addrconf_timeout_fixup(ntohl(rinfo->lifetime), HZ);

733

lifetime = addrconf_timeout_fixup(ntohl(rinfo->lifetime), HZ);

734

735

if (rinfo->length == 3)

735

if (rinfo->length == 3)

736

prefix = (struct in6_addr *)rinfo->prefix;

736

prefix = (struct in6_addr *)rinfo->prefix;

737

else {

737

else {

738

/* this function is safe */

738

/* this function is safe */

739

ipv6_addr_prefix(&prefix_buf,

739

ipv6_addr_prefix(&prefix_buf,

740

(struct in6_addr *)rinfo->prefix,

740

(struct in6_addr *)rinfo->prefix,

741

rinfo->prefix_len);

741

rinfo->prefix_len);

742

prefix = &prefix_buf;

742

prefix = &prefix_buf;

743

}

743

}

744

745

if (rinfo->prefix_len == 0)

745

if (rinfo->prefix_len == 0)

746

rt = rt6_get_dflt_router(gwaddr, dev);

746

rt = rt6_get_dflt_router(gwaddr, dev);

747

else

747

else

748

rt = rt6_get_route_info(net, prefix, rinfo->prefix_len,

748

rt = rt6_get_route_info(net, prefix, rinfo->prefix_len,

749

gwaddr, dev->ifindex);

749

gwaddr, dev->ifindex);

750

751

if (rt && !lifetime) {

751

if (rt && !lifetime) {

752

ip6_del_rt(rt);

752

ip6_del_rt(rt);

753

rt = NULL;

753

rt = NULL;

754

}

754

}

755

756

if (!rt && lifetime)

756

if (!rt && lifetime)

757

rt = rt6_add_route_info(net, prefix, rinfo->prefix_len, gwaddr, dev->ifindex,

757

rt = rt6_add_route_info(net, prefix, rinfo->prefix_len, gwaddr, dev->ifindex,

758

pref);

758

pref);

759

else if (rt)

759

else if (rt)

760

rt->rt6i_flags = RTF_ROUTEINFO |

760

rt->rt6i_flags = RTF_ROUTEINFO |

761

(rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);

761

(rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);

762

763

if (rt) {

763

if (rt) {

764

if (!addrconf_finite_timeout(lifetime))

764

if (!addrconf_finite_timeout(lifetime))

765

rt6_clean_expires(rt);

765

rt6_clean_expires(rt);

766

else

766

else

767

rt6_set_expires(rt, jiffies + HZ * lifetime);

767

rt6_set_expires(rt, jiffies + HZ * lifetime);

768

769

ip6_rt_put(rt);

769

ip6_rt_put(rt);

770

}

770

}

771

return 0;

771

return 0;

772

}

772

}

773

#endif

773

#endif

774

775

#define BACKTRACK(__net, saddr) \

775

#define BACKTRACK(__net, saddr) \

776

do { \

776

do { \

777

if (rt == __net->ipv6.ip6_null_entry) { \

777

if (rt == __net->ipv6.ip6_null_entry) { \

778

struct fib6_node *pn; \

778

struct fib6_node *pn; \

779

while (1) { \

779

while (1) { \

780

if (fn->fn_flags & RTN_TL_ROOT) \

780

if (fn->fn_flags & RTN_TL_ROOT) \

781

goto out; \

781

goto out; \

782

pn = fn->parent; \

782

pn = fn->parent; \

783

if (FIB6_SUBTREE(pn) && FIB6_SUBTREE(pn) != fn) \

783

if (FIB6_SUBTREE(pn) && FIB6_SUBTREE(pn) != fn) \

784

fn = fib6_lookup(FIB6_SUBTREE(pn), NULL, saddr); \

784

fn = fib6_lookup(FIB6_SUBTREE(pn), NULL, saddr); \

785

else \

785

else \

786

fn = pn; \

786

fn = pn; \

787

if (fn->fn_flags & RTN_RTINFO) \

787

if (fn->fn_flags & RTN_RTINFO) \

788

goto restart; \

788

goto restart; \

789

} \

789

} \

790

} \

790

} \

791

} while (0)

791

} while (0)

792

793

static struct rt6_info *ip6_pol_route_lookup(struct net *net,

793

static struct rt6_info *ip6_pol_route_lookup(struct net *net,

794

struct fib6_table *table,

794

struct fib6_table *table,

795

struct flowi6 *fl6, int flags)

795

struct flowi6 *fl6, int flags)

796

{

796

{

797

struct fib6_node *fn;

797

struct fib6_node *fn;

798

struct rt6_info *rt;

798

struct rt6_info *rt;

799

800

read_lock_bh(&table->tb6_lock);

800

read_lock_bh(&table->tb6_lock);

801

fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);

801

fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);

802

restart:

802

restart:

803

rt = fn->leaf;

803

rt = fn->leaf;

804

rt = rt6_device_match(net, rt, &fl6->saddr, fl6->flowi6_oif, flags);

804

rt = rt6_device_match(net, rt, &fl6->saddr, fl6->flowi6_oif, flags);

805

if (rt->rt6i_nsiblings && fl6->flowi6_oif == 0)

805

if (rt->rt6i_nsiblings && fl6->flowi6_oif == 0)

806

rt = rt6_multipath_select(rt, fl6, fl6->flowi6_oif, flags);

806

rt = rt6_multipath_select(rt, fl6, fl6->flowi6_oif, flags);

807

BACKTRACK(net, &fl6->saddr);

807

BACKTRACK(net, &fl6->saddr);

808

out:

808

out:

809

dst_use(&rt->dst, jiffies);

809

dst_use(&rt->dst, jiffies);

810

read_unlock_bh(&table->tb6_lock);

810

read_unlock_bh(&table->tb6_lock);

811

return rt;

811

return rt;

812

813

}

813

}

814

815

struct dst_entry *ip6_route_lookup(struct net *net, struct flowi6 *fl6,

815

struct dst_entry *ip6_route_lookup(struct net *net, struct flowi6 *fl6,

816

int flags)

816

int flags)

817

{

817

{

818

return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_lookup);

818

return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_lookup);

819

}

819

}

820

EXPORT_SYMBOL_GPL(ip6_route_lookup);

820

EXPORT_SYMBOL_GPL(ip6_route_lookup);

821

822

struct rt6_info *rt6_lookup(struct net *net, const struct in6_addr *daddr,

822

struct rt6_info *rt6_lookup(struct net *net, const struct in6_addr *daddr,

823

const struct in6_addr *saddr, int oif, int strict)

823

const struct in6_addr *saddr, int oif, int strict)

824

{

824

{

825

struct flowi6 fl6 = {

825

struct flowi6 fl6 = {

826

.flowi6_oif = oif,

826

.flowi6_oif = oif,

827

.daddr = *daddr,

827

.daddr = *daddr,

828

};

828

};

829

struct dst_entry *dst;

829

struct dst_entry *dst;

830

int flags = strict ? RT6_LOOKUP_F_IFACE : 0;

830

int flags = strict ? RT6_LOOKUP_F_IFACE : 0;

831

832

if (saddr) {

832

if (saddr) {

833

memcpy(&fl6.saddr, saddr, sizeof(*saddr));

833

memcpy(&fl6.saddr, saddr, sizeof(*saddr));

834

flags |= RT6_LOOKUP_F_HAS_SADDR;

834

flags |= RT6_LOOKUP_F_HAS_SADDR;

835

}

835

}

836

837

dst = fib6_rule_lookup(net, &fl6, flags, ip6_pol_route_lookup);

837

dst = fib6_rule_lookup(net, &fl6, flags, ip6_pol_route_lookup);

838

if (dst->error == 0)

838

if (dst->error == 0)

839

return (struct rt6_info *) dst;

839

return (struct rt6_info *) dst;

840

841

dst_release(dst);

841

dst_release(dst);

842

843

return NULL;

843

return NULL;

844

}

844

}

845

EXPORT_SYMBOL(rt6_lookup);

845

EXPORT_SYMBOL(rt6_lookup);

846

847

/* ip6_ins_rt is called with FREE table->tb6_lock.

847

/* ip6_ins_rt is called with FREE table->tb6_lock.

848

It takes new route entry, the addition fails by any reason the

848

It takes new route entry, the addition fails by any reason the

849

route is freed. In any case, if caller does not hold it, it may

849

route is freed. In any case, if caller does not hold it, it may

850

be destroyed.

850

be destroyed.

851

*/

851

*/

852

853

static int __ip6_ins_rt(struct rt6_info *rt, struct nl_info *info,

853

static int __ip6_ins_rt(struct rt6_info *rt, struct nl_info *info,

854

struct nlattr *mx, int mx_len)

854

struct nlattr *mx, int mx_len)

855

{

855

{

856

int err;

856

int err;

857

struct fib6_table *table;

857

struct fib6_table *table;

858

859

table = rt->rt6i_table;

859

table = rt->rt6i_table;

860

write_lock_bh(&table->tb6_lock);

860

write_lock_bh(&table->tb6_lock);

861

err = fib6_add(&table->tb6_root, rt, info, mx, mx_len);

861

err = fib6_add(&table->tb6_root, rt, info, mx, mx_len);

862

write_unlock_bh(&table->tb6_lock);

862

write_unlock_bh(&table->tb6_lock);

863

864

return err;

864

return err;

865

}

865

}

866

867

int ip6_ins_rt(struct rt6_info *rt)

867

int ip6_ins_rt(struct rt6_info *rt)

868

{

868

{

869

struct nl_info info = {

869

struct nl_info info = {

870

.nl_net = dev_net(rt->dst.dev),

870

.nl_net = dev_net(rt->dst.dev),

871

};

871

};

872

return __ip6_ins_rt(rt, &info, NULL, 0);

872

return __ip6_ins_rt(rt, &info, NULL, 0);

873

}

873

}

874

875

static struct rt6_info *rt6_alloc_cow(struct rt6_info *ort,

875

static struct rt6_info *rt6_alloc_cow(struct rt6_info *ort,

876

const struct in6_addr *daddr,

876

const struct in6_addr *daddr,

877

const struct in6_addr *saddr)

877

const struct in6_addr *saddr)

878

{

878

{

879

struct rt6_info *rt;

879

struct rt6_info *rt;

880

881

/*

881

/*

882

* Clone the route.

882

* Clone the route.

883

*/

883

*/

884

885

rt = ip6_rt_copy(ort, daddr);

885

rt = ip6_rt_copy(ort, daddr);

886

887

if (rt) {

887

if (rt) {

888

if (ort->rt6i_dst.plen != 128 &&

888

if (ort->rt6i_dst.plen != 128 &&

889

ipv6_addr_equal(&ort->rt6i_dst.addr, daddr))

889

ipv6_addr_equal(&ort->rt6i_dst.addr, daddr))

890

rt->rt6i_flags |= RTF_ANYCAST;

890

rt->rt6i_flags |= RTF_ANYCAST;

891

892

rt->rt6i_flags |= RTF_CACHE;

892

rt->rt6i_flags |= RTF_CACHE;

893

894

#ifdef CONFIG_IPV6_SUBTREES

894

#ifdef CONFIG_IPV6_SUBTREES

895

if (rt->rt6i_src.plen && saddr) {

895

if (rt->rt6i_src.plen && saddr) {

896

rt->rt6i_src.addr = *saddr;

896

rt->rt6i_src.addr = *saddr;

897

rt->rt6i_src.plen = 128;

897

rt->rt6i_src.plen = 128;

898

}

898

}

899

#endif

899

#endif

900

}

900

}

901

902

return rt;

902

return rt;

903

}

903

}

904

905

static struct rt6_info *rt6_alloc_clone(struct rt6_info *ort,

905

static struct rt6_info *rt6_alloc_clone(struct rt6_info *ort,

906

const struct in6_addr *daddr)

906

const struct in6_addr *daddr)

907

{

907

{

908

struct rt6_info *rt = ip6_rt_copy(ort, daddr);

908

struct rt6_info *rt = ip6_rt_copy(ort, daddr);

909

910

if (rt)

910

if (rt)

911

rt->rt6i_flags |= RTF_CACHE;

911

rt->rt6i_flags |= RTF_CACHE;

912

return rt;

912

return rt;

913

}

913

}

914

915

static struct rt6_info *ip6_pol_route(struct net *net, struct fib6_table *table, int oif,

915

static struct rt6_info *ip6_pol_route(struct net *net, struct fib6_table *table, int oif,

916

struct flowi6 *fl6, int flags)

916

struct flowi6 *fl6, int flags)

917

{

917

{

918

struct fib6_node *fn;

918

struct fib6_node *fn;

919

struct rt6_info *rt, *nrt;

919

struct rt6_info *rt, *nrt;

920

int strict = 0;

920

int strict = 0;

921

int attempts = 3;

921

int attempts = 3;

922

int err;

922

int err;

923

int reachable = net->ipv6.devconf_all->forwarding ? 0 : RT6_LOOKUP_F_REACHABLE;

923

int reachable = net->ipv6.devconf_all->forwarding ? 0 : RT6_LOOKUP_F_REACHABLE;

924

925

strict |= flags & RT6_LOOKUP_F_IFACE;

925

strict |= flags & RT6_LOOKUP_F_IFACE;

926

927

relookup:

927

relookup:

928

read_lock_bh(&table->tb6_lock);

928

read_lock_bh(&table->tb6_lock);

929

930

restart_2:

930

restart_2:

931

fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);

931

fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);

932

933

restart:

933

restart:

934

rt = rt6_select(fn, oif, strict | reachable);

934

rt = rt6_select(fn, oif, strict | reachable);

935

if (rt->rt6i_nsiblings)

935

if (rt->rt6i_nsiblings)

936

rt = rt6_multipath_select(rt, fl6, oif, strict | reachable);

936

rt = rt6_multipath_select(rt, fl6, oif, strict | reachable);

937

BACKTRACK(net, &fl6->saddr);

937

BACKTRACK(net, &fl6->saddr);

938

if (rt == net->ipv6.ip6_null_entry ||

938

if (rt == net->ipv6.ip6_null_entry ||

939

rt->rt6i_flags & RTF_CACHE)

939

rt->rt6i_flags & RTF_CACHE)

940

goto out;

940

goto out;

941

942

dst_hold(&rt->dst);

942

dst_hold(&rt->dst);

943

read_unlock_bh(&table->tb6_lock);

943

read_unlock_bh(&table->tb6_lock);

944

945

if (!(rt->rt6i_flags & (RTF_NONEXTHOP | RTF_GATEWAY)))

945

if (!(rt->rt6i_flags & (RTF_NONEXTHOP | RTF_GATEWAY)))

946

nrt = rt6_alloc_cow(rt, &fl6->daddr, &fl6->saddr);

946

nrt = rt6_alloc_cow(rt, &fl6->daddr, &fl6->saddr);

947

else if (!(rt->dst.flags & DST_HOST))

947

else if (!(rt->dst.flags & DST_HOST))

948

nrt = rt6_alloc_clone(rt, &fl6->daddr);

948

nrt = rt6_alloc_clone(rt, &fl6->daddr);

949

else

949

else

950

goto out2;

950

goto out2;

951

952

ip6_rt_put(rt);

952

ip6_rt_put(rt);

953

rt = nrt ? : net->ipv6.ip6_null_entry;

953

rt = nrt ? : net->ipv6.ip6_null_entry;

954

955

dst_hold(&rt->dst);

955

dst_hold(&rt->dst);

956

if (nrt) {

956

if (nrt) {

957

err = ip6_ins_rt(nrt);

957

err = ip6_ins_rt(nrt);

958

if (!err)

958

if (!err)

959

goto out2;

959

goto out2;

960

}

960

}

961

962

if (--attempts <= 0)

962

if (--attempts <= 0)

963

goto out2;

963

goto out2;

964

965

/*

965

/*

966

* Race condition! In the gap, when table->tb6_lock was

966

* Race condition! In the gap, when table->tb6_lock was

967

* released someone could insert this route. Relookup.

967

* released someone could insert this route. Relookup.

968

*/

968

*/

969

ip6_rt_put(rt);

969

ip6_rt_put(rt);

970

goto relookup;

970

goto relookup;

971

972

out:

972

out:

973

if (reachable) {

973

if (reachable) {

974

reachable = 0;

974

reachable = 0;

975

goto restart_2;

975

goto restart_2;

976

}

976

}

977

dst_hold(&rt->dst);

977

dst_hold(&rt->dst);

978

read_unlock_bh(&table->tb6_lock);

978

read_unlock_bh(&table->tb6_lock);

979

out2:

979

out2:

980

rt->dst.lastuse = jiffies;

980

rt->dst.lastuse = jiffies;

981

rt->dst.__use++;

981

rt->dst.__use++;

982

983

return rt;

983

return rt;

984

}

984

}

985

986

static struct rt6_info *ip6_pol_route_input(struct net *net, struct fib6_table *table,

986

static struct rt6_info *ip6_pol_route_input(struct net *net, struct fib6_table *table,

987

struct flowi6 *fl6, int flags)

987

struct flowi6 *fl6, int flags)

988

{

988

{

989

return ip6_pol_route(net, table, fl6->flowi6_iif, fl6, flags);

989

return ip6_pol_route(net, table, fl6->flowi6_iif, fl6, flags);

990

}

990

}

991

992

static struct dst_entry *ip6_route_input_lookup(struct net *net,

992

static struct dst_entry *ip6_route_input_lookup(struct net *net,

993

struct net_device *dev,

993

struct net_device *dev,

994

struct flowi6 *fl6, int flags)

994

struct flowi6 *fl6, int flags)

995

{

995

{

996

if (rt6_need_strict(&fl6->daddr) && dev->type != ARPHRD_PIMREG)

996

if (rt6_need_strict(&fl6->daddr) && dev->type != ARPHRD_PIMREG)

997

flags |= RT6_LOOKUP_F_IFACE;

997

flags |= RT6_LOOKUP_F_IFACE;

998

999

return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_input);

999

return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_input);

1000

}

1000

}

1001

1002

void ip6_route_input(struct sk_buff *skb)

1002

void ip6_route_input(struct sk_buff *skb)

1003

{

1003

{

1004

const struct ipv6hdr *iph = ipv6_hdr(skb);

1004

const struct ipv6hdr *iph = ipv6_hdr(skb);

1005

struct net *net = dev_net(skb->dev);

1005

struct net *net = dev_net(skb->dev);

1006

int flags = RT6_LOOKUP_F_HAS_SADDR;

1006

int flags = RT6_LOOKUP_F_HAS_SADDR;

1007

struct flowi6 fl6 = {

1007

struct flowi6 fl6 = {

1008

.flowi6_iif = skb->dev->ifindex,

1008

.flowi6_iif = skb->dev->ifindex,

1009

.daddr = iph->daddr,

1009

.daddr = iph->daddr,

1010

.saddr = iph->saddr,

1010

.saddr = iph->saddr,

1011

.flowlabel = ip6_flowinfo(iph),

1011

.flowlabel = ip6_flowinfo(iph),

1012

.flowi6_mark = skb->mark,

1012

.flowi6_mark = skb->mark,

1013

.flowi6_proto = iph->nexthdr,

1013

.flowi6_proto = iph->nexthdr,

1014

};

1014

};

1015

1016

skb_dst_set(skb, ip6_route_input_lookup(net, skb->dev, &fl6, flags));

1016

skb_dst_set(skb, ip6_route_input_lookup(net, skb->dev, &fl6, flags));

1017

}

1017

}

1018

1019

static struct rt6_info *ip6_pol_route_output(struct net *net, struct fib6_table *table,

1019

static struct rt6_info *ip6_pol_route_output(struct net *net, struct fib6_table *table,

1020

struct flowi6 *fl6, int flags)

1020

struct flowi6 *fl6, int flags)

1021

{

1021

{

1022

return ip6_pol_route(net, table, fl6->flowi6_oif, fl6, flags);

1022

return ip6_pol_route(net, table, fl6->flowi6_oif, fl6, flags);

1023

}

1023

}

1024

1025

struct dst_entry *ip6_route_output(struct net *net, const struct sock *sk,

1025

struct dst_entry *ip6_route_output(struct net *net, const struct sock *sk,

1026

struct flowi6 *fl6)

1026

struct flowi6 *fl6)

1027

{

1027

{

1028

int flags = 0;

1028

int flags = 0;

1029

1030

fl6->flowi6_iif = LOOPBACK_IFINDEX;

1030

fl6->flowi6_iif = LOOPBACK_IFINDEX;

1031

1032

if ((sk && sk->sk_bound_dev_if) || rt6_need_strict(&fl6->daddr))

1032

if ((sk && sk->sk_bound_dev_if) || rt6_need_strict(&fl6->daddr))

1033

flags |= RT6_LOOKUP_F_IFACE;

1033

flags |= RT6_LOOKUP_F_IFACE;

1034

1035

if (!ipv6_addr_any(&fl6->saddr))

1035

if (!ipv6_addr_any(&fl6->saddr))

1036

flags |= RT6_LOOKUP_F_HAS_SADDR;

1036

flags |= RT6_LOOKUP_F_HAS_SADDR;

1037

else if (sk)

1037

else if (sk)

1038

flags |= rt6_srcprefs2flags(inet6_sk(sk)->srcprefs);

1038

flags |= rt6_srcprefs2flags(inet6_sk(sk)->srcprefs);

1039

1040

return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_output);

1040

return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_output);

1041

}

1041

}

1042

EXPORT_SYMBOL(ip6_route_output);

1042

EXPORT_SYMBOL(ip6_route_output);

1043

1044

struct dst_entry *ip6_blackhole_route(struct net *net, struct dst_entry *dst_orig)

1044

struct dst_entry *ip6_blackhole_route(struct net *net, struct dst_entry *dst_orig)

1045

{

1045

{

1046

struct rt6_info *rt, *ort = (struct rt6_info *) dst_orig;

1046

struct rt6_info *rt, *ort = (struct rt6_info *) dst_orig;

1047

struct dst_entry *new = NULL;

1047

struct dst_entry *new = NULL;

1048

1049

rt = dst_alloc(&ip6_dst_blackhole_ops, ort->dst.dev, 1, DST_OBSOLETE_NONE, 0);

1049

rt = dst_alloc(&ip6_dst_blackhole_ops, ort->dst.dev, 1, DST_OBSOLETE_NONE, 0);

1050

if (rt) {

1050

if (rt) {

1051

new = &rt->dst;

1051

new = &rt->dst;

1052

1053

memset(new + 1, 0, sizeof(*rt) - sizeof(*new));

1053

memset(new + 1, 0, sizeof(*rt) - sizeof(*new));

1054

rt6_init_peer(rt, net->ipv6.peers);

1054

rt6_init_peer(rt, net->ipv6.peers);

1055

1056

new->__use = 1;

1056

new->__use = 1;

1057

new->input = dst_discard;

1057

new->input = dst_discard;

1058

new->output = dst_discard_sk;

1058

new->output = dst_discard_sk;

1059

1060

if (dst_metrics_read_only(&ort->dst))

1060

if (dst_metrics_read_only(&ort->dst))

1061

new->_metrics = ort->dst._metrics;

1061

new->_metrics = ort->dst._metrics;

1062

else

1062

else

1063

dst_copy_metrics(new, &ort->dst);

1063

dst_copy_metrics(new, &ort->dst);

1064

rt->rt6i_idev = ort->rt6i_idev;

1064

rt->rt6i_idev = ort->rt6i_idev;

1065

if (rt->rt6i_idev)

1065

if (rt->rt6i_idev)

1066

in6_dev_hold(rt->rt6i_idev);

1066

in6_dev_hold(rt->rt6i_idev);

1067

1068

rt->rt6i_gateway = ort->rt6i_gateway;

1068

rt->rt6i_gateway = ort->rt6i_gateway;

1069

rt->rt6i_flags = ort->rt6i_flags;

1069

rt->rt6i_flags = ort->rt6i_flags;

1070

rt->rt6i_metric = 0;

1070

rt->rt6i_metric = 0;

1071

1072

memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key));

1072

memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key));

1073

#ifdef CONFIG_IPV6_SUBTREES

1073

#ifdef CONFIG_IPV6_SUBTREES

1074

memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));

1074

memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));

1075

#endif

1075

#endif

1076

1077

dst_free(new);

1077

dst_free(new);

1078

}

1078

}

1079

1080

dst_release(dst_orig);

1080

dst_release(dst_orig);

1081

return new ? new : ERR_PTR(-ENOMEM);

1081

return new ? new : ERR_PTR(-ENOMEM);

1082

}

1082

}

1083

1084

/*

1084

/*

1085

* Destination cache support functions

1085

* Destination cache support functions

1086

*/

1086

*/

1087

1088

static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie)

1088

static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie)

1089

{

1089

{

1090

struct rt6_info *rt;

1090

struct rt6_info *rt;

1091

1092

rt = (struct rt6_info *) dst;

1092

rt = (struct rt6_info *) dst;

1093

1094

/* All IPV6 dsts are created with ->obsolete set to the value

1094

/* All IPV6 dsts are created with ->obsolete set to the value

1095

* DST_OBSOLETE_FORCE_CHK which forces validation calls down

1095

* DST_OBSOLETE_FORCE_CHK which forces validation calls down

1096

* into this function always.

1096

* into this function always.

1097

*/

1097

*/

1098

if (!rt->rt6i_node || (rt->rt6i_node->fn_sernum != cookie))

1098

if (!rt->rt6i_node || (rt->rt6i_node->fn_sernum != cookie))

1099

return NULL;

1099

return NULL;

1100

1101

if (rt6_check_expired(rt))

1101

if (rt6_check_expired(rt))

1102

return NULL;

1102

return NULL;

1103

1104

return dst;

1104

return dst;

1105

}

1105

}

1106

1107

static struct dst_entry *ip6_negative_advice(struct dst_entry *dst)

1107

static struct dst_entry *ip6_negative_advice(struct dst_entry *dst)

1108

{

1108

{

1109

struct rt6_info *rt = (struct rt6_info *) dst;

1109

struct rt6_info *rt = (struct rt6_info *) dst;

1110

1111

if (rt) {

1111

if (rt) {

1112

if (rt->rt6i_flags & RTF_CACHE) {

1112

if (rt->rt6i_flags & RTF_CACHE) {

1113

if (rt6_check_expired(rt)) {

1113

if (rt6_check_expired(rt)) {

1114

ip6_del_rt(rt);

1114

ip6_del_rt(rt);

1115

dst = NULL;

1115

dst = NULL;

1116

}

1116

}

1117

} else {

1117

} else {

1118

dst_release(dst);

1118

dst_release(dst);

1119

dst = NULL;

1119

dst = NULL;

1120

}

1120

}

1121

}

1121

}

1122

return dst;

1122

return dst;

1123

}

1123

}

1124

1125

static void ip6_link_failure(struct sk_buff *skb)

1125

static void ip6_link_failure(struct sk_buff *skb)

1126

{

1126

{

1127

struct rt6_info *rt;

1127

struct rt6_info *rt;

1128

1129

icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_ADDR_UNREACH, 0);

1129

icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_ADDR_UNREACH, 0);

1130

1131

rt = (struct rt6_info *) skb_dst(skb);

1131

rt = (struct rt6_info *) skb_dst(skb);

1132

if (rt) {

1132

if (rt) {

1133

if (rt->rt6i_flags & RTF_CACHE) {

1133

if (rt->rt6i_flags & RTF_CACHE) {

1134

dst_hold(&rt->dst);

1134

dst_hold(&rt->dst);

1135

if (ip6_del_rt(rt))

1135

if (ip6_del_rt(rt))

1136

dst_free(&rt->dst);

1136

dst_free(&rt->dst);

1137

} else if (rt->rt6i_node && (rt->rt6i_flags & RTF_DEFAULT)) {

1137

} else if (rt->rt6i_node && (rt->rt6i_flags & RTF_DEFAULT)) {

1138

rt->rt6i_node->fn_sernum = -1;

1138

rt->rt6i_node->fn_sernum = -1;

1139

}

1139

}

1140

}

1140

}

1141

}

1141

}

1142

1143

static void ip6_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,

1143

static void ip6_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,

1144

struct sk_buff *skb, u32 mtu)

1144

struct sk_buff *skb, u32 mtu)

1145

{

1145

{

1146

struct rt6_info *rt6 = (struct rt6_info *)dst;

1146

struct rt6_info *rt6 = (struct rt6_info *)dst;

1147

1148

dst_confirm(dst);

1148

dst_confirm(dst);

1149

if (mtu < dst_mtu(dst) && rt6->rt6i_dst.plen == 128) {

1149

if (mtu < dst_mtu(dst) && rt6->rt6i_dst.plen == 128) {

1150

struct net *net = dev_net(dst->dev);

1150

struct net *net = dev_net(dst->dev);

1151

1152

rt6->rt6i_flags |= RTF_MODIFIED;

1152

rt6->rt6i_flags |= RTF_MODIFIED;

1153

if (mtu < IPV6_MIN_MTU) {

1153

if (mtu < IPV6_MIN_MTU)

1154

u32 features = dst_metric(dst, RTAX_FEATURES);

1155

mtu = IPV6_MIN_MTU;

1154

mtu = IPV6_MIN_MTU;

1156

features |= RTAX_FEATURE_ALLFRAG;

1155

1157

dst_metric_set(dst, RTAX_FEATURES, features);

1158

}

1159

dst_metric_set(dst, RTAX_MTU, mtu);

1156

dst_metric_set(dst, RTAX_MTU, mtu);

1160

rt6_update_expires(rt6, net->ipv6.sysctl.ip6_rt_mtu_expires);

1157

rt6_update_expires(rt6, net->ipv6.sysctl.ip6_rt_mtu_expires);

1161

}

1158

}

1162

}

1159

}

1163

1160

1164

void ip6_update_pmtu(struct sk_buff *skb, struct net *net, __be32 mtu,

1161

void ip6_update_pmtu(struct sk_buff *skb, struct net *net, __be32 mtu,

1165

int oif, u32 mark)

1162

int oif, u32 mark)

1166

{

1163

{

1167

const struct ipv6hdr *iph = (struct ipv6hdr *) skb->data;

1164

const struct ipv6hdr *iph = (struct ipv6hdr *) skb->data;

1168

struct dst_entry *dst;

1165

struct dst_entry *dst;

1169

struct flowi6 fl6;

1166

struct flowi6 fl6;

1170

1167

1171

memset(&fl6, 0, sizeof(fl6));

1168

memset(&fl6, 0, sizeof(fl6));

1172

fl6.flowi6_oif = oif;

1169

fl6.flowi6_oif = oif;

1173

fl6.flowi6_mark = mark ? mark : IP6_REPLY_MARK(net, skb->mark);

1170

fl6.flowi6_mark = mark ? mark : IP6_REPLY_MARK(net, skb->mark);

1174

fl6.daddr = iph->daddr;

1171

fl6.daddr = iph->daddr;

1175

fl6.saddr = iph->saddr;

1172

fl6.saddr = iph->saddr;

1176

fl6.flowlabel = ip6_flowinfo(iph);

1173

fl6.flowlabel = ip6_flowinfo(iph);

1177

1174

1178

dst = ip6_route_output(net, NULL, &fl6);

1175

dst = ip6_route_output(net, NULL, &fl6);

1179

if (!dst->error)

1176

if (!dst->error)

1180

ip6_rt_update_pmtu(dst, NULL, skb, ntohl(mtu));

1177

ip6_rt_update_pmtu(dst, NULL, skb, ntohl(mtu));

1181

dst_release(dst);

1178

dst_release(dst);

1182

}

1179

}

1183

EXPORT_SYMBOL_GPL(ip6_update_pmtu);

1180

EXPORT_SYMBOL_GPL(ip6_update_pmtu);

1184

1181

1185

void ip6_sk_update_pmtu(struct sk_buff *skb, struct sock *sk, __be32 mtu)

1182

void ip6_sk_update_pmtu(struct sk_buff *skb, struct sock *sk, __be32 mtu)

1186

{

1183

{

1187

ip6_update_pmtu(skb, sock_net(sk), mtu,

1184

ip6_update_pmtu(skb, sock_net(sk), mtu,

1188

sk->sk_bound_dev_if, sk->sk_mark);

1185

sk->sk_bound_dev_if, sk->sk_mark);

1189

}

1186

}

1190

EXPORT_SYMBOL_GPL(ip6_sk_update_pmtu);

1187

EXPORT_SYMBOL_GPL(ip6_sk_update_pmtu);

1191

1188

1192

/* Handle redirects */

1189

/* Handle redirects */

1193

struct ip6rd_flowi {

1190

struct ip6rd_flowi {

1194

struct flowi6 fl6;

1191

struct flowi6 fl6;

1195

struct in6_addr gateway;

1192

struct in6_addr gateway;

1196

};

1193

};

1197

1194

1198

static struct rt6_info *__ip6_route_redirect(struct net *net,

1195

static struct rt6_info *__ip6_route_redirect(struct net *net,

1199

struct fib6_table *table,

1196

struct fib6_table *table,

1200

struct flowi6 *fl6,

1197

struct flowi6 *fl6,

1201

int flags)

1198

int flags)

1202

{

1199

{

1203

struct ip6rd_flowi *rdfl = (struct ip6rd_flowi *)fl6;

1200

struct ip6rd_flowi *rdfl = (struct ip6rd_flowi *)fl6;

1204

struct rt6_info *rt;

1201

struct rt6_info *rt;

1205

struct fib6_node *fn;

1202

struct fib6_node *fn;

1206

1203

1207

/* Get the "current" route for this destination and

1204

/* Get the "current" route for this destination and

1208

* check if the redirect has come from approriate router.

1205

* check if the redirect has come from approriate router.

1209

*

1206

*

1210

* RFC 4861 specifies that redirects should only be

1207

* RFC 4861 specifies that redirects should only be

1211

* accepted if they come from the nexthop to the target.

1208

* accepted if they come from the nexthop to the target.

1212

* Due to the way the routes are chosen, this notion

1209

* Due to the way the routes are chosen, this notion

1213

* is a bit fuzzy and one might need to check all possible

1210

* is a bit fuzzy and one might need to check all possible

1214

* routes.

1211

* routes.

1215

*/

1212

*/

1216

1213

1217

read_lock_bh(&table->tb6_lock);

1214

read_lock_bh(&table->tb6_lock);

1218

fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);

1215

fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);

1219

restart:

1216

restart:

1220

for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {

1217

for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {

1221

if (rt6_check_expired(rt))

1218

if (rt6_check_expired(rt))

1222

continue;

1219

continue;

1223

if (rt->dst.error)

1220

if (rt->dst.error)

1224

break;

1221

break;

1225

if (!(rt->rt6i_flags & RTF_GATEWAY))

1222

if (!(rt->rt6i_flags & RTF_GATEWAY))

1226

continue;

1223

continue;

1227

if (fl6->flowi6_oif != rt->dst.dev->ifindex)

1224

if (fl6->flowi6_oif != rt->dst.dev->ifindex)

1228

continue;

1225

continue;

1229

if (!ipv6_addr_equal(&rdfl->gateway, &rt->rt6i_gateway))

1226

if (!ipv6_addr_equal(&rdfl->gateway, &rt->rt6i_gateway))

1230

continue;

1227

continue;

1231

break;

1228

break;

1232

}

1229

}

1233

1230

1234

if (!rt)

1231

if (!rt)

1235

rt = net->ipv6.ip6_null_entry;

1232

rt = net->ipv6.ip6_null_entry;

1236

else if (rt->dst.error) {

1233

else if (rt->dst.error) {

1237

rt = net->ipv6.ip6_null_entry;

1234

rt = net->ipv6.ip6_null_entry;

1238

goto out;

1235

goto out;

1239

}

1236

}

1240

BACKTRACK(net, &fl6->saddr);

1237

BACKTRACK(net, &fl6->saddr);

1241

out:

1238

out:

1242

dst_hold(&rt->dst);

1239

dst_hold(&rt->dst);

1243

1240

1244

read_unlock_bh(&table->tb6_lock);

1241

read_unlock_bh(&table->tb6_lock);

1245

1242

1246

return rt;

1243

return rt;

1247

};

1244

};

1248

1245

1249

static struct dst_entry *ip6_route_redirect(struct net *net,

1246

static struct dst_entry *ip6_route_redirect(struct net *net,

1250

const struct flowi6 *fl6,

1247

const struct flowi6 *fl6,

1251

const struct in6_addr *gateway)

1248

const struct in6_addr *gateway)

1252

{

1249

{

1253

int flags = RT6_LOOKUP_F_HAS_SADDR;

1250

int flags = RT6_LOOKUP_F_HAS_SADDR;

1254

struct ip6rd_flowi rdfl;

1251

struct ip6rd_flowi rdfl;

1255

1252

1256

rdfl.fl6 = *fl6;

1253

rdfl.fl6 = *fl6;

1257

rdfl.gateway = *gateway;

1254

rdfl.gateway = *gateway;

1258

1255

1259

return fib6_rule_lookup(net, &rdfl.fl6,

1256

return fib6_rule_lookup(net, &rdfl.fl6,

1260

flags, __ip6_route_redirect);

1257

flags, __ip6_route_redirect);

1261

}

1258

}

1262

1259

1263

void ip6_redirect(struct sk_buff *skb, struct net *net, int oif, u32 mark)

1260

void ip6_redirect(struct sk_buff *skb, struct net *net, int oif, u32 mark)

1264

{

1261

{

1265

const struct ipv6hdr *iph = (struct ipv6hdr *) skb->data;

1262

const struct ipv6hdr *iph = (struct ipv6hdr *) skb->data;

1266

struct dst_entry *dst;

1263

struct dst_entry *dst;

1267

struct flowi6 fl6;

1264

struct flowi6 fl6;

1268

1265

1269

memset(&fl6, 0, sizeof(fl6));

1266

memset(&fl6, 0, sizeof(fl6));

1270

fl6.flowi6_iif = LOOPBACK_IFINDEX;

1267

fl6.flowi6_iif = LOOPBACK_IFINDEX;

1271

fl6.flowi6_oif = oif;

1268

fl6.flowi6_oif = oif;

1272

fl6.flowi6_mark = mark;

1269

fl6.flowi6_mark = mark;

1273

fl6.daddr = iph->daddr;

1270

fl6.daddr = iph->daddr;

1274

fl6.saddr = iph->saddr;

1271

fl6.saddr = iph->saddr;

1275

fl6.flowlabel = ip6_flowinfo(iph);

1272

fl6.flowlabel = ip6_flowinfo(iph);

1276

1273

1277

dst = ip6_route_redirect(net, &fl6, &ipv6_hdr(skb)->saddr);

1274

dst = ip6_route_redirect(net, &fl6, &ipv6_hdr(skb)->saddr);

1278

rt6_do_redirect(dst, NULL, skb);

1275

rt6_do_redirect(dst, NULL, skb);

1279

dst_release(dst);

1276

dst_release(dst);

1280

}

1277

}

1281

EXPORT_SYMBOL_GPL(ip6_redirect);

1278

EXPORT_SYMBOL_GPL(ip6_redirect);

1282

1279

1283

void ip6_redirect_no_header(struct sk_buff *skb, struct net *net, int oif,

1280

void ip6_redirect_no_header(struct sk_buff *skb, struct net *net, int oif,

1284

u32 mark)

1281

u32 mark)

1285

{

1282

{

1286

const struct ipv6hdr *iph = ipv6_hdr(skb);

1283

const struct ipv6hdr *iph = ipv6_hdr(skb);

1287

const struct rd_msg *msg = (struct rd_msg *)icmp6_hdr(skb);

1284

const struct rd_msg *msg = (struct rd_msg *)icmp6_hdr(skb);

1288

struct dst_entry *dst;

1285

struct dst_entry *dst;

1289

struct flowi6 fl6;

1286

struct flowi6 fl6;

1290

1287

1291

memset(&fl6, 0, sizeof(fl6));

1288

memset(&fl6, 0, sizeof(fl6));

1292

fl6.flowi6_iif = LOOPBACK_IFINDEX;

1289

fl6.flowi6_iif = LOOPBACK_IFINDEX;

1293

fl6.flowi6_oif = oif;

1290

fl6.flowi6_oif = oif;

1294

fl6.flowi6_mark = mark;

1291

fl6.flowi6_mark = mark;

1295

fl6.daddr = msg->dest;

1292

fl6.daddr = msg->dest;

1296

fl6.saddr = iph->daddr;

1293

fl6.saddr = iph->daddr;

1297

1294

1298

dst = ip6_route_redirect(net, &fl6, &iph->saddr);

1295

dst = ip6_route_redirect(net, &fl6, &iph->saddr);

1299

rt6_do_redirect(dst, NULL, skb);

1296

rt6_do_redirect(dst, NULL, skb);

1300

dst_release(dst);

1297

dst_release(dst);

1301

}

1298

}

1302

1299

1303

void ip6_sk_redirect(struct sk_buff *skb, struct sock *sk)

1300

void ip6_sk_redirect(struct sk_buff *skb, struct sock *sk)

1304

{

1301

{

1305

ip6_redirect(skb, sock_net(sk), sk->sk_bound_dev_if, sk->sk_mark);

1302

ip6_redirect(skb, sock_net(sk), sk->sk_bound_dev_if, sk->sk_mark);

1306

}

1303

}

1307

EXPORT_SYMBOL_GPL(ip6_sk_redirect);

1304

EXPORT_SYMBOL_GPL(ip6_sk_redirect);

1308

1305

1309

static unsigned int ip6_default_advmss(const struct dst_entry *dst)

1306

static unsigned int ip6_default_advmss(const struct dst_entry *dst)

1310

{

1307

{

1311

struct net_device *dev = dst->dev;

1308

struct net_device *dev = dst->dev;

1312

unsigned int mtu = dst_mtu(dst);

1309

unsigned int mtu = dst_mtu(dst);

1313

struct net *net = dev_net(dev);

1310

struct net *net = dev_net(dev);

1314

1311

1315

mtu -= sizeof(struct ipv6hdr) + sizeof(struct tcphdr);

1312

mtu -= sizeof(struct ipv6hdr) + sizeof(struct tcphdr);

1316

1313

1317

if (mtu < net->ipv6.sysctl.ip6_rt_min_advmss)

1314

if (mtu < net->ipv6.sysctl.ip6_rt_min_advmss)

1318

mtu = net->ipv6.sysctl.ip6_rt_min_advmss;

1315

mtu = net->ipv6.sysctl.ip6_rt_min_advmss;

1319

1316

1320

/*

1317

/*

1321

* Maximal non-jumbo IPv6 payload is IPV6_MAXPLEN and

1318

* Maximal non-jumbo IPv6 payload is IPV6_MAXPLEN and

1322

* corresponding MSS is IPV6_MAXPLEN - tcp_header_size.

1319

* corresponding MSS is IPV6_MAXPLEN - tcp_header_size.

1323

* IPV6_MAXPLEN is also valid and means: "any MSS,

1320

* IPV6_MAXPLEN is also valid and means: "any MSS,

1324

* rely only on pmtu discovery"

1321

* rely only on pmtu discovery"

1325

*/

1322

*/

1326

if (mtu > IPV6_MAXPLEN - sizeof(struct tcphdr))

1323

if (mtu > IPV6_MAXPLEN - sizeof(struct tcphdr))

1327

mtu = IPV6_MAXPLEN;

1324

mtu = IPV6_MAXPLEN;

1328

return mtu;

1325

return mtu;

1329

}

1326

}

1330

1327

1331

static unsigned int ip6_mtu(const struct dst_entry *dst)

1328

static unsigned int ip6_mtu(const struct dst_entry *dst)

1332

{

1329

{

1333

struct inet6_dev *idev;

1330

struct inet6_dev *idev;

1334

unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);

1331

unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);

1335

1332

1336

if (mtu)

1333

if (mtu)

1337

goto out;

1334

goto out;

1338

1335

1339

mtu = IPV6_MIN_MTU;

1336

mtu = IPV6_MIN_MTU;

1340

1337

1341

rcu_read_lock();

1338

rcu_read_lock();

1342

idev = __in6_dev_get(dst->dev);

1339

idev = __in6_dev_get(dst->dev);

1343

if (idev)

1340

if (idev)

1344

mtu = idev->cnf.mtu6;

1341

mtu = idev->cnf.mtu6;

1345

rcu_read_unlock();

1342

rcu_read_unlock();

1346

1343

1347

out:

1344

out:

1348

return min_t(unsigned int, mtu, IP6_MAX_MTU);

1345

return min_t(unsigned int, mtu, IP6_MAX_MTU);

1349

}

1346

}

1350

1347

1351

static struct dst_entry *icmp6_dst_gc_list;

1348

static struct dst_entry *icmp6_dst_gc_list;

1352

static DEFINE_SPINLOCK(icmp6_dst_lock);

1349

static DEFINE_SPINLOCK(icmp6_dst_lock);

1353

1350

1354

struct dst_entry *icmp6_dst_alloc(struct net_device *dev,

1351

struct dst_entry *icmp6_dst_alloc(struct net_device *dev,

1355

struct flowi6 *fl6)

1352

struct flowi6 *fl6)

1356

{

1353

{

1357

struct dst_entry *dst;

1354

struct dst_entry *dst;

1358

struct rt6_info *rt;

1355

struct rt6_info *rt;

1359

struct inet6_dev *idev = in6_dev_get(dev);

1356

struct inet6_dev *idev = in6_dev_get(dev);

1360

struct net *net = dev_net(dev);

1357

struct net *net = dev_net(dev);

1361

1358

1362

if (unlikely(!idev))

1359

if (unlikely(!idev))

1363

return ERR_PTR(-ENODEV);

1360

return ERR_PTR(-ENODEV);

1364

1361

1365

rt = ip6_dst_alloc(net, dev, 0, NULL);

1362

rt = ip6_dst_alloc(net, dev, 0, NULL);

1366

if (unlikely(!rt)) {

1363

if (unlikely(!rt)) {

1367

in6_dev_put(idev);

1364

in6_dev_put(idev);

1368

dst = ERR_PTR(-ENOMEM);

1365

dst = ERR_PTR(-ENOMEM);

1369

goto out;

1366

goto out;

1370

}

1367

}

1371

1368

1372

rt->dst.flags |= DST_HOST;

1369

rt->dst.flags |= DST_HOST;

1373

rt->dst.output = ip6_output;

1370

rt->dst.output = ip6_output;

1374

atomic_set(&rt->dst.__refcnt, 1);

1371

atomic_set(&rt->dst.__refcnt, 1);

1375

rt->rt6i_gateway = fl6->daddr;

1372

rt->rt6i_gateway = fl6->daddr;

1376

rt->rt6i_dst.addr = fl6->daddr;

1373

rt->rt6i_dst.addr = fl6->daddr;

1377

rt->rt6i_dst.plen = 128;

1374

rt->rt6i_dst.plen = 128;

1378

rt->rt6i_idev = idev;

1375

rt->rt6i_idev = idev;

1379

dst_metric_set(&rt->dst, RTAX_HOPLIMIT, 0);

1376

dst_metric_set(&rt->dst, RTAX_HOPLIMIT, 0);

1380

1377

1381

spin_lock_bh(&icmp6_dst_lock);

1378

spin_lock_bh(&icmp6_dst_lock);

1382

rt->dst.next = icmp6_dst_gc_list;

1379

rt->dst.next = icmp6_dst_gc_list;

1383

icmp6_dst_gc_list = &rt->dst;

1380

icmp6_dst_gc_list = &rt->dst;

1384

spin_unlock_bh(&icmp6_dst_lock);

1381

spin_unlock_bh(&icmp6_dst_lock);

1385

1382

1386

fib6_force_start_gc(net);

1383

fib6_force_start_gc(net);

1387

1384

1388

dst = xfrm_lookup(net, &rt->dst, flowi6_to_flowi(fl6), NULL, 0);

1385

dst = xfrm_lookup(net, &rt->dst, flowi6_to_flowi(fl6), NULL, 0);

1389

1386

1390

out:

1387

out:

1391

return dst;

1388

return dst;

1392

}

1389

}

1393

1390

1394

int icmp6_dst_gc(void)

1391

int icmp6_dst_gc(void)

1395

{

1392

{

1396

struct dst_entry *dst, **pprev;

1393

struct dst_entry *dst, **pprev;

1397

int more = 0;

1394

int more = 0;

1398

1395

1399

spin_lock_bh(&icmp6_dst_lock);

1396

spin_lock_bh(&icmp6_dst_lock);

1400

pprev = &icmp6_dst_gc_list;

1397

pprev = &icmp6_dst_gc_list;

1401

1398

1402

while ((dst = *pprev) != NULL) {

1399

while ((dst = *pprev) != NULL) {

1403

if (!atomic_read(&dst->__refcnt)) {

1400

if (!atomic_read(&dst->__refcnt)) {

1404

*pprev = dst->next;

1401

*pprev = dst->next;

1405

dst_free(dst);

1402

dst_free(dst);

1406

} else {

1403

} else {

1407

pprev = &dst->next;

1404

pprev = &dst->next;

1408

++more;

1405

++more;

1409

}

1406

}

1410

}

1407

}

1411

1408

1412

spin_unlock_bh(&icmp6_dst_lock);

1409

spin_unlock_bh(&icmp6_dst_lock);

1413

1410

1414

return more;

1411

return more;

1415

}

1412

}

1416

1413

1417

static void icmp6_clean_all(int (*func)(struct rt6_info *rt, void *arg),

1414

static void icmp6_clean_all(int (*func)(struct rt6_info *rt, void *arg),

1418

void *arg)

1415

void *arg)

1419

{

1416

{

1420

struct dst_entry *dst, **pprev;

1417

struct dst_entry *dst, **pprev;

1421

1418

1422

spin_lock_bh(&icmp6_dst_lock);

1419

spin_lock_bh(&icmp6_dst_lock);

1423

pprev = &icmp6_dst_gc_list;

1420

pprev = &icmp6_dst_gc_list;

1424

while ((dst = *pprev) != NULL) {

1421

while ((dst = *pprev) != NULL) {

1425

struct rt6_info *rt = (struct rt6_info *) dst;

1422

struct rt6_info *rt = (struct rt6_info *) dst;

1426

if (func(rt, arg)) {

1423

if (func(rt, arg)) {

1427

*pprev = dst->next;

1424

*pprev = dst->next;

1428

dst_free(dst);

1425

dst_free(dst);

1429

} else {

1426

} else {

1430

pprev = &dst->next;

1427

pprev = &dst->next;

1431

}

1428

}

1432

}

1429

}

1433

spin_unlock_bh(&icmp6_dst_lock);

1430

spin_unlock_bh(&icmp6_dst_lock);

1434

}

1431

}

1435

1432

1436

static int ip6_dst_gc(struct dst_ops *ops)

1433

static int ip6_dst_gc(struct dst_ops *ops)

1437

{

1434

{

1438

struct net *net = container_of(ops, struct net, ipv6.ip6_dst_ops);

1435

struct net *net = container_of(ops, struct net, ipv6.ip6_dst_ops);

1439

int rt_min_interval = net->ipv6.sysctl.ip6_rt_gc_min_interval;

1436

int rt_min_interval = net->ipv6.sysctl.ip6_rt_gc_min_interval;

1440

int rt_max_size = net->ipv6.sysctl.ip6_rt_max_size;

1437

int rt_max_size = net->ipv6.sysctl.ip6_rt_max_size;

1441

int rt_elasticity = net->ipv6.sysctl.ip6_rt_gc_elasticity;

1438

int rt_elasticity = net->ipv6.sysctl.ip6_rt_gc_elasticity;

1442

int rt_gc_timeout = net->ipv6.sysctl.ip6_rt_gc_timeout;

1439

int rt_gc_timeout = net->ipv6.sysctl.ip6_rt_gc_timeout;

1443

unsigned long rt_last_gc = net->ipv6.ip6_rt_last_gc;

1440

unsigned long rt_last_gc = net->ipv6.ip6_rt_last_gc;

1444

int entries;

1441

int entries;

1445

1442

1446

entries = dst_entries_get_fast(ops);

1443

entries = dst_entries_get_fast(ops);

1447

if (time_after(rt_last_gc + rt_min_interval, jiffies) &&

1444

if (time_after(rt_last_gc + rt_min_interval, jiffies) &&

1448

entries <= rt_max_size)

1445

entries <= rt_max_size)

1449

goto out;

1446

goto out;

1450

1447

1451

net->ipv6.ip6_rt_gc_expire++;

1448

net->ipv6.ip6_rt_gc_expire++;

1452

fib6_run_gc(net->ipv6.ip6_rt_gc_expire, net, true);

1449

fib6_run_gc(net->ipv6.ip6_rt_gc_expire, net, true);

1453

entries = dst_entries_get_slow(ops);

1450

entries = dst_entries_get_slow(ops);

1454

if (entries < ops->gc_thresh)

1451

if (entries < ops->gc_thresh)

1455

net->ipv6.ip6_rt_gc_expire = rt_gc_timeout>>1;

1452

net->ipv6.ip6_rt_gc_expire = rt_gc_timeout>>1;

1456

out:

1453

out:

1457

net->ipv6.ip6_rt_gc_expire -= net->ipv6.ip6_rt_gc_expire>>rt_elasticity;

1454

net->ipv6.ip6_rt_gc_expire -= net->ipv6.ip6_rt_gc_expire>>rt_elasticity;

1458

return entries > rt_max_size;

1455

return entries > rt_max_size;

1459

}

1456

}

1460

1457

1461

/*

1458

/*

1462

*

1459

*

1463

*/

1460

*/

1464

1461

1465

int ip6_route_add(struct fib6_config *cfg)

1462

int ip6_route_add(struct fib6_config *cfg)

1466

{

1463

{

1467

int err;

1464

int err;

1468

struct net *net = cfg->fc_nlinfo.nl_net;

1465

struct net *net = cfg->fc_nlinfo.nl_net;

1469

struct rt6_info *rt = NULL;

1466

struct rt6_info *rt = NULL;

1470

struct net_device *dev = NULL;

1467

struct net_device *dev = NULL;

1471

struct inet6_dev *idev = NULL;

1468

struct inet6_dev *idev = NULL;

1472

struct fib6_table *table;

1469

struct fib6_table *table;

1473

int addr_type;

1470

int addr_type;

1474

1471

1475

if (cfg->fc_dst_len > 128 || cfg->fc_src_len > 128)

1472

if (cfg->fc_dst_len > 128 || cfg->fc_src_len > 128)

1476

return -EINVAL;

1473

return -EINVAL;

1477

#ifndef CONFIG_IPV6_SUBTREES

1474

#ifndef CONFIG_IPV6_SUBTREES

1478

if (cfg->fc_src_len)

1475

if (cfg->fc_src_len)

1479

return -EINVAL;

1476

return -EINVAL;

1480

#endif

1477

#endif

1481

if (cfg->fc_ifindex) {

1478

if (cfg->fc_ifindex) {

1482

err = -ENODEV;

1479

err = -ENODEV;

1483

dev = dev_get_by_index(net, cfg->fc_ifindex);

1480

dev = dev_get_by_index(net, cfg->fc_ifindex);

1484

if (!dev)

1481

if (!dev)

1485

goto out;

1482

goto out;

1486

idev = in6_dev_get(dev);

1483

idev = in6_dev_get(dev);

1487

if (!idev)

1484

if (!idev)

1488

goto out;

1485

goto out;

1489

}

1486

}

1490

1487

1491

if (cfg->fc_metric == 0)

1488

if (cfg->fc_metric == 0)

1492

cfg->fc_metric = IP6_RT_PRIO_USER;

1489

cfg->fc_metric = IP6_RT_PRIO_USER;

1493

1490

1494

err = -ENOBUFS;

1491

err = -ENOBUFS;

1495

if (cfg->fc_nlinfo.nlh &&

1492

if (cfg->fc_nlinfo.nlh &&

1496

!(cfg->fc_nlinfo.nlh->nlmsg_flags & NLM_F_CREATE)) {

1493

!(cfg->fc_nlinfo.nlh->nlmsg_flags & NLM_F_CREATE)) {

1497

table = fib6_get_table(net, cfg->fc_table);

1494

table = fib6_get_table(net, cfg->fc_table);

1498

if (!table) {

1495

if (!table) {

1499

pr_warn("NLM_F_CREATE should be specified when creating new route\n");

1496

pr_warn("NLM_F_CREATE should be specified when creating new route\n");

1500

table = fib6_new_table(net, cfg->fc_table);

1497

table = fib6_new_table(net, cfg->fc_table);

1501

}

1498

}

1502

} else {

1499

} else {

1503

table = fib6_new_table(net, cfg->fc_table);

1500

table = fib6_new_table(net, cfg->fc_table);

1504

}

1501

}

1505

1502

1506

if (!table)

1503

if (!table)

1507

goto out;

1504

goto out;

1508

1505

1509

rt = ip6_dst_alloc(net, NULL, (cfg->fc_flags & RTF_ADDRCONF) ? 0 : DST_NOCOUNT, table);

1506

rt = ip6_dst_alloc(net, NULL, (cfg->fc_flags & RTF_ADDRCONF) ? 0 : DST_NOCOUNT, table);

1510

1507

1511

if (!rt) {

1508

if (!rt) {

1512

err = -ENOMEM;

1509

err = -ENOMEM;

1513

goto out;

1510

goto out;

1514

}

1511

}

1515

1512

1516

if (cfg->fc_flags & RTF_EXPIRES)

1513

if (cfg->fc_flags & RTF_EXPIRES)

1517

rt6_set_expires(rt, jiffies +

1514

rt6_set_expires(rt, jiffies +

1518

clock_t_to_jiffies(cfg->fc_expires));

1515

clock_t_to_jiffies(cfg->fc_expires));

1519

else

1516

else

1520

rt6_clean_expires(rt);

1517

rt6_clean_expires(rt);

1521

1518

1522

if (cfg->fc_protocol == RTPROT_UNSPEC)

1519

if (cfg->fc_protocol == RTPROT_UNSPEC)

1523

cfg->fc_protocol = RTPROT_BOOT;

1520

cfg->fc_protocol = RTPROT_BOOT;

1524

rt->rt6i_protocol = cfg->fc_protocol;

1521

rt->rt6i_protocol = cfg->fc_protocol;

1525

1522

1526

addr_type = ipv6_addr_type(&cfg->fc_dst);

1523

addr_type = ipv6_addr_type(&cfg->fc_dst);

1527

1524

1528

if (addr_type & IPV6_ADDR_MULTICAST)

1525

if (addr_type & IPV6_ADDR_MULTICAST)

1529

rt->dst.input = ip6_mc_input;

1526

rt->dst.input = ip6_mc_input;

1530

else if (cfg->fc_flags & RTF_LOCAL)

1527

else if (cfg->fc_flags & RTF_LOCAL)

1531

rt->dst.input = ip6_input;

1528

rt->dst.input = ip6_input;

1532

else

1529

else

1533

rt->dst.input = ip6_forward;

1530

rt->dst.input = ip6_forward;

1534

1531

1535

rt->dst.output = ip6_output;

1532

rt->dst.output = ip6_output;

1536

1533

1537

ipv6_addr_prefix(&rt->rt6i_dst.addr, &cfg->fc_dst, cfg->fc_dst_len);

1534

ipv6_addr_prefix(&rt->rt6i_dst.addr, &cfg->fc_dst, cfg->fc_dst_len);

1538

rt->rt6i_dst.plen = cfg->fc_dst_len;

1535

rt->rt6i_dst.plen = cfg->fc_dst_len;

1539

if (rt->rt6i_dst.plen == 128) {

1536

if (rt->rt6i_dst.plen == 128) {

1540

rt->dst.flags |= DST_HOST;

1537

rt->dst.flags |= DST_HOST;

1541

dst_metrics_set_force_overwrite(&rt->dst);

1538

dst_metrics_set_force_overwrite(&rt->dst);

1542

}

1539

}

1543

1540

1544

#ifdef CONFIG_IPV6_SUBTREES

1541

#ifdef CONFIG_IPV6_SUBTREES

1545

ipv6_addr_prefix(&rt->rt6i_src.addr, &cfg->fc_src, cfg->fc_src_len);

1542

ipv6_addr_prefix(&rt->rt6i_src.addr, &cfg->fc_src, cfg->fc_src_len);

1546

rt->rt6i_src.plen = cfg->fc_src_len;

1543

rt->rt6i_src.plen = cfg->fc_src_len;

1547

#endif

1544

#endif

1548

1545

1549

rt->rt6i_metric = cfg->fc_metric;

1546

rt->rt6i_metric = cfg->fc_metric;

1550

1547

1551

/* We cannot add true routes via loopback here,

1548

/* We cannot add true routes via loopback here,

1552

they would result in kernel looping; promote them to reject routes

1549

they would result in kernel looping; promote them to reject routes

1553

*/

1550

*/

1554

if ((cfg->fc_flags & RTF_REJECT) ||

1551

if ((cfg->fc_flags & RTF_REJECT) ||

1555

(dev && (dev->flags & IFF_LOOPBACK) &&

1552

(dev && (dev->flags & IFF_LOOPBACK) &&

1556

!(addr_type & IPV6_ADDR_LOOPBACK) &&

1553

!(addr_type & IPV6_ADDR_LOOPBACK) &&

1557

!(cfg->fc_flags & RTF_LOCAL))) {

1554

!(cfg->fc_flags & RTF_LOCAL))) {

1558

/* hold loopback dev/idev if we haven't done so. */

1555

/* hold loopback dev/idev if we haven't done so. */

1559

if (dev != net->loopback_dev) {

1556

if (dev != net->loopback_dev) {

1560

if (dev) {

1557

if (dev) {

1561

dev_put(dev);

1558

dev_put(dev);

1562

in6_dev_put(idev);

1559

in6_dev_put(idev);

1563

}

1560

}

1564

dev = net->loopback_dev;

1561

dev = net->loopback_dev;

1565

dev_hold(dev);

1562

dev_hold(dev);

1566

idev = in6_dev_get(dev);

1563

idev = in6_dev_get(dev);

1567

if (!idev) {

1564

if (!idev) {

1568

err = -ENODEV;

1565

err = -ENODEV;

1569

goto out;

1566

goto out;

1570

}

1567

}

1571

}

1568

}

1572

rt->rt6i_flags = RTF_REJECT|RTF_NONEXTHOP;

1569

rt->rt6i_flags = RTF_REJECT|RTF_NONEXTHOP;

1573

switch (cfg->fc_type) {

1570

switch (cfg->fc_type) {

1574

case RTN_BLACKHOLE:

1571

case RTN_BLACKHOLE:

1575

rt->dst.error = -EINVAL;

1572

rt->dst.error = -EINVAL;

1576

rt->dst.output = dst_discard_sk;

1573

rt->dst.output = dst_discard_sk;

1577

rt->dst.input = dst_discard;

1574

rt->dst.input = dst_discard;

1578

break;

1575

break;

1579

case RTN_PROHIBIT:

1576

case RTN_PROHIBIT:

1580

rt->dst.error = -EACCES;

1577

rt->dst.error = -EACCES;

1581

rt->dst.output = ip6_pkt_prohibit_out;

1578

rt->dst.output = ip6_pkt_prohibit_out;

1582

rt->dst.input = ip6_pkt_prohibit;

1579

rt->dst.input = ip6_pkt_prohibit;

1583

break;

1580

break;

1584

case RTN_THROW:

1581

case RTN_THROW:

1585

default:

1582

default:

1586

rt->dst.error = (cfg->fc_type == RTN_THROW) ? -EAGAIN

1583

rt->dst.error = (cfg->fc_type == RTN_THROW) ? -EAGAIN

1587

: -ENETUNREACH;

1584

: -ENETUNREACH;

1588

rt->dst.output = ip6_pkt_discard_out;

1585

rt->dst.output = ip6_pkt_discard_out;

1589

rt->dst.input = ip6_pkt_discard;

1586

rt->dst.input = ip6_pkt_discard;

1590

break;

1587

break;

1591

}

1588

}

1592

goto install_route;

1589

goto install_route;

1593

}

1590

}

1594

1591

1595

if (cfg->fc_flags & RTF_GATEWAY) {

1592

if (cfg->fc_flags & RTF_GATEWAY) {

1596

const struct in6_addr *gw_addr;

1593

const struct in6_addr *gw_addr;

1597

int gwa_type;

1594

int gwa_type;

1598

1595

1599

gw_addr = &cfg->fc_gateway;

1596

gw_addr = &cfg->fc_gateway;

1600

rt->rt6i_gateway = *gw_addr;

1597

rt->rt6i_gateway = *gw_addr;

1601

gwa_type = ipv6_addr_type(gw_addr);

1598

gwa_type = ipv6_addr_type(gw_addr);

1602

1599

1603

if (gwa_type != (IPV6_ADDR_LINKLOCAL|IPV6_ADDR_UNICAST)) {

1600

if (gwa_type != (IPV6_ADDR_LINKLOCAL|IPV6_ADDR_UNICAST)) {

1604

struct rt6_info *grt;

1601

struct rt6_info *grt;

1605

1602

1606

/* IPv6 strictly inhibits using not link-local

1603

/* IPv6 strictly inhibits using not link-local

1607

addresses as nexthop address.

1604

addresses as nexthop address.

1608

Otherwise, router will not able to send redirects.

1605

Otherwise, router will not able to send redirects.

1609

It is very good, but in some (rare!) circumstances

1606

It is very good, but in some (rare!) circumstances

1610

(SIT, PtP, NBMA NOARP links) it is handy to allow

1607

(SIT, PtP, NBMA NOARP links) it is handy to allow

1611

some exceptions. --ANK

1608

some exceptions. --ANK

1612

*/

1609

*/

1613

err = -EINVAL;

1610

err = -EINVAL;

1614

if (!(gwa_type & IPV6_ADDR_UNICAST))

1611

if (!(gwa_type & IPV6_ADDR_UNICAST))

1615

goto out;

1612

goto out;

1616

1613

1617

grt = rt6_lookup(net, gw_addr, NULL, cfg->fc_ifindex, 1);

1614

grt = rt6_lookup(net, gw_addr, NULL, cfg->fc_ifindex, 1);

1618

1615

1619

err = -EHOSTUNREACH;

1616

err = -EHOSTUNREACH;

1620

if (!grt)

1617

if (!grt)

1621

goto out;

1618

goto out;

1622

if (dev) {

1619

if (dev) {

1623

if (dev != grt->dst.dev) {

1620

if (dev != grt->dst.dev) {

1624

ip6_rt_put(grt);

1621

ip6_rt_put(grt);

1625

goto out;

1622

goto out;

1626

}

1623

}

1627

} else {

1624

} else {

1628

dev = grt->dst.dev;

1625

dev = grt->dst.dev;

1629

idev = grt->rt6i_idev;

1626

idev = grt->rt6i_idev;

1630

dev_hold(dev);

1627

dev_hold(dev);

1631

in6_dev_hold(grt->rt6i_idev);

1628

in6_dev_hold(grt->rt6i_idev);

1632

}

1629

}

1633

if (!(grt->rt6i_flags & RTF_GATEWAY))

1630

if (!(grt->rt6i_flags & RTF_GATEWAY))

1634

err = 0;

1631

err = 0;

1635

ip6_rt_put(grt);

1632

ip6_rt_put(grt);

1636

1633

1637

if (err)

1634

if (err)

1638

goto out;

1635

goto out;

1639

}

1636

}

1640

err = -EINVAL;

1637

err = -EINVAL;

1641

if (!dev || (dev->flags & IFF_LOOPBACK))

1638

if (!dev || (dev->flags & IFF_LOOPBACK))

1642

goto out;

1639

goto out;

1643

}

1640

}

1644

1641

1645

err = -ENODEV;

1642

err = -ENODEV;

1646

if (!dev)

1643

if (!dev)

1647

goto out;

1644

goto out;

1648

1645

1649

if (!ipv6_addr_any(&cfg->fc_prefsrc)) {

1646

if (!ipv6_addr_any(&cfg->fc_prefsrc)) {

1650

if (!ipv6_chk_addr(net, &cfg->fc_prefsrc, dev, 0)) {

1647

if (!ipv6_chk_addr(net, &cfg->fc_prefsrc, dev, 0)) {

1651

err = -EINVAL;

1648

err = -EINVAL;

1652

goto out;

1649

goto out;

1653

}

1650

}

1654

rt->rt6i_prefsrc.addr = cfg->fc_prefsrc;

1651

rt->rt6i_prefsrc.addr = cfg->fc_prefsrc;

1655

rt->rt6i_prefsrc.plen = 128;

1652

rt->rt6i_prefsrc.plen = 128;

1656

} else

1653

} else

1657

rt->rt6i_prefsrc.plen = 0;

1654

rt->rt6i_prefsrc.plen = 0;

1658

1655

1659

rt->rt6i_flags = cfg->fc_flags;

1656

rt->rt6i_flags = cfg->fc_flags;

1660

1657

1661

install_route:

1658

install_route:

1662

rt->dst.dev = dev;

1659

rt->dst.dev = dev;

1663

rt->rt6i_idev = idev;

1660

rt->rt6i_idev = idev;

1664

rt->rt6i_table = table;

1661

rt->rt6i_table = table;

1665

1662

1666

cfg->fc_nlinfo.nl_net = dev_net(dev);

1663

cfg->fc_nlinfo.nl_net = dev_net(dev);

1667

1664

1668

return __ip6_ins_rt(rt, &cfg->fc_nlinfo, cfg->fc_mx, cfg->fc_mx_len);

1665

return __ip6_ins_rt(rt, &cfg->fc_nlinfo, cfg->fc_mx, cfg->fc_mx_len);

1669

1666

1670

out:

1667

out:

1671

if (dev)

1668

if (dev)

1672

dev_put(dev);

1669

dev_put(dev);

1673

if (idev)

1670

if (idev)

1674

in6_dev_put(idev);

1671

in6_dev_put(idev);

1675

if (rt)

1672

if (rt)

1676

dst_free(&rt->dst);

1673

dst_free(&rt->dst);

1677

return err;

1674

return err;

1678

}

1675

}

1679

1676

1680

static int __ip6_del_rt(struct rt6_info *rt, struct nl_info *info)

1677

static int __ip6_del_rt(struct rt6_info *rt, struct nl_info *info)

1681

{

1678

{

1682

int err;

1679

int err;

1683

struct fib6_table *table;

1680

struct fib6_table *table;

1684

struct net *net = dev_net(rt->dst.dev);

1681

struct net *net = dev_net(rt->dst.dev);

1685

1682

1686

if (rt == net->ipv6.ip6_null_entry) {

1683

if (rt == net->ipv6.ip6_null_entry) {

1687

err = -ENOENT;

1684

err = -ENOENT;

1688

goto out;

1685

goto out;

1689

}

1686

}

1690

1687

1691

table = rt->rt6i_table;

1688

table = rt->rt6i_table;

1692

write_lock_bh(&table->tb6_lock);

1689

write_lock_bh(&table->tb6_lock);

1693

err = fib6_del(rt, info);

1690

err = fib6_del(rt, info);

1694

write_unlock_bh(&table->tb6_lock);

1691

write_unlock_bh(&table->tb6_lock);

1695

1692

1696

out:

1693

out:

1697

ip6_rt_put(rt);

1694

ip6_rt_put(rt);

1698

return err;

1695

return err;

1699

}

1696

}

1700

1697

1701

int ip6_del_rt(struct rt6_info *rt)

1698

int ip6_del_rt(struct rt6_info *rt)

1702

{

1699

{

1703

struct nl_info info = {

1700

struct nl_info info = {

1704

.nl_net = dev_net(rt->dst.dev),

1701

.nl_net = dev_net(rt->dst.dev),

1705

};

1702

};

1706

return __ip6_del_rt(rt, &info);

1703

return __ip6_del_rt(rt, &info);

1707

}

1704

}

1708

1705

1709

static int ip6_route_del(struct fib6_config *cfg)

1706

static int ip6_route_del(struct fib6_config *cfg)

1710

{

1707

{

1711

struct fib6_table *table;

1708

struct fib6_table *table;

1712

struct fib6_node *fn;

1709

struct fib6_node *fn;

1713

struct rt6_info *rt;

1710

struct rt6_info *rt;

1714

int err = -ESRCH;

1711

int err = -ESRCH;

1715

1712

1716

table = fib6_get_table(cfg->fc_nlinfo.nl_net, cfg->fc_table);

1713

table = fib6_get_table(cfg->fc_nlinfo.nl_net, cfg->fc_table);

1717

if (!table)

1714

if (!table)

1718

return err;

1715

return err;

1719

1716

1720

read_lock_bh(&table->tb6_lock);

1717

read_lock_bh(&table->tb6_lock);

1721

1718

1722

fn = fib6_locate(&table->tb6_root,

1719

fn = fib6_locate(&table->tb6_root,

1723

&cfg->fc_dst, cfg->fc_dst_len,

1720

&cfg->fc_dst, cfg->fc_dst_len,

1724

&cfg->fc_src, cfg->fc_src_len);

1721

&cfg->fc_src, cfg->fc_src_len);

1725

1722

1726

if (fn) {

1723

if (fn) {

1727

for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {

1724

for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {

1728

if (cfg->fc_ifindex &&

1725

if (cfg->fc_ifindex &&

1729

(!rt->dst.dev ||

1726

(!rt->dst.dev ||

1730

rt->dst.dev->ifindex != cfg->fc_ifindex))

1727

rt->dst.dev->ifindex != cfg->fc_ifindex))

1731

continue;

1728

continue;

1732

if (cfg->fc_flags & RTF_GATEWAY &&

1729

if (cfg->fc_flags & RTF_GATEWAY &&

1733

!ipv6_addr_equal(&cfg->fc_gateway, &rt->rt6i_gateway))

1730

!ipv6_addr_equal(&cfg->fc_gateway, &rt->rt6i_gateway))

1734

continue;

1731

continue;

1735

if (cfg->fc_metric && cfg->fc_metric != rt->rt6i_metric)

1732

if (cfg->fc_metric && cfg->fc_metric != rt->rt6i_metric)

1736

continue;

1733

continue;

1737

dst_hold(&rt->dst);

1734

dst_hold(&rt->dst);

1738

read_unlock_bh(&table->tb6_lock);

1735

read_unlock_bh(&table->tb6_lock);

1739

1736

1740

return __ip6_del_rt(rt, &cfg->fc_nlinfo);

1737

return __ip6_del_rt(rt, &cfg->fc_nlinfo);

1741

}

1738

}

1742

}

1739

}

1743

read_unlock_bh(&table->tb6_lock);

1740

read_unlock_bh(&table->tb6_lock);

1744

1741

1745

return err;

1742

return err;

1746

}

1743

}

1747

1744

1748

static void rt6_do_redirect(struct dst_entry *dst, struct sock *sk, struct sk_buff *skb)

1745

static void rt6_do_redirect(struct dst_entry *dst, struct sock *sk, struct sk_buff *skb)

1749

{

1746

{

1750

struct net *net = dev_net(skb->dev);

1747

struct net *net = dev_net(skb->dev);

1751

struct netevent_redirect netevent;

1748

struct netevent_redirect netevent;

1752

struct rt6_info *rt, *nrt = NULL;

1749

struct rt6_info *rt, *nrt = NULL;

1753

struct ndisc_options ndopts;

1750

struct ndisc_options ndopts;

1754

struct inet6_dev *in6_dev;

1751

struct inet6_dev *in6_dev;

1755

struct neighbour *neigh;

1752

struct neighbour *neigh;

1756

struct rd_msg *msg;

1753

struct rd_msg *msg;

1757

int optlen, on_link;

1754

int optlen, on_link;

1758

u8 *lladdr;

1755

u8 *lladdr;

1759

1756

1760

optlen = skb_tail_pointer(skb) - skb_transport_header(skb);

1757

optlen = skb_tail_pointer(skb) - skb_transport_header(skb);

1761

optlen -= sizeof(*msg);

1758

optlen -= sizeof(*msg);

1762

1759

1763

if (optlen < 0) {

1760

if (optlen < 0) {

1764

net_dbg_ratelimited("rt6_do_redirect: packet too short\n");

1761

net_dbg_ratelimited("rt6_do_redirect: packet too short\n");

1765

return;

1762

return;

1766

}

1763

}

1767

1764

1768

msg = (struct rd_msg *)icmp6_hdr(skb);

1765

msg = (struct rd_msg *)icmp6_hdr(skb);

1769

1766

1770

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

1767

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

1771

net_dbg_ratelimited("rt6_do_redirect: destination address is multicast\n");

1768

net_dbg_ratelimited("rt6_do_redirect: destination address is multicast\n");

1772

return;

1769

return;

1773

}

1770

}

1774

1771

1775

on_link = 0;

1772

on_link = 0;

1776

if (ipv6_addr_equal(&msg->dest, &msg->target)) {

1773

if (ipv6_addr_equal(&msg->dest, &msg->target)) {

1777

on_link = 1;

1774

on_link = 1;

1778

} else if (ipv6_addr_type(&msg->target) !=

1775

} else if (ipv6_addr_type(&msg->target) !=

1779

(IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {

1776

(IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {

1780

net_dbg_ratelimited("rt6_do_redirect: target address is not link-local unicast\n");

1777

net_dbg_ratelimited("rt6_do_redirect: target address is not link-local unicast\n");

1781

return;

1778

return;

1782

}

1779

}

1783

1780

1784

in6_dev = __in6_dev_get(skb->dev);

1781

in6_dev = __in6_dev_get(skb->dev);

1785

if (!in6_dev)

1782

if (!in6_dev)

1786

return;

1783

return;

1787

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

1784

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

1788

return;

1785

return;

1789

1786

1790

/* RFC2461 8.1:

1787

/* RFC2461 8.1:

1791

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

1788

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

1792

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

1789

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

1793

*/

1790

*/

1794

1791

1795

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

1792

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

1796

net_dbg_ratelimited("rt6_redirect: invalid ND options\n");

1793

net_dbg_ratelimited("rt6_redirect: invalid ND options\n");

1797

return;

1794

return;

1798

}

1795

}

1799

1796

1800

lladdr = NULL;

1797

lladdr = NULL;

1801

if (ndopts.nd_opts_tgt_lladdr) {

1798

if (ndopts.nd_opts_tgt_lladdr) {

1802

lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr,

1799

lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr,

1803

skb->dev);

1800

skb->dev);

1804

if (!lladdr) {

1801

if (!lladdr) {

1805

net_dbg_ratelimited("rt6_redirect: invalid link-layer address length\n");

1802

net_dbg_ratelimited("rt6_redirect: invalid link-layer address length\n");

1806

return;

1803

return;

1807

}

1804

}

1808

}

1805

}

1809

1806

1810

rt = (struct rt6_info *) dst;

1807

rt = (struct rt6_info *) dst;

1811

if (rt == net->ipv6.ip6_null_entry) {

1808

if (rt == net->ipv6.ip6_null_entry) {

1812

net_dbg_ratelimited("rt6_redirect: source isn't a valid nexthop for redirect target\n");

1809

net_dbg_ratelimited("rt6_redirect: source isn't a valid nexthop for redirect target\n");

1813

return;

1810

return;

1814

}

1811

}

1815

1812

1816

/* Redirect received -> path was valid.

1813

/* Redirect received -> path was valid.

1817

* Look, redirects are sent only in response to data packets,

1814

* Look, redirects are sent only in response to data packets,

1818

* so that this nexthop apparently is reachable. --ANK

1815

* so that this nexthop apparently is reachable. --ANK

1819

*/

1816

*/

1820

dst_confirm(&rt->dst);

1817

dst_confirm(&rt->dst);

1821

1818

1822

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

1819

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

1823

if (!neigh)

1820

if (!neigh)

1824

return;

1821

return;

1825

1822

1826

/*

1823

/*

1827

* We have finally decided to accept it.

1824

* We have finally decided to accept it.

1828

*/

1825

*/

1829

1826

1830

neigh_update(neigh, lladdr, NUD_STALE,

1827

neigh_update(neigh, lladdr, NUD_STALE,

1831

NEIGH_UPDATE_F_WEAK_OVERRIDE|

1828

NEIGH_UPDATE_F_WEAK_OVERRIDE|

1832

NEIGH_UPDATE_F_OVERRIDE|

1829

NEIGH_UPDATE_F_OVERRIDE|

1833

(on_link ? 0 : (NEIGH_UPDATE_F_OVERRIDE_ISROUTER|

1830

(on_link ? 0 : (NEIGH_UPDATE_F_OVERRIDE_ISROUTER|

1834

NEIGH_UPDATE_F_ISROUTER))

1831

NEIGH_UPDATE_F_ISROUTER))

1835

);

1832

);

1836

1833

1837

nrt = ip6_rt_copy(rt, &msg->dest);

1834

nrt = ip6_rt_copy(rt, &msg->dest);

1838

if (!nrt)

1835

if (!nrt)

1839

goto out;

1836

goto out;

1840

1837

1841

nrt->rt6i_flags = RTF_GATEWAY|RTF_UP|RTF_DYNAMIC|RTF_CACHE;

1838

nrt->rt6i_flags = RTF_GATEWAY|RTF_UP|RTF_DYNAMIC|RTF_CACHE;

1842

if (on_link)

1839

if (on_link)

1843

nrt->rt6i_flags &= ~RTF_GATEWAY;

1840

nrt->rt6i_flags &= ~RTF_GATEWAY;

1844

1841

1845

nrt->rt6i_gateway = *(struct in6_addr *)neigh->primary_key;

1842

nrt->rt6i_gateway = *(struct in6_addr *)neigh->primary_key;

1846

1843

1847

if (ip6_ins_rt(nrt))

1844

if (ip6_ins_rt(nrt))

1848

goto out;

1845

goto out;

1849

1846

1850

netevent.old = &rt->dst;

1847

netevent.old = &rt->dst;

1851

netevent.new = &nrt->dst;

1848

netevent.new = &nrt->dst;

1852

netevent.daddr = &msg->dest;

1849

netevent.daddr = &msg->dest;

1853

netevent.neigh = neigh;

1850

netevent.neigh = neigh;

1854

call_netevent_notifiers(NETEVENT_REDIRECT, &netevent);

1851

call_netevent_notifiers(NETEVENT_REDIRECT, &netevent);

1855

1852

1856

if (rt->rt6i_flags & RTF_CACHE) {

1853

if (rt->rt6i_flags & RTF_CACHE) {

1857

rt = (struct rt6_info *) dst_clone(&rt->dst);

1854

rt = (struct rt6_info *) dst_clone(&rt->dst);

1858

ip6_del_rt(rt);

1855

ip6_del_rt(rt);

1859

}

1856

}

1860

1857

1861

out:

1858

out:

1862

neigh_release(neigh);

1859

neigh_release(neigh);

1863

}

1860

}

1864

1861

1865

/*

1862

/*

1866

* Misc support functions

1863

* Misc support functions

1867

*/

1864

*/

1868

1865

1869

static struct rt6_info *ip6_rt_copy(struct rt6_info *ort,

1866

static struct rt6_info *ip6_rt_copy(struct rt6_info *ort,

1870

const struct in6_addr *dest)

1867

const struct in6_addr *dest)

1871

{

1868

{

1872

struct net *net = dev_net(ort->dst.dev);

1869

struct net *net = dev_net(ort->dst.dev);

1873

struct rt6_info *rt = ip6_dst_alloc(net, ort->dst.dev, 0,

1870

struct rt6_info *rt = ip6_dst_alloc(net, ort->dst.dev, 0,

1874

ort->rt6i_table);

1871

ort->rt6i_table);

1875

1872

1876

if (rt) {

1873

if (rt) {

1877

rt->dst.input = ort->dst.input;

1874

rt->dst.input = ort->dst.input;

1878

rt->dst.output = ort->dst.output;

1875

rt->dst.output = ort->dst.output;

1879

rt->dst.flags |= DST_HOST;

1876

rt->dst.flags |= DST_HOST;

1880

1877

1881

rt->rt6i_dst.addr = *dest;

1878

rt->rt6i_dst.addr = *dest;

1882

rt->rt6i_dst.plen = 128;

1879

rt->rt6i_dst.plen = 128;

1883

dst_copy_metrics(&rt->dst, &ort->dst);

1880

dst_copy_metrics(&rt->dst, &ort->dst);

1884

rt->dst.error = ort->dst.error;

1881

rt->dst.error = ort->dst.error;

1885

rt->rt6i_idev = ort->rt6i_idev;

1882

rt->rt6i_idev = ort->rt6i_idev;

1886

if (rt->rt6i_idev)

1883

if (rt->rt6i_idev)

1887

in6_dev_hold(rt->rt6i_idev);

1884

in6_dev_hold(rt->rt6i_idev);

1888

rt->dst.lastuse = jiffies;

1885

rt->dst.lastuse = jiffies;

1889

1886

1890

if (ort->rt6i_flags & RTF_GATEWAY)

1887

if (ort->rt6i_flags & RTF_GATEWAY)

1891

rt->rt6i_gateway = ort->rt6i_gateway;

1888

rt->rt6i_gateway = ort->rt6i_gateway;

1892

else

1889

else

1893

rt->rt6i_gateway = *dest;

1890

rt->rt6i_gateway = *dest;

1894

rt->rt6i_flags = ort->rt6i_flags;

1891

rt->rt6i_flags = ort->rt6i_flags;

1895

rt6_set_from(rt, ort);

1892

rt6_set_from(rt, ort);

1896

rt->rt6i_metric = 0;

1893

rt->rt6i_metric = 0;

1897

1894

1898

#ifdef CONFIG_IPV6_SUBTREES

1895

#ifdef CONFIG_IPV6_SUBTREES

1899

memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));

1896

memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));

1900

#endif

1897

#endif

1901

memcpy(&rt->rt6i_prefsrc, &ort->rt6i_prefsrc, sizeof(struct rt6key));

1898

memcpy(&rt->rt6i_prefsrc, &ort->rt6i_prefsrc, sizeof(struct rt6key));

1902

rt->rt6i_table = ort->rt6i_table;

1899

rt->rt6i_table = ort->rt6i_table;

1903

}

1900

}

1904

return rt;

1901

return rt;

1905

}

1902

}

1906

1903

1907

#ifdef CONFIG_IPV6_ROUTE_INFO

1904

#ifdef CONFIG_IPV6_ROUTE_INFO

1908

static struct rt6_info *rt6_get_route_info(struct net *net,

1905

static struct rt6_info *rt6_get_route_info(struct net *net,

1909

const struct in6_addr *prefix, int prefixlen,

1906

const struct in6_addr *prefix, int prefixlen,

1910

const struct in6_addr *gwaddr, int ifindex)

1907

const struct in6_addr *gwaddr, int ifindex)

1911

{

1908

{

1912

struct fib6_node *fn;

1909

struct fib6_node *fn;

1913

struct rt6_info *rt = NULL;

1910

struct rt6_info *rt = NULL;

1914

struct fib6_table *table;

1911

struct fib6_table *table;

1915

1912

1916

table = fib6_get_table(net, RT6_TABLE_INFO);

1913

table = fib6_get_table(net, RT6_TABLE_INFO);

1917

if (!table)

1914

if (!table)

1918

return NULL;

1915

return NULL;

1919

1916

1920

read_lock_bh(&table->tb6_lock);

1917

read_lock_bh(&table->tb6_lock);

1921

fn = fib6_locate(&table->tb6_root, prefix, prefixlen, NULL, 0);

1918

fn = fib6_locate(&table->tb6_root, prefix, prefixlen, NULL, 0);

1922

if (!fn)

1919

if (!fn)

1923

goto out;

1920

goto out;

1924

1921

1925

for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {

1922

for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {

1926

if (rt->dst.dev->ifindex != ifindex)

1923

if (rt->dst.dev->ifindex != ifindex)

1927

continue;

1924

continue;

1928

if ((rt->rt6i_flags & (RTF_ROUTEINFO|RTF_GATEWAY)) != (RTF_ROUTEINFO|RTF_GATEWAY))

1925

if ((rt->rt6i_flags & (RTF_ROUTEINFO|RTF_GATEWAY)) != (RTF_ROUTEINFO|RTF_GATEWAY))

1929

continue;

1926

continue;

1930

if (!ipv6_addr_equal(&rt->rt6i_gateway, gwaddr))

1927

if (!ipv6_addr_equal(&rt->rt6i_gateway, gwaddr))

1931

continue;

1928

continue;

1932

dst_hold(&rt->dst);

1929

dst_hold(&rt->dst);

1933

break;

1930

break;

1934

}

1931

}

1935

out:

1932

out:

1936

read_unlock_bh(&table->tb6_lock);

1933

read_unlock_bh(&table->tb6_lock);

1937

return rt;

1934

return rt;

1938

}

1935

}

1939

1936

1940

static struct rt6_info *rt6_add_route_info(struct net *net,

1937

static struct rt6_info *rt6_add_route_info(struct net *net,

1941

const struct in6_addr *prefix, int prefixlen,

1938

const struct in6_addr *prefix, int prefixlen,

1942

const struct in6_addr *gwaddr, int ifindex,

1939

const struct in6_addr *gwaddr, int ifindex,

1943

unsigned int pref)

1940

unsigned int pref)

1944

{

1941

{

1945

struct fib6_config cfg = {

1942

struct fib6_config cfg = {

1946

.fc_table = RT6_TABLE_INFO,

1943

.fc_table = RT6_TABLE_INFO,

1947

.fc_metric = IP6_RT_PRIO_USER,

1944

.fc_metric = IP6_RT_PRIO_USER,

1948

.fc_ifindex = ifindex,

1945

.fc_ifindex = ifindex,

1949

.fc_dst_len = prefixlen,

1946

.fc_dst_len = prefixlen,

1950

.fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_ROUTEINFO |

1947

.fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_ROUTEINFO |

1951

RTF_UP | RTF_PREF(pref),

1948

RTF_UP | RTF_PREF(pref),

1952

.fc_nlinfo.portid = 0,

1949

.fc_nlinfo.portid = 0,

1953

.fc_nlinfo.nlh = NULL,

1950

.fc_nlinfo.nlh = NULL,

1954

.fc_nlinfo.nl_net = net,

1951

.fc_nlinfo.nl_net = net,

1955

};

1952

};

1956

1953

1957

cfg.fc_dst = *prefix;

1954

cfg.fc_dst = *prefix;

1958

cfg.fc_gateway = *gwaddr;

1955

cfg.fc_gateway = *gwaddr;

1959

1956

1960

/* We should treat it as a default route if prefix length is 0. */

1957

/* We should treat it as a default route if prefix length is 0. */

1961

if (!prefixlen)

1958

if (!prefixlen)

1962

cfg.fc_flags |= RTF_DEFAULT;

1959

cfg.fc_flags |= RTF_DEFAULT;

1963

1960

1964

ip6_route_add(&cfg);

1961

ip6_route_add(&cfg);

1965

1962

1966

return rt6_get_route_info(net, prefix, prefixlen, gwaddr, ifindex);

1963

return rt6_get_route_info(net, prefix, prefixlen, gwaddr, ifindex);

1967

}

1964

}

1968

#endif

1965

#endif

1969

1966

1970

struct rt6_info *rt6_get_dflt_router(const struct in6_addr *addr, struct net_device *dev)

1967

struct rt6_info *rt6_get_dflt_router(const struct in6_addr *addr, struct net_device *dev)

1971

{

1968

{

1972

struct rt6_info *rt;

1969

struct rt6_info *rt;

1973

struct fib6_table *table;

1970

struct fib6_table *table;

1974

1971

1975

table = fib6_get_table(dev_net(dev), RT6_TABLE_DFLT);

1972

table = fib6_get_table(dev_net(dev), RT6_TABLE_DFLT);

1976

if (!table)

1973

if (!table)

1977

return NULL;

1974

return NULL;

1978

1975

1979

read_lock_bh(&table->tb6_lock);

1976

read_lock_bh(&table->tb6_lock);

1980

for (rt = table->tb6_root.leaf; rt; rt = rt->dst.rt6_next) {

1977

for (rt = table->tb6_root.leaf; rt; rt = rt->dst.rt6_next) {

1981

if (dev == rt->dst.dev &&

1978

if (dev == rt->dst.dev &&

1982

((rt->rt6i_flags & (RTF_ADDRCONF | RTF_DEFAULT)) == (RTF_ADDRCONF | RTF_DEFAULT)) &&

1979

((rt->rt6i_flags & (RTF_ADDRCONF | RTF_DEFAULT)) == (RTF_ADDRCONF | RTF_DEFAULT)) &&

1983

ipv6_addr_equal(&rt->rt6i_gateway, addr))

1980

ipv6_addr_equal(&rt->rt6i_gateway, addr))

1984

break;

1981

break;

1985

}

1982

}

1986

if (rt)

1983

if (rt)

1987

dst_hold(&rt->dst);

1984

dst_hold(&rt->dst);

1988

read_unlock_bh(&table->tb6_lock);

1985

read_unlock_bh(&table->tb6_lock);

1989

return rt;

1986

return rt;

1990

}

1987

}

1991

1988

1992

struct rt6_info *rt6_add_dflt_router(const struct in6_addr *gwaddr,

1989

struct rt6_info *rt6_add_dflt_router(const struct in6_addr *gwaddr,

1993

struct net_device *dev,

1990

struct net_device *dev,

1994

unsigned int pref)

1991

unsigned int pref)

1995

{

1992

{

1996

struct fib6_config cfg = {

1993

struct fib6_config cfg = {

1997

.fc_table = RT6_TABLE_DFLT,

1994

.fc_table = RT6_TABLE_DFLT,

1998

.fc_metric = IP6_RT_PRIO_USER,

1995

.fc_metric = IP6_RT_PRIO_USER,

1999

.fc_ifindex = dev->ifindex,

1996

.fc_ifindex = dev->ifindex,

2000

.fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_DEFAULT |

1997

.fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_DEFAULT |

2001

RTF_UP | RTF_EXPIRES | RTF_PREF(pref),

1998

RTF_UP | RTF_EXPIRES | RTF_PREF(pref),

2002

.fc_nlinfo.portid = 0,

1999

.fc_nlinfo.portid = 0,

2003

.fc_nlinfo.nlh = NULL,

2000

.fc_nlinfo.nlh = NULL,

2004

.fc_nlinfo.nl_net = dev_net(dev),

2001

.fc_nlinfo.nl_net = dev_net(dev),

2005

};

2002

};

2006

2003

2007

cfg.fc_gateway = *gwaddr;

2004

cfg.fc_gateway = *gwaddr;

2008

2005

2009

ip6_route_add(&cfg);

2006

ip6_route_add(&cfg);

2010

2007

2011

return rt6_get_dflt_router(gwaddr, dev);

2008

return rt6_get_dflt_router(gwaddr, dev);

2012

}

2009

}

2013

2010

2014

void rt6_purge_dflt_routers(struct net *net)

2011

void rt6_purge_dflt_routers(struct net *net)

2015

{

2012

{

2016

struct rt6_info *rt;

2013

struct rt6_info *rt;

2017

struct fib6_table *table;

2014

struct fib6_table *table;

2018

2015

2019

/* NOTE: Keep consistent with rt6_get_dflt_router */

2016

/* NOTE: Keep consistent with rt6_get_dflt_router */

2020

table = fib6_get_table(net, RT6_TABLE_DFLT);

2017

table = fib6_get_table(net, RT6_TABLE_DFLT);

2021

if (!table)

2018

if (!table)

2022

return;

2019

return;

2023

2020

2024

restart:

2021

restart:

2025

read_lock_bh(&table->tb6_lock);

2022

read_lock_bh(&table->tb6_lock);

2026

for (rt = table->tb6_root.leaf; rt; rt = rt->dst.rt6_next) {

2023

for (rt = table->tb6_root.leaf; rt; rt = rt->dst.rt6_next) {

2027

if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF) &&

2024

if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF) &&

2028

(!rt->rt6i_idev || rt->rt6i_idev->cnf.accept_ra != 2)) {

2025

(!rt->rt6i_idev || rt->rt6i_idev->cnf.accept_ra != 2)) {

2029

dst_hold(&rt->dst);

2026

dst_hold(&rt->dst);

2030

read_unlock_bh(&table->tb6_lock);

2027

read_unlock_bh(&table->tb6_lock);

2031

ip6_del_rt(rt);

2028

ip6_del_rt(rt);

2032

goto restart;

2029

goto restart;

2033

}

2030

}

2034

}

2031

}

2035

read_unlock_bh(&table->tb6_lock);

2032

read_unlock_bh(&table->tb6_lock);

2036

}

2033

}

2037

2034

2038

static void rtmsg_to_fib6_config(struct net *net,

2035

static void rtmsg_to_fib6_config(struct net *net,

2039

struct in6_rtmsg *rtmsg,

2036

struct in6_rtmsg *rtmsg,

2040

struct fib6_config *cfg)

2037

struct fib6_config *cfg)

2041

{

2038

{

2042

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

2039

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

2043

2040

2044

cfg->fc_table = RT6_TABLE_MAIN;

2041

cfg->fc_table = RT6_TABLE_MAIN;

2045

cfg->fc_ifindex = rtmsg->rtmsg_ifindex;

2042

cfg->fc_ifindex = rtmsg->rtmsg_ifindex;

2046

cfg->fc_metric = rtmsg->rtmsg_metric;

2043

cfg->fc_metric = rtmsg->rtmsg_metric;

2047

cfg->fc_expires = rtmsg->rtmsg_info;

2044

cfg->fc_expires = rtmsg->rtmsg_info;

2048

cfg->fc_dst_len = rtmsg->rtmsg_dst_len;

2045

cfg->fc_dst_len = rtmsg->rtmsg_dst_len;

2049

cfg->fc_src_len = rtmsg->rtmsg_src_len;

2046

cfg->fc_src_len = rtmsg->rtmsg_src_len;

2050

cfg->fc_flags = rtmsg->rtmsg_flags;

2047

cfg->fc_flags = rtmsg->rtmsg_flags;

2051

2048

2052

cfg->fc_nlinfo.nl_net = net;

2049

cfg->fc_nlinfo.nl_net = net;

2053

2050

2054

cfg->fc_dst = rtmsg->rtmsg_dst;

2051

cfg->fc_dst = rtmsg->rtmsg_dst;

2055

cfg->fc_src = rtmsg->rtmsg_src;

2052

cfg->fc_src = rtmsg->rtmsg_src;

2056

cfg->fc_gateway = rtmsg->rtmsg_gateway;

2053

cfg->fc_gateway = rtmsg->rtmsg_gateway;

2057

}

2054

}

2058

2055

2059

int ipv6_route_ioctl(struct net *net, unsigned int cmd, void __user *arg)

2056

int ipv6_route_ioctl(struct net *net, unsigned int cmd, void __user *arg)

2060

{

2057

{

2061

struct fib6_config cfg;

2058

struct fib6_config cfg;

2062

struct in6_rtmsg rtmsg;

2059

struct in6_rtmsg rtmsg;

2063

int err;

2060

int err;

2064

2061

2065

switch (cmd) {

2062

switch (cmd) {

2066

case SIOCADDRT: /* Add a route */

2063

case SIOCADDRT: /* Add a route */

2067

case SIOCDELRT: /* Delete a route */

2064

case SIOCDELRT: /* Delete a route */

2068

if (!ns_capable(net->user_ns, CAP_NET_ADMIN))

2065

if (!ns_capable(net->user_ns, CAP_NET_ADMIN))

2069

return -EPERM;

2066

return -EPERM;

2070

err = copy_from_user(&rtmsg, arg,

2067

err = copy_from_user(&rtmsg, arg,

2071

sizeof(struct in6_rtmsg));

2068

sizeof(struct in6_rtmsg));

2072

if (err)

2069

if (err)

2073

return -EFAULT;

2070

return -EFAULT;

2074

2071

2075

rtmsg_to_fib6_config(net, &rtmsg, &cfg);

2072

rtmsg_to_fib6_config(net, &rtmsg, &cfg);

2076

2073

2077

rtnl_lock();

2074

rtnl_lock();

2078

switch (cmd) {

2075

switch (cmd) {

2079

case SIOCADDRT:

2076

case SIOCADDRT:

2080

err = ip6_route_add(&cfg);

2077

err = ip6_route_add(&cfg);

2081

break;

2078

break;

2082

case SIOCDELRT:

2079

case SIOCDELRT:

2083

err = ip6_route_del(&cfg);

2080

err = ip6_route_del(&cfg);

2084

break;

2081

break;

2085

default:

2082

default:

2086

err = -EINVAL;

2083

err = -EINVAL;

2087

}

2084

}

2088

rtnl_unlock();

2085

rtnl_unlock();

2089

2086

2090

return err;

2087

return err;

2091

}

2088

}

2092

2089

2093

return -EINVAL;

2090

return -EINVAL;

2094

}

2091

}

2095

2092

2096

/*

2093

/*

2097

* Drop the packet on the floor

2094

* Drop the packet on the floor

2098

*/

2095

*/

2099

2096

2100

static int ip6_pkt_drop(struct sk_buff *skb, u8 code, int ipstats_mib_noroutes)

2097

static int ip6_pkt_drop(struct sk_buff *skb, u8 code, int ipstats_mib_noroutes)

2101

{

2098

{

2102

int type;

2099

int type;

2103

struct dst_entry *dst = skb_dst(skb);

2100

struct dst_entry *dst = skb_dst(skb);

2104

switch (ipstats_mib_noroutes) {

2101

switch (ipstats_mib_noroutes) {

2105

case IPSTATS_MIB_INNOROUTES:

2102

case IPSTATS_MIB_INNOROUTES:

2106

type = ipv6_addr_type(&ipv6_hdr(skb)->daddr);

2103

type = ipv6_addr_type(&ipv6_hdr(skb)->daddr);

2107

if (type == IPV6_ADDR_ANY) {

2104

if (type == IPV6_ADDR_ANY) {

2108

IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),

2105

IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),

2109

IPSTATS_MIB_INADDRERRORS);

2106

IPSTATS_MIB_INADDRERRORS);

2110

break;

2107

break;

2111

}

2108

}

2112

/* FALLTHROUGH */

2109

/* FALLTHROUGH */

2113

case IPSTATS_MIB_OUTNOROUTES:

2110

case IPSTATS_MIB_OUTNOROUTES:

2114

IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),

2111

IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),

2115

ipstats_mib_noroutes);

2112

ipstats_mib_noroutes);

2116

break;

2113

break;

2117

}

2114

}

2118

icmpv6_send(skb, ICMPV6_DEST_UNREACH, code, 0);

2115

icmpv6_send(skb, ICMPV6_DEST_UNREACH, code, 0);

2119

kfree_skb(skb);

2116

kfree_skb(skb);

2120

return 0;

2117

return 0;

2121

}

2118

}

2122

2119

2123

static int ip6_pkt_discard(struct sk_buff *skb)

2120

static int ip6_pkt_discard(struct sk_buff *skb)

2124

{

2121

{

2125

return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_INNOROUTES);

2122

return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_INNOROUTES);

2126

}

2123

}

2127

2124

2128

static int ip6_pkt_discard_out(struct sock *sk, struct sk_buff *skb)

2125

static int ip6_pkt_discard_out(struct sock *sk, struct sk_buff *skb)

2129

{

2126

{

2130

skb->dev = skb_dst(skb)->dev;

2127

skb->dev = skb_dst(skb)->dev;

2131

return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_OUTNOROUTES);

2128

return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_OUTNOROUTES);

2132

}

2129

}

2133

2130

2134

static int ip6_pkt_prohibit(struct sk_buff *skb)

2131

static int ip6_pkt_prohibit(struct sk_buff *skb)

2135

{

2132

{

2136

return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_INNOROUTES);

2133

return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_INNOROUTES);

2137

}

2134

}

2138

2135

2139

static int ip6_pkt_prohibit_out(struct sock *sk, struct sk_buff *skb)

2136

static int ip6_pkt_prohibit_out(struct sock *sk, struct sk_buff *skb)

2140

{

2137

{

2141

skb->dev = skb_dst(skb)->dev;

2138

skb->dev = skb_dst(skb)->dev;

2142

return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_OUTNOROUTES);

2139

return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_OUTNOROUTES);

2143

}

2140

}

2144

2141

2145

/*

2142

/*

2146

* Allocate a dst for local (unicast / anycast) address.

2143

* Allocate a dst for local (unicast / anycast) address.

2147

*/

2144

*/

2148

2145

2149

struct rt6_info *addrconf_dst_alloc(struct inet6_dev *idev,

2146

struct rt6_info *addrconf_dst_alloc(struct inet6_dev *idev,

2150

const struct in6_addr *addr,

2147

const struct in6_addr *addr,

2151

bool anycast)

2148

bool anycast)

2152

{

2149

{

2153

struct net *net = dev_net(idev->dev);

2150

struct net *net = dev_net(idev->dev);

2154

struct rt6_info *rt = ip6_dst_alloc(net, net->loopback_dev,

2151

struct rt6_info *rt = ip6_dst_alloc(net, net->loopback_dev,

2155

DST_NOCOUNT, NULL);

2152

DST_NOCOUNT, NULL);

2156

if (!rt)

2153

if (!rt)

2157

return ERR_PTR(-ENOMEM);

2154

return ERR_PTR(-ENOMEM);

2158

2155

2159

in6_dev_hold(idev);

2156

in6_dev_hold(idev);

2160

2157

2161

rt->dst.flags |= DST_HOST;

2158

rt->dst.flags |= DST_HOST;

2162

rt->dst.input = ip6_input;

2159

rt->dst.input = ip6_input;

2163

rt->dst.output = ip6_output;

2160

rt->dst.output = ip6_output;

2164

rt->rt6i_idev = idev;

2161

rt->rt6i_idev = idev;

2165

2162

2166

rt->rt6i_flags = RTF_UP | RTF_NONEXTHOP;

2163

rt->rt6i_flags = RTF_UP | RTF_NONEXTHOP;

2167

if (anycast)

2164

if (anycast)

2168

rt->rt6i_flags |= RTF_ANYCAST;

2165

rt->rt6i_flags |= RTF_ANYCAST;

2169

else

2166

else

2170

rt->rt6i_flags |= RTF_LOCAL;

2167

rt->rt6i_flags |= RTF_LOCAL;

2171

2168

2172

rt->rt6i_gateway = *addr;

2169

rt->rt6i_gateway = *addr;

2173

rt->rt6i_dst.addr = *addr;

2170

rt->rt6i_dst.addr = *addr;

2174

rt->rt6i_dst.plen = 128;

2171

rt->rt6i_dst.plen = 128;

2175

rt->rt6i_table = fib6_get_table(net, RT6_TABLE_LOCAL);

2172

rt->rt6i_table = fib6_get_table(net, RT6_TABLE_LOCAL);

2176

2173

2177

atomic_set(&rt->dst.__refcnt, 1);

2174

atomic_set(&rt->dst.__refcnt, 1);

2178

2175

2179

return rt;

2176

return rt;

2180

}

2177

}

2181

2178

2182

int ip6_route_get_saddr(struct net *net,

2179

int ip6_route_get_saddr(struct net *net,

2183

struct rt6_info *rt,

2180

struct rt6_info *rt,

2184

const struct in6_addr *daddr,

2181

const struct in6_addr *daddr,

2185

unsigned int prefs,

2182

unsigned int prefs,

2186

struct in6_addr *saddr)

2183

struct in6_addr *saddr)

2187

{

2184

{

2188

struct inet6_dev *idev = ip6_dst_idev((struct dst_entry *)rt);

2185

struct inet6_dev *idev = ip6_dst_idev((struct dst_entry *)rt);

2189

int err = 0;

2186

int err = 0;

2190

if (rt->rt6i_prefsrc.plen)

2187

if (rt->rt6i_prefsrc.plen)

2191

*saddr = rt->rt6i_prefsrc.addr;

2188

*saddr = rt->rt6i_prefsrc.addr;

2192

else

2189

else

2193

err = ipv6_dev_get_saddr(net, idev ? idev->dev : NULL,

2190

err = ipv6_dev_get_saddr(net, idev ? idev->dev : NULL,

2194

daddr, prefs, saddr);

2191

daddr, prefs, saddr);

2195

return err;

2192

return err;

2196

}

2193

}

2197

2194

2198

/* remove deleted ip from prefsrc entries */

2195

/* remove deleted ip from prefsrc entries */

2199

struct arg_dev_net_ip {

2196

struct arg_dev_net_ip {

2200

struct net_device *dev;

2197

struct net_device *dev;

2201

struct net *net;

2198

struct net *net;

2202

struct in6_addr *addr;

2199

struct in6_addr *addr;

2203

};

2200

};

2204

2201

2205

static int fib6_remove_prefsrc(struct rt6_info *rt, void *arg)

2202

static int fib6_remove_prefsrc(struct rt6_info *rt, void *arg)

2206

{

2203

{

2207

struct net_device *dev = ((struct arg_dev_net_ip *)arg)->dev;

2204

struct net_device *dev = ((struct arg_dev_net_ip *)arg)->dev;

2208

struct net *net = ((struct arg_dev_net_ip *)arg)->net;

2205

struct net *net = ((struct arg_dev_net_ip *)arg)->net;

2209

struct in6_addr *addr = ((struct arg_dev_net_ip *)arg)->addr;

2206

struct in6_addr *addr = ((struct arg_dev_net_ip *)arg)->addr;

2210

2207

2211

if (((void *)rt->dst.dev == dev || !dev) &&

2208

if (((void *)rt->dst.dev == dev || !dev) &&

2212

rt != net->ipv6.ip6_null_entry &&

2209

rt != net->ipv6.ip6_null_entry &&

2213

ipv6_addr_equal(addr, &rt->rt6i_prefsrc.addr)) {

2210

ipv6_addr_equal(addr, &rt->rt6i_prefsrc.addr)) {

2214

/* remove prefsrc entry */

2211

/* remove prefsrc entry */

2215

rt->rt6i_prefsrc.plen = 0;

2212

rt->rt6i_prefsrc.plen = 0;

2216

}

2213

}

2217

return 0;

2214

return 0;

2218

}

2215

}

2219

2216

2220

void rt6_remove_prefsrc(struct inet6_ifaddr *ifp)

2217

void rt6_remove_prefsrc(struct inet6_ifaddr *ifp)

2221

{

2218

{

2222

struct net *net = dev_net(ifp->idev->dev);

2219

struct net *net = dev_net(ifp->idev->dev);

2223

struct arg_dev_net_ip adni = {

2220

struct arg_dev_net_ip adni = {

2224

.dev = ifp->idev->dev,

2221

.dev = ifp->idev->dev,

2225

.net = net,

2222

.net = net,

2226

.addr = &ifp->addr,

2223

.addr = &ifp->addr,

2227

};

2224

};

2228

fib6_clean_all(net, fib6_remove_prefsrc, &adni);

2225

fib6_clean_all(net, fib6_remove_prefsrc, &adni);

2229

}

2226

}

2230

2227

2231

#define RTF_RA_ROUTER (RTF_ADDRCONF | RTF_DEFAULT | RTF_GATEWAY)

2228

#define RTF_RA_ROUTER (RTF_ADDRCONF | RTF_DEFAULT | RTF_GATEWAY)

2232

#define RTF_CACHE_GATEWAY (RTF_GATEWAY | RTF_CACHE)

2229

#define RTF_CACHE_GATEWAY (RTF_GATEWAY | RTF_CACHE)

2233

2230

2234

/* Remove routers and update dst entries when gateway turn into host. */

2231

/* Remove routers and update dst entries when gateway turn into host. */

2235

static int fib6_clean_tohost(struct rt6_info *rt, void *arg)

2232

static int fib6_clean_tohost(struct rt6_info *rt, void *arg)

2236

{

2233

{

2237

struct in6_addr *gateway = (struct in6_addr *)arg;

2234

struct in6_addr *gateway = (struct in6_addr *)arg;

2238

2235

2239

if ((((rt->rt6i_flags & RTF_RA_ROUTER) == RTF_RA_ROUTER) ||

2236

if ((((rt->rt6i_flags & RTF_RA_ROUTER) == RTF_RA_ROUTER) ||

2240

((rt->rt6i_flags & RTF_CACHE_GATEWAY) == RTF_CACHE_GATEWAY)) &&

2237

((rt->rt6i_flags & RTF_CACHE_GATEWAY) == RTF_CACHE_GATEWAY)) &&

2241

ipv6_addr_equal(gateway, &rt->rt6i_gateway)) {

2238

ipv6_addr_equal(gateway, &rt->rt6i_gateway)) {

2242

return -1;

2239

return -1;

2243

}

2240

}

2244

return 0;

2241

return 0;

2245

}

2242

}

2246

2243

2247

void rt6_clean_tohost(struct net *net, struct in6_addr *gateway)

2244

void rt6_clean_tohost(struct net *net, struct in6_addr *gateway)

2248

{

2245

{

2249

fib6_clean_all(net, fib6_clean_tohost, gateway);

2246

fib6_clean_all(net, fib6_clean_tohost, gateway);

2250

}

2247

}

2251

2248

2252

struct arg_dev_net {

2249

struct arg_dev_net {

2253

struct net_device *dev;

2250

struct net_device *dev;

2254

struct net *net;

2251

struct net *net;

2255

};

2252

};

2256

2253

2257

static int fib6_ifdown(struct rt6_info *rt, void *arg)

2254

static int fib6_ifdown(struct rt6_info *rt, void *arg)

2258

{

2255

{

2259

const struct arg_dev_net *adn = arg;

2256

const struct arg_dev_net *adn = arg;

2260

const struct net_device *dev = adn->dev;

2257

const struct net_device *dev = adn->dev;

2261

2258

2262

if ((rt->dst.dev == dev || !dev) &&

2259

if ((rt->dst.dev == dev || !dev) &&

2263

rt != adn->net->ipv6.ip6_null_entry)

2260

rt != adn->net->ipv6.ip6_null_entry)

2264

return -1;

2261

return -1;

2265

2262

2266

return 0;

2263

return 0;

2267

}

2264

}

2268

2265

2269

void rt6_ifdown(struct net *net, struct net_device *dev)

2266

void rt6_ifdown(struct net *net, struct net_device *dev)

2270

{

2267

{

2271

struct arg_dev_net adn = {

2268

struct arg_dev_net adn = {

2272

.dev = dev,

2269

.dev = dev,

2273

.net = net,

2270

.net = net,

2274

};

2271

};

2275

2272

2276

fib6_clean_all(net, fib6_ifdown, &adn);

2273

fib6_clean_all(net, fib6_ifdown, &adn);

2277

icmp6_clean_all(fib6_ifdown, &adn);

2274

icmp6_clean_all(fib6_ifdown, &adn);

2278

}

2275

}

2279

2276

2280

struct rt6_mtu_change_arg {

2277

struct rt6_mtu_change_arg {

2281

struct net_device *dev;

2278

struct net_device *dev;

2282

unsigned int mtu;

2279

unsigned int mtu;

2283

};

2280

};

2284

2281

2285

static int rt6_mtu_change_route(struct rt6_info *rt, void *p_arg)

2282

static int rt6_mtu_change_route(struct rt6_info *rt, void *p_arg)

2286

{

2283

{

2287

struct rt6_mtu_change_arg *arg = (struct rt6_mtu_change_arg *) p_arg;

2284

struct rt6_mtu_change_arg *arg = (struct rt6_mtu_change_arg *) p_arg;

2288

struct inet6_dev *idev;

2285

struct inet6_dev *idev;

2289

2286

2290

/* In IPv6 pmtu discovery is not optional,

2287

/* In IPv6 pmtu discovery is not optional,

2291

so that RTAX_MTU lock cannot disable it.

2288

so that RTAX_MTU lock cannot disable it.

2292

We still use this lock to block changes

2289

We still use this lock to block changes

2293

caused by addrconf/ndisc.

2290

caused by addrconf/ndisc.

2294

*/

2291

*/

2295

2292

2296

idev = __in6_dev_get(arg->dev);

2293

idev = __in6_dev_get(arg->dev);

2297

if (!idev)

2294

if (!idev)

2298

return 0;

2295

return 0;

2299

2296

2300

/* For administrative MTU increase, there is no way to discover

2297

/* For administrative MTU increase, there is no way to discover

2301

IPv6 PMTU increase, so PMTU increase should be updated here.

2298

IPv6 PMTU increase, so PMTU increase should be updated here.

2302

Since RFC 1981 doesn't include administrative MTU increase

2299

Since RFC 1981 doesn't include administrative MTU increase

2303

update PMTU increase is a MUST. (i.e. jumbo frame)

2300

update PMTU increase is a MUST. (i.e. jumbo frame)

2304

*/

2301

*/

2305

/*

2302

/*

2306

If new MTU is less than route PMTU, this new MTU will be the

2303

If new MTU is less than route PMTU, this new MTU will be the

2307

lowest MTU in the path, update the route PMTU to reflect PMTU

2304

lowest MTU in the path, update the route PMTU to reflect PMTU

2308

decreases; if new MTU is greater than route PMTU, and the

2305

decreases; if new MTU is greater than route PMTU, and the

2309

old MTU is the lowest MTU in the path, update the route PMTU

2306

old MTU is the lowest MTU in the path, update the route PMTU

2310

to reflect the increase. In this case if the other nodes' MTU

2307

to reflect the increase. In this case if the other nodes' MTU

2311

also have the lowest MTU, TOO BIG MESSAGE will be lead to

2308

also have the lowest MTU, TOO BIG MESSAGE will be lead to

2312

PMTU discouvery.

2309

PMTU discouvery.

2313

*/

2310

*/

2314

if (rt->dst.dev == arg->dev &&

2311

if (rt->dst.dev == arg->dev &&

2315

!dst_metric_locked(&rt->dst, RTAX_MTU) &&

2312

!dst_metric_locked(&rt->dst, RTAX_MTU) &&

2316

(dst_mtu(&rt->dst) >= arg->mtu ||

2313

(dst_mtu(&rt->dst) >= arg->mtu ||

2317

(dst_mtu(&rt->dst) < arg->mtu &&

2314

(dst_mtu(&rt->dst) < arg->mtu &&

2318

dst_mtu(&rt->dst) == idev->cnf.mtu6))) {

2315

dst_mtu(&rt->dst) == idev->cnf.mtu6))) {

2319

dst_metric_set(&rt->dst, RTAX_MTU, arg->mtu);

2316

dst_metric_set(&rt->dst, RTAX_MTU, arg->mtu);

2320

}

2317

}

2321

return 0;

2318

return 0;

2322

}

2319

}

2323

2320

2324

void rt6_mtu_change(struct net_device *dev, unsigned int mtu)

2321

void rt6_mtu_change(struct net_device *dev, unsigned int mtu)

2325

{

2322

{

2326

struct rt6_mtu_change_arg arg = {

2323

struct rt6_mtu_change_arg arg = {

2327

.dev = dev,

2324

.dev = dev,

2328

.mtu = mtu,

2325

.mtu = mtu,

2329

};

2326

};

2330

2327

2331

fib6_clean_all(dev_net(dev), rt6_mtu_change_route, &arg);

2328

fib6_clean_all(dev_net(dev), rt6_mtu_change_route, &arg);

2332

}

2329

}

2333

2330

2334

static const struct nla_policy rtm_ipv6_policy[RTA_MAX+1] = {

2331

static const struct nla_policy rtm_ipv6_policy[RTA_MAX+1] = {

2335

[RTA_GATEWAY] = { .len = sizeof(struct in6_addr) },

2332

[RTA_GATEWAY] = { .len = sizeof(struct in6_addr) },

2336

[RTA_OIF] = { .type = NLA_U32 },

2333

[RTA_OIF] = { .type = NLA_U32 },

2337

[RTA_IIF] = { .type = NLA_U32 },

2334

[RTA_IIF] = { .type = NLA_U32 },

2338

[RTA_PRIORITY] = { .type = NLA_U32 },

2335

[RTA_PRIORITY] = { .type = NLA_U32 },

2339

[RTA_METRICS] = { .type = NLA_NESTED },

2336

[RTA_METRICS] = { .type = NLA_NESTED },

2340

[RTA_MULTIPATH] = { .len = sizeof(struct rtnexthop) },

2337

[RTA_MULTIPATH] = { .len = sizeof(struct rtnexthop) },

2341

};

2338

};

2342

2339

2343

static int rtm_to_fib6_config(struct sk_buff *skb, struct nlmsghdr *nlh,

2340

static int rtm_to_fib6_config(struct sk_buff *skb, struct nlmsghdr *nlh,

2344

struct fib6_config *cfg)

2341

struct fib6_config *cfg)

2345

{

2342

{

2346

struct rtmsg *rtm;

2343

struct rtmsg *rtm;

2347

struct nlattr *tb[RTA_MAX+1];

2344

struct nlattr *tb[RTA_MAX+1];

2348

int err;

2345

int err;

2349

2346

2350

err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);

2347

err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);

2351

if (err < 0)

2348

if (err < 0)

2352

goto errout;

2349

goto errout;

2353

2350

2354

err = -EINVAL;

2351

err = -EINVAL;

2355

rtm = nlmsg_data(nlh);

2352

rtm = nlmsg_data(nlh);

2356

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

2353

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

2357

2354

2358

cfg->fc_table = rtm->rtm_table;

2355

cfg->fc_table = rtm->rtm_table;

2359

cfg->fc_dst_len = rtm->rtm_dst_len;

2356

cfg->fc_dst_len = rtm->rtm_dst_len;

2360

cfg->fc_src_len = rtm->rtm_src_len;

2357

cfg->fc_src_len = rtm->rtm_src_len;

2361

cfg->fc_flags = RTF_UP;

2358

cfg->fc_flags = RTF_UP;

2362

cfg->fc_protocol = rtm->rtm_protocol;

2359

cfg->fc_protocol = rtm->rtm_protocol;

2363

cfg->fc_type = rtm->rtm_type;

2360

cfg->fc_type = rtm->rtm_type;

2364

2361

2365

if (rtm->rtm_type == RTN_UNREACHABLE ||

2362

if (rtm->rtm_type == RTN_UNREACHABLE ||

2366

rtm->rtm_type == RTN_BLACKHOLE ||

2363

rtm->rtm_type == RTN_BLACKHOLE ||

2367

rtm->rtm_type == RTN_PROHIBIT ||

2364

rtm->rtm_type == RTN_PROHIBIT ||

2368

rtm->rtm_type == RTN_THROW)

2365

rtm->rtm_type == RTN_THROW)

2369

cfg->fc_flags |= RTF_REJECT;

2366

cfg->fc_flags |= RTF_REJECT;

2370

2367

2371

if (rtm->rtm_type == RTN_LOCAL)

2368

if (rtm->rtm_type == RTN_LOCAL)

2372

cfg->fc_flags |= RTF_LOCAL;

2369

cfg->fc_flags |= RTF_LOCAL;

2373

2370

2374

cfg->fc_nlinfo.portid = NETLINK_CB(skb).portid;

2371

cfg->fc_nlinfo.portid = NETLINK_CB(skb).portid;

2375

cfg->fc_nlinfo.nlh = nlh;

2372

cfg->fc_nlinfo.nlh = nlh;

2376

cfg->fc_nlinfo.nl_net = sock_net(skb->sk);

2373

cfg->fc_nlinfo.nl_net = sock_net(skb->sk);

2377

2374

2378

if (tb[RTA_GATEWAY]) {

2375

if (tb[RTA_GATEWAY]) {

2379

nla_memcpy(&cfg->fc_gateway, tb[RTA_GATEWAY], 16);

2376

nla_memcpy(&cfg->fc_gateway, tb[RTA_GATEWAY], 16);

2380

cfg->fc_flags |= RTF_GATEWAY;

2377

cfg->fc_flags |= RTF_GATEWAY;

2381

}

2378

}

2382

2379

2383

if (tb[RTA_DST]) {

2380

if (tb[RTA_DST]) {

2384

int plen = (rtm->rtm_dst_len + 7) >> 3;

2381

int plen = (rtm->rtm_dst_len + 7) >> 3;

2385

2382

2386

if (nla_len(tb[RTA_DST]) < plen)

2383

if (nla_len(tb[RTA_DST]) < plen)

2387

goto errout;

2384

goto errout;

2388

2385

2389

nla_memcpy(&cfg->fc_dst, tb[RTA_DST], plen);

2386

nla_memcpy(&cfg->fc_dst, tb[RTA_DST], plen);

2390

}

2387

}

2391

2388

2392

if (tb[RTA_SRC]) {

2389

if (tb[RTA_SRC]) {

2393

int plen = (rtm->rtm_src_len + 7) >> 3;

2390

int plen = (rtm->rtm_src_len + 7) >> 3;

2394

2391

2395

if (nla_len(tb[RTA_SRC]) < plen)

2392

if (nla_len(tb[RTA_SRC]) < plen)

2396

goto errout;

2393

goto errout;

2397

2394

2398

nla_memcpy(&cfg->fc_src, tb[RTA_SRC], plen);

2395

nla_memcpy(&cfg->fc_src, tb[RTA_SRC], plen);

2399

}

2396

}

2400

2397

2401

if (tb[RTA_PREFSRC])

2398

if (tb[RTA_PREFSRC])

2402

nla_memcpy(&cfg->fc_prefsrc, tb[RTA_PREFSRC], 16);

2399

nla_memcpy(&cfg->fc_prefsrc, tb[RTA_PREFSRC], 16);

2403

2400

2404

if (tb[RTA_OIF])

2401

if (tb[RTA_OIF])

2405

cfg->fc_ifindex = nla_get_u32(tb[RTA_OIF]);

2402

cfg->fc_ifindex = nla_get_u32(tb[RTA_OIF]);

2406

2403

2407

if (tb[RTA_PRIORITY])

2404

if (tb[RTA_PRIORITY])

2408

cfg->fc_metric = nla_get_u32(tb[RTA_PRIORITY]);

2405

cfg->fc_metric = nla_get_u32(tb[RTA_PRIORITY]);

2409

2406

2410

if (tb[RTA_METRICS]) {

2407

if (tb[RTA_METRICS]) {

2411

cfg->fc_mx = nla_data(tb[RTA_METRICS]);

2408

cfg->fc_mx = nla_data(tb[RTA_METRICS]);

2412

cfg->fc_mx_len = nla_len(tb[RTA_METRICS]);

2409

cfg->fc_mx_len = nla_len(tb[RTA_METRICS]);

2413

}

2410

}

2414

2411

2415

if (tb[RTA_TABLE])

2412

if (tb[RTA_TABLE])

2416

cfg->fc_table = nla_get_u32(tb[RTA_TABLE]);

2413

cfg->fc_table = nla_get_u32(tb[RTA_TABLE]);

2417

2414

2418

if (tb[RTA_MULTIPATH]) {

2415

if (tb[RTA_MULTIPATH]) {

2419

cfg->fc_mp = nla_data(tb[RTA_MULTIPATH]);

2416

cfg->fc_mp = nla_data(tb[RTA_MULTIPATH]);

2420

cfg->fc_mp_len = nla_len(tb[RTA_MULTIPATH]);

2417

cfg->fc_mp_len = nla_len(tb[RTA_MULTIPATH]);

2421

}

2418

}

2422

2419

2423

err = 0;

2420

err = 0;

2424

errout:

2421

errout:

2425

return err;

2422

return err;

2426

}

2423

}

2427

2424

2428

static int ip6_route_multipath(struct fib6_config *cfg, int add)

2425

static int ip6_route_multipath(struct fib6_config *cfg, int add)

2429

{

2426

{

2430

struct fib6_config r_cfg;

2427

struct fib6_config r_cfg;

2431

struct rtnexthop *rtnh;

2428

struct rtnexthop *rtnh;

2432

int remaining;

2429

int remaining;

2433

int attrlen;

2430

int attrlen;

2434

int err = 0, last_err = 0;

2431

int err = 0, last_err = 0;

2435

2432

2436

beginning:

2433

beginning:

2437

rtnh = (struct rtnexthop *)cfg->fc_mp;

2434

rtnh = (struct rtnexthop *)cfg->fc_mp;

2438

remaining = cfg->fc_mp_len;

2435

remaining = cfg->fc_mp_len;

2439

2436

2440

/* Parse a Multipath Entry */

2437

/* Parse a Multipath Entry */

2441

while (rtnh_ok(rtnh, remaining)) {

2438

while (rtnh_ok(rtnh, remaining)) {

2442

memcpy(&r_cfg, cfg, sizeof(*cfg));

2439

memcpy(&r_cfg, cfg, sizeof(*cfg));

2443

if (rtnh->rtnh_ifindex)

2440

if (rtnh->rtnh_ifindex)

2444

r_cfg.fc_ifindex = rtnh->rtnh_ifindex;

2441

r_cfg.fc_ifindex = rtnh->rtnh_ifindex;

2445

2442

2446

attrlen = rtnh_attrlen(rtnh);

2443

attrlen = rtnh_attrlen(rtnh);

2447

if (attrlen > 0) {

2444

if (attrlen > 0) {

2448

struct nlattr *nla, *attrs = rtnh_attrs(rtnh);

2445

struct nlattr *nla, *attrs = rtnh_attrs(rtnh);

2449

2446

2450

nla = nla_find(attrs, attrlen, RTA_GATEWAY);

2447

nla = nla_find(attrs, attrlen, RTA_GATEWAY);

2451

if (nla) {

2448

if (nla) {

2452

nla_memcpy(&r_cfg.fc_gateway, nla, 16);

2449

nla_memcpy(&r_cfg.fc_gateway, nla, 16);

2453

r_cfg.fc_flags |= RTF_GATEWAY;

2450

r_cfg.fc_flags |= RTF_GATEWAY;

2454

}

2451

}

2455

}

2452

}

2456

err = add ? ip6_route_add(&r_cfg) : ip6_route_del(&r_cfg);

2453

err = add ? ip6_route_add(&r_cfg) : ip6_route_del(&r_cfg);

2457

if (err) {

2454

if (err) {

2458

last_err = err;

2455

last_err = err;

2459

/* If we are trying to remove a route, do not stop the

2456

/* If we are trying to remove a route, do not stop the

2460

* loop when ip6_route_del() fails (because next hop is

2457

* loop when ip6_route_del() fails (because next hop is

2461

* already gone), we should try to remove all next hops.

2458

* already gone), we should try to remove all next hops.

2462

*/

2459

*/

2463

if (add) {

2460

if (add) {

2464

/* If add fails, we should try to delete all

2461

/* If add fails, we should try to delete all

2465

* next hops that have been already added.

2462

* next hops that have been already added.

2466

*/

2463

*/

2467

add = 0;

2464

add = 0;

2468

goto beginning;

2465

goto beginning;

2469

}

2466

}

2470

}

2467

}

2471

/* Because each route is added like a single route we remove

2468

/* Because each route is added like a single route we remove

2472

* this flag after the first nexthop (if there is a collision,

2469

* this flag after the first nexthop (if there is a collision,

2473

* we have already fail to add the first nexthop:

2470

* we have already fail to add the first nexthop:

2474

* fib6_add_rt2node() has reject it).

2471

* fib6_add_rt2node() has reject it).

2475

*/

2472

*/

2476

cfg->fc_nlinfo.nlh->nlmsg_flags &= ~NLM_F_EXCL;

2473

cfg->fc_nlinfo.nlh->nlmsg_flags &= ~NLM_F_EXCL;

2477

rtnh = rtnh_next(rtnh, &remaining);

2474

rtnh = rtnh_next(rtnh, &remaining);

2478

}

2475

}

2479

2476

2480

return last_err;

2477

return last_err;

2481

}

2478

}

2482

2479

2483

static int inet6_rtm_delroute(struct sk_buff *skb, struct nlmsghdr *nlh)

2480

static int inet6_rtm_delroute(struct sk_buff *skb, struct nlmsghdr *nlh)

2484

{

2481

{

2485

struct fib6_config cfg;

2482

struct fib6_config cfg;

2486

int err;

2483

int err;

2487

2484

2488

err = rtm_to_fib6_config(skb, nlh, &cfg);

2485

err = rtm_to_fib6_config(skb, nlh, &cfg);

2489

if (err < 0)

2486

if (err < 0)

2490

return err;

2487

return err;

2491

2488

2492

if (cfg.fc_mp)

2489

if (cfg.fc_mp)

2493

return ip6_route_multipath(&cfg, 0);

2490

return ip6_route_multipath(&cfg, 0);

2494

else

2491

else

2495

return ip6_route_del(&cfg);

2492

return ip6_route_del(&cfg);

2496

}

2493

}

2497

2494

2498

static int inet6_rtm_newroute(struct sk_buff *skb, struct nlmsghdr *nlh)

2495

static int inet6_rtm_newroute(struct sk_buff *skb, struct nlmsghdr *nlh)

2499

{

2496

{

2500

struct fib6_config cfg;

2497

struct fib6_config cfg;

2501

int err;

2498

int err;

2502

2499

2503

err = rtm_to_fib6_config(skb, nlh, &cfg);

2500

err = rtm_to_fib6_config(skb, nlh, &cfg);

2504

if (err < 0)

2501

if (err < 0)

2505

return err;

2502

return err;

2506

2503

2507

if (cfg.fc_mp)

2504

if (cfg.fc_mp)

2508

return ip6_route_multipath(&cfg, 1);

2505

return ip6_route_multipath(&cfg, 1);

2509

else

2506

else

2510

return ip6_route_add(&cfg);

2507

return ip6_route_add(&cfg);

2511

}

2508

}

2512

2509

2513

static inline size_t rt6_nlmsg_size(void)

2510

static inline size_t rt6_nlmsg_size(void)

2514

{

2511

{

2515

return NLMSG_ALIGN(sizeof(struct rtmsg))

2512

return NLMSG_ALIGN(sizeof(struct rtmsg))

2516

+ nla_total_size(16) /* RTA_SRC */

2513

+ nla_total_size(16) /* RTA_SRC */

2517

+ nla_total_size(16) /* RTA_DST */

2514

+ nla_total_size(16) /* RTA_DST */

2518

+ nla_total_size(16) /* RTA_GATEWAY */

2515

+ nla_total_size(16) /* RTA_GATEWAY */

2519

+ nla_total_size(16) /* RTA_PREFSRC */

2516

+ nla_total_size(16) /* RTA_PREFSRC */

2520

+ nla_total_size(4) /* RTA_TABLE */

2517

+ nla_total_size(4) /* RTA_TABLE */

2521

+ nla_total_size(4) /* RTA_IIF */

2518

+ nla_total_size(4) /* RTA_IIF */

2522

+ nla_total_size(4) /* RTA_OIF */

2519

+ nla_total_size(4) /* RTA_OIF */

2523

+ nla_total_size(4) /* RTA_PRIORITY */

2520

+ nla_total_size(4) /* RTA_PRIORITY */

2524

+ RTAX_MAX * nla_total_size(4) /* RTA_METRICS */

2521

+ RTAX_MAX * nla_total_size(4) /* RTA_METRICS */

2525

+ nla_total_size(sizeof(struct rta_cacheinfo));

2522

+ nla_total_size(sizeof(struct rta_cacheinfo));

2526

}

2523

}

2527

2524

2528

static int rt6_fill_node(struct net *net,

2525

static int rt6_fill_node(struct net *net,

2529

struct sk_buff *skb, struct rt6_info *rt,

2526

struct sk_buff *skb, struct rt6_info *rt,

2530

struct in6_addr *dst, struct in6_addr *src,

2527

struct in6_addr *dst, struct in6_addr *src,

2531

int iif, int type, u32 portid, u32 seq,

2528

int iif, int type, u32 portid, u32 seq,

2532

int prefix, int nowait, unsigned int flags)

2529

int prefix, int nowait, unsigned int flags)

2533

{

2530

{

2534

struct rtmsg *rtm;

2531

struct rtmsg *rtm;

2535

struct nlmsghdr *nlh;

2532

struct nlmsghdr *nlh;

2536

long expires;

2533

long expires;

2537

u32 table;

2534

u32 table;

2538

2535

2539

if (prefix) { /* user wants prefix routes only */

2536

if (prefix) { /* user wants prefix routes only */

2540

if (!(rt->rt6i_flags & RTF_PREFIX_RT)) {

2537

if (!(rt->rt6i_flags & RTF_PREFIX_RT)) {

2541

/* success since this is not a prefix route */

2538

/* success since this is not a prefix route */

2542

return 1;

2539

return 1;

2543

}

2540

}

2544

}

2541

}

2545

2542

2546

nlh = nlmsg_put(skb, portid, seq, type, sizeof(*rtm), flags);

2543

nlh = nlmsg_put(skb, portid, seq, type, sizeof(*rtm), flags);

2547

if (!nlh)

2544

if (!nlh)

2548

return -EMSGSIZE;

2545

return -EMSGSIZE;

2549

2546

2550

rtm = nlmsg_data(nlh);

2547

rtm = nlmsg_data(nlh);

2551

rtm->rtm_family = AF_INET6;

2548

rtm->rtm_family = AF_INET6;

2552

rtm->rtm_dst_len = rt->rt6i_dst.plen;

2549

rtm->rtm_dst_len = rt->rt6i_dst.plen;

2553

rtm->rtm_src_len = rt->rt6i_src.plen;

2550

rtm->rtm_src_len = rt->rt6i_src.plen;

2554

rtm->rtm_tos = 0;

2551

rtm->rtm_tos = 0;

2555

if (rt->rt6i_table)

2552

if (rt->rt6i_table)

2556

table = rt->rt6i_table->tb6_id;

2553

table = rt->rt6i_table->tb6_id;

2557

else

2554

else

2558

table = RT6_TABLE_UNSPEC;

2555

table = RT6_TABLE_UNSPEC;

2559

rtm->rtm_table = table;

2556

rtm->rtm_table = table;

2560

if (nla_put_u32(skb, RTA_TABLE, table))

2557

if (nla_put_u32(skb, RTA_TABLE, table))

2561

goto nla_put_failure;

2558

goto nla_put_failure;

2562

if (rt->rt6i_flags & RTF_REJECT) {

2559

if (rt->rt6i_flags & RTF_REJECT) {

2563

switch (rt->dst.error) {

2560

switch (rt->dst.error) {

2564

case -EINVAL:

2561

case -EINVAL:

2565

rtm->rtm_type = RTN_BLACKHOLE;

2562

rtm->rtm_type = RTN_BLACKHOLE;

2566

break;

2563

break;

2567

case -EACCES:

2564

case -EACCES:

2568

rtm->rtm_type = RTN_PROHIBIT;

2565

rtm->rtm_type = RTN_PROHIBIT;

2569

break;

2566

break;

2570

case -EAGAIN:

2567

case -EAGAIN:

2571

rtm->rtm_type = RTN_THROW;

2568

rtm->rtm_type = RTN_THROW;

2572

break;

2569

break;

2573

default:

2570

default:

2574

rtm->rtm_type = RTN_UNREACHABLE;

2571

rtm->rtm_type = RTN_UNREACHABLE;

2575

break;

2572

break;

2576

}

2573

}

2577

}

2574

}

2578

else if (rt->rt6i_flags & RTF_LOCAL)

2575

else if (rt->rt6i_flags & RTF_LOCAL)

2579

rtm->rtm_type = RTN_LOCAL;

2576

rtm->rtm_type = RTN_LOCAL;

2580

else if (rt->dst.dev && (rt->dst.dev->flags & IFF_LOOPBACK))

2577

else if (rt->dst.dev && (rt->dst.dev->flags & IFF_LOOPBACK))

2581

rtm->rtm_type = RTN_LOCAL;

2578

rtm->rtm_type = RTN_LOCAL;

2582

else

2579

else

2583

rtm->rtm_type = RTN_UNICAST;

2580

rtm->rtm_type = RTN_UNICAST;

2584

rtm->rtm_flags = 0;

2581

rtm->rtm_flags = 0;

2585

rtm->rtm_scope = RT_SCOPE_UNIVERSE;

2582

rtm->rtm_scope = RT_SCOPE_UNIVERSE;

2586

rtm->rtm_protocol = rt->rt6i_protocol;

2583

rtm->rtm_protocol = rt->rt6i_protocol;

2587

if (rt->rt6i_flags & RTF_DYNAMIC)

2584

if (rt->rt6i_flags & RTF_DYNAMIC)

2588

rtm->rtm_protocol = RTPROT_REDIRECT;

2585

rtm->rtm_protocol = RTPROT_REDIRECT;

2589

else if (rt->rt6i_flags & RTF_ADDRCONF) {

2586

else if (rt->rt6i_flags & RTF_ADDRCONF) {

2590

if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ROUTEINFO))

2587

if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ROUTEINFO))

2591

rtm->rtm_protocol = RTPROT_RA;

2588

rtm->rtm_protocol = RTPROT_RA;

2592

else

2589

else

2593

rtm->rtm_protocol = RTPROT_KERNEL;

2590

rtm->rtm_protocol = RTPROT_KERNEL;

2594

}

2591

}

2595

2592

2596

if (rt->rt6i_flags & RTF_CACHE)

2593

if (rt->rt6i_flags & RTF_CACHE)

2597

rtm->rtm_flags |= RTM_F_CLONED;

2594

rtm->rtm_flags |= RTM_F_CLONED;

2598

2595

2599

if (dst) {

2596

if (dst) {

2600

if (nla_put(skb, RTA_DST, 16, dst))

2597

if (nla_put(skb, RTA_DST, 16, dst))

2601

goto nla_put_failure;

2598

goto nla_put_failure;

2602

rtm->rtm_dst_len = 128;

2599

rtm->rtm_dst_len = 128;

2603

} else if (rtm->rtm_dst_len)

2600

} else if (rtm->rtm_dst_len)

2604

if (nla_put(skb, RTA_DST, 16, &rt->rt6i_dst.addr))

2601

if (nla_put(skb, RTA_DST, 16, &rt->rt6i_dst.addr))

2605

goto nla_put_failure;

2602

goto nla_put_failure;

2606

#ifdef CONFIG_IPV6_SUBTREES

2603

#ifdef CONFIG_IPV6_SUBTREES

2607

if (src) {

2604

if (src) {

2608

if (nla_put(skb, RTA_SRC, 16, src))

2605

if (nla_put(skb, RTA_SRC, 16, src))

2609

goto nla_put_failure;

2606

goto nla_put_failure;

2610

rtm->rtm_src_len = 128;

2607

rtm->rtm_src_len = 128;

2611

} else if (rtm->rtm_src_len &&

2608

} else if (rtm->rtm_src_len &&

2612

nla_put(skb, RTA_SRC, 16, &rt->rt6i_src.addr))

2609

nla_put(skb, RTA_SRC, 16, &rt->rt6i_src.addr))

2613

goto nla_put_failure;

2610

goto nla_put_failure;

2614

#endif

2611

#endif

2615

if (iif) {

2612

if (iif) {

2616

#ifdef CONFIG_IPV6_MROUTE

2613

#ifdef CONFIG_IPV6_MROUTE

2617

if (ipv6_addr_is_multicast(&rt->rt6i_dst.addr)) {

2614

if (ipv6_addr_is_multicast(&rt->rt6i_dst.addr)) {

2618

int err = ip6mr_get_route(net, skb, rtm, nowait);

2615

int err = ip6mr_get_route(net, skb, rtm, nowait);

2619

if (err <= 0) {

2616

if (err <= 0) {

2620

if (!nowait) {

2617

if (!nowait) {

2621

if (err == 0)

2618

if (err == 0)

2622

return 0;

2619

return 0;

2623

goto nla_put_failure;

2620

goto nla_put_failure;

2624

} else {

2621

} else {

2625

if (err == -EMSGSIZE)

2622

if (err == -EMSGSIZE)

2626

goto nla_put_failure;

2623

goto nla_put_failure;

2627

}

2624

}

2628

}

2625

}

2629

} else

2626

} else

2630

#endif

2627

#endif

2631

if (nla_put_u32(skb, RTA_IIF, iif))

2628

if (nla_put_u32(skb, RTA_IIF, iif))

2632

goto nla_put_failure;

2629

goto nla_put_failure;

2633

} else if (dst) {

2630

} else if (dst) {

2634

struct in6_addr saddr_buf;

2631

struct in6_addr saddr_buf;

2635

if (ip6_route_get_saddr(net, rt, dst, 0, &saddr_buf) == 0 &&

2632

if (ip6_route_get_saddr(net, rt, dst, 0, &saddr_buf) == 0 &&

2636

nla_put(skb, RTA_PREFSRC, 16, &saddr_buf))

2633

nla_put(skb, RTA_PREFSRC, 16, &saddr_buf))

2637

goto nla_put_failure;

2634

goto nla_put_failure;

2638

}

2635

}

2639

2636

2640

if (rt->rt6i_prefsrc.plen) {

2637

if (rt->rt6i_prefsrc.plen) {

2641

struct in6_addr saddr_buf;

2638

struct in6_addr saddr_buf;

2642

saddr_buf = rt->rt6i_prefsrc.addr;

2639

saddr_buf = rt->rt6i_prefsrc.addr;

2643

if (nla_put(skb, RTA_PREFSRC, 16, &saddr_buf))

2640

if (nla_put(skb, RTA_PREFSRC, 16, &saddr_buf))

2644

goto nla_put_failure;

2641

goto nla_put_failure;

2645

}

2642

}

2646

2643

2647

if (rtnetlink_put_metrics(skb, dst_metrics_ptr(&rt->dst)) < 0)

2644

if (rtnetlink_put_metrics(skb, dst_metrics_ptr(&rt->dst)) < 0)

2648

goto nla_put_failure;

2645

goto nla_put_failure;

2649

2646

2650

if (rt->rt6i_flags & RTF_GATEWAY) {

2647

if (rt->rt6i_flags & RTF_GATEWAY) {

2651

if (nla_put(skb, RTA_GATEWAY, 16, &rt->rt6i_gateway) < 0)

2648

if (nla_put(skb, RTA_GATEWAY, 16, &rt->rt6i_gateway) < 0)

2652

goto nla_put_failure;

2649

goto nla_put_failure;

2653

}

2650

}

2654

2651

2655

if (rt->dst.dev &&

2652

if (rt->dst.dev &&

2656

nla_put_u32(skb, RTA_OIF, rt->dst.dev->ifindex))

2653

nla_put_u32(skb, RTA_OIF, rt->dst.dev->ifindex))

2657

goto nla_put_failure;

2654

goto nla_put_failure;

2658

if (nla_put_u32(skb, RTA_PRIORITY, rt->rt6i_metric))

2655

if (nla_put_u32(skb, RTA_PRIORITY, rt->rt6i_metric))

2659

goto nla_put_failure;

2656

goto nla_put_failure;

2660

2657

2661

expires = (rt->rt6i_flags & RTF_EXPIRES) ? rt->dst.expires - jiffies : 0;

2658

expires = (rt->rt6i_flags & RTF_EXPIRES) ? rt->dst.expires - jiffies : 0;

2662

2659

2663

if (rtnl_put_cacheinfo(skb, &rt->dst, 0, expires, rt->dst.error) < 0)

2660

if (rtnl_put_cacheinfo(skb, &rt->dst, 0, expires, rt->dst.error) < 0)

2664

goto nla_put_failure;

2661

goto nla_put_failure;

2665

2662

2666

return nlmsg_end(skb, nlh);

2663

return nlmsg_end(skb, nlh);

2667

2664

2668

nla_put_failure:

2665

nla_put_failure:

2669

nlmsg_cancel(skb, nlh);

2666

nlmsg_cancel(skb, nlh);

2670

return -EMSGSIZE;

2667

return -EMSGSIZE;

2671

}

2668

}

2672

2669

2673

int rt6_dump_route(struct rt6_info *rt, void *p_arg)

2670

int rt6_dump_route(struct rt6_info *rt, void *p_arg)

2674

{

2671

{

2675

struct rt6_rtnl_dump_arg *arg = (struct rt6_rtnl_dump_arg *) p_arg;

2672

struct rt6_rtnl_dump_arg *arg = (struct rt6_rtnl_dump_arg *) p_arg;

2676

int prefix;

2673

int prefix;

2677

2674

2678

if (nlmsg_len(arg->cb->nlh) >= sizeof(struct rtmsg)) {

2675

if (nlmsg_len(arg->cb->nlh) >= sizeof(struct rtmsg)) {

2679

struct rtmsg *rtm = nlmsg_data(arg->cb->nlh);

2676

struct rtmsg *rtm = nlmsg_data(arg->cb->nlh);

2680

prefix = (rtm->rtm_flags & RTM_F_PREFIX) != 0;

2677

prefix = (rtm->rtm_flags & RTM_F_PREFIX) != 0;

2681

} else

2678

} else

2682

prefix = 0;

2679

prefix = 0;

2683

2680

2684

return rt6_fill_node(arg->net,

2681

return rt6_fill_node(arg->net,

2685

arg->skb, rt, NULL, NULL, 0, RTM_NEWROUTE,

2682

arg->skb, rt, NULL, NULL, 0, RTM_NEWROUTE,

2686

NETLINK_CB(arg->cb->skb).portid, arg->cb->nlh->nlmsg_seq,

2683

NETLINK_CB(arg->cb->skb).portid, arg->cb->nlh->nlmsg_seq,

2687

prefix, 0, NLM_F_MULTI);

2684

prefix, 0, NLM_F_MULTI);

2688

}

2685

}

2689

2686

2690

static int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr *nlh)

2687

static int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr *nlh)

2691

{

2688

{

2692

struct net *net = sock_net(in_skb->sk);

2689

struct net *net = sock_net(in_skb->sk);

2693

struct nlattr *tb[RTA_MAX+1];

2690

struct nlattr *tb[RTA_MAX+1];

2694

struct rt6_info *rt;

2691

struct rt6_info *rt;

2695

struct sk_buff *skb;

2692

struct sk_buff *skb;

2696

struct rtmsg *rtm;

2693

struct rtmsg *rtm;

2697

struct flowi6 fl6;

2694

struct flowi6 fl6;

2698

int err, iif = 0, oif = 0;

2695

int err, iif = 0, oif = 0;

2699

2696

2700

err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);

2697

err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);

2701

if (err < 0)

2698

if (err < 0)

2702

goto errout;

2699

goto errout;

2703

2700

2704

err = -EINVAL;

2701

err = -EINVAL;

2705

memset(&fl6, 0, sizeof(fl6));

2702

memset(&fl6, 0, sizeof(fl6));

2706

2703

2707

if (tb[RTA_SRC]) {

2704

if (tb[RTA_SRC]) {

2708

if (nla_len(tb[RTA_SRC]) < sizeof(struct in6_addr))

2705

if (nla_len(tb[RTA_SRC]) < sizeof(struct in6_addr))

2709

goto errout;

2706

goto errout;

2710

2707

2711

fl6.saddr = *(struct in6_addr *)nla_data(tb[RTA_SRC]);

2708

fl6.saddr = *(struct in6_addr *)nla_data(tb[RTA_SRC]);

2712

}

2709

}

2713

2710

2714

if (tb[RTA_DST]) {

2711

if (tb[RTA_DST]) {

2715

if (nla_len(tb[RTA_DST]) < sizeof(struct in6_addr))

2712

if (nla_len(tb[RTA_DST]) < sizeof(struct in6_addr))

2716

goto errout;

2713

goto errout;

2717

2714

2718

fl6.daddr = *(struct in6_addr *)nla_data(tb[RTA_DST]);

2715

fl6.daddr = *(struct in6_addr *)nla_data(tb[RTA_DST]);

2719

}

2716

}

2720

2717

2721

if (tb[RTA_IIF])

2718

if (tb[RTA_IIF])

2722

iif = nla_get_u32(tb[RTA_IIF]);

2719

iif = nla_get_u32(tb[RTA_IIF]);

2723

2720

2724

if (tb[RTA_OIF])

2721

if (tb[RTA_OIF])

2725

oif = nla_get_u32(tb[RTA_OIF]);

2722

oif = nla_get_u32(tb[RTA_OIF]);

2726

2723

2727

if (tb[RTA_MARK])

2724

if (tb[RTA_MARK])

2728

fl6.flowi6_mark = nla_get_u32(tb[RTA_MARK]);

2725

fl6.flowi6_mark = nla_get_u32(tb[RTA_MARK]);

2729

2726

2730

if (iif) {

2727

if (iif) {

2731

struct net_device *dev;

2728

struct net_device *dev;

2732

int flags = 0;

2729

int flags = 0;

2733

2730

2734

dev = __dev_get_by_index(net, iif);

2731

dev = __dev_get_by_index(net, iif);

2735

if (!dev) {

2732

if (!dev) {

2736

err = -ENODEV;

2733

err = -ENODEV;

2737

goto errout;

2734

goto errout;

2738

}

2735

}

2739

2736

2740

fl6.flowi6_iif = iif;

2737

fl6.flowi6_iif = iif;

2741

2738

2742

if (!ipv6_addr_any(&fl6.saddr))

2739

if (!ipv6_addr_any(&fl6.saddr))

2743

flags |= RT6_LOOKUP_F_HAS_SADDR;

2740

flags |= RT6_LOOKUP_F_HAS_SADDR;

2744

2741

2745

rt = (struct rt6_info *)ip6_route_input_lookup(net, dev, &fl6,

2742

rt = (struct rt6_info *)ip6_route_input_lookup(net, dev, &fl6,

2746

flags);

2743

flags);

2747

} else {

2744

} else {

2748

fl6.flowi6_oif = oif;

2745

fl6.flowi6_oif = oif;

2749

2746

2750

rt = (struct rt6_info *)ip6_route_output(net, NULL, &fl6);

2747

rt = (struct rt6_info *)ip6_route_output(net, NULL, &fl6);

2751

}

2748

}

2752

2749

2753

skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);

2750

skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);

2754

if (!skb) {

2751

if (!skb) {

2755

ip6_rt_put(rt);

2752

ip6_rt_put(rt);

2756

err = -ENOBUFS;

2753

err = -ENOBUFS;

2757

goto errout;

2754

goto errout;

2758

}

2755

}

2759

2756

2760

/* Reserve room for dummy headers, this skb can pass

2757

/* Reserve room for dummy headers, this skb can pass

2761

through good chunk of routing engine.

2758

through good chunk of routing engine.

2762

*/

2759

*/

2763

skb_reset_mac_header(skb);

2760

skb_reset_mac_header(skb);

2764

skb_reserve(skb, MAX_HEADER + sizeof(struct ipv6hdr));

2761

skb_reserve(skb, MAX_HEADER + sizeof(struct ipv6hdr));

2765

2762

2766

skb_dst_set(skb, &rt->dst);

2763

skb_dst_set(skb, &rt->dst);

2767

2764

2768

err = rt6_fill_node(net, skb, rt, &fl6.daddr, &fl6.saddr, iif,

2765

err = rt6_fill_node(net, skb, rt, &fl6.daddr, &fl6.saddr, iif,

2769

RTM_NEWROUTE, NETLINK_CB(in_skb).portid,

2766

RTM_NEWROUTE, NETLINK_CB(in_skb).portid,

2770

nlh->nlmsg_seq, 0, 0, 0);

2767

nlh->nlmsg_seq, 0, 0, 0);

2771

if (err < 0) {

2768

if (err < 0) {

2772

kfree_skb(skb);

2769

kfree_skb(skb);

2773

goto errout;

2770

goto errout;

2774

}

2771

}

2775

2772

2776

err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);

2773

err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);

2777

errout:

2774

errout:

2778

return err;

2775

return err;

2779

}

2776

}

2780

2777

2781

void inet6_rt_notify(int event, struct rt6_info *rt, struct nl_info *info)

2778

void inet6_rt_notify(int event, struct rt6_info *rt, struct nl_info *info)

2782

{

2779

{

2783

struct sk_buff *skb;

2780

struct sk_buff *skb;

2784

struct net *net = info->nl_net;

2781

struct net *net = info->nl_net;

2785

u32 seq;

2782

u32 seq;

2786

int err;

2783

int err;

2787

2784

2788

err = -ENOBUFS;

2785

err = -ENOBUFS;

2789

seq = info->nlh ? info->nlh->nlmsg_seq : 0;

2786

seq = info->nlh ? info->nlh->nlmsg_seq : 0;

2790

2787

2791

skb = nlmsg_new(rt6_nlmsg_size(), gfp_any());

2788

skb = nlmsg_new(rt6_nlmsg_size(), gfp_any());

2792

if (!skb)

2789

if (!skb)

2793

goto errout;

2790

goto errout;

2794

2791

2795

err = rt6_fill_node(net, skb, rt, NULL, NULL, 0,

2792

err = rt6_fill_node(net, skb, rt, NULL, NULL, 0,

2796

event, info->portid, seq, 0, 0, 0);

2793

event, info->portid, seq, 0, 0, 0);

2797

if (err < 0) {

2794

if (err < 0) {

2798

/* -EMSGSIZE implies BUG in rt6_nlmsg_size() */

2795

/* -EMSGSIZE implies BUG in rt6_nlmsg_size() */

2799

WARN_ON(err == -EMSGSIZE);

2796

WARN_ON(err == -EMSGSIZE);

2800

kfree_skb(skb);

2797

kfree_skb(skb);

2801

goto errout;

2798

goto errout;

2802

}

2799

}

2803

rtnl_notify(skb, net, info->portid, RTNLGRP_IPV6_ROUTE,

2800

rtnl_notify(skb, net, info->portid, RTNLGRP_IPV6_ROUTE,

2804

info->nlh, gfp_any());

2801

info->nlh, gfp_any());

2805

return;

2802

return;

2806

errout:

2803

errout:

2807

if (err < 0)

2804

if (err < 0)

2808

rtnl_set_sk_err(net, RTNLGRP_IPV6_ROUTE, err);

2805

rtnl_set_sk_err(net, RTNLGRP_IPV6_ROUTE, err);

2809

}

2806

}

2810

2807

2811

static int ip6_route_dev_notify(struct notifier_block *this,

2808

static int ip6_route_dev_notify(struct notifier_block *this,

2812

unsigned long event, void *ptr)

2809

unsigned long event, void *ptr)

2813

{

2810

{

2814

struct net_device *dev = netdev_notifier_info_to_dev(ptr);

2811

struct net_device *dev = netdev_notifier_info_to_dev(ptr);

2815

struct net *net = dev_net(dev);

2812

struct net *net = dev_net(dev);

2816

2813

2817

if (event == NETDEV_REGISTER && (dev->flags & IFF_LOOPBACK)) {

2814

if (event == NETDEV_REGISTER && (dev->flags & IFF_LOOPBACK)) {

2818

net->ipv6.ip6_null_entry->dst.dev = dev;

2815

net->ipv6.ip6_null_entry->dst.dev = dev;

2819

net->ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(dev);

2816

net->ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(dev);

2820

#ifdef CONFIG_IPV6_MULTIPLE_TABLES

2817

#ifdef CONFIG_IPV6_MULTIPLE_TABLES

2821

net->ipv6.ip6_prohibit_entry->dst.dev = dev;

2818

net->ipv6.ip6_prohibit_entry->dst.dev = dev;

2822

net->ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(dev);

2819

net->ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(dev);

2823

net->ipv6.ip6_blk_hole_entry->dst.dev = dev;

2820

net->ipv6.ip6_blk_hole_entry->dst.dev = dev;

2824

net->ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(dev);

2821

net->ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(dev);

2825

#endif

2822

#endif

2826

}

2823

}

2827

2824

2828

return NOTIFY_OK;

2825

return NOTIFY_OK;

2829

}

2826

}

2830

2827

2831

/*

2828

/*

2832

* /proc

2829

* /proc

2833

*/

2830

*/

2834

2831

2835

#ifdef CONFIG_PROC_FS

2832

#ifdef CONFIG_PROC_FS

2836

2833

2837

static const struct file_operations ipv6_route_proc_fops = {

2834

static const struct file_operations ipv6_route_proc_fops = {

2838

.owner = THIS_MODULE,

2835

.owner = THIS_MODULE,

2839

.open = ipv6_route_open,

2836

.open = ipv6_route_open,

2840

.read = seq_read,

2837

.read = seq_read,

2841

.llseek = seq_lseek,

2838

.llseek = seq_lseek,

2842

.release = seq_release_net,

2839

.release = seq_release_net,

2843

};

2840

};

2844

2841

2845

static int rt6_stats_seq_show(struct seq_file *seq, void *v)

2842

static int rt6_stats_seq_show(struct seq_file *seq, void *v)

2846

{

2843

{

2847

struct net *net = (struct net *)seq->private;

2844

struct net *net = (struct net *)seq->private;

2848

seq_printf(seq, "%04x %04x %04x %04x %04x %04x %04x\n",

2845

seq_printf(seq, "%04x %04x %04x %04x %04x %04x %04x\n",

2849

net->ipv6.rt6_stats->fib_nodes,

2846

net->ipv6.rt6_stats->fib_nodes,

2850

net->ipv6.rt6_stats->fib_route_nodes,

2847

net->ipv6.rt6_stats->fib_route_nodes,

2851

net->ipv6.rt6_stats->fib_rt_alloc,

2848

net->ipv6.rt6_stats->fib_rt_alloc,

2852

net->ipv6.rt6_stats->fib_rt_entries,

2849

net->ipv6.rt6_stats->fib_rt_entries,

2853

net->ipv6.rt6_stats->fib_rt_cache,

2850

net->ipv6.rt6_stats->fib_rt_cache,

2854

dst_entries_get_slow(&net->ipv6.ip6_dst_ops),

2851

dst_entries_get_slow(&net->ipv6.ip6_dst_ops),

2855

net->ipv6.rt6_stats->fib_discarded_routes);

2852

net->ipv6.rt6_stats->fib_discarded_routes);

2856

2853

2857

return 0;

2854

return 0;

2858

}

2855

}

2859

2856

2860

static int rt6_stats_seq_open(struct inode *inode, struct file *file)

2857

static int rt6_stats_seq_open(struct inode *inode, struct file *file)

2861

{

2858

{

2862

return single_open_net(inode, file, rt6_stats_seq_show);

2859

return single_open_net(inode, file, rt6_stats_seq_show);

2863

}

2860

}

2864

2861

2865

static const struct file_operations rt6_stats_seq_fops = {

2862

static const struct file_operations rt6_stats_seq_fops = {

2866

.owner = THIS_MODULE,

2863

.owner = THIS_MODULE,

2867

.open = rt6_stats_seq_open,

2864

.open = rt6_stats_seq_open,

2868

.read = seq_read,

2865

.read = seq_read,

2869

.llseek = seq_lseek,

2866

.llseek = seq_lseek,

2870

.release = single_release_net,

2867

.release = single_release_net,

2871

};

2868

};

2872

#endif /* CONFIG_PROC_FS */

2869

#endif /* CONFIG_PROC_FS */

2873

2870

2874

#ifdef CONFIG_SYSCTL

2871

#ifdef CONFIG_SYSCTL

2875

2872

2876

static

2873

static

2877

int ipv6_sysctl_rtcache_flush(struct ctl_table *ctl, int write,

2874

int ipv6_sysctl_rtcache_flush(struct ctl_table *ctl, int write,

2878

void __user *buffer, size_t *lenp, loff_t *ppos)

2875

void __user *buffer, size_t *lenp, loff_t *ppos)

2879

{

2876

{

2880

struct net *net;

2877

struct net *net;

2881

int delay;

2878

int delay;

2882

if (!write)

2879

if (!write)

2883

return -EINVAL;

2880

return -EINVAL;

2884

2881

2885

net = (struct net *)ctl->extra1;

2882

net = (struct net *)ctl->extra1;

2886

delay = net->ipv6.sysctl.flush_delay;

2883

delay = net->ipv6.sysctl.flush_delay;

2887

proc_dointvec(ctl, write, buffer, lenp, ppos);

2884

proc_dointvec(ctl, write, buffer, lenp, ppos);

2888

fib6_run_gc(delay <= 0 ? 0 : (unsigned long)delay, net, delay > 0);

2885

fib6_run_gc(delay <= 0 ? 0 : (unsigned long)delay, net, delay > 0);

2889

return 0;

2886

return 0;

2890

}

2887

}

2891

2888

2892

struct ctl_table ipv6_route_table_template[] = {

2889

struct ctl_table ipv6_route_table_template[] = {

2893

{

2890

{

2894

.procname = "flush",

2891

.procname = "flush",

2895

.data = &init_net.ipv6.sysctl.flush_delay,

2892

.data = &init_net.ipv6.sysctl.flush_delay,

2896

.maxlen = sizeof(int),

2893

.maxlen = sizeof(int),

2897

.mode = 0200,

2894

.mode = 0200,

2898

.proc_handler = ipv6_sysctl_rtcache_flush

2895

.proc_handler = ipv6_sysctl_rtcache_flush

2899

},

2896

},

2900

{

2897

{

2901

.procname = "gc_thresh",

2898

.procname = "gc_thresh",

2902

.data = &ip6_dst_ops_template.gc_thresh,

2899

.data = &ip6_dst_ops_template.gc_thresh,

2903

.maxlen = sizeof(int),

2900

.maxlen = sizeof(int),

2904

.mode = 0644,

2901

.mode = 0644,

2905

.proc_handler = proc_dointvec,

2902

.proc_handler = proc_dointvec,

2906

},

2903

},

2907

{

2904

{

2908

.procname = "max_size",

2905

.procname = "max_size",

2909

.data = &init_net.ipv6.sysctl.ip6_rt_max_size,

2906

.data = &init_net.ipv6.sysctl.ip6_rt_max_size,

2910

.maxlen = sizeof(int),

2907

.maxlen = sizeof(int),

2911

.mode = 0644,

2908

.mode = 0644,

2912

.proc_handler = proc_dointvec,

2909

.proc_handler = proc_dointvec,

2913

},

2910

},

2914

{

2911

{

2915

.procname = "gc_min_interval",

2912

.procname = "gc_min_interval",

2916

.data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,

2913

.data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,

2917

.maxlen = sizeof(int),

2914

.maxlen = sizeof(int),

2918

.mode = 0644,

2915

.mode = 0644,

2919

.proc_handler = proc_dointvec_jiffies,

2916

.proc_handler = proc_dointvec_jiffies,

2920

},

2917

},

2921

{

2918

{

2922

.procname = "gc_timeout",

2919

.procname = "gc_timeout",

2923

.data = &init_net.ipv6.sysctl.ip6_rt_gc_timeout,

2920

.data = &init_net.ipv6.sysctl.ip6_rt_gc_timeout,

2924

.maxlen = sizeof(int),

2921

.maxlen = sizeof(int),

2925

.mode = 0644,

2922

.mode = 0644,

2926

.proc_handler = proc_dointvec_jiffies,

2923

.proc_handler = proc_dointvec_jiffies,

2927

},

2924

},

2928

{

2925

{

2929

.procname = "gc_interval",

2926

.procname = "gc_interval",

2930

.data = &init_net.ipv6.sysctl.ip6_rt_gc_interval,

2927

.data = &init_net.ipv6.sysctl.ip6_rt_gc_interval,

2931

.maxlen = sizeof(int),

2928

.maxlen = sizeof(int),

2932

.mode = 0644,

2929

.mode = 0644,

2933

.proc_handler = proc_dointvec_jiffies,

2930

.proc_handler = proc_dointvec_jiffies,

2934

},

2931

},

2935

{

2932

{

2936

.procname = "gc_elasticity",

2933

.procname = "gc_elasticity",

2937

.data = &init_net.ipv6.sysctl.ip6_rt_gc_elasticity,

2934

.data = &init_net.ipv6.sysctl.ip6_rt_gc_elasticity,

2938

.maxlen = sizeof(int),

2935

.maxlen = sizeof(int),

2939

.mode = 0644,

2936

.mode = 0644,

2940

.proc_handler = proc_dointvec,

2937

.proc_handler = proc_dointvec,

2941

},

2938

},

2942

{

2939

{

2943

.procname = "mtu_expires",

2940

.procname = "mtu_expires",

2944

.data = &init_net.ipv6.sysctl.ip6_rt_mtu_expires,

2941

.data = &init_net.ipv6.sysctl.ip6_rt_mtu_expires,

2945

.maxlen = sizeof(int),

2942

.maxlen = sizeof(int),

2946

.mode = 0644,

2943

.mode = 0644,

2947

.proc_handler = proc_dointvec_jiffies,

2944

.proc_handler = proc_dointvec_jiffies,

2948

},

2945

},

2949

{

2946

{

2950

.procname = "min_adv_mss",

2947

.procname = "min_adv_mss",

2951

.data = &init_net.ipv6.sysctl.ip6_rt_min_advmss,

2948

.data = &init_net.ipv6.sysctl.ip6_rt_min_advmss,

2952

.maxlen = sizeof(int),

2949

.maxlen = sizeof(int),

2953

.mode = 0644,

2950

.mode = 0644,

2954

.proc_handler = proc_dointvec,

2951

.proc_handler = proc_dointvec,

2955

},

2952

},

2956

{

2953

{

2957

.procname = "gc_min_interval_ms",

2954

.procname = "gc_min_interval_ms",

2958

.data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,

2955

.data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,

2959

.maxlen = sizeof(int),

2956

.maxlen = sizeof(int),

2960

.mode = 0644,

2957

.mode = 0644,

2961

.proc_handler = proc_dointvec_ms_jiffies,

2958

.proc_handler = proc_dointvec_ms_jiffies,

2962

},

2959

},

2963

{ }

2960

{ }

2964

};

2961

};

2965

2962

2966

struct ctl_table * __net_init ipv6_route_sysctl_init(struct net *net)

2963

struct ctl_table * __net_init ipv6_route_sysctl_init(struct net *net)

2967

{

2964

{

2968

struct ctl_table *table;

2965

struct ctl_table *table;

2969

2966

2970

table = kmemdup(ipv6_route_table_template,

2967

table = kmemdup(ipv6_route_table_template,

2971

sizeof(ipv6_route_table_template),

2968

sizeof(ipv6_route_table_template),

2972

GFP_KERNEL);

2969

GFP_KERNEL);

2973

2970

2974

if (table) {

2971

if (table) {

2975

table[0].data = &net->ipv6.sysctl.flush_delay;

2972

table[0].data = &net->ipv6.sysctl.flush_delay;

2976

table[0].extra1 = net;

2973

table[0].extra1 = net;

2977

table[1].data = &net->ipv6.ip6_dst_ops.gc_thresh;

2974

table[1].data = &net->ipv6.ip6_dst_ops.gc_thresh;

2978

table[2].data = &net->ipv6.sysctl.ip6_rt_max_size;

2975

table[2].data = &net->ipv6.sysctl.ip6_rt_max_size;

2979

table[3].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;

2976

table[3].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;

2980

table[4].data = &net->ipv6.sysctl.ip6_rt_gc_timeout;

2977

table[4].data = &net->ipv6.sysctl.ip6_rt_gc_timeout;

2981

table[5].data = &net->ipv6.sysctl.ip6_rt_gc_interval;

2978

table[5].data = &net->ipv6.sysctl.ip6_rt_gc_interval;

2982

table[6].data = &net->ipv6.sysctl.ip6_rt_gc_elasticity;

2979

table[6].data = &net->ipv6.sysctl.ip6_rt_gc_elasticity;

2983

table[7].data = &net->ipv6.sysctl.ip6_rt_mtu_expires;

2980

table[7].data = &net->ipv6.sysctl.ip6_rt_mtu_expires;

2984

table[8].data = &net->ipv6.sysctl.ip6_rt_min_advmss;

2981

table[8].data = &net->ipv6.sysctl.ip6_rt_min_advmss;

2985

table[9].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;

2982

table[9].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;

2986

2983

2987

/* Don't export sysctls to unprivileged users */

2984

/* Don't export sysctls to unprivileged users */

2988

if (net->user_ns != &init_user_ns)

2985

if (net->user_ns != &init_user_ns)

2989

table[0].procname = NULL;

2986

table[0].procname = NULL;

2990

}

2987

}

2991

2988

2992

return table;

2989

return table;

2993

}

2990

}

2994

#endif

2991

#endif

2995

2992

2996

static int __net_init ip6_route_net_init(struct net *net)

2993

static int __net_init ip6_route_net_init(struct net *net)

2997

{

2994

{

2998

int ret = -ENOMEM;

2995

int ret = -ENOMEM;

2999

2996

3000

memcpy(&net->ipv6.ip6_dst_ops, &ip6_dst_ops_template,

2997

memcpy(&net->ipv6.ip6_dst_ops, &ip6_dst_ops_template,

3001

sizeof(net->ipv6.ip6_dst_ops));

2998

sizeof(net->ipv6.ip6_dst_ops));

3002

2999

3003

if (dst_entries_init(&net->ipv6.ip6_dst_ops) < 0)

3000

if (dst_entries_init(&net->ipv6.ip6_dst_ops) < 0)

3004

goto out_ip6_dst_ops;

3001

goto out_ip6_dst_ops;

3005

3002

3006

net->ipv6.ip6_null_entry = kmemdup(&ip6_null_entry_template,

3003

net->ipv6.ip6_null_entry = kmemdup(&ip6_null_entry_template,

3007

sizeof(*net->ipv6.ip6_null_entry),

3004

sizeof(*net->ipv6.ip6_null_entry),

3008

GFP_KERNEL);

3005

GFP_KERNEL);

3009

if (!net->ipv6.ip6_null_entry)

3006

if (!net->ipv6.ip6_null_entry)

3010

goto out_ip6_dst_entries;

3007

goto out_ip6_dst_entries;

3011

net->ipv6.ip6_null_entry->dst.path =

3008

net->ipv6.ip6_null_entry->dst.path =

3012

(struct dst_entry *)net->ipv6.ip6_null_entry;

3009

(struct dst_entry *)net->ipv6.ip6_null_entry;

3013

net->ipv6.ip6_null_entry->dst.ops = &net->ipv6.ip6_dst_ops;

3010

net->ipv6.ip6_null_entry->dst.ops = &net->ipv6.ip6_dst_ops;

3014

dst_init_metrics(&net->ipv6.ip6_null_entry->dst,

3011

dst_init_metrics(&net->ipv6.ip6_null_entry->dst,

3015

ip6_template_metrics, true);

3012

ip6_template_metrics, true);

3016

3013

3017

#ifdef CONFIG_IPV6_MULTIPLE_TABLES

3014

#ifdef CONFIG_IPV6_MULTIPLE_TABLES

3018

net->ipv6.ip6_prohibit_entry = kmemdup(&ip6_prohibit_entry_template,

3015

net->ipv6.ip6_prohibit_entry = kmemdup(&ip6_prohibit_entry_template,

3019

sizeof(*net->ipv6.ip6_prohibit_entry),

3016

sizeof(*net->ipv6.ip6_prohibit_entry),

3020

GFP_KERNEL);

3017

GFP_KERNEL);

3021

if (!net->ipv6.ip6_prohibit_entry)

3018

if (!net->ipv6.ip6_prohibit_entry)

3022

goto out_ip6_null_entry;

3019

goto out_ip6_null_entry;

3023

net->ipv6.ip6_prohibit_entry->dst.path =

3020

net->ipv6.ip6_prohibit_entry->dst.path =

3024

(struct dst_entry *)net->ipv6.ip6_prohibit_entry;

3021

(struct dst_entry *)net->ipv6.ip6_prohibit_entry;

3025

net->ipv6.ip6_prohibit_entry->dst.ops = &net->ipv6.ip6_dst_ops;

3022

net->ipv6.ip6_prohibit_entry->dst.ops = &net->ipv6.ip6_dst_ops;

3026

dst_init_metrics(&net->ipv6.ip6_prohibit_entry->dst,

3023

dst_init_metrics(&net->ipv6.ip6_prohibit_entry->dst,

3027

ip6_template_metrics, true);

3024

ip6_template_metrics, true);

3028

3025

3029

net->ipv6.ip6_blk_hole_entry = kmemdup(&ip6_blk_hole_entry_template,

3026

net->ipv6.ip6_blk_hole_entry = kmemdup(&ip6_blk_hole_entry_template,

3030

sizeof(*net->ipv6.ip6_blk_hole_entry),

3027

sizeof(*net->ipv6.ip6_blk_hole_entry),

3031

GFP_KERNEL);

3028

GFP_KERNEL);

3032

if (!net->ipv6.ip6_blk_hole_entry)

3029

if (!net->ipv6.ip6_blk_hole_entry)

3033

goto out_ip6_prohibit_entry;

3030

goto out_ip6_prohibit_entry;

3034

net->ipv6.ip6_blk_hole_entry->dst.path =

3031

net->ipv6.ip6_blk_hole_entry->dst.path =

3035

(struct dst_entry *)net->ipv6.ip6_blk_hole_entry;

3032

(struct dst_entry *)net->ipv6.ip6_blk_hole_entry;

3036

net->ipv6.ip6_blk_hole_entry->dst.ops = &net->ipv6.ip6_dst_ops;

3033

net->ipv6.ip6_blk_hole_entry->dst.ops = &net->ipv6.ip6_dst_ops;

3037

dst_init_metrics(&net->ipv6.ip6_blk_hole_entry->dst,

3034

dst_init_metrics(&net->ipv6.ip6_blk_hole_entry->dst,

3038

ip6_template_metrics, true);

3035

ip6_template_metrics, true);

3039

#endif

3036

#endif

3040

3037

3041

net->ipv6.sysctl.flush_delay = 0;

3038

net->ipv6.sysctl.flush_delay = 0;

3042

net->ipv6.sysctl.ip6_rt_max_size = 4096;

3039

net->ipv6.sysctl.ip6_rt_max_size = 4096;

3043

net->ipv6.sysctl.ip6_rt_gc_min_interval = HZ / 2;

3040

net->ipv6.sysctl.ip6_rt_gc_min_interval = HZ / 2;

3044

net->ipv6.sysctl.ip6_rt_gc_timeout = 60*HZ;

3041

net->ipv6.sysctl.ip6_rt_gc_timeout = 60*HZ;

3045

net->ipv6.sysctl.ip6_rt_gc_interval = 30*HZ;

3042

net->ipv6.sysctl.ip6_rt_gc_interval = 30*HZ;

3046

net->ipv6.sysctl.ip6_rt_gc_elasticity = 9;

3043

net->ipv6.sysctl.ip6_rt_gc_elasticity = 9;

3047

net->ipv6.sysctl.ip6_rt_mtu_expires = 10*60*HZ;

3044

net->ipv6.sysctl.ip6_rt_mtu_expires = 10*60*HZ;

3048

net->ipv6.sysctl.ip6_rt_min_advmss = IPV6_MIN_MTU - 20 - 40;

3045

net->ipv6.sysctl.ip6_rt_min_advmss = IPV6_MIN_MTU - 20 - 40;

3049

3046

3050

net->ipv6.ip6_rt_gc_expire = 30*HZ;

3047

net->ipv6.ip6_rt_gc_expire = 30*HZ;

3051

3048

3052

ret = 0;

3049

ret = 0;

3053

out:

3050

out:

3054

return ret;

3051

return ret;

3055

3052

3056

#ifdef CONFIG_IPV6_MULTIPLE_TABLES

3053

#ifdef CONFIG_IPV6_MULTIPLE_TABLES

3057

out_ip6_prohibit_entry:

3054

out_ip6_prohibit_entry:

3058

kfree(net->ipv6.ip6_prohibit_entry);

3055

kfree(net->ipv6.ip6_prohibit_entry);

3059

out_ip6_null_entry:

3056

out_ip6_null_entry:

3060

kfree(net->ipv6.ip6_null_entry);

3057

kfree(net->ipv6.ip6_null_entry);

3061

#endif

3058

#endif

3062

out_ip6_dst_entries:

3059

out_ip6_dst_entries:

3063

dst_entries_destroy(&net->ipv6.ip6_dst_ops);

3060

dst_entries_destroy(&net->ipv6.ip6_dst_ops);

3064

out_ip6_dst_ops:

3061

out_ip6_dst_ops:

3065

goto out;

3062

goto out;

3066

}

3063

}

3067

3064

3068

static void __net_exit ip6_route_net_exit(struct net *net)

3065

static void __net_exit ip6_route_net_exit(struct net *net)

3069

{

3066

{

3070

kfree(net->ipv6.ip6_null_entry);

3067

kfree(net->ipv6.ip6_null_entry);

3071

#ifdef CONFIG_IPV6_MULTIPLE_TABLES

3068

#ifdef CONFIG_IPV6_MULTIPLE_TABLES

3072

kfree(net->ipv6.ip6_prohibit_entry);

3069

kfree(net->ipv6.ip6_prohibit_entry);

3073

kfree(net->ipv6.ip6_blk_hole_entry);

3070

kfree(net->ipv6.ip6_blk_hole_entry);

3074

#endif

3071

#endif

3075

dst_entries_destroy(&net->ipv6.ip6_dst_ops);

3072

dst_entries_destroy(&net->ipv6.ip6_dst_ops);

3076

}

3073

}

3077

3074

3078

static int __net_init ip6_route_net_init_late(struct net *net)

3075

static int __net_init ip6_route_net_init_late(struct net *net)

3079

{

3076

{

3080

#ifdef CONFIG_PROC_FS

3077

#ifdef CONFIG_PROC_FS

3081

proc_create("ipv6_route", 0, net->proc_net, &ipv6_route_proc_fops);

3078

proc_create("ipv6_route", 0, net->proc_net, &ipv6_route_proc_fops);

3082

proc_create("rt6_stats", S_IRUGO, net->proc_net, &rt6_stats_seq_fops);

3079

proc_create("rt6_stats", S_IRUGO, net->proc_net, &rt6_stats_seq_fops);

3083

#endif

3080

#endif

3084

return 0;

3081

return 0;

3085

}

3082

}

3086

3083

3087

static void __net_exit ip6_route_net_exit_late(struct net *net)

3084

static void __net_exit ip6_route_net_exit_late(struct net *net)

3088

{

3085

{

3089

#ifdef CONFIG_PROC_FS

3086

#ifdef CONFIG_PROC_FS

3090

remove_proc_entry("ipv6_route", net->proc_net);

3087

remove_proc_entry("ipv6_route", net->proc_net);

3091

remove_proc_entry("rt6_stats", net->proc_net);

3088

remove_proc_entry("rt6_stats", net->proc_net);

3092

#endif

3089

#endif

3093

}

3090

}

3094

3091

3095

static struct pernet_operations ip6_route_net_ops = {

3092

static struct pernet_operations ip6_route_net_ops = {

3096

.init = ip6_route_net_init,

3093

.init = ip6_route_net_init,

3097

.exit = ip6_route_net_exit,

3094

.exit = ip6_route_net_exit,

3098

};

3095

};

3099

3096

3100

static int __net_init ipv6_inetpeer_init(struct net *net)

3097

static int __net_init ipv6_inetpeer_init(struct net *net)

3101

{

3098

{

3102

struct inet_peer_base *bp = kmalloc(sizeof(*bp), GFP_KERNEL);

3099

struct inet_peer_base *bp = kmalloc(sizeof(*bp), GFP_KERNEL);

3103

3100

3104

if (!bp)

3101

if (!bp)

3105

return -ENOMEM;

3102

return -ENOMEM;

3106

inet_peer_base_init(bp);

3103

inet_peer_base_init(bp);

3107

net->ipv6.peers = bp;

3104

net->ipv6.peers = bp;

3108

return 0;

3105

return 0;

3109

}

3106

}

3110

3107

3111

static void __net_exit ipv6_inetpeer_exit(struct net *net)

3108

static void __net_exit ipv6_inetpeer_exit(struct net *net)

3112

{

3109

{

3113

struct inet_peer_base *bp = net->ipv6.peers;

3110

struct inet_peer_base *bp = net->ipv6.peers;

3114

3111

3115

net->ipv6.peers = NULL;

3112

net->ipv6.peers = NULL;

3116

inetpeer_invalidate_tree(bp);

3113

inetpeer_invalidate_tree(bp);

3117

kfree(bp);

3114

kfree(bp);

3118

}

3115

}

3119

3116

3120

static struct pernet_operations ipv6_inetpeer_ops = {

3117

static struct pernet_operations ipv6_inetpeer_ops = {

3121

.init = ipv6_inetpeer_init,

3118

.init = ipv6_inetpeer_init,

3122

.exit = ipv6_inetpeer_exit,

3119

.exit = ipv6_inetpeer_exit,

3123

};

3120

};

3124

3121

3125

static struct pernet_operations ip6_route_net_late_ops = {

3122

static struct pernet_operations ip6_route_net_late_ops = {

3126

.init = ip6_route_net_init_late,

3123

.init = ip6_route_net_init_late,

3127

.exit = ip6_route_net_exit_late,

3124

.exit = ip6_route_net_exit_late,

3128

};

3125

};

3129

3126

3130

static struct notifier_block ip6_route_dev_notifier = {

3127

static struct notifier_block ip6_route_dev_notifier = {

3131

.notifier_call = ip6_route_dev_notify,

3128

.notifier_call = ip6_route_dev_notify,

3132

.priority = 0,

3129

.priority = 0,

3133

};

3130

};

3134

3131

3135

int __init ip6_route_init(void)

3132

int __init ip6_route_init(void)

3136

{

3133

{

3137

int ret;

3134

int ret;

3138

3135

3139

ret = -ENOMEM;

3136

ret = -ENOMEM;

3140

ip6_dst_ops_template.kmem_cachep =

3137

ip6_dst_ops_template.kmem_cachep =

3141

kmem_cache_create("ip6_dst_cache", sizeof(struct rt6_info), 0,

3138

kmem_cache_create("ip6_dst_cache", sizeof(struct rt6_info), 0,

3142

SLAB_HWCACHE_ALIGN, NULL);

3139

SLAB_HWCACHE_ALIGN, NULL);

3143

if (!ip6_dst_ops_template.kmem_cachep)

3140

if (!ip6_dst_ops_template.kmem_cachep)

3144

goto out;

3141

goto out;

3145

3142

3146

ret = dst_entries_init(&ip6_dst_blackhole_ops);

3143

ret = dst_entries_init(&ip6_dst_blackhole_ops);

3147

if (ret)

3144

if (ret)

3148

goto out_kmem_cache;

3145

goto out_kmem_cache;

3149

3146

3150

ret = register_pernet_subsys(&ipv6_inetpeer_ops);

3147

ret = register_pernet_subsys(&ipv6_inetpeer_ops);

3151

if (ret)

3148

if (ret)

3152

goto out_dst_entries;

3149

goto out_dst_entries;

3153

3150

3154

ret = register_pernet_subsys(&ip6_route_net_ops);

3151

ret = register_pernet_subsys(&ip6_route_net_ops);

3155

if (ret)

3152

if (ret)

3156

goto out_register_inetpeer;

3153

goto out_register_inetpeer;

3157

3154

3158

ip6_dst_blackhole_ops.kmem_cachep = ip6_dst_ops_template.kmem_cachep;

3155

ip6_dst_blackhole_ops.kmem_cachep = ip6_dst_ops_template.kmem_cachep;

3159

3156

3160

/* Registering of the loopback is done before this portion of code,

3157

/* Registering of the loopback is done before this portion of code,

3161

* the loopback reference in rt6_info will not be taken, do it

3158

* the loopback reference in rt6_info will not be taken, do it

3162

* manually for init_net */

3159

* manually for init_net */

3163

init_net.ipv6.ip6_null_entry->dst.dev = init_net.loopback_dev;

3160

init_net.ipv6.ip6_null_entry->dst.dev = init_net.loopback_dev;

3164

init_net.ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);

3161

init_net.ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);

3165

#ifdef CONFIG_IPV6_MULTIPLE_TABLES

3162

#ifdef CONFIG_IPV6_MULTIPLE_TABLES

3166

init_net.ipv6.ip6_prohibit_entry->dst.dev = init_net.loopback_dev;

3163

init_net.ipv6.ip6_prohibit_entry->dst.dev = init_net.loopback_dev;

3167

init_net.ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);

3164

init_net.ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);

3168

init_net.ipv6.ip6_blk_hole_entry->dst.dev = init_net.loopback_dev;

3165

init_net.ipv6.ip6_blk_hole_entry->dst.dev = init_net.loopback_dev;

3169

init_net.ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);

3166

init_net.ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);

3170

#endif

3167

#endif

3171

ret = fib6_init();

3168

ret = fib6_init();

3172

if (ret)

3169

if (ret)

3173

goto out_register_subsys;

3170

goto out_register_subsys;

3174

3171

3175

ret = xfrm6_init();

3172

ret = xfrm6_init();

3176

if (ret)

3173

if (ret)

3177

goto out_fib6_init;

3174

goto out_fib6_init;

3178

3175

3179

ret = fib6_rules_init();

3176

ret = fib6_rules_init();

3180

if (ret)

3177

if (ret)

3181

goto xfrm6_init;

3178

goto xfrm6_init;

3182

3179

3183

ret = register_pernet_subsys(&ip6_route_net_late_ops);

3180

ret = register_pernet_subsys(&ip6_route_net_late_ops);

3184

if (ret)

3181

if (ret)

3185

goto fib6_rules_init;

3182

goto fib6_rules_init;

3186

3183

3187

ret = -ENOBUFS;

3184

ret = -ENOBUFS;

3188

if (__rtnl_register(PF_INET6, RTM_NEWROUTE, inet6_rtm_newroute, NULL, NULL) ||

3185

if (__rtnl_register(PF_INET6, RTM_NEWROUTE, inet6_rtm_newroute, NULL, NULL) ||

3189

__rtnl_register(PF_INET6, RTM_DELROUTE, inet6_rtm_delroute, NULL, NULL) ||

3186

__rtnl_register(PF_INET6, RTM_DELROUTE, inet6_rtm_delroute, NULL, NULL) ||

3190

__rtnl_register(PF_INET6, RTM_GETROUTE, inet6_rtm_getroute, NULL, NULL))

3187

__rtnl_register(PF_INET6, RTM_GETROUTE, inet6_rtm_getroute, NULL, NULL))

3191

goto out_register_late_subsys;

3188

goto out_register_late_subsys;

3192

3189

3193

ret = register_netdevice_notifier(&ip6_route_dev_notifier);

3190

ret = register_netdevice_notifier(&ip6_route_dev_notifier);

3194

if (ret)

3191

if (ret)

3195

goto out_register_late_subsys;

3192

goto out_register_late_subsys;

3196

3193

3197

out:

3194

out:

3198

return ret;

3195

return ret;

3199

3196

3200

out_register_late_subsys:

3197

out_register_late_subsys:

3201

unregister_pernet_subsys(&ip6_route_net_late_ops);

3198

unregister_pernet_subsys(&ip6_route_net_late_ops);

3202

fib6_rules_init:

3199

fib6_rules_init:

3203

fib6_rules_cleanup();

3200

fib6_rules_cleanup();

3204

xfrm6_init:

3201

xfrm6_init:

3205

xfrm6_fini();

3202

xfrm6_fini();

3206

out_fib6_init:

3203

out_fib6_init:

3207

fib6_gc_cleanup();

3204

fib6_gc_cleanup();

3208

out_register_subsys:

3205

out_register_subsys:

3209

unregister_pernet_subsys(&ip6_route_net_ops);

3206

unregister_pernet_subsys(&ip6_route_net_ops);

3210

out_register_inetpeer:

3207

out_register_inetpeer:

3211

unregister_pernet_subsys(&ipv6_inetpeer_ops);

3208

unregister_pernet_subsys(&ipv6_inetpeer_ops);

3212

out_dst_entries:

3209

out_dst_entries:

3213

dst_entries_destroy(&ip6_dst_blackhole_ops);

3210

dst_entries_destroy(&ip6_dst_blackhole_ops);

3214

out_kmem_cache:

3211

out_kmem_cache:

3215

kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);

3212

kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);

3216

goto out;

3213

goto out;

3217

}

3214

}

3218

3215

3219

void ip6_route_cleanup(void)

3216

void ip6_route_cleanup(void)

3220

{

3217

{

3221

unregister_netdevice_notifier(&ip6_route_dev_notifier);

3218

unregister_netdevice_notifier(&ip6_route_dev_notifier);

3222

unregister_pernet_subsys(&ip6_route_net_late_ops);

3219

unregister_pernet_subsys(&ip6_route_net_late_ops);

3223

fib6_rules_cleanup();

3220

fib6_rules_cleanup();

3224

xfrm6_fini();

3221

xfrm6_fini();

3225

fib6_gc_cleanup();

3222

fib6_gc_cleanup();

3226

unregister_pernet_subsys(&ipv6_inetpeer_ops);

3223

unregister_pernet_subsys(&ipv6_inetpeer_ops);

3227

unregister_pernet_subsys(&ip6_route_net_ops);

3224

unregister_pernet_subsys(&ip6_route_net_ops);

3228

dst_entries_destroy(&ip6_dst_blackhole_ops);

3225

dst_entries_destroy(&ip6_dst_blackhole_ops);

3229

kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);

3226

kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);

3230

}

3227

}

3231

3228

GITLAB

ipv6: stop sending PTB packets for MTU < 1280