Eric Lee / smarc-ti-linux-kernel

1

/*

1

/*

2

* GRE over IPv6 protocol decoder.

2

* GRE over IPv6 protocol decoder.

3

*

3

*

4

* Authors: Dmitry Kozlov (xeb@mail.ru)

4

* Authors: Dmitry Kozlov (xeb@mail.ru)

5

*

5

*

6

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

6

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

7

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

7

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

8

* as published by the Free Software Foundation; either version

8

* as published by the Free Software Foundation; either version

9

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

9

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

10

*

10

*

11

*/

11

*/

12

13

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

13

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

14

15

#include <linux/capability.h>

15

#include <linux/capability.h>

16

#include <linux/module.h>

16

#include <linux/module.h>

17

#include <linux/types.h>

17

#include <linux/types.h>

18

#include <linux/kernel.h>

18

#include <linux/kernel.h>

19

#include <linux/slab.h>

19

#include <linux/slab.h>

20

#include <linux/uaccess.h>

20

#include <linux/uaccess.h>

21

#include <linux/skbuff.h>

21

#include <linux/skbuff.h>

22

#include <linux/netdevice.h>

22

#include <linux/netdevice.h>

23

#include <linux/in.h>

23

#include <linux/in.h>

24

#include <linux/tcp.h>

24

#include <linux/tcp.h>

25

#include <linux/udp.h>

25

#include <linux/udp.h>

26

#include <linux/if_arp.h>

26

#include <linux/if_arp.h>

27

#include <linux/mroute.h>

27

#include <linux/mroute.h>

28

#include <linux/init.h>

28

#include <linux/init.h>

29

#include <linux/in6.h>

29

#include <linux/in6.h>

30

#include <linux/inetdevice.h>

30

#include <linux/inetdevice.h>

31

#include <linux/igmp.h>

31

#include <linux/igmp.h>

32

#include <linux/netfilter_ipv4.h>

32

#include <linux/netfilter_ipv4.h>

33

#include <linux/etherdevice.h>

33

#include <linux/etherdevice.h>

34

#include <linux/if_ether.h>

34

#include <linux/if_ether.h>

35

#include <linux/hash.h>

35

#include <linux/hash.h>

36

#include <linux/if_tunnel.h>

36

#include <linux/if_tunnel.h>

37

#include <linux/ip6_tunnel.h>

37

#include <linux/ip6_tunnel.h>

38

39

#include <net/sock.h>

39

#include <net/sock.h>

40

#include <net/ip.h>

40

#include <net/ip.h>

41

#include <net/ip_tunnels.h>

41

#include <net/ip_tunnels.h>

42

#include <net/icmp.h>

42

#include <net/icmp.h>

43

#include <net/protocol.h>

43

#include <net/protocol.h>

44

#include <net/addrconf.h>

44

#include <net/addrconf.h>

45

#include <net/arp.h>

45

#include <net/arp.h>

46

#include <net/checksum.h>

46

#include <net/checksum.h>

47

#include <net/dsfield.h>

47

#include <net/dsfield.h>

48

#include <net/inet_ecn.h>

48

#include <net/inet_ecn.h>

49

#include <net/xfrm.h>

49

#include <net/xfrm.h>

50

#include <net/net_namespace.h>

50

#include <net/net_namespace.h>

51

#include <net/netns/generic.h>

51

#include <net/netns/generic.h>

52

#include <net/rtnetlink.h>

52

#include <net/rtnetlink.h>

53

54

#include <net/ipv6.h>

54

#include <net/ipv6.h>

55

#include <net/ip6_fib.h>

55

#include <net/ip6_fib.h>

56

#include <net/ip6_route.h>

56

#include <net/ip6_route.h>

57

#include <net/ip6_tunnel.h>

57

#include <net/ip6_tunnel.h>

58

59

60

static bool log_ecn_error = true;

60

static bool log_ecn_error = true;

61

module_param(log_ecn_error, bool, 0644);

61

module_param(log_ecn_error, bool, 0644);

62

MODULE_PARM_DESC(log_ecn_error, "Log packets received with corrupted ECN");

62

MODULE_PARM_DESC(log_ecn_error, "Log packets received with corrupted ECN");

63

64

#define HASH_SIZE_SHIFT 5

64

#define HASH_SIZE_SHIFT 5

65

#define HASH_SIZE (1 << HASH_SIZE_SHIFT)

65

#define HASH_SIZE (1 << HASH_SIZE_SHIFT)

66

67

static int ip6gre_net_id __read_mostly;

67

static int ip6gre_net_id __read_mostly;

68

struct ip6gre_net {

68

struct ip6gre_net {

69

struct ip6_tnl __rcu *tunnels[4][HASH_SIZE];

69

struct ip6_tnl __rcu *tunnels[4][HASH_SIZE];

70

71

struct net_device *fb_tunnel_dev;

71

struct net_device *fb_tunnel_dev;

72

};

72

};

73

74

static struct rtnl_link_ops ip6gre_link_ops __read_mostly;

74

static struct rtnl_link_ops ip6gre_link_ops __read_mostly;

75

static int ip6gre_tunnel_init(struct net_device *dev);

75

static int ip6gre_tunnel_init(struct net_device *dev);

76

static void ip6gre_tunnel_setup(struct net_device *dev);

76

static void ip6gre_tunnel_setup(struct net_device *dev);

77

static void ip6gre_tunnel_link(struct ip6gre_net *ign, struct ip6_tnl *t);

77

static void ip6gre_tunnel_link(struct ip6gre_net *ign, struct ip6_tnl *t);

78

static void ip6gre_tnl_link_config(struct ip6_tnl *t, int set_mtu);

78

static void ip6gre_tnl_link_config(struct ip6_tnl *t, int set_mtu);

79

80

/* Tunnel hash table */

80

/* Tunnel hash table */

81

82

/*

82

/*

83

4 hash tables:

83

4 hash tables:

84

85

3: (remote,local)

85

3: (remote,local)

86

2: (remote,*)

86

2: (remote,*)

87

1: (*,local)

87

1: (*,local)

88

0: (*,*)

88

0: (*,*)

89

90

We require exact key match i.e. if a key is present in packet

90

We require exact key match i.e. if a key is present in packet

91

it will match only tunnel with the same key; if it is not present,

91

it will match only tunnel with the same key; if it is not present,

92

it will match only keyless tunnel.

92

it will match only keyless tunnel.

93

94

All keysless packets, if not matched configured keyless tunnels

94

All keysless packets, if not matched configured keyless tunnels

95

will match fallback tunnel.

95

will match fallback tunnel.

96

*/

96

*/

97

98

#define HASH_KEY(key) (((__force u32)key^((__force u32)key>>4))&(HASH_SIZE - 1))

98

#define HASH_KEY(key) (((__force u32)key^((__force u32)key>>4))&(HASH_SIZE - 1))

99

static u32 HASH_ADDR(const struct in6_addr *addr)

99

static u32 HASH_ADDR(const struct in6_addr *addr)

100

{

100

{

101

u32 hash = ipv6_addr_hash(addr);

101

u32 hash = ipv6_addr_hash(addr);

102

103

return hash_32(hash, HASH_SIZE_SHIFT);

103

return hash_32(hash, HASH_SIZE_SHIFT);

104

}

104

}

105

106

#define tunnels_r_l tunnels[3]

106

#define tunnels_r_l tunnels[3]

107

#define tunnels_r tunnels[2]

107

#define tunnels_r tunnels[2]

108

#define tunnels_l tunnels[1]

108

#define tunnels_l tunnels[1]

109

#define tunnels_wc tunnels[0]

109

#define tunnels_wc tunnels[0]

110

111

/* Given src, dst and key, find appropriate for input tunnel. */

111

/* Given src, dst and key, find appropriate for input tunnel. */

112

113

static struct ip6_tnl *ip6gre_tunnel_lookup(struct net_device *dev,

113

static struct ip6_tnl *ip6gre_tunnel_lookup(struct net_device *dev,

114

const struct in6_addr *remote, const struct in6_addr *local,

114

const struct in6_addr *remote, const struct in6_addr *local,

115

__be32 key, __be16 gre_proto)

115

__be32 key, __be16 gre_proto)

116

{

116

{

117

struct net *net = dev_net(dev);

117

struct net *net = dev_net(dev);

118

int link = dev->ifindex;

118

int link = dev->ifindex;

119

unsigned int h0 = HASH_ADDR(remote);

119

unsigned int h0 = HASH_ADDR(remote);

120

unsigned int h1 = HASH_KEY(key);

120

unsigned int h1 = HASH_KEY(key);

121

struct ip6_tnl *t, *cand = NULL;

121

struct ip6_tnl *t, *cand = NULL;

122

struct ip6gre_net *ign = net_generic(net, ip6gre_net_id);

122

struct ip6gre_net *ign = net_generic(net, ip6gre_net_id);

123

int dev_type = (gre_proto == htons(ETH_P_TEB)) ?

123

int dev_type = (gre_proto == htons(ETH_P_TEB)) ?

124

ARPHRD_ETHER : ARPHRD_IP6GRE;

124

ARPHRD_ETHER : ARPHRD_IP6GRE;

125

int score, cand_score = 4;

125

int score, cand_score = 4;

126

127

for_each_ip_tunnel_rcu(t, ign->tunnels_r_l[h0 ^ h1]) {

127

for_each_ip_tunnel_rcu(t, ign->tunnels_r_l[h0 ^ h1]) {

128

if (!ipv6_addr_equal(local, &t->parms.laddr) ||

128

if (!ipv6_addr_equal(local, &t->parms.laddr) ||

129

!ipv6_addr_equal(remote, &t->parms.raddr) ||

129

!ipv6_addr_equal(remote, &t->parms.raddr) ||

130

key != t->parms.i_key ||

130

key != t->parms.i_key ||

131

!(t->dev->flags & IFF_UP))

131

!(t->dev->flags & IFF_UP))

132

continue;

132

continue;

133

134

if (t->dev->type != ARPHRD_IP6GRE &&

134

if (t->dev->type != ARPHRD_IP6GRE &&

135

t->dev->type != dev_type)

135

t->dev->type != dev_type)

136

continue;

136

continue;

137

138

score = 0;

138

score = 0;

139

if (t->parms.link != link)

139

if (t->parms.link != link)

140

score |= 1;

140

score |= 1;

141

if (t->dev->type != dev_type)

141

if (t->dev->type != dev_type)

142

score |= 2;

142

score |= 2;

143

if (score == 0)

143

if (score == 0)

144

return t;

144

return t;

145

146

if (score < cand_score) {

146

if (score < cand_score) {

147

cand = t;

147

cand = t;

148

cand_score = score;

148

cand_score = score;

149

}

149

}

150

}

150

}

151

152

for_each_ip_tunnel_rcu(t, ign->tunnels_r[h0 ^ h1]) {

152

for_each_ip_tunnel_rcu(t, ign->tunnels_r[h0 ^ h1]) {

153

if (!ipv6_addr_equal(remote, &t->parms.raddr) ||

153

if (!ipv6_addr_equal(remote, &t->parms.raddr) ||

154

key != t->parms.i_key ||

154

key != t->parms.i_key ||

155

!(t->dev->flags & IFF_UP))

155

!(t->dev->flags & IFF_UP))

156

continue;

156

continue;

157

158

if (t->dev->type != ARPHRD_IP6GRE &&

158

if (t->dev->type != ARPHRD_IP6GRE &&

159

t->dev->type != dev_type)

159

t->dev->type != dev_type)

160

continue;

160

continue;

161

162

score = 0;

162

score = 0;

163

if (t->parms.link != link)

163

if (t->parms.link != link)

164

score |= 1;

164

score |= 1;

165

if (t->dev->type != dev_type)

165

if (t->dev->type != dev_type)

166

score |= 2;

166

score |= 2;

167

if (score == 0)

167

if (score == 0)

168

return t;

168

return t;

169

170

if (score < cand_score) {

170

if (score < cand_score) {

171

cand = t;

171

cand = t;

172

cand_score = score;

172

cand_score = score;

173

}

173

}

174

}

174

}

175

176

for_each_ip_tunnel_rcu(t, ign->tunnels_l[h1]) {

176

for_each_ip_tunnel_rcu(t, ign->tunnels_l[h1]) {

177

if ((!ipv6_addr_equal(local, &t->parms.laddr) &&

177

if ((!ipv6_addr_equal(local, &t->parms.laddr) &&

178

(!ipv6_addr_equal(local, &t->parms.raddr) ||

178

(!ipv6_addr_equal(local, &t->parms.raddr) ||

179

!ipv6_addr_is_multicast(local))) ||

179

!ipv6_addr_is_multicast(local))) ||

180

key != t->parms.i_key ||

180

key != t->parms.i_key ||

181

!(t->dev->flags & IFF_UP))

181

!(t->dev->flags & IFF_UP))

182

continue;

182

continue;

183

184

if (t->dev->type != ARPHRD_IP6GRE &&

184

if (t->dev->type != ARPHRD_IP6GRE &&

185

t->dev->type != dev_type)

185

t->dev->type != dev_type)

186

continue;

186

continue;

187

188

score = 0;

188

score = 0;

189

if (t->parms.link != link)

189

if (t->parms.link != link)

190

score |= 1;

190

score |= 1;

191

if (t->dev->type != dev_type)

191

if (t->dev->type != dev_type)

192

score |= 2;

192

score |= 2;

193

if (score == 0)

193

if (score == 0)

194

return t;

194

return t;

195

196

if (score < cand_score) {

196

if (score < cand_score) {

197

cand = t;

197

cand = t;

198

cand_score = score;

198

cand_score = score;

199

}

199

}

200

}

200

}

201

202

for_each_ip_tunnel_rcu(t, ign->tunnels_wc[h1]) {

202

for_each_ip_tunnel_rcu(t, ign->tunnels_wc[h1]) {

203

if (t->parms.i_key != key ||

203

if (t->parms.i_key != key ||

204

!(t->dev->flags & IFF_UP))

204

!(t->dev->flags & IFF_UP))

205

continue;

205

continue;

206

207

if (t->dev->type != ARPHRD_IP6GRE &&

207

if (t->dev->type != ARPHRD_IP6GRE &&

208

t->dev->type != dev_type)

208

t->dev->type != dev_type)

209

continue;

209

continue;

210

211

score = 0;

211

score = 0;

212

if (t->parms.link != link)

212

if (t->parms.link != link)

213

score |= 1;

213

score |= 1;

214

if (t->dev->type != dev_type)

214

if (t->dev->type != dev_type)

215

score |= 2;

215

score |= 2;

216

if (score == 0)

216

if (score == 0)

217

return t;

217

return t;

218

219

if (score < cand_score) {

219

if (score < cand_score) {

220

cand = t;

220

cand = t;

221

cand_score = score;

221

cand_score = score;

222

}

222

}

223

}

223

}

224

225

if (cand != NULL)

225

if (cand != NULL)

226

return cand;

226

return cand;

227

228

dev = ign->fb_tunnel_dev;

228

dev = ign->fb_tunnel_dev;

229

if (dev->flags & IFF_UP)

229

if (dev->flags & IFF_UP)

230

return netdev_priv(dev);

230

return netdev_priv(dev);

231

232

return NULL;

232

return NULL;

233

}

233

}

234

235

static struct ip6_tnl __rcu **__ip6gre_bucket(struct ip6gre_net *ign,

235

static struct ip6_tnl __rcu **__ip6gre_bucket(struct ip6gre_net *ign,

236

const struct __ip6_tnl_parm *p)

236

const struct __ip6_tnl_parm *p)

237

{

237

{

238

const struct in6_addr *remote = &p->raddr;

238

const struct in6_addr *remote = &p->raddr;

239

const struct in6_addr *local = &p->laddr;

239

const struct in6_addr *local = &p->laddr;

240

unsigned int h = HASH_KEY(p->i_key);

240

unsigned int h = HASH_KEY(p->i_key);

241

int prio = 0;

241

int prio = 0;

242

243

if (!ipv6_addr_any(local))

243

if (!ipv6_addr_any(local))

244

prio |= 1;

244

prio |= 1;

245

if (!ipv6_addr_any(remote) && !ipv6_addr_is_multicast(remote)) {

245

if (!ipv6_addr_any(remote) && !ipv6_addr_is_multicast(remote)) {

246

prio |= 2;

246

prio |= 2;

247

h ^= HASH_ADDR(remote);

247

h ^= HASH_ADDR(remote);

248

}

248

}

249

250

return &ign->tunnels[prio][h];

250

return &ign->tunnels[prio][h];

251

}

251

}

