*/
#include "includes.h"
+#include "libads/sitename_cache.h"
+#include "../librpc/gen_ndr/ndr_netlogon.h"
+#include "libads/cldap.h"
+#include "libads/dns.h"
+#include "libsmb/clidgram.h"
-#define DSGETDCNAME_FMT "DSGETDCNAME/DOMAIN/%s"
/* 15 minutes */
#define DSGETDCNAME_CACHE_TTL 60*15
const char *hostname;
};
+static NTSTATUS make_dc_info_from_cldap_reply(TALLOC_CTX *mem_ctx,
+ uint32_t flags,
+ struct sockaddr_storage *ss,
+ struct NETLOGON_SAM_LOGON_RESPONSE_EX *r,
+ struct netr_DsRGetDCNameInfo **info);
+
/****************************************************************
****************************************************************/
DEBUGADD(lvl,("\n"));
}
-/*********************************************************************
- ********************************************************************/
-
-static int pack_dsdcinfo(struct netr_DsRGetDCNameInfo *info,
- unsigned char **buf)
-{
- unsigned char *buffer = NULL;
- int len = 0;
- int buflen = 0;
- UUID_FLAT guid_flat;
-
- DEBUG(10,("pack_dsdcinfo: Packing dsdcinfo\n"));
-
- ZERO_STRUCT(guid_flat);
-
- if (!GUID_all_zero(&info->domain_guid)) {
- smb_uuid_pack(info->domain_guid, &guid_flat);
- }
-
- again:
- len = 0;
-
- if (buflen > 0) {
- DEBUG(10,("pack_dsdcinfo: Packing domain %s (%s)\n",
- info->domain_name, info->dc_unc));
- }
-
- len += tdb_pack(buffer+len, buflen-len, "ffdBffdff",
- info->dc_unc,
- info->dc_address,
- info->dc_address_type,
- UUID_FLAT_SIZE, guid_flat.info,
- info->domain_name,
- info->forest_name,
- info->dc_flags,
- info->dc_site_name,
- info->client_site_name);
-
- if (buflen < len) {
- SAFE_FREE(buffer);
- if ((buffer = SMB_MALLOC_ARRAY(unsigned char, len)) == NULL ) {
- DEBUG(0,("pack_dsdcinfo: failed to alloc buffer!\n"));
- buflen = -1;
- goto done;
- }
- buflen = len;
- goto again;
- }
-
- *buf = buffer;
-
- done:
- return buflen;
-}
-
-/*********************************************************************
- ********************************************************************/
-
-static NTSTATUS unpack_dsdcinfo(TALLOC_CTX *mem_ctx,
- unsigned char *buf,
- int buflen,
- struct netr_DsRGetDCNameInfo **info_ret)
-{
- int len = 0;
- struct netr_DsRGetDCNameInfo *info = NULL;
- uint32_t guid_len = 0;
- unsigned char *guid_buf = NULL;
- UUID_FLAT guid_flat;
-
- /* forgive me 6 times */
- fstring dc_unc;
- fstring dc_address;
- fstring domain_name;
- fstring forest_name;
- fstring dc_site_name;
- fstring client_site_name;
-
- info = TALLOC_ZERO_P(mem_ctx, struct netr_DsRGetDCNameInfo);
- NT_STATUS_HAVE_NO_MEMORY(info);
-
- len += tdb_unpack(buf+len, buflen-len, "ffdBffdff",
- &dc_unc,
- &dc_address,
- &info->dc_address_type,
- &guid_len, &guid_buf,
- &domain_name,
- &forest_name,
- &info->dc_flags,
- &dc_site_name,
- &client_site_name);
- if (len == -1) {
- DEBUG(5,("unpack_dsdcinfo: Failed to unpack domain\n"));
- goto failed;
- }
-
- info->dc_unc =
- talloc_strdup(mem_ctx, dc_unc);
- info->dc_address =
- talloc_strdup(mem_ctx, dc_address);
- info->domain_name =
- talloc_strdup(mem_ctx, domain_name);
- info->forest_name =
- talloc_strdup(mem_ctx, forest_name);
- info->dc_site_name =
- talloc_strdup(mem_ctx, dc_site_name);
- info->client_site_name =
- talloc_strdup(mem_ctx, client_site_name);
-
- if (!info->dc_unc ||
- !info->dc_address ||
- !info->domain_name ||
- !info->forest_name ||
- !info->dc_site_name ||
- !info->client_site_name) {
- goto failed;
- }
-
- if (guid_len > 0) {
- struct GUID guid;
-
- if (guid_len != UUID_FLAT_SIZE) {
- goto failed;
- }
-
- memcpy(&guid_flat.info, guid_buf, guid_len);
- smb_uuid_unpack(guid_flat, &guid);
-
- info->domain_guid = guid;
- SAFE_FREE(guid_buf);
- }
-
- DEBUG(10,("unpack_dcscinfo: Unpacked domain %s (%s)\n",
- info->domain_name, info->dc_unc));
-
- *info_ret = info;
-
- return NT_STATUS_OK;
-
- failed:
- TALLOC_FREE(info);
- SAFE_FREE(guid_buf);
- return NT_STATUS_NO_MEMORY;
-}
-
/****************************************************************
****************************************************************/
static char *dsgetdcname_cache_key(TALLOC_CTX *mem_ctx, const char *domain)
{
- if (!mem_ctx || !domain) {
+ if (!domain) {
return NULL;
}
- return talloc_asprintf_strupper_m(mem_ctx, DSGETDCNAME_FMT, domain);
+ return talloc_asprintf_strupper_m(mem_ctx, "DSGETDCNAME/DOMAIN/%s",
+ domain);
}
/****************************************************************
{
char *key;
- if (!gencache_init()) {
- return NT_STATUS_INTERNAL_DB_ERROR;
- }
-
key = dsgetdcname_cache_key(mem_ctx, domain_name);
if (!key) {
return NT_STATUS_NO_MEMORY;
static NTSTATUS dsgetdcname_cache_store(TALLOC_CTX *mem_ctx,
const char *domain_name,
- struct netr_DsRGetDCNameInfo *info)
+ const DATA_BLOB *blob)
{
time_t expire_time;
char *key;
bool ret = false;
- DATA_BLOB blob;
- unsigned char *buf = NULL;
- int len = 0;
-
- if (!gencache_init()) {
- return NT_STATUS_INTERNAL_DB_ERROR;
- }
key = dsgetdcname_cache_key(mem_ctx, domain_name);
if (!key) {
expire_time = time(NULL) + DSGETDCNAME_CACHE_TTL;
- len = pack_dsdcinfo(info, &buf);
- if (len == -1) {
- return NT_STATUS_UNSUCCESSFUL;
- }
-
- blob = data_blob(buf, len);
- SAFE_FREE(buf);
-
- if (gencache_lock_entry(key) != 0) {
- data_blob_free(&blob);
- return NT_STATUS_LOCK_NOT_GRANTED;
- }
-
- ret = gencache_set_data_blob(key, &blob, expire_time);
- data_blob_free(&blob);
-
- gencache_unlock_entry(key);
+ ret = gencache_set_data_blob(key, blob, expire_time);
return ret ? NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
}
/****************************************************************
****************************************************************/
-static NTSTATUS dsgetdcname_cache_refresh(TALLOC_CTX *mem_ctx,
- const char *domain_name,
- struct GUID *domain_guid,
- uint32_t flags,
- const char *site_name,
- struct netr_DsRGetDCNameInfo *info)
+static NTSTATUS store_cldap_reply(TALLOC_CTX *mem_ctx,
+ uint32_t flags,
+ struct sockaddr_storage *ss,
+ uint32_t nt_version,
+ struct NETLOGON_SAM_LOGON_RESPONSE_EX *r)
{
- struct cldap_netlogon_reply r;
-
- /* check if matching entry is older then 15 minutes, if yes, send
- * CLDAP/MAILSLOT ping again and store the cached data */
+ DATA_BLOB blob;
+ enum ndr_err_code ndr_err;
+ NTSTATUS status;
+ char addr[INET6_ADDRSTRLEN];
- ZERO_STRUCT(r);
+ print_sockaddr(addr, sizeof(addr), ss);
- if (ads_cldap_netlogon(info->dc_unc,
- info->domain_name, &r)) {
+ /* FIXME */
+ r->sockaddr_size = 0x10; /* the w32 winsock addr size */
+ r->sockaddr.sockaddr_family = 2; /* AF_INET */
+ r->sockaddr.pdc_ip = talloc_strdup(mem_ctx, addr);
- dsgetdcname_cache_delete(mem_ctx, domain_name);
+ ndr_err = ndr_push_struct_blob(&blob, mem_ctx, r,
+ (ndr_push_flags_fn_t)ndr_push_NETLOGON_SAM_LOGON_RESPONSE_EX);
+ if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+ return ndr_map_error2ntstatus(ndr_err);
+ }
- return dsgetdcname_cache_store(mem_ctx,
- info->domain_name,
- info);
+ if (r->domain_name) {
+ status = dsgetdcname_cache_store(mem_ctx, r->domain_name, &blob);
+ if (!NT_STATUS_IS_OK(status)) {
+ goto done;
+ }
+ if (r->client_site) {
+ sitename_store(r->domain_name, r->client_site);
+ }
}
+ if (r->dns_domain) {
+ status = dsgetdcname_cache_store(mem_ctx, r->dns_domain, &blob);
+ if (!NT_STATUS_IS_OK(status)) {
+ goto done;
+ }
+ if (r->client_site) {
+ sitename_store(r->dns_domain, r->client_site);
+ }
+ }
+
+ status = NT_STATUS_OK;
+
+ done:
+ data_blob_free(&blob);
+
+ return status;
+}
- return NT_STATUS_INVALID_NETWORK_RESPONSE;
+/****************************************************************
+****************************************************************/
+
+static uint32_t get_cldap_reply_server_flags(struct netlogon_samlogon_response *r,
+ uint32_t nt_version)
+{
+ switch (nt_version & 0x0000001f) {
+ case 0:
+ case 1:
+ case 16:
+ case 17:
+ return 0;
+ case 2:
+ case 3:
+ case 18:
+ case 19:
+ return r->data.nt5.server_type;
+ case 4:
+ case 5:
+ case 6:
+ case 7:
+ return r->data.nt5_ex.server_type;
+ case 8:
+ case 9:
+ case 10:
+ case 11:
+ case 12:
+ case 13:
+ case 14:
+ case 15:
+ return r->data.nt5_ex.server_type;
+ case 20:
+ case 21:
+ case 22:
+ case 23:
+ case 24:
+ case 25:
+ case 26:
+ case 27:
+ case 28:
+ return r->data.nt5_ex.server_type;
+ case 29:
+ case 30:
+ case 31:
+ return r->data.nt5_ex.server_type;
+ default:
+ return 0;
+ }
}
/****************************************************************
****************************************************************/
-#define RETURN_ON_FALSE(x) if (!x) return false;
+#define RETURN_ON_FALSE(x) if (!(x)) return false;
static bool check_cldap_reply_required_flags(uint32_t ret_flags,
uint32_t req_flags)
{
+ if (ret_flags == 0) {
+ return true;
+ }
+
if (req_flags & DS_PDC_REQUIRED)
- RETURN_ON_FALSE(ret_flags & ADS_PDC);
+ RETURN_ON_FALSE(ret_flags & NBT_SERVER_PDC);
if (req_flags & DS_GC_SERVER_REQUIRED)
- RETURN_ON_FALSE(ret_flags & ADS_GC);
+ RETURN_ON_FALSE(ret_flags & NBT_SERVER_GC);
if (req_flags & DS_ONLY_LDAP_NEEDED)
- RETURN_ON_FALSE(ret_flags & ADS_LDAP);
+ RETURN_ON_FALSE(ret_flags & NBT_SERVER_LDAP);
if ((req_flags & DS_DIRECTORY_SERVICE_REQUIRED) ||
(req_flags & DS_DIRECTORY_SERVICE_PREFERRED))
- RETURN_ON_FALSE(ret_flags & ADS_DS);
+ RETURN_ON_FALSE(ret_flags & NBT_SERVER_DS);
if (req_flags & DS_KDC_REQUIRED)
- RETURN_ON_FALSE(ret_flags & ADS_KDC);
+ RETURN_ON_FALSE(ret_flags & NBT_SERVER_KDC);
if (req_flags & DS_TIMESERV_REQUIRED)
- RETURN_ON_FALSE(ret_flags & ADS_TIMESERV);
+ RETURN_ON_FALSE(ret_flags & NBT_SERVER_TIMESERV);
if (req_flags & DS_WRITABLE_REQUIRED)
- RETURN_ON_FALSE(ret_flags & ADS_WRITABLE);
+ RETURN_ON_FALSE(ret_flags & NBT_SERVER_WRITABLE);
return true;
}
static NTSTATUS dsgetdcname_cache_fetch(TALLOC_CTX *mem_ctx,
const char *domain_name,
- struct GUID *domain_guid,
+ const struct GUID *domain_guid,
uint32_t flags,
const char *site_name,
- struct netr_DsRGetDCNameInfo **info,
- bool *expired)
+ struct netr_DsRGetDCNameInfo **info_p)
{
char *key;
DATA_BLOB blob;
+ enum ndr_err_code ndr_err;
+ struct netr_DsRGetDCNameInfo *info;
+ struct NETLOGON_SAM_LOGON_RESPONSE_EX r;
NTSTATUS status;
- if (!gencache_init()) {
- return NT_STATUS_INTERNAL_DB_ERROR;
- }
-
key = dsgetdcname_cache_key(mem_ctx, domain_name);
if (!key) {
return NT_STATUS_NO_MEMORY;
}
- if (!gencache_get_data_blob(key, &blob, expired)) {
- return NT_STATUS_OBJECT_NAME_NOT_FOUND;
+ if (!gencache_get_data_blob(key, &blob, NULL, NULL)) {
+ return NT_STATUS_NOT_FOUND;
}
- status = unpack_dsdcinfo(mem_ctx, blob.data, blob.length, info);
+ info = TALLOC_ZERO_P(mem_ctx, struct netr_DsRGetDCNameInfo);
+ if (!info) {
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, &r,
+ (ndr_pull_flags_fn_t)ndr_pull_NETLOGON_SAM_LOGON_RESPONSE_EX);
+
+ data_blob_free(&blob);
+ if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+ dsgetdcname_cache_delete(mem_ctx, domain_name);
+ return ndr_map_error2ntstatus(ndr_err);
+ }
+
+ status = make_dc_info_from_cldap_reply(mem_ctx, flags, NULL,
+ &r, &info);
if (!NT_STATUS_IS_OK(status)) {
- data_blob_free(&blob);
return status;
}
- data_blob_free(&blob);
+ if (DEBUGLEVEL >= 10) {
+ NDR_PRINT_DEBUG(netr_DsRGetDCNameInfo, info);
+ }
/* check flags */
- if (!check_cldap_reply_required_flags((*info)->dc_flags, flags)) {
+ if (!check_cldap_reply_required_flags(info->dc_flags, flags)) {
DEBUG(10,("invalid flags\n"));
return NT_STATUS_INVALID_PARAMETER;
}
if ((flags & DS_IP_REQUIRED) &&
- ((*info)->dc_address_type != DS_ADDRESS_TYPE_INET)) {
+ (info->dc_address_type != DS_ADDRESS_TYPE_INET)) {
return NT_STATUS_INVALID_PARAMETER_MIX;
}
+ *info_p = info;
+
return NT_STATUS_OK;
}
****************************************************************/
static NTSTATUS dsgetdcname_cached(TALLOC_CTX *mem_ctx,
+ struct messaging_context *msg_ctx,
const char *domain_name,
- struct GUID *domain_guid,
+ const struct GUID *domain_guid,
uint32_t flags,
const char *site_name,
struct netr_DsRGetDCNameInfo **info)
{
NTSTATUS status;
- bool expired = false;
status = dsgetdcname_cache_fetch(mem_ctx, domain_name, domain_guid,
- flags, site_name, info, &expired);
- if (!NT_STATUS_IS_OK(status)) {
+ flags, site_name, info);
+ if (!NT_STATUS_IS_OK(status)
+ && !NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
DEBUG(10,("dsgetdcname_cached: cache fetch failed with: %s\n",
nt_errstr(status)));
return NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND;
return status;
}
- if (expired) {
- status = dsgetdcname_cache_refresh(mem_ctx, domain_name,
- domain_guid, flags,
- site_name, *info);
+ if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
+ struct netr_DsRGetDCNameInfo *dc_info;
+
+ status = dsgetdcname(mem_ctx, msg_ctx, domain_name,
+ domain_guid, site_name,
+ flags | DS_FORCE_REDISCOVERY,
+ &dc_info);
+
if (!NT_STATUS_IS_OK(status)) {
return status;
}
+
+ *info = dc_info;
}
return status;
/****************************************************************
****************************************************************/
-static bool check_allowed_required_flags(uint32_t flags)
+static bool check_allowed_required_flags(uint32_t flags,
+ const char *site_name)
{
uint32_t return_type = flags & (DS_RETURN_FLAT_NAME|DS_RETURN_DNS_NAME);
uint32_t offered_type = flags & (DS_IS_FLAT_NAME|DS_IS_DNS_NAME);
debug_dsdcinfo_flags(10, flags);
+ if ((flags & DS_TRY_NEXTCLOSEST_SITE) && site_name) {
+ return false;
+ }
+
if (return_type == (DS_RETURN_FLAT_NAME|DS_RETURN_DNS_NAME)) {
return false;
}
const char *domain_name,
uint32_t flags,
struct ip_service_name **returned_dclist,
- int *return_count)
+ int *returned_count)
{
+ NTSTATUS status;
+ enum nbt_name_type name_type = NBT_NAME_LOGON;
+ struct ip_service *iplist;
+ int i;
+ struct ip_service_name *dclist = NULL;
+ int count;
+
+ *returned_dclist = NULL;
+ *returned_count = 0;
+
if (lp_disable_netbios()) {
return NT_STATUS_NOT_SUPPORTED;
}
- /* FIXME: code here */
+ if (flags & DS_PDC_REQUIRED) {
+ name_type = NBT_NAME_PDC;
+ }
+
+ status = internal_resolve_name(domain_name, name_type, NULL,
+ &iplist, &count,
+ "lmhosts wins bcast");
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(10,("discover_dc_netbios: failed to find DC\n"));
+ return status;
+ }
- return NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND;
+ dclist = TALLOC_ZERO_ARRAY(mem_ctx, struct ip_service_name, count);
+ if (!dclist) {
+ SAFE_FREE(iplist);
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ for (i=0; i<count; i++) {
+
+ char addr[INET6_ADDRSTRLEN];
+ struct ip_service_name *r = &dclist[i];
+
+ print_sockaddr(addr, sizeof(addr),
+ &iplist[i].ss);
+
+ r->ss = iplist[i].ss;
+ r->port = iplist[i].port;
+ r->hostname = talloc_strdup(mem_ctx, addr);
+ if (!r->hostname) {
+ SAFE_FREE(iplist);
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ }
+
+ *returned_dclist = dclist;
+ *returned_count = count;
+ SAFE_FREE(iplist);
+
+ return NT_STATUS_OK;
}
/****************************************************************
static NTSTATUS discover_dc_dns(TALLOC_CTX *mem_ctx,
const char *domain_name,
- struct GUID *domain_guid,
+ const struct GUID *domain_guid,
uint32_t flags,
const char *site_name,
struct ip_service_name **returned_dclist,
struct dns_rr_srv *dcs = NULL;
int numdcs = 0;
int numaddrs = 0;
-
- if ((!(flags & DS_DIRECTORY_SERVICE_REQUIRED)) &&
- (!(flags & DS_KDC_REQUIRED)) &&
- (!(flags & DS_GC_SERVER_REQUIRED)) &&
- (!(flags & DS_PDC_REQUIRED))) {
- DEBUG(1,("discover_dc_dns: invalid flags\n"));
- return NT_STATUS_INVALID_PARAMETER;
- }
+ struct ip_service_name *dclist = NULL;
+ int count = 0;
if (flags & DS_PDC_REQUIRED) {
status = ads_dns_query_pdc(mem_ctx, domain_name,
status = ads_dns_query_dcs_guid(mem_ctx, domain_name,
domain_guid, &dcs, &numdcs);
} else {
- /* FIXME: ? */
- DEBUG(1,("discover_dc_dns: not enough input\n"));
- status = NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND;
+ status = ads_dns_query_dcs(mem_ctx, domain_name, site_name,
+ &dcs, &numdcs);
}
if (!NT_STATUS_IS_OK(status)) {
numaddrs += MAX(dcs[i].num_ips,1);
}
- if ((*returned_dclist = TALLOC_ZERO_ARRAY(mem_ctx,
- struct ip_service_name,
- numaddrs)) == NULL) {
+ dclist = TALLOC_ZERO_ARRAY(mem_ctx,
+ struct ip_service_name,
+ numaddrs);
+ if (!dclist) {
return NT_STATUS_NO_MEMORY;
}
*return_count = 0;
i = 0;
j = 0;
- while (i < numdcs && (*return_count<numaddrs)) {
- struct ip_service_name *r = &(*returned_dclist)[*return_count];
+ while ((i < numdcs) && (count < numaddrs)) {
+
+ struct ip_service_name *r = &dclist[count];
r->port = dcs[i].port;
r->hostname = dcs[i].hostname;
- if (!(flags & DS_IP_REQUIRED)) {
- (*return_count)++;
- continue;
- }
-
/* 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);
+ interpret_string_addr_prefer_ipv4(&r->ss,
+ dcs[i].hostname, 0);
i++;
j = 0;
} else {
* back to netbios lookups is that our DNS server doesn't know
* anything about the DC's -- jerry */
- if (!is_zero_addr(&r->ss)) {
- (*return_count)++;
+ if (!is_zero_addr((struct sockaddr *)(void *)&r->ss)) {
+ count++;
continue;
}
}
- return (*return_count > 0) ? NT_STATUS_OK :
- NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND;
+ *returned_dclist = dclist;
+ *return_count = count;
+
+ if (count > 0) {
+ return NT_STATUS_OK;
+ }
+
+ return NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND;
}
/****************************************************************
}
if (dc_address) {
- info->dc_address = talloc_strdup(mem_ctx, dc_address);
+ if (!(dc_address[0] == '\\' && dc_address[1] == '\\')) {
+ info->dc_address = talloc_asprintf(mem_ctx, "\\\\%s",
+ dc_address);
+ } else {
+ info->dc_address = talloc_strdup(mem_ctx, dc_address);
+ }
NT_STATUS_HAVE_NO_MEMORY(info->dc_address);
}
NT_STATUS_HAVE_NO_MEMORY(info->domain_name);
}
- if (forest_name) {
+ if (forest_name && *forest_name) {
info->forest_name = talloc_strdup(mem_ctx, forest_name);
NT_STATUS_HAVE_NO_MEMORY(info->forest_name);
+ flags |= DS_DNS_FOREST_ROOT;
}
info->dc_flags = flags;
/****************************************************************
****************************************************************/
+static void map_dc_and_domain_names(uint32_t flags,
+ const char *dc_name,
+ const char *domain_name,
+ const char *dns_dc_name,
+ const char *dns_domain_name,
+ uint32_t *dc_flags,
+ const char **hostname_p,
+ const char **domain_p)
+{
+ switch (flags & 0xf0000000) {
+ case DS_RETURN_FLAT_NAME:
+ if (dc_name && domain_name &&
+ *dc_name && *domain_name) {
+ *hostname_p = dc_name;
+ *domain_p = domain_name;
+ break;
+ }
+ case DS_RETURN_DNS_NAME:
+ default:
+ if (dns_dc_name && dns_domain_name &&
+ *dns_dc_name && *dns_domain_name) {
+ *hostname_p = dns_dc_name;
+ *domain_p = dns_domain_name;
+ *dc_flags |= DS_DNS_DOMAIN | DS_DNS_CONTROLLER;
+ break;
+ }
+ if (dc_name && domain_name &&
+ *dc_name && *domain_name) {
+ *hostname_p = dc_name;
+ *domain_p = domain_name;
+ break;
+ }
+ }
+}
+
+/****************************************************************
+****************************************************************/
+
+static NTSTATUS make_dc_info_from_cldap_reply(TALLOC_CTX *mem_ctx,
+ uint32_t flags,
+ struct sockaddr_storage *ss,
+ struct NETLOGON_SAM_LOGON_RESPONSE_EX *r,
+ struct netr_DsRGetDCNameInfo **info)
+{
+ const char *dc_hostname = NULL;
+ const char *dc_domain_name = NULL;
+ const char *dc_address = NULL;
+ const char *dc_forest = NULL;
+ uint32_t dc_address_type = 0;
+ uint32_t dc_flags = 0;
+ struct GUID *dc_domain_guid = NULL;
+ const char *dc_server_site = NULL;
+ const char *dc_client_site = NULL;
+
+ char addr[INET6_ADDRSTRLEN];
+
+ if (ss) {
+ print_sockaddr(addr, sizeof(addr), ss);
+ dc_address = addr;
+ dc_address_type = DS_ADDRESS_TYPE_INET;
+ }
+
+ if (!ss && r->sockaddr.pdc_ip) {
+ dc_address = r->sockaddr.pdc_ip;
+ dc_address_type = DS_ADDRESS_TYPE_INET;
+ } else {
+ dc_address = r->pdc_name;
+ dc_address_type = DS_ADDRESS_TYPE_NETBIOS;
+ }
+
+ map_dc_and_domain_names(flags,
+ r->pdc_name,
+ r->domain_name,
+ r->pdc_dns_name,
+ r->dns_domain,
+ &dc_flags,
+ &dc_hostname,
+ &dc_domain_name);
+
+ dc_flags |= r->server_type;
+ dc_forest = r->forest;
+ dc_domain_guid = &r->domain_uuid;
+ dc_server_site = r->server_site;
+ dc_client_site = r->client_site;
+
+ return make_domain_controller_info(mem_ctx,
+ dc_hostname,
+ dc_address,
+ dc_address_type,
+ dc_domain_guid,
+ dc_domain_name,
+ dc_forest,
+ dc_flags,
+ dc_server_site,
+ dc_client_site,
+ info);
+}
+
+/****************************************************************
+****************************************************************/
+
+static uint32_t map_ds_flags_to_nt_version(uint32_t flags)
+{
+ uint32_t nt_version = 0;
+
+ if (flags & DS_PDC_REQUIRED) {
+ nt_version |= NETLOGON_NT_VERSION_PDC;
+ }
+
+ if (flags & DS_GC_SERVER_REQUIRED) {
+ nt_version |= NETLOGON_NT_VERSION_GC;
+ }
+
+ if (flags & DS_TRY_NEXTCLOSEST_SITE) {
+ nt_version |= NETLOGON_NT_VERSION_WITH_CLOSEST_SITE;
+ }
+
+ if (flags & DS_IP_REQUIRED) {
+ nt_version |= NETLOGON_NT_VERSION_IP;
+ }
+
+ return nt_version;
+}
+
+/****************************************************************
+****************************************************************/
+
static NTSTATUS process_dc_dns(TALLOC_CTX *mem_ctx,
const char *domain_name,
uint32_t flags,
- struct ip_service_name **dclist,
+ struct ip_service_name *dclist,
int num_dcs,
struct netr_DsRGetDCNameInfo **info)
{
int i = 0;
bool valid_dc = false;
- struct cldap_netlogon_reply r;
- const char *dc_hostname, *dc_domain_name;
- const char *dc_address;
- uint32_t dc_address_type;
- uint32_t dc_flags;
- struct GUID dc_guid;
+ struct netlogon_samlogon_response *r = NULL;
+ uint32_t nt_version = NETLOGON_NT_VERSION_5 |
+ NETLOGON_NT_VERSION_5EX;
+ uint32_t ret_flags = 0;
+ NTSTATUS status;
+
+ nt_version |= map_ds_flags_to_nt_version(flags);
for (i=0; i<num_dcs; i++) {
- ZERO_STRUCT(r);
+ DEBUG(10,("LDAP ping to %s\n", dclist[i].hostname));
- if ((ads_cldap_netlogon(dclist[i]->hostname,
- domain_name, &r)) &&
- (check_cldap_reply_required_flags(r.flags, flags))) {
- valid_dc = true;
- break;
+ if (ads_cldap_netlogon(mem_ctx, dclist[i].hostname,
+ domain_name,
+ nt_version,
+ &r))
+ {
+ nt_version = r->ntver;
+ ret_flags = get_cldap_reply_server_flags(r, nt_version);
+
+ if (check_cldap_reply_required_flags(ret_flags, flags)) {
+ valid_dc = true;
+ break;
+ }
}
continue;
return NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND;
}
- dc_flags = r.flags;
-
- if (flags & DS_RETURN_FLAT_NAME) {
- if (!strlen(r.netbios_hostname) || !strlen(r.netbios_domain)) {
- return NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND;
- }
- dc_hostname = r.netbios_hostname;
- dc_domain_name = r.netbios_domain;
- } else if (flags & DS_RETURN_DNS_NAME) {
- if (!strlen(r.hostname) || !strlen(r.domain)) {
- return NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND;
- }
- dc_hostname = r.hostname;
- dc_domain_name = r.domain;
- dc_flags |= DS_DNS_DOMAIN | DS_DNS_CONTROLLER;
- } else {
- /* FIXME */
- dc_hostname = r.hostname;
- dc_domain_name = r.domain;
- dc_flags |= DS_DNS_DOMAIN | DS_DNS_CONTROLLER;
- }
-
- if (flags & DS_IP_REQUIRED) {
- char addr[INET6_ADDRSTRLEN];
- print_sockaddr(addr, sizeof(addr), &dclist[i]->ss);
- dc_address = talloc_asprintf(mem_ctx, "\\\\%s",
- addr);
- dc_address_type = DS_ADDRESS_TYPE_INET;
- } else {
- dc_address = talloc_asprintf(mem_ctx, "\\\\%s",
- r.netbios_hostname);
- dc_address_type = DS_ADDRESS_TYPE_NETBIOS;
- }
- NT_STATUS_HAVE_NO_MEMORY(dc_address);
- smb_uuid_unpack(r.guid, &dc_guid);
-
- if (r.forest) {
- dc_flags |= DS_DNS_FOREST;
+ status = make_dc_info_from_cldap_reply(mem_ctx, flags, &dclist[i].ss,
+ &r->data.nt5_ex, info);
+ if (NT_STATUS_IS_OK(status)) {
+ return store_cldap_reply(mem_ctx, flags, &dclist[i].ss,
+ nt_version, &r->data.nt5_ex);
}
- return make_domain_controller_info(mem_ctx,
- dc_hostname,
- dc_address,
- dc_address_type,
- &dc_guid,
- dc_domain_name,
- r.forest,
- dc_flags,
- r.server_site_name,
- r.client_site_name,
- info);
-
+ return status;
}
/****************************************************************
****************************************************************/
+/****************************************************************
+****************************************************************/
+
static NTSTATUS process_dc_netbios(TALLOC_CTX *mem_ctx,
+ struct messaging_context *msg_ctx,
const char *domain_name,
uint32_t flags,
- struct ip_service_name **dclist,
+ struct ip_service_name *dclist,
int num_dcs,
struct netr_DsRGetDCNameInfo **info)
{
- /* FIXME: code here */
+ struct sockaddr_storage ss;
+ struct ip_service ip_list;
+ enum nbt_name_type name_type = NBT_NAME_LOGON;
+ NTSTATUS status;
+ int i;
+ const char *dc_name = NULL;
+ fstring tmp_dc_name;
+ struct netlogon_samlogon_response *r = NULL;
+ bool store_cache = false;
+ uint32_t nt_version = NETLOGON_NT_VERSION_1 |
+ NETLOGON_NT_VERSION_5 |
+ NETLOGON_NT_VERSION_5EX_WITH_IP;
+
+ if (msg_ctx == NULL) {
+ return NT_STATUS_INVALID_PARAMETER;
+ }
+
+ if (flags & DS_PDC_REQUIRED) {
+ name_type = NBT_NAME_PDC;
+ }
+
+ nt_version |= map_ds_flags_to_nt_version(flags);
+
+ DEBUG(10,("process_dc_netbios\n"));
+
+ for (i=0; i<num_dcs; i++) {
+ uint16_t val;
+ int dgm_id;
- return NT_STATUS_NOT_SUPPORTED;
+ generate_random_buffer((uint8_t *)&val, 2);
+ dgm_id = val;
+
+ ip_list.ss = dclist[i].ss;
+ ip_list.port = 0;
+
+ if (!interpret_string_addr_prefer_ipv4(&ss, dclist[i].hostname, AI_NUMERICHOST)) {
+ return NT_STATUS_UNSUCCESSFUL;
+ }
+
+ if (send_getdc_request(msg_ctx,
+ &dclist[i].ss, domain_name,
+ NULL, nt_version, dgm_id))
+ {
+ int k;
+ smb_msleep(300);
+ for (k=0; k<5; k++) {
+ if (receive_getdc_response(mem_ctx,
+ &dclist[i].ss,
+ domain_name,
+ dgm_id,
+ &nt_version,
+ &dc_name,
+ &r)) {
+ store_cache = true;
+ namecache_store(dc_name, NBT_NAME_SERVER, 1, &ip_list);
+ goto make_reply;
+ }
+ smb_msleep(1500);
+ }
+ }
+
+ if (name_status_find(domain_name,
+ name_type,
+ NBT_NAME_SERVER,
+ &dclist[i].ss,
+ tmp_dc_name))
+ {
+ struct NETLOGON_SAM_LOGON_RESPONSE_NT40 logon1;
+
+ r = TALLOC_ZERO_P(mem_ctx, struct netlogon_samlogon_response);
+ NT_STATUS_HAVE_NO_MEMORY(r);
+
+ ZERO_STRUCT(logon1);
+
+ nt_version = NETLOGON_NT_VERSION_1;
+
+ logon1.nt_version = nt_version;
+ logon1.pdc_name = tmp_dc_name;
+ logon1.domain_name = talloc_strdup_upper(mem_ctx, domain_name);
+ NT_STATUS_HAVE_NO_MEMORY(logon1.domain_name);
+
+ r->data.nt4 = logon1;
+ r->ntver = nt_version;
+
+ map_netlogon_samlogon_response(r);
+
+ namecache_store(tmp_dc_name, NBT_NAME_SERVER, 1, &ip_list);
+
+ goto make_reply;
+ }
+ }
+
+ return NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND;
+
+ make_reply:
+
+ status = make_dc_info_from_cldap_reply(mem_ctx, flags, &dclist[i].ss,
+ &r->data.nt5_ex, info);
+ if (NT_STATUS_IS_OK(status) && store_cache) {
+ return store_cldap_reply(mem_ctx, flags, &dclist[i].ss,
+ nt_version, &r->data.nt5_ex);
+ }
+
+ return status;
}
/****************************************************************
****************************************************************/
static NTSTATUS dsgetdcname_rediscover(TALLOC_CTX *mem_ctx,
+ struct messaging_context *msg_ctx,
const char *domain_name,
- struct GUID *domain_guid,
+ const struct GUID *domain_guid,
uint32_t flags,
const char *site_name,
struct netr_DsRGetDCNameInfo **info)
{
NTSTATUS status = NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND;
- struct ip_service_name *dclist;
+ struct ip_service_name *dclist = NULL;
int num_dcs;
DEBUG(10,("dsgetdcname_rediscover\n"));
&dclist, &num_dcs);
NT_STATUS_NOT_OK_RETURN(status);
- return process_dc_netbios(mem_ctx, domain_name, flags,
- &dclist, num_dcs, info);
+ return process_dc_netbios(mem_ctx, msg_ctx, domain_name, flags,
+ dclist, num_dcs, info);
}
if (flags & DS_IS_DNS_NAME) {
NT_STATUS_NOT_OK_RETURN(status);
return process_dc_dns(mem_ctx, domain_name, flags,
- &dclist, num_dcs, info);
+ dclist, num_dcs, info);
}
status = discover_dc_dns(mem_ctx, domain_name, domain_guid, flags,
if (NT_STATUS_IS_OK(status) && num_dcs != 0) {
- status = process_dc_dns(mem_ctx, domain_name, flags, &dclist,
+ status = process_dc_dns(mem_ctx, domain_name, flags, dclist,
num_dcs, info);
if (NT_STATUS_IS_OK(status)) {
return status;
&num_dcs);
NT_STATUS_NOT_OK_RETURN(status);
- return process_dc_netbios(mem_ctx, domain_name, flags, &dclist,
+ return process_dc_netbios(mem_ctx, msg_ctx, domain_name, flags, dclist,
num_dcs, info);
}
+static bool is_closest_site(struct netr_DsRGetDCNameInfo *info)
+{
+ if (info->dc_flags & DS_SERVER_CLOSEST) {
+ return true;
+ }
+
+ if (!info->client_site_name) {
+ return true;
+ }
+
+ if (!info->dc_site_name) {
+ return false;
+ }
+
+ if (strcmp(info->client_site_name, info->dc_site_name) == 0) {
+ return true;
+ }
+
+ return false;
+}
+
/********************************************************************
dsgetdcname.
********************************************************************/
NTSTATUS dsgetdcname(TALLOC_CTX *mem_ctx,
+ struct messaging_context *msg_ctx,
const char *domain_name,
- struct GUID *domain_guid,
+ const struct GUID *domain_guid,
const char *site_name,
uint32_t flags,
struct netr_DsRGetDCNameInfo **info)
{
NTSTATUS status = NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND;
struct netr_DsRGetDCNameInfo *myinfo = NULL;
+ char *query_site = NULL;
+ bool first = true;
+ struct netr_DsRGetDCNameInfo *first_info = NULL;
DEBUG(10,("dsgetdcname: domain_name: %s, "
"domain_guid: %s, site_name: %s, flags: 0x%08x\n",
*info = NULL;
- if (!check_allowed_required_flags(flags)) {
+ if (!check_allowed_required_flags(flags, site_name)) {
DEBUG(0,("invalid flags specified\n"));
return NT_STATUS_INVALID_PARAMETER;
}
+ if ((site_name == NULL) || (site_name[0] == '\0')) {
+ query_site = sitename_fetch(domain_name);
+ } else {
+ query_site = SMB_STRDUP(site_name);
+ }
+
if (flags & DS_FORCE_REDISCOVERY) {
goto rediscover;
}
- status = dsgetdcname_cached(mem_ctx, domain_name, domain_guid,
- flags, site_name, &myinfo);
+ status = dsgetdcname_cached(mem_ctx, msg_ctx, domain_name, domain_guid,
+ flags, query_site, &myinfo);
if (NT_STATUS_IS_OK(status)) {
- *info = myinfo;
- return status;
+ goto done;
}
if (flags & DS_BACKGROUND_ONLY) {
- return status;
+ goto done;
}
rediscover:
- status = dsgetdcname_rediscover(mem_ctx, domain_name,
- domain_guid, flags, site_name,
+ status = dsgetdcname_rediscover(mem_ctx, msg_ctx, domain_name,
+ domain_guid, flags, query_site,
&myinfo);
- if (NT_STATUS_IS_OK(status)) {
- dsgetdcname_cache_store(mem_ctx, domain_name, myinfo);
- *info = myinfo;
+ done:
+ SAFE_FREE(query_site);
+
+ if (!NT_STATUS_IS_OK(status)) {
+ if (!first) {
+ *info = first_info;
+ return NT_STATUS_OK;
+ }
+ return status;
}
- return status;
+ if (!first) {
+ TALLOC_FREE(first_info);
+ } else if (!is_closest_site(myinfo)) {
+ first = false;
+ first_info = myinfo;
+ /* TODO: may use the next_closest_site here */
+ query_site = SMB_STRDUP(myinfo->client_site_name);
+ goto rediscover;
+ }
+
+ *info = myinfo;
+ return NT_STATUS_OK;
}
git.samba.org / metze / samba / wip.git / blobdiff