Modified fix for bugid #784. Based on a patch from moriyama@miraclelinux.com (MORIYAM...
[samba.git] / source3 / nmbd / nmbd_browsesync.c
1 /* 
2    Unix SMB/CIFS implementation.
3    NBT netbios routines and daemon - version 2
4    Copyright (C) Andrew Tridgell 1994-1998
5    Copyright (C) Luke Kenneth Casson Leighton 1994-1998
6    Copyright (C) Jeremy Allison 1994-2003
7    
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 2 of the License, or
11    (at your option) any later version.
12    
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17    
18    You should have received a copy of the GNU General Public License
19    along with this program; if not, write to the Free Software
20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21    
22 */
23
24 #include "includes.h"
25
26 /* This is our local master browser list database. */
27 extern ubi_dlList lmb_browserlist[];
28
29 /****************************************************************************
30 As a domain master browser, do a sync with a local master browser.
31 **************************************************************************/
32
33 static void sync_with_lmb(struct browse_cache_record *browc)
34 {                     
35         struct work_record *work;
36
37         if( !(work = find_workgroup_on_subnet(unicast_subnet, browc->work_group)) ) {
38                 if( DEBUGLVL( 0 ) ) {
39                         dbgtext( "sync_with_lmb:\n" );
40                         dbgtext( "Failed to get a workgroup for a local master browser " );
41                         dbgtext( "cache entry workgroup " );
42                         dbgtext( "%s, server %s\n", browc->work_group, browc->lmb_name );
43                 }
44                 return;
45         }
46
47         /* We should only be doing this if we are a domain master browser for
48                 the given workgroup. Ensure this is so. */
49
50         if(!AM_DOMAIN_MASTER_BROWSER(work)) {
51                 if( DEBUGLVL( 0 ) ) {
52                         dbgtext( "sync_with_lmb:\n" );
53                         dbgtext( "We are trying to sync with a local master browser " );
54                         dbgtext( "%s for workgroup %s\n", browc->lmb_name, browc->work_group );
55                         dbgtext( "and we are not a domain master browser on this workgroup.\n" );
56                         dbgtext( "Error!\n" );
57                 }
58                 return;
59         }
60
61         if( DEBUGLVL( 2 ) ) {
62                 dbgtext( "sync_with_lmb:\n" );
63                 dbgtext( "Initiating sync with local master browser " );
64                 dbgtext( "%s<0x20> at IP %s ", browc->lmb_name, inet_ntoa(browc->ip) );
65                 dbgtext( "for workgroup %s\n", browc->work_group );
66         }
67
68         sync_browse_lists(work, browc->lmb_name, 0x20, browc->ip, True, True);
69
70         browc->sync_time += (CHECK_TIME_DMB_TO_LMB_SYNC * 60);
71 }
72
73 /****************************************************************************
74 Sync or expire any local master browsers.
75 **************************************************************************/
76
77 void dmb_expire_and_sync_browser_lists(time_t t)
78 {
79         static time_t last_run = 0;
80         struct browse_cache_record *browc;
81
82         /* Only do this every 20 seconds. */  
83         if (t - last_run < 20) 
84                 return;
85
86         last_run = t;
87
88         expire_lmb_browsers(t);
89
90         for( browc = (struct browse_cache_record *)ubi_dlFirst( lmb_browserlist );
91                         browc;
92                         browc = (struct browse_cache_record *)ubi_dlNext( browc ) ) {
93                 if (browc->sync_time < t)
94                         sync_with_lmb(browc);
95         }
96 }
97
98 /****************************************************************************
99 As a local master browser, send an announce packet to the domain master browser.
100 **************************************************************************/
101
102 static void announce_local_master_browser_to_domain_master_browser( struct work_record *work)
103 {
104         pstring outbuf;
105         fstring myname;
106         char *p;
107
108         if(ismyip(work->dmb_addr)) {
109                 if( DEBUGLVL( 2 ) ) {
110                         dbgtext( "announce_local_master_browser_to_domain_master_browser:\n" );
111                         dbgtext( "We are both a domain and a local master browser for " );
112                         dbgtext( "workgroup %s.  ", work->work_group );
113                         dbgtext( "Do not announce to ourselves.\n" );
114                 }
115                 return;
116         }
117
118         memset(outbuf,'\0',sizeof(outbuf));
119         p = outbuf;
120         SCVAL(p,0,ANN_MasterAnnouncement);
121         p++;
122
123         fstrcpy(myname, global_myname());
124         strupper_m(myname);
125         myname[15]='\0';
126         /* The call below does CH_UNIX -> CH_DOS conversion. JRA */
127         push_pstring_base(p, myname, outbuf);
128
129         p = skip_string(p,1);
130
131         if( DEBUGLVL( 4 ) ) {
132                 dbgtext( "announce_local_master_browser_to_domain_master_browser:\n" );
133                 dbgtext( "Sending local master announce to " );
134                 dbgtext( "%s for workgroup %s.\n", nmb_namestr(&work->dmb_name),
135                                         work->work_group );
136         }
137
138         send_mailslot(True, BROWSE_MAILSLOT, outbuf,PTR_DIFF(p,outbuf),
139                 global_myname(), 0x0, work->dmb_name.name, 0x0, 
140                 work->dmb_addr, FIRST_SUBNET->myip, DGRAM_PORT);
141 }
142
143 /****************************************************************************
144 As a local master browser, do a sync with a domain master browser.
145 **************************************************************************/
146
147 static void sync_with_dmb(struct work_record *work)
148 {
149         fstring dmb_name;
150
151         if( DEBUGLVL( 2 ) ) {
152                 dbgtext( "sync_with_dmb:\n" );
153                 dbgtext( "Initiating sync with domain master browser " );
154                 dbgtext( "%s ", nmb_namestr(&work->dmb_name) );
155                 dbgtext( "at IP %s ", inet_ntoa(work->dmb_addr) );
156                 dbgtext( "for workgroup %s\n", work->work_group );
157         }
158
159         pull_ascii_nstring(dmb_name, sizeof(fstring), work->dmb_name.name);
160         sync_browse_lists(work, dmb_name, work->dmb_name.name_type, 
161                 work->dmb_addr, False, True);
162 }
163
164 /****************************************************************************
165   Function called when a node status query to a domain master browser IP succeeds.
166 ****************************************************************************/
167
168 static void domain_master_node_status_success(struct subnet_record *subrec,
169                                               struct userdata_struct *userdata,
170                                               struct res_rec *answers,
171                                               struct in_addr from_ip)
172 {
173         struct work_record *work = find_workgroup_on_subnet( subrec, userdata->data);
174
175         if( work == NULL ) {
176                 if( DEBUGLVL( 0 ) ) {
177                         dbgtext( "domain_master_node_status_success:\n" );
178                         dbgtext( "Unable to find workgroup " );
179                         dbgtext( "%s on subnet %s.\n", userdata->data, subrec->subnet_name );
180                 }
181                 return;
182         }
183
184         if( DEBUGLVL( 3 ) ) {
185                 dbgtext( "domain_master_node_status_success:\n" );
186                 dbgtext( "Success in node status for workgroup " );
187                 dbgtext( "%s from ip %s\n", work->work_group, inet_ntoa(from_ip) );
188         }
189
190   /* Go through the list of names found at answers->rdata and look for
191      the first SERVER<0x20> name. */
192
193         if(answers->rdata != NULL) {
194                 char *p = answers->rdata;
195                 int numnames = CVAL(p, 0);
196
197                 p += 1;
198
199                 while (numnames--) {
200                         fstring qname;
201                         uint16 nb_flags;
202                         int name_type;
203
204                         pull_ascii_nstring(qname, sizeof(qname), p);
205                         name_type = CVAL(p,15);
206                         nb_flags = get_nb_flags(&p[16]);
207                         trim_char(qname,'\0',' ');
208
209                         p += 18;
210
211                         if(!(nb_flags & NB_GROUP) && (name_type == 0x20)) {
212                                 struct nmb_name nmbname;
213
214                                 make_nmb_name(&nmbname, qname, name_type);
215
216                                 /* Copy the dmb name and IP address
217                                         into the workgroup struct. */
218
219                                 work->dmb_name = nmbname;
220                                 putip((char *)&work->dmb_addr, &from_ip);
221
222                                 /* Do the local master browser announcement to the domain
223                                         master browser name and IP. */
224                                 announce_local_master_browser_to_domain_master_browser( work );
225
226                                 /* Now synchronise lists with the domain master browser. */
227                                 sync_with_dmb(work);
228                                 break;
229                         }
230                 }
231         } else if( DEBUGLVL( 0 ) ) {
232                 dbgtext( "domain_master_node_status_success:\n" );
233                 dbgtext( "Failed to find a SERVER<0x20> name in reply from IP " );
234                 dbgtext( "%s.\n", inet_ntoa(from_ip) );
235         }
236 }
237
238 /****************************************************************************
239   Function called when a node status query to a domain master browser IP fails.
240 ****************************************************************************/
241
242 static void domain_master_node_status_fail(struct subnet_record *subrec,
243                        struct response_record *rrec)
244 {
245         struct userdata_struct *userdata = rrec->userdata;
246
247         if( DEBUGLVL( 0 ) ) {
248                 dbgtext( "domain_master_node_status_fail:\n" );
249                 dbgtext( "Doing a node status request to the domain master browser\n" );
250                 dbgtext( "for workgroup %s ", userdata ? userdata->data : "NULL" );
251                 dbgtext( "at IP %s failed.\n", inet_ntoa(rrec->packet->ip) );
252                 dbgtext( "Cannot sync browser lists.\n" );
253         }
254 }
255
256 /****************************************************************************
257   Function called when a query for a WORKGROUP<1b> name succeeds.
258 ****************************************************************************/
259
260 static void find_domain_master_name_query_success(struct subnet_record *subrec,
261                         struct userdata_struct *userdata_in,
262                         struct nmb_name *q_name, struct in_addr answer_ip, struct res_rec *rrec)
263 {
264         /* 
265          * Unfortunately, finding the IP address of the Domain Master Browser,
266          * as we have here, is not enough. We need to now do a sync to the
267          * SERVERNAME<0x20> NetBIOS name, as only recent NT servers will
268          * respond to the SMBSERVER name. To get this name from IP
269          * address we do a Node status request, and look for the first
270          * NAME<0x20> in the response, and take that as the server name.
271          * We also keep a cache of the Domain Master Browser name for this
272          * workgroup in the Workgroup struct, so that if the same IP addess
273          * is returned every time, we don't need to do the node status
274          * request.
275          */
276
277         struct work_record *work;
278         struct nmb_name nmbname;
279         struct userdata_struct *userdata;
280         size_t size = sizeof(struct userdata_struct) + sizeof(fstring)+1;
281         fstring qname;
282
283         pull_ascii_nstring(qname, sizeof(qname), q_name->name);
284         if( !(work = find_workgroup_on_subnet(subrec, qname)) ) {
285                 if( DEBUGLVL( 0 ) ) {
286                         dbgtext( "find_domain_master_name_query_success:\n" );
287                         dbgtext( "Failed to find workgroup %s\n", qname);
288                 }
289         return;
290   }
291
292   /* First check if we already have a dmb for this workgroup. */
293
294         if(!is_zero_ip(work->dmb_addr) && ip_equal(work->dmb_addr, answer_ip)) {
295                 /* Do the local master browser announcement to the domain
296                         master browser name and IP. */
297                 announce_local_master_browser_to_domain_master_browser( work );
298
299                 /* Now synchronise lists with the domain master browser. */
300                 sync_with_dmb(work);
301                 return;
302         } else {
303                 zero_ip(&work->dmb_addr);
304         }
305
306         /* Now initiate the node status request. */
307
308         /* We used to use the name "*",0x0 here, but some Windows
309          * servers don't answer that name. However we *know* they
310          * have the name workgroup#1b (as we just looked it up).
311          * So do the node status request on this name instead.
312          * Found at LBL labs. JRA.
313          */
314
315         make_nmb_name(&nmbname,work->work_group,0x1b);
316
317         /* Put the workgroup name into the userdata so we know
318          what workgroup we're talking to when the reply comes
319          back. */
320
321         /* Setup the userdata_struct - this is copied so we can use
322         a stack variable for this. */
323
324         if((userdata = (struct userdata_struct *)malloc(size)) == NULL) {
325                 DEBUG(0, ("find_domain_master_name_query_success: malloc fail.\n"));
326                 return;
327         }
328
329         userdata->copy_fn = NULL;
330         userdata->free_fn = NULL;
331         userdata->userdata_len = strlen(work->work_group)+1;
332         overmalloc_safe_strcpy(userdata->data, work->work_group, size - sizeof(*userdata) - 1);
333
334         node_status( subrec, &nmbname, answer_ip, 
335                 domain_master_node_status_success,
336                 domain_master_node_status_fail,
337                 userdata);
338
339         zero_free(userdata, size);
340 }
341
342 /****************************************************************************
343   Function called when a query for a WORKGROUP<1b> name fails.
344   ****************************************************************************/
345
346 static void find_domain_master_name_query_fail(struct subnet_record *subrec,
347                                     struct response_record *rrec,
348                                     struct nmb_name *question_name, int fail_code)
349 {
350         if( DEBUGLVL( 0 ) ) {
351                 dbgtext( "find_domain_master_name_query_fail:\n" );
352                 dbgtext( "Unable to find the Domain Master Browser name " );
353                 dbgtext( "%s for the workgroup %s.\n",
354                         nmb_namestr(question_name), question_name->name );
355                 dbgtext( "Unable to sync browse lists in this workgroup.\n" );
356         }
357 }
358
359 /****************************************************************************
360 As a local master browser for a workgroup find the domain master browser
361 name, announce ourselves as local master browser to it and then pull the
362 full domain browse lists from it onto the given subnet.
363 **************************************************************************/
364
365 void announce_and_sync_with_domain_master_browser( struct subnet_record *subrec,
366                                                    struct work_record *work)
367 {
368         /* Only do this if we are using a WINS server. */
369         if(we_are_a_wins_client() == False) {
370                 if( DEBUGLVL( 10 ) ) {
371                         dbgtext( "announce_and_sync_with_domain_master_browser:\n" );
372                         dbgtext( "Ignoring, as we are not a WINS client.\n" );
373                 }
374                 return;
375         }
376
377         /* First, query for the WORKGROUP<1b> name from the WINS server. */
378         query_name(unicast_subnet, work->work_group, 0x1b,
379              find_domain_master_name_query_success,
380              find_domain_master_name_query_fail,
381              NULL);
382 }
383
384 /****************************************************************************
385   Function called when a node status query to a domain master browser IP succeeds.
386   This function is only called on query to a Samba 1.9.18 or above WINS server.
387
388   Note that adding the workgroup name is enough for this workgroup to be
389   browsable by clients, as clients query the WINS server or broadcast 
390   nets for the WORKGROUP<1b> name when they want to browse a workgroup
391   they are not in. We do not need to do a sync with this Domain Master
392   Browser in order for our browse clients to see machines in this workgroup.
393   JRA.
394 ****************************************************************************/
395
396 static void get_domain_master_name_node_status_success(struct subnet_record *subrec,
397                                               struct userdata_struct *userdata,
398                                               struct res_rec *answers,
399                                               struct in_addr from_ip)
400 {
401         struct work_record *work;
402         fstring server_name;
403
404         server_name[0] = 0;
405
406         if( DEBUGLVL( 3 ) ) {
407                 dbgtext( "get_domain_master_name_node_status_success:\n" );
408                 dbgtext( "Success in node status from ip %s\n", inet_ntoa(from_ip) );
409         }
410
411         /* 
412          * Go through the list of names found at answers->rdata and look for
413          * the first WORKGROUP<0x1b> name.
414          */
415
416         if(answers->rdata != NULL) {
417                 char *p = answers->rdata;
418                 int numnames = CVAL(p, 0);
419
420                 p += 1;
421
422                 while (numnames--) {
423                         fstring qname;
424                         uint16 nb_flags;
425                         int name_type;
426
427                         pull_ascii_nstring(qname, sizeof(qname), p);
428                         name_type = CVAL(p,15);
429                         nb_flags = get_nb_flags(&p[16]);
430                         trim_char(qname,'\0',' ');
431
432                         p += 18;
433
434                         if(!(nb_flags & NB_GROUP) && (name_type == 0x00) && 
435                                         server_name[0] == 0) {
436                                 /* this is almost certainly the server netbios name */
437                                 fstrcpy(server_name, qname);
438                                 continue;
439                         }
440
441                         if(!(nb_flags & NB_GROUP) && (name_type == 0x1b)) {
442                                 if( DEBUGLVL( 5 ) ) {
443                                         dbgtext( "get_domain_master_name_node_status_success:\n" );
444                                         dbgtext( "%s(%s) ", server_name, inet_ntoa(from_ip) );
445                                         dbgtext( "is a domain master browser for workgroup " );
446                                         dbgtext( "%s. Adding this name.\n", qname );
447                                 }
448
449                                 /* 
450                                  * If we don't already know about this workgroup, add it
451                                  * to the workgroup list on the unicast_subnet.
452                                  */
453
454                                 if((work = find_workgroup_on_subnet( subrec, qname)) == NULL) {
455                                         struct nmb_name nmbname;
456                                         /* 
457                                          * Add it - with an hour in the cache.
458                                          */
459                                         if(!(work= create_workgroup_on_subnet(subrec, qname, 60*60)))
460                                                 return;
461
462                                         /* remember who the master is */
463                                         fstrcpy(work->local_master_browser_name, server_name);
464                                         make_nmb_name(&nmbname, server_name, 0x20);
465                                         work->dmb_name = nmbname;
466                                         work->dmb_addr = from_ip;
467                                 }
468                                 break;
469                         }
470                 }
471         } else if( DEBUGLVL( 0 ) ) {
472                 dbgtext( "get_domain_master_name_node_status_success:\n" );
473                 dbgtext( "Failed to find a WORKGROUP<0x1b> name in reply from IP " );
474                 dbgtext( "%s.\n", inet_ntoa(from_ip) );
475         }
476 }
477
478 /****************************************************************************
479   Function called when a node status query to a domain master browser IP fails.
480 ****************************************************************************/
481
482 static void get_domain_master_name_node_status_fail(struct subnet_record *subrec,
483                        struct response_record *rrec)
484 {
485         if( DEBUGLVL( 0 ) ) {
486                 dbgtext( "get_domain_master_name_node_status_fail:\n" );
487                 dbgtext( "Doing a node status request to the domain master browser " );
488                 dbgtext( "at IP %s failed.\n", inet_ntoa(rrec->packet->ip) );
489                 dbgtext( "Cannot get workgroup name.\n" );
490         }
491 }
492
493 /****************************************************************************
494   Function called when a query for *<1b> name succeeds.
495 ****************************************************************************/
496
497 static void find_all_domain_master_names_query_success(struct subnet_record *subrec,
498                         struct userdata_struct *userdata_in,
499                         struct nmb_name *q_name, struct in_addr answer_ip, struct res_rec *rrec)
500 {
501         /* 
502          * We now have a list of all the domain master browsers for all workgroups
503          * that have registered with the WINS server. Now do a node status request
504          * to each one and look for the first 1b name in the reply. This will be
505          * the workgroup name that we will add to the unicast subnet as a 'non-local'
506          * workgroup.
507          */
508
509         struct nmb_name nmbname;
510         struct in_addr send_ip;
511         int i;
512
513         if( DEBUGLVL( 5 ) ) {
514                 dbgtext( "find_all_domain_master_names_query_succes:\n" );
515                 dbgtext( "Got answer from WINS server of %d ", (rrec->rdlength / 6) );
516                 dbgtext( "IP addresses for Domain Master Browsers.\n" );
517         }
518
519         for(i = 0; i < rrec->rdlength / 6; i++) {
520                 /* Initiate the node status requests. */
521                 make_nmb_name(&nmbname, "*", 0);
522
523                 putip((char *)&send_ip, (char *)&rrec->rdata[(i*6) + 2]);
524
525                 /* 
526                  * Don't send node status requests to ourself.
527                  */
528
529                 if(ismyip( send_ip )) {
530                         if( DEBUGLVL( 5 ) ) {
531                                 dbgtext( "find_all_domain_master_names_query_succes:\n" );
532                                 dbgtext( "Not sending node status to our own IP " );
533                                 dbgtext( "%s.\n", inet_ntoa(send_ip) );
534                         }
535                         continue;
536                 }
537
538                 if( DEBUGLVL( 5 ) ) {
539                         dbgtext( "find_all_domain_master_names_query_success:\n" );
540                         dbgtext( "Sending node status request to IP %s.\n", inet_ntoa(send_ip) );
541                 }
542
543                 node_status( subrec, &nmbname, send_ip, 
544                                 get_domain_master_name_node_status_success,
545                                 get_domain_master_name_node_status_fail,
546                                 NULL);
547         }
548 }
549
550 /****************************************************************************
551   Function called when a query for *<1b> name fails.
552   ****************************************************************************/
553 static void find_all_domain_master_names_query_fail(struct subnet_record *subrec,
554                                     struct response_record *rrec,
555                                     struct nmb_name *question_name, int fail_code)
556 {
557         if( DEBUGLVL( 10 ) ) {
558                 dbgtext( "find_domain_master_name_query_fail:\n" );
559                 dbgtext( "WINS server did not reply to a query for name " );
560                 dbgtext( "%s.\nThis means it ", nmb_namestr(question_name) );
561                 dbgtext( "is probably not a Samba 1.9.18 or above WINS server.\n" );
562         }
563 }
564
565 /****************************************************************************
566  If we are a domain master browser on the unicast subnet, do a query to the
567  WINS server for the *<1b> name. This will only work to a Samba WINS server,
568  so ignore it if we fail. If we succeed, contact each of the IP addresses in
569  turn and do a node status request to them. If this succeeds then look for a
570  <1b> name in the reply - this is the workgroup name. Add this to the unicast
571  subnet. This is expensive, so we only do this every 15 minutes.
572 **************************************************************************/
573
574 void collect_all_workgroup_names_from_wins_server(time_t t)
575 {
576         static time_t lastrun = 0;
577         struct work_record *work;
578
579         /* Only do this if we are using a WINS server. */
580         if(we_are_a_wins_client() == False)
581                 return;
582
583         /* Check to see if we are a domain master browser on the unicast subnet. */
584         if((work = find_workgroup_on_subnet( unicast_subnet, lp_workgroup())) == NULL) {
585                 if( DEBUGLVL( 0 ) ) {
586                         dbgtext( "collect_all_workgroup_names_from_wins_server:\n" );
587                         dbgtext( "Cannot find my workgroup %s ", lp_workgroup() );
588                         dbgtext( "on subnet %s.\n", unicast_subnet->subnet_name );
589                 }
590                 return;
591         }
592
593         if(!AM_DOMAIN_MASTER_BROWSER(work))
594                 return;
595
596         if ((lastrun != 0) && (t < lastrun + (15 * 60)))
597                 return;
598      
599         lastrun = t;
600
601         /* First, query for the *<1b> name from the WINS server. */
602         query_name(unicast_subnet, "*", 0x1b,
603                 find_all_domain_master_names_query_success,
604                 find_all_domain_master_names_query_fail,
605                 NULL);
606
607
608
609 /****************************************************************************
610  If we are a domain master browser on the unicast subnet, do a regular sync
611  with all other DMBs that we know of on that subnet.
612
613 To prevent exponential network traffic with large numbers of workgroups
614 we use a randomised system where sync probability is inversely proportional
615 to the number of known workgroups
616 **************************************************************************/
617
618 void sync_all_dmbs(time_t t)
619 {
620         static time_t lastrun = 0;
621         struct work_record *work;
622         int count=0;
623
624         /* Only do this if we are using a WINS server. */
625         if(we_are_a_wins_client() == False)
626                 return;
627
628         /* Check to see if we are a domain master browser on the
629            unicast subnet. */
630         work = find_workgroup_on_subnet(unicast_subnet, lp_workgroup());
631         if (!work)
632                 return;
633
634         if (!AM_DOMAIN_MASTER_BROWSER(work))
635                 return;
636
637         if ((lastrun != 0) && (t < lastrun + (5 * 60)))
638                 return;
639      
640         /* count how many syncs we might need to do */
641         for (work=unicast_subnet->workgrouplist; work; work = work->next) {
642                 if (strncmp(lp_workgroup(), work->work_group, sizeof(nstring))) {
643                         count++;
644                 }
645         }
646
647         /* sync with a probability of 1/count */
648         for (work=unicast_subnet->workgrouplist; work; work = work->next) {
649                 if (strncmp(lp_workgroup(), work->work_group, sizeof(nstring))) {
650                         fstring dmb_name;
651
652                         if (((unsigned)sys_random()) % count != 0)
653                                 continue;
654
655                         lastrun = t;
656
657                         if (!work->dmb_name.name[0]) {
658                                 /* we don't know the DMB - assume it is
659                                    the same as the unicast local master */
660                                 make_nmb_name(&work->dmb_name, 
661                                               work->local_master_browser_name,
662                                               0x20);
663                         }
664
665                         pull_ascii_nstring(dmb_name, sizeof(dmb_name), work->dmb_name.name);
666
667                         DEBUG(3,("Initiating DMB<->DMB sync with %s(%s)\n",
668                                  dmb_name, inet_ntoa(work->dmb_addr)));
669
670                         sync_browse_lists(work, 
671                                           dmb_name,
672                                           work->dmb_name.name_type, 
673                                           work->dmb_addr, False, False);
674                 }
675         }
676 }