252

253

static inline struct ip6_tnl __rcu **ip6gre_bucket(struct ip6gre_net *ign,

253

static inline struct ip6_tnl __rcu **ip6gre_bucket(struct ip6gre_net *ign,

254

const struct ip6_tnl *t)

254

const struct ip6_tnl *t)

255

{

255

{

256

return __ip6gre_bucket(ign, &t->parms);

256

return __ip6gre_bucket(ign, &t->parms);

257

}

257

}

258

259

static void ip6gre_tunnel_link(struct ip6gre_net *ign, struct ip6_tnl *t)

259

static void ip6gre_tunnel_link(struct ip6gre_net *ign, struct ip6_tnl *t)

260

{

260

{

261

struct ip6_tnl __rcu **tp = ip6gre_bucket(ign, t);

261

struct ip6_tnl __rcu **tp = ip6gre_bucket(ign, t);

262

263

rcu_assign_pointer(t->next, rtnl_dereference(*tp));

263

rcu_assign_pointer(t->next, rtnl_dereference(*tp));

264

rcu_assign_pointer(*tp, t);

264

rcu_assign_pointer(*tp, t);

265

}

265

}

266

267

static void ip6gre_tunnel_unlink(struct ip6gre_net *ign, struct ip6_tnl *t)

267

static void ip6gre_tunnel_unlink(struct ip6gre_net *ign, struct ip6_tnl *t)

268

{

268

{

269

struct ip6_tnl __rcu **tp;

269

struct ip6_tnl __rcu **tp;

270

struct ip6_tnl *iter;

270

struct ip6_tnl *iter;

271

272

for (tp = ip6gre_bucket(ign, t);

272

for (tp = ip6gre_bucket(ign, t);

273

(iter = rtnl_dereference(*tp)) != NULL;

273

(iter = rtnl_dereference(*tp)) != NULL;

274

tp = &iter->next) {

274

tp = &iter->next) {

275

if (t == iter) {

275

if (t == iter) {

276

rcu_assign_pointer(*tp, t->next);

276

rcu_assign_pointer(*tp, t->next);

277

break;

277

break;

278

}

278

}

279

}

279

}

280

}

280

}

281

282

static struct ip6_tnl *ip6gre_tunnel_find(struct net *net,

282

static struct ip6_tnl *ip6gre_tunnel_find(struct net *net,

283

const struct __ip6_tnl_parm *parms,

283

const struct __ip6_tnl_parm *parms,

284

int type)

284

int type)

285

{

285

{

286

const struct in6_addr *remote = &parms->raddr;

286

const struct in6_addr *remote = &parms->raddr;

287

const struct in6_addr *local = &parms->laddr;

287

const struct in6_addr *local = &parms->laddr;

288

__be32 key = parms->i_key;

288

__be32 key = parms->i_key;

289

int link = parms->link;

289

int link = parms->link;

290

struct ip6_tnl *t;

290

struct ip6_tnl *t;

291

struct ip6_tnl __rcu **tp;

291

struct ip6_tnl __rcu **tp;

292

struct ip6gre_net *ign = net_generic(net, ip6gre_net_id);

292

struct ip6gre_net *ign = net_generic(net, ip6gre_net_id);

293

294

for (tp = __ip6gre_bucket(ign, parms);

294

for (tp = __ip6gre_bucket(ign, parms);

295

(t = rtnl_dereference(*tp)) != NULL;

295

(t = rtnl_dereference(*tp)) != NULL;

296

tp = &t->next)

296

tp = &t->next)

297

if (ipv6_addr_equal(local, &t->parms.laddr) &&

297

if (ipv6_addr_equal(local, &t->parms.laddr) &&

298

ipv6_addr_equal(remote, &t->parms.raddr) &&

298

ipv6_addr_equal(remote, &t->parms.raddr) &&

299

key == t->parms.i_key &&

299

key == t->parms.i_key &&

300

link == t->parms.link &&

300

link == t->parms.link &&

301

type == t->dev->type)

301

type == t->dev->type)

302

break;

302

break;

303

304

return t;

304

return t;

305

}

305

}

306

307

static struct ip6_tnl *ip6gre_tunnel_locate(struct net *net,

307

static struct ip6_tnl *ip6gre_tunnel_locate(struct net *net,

308

const struct __ip6_tnl_parm *parms, int create)

308

const struct __ip6_tnl_parm *parms, int create)

309

{

309

{

310

struct ip6_tnl *t, *nt;

310

struct ip6_tnl *t, *nt;

311

struct net_device *dev;

311

struct net_device *dev;

312

char name[IFNAMSIZ];

312

char name[IFNAMSIZ];

313

struct ip6gre_net *ign = net_generic(net, ip6gre_net_id);

313

struct ip6gre_net *ign = net_generic(net, ip6gre_net_id);

314

315

t = ip6gre_tunnel_find(net, parms, ARPHRD_IP6GRE);

315

t = ip6gre_tunnel_find(net, parms, ARPHRD_IP6GRE);

316

if (t || !create)

316

if (t || !create)

317

return t;

317

return t;

318

319

if (parms->name[0])

319

if (parms->name[0])

320

strlcpy(name, parms->name, IFNAMSIZ);

320

strlcpy(name, parms->name, IFNAMSIZ);

321

else

321

else

322

strcpy(name, "ip6gre%d");

322

strcpy(name, "ip6gre%d");

323

324

dev = alloc_netdev(sizeof(*t), name, ip6gre_tunnel_setup);

324

dev = alloc_netdev(sizeof(*t), name, ip6gre_tunnel_setup);

325

if (!dev)

325

if (!dev)

326

return NULL;

326

return NULL;

327

328

dev_net_set(dev, net);

328

dev_net_set(dev, net);

329

330

nt = netdev_priv(dev);

330

nt = netdev_priv(dev);

331

nt->parms = *parms;

331

nt->parms = *parms;

332

dev->rtnl_link_ops = &ip6gre_link_ops;

332

dev->rtnl_link_ops = &ip6gre_link_ops;

333

334

nt->dev = dev;

334

nt->dev = dev;

335

nt->net = dev_net(dev);

335

nt->net = dev_net(dev);

336

ip6gre_tnl_link_config(nt, 1);

336

ip6gre_tnl_link_config(nt, 1);

337

338

if (register_netdevice(dev) < 0)

338

if (register_netdevice(dev) < 0)

339

goto failed_free;

339

goto failed_free;

340

341

/* Can use a lockless transmit, unless we generate output sequences */

341

/* Can use a lockless transmit, unless we generate output sequences */

342

if (!(nt->parms.o_flags & GRE_SEQ))

342

if (!(nt->parms.o_flags & GRE_SEQ))

343

dev->features |= NETIF_F_LLTX;

343

dev->features |= NETIF_F_LLTX;

344

345

dev_hold(dev);

345

dev_hold(dev);

346

ip6gre_tunnel_link(ign, nt);

346

ip6gre_tunnel_link(ign, nt);

347

return nt;

347

return nt;

348

349

failed_free:

349

failed_free:

350

free_netdev(dev);

350

free_netdev(dev);

351

return NULL;

351

return NULL;

352

}

352

}

353

354

static void ip6gre_tunnel_uninit(struct net_device *dev)

354

static void ip6gre_tunnel_uninit(struct net_device *dev)

355

{

355

{

356

struct net *net = dev_net(dev);

356

struct net *net = dev_net(dev);

357

struct ip6gre_net *ign = net_generic(net, ip6gre_net_id);

357

struct ip6gre_net *ign = net_generic(net, ip6gre_net_id);

358

359

ip6gre_tunnel_unlink(ign, netdev_priv(dev));

359

ip6gre_tunnel_unlink(ign, netdev_priv(dev));

360

dev_put(dev);

360

dev_put(dev);

361

}

361

}

362

363

364

static void ip6gre_err(struct sk_buff *skb, struct inet6_skb_parm *opt,

364

static void ip6gre_err(struct sk_buff *skb, struct inet6_skb_parm *opt,

365

u8 type, u8 code, int offset, __be32 info)

365

u8 type, u8 code, int offset, __be32 info)

366

{

366

{

367

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

367

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

368

__be16 *p = (__be16 *)(skb->data + offset);

368

__be16 *p = (__be16 *)(skb->data + offset);

369

int grehlen = offset + 4;

369

int grehlen = offset + 4;

370

struct ip6_tnl *t;

370

struct ip6_tnl *t;

371

__be16 flags;

371

__be16 flags;

372

373

flags = p[0];

373

flags = p[0];

374

if (flags&(GRE_CSUM|GRE_KEY|GRE_SEQ|GRE_ROUTING|GRE_VERSION)) {

374

if (flags&(GRE_CSUM|GRE_KEY|GRE_SEQ|GRE_ROUTING|GRE_VERSION)) {

375

if (flags&(GRE_VERSION|GRE_ROUTING))

375

if (flags&(GRE_VERSION|GRE_ROUTING))

376

return;

376

return;

377

if (flags&GRE_KEY) {

377

if (flags&GRE_KEY) {

378

grehlen += 4;

378

grehlen += 4;

379

if (flags&GRE_CSUM)

379

if (flags&GRE_CSUM)

380

grehlen += 4;

380

grehlen += 4;

381

}

381

}

382

}

382

}

383

384

/* If only 8 bytes returned, keyed message will be dropped here */

384

/* If only 8 bytes returned, keyed message will be dropped here */

385

if (!pskb_may_pull(skb, grehlen))

385

if (!pskb_may_pull(skb, grehlen))

386

return;

386

return;

387

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

387

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

388

p = (__be16 *)(skb->data + offset);

388

p = (__be16 *)(skb->data + offset);

389

390

t = ip6gre_tunnel_lookup(skb->dev, &ipv6h->daddr, &ipv6h->saddr,

390

t = ip6gre_tunnel_lookup(skb->dev, &ipv6h->daddr, &ipv6h->saddr,

391

flags & GRE_KEY ?

391

flags & GRE_KEY ?

392

*(((__be32 *)p) + (grehlen / 4) - 1) : 0,

392

*(((__be32 *)p) + (grehlen / 4) - 1) : 0,

393

p[1]);

393

p[1]);

394

if (t == NULL)

394

if (t == NULL)

395

return;

395

return;

396

397

switch (type) {

397

switch (type) {

398

__u32 teli;

398

__u32 teli;

399

struct ipv6_tlv_tnl_enc_lim *tel;

399

struct ipv6_tlv_tnl_enc_lim *tel;

400

__u32 mtu;

400

__u32 mtu;

401

case ICMPV6_DEST_UNREACH:

401

case ICMPV6_DEST_UNREACH:

402

net_warn_ratelimited("%s: Path to destination invalid or inactive!\n",

402

net_warn_ratelimited("%s: Path to destination invalid or inactive!\n",

403

t->parms.name);

403

t->parms.name);

404

break;

404

break;

405

case ICMPV6_TIME_EXCEED:

405

case ICMPV6_TIME_EXCEED:

406

if (code == ICMPV6_EXC_HOPLIMIT) {

406

if (code == ICMPV6_EXC_HOPLIMIT) {

407

net_warn_ratelimited("%s: Too small hop limit or routing loop in tunnel!\n",

407

net_warn_ratelimited("%s: Too small hop limit or routing loop in tunnel!\n",

408

t->parms.name);

408

t->parms.name);

409

}

409

}

410

break;

410

break;

411

case ICMPV6_PARAMPROB:

411

case ICMPV6_PARAMPROB:

412

teli = 0;

412

teli = 0;

413

if (code == ICMPV6_HDR_FIELD)

413

if (code == ICMPV6_HDR_FIELD)

414

teli = ip6_tnl_parse_tlv_enc_lim(skb, skb->data);

414

teli = ip6_tnl_parse_tlv_enc_lim(skb, skb->data);

415

416

if (teli && teli == info - 2) {

416

if (teli && teli == info - 2) {

417

tel = (struct ipv6_tlv_tnl_enc_lim *) &skb->data[teli];

417

tel = (struct ipv6_tlv_tnl_enc_lim *) &skb->data[teli];

418

if (tel->encap_limit == 0) {

418

if (tel->encap_limit == 0) {

419

net_warn_ratelimited("%s: Too small encapsulation limit or routing loop in tunnel!\n",

419

net_warn_ratelimited("%s: Too small encapsulation limit or routing loop in tunnel!\n",

420

t->parms.name);

420

t->parms.name);

421

}

421

}

422

} else {

422

} else {

423

net_warn_ratelimited("%s: Recipient unable to parse tunneled packet!\n",

423

net_warn_ratelimited("%s: Recipient unable to parse tunneled packet!\n",

424

t->parms.name);

424

t->parms.name);

425

}

425

}

426

break;

426

break;

427

case ICMPV6_PKT_TOOBIG:

427

case ICMPV6_PKT_TOOBIG:

428

mtu = info - offset;

428

mtu = info - offset;

429

if (mtu < IPV6_MIN_MTU)

429

if (mtu < IPV6_MIN_MTU)

430

mtu = IPV6_MIN_MTU;

430

mtu = IPV6_MIN_MTU;

431

t->dev->mtu = mtu;

431

t->dev->mtu = mtu;

432

break;

432

break;

433

}

433

}

434

435

if (time_before(jiffies, t->err_time + IP6TUNNEL_ERR_TIMEO))

435

if (time_before(jiffies, t->err_time + IP6TUNNEL_ERR_TIMEO))

436

t->err_count++;

436

t->err_count++;

437

else

437

else

438

t->err_count = 1;

438

t->err_count = 1;

439

t->err_time = jiffies;

439

t->err_time = jiffies;

440

}

440

}

441

442

static int ip6gre_rcv(struct sk_buff *skb)

442

static int ip6gre_rcv(struct sk_buff *skb)

443

{

443

{

444

const struct ipv6hdr *ipv6h;

444

const struct ipv6hdr *ipv6h;

445

u8 *h;

445

u8 *h;

446

__be16 flags;

446

__be16 flags;

447

__sum16 csum = 0;

447

__sum16 csum = 0;

448

__be32 key = 0;

448

__be32 key = 0;

449

u32 seqno = 0;

449

u32 seqno = 0;

450

struct ip6_tnl *tunnel;

450

struct ip6_tnl *tunnel;

451

int offset = 4;

451

int offset = 4;

452

__be16 gre_proto;

452

__be16 gre_proto;

453

int err;

453

int err;

454

455

if (!pskb_may_pull(skb, sizeof(struct in6_addr)))

455

if (!pskb_may_pull(skb, sizeof(struct in6_addr)))

456

goto drop;

456

goto drop;

457

458

ipv6h = ipv6_hdr(skb);

458

ipv6h = ipv6_hdr(skb);

459

h = skb->data;

459

h = skb->data;

460

flags = *(__be16 *)h;

460

flags = *(__be16 *)h;

461

462

if (flags&(GRE_CSUM|GRE_KEY|GRE_ROUTING|GRE_SEQ|GRE_VERSION)) {

462

if (flags&(GRE_CSUM|GRE_KEY|GRE_ROUTING|GRE_SEQ|GRE_VERSION)) {

463

/* - Version must be 0.

463

/* - Version must be 0.

464

- We do not support routing headers.

464

- We do not support routing headers.

465

*/

465

*/

466

if (flags&(GRE_VERSION|GRE_ROUTING))

466

if (flags&(GRE_VERSION|GRE_ROUTING))

467

goto drop;

467

goto drop;

468

469

if (flags&GRE_CSUM) {

469

if (flags&GRE_CSUM) {

470

switch (skb->ip_summed) {

470

switch (skb->ip_summed) {

471

case CHECKSUM_COMPLETE:

471

case CHECKSUM_COMPLETE:

472

csum = csum_fold(skb->csum);

472

csum = csum_fold(skb->csum);

473

if (!csum)

473

if (!csum)

474

break;

474

break;

475

/* fall through */

475

/* fall through */

476

case CHECKSUM_NONE:

476

case CHECKSUM_NONE:

477

skb->csum = 0;

477

skb->csum = 0;

478

csum = __skb_checksum_complete(skb);

478

csum = __skb_checksum_complete(skb);

479

skb->ip_summed = CHECKSUM_COMPLETE;

479

skb->ip_summed = CHECKSUM_COMPLETE;

480

}

480

}

481

offset += 4;

481

offset += 4;

482

}

482

}

483

if (flags&GRE_KEY) {

483

if (flags&GRE_KEY) {

484

key = *(__be32 *)(h + offset);

484

key = *(__be32 *)(h + offset);

485

offset += 4;

485

offset += 4;

486

}

486

}

487

if (flags&GRE_SEQ) {

487

if (flags&GRE_SEQ) {

488

seqno = ntohl(*(__be32 *)(h + offset));

488

seqno = ntohl(*(__be32 *)(h + offset));

489

offset += 4;

489

offset += 4;

490

}

490

}

491

}

491

}

492

493

gre_proto = *(__be16 *)(h + 2);

493

gre_proto = *(__be16 *)(h + 2);

494

495

tunnel = ip6gre_tunnel_lookup(skb->dev,

495

tunnel = ip6gre_tunnel_lookup(skb->dev,

496

&ipv6h->saddr, &ipv6h->daddr, key,

496

&ipv6h->saddr, &ipv6h->daddr, key,

497

gre_proto);

497

gre_proto);

498

if (tunnel) {

498

if (tunnel) {

499

struct pcpu_sw_netstats *tstats;

499

struct pcpu_sw_netstats *tstats;

500

501

if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb))

501

if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb))

