static void msg_nmbd_send_packet(struct messaging_context *msg,
void *private_data,
uint32_t msg_type,
struct server_id src,
DATA_BLOB *data)
{
struct packet_struct *p = (struct packet_struct *)data->data;
struct subnet_record *subrec;
struct sockaddr_storage ss;
const struct sockaddr_storage *pss;
const struct in_addr *local_ip;
DEBUG(10, ("Received send_packet from %u\n", (unsigned int)procid_to_pid(&src)));
if (data->length != sizeof(struct packet_struct)) {
DEBUG(2, ("Discarding invalid packet length from %u\n",
(unsigned int)procid_to_pid(&src)));
return;
}
if ((p->packet_type != NMB_PACKET) &&
(p->packet_type != DGRAM_PACKET)) {
DEBUG(2, ("Discarding invalid packet type from %u: %d\n",
(unsigned int)procid_to_pid(&src), p->packet_type));
return;
}
in_addr_to_sockaddr_storage(&ss, p->ip);
pss = iface_ip((struct sockaddr *)(void *)&ss);
if (pss == NULL) {
DEBUG(2, ("Could not find ip for packet from %u\n",
(unsigned int)procid_to_pid(&src)));
return;
}
local_ip = &((const struct sockaddr_in *)pss)->sin_addr;
subrec = FIRST_SUBNET;
p->recv_fd = -1;
p->send_fd = (p->packet_type == NMB_PACKET) ?
subrec->nmb_sock : subrec->dgram_sock;
for (subrec = FIRST_SUBNET; subrec != NULL;
subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec)) {
if (ip_equal_v4(*local_ip, subrec->myip)) {
p->send_fd = (p->packet_type == NMB_PACKET) ?
subrec->nmb_sock : subrec->dgram_sock;
break;
}
}
if (p->packet_type == DGRAM_PACKET) {
p->port = 138;
p->packet.dgram.header.source_ip.s_addr = local_ip->s_addr;
p->packet.dgram.header.source_port = 138;
}
send_packet(p);
}
static void wins_next_registration(struct response_record *rrec)
{
struct nmb_packet *sent_nmb = &rrec->packet->packet.nmb;
struct nmb_name *nmbname = &sent_nmb->question.question_name;
uint16_t nb_flags = get_nb_flags(sent_nmb->additional->rdata);
struct userdata_struct *userdata = rrec->userdata;
const char *tag;
struct in_addr last_ip;
struct subnet_record *subrec;
putip(&last_ip,&sent_nmb->additional->rdata[2]);
if (!userdata) {
/* it wasn't multi-homed */
return;
}
tag = (const char *)userdata->data;
for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec)) {
if (ip_equal_v4(last_ip, subrec->myip)) {
subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec);
break;
}
}
if (!subrec) {
/* no more to do! */
return;
}
switch (sent_nmb->header.opcode) {
case NMB_NAME_MULTIHOMED_REG_OPCODE:
multihomed_register_one(nmbname, nb_flags, NULL, NULL, subrec->myip, tag);
break;
case NMB_NAME_REFRESH_OPCODE_8:
queue_wins_refresh(nmbname,
register_name_response,
register_name_timeout_response,
nb_flags, subrec->myip, tag);
break;
}
}
static void register_name_response(struct subnet_record *subrec,
struct response_record *rrec, struct packet_struct *p)
{
/*
* If we are registering broadcast, then getting a response is an
* error - we do not have the name. If we are registering unicast,
* then we expect to get a response.
*/
struct nmb_packet *nmb = &p->packet.nmb;
bool bcast = nmb->header.nm_flags.bcast;
bool success = True;
struct nmb_name *question_name = &rrec->packet->packet.nmb.question.question_name;
struct nmb_name *answer_name = &nmb->answers->rr_name;
struct nmb_packet *sent_nmb = &rrec->packet->packet.nmb;
int ttl = 0;
uint16_t nb_flags = 0;
struct in_addr register_ip;
fstring reg_name;
putip(®ister_ip,&sent_nmb->additional->rdata[2]);
fstrcpy(reg_name, inet_ntoa(register_ip));
if (subrec == unicast_subnet) {
/* we know that this wins server is definately alive - for the moment! */
wins_srv_alive(rrec->packet->ip, register_ip);
}
/* Sanity check. Ensure that the answer name in the incoming packet is the
same as the requested name in the outgoing packet. */
if(!question_name || !answer_name) {
DEBUG(0,("register_name_response: malformed response (%s is NULL).\n",
question_name ? "question_name" : "answer_name" ));
return;
}
if(!nmb_name_equal(question_name, answer_name)) {
DEBUG(0,("register_name_response: Answer name %s differs from question name %s.\n",
nmb_namestr(answer_name), nmb_namestr(question_name)));
return;
}
if(bcast) {
/*
* Special hack to cope with old Samba nmbd's.
* Earlier versions of Samba (up to 1.9.16p11) respond
* to a broadcast name registration of WORKGROUP<1b> when
* they should not. Hence, until these versions are gone,
* we should treat such errors as success for this particular
* case only. [email protected].
*/
#if 1 /* OLD_SAMBA_SERVER_HACK */
unstring ans_name;
pull_ascii_nstring(ans_name, sizeof(ans_name), answer_name->name);
if((nmb->header.rcode == ACT_ERR) && strequal(lp_workgroup(), ans_name) &&
(answer_name->name_type == 0x1b)) {
/* Pretend we did not get this. */
rrec->num_msgs--;
DEBUG(5,("register_name_response: Ignoring broadcast response to registration of name %s due to old Samba server bug.\n",
nmb_namestr(answer_name)));
return;
}
#endif /* OLD_SAMBA_SERVER_HACK */
/* Someone else has the name. Log the problem. */
DEBUG(1,("register_name_response: Failed to register name %s IP %s on subnet %s via broadcast. Error code was %d. Reject came from IP %s\n",
nmb_namestr(answer_name),
reg_name,
subrec->subnet_name, nmb->header.rcode, inet_ntoa(p->ip)));
success = False;
} else {
if (!ip_equal_v4(rrec->packet->ip, p->ip)) {
DEBUG(5,("register_name_response: Ignoring WINS server response "
"from IP %s, for name %s. We sent to IP %s\n",
inet_ntoa(p->ip),
nmb_namestr(answer_name),
inet_ntoa(rrec->packet->ip)));
return;
}
/* Unicast - check to see if the response allows us to have the name. */
if (nmb->header.opcode == NMB_WACK_OPCODE) {
/* WINS server is telling us to wait. Pretend we didn't get
the response but don't send out any more register requests. */
DEBUG(5,("register_name_response: WACK from WINS server %s in registering name %s IP %s\n",
inet_ntoa(p->ip), nmb_namestr(answer_name), reg_name));
rrec->repeat_count = 0;
/* How long we should wait for. */
rrec->repeat_time = p->timestamp + nmb->answers->ttl;
rrec->num_msgs--;
return;
} else if (nmb->header.rcode != 0) {
/* Error code - we didn't get the name. */
success = False;
DEBUG(0,("register_name_response: %sserver at IP %s rejected our name registration of %s IP %s with error code %d.\n",
subrec==unicast_subnet?"WINS ":"",
inet_ntoa(p->ip),
nmb_namestr(answer_name),
reg_name,
nmb->header.rcode));
} else {
success = True;
/* Get the data we need to pass to the success function. */
nb_flags = get_nb_flags(nmb->answers->rdata);
ttl = nmb->answers->ttl;
/* send off a registration for the next IP, if any */
wins_next_registration(rrec);
}
}
DEBUG(5,("register_name_response: %s in registering %sname %s IP %s with %s.\n",
success ? "success" : "failure",
subrec==unicast_subnet?"WINS ":"",
nmb_namestr(answer_name),
reg_name,
inet_ntoa(rrec->packet->ip)));
if(success) {
/* Enter the registered name into the subnet name database before calling
the success function. */
standard_success_register(subrec, rrec->userdata, answer_name, nb_flags, ttl, register_ip);
if( rrec->success_fn)
(*(register_name_success_function)rrec->success_fn)(subrec, rrec->userdata, answer_name, nb_flags, ttl, register_ip);
} else {
struct nmb_name qname = *question_name;
if( rrec->fail_fn)
(*(register_name_fail_function)rrec->fail_fn)(subrec, rrec, question_name);
/* Remove the name. */
standard_fail_register( subrec, &qname);
}
/* Ensure we don't retry. */
remove_response_record(subrec, rrec);
}
static void reload_interfaces(time_t t)
{
static time_t lastt;
int n;
bool print_waiting_msg = true;
struct subnet_record *subrec;
if (t && ((t - lastt) < NMBD_INTERFACES_RELOAD)) {
return;
}
lastt = t;
if (!interfaces_changed()) {
return;
}
try_again:
/* the list of probed interfaces has changed, we may need to add/remove
some subnets */
load_interfaces();
/* find any interfaces that need adding */
for (n=iface_count() - 1; n >= 0; n--) {
char str[INET6_ADDRSTRLEN];
const struct interface *iface = get_interface(n);
struct in_addr ip, nmask;
if (!iface) {
DEBUG(2,("reload_interfaces: failed to get interface %d\n", n));
continue;
}
/* Ensure we're only dealing with IPv4 here. */
if (iface->ip.ss_family != AF_INET) {
DEBUG(2,("reload_interfaces: "
"ignoring non IPv4 interface.\n"));
continue;
}
ip = ((const struct sockaddr_in *)(const void *)&iface->ip)->sin_addr;
nmask = ((const struct sockaddr_in *)(const void *)
&iface->netmask)->sin_addr;
/*
* We don't want to add a loopback interface, in case
* someone has added 127.0.0.1 for smbd, nmbd needs to
* ignore it here. JRA.
*/
if (is_loopback_addr((const struct sockaddr *)(const void *)&iface->ip)) {
DEBUG(2,("reload_interfaces: Ignoring loopback "
"interface %s\n",
print_sockaddr(str, sizeof(str), &iface->ip) ));
continue;
}
for (subrec=subnetlist; subrec; subrec=subrec->next) {
if (ip_equal_v4(ip, subrec->myip) &&
ip_equal_v4(nmask, subrec->mask_ip)) {
break;
}
}
if (!subrec) {
/* it wasn't found! add it */
DEBUG(2,("Found new interface %s\n",
print_sockaddr(str,
sizeof(str), &iface->ip) ));
subrec = make_normal_subnet(iface);
if (subrec)
register_my_workgroup_one_subnet(subrec);
}
}
/* find any interfaces that need deleting */
for (subrec=subnetlist; subrec; subrec=subrec->next) {
for (n=iface_count() - 1; n >= 0; n--) {
struct interface *iface = get_interface(n);
struct in_addr ip, nmask;
if (!iface) {
continue;
}
/* Ensure we're only dealing with IPv4 here. */
if (iface->ip.ss_family != AF_INET) {
DEBUG(2,("reload_interfaces: "
"ignoring non IPv4 interface.\n"));
continue;
}
ip = ((struct sockaddr_in *)(void *)
&iface->ip)->sin_addr;
nmask = ((struct sockaddr_in *)(void *)
&iface->netmask)->sin_addr;
if (ip_equal_v4(ip, subrec->myip) &&
ip_equal_v4(nmask, subrec->mask_ip)) {
break;
}
}
if (n == -1) {
/* oops, an interface has disapeared. This is
tricky, we don't dare actually free the
interface as it could be being used, so
instead we just wear the memory leak and
remove it from the list of interfaces without
freeing it */
DEBUG(2,("Deleting dead interface %s\n",
inet_ntoa(subrec->myip)));
close_subnet(subrec);
}
}
rescan_listen_set = True;
/* We need to wait if there are no subnets... */
if (FIRST_SUBNET == NULL) {
void (*saved_handler)(int);
if (print_waiting_msg) {
DEBUG(0,("reload_interfaces: "
"No subnets to listen to. Waiting..\n"));
print_waiting_msg = false;
}
/*
* Whilst we're waiting for an interface, allow SIGTERM to
* cause us to exit.
*/
saved_handler = CatchSignal(SIGTERM, SIG_DFL);
/* We only count IPv4, non-loopback interfaces here. */
while (iface_count_v4_nl() == 0) {
sleep(5);
load_interfaces();
}
CatchSignal(SIGTERM, saved_handler);
/*
* We got an interface, go back to blocking term.
*/
goto try_again;
}
}
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)
{
/*
* Unfortunately, finding the IP address of the Domain Master Browser,
* as we have here, is not enough. We need to now do a sync to the
* SERVERNAME<0x20> NetBIOS name, as only recent NT servers will
* respond to the SMBSERVER name. To get this name from IP
* address we do a Node status request, and look for the first
* NAME<0x20> in the response, and take that as the server name.
* We also keep a cache of the Domain Master Browser name for this
* workgroup in the Workgroup struct, so that if the same IP addess
* is returned every time, we don't need to do the node status
* request.
*/
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;
}
/* First check if we already have a dmb for this workgroup. */
if(!is_zero_ip_v4(work->dmb_addr) && ip_equal_v4(work->dmb_addr, answer_ip)) {
/* Do the local master browser announcement to the domain
master browser name and IP. */
announce_local_master_browser_to_domain_master_browser( work );
/* Now synchronise lists with the domain master browser. */
sync_with_dmb(work);
return;
} else {
zero_ip_v4(&work->dmb_addr);
}
/* Now initiate the node status request. */
/* We used to use the name "*",0x0 here, but some Windows
* servers don't answer that name. However we *know* they
* have the name workgroup#1b (as we just looked it up).
* So do the node status request on this name instead.
* Found at LBL labs. JRA.
*/
make_nmb_name(&nmbname,work->work_group,0x1b);
/* Put the workgroup name into the userdata so we know
what workgroup we're talking to when the reply comes
back. */
/* Setup the userdata_struct - this is copied so we can use
a stack variable for this. */
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);
}
