nmbd_sendannounce.c [plain text]
#include "includes.h"
extern int updatecount;
extern BOOL found_lm_clients;
void send_browser_reset(int reset_type, const char *to_name, int to_type, struct in_addr to_ip)
{
pstring outbuf;
char *p;
DEBUG(3,("send_browser_reset: sending reset request type %d to %s<%02x> IP %s.\n",
reset_type, to_name, to_type, inet_ntoa(to_ip) ));
memset(outbuf,'\0',sizeof(outbuf));
p = outbuf;
SCVAL(p,0,ANN_ResetBrowserState);
p++;
SCVAL(p,0,reset_type);
p++;
send_mailslot(True, BROWSE_MAILSLOT, outbuf,PTR_DIFF(p,outbuf),
global_myname(), 0x0, to_name, to_type, to_ip,
FIRST_SUBNET->myip, DGRAM_PORT);
}
void broadcast_announce_request(struct subnet_record *subrec, struct work_record *work)
{
pstring outbuf;
char *p;
work->needannounce = True;
DEBUG(3,("broadcast_announce_request: sending announce request for workgroup %s \
to subnet %s\n", work->work_group, subrec->subnet_name));
memset(outbuf,'\0',sizeof(outbuf));
p = outbuf;
SCVAL(p,0,ANN_AnnouncementRequest);
p++;
SCVAL(p,0,work->token);
p++;
p += push_string(NULL, p+1, global_myname(), 15, STR_ASCII|STR_UPPER|STR_TERMINATE);
send_mailslot(False, BROWSE_MAILSLOT, outbuf,PTR_DIFF(p,outbuf),
global_myname(), 0x0, work->work_group,0x1e, subrec->bcast_ip,
subrec->myip, DGRAM_PORT);
}
static void send_announcement(struct subnet_record *subrec, int announce_type,
const char *from_name, const char *to_name, int to_type, struct in_addr to_ip,
time_t announce_interval,
const char *server_name, int server_type, const char *server_comment)
{
pstring outbuf;
char *p;
memset(outbuf,'\0',sizeof(outbuf));
p = outbuf+1;
SCVAL(outbuf,0,announce_type);
SCVAL(p,0,updatecount);
SIVAL(p,1,announce_interval*1000);
push_string(NULL, p+5, server_name, 15, STR_ASCII|STR_UPPER|STR_TERMINATE);
SCVAL(p,21,lp_major_announce_version());
SCVAL(p,22,lp_minor_announce_version());
SIVAL(p,23,server_type & ~SV_TYPE_LOCAL_LIST_ONLY);
SSVAL(p,27,BROWSER_ELECTION_VERSION);
SSVAL(p,29,BROWSER_CONSTANT);
p += 31 + push_string(NULL, p+31, server_comment, -1, STR_ASCII|STR_TERMINATE);
send_mailslot(False,BROWSE_MAILSLOT, outbuf, PTR_DIFF(p,outbuf),
from_name, 0x0, to_name, to_type, to_ip, subrec->myip,
DGRAM_PORT);
}
static void send_lm_announcement(struct subnet_record *subrec, int announce_type,
char *from_name, char *to_name, int to_type, struct in_addr to_ip,
time_t announce_interval,
char *server_name, int server_type, char *server_comment)
{
pstring outbuf;
char *p=outbuf;
memset(outbuf,'\0',sizeof(outbuf));
SSVAL(p,0,announce_type);
SIVAL(p,2,server_type & ~SV_TYPE_LOCAL_LIST_ONLY);
SCVAL(p,6,lp_major_announce_version());
SCVAL(p,7,lp_minor_announce_version());
SSVAL(p,8,announce_interval);
p += 10;
p += push_string(NULL, p, server_name, 15, STR_ASCII|STR_UPPER|STR_TERMINATE);
p += push_string(NULL, p, server_comment, sizeof(pstring)-15, STR_ASCII|STR_UPPER|STR_TERMINATE);
send_mailslot(False,LANMAN_MAILSLOT, outbuf, PTR_DIFF(p,outbuf),
from_name, 0x0, to_name, to_type, to_ip, subrec->myip,
DGRAM_PORT);
}
static void send_local_master_announcement(struct subnet_record *subrec, struct work_record *work,
struct server_record *servrec)
{
uint32 type = servrec->serv.type & ~SV_TYPE_LOCAL_LIST_ONLY;
DEBUG(3,("send_local_master_announcement: type %x for name %s on subnet %s for workgroup %s\n",
type, global_myname(), subrec->subnet_name, work->work_group));
send_announcement(subrec, ANN_LocalMasterAnnouncement,
global_myname(),
work->work_group, 0x1e,
subrec->bcast_ip,
work->announce_interval,
global_myname(),
type,
servrec->serv.comment);
}
static void send_workgroup_announcement(struct subnet_record *subrec, struct work_record *work)
{
DEBUG(3,("send_workgroup_announcement: on subnet %s for workgroup %s\n",
subrec->subnet_name, work->work_group));
send_announcement(subrec, ANN_DomainAnnouncement,
global_myname(),
MSBROWSE, 0x1,
subrec->bcast_ip,
work->announce_interval,
work->work_group,
SV_TYPE_DOMAIN_ENUM|SV_TYPE_NT,
global_myname());
}
static void send_host_announcement(struct subnet_record *subrec, struct work_record *work,
struct server_record *servrec)
{
uint32 type = servrec->serv.type & ~SV_TYPE_LOCAL_LIST_ONLY;
DEBUG(3,("send_host_announcement: type %x for host %s on subnet %s for workgroup %s\n",
type, servrec->serv.name, subrec->subnet_name, work->work_group));
send_announcement(subrec, ANN_HostAnnouncement,
servrec->serv.name,
work->work_group, 0x1d,
subrec->bcast_ip,
work->announce_interval,
servrec->serv.name,
type,
servrec->serv.comment);
}
static void send_lm_host_announcement(struct subnet_record *subrec, struct work_record *work,
struct server_record *servrec, int lm_interval)
{
uint32 type = servrec->serv.type & ~SV_TYPE_LOCAL_LIST_ONLY;
DEBUG(3,("send_lm_host_announcement: type %x for host %s on subnet %s for workgroup %s, ttl: %d\n",
type, servrec->serv.name, subrec->subnet_name, work->work_group, lm_interval));
send_lm_announcement(subrec, ANN_HostAnnouncement,
servrec->serv.name,
work->work_group, 0x00,
subrec->bcast_ip,
lm_interval,
servrec->serv.name,
type,
servrec->serv.comment);
}
static void announce_server(struct subnet_record *subrec, struct work_record *work,
struct server_record *servrec)
{
if (AM_LOCAL_MASTER_BROWSER(work) && strequal(global_myname(),servrec->serv.name)) {
send_local_master_announcement(subrec, work, servrec);
send_workgroup_announcement(subrec, work);
} else {
send_host_announcement(subrec, work, servrec);
}
}
void announce_my_server_names(time_t t)
{
struct subnet_record *subrec;
for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec)) {
struct work_record *work = find_workgroup_on_subnet(subrec, lp_workgroup());
if(work) {
struct server_record *servrec;
if (work->needannounce) {
work->announce_interval = MIN(work->announce_interval,
CHECK_TIME_MIN_HOST_ANNCE*60);
work->lastannounce_time = t - (work->announce_interval+1);
work->needannounce = False;
}
if ((t - work->lastannounce_time) < work->announce_interval)
continue;
if (work->announce_interval < (CHECK_TIME_MAX_HOST_ANNCE * 60))
work->announce_interval += 60;
work->lastannounce_time = t;
for (servrec = work->serverlist; servrec; servrec = servrec->next) {
if (is_myname(servrec->serv.name))
announce_server(subrec, work, servrec);
}
}
}
}
void announce_my_lm_server_names(time_t t)
{
struct subnet_record *subrec;
static time_t last_lm_announce_time=0;
int announce_interval = lp_lm_interval();
int lm_announce = lp_lm_announce();
if ((announce_interval <= 0) || (lm_announce <= 0)) {
return;
}
if ((lm_announce >= 2) && (!found_lm_clients)) {
return;
}
for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec)) {
struct work_record *work = find_workgroup_on_subnet(subrec, lp_workgroup());
if(work) {
struct server_record *servrec;
if (last_lm_announce_time && ((t - last_lm_announce_time) < announce_interval ))
continue;
last_lm_announce_time = t;
for (servrec = work->serverlist; servrec; servrec = servrec->next) {
if (is_myname(servrec->serv.name))
send_lm_host_announcement(subrec, work, servrec, announce_interval);
}
}
}
}
static time_t announce_timer_last=0;
void reset_announce_timer(void)
{
announce_timer_last = time(NULL) - (CHECK_TIME_MST_ANNOUNCE * 60);
}
void announce_myself_to_domain_master_browser(time_t t)
{
struct subnet_record *subrec;
struct work_record *work;
if(!we_are_a_wins_client()) {
DEBUG(10,("announce_myself_to_domain_master_browser: no unicast subnet, ignoring.\n"));
return;
}
if (!announce_timer_last)
announce_timer_last = t;
if ((t-announce_timer_last) < (CHECK_TIME_MST_ANNOUNCE * 60)) {
DEBUG(10,("announce_myself_to_domain_master_browser: t (%d) - last(%d) < %d\n",
(int)t, (int)announce_timer_last,
CHECK_TIME_MST_ANNOUNCE * 60 ));
return;
}
announce_timer_last = t;
for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec)) {
for (work = subrec->workgrouplist; work; work = work->next) {
if (AM_LOCAL_MASTER_BROWSER(work)) {
DEBUG(4,( "announce_myself_to_domain_master_browser: I am a local master browser for \
workgroup %s on subnet %s\n", work->work_group, subrec->subnet_name));
announce_and_sync_with_domain_master_browser(subrec, work);
}
}
}
}
void announce_my_servers_removed(void)
{
int announce_interval = lp_lm_interval();
int lm_announce = lp_lm_announce();
struct subnet_record *subrec;
for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec)) {
struct work_record *work;
for (work = subrec->workgrouplist; work; work = work->next) {
struct server_record *servrec;
work->announce_interval = 0;
for (servrec = work->serverlist; servrec; servrec = servrec->next) {
if (!is_myname(servrec->serv.name))
continue;
servrec->serv.type = 0;
if(AM_LOCAL_MASTER_BROWSER(work))
send_local_master_announcement(subrec, work, servrec);
send_host_announcement(subrec, work, servrec);
if ((announce_interval <= 0) || (lm_announce <= 0)) {
continue;
}
if ((lm_announce >= 2) && (!found_lm_clients)) {
continue;
}
send_lm_host_announcement(subrec, work, servrec, 0);
}
}
}
}
void announce_remote(time_t t)
{
char *s;
const char *ptr;
static time_t last_time = 0;
pstring s2;
struct in_addr addr;
char *comment;
int stype = lp_default_server_announce();
if (last_time && (t < (last_time + REMOTE_ANNOUNCE_INTERVAL)))
return;
last_time = t;
s = lp_remote_announce();
if (!*s)
return;
comment = string_truncate(lp_serverstring(), MAX_SERVER_STRING_LENGTH);
for (ptr=s; next_token(&ptr,s2,NULL,sizeof(s2)); ) {
const char *wgroup;
char *pwgroup;
int i;
pwgroup = strchr_m(s2,'/');
if (pwgroup)
*pwgroup++ = 0;
if (!pwgroup || !*pwgroup)
wgroup = lp_workgroup();
else
wgroup = pwgroup;
addr = *interpret_addr2(s2);
for(i=0; my_netbios_names(i); i++) {
const char *name = my_netbios_names(i);
DEBUG(5,("announce_remote: Doing remote announce for server %s to IP %s.\n",
name, inet_ntoa(addr) ));
send_announcement(FIRST_SUBNET, ANN_HostAnnouncement,
name,
wgroup, 0x1d,
addr,
REMOTE_ANNOUNCE_INTERVAL,
name,
stype,
comment);
}
}
}
void browse_sync_remote(time_t t)
{
char *s;
const char *ptr;
static time_t last_time = 0;
pstring s2;
struct in_addr addr;
struct work_record *work;
pstring outbuf;
char *p;
fstring myname;
if (last_time && (t < (last_time + REMOTE_ANNOUNCE_INTERVAL)))
return;
last_time = t;
s = lp_remote_browse_sync();
if (!*s)
return;
if((work = find_workgroup_on_subnet(FIRST_SUBNET, lp_workgroup())) == NULL) {
DEBUG(0,("browse_sync_remote: Cannot find workgroup %s on subnet %s\n",
lp_workgroup(), FIRST_SUBNET->subnet_name ));
return;
}
if(!AM_LOCAL_MASTER_BROWSER(work)) {
DEBUG(5,("browse_sync_remote: We can only do this if we are a local master browser \
for workgroup %s on subnet %s.\n", lp_workgroup(), FIRST_SUBNET->subnet_name ));
return;
}
memset(outbuf,'\0',sizeof(outbuf));
p = outbuf;
SCVAL(p,0,ANN_MasterAnnouncement);
p++;
fstrcpy(myname, global_myname());
strupper_m(myname);
myname[15]='\0';
push_pstring_base(p, myname, outbuf);
p = skip_string(p,1);
for (ptr=s; next_token(&ptr,s2,NULL,sizeof(s2)); ) {
addr = *interpret_addr2(s2);
DEBUG(5,("announce_remote: Doing remote browse sync announce for server %s to IP %s.\n",
global_myname(), inet_ntoa(addr) ));
send_mailslot(True, BROWSE_MAILSLOT, outbuf,PTR_DIFF(p,outbuf),
global_myname(), 0x0, "*", 0x0, addr, FIRST_SUBNET->myip, DGRAM_PORT);
}
}