2868d54ac4f53e3aa9624a7581aa8670492cf0e1
[samba.git] / source3 / namedb.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-1995
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    Revision History:
22
23    14 jan 96: lkcl@pires.co.uk
24    added multiple workgroup domain master support
25
26 */
27
28 #include "includes.h"
29 #include "smb.h"
30 #include "loadparm.h"
31
32 extern int ClientNMB;
33 extern int ClientDGRAM;
34
35 extern int DEBUGLEVEL;
36
37 extern time_t StartupTime;
38 extern pstring myname;
39 extern pstring scope;
40
41 /* this is our browse master/backup cache database */
42 struct browse_cache_record *browserlist = NULL;
43
44 /* this is our domain/workgroup/server database */
45 struct domain_record *domainlist = NULL;
46
47 static BOOL updatedlists = True;
48 int  updatecount=0;
49
50 int workgroup_count = 0; /* unique index key: one for each workgroup */
51
52 /* what server type are we currently */
53
54 #define DFLT_SERVER_TYPE (SV_TYPE_WORKSTATION | SV_TYPE_SERVER | \
55                         SV_TYPE_TIME_SOURCE | SV_TYPE_SERVER_UNIX | \
56                         SV_TYPE_PRINTQ_SERVER | SV_TYPE_POTENTIAL_BROWSER)
57
58 /* here are my election parameters */
59 #define MSBROWSE "\001\002__MSBROWSE__\002"
60
61
62 /****************************************************************************
63   add a workgroup into the domain list
64   **************************************************************************/
65 static void add_workgroup(struct work_record *work, struct domain_record *d)
66 {
67   struct work_record *w2;
68
69   if (!work || !d) return;
70
71   if (!d->workgrouplist)
72     {
73       d->workgrouplist = work;
74       work->prev = NULL;
75       work->next = NULL;
76       return;
77     }
78   
79   for (w2 = d->workgrouplist; w2->next; w2 = w2->next);
80   
81   w2->next = work;
82   work->next = NULL;
83   work->prev = w2;
84 }
85
86
87 /****************************************************************************
88   create a blank workgroup 
89   **************************************************************************/
90 static struct work_record *make_workgroup(char *name)
91 {
92   struct work_record *work;
93   struct domain_record *d;
94   int t = -1;
95   
96   if (!name || !name[0]) return NULL;
97   
98   work = (struct work_record *)malloc(sizeof(*work));
99   if (!work) return(NULL);
100   
101   StrnCpy(work->work_group,name,sizeof(work->work_group)-1);
102   work->serverlist = NULL;
103   
104   work->ServerType = DFLT_SERVER_TYPE;
105   work->RunningElection = False;
106   work->ElectionCount = 0;
107   work->needelection = False;
108   work->needannounce = True;
109   
110   /* make sure all token representations of workgroups are unique */
111   
112   for (d = domainlist; d && t == -1; d = d->next)
113     {
114       struct work_record *w;
115       for (w = d->workgrouplist; w && t == -1; w = w->next)
116         {
117           if (strequal(w->work_group, work->work_group)) t = w->token;
118         }
119     }
120   
121   if (t == -1)
122     {
123       work->token = ++workgroup_count;
124     }
125   else
126     {
127       work->token = t;
128     }
129   
130   
131   /* WfWg  uses 01040b01 */
132   /* Win95 uses 01041501 */
133   /* NTAS  uses ???????? */
134   work->ElectionCriterion  = (MAINTAIN_LIST<<1)|(ELECTION_VERSION<<8); 
135   work->ElectionCriterion |= (lp_os_level() << 24);
136   if (lp_domain_master()) {
137     work->ElectionCriterion |= 0x80;
138   }
139   
140   return work;
141 }
142
143
144 /*******************************************************************
145   expire old servers in the serverlist
146   time of -1 indicates everybody dies
147   ******************************************************************/
148 static void remove_old_servers(struct work_record *work, time_t t)
149 {
150   struct server_record *s;
151   struct server_record *nexts;
152   
153   /* expire old entries in the serverlist */
154   for (s = work->serverlist; s; s = nexts)
155     {
156       if (t == -1 || (s->death_time && s->death_time < t))
157         {
158           DEBUG(3,("Removing dead server %s\n",s->serv.name));
159           updatedlists = True;
160           nexts = s->next;
161           
162           if (s->prev) s->prev->next = s->next;
163           if (s->next) s->next->prev = s->prev;
164           
165           if (work->serverlist == s) 
166             work->serverlist = s->next; 
167
168           free(s);
169         }
170       else
171         {
172           nexts = s->next;
173         }
174     }
175 }
176
177
178 /*******************************************************************
179   remove workgroups
180   ******************************************************************/
181 struct work_record *remove_workgroup(struct domain_record *d, 
182                                      struct work_record *work)
183 {
184   struct work_record *ret_work = NULL;
185   
186   if (!d || !work) return NULL;
187   
188   DEBUG(3,("Removing old workgroup %s\n", work->work_group));
189   
190   remove_old_servers(work, -1);
191   
192   ret_work = work->next;
193   
194   if (work->prev) work->prev->next = work->next;
195   if (work->next) work->next->prev = work->prev;
196   
197   if (d->workgrouplist == work) d->workgrouplist = work->next; 
198   
199   free(work);
200   
201   return ret_work;
202 }
203
204
205 /****************************************************************************
206   add a domain into the list
207   **************************************************************************/
208 static void add_domain(struct domain_record *d)
209 {
210   struct domain_record *d2;
211
212   if (!domainlist)
213   {
214     domainlist = d;
215     d->prev = NULL;
216     d->next = NULL;
217     return;
218   }
219
220   for (d2 = domainlist; d2->next; d2 = d2->next);
221
222   d2->next = d;
223   d->next = NULL;
224   d->prev = d2;
225 }
226
227 /***************************************************************************
228   add a browser into the list
229   **************************************************************************/
230 static void add_browse_cache(struct browse_cache_record *b)
231 {
232   struct browse_cache_record *b2;
233
234   if (!browserlist)
235     {
236       browserlist = b;
237       b->prev = NULL;
238       b->next = NULL;
239       return;
240     }
241   
242   for (b2 = browserlist; b2->next; b2 = b2->next) ;
243   
244   b2->next = b;
245   b->next = NULL;
246   b->prev = b2;
247 }
248
249
250 /***************************************************************************
251   add a server into the list
252   **************************************************************************/
253 static void add_server(struct work_record *work,struct server_record *s)
254 {
255   struct server_record *s2;
256
257   if (!work->serverlist) {
258     work->serverlist = s;
259     s->prev = NULL;
260     s->next = NULL;
261     return;
262   }
263
264   for (s2 = work->serverlist; s2->next; s2 = s2->next) ;
265
266   s2->next = s;
267   s->next = NULL;
268   s->prev = s2;
269 }
270
271
272 /*******************************************************************
273   remove old browse entries
274   ******************************************************************/
275 void expire_browse_cache(time_t t)
276 {
277   struct browse_cache_record *b;
278   struct browse_cache_record *nextb;
279   
280   /* expire old entries in the serverlist */
281   for (b = browserlist; b; b = nextb)
282     {
283       if (b->synced && b->sync_time < t)
284         {
285           DEBUG(3,("Removing dead cached browser %s\n",b->name));
286           nextb = b->next;
287           
288           if (b->prev) b->prev->next = b->next;
289           if (b->next) b->next->prev = b->prev;
290           
291           if (browserlist == b) browserlist = b->next; 
292           
293           free(b);
294         }
295       else
296         {
297           nextb = b->next;
298         }
299     }
300 }
301
302
303 /****************************************************************************
304   find a workgroup in the workgrouplist 
305   only create it if the domain allows it, or the parameter 'add' insists
306   that it get created/added anyway. this allows us to force entries in
307   lmhosts file to be added.
308   **************************************************************************/
309 struct work_record *find_workgroupstruct(struct domain_record *d, 
310                                          fstring name, BOOL add)
311 {
312   struct work_record *ret, *work;
313   
314   if (!d) return NULL;
315   
316   DEBUG(4, ("workgroup search for %s: ", name));
317   
318   if (strequal(name, "*"))
319     {
320       DEBUG(2,("add any workgroups: initiating browser search on %s\n",
321                inet_ntoa(d->bcast_ip)));
322       queue_netbios_pkt_wins(ClientNMB,NMB_QUERY, FIND_MASTER,
323                              MSBROWSE,0x1,0,
324                              True,False, d->bcast_ip);
325       return NULL;
326     }
327   
328   for (ret = d->workgrouplist; ret; ret = ret->next) {
329     if (!strcmp(ret->work_group,name)) {
330       DEBUG(4, ("found\n"));
331       return(ret);
332     }
333   }
334
335   if (!add) {
336     DEBUG(4, ("not found\n"));
337     return NULL;
338   }
339
340   DEBUG(4,("not found: creating\n"));
341   
342   if ((work = make_workgroup(name)))
343     {
344       if (lp_preferred_master() &&
345           strequal(lp_workgroup(), name) &&
346           ismybcast(d->bcast_ip))
347         {
348           DEBUG(3, ("preferred master startup for %s\n", work->work_group));
349           work->needelection = True;
350           work->ElectionCriterion |= (1<<3);
351         }
352       if (!ismybcast(d->bcast_ip))
353         {
354           work->needelection = False;
355         }
356       add_workgroup(work, d);
357       return(work);
358     }
359   return NULL;
360 }
361
362 /****************************************************************************
363   find a domain in the domainlist 
364   **************************************************************************/
365 struct domain_record *find_domain(struct in_addr source_ip)
366 {   
367   struct domain_record *d;
368   
369   /* search through domain list for broadcast/netmask that matches
370      the source ip address */
371   
372   for (d = domainlist; d; d = d->next)
373     {
374       if (same_net(source_ip, d->bcast_ip, d->mask_ip))
375         {
376           return(d);
377         }
378     }
379   
380   return (NULL);
381 }
382
383
384 /****************************************************************************
385   dump a copy of the workgroup/domain database
386   **************************************************************************/
387 void dump_workgroups(void)
388 {
389   struct domain_record *d;
390   
391   for (d = domainlist; d; d = d->next)
392     {
393       if (d->workgrouplist)
394         {
395           struct work_record *work;
396           
397           DEBUG(4,("dump domain bcast=%15s: ", inet_ntoa(d->bcast_ip)));
398           DEBUG(4,(" netmask=%15s:\n", inet_ntoa(d->mask_ip)));
399           
400           for (work = d->workgrouplist; work; work = work->next)
401             {
402               DEBUG(4,("\t%s(%d)\n", work->work_group, work->token));
403               if (work->serverlist)
404                 {
405                   struct server_record *s;                
406                   for (s = work->serverlist; s; s = s->next)
407                     {
408                       DEBUG(4,("\t\t%s %8x (%s)\n",
409                                s->serv.name, s->serv.type, s->serv.comment));
410                     }
411                 }
412             }
413         }
414     }
415 }
416
417 /****************************************************************************
418   create a domain entry
419   ****************************************************************************/
420 static struct domain_record *make_domain(struct in_addr ip, struct in_addr mask)
421 {
422   struct domain_record *d;
423   d = (struct domain_record *)malloc(sizeof(*d));
424   
425   if (!d) return(NULL);
426   
427   bzero((char *)d,sizeof(*d));
428   
429   DEBUG(4, ("making domain %s ", inet_ntoa(ip)));
430   DEBUG(4, ("%s\n", inet_ntoa(mask)));
431   
432   d->bcast_ip = ip;
433   d->mask_ip  = mask;
434   d->workgrouplist = NULL;
435   
436   add_domain(d);
437   
438   return d;
439 }
440
441 /****************************************************************************
442   add a domain entry. creates a workgroup, if necessary, and adds the domain
443   to the named a workgroup.
444   ****************************************************************************/
445 struct domain_record *add_domain_entry(struct in_addr source_ip, 
446                                        struct in_addr source_mask,
447                                        char *name, BOOL add)
448 {
449   struct domain_record *d;
450   struct in_addr ip;
451   
452   ip = *interpret_addr2("255.255.255.255");
453   
454   if (zero_ip(source_ip)) 
455     source_ip = *iface_bcast(source_ip);
456   
457   /* add the domain into our domain database */
458   if ((d = find_domain(source_ip)) ||
459       (d = make_domain(source_ip, source_mask)))
460     {
461       struct work_record *w = find_workgroupstruct(d, name, add);
462       
463       if (!w) return NULL;
464
465       /* add WORKGROUP(1e) and WORKGROUP(00) entries into name database
466          or register with WINS server, if it's our workgroup */
467       if (strequal(lp_workgroup(), name))
468         {
469           extern pstring ServerComment;
470           add_name_entry(name,0x1e,NB_ACTIVE|NB_GROUP);
471           add_name_entry(name,0x0 ,NB_ACTIVE|NB_GROUP);
472           add_server_entry(d,w,myname,w->ServerType,0,ServerComment,True);
473         }
474       
475       DEBUG(3,("Added domain name entry %s at %s\n", name,inet_ntoa(ip)));
476       return d;
477     }
478   return NULL;
479 }
480
481 /****************************************************************************
482   add a browser entry
483   ****************************************************************************/
484 struct browse_cache_record *add_browser_entry(char *name, int type, char *wg,
485                                               time_t ttl, struct in_addr ip)
486 {
487   BOOL newentry=False;
488   
489   struct browse_cache_record *b;
490
491   /* search for the entry: if it's already in the cache, update that entry */
492   for (b = browserlist; b; b = b->next)
493     {
494       if (ip_equal(ip,b->ip) && strequal(b->group, wg)) break;
495     }
496   
497   if (b && b->synced)
498     {
499       /* entries get left in the cache for a while. this stops sync'ing too
500          often if the network is large */
501       DEBUG(4, ("browser %s %s %s already sync'd at time %d\n",
502                 b->name, b->group, inet_ntoa(b->ip), b->sync_time));
503       return NULL;
504     }
505   
506   if (!b)
507     {
508       newentry = True;
509       b = (struct browse_cache_record *)malloc(sizeof(*b));
510       
511       if (!b) return(NULL);
512       
513       bzero((char *)b,sizeof(*b));
514     }
515   
516   /* update the entry */
517   ttl = time(NULL)+ttl;
518   
519   StrnCpy(b->name ,name,sizeof(b->name )-1);
520   StrnCpy(b->group,wg  ,sizeof(b->group)-1);
521   strupper(b->name);
522   strupper(b->group);
523   
524   b->ip     = ip;
525   b->type   = type;
526   
527   if (newentry || ttl < b->sync_time) 
528     b->sync_time = ttl;
529   
530   if (newentry)
531     {
532       b->synced = False;
533       add_browse_cache(b);
534       
535       DEBUG(3,("Added cache entry %s %s(%2x) %s ttl %d\n",
536                wg, name, type, inet_ntoa(ip),ttl));
537     }
538   else
539     {
540       DEBUG(3,("Updated cache entry %s %s(%2x) %s ttl %d\n",
541                wg, name, type, inet_ntoa(ip),ttl));
542     }
543   
544   return(b);
545 }
546
547
548 /****************************************************************************
549   add a server entry
550   ****************************************************************************/
551 struct server_record *add_server_entry(struct domain_record *d, 
552                                        struct work_record *work,
553                                        char *name,int servertype, 
554                                        int ttl,char *comment,
555                                        BOOL replace)
556 {
557   BOOL newentry=False;
558   struct server_record *s;
559   
560   if (name[0] == '*')
561     {
562       return (NULL);
563     }
564   
565   for (s = work->serverlist; s; s = s->next)
566     {
567       if (strequal(name,s->serv.name)) break;
568     }
569   
570   if (s && !replace)
571     {
572       DEBUG(4,("Not replacing %s\n",name));
573       return(s);
574     }
575   
576   updatedlists=True;
577   
578   if (!s)
579     {
580       newentry = True;
581       s = (struct server_record *)malloc(sizeof(*s));
582       
583       if (!s) return(NULL);
584       
585       bzero((char *)s,sizeof(*s));
586     }
587   
588   if (ismybcast(d->bcast_ip) &&
589       strequal(lp_workgroup(),work->work_group))
590     {
591       if (servertype)
592         servertype |= SV_TYPE_LOCAL_LIST_ONLY;
593     }
594   else
595     {
596       servertype &= ~SV_TYPE_LOCAL_LIST_ONLY;
597     }
598   
599   /* update the entry */
600   StrnCpy(s->serv.name,name,sizeof(s->serv.name)-1);
601   StrnCpy(s->serv.comment,comment,sizeof(s->serv.comment)-1);
602   strupper(s->serv.name);
603   s->serv.type  = servertype;
604   s->death_time = ttl?time(NULL)+ttl*3:0;
605
606   if (servertype == 0)
607     s->death_time = time(NULL)-1;
608   
609   /* for a domain entry, the comment field refers to the server name */
610   
611   if (s->serv.type & SV_TYPE_DOMAIN_ENUM) strupper(s->serv.comment);
612   
613   if (newentry)
614     {
615       add_server(work, s);
616       
617       DEBUG(3,("Added "));
618     }
619   else
620     {
621       DEBUG(3,("Updated "));
622     }
623   
624   DEBUG(3,("server entry %s of type %x (%s) to %s %s\n",
625            name,servertype,comment,
626            work->work_group,inet_ntoa(d->bcast_ip)));
627   
628   return(s);
629 }
630
631
632 /*******************************************************************
633   write out browse.dat
634   ******************************************************************/
635 void write_browse_list(void)
636 {
637   struct domain_record *d;
638   
639   pstring fname,fnamenew;
640   FILE *f;
641   
642   if (!updatedlists) return;
643   
644   dump_names();
645   dump_workgroups();
646   
647   updatedlists = False;
648   updatecount++;
649   
650   strcpy(fname,lp_lockdir());
651   trim_string(fname,NULL,"/");
652   strcat(fname,"/");
653   strcat(fname,SERVER_LIST);
654   strcpy(fnamenew,fname);
655   strcat(fnamenew,".");
656   
657   f = fopen(fnamenew,"w");
658   
659   if (!f)
660     {
661       DEBUG(4,("Can't open %s - %s\n",fnamenew,strerror(errno)));
662       return;
663     }
664   
665   for (d = domainlist; d ; d = d->next)
666     {
667       struct work_record *work;
668       for (work = d->workgrouplist; work ; work = work->next)
669         {
670           struct server_record *s;
671           for (s = work->serverlist; s ; s = s->next)
672             {
673               fstring tmp;
674               
675               /* don't list domains I don't have a master for */
676               if ((s->serv.type & SV_TYPE_DOMAIN_ENUM) &&
677                   !s->serv.comment[0])
678                 {
679                   continue;
680                 }
681               
682               /* output server details, plus what workgroup/domain
683                  they're in. without the domain information, the
684                  combined list of all servers in all workgroups gets
685                  sent to anyone asking about any workgroup! */
686               
687               sprintf(tmp, "\"%s\"", s->serv.name);
688               fprintf(f, "%-25s ", tmp);
689               fprintf(f, "%08x ", s->serv.type);
690               sprintf(tmp, "\"%s\" ", s->serv.comment);
691               fprintf(f, "%-30s", tmp);
692               fprintf(f, "\"%s\"\n", work->work_group);
693             }
694         }
695     }
696   
697   fclose(f);
698   unlink(fname);
699   chmod(fnamenew,0644);
700   rename(fnamenew,fname);   
701   DEBUG(3,("Wrote browse list %s\n",fname));
702 }
703
704
705 /*******************************************************************
706   expire old servers in the serverlist
707   ******************************************************************/
708 void expire_servers(time_t t)
709 {
710   struct domain_record *d;
711   
712   for (d = domainlist ; d ; d = d->next)
713     {
714       struct work_record *work;
715       
716       for (work = d->workgrouplist; work; work = work->next)
717         {
718           remove_old_servers(work, t);
719         }
720     }
721 }
722