502

goto drop;

502

goto drop;

503

504

if (!ip6_tnl_rcv_ctl(tunnel, &ipv6h->daddr, &ipv6h->saddr)) {

504

if (!ip6_tnl_rcv_ctl(tunnel, &ipv6h->daddr, &ipv6h->saddr)) {

505

tunnel->dev->stats.rx_dropped++;

505

tunnel->dev->stats.rx_dropped++;

506

goto drop;

506

goto drop;

507

}

507

}

508

509

skb->protocol = gre_proto;

509

skb->protocol = gre_proto;

510

/* WCCP version 1 and 2 protocol decoding.

510

/* WCCP version 1 and 2 protocol decoding.

511

* - Change protocol to IP

511

* - Change protocol to IPv6

512

* - When dealing with WCCPv2, Skip extra 4 bytes in GRE header

512

* - When dealing with WCCPv2, Skip extra 4 bytes in GRE header

513

*/

513

*/

514

if (flags == 0 && gre_proto == htons(ETH_P_WCCP)) {

514

if (flags == 0 && gre_proto == htons(ETH_P_WCCP)) {

515

skb->protocol = htons(ETH_P_IP);

515

skb->protocol = htons(ETH_P_IPV6);

516

if ((*(h + offset) & 0xF0) != 0x40)

516

if ((*(h + offset) & 0xF0) != 0x40)

517

offset += 4;

517

offset += 4;

518

}

518

}

519

520

skb->mac_header = skb->network_header;

520

skb->mac_header = skb->network_header;

521

__pskb_pull(skb, offset);

521

__pskb_pull(skb, offset);

522

skb_postpull_rcsum(skb, skb_transport_header(skb), offset);

522

skb_postpull_rcsum(skb, skb_transport_header(skb), offset);

523

524

if (((flags&GRE_CSUM) && csum) ||

524

if (((flags&GRE_CSUM) && csum) ||

525

(!(flags&GRE_CSUM) && tunnel->parms.i_flags&GRE_CSUM)) {

525

(!(flags&GRE_CSUM) && tunnel->parms.i_flags&GRE_CSUM)) {

526

tunnel->dev->stats.rx_crc_errors++;

526

tunnel->dev->stats.rx_crc_errors++;

527

tunnel->dev->stats.rx_errors++;

527

tunnel->dev->stats.rx_errors++;

528

goto drop;

528

goto drop;

529

}

529

}

530

if (tunnel->parms.i_flags&GRE_SEQ) {

530

if (tunnel->parms.i_flags&GRE_SEQ) {

531

if (!(flags&GRE_SEQ) ||

531

if (!(flags&GRE_SEQ) ||

532

(tunnel->i_seqno &&

532

(tunnel->i_seqno &&

533

(s32)(seqno - tunnel->i_seqno) < 0)) {

533

(s32)(seqno - tunnel->i_seqno) < 0)) {

534

tunnel->dev->stats.rx_fifo_errors++;

534

tunnel->dev->stats.rx_fifo_errors++;

535

tunnel->dev->stats.rx_errors++;

535

tunnel->dev->stats.rx_errors++;

536

goto drop;

536

goto drop;

537

}

537

}

538

tunnel->i_seqno = seqno + 1;

538

tunnel->i_seqno = seqno + 1;

539

}

539

}

540

541

/* Warning: All skb pointers will be invalidated! */

541

/* Warning: All skb pointers will be invalidated! */

542

if (tunnel->dev->type == ARPHRD_ETHER) {

542

if (tunnel->dev->type == ARPHRD_ETHER) {

543

if (!pskb_may_pull(skb, ETH_HLEN)) {

543

if (!pskb_may_pull(skb, ETH_HLEN)) {

544

tunnel->dev->stats.rx_length_errors++;

544

tunnel->dev->stats.rx_length_errors++;

545

tunnel->dev->stats.rx_errors++;

545

tunnel->dev->stats.rx_errors++;

546

goto drop;

546

goto drop;

547

}

547

}

548

549

ipv6h = ipv6_hdr(skb);

549

ipv6h = ipv6_hdr(skb);

550

skb->protocol = eth_type_trans(skb, tunnel->dev);

550

skb->protocol = eth_type_trans(skb, tunnel->dev);

551

skb_postpull_rcsum(skb, eth_hdr(skb), ETH_HLEN);

551

skb_postpull_rcsum(skb, eth_hdr(skb), ETH_HLEN);

552

}

552

}

553

554

__skb_tunnel_rx(skb, tunnel->dev, tunnel->net);

554

__skb_tunnel_rx(skb, tunnel->dev, tunnel->net);

555

556

skb_reset_network_header(skb);

556

skb_reset_network_header(skb);

557

558

err = IP6_ECN_decapsulate(ipv6h, skb);

558

err = IP6_ECN_decapsulate(ipv6h, skb);

559

if (unlikely(err)) {

559

if (unlikely(err)) {

560

if (log_ecn_error)

560

if (log_ecn_error)

561

net_info_ratelimited("non-ECT from %pI6 with dsfield=%#x\n",

561

net_info_ratelimited("non-ECT from %pI6 with dsfield=%#x\n",

562

&ipv6h->saddr,

562

&ipv6h->saddr,

563

ipv6_get_dsfield(ipv6h));

563

ipv6_get_dsfield(ipv6h));

564

if (err > 1) {

564

if (err > 1) {

565

++tunnel->dev->stats.rx_frame_errors;

565

++tunnel->dev->stats.rx_frame_errors;

566

++tunnel->dev->stats.rx_errors;

566

++tunnel->dev->stats.rx_errors;

567

goto drop;

567

goto drop;

568

}

568

}

569

}

569

}

570

571

tstats = this_cpu_ptr(tunnel->dev->tstats);

571

tstats = this_cpu_ptr(tunnel->dev->tstats);

572

u64_stats_update_begin(&tstats->syncp);

572

u64_stats_update_begin(&tstats->syncp);

573

tstats->rx_packets++;

573

tstats->rx_packets++;

574

tstats->rx_bytes += skb->len;

574

tstats->rx_bytes += skb->len;

575

u64_stats_update_end(&tstats->syncp);

575

u64_stats_update_end(&tstats->syncp);

576

577

netif_rx(skb);

577

netif_rx(skb);

578

579

return 0;

579

return 0;

580

}

580

}

581

icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_PORT_UNREACH, 0);

581

icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_PORT_UNREACH, 0);

582

583

drop:

583

drop:

584

kfree_skb(skb);

584

kfree_skb(skb);

585

return 0;

585

return 0;

586

}

586

}

587

588

struct ipv6_tel_txoption {

588

struct ipv6_tel_txoption {

589

struct ipv6_txoptions ops;

589

struct ipv6_txoptions ops;

590

__u8 dst_opt[8];

590

__u8 dst_opt[8];

591

};

591

};

592

593

static void init_tel_txopt(struct ipv6_tel_txoption *opt, __u8 encap_limit)

593

static void init_tel_txopt(struct ipv6_tel_txoption *opt, __u8 encap_limit)

594

{

594

{

595

memset(opt, 0, sizeof(struct ipv6_tel_txoption));

595

memset(opt, 0, sizeof(struct ipv6_tel_txoption));

596

597

opt->dst_opt[2] = IPV6_TLV_TNL_ENCAP_LIMIT;

597

opt->dst_opt[2] = IPV6_TLV_TNL_ENCAP_LIMIT;

598

opt->dst_opt[3] = 1;

598

opt->dst_opt[3] = 1;

599

opt->dst_opt[4] = encap_limit;

599

opt->dst_opt[4] = encap_limit;

600

opt->dst_opt[5] = IPV6_TLV_PADN;

600

opt->dst_opt[5] = IPV6_TLV_PADN;

601

opt->dst_opt[6] = 1;

601

opt->dst_opt[6] = 1;

602

603

opt->ops.dst0opt = (struct ipv6_opt_hdr *) opt->dst_opt;

603

opt->ops.dst0opt = (struct ipv6_opt_hdr *) opt->dst_opt;

604

opt->ops.opt_nflen = 8;

604

opt->ops.opt_nflen = 8;

605

}

605

}

606

607

static netdev_tx_t ip6gre_xmit2(struct sk_buff *skb,

607

static netdev_tx_t ip6gre_xmit2(struct sk_buff *skb,

608

struct net_device *dev,

608

struct net_device *dev,

609

__u8 dsfield,

609

__u8 dsfield,

610

struct flowi6 *fl6,

610

struct flowi6 *fl6,

611

int encap_limit,

611

int encap_limit,

612

__u32 *pmtu)

612

__u32 *pmtu)

613

{

613

{

614

struct net *net = dev_net(dev);

614

struct net *net = dev_net(dev);

615

struct ip6_tnl *tunnel = netdev_priv(dev);

615

struct ip6_tnl *tunnel = netdev_priv(dev);

616

struct net_device *tdev; /* Device to other host */

616

struct net_device *tdev; /* Device to other host */

617

struct ipv6hdr *ipv6h; /* Our new IP header */

617

struct ipv6hdr *ipv6h; /* Our new IP header */

618

unsigned int max_headroom = 0; /* The extra header space needed */

618

unsigned int max_headroom = 0; /* The extra header space needed */

619

int gre_hlen;

619

int gre_hlen;

620

struct ipv6_tel_txoption opt;

620

struct ipv6_tel_txoption opt;

621

int mtu;

621

int mtu;

622

struct dst_entry *dst = NULL, *ndst = NULL;

622

struct dst_entry *dst = NULL, *ndst = NULL;

623

struct net_device_stats *stats = &tunnel->dev->stats;

623

struct net_device_stats *stats = &tunnel->dev->stats;

624

int err = -1;

624

int err = -1;

625

u8 proto;

625

u8 proto;

626

struct sk_buff *new_skb;

626

struct sk_buff *new_skb;

627

628

if (dev->type == ARPHRD_ETHER)

628

if (dev->type == ARPHRD_ETHER)

629

IPCB(skb)->flags = 0;

629

IPCB(skb)->flags = 0;

630

631

if (dev->header_ops && dev->type == ARPHRD_IP6GRE) {

631

if (dev->header_ops && dev->type == ARPHRD_IP6GRE) {

632

gre_hlen = 0;

632

gre_hlen = 0;

633

ipv6h = (struct ipv6hdr *)skb->data;

633

ipv6h = (struct ipv6hdr *)skb->data;

634

fl6->daddr = ipv6h->daddr;

634

fl6->daddr = ipv6h->daddr;

635

} else {

635

} else {

636

gre_hlen = tunnel->hlen;

636

gre_hlen = tunnel->hlen;

637

fl6->daddr = tunnel->parms.raddr;

637

fl6->daddr = tunnel->parms.raddr;

638

}

638

}

639

640

if (!fl6->flowi6_mark)

640

if (!fl6->flowi6_mark)

641

dst = ip6_tnl_dst_check(tunnel);

641

dst = ip6_tnl_dst_check(tunnel);

642

643

if (!dst) {

643

if (!dst) {

644

ndst = ip6_route_output(net, NULL, fl6);

644

ndst = ip6_route_output(net, NULL, fl6);

645

646

if (ndst->error)

646

if (ndst->error)

647

goto tx_err_link_failure;

647

goto tx_err_link_failure;

648

ndst = xfrm_lookup(net, ndst, flowi6_to_flowi(fl6), NULL, 0);

648

ndst = xfrm_lookup(net, ndst, flowi6_to_flowi(fl6), NULL, 0);

649

if (IS_ERR(ndst)) {

649

if (IS_ERR(ndst)) {

650

err = PTR_ERR(ndst);

650

err = PTR_ERR(ndst);

651

ndst = NULL;

651

ndst = NULL;

652

goto tx_err_link_failure;

652

goto tx_err_link_failure;

653

}

653

}

654

dst = ndst;

654

dst = ndst;

655

}

655

}

656

657

tdev = dst->dev;

657

tdev = dst->dev;

658

659

if (tdev == dev) {

659

if (tdev == dev) {

660

stats->collisions++;

660

stats->collisions++;

661

net_warn_ratelimited("%s: Local routing loop detected!\n",

661

net_warn_ratelimited("%s: Local routing loop detected!\n",

662

tunnel->parms.name);

662

tunnel->parms.name);

663

goto tx_err_dst_release;

663

goto tx_err_dst_release;

664

}

664

}

665

666

mtu = dst_mtu(dst) - sizeof(*ipv6h);

666

mtu = dst_mtu(dst) - sizeof(*ipv6h);

667

if (encap_limit >= 0) {

667

if (encap_limit >= 0) {

668

max_headroom += 8;

668

max_headroom += 8;

669

mtu -= 8;

669

mtu -= 8;

670

}

670

}

671

if (mtu < IPV6_MIN_MTU)

671

if (mtu < IPV6_MIN_MTU)

672

mtu = IPV6_MIN_MTU;

672

mtu = IPV6_MIN_MTU;

673

if (skb_dst(skb))

673

if (skb_dst(skb))

674

skb_dst(skb)->ops->update_pmtu(skb_dst(skb), NULL, skb, mtu);

674

skb_dst(skb)->ops->update_pmtu(skb_dst(skb), NULL, skb, mtu);

675

if (skb->len > mtu) {

675

if (skb->len > mtu) {

676

*pmtu = mtu;

676

*pmtu = mtu;

677

err = -EMSGSIZE;

677

err = -EMSGSIZE;

678

goto tx_err_dst_release;

678

goto tx_err_dst_release;

679

}

679

}

680

681

if (tunnel->err_count > 0) {

681

if (tunnel->err_count > 0) {

682

if (time_before(jiffies,

682

if (time_before(jiffies,

683

tunnel->err_time + IP6TUNNEL_ERR_TIMEO)) {

683

tunnel->err_time + IP6TUNNEL_ERR_TIMEO)) {

684

tunnel->err_count--;

684

tunnel->err_count--;

685

686

dst_link_failure(skb);

686

dst_link_failure(skb);

687

} else

687

} else

688

tunnel->err_count = 0;

688

tunnel->err_count = 0;

689

}

689

}

690

691

skb_scrub_packet(skb, !net_eq(tunnel->net, dev_net(dev)));

691

skb_scrub_packet(skb, !net_eq(tunnel->net, dev_net(dev)));

692

693

max_headroom += LL_RESERVED_SPACE(tdev) + gre_hlen + dst->header_len;

693

max_headroom += LL_RESERVED_SPACE(tdev) + gre_hlen + dst->header_len;

694

695

if (skb_headroom(skb) < max_headroom || skb_shared(skb) ||

695

if (skb_headroom(skb) < max_headroom || skb_shared(skb) ||

696

(skb_cloned(skb) && !skb_clone_writable(skb, 0))) {

696

(skb_cloned(skb) && !skb_clone_writable(skb, 0))) {

697

new_skb = skb_realloc_headroom(skb, max_headroom);

697

new_skb = skb_realloc_headroom(skb, max_headroom);

698

if (max_headroom > dev->needed_headroom)

698

if (max_headroom > dev->needed_headroom)

699

dev->needed_headroom = max_headroom;

699

dev->needed_headroom = max_headroom;

700

if (!new_skb)

700

if (!new_skb)

701

goto tx_err_dst_release;

701

goto tx_err_dst_release;

702

703

if (skb->sk)

703

if (skb->sk)

704

skb_set_owner_w(new_skb, skb->sk);

704

skb_set_owner_w(new_skb, skb->sk);

705

consume_skb(skb);

705

consume_skb(skb);

706

skb = new_skb;

706

skb = new_skb;

707

}

707

}

708

709

if (fl6->flowi6_mark) {

709

if (fl6->flowi6_mark) {

710

skb_dst_set(skb, dst);

710

skb_dst_set(skb, dst);

711

ndst = NULL;

711

ndst = NULL;

712

} else {

712

} else {

713

skb_dst_set_noref(skb, dst);

713

skb_dst_set_noref(skb, dst);

714

}

714

}

715

716

proto = NEXTHDR_GRE;

716

proto = NEXTHDR_GRE;

717

if (encap_limit >= 0) {

717

if (encap_limit >= 0) {

718

init_tel_txopt(&opt, encap_limit);

718

init_tel_txopt(&opt, encap_limit);

719

ipv6_push_nfrag_opts(skb, &opt.ops, &proto, NULL);

719

ipv6_push_nfrag_opts(skb, &opt.ops, &proto, NULL);

720

}

720

}

721

722

if (likely(!skb->encapsulation)) {

722

if (likely(!skb->encapsulation)) {

723

skb_reset_inner_headers(skb);

723

skb_reset_inner_headers(skb);

724

skb->encapsulation = 1;

724

skb->encapsulation = 1;

725

}

725

}

726

727

skb_push(skb, gre_hlen);

727

skb_push(skb, gre_hlen);

728

skb_reset_network_header(skb);

728

skb_reset_network_header(skb);

729

skb_set_transport_header(skb, sizeof(*ipv6h));

729

skb_set_transport_header(skb, sizeof(*ipv6h));

730

731

/*

731

/*

732

* Push down and install the IP header.

732

* Push down and install the IP header.

733

*/

733

*/

734

ipv6h = ipv6_hdr(skb);

734

ipv6h = ipv6_hdr(skb);

735

ip6_flow_hdr(ipv6h, INET_ECN_encapsulate(0, dsfield), fl6->flowlabel);

735

ip6_flow_hdr(ipv6h, INET_ECN_encapsulate(0, dsfield), fl6->flowlabel);

736

ipv6h->hop_limit = tunnel->parms.hop_limit;

736

ipv6h->hop_limit = tunnel->parms.hop_limit;

737

ipv6h->nexthdr = proto;

737

ipv6h->nexthdr = proto;

738

ipv6h->saddr = fl6->saddr;

738

ipv6h->saddr = fl6->saddr;

739

ipv6h->daddr = fl6->daddr;

739

ipv6h->daddr = fl6->daddr;

740

741

((__be16 *)(ipv6h + 1))[0] = tunnel->parms.o_flags;

741

((__be16 *)(ipv6h + 1))[0] = tunnel->parms.o_flags;

742

((__be16 *)(ipv6h + 1))[1] = (dev->type == ARPHRD_ETHER) ?

742

((__be16 *)(ipv6h + 1))[1] = (dev->type == ARPHRD_ETHER) ?

743

htons(ETH_P_TEB) : skb->protocol;

743

htons(ETH_P_TEB) : skb->protocol;

744

745

if (tunnel->parms.o_flags&(GRE_KEY|GRE_CSUM|GRE_SEQ)) {

745

if (tunnel->parms.o_flags&(GRE_KEY|GRE_CSUM|GRE_SEQ)) {

746

__be32 *ptr = (__be32 *)(((u8 *)ipv6h) + tunnel->hlen - 4);

746

__be32 *ptr = (__be32 *)(((u8 *)ipv6h) + tunnel->hlen - 4);

747

748

if (tunnel->parms.o_flags&GRE_SEQ) {

748

if (tunnel->parms.o_flags&GRE_SEQ) {

749

++tunnel->o_seqno;

749

++tunnel->o_seqno;

750

*ptr = htonl(tunnel->o_seqno);

750

*ptr = htonl(tunnel->o_seqno);

751

ptr--;

751

ptr--;

752

}

752

}

753

if (tunnel->parms.o_flags&GRE_KEY) {

753

if (tunnel->parms.o_flags&GRE_KEY) {

754

*ptr = tunnel->parms.o_key;

754

*ptr = tunnel->parms.o_key;

755

ptr--;

755

ptr--;

756

}

756

}

757

if (tunnel->parms.o_flags&GRE_CSUM) {

757

if (tunnel->parms.o_flags&GRE_CSUM) {

758

*ptr = 0;

758

*ptr = 0;

759

*(__sum16 *)ptr = ip_compute_csum((void *)(ipv6h+1),

759

*(__sum16 *)ptr = ip_compute_csum((void *)(ipv6h+1),

760

skb->len - sizeof(struct ipv6hdr));

760

skb->len - sizeof(struct ipv6hdr));

761

}

761

}

762

}

762

}

763

764

ip6tunnel_xmit(skb, dev);

764

ip6tunnel_xmit(skb, dev);

765

if (ndst)

765

if (ndst)

766

ip6_tnl_dst_store(tunnel, ndst);

766

ip6_tnl_dst_store(tunnel, ndst);

767

return 0;

767

return 0;

768

tx_err_link_failure:

768

tx_err_link_failure:

769

stats->tx_carrier_errors++;

769

stats->tx_carrier_errors++;

770

dst_link_failure(skb);

770

dst_link_failure(skb);

771

tx_err_dst_release:

771

tx_err_dst_release:

772

dst_release(ndst);

772

dst_release(ndst);

773

return err;

773

return err;

774

}

774

}

