5c514c263ffe1248d06ce4afe1c72d69216467b9
[kai/samba.git] / source3 / namedbname.c
1 /* 
2    Unix SMB/Netbios implementation.
3    Version 1.9.
4    NBT netbios routines and daemon - version 2
5    Copyright (C) Andrew Tridgell 1994-1997
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    Module name: namedbname.c
22
23    Revision History:
24
25    14 jan 96: lkcl@pires.co.uk
26    added multiple workgroup domain master support
27
28    04 jul 96: lkcl@pires.co.uk
29    created module namedbname containing name database functions
30 */
31
32 #include "includes.h"
33
34 extern int DEBUGLEVEL;
35
36 extern pstring scope;
37 extern struct in_addr ipzero;
38 extern struct in_addr wins_ip;
39
40 extern struct subnet_record *subnetlist;
41
42 #define WINS_LIST "wins.dat"
43
44 uint16 nb_type = 0; /* samba's NetBIOS name type */
45
46
47 /****************************************************************************
48   samba's NetBIOS name type
49
50   XXXX maybe functionality could be set: B, M, P or H name registration
51   and resolution could be set through nb_type. just a thought.  
52   ****************************************************************************/
53 void set_samba_nb_type(void)
54 {
55         if (lp_wins_support() || (*lp_wins_server()))
56         {
57                 nb_type = NB_MFLAG; /* samba is a 'hybrid' node type */
58         }
59         else
60         {
61                 nb_type = NB_BFLAG; /* samba is broadcast-only node type */
62         }
63 }
64
65
66 /****************************************************************************
67   true if two netbios names are equal
68 ****************************************************************************/
69 BOOL name_equal(struct nmb_name *n1,struct nmb_name *n2)
70 {
71   return n1->name_type == n2->name_type &&
72                  strequal(n1->name ,n2->name ) &&
73          strequal(n1->scope,n2->scope);
74 }
75
76
77 /****************************************************************************
78   true if the netbios name is ^1^2__MSBROWSE__^2^1
79
80   note: this name is registered if as a master browser or backup browser
81   you are responsible for a workgroup (when you announce a domain by
82   broadcasting on your local subnet, you announce it as coming from this
83   name: see announce_host()).
84
85   **************************************************************************/
86 BOOL ms_browser_name(char *name, int type)
87 {
88   return strequal(name,MSBROWSE) && type == 0x01;
89 }
90
91
92 /****************************************************************************
93   add a netbios name into the namelist
94   **************************************************************************/
95 static void add_name(struct subnet_record *d, struct name_record *n)
96 {
97   struct name_record *n2;
98
99   if (!d) return;
100
101   if (!d->namelist)
102   {
103     d->namelist = n;
104     n->prev = NULL;
105     n->next = NULL;
106     return;
107   }
108
109   for (n2 = d->namelist; n2->next; n2 = n2->next) ;
110
111   n2->next = n;
112   n->next = NULL;
113   n->prev = n2;
114 }
115
116
117 /****************************************************************************
118   remove a name from the namelist. The pointer must be an element just 
119   retrieved
120   **************************************************************************/
121 void remove_name(struct subnet_record *d, struct name_record *n)
122 {
123   struct name_record *nlist;
124   if (!d) return;
125
126   nlist = d->namelist;
127
128   while (nlist && nlist != n) nlist = nlist->next;
129
130   if (nlist)
131   {
132     if (nlist->next) nlist->next->prev = nlist->prev;
133     if (nlist->prev) nlist->prev->next = nlist->next;
134     free(nlist);
135   }
136 }
137
138
139 /****************************************************************************
140   find a name in a namelist.
141   **************************************************************************/
142 struct name_record *find_name(struct name_record *n,
143                         struct nmb_name *name, int search)
144 {
145         struct name_record *ret;
146   
147         for (ret = n; ret; ret = ret->next)
148         {
149                 if (name_equal(&ret->name,name))
150                 {
151                         /* self search: self names only */
152                         if ((search&FIND_SELF) == FIND_SELF && ret->source != SELF)
153                         {
154                                 continue;
155                         }
156                         DEBUG(9,("find_name: found name %s\n", name->name));
157                         return ret;
158                 }
159         }
160     DEBUG(9,("find_name: name %s NOT FOUND\n", name->name));
161     return NULL;
162 }
163
164
165 /****************************************************************************
166   find a name in the domain database namelist 
167   search can be any of:
168   FIND_SELF - look exclusively for names the samba server has added for itself
169   FIND_LOCAL - look for names in the local subnet record.
170   FIND_WINS - look for names in the WINS record
171   **************************************************************************/
172 struct name_record *find_name_search(struct subnet_record **d,
173                         struct nmb_name *name,
174                         int search, struct in_addr ip)
175 {
176   if (d == NULL) return NULL; /* bad error! */
177         
178   if (search & FIND_LOCAL) {
179     if (*d != NULL) {
180       struct name_record *n = find_name((*d)->namelist, name, search);
181       DEBUG(4,("find_name on local: %s %s search %x\n",
182                namestr(name),inet_ntoa(ip), search));
183       if (n) return n;
184     }
185   }
186
187   if (!(search & FIND_WINS)) return NULL;
188
189   /* find WINS subnet record. */
190   *d = wins_subnet;
191   
192   if (*d == NULL) return NULL;
193   
194   DEBUG(4,("find_name on WINS: %s %s search %x\n",
195            namestr(name),inet_ntoa(ip), search));
196   return find_name((*d)->namelist, name, search);
197 }
198
199
200 /****************************************************************************
201   dump a copy of the name table
202   **************************************************************************/
203 void dump_names(void)
204 {
205   struct name_record *n;
206   fstring fname, fnamenew;
207   time_t t = time(NULL);
208   
209   FILE *f;
210  
211   if(lp_wins_support() == False || wins_subnet == 0)
212     return;
213  
214   strcpy(fname,lp_lockdir());
215   trim_string(fname,NULL,"/");
216   strcat(fname,"/");
217   strcat(fname,WINS_LIST);
218   strcpy(fnamenew,fname);
219   strcat(fnamenew,".");
220   
221   f = fopen(fnamenew,"w");
222   
223   if (!f)
224   {
225     DEBUG(3,("Can't open %s - %s\n",fnamenew,strerror(errno)));
226     return;
227   }
228   
229   DEBUG(4,("Dump of WINS name table:\n"));
230   
231   for (n = wins_subnet->namelist; n; n = n->next)
232    {
233      int i;
234
235      DEBUG(4,("%15s ", inet_ntoa(wins_subnet->bcast_ip)));
236      DEBUG(4,("%15s ", inet_ntoa(wins_subnet->mask_ip)));
237      DEBUG(4,("%-19s TTL=%ld ",
238                namestr(&n->name),
239                n->death_time?n->death_time-t:0));
240
241      for (i = 0; i < n->num_ips; i++)
242       {
243         DEBUG(4,("%15s NB=%2x source=%d",
244                  inet_ntoa(n->ip_flgs[i].ip),
245                     n->ip_flgs[i].nb_flags,n->source));
246
247       }
248      DEBUG(4,("\n"));
249
250      if (f && n->source == REGISTER)
251       {
252       /* XXXX i have little imagination as to how to output nb_flags as
253          anything other than as a hexadecimal number :-) */
254
255         fprintf(f, "%s#%02x %ld ",
256                n->name.name,n->name.name_type, /* XXXX ignore scope for now */
257                n->death_time);
258
259         for (i = 0; i < n->num_ips; i++)
260         {
261            fprintf(f, "%s %2x ",
262                                                 inet_ntoa(n->ip_flgs[i].ip),
263                                                 n->ip_flgs[i].nb_flags);
264         }
265                 fprintf(f, "\n");
266       }
267
268   }
269
270   fclose(f);
271   unlink(fname);
272   chmod(fnamenew,0644);
273   rename(fnamenew,fname);   
274
275   DEBUG(3,("Wrote wins database %s\n",fname));
276 }
277
278
279 /****************************************************************************
280   load a netbios name database file
281
282   XXXX we cannot cope with loading Internet Group names, yet
283   ****************************************************************************/
284 void load_netbios_names(void)
285 {
286   struct subnet_record *d = wins_subnet;
287   fstring fname;
288
289   FILE *f;
290   pstring line;
291
292   if (!d) return;
293
294   strcpy(fname,lp_lockdir());
295   trim_string(fname,NULL,"/");
296   strcat(fname,"/");
297   strcat(fname,WINS_LIST);
298
299   f = fopen(fname,"r");
300
301   if (!f) {
302     DEBUG(2,("Can't open wins database file %s\n",fname));
303     return;
304   }
305
306   while (!feof(f))
307     {
308       pstring name_str, ip_str, ttd_str, nb_flags_str;
309
310       pstring name;
311       int type = 0;
312       unsigned int nb_flags;
313       time_t ttd;
314           struct in_addr ipaddr;
315
316           enum name_source source;
317
318       char *ptr;
319           int count = 0;
320
321       char *p;
322
323       if (!fgets_slash(line,sizeof(pstring),f)) continue;
324
325       if (*line == '#') continue;
326
327         ptr = line;
328
329         if (next_token(&ptr,name_str    ,NULL)) ++count;
330         if (next_token(&ptr,ttd_str     ,NULL)) ++count;
331         if (next_token(&ptr,ip_str      ,NULL)) ++count;
332         if (next_token(&ptr,nb_flags_str,NULL)) ++count;
333
334         if (count <= 0) continue;
335
336         if (count != 4) {
337           DEBUG(0,("Ill formed wins line"));
338           DEBUG(0,("[%s]: name#type abs_time ip nb_flags\n",line));
339           continue;
340         }
341
342       /* netbios name. # divides the name from the type (hex): netbios#xx */
343       strcpy(name,name_str);
344
345       p = strchr(name,'#');
346
347       if (p) {
348             *p = 0;
349             sscanf(p+1,"%x",&type);
350       }
351
352       /* decode the netbios flags (hex) and the time-to-die (seconds) */
353           sscanf(nb_flags_str,"%x",&nb_flags);
354           sscanf(ttd_str,"%ld",&ttd);
355
356           ipaddr = *interpret_addr2(ip_str);
357
358       if (ip_equal(ipaddr,ipzero)) {
359          source = SELF;
360       }
361       else
362       {
363          source = REGISTER;
364       }
365
366       DEBUG(4, ("add WINS line: %s#%02x %ld %s %2x\n",
367                name,type, ttd, inet_ntoa(ipaddr), nb_flags));
368
369       /* add all entries that have 60 seconds or more to live */
370       if (ttd - 60 > time(NULL) || ttd == 0)
371       {
372         time_t t = (ttd?ttd-time(NULL):0) / 3;
373
374         /* add netbios entry read from the wins.dat file. IF it's ok */
375         add_netbios_entry(d,name,type,nb_flags,t,source,ipaddr,True,True);
376       }
377     }
378
379   fclose(f);
380 }
381
382
383 /****************************************************************************
384   remove an entry from the name list
385   ****************************************************************************/
386 void remove_netbios_name(struct subnet_record *d,
387                         char *name,int type, enum name_source source,
388                          struct in_addr ip)
389 {
390   struct nmb_name nn;
391   struct name_record *n;
392
393   make_nmb_name(&nn, name, type, scope);
394   n = find_name_search(&d, &nn, FIND_LOCAL, ip);
395   
396   if (n && n->source == source) remove_name(d,n);
397 }
398
399
400 /****************************************************************************
401   add an entry to the name list.
402
403   this is a multi-purpose function.
404
405   it adds samba's own names in to its records on each interface, keeping a
406   record of whether it is a master browser, domain master, or WINS server.
407
408   it also keeps a record of WINS entries.
409
410   ****************************************************************************/
411 struct name_record *add_netbios_entry(struct subnet_record *d,
412                 char *name, int type, int nb_flags, 
413                 int ttl, enum name_source source, struct in_addr ip,
414                 BOOL new_only,BOOL wins)
415 {
416   struct name_record *n;
417   struct name_record *n2=NULL;
418   struct subnet_record *found_subnet = 0;
419   int search = 0;
420   BOOL self = source == SELF;
421
422   /* add the name to the WINS list if the name comes from a directed query */
423   search |= wins ? FIND_WINS : FIND_LOCAL;
424   /* search for SELF names only */
425   search |= self ? FIND_SELF : 0;
426
427   if (!self)
428   {
429     if (!wins && type != 0x1b)
430     {
431        /* the only broadcast (non-WINS) names we are adding are ours
432           (SELF) and Domain Master type names */
433        return NULL;
434     }
435   }
436
437   n = (struct name_record *)malloc(sizeof(*n));
438   if (!n) return(NULL);
439
440   bzero((char *)n,sizeof(*n));
441
442   n->num_ips = 1; /* XXXX ONLY USE THIS FUNCTION FOR ONE ENTRY */
443   n->ip_flgs = (struct nmb_ip*)malloc(sizeof(*n->ip_flgs) * n->num_ips);
444   if (!n->ip_flgs)
445   {
446      free(n);
447      return NULL;
448   }
449
450   make_nmb_name(&n->name,name,type,scope);
451
452   if ((n2 = find_name_search(&found_subnet, &n->name, search, new_only?ipzero:ip)))
453   {
454     free(n->ip_flgs);
455     free(n);
456     if (new_only || (n2->source==SELF && source!=SELF)) return n2;
457     n = n2;
458     d = found_subnet;
459   }
460
461   if (ttl)
462      n->death_time = time(NULL)+ttl*3;
463   n->refresh_time = time(NULL)+GET_TTL(ttl);
464
465   /* XXXX only one entry expected with this function */
466   n->ip_flgs[0].ip = ip;
467   n->ip_flgs[0].nb_flags = nb_flags;
468
469   n->source = source;
470   
471   if (!n2) add_name(d,n);
472
473   DEBUG(3,("Added netbios name %s at %s ttl=%d nb_flags=%2x to interface %s\n",
474            namestr(&n->name),inet_ntoa(ip),ttl,nb_flags,
475            ip_equal(d->bcast_ip, wins_ip) ? "WINS" : (char *)inet_ntoa(d->bcast_ip)));
476
477   return(n);
478 }
479
480
481 /*******************************************************************
482   expires old names in the namelist
483   ******************************************************************/
484 void expire_names(time_t t)
485 {
486         struct name_record *n;
487         struct name_record *next;
488         struct subnet_record *d;
489
490         /* expire old names */
491         for (d = FIRST_SUBNET; d; d = NEXT_SUBNET_INCLUDING_WINS(d))
492         {
493           for (n = d->namelist; n; n = next)
494             {
495               next = n->next;
496               if (n->death_time && n->death_time < t)
497                 {
498                   if (n->source == SELF) {
499                     DEBUG(3,("not expiring SELF name %s\n", namestr(&n->name)));
500                     n->death_time += 300;
501                     continue;
502                   }
503                   DEBUG(3,("Removing dead name %s\n", namestr(&n->name)));
504                   
505                   if (n->prev) n->prev->next = n->next;
506                   if (n->next) n->next->prev = n->prev;
507                   
508                   if (d->namelist == n) d->namelist = n->next; 
509                   
510                   free(n->ip_flgs);
511                   free(n);
512                 }
513             }
514         }
515 }
516
517
518 /***************************************************************************
519   assume a WINS name is a dns name, and do a gethostbyname() on it.
520   ****************************************************************************/
521 struct name_record *dns_name_search(struct nmb_name *question, int Time)
522 {
523         int name_type = question->name_type;
524         char *qname = question->name;
525         char *r;
526         BOOL dns_type = (name_type == 0x20 || name_type == 0);
527         struct in_addr dns_ip;
528
529         if (wins_subnet == NULL) 
530           return NULL;
531
532         DEBUG(3,("Search for %s - ", namestr(question)));
533
534         /* only do DNS lookups if the query is for type 0x20 or type 0x0 */
535         if (!dns_type)
536         {
537                 DEBUG(3,("types 0x20 0x0 only: name not found\n"));
538                 return NULL;
539         }
540
541         /* look it up with DNS */      
542         dns_ip.s_addr = interpret_addr(qname);
543
544         if (!dns_ip.s_addr)
545         {
546                 /* no luck with DNS. We could possibly recurse here XXXX */
547                 DEBUG(3,("not found. no recursion.\n"));
548                 /* add the fail to WINS cache of names. give it 1 hour in the cache */
549                 add_netbios_entry(wins_subnet,qname,name_type,NB_ACTIVE,60*60,DNSFAIL,dns_ip,
550                                   True, True);
551                 return NULL;
552         }
553
554         DEBUG(3,("found with DNS: %s\n", inet_ntoa(dns_ip)));
555
556         /* add it to our WINS cache of names. give it 2 hours in the cache */
557         return add_netbios_entry(wins_subnet,qname,name_type,NB_ACTIVE,2*60*60,DNS,dns_ip,
558                                  True,True);
559 }