source4/nbt_server/register.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    register our names
   5
   6    Copyright (C) Andrew Tridgell        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 "lib/events/events.h"
  24 #include "../lib/util/dlinklist.h"
  25 #include "nbt_server/nbt_server.h"
  26 #include "samba/service_task.h"
  27 #include "libcli/composite/composite.h"
  28 #include "librpc/gen_ndr/ndr_samr.h"
  29 #include "nbt_server/wins/winsserver.h"
  30 #include "librpc/gen_ndr/ndr_nbt.h"
  31 #include "dsdb/samdb/samdb.h"
  32 #include "param/param.h"
  33 #include "libds/common/roles.h"
  34
  35 static void nbtd_start_refresh_timer(struct nbtd_iface_name *iname);
  36
  37 /*
  38   a name refresh request has completed
  39 */
  40 static void refresh_completion_handler(struct nbt_name_request *req)
  41 {
  42         struct nbtd_iface_name *iname = talloc_get_type(req->async.private_data,
  43                                                         struct nbtd_iface_name);
  44         NTSTATUS status;
  45         struct nbt_name_refresh io;
  46         TALLOC_CTX *tmp_ctx = talloc_new(iname);
  47
  48         status = nbt_name_refresh_recv(req, tmp_ctx, &io);
  49         if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
  50                 DEBUG(4,("Refreshed name %s with %s on interface %s\n",
  51                          nbt_name_string(tmp_ctx, &iname->name),
  52                          iname->iface->ip_address, iname->iface->bcast_address));
  53                 iname->registration_time = timeval_current();
  54                 nbtd_start_refresh_timer(iname);
  55                 talloc_free(tmp_ctx);
  56                 return;
  57         }
  58
  59         iname->nb_flags |= NBT_NM_CONFLICT;
  60         iname->nb_flags &= ~NBT_NM_ACTIVE;
  61
  62         if (NT_STATUS_IS_OK(status)) {
  63                 DEBUG(1,("Name conflict from %s refreshing name %s with %s on interface %s - %s\n",
  64                          io.out.reply_addr, nbt_name_string(tmp_ctx, &iname->name),
  65                          iname->iface->ip_address, iname->iface->bcast_address,
  66                          nt_errstr(nbt_rcode_to_ntstatus(io.out.rcode))));
  67         } else {
  68                 DEBUG(1,("Error refreshing name %s with %s on interface %s - %s\n",
  69                          nbt_name_string(tmp_ctx, &iname->name),
  70                          iname->iface->ip_address, iname->iface->bcast_address,
  71                          nt_errstr(status)));
  72         }
  73
  74         talloc_free(tmp_ctx);
  75 }
  76
  77
  78 /*
  79   handle name refresh timer events
  80 */
  81 static void name_refresh_handler(struct tevent_context *ev, struct tevent_timer *te,
  82                                  struct timeval t, void *private_data)
  83 {
  84         struct nbtd_iface_name *iname = talloc_get_type(private_data, struct nbtd_iface_name);
  85         struct nbtd_interface *iface = iname->iface;
  86         struct nbt_name_register io;
  87         struct nbt_name_request *req;
  88         struct nbtd_server *nbtsrv = iface->nbtsrv;
  89
  90         /* setup a single name register request. Notice that we don't
  91            use a name refresh request, as Windows and Samba3 do not
  92            defend against broadcast name refresh packets. So for this
  93            to be of any use at all, we need to refresh using name
  94            registration packets */
  95         io.in.name            = iname->name;
  96         io.in.dest_addr       = iface->bcast_address;
  97         io.in.dest_port       = lpcfg_nbt_port(iface->nbtsrv->task->lp_ctx);
  98         io.in.address         = iface->ip_address;
  99         io.in.nb_flags        = iname->nb_flags;
 100         io.in.ttl             = iname->ttl;
 101         io.in.register_demand = false;
 102         io.in.broadcast       = true;
 103         io.in.multi_homed     = false;
 104         io.in.timeout         = 3;
 105         io.in.retries         = 0;
 106
 107         nbtsrv->stats.total_sent++;
 108         req = nbt_name_register_send(iface->nbtsock, &io);
 109         if (req == NULL) return;
 110
 111         req->async.fn = refresh_completion_handler;
 112         req->async.private_data = iname;
 113 }
 114
 115
 116 /*
 117   start a timer to refresh this name
 118 */
 119 static void nbtd_start_refresh_timer(struct nbtd_iface_name *iname)
 120 {
 121         uint32_t refresh_time;
 122         uint32_t max_refresh_time = lpcfg_parm_int(iname->iface->nbtsrv->task->lp_ctx, NULL, "nbtd", "max_refresh_time", 7200);
 123
 124         refresh_time = MIN(max_refresh_time, iname->ttl/2);
 125
 126         tevent_add_timer(iname->iface->nbtsrv->task->event_ctx,
 127                         iname,
 128                         timeval_add(&iname->registration_time, refresh_time, 0),
 129                         name_refresh_handler, iname);
 130 }
 131
 132 struct nbtd_register_name_state {
 133         struct nbtd_iface_name *iname;
 134         struct nbt_name_register_bcast io;
 135 };
 136
 137 /*
 138   a name registration has completed
 139 */
 140 static void nbtd_register_name_handler(struct tevent_req *subreq)
 141 {
 142         struct nbtd_register_name_state *state =
 143                 tevent_req_callback_data(subreq,
 144                 struct nbtd_register_name_state);
 145         struct nbtd_iface_name *iname = state->iname;
 146         NTSTATUS status;
 147
 148         status = nbt_name_register_bcast_recv(subreq);
 149         TALLOC_FREE(subreq);
 150         if (NT_STATUS_IS_OK(status)) {
 151                 /* good - nobody complained about our registration */
 152                 iname->nb_flags |= NBT_NM_ACTIVE;
 153                 DEBUG(3,("Registered %s with %s on interface %s\n",
 154                          nbt_name_string(state, &iname->name),
 155                          iname->iface->ip_address, iname->iface->bcast_address));
 156                 iname->registration_time = timeval_current();
 157                 talloc_free(state);
 158                 nbtd_start_refresh_timer(iname);
 159                 return;
 160         }
 161
 162         /* someone must have replied with an objection! */
 163         iname->nb_flags |= NBT_NM_CONFLICT;
 164
 165         DEBUG(1,("Error registering %s with %s on interface %s - %s\n",
 166                  nbt_name_string(state, &iname->name),
 167                  iname->iface->ip_address, iname->iface->bcast_address,
 168                  nt_errstr(status)));
 169         talloc_free(state);
 170 }
 171
 172
 173 /*
 174   register a name on a network interface
 175 */
 176 static void nbtd_register_name_iface(struct nbtd_interface *iface,
 177                                      const char *name, enum nbt_name_type type,
 178                                      uint16_t nb_flags)
 179 {
 180         struct nbtd_iface_name *iname;
 181         const char *scope = lpcfg_netbios_scope(iface->nbtsrv->task->lp_ctx);
 182         struct nbtd_register_name_state *state;
 183         struct tevent_req *subreq;
 184         struct nbtd_server *nbtsrv = iface->nbtsrv;
 185
 186         iname = talloc(iface, struct nbtd_iface_name);
 187         if (!iname) return;
 188
 189         iname->iface     = iface;
 190         iname->name.name = strupper_talloc(iname, name);
 191         iname->name.type = type;
 192         if (scope && *scope) {
 193                 iname->name.scope = strupper_talloc(iname, scope);
 194         } else {
 195                 iname->name.scope = NULL;
 196         }
 197         iname->nb_flags          = nb_flags;
 198         iname->ttl               = lpcfg_parm_int(iface->nbtsrv->task->lp_ctx, NULL, "nbtd", "bcast_ttl", 300000);
 199         iname->registration_time = timeval_zero();
 200         iname->wins_server       = NULL;
 201
 202         DLIST_ADD_END(iface->names, iname);
 203
 204         if (nb_flags & NBT_NM_PERMANENT) {
 205                 /* permanent names are not announced and are immediately active */
 206                 iname->nb_flags |= NBT_NM_ACTIVE;
 207                 iname->ttl       = 0;
 208                 return;
 209         }
 210
 211         /* if this is the wins interface, then we need to do a special
 212            wins name registration */
 213         if (iface == iface->nbtsrv->wins_interface) {
 214                 nbtd_winsclient_register(iname);
 215                 return;
 216         }
 217
 218         state = talloc_zero(iname, struct nbtd_register_name_state);
 219         if (state == NULL) {
 220                 return;
 221         }
 222
 223         state->iname = iname;
 224
 225         /* setup a broadcast name registration request */
 226         state->io.in.name      = iname->name;
 227         state->io.in.dest_addr = iface->bcast_address;
 228         state->io.in.dest_port = lpcfg_nbt_port(iface->nbtsrv->task->lp_ctx);
 229         state->io.in.address   = iface->ip_address;
 230         state->io.in.nb_flags  = nb_flags;
 231         state->io.in.ttl       = iname->ttl;
 232
 233         nbtsrv->stats.total_sent++;
 234
 235         subreq = nbt_name_register_bcast_send(state, nbtsrv->task->event_ctx,
 236                                               iface->nbtsock, &state->io);
 237         if (subreq == NULL) {
 238                 return;
 239         }
 240
 241         tevent_req_set_callback(subreq, nbtd_register_name_handler, state);
 242 }
 243
 244
 245 /*
 246   register one name on all our interfaces
 247 */
 248 void nbtd_register_name(struct nbtd_server *nbtsrv,
 249                         const char *name, enum nbt_name_type type,
 250                         uint16_t nb_flags)
 251 {
 252         struct nbtd_interface *iface;
 253
 254         /* register with all the local interfaces */
 255         for (iface=nbtsrv->interfaces;iface;iface=iface->next) {
 256                 nbtd_register_name_iface(iface, name, type, nb_flags);
 257         }
 258
 259         /* register on our general broadcast interface as a permanent name */
 260         if (nbtsrv->bcast_interface) {
 261                 nbtd_register_name_iface(nbtsrv->bcast_interface, name, type,
 262                                          nb_flags | NBT_NM_PERMANENT);
 263         }
 264
 265         /* register with our WINS servers */
 266         if (nbtsrv->wins_interface) {
 267                 nbtd_register_name_iface(nbtsrv->wins_interface, name, type, nb_flags);
 268         }
 269 }
 270
 271
 272 /*
 273   register our names on all interfaces
 274 */
 275 void nbtd_register_names(struct nbtd_server *nbtsrv)
 276 {
 277         uint16_t nb_flags = NBT_NODE_M;
 278         const char **aliases;
 279
 280         /* note that we don't initially mark the names "ACTIVE". They are
 281            marked active once registration is successful */
 282         nbtd_register_name(nbtsrv, lpcfg_netbios_name(nbtsrv->task->lp_ctx), NBT_NAME_CLIENT, nb_flags);
 283         nbtd_register_name(nbtsrv, lpcfg_netbios_name(nbtsrv->task->lp_ctx), NBT_NAME_USER,   nb_flags);
 284         nbtd_register_name(nbtsrv, lpcfg_netbios_name(nbtsrv->task->lp_ctx), NBT_NAME_SERVER, nb_flags);
 285
 286         aliases = lpcfg_netbios_aliases(nbtsrv->task->lp_ctx);
 287         while (aliases && aliases[0]) {
 288                 nbtd_register_name(nbtsrv, aliases[0], NBT_NAME_CLIENT, nb_flags);
 289                 nbtd_register_name(nbtsrv, aliases[0], NBT_NAME_SERVER, nb_flags);
 290                 aliases++;
 291         }
 292
 293         if (lpcfg_server_role(nbtsrv->task->lp_ctx) == ROLE_ACTIVE_DIRECTORY_DC)        {
 294                 bool is_pdc = samdb_is_pdc(nbtsrv->sam_ctx);
 295                 if (is_pdc) {
 296                         nbtd_register_name(nbtsrv, lpcfg_workgroup(nbtsrv->task->lp_ctx),
 297                                            NBT_NAME_PDC, nb_flags);
 298                 }
 299                 nbtd_register_name(nbtsrv, lpcfg_workgroup(nbtsrv->task->lp_ctx),
 300                                    NBT_NAME_LOGON, nb_flags | NBT_NM_GROUP);
 301         }
 302
 303         nb_flags |= NBT_NM_GROUP;
 304         nbtd_register_name(nbtsrv, lpcfg_workgroup(nbtsrv->task->lp_ctx), NBT_NAME_CLIENT, nb_flags);
 305
 306         nb_flags |= NBT_NM_PERMANENT;
 307         nbtd_register_name(nbtsrv, "__SAMBA__",       NBT_NAME_CLIENT, nb_flags);
 308         nbtd_register_name(nbtsrv, "__SAMBA__",       NBT_NAME_SERVER, nb_flags);
 309         nbtd_register_name(nbtsrv, "*",               NBT_NAME_CLIENT, nb_flags);
 310 }