775

776

static inline int ip6gre_xmit_ipv4(struct sk_buff *skb, struct net_device *dev)

776

static inline int ip6gre_xmit_ipv4(struct sk_buff *skb, struct net_device *dev)

777

{

777

{

778

struct ip6_tnl *t = netdev_priv(dev);

778

struct ip6_tnl *t = netdev_priv(dev);

779

const struct iphdr *iph = ip_hdr(skb);

779

const struct iphdr *iph = ip_hdr(skb);

780

int encap_limit = -1;

780

int encap_limit = -1;

781

struct flowi6 fl6;

781

struct flowi6 fl6;

782

__u8 dsfield;

782

__u8 dsfield;

783

__u32 mtu;

783

__u32 mtu;

784

int err;

784

int err;

785

786

if (!(t->parms.flags & IP6_TNL_F_IGN_ENCAP_LIMIT))

786

if (!(t->parms.flags & IP6_TNL_F_IGN_ENCAP_LIMIT))

787

encap_limit = t->parms.encap_limit;

787

encap_limit = t->parms.encap_limit;

788

789

memcpy(&fl6, &t->fl.u.ip6, sizeof(fl6));

789

memcpy(&fl6, &t->fl.u.ip6, sizeof(fl6));

790

fl6.flowi6_proto = IPPROTO_GRE;

790

fl6.flowi6_proto = IPPROTO_GRE;

791

792

dsfield = ipv4_get_dsfield(iph);

792

dsfield = ipv4_get_dsfield(iph);

793

794

if (t->parms.flags & IP6_TNL_F_USE_ORIG_TCLASS)

794

if (t->parms.flags & IP6_TNL_F_USE_ORIG_TCLASS)

795

fl6.flowlabel |= htonl((__u32)iph->tos << IPV6_TCLASS_SHIFT)

795

fl6.flowlabel |= htonl((__u32)iph->tos << IPV6_TCLASS_SHIFT)

796

& IPV6_TCLASS_MASK;

796

& IPV6_TCLASS_MASK;

797

if (t->parms.flags & IP6_TNL_F_USE_ORIG_FWMARK)

797

if (t->parms.flags & IP6_TNL_F_USE_ORIG_FWMARK)

798

fl6.flowi6_mark = skb->mark;

798

fl6.flowi6_mark = skb->mark;

799

800

err = ip6gre_xmit2(skb, dev, dsfield, &fl6, encap_limit, &mtu);

800

err = ip6gre_xmit2(skb, dev, dsfield, &fl6, encap_limit, &mtu);

801

if (err != 0) {

801

if (err != 0) {

802

/* XXX: send ICMP error even if DF is not set. */

802

/* XXX: send ICMP error even if DF is not set. */

803

if (err == -EMSGSIZE)

803

if (err == -EMSGSIZE)

804

icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED,

804

icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED,

805

htonl(mtu));

805

htonl(mtu));

806

return -1;

806

return -1;

807

}

807

}

808

809

return 0;

809

return 0;

810

}

810

}

811

812

static inline int ip6gre_xmit_ipv6(struct sk_buff *skb, struct net_device *dev)

812

static inline int ip6gre_xmit_ipv6(struct sk_buff *skb, struct net_device *dev)

813

{

813

{

814

struct ip6_tnl *t = netdev_priv(dev);

814

struct ip6_tnl *t = netdev_priv(dev);

815

struct ipv6hdr *ipv6h = ipv6_hdr(skb);

815

struct ipv6hdr *ipv6h = ipv6_hdr(skb);

816

int encap_limit = -1;

816

int encap_limit = -1;

817

__u16 offset;

817

__u16 offset;

818

struct flowi6 fl6;

818

struct flowi6 fl6;

819

__u8 dsfield;

819

__u8 dsfield;

820

__u32 mtu;

820

__u32 mtu;

821

int err;

821

int err;

822

823

if (ipv6_addr_equal(&t->parms.raddr, &ipv6h->saddr))

823

if (ipv6_addr_equal(&t->parms.raddr, &ipv6h->saddr))

824

return -1;

824

return -1;

825

826

offset = ip6_tnl_parse_tlv_enc_lim(skb, skb_network_header(skb));

826

offset = ip6_tnl_parse_tlv_enc_lim(skb, skb_network_header(skb));

827

if (offset > 0) {

827

if (offset > 0) {

828

struct ipv6_tlv_tnl_enc_lim *tel;

828

struct ipv6_tlv_tnl_enc_lim *tel;

829

tel = (struct ipv6_tlv_tnl_enc_lim *)&skb_network_header(skb)[offset];

829

tel = (struct ipv6_tlv_tnl_enc_lim *)&skb_network_header(skb)[offset];

830

if (tel->encap_limit == 0) {

830

if (tel->encap_limit == 0) {

831

icmpv6_send(skb, ICMPV6_PARAMPROB,

831

icmpv6_send(skb, ICMPV6_PARAMPROB,

832

ICMPV6_HDR_FIELD, offset + 2);

832

ICMPV6_HDR_FIELD, offset + 2);

833

return -1;

833

return -1;

834

}

834

}

835

encap_limit = tel->encap_limit - 1;

835

encap_limit = tel->encap_limit - 1;

836

} else if (!(t->parms.flags & IP6_TNL_F_IGN_ENCAP_LIMIT))

836

} else if (!(t->parms.flags & IP6_TNL_F_IGN_ENCAP_LIMIT))

837

encap_limit = t->parms.encap_limit;

837

encap_limit = t->parms.encap_limit;

838

839

memcpy(&fl6, &t->fl.u.ip6, sizeof(fl6));

839

memcpy(&fl6, &t->fl.u.ip6, sizeof(fl6));

840

fl6.flowi6_proto = IPPROTO_GRE;

840

fl6.flowi6_proto = IPPROTO_GRE;

841

842

dsfield = ipv6_get_dsfield(ipv6h);

842

dsfield = ipv6_get_dsfield(ipv6h);

843

if (t->parms.flags & IP6_TNL_F_USE_ORIG_TCLASS)

843

if (t->parms.flags & IP6_TNL_F_USE_ORIG_TCLASS)

844

fl6.flowlabel |= (*(__be32 *) ipv6h & IPV6_TCLASS_MASK);

844

fl6.flowlabel |= (*(__be32 *) ipv6h & IPV6_TCLASS_MASK);

845

if (t->parms.flags & IP6_TNL_F_USE_ORIG_FLOWLABEL)

845

if (t->parms.flags & IP6_TNL_F_USE_ORIG_FLOWLABEL)

846

fl6.flowlabel |= ip6_flowlabel(ipv6h);

846

fl6.flowlabel |= ip6_flowlabel(ipv6h);

847

if (t->parms.flags & IP6_TNL_F_USE_ORIG_FWMARK)

847

if (t->parms.flags & IP6_TNL_F_USE_ORIG_FWMARK)

848

fl6.flowi6_mark = skb->mark;

848

fl6.flowi6_mark = skb->mark;

849

850

err = ip6gre_xmit2(skb, dev, dsfield, &fl6, encap_limit, &mtu);

850

err = ip6gre_xmit2(skb, dev, dsfield, &fl6, encap_limit, &mtu);

851

if (err != 0) {

851

if (err != 0) {

852

if (err == -EMSGSIZE)

852

if (err == -EMSGSIZE)

853

icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu);

853

icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu);

854

return -1;

854

return -1;

855

}

855

}

856

857

return 0;

857

return 0;

858

}

858

}

859

860

/**

860

/**

861

* ip6_tnl_addr_conflict - compare packet addresses to tunnel's own

861

* ip6_tnl_addr_conflict - compare packet addresses to tunnel's own

862

* @t: the outgoing tunnel device

862

* @t: the outgoing tunnel device

863

* @hdr: IPv6 header from the incoming packet

863

* @hdr: IPv6 header from the incoming packet

864

*

864

*

865

* Description:

865

* Description:

866

* Avoid trivial tunneling loop by checking that tunnel exit-point

866

* Avoid trivial tunneling loop by checking that tunnel exit-point

867

* doesn't match source of incoming packet.

867

* doesn't match source of incoming packet.

868

*

868

*

869

* Return:

869

* Return:

870

* 1 if conflict,

870

* 1 if conflict,

871

* 0 else

871

* 0 else

872

**/

872

**/

873

874

static inline bool ip6gre_tnl_addr_conflict(const struct ip6_tnl *t,

874

static inline bool ip6gre_tnl_addr_conflict(const struct ip6_tnl *t,

875

const struct ipv6hdr *hdr)

875

const struct ipv6hdr *hdr)

876

{

876

{

877

return ipv6_addr_equal(&t->parms.raddr, &hdr->saddr);

877

return ipv6_addr_equal(&t->parms.raddr, &hdr->saddr);

878

}

878

}

879

880

static int ip6gre_xmit_other(struct sk_buff *skb, struct net_device *dev)

880

static int ip6gre_xmit_other(struct sk_buff *skb, struct net_device *dev)

881

{

881

{

882

struct ip6_tnl *t = netdev_priv(dev);

882

struct ip6_tnl *t = netdev_priv(dev);

883

int encap_limit = -1;

883

int encap_limit = -1;

884

struct flowi6 fl6;

884

struct flowi6 fl6;

885

__u32 mtu;

885

__u32 mtu;

886

int err;

886

int err;

887

888

if (!(t->parms.flags & IP6_TNL_F_IGN_ENCAP_LIMIT))

888

if (!(t->parms.flags & IP6_TNL_F_IGN_ENCAP_LIMIT))

889

encap_limit = t->parms.encap_limit;

889

encap_limit = t->parms.encap_limit;

890

891

memcpy(&fl6, &t->fl.u.ip6, sizeof(fl6));

891

memcpy(&fl6, &t->fl.u.ip6, sizeof(fl6));

892

fl6.flowi6_proto = skb->protocol;

892

fl6.flowi6_proto = skb->protocol;

893

894

err = ip6gre_xmit2(skb, dev, 0, &fl6, encap_limit, &mtu);

894

err = ip6gre_xmit2(skb, dev, 0, &fl6, encap_limit, &mtu);

895

896

return err;

896

return err;

897

}

897

}

898

899

static netdev_tx_t ip6gre_tunnel_xmit(struct sk_buff *skb,

899

static netdev_tx_t ip6gre_tunnel_xmit(struct sk_buff *skb,

900

struct net_device *dev)

900

struct net_device *dev)

901

