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

#include <linux/capability.h>

27

#include <linux/capability.h>

28

#include <linux/errno.h>

28

#include <linux/errno.h>

29

#include <linux/types.h>

29

#include <linux/types.h>

30

#include <linux/times.h>

30

#include <linux/times.h>

31

#include <linux/socket.h>

31

#include <linux/socket.h>

32

#include <linux/sockios.h>

32

#include <linux/sockios.h>

33

#include <linux/net.h>

33

#include <linux/net.h>

34

#include <linux/route.h>

34

#include <linux/route.h>

35

#include <linux/netdevice.h>

35

#include <linux/netdevice.h>

36

#include <linux/in6.h>

36

#include <linux/in6.h>

37

#include <linux/mroute6.h>

37

#include <linux/mroute6.h>

38

#include <linux/init.h>

38

#include <linux/init.h>

39

#include <linux/if_arp.h>

39

#include <linux/if_arp.h>

40

#include <linux/proc_fs.h>

40

#include <linux/proc_fs.h>

41

#include <linux/seq_file.h>

41

#include <linux/seq_file.h>

42

#include <linux/nsproxy.h>

42

#include <linux/nsproxy.h>

43

#include <linux/slab.h>

43

#include <linux/slab.h>

44

#include <net/net_namespace.h>

44

#include <net/net_namespace.h>

45

#include <net/snmp.h>

45

#include <net/snmp.h>

46

#include <net/ipv6.h>

46

#include <net/ipv6.h>

47

#include <net/ip6_fib.h>

47

#include <net/ip6_fib.h>

48

#include <net/ip6_route.h>

48

#include <net/ip6_route.h>

49

#include <net/ndisc.h>

49

#include <net/ndisc.h>

50

#include <net/addrconf.h>

50

#include <net/addrconf.h>

51

#include <net/tcp.h>

51

#include <net/tcp.h>

52

#include <linux/rtnetlink.h>

52

#include <linux/rtnetlink.h>

53

#include <net/dst.h>

53

#include <net/dst.h>

54

#include <net/xfrm.h>

54

#include <net/xfrm.h>

55

#include <net/netevent.h>

55

#include <net/netevent.h>

56

#include <net/netlink.h>

56

#include <net/netlink.h>

57

58

#include <asm/uaccess.h>

58

#include <asm/uaccess.h>

59

60

#ifdef CONFIG_SYSCTL

60

#ifdef CONFIG_SYSCTL

61

#include <linux/sysctl.h>

61

#include <linux/sysctl.h>

62

#endif

62

#endif

63

64

/* Set to 3 to get tracing. */

64

/* Set to 3 to get tracing. */

65

#define RT6_DEBUG 2

65

#define RT6_DEBUG 2

66

67

#if RT6_DEBUG >= 3

67

#if RT6_DEBUG >= 3

68

#define RDBG(x) printk x

68

#define RDBG(x) printk x

69

#define RT6_TRACE(x...) printk(KERN_DEBUG x)

69

#define RT6_TRACE(x...) printk(KERN_DEBUG x)

70

#else

70

#else

71

#define RDBG(x)

71

#define RDBG(x)

72

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

72

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

73

#endif

73

#endif

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

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

76

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

77

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

77

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

78

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

78

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

79

static struct dst_entry *ip6_negative_advice(struct dst_entry *);

79

static struct dst_entry *ip6_negative_advice(struct dst_entry *);

80

static void ip6_dst_destroy(struct dst_entry *);

80

static void ip6_dst_destroy(struct dst_entry *);

81

static void ip6_dst_ifdown(struct dst_entry *,

81

static void ip6_dst_ifdown(struct dst_entry *,

82

struct net_device *dev, int how);

82

struct net_device *dev, int how);

83

static int ip6_dst_gc(struct dst_ops *ops);

83

static int ip6_dst_gc(struct dst_ops *ops);

84

85

static int ip6_pkt_discard(struct sk_buff *skb);

85

static int ip6_pkt_discard(struct sk_buff *skb);

86

static int ip6_pkt_discard_out(struct sk_buff *skb);

86

static int ip6_pkt_discard_out(struct sk_buff *skb);

87

static void ip6_link_failure(struct sk_buff *skb);

87

static void ip6_link_failure(struct sk_buff *skb);

88

static void ip6_rt_update_pmtu(struct dst_entry *dst, u32 mtu);

88

static void ip6_rt_update_pmtu(struct dst_entry *dst, u32 mtu);

89

90

#ifdef CONFIG_IPV6_ROUTE_INFO

90

#ifdef CONFIG_IPV6_ROUTE_INFO

91

static struct rt6_info *rt6_add_route_info(struct net *net,

91

static struct rt6_info *rt6_add_route_info(struct net *net,

92

struct in6_addr *prefix, int prefixlen,

92

struct in6_addr *prefix, int prefixlen,

93

struct in6_addr *gwaddr, int ifindex,

93

struct in6_addr *gwaddr, int ifindex,

94

unsigned pref);

94

unsigned pref);

95

static struct rt6_info *rt6_get_route_info(struct net *net,

95

static struct rt6_info *rt6_get_route_info(struct net *net,

96

struct in6_addr *prefix, int prefixlen,

96

struct in6_addr *prefix, int prefixlen,

97

struct in6_addr *gwaddr, int ifindex);

97

struct in6_addr *gwaddr, int ifindex);

98

#endif

98

#endif

99

100

static struct dst_ops ip6_dst_ops_template = {

100

static struct dst_ops ip6_dst_ops_template = {

101

.family = AF_INET6,

101

.family = AF_INET6,

102

.protocol = cpu_to_be16(ETH_P_IPV6),

102

.protocol = cpu_to_be16(ETH_P_IPV6),

103

.gc = ip6_dst_gc,

103

.gc = ip6_dst_gc,

104

.gc_thresh = 1024,

104

.gc_thresh = 1024,

105

.check = ip6_dst_check,

105

.check = ip6_dst_check,

106

.default_advmss = ip6_default_advmss,

106

.default_advmss = ip6_default_advmss,

107

.default_mtu = ip6_default_mtu,

107

.default_mtu = ip6_default_mtu,

108

.destroy = ip6_dst_destroy,

108

.destroy = ip6_dst_destroy,

109

.ifdown = ip6_dst_ifdown,

109

.ifdown = ip6_dst_ifdown,

110

.negative_advice = ip6_negative_advice,

110

.negative_advice = ip6_negative_advice,

111

.link_failure = ip6_link_failure,

111

.link_failure = ip6_link_failure,

112

.update_pmtu = ip6_rt_update_pmtu,

112

.update_pmtu = ip6_rt_update_pmtu,

113

.local_out = __ip6_local_out,

113

.local_out = __ip6_local_out,

114

};

114

};

115

116

static unsigned int ip6_blackhole_default_mtu(const struct dst_entry *dst)

116

static unsigned int ip6_blackhole_default_mtu(const struct dst_entry *dst)

117

{

117

{

118

return 0;

118

return 0;

119

}

119

}

120

121

static void ip6_rt_blackhole_update_pmtu(struct dst_entry *dst, u32 mtu)

121

static void ip6_rt_blackhole_update_pmtu(struct dst_entry *dst, u32 mtu)

122

{

122

{

123

}

123

}

124

125

static struct dst_ops ip6_dst_blackhole_ops = {

125

static struct dst_ops ip6_dst_blackhole_ops = {

126

.family = AF_INET6,

126

.family = AF_INET6,

127

.protocol = cpu_to_be16(ETH_P_IPV6),

127

.protocol = cpu_to_be16(ETH_P_IPV6),

128

.destroy = ip6_dst_destroy,

128

.destroy = ip6_dst_destroy,

129

.check = ip6_dst_check,

129

.check = ip6_dst_check,

130

.default_mtu = ip6_blackhole_default_mtu,

130

.default_mtu = ip6_blackhole_default_mtu,

131

.default_advmss = ip6_default_advmss,

131

.default_advmss = ip6_default_advmss,

132

.update_pmtu = ip6_rt_blackhole_update_pmtu,

132

.update_pmtu = ip6_rt_blackhole_update_pmtu,

133

};

133

};

134

135

static struct rt6_info ip6_null_entry_template = {

135

static struct rt6_info ip6_null_entry_template = {

136

.dst = {

136

.dst = {

137

.__refcnt = ATOMIC_INIT(1),

137

.__refcnt = ATOMIC_INIT(1),

138

.__use = 1,

138

.__use = 1,

139

.obsolete = -1,

139

.obsolete = -1,

140

.error = -ENETUNREACH,

140

.error = -ENETUNREACH,

141

.input = ip6_pkt_discard,

141

.input = ip6_pkt_discard,

142

.output = ip6_pkt_discard_out,

142

.output = ip6_pkt_discard_out,

143

},

143

},

144

.rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),

144

.rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),

145

.rt6i_protocol = RTPROT_KERNEL,

145

.rt6i_protocol = RTPROT_KERNEL,

146

.rt6i_metric = ~(u32) 0,

146

.rt6i_metric = ~(u32) 0,

147

.rt6i_ref = ATOMIC_INIT(1),

147

.rt6i_ref = ATOMIC_INIT(1),

148

};

148

};

149

150

#ifdef CONFIG_IPV6_MULTIPLE_TABLES

150

#ifdef CONFIG_IPV6_MULTIPLE_TABLES

151

152

static int ip6_pkt_prohibit(struct sk_buff *skb);

152

static int ip6_pkt_prohibit(struct sk_buff *skb);

153

static int ip6_pkt_prohibit_out(struct sk_buff *skb);

153

static int ip6_pkt_prohibit_out(struct sk_buff *skb);

154

155

static struct rt6_info ip6_prohibit_entry_template = {

155

static struct rt6_info ip6_prohibit_entry_template = {

156

.dst = {

156

.dst = {

157

.__refcnt = ATOMIC_INIT(1),

157

.__refcnt = ATOMIC_INIT(1),

158

.__use = 1,

158

.__use = 1,

159

.obsolete = -1,

159

.obsolete = -1,

160

.error = -EACCES,

160

.error = -EACCES,

161

.input = ip6_pkt_prohibit,

161

.input = ip6_pkt_prohibit,

162

.output = ip6_pkt_prohibit_out,

162

.output = ip6_pkt_prohibit_out,

163

},

163

},

164

.rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),

164

.rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),

165

.rt6i_protocol = RTPROT_KERNEL,

165

.rt6i_protocol = RTPROT_KERNEL,

166

.rt6i_metric = ~(u32) 0,

166

.rt6i_metric = ~(u32) 0,

167

.rt6i_ref = ATOMIC_INIT(1),

167

.rt6i_ref = ATOMIC_INIT(1),

168

};

168

};

169

170

static struct rt6_info ip6_blk_hole_entry_template = {

170

static struct rt6_info ip6_blk_hole_entry_template = {

171

.dst = {

171

.dst = {

172

.__refcnt = ATOMIC_INIT(1),

172

.__refcnt = ATOMIC_INIT(1),

173

.__use = 1,

173

.__use = 1,

174

.obsolete = -1,

174

.obsolete = -1,

175

.error = -EINVAL,

175

.error = -EINVAL,

176

.input = dst_discard,

176

.input = dst_discard,

177

.output = dst_discard,

177

.output = dst_discard,

178

},

178

},

179

.rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),

179

.rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),

180

.rt6i_protocol = RTPROT_KERNEL,

180

.rt6i_protocol = RTPROT_KERNEL,

181

.rt6i_metric = ~(u32) 0,

181

.rt6i_metric = ~(u32) 0,

182

.rt6i_ref = ATOMIC_INIT(1),

182

.rt6i_ref = ATOMIC_INIT(1),

183

};

183

};

184

185

#endif

185

#endif

186

187

/* allocate dst with ip6_dst_ops */

187

/* allocate dst with ip6_dst_ops */

188

static inline struct rt6_info *ip6_dst_alloc(struct dst_ops *ops)

188

static inline struct rt6_info *ip6_dst_alloc(struct dst_ops *ops)

189

{

189

{

190

return (struct rt6_info *)dst_alloc(ops);

190

return (struct rt6_info *)dst_alloc(ops);

191

}

191

}

192

193

static void ip6_dst_destroy(struct dst_entry *dst)

193

static void ip6_dst_destroy(struct dst_entry *dst)

194

{

194

{

195

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

195

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

196

struct inet6_dev *idev = rt->rt6i_idev;

196

struct inet6_dev *idev = rt->rt6i_idev;

197

struct inet_peer *peer = rt->rt6i_peer;

197

struct inet_peer *peer = rt->rt6i_peer;

198

199

if (idev != NULL) {

199

if (idev != NULL) {

200

rt->rt6i_idev = NULL;

200

rt->rt6i_idev = NULL;

201

in6_dev_put(idev);

201

in6_dev_put(idev);

202

}

202

}

203

if (peer) {

203

if (peer) {

204

rt->rt6i_peer = NULL;

204

rt->rt6i_peer = NULL;

205

inet_putpeer(peer);

205

inet_putpeer(peer);

206

}

206

}

207

}

207

}

208

209

void rt6_bind_peer(struct rt6_info *rt, int create)

209

void rt6_bind_peer(struct rt6_info *rt, int create)

210

{

210

{

211

struct inet_peer *peer;

211

struct inet_peer *peer;

212

213

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

213

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

214

if (peer && cmpxchg(&rt->rt6i_peer, NULL, peer) != NULL)

214

if (peer && cmpxchg(&rt->rt6i_peer, NULL, peer) != NULL)

215

inet_putpeer(peer);

215

inet_putpeer(peer);

216

}

216

}

217

218

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

218

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

219

int how)

219

int how)

220

{

220

{

221

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

221

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

222

struct inet6_dev *idev = rt->rt6i_idev;

222

struct inet6_dev *idev = rt->rt6i_idev;

223

struct net_device *loopback_dev =

223

struct net_device *loopback_dev =

224

dev_net(dev)->loopback_dev;

224

dev_net(dev)->loopback_dev;

225

226

if (dev != loopback_dev && idev != NULL && idev->dev == dev) {

226

if (dev != loopback_dev && idev != NULL && idev->dev == dev) {

227

struct inet6_dev *loopback_idev =

227

struct inet6_dev *loopback_idev =

228

in6_dev_get(loopback_dev);

228

in6_dev_get(loopback_dev);

229

if (loopback_idev != NULL) {

229

if (loopback_idev != NULL) {

230

rt->rt6i_idev = loopback_idev;

230

rt->rt6i_idev = loopback_idev;

231

in6_dev_put(idev);

231

in6_dev_put(idev);

232

}

232

}

233

}

233

}

234

}

234

}

235

236

static __inline__ int rt6_check_expired(const struct rt6_info *rt)

236

static __inline__ int rt6_check_expired(const struct rt6_info *rt)

237

{

237

{

238

return (rt->rt6i_flags & RTF_EXPIRES) &&

238

return (rt->rt6i_flags & RTF_EXPIRES) &&

239

time_after(jiffies, rt->rt6i_expires);

239

time_after(jiffies, rt->rt6i_expires);

240

}

240

}

241

242

static inline int rt6_need_strict(struct in6_addr *daddr)

242

static inline int rt6_need_strict(struct in6_addr *daddr)

243

{

243

{

244

return ipv6_addr_type(daddr) &

244

return ipv6_addr_type(daddr) &

245

(IPV6_ADDR_MULTICAST | IPV6_ADDR_LINKLOCAL | IPV6_ADDR_LOOPBACK);

245

(IPV6_ADDR_MULTICAST | IPV6_ADDR_LINKLOCAL | IPV6_ADDR_LOOPBACK);

246

}

246

}

247

248

/*

248

/*

249

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

249

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

250

*/

250

*/

251

252

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

252

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

253

struct rt6_info *rt,

253

struct rt6_info *rt,

254

struct in6_addr *saddr,

254

struct in6_addr *saddr,

255

int oif,

255

int oif,

256

int flags)

256

int flags)

257

{

257

{

258

struct rt6_info *local = NULL;

258

struct rt6_info *local = NULL;

259

struct rt6_info *sprt;

259

struct rt6_info *sprt;

260

261

if (!oif && ipv6_addr_any(saddr))

261

if (!oif && ipv6_addr_any(saddr))

262

goto out;

262

goto out;

263

264

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

264

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

265

struct net_device *dev = sprt->rt6i_dev;

265

struct net_device *dev = sprt->rt6i_dev;

266

267

if (oif) {

267

if (oif) {

268

if (dev->ifindex == oif)

268

if (dev->ifindex == oif)

269

return sprt;

269

return sprt;

270

if (dev->flags & IFF_LOOPBACK) {

270

if (dev->flags & IFF_LOOPBACK) {

271

if (sprt->rt6i_idev == NULL ||

271

if (sprt->rt6i_idev == NULL ||

272

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

272

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

273

if (flags & RT6_LOOKUP_F_IFACE && oif)

273

if (flags & RT6_LOOKUP_F_IFACE && oif)

274

continue;

274

continue;

275

if (local && (!oif ||

275

if (local && (!oif ||

276

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

276

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

277

continue;

277

continue;

278

}

278

}

279

local = sprt;

279

local = sprt;

280

}

280

}

281

} else {

281

} else {

282

if (ipv6_chk_addr(net, saddr, dev,

282

if (ipv6_chk_addr(net, saddr, dev,

283

flags & RT6_LOOKUP_F_IFACE))

283

flags & RT6_LOOKUP_F_IFACE))

284

return sprt;

284

return sprt;

285

}

285

}

286

}

286

}

287

288

if (oif) {

288

if (oif) {

289

if (local)

289

if (local)

290

return local;

290

return local;

291

292

if (flags & RT6_LOOKUP_F_IFACE)

292

if (flags & RT6_LOOKUP_F_IFACE)

293

return net->ipv6.ip6_null_entry;

293

return net->ipv6.ip6_null_entry;

294

}

294

}

295

out:

295

out:

296

return rt;

296

return rt;

297

}

297

}

298

299

#ifdef CONFIG_IPV6_ROUTER_PREF

299

#ifdef CONFIG_IPV6_ROUTER_PREF

300

static void rt6_probe(struct rt6_info *rt)

300

static void rt6_probe(struct rt6_info *rt)

301

{

301

{

302

struct neighbour *neigh = rt ? rt->rt6i_nexthop : NULL;

302

struct neighbour *neigh = rt ? rt->rt6i_nexthop : NULL;

303

/*

303

/*

304

* Okay, this does not seem to be appropriate

304

* Okay, this does not seem to be appropriate

305

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

305

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

306

* is really so; aka Router Reachability Probing.

306

* is really so; aka Router Reachability Probing.

307

*

307

*

308

* Router Reachability Probe MUST be rate-limited

308

* Router Reachability Probe MUST be rate-limited

309

* to no more than one per minute.

309

* to no more than one per minute.

310

*/

310

*/

311

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

311

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

312

return;

312

return;

313

read_lock_bh(&neigh->lock);

313

read_lock_bh(&neigh->lock);

314

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

314

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

315

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

315

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

316

struct in6_addr mcaddr;

316

struct in6_addr mcaddr;

317

struct in6_addr *target;

317

struct in6_addr *target;

318

319

neigh->updated = jiffies;

319

neigh->updated = jiffies;

320

read_unlock_bh(&neigh->lock);

320

read_unlock_bh(&neigh->lock);

321

322

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

322

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

323

addrconf_addr_solict_mult(target, &mcaddr);

323

addrconf_addr_solict_mult(target, &mcaddr);

324

ndisc_send_ns(rt->rt6i_dev, NULL, target, &mcaddr, NULL);

324

ndisc_send_ns(rt->rt6i_dev, NULL, target, &mcaddr, NULL);

325

} else

325

} else

326

read_unlock_bh(&neigh->lock);

326

read_unlock_bh(&neigh->lock);

327

}

327

}

328

#else

328

#else

329

static inline void rt6_probe(struct rt6_info *rt)

329

static inline void rt6_probe(struct rt6_info *rt)

330

{

330

{

331

}

331

}

332

#endif

332

#endif

333

334

/*

334

/*

335

* Default Router Selection (RFC 2461 6.3.6)

335

* Default Router Selection (RFC 2461 6.3.6)

336

*/

336

*/

337

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

337

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

338

{

338

{

339

struct net_device *dev = rt->rt6i_dev;

339

struct net_device *dev = rt->rt6i_dev;

340

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

340

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

341

return 2;

341

return 2;

342

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

342

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

343

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

343

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

344

return 1;

344

return 1;

345

return 0;

345

return 0;

346

}

346

}

347

348

static inline int rt6_check_neigh(struct rt6_info *rt)

348

static inline int rt6_check_neigh(struct rt6_info *rt)

349

{

349

{

350

struct neighbour *neigh = rt->rt6i_nexthop;

350

struct neighbour *neigh = rt->rt6i_nexthop;

351

int m;

351

int m;

352

if (rt->rt6i_flags & RTF_NONEXTHOP ||

352

if (rt->rt6i_flags & RTF_NONEXTHOP ||

353

!(rt->rt6i_flags & RTF_GATEWAY))

353

!(rt->rt6i_flags & RTF_GATEWAY))

354

m = 1;

354

m = 1;

355

else if (neigh) {

355

else if (neigh) {

356

read_lock_bh(&neigh->lock);

356

read_lock_bh(&neigh->lock);

357

if (neigh->nud_state & NUD_VALID)

357

if (neigh->nud_state & NUD_VALID)

358

m = 2;

358

m = 2;

359

#ifdef CONFIG_IPV6_ROUTER_PREF

359

#ifdef CONFIG_IPV6_ROUTER_PREF

360

else if (neigh->nud_state & NUD_FAILED)

360

else if (neigh->nud_state & NUD_FAILED)

361

m = 0;

361

m = 0;

362

#endif

362

#endif

363

else

363

else

364

m = 1;

364

m = 1;

365

read_unlock_bh(&neigh->lock);

365

read_unlock_bh(&neigh->lock);

366

} else

366

} else

367

m = 0;

367

m = 0;

368

return m;

368

return m;

369

}

369

}

370

371

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

371

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

372

int strict)

372

int strict)

373

{

373

{

374

int m, n;

374

int m, n;

375

376

m = rt6_check_dev(rt, oif);

376

m = rt6_check_dev(rt, oif);

377

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

377

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

378

return -1;

378

return -1;

379

#ifdef CONFIG_IPV6_ROUTER_PREF

379

#ifdef CONFIG_IPV6_ROUTER_PREF

380

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

380

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

381

#endif

381

#endif

382

n = rt6_check_neigh(rt);

382

n = rt6_check_neigh(rt);

383

if (!n && (strict & RT6_LOOKUP_F_REACHABLE))

383

if (!n && (strict & RT6_LOOKUP_F_REACHABLE))

384

return -1;

384

return -1;

385

return m;

385

return m;

386

}

386

}

387

388

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

388

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

389

int *mpri, struct rt6_info *match)

389

int *mpri, struct rt6_info *match)

390

{

390

{

391

int m;

391

int m;

392

393

if (rt6_check_expired(rt))

393

if (rt6_check_expired(rt))

394

goto out;

394

goto out;

395

396

m = rt6_score_route(rt, oif, strict);

396

m = rt6_score_route(rt, oif, strict);

397

if (m < 0)

397

if (m < 0)

398

goto out;

398

goto out;

399

400

if (m > *mpri) {

400

if (m > *mpri) {

401

if (strict & RT6_LOOKUP_F_REACHABLE)

401

if (strict & RT6_LOOKUP_F_REACHABLE)

402

rt6_probe(match);

402

rt6_probe(match);

403

*mpri = m;

403

*mpri = m;

404

match = rt;

404

match = rt;

405

} else if (strict & RT6_LOOKUP_F_REACHABLE) {

405

} else if (strict & RT6_LOOKUP_F_REACHABLE) {

406

rt6_probe(rt);

406

rt6_probe(rt);

407

}

407

}

408

409

out:

409

out:

410

return match;

410

return match;

411

}

411

}

412

413

static struct rt6_info *find_rr_leaf(struct fib6_node *fn,

413

static struct rt6_info *find_rr_leaf(struct fib6_node *fn,

414

struct rt6_info *rr_head,

414

struct rt6_info *rr_head,

415

u32 metric, int oif, int strict)

415

u32 metric, int oif, int strict)

416

{

416

{

417

struct rt6_info *rt, *match;

417

struct rt6_info *rt, *match;

418

int mpri = -1;

418

int mpri = -1;

419

420

match = NULL;

420

match = NULL;

421

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

421

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

422

rt = rt->dst.rt6_next)

422

rt = rt->dst.rt6_next)

423

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

423

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

424

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

424

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

425

rt = rt->dst.rt6_next)

425

rt = rt->dst.rt6_next)

426

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

426

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

427

428

return match;

428

return match;

429

}

429

}

430

431

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

431

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

432

{

432

{

433

struct rt6_info *match, *rt0;

433

struct rt6_info *match, *rt0;

434

struct net *net;

434

struct net *net;

435

436

RT6_TRACE("%s(fn->leaf=%p, oif=%d)\n",

436

RT6_TRACE("%s(fn->leaf=%p, oif=%d)\n",

437

__func__, fn->leaf, oif);

437

__func__, fn->leaf, oif);

438

439

rt0 = fn->rr_ptr;

439

rt0 = fn->rr_ptr;

440

if (!rt0)

440

if (!rt0)

441

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

441

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

442

443

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

443

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

444

445

if (!match &&

445

if (!match &&

446

(strict & RT6_LOOKUP_F_REACHABLE)) {

446

(strict & RT6_LOOKUP_F_REACHABLE)) {

447

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

447

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

448

449

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

449

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

450

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

450

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

451

next = fn->leaf;

451

next = fn->leaf;

452

453

if (next != rt0)

453

if (next != rt0)

454

fn->rr_ptr = next;

454

fn->rr_ptr = next;

455

}

455

}

456

457

RT6_TRACE("%s() => %p\n",

457

RT6_TRACE("%s() => %p\n",

458

__func__, match);

458

__func__, match);

459

460

net = dev_net(rt0->rt6i_dev);

460

net = dev_net(rt0->rt6i_dev);

461

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

461

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

462

}

462

}

463

464

#ifdef CONFIG_IPV6_ROUTE_INFO

464

#ifdef CONFIG_IPV6_ROUTE_INFO

465

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

465

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

466

struct in6_addr *gwaddr)

466

struct in6_addr *gwaddr)

467

{

467

{

468

struct net *net = dev_net(dev);

468

struct net *net = dev_net(dev);

469

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

469

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

470

struct in6_addr prefix_buf, *prefix;

470

struct in6_addr prefix_buf, *prefix;

471

unsigned int pref;

471

unsigned int pref;

472

unsigned long lifetime;

472

unsigned long lifetime;

473

struct rt6_info *rt;

473

struct rt6_info *rt;

474

475

if (len < sizeof(struct route_info)) {

475

if (len < sizeof(struct route_info)) {

476

return -EINVAL;

476

return -EINVAL;

477

}

477

}

478

479

/* Sanity check for prefix_len and length */

479

/* Sanity check for prefix_len and length */

480

if (rinfo->length > 3) {

480

if (rinfo->length > 3) {

481

return -EINVAL;

481

return -EINVAL;

482

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

482

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

483

return -EINVAL;

483

return -EINVAL;

484

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

484

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

485

if (rinfo->length < 2) {

485

if (rinfo->length < 2) {

486

return -EINVAL;

486

return -EINVAL;

487

}

487

}

488

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

488

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

489

if (rinfo->length < 1) {

489

if (rinfo->length < 1) {

490

return -EINVAL;

490

return -EINVAL;

491

}

491

}

492

}

492

}

493

494

pref = rinfo->route_pref;

494

pref = rinfo->route_pref;

495

if (pref == ICMPV6_ROUTER_PREF_INVALID)

495

if (pref == ICMPV6_ROUTER_PREF_INVALID)

496

return -EINVAL;

496

return -EINVAL;

497

498

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

498

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

499

500

if (rinfo->length == 3)

500

if (rinfo->length == 3)

501

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

501

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

502

else {

502

else {

503

/* this function is safe */

503

/* this function is safe */

504

ipv6_addr_prefix(&prefix_buf,

504

ipv6_addr_prefix(&prefix_buf,

505

(struct in6_addr *)rinfo->prefix,

505

(struct in6_addr *)rinfo->prefix,

506

rinfo->prefix_len);

506

rinfo->prefix_len);

507

prefix = &prefix_buf;

507

prefix = &prefix_buf;

508

}

508

}

509

510

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

510

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

511

dev->ifindex);

511

dev->ifindex);

512

513

if (rt && !lifetime) {

513

if (rt && !lifetime) {

514

ip6_del_rt(rt);

514

ip6_del_rt(rt);

515

rt = NULL;

515

rt = NULL;

516

}

516

}

517

518

if (!rt && lifetime)

518

if (!rt && lifetime)

519

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

519

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

520

pref);

520

pref);

521

else if (rt)

521

else if (rt)

522

rt->rt6i_flags = RTF_ROUTEINFO |

522

rt->rt6i_flags = RTF_ROUTEINFO |

523

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

523

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

524

525

if (rt) {

525

if (rt) {

526

if (!addrconf_finite_timeout(lifetime)) {

526

if (!addrconf_finite_timeout(lifetime)) {

527

rt->rt6i_flags &= ~RTF_EXPIRES;

527

rt->rt6i_flags &= ~RTF_EXPIRES;

528

} else {

528

} else {

529

rt->rt6i_expires = jiffies + HZ * lifetime;

529

rt->rt6i_expires = jiffies + HZ * lifetime;

530

rt->rt6i_flags |= RTF_EXPIRES;

530

rt->rt6i_flags |= RTF_EXPIRES;

531

}

531

}

532

dst_release(&rt->dst);

532

dst_release(&rt->dst);

533

}

533

}

534

return 0;

534

return 0;

535

}

535

}

536

#endif

536

#endif

537

538

#define BACKTRACK(__net, saddr) \

538

#define BACKTRACK(__net, saddr) \

539

do { \

539

do { \

540

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

540

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

541

struct fib6_node *pn; \

541

struct fib6_node *pn; \

542

while (1) { \

542

while (1) { \

543

if (fn->fn_flags & RTN_TL_ROOT) \

543

if (fn->fn_flags & RTN_TL_ROOT) \

544

goto out; \

544

goto out; \

545

pn = fn->parent; \

545

pn = fn->parent; \

546

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

546

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

547

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

547

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

548

else \

548

else \

549

fn = pn; \

549

fn = pn; \

550

if (fn->fn_flags & RTN_RTINFO) \

550

if (fn->fn_flags & RTN_RTINFO) \

551

goto restart; \

551

goto restart; \

552

} \

552

} \

553

} \

553

} \

554

} while(0)

554

} while(0)

555

556

static struct rt6_info *ip6_pol_route_lookup(struct net *net,

556

static struct rt6_info *ip6_pol_route_lookup(struct net *net,

557

struct fib6_table *table,

557

struct fib6_table *table,

558

struct flowi *fl, int flags)

558

struct flowi *fl, int flags)

559

{

559

{

560

struct fib6_node *fn;

560

struct fib6_node *fn;

561

struct rt6_info *rt;

561

struct rt6_info *rt;

562

563

read_lock_bh(&table->tb6_lock);

563

read_lock_bh(&table->tb6_lock);

564

fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);

564

fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);

565

restart:

565

restart:

566

rt = fn->leaf;

566

rt = fn->leaf;

567

rt = rt6_device_match(net, rt, &fl->fl6_src, fl->oif, flags);

567

rt = rt6_device_match(net, rt, &fl->fl6_src, fl->oif, flags);

568

BACKTRACK(net, &fl->fl6_src);

568

BACKTRACK(net, &fl->fl6_src);

569

out:

569

out:

570

dst_use(&rt->dst, jiffies);

570

dst_use(&rt->dst, jiffies);

571

read_unlock_bh(&table->tb6_lock);

571

read_unlock_bh(&table->tb6_lock);

572

return rt;

572

return rt;

573

574

}

574

}

575

576

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

576

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

577

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

577

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

578

{

578

{

579

struct flowi fl = {

579

struct flowi fl = {

580

.oif = oif,

580

.oif = oif,

581

.fl6_dst = *daddr,

581

.fl6_dst = *daddr,

582

};

582

};

583

struct dst_entry *dst;

583

struct dst_entry *dst;

584

int flags = strict ? RT6_LOOKUP_F_IFACE : 0;

584

int flags = strict ? RT6_LOOKUP_F_IFACE : 0;

585

586

if (saddr) {

586

if (saddr) {

587

memcpy(&fl.fl6_src, saddr, sizeof(*saddr));

587

memcpy(&fl.fl6_src, saddr, sizeof(*saddr));

588

flags |= RT6_LOOKUP_F_HAS_SADDR;

588

flags |= RT6_LOOKUP_F_HAS_SADDR;

589

}

589

}

590

591

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

591

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

592

if (dst->error == 0)

592

if (dst->error == 0)

593

return (struct rt6_info *) dst;

593

return (struct rt6_info *) dst;

594

595

dst_release(dst);

595

dst_release(dst);

596

597

return NULL;

597

return NULL;

598

}

598

}

599

600

EXPORT_SYMBOL(rt6_lookup);

600

EXPORT_SYMBOL(rt6_lookup);

601

602

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

602

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

603

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

603

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

604

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

604

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

605

be destroyed.

605

be destroyed.

606

*/

606

*/

607

608

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

608

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

609

{

609

{

610

int err;

610

int err;

611

struct fib6_table *table;

611

struct fib6_table *table;

612

613

table = rt->rt6i_table;

613

table = rt->rt6i_table;

614

write_lock_bh(&table->tb6_lock);

614

write_lock_bh(&table->tb6_lock);

615

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

615

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

616

write_unlock_bh(&table->tb6_lock);

616

write_unlock_bh(&table->tb6_lock);

617

618

return err;

618

return err;

619

}

619

}

620

621

int ip6_ins_rt(struct rt6_info *rt)

621

int ip6_ins_rt(struct rt6_info *rt)

622

{

622

{

623

struct nl_info info = {

623

struct nl_info info = {

624

.nl_net = dev_net(rt->rt6i_dev),

624

.nl_net = dev_net(rt->rt6i_dev),

625

};

625

};

626

return __ip6_ins_rt(rt, &info);

626

return __ip6_ins_rt(rt, &info);

627

}

627

}

628

629

static struct rt6_info *rt6_alloc_cow(struct rt6_info *ort, struct in6_addr *daddr,

629

static struct rt6_info *rt6_alloc_cow(struct rt6_info *ort, struct in6_addr *daddr,

630

struct in6_addr *saddr)

630

struct in6_addr *saddr)

631

{

631

{

632

struct rt6_info *rt;

632

struct rt6_info *rt;

633

634

/*

634

/*

635

* Clone the route.

635

* Clone the route.

636

*/

636

*/

637

638

rt = ip6_rt_copy(ort);

638

rt = ip6_rt_copy(ort);

639

640

if (rt) {

640

if (rt) {

641

struct neighbour *neigh;

641

struct neighbour *neigh;

642

int attempts = !in_softirq();

642

int attempts = !in_softirq();

643

644

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

644

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

645

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

645

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

646

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

646

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

647

rt->rt6i_flags |= RTF_ANYCAST;

647

rt->rt6i_flags |= RTF_ANYCAST;

648

ipv6_addr_copy(&rt->rt6i_gateway, daddr);

648

ipv6_addr_copy(&rt->rt6i_gateway, daddr);

649

}

649

}

650

651

ipv6_addr_copy(&rt->rt6i_dst.addr, daddr);

651

ipv6_addr_copy(&rt->rt6i_dst.addr, daddr);

652

rt->rt6i_dst.plen = 128;

652

rt->rt6i_dst.plen = 128;

653

rt->rt6i_flags |= RTF_CACHE;

653

rt->rt6i_flags |= RTF_CACHE;

654

rt->dst.flags |= DST_HOST;

654

rt->dst.flags |= DST_HOST;

655

656

#ifdef CONFIG_IPV6_SUBTREES

656

#ifdef CONFIG_IPV6_SUBTREES

657

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

657

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

658

ipv6_addr_copy(&rt->rt6i_src.addr, saddr);

658

ipv6_addr_copy(&rt->rt6i_src.addr, saddr);

659

rt->rt6i_src.plen = 128;

659

rt->rt6i_src.plen = 128;

660

}

660

}

