?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3:smbd: change blocking.c to use fsp_fnum_dbg() for fsp->fnum logging.
[Samba/gebeck_regimport.git] / source3 / nmbd / nmbd_winsserver.c
blobff5fae70b1252d49f2849592cd9a13c5f5d5ae01
1 /*
2 Unix SMB/CIFS implementation.
3 NBT netbios routines and daemon - version 2
4
5 Copyright (C) Jeremy Allison 1994-2005
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>.
19
20 Converted to store WINS data in a tdb. Dec 2005. JRA.
21 */
22
23 #include "includes.h"
24 #include "system/filesys.h"
25 #include "nmbd/nmbd.h"
26 #include "util_tdb.h"
27
28 #define WINS_LIST "wins.dat"
29 #define WINS_VERSION 1
30 #define WINSDB_VERSION 1
31
32 /****************************************************************************
33 We don't store the NetBIOS scope in the wins.tdb. We key off the (utf8) netbios
34 name (65 bytes with the last byte being the name type).
35 *****************************************************************************/
36
37 TDB_CONTEXT *wins_tdb;
38
39 /****************************************************************************
40 Delete all the temporary name records on the in-memory linked list.
41 *****************************************************************************/
42
43 static void wins_delete_all_tmp_in_memory_records(void)
44 {
45 struct name_record *nr = NULL;
46 struct name_record *nrnext = NULL;
47
48 /* Delete all temporary name records on the wins subnet linked list. */
49 for( nr = wins_server_subnet->namelist; nr; nr = nrnext) {
50 nrnext = nr->next;
51 DLIST_REMOVE(wins_server_subnet->namelist, nr);
52 SAFE_FREE(nr->data.ip);
53 SAFE_FREE(nr);
54 }
55 }
56
57 /****************************************************************************
58 Delete all the temporary 1b name records on the in-memory linked list.
59 *****************************************************************************/
60
61 static void wins_delete_all_1b_in_memory_records(void)
62 {
63 struct name_record *nr = NULL;
64 struct name_record *nrnext = NULL;
65
66 /* Delete all temporary 1b name records on the wins subnet linked list. */
67 for( nr = wins_server_subnet->namelist; nr; nr = nrnext) {
68 nrnext = nr->next;
69 if (nr->name.name_type == 0x1b) {
70 DLIST_REMOVE(wins_server_subnet->namelist, nr);
71 SAFE_FREE(nr->data.ip);
72 SAFE_FREE(nr);
73 }
74 }
75 }
76
77 /****************************************************************************
78 Convert a wins.tdb record to a struct name_record. Add in our lp_netbios_scope().
79 *****************************************************************************/
80
81 static struct name_record *wins_record_to_name_record(TDB_DATA key, TDB_DATA data)
82 {
83 struct name_record *namerec = NULL;
84 uint16 nb_flags;
85 unsigned char nr_src;
86 uint32 death_time, refresh_time;
87 uint32 id_low, id_high;
88 uint32 saddr;
89 uint32 wins_flags;
90 uint32 num_ips;
91 size_t len;
92 int i;
93
94 if (data.dptr == NULL || data.dsize == 0) {
95 return NULL;
96 }
97
98 /* Min size is "wbddddddd" + 1 ip address (4). */
99 if (data.dsize < 2 + 1 + (7*4) + 4) {
100 return NULL;
101 }
102
103 len = tdb_unpack(data.dptr, data.dsize,
104 "wbddddddd",
105 &nb_flags,
106 &nr_src,
107 &death_time,
108 &refresh_time,
109 &id_low,
110 &id_high,
111 &saddr,
112 &wins_flags,
113 &num_ips );
114
115 namerec = SMB_MALLOC_P(struct name_record);
116 if (!namerec) {
117 return NULL;
118 }
119 ZERO_STRUCTP(namerec);
120
121 namerec->data.ip = SMB_MALLOC_ARRAY(struct in_addr, num_ips);
122 if (!namerec->data.ip) {
123 SAFE_FREE(namerec);
124 return NULL;
125 }
126
127 namerec->subnet = wins_server_subnet;
128 push_ascii_nstring(namerec->name.name, (const char *)key.dptr);
129 namerec->name.name_type = key.dptr[sizeof(unstring)];
130 /* Add the scope. */
131 push_ascii(namerec->name.scope, lp_netbios_scope(), 64, STR_TERMINATE);
132
133 /* We're using a byte-by-byte compare, so we must be sure that
134 * unused space doesn't have garbage in it.
135 */
136
137 for( i = strlen( namerec->name.name ); i < sizeof( namerec->name.name ); i++ ) {
138 namerec->name.name[i] = '\0';
139 }
140 for( i = strlen( namerec->name.scope ); i < sizeof( namerec->name.scope ); i++ ) {
141 namerec->name.scope[i] = '\0';
142 }
143
144 namerec->data.nb_flags = nb_flags;
145 namerec->data.source = (enum name_source)nr_src;
146 namerec->data.death_time = (time_t)death_time;
147 namerec->data.refresh_time = (time_t)refresh_time;
148 namerec->data.id = id_low;
149 #if defined(HAVE_LONGLONG)
150 namerec->data.id |= ((uint64_t)id_high << 32);
151 #endif
152 namerec->data.wins_ip.s_addr = saddr;
153 namerec->data.wins_flags = wins_flags,
154 namerec->data.num_ips = num_ips;
155
156 for (i = 0; i < num_ips; i++) {
157 namerec->data.ip[i].s_addr = IVAL(data.dptr, len + (i*4));
158 }
159
160 return namerec;
161 }
162
163 /****************************************************************************
164 Convert a struct name_record to a wins.tdb record. Ignore the scope.
165 *****************************************************************************/
166
167 static TDB_DATA name_record_to_wins_record(const struct name_record *namerec)
168 {
169 TDB_DATA data;
170 size_t len = 0;
171 int i;
172 uint32 id_low = (namerec->data.id & 0xFFFFFFFF);
173 #if defined(HAVE_LONGLONG)
174 uint32 id_high = (namerec->data.id >> 32) & 0xFFFFFFFF;
175 #else
176 uint32 id_high = 0;
177 #endif
178
179 ZERO_STRUCT(data);
180
181 len = (2 + 1 + (7*4)); /* "wbddddddd" */
182 len += (namerec->data.num_ips * 4);
183
184 data.dptr = (uint8 *)SMB_MALLOC(len);
185 if (!data.dptr) {
186 return data;
187 }
188 data.dsize = len;
189
190 len = tdb_pack(data.dptr, data.dsize, "wbddddddd",
191 namerec->data.nb_flags,
192 (unsigned char)namerec->data.source,
193 (uint32)namerec->data.death_time,
194 (uint32)namerec->data.refresh_time,
195 id_low,
196 id_high,
197 (uint32)namerec->data.wins_ip.s_addr,
198 (uint32)namerec->data.wins_flags,
199 (uint32)namerec->data.num_ips );
200
201 for (i = 0; i < namerec->data.num_ips; i++) {
202 SIVAL(data.dptr, len + (i*4), namerec->data.ip[i].s_addr);
203 }
204
205 return data;
206 }
207
208 /****************************************************************************
209 Create key. Key is UNIX codepage namestring (usually utf8 64 byte len) with 1 byte type.
210 *****************************************************************************/
211
212 static TDB_DATA name_to_key(const struct nmb_name *nmbname)
213 {
214 static char keydata[sizeof(unstring) + 1];
215 TDB_DATA key;
216
217 memset(keydata, '\0', sizeof(keydata));
218
219 pull_ascii_nstring(keydata, sizeof(unstring), nmbname->name);
220 strupper_m(keydata);
221 keydata[sizeof(unstring)] = nmbname->name_type;
222 key.dptr = (uint8 *)keydata;
223 key.dsize = sizeof(keydata);
224
225 return key;
226 }
227
228 /****************************************************************************
229 Lookup a given name in the wins.tdb and create a temporary malloc'ed data struct
230 on the linked list. We will free this later in XXXX().
231 *****************************************************************************/
232
233 struct name_record *find_name_on_wins_subnet(const struct nmb_name *nmbname, bool self_only)
234 {
235 TDB_DATA data, key;
236 struct name_record *nr = NULL;
237 struct name_record *namerec = NULL;
238
239 if (!wins_tdb) {
240 return NULL;
241 }
242
243 key = name_to_key(nmbname);
244 data = tdb_fetch_compat(wins_tdb, key);
245
246 if (data.dsize == 0) {
247 return NULL;
248 }
249
250 namerec = wins_record_to_name_record(key, data);
251
252 /* done with the this */
253
254 SAFE_FREE( data.dptr );
255
256 if (!namerec) {
257 return NULL;
258 }
259
260 /* Self names only - these include permanent names. */
261 if( self_only && (namerec->data.source != SELF_NAME) && (namerec->data.source != PERMANENT_NAME) ) {
262 DEBUG( 9, ( "find_name_on_wins_subnet: self name %s NOT FOUND\n", nmb_namestr(nmbname) ) );
263 SAFE_FREE(namerec->data.ip);
264 SAFE_FREE(namerec);
265 return NULL;
266 }
267
268 /* Search for this name record on the list. Replace it if found. */
269
270 for( nr = wins_server_subnet->namelist; nr; nr = nr->next) {
271 if (memcmp(nmbname->name, nr->name.name, 16) == 0) {
272 /* Delete it. */
273 DLIST_REMOVE(wins_server_subnet->namelist, nr);
274 SAFE_FREE(nr->data.ip);
275 SAFE_FREE(nr);
276 break;
277 }
278 }
279
280 DLIST_ADD(wins_server_subnet->namelist, namerec);
281 return namerec;
282 }
283
284 /****************************************************************************
285 Overwrite or add a given name in the wins.tdb.
286 *****************************************************************************/
287
288 static bool store_or_replace_wins_namerec(const struct name_record *namerec, int tdb_flag)
289 {
290 TDB_DATA key, data;
291 int ret;
292
293 if (!wins_tdb) {
294 return False;
295 }
296
297 key = name_to_key(&namerec->name);
298 data = name_record_to_wins_record(namerec);
299
300 if (data.dptr == NULL) {
301 return False;
302 }
303
304 ret = tdb_store(wins_tdb, key, data, tdb_flag);
305
306 SAFE_FREE(data.dptr);
307 return (ret == 0) ? True : False;
308 }
309
310 /****************************************************************************
311 Overwrite a given name in the wins.tdb.
312 *****************************************************************************/
313
314 bool wins_store_changed_namerec(const struct name_record *namerec)
315 {
316 return store_or_replace_wins_namerec(namerec, TDB_REPLACE);
317 }
318
319 /****************************************************************************
320 Primary interface into creating and overwriting records in the wins.tdb.
321 *****************************************************************************/
322
323 bool add_name_to_wins_subnet(const struct name_record *namerec)
324 {
325 return store_or_replace_wins_namerec(namerec, TDB_INSERT);
326 }
327
328 /****************************************************************************
329 Delete a given name in the tdb and remove the temporary malloc'ed data struct
330 on the linked list.
331 *****************************************************************************/
332
333 bool remove_name_from_wins_namelist(struct name_record *namerec)
334 {
335 TDB_DATA key;
336 int ret;
337
338 if (!wins_tdb) {
339 return False;
340 }
341
342 key = name_to_key(&namerec->name);
343 ret = tdb_delete(wins_tdb, key);
344
345 DLIST_REMOVE(wins_server_subnet->namelist, namerec);
346
347 /* namerec must be freed by the caller */
348
349 return (ret == 0) ? True : False;
350 }
351
352 /****************************************************************************
353 Dump out the complete namelist.
354 *****************************************************************************/
355
356 static int traverse_fn(TDB_CONTEXT *tdb, TDB_DATA kbuf, TDB_DATA dbuf, void *state)
357 {
358 struct name_record *namerec = NULL;
359 XFILE *fp = (XFILE *)state;
360
361 if (kbuf.dsize != sizeof(unstring) + 1) {
362 return 0;
363 }
364
365 namerec = wins_record_to_name_record(kbuf, dbuf);
366 if (!namerec) {
367 return 0;
368 }
369
370 dump_name_record(namerec, fp);
371
372 SAFE_FREE(namerec->data.ip);
373 SAFE_FREE(namerec);
374 return 0;
375 }
376
377 void dump_wins_subnet_namelist(XFILE *fp)
378 {
379 tdb_traverse(wins_tdb, traverse_fn, (void *)fp);
380 }
381
382 /****************************************************************************
383 Change the wins owner address in the record.
384 *****************************************************************************/
385
386 static void update_wins_owner(struct name_record *namerec, struct in_addr wins_ip)
387 {
388 namerec->data.wins_ip=wins_ip;
389 }
390
391 /****************************************************************************
392 Create the wins flags based on the nb flags and the input value.
393 *****************************************************************************/
394
395 static void update_wins_flag(struct name_record *namerec, int flags)
396 {
397 namerec->data.wins_flags=0x0;
398
399 /* if it's a group, it can be a normal or a special one */
400 if (namerec->data.nb_flags & NB_GROUP) {
401 if (namerec->name.name_type==0x1C) {
402 namerec->data.wins_flags|=WINS_SGROUP;
403 } else {
404 if (namerec->data.num_ips>1) {
405 namerec->data.wins_flags|=WINS_SGROUP;
406 } else {
407 namerec->data.wins_flags|=WINS_NGROUP;
408 }
409 }
410 } else {
411 /* can be unique or multi-homed */
412 if (namerec->data.num_ips>1) {
413 namerec->data.wins_flags|=WINS_MHOMED;
414 } else {
415 namerec->data.wins_flags|=WINS_UNIQUE;
416 }
417 }
418
419 /* the node type are the same bits */
420 namerec->data.wins_flags|=namerec->data.nb_flags&NB_NODETYPEMASK;
421
422 /* the static bit is elsewhere */
423 if (namerec->data.death_time == PERMANENT_TTL) {
424 namerec->data.wins_flags|=WINS_STATIC;
425 }
426
427 /* and add the given bits */
428 namerec->data.wins_flags|=flags;
429
430 DEBUG(8,("update_wins_flag: nbflags: 0x%x, ttl: %d, flags: 0x%x, winsflags: 0x%x\n",
431 namerec->data.nb_flags, (int)namerec->data.death_time, flags, namerec->data.wins_flags));
432 }
433
434 /****************************************************************************
435 Return the general ID value and increase it if requested.
436 *****************************************************************************/
437
438 static void get_global_id_and_update(uint64_t *current_id, bool update)
439 {
440 /*
441 * it's kept as a static here, to prevent people from messing
442 * with the value directly
443 */
444
445 static uint64_t general_id = 1;
446
447 DEBUG(5,("get_global_id_and_update: updating version ID: %d\n", (int)general_id));
448
449 *current_id = general_id;
450
451 if (update) {
452 general_id++;
453 }
454 }
455
456 /****************************************************************************
457 Possibly call the WINS hook external program when a WINS change is made.
458 Also stores the changed record back in the wins_tdb.
459 *****************************************************************************/
460
461 static void wins_hook(const char *operation, struct name_record *namerec, int ttl)
462 {
463 char *command = NULL;
464 char *cmd = lp_wins_hook();
465 char *p, *namestr;
466 int i;
467 TALLOC_CTX *ctx = talloc_tos();
468
469 wins_store_changed_namerec(namerec);
470
471 if (!cmd || !*cmd) {
472 return;
473 }
474
475 for (p=namerec->name.name; *p; p++) {
476 if (!(isalnum((int)*p) || strchr_m("._-",*p))) {
477 DEBUG(3,("not calling wins hook for invalid name %s\n", nmb_namestr(&namerec->name)));
478 return;
479 }
480 }
481
482 /* Use the name without the nametype (and scope) appended */
483
484 namestr = nmb_namestr(&namerec->name);
485 if ((p = strchr(namestr, '<'))) {
486 *p = 0;
487 }
488
489 command = talloc_asprintf(ctx,
490 "%s %s %s %02x %d",
491 cmd,
492 operation,
493 namestr,
494 namerec->name.name_type,
495 ttl);
496 if (!command) {
497 return;
498 }
499
500 for (i=0;i<namerec->data.num_ips;i++) {
501 command = talloc_asprintf_append(command,
502 " %s",
503 inet_ntoa(namerec->data.ip[i]));
504 if (!command) {
505 return;
506 }
507 }
508
509 DEBUG(3,("calling wins hook for %s\n", nmb_namestr(&namerec->name)));
510 smbrun(command, NULL);
511 TALLOC_FREE(command);
512 }
513
514 /****************************************************************************
515 Determine if this packet should be allocated to the WINS server.
516 *****************************************************************************/
517
518 bool packet_is_for_wins_server(struct packet_struct *packet)
519 {
520 struct nmb_packet *nmb = &packet->packet.nmb;
521
522 /* Only unicast packets go to a WINS server. */
523 if((wins_server_subnet == NULL) || (nmb->header.nm_flags.bcast == True)) {
524 DEBUG(10, ("packet_is_for_wins_server: failing WINS test #1.\n"));
525 return False;
526 }
527
528 /* Check for node status requests. */
529 if (nmb->question.question_type != QUESTION_TYPE_NB_QUERY) {
530 return False;
531 }
532
533 switch(nmb->header.opcode) {
534 /*
535 * A WINS server issues WACKS, not receives them.
536 */
537 case NMB_WACK_OPCODE:
538 DEBUG(10, ("packet_is_for_wins_server: failing WINS test #2 (WACK).\n"));
539 return False;
540 /*
541 * A WINS server only processes registration and
542 * release requests, not responses.
543 */
544 case NMB_NAME_REG_OPCODE:
545 case NMB_NAME_MULTIHOMED_REG_OPCODE:
546 case NMB_NAME_REFRESH_OPCODE_8: /* ambiguity in rfc1002 about which is correct. */
547 case NMB_NAME_REFRESH_OPCODE_9: /* WinNT uses 8 by default. */
548 if(nmb->header.response) {
549 DEBUG(10, ("packet_is_for_wins_server: failing WINS test #3 (response = 1).\n"));
550 return False;
551 }
552 break;
553
554 case NMB_NAME_RELEASE_OPCODE:
555 if(nmb->header.response) {
556 DEBUG(10, ("packet_is_for_wins_server: failing WINS test #4 (response = 1).\n"));
557 return False;
558 }
559 break;
560
561 /*
562 * Only process unicast name queries with rd = 1.
563 */
564 case NMB_NAME_QUERY_OPCODE:
565 if(!nmb->header.response && !nmb->header.nm_flags.recursion_desired) {
566 DEBUG(10, ("packet_is_for_wins_server: failing WINS test #5 (response = 1).\n"));
567 return False;
568 }
569 break;
570 }
571
572 return True;
573 }
574
575 /****************************************************************************
576 Utility function to decide what ttl to give a register/refresh request.
577 *****************************************************************************/
578
579 static int get_ttl_from_packet(struct nmb_packet *nmb)
580 {
581 int ttl = nmb->additional->ttl;
582
583 if (ttl < lp_min_wins_ttl()) {
584 ttl = lp_min_wins_ttl();
585 }
586
587 if (ttl > lp_max_wins_ttl()) {
588 ttl = lp_max_wins_ttl();
589 }
590
591 return ttl;
592 }
593
594 /****************************************************************************
595 Load or create the WINS database.
596 *****************************************************************************/
597
598 bool initialise_wins(void)
599 {
600 time_t time_now = time(NULL);
601 XFILE *fp;
602 char line[1024];
603
604 if(!lp_we_are_a_wins_server()) {
605 return True;
606 }
607
608 /* Open the wins.tdb. */
609 wins_tdb = tdb_open_log(state_path("wins.tdb"), 0, TDB_DEFAULT|TDB_CLEAR_IF_FIRST|TDB_INCOMPATIBLE_HASH,
610 O_CREAT|O_RDWR, 0600);
611 if (!wins_tdb) {
612 DEBUG(0,("initialise_wins: failed to open wins.tdb. Error was %s\n",
613 strerror(errno) ));
614 return False;
615 }
616
617 tdb_store_int32(wins_tdb, "WINSDB_VERSION", WINSDB_VERSION);
618
619 add_samba_names_to_subnet(wins_server_subnet);
620
621 if((fp = x_fopen(state_path(WINS_LIST),O_RDONLY,0)) == NULL) {
622 DEBUG(2,("initialise_wins: Can't open wins database file %s. Error was %s\n",
623 WINS_LIST, strerror(errno) ));
624 return True;
625 }
626
627 while (!x_feof(fp)) {
628 char *name_str = NULL;
629 char *ip_str = NULL;
630 char *ttl_str = NULL, *nb_flags_str = NULL;
631 unsigned int num_ips;
632 char *name = NULL;
633 struct in_addr *ip_list = NULL;
634 int type = 0;
635 int nb_flags;
636 int ttl;
637 const char *ptr;
638 char *p = NULL;
639 bool got_token;
640 bool was_ip;
641 int i;
642 unsigned int hash;
643 int version;
644 TALLOC_CTX *frame = NULL;
645
646 /* Read a line from the wins.dat file. Strips whitespace
647 from the beginning and end of the line. */
648 if (!fgets_slash(line,sizeof(line),fp)) {
649 continue;
650 }
651
652 if (*line == '#') {
653 continue;
654 }
655
656 if (strncmp(line,"VERSION ", 8) == 0) {
657 if (sscanf(line,"VERSION %d %u", &version, &hash) != 2 ||
658 version != WINS_VERSION) {
659 DEBUG(0,("Discarding invalid wins.dat file [%s]\n",line));
660 x_fclose(fp);
661 return True;
662 }
663 continue;
664 }
665
666 ptr = line;
667
668 /*
669 * Now we handle multiple IP addresses per name we need
670 * to iterate over the line twice. The first time to
671 * determine how many IP addresses there are, the second
672 * time to actually parse them into the ip_list array.
673 */
674
675 frame = talloc_stackframe();
676 if (!next_token_talloc(frame,&ptr,&name_str,NULL)) {
677 DEBUG(0,("initialise_wins: Failed to parse name when parsing line %s\n", line ));
678 TALLOC_FREE(frame);
679 continue;
680 }
681
682 if (!next_token_talloc(frame,&ptr,&ttl_str,NULL)) {
683 DEBUG(0,("initialise_wins: Failed to parse time to live when parsing line %s\n", line ));
684 TALLOC_FREE(frame);
685 continue;
686 }
687
688 /*
689 * Determine the number of IP addresses per line.
690 */
691 num_ips = 0;
692 do {
693 got_token = next_token_talloc(frame,&ptr,&ip_str,NULL);
694 was_ip = False;
695
696 if(got_token && strchr(ip_str, '.')) {
697 num_ips++;
698 was_ip = True;
699 }
700 } while(got_token && was_ip);
701
702 if(num_ips == 0) {
703 DEBUG(0,("initialise_wins: Missing IP address when parsing line %s\n", line ));
704 TALLOC_FREE(frame);
705 continue;
706 }
707
708 if(!got_token) {
709 DEBUG(0,("initialise_wins: Missing nb_flags when parsing line %s\n", line ));
710 TALLOC_FREE(frame);
711 continue;
712 }
713
714 /* Allocate the space for the ip_list. */
715 if((ip_list = SMB_MALLOC_ARRAY( struct in_addr, num_ips)) == NULL) {
716 DEBUG(0,("initialise_wins: Malloc fail !\n"));
717 x_fclose(fp);
718 TALLOC_FREE(frame);
719 return False;
720 }
721
722 /* Reset and re-parse the line. */
723 ptr = line;
724 next_token_talloc(frame,&ptr,&name_str,NULL);
725 next_token_talloc(frame,&ptr,&ttl_str,NULL);
726 for(i = 0; i < num_ips; i++) {
727 next_token_talloc(frame,&ptr, &ip_str, NULL);
728 ip_list[i] = interpret_addr2(ip_str);
729 }
730 next_token_talloc(frame,&ptr,&nb_flags_str,NULL);
731
732 /*
733 * Deal with SELF or REGISTER name encoding. Default is REGISTER
734 * for compatibility with old nmbds.
735 */
736
737 if(nb_flags_str[strlen(nb_flags_str)-1] == 'S') {
738 DEBUG(5,("initialise_wins: Ignoring SELF name %s\n", line));
739 SAFE_FREE(ip_list);
740 TALLOC_FREE(frame);
741 continue;
742 }
743
744 if(nb_flags_str[strlen(nb_flags_str)-1] == 'R') {
745 nb_flags_str[strlen(nb_flags_str)-1] = '\0';
746 }
747
748 /* Netbios name. # divides the name from the type (hex): netbios#xx */
749 name = name_str;
750
751 if((p = strchr(name,'#')) != NULL) {
752 *p = 0;
753 sscanf(p+1,"%x",&type);
754 }
755
756 /* Decode the netbios flags (hex) and the time-to-live (in seconds). */
757 sscanf(nb_flags_str,"%x",&nb_flags);
758 sscanf(ttl_str,"%d",&ttl);
759
760 /* add all entries that have 60 seconds or more to live */
761 if ((ttl - 60) > time_now || ttl == PERMANENT_TTL) {
762 if(ttl != PERMANENT_TTL) {
763 ttl -= time_now;
764 }
765
766 DEBUG( 4, ("initialise_wins: add name: %s#%02x ttl = %d first IP %s flags = %2x\n",
767 name, type, ttl, inet_ntoa(ip_list[0]), nb_flags));
768
769 (void)add_name_to_subnet( wins_server_subnet, name, type, nb_flags,
770 ttl, REGISTER_NAME, num_ips, ip_list );
771 } else {
772 DEBUG(4, ("initialise_wins: not adding name (ttl problem) "
773 "%s#%02x ttl = %d first IP %s flags = %2x\n",
774 name, type, ttl, inet_ntoa(ip_list[0]), nb_flags));
775 }
776
777 TALLOC_FREE(frame);
778 SAFE_FREE(ip_list);
779 }
780
781 x_fclose(fp);
782 return True;
783 }
784
785 /****************************************************************************
786 Send a WINS WACK (Wait ACKnowledgement) response.
787 **************************************************************************/
788
789 static void send_wins_wack_response(int ttl, struct packet_struct *p)
790 {
791 struct nmb_packet *nmb = &p->packet.nmb;
792 unsigned char rdata[2];
793
794 rdata[0] = rdata[1] = 0;
795
796 /* Taken from nmblib.c - we need to send back almost
797 identical bytes from the requesting packet header. */
798
799 rdata[0] = (nmb->header.opcode & 0xF) << 3;
800 if (nmb->header.nm_flags.authoritative && nmb->header.response) {
801 rdata[0] |= 0x4;
802 }
803 if (nmb->header.nm_flags.trunc) {
804 rdata[0] |= 0x2;
805 }
806 if (nmb->header.nm_flags.recursion_desired) {
807 rdata[0] |= 0x1;
808 }
809 if (nmb->header.nm_flags.recursion_available && nmb->header.response) {
810 rdata[1] |= 0x80;
811 }
812 if (nmb->header.nm_flags.bcast) {
813 rdata[1] |= 0x10;
814 }
815
816 reply_netbios_packet(p, /* Packet to reply to. */
817 0, /* Result code. */
818 NMB_WAIT_ACK, /* nmbd type code. */
819 NMB_WACK_OPCODE, /* opcode. */
820 ttl, /* ttl. */
821 (char *)rdata, /* data to send. */
822 2); /* data length. */
823 }
824
825 /****************************************************************************
826 Send a WINS name registration response.
827 **************************************************************************/
828
829 static void send_wins_name_registration_response(int rcode, int ttl, struct packet_struct *p)
830 {
831 struct nmb_packet *nmb = &p->packet.nmb;
832 char rdata[6];
833
834 memcpy(&rdata[0], &nmb->additional->rdata[0], 6);
835
836 reply_netbios_packet(p, /* Packet to reply to. */
837 rcode, /* Result code. */
838 WINS_REG, /* nmbd type code. */
839 NMB_NAME_REG_OPCODE, /* opcode. */
840 ttl, /* ttl. */
841 rdata, /* data to send. */
842 6); /* data length. */
843 }
844
845 /***********************************************************************
846 Deal with a name refresh request to a WINS server.
847 ************************************************************************/
848
849 void wins_process_name_refresh_request( struct subnet_record *subrec,
850 struct packet_struct *p )
851 {
852 struct nmb_packet *nmb = &p->packet.nmb;
853 struct nmb_name *question = &nmb->question.question_name;
854 bool bcast = nmb->header.nm_flags.bcast;
855 uint16 nb_flags = get_nb_flags(nmb->additional->rdata);
856 bool group = (nb_flags & NB_GROUP) ? True : False;
857 struct name_record *namerec = NULL;
858 int ttl = get_ttl_from_packet(nmb);
859 struct in_addr from_ip;
860 struct in_addr our_fake_ip;
861
862 our_fake_ip = interpret_addr2("0.0.0.0");
863 putip( (char *)&from_ip, &nmb->additional->rdata[2] );
864
865 if(bcast) {
866 /*
867 * We should only get unicast name refresh packets here.
868 * Anyone trying to refresh broadcast should not be going
869 * to a WINS server. Log an error here.
870 */
871 if( DEBUGLVL( 0 ) ) {
872 dbgtext( "wins_process_name_refresh_request: " );
873 dbgtext( "Broadcast name refresh request received " );
874 dbgtext( "for name %s ", nmb_namestr(question) );
875 dbgtext( "from IP %s ", inet_ntoa(from_ip) );
876 dbgtext( "on subnet %s. ", subrec->subnet_name );
877 dbgtext( "Error - Broadcasts should not be sent " );
878 dbgtext( "to a WINS server\n" );
879 }
880 return;
881 }
882
883 if( DEBUGLVL( 3 ) ) {
884 dbgtext( "wins_process_name_refresh_request: " );
885 dbgtext( "Name refresh for name %s IP %s\n",
886 nmb_namestr(question), inet_ntoa(from_ip) );
887 }
888
889 /*
890 * See if the name already exists.
891 * If not, handle it as a name registration and return.
892 */
893 namerec = find_name_on_subnet(subrec, question, FIND_ANY_NAME);
894
895 /*
896 * If this is a refresh request and the name doesn't exist then
897 * treat it like a registration request. This allows us to recover
898 * from errors (tridge)
899 */
900 if(namerec == NULL) {
901 if( DEBUGLVL( 3 ) ) {
902 dbgtext( "wins_process_name_refresh_request: " );
903 dbgtext( "Name refresh for name %s ",
904 nmb_namestr( question ) );
905 dbgtext( "and the name does not exist. Treating " );
906 dbgtext( "as registration.\n" );
907 }
908 wins_process_name_registration_request(subrec,p);
909 return;
910 }
911
912 /*
913 * if the name is present but not active, simply remove it
914 * and treat the refresh request as a registration & return.
915 */
916 if (namerec != NULL && !WINS_STATE_ACTIVE(namerec)) {
917 if( DEBUGLVL( 5 ) ) {
918 dbgtext( "wins_process_name_refresh_request: " );
919 dbgtext( "Name (%s) in WINS ", nmb_namestr(question) );
920 dbgtext( "was not active - removing it.\n" );
921 }
922 remove_name_from_namelist( subrec, namerec );
923 namerec = NULL;
924 wins_process_name_registration_request( subrec, p );
925 return;
926 }
927
928 /*
929 * Check that the group bits for the refreshing name and the
930 * name in our database match. If not, refuse the refresh.
931 * [crh: Why RFS_ERR instead of ACT_ERR? Is this what MS does?]
932 */
933 if( (namerec != NULL) &&
934 ( (group && !NAME_GROUP(namerec))
935 || (!group && NAME_GROUP(namerec)) ) ) {
936 if( DEBUGLVL( 3 ) ) {
937 dbgtext( "wins_process_name_refresh_request: " );
938 dbgtext( "Name %s ", nmb_namestr(question) );
939 dbgtext( "group bit = %s does not match ",
940 group ? "True" : "False" );
941 dbgtext( "group bit in WINS for this name.\n" );
942 }
943 send_wins_name_registration_response(RFS_ERR, 0, p);
944 return;
945 }
946
947 /*
948 * For a unique name check that the person refreshing the name is
949 * one of the registered IP addresses. If not - fail the refresh.
950 * Do the same for group names with a type of 0x1c.
951 * Just return success for unique 0x1d refreshes. For normal group
952 * names update the ttl and return success.
953 */
954 if( (!group || (group && (question->name_type == 0x1c)))
955 && find_ip_in_name_record(namerec, from_ip) ) {
956 /*
957 * Update the ttl.
958 */
959 update_name_ttl(namerec, ttl);
960
961 /*
962 * if the record is a replica:
963 * we take ownership and update the version ID.
964 */
965 if (!ip_equal_v4(namerec->data.wins_ip, our_fake_ip)) {
966 update_wins_owner(namerec, our_fake_ip);
967 get_global_id_and_update(&namerec->data.id, True);
968 }
969
970 send_wins_name_registration_response(0, ttl, p);
971 wins_hook("refresh", namerec, ttl);
972 return;
973 } else if((group && (question->name_type == 0x1c))) {
974 /*
975 * Added by crh for bug #1079.
976 * Fix from Bert Driehuis
977 */
978 if( DEBUGLVL( 3 ) ) {
979 dbgtext( "wins_process_name_refresh_request: " );
980 dbgtext( "Name refresh for name %s, ",
981 nmb_namestr(question) );
982 dbgtext( "but IP address %s ", inet_ntoa(from_ip) );
983 dbgtext( "is not yet associated with " );
984 dbgtext( "that name. Treating as registration.\n" );
985 }
986 wins_process_name_registration_request(subrec,p);
987 return;
988 } else if(group) {
989 /*
990 * Normal groups are all registered with an IP address of
991 * 255.255.255.255 so we can't search for the IP address.
992 */
993 update_name_ttl(namerec, ttl);
994 wins_hook("refresh", namerec, ttl);
995 send_wins_name_registration_response(0, ttl, p);
996 return;
997 } else if(!group && (question->name_type == 0x1d)) {
998 /*
999 * Special name type - just pretend the refresh succeeded.
1000 */
1001 send_wins_name_registration_response(0, ttl, p);
1002 return;
1003 } else {
1004 /*
1005 * Fail the refresh.
1006 */
1007 if( DEBUGLVL( 3 ) ) {
1008 dbgtext( "wins_process_name_refresh_request: " );
1009 dbgtext( "Name refresh for name %s with IP %s ",
1010 nmb_namestr(question), inet_ntoa(from_ip) );
1011 dbgtext( "and is IP is not known to the name.\n" );
1012 }
1013 send_wins_name_registration_response(RFS_ERR, 0, p);
1014 return;
1015 }
1016 }
1017
1018 /***********************************************************************
1019 Deal with a name registration request query success to a client that
1020 owned the name.
1021
1022 We have a locked pointer to the original packet stashed away in the
1023 userdata pointer. The success here is actually a failure as it means
1024 the client we queried wants to keep the name, so we must return
1025 a registration failure to the original requestor.
1026 ************************************************************************/
1027
1028 static void wins_register_query_success(struct subnet_record *subrec,
1029 struct userdata_struct *userdata,
1030 struct nmb_name *question_name,
1031 struct in_addr ip,
1032 struct res_rec *answers)
1033 {
1034 struct packet_struct *orig_reg_packet;
1035
1036 memcpy((char *)&orig_reg_packet, userdata->data, sizeof(struct packet_struct *));
1037
1038 DEBUG(3,("wins_register_query_success: Original client at IP %s still wants the \
1039 name %s. Rejecting registration request.\n", inet_ntoa(ip), nmb_namestr(question_name) ));
1040
1041 send_wins_name_registration_response(RFS_ERR, 0, orig_reg_packet);
1042
1043 orig_reg_packet->locked = False;
1044 free_packet(orig_reg_packet);
1045 }
1046
1047 /***********************************************************************
1048 Deal with a name registration request query failure to a client that
1049 owned the name.
1050
1051 We have a locked pointer to the original packet stashed away in the
1052 userdata pointer. The failure here is actually a success as it means
1053 the client we queried didn't want to keep the name, so we can remove
1054 the old name record and then successfully add the new name.
1055 ************************************************************************/
1056
1057 static void wins_register_query_fail(struct subnet_record *subrec,
1058 struct response_record *rrec,
1059 struct nmb_name *question_name,
1060 int rcode)
1061 {
1062 struct userdata_struct *userdata = rrec->userdata;
1063 struct packet_struct *orig_reg_packet;
1064 struct name_record *namerec = NULL;
1065
1066 memcpy((char *)&orig_reg_packet, userdata->data, sizeof(struct packet_struct *));
1067
1068 /*
1069 * We want to just add the name, as we now know the original owner
1070 * didn't want it. But we can't just do that as an arbitary
1071 * amount of time may have taken place between the name query
1072 * request and this timeout/error response. So we check that
1073 * the name still exists and is in the same state - if so
1074 * we remove it and call wins_process_name_registration_request()
1075 * as we know it will do the right thing now.
1076 */
1077
1078 namerec = find_name_on_subnet(subrec, question_name, FIND_ANY_NAME);
1079
1080 if ((namerec != NULL) && (namerec->data.source == REGISTER_NAME) &&
1081 ip_equal_v4(rrec->packet->ip, *namerec->data.ip)) {
1082 remove_name_from_namelist( subrec, namerec);
1083 namerec = NULL;
1084 }
1085
1086 if(namerec == NULL) {
1087 wins_process_name_registration_request(subrec, orig_reg_packet);
1088 } else {
1089 DEBUG(2,("wins_register_query_fail: The state of the WINS database changed between "
1090 "querying for name %s in order to replace it and this reply.\n",
1091 nmb_namestr(question_name) ));
1092 }
1093
1094 orig_reg_packet->locked = False;
1095 free_packet(orig_reg_packet);
1096 }
1097
1098 /***********************************************************************
1099 Deal with a name registration request to a WINS server.
1100
1101 Use the following pseudocode :
1102
1103 registering_group
1104 |
1105 |
1106 +--------name exists
1107 | |
1108 | |
1109 | +--- existing name is group
1110 | | |
1111 | | |
1112 | | +--- add name (return).
1113 | |
1114 | |
1115 | +--- exiting name is unique
1116 | |
1117 | |
1118 | +--- query existing owner (return).
1119 |
1120 |
1121 +--------name doesn't exist
1122 |
1123 |
1124 +--- add name (return).
1125
1126 registering_unique
1127 |
1128 |
1129 +--------name exists
1130 | |
1131 | |
1132 | +--- existing name is group
1133 | | |
1134 | | |
1135 | | +--- fail add (return).
1136 | |
1137 | |
1138 | +--- exiting name is unique
1139 | |
1140 | |
1141 | +--- query existing owner (return).
1142 |
1143 |
1144 +--------name doesn't exist
1145 |
1146 |
1147 +--- add name (return).
1148
1149 As can be seen from the above, the two cases may be collapsed onto each
1150 other with the exception of the case where the name already exists and
1151 is a group name. This case we handle with an if statement.
1152
1153 ************************************************************************/
1154
1155 void wins_process_name_registration_request(struct subnet_record *subrec,
1156 struct packet_struct *p)
1157 {
1158 unstring name;
1159 struct nmb_packet *nmb = &p->packet.nmb;
1160 struct nmb_name *question = &nmb->question.question_name;
1161 bool bcast = nmb->header.nm_flags.bcast;
1162 uint16 nb_flags = get_nb_flags(nmb->additional->rdata);
1163 int ttl = get_ttl_from_packet(nmb);
1164 struct name_record *namerec = NULL;
1165 struct in_addr from_ip;
1166 bool registering_group_name = (nb_flags & NB_GROUP) ? True : False;
1167 struct in_addr our_fake_ip;
1168
1169 our_fake_ip = interpret_addr2("0.0.0.0");
1170 putip((char *)&from_ip,&nmb->additional->rdata[2]);
1171
1172 if(bcast) {
1173 /*
1174 * We should only get unicast name registration packets here.
1175 * Anyone trying to register broadcast should not be going to a WINS
1176 * server. Log an error here.
1177 */
1178
1179 DEBUG(0,("wins_process_name_registration_request: broadcast name registration request \
1180 received for name %s from IP %s on subnet %s. Error - should not be sent to WINS server\n",
1181 nmb_namestr(question), inet_ntoa(from_ip), subrec->subnet_name));
1182 return;
1183 }
1184
1185 DEBUG(3,("wins_process_name_registration_request: %s name registration for name %s \
1186 IP %s\n", registering_group_name ? "Group" : "Unique", nmb_namestr(question), inet_ntoa(from_ip) ));
1187
1188 /*
1189 * See if the name already exists.
1190 */
1191
1192 namerec = find_name_on_subnet(subrec, question, FIND_ANY_NAME);
1193
1194 /*
1195 * if the record exists but NOT in active state,
1196 * consider it dead.
1197 */
1198 if ( (namerec != NULL) && !WINS_STATE_ACTIVE(namerec)) {
1199 DEBUG(5,("wins_process_name_registration_request: Name (%s) in WINS was \
1200 not active - removing it.\n", nmb_namestr(question) ));
1201 remove_name_from_namelist( subrec, namerec );
1202 namerec = NULL;
1203 }
1204
1205 /*
1206 * Deal with the case where the name found was a dns entry.
1207 * Remove it as we now have a NetBIOS client registering the
1208 * name.
1209 */
1210
1211 if( (namerec != NULL) && ( (namerec->data.source == DNS_NAME) || (namerec->data.source == DNSFAIL_NAME) ) ) {
1212 DEBUG(5,("wins_process_name_registration_request: Name (%s) in WINS was \
1213 a dns lookup - removing it.\n", nmb_namestr(question) ));
1214 remove_name_from_namelist( subrec, namerec );
1215 namerec = NULL;
1216 }
1217
1218 /*
1219 * Reject if the name exists and is not a REGISTER_NAME.
1220 * (ie. Don't allow any static names to be overwritten.
1221 */
1222
1223 if((namerec != NULL) && (namerec->data.source != REGISTER_NAME)) {
1224 DEBUG( 3, ( "wins_process_name_registration_request: Attempt \
1225 to register name %s. Name already exists in WINS with source type %d.\n",
1226 nmb_namestr(question), namerec->data.source ));
1227 send_wins_name_registration_response(RFS_ERR, 0, p);
1228 return;
1229 }
1230
1231 /*
1232 * Special policy decisions based on MS documentation.
1233 * 1). All group names (except names ending in 0x1c) are added as 255.255.255.255.
1234 * 2). All unique names ending in 0x1d are ignored, although a positive response is sent.
1235 */
1236
1237 /*
1238 * A group name is always added as the local broadcast address, except
1239 * for group names ending in 0x1c.
1240 * Group names with type 0x1c are registered with individual IP addresses.
1241 */
1242
1243 if(registering_group_name && (question->name_type != 0x1c)) {
1244 from_ip = interpret_addr2("255.255.255.255");
1245 }
1246
1247 /*
1248 * Ignore all attempts to register a unique 0x1d name, although return success.
1249 */
1250
1251 if(!registering_group_name && (question->name_type == 0x1d)) {
1252 DEBUG(3,("wins_process_name_registration_request: Ignoring request \
1253 to register name %s from IP %s.\n", nmb_namestr(question), inet_ntoa(p->ip) ));
1254 send_wins_name_registration_response(0, ttl, p);
1255 return;
1256 }
1257
1258 /*
1259 * Next two cases are the 'if statement' mentioned above.
1260 */
1261
1262 if((namerec != NULL) && NAME_GROUP(namerec)) {
1263 if(registering_group_name) {
1264 /*
1265 * If we are adding a group name, the name exists and is also a group entry just add this
1266 * IP address to it and update the ttl.
1267 */
1268
1269 DEBUG(3,("wins_process_name_registration_request: Adding IP %s to group name %s.\n",
1270 inet_ntoa(from_ip), nmb_namestr(question) ));
1271
1272 /*
1273 * Check the ip address is not already in the group.
1274 */
1275
1276 if(!find_ip_in_name_record(namerec, from_ip)) {
1277 /*
1278 * Need to emulate the behaviour of Windows, as
1279 * described in:
1280 * http://lists.samba.org/archive/samba-technical/2001-October/016236.html
1281 * (is there an MS reference for this
1282 * somewhere?) because if the 1c list gets over
1283 * 86 entries, the reply packet is too big
1284 * (rdata>576 bytes) so no reply is sent.
1285 *
1286 * Keep only the "latest" 25 records, while
1287 * ensuring that the PDC (0x1b) is never removed
1288 * We do this by removing the first entry that
1289 * isn't the 1b entry for the same name,
1290 * on the grounds that insertion is at the end
1291 * of the list, so the oldest entries are at
1292 * the start.
1293 *
1294 */
1295 while(namerec->data.num_ips>=25) {
1296 struct name_record *name1brec = NULL;
1297
1298 /* We only do this for 1c types. */
1299 if (namerec->name.name_type != 0x1c) {
1300 break;
1301 }
1302 DEBUG(3,("wins_process_name_registration_request: "
1303 "More than 25 IPs already in "
1304 "the list. Looking for a 1b "
1305 "record\n"));
1306
1307 /* Ensure we have all the active 1b
1308 * names on the list. */
1309 wins_delete_all_1b_in_memory_records();
1310 fetch_all_active_wins_1b_names();
1311
1312 /* Per the above, find the 1b record,
1313 and then remove the first IP that isn't the same */
1314 for(name1brec = subrec->namelist;
1315 name1brec;
1316 name1brec = name1brec->next ) {
1317 if( WINS_STATE_ACTIVE(name1brec) &&
1318 name1brec->name.name_type == 0x1b) {
1319 DEBUG(3,("wins_process_name_registration_request: "
1320 "Found the #1b record "
1321 "with ip %s\n",
1322 inet_ntoa(name1brec->data.ip[0])));
1323 break;
1324 }
1325 }
1326 if(!name1brec) {
1327 DEBUG(3,("wins_process_name_registration_request: "
1328 "Didn't find a #1b name record. "
1329 "Removing the first available "
1330 "entry %s\n",
1331 inet_ntoa(namerec->data.ip[0])));
1332 remove_ip_from_name_record(namerec, namerec->data.ip[0]);
1333 wins_hook("delete", namerec, 0);
1334 } else {
1335 int i;
1336 for(i=0; i<namerec->data.num_ips; i++) {
1337 /* The name1brec should only have
1338 * the single IP address in it,
1339 * so we only check against the first one*/
1340 if(!ip_equal_v4( namerec->data.ip[i], name1brec->data.ip[0])) {
1341 /* The i'th entry isn't the 1b address; delete it */
1342 DEBUG(3,("wins_process_name_registration_request: "
1343 "Entry at %d is not the #1b address. "
1344 "About to remove it\n",
1345 i));
1346 remove_ip_from_name_record(namerec, namerec->data.ip[i]);
1347 wins_hook("delete", namerec, 0);
1348 break;
1349 }
1350 }
1351 }
1352 }
1353 /* The list is guaranteed to be < 25 entries now
1354 * - safe to add a new one */
1355 add_ip_to_name_record(namerec, from_ip);
1356 /* we need to update the record for replication */
1357 get_global_id_and_update(&namerec->data.id, True);
1358
1359 /*
1360 * if the record is a replica, we must change
1361 * the wins owner to us to make the replication updates
1362 * it on the other wins servers.
1363 * And when the partner will receive this record,
1364 * it will update its own record.
1365 */
1366
1367 update_wins_owner(namerec, our_fake_ip);
1368 }
1369 update_name_ttl(namerec, ttl);
1370 wins_hook("refresh", namerec, ttl);
1371 send_wins_name_registration_response(0, ttl, p);
1372 return;
1373 } else {
1374
1375 /*
1376 * If we are adding a unique name, the name exists in the WINS db
1377 * and is a group name then reject the registration.
1378 *
1379 * explanation: groups have a higher priority than unique names.
1380 */
1381
1382 DEBUG(3,("wins_process_name_registration_request: Attempt to register name %s. Name \
1383 already exists in WINS as a GROUP name.\n", nmb_namestr(question) ));
1384 send_wins_name_registration_response(RFS_ERR, 0, p);
1385 return;
1386 }
1387 }
1388
1389 /*
1390 * From here on down we know that if the name exists in the WINS db it is
1391 * a unique name, not a group name.
1392 */
1393
1394 /*
1395 * If the name exists and is one of our names then check the
1396 * registering IP address. If it's not one of ours then automatically
1397 * reject without doing the query - we know we will reject it.
1398 */
1399
1400 if ( namerec != NULL ) {
1401 pull_ascii_nstring(name, sizeof(name), namerec->name.name);
1402 if( is_myname(name) ) {
1403 if(!ismyip_v4(from_ip)) {
1404 DEBUG(3,("wins_process_name_registration_request: Attempt to register name %s. Name \
1405 is one of our (WINS server) names. Denying registration.\n", nmb_namestr(question) ));
1406 send_wins_name_registration_response(RFS_ERR, 0, p);
1407 return;
1408 } else {
1409 /*
1410 * It's one of our names and one of our IP's - update the ttl.
1411 */
1412 update_name_ttl(namerec, ttl);
1413 wins_hook("refresh", namerec, ttl);
1414 send_wins_name_registration_response(0, ttl, p);
1415 return;
1416 }
1417 }
1418 } else {
1419 name[0] = '\0';
1420 }
1421
1422 /*
1423 * If the name exists and it is a unique registration and the registering IP
1424 * is the same as the (single) already registered IP then just update the ttl.
1425 *
1426 * But not if the record is an active replica. IF it's a replica, it means it can be
1427 * the same client which has moved and not yet expired. So we don't update
1428 * the ttl in this case and go beyond to do a WACK and query the old client
1429 */
1430
1431 if( !registering_group_name
1432 && (namerec != NULL)
1433 && (namerec->data.num_ips == 1)
1434 && ip_equal_v4( namerec->data.ip[0], from_ip )
1435 && ip_equal_v4(namerec->data.wins_ip, our_fake_ip) ) {
1436 update_name_ttl( namerec, ttl );
1437 wins_hook("refresh", namerec, ttl);
1438 send_wins_name_registration_response( 0, ttl, p );
1439 return;
1440 }
1441
1442 /*
1443 * Finally if the name exists do a query to the registering machine
1444 * to see if they still claim to have the name.
1445 */
1446
1447 if( namerec != NULL ) {
1448 long *ud[(sizeof(struct userdata_struct) + sizeof(struct packet_struct *))/sizeof(long *) + 1];
1449 struct userdata_struct *userdata = (struct userdata_struct *)ud;
1450
1451 /*
1452 * First send a WACK to the registering machine.
1453 */
1454
1455 send_wins_wack_response(60, p);
1456
1457 /*
1458 * When the reply comes back we need the original packet.
1459 * Lock this so it won't be freed and then put it into
1460 * the userdata structure.
1461 */
1462
1463 p->locked = True;
1464
1465 userdata = (struct userdata_struct *)ud;
1466
1467 userdata->copy_fn = NULL;
1468 userdata->free_fn = NULL;
1469 userdata->userdata_len = sizeof(struct packet_struct *);
1470 memcpy(userdata->data, (char *)&p, sizeof(struct packet_struct *) );
1471
1472 /*
1473 * Use the new call to send a query directly to an IP address.
1474 * This sends the query directly to the IP address, and ensures
1475 * the recursion desired flag is not set (you were right Luke :-).
1476 * This function should *only* be called from the WINS server
1477 * code. JRA.
1478 */
1479
1480 pull_ascii_nstring(name, sizeof(name), question->name);
1481 query_name_from_wins_server( *namerec->data.ip,
1482 name,
1483 question->name_type,
1484 wins_register_query_success,
1485 wins_register_query_fail,
1486 userdata );
1487 return;
1488 }
1489
1490 /*
1491 * Name did not exist - add it.
1492 */
1493
1494 pull_ascii_nstring(name, sizeof(name), question->name);
1495 add_name_to_subnet( subrec, name, question->name_type,
1496 nb_flags, ttl, REGISTER_NAME, 1, &from_ip);
1497
1498 if ((namerec = find_name_on_subnet(subrec, question, FIND_ANY_NAME))) {
1499 get_global_id_and_update(&namerec->data.id, True);
1500 update_wins_owner(namerec, our_fake_ip);
1501 update_wins_flag(namerec, WINS_ACTIVE);
1502 wins_hook("add", namerec, ttl);
1503 }
1504
1505 send_wins_name_registration_response(0, ttl, p);
1506 }
1507
1508 /***********************************************************************
1509 Deal with a mutihomed name query success to the machine that
1510 requested the multihomed name registration.
1511
1512 We have a locked pointer to the original packet stashed away in the
1513 userdata pointer.
1514 ************************************************************************/
1515
1516 static void wins_multihomed_register_query_success(struct subnet_record *subrec,
1517 struct userdata_struct *userdata,
1518 struct nmb_name *question_name,
1519 struct in_addr ip,
1520 struct res_rec *answers)
1521 {
1522 struct packet_struct *orig_reg_packet;
1523 struct nmb_packet *nmb;
1524 struct name_record *namerec = NULL;
1525 struct in_addr from_ip;
1526 int ttl;
1527 struct in_addr our_fake_ip;
1528
1529 our_fake_ip = interpret_addr2("0.0.0.0");
1530 memcpy((char *)&orig_reg_packet, userdata->data, sizeof(struct packet_struct *));
1531
1532 nmb = &orig_reg_packet->packet.nmb;
1533
1534 putip((char *)&from_ip,&nmb->additional->rdata[2]);
1535 ttl = get_ttl_from_packet(nmb);
1536
1537 /*
1538 * We want to just add the new IP, as we now know the requesting
1539 * machine claims to own it. But we can't just do that as an arbitary
1540 * amount of time may have taken place between the name query
1541 * request and this response. So we check that
1542 * the name still exists and is in the same state - if so
1543 * we just add the extra IP and update the ttl.
1544 */
1545
1546 namerec = find_name_on_subnet(subrec, question_name, FIND_ANY_NAME);
1547
1548 if( (namerec == NULL) || (namerec->data.source != REGISTER_NAME) || !WINS_STATE_ACTIVE(namerec) ) {
1549 DEBUG(3,("wins_multihomed_register_query_success: name %s is not in the correct state to add \
1550 a subsequent IP address.\n", nmb_namestr(question_name) ));
1551 send_wins_name_registration_response(RFS_ERR, 0, orig_reg_packet);
1552
1553 orig_reg_packet->locked = False;
1554 free_packet(orig_reg_packet);
1555
1556 return;
1557 }
1558
1559 if(!find_ip_in_name_record(namerec, from_ip)) {
1560 add_ip_to_name_record(namerec, from_ip);
1561 }
1562
1563 get_global_id_and_update(&namerec->data.id, True);
1564 update_wins_owner(namerec, our_fake_ip);
1565 update_wins_flag(namerec, WINS_ACTIVE);
1566 update_name_ttl(namerec, ttl);
1567 wins_hook("add", namerec, ttl);
1568 send_wins_name_registration_response(0, ttl, orig_reg_packet);
1569
1570 orig_reg_packet->locked = False;
1571 free_packet(orig_reg_packet);
1572 }
1573
1574 /***********************************************************************
1575 Deal with a name registration request query failure to a client that
1576 owned the name.
1577
1578 We have a locked pointer to the original packet stashed away in the
1579 userdata pointer.
1580 ************************************************************************/
1581
1582 static void wins_multihomed_register_query_fail(struct subnet_record *subrec,
1583 struct response_record *rrec,
1584 struct nmb_name *question_name,
1585 int rcode)
1586 {
1587 struct userdata_struct *userdata = rrec->userdata;
1588 struct packet_struct *orig_reg_packet;
1589
1590 memcpy((char *)&orig_reg_packet, userdata->data, sizeof(struct packet_struct *));
1591
1592 DEBUG(3,("wins_multihomed_register_query_fail: Registering machine at IP %s failed to answer \
1593 query successfully for name %s.\n", inet_ntoa(orig_reg_packet->ip), nmb_namestr(question_name) ));
1594 send_wins_name_registration_response(RFS_ERR, 0, orig_reg_packet);
1595
1596 orig_reg_packet->locked = False;
1597 free_packet(orig_reg_packet);
1598 return;
1599 }
1600
1601 /***********************************************************************
1602 Deal with a multihomed name registration request to a WINS server.
1603 These cannot be group name registrations.
1604 ***********************************************************************/
1605
1606 void wins_process_multihomed_name_registration_request( struct subnet_record *subrec,
1607 struct packet_struct *p)
1608 {
1609 struct nmb_packet *nmb = &p->packet.nmb;
1610 struct nmb_name *question = &nmb->question.question_name;
1611 bool bcast = nmb->header.nm_flags.bcast;
1612 uint16 nb_flags = get_nb_flags(nmb->additional->rdata);
1613 int ttl = get_ttl_from_packet(nmb);
1614 struct name_record *namerec = NULL;
1615 struct in_addr from_ip;
1616 bool group = (nb_flags & NB_GROUP) ? True : False;
1617 struct in_addr our_fake_ip;
1618 unstring qname;
1619
1620 our_fake_ip = interpret_addr2("0.0.0.0");
1621 putip((char *)&from_ip,&nmb->additional->rdata[2]);
1622
1623 if(bcast) {
1624 /*
1625 * We should only get unicast name registration packets here.
1626 * Anyone trying to register broadcast should not be going to a WINS
1627 * server. Log an error here.
1628 */
1629
1630 DEBUG(0,("wins_process_multihomed_name_registration_request: broadcast name registration request \
1631 received for name %s from IP %s on subnet %s. Error - should not be sent to WINS server\n",
1632 nmb_namestr(question), inet_ntoa(from_ip), subrec->subnet_name));
1633 return;
1634 }
1635
1636 /*
1637 * Only unique names should be registered multihomed.
1638 */
1639
1640 if(group) {
1641 DEBUG(0,("wins_process_multihomed_name_registration_request: group name registration request \
1642 received for name %s from IP %s on subnet %s. Errror - group names should not be multihomed.\n",
1643 nmb_namestr(question), inet_ntoa(from_ip), subrec->subnet_name));
1644 return;
1645 }
1646
1647 DEBUG(3,("wins_process_multihomed_name_registration_request: name registration for name %s \
1648 IP %s\n", nmb_namestr(question), inet_ntoa(from_ip) ));
1649
1650 /*
1651 * Deal with policy regarding 0x1d names.
1652 */
1653
1654 if(question->name_type == 0x1d) {
1655 DEBUG(3,("wins_process_multihomed_name_registration_request: Ignoring request \
1656 to register name %s from IP %s.", nmb_namestr(question), inet_ntoa(p->ip) ));
1657 send_wins_name_registration_response(0, ttl, p);
1658 return;
1659 }
1660
1661 /*
1662 * See if the name already exists.
1663 */
1664
1665 namerec = find_name_on_subnet(subrec, question, FIND_ANY_NAME);
1666
1667 /*
1668 * if the record exists but NOT in active state,
1669 * consider it dead.
1670 */
1671
1672 if ((namerec != NULL) && !WINS_STATE_ACTIVE(namerec)) {
1673 DEBUG(5,("wins_process_multihomed_name_registration_request: Name (%s) in WINS was not active - removing it.\n", nmb_namestr(question)));
1674 remove_name_from_namelist(subrec, namerec);
1675 namerec = NULL;
1676 }
1677
1678 /*
1679 * Deal with the case where the name found was a dns entry.
1680 * Remove it as we now have a NetBIOS client registering the
1681 * name.
1682 */
1683
1684 if( (namerec != NULL) && ( (namerec->data.source == DNS_NAME) || (namerec->data.source == DNSFAIL_NAME) ) ) {
1685 DEBUG(5,("wins_process_multihomed_name_registration_request: Name (%s) in WINS was a dns lookup \
1686 - removing it.\n", nmb_namestr(question) ));
1687 remove_name_from_namelist( subrec, namerec);
1688 namerec = NULL;
1689 }
1690
1691 /*
1692 * Reject if the name exists and is not a REGISTER_NAME.
1693 * (ie. Don't allow any static names to be overwritten.
1694 */
1695
1696 if( (namerec != NULL) && (namerec->data.source != REGISTER_NAME) ) {
1697 DEBUG( 3, ( "wins_process_multihomed_name_registration_request: Attempt \
1698 to register name %s. Name already exists in WINS with source type %d.\n",
1699 nmb_namestr(question), namerec->data.source ));
1700 send_wins_name_registration_response(RFS_ERR, 0, p);
1701 return;
1702 }
1703
1704 /*
1705 * Reject if the name exists and is a GROUP name and is active.
1706 */
1707
1708 if((namerec != NULL) && NAME_GROUP(namerec) && WINS_STATE_ACTIVE(namerec)) {
1709 DEBUG(3,("wins_process_multihomed_name_registration_request: Attempt to register name %s. Name \
1710 already exists in WINS as a GROUP name.\n", nmb_namestr(question) ));
1711 send_wins_name_registration_response(RFS_ERR, 0, p);
1712 return;
1713 }
1714
1715 /*
1716 * From here on down we know that if the name exists in the WINS db it is
1717 * a unique name, not a group name.
1718 */
1719
1720 /*
1721 * If the name exists and is one of our names then check the
1722 * registering IP address. If it's not one of ours then automatically
1723 * reject without doing the query - we know we will reject it.
1724 */
1725
1726 if((namerec != NULL) && (is_myname(namerec->name.name)) ) {
1727 if(!ismyip_v4(from_ip)) {
1728 DEBUG(3,("wins_process_multihomed_name_registration_request: Attempt to register name %s. Name \
1729 is one of our (WINS server) names. Denying registration.\n", nmb_namestr(question) ));
1730 send_wins_name_registration_response(RFS_ERR, 0, p);
1731 return;
1732 } else {
1733 /*
1734 * It's one of our names and one of our IP's. Ensure the IP is in the record and
1735 * update the ttl. Update the version ID to force replication.
1736 */
1737 update_name_ttl(namerec, ttl);
1738
1739 if(!find_ip_in_name_record(namerec, from_ip)) {
1740 get_global_id_and_update(&namerec->data.id, True);
1741 update_wins_owner(namerec, our_fake_ip);
1742 update_wins_flag(namerec, WINS_ACTIVE);
1743
1744 add_ip_to_name_record(namerec, from_ip);
1745 }
1746
1747 wins_hook("refresh", namerec, ttl);
1748 send_wins_name_registration_response(0, ttl, p);
1749 return;
1750 }
1751 }
1752
1753 /*
1754 * If the name exists and is active, check if the IP address is already registered
1755 * to that name. If so then update the ttl and reply success.
1756 */
1757
1758 if((namerec != NULL) && find_ip_in_name_record(namerec, from_ip) && WINS_STATE_ACTIVE(namerec)) {
1759 update_name_ttl(namerec, ttl);
1760
1761 /*
1762 * If it's a replica, we need to become the wins owner
1763 * to force the replication
1764 */
1765 if (!ip_equal_v4(namerec->data.wins_ip, our_fake_ip)) {
1766 get_global_id_and_update(&namerec->data.id, True);
1767 update_wins_owner(namerec, our_fake_ip);
1768 update_wins_flag(namerec, WINS_ACTIVE);
1769 }
1770
1771 wins_hook("refresh", namerec, ttl);
1772 send_wins_name_registration_response(0, ttl, p);
1773 return;
1774 }
1775
1776 /*
1777 * If the name exists do a query to the owner
1778 * to see if they still want the name.
1779 */
1780
1781 if(namerec != NULL) {
1782 long *ud[(sizeof(struct userdata_struct) + sizeof(struct packet_struct *))/sizeof(long *) + 1];
1783 struct userdata_struct *userdata = (struct userdata_struct *)ud;
1784
1785 /*
1786 * First send a WACK to the registering machine.
1787 */
1788
1789 send_wins_wack_response(60, p);
1790
1791 /*
1792 * When the reply comes back we need the original packet.
1793 * Lock this so it won't be freed and then put it into
1794 * the userdata structure.
1795 */
1796
1797 p->locked = True;
1798
1799 userdata = (struct userdata_struct *)ud;
1800
1801 userdata->copy_fn = NULL;
1802 userdata->free_fn = NULL;
1803 userdata->userdata_len = sizeof(struct packet_struct *);
1804 memcpy(userdata->data, (char *)&p, sizeof(struct packet_struct *) );
1805
1806 /*
1807 * Use the new call to send a query directly to an IP address.
1808 * This sends the query directly to the IP address, and ensures
1809 * the recursion desired flag is not set (you were right Luke :-).
1810 * This function should *only* be called from the WINS server
1811 * code. JRA.
1812 *
1813 * Note that this packet is sent to the current owner of the name,
1814 * not the person who sent the packet
1815 */
1816
1817 pull_ascii_nstring( qname, sizeof(qname), question->name);
1818 query_name_from_wins_server( namerec->data.ip[0],
1819 qname,
1820 question->name_type,
1821 wins_multihomed_register_query_success,
1822 wins_multihomed_register_query_fail,
1823 userdata );
1824
1825 return;
1826 }
1827
1828 /*
1829 * Name did not exist - add it.
1830 */
1831
1832 pull_ascii_nstring( qname, sizeof(qname), question->name);
1833 add_name_to_subnet( subrec, qname, question->name_type,
1834 nb_flags, ttl, REGISTER_NAME, 1, &from_ip);
1835
1836 if ((namerec = find_name_on_subnet(subrec, question, FIND_ANY_NAME))) {
1837 get_global_id_and_update(&namerec->data.id, True);
1838 update_wins_owner(namerec, our_fake_ip);
1839 update_wins_flag(namerec, WINS_ACTIVE);
1840 wins_hook("add", namerec, ttl);
1841 }
1842
1843 send_wins_name_registration_response(0, ttl, p);
1844 }
1845
1846 /***********************************************************************
1847 Fetch all *<1b> names from the WINS db and store on the namelist.
1848 ***********************************************************************/
1849
1850 static int fetch_1b_traverse_fn(TDB_CONTEXT *tdb, TDB_DATA kbuf, TDB_DATA dbuf, void *state)
1851 {
1852 struct name_record *namerec = NULL;
1853
1854 if (kbuf.dsize != sizeof(unstring) + 1) {
1855 return 0;
1856 }
1857
1858 /* Filter out all non-1b names. */
1859 if (kbuf.dptr[sizeof(unstring)] != 0x1b) {
1860 return 0;
1861 }
1862
1863 namerec = wins_record_to_name_record(kbuf, dbuf);
1864 if (!namerec) {
1865 return 0;
1866 }
1867
1868 DLIST_ADD(wins_server_subnet->namelist, namerec);
1869 return 0;
1870 }
1871
1872 void fetch_all_active_wins_1b_names(void)
1873 {
1874 tdb_traverse(wins_tdb, fetch_1b_traverse_fn, NULL);
1875 }
1876
1877 /***********************************************************************
1878 Deal with the special name query for *<1b>.
1879 ***********************************************************************/
1880
1881 static void process_wins_dmb_query_request(struct subnet_record *subrec,
1882 struct packet_struct *p)
1883 {
1884 struct name_record *namerec = NULL;
1885 char *prdata;
1886 int num_ips;
1887
1888 /*
1889 * Go through all the ACTIVE names in the WINS db looking for those
1890 * ending in <1b>. Use this to calculate the number of IP
1891 * addresses we need to return.
1892 */
1893
1894 num_ips = 0;
1895
1896 /* First, clear the in memory list - we're going to re-populate
1897 it with the tdb_traversal in fetch_all_active_wins_1b_names. */
1898
1899 wins_delete_all_tmp_in_memory_records();
1900
1901 fetch_all_active_wins_1b_names();
1902
1903 for( namerec = subrec->namelist; namerec; namerec = namerec->next ) {
1904 if( WINS_STATE_ACTIVE(namerec) && namerec->name.name_type == 0x1b) {
1905 num_ips += namerec->data.num_ips;
1906 }
1907 }
1908
1909 if(num_ips == 0) {
1910 /*
1911 * There are no 0x1b names registered. Return name query fail.
1912 */
1913 send_wins_name_query_response(NAM_ERR, p, NULL);
1914 return;
1915 }
1916
1917 if((prdata = (char *)SMB_MALLOC( num_ips * 6 )) == NULL) {
1918 DEBUG(0,("process_wins_dmb_query_request: Malloc fail !.\n"));
1919 return;
1920 }
1921
1922 /*
1923 * Go through all the names again in the WINS db looking for those
1924 * ending in <1b>. Add their IP addresses into the list we will
1925 * return.
1926 */
1927
1928 num_ips = 0;
1929 for( namerec = subrec->namelist; namerec; namerec = namerec->next ) {
1930 if( WINS_STATE_ACTIVE(namerec) && namerec->name.name_type == 0x1b) {
1931 int i;
1932 for(i = 0; i < namerec->data.num_ips; i++) {
1933 set_nb_flags(&prdata[num_ips * 6],namerec->data.nb_flags);
1934 putip((char *)&prdata[(num_ips * 6) + 2], &namerec->data.ip[i]);
1935 num_ips++;
1936 }
1937 }
1938 }
1939
1940 /*
1941 * Send back the reply containing the IP list.
1942 */
1943
1944 reply_netbios_packet(p, /* Packet to reply to. */
1945 0, /* Result code. */
1946 WINS_QUERY, /* nmbd type code. */
1947 NMB_NAME_QUERY_OPCODE, /* opcode. */
1948 lp_min_wins_ttl(), /* ttl. */
1949 prdata, /* data to send. */
1950 num_ips*6); /* data length. */
1951
1952 SAFE_FREE(prdata);
1953 }
1954
1955 /****************************************************************************
1956 Send a WINS name query response.
1957 **************************************************************************/
1958
1959 void send_wins_name_query_response(int rcode, struct packet_struct *p,
1960 struct name_record *namerec)
1961 {
1962 char rdata[6];
1963 char *prdata = rdata;
1964 int reply_data_len = 0;
1965 int ttl = 0;
1966 int i;
1967
1968 memset(rdata,'\0',6);
1969
1970 if(rcode == 0) {
1971
1972 int ip_count;
1973
1974 ttl = (namerec->data.death_time != PERMANENT_TTL) ? namerec->data.death_time - p->timestamp : lp_max_wins_ttl();
1975
1976 /* The netbios reply packet data section is limited to 576 bytes. In theory
1977 * this should give us space for 96 addresses, but in practice, 86 appears
1978 * to be the max (don't know why). If we send any more than that,
1979 * reply_netbios_packet will fail to send a reply to avoid a memcpy buffer
1980 * overflow. Keep the count to 85 and it will be ok */
1981 ip_count=namerec->data.num_ips;
1982 if(ip_count>85) {
1983 ip_count=85;
1984 }
1985
1986 /* Copy all known ip addresses into the return data. */
1987 /* Optimise for the common case of one IP address so we don't need a malloc. */
1988
1989 if( ip_count == 1 ) {
1990 prdata = rdata;
1991 } else {
1992 if((prdata = (char *)SMB_MALLOC( ip_count * 6 )) == NULL) {
1993 DEBUG(0,("send_wins_name_query_response: malloc fail !\n"));
1994 return;
1995 }
1996 }
1997
1998 for(i = 0; i < ip_count; i++) {
1999 set_nb_flags(&prdata[i*6],namerec->data.nb_flags);
2000 putip((char *)&prdata[2+(i*6)], &namerec->data.ip[i]);
2001 }
2002
2003 sort_query_replies(prdata, i, p->ip);
2004 reply_data_len = ip_count * 6;
2005 }
2006
2007 reply_netbios_packet(p, /* Packet to reply to. */
2008 rcode, /* Result code. */
2009 WINS_QUERY, /* nmbd type code. */
2010 NMB_NAME_QUERY_OPCODE, /* opcode. */
2011 ttl, /* ttl. */
2012 prdata, /* data to send. */
2013 reply_data_len); /* data length. */
2014
2015 if(prdata != rdata) {
2016 SAFE_FREE(prdata);
2017 }
2018 }
2019
2020 /***********************************************************************
2021 Deal with a name query.
2022 ***********************************************************************/
2023
2024 void wins_process_name_query_request(struct subnet_record *subrec,
2025 struct packet_struct *p)
2026 {
2027 struct nmb_packet *nmb = &p->packet.nmb;
2028 struct nmb_name *question = &nmb->question.question_name;
2029 struct name_record *namerec = NULL;
2030 unstring qname;
2031
2032 DEBUG(3,("wins_process_name_query: name query for name %s from IP %s\n",
2033 nmb_namestr(question), inet_ntoa(p->ip) ));
2034
2035 /*
2036 * Special name code. If the queried name is *<1b> then search
2037 * the entire WINS database and return a list of all the IP addresses
2038 * registered to any <1b> name. This is to allow domain master browsers
2039 * to discover other domains that may not have a presence on their subnet.
2040 */
2041
2042 pull_ascii_nstring(qname, sizeof(qname), question->name);
2043 if(strequal( qname, "*") && (question->name_type == 0x1b)) {
2044 process_wins_dmb_query_request( subrec, p);
2045 return;
2046 }
2047
2048 namerec = find_name_on_subnet(subrec, question, FIND_ANY_NAME);
2049
2050 if(namerec != NULL) {
2051 /*
2052 * If the name is not anymore in active state then reply not found.
2053 * it's fair even if we keep it in the cache for days.
2054 */
2055 if (!WINS_STATE_ACTIVE(namerec)) {
2056 DEBUG(3,("wins_process_name_query: name query for name %s - name expired. Returning fail.\n",
2057 nmb_namestr(question) ));
2058 send_wins_name_query_response(NAM_ERR, p, namerec);
2059 return;
2060 }
2061
2062 /*
2063 * If it's a DNSFAIL_NAME then reply name not found.
2064 */
2065
2066 if( namerec->data.source == DNSFAIL_NAME ) {
2067 DEBUG(3,("wins_process_name_query: name query for name %s returning DNS fail.\n",
2068 nmb_namestr(question) ));
2069 send_wins_name_query_response(NAM_ERR, p, namerec);
2070 return;
2071 }
2072
2073 /*
2074 * If the name has expired then reply name not found.
2075 */
2076
2077 if( (namerec->data.death_time != PERMANENT_TTL) && (namerec->data.death_time < p->timestamp) ) {
2078 DEBUG(3,("wins_process_name_query: name query for name %s - name expired. Returning fail.\n",
2079 nmb_namestr(question) ));
2080 send_wins_name_query_response(NAM_ERR, p, namerec);
2081 return;
2082 }
2083
2084 DEBUG(3,("wins_process_name_query: name query for name %s returning first IP %s.\n",
2085 nmb_namestr(question), inet_ntoa(namerec->data.ip[0]) ));
2086
2087 send_wins_name_query_response(0, p, namerec);
2088 return;
2089 }
2090
2091 /*
2092 * Name not found in WINS - try a dns query if it's a 0x20 name.
2093 */
2094
2095 if(lp_wins_dns_proxy() && ((question->name_type == 0x20) || question->name_type == 0)) {
2096 DEBUG(3,("wins_process_name_query: name query for name %s not found - doing dns lookup.\n",
2097 nmb_namestr(question) ));
2098
2099 queue_dns_query(p, question);
2100 return;
2101 }
2102
2103 /*
2104 * Name not found - return error.
2105 */
2106
2107 send_wins_name_query_response(NAM_ERR, p, NULL);
2108 }
2109
2110 /****************************************************************************
2111 Send a WINS name release response.
2112 **************************************************************************/
2113
2114 static void send_wins_name_release_response(int rcode, struct packet_struct *p)
2115 {
2116 struct nmb_packet *nmb = &p->packet.nmb;
2117 char rdata[6];
2118
2119 memcpy(&rdata[0], &nmb->additional->rdata[0], 6);
2120
2121 reply_netbios_packet(p, /* Packet to reply to. */
2122 rcode, /* Result code. */
2123 NMB_REL, /* nmbd type code. */
2124 NMB_NAME_RELEASE_OPCODE, /* opcode. */
2125 0, /* ttl. */
2126 rdata, /* data to send. */
2127 6); /* data length. */
2128 }
2129
2130 /***********************************************************************
2131 Deal with a name release.
2132 ***********************************************************************/
2133
2134 void wins_process_name_release_request(struct subnet_record *subrec,
2135 struct packet_struct *p)
2136 {
2137 struct nmb_packet *nmb = &p->packet.nmb;
2138 struct nmb_name *question = &nmb->question.question_name;
2139 bool bcast = nmb->header.nm_flags.bcast;
2140 uint16 nb_flags = get_nb_flags(nmb->additional->rdata);
2141 struct name_record *namerec = NULL;
2142 struct in_addr from_ip;
2143 bool releasing_group_name = (nb_flags & NB_GROUP) ? True : False;
2144
2145 putip((char *)&from_ip,&nmb->additional->rdata[2]);
2146
2147 if(bcast) {
2148 /*
2149 * We should only get unicast name registration packets here.
2150 * Anyone trying to register broadcast should not be going to a WINS
2151 * server. Log an error here.
2152 */
2153
2154 DEBUG(0,("wins_process_name_release_request: broadcast name registration request \
2155 received for name %s from IP %s on subnet %s. Error - should not be sent to WINS server\n",
2156 nmb_namestr(question), inet_ntoa(from_ip), subrec->subnet_name));
2157 return;
2158 }
2159
2160 DEBUG(3,("wins_process_name_release_request: %s name release for name %s \
2161 IP %s\n", releasing_group_name ? "Group" : "Unique", nmb_namestr(question), inet_ntoa(from_ip) ));
2162
2163 /*
2164 * Deal with policy regarding 0x1d names.
2165 */
2166
2167 if(!releasing_group_name && (question->name_type == 0x1d)) {
2168 DEBUG(3,("wins_process_name_release_request: Ignoring request \
2169 to release name %s from IP %s.", nmb_namestr(question), inet_ntoa(p->ip) ));
2170 send_wins_name_release_response(0, p);
2171 return;
2172 }
2173
2174 /*
2175 * See if the name already exists.
2176 */
2177
2178 namerec = find_name_on_subnet(subrec, question, FIND_ANY_NAME);
2179
2180 if( (namerec == NULL) || ((namerec != NULL) && (namerec->data.source != REGISTER_NAME)) ) {
2181 send_wins_name_release_response(NAM_ERR, p);
2182 return;
2183 }
2184
2185 /*
2186 * Check that the sending machine has permission to release this name.
2187 * If it's a group name not ending in 0x1c then just say yes and let
2188 * the group time out.
2189 */
2190
2191 if(releasing_group_name && (question->name_type != 0x1c)) {
2192 send_wins_name_release_response(0, p);
2193 return;
2194 }
2195
2196 /*
2197 * Check that the releasing node is on the list of IP addresses
2198 * for this name. Disallow the release if not.
2199 */
2200
2201 if(!find_ip_in_name_record(namerec, from_ip)) {
2202 DEBUG(3,("wins_process_name_release_request: Refusing request to \
2203 release name %s as IP %s is not one of the known IP's for this name.\n",
2204 nmb_namestr(question), inet_ntoa(from_ip) ));
2205 send_wins_name_release_response(NAM_ERR, p);
2206 return;
2207 }
2208
2209 /*
2210 * Check if the record is active. IF it's already released
2211 * or tombstoned, refuse the release.
2212 */
2213
2214 if (!WINS_STATE_ACTIVE(namerec)) {
2215 DEBUG(3,("wins_process_name_release_request: Refusing request to \
2216 release name %s as this record is not active anymore.\n", nmb_namestr(question) ));
2217 send_wins_name_release_response(NAM_ERR, p);
2218 return;
2219 }
2220
2221 /*
2222 * Check if the record is a 0x1c group
2223 * and has more then one ip
2224 * remove only this address.
2225 */
2226
2227 if(releasing_group_name && (question->name_type == 0x1c) && (namerec->data.num_ips > 1)) {
2228 remove_ip_from_name_record(namerec, from_ip);
2229 DEBUG(3,("wins_process_name_release_request: Remove IP %s from NAME: %s\n",
2230 inet_ntoa(from_ip),nmb_namestr(question)));
2231 wins_hook("delete", namerec, 0);
2232 send_wins_name_release_response(0, p);
2233 return;
2234 }
2235
2236 /*
2237 * Send a release response.
2238 * Flag the name as released and update the ttl
2239 */
2240
2241 namerec->data.wins_flags |= WINS_RELEASED;
2242 update_name_ttl(namerec, EXTINCTION_INTERVAL);
2243
2244 wins_hook("delete", namerec, 0);
2245 send_wins_name_release_response(0, p);
2246 }
2247
2248 /*******************************************************************
2249 WINS time dependent processing.
2250 ******************************************************************/
2251
2252 static int wins_processing_traverse_fn(TDB_CONTEXT *tdb, TDB_DATA kbuf, TDB_DATA dbuf, void *state)
2253 {
2254 time_t t = *(time_t *)state;
2255 bool store_record = False;
2256 struct name_record *namerec = NULL;
2257 struct in_addr our_fake_ip;
2258
2259 our_fake_ip = interpret_addr2("0.0.0.0");
2260 if (kbuf.dsize != sizeof(unstring) + 1) {
2261 return 0;
2262 }
2263
2264 namerec = wins_record_to_name_record(kbuf, dbuf);
2265 if (!namerec) {
2266 return 0;
2267 }
2268
2269 if( (namerec->data.death_time != PERMANENT_TTL) && (namerec->data.death_time < t) ) {
2270 if( namerec->data.source == SELF_NAME ) {
2271 DEBUG( 3, ( "wins_processing_traverse_fn: Subnet %s not expiring SELF name %s\n",
2272 wins_server_subnet->subnet_name, nmb_namestr(&namerec->name) ) );
2273 namerec->data.death_time += 300;
2274 store_record = True;
2275 goto done;
2276 } else if (namerec->data.source == DNS_NAME || namerec->data.source == DNSFAIL_NAME) {
2277 DEBUG(3,("wins_processing_traverse_fn: deleting timed out DNS name %s\n",
2278 nmb_namestr(&namerec->name)));
2279 remove_name_from_wins_namelist(namerec );
2280 goto done;
2281 }
2282
2283 /* handle records, samba is the wins owner */
2284 if (ip_equal_v4(namerec->data.wins_ip, our_fake_ip)) {
2285 switch (namerec->data.wins_flags & WINS_STATE_MASK) {
2286 case WINS_ACTIVE:
2287 namerec->data.wins_flags&=~WINS_STATE_MASK;
2288 namerec->data.wins_flags|=WINS_RELEASED;
2289 namerec->data.death_time = t + EXTINCTION_INTERVAL;
2290 DEBUG(3,("wins_processing_traverse_fn: expiring %s\n",
2291 nmb_namestr(&namerec->name)));
2292 store_record = True;
2293 goto done;
2294 case WINS_RELEASED:
2295 namerec->data.wins_flags&=~WINS_STATE_MASK;
2296 namerec->data.wins_flags|=WINS_TOMBSTONED;
2297 namerec->data.death_time = t + EXTINCTION_TIMEOUT;
2298 get_global_id_and_update(&namerec->data.id, True);
2299 DEBUG(3,("wins_processing_traverse_fn: tombstoning %s\n",
2300 nmb_namestr(&namerec->name)));
2301 store_record = True;
2302 goto done;
2303 case WINS_TOMBSTONED:
2304 DEBUG(3,("wins_processing_traverse_fn: deleting %s\n",
2305 nmb_namestr(&namerec->name)));
2306 remove_name_from_wins_namelist(namerec );
2307 goto done;
2308 }
2309 } else {
2310 switch (namerec->data.wins_flags & WINS_STATE_MASK) {
2311 case WINS_ACTIVE:
2312 /* that's not as MS says it should be */
2313 namerec->data.wins_flags&=~WINS_STATE_MASK;
2314 namerec->data.wins_flags|=WINS_TOMBSTONED;
2315 namerec->data.death_time = t + EXTINCTION_TIMEOUT;
2316 DEBUG(3,("wins_processing_traverse_fn: tombstoning %s\n",
2317 nmb_namestr(&namerec->name)));
2318 store_record = True;
2319 goto done;
2320 case WINS_TOMBSTONED:
2321 DEBUG(3,("wins_processing_traverse_fn: deleting %s\n",
2322 nmb_namestr(&namerec->name)));
2323 remove_name_from_wins_namelist(namerec );
2324 goto done;
2325 case WINS_RELEASED:
2326 DEBUG(0,("wins_processing_traverse_fn: %s is in released state and\
2327 we are not the wins owner !\n", nmb_namestr(&namerec->name)));
2328 goto done;
2329 }
2330 }
2331 }
2332
2333 done:
2334
2335 if (store_record) {
2336 wins_store_changed_namerec(namerec);
2337 }
2338
2339 SAFE_FREE(namerec->data.ip);
2340 SAFE_FREE(namerec);
2341
2342 return 0;
2343 }
2344
2345 /*******************************************************************
2346 Time dependent wins processing.
2347 ******************************************************************/
2348
2349 void initiate_wins_processing(time_t t)
2350 {
2351 static time_t lasttime = 0;
2352
2353 if (!lasttime) {
2354 lasttime = t;
2355 }
2356 if (t - lasttime < 20) {
2357 return;
2358 }
2359
2360 if(!lp_we_are_a_wins_server()) {
2361 lasttime = t;
2362 return;
2363 }
2364
2365 tdb_traverse(wins_tdb, wins_processing_traverse_fn, &t);
2366
2367 wins_delete_all_tmp_in_memory_records();
2368
2369 wins_write_database(t, True);
2370
2371 lasttime = t;
2372 }
2373
2374 /*******************************************************************
2375 Write out one record.
2376 ******************************************************************/
2377
2378 void wins_write_name_record(struct name_record *namerec, XFILE *fp)
2379 {
2380 int i;
2381 struct tm *tm;
2382
2383 DEBUGADD(4,("%-19s ", nmb_namestr(&namerec->name) ));
2384
2385 if( namerec->data.death_time != PERMANENT_TTL ) {
2386 char *ts, *nl;
2387
2388 tm = localtime(&namerec->data.death_time);
2389 if (!tm) {
2390 return;
2391 }
2392 ts = asctime(tm);
2393 if (!ts) {
2394 return;
2395 }
2396 nl = strrchr( ts, '\n' );
2397 if( NULL != nl ) {
2398 *nl = '\0';
2399 }
2400 DEBUGADD(4,("TTL = %s ", ts ));
2401 } else {
2402 DEBUGADD(4,("TTL = PERMANENT "));
2403 }
2404
2405 for (i = 0; i < namerec->data.num_ips; i++) {
2406 DEBUGADD(4,("%15s ", inet_ntoa(namerec->data.ip[i]) ));
2407 }
2408 DEBUGADD(4,("%2x\n", namerec->data.nb_flags ));
2409
2410 if( namerec->data.source == REGISTER_NAME ) {
2411 unstring name;
2412 pull_ascii_nstring(name, sizeof(name), namerec->name.name);
2413 x_fprintf(fp, "\"%s#%02x\" %d ", name,namerec->name.name_type, /* Ignore scope. */
2414 (int)namerec->data.death_time);
2415
2416 for (i = 0; i < namerec->data.num_ips; i++)
2417 x_fprintf( fp, "%s ", inet_ntoa( namerec->data.ip[i] ) );
2418 x_fprintf( fp, "%2xR\n", namerec->data.nb_flags );
2419 }
2420 }
2421
2422 /*******************************************************************
2423 Write out the current WINS database.
2424 ******************************************************************/
2425
2426 static int wins_writedb_traverse_fn(TDB_CONTEXT *tdb, TDB_DATA kbuf, TDB_DATA dbuf, void *state)
2427 {
2428 struct name_record *namerec = NULL;
2429 XFILE *fp = (XFILE *)state;
2430
2431 if (kbuf.dsize != sizeof(unstring) + 1) {
2432 return 0;
2433 }
2434
2435 namerec = wins_record_to_name_record(kbuf, dbuf);
2436 if (!namerec) {
2437 return 0;
2438 }
2439
2440 wins_write_name_record(namerec, fp);
2441
2442 SAFE_FREE(namerec->data.ip);
2443 SAFE_FREE(namerec);
2444 return 0;
2445 }
2446
2447
2448 void wins_write_database(time_t t, bool background)
2449 {
2450 static time_t last_write_time = 0;
2451 char *fname = NULL;
2452 char *fnamenew = NULL;
2453
2454 XFILE *fp;
2455
2456 if (background) {
2457 if (!last_write_time) {
2458 last_write_time = t;
2459 }
2460 if (t - last_write_time < 120) {
2461 return;
2462 }
2463
2464 }
2465
2466 if(!lp_we_are_a_wins_server()) {
2467 return;
2468 }
2469
2470 /* We will do the writing in a child process to ensure that the parent doesn't block while this is done */
2471 if (background) {
2472 CatchChild();
2473 if (fork()) {
2474 return;
2475 }
2476 if (tdb_reopen(wins_tdb)) {
2477 DEBUG(0,("wins_write_database: tdb_reopen failed. Error was %s\n",
2478 strerror(errno)));
2479 _exit(0);
2480 return;
2481 }
2482 }
2483
2484 if (!(fname = state_path(WINS_LIST))) {
2485 goto err_exit;
2486 }
2487 /* This is safe as the 0 length means "don't expand". */
2488 all_string_sub(fname,"//", "/", 0);
2489
2490 if (asprintf(&fnamenew, "%s.%u", fname, (unsigned int)getpid()) < 0) {
2491 goto err_exit;
2492 }
2493
2494 if((fp = x_fopen(fnamenew,O_WRONLY|O_CREAT,0644)) == NULL) {
2495 DEBUG(0,("wins_write_database: Can't open %s. Error was %s\n", fnamenew, strerror(errno)));
2496 goto err_exit;
2497 }
2498
2499 DEBUG(4,("wins_write_database: Dump of WINS name list.\n"));
2500
2501 x_fprintf(fp,"VERSION %d %u\n", WINS_VERSION, 0);
2502
2503 tdb_traverse(wins_tdb, wins_writedb_traverse_fn, fp);
2504
2505 x_fclose(fp);
2506 chmod(fnamenew,0644);
2507 unlink(fname);
2508 rename(fnamenew,fname);
2509
2510 err_exit:
2511
2512 SAFE_FREE(fnamenew);
2513 TALLOC_FREE(fname);
2514
2515 if (background) {
2516 _exit(0);
2517 }
2518 }
2519
2520 #if 0
2521 Until winsrepl is done.
2522 /****************************************************************************
2523 Process a internal Samba message receiving a wins record.
2524 ***************************************************************************/
2525
2526 void nmbd_wins_new_entry(struct messaging_context *msg,
2527 void *private_data,
2528 uint32_t msg_type,
2529 struct server_id server_id,
2530 DATA_BLOB *data)
2531 {
2532 WINS_RECORD *record;
2533 struct name_record *namerec = NULL;
2534 struct name_record *new_namerec = NULL;
2535 struct nmb_name question;
2536 bool overwrite=False;
2537 struct in_addr our_fake_ip;
2538 int i;
2539
2540 our_fake_ip = interpret_addr2("0.0.0.0");
2541 if (buf==NULL) {
2542 return;
2543 }
2544
2545 /* Record should use UNIX codepage. Ensure this is so in the wrepld code. JRA. */
2546 record=(WINS_RECORD *)buf;
2547
2548 make_nmb_name(&question, record->name, record->type);
2549
2550 namerec = find_name_on_subnet(wins_server_subnet, &question, FIND_ANY_NAME);
2551
2552 /* record doesn't exist, add it */
2553 if (namerec == NULL) {
2554 DEBUG(3,("nmbd_wins_new_entry: adding new replicated record: %s<%02x> for wins server: %s\n",
2555 record->name, record->type, inet_ntoa(record->wins_ip)));
2556
2557 new_namerec=add_name_to_subnet( wins_server_subnet,
2558 record->name,
2559 record->type,
2560 record->nb_flags,
2561 EXTINCTION_INTERVAL,
2562 REGISTER_NAME,
2563 record->num_ips,
2564 record->ip);
2565
2566 if (new_namerec!=NULL) {
2567 update_wins_owner(new_namerec, record->wins_ip);
2568 update_wins_flag(new_namerec, record->wins_flags);
2569 new_namerec->data.id=record->id;
2570
2571 wins_server_subnet->namelist_changed = True;
2572 }
2573 }
2574
2575 /* check if we have a conflict */
2576 if (namerec != NULL) {
2577 /* both records are UNIQUE */
2578 if (namerec->data.wins_flags&WINS_UNIQUE && record->wins_flags&WINS_UNIQUE) {
2579
2580 /* the database record is a replica */
2581 if (!ip_equal_v4(namerec->data.wins_ip, our_fake_ip)) {
2582 if (namerec->data.wins_flags&WINS_ACTIVE && record->wins_flags&WINS_TOMBSTONED) {
2583 if (ip_equal_v4(namerec->data.wins_ip, record->wins_ip))
2584 overwrite=True;
2585 } else
2586 overwrite=True;
2587 } else {
2588 /* we are the wins owner of the database record */
2589 /* the 2 records have the same IP address */
2590 if (ip_equal_v4(namerec->data.ip[0], record->ip[0])) {
2591 if (namerec->data.wins_flags&WINS_ACTIVE && record->wins_flags&WINS_TOMBSTONED)
2592 get_global_id_and_update(&namerec->data.id, True);
2593 else
2594 overwrite=True;
2595
2596 } else {
2597 /* the 2 records have different IP address */
2598 if (namerec->data.wins_flags&WINS_ACTIVE) {
2599 if (record->wins_flags&WINS_TOMBSTONED)
2600 get_global_id_and_update(&namerec->data.id, True);
2601 if (record->wins_flags&WINS_ACTIVE)
2602 /* send conflict challenge to the replica node */
2603 ;
2604 } else
2605 overwrite=True;
2606 }
2607
2608 }
2609 }
2610
2611 /* the replica is a standard group */
2612 if (record->wins_flags&WINS_NGROUP || record->wins_flags&WINS_SGROUP) {
2613 /* if the database record is unique and active force a name release */
2614 if (namerec->data.wins_flags&WINS_UNIQUE)
2615 /* send a release name to the unique node */
2616 ;
2617 overwrite=True;
2618
2619 }
2620
2621 /* the replica is a special group */
2622 if (record->wins_flags&WINS_SGROUP && namerec->data.wins_flags&WINS_SGROUP) {
2623 if (namerec->data.wins_flags&WINS_ACTIVE) {
2624 for (i=0; i<record->num_ips; i++)
2625 if(!find_ip_in_name_record(namerec, record->ip[i]))
2626 add_ip_to_name_record(namerec, record->ip[i]);
2627 } else {
2628 overwrite=True;
2629 }
2630 }
2631
2632 /* the replica is a multihomed host */
2633
2634 /* I'm giving up on multi homed. Too much complex to understand */
2635
2636 if (record->wins_flags&WINS_MHOMED) {
2637 if (! (namerec->data.wins_flags&WINS_ACTIVE)) {
2638 if ( !(namerec->data.wins_flags&WINS_RELEASED) && !(namerec->data.wins_flags&WINS_NGROUP))
2639 overwrite=True;
2640 }
2641 else {
2642 if (ip_equal_v4(record->wins_ip, namerec->data.wins_ip))
2643 overwrite=True;
2644
2645 if (ip_equal_v4(namerec->data.wins_ip, our_fake_ip))
2646 if (namerec->data.wins_flags&WINS_UNIQUE)
2647 get_global_id_and_update(&namerec->data.id, True);
2648
2649 }
2650
2651 if (record->wins_flags&WINS_ACTIVE && namerec->data.wins_flags&WINS_ACTIVE)
2652 if (namerec->data.wins_flags&WINS_UNIQUE ||
2653 namerec->data.wins_flags&WINS_MHOMED)
2654 if (ip_equal_v4(record->wins_ip, namerec->data.wins_ip))
2655 overwrite=True;
2656
2657 }
2658
2659 if (overwrite == False)
2660 DEBUG(3, ("nmbd_wins_new_entry: conflict in adding record: %s<%02x> from wins server: %s\n",
2661 record->name, record->type, inet_ntoa(record->wins_ip)));
2662 else {
2663 DEBUG(3, ("nmbd_wins_new_entry: replacing record: %s<%02x> from wins server: %s\n",
2664 record->name, record->type, inet_ntoa(record->wins_ip)));
2665
2666 /* remove the old record and add a new one */
2667 remove_name_from_namelist( wins_server_subnet, namerec );
2668 new_namerec=add_name_to_subnet( wins_server_subnet, record->name, record->type, record->nb_flags,
2669 EXTINCTION_INTERVAL, REGISTER_NAME, record->num_ips, record->ip);
2670 if (new_namerec!=NULL) {
2671 update_wins_owner(new_namerec, record->wins_ip);
2672 update_wins_flag(new_namerec, record->wins_flags);
2673 new_namerec->data.id=record->id;
2674
2675 wins_server_subnet->namelist_changed = True;
2676 }
2677
2678 wins_server_subnet->namelist_changed = True;
2679 }
2680
2681 }
2682 }
2683 #endif
reg import