WebSVN – OpenWrt – Blame – Rev 1 – /trunk/package/network/services/dnsmasq/patches/0020-Futher-address-union-tidying.patch

1

office

1

From ab194ed7ca433e4e2e8b2ec338bfa4e6aa886a4b Mon Sep 17 00:00:00 2001

2

From: Simon Kelley <simon@thekelleys.org.uk>

3

Date: Tue, 1 Jan 2019 01:35:30 +0000

4

Subject: [PATCH 20/32] Futher address union tidying.

5

6

Pass DNSKEY and DS data into cache_insert via the address argument,

7

now these data types are included in struct all_addr.

8

9

Signed-off-by: Kevin Darbyshire-Bryant <ldir@darbyshire-bryant.me.uk>

10

---

11

src/cache.c | 116 ++++++++++++++++----------------------------------

12

src/dnsmasq.h | 26 +++++------

13

src/dnssec.c | 53 +++++++++++------------

14

3 files changed, 73 insertions(+), 122 deletions(-)

--- a/src/cache.c

+++ b/src/cache.c

@@ -202,9 +202,9 @@ static void cache_hash(struct crec *crec

19

static void cache_blockdata_free(struct crec *crecp)

20

{

21

if (crecp->flags & F_DNSKEY)

22

- blockdata_free(crecp->addr.key.keydata);

23

+ blockdata_free(crecp->addr.addr.addr.key.keydata);

24

else if ((crecp->flags & F_DS) && !(crecp->flags & F_NEG))

25

- blockdata_free(crecp->addr.ds.keydata);

26

+ blockdata_free(crecp->addr.addr.addr.ds.keydata);

}

#endif

@@ -659,33 +659,22 @@ void cache_end_insert(void)

31

read_write(daemon->pipe_to_parent, (unsigned char *)&new_chain->ttd, sizeof(new_chain->ttd), 0);

32

read_write(daemon->pipe_to_parent, (unsigned char *)&flags, sizeof(flags), 0);

33

34

- if (flags & (F_IPV4 | F_IPV6))

35

+ if (flags & (F_IPV4 | F_IPV6 | F_DNSKEY | F_DS))

36

read_write(daemon->pipe_to_parent, (unsigned char *)&new_chain->addr, sizeof(new_chain->addr), 0);

37

#ifdef HAVE_DNSSEC

38

- else if (flags & F_DNSKEY)

39

+ if (flags & F_DNSKEY)

40

{

41

read_write(daemon->pipe_to_parent, (unsigned char *)&class, sizeof(class), 0);

42

-		  read_write(daemon->pipe_to_parent, (unsigned char *)&new_chain->addr.key.algo, sizeof(new_chain->addr.key.algo), 0);

43

-		  read_write(daemon->pipe_to_parent, (unsigned char *)&new_chain->addr.key.keytag, sizeof(new_chain->addr.key.keytag), 0);

44

-		  read_write(daemon->pipe_to_parent, (unsigned char *)&new_chain->addr.key.flags, sizeof(new_chain->addr.key.flags), 0);

45

-		  read_write(daemon->pipe_to_parent, (unsigned char *)&new_chain->addr.key.keylen, sizeof(new_chain->addr.key.keylen), 0);

46

- blockdata_write(new_chain->addr.key.keydata, new_chain->addr.key.keylen, daemon->pipe_to_parent);

47

+		  blockdata_write(new_chain->addr.addr.addr.key.keydata, new_chain->addr.addr.addr.key.keylen, daemon->pipe_to_parent);

48

}

49

else if (flags & F_DS)

50

{

51

read_write(daemon->pipe_to_parent, (unsigned char *)&class, sizeof(class), 0);

52

/* A negative DS entry is possible and has no data, obviously. */

53

if (!(flags & F_NEG))

54

- {

55

-		      read_write(daemon->pipe_to_parent, (unsigned char *)&new_chain->addr.ds.algo, sizeof(new_chain->addr.ds.algo), 0);

56

-		      read_write(daemon->pipe_to_parent, (unsigned char *)&new_chain->addr.ds.keytag, sizeof(new_chain->addr.ds.keytag), 0);

57

-		      read_write(daemon->pipe_to_parent, (unsigned char *)&new_chain->addr.ds.digest, sizeof(new_chain->addr.ds.digest), 0);

58

-		      read_write(daemon->pipe_to_parent, (unsigned char *)&new_chain->addr.ds.keylen, sizeof(new_chain->addr.ds.keylen), 0);

59

- blockdata_write(new_chain->addr.ds.keydata, new_chain->addr.ds.keylen, daemon->pipe_to_parent);

60

- }

61

+		    blockdata_write(new_chain->addr.addr.addr.ds.keydata, new_chain->addr.addr.addr.ds.keylen, daemon->pipe_to_parent);

}

#endif

-

}

}

