source: vendor/3.5.11/source4/libcli/finddcs.c

/* 
   Unix SMB/CIFS implementation.

   a composite API for finding a DC and its name

   Copyright (C) Volker Lendecke 2005
   Copyright (C) Andrew Bartlett <abartlet@samba.org> 2006
   
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.
   
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
   
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "include/includes.h"
#include "lib/messaging/irpc.h"
#include "librpc/gen_ndr/ndr_irpc.h"
#include "librpc/gen_ndr/samr.h"
#include "libcli/composite/composite.h"
#include "libcli/libcli.h"
#include "libcli/resolve/resolve.h"
#include "libcli/finddcs.h"

struct finddcs_state {
        struct composite_context *ctx;
        struct messaging_context *msg_ctx;

        const char *my_netbios_name;
        const char *domain_name;
        struct dom_sid *domain_sid;

        struct nbtd_getdcname r;
        struct nbt_name_status node_status;

        struct smb_iconv_convenience *iconv_convenience;

        int num_dcs;
        struct nbt_dc_name *dcs;
        uint16_t nbt_port;
};

static void finddcs_name_resolved(struct composite_context *ctx);
static void finddcs_getdc_replied(struct irpc_request *ireq);
static void fallback_node_status(struct finddcs_state *state);
static void fallback_node_status_replied(struct nbt_name_request *name_req);

/* 
 * Setup and send off the a normal name resolution for the target name.
 *
 * The domain_sid parameter is optional, and is used in the subsequent getdc request.
 *
 * This will try a GetDC request, but this may not work.  It will try
 * a node status as a fallback, then return no name (but still include
 * the IP)
 */

struct composite_context *finddcs_send(TALLOC_CTX *mem_ctx,
                                       const char *my_netbios_name,
                                       uint16_t nbt_port,
                                       const char *domain_name,
                                       int name_type,
                                       struct dom_sid *domain_sid,
                                       struct smb_iconv_convenience *iconv_convenience,
                                       struct resolve_context *resolve_ctx,
                                       struct tevent_context *event_ctx,
                                       struct messaging_context *msg_ctx)
{
        struct composite_context *c, *creq;
        struct finddcs_state *state;
        struct nbt_name name;

        c = composite_create(mem_ctx, event_ctx);
        if (c == NULL) return NULL;

        state = talloc(c, struct finddcs_state);
        if (composite_nomem(state, c)) return c;
        c->private_data = state;

        state->ctx = c;

        state->nbt_port = nbt_port;
        state->my_netbios_name = talloc_strdup(state, my_netbios_name);
        state->domain_name = talloc_strdup(state, domain_name);
        state->iconv_convenience = iconv_convenience;
        if (composite_nomem(state->domain_name, c)) return c;

        if (domain_sid) {
                state->domain_sid = talloc_reference(state, domain_sid);
                if (composite_nomem(state->domain_sid, c)) return c;
        } else {
                state->domain_sid = NULL;
        }

        state->msg_ctx = msg_ctx;

        make_nbt_name(&name, state->domain_name, name_type);
        creq = resolve_name_send(resolve_ctx, state, &name, event_ctx);
        composite_continue(c, creq, finddcs_name_resolved, state);
        return c;
}

/* Having got an name query answer, fire off a GetDC request, so we
 * can find the target's all-important name.  (Kerberos and some
 * netlogon operations are quite picky about names) 
 *
 * The name is a courtesy, if we don't find it, don't completely fail.
 *
 * However, if the nbt server is down, fall back to a node status
 * request
 */
static void finddcs_name_resolved(struct composite_context *ctx)
{
        struct finddcs_state *state =
                talloc_get_type(ctx->async.private_data, struct finddcs_state);
        struct irpc_request *ireq;
        struct server_id *nbt_servers;
        const char *address;

        state->ctx->status = resolve_name_recv(ctx, state, &address);
        if (!composite_is_ok(state->ctx)) return;

        /* TODO: This should try and find all the DCs, and give the
         * caller them in the order they responded */

        state->num_dcs = 1;
        state->dcs = talloc_array(state, struct nbt_dc_name, state->num_dcs);
        if (composite_nomem(state->dcs, state->ctx)) return;

        state->dcs[0].address = talloc_steal(state->dcs, address);

        /* Try and find the nbt server.  Fallback to a node status
         * request if we can't make this happen The nbt server just
         * might not be running, or we may not have a messaging
         * context (not root etc) */
        if (!state->msg_ctx) {
                fallback_node_status(state);
                return;
        }

        nbt_servers = irpc_servers_byname(state->msg_ctx, state, "nbt_server");
        if ((nbt_servers == NULL) || (nbt_servers[0].id == 0)) {
                fallback_node_status(state);
                return;
        }

        state->r.in.domainname = state->domain_name;
        state->r.in.ip_address = state->dcs[0].address;
        state->r.in.my_computername = state->my_netbios_name;
        state->r.in.my_accountname = talloc_asprintf(state, "%s$", state->my_netbios_name);
        if (composite_nomem(state->r.in.my_accountname, state->ctx)) return;
        state->r.in.account_control = ACB_WSTRUST;
        state->r.in.domain_sid = state->domain_sid;

        ireq = irpc_call_send(state->msg_ctx, nbt_servers[0],
                              &ndr_table_irpc, NDR_NBTD_GETDCNAME,
                              &state->r, state);
        if (!ireq) {
                fallback_node_status(state);
                return;
        }

        composite_continue_irpc(state->ctx, ireq, finddcs_getdc_replied, state);
}

