LCOV - code coverage report
Current view: top level - source4/nbt_server/wins - winswack.c (source / functions) Hit Total Coverage
Test: coverage report for master 2b515b7d Lines: 136 194 70.1 %
Date: 2024-02-28 12:06:22 Functions: 10 10 100.0 %

          Line data    Source code
       1             : /* 
       2             :    Unix SMB/CIFS implementation.
       3             : 
       4             :    "secure" wins server WACK processing
       5             : 
       6             :    Copyright (C) Andrew Tridgell        2005
       7             :    Copyright (C) Stefan Metzmacher      2005
       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             : #include "includes.h"
      24             : #include "nbt_server/nbt_server.h"
      25             : #include "nbt_server/wins/winsdb.h"
      26             : #include "nbt_server/wins/winsserver.h"
      27             : #include "system/time.h"
      28             : #include "libcli/composite/composite.h"
      29             : #include "param/param.h"
      30             : #include "samba/service_task.h"
      31             : 
      32             : struct wins_challenge_state {
      33             :         struct wins_challenge_io *io;
      34             :         uint32_t current_address;
      35             :         struct nbt_name_query query;
      36             : };
      37             : 
      38          39 : static void wins_challenge_handler(struct nbt_name_request *req)
      39             : {
      40          39 :         struct composite_context *ctx = talloc_get_type(req->async.private_data, struct composite_context);
      41          39 :         struct wins_challenge_state *state = talloc_get_type(ctx->private_data, struct wins_challenge_state);
      42             : 
      43          39 :         ctx->status = nbt_name_query_recv(req, state, &state->query);
      44             : 
      45             :         /* if we timed out then try the next owner address, if any */
      46          39 :         if (NT_STATUS_EQUAL(ctx->status, NT_STATUS_IO_TIMEOUT)) {
      47           0 :                 state->current_address++;
      48           0 :                 if (state->current_address < state->io->in.num_addresses) {
      49           0 :                         struct nbtd_interface *iface;
      50             : 
      51           0 :                         state->query.in.dest_port = state->io->in.nbt_port;
      52           0 :                         state->query.in.dest_addr = state->io->in.addresses[state->current_address];
      53             :                         
      54           0 :                         iface = nbtd_find_request_iface(state->io->in.nbtd_server, state->query.in.dest_addr, true);
      55           0 :                         if (!iface) {
      56           0 :                                 composite_error(ctx, NT_STATUS_INTERNAL_ERROR);
      57           0 :                                 return;
      58             :                         }
      59             : 
      60           0 :                         ZERO_STRUCT(state->query.out);
      61           0 :                         req = nbt_name_query_send(iface->nbtsock, &state->query);
      62           0 :                         composite_continue_nbt(ctx, req, wins_challenge_handler, ctx);
      63           0 :                         return;
      64             :                 }
      65             :         }
      66             : 
      67          39 :         composite_done(ctx);
      68             : }
      69             : 
      70          39 : NTSTATUS wins_challenge_recv(struct composite_context *ctx, TALLOC_CTX *mem_ctx, struct wins_challenge_io *io)
      71             : {
      72          39 :         NTSTATUS status = ctx->status;
      73          39 :         struct wins_challenge_state *state = talloc_get_type(ctx->private_data, struct wins_challenge_state);
      74             : 
      75          39 :         if (NT_STATUS_IS_OK(status)) {
      76          24 :                 io->out.num_addresses        = state->query.out.num_addrs;
      77          24 :                 io->out.addresses    = state->query.out.reply_addrs;
      78          24 :                 talloc_steal(mem_ctx, io->out.addresses);
      79             :         } else {
      80          15 :                 ZERO_STRUCT(io->out);
      81             :         }
      82             : 
      83          39 :         talloc_free(ctx);
      84          39 :         return status;
      85             : }
      86             : 
      87          39 : struct composite_context *wins_challenge_send(TALLOC_CTX *mem_ctx, struct wins_challenge_io *io)
      88             : {
      89           0 :         struct composite_context *result;
      90           0 :         struct wins_challenge_state *state;
      91           0 :         struct nbt_name_request *req;
      92           0 :         struct nbtd_interface *iface;
      93             : 
      94          39 :         result = talloc_zero(mem_ctx, struct composite_context);
      95          39 :         if (result == NULL) return NULL;
      96          39 :         result->state = COMPOSITE_STATE_IN_PROGRESS;
      97          39 :         result->event_ctx = io->in.event_ctx;
      98             : 
      99          39 :         state = talloc_zero(result, struct wins_challenge_state);
     100          39 :         if (state == NULL) goto failed;
     101          39 :         result->private_data = state;
     102             : 
     103             :         /* package up the state variables for this wack request */
     104          39 :         state->io            = io;
     105          39 :         state->current_address       = 0;
     106             : 
     107             :         /* setup a name query to the first address */
     108          39 :         state->query.in.name        = *state->io->in.name;
     109          39 :         state->query.in.dest_port   = state->io->in.nbt_port;
     110          39 :         state->query.in.dest_addr   = state->io->in.addresses[state->current_address];
     111          39 :         state->query.in.broadcast   = false;
     112          39 :         state->query.in.wins_lookup = true;
     113          39 :         state->query.in.timeout     = 1;
     114          39 :         state->query.in.retries     = 2;
     115          39 :         ZERO_STRUCT(state->query.out);
     116             : 
     117          39 :         iface = nbtd_find_request_iface(state->io->in.nbtd_server, state->query.in.dest_addr, true);
     118          39 :         if (!iface) {
     119           0 :                 goto failed;
     120             :         }
     121             : 
     122          39 :         req = nbt_name_query_send(iface->nbtsock, &state->query);
     123          39 :         if (req == NULL) goto failed;
     124             : 
     125          39 :         req->async.fn = wins_challenge_handler;
     126          39 :         req->async.private_data = result;
     127             : 
     128          39 :         return result;
     129           0 : failed:
     130           0 :         talloc_free(result);
     131           0 :         return NULL;
     132             : }
     133             : 
     134             : struct wins_release_demand_io {
     135             :         struct {
     136             :                 struct nbtd_server *nbtd_server;
     137             :                 struct tevent_context *event_ctx;
     138             :                 struct nbt_name *name;
     139             :                 uint16_t nb_flags;
     140             :                 uint32_t num_addresses;
     141             :                 const char **addresses;
     142             :         } in;
     143             : };
     144             : 
     145             : struct wins_release_demand_state {
     146             :         struct wins_release_demand_io *io;
     147             :         uint32_t current_address;
     148             :         uint32_t addresses_left;
     149             :         struct nbt_name_release release;
     150             : };
     151             : 
     152          10 : static void wins_release_demand_handler(struct nbt_name_request *req)
     153             : {
     154          10 :         struct composite_context *ctx = talloc_get_type(req->async.private_data, struct composite_context);
     155          10 :         struct wins_release_demand_state *state = talloc_get_type(ctx->private_data, struct wins_release_demand_state);
     156             : 
     157          10 :         ctx->status = nbt_name_release_recv(req, state, &state->release);
     158             : 
     159             :         /* if we timed out then try the next owner address, if any */
     160          10 :         if (NT_STATUS_EQUAL(ctx->status, NT_STATUS_IO_TIMEOUT)) {
     161           0 :                 state->current_address++;
     162           0 :                 state->addresses_left--;
     163           0 :                 if (state->current_address < state->io->in.num_addresses) {
     164           0 :                         struct nbtd_interface *iface;
     165             : 
     166           0 :                         state->release.in.dest_port = lpcfg_nbt_port(state->io->in.nbtd_server->task->lp_ctx);
     167           0 :                         state->release.in.dest_addr = state->io->in.addresses[state->current_address];
     168           0 :                         state->release.in.address   = state->release.in.dest_addr;
     169           0 :                         state->release.in.timeout   = (state->addresses_left > 1 ? 2 : 1);
     170           0 :                         state->release.in.retries   = (state->addresses_left > 1 ? 0 : 2);
     171             : 
     172           0 :                         iface = nbtd_find_request_iface(state->io->in.nbtd_server, state->release.in.dest_addr, true);
     173           0 :                         if (!iface) {
     174           0 :                                 composite_error(ctx, NT_STATUS_INTERNAL_ERROR);
     175           0 :                                 return;
     176             :                         }
     177             : 
     178           0 :                         ZERO_STRUCT(state->release.out);
     179           0 :                         req = nbt_name_release_send(iface->nbtsock, &state->release);
     180           0 :                         composite_continue_nbt(ctx, req, wins_release_demand_handler, ctx);
     181           0 :                         return;
     182             :                 }
     183             :         }
     184             : 
     185          10 :         composite_done(ctx);
     186             : }
     187             : 
     188          10 : static NTSTATUS wins_release_demand_recv(struct composite_context *ctx,
     189             :                                          TALLOC_CTX *mem_ctx,
     190             :                                          struct wins_release_demand_io *io)
     191             : {
     192          10 :         NTSTATUS status = ctx->status;
     193          10 :         talloc_free(ctx);
     194          10 :         return status;
     195             : }
     196             : 
     197          10 : static struct composite_context *wins_release_demand_send(TALLOC_CTX *mem_ctx, struct wins_release_demand_io *io)
     198             : {
     199           0 :         struct composite_context *result;
     200           0 :         struct wins_release_demand_state *state;
     201           0 :         struct nbt_name_request *req;
     202           0 :         struct nbtd_interface *iface;
     203             : 
     204          10 :         result = talloc_zero(mem_ctx, struct composite_context);
     205          10 :         if (result == NULL) return NULL;
     206          10 :         result->state = COMPOSITE_STATE_IN_PROGRESS;
     207          10 :         result->event_ctx = io->in.event_ctx;
     208             : 
     209          10 :         state = talloc_zero(result, struct wins_release_demand_state);
     210          10 :         if (state == NULL) goto failed;
     211          10 :         result->private_data = state;
     212             : 
     213             :         /* package up the state variables for this wack request */
     214          10 :         state->io            = io;
     215          10 :         state->current_address       = 0;
     216          10 :         state->addresses_left        = state->io->in.num_addresses;
     217             : 
     218             :         /* 
     219             :          * setup a name query to the first address
     220             :          * - if we have more than one address try the first
     221             :          *   with 2 secs timeout and no retry
     222             :          * - otherwise use 1 sec timeout (w2k3 uses 0.5 sec here)
     223             :          *   with 2 retries
     224             :          */
     225          10 :         state->release.in.name        = *state->io->in.name;
     226          10 :         state->release.in.dest_port   = lpcfg_nbt_port(state->io->in.nbtd_server->task->lp_ctx);
     227          10 :         state->release.in.dest_addr   = state->io->in.addresses[state->current_address];
     228          10 :         state->release.in.address     = state->release.in.dest_addr;
     229          10 :         state->release.in.broadcast   = false;
     230          10 :         state->release.in.timeout     = (state->addresses_left > 1 ? 2 : 1);
     231          10 :         state->release.in.retries     = (state->addresses_left > 1 ? 0 : 2);
     232          10 :         ZERO_STRUCT(state->release.out);
     233             : 
     234          10 :         iface = nbtd_find_request_iface(state->io->in.nbtd_server, state->release.in.dest_addr, true);
     235          10 :         if (!iface) {
     236           0 :                 goto failed;
     237             :         }
     238             : 
     239          10 :         req = nbt_name_release_send(iface->nbtsock, &state->release);
     240          10 :         if (req == NULL) goto failed;
     241             : 
     242          10 :         req->async.fn = wins_release_demand_handler;
     243          10 :         req->async.private_data = result;
     244             : 
     245          10 :         return result;
     246           0 : failed:
     247           0 :         talloc_free(result);
     248           0 :         return NULL;
     249             : }
     250             : 
     251             : /*
     252             :   wrepl_server needs to be able to do a name query request, but some windows
     253             :   servers always send the reply to port 137, regardless of the request
     254             :   port. To cope with this we use a irpc request to the NBT server
     255             :   which has port 137 open, and thus can receive the replies
     256             : */
     257             : struct proxy_wins_challenge_state {
     258             :         struct irpc_message *msg;
     259             :         struct nbtd_proxy_wins_challenge *req;
     260             :         struct wins_challenge_io io;
     261             :         struct composite_context *c_req;
     262             : };
     263             : 
     264          21 : static void proxy_wins_challenge_handler(struct composite_context *c_req)
     265             : {
     266           0 :         NTSTATUS status;
     267           0 :         uint32_t i;
     268          21 :         struct proxy_wins_challenge_state *s = talloc_get_type(c_req->async.private_data,
     269             :                                                                struct proxy_wins_challenge_state);
     270             : 
     271          21 :         status = wins_challenge_recv(s->c_req, s, &s->io);
     272          21 :         if (!NT_STATUS_IS_OK(status)) {
     273           5 :                 ZERO_STRUCT(s->req->out);
     274           5 :                 irpc_send_reply(s->msg, status);
     275           5 :                 return;
     276             :         }
     277             : 
     278          16 :         s->req->out.num_addrs     = s->io.out.num_addresses;           
     279             :         /* TODO: fix pidl to handle inline ipv4address arrays */
     280          16 :         s->req->out.addrs = talloc_array(s->msg, struct nbtd_proxy_wins_addr,
     281             :                                                s->io.out.num_addresses);
     282          16 :         if (!s->req->out.addrs) {
     283           0 :                 ZERO_STRUCT(s->req->out);
     284           0 :                 irpc_send_reply(s->msg, NT_STATUS_NO_MEMORY);
     285           0 :                 return;
     286             :         }
     287          54 :         for (i=0; i < s->io.out.num_addresses; i++) {
     288          38 :                 s->req->out.addrs[i].addr = talloc_steal(s->req->out.addrs, s->io.out.addresses[i]);
     289             :         }
     290             : 
     291          16 :         irpc_send_reply(s->msg, status);
     292             : }
     293             : 
     294          21 : NTSTATUS nbtd_proxy_wins_challenge(struct irpc_message *msg, 
     295             :                                    struct nbtd_proxy_wins_challenge *req)
     296             : {
     297           0 :         struct nbtd_server *nbtd_server =
     298          21 :                 talloc_get_type(msg->private_data, struct nbtd_server);
     299           0 :         struct proxy_wins_challenge_state *s;
     300           0 :         uint32_t i;
     301             : 
     302          21 :         s = talloc(msg, struct proxy_wins_challenge_state);
     303          21 :         NT_STATUS_HAVE_NO_MEMORY(s);
     304             : 
     305          21 :         s->msg = msg;
     306          21 :         s->req = req;
     307             : 
     308          21 :         s->io.in.nbtd_server = nbtd_server;
     309          21 :         s->io.in.nbt_port       = lpcfg_nbt_port(nbtd_server->task->lp_ctx);
     310          21 :         s->io.in.event_ctx   = nbtd_server->task->event_ctx;
     311          21 :         s->io.in.name                = &req->in.name;
     312          21 :         s->io.in.num_addresses       = req->in.num_addrs;
     313          21 :         s->io.in.addresses   = talloc_array(s, const char *, req->in.num_addrs);
     314          21 :         NT_STATUS_HAVE_NO_MEMORY(s->io.in.addresses);
     315             :         /* TODO: fix pidl to handle inline ipv4address arrays */
     316          48 :         for (i=0; i < req->in.num_addrs; i++) {
     317          27 :                 s->io.in.addresses[i]        = talloc_steal(s->io.in.addresses, req->in.addrs[i].addr);
     318             :         }
     319             : 
     320          21 :         s->c_req = wins_challenge_send(s, &s->io);
     321          21 :         NT_STATUS_HAVE_NO_MEMORY(s->c_req);
     322             : 
     323          21 :         s->c_req->async.fn                = proxy_wins_challenge_handler;
     324          21 :         s->c_req->async.private_data      = s;
     325             : 
     326          21 :         msg->defer_reply = true;
     327          21 :         return NT_STATUS_OK;
     328             : }
     329             : 
     330             : /*
     331             :   wrepl_server needs to be able to do a name release demands, but some windows
     332             :   servers always send the reply to port 137, regardless of the request
     333             :   port. To cope with this we use a irpc request to the NBT server
     334             :   which has port 137 open, and thus can receive the replies
     335             : */
     336             : struct proxy_wins_release_demand_state {
     337             :         struct irpc_message *msg;
     338             :         struct nbtd_proxy_wins_release_demand *req;
     339             :         struct wins_release_demand_io io;
     340             :         struct composite_context *c_req;
     341             : };
     342             : 
     343          10 : static void proxy_wins_release_demand_handler(struct composite_context *c_req)
     344             : {
     345           0 :         NTSTATUS status;
     346          10 :         struct proxy_wins_release_demand_state *s = talloc_get_type(c_req->async.private_data,
     347             :                                                                struct proxy_wins_release_demand_state);
     348             : 
     349          10 :         status = wins_release_demand_recv(s->c_req, s, &s->io);
     350             : 
     351          10 :         irpc_send_reply(s->msg, status);
     352          10 : }
     353             : 
     354          10 : NTSTATUS nbtd_proxy_wins_release_demand(struct irpc_message *msg, 
     355             :                                    struct nbtd_proxy_wins_release_demand *req)
     356             : {
     357           0 :         struct nbtd_server *nbtd_server =
     358          10 :                 talloc_get_type(msg->private_data, struct nbtd_server);
     359           0 :         struct proxy_wins_release_demand_state *s;
     360           0 :         uint32_t i;
     361             : 
     362          10 :         s = talloc(msg, struct proxy_wins_release_demand_state);
     363          10 :         NT_STATUS_HAVE_NO_MEMORY(s);
     364             : 
     365          10 :         s->msg = msg;
     366          10 :         s->req = req;
     367             : 
     368          10 :         s->io.in.nbtd_server = nbtd_server;
     369          10 :         s->io.in.event_ctx   = nbtd_server->task->event_ctx;
     370          10 :         s->io.in.name                = &req->in.name;
     371          10 :         s->io.in.num_addresses       = req->in.num_addrs;
     372          10 :         s->io.in.addresses   = talloc_array(s, const char *, req->in.num_addrs);
     373          10 :         NT_STATUS_HAVE_NO_MEMORY(s->io.in.addresses);
     374             :         /* TODO: fix pidl to handle inline ipv4address arrays */
     375          20 :         for (i=0; i < req->in.num_addrs; i++) {
     376          10 :                 s->io.in.addresses[i]        = talloc_steal(s->io.in.addresses, req->in.addrs[i].addr);
     377             :         }
     378             : 
     379          10 :         s->c_req = wins_release_demand_send(s, &s->io);
     380          10 :         NT_STATUS_HAVE_NO_MEMORY(s->c_req);
     381             : 
     382          10 :         s->c_req->async.fn                = proxy_wins_release_demand_handler;
     383          10 :         s->c_req->async.private_data      = s;
     384             : 
     385          10 :         msg->defer_reply = true;
     386          10 :         return NT_STATUS_OK;
     387             : }

Generated by: LCOV version 1.14