librpc/ndr/ndr_dns.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    manipulate dns name structures
   5
   6    Copyright (C) 2010 Kai Blin  <kai@samba.org>
   7
   8    Heavily based on nbtname.c which is:
   9
  10    Copyright (C) Andrew Tridgell 2005
  11
  12    This program is free software; you can redistribute it and/or modify
  13    it under the terms of the GNU General Public License as published by
  14    the Free Software Foundation; either version 3 of the License, or
  15    (at your option) any later version.
  16
  17    This program is distributed in the hope that it will be useful,
  18    but WITHOUT ANY WARRANTY; without even the implied warranty of
  19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20    GNU General Public License for more details.
  21
  22    You should have received a copy of the GNU General Public License
  23    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  24 */
  25
  26 /*
  27   see rfc1002 for the detailed format of compressed names
  28 */
  29
  30 #include "includes.h"
  31 #include "librpc/gen_ndr/ndr_dns.h"
  32 #include "librpc/gen_ndr/ndr_misc.h"
  33 #include "librpc/gen_ndr/ndr_dnsp.h"
  34 #include "system/locale.h"
  35 #include "lib/util/util_net.h"
  36 #include "ndr_dns_utils.h"
  37
  38 /* don't allow an unlimited number of name components */
  39 #define MAX_COMPONENTS 128
  40
  41 /**
  42   print a dns string
  43 */
  44 _PUBLIC_ void ndr_print_dns_string(struct ndr_print *ndr,
  45                                    const char *name,
  46                                    const char *s)
  47 {
  48         ndr_print_string(ndr, name, s);
  49 }
  50
  51 /*
  52   pull one component of a dns_string
  53 */
  54 static enum ndr_err_code ndr_pull_component(struct ndr_pull *ndr,
  55                                             uint8_t **component,
  56                                             uint32_t *offset,
  57                                             uint32_t *max_offset)
  58 {
  59         uint8_t len;
  60         unsigned int loops = 0;
  61         while (loops < 5) {
  62                 if (*offset >= ndr->data_size) {
  63                         return ndr_pull_error(ndr, NDR_ERR_STRING,
  64                                         "BAD DNS NAME component, bad offset");
  65                 }
  66                 len = ndr->data[*offset];
  67                 if (len == 0) {
  68                         *offset += 1;
  69                         *max_offset = MAX(*max_offset, *offset);
  70                         *component = NULL;
  71                         return NDR_ERR_SUCCESS;
  72                 }
  73                 if ((len & 0xC0) == 0xC0) {
  74                         /* its a label pointer */
  75                         if (1 + *offset >= ndr->data_size) {
  76                                 return ndr_pull_error(ndr, NDR_ERR_STRING,
  77                                                 "BAD DNS NAME component, " \
  78                                                 "bad label offset");
  79                         }
  80                         *max_offset = MAX(*max_offset, *offset + 2);
  81                         *offset = ((len&0x3F)<<8) | ndr->data[1 + *offset];
  82                         *max_offset = MAX(*max_offset, *offset);
  83                         loops++;
  84                         continue;
  85                 }
  86                 if ((len & 0xC0) != 0) {
  87                         /* its a reserved length field */
  88                         return ndr_pull_error(ndr, NDR_ERR_STRING,
  89                                               "BAD DNS NAME component, " \
  90                                               "reserved length field: 0x%02x",
  91                                               (len &0xC));
  92                 }
  93                 if (*offset + len + 1 > ndr->data_size) {
  94                         return ndr_pull_error(ndr, NDR_ERR_STRING,
  95                                               "BAD DNS NAME component, "\
  96                                               "length too long");
  97                 }
  98                 *component = (uint8_t*)talloc_strndup(ndr,
  99                                 (const char *)&ndr->data[1 + *offset], len);
 100                 NDR_ERR_HAVE_NO_MEMORY(*component);
 101                 *offset += len + 1;
 102                 *max_offset = MAX(*max_offset, *offset);
 103                 return NDR_ERR_SUCCESS;
 104         }
 105
 106         /* too many pointers */
 107         return ndr_pull_error(ndr, NDR_ERR_STRING,
 108                               "BAD DNS NAME component, too many pointers");
 109 }
 110
 111 /**
 112   pull a dns_string from the wire
 113 */
 114 _PUBLIC_ enum ndr_err_code ndr_pull_dns_string(struct ndr_pull *ndr,
 115                                                int ndr_flags,
 116                                                const char **s)
 117 {
 118         uint32_t offset = ndr->offset;
 119         uint32_t max_offset = offset;
 120         unsigned num_components;
 121         char *name;
 122
 123         if (!(ndr_flags & NDR_SCALARS)) {
 124                 return NDR_ERR_SUCCESS;
 125         }
 126
 127         name = talloc_strdup(ndr->current_mem_ctx, "");
 128
 129         /* break up name into a list of components */
 130         for (num_components=0; num_components<MAX_COMPONENTS;
 131              num_components++) {
 132                 uint8_t *component = NULL;
 133                 NDR_CHECK(ndr_pull_component(ndr, &component, &offset,
 134                                              &max_offset));
 135                 if (component == NULL) break;
 136                 if (num_components > 0) {
 137                         name = talloc_asprintf_append_buffer(name, ".%s",
 138                                                              component);
 139                 } else {
 140                         name = talloc_asprintf_append_buffer(name, "%s",
 141                                                              component);
 142                 }
 143                 NDR_ERR_HAVE_NO_MEMORY(name);
 144         }
 145         if (num_components == MAX_COMPONENTS) {
 146                 return ndr_pull_error(ndr, NDR_ERR_STRING,
 147                                       "BAD DNS NAME too many components");
 148         }
 149
 150         (*s) = name;
 151         ndr->offset = max_offset;
 152
 153         return NDR_ERR_SUCCESS;
 154 }
 155
 156 /**
 157   push a dns string to the wire
 158 */
 159 _PUBLIC_ enum ndr_err_code ndr_push_dns_string(struct ndr_push *ndr,
 160                                                int ndr_flags,
 161                                                const char *s)
 162 {
 163         return ndr_push_dns_string_list(ndr,
 164                                         &ndr->dns_string_list,
 165                                         ndr_flags,
 166                                         s,
 167                                         false);
 168 }
 169
 170 _PUBLIC_ enum ndr_err_code ndr_pull_dns_txt_record(struct ndr_pull *ndr, int ndr_flags, struct dns_txt_record *r)
 171 {
 172         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 173         if (ndr_flags & NDR_SCALARS) {
 174                 enum ndr_err_code ndr_err;
 175                 uint32_t data_size = ndr->data_size;
 176                 uint32_t record_size = 0;
 177                 ndr_err = ndr_token_retrieve(&ndr->array_size_list, r,
 178                                              &record_size);
 179                 if (NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 180                         NDR_PULL_NEED_BYTES(ndr, record_size);
 181                         ndr->data_size = ndr->offset + record_size;
 182                 }
 183                 NDR_CHECK(ndr_pull_align(ndr, 1));
 184                 NDR_CHECK(ndr_pull_dnsp_string_list(ndr, NDR_SCALARS, &r->txt));
 185                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
 186                 ndr->data_size = data_size;
 187         }
 188         if (ndr_flags & NDR_BUFFERS) {
 189         }
 190         return NDR_ERR_SUCCESS;
 191 }
 192
 193 _PUBLIC_ enum ndr_err_code ndr_push_dns_res_rec(struct ndr_push *ndr,
 194                                                 int ndr_flags,
 195                                                 const struct dns_res_rec *r)
 196 {
 197         uint32_t _flags_save_STRUCT = ndr->flags;
 198         uint32_t _saved_offset1, _saved_offset2;
 199         uint16_t length;
 200         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX |
 201                                    LIBNDR_FLAG_NOALIGN);
 202         if (ndr_flags & NDR_SCALARS) {
 203                 uint32_t _flags_save_name = ndr->flags;
 204
 205                 NDR_CHECK(ndr_push_align(ndr, 4));
 206
 207                 switch (r->rr_type) {
 208                 case DNS_QTYPE_TKEY:
 209                 case DNS_QTYPE_TSIG:
 210                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NO_COMPRESSION);
 211                         break;
 212                 default:
 213                         break;
 214                 }
 215                 NDR_CHECK(ndr_push_dns_string(ndr, NDR_SCALARS, r->name));
 216                 ndr->flags = _flags_save_name;
 217
 218                 NDR_CHECK(ndr_push_dns_qtype(ndr, NDR_SCALARS, r->rr_type));
 219                 NDR_CHECK(ndr_push_dns_qclass(ndr, NDR_SCALARS, r->rr_class));
 220                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ttl));
 221                 _saved_offset1 = ndr->offset;
 222                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 0));
 223                 if (r->length > 0) {
 224                         uint32_t _saved_offset3;
 225
 226                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->rdata,
 227                                                             r->rr_type));
 228                         _saved_offset3 = ndr->offset;
 229                         NDR_CHECK(ndr_push_dns_rdata(ndr, NDR_SCALARS,
 230                                                      &r->rdata));
 231                         if ((ndr->offset != _saved_offset3) &&
 232                             (r->unexpected.length > 0)) {
 233                                 /*
 234                                  * ndr_push_dns_rdata pushed a known
 235                                  * record, but we have something
 236                                  * unexpected. That's invalid.
 237                                  */
 238                                 return ndr_push_error(ndr,
 239                                                       NDR_ERR_LENGTH,
 240                                                       "Invalid...Unexpected " \
 241                                                       "blob length is too " \
 242                                                       "large");
 243                         }
 244                 }
 245                 if (r->unexpected.length > UINT16_MAX) {
 246                         return ndr_push_error(ndr, NDR_ERR_LENGTH,
 247                                               "Unexpected blob length "\
 248                                               "is too large");
 249                 }
 250
 251                 NDR_CHECK(ndr_push_bytes(ndr, r->unexpected.data,
 252                                          r->unexpected.length));
 253                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 254                 length = ndr->offset - (_saved_offset1 + 2);
 255                 _saved_offset2 = ndr->offset;
 256                 ndr->offset = _saved_offset1;
 257                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, length));
 258                 ndr->offset = _saved_offset2;
 259         }
 260         if (ndr_flags & NDR_BUFFERS) {
 261                 NDR_CHECK(ndr_push_dns_rdata(ndr, NDR_BUFFERS,
 262                                              &r->rdata));
 263         }
 264         ndr->flags = _flags_save_STRUCT;
 265         return NDR_ERR_SUCCESS;
 266 }
 267
 268 _PUBLIC_ enum ndr_err_code ndr_pull_dns_res_rec(struct ndr_pull *ndr,
 269                                                 int ndr_flags,
 270                                                 struct dns_res_rec *r)
 271 {
 272         uint32_t _flags_save_STRUCT = ndr->flags;
 273         uint32_t _saved_offset1;
 274         uint32_t pad, length;
 275
 276         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX |
 277                                    LIBNDR_FLAG_NOALIGN);
 278         if (ndr_flags & NDR_SCALARS) {
 279                 NDR_CHECK(ndr_pull_align(ndr, 4));
 280                 NDR_CHECK(ndr_pull_dns_string(ndr, NDR_SCALARS, &r->name));
 281                 NDR_CHECK(ndr_pull_dns_qtype(ndr, NDR_SCALARS, &r->rr_type));
 282                 NDR_CHECK(ndr_pull_dns_qclass(ndr, NDR_SCALARS, &r->rr_class));
 283                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ttl));
 284                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->length));
 285                 _saved_offset1 = ndr->offset;
 286                 if (r->length > 0) {
 287                         NDR_CHECK(ndr_token_store(ndr, &ndr->array_size_list,
 288                                                   &r->rdata,
 289                                                   r->length));
 290                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->rdata,
 291                                                             r->rr_type));
 292                         NDR_CHECK(ndr_pull_dns_rdata(ndr, NDR_SCALARS,
 293                                                      &r->rdata));
 294                 } else {
 295                         ZERO_STRUCT(r->rdata);
 296                 }
 297                 length = ndr->offset - _saved_offset1;
 298                 if (length > r->length) {
 299                         return ndr_pull_error(ndr, NDR_ERR_LENGTH, "TODO");
 300                 }
 301
 302                 r->unexpected = data_blob_null;
 303                 pad = r->length - length;
 304                 if (pad > 0) {
 305                         NDR_PULL_NEED_BYTES(ndr, pad);
 306                         r->unexpected = data_blob_talloc(ndr->current_mem_ctx,
 307                                                          ndr->data +
 308                                                          ndr->offset,
 309                                                          pad);
 310                         if (r->unexpected.data == NULL) {
 311                                 return ndr_pull_error(ndr,
 312                                                       NDR_ERR_ALLOC,
 313                                                       "Failed to allocate a " \
 314                                                       "data blob");
 315                         }
 316                         ndr->offset += pad;
 317                 }
 318
 319
 320                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 321         }
 322         if (ndr_flags & NDR_BUFFERS) {
 323                 NDR_CHECK(ndr_pull_dns_rdata(ndr, NDR_BUFFERS, &r->rdata));
 324         }
 325         ndr->flags = _flags_save_STRUCT;
 326         return NDR_ERR_SUCCESS;
 327 }