contrib/ldns/host2wire.c

   1 /*
   2  * host2wire.c
   3  *
   4  * conversion routines from the host to the wire format.
   5  * This will usually just a re-ordering of the
   6  * data (as we store it in network format)
   7  *
   8  * a Net::DNS like library for C
   9  *
  10  * (c) NLnet Labs, 2004-2006
  11  *
  12  * See the file LICENSE for the license
  13  */
  14
  15 #include <ldns/config.h>
  16
  17 #include <ldns/ldns.h>
  18
  19 /* TODO Jelte
  20   add a pointer to a 'possiblecompression' structure
  21   to all the needed functions?
  22   something like an array of name, pointer values?
  23   every dname part could be added to it
  24 */
  25
  26 ldns_status
  27 ldns_dname2buffer_wire(ldns_buffer *buffer, const ldns_rdf *name)
  28 {
  29         if (ldns_buffer_reserve(buffer, ldns_rdf_size(name))) {
  30                 ldns_buffer_write(buffer, ldns_rdf_data(name), ldns_rdf_size(name));
  31         }
  32         return ldns_buffer_status(buffer);
  33 }
  34
  35 ldns_status
  36 ldns_rdf2buffer_wire(ldns_buffer *buffer, const ldns_rdf *rdf)
  37 {
  38         if (ldns_buffer_reserve(buffer, ldns_rdf_size(rdf))) {
  39                 ldns_buffer_write(buffer, ldns_rdf_data(rdf), ldns_rdf_size(rdf));
  40         }
  41         return ldns_buffer_status(buffer);
  42 }
  43
  44 ldns_status
  45 ldns_rdf2buffer_wire_canonical(ldns_buffer *buffer, const ldns_rdf *rdf)
  46 {
  47         size_t i;
  48         uint8_t *rdf_data;
  49
  50         if (ldns_rdf_get_type(rdf) == LDNS_RDF_TYPE_DNAME) {
  51                 if (ldns_buffer_reserve(buffer, ldns_rdf_size(rdf))) {
  52                         rdf_data = ldns_rdf_data(rdf);
  53                         for (i = 0; i < ldns_rdf_size(rdf); i++) {
  54                                 ldns_buffer_write_u8(buffer,
  55                                     (uint8_t) LDNS_DNAME_NORMALIZE((int)rdf_data[i]));
  56                         }
  57                 }
  58         } else {
  59                 /* direct copy for all other types */
  60                 if (ldns_buffer_reserve(buffer, ldns_rdf_size(rdf))) {
  61                         ldns_buffer_write(buffer,
  62                                                    ldns_rdf_data(rdf),
  63                                                    ldns_rdf_size(rdf));
  64                 }
  65         }
  66         return ldns_buffer_status(buffer);
  67 }
  68
  69 /* convert a rr list to wireformat */
  70 ldns_status
  71 ldns_rr_list2buffer_wire(ldns_buffer *buffer,const ldns_rr_list *rr_list)
  72 {
  73         uint16_t rr_count;
  74         uint16_t i;
  75
  76         rr_count = ldns_rr_list_rr_count(rr_list);
  77         for(i = 0; i < rr_count; i++) {
  78                 (void)ldns_rr2buffer_wire(buffer, ldns_rr_list_rr(rr_list, i),
  79                                           LDNS_SECTION_ANY);
  80         }
  81         return ldns_buffer_status(buffer);
  82 }
  83
  84 ldns_status
  85 ldns_rr2buffer_wire_canonical(ldns_buffer *buffer,
  86                                                 const ldns_rr *rr,
  87                                                 int section)
  88 {
  89         uint16_t i;
  90         uint16_t rdl_pos = 0;
  91         bool pre_rfc3597 = false;
  92         switch (ldns_rr_get_type(rr)) {
  93         case LDNS_RR_TYPE_NS:
  94         case LDNS_RR_TYPE_MD:
  95         case LDNS_RR_TYPE_MF:
  96         case LDNS_RR_TYPE_CNAME:
  97         case LDNS_RR_TYPE_SOA:
  98         case LDNS_RR_TYPE_MB:
  99         case LDNS_RR_TYPE_MG:
 100         case LDNS_RR_TYPE_MR:
 101         case LDNS_RR_TYPE_PTR:
 102         case LDNS_RR_TYPE_HINFO:
 103         case LDNS_RR_TYPE_MINFO:
 104         case LDNS_RR_TYPE_MX:
 105         case LDNS_RR_TYPE_RP:
 106         case LDNS_RR_TYPE_AFSDB:
 107         case LDNS_RR_TYPE_RT:
 108         case LDNS_RR_TYPE_SIG:
 109         case LDNS_RR_TYPE_PX:
 110         case LDNS_RR_TYPE_NXT:
 111         case LDNS_RR_TYPE_NAPTR:
 112         case LDNS_RR_TYPE_KX:
 113         case LDNS_RR_TYPE_SRV:
 114         case LDNS_RR_TYPE_DNAME:
 115         case LDNS_RR_TYPE_A6:
 116                 pre_rfc3597 = true;
 117                 break;
 118         default:
 119                 break;
 120         }
 121
 122         if (ldns_rr_owner(rr)) {
 123                 (void) ldns_rdf2buffer_wire_canonical(buffer, ldns_rr_owner(rr));
 124         }
 125
 126         if (ldns_buffer_reserve(buffer, 4)) {
 127                 (void) ldns_buffer_write_u16(buffer, ldns_rr_get_type(rr));
 128                 (void) ldns_buffer_write_u16(buffer, ldns_rr_get_class(rr));
 129         }
 130
 131         if (section != LDNS_SECTION_QUESTION) {
 132                 if (ldns_buffer_reserve(buffer, 6)) {
 133                         ldns_buffer_write_u32(buffer, ldns_rr_ttl(rr));
 134                         /* remember pos for later */
 135                         rdl_pos = ldns_buffer_position(buffer);
 136                         ldns_buffer_write_u16(buffer, 0);
 137                 }
 138
 139                 for (i = 0; i < ldns_rr_rd_count(rr); i++) {
 140                         if (pre_rfc3597) {
 141                                 (void) ldns_rdf2buffer_wire_canonical(buffer,
 142                                                                                            ldns_rr_rdf(rr, i));
 143                         } else {
 144                                 (void) ldns_rdf2buffer_wire(buffer, ldns_rr_rdf(rr, i));
 145                         }
 146                 }
 147
 148                 if (rdl_pos != 0) {
 149                         ldns_buffer_write_u16_at(buffer, rdl_pos,
 150                                                  ldns_buffer_position(buffer)
 151                                                    - rdl_pos - 2);
 152                 }
 153         }
 154         return ldns_buffer_status(buffer);
 155 }
 156
 157 ldns_status
 158 ldns_rr2buffer_wire(ldns_buffer *buffer, const ldns_rr *rr, int section)
 159 {
 160         uint16_t i;
 161         uint16_t rdl_pos = 0;
 162
 163         if (ldns_rr_owner(rr)) {
 164                 (void) ldns_dname2buffer_wire(buffer, ldns_rr_owner(rr));
 165         }
 166
 167         if (ldns_buffer_reserve(buffer, 4)) {
 168                 (void) ldns_buffer_write_u16(buffer, ldns_rr_get_type(rr));
 169                 (void) ldns_buffer_write_u16(buffer, ldns_rr_get_class(rr));
 170         }
 171
 172         if (section != LDNS_SECTION_QUESTION) {
 173                 if (ldns_buffer_reserve(buffer, 6)) {
 174                         ldns_buffer_write_u32(buffer, ldns_rr_ttl(rr));
 175                         /* remember pos for later */
 176                         rdl_pos = ldns_buffer_position(buffer);
 177                         ldns_buffer_write_u16(buffer, 0);
 178                 }
 179
 180                 for (i = 0; i < ldns_rr_rd_count(rr); i++) {
 181                         (void) ldns_rdf2buffer_wire(buffer, ldns_rr_rdf(rr, i));
 182                 }
 183
 184                 if (rdl_pos != 0) {
 185                         ldns_buffer_write_u16_at(buffer, rdl_pos,
 186                                                  ldns_buffer_position(buffer)
 187                                                    - rdl_pos - 2);
 188                 }
 189         }
 190         return ldns_buffer_status(buffer);
 191 }
 192
 193 ldns_status
 194 ldns_rrsig2buffer_wire(ldns_buffer *buffer, const ldns_rr *rr)
 195 {
 196         uint16_t i;
 197
 198         /* it must be a sig RR */
 199         if (ldns_rr_get_type(rr) != LDNS_RR_TYPE_RRSIG) {
 200                 return LDNS_STATUS_ERR;
 201         }
 202
 203         /* Convert all the rdfs, except the actual signature data
 204          * rdf number 8  - the last, hence: -1 */
 205         for (i = 0; i < ldns_rr_rd_count(rr) - 1; i++) {
 206                 if (ldns_rr_rdf(rr, i)) {
 207                         (void) ldns_rdf2buffer_wire(buffer, ldns_rr_rdf(rr, i));
 208                 }
 209         }
 210
 211         return ldns_buffer_status(buffer);
 212 }
 213
 214 ldns_status
 215 ldns_rr_rdata2buffer_wire(ldns_buffer *buffer, const ldns_rr *rr)
 216 {
 217         uint16_t i;
 218         /* convert all the rdf's */
 219         for (i = 0; i < ldns_rr_rd_count(rr); i++) {
 220                 (void) ldns_rdf2buffer_wire(buffer, ldns_rr_rdf(rr, i));
 221         }
 222
 223         return ldns_buffer_status(buffer);
 224 }
 225
 226 /*
 227  * Copies the packet header data to the buffer in wire format
 228  */
 229 static ldns_status
 230 ldns_hdr2buffer_wire(ldns_buffer *buffer, const ldns_pkt *packet)
 231 {
 232         uint8_t flags;
 233         uint16_t arcount;
 234
 235         if (ldns_buffer_reserve(buffer, 12)) {
 236                 ldns_buffer_write_u16(buffer, ldns_pkt_id(packet));
 237
 238                 flags = ldns_pkt_qr(packet) << 7
 239                         | ldns_pkt_get_opcode(packet) << 3
 240                         | ldns_pkt_aa(packet) << 2
 241                         | ldns_pkt_tc(packet) << 1 | ldns_pkt_rd(packet);
 242                 ldns_buffer_write_u8(buffer, flags);
 243
 244                 flags = ldns_pkt_ra(packet) << 7
 245                         /*| ldns_pkt_z(packet) << 6*/
 246                         | ldns_pkt_ad(packet) << 5
 247                         | ldns_pkt_cd(packet) << 4 | ldns_pkt_get_rcode(packet);
 248                 ldns_buffer_write_u8(buffer, flags);
 249
 250                 ldns_buffer_write_u16(buffer, ldns_pkt_qdcount(packet));
 251                 ldns_buffer_write_u16(buffer, ldns_pkt_ancount(packet));
 252                 ldns_buffer_write_u16(buffer, ldns_pkt_nscount(packet));
 253                 /* add EDNS0 and TSIG to additional if they are there */
 254                 arcount = ldns_pkt_arcount(packet);
 255                 if (ldns_pkt_tsig(packet)) {
 256                         arcount++;
 257                 }
 258                 if (ldns_pkt_edns(packet)) {
 259                         arcount++;
 260                 }
 261                 ldns_buffer_write_u16(buffer, arcount);
 262         }
 263
 264         return ldns_buffer_status(buffer);
 265 }
 266
 267 ldns_status
 268 ldns_pkt2buffer_wire(ldns_buffer *buffer, const ldns_pkt *packet)
 269 {
 270         ldns_rr_list *rr_list;
 271         uint16_t i;
 272
 273         /* edns tmp vars */
 274         ldns_rr *edns_rr;
 275         uint8_t edata[4];
 276
 277         (void) ldns_hdr2buffer_wire(buffer, packet);
 278
 279         rr_list = ldns_pkt_question(packet);
 280         if (rr_list) {
 281                 for (i = 0; i < ldns_rr_list_rr_count(rr_list); i++) {
 282                         (void) ldns_rr2buffer_wire(buffer,
 283                                      ldns_rr_list_rr(rr_list, i), LDNS_SECTION_QUESTION);
 284                 }
 285         }
 286         rr_list = ldns_pkt_answer(packet);
 287         if (rr_list) {
 288                 for (i = 0; i < ldns_rr_list_rr_count(rr_list); i++) {
 289                         (void) ldns_rr2buffer_wire(buffer,
 290                                      ldns_rr_list_rr(rr_list, i), LDNS_SECTION_ANSWER);
 291                 }
 292         }
 293         rr_list = ldns_pkt_authority(packet);
 294         if (rr_list) {
 295                 for (i = 0; i < ldns_rr_list_rr_count(rr_list); i++) {
 296                         (void) ldns_rr2buffer_wire(buffer,
 297                                      ldns_rr_list_rr(rr_list, i), LDNS_SECTION_AUTHORITY);
 298                 }
 299         }
 300         rr_list = ldns_pkt_additional(packet);
 301         if (rr_list) {
 302                 for (i = 0; i < ldns_rr_list_rr_count(rr_list); i++) {
 303                         (void) ldns_rr2buffer_wire(buffer,
 304                                      ldns_rr_list_rr(rr_list, i), LDNS_SECTION_ADDITIONAL);
 305                 }
 306         }
 307
 308         /* add EDNS to additional if it is needed */
 309         if (ldns_pkt_edns(packet)) {
 310                 edns_rr = ldns_rr_new();
 311                 ldns_rr_set_owner(edns_rr,
 312                                 ldns_rdf_new_frm_str(LDNS_RDF_TYPE_DNAME, "."));
 313                 ldns_rr_set_type(edns_rr, LDNS_RR_TYPE_OPT);
 314                 ldns_rr_set_class(edns_rr, ldns_pkt_edns_udp_size(packet));
 315                 edata[0] = ldns_pkt_edns_extended_rcode(packet);
 316                 edata[1] = ldns_pkt_edns_version(packet);
 317                 ldns_write_uint16(&edata[2], ldns_pkt_edns_z(packet));
 318                 ldns_rr_set_ttl(edns_rr, ldns_read_uint32(edata));
 319                 /* don't forget to add the edns rdata (if any) */
 320                 if (packet->_edns_data)
 321                         ldns_rr_push_rdf (edns_rr, packet->_edns_data);
 322                 (void)ldns_rr2buffer_wire(buffer, edns_rr, LDNS_SECTION_ADDITIONAL);
 323                 /* take the edns rdata back out of the rr before we free rr */
 324                 if (packet->_edns_data)
 325                         ldns_rr_pop_rdf (edns_rr);
 326                 ldns_rr_free(edns_rr);
 327         }
 328
 329         /* add TSIG to additional if it is there */
 330         if (ldns_pkt_tsig(packet)) {
 331                 (void) ldns_rr2buffer_wire(buffer,
 332                                            ldns_pkt_tsig(packet), LDNS_SECTION_ADDITIONAL);
 333         }
 334
 335         return LDNS_STATUS_OK;
 336 }
 337
 338 ldns_status
 339 ldns_rdf2wire(uint8_t **dest, const ldns_rdf *rdf, size_t *result_size)
 340 {
 341         ldns_buffer *buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN);
 342         uint8_t *result = NULL;
 343         ldns_status status;
 344         *result_size = 0;
 345         *dest = NULL;
 346
 347         status = ldns_rdf2buffer_wire(buffer, rdf);
 348         if (status == LDNS_STATUS_OK) {
 349                 *result_size =  ldns_buffer_position(buffer);
 350                 result = (uint8_t *) ldns_buffer_export(buffer);
 351         } else {
 352                 return status;
 353         }
 354
 355         if (result) {
 356                 *dest = LDNS_XMALLOC(uint8_t, ldns_buffer_position(buffer));
 357                 memcpy(*dest, result, ldns_buffer_position(buffer));
 358         }
 359
 360         ldns_buffer_free(buffer);
 361         return status;
 362 }
 363
 364 ldns_status
 365 ldns_rr2wire(uint8_t **dest, const ldns_rr *rr, int section, size_t *result_size)
 366 {
 367         ldns_buffer *buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN);
 368         uint8_t *result = NULL;
 369         ldns_status status;
 370         *result_size = 0;
 371         *dest = NULL;
 372
 373         status = ldns_rr2buffer_wire(buffer, rr, section);
 374         if (status == LDNS_STATUS_OK) {
 375                 *result_size =  ldns_buffer_position(buffer);
 376                 result = (uint8_t *) ldns_buffer_export(buffer);
 377         } else {
 378                 return status;
 379         }
 380
 381         if (result) {
 382                 *dest = LDNS_XMALLOC(uint8_t, ldns_buffer_position(buffer));
 383                 memcpy(*dest, result, ldns_buffer_position(buffer));
 384         }
 385
 386         ldns_buffer_free(buffer);
 387         return status;
 388 }
 389
 390 ldns_status
 391 ldns_pkt2wire(uint8_t **dest, const ldns_pkt *packet, size_t *result_size)
 392 {
 393         ldns_buffer *buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN);
 394         uint8_t *result = NULL;
 395         ldns_status status;
 396         *result_size = 0;
 397         *dest = NULL;
 398
 399         status = ldns_pkt2buffer_wire(buffer, packet);
 400         if (status == LDNS_STATUS_OK) {
 401                 *result_size =  ldns_buffer_position(buffer);
 402                 result = (uint8_t *) ldns_buffer_export(buffer);
 403         } else {
 404                 return status;
 405         }
 406
 407         if (result) {
 408                 *dest = LDNS_XMALLOC(uint8_t, ldns_buffer_position(buffer));
 409                 memcpy(*dest, result, ldns_buffer_position(buffer));
 410         }
 411
 412         ldns_buffer_free(buffer);
 413         return status;
 414 }