@@ -736,11 +725,30 @@ int cache_recv_insert(time_t now, int fd

69

70

ttl = difftime(ttd, now);

71

72

- if (flags & (F_IPV4 | F_IPV6))

73

+ if (flags & (F_IPV4 | F_IPV6 | F_DNSKEY | F_DS))

74

{

75

+ unsigned short class = C_IN;

76

+

77

if (!read_write(fd, (unsigned char *)&addr, sizeof(addr), 1))

78

return 0;

79

- crecp = really_insert(daemon->namebuff, &addr, C_IN, now, ttl, flags);

80

+

81

+#ifdef HAVE_DNSSEC

82

+ if (flags & F_DNSKEY)

83

+ {

84

+ if (!read_write(fd, (unsigned char *)&class, sizeof(class), 1) ||

85

+ !(addr.addr.key.keydata = blockdata_read(fd, addr.addr.key.keylen)))

86

+ return 0;

87

+ }

88

+ else if (flags & F_DS)

89

+ {

90

+ if (!read_write(fd, (unsigned char *)&class, sizeof(class), 1) ||

91

+ (flags & F_NEG) ||

92

+ !(addr.addr.key.keydata = blockdata_read(fd, addr.addr.key.keylen)))

+ return 0;

+ }

+#endif

+

+ crecp = really_insert(daemon->namebuff, &addr, class, now, ttl, flags);

98

}

99

else if (flags & F_CNAME)

100

{

101

@@ -764,58 +772,6 @@ int cache_recv_insert(time_t now, int fd

}

}

}

-#ifdef HAVE_DNSSEC

106

- else if (flags & (F_DNSKEY | F_DS))

107

- {

108

- unsigned short class, keylen, keyflags, keytag;

109

- unsigned char algo, digest;

110

- struct blockdata *keydata;

111

-

112

- if (!read_write(fd, (unsigned char *)&class, sizeof(class), 1))

113

- return 0;

114

-

115

- crecp = really_insert(daemon->namebuff, NULL, class, now, ttl, flags);

116

-

117

- if (flags & F_DNSKEY)

118

- {

119

- if (!read_write(fd, (unsigned char *)&algo, sizeof(algo), 1) ||

120

- !read_write(fd, (unsigned char *)&keytag, sizeof(keytag), 1) ||

121

- !read_write(fd, (unsigned char *)&keyflags, sizeof(keyflags), 1) ||

122

- !read_write(fd, (unsigned char *)&keylen, sizeof(keylen), 1) ||

123

- !(keydata = blockdata_read(fd, keylen)))

124

- return 0;

125

- }

126

- else if (!(flags & F_NEG))

127

- {

128

- if (!read_write(fd, (unsigned char *)&algo, sizeof(algo), 1) ||

129

- !read_write(fd, (unsigned char *)&keytag, sizeof(keytag), 1) ||

130

- !read_write(fd, (unsigned char *)&digest, sizeof(digest), 1) ||

131

- !read_write(fd, (unsigned char *)&keylen, sizeof(keylen), 1) ||

132

- !(keydata = blockdata_read(fd, keylen)))

- return 0;

- }

-

- if (crecp)

- {

- if (flags & F_DNSKEY)

139

- {

140

- crecp->addr.key.algo = algo;

141

- crecp->addr.key.keytag = keytag;

142

- crecp->addr.key.flags = flags;

143

- crecp->addr.key.keylen = keylen;

144

- crecp->addr.key.keydata = keydata;

145

- }

146

- else if (!(flags & F_NEG))

147

- {

148

- crecp->addr.ds.algo = algo;

149

- crecp->addr.ds.keytag = keytag;

150

- crecp->addr.ds.digest = digest;

151

- crecp->addr.ds.keylen = keylen;

152

- crecp->addr.ds.keydata = keydata;

- }

- }

- }