661

#endif

661

#endif

662

663

retry:

663

retry:

664

neigh = ndisc_get_neigh(rt->rt6i_dev, &rt->rt6i_gateway);

664

neigh = ndisc_get_neigh(rt->rt6i_dev, &rt->rt6i_gateway);

665

if (IS_ERR(neigh)) {

665

if (IS_ERR(neigh)) {

666

struct net *net = dev_net(rt->rt6i_dev);

666

struct net *net = dev_net(rt->rt6i_dev);

667

int saved_rt_min_interval =

667

int saved_rt_min_interval =

668

net->ipv6.sysctl.ip6_rt_gc_min_interval;

668

net->ipv6.sysctl.ip6_rt_gc_min_interval;

669

int saved_rt_elasticity =

669

int saved_rt_elasticity =

670

net->ipv6.sysctl.ip6_rt_gc_elasticity;

670

net->ipv6.sysctl.ip6_rt_gc_elasticity;

671

672

if (attempts-- > 0) {

672

if (attempts-- > 0) {

673

net->ipv6.sysctl.ip6_rt_gc_elasticity = 1;

673

net->ipv6.sysctl.ip6_rt_gc_elasticity = 1;

674

net->ipv6.sysctl.ip6_rt_gc_min_interval = 0;

674

net->ipv6.sysctl.ip6_rt_gc_min_interval = 0;

675

676

ip6_dst_gc(&net->ipv6.ip6_dst_ops);

676

ip6_dst_gc(&net->ipv6.ip6_dst_ops);

677

678

net->ipv6.sysctl.ip6_rt_gc_elasticity =

678

net->ipv6.sysctl.ip6_rt_gc_elasticity =

679

saved_rt_elasticity;

679

saved_rt_elasticity;

680

net->ipv6.sysctl.ip6_rt_gc_min_interval =

680

net->ipv6.sysctl.ip6_rt_gc_min_interval =

681

saved_rt_min_interval;

681

saved_rt_min_interval;

682

goto retry;

682

goto retry;

683

}

683

}

684

685

if (net_ratelimit())

685

if (net_ratelimit())

686

printk(KERN_WARNING

686

printk(KERN_WARNING

687

"ipv6: Neighbour table overflow.\n");

687

"ipv6: Neighbour table overflow.\n");

688

dst_free(&rt->dst);

688

dst_free(&rt->dst);

689

return NULL;

689

return NULL;

690

}

690

}

691

rt->rt6i_nexthop = neigh;

691

rt->rt6i_nexthop = neigh;

692

693

}

693

}

694

695

return rt;

695

return rt;

696

}

696

}

697

698

static struct rt6_info *rt6_alloc_clone(struct rt6_info *ort, struct in6_addr *daddr)

698

static struct rt6_info *rt6_alloc_clone(struct rt6_info *ort, struct in6_addr *daddr)

699

{

699

{

700

struct rt6_info *rt = ip6_rt_copy(ort);

700

struct rt6_info *rt = ip6_rt_copy(ort);

701

if (rt) {

701

if (rt) {

702

ipv6_addr_copy(&rt->rt6i_dst.addr, daddr);

702

ipv6_addr_copy(&rt->rt6i_dst.addr, daddr);

703

rt->rt6i_dst.plen = 128;

703

rt->rt6i_dst.plen = 128;

704

rt->rt6i_flags |= RTF_CACHE;

704

rt->rt6i_flags |= RTF_CACHE;

705

rt->dst.flags |= DST_HOST;

705

rt->dst.flags |= DST_HOST;

706

rt->rt6i_nexthop = neigh_clone(ort->rt6i_nexthop);

706

rt->rt6i_nexthop = neigh_clone(ort->rt6i_nexthop);

707

}

707

}

708

return rt;

708

return rt;

709

}

709

}

710

711

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

711

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

712

struct flowi *fl, int flags)

712

struct flowi *fl, int flags)

713

{

713

{

714

struct fib6_node *fn;

714

struct fib6_node *fn;

715

struct rt6_info *rt, *nrt;

715

struct rt6_info *rt, *nrt;

716

int strict = 0;

716

int strict = 0;

717

int attempts = 3;

717

int attempts = 3;

718

int err;

718

int err;

719

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

719

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

720

721

strict |= flags & RT6_LOOKUP_F_IFACE;

721

strict |= flags & RT6_LOOKUP_F_IFACE;

722

723

relookup:

723

relookup:

724

read_lock_bh(&table->tb6_lock);

724

read_lock_bh(&table->tb6_lock);

725

726

restart_2:

726

restart_2:

727

fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);

727

fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);

728

729

restart:

729

restart:

730

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

730

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

731

732

BACKTRACK(net, &fl->fl6_src);

732

BACKTRACK(net, &fl->fl6_src);

733

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

733

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

734

rt->rt6i_flags & RTF_CACHE)

734

rt->rt6i_flags & RTF_CACHE)

735

goto out;

735

goto out;

736

737

dst_hold(&rt->dst);

737

dst_hold(&rt->dst);

738

read_unlock_bh(&table->tb6_lock);

738

read_unlock_bh(&table->tb6_lock);

739

740

if (!rt->rt6i_nexthop && !(rt->rt6i_flags & RTF_NONEXTHOP))

740

if (!rt->rt6i_nexthop && !(rt->rt6i_flags & RTF_NONEXTHOP))

741

nrt = rt6_alloc_cow(rt, &fl->fl6_dst, &fl->fl6_src);

741

nrt = rt6_alloc_cow(rt, &fl->fl6_dst, &fl->fl6_src);

742

else

742

else

743

nrt = rt6_alloc_clone(rt, &fl->fl6_dst);

743

nrt = rt6_alloc_clone(rt, &fl->fl6_dst);

744

745

dst_release(&rt->dst);

745

dst_release(&rt->dst);

746

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

746

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

747

748

dst_hold(&rt->dst);

748

dst_hold(&rt->dst);

749

if (nrt) {

749

if (nrt) {

750

err = ip6_ins_rt(nrt);

750

err = ip6_ins_rt(nrt);

751

if (!err)

751

if (!err)

752

goto out2;

752

goto out2;

753

}

753

}

754

755

if (--attempts <= 0)

755

if (--attempts <= 0)

756

goto out2;

756

goto out2;

757

758

/*

758

/*

759

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

759

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

760

* released someone could insert this route. Relookup.

760

* released someone could insert this route. Relookup.

761

*/

761

*/

762

dst_release(&rt->dst);

762

dst_release(&rt->dst);

763

goto relookup;

763

goto relookup;

764

765

out:

765

out:

766

if (reachable) {

766

if (reachable) {

767

reachable = 0;

767

reachable = 0;

768

goto restart_2;

768

goto restart_2;

769

}

769

}

770

dst_hold(&rt->dst);

770

dst_hold(&rt->dst);

771

read_unlock_bh(&table->tb6_lock);

771

read_unlock_bh(&table->tb6_lock);

772

out2:

772

out2:

773

rt->dst.lastuse = jiffies;

773

rt->dst.lastuse = jiffies;

774

rt->dst.__use++;

774

rt->dst.__use++;

775

776

return rt;

776

return rt;

777

}

777

}

778

779

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

779

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

780

struct flowi *fl, int flags)

780

struct flowi *fl, int flags)

781

{

781

{

782

return ip6_pol_route(net, table, fl->iif, fl, flags);

782

return ip6_pol_route(net, table, fl->iif, fl, flags);

783

}

783

}

784

785

void ip6_route_input(struct sk_buff *skb)

785

void ip6_route_input(struct sk_buff *skb)

786

{

786

{

787

struct ipv6hdr *iph = ipv6_hdr(skb);

787

struct ipv6hdr *iph = ipv6_hdr(skb);

788

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

788

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

789

int flags = RT6_LOOKUP_F_HAS_SADDR;

789

int flags = RT6_LOOKUP_F_HAS_SADDR;

790

struct flowi fl = {

790

struct flowi fl = {

791

.iif = skb->dev->ifindex,

791

.iif = skb->dev->ifindex,

792

.fl6_dst = iph->daddr,

792

.fl6_dst = iph->daddr,

793

.fl6_src = iph->saddr,

793

.fl6_src = iph->saddr,

794

.fl6_flowlabel = (* (__be32 *) iph)&IPV6_FLOWINFO_MASK,

794

.fl6_flowlabel = (* (__be32 *) iph)&IPV6_FLOWINFO_MASK,

795

.mark = skb->mark,

795

.mark = skb->mark,

796

.proto = iph->nexthdr,

796

.proto = iph->nexthdr,

797

};

797

};

798

799

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

799

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

800

flags |= RT6_LOOKUP_F_IFACE;

800

flags |= RT6_LOOKUP_F_IFACE;

801

802

skb_dst_set(skb, fib6_rule_lookup(net, &fl, flags, ip6_pol_route_input));

802

skb_dst_set(skb, fib6_rule_lookup(net, &fl, flags, ip6_pol_route_input));

803

}

803

}

804

805

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

805

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

806

struct flowi *fl, int flags)

806

struct flowi *fl, int flags)

807

{

807

{

808

return ip6_pol_route(net, table, fl->oif, fl, flags);

808

return ip6_pol_route(net, table, fl->oif, fl, flags);

809

}

809

}

810

811

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

811

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

812

struct flowi *fl)

812

struct flowi *fl)

813

{

813

{

814

int flags = 0;

814

int flags = 0;

815

816

if ((sk && sk->sk_bound_dev_if) || rt6_need_strict(&fl->fl6_dst))

816

if ((sk && sk->sk_bound_dev_if) || rt6_need_strict(&fl->fl6_dst))

817

flags |= RT6_LOOKUP_F_IFACE;

817

flags |= RT6_LOOKUP_F_IFACE;

818

819

if (!ipv6_addr_any(&fl->fl6_src))

819

if (!ipv6_addr_any(&fl->fl6_src))

820

flags |= RT6_LOOKUP_F_HAS_SADDR;

820

flags |= RT6_LOOKUP_F_HAS_SADDR;

821

else if (sk)

821

else if (sk)

822

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

822

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

823

824

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

824

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

825

}

825

}

826

827

EXPORT_SYMBOL(ip6_route_output);

827

EXPORT_SYMBOL(ip6_route_output);

828

829

int ip6_dst_blackhole(struct sock *sk, struct dst_entry **dstp, struct flowi *fl)

829

int ip6_dst_blackhole(struct sock *sk, struct dst_entry **dstp, struct flowi *fl)

830

{

830

{

831

struct rt6_info *ort = (struct rt6_info *) *dstp;

831

struct rt6_info *ort = (struct rt6_info *) *dstp;

832

struct rt6_info *rt = (struct rt6_info *)

832

struct rt6_info *rt = (struct rt6_info *)

833

dst_alloc(&ip6_dst_blackhole_ops);

833

dst_alloc(&ip6_dst_blackhole_ops);

834

struct dst_entry *new = NULL;

834

struct dst_entry *new = NULL;

835

836

if (rt) {

836

if (rt) {

837

new = &rt->dst;

837

new = &rt->dst;

838

839

atomic_set(&new->__refcnt, 1);

839

atomic_set(&new->__refcnt, 1);

840

new->__use = 1;

840

new->__use = 1;

841

new->input = dst_discard;

841

new->input = dst_discard;

842

new->output = dst_discard;

842

new->output = dst_discard;

843

844

dst_copy_metrics(new, &ort->dst);

844

dst_copy_metrics(new, &ort->dst);

845

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

845

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

846

if (new->dev)

846

if (new->dev)

847

dev_hold(new->dev);

847

dev_hold(new->dev);

848

rt->rt6i_idev = ort->rt6i_idev;

848

rt->rt6i_idev = ort->rt6i_idev;

849

if (rt->rt6i_idev)

849

if (rt->rt6i_idev)

850

in6_dev_hold(rt->rt6i_idev);

850

in6_dev_hold(rt->rt6i_idev);

851

rt->rt6i_expires = 0;

851

rt->rt6i_expires = 0;

852

853

ipv6_addr_copy(&rt->rt6i_gateway, &ort->rt6i_gateway);

853

ipv6_addr_copy(&rt->rt6i_gateway, &ort->rt6i_gateway);

854

rt->rt6i_flags = ort->rt6i_flags & ~RTF_EXPIRES;

854

rt->rt6i_flags = ort->rt6i_flags & ~RTF_EXPIRES;

855

rt->rt6i_metric = 0;

855

rt->rt6i_metric = 0;

856

857

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

857

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

858

#ifdef CONFIG_IPV6_SUBTREES

858

#ifdef CONFIG_IPV6_SUBTREES

859

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

859

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

860

#endif

860

#endif

861

862

dst_free(new);

862

dst_free(new);

863

}

863

}

864

865

dst_release(*dstp);

865

dst_release(*dstp);

866

*dstp = new;

866

*dstp = new;

867

return new ? 0 : -ENOMEM;

867

return new ? 0 : -ENOMEM;

868

}

868

}

869

EXPORT_SYMBOL_GPL(ip6_dst_blackhole);

869

EXPORT_SYMBOL_GPL(ip6_dst_blackhole);

870

871

/*

871

/*

872

* Destination cache support functions

872

* Destination cache support functions

873

*/

873

*/

874

875

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

875

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

876

{

876

{

877

struct rt6_info *rt;

877

struct rt6_info *rt;

878

879

rt = (struct rt6_info *) dst;

879

rt = (struct rt6_info *) dst;

880

881

if (rt->rt6i_node && (rt->rt6i_node->fn_sernum == cookie))

881

if (rt->rt6i_node && (rt->rt6i_node->fn_sernum == cookie))

882

return dst;

882

return dst;

883

884

return NULL;

884

return NULL;

885

}

885

}

886

887

static struct dst_entry *ip6_negative_advice(struct dst_entry *dst)

887

static struct dst_entry *ip6_negative_advice(struct dst_entry *dst)

888

{

888

{

889

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

889

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

890

891

if (rt) {

891

if (rt) {

892

if (rt->rt6i_flags & RTF_CACHE) {

892

if (rt->rt6i_flags & RTF_CACHE) {

893

if (rt6_check_expired(rt)) {

893

if (rt6_check_expired(rt)) {

894

ip6_del_rt(rt);

894

ip6_del_rt(rt);

895

dst = NULL;

895

dst = NULL;

896

}

896

}

897

} else {

897

} else {

898

dst_release(dst);

898

dst_release(dst);

899

dst = NULL;

899

dst = NULL;

900

}

900

}

901

}

901

}

902

return dst;

902

return dst;

903

}

903

}

904

905

static void ip6_link_failure(struct sk_buff *skb)

905

static void ip6_link_failure(struct sk_buff *skb)

906

{

906

{

907

struct rt6_info *rt;

907

struct rt6_info *rt;

908

909

icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_ADDR_UNREACH, 0);

909

icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_ADDR_UNREACH, 0);

910

911

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

911

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

912

if (rt) {

912

if (rt) {

913

if (rt->rt6i_flags&RTF_CACHE) {

913

if (rt->rt6i_flags&RTF_CACHE) {

914

dst_set_expires(&rt->dst, 0);

914

dst_set_expires(&rt->dst, 0);

915

rt->rt6i_flags |= RTF_EXPIRES;

915

rt->rt6i_flags |= RTF_EXPIRES;

916

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

916

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

917

rt->rt6i_node->fn_sernum = -1;

917

rt->rt6i_node->fn_sernum = -1;

918

}

918

}

919

}

919

}

920

921

static void ip6_rt_update_pmtu(struct dst_entry *dst, u32 mtu)

921

static void ip6_rt_update_pmtu(struct dst_entry *dst, u32 mtu)

922

{

922

{

923

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

923

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

924

925

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

925

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

926

rt6->rt6i_flags |= RTF_MODIFIED;

926

rt6->rt6i_flags |= RTF_MODIFIED;

927

if (mtu < IPV6_MIN_MTU) {

927

if (mtu < IPV6_MIN_MTU) {

928

u32 features = dst_metric(dst, RTAX_FEATURES);

928

u32 features = dst_metric(dst, RTAX_FEATURES);

929

mtu = IPV6_MIN_MTU;

929

mtu = IPV6_MIN_MTU;

930

features |= RTAX_FEATURE_ALLFRAG;

930

features |= RTAX_FEATURE_ALLFRAG;

931

dst_metric_set(dst, RTAX_FEATURES, features);

931

dst_metric_set(dst, RTAX_FEATURES, features);

932

}

932

}

933

dst_metric_set(dst, RTAX_MTU, mtu);

933

dst_metric_set(dst, RTAX_MTU, mtu);

934

call_netevent_notifiers(NETEVENT_PMTU_UPDATE, dst);

934

call_netevent_notifiers(NETEVENT_PMTU_UPDATE, dst);

935

}

935

}

936

}

936

}

937

938

static unsigned int ip6_default_advmss(const struct dst_entry *dst)

938

static unsigned int ip6_default_advmss(const struct dst_entry *dst)

939

{

939

{

940

struct net_device *dev = dst->dev;

940

struct net_device *dev = dst->dev;

941

unsigned int mtu = dst_mtu(dst);

941

unsigned int mtu = dst_mtu(dst);

942

struct net *net = dev_net(dev);

942

struct net *net = dev_net(dev);

943

944

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

944

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

945

946

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

946

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

947

mtu = net->ipv6.sysctl.ip6_rt_min_advmss;

947

mtu = net->ipv6.sysctl.ip6_rt_min_advmss;

948

949

/*

949

/*

950

* Maximal non-jumbo IPv6 payload is IPV6_MAXPLEN and

950

* Maximal non-jumbo IPv6 payload is IPV6_MAXPLEN and

951

* corresponding MSS is IPV6_MAXPLEN - tcp_header_size.

951

* corresponding MSS is IPV6_MAXPLEN - tcp_header_size.

952

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

952

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

953

* rely only on pmtu discovery"

953

* rely only on pmtu discovery"

954

*/

954

*/

955

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

955

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

956

mtu = IPV6_MAXPLEN;

956

mtu = IPV6_MAXPLEN;

957

return mtu;

957

return mtu;

958

}

958

}

959

960

static unsigned int ip6_default_mtu(const struct dst_entry *dst)

960

static unsigned int ip6_default_mtu(const struct dst_entry *dst)

961

{

961

{

962

unsigned int mtu = IPV6_MIN_MTU;

962

unsigned int mtu = IPV6_MIN_MTU;

963

struct inet6_dev *idev;

963

struct inet6_dev *idev;

964

965

rcu_read_lock();

965

rcu_read_lock();

966

idev = __in6_dev_get(dst->dev);

966

idev = __in6_dev_get(dst->dev);

967

if (idev)

967

if (idev)

968

mtu = idev->cnf.mtu6;

968

mtu = idev->cnf.mtu6;

969

rcu_read_unlock();

969

rcu_read_unlock();

970

971

return mtu;

971

return mtu;

972

}

972

}

973

974

static struct dst_entry *icmp6_dst_gc_list;

974

static struct dst_entry *icmp6_dst_gc_list;

975

static DEFINE_SPINLOCK(icmp6_dst_lock);

975

static DEFINE_SPINLOCK(icmp6_dst_lock);

976

977

struct dst_entry *icmp6_dst_alloc(struct net_device *dev,

977

struct dst_entry *icmp6_dst_alloc(struct net_device *dev,

978

struct neighbour *neigh,

978

struct neighbour *neigh,

979

const struct in6_addr *addr)

979

const struct in6_addr *addr)

980

{

980

{

981

struct rt6_info *rt;

981

struct rt6_info *rt;

982

struct inet6_dev *idev = in6_dev_get(dev);

982

struct inet6_dev *idev = in6_dev_get(dev);

983

struct net *net = dev_net(dev);

983

struct net *net = dev_net(dev);

984

985

if (unlikely(idev == NULL))

985

if (unlikely(idev == NULL))

986

return NULL;

986

return NULL;

987

988

rt = ip6_dst_alloc(&net->ipv6.ip6_dst_ops);

988

rt = ip6_dst_alloc(&net->ipv6.ip6_dst_ops);

989

if (unlikely(rt == NULL)) {

989

if (unlikely(rt == NULL)) {

990

in6_dev_put(idev);

990

in6_dev_put(idev);

991

goto out;

991

goto out;

992

}

992

}

993

994

dev_hold(dev);

994

dev_hold(dev);

995

if (neigh)

995

if (neigh)

996

neigh_hold(neigh);

996

neigh_hold(neigh);

997

else {

997

else {

998

neigh = ndisc_get_neigh(dev, addr);

998

neigh = ndisc_get_neigh(dev, addr);

999

if (IS_ERR(neigh))

999

if (IS_ERR(neigh))

1000

neigh = NULL;

1000

neigh = NULL;

1001

}

1001

}

1002

1003

rt->rt6i_dev = dev;

1003

rt->rt6i_dev = dev;

1004

rt->rt6i_idev = idev;

1004

rt->rt6i_idev = idev;

1005

rt->rt6i_nexthop = neigh;

1005

rt->rt6i_nexthop = neigh;

1006

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

1006

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

1007

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

1007

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

1008

rt->dst.output = ip6_output;

1008

rt->dst.output = ip6_output;

1009

1010

#if 0 /* there's no chance to use these for ndisc */

1010

#if 0 /* there's no chance to use these for ndisc */

1011

rt->dst.flags = ipv6_addr_type(addr) & IPV6_ADDR_UNICAST

1011

rt->dst.flags = ipv6_addr_type(addr) & IPV6_ADDR_UNICAST

1012

? DST_HOST

1012

? DST_HOST

1013

: 0;

1013

: 0;

1014

ipv6_addr_copy(&rt->rt6i_dst.addr, addr);

1014

ipv6_addr_copy(&rt->rt6i_dst.addr, addr);

1015

rt->rt6i_dst.plen = 128;

1015

rt->rt6i_dst.plen = 128;

1016

#endif

1016

#endif

1017

1018

spin_lock_bh(&icmp6_dst_lock);

1018

spin_lock_bh(&icmp6_dst_lock);

1019

rt->dst.next = icmp6_dst_gc_list;

1019

rt->dst.next = icmp6_dst_gc_list;

1020

icmp6_dst_gc_list = &rt->dst;

1020

icmp6_dst_gc_list = &rt->dst;

1021

spin_unlock_bh(&icmp6_dst_lock);

1021

spin_unlock_bh(&icmp6_dst_lock);

1022

1023

fib6_force_start_gc(net);

1023

fib6_force_start_gc(net);

1024

1025

out:

1025

out:

1026

return &rt->dst;

1026

return &rt->dst;

1027

}

1027

}

1028

1029

int icmp6_dst_gc(void)

1029

int icmp6_dst_gc(void)

1030

{

1030

{

1031

struct dst_entry *dst, *next, **pprev;

1031

struct dst_entry *dst, *next, **pprev;

1032

int more = 0;

1032

int more = 0;

1033

1034

next = NULL;

1034

next = NULL;

1035

1036

spin_lock_bh(&icmp6_dst_lock);

1036

spin_lock_bh(&icmp6_dst_lock);

1037

pprev = &icmp6_dst_gc_list;

1037

pprev = &icmp6_dst_gc_list;

1038

1039

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

1039

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

1040

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

1040

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

1041

*pprev = dst->next;

1041

*pprev = dst->next;

1042

dst_free(dst);

1042

dst_free(dst);

1043

} else {

1043

} else {

1044

pprev = &dst->next;

1044

pprev = &dst->next;

1045

++more;

1045

++more;

1046

}

1046

}

1047

}

1047

}

1048

1049

spin_unlock_bh(&icmp6_dst_lock);

1049

spin_unlock_bh(&icmp6_dst_lock);

1050

1051

return more;

1051

return more;

1052

}

1052

}

1053

1054

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

1054

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

1055

void *arg)

1055

void *arg)

1056

{

1056

{

1057

struct dst_entry *dst, **pprev;

1057

struct dst_entry *dst, **pprev;

1058

1059

spin_lock_bh(&icmp6_dst_lock);

1059

spin_lock_bh(&icmp6_dst_lock);

1060

pprev = &icmp6_dst_gc_list;

1060

pprev = &icmp6_dst_gc_list;

1061

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

1061

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

1062

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

1062

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

1063

if (func(rt, arg)) {

1063

if (func(rt, arg)) {

1064

*pprev = dst->next;

1064

*pprev = dst->next;

1065

dst_free(dst);

1065

dst_free(dst);

1066

} else {

1066

} else {

1067

pprev = &dst->next;

1067

pprev = &dst->next;

1068

}

1068

}

1069

}

1069

}

1070

spin_unlock_bh(&icmp6_dst_lock);

1070

spin_unlock_bh(&icmp6_dst_lock);

1071

}

1071

}

1072

1073

static int ip6_dst_gc(struct dst_ops *ops)

1073

static int ip6_dst_gc(struct dst_ops *ops)

1074

{

1074

{

1075

unsigned long now = jiffies;

1075

unsigned long now = jiffies;

1076

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

1076

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

1077

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

1077

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

1078

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

1078

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

1079

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

1079

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

1080

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

1080

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

1081

unsigned long rt_last_gc = net->ipv6.ip6_rt_last_gc;

1081

unsigned long rt_last_gc = net->ipv6.ip6_rt_last_gc;

1082

int entries;

1082

int entries;

1083

1084

entries = dst_entries_get_fast(ops);

1084

entries = dst_entries_get_fast(ops);

1085

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

1085

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

1086

entries <= rt_max_size)

1086

entries <= rt_max_size)

1087

goto out;

1087

goto out;

1088

1089

net->ipv6.ip6_rt_gc_expire++;

1089

net->ipv6.ip6_rt_gc_expire++;

1090

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

1090

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

1091

net->ipv6.ip6_rt_last_gc = now;

1091

net->ipv6.ip6_rt_last_gc = now;

1092

entries = dst_entries_get_slow(ops);

1092

entries = dst_entries_get_slow(ops);

1093

if (entries < ops->gc_thresh)

1093

if (entries < ops->gc_thresh)

1094

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

1094

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

1095

out:

1095

out:

1096

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

1096

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

1097

return entries > rt_max_size;

1097

return entries > rt_max_size;

1098

}

1098

}

1099

1100

/* Clean host part of a prefix. Not necessary in radix tree,

1100

/* Clean host part of a prefix. Not necessary in radix tree,

1101

but results in cleaner routing tables.

1101

but results in cleaner routing tables.

1102

1103

Remove it only when all the things will work!

1103

Remove it only when all the things will work!

1104

*/

1104

*/

1105

1106

int ip6_dst_hoplimit(struct dst_entry *dst)

1106

int ip6_dst_hoplimit(struct dst_entry *dst)

1107

{

1107

{

1108

int hoplimit = dst_metric_raw(dst, RTAX_HOPLIMIT);

1108

int hoplimit = dst_metric_raw(dst, RTAX_HOPLIMIT);

1109

if (hoplimit == 0) {

1109

if (hoplimit == 0) {

1110

struct net_device *dev = dst->dev;

1110

struct net_device *dev = dst->dev;

1111

struct inet6_dev *idev;

1111

struct inet6_dev *idev;

1112

1113

rcu_read_lock();

1113

rcu_read_lock();

1114

idev = __in6_dev_get(dev);

1114

idev = __in6_dev_get(dev);

1115

if (idev)

1115

if (idev)

1116

hoplimit = idev->cnf.hop_limit;

1116

hoplimit = idev->cnf.hop_limit;

1117

else

1117

else

1118

hoplimit = dev_net(dev)->ipv6.devconf_all->hop_limit;

1118

hoplimit = dev_net(dev)->ipv6.devconf_all->hop_limit;

1119

rcu_read_unlock();

1119

rcu_read_unlock();

1120

}

1120

}

1121

return hoplimit;

1121

return hoplimit;

1122

}

1122

}

1123

EXPORT_SYMBOL(ip6_dst_hoplimit);

1123

EXPORT_SYMBOL(ip6_dst_hoplimit);

1124

1125

/*

1125

/*

1126

*

1126

*

1127

*/

1127

*/

1128

1129

int ip6_route_add(struct fib6_config *cfg)

1129

int ip6_route_add(struct fib6_config *cfg)

1130

{

1130

{

1131

int err;

1131

int err;

1132

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

1132

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

1133

struct rt6_info *rt = NULL;

1133

struct rt6_info *rt = NULL;

1134

struct net_device *dev = NULL;

1134

struct net_device *dev = NULL;

1135

struct inet6_dev *idev = NULL;

1135

struct inet6_dev *idev = NULL;

1136

struct fib6_table *table;

1136

struct fib6_table *table;

1137

int addr_type;

1137

int addr_type;

1138

1139

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

1139

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

1140

return -EINVAL;

1140

return -EINVAL;

1141

#ifndef CONFIG_IPV6_SUBTREES

1141

#ifndef CONFIG_IPV6_SUBTREES

1142

if (cfg->fc_src_len)

1142

if (cfg->fc_src_len)

1143

return -EINVAL;

1143

return -EINVAL;

1144

#endif

1144

#endif

1145

if (cfg->fc_ifindex) {

1145

if (cfg->fc_ifindex) {

1146

err = -ENODEV;

1146

err = -ENODEV;

1147

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

1147

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

1148

if (!dev)

1148

if (!dev)

1149

goto out;

1149

goto out;

1150

idev = in6_dev_get(dev);

1150

idev = in6_dev_get(dev);

1151

if (!idev)

1151

if (!idev)

1152

goto out;

1152

goto out;

1153

}

1153

}

1154

1155

if (cfg->fc_metric == 0)

1155

if (cfg->fc_metric == 0)

1156

cfg->fc_metric = IP6_RT_PRIO_USER;

1156

cfg->fc_metric = IP6_RT_PRIO_USER;

1157

1158

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

1158

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

1159

if (table == NULL) {

1159

if (table == NULL) {

1160

err = -ENOBUFS;

1160

err = -ENOBUFS;

1161

goto out;

1161

goto out;

1162

}

1162

}

1163

1164

rt = ip6_dst_alloc(&net->ipv6.ip6_dst_ops);

1164

rt = ip6_dst_alloc(&net->ipv6.ip6_dst_ops);

1165

1166

if (rt == NULL) {

1166

if (rt == NULL) {

1167

err = -ENOMEM;

1167

err = -ENOMEM;

1168

goto out;

1168

goto out;

1169

}

1169

}

1170

1171

rt->dst.obsolete = -1;

1171

rt->dst.obsolete = -1;

1172

rt->rt6i_expires = (cfg->fc_flags & RTF_EXPIRES) ?

1172

rt->rt6i_expires = (cfg->fc_flags & RTF_EXPIRES) ?

1173

jiffies + clock_t_to_jiffies(cfg->fc_expires) :

1173

jiffies + clock_t_to_jiffies(cfg->fc_expires) :

1174

0;

1174

0;

1175

1176

if (cfg->fc_protocol == RTPROT_UNSPEC)

1176

if (cfg->fc_protocol == RTPROT_UNSPEC)

1177

cfg->fc_protocol = RTPROT_BOOT;

1177

cfg->fc_protocol = RTPROT_BOOT;

1178

rt->rt6i_protocol = cfg->fc_protocol;

1178

rt->rt6i_protocol = cfg->fc_protocol;

1179

1180

addr_type = ipv6_addr_type(&cfg->fc_dst);

1180

addr_type = ipv6_addr_type(&cfg->fc_dst);

1181

1182

if (addr_type & IPV6_ADDR_MULTICAST)

1182

if (addr_type & IPV6_ADDR_MULTICAST)

1183

rt->dst.input = ip6_mc_input;

1183

rt->dst.input = ip6_mc_input;

1184

else if (cfg->fc_flags & RTF_LOCAL)

1184

else if (cfg->fc_flags & RTF_LOCAL)

1185

rt->dst.input = ip6_input;

1185

rt->dst.input = ip6_input;

1186

else

1186

else

1187

rt->dst.input = ip6_forward;

1187

rt->dst.input = ip6_forward;

1188

1189

rt->dst.output = ip6_output;

1189

rt->dst.output = ip6_output;

1190

1191

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

1191

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

1192

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

1192

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

1193

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

1193

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

1194

rt->dst.flags = DST_HOST;

1194

rt->dst.flags = DST_HOST;

1195

1196

#ifdef CONFIG_IPV6_SUBTREES

1196

#ifdef CONFIG_IPV6_SUBTREES

1197

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

1197

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

1198

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

1198

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

1199

#endif

1199

#endif

1200

1201

rt->rt6i_metric = cfg->fc_metric;

1201

rt->rt6i_metric = cfg->fc_metric;

1202

1203

/* We cannot add true routes via loopback here,

1203

/* We cannot add true routes via loopback here,

1204

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

1204

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

1205

*/

1205

*/

1206

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

1206

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

1207

(dev && (dev->flags&IFF_LOOPBACK) && !(addr_type&IPV6_ADDR_LOOPBACK)

1207

(dev && (dev->flags&IFF_LOOPBACK) && !(addr_type&IPV6_ADDR_LOOPBACK)

1208

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

1208

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

1209

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

1209

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

1210

if (dev != net->loopback_dev) {

1210

if (dev != net->loopback_dev) {

1211

if (dev) {

1211

if (dev) {

1212

dev_put(dev);

1212

dev_put(dev);

1213

in6_dev_put(idev);

1213

in6_dev_put(idev);

1214

}

1214

}

1215

dev = net->loopback_dev;

1215

dev = net->loopback_dev;

1216

dev_hold(dev);

1216

dev_hold(dev);

1217

idev = in6_dev_get(dev);

1217

idev = in6_dev_get(dev);

1218

if (!idev) {

1218

if (!idev) {

1219

err = -ENODEV;

1219

err = -ENODEV;

1220

goto out;

1220

goto out;

1221

}

1221

}

1222

}

1222

}

1223

rt->dst.output = ip6_pkt_discard_out;

1223

rt->dst.output = ip6_pkt_discard_out;

1224

rt->dst.input = ip6_pkt_discard;

1224

rt->dst.input = ip6_pkt_discard;

1225

rt->dst.error = -ENETUNREACH;

1225

rt->dst.error = -ENETUNREACH;

1226

rt->rt6i_flags = RTF_REJECT|RTF_NONEXTHOP;

1226

rt->rt6i_flags = RTF_REJECT|RTF_NONEXTHOP;

1227

goto install_route;

1227

goto install_route;

1228

}

1228

}

1229

1230

if (cfg->fc_flags & RTF_GATEWAY) {

1230

if (cfg->fc_flags & RTF_GATEWAY) {

1231

struct in6_addr *gw_addr;

1231

struct in6_addr *gw_addr;

1232

int gwa_type;

1232

int gwa_type;

1233

1234

gw_addr = &cfg->fc_gateway;

1234

gw_addr = &cfg->fc_gateway;

1235

ipv6_addr_copy(&rt->rt6i_gateway, gw_addr);

1235

ipv6_addr_copy(&rt->rt6i_gateway, gw_addr);

1236

gwa_type = ipv6_addr_type(gw_addr);

1236

gwa_type = ipv6_addr_type(gw_addr);

1237

1238

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

1238

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

1239

struct rt6_info *grt;

1239

struct rt6_info *grt;

1240

1241

/* IPv6 strictly inhibits using not link-local

1241

/* IPv6 strictly inhibits using not link-local

1242

addresses as nexthop address.

1242

addresses as nexthop address.

1243

Otherwise, router will not able to send redirects.

1243

Otherwise, router will not able to send redirects.

1244

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

1244

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

1245

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

1245

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

1246

some exceptions. --ANK

1246

some exceptions. --ANK

1247

*/

1247

*/

1248

err = -EINVAL;

1248

err = -EINVAL;

1249

if (!(gwa_type&IPV6_ADDR_UNICAST))

1249

if (!(gwa_type&IPV6_ADDR_UNICAST))

1250

goto out;

1250

goto out;

1251

1252

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

1252

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

1253

1254

err = -EHOSTUNREACH;

1254

err = -EHOSTUNREACH;

1255

if (grt == NULL)

1255

if (grt == NULL)

1256

goto out;

1256

goto out;

1257

if (dev) {

1257

if (dev) {

1258

if (dev != grt->rt6i_dev) {

1258

if (dev != grt->rt6i_dev) {

1259

dst_release(&grt->dst);

1259

dst_release(&grt->dst);

1260

goto out;

1260

goto out;

1261

}

1261

}

1262

} else {

1262

} else {

1263

dev = grt->rt6i_dev;

1263

dev = grt->rt6i_dev;

1264

idev = grt->rt6i_idev;

1264

idev = grt->rt6i_idev;

1265

dev_hold(dev);

1265

dev_hold(dev);

1266

in6_dev_hold(grt->rt6i_idev);

1266

in6_dev_hold(grt->rt6i_idev);

1267

}

1267

}

1268

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

1268

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

1269

err = 0;

1269

err = 0;

1270

dst_release(&grt->dst);

1270

dst_release(&grt->dst);

1271

1272

if (err)

1272

if (err)

1273

goto out;

1273

goto out;

1274

}

1274

}

1275

err = -EINVAL;

1275

err = -EINVAL;

1276

if (dev == NULL || (dev->flags&IFF_LOOPBACK))

1276

if (dev == NULL || (dev->flags&IFF_LOOPBACK))

1277

goto out;

1277

goto out;

1278

}

1278

}

