source4/libcli/resolve/dns_ex.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    async getaddrinfo()/dns_lookup() name resolution module
   5
   6    Copyright (C) Andrew Tridgell 2005
   7    Copyright (C) Stefan Metzmacher 2008
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  21 */
  22
  23 /*
  24   this module uses a fork() per getaddrinfo() or dns_looup() call.
  25   At first that might seem crazy, but it is actually very fast,
  26   and solves many of the tricky problems of keeping a child
  27   hanging around in a librar (like what happens when the parent forks).
  28   We use a talloc destructor to ensure that the child is cleaned up
  29   when we have finished with this name resolution.
  30 */
  31
  32 #include "includes.h"
  33 #include "lib/events/events.h"
  34 #include "system/network.h"
  35 #include "system/filesys.h"
  36 #include "lib/socket/socket.h"
  37 #include "libcli/composite/composite.h"
  38 #include "librpc/gen_ndr/ndr_nbt.h"
  39 #include "libcli/resolve/resolve.h"
  40 #include "heimdal/lib/roken/resolve.h"
  41
  42 struct dns_ex_state {
  43         bool do_fallback;
  44         uint32_t flags;
  45         uint16_t port;
  46         struct nbt_name name;
  47         struct socket_address **addrs;
  48         char **names;
  49         pid_t child;
  50         int child_fd;
  51         struct tevent_fd *fde;
  52         struct tevent_context *event_ctx;
  53 };
  54
  55 /*
  56   kill off a wayward child if needed. This allows us to stop an async
  57   name resolution without leaving a potentially blocking call running
  58   in a child
  59 */
  60 static int dns_ex_destructor(struct dns_ex_state *state)
  61 {
  62         int status;
  63
  64         kill(state->child, SIGTERM);
  65         close(state->child_fd);
  66         if (waitpid(state->child, &status, WNOHANG) == 0) {
  67                 kill(state->child, SIGKILL);
  68                 waitpid(state->child, &status, 0);
  69         }
  70
  71         return 0;
  72 }
  73
  74 /*
  75   the blocking child
  76 */
  77 static void run_child_dns_lookup(struct dns_ex_state *state, int fd)
  78 {
  79         struct dns_reply *reply;
  80         struct resource_record *rr;
  81         uint32_t count = 0;
  82         uint32_t srv_valid = 0;
  83         struct resource_record **srv_rr;
  84         uint32_t addrs_valid = 0;
  85         struct resource_record **addrs_rr;
  86         char *addrs;
  87         bool first;
  88         uint32_t i;
  89         bool do_srv = (state->flags & RESOLVE_NAME_FLAG_DNS_SRV);
  90
  91         /* this is the blocking call we are going to lots of trouble
  92            to avoid in the parent */
  93         reply = dns_lookup(state->name.name, do_srv?"SRV":"A");
  94         if (!reply) {
  95                 goto done;
  96         }
  97
  98         if (do_srv) {
  99                 dns_srv_order(reply);
 100         }
 101
 102         /* Loop over all returned records and pick the "srv" records */
 103         for (rr=reply->head; rr; rr=rr->next) {
 104                 /* we are only interested in the IN class */
 105                 if (rr->class != C_IN) {
 106                         continue;
 107                 }
 108
 109                 if (do_srv) {
 110                         /* we are only interested in SRV records */
 111                         if (rr->type != T_SRV) {
 112                                 continue;
 113                         }
 114
 115                         /* verify we actually have a SRV record here */
 116                         if (!rr->u.srv) {
 117                                 continue;
 118                         }
 119
 120                         /* Verify we got a port */
 121                         if (rr->u.srv->port == 0) {
 122                                 continue;
 123                         }
 124                 } else {
 125                         /* we are only interested in A records */
 126                         /* TODO: add AAAA support */
 127                         if (rr->type != T_A) {
 128                                 continue;
 129                         }
 130
 131                         /* verify we actually have a A record here */
 132                         if (!rr->u.a) {
 133                                 continue;
 134                         }
 135                 }
 136                 count++;
 137         }
 138
 139         if (count == 0) {
 140                 goto done;
 141         }
 142
 143         srv_rr = talloc_zero_array(state,
 144                                    struct resource_record *,
 145                                    count);
 146         if (!srv_rr) {
 147                 goto done;
 148         }
 149
 150         addrs_rr = talloc_zero_array(state,
 151                                      struct resource_record *,
 152                                      count);
 153         if (!addrs_rr) {
 154                 goto done;
 155         }
 156
 157         /* Loop over all returned records and pick the records */
 158         for (rr=reply->head;rr;rr=rr->next) {
 159                 /* we are only interested in the IN class */
 160                 if (rr->class != C_IN) {
 161                         continue;
 162                 }
 163
 164                 if (do_srv) {
 165                         /* we are only interested in SRV records */
 166                         if (rr->type != T_SRV) {
 167                                 continue;
 168                         }
 169
 170                         /* verify we actually have a srv record here */
 171                         if (!rr->u.srv) {
 172                                 continue;
 173                         }
 174
 175                         /* Verify we got a port */
 176                         if (rr->u.srv->port == 0) {
 177                                 continue;
 178                         }
 179
 180                         srv_rr[srv_valid] = rr;
 181                         srv_valid++;
 182                 } else {
 183                         /* we are only interested in A records */
 184                         /* TODO: add AAAA support */
 185                         if (rr->type != T_A) {
 186                                 continue;
 187                         }
 188
 189                         /* verify we actually have a A record here */
 190                         if (!rr->u.a) {
 191                                 continue;
 192                         }
 193
 194                         addrs_rr[addrs_valid] = rr;
 195                         addrs_valid++;
 196                 }
 197         }
 198
 199         for (i=0; i < srv_valid; i++) {
 200                 for (rr=reply->head;rr;rr=rr->next) {
 201
 202                         if (rr->class != C_IN) {
 203                                 continue;
 204                         }
 205
 206                         /* we are only interested in SRV records */
 207                         if (rr->type != T_A) {
 208                                 continue;
 209                         }
 210
 211                         /* verify we actually have a srv record here */
 212                         if (strcmp(&srv_rr[i]->u.srv->target[0], rr->domain) != 0) {
 213                                 continue;
 214                         }
 215
 216                         addrs_rr[i] = rr;
 217                         addrs_valid++;
 218                         break;
 219                 }
 220         }
 221
 222         if (addrs_valid == 0) {
 223                 goto done;
 224         }
 225
 226         addrs = talloc_strdup(state, "");
 227         if (!addrs) {
 228                 goto done;
 229         }
 230         first = true;
 231         for (i=0; i < count; i++) {
 232                 uint16_t port;
 233                 if (!addrs_rr[i]) {
 234                         continue;
 235                 }
 236
 237                 if (srv_rr[i] &&
 238                     (state->flags & RESOLVE_NAME_FLAG_OVERWRITE_PORT)) {
 239                         port = srv_rr[i]->u.srv->port;
 240                 } else {
 241                         port = state->port;
 242                 }
 243
 244                 addrs = talloc_asprintf_append_buffer(addrs, "%s%s:%u/%s",
 245                                                       first?"":",",
 246                                                       inet_ntoa(*addrs_rr[i]->u.a),
 247                                                       port,
 248                                                       addrs_rr[i]->domain);
 249                 if (!addrs) {
 250                         goto done;
 251                 }
 252                 first = false;
 253         }
 254
 255         if (addrs) {
 256                 write(fd, addrs, talloc_get_size(addrs));
 257         }
 258
 259 done:
 260         close(fd);
 261 }
 262
 263 /*
 264   the blocking child
 265 */
 266 static void run_child_getaddrinfo(struct dns_ex_state *state, int fd)
 267 {
 268         int ret;
 269         struct addrinfo hints;
 270         struct addrinfo *res;
 271         struct addrinfo *res_list = NULL;
 272         char *addrs;
 273         bool first;
 274
 275         ZERO_STRUCT(hints);
 276         hints.ai_socktype = SOCK_STREAM;
 277         hints.ai_family = AF_INET;/* TODO: add AF_INET6 support */
 278         hints.ai_flags = AI_ADDRCONFIG | AI_NUMERICSERV;
 279
 280         ret = getaddrinfo(state->name.name, "0", &hints, &res_list);
 281 #if defined(EAI_NODATA) && (EAI_NODATA != EAI_NONAME)
 282         if (ret == EAI_NODATA && state->do_fallback) {
 283 #else
 284         if (ret == EAI_NONAME && state->do_fallback) {
 285 #endif
 286                 /* getaddrinfo() doesn't handle CNAME records */
 287                 run_child_dns_lookup(state, fd);
 288                 return;
 289         }
 290         if (ret != 0) {
 291                 goto done;
 292         }
 293
 294         addrs = talloc_strdup(state, "");
 295         if (!addrs) {
 296                 goto done;
 297         }
 298         first = true;
 299         for (res = res_list; res; res = res->ai_next) {
 300                 struct sockaddr_in *in;
 301
 302                 if (res->ai_family != AF_INET) {
 303                         continue;
 304                 }
 305                 in = (struct sockaddr_in *)res->ai_addr;
 306
 307                 addrs = talloc_asprintf_append_buffer(addrs, "%s%s:%u/%s",
 308                                                       first?"":",",
 309                                                       inet_ntoa(in->sin_addr),
 310                                                       state->port,
 311                                                       state->name.name);
 312                 if (!addrs) {
 313                         goto done;
 314                 }
 315                 first = false;
 316         }
 317
 318         if (addrs) {
 319                 write(fd, addrs, talloc_get_size(addrs));
 320         }
 321 done:
 322         if (res_list) {
 323                 freeaddrinfo(res_list);
 324         }
 325         close(fd);
 326 }
 327
 328 /*
 329   handle a read event on the pipe
 330 */
 331 static void pipe_handler(struct tevent_context *ev, struct tevent_fd *fde,
 332                          uint16_t flags, void *private_data)
 333 {
 334         struct composite_context *c = talloc_get_type(private_data, struct composite_context);
 335         struct dns_ex_state *state = talloc_get_type(c->private_data,
 336                                      struct dns_ex_state);
 337         char *address;
 338         uint32_t num_addrs, i;
 339         char **addrs;
 340         int ret;
 341         int status;
 342         int value = 0;
 343
 344         /* if we get any event from the child then we know that we
 345            won't need to kill it off */
 346         talloc_set_destructor(state, NULL);
 347
 348         if (ioctl(state->child_fd, FIONREAD, &value) != 0) {
 349                 value = 8192;
 350         }
 351
 352         address = talloc_array(state, char, value+1);
 353         if (address) {
 354                 /* yes, we don't care about EAGAIN or other niceities
 355                    here. They just can't happen with this parent/child
 356                    relationship, and even if they did then giving an error is
 357                    the right thing to do */
 358                 ret = read(state->child_fd, address, value);
 359         } else {
 360                 ret = -1;
 361         }
 362         close(state->child_fd);
 363         if (waitpid(state->child, &status, WNOHANG) == 0) {
 364                 kill(state->child, SIGKILL);
 365                 waitpid(state->child, &status, 0);
 366         }
 367
 368         if (ret <= 0) {
 369                 composite_error(c, NT_STATUS_OBJECT_NAME_NOT_FOUND);
 370                 return;
 371         }
 372
 373         /* enusre the address looks good */
 374         address[ret] = 0;
 375
 376         addrs = str_list_make(state, address, ",");
 377         if (composite_nomem(addrs, c)) return;
 378
 379         num_addrs = str_list_length((const char * const *)addrs);
 380
 381         state->addrs = talloc_array(state, struct socket_address *,
 382                                     num_addrs+1);
 383         if (composite_nomem(state->addrs, c)) return;
 384
 385         state->names = talloc_array(state, char *, num_addrs+1);
 386         if (composite_nomem(state->names, c)) return;
 387
 388         for (i=0; i < num_addrs; i++) {
 389                 uint32_t port = 0;
 390                 char *p = strrchr(addrs[i], ':');
 391                 char *n;
 392
 393                 if (!p) {
 394                         composite_error(c, NT_STATUS_OBJECT_NAME_NOT_FOUND);
 395                         return;
 396                 }
 397
 398                 *p = '\0';
 399                 p++;
 400
 401                 n = strrchr(p, '/');
 402                 if (!n) {
 403                         composite_error(c, NT_STATUS_OBJECT_NAME_NOT_FOUND);
 404                         return;
 405                 }
 406
 407                 *n = '\0';
 408                 n++;
 409
 410                 if (strcmp(addrs[i], "0.0.0.0") == 0 ||
 411                     inet_addr(addrs[i]) == INADDR_NONE) {
 412                         composite_error(c, NT_STATUS_OBJECT_NAME_NOT_FOUND);
 413                         return;
 414                 }
 415                 port = strtoul(p, NULL, 10);
 416                 if (port > UINT16_MAX) {
 417                         composite_error(c, NT_STATUS_OBJECT_NAME_NOT_FOUND);
 418                         return;
 419                 }
 420                 state->addrs[i] = socket_address_from_strings(state->addrs,
 421                                                               "ipv4",
 422                                                               addrs[i],
 423                                                               port);
 424                 if (composite_nomem(state->addrs[i], c)) return;
 425
 426                 state->names[i] = talloc_strdup(state->names, n);
 427                 if (composite_nomem(state->names[i], c)) return;
 428         }
 429         state->addrs[i] = NULL;
 430         state->names[i] = NULL;
 431
 432         composite_done(c);
 433 }
 434
 435 /*
 436   getaddrinfo() or dns_lookup() name resolution method - async send
 437  */
 438 struct composite_context *resolve_name_dns_ex_send(TALLOC_CTX *mem_ctx,
 439                                                    struct tevent_context *event_ctx,
 440                                                    void *privdata,
 441                                                    uint32_t flags,
 442                                                    uint16_t port,
 443                                                    struct nbt_name *name,
 444                                                    bool do_fallback)
 445 {
 446         struct composite_context *c;
 447         struct dns_ex_state *state;
 448         int fd[2] = { -1, -1 };
 449         int ret;
 450
 451         c = composite_create(mem_ctx, event_ctx);
 452         if (c == NULL) return NULL;
 453
 454         if (flags & RESOLVE_NAME_FLAG_FORCE_NBT) {
 455                 composite_error(c, NT_STATUS_OBJECT_NAME_NOT_FOUND);
 456                 return c;
 457         }
 458
 459         state = talloc_zero(c, struct dns_ex_state);
 460         if (composite_nomem(state, c)) return c;
 461         c->private_data = state;
 462
 463         c->status = nbt_name_dup(state, name, &state->name);
 464         if (!composite_is_ok(c)) return c;
 465
 466         /* setup a pipe to chat to our child */
 467         ret = pipe(fd);
 468         if (ret == -1) {
 469                 composite_error(c, map_nt_error_from_unix(errno));
 470                 return c;
 471         }
 472
 473         state->do_fallback = do_fallback;
 474         state->flags = flags;
 475         state->port = port;
 476
 477         state->child_fd = fd[0];
 478         state->event_ctx = c->event_ctx;
 479
 480         /* we need to put the child in our event context so
 481            we know when the dns_lookup() has finished */
 482         state->fde = event_add_fd(c->event_ctx, c, state->child_fd, EVENT_FD_READ,
 483                                   pipe_handler, c);
 484         if (composite_nomem(state->fde, c)) {
 485                 close(fd[0]);
 486                 close(fd[1]);
 487                 return c;
 488         }
 489
 490         state->child = fork();
 491         if (state->child == (pid_t)-1) {
 492                 composite_error(c, map_nt_error_from_unix(errno));
 493                 return c;
 494         }
 495
 496         if (state->child == 0) {
 497                 close(fd[0]);
 498                 if (state->flags & RESOLVE_NAME_FLAG_FORCE_DNS) {
 499                         run_child_dns_lookup(state, fd[1]);
 500                 } else {
 501                         run_child_getaddrinfo(state, fd[1]);
 502                 }
 503                 _exit(0);
 504         }
 505         close(fd[1]);
 506
 507         /* cleanup wayward children */
 508         talloc_set_destructor(state, dns_ex_destructor);
 509
 510         return c;
 511 }
 512
 513 /*
 514   getaddrinfo() or dns_lookup() name resolution method - recv side
 515 */
 516 NTSTATUS resolve_name_dns_ex_recv(struct composite_context *c,
 517                                   TALLOC_CTX *mem_ctx,
 518                                   struct socket_address ***addrs,
 519                                   char ***names)
 520 {
 521         NTSTATUS status;
 522
 523         status = composite_wait(c);
 524
 525         if (NT_STATUS_IS_OK(status)) {
 526                 struct dns_ex_state *state = talloc_get_type(c->private_data,
 527                                              struct dns_ex_state);
 528                 *addrs = talloc_steal(mem_ctx, state->addrs);
 529                 if (names) {
 530                         *names = talloc_steal(mem_ctx, state->names);
 531                 }
 532         }
 533
 534         talloc_free(c);
 535         return status;
 536 }