[BACK]Return to nxt_30.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / external / mpl / bind / dist / lib / dns / rdata / generic

Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.

Diff for /src/external/mpl/bind/dist/lib/dns/rdata/generic/nxt_30.c between version 1.4 and 1.5

version 1.4, 2019/11/27 05:48:42 version 1.5, 2020/05/24 19:46:24
Line 28  fromtext_nxt(ARGS_FROMTEXT) {
Line 28  fromtext_nxt(ARGS_FROMTEXT) {
         dns_name_t name;          dns_name_t name;
         isc_buffer_t buffer;          isc_buffer_t buffer;
         char *e;          char *e;
         unsigned char bm[8*1024]; /* 64k bits */          unsigned char bm[8 * 1024]; /* 64k bits */
         dns_rdatatype_t covered;          dns_rdatatype_t covered;
         dns_rdatatype_t maxcovered = 0;          dns_rdatatype_t maxcovered = 0;
         bool first = true;          bool first = true;
Line 47  fromtext_nxt(ARGS_FROMTEXT) {
Line 47  fromtext_nxt(ARGS_FROMTEXT) {
                                       false));                                        false));
         dns_name_init(&name, NULL);          dns_name_init(&name, NULL);
         buffer_fromregion(&buffer, &token.value.as_region);          buffer_fromregion(&buffer, &token.value.as_region);
         if (origin == NULL)          if (origin == NULL) {
                 origin = dns_rootname;                  origin = dns_rootname;
           }
         RETTOK(dns_name_fromtext(&name, &buffer, origin, options, target));          RETTOK(dns_name_fromtext(&name, &buffer, origin, options, target));
   
         memset(bm, 0, sizeof(bm));          memset(bm, 0, sizeof(bm));
         do {          do {
                 RETERR(isc_lex_getmastertoken(lexer, &token,                  RETERR(isc_lex_getmastertoken(lexer, &token,
                                               isc_tokentype_string, true));                                                isc_tokentype_string, true));
                 if (token.type != isc_tokentype_string)                  if (token.type != isc_tokentype_string) {
                         break;                          break;
                   }
                 n = strtol(DNS_AS_STR(token), &e, 10);                  n = strtol(DNS_AS_STR(token), &e, 10);
                 if (e != DNS_AS_STR(token) && *e == '\0') {                  if (e != DNS_AS_STR(token) && *e == '\0') {
                         covered = (dns_rdatatype_t)n;                          covered = (dns_rdatatype_t)n;
                 } else if (dns_rdatatype_fromtext(&covered,                  } else if (dns_rdatatype_fromtext(&covered,
                                 &token.value.as_textregion) == DNS_R_UNKNOWN)                                                    &token.value.as_textregion) ==
                              DNS_R_UNKNOWN)
                   {
                         RETTOK(DNS_R_UNKNOWN);                          RETTOK(DNS_R_UNKNOWN);
                   }
                 /*                  /*
                  * NXT is only specified for types 1..127.                   * NXT is only specified for types 1..127.
                  */                   */
                 if (covered < 1 || covered > 127)                  if (covered < 1 || covered > 127) {
                         return (ISC_R_RANGE);                          return (ISC_R_RANGE);
                 if (first || covered > maxcovered)                  }
                   if (first || covered > maxcovered) {
                         maxcovered = covered;                          maxcovered = covered;
                   }
                 first = false;                  first = false;
                 bm[covered/8] |= (0x80>>(covered%8));                  bm[covered / 8] |= (0x80 >> (covered % 8));
         } while (1);          } while (1);
         isc_lex_ungettoken(lexer, &token);          isc_lex_ungettoken(lexer, &token);
         if (first)          if (first) {
                 return (ISC_R_SUCCESS);                  return (ISC_R_SUCCESS);
           }
         n = (maxcovered + 8) / 8;          n = (maxcovered + 8) / 8;
         return (mem_tobuffer(target, bm, n));          return (mem_tobuffer(target, bm, n));
 }  }