-#endif

}

}

@@ -1290,15 +1246,15 @@ void cache_reload(void)

161

#ifdef HAVE_DNSSEC

162

for (ds = daemon->ds; ds; ds = ds->next)

163

if ((cache = whine_malloc(SIZEOF_POINTER_CREC)) &&

164

- (cache->addr.ds.keydata = blockdata_alloc(ds->digest, ds->digestlen)))

165

+ (cache->addr.addr.addr.ds.keydata = blockdata_alloc(ds->digest, ds->digestlen)))

166

{

167

cache->flags = F_FORWARD | F_IMMORTAL | F_DS | F_CONFIG | F_NAMEP;

168

cache->ttd = daemon->local_ttl;

169

cache->name.namep = ds->name;

170

- cache->addr.ds.keylen = ds->digestlen;

171

- cache->addr.ds.algo = ds->algo;

172

- cache->addr.ds.keytag = ds->keytag;

173

- cache->addr.ds.digest = ds->digest_type;

174

+ cache->addr.addr.addr.ds.keylen = ds->digestlen;

175

+ cache->addr.addr.addr.ds.algo = ds->algo;

176

+ cache->addr.addr.addr.ds.keytag = ds->keytag;

177

+ cache->addr.addr.addr.ds.digest = ds->digest_type;

178

cache->uid = ds->class;

179

cache_hash(cache);

180

make_non_terminals(cache);

181

@@ -1775,12 +1731,12 @@ void dump_cache(time_t now)

182

else if (cache->flags & F_DS)

183

{

184

if (!(cache->flags & F_NEG))

185

- sprintf(a, "%5u %3u %3u", cache->addr.ds.keytag,

186

- cache->addr.ds.algo, cache->addr.ds.digest);

187

+ sprintf(a, "%5u %3u %3u", cache->addr.addr.addr.ds.keytag,

188

+ cache->addr.addr.addr.ds.algo, cache->addr.addr.addr.ds.digest);

189

}

190

else if (cache->flags & F_DNSKEY)

191

- sprintf(a, "%5u %3u %3u", cache->addr.key.keytag,

192

- cache->addr.key.algo, cache->addr.key.flags);

193

+ sprintf(a, "%5u %3u %3u", cache->addr.addr.addr.key.keytag,

194

+ cache->addr.addr.addr.key.algo, cache->addr.addr.addr.key.flags);

195

#endif

196

else if (!(cache->flags & F_NEG) || !(cache->flags & F_FORWARD))

197

{

198

--- a/src/dnsmasq.h

199

+++ b/src/dnsmasq.h

200

@@ -277,14 +277,21 @@ struct all_addr {

201

union {

202

struct in_addr addr4;

203

struct in6_addr addr6;

204

+ struct {

205

+ struct blockdata *keydata;

206

+ unsigned short keylen, flags, keytag;

207

+ unsigned char algo;

208

+ } key;

209

+ struct {

210

+ struct blockdata *keydata;

211

+ unsigned short keylen, keytag;

212

+ unsigned char algo;

213

+ unsigned char digest;

214

+ } ds;

215

/* for log_query */

216

struct {

217

unsigned short keytag, algo, digest, rcode;

218

} log;

219

- /* for cache_insert of DNSKEY, DS */

220

- struct {

221

- unsigned short class, type;

- } dnssec;

} addr;

};

@@ -414,17 +421,6 @@ struct crec {

227

} target;

228

unsigned int uid; /* 0 if union is interface-name */

229

} cname;

230

- struct {

231

- struct blockdata *keydata;

232

- unsigned short keylen, flags, keytag;

233

- unsigned char algo;

234

- } key;

235

- struct {

236

- struct blockdata *keydata;

237

- unsigned short keylen, keytag;

238

- unsigned char algo;

239

- unsigned char digest;

240

- } ds;

241

} addr;

