Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

source: vendor/current/source3/nmbd/nmbd_winsserver.c@ 414

Visit:

Last change on this file since 414 was 414, checked in by Herwig Bauernfeind, 16 years ago
Samba 3.5.0: Initial import
File size: 77.2 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: