Line data    Source code

       1             : /* 
       2             :    Unix SMB/CIFS implementation.
       3             : 
       4             :    wins server dns proxy
       5             : 
       6             :    Copyright (C) Stefan Metzmacher      2005
       7             :       
       8             :    This program is free software; you can redistribute it and/or modify
       9             :    it under the terms of the GNU General Public License as published by
      10             :    the Free Software Foundation; either version 3 of the License, or
      11             :    (at your option) any later version.
      12             :    
      13             :    This program is distributed in the hope that it will be useful,
      14             :    but WITHOUT ANY WARRANTY; without even the implied warranty of
      15             :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      16             :    GNU General Public License for more details.
      17             :    
      18             :    You should have received a copy of the GNU General Public License
      19             :    along with this program.  If not, see <http://www.gnu.org/licenses/>.
      20             : */
      21             : 
      22             : #include "includes.h"
      23             : #include "nbt_server/nbt_server.h"
      24             : #include "nbt_server/wins/winsdb.h"
      25             : #include "nbt_server/wins/winsserver.h"
      26             : #include "system/time.h"
      27             : #include "libcli/composite/composite.h"
      28             : #include "samba/service_task.h"
      29             : #include "libcli/resolve/resolve.h"
      30             : #include "lib/socket/socket.h"
      31             : 
      32             : struct wins_dns_proxy_state {
      33             :         struct nbt_name_socket *nbtsock;
      34             :         struct nbt_name_packet *packet;
      35             :         struct socket_address *src;
      36             : };
      37             : 
      38          12 : static void nbtd_wins_dns_proxy_handler(struct composite_context *creq)
      39             : {
      40           0 :         NTSTATUS status;
      41          12 :         struct wins_dns_proxy_state *s = talloc_get_type(creq->async.private_data,
      42             :                                                          struct wins_dns_proxy_state);
      43          12 :         struct nbt_name *name = &s->packet->questions[0].name;
      44           0 :         const char *address;
      45           0 :         const char **addresses;
      46          12 :         uint16_t nb_flags = 0; /* TODO: ... */
      47             : 
      48          12 :         status = resolve_name_recv(creq, s->packet, &address);
      49          12 :         if (!NT_STATUS_IS_OK(status)) {
      50          12 :                 goto notfound;
      51             :         }
      52             : 
      53           0 :         addresses = str_list_add(NULL, address);
      54           0 :         talloc_steal(s->packet, addresses);
      55           0 :         if (!addresses) goto notfound;
      56             : 
      57           0 :         nbtd_name_query_reply(s->nbtsock, s->packet, s->src, name, 
      58             :                               0, nb_flags, addresses);
      59           0 :         return;
      60          12 : notfound:
      61          12 :         nbtd_negative_name_query_reply(s->nbtsock, s->packet, s->src);
      62             : }
      63             : 
      64             : /*
      65             :   dns proxy query a name
      66             : */
      67          12 : void nbtd_wins_dns_proxy_query(struct nbt_name_socket *nbtsock, 
      68             :                                struct nbt_name_packet *packet, 
      69             :                                struct socket_address *src)
      70             : {
      71          12 :         struct nbt_name *name = &packet->questions[0].name;
      72          12 :         struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private_data,
      73             :                                                        struct nbtd_interface);
      74           0 :         struct wins_dns_proxy_state *s;
      75           0 :         struct composite_context *creq;
      76           0 :         struct resolve_context *resolve_ctx;
      77             : 
      78          12 :         s = talloc(nbtsock, struct wins_dns_proxy_state);
      79          12 :         if (!s) goto failed;
      80          12 :         s->nbtsock   = nbtsock;
      81          12 :         s->packet    = talloc_steal(s, packet);
      82          12 :         s->src               = socket_address_copy(s, src);
      83          12 :         if (s->src == NULL) {
      84           0 :                 goto failed;
      85             :         }
      86             : 
      87          12 :         resolve_ctx = resolve_context_init(s);
      88          12 :         if (resolve_ctx == NULL) goto failed;
      89          12 :         resolve_context_add_host_method(resolve_ctx);
      90             : 
      91          12 :         creq = resolve_name_send(resolve_ctx, s, name, iface->nbtsrv->task->event_ctx);
      92          12 :         if (!creq) goto failed;
      93             : 
      94          12 :         creq->async.fn               = nbtd_wins_dns_proxy_handler;
      95          12 :         creq->async.private_data= s;
      96          12 :         return;
      97           0 : failed:
      98           0 :         nbtd_negative_name_query_reply(nbtsock, packet, src);
      99             : }