{

901

{

902

struct ip6_tnl *t = netdev_priv(dev);

902

struct ip6_tnl *t = netdev_priv(dev);

903

struct net_device_stats *stats = &t->dev->stats;

903

struct net_device_stats *stats = &t->dev->stats;

904

int ret;

904

int ret;

905

906

if (!ip6_tnl_xmit_ctl(t))

906

if (!ip6_tnl_xmit_ctl(t))

907

goto tx_err;

907

goto tx_err;

908

909

switch (skb->protocol) {

909

switch (skb->protocol) {

910

case htons(ETH_P_IP):

910

case htons(ETH_P_IP):

911

ret = ip6gre_xmit_ipv4(skb, dev);

911

ret = ip6gre_xmit_ipv4(skb, dev);

912

break;

912

break;

913

case htons(ETH_P_IPV6):

913

case htons(ETH_P_IPV6):

914

ret = ip6gre_xmit_ipv6(skb, dev);

914

ret = ip6gre_xmit_ipv6(skb, dev);

915

break;

915

break;

916

default:

916

default:

917

ret = ip6gre_xmit_other(skb, dev);

917

ret = ip6gre_xmit_other(skb, dev);

918

break;

918

break;

919

}

919

}

920

921

if (ret < 0)

921

if (ret < 0)

922

goto tx_err;

922

goto tx_err;

923

924

return NETDEV_TX_OK;

924

return NETDEV_TX_OK;

925

926

tx_err:

926

tx_err:

927

stats->tx_errors++;

927

stats->tx_errors++;

928

stats->tx_dropped++;

928

stats->tx_dropped++;

929

kfree_skb(skb);

929

kfree_skb(skb);

930

return NETDEV_TX_OK;

930

return NETDEV_TX_OK;

931

}

931

}

932

933

static void ip6gre_tnl_link_config(struct ip6_tnl *t, int set_mtu)

933

static void ip6gre_tnl_link_config(struct ip6_tnl *t, int set_mtu)

934

{

934

{

935

struct net_device *dev = t->dev;

935

struct net_device *dev = t->dev;

936

struct __ip6_tnl_parm *p = &t->parms;

936

struct __ip6_tnl_parm *p = &t->parms;

937

struct flowi6 *fl6 = &t->fl.u.ip6;

937

struct flowi6 *fl6 = &t->fl.u.ip6;

938

int addend = sizeof(struct ipv6hdr) + 4;

938

int addend = sizeof(struct ipv6hdr) + 4;

939

940

if (dev->type != ARPHRD_ETHER) {

940

if (dev->type != ARPHRD_ETHER) {

941

memcpy(dev->dev_addr, &p->laddr, sizeof(struct in6_addr));

941

memcpy(dev->dev_addr, &p->laddr, sizeof(struct in6_addr));

942

memcpy(dev->broadcast, &p->raddr, sizeof(struct in6_addr));

942

memcpy(dev->broadcast, &p->raddr, sizeof(struct in6_addr));

943

}

943

}

944

945

/* Set up flowi template */

945

/* Set up flowi template */

946

fl6->saddr = p->laddr;

946

fl6->saddr = p->laddr;

947

fl6->daddr = p->raddr;

947

fl6->daddr = p->raddr;

948

fl6->flowi6_oif = p->link;

948

fl6->flowi6_oif = p->link;

949

fl6->flowlabel = 0;

949

fl6->flowlabel = 0;

950

951

if (!(p->flags&IP6_TNL_F_USE_ORIG_TCLASS))

951

if (!(p->flags&IP6_TNL_F_USE_ORIG_TCLASS))

952

fl6->flowlabel |= IPV6_TCLASS_MASK & p->flowinfo;

952

fl6->flowlabel |= IPV6_TCLASS_MASK & p->flowinfo;

953

if (!(p->flags&IP6_TNL_F_USE_ORIG_FLOWLABEL))

953

if (!(p->flags&IP6_TNL_F_USE_ORIG_FLOWLABEL))

954

fl6->flowlabel |= IPV6_FLOWLABEL_MASK & p->flowinfo;

954

fl6->flowlabel |= IPV6_FLOWLABEL_MASK & p->flowinfo;

955

956

p->flags &= ~(IP6_TNL_F_CAP_XMIT|IP6_TNL_F_CAP_RCV|IP6_TNL_F_CAP_PER_PACKET);

956

p->flags &= ~(IP6_TNL_F_CAP_XMIT|IP6_TNL_F_CAP_RCV|IP6_TNL_F_CAP_PER_PACKET);

957

p->flags |= ip6_tnl_get_cap(t, &p->laddr, &p->raddr);

957

p->flags |= ip6_tnl_get_cap(t, &p->laddr, &p->raddr);

958

959

if (p->flags&IP6_TNL_F_CAP_XMIT &&

959

if (p->flags&IP6_TNL_F_CAP_XMIT &&

960

p->flags&IP6_TNL_F_CAP_RCV && dev->type != ARPHRD_ETHER)

960

p->flags&IP6_TNL_F_CAP_RCV && dev->type != ARPHRD_ETHER)

961

dev->flags |= IFF_POINTOPOINT;

961

dev->flags |= IFF_POINTOPOINT;

962

else

962

else

963

dev->flags &= ~IFF_POINTOPOINT;

963

dev->flags &= ~IFF_POINTOPOINT;

964

965

/* Precalculate GRE options length */

965

/* Precalculate GRE options length */

966

if (t->parms.o_flags&(GRE_CSUM|GRE_KEY|GRE_SEQ)) {

966

if (t->parms.o_flags&(GRE_CSUM|GRE_KEY|GRE_SEQ)) {

967

if (t->parms.o_flags&GRE_CSUM)

967

if (t->parms.o_flags&GRE_CSUM)

968

addend += 4;

968

addend += 4;

969

if (t->parms.o_flags&GRE_KEY)

969

if (t->parms.o_flags&GRE_KEY)

970

addend += 4;

970

addend += 4;

971

if (t->parms.o_flags&GRE_SEQ)

971

if (t->parms.o_flags&GRE_SEQ)

972

addend += 4;

972

addend += 4;

973

}

973

}

974

t->hlen = addend;

974

t->hlen = addend;

975

976

if (p->flags & IP6_TNL_F_CAP_XMIT) {

976

if (p->flags & IP6_TNL_F_CAP_XMIT) {

977

int strict = (ipv6_addr_type(&p->raddr) &

977

int strict = (ipv6_addr_type(&p->raddr) &

978

(IPV6_ADDR_MULTICAST|IPV6_ADDR_LINKLOCAL));

978

(IPV6_ADDR_MULTICAST|IPV6_ADDR_LINKLOCAL));

979

980

struct rt6_info *rt = rt6_lookup(dev_net(dev),

980

struct rt6_info *rt = rt6_lookup(dev_net(dev),

981

&p->raddr, &p->laddr,

981

&p->raddr, &p->laddr,

982

p->link, strict);

982

p->link, strict);

983

984

if (rt == NULL)

984

if (rt == NULL)

985

return;

985

return;

986

987

if (rt->dst.dev) {

987

if (rt->dst.dev) {

988

dev->hard_header_len = rt->dst.dev->hard_header_len + addend;

988

dev->hard_header_len = rt->dst.dev->hard_header_len + addend;

989

990

if (set_mtu) {

990

if (set_mtu) {

991

dev->mtu = rt->dst.dev->mtu - addend;

991

dev->mtu = rt->dst.dev->mtu - addend;

992

if (!(t->parms.flags & IP6_TNL_F_IGN_ENCAP_LIMIT))

992

if (!(t->parms.flags & IP6_TNL_F_IGN_ENCAP_LIMIT))

993

dev->mtu -= 8;

993

dev->mtu -= 8;

994

995

if (dev->mtu < IPV6_MIN_MTU)

995

if (dev->mtu < IPV6_MIN_MTU)

996

dev->mtu = IPV6_MIN_MTU;

996

dev->mtu = IPV6_MIN_MTU;

997

}

997

}

998

}

998

}

999

ip6_rt_put(rt);

999

ip6_rt_put(rt);

1000

}

1000

}

1001

}

1001

}

1002

1003

static int ip6gre_tnl_change(struct ip6_tnl *t,

1003

static int ip6gre_tnl_change(struct ip6_tnl *t,

1004

const struct __ip6_tnl_parm *p, int set_mtu)

1004

const struct __ip6_tnl_parm *p, int set_mtu)

1005

{

1005

{

1006

t->parms.laddr = p->laddr;

1006

t->parms.laddr = p->laddr;

1007

t->parms.raddr = p->raddr;

1007

t->parms.raddr = p->raddr;

1008

t->parms.flags = p->flags;

1008

t->parms.flags = p->flags;

1009

t->parms.hop_limit = p->hop_limit;

1009

t->parms.hop_limit = p->hop_limit;

1010

t->parms.encap_limit = p->encap_limit;

1010

t->parms.encap_limit = p->encap_limit;

1011

t->parms.flowinfo = p->flowinfo;

1011

t->parms.flowinfo = p->flowinfo;

1012

t->parms.link = p->link;

1012

t->parms.link = p->link;

1013

t->parms.proto = p->proto;

1013

t->parms.proto = p->proto;

1014

t->parms.i_key = p->i_key;

1014

t->parms.i_key = p->i_key;

1015

t->parms.o_key = p->o_key;

1015

t->parms.o_key = p->o_key;

1016

t->parms.i_flags = p->i_flags;

1016

t->parms.i_flags = p->i_flags;

1017

t->parms.o_flags = p->o_flags;

1017

t->parms.o_flags = p->o_flags;

1018

ip6_tnl_dst_reset(t);

1018

ip6_tnl_dst_reset(t);

1019

ip6gre_tnl_link_config(t, set_mtu);

1019

ip6gre_tnl_link_config(t, set_mtu);

1020

return 0;

1020

return 0;

1021

}

1021

}

1022

1023

static void ip6gre_tnl_parm_from_user(struct __ip6_tnl_parm *p,

1023

static void ip6gre_tnl_parm_from_user(struct __ip6_tnl_parm *p,

1024

const struct ip6_tnl_parm2 *u)

1024

const struct ip6_tnl_parm2 *u)

1025

{

1025

{

1026

p->laddr = u->laddr;

1026

p->laddr = u->laddr;

1027

p->raddr = u->raddr;

1027

p->raddr = u->raddr;

1028

p->flags = u->flags;

1028

p->flags = u->flags;

1029

p->hop_limit = u->hop_limit;

1029

p->hop_limit = u->hop_limit;

1030

p->encap_limit = u->encap_limit;

1030

p->encap_limit = u->encap_limit;

1031

p->flowinfo = u->flowinfo;

1031

p->flowinfo = u->flowinfo;

1032

p->link = u->link;

1032

p->link = u->link;

1033

p->i_key = u->i_key;

1033

p->i_key = u->i_key;

1034

p->o_key = u->o_key;

1034

p->o_key = u->o_key;

1035

p->i_flags = u->i_flags;

1035

p->i_flags = u->i_flags;

1036

p->o_flags = u->o_flags;

1036

p->o_flags = u->o_flags;

1037

memcpy(p->name, u->name, sizeof(u->name));

1037

memcpy(p->name, u->name, sizeof(u->name));

1038

}

1038

}

1039

1040

static void ip6gre_tnl_parm_to_user(struct ip6_tnl_parm2 *u,

1040

static void ip6gre_tnl_parm_to_user(struct ip6_tnl_parm2 *u,

1041

const struct __ip6_tnl_parm *p)

1041

const struct __ip6_tnl_parm *p)

1042

{

1042

{

1043

u->proto = IPPROTO_GRE;

1043

u->proto = IPPROTO_GRE;

1044

u->laddr = p->laddr;

1044

u->laddr = p->laddr;

1045

u->raddr = p->raddr;

1045

u->raddr = p->raddr;

1046

u->flags = p->flags;

1046

u->flags = p->flags;

1047

u->hop_limit = p->hop_limit;

1047

u->hop_limit = p->hop_limit;

1048

u->encap_limit = p->encap_limit;

1048

u->encap_limit = p->encap_limit;

1049

u->flowinfo = p->flowinfo;

1049

u->flowinfo = p->flowinfo;

1050

u->link = p->link;

1050

u->link = p->link;

1051

u->i_key = p->i_key;

1051

u->i_key = p->i_key;

1052

u->o_key = p->o_key;

1052

u->o_key = p->o_key;

1053

u->i_flags = p->i_flags;

1053

u->i_flags = p->i_flags;

1054

u->o_flags = p->o_flags;

1054

u->o_flags = p->o_flags;

1055

memcpy(u->name, p->name, sizeof(u->name));

1055

memcpy(u->name, p->name, sizeof(u->name));

1056

}

1056

}

1057

1058

static int ip6gre_tunnel_ioctl(struct net_device *dev,

1058

static int ip6gre_tunnel_ioctl(struct net_device *dev,

1059

struct ifreq *ifr, int cmd)

1059

struct ifreq *ifr, int cmd)

1060

{

1060

{

1061

int err = 0;

1061

int err = 0;

1062

struct ip6_tnl_parm2 p;

1062

struct ip6_tnl_parm2 p;

1063

struct __ip6_tnl_parm p1;

1063

struct __ip6_tnl_parm p1;

1064

struct ip6_tnl *t;

1064

struct ip6_tnl *t;

1065

struct net *net = dev_net(dev);

1065

struct net *net = dev_net(dev);

1066

struct ip6gre_net *ign = net_generic(net, ip6gre_net_id);

1066

struct ip6gre_net *ign = net_generic(net, ip6gre_net_id);

1067

1068

switch (cmd) {

1068

switch (cmd) {

1069

case SIOCGETTUNNEL:

1069

case SIOCGETTUNNEL:

1070

t = NULL;

1070

t = NULL;

1071

if (dev == ign->fb_tunnel_dev) {

1071

if (dev == ign->fb_tunnel_dev) {

1072

if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) {

1072

if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) {

1073

err = -EFAULT;

1073

err = -EFAULT;

1074

break;

1074

break;

1075

}

1075

}

1076

ip6gre_tnl_parm_from_user(&p1, &p);

1076

ip6gre_tnl_parm_from_user(&p1, &p);

1077

t = ip6gre_tunnel_locate(net, &p1, 0);

1077

t = ip6gre_tunnel_locate(net, &p1, 0);

1078

}

1078

}

1079

if (t == NULL)

1079

if (t == NULL)

1080

t = netdev_priv(dev);

1080

t = netdev_priv(dev);

1081

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

1081

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

1082

ip6gre_tnl_parm_to_user(&p, &t->parms);

1082

ip6gre_tnl_parm_to_user(&p, &t->parms);

1083

if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))

1083

if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))

1084

err = -EFAULT;

1084

err = -EFAULT;

1085

break;

1085

break;

1086

1087

case SIOCADDTUNNEL:

1087

case SIOCADDTUNNEL:

1088

case SIOCCHGTUNNEL:

1088

case SIOCCHGTUNNEL:

1089

err = -EPERM;

1089

err = -EPERM;

1090

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

1090

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

1091

goto done;

1091

goto done;

1092

1093

err = -EFAULT;

1093

err = -EFAULT;

1094

if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))

1094

if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))

1095

goto done;

1095

goto done;

1096

1097

err = -EINVAL;

1097

err = -EINVAL;

1098

if ((p.i_flags|p.o_flags)&(GRE_VERSION|GRE_ROUTING))

1098

if ((p.i_flags|p.o_flags)&(GRE_VERSION|GRE_ROUTING))

1099

goto done;

1099

goto done;

1100

1101

if (!(p.i_flags&GRE_KEY))

1101

if (!(p.i_flags&GRE_KEY))

1102

p.i_key = 0;

1102

p.i_key = 0;

1103

if (!(p.o_flags&GRE_KEY))

1103

if (!(p.o_flags&GRE_KEY))

1104

p.o_key = 0;

1104

p.o_key = 0;

1105

1106

ip6gre_tnl_parm_from_user(&p1, &p);

1106

ip6gre_tnl_parm_from_user(&p1, &p);

1107

t = ip6gre_tunnel_locate(net, &p1, cmd == SIOCADDTUNNEL);

1107

t = ip6gre_tunnel_locate(net, &p1, cmd == SIOCADDTUNNEL);

1108

1109