1279

1280

err = -ENODEV;

1280

err = -ENODEV;

1281

if (dev == NULL)

1281

if (dev == NULL)

1282

goto out;

1282

goto out;

1283

1284

if (cfg->fc_flags & (RTF_GATEWAY | RTF_NONEXTHOP)) {

1284

if (cfg->fc_flags & (RTF_GATEWAY | RTF_NONEXTHOP)) {

1285

rt->rt6i_nexthop = __neigh_lookup_errno(&nd_tbl, &rt->rt6i_gateway, dev);

1285

rt->rt6i_nexthop = __neigh_lookup_errno(&nd_tbl, &rt->rt6i_gateway, dev);

1286

if (IS_ERR(rt->rt6i_nexthop)) {

1286

if (IS_ERR(rt->rt6i_nexthop)) {

1287

err = PTR_ERR(rt->rt6i_nexthop);

1287

err = PTR_ERR(rt->rt6i_nexthop);

1288

rt->rt6i_nexthop = NULL;

1288

rt->rt6i_nexthop = NULL;

1289

goto out;

1289

goto out;

1290

}

1290

}

1291

}

1291

}

1292

1293

rt->rt6i_flags = cfg->fc_flags;

1293

rt->rt6i_flags = cfg->fc_flags;

1294

1295

install_route:

1295

install_route:

1296

if (cfg->fc_mx) {

1296

if (cfg->fc_mx) {

1297

struct nlattr *nla;

1297

struct nlattr *nla;

1298

int remaining;

1298

int remaining;

1299

1300

nla_for_each_attr(nla, cfg->fc_mx, cfg->fc_mx_len, remaining) {

1300

nla_for_each_attr(nla, cfg->fc_mx, cfg->fc_mx_len, remaining) {

1301

int type = nla_type(nla);

1301

int type = nla_type(nla);

1302

1303

if (type) {

1303

if (type) {

1304

if (type > RTAX_MAX) {

1304

if (type > RTAX_MAX) {

1305

err = -EINVAL;

1305

err = -EINVAL;

1306

goto out;

1306

goto out;

1307

}

1307

}

1308

1309

dst_metric_set(&rt->dst, type, nla_get_u32(nla));

1309

dst_metric_set(&rt->dst, type, nla_get_u32(nla));

1310

}

1310

}

1311

}

1311

}

1312

}

1312

}

1313

1314

rt->dst.dev = dev;

1314

rt->dst.dev = dev;

1315

rt->rt6i_idev = idev;

1315

rt->rt6i_idev = idev;

1316

rt->rt6i_table = table;

1316

rt->rt6i_table = table;

1317

1318

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

1318

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

1319

1320

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

1320

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

1321

1322

out:

1322

out:

1323

if (dev)

1323

if (dev)

1324

dev_put(dev);

1324

dev_put(dev);

1325

if (idev)

1325

if (idev)

1326

in6_dev_put(idev);

1326

in6_dev_put(idev);

1327

if (rt)

1327

if (rt)

1328

dst_free(&rt->dst);

1328

dst_free(&rt->dst);

1329

return err;

1329

return err;

1330

}

1330

}

1331

1332

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

1332

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

1333

{

1333

{

1334

int err;

1334

int err;

1335

struct fib6_table *table;

1335

struct fib6_table *table;

1336

struct net *net = dev_net(rt->rt6i_dev);

1336

struct net *net = dev_net(rt->rt6i_dev);

1337

1338

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

1338

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

1339

return -ENOENT;

1339

return -ENOENT;

1340

1341

table = rt->rt6i_table;

1341

table = rt->rt6i_table;

1342

write_lock_bh(&table->tb6_lock);

1342

write_lock_bh(&table->tb6_lock);

1343

1344

err = fib6_del(rt, info);

1344

err = fib6_del(rt, info);

1345

dst_release(&rt->dst);

1345

dst_release(&rt->dst);

1346

1347

write_unlock_bh(&table->tb6_lock);

1347

write_unlock_bh(&table->tb6_lock);

1348

1349

return err;

1349

return err;

1350

}

1350

}

1351

1352

int ip6_del_rt(struct rt6_info *rt)

1352

int ip6_del_rt(struct rt6_info *rt)

1353

{

1353

{

1354

struct nl_info info = {

1354

struct nl_info info = {

1355

.nl_net = dev_net(rt->rt6i_dev),

1355

.nl_net = dev_net(rt->rt6i_dev),

1356

};

1356

};

1357

return __ip6_del_rt(rt, &info);

1357

return __ip6_del_rt(rt, &info);

1358

}

1358

}

1359

1360

static int ip6_route_del(struct fib6_config *cfg)

1360

static int ip6_route_del(struct fib6_config *cfg)

1361

{

1361

{

1362

struct fib6_table *table;

1362

struct fib6_table *table;

1363

struct fib6_node *fn;

1363

struct fib6_node *fn;

1364

struct rt6_info *rt;

1364

struct rt6_info *rt;

1365

int err = -ESRCH;

1365

int err = -ESRCH;

1366

1367

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

1367

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

1368

if (table == NULL)

1368

if (table == NULL)

1369

return err;

1369

return err;

1370

1371

read_lock_bh(&table->tb6_lock);

1371

read_lock_bh(&table->tb6_lock);

1372

1373

fn = fib6_locate(&table->tb6_root,

1373

fn = fib6_locate(&table->tb6_root,

1374

&cfg->fc_dst, cfg->fc_dst_len,

1374

&cfg->fc_dst, cfg->fc_dst_len,

1375

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

1375

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

1376

1377

if (fn) {

1377

if (fn) {

1378

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

1378

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

1379

if (cfg->fc_ifindex &&

1379

if (cfg->fc_ifindex &&

1380

(rt->rt6i_dev == NULL ||

1380

(rt->rt6i_dev == NULL ||

1381

rt->rt6i_dev->ifindex != cfg->fc_ifindex))

1381

rt->rt6i_dev->ifindex != cfg->fc_ifindex))

1382

continue;

1382

continue;

1383

if (cfg->fc_flags & RTF_GATEWAY &&

1383

if (cfg->fc_flags & RTF_GATEWAY &&

1384

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

1384

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

1385

continue;

1385

continue;

1386

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

1386

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

1387

continue;

1387

continue;

1388

dst_hold(&rt->dst);

1388

dst_hold(&rt->dst);

1389

read_unlock_bh(&table->tb6_lock);

1389

read_unlock_bh(&table->tb6_lock);

1390

1391

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

1391

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

1392

}

1392

}

1393

}

1393

}

1394

read_unlock_bh(&table->tb6_lock);

1394

read_unlock_bh(&table->tb6_lock);

1395

1396

return err;

1396

return err;

1397

}

1397

}

1398

1399

/*

1399

/*

1400

* Handle redirects

1400

* Handle redirects

1401

*/

1401

*/

1402

struct ip6rd_flowi {

1402

struct ip6rd_flowi {

1403

struct flowi fl;

1403

struct flowi fl;

1404

struct in6_addr gateway;

1404

struct in6_addr gateway;

1405

};

1405

};

1406

1407

static struct rt6_info *__ip6_route_redirect(struct net *net,

1407

static struct rt6_info *__ip6_route_redirect(struct net *net,

1408

struct fib6_table *table,

1408

struct fib6_table *table,

1409

struct flowi *fl,

1409

struct flowi *fl,

1410

int flags)

1410

int flags)

1411

{

1411

{

1412

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

1412

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

1413

struct rt6_info *rt;

1413

struct rt6_info *rt;

1414

struct fib6_node *fn;

1414

struct fib6_node *fn;

1415

1416

/*

1416

/*

1417

* Get the "current" route for this destination and

1417

* Get the "current" route for this destination and

1418

* check if the redirect has come from approriate router.

1418

* check if the redirect has come from approriate router.

1419

*

1419

*

1420

* RFC 2461 specifies that redirects should only be

1420

* RFC 2461 specifies that redirects should only be

1421

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

1421

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

1422

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

1422

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

1423

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

1423

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

1424

* routes.

1424

* routes.

1425

*/

1425

*/

1426

1427

read_lock_bh(&table->tb6_lock);

1427

read_lock_bh(&table->tb6_lock);

1428

fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);

1428

fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);

1429

restart:

1429

restart:

1430

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

1430

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

1431

/*

1431

/*

1432

* Current route is on-link; redirect is always invalid.

1432

* Current route is on-link; redirect is always invalid.

1433

*

1433

*

1434

* Seems, previous statement is not true. It could

1434

* Seems, previous statement is not true. It could

1435

* be node, which looks for us as on-link (f.e. proxy ndisc)

1435

* be node, which looks for us as on-link (f.e. proxy ndisc)

1436

* But then router serving it might decide, that we should

1436

* But then router serving it might decide, that we should

1437

* know truth 8)8) --ANK (980726).

1437

* know truth 8)8) --ANK (980726).

1438

*/

1438

*/

1439

if (rt6_check_expired(rt))

1439

if (rt6_check_expired(rt))

1440

continue;

1440

continue;

1441

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

1441

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

1442

continue;

1442

continue;

1443

if (fl->oif != rt->rt6i_dev->ifindex)

1443

if (fl->oif != rt->rt6i_dev->ifindex)

1444

continue;

1444

continue;

1445

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

1445

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

1446

continue;

1446

continue;

1447

break;

1447

break;

1448

}

1448

}

1449

1450

if (!rt)

1450

if (!rt)

1451

rt = net->ipv6.ip6_null_entry;

1451

rt = net->ipv6.ip6_null_entry;

1452

BACKTRACK(net, &fl->fl6_src);

1452

BACKTRACK(net, &fl->fl6_src);

1453

out:

1453

out:

1454

dst_hold(&rt->dst);

1454

dst_hold(&rt->dst);

1455

1456

read_unlock_bh(&table->tb6_lock);

1456

read_unlock_bh(&table->tb6_lock);

1457

1458

return rt;

1458

return rt;

1459

};

1459

};

1460

1461

static struct rt6_info *ip6_route_redirect(struct in6_addr *dest,

1461

static struct rt6_info *ip6_route_redirect(struct in6_addr *dest,

1462

struct in6_addr *src,

1462

struct in6_addr *src,

1463

struct in6_addr *gateway,

1463

struct in6_addr *gateway,

1464

struct net_device *dev)

1464

struct net_device *dev)

1465

{

1465

{

1466

int flags = RT6_LOOKUP_F_HAS_SADDR;

1466

int flags = RT6_LOOKUP_F_HAS_SADDR;

1467

struct net *net = dev_net(dev);

1467

struct net *net = dev_net(dev);

1468

struct ip6rd_flowi rdfl = {

1468

struct ip6rd_flowi rdfl = {

1469

.fl = {

1469

.fl = {

1470

.oif = dev->ifindex,

1470

.oif = dev->ifindex,

1471

.fl6_dst = *dest,

1471

.fl6_dst = *dest,

1472

.fl6_src = *src,

1472

.fl6_src = *src,

1473

},

1473

},

1474

};

1474

};

1475

1476

ipv6_addr_copy(&rdfl.gateway, gateway);

1476

ipv6_addr_copy(&rdfl.gateway, gateway);

1477

1478

if (rt6_need_strict(dest))

1478

if (rt6_need_strict(dest))

1479

flags |= RT6_LOOKUP_F_IFACE;

1479

flags |= RT6_LOOKUP_F_IFACE;

1480

1481

return (struct rt6_info *)fib6_rule_lookup(net, (struct flowi *)&rdfl,

1481

return (struct rt6_info *)fib6_rule_lookup(net, (struct flowi *)&rdfl,

1482

flags, __ip6_route_redirect);

1482

flags, __ip6_route_redirect);

1483

}

1483

}

1484

1485

void rt6_redirect(struct in6_addr *dest, struct in6_addr *src,

1485

void rt6_redirect(struct in6_addr *dest, struct in6_addr *src,

1486

struct in6_addr *saddr,

1486

struct in6_addr *saddr,

1487

struct neighbour *neigh, u8 *lladdr, int on_link)

1487

struct neighbour *neigh, u8 *lladdr, int on_link)

1488

{

1488

{

1489

struct rt6_info *rt, *nrt = NULL;

1489

struct rt6_info *rt, *nrt = NULL;

1490

struct netevent_redirect netevent;

1490

struct netevent_redirect netevent;

1491

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

1491

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

1492

1493

rt = ip6_route_redirect(dest, src, saddr, neigh->dev);

1493

rt = ip6_route_redirect(dest, src, saddr, neigh->dev);

1494

1495

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

1495

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

1496

if (net_ratelimit())

1496

if (net_ratelimit())

1497

printk(KERN_DEBUG "rt6_redirect: source isn't a valid nexthop "

1497

printk(KERN_DEBUG "rt6_redirect: source isn't a valid nexthop "

1498

"for redirect target\n");

1498

"for redirect target\n");

1499

goto out;

1499

goto out;

1500

}

1500

}

1501

1502

/*

1502

/*

1503

* We have finally decided to accept it.

1503

* We have finally decided to accept it.

1504

*/

1504

*/

1505

1506

neigh_update(neigh, lladdr, NUD_STALE,

1506

neigh_update(neigh, lladdr, NUD_STALE,

1507

NEIGH_UPDATE_F_WEAK_OVERRIDE|

1507

NEIGH_UPDATE_F_WEAK_OVERRIDE|

1508

NEIGH_UPDATE_F_OVERRIDE|

1508

NEIGH_UPDATE_F_OVERRIDE|

1509

(on_link ? 0 : (NEIGH_UPDATE_F_OVERRIDE_ISROUTER|

1509

(on_link ? 0 : (NEIGH_UPDATE_F_OVERRIDE_ISROUTER|

1510

NEIGH_UPDATE_F_ISROUTER))

1510

NEIGH_UPDATE_F_ISROUTER))

1511

);

1511

);

1512

1513

/*

1513

/*

1514

* Redirect received -> path was valid.

1514

* Redirect received -> path was valid.

1515

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

1515

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

1516

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

1516

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

1517

*/

1517

*/

1518

dst_confirm(&rt->dst);

1518

dst_confirm(&rt->dst);

1519

1520

/* Duplicate redirect: silently ignore. */

1520

/* Duplicate redirect: silently ignore. */

1521

if (neigh == rt->dst.neighbour)

1521

if (neigh == rt->dst.neighbour)

1522

goto out;

1522

goto out;

1523

1524

nrt = ip6_rt_copy(rt);

1524

nrt = ip6_rt_copy(rt);

1525

if (nrt == NULL)

1525

if (nrt == NULL)

1526

goto out;

1526

goto out;

1527

1528

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

1528

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

1529

if (on_link)

1529

if (on_link)

1530

nrt->rt6i_flags &= ~RTF_GATEWAY;

1530

nrt->rt6i_flags &= ~RTF_GATEWAY;

1531

1532

ipv6_addr_copy(&nrt->rt6i_dst.addr, dest);

1532

ipv6_addr_copy(&nrt->rt6i_dst.addr, dest);

1533

nrt->rt6i_dst.plen = 128;

1533

nrt->rt6i_dst.plen = 128;

1534

nrt->dst.flags |= DST_HOST;

1534

nrt->dst.flags |= DST_HOST;

1535

1536

ipv6_addr_copy(&nrt->rt6i_gateway, (struct in6_addr*)neigh->primary_key);

1536

ipv6_addr_copy(&nrt->rt6i_gateway, (struct in6_addr*)neigh->primary_key);

1537

nrt->rt6i_nexthop = neigh_clone(neigh);

1537

nrt->rt6i_nexthop = neigh_clone(neigh);

1538

1539

if (ip6_ins_rt(nrt))

1539

if (ip6_ins_rt(nrt))

1540

goto out;

1540

goto out;

1541

1542

netevent.old = &rt->dst;

1542

netevent.old = &rt->dst;

1543

netevent.new = &nrt->dst;

1543

netevent.new = &nrt->dst;

1544

call_netevent_notifiers(NETEVENT_REDIRECT, &netevent);

1544

call_netevent_notifiers(NETEVENT_REDIRECT, &netevent);

1545

1546

if (rt->rt6i_flags&RTF_CACHE) {

1546

if (rt->rt6i_flags&RTF_CACHE) {

1547

ip6_del_rt(rt);

1547

ip6_del_rt(rt);

1548

return;

1548

return;

1549

}

1549

}

1550

1551

out:

1551

out:

1552

dst_release(&rt->dst);

1552

dst_release(&rt->dst);

1553

}

1553

}

1554

1555

/*

1555

/*

1556

* Handle ICMP "packet too big" messages

1556

* Handle ICMP "packet too big" messages

1557

* i.e. Path MTU discovery

1557

* i.e. Path MTU discovery

1558

*/

1558

*/

1559

1560

static void rt6_do_pmtu_disc(struct in6_addr *daddr, struct in6_addr *saddr,

1560

static void rt6_do_pmtu_disc(struct in6_addr *daddr, struct in6_addr *saddr,

1561

struct net *net, u32 pmtu, int ifindex)

1561

struct net *net, u32 pmtu, int ifindex)

1562

{

1562

{

1563

struct rt6_info *rt, *nrt;

1563

struct rt6_info *rt, *nrt;

1564

int allfrag = 0;

1564

int allfrag = 0;

1565

again:

1565

again:

1566

rt = rt6_lookup(net, daddr, saddr, ifindex, 0);

1566

rt = rt6_lookup(net, daddr, saddr, ifindex, 0);

1567

if (rt == NULL)

1567

if (rt == NULL)

1568

return;

1568

return;

1569

1570

if (rt6_check_expired(rt)) {

1570

if (rt6_check_expired(rt)) {

1571

ip6_del_rt(rt);

1571

ip6_del_rt(rt);

1572

goto again;

1572

goto again;

1573

}

1573

}

1574

1575

if (pmtu >= dst_mtu(&rt->dst))

1575

if (pmtu >= dst_mtu(&rt->dst))

1576

goto out;

1576

goto out;

1577

1578

if (pmtu < IPV6_MIN_MTU) {

1578

if (pmtu < IPV6_MIN_MTU) {

1579

/*

1579

/*

1580

* According to RFC2460, PMTU is set to the IPv6 Minimum Link

1580

* According to RFC2460, PMTU is set to the IPv6 Minimum Link

1581

* MTU (1280) and a fragment header should always be included

1581

* MTU (1280) and a fragment header should always be included

1582

* after a node receiving Too Big message reporting PMTU is

1582

* after a node receiving Too Big message reporting PMTU is

1583

* less than the IPv6 Minimum Link MTU.

1583

* less than the IPv6 Minimum Link MTU.

1584

*/

1584

*/

1585

pmtu = IPV6_MIN_MTU;

1585

pmtu = IPV6_MIN_MTU;

1586

allfrag = 1;

1586

allfrag = 1;

1587

}

1587

}

1588

1589

/* New mtu received -> path was valid.

1589

/* New mtu received -> path was valid.

1590

They are sent only in response to data packets,

1590

They are sent only in response to data packets,

1591

so that this nexthop apparently is reachable. --ANK

1591

so that this nexthop apparently is reachable. --ANK

1592

*/

1592

*/

1593

dst_confirm(&rt->dst);

1593

dst_confirm(&rt->dst);

1594

1595

/* Host route. If it is static, it would be better

1595

/* Host route. If it is static, it would be better

1596

not to override it, but add new one, so that

1596

not to override it, but add new one, so that

1597

when cache entry will expire old pmtu

1597

when cache entry will expire old pmtu

1598

would return automatically.

1598

would return automatically.

1599

*/

1599

*/

1600

if (rt->rt6i_flags & RTF_CACHE) {

1600

if (rt->rt6i_flags & RTF_CACHE) {

1601

dst_metric_set(&rt->dst, RTAX_MTU, pmtu);

1601

dst_metric_set(&rt->dst, RTAX_MTU, pmtu);

1602

if (allfrag) {

1602

if (allfrag) {

1603

u32 features = dst_metric(&rt->dst, RTAX_FEATURES);

1603

u32 features = dst_metric(&rt->dst, RTAX_FEATURES);

1604

features |= RTAX_FEATURE_ALLFRAG;

1604

features |= RTAX_FEATURE_ALLFRAG;

1605

dst_metric_set(&rt->dst, RTAX_FEATURES, features);

1605

dst_metric_set(&rt->dst, RTAX_FEATURES, features);

1606

}

1606

}

1607

dst_set_expires(&rt->dst, net->ipv6.sysctl.ip6_rt_mtu_expires);

1607

dst_set_expires(&rt->dst, net->ipv6.sysctl.ip6_rt_mtu_expires);

1608

rt->rt6i_flags |= RTF_MODIFIED|RTF_EXPIRES;

1608

rt->rt6i_flags |= RTF_MODIFIED|RTF_EXPIRES;

1609

goto out;

1609

goto out;

1610

}

1610

}

1611

1612

/* Network route.

1612

/* Network route.

1613

Two cases are possible:

1613

Two cases are possible:

1614

1. It is connected route. Action: COW

1614

1. It is connected route. Action: COW

1615

2. It is gatewayed route or NONEXTHOP route. Action: clone it.

1615

2. It is gatewayed route or NONEXTHOP route. Action: clone it.

1616

*/

1616

*/

1617

if (!rt->rt6i_nexthop && !(rt->rt6i_flags & RTF_NONEXTHOP))

1617

if (!rt->rt6i_nexthop && !(rt->rt6i_flags & RTF_NONEXTHOP))

1618

nrt = rt6_alloc_cow(rt, daddr, saddr);

1618

nrt = rt6_alloc_cow(rt, daddr, saddr);

1619

else

1619

else

1620

nrt = rt6_alloc_clone(rt, daddr);

1620

nrt = rt6_alloc_clone(rt, daddr);

1621

1622

if (nrt) {

1622

if (nrt) {

1623

dst_metric_set(&nrt->dst, RTAX_MTU, pmtu);

1623

dst_metric_set(&nrt->dst, RTAX_MTU, pmtu);

1624

if (allfrag) {

1624

if (allfrag) {

1625

u32 features = dst_metric(&nrt->dst, RTAX_FEATURES);

1625

u32 features = dst_metric(&nrt->dst, RTAX_FEATURES);

1626

features |= RTAX_FEATURE_ALLFRAG;

1626

features |= RTAX_FEATURE_ALLFRAG;

1627

dst_metric_set(&nrt->dst, RTAX_FEATURES, features);

1627

dst_metric_set(&nrt->dst, RTAX_FEATURES, features);

1628

}

1628

}

1629

1630

/* According to RFC 1981, detecting PMTU increase shouldn't be

1630

/* According to RFC 1981, detecting PMTU increase shouldn't be

1631

* happened within 5 mins, the recommended timer is 10 mins.

1631

* happened within 5 mins, the recommended timer is 10 mins.

1632

* Here this route expiration time is set to ip6_rt_mtu_expires

1632

* Here this route expiration time is set to ip6_rt_mtu_expires

1633

* which is 10 mins. After 10 mins the decreased pmtu is expired

1633

* which is 10 mins. After 10 mins the decreased pmtu is expired

1634

* and detecting PMTU increase will be automatically happened.

1634

* and detecting PMTU increase will be automatically happened.

1635

*/

1635

*/

1636

dst_set_expires(&nrt->dst, net->ipv6.sysctl.ip6_rt_mtu_expires);

1636

dst_set_expires(&nrt->dst, net->ipv6.sysctl.ip6_rt_mtu_expires);

1637

nrt->rt6i_flags |= RTF_DYNAMIC|RTF_EXPIRES;

1637

nrt->rt6i_flags |= RTF_DYNAMIC|RTF_EXPIRES;

1638

1639

ip6_ins_rt(nrt);

1639

ip6_ins_rt(nrt);

1640

}

1640

}

1641

out:

1641

out:

1642

dst_release(&rt->dst);

1642

dst_release(&rt->dst);

1643

}

1643

}

1644

1645

void rt6_pmtu_discovery(struct in6_addr *daddr, struct in6_addr *saddr,

1645

void rt6_pmtu_discovery(struct in6_addr *daddr, struct in6_addr *saddr,

1646

struct net_device *dev, u32 pmtu)

1646

struct net_device *dev, u32 pmtu)

1647

{

1647

{

1648

struct net *net = dev_net(dev);

1648

struct net *net = dev_net(dev);

1649

1650

/*

1650

/*

1651

* RFC 1981 states that a node "MUST reduce the size of the packets it

1651

* RFC 1981 states that a node "MUST reduce the size of the packets it

1652

* is sending along the path" that caused the Packet Too Big message.

1652

* is sending along the path" that caused the Packet Too Big message.

1653

* Since it's not possible in the general case to determine which

1653

* Since it's not possible in the general case to determine which

1654

* interface was used to send the original packet, we update the MTU

1654

* interface was used to send the original packet, we update the MTU

1655

* on the interface that will be used to send future packets. We also

1655

* on the interface that will be used to send future packets. We also

1656

* update the MTU on the interface that received the Packet Too Big in

1656

* update the MTU on the interface that received the Packet Too Big in

1657

* case the original packet was forced out that interface with

1657

* case the original packet was forced out that interface with

1658

* SO_BINDTODEVICE or similar. This is the next best thing to the

1658

* SO_BINDTODEVICE or similar. This is the next best thing to the

1659

* correct behaviour, which would be to update the MTU on all

1659

* correct behaviour, which would be to update the MTU on all

1660

* interfaces.

1660

* interfaces.

1661

*/

1661

*/

1662

rt6_do_pmtu_disc(daddr, saddr, net, pmtu, 0);

1662

rt6_do_pmtu_disc(daddr, saddr, net, pmtu, 0);

1663

rt6_do_pmtu_disc(daddr, saddr, net, pmtu, dev->ifindex);

1663

rt6_do_pmtu_disc(daddr, saddr, net, pmtu, dev->ifindex);

1664

}

1664

}

1665

1666

/*

1666

/*

1667

* Misc support functions

1667

* Misc support functions

1668

*/

1668

*/

1669

1670

static struct rt6_info * ip6_rt_copy(struct rt6_info *ort)

1670

static struct rt6_info * ip6_rt_copy(struct rt6_info *ort)

1671

{

1671

{

1672

struct net *net = dev_net(ort->rt6i_dev);

1672

struct net *net = dev_net(ort->rt6i_dev);

1673

struct rt6_info *rt = ip6_dst_alloc(&net->ipv6.ip6_dst_ops);

1673

struct rt6_info *rt = ip6_dst_alloc(&net->ipv6.ip6_dst_ops);

1674

1675

if (rt) {

1675

if (rt) {

1676

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

1676

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

1677

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

1677

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

1678

1679

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

1679

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

1680

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

1680

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

1681

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

1681

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

1682

if (rt->dst.dev)

1682

if (rt->dst.dev)

1683

dev_hold(rt->dst.dev);

1683

dev_hold(rt->dst.dev);

1684

rt->rt6i_idev = ort->rt6i_idev;

1684

rt->rt6i_idev = ort->rt6i_idev;

1685

if (rt->rt6i_idev)

1685

if (rt->rt6i_idev)

1686

in6_dev_hold(rt->rt6i_idev);

1686

in6_dev_hold(rt->rt6i_idev);

1687

rt->dst.lastuse = jiffies;

1687

rt->dst.lastuse = jiffies;

1688

rt->rt6i_expires = 0;

1688

rt->rt6i_expires = 0;

1689

1690

ipv6_addr_copy(&rt->rt6i_gateway, &ort->rt6i_gateway);

1690

ipv6_addr_copy(&rt->rt6i_gateway, &ort->rt6i_gateway);

1691

rt->rt6i_flags = ort->rt6i_flags & ~RTF_EXPIRES;

1691

rt->rt6i_flags = ort->rt6i_flags & ~RTF_EXPIRES;

1692

rt->rt6i_metric = 0;

1692

rt->rt6i_metric = 0;

1693

1694

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

1694

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

1695

#ifdef CONFIG_IPV6_SUBTREES

1695

#ifdef CONFIG_IPV6_SUBTREES

1696

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

1696

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

1697

#endif

1697

#endif

1698

rt->rt6i_table = ort->rt6i_table;

1698

rt->rt6i_table = ort->rt6i_table;

1699

}

1699

}

1700

return rt;

1700

return rt;

1701

}

1701

}

1702

1703

#ifdef CONFIG_IPV6_ROUTE_INFO

1703

#ifdef CONFIG_IPV6_ROUTE_INFO

1704

static struct rt6_info *rt6_get_route_info(struct net *net,

1704

static struct rt6_info *rt6_get_route_info(struct net *net,

1705

struct in6_addr *prefix, int prefixlen,

1705

struct in6_addr *prefix, int prefixlen,

1706

struct in6_addr *gwaddr, int ifindex)

1706

struct in6_addr *gwaddr, int ifindex)

1707

{

1707

{

1708

struct fib6_node *fn;

1708

struct fib6_node *fn;

1709

struct rt6_info *rt = NULL;

1709

struct rt6_info *rt = NULL;

1710

struct fib6_table *table;

1710

struct fib6_table *table;

1711

1712

table = fib6_get_table(net, RT6_TABLE_INFO);

1712

table = fib6_get_table(net, RT6_TABLE_INFO);

1713

if (table == NULL)

1713

if (table == NULL)

1714

return NULL;

1714

return NULL;

1715

1716

write_lock_bh(&table->tb6_lock);

1716

write_lock_bh(&table->tb6_lock);

1717

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

1717

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

1718

if (!fn)

1718

if (!fn)

1719

goto out;

1719

goto out;

1720

1721

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

1721

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

1722

if (rt->rt6i_dev->ifindex != ifindex)

1722

if (rt->rt6i_dev->ifindex != ifindex)

1723

continue;

1723

continue;

1724

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

1724

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

1725

continue;

1725

continue;

1726

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

1726

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

1727

continue;

1727

continue;

1728

dst_hold(&rt->dst);

1728

dst_hold(&rt->dst);

1729

break;

1729

break;

1730

}

1730

}

1731

out:

1731

out:

1732

write_unlock_bh(&table->tb6_lock);

1732

write_unlock_bh(&table->tb6_lock);

1733

return rt;

1733

return rt;

1734

}

1734

}

1735

1736

static struct rt6_info *rt6_add_route_info(struct net *net,

1736

static struct rt6_info *rt6_add_route_info(struct net *net,

1737

struct in6_addr *prefix, int prefixlen,

1737

struct in6_addr *prefix, int prefixlen,

1738

struct in6_addr *gwaddr, int ifindex,

1738

struct in6_addr *gwaddr, int ifindex,

1739

unsigned pref)

1739

unsigned pref)

1740

{

1740

{

1741

struct fib6_config cfg = {

1741

struct fib6_config cfg = {

1742

.fc_table = RT6_TABLE_INFO,

1742

.fc_table = RT6_TABLE_INFO,

1743

.fc_metric = IP6_RT_PRIO_USER,

1743

.fc_metric = IP6_RT_PRIO_USER,

1744

.fc_ifindex = ifindex,

1744

.fc_ifindex = ifindex,

1745

.fc_dst_len = prefixlen,

1745

.fc_dst_len = prefixlen,

1746

.fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_ROUTEINFO |

1746

.fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_ROUTEINFO |

1747

RTF_UP | RTF_PREF(pref),

1747

RTF_UP | RTF_PREF(pref),

1748

.fc_nlinfo.pid = 0,

1748

.fc_nlinfo.pid = 0,

1749

.fc_nlinfo.nlh = NULL,

1749

.fc_nlinfo.nlh = NULL,

1750

.fc_nlinfo.nl_net = net,

1750

.fc_nlinfo.nl_net = net,

1751

};

1751

};

1752

1753

ipv6_addr_copy(&cfg.fc_dst, prefix);

1753

ipv6_addr_copy(&cfg.fc_dst, prefix);

1754

ipv6_addr_copy(&cfg.fc_gateway, gwaddr);

1754

ipv6_addr_copy(&cfg.fc_gateway, gwaddr);

1755

1756

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

1756

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

1757

if (!prefixlen)

1757

if (!prefixlen)

1758

cfg.fc_flags |= RTF_DEFAULT;

1758

cfg.fc_flags |= RTF_DEFAULT;

1759

1760

ip6_route_add(&cfg);

1760

ip6_route_add(&cfg);

1761

1762

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

1762

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

1763

}

1763

}

1764

#endif

1764

#endif

1765

1766

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

1766

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

1767

{

1767

{

1768

struct rt6_info *rt;

1768

struct rt6_info *rt;

1769

struct fib6_table *table;

1769

struct fib6_table *table;

1770

1771

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

1771

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

1772

if (table == NULL)

1772

if (table == NULL)

1773

return NULL;

1773

return NULL;

1774

1775

write_lock_bh(&table->tb6_lock);

1775

write_lock_bh(&table->tb6_lock);

1776

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

1776

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

1777

if (dev == rt->rt6i_dev &&

1777

if (dev == rt->rt6i_dev &&

1778

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

1778

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

1779

ipv6_addr_equal(&rt->rt6i_gateway, addr))

1779

ipv6_addr_equal(&rt->rt6i_gateway, addr))

1780

break;

1780

break;

1781

}

1781

}

1782

if (rt)

1782

if (rt)

1783

dst_hold(&rt->dst);

1783

dst_hold(&rt->dst);

1784

write_unlock_bh(&table->tb6_lock);

1784

write_unlock_bh(&table->tb6_lock);

1785

return rt;

1785

return rt;

1786

}

1786

}

1787

1788

struct rt6_info *rt6_add_dflt_router(struct in6_addr *gwaddr,

1788

struct rt6_info *rt6_add_dflt_router(struct in6_addr *gwaddr,

1789

struct net_device *dev,

1789

struct net_device *dev,

1790

unsigned int pref)

1790

unsigned int pref)

1791