/* Called when the GetDC request returns */
static void finddcs_getdc_replied(struct irpc_request *ireq)
{
        struct finddcs_state *state =
                talloc_get_type(ireq->async.private_data, struct finddcs_state);

        state->ctx->status = irpc_call_recv(ireq);
        if (!composite_is_ok(state->ctx)) return;

        state->dcs[0].name = talloc_steal(state->dcs, state->r.out.dcname);
        composite_done(state->ctx);
}

/* The GetDC request might not be available (such as occours when the
 * NBT server is down).  Fallback to a node status.  It is the best
 * hope we have... */
static void fallback_node_status(struct finddcs_state *state) 
{
        struct nbt_name_socket *nbtsock;
        struct nbt_name_request *name_req;

        state->node_status.in.name.name = "*";
        state->node_status.in.name.type = NBT_NAME_CLIENT;
        state->node_status.in.name.scope = NULL;
        state->node_status.in.dest_addr = state->dcs[0].address;
        state->node_status.in.dest_port = state->nbt_port;
        state->node_status.in.timeout = 1;
        state->node_status.in.retries = 2;

        nbtsock = nbt_name_socket_init(state, state->ctx->event_ctx, 
                                       state->iconv_convenience);
        if (composite_nomem(nbtsock, state->ctx)) return;
        
        name_req = nbt_name_status_send(nbtsock, &state->node_status);
        if (composite_nomem(name_req, state->ctx)) return;

        composite_continue_nbt(state->ctx, 
                               name_req, 
                               fallback_node_status_replied,
                               state);
}

/* We have a node status reply (or perhaps a timeout) */
static void fallback_node_status_replied(struct nbt_name_request *name_req) 
{
        int i;
        struct finddcs_state *state = talloc_get_type(name_req->async.private_data, struct finddcs_state);
        state->ctx->status = nbt_name_status_recv(name_req, state, &state->node_status);
        if (!composite_is_ok(state->ctx)) return;

        for (i=0; i < state->node_status.out.status.num_names; i++) {
                int j;
                if (state->node_status.out.status.names[i].type == NBT_NAME_SERVER) {
                        char *name = talloc_strndup(state->dcs, state->node_status.out.status.names[0].name, 15);
                        /* Strip space padding */
                        if (name) {
                                j = MIN(strlen(name), 15);
                                for (; j > 0 && name[j - 1] == ' '; j--) {
                                        name[j - 1] = '\0';
                                }
                        }
                        state->dcs[0].name = name;
                        composite_done(state->ctx);
                        return;
                }
        }
        composite_error(state->ctx, NT_STATUS_NO_LOGON_SERVERS);
}

NTSTATUS finddcs_recv(struct composite_context *c, TALLOC_CTX *mem_ctx,
                      int *num_dcs, struct nbt_dc_name **dcs)
{
        NTSTATUS status = composite_wait(c);
        if (NT_STATUS_IS_OK(status)) {
                struct finddcs_state *state =
                        talloc_get_type(c->private_data, struct finddcs_state);
                *num_dcs = state->num_dcs;
                *dcs = talloc_steal(mem_ctx, state->dcs);
        }
        talloc_free(c);
        return status;
}

NTSTATUS finddcs(TALLOC_CTX *mem_ctx,
                 const char *my_netbios_name,
                 uint16_t nbt_port,
                 const char *domain_name, int name_type, 
                 struct dom_sid *domain_sid,
                 struct smb_iconv_convenience *iconv_convenience,
                 struct resolve_context *resolve_ctx,
                 struct tevent_context *event_ctx,
                 struct messaging_context *msg_ctx,
                 int *num_dcs, struct nbt_dc_name **dcs)
{
        struct composite_context *c = finddcs_send(mem_ctx,
                                                   my_netbios_name,
                                                   nbt_port,
                                                   domain_name, name_type,
                                                   domain_sid, 
                                                   iconv_convenience,
                                                   resolve_ctx,
                                                   event_ctx, msg_ctx);
        return finddcs_recv(c, mem_ctx, num_dcs, dcs);
}