if (dev != ign->fb_tunnel_dev && cmd == SIOCCHGTUNNEL) {

1109

if (dev != ign->fb_tunnel_dev && cmd == SIOCCHGTUNNEL) {

1110

if (t != NULL) {

1110

if (t != NULL) {

1111

if (t->dev != dev) {

1111

if (t->dev != dev) {

1112

err = -EEXIST;

1112

err = -EEXIST;

1113

break;

1113

break;

1114

}

1114

}

1115

} else {

1115

} else {

1116

t = netdev_priv(dev);

1116

t = netdev_priv(dev);

1117

1118

ip6gre_tunnel_unlink(ign, t);

1118

ip6gre_tunnel_unlink(ign, t);

1119

synchronize_net();

1119

synchronize_net();

1120

ip6gre_tnl_change(t, &p1, 1);

1120

ip6gre_tnl_change(t, &p1, 1);

1121

ip6gre_tunnel_link(ign, t);

1121

ip6gre_tunnel_link(ign, t);

1122

netdev_state_change(dev);

1122

netdev_state_change(dev);

1123

}

1123

}

1124

}

1124

}

1125

1126

if (t) {

1126

if (t) {

1127

err = 0;

1127

err = 0;

1128

1129

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

1129

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

1130

ip6gre_tnl_parm_to_user(&p, &t->parms);

1130

ip6gre_tnl_parm_to_user(&p, &t->parms);

1131

if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))

1131

if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))

1132

err = -EFAULT;

1132

err = -EFAULT;

1133

} else

1133

} else

1134

err = (cmd == SIOCADDTUNNEL ? -ENOBUFS : -ENOENT);

1134

err = (cmd == SIOCADDTUNNEL ? -ENOBUFS : -ENOENT);

1135

break;

1135

break;

1136

1137

case SIOCDELTUNNEL:

1137

case SIOCDELTUNNEL:

1138

err = -EPERM;

1138

err = -EPERM;

1139

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

1139

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

1140

goto done;

1140

goto done;

1141

1142

if (dev == ign->fb_tunnel_dev) {

1142

if (dev == ign->fb_tunnel_dev) {

1143

err = -EFAULT;

1143

err = -EFAULT;

1144

if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))

1144

if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))

1145

goto done;

1145

goto done;

1146

err = -ENOENT;

1146

err = -ENOENT;

1147

ip6gre_tnl_parm_from_user(&p1, &p);

1147

ip6gre_tnl_parm_from_user(&p1, &p);

1148

t = ip6gre_tunnel_locate(net, &p1, 0);

1148

t = ip6gre_tunnel_locate(net, &p1, 0);

1149

if (t == NULL)

1149

if (t == NULL)

1150

goto done;

1150

goto done;

1151

err = -EPERM;

1151

err = -EPERM;

1152

if (t == netdev_priv(ign->fb_tunnel_dev))

1152

if (t == netdev_priv(ign->fb_tunnel_dev))

1153

goto done;

1153

goto done;

1154

dev = t->dev;

1154

dev = t->dev;

1155

}

1155

}

1156

unregister_netdevice(dev);

1156

unregister_netdevice(dev);

1157

err = 0;

1157

err = 0;

1158

break;

1158

break;

1159

1160

default:

1160

default:

1161

err = -EINVAL;

1161

err = -EINVAL;

1162

}

1162

}

1163

1164

done:

1164

done:

1165

return err;

1165

return err;

1166

}

1166

}

1167

1168

static int ip6gre_tunnel_change_mtu(struct net_device *dev, int new_mtu)

1168

static int ip6gre_tunnel_change_mtu(struct net_device *dev, int new_mtu)

1169

{

1169

{

1170

if (new_mtu < 68 ||

1170

if (new_mtu < 68 ||

1171

new_mtu > 0xFFF8 - dev->hard_header_len)

1171

new_mtu > 0xFFF8 - dev->hard_header_len)

1172

return -EINVAL;

1172

return -EINVAL;

1173

dev->mtu = new_mtu;

1173

dev->mtu = new_mtu;

1174

return 0;

1174

return 0;

1175

}

1175

}

1176

1177

static int ip6gre_header(struct sk_buff *skb, struct net_device *dev,

1177

static int ip6gre_header(struct sk_buff *skb, struct net_device *dev,

1178

unsigned short type,

1178

unsigned short type,

1179

const void *daddr, const void *saddr, unsigned int len)

1179

const void *daddr, const void *saddr, unsigned int len)

1180

{

1180

{

1181

struct ip6_tnl *t = netdev_priv(dev);

1181

struct ip6_tnl *t = netdev_priv(dev);

1182

struct ipv6hdr *ipv6h = (struct ipv6hdr *)skb_push(skb, t->hlen);

1182

struct ipv6hdr *ipv6h = (struct ipv6hdr *)skb_push(skb, t->hlen);

1183

__be16 *p = (__be16 *)(ipv6h+1);

1183

__be16 *p = (__be16 *)(ipv6h+1);

1184

1185

ip6_flow_hdr(ipv6h, 0, t->fl.u.ip6.flowlabel);

1185

ip6_flow_hdr(ipv6h, 0, t->fl.u.ip6.flowlabel);

1186

ipv6h->hop_limit = t->parms.hop_limit;

1186

ipv6h->hop_limit = t->parms.hop_limit;

1187

ipv6h->nexthdr = NEXTHDR_GRE;

1187

ipv6h->nexthdr = NEXTHDR_GRE;

1188

ipv6h->saddr = t->parms.laddr;

1188

ipv6h->saddr = t->parms.laddr;

1189

ipv6h->daddr = t->parms.raddr;

1189

ipv6h->daddr = t->parms.raddr;

1190

1191

p[0] = t->parms.o_flags;

1191

p[0] = t->parms.o_flags;

1192

p[1] = htons(type);

1192

p[1] = htons(type);

1193

1194

/*

1194

/*

1195

* Set the source hardware address.

1195

* Set the source hardware address.

1196

*/

1196

*/

1197

1198

if (saddr)

1198

if (saddr)

1199

memcpy(&ipv6h->saddr, saddr, sizeof(struct in6_addr));

1199

memcpy(&ipv6h->saddr, saddr, sizeof(struct in6_addr));

1200

if (daddr)

1200

if (daddr)

1201

memcpy(&ipv6h->daddr, daddr, sizeof(struct in6_addr));

1201

memcpy(&ipv6h->daddr, daddr, sizeof(struct in6_addr));

1202

if (!ipv6_addr_any(&ipv6h->daddr))

1202

if (!ipv6_addr_any(&ipv6h->daddr))

1203

return t->hlen;

1203

return t->hlen;

1204

1205

return -t->hlen;

1205

return -t->hlen;

1206

}

1206

}

1207

1208

static const struct header_ops ip6gre_header_ops = {

1208

static const struct header_ops ip6gre_header_ops = {

1209

.create = ip6gre_header,

1209

.create = ip6gre_header,

1210

};

1210

};

1211

1212

static const struct net_device_ops ip6gre_netdev_ops = {

1212

static const struct net_device_ops ip6gre_netdev_ops = {

1213

.ndo_init = ip6gre_tunnel_init,

1213

.ndo_init = ip6gre_tunnel_init,

1214

.ndo_uninit = ip6gre_tunnel_uninit,

1214

.ndo_uninit = ip6gre_tunnel_uninit,

1215

.ndo_start_xmit = ip6gre_tunnel_xmit,

1215

.ndo_start_xmit = ip6gre_tunnel_xmit,

1216

.ndo_do_ioctl = ip6gre_tunnel_ioctl,

1216

.ndo_do_ioctl = ip6gre_tunnel_ioctl,

1217

.ndo_change_mtu = ip6gre_tunnel_change_mtu,

1217

.ndo_change_mtu = ip6gre_tunnel_change_mtu,

1218

.ndo_get_stats64 = ip_tunnel_get_stats64,

1218

.ndo_get_stats64 = ip_tunnel_get_stats64,

1219

};

1219

};

1220

1221

static void ip6gre_dev_free(struct net_device *dev)

1221

static void ip6gre_dev_free(struct net_device *dev)

1222

{

1222

{

1223

free_percpu(dev->tstats);

1223

free_percpu(dev->tstats);

1224

free_netdev(dev);

1224

free_netdev(dev);

1225

}

1225

}

1226

1227

static void ip6gre_tunnel_setup(struct net_device *dev)

1227

static void ip6gre_tunnel_setup(struct net_device *dev)

1228

{

1228

{

1229

struct ip6_tnl *t;

1229

struct ip6_tnl *t;

1230

1231

dev->netdev_ops = &ip6gre_netdev_ops;

1231

dev->netdev_ops = &ip6gre_netdev_ops;

1232

dev->destructor = ip6gre_dev_free;

1232

dev->destructor = ip6gre_dev_free;

1233

1234

dev->type = ARPHRD_IP6GRE;

1234

dev->type = ARPHRD_IP6GRE;

1235

dev->hard_header_len = LL_MAX_HEADER + sizeof(struct ipv6hdr) + 4;

1235

dev->hard_header_len = LL_MAX_HEADER + sizeof(struct ipv6hdr) + 4;

1236

dev->mtu = ETH_DATA_LEN - sizeof(struct ipv6hdr) - 4;

1236

dev->mtu = ETH_DATA_LEN - sizeof(struct ipv6hdr) - 4;

1237

t = netdev_priv(dev);

1237

t = netdev_priv(dev);

1238

if (!(t->parms.flags & IP6_TNL_F_IGN_ENCAP_LIMIT))

1238

if (!(t->parms.flags & IP6_TNL_F_IGN_ENCAP_LIMIT))

1239

dev->mtu -= 8;

1239

dev->mtu -= 8;

1240

dev->flags |= IFF_NOARP;

1240

dev->flags |= IFF_NOARP;

1241

dev->iflink = 0;

1241

dev->iflink = 0;

1242

dev->addr_len = sizeof(struct in6_addr);

1242

dev->addr_len = sizeof(struct in6_addr);

1243

dev->features |= NETIF_F_NETNS_LOCAL;

1243

dev->features |= NETIF_F_NETNS_LOCAL;

1244

dev->priv_flags &= ~IFF_XMIT_DST_RELEASE;

1244

dev->priv_flags &= ~IFF_XMIT_DST_RELEASE;

1245

}

1245

}

1246

1247

static int ip6gre_tunnel_init(struct net_device *dev)

1247

static int ip6gre_tunnel_init(struct net_device *dev)

1248

{

1248

{

1249

struct ip6_tnl *tunnel;

1249

struct ip6_tnl *tunnel;

1250

int i;

1250

int i;

1251

1252

tunnel = netdev_priv(dev);

1252

tunnel = netdev_priv(dev);

1253

1254

tunnel->dev = dev;

1254

tunnel->dev = dev;

1255

tunnel->net = dev_net(dev);

1255

tunnel->net = dev_net(dev);

1256

strcpy(tunnel->parms.name, dev->name);

1256

strcpy(tunnel->parms.name, dev->name);

1257

1258

memcpy(dev->dev_addr, &tunnel->parms.laddr, sizeof(struct in6_addr));

1258

memcpy(dev->dev_addr, &tunnel->parms.laddr, sizeof(struct in6_addr));

1259

memcpy(dev->broadcast, &tunnel->parms.raddr, sizeof(struct in6_addr));

1259

memcpy(dev->broadcast, &tunnel->parms.raddr, sizeof(struct in6_addr));

1260

1261

if (ipv6_addr_any(&tunnel->parms.raddr))

1261

if (ipv6_addr_any(&tunnel->parms.raddr))

1262

dev->header_ops = &ip6gre_header_ops;

1262

dev->header_ops = &ip6gre_header_ops;

1263

1264

dev->tstats = alloc_percpu(struct pcpu_sw_netstats);

1264

dev->tstats = alloc_percpu(struct pcpu_sw_netstats);

1265

if (!dev->tstats)

1265

if (!dev->tstats)

1266

return -ENOMEM;

1266

return -ENOMEM;

1267

1268

for_each_possible_cpu(i) {

1268

for_each_possible_cpu(i) {

1269

struct pcpu_sw_netstats *ip6gre_tunnel_stats;

1269

struct pcpu_sw_netstats *ip6gre_tunnel_stats;

1270

ip6gre_tunnel_stats = per_cpu_ptr(dev->tstats, i);

1270

ip6gre_tunnel_stats = per_cpu_ptr(dev->tstats, i);

1271

u64_stats_init(&ip6gre_tunnel_stats->syncp);

1271

u64_stats_init(&ip6gre_tunnel_stats->syncp);

1272

}

1272

}

1273

1274

dev->iflink = tunnel->parms.link;

1274

dev->iflink = tunnel->parms.link;

1275

1276

return 0;

1276

return 0;

1277

}

1277

}

1278

1279

static void ip6gre_fb_tunnel_init(struct net_device *dev)

1279

static void ip6gre_fb_tunnel_init(struct net_device *dev)

1280

{

1280

{

1281

struct ip6_tnl *tunnel = netdev_priv(dev);

1281

struct ip6_tnl *tunnel = netdev_priv(dev);

1282

1283

tunnel->dev = dev;

1283

tunnel->dev = dev;

1284

tunnel->net = dev_net(dev);

1284

tunnel->net = dev_net(dev);

1285

strcpy(tunnel->parms.name, dev->name);

1285

strcpy(tunnel->parms.name, dev->name);

1286

1287

tunnel->hlen = sizeof(struct ipv6hdr) + 4;

1287

tunnel->hlen = sizeof(struct ipv6hdr) + 4;

1288

1289

dev_hold(dev);

1289

dev_hold(dev);

1290

}

1290

}

1291

1292

1293

static struct inet6_protocol ip6gre_protocol __read_mostly = {

1293

static struct inet6_protocol ip6gre_protocol __read_mostly = {

1294

.handler = ip6gre_rcv,

1294

.handler = ip6gre_rcv,

1295

.err_handler = ip6gre_err,

1295

.err_handler = ip6gre_err,

1296

.flags = INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,

1296

.flags = INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,

1297

};

1297

};

1298

1299

static void ip6gre_destroy_tunnels(struct ip6gre_net *ign,

1299

static void ip6gre_destroy_tunnels(struct ip6gre_net *ign,

1300

struct list_head *head)

1300

struct list_head *head)

1301

{

1301

{

1302

int prio;

1302

int prio;

1303

1304

for (prio = 0; prio < 4; prio++) {

1304

for (prio = 0; prio < 4; prio++) {

1305

int h;

1305

int h;

1306

for (h = 0; h < HASH_SIZE; h++) {

1306

for (h = 0; h < HASH_SIZE; h++) {

1307

struct ip6_tnl *t;

1307

struct ip6_tnl *t;

1308

1309

t = rtnl_dereference(ign->tunnels[prio][h]);

1309

t = rtnl_dereference(ign->tunnels[prio][h]);

1310

1311

while (t != NULL) {

1311

while (t != NULL) {

1312

unregister_netdevice_queue(t->dev, head);

1312

unregister_netdevice_queue(t->dev, head);

1313

t = rtnl_dereference(t->next);

1313

t = rtnl_dereference(t->next);

1314

}

1314

}

1315

}

1315

}

1316

}

1316

}

1317

}

1317

}

1318

1319

static int __net_init ip6gre_init_net(struct net *net)

1319

static int __net_init ip6gre_init_net(struct net *net)

1320

{

1320

{

1321

struct ip6gre_net *ign = net_generic(net, ip6gre_net_id);

1321

struct ip6gre_net *ign = net_generic(net, ip6gre_net_id);

1322

int err;

1322

int err;

1323

1324

ign->fb_tunnel_dev = alloc_netdev(sizeof(struct ip6_tnl), "ip6gre0",

1324

ign->fb_tunnel_dev = alloc_netdev(sizeof(struct ip6_tnl), "ip6gre0",

1325

ip6gre_tunnel_setup);

1325

ip6gre_tunnel_setup);

1326

if (!ign->fb_tunnel_dev) {

1326

if (!ign->fb_tunnel_dev) {

1327

err = -ENOMEM;

1327

err = -ENOMEM;

1328

goto err_alloc_dev;

1328

goto err_alloc_dev;

1329

}

1329

}

1330

dev_net_set(ign->fb_tunnel_dev, net);

1330

dev_net_set(ign->fb_tunnel_dev, net);

1331

1332

ip6gre_fb_tunnel_init(ign->fb_tunnel_dev);

1332

ip6gre_fb_tunnel_init(ign->fb_tunnel_dev);

1333

ign->fb_tunnel_dev->rtnl_link_ops = &ip6gre_link_ops;

1333

ign->fb_tunnel_dev->rtnl_link_ops = &ip6gre_link_ops;

1334

1335

err = register_netdev(ign->fb_tunnel_dev);

1335

err = register_netdev(ign->fb_tunnel_dev);

1336

if (err)

1336

if (err)

1337

goto err_reg_dev;

1337

goto err_reg_dev;

1338

1339

rcu_assign_pointer(ign->tunnels_wc[0],

1339

rcu_assign_pointer(ign->tunnels_wc[0],

1340

netdev_priv(ign->fb_tunnel_dev));

1340

netdev_priv(ign->fb_tunnel_dev));

1341

return 0;

1341

return 0;

1342

1343

err_reg_dev:

1343

err_reg_dev:

1344

ip6gre_dev_free(ign->fb_tunnel_dev);

1344

ip6gre_dev_free(ign->fb_tunnel_dev);

1345

err_alloc_dev:

1345

err_alloc_dev:

1346

return err;

1346

return err;

1347

}

1347

}