{

1791

{

1792

struct fib6_config cfg = {

1792

struct fib6_config cfg = {

1793

.fc_table = RT6_TABLE_DFLT,

1793

.fc_table = RT6_TABLE_DFLT,

1794

.fc_metric = IP6_RT_PRIO_USER,

1794

.fc_metric = IP6_RT_PRIO_USER,

1795

.fc_ifindex = dev->ifindex,

1795

.fc_ifindex = dev->ifindex,

1796

.fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_DEFAULT |

1796

.fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_DEFAULT |

1797

RTF_UP | RTF_EXPIRES | RTF_PREF(pref),

1797

RTF_UP | RTF_EXPIRES | RTF_PREF(pref),

1798

.fc_nlinfo.pid = 0,

1798

.fc_nlinfo.pid = 0,

1799

.fc_nlinfo.nlh = NULL,

1799

.fc_nlinfo.nlh = NULL,

1800

.fc_nlinfo.nl_net = dev_net(dev),

1800

.fc_nlinfo.nl_net = dev_net(dev),

1801

};

1801

};

1802

1803

ipv6_addr_copy(&cfg.fc_gateway, gwaddr);

1803

ipv6_addr_copy(&cfg.fc_gateway, gwaddr);

1804

1805

ip6_route_add(&cfg);

1805

ip6_route_add(&cfg);

1806

1807

return rt6_get_dflt_router(gwaddr, dev);

1807

return rt6_get_dflt_router(gwaddr, dev);

1808

}

1808

}

1809

1810

void rt6_purge_dflt_routers(struct net *net)

1810

void rt6_purge_dflt_routers(struct net *net)

1811

{

1811

{

1812

struct rt6_info *rt;

1812

struct rt6_info *rt;

1813

struct fib6_table *table;

1813

struct fib6_table *table;

1814

1815

/* NOTE: Keep consistent with rt6_get_dflt_router */

1815

/* NOTE: Keep consistent with rt6_get_dflt_router */

1816

table = fib6_get_table(net, RT6_TABLE_DFLT);

1816

table = fib6_get_table(net, RT6_TABLE_DFLT);

1817

if (table == NULL)

1817

if (table == NULL)

1818

return;

1818

return;

1819

1820

restart:

1820

restart:

1821

read_lock_bh(&table->tb6_lock);

1821

read_lock_bh(&table->tb6_lock);

1822

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

1822

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

1823

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

1823

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

1824

dst_hold(&rt->dst);

1824

dst_hold(&rt->dst);

1825

read_unlock_bh(&table->tb6_lock);

1825

read_unlock_bh(&table->tb6_lock);

1826

ip6_del_rt(rt);

1826

ip6_del_rt(rt);

1827

goto restart;

1827

goto restart;

1828

}

1828

}

1829

}

1829

}

1830

read_unlock_bh(&table->tb6_lock);

1830

read_unlock_bh(&table->tb6_lock);

1831

}

1831

}

1832

1833

static void rtmsg_to_fib6_config(struct net *net,

1833

static void rtmsg_to_fib6_config(struct net *net,

1834

struct in6_rtmsg *rtmsg,

1834

struct in6_rtmsg *rtmsg,

1835

struct fib6_config *cfg)

1835

struct fib6_config *cfg)

1836

{

1836

{

1837

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

1837

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

1838

1839

cfg->fc_table = RT6_TABLE_MAIN;

1839

cfg->fc_table = RT6_TABLE_MAIN;

1840

cfg->fc_ifindex = rtmsg->rtmsg_ifindex;

1840

cfg->fc_ifindex = rtmsg->rtmsg_ifindex;

1841

cfg->fc_metric = rtmsg->rtmsg_metric;

1841

cfg->fc_metric = rtmsg->rtmsg_metric;

1842

cfg->fc_expires = rtmsg->rtmsg_info;

1842

cfg->fc_expires = rtmsg->rtmsg_info;

1843

cfg->fc_dst_len = rtmsg->rtmsg_dst_len;

1843

cfg->fc_dst_len = rtmsg->rtmsg_dst_len;

1844

cfg->fc_src_len = rtmsg->rtmsg_src_len;

1844

cfg->fc_src_len = rtmsg->rtmsg_src_len;

1845

cfg->fc_flags = rtmsg->rtmsg_flags;

1845

cfg->fc_flags = rtmsg->rtmsg_flags;

1846

1847

cfg->fc_nlinfo.nl_net = net;

1847

cfg->fc_nlinfo.nl_net = net;

1848

1849

ipv6_addr_copy(&cfg->fc_dst, &rtmsg->rtmsg_dst);

1849

ipv6_addr_copy(&cfg->fc_dst, &rtmsg->rtmsg_dst);

1850

ipv6_addr_copy(&cfg->fc_src, &rtmsg->rtmsg_src);

1850

ipv6_addr_copy(&cfg->fc_src, &rtmsg->rtmsg_src);

1851

ipv6_addr_copy(&cfg->fc_gateway, &rtmsg->rtmsg_gateway);

1851

ipv6_addr_copy(&cfg->fc_gateway, &rtmsg->rtmsg_gateway);

1852

}

1852

}

1853

1854

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

1854

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

1855

{

1855

{

1856

struct fib6_config cfg;

1856

struct fib6_config cfg;

1857

struct in6_rtmsg rtmsg;

1857

struct in6_rtmsg rtmsg;

1858

int err;

1858

int err;

1859

1860

switch(cmd) {

1860

switch(cmd) {

1861

case SIOCADDRT: /* Add a route */

1861

case SIOCADDRT: /* Add a route */

1862

case SIOCDELRT: /* Delete a route */

1862

case SIOCDELRT: /* Delete a route */

1863

if (!capable(CAP_NET_ADMIN))

1863

if (!capable(CAP_NET_ADMIN))

1864

return -EPERM;

1864

return -EPERM;

1865

err = copy_from_user(&rtmsg, arg,

1865

err = copy_from_user(&rtmsg, arg,

1866

sizeof(struct in6_rtmsg));

1866

sizeof(struct in6_rtmsg));

1867

if (err)

1867

if (err)

1868

return -EFAULT;

1868

return -EFAULT;

1869

1870

rtmsg_to_fib6_config(net, &rtmsg, &cfg);

1870

rtmsg_to_fib6_config(net, &rtmsg, &cfg);

1871

1872

rtnl_lock();

1872

rtnl_lock();

1873

switch (cmd) {

1873

switch (cmd) {

1874

case SIOCADDRT:

1874

case SIOCADDRT:

1875

err = ip6_route_add(&cfg);

1875

err = ip6_route_add(&cfg);

1876

break;

1876

break;

1877

case SIOCDELRT:

1877

case SIOCDELRT:

1878

err = ip6_route_del(&cfg);

1878

err = ip6_route_del(&cfg);

1879

break;

1879

break;

1880

default:

1880

default:

1881

err = -EINVAL;

1881

err = -EINVAL;

1882

}

1882

}

1883

rtnl_unlock();

1883

rtnl_unlock();

1884

1885

return err;

1885

return err;

1886

}

1886

}

1887

1888

return -EINVAL;

1888

return -EINVAL;

1889

}

1889

}

1890

1891

/*

1891

/*

1892

* Drop the packet on the floor

1892

* Drop the packet on the floor

1893

*/

1893

*/

1894

1895

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

1895

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

1896

{

1896

{

1897

int type;

1897

int type;

1898

struct dst_entry *dst = skb_dst(skb);

1898

struct dst_entry *dst = skb_dst(skb);

1899

switch (ipstats_mib_noroutes) {

1899

switch (ipstats_mib_noroutes) {

1900

case IPSTATS_MIB_INNOROUTES:

1900

case IPSTATS_MIB_INNOROUTES:

1901

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

1901

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

1902

if (type == IPV6_ADDR_ANY) {

1902

if (type == IPV6_ADDR_ANY) {

1903

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

1903

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

1904

IPSTATS_MIB_INADDRERRORS);

1904

IPSTATS_MIB_INADDRERRORS);

1905

break;

1905

break;

1906

}

1906

}

1907

/* FALLTHROUGH */

1907

/* FALLTHROUGH */

1908

case IPSTATS_MIB_OUTNOROUTES:

1908

case IPSTATS_MIB_OUTNOROUTES:

1909

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

1909

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

1910

ipstats_mib_noroutes);

1910

ipstats_mib_noroutes);

1911

break;

1911

break;

1912

}

1912

}

1913

icmpv6_send(skb, ICMPV6_DEST_UNREACH, code, 0);

1913

icmpv6_send(skb, ICMPV6_DEST_UNREACH, code, 0);

1914

kfree_skb(skb);

1914

kfree_skb(skb);

1915

return 0;

1915

return 0;

1916

}

1916

}

1917

1918

static int ip6_pkt_discard(struct sk_buff *skb)

1918

static int ip6_pkt_discard(struct sk_buff *skb)

1919

{

1919

{

1920

return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_INNOROUTES);

1920

return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_INNOROUTES);

1921

}

1921

}

1922

1923

static int ip6_pkt_discard_out(struct sk_buff *skb)

1923

static int ip6_pkt_discard_out(struct sk_buff *skb)

1924

{

1924

{

1925

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

1925

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

1926

return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_OUTNOROUTES);

1926

return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_OUTNOROUTES);

1927

}

1927

}

1928

1929

#ifdef CONFIG_IPV6_MULTIPLE_TABLES

1929

#ifdef CONFIG_IPV6_MULTIPLE_TABLES

1930

1931

static int ip6_pkt_prohibit(struct sk_buff *skb)

1931

static int ip6_pkt_prohibit(struct sk_buff *skb)

1932

{

1932

{

1933

return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_INNOROUTES);

1933

return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_INNOROUTES);

1934

}

1934

}

1935

1936

static int ip6_pkt_prohibit_out(struct sk_buff *skb)

1936

static int ip6_pkt_prohibit_out(struct sk_buff *skb)

1937

{

1937

{

1938

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

1938

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

1939

return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_OUTNOROUTES);

1939

return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_OUTNOROUTES);

1940

}

1940

}

1941

1942

#endif

1942

#endif

1943

1944

/*

1944

/*

1945

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

1945

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

1946

*/

1946

*/

1947

1948

struct rt6_info *addrconf_dst_alloc(struct inet6_dev *idev,

1948

struct rt6_info *addrconf_dst_alloc(struct inet6_dev *idev,

1949

const struct in6_addr *addr,

1949

const struct in6_addr *addr,

1950

int anycast)

1950

int anycast)

1951

{

1951

{

1952

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

1952

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

1953

struct rt6_info *rt = ip6_dst_alloc(&net->ipv6.ip6_dst_ops);

1953

struct rt6_info *rt = ip6_dst_alloc(&net->ipv6.ip6_dst_ops);

1954

struct neighbour *neigh;

1954

struct neighbour *neigh;

1955

1956

if (rt == NULL) {

1956

if (rt == NULL) {

1957

if (net_ratelimit())

1957

if (net_ratelimit())

1958

pr_warning("IPv6: Maximum number of routes reached,"

1958

pr_warning("IPv6: Maximum number of routes reached,"

1959

" consider increasing route/max_size.\n");

1959

" consider increasing route/max_size.\n");

1960

return ERR_PTR(-ENOMEM);

1960

return ERR_PTR(-ENOMEM);

1961

}

1961

}

1962

1963

dev_hold(net->loopback_dev);

1963

dev_hold(net->loopback_dev);

1964

in6_dev_hold(idev);

1964

in6_dev_hold(idev);

1965

1966

rt->dst.flags = DST_HOST;

1966

rt->dst.flags = DST_HOST;

1967

rt->dst.input = ip6_input;

1967

rt->dst.input = ip6_input;

1968

rt->dst.output = ip6_output;

1968

rt->dst.output = ip6_output;

1969

rt->rt6i_dev = net->loopback_dev;

1969

rt->rt6i_dev = net->loopback_dev;

1970

rt->rt6i_idev = idev;

1970

rt->rt6i_idev = idev;

1971

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

1971

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

1972

rt->dst.obsolete = -1;

1972

rt->dst.obsolete = -1;

1973

1974

rt->rt6i_flags = RTF_UP | RTF_NONEXTHOP;

1974

rt->rt6i_flags = RTF_UP | RTF_NONEXTHOP;

1975

if (anycast)

1975

if (anycast)

1976

rt->rt6i_flags |= RTF_ANYCAST;

1976

rt->rt6i_flags |= RTF_ANYCAST;

1977

else

1977

else

1978

rt->rt6i_flags |= RTF_LOCAL;

1978

rt->rt6i_flags |= RTF_LOCAL;

1979

neigh = ndisc_get_neigh(rt->rt6i_dev, &rt->rt6i_gateway);

1979

neigh = ndisc_get_neigh(rt->rt6i_dev, &rt->rt6i_gateway);

1980

if (IS_ERR(neigh)) {

1980

if (IS_ERR(neigh)) {

1981

dst_free(&rt->dst);

1981

dst_free(&rt->dst);

1982

1983

/* We are casting this because that is the return

1983

/* We are casting this because that is the return

1984

* value type. But an errno encoded pointer is the

1984

* value type. But an errno encoded pointer is the

1985

* same regardless of the underlying pointer type,

1985

* same regardless of the underlying pointer type,

1986

* and that's what we are returning. So this is OK.

1986

* and that's what we are returning. So this is OK.

1987

*/

1987

*/

1988

return (struct rt6_info *) neigh;

1988

return (struct rt6_info *) neigh;

1989

}

1989

}

1990

rt->rt6i_nexthop = neigh;

1990

rt->rt6i_nexthop = neigh;

1991

1992

ipv6_addr_copy(&rt->rt6i_dst.addr, addr);

1992

ipv6_addr_copy(&rt->rt6i_dst.addr, addr);

1993

rt->rt6i_dst.plen = 128;

1993

rt->rt6i_dst.plen = 128;

1994

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

1994

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

1995

1996

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

1996

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

1997

1998

return rt;

1998

return rt;

1999

}

1999

}

2000

2001

struct arg_dev_net {

2001

struct arg_dev_net {

2002

struct net_device *dev;

2002

struct net_device *dev;

2003

struct net *net;

2003

struct net *net;

2004

};

2004

};

2005

2006

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

2006

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

2007

{

2007

{

2008

const struct arg_dev_net *adn = arg;

2008

const struct arg_dev_net *adn = arg;

2009

const struct net_device *dev = adn->dev;

2009

const struct net_device *dev = adn->dev;

2010

2011

if ((rt->rt6i_dev == dev || dev == NULL) &&

2011

if ((rt->rt6i_dev == dev || dev == NULL) &&

2012

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

2012

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

2013

RT6_TRACE("deleted by ifdown %p\n", rt);

2013

RT6_TRACE("deleted by ifdown %p\n", rt);

2014

return -1;

2014

return -1;

2015

}

2015

}

2016

return 0;

2016

return 0;

2017

}

2017

}

2018

2019

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

2019

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

2020

{

2020

{

2021

struct arg_dev_net adn = {

2021

struct arg_dev_net adn = {

2022

.dev = dev,

2022

.dev = dev,

2023

.net = net,

2023

.net = net,

2024

};

2024

};

2025

2026

fib6_clean_all(net, fib6_ifdown, 0, &adn);

2026

fib6_clean_all(net, fib6_ifdown, 0, &adn);

2027

icmp6_clean_all(fib6_ifdown, &adn);

2027

icmp6_clean_all(fib6_ifdown, &adn);

2028

}

2028

}

2029

2030

struct rt6_mtu_change_arg

2030

struct rt6_mtu_change_arg

2031

{

2031

{

2032

struct net_device *dev;

2032

struct net_device *dev;

2033

unsigned mtu;

2033

unsigned mtu;

2034

};

2034

};

2035

2036

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

2036

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

2037

{

2037

{

2038

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

2038

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

2039

struct inet6_dev *idev;

2039

struct inet6_dev *idev;

2040

2041

/* In IPv6 pmtu discovery is not optional,

2041

/* In IPv6 pmtu discovery is not optional,

2042

so that RTAX_MTU lock cannot disable it.

2042

so that RTAX_MTU lock cannot disable it.

2043

We still use this lock to block changes

2043

We still use this lock to block changes

2044

caused by addrconf/ndisc.

2044

caused by addrconf/ndisc.

2045

*/

2045

*/

2046

2047

idev = __in6_dev_get(arg->dev);

2047

idev = __in6_dev_get(arg->dev);

2048

if (idev == NULL)

2048

if (idev == NULL)

2049

return 0;

2049

return 0;

2050

2051

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

2051

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

2052

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

2052

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

2053

Since RFC 1981 doesn't include administrative MTU increase

2053

Since RFC 1981 doesn't include administrative MTU increase

2054

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

2054

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

2055

*/

2055

*/

2056

/*

2056

/*

2057

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

2057

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

2058

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

2058

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

2059

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

2059

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

2060

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

2060

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

2061

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

2061

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

2062

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

2062

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

2063

PMTU discouvery.

2063

PMTU discouvery.

2064

*/

2064

*/

2065

if (rt->rt6i_dev == arg->dev &&

2065

if (rt->rt6i_dev == arg->dev &&

2066

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

2066

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

2067

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

2067

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

2068

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

2068

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

2069

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

2069

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

2070

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

2070

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

2071

}

2071

}

2072

return 0;

2072

return 0;

2073

}

2073

}

2074

2075

void rt6_mtu_change(struct net_device *dev, unsigned mtu)

2075

void rt6_mtu_change(struct net_device *dev, unsigned mtu)

2076

{

2076

{

2077

struct rt6_mtu_change_arg arg = {

2077

struct rt6_mtu_change_arg arg = {

2078

.dev = dev,

2078

.dev = dev,

2079

.mtu = mtu,

2079

.mtu = mtu,

2080

};

2080

};

2081

2082

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

2082

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

2083

}

2083

}

2084

2085

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

2085

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

2086

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

2086

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

2087

[RTA_OIF] = { .type = NLA_U32 },

2087

[RTA_OIF] = { .type = NLA_U32 },

2088

[RTA_IIF] = { .type = NLA_U32 },

2088

[RTA_IIF] = { .type = NLA_U32 },

2089

[RTA_PRIORITY] = { .type = NLA_U32 },

2089

[RTA_PRIORITY] = { .type = NLA_U32 },

2090

[RTA_METRICS] = { .type = NLA_NESTED },

2090

[RTA_METRICS] = { .type = NLA_NESTED },

2091

};

2091

};

2092

2093

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

2093

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

2094

struct fib6_config *cfg)

2094

struct fib6_config *cfg)

2095

{

2095

{

2096

struct rtmsg *rtm;

2096

struct rtmsg *rtm;

2097

struct nlattr *tb[RTA_MAX+1];

2097

struct nlattr *tb[RTA_MAX+1];

2098

int err;

2098

int err;

2099

2100

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

2100

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

2101

if (err < 0)

2101

if (err < 0)

2102

goto errout;

2102

goto errout;

2103

2104

err = -EINVAL;

2104

err = -EINVAL;

2105

rtm = nlmsg_data(nlh);

2105

rtm = nlmsg_data(nlh);

2106

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

2106

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

2107

2108

cfg->fc_table = rtm->rtm_table;

2108

cfg->fc_table = rtm->rtm_table;

2109

cfg->fc_dst_len = rtm->rtm_dst_len;

2109

cfg->fc_dst_len = rtm->rtm_dst_len;

2110

cfg->fc_src_len = rtm->rtm_src_len;

2110

cfg->fc_src_len = rtm->rtm_src_len;

2111

cfg->fc_flags = RTF_UP;

2111

cfg->fc_flags = RTF_UP;

2112

cfg->fc_protocol = rtm->rtm_protocol;

2112

cfg->fc_protocol = rtm->rtm_protocol;

2113

2114

if (rtm->rtm_type == RTN_UNREACHABLE)

2114

if (rtm->rtm_type == RTN_UNREACHABLE)

2115

cfg->fc_flags |= RTF_REJECT;

2115

cfg->fc_flags |= RTF_REJECT;

2116

2117

if (rtm->rtm_type == RTN_LOCAL)

2117

if (rtm->rtm_type == RTN_LOCAL)

2118

cfg->fc_flags |= RTF_LOCAL;

2118

cfg->fc_flags |= RTF_LOCAL;

2119

2120

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

2120

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

2121

cfg->fc_nlinfo.nlh = nlh;

2121

cfg->fc_nlinfo.nlh = nlh;

2122

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

2122

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

2123

2124

if (tb[RTA_GATEWAY]) {

2124

if (tb[RTA_GATEWAY]) {

2125

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

2125

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

2126

cfg->fc_flags |= RTF_GATEWAY;

2126

cfg->fc_flags |= RTF_GATEWAY;

2127

}

2127

}

2128

2129

if (tb[RTA_DST]) {

2129

if (tb[RTA_DST]) {

2130

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

2130

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

2131

2132

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

2132

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

2133

goto errout;

2133

goto errout;

2134

2135

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

2135

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

2136

}

2136

}

2137

2138

if (tb[RTA_SRC]) {

2138

if (tb[RTA_SRC]) {

2139

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

2139

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

2140

2141

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

2141

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

2142

goto errout;

2142

goto errout;

2143

2144

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

2144

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

2145

}

2145

}

2146

2147

if (tb[RTA_OIF])

2147

if (tb[RTA_OIF])

2148

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

2148

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

2149

2150

if (tb[RTA_PRIORITY])

2150

if (tb[RTA_PRIORITY])

2151

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

2151

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

2152

2153

if (tb[RTA_METRICS]) {

2153

if (tb[RTA_METRICS]) {

2154

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

2154

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

2155

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

2155

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

2156

}

2156

}

2157

2158

if (tb[RTA_TABLE])

2158

if (tb[RTA_TABLE])

2159

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

2159

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

2160

2161

err = 0;

2161

err = 0;

2162

errout:

2162

errout:

2163

return err;

2163

return err;

2164

}

2164

}

2165

2166

static int inet6_rtm_delroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)

2166

static int inet6_rtm_delroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)

2167

{

2167

{

2168

struct fib6_config cfg;

2168

struct fib6_config cfg;

2169

int err;

2169

int err;

2170

2171

err = rtm_to_fib6_config(skb, nlh, &cfg);

2171

err = rtm_to_fib6_config(skb, nlh, &cfg);

2172

if (err < 0)

2172

if (err < 0)

2173

return err;

2173

return err;

2174

2175

return ip6_route_del(&cfg);

2175

return ip6_route_del(&cfg);

2176

}

2176

}

2177

2178

static int inet6_rtm_newroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)

2178

static int inet6_rtm_newroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)

2179

{

2179

{

2180

struct fib6_config cfg;

2180

struct fib6_config cfg;

2181

int err;

2181

int err;

2182

2183

err = rtm_to_fib6_config(skb, nlh, &cfg);

2183

err = rtm_to_fib6_config(skb, nlh, &cfg);

2184

if (err < 0)

2184

if (err < 0)

2185

return err;

2185

return err;

2186

2187

return ip6_route_add(&cfg);

2187

return ip6_route_add(&cfg);

2188

}

2188

}

2189

2190

static inline size_t rt6_nlmsg_size(void)

2190

static inline size_t rt6_nlmsg_size(void)

2191

{

2191

{

2192

return NLMSG_ALIGN(sizeof(struct rtmsg))

2192

return NLMSG_ALIGN(sizeof(struct rtmsg))

2193

+ nla_total_size(16) /* RTA_SRC */

2193

+ nla_total_size(16) /* RTA_SRC */

2194

+ nla_total_size(16) /* RTA_DST */

2194

+ nla_total_size(16) /* RTA_DST */

2195

+ nla_total_size(16) /* RTA_GATEWAY */

2195

+ nla_total_size(16) /* RTA_GATEWAY */

2196

+ nla_total_size(16) /* RTA_PREFSRC */

2196

+ nla_total_size(16) /* RTA_PREFSRC */

2197

+ nla_total_size(4) /* RTA_TABLE */

2197

+ nla_total_size(4) /* RTA_TABLE */

2198

+ nla_total_size(4) /* RTA_IIF */

2198

+ nla_total_size(4) /* RTA_IIF */

2199

+ nla_total_size(4) /* RTA_OIF */

2199

+ nla_total_size(4) /* RTA_OIF */

2200

+ nla_total_size(4) /* RTA_PRIORITY */

2200

+ nla_total_size(4) /* RTA_PRIORITY */

2201

+ RTAX_MAX * nla_total_size(4) /* RTA_METRICS */

2201

+ RTAX_MAX * nla_total_size(4) /* RTA_METRICS */

2202

+ nla_total_size(sizeof(struct rta_cacheinfo));

2202

+ nla_total_size(sizeof(struct rta_cacheinfo));

2203

}

2203

}

2204

2205

static int rt6_fill_node(struct net *net,

2205

static int rt6_fill_node(struct net *net,

2206

struct sk_buff *skb, struct rt6_info *rt,

2206

struct sk_buff *skb, struct rt6_info *rt,

2207

struct in6_addr *dst, struct in6_addr *src,

2207

struct in6_addr *dst, struct in6_addr *src,

2208

int iif, int type, u32 pid, u32 seq,

2208

int iif, int type, u32 pid, u32 seq,

2209

int prefix, int nowait, unsigned int flags)

2209

int prefix, int nowait, unsigned int flags)

2210

{

2210

{

2211

struct rtmsg *rtm;

2211

struct rtmsg *rtm;

2212

struct nlmsghdr *nlh;

2212

struct nlmsghdr *nlh;

2213

long expires;

2213

long expires;

2214

u32 table;

2214

u32 table;

2215

2216

if (prefix) { /* user wants prefix routes only */

2216

if (prefix) { /* user wants prefix routes only */

2217

if (!(rt->rt6i_flags & RTF_PREFIX_RT)) {

2217

if (!(rt->rt6i_flags & RTF_PREFIX_RT)) {

2218

/* success since this is not a prefix route */

2218

/* success since this is not a prefix route */

2219

return 1;

2219

return 1;

2220

}

2220

}

2221

}

2221

}

2222

2223

nlh = nlmsg_put(skb, pid, seq, type, sizeof(*rtm), flags);

2223

nlh = nlmsg_put(skb, pid, seq, type, sizeof(*rtm), flags);

2224

if (nlh == NULL)

2224

if (nlh == NULL)

2225

return -EMSGSIZE;

2225

return -EMSGSIZE;

2226

2227

rtm = nlmsg_data(nlh);

2227

rtm = nlmsg_data(nlh);

2228

rtm->rtm_family = AF_INET6;

2228

rtm->rtm_family = AF_INET6;

2229

rtm->rtm_dst_len = rt->rt6i_dst.plen;

2229

rtm->rtm_dst_len = rt->rt6i_dst.plen;

2230

rtm->rtm_src_len = rt->rt6i_src.plen;

2230

rtm->rtm_src_len = rt->rt6i_src.plen;

2231

rtm->rtm_tos = 0;

2231

rtm->rtm_tos = 0;

2232

if (rt->rt6i_table)

2232

if (rt->rt6i_table)

2233

table = rt->rt6i_table->tb6_id;

2233

table = rt->rt6i_table->tb6_id;

2234

else

2234

else

2235

table = RT6_TABLE_UNSPEC;

2235

table = RT6_TABLE_UNSPEC;

2236

rtm->rtm_table = table;

2236

rtm->rtm_table = table;

2237

NLA_PUT_U32(skb, RTA_TABLE, table);

2237

NLA_PUT_U32(skb, RTA_TABLE, table);

2238

if (rt->rt6i_flags&RTF_REJECT)

2238

if (rt->rt6i_flags&RTF_REJECT)

2239

rtm->rtm_type = RTN_UNREACHABLE;

2239

rtm->rtm_type = RTN_UNREACHABLE;

2240

else if (rt->rt6i_flags&RTF_LOCAL)

2240

else if (rt->rt6i_flags&RTF_LOCAL)

2241

rtm->rtm_type = RTN_LOCAL;

2241

rtm->rtm_type = RTN_LOCAL;

2242

else if (rt->rt6i_dev && (rt->rt6i_dev->flags&IFF_LOOPBACK))

2242

else if (rt->rt6i_dev && (rt->rt6i_dev->flags&IFF_LOOPBACK))

2243

rtm->rtm_type = RTN_LOCAL;

2243

rtm->rtm_type = RTN_LOCAL;

2244

else

2244

else

2245

rtm->rtm_type = RTN_UNICAST;

2245

rtm->rtm_type = RTN_UNICAST;

2246

rtm->rtm_flags = 0;

2246

rtm->rtm_flags = 0;

2247

rtm->rtm_scope = RT_SCOPE_UNIVERSE;

2247

rtm->rtm_scope = RT_SCOPE_UNIVERSE;

2248

rtm->rtm_protocol = rt->rt6i_protocol;

2248

rtm->rtm_protocol = rt->rt6i_protocol;

2249

if (rt->rt6i_flags&RTF_DYNAMIC)

2249

if (rt->rt6i_flags&RTF_DYNAMIC)

2250

rtm->rtm_protocol = RTPROT_REDIRECT;

2250

rtm->rtm_protocol = RTPROT_REDIRECT;

2251

else if (rt->rt6i_flags & RTF_ADDRCONF)

2251

else if (rt->rt6i_flags & RTF_ADDRCONF)

2252

rtm->rtm_protocol = RTPROT_KERNEL;

2252

rtm->rtm_protocol = RTPROT_KERNEL;

2253

else if (rt->rt6i_flags&RTF_DEFAULT)

2253

else if (rt->rt6i_flags&RTF_DEFAULT)

2254

rtm->rtm_protocol = RTPROT_RA;

2254

rtm->rtm_protocol = RTPROT_RA;

2255

2256

if (rt->rt6i_flags&RTF_CACHE)

2256

if (rt->rt6i_flags&RTF_CACHE)

2257

rtm->rtm_flags |= RTM_F_CLONED;

2257

rtm->rtm_flags |= RTM_F_CLONED;

2258

2259

if (dst) {

2259

if (dst) {

2260

NLA_PUT(skb, RTA_DST, 16, dst);

2260

NLA_PUT(skb, RTA_DST, 16, dst);

2261

rtm->rtm_dst_len = 128;

2261

rtm->rtm_dst_len = 128;

2262

} else if (rtm->rtm_dst_len)

2262

} else if (rtm->rtm_dst_len)

2263

NLA_PUT(skb, RTA_DST, 16, &rt->rt6i_dst.addr);

2263

NLA_PUT(skb, RTA_DST, 16, &rt->rt6i_dst.addr);

2264

#ifdef CONFIG_IPV6_SUBTREES

2264

#ifdef CONFIG_IPV6_SUBTREES

2265

if (src) {

2265

if (src) {

2266

NLA_PUT(skb, RTA_SRC, 16, src);

2266

NLA_PUT(skb, RTA_SRC, 16, src);

2267

rtm->rtm_src_len = 128;

2267

rtm->rtm_src_len = 128;

2268

} else if (rtm->rtm_src_len)

2268

} else if (rtm->rtm_src_len)

2269

NLA_PUT(skb, RTA_SRC, 16, &rt->rt6i_src.addr);

2269

NLA_PUT(skb, RTA_SRC, 16, &rt->rt6i_src.addr);

2270

#endif

2270

#endif

2271

if (iif) {

2271

if (iif) {

2272

#ifdef CONFIG_IPV6_MROUTE

2272

#ifdef CONFIG_IPV6_MROUTE

2273

if (ipv6_addr_is_multicast(&rt->rt6i_dst.addr)) {

2273

if (ipv6_addr_is_multicast(&rt->rt6i_dst.addr)) {

2274

int err = ip6mr_get_route(net, skb, rtm, nowait);

2274

int err = ip6mr_get_route(net, skb, rtm, nowait);

2275

if (err <= 0) {

2275

if (err <= 0) {

2276

if (!nowait) {

2276

if (!nowait) {

2277

if (err == 0)

2277

if (err == 0)

2278

return 0;

2278

return 0;

2279

goto nla_put_failure;

2279

goto nla_put_failure;

2280

} else {

2280

} else {

2281

if (err == -EMSGSIZE)

2281

if (err == -EMSGSIZE)

2282

goto nla_put_failure;

2282

goto nla_put_failure;

2283

}

2283

}

2284

}

2284

}

2285

} else

2285

} else

2286

#endif

2286

#endif

2287

NLA_PUT_U32(skb, RTA_IIF, iif);

2287

NLA_PUT_U32(skb, RTA_IIF, iif);

2288

} else if (dst) {

2288

} else if (dst) {

2289

struct inet6_dev *idev = ip6_dst_idev(&rt->dst);

2289

struct inet6_dev *idev = ip6_dst_idev(&rt->dst);

2290

struct in6_addr saddr_buf;

2290

struct in6_addr saddr_buf;

2291

if (ipv6_dev_get_saddr(net, idev ? idev->dev : NULL,

2291

if (ipv6_dev_get_saddr(net, idev ? idev->dev : NULL,

2292

dst, 0, &saddr_buf) == 0)

2292

dst, 0, &saddr_buf) == 0)

2293

NLA_PUT(skb, RTA_PREFSRC, 16, &saddr_buf);

2293

NLA_PUT(skb, RTA_PREFSRC, 16, &saddr_buf);

2294

}

2294

}

2295

2296

if (rtnetlink_put_metrics(skb, dst_metrics_ptr(&rt->dst)) < 0)

2296

if (rtnetlink_put_metrics(skb, dst_metrics_ptr(&rt->dst)) < 0)

2297

goto nla_put_failure;

2297

goto nla_put_failure;

2298

2299

if (rt->dst.neighbour)

2299

if (rt->dst.neighbour)

2300

NLA_PUT(skb, RTA_GATEWAY, 16, &rt->dst.neighbour->primary_key);

2300

NLA_PUT(skb, RTA_GATEWAY, 16, &rt->dst.neighbour->primary_key);

2301

2302

if (rt->dst.dev)

2302

if (rt->dst.dev)

2303

NLA_PUT_U32(skb, RTA_OIF, rt->rt6i_dev->ifindex);

2303

NLA_PUT_U32(skb, RTA_OIF, rt->rt6i_dev->ifindex);

2304

2305

NLA_PUT_U32(skb, RTA_PRIORITY, rt->rt6i_metric);

2305

NLA_PUT_U32(skb, RTA_PRIORITY, rt->rt6i_metric);

2306

2307

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

2307

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

2308

expires = 0;

2308

expires = 0;

2309

else if (rt->rt6i_expires - jiffies < INT_MAX)

2309

else if (rt->rt6i_expires - jiffies < INT_MAX)

2310

expires = rt->rt6i_expires - jiffies;

2310

expires = rt->rt6i_expires - jiffies;

2311

else

2311

else

2312

expires = INT_MAX;

2312

expires = INT_MAX;

2313

2314

if (rtnl_put_cacheinfo(skb, &rt->dst, 0, 0, 0,

2314

if (rtnl_put_cacheinfo(skb, &rt->dst, 0, 0, 0,

2315

expires, rt->dst.error) < 0)

2315

expires, rt->dst.error) < 0)

2316

goto nla_put_failure;

2316

goto nla_put_failure;

2317

2318

return nlmsg_end(skb, nlh);

2318

return nlmsg_end(skb, nlh);

2319

2320

nla_put_failure:

2320

nla_put_failure:

2321

nlmsg_cancel(skb, nlh);

2321

nlmsg_cancel(skb, nlh);

2322

return -EMSGSIZE;

2322

return -EMSGSIZE;

2323

}

2323

}

2324

2325

int rt6_dump_route(struct rt6_info *rt, void *p_arg)

2325

int rt6_dump_route(struct rt6_info *rt, void *p_arg)

2326

