#include "includes.h"
#include "winbindd.h"
#undef DBGC_CLASS
#define DBGC_CLASS DBGC_WINBIND
extern struct winbindd_methods cache_methods;
extern struct winbindd_methods passdb_methods;
static struct winbindd_domain *_domain_list;
static time_t last_trustdom_scan;
struct winbindd_domain *domain_list(void)
{
if ((!_domain_list) && (!init_domain_list())) {
smb_panic("Init_domain_list failed\n");
}
return _domain_list;
}
void free_domain_list(void)
{
struct winbindd_domain *domain = _domain_list;
while(domain) {
struct winbindd_domain *next = domain->next;
DLIST_REMOVE(_domain_list, domain);
SAFE_FREE(domain);
domain = next;
}
}
static BOOL is_internal_domain(const DOM_SID *sid)
{
if (sid == NULL)
return False;
return (sid_check_is_domain(sid) || sid_check_is_builtin(sid));
}
static BOOL is_in_internal_domain(const DOM_SID *sid)
{
if (sid == NULL)
return False;
return (sid_check_is_in_our_domain(sid) || sid_check_is_in_builtin(sid));
}
static struct winbindd_domain *add_trusted_domain(const char *domain_name, const char *alt_name,
struct winbindd_methods *methods,
const DOM_SID *sid)
{
struct winbindd_domain *domain;
const char *alternative_name = NULL;
if ( alt_name && *alt_name) {
alternative_name = alt_name;
}
for (domain = _domain_list; domain; domain = domain->next) {
if (strequal(domain_name, domain->name) ||
strequal(domain_name, domain->alt_name)) {
return domain;
}
if (alternative_name && *alternative_name) {
if (strequal(alternative_name, domain->name) ||
strequal(alternative_name, domain->alt_name)) {
return domain;
}
}
if (sid) {
if (is_null_sid(sid)) {
} else if (sid_equal(sid, &domain->sid)) {
return domain;
}
}
}
if ((domain = SMB_MALLOC_P(struct winbindd_domain)) == NULL)
return NULL;
ZERO_STRUCTP(domain);
if (strchr_m(domain_name, '.') && alternative_name && *alternative_name) {
fstrcpy(domain->name, alternative_name);
fstrcpy(domain->alt_name, domain_name);
} else {
fstrcpy(domain->name, domain_name);
if (alternative_name) {
fstrcpy(domain->alt_name, alternative_name);
}
}
domain->methods = methods;
domain->backend = NULL;
domain->internal = is_internal_domain(sid);
domain->sequence_number = DOM_SEQUENCE_NONE;
domain->last_seq_check = 0;
domain->initialized = False;
domain->online = is_internal_domain(sid);
domain->check_online_timeout = 0;
if (sid) {
sid_copy(&domain->sid, sid);
}
DLIST_ADD(_domain_list, domain);
DEBUG(2,("Added domain %s %s %s\n",
domain->name, domain->alt_name,
&domain->sid?sid_string_static(&domain->sid):""));
return domain;
}
struct trustdom_state {
TALLOC_CTX *mem_ctx;
struct winbindd_response *response;
};
static void trustdom_recv(void *private_data, BOOL success);
static void add_trusted_domains( struct winbindd_domain *domain )
{
TALLOC_CTX *mem_ctx;
struct winbindd_request *request;
struct winbindd_response *response;
struct trustdom_state *state;
mem_ctx = talloc_init("add_trusted_domains");
if (mem_ctx == NULL) {
DEBUG(0, ("talloc_init failed\n"));
return;
}
request = TALLOC_ZERO_P(mem_ctx, struct winbindd_request);
response = TALLOC_P(mem_ctx, struct winbindd_response);
state = TALLOC_P(mem_ctx, struct trustdom_state);
if ((request == NULL) || (response == NULL) || (state == NULL)) {
DEBUG(0, ("talloc failed\n"));
talloc_destroy(mem_ctx);
return;
}
state->mem_ctx = mem_ctx;
state->response = response;
request->length = sizeof(*request);
request->cmd = WINBINDD_LIST_TRUSTDOM;
async_domain_request(mem_ctx, domain, request, response,
trustdom_recv, state);
}
static void trustdom_recv(void *private_data, BOOL success)
{
struct trustdom_state *state =
talloc_get_type_abort(private_data, struct trustdom_state);
struct winbindd_response *response = state->response;
char *p;
if ((!success) || (response->result != WINBINDD_OK)) {
DEBUG(1, ("Could not receive trustdoms\n"));
talloc_destroy(state->mem_ctx);
return;
}
p = (char *)response->extra_data.data;
while ((p != NULL) && (*p != '\0')) {
char *q, *sidstr, *alt_name;
DOM_SID sid;
alt_name = strchr(p, '\\');
if (alt_name == NULL) {
DEBUG(0, ("Got invalid trustdom response\n"));
break;
}
*alt_name = '\0';
alt_name += 1;
sidstr = strchr(alt_name, '\\');
if (sidstr == NULL) {
DEBUG(0, ("Got invalid trustdom response\n"));
break;
}
*sidstr = '\0';
sidstr += 1;
q = strchr(sidstr, '\n');
if (q != NULL)
*q = '\0';
if (!string_to_sid(&sid, sidstr)) {
if ( strcmp(sidstr,"S-0-0") == 0) {
sid_copy( &sid, &global_sid_NULL);
} else {
DEBUG(0, ("Got invalid trustdom response\n"));
break;
}
}
if (find_domain_from_name_noinit(p) == NULL) {
struct winbindd_domain *domain;
char *alternate_name = NULL;
if ( !strequal( alt_name, "(null)" ) )
alternate_name = alt_name;
domain = add_trusted_domain(p, alternate_name,
&cache_methods,
&sid);
setup_domain_child(domain, &domain->child, NULL);
}
p=q;
if (p != NULL)
p += 1;
}
SAFE_FREE(response->extra_data.data);
talloc_destroy(state->mem_ctx);
}
void rescan_trusted_domains( void )
{
time_t now = time(NULL);
if ((now >= last_trustdom_scan) &&
((now-last_trustdom_scan) < WINBINDD_RESCAN_FREQ) )
return;
add_trusted_domains( find_our_domain() );
last_trustdom_scan = now;
return;
}
struct init_child_state {
TALLOC_CTX *mem_ctx;
struct winbindd_domain *domain;
struct winbindd_request *request;
struct winbindd_response *response;
void (*continuation)(void *private_data, BOOL success);
void *private_data;
};
static void init_child_recv(void *private_data, BOOL success);
static void init_child_getdc_recv(void *private_data, BOOL success);
enum winbindd_result init_child_connection(struct winbindd_domain *domain,
void (*continuation)(void *private_data,
BOOL success),
void *private_data)
{
TALLOC_CTX *mem_ctx;
struct winbindd_request *request;
struct winbindd_response *response;
struct init_child_state *state;
struct winbindd_domain *request_domain;
mem_ctx = talloc_init("init_child_connection");
if (mem_ctx == NULL) {
DEBUG(0, ("talloc_init failed\n"));
return WINBINDD_ERROR;
}
request = TALLOC_ZERO_P(mem_ctx, struct winbindd_request);
response = TALLOC_P(mem_ctx, struct winbindd_response);
state = TALLOC_P(mem_ctx, struct init_child_state);
if ((request == NULL) || (response == NULL) || (state == NULL)) {
DEBUG(0, ("talloc failed\n"));
TALLOC_FREE(mem_ctx);
continuation(private_data, False);
return WINBINDD_ERROR;
}
request->length = sizeof(*request);
state->mem_ctx = mem_ctx;
state->domain = domain;
state->request = request;
state->response = response;
state->continuation = continuation;
state->private_data = private_data;
if (IS_DC || domain->primary) {
request->cmd = WINBINDD_INIT_CONNECTION;
fstrcpy(request->domain_name, domain->name);
request->data.init_conn.is_primary = True;
fstrcpy(request->data.init_conn.dcname, "");
async_request(mem_ctx, &domain->child, request, response,
init_child_recv, state);
return WINBINDD_PENDING;
}
request->cmd = WINBINDD_GETDCNAME;
fstrcpy(request->domain_name, domain->name);
request_domain = find_our_domain();
async_domain_request(mem_ctx, request_domain, request, response,
init_child_getdc_recv, state);
return WINBINDD_PENDING;
}
static void init_child_getdc_recv(void *private_data, BOOL success)
{
struct init_child_state *state =
talloc_get_type_abort(private_data, struct init_child_state);
const char *dcname = "";
DEBUG(10, ("Received getdcname response\n"));
if (success && (state->response->result == WINBINDD_OK)) {
dcname = state->response->data.dc_name;
}
state->request->cmd = WINBINDD_INIT_CONNECTION;
fstrcpy(state->request->domain_name, state->domain->name);
state->request->data.init_conn.is_primary = False;
fstrcpy(state->request->data.init_conn.dcname, dcname);
async_request(state->mem_ctx, &state->domain->child,
state->request, state->response,
init_child_recv, state);
}
static void init_child_recv(void *private_data, BOOL success)
{
struct init_child_state *state =
talloc_get_type_abort(private_data, struct init_child_state);
DEBUG(5, ("Received child initialization response for domain %s\n",
state->domain->name));
if ((!success) || (state->response->result != WINBINDD_OK)) {
DEBUG(3, ("Could not init child\n"));
state->continuation(state->private_data, False);
talloc_destroy(state->mem_ctx);
return;
}
fstrcpy(state->domain->name,
state->response->data.domain_info.name);
fstrcpy(state->domain->alt_name,
state->response->data.domain_info.alt_name);
string_to_sid(&state->domain->sid,
state->response->data.domain_info.sid);
state->domain->native_mode =
state->response->data.domain_info.native_mode;
state->domain->active_directory =
state->response->data.domain_info.active_directory;
state->domain->sequence_number =
state->response->data.domain_info.sequence_number;
init_dc_connection(state->domain);
if (state->continuation != NULL)
state->continuation(state->private_data, True);
talloc_destroy(state->mem_ctx);
}
enum winbindd_result winbindd_dual_init_connection(struct winbindd_domain *domain,
struct winbindd_cli_state *state)
{
state->request.domain_name
[sizeof(state->request.domain_name)-1]='\0';
state->request.data.init_conn.dcname
[sizeof(state->request.data.init_conn.dcname)-1]='\0';
if (strlen(state->request.data.init_conn.dcname) > 0) {
fstrcpy(domain->dcname, state->request.data.init_conn.dcname);
}
init_dc_connection(domain);
if (!domain->initialized) {
DEBUG(5, ("winbindd_dual_init_connection: %s returning without initialization "
"online = %d\n", domain->name, (int)domain->online ));
}
fstrcpy(state->response.data.domain_info.name, domain->name);
fstrcpy(state->response.data.domain_info.alt_name, domain->alt_name);
fstrcpy(state->response.data.domain_info.sid,
sid_string_static(&domain->sid));
state->response.data.domain_info.native_mode
= domain->native_mode;
state->response.data.domain_info.active_directory
= domain->active_directory;
state->response.data.domain_info.primary
= domain->primary;
state->response.data.domain_info.sequence_number =
domain->sequence_number;
return WINBINDD_OK;
}
BOOL init_domain_list(void)
{
struct winbindd_domain *domain;
int role = lp_server_role();
free_domain_list();
if ( role == ROLE_DOMAIN_MEMBER ) {
DOM_SID our_sid;
if (!secrets_fetch_domain_sid(lp_workgroup(), &our_sid)) {
DEBUG(0, ("Could not fetch our SID - did we join?\n"));
return False;
}
domain = add_trusted_domain( lp_workgroup(), lp_realm(),
&cache_methods, &our_sid);
domain->primary = True;
setup_domain_child(domain, &domain->child, NULL);
set_domain_online_request(domain);
}
domain = add_trusted_domain(get_global_sam_name(), lp_realm(),
&passdb_methods, get_global_sam_sid());
if ( role != ROLE_DOMAIN_MEMBER ) {
domain->primary = True;
}
setup_domain_child(domain, &domain->child, NULL);
domain = add_trusted_domain("BUILTIN", NULL, &passdb_methods,
&global_sid_Builtin);
setup_domain_child(domain, &domain->child, NULL);
return True;
}
struct winbindd_domain *find_domain_from_name_noinit(const char *domain_name)
{
struct winbindd_domain *domain;
for (domain = domain_list(); domain != NULL; domain = domain->next) {
if (strequal(domain_name, domain->name) ||
(domain->alt_name[0] &&
strequal(domain_name, domain->alt_name))) {
return domain;
}
}
return NULL;
}
struct winbindd_domain *find_domain_from_name(const char *domain_name)
{
struct winbindd_domain *domain;
domain = find_domain_from_name_noinit(domain_name);
if (domain == NULL)
return NULL;
if (!domain->initialized)
init_dc_connection(domain);
return domain;
}
struct winbindd_domain *find_domain_from_sid_noinit(const DOM_SID *sid)
{
struct winbindd_domain *domain;
uint32_t discard;
for (domain = domain_list(); domain != NULL; domain = domain->next) {
if (sid_peek_check_rid(&domain->sid, sid, &discard) == 0) {
return domain;
}
}
return NULL;
}
struct winbindd_domain *find_domain_from_sid(const DOM_SID *sid)
{
struct winbindd_domain *domain;
domain = find_domain_from_sid_noinit(sid);
if (domain == NULL)
return NULL;
if (!domain->initialized)
init_dc_connection(domain);
return domain;
}
struct winbindd_domain *find_our_domain(void)
{
struct winbindd_domain *domain;
for (domain = domain_list(); domain != NULL; domain = domain->next) {
if (domain->primary)
return domain;
}
smb_panic("Could not find our domain\n");
return NULL;
}
struct winbindd_domain *find_root_domain(void)
{
struct winbindd_domain *ours = find_our_domain();
if ( !ours )
return NULL;
if ( strlen(ours->forest_name) == 0 )
return NULL;
return find_domain_from_name( ours->forest_name );
}
struct winbindd_domain *find_builtin_domain(void)
{
DOM_SID sid;
struct winbindd_domain *domain;
string_to_sid(&sid, "S-1-5-32");
domain = find_domain_from_sid(&sid);
if (domain == NULL)
smb_panic("Could not find BUILTIN domain\n");
return domain;
}
struct winbindd_domain *find_lookup_domain_from_sid(const DOM_SID *sid)
{
DEBUG(10, ("find_lookup_domain_from_sid(%s)\n",
sid_string_static(sid)));
if (IS_DC || is_internal_domain(sid) || is_in_internal_domain(sid)) {
DEBUG(10, ("calling find_domain_from_sid\n"));
return find_domain_from_sid(sid);
}
DEBUG(10, ("calling find_our_domain\n"));
return find_our_domain();
}
struct winbindd_domain *find_lookup_domain_from_name(const char *domain_name)
{
if (IS_DC || strequal(domain_name, "BUILTIN") ||
strequal(domain_name, get_global_sam_name()))
return find_domain_from_name_noinit(domain_name);
return find_our_domain();
}
BOOL winbindd_lookup_sid_by_name(TALLOC_CTX *mem_ctx,
struct winbindd_domain *domain,
const char *domain_name,
const char *name, DOM_SID *sid,
enum lsa_SidType *type)
{
NTSTATUS result;
result = domain->methods->name_to_sid(domain, mem_ctx, domain_name, name, sid, type);
if (!NT_STATUS_IS_OK(result)) {
*type = SID_NAME_UNKNOWN;
}
return NT_STATUS_IS_OK(result);
}
BOOL winbindd_lookup_name_by_sid(TALLOC_CTX *mem_ctx,
DOM_SID *sid,
char **dom_name,
char **name,
enum lsa_SidType *type)
{
NTSTATUS result;
struct winbindd_domain *domain;
*dom_name = NULL;
*name = NULL;
domain = find_lookup_domain_from_sid(sid);
if (!domain) {
DEBUG(1,("Can't find domain from sid\n"));
return False;
}
result = domain->methods->sid_to_name(domain, mem_ctx, sid, dom_name, name, type);
if (NT_STATUS_IS_OK(result)) {
return True;
}
*type = SID_NAME_UNKNOWN;
return False;
}
void free_getent_state(struct getent_state *state)
{
struct getent_state *temp;
temp = state;
while(temp != NULL) {
struct getent_state *next;
SAFE_FREE(state->sam_entries);
DLIST_REMOVE(state, state);
next = temp->next;
SAFE_FREE(temp);
temp = next;
}
}
static BOOL assume_domain(const char *domain)
{
if ( lp_server_role() == ROLE_STANDALONE )
return False;
if ( lp_server_role() == ROLE_DOMAIN_MEMBER ) {
if ( !strequal(lp_workgroup(), domain) )
return False;
if ( lp_winbind_use_default_domain() || lp_winbind_trusted_domains_only() )
return True;
}
if ( strequal(get_global_sam_name(), domain) ) {
return True;
}
return False;
}
BOOL parse_domain_user(const char *domuser, fstring domain, fstring user)
{
char *p = strchr(domuser,*lp_winbind_separator());
if ( !p ) {
fstrcpy(user, domuser);
if ( assume_domain(lp_workgroup())) {
fstrcpy(domain, lp_workgroup());
} else {
return False;
}
} else {
fstrcpy(user, p+1);
fstrcpy(domain, domuser);
domain[PTR_DIFF(p, domuser)] = 0;
}
strupper_m(domain);
return True;
}
BOOL parse_domain_user_talloc(TALLOC_CTX *mem_ctx, const char *domuser,
char **domain, char **user)
{
fstring fstr_domain, fstr_user;
if (!parse_domain_user(domuser, fstr_domain, fstr_user)) {
return False;
}
*domain = talloc_strdup(mem_ctx, fstr_domain);
*user = talloc_strdup(mem_ctx, fstr_user);
return ((*domain != NULL) && (*user != NULL));
}
BOOL canonicalize_username(fstring username_inout, fstring domain, fstring user)
{
if (!parse_domain_user(username_inout, domain, user)) {
return False;
}
slprintf(username_inout, sizeof(fstring) - 1, "%s%c%s",
domain, *lp_winbind_separator(),
user);
return True;
}
void fill_domain_username(fstring name, const char *domain, const char *user, BOOL can_assume)
{
fstring tmp_user;
fstrcpy(tmp_user, user);
strlower_m(tmp_user);
if (can_assume && assume_domain(domain)) {
strlcpy(name, tmp_user, sizeof(fstring));
} else {
slprintf(name, sizeof(fstring) - 1, "%s%c%s",
domain, *lp_winbind_separator(),
tmp_user);
}
}
char *get_winbind_priv_pipe_dir(void)
{
return lock_path(WINBINDD_PRIV_SOCKET_SUBDIR);
}
static struct winbindd_cli_state *_client_list;
static int _num_clients;
struct winbindd_cli_state *winbindd_client_list(void)
{
return _client_list;
}
void winbindd_add_client(struct winbindd_cli_state *cli)
{
DLIST_ADD(_client_list, cli);
_num_clients++;
}
void winbindd_remove_client(struct winbindd_cli_state *cli)
{
DLIST_REMOVE(_client_list, cli);
_num_clients--;
}
void winbindd_kill_all_clients(void)
{
struct winbindd_cli_state *cl = winbindd_client_list();
DEBUG(10, ("winbindd_kill_all_clients: going postal\n"));
while (cl) {
struct winbindd_cli_state *next;
next = cl->next;
winbindd_remove_client(cl);
cl = next;
}
}
int winbindd_num_clients(void)
{
return _num_clients;
}
NTSTATUS lookup_usergroups_cached(struct winbindd_domain *domain,
TALLOC_CTX *mem_ctx,
const DOM_SID *user_sid,
uint32 *p_num_groups, DOM_SID **user_sids)
{
NET_USER_INFO_3 *info3 = NULL;
NTSTATUS status = NT_STATUS_NO_MEMORY;
int i;
size_t num_groups = 0;
DOM_SID group_sid, primary_group;
DEBUG(3,(": lookup_usergroups_cached\n"));
*user_sids = NULL;
num_groups = 0;
*p_num_groups = 0;
info3 = netsamlogon_cache_get(mem_ctx, user_sid);
if (info3 == NULL) {
return NT_STATUS_OBJECT_NAME_NOT_FOUND;
}
if (info3->num_groups == 0) {
TALLOC_FREE(info3);
return NT_STATUS_UNSUCCESSFUL;
}
sid_compose(&primary_group, &info3->dom_sid.sid, info3->user_rid);
if (!add_sid_to_array(mem_ctx, &primary_group, user_sids, &num_groups)) {
TALLOC_FREE(info3);
return NT_STATUS_NO_MEMORY;
}
for (i=0; i<info3->num_groups; i++) {
sid_copy(&group_sid, &info3->dom_sid.sid);
sid_append_rid(&group_sid, info3->gids[i].g_rid);
if (!add_sid_to_array(mem_ctx, &group_sid, user_sids,
&num_groups)) {
TALLOC_FREE(info3);
return NT_STATUS_NO_MEMORY;
}
}
TALLOC_FREE(info3);
*p_num_groups = num_groups;
status = (user_sids != NULL) ? NT_STATUS_OK : NT_STATUS_NO_MEMORY;
DEBUG(3,(": lookup_usergroups_cached succeeded\n"));
return status;
}
void ws_name_replace( char *name, char replace )
{
char replace_char[2] = { 0x0, 0x0 };
if ( !lp_winbind_normalize_names() || (replace == '\0') )
return;
replace_char[0] = replace;
all_string_sub( name, " ", replace_char, 0 );
return;
}
void ws_name_return( char *name, char replace )
{
char replace_char[2] = { 0x0, 0x0 };
if ( !lp_winbind_normalize_names() || (replace == '\0') )
return;
replace_char[0] = replace;
all_string_sub( name, replace_char, " ", 0 );
return;
}