source/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 nbt_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                 nbt_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 nbt_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 nbt_register_handler(struct composite_context *req)
 120 {
 121         struct nbt_iface_name *iname = talloc_get_type(req->async.private, struct nbt_iface_name);
 122         NTSTATUS status;
 123
 124         status = nbt_name_register_bcast_recv(req);
 125         if (NT_STATUS_IS_OK(status)) {
 126                 /* good - nobody complained about our registration */
 127                 iname->nb_flags |= NBT_NM_ACTIVE;
 128                 DEBUG(3,("Registered %s<%02x> on interface %s\n",
 129                          iname->name.name, iname->name.type, iname->iface->bcast_address));
 130                 iname->registration_time = timeval_current();
 131                 nbt_start_refresh_timer(iname);
 132                 return;
 133         }
 134
 135         /* someone must have replied with an objection! */
 136         iname->nb_flags |= NBT_NM_CONFLICT;
 137
 138         DEBUG(1,("Error registering %s<%02x> on interface %s - %s\n",
 139                  iname->name.name, iname->name.type, iname->iface->bcast_address,
 140                  nt_errstr(status)));
 141 }
 142
 143
 144 /*
 145   register a name on a network interface
 146 */
 147 static void nbt_register_name_iface(struct nbt_interface *iface,
 148                                     const char *name, enum nbt_name_type type,
 149                                     uint16_t nb_flags)
 150 {
 151         struct nbt_iface_name *iname;
 152         const char *scope = lp_netbios_scope();
 153         struct nbt_name_register_bcast io;
 154         struct composite_context *req;
 155
 156         iname = talloc(iface, struct nbt_iface_name);
 157         if (!iname) return;
 158
 159         iname->iface     = iface;
 160         iname->name.name = talloc_strdup(iname, name);
 161         iname->name.type = type;
 162         if (scope && *scope) {
 163                 iname->name.scope = talloc_strdup(iname, scope);
 164         } else {
 165                 iname->name.scope = NULL;
 166         }
 167         iname->nb_flags          = nb_flags;
 168         iname->ttl               = lp_parm_int(-1, "nbtd", "bcast_ttl", 300000);
 169         iname->registration_time = timeval_zero();
 170
 171         DLIST_ADD_END(iface->names, iname, struct nbt_iface_name *);
 172
 173         if (nb_flags & NBT_NM_PERMANENT) {
 174                 /* permanent names are not announced and are immediately active */
 175                 iname->nb_flags |= NBT_NM_ACTIVE;
 176                 iname->ttl       = 0;
 177                 return;
 178         }
 179
 180         /* setup a broadcast name registration request */
 181         io.in.name            = iname->name;
 182         io.in.dest_addr       = iface->bcast_address;
 183         io.in.address         = iface->ip_address;
 184         io.in.nb_flags        = nb_flags;
 185         io.in.ttl             = iname->ttl;
 186
 187         req = nbt_name_register_bcast_send(iface->nbtsock, &io);
 188         if (req == NULL) return;
 189
 190         req->async.fn = nbt_register_handler;
 191         req->async.private = iname;
 192 }
 193
 194
 195 /*
 196   register one name on all our interfaces
 197 */
 198 static void nbt_register_name(struct nbt_server *nbtsrv,
 199                               const char *name, enum nbt_name_type type,
 200                               uint16_t nb_flags)
 201 {
 202         struct nbt_interface *iface;
 203
 204         /* register with all the local interfaces */
 205         for (iface=nbtsrv->interfaces;iface;iface=iface->next) {
 206                 nbt_register_name_iface(iface, name, type, nb_flags);
 207         }
 208
 209         /* register on our general broadcast interface as a permanent name */
 210         if (nbtsrv->bcast_interface) {
 211                 nbt_register_name_iface(nbtsrv->bcast_interface, name, type,
 212                                         nb_flags | NBT_NM_PERMANENT);
 213         }
 214
 215         /* TODO: register with our WINS servers */
 216 }
 217
 218
 219 /*
 220   register our names on all interfaces
 221 */
 222 void nbt_register_names(struct nbt_server *nbtsrv)
 223 {
 224         uint16_t nb_flags = NBT_NODE_M;
 225
 226         /* note that we don't initially mark the names "ACTIVE". They are
 227            marked active once registration is successful */
 228         nbt_register_name(nbtsrv, lp_netbios_name(), NBT_NAME_CLIENT, nb_flags);
 229         nbt_register_name(nbtsrv, lp_netbios_name(), NBT_NAME_USER,   nb_flags);
 230         nbt_register_name(nbtsrv, lp_netbios_name(), NBT_NAME_SERVER, nb_flags);
 231
 232         nb_flags |= NBT_NM_GROUP;
 233         nbt_register_name(nbtsrv, lp_workgroup(),    NBT_NAME_CLIENT, nb_flags);
 234
 235         nb_flags |= NBT_NM_PERMANENT;
 236         nbt_register_name(nbtsrv, "__SAMBA__",       NBT_NAME_CLIENT, nb_flags);
 237         nbt_register_name(nbtsrv, "__SAMBA__",       NBT_NAME_SERVER, nb_flags);
 238         nbt_register_name(nbtsrv, "*",               NBT_NAME_CLIENT, nb_flags);
 239 }