WERROR NetJoinDomain_r(struct libnetapi_ctx *ctx,
struct NetJoinDomain *r)
{
struct cli_state *cli = NULL;
struct rpc_pipe_client *pipe_cli = NULL;
struct wkssvc_PasswordBuffer *encrypted_password = NULL;
NTSTATUS status;
WERROR werr;
unsigned int old_timeout = 0;
werr = libnetapi_open_pipe(ctx, r->in.server,
&ndr_table_wkssvc.syntax_id,
&cli,
&pipe_cli);
if (!W_ERROR_IS_OK(werr)) {
goto done;
}
if (r->in.password) {
encode_wkssvc_join_password_buffer(ctx,
r->in.password,
&cli->user_session_key,
&encrypted_password);
}
old_timeout = cli_set_timeout(cli, 600000);
status = rpccli_wkssvc_NetrJoinDomain2(pipe_cli, ctx,
r->in.server,
r->in.domain,
r->in.account_ou,
r->in.account,
encrypted_password,
r->in.join_flags,
&werr);
if (!NT_STATUS_IS_OK(status)) {
werr = ntstatus_to_werror(status);
goto done;
}
done:
if (cli) {
if (old_timeout) {
cli_set_timeout(cli, old_timeout);
}
}
return werr;
}
static WERROR cracknames(struct rpc_pipe_client *cli,
TALLOC_CTX *mem_ctx,
struct policy_handle *bind_handle,
enum drsuapi_DsNameFormat format_offered,
enum drsuapi_DsNameFormat format_desired,
int argc,
const char **argv,
union drsuapi_DsNameCtr *ctr)
{
NTSTATUS status;
WERROR werr;
int i;
int32_t level = 1;
union drsuapi_DsNameRequest req;
int32_t level_out;
struct drsuapi_DsNameString *names;
names = TALLOC_ZERO_ARRAY(mem_ctx, struct drsuapi_DsNameString, argc);
W_ERROR_HAVE_NO_MEMORY(names);
for (i=0; i<argc; i++) {
names[i].str = argv[i];
}
req.req1.codepage = 1252; /* german */
req.req1.language = 0x00000407; /* german */
req.req1.count = argc;
req.req1.names = names;
req.req1.format_flags = DRSUAPI_DS_NAME_FLAG_NO_FLAGS;
req.req1.format_offered = format_offered;
req.req1.format_desired = format_desired;
status = rpccli_drsuapi_DsCrackNames(cli, mem_ctx,
bind_handle,
level,
&req,
&level_out,
ctr,
&werr);
if (!NT_STATUS_IS_OK(status)) {
return ntstatus_to_werror(status);
}
if (!W_ERROR_IS_OK(werr)) {
return werr;
}
return WERR_OK;
}
static WERROR cmd_netlogon_dsr_enumtrustdom(struct rpc_pipe_client *cli,
TALLOC_CTX *mem_ctx, int argc,
const char **argv)
{
NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
WERROR werr = WERR_GEN_FAILURE;
const char *server_name = cli->desthost;
uint32_t trust_flags = NETR_TRUST_FLAG_IN_FOREST;
struct netr_DomainTrustList trusts;
struct dcerpc_binding_handle *b = cli->binding_handle;
if (argc < 1 || argc > 3) {
fprintf(stderr, "Usage: %s <server_name> <trust_flags>\n",
argv[0]);
return WERR_OK;
}
if (argc >= 2) {
server_name = argv[1];
}
if (argc >= 3) {
sscanf(argv[2], "%x", &trust_flags);
}
status = dcerpc_netr_DsrEnumerateDomainTrusts(b, mem_ctx,
server_name,
trust_flags,
&trusts,
&werr);
if (!NT_STATUS_IS_OK(status)) {
werr = ntstatus_to_werror(status);
goto done;
}
if (W_ERROR_IS_OK(werr)) {
int i;
printf("%d domains returned\n", trusts.count);
for (i=0; i<trusts.count; i++ ) {
printf("%s (%s)\n",
trusts.array[i].dns_name,
trusts.array[i].netbios_name);
}
}
done:
return werr;
}
static WERROR cmd_ntsvcs_get_dev_list(struct rpc_pipe_client *cli,
TALLOC_CTX *mem_ctx,
int argc,
const char **argv)
{
struct dcerpc_binding_handle *b = cli->binding_handle;
NTSTATUS status;
WERROR werr;
const char *filter = NULL;
uint16_t *buffer = NULL;
uint32_t length = 0;
uint32_t flags = 0;
if (argc > 4) {
printf("usage: %s [filter] [length] [flags]\n", argv[0]);
return WERR_OK;
}
if (argc >= 2) {
filter = argv[1];
}
if (argc >= 3) {
length = atoi(argv[2]);
}
if (argc >= 4) {
flags = atoi(argv[3]);
}
buffer = talloc(mem_ctx, uint16_t);
if (!buffer) {
return WERR_NOT_ENOUGH_MEMORY;
}
status = dcerpc_PNP_GetDeviceList(b, mem_ctx,
filter,
buffer,
&length,
flags,
&werr);
if (!NT_STATUS_IS_OK(status)) {
return ntstatus_to_werror(status);
}
printf("devlist needs size: %d\n", length);
return werr;
}
static WERROR regdb_trans_do(struct db_context *db,
NTSTATUS (*action)(struct db_context *, void *),
void *private_data)
{
NTSTATUS status;
struct regdb_trans_ctx ctx;
ctx.action = action;
ctx.private_data = private_data;
status = dbwrap_trans_do(db, regdb_trans_do_action, &ctx);
return ntstatus_to_werror(status);
}
/**
* initialize the registry smbconf backend
*/
static sbcErr smbconf_reg_init(struct smbconf_ctx *ctx, const char *path)
{
WERROR werr = WERR_OK;
sbcErr err;
struct security_token *token;
if (path == NULL) {
path = KEY_SMBCONF;
}
ctx->path = talloc_strdup(ctx, path);
if (ctx->path == NULL) {
err = SBC_ERR_NOMEM;
goto done;
}
ctx->data = talloc_zero(ctx, struct reg_private_data);
werr = ntstatus_to_werror(registry_create_admin_token(ctx, &token));
if (!W_ERROR_IS_OK(werr)) {
DEBUG(1, ("Error creating admin token\n"));
err = SBC_ERR_UNKNOWN_FAILURE;
goto done;
}
rpd(ctx)->open = false;
werr = registry_init_smbconf(path);
if (!W_ERROR_IS_OK(werr)) {
err = SBC_ERR_BADFILE;
goto done;
}
err = ctx->ops->open_conf(ctx);
if (!SBC_ERROR_IS_OK(err)) {
DEBUG(1, ("Error opening the registry.\n"));
goto done;
}
werr = reg_open_path(ctx, ctx->path,
KEY_ENUMERATE_SUB_KEYS | REG_KEY_WRITE,
token, &rpd(ctx)->base_key);
if (!W_ERROR_IS_OK(werr)) {
err = SBC_ERR_UNKNOWN_FAILURE;
goto done;
}
done:
return err;
}
static WERROR cmd_netlogon_logon_ctrl(struct rpc_pipe_client *cli,
TALLOC_CTX *mem_ctx, int argc,
const char **argv)
{
NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
WERROR werr;
const char *logon_server = cli->desthost;
enum netr_LogonControlCode function_code = 1;
uint32_t level = 1;
union netr_CONTROL_QUERY_INFORMATION info;
struct dcerpc_binding_handle *b = cli->binding_handle;
if (argc > 4) {
fprintf(stderr, "Usage: %s <logon_server> <function_code> "
"<level>\n", argv[0]);
return WERR_OK;
}
if (argc >= 2) {
logon_server = argv[1];
}
if (argc >= 3) {
function_code = atoi(argv[2]);
}
if (argc >= 4) {
level = atoi(argv[3]);
}
status = dcerpc_netr_LogonControl(b, mem_ctx,
logon_server,
function_code,
level,
&info,
&werr);
if (!NT_STATUS_IS_OK(status)) {
return ntstatus_to_werror(status);
}
if (!W_ERROR_IS_OK(werr)) {
return werr;
}
/* Display results */
return werr;
}
static WERROR cmd_wkssvc_enumerateusers(struct rpc_pipe_client *cli,
TALLOC_CTX *mem_ctx,
int argc,
const char **argv)
{
const char *server_name;
NTSTATUS status;
struct wkssvc_NetWkstaEnumUsersInfo info;
WERROR werr;
uint32_t i, num_entries, resume_handle;
struct dcerpc_binding_handle *b = cli->binding_handle;
server_name = cli->desthost;
ZERO_STRUCT(info);
if (argc >= 2) {
info.level = atoi(argv[1]);
}
status = dcerpc_wkssvc_NetWkstaEnumUsers(b, mem_ctx, server_name,
&info, 1000, &num_entries,
&resume_handle, &werr);
if (!NT_STATUS_IS_OK(status)) {
return ntstatus_to_werror(status);
}
if (!W_ERROR_IS_OK(werr)) {
return werr;
}
for (i=0; i<num_entries; i++) {
const char *user = NULL;
switch (info.level) {
case 0:
user = info.ctr.user0->user0[i].user_name;
break;
case 1:
user = talloc_asprintf(
talloc_tos(), "%s\\%s",
info.ctr.user1->user1[i].logon_domain,
info.ctr.user1->user1[i].user_name);
break;
}
printf("%s\n", user ? user : "******");
}
return werr;
}
static WERROR cmd_netlogon_deregisterdnsrecords(struct rpc_pipe_client *cli,
TALLOC_CTX *mem_ctx, int argc,
const char **argv)
{
NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
WERROR werr = WERR_GEN_FAILURE;
const char *server_name = cli->desthost;
const char *domain = lp_workgroup();
const char *dns_host = NULL;
struct dcerpc_binding_handle *b = cli->binding_handle;
if (argc < 1 || argc > 4) {
fprintf(stderr, "Usage: %s <server_name> <domain_name> "
"<dns_host>\n", argv[0]);
return WERR_OK;
}
if (argc >= 2) {
server_name = argv[1];
}
if (argc >= 3) {
domain = argv[2];
}
if (argc >= 4) {
dns_host = argv[3];
}
status = dcerpc_netr_DsrDeregisterDNSHostRecords(b, mem_ctx,
server_name,
domain,
NULL,
NULL,
dns_host,
&werr);
if (!NT_STATUS_IS_OK(status)) {
werr = ntstatus_to_werror(status);
goto done;
}
if (W_ERROR_IS_OK(werr)) {
printf("success\n");
}
done:
return werr;
}
static WERROR cmd_netlogon_dsr_getforesttrustinfo(struct rpc_pipe_client *cli,
TALLOC_CTX *mem_ctx, int argc,
const char **argv)
{
NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
WERROR werr = WERR_GEN_FAILURE;
const char *server_name = cli->desthost;
const char *trusted_domain_name = NULL;
struct lsa_ForestTrustInformation *info = NULL;
uint32_t flags = 0;
struct dcerpc_binding_handle *b = cli->binding_handle;
if (argc < 1 || argc > 4) {
fprintf(stderr, "Usage: %s <server_name> <trusted_domain_name> "
"<flags>\n", argv[0]);
return WERR_OK;
}
if (argc >= 2) {
server_name = argv[1];
}
if (argc >= 3) {
trusted_domain_name = argv[2];
}
if (argc >= 4) {
sscanf(argv[3], "%x", &flags);
}
status = dcerpc_netr_DsRGetForestTrustInformation(b, mem_ctx,
server_name,
trusted_domain_name,
flags,
&info,
&werr);
if (!NT_STATUS_IS_OK(status)) {
werr = ntstatus_to_werror(status);
goto done;
}
if (W_ERROR_IS_OK(werr)) {
printf("success\n");
}
done:
return werr;
}
static WERROR cmd_ntsvcs_get_dev_reg_prop(struct rpc_pipe_client *cli,
TALLOC_CTX *mem_ctx,
int argc,
const char **argv)
{
struct dcerpc_binding_handle *b = cli->binding_handle;
NTSTATUS status;
WERROR werr;
const char *devicepath = NULL;
uint32_t property = DEV_REGPROP_DESC;
uint32_t reg_data_type = REG_NONE;
uint8_t *buffer;
uint32_t buffer_size = 0;
uint32_t needed = 0;
uint32_t flags = 0;
if (argc < 2) {
printf("usage: %s [devicepath] [buffersize]\n", argv[0]);
return WERR_OK;
}
devicepath = argv[1];
if (argc >= 3) {
buffer_size = atoi(argv[2]);
needed = buffer_size;
}
buffer = talloc_array(mem_ctx, uint8_t, buffer_size);
W_ERROR_HAVE_NO_MEMORY(buffer);
status = dcerpc_PNP_GetDeviceRegProp(b, mem_ctx,
devicepath,
property,
®_data_type,
buffer,
&buffer_size,
&needed,
flags,
&werr);
if (!NT_STATUS_IS_OK(status)) {
return ntstatus_to_werror(status);
}
return werr;
}
WERROR rpccli_spoolss_openprinter_ex(struct rpc_pipe_client *cli,
TALLOC_CTX *mem_ctx,
const char *printername,
uint32_t access_desired,
struct policy_handle *handle)
{
NTSTATUS status;
WERROR werror;
struct spoolss_DevmodeContainer devmode_ctr;
union spoolss_UserLevel userlevel;
struct spoolss_UserLevel1 level1;
struct dcerpc_binding_handle *b = cli->binding_handle;
ZERO_STRUCT(devmode_ctr);
level1.size = 28;
level1.client = talloc_asprintf(mem_ctx, "\\\\%s", lp_netbios_name());
W_ERROR_HAVE_NO_MEMORY(level1.client);
level1.user = cli->auth->user_name;
level1.build = 1381;
level1.major = 2;
level1.minor = 0;
level1.processor = 0;
userlevel.level1 = &level1;
status = dcerpc_spoolss_OpenPrinterEx(b, mem_ctx,
printername,
NULL,
devmode_ctr,
access_desired,
1, /* level */
userlevel,
handle,
&werror);
if (!NT_STATUS_IS_OK(status)) {
return ntstatus_to_werror(status);
}
if (!W_ERROR_IS_OK(werror)) {
return werror;
}
return WERR_OK;
}
static WERROR dreplsrv_out_connection_attach(struct dreplsrv_service *s,
const struct repsFromTo1 *rft,
struct dreplsrv_out_connection **_conn)
{
struct dreplsrv_out_connection *cur, *conn = NULL;
const char *hostname;
if (!rft->other_info) {
return WERR_FOOBAR;
}
if (!rft->other_info->dns_name) {
return WERR_FOOBAR;
}
hostname = rft->other_info->dns_name;
for (cur = s->connections; cur; cur = cur->next) {
if (strcmp(cur->binding->host, hostname) == 0) {
conn = cur;
break;
}
}
if (!conn) {
NTSTATUS nt_status;
char *binding_str;
conn = talloc_zero(s, struct dreplsrv_out_connection);
W_ERROR_HAVE_NO_MEMORY(conn);
conn->service = s;
binding_str = talloc_asprintf(conn, "ncacn_ip_tcp:%s[krb5,seal]",
hostname);
W_ERROR_HAVE_NO_MEMORY(binding_str);
nt_status = dcerpc_parse_binding(conn, binding_str, &conn->binding);
talloc_free(binding_str);
if (!NT_STATUS_IS_OK(nt_status)) {
return ntstatus_to_werror(nt_status);
}
DLIST_ADD_END(s->connections, conn, struct dreplsrv_out_connection *);
DEBUG(2,("dreplsrv_out_connection_attach(%s): create\n", conn->binding->host));
} else {
static WERROR rpc_get_value_by_name(TALLOC_CTX *mem_ctx,
const struct registry_key *parent,
const char *value_name,
uint32_t *type,
DATA_BLOB *data)
{
struct rpc_key *mykeydata = talloc_get_type(parent, struct rpc_key);
struct winreg_QueryValue r;
struct winreg_String name;
uint8_t value;
uint32_t val_size = MAX_VALSIZE;
uint32_t zero = 0;
WERROR error;
NTSTATUS status;
if (mykeydata->num_values == -1) {
error = rpc_query_key(mem_ctx, parent);
if(!W_ERROR_IS_OK(error)) return error;
}
name.name = value_name;
ZERO_STRUCT(r);
r.in.handle = &mykeydata->pol;
r.in.value_name = &name;
r.in.type = type;
r.in.data = &value;
r.in.data_size = &val_size;
r.in.data_length = &zero;
r.out.type = type;
r.out.data = &value;
r.out.data_size = &val_size;
r.out.data_length = &zero;
status = dcerpc_winreg_QueryValue(mykeydata->pipe, mem_ctx, &r);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(1, ("QueryValue failed - %s\n", nt_errstr(status)));
return ntstatus_to_werror(status);
}
*type = *(r.out.type);
*data = data_blob_talloc(mem_ctx, r.out.data, *r.out.data_length);
return r.out.result;
}
static WERROR dsdb_syntax_DN_BINARY_ldb_to_drsuapi(struct ldb_context *ldb,
const struct dsdb_schema *schema,
const struct dsdb_attribute *attr,
const struct ldb_message_element *in,
TALLOC_CTX *mem_ctx,
struct drsuapi_DsReplicaAttribute *out)
{
uint32_t i;
DATA_BLOB *blobs;
if (attr->attributeID_id == 0xFFFFFFFF) {
return WERR_FOOBAR;
}
out->attid = attr->attributeID_id;
out->value_ctr.num_values = in->num_values;
out->value_ctr.values = talloc_array(mem_ctx,
struct drsuapi_DsAttributeValue,
in->num_values);
W_ERROR_HAVE_NO_MEMORY(out->value_ctr.values);
blobs = talloc_array(mem_ctx, DATA_BLOB, in->num_values);
W_ERROR_HAVE_NO_MEMORY(blobs);
for (i=0; i < in->num_values; i++) {
struct drsuapi_DsReplicaObjectIdentifier3Binary id3b;
enum ndr_err_code ndr_err;
out->value_ctr.values[i].blob = &blobs[i];
/* TODO: handle id3b.guid and id3b.sid, id3.binary */
ZERO_STRUCT(id3b);
id3b.dn = (const char *)in->values[i].data;
id3b.binary = data_blob(NULL, 0);
ndr_err = ndr_push_struct_blob(&blobs[i], blobs, schema->iconv_convenience, &id3b,
(ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3Binary);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
NTSTATUS status = ndr_map_error2ntstatus(ndr_err);
return ntstatus_to_werror(status);
}
}
return WERR_OK;
}
WERROR dsdb_get_drsuapi_prefixmap_as_blob(const struct drsuapi_DsReplicaOIDMapping_Ctr *ctr,
TALLOC_CTX *mem_ctx,
struct ldb_val *prefixMap)
{
struct prefixMapBlob pfm;
enum ndr_err_code ndr_err;
pfm.version = PREFIX_MAP_VERSION_DSDB;
pfm.reserved = 0;
pfm.ctr.dsdb = *ctr;
ndr_err = ndr_push_struct_blob(prefixMap, mem_ctx, &pfm,
(ndr_push_flags_fn_t)ndr_push_prefixMapBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
NTSTATUS nt_status = ndr_map_error2ntstatus(ndr_err);
return ntstatus_to_werror(nt_status);
}
return WERR_OK;
}
static WERROR regdb_store_regdb_version(struct db_context *db, uint32_t version)
{
NTSTATUS status;
if (db == NULL) {
return WERR_CAN_NOT_COMPLETE;
}
status = dbwrap_trans_store_int32(db, REGDB_VERSION_KEYNAME, version);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(1, ("regdb_store_regdb_version: error storing %s = %d: %s\n",
REGDB_VERSION_KEYNAME, version, nt_errstr(status)));
return ntstatus_to_werror(status);
} else {
DEBUG(10, ("regdb_store_regdb_version: stored %s = %d\n",
REGDB_VERSION_KEYNAME, version));
return WERR_OK;
}
}
WERROR DsGetDcName_r(struct libnetapi_ctx *ctx,
struct DsGetDcName *r)
{
WERROR werr;
NTSTATUS status = NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND;
struct dcerpc_binding_handle *b;
werr = libnetapi_get_binding_handle(ctx, r->in.server_name,
&ndr_table_netlogon,
&b);
if (!W_ERROR_IS_OK(werr)) {
goto done;
}
status = dcerpc_netr_DsRGetDCNameEx(b,
ctx,
r->in.server_name,
r->in.domain_name,
r->in.domain_guid,
r->in.site_name,
r->in.flags,
(struct netr_DsRGetDCNameInfo **)r->out.dc_info,
&werr);
if (NT_STATUS_IS_OK(status) && W_ERROR_IS_OK(werr)) {
goto done;
}
status = dcerpc_netr_DsRGetDCName(b,
ctx,
r->in.server_name,
r->in.domain_name,
r->in.domain_guid,
NULL,
r->in.flags,
(struct netr_DsRGetDCNameInfo **)r->out.dc_info,
&werr);
if (!NT_STATUS_IS_OK(status)) {
werr = ntstatus_to_werror(status);
goto done;
}
done:
return werr;
}
static WERROR rpc_get_subkey_by_index(TALLOC_CTX *mem_ctx,
const struct registry_key *parent,
uint32_t n,
const char **name,
const char **keyclass,
NTTIME *last_changed_time)
{
struct winreg_EnumKey r;
struct rpc_key *mykeydata = talloc_get_type(parent, struct rpc_key);
struct winreg_StringBuf namebuf, classbuf;
NTTIME change_time = 0;
NTSTATUS status;
namebuf.name = "";
namebuf.size = MAX_NAMESIZE;
classbuf.name = NULL;
classbuf.size = 0;
ZERO_STRUCT(r);
r.in.handle = &mykeydata->pol;
r.in.enum_index = n;
r.in.name = &namebuf;
r.in.keyclass = &classbuf;
r.in.last_changed_time = &change_time;
r.out.name = &namebuf;
r.out.keyclass = &classbuf;
r.out.last_changed_time = &change_time;
status = dcerpc_winreg_EnumKey(mykeydata->pipe, mem_ctx, &r);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(1, ("EnumKey failed - %s\n", nt_errstr(status)));
return ntstatus_to_werror(status);
}
if (name != NULL)
*name = talloc_reference(mem_ctx, r.out.name->name);
if (keyclass != NULL)
*keyclass = talloc_reference(mem_ctx, r.out.keyclass->name);
if (last_changed_time != NULL)
*last_changed_time = *(r.out.last_changed_time);
return r.out.result;
}
WERROR rpccli_spoolss_addprinterex(struct rpc_pipe_client *cli,
TALLOC_CTX *mem_ctx,
struct spoolss_SetPrinterInfoCtr *info_ctr)
{
WERROR result;
NTSTATUS status;
struct spoolss_DevmodeContainer devmode_ctr;
struct sec_desc_buf secdesc_ctr;
struct spoolss_UserLevelCtr userlevel_ctr;
struct spoolss_UserLevel1 level1;
struct policy_handle handle;
struct dcerpc_binding_handle *b = cli->binding_handle;
ZERO_STRUCT(devmode_ctr);
ZERO_STRUCT(secdesc_ctr);
level1.size = 28;
level1.build = 1381;
level1.major = 2;
level1.minor = 0;
level1.processor = 0;
level1.client = talloc_asprintf(mem_ctx, "\\\\%s", lp_netbios_name());
W_ERROR_HAVE_NO_MEMORY(level1.client);
level1.user = cli->auth->user_name;
userlevel_ctr.level = 1;
userlevel_ctr.user_info.level1 = &level1;
status = dcerpc_spoolss_AddPrinterEx(b, mem_ctx,
cli->srv_name_slash,
info_ctr,
&devmode_ctr,
&secdesc_ctr,
&userlevel_ctr,
&handle,
&result);
if (!NT_STATUS_IS_OK(status)) {
return ntstatus_to_werror(status);
}
return result;
}
static WERROR dsdb_syntax_DN_ldb_to_drsuapi(const struct dsdb_schema *schema,
const struct dsdb_attribute *attr,
const struct ldb_message_element *in,
TALLOC_CTX *mem_ctx,
struct drsuapi_DsReplicaAttribute *out)
{
uint32_t i;
DATA_BLOB *blobs;
if (attr->attributeID_id == 0xFFFFFFFF) {
return WERR_FOOBAR;
}
out->attid = attr->attributeID_id;
out->value_ctr.num_values = in->num_values;
out->value_ctr.values = talloc_array(mem_ctx,
struct drsuapi_DsAttributeValue,
in->num_values);
W_ERROR_HAVE_NO_MEMORY(out->value_ctr.values);
blobs = talloc_array(mem_ctx, DATA_BLOB, in->num_values);
W_ERROR_HAVE_NO_MEMORY(blobs);
for (i=0; i < in->num_values; i++) {
NTSTATUS status;
struct drsuapi_DsReplicaObjectIdentifier3 id3;
out->value_ctr.values[i].blob = &blobs[i];
/* TODO: handle id3.guid and id3.sid */
ZERO_STRUCT(id3);
id3.dn = (const char *)in->values[i].data;
status = ndr_push_struct_blob(&blobs[i], blobs, &id3,
(ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
if (!NT_STATUS_IS_OK(status)) {
return ntstatus_to_werror(status);
}
}
return WERR_OK;
}
WERROR NetGetAnyDCName_r(struct libnetapi_ctx *ctx,
struct NetGetAnyDCName *r)
{
NTSTATUS status;
WERROR werr;
struct dcerpc_binding_handle *b;
const char *dcname;
void *buffer;
werr = libnetapi_get_binding_handle(ctx, r->in.server_name,
&ndr_table_netlogon,
&b);
if (!W_ERROR_IS_OK(werr)) {
goto done;
}
status = dcerpc_netr_GetAnyDCName(b, talloc_tos(),
r->in.server_name,
r->in.domain_name,
&dcname,
&werr);
if (!NT_STATUS_IS_OK(status)) {
werr = ntstatus_to_werror(status);
goto done;
}
if (!W_ERROR_IS_OK(werr)) {
goto done;
}
if (NetApiBufferAllocate(strlen_m_term(dcname), &buffer)) {
werr = WERR_NOT_ENOUGH_MEMORY;
goto done;
}
memcpy(buffer, dcname, strlen_m_term(dcname));
*r->out.buffer = buffer;
done:
return werr;
}
/**
* split given path into hive and remaining path and open the hive key
*/
static WERROR open_hive(TALLOC_CTX *ctx, const char *path,
uint32 desired_access,
struct registry_key **hive,
char **subkeyname)
{
WERROR werr;
struct security_token *token = NULL;
char *hivename = NULL;
char *tmp_subkeyname = NULL;
TALLOC_CTX *tmp_ctx = talloc_stackframe();
if ((hive == NULL) || (subkeyname == NULL)) {
werr = WERR_INVALID_PARAM;
goto done;
}
werr = split_hive_key(tmp_ctx, path, &hivename, &tmp_subkeyname);
if (!W_ERROR_IS_OK(werr)) {
goto done;
}
*subkeyname = talloc_strdup(ctx, tmp_subkeyname);
if (*subkeyname == NULL) {
werr = WERR_NOMEM;
goto done;
}
werr = ntstatus_to_werror(registry_create_admin_token(tmp_ctx, &token));
if (!W_ERROR_IS_OK(werr)) {
goto done;
}
werr = reg_openhive(ctx, hivename, desired_access, token, hive);
if (!W_ERROR_IS_OK(werr)) {
goto done;
}
werr = WERR_OK;
done:
TALLOC_FREE(tmp_ctx);
return werr;
}
_PUBLIC_ uint32_t dcerpc_fault_from_nt_status(NTSTATUS nt_status)
{
int idx = 0;
WERROR werr;
if (NT_STATUS_IS_OK(nt_status)) {
return DCERPC_NCA_S_PROTO_ERROR;
}
while (dcerpc_faults[idx].errstr != NULL) {
if (NT_STATUS_EQUAL(dcerpc_faults[idx].nt_status, nt_status)) {
return dcerpc_faults[idx].faultcode;
}
idx++;
}
werr = ntstatus_to_werror(nt_status);
return W_ERROR_V(werr);
}
static WERROR regdb_store_regdb_version(uint32_t version)
{
NTSTATUS status;
const char *version_keyname = "INFO/version";
if (!regdb) {
return WERR_CAN_NOT_COMPLETE;
}
status = dbwrap_trans_store_int32(regdb, version_keyname, version);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(1, ("regdb_store_regdb_version: error storing %s = %d: %s\n",
version_keyname, version, nt_errstr(status)));
return ntstatus_to_werror(status);
} else {
DEBUG(10, ("regdb_store_regdb_version: stored %s = %d\n",
version_keyname, version));
return WERR_OK;
}
}
WERROR DsGetDcName_l(struct libnetapi_ctx *ctx,
struct DsGetDcName *r)
{
NTSTATUS status;
status = dsgetdcname(ctx,
NULL,
r->in.domain_name,
r->in.domain_guid,
r->in.site_name,
r->in.flags,
(struct netr_DsRGetDCNameInfo **)r->out.dc_info);
if (!NT_STATUS_IS_OK(status)) {
libnetapi_set_error_string(ctx,
"failed to find DC: %s",
get_friendly_nt_error_msg(status));
}
return ntstatus_to_werror(status);
}
static WERROR cmd_netlogon_gettrustrid(struct rpc_pipe_client *cli,
TALLOC_CTX *mem_ctx, int argc,
const char **argv)
{
NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
WERROR werr = WERR_GEN_FAILURE;
const char *server_name = cli->desthost;
const char *domain_name = lp_workgroup();
uint32_t rid = 0;
struct dcerpc_binding_handle *b = cli->binding_handle;
if (argc < 1 || argc > 3) {
fprintf(stderr, "Usage: %s <server_name> <domain_name>\n",
argv[0]);
return WERR_OK;
}
if (argc >= 2) {
server_name = argv[1];
}
if (argc >= 3) {
domain_name = argv[2];
}
status = dcerpc_netr_LogonGetTrustRid(b, mem_ctx,
server_name,
domain_name,
&rid,
&werr);
if (!NT_STATUS_IS_OK(status)) {
werr = ntstatus_to_werror(status);
goto done;
}
if (W_ERROR_IS_OK(werr)) {
printf("Rid: %d\n", rid);
}
done:
return werr;
}
static WERROR dsdb_syntax_DN_drsuapi_to_ldb(const struct dsdb_schema *schema,
const struct dsdb_attribute *attr,
const struct drsuapi_DsReplicaAttribute *in,
TALLOC_CTX *mem_ctx,
struct ldb_message_element *out)
{
uint32_t i;
out->flags = 0;
out->name = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
W_ERROR_HAVE_NO_MEMORY(out->name);
out->num_values = in->value_ctr.num_values;
out->values = talloc_array(mem_ctx, struct ldb_val, out->num_values);
W_ERROR_HAVE_NO_MEMORY(out->values);
for (i=0; i < out->num_values; i++) {
struct drsuapi_DsReplicaObjectIdentifier3 id3;
NTSTATUS status;
if (in->value_ctr.values[i].blob == NULL) {
return WERR_FOOBAR;
}
if (in->value_ctr.values[i].blob->length == 0) {
return WERR_FOOBAR;
}
status = ndr_pull_struct_blob_all(in->value_ctr.values[i].blob,
out->values, &id3,
(ndr_pull_flags_fn_t)ndr_pull_drsuapi_DsReplicaObjectIdentifier3);
if (!NT_STATUS_IS_OK(status)) {
return ntstatus_to_werror(status);
}
/* TODO: handle id3.guid and id3.sid */
out->values[i] = data_blob_string_const(id3.dn);
}
return WERR_OK;
}
static WERROR cmd_ntsvcs_get_version(struct rpc_pipe_client *cli,
TALLOC_CTX *mem_ctx,
int argc,
const char **argv)
{
NTSTATUS status;
WERROR werr;
uint16_t version;
status = rpccli_PNP_GetVersion(cli, mem_ctx,
&version, &werr);
if (!NT_STATUS_IS_OK(status)) {
return ntstatus_to_werror(status);
}
if (W_ERROR_IS_OK(werr)) {
printf("version: %d\n", version);
}
return werr;
}
static WERROR cmd_netlogon_getdcname(struct rpc_pipe_client *cli,
TALLOC_CTX *mem_ctx, int argc,
const char **argv)
{
const char *dcname = NULL;
NTSTATUS status;
WERROR werr;
int old_timeout;
struct dcerpc_binding_handle *b = cli->binding_handle;
if (argc != 2) {
fprintf(stderr, "Usage: %s domainname\n", argv[0]);
return WERR_OK;
}
/* Make sure to wait for our DC's reply */
old_timeout = rpccli_set_timeout(cli, 30000); /* 30 seconds. */
rpccli_set_timeout(cli, MAX(30000, old_timeout)); /* At least 30 sec */
status = dcerpc_netr_GetDcName(b, mem_ctx,
cli->desthost,
argv[1],
&dcname,
&werr);
rpccli_set_timeout(cli, old_timeout);
if (!NT_STATUS_IS_OK(status)) {
return ntstatus_to_werror(status);
}
if (!W_ERROR_IS_OK(werr)) {
return werr;
}
/* Display results */
printf("%s\n", dcname);
return werr;
}
