?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r395: BUG 1232: patch from landonf@opendarwin.org (Landon Fuller) to fix
[Samba/gebeck_regimport.git] / source / nmbd / nmbd_winsserver.c
blob582338d710a97871188d55a5b2df18249a886747
1 /*
2 Unix SMB/CIFS implementation.
3 NBT netbios routines and daemon - version 2
4
5 Copyright (C) Jeremy Allison 1994-2003
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 2 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, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20
21 */
22
23 #include "includes.h"
24
25 #define WINS_LIST "wins.dat"
26 #define WINS_VERSION 1
27
28 /****************************************************************************
29 Change the wins owner address in the record.
30 *****************************************************************************/
31
32 static void update_wins_owner(struct name_record *namerec, struct in_addr wins_ip)
33 {
34 if (namerec==NULL)
35 return;
36 namerec->data.wins_ip=wins_ip;
37 }
38
39 /****************************************************************************
40 Create the wins flags based on the nb flags and the input value.
41 *****************************************************************************/
42
43 static void update_wins_flag(struct name_record *namerec, int flags)
44 {
45 if (namerec==NULL)
46 return;
47
48 namerec->data.wins_flags=0x0;
49
50 /* if it's a group, it can be a normal or a special one */
51 if (namerec->data.nb_flags & NB_GROUP) {
52 if (namerec->name.name_type==0x1C)
53 namerec->data.wins_flags|=WINS_SGROUP;
54 else
55 if (namerec->data.num_ips>1)
56 namerec->data.wins_flags|=WINS_SGROUP;
57 else
58 namerec->data.wins_flags|=WINS_NGROUP;
59 } else {
60 /* can be unique or multi-homed */
61 if (namerec->data.num_ips>1)
62 namerec->data.wins_flags|=WINS_MHOMED;
63 else
64 namerec->data.wins_flags|=WINS_UNIQUE;
65 }
66
67 /* the node type are the same bits */
68 namerec->data.wins_flags|=namerec->data.nb_flags&NB_NODETYPEMASK;
69
70 /* the static bit is elsewhere */
71 if (namerec->data.death_time == PERMANENT_TTL)
72 namerec->data.wins_flags|=WINS_STATIC;
73
74 /* and add the given bits */
75 namerec->data.wins_flags|=flags;
76
77 DEBUG(8,("update_wins_flag: nbflags: 0x%x, ttl: 0x%d, flags: 0x%x, winsflags: 0x%x\n",
78 namerec->data.nb_flags, (int)namerec->data.death_time, flags, namerec->data.wins_flags));
79 }
80
81 /****************************************************************************
82 Return the general ID value and increase it if requested.
83 *****************************************************************************/
84
85 static void get_global_id_and_update(SMB_BIG_UINT *current_id, BOOL update)
86 {
87 /*
88 * it's kept as a static here, to prevent people from messing
89 * with the value directly
90 */
91
92 static SMB_BIG_UINT general_id = 1;
93
94 DEBUG(5,("get_global_id_and_update: updating version ID: %d\n", (int)general_id));
95
96 *current_id = general_id;
97
98 if (update)
99 general_id++;
100 }
101
102 /****************************************************************************
103 Possibly call the WINS hook external program when a WINS change is made.
104 *****************************************************************************/
105
106 static void wins_hook(const char *operation, struct name_record *namerec, int ttl)
107 {
108 pstring command;
109 char *cmd = lp_wins_hook();
110 char *p, *namestr;
111 int i;
112
113 if (!cmd || !*cmd) return;
114
115 for (p=namerec->name.name; *p; p++) {
116 if (!(isalnum((int)*p) || strchr_m("._-",*p))) {
117 DEBUG(3,("not calling wins hook for invalid name %s\n", nmb_namestr(&namerec->name)));
118 return;
119 }
120 }
121
122 /* Use the name without the nametype (and scope) appended */
123
124 namestr = nmb_namestr(&namerec->name);
125 if ((p = strchr(namestr, '<')))
126 *p = 0;
127
128 p = command;
129 p += slprintf(p, sizeof(command)-1, "%s %s %s %02x %d",
130 cmd,
131 operation,
132 namestr,
133 namerec->name.name_type,
134 ttl);
135
136 for (i=0;i<namerec->data.num_ips;i++) {
137 p += slprintf(p, sizeof(command) - (p-command) -1, " %s", inet_ntoa(namerec->data.ip[i]));
138 }
139
140 DEBUG(3,("calling wins hook for %s\n", nmb_namestr(&namerec->name)));
141 smbrun(command, NULL);
142 }
143
144
145 /****************************************************************************
146 Determine if this packet should be allocated to the WINS server.
147 *****************************************************************************/
148
149 BOOL packet_is_for_wins_server(struct packet_struct *packet)
150 {
151 struct nmb_packet *nmb = &packet->packet.nmb;
152
153 /* Only unicast packets go to a WINS server. */
154 if((wins_server_subnet == NULL) || (nmb->header.nm_flags.bcast == True)) {
155 DEBUG(10, ("packet_is_for_wins_server: failing WINS test #1.\n"));
156 return False;
157 }
158
159 /* Check for node status requests. */
160 if (nmb->question.question_type != QUESTION_TYPE_NB_QUERY)
161 return False;
162
163 switch(nmb->header.opcode) {
164 /*
165 * A WINS server issues WACKS, not receives them.
166 */
167 case NMB_WACK_OPCODE:
168 DEBUG(10, ("packet_is_for_wins_server: failing WINS test #2 (WACK).\n"));
169 return False;
170 /*
171 * A WINS server only processes registration and
172 * release requests, not responses.
173 */
174 case NMB_NAME_REG_OPCODE:
175 case NMB_NAME_MULTIHOMED_REG_OPCODE:
176 case NMB_NAME_REFRESH_OPCODE_8: /* ambiguity in rfc1002 about which is correct. */
177 case NMB_NAME_REFRESH_OPCODE_9: /* WinNT uses 8 by default. */
178 if(nmb->header.response) {
179 DEBUG(10, ("packet_is_for_wins_server: failing WINS test #3 (response = 1).\n"));
180 return False;
181 }
182 break;
183
184 case NMB_NAME_RELEASE_OPCODE:
185 if(nmb->header.response) {
186 DEBUG(10, ("packet_is_for_wins_server: failing WINS test #4 (response = 1).\n"));
187 return False;
188 }
189 break;
190
191 /*
192 * Only process unicast name queries with rd = 1.
193 */
194 case NMB_NAME_QUERY_OPCODE:
195 if(!nmb->header.response && !nmb->header.nm_flags.recursion_desired) {
196 DEBUG(10, ("packet_is_for_wins_server: failing WINS test #5 (response = 1).\n"));
197 return False;
198 }
199 break;
200 }
201
202 return True;
203 }
204
205 /****************************************************************************
206 Utility function to decide what ttl to give a register/refresh request.
207 *****************************************************************************/
208
209 static int get_ttl_from_packet(struct nmb_packet *nmb)
210 {
211 int ttl = nmb->additional->ttl;
212
213 if(ttl < lp_min_wins_ttl() )
214 ttl = lp_min_wins_ttl();
215
216 if(ttl > lp_max_wins_ttl() )
217 ttl = lp_max_wins_ttl();
218
219 return ttl;
220 }
221
222 /****************************************************************************
223 Load or create the WINS database.
224 *****************************************************************************/
225
226 BOOL initialise_wins(void)
227 {
228 time_t time_now = time(NULL);
229 XFILE *fp;
230 pstring line;
231
232 if(!lp_we_are_a_wins_server())
233 return True;
234
235 add_samba_names_to_subnet(wins_server_subnet);
236
237 if((fp = x_fopen(lock_path(WINS_LIST),O_RDONLY,0)) == NULL) {
238 DEBUG(2,("initialise_wins: Can't open wins database file %s. Error was %s\n",
239 WINS_LIST, strerror(errno) ));
240 return True;
241 }
242
243 while (!x_feof(fp)) {
244 pstring name_str, ip_str, ttl_str, nb_flags_str;
245 unsigned int num_ips;
246 pstring name;
247 struct in_addr *ip_list;
248 int type = 0;
249 int nb_flags;
250 int ttl;
251 const char *ptr;
252 char *p;
253 BOOL got_token;
254 BOOL was_ip;
255 int i;
256 unsigned int hash;
257 int version;
258
259 /* Read a line from the wins.dat file. Strips whitespace
260 from the beginning and end of the line. */
261 if (!fgets_slash(line,sizeof(pstring),fp))
262 continue;
263
264 if (*line == '#')
265 continue;
266
267 if (strncmp(line,"VERSION ", 8) == 0) {
268 if (sscanf(line,"VERSION %d %u", &version, &hash) != 2 ||
269 version != WINS_VERSION) {
270 DEBUG(0,("Discarding invalid wins.dat file [%s]\n",line));
271 x_fclose(fp);
272 return True;
273 }
274 continue;
275 }
276
277 ptr = line;
278
279 /*
280 * Now we handle multiple IP addresses per name we need
281 * to iterate over the line twice. The first time to
282 * determine how many IP addresses there are, the second
283 * time to actually parse them into the ip_list array.
284 */
285
286 if (!next_token(&ptr,name_str,NULL,sizeof(name_str))) {
287 DEBUG(0,("initialise_wins: Failed to parse name when parsing line %s\n", line ));
288 continue;
289 }
290
291 if (!next_token(&ptr,ttl_str,NULL,sizeof(ttl_str))) {
292 DEBUG(0,("initialise_wins: Failed to parse time to live when parsing line %s\n", line ));
293 continue;
294 }
295
296 /*
297 * Determine the number of IP addresses per line.
298 */
299 num_ips = 0;
300 do {
301 got_token = next_token(&ptr,ip_str,NULL,sizeof(ip_str));
302 was_ip = False;
303
304 if(got_token && strchr(ip_str, '.')) {
305 num_ips++;
306 was_ip = True;
307 }
308 } while( got_token && was_ip);
309
310 if(num_ips == 0) {
311 DEBUG(0,("initialise_wins: Missing IP address when parsing line %s\n", line ));
312 continue;
313 }
314
315 if(!got_token) {
316 DEBUG(0,("initialise_wins: Missing nb_flags when parsing line %s\n", line ));
317 continue;
318 }
319
320 /* Allocate the space for the ip_list. */
321 if((ip_list = (struct in_addr *)malloc( num_ips * sizeof(struct in_addr))) == NULL) {
322 DEBUG(0,("initialise_wins: Malloc fail !\n"));
323 return False;
324 }
325
326 /* Reset and re-parse the line. */
327 ptr = line;
328 next_token(&ptr,name_str,NULL,sizeof(name_str));
329 next_token(&ptr,ttl_str,NULL,sizeof(ttl_str));
330 for(i = 0; i < num_ips; i++) {
331 next_token(&ptr, ip_str, NULL, sizeof(ip_str));
332 ip_list[i] = *interpret_addr2(ip_str);
333 }
334 next_token(&ptr,nb_flags_str,NULL, sizeof(nb_flags_str));
335
336 /*
337 * Deal with SELF or REGISTER name encoding. Default is REGISTER
338 * for compatibility with old nmbds.
339 */
340
341 if(nb_flags_str[strlen(nb_flags_str)-1] == 'S') {
342 DEBUG(5,("initialise_wins: Ignoring SELF name %s\n", line));
343 SAFE_FREE(ip_list);
344 continue;
345 }
346
347 if(nb_flags_str[strlen(nb_flags_str)-1] == 'R')
348 nb_flags_str[strlen(nb_flags_str)-1] = '\0';
349
350 /* Netbios name. # divides the name from the type (hex): netbios#xx */
351 pstrcpy(name,name_str);
352
353 if((p = strchr(name,'#')) != NULL) {
354 *p = 0;
355 sscanf(p+1,"%x",&type);
356 }
357
358 /* Decode the netbios flags (hex) and the time-to-live (in seconds). */
359 sscanf(nb_flags_str,"%x",&nb_flags);
360 sscanf(ttl_str,"%d",&ttl);
361
362 /* add all entries that have 60 seconds or more to live */
363 if ((ttl - 60) > time_now || ttl == PERMANENT_TTL) {
364 if(ttl != PERMANENT_TTL)
365 ttl -= time_now;
366
367 DEBUG( 4, ("initialise_wins: add name: %s#%02x ttl = %d first IP %s flags = %2x\n",
368 name, type, ttl, inet_ntoa(ip_list[0]), nb_flags));
369
370 (void)add_name_to_subnet( wins_server_subnet, name, type, nb_flags,
371 ttl, REGISTER_NAME, num_ips, ip_list );
372 } else {
373 DEBUG(4, ("initialise_wins: not adding name (ttl problem) %s#%02x ttl = %d first IP %s flags = %2x\n",
374 name, type, ttl, inet_ntoa(ip_list[0]), nb_flags));
375 }
376
377 SAFE_FREE(ip_list);
378 }
379
380 x_fclose(fp);
381 return True;
382 }
383
384 /****************************************************************************
385 Send a WINS WACK (Wait ACKnowledgement) response.
386 **************************************************************************/
387
388 static void send_wins_wack_response(int ttl, struct packet_struct *p)
389 {
390 struct nmb_packet *nmb = &p->packet.nmb;
391 unsigned char rdata[2];
392
393 rdata[0] = rdata[1] = 0;
394
395 /* Taken from nmblib.c - we need to send back almost
396 identical bytes from the requesting packet header. */
397
398 rdata[0] = (nmb->header.opcode & 0xF) << 3;
399 if (nmb->header.nm_flags.authoritative && nmb->header.response)
400 rdata[0] |= 0x4;
401 if (nmb->header.nm_flags.trunc)
402 rdata[0] |= 0x2;
403 if (nmb->header.nm_flags.recursion_desired)
404 rdata[0] |= 0x1;
405 if (nmb->header.nm_flags.recursion_available && nmb->header.response)
406 rdata[1] |= 0x80;
407 if (nmb->header.nm_flags.bcast)
408 rdata[1] |= 0x10;
409
410 reply_netbios_packet(p, /* Packet to reply to. */
411 0, /* Result code. */
412 NMB_WAIT_ACK, /* nmbd type code. */
413 NMB_WACK_OPCODE, /* opcode. */
414 ttl, /* ttl. */
415 (char *)rdata, /* data to send. */
416 2); /* data length. */
417 }
418
419 /****************************************************************************
420 Send a WINS name registration response.
421 **************************************************************************/
422
423 static void send_wins_name_registration_response(int rcode, int ttl, struct packet_struct *p)
424 {
425 struct nmb_packet *nmb = &p->packet.nmb;
426 char rdata[6];
427
428 memcpy(&rdata[0], &nmb->additional->rdata[0], 6);
429
430 reply_netbios_packet(p, /* Packet to reply to. */
431 rcode, /* Result code. */
432 WINS_REG, /* nmbd type code. */
433 NMB_NAME_REG_OPCODE, /* opcode. */
434 ttl, /* ttl. */
435 rdata, /* data to send. */
436 6); /* data length. */
437 }
438
439 /***********************************************************************
440 Deal with a name refresh request to a WINS server.
441 ************************************************************************/
442
443 void wins_process_name_refresh_request( struct subnet_record *subrec,
444 struct packet_struct *p )
445 {
446 struct nmb_packet *nmb = &p->packet.nmb;
447 struct nmb_name *question = &nmb->question.question_name;
448 BOOL bcast = nmb->header.nm_flags.bcast;
449 uint16 nb_flags = get_nb_flags(nmb->additional->rdata);
450 BOOL group = (nb_flags & NB_GROUP) ? True : False;
451 struct name_record *namerec = NULL;
452 int ttl = get_ttl_from_packet(nmb);
453 struct in_addr from_ip;
454 struct in_addr our_fake_ip = *interpret_addr2("0.0.0.0");
455
456 putip( (char *)&from_ip, &nmb->additional->rdata[2] );
457
458 if(bcast) {
459 /*
460 * We should only get unicast name refresh packets here.
461 * Anyone trying to refresh broadcast should not be going
462 * to a WINS server. Log an error here.
463 */
464 if( DEBUGLVL( 0 ) ) {
465 dbgtext( "wins_process_name_refresh_request: " );
466 dbgtext( "Broadcast name refresh request received " );
467 dbgtext( "for name %s ", nmb_namestr(question) );
468 dbgtext( "from IP %s ", inet_ntoa(from_ip) );
469 dbgtext( "on subnet %s. ", subrec->subnet_name );
470 dbgtext( "Error - Broadcasts should not be sent " );
471 dbgtext( "to a WINS server\n" );
472 }
473 return;
474 }
475
476 if( DEBUGLVL( 3 ) ) {
477 dbgtext( "wins_process_name_refresh_request: " );
478 dbgtext( "Name refresh for name %s IP %s\n",
479 nmb_namestr(question), inet_ntoa(from_ip) );
480 }
481
482 /*
483 * See if the name already exists.
484 * If not, handle it as a name registration and return.
485 */
486 namerec = find_name_on_subnet(subrec, question, FIND_ANY_NAME);
487
488 /*
489 * If this is a refresh request and the name doesn't exist then
490 * treat it like a registration request. This allows us to recover
491 * from errors (tridge)
492 */
493 if(namerec == NULL) {
494 if( DEBUGLVL( 3 ) ) {
495 dbgtext( "wins_process_name_refresh_request: " );
496 dbgtext( "Name refresh for name %s ",
497 nmb_namestr( question ) );
498 dbgtext( "and the name does not exist. Treating " );
499 dbgtext( "as registration.\n" );
500 }
501 wins_process_name_registration_request(subrec,p);
502 return;
503 }
504
505 /*
506 * if the name is present but not active, simply remove it
507 * and treat the refresh request as a registration & return.
508 */
509 if (namerec != NULL && !WINS_STATE_ACTIVE(namerec)) {
510 if( DEBUGLVL( 5 ) ) {
511 dbgtext( "wins_process_name_refresh_request: " );
512 dbgtext( "Name (%s) in WINS ", nmb_namestr(question) );
513 dbgtext( "was not active - removing it.\n" );
514 }
515 remove_name_from_namelist( subrec, namerec );
516 namerec = NULL;
517 wins_process_name_registration_request( subrec, p );
518 return;
519 }
520
521 /*
522 * Check that the group bits for the refreshing name and the
523 * name in our database match. If not, refuse the refresh.
524 * [crh: Why RFS_ERR instead of ACT_ERR? Is this what MS does?]
525 */
526 if( (namerec != NULL) &&
527 ( (group && !NAME_GROUP(namerec))
528 || (!group && NAME_GROUP(namerec)) ) ) {
529 if( DEBUGLVL( 3 ) ) {
530 dbgtext( "wins_process_name_refresh_request: " );
531 dbgtext( "Name %s ", nmb_namestr(question) );
532 dbgtext( "group bit = %s does not match ",
533 group ? "True" : "False" );
534 dbgtext( "group bit in WINS for this name.\n" );
535 }
536 send_wins_name_registration_response(RFS_ERR, 0, p);
537 return;
538 }
539
540 /*
541 * For a unique name check that the person refreshing the name is
542 * one of the registered IP addresses. If not - fail the refresh.
543 * Do the same for group names with a type of 0x1c.
544 * Just return success for unique 0x1d refreshes. For normal group
545 * names update the ttl and return success.
546 */
547 if( (!group || (group && (question->name_type == 0x1c)))
548 && find_ip_in_name_record(namerec, from_ip) ) {
549 /*
550 * Update the ttl.
551 */
552 update_name_ttl(namerec, ttl);
553
554 /*
555 * if the record is a replica:
556 * we take ownership and update the version ID.
557 */
558 if (!ip_equal(namerec->data.wins_ip, our_fake_ip)) {
559 update_wins_owner(namerec, our_fake_ip);
560 get_global_id_and_update(&namerec->data.id, True);
561 }
562
563 send_wins_name_registration_response(0, ttl, p);
564 wins_hook("refresh", namerec, ttl);
565 return;
566 } else if((group && (question->name_type == 0x1c))) {
567 /*
568 * Added by crh for bug #1079.
569 * Fix from Bert Driehuis
570 */
571 if( DEBUGLVL( 3 ) ) {
572 dbgtext( "wins_process_name_refresh_request: " );
573 dbgtext( "Name refresh for name %s, ",
574 nmb_namestr(question) );
575 dbgtext( "but IP address %s ", inet_ntoa(from_ip) );
576 dbgtext( "is not yet associated with " );
577 dbgtext( "that name. Treating as registration.\n" );
578 }
579 wins_process_name_registration_request(subrec,p);
580 return;
581 } else if(group) {
582 /*
583 * Normal groups are all registered with an IP address of
584 * 255.255.255.255 so we can't search for the IP address.
585 */
586 update_name_ttl(namerec, ttl);
587 send_wins_name_registration_response(0, ttl, p);
588 return;
589 } else if(!group && (question->name_type == 0x1d)) {
590 /*
591 * Special name type - just pretend the refresh succeeded.
592 */
593 send_wins_name_registration_response(0, ttl, p);
594 return;
595 } else {
596 /*
597 * Fail the refresh.
598 */
599 if( DEBUGLVL( 3 ) ) {
600 dbgtext( "wins_process_name_refresh_request: " );
601 dbgtext( "Name refresh for name %s with IP %s ",
602 nmb_namestr(question), inet_ntoa(from_ip) );
603 dbgtext( "and is IP is not known to the name.\n" );
604 }
605 send_wins_name_registration_response(RFS_ERR, 0, p);
606 return;
607 }
608 }
609
610 /***********************************************************************
611 Deal with a name registration request query success to a client that
612 owned the name.
613
614 We have a locked pointer to the original packet stashed away in the
615 userdata pointer. The success here is actually a failure as it means
616 the client we queried wants to keep the name, so we must return
617 a registration failure to the original requestor.
618 ************************************************************************/
619
620 static void wins_register_query_success(struct subnet_record *subrec,
621 struct userdata_struct *userdata,
622 struct nmb_name *question_name,
623 struct in_addr ip,
624 struct res_rec *answers)
625 {
626 struct packet_struct *orig_reg_packet;
627
628 memcpy((char *)&orig_reg_packet, userdata->data, sizeof(struct packet_struct *));
629
630 DEBUG(3,("wins_register_query_success: Original client at IP %s still wants the \
631 name %s. Rejecting registration request.\n", inet_ntoa(ip), nmb_namestr(question_name) ));
632
633 send_wins_name_registration_response(RFS_ERR, 0, orig_reg_packet);
634
635 orig_reg_packet->locked = False;
636 free_packet(orig_reg_packet);
637 }
638
639 /***********************************************************************
640 Deal with a name registration request query failure to a client that
641 owned the name.
642
643 We have a locked pointer to the original packet stashed away in the
644 userdata pointer. The failure here is actually a success as it means
645 the client we queried didn't want to keep the name, so we can remove
646 the old name record and then successfully add the new name.
647 ************************************************************************/
648
649 static void wins_register_query_fail(struct subnet_record *subrec,
650 struct response_record *rrec,
651 struct nmb_name *question_name,
652 int rcode)
653 {
654 struct userdata_struct *userdata = rrec->userdata;
655 struct packet_struct *orig_reg_packet;
656 struct name_record *namerec = NULL;
657
658 memcpy((char *)&orig_reg_packet, userdata->data, sizeof(struct packet_struct *));
659
660 /*
661 * We want to just add the name, as we now know the original owner
662 * didn't want it. But we can't just do that as an arbitary
663 * amount of time may have taken place between the name query
664 * request and this timeout/error response. So we check that
665 * the name still exists and is in the same state - if so
666 * we remove it and call wins_process_name_registration_request()
667 * as we know it will do the right thing now.
668 */
669
670 namerec = find_name_on_subnet(subrec, question_name, FIND_ANY_NAME);
671
672 if( (namerec != NULL) && (namerec->data.source == REGISTER_NAME) && ip_equal(rrec->packet->ip, *namerec->data.ip) ) {
673 remove_name_from_namelist( subrec, namerec);
674 namerec = NULL;
675 }
676
677 if(namerec == NULL)
678 wins_process_name_registration_request(subrec, orig_reg_packet);
679 else
680 DEBUG(2,("wins_register_query_fail: The state of the WINS database changed between \
681 querying for name %s in order to replace it and this reply.\n", nmb_namestr(question_name) ));
682
683 orig_reg_packet->locked = False;
684 free_packet(orig_reg_packet);
685 }
686
687 /***********************************************************************
688 Deal with a name registration request to a WINS server.
689
690 Use the following pseudocode :
691
692 registering_group
693 |
694 |
695 +--------name exists
696 | |
697 | |
698 | +--- existing name is group
699 | | |
700 | | |
701 | | +--- add name (return).
702 | |
703 | |
704 | +--- exiting name is unique
705 | |
706 | |
707 | +--- query existing owner (return).
708 |
709 |
710 +--------name doesn't exist
711 |
712 |
713 +--- add name (return).
714
715 registering_unique
716 |
717 |
718 +--------name exists
719 | |
720 | |
721 | +--- existing name is group
722 | | |
723 | | |
724 | | +--- fail add (return).
725 | |
726 | |
727 | +--- exiting name is unique
728 | |
729 | |
730 | +--- query existing owner (return).
731 |
732 |
733 +--------name doesn't exist
734 |
735 |
736 +--- add name (return).
737
738 As can be seen from the above, the two cases may be collapsed onto each
739 other with the exception of the case where the name already exists and
740 is a group name. This case we handle with an if statement.
741
742 ************************************************************************/
743
744 void wins_process_name_registration_request(struct subnet_record *subrec,
745 struct packet_struct *p)
746 {
747 unstring name;
748 struct nmb_packet *nmb = &p->packet.nmb;
749 struct nmb_name *question = &nmb->question.question_name;
750 BOOL bcast = nmb->header.nm_flags.bcast;
751 uint16 nb_flags = get_nb_flags(nmb->additional->rdata);
752 int ttl = get_ttl_from_packet(nmb);
753 struct name_record *namerec = NULL;
754 struct in_addr from_ip;
755 BOOL registering_group_name = (nb_flags & NB_GROUP) ? True : False;
756 struct in_addr our_fake_ip = *interpret_addr2("0.0.0.0");
757
758 putip((char *)&from_ip,&nmb->additional->rdata[2]);
759
760 if(bcast) {
761 /*
762 * We should only get unicast name registration packets here.
763 * Anyone trying to register broadcast should not be going to a WINS
764 * server. Log an error here.
765 */
766
767 DEBUG(0,("wins_process_name_registration_request: broadcast name registration request \
768 received for name %s from IP %s on subnet %s. Error - should not be sent to WINS server\n",
769 nmb_namestr(question), inet_ntoa(from_ip), subrec->subnet_name));
770 return;
771 }
772
773 DEBUG(3,("wins_process_name_registration_request: %s name registration for name %s \
774 IP %s\n", registering_group_name ? "Group" : "Unique", nmb_namestr(question), inet_ntoa(from_ip) ));
775
776 /*
777 * See if the name already exists.
778 */
779
780 namerec = find_name_on_subnet(subrec, question, FIND_ANY_NAME);
781
782 /*
783 * if the record exists but NOT in active state,
784 * consider it dead.
785 */
786 if ( (namerec != NULL) && !WINS_STATE_ACTIVE(namerec)) {
787 DEBUG(5,("wins_process_name_registration_request: Name (%s) in WINS was \
788 not active - removing it.\n", nmb_namestr(question) ));
789 remove_name_from_namelist( subrec, namerec );
790 namerec = NULL;
791 }
792
793 /*
794 * Deal with the case where the name found was a dns entry.
795 * Remove it as we now have a NetBIOS client registering the
796 * name.
797 */
798
799 if( (namerec != NULL) && ( (namerec->data.source == DNS_NAME) || (namerec->data.source == DNSFAIL_NAME) ) ) {
800 DEBUG(5,("wins_process_name_registration_request: Name (%s) in WINS was \
801 a dns lookup - removing it.\n", nmb_namestr(question) ));
802 remove_name_from_namelist( subrec, namerec );
803 namerec = NULL;
804 }
805
806 /*
807 * Reject if the name exists and is not a REGISTER_NAME.
808 * (ie. Don't allow any static names to be overwritten.
809 */
810
811 if((namerec != NULL) && (namerec->data.source != REGISTER_NAME)) {
812 DEBUG( 3, ( "wins_process_name_registration_request: Attempt \
813 to register name %s. Name already exists in WINS with source type %d.\n",
814 nmb_namestr(question), namerec->data.source ));
815 send_wins_name_registration_response(RFS_ERR, 0, p);
816 return;
817 }
818
819 /*
820 * Special policy decisions based on MS documentation.
821 * 1). All group names (except names ending in 0x1c) are added as 255.255.255.255.
822 * 2). All unique names ending in 0x1d are ignored, although a positive response is sent.
823 */
824
825 /*
826 * A group name is always added as the local broadcast address, except
827 * for group names ending in 0x1c.
828 * Group names with type 0x1c are registered with individual IP addresses.
829 */
830
831 if(registering_group_name && (question->name_type != 0x1c))
832 from_ip = *interpret_addr2("255.255.255.255");
833
834 /*
835 * Ignore all attempts to register a unique 0x1d name, although return success.
836 */
837
838 if(!registering_group_name && (question->name_type == 0x1d)) {
839 DEBUG(3,("wins_process_name_registration_request: Ignoring request \
840 to register name %s from IP %s.\n", nmb_namestr(question), inet_ntoa(p->ip) ));
841 send_wins_name_registration_response(0, ttl, p);
842 return;
843 }
844
845 /*
846 * Next two cases are the 'if statement' mentioned above.
847 */
848
849 if((namerec != NULL) && NAME_GROUP(namerec)) {
850 if(registering_group_name) {
851 /*
852 * If we are adding a group name, the name exists and is also a group entry just add this
853 * IP address to it and update the ttl.
854 */
855
856 DEBUG(3,("wins_process_name_registration_request: Adding IP %s to group name %s.\n",
857 inet_ntoa(from_ip), nmb_namestr(question) ));
858
859 /*
860 * Check the ip address is not already in the group.
861 */
862
863 if(!find_ip_in_name_record(namerec, from_ip)) {
864 add_ip_to_name_record(namerec, from_ip);
865 /* we need to update the record for replication */
866 get_global_id_and_update(&namerec->data.id, True);
867
868 /*
869 * if the record is a replica, we must change
870 * the wins owner to us to make the replication updates
871 * it on the other wins servers.
872 * And when the partner will receive this record,
873 * it will update its own record.
874 */
875
876 update_wins_owner(namerec, our_fake_ip);
877 }
878 update_name_ttl(namerec, ttl);
879 send_wins_name_registration_response(0, ttl, p);
880 return;
881 } else {
882
883 /*
884 * If we are adding a unique name, the name exists in the WINS db
885 * and is a group name then reject the registration.
886 *
887 * explanation: groups have a higher priority than unique names.
888 */
889
890 DEBUG(3,("wins_process_name_registration_request: Attempt to register name %s. Name \
891 already exists in WINS as a GROUP name.\n", nmb_namestr(question) ));
892 send_wins_name_registration_response(RFS_ERR, 0, p);
893 return;
894 }
895 }
896
897 /*
898 * From here on down we know that if the name exists in the WINS db it is
899 * a unique name, not a group name.
900 */
901
902 /*
903 * If the name exists and is one of our names then check the
904 * registering IP address. If it's not one of ours then automatically
905 * reject without doing the query - we know we will reject it.
906 */
907
908 if ( namerec != NULL )
909 pull_ascii_nstring(name, sizeof(name), namerec->name.name);
910
911 if( is_myname(name) ) {
912 if(!ismyip(from_ip)) {
913 DEBUG(3,("wins_process_name_registration_request: Attempt to register name %s. Name \
914 is one of our (WINS server) names. Denying registration.\n", nmb_namestr(question) ));
915 send_wins_name_registration_response(RFS_ERR, 0, p);
916 return;
917 } else {
918 /*
919 * It's one of our names and one of our IP's - update the ttl.
920 */
921 update_name_ttl(namerec, ttl);
922 send_wins_name_registration_response(0, ttl, p);
923 wins_hook("refresh", namerec, ttl);
924 return;
925 }
926 }
927
928 /*
929 * If the name exists and it is a unique registration and the registering IP
930 * is the same as the (single) already registered IP then just update the ttl.
931 *
932 * But not if the record is an active replica. IF it's a replica, it means it can be
933 * the same client which has moved and not yet expired. So we don't update
934 * the ttl in this case and go beyond to do a WACK and query the old client
935 */
936
937 if( !registering_group_name
938 && (namerec != NULL)
939 && (namerec->data.num_ips == 1)
940 && ip_equal( namerec->data.ip[0], from_ip )
941 && ip_equal(namerec->data.wins_ip, our_fake_ip) ) {
942 update_name_ttl( namerec, ttl );
943 send_wins_name_registration_response( 0, ttl, p );
944 wins_hook("refresh", namerec, ttl);
945 return;
946 }
947
948 /*
949 * Finally if the name exists do a query to the registering machine
950 * to see if they still claim to have the name.
951 */
952
953 if( namerec != NULL ) {
954 long *ud[(sizeof(struct userdata_struct) + sizeof(struct packet_struct *))/sizeof(long *) + 1];
955 struct userdata_struct *userdata = (struct userdata_struct *)ud;
956
957 /*
958 * First send a WACK to the registering machine.
959 */
960
961 send_wins_wack_response(60, p);
962
963 /*
964 * When the reply comes back we need the original packet.
965 * Lock this so it won't be freed and then put it into
966 * the userdata structure.
967 */
968
969 p->locked = True;
970
971 userdata = (struct userdata_struct *)ud;
972
973 userdata->copy_fn = NULL;
974 userdata->free_fn = NULL;
975 userdata->userdata_len = sizeof(struct packet_struct *);
976 memcpy(userdata->data, (char *)&p, sizeof(struct packet_struct *) );
977
978 /*
979 * Use the new call to send a query directly to an IP address.
980 * This sends the query directly to the IP address, and ensures
981 * the recursion desired flag is not set (you were right Luke :-).
982 * This function should *only* be called from the WINS server
983 * code. JRA.
984 */
985
986 pull_ascii_nstring(name, sizeof(name), question->name);
987 query_name_from_wins_server( *namerec->data.ip,
988 name,
989 question->name_type,
990 wins_register_query_success,
991 wins_register_query_fail,
992 userdata );
993 return;
994 }
995
996 /*
997 * Name did not exist - add it.
998 */
999
1000 pull_ascii_nstring(name, sizeof(name), question->name);
1001 add_name_to_subnet( subrec, name, question->name_type,
1002 nb_flags, ttl, REGISTER_NAME, 1, &from_ip);
1003
1004 if ((namerec = find_name_on_subnet(subrec, question, FIND_ANY_NAME))) {
1005 get_global_id_and_update(&namerec->data.id, True);
1006 update_wins_owner(namerec, our_fake_ip);
1007 update_wins_flag(namerec, WINS_ACTIVE);
1008 wins_hook("add", namerec, ttl);
1009 }
1010
1011 send_wins_name_registration_response(0, ttl, p);
1012 }
1013
1014 /***********************************************************************
1015 Deal with a mutihomed name query success to the machine that
1016 requested the multihomed name registration.
1017
1018 We have a locked pointer to the original packet stashed away in the
1019 userdata pointer.
1020 ************************************************************************/
1021
1022 static void wins_multihomed_register_query_success(struct subnet_record *subrec,
1023 struct userdata_struct *userdata,
1024 struct nmb_name *question_name,
1025 struct in_addr ip,
1026 struct res_rec *answers)
1027 {
1028 struct packet_struct *orig_reg_packet;
1029 struct nmb_packet *nmb;
1030 struct name_record *namerec = NULL;
1031 struct in_addr from_ip;
1032 int ttl;
1033 struct in_addr our_fake_ip = *interpret_addr2("0.0.0.0");
1034
1035 memcpy((char *)&orig_reg_packet, userdata->data, sizeof(struct packet_struct *));
1036
1037 nmb = &orig_reg_packet->packet.nmb;
1038
1039 putip((char *)&from_ip,&nmb->additional->rdata[2]);
1040 ttl = get_ttl_from_packet(nmb);
1041
1042 /*
1043 * We want to just add the new IP, as we now know the requesting
1044 * machine claims to own it. But we can't just do that as an arbitary
1045 * amount of time may have taken place between the name query
1046 * request and this response. So we check that
1047 * the name still exists and is in the same state - if so
1048 * we just add the extra IP and update the ttl.
1049 */
1050
1051 namerec = find_name_on_subnet(subrec, question_name, FIND_ANY_NAME);
1052
1053 if( (namerec == NULL) || (namerec->data.source != REGISTER_NAME) || !WINS_STATE_ACTIVE(namerec) ) {
1054 DEBUG(3,("wins_multihomed_register_query_success: name %s is not in the correct state to add \
1055 a subsequent IP address.\n", nmb_namestr(question_name) ));
1056 send_wins_name_registration_response(RFS_ERR, 0, orig_reg_packet);
1057
1058 orig_reg_packet->locked = False;
1059 free_packet(orig_reg_packet);
1060
1061 return;
1062 }
1063
1064 if(!find_ip_in_name_record(namerec, from_ip))
1065 add_ip_to_name_record(namerec, from_ip);
1066
1067 get_global_id_and_update(&namerec->data.id, True);
1068 update_wins_owner(namerec, our_fake_ip);
1069 update_wins_flag(namerec, WINS_ACTIVE);
1070 update_name_ttl(namerec, ttl);
1071 send_wins_name_registration_response(0, ttl, orig_reg_packet);
1072 wins_hook("add", namerec, ttl);
1073
1074 orig_reg_packet->locked = False;
1075 free_packet(orig_reg_packet);
1076 }
1077
1078 /***********************************************************************
1079 Deal with a name registration request query failure to a client that
1080 owned the name.
1081
1082 We have a locked pointer to the original packet stashed away in the
1083 userdata pointer.
1084 ************************************************************************/
1085
1086 static void wins_multihomed_register_query_fail(struct subnet_record *subrec,
1087 struct response_record *rrec,
1088 struct nmb_name *question_name,
1089 int rcode)
1090 {
1091 struct userdata_struct *userdata = rrec->userdata;
1092 struct packet_struct *orig_reg_packet;
1093
1094 memcpy((char *)&orig_reg_packet, userdata->data, sizeof(struct packet_struct *));
1095
1096 DEBUG(3,("wins_multihomed_register_query_fail: Registering machine at IP %s failed to answer \
1097 query successfully for name %s.\n", inet_ntoa(orig_reg_packet->ip), nmb_namestr(question_name) ));
1098 send_wins_name_registration_response(RFS_ERR, 0, orig_reg_packet);
1099
1100 orig_reg_packet->locked = False;
1101 free_packet(orig_reg_packet);
1102 return;
1103 }
1104
1105 /***********************************************************************
1106 Deal with a multihomed name registration request to a WINS server.
1107 These cannot be group name registrations.
1108 ***********************************************************************/
1109
1110 void wins_process_multihomed_name_registration_request( struct subnet_record *subrec,
1111 struct packet_struct *p)
1112 {
1113 struct nmb_packet *nmb = &p->packet.nmb;
1114 struct nmb_name *question = &nmb->question.question_name;
1115 BOOL bcast = nmb->header.nm_flags.bcast;
1116 uint16 nb_flags = get_nb_flags(nmb->additional->rdata);
1117 int ttl = get_ttl_from_packet(nmb);
1118 struct name_record *namerec = NULL;
1119 struct in_addr from_ip;
1120 BOOL group = (nb_flags & NB_GROUP) ? True : False;
1121 struct in_addr our_fake_ip = *interpret_addr2("0.0.0.0");
1122 unstring qname;
1123
1124 putip((char *)&from_ip,&nmb->additional->rdata[2]);
1125
1126 if(bcast) {
1127 /*
1128 * We should only get unicast name registration packets here.
1129 * Anyone trying to register broadcast should not be going to a WINS
1130 * server. Log an error here.
1131 */
1132
1133 DEBUG(0,("wins_process_multihomed_name_registration_request: broadcast name registration request \
1134 received for name %s from IP %s on subnet %s. Error - should not be sent to WINS server\n",
1135 nmb_namestr(question), inet_ntoa(from_ip), subrec->subnet_name));
1136 return;
1137 }
1138
1139 /*
1140 * Only unique names should be registered multihomed.
1141 */
1142
1143 if(group) {
1144 DEBUG(0,("wins_process_multihomed_name_registration_request: group name registration request \
1145 received for name %s from IP %s on subnet %s. Errror - group names should not be multihomed.\n",
1146 nmb_namestr(question), inet_ntoa(from_ip), subrec->subnet_name));
1147 return;
1148 }
1149
1150 DEBUG(3,("wins_process_multihomed_name_registration_request: name registration for name %s \
1151 IP %s\n", nmb_namestr(question), inet_ntoa(from_ip) ));
1152
1153 /*
1154 * Deal with policy regarding 0x1d names.
1155 */
1156
1157 if(question->name_type == 0x1d) {
1158 DEBUG(3,("wins_process_multihomed_name_registration_request: Ignoring request \
1159 to register name %s from IP %s.", nmb_namestr(question), inet_ntoa(p->ip) ));
1160 send_wins_name_registration_response(0, ttl, p);
1161 return;
1162 }
1163
1164 /*
1165 * See if the name already exists.
1166 */
1167
1168 namerec = find_name_on_subnet(subrec, question, FIND_ANY_NAME);
1169
1170 /*
1171 * if the record exists but NOT in active state,
1172 * consider it dead.
1173 */
1174
1175 if ((namerec != NULL) && !WINS_STATE_ACTIVE(namerec)) {
1176 DEBUG(5,("wins_process_multihomed_name_registration_request: Name (%s) in WINS was not active - removing it.\n", nmb_namestr(question)));
1177 remove_name_from_namelist(subrec, namerec);
1178 namerec = NULL;
1179 }
1180
1181 /*
1182 * Deal with the case where the name found was a dns entry.
1183 * Remove it as we now have a NetBIOS client registering the
1184 * name.
1185 */
1186
1187 if( (namerec != NULL) && ( (namerec->data.source == DNS_NAME) || (namerec->data.source == DNSFAIL_NAME) ) ) {
1188 DEBUG(5,("wins_process_multihomed_name_registration_request: Name (%s) in WINS was a dns lookup \
1189 - removing it.\n", nmb_namestr(question) ));
1190 remove_name_from_namelist( subrec, namerec);
1191 namerec = NULL;
1192 }
1193
1194 /*
1195 * Reject if the name exists and is not a REGISTER_NAME.
1196 * (ie. Don't allow any static names to be overwritten.
1197 */
1198
1199 if( (namerec != NULL) && (namerec->data.source != REGISTER_NAME) ) {
1200 DEBUG( 3, ( "wins_process_multihomed_name_registration_request: Attempt \
1201 to register name %s. Name already exists in WINS with source type %d.\n",
1202 nmb_namestr(question), namerec->data.source ));
1203 send_wins_name_registration_response(RFS_ERR, 0, p);
1204 return;
1205 }
1206
1207 /*
1208 * Reject if the name exists and is a GROUP name and is active.
1209 */
1210
1211 if((namerec != NULL) && NAME_GROUP(namerec) && WINS_STATE_ACTIVE(namerec)) {
1212 DEBUG(3,("wins_process_multihomed_name_registration_request: Attempt to register name %s. Name \
1213 already exists in WINS as a GROUP name.\n", nmb_namestr(question) ));
1214 send_wins_name_registration_response(RFS_ERR, 0, p);
1215 return;
1216 }
1217
1218 /*
1219 * From here on down we know that if the name exists in the WINS db it is
1220 * a unique name, not a group name.
1221 */
1222
1223 /*
1224 * If the name exists and is one of our names then check the
1225 * registering IP address. If it's not one of ours then automatically
1226 * reject without doing the query - we know we will reject it.
1227 */
1228
1229 if((namerec != NULL) && (is_myname(namerec->name.name)) ) {
1230 if(!ismyip(from_ip)) {
1231 DEBUG(3,("wins_process_multihomed_name_registration_request: Attempt to register name %s. Name \
1232 is one of our (WINS server) names. Denying registration.\n", nmb_namestr(question) ));
1233 send_wins_name_registration_response(RFS_ERR, 0, p);
1234 return;
1235 } else {
1236 /*
1237 * It's one of our names and one of our IP's. Ensure the IP is in the record and
1238 * update the ttl. Update the version ID to force replication.
1239 */
1240 if(!find_ip_in_name_record(namerec, from_ip)) {
1241 get_global_id_and_update(&namerec->data.id, True);
1242 update_wins_owner(namerec, our_fake_ip);
1243 update_wins_flag(namerec, WINS_ACTIVE);
1244
1245 add_ip_to_name_record(namerec, from_ip);
1246 wins_hook("add", namerec, ttl);
1247 } else {
1248 wins_hook("refresh", namerec, ttl);
1249 }
1250
1251 update_name_ttl(namerec, ttl);
1252 send_wins_name_registration_response(0, ttl, p);
1253 return;
1254 }
1255 }
1256
1257 /*
1258 * If the name exists and is active, check if the IP address is already registered
1259 * to that name. If so then update the ttl and reply success.
1260 */
1261
1262 if((namerec != NULL) && find_ip_in_name_record(namerec, from_ip) && WINS_STATE_ACTIVE(namerec)) {
1263 update_name_ttl(namerec, ttl);
1264
1265 /*
1266 * If it's a replica, we need to become the wins owner
1267 * to force the replication
1268 */
1269 if (!ip_equal(namerec->data.wins_ip, our_fake_ip)) {
1270 get_global_id_and_update(&namerec->data.id, True);
1271 update_wins_owner(namerec, our_fake_ip);
1272 update_wins_flag(namerec, WINS_ACTIVE);
1273 }
1274
1275 send_wins_name_registration_response(0, ttl, p);
1276 wins_hook("refresh", namerec, ttl);
1277 return;
1278 }
1279
1280 /*
1281 * If the name exists do a query to the owner
1282 * to see if they still want the name.
1283 */
1284
1285 if(namerec != NULL) {
1286 long *ud[(sizeof(struct userdata_struct) + sizeof(struct packet_struct *))/sizeof(long *) + 1];
1287 struct userdata_struct *userdata = (struct userdata_struct *)ud;
1288
1289 /*
1290 * First send a WACK to the registering machine.
1291 */
1292
1293 send_wins_wack_response(60, p);
1294
1295 /*
1296 * When the reply comes back we need the original packet.
1297 * Lock this so it won't be freed and then put it into
1298 * the userdata structure.
1299 */
1300
1301 p->locked = True;
1302
1303 userdata = (struct userdata_struct *)ud;
1304
1305 userdata->copy_fn = NULL;
1306 userdata->free_fn = NULL;
1307 userdata->userdata_len = sizeof(struct packet_struct *);
1308 memcpy(userdata->data, (char *)&p, sizeof(struct packet_struct *) );
1309
1310 /*
1311 * Use the new call to send a query directly to an IP address.
1312 * This sends the query directly to the IP address, and ensures
1313 * the recursion desired flag is not set (you were right Luke :-).
1314 * This function should *only* be called from the WINS server
1315 * code. JRA.
1316 *
1317 * Note that this packet is sent to the current owner of the name,
1318 * not the person who sent the packet
1319 */
1320
1321 pull_ascii_nstring( qname, sizeof(qname), question->name);
1322 query_name_from_wins_server( namerec->data.ip[0],
1323 qname,
1324 question->name_type,
1325 wins_multihomed_register_query_success,
1326 wins_multihomed_register_query_fail,
1327 userdata );
1328
1329 return;
1330 }
1331
1332 /*
1333 * Name did not exist - add it.
1334 */
1335
1336 pull_ascii_nstring( qname, sizeof(qname), question->name);
1337 add_name_to_subnet( subrec, qname, question->name_type,
1338 nb_flags, ttl, REGISTER_NAME, 1, &from_ip);
1339
1340 if ((namerec = find_name_on_subnet(subrec, question, FIND_ANY_NAME))) {
1341 get_global_id_and_update(&namerec->data.id, True);
1342 update_wins_owner(namerec, our_fake_ip);
1343 update_wins_flag(namerec, WINS_ACTIVE);
1344 wins_hook("add", namerec, ttl);
1345 }
1346
1347 send_wins_name_registration_response(0, ttl, p);
1348 }
1349
1350 /***********************************************************************
1351 Deal with the special name query for *<1b>.
1352 ***********************************************************************/
1353
1354 static void process_wins_dmb_query_request(struct subnet_record *subrec,
1355 struct packet_struct *p)
1356 {
1357 struct name_record *namerec = NULL;
1358 char *prdata;
1359 int num_ips;
1360
1361 /*
1362 * Go through all the ACTIVE names in the WINS db looking for those
1363 * ending in <1b>. Use this to calculate the number of IP
1364 * addresses we need to return.
1365 */
1366
1367 num_ips = 0;
1368 for( namerec = (struct name_record *)ubi_trFirst( subrec->namelist );
1369 namerec; namerec = (struct name_record *)ubi_trNext( namerec ) ) {
1370 if(WINS_STATE_ACTIVE(namerec) && namerec->name.name_type == 0x1b )
1371 num_ips += namerec->data.num_ips;
1372 }
1373
1374 if(num_ips == 0) {
1375 /*
1376 * There are no 0x1b names registered. Return name query fail.
1377 */
1378 send_wins_name_query_response(NAM_ERR, p, NULL);
1379 return;
1380 }
1381
1382 if((prdata = (char *)malloc( num_ips * 6 )) == NULL) {
1383 DEBUG(0,("process_wins_dmb_query_request: Malloc fail !.\n"));
1384 return;
1385 }
1386
1387 /*
1388 * Go through all the names again in the WINS db looking for those
1389 * ending in <1b>. Add their IP addresses into the list we will
1390 * return.
1391 */
1392
1393 num_ips = 0;
1394 for( namerec = (struct name_record *)ubi_trFirst( subrec->namelist );
1395 namerec; namerec = (struct name_record *)ubi_trNext( namerec ) ) {
1396 if(WINS_STATE_ACTIVE(namerec) && namerec->name.name_type == 0x1b) {
1397 int i;
1398 for(i = 0; i < namerec->data.num_ips; i++) {
1399 set_nb_flags(&prdata[num_ips * 6],namerec->data.nb_flags);
1400 putip((char *)&prdata[(num_ips * 6) + 2], &namerec->data.ip[i]);
1401 num_ips++;
1402 }
1403 }
1404 }
1405
1406 /*
1407 * Send back the reply containing the IP list.
1408 */
1409
1410 reply_netbios_packet(p, /* Packet to reply to. */
1411 0, /* Result code. */
1412 WINS_QUERY, /* nmbd type code. */
1413 NMB_NAME_QUERY_OPCODE, /* opcode. */
1414 lp_min_wins_ttl(), /* ttl. */
1415 prdata, /* data to send. */
1416 num_ips*6); /* data length. */
1417
1418 SAFE_FREE(prdata);
1419 }
1420
1421 /****************************************************************************
1422 Send a WINS name query response.
1423 **************************************************************************/
1424
1425 void send_wins_name_query_response(int rcode, struct packet_struct *p,
1426 struct name_record *namerec)
1427 {
1428 char rdata[6];
1429 char *prdata = rdata;
1430 int reply_data_len = 0;
1431 int ttl = 0;
1432 int i;
1433
1434 memset(rdata,'\0',6);
1435
1436 if(rcode == 0) {
1437 ttl = (namerec->data.death_time != PERMANENT_TTL) ? namerec->data.death_time - p->timestamp : lp_max_wins_ttl();
1438
1439 /* Copy all known ip addresses into the return data. */
1440 /* Optimise for the common case of one IP address so we don't need a malloc. */
1441
1442 if( namerec->data.num_ips == 1 ) {
1443 prdata = rdata;
1444 } else {
1445 if((prdata = (char *)malloc( namerec->data.num_ips * 6 )) == NULL) {
1446 DEBUG(0,("send_wins_name_query_response: malloc fail !\n"));
1447 return;
1448 }
1449 }
1450
1451 for(i = 0; i < namerec->data.num_ips; i++) {
1452 set_nb_flags(&prdata[i*6],namerec->data.nb_flags);
1453 putip((char *)&prdata[2+(i*6)], &namerec->data.ip[i]);
1454 }
1455
1456 sort_query_replies(prdata, i, p->ip);
1457 reply_data_len = namerec->data.num_ips * 6;
1458 }
1459
1460 reply_netbios_packet(p, /* Packet to reply to. */
1461 rcode, /* Result code. */
1462 WINS_QUERY, /* nmbd type code. */
1463 NMB_NAME_QUERY_OPCODE, /* opcode. */
1464 ttl, /* ttl. */
1465 prdata, /* data to send. */
1466 reply_data_len); /* data length. */
1467
1468 if(prdata != rdata)
1469 SAFE_FREE(prdata);
1470 }
1471
1472 /***********************************************************************
1473 Deal with a name query.
1474 ***********************************************************************/
1475
1476 void wins_process_name_query_request(struct subnet_record *subrec,
1477 struct packet_struct *p)
1478 {
1479 struct nmb_packet *nmb = &p->packet.nmb;
1480 struct nmb_name *question = &nmb->question.question_name;
1481 struct name_record *namerec = NULL;
1482 unstring qname;
1483
1484 DEBUG(3,("wins_process_name_query: name query for name %s from IP %s\n",
1485 nmb_namestr(question), inet_ntoa(p->ip) ));
1486
1487 /*
1488 * Special name code. If the queried name is *<1b> then search
1489 * the entire WINS database and return a list of all the IP addresses
1490 * registered to any <1b> name. This is to allow domain master browsers
1491 * to discover other domains that may not have a presence on their subnet.
1492 */
1493
1494 pull_ascii_nstring(qname, sizeof(qname), question->name);
1495 if(strequal( qname, "*") && (question->name_type == 0x1b)) {
1496 process_wins_dmb_query_request( subrec, p);
1497 return;
1498 }
1499
1500 namerec = find_name_on_subnet(subrec, question, FIND_ANY_NAME);
1501
1502 if(namerec != NULL) {
1503 /*
1504 * If the name is not anymore in active state then reply not found.
1505 * it's fair even if we keep it in the cache for days.
1506 */
1507 if (!WINS_STATE_ACTIVE(namerec)) {
1508 DEBUG(3,("wins_process_name_query: name query for name %s - name expired. Returning fail.\n",
1509 nmb_namestr(question) ));
1510 send_wins_name_query_response(NAM_ERR, p, namerec);
1511 return;
1512 }
1513
1514 /*
1515 * If it's a DNSFAIL_NAME then reply name not found.
1516 */
1517
1518 if( namerec->data.source == DNSFAIL_NAME ) {
1519 DEBUG(3,("wins_process_name_query: name query for name %s returning DNS fail.\n",
1520 nmb_namestr(question) ));
1521 send_wins_name_query_response(NAM_ERR, p, namerec);
1522 return;
1523 }
1524
1525 /*
1526 * If the name has expired then reply name not found.
1527 */
1528
1529 if( (namerec->data.death_time != PERMANENT_TTL) && (namerec->data.death_time < p->timestamp) ) {
1530 DEBUG(3,("wins_process_name_query: name query for name %s - name expired. Returning fail.\n",
1531 nmb_namestr(question) ));
1532 send_wins_name_query_response(NAM_ERR, p, namerec);
1533 return;
1534 }
1535
1536 DEBUG(3,("wins_process_name_query: name query for name %s returning first IP %s.\n",
1537 nmb_namestr(question), inet_ntoa(namerec->data.ip[0]) ));
1538
1539 send_wins_name_query_response(0, p, namerec);
1540 return;
1541 }
1542
1543 /*
1544 * Name not found in WINS - try a dns query if it's a 0x20 name.
1545 */
1546
1547 if(lp_dns_proxy() && ((question->name_type == 0x20) || question->name_type == 0)) {
1548 DEBUG(3,("wins_process_name_query: name query for name %s not found - doing dns lookup.\n",
1549 nmb_namestr(question) ));
1550
1551 queue_dns_query(p, question, &namerec);
1552 return;
1553 }
1554
1555 /*
1556 * Name not found - return error.
1557 */
1558
1559 send_wins_name_query_response(NAM_ERR, p, NULL);
1560 }
1561
1562 /****************************************************************************
1563 Send a WINS name release response.
1564 **************************************************************************/
1565
1566 static void send_wins_name_release_response(int rcode, struct packet_struct *p)
1567 {
1568 struct nmb_packet *nmb = &p->packet.nmb;
1569 char rdata[6];
1570
1571 memcpy(&rdata[0], &nmb->additional->rdata[0], 6);
1572
1573 reply_netbios_packet(p, /* Packet to reply to. */
1574 rcode, /* Result code. */
1575 NMB_REL, /* nmbd type code. */
1576 NMB_NAME_RELEASE_OPCODE, /* opcode. */
1577 0, /* ttl. */
1578 rdata, /* data to send. */
1579 6); /* data length. */
1580 }
1581
1582 /***********************************************************************
1583 Deal with a name release.
1584 ***********************************************************************/
1585
1586 void wins_process_name_release_request(struct subnet_record *subrec,
1587 struct packet_struct *p)
1588 {
1589 struct nmb_packet *nmb = &p->packet.nmb;
1590 struct nmb_name *question = &nmb->question.question_name;
1591 BOOL bcast = nmb->header.nm_flags.bcast;
1592 uint16 nb_flags = get_nb_flags(nmb->additional->rdata);
1593 struct name_record *namerec = NULL;
1594 struct in_addr from_ip;
1595 BOOL releasing_group_name = (nb_flags & NB_GROUP) ? True : False;;
1596
1597 putip((char *)&from_ip,&nmb->additional->rdata[2]);
1598
1599 if(bcast) {
1600 /*
1601 * We should only get unicast name registration packets here.
1602 * Anyone trying to register broadcast should not be going to a WINS
1603 * server. Log an error here.
1604 */
1605
1606 DEBUG(0,("wins_process_name_release_request: broadcast name registration request \
1607 received for name %s from IP %s on subnet %s. Error - should not be sent to WINS server\n",
1608 nmb_namestr(question), inet_ntoa(from_ip), subrec->subnet_name));
1609 return;
1610 }
1611
1612 DEBUG(3,("wins_process_name_release_request: %s name release for name %s \
1613 IP %s\n", releasing_group_name ? "Group" : "Unique", nmb_namestr(question), inet_ntoa(from_ip) ));
1614
1615 /*
1616 * Deal with policy regarding 0x1d names.
1617 */
1618
1619 if(!releasing_group_name && (question->name_type == 0x1d)) {
1620 DEBUG(3,("wins_process_name_release_request: Ignoring request \
1621 to release name %s from IP %s.", nmb_namestr(question), inet_ntoa(p->ip) ));
1622 send_wins_name_release_response(0, p);
1623 return;
1624 }
1625
1626 /*
1627 * See if the name already exists.
1628 */
1629
1630 namerec = find_name_on_subnet(subrec, question, FIND_ANY_NAME);
1631
1632 if( (namerec == NULL) || ((namerec != NULL) && (namerec->data.source != REGISTER_NAME)) ) {
1633 send_wins_name_release_response(NAM_ERR, p);
1634 return;
1635 }
1636
1637 /*
1638 * Check that the sending machine has permission to release this name.
1639 * If it's a group name not ending in 0x1c then just say yes and let
1640 * the group time out.
1641 */
1642
1643 if(releasing_group_name && (question->name_type != 0x1c)) {
1644 send_wins_name_release_response(0, p);
1645 return;
1646 }
1647
1648 /*
1649 * Check that the releasing node is on the list of IP addresses
1650 * for this name. Disallow the release if not.
1651 */
1652
1653 if(!find_ip_in_name_record(namerec, from_ip)) {
1654 DEBUG(3,("wins_process_name_release_request: Refusing request to \
1655 release name %s as IP %s is not one of the known IP's for this name.\n",
1656 nmb_namestr(question), inet_ntoa(from_ip) ));
1657 send_wins_name_release_response(NAM_ERR, p);
1658 return;
1659 }
1660
1661 /*
1662 * Check if the record is active. IF it's already released
1663 * or tombstoned, refuse the release.
1664 */
1665
1666 if (!WINS_STATE_ACTIVE(namerec)) {
1667 DEBUG(3,("wins_process_name_release_request: Refusing request to \
1668 release name %s as this record is not active anymore.\n", nmb_namestr(question) ));
1669 send_wins_name_release_response(NAM_ERR, p);
1670 return;
1671 }
1672
1673 /*
1674 * Check if the record is a 0x1c group
1675 * and has more then one ip
1676 * remove only this address.
1677 */
1678
1679 if(releasing_group_name && (question->name_type == 0x1c) && (namerec->data.num_ips > 1)) {
1680 remove_ip_from_name_record(namerec, from_ip);
1681 DEBUG(3,("wins_process_name_release_request: Remove IP %s from NAME: %s\n",
1682 inet_ntoa(from_ip),nmb_namestr(question)));
1683 send_wins_name_release_response(0, p);
1684 return;
1685 }
1686
1687 /*
1688 * Send a release response.
1689 * Flag the name as released and update the ttl
1690 */
1691
1692 send_wins_name_release_response(0, p);
1693
1694 namerec->data.wins_flags |= WINS_RELEASED;
1695 update_name_ttl(namerec, EXTINCTION_INTERVAL);
1696
1697 wins_hook("delete", namerec, 0);
1698 }
1699
1700 /*******************************************************************
1701 WINS time dependent processing.
1702 ******************************************************************/
1703
1704 void initiate_wins_processing(time_t t)
1705 {
1706 static time_t lasttime = 0;
1707 struct name_record *namerec;
1708 struct name_record *next_namerec;
1709 struct in_addr our_fake_ip = *interpret_addr2("0.0.0.0");
1710
1711 if (!lasttime)
1712 lasttime = t;
1713 if (t - lasttime < 20)
1714 return;
1715
1716 lasttime = t;
1717
1718 if(!lp_we_are_a_wins_server())
1719 return;
1720
1721 for( namerec = (struct name_record *)ubi_trFirst( wins_server_subnet->namelist );
1722 namerec;
1723 namerec = next_namerec ) {
1724 next_namerec = (struct name_record *)ubi_trNext( namerec );
1725
1726 if( (namerec->data.death_time != PERMANENT_TTL)
1727 && (namerec->data.death_time < t) ) {
1728
1729 if( namerec->data.source == SELF_NAME ) {
1730 DEBUG( 3, ( "expire_names_on_subnet: Subnet %s not expiring SELF name %s\n",
1731 wins_server_subnet->subnet_name, nmb_namestr(&namerec->name) ) );
1732 namerec->data.death_time += 300;
1733 namerec->subnet->namelist_changed = True;
1734 continue;
1735 }
1736
1737 /* handle records, samba is the wins owner */
1738 if (ip_equal(namerec->data.wins_ip, our_fake_ip)) {
1739 switch (namerec->data.wins_flags | WINS_STATE_MASK) {
1740 case WINS_ACTIVE:
1741 namerec->data.wins_flags&=~WINS_STATE_MASK;
1742 namerec->data.wins_flags|=WINS_RELEASED;
1743 namerec->data.death_time = t + EXTINCTION_INTERVAL;
1744 DEBUG(3,("initiate_wins_processing: expiring %s\n", nmb_namestr(&namerec->name)));
1745 break;
1746 case WINS_RELEASED:
1747 namerec->data.wins_flags&=~WINS_STATE_MASK;
1748 namerec->data.wins_flags|=WINS_TOMBSTONED;
1749 namerec->data.death_time = t + EXTINCTION_TIMEOUT;
1750 get_global_id_and_update(&namerec->data.id, True);
1751 DEBUG(3,("initiate_wins_processing: tombstoning %s\n", nmb_namestr(&namerec->name)));
1752 break;
1753 case WINS_TOMBSTONED:
1754 DEBUG(3,("initiate_wins_processing: deleting %s\n", nmb_namestr(&namerec->name)));
1755 remove_name_from_namelist( wins_server_subnet, namerec );
1756 break;
1757 }
1758 } else {
1759 switch (namerec->data.wins_flags | WINS_STATE_MASK) {
1760 case WINS_ACTIVE:
1761 /* that's not as MS says it should be */
1762 namerec->data.wins_flags&=~WINS_STATE_MASK;
1763 namerec->data.wins_flags|=WINS_TOMBSTONED;
1764 namerec->data.death_time = t + EXTINCTION_TIMEOUT;
1765 DEBUG(3,("initiate_wins_processing: tombstoning %s\n", nmb_namestr(&namerec->name)));
1766 case WINS_TOMBSTONED:
1767 DEBUG(3,("initiate_wins_processing: deleting %s\n", nmb_namestr(&namerec->name)));
1768 remove_name_from_namelist( wins_server_subnet, namerec );
1769 break;
1770 case WINS_RELEASED:
1771 DEBUG(0,("initiate_wins_processing: %s is in released state and\
1772 we are not the wins owner !\n", nmb_namestr(&namerec->name)));
1773 break;
1774 }
1775 }
1776
1777 }
1778 }
1779
1780 if(wins_server_subnet->namelist_changed)
1781 wins_write_database(True);
1782
1783 wins_server_subnet->namelist_changed = False;
1784 }
1785
1786 /*******************************************************************
1787 Write out the current WINS database.
1788 ******************************************************************/
1789
1790 void wins_write_database(BOOL background)
1791 {
1792 struct name_record *namerec;
1793 pstring fname, fnamenew;
1794
1795 XFILE *fp;
1796
1797 if(!lp_we_are_a_wins_server())
1798 return;
1799
1800 /* We will do the writing in a child process to ensure that the parent doesn't block while this is done */
1801 if (background) {
1802 CatchChild();
1803 if (sys_fork()) {
1804 return;
1805 }
1806 }
1807
1808 slprintf(fname,sizeof(fname)-1,"%s/%s", lp_lockdir(), WINS_LIST);
1809 all_string_sub(fname,"//", "/", 0);
1810 slprintf(fnamenew,sizeof(fnamenew)-1,"%s.%u", fname, (unsigned int)sys_getpid());
1811
1812 if((fp = x_fopen(fnamenew,O_WRONLY|O_CREAT,0644)) == NULL) {
1813 DEBUG(0,("wins_write_database: Can't open %s. Error was %s\n", fnamenew, strerror(errno)));
1814 if (background) {
1815 _exit(0);
1816 }
1817 return;
1818 }
1819
1820 DEBUG(4,("wins_write_database: Dump of WINS name list.\n"));
1821
1822 x_fprintf(fp,"VERSION %d %u\n", WINS_VERSION, 0);
1823
1824 for( namerec = (struct name_record *)ubi_trFirst( wins_server_subnet->namelist ); namerec; namerec = (struct name_record *)ubi_trNext( namerec ) ) {
1825 int i;
1826 struct tm *tm;
1827
1828 DEBUGADD(4,("%-19s ", nmb_namestr(&namerec->name) ));
1829
1830 if( namerec->data.death_time != PERMANENT_TTL ) {
1831 char *ts, *nl;
1832
1833 tm = LocalTime(&namerec->data.death_time);
1834 ts = asctime(tm);
1835 nl = strrchr( ts, '\n' );
1836 if( NULL != nl )
1837 *nl = '\0';
1838 DEBUGADD(4,("TTL = %s ", ts ));
1839 } else {
1840 DEBUGADD(4,("TTL = PERMANENT "));
1841 }
1842
1843 for (i = 0; i < namerec->data.num_ips; i++)
1844 DEBUGADD(4,("%15s ", inet_ntoa(namerec->data.ip[i]) ));
1845 DEBUGADD(4,("%2x\n", namerec->data.nb_flags ));
1846
1847 if( namerec->data.source == REGISTER_NAME ) {
1848 unstring name;
1849 pull_ascii_nstring(name, sizeof(name), namerec->name.name);
1850 x_fprintf(fp, "\"%s#%02x\" %d ", name,namerec->name.name_type, /* Ignore scope. */
1851 (int)namerec->data.death_time);
1852
1853 for (i = 0; i < namerec->data.num_ips; i++)
1854 x_fprintf( fp, "%s ", inet_ntoa( namerec->data.ip[i] ) );
1855 x_fprintf( fp, "%2xR\n", namerec->data.nb_flags );
1856 }
1857 }
1858
1859 x_fclose(fp);
1860 chmod(fnamenew,0644);
1861 unlink(fname);
1862 rename(fnamenew,fname);
1863 if (background) {
1864 _exit(0);
1865 }
1866 }
1867
1868 /****************************************************************************
1869 Process a internal Samba message receiving a wins record.
1870 ***************************************************************************/
1871
1872 void nmbd_wins_new_entry(int msg_type, pid_t src, void *buf, size_t len)
1873 {
1874 WINS_RECORD *record;
1875 struct name_record *namerec = NULL;
1876 struct name_record *new_namerec = NULL;
1877 struct nmb_name question;
1878 BOOL overwrite=False;
1879 struct in_addr our_fake_ip = *interpret_addr2("0.0.0.0");
1880 int i;
1881
1882 if (buf==NULL)
1883 return;
1884
1885 /* Record should use UNIX codepage. Ensure this is so in the wrepld code. JRA. */
1886 record=(WINS_RECORD *)buf;
1887
1888 make_nmb_name(&question, record->name, record->type);
1889
1890 namerec = find_name_on_subnet(wins_server_subnet, &question, FIND_ANY_NAME);
1891
1892 /* record doesn't exist, add it */
1893 if (namerec == NULL) {
1894 DEBUG(3,("nmbd_wins_new_entry: adding new replicated record: %s<%02x> for wins server: %s\n",
1895 record->name, record->type, inet_ntoa(record->wins_ip)));
1896
1897 new_namerec=add_name_to_subnet( wins_server_subnet, record->name, record->type, record->nb_flags,
1898 EXTINCTION_INTERVAL, REGISTER_NAME, record->num_ips, record->ip);
1899 if (new_namerec!=NULL) {
1900 update_wins_owner(new_namerec, record->wins_ip);
1901 update_wins_flag(new_namerec, record->wins_flags);
1902 new_namerec->data.id=record->id;
1903
1904 wins_server_subnet->namelist_changed = True;
1905 }
1906 }
1907
1908 /* check if we have a conflict */
1909 if (namerec != NULL) {
1910 /* both records are UNIQUE */
1911 if (namerec->data.wins_flags&WINS_UNIQUE && record->wins_flags&WINS_UNIQUE) {
1912
1913 /* the database record is a replica */
1914 if (!ip_equal(namerec->data.wins_ip, our_fake_ip)) {
1915 if (namerec->data.wins_flags&WINS_ACTIVE && record->wins_flags&WINS_TOMBSTONED) {
1916 if (ip_equal(namerec->data.wins_ip, record->wins_ip))
1917 overwrite=True;
1918 } else
1919 overwrite=True;
1920 } else {
1921 /* we are the wins owner of the database record */
1922 /* the 2 records have the same IP address */
1923 if (ip_equal(namerec->data.ip[0], record->ip[0])) {
1924 if (namerec->data.wins_flags&WINS_ACTIVE && record->wins_flags&WINS_TOMBSTONED)
1925 get_global_id_and_update(&namerec->data.id, True);
1926 else
1927 overwrite=True;
1928
1929 } else {
1930 /* the 2 records have different IP address */
1931 if (namerec->data.wins_flags&WINS_ACTIVE) {
1932 if (record->wins_flags&WINS_TOMBSTONED)
1933 get_global_id_and_update(&namerec->data.id, True);
1934 if (record->wins_flags&WINS_ACTIVE)
1935 /* send conflict challenge to the replica node */
1936 ;
1937 } else
1938 overwrite=True;
1939 }
1940
1941 }
1942 }
1943
1944 /* the replica is a standard group */
1945 if (record->wins_flags&WINS_NGROUP || record->wins_flags&WINS_SGROUP) {
1946 /* if the database record is unique and active force a name release */
1947 if (namerec->data.wins_flags&WINS_UNIQUE)
1948 /* send a release name to the unique node */
1949 ;
1950 overwrite=True;
1951
1952 }
1953
1954 /* the replica is a special group */
1955 if (record->wins_flags&WINS_SGROUP && namerec->data.wins_flags&WINS_SGROUP) {
1956 if (namerec->data.wins_flags&WINS_ACTIVE) {
1957 for (i=0; i<record->num_ips; i++)
1958 if(!find_ip_in_name_record(namerec, record->ip[i]))
1959 add_ip_to_name_record(namerec, record->ip[i]);
1960 } else {
1961 overwrite=True;
1962 }
1963 }
1964
1965 /* the replica is a multihomed host */
1966
1967 /* I'm giving up on multi homed. Too much complex to understand */
1968
1969 if (record->wins_flags&WINS_MHOMED) {
1970 if (! (namerec->data.wins_flags&WINS_ACTIVE)) {
1971 if ( !(namerec->data.wins_flags&WINS_RELEASED) && !(namerec->data.wins_flags&WINS_NGROUP))
1972 overwrite=True;
1973 }
1974 else {
1975 if (ip_equal(record->wins_ip, namerec->data.wins_ip))
1976 overwrite=True;
1977
1978 if (ip_equal(namerec->data.wins_ip, our_fake_ip))
1979 if (namerec->data.wins_flags&WINS_UNIQUE)
1980 get_global_id_and_update(&namerec->data.id, True);
1981
1982 }
1983
1984 if (record->wins_flags&WINS_ACTIVE && namerec->data.wins_flags&WINS_ACTIVE)
1985 if (namerec->data.wins_flags&WINS_UNIQUE ||
1986 namerec->data.wins_flags&WINS_MHOMED)
1987 if (ip_equal(record->wins_ip, namerec->data.wins_ip))
1988 overwrite=True;
1989
1990 }
1991
1992 if (overwrite == False)
1993 DEBUG(3, ("nmbd_wins_new_entry: conflict in adding record: %s<%02x> from wins server: %s\n",
1994 record->name, record->type, inet_ntoa(record->wins_ip)));
1995 else {
1996 DEBUG(3, ("nmbd_wins_new_entry: replacing record: %s<%02x> from wins server: %s\n",
1997 record->name, record->type, inet_ntoa(record->wins_ip)));
1998
1999 /* remove the old record and add a new one */
2000 remove_name_from_namelist( wins_server_subnet, namerec );
2001 new_namerec=add_name_to_subnet( wins_server_subnet, record->name, record->type, record->nb_flags,
2002 EXTINCTION_INTERVAL, REGISTER_NAME, record->num_ips, record->ip);
2003 if (new_namerec!=NULL) {
2004 update_wins_owner(new_namerec, record->wins_ip);
2005 update_wins_flag(new_namerec, record->wins_flags);
2006 new_namerec->data.id=record->id;
2007
2008 wins_server_subnet->namelist_changed = True;
2009 }
2010
2011 wins_server_subnet->namelist_changed = True;
2012 }
2013
2014 }
2015 }
reg import