{

2326

{

2327

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

2327

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

2328

int prefix;

2328

int prefix;

2329

2330

if (nlmsg_len(arg->cb->nlh) >= sizeof(struct rtmsg)) {

2330

if (nlmsg_len(arg->cb->nlh) >= sizeof(struct rtmsg)) {

2331

struct rtmsg *rtm = nlmsg_data(arg->cb->nlh);

2331

struct rtmsg *rtm = nlmsg_data(arg->cb->nlh);

2332

prefix = (rtm->rtm_flags & RTM_F_PREFIX) != 0;

2332

prefix = (rtm->rtm_flags & RTM_F_PREFIX) != 0;

2333

} else

2333

} else

2334

prefix = 0;

2334

prefix = 0;

2335

2336

return rt6_fill_node(arg->net,

2336

return rt6_fill_node(arg->net,

2337

arg->skb, rt, NULL, NULL, 0, RTM_NEWROUTE,

2337

arg->skb, rt, NULL, NULL, 0, RTM_NEWROUTE,

2338

NETLINK_CB(arg->cb->skb).pid, arg->cb->nlh->nlmsg_seq,

2338

NETLINK_CB(arg->cb->skb).pid, arg->cb->nlh->nlmsg_seq,

2339

prefix, 0, NLM_F_MULTI);

2339

prefix, 0, NLM_F_MULTI);

2340

}

2340

}

2341

2342

static int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr* nlh, void *arg)

2342

static int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr* nlh, void *arg)

2343

{

2343

{

2344

struct net *net = sock_net(in_skb->sk);

2344

struct net *net = sock_net(in_skb->sk);

2345

struct nlattr *tb[RTA_MAX+1];

2345

struct nlattr *tb[RTA_MAX+1];

2346

struct rt6_info *rt;

2346

struct rt6_info *rt;

2347

struct sk_buff *skb;

2347

struct sk_buff *skb;

2348

struct rtmsg *rtm;

2348

struct rtmsg *rtm;

2349

struct flowi fl;

2349

struct flowi fl;

2350

int err, iif = 0;

2350

int err, iif = 0;

2351

2352

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

2352

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

2353

if (err < 0)

2353

if (err < 0)

2354

goto errout;

2354

goto errout;

2355

2356

err = -EINVAL;

2356

err = -EINVAL;

2357

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

2357

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

2358

2359

if (tb[RTA_SRC]) {

2359

if (tb[RTA_SRC]) {

2360

if (nla_len(tb[RTA_SRC]) < sizeof(struct in6_addr))

2360

if (nla_len(tb[RTA_SRC]) < sizeof(struct in6_addr))

2361

goto errout;

2361

goto errout;

2362

2363

ipv6_addr_copy(&fl.fl6_src, nla_data(tb[RTA_SRC]));

2363

ipv6_addr_copy(&fl.fl6_src, nla_data(tb[RTA_SRC]));

2364

}

2364

}

2365

2366

if (tb[RTA_DST]) {

2366

if (tb[RTA_DST]) {

2367

if (nla_len(tb[RTA_DST]) < sizeof(struct in6_addr))

2367

if (nla_len(tb[RTA_DST]) < sizeof(struct in6_addr))

2368

goto errout;

2368

goto errout;

2369

2370

ipv6_addr_copy(&fl.fl6_dst, nla_data(tb[RTA_DST]));

2370

ipv6_addr_copy(&fl.fl6_dst, nla_data(tb[RTA_DST]));

2371

}

2371

}

2372

2373

if (tb[RTA_IIF])

2373

if (tb[RTA_IIF])

2374

iif = nla_get_u32(tb[RTA_IIF]);

2374

iif = nla_get_u32(tb[RTA_IIF]);

2375

2376

if (tb[RTA_OIF])

2376

if (tb[RTA_OIF])

2377

fl.oif = nla_get_u32(tb[RTA_OIF]);

2377

fl.oif = nla_get_u32(tb[RTA_OIF]);

2378

2379

if (iif) {

2379

if (iif) {

2380

struct net_device *dev;

2380

struct net_device *dev;

2381

dev = __dev_get_by_index(net, iif);

2381

dev = __dev_get_by_index(net, iif);

2382

if (!dev) {

2382

if (!dev) {

2383

err = -ENODEV;

2383

err = -ENODEV;

2384

goto errout;

2384

goto errout;

2385

}

2385

}

2386

}

2386

}

2387

2388

skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);

2388

skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);

2389

if (skb == NULL) {

2389

if (skb == NULL) {

2390

err = -ENOBUFS;

2390

err = -ENOBUFS;

2391

goto errout;

2391

goto errout;

2392

}

2392

}

2393

2394

/* Reserve room for dummy headers, this skb can pass

2394

/* Reserve room for dummy headers, this skb can pass

2395

through good chunk of routing engine.

2395

through good chunk of routing engine.

2396

*/

2396

*/

2397

skb_reset_mac_header(skb);

2397

skb_reset_mac_header(skb);

2398

skb_reserve(skb, MAX_HEADER + sizeof(struct ipv6hdr));

2398

skb_reserve(skb, MAX_HEADER + sizeof(struct ipv6hdr));

2399

2400

rt = (struct rt6_info*) ip6_route_output(net, NULL, &fl);

2400

rt = (struct rt6_info*) ip6_route_output(net, NULL, &fl);

2401

skb_dst_set(skb, &rt->dst);

2401

skb_dst_set(skb, &rt->dst);

2402

2403

err = rt6_fill_node(net, skb, rt, &fl.fl6_dst, &fl.fl6_src, iif,

2403

err = rt6_fill_node(net, skb, rt, &fl.fl6_dst, &fl.fl6_src, iif,

2404

RTM_NEWROUTE, NETLINK_CB(in_skb).pid,

2404

RTM_NEWROUTE, NETLINK_CB(in_skb).pid,

2405

nlh->nlmsg_seq, 0, 0, 0);

2405

nlh->nlmsg_seq, 0, 0, 0);

2406

if (err < 0) {

2406

if (err < 0) {

2407

kfree_skb(skb);

2407

kfree_skb(skb);

2408

goto errout;

2408

goto errout;

2409

}

2409

}

2410

2411

err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).pid);

2411

err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).pid);

2412

errout:

2412

errout:

2413

return err;

2413

return err;

2414

}

2414

}

2415

2416

void inet6_rt_notify(int event, struct rt6_info *rt, struct nl_info *info)

2416

void inet6_rt_notify(int event, struct rt6_info *rt, struct nl_info *info)

2417

{

2417

{

2418

struct sk_buff *skb;

2418

struct sk_buff *skb;

2419

struct net *net = info->nl_net;

2419

struct net *net = info->nl_net;

2420

u32 seq;

2420

u32 seq;

2421

int err;

2421

int err;

2422

2423

err = -ENOBUFS;

2423

err = -ENOBUFS;

2424

seq = info->nlh != NULL ? info->nlh->nlmsg_seq : 0;

2424

seq = info->nlh != NULL ? info->nlh->nlmsg_seq : 0;

2425

2426

skb = nlmsg_new(rt6_nlmsg_size(), gfp_any());

2426

skb = nlmsg_new(rt6_nlmsg_size(), gfp_any());

2427

if (skb == NULL)

2427

if (skb == NULL)

2428

goto errout;

2428

goto errout;

2429

2430

err = rt6_fill_node(net, skb, rt, NULL, NULL, 0,

2430

err = rt6_fill_node(net, skb, rt, NULL, NULL, 0,

2431

event, info->pid, seq, 0, 0, 0);

2431

event, info->pid, seq, 0, 0, 0);

2432

if (err < 0) {

2432

if (err < 0) {

2433

/* -EMSGSIZE implies BUG in rt6_nlmsg_size() */

2433

/* -EMSGSIZE implies BUG in rt6_nlmsg_size() */

2434

WARN_ON(err == -EMSGSIZE);

2434

WARN_ON(err == -EMSGSIZE);

2435

kfree_skb(skb);

2435

kfree_skb(skb);

2436

goto errout;

2436

goto errout;

2437

}

2437

}

2438

rtnl_notify(skb, net, info->pid, RTNLGRP_IPV6_ROUTE,

2438

rtnl_notify(skb, net, info->pid, RTNLGRP_IPV6_ROUTE,

2439

info->nlh, gfp_any());

2439

info->nlh, gfp_any());

2440

return;

2440

return;

2441

errout:

2441

errout:

2442

if (err < 0)

2442

if (err < 0)

2443

rtnl_set_sk_err(net, RTNLGRP_IPV6_ROUTE, err);

2443

rtnl_set_sk_err(net, RTNLGRP_IPV6_ROUTE, err);

2444

}

2444

}

2445

2446

static int ip6_route_dev_notify(struct notifier_block *this,

2446

static int ip6_route_dev_notify(struct notifier_block *this,

2447

unsigned long event, void *data)

2447

unsigned long event, void *data)

2448

{

2448

{

2449

struct net_device *dev = (struct net_device *)data;

2449

struct net_device *dev = (struct net_device *)data;

2450

struct net *net = dev_net(dev);

2450

struct net *net = dev_net(dev);

2451

2452

if (event == NETDEV_REGISTER && (dev->flags & IFF_LOOPBACK)) {

2452

if (event == NETDEV_REGISTER && (dev->flags & IFF_LOOPBACK)) {

2453

net->ipv6.ip6_null_entry->dst.dev = dev;

2453

net->ipv6.ip6_null_entry->dst.dev = dev;

2454

net->ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(dev);

2454

net->ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(dev);

2455

#ifdef CONFIG_IPV6_MULTIPLE_TABLES

2455

#ifdef CONFIG_IPV6_MULTIPLE_TABLES

2456

net->ipv6.ip6_prohibit_entry->dst.dev = dev;

2456

net->ipv6.ip6_prohibit_entry->dst.dev = dev;

2457

net->ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(dev);

2457

net->ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(dev);

2458

net->ipv6.ip6_blk_hole_entry->dst.dev = dev;

2458

net->ipv6.ip6_blk_hole_entry->dst.dev = dev;

2459

net->ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(dev);

2459

net->ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(dev);

2460

#endif

2460

#endif

2461

}

2461

}

2462

2463

return NOTIFY_OK;

2463

return NOTIFY_OK;

2464

}

2464

}

2465

2466

/*

2466

/*

2467

* /proc

2467

* /proc

2468

*/

2468

*/

2469

2470

#ifdef CONFIG_PROC_FS

2470

#ifdef CONFIG_PROC_FS

2471

2472

struct rt6_proc_arg

2472

struct rt6_proc_arg

2473

{

2473

{

2474

char *buffer;

2474

char *buffer;

2475

int offset;

2475

int offset;

2476

int length;

2476

int length;

2477

int skip;

2477

int skip;

2478

int len;

2478

int len;

2479

};

2479

};

2480

2481

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

2481

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

2482

{

2482

{

2483

struct seq_file *m = p_arg;

2483

struct seq_file *m = p_arg;

2484

2485

seq_printf(m, "%pi6 %02x ", &rt->rt6i_dst.addr, rt->rt6i_dst.plen);

2485

seq_printf(m, "%pi6 %02x ", &rt->rt6i_dst.addr, rt->rt6i_dst.plen);

2486

2487

#ifdef CONFIG_IPV6_SUBTREES

2487

#ifdef CONFIG_IPV6_SUBTREES

2488

seq_printf(m, "%pi6 %02x ", &rt->rt6i_src.addr, rt->rt6i_src.plen);

2488

seq_printf(m, "%pi6 %02x ", &rt->rt6i_src.addr, rt->rt6i_src.plen);

2489

#else

2489

#else

2490

seq_puts(m, "00000000000000000000000000000000 00 ");

2490

seq_puts(m, "00000000000000000000000000000000 00 ");

2491

#endif

2491

#endif

2492

2493

if (rt->rt6i_nexthop) {

2493

if (rt->rt6i_nexthop) {

2494

seq_printf(m, "%pi6", rt->rt6i_nexthop->primary_key);

2494

seq_printf(m, "%pi6", rt->rt6i_nexthop->primary_key);

2495

} else {

2495

} else {

2496

seq_puts(m, "00000000000000000000000000000000");

2496

seq_puts(m, "00000000000000000000000000000000");

2497

}

2497

}

2498

seq_printf(m, " %08x %08x %08x %08x %8s\n",

2498

seq_printf(m, " %08x %08x %08x %08x %8s\n",

2499

rt->rt6i_metric, atomic_read(&rt->dst.__refcnt),

2499

rt->rt6i_metric, atomic_read(&rt->dst.__refcnt),

2500

rt->dst.__use, rt->rt6i_flags,

2500

rt->dst.__use, rt->rt6i_flags,

2501

rt->rt6i_dev ? rt->rt6i_dev->name : "");

2501

rt->rt6i_dev ? rt->rt6i_dev->name : "");

2502

return 0;

2502

return 0;

2503

}

2503

}

2504

2505

static int ipv6_route_show(struct seq_file *m, void *v)

2505

static int ipv6_route_show(struct seq_file *m, void *v)

2506

{

2506

{

2507

struct net *net = (struct net *)m->private;

2507

struct net *net = (struct net *)m->private;

2508

fib6_clean_all(net, rt6_info_route, 0, m);

2508

fib6_clean_all(net, rt6_info_route, 0, m);

2509

return 0;

2509

return 0;

2510

}

2510

}

2511

2512

static int ipv6_route_open(struct inode *inode, struct file *file)

2512

static int ipv6_route_open(struct inode *inode, struct file *file)

2513

{

2513

{

2514

return single_open_net(inode, file, ipv6_route_show);

2514

return single_open_net(inode, file, ipv6_route_show);

2515

}

2515

}

2516

2517

static const struct file_operations ipv6_route_proc_fops = {

2517

static const struct file_operations ipv6_route_proc_fops = {

2518

.owner = THIS_MODULE,

2518

.owner = THIS_MODULE,

2519

.open = ipv6_route_open,

2519

.open = ipv6_route_open,

2520

.read = seq_read,

2520

.read = seq_read,

2521

.llseek = seq_lseek,

2521

.llseek = seq_lseek,

2522

.release = single_release_net,

2522

.release = single_release_net,

2523

};

2523

};

2524

2525

static int rt6_stats_seq_show(struct seq_file *seq, void *v)

2525

static int rt6_stats_seq_show(struct seq_file *seq, void *v)

2526

{

2526

{

2527

struct net *net = (struct net *)seq->private;

2527

struct net *net = (struct net *)seq->private;

2528

seq_printf(seq, "%04x %04x %04x %04x %04x %04x %04x\n",

2528

seq_printf(seq, "%04x %04x %04x %04x %04x %04x %04x\n",

2529

net->ipv6.rt6_stats->fib_nodes,

2529

net->ipv6.rt6_stats->fib_nodes,

2530

net->ipv6.rt6_stats->fib_route_nodes,

2530

net->ipv6.rt6_stats->fib_route_nodes,

2531

net->ipv6.rt6_stats->fib_rt_alloc,

2531

net->ipv6.rt6_stats->fib_rt_alloc,

2532

net->ipv6.rt6_stats->fib_rt_entries,

2532

net->ipv6.rt6_stats->fib_rt_entries,

2533

net->ipv6.rt6_stats->fib_rt_cache,

2533

net->ipv6.rt6_stats->fib_rt_cache,

2534

dst_entries_get_slow(&net->ipv6.ip6_dst_ops),

2534

dst_entries_get_slow(&net->ipv6.ip6_dst_ops),

2535

net->ipv6.rt6_stats->fib_discarded_routes);

2535

net->ipv6.rt6_stats->fib_discarded_routes);

2536

2537

return 0;

2537

return 0;

2538

}

2538

}

2539

2540

static int rt6_stats_seq_open(struct inode *inode, struct file *file)

2540

static int rt6_stats_seq_open(struct inode *inode, struct file *file)

2541

{

2541

{

2542

return single_open_net(inode, file, rt6_stats_seq_show);

2542

return single_open_net(inode, file, rt6_stats_seq_show);

2543

}

2543

}

2544

2545

static const struct file_operations rt6_stats_seq_fops = {

2545

static const struct file_operations rt6_stats_seq_fops = {

2546

.owner = THIS_MODULE,

2546

.owner = THIS_MODULE,

2547

.open = rt6_stats_seq_open,

2547

.open = rt6_stats_seq_open,

2548

.read = seq_read,

2548

.read = seq_read,

2549

.llseek = seq_lseek,

2549

.llseek = seq_lseek,

2550

.release = single_release_net,

2550

.release = single_release_net,

2551

};

2551

};

2552

#endif /* CONFIG_PROC_FS */

2552

#endif /* CONFIG_PROC_FS */

2553

2554

#ifdef CONFIG_SYSCTL

2554

#ifdef CONFIG_SYSCTL

2555

2556

static

2556

static

2557

int ipv6_sysctl_rtcache_flush(ctl_table *ctl, int write,

2557

int ipv6_sysctl_rtcache_flush(ctl_table *ctl, int write,

2558

void __user *buffer, size_t *lenp, loff_t *ppos)

2558

void __user *buffer, size_t *lenp, loff_t *ppos)

2559

{

2559

{

2560

struct net *net = current->nsproxy->net_ns;

2560

struct net *net;

2561

int delay = net->ipv6.sysctl.flush_delay;

2561

int delay;

2562

if (write) {

2562

if (!write)

2563

proc_dointvec(ctl, write, buffer, lenp, ppos);

2564

fib6_run_gc(delay <= 0 ? ~0UL : (unsigned long)delay, net);

2565

return 0;

2566

} else

2567

return -EINVAL;

2563

return -EINVAL;

2564

2565

net = (struct net *)ctl->extra1;

2566

delay = net->ipv6.sysctl.flush_delay;

2567

proc_dointvec(ctl, write, buffer, lenp, ppos);

2568

fib6_run_gc(delay <= 0 ? ~0UL : (unsigned long)delay, net);

2569

return 0;

2568

}

2570

}

2569

2571

2570

ctl_table ipv6_route_table_template[] = {

2572

ctl_table ipv6_route_table_template[] = {

2571

{

2573

{

2572

.procname = "flush",

2574

.procname = "flush",

2573

.data = &init_net.ipv6.sysctl.flush_delay,

2575

.data = &init_net.ipv6.sysctl.flush_delay,

2574

.maxlen = sizeof(int),

2576

.maxlen = sizeof(int),

2575

.mode = 0200,

2577

.mode = 0200,

2576

.proc_handler = ipv6_sysctl_rtcache_flush

2578

.proc_handler = ipv6_sysctl_rtcache_flush

2577

},

2579

},

2578

{

2580

{

2579

.procname = "gc_thresh",

2581

.procname = "gc_thresh",

2580

.data = &ip6_dst_ops_template.gc_thresh,

2582

.data = &ip6_dst_ops_template.gc_thresh,

2581

.maxlen = sizeof(int),

2583

.maxlen = sizeof(int),

2582

.mode = 0644,

2584

.mode = 0644,

2583

.proc_handler = proc_dointvec,

2585

.proc_handler = proc_dointvec,

2584

},

2586

},

2585

{

2587

{

2586

.procname = "max_size",

2588

.procname = "max_size",

2587

.data = &init_net.ipv6.sysctl.ip6_rt_max_size,

2589

.data = &init_net.ipv6.sysctl.ip6_rt_max_size,

2588

.maxlen = sizeof(int),

2590

.maxlen = sizeof(int),

2589

.mode = 0644,

2591

.mode = 0644,

2590

.proc_handler = proc_dointvec,

2592

.proc_handler = proc_dointvec,

2591

},

2593

},

2592

{

2594

{

2593

.procname = "gc_min_interval",

2595

.procname = "gc_min_interval",

2594

.data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,

2596

.data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,

2595

.maxlen = sizeof(int),

2597

.maxlen = sizeof(int),

2596

.mode = 0644,

2598

.mode = 0644,

2597

.proc_handler = proc_dointvec_jiffies,

2599

.proc_handler = proc_dointvec_jiffies,

2598

},

2600

},

2599

{

2601

{

2600

.procname = "gc_timeout",

2602

.procname = "gc_timeout",

2601

.data = &init_net.ipv6.sysctl.ip6_rt_gc_timeout,

2603

.data = &init_net.ipv6.sysctl.ip6_rt_gc_timeout,

2602

.maxlen = sizeof(int),

2604

.maxlen = sizeof(int),

2603

.mode = 0644,

2605

.mode = 0644,

2604

.proc_handler = proc_dointvec_jiffies,

2606

.proc_handler = proc_dointvec_jiffies,

2605

},

2607

},

2606

{

2608

{

2607

.procname = "gc_interval",

2609

.procname = "gc_interval",

2608

.data = &init_net.ipv6.sysctl.ip6_rt_gc_interval,

2610

.data = &init_net.ipv6.sysctl.ip6_rt_gc_interval,

2609

.maxlen = sizeof(int),

2611

.maxlen = sizeof(int),

2610

.mode = 0644,

2612

.mode = 0644,

2611

.proc_handler = proc_dointvec_jiffies,

2613

.proc_handler = proc_dointvec_jiffies,

2612

},

2614

},

2613

{

2615

{

2614

.procname = "gc_elasticity",

2616

.procname = "gc_elasticity",

2615

.data = &init_net.ipv6.sysctl.ip6_rt_gc_elasticity,

2617

.data = &init_net.ipv6.sysctl.ip6_rt_gc_elasticity,

2616

.maxlen = sizeof(int),

2618

.maxlen = sizeof(int),

2617

.mode = 0644,

2619

.mode = 0644,

2618

.proc_handler = proc_dointvec,

2620

.proc_handler = proc_dointvec,

2619

},

2621

},

2620

{

2622

{

2621

.procname = "mtu_expires",

2623

.procname = "mtu_expires",

2622

.data = &init_net.ipv6.sysctl.ip6_rt_mtu_expires,

2624

.data = &init_net.ipv6.sysctl.ip6_rt_mtu_expires,

2623

.maxlen = sizeof(int),

2625

.maxlen = sizeof(int),

2624

.mode = 0644,

2626

.mode = 0644,

2625

.proc_handler = proc_dointvec_jiffies,

2627

.proc_handler = proc_dointvec_jiffies,

2626

},

2628

},

2627

{

2629

{

2628

.procname = "min_adv_mss",

2630

.procname = "min_adv_mss",

2629

.data = &init_net.ipv6.sysctl.ip6_rt_min_advmss,

2631

.data = &init_net.ipv6.sysctl.ip6_rt_min_advmss,

2630

.maxlen = sizeof(int),

2632

.maxlen = sizeof(int),

2631

.mode = 0644,

2633

.mode = 0644,

2632

.proc_handler = proc_dointvec,

2634

.proc_handler = proc_dointvec,

2633

},

2635

},

2634

{

2636

{

2635

.procname = "gc_min_interval_ms",

2637

.procname = "gc_min_interval_ms",

2636

.data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,

2638

.data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,

2637

.maxlen = sizeof(int),

2639

.maxlen = sizeof(int),

2638

.mode = 0644,

2640

.mode = 0644,

2639

.proc_handler = proc_dointvec_ms_jiffies,

2641

.proc_handler = proc_dointvec_ms_jiffies,

2640

},

2642

},

2641

{ }

2643

{ }

2642

};

2644

};

2643

2645

2644

struct ctl_table * __net_init ipv6_route_sysctl_init(struct net *net)

2646

struct ctl_table * __net_init ipv6_route_sysctl_init(struct net *net)

2645

{

2647

{

2646

struct ctl_table *table;

2648

struct ctl_table *table;

2647

2649

2648

table = kmemdup(ipv6_route_table_template,

2650

table = kmemdup(ipv6_route_table_template,

2649

sizeof(ipv6_route_table_template),

2651

sizeof(ipv6_route_table_template),

2650

GFP_KERNEL);

2652

GFP_KERNEL);

2651

2653

2652

if (table) {

2654

if (table) {

2653

table[0].data = &net->ipv6.sysctl.flush_delay;

2655

table[0].data = &net->ipv6.sysctl.flush_delay;

2656

table[0].extra1 = net;

2654

table[1].data = &net->ipv6.ip6_dst_ops.gc_thresh;

2657

table[1].data = &net->ipv6.ip6_dst_ops.gc_thresh;

2655

table[2].data = &net->ipv6.sysctl.ip6_rt_max_size;

2658

table[2].data = &net->ipv6.sysctl.ip6_rt_max_size;

2656

table[3].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;

2659

table[3].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;

2657

table[4].data = &net->ipv6.sysctl.ip6_rt_gc_timeout;

2660

table[4].data = &net->ipv6.sysctl.ip6_rt_gc_timeout;

2658

table[5].data = &net->ipv6.sysctl.ip6_rt_gc_interval;

2661

table[5].data = &net->ipv6.sysctl.ip6_rt_gc_interval;

2659

table[6].data = &net->ipv6.sysctl.ip6_rt_gc_elasticity;

2662

table[6].data = &net->ipv6.sysctl.ip6_rt_gc_elasticity;

2660

table[7].data = &net->ipv6.sysctl.ip6_rt_mtu_expires;

2663

table[7].data = &net->ipv6.sysctl.ip6_rt_mtu_expires;

2661

table[8].data = &net->ipv6.sysctl.ip6_rt_min_advmss;

2664

table[8].data = &net->ipv6.sysctl.ip6_rt_min_advmss;

2662

table[9].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;

2665

table[9].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;

2663

}

2666

}

2664

2667

2665

return table;

2668

return table;

2666

}

2669

}

2667

#endif

2670

#endif

2668

2671

2669

static int __net_init ip6_route_net_init(struct net *net)

2672

static int __net_init ip6_route_net_init(struct net *net)

2670

{

2673

{

2671

int ret = -ENOMEM;

2674

int ret = -ENOMEM;

2672

2675

2673

memcpy(&net->ipv6.ip6_dst_ops, &ip6_dst_ops_template,

2676

memcpy(&net->ipv6.ip6_dst_ops, &ip6_dst_ops_template,

2674

sizeof(net->ipv6.ip6_dst_ops));

2677

sizeof(net->ipv6.ip6_dst_ops));

2675

2678

2676

if (dst_entries_init(&net->ipv6.ip6_dst_ops) < 0)

2679

if (dst_entries_init(&net->ipv6.ip6_dst_ops) < 0)

2677

goto out_ip6_dst_ops;

2680

goto out_ip6_dst_ops;

2678

2681

2679

net->ipv6.ip6_null_entry = kmemdup(&ip6_null_entry_template,

2682

net->ipv6.ip6_null_entry = kmemdup(&ip6_null_entry_template,

2680

sizeof(*net->ipv6.ip6_null_entry),

2683

sizeof(*net->ipv6.ip6_null_entry),

2681

GFP_KERNEL);

2684

GFP_KERNEL);

2682

if (!net->ipv6.ip6_null_entry)

2685

if (!net->ipv6.ip6_null_entry)

2683

goto out_ip6_dst_entries;

2686

goto out_ip6_dst_entries;

2684

net->ipv6.ip6_null_entry->dst.path =

2687

net->ipv6.ip6_null_entry->dst.path =

2685

(struct dst_entry *)net->ipv6.ip6_null_entry;

2688

(struct dst_entry *)net->ipv6.ip6_null_entry;

2686

net->ipv6.ip6_null_entry->dst.ops = &net->ipv6.ip6_dst_ops;

2689

net->ipv6.ip6_null_entry->dst.ops = &net->ipv6.ip6_dst_ops;

2687

dst_metric_set(&net->ipv6.ip6_null_entry->dst, RTAX_HOPLIMIT, 255);

2690

dst_metric_set(&net->ipv6.ip6_null_entry->dst, RTAX_HOPLIMIT, 255);

2688

2691

2689

#ifdef CONFIG_IPV6_MULTIPLE_TABLES

2692

#ifdef CONFIG_IPV6_MULTIPLE_TABLES

2690

net->ipv6.ip6_prohibit_entry = kmemdup(&ip6_prohibit_entry_template,

2693

net->ipv6.ip6_prohibit_entry = kmemdup(&ip6_prohibit_entry_template,

2691

sizeof(*net->ipv6.ip6_prohibit_entry),

2694

sizeof(*net->ipv6.ip6_prohibit_entry),

2692

GFP_KERNEL);

2695

GFP_KERNEL);

2693

if (!net->ipv6.ip6_prohibit_entry)

2696

if (!net->ipv6.ip6_prohibit_entry)

2694

goto out_ip6_null_entry;

2697

goto out_ip6_null_entry;

2695

net->ipv6.ip6_prohibit_entry->dst.path =

2698

net->ipv6.ip6_prohibit_entry->dst.path =

2696

(struct dst_entry *)net->ipv6.ip6_prohibit_entry;

2699

(struct dst_entry *)net->ipv6.ip6_prohibit_entry;

2697

net->ipv6.ip6_prohibit_entry->dst.ops = &net->ipv6.ip6_dst_ops;

2700

net->ipv6.ip6_prohibit_entry->dst.ops = &net->ipv6.ip6_dst_ops;

2698

dst_metric_set(&net->ipv6.ip6_prohibit_entry->dst, RTAX_HOPLIMIT, 255);

2701

dst_metric_set(&net->ipv6.ip6_prohibit_entry->dst, RTAX_HOPLIMIT, 255);

2699

2702

2700

net->ipv6.ip6_blk_hole_entry = kmemdup(&ip6_blk_hole_entry_template,

2703

net->ipv6.ip6_blk_hole_entry = kmemdup(&ip6_blk_hole_entry_template,

2701

sizeof(*net->ipv6.ip6_blk_hole_entry),

2704

sizeof(*net->ipv6.ip6_blk_hole_entry),

2702

GFP_KERNEL);

2705

GFP_KERNEL);

2703

if (!net->ipv6.ip6_blk_hole_entry)

2706

if (!net->ipv6.ip6_blk_hole_entry)

2704

goto out_ip6_prohibit_entry;

2707

goto out_ip6_prohibit_entry;

2705

net->ipv6.ip6_blk_hole_entry->dst.path =

2708

net->ipv6.ip6_blk_hole_entry->dst.path =

2706

(struct dst_entry *)net->ipv6.ip6_blk_hole_entry;

2709

(struct dst_entry *)net->ipv6.ip6_blk_hole_entry;

2707

net->ipv6.ip6_blk_hole_entry->dst.ops = &net->ipv6.ip6_dst_ops;

2710

net->ipv6.ip6_blk_hole_entry->dst.ops = &net->ipv6.ip6_dst_ops;

2708

dst_metric_set(&net->ipv6.ip6_blk_hole_entry->dst, RTAX_HOPLIMIT, 255);

2711

dst_metric_set(&net->ipv6.ip6_blk_hole_entry->dst, RTAX_HOPLIMIT, 255);

2709

#endif

2712

#endif

2710

2713

2711

net->ipv6.sysctl.flush_delay = 0;

2714

net->ipv6.sysctl.flush_delay = 0;

2712

net->ipv6.sysctl.ip6_rt_max_size = 4096;

2715

net->ipv6.sysctl.ip6_rt_max_size = 4096;

2713

net->ipv6.sysctl.ip6_rt_gc_min_interval = HZ / 2;

2716

net->ipv6.sysctl.ip6_rt_gc_min_interval = HZ / 2;

2714

net->ipv6.sysctl.ip6_rt_gc_timeout = 60*HZ;

2717

net->ipv6.sysctl.ip6_rt_gc_timeout = 60*HZ;

2715

net->ipv6.sysctl.ip6_rt_gc_interval = 30*HZ;

2718

net->ipv6.sysctl.ip6_rt_gc_interval = 30*HZ;

2716

net->ipv6.sysctl.ip6_rt_gc_elasticity = 9;

2719

net->ipv6.sysctl.ip6_rt_gc_elasticity = 9;

2717

net->ipv6.sysctl.ip6_rt_mtu_expires = 10*60*HZ;

2720

net->ipv6.sysctl.ip6_rt_mtu_expires = 10*60*HZ;

2718

net->ipv6.sysctl.ip6_rt_min_advmss = IPV6_MIN_MTU - 20 - 40;

2721

net->ipv6.sysctl.ip6_rt_min_advmss = IPV6_MIN_MTU - 20 - 40;

2719

2722

2720

#ifdef CONFIG_PROC_FS

2723

#ifdef CONFIG_PROC_FS

2721

proc_net_fops_create(net, "ipv6_route", 0, &ipv6_route_proc_fops);

2724

proc_net_fops_create(net, "ipv6_route", 0, &ipv6_route_proc_fops);

2722

proc_net_fops_create(net, "rt6_stats", S_IRUGO, &rt6_stats_seq_fops);

2725

proc_net_fops_create(net, "rt6_stats", S_IRUGO, &rt6_stats_seq_fops);

2723

#endif

2726

#endif

2724

net->ipv6.ip6_rt_gc_expire = 30*HZ;

2727

net->ipv6.ip6_rt_gc_expire = 30*HZ;

2725

2728

2726

ret = 0;

2729

ret = 0;

2727

out:

2730

out:

2728

return ret;

2731

return ret;

2729

2732

2730

#ifdef CONFIG_IPV6_MULTIPLE_TABLES

2733

#ifdef CONFIG_IPV6_MULTIPLE_TABLES

2731

out_ip6_prohibit_entry:

2734

out_ip6_prohibit_entry:

2732

kfree(net->ipv6.ip6_prohibit_entry);

2735

kfree(net->ipv6.ip6_prohibit_entry);

2733

out_ip6_null_entry:

2736

out_ip6_null_entry:

2734

kfree(net->ipv6.ip6_null_entry);

2737

kfree(net->ipv6.ip6_null_entry);

2735

#endif

2738

#endif

2736

out_ip6_dst_entries:

2739

out_ip6_dst_entries:

2737

dst_entries_destroy(&net->ipv6.ip6_dst_ops);

2740

dst_entries_destroy(&net->ipv6.ip6_dst_ops);

2738

out_ip6_dst_ops:

2741

out_ip6_dst_ops:

2739

goto out;

2742

goto out;

2740

}

2743

}

2741

2744

2742

static void __net_exit ip6_route_net_exit(struct net *net)

2745

static void __net_exit ip6_route_net_exit(struct net *net)

2743

{

2746

{

2744

#ifdef CONFIG_PROC_FS

2747

#ifdef CONFIG_PROC_FS

2745

proc_net_remove(net, "ipv6_route");

2748

proc_net_remove(net, "ipv6_route");

2746

proc_net_remove(net, "rt6_stats");

2749

proc_net_remove(net, "rt6_stats");

2747

#endif

2750

#endif

2748

kfree(net->ipv6.ip6_null_entry);

2751

kfree(net->ipv6.ip6_null_entry);

2749

#ifdef CONFIG_IPV6_MULTIPLE_TABLES

2752

#ifdef CONFIG_IPV6_MULTIPLE_TABLES

2750

kfree(net->ipv6.ip6_prohibit_entry);

2753

kfree(net->ipv6.ip6_prohibit_entry);

2751

kfree(net->ipv6.ip6_blk_hole_entry);

2754

kfree(net->ipv6.ip6_blk_hole_entry);

2752

#endif

2755

#endif

2753

dst_entries_destroy(&net->ipv6.ip6_dst_ops);

2756

dst_entries_destroy(&net->ipv6.ip6_dst_ops);

2754

}

2757

}

2755

2758

2756

static struct pernet_operations ip6_route_net_ops = {

2759

static struct pernet_operations ip6_route_net_ops = {

2757

.init = ip6_route_net_init,

2760

.init = ip6_route_net_init,

2758

.exit = ip6_route_net_exit,

2761

.exit = ip6_route_net_exit,

2759

};

2762

};

2760

2763

2761

static struct notifier_block ip6_route_dev_notifier = {

2764

static struct notifier_block ip6_route_dev_notifier = {

2762

.notifier_call = ip6_route_dev_notify,

2765

.notifier_call = ip6_route_dev_notify,

2763

.priority = 0,

2766

.priority = 0,

2764

};

2767

};

2765

2768

2766

int __init ip6_route_init(void)

2769

int __init ip6_route_init(void)

2767

