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