94768f7cb621038a1b3049d88621f6fff849694c
[tprouty/samba.git] / libcli / nbt / tools / nmblookup.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    NBT client - used to lookup netbios names
5
6    Copyright (C) Andrew Tridgell 1994-2005
7    Copyright (C) Jelmer Vernooij 2003 (Conversion to popt)
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
24 #include "includes.h"
25 #include "lib/cmdline/popt_common.h"
26 #include "lib/socket/socket.h"
27 #include "lib/events/events.h"
28 #include "system/network.h"
29 #include "system/locale.h"
30 #include "lib/socket/netif.h"
31 #include "librpc/gen_ndr/nbt.h"
32 #include "../libcli/nbt/libnbt.h"
33 #include "param/param.h"
34
35 /* command line options */
36 static struct {
37         const char *broadcast_address;
38         const char *unicast_address;
39         bool find_master;
40         bool wins_lookup;
41         bool node_status;
42         bool root_port;
43         bool lookup_by_ip;
44         bool case_sensitive;
45 } options;
46
47 /*
48   clean any binary from a node name
49 */
50 static const char *clean_name(TALLOC_CTX *mem_ctx, const char *name)
51 {
52         char *ret = talloc_strdup(mem_ctx, name);
53         int i;
54         for (i=0;ret[i];i++) {
55                 if (!isprint((unsigned char)ret[i])) ret[i] = '.';
56         }
57         return ret;
58 }
59
60 /*
61   turn a node status flags field into a string
62 */
63 static char *node_status_flags(TALLOC_CTX *mem_ctx, uint16_t flags)
64 {
65         char *ret;
66         const char *group = "       ";
67         const char *type = "B";
68
69         if (flags & NBT_NM_GROUP) {
70                 group = "<GROUP>";
71         }
72
73         switch (flags & NBT_NM_OWNER_TYPE) {
74         case NBT_NODE_B: 
75                 type = "B";
76                 break;
77         case NBT_NODE_P: 
78                 type = "P";
79                 break;
80         case NBT_NODE_M: 
81                 type = "M";
82                 break;
83         case NBT_NODE_H: 
84                 type = "H";
85                 break;
86         }
87
88         ret = talloc_asprintf(mem_ctx, "%s %s", group, type);
89
90         if (flags & NBT_NM_DEREGISTER) {
91                 ret = talloc_asprintf_append_buffer(ret, " <DEREGISTERING>");
92         }
93         if (flags & NBT_NM_CONFLICT) {
94                 ret = talloc_asprintf_append_buffer(ret, " <CONFLICT>");
95         }
96         if (flags & NBT_NM_ACTIVE) {
97                 ret = talloc_asprintf_append_buffer(ret, " <ACTIVE>");
98         }
99         if (flags & NBT_NM_PERMANENT) {
100                 ret = talloc_asprintf_append_buffer(ret, " <PERMANENT>");
101         }
102         
103         return ret;
104 }
105
106 /* do a single node status */
107 static bool do_node_status(struct nbt_name_socket *nbtsock,
108                            const char *addr, uint16_t port)
109 {
110         struct nbt_name_status io;
111         NTSTATUS status;
112
113         io.in.name.name = "*";
114         io.in.name.type = NBT_NAME_CLIENT;
115         io.in.name.scope = NULL;
116         io.in.dest_addr = addr;
117         io.in.dest_port = port;
118         io.in.timeout = 1;
119         io.in.retries = 2;
120
121         status = nbt_name_status(nbtsock, nbtsock, &io);
122         if (NT_STATUS_IS_OK(status)) {
123                 int i;
124                 printf("Node status reply from %s\n",
125                        io.out.reply_from);
126                 for (i=0;i<io.out.status.num_names;i++) {
127                         d_printf("\t%-16s <%02x>  %s\n", 
128                                  clean_name(nbtsock, io.out.status.names[i].name),
129                                  io.out.status.names[i].type,
130                                  node_status_flags(nbtsock, io.out.status.names[i].nb_flags));
131                 }
132                 printf("\n\tMAC Address = %02X-%02X-%02X-%02X-%02X-%02X\n",
133                        io.out.status.statistics.unit_id[0],
134                        io.out.status.statistics.unit_id[1],
135                        io.out.status.statistics.unit_id[2],
136                        io.out.status.statistics.unit_id[3],
137                        io.out.status.statistics.unit_id[4],
138                        io.out.status.statistics.unit_id[5]);
139                 return true;
140         }
141
142         return false;
143 }
144
145 /* do a single node query */
146 static NTSTATUS do_node_query(struct nbt_name_socket *nbtsock,
147                               const char *addr, 
148                               uint16_t port,
149                               const char *node_name, 
150                               enum nbt_name_type node_type,
151                               bool broadcast)
152 {
153         struct nbt_name_query io;
154         NTSTATUS status;
155         int i;
156
157         io.in.name.name = node_name;
158         io.in.name.type = node_type;
159         io.in.name.scope = NULL;
160         io.in.dest_addr = addr;
161         io.in.dest_port = port;
162         io.in.broadcast = broadcast;
163         io.in.wins_lookup = options.wins_lookup;
164         io.in.timeout = 1;
165         io.in.retries = 2;
166
167         status = nbt_name_query(nbtsock, nbtsock, &io);
168         NT_STATUS_NOT_OK_RETURN(status);
169
170         for (i=0;i<io.out.num_addrs;i++) {
171                 printf("%s %s<%02x>\n",
172                        io.out.reply_addrs[i],
173                        io.out.name.name,
174                        io.out.name.type);
175         }
176         if (options.node_status && io.out.num_addrs > 0) {
177                 do_node_status(nbtsock, io.out.reply_addrs[0], port);
178         }
179
180         return status;
181 }
182
183
184 static bool process_one(struct loadparm_context *lp_ctx, struct event_context *ev,
185                         struct interface *ifaces, const char *name, int nbt_port)
186 {
187         TALLOC_CTX *tmp_ctx = talloc_new(NULL);
188         enum nbt_name_type node_type = NBT_NAME_CLIENT;
189         char *node_name, *p;
190         struct socket_address *all_zero_addr;
191         struct nbt_name_socket *nbtsock;
192         NTSTATUS status = NT_STATUS_OK;
193         bool ret = true;
194
195         if (!options.case_sensitive) {
196                 name = strupper_talloc(tmp_ctx, name);
197         }
198         
199         if (options.find_master) {
200                 node_type = NBT_NAME_MASTER;
201                 if (*name == '-' || *name == '_') {
202                         name = "\01\02__MSBROWSE__\02";
203                         node_type = NBT_NAME_MS;
204                 }
205         }
206
207         p = strchr(name, '#');
208         if (p) {
209                 node_name = talloc_strndup(tmp_ctx, name, PTR_DIFF(p,name));
210                 node_type = (enum nbt_name_type)strtol(p+1, NULL, 16);
211         } else {
212                 node_name = talloc_strdup(tmp_ctx, name);
213         }
214
215         nbtsock = nbt_name_socket_init(tmp_ctx, ev, lp_iconv_convenience(lp_ctx),
216                                                                    lp_parm_int(lp_ctx, NULL, "nbt", "wack_timeout", 30)
217                                                                    );
218         
219         if (options.root_port) {
220                 all_zero_addr = socket_address_from_strings(tmp_ctx, nbtsock->sock->backend_name, 
221                                                             "0.0.0.0", NBT_NAME_SERVICE_PORT);
222                 
223                 if (!all_zero_addr) {
224                         talloc_free(tmp_ctx);
225                         return false;
226                 }
227
228                 status = socket_listen(nbtsock->sock, all_zero_addr, 0, 0);
229                 if (!NT_STATUS_IS_OK(status)) {
230                         printf("Failed to bind to local port 137 - %s\n", nt_errstr(status));
231                         talloc_free(tmp_ctx);
232                         return false;
233                 }
234         }
235
236         if (options.lookup_by_ip) {
237                 ret = do_node_status(nbtsock, name, nbt_port);
238                 talloc_free(tmp_ctx);
239                 return ret;
240         }
241
242         if (options.broadcast_address) {
243                 status = do_node_query(nbtsock, options.broadcast_address, nbt_port,
244                                        node_name, node_type, true);
245         } else if (options.unicast_address) {
246                 status = do_node_query(nbtsock, options.unicast_address, 
247                                        nbt_port, node_name, node_type, false);
248         } else {
249                 int i, num_interfaces;
250
251                 num_interfaces = iface_count(ifaces);
252                 for (i=0;i<num_interfaces;i++) {
253                         const char *bcast = iface_n_bcast(ifaces, i);
254                         if (bcast == NULL) continue;
255                         status = do_node_query(nbtsock, bcast, nbt_port, 
256                                                node_name, node_type, true);
257                         if (NT_STATUS_IS_OK(status)) break;
258                 }
259         }
260
261         if (!NT_STATUS_IS_OK(status)) {
262                 printf("Lookup failed - %s\n", nt_errstr(status));
263                 ret = false;
264         }
265
266         talloc_free(tmp_ctx);
267         return ret;
268 }
269
270 /*
271   main program
272 */
273 int main(int argc, const char *argv[])
274 {
275         bool ret = true;
276         struct interface *ifaces;
277         struct event_context *ev;
278         poptContext pc;
279         int opt;
280         enum {
281                 OPT_BROADCAST_ADDRESS   = 1000,
282                 OPT_UNICAST_ADDRESS,
283                 OPT_FIND_MASTER,
284                 OPT_WINS_LOOKUP,
285                 OPT_NODE_STATUS,
286                 OPT_ROOT_PORT,
287                 OPT_LOOKUP_BY_IP,
288                 OPT_CASE_SENSITIVE
289         };
290         struct poptOption long_options[] = {
291                 POPT_AUTOHELP
292                 { "broadcast", 'B', POPT_ARG_STRING, NULL, OPT_BROADCAST_ADDRESS,
293                   "Specify address to use for broadcasts", "BROADCAST-ADDRESS" },
294
295                 { "unicast", 'U', POPT_ARG_STRING, NULL, OPT_UNICAST_ADDRESS,
296                   "Specify address to use for unicast", NULL },
297
298                 { "master-browser", 'M', POPT_ARG_NONE, NULL, OPT_FIND_MASTER,
299                   "Search for a master browser", NULL },
300
301                 { "wins", 'W', POPT_ARG_NONE, NULL, OPT_WINS_LOOKUP,
302                   "Do a WINS lookup", NULL },
303
304                 { "status", 'S', POPT_ARG_NONE, NULL, OPT_NODE_STATUS, 
305                   "Lookup node status as well", NULL },
306
307                 { "root-port", 'r', POPT_ARG_NONE, NULL, OPT_ROOT_PORT, 
308                   "Use root port 137 (Win95 only replies to this)", NULL },
309
310                 { "lookup-by-ip", 'A', POPT_ARG_NONE, NULL, OPT_LOOKUP_BY_IP, 
311                   "Do a node status on <name> as an IP Address", NULL },
312
313                 { "case-sensitive", 0, POPT_ARG_NONE, NULL, OPT_CASE_SENSITIVE, 
314                   "Don't uppercase the name before sending", NULL },
315
316                 POPT_COMMON_SAMBA
317                 { 0, 0, 0, 0 }
318         };
319         
320         pc = poptGetContext("nmblookup", argc, argv, long_options, 
321                             POPT_CONTEXT_KEEP_FIRST);
322
323         poptSetOtherOptionHelp(pc, "<NODE> ...");
324
325         while ((opt = poptGetNextOpt(pc)) != -1) {
326                 switch(opt) {
327                 case OPT_BROADCAST_ADDRESS:
328                         options.broadcast_address = poptGetOptArg(pc);
329                         break;
330                 case OPT_UNICAST_ADDRESS:
331                         options.unicast_address = poptGetOptArg(pc);
332                         break;
333                 case OPT_FIND_MASTER:
334                         options.find_master = true;
335                         break;
336                 case OPT_WINS_LOOKUP:
337                         options.wins_lookup = true;
338                         break;
339                 case OPT_NODE_STATUS:
340                         options.node_status = true;
341                         break;
342                 case OPT_ROOT_PORT:
343                         options.root_port = true;
344                         break;
345                 case OPT_LOOKUP_BY_IP:
346                         options.lookup_by_ip = true;
347                         break;
348                 case OPT_CASE_SENSITIVE:
349                         options.case_sensitive = true;
350                         break;
351                 }
352         }
353
354         /* swallow argv[0] */
355         poptGetArg(pc);
356
357         if(!poptPeekArg(pc)) { 
358                 poptPrintUsage(pc, stderr, 0);
359                 exit(1);
360         }
361
362         load_interfaces(NULL, lp_interfaces(cmdline_lp_ctx), &ifaces);
363
364         ev = s4_event_context_init(talloc_autofree_context());
365
366         while (poptPeekArg(pc)) {
367                 const char *name = poptGetArg(pc);
368
369                 ret &= process_one(cmdline_lp_ctx, ev, ifaces, name, lp_nbt_port(cmdline_lp_ctx));
370         }
371
372         talloc_free(ev);
373
374         talloc_free(ifaces);
375
376         poptFreeContext(pc);
377
378         if (!ret) {
379                 return 1;
380         }
381
382         return 0;
383 }