#include "includes.h"
extern ubi_dlList lmb_browserlist[];
static void sync_with_lmb(struct browse_cache_record *browc)
{
struct work_record *work;
if( !(work = find_workgroup_on_subnet(unicast_subnet, browc->work_group)) ) {
if( DEBUGLVL( 0 ) ) {
dbgtext( "sync_with_lmb:\n" );
dbgtext( "Failed to get a workgroup for a local master browser " );
dbgtext( "cache entry workgroup " );
dbgtext( "%s, server %s\n", browc->work_group, browc->lmb_name );
}
return;
}
if(!AM_DOMAIN_MASTER_BROWSER(work)) {
if( DEBUGLVL( 0 ) ) {
dbgtext( "sync_with_lmb:\n" );
dbgtext( "We are trying to sync with a local master browser " );
dbgtext( "%s for workgroup %s\n", browc->lmb_name, browc->work_group );
dbgtext( "and we are not a domain master browser on this workgroup.\n" );
dbgtext( "Error!\n" );
}
return;
}
if( DEBUGLVL( 2 ) ) {
dbgtext( "sync_with_lmb:\n" );
dbgtext( "Initiating sync with local master browser " );
dbgtext( "%s<0x20> at IP %s ", browc->lmb_name, inet_ntoa(browc->ip) );
dbgtext( "for workgroup %s\n", browc->work_group );
}
sync_browse_lists(work, browc->lmb_name, 0x20, browc->ip, True, True);
browc->sync_time += (CHECK_TIME_DMB_TO_LMB_SYNC * 60);
}
void dmb_expire_and_sync_browser_lists(time_t t)
{
static time_t last_run = 0;
struct browse_cache_record *browc;
if (t - last_run < 20)
return;
last_run = t;
expire_lmb_browsers(t);
for( browc = (struct browse_cache_record *)ubi_dlFirst( lmb_browserlist );
browc;
browc = (struct browse_cache_record *)ubi_dlNext( browc ) ) {
if (browc->sync_time < t)
sync_with_lmb(browc);
}
}
static void announce_local_master_browser_to_domain_master_browser( struct work_record *work)
{
pstring outbuf;
unstring myname;
unstring dmb_name;
char *p;
if(ismyip(work->dmb_addr)) {
if( DEBUGLVL( 2 ) ) {
dbgtext( "announce_local_master_browser_to_domain_master_browser:\n" );
dbgtext( "We are both a domain and a local master browser for " );
dbgtext( "workgroup %s. ", work->work_group );
dbgtext( "Do not announce to ourselves.\n" );
}
return;
}
memset(outbuf,'\0',sizeof(outbuf));
p = outbuf;
SCVAL(p,0,ANN_MasterAnnouncement);
p++;
unstrcpy(myname, global_myname());
strupper_m(myname);
myname[15]='\0';
push_pstring_base(p, myname, outbuf);
p = skip_string(p,1);
if( DEBUGLVL( 4 ) ) {
dbgtext( "announce_local_master_browser_to_domain_master_browser:\n" );
dbgtext( "Sending local master announce to " );
dbgtext( "%s for workgroup %s.\n", nmb_namestr(&work->dmb_name),
work->work_group );
}
pull_ascii_nstring(dmb_name, sizeof(dmb_name), work->dmb_name.name);
send_mailslot(True, BROWSE_MAILSLOT, outbuf,PTR_DIFF(p,outbuf),
global_myname(), 0x0, dmb_name, 0x0,
work->dmb_addr, FIRST_SUBNET->myip, DGRAM_PORT);
}
static void sync_with_dmb(struct work_record *work)
{
unstring dmb_name;
if( DEBUGLVL( 2 ) ) {
dbgtext( "sync_with_dmb:\n" );
dbgtext( "Initiating sync with domain master browser " );
dbgtext( "%s ", nmb_namestr(&work->dmb_name) );
dbgtext( "at IP %s ", inet_ntoa(work->dmb_addr) );
dbgtext( "for workgroup %s\n", work->work_group );
}
pull_ascii_nstring(dmb_name, sizeof(dmb_name), work->dmb_name.name);
sync_browse_lists(work, dmb_name, work->dmb_name.name_type,
work->dmb_addr, False, True);
}
static void domain_master_node_status_success(struct subnet_record *subrec,
struct userdata_struct *userdata,
struct res_rec *answers,
struct in_addr from_ip)
{
struct work_record *work = find_workgroup_on_subnet( subrec, userdata->data);
if( work == NULL ) {
if( DEBUGLVL( 0 ) ) {
dbgtext( "domain_master_node_status_success:\n" );
dbgtext( "Unable to find workgroup " );
dbgtext( "%s on subnet %s.\n", userdata->data, subrec->subnet_name );
}
return;
}
if( DEBUGLVL( 3 ) ) {
dbgtext( "domain_master_node_status_success:\n" );
dbgtext( "Success in node status for workgroup " );
dbgtext( "%s from ip %s\n", work->work_group, inet_ntoa(from_ip) );
}
if(answers->rdata != NULL) {
char *p = answers->rdata;
int numnames = CVAL(p, 0);
p += 1;
while (numnames--) {
unstring qname;
uint16 nb_flags;
int name_type;
pull_ascii_nstring(qname, sizeof(qname), p);
name_type = CVAL(p,15);
nb_flags = get_nb_flags(&p[16]);
trim_char(qname,'\0',' ');
p += 18;
if(!(nb_flags & NB_GROUP) && (name_type == 0x20)) {
struct nmb_name nmbname;
make_nmb_name(&nmbname, qname, name_type);
work->dmb_name = nmbname;
putip((char *)&work->dmb_addr, &from_ip);
announce_local_master_browser_to_domain_master_browser( work );
sync_with_dmb(work);
break;
}
}
} else if( DEBUGLVL( 0 ) ) {
dbgtext( "domain_master_node_status_success:\n" );
dbgtext( "Failed to find a SERVER<0x20> name in reply from IP " );
dbgtext( "%s.\n", inet_ntoa(from_ip) );
}
}
static void domain_master_node_status_fail(struct subnet_record *subrec,
struct response_record *rrec)
{
struct userdata_struct *userdata = rrec->userdata;
if( DEBUGLVL( 0 ) ) {
dbgtext( "domain_master_node_status_fail:\n" );
dbgtext( "Doing a node status request to the domain master browser\n" );
dbgtext( "for workgroup %s ", userdata ? userdata->data : "NULL" );
dbgtext( "at IP %s failed.\n", inet_ntoa(rrec->packet->ip) );
dbgtext( "Cannot sync browser lists.\n" );
}
}
static void find_domain_master_name_query_success(struct subnet_record *subrec,
struct userdata_struct *userdata_in,
struct nmb_name *q_name, struct in_addr answer_ip, struct res_rec *rrec)
{
struct work_record *work;
struct nmb_name nmbname;
struct userdata_struct *userdata;
size_t size = sizeof(struct userdata_struct) + sizeof(fstring)+1;
unstring qname;
pull_ascii_nstring(qname, sizeof(qname), q_name->name);
if( !(work = find_workgroup_on_subnet(subrec, qname)) ) {
if( DEBUGLVL( 0 ) ) {
dbgtext( "find_domain_master_name_query_success:\n" );
dbgtext( "Failed to find workgroup %s\n", qname);
}
return;
}
if(!is_zero_ip(work->dmb_addr) && ip_equal(work->dmb_addr, answer_ip)) {
announce_local_master_browser_to_domain_master_browser( work );
sync_with_dmb(work);
return;
} else {
zero_ip(&work->dmb_addr);
}
make_nmb_name(&nmbname,work->work_group,0x1b);
if((userdata = (struct userdata_struct *)SMB_MALLOC(size)) == NULL) {
DEBUG(0, ("find_domain_master_name_query_success: malloc fail.\n"));
return;
}
userdata->copy_fn = NULL;
userdata->free_fn = NULL;
userdata->userdata_len = strlen(work->work_group)+1;
overmalloc_safe_strcpy(userdata->data, work->work_group, size - sizeof(*userdata) - 1);
node_status( subrec, &nmbname, answer_ip,
domain_master_node_status_success,
domain_master_node_status_fail,
userdata);
zero_free(userdata, size);
}
static void find_domain_master_name_query_fail(struct subnet_record *subrec,
struct response_record *rrec,
struct nmb_name *question_name, int fail_code)
{
if( DEBUGLVL( 0 ) ) {
dbgtext( "find_domain_master_name_query_fail:\n" );
dbgtext( "Unable to find the Domain Master Browser name " );
dbgtext( "%s for the workgroup %s.\n",
nmb_namestr(question_name), question_name->name );
dbgtext( "Unable to sync browse lists in this workgroup.\n" );
}
}
void announce_and_sync_with_domain_master_browser( struct subnet_record *subrec,
struct work_record *work)
{
if(we_are_a_wins_client() == False) {
if( DEBUGLVL( 10 ) ) {
dbgtext( "announce_and_sync_with_domain_master_browser:\n" );
dbgtext( "Ignoring, as we are not a WINS client.\n" );
}
return;
}
query_name(unicast_subnet, work->work_group, 0x1b,
find_domain_master_name_query_success,
find_domain_master_name_query_fail,
NULL);
}
static void get_domain_master_name_node_status_success(struct subnet_record *subrec,
struct userdata_struct *userdata,
struct res_rec *answers,
struct in_addr from_ip)
{
struct work_record *work;
unstring server_name;
server_name[0] = 0;
if( DEBUGLVL( 3 ) ) {
dbgtext( "get_domain_master_name_node_status_success:\n" );
dbgtext( "Success in node status from ip %s\n", inet_ntoa(from_ip) );
}
if(answers->rdata != NULL) {
char *p = answers->rdata;
int numnames = CVAL(p, 0);
p += 1;
while (numnames--) {
unstring qname;
uint16 nb_flags;
int name_type;
pull_ascii_nstring(qname, sizeof(qname), p);
name_type = CVAL(p,15);
nb_flags = get_nb_flags(&p[16]);
trim_char(qname,'\0',' ');
p += 18;
if(!(nb_flags & NB_GROUP) && (name_type == 0x00) &&
server_name[0] == 0) {
unstrcpy(server_name, qname);
continue;
}
if(!(nb_flags & NB_GROUP) && (name_type == 0x1b)) {
if( DEBUGLVL( 5 ) ) {
dbgtext( "get_domain_master_name_node_status_success:\n" );
dbgtext( "%s(%s) ", server_name, inet_ntoa(from_ip) );
dbgtext( "is a domain master browser for workgroup " );
dbgtext( "%s. Adding this name.\n", qname );
}
if((work = find_workgroup_on_subnet( subrec, qname)) == NULL) {
struct nmb_name nmbname;
if(!(work= create_workgroup_on_subnet(subrec, qname, 60*60)))
return;
unstrcpy(work->local_master_browser_name, server_name);
make_nmb_name(&nmbname, server_name, 0x20);
work->dmb_name = nmbname;
work->dmb_addr = from_ip;
}
break;
}
}
} else if( DEBUGLVL( 0 ) ) {
dbgtext( "get_domain_master_name_node_status_success:\n" );
dbgtext( "Failed to find a WORKGROUP<0x1b> name in reply from IP " );
dbgtext( "%s.\n", inet_ntoa(from_ip) );
}
}
static void get_domain_master_name_node_status_fail(struct subnet_record *subrec,
struct response_record *rrec)
{
if( DEBUGLVL( 0 ) ) {
dbgtext( "get_domain_master_name_node_status_fail:\n" );
dbgtext( "Doing a node status request to the domain master browser " );
dbgtext( "at IP %s failed.\n", inet_ntoa(rrec->packet->ip) );
dbgtext( "Cannot get workgroup name.\n" );
}
}
static void find_all_domain_master_names_query_success(struct subnet_record *subrec,
struct userdata_struct *userdata_in,
struct nmb_name *q_name, struct in_addr answer_ip, struct res_rec *rrec)
{
struct nmb_name nmbname;
struct in_addr send_ip;
int i;
if( DEBUGLVL( 5 ) ) {
dbgtext( "find_all_domain_master_names_query_succes:\n" );
dbgtext( "Got answer from WINS server of %d ", (rrec->rdlength / 6) );
dbgtext( "IP addresses for Domain Master Browsers.\n" );
}
for(i = 0; i < rrec->rdlength / 6; i++) {
make_nmb_name(&nmbname, "*", 0);
putip((char *)&send_ip, (char *)&rrec->rdata[(i*6) + 2]);
if(ismyip( send_ip )) {
if( DEBUGLVL( 5 ) ) {
dbgtext( "find_all_domain_master_names_query_succes:\n" );
dbgtext( "Not sending node status to our own IP " );
dbgtext( "%s.\n", inet_ntoa(send_ip) );
}
continue;
}
if( DEBUGLVL( 5 ) ) {
dbgtext( "find_all_domain_master_names_query_success:\n" );
dbgtext( "Sending node status request to IP %s.\n", inet_ntoa(send_ip) );
}
node_status( subrec, &nmbname, send_ip,
get_domain_master_name_node_status_success,
get_domain_master_name_node_status_fail,
NULL);
}
}
static void find_all_domain_master_names_query_fail(struct subnet_record *subrec,
struct response_record *rrec,
struct nmb_name *question_name, int fail_code)
{
if( DEBUGLVL( 10 ) ) {
dbgtext( "find_domain_master_name_query_fail:\n" );
dbgtext( "WINS server did not reply to a query for name " );
dbgtext( "%s.\nThis means it ", nmb_namestr(question_name) );
dbgtext( "is probably not a Samba 1.9.18 or above WINS server.\n" );
}
}
void collect_all_workgroup_names_from_wins_server(time_t t)
{
static time_t lastrun = 0;
struct work_record *work;
if(we_are_a_wins_client() == False)
return;
if((work = find_workgroup_on_subnet( unicast_subnet, lp_workgroup())) == NULL) {
if( DEBUGLVL( 0 ) ) {
dbgtext( "collect_all_workgroup_names_from_wins_server:\n" );
dbgtext( "Cannot find my workgroup %s ", lp_workgroup() );
dbgtext( "on subnet %s.\n", unicast_subnet->subnet_name );
}
return;
}
if(!AM_DOMAIN_MASTER_BROWSER(work))
return;
if ((lastrun != 0) && (t < lastrun + (15 * 60)))
return;
lastrun = t;
query_name(unicast_subnet, "*", 0x1b,
find_all_domain_master_names_query_success,
find_all_domain_master_names_query_fail,
NULL);
}
void sync_all_dmbs(time_t t)
{
static time_t lastrun = 0;
struct work_record *work;
int count=0;
if(we_are_a_wins_client() == False)
return;
work = find_workgroup_on_subnet(unicast_subnet, lp_workgroup());
if (!work)
return;
if (!AM_DOMAIN_MASTER_BROWSER(work))
return;
if ((lastrun != 0) && (t < lastrun + (5 * 60)))
return;
for (work=unicast_subnet->workgrouplist; work; work = work->next) {
if (strcmp(lp_workgroup(), work->work_group)) {
count++;
}
}
for (work=unicast_subnet->workgrouplist; work; work = work->next) {
if (strcmp(lp_workgroup(), work->work_group)) {
unstring dmb_name;
if (((unsigned)sys_random()) % count != 0)
continue;
lastrun = t;
if (!work->dmb_name.name[0]) {
make_nmb_name(&work->dmb_name,
work->local_master_browser_name,
0x20);
}
pull_ascii_nstring(dmb_name, sizeof(dmb_name), work->dmb_name.name);
DEBUG(3,("Initiating DMB<->DMB sync with %s(%s)\n",
dmb_name, inet_ntoa(work->dmb_addr)));
sync_browse_lists(work,
dmb_name,
work->dmb_name.name_type,
work->dmb_addr, False, False);
}
}
}