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 2 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, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23 #include "includes.h"
  24 #include "lib/events/events.h"
  25 #include "dlinklist.h"
  26 #include "nbt_server/nbt_server.h"
  27 #include "smbd/service_task.h"
  28 #include "libcli/raw/libcliraw.h"
  29 #include "libcli/composite/composite.h"
  30
  31
  32 static void nbtd_start_refresh_timer(struct nbt_iface_name *iname);
  33
  34 /*
  35   a name refresh request has completed
  36 */
  37 static void refresh_completion_handler(struct nbt_name_request *req)
  38 {
  39         struct nbt_iface_name *iname = talloc_get_type(req->async.private, struct nbt_iface_name);
  40         NTSTATUS status;
  41         struct nbt_name_refresh io;
  42         TALLOC_CTX *tmp_ctx = talloc_new(iname);
  43
  44         status = nbt_name_refresh_recv(req, tmp_ctx, &io);
  45         if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
  46                 DEBUG(4,("Refreshed name %s<%02x> on %s\n",
  47                          iname->name.name, iname->name.type, iname->iface->ip_address));
  48                 iname->registration_time = timeval_current();
  49                 nbtd_start_refresh_timer(iname);
  50                 talloc_free(tmp_ctx);
  51                 return;
  52         }
  53
  54         iname->nb_flags |= NBT_NM_CONFLICT;
  55         iname->nb_flags &= ~NBT_NM_ACTIVE;
  56
  57         if (NT_STATUS_IS_OK(status)) {
  58                 DEBUG(1,("Name conflict from %s refreshing name %s<%02x> on %s - rcode %d\n",
  59                          io.out.reply_addr, iname->name.name, iname->name.type,
  60                          iname->iface->ip_address, io.out.rcode));
  61         } else {
  62                 DEBUG(1,("Error refreshing name %s<%02x> on %s - %s\n",
  63                          iname->name.name, iname->name.type, iname->iface->ip_address,
  64                          nt_errstr(status)));
  65         }
  66
  67         talloc_free(tmp_ctx);
  68 }
  69
  70
  71 /*
  72   handle name refresh timer events
  73 */
  74 static void name_refresh_handler(struct event_context *ev, struct timed_event *te,
  75                                  struct timeval t, void *private)
  76 {
  77         struct nbt_iface_name *iname = talloc_get_type(private, struct nbt_iface_name);
  78         struct nbt_interface *iface = iname->iface;
  79         struct nbt_name_refresh io;
  80         struct nbt_name_request *req;
  81
  82         /* setup a name refresh request */
  83         io.in.name            = iname->name;
  84         io.in.dest_addr       = iface->bcast_address;
  85         io.in.address         = iface->ip_address;
  86         io.in.nb_flags        = iname->nb_flags;
  87         io.in.ttl             = iname->ttl;
  88         io.in.broadcast       = True;
  89         io.in.timeout         = 3;
  90
  91         req = nbt_name_refresh_send(iface->nbtsock, &io);
  92         if (req == NULL) return;
  93
  94         req->async.fn = refresh_completion_handler;
  95         req->async.private = iname;
  96 }
  97
  98
  99 /*
 100   start a timer to refresh this name
 101 */
 102 static void nbtd_start_refresh_timer(struct nbt_iface_name *iname)
 103 {
 104         uint32_t refresh_time;
 105         uint32_t max_refresh_time = lp_parm_int(-1, "nbtd", "max_refresh_time", 7200);
 106
 107         refresh_time = MIN(max_refresh_time, iname->ttl/2);
 108
 109         event_add_timed(iname->iface->nbtsrv->task->event_ctx,
 110                         iname,
 111                         timeval_current_ofs(refresh_time, 0),
 112                         name_refresh_handler, iname);
 113 }
 114
 115
 116 /*
 117   a name registration has completed
 118 */
 119 static void nbtd_register_handler(struct composite_context *req)
 120 {
 121         struct nbt_iface_name *iname = talloc_get_type(req->async.private,
 122                                                        struct nbt_iface_name);
 123         NTSTATUS status;
 124
 125         status = nbt_name_register_bcast_recv(req);
 126         if (NT_STATUS_IS_OK(status)) {
 127                 /* good - nobody complained about our registration */
 128                 iname->nb_flags |= NBT_NM_ACTIVE;
 129                 DEBUG(3,("Registered %s<%02x> on interface %s\n",
 130                          iname->name.name, iname->name.type, iname->iface->bcast_address));
 131                 iname->registration_time = timeval_current();
 132                 nbtd_start_refresh_timer(iname);
 133                 return;
 134         }
 135
 136         /* someone must have replied with an objection! */
 137         iname->nb_flags |= NBT_NM_CONFLICT;
 138
 139         DEBUG(1,("Error registering %s<%02x> on interface %s - %s\n",
 140                  iname->name.name, iname->name.type, iname->iface->bcast_address,
 141                  nt_errstr(status)));
 142 }
 143
 144
 145 /*
 146   register a name on a network interface
 147 */
 148 static void nbtd_register_name_iface(struct nbt_interface *iface,
 149                                      const char *name, enum nbt_name_type type,
 150                                      uint16_t nb_flags)
 151 {
 152         struct nbt_iface_name *iname;
 153         const char *scope = lp_netbios_scope();
 154         struct nbt_name_register_bcast io;
 155         struct composite_context *req;
 156
 157         iname = talloc(iface, struct nbt_iface_name);
 158         if (!iname) return;
 159
 160         iname->iface     = iface;
 161         iname->name.name = talloc_strdup(iname, name);
 162         iname->name.type = type;
 163         if (scope && *scope) {
 164                 iname->name.scope = talloc_strdup(iname, scope);
 165         } else {
 166                 iname->name.scope = NULL;
 167         }
 168         iname->nb_flags          = nb_flags;
 169         iname->ttl               = lp_parm_int(-1, "nbtd", "bcast_ttl", 300000);
 170         iname->registration_time = timeval_zero();
 171
 172         DLIST_ADD_END(iface->names, iname, struct nbt_iface_name *);
 173
 174         if (nb_flags & NBT_NM_PERMANENT) {
 175                 /* permanent names are not announced and are immediately active */
 176                 iname->nb_flags |= NBT_NM_ACTIVE;
 177                 iname->ttl       = 0;
 178                 return;
 179         }
 180
 181         /* setup a broadcast name registration request */
 182         io.in.name            = iname->name;
 183         io.in.dest_addr       = iface->bcast_address;
 184         io.in.address         = iface->ip_address;
 185         io.in.nb_flags        = nb_flags;
 186         io.in.ttl             = iname->ttl;
 187
 188         req = nbt_name_register_bcast_send(iface->nbtsock, &io);
 189         if (req == NULL) return;
 190
 191         req->async.fn = nbtd_register_handler;
 192         req->async.private = iname;
 193 }
 194
 195
 196 /*
 197   register one name on all our interfaces
 198 */
 199 static void nbtd_register_name(struct nbt_server *nbtsrv,
 200                                const char *name, enum nbt_name_type type,
 201                                uint16_t nb_flags)
 202 {
 203         struct nbt_interface *iface;
 204
 205         /* register with all the local interfaces */
 206         for (iface=nbtsrv->interfaces;iface;iface=iface->next) {
 207                 nbtd_register_name_iface(iface, name, type, nb_flags);
 208         }
 209
 210         /* register on our general broadcast interface as a permanent name */
 211         if (nbtsrv->bcast_interface) {
 212                 nbtd_register_name_iface(nbtsrv->bcast_interface, name, type,
 213                                          nb_flags | NBT_NM_PERMANENT);
 214         }
 215
 216         /* TODO: register with our WINS servers */
 217 }
 218
 219
 220 /*
 221   register our names on all interfaces
 222 */
 223 void nbtd_register_names(struct nbt_server *nbtsrv)
 224 {
 225         uint16_t nb_flags = NBT_NODE_M;
 226
 227         /* note that we don't initially mark the names "ACTIVE". They are
 228            marked active once registration is successful */
 229         nbtd_register_name(nbtsrv, lp_netbios_name(), NBT_NAME_CLIENT, nb_flags);
 230         nbtd_register_name(nbtsrv, lp_netbios_name(), NBT_NAME_USER,   nb_flags);
 231         nbtd_register_name(nbtsrv, lp_netbios_name(), NBT_NAME_SERVER, nb_flags);
 232
 233         nb_flags |= NBT_NM_GROUP;
 234         nbtd_register_name(nbtsrv, lp_workgroup(),    NBT_NAME_CLIENT, nb_flags);
 235
 236         nb_flags |= NBT_NM_PERMANENT;
 237         nbtd_register_name(nbtsrv, "__SAMBA__",       NBT_NAME_CLIENT, nb_flags);
 238         nbtd_register_name(nbtsrv, "__SAMBA__",       NBT_NAME_SERVER, nb_flags);
 239         nbtd_register_name(nbtsrv, "*",               NBT_NAME_CLIENT, nb_flags);
 240 }