{

2770

{

2768

int ret;

2771

int ret;

2769

2772

2770

ret = -ENOMEM;

2773

ret = -ENOMEM;

2771

ip6_dst_ops_template.kmem_cachep =

2774

ip6_dst_ops_template.kmem_cachep =

2772

kmem_cache_create("ip6_dst_cache", sizeof(struct rt6_info), 0,

2775

kmem_cache_create("ip6_dst_cache", sizeof(struct rt6_info), 0,

2773

SLAB_HWCACHE_ALIGN, NULL);

2776

SLAB_HWCACHE_ALIGN, NULL);

2774

if (!ip6_dst_ops_template.kmem_cachep)

2777

if (!ip6_dst_ops_template.kmem_cachep)

2775

goto out;

2778

goto out;

2776

2779

2777

ret = dst_entries_init(&ip6_dst_blackhole_ops);

2780

ret = dst_entries_init(&ip6_dst_blackhole_ops);

2778

if (ret)

2781

if (ret)

2779

goto out_kmem_cache;

2782

goto out_kmem_cache;

2780

2783

2781

ret = register_pernet_subsys(&ip6_route_net_ops);

2784

ret = register_pernet_subsys(&ip6_route_net_ops);

2782

if (ret)

2785

if (ret)

2783

goto out_dst_entries;

2786

goto out_dst_entries;

2784

2787

2785

ip6_dst_blackhole_ops.kmem_cachep = ip6_dst_ops_template.kmem_cachep;

2788

ip6_dst_blackhole_ops.kmem_cachep = ip6_dst_ops_template.kmem_cachep;

2786

2789

2787

/* Registering of the loopback is done before this portion of code,

2790

/* Registering of the loopback is done before this portion of code,

2788

* the loopback reference in rt6_info will not be taken, do it

2791

* the loopback reference in rt6_info will not be taken, do it

2789

* manually for init_net */

2792

* manually for init_net */

2790

init_net.ipv6.ip6_null_entry->dst.dev = init_net.loopback_dev;

2793

init_net.ipv6.ip6_null_entry->dst.dev = init_net.loopback_dev;

2791

init_net.ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);

2794

init_net.ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);

2792

#ifdef CONFIG_IPV6_MULTIPLE_TABLES

2795

#ifdef CONFIG_IPV6_MULTIPLE_TABLES

2793

init_net.ipv6.ip6_prohibit_entry->dst.dev = init_net.loopback_dev;

2796

init_net.ipv6.ip6_prohibit_entry->dst.dev = init_net.loopback_dev;

2794

init_net.ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);

2797

init_net.ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);

2795

init_net.ipv6.ip6_blk_hole_entry->dst.dev = init_net.loopback_dev;

2798

init_net.ipv6.ip6_blk_hole_entry->dst.dev = init_net.loopback_dev;

2796

init_net.ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);

2799

init_net.ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);

2797

#endif

2800

#endif

2798

ret = fib6_init();

2801

ret = fib6_init();

2799

if (ret)

2802

if (ret)

2800

goto out_register_subsys;

2803

goto out_register_subsys;

2801

2804

2802

ret = xfrm6_init();

2805

ret = xfrm6_init();

2803

if (ret)

2806

if (ret)

2804

goto out_fib6_init;

2807

goto out_fib6_init;

2805

2808

2806

ret = fib6_rules_init();

2809

ret = fib6_rules_init();

2807

if (ret)

2810

if (ret)

2808

goto xfrm6_init;

2811

goto xfrm6_init;

2809

2812

2810

ret = -ENOBUFS;

2813

ret = -ENOBUFS;

2811

if (__rtnl_register(PF_INET6, RTM_NEWROUTE, inet6_rtm_newroute, NULL) ||

2814

if (__rtnl_register(PF_INET6, RTM_NEWROUTE, inet6_rtm_newroute, NULL) ||

2812

__rtnl_register(PF_INET6, RTM_DELROUTE, inet6_rtm_delroute, NULL) ||

2815

__rtnl_register(PF_INET6, RTM_DELROUTE, inet6_rtm_delroute, NULL) ||

2813

__rtnl_register(PF_INET6, RTM_GETROUTE, inet6_rtm_getroute, NULL))

2816

__rtnl_register(PF_INET6, RTM_GETROUTE, inet6_rtm_getroute, NULL))

2814

goto fib6_rules_init;

2817

goto fib6_rules_init;

2815

2818

2816

ret = register_netdevice_notifier(&ip6_route_dev_notifier);

2819

ret = register_netdevice_notifier(&ip6_route_dev_notifier);

2817

if (ret)

2820

if (ret)

2818

goto fib6_rules_init;

2821

goto fib6_rules_init;

2819

2822

2820

out:

2823

out:

2821

return ret;

2824

return ret;

2822

2825

2823

fib6_rules_init:

2826

fib6_rules_init:

2824

fib6_rules_cleanup();

2827

fib6_rules_cleanup();

2825

xfrm6_init:

2828

xfrm6_init:

2826

xfrm6_fini();

2829

xfrm6_fini();

2827

out_fib6_init:

2830

out_fib6_init:

2828

fib6_gc_cleanup();

2831

fib6_gc_cleanup();

2829

out_register_subsys:

2832

out_register_subsys:

2830

unregister_pernet_subsys(&ip6_route_net_ops);

2833

unregister_pernet_subsys(&ip6_route_net_ops);

2831

out_dst_entries:

2834

out_dst_entries:

2832

dst_entries_destroy(&ip6_dst_blackhole_ops);

2835

dst_entries_destroy(&ip6_dst_blackhole_ops);

2833

out_kmem_cache:

2836

out_kmem_cache:

2834

kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);

2837

kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);

2835

goto out;

2838

goto out;

2836

}

2839

}

2837

2840

2838

void ip6_route_cleanup(void)

2841

void ip6_route_cleanup(void)

2839