242

time_t ttd; /* time to die */

243

/* used as class if DNSKEY/DS, index to source for F_HOSTS */

244

--- a/src/dnssec.c

245

+++ b/src/dnssec.c

246

@@ -628,10 +628,10 @@ static int validate_rrset(time_t now, st

247

{

248

/* iterate through all possible keys 4035 5.3.1 */

249

for (; crecp; crecp = cache_find_by_name(crecp, keyname, now, F_DNSKEY))

250

- if (crecp->addr.key.algo == algo &&

251

- crecp->addr.key.keytag == key_tag &&

252

+ if (crecp->addr.addr.addr.key.algo == algo &&

253

+ crecp->addr.addr.addr.key.keytag == key_tag &&

254

crecp->uid == (unsigned int)class &&

255

- verify(crecp->addr.key.keydata, crecp->addr.key.keylen, sig, sig_len, digest, hash->digest_size, algo))

256

+		verify(crecp->addr.addr.addr.key.keydata, crecp->addr.addr.addr.key.keylen, sig, sig_len, digest, hash->digest_size, algo))

257

return (labels < name_labels) ? STAT_SECURE_WILDCARD : STAT_SECURE;

258

}

259

}

260

@@ -728,10 +728,10 @@ int dnssec_validate_by_ds(time_t now, st

261

const struct nettle_hash *hash;

262

int sigcnt, rrcnt;

263

264

- if (recp1->addr.ds.algo == algo &&

265

- recp1->addr.ds.keytag == keytag &&

266

+ if (recp1->addr.addr.addr.ds.algo == algo &&

267

+ recp1->addr.addr.addr.ds.keytag == keytag &&

268

recp1->uid == (unsigned int)class &&

269

- (hash = hash_find(ds_digest_name(recp1->addr.ds.digest))) &&

270

+ (hash = hash_find(ds_digest_name(recp1->addr.addr.addr.ds.digest))) &&

271

hash_init(hash, &ctx, &digest))

272

273

{

274

@@ -746,9 +746,9 @@ int dnssec_validate_by_ds(time_t now, st

275

from_wire(name);

276

277

if (!(recp1->flags & F_NEG) &&

278

- recp1->addr.ds.keylen == (int)hash->digest_size &&

279

- (ds_digest = blockdata_retrieve(recp1->addr.key.keydata, recp1->addr.ds.keylen, NULL)) &&

280

- memcmp(ds_digest, digest, recp1->addr.ds.keylen) == 0 &&

281

+ recp1->addr.addr.addr.ds.keylen == (int)hash->digest_size &&

282

+ (ds_digest = blockdata_retrieve(recp1->addr.addr.addr.ds.keydata, recp1->addr.addr.addr.ds.keylen, NULL)) &&

283

+ memcmp(ds_digest, digest, recp1->addr.addr.addr.ds.keylen) == 0 &&

284

explore_rrset(header, plen, class, T_DNSKEY, name, keyname, &sigcnt, &rrcnt) &&

285

sigcnt != 0 && rrcnt != 0 &&

286

validate_rrset(now, header, plen, class, T_DNSKEY, sigcnt, rrcnt, name, keyname,

287

@@ -800,7 +800,13 @@ int dnssec_validate_by_ds(time_t now, st

288

289

if ((key = blockdata_alloc((char*)p, rdlen - 4)))

290

{

291

- if (!(recp1 = cache_insert(name, &a, class, now, ttl, F_FORWARD | F_DNSKEY | F_DNSSECOK)))

292

+ a.addr.key.keylen = rdlen - 4;

293

+ a.addr.key.keydata = key;

294

+ a.addr.key.algo = algo;

295

+ a.addr.key.keytag = keytag;

296

+ a.addr.key.flags = flags;

297

+

298

+ if (!cache_insert(name, &a, class, now, ttl, F_FORWARD | F_DNSKEY | F_DNSSECOK))

299

{

300

blockdata_free(key);

301

return STAT_BOGUS;

302

@@ -813,12 +819,6 @@ int dnssec_validate_by_ds(time_t now, st

303

log_query(F_NOEXTRA | F_KEYTAG | F_UPSTREAM, name, &a, "DNSKEY keytag %hu, algo %hu");

304

else

305

log_query(F_NOEXTRA | F_KEYTAG | F_UPSTREAM, name, &a, "DNSKEY keytag %hu, algo %hu (not supported)");

306

-

307

- recp1->addr.key.keylen = rdlen - 4;

308

- recp1->addr.key.keydata = key;

309

- recp1->addr.key.algo = algo;

310

- recp1->addr.key.keytag = keytag;

311

- recp1->addr.key.flags = flags;

}

}

}

@@ -915,8 +915,7 @@ int dnssec_validate_ds(time_t now, struc

316

int algo, digest, keytag;

317

unsigned char *psave = p;

318

struct blockdata *key;

319

- struct crec *crecp;

-

+

if (rdlen < 4)

return STAT_BOGUS; /* bad packet */

324

325

@@ -926,7 +925,13 @@ int dnssec_validate_ds(time_t now, struc

326

327

if ((key = blockdata_alloc((char*)p, rdlen - 4)))

328

{

329

- if (!(crecp = cache_insert(name, NULL, class, now, ttl, F_FORWARD | F_DS | F_DNSSECOK)))

330

+ a.addr.ds.digest = digest;

331

+ a.addr.ds.keydata = key;

332

+ a.addr.ds.algo = algo;

333

+ a.addr.ds.keytag = keytag;

334

+ a.addr.ds.keylen = rdlen - 4;

335

+

336

+ if (!cache_insert(name, &a, class, now, ttl, F_FORWARD | F_DS | F_DNSSECOK))

337

{

338

blockdata_free(key);

339

return STAT_BOGUS;

340

@@ -940,12 +945,6 @@ int dnssec_validate_ds(time_t now, struc

341

log_query(F_NOEXTRA | F_KEYTAG | F_UPSTREAM, name, &a, "DS keytag %hu, algo %hu, digest %hu");

342

else

343

log_query(F_NOEXTRA | F_KEYTAG | F_UPSTREAM, name, &a, "DS keytag %hu, algo %hu, digest %hu (not supported)");

344

-

345

- crecp->addr.ds.digest = digest;

346

- crecp->addr.ds.keydata = key;

347

- crecp->addr.ds.algo = algo;

348

- crecp->addr.ds.keytag = keytag;

349

- crecp->addr.ds.keylen = rdlen - 4;

}

}

@@ -1711,8 +1710,8 @@ static int zone_status(char *name, int c

354

do

355

{

356

if (crecp->uid == (unsigned int)class &&

357

- ds_digest_name(crecp->addr.ds.digest) &&

358

- algo_digest_name(crecp->addr.ds.algo))

359

+ ds_digest_name(crecp->addr.addr.addr.ds.digest) &&

360

+ algo_digest_name(crecp->addr.addr.addr.ds.algo))

361

break;

362

}

363

while ((crecp = cache_find_by_name(crecp, keyname, now, F_DS)));

OpenWrt – Blame information for rev 1