Line 100  totext_nxt(ARGS_TOTEXT) {
Line 108  totext_nxt(ARGS_TOTEXT) {
         RETERR(dns_name_totext(&prefix, sub, target));          RETERR(dns_name_totext(&prefix, sub, target));
   
         for (i = 0; i < sr.length; i++) {          for (i = 0; i < sr.length; i++) {
                 if (sr.base[i] != 0)                  if (sr.base[i] != 0) {
                         for (j = 0; j < 8; j++)                          for (j = 0; j < 8; j++) {
                                 if ((sr.base[i] & (0x80 >> j)) != 0) {                                  if ((sr.base[i] & (0x80 >> j)) != 0) {
                                         dns_rdatatype_t t = i * 8 + j;                                          {
                                         RETERR(str_totext(" ", target));                                                  dns_rdatatype_t t = i * 8 + j;
                                         if (dns_rdatatype_isknown(t)) {                                                  RETERR(str_totext(" ", target));
                                                 RETERR(dns_rdatatype_totext(t,                                                  if (dns_rdatatype_isknown(t)) {
                                                                       target));                                                          RETERR(dns_rdatatype_totext(
                                         } else {                                                                  t, target));
                                                 char buf[sizeof("65535")];                                                  } else {
                                                 snprintf(buf, sizeof(buf),                                                          char buf[sizeof("6553"
                                                          "%u", t);                                                                          "5")];
                                                 RETERR(str_totext(buf,                                                          snprintf(buf,
                                                                   target));                                                                   sizeof(buf),
                                                                    "%u", t);
                                                           RETERR(str_totext(
                                                                   buf, target));
                                                   }
                                         }                                          }
                                 }                                  }
                           }
                   }
         }          }
         return (ISC_R_SUCCESS);          return (ISC_R_SUCCESS);
 }  }
