*/
#include "includes.h"
+#include "libsmb/namequery.h"
#include "../lib/util/tevent_ntstatus.h"
#include "libads/sitename_cache.h"
-#include "libads/dns.h"
+#include "../lib/addns/dnsquery.h"
#include "../libcli/netlogon/netlogon.h"
#include "lib/async_req/async_sock.h"
+#include "lib/tsocket/tsocket.h"
#include "libsmb/nmblib.h"
+#include "libsmb/unexpected.h"
+#include "../libcli/nbt/libnbt.h"
+#include "libads/kerberos_proto.h"
+#include "lib/gencache.h"
/* nmbd.c sets this to True. */
bool global_in_nmbd = False;
#define SAFJOINKEY_FMT "SAFJOIN/DOMAIN/%s"
#define SAFJOIN_TTL 3600
-static char *saf_key(const char *domain)
+static char *saf_key(TALLOC_CTX *mem_ctx, const char *domain)
{
- char *keystr;
-
- asprintf_strupper_m(&keystr, SAFKEY_FMT, domain);
-
- return keystr;
+ return talloc_asprintf_strupper_m(mem_ctx, SAFKEY_FMT, domain);
}
-static char *saf_join_key(const char *domain)
+static char *saf_join_key(TALLOC_CTX *mem_ctx, const char *domain)
{
- char *keystr;
-
- asprintf_strupper_m(&keystr, SAFJOINKEY_FMT, domain);
-
- return keystr;
+ return talloc_asprintf_strupper_m(mem_ctx, SAFJOINKEY_FMT, domain);
}
/****************************************************************************
return False;
}
- key = saf_key( domain );
+ key = saf_key(talloc_tos(), domain);
+ if (key == NULL) {
+ DEBUG(1, ("saf_key() failed\n"));
+ return false;
+ }
expire = time( NULL ) + lp_parm_int(-1, "saf","ttl", SAF_TTL);
DEBUG(10,("saf_store: domain = [%s], server = [%s], expire = [%u]\n",
ret = gencache_set( key, servername, expire );
- SAFE_FREE( key );
+ TALLOC_FREE( key );
return ret;
}
return False;
}
- key = saf_join_key( domain );
+ key = saf_join_key(talloc_tos(), domain);
+ if (key == NULL) {
+ DEBUG(1, ("saf_join_key() failed\n"));
+ return false;
+ }
expire = time( NULL ) + lp_parm_int(-1, "saf","join ttl", SAFJOIN_TTL);
DEBUG(10,("saf_join_store: domain = [%s], server = [%s], expire = [%u]\n",
ret = gencache_set( key, servername, expire );
- SAFE_FREE( key );
+ TALLOC_FREE( key );
return ret;
}
return False;
}
- key = saf_join_key(domain);
+ key = saf_join_key(talloc_tos(), domain);
+ if (key == NULL) {
+ DEBUG(1, ("saf_join_key() failed\n"));
+ return false;
+ }
ret = gencache_del(key);
- SAFE_FREE(key);
+ TALLOC_FREE(key);
if (ret) {
DEBUG(10,("saf_delete[join]: domain = [%s]\n", domain ));
}
- key = saf_key(domain);
+ key = saf_key(talloc_tos(), domain);
+ if (key == NULL) {
+ DEBUG(1, ("saf_key() failed\n"));
+ return false;
+ }
ret = gencache_del(key);
- SAFE_FREE(key);
+ TALLOC_FREE(key);
if (ret) {
DEBUG(10,("saf_delete: domain = [%s]\n", domain ));
/****************************************************************************
****************************************************************************/
-char *saf_fetch( const char *domain )
+char *saf_fetch(TALLOC_CTX *mem_ctx, const char *domain )
{
char *server = NULL;
time_t timeout;
return NULL;
}
- key = saf_join_key( domain );
+ key = saf_join_key(talloc_tos(), domain);
+ if (key == NULL) {
+ DEBUG(1, ("saf_join_key() failed\n"));
+ return NULL;
+ }
- ret = gencache_get( key, &server, &timeout );
+ ret = gencache_get( key, mem_ctx, &server, &timeout );
- SAFE_FREE( key );
+ TALLOC_FREE( key );
if ( ret ) {
DEBUG(5,("saf_fetch[join]: Returning \"%s\" for \"%s\" domain\n",
return server;
}
- key = saf_key( domain );
+ key = saf_key(talloc_tos(), domain);
+ if (key == NULL) {
+ DEBUG(1, ("saf_key() failed\n"));
+ return NULL;
+ }
- ret = gencache_get( key, &server, &timeout );
+ ret = gencache_get( key, mem_ctx, &server, &timeout );
- SAFE_FREE( key );
+ TALLOC_FREE( key );
if ( !ret ) {
DEBUG(5,("saf_fetch: failed to find server for \"%s\" domain\n",
static void set_socket_addr_v4(struct sockaddr_storage *addr)
{
- if (!interpret_string_addr(addr, lp_socket_address(),
+ if (!interpret_string_addr(addr, lp_nbt_client_socket_address(),
AI_NUMERICHOST|AI_PASSIVE)) {
zero_sockaddr(addr);
}
static int generate_trn_id(void)
{
- uint16 id;
+ uint16_t id;
- generate_random_buffer((uint8 *)&id, sizeof(id));
+ generate_random_buffer((uint8_t *)&id, sizeof(id));
return id % (unsigned)0x7FFF;
}
p++;
for (i=0;i< *num_names;i++) {
- StrnCpy(ret[i].name,p,15);
+ strlcpy(ret[i].name,p,16);
trim_char(ret[i].name,'\0',' ');
ret[i].type = CVAL(p,15);
ret[i].flags = p[16];
struct nb_packet_reader *reader;
struct tevent_req *reader_req;
- int sock;
+ struct tdgram_context *sock;
struct tevent_req *socket_req;
- uint8_t buf[1024];
- struct sockaddr_storage addr;
- socklen_t addr_len;
+ uint8_t *buf;
+ struct tsocket_address *addr;
bool (*validator)(struct packet_struct *p,
void *private_data);
struct packet_struct *packet;
};
-static int sock_packet_read_state_destructor(struct sock_packet_read_state *s);
static void sock_packet_read_got_packet(struct tevent_req *subreq);
static void sock_packet_read_got_socket(struct tevent_req *subreq);
static struct tevent_req *sock_packet_read_send(
TALLOC_CTX *mem_ctx,
struct tevent_context *ev,
- int sock, /* dgram socket */
+ struct tdgram_context *sock,
struct nb_packet_reader *reader,
enum packet_type type,
int trn_id,
if (req == NULL) {
return NULL;
}
- talloc_set_destructor(state, sock_packet_read_state_destructor);
state->ev = ev;
state->reader = reader;
state->sock = sock;
state->reader_req, sock_packet_read_got_packet, req);
}
- state->addr_len = sizeof(state->addr);
- state->socket_req = recvfrom_send(state, ev, sock,
- state->buf, sizeof(state->buf), 0,
- &state->addr, &state->addr_len);
+ state->socket_req = tdgram_recvfrom_send(state, ev, state->sock);
if (tevent_req_nomem(state->socket_req, req)) {
return tevent_req_post(req, ev);
}
return req;
}
-static int sock_packet_read_state_destructor(struct sock_packet_read_state *s)
-{
- if (s->packet != NULL) {
- free_packet(s->packet);
- s->packet = NULL;
- }
- return 0;
-}
-
static void sock_packet_read_got_packet(struct tevent_req *subreq)
{
struct tevent_req *req = tevent_req_callback_data(
req, struct sock_packet_read_state);
NTSTATUS status;
- status = nb_packet_read_recv(subreq, &state->packet);
+ status = nb_packet_read_recv(subreq, state, &state->packet);
TALLOC_FREE(state->reader_req);
!state->validator(state->packet, state->private_data)) {
DEBUG(10, ("validator failed\n"));
- free_packet(state->packet);
- state->packet = NULL;
+ TALLOC_FREE(state->packet);
state->reader_req = nb_packet_read_send(state, state->ev,
state->reader);
subreq, struct tevent_req);
struct sock_packet_read_state *state = tevent_req_data(
req, struct sock_packet_read_state);
- struct sockaddr_in *in_addr;
+ union {
+ struct sockaddr sa;
+ struct sockaddr_in sin;
+ } addr;
+ ssize_t ret;
ssize_t received;
int err;
+ bool ok;
- received = recvfrom_recv(subreq, &err);
+ received = tdgram_recvfrom_recv(subreq, &err, state,
+ &state->buf, &state->addr);
TALLOC_FREE(state->socket_req);
tevent_req_nterror(req, map_nt_error_from_unix(err));
return;
}
- if (state->addr.ss_family != AF_INET) {
+ ok = tsocket_address_is_inet(state->addr, "ipv4");
+ if (!ok) {
goto retry;
}
- in_addr = (struct sockaddr_in *)(void *)&state->addr;
+ ret = tsocket_address_bsd_sockaddr(state->addr,
+ &addr.sa,
+ sizeof(addr.sin));
+ if (ret == -1) {
+ tevent_req_nterror(req, map_nt_error_from_unix(errno));
+ return;
+ }
- state->packet = parse_packet((char *)state->buf, received, state->type,
- in_addr->sin_addr, in_addr->sin_port);
+ state->packet = parse_packet_talloc(
+ state, (char *)state->buf, received, state->type,
+ addr.sin.sin_addr, addr.sin.sin_port);
if (state->packet == NULL) {
DEBUG(10, ("parse_packet failed\n"));
goto retry;
return;
retry:
- if (state->packet != NULL) {
- free_packet(state->packet);
- state->packet = NULL;
- }
- state->socket_req = recvfrom_send(state, state->ev, state->sock,
- state->buf, sizeof(state->buf), 0,
- &state->addr, &state->addr_len);
+ TALLOC_FREE(state->packet);
+ TALLOC_FREE(state->buf);
+ TALLOC_FREE(state->addr);
+
+ state->socket_req = tdgram_recvfrom_send(state, state->ev, state->sock);
if (tevent_req_nomem(state->socket_req, req)) {
return;
}
}
static NTSTATUS sock_packet_read_recv(struct tevent_req *req,
+ TALLOC_CTX *mem_ctx,
struct packet_struct **ppacket)
{
struct sock_packet_read_state *state = tevent_req_data(
if (tevent_req_is_nterror(req, &status)) {
return status;
}
- *ppacket = state->packet;
- state->packet = NULL;
+ *ppacket = talloc_move(mem_ctx, &state->packet);
return NT_STATUS_OK;
}
struct nb_trans_state {
struct tevent_context *ev;
- int sock;
+ struct tdgram_context *sock;
struct nb_packet_reader *reader;
- const struct sockaddr_storage *dst_addr;
+ struct tsocket_address *src_addr;
+ struct tsocket_address *dst_addr;
uint8_t *buf;
size_t buflen;
enum packet_type type;
struct packet_struct *packet;
};
-static int nb_trans_state_destructor(struct nb_trans_state *s);
static void nb_trans_got_reader(struct tevent_req *subreq);
static void nb_trans_done(struct tevent_req *subreq);
static void nb_trans_sent(struct tevent_req *subreq);
static struct tevent_req *nb_trans_send(
TALLOC_CTX *mem_ctx,
struct tevent_context *ev,
- const struct sockaddr_storage *my_addr,
- const struct sockaddr_storage *dst_addr,
+ const struct sockaddr_storage *_my_addr,
+ const struct sockaddr_storage *_dst_addr,
bool bcast,
uint8_t *buf, size_t buflen,
enum packet_type type, int trn_id,
void *private_data),
void *private_data)
{
+ const struct sockaddr *my_addr =
+ discard_const_p(const struct sockaddr, _my_addr);
+ size_t my_addr_len = sizeof(*_my_addr);
+ const struct sockaddr *dst_addr =
+ discard_const_p(const struct sockaddr, _dst_addr);
+ size_t dst_addr_len = sizeof(*_dst_addr);
struct tevent_req *req, *subreq;
struct nb_trans_state *state;
+ int ret;
req = tevent_req_create(mem_ctx, &state, struct nb_trans_state);
if (req == NULL) {
return NULL;
}
- talloc_set_destructor(state, nb_trans_state_destructor);
state->ev = ev;
- state->dst_addr = dst_addr;
state->buf = buf;
state->buflen = buflen;
state->type = type;
state->validator = validator;
state->private_data = private_data;
- state->sock = open_socket_in(SOCK_DGRAM, 0, 3, my_addr, True);
- if (state->sock == -1) {
+ ret = tsocket_address_bsd_from_sockaddr(state,
+ my_addr, my_addr_len,
+ &state->src_addr);
+ if (ret == -1) {
tevent_req_nterror(req, map_nt_error_from_unix(errno));
- DEBUG(10, ("open_socket_in failed: %s\n", strerror(errno)));
return tevent_req_post(req, ev);
}
- if (bcast) {
- set_socket_options(state->sock,"SO_BROADCAST");
+ ret = tsocket_address_bsd_from_sockaddr(state,
+ dst_addr, dst_addr_len,
+ &state->dst_addr);
+ if (ret == -1) {
+ tevent_req_nterror(req, map_nt_error_from_unix(errno));
+ return tevent_req_post(req, ev);
+ }
+
+ ret = tdgram_inet_udp_broadcast_socket(state->src_addr, state,
+ &state->sock);
+ if (ret == -1) {
+ tevent_req_nterror(req, map_nt_error_from_unix(errno));
+ return tevent_req_post(req, ev);
}
subreq = nb_packet_reader_send(state, ev, type, state->trn_id, NULL);
return req;
}
-static int nb_trans_state_destructor(struct nb_trans_state *s)
-{
- if (s->sock != -1) {
- close(s->sock);
- s->sock = -1;
- }
- if (s->packet != NULL) {
- free_packet(s->packet);
- s->packet = NULL;
- }
- return 0;
-}
-
static void nb_trans_got_reader(struct tevent_req *subreq)
{
struct tevent_req *req = tevent_req_callback_data(
}
tevent_req_set_callback(subreq, nb_trans_done, req);
- subreq = sendto_send(state, state->ev, state->sock,
- state->buf, state->buflen, 0, state->dst_addr);
+ subreq = tdgram_sendto_send(state, state->ev,
+ state->sock,
+ state->buf, state->buflen,
+ state->dst_addr);
if (tevent_req_nomem(subreq, req)) {
return;
}
ssize_t sent;
int err;
- sent = sendto_recv(subreq, &err);
+ sent = tdgram_sendto_recv(subreq, &err);
TALLOC_FREE(subreq);
if (sent == -1) {
DEBUG(10, ("sendto failed: %s\n", strerror(err)));
tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
return;
}
- subreq = sendto_send(state, state->ev, state->sock,
- state->buf, state->buflen, 0, state->dst_addr);
+ subreq = tdgram_sendto_send(state, state->ev,
+ state->sock,
+ state->buf, state->buflen,
+ state->dst_addr);
if (tevent_req_nomem(subreq, req)) {
return;
}
req, struct nb_trans_state);
NTSTATUS status;
- status = sock_packet_read_recv(subreq, &state->packet);
+ status = sock_packet_read_recv(subreq, state, &state->packet);
TALLOC_FREE(subreq);
if (tevent_req_nterror(req, status)) {
return;
tevent_req_done(req);
}
-static NTSTATUS nb_trans_recv(struct tevent_req *req,
+static NTSTATUS nb_trans_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
struct packet_struct **ppacket)
{
struct nb_trans_state *state = tevent_req_data(
if (tevent_req_is_nterror(req, &status)) {
return status;
}
- *ppacket = state->packet;
- state->packet = NULL;
+ *ppacket = talloc_move(mem_ctx, &state->packet);
return NT_STATUS_OK;
}
struct packet_struct *packet;
};
-static int node_status_query_state_destructor(
- struct node_status_query_state *s);
static bool node_status_query_validator(struct packet_struct *p,
void *private_data);
static void node_status_query_done(struct tevent_req *subreq);
if (req == NULL) {
return NULL;
}
- talloc_set_destructor(state, node_status_query_state_destructor);
if (addr->ss_family != AF_INET) {
/* Can't do node status to IPv6 */
return true;
}
-static int node_status_query_state_destructor(
- struct node_status_query_state *s)
-{
- if (s->packet != NULL) {
- free_packet(s->packet);
- s->packet = NULL;
- }
- return 0;
-}
-
static void node_status_query_done(struct tevent_req *subreq)
{
struct tevent_req *req = tevent_req_callback_data(
req, struct node_status_query_state);
NTSTATUS status;
- status = nb_trans_recv(subreq, &state->packet);
+ status = nb_trans_recv(subreq, state, &state->packet);
TALLOC_FREE(subreq);
if (tevent_req_nterror(req, status)) {
return;
struct tevent_req *req;
NTSTATUS status = NT_STATUS_NO_MEMORY;
- ev = tevent_context_init(frame);
+ ev = samba_tevent_context_init(frame);
if (ev == NULL) {
goto fail;
}
return status;
}
+static bool name_status_lmhosts(const struct sockaddr_storage *paddr,
+ int qname_type, fstring pname)
+{
+ FILE *f;
+ char *name;
+ int name_type;
+ struct sockaddr_storage addr;
+
+ if (paddr->ss_family != AF_INET) {
+ return false;
+ }
+
+ f = startlmhosts(get_dyn_LMHOSTSFILE());
+ if (f == NULL) {
+ return false;
+ }
+
+ while (getlmhostsent(talloc_tos(), f, &name, &name_type, &addr)) {
+ if (addr.ss_family != AF_INET) {
+ continue;
+ }
+ if (name_type != qname_type) {
+ continue;
+ }
+ if (memcmp(&((const struct sockaddr_in *)paddr)->sin_addr,
+ &((const struct sockaddr_in *)&addr)->sin_addr,
+ sizeof(struct in_addr)) == 0) {
+ fstrcpy(pname, name);
+ endlmhosts(f);
+ return true;
+ }
+ }
+ endlmhosts(f);
+ return false;
+}
+
/****************************************************************************
Find the first type XX name in a node status reply - used for finding
a servers name given its IP. Return the matched name in *name.
struct sockaddr_storage ss;
struct node_status *addrs = NULL;
struct nmb_name nname;
- int count, i;
+ int count = 0, i;
bool result = false;
NTSTATUS status;
return false;
}
+ result = name_status_lmhosts(to_ss, type, name);
+ if (result) {
+ DBG_DEBUG("Found name %s in lmhosts\n", name);
+ namecache_status_store(q_name, q_type, type, to_ss, name);
+ return true;
+ }
+
set_socket_addr_v4(&ss);
/* W2K PDC's seem not to respond to '*'#0. JRA */
compare 2 ldap IPs by nearness to our interfaces - used in qsort
*******************************************************************/
-int ip_service_compare(struct ip_service *ss1, struct ip_service *ss2)
+static int ip_service_compare(struct ip_service *ss1, struct ip_service *ss2)
{
int result;
Remove any duplicate address/port pairs in the list
*********************************************************************/
-static int remove_duplicate_addrs2(struct ip_service *iplist, int count )
+int remove_duplicate_addrs2(struct ip_service *iplist, int count )
{
int i, j;
DEBUG(10,("remove_duplicate_addrs2: "
"looking for duplicate address/port pairs\n"));
- /* one loop to remove duplicates */
+ /* One loop to set duplicates to a zero addr. */
for ( i=0; i<count; i++ ) {
if ( is_zero_addr(&iplist[i].ss)) {
continue;
}
}
- /* one loop to clean up any holes we left */
- /* first ip should never be a zero_ip() */
- for (i = 0; i<count; ) {
- if (is_zero_addr(&iplist[i].ss) ) {
- if (i != count-1) {
- memmove(&iplist[i], &iplist[i+1],
- (count - i - 1)*sizeof(iplist[i]));
- }
+ /* Now remove any addresses set to zero above. */
+ for (i = 0; i < count; i++) {
+ while (i < count &&
+ is_zero_addr(&iplist[i].ss)) {
+ ARRAY_DEL_ELEMENT(iplist, i, count);
count--;
- continue;
}
- i++;
}
return count;
struct sockaddr_storage my_addr;
struct sockaddr_storage addr;
bool bcast;
+ bool bcast_star_query;
uint8_t buf[1024];
nmb->header.nscount = 0;
nmb->header.arcount = 0;
+ if (bcast && (strcmp(name, "*")==0)) {
+ /*
+ * We're doing a broadcast query for all
+ * names in the area. Remember this so
+ * we will wait for all names within
+ * the timeout period.
+ */
+ state->bcast_star_query = true;
+ }
+
make_nmb_name(&nmb->question.question_name,name,name_type);
nmb->question.question_type = 0x20;
putip((char *)&ip,&nmb->answers->rdata[2+i*6]);
in_addr_to_sockaddr_storage(&addr, ip);
+ if (is_zero_addr(&addr)) {
+ continue;
+ }
+
for (j=0; j<state->num_addrs; j++) {
if (sockaddr_equal(
(struct sockaddr *)(void *)&addr,
if (state->bcast) {
/*
* We have to collect all entries coming in from broadcast
- * queries. If we got a unique name, we're done.
+ * queries. If we got a unique name and we are not querying
+ * all names registered within broadcast area (query
+ * for the name '*', so state->bcast_star_query is set),
+ * we're done.
*/
- return got_unique_netbios_name;
+ return (got_unique_netbios_name && !state->bcast_star_query);
}
/*
* WINS responses are accepted when they are received
NTSTATUS status;
struct packet_struct *p = NULL;
- status = nb_trans_recv(subreq, &p);
+ status = nb_trans_recv(subreq, state, &p);
TALLOC_FREE(subreq);
if (tevent_req_nterror(req, status)) {
return;
tevent_req_nterror(req, state->validate_error);
return;
}
- if (p != NULL) {
- /*
- * Free the packet here, we've collected the response in the
- * validator
- */
- free_packet(p);
- }
tevent_req_done(req);
}
struct timeval timeout;
NTSTATUS status = NT_STATUS_NO_MEMORY;
- ev = tevent_context_init(frame);
+ ev = samba_tevent_context_init(frame);
if (ev == NULL) {
goto fail;
}
}
/********************************************************
- convert an array if struct sockaddr_storage to struct ip_service
+ Convert an array if struct sockaddr_storage to struct ip_service
return false on failure. Port is set to PORT_NONE;
+ pcount is [in/out] - it is the length of ss_list on input,
+ and the length of return_iplist on output as we remove any
+ zero addresses from ss_list.
*********************************************************/
static bool convert_ss2service(struct ip_service **return_iplist,
const struct sockaddr_storage *ss_list,
- int count)
+ int *pcount)
{
int i;
+ int orig_count = *pcount;
+ int real_count = 0;
- if ( count==0 || !ss_list )
+ if (orig_count==0 || !ss_list )
return False;
+ /* Filter out zero addrs. */
+ for ( i=0; i<orig_count; i++ ) {
+ if (is_zero_addr(&ss_list[i])) {
+ continue;
+ }
+ real_count++;
+ }
+ if (real_count==0) {
+ return false;
+ }
+
/* copy the ip address; port will be PORT_NONE */
- if ((*return_iplist = SMB_MALLOC_ARRAY(struct ip_service, count)) ==
+ if ((*return_iplist = SMB_MALLOC_ARRAY(struct ip_service, real_count)) ==
NULL) {
DEBUG(0,("convert_ip2service: malloc failed "
- "for %d enetries!\n", count ));
+ "for %d enetries!\n", real_count ));
return False;
}
- for ( i=0; i<count; i++ ) {
- (*return_iplist)[i].ss = ss_list[i];
- (*return_iplist)[i].port = PORT_NONE;
+ for ( i=0, real_count = 0; i<orig_count; i++ ) {
+ if (is_zero_addr(&ss_list[i])) {
+ continue;
+ }
+ (*return_iplist)[real_count].ss = ss_list[i];
+ (*return_iplist)[real_count].port = PORT_NONE;
+ real_count++;
}
+ *pcount = real_count;
return true;
}
if (!tevent_req_set_endtime(
subreq, state->ev,
timeval_current_ofs(0, state->timeout_msec * 1000))) {
- tevent_req_oom(req);
return tevent_req_post(req, ev);
}
tevent_req_set_callback(subreq, name_queries_done, req);
if (!tevent_req_set_endtime(
subreq, state->ev,
timeval_current_ofs(0, state->timeout_msec * 1000))) {
- tevent_req_oom(req);
return;
}
state->subreqs[state->num_sent] = subreq;
}
subreq = name_queries_send(state, ev, name, name_type, true, true,
- bcast_addrs, num_bcast_addrs, 0, 1000);
+ bcast_addrs, num_bcast_addrs, 0, 250);
if (tevent_req_nomem(subreq, req)) {
return tevent_req_post(req, ev);
}
int *return_count)
{
TALLOC_CTX *frame = talloc_stackframe();
- struct event_context *ev;
+ struct tevent_context *ev;
struct tevent_req *req;
NTSTATUS status = NT_STATUS_NO_MEMORY;
- ev = event_context_init(frame);
+ ev = samba_tevent_context_init(frame);
if (ev == NULL) {
goto fail;
}
}
if (!tevent_req_set_endtime(subreq, state->ev,
timeval_current_ofs(2, 0))) {
- tevent_req_oom(req);
return tevent_req_post(req, ev);
}
tevent_req_set_callback(subreq, query_wins_list_done, req);
}
if (!tevent_req_set_endtime(subreq, state->ev,
timeval_current_ofs(2, 0))) {
- tevent_req_oom(req);
return;
}
tevent_req_set_callback(subreq, query_wins_list_done, req);
}
/* the address we will be sending from */
- if (!interpret_string_addr(&src_ss, lp_socket_address(),
+ if (!interpret_string_addr(&src_ss, lp_nbt_client_socket_address(),
AI_NUMERICHOST|AI_PASSIVE)) {
zero_sockaddr(&src_ss);
}
struct tevent_req *req;
NTSTATUS status = NT_STATUS_NO_MEMORY;
- ev = tevent_context_init(talloc_tos());
+ ev = samba_tevent_context_init(talloc_tos());
if (ev == NULL) {
goto fail;
}
return status;
}
-/********************************************************
- Resolve via "lmhosts" method.
-*********************************************************/
-
-static NTSTATUS resolve_lmhosts(const char *name, int name_type,
- struct ip_service **return_iplist,
- int *return_count)
-{
- /*
- * "lmhosts" means parse the local lmhosts file.
- */
- struct sockaddr_storage *ss_list;
- NTSTATUS status = NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND;
- TALLOC_CTX *ctx = NULL;
-
- *return_iplist = NULL;
- *return_count = 0;
-
- DEBUG(3,("resolve_lmhosts: "
- "Attempting lmhosts lookup for name %s<0x%x>\n",
- name, name_type));
-
- ctx = talloc_init("resolve_lmhosts");
- if (!ctx) {
- return NT_STATUS_NO_MEMORY;
- }
-
- status = resolve_lmhosts_file_as_sockaddr(get_dyn_LMHOSTSFILE(),
- name, name_type,
- ctx,
- &ss_list,
- return_count);
- if (NT_STATUS_IS_OK(status)) {
- if (convert_ss2service(return_iplist,
- ss_list,
- *return_count)) {
- talloc_free(ctx);
- return NT_STATUS_OK;
- } else {
- talloc_free(ctx);
- return NT_STATUS_NO_MEMORY;
- }
- }
- talloc_free(ctx);
- return status;
-}
-
-
/********************************************************
Resolve via "hosts" method.
*********************************************************/
static NTSTATUS resolve_hosts(const char *name, int name_type,
- struct ip_service **return_iplist,
+ TALLOC_CTX *mem_ctx,
+ struct sockaddr_storage **return_iplist,
int *return_count)
{
/*
struct addrinfo *res = NULL;
int ret = -1;
int i = 0;
- const char *dns_hosts_file;
if ( name_type != 0x20 && name_type != 0x0) {
DEBUG(5, ("resolve_hosts: not appropriate "
hints.ai_family = AF_INET;
#endif
- dns_hosts_file = lp_parm_const_string(-1, "resolv", "host file", NULL);
- if (dns_hosts_file) {
- struct sockaddr_storage *ss_list;
- NTSTATUS status;
- TALLOC_CTX *ctx = talloc_stackframe();
- if (!ctx) {
- return NT_STATUS_NO_MEMORY;
- }
-
- status = resolve_dns_hosts_file_as_sockaddr(dns_hosts_file, name, false,
- ctx, &ss_list, return_count);
- if (NT_STATUS_IS_OK(status)) {
- if (convert_ss2service(return_iplist,
- ss_list,
- *return_count)) {
- talloc_free(ctx);
- return NT_STATUS_OK;
- } else {
- talloc_free(ctx);
- return NT_STATUS_NO_MEMORY;
- }
- }
- talloc_free(ctx);
- return NT_STATUS_UNSUCCESSFUL;
- }
-
ret = getaddrinfo(name,
NULL,
&hints,
ZERO_STRUCT(ss);
memcpy(&ss, res->ai_addr, res->ai_addrlen);
+ if (is_zero_addr(&ss)) {
+ continue;
+ }
+
*return_count += 1;
- *return_iplist = SMB_REALLOC_ARRAY(*return_iplist,
- struct ip_service,
- *return_count);
+ *return_iplist = talloc_realloc(
+ mem_ctx, *return_iplist, struct sockaddr_storage,
+ *return_count);
if (!*return_iplist) {
DEBUG(3,("resolve_hosts: malloc fail !\n"));
freeaddrinfo(ailist);
return NT_STATUS_NO_MEMORY;
}
- (*return_iplist)[i].ss = ss;
- (*return_iplist)[i].port = PORT_NONE;
+ (*return_iplist)[i] = ss;
i++;
}
if (ailist) {
struct ip_service **return_iplist,
int *return_count)
{
- int i, j;
+ int i;
NTSTATUS status;
TALLOC_CTX *ctx;
struct dns_rr_srv *dcs = NULL;
}
/* The DNS code needs fixing to find IPv6 addresses... JRA. */
-
switch (name_type) {
case 0x1b:
DEBUG(5,("resolve_ads: Attempting to resolve "
"PDC for %s using DNS\n", name));
- status = ads_dns_query_pdc(ctx, name, &dcs, &numdcs);
+ status = ads_dns_query_pdc(ctx,
+ name,
+ &dcs,
+ &numdcs);
break;
case 0x1c:
DEBUG(5,("resolve_ads: Attempting to resolve "
"DCs for %s using DNS\n", name));
- status = ads_dns_query_dcs(ctx, name, sitename, &dcs,
+ status = ads_dns_query_dcs(ctx,
+ name,
+ sitename,
+ &dcs,
&numdcs);
break;
case KDC_NAME_TYPE:
DEBUG(5,("resolve_ads: Attempting to resolve "
"KDCs for %s using DNS\n", name));
- status = ads_dns_query_kdcs(ctx, name, sitename, &dcs,
+ status = ads_dns_query_kdcs(ctx,
+ name,
+ sitename,
+ &dcs,
&numdcs);
break;
default:
return status;
}
- for (i=0;i<numdcs;i++) {
- numaddrs += MAX(dcs[i].num_ips,1);
+ if (numdcs == 0) {
+ *return_iplist = NULL;
+ *return_count = 0;
+ talloc_destroy(ctx);
+ return NT_STATUS_OK;
}
+ for (i=0;i<numdcs;i++) {
+ if (!dcs[i].ss_s) {
+ numaddrs += 1;
+ } else {
+ numaddrs += dcs[i].num_ips;
+ }
+ }
+
if ((*return_iplist = SMB_MALLOC_ARRAY(struct ip_service, numaddrs)) ==
NULL ) {
DEBUG(0,("resolve_ads: malloc failed for %d entries\n",
/* now unroll the list of IP addresses */
*return_count = 0;
- i = 0;
- j = 0;
- while ( i < numdcs && (*return_count<numaddrs) ) {
- struct ip_service *r = &(*return_iplist)[*return_count];
-
- r->port = dcs[i].port;
+ for (i = 0; i < numdcs && (*return_count<numaddrs); i++ ) {
/* If we don't have an IP list for a name, lookup it up */
-
if (!dcs[i].ss_s) {
- interpret_string_addr(&r->ss, dcs[i].hostname, 0);
- i++;
- j = 0;
- } else {
- /* use the IP addresses from the SRV sresponse */
-
- if ( j >= dcs[i].num_ips ) {
- i++;
- j = 0;
+ /* We need to get all IP addresses here. */
+ struct addrinfo *res = NULL;
+ struct addrinfo *p;
+ int extra_addrs = 0;
+
+ if (!interpret_string_addr_internal(&res,
+ dcs[i].hostname,
+ 0)) {
continue;
}
-
- r->ss = dcs[i].ss_s[j];
- j++;
+ /* Add in every IP from the lookup. How
+ many is that ? */
+ for (p = res; p; p = p->ai_next) {
+ struct sockaddr_storage ss;
+ memcpy(&ss, p->ai_addr, p->ai_addrlen);
+ if (is_zero_addr(&ss)) {
+ continue;
+ }
+ extra_addrs++;
+ }
+ if (extra_addrs > 1) {
+ /* We need to expand the return_iplist array
+ as we only budgeted for one address. */
+ numaddrs += (extra_addrs-1);
+ *return_iplist = SMB_REALLOC_ARRAY(*return_iplist,
+ struct ip_service,
+ numaddrs);
+ if (*return_iplist == NULL) {
+ if (res) {
+ freeaddrinfo(res);
+ }
+ talloc_destroy(ctx);
+ return NT_STATUS_NO_MEMORY;
+ }
+ }
+ for (p = res; p; p = p->ai_next) {
+ (*return_iplist)[*return_count].port = dcs[i].port;
+ memcpy(&(*return_iplist)[*return_count].ss,
+ p->ai_addr,
+ p->ai_addrlen);
+ if (is_zero_addr(&(*return_iplist)[*return_count].ss)) {
+ continue;
+ }
+ (*return_count)++;
+ /* Should never happen, but still... */
+ if (*return_count>=numaddrs) {
+ break;
+ }
+ }
+ if (res) {
+ freeaddrinfo(res);
+ }
+ } else {
+ /* use all the IP addresses from the SRV response */
+ size_t j;
+ for (j = 0; j < dcs[i].num_ips; j++) {
+ (*return_iplist)[*return_count].port = dcs[i].port;
+ (*return_iplist)[*return_count].ss = dcs[i].ss_s[j];
+ if (is_zero_addr(&(*return_iplist)[*return_count].ss)) {
+ continue;
+ }
+ (*return_count)++;
+ /* Should never happen, but still... */
+ if (*return_count>=numaddrs) {
+ break;
+ }
+ }
}
+ }
- /* make sure it is a valid IP. I considered checking the
- * negative connection cache, but this is the wrong place
- * for it. Maybe only as a hack. After think about it, if
- * all of the IP addresses returned from DNS are dead, what
- * hope does a netbios name lookup have ? The standard reason
- * for falling back to netbios lookups is that our DNS server
- * doesn't know anything about the DC's -- jerry */
+ talloc_destroy(ctx);
+ return NT_STATUS_OK;
+}
+
+static const char **filter_out_nbt_lookup(TALLOC_CTX *mem_ctx,
+ const char **resolve_order)
+{
+ size_t i, len, result_idx;
+ const char **result;
+
+ len = 0;
+ while (resolve_order[len] != NULL) {
+ len += 1;
+ }
+
+ result = talloc_array(mem_ctx, const char *, len+1);
+ if (result == NULL) {
+ return NULL;
+ }
- if (!is_zero_addr(&r->ss)) {
- (*return_count)++;
+ result_idx = 0;
+
+ for (i=0; i<len; i++) {
+ const char *tok = resolve_order[i];
+
+ if (strequal(tok, "lmhosts") || strequal(tok, "wins") ||
+ strequal(tok, "bcast")) {
+ continue;
}
+ result[result_idx++] = tok;
}
+ result[result_idx] = NULL;
- talloc_destroy(ctx);
- return NT_STATUS_OK;
+ return result;
}
/*******************************************************************
const char *sitename,
struct ip_service **return_iplist,
int *return_count,
- const char *resolve_order)
+ const char **resolve_order)
{
- char *tok;
- const char *ptr;
+ const char *tok;
NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
int i;
TALLOC_CTX *frame = NULL;
SAFE_FREE(*return_iplist);
return NT_STATUS_INVALID_PARAMETER;
}
+ if (is_zero_addr(&(*return_iplist)->ss)) {
+ SAFE_FREE(*return_iplist);
+ return NT_STATUS_UNSUCCESSFUL;
+ }
*return_count = 1;
return NT_STATUS_OK;
}
/* Check name cache */
if (namecache_fetch(name, name_type, return_iplist, return_count)) {
+ *return_count = remove_duplicate_addrs2(*return_iplist,
+ *return_count );
/* This could be a negative response */
if (*return_count > 0) {
return NT_STATUS_OK;
/* set the name resolution order */
- if (strcmp( resolve_order, "NULL") == 0) {
+ if (resolve_order && strcmp(resolve_order[0], "NULL") == 0) {
DEBUG(8,("internal_resolve_name: all lookups disabled\n"));
return NT_STATUS_INVALID_PARAMETER;
}
- if (!resolve_order[0]) {
- ptr = "host";
- } else {
- ptr = resolve_order;
+ if (!resolve_order || !resolve_order[0]) {
+ static const char *host_order[] = { "host", NULL };
+ resolve_order = host_order;
+ }
+
+ frame = talloc_stackframe();
+
+ if ((strlen(name) > MAX_NETBIOSNAME_LEN - 1) ||
+ (strchr(name, '.') != NULL)) {
+ /*
+ * Don't do NBT lookup, the name would not fit anyway
+ */
+ resolve_order = filter_out_nbt_lookup(frame, resolve_order);
+ if (resolve_order == NULL) {
+ TALLOC_FREE(frame);
+ return NT_STATUS_NO_MEMORY;
+ }
}
/* iterate through the name resolution backends */
- frame = talloc_stackframe();
- while (next_token_talloc(frame, &ptr, &tok, LIST_SEP)) {
+ for (i=0; resolve_order[i]; i++) {
+ tok = resolve_order[i];
+
if((strequal(tok, "host") || strequal(tok, "hosts"))) {
- status = resolve_hosts(name, name_type, return_iplist,
+ struct sockaddr_storage *ss_list;
+ status = resolve_hosts(name, name_type,
+ talloc_tos(), &ss_list,
return_count);
if (NT_STATUS_IS_OK(status)) {
+ if (!convert_ss2service(return_iplist,
+ ss_list,
+ return_count)) {
+ status = NT_STATUS_NO_MEMORY;
+ }
goto done;
}
} else if(strequal( tok, "kdc")) {
if (NT_STATUS_IS_OK(status)) {
goto done;
}
- } else if(strequal( tok, "lmhosts")) {
- status = resolve_lmhosts(name, name_type,
- return_iplist, return_count);
+ } else if (strequal(tok, "lmhosts")) {
+ struct sockaddr_storage *ss_list;
+ status = resolve_lmhosts_file_as_sockaddr(
+ get_dyn_LMHOSTSFILE(), name, name_type,
+ talloc_tos(), &ss_list, return_count);
if (NT_STATUS_IS_OK(status)) {
+ if (!convert_ss2service(return_iplist,
+ ss_list,
+ return_count)) {
+ status = NT_STATUS_NO_MEMORY;
+ }
goto done;
}
- } else if(strequal( tok, "wins")) {
+ } else if (strequal(tok, "wins")) {
/* don't resolve 1D via WINS */
- struct sockaddr_storage *ss_list;
+ struct sockaddr_storage *ss_list = NULL;
if (name_type != 0x1D) {
status = resolve_wins(name, name_type,
talloc_tos(),
if (NT_STATUS_IS_OK(status)) {
if (!convert_ss2service(return_iplist,
ss_list,
- *return_count)) {
+ return_count)) {
status = NT_STATUS_NO_MEMORY;
}
goto done;
}
}
- } else if(strequal( tok, "bcast")) {
- struct sockaddr_storage *ss_list;
+ } else if (strequal(tok, "bcast")) {
+ struct sockaddr_storage *ss_list = NULL;
status = name_resolve_bcast(
name, name_type, talloc_tos(),
&ss_list, return_count);
if (NT_STATUS_IS_OK(status)) {
if (!convert_ss2service(return_iplist,
ss_list,
- *return_count)) {
+ return_count)) {
status = NT_STATUS_NO_MEMORY;
}
goto done;
SAFE_FREE(*return_iplist);
*return_count = 0;
- return NT_STATUS_UNSUCCESSFUL;
+ return status;
done:
controllers including the PDC in iplist[1..n]. Iterating over
the iplist when the PDC is down will cause two sets of timeouts. */
- if ( *return_count ) {
- *return_count = remove_duplicate_addrs2(*return_iplist,
- *return_count );
- }
+ *return_count = remove_duplicate_addrs2(*return_iplist, *return_count );
/* Save in name cache */
if ( DEBUGLEVEL >= 100 ) {
}
}
- namecache_store(name, name_type, *return_count, *return_iplist);
+ if (*return_count) {
+ namecache_store(name, name_type, *return_count, *return_iplist);
+ }
/* Display some debugging info */
char *sitename = NULL;
int count = 0;
NTSTATUS status;
+ TALLOC_CTX *frame = NULL;
if (is_ipaddress(name)) {
return interpret_string_addr(return_ss, name, AI_NUMERICHOST);
}
- sitename = sitename_fetch(lp_realm()); /* wild guess */
+ frame = talloc_stackframe();
+
+ sitename = sitename_fetch(frame, lp_realm()); /* wild guess */
status = internal_resolve_name(name, name_type, sitename,
&ss_list, &count,
(ss_list[i].ss.ss_family == AF_INET)) {
*return_ss = ss_list[i].ss;
SAFE_FREE(ss_list);
- SAFE_FREE(sitename);
+ TALLOC_FREE(frame);
return True;
}
}
!is_broadcast_addr((struct sockaddr *)(void *)&ss_list[i].ss)) {
*return_ss = ss_list[i].ss;
SAFE_FREE(ss_list);
- SAFE_FREE(sitename);
+ TALLOC_FREE(frame);
return True;
}
}
}
SAFE_FREE(ss_list);
- SAFE_FREE(sitename);
+ TALLOC_FREE(frame);
return False;
}
return NT_STATUS_OK;
}
- sitename = sitename_fetch(lp_realm()); /* wild guess */
+ sitename = sitename_fetch(ctx, lp_realm()); /* wild guess */
status = internal_resolve_name(name, name_type, sitename,
&ss_list, &count,
lp_name_resolve_order());
- SAFE_FREE(sitename);
+ TALLOC_FREE(sitename);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
}
if (num_entries == 0) {
- SAFE_FREE(ss_list);
- return NT_STATUS_BAD_NETWORK_NAME;
+ status = NT_STATUS_BAD_NETWORK_NAME;
+ goto done;
}
*return_ss_arr = talloc_array(ctx,
struct sockaddr_storage,
num_entries);
if (!(*return_ss_arr)) {
- SAFE_FREE(ss_list);
- return NT_STATUS_NO_MEMORY;
+ status = NT_STATUS_NO_MEMORY;
+ goto done;
}
for (i=0, num_entries = 0; i<count; i++) {
status = NT_STATUS_OK;
*p_num_entries = num_entries;
-
+done:
SAFE_FREE(ss_list);
- return NT_STATUS_OK;
+ return status;
}
/********************************************************
struct ip_service *ip_list = NULL;
int count = 0;
NTSTATUS status = NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND;
-
+ static const char *ads_order[] = { "ads", NULL };
/* Look up #1B name */
if (lp_security() == SEC_ADS) {
status = internal_resolve_name(domain, 0x1b, NULL, &ip_list,
- &count, "ads");
+ &count, ads_order);
}
if (!NT_STATUS_IS_OK(status) || count == 0) {
&count,
lp_name_resolve_order());
if (!NT_STATUS_IS_OK(status)) {
+ SAFE_FREE(ip_list);
return false;
}
}
enum dc_lookup_type lookup_type,
bool *ordered)
{
- char *resolve_order = NULL;
+ const char **resolve_order = NULL;
char *saf_servername = NULL;
char *pserver = NULL;
const char *p;
char *port_str = NULL;
int port;
char *name;
- int num_addresses = 0;
- int local_count, i, j;
+ size_t num_addresses = 0;
+ size_t local_count, i;
struct ip_service *return_iplist = NULL;
struct ip_service *auto_ip_list = NULL;
bool done_auto_lookup = false;
int auto_count = 0;
NTSTATUS status;
- TALLOC_CTX *ctx = talloc_init("get_dc_list");
+ TALLOC_CTX *ctx = talloc_stackframe();
+ int auto_name_type = 0x1C;
*ip_list = NULL;
*count = 0;
- if (!ctx) {
- return NT_STATUS_NO_MEMORY;
- }
-
*ordered = False;
/* if we are restricted to solely using DNS for looking
are disabled and ads_only is True, then set the string to
NULL. */
- resolve_order = talloc_strdup(ctx, lp_name_resolve_order());
+ resolve_order = lp_name_resolve_order();
if (!resolve_order) {
status = NT_STATUS_NO_MEMORY;
goto out;
}
- strlower_m(resolve_order);
if (lookup_type == DC_ADS_ONLY) {
- if (strstr( resolve_order, "host")) {
- resolve_order = talloc_strdup(ctx, "ads");
+ if (str_list_check_ci(resolve_order, "host")) {
+ static const char *ads_order[] = { "ads", NULL };
+ resolve_order = ads_order;
/* DNS SRV lookups used by the ads resolver
are already sorted by priority and weight */
*ordered = true;
} else {
- resolve_order = talloc_strdup(ctx, "NULL");
+ /* this is quite bizarre! */
+ static const char *null_order[] = { "NULL", NULL };
+ resolve_order = null_order;
}
} else if (lookup_type == DC_KDC_ONLY) {
+ static const char *kdc_order[] = { "kdc", NULL };
/* DNS SRV lookups used by the ads/kdc resolver
are already sorted by priority and weight */
*ordered = true;
- resolve_order = talloc_strdup(ctx, "kdc");
- }
- if (!resolve_order) {
- status = NT_STATUS_NO_MEMORY;
- goto out;
+ resolve_order = kdc_order;
+ auto_name_type = KDC_NAME_TYPE;
}
/* fetch the server we have affinity for. Add the
'password server' list to a search for our domain controllers */
- saf_servername = saf_fetch( domain);
+ saf_servername = saf_fetch(ctx, domain);
if (strequal(domain, lp_workgroup()) || strequal(domain, lp_realm())) {
pserver = talloc_asprintf(ctx, "%s, %s",
saf_servername ? saf_servername : "",
- lp_passwordserver());
+ lp_password_server());
} else {
pserver = talloc_asprintf(ctx, "%s, *",
saf_servername ? saf_servername : "");
}
- SAFE_FREE(saf_servername);
+ TALLOC_FREE(saf_servername);
if (!pserver) {
status = NT_STATUS_NO_MEMORY;
goto out;
}
- /* if we are starting from scratch, just lookup DOMAIN<0x1c> */
-
- if (!*pserver ) {
- DEBUG(10,("get_dc_list: no preferred domain controllers.\n"));
- status = internal_resolve_name(domain, 0x1C, sitename, ip_list,
- count, resolve_order);
- goto out;
- }
-
DEBUG(3,("get_dc_list: preferred server list: \"%s\"\n", pserver ));
/*
p = pserver;
while (next_token_talloc(ctx, &p, &name, LIST_SEP)) {
if (!done_auto_lookup && strequal(name, "*")) {
- status = internal_resolve_name(domain, 0x1C, sitename,
+ status = internal_resolve_name(domain, auto_name_type,
+ sitename,
&auto_ip_list,
&auto_count,
resolve_order);
/* if we have no addresses and haven't done the auto lookup, then
just return the list of DC's. Or maybe we just failed. */
- if ((num_addresses == 0)) {
+ if (num_addresses == 0) {
if (done_auto_lookup) {
DEBUG(4,("get_dc_list: no servers found\n"));
status = NT_STATUS_NO_LOGON_SERVERS;
goto out;
}
- status = internal_resolve_name(domain, 0x1C, sitename, ip_list,
+ status = internal_resolve_name(domain, auto_name_type,
+ sitename, ip_list,
count, resolve_order);
goto out;
}
next_token_talloc(ctx, &p, &name, LIST_SEP)) {
struct sockaddr_storage name_ss;
- /* copy any addersses from the auto lookup */
+ /* copy any addresses from the auto lookup */
if (strequal(name, "*")) {
+ int j;
for (j=0; j<auto_count; j++) {
char addr[INET6_ADDRSTRLEN];
print_sockaddr(addr,
/* added support for address:port syntax for ads
* (not that I think anyone will ever run the LDAP
* server in an AD domain on something other than
- * port 389 */
+ * port 389
+ * However, the port should not be used for kerberos
+ */
- port = (lp_security() == SEC_ADS) ? LDAP_PORT : PORT_NONE;
+ port = (lookup_type == DC_ADS_ONLY) ? LDAP_PORT :
+ ((lookup_type == DC_KDC_ONLY) ? DEFAULT_KRB5_PORT :
+ PORT_NONE);
if ((port_str=strchr(name, ':')) != NULL) {
*port_str = '\0';
- port_str++;
- port = atoi(port_str);
+ if (lookup_type != DC_KDC_ONLY) {
+ port_str++;
+ port = atoi(port_str);
+ }
}
/* explicit lookup; resolve_name() will
/* need to remove duplicates in the list if we have any
explicit password servers */
- if (local_count) {
- local_count = remove_duplicate_addrs2(return_iplist,
- local_count );
- }
+ local_count = remove_duplicate_addrs2(return_iplist, local_count );
/* For DC's we always prioritize IPv4 due to W2K3 not
* supporting LDAP, KRB5 or CLDAP over IPv6. */
}
if ( DEBUGLEVEL >= 4 ) {
- DEBUG(4,("get_dc_list: returning %d ip addresses "
+ DEBUG(4,("get_dc_list: returning %zu ip addresses "
"in an %sordered list\n",
local_count,
*ordered ? "":"un"));
*count = 0;
DEBUG(8,("get_sorted_dc_list: attempting lookup "
- "for name %s (sitename %s) using [%s]\n",
+ "for name %s (sitename %s)\n",
domain,
- sitename ? sitename : "NULL",
- (ads_only ? "ads" : lp_name_resolve_order())));
+ sitename ? sitename : "NULL"));
if (ads_only) {
lookup_type = DC_ADS_ONLY;