/contrib/bind9/lib/dns/rdata/generic/rt_21.c

https://bitbucket.org/freebsd/freebsd-head/ · C · 316 lines · 233 code · 64 blank · 19 comment · 50 complexity · dddf265d37ee0c4f3acebac7c28f7376 MD5 · raw file

  1. /*
  2. * Copyright (C) 2004, 2005, 2007, 2009 Internet Systems Consortium, Inc. ("ISC")
  3. * Copyright (C) 1999-2001, 2003 Internet Software Consortium.
  4. *
  5. * Permission to use, copy, modify, and/or distribute this software for any
  6. * purpose with or without fee is hereby granted, provided that the above
  7. * copyright notice and this permission notice appear in all copies.
  8. *
  9. * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
  10. * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  11. * AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
  12. * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  13. * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
  14. * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  15. * PERFORMANCE OF THIS SOFTWARE.
  16. */
  17. /* $Id: rt_21.c,v 1.48 2009/12/04 22:06:37 tbox Exp $ */
  18. /* reviewed: Thu Mar 16 15:02:31 PST 2000 by brister */
  19. /* RFC1183 */
  20. #ifndef RDATA_GENERIC_RT_21_C
  21. #define RDATA_GENERIC_RT_21_C
  22. #define RRTYPE_RT_ATTRIBUTES (0)
  23. static inline isc_result_t
  24. fromtext_rt(ARGS_FROMTEXT) {
  25. isc_token_t token;
  26. dns_name_t name;
  27. isc_buffer_t buffer;
  28. isc_boolean_t ok;
  29. REQUIRE(type == 21);
  30. UNUSED(type);
  31. UNUSED(rdclass);
  32. UNUSED(callbacks);
  33. RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_number,
  34. ISC_FALSE));
  35. if (token.value.as_ulong > 0xffffU)
  36. RETTOK(ISC_R_RANGE);
  37. RETERR(uint16_tobuffer(token.value.as_ulong, target));
  38. RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
  39. ISC_FALSE));
  40. dns_name_init(&name, NULL);
  41. buffer_fromregion(&buffer, &token.value.as_region);
  42. origin = (origin != NULL) ? origin : dns_rootname;
  43. RETTOK(dns_name_fromtext(&name, &buffer, origin, options, target));
  44. ok = ISC_TRUE;
  45. if ((options & DNS_RDATA_CHECKNAMES) != 0)
  46. ok = dns_name_ishostname(&name, ISC_FALSE);
  47. if (!ok && (options & DNS_RDATA_CHECKNAMESFAIL) != 0)
  48. RETTOK(DNS_R_BADNAME);
  49. if (!ok && callbacks != NULL)
  50. warn_badname(&name, lexer, callbacks);
  51. return (ISC_R_SUCCESS);
  52. }
  53. static inline isc_result_t
  54. totext_rt(ARGS_TOTEXT) {
  55. isc_region_t region;
  56. dns_name_t name;
  57. dns_name_t prefix;
  58. isc_boolean_t sub;
  59. char buf[sizeof("64000")];
  60. unsigned short num;
  61. REQUIRE(rdata->type == 21);
  62. REQUIRE(rdata->length != 0);
  63. dns_name_init(&name, NULL);
  64. dns_name_init(&prefix, NULL);
  65. dns_rdata_toregion(rdata, &region);
  66. num = uint16_fromregion(&region);
  67. isc_region_consume(&region, 2);
  68. sprintf(buf, "%u", num);
  69. RETERR(str_totext(buf, target));
  70. RETERR(str_totext(" ", target));
  71. dns_name_fromregion(&name, &region);
  72. sub = name_prefix(&name, tctx->origin, &prefix);
  73. return (dns_name_totext(&prefix, sub, target));
  74. }
  75. static inline isc_result_t
  76. fromwire_rt(ARGS_FROMWIRE) {
  77. dns_name_t name;
  78. isc_region_t sregion;
  79. isc_region_t tregion;
  80. REQUIRE(type == 21);
  81. UNUSED(type);
  82. UNUSED(rdclass);
  83. dns_decompress_setmethods(dctx, DNS_COMPRESS_NONE);
  84. dns_name_init(&name, NULL);
  85. isc_buffer_activeregion(source, &sregion);
  86. isc_buffer_availableregion(target, &tregion);
  87. if (tregion.length < 2)
  88. return (ISC_R_NOSPACE);
  89. if (sregion.length < 2)
  90. return (ISC_R_UNEXPECTEDEND);
  91. memcpy(tregion.base, sregion.base, 2);
  92. isc_buffer_forward(source, 2);
  93. isc_buffer_add(target, 2);
  94. return (dns_name_fromwire(&name, source, dctx, options, target));
  95. }
  96. static inline isc_result_t
  97. towire_rt(ARGS_TOWIRE) {
  98. dns_name_t name;
  99. dns_offsets_t offsets;
  100. isc_region_t region;
  101. isc_region_t tr;
  102. REQUIRE(rdata->type == 21);
  103. REQUIRE(rdata->length != 0);
  104. dns_compress_setmethods(cctx, DNS_COMPRESS_NONE);
  105. isc_buffer_availableregion(target, &tr);
  106. dns_rdata_toregion(rdata, &region);
  107. if (tr.length < 2)
  108. return (ISC_R_NOSPACE);
  109. memcpy(tr.base, region.base, 2);
  110. isc_region_consume(&region, 2);
  111. isc_buffer_add(target, 2);
  112. dns_name_init(&name, offsets);
  113. dns_name_fromregion(&name, &region);
  114. return (dns_name_towire(&name, cctx, target));
  115. }
  116. static inline int
  117. compare_rt(ARGS_COMPARE) {
  118. dns_name_t name1;
  119. dns_name_t name2;
  120. isc_region_t region1;
  121. isc_region_t region2;
  122. int order;
  123. REQUIRE(rdata1->type == rdata2->type);
  124. REQUIRE(rdata1->rdclass == rdata2->rdclass);
  125. REQUIRE(rdata1->type == 21);
  126. REQUIRE(rdata1->length != 0);
  127. REQUIRE(rdata2->length != 0);
  128. order = memcmp(rdata1->data, rdata2->data, 2);
  129. if (order != 0)
  130. return (order < 0 ? -1 : 1);
  131. dns_name_init(&name1, NULL);
  132. dns_name_init(&name2, NULL);
  133. dns_rdata_toregion(rdata1, &region1);
  134. dns_rdata_toregion(rdata2, &region2);
  135. isc_region_consume(&region1, 2);
  136. isc_region_consume(&region2, 2);
  137. dns_name_fromregion(&name1, &region1);
  138. dns_name_fromregion(&name2, &region2);
  139. return (dns_name_rdatacompare(&name1, &name2));
  140. }
  141. static inline isc_result_t
  142. fromstruct_rt(ARGS_FROMSTRUCT) {
  143. dns_rdata_rt_t *rt = source;
  144. isc_region_t region;
  145. REQUIRE(type == 21);
  146. REQUIRE(source != NULL);
  147. REQUIRE(rt->common.rdtype == type);
  148. REQUIRE(rt->common.rdclass == rdclass);
  149. UNUSED(type);
  150. UNUSED(rdclass);
  151. RETERR(uint16_tobuffer(rt->preference, target));
  152. dns_name_toregion(&rt->host, &region);
  153. return (isc_buffer_copyregion(target, &region));
  154. }
  155. static inline isc_result_t
  156. tostruct_rt(ARGS_TOSTRUCT) {
  157. isc_region_t region;
  158. dns_rdata_rt_t *rt = target;
  159. dns_name_t name;
  160. REQUIRE(rdata->type == 21);
  161. REQUIRE(target != NULL);
  162. REQUIRE(rdata->length != 0);
  163. rt->common.rdclass = rdata->rdclass;
  164. rt->common.rdtype = rdata->type;
  165. ISC_LINK_INIT(&rt->common, link);
  166. dns_name_init(&name, NULL);
  167. dns_rdata_toregion(rdata, &region);
  168. rt->preference = uint16_fromregion(&region);
  169. isc_region_consume(&region, 2);
  170. dns_name_fromregion(&name, &region);
  171. dns_name_init(&rt->host, NULL);
  172. RETERR(name_duporclone(&name, mctx, &rt->host));
  173. rt->mctx = mctx;
  174. return (ISC_R_SUCCESS);
  175. }
  176. static inline void
  177. freestruct_rt(ARGS_FREESTRUCT) {
  178. dns_rdata_rt_t *rt = source;
  179. REQUIRE(source != NULL);
  180. REQUIRE(rt->common.rdtype == 21);
  181. if (rt->mctx == NULL)
  182. return;
  183. dns_name_free(&rt->host, rt->mctx);
  184. rt->mctx = NULL;
  185. }
  186. static inline isc_result_t
  187. additionaldata_rt(ARGS_ADDLDATA) {
  188. dns_name_t name;
  189. dns_offsets_t offsets;
  190. isc_region_t region;
  191. isc_result_t result;
  192. REQUIRE(rdata->type == 21);
  193. dns_name_init(&name, offsets);
  194. dns_rdata_toregion(rdata, &region);
  195. isc_region_consume(&region, 2);
  196. dns_name_fromregion(&name, &region);
  197. result = (add)(arg, &name, dns_rdatatype_x25);
  198. if (result != ISC_R_SUCCESS)
  199. return (result);
  200. result = (add)(arg, &name, dns_rdatatype_isdn);
  201. if (result != ISC_R_SUCCESS)
  202. return (result);
  203. return ((add)(arg, &name, dns_rdatatype_a));
  204. }
  205. static inline isc_result_t
  206. digest_rt(ARGS_DIGEST) {
  207. isc_region_t r1, r2;
  208. isc_result_t result;
  209. dns_name_t name;
  210. REQUIRE(rdata->type == 21);
  211. dns_rdata_toregion(rdata, &r1);
  212. r2 = r1;
  213. isc_region_consume(&r2, 2);
  214. r1.length = 2;
  215. result = (digest)(arg, &r1);
  216. if (result != ISC_R_SUCCESS)
  217. return (result);
  218. dns_name_init(&name, NULL);
  219. dns_name_fromregion(&name, &r2);
  220. return (dns_name_digest(&name, digest, arg));
  221. }
  222. static inline isc_boolean_t
  223. checkowner_rt(ARGS_CHECKOWNER) {
  224. REQUIRE(type == 21);
  225. UNUSED(name);
  226. UNUSED(type);
  227. UNUSED(rdclass);
  228. UNUSED(wildcard);
  229. return (ISC_TRUE);
  230. }
  231. static inline isc_boolean_t
  232. checknames_rt(ARGS_CHECKNAMES) {
  233. isc_region_t region;
  234. dns_name_t name;
  235. REQUIRE(rdata->type == 21);
  236. UNUSED(owner);
  237. dns_rdata_toregion(rdata, &region);
  238. isc_region_consume(&region, 2);
  239. dns_name_init(&name, NULL);
  240. dns_name_fromregion(&name, &region);
  241. if (!dns_name_ishostname(&name, ISC_FALSE)) {
  242. if (bad != NULL)
  243. dns_name_clone(&name, bad);
  244. return (ISC_FALSE);
  245. }
  246. return (ISC_TRUE);
  247. }
  248. static inline int
  249. casecompare_rt(ARGS_COMPARE) {
  250. return (compare_rt(rdata1, rdata2));
  251. }
  252. #endif /* RDATA_GENERIC_RT_21_C */