s3-vfs: Use ENOATTR in errno comparison for getxattr
[garming/samba-autobuild/.git] / source4 / nbt_server / interfaces.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    NBT interface handling
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/util/dlinklist.h"
24 #include "nbt_server/nbt_server.h"
25 #include "smbd/service_task.h"
26 #include "lib/socket/socket.h"
27 #include "nbt_server/wins/winsserver.h"
28 #include "nbt_server/dgram/proto.h"
29 #include "system/network.h"
30 #include "lib/socket/netif.h"
31 #include "param/param.h"
32 #include "lib/util/util_net.h"
33
34
35 /*
36   receive an incoming request and dispatch it to the right place
37 */
38 static void nbtd_request_handler(struct nbt_name_socket *nbtsock, 
39                                  struct nbt_name_packet *packet, 
40                                  struct socket_address *src)
41 {
42         struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private_data,
43                                                        struct nbtd_interface);
44         struct nbtd_server *nbtsrv = iface->nbtsrv;
45
46         nbtsrv->stats.total_received++;
47
48         /* see if it's from one of our own interfaces - if so, then ignore it */
49         if (nbtd_self_packet_and_bcast(nbtsock, packet, src)) {
50                 DEBUG(10,("Ignoring bcast self packet from %s:%d\n", src->addr, src->port));
51                 return;
52         }
53
54         switch (packet->operation & NBT_OPCODE) {
55         case NBT_OPCODE_QUERY:
56                 nbtsrv->stats.query_count++;
57                 nbtd_request_query(nbtsock, packet, src);
58                 break;
59
60         case NBT_OPCODE_REGISTER:
61         case NBT_OPCODE_REFRESH:
62         case NBT_OPCODE_REFRESH2:
63                 nbtsrv->stats.register_count++;
64                 nbtd_request_defense(nbtsock, packet, src);
65                 break;
66
67         case NBT_OPCODE_RELEASE:
68         case NBT_OPCODE_MULTI_HOME_REG:
69                 nbtsrv->stats.release_count++;
70                 nbtd_winsserver_request(nbtsock, packet, src);
71                 break;
72
73         default:
74                 nbtd_bad_packet(packet, src, "Unexpected opcode");
75                 break;
76         }
77 }
78
79 static void nbtd_unexpected_handler(struct nbt_name_socket *nbtsock,
80                                     struct nbt_name_packet *packet,
81                                     struct socket_address *src)
82 {
83         struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private_data,
84                                                        struct nbtd_interface);
85         struct nbtd_server *nbtsrv = iface->nbtsrv;
86         struct nbtd_interface *i;
87         struct nbt_name_request *req = NULL;
88
89         nbtsrv->stats.total_received++;
90
91         DEBUG(10,("unexpected from src[%s] on interface[%p] %s/%s\n",
92                 src->addr, iface, iface->ip_address, iface->netmask));
93
94         /* try the broadcast interface */
95         if (nbtsrv->bcast_interface) {
96                 i = nbtsrv->bcast_interface;
97                 req = idr_find(i->nbtsock->idr, packet->name_trn_id);
98         }
99
100         /* try the wins server client interface */
101         if (!req && nbtsrv->wins_interface && nbtsrv->wins_interface->nbtsock) {
102                 i = nbtsrv->wins_interface;
103                 req = idr_find(i->nbtsock->idr, packet->name_trn_id);
104         }
105
106         /* try all other interfaces... */
107         if (!req) {
108                 for (i = nbtsrv->interfaces; i; i = i->next) {
109                         if (i == iface) {
110                                 continue;
111                         }
112                         req = idr_find(i->nbtsock->idr, packet->name_trn_id);
113                         if (req) break;
114                 }
115         }
116
117         if (!req) {
118                 DEBUG(10,("unexpected from src[%s] unable to redirected\n", src->addr));
119                 return;
120         }
121
122         DEBUG(10,("unexpected from src[%s] redirected to interface[%p] %s/%s\n",
123                 src->addr, i, i->ip_address, i->netmask));
124
125         /*
126          * redirect the incoming response to the socket
127          * we sent the matching request
128          */
129         nbt_name_socket_handle_response_packet(req, packet, src);
130 }
131
132 /*
133   find a registered name on an interface
134 */
135 struct nbtd_iface_name *nbtd_find_iname(struct nbtd_interface *iface, 
136                                         struct nbt_name *name, 
137                                         uint16_t nb_flags)
138 {
139         struct nbtd_iface_name *iname;
140         for (iname=iface->names;iname;iname=iname->next) {
141                 if (iname->name.type == name->type &&
142                     strcmp(name->name, iname->name.name) == 0 &&
143                     ((iname->nb_flags & nb_flags) == nb_flags)) {
144                         return iname;
145                 }
146         }
147         return NULL;
148 }
149
150 /*
151   start listening on the given address
152 */
153 static NTSTATUS nbtd_add_socket(struct nbtd_server *nbtsrv, 
154                                 struct loadparm_context *lp_ctx,
155                                 const char *bind_address, 
156                                 const char *address, 
157                                 const char *bcast, 
158                                 const char *netmask)
159 {
160         struct nbtd_interface *iface;
161         NTSTATUS status;
162         struct socket_address *bcast_address;
163         struct socket_address *unicast_address;
164
165         DEBUG(6,("nbtd_add_socket(%s, %s, %s, %s)\n", bind_address, address, bcast, netmask));
166
167         /*
168           we actually create two sockets. One listens on the broadcast address
169           for the interface, and the other listens on our specific address. This
170           allows us to run with "bind interfaces only" while still receiving 
171           broadcast addresses, and also simplifies matching incoming requests 
172           to interfaces
173         */
174
175         iface = talloc(nbtsrv, struct nbtd_interface);
176         NT_STATUS_HAVE_NO_MEMORY(iface);
177
178         iface->nbtsrv        = nbtsrv;
179         iface->bcast_address = talloc_steal(iface, bcast);
180         iface->ip_address    = talloc_steal(iface, address);
181         iface->netmask       = talloc_steal(iface, netmask);
182         iface->names         = NULL;
183         iface->wack_queue    = NULL;
184
185         if (strcmp(netmask, "0.0.0.0") != 0) {
186                 struct nbt_name_socket *bcast_nbtsock;
187
188                 /* listen for broadcasts on port 137 */
189                 bcast_nbtsock = nbt_name_socket_init(iface, nbtsrv->task->event_ctx);
190                 if (!bcast_nbtsock) {
191                         talloc_free(iface);
192                         return NT_STATUS_NO_MEMORY;
193                 }
194
195                 bcast_address = socket_address_from_strings(bcast_nbtsock, bcast_nbtsock->sock->backend_name, 
196                                                             bcast, lpcfg_nbt_port(lp_ctx));
197                 if (!bcast_address) {
198                         talloc_free(iface);
199                         return NT_STATUS_NO_MEMORY;
200                 }
201
202                 status = socket_listen(bcast_nbtsock->sock, bcast_address, 0, 0);
203                 if (!NT_STATUS_IS_OK(status)) {
204                         DEBUG(0,("Failed to bind to %s:%d - %s\n", 
205                                  bcast, lpcfg_nbt_port(lp_ctx), nt_errstr(status)));
206                         talloc_free(iface);
207                         return status;
208                 }
209                 talloc_free(bcast_address);
210
211                 nbt_set_incoming_handler(bcast_nbtsock, nbtd_request_handler, iface);
212         }
213
214         /* listen for unicasts on port 137 */
215         iface->nbtsock = nbt_name_socket_init(iface, nbtsrv->task->event_ctx);
216         if (!iface->nbtsock) {
217                 talloc_free(iface);
218                 return NT_STATUS_NO_MEMORY;
219         }
220
221         unicast_address = socket_address_from_strings(iface->nbtsock, 
222                                                       iface->nbtsock->sock->backend_name, 
223                                                       bind_address, lpcfg_nbt_port(lp_ctx));
224
225         status = socket_listen(iface->nbtsock->sock, unicast_address, 0, 0);
226         if (!NT_STATUS_IS_OK(status)) {
227                 DEBUG(0,("Failed to bind to %s:%d - %s\n", 
228                          bind_address, lpcfg_nbt_port(lp_ctx), nt_errstr(status)));
229                 talloc_free(iface);
230                 return status;
231         }
232         talloc_free(unicast_address);
233
234         nbt_set_incoming_handler(iface->nbtsock, nbtd_request_handler, iface);
235         nbt_set_unexpected_handler(iface->nbtsock, nbtd_unexpected_handler, iface);
236
237         /* also setup the datagram listeners */
238         status = nbtd_dgram_setup(iface, bind_address);
239         if (!NT_STATUS_IS_OK(status)) {
240                 DEBUG(0,("Failed to setup dgram listen on %s - %s\n", 
241                          bind_address, nt_errstr(status)));
242                 talloc_free(iface);
243                 return status;
244         }
245         
246         if (strcmp(netmask, "0.0.0.0") == 0) {
247                 DLIST_ADD(nbtsrv->bcast_interface, iface);
248         } else {
249                 DLIST_ADD(nbtsrv->interfaces, iface);
250         }
251
252         return NT_STATUS_OK;
253 }
254
255 /*
256   setup a socket for talking to our WINS servers
257 */
258 static NTSTATUS nbtd_add_wins_socket(struct nbtd_server *nbtsrv)
259 {
260         struct nbtd_interface *iface;
261
262         iface = talloc_zero(nbtsrv, struct nbtd_interface);
263         NT_STATUS_HAVE_NO_MEMORY(iface);
264
265         iface->nbtsrv        = nbtsrv;
266
267         DLIST_ADD(nbtsrv->wins_interface, iface);
268
269         return NT_STATUS_OK;
270 }
271
272
273 /*
274   setup our listening sockets on the configured network interfaces
275 */
276 NTSTATUS nbtd_startup_interfaces(struct nbtd_server *nbtsrv, struct loadparm_context *lp_ctx,
277                                  struct interface *ifaces)
278 {
279         int num_interfaces = iface_list_count(ifaces);
280         int i;
281         TALLOC_CTX *tmp_ctx = talloc_new(nbtsrv);
282         NTSTATUS status;
283
284         /* if we are allowing incoming packets from any address, then
285            we also need to bind to the wildcard address */
286         if (!lpcfg_bind_interfaces_only(lp_ctx)) {
287                 const char *primary_address;
288
289                 primary_address = iface_list_first_v4(ifaces);
290
291                 /* the primary address is the address we will return
292                    for non-WINS queries not made on a specific
293                    interface */
294                 if (primary_address == NULL) {
295                         primary_address = inet_ntoa(interpret_addr2(
296                                                             lpcfg_netbios_name(lp_ctx)));
297                 }
298
299                 primary_address = talloc_strdup(tmp_ctx, primary_address);
300                 NT_STATUS_HAVE_NO_MEMORY(primary_address);
301
302                 status = nbtd_add_socket(nbtsrv, 
303                                          lp_ctx,
304                                          "0.0.0.0",
305                                          primary_address,
306                                          talloc_strdup(tmp_ctx, "255.255.255.255"),
307                                          talloc_strdup(tmp_ctx, "0.0.0.0"));
308                 NT_STATUS_NOT_OK_RETURN(status);
309         }
310
311         for (i=0; i<num_interfaces; i++) {
312                 const char *bcast;
313                 const char *address, *netmask;
314
315                 if (!iface_list_n_is_v4(ifaces, i)) {
316                         /* v4 only for NBT protocol */
317                         continue;
318                 }
319
320                 bcast = iface_list_n_bcast(ifaces, i);
321                 /* we can't assume every interface is broadcast capable */
322                 if (bcast == NULL) continue;
323
324                 address = talloc_strdup(tmp_ctx, iface_list_n_ip(ifaces, i));
325                 bcast   = talloc_strdup(tmp_ctx, bcast);
326                 netmask = talloc_strdup(tmp_ctx, iface_list_n_netmask(ifaces, i));
327
328                 status = nbtd_add_socket(nbtsrv, lp_ctx,
329                                          address, address, bcast, netmask);
330                 NT_STATUS_NOT_OK_RETURN(status);
331         }
332
333         if (lpcfg_wins_server_list(lp_ctx)) {
334                 status = nbtd_add_wins_socket(nbtsrv);
335                 NT_STATUS_NOT_OK_RETURN(status);
336         }
337
338         talloc_free(tmp_ctx);
339
340         return NT_STATUS_OK;
341 }
342
343
344 /*
345   form a list of addresses that we should use in name query replies
346   we always place the IP in the given interface first
347 */
348 const char **nbtd_address_list(struct nbtd_interface *iface, TALLOC_CTX *mem_ctx)
349 {
350         struct nbtd_server *nbtsrv = iface->nbtsrv;
351         const char **ret = NULL;
352         struct nbtd_interface *iface2;
353         bool is_loopback = false;
354
355         if (iface->ip_address) {
356                 is_loopback = iface_list_same_net(iface->ip_address, "127.0.0.1", "255.0.0.0");
357                 ret = str_list_add(ret, iface->ip_address);
358         }
359
360         for (iface2=nbtsrv->interfaces;iface2;iface2=iface2->next) {
361                 if (iface2 == iface) continue;
362
363                 if (!iface2->ip_address) continue;
364
365                 if (!is_loopback) {
366                         if (iface_list_same_net(iface2->ip_address, "127.0.0.1", "255.0.0.0")) {
367                                 continue;
368                         }
369                 }
370
371                 ret = str_list_add(ret, iface2->ip_address);
372         }
373
374         talloc_steal(mem_ctx, ret);
375
376         return ret;
377 }
378
379
380 /*
381   find the interface to use for sending a outgoing request
382 */
383 struct nbtd_interface *nbtd_find_request_iface(struct nbtd_server *nbtd_server,
384                                                const char *address, bool allow_bcast_iface)
385 {
386         struct nbtd_interface *cur;
387
388         /* try to find a exact match */
389         for (cur=nbtd_server->interfaces;cur;cur=cur->next) {
390                 if (iface_list_same_net(address, cur->ip_address, cur->netmask)) {
391                         DEBUG(10,("find interface for dst[%s] ip: %s/%s (iface[%p])\n",
392                                   address, cur->ip_address, cur->netmask, cur));
393                         return cur;
394                 }
395         }
396
397         /* no exact match, if we have the broadcast interface, use that */
398         if (allow_bcast_iface && nbtd_server->bcast_interface) {
399                 cur = nbtd_server->bcast_interface;
400                 DEBUG(10,("find interface for dst[%s] ip: %s/%s (bcast iface[%p])\n",
401                         address, cur->ip_address, cur->netmask, cur));
402                 return cur;
403         }
404
405         /* fallback to first interface */
406         cur = nbtd_server->interfaces;
407         DEBUG(10,("find interface for dst[%s] ip: %s/%s (default iface[%p])\n",
408                 address, cur->ip_address, cur->netmask, cur));
409         return cur;
410 }
411
412 /*
413  * find the interface to use for sending a outgoing reply
414  */
415 struct nbtd_interface *nbtd_find_reply_iface(struct nbtd_interface *iface,
416                                              const char *address, bool allow_bcast_iface)
417 {
418         struct nbtd_server *nbtd_server = iface->nbtsrv;
419
420         /* first try to use the given interfacel when it's not the broadcast one */
421         if (iface != nbtd_server->bcast_interface) {
422                 return iface;
423         }
424
425         return nbtd_find_request_iface(nbtd_server, address, allow_bcast_iface);
426 }