1348

1349

static void __net_exit ip6gre_exit_net(struct net *net)

1349

static void __net_exit ip6gre_exit_net(struct net *net)

1350

{

1350

{

1351

struct ip6gre_net *ign;

1351

struct ip6gre_net *ign;

1352

LIST_HEAD(list);

1352

LIST_HEAD(list);

1353

1354

ign = net_generic(net, ip6gre_net_id);

1354

ign = net_generic(net, ip6gre_net_id);

1355

rtnl_lock();

1355

rtnl_lock();

1356

ip6gre_destroy_tunnels(ign, &list);

1356

ip6gre_destroy_tunnels(ign, &list);

1357

unregister_netdevice_many(&list);

1357

unregister_netdevice_many(&list);

1358

rtnl_unlock();

1358

rtnl_unlock();

1359

}

1359

}

1360

1361

static struct pernet_operations ip6gre_net_ops = {

1361

static struct pernet_operations ip6gre_net_ops = {

1362

.init = ip6gre_init_net,

1362

.init = ip6gre_init_net,

1363

.exit = ip6gre_exit_net,

1363

.exit = ip6gre_exit_net,

1364

.id = &ip6gre_net_id,

1364

.id = &ip6gre_net_id,

1365

.size = sizeof(struct ip6gre_net),

1365

.size = sizeof(struct ip6gre_net),

1366

};

1366

};

1367

1368

static int ip6gre_tunnel_validate(struct nlattr *tb[], struct nlattr *data[])

1368

static int ip6gre_tunnel_validate(struct nlattr *tb[], struct nlattr *data[])

1369

{

1369

{

1370

__be16 flags;

1370

__be16 flags;

1371

1372

if (!data)

1372

if (!data)

1373

return 0;

1373

return 0;

1374

1375

flags = 0;

1375

flags = 0;

1376

if (data[IFLA_GRE_IFLAGS])

1376

if (data[IFLA_GRE_IFLAGS])

1377

flags |= nla_get_be16(data[IFLA_GRE_IFLAGS]);

1377

flags |= nla_get_be16(data[IFLA_GRE_IFLAGS]);

1378

if (data[IFLA_GRE_OFLAGS])

1378

if (data[IFLA_GRE_OFLAGS])

1379

flags |= nla_get_be16(data[IFLA_GRE_OFLAGS]);

1379

flags |= nla_get_be16(data[IFLA_GRE_OFLAGS]);

1380

if (flags & (GRE_VERSION|GRE_ROUTING))

1380

if (flags & (GRE_VERSION|GRE_ROUTING))

1381

return -EINVAL;

1381

return -EINVAL;

1382

1383

return 0;

1383

return 0;

1384

}

1384

}

1385

1386

static int ip6gre_tap_validate(struct nlattr *tb[], struct nlattr *data[])

1386

static int ip6gre_tap_validate(struct nlattr *tb[], struct nlattr *data[])

1387

{

1387

{

1388

struct in6_addr daddr;

1388

struct in6_addr daddr;

1389

1390

if (tb[IFLA_ADDRESS]) {

1390

if (tb[IFLA_ADDRESS]) {

1391

if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)

1391

if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)

1392

return -EINVAL;

1392

return -EINVAL;

1393

if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))

1393

if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))

1394

return -EADDRNOTAVAIL;

1394

return -EADDRNOTAVAIL;

1395

}

1395

}

1396

1397

if (!data)

1397

if (!data)

1398

goto out;

1398

goto out;

1399

1400

if (data[IFLA_GRE_REMOTE]) {

1400

if (data[IFLA_GRE_REMOTE]) {

1401

nla_memcpy(&daddr, data[IFLA_GRE_REMOTE], sizeof(struct in6_addr));

1401

nla_memcpy(&daddr, data[IFLA_GRE_REMOTE], sizeof(struct in6_addr));

1402

if (ipv6_addr_any(&daddr))

1402

if (ipv6_addr_any(&daddr))

1403

return -EINVAL;

1403

return -EINVAL;

1404

}

1404

}

1405

1406

out:

1406

out:

1407

return ip6gre_tunnel_validate(tb, data);

1407

return ip6gre_tunnel_validate(tb, data);

1408

}

1408

}

1409

1410

1411

static void ip6gre_netlink_parms(struct nlattr *data[],

1411

static void ip6gre_netlink_parms(struct nlattr *data[],

1412

struct __ip6_tnl_parm *parms)

1412

struct __ip6_tnl_parm *parms)

1413

{

1413

{

1414

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

1414

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

1415

1416

if (!data)

1416

if (!data)

1417

return;

1417

return;

1418

1419

if (data[IFLA_GRE_LINK])

1419

if (data[IFLA_GRE_LINK])

1420

parms->link = nla_get_u32(data[IFLA_GRE_LINK]);

1420

parms->link = nla_get_u32(data[IFLA_GRE_LINK]);

1421

1422

if (data[IFLA_GRE_IFLAGS])

1422

if (data[IFLA_GRE_IFLAGS])

1423

parms->i_flags = nla_get_be16(data[IFLA_GRE_IFLAGS]);

1423

parms->i_flags = nla_get_be16(data[IFLA_GRE_IFLAGS]);

1424

1425

if (data[IFLA_GRE_OFLAGS])

1425

if (data[IFLA_GRE_OFLAGS])

1426

parms->o_flags = nla_get_be16(data[IFLA_GRE_OFLAGS]);

1426

parms->o_flags = nla_get_be16(data[IFLA_GRE_OFLAGS]);

1427

1428

if (data[IFLA_GRE_IKEY])

1428

if (data[IFLA_GRE_IKEY])

1429

parms->i_key = nla_get_be32(data[IFLA_GRE_IKEY]);

1429

parms->i_key = nla_get_be32(data[IFLA_GRE_IKEY]);

1430

1431

if (data[IFLA_GRE_OKEY])

1431

if (data[IFLA_GRE_OKEY])

1432

parms->o_key = nla_get_be32(data[IFLA_GRE_OKEY]);

1432

parms->o_key = nla_get_be32(data[IFLA_GRE_OKEY]);

1433

1434

if (data[IFLA_GRE_LOCAL])

1434

if (data[IFLA_GRE_LOCAL])

1435

nla_memcpy(&parms->laddr, data[IFLA_GRE_LOCAL], sizeof(struct in6_addr));

1435

nla_memcpy(&parms->laddr, data[IFLA_GRE_LOCAL], sizeof(struct in6_addr));

1436

1437

if (data[IFLA_GRE_REMOTE])

1437

if (data[IFLA_GRE_REMOTE])

1438

nla_memcpy(&parms->raddr, data[IFLA_GRE_REMOTE], sizeof(struct in6_addr));

1438

nla_memcpy(&parms->raddr, data[IFLA_GRE_REMOTE], sizeof(struct in6_addr));

1439

1440

if (data[IFLA_GRE_TTL])

1440

if (data[IFLA_GRE_TTL])

1441

parms->hop_limit = nla_get_u8(data[IFLA_GRE_TTL]);

1441

parms->hop_limit = nla_get_u8(data[IFLA_GRE_TTL]);

1442

1443

if (data[IFLA_GRE_ENCAP_LIMIT])

1443

if (data[IFLA_GRE_ENCAP_LIMIT])

1444

parms->encap_limit = nla_get_u8(data[IFLA_GRE_ENCAP_LIMIT]);

1444

parms->encap_limit = nla_get_u8(data[IFLA_GRE_ENCAP_LIMIT]);

1445

1446

if (data[IFLA_GRE_FLOWINFO])

1446

if (data[IFLA_GRE_FLOWINFO])

1447

parms->flowinfo = nla_get_u32(data[IFLA_GRE_FLOWINFO]);

1447

parms->flowinfo = nla_get_u32(data[IFLA_GRE_FLOWINFO]);

1448

1449

if (data[IFLA_GRE_FLAGS])

1449

if (data[IFLA_GRE_FLAGS])

1450

parms->flags = nla_get_u32(data[IFLA_GRE_FLAGS]);

1450

parms->flags = nla_get_u32(data[IFLA_GRE_FLAGS]);

1451

}

1451

}

1452

1453

static int ip6gre_tap_init(struct net_device *dev)

1453

static int ip6gre_tap_init(struct net_device *dev)

1454

{

1454

{

1455

struct ip6_tnl *tunnel;

1455

struct ip6_tnl *tunnel;

1456

int i;

1456

int i;

1457

1458

tunnel = netdev_priv(dev);

1458

tunnel = netdev_priv(dev);

1459

1460

tunnel->dev = dev;

1460

tunnel->dev = dev;

1461

tunnel->net = dev_net(dev);

1461

tunnel->net = dev_net(dev);

1462

strcpy(tunnel->parms.name, dev->name);

1462

strcpy(tunnel->parms.name, dev->name);

1463

1464

ip6gre_tnl_link_config(tunnel, 1);

1464

ip6gre_tnl_link_config(tunnel, 1);

1465

1466

dev->tstats = alloc_percpu(struct pcpu_sw_netstats);

1466

dev->tstats = alloc_percpu(struct pcpu_sw_netstats);

1467

if (!dev->tstats)

1467

if (!dev->tstats)

1468

return -ENOMEM;

1468

return -ENOMEM;

1469

1470

for_each_possible_cpu(i) {

1470

for_each_possible_cpu(i) {

1471

struct pcpu_sw_netstats *ip6gre_tap_stats;

1471

struct pcpu_sw_netstats *ip6gre_tap_stats;

1472

ip6gre_tap_stats = per_cpu_ptr(dev->tstats, i);

1472

ip6gre_tap_stats = per_cpu_ptr(dev->tstats, i);

1473

u64_stats_init(&ip6gre_tap_stats->syncp);

1473

u64_stats_init(&ip6gre_tap_stats->syncp);

1474

}

1474

}

1475

1476

dev->iflink = tunnel->parms.link;

1476

dev->iflink = tunnel->parms.link;

1477

1478

return 0;

1478

return 0;

1479

}

1479

}

1480

1481

static const struct net_device_ops ip6gre_tap_netdev_ops = {

1481

static const struct net_device_ops ip6gre_tap_netdev_ops = {

1482

.ndo_init = ip6gre_tap_init,

1482

.ndo_init = ip6gre_tap_init,

1483

.ndo_uninit = ip6gre_tunnel_uninit,

1483

.ndo_uninit = ip6gre_tunnel_uninit,

1484

.ndo_start_xmit = ip6gre_tunnel_xmit,

1484

.ndo_start_xmit = ip6gre_tunnel_xmit,

1485

.ndo_set_mac_address = eth_mac_addr,

1485

.ndo_set_mac_address = eth_mac_addr,

1486

.ndo_validate_addr = eth_validate_addr,

1486

.ndo_validate_addr = eth_validate_addr,

1487

.ndo_change_mtu = ip6gre_tunnel_change_mtu,

1487

.ndo_change_mtu = ip6gre_tunnel_change_mtu,

1488

.ndo_get_stats64 = ip_tunnel_get_stats64,

1488

.ndo_get_stats64 = ip_tunnel_get_stats64,

1489

};

1489

};

1490

1491

static void ip6gre_tap_setup(struct net_device *dev)

1491

static void ip6gre_tap_setup(struct net_device *dev)

1492

{

1492

{

1493

1494

ether_setup(dev);

1494

ether_setup(dev);

1495

1496

dev->netdev_ops = &ip6gre_tap_netdev_ops;

1496

dev->netdev_ops = &ip6gre_tap_netdev_ops;

1497

dev->destructor = ip6gre_dev_free;

1497

dev->destructor = ip6gre_dev_free;

1498

1499

dev->iflink = 0;

1499

dev->iflink = 0;

1500

dev->features |= NETIF_F_NETNS_LOCAL;

1500

dev->features |= NETIF_F_NETNS_LOCAL;

1501

}

1501

}

1502

1503

static int ip6gre_newlink(struct net *src_net, struct net_device *dev,

1503

static int ip6gre_newlink(struct net *src_net, struct net_device *dev,

1504

struct nlattr *tb[], struct nlattr *data[])

1504

struct nlattr *tb[], struct nlattr *data[])

1505

{

1505

{

1506

struct ip6_tnl *nt;

1506

struct ip6_tnl *nt;

1507

struct net *net = dev_net(dev);

1507

struct net *net = dev_net(dev);

1508

struct ip6gre_net *ign = net_generic(net, ip6gre_net_id);

1508

struct ip6gre_net *ign = net_generic(net, ip6gre_net_id);

1509

int err;

1509

int err;

1510

1511

nt = netdev_priv(dev);

1511

nt = netdev_priv(dev);

1512

ip6gre_netlink_parms(data, &nt->parms);

1512

ip6gre_netlink_parms(data, &nt->parms);

1513

1514

if (ip6gre_tunnel_find(net, &nt->parms, dev->type))

1514

if (ip6gre_tunnel_find(net, &nt->parms, dev->type))

1515

return -EEXIST;

1515

return -EEXIST;

1516

1517

if (dev->type == ARPHRD_ETHER && !tb[IFLA_ADDRESS])

1517

if (dev->type == ARPHRD_ETHER && !tb[IFLA_ADDRESS])

1518

eth_hw_addr_random(dev);

1518

eth_hw_addr_random(dev);

1519

1520

nt->dev = dev;

1520

nt->dev = dev;

1521

nt->net = dev_net(dev);

1521

nt->net = dev_net(dev);

1522

ip6gre_tnl_link_config(nt, !tb[IFLA_MTU]);

1522

ip6gre_tnl_link_config(nt, !tb[IFLA_MTU]);

1523

1524

/* Can use a lockless transmit, unless we generate output sequences */

1524

/* Can use a lockless transmit, unless we generate output sequences */

1525

if (!(nt->parms.o_flags & GRE_SEQ))

1525

if (!(nt->parms.o_flags & GRE_SEQ))

1526

dev->features |= NETIF_F_LLTX;

1526

dev->features |= NETIF_F_LLTX;

1527

1528

err = register_netdevice(dev);

1528

err = register_netdevice(dev);

1529

if (err)

1529

if (err)

1530

goto out;

1530

goto out;

1531

1532

dev_hold(dev);

1532

dev_hold(dev);

1533

ip6gre_tunnel_link(ign, nt);

1533

ip6gre_tunnel_link(ign, nt);

1534

1535

out:

1535

out:

1536

return err;

1536

return err;

1537

}

1537

}

1538

1539

static int ip6gre_changelink(struct net_device *dev, struct nlattr *tb[],

1539

static int ip6gre_changelink(struct net_device *dev, struct nlattr *tb[],

1540

struct nlattr *data[])

1540

struct nlattr *data[])

1541