Line 138  fromwire_nxt(ARGS_FROMWIRE) {
Line 152  fromwire_nxt(ARGS_FROMWIRE) {
         isc_buffer_activeregion(source, &sr);          isc_buffer_activeregion(source, &sr);
         if (sr.length > 0 && (sr.base[0] & 0x80) == 0 &&          if (sr.length > 0 && (sr.base[0] & 0x80) == 0 &&
             ((sr.length > 16) || sr.base[sr.length - 1] == 0))              ((sr.length > 16) || sr.base[sr.length - 1] == 0))
           {
                 return (DNS_R_BADBITMAP);                  return (DNS_R_BADBITMAP);
           }
         RETERR(mem_tobuffer(target, sr.base, sr.length));          RETERR(mem_tobuffer(target, sr.base, sr.length));
         isc_buffer_forward(source, sr.length);          isc_buffer_forward(source, sr.length);
         return (ISC_R_SUCCESS);          return (ISC_R_SUCCESS);
Line 184  compare_nxt(ARGS_COMPARE) {
Line 200  compare_nxt(ARGS_COMPARE) {
         dns_name_fromregion(&name1, &r1);          dns_name_fromregion(&name1, &r1);
         dns_name_fromregion(&name2, &r2);          dns_name_fromregion(&name2, &r2);
         order = dns_name_rdatacompare(&name1, &name2);          order = dns_name_rdatacompare(&name1, &name2);
         if (order != 0)          if (order != 0) {
                 return (order);                  return (order);
           }
   
         isc_region_consume(&r1, name_length(&name1));          isc_region_consume(&r1, name_length(&name1));
         isc_region_consume(&r2, name_length(&name2));          isc_region_consume(&r2, name_length(&name2));
Line 240  tostruct_nxt(ARGS_TOSTRUCT) {
Line 257  tostruct_nxt(ARGS_TOSTRUCT) {
   
         nxt->len = region.length;          nxt->len = region.length;
         nxt->typebits = mem_maybedup(mctx, region.base, region.length);          nxt->typebits = mem_maybedup(mctx, region.base, region.length);
         if (nxt->typebits == NULL)          if (nxt->typebits == NULL) {
                 goto cleanup;                  goto cleanup;
           }
   
         nxt->mctx = mctx;          nxt->mctx = mctx;
         return (ISC_R_SUCCESS);          return (ISC_R_SUCCESS);
   
  cleanup:  cleanup:
         if (mctx != NULL)          if (mctx != NULL) {
                 dns_name_free(&nxt->next, mctx);                  dns_name_free(&nxt->next, mctx);
           }
         return (ISC_R_NOMEMORY);          return (ISC_R_NOMEMORY);
 }  }
   
Line 259  freestruct_nxt(ARGS_FREESTRUCT) {
Line 278  freestruct_nxt(ARGS_FREESTRUCT) {
         REQUIRE(nxt != NULL);          REQUIRE(nxt != NULL);
         REQUIRE(nxt->common.rdtype == dns_rdatatype_nxt);          REQUIRE(nxt->common.rdtype == dns_rdatatype_nxt);
   
         if (nxt->mctx == NULL)          if (nxt->mctx == NULL) {
                 return;                  return;
           }
   
         dns_name_free(&nxt->next, nxt->mctx);          dns_name_free(&nxt->next, nxt->mctx);
         if (nxt->typebits != NULL)          if (nxt->typebits != NULL) {
                 isc_mem_free(nxt->mctx, nxt->typebits);                  isc_mem_free(nxt->mctx, nxt->typebits);
           }
         nxt->mctx = NULL;          nxt->mctx = NULL;
 }  }
   
Line 291  digest_nxt(ARGS_DIGEST) {
Line 312  digest_nxt(ARGS_DIGEST) {
         dns_name_init(&name, NULL);          dns_name_init(&name, NULL);
         dns_name_fromregion(&name, &r);          dns_name_fromregion(&name, &r);
         result = dns_name_digest(&name, digest, arg);          result = dns_name_digest(&name, digest, arg);
         if (result != ISC_R_SUCCESS)          if (result != ISC_R_SUCCESS) {
                 return (result);                  return (result);
           }
         isc_region_consume(&r, name_length(&name));          isc_region_consume(&r, name_length(&name));
   
         return ((digest)(arg, &r));          return ((digest)(arg, &r));
Line 300  digest_nxt(ARGS_DIGEST) {
Line 322  digest_nxt(ARGS_DIGEST) {
   
 static inline bool  static inline bool
 checkowner_nxt(ARGS_CHECKOWNER) {  checkowner_nxt(ARGS_CHECKOWNER) {
   
         REQUIRE(type == dns_rdatatype_nxt);          REQUIRE(type == dns_rdatatype_nxt);
   
         UNUSED(name);          UNUSED(name);
Line 313  checkowner_nxt(ARGS_CHECKOWNER) {
Line 334  checkowner_nxt(ARGS_CHECKOWNER) {
   
 static inline bool  static inline bool
 checknames_nxt(ARGS_CHECKNAMES) {  checknames_nxt(ARGS_CHECKNAMES) {
   
         REQUIRE(rdata->type == dns_rdatatype_nxt);          REQUIRE(rdata->type == dns_rdatatype_nxt);
   
         UNUSED(rdata);          UNUSED(rdata);
Line 327  static inline int
Line 347  static inline int
 casecompare_nxt(ARGS_COMPARE) {  casecompare_nxt(ARGS_COMPARE) {
         return (compare_nxt(rdata1, rdata2));          return (compare_nxt(rdata1, rdata2));
 }  }
 #endif  /* RDATA_GENERIC_NXT_30_C */  #endif /* RDATA_GENERIC_NXT_30_C */
Legend:
Removed from v.1.4  
changed lines
  Added in v.1.5
CVSweb <webmaster@jp.NetBSD.org>