Mercurial > hg > nginx
comparison src/core/ngx_resolver.c @ 5468:5c410d6ca7dd
Resolver: improved code readability.
Renamed ngx_resolver_query_t to ngx_resolver_hdr_t as it describes
the header that is common to DNS queries and answers.
Replaced the magic number 12 by the size of the header structure.
The other changes are self-explanatory.
author | Ruslan Ermilov <ru@nginx.com> |
---|---|
date | Fri, 06 Dec 2013 14:30:27 +0400 |
parents | 3d2d3e1cf427 |
children | b2fc466a11a7 |
comparison
equal
deleted
inserted
replaced
5467:f6258a7092e4 | 5468:5c410d6ca7dd |
---|---|
24 u_char nan_lo; | 24 u_char nan_lo; |
25 u_char nns_hi; | 25 u_char nns_hi; |
26 u_char nns_lo; | 26 u_char nns_lo; |
27 u_char nar_hi; | 27 u_char nar_hi; |
28 u_char nar_lo; | 28 u_char nar_lo; |
29 } ngx_resolver_query_t; | 29 } ngx_resolver_hdr_t; |
30 | 30 |
31 | 31 |
32 typedef struct { | 32 typedef struct { |
33 u_char type_hi; | 33 u_char type_hi; |
34 u_char type_lo; | 34 u_char type_lo; |
1019 | 1019 |
1020 | 1020 |
1021 static void | 1021 static void |
1022 ngx_resolver_process_response(ngx_resolver_t *r, u_char *buf, size_t n) | 1022 ngx_resolver_process_response(ngx_resolver_t *r, u_char *buf, size_t n) |
1023 { | 1023 { |
1024 char *err; | 1024 char *err; |
1025 size_t len; | 1025 size_t len; |
1026 ngx_uint_t i, times, ident, qident, flags, code, nqs, nan, | 1026 ngx_uint_t i, times, ident, qident, flags, code, nqs, nan, |
1027 qtype, qclass; | 1027 qtype, qclass; |
1028 ngx_queue_t *q; | 1028 ngx_queue_t *q; |
1029 ngx_resolver_qs_t *qs; | 1029 ngx_resolver_qs_t *qs; |
1030 ngx_resolver_node_t *rn; | 1030 ngx_resolver_hdr_t *response; |
1031 ngx_resolver_query_t *query; | 1031 ngx_resolver_node_t *rn; |
1032 | 1032 |
1033 if ((size_t) n < sizeof(ngx_resolver_query_t)) { | 1033 if (n < sizeof(ngx_resolver_hdr_t)) { |
1034 goto short_response; | 1034 goto short_response; |
1035 } | 1035 } |
1036 | 1036 |
1037 query = (ngx_resolver_query_t *) buf; | 1037 response = (ngx_resolver_hdr_t *) buf; |
1038 | 1038 |
1039 ident = (query->ident_hi << 8) + query->ident_lo; | 1039 ident = (response->ident_hi << 8) + response->ident_lo; |
1040 flags = (query->flags_hi << 8) + query->flags_lo; | 1040 flags = (response->flags_hi << 8) + response->flags_lo; |
1041 nqs = (query->nqs_hi << 8) + query->nqs_lo; | 1041 nqs = (response->nqs_hi << 8) + response->nqs_lo; |
1042 nan = (query->nan_hi << 8) + query->nan_lo; | 1042 nan = (response->nan_hi << 8) + response->nan_lo; |
1043 | 1043 |
1044 ngx_log_debug6(NGX_LOG_DEBUG_CORE, r->log, 0, | 1044 ngx_log_debug6(NGX_LOG_DEBUG_CORE, r->log, 0, |
1045 "resolver DNS response %ui fl:%04Xui %ui/%ui/%ud/%ud", | 1045 "resolver DNS response %ui fl:%04Xui %ui/%ui/%ud/%ud", |
1046 ident, flags, nqs, nan, | 1046 ident, flags, nqs, nan, |
1047 (query->nns_hi << 8) + query->nns_lo, | 1047 (response->nns_hi << 8) + response->nns_lo, |
1048 (query->nar_hi << 8) + query->nar_lo); | 1048 (response->nar_hi << 8) + response->nar_lo); |
1049 | 1049 |
1050 if (!(flags & 0x8000)) { | 1050 if (!(flags & 0x8000)) { |
1051 ngx_log_error(r->log_level, r->log, 0, | 1051 ngx_log_error(r->log_level, r->log, 0, |
1052 "invalid DNS response %ui fl:%04Xui", ident, flags); | 1052 "invalid DNS response %ui fl:%04Xui", ident, flags); |
1053 return; | 1053 return; |
1085 if (nqs != 1) { | 1085 if (nqs != 1) { |
1086 err = "invalid number of questions in DNS response"; | 1086 err = "invalid number of questions in DNS response"; |
1087 goto done; | 1087 goto done; |
1088 } | 1088 } |
1089 | 1089 |
1090 i = sizeof(ngx_resolver_query_t); | 1090 i = sizeof(ngx_resolver_hdr_t); |
1091 | 1091 |
1092 while (i < (ngx_uint_t) n) { | 1092 while (i < (ngx_uint_t) n) { |
1093 if (buf[i] == '\0') { | 1093 if (buf[i] == '\0') { |
1094 goto found; | 1094 goto found; |
1095 } | 1095 } |
1150 | 1150 |
1151 return; | 1151 return; |
1152 | 1152 |
1153 short_response: | 1153 short_response: |
1154 | 1154 |
1155 err = "short dns response"; | 1155 err = "short DNS response"; |
1156 | 1156 |
1157 done: | 1157 done: |
1158 | 1158 |
1159 ngx_log_error(r->log_level, r->log, 0, err); | 1159 ngx_log_error(r->log_level, r->log, 0, err); |
1160 | 1160 |
1178 size_t len; | 1178 size_t len; |
1179 int32_t ttl; | 1179 int32_t ttl; |
1180 uint32_t hash; | 1180 uint32_t hash; |
1181 in_addr_t addr, *addrs; | 1181 in_addr_t addr, *addrs; |
1182 ngx_str_t name; | 1182 ngx_str_t name; |
1183 ngx_uint_t qtype, qident, naddrs, a, i, n, start; | 1183 ngx_uint_t type, qident, naddrs, a, i, n, start; |
1184 ngx_resolver_an_t *an; | 1184 ngx_resolver_an_t *an; |
1185 ngx_resolver_ctx_t *ctx, *next; | 1185 ngx_resolver_ctx_t *ctx, *next; |
1186 ngx_resolver_node_t *rn; | 1186 ngx_resolver_node_t *rn; |
1187 | 1187 |
1188 if (ngx_resolver_copy(r, &name, buf, &buf[12], &buf[last]) != NGX_OK) { | 1188 if (ngx_resolver_copy(r, &name, buf, |
1189 buf + sizeof(ngx_resolver_hdr_t), buf + last) | |
1190 != NGX_OK) | |
1191 { | |
1189 return; | 1192 return; |
1190 } | 1193 } |
1191 | 1194 |
1192 ngx_log_debug1(NGX_LOG_DEBUG_CORE, r->log, 0, "resolver qs:%V", &name); | 1195 ngx_log_debug1(NGX_LOG_DEBUG_CORE, r->log, 0, "resolver qs:%V", &name); |
1193 | 1196 |
1213 } | 1216 } |
1214 | 1217 |
1215 ngx_resolver_free(r, name.data); | 1218 ngx_resolver_free(r, name.data); |
1216 | 1219 |
1217 if (code == 0 && nan == 0) { | 1220 if (code == 0 && nan == 0) { |
1218 code = 3; /* NXDOMAIN */ | 1221 code = NGX_RESOLVE_NXDOMAIN; |
1219 } | 1222 } |
1220 | 1223 |
1221 if (code) { | 1224 if (code) { |
1222 next = rn->waiting; | 1225 next = rn->waiting; |
1223 rn->waiting = NULL; | 1226 rn->waiting = NULL; |
1244 i = ans; | 1247 i = ans; |
1245 naddrs = 0; | 1248 naddrs = 0; |
1246 addr = 0; | 1249 addr = 0; |
1247 addrs = NULL; | 1250 addrs = NULL; |
1248 cname = NULL; | 1251 cname = NULL; |
1249 qtype = 0; | |
1250 ttl = 0; | 1252 ttl = 0; |
1251 | 1253 |
1252 for (a = 0; a < nan; a++) { | 1254 for (a = 0; a < nan; a++) { |
1253 | 1255 |
1254 start = i; | 1256 start = i; |
1271 goto short_response; | 1273 goto short_response; |
1272 | 1274 |
1273 test_length: | 1275 test_length: |
1274 | 1276 |
1275 if (i - start < 2) { | 1277 if (i - start < 2) { |
1276 err = "invalid name in dns response"; | 1278 err = "invalid name in DNS response"; |
1277 goto invalid; | 1279 goto invalid; |
1278 } | 1280 } |
1279 | 1281 |
1280 found: | 1282 found: |
1281 | 1283 |
1283 goto short_response; | 1285 goto short_response; |
1284 } | 1286 } |
1285 | 1287 |
1286 an = (ngx_resolver_an_t *) &buf[i]; | 1288 an = (ngx_resolver_an_t *) &buf[i]; |
1287 | 1289 |
1288 qtype = (an->type_hi << 8) + an->type_lo; | 1290 type = (an->type_hi << 8) + an->type_lo; |
1289 len = (an->len_hi << 8) + an->len_lo; | 1291 len = (an->len_hi << 8) + an->len_lo; |
1290 ttl = (an->ttl[0] << 24) + (an->ttl[1] << 16) | 1292 ttl = (an->ttl[0] << 24) + (an->ttl[1] << 16) |
1291 + (an->ttl[2] << 8) + (an->ttl[3]); | 1293 + (an->ttl[2] << 8) + (an->ttl[3]); |
1292 | 1294 |
1293 if (ttl < 0) { | 1295 if (ttl < 0) { |
1294 ttl = 0; | 1296 ttl = 0; |
1295 } | 1297 } |
1296 | 1298 |
1297 if (qtype == NGX_RESOLVE_A) { | 1299 switch (type) { |
1300 | |
1301 case NGX_RESOLVE_A: | |
1298 | 1302 |
1299 i += sizeof(ngx_resolver_an_t); | 1303 i += sizeof(ngx_resolver_an_t); |
1300 | 1304 |
1301 if (i + len > last) { | 1305 if (i + len > last) { |
1302 goto short_response; | 1306 goto short_response; |
1307 | 1311 |
1308 naddrs++; | 1312 naddrs++; |
1309 | 1313 |
1310 i += len; | 1314 i += len; |
1311 | 1315 |
1312 } else if (qtype == NGX_RESOLVE_CNAME) { | 1316 break; |
1317 | |
1318 case NGX_RESOLVE_CNAME: | |
1319 | |
1313 cname = &buf[i] + sizeof(ngx_resolver_an_t); | 1320 cname = &buf[i] + sizeof(ngx_resolver_an_t); |
1314 i += sizeof(ngx_resolver_an_t) + len; | 1321 i += sizeof(ngx_resolver_an_t) + len; |
1315 | 1322 |
1316 } else if (qtype == NGX_RESOLVE_DNAME) { | 1323 break; |
1324 | |
1325 case NGX_RESOLVE_DNAME: | |
1326 | |
1317 i += sizeof(ngx_resolver_an_t) + len; | 1327 i += sizeof(ngx_resolver_an_t) + len; |
1318 | 1328 |
1319 } else { | 1329 break; |
1330 | |
1331 default: | |
1332 | |
1320 ngx_log_error(r->log_level, r->log, 0, | 1333 ngx_log_error(r->log_level, r->log, 0, |
1321 "unexpected qtype %ui", qtype); | 1334 "unexpected RR type %ui", type); |
1322 } | 1335 } |
1323 } | 1336 } |
1324 | 1337 |
1325 ngx_log_debug3(NGX_LOG_DEBUG_CORE, r->log, 0, | 1338 ngx_log_debug3(NGX_LOG_DEBUG_CORE, r->log, 0, |
1326 "resolver naddrs:%ui cname:%p ttl:%d", | 1339 "resolver naddrs:%ui cname:%p ttl:%d", |
1345 | 1358 |
1346 for ( ;; ) { | 1359 for ( ;; ) { |
1347 | 1360 |
1348 if (buf[i] & 0xc0) { | 1361 if (buf[i] & 0xc0) { |
1349 i += 2; | 1362 i += 2; |
1350 goto ok; | 1363 break; |
1351 } | 1364 } |
1352 | 1365 |
1353 if (buf[i] == 0) { | 1366 if (buf[i] == 0) { |
1354 i++; | 1367 i++; |
1355 goto ok; | 1368 break; |
1356 } | 1369 } |
1357 | 1370 |
1358 i += 1 + buf[i]; | 1371 i += 1 + buf[i]; |
1359 } | 1372 } |
1360 | 1373 |
1361 ok: | |
1362 | |
1363 an = (ngx_resolver_an_t *) &buf[i]; | 1374 an = (ngx_resolver_an_t *) &buf[i]; |
1364 | 1375 |
1365 qtype = (an->type_hi << 8) + an->type_lo; | 1376 type = (an->type_hi << 8) + an->type_lo; |
1366 len = (an->len_hi << 8) + an->len_lo; | 1377 len = (an->len_hi << 8) + an->len_lo; |
1367 | 1378 |
1368 i += sizeof(ngx_resolver_an_t); | 1379 i += sizeof(ngx_resolver_an_t); |
1369 | 1380 |
1370 if (qtype == NGX_RESOLVE_A) { | 1381 if (type == NGX_RESOLVE_A) { |
1371 | 1382 |
1372 addrs[n++] = htonl((buf[i] << 24) + (buf[i + 1] << 16) | 1383 addrs[n++] = htonl((buf[i] << 24) + (buf[i + 1] << 16) |
1373 + (buf[i + 2] << 8) + (buf[i + 3])); | 1384 + (buf[i + 2] << 8) + (buf[i + 3])); |
1374 | 1385 |
1375 if (n == naddrs) { | 1386 if (n == naddrs) { |
1420 | 1431 |
1421 ngx_resolver_free(r, rn->query); | 1432 ngx_resolver_free(r, rn->query); |
1422 rn->query = NULL; | 1433 rn->query = NULL; |
1423 | 1434 |
1424 return; | 1435 return; |
1425 | 1436 } |
1426 } else if (cname) { | 1437 |
1438 if (cname) { | |
1427 | 1439 |
1428 /* CNAME only */ | 1440 /* CNAME only */ |
1429 | 1441 |
1430 if (ngx_resolver_copy(r, &name, buf, cname, &buf[last]) != NGX_OK) { | 1442 if (ngx_resolver_copy(r, &name, buf, cname, buf + last) != NGX_OK) { |
1431 return; | 1443 return; |
1432 } | 1444 } |
1433 | 1445 |
1434 ngx_log_debug1(NGX_LOG_DEBUG_CORE, r->log, 0, | 1446 ngx_log_debug1(NGX_LOG_DEBUG_CORE, r->log, 0, |
1435 "resolver cname:\"%V\"", &name); | 1447 "resolver cname:\"%V\"", &name); |
1458 | 1470 |
1459 return; | 1471 return; |
1460 } | 1472 } |
1461 | 1473 |
1462 ngx_log_error(r->log_level, r->log, 0, | 1474 ngx_log_error(r->log_level, r->log, 0, |
1463 "no A or CNAME types in DNS responses, unknown query type: %ui", | 1475 "no A or CNAME types in DNS response"); |
1464 qtype); | |
1465 return; | 1476 return; |
1466 | 1477 |
1467 short_response: | 1478 short_response: |
1468 | 1479 |
1469 err = "short dns response"; | 1480 err = "short DNS response"; |
1470 | 1481 |
1471 invalid: | 1482 invalid: |
1472 | 1483 |
1473 /* unlock name mutex */ | 1484 /* unlock name mutex */ |
1474 | 1485 |
1492 { | 1503 { |
1493 char *err; | 1504 char *err; |
1494 size_t len; | 1505 size_t len; |
1495 in_addr_t addr; | 1506 in_addr_t addr; |
1496 int32_t ttl; | 1507 int32_t ttl; |
1497 ngx_int_t digit; | 1508 ngx_int_t octet; |
1498 ngx_str_t name; | 1509 ngx_str_t name; |
1499 ngx_uint_t i, mask, qident; | 1510 ngx_uint_t i, mask, qident; |
1500 ngx_resolver_an_t *an; | 1511 ngx_resolver_an_t *an; |
1501 ngx_resolver_ctx_t *ctx, *next; | 1512 ngx_resolver_ctx_t *ctx, *next; |
1502 ngx_resolver_node_t *rn; | 1513 ngx_resolver_node_t *rn; |
1503 | 1514 |
1504 if (ngx_resolver_copy(r, NULL, buf, &buf[12], &buf[n]) != NGX_OK) { | 1515 if (ngx_resolver_copy(r, NULL, buf, |
1516 buf + sizeof(ngx_resolver_hdr_t), buf + n) | |
1517 != NGX_OK) | |
1518 { | |
1505 goto invalid_in_addr_arpa; | 1519 goto invalid_in_addr_arpa; |
1506 } | 1520 } |
1507 | 1521 |
1508 addr = 0; | 1522 addr = 0; |
1509 i = 12; | 1523 i = sizeof(ngx_resolver_hdr_t); |
1510 | 1524 |
1511 for (mask = 0; mask < 32; mask += 8) { | 1525 for (mask = 0; mask < 32; mask += 8) { |
1512 len = buf[i++]; | 1526 len = buf[i++]; |
1513 | 1527 |
1514 digit = ngx_atoi(&buf[i], len); | 1528 octet = ngx_atoi(&buf[i], len); |
1515 if (digit == NGX_ERROR || digit > 255) { | 1529 if (octet == NGX_ERROR || octet > 255) { |
1516 goto invalid_in_addr_arpa; | 1530 goto invalid_in_addr_arpa; |
1517 } | 1531 } |
1518 | 1532 |
1519 addr += digit << mask; | 1533 addr += octet << mask; |
1520 i += len; | 1534 i += len; |
1521 } | 1535 } |
1522 | 1536 |
1523 if (ngx_strcmp(&buf[i], "\7in-addr\4arpa") != 0) { | 1537 if (ngx_strcmp(&buf[i], "\7in-addr\4arpa") != 0) { |
1524 goto invalid_in_addr_arpa; | 1538 goto invalid_in_addr_arpa; |
1545 (addr >> 8) & 0xff, addr & 0xff, qident); | 1559 (addr >> 8) & 0xff, addr & 0xff, qident); |
1546 goto failed; | 1560 goto failed; |
1547 } | 1561 } |
1548 | 1562 |
1549 if (code == 0 && nan == 0) { | 1563 if (code == 0 && nan == 0) { |
1550 code = 3; /* NXDOMAIN */ | 1564 code = NGX_RESOLVE_NXDOMAIN; |
1551 } | 1565 } |
1552 | 1566 |
1553 if (code) { | 1567 if (code) { |
1554 next = rn->waiting; | 1568 next = rn->waiting; |
1555 rn->waiting = NULL; | 1569 rn->waiting = NULL; |
1579 goto short_response; | 1593 goto short_response; |
1580 } | 1594 } |
1581 | 1595 |
1582 /* compression pointer to "XX.XX.XX.XX.in-addr.arpa */ | 1596 /* compression pointer to "XX.XX.XX.XX.in-addr.arpa */ |
1583 | 1597 |
1584 if (buf[i] != 0xc0 || buf[i + 1] != 0x0c) { | 1598 if (buf[i] != 0xc0 || buf[i + 1] != sizeof(ngx_resolver_hdr_t)) { |
1585 err = "invalid in-addr.arpa name in DNS response"; | 1599 err = "invalid in-addr.arpa name in DNS response"; |
1586 goto invalid; | 1600 goto invalid; |
1587 } | 1601 } |
1588 | 1602 |
1589 an = (ngx_resolver_an_t *) &buf[i + 2]; | 1603 an = (ngx_resolver_an_t *) &buf[i + 2]; |
1605 | 1619 |
1606 if (i + len > (ngx_uint_t) n) { | 1620 if (i + len > (ngx_uint_t) n) { |
1607 goto short_response; | 1621 goto short_response; |
1608 } | 1622 } |
1609 | 1623 |
1610 if (ngx_resolver_copy(r, &name, buf, &buf[i], &buf[n]) != NGX_OK) { | 1624 if (ngx_resolver_copy(r, &name, buf, buf + i, buf + n) != NGX_OK) { |
1611 return; | 1625 return; |
1612 } | 1626 } |
1613 | 1627 |
1614 ngx_log_debug1(NGX_LOG_DEBUG_CORE, r->log, 0, "resolver an:%V", &name); | 1628 ngx_log_debug1(NGX_LOG_DEBUG_CORE, r->log, 0, "resolver an:%V", &name); |
1615 | 1629 |
1794 | 1808 |
1795 | 1809 |
1796 static ngx_int_t | 1810 static ngx_int_t |
1797 ngx_resolver_create_name_query(ngx_resolver_node_t *rn, ngx_resolver_ctx_t *ctx) | 1811 ngx_resolver_create_name_query(ngx_resolver_node_t *rn, ngx_resolver_ctx_t *ctx) |
1798 { | 1812 { |
1799 u_char *p, *s; | 1813 u_char *p, *s; |
1800 size_t len, nlen; | 1814 size_t len, nlen; |
1801 ngx_uint_t ident; | 1815 ngx_uint_t ident; |
1802 ngx_resolver_qs_t *qs; | 1816 ngx_resolver_qs_t *qs; |
1803 ngx_resolver_query_t *query; | 1817 ngx_resolver_hdr_t *query; |
1804 | 1818 |
1805 nlen = ctx->name.len ? (1 + ctx->name.len + 1) : 1; | 1819 nlen = ctx->name.len ? (1 + ctx->name.len + 1) : 1; |
1806 | 1820 |
1807 len = sizeof(ngx_resolver_query_t) + nlen + sizeof(ngx_resolver_qs_t); | 1821 len = sizeof(ngx_resolver_hdr_t) + nlen + sizeof(ngx_resolver_qs_t); |
1808 | 1822 |
1809 p = ngx_resolver_alloc(ctx->resolver, len); | 1823 p = ngx_resolver_alloc(ctx->resolver, len); |
1810 if (p == NULL) { | 1824 if (p == NULL) { |
1811 return NGX_ERROR; | 1825 return NGX_ERROR; |
1812 } | 1826 } |
1813 | 1827 |
1814 rn->qlen = (u_short) len; | 1828 rn->qlen = (u_short) len; |
1815 rn->query = p; | 1829 rn->query = p; |
1816 | 1830 |
1817 query = (ngx_resolver_query_t *) p; | 1831 query = (ngx_resolver_hdr_t *) p; |
1818 | 1832 |
1819 ident = ngx_random(); | 1833 ident = ngx_random(); |
1820 | 1834 |
1821 ngx_log_debug2(NGX_LOG_DEBUG_CORE, ctx->resolver->log, 0, | 1835 ngx_log_debug2(NGX_LOG_DEBUG_CORE, ctx->resolver->log, 0, |
1822 "resolve: \"%V\" %i", &ctx->name, ident & 0xffff); | 1836 "resolve: \"%V\" %i", &ctx->name, ident & 0xffff); |
1831 query->nqs_hi = 0; query->nqs_lo = 1; | 1845 query->nqs_hi = 0; query->nqs_lo = 1; |
1832 query->nan_hi = 0; query->nan_lo = 0; | 1846 query->nan_hi = 0; query->nan_lo = 0; |
1833 query->nns_hi = 0; query->nns_lo = 0; | 1847 query->nns_hi = 0; query->nns_lo = 0; |
1834 query->nar_hi = 0; query->nar_lo = 0; | 1848 query->nar_hi = 0; query->nar_lo = 0; |
1835 | 1849 |
1836 p += sizeof(ngx_resolver_query_t) + nlen; | 1850 p += sizeof(ngx_resolver_hdr_t) + nlen; |
1837 | 1851 |
1838 qs = (ngx_resolver_qs_t *) p; | 1852 qs = (ngx_resolver_qs_t *) p; |
1839 | 1853 |
1840 /* query type */ | 1854 /* query type */ |
1841 qs->type_hi = 0; qs->type_lo = (u_char) ctx->type; | 1855 qs->type_hi = 0; qs->type_lo = (u_char) ctx->type; |
1842 | 1856 |
1843 /* IP query class */ | 1857 /* IN query class */ |
1844 qs->class_hi = 0; qs->class_lo = 1; | 1858 qs->class_hi = 0; qs->class_lo = 1; |
1845 | 1859 |
1846 /* convert "www.example.com" to "\3www\7example\3com\0" */ | 1860 /* convert "www.example.com" to "\3www\7example\3com\0" */ |
1847 | 1861 |
1848 len = 0; | 1862 len = 0; |
1883 /* AF_INET only */ | 1897 /* AF_INET only */ |
1884 | 1898 |
1885 static ngx_int_t | 1899 static ngx_int_t |
1886 ngx_resolver_create_addr_query(ngx_resolver_node_t *rn, ngx_resolver_ctx_t *ctx) | 1900 ngx_resolver_create_addr_query(ngx_resolver_node_t *rn, ngx_resolver_ctx_t *ctx) |
1887 { | 1901 { |
1888 u_char *p, *d; | 1902 u_char *p, *d; |
1889 size_t len; | 1903 size_t len; |
1890 ngx_int_t n; | 1904 ngx_int_t n; |
1891 ngx_uint_t ident; | 1905 ngx_uint_t ident; |
1892 ngx_resolver_query_t *query; | 1906 ngx_resolver_hdr_t *query; |
1893 | 1907 |
1894 len = sizeof(ngx_resolver_query_t) | 1908 len = sizeof(ngx_resolver_hdr_t) |
1895 + sizeof(".255.255.255.255.in-addr.arpa.") - 1 | 1909 + sizeof(".255.255.255.255.in-addr.arpa.") - 1 |
1896 + sizeof(ngx_resolver_qs_t); | 1910 + sizeof(ngx_resolver_qs_t); |
1897 | 1911 |
1898 p = ngx_resolver_alloc(ctx->resolver, len); | 1912 p = ngx_resolver_alloc(ctx->resolver, len); |
1899 if (p == NULL) { | 1913 if (p == NULL) { |
1900 return NGX_ERROR; | 1914 return NGX_ERROR; |
1901 } | 1915 } |
1902 | 1916 |
1903 rn->query = p; | 1917 rn->query = p; |
1904 query = (ngx_resolver_query_t *) p; | 1918 query = (ngx_resolver_hdr_t *) p; |
1905 | 1919 |
1906 ident = ngx_random(); | 1920 ident = ngx_random(); |
1907 | 1921 |
1908 query->ident_hi = (u_char) ((ident >> 8) & 0xff); | 1922 query->ident_hi = (u_char) ((ident >> 8) & 0xff); |
1909 query->ident_lo = (u_char) (ident & 0xff); | 1923 query->ident_lo = (u_char) (ident & 0xff); |
1915 query->nqs_hi = 0; query->nqs_lo = 1; | 1929 query->nqs_hi = 0; query->nqs_lo = 1; |
1916 query->nan_hi = 0; query->nan_lo = 0; | 1930 query->nan_hi = 0; query->nan_lo = 0; |
1917 query->nns_hi = 0; query->nns_lo = 0; | 1931 query->nns_hi = 0; query->nns_lo = 0; |
1918 query->nar_hi = 0; query->nar_lo = 0; | 1932 query->nar_hi = 0; query->nar_lo = 0; |
1919 | 1933 |
1920 p += sizeof(ngx_resolver_query_t); | 1934 p += sizeof(ngx_resolver_hdr_t); |
1921 | 1935 |
1922 for (n = 0; n < 32; n += 8) { | 1936 for (n = 0; n < 32; n += 8) { |
1923 d = ngx_sprintf(&p[1], "%ud", (ctx->addr >> n) & 0xff); | 1937 d = ngx_sprintf(&p[1], "%ud", (ctx->addr >> n) & 0xff); |
1924 *p = (u_char) (d - &p[1]); | 1938 *p = (u_char) (d - &p[1]); |
1925 p = d; | 1939 p = d; |
1926 } | 1940 } |
1927 | 1941 |
1928 /* query type "PTR", IP query class */ | 1942 /* query type "PTR", IN query class */ |
1929 ngx_memcpy(p, "\7in-addr\4arpa\0\0\14\0\1", 18); | 1943 ngx_memcpy(p, "\7in-addr\4arpa\0\0\14\0\1", 18); |
1930 | 1944 |
1931 rn->qlen = (u_short) | 1945 rn->qlen = (u_short) |
1932 (p + sizeof("\7in-addr\4arpa") + sizeof(ngx_resolver_qs_t) | 1946 (p + sizeof("\7in-addr\4arpa") + sizeof(ngx_resolver_qs_t) |
1933 - rn->query); | 1947 - rn->query); |