{

2842

{

2840

unregister_netdevice_notifier(&ip6_route_dev_notifier);

2843

unregister_netdevice_notifier(&ip6_route_dev_notifier);

2841

fib6_rules_cleanup();

2844

fib6_rules_cleanup();

2842

xfrm6_fini();

2845

xfrm6_fini();

2843

fib6_gc_cleanup();

2846

fib6_gc_cleanup();

2844

unregister_pernet_subsys(&ip6_route_net_ops);

2847

unregister_pernet_subsys(&ip6_route_net_ops);

GITLAB

sysctl: ipv6: use correct net in ipv6_sysctl_rtcache_flush

 /*
  *	Linux INET6 implementation
  *	FIB front-end.
  *
  *	Authors:
  *	Pedro Roque		<roque@di.fc.ul.pt>
  *
  *	This program is free software; you can redistribute it and/or
  *      modify it under the terms of the GNU General Public License
  *      as published by the Free Software Foundation; either version
  *      2 of the License, or (at your option) any later version.
  */
 /*	Changes:
  *
  *	YOSHIFUJI Hideaki @USAGI
  *		reworked default router selection.
  *		- respect outgoing interface
  *		- select from (probably) reachable routers (i.e.
  *		routers in REACHABLE, STALE, DELAY or PROBE states).
  *		- always select the same router if it is (probably)
  *		reachable.  otherwise, round-robin the list.
  *	Ville Nuorvala
  *		Fixed routing subtrees.
  */
 #include <linux/capability.h>
 #include <linux/errno.h>
 #include <linux/types.h>
 #include <linux/times.h>
 #include <linux/socket.h>
 #include <linux/sockios.h>
 #include <linux/net.h>
 #include <linux/route.h>
 #include <linux/netdevice.h>
 #include <linux/in6.h>
 #include <linux/mroute6.h>
 #include <linux/init.h>
 #include <linux/if_arp.h>
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
 #include <linux/nsproxy.h>
 #include <linux/slab.h>
 #include <net/net_namespace.h>
 #include <net/snmp.h>
 #include <net/ipv6.h>
 #include <net/ip6_fib.h>
 #include <net/ip6_route.h>
 #include <net/ndisc.h>
 #include <net/addrconf.h>
 #include <net/tcp.h>
 #include <linux/rtnetlink.h>
 #include <net/dst.h>
 #include <net/xfrm.h>
 #include <net/netevent.h>
 #include <net/netlink.h>
 #include <asm/uaccess.h>
 #ifdef CONFIG_SYSCTL
 #include <linux/sysctl.h>
 #endif
 /* Set to 3 to get tracing. */
 #define RT6_DEBUG 2
 #if RT6_DEBUG >= 3
 #define RDBG(x) printk x
 #define RT6_TRACE(x...) printk(KERN_DEBUG x)
 #else
 #define RDBG(x)
 #define RT6_TRACE(x...) do { ; } while (0)
 #endif
 static struct rt6_info * ip6_rt_copy(struct rt6_info *ort);
 static struct dst_entry	*ip6_dst_check(struct dst_entry *dst, u32 cookie);
 static unsigned int	 ip6_default_advmss(const struct dst_entry *dst);
 static unsigned int	 ip6_default_mtu(const struct dst_entry *dst);
 static struct dst_entry *ip6_negative_advice(struct dst_entry *);
 static void		ip6_dst_destroy(struct dst_entry *);
 static void		ip6_dst_ifdown(struct dst_entry *,
 				       struct net_device *dev, int how);
 static int		 ip6_dst_gc(struct dst_ops *ops);
 static int		ip6_pkt_discard(struct sk_buff *skb);
 static int		ip6_pkt_discard_out(struct sk_buff *skb);
 static void		ip6_link_failure(struct sk_buff *skb);
 static void		ip6_rt_update_pmtu(struct dst_entry *dst, u32 mtu);
 #ifdef CONFIG_IPV6_ROUTE_INFO
 static struct rt6_info *rt6_add_route_info(struct net *net,
 					   struct in6_addr *prefix, int prefixlen,
 					   struct in6_addr *gwaddr, int ifindex,
 					   unsigned pref);
 static struct rt6_info *rt6_get_route_info(struct net *net,
 					   struct in6_addr *prefix, int prefixlen,
 					   struct in6_addr *gwaddr, int ifindex);
 #endif
 static struct dst_ops ip6_dst_ops_template = {
 	.family			=	AF_INET6,
 	.protocol		=	cpu_to_be16(ETH_P_IPV6),
 	.gc			=	ip6_dst_gc,
 	.gc_thresh		=	1024,
 	.check			=	ip6_dst_check,
 	.default_advmss		=	ip6_default_advmss,
 	.default_mtu		=	ip6_default_mtu,
 	.destroy		=	ip6_dst_destroy,
 	.ifdown			=	ip6_dst_ifdown,
 	.negative_advice	=	ip6_negative_advice,
 	.link_failure		=	ip6_link_failure,
 	.update_pmtu		=	ip6_rt_update_pmtu,
 	.local_out		=	__ip6_local_out,
 };
 static unsigned int ip6_blackhole_default_mtu(const struct dst_entry *dst)
 {
 	return 0;
 }
 static void ip6_rt_blackhole_update_pmtu(struct dst_entry *dst, u32 mtu)
 {
 }
 static struct dst_ops ip6_dst_blackhole_ops = {
 	.family			=	AF_INET6,
 	.protocol		=	cpu_to_be16(ETH_P_IPV6),
 	.destroy		=	ip6_dst_destroy,
 	.check			=	ip6_dst_check,
 	.default_mtu		=	ip6_blackhole_default_mtu,
 	.default_advmss		=	ip6_default_advmss,
 	.update_pmtu		=	ip6_rt_blackhole_update_pmtu,
 };
 static struct rt6_info ip6_null_entry_template = {
 	.dst = {
 		.__refcnt	= ATOMIC_INIT(1),
 		.__use		= 1,
 		.obsolete	= -1,
 		.error		= -ENETUNREACH,
 		.input		= ip6_pkt_discard,
 		.output		= ip6_pkt_discard_out,
 	},
 	.rt6i_flags	= (RTF_REJECT | RTF_NONEXTHOP),
 	.rt6i_protocol  = RTPROT_KERNEL,
 	.rt6i_metric	= ~(u32) 0,
 	.rt6i_ref	= ATOMIC_INIT(1),
 };
 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
 static int ip6_pkt_prohibit(struct sk_buff *skb);
 static int ip6_pkt_prohibit_out(struct sk_buff *skb);
 static struct rt6_info ip6_prohibit_entry_template = {
 	.dst = {
 		.__refcnt	= ATOMIC_INIT(1),
 		.__use		= 1,
 		.obsolete	= -1,
 		.error		= -EACCES,
 		.input		= ip6_pkt_prohibit,
 		.output		= ip6_pkt_prohibit_out,
 	},
 	.rt6i_flags	= (RTF_REJECT | RTF_NONEXTHOP),
 	.rt6i_protocol  = RTPROT_KERNEL,
 	.rt6i_metric	= ~(u32) 0,
 	.rt6i_ref	= ATOMIC_INIT(1),
 };
 static struct rt6_info ip6_blk_hole_entry_template = {
 	.dst = {
 		.__refcnt	= ATOMIC_INIT(1),
 		.__use		= 1,
 		.obsolete	= -1,
 		.error		= -EINVAL,
 		.input		= dst_discard,
 		.output		= dst_discard,
 	},
 	.rt6i_flags	= (RTF_REJECT | RTF_NONEXTHOP),
 	.rt6i_protocol  = RTPROT_KERNEL,
 	.rt6i_metric	= ~(u32) 0,
 	.rt6i_ref	= ATOMIC_INIT(1),
 };
 #endif
 /* allocate dst with ip6_dst_ops */
 static inline struct rt6_info *ip6_dst_alloc(struct dst_ops *ops)
 {
 	return (struct rt6_info *)dst_alloc(ops);
 }
 static void ip6_dst_destroy(struct dst_entry *dst)
 {
 	struct rt6_info *rt = (struct rt6_info *)dst;
 	struct inet6_dev *idev = rt->rt6i_idev;
 	struct inet_peer *peer = rt->rt6i_peer;
 	if (idev != NULL) {
 		rt->rt6i_idev = NULL;
 		in6_dev_put(idev);
 	}
 	if (peer) {
 		rt->rt6i_peer = NULL;
 		inet_putpeer(peer);
 	}
 }
 void rt6_bind_peer(struct rt6_info *rt, int create)
 {
 	struct inet_peer *peer;
 	peer = inet_getpeer_v6(&rt->rt6i_dst.addr, create);
 	if (peer && cmpxchg(&rt->rt6i_peer, NULL, peer) != NULL)
 		inet_putpeer(peer);
 }
 static void ip6_dst_ifdown(struct dst_entry *dst, struct net_device *dev,
 			   int how)
 {
 	struct rt6_info *rt = (struct rt6_info *)dst;
 	struct inet6_dev *idev = rt->rt6i_idev;
 	struct net_device *loopback_dev =
 		dev_net(dev)->loopback_dev;
 	if (dev != loopback_dev && idev != NULL && idev->dev == dev) {
 		struct inet6_dev *loopback_idev =
 			in6_dev_get(loopback_dev);
 		if (loopback_idev != NULL) {
 			rt->rt6i_idev = loopback_idev;
 			in6_dev_put(idev);
 		}
 	}
 }
 static __inline__ int rt6_check_expired(const struct rt6_info *rt)
 {
 	return (rt->rt6i_flags & RTF_EXPIRES) &&
 		time_after(jiffies, rt->rt6i_expires);
 }
 static inline int rt6_need_strict(struct in6_addr *daddr)
 {
 	return ipv6_addr_type(daddr) &
 		(IPV6_ADDR_MULTICAST | IPV6_ADDR_LINKLOCAL | IPV6_ADDR_LOOPBACK);
 }
 /*
  *	Route lookup. Any table->tb6_lock is implied.
  */
 static inline struct rt6_info *rt6_device_match(struct net *net,
 						    struct rt6_info *rt,
 						    struct in6_addr *saddr,
 						    int oif,
 						    int flags)
 {
 	struct rt6_info *local = NULL;
 	struct rt6_info *sprt;
 	if (!oif && ipv6_addr_any(saddr))
 		goto out;
 	for (sprt = rt; sprt; sprt = sprt->dst.rt6_next) {
 		struct net_device *dev = sprt->rt6i_dev;
 		if (oif) {
 			if (dev->ifindex == oif)
 				return sprt;
 			if (dev->flags & IFF_LOOPBACK) {
 				if (sprt->rt6i_idev == NULL ||
 				    sprt->rt6i_idev->dev->ifindex != oif) {
 					if (flags & RT6_LOOKUP_F_IFACE && oif)
 						continue;
 					if (local && (!oif ||
 						      local->rt6i_idev->dev->ifindex == oif))
 						continue;
 				}
 				local = sprt;
 			}
 		} else {
 			if (ipv6_chk_addr(net, saddr, dev,
 					  flags & RT6_LOOKUP_F_IFACE))
 				return sprt;
 		}
 	}
 	if (oif) {
 		if (local)
 			return local;
 		if (flags & RT6_LOOKUP_F_IFACE)
 			return net->ipv6.ip6_null_entry;
 	}
 out:
 	return rt;
 }
 #ifdef CONFIG_IPV6_ROUTER_PREF
 static void rt6_probe(struct rt6_info *rt)
 {
 	struct neighbour *neigh = rt ? rt->rt6i_nexthop : NULL;
 	/*
 	 * Okay, this does not seem to be appropriate
 	 * for now, however, we need to check if it
 	 * is really so; aka Router Reachability Probing.
 	 *
 	 * Router Reachability Probe MUST be rate-limited
 	 * to no more than one per minute.
 	 */
 	if (!neigh || (neigh->nud_state & NUD_VALID))
 		return;
 	read_lock_bh(&neigh->lock);
 	if (!(neigh->nud_state & NUD_VALID) &&
 	    time_after(jiffies, neigh->updated + rt->rt6i_idev->cnf.rtr_probe_interval)) {
 		struct in6_addr mcaddr;
 		struct in6_addr *target;
 		neigh->updated = jiffies;
 		read_unlock_bh(&neigh->lock);
 		target = (struct in6_addr *)&neigh->primary_key;
 		addrconf_addr_solict_mult(target, &mcaddr);
 		ndisc_send_ns(rt->rt6i_dev, NULL, target, &mcaddr, NULL);
 	} else
 		read_unlock_bh(&neigh->lock);
 }
 #else
 static inline void rt6_probe(struct rt6_info *rt)
 {
 }
 #endif
 /*
  * Default Router Selection (RFC 2461 6.3.6)
  */
 static inline int rt6_check_dev(struct rt6_info *rt, int oif)
 {
 	struct net_device *dev = rt->rt6i_dev;
 	if (!oif || dev->ifindex == oif)
 		return 2;
 	if ((dev->flags & IFF_LOOPBACK) &&
 	    rt->rt6i_idev && rt->rt6i_idev->dev->ifindex == oif)
 		return 1;
 	return 0;
 }
 static inline int rt6_check_neigh(struct rt6_info *rt)
 {
 	struct neighbour *neigh = rt->rt6i_nexthop;
 	int m;
 	if (rt->rt6i_flags & RTF_NONEXTHOP ||
 	    !(rt->rt6i_flags & RTF_GATEWAY))
 		m = 1;
 	else if (neigh) {
 		read_lock_bh(&neigh->lock);
 		if (neigh->nud_state & NUD_VALID)
 			m = 2;
 #ifdef CONFIG_IPV6_ROUTER_PREF
 		else if (neigh->nud_state & NUD_FAILED)
 			m = 0;
 #endif
 		else
 			m = 1;
 		read_unlock_bh(&neigh->lock);
 	} else
 		m = 0;
 	return m;
 }
 static int rt6_score_route(struct rt6_info *rt, int oif,
 			   int strict)
 {
 	int m, n;
 	m = rt6_check_dev(rt, oif);
 	if (!m && (strict & RT6_LOOKUP_F_IFACE))
 		return -1;
 #ifdef CONFIG_IPV6_ROUTER_PREF
 	m |= IPV6_DECODE_PREF(IPV6_EXTRACT_PREF(rt->rt6i_flags)) << 2;
 #endif
 	n = rt6_check_neigh(rt);
 	if (!n && (strict & RT6_LOOKUP_F_REACHABLE))
 		return -1;
 	return m;
 }
 static struct rt6_info *find_match(struct rt6_info *rt, int oif, int strict,
 				   int *mpri, struct rt6_info *match)
 {
 	int m;
 	if (rt6_check_expired(rt))
 		goto out;
 	m = rt6_score_route(rt, oif, strict);
 	if (m < 0)
 		goto out;
 	if (m > *mpri) {
 		if (strict & RT6_LOOKUP_F_REACHABLE)
 			rt6_probe(match);
 		*mpri = m;
 		match = rt;
 	} else if (strict & RT6_LOOKUP_F_REACHABLE) {
 		rt6_probe(rt);
 	}
 out:
 	return match;
 }
 static struct rt6_info *find_rr_leaf(struct fib6_node *fn,
 				     struct rt6_info *rr_head,
 				     u32 metric, int oif, int strict)
 {
 	struct rt6_info *rt, *match;
 	int mpri = -1;
 	match = NULL;
 	for (rt = rr_head; rt && rt->rt6i_metric == metric;
 	     rt = rt->dst.rt6_next)
 		match = find_match(rt, oif, strict, &mpri, match);
 	for (rt = fn->leaf; rt && rt != rr_head && rt->rt6i_metric == metric;
 	     rt = rt->dst.rt6_next)
 		match = find_match(rt, oif, strict, &mpri, match);
 	return match;
 }
 static struct rt6_info *rt6_select(struct fib6_node *fn, int oif, int strict)
 {
 	struct rt6_info *match, *rt0;
 	struct net *net;
 	RT6_TRACE("%s(fn->leaf=%p, oif=%d)\n",
 		  __func__, fn->leaf, oif);
 	rt0 = fn->rr_ptr;
 	if (!rt0)
 		fn->rr_ptr = rt0 = fn->leaf;
 	match = find_rr_leaf(fn, rt0, rt0->rt6i_metric, oif, strict);
 	if (!match &&
 	    (strict & RT6_LOOKUP_F_REACHABLE)) {
 		struct rt6_info *next = rt0->dst.rt6_next;
 		/* no entries matched; do round-robin */
 		if (!next || next->rt6i_metric != rt0->rt6i_metric)
 			next = fn->leaf;
 		if (next != rt0)
 			fn->rr_ptr = next;
 	}
 	RT6_TRACE("%s() => %p\n",
 		  __func__, match);
 	net = dev_net(rt0->rt6i_dev);
 	return match ? match : net->ipv6.ip6_null_entry;
 }
 #ifdef CONFIG_IPV6_ROUTE_INFO
 int rt6_route_rcv(struct net_device *dev, u8 *opt, int len,
 		  struct in6_addr *gwaddr)
 {
 	struct net *net = dev_net(dev);
 	struct route_info *rinfo = (struct route_info *) opt;
 	struct in6_addr prefix_buf, *prefix;
 	unsigned int pref;
 	unsigned long lifetime;
 	struct rt6_info *rt;
 	if (len < sizeof(struct route_info)) {
 		return -EINVAL;
 	}
 	/* Sanity check for prefix_len and length */
 	if (rinfo->length > 3) {
 		return -EINVAL;
 	} else if (rinfo->prefix_len > 128) {
 		return -EINVAL;
 	} else if (rinfo->prefix_len > 64) {
 		if (rinfo->length < 2) {
 			return -EINVAL;
 		}
 	} else if (rinfo->prefix_len > 0) {
 		if (rinfo->length < 1) {
 			return -EINVAL;
 		}
 	}
 	pref = rinfo->route_pref;
 	if (pref == ICMPV6_ROUTER_PREF_INVALID)
 		return -EINVAL;
 	lifetime = addrconf_timeout_fixup(ntohl(rinfo->lifetime), HZ);
 	if (rinfo->length == 3)
 		prefix = (struct in6_addr *)rinfo->prefix;
 	else {
 		/* this function is safe */
 		ipv6_addr_prefix(&prefix_buf,
 				 (struct in6_addr *)rinfo->prefix,
 				 rinfo->prefix_len);
 		prefix = &prefix_buf;
 	}
 	rt = rt6_get_route_info(net, prefix, rinfo->prefix_len, gwaddr,
 				dev->ifindex);
 	if (rt && !lifetime) {
 		ip6_del_rt(rt);
 		rt = NULL;
 	}
 	if (!rt && lifetime)
 		rt = rt6_add_route_info(net, prefix, rinfo->prefix_len, gwaddr, dev->ifindex,
 					pref);
 	else if (rt)
 		rt->rt6i_flags = RTF_ROUTEINFO |
 				 (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
 	if (rt) {
 		if (!addrconf_finite_timeout(lifetime)) {
 			rt->rt6i_flags &= ~RTF_EXPIRES;
 		} else {
 			rt->rt6i_expires = jiffies + HZ * lifetime;
 			rt->rt6i_flags |= RTF_EXPIRES;
 		}
 		dst_release(&rt->dst);
 	}
 	return 0;
 }
 #endif
 #define BACKTRACK(__net, saddr)			\
 do { \
 	if (rt == __net->ipv6.ip6_null_entry) {	\
 		struct fib6_node *pn; \
 		while (1) { \
 			if (fn->fn_flags & RTN_TL_ROOT) \
 				goto out; \
 			pn = fn->parent; \
 			if (FIB6_SUBTREE(pn) && FIB6_SUBTREE(pn) != fn) \
 				fn = fib6_lookup(FIB6_SUBTREE(pn), NULL, saddr); \
 			else \
 				fn = pn; \
 			if (fn->fn_flags & RTN_RTINFO) \
 				goto restart; \
 		} \
 	} \
 } while(0)
 static struct rt6_info *ip6_pol_route_lookup(struct net *net,
 					     struct fib6_table *table,
 					     struct flowi *fl, int flags)
 {
 	struct fib6_node *fn;
 	struct rt6_info *rt;
 	read_lock_bh(&table->tb6_lock);
 	fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);
 restart:
 	rt = fn->leaf;
 	rt = rt6_device_match(net, rt, &fl->fl6_src, fl->oif, flags);
 	BACKTRACK(net, &fl->fl6_src);
 out:
 	dst_use(&rt->dst, jiffies);
 	read_unlock_bh(&table->tb6_lock);
 	return rt;
 }
 struct rt6_info *rt6_lookup(struct net *net, const struct in6_addr *daddr,
 			    const struct in6_addr *saddr, int oif, int strict)
 {
 	struct flowi fl = {
 		.oif = oif,
 		.fl6_dst = *daddr,
 	};
 	struct dst_entry *dst;
 	int flags = strict ? RT6_LOOKUP_F_IFACE : 0;
 	if (saddr) {
 		memcpy(&fl.fl6_src, saddr, sizeof(*saddr));
 		flags |= RT6_LOOKUP_F_HAS_SADDR;
 	}
 	dst = fib6_rule_lookup(net, &fl, flags, ip6_pol_route_lookup);
 	if (dst->error == 0)
 		return (struct rt6_info *) dst;
 	dst_release(dst);
 	return NULL;
 }
 EXPORT_SYMBOL(rt6_lookup);
 /* ip6_ins_rt is called with FREE table->tb6_lock.
    It takes new route entry, the addition fails by any reason the
    route is freed. In any case, if caller does not hold it, it may
    be destroyed.
  */
 static int __ip6_ins_rt(struct rt6_info *rt, struct nl_info *info)
 {
 	int err;
 	struct fib6_table *table;
 	table = rt->rt6i_table;
 	write_lock_bh(&table->tb6_lock);
 	err = fib6_add(&table->tb6_root, rt, info);
 	write_unlock_bh(&table->tb6_lock);
 	return err;
 }
 int ip6_ins_rt(struct rt6_info *rt)
 {
 	struct nl_info info = {
 		.nl_net = dev_net(rt->rt6i_dev),
 	};
 	return __ip6_ins_rt(rt, &info);
 }
 static struct rt6_info *rt6_alloc_cow(struct rt6_info *ort, struct in6_addr *daddr,
 				      struct in6_addr *saddr)
 {
 	struct rt6_info *rt;
 	/*
 	 *	Clone the route.
 	 */
 	rt = ip6_rt_copy(ort);
 	if (rt) {
 		struct neighbour *neigh;
 		int attempts = !in_softirq();
 		if (!(rt->rt6i_flags&RTF_GATEWAY)) {
 			if (rt->rt6i_dst.plen != 128 &&
 			    ipv6_addr_equal(&rt->rt6i_dst.addr, daddr))
 				rt->rt6i_flags |= RTF_ANYCAST;
 			ipv6_addr_copy(&rt->rt6i_gateway, daddr);
 		}
 		ipv6_addr_copy(&rt->rt6i_dst.addr, daddr);
 		rt->rt6i_dst.plen = 128;
 		rt->rt6i_flags |= RTF_CACHE;
 		rt->dst.flags |= DST_HOST;
 #ifdef CONFIG_IPV6_SUBTREES
 		if (rt->rt6i_src.plen && saddr) {
 			ipv6_addr_copy(&rt->rt6i_src.addr, saddr);
 			rt->rt6i_src.plen = 128;
 		}
 #endif
 	retry:
 		neigh = ndisc_get_neigh(rt->rt6i_dev, &rt->rt6i_gateway);
 		if (IS_ERR(neigh)) {
 			struct net *net = dev_net(rt->rt6i_dev);
 			int saved_rt_min_interval =
 				net->ipv6.sysctl.ip6_rt_gc_min_interval;
 			int saved_rt_elasticity =
 				net->ipv6.sysctl.ip6_rt_gc_elasticity;
 			if (attempts-- > 0) {
 				net->ipv6.sysctl.ip6_rt_gc_elasticity = 1;
 				net->ipv6.sysctl.ip6_rt_gc_min_interval = 0;
 				ip6_dst_gc(&net->ipv6.ip6_dst_ops);
 				net->ipv6.sysctl.ip6_rt_gc_elasticity =
 					saved_rt_elasticity;
 				net->ipv6.sysctl.ip6_rt_gc_min_interval =
 					saved_rt_min_interval;
 				goto retry;
 			}
 			if (net_ratelimit())
 				printk(KERN_WARNING
 				       "ipv6: Neighbour table overflow.\n");
 			dst_free(&rt->dst);
 			return NULL;
 		}
 		rt->rt6i_nexthop = neigh;
 	}
 	return rt;
 }
 static struct rt6_info *rt6_alloc_clone(struct rt6_info *ort, struct in6_addr *daddr)
 {
 	struct rt6_info *rt = ip6_rt_copy(ort);
 	if (rt) {
 		ipv6_addr_copy(&rt->rt6i_dst.addr, daddr);
 		rt->rt6i_dst.plen = 128;
 		rt->rt6i_flags |= RTF_CACHE;
 		rt->dst.flags |= DST_HOST;
 		rt->rt6i_nexthop = neigh_clone(ort->rt6i_nexthop);
 	}
 	return rt;
 }
 static struct rt6_info *ip6_pol_route(struct net *net, struct fib6_table *table, int oif,
 				      struct flowi *fl, int flags)
 {
 	struct fib6_node *fn;
 	struct rt6_info *rt, *nrt;
 	int strict = 0;
 	int attempts = 3;
 	int err;
 	int reachable = net->ipv6.devconf_all->forwarding ? 0 : RT6_LOOKUP_F_REACHABLE;
 	strict |= flags & RT6_LOOKUP_F_IFACE;
 relookup:
 	read_lock_bh(&table->tb6_lock);
 restart_2:
 	fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);
 restart:
 	rt = rt6_select(fn, oif, strict | reachable);
 	BACKTRACK(net, &fl->fl6_src);
 	if (rt == net->ipv6.ip6_null_entry ||
 	    rt->rt6i_flags & RTF_CACHE)
 		goto out;
 	dst_hold(&rt->dst);
 	read_unlock_bh(&table->tb6_lock);
 	if (!rt->rt6i_nexthop && !(rt->rt6i_flags & RTF_NONEXTHOP))
 		nrt = rt6_alloc_cow(rt, &fl->fl6_dst, &fl->fl6_src);
 	else
 		nrt = rt6_alloc_clone(rt, &fl->fl6_dst);
 	dst_release(&rt->dst);
 	rt = nrt ? : net->ipv6.ip6_null_entry;
 	dst_hold(&rt->dst);
 	if (nrt) {
 		err = ip6_ins_rt(nrt);
 		if (!err)
 			goto out2;
 	}
 	if (--attempts <= 0)
 		goto out2;
 	/*
 	 * Race condition! In the gap, when table->tb6_lock was
 	 * released someone could insert this route.  Relookup.
 	 */
 	dst_release(&rt->dst);
 	goto relookup;
 out:
 	if (reachable) {
 		reachable = 0;
 		goto restart_2;
 	}
 	dst_hold(&rt->dst);
 	read_unlock_bh(&table->tb6_lock);
 out2:
 	rt->dst.lastuse = jiffies;
 	rt->dst.__use++;
 	return rt;
 }
 static struct rt6_info *ip6_pol_route_input(struct net *net, struct fib6_table *table,
 					    struct flowi *fl, int flags)
 {
 	return ip6_pol_route(net, table, fl->iif, fl, flags);
 }
 void ip6_route_input(struct sk_buff *skb)
 {
 	struct ipv6hdr *iph = ipv6_hdr(skb);
 	struct net *net = dev_net(skb->dev);
 	int flags = RT6_LOOKUP_F_HAS_SADDR;
 	struct flowi fl = {
 		.iif = skb->dev->ifindex,
 		.fl6_dst = iph->daddr,
 		.fl6_src = iph->saddr,
 		.fl6_flowlabel = (* (__be32 *) iph)&IPV6_FLOWINFO_MASK,
 		.mark = skb->mark,
 		.proto = iph->nexthdr,
 	};
 	if (rt6_need_strict(&iph->daddr) && skb->dev->type != ARPHRD_PIMREG)
 		flags |= RT6_LOOKUP_F_IFACE;
 	skb_dst_set(skb, fib6_rule_lookup(net, &fl, flags, ip6_pol_route_input));
 }
 static struct rt6_info *ip6_pol_route_output(struct net *net, struct fib6_table *table,
 					     struct flowi *fl, int flags)
 {
 	return ip6_pol_route(net, table, fl->oif, fl, flags);
 }
 struct dst_entry * ip6_route_output(struct net *net, struct sock *sk,
 				    struct flowi *fl)
 {
 	int flags = 0;
 	if ((sk && sk->sk_bound_dev_if) || rt6_need_strict(&fl->fl6_dst))
 		flags |= RT6_LOOKUP_F_IFACE;
 	if (!ipv6_addr_any(&fl->fl6_src))
 		flags |= RT6_LOOKUP_F_HAS_SADDR;
 	else if (sk)
 		flags |= rt6_srcprefs2flags(inet6_sk(sk)->srcprefs);
 	return fib6_rule_lookup(net, fl, flags, ip6_pol_route_output);
 }
 EXPORT_SYMBOL(ip6_route_output);
 int ip6_dst_blackhole(struct sock *sk, struct dst_entry **dstp, struct flowi *fl)
 {
 	struct rt6_info *ort = (struct rt6_info *) *dstp;
 	struct rt6_info *rt = (struct rt6_info *)
 		dst_alloc(&ip6_dst_blackhole_ops);
 	struct dst_entry *new = NULL;
 	if (rt) {
 		new = &rt->dst;
 		atomic_set(&new->__refcnt, 1);
 		new->__use = 1;
 		new->input = dst_discard;
 		new->output = dst_discard;
 		dst_copy_metrics(new, &ort->dst);
 		new->dev = ort->dst.dev;
 		if (new->dev)
 			dev_hold(new->dev);
 		rt->rt6i_idev = ort->rt6i_idev;
 		if (rt->rt6i_idev)
 			in6_dev_hold(rt->rt6i_idev);
 		rt->rt6i_expires = 0;
 		ipv6_addr_copy(&rt->rt6i_gateway, &ort->rt6i_gateway);
 		rt->rt6i_flags = ort->rt6i_flags & ~RTF_EXPIRES;
 		rt->rt6i_metric = 0;
 		memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key));
 #ifdef CONFIG_IPV6_SUBTREES
 		memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
 #endif
 		dst_free(new);
 	}
 	dst_release(*dstp);
 	*dstp = new;
 	return new ? 0 : -ENOMEM;
 }
 EXPORT_SYMBOL_GPL(ip6_dst_blackhole);
 /*
  *	Destination cache support functions
  */
 static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie)
 {
 	struct rt6_info *rt;
 	rt = (struct rt6_info *) dst;
 	if (rt->rt6i_node && (rt->rt6i_node->fn_sernum == cookie))
 		return dst;
 	return NULL;
 }
 static struct dst_entry *ip6_negative_advice(struct dst_entry *dst)
 {
 	struct rt6_info *rt = (struct rt6_info *) dst;
 	if (rt) {
 		if (rt->rt6i_flags & RTF_CACHE) {
 			if (rt6_check_expired(rt)) {
 				ip6_del_rt(rt);
 				dst = NULL;
 			}
 		} else {
 			dst_release(dst);
 			dst = NULL;
 		}
 	}
 	return dst;
 }
 static void ip6_link_failure(struct sk_buff *skb)
 {
 	struct rt6_info *rt;
 	icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_ADDR_UNREACH, 0);
 	rt = (struct rt6_info *) skb_dst(skb);
 	if (rt) {
 		if (rt->rt6i_flags&RTF_CACHE) {
 			dst_set_expires(&rt->dst, 0);
 			rt->rt6i_flags |= RTF_EXPIRES;
 		} else if (rt->rt6i_node && (rt->rt6i_flags & RTF_DEFAULT))
 			rt->rt6i_node->fn_sernum = -1;
 	}
 }
 static void ip6_rt_update_pmtu(struct dst_entry *dst, u32 mtu)
 {
 	struct rt6_info *rt6 = (struct rt6_info*)dst;
 	if (mtu < dst_mtu(dst) && rt6->rt6i_dst.plen == 128) {
 		rt6->rt6i_flags |= RTF_MODIFIED;
 		if (mtu < IPV6_MIN_MTU) {
 			u32 features = dst_metric(dst, RTAX_FEATURES);
 			mtu = IPV6_MIN_MTU;
 			features |= RTAX_FEATURE_ALLFRAG;
 			dst_metric_set(dst, RTAX_FEATURES, features);
 		}
 		dst_metric_set(dst, RTAX_MTU, mtu);
 		call_netevent_notifiers(NETEVENT_PMTU_UPDATE, dst);
 	}
 }
 static unsigned int ip6_default_advmss(const struct dst_entry *dst)
 {
 	struct net_device *dev = dst->dev;
 	unsigned int mtu = dst_mtu(dst);
 	struct net *net = dev_net(dev);
 	mtu -= sizeof(struct ipv6hdr) + sizeof(struct tcphdr);
 	if (mtu < net->ipv6.sysctl.ip6_rt_min_advmss)
 		mtu = net->ipv6.sysctl.ip6_rt_min_advmss;
 	/*
 	 * Maximal non-jumbo IPv6 payload is IPV6_MAXPLEN and
 	 * corresponding MSS is IPV6_MAXPLEN - tcp_header_size.
 	 * IPV6_MAXPLEN is also valid and means: "any MSS,
 	 * rely only on pmtu discovery"
 	 */
 	if (mtu > IPV6_MAXPLEN - sizeof(struct tcphdr))
 		mtu = IPV6_MAXPLEN;
 	return mtu;
 }
 static unsigned int ip6_default_mtu(const struct dst_entry *dst)
 {
 	unsigned int mtu = IPV6_MIN_MTU;
 	struct inet6_dev *idev;
 	rcu_read_lock();
 	idev = __in6_dev_get(dst->dev);
 	if (idev)
 		mtu = idev->cnf.mtu6;
 	rcu_read_unlock();
 	return mtu;
 }
 static struct dst_entry *icmp6_dst_gc_list;
 static DEFINE_SPINLOCK(icmp6_dst_lock);
 struct dst_entry *icmp6_dst_alloc(struct net_device *dev,
 				  struct neighbour *neigh,
 				  const struct in6_addr *addr)
 {
 	struct rt6_info *rt;
 	struct inet6_dev *idev = in6_dev_get(dev);
 	struct net *net = dev_net(dev);
 	if (unlikely(idev == NULL))
 		return NULL;
 	rt = ip6_dst_alloc(&net->ipv6.ip6_dst_ops);
 	if (unlikely(rt == NULL)) {
 		in6_dev_put(idev);
 		goto out;
 	}
 	dev_hold(dev);
 	if (neigh)
 		neigh_hold(neigh);
 	else {
 		neigh = ndisc_get_neigh(dev, addr);
 		if (IS_ERR(neigh))
 			neigh = NULL;
 	}
 	rt->rt6i_dev	  = dev;
 	rt->rt6i_idev     = idev;
 	rt->rt6i_nexthop  = neigh;
 	atomic_set(&rt->dst.__refcnt, 1);
 	dst_metric_set(&rt->dst, RTAX_HOPLIMIT, 255);
 	rt->dst.output  = ip6_output;
 #if 0	/* there's no chance to use these for ndisc */
 	rt->dst.flags   = ipv6_addr_type(addr) & IPV6_ADDR_UNICAST
 				? DST_HOST
 				: 0;
 	ipv6_addr_copy(&rt->rt6i_dst.addr, addr);
 	rt->rt6i_dst.plen = 128;
 #endif
 	spin_lock_bh(&icmp6_dst_lock);
 	rt->dst.next = icmp6_dst_gc_list;
 	icmp6_dst_gc_list = &rt->dst;
 	spin_unlock_bh(&icmp6_dst_lock);
 	fib6_force_start_gc(net);
 out:
 	return &rt->dst;
 }
 int icmp6_dst_gc(void)
 {
 	struct dst_entry *dst, *next, **pprev;
 	int more = 0;
 	next = NULL;
 	spin_lock_bh(&icmp6_dst_lock);
 	pprev = &icmp6_dst_gc_list;
 	while ((dst = *pprev) != NULL) {
 		if (!atomic_read(&dst->__refcnt)) {
 			*pprev = dst->next;
 			dst_free(dst);
 		} else {
 			pprev = &dst->next;
 			++more;
 		}
 	}
 	spin_unlock_bh(&icmp6_dst_lock);
 	return more;
 }
 static void icmp6_clean_all(int (*func)(struct rt6_info *rt, void *arg),
 			    void *arg)
 {
 	struct dst_entry *dst, **pprev;
 	spin_lock_bh(&icmp6_dst_lock);
 	pprev = &icmp6_dst_gc_list;
 	while ((dst = *pprev) != NULL) {
 		struct rt6_info *rt = (struct rt6_info *) dst;
 		if (func(rt, arg)) {
 			*pprev = dst->next;
 			dst_free(dst);
 		} else {
 			pprev = &dst->next;
 		}
 	}
 	spin_unlock_bh(&icmp6_dst_lock);
 }
 static int ip6_dst_gc(struct dst_ops *ops)
 {
 	unsigned long now = jiffies;
 	struct net *net = container_of(ops, struct net, ipv6.ip6_dst_ops);
 	int rt_min_interval = net->ipv6.sysctl.ip6_rt_gc_min_interval;
 	int rt_max_size = net->ipv6.sysctl.ip6_rt_max_size;
 	int rt_elasticity = net->ipv6.sysctl.ip6_rt_gc_elasticity;
 	int rt_gc_timeout = net->ipv6.sysctl.ip6_rt_gc_timeout;
 	unsigned long rt_last_gc = net->ipv6.ip6_rt_last_gc;
 	int entries;
 	entries = dst_entries_get_fast(ops);
 	if (time_after(rt_last_gc + rt_min_interval, now) &&
 	    entries <= rt_max_size)
 		goto out;
 	net->ipv6.ip6_rt_gc_expire++;
 	fib6_run_gc(net->ipv6.ip6_rt_gc_expire, net);
 	net->ipv6.ip6_rt_last_gc = now;
 	entries = dst_entries_get_slow(ops);
 	if (entries < ops->gc_thresh)
 		net->ipv6.ip6_rt_gc_expire = rt_gc_timeout>>1;
 out:
 	net->ipv6.ip6_rt_gc_expire -= net->ipv6.ip6_rt_gc_expire>>rt_elasticity;
 	return entries > rt_max_size;
 }
 /* Clean host part of a prefix. Not necessary in radix tree,
    but results in cleaner routing tables.
    Remove it only when all the things will work!
  */
 int ip6_dst_hoplimit(struct dst_entry *dst)
 {
 	int hoplimit = dst_metric_raw(dst, RTAX_HOPLIMIT);
 	if (hoplimit == 0) {
 		struct net_device *dev = dst->dev;
 		struct inet6_dev *idev;
 		rcu_read_lock();
 		idev = __in6_dev_get(dev);
 		if (idev)
 			hoplimit = idev->cnf.hop_limit;
 		else
 			hoplimit = dev_net(dev)->ipv6.devconf_all->hop_limit;
 		rcu_read_unlock();
 	}
 	return hoplimit;
 }
 EXPORT_SYMBOL(ip6_dst_hoplimit);
 /*
  *
  */
 int ip6_route_add(struct fib6_config *cfg)
 {
 	int err;
 	struct net *net = cfg->fc_nlinfo.nl_net;
 	struct rt6_info *rt = NULL;
 	struct net_device *dev = NULL;
 	struct inet6_dev *idev = NULL;
 	struct fib6_table *table;
 	int addr_type;
 	if (cfg->fc_dst_len > 128 || cfg->fc_src_len > 128)
 		return -EINVAL;
 #ifndef CONFIG_IPV6_SUBTREES
 	if (cfg->fc_src_len)
 		return -EINVAL;
 #endif
 	if (cfg->fc_ifindex) {
 		err = -ENODEV;
 		dev = dev_get_by_index(net, cfg->fc_ifindex);
 		if (!dev)
 			goto out;
 		idev = in6_dev_get(dev);
 		if (!idev)
 			goto out;
 	}
 	if (cfg->fc_metric == 0)
 		cfg->fc_metric = IP6_RT_PRIO_USER;
 	table = fib6_new_table(net, cfg->fc_table);
 	if (table == NULL) {
 		err = -ENOBUFS;
 		goto out;
 	}
 	rt = ip6_dst_alloc(&net->ipv6.ip6_dst_ops);
 	if (rt == NULL) {
 		err = -ENOMEM;
 		goto out;
 	}
 	rt->dst.obsolete = -1;
 	rt->rt6i_expires = (cfg->fc_flags & RTF_EXPIRES) ?
 				jiffies + clock_t_to_jiffies(cfg->fc_expires) :
 				0;
 	if (cfg->fc_protocol == RTPROT_UNSPEC)
 		cfg->fc_protocol = RTPROT_BOOT;
 	rt->rt6i_protocol = cfg->fc_protocol;
 	addr_type = ipv6_addr_type(&cfg->fc_dst);
 	if (addr_type & IPV6_ADDR_MULTICAST)
 		rt->dst.input = ip6_mc_input;
 	else if (cfg->fc_flags & RTF_LOCAL)
 		rt->dst.input = ip6_input;
 	else
 		rt->dst.input = ip6_forward;
 	rt->dst.output = ip6_output;
 	ipv6_addr_prefix(&rt->rt6i_dst.addr, &cfg->fc_dst, cfg->fc_dst_len);
 	rt->rt6i_dst.plen = cfg->fc_dst_len;
 	if (rt->rt6i_dst.plen == 128)
 	       rt->dst.flags = DST_HOST;
 #ifdef CONFIG_IPV6_SUBTREES
 	ipv6_addr_prefix(&rt->rt6i_src.addr, &cfg->fc_src, cfg->fc_src_len);
 	rt->rt6i_src.plen = cfg->fc_src_len;
 #endif
 	rt->rt6i_metric = cfg->fc_metric;
 	/* We cannot add true routes via loopback here,
 	   they would result in kernel looping; promote them to reject routes
 	 */
 	if ((cfg->fc_flags & RTF_REJECT) ||
 	    (dev && (dev->flags&IFF_LOOPBACK) && !(addr_type&IPV6_ADDR_LOOPBACK)
 					      && !(cfg->fc_flags&RTF_LOCAL))) {
 		/* hold loopback dev/idev if we haven't done so. */
 		if (dev != net->loopback_dev) {
 			if (dev) {
 				dev_put(dev);
 				in6_dev_put(idev);
 			}
 			dev = net->loopback_dev;
 			dev_hold(dev);
 			idev = in6_dev_get(dev);
 			if (!idev) {
 				err = -ENODEV;
 				goto out;
 			}
 		}
 		rt->dst.output = ip6_pkt_discard_out;
 		rt->dst.input = ip6_pkt_discard;
 		rt->dst.error = -ENETUNREACH;
 		rt->rt6i_flags = RTF_REJECT|RTF_NONEXTHOP;
 		goto install_route;
 	}
 	if (cfg->fc_flags & RTF_GATEWAY) {
 		struct in6_addr *gw_addr;
 		int gwa_type;
 		gw_addr = &cfg->fc_gateway;
 		ipv6_addr_copy(&rt->rt6i_gateway, gw_addr);
 		gwa_type = ipv6_addr_type(gw_addr);
 		if (gwa_type != (IPV6_ADDR_LINKLOCAL|IPV6_ADDR_UNICAST)) {
 			struct rt6_info *grt;
 			/* IPv6 strictly inhibits using not link-local
 			   addresses as nexthop address.
 			   Otherwise, router will not able to send redirects.
 			   It is very good, but in some (rare!) circumstances
 			   (SIT, PtP, NBMA NOARP links) it is handy to allow
 			   some exceptions. --ANK
 			 */
 			err = -EINVAL;
 			if (!(gwa_type&IPV6_ADDR_UNICAST))
 				goto out;
 			grt = rt6_lookup(net, gw_addr, NULL, cfg->fc_ifindex, 1);
 			err = -EHOSTUNREACH;
 			if (grt == NULL)
 				goto out;
 			if (dev) {
 				if (dev != grt->rt6i_dev) {
 					dst_release(&grt->dst);
 					goto out;
 				}
 			} else {
 				dev = grt->rt6i_dev;
 				idev = grt->rt6i_idev;
 				dev_hold(dev);
 				in6_dev_hold(grt->rt6i_idev);
 			}
 			if (!(grt->rt6i_flags&RTF_GATEWAY))
 				err = 0;
 			dst_release(&grt->dst);
 			if (err)
 				goto out;
 		}
 		err = -EINVAL;
 		if (dev == NULL || (dev->flags&IFF_LOOPBACK))
 			goto out;
 	}
 	err = -ENODEV;
 	if (dev == NULL)
 		goto out;
 	if (cfg->fc_flags & (RTF_GATEWAY | RTF_NONEXTHOP)) {
 		rt->rt6i_nexthop = __neigh_lookup_errno(&nd_tbl, &rt->rt6i_gateway, dev);
 		if (IS_ERR(rt->rt6i_nexthop)) {
 			err = PTR_ERR(rt->rt6i_nexthop);
 			rt->rt6i_nexthop = NULL;
 			goto out;
 		}
 	}
 	rt->rt6i_flags = cfg->fc_flags;
 install_route:
 	if (cfg->fc_mx) {
 		struct nlattr *nla;
 		int remaining;
 		nla_for_each_attr(nla, cfg->fc_mx, cfg->fc_mx_len, remaining) {
 			int type = nla_type(nla);
 			if (type) {
 				if (type > RTAX_MAX) {
 					err = -EINVAL;
 					goto out;
 				}
 				dst_metric_set(&rt->dst, type, nla_get_u32(nla));
 			}
 		}
 	}
 	rt->dst.dev = dev;
 	rt->rt6i_idev = idev;
 	rt->rt6i_table = table;
 	cfg->fc_nlinfo.nl_net = dev_net(dev);
 	return __ip6_ins_rt(rt, &cfg->fc_nlinfo);
 out:
 	if (dev)
 		dev_put(dev);
 	if (idev)
 		in6_dev_put(idev);
 	if (rt)
 		dst_free(&rt->dst);
 	return err;
 }
 static int __ip6_del_rt(struct rt6_info *rt, struct nl_info *info)
 {
 	int err;
 	struct fib6_table *table;
 	struct net *net = dev_net(rt->rt6i_dev);
 	if (rt == net->ipv6.ip6_null_entry)
 		return -ENOENT;
 	table = rt->rt6i_table;
 	write_lock_bh(&table->tb6_lock);
 	err = fib6_del(rt, info);
 	dst_release(&rt->dst);
 	write_unlock_bh(&table->tb6_lock);
 	return err;
 }
 int ip6_del_rt(struct rt6_info *rt)
 {
 	struct nl_info info = {
 		.nl_net = dev_net(rt->rt6i_dev),
 	};
 	return __ip6_del_rt(rt, &info);
 }
 static int ip6_route_del(struct fib6_config *cfg)
 {
 	struct fib6_table *table;
 	struct fib6_node *fn;
 	struct rt6_info *rt;
 	int err = -ESRCH;
 	table = fib6_get_table(cfg->fc_nlinfo.nl_net, cfg->fc_table);
 	if (table == NULL)
 		return err;
 	read_lock_bh(&table->tb6_lock);
 	fn = fib6_locate(&table->tb6_root,
 			 &cfg->fc_dst, cfg->fc_dst_len,
 			 &cfg->fc_src, cfg->fc_src_len);
 	if (fn) {
 		for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
 			if (cfg->fc_ifindex &&
 			    (rt->rt6i_dev == NULL ||
 			     rt->rt6i_dev->ifindex != cfg->fc_ifindex))
 				continue;
 			if (cfg->fc_flags & RTF_GATEWAY &&
 			    !ipv6_addr_equal(&cfg->fc_gateway, &rt->rt6i_gateway))
 				continue;
 			if (cfg->fc_metric && cfg->fc_metric != rt->rt6i_metric)
 				continue;
 			dst_hold(&rt->dst);
 			read_unlock_bh(&table->tb6_lock);
 			return __ip6_del_rt(rt, &cfg->fc_nlinfo);
 		}
 	}
 	read_unlock_bh(&table->tb6_lock);
 	return err;
 }
 /*
  *	Handle redirects
  */
 struct ip6rd_flowi {
 	struct flowi fl;
 	struct in6_addr gateway;
 };
 static struct rt6_info *__ip6_route_redirect(struct net *net,
 					     struct fib6_table *table,
 					     struct flowi *fl,
 					     int flags)
 {
 	struct ip6rd_flowi *rdfl = (struct ip6rd_flowi *)fl;
 	struct rt6_info *rt;
 	struct fib6_node *fn;
 	/*
 	 * Get the "current" route for this destination and
 	 * check if the redirect has come from approriate router.
 	 *
 	 * RFC 2461 specifies that redirects should only be
 	 * accepted if they come from the nexthop to the target.
 	 * Due to the way the routes are chosen, this notion
 	 * is a bit fuzzy and one might need to check all possible
 	 * routes.
 	 */
 	read_lock_bh(&table->tb6_lock);
 	fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);
 restart:
 	for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
 		/*
 		 * Current route is on-link; redirect is always invalid.
 		 *
 		 * Seems, previous statement is not true. It could
 		 * be node, which looks for us as on-link (f.e. proxy ndisc)
 		 * But then router serving it might decide, that we should
 		 * know truth 8)8) --ANK (980726).
 		 */
 		if (rt6_check_expired(rt))
 			continue;
 		if (!(rt->rt6i_flags & RTF_GATEWAY))
 			continue;
 		if (fl->oif != rt->rt6i_dev->ifindex)
 			continue;
 		if (!ipv6_addr_equal(&rdfl->gateway, &rt->rt6i_gateway))
 			continue;
 		break;
 	}
 	if (!rt)
 		rt = net->ipv6.ip6_null_entry;
 	BACKTRACK(net, &fl->fl6_src);
 out:
 	dst_hold(&rt->dst);
 	read_unlock_bh(&table->tb6_lock);
 	return rt;
 };
 static struct rt6_info *ip6_route_redirect(struct in6_addr *dest,
 					   struct in6_addr *src,
 					   struct in6_addr *gateway,
 					   struct net_device *dev)
 {
 	int flags = RT6_LOOKUP_F_HAS_SADDR;
 	struct net *net = dev_net(dev);
 	struct ip6rd_flowi rdfl = {
 		.fl = {
 			.oif = dev->ifindex,
 			.fl6_dst = *dest,
 			.fl6_src = *src,
 		},
 	};
 	ipv6_addr_copy(&rdfl.gateway, gateway);
 	if (rt6_need_strict(dest))
 		flags |= RT6_LOOKUP_F_IFACE;
 	return (struct rt6_info *)fib6_rule_lookup(net, (struct flowi *)&rdfl,
 						   flags, __ip6_route_redirect);
 }
 void rt6_redirect(struct in6_addr *dest, struct in6_addr *src,
 		  struct in6_addr *saddr,
 		  struct neighbour *neigh, u8 *lladdr, int on_link)
 {
 	struct rt6_info *rt, *nrt = NULL;
 	struct netevent_redirect netevent;
 	struct net *net = dev_net(neigh->dev);
 	rt = ip6_route_redirect(dest, src, saddr, neigh->dev);
 	if (rt == net->ipv6.ip6_null_entry) {
 		if (net_ratelimit())
 			printk(KERN_DEBUG "rt6_redirect: source isn't a valid nexthop "
 			       "for redirect target\n");
 		goto out;
 	}
 	/*
 	 *	We have finally decided to accept it.
 	 */
 	neigh_update(neigh, lladdr, NUD_STALE,
 		     NEIGH_UPDATE_F_WEAK_OVERRIDE|
 		     NEIGH_UPDATE_F_OVERRIDE|
 		     (on_link ? 0 : (NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
 				     NEIGH_UPDATE_F_ISROUTER))
 		     );
 	/*
 	 * Redirect received -> path was valid.
 	 * Look, redirects are sent only in response to data packets,
 	 * so that this nexthop apparently is reachable. --ANK
 	 */
 	dst_confirm(&rt->dst);
 	/* Duplicate redirect: silently ignore. */
 	if (neigh == rt->dst.neighbour)
 		goto out;
 	nrt = ip6_rt_copy(rt);
 	if (nrt == NULL)
 		goto out;
 	nrt->rt6i_flags = RTF_GATEWAY|RTF_UP|RTF_DYNAMIC|RTF_CACHE;
 	if (on_link)
 		nrt->rt6i_flags &= ~RTF_GATEWAY;
 	ipv6_addr_copy(&nrt->rt6i_dst.addr, dest);
 	nrt->rt6i_dst.plen = 128;
 	nrt->dst.flags |= DST_HOST;
 	ipv6_addr_copy(&nrt->rt6i_gateway, (struct in6_addr*)neigh->primary_key);
 	nrt->rt6i_nexthop = neigh_clone(neigh);
 	if (ip6_ins_rt(nrt))
 		goto out;
 	netevent.old = &rt->dst;
 	netevent.new = &nrt->dst;
 	call_netevent_notifiers(NETEVENT_REDIRECT, &netevent);
 	if (rt->rt6i_flags&RTF_CACHE) {
 		ip6_del_rt(rt);
 		return;
 	}
 out:
 	dst_release(&rt->dst);
 }
 /*
  *	Handle ICMP "packet too big" messages
  *	i.e. Path MTU discovery
  */
 static void rt6_do_pmtu_disc(struct in6_addr *daddr, struct in6_addr *saddr,
 			     struct net *net, u32 pmtu, int ifindex)
 {
 	struct rt6_info *rt, *nrt;
 	int allfrag = 0;
 again:
 	rt = rt6_lookup(net, daddr, saddr, ifindex, 0);
 	if (rt == NULL)
 		return;
 	if (rt6_check_expired(rt)) {
 		ip6_del_rt(rt);
 		goto again;
 	}
 	if (pmtu >= dst_mtu(&rt->dst))
 		goto out;
 	if (pmtu < IPV6_MIN_MTU) {
 		/*
 		 * According to RFC2460, PMTU is set to the IPv6 Minimum Link
 		 * MTU (1280) and a fragment header should always be included
 		 * after a node receiving Too Big message reporting PMTU is
 		 * less than the IPv6 Minimum Link MTU.
 		 */
 		pmtu = IPV6_MIN_MTU;
 		allfrag = 1;
 	}
 	/* New mtu received -> path was valid.
 	   They are sent only in response to data packets,
 	   so that this nexthop apparently is reachable. --ANK
 	 */
 	dst_confirm(&rt->dst);
 	/* Host route. If it is static, it would be better
 	   not to override it, but add new one, so that
 	   when cache entry will expire old pmtu
 	   would return automatically.
 	 */
 	if (rt->rt6i_flags & RTF_CACHE) {
 		dst_metric_set(&rt->dst, RTAX_MTU, pmtu);
 		if (allfrag) {
 			u32 features = dst_metric(&rt->dst, RTAX_FEATURES);
 			features |= RTAX_FEATURE_ALLFRAG;
 			dst_metric_set(&rt->dst, RTAX_FEATURES, features);
 		}
 		dst_set_expires(&rt->dst, net->ipv6.sysctl.ip6_rt_mtu_expires);
 		rt->rt6i_flags |= RTF_MODIFIED|RTF_EXPIRES;
 		goto out;
 	}
 	/* Network route.
 	   Two cases are possible:
 	   1. It is connected route. Action: COW
 	   2. It is gatewayed route or NONEXTHOP route. Action: clone it.
 	 */
 	if (!rt->rt6i_nexthop && !(rt->rt6i_flags & RTF_NONEXTHOP))
 		nrt = rt6_alloc_cow(rt, daddr, saddr);
 	else
 		nrt = rt6_alloc_clone(rt, daddr);
 	if (nrt) {
 		dst_metric_set(&nrt->dst, RTAX_MTU, pmtu);
 		if (allfrag) {
 			u32 features = dst_metric(&nrt->dst, RTAX_FEATURES);
 			features |= RTAX_FEATURE_ALLFRAG;
 			dst_metric_set(&nrt->dst, RTAX_FEATURES, features);
 		}
 		/* According to RFC 1981, detecting PMTU increase shouldn't be
 		 * happened within 5 mins, the recommended timer is 10 mins.
 		 * Here this route expiration time is set to ip6_rt_mtu_expires
 		 * which is 10 mins. After 10 mins the decreased pmtu is expired
 		 * and detecting PMTU increase will be automatically happened.
 		 */
 		dst_set_expires(&nrt->dst, net->ipv6.sysctl.ip6_rt_mtu_expires);
 		nrt->rt6i_flags |= RTF_DYNAMIC|RTF_EXPIRES;
 		ip6_ins_rt(nrt);
 	}
 out:
 	dst_release(&rt->dst);
 }
 void rt6_pmtu_discovery(struct in6_addr *daddr, struct in6_addr *saddr,
 			struct net_device *dev, u32 pmtu)
 {
 	struct net *net = dev_net(dev);
 	/*
 	 * RFC 1981 states that a node "MUST reduce the size of the packets it
 	 * is sending along the path" that caused the Packet Too Big message.
 	 * Since it's not possible in the general case to determine which
 	 * interface was used to send the original packet, we update the MTU
 	 * on the interface that will be used to send future packets. We also
 	 * update the MTU on the interface that received the Packet Too Big in
 	 * case the original packet was forced out that interface with
 	 * SO_BINDTODEVICE or similar. This is the next best thing to the
 	 * correct behaviour, which would be to update the MTU on all
 	 * interfaces.
 	 */
 	rt6_do_pmtu_disc(daddr, saddr, net, pmtu, 0);
 	rt6_do_pmtu_disc(daddr, saddr, net, pmtu, dev->ifindex);
 }
 /*
  *	Misc support functions
  */
 static struct rt6_info * ip6_rt_copy(struct rt6_info *ort)
 {
 	struct net *net = dev_net(ort->rt6i_dev);
 	struct rt6_info *rt = ip6_dst_alloc(&net->ipv6.ip6_dst_ops);
 	if (rt) {
 		rt->dst.input = ort->dst.input;
 		rt->dst.output = ort->dst.output;
 		dst_copy_metrics(&rt->dst, &ort->dst);
 		rt->dst.error = ort->dst.error;
 		rt->dst.dev = ort->dst.dev;
 		if (rt->dst.dev)
 			dev_hold(rt->dst.dev);
 		rt->rt6i_idev = ort->rt6i_idev;
 		if (rt->rt6i_idev)
 			in6_dev_hold(rt->rt6i_idev);
 		rt->dst.lastuse = jiffies;
 		rt->rt6i_expires = 0;
 		ipv6_addr_copy(&rt->rt6i_gateway, &ort->rt6i_gateway);
 		rt->rt6i_flags = ort->rt6i_flags & ~RTF_EXPIRES;
 		rt->rt6i_metric = 0;
 		memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key));
 #ifdef CONFIG_IPV6_SUBTREES
 		memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
 #endif
 		rt->rt6i_table = ort->rt6i_table;
 	}
 	return rt;
 }
 #ifdef CONFIG_IPV6_ROUTE_INFO
 static struct rt6_info *rt6_get_route_info(struct net *net,
 					   struct in6_addr *prefix, int prefixlen,
 					   struct in6_addr *gwaddr, int ifindex)
 {
 	struct fib6_node *fn;
 	struct rt6_info *rt = NULL;
 	struct fib6_table *table;
 	table = fib6_get_table(net, RT6_TABLE_INFO);
 	if (table == NULL)
 		return NULL;
 	write_lock_bh(&table->tb6_lock);
 	fn = fib6_locate(&table->tb6_root, prefix ,prefixlen, NULL, 0);
 	if (!fn)
 		goto out;
 	for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
 		if (rt->rt6i_dev->ifindex != ifindex)
 			continue;
 		if ((rt->rt6i_flags & (RTF_ROUTEINFO|RTF_GATEWAY)) != (RTF_ROUTEINFO|RTF_GATEWAY))
 			continue;
 		if (!ipv6_addr_equal(&rt->rt6i_gateway, gwaddr))
 			continue;
 		dst_hold(&rt->dst);
 		break;
 	}
 out:
 	write_unlock_bh(&table->tb6_lock);
 	return rt;
 }
 static struct rt6_info *rt6_add_route_info(struct net *net,
 					   struct in6_addr *prefix, int prefixlen,
 					   struct in6_addr *gwaddr, int ifindex,
 					   unsigned pref)
 {
 	struct fib6_config cfg = {
 		.fc_table	= RT6_TABLE_INFO,
 		.fc_metric	= IP6_RT_PRIO_USER,
 		.fc_ifindex	= ifindex,
 		.fc_dst_len	= prefixlen,
 		.fc_flags	= RTF_GATEWAY | RTF_ADDRCONF | RTF_ROUTEINFO |
 				  RTF_UP | RTF_PREF(pref),
 		.fc_nlinfo.pid = 0,
 		.fc_nlinfo.nlh = NULL,
 		.fc_nlinfo.nl_net = net,
 	};
 	ipv6_addr_copy(&cfg.fc_dst, prefix);
 	ipv6_addr_copy(&cfg.fc_gateway, gwaddr);
 	/* We should treat it as a default route if prefix length is 0. */
 	if (!prefixlen)
 		cfg.fc_flags |= RTF_DEFAULT;
 	ip6_route_add(&cfg);
 	return rt6_get_route_info(net, prefix, prefixlen, gwaddr, ifindex);
 }
 #endif
 struct rt6_info *rt6_get_dflt_router(struct in6_addr *addr, struct net_device *dev)
 {
 	struct rt6_info *rt;
 	struct fib6_table *table;
 	table = fib6_get_table(dev_net(dev), RT6_TABLE_DFLT);
 	if (table == NULL)
 		return NULL;
 	write_lock_bh(&table->tb6_lock);
 	for (rt = table->tb6_root.leaf; rt; rt=rt->dst.rt6_next) {
 		if (dev == rt->rt6i_dev &&
 		    ((rt->rt6i_flags & (RTF_ADDRCONF | RTF_DEFAULT)) == (RTF_ADDRCONF | RTF_DEFAULT)) &&
 		    ipv6_addr_equal(&rt->rt6i_gateway, addr))
 			break;
 	}
 	if (rt)
 		dst_hold(&rt->dst);
 	write_unlock_bh(&table->tb6_lock);
 	return rt;
 }
 struct rt6_info *rt6_add_dflt_router(struct in6_addr *gwaddr,
 				     struct net_device *dev,
 				     unsigned int pref)
 {
 	struct fib6_config cfg = {
 		.fc_table	= RT6_TABLE_DFLT,
 		.fc_metric	= IP6_RT_PRIO_USER,
 		.fc_ifindex	= dev->ifindex,
 		.fc_flags	= RTF_GATEWAY | RTF_ADDRCONF | RTF_DEFAULT |
 				  RTF_UP | RTF_EXPIRES | RTF_PREF(pref),
 		.fc_nlinfo.pid = 0,
 		.fc_nlinfo.nlh = NULL,
 		.fc_nlinfo.nl_net = dev_net(dev),
 	};
 	ipv6_addr_copy(&cfg.fc_gateway, gwaddr);
 	ip6_route_add(&cfg);
 	return rt6_get_dflt_router(gwaddr, dev);
 }
 void rt6_purge_dflt_routers(struct net *net)
 {
 	struct rt6_info *rt;
 	struct fib6_table *table;
 	/* NOTE: Keep consistent with rt6_get_dflt_router */
 	table = fib6_get_table(net, RT6_TABLE_DFLT);
 	if (table == NULL)
 		return;
 restart:
 	read_lock_bh(&table->tb6_lock);
 	for (rt = table->tb6_root.leaf; rt; rt = rt->dst.rt6_next) {
 		if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF)) {
 			dst_hold(&rt->dst);
 			read_unlock_bh(&table->tb6_lock);
 			ip6_del_rt(rt);
 			goto restart;
 		}
 	}
 	read_unlock_bh(&table->tb6_lock);
 }
 static void rtmsg_to_fib6_config(struct net *net,
 				 struct in6_rtmsg *rtmsg,
 				 struct fib6_config *cfg)
 {
 	memset(cfg, 0, sizeof(*cfg));
 	cfg->fc_table = RT6_TABLE_MAIN;
 	cfg->fc_ifindex = rtmsg->rtmsg_ifindex;
 	cfg->fc_metric = rtmsg->rtmsg_metric;
 	cfg->fc_expires = rtmsg->rtmsg_info;
 	cfg->fc_dst_len = rtmsg->rtmsg_dst_len;
 	cfg->fc_src_len = rtmsg->rtmsg_src_len;
 	cfg->fc_flags = rtmsg->rtmsg_flags;
 	cfg->fc_nlinfo.nl_net = net;
 	ipv6_addr_copy(&cfg->fc_dst, &rtmsg->rtmsg_dst);
 	ipv6_addr_copy(&cfg->fc_src, &rtmsg->rtmsg_src);
 	ipv6_addr_copy(&cfg->fc_gateway, &rtmsg->rtmsg_gateway);
 }
 int ipv6_route_ioctl(struct net *net, unsigned int cmd, void __user *arg)
 {
 	struct fib6_config cfg;
 	struct in6_rtmsg rtmsg;
 	int err;
 	switch(cmd) {
 	case SIOCADDRT:		/* Add a route */
 	case SIOCDELRT:		/* Delete a route */
 		if (!capable(CAP_NET_ADMIN))
 			return -EPERM;
 		err = copy_from_user(&rtmsg, arg,
 				     sizeof(struct in6_rtmsg));
 		if (err)
 			return -EFAULT;
 		rtmsg_to_fib6_config(net, &rtmsg, &cfg);
 		rtnl_lock();
 		switch (cmd) {
 		case SIOCADDRT:
 			err = ip6_route_add(&cfg);
 			break;
 		case SIOCDELRT:
 			err = ip6_route_del(&cfg);
 			break;
 		default:
 			err = -EINVAL;
 		}
 		rtnl_unlock();
 		return err;
 	}
 	return -EINVAL;
 }
 /*
  *	Drop the packet on the floor
  */
 static int ip6_pkt_drop(struct sk_buff *skb, u8 code, int ipstats_mib_noroutes)
 {
 	int type;
 	struct dst_entry *dst = skb_dst(skb);
 	switch (ipstats_mib_noroutes) {
 	case IPSTATS_MIB_INNOROUTES:
 		type = ipv6_addr_type(&ipv6_hdr(skb)->daddr);
 		if (type == IPV6_ADDR_ANY) {
 			IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
 				      IPSTATS_MIB_INADDRERRORS);
 			break;
 		}
 		/* FALLTHROUGH */
 	case IPSTATS_MIB_OUTNOROUTES:
 		IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
 			      ipstats_mib_noroutes);
 		break;
 	}
 	icmpv6_send(skb, ICMPV6_DEST_UNREACH, code, 0);
 	kfree_skb(skb);
 	return 0;
 }
 static int ip6_pkt_discard(struct sk_buff *skb)
 {
 	return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_INNOROUTES);
 }
 static int ip6_pkt_discard_out(struct sk_buff *skb)
 {
 	skb->dev = skb_dst(skb)->dev;
 	return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_OUTNOROUTES);
 }
 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
 static int ip6_pkt_prohibit(struct sk_buff *skb)
 {
 	return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_INNOROUTES);
 }
 static int ip6_pkt_prohibit_out(struct sk_buff *skb)
 {
 	skb->dev = skb_dst(skb)->dev;
 	return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_OUTNOROUTES);
 }
 #endif
 /*
  *	Allocate a dst for local (unicast / anycast) address.
  */
 struct rt6_info *addrconf_dst_alloc(struct inet6_dev *idev,
 				    const struct in6_addr *addr,
 				    int anycast)
 {
 	struct net *net = dev_net(idev->dev);
 	struct rt6_info *rt = ip6_dst_alloc(&net->ipv6.ip6_dst_ops);
 	struct neighbour *neigh;
 	if (rt == NULL) {
 		if (net_ratelimit())
 			pr_warning("IPv6:  Maximum number of routes reached,"
 				   " consider increasing route/max_size.\n");
 		return ERR_PTR(-ENOMEM);
 	}
 	dev_hold(net->loopback_dev);
 	in6_dev_hold(idev);
 	rt->dst.flags = DST_HOST;
 	rt->dst.input = ip6_input;
 	rt->dst.output = ip6_output;
 	rt->rt6i_dev = net->loopback_dev;
 	rt->rt6i_idev = idev;
 	dst_metric_set(&rt->dst, RTAX_HOPLIMIT, -1);
 	rt->dst.obsolete = -1;
 	rt->rt6i_flags = RTF_UP | RTF_NONEXTHOP;
 	if (anycast)
 		rt->rt6i_flags |= RTF_ANYCAST;
 	else
 		rt->rt6i_flags |= RTF_LOCAL;
 	neigh = ndisc_get_neigh(rt->rt6i_dev, &rt->rt6i_gateway);
 	if (IS_ERR(neigh)) {
 		dst_free(&rt->dst);
 		/* We are casting this because that is the return
 		 * value type.  But an errno encoded pointer is the
 		 * same regardless of the underlying pointer type,
 		 * and that's what we are returning.  So this is OK.
 		 */
 		return (struct rt6_info *) neigh;
 	}
 	rt->rt6i_nexthop = neigh;
 	ipv6_addr_copy(&rt->rt6i_dst.addr, addr);
 	rt->rt6i_dst.plen = 128;
 	rt->rt6i_table = fib6_get_table(net, RT6_TABLE_LOCAL);
 	atomic_set(&rt->dst.__refcnt, 1);
 	return rt;
 }
 struct arg_dev_net {
 	struct net_device *dev;
 	struct net *net;
 };
 static int fib6_ifdown(struct rt6_info *rt, void *arg)
 {
 	const struct arg_dev_net *adn = arg;
 	const struct net_device *dev = adn->dev;
 	if ((rt->rt6i_dev == dev || dev == NULL) &&
 	    rt != adn->net->ipv6.ip6_null_entry) {
 		RT6_TRACE("deleted by ifdown %p\n", rt);
 		return -1;
 	}
 	return 0;
 }
 void rt6_ifdown(struct net *net, struct net_device *dev)
 {
 	struct arg_dev_net adn = {
 		.dev = dev,
 		.net = net,
 	};
 	fib6_clean_all(net, fib6_ifdown, 0, &adn);
 	icmp6_clean_all(fib6_ifdown, &adn);
 }
 struct rt6_mtu_change_arg
 {
 	struct net_device *dev;
 	unsigned mtu;
 };
 static int rt6_mtu_change_route(struct rt6_info *rt, void *p_arg)
 {
 	struct rt6_mtu_change_arg *arg = (struct rt6_mtu_change_arg *) p_arg;
 	struct inet6_dev *idev;
 	/* In IPv6 pmtu discovery is not optional,
 	   so that RTAX_MTU lock cannot disable it.
 	   We still use this lock to block changes
 	   caused by addrconf/ndisc.
 	*/
 	idev = __in6_dev_get(arg->dev);
 	if (idev == NULL)
 		return 0;
 	/* For administrative MTU increase, there is no way to discover
 	   IPv6 PMTU increase, so PMTU increase should be updated here.
 	   Since RFC 1981 doesn't include administrative MTU increase
 	   update PMTU increase is a MUST. (i.e. jumbo frame)
 	 */
 	/*
 	   If new MTU is less than route PMTU, this new MTU will be the
 	   lowest MTU in the path, update the route PMTU to reflect PMTU
 	   decreases; if new MTU is greater than route PMTU, and the
 	   old MTU is the lowest MTU in the path, update the route PMTU
 	   to reflect the increase. In this case if the other nodes' MTU
 	   also have the lowest MTU, TOO BIG MESSAGE will be lead to
 	   PMTU discouvery.
 	 */
 	if (rt->rt6i_dev == arg->dev &&
 	    !dst_metric_locked(&rt->dst, RTAX_MTU) &&
 	    (dst_mtu(&rt->dst) >= arg->mtu ||
 	     (dst_mtu(&rt->dst) < arg->mtu &&
 	      dst_mtu(&rt->dst) == idev->cnf.mtu6))) {
 		dst_metric_set(&rt->dst, RTAX_MTU, arg->mtu);
 	}
 	return 0;
 }
 void rt6_mtu_change(struct net_device *dev, unsigned mtu)
 {
 	struct rt6_mtu_change_arg arg = {
 		.dev = dev,
 		.mtu = mtu,
 	};
 	fib6_clean_all(dev_net(dev), rt6_mtu_change_route, 0, &arg);
 }
 static const struct nla_policy rtm_ipv6_policy[RTA_MAX+1] = {
 	[RTA_GATEWAY]           = { .len = sizeof(struct in6_addr) },
 	[RTA_OIF]               = { .type = NLA_U32 },
 	[RTA_IIF]		= { .type = NLA_U32 },
 	[RTA_PRIORITY]          = { .type = NLA_U32 },
 	[RTA_METRICS]           = { .type = NLA_NESTED },
 };
 static int rtm_to_fib6_config(struct sk_buff *skb, struct nlmsghdr *nlh,
 			      struct fib6_config *cfg)
 {
 	struct rtmsg *rtm;
 	struct nlattr *tb[RTA_MAX+1];
 	int err;
 	err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
 	if (err < 0)
 		goto errout;
 	err = -EINVAL;
 	rtm = nlmsg_data(nlh);
 	memset(cfg, 0, sizeof(*cfg));
 	cfg->fc_table = rtm->rtm_table;
 	cfg->fc_dst_len = rtm->rtm_dst_len;
 	cfg->fc_src_len = rtm->rtm_src_len;
 	cfg->fc_flags = RTF_UP;
 	cfg->fc_protocol = rtm->rtm_protocol;
 	if (rtm->rtm_type == RTN_UNREACHABLE)
 		cfg->fc_flags |= RTF_REJECT;
 	if (rtm->rtm_type == RTN_LOCAL)
 		cfg->fc_flags |= RTF_LOCAL;
 	cfg->fc_nlinfo.pid = NETLINK_CB(skb).pid;
 	cfg->fc_nlinfo.nlh = nlh;
 	cfg->fc_nlinfo.nl_net = sock_net(skb->sk);
 	if (tb[RTA_GATEWAY]) {
 		nla_memcpy(&cfg->fc_gateway, tb[RTA_GATEWAY], 16);
 		cfg->fc_flags |= RTF_GATEWAY;
 	}
 	if (tb[RTA_DST]) {
 		int plen = (rtm->rtm_dst_len + 7) >> 3;
 		if (nla_len(tb[RTA_DST]) < plen)
 			goto errout;
 		nla_memcpy(&cfg->fc_dst, tb[RTA_DST], plen);
 	}
 	if (tb[RTA_SRC]) {
 		int plen = (rtm->rtm_src_len + 7) >> 3;
 		if (nla_len(tb[RTA_SRC]) < plen)
 			goto errout;
 		nla_memcpy(&cfg->fc_src, tb[RTA_SRC], plen);
 	}
 	if (tb[RTA_OIF])
 		cfg->fc_ifindex = nla_get_u32(tb[RTA_OIF]);
 	if (tb[RTA_PRIORITY])
 		cfg->fc_metric = nla_get_u32(tb[RTA_PRIORITY]);
 	if (tb[RTA_METRICS]) {
 		cfg->fc_mx = nla_data(tb[RTA_METRICS]);
 		cfg->fc_mx_len = nla_len(tb[RTA_METRICS]);
 	}
 	if (tb[RTA_TABLE])
 		cfg->fc_table = nla_get_u32(tb[RTA_TABLE]);
 	err = 0;
 errout:
 	return err;
 }
 static int inet6_rtm_delroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
 {
 	struct fib6_config cfg;
 	int err;
 	err = rtm_to_fib6_config(skb, nlh, &cfg);
 	if (err < 0)
 		return err;
 	return ip6_route_del(&cfg);
 }
 static int inet6_rtm_newroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
 {
 	struct fib6_config cfg;
 	int err;
 	err = rtm_to_fib6_config(skb, nlh, &cfg);
 	if (err < 0)
 		return err;
 	return ip6_route_add(&cfg);
 }
 static inline size_t rt6_nlmsg_size(void)
 {
 	return NLMSG_ALIGN(sizeof(struct rtmsg))
 	       + nla_total_size(16) /* RTA_SRC */
 	       + nla_total_size(16) /* RTA_DST */
 	       + nla_total_size(16) /* RTA_GATEWAY */
 	       + nla_total_size(16) /* RTA_PREFSRC */
 	       + nla_total_size(4) /* RTA_TABLE */
 	       + nla_total_size(4) /* RTA_IIF */
 	       + nla_total_size(4) /* RTA_OIF */
 	       + nla_total_size(4) /* RTA_PRIORITY */
 	       + RTAX_MAX * nla_total_size(4) /* RTA_METRICS */
 	       + nla_total_size(sizeof(struct rta_cacheinfo));
 }
 static int rt6_fill_node(struct net *net,
 			 struct sk_buff *skb, struct rt6_info *rt,
 			 struct in6_addr *dst, struct in6_addr *src,
 			 int iif, int type, u32 pid, u32 seq,
 			 int prefix, int nowait, unsigned int flags)
 {
 	struct rtmsg *rtm;
 	struct nlmsghdr *nlh;
 	long expires;
 	u32 table;
 	if (prefix) {	/* user wants prefix routes only */
 		if (!(rt->rt6i_flags & RTF_PREFIX_RT)) {
 			/* success since this is not a prefix route */
 			return 1;
 		}
 	}
 	nlh = nlmsg_put(skb, pid, seq, type, sizeof(*rtm), flags);
 	if (nlh == NULL)
 		return -EMSGSIZE;
 	rtm = nlmsg_data(nlh);
 	rtm->rtm_family = AF_INET6;
 	rtm->rtm_dst_len = rt->rt6i_dst.plen;
 	rtm->rtm_src_len = rt->rt6i_src.plen;
 	rtm->rtm_tos = 0;
 	if (rt->rt6i_table)
 		table = rt->rt6i_table->tb6_id;
 	else
 		table = RT6_TABLE_UNSPEC;
 	rtm->rtm_table = table;
 	NLA_PUT_U32(skb, RTA_TABLE, table);
 	if (rt->rt6i_flags&RTF_REJECT)
 		rtm->rtm_type = RTN_UNREACHABLE;
 	else if (rt->rt6i_flags&RTF_LOCAL)
 		rtm->rtm_type = RTN_LOCAL;
 	else if (rt->rt6i_dev && (rt->rt6i_dev->flags&IFF_LOOPBACK))
 		rtm->rtm_type = RTN_LOCAL;
 	else
 		rtm->rtm_type = RTN_UNICAST;
 	rtm->rtm_flags = 0;
 	rtm->rtm_scope = RT_SCOPE_UNIVERSE;
 	rtm->rtm_protocol = rt->rt6i_protocol;
 	if (rt->rt6i_flags&RTF_DYNAMIC)
 		rtm->rtm_protocol = RTPROT_REDIRECT;
 	else if (rt->rt6i_flags & RTF_ADDRCONF)
 		rtm->rtm_protocol = RTPROT_KERNEL;
 	else if (rt->rt6i_flags&RTF_DEFAULT)
 		rtm->rtm_protocol = RTPROT_RA;
 	if (rt->rt6i_flags&RTF_CACHE)
 		rtm->rtm_flags |= RTM_F_CLONED;
 	if (dst) {
 		NLA_PUT(skb, RTA_DST, 16, dst);
 		rtm->rtm_dst_len = 128;
 	} else if (rtm->rtm_dst_len)
 		NLA_PUT(skb, RTA_DST, 16, &rt->rt6i_dst.addr);
 #ifdef CONFIG_IPV6_SUBTREES
 	if (src) {
 		NLA_PUT(skb, RTA_SRC, 16, src);
 		rtm->rtm_src_len = 128;
 	} else if (rtm->rtm_src_len)
 		NLA_PUT(skb, RTA_SRC, 16, &rt->rt6i_src.addr);
 #endif
 	if (iif) {
 #ifdef CONFIG_IPV6_MROUTE
 		if (ipv6_addr_is_multicast(&rt->rt6i_dst.addr)) {
 			int err = ip6mr_get_route(net, skb, rtm, nowait);
 			if (err <= 0) {
 				if (!nowait) {
 					if (err == 0)
 						return 0;
 					goto nla_put_failure;
 				} else {
 					if (err == -EMSGSIZE)
 						goto nla_put_failure;
 				}
 			}
 		} else
 #endif
 			NLA_PUT_U32(skb, RTA_IIF, iif);
 	} else if (dst) {
 		struct inet6_dev *idev = ip6_dst_idev(&rt->dst);
 		struct in6_addr saddr_buf;
 		if (ipv6_dev_get_saddr(net, idev ? idev->dev : NULL,
 				       dst, 0, &saddr_buf) == 0)
 			NLA_PUT(skb, RTA_PREFSRC, 16, &saddr_buf);
 	}
 	if (rtnetlink_put_metrics(skb, dst_metrics_ptr(&rt->dst)) < 0)
 		goto nla_put_failure;
 	if (rt->dst.neighbour)
 		NLA_PUT(skb, RTA_GATEWAY, 16, &rt->dst.neighbour->primary_key);
 	if (rt->dst.dev)
 		NLA_PUT_U32(skb, RTA_OIF, rt->rt6i_dev->ifindex);
 	NLA_PUT_U32(skb, RTA_PRIORITY, rt->rt6i_metric);
 	if (!(rt->rt6i_flags & RTF_EXPIRES))
 		expires = 0;
 	else if (rt->rt6i_expires - jiffies < INT_MAX)
 		expires = rt->rt6i_expires - jiffies;
 	else
 		expires = INT_MAX;
 	if (rtnl_put_cacheinfo(skb, &rt->dst, 0, 0, 0,
 			       expires, rt->dst.error) < 0)
 		goto nla_put_failure;
 	return nlmsg_end(skb, nlh);
 nla_put_failure:
 	nlmsg_cancel(skb, nlh);
 	return -EMSGSIZE;
 }
 int rt6_dump_route(struct rt6_info *rt, void *p_arg)
 {
 	struct rt6_rtnl_dump_arg *arg = (struct rt6_rtnl_dump_arg *) p_arg;
 	int prefix;
 	if (nlmsg_len(arg->cb->nlh) >= sizeof(struct rtmsg)) {
 		struct rtmsg *rtm = nlmsg_data(arg->cb->nlh);
 		prefix = (rtm->rtm_flags & RTM_F_PREFIX) != 0;
 	} else
 		prefix = 0;
 	return rt6_fill_node(arg->net,
 		     arg->skb, rt, NULL, NULL, 0, RTM_NEWROUTE,
 		     NETLINK_CB(arg->cb->skb).pid, arg->cb->nlh->nlmsg_seq,
 		     prefix, 0, NLM_F_MULTI);
 }
 static int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr* nlh, void *arg)
 {
 	struct net *net = sock_net(in_skb->sk);
 	struct nlattr *tb[RTA_MAX+1];
 	struct rt6_info *rt;
 	struct sk_buff *skb;
 	struct rtmsg *rtm;
 	struct flowi fl;
 	int err, iif = 0;
 	err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
 	if (err < 0)
 		goto errout;
 	err = -EINVAL;
 	memset(&fl, 0, sizeof(fl));
 	if (tb[RTA_SRC]) {
 		if (nla_len(tb[RTA_SRC]) < sizeof(struct in6_addr))
 			goto errout;
 		ipv6_addr_copy(&fl.fl6_src, nla_data(tb[RTA_SRC]));
 	}
 	if (tb[RTA_DST]) {
 		if (nla_len(tb[RTA_DST]) < sizeof(struct in6_addr))
 			goto errout;
 		ipv6_addr_copy(&fl.fl6_dst, nla_data(tb[RTA_DST]));
 	}
 	if (tb[RTA_IIF])
 		iif = nla_get_u32(tb[RTA_IIF]);
 	if (tb[RTA_OIF])
 		fl.oif = nla_get_u32(tb[RTA_OIF]);
 	if (iif) {
 		struct net_device *dev;
 		dev = __dev_get_by_index(net, iif);
 		if (!dev) {
 			err = -ENODEV;
 			goto errout;
 		}
 	}
 	skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
 	if (skb == NULL) {
 		err = -ENOBUFS;
 		goto errout;
 	}
 	/* Reserve room for dummy headers, this skb can pass
 	   through good chunk of routing engine.
 	 */
 	skb_reset_mac_header(skb);
 	skb_reserve(skb, MAX_HEADER + sizeof(struct ipv6hdr));
 	rt = (struct rt6_info*) ip6_route_output(net, NULL, &fl);
 	skb_dst_set(skb, &rt->dst);
 	err = rt6_fill_node(net, skb, rt, &fl.fl6_dst, &fl.fl6_src, iif,
 			    RTM_NEWROUTE, NETLINK_CB(in_skb).pid,
 			    nlh->nlmsg_seq, 0, 0, 0);
 	if (err < 0) {
 		kfree_skb(skb);
 		goto errout;
 	}
 	err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).pid);
 errout:
 	return err;
 }
 void inet6_rt_notify(int event, struct rt6_info *rt, struct nl_info *info)
 {
 	struct sk_buff *skb;
 	struct net *net = info->nl_net;
 	u32 seq;
 	int err;
 	err = -ENOBUFS;
 	seq = info->nlh != NULL ? info->nlh->nlmsg_seq : 0;
 	skb = nlmsg_new(rt6_nlmsg_size(), gfp_any());
 	if (skb == NULL)
 		goto errout;
 	err = rt6_fill_node(net, skb, rt, NULL, NULL, 0,
 				event, info->pid, seq, 0, 0, 0);
 	if (err < 0) {
 		/* -EMSGSIZE implies BUG in rt6_nlmsg_size() */
 		WARN_ON(err == -EMSGSIZE);
 		kfree_skb(skb);
 		goto errout;
 	}
 	rtnl_notify(skb, net, info->pid, RTNLGRP_IPV6_ROUTE,
 		    info->nlh, gfp_any());
 	return;
 errout:
 	if (err < 0)
 		rtnl_set_sk_err(net, RTNLGRP_IPV6_ROUTE, err);
 }
 static int ip6_route_dev_notify(struct notifier_block *this,
 				unsigned long event, void *data)
 {
 	struct net_device *dev = (struct net_device *)data;
 	struct net *net = dev_net(dev);
 	if (event == NETDEV_REGISTER && (dev->flags & IFF_LOOPBACK)) {
 		net->ipv6.ip6_null_entry->dst.dev = dev;
 		net->ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(dev);
 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
 		net->ipv6.ip6_prohibit_entry->dst.dev = dev;
 		net->ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(dev);
 		net->ipv6.ip6_blk_hole_entry->dst.dev = dev;
 		net->ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(dev);
 #endif
 	}
 	return NOTIFY_OK;
 }
 /*
  *	/proc
  */
 #ifdef CONFIG_PROC_FS
 struct rt6_proc_arg
 {
 	char *buffer;
 	int offset;
 	int length;
 	int skip;
 	int len;
 };
 static int rt6_info_route(struct rt6_info *rt, void *p_arg)
 {
 	struct seq_file *m = p_arg;
 	seq_printf(m, "%pi6 %02x ", &rt->rt6i_dst.addr, rt->rt6i_dst.plen);
 #ifdef CONFIG_IPV6_SUBTREES
 	seq_printf(m, "%pi6 %02x ", &rt->rt6i_src.addr, rt->rt6i_src.plen);
 #else
 	seq_puts(m, "00000000000000000000000000000000 00 ");
 #endif
 	if (rt->rt6i_nexthop) {
 		seq_printf(m, "%pi6", rt->rt6i_nexthop->primary_key);
 	} else {
 		seq_puts(m, "00000000000000000000000000000000");
 	}
 	seq_printf(m, " %08x %08x %08x %08x %8s\n",
 		   rt->rt6i_metric, atomic_read(&rt->dst.__refcnt),
 		   rt->dst.__use, rt->rt6i_flags,
 		   rt->rt6i_dev ? rt->rt6i_dev->name : "");
 	return 0;
 }
 static int ipv6_route_show(struct seq_file *m, void *v)
 {
 	struct net *net = (struct net *)m->private;
 	fib6_clean_all(net, rt6_info_route, 0, m);
 	return 0;
 }
 static int ipv6_route_open(struct inode *inode, struct file *file)
 {
 	return single_open_net(inode, file, ipv6_route_show);
 }
 static const struct file_operations ipv6_route_proc_fops = {
 	.owner		= THIS_MODULE,
 	.open		= ipv6_route_open,
 	.read		= seq_read,
 	.llseek		= seq_lseek,
 	.release	= single_release_net,
 };
 static int rt6_stats_seq_show(struct seq_file *seq, void *v)
 {
 	struct net *net = (struct net *)seq->private;
 	seq_printf(seq, "%04x %04x %04x %04x %04x %04x %04x\n",
 		   net->ipv6.rt6_stats->fib_nodes,
 		   net->ipv6.rt6_stats->fib_route_nodes,
 		   net->ipv6.rt6_stats->fib_rt_alloc,
 		   net->ipv6.rt6_stats->fib_rt_entries,
 		   net->ipv6.rt6_stats->fib_rt_cache,
 		   dst_entries_get_slow(&net->ipv6.ip6_dst_ops),
 		   net->ipv6.rt6_stats->fib_discarded_routes);
 	return 0;
 }
 static int rt6_stats_seq_open(struct inode *inode, struct file *file)
 {
 	return single_open_net(inode, file, rt6_stats_seq_show);
 }
 static const struct file_operations rt6_stats_seq_fops = {
 	.owner	 = THIS_MODULE,
 	.open	 = rt6_stats_seq_open,
 	.read	 = seq_read,
 	.llseek	 = seq_lseek,
 	.release = single_release_net,
 };
 #endif	/* CONFIG_PROC_FS */
 #ifdef CONFIG_SYSCTL
 static
 int ipv6_sysctl_rtcache_flush(ctl_table *ctl, int write,
 			      void __user *buffer, size_t *lenp, loff_t *ppos)
 {
-	struct net *net = current->nsproxy->net_ns;
+	struct net *net;
-	int delay = net->ipv6.sysctl.flush_delay;
+	int delay;
-	if (write) {
+	if (!write)
-		proc_dointvec(ctl, write, buffer, lenp, ppos);
-		fib6_run_gc(delay <= 0 ? ~0UL : (unsigned long)delay, net);
-		return 0;
-	} else
 		return -EINVAL;
+	net = (struct net *)ctl->extra1;
+	delay = net->ipv6.sysctl.flush_delay;
+	proc_dointvec(ctl, write, buffer, lenp, ppos);
+	fib6_run_gc(delay <= 0 ? ~0UL : (unsigned long)delay, net);
+	return 0;
 }
 ctl_table ipv6_route_table_template[] = {
 	{
 		.procname	=	"flush",
 		.data		=	&init_net.ipv6.sysctl.flush_delay,
 		.maxlen		=	sizeof(int),
 		.mode		=	0200,
 		.proc_handler	=	ipv6_sysctl_rtcache_flush
 	},
 	{
 		.procname	=	"gc_thresh",
 		.data		=	&ip6_dst_ops_template.gc_thresh,
 		.maxlen		=	sizeof(int),
 		.mode		=	0644,
 		.proc_handler	=	proc_dointvec,
 	},
 	{
 		.procname	=	"max_size",
 		.data		=	&init_net.ipv6.sysctl.ip6_rt_max_size,
 		.maxlen		=	sizeof(int),
 		.mode		=	0644,
 		.proc_handler	=	proc_dointvec,
 	},
 	{
 		.procname	=	"gc_min_interval",
 		.data		=	&init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
 		.maxlen		=	sizeof(int),
 		.mode		=	0644,
 		.proc_handler	=	proc_dointvec_jiffies,
 	},
 	{
 		.procname	=	"gc_timeout",
 		.data		=	&init_net.ipv6.sysctl.ip6_rt_gc_timeout,
 		.maxlen		=	sizeof(int),
 		.mode		=	0644,
 		.proc_handler	=	proc_dointvec_jiffies,
 	},
 	{
 		.procname	=	"gc_interval",
 		.data		=	&init_net.ipv6.sysctl.ip6_rt_gc_interval,
 		.maxlen		=	sizeof(int),
 		.mode		=	0644,
 		.proc_handler	=	proc_dointvec_jiffies,
 	},
 	{
 		.procname	=	"gc_elasticity",
 		.data		=	&init_net.ipv6.sysctl.ip6_rt_gc_elasticity,
 		.maxlen		=	sizeof(int),
 		.mode		=	0644,
 		.proc_handler	=	proc_dointvec,
 	},
 	{
 		.procname	=	"mtu_expires",
 		.data		=	&init_net.ipv6.sysctl.ip6_rt_mtu_expires,
 		.maxlen		=	sizeof(int),
 		.mode		=	0644,
 		.proc_handler	=	proc_dointvec_jiffies,
 	},
 	{
 		.procname	=	"min_adv_mss",
 		.data		=	&init_net.ipv6.sysctl.ip6_rt_min_advmss,
 		.maxlen		=	sizeof(int),
 		.mode		=	0644,
 		.proc_handler	=	proc_dointvec,
 	},
 	{
 		.procname	=	"gc_min_interval_ms",
 		.data		=	&init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
 		.maxlen		=	sizeof(int),
 		.mode		=	0644,
 		.proc_handler	=	proc_dointvec_ms_jiffies,
 	},
 	{ }
 };
 struct ctl_table * __net_init ipv6_route_sysctl_init(struct net *net)
 {
 	struct ctl_table *table;
 	table = kmemdup(ipv6_route_table_template,
 			sizeof(ipv6_route_table_template),
 			GFP_KERNEL);
 	if (table) {
 		table[0].data = &net->ipv6.sysctl.flush_delay;
+		table[0].extra1 = net;
 		table[1].data = &net->ipv6.ip6_dst_ops.gc_thresh;
 		table[2].data = &net->ipv6.sysctl.ip6_rt_max_size;
 		table[3].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
 		table[4].data = &net->ipv6.sysctl.ip6_rt_gc_timeout;
 		table[5].data = &net->ipv6.sysctl.ip6_rt_gc_interval;
 		table[6].data = &net->ipv6.sysctl.ip6_rt_gc_elasticity;
 		table[7].data = &net->ipv6.sysctl.ip6_rt_mtu_expires;
 		table[8].data = &net->ipv6.sysctl.ip6_rt_min_advmss;
 		table[9].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
 	}
 	return table;
 }
 #endif
 static int __net_init ip6_route_net_init(struct net *net)
 {
 	int ret = -ENOMEM;
 	memcpy(&net->ipv6.ip6_dst_ops, &ip6_dst_ops_template,
 	       sizeof(net->ipv6.ip6_dst_ops));
 	if (dst_entries_init(&net->ipv6.ip6_dst_ops) < 0)
 		goto out_ip6_dst_ops;
 	net->ipv6.ip6_null_entry = kmemdup(&ip6_null_entry_template,
 					   sizeof(*net->ipv6.ip6_null_entry),
 					   GFP_KERNEL);
 	if (!net->ipv6.ip6_null_entry)
 		goto out_ip6_dst_entries;
 	net->ipv6.ip6_null_entry->dst.path =
 		(struct dst_entry *)net->ipv6.ip6_null_entry;
 	net->ipv6.ip6_null_entry->dst.ops = &net->ipv6.ip6_dst_ops;
 	dst_metric_set(&net->ipv6.ip6_null_entry->dst, RTAX_HOPLIMIT, 255);
 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
 	net->ipv6.ip6_prohibit_entry = kmemdup(&ip6_prohibit_entry_template,
 					       sizeof(*net->ipv6.ip6_prohibit_entry),
 					       GFP_KERNEL);
 	if (!net->ipv6.ip6_prohibit_entry)
 		goto out_ip6_null_entry;
 	net->ipv6.ip6_prohibit_entry->dst.path =
 		(struct dst_entry *)net->ipv6.ip6_prohibit_entry;
 	net->ipv6.ip6_prohibit_entry->dst.ops = &net->ipv6.ip6_dst_ops;
 	dst_metric_set(&net->ipv6.ip6_prohibit_entry->dst, RTAX_HOPLIMIT, 255);
 	net->ipv6.ip6_blk_hole_entry = kmemdup(&ip6_blk_hole_entry_template,
 					       sizeof(*net->ipv6.ip6_blk_hole_entry),
 					       GFP_KERNEL);
 	if (!net->ipv6.ip6_blk_hole_entry)
 		goto out_ip6_prohibit_entry;
 	net->ipv6.ip6_blk_hole_entry->dst.path =
 		(struct dst_entry *)net->ipv6.ip6_blk_hole_entry;
 	net->ipv6.ip6_blk_hole_entry->dst.ops = &net->ipv6.ip6_dst_ops;
 	dst_metric_set(&net->ipv6.ip6_blk_hole_entry->dst, RTAX_HOPLIMIT, 255);
 #endif
 	net->ipv6.sysctl.flush_delay = 0;
 	net->ipv6.sysctl.ip6_rt_max_size = 4096;
 	net->ipv6.sysctl.ip6_rt_gc_min_interval = HZ / 2;
 	net->ipv6.sysctl.ip6_rt_gc_timeout = 60*HZ;
 	net->ipv6.sysctl.ip6_rt_gc_interval = 30*HZ;
 	net->ipv6.sysctl.ip6_rt_gc_elasticity = 9;
 	net->ipv6.sysctl.ip6_rt_mtu_expires = 10*60*HZ;
 	net->ipv6.sysctl.ip6_rt_min_advmss = IPV6_MIN_MTU - 20 - 40;
 #ifdef CONFIG_PROC_FS
 	proc_net_fops_create(net, "ipv6_route", 0, &ipv6_route_proc_fops);
 	proc_net_fops_create(net, "rt6_stats", S_IRUGO, &rt6_stats_seq_fops);
 #endif
 	net->ipv6.ip6_rt_gc_expire = 30*HZ;
 	ret = 0;
 out:
 	return ret;
 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
 out_ip6_prohibit_entry:
 	kfree(net->ipv6.ip6_prohibit_entry);
 out_ip6_null_entry:
 	kfree(net->ipv6.ip6_null_entry);
 #endif
 out_ip6_dst_entries:
 	dst_entries_destroy(&net->ipv6.ip6_dst_ops);
 out_ip6_dst_ops:
 	goto out;
 }
 static void __net_exit ip6_route_net_exit(struct net *net)
 {
 #ifdef CONFIG_PROC_FS
 	proc_net_remove(net, "ipv6_route");
 	proc_net_remove(net, "rt6_stats");
 #endif
 	kfree(net->ipv6.ip6_null_entry);
 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
 	kfree(net->ipv6.ip6_prohibit_entry);
 	kfree(net->ipv6.ip6_blk_hole_entry);
 #endif
 	dst_entries_destroy(&net->ipv6.ip6_dst_ops);
 }
 static struct pernet_operations ip6_route_net_ops = {
 	.init = ip6_route_net_init,
 	.exit = ip6_route_net_exit,
 };
 static struct notifier_block ip6_route_dev_notifier = {
 	.notifier_call = ip6_route_dev_notify,
 	.priority = 0,
 };
 int __init ip6_route_init(void)
 {
 	int ret;
 	ret = -ENOMEM;
 	ip6_dst_ops_template.kmem_cachep =
 		kmem_cache_create("ip6_dst_cache", sizeof(struct rt6_info), 0,
 				  SLAB_HWCACHE_ALIGN, NULL);
 	if (!ip6_dst_ops_template.kmem_cachep)
 		goto out;
 	ret = dst_entries_init(&ip6_dst_blackhole_ops);
 	if (ret)
 		goto out_kmem_cache;
 	ret = register_pernet_subsys(&ip6_route_net_ops);
 	if (ret)
 		goto out_dst_entries;
 	ip6_dst_blackhole_ops.kmem_cachep = ip6_dst_ops_template.kmem_cachep;
 	/* Registering of the loopback is done before this portion of code,
 	 * the loopback reference in rt6_info will not be taken, do it
 	 * manually for init_net */
 	init_net.ipv6.ip6_null_entry->dst.dev = init_net.loopback_dev;
 	init_net.ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
   #ifdef CONFIG_IPV6_MULTIPLE_TABLES
 	init_net.ipv6.ip6_prohibit_entry->dst.dev = init_net.loopback_dev;
 	init_net.ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
 	init_net.ipv6.ip6_blk_hole_entry->dst.dev = init_net.loopback_dev;
 	init_net.ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
   #endif
 	ret = fib6_init();
 	if (ret)
 		goto out_register_subsys;
 	ret = xfrm6_init();
 	if (ret)
 		goto out_fib6_init;
 	ret = fib6_rules_init();
 	if (ret)
 		goto xfrm6_init;
 	ret = -ENOBUFS;
 	if (__rtnl_register(PF_INET6, RTM_NEWROUTE, inet6_rtm_newroute, NULL) ||
 	    __rtnl_register(PF_INET6, RTM_DELROUTE, inet6_rtm_delroute, NULL) ||
 	    __rtnl_register(PF_INET6, RTM_GETROUTE, inet6_rtm_getroute, NULL))
 		goto fib6_rules_init;
 	ret = register_netdevice_notifier(&ip6_route_dev_notifier);
 	if (ret)
 		goto fib6_rules_init;
 out:
 	return ret;
 fib6_rules_init:
 	fib6_rules_cleanup();
 xfrm6_init:
 	xfrm6_fini();
 out_fib6_init:
 	fib6_gc_cleanup();
 out_register_subsys:
 	unregister_pernet_subsys(&ip6_route_net_ops);
 out_dst_entries:
 	dst_entries_destroy(&ip6_dst_blackhole_ops);
 out_kmem_cache:
 	kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
 	goto out;
 }
 void ip6_route_cleanup(void)
 {
 	unregister_netdevice_notifier(&ip6_route_dev_notifier);
 	fib6_rules_cleanup();
 	xfrm6_fini();
 	fib6_gc_cleanup();
 	unregister_pernet_subsys(&ip6_route_net_ops);