{

1541

{

1542

struct ip6_tnl *t, *nt;

1542

struct ip6_tnl *t, *nt;

1543

struct net *net = dev_net(dev);

1543

struct net *net = dev_net(dev);

1544

struct ip6gre_net *ign = net_generic(net, ip6gre_net_id);

1544

struct ip6gre_net *ign = net_generic(net, ip6gre_net_id);

1545

struct __ip6_tnl_parm p;

1545

struct __ip6_tnl_parm p;

1546

1547

if (dev == ign->fb_tunnel_dev)

1547

if (dev == ign->fb_tunnel_dev)

1548

return -EINVAL;

1548

return -EINVAL;

1549

1550

nt = netdev_priv(dev);

1550

nt = netdev_priv(dev);

1551

ip6gre_netlink_parms(data, &p);

1551

ip6gre_netlink_parms(data, &p);

1552

1553

t = ip6gre_tunnel_locate(net, &p, 0);

1553

t = ip6gre_tunnel_locate(net, &p, 0);

1554

1555

if (t) {

1555

if (t) {

1556

if (t->dev != dev)

1556

if (t->dev != dev)

1557

return -EEXIST;

1557

return -EEXIST;

1558

} else {

1558

} else {

1559

t = nt;

1559

t = nt;

1560

1561

ip6gre_tunnel_unlink(ign, t);

1561

ip6gre_tunnel_unlink(ign, t);

1562

ip6gre_tnl_change(t, &p, !tb[IFLA_MTU]);

1562

ip6gre_tnl_change(t, &p, !tb[IFLA_MTU]);

1563

ip6gre_tunnel_link(ign, t);

1563

ip6gre_tunnel_link(ign, t);

1564

netdev_state_change(dev);

1564

netdev_state_change(dev);

1565

}

1565

}

1566

1567

return 0;

1567

return 0;

1568

}

1568

}

1569

1570

static void ip6gre_dellink(struct net_device *dev, struct list_head *head)

1570

static void ip6gre_dellink(struct net_device *dev, struct list_head *head)

1571

{

1571

{

1572

struct net *net = dev_net(dev);

1572

struct net *net = dev_net(dev);

1573

struct ip6gre_net *ign = net_generic(net, ip6gre_net_id);

1573

struct ip6gre_net *ign = net_generic(net, ip6gre_net_id);

1574

1575

if (dev != ign->fb_tunnel_dev)

1575

if (dev != ign->fb_tunnel_dev)

1576

unregister_netdevice_queue(dev, head);

1576

unregister_netdevice_queue(dev, head);

1577

}

1577

}

1578

1579

static size_t ip6gre_get_size(const struct net_device *dev)

1579

static size_t ip6gre_get_size(const struct net_device *dev)

1580

{

1580

{

1581

return

1581

return

1582

/* IFLA_GRE_LINK */

1582

/* IFLA_GRE_LINK */

1583

nla_total_size(4) +

1583

nla_total_size(4) +

1584

/* IFLA_GRE_IFLAGS */

1584

/* IFLA_GRE_IFLAGS */

1585

nla_total_size(2) +

1585

nla_total_size(2) +

1586

/* IFLA_GRE_OFLAGS */

1586

/* IFLA_GRE_OFLAGS */

1587

nla_total_size(2) +

1587

nla_total_size(2) +

1588

/* IFLA_GRE_IKEY */

1588

/* IFLA_GRE_IKEY */

1589

nla_total_size(4) +

1589

nla_total_size(4) +

1590

/* IFLA_GRE_OKEY */

1590

/* IFLA_GRE_OKEY */

1591

nla_total_size(4) +

1591

nla_total_size(4) +

1592

/* IFLA_GRE_LOCAL */

1592

/* IFLA_GRE_LOCAL */

1593

nla_total_size(sizeof(struct in6_addr)) +

1593

nla_total_size(sizeof(struct in6_addr)) +

1594

/* IFLA_GRE_REMOTE */

1594

/* IFLA_GRE_REMOTE */

1595

nla_total_size(sizeof(struct in6_addr)) +

1595

nla_total_size(sizeof(struct in6_addr)) +

1596

/* IFLA_GRE_TTL */

1596

/* IFLA_GRE_TTL */

1597

nla_total_size(1) +

1597

nla_total_size(1) +

1598

/* IFLA_GRE_TOS */

1598

/* IFLA_GRE_TOS */

1599

nla_total_size(1) +

1599

nla_total_size(1) +

1600

/* IFLA_GRE_ENCAP_LIMIT */

1600

/* IFLA_GRE_ENCAP_LIMIT */

1601

nla_total_size(1) +

1601

nla_total_size(1) +

1602

/* IFLA_GRE_FLOWINFO */

1602

/* IFLA_GRE_FLOWINFO */

1603

nla_total_size(4) +

1603

nla_total_size(4) +

1604

/* IFLA_GRE_FLAGS */

1604

/* IFLA_GRE_FLAGS */

1605

nla_total_size(4) +

1605

nla_total_size(4) +

1606

0;

1606

0;

1607

}

1607

}

1608

1609

static int ip6gre_fill_info(struct sk_buff *skb, const struct net_device *dev)

1609

static int ip6gre_fill_info(struct sk_buff *skb, const struct net_device *dev)

1610

{

1610

{

1611

struct ip6_tnl *t = netdev_priv(dev);

1611

struct ip6_tnl *t = netdev_priv(dev);

1612

struct __ip6_tnl_parm *p = &t->parms;

1612

struct __ip6_tnl_parm *p = &t->parms;

1613

1614

if (nla_put_u32(skb, IFLA_GRE_LINK, p->link) ||

1614

if (nla_put_u32(skb, IFLA_GRE_LINK, p->link) ||

1615

nla_put_be16(skb, IFLA_GRE_IFLAGS, p->i_flags) ||

1615

nla_put_be16(skb, IFLA_GRE_IFLAGS, p->i_flags) ||

1616

nla_put_be16(skb, IFLA_GRE_OFLAGS, p->o_flags) ||

1616

nla_put_be16(skb, IFLA_GRE_OFLAGS, p->o_flags) ||

1617

nla_put_be32(skb, IFLA_GRE_IKEY, p->i_key) ||

1617

nla_put_be32(skb, IFLA_GRE_IKEY, p->i_key) ||

1618

nla_put_be32(skb, IFLA_GRE_OKEY, p->o_key) ||

1618

nla_put_be32(skb, IFLA_GRE_OKEY, p->o_key) ||

1619

nla_put(skb, IFLA_GRE_LOCAL, sizeof(struct in6_addr), &p->laddr) ||

1619

nla_put(skb, IFLA_GRE_LOCAL, sizeof(struct in6_addr), &p->laddr) ||

1620

nla_put(skb, IFLA_GRE_REMOTE, sizeof(struct in6_addr), &p->raddr) ||

1620

nla_put(skb, IFLA_GRE_REMOTE, sizeof(struct in6_addr), &p->raddr) ||

1621

nla_put_u8(skb, IFLA_GRE_TTL, p->hop_limit) ||

1621

nla_put_u8(skb, IFLA_GRE_TTL, p->hop_limit) ||

1622

/*nla_put_u8(skb, IFLA_GRE_TOS, t->priority) ||*/

1622

/*nla_put_u8(skb, IFLA_GRE_TOS, t->priority) ||*/

1623

nla_put_u8(skb, IFLA_GRE_ENCAP_LIMIT, p->encap_limit) ||

1623

nla_put_u8(skb, IFLA_GRE_ENCAP_LIMIT, p->encap_limit) ||

1624

nla_put_be32(skb, IFLA_GRE_FLOWINFO, p->flowinfo) ||

1624

nla_put_be32(skb, IFLA_GRE_FLOWINFO, p->flowinfo) ||

1625

nla_put_u32(skb, IFLA_GRE_FLAGS, p->flags))

1625

nla_put_u32(skb, IFLA_GRE_FLAGS, p->flags))

1626

goto nla_put_failure;

1626

goto nla_put_failure;

1627

return 0;

1627

return 0;

1628

1629

nla_put_failure:

1629

nla_put_failure:

1630

return -EMSGSIZE;

1630

return -EMSGSIZE;

1631

}

1631

}

1632

1633

static const struct nla_policy ip6gre_policy[IFLA_GRE_MAX + 1] = {

1633

static const struct nla_policy ip6gre_policy[IFLA_GRE_MAX + 1] = {

1634

[IFLA_GRE_LINK] = { .type = NLA_U32 },

1634

[IFLA_GRE_LINK] = { .type = NLA_U32 },

1635

[IFLA_GRE_IFLAGS] = { .type = NLA_U16 },

1635

[IFLA_GRE_IFLAGS] = { .type = NLA_U16 },

1636

[IFLA_GRE_OFLAGS] = { .type = NLA_U16 },

1636

[IFLA_GRE_OFLAGS] = { .type = NLA_U16 },

1637

[IFLA_GRE_IKEY] = { .type = NLA_U32 },

1637

[IFLA_GRE_IKEY] = { .type = NLA_U32 },

1638

[IFLA_GRE_OKEY] = { .type = NLA_U32 },

1638

[IFLA_GRE_OKEY] = { .type = NLA_U32 },

1639

[IFLA_GRE_LOCAL] = { .len = FIELD_SIZEOF(struct ipv6hdr, saddr) },

1639

[IFLA_GRE_LOCAL] = { .len = FIELD_SIZEOF(struct ipv6hdr, saddr) },

1640

[IFLA_GRE_REMOTE] = { .len = FIELD_SIZEOF(struct ipv6hdr, daddr) },

1640

[IFLA_GRE_REMOTE] = { .len = FIELD_SIZEOF(struct ipv6hdr, daddr) },

1641

[IFLA_GRE_TTL] = { .type = NLA_U8 },

1641

[IFLA_GRE_TTL] = { .type = NLA_U8 },

1642

[IFLA_GRE_ENCAP_LIMIT] = { .type = NLA_U8 },

1642

[IFLA_GRE_ENCAP_LIMIT] = { .type = NLA_U8 },

1643

[IFLA_GRE_FLOWINFO] = { .type = NLA_U32 },

1643

[IFLA_GRE_FLOWINFO] = { .type = NLA_U32 },

1644

[IFLA_GRE_FLAGS] = { .type = NLA_U32 },

1644

[IFLA_GRE_FLAGS] = { .type = NLA_U32 },

1645

};

1645

};

1646

1647

static struct rtnl_link_ops ip6gre_link_ops __read_mostly = {

1647

static struct rtnl_link_ops ip6gre_link_ops __read_mostly = {

1648

.kind = "ip6gre",

1648

.kind = "ip6gre",

1649

.maxtype = IFLA_GRE_MAX,

1649

.maxtype = IFLA_GRE_MAX,

1650

.policy = ip6gre_policy,

1650

.policy = ip6gre_policy,

1651

.priv_size = sizeof(struct ip6_tnl),

1651

.priv_size = sizeof(struct ip6_tnl),

1652

.setup = ip6gre_tunnel_setup,

1652

.setup = ip6gre_tunnel_setup,

1653

.validate = ip6gre_tunnel_validate,

1653

.validate = ip6gre_tunnel_validate,

1654

.newlink = ip6gre_newlink,

1654

.newlink = ip6gre_newlink,

1655

.changelink = ip6gre_changelink,

1655

.changelink = ip6gre_changelink,

1656

.dellink = ip6gre_dellink,

1656

.dellink = ip6gre_dellink,

1657

.get_size = ip6gre_get_size,

1657

.get_size = ip6gre_get_size,

1658

.fill_info = ip6gre_fill_info,

1658

.fill_info = ip6gre_fill_info,

1659

};

1659

};

1660

1661

static struct rtnl_link_ops ip6gre_tap_ops __read_mostly = {

1661

static struct rtnl_link_ops ip6gre_tap_ops __read_mostly = {

1662

.kind = "ip6gretap",

1662

.kind = "ip6gretap",

1663

.maxtype = IFLA_GRE_MAX,

1663

.maxtype = IFLA_GRE_MAX,

1664

.policy = ip6gre_policy,

1664

.policy = ip6gre_policy,

1665

.priv_size = sizeof(struct ip6_tnl),

1665

.priv_size = sizeof(struct ip6_tnl),

1666

.setup = ip6gre_tap_setup,

1666

.setup = ip6gre_tap_setup,

1667

.validate = ip6gre_tap_validate,

1667

.validate = ip6gre_tap_validate,

1668

.newlink = ip6gre_newlink,

1668

.newlink = ip6gre_newlink,

1669

.changelink = ip6gre_changelink,

1669

.changelink = ip6gre_changelink,

1670

.get_size = ip6gre_get_size,

1670

.get_size = ip6gre_get_size,

1671

.fill_info = ip6gre_fill_info,

1671

.fill_info = ip6gre_fill_info,

1672

};

1672

};

1673

1674

/*

1674

/*

1675

* And now the modules code and kernel interface.

1675

* And now the modules code and kernel interface.

1676

*/

1676

*/

1677

1678

static int __init ip6gre_init(void)

1678

static int __init ip6gre_init(void)

1679

{

1679

{

1680

int err;

1680

int err;

1681

1682

pr_info("GRE over IPv6 tunneling driver\n");

1682

pr_info("GRE over IPv6 tunneling driver\n");

1683

1684

err = register_pernet_device(&ip6gre_net_ops);

1684

err = register_pernet_device(&ip6gre_net_ops);

1685

if (err < 0)

1685

if (err < 0)

1686

return err;

1686

return err;

1687

1688

err = inet6_add_protocol(&ip6gre_protocol, IPPROTO_GRE);

1688

err = inet6_add_protocol(&ip6gre_protocol, IPPROTO_GRE);

1689

if (err < 0) {

1689

if (err < 0) {

1690

pr_info("%s: can't add protocol\n", __func__);

1690

pr_info("%s: can't add protocol\n", __func__);

1691

goto add_proto_failed;

1691

goto add_proto_failed;

1692

}

1692

}

1693

1694

err = rtnl_link_register(&ip6gre_link_ops);

1694

err = rtnl_link_register(&ip6gre_link_ops);

1695

if (err < 0)

1695

if (err < 0)

1696

goto rtnl_link_failed;

1696

goto rtnl_link_failed;

1697

1698

err = rtnl_link_register(&ip6gre_tap_ops);

1698

err = rtnl_link_register(&ip6gre_tap_ops);

1699

if (err < 0)

1699

if (err < 0)

1700

goto tap_ops_failed;

1700

goto tap_ops_failed;

1701

1702

out:

1702

out:

1703

return err;

1703

return err;

1704

1705

tap_ops_failed:

1705

tap_ops_failed:

1706

rtnl_link_unregister(&ip6gre_link_ops);

1706

rtnl_link_unregister(&ip6gre_link_ops);

1707

rtnl_link_failed:

1707

rtnl_link_failed:

1708

inet6_del_protocol(&ip6gre_protocol, IPPROTO_GRE);

1708

inet6_del_protocol(&ip6gre_protocol, IPPROTO_GRE);

1709

add_proto_failed:

1709

add_proto_failed:

1710

unregister_pernet_device(&ip6gre_net_ops);

1710

unregister_pernet_device(&ip6gre_net_ops);

1711

goto out;

1711

goto out;

1712

}

1712

}

1713

1714

static void __exit ip6gre_fini(void)

1714

static void __exit ip6gre_fini(void)

1715

{

1715

{

1716

rtnl_link_unregister(&ip6gre_tap_ops);

1716

rtnl_link_unregister(&ip6gre_tap_ops);

1717

rtnl_link_unregister(&ip6gre_link_ops);

1717

rtnl_link_unregister(&ip6gre_link_ops);

1718

inet6_del_protocol(&ip6gre_protocol, IPPROTO_GRE);

1718

inet6_del_protocol(&ip6gre_protocol, IPPROTO_GRE);

1719

unregister_pernet_device(&ip6gre_net_ops);

1719

unregister_pernet_device(&ip6gre_net_ops);

1720

}

1720

}

1721

1722

module_init(ip6gre_init);

1722

module_init(ip6gre_init);

1723

module_exit(ip6gre_fini);

1723

module_exit(ip6gre_fini);

1724

MODULE_LICENSE("GPL");

1724

MODULE_LICENSE("GPL");

1725

MODULE_AUTHOR("D. Kozlov (xeb@mail.ru)");

1725

MODULE_AUTHOR("D. Kozlov (xeb@mail.ru)");

1726

MODULE_DESCRIPTION("GRE over IPv6 tunneling device");

1726

MODULE_DESCRIPTION("GRE over IPv6 tunneling device");

1727

MODULE_ALIAS_RTNL_LINK("ip6gre");

1727

MODULE_ALIAS_RTNL_LINK("ip6gre");

1728

MODULE_ALIAS_NETDEV("ip6gre0");

1728

MODULE_ALIAS_NETDEV("ip6gre0");

1729

GITLAB

ipv6: gre: fix wrong skb->protocol in WCCP