1
0
mirror of https://github.com/samba-team/samba.git synced 2025-01-13 13:18:06 +03:00

Restructure inner workings of libnetapi a bit.

Guenther
This commit is contained in:
Günther Deschner 2008-04-08 02:42:50 +02:00
parent 78da087b3a
commit a4e3bc2bad
8 changed files with 663 additions and 680 deletions

View File

@ -815,6 +815,7 @@ CLIENT_OBJ = $(CLIENT_OBJ1) $(PARAM_OBJ) $(LIBSMB_OBJ) \
LIBNETAPI_OBJ1 = lib/netapi/netapi.o \
librpc/gen_ndr/ndr_libnetapi.o \
lib/netapi/libnetapi.o \
lib/netapi/joindomain.o \
lib/netapi/serverinfo.o \
lib/netapi/getdc.o

View File

@ -19,6 +19,7 @@
#include <string.h>
#include <stdio.h>
#include <inttypes.h>
#include <netapi.h>

View File

@ -19,16 +19,16 @@
#include "includes.h"
#include "librpc/gen_ndr/libnetapi.h"
#include "lib/netapi/netapi.h"
#include "lib/netapi/libnetapi.h"
#include "libnet/libnet.h"
/********************************************************************
********************************************************************/
static WERROR NetGetDCNameLocal(struct libnetapi_ctx *ctx,
const char *server_name,
const char *domain_name,
uint8_t **buffer)
WERROR NetGetDCName_l(struct libnetapi_ctx *ctx,
struct NetGetDCName *r)
{
return WERR_NOT_SUPPORTED;
}
@ -36,17 +36,15 @@ static WERROR NetGetDCNameLocal(struct libnetapi_ctx *ctx,
/********************************************************************
********************************************************************/
static WERROR NetGetDCNameRemote(struct libnetapi_ctx *ctx,
const char *server_name,
const char *domain_name,
uint8_t **buffer)
WERROR NetGetDCName_r(struct libnetapi_ctx *ctx,
struct NetGetDCName *r)
{
struct cli_state *cli = NULL;
struct rpc_pipe_client *pipe_cli = NULL;
NTSTATUS status;
WERROR werr;
status = cli_full_connection(&cli, NULL, server_name,
status = cli_full_connection(&cli, NULL, r->in.server_name,
NULL, 0,
"IPC$", "IPC",
ctx->username,
@ -64,12 +62,12 @@ static WERROR NetGetDCNameRemote(struct libnetapi_ctx *ctx,
if (!pipe_cli) {
werr = ntstatus_to_werror(status);
goto done;
};
}
status = rpccli_netr_GetDcName(pipe_cli, ctx,
server_name,
domain_name,
(const char **)buffer,
r->in.server_name,
r->in.domain_name,
(const char **)r->out.buffer,
&werr);
done:
if (cli) {
@ -82,59 +80,8 @@ static WERROR NetGetDCNameRemote(struct libnetapi_ctx *ctx,
/********************************************************************
********************************************************************/
static WERROR libnetapi_NetGetDCName(struct libnetapi_ctx *ctx,
const char *server_name,
const char *domain_name,
uint8_t **buffer)
{
if (!server_name || is_myname_or_ipaddr(server_name)) {
return NetGetDCNameLocal(ctx,
server_name,
domain_name,
buffer);
}
return NetGetDCNameRemote(ctx,
server_name,
domain_name,
buffer);
}
/****************************************************************
NetGetDCName
****************************************************************/
NET_API_STATUS NetGetDCName(const char *server_name,
const char *domain_name,
uint8_t **buffer)
{
struct libnetapi_ctx *ctx = NULL;
NET_API_STATUS status;
WERROR werr;
status = libnetapi_getctx(&ctx);
if (status != 0) {
return status;
}
werr = libnetapi_NetGetDCName(ctx,
server_name,
domain_name,
buffer);
if (!W_ERROR_IS_OK(werr)) {
return W_ERROR_V(werr);
}
return NET_API_STATUS_SUCCESS;
}
/********************************************************************
********************************************************************/
static WERROR NetGetAnyDCNameLocal(struct libnetapi_ctx *ctx,
const char *server_name,
const char *domain_name,
uint8_t **buffer)
WERROR NetGetAnyDCName_l(struct libnetapi_ctx *ctx,
struct NetGetAnyDCName *r)
{
return WERR_NOT_SUPPORTED;
}
@ -142,17 +89,15 @@ static WERROR NetGetAnyDCNameLocal(struct libnetapi_ctx *ctx,
/********************************************************************
********************************************************************/
static WERROR NetGetAnyDCNameRemote(struct libnetapi_ctx *ctx,
const char *server_name,
const char *domain_name,
uint8_t **buffer)
WERROR NetGetAnyDCName_r(struct libnetapi_ctx *ctx,
struct NetGetAnyDCName *r)
{
struct cli_state *cli = NULL;
struct rpc_pipe_client *pipe_cli = NULL;
NTSTATUS status;
WERROR werr;
status = cli_full_connection(&cli, NULL, server_name,
status = cli_full_connection(&cli, NULL, r->in.server_name,
NULL, 0,
"IPC$", "IPC",
ctx->username,
@ -173,9 +118,9 @@ static WERROR NetGetAnyDCNameRemote(struct libnetapi_ctx *ctx,
};
status = rpccli_netr_GetAnyDCName(pipe_cli, ctx,
server_name,
domain_name,
(const char **)buffer,
r->in.server_name,
r->in.domain_name,
(const char **)r->out.buffer,
&werr);
if (!NT_STATUS_IS_OK(status)) {
goto done;
@ -188,52 +133,3 @@ static WERROR NetGetAnyDCNameRemote(struct libnetapi_ctx *ctx,
return werr;
}
/********************************************************************
********************************************************************/
static WERROR libnetapi_NetGetAnyDCName(struct libnetapi_ctx *ctx,
const char *server_name,
const char *domain_name,
uint8_t **buffer)
{
if (!server_name || is_myname_or_ipaddr(server_name)) {
return NetGetAnyDCNameLocal(ctx,
server_name,
domain_name,
buffer);
}
return NetGetAnyDCNameRemote(ctx,
server_name,
domain_name,
buffer);
}
/****************************************************************
NetGetAnyDCName
****************************************************************/
NET_API_STATUS NetGetAnyDCName(const char *server_name,
const char *domain_name,
uint8_t **buffer)
{
struct libnetapi_ctx *ctx = NULL;
NET_API_STATUS status;
WERROR werr;
status = libnetapi_getctx(&ctx);
if (status != 0) {
return status;
}
werr = libnetapi_NetGetAnyDCName(ctx,
server_name,
domain_name,
buffer);
if (!W_ERROR_IS_OK(werr)) {
return W_ERROR_V(werr);
}
return NET_API_STATUS_SUCCESS;
}

View File

@ -19,75 +19,72 @@
#include "includes.h"
#include "librpc/gen_ndr/libnetapi.h"
#include "lib/netapi/netapi.h"
#include "lib/netapi/libnetapi.h"
#include "libnet/libnet.h"
/****************************************************************
****************************************************************/
static WERROR NetJoinDomainLocal(struct libnetapi_ctx *mem_ctx,
const char *server_name,
const char *domain_name,
const char *account_ou,
const char *Account,
const char *password,
uint32_t join_flags)
WERROR NetJoinDomain_l(struct libnetapi_ctx *mem_ctx,
struct NetJoinDomain *r)
{
struct libnet_JoinCtx *r = NULL;
struct libnet_JoinCtx *j = NULL;
WERROR werr;
if (!domain_name) {
if (!r->in.domain) {
return WERR_INVALID_PARAM;
}
werr = libnet_init_JoinCtx(mem_ctx, &r);
werr = libnet_init_JoinCtx(mem_ctx, &j);
W_ERROR_NOT_OK_RETURN(werr);
r->in.domain_name = talloc_strdup(mem_ctx, domain_name);
W_ERROR_HAVE_NO_MEMORY(r->in.domain_name);
j->in.domain_name = talloc_strdup(mem_ctx, r->in.domain);
W_ERROR_HAVE_NO_MEMORY(j->in.domain_name);
if (join_flags & WKSSVC_JOIN_FLAGS_JOIN_TYPE) {
if (r->in.join_flags & WKSSVC_JOIN_FLAGS_JOIN_TYPE) {
NTSTATUS status;
struct netr_DsRGetDCNameInfo *info = NULL;
uint32_t flags = DS_DIRECTORY_SERVICE_REQUIRED |
DS_WRITABLE_REQUIRED |
DS_RETURN_DNS_NAME;
status = dsgetdcname(mem_ctx, domain_name,
status = dsgetdcname(mem_ctx, r->in.domain,
NULL, NULL, flags, &info);
if (!NT_STATUS_IS_OK(status)) {
libnetapi_set_error_string(mem_ctx,
"%s", get_friendly_nt_error_msg(status));
return ntstatus_to_werror(status);
}
r->in.dc_name = talloc_strdup(mem_ctx,
j->in.dc_name = talloc_strdup(mem_ctx,
info->dc_unc);
W_ERROR_HAVE_NO_MEMORY(r->in.dc_name);
W_ERROR_HAVE_NO_MEMORY(j->in.dc_name);
}
if (account_ou) {
r->in.account_ou = talloc_strdup(mem_ctx, account_ou);
W_ERROR_HAVE_NO_MEMORY(r->in.account_ou);
if (r->in.account_ou) {
j->in.account_ou = talloc_strdup(mem_ctx, r->in.account_ou);
W_ERROR_HAVE_NO_MEMORY(j->in.account_ou);
}
if (Account) {
r->in.admin_account = talloc_strdup(mem_ctx, Account);
W_ERROR_HAVE_NO_MEMORY(r->in.admin_account);
if (r->in.account) {
j->in.admin_account = talloc_strdup(mem_ctx, r->in.account);
W_ERROR_HAVE_NO_MEMORY(j->in.admin_account);
}
if (password) {
r->in.admin_password = talloc_strdup(mem_ctx, password);
W_ERROR_HAVE_NO_MEMORY(r->in.admin_password);
if (r->in.password) {
j->in.admin_password = talloc_strdup(mem_ctx, r->in.password);
W_ERROR_HAVE_NO_MEMORY(j->in.admin_password);
}
r->in.join_flags = join_flags;
r->in.modify_config = true;
r->in.debug = true;
j->in.join_flags = r->in.join_flags;
j->in.modify_config = true;
j->in.debug = true;
werr = libnet_Join(mem_ctx, r);
if (!W_ERROR_IS_OK(werr) && r->out.error_string) {
libnetapi_set_error_string(mem_ctx, "%s", r->out.error_string);
werr = libnet_Join(mem_ctx, j);
if (!W_ERROR_IS_OK(werr) && j->out.error_string) {
libnetapi_set_error_string(mem_ctx, "%s", j->out.error_string);
}
TALLOC_FREE(r);
TALLOC_FREE(j);
return werr;
}
@ -95,13 +92,8 @@ static WERROR NetJoinDomainLocal(struct libnetapi_ctx *mem_ctx,
/****************************************************************
****************************************************************/
static WERROR NetJoinDomainRemote(struct libnetapi_ctx *ctx,
const char *server_name,
const char *domain_name,
const char *account_ou,
const char *Account,
const char *password,
uint32_t join_flags)
WERROR NetJoinDomain_r(struct libnetapi_ctx *ctx,
struct NetJoinDomain *r)
{
struct cli_state *cli = NULL;
struct rpc_pipe_client *pipe_cli = NULL;
@ -110,7 +102,7 @@ static WERROR NetJoinDomainRemote(struct libnetapi_ctx *ctx,
WERROR werr;
unsigned int old_timeout = 0;
status = cli_full_connection(&cli, NULL, server_name,
status = cli_full_connection(&cli, NULL, r->in.server,
NULL, 0,
"IPC$", "IPC",
ctx->username,
@ -130,20 +122,23 @@ static WERROR NetJoinDomainRemote(struct libnetapi_ctx *ctx,
goto done;
}
if (password) {
if (r->in.password) {
encode_wkssvc_join_password_buffer(ctx,
password,
r->in.password,
&cli->user_session_key,
&encrypted_password);
}
old_timeout = cli_set_timeout(cli, 60000);
old_timeout = cli_set_timeout(cli, 600000);
status = rpccli_wkssvc_NetrJoinDomain2(pipe_cli, ctx,
server_name, domain_name,
account_ou, Account,
r->in.server,
r->in.domain,
r->in.account_ou,
r->in.account,
encrypted_password,
join_flags, &werr);
r->in.join_flags,
&werr);
if (!NT_STATUS_IS_OK(status)) {
werr = ntstatus_to_werror(status);
goto done;
@ -151,92 +146,21 @@ static WERROR NetJoinDomainRemote(struct libnetapi_ctx *ctx,
done:
if (cli) {
cli_set_timeout(cli, old_timeout);
if (old_timeout) {
cli_set_timeout(cli, old_timeout);
}
cli_shutdown(cli);
}
return werr;
}
/****************************************************************
****************************************************************/
static WERROR libnetapi_NetJoinDomain(struct libnetapi_ctx *ctx,
const char *server_name,
const char *domain_name,
const char *account_ou,
const char *Account,
const char *password,
uint32_t join_flags)
WERROR NetUnjoinDomain_l(struct libnetapi_ctx *mem_ctx,
struct NetUnjoinDomain *r)
{
if (!domain_name) {
return WERR_INVALID_PARAM;
}
if (!server_name || is_myname_or_ipaddr(server_name)) {
return NetJoinDomainLocal(ctx,
server_name,
domain_name,
account_ou,
Account,
password,
join_flags);
}
return NetJoinDomainRemote(ctx,
server_name,
domain_name,
account_ou,
Account,
password,
join_flags);
}
/****************************************************************
NetJoinDomain
****************************************************************/
NET_API_STATUS NetJoinDomain(const char *server_name,
const char *domain_name,
const char *account_ou,
const char *Account,
const char *password,
uint32_t join_flags)
{
struct libnetapi_ctx *ctx = NULL;
NET_API_STATUS status;
WERROR werr;
status = libnetapi_getctx(&ctx);
if (status != 0) {
return status;
}
werr = libnetapi_NetJoinDomain(ctx,
server_name,
domain_name,
account_ou,
Account,
password,
join_flags);
if (!W_ERROR_IS_OK(werr)) {
return W_ERROR_V(werr);
}
return NET_API_STATUS_SUCCESS;
}
/****************************************************************
****************************************************************/
static WERROR NetUnjoinDomainLocal(struct libnetapi_ctx *mem_ctx,
const char *server_name,
const char *account,
const char *password,
uint32_t unjoin_flags)
{
struct libnet_UnjoinCtx *r = NULL;
struct libnet_UnjoinCtx *u = NULL;
struct dom_sid domain_sid;
const char *domain = NULL;
WERROR werr;
@ -245,7 +169,7 @@ static WERROR NetUnjoinDomainLocal(struct libnetapi_ctx *mem_ctx,
return WERR_SETUP_NOT_JOINED;
}
werr = libnet_init_UnjoinCtx(mem_ctx, &r);
werr = libnet_init_UnjoinCtx(mem_ctx, &u);
W_ERROR_NOT_OK_RETURN(werr);
if (lp_realm()) {
@ -254,9 +178,9 @@ static WERROR NetUnjoinDomainLocal(struct libnetapi_ctx *mem_ctx,
domain = lp_workgroup();
}
if (server_name) {
r->in.dc_name = talloc_strdup(mem_ctx, server_name);
W_ERROR_HAVE_NO_MEMORY(r->in.dc_name);
if (r->in.server_name) {
u->in.dc_name = talloc_strdup(mem_ctx, r->in.server_name);
W_ERROR_HAVE_NO_MEMORY(u->in.dc_name);
} else {
NTSTATUS status;
struct netr_DsRGetDCNameInfo *info = NULL;
@ -272,33 +196,35 @@ static WERROR NetUnjoinDomainLocal(struct libnetapi_ctx *mem_ctx,
get_friendly_nt_error_msg(status));
return ntstatus_to_werror(status);
}
r->in.dc_name = talloc_strdup(mem_ctx,
u->in.dc_name = talloc_strdup(mem_ctx,
info->dc_unc);
W_ERROR_HAVE_NO_MEMORY(r->in.dc_name);
W_ERROR_HAVE_NO_MEMORY(u->in.dc_name);
u->in.domain_name = domain;
}
if (account) {
r->in.admin_account = talloc_strdup(mem_ctx, account);
W_ERROR_HAVE_NO_MEMORY(r->in.admin_account);
if (r->in.account) {
u->in.admin_account = talloc_strdup(mem_ctx, r->in.account);
W_ERROR_HAVE_NO_MEMORY(u->in.admin_account);
}
if (password) {
r->in.admin_password = talloc_strdup(mem_ctx, password);
W_ERROR_HAVE_NO_MEMORY(r->in.admin_password);
if (r->in.password) {
u->in.admin_password = talloc_strdup(mem_ctx, r->in.password);
W_ERROR_HAVE_NO_MEMORY(u->in.admin_password);
}
r->in.domain_name = domain;
r->in.unjoin_flags = unjoin_flags;
r->in.modify_config = true;
r->in.debug = true;
u->in.domain_name = domain;
u->in.unjoin_flags = r->in.unjoin_flags;
u->in.modify_config = true;
u->in.debug = true;
r->in.domain_sid = &domain_sid;
u->in.domain_sid = &domain_sid;
werr = libnet_Unjoin(mem_ctx, r);
if (!W_ERROR_IS_OK(werr) && r->out.error_string) {
libnetapi_set_error_string(mem_ctx, "%s", r->out.error_string);
werr = libnet_Unjoin(mem_ctx, u);
if (!W_ERROR_IS_OK(werr) && u->out.error_string) {
libnetapi_set_error_string(mem_ctx, "%s", u->out.error_string);
}
TALLOC_FREE(r);
TALLOC_FREE(u);
return werr;
}
@ -306,11 +232,8 @@ static WERROR NetUnjoinDomainLocal(struct libnetapi_ctx *mem_ctx,
/****************************************************************
****************************************************************/
static WERROR NetUnjoinDomainRemote(struct libnetapi_ctx *ctx,
const char *server_name,
const char *account,
const char *password,
uint32_t unjoin_flags)
WERROR NetUnjoinDomain_r(struct libnetapi_ctx *ctx,
struct NetUnjoinDomain *r)
{
struct cli_state *cli = NULL;
struct rpc_pipe_client *pipe_cli = NULL;
@ -319,7 +242,7 @@ static WERROR NetUnjoinDomainRemote(struct libnetapi_ctx *ctx,
WERROR werr;
unsigned int old_timeout = 0;
status = cli_full_connection(&cli, NULL, server_name,
status = cli_full_connection(&cli, NULL, r->in.server_name,
NULL, 0,
"IPC$", "IPC",
ctx->username,
@ -339,9 +262,9 @@ static WERROR NetUnjoinDomainRemote(struct libnetapi_ctx *ctx,
goto done;
}
if (password) {
if (r->in.password) {
encode_wkssvc_join_password_buffer(ctx,
password,
r->in.password,
&cli->user_session_key,
&encrypted_password);
}
@ -349,10 +272,10 @@ static WERROR NetUnjoinDomainRemote(struct libnetapi_ctx *ctx,
old_timeout = cli_set_timeout(cli, 60000);
status = rpccli_wkssvc_NetrUnjoinDomain2(pipe_cli, ctx,
server_name,
account,
r->in.server_name,
r->in.account,
encrypted_password,
unjoin_flags,
r->in.unjoin_flags,
&werr);
if (!NT_STATUS_IS_OK(status)) {
werr = ntstatus_to_werror(status);
@ -371,72 +294,15 @@ static WERROR NetUnjoinDomainRemote(struct libnetapi_ctx *ctx,
/****************************************************************
****************************************************************/
static WERROR libnetapi_NetUnjoinDomain(struct libnetapi_ctx *ctx,
const char *server_name,
const char *account,
const char *password,
uint32_t unjoin_flags)
{
if (!server_name || is_myname_or_ipaddr(server_name)) {
return NetUnjoinDomainLocal(ctx,
server_name,
account,
password,
unjoin_flags);
}
return NetUnjoinDomainRemote(ctx,
server_name,
account,
password,
unjoin_flags);
}
/****************************************************************
NetUnjoinDomain
****************************************************************/
NET_API_STATUS NetUnjoinDomain(const char *server_name,
const char *account,
const char *password,
uint32_t unjoin_flags)
{
struct libnetapi_ctx *ctx = NULL;
NET_API_STATUS status;
WERROR werr;
status = libnetapi_getctx(&ctx);
if (status != 0) {
return status;
}
werr = libnetapi_NetUnjoinDomain(ctx,
server_name,
account,
password,
unjoin_flags);
if (!W_ERROR_IS_OK(werr)) {
return W_ERROR_V(werr);
}
return NET_API_STATUS_SUCCESS;
}
/****************************************************************
****************************************************************/
static WERROR NetGetJoinInformationRemote(struct libnetapi_ctx *ctx,
const char *server_name,
const char **name_buffer,
uint16_t *name_type)
WERROR NetGetJoinInformation_r(struct libnetapi_ctx *ctx,
struct NetGetJoinInformation *r)
{
struct cli_state *cli = NULL;
struct rpc_pipe_client *pipe_cli = NULL;
NTSTATUS status;
WERROR werr;
status = cli_full_connection(&cli, NULL, server_name,
status = cli_full_connection(&cli, NULL, r->in.server_name,
NULL, 0,
"IPC$", "IPC",
ctx->username,
@ -457,9 +323,9 @@ static WERROR NetGetJoinInformationRemote(struct libnetapi_ctx *ctx,
}
status = rpccli_wkssvc_NetrGetJoinInformation(pipe_cli, ctx,
server_name,
name_buffer,
(enum wkssvc_NetJoinStatus *)name_type,
r->in.server_name,
r->out.name_buffer,
(enum wkssvc_NetJoinStatus *)r->out.name_type,
&werr);
if (!NT_STATUS_IS_OK(status)) {
werr = ntstatus_to_werror(status);
@ -477,17 +343,15 @@ static WERROR NetGetJoinInformationRemote(struct libnetapi_ctx *ctx,
/****************************************************************
****************************************************************/
static WERROR NetGetJoinInformationLocal(struct libnetapi_ctx *ctx,
const char *server_name,
const char **name_buffer,
uint16_t *name_type)
WERROR NetGetJoinInformation_l(struct libnetapi_ctx *ctx,
struct NetGetJoinInformation *r)
{
if ((lp_security() == SEC_ADS) && lp_realm()) {
*name_buffer = talloc_strdup(ctx, lp_realm());
*r->out.name_buffer = talloc_strdup(ctx, lp_realm());
} else {
*name_buffer = talloc_strdup(ctx, lp_workgroup());
*r->out.name_buffer = talloc_strdup(ctx, lp_workgroup());
}
if (!*name_buffer) {
if (!*r->out.name_buffer) {
return WERR_NOMEM;
}
@ -495,73 +359,22 @@ static WERROR NetGetJoinInformationLocal(struct libnetapi_ctx *ctx,
case ROLE_DOMAIN_MEMBER:
case ROLE_DOMAIN_PDC:
case ROLE_DOMAIN_BDC:
*name_type = NetSetupDomainName;
*r->out.name_type = NetSetupDomainName;
break;
case ROLE_STANDALONE:
default:
*name_type = NetSetupWorkgroupName;
*r->out.name_type = NetSetupWorkgroupName;
break;
}
return WERR_OK;
}
static WERROR libnetapi_NetGetJoinInformation(struct libnetapi_ctx *ctx,
const char *server_name,
const char **name_buffer,
uint16_t *name_type)
{
if (!server_name || is_myname_or_ipaddr(server_name)) {
return NetGetJoinInformationLocal(ctx,
server_name,
name_buffer,
name_type);
}
return NetGetJoinInformationRemote(ctx,
server_name,
name_buffer,
name_type);
}
/****************************************************************
NetGetJoinInformation
****************************************************************/
NET_API_STATUS NetGetJoinInformation(const char *server_name,
const char **name_buffer,
uint16_t *name_type)
{
struct libnetapi_ctx *ctx = NULL;
NET_API_STATUS status;
WERROR werr;
status = libnetapi_getctx(&ctx);
if (status != 0) {
return status;
}
werr = libnetapi_NetGetJoinInformation(ctx,
server_name,
name_buffer,
name_type);
if (!W_ERROR_IS_OK(werr)) {
return W_ERROR_V(werr);
}
return NET_API_STATUS_SUCCESS;
}
/****************************************************************
****************************************************************/
static WERROR NetGetJoinableOUsLocal(struct libnetapi_ctx *ctx,
const char *server_name,
const char *domain,
const char *account,
const char *password,
uint32_t *ou_count,
const char ***ous)
WERROR NetGetJoinableOUs_l(struct libnetapi_ctx *ctx,
struct NetGetJoinableOUs *r)
{
#ifdef WITH_ADS
NTSTATUS status;
@ -571,7 +384,7 @@ static WERROR NetGetJoinableOUsLocal(struct libnetapi_ctx *ctx,
uint32_t flags = DS_DIRECTORY_SERVICE_REQUIRED |
DS_RETURN_DNS_NAME;
status = dsgetdcname(ctx, domain,
status = dsgetdcname(ctx, r->in.domain,
NULL, NULL, flags, &info);
if (!NT_STATUS_IS_OK(status)) {
libnetapi_set_error_string(ctx, "%s",
@ -579,21 +392,21 @@ static WERROR NetGetJoinableOUsLocal(struct libnetapi_ctx *ctx,
return ntstatus_to_werror(status);
}
ads = ads_init(domain, domain, info->dc_unc);
ads = ads_init(r->in.domain, r->in.domain, info->dc_unc);
if (!ads) {
return WERR_GENERAL_FAILURE;
}
SAFE_FREE(ads->auth.user_name);
if (account) {
ads->auth.user_name = SMB_STRDUP(account);
if (r->in.account) {
ads->auth.user_name = SMB_STRDUP(r->in.account);
} else if (ctx->username) {
ads->auth.user_name = SMB_STRDUP(ctx->username);
}
SAFE_FREE(ads->auth.password);
if (password) {
ads->auth.password = SMB_STRDUP(password);
if (r->in.password) {
ads->auth.password = SMB_STRDUP(r->in.password);
} else if (ctx->password) {
ads->auth.password = SMB_STRDUP(ctx->password);
}
@ -605,8 +418,8 @@ static WERROR NetGetJoinableOUsLocal(struct libnetapi_ctx *ctx,
}
ads_status = ads_get_joinable_ous(ads, ctx,
(char ***)ous,
(size_t *)ou_count);
(char ***)r->out.ous,
(size_t *)r->out.ou_count);
if (!ADS_ERR_OK(ads_status)) {
ads_destroy(&ads);
return WERR_DEFAULT_JOIN_REQUIRED;
@ -622,13 +435,8 @@ static WERROR NetGetJoinableOUsLocal(struct libnetapi_ctx *ctx,
/****************************************************************
****************************************************************/
static WERROR NetGetJoinableOUsRemote(struct libnetapi_ctx *ctx,
const char *server_name,
const char *domain,
const char *account,
const char *password,
uint32_t *ou_count,
const char ***ous)
WERROR NetGetJoinableOUs_r(struct libnetapi_ctx *ctx,
struct NetGetJoinableOUs *r)
{
struct cli_state *cli = NULL;
struct rpc_pipe_client *pipe_cli = NULL;
@ -636,7 +444,7 @@ static WERROR NetGetJoinableOUsRemote(struct libnetapi_ctx *ctx,
NTSTATUS status;
WERROR werr;
status = cli_full_connection(&cli, NULL, server_name,
status = cli_full_connection(&cli, NULL, r->in.server_name,
NULL, 0,
"IPC$", "IPC",
ctx->username,
@ -656,20 +464,20 @@ static WERROR NetGetJoinableOUsRemote(struct libnetapi_ctx *ctx,
goto done;
}
if (password) {
if (r->in.password) {
encode_wkssvc_join_password_buffer(ctx,
password,
r->in.password,
&cli->user_session_key,
&encrypted_password);
}
status = rpccli_wkssvc_NetrGetJoinableOus2(pipe_cli, ctx,
server_name,
domain,
account,
r->in.server_name,
r->in.domain,
r->in.account,
encrypted_password,
ou_count,
ous,
r->out.ou_count,
r->out.ous,
&werr);
if (!NT_STATUS_IS_OK(status)) {
werr = ntstatus_to_werror(status);
@ -683,67 +491,3 @@ static WERROR NetGetJoinableOUsRemote(struct libnetapi_ctx *ctx,
return werr;
}
/****************************************************************
****************************************************************/
static WERROR libnetapi_NetGetJoinableOUs(struct libnetapi_ctx *ctx,
const char *server_name,
const char *domain,
const char *account,
const char *password,
uint32_t *ou_count,
const char ***ous)
{
if (!server_name || is_myname_or_ipaddr(server_name)) {
return NetGetJoinableOUsLocal(ctx,
server_name,
domain,
account,
password,
ou_count,
ous);
}
return NetGetJoinableOUsRemote(ctx,
server_name,
domain,
account,
password,
ou_count,
ous);
}
/****************************************************************
NetGetJoinableOUs
****************************************************************/
NET_API_STATUS NetGetJoinableOUs(const char *server_name,
const char *domain,
const char *account,
const char *password,
uint32_t *ou_count,
const char ***ous)
{
struct libnetapi_ctx *ctx = NULL;
NET_API_STATUS status;
WERROR werr;
status = libnetapi_getctx(&ctx);
if (status != 0) {
return status;
}
werr = libnetapi_NetGetJoinableOUs(ctx,
server_name,
domain,
account,
password,
ou_count,
ous);
if (!W_ERROR_IS_OK(werr)) {
return W_ERROR_V(werr);
}
return NET_API_STATUS_SUCCESS;
}

View File

@ -0,0 +1,393 @@
/*
* Unix SMB/CIFS implementation.
* NetApi Support
* Copyright (C) Guenther Deschner 2007-2008
*
* 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 "includes.h"
#include "librpc/gen_ndr/libnetapi.h"
#include "lib/netapi/netapi.h"
#include "libnetapi.h"
#include "librpc/gen_ndr/ndr_libnetapi.h"
/****************************************************************
NetJoinDomain
****************************************************************/
NET_API_STATUS NetJoinDomain(const char * server /* [in] [unique] */,
const char * domain /* [in] [ref] */,
const char * account_ou /* [in] [unique] */,
const char * account /* [in] [unique] */,
const char * password /* [in] [unique] */,
uint32_t join_flags /* [in] */)
{
struct NetJoinDomain r;
struct libnetapi_ctx *ctx = NULL;
NET_API_STATUS status;
WERROR werr;
status = libnetapi_getctx(&ctx);
if (status != 0) {
return status;
}
/* In parameters */
r.in.server = server;
r.in.domain = domain;
r.in.account_ou = account_ou;
r.in.account = account;
r.in.password = password;
r.in.join_flags = join_flags;
/* Out parameters */
if (DEBUGLEVEL >= 10) {
NDR_PRINT_IN_DEBUG(NetJoinDomain, &r);
}
if (LIBNETAPI_LOCAL_SERVER(server)) {
werr = NetJoinDomain_l(ctx, &r);
} else {
werr = NetJoinDomain_r(ctx, &r);
}
r.out.result = W_ERROR_V(werr);
if (DEBUGLEVEL >= 10) {
NDR_PRINT_OUT_DEBUG(NetJoinDomain, &r);
}
return r.out.result;
}
/****************************************************************
NetUnjoinDomain
****************************************************************/
NET_API_STATUS NetUnjoinDomain(const char * server_name /* [in] [unique] */,
const char * account /* [in] [unique] */,
const char * password /* [in] [unique] */,
uint32_t unjoin_flags /* [in] */)
{
struct NetUnjoinDomain r;
struct libnetapi_ctx *ctx = NULL;
NET_API_STATUS status;
WERROR werr;
status = libnetapi_getctx(&ctx);
if (status != 0) {
return status;
}
/* In parameters */
r.in.server_name = server_name;
r.in.account = account;
r.in.password = password;
r.in.unjoin_flags = unjoin_flags;
/* Out parameters */
if (DEBUGLEVEL >= 10) {
NDR_PRINT_IN_DEBUG(NetUnjoinDomain, &r);
}
if (LIBNETAPI_LOCAL_SERVER(server_name)) {
werr = NetUnjoinDomain_l(ctx, &r);
} else {
werr = NetUnjoinDomain_r(ctx, &r);
}
r.out.result = W_ERROR_V(werr);
if (DEBUGLEVEL >= 10) {
NDR_PRINT_OUT_DEBUG(NetUnjoinDomain, &r);
}
return r.out.result;
}
/****************************************************************
NetGetJoinInformation
****************************************************************/
NET_API_STATUS NetGetJoinInformation(const char * server_name /* [in] [unique] */,
const char * *name_buffer /* [out] [ref] */,
uint16_t *name_type /* [out] [ref] */)
{
struct NetGetJoinInformation r;
struct libnetapi_ctx *ctx = NULL;
NET_API_STATUS status;
WERROR werr;
status = libnetapi_getctx(&ctx);
if (status != 0) {
return status;
}
/* In parameters */
r.in.server_name = server_name;
/* Out parameters */
r.out.name_buffer = name_buffer;
r.out.name_type = name_type;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_IN_DEBUG(NetGetJoinInformation, &r);
}
if (LIBNETAPI_LOCAL_SERVER(server_name)) {
werr = NetGetJoinInformation_l(ctx, &r);
} else {
werr = NetGetJoinInformation_r(ctx, &r);
}
r.out.result = W_ERROR_V(werr);
if (DEBUGLEVEL >= 10) {
NDR_PRINT_OUT_DEBUG(NetGetJoinInformation, &r);
}
return r.out.result;
}
/****************************************************************
NetGetJoinableOUs
****************************************************************/
NET_API_STATUS NetGetJoinableOUs(const char * server_name /* [in] [unique] */,
const char * domain /* [in] [ref] */,
const char * account /* [in] [unique] */,
const char * password /* [in] [unique] */,
uint32_t *ou_count /* [out] [ref] */,
const char * **ous /* [out] [ref] */)
{
struct NetGetJoinableOUs r;
struct libnetapi_ctx *ctx = NULL;
NET_API_STATUS status;
WERROR werr;
status = libnetapi_getctx(&ctx);
if (status != 0) {
return status;
}
/* In parameters */
r.in.server_name = server_name;
r.in.domain = domain;
r.in.account = account;
r.in.password = password;
/* Out parameters */
r.out.ou_count = ou_count;
r.out.ous = ous;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_IN_DEBUG(NetGetJoinableOUs, &r);
}
if (LIBNETAPI_LOCAL_SERVER(server_name)) {
werr = NetGetJoinableOUs_l(ctx, &r);
} else {
werr = NetGetJoinableOUs_r(ctx, &r);
}
r.out.result = W_ERROR_V(werr);
if (DEBUGLEVEL >= 10) {
NDR_PRINT_OUT_DEBUG(NetGetJoinableOUs, &r);
}
return r.out.result;
}
/****************************************************************
NetServerGetInfo
****************************************************************/
NET_API_STATUS NetServerGetInfo(const char * server_name /* [in] [unique] */,
uint32_t level /* [in] */,
uint8_t **buffer /* [out] [ref] */)
{
struct NetServerGetInfo r;
struct libnetapi_ctx *ctx = NULL;
NET_API_STATUS status;
WERROR werr;
status = libnetapi_getctx(&ctx);
if (status != 0) {
return status;
}
/* In parameters */
r.in.server_name = server_name;
r.in.level = level;
/* Out parameters */
r.out.buffer = buffer;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_IN_DEBUG(NetServerGetInfo, &r);
}
if (LIBNETAPI_LOCAL_SERVER(server_name)) {
werr = NetServerGetInfo_l(ctx, &r);
} else {
werr = NetServerGetInfo_r(ctx, &r);
}
r.out.result = W_ERROR_V(werr);
if (DEBUGLEVEL >= 10) {
NDR_PRINT_OUT_DEBUG(NetServerGetInfo, &r);
}
return r.out.result;
}
/****************************************************************
NetServerSetInfo
****************************************************************/
NET_API_STATUS NetServerSetInfo(const char * server_name /* [in] [unique] */,
uint32_t level /* [in] */,
uint8_t *buffer /* [in] [ref] */,
uint32_t *parm_error /* [out] [ref] */)
{
struct NetServerSetInfo r;
struct libnetapi_ctx *ctx = NULL;
NET_API_STATUS status;
WERROR werr;
status = libnetapi_getctx(&ctx);
if (status != 0) {
return status;
}
/* In parameters */
r.in.server_name = server_name;
r.in.level = level;
r.in.buffer = buffer;
/* Out parameters */
r.out.parm_error = parm_error;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_IN_DEBUG(NetServerSetInfo, &r);
}
if (LIBNETAPI_LOCAL_SERVER(server_name)) {
werr = NetServerSetInfo_l(ctx, &r);
} else {
werr = NetServerSetInfo_r(ctx, &r);
}
r.out.result = W_ERROR_V(werr);
if (DEBUGLEVEL >= 10) {
NDR_PRINT_OUT_DEBUG(NetServerSetInfo, &r);
}
return r.out.result;
}
/****************************************************************
NetGetDCName
****************************************************************/
NET_API_STATUS NetGetDCName(const char * server_name /* [in] [unique] */,
const char * domain_name /* [in] [unique] */,
uint8_t **buffer /* [out] [ref] */)
{
struct NetGetDCName r;
struct libnetapi_ctx *ctx = NULL;
NET_API_STATUS status;
WERROR werr;
status = libnetapi_getctx(&ctx);
if (status != 0) {
return status;
}
/* In parameters */
r.in.server_name = server_name;
r.in.domain_name = domain_name;
/* Out parameters */
r.out.buffer = buffer;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_IN_DEBUG(NetGetDCName, &r);
}
if (LIBNETAPI_LOCAL_SERVER(server_name)) {
werr = NetGetDCName_l(ctx, &r);
} else {
werr = NetGetDCName_r(ctx, &r);
}
r.out.result = W_ERROR_V(werr);
if (DEBUGLEVEL >= 10) {
NDR_PRINT_OUT_DEBUG(NetGetDCName, &r);
}
return r.out.result;
}
/****************************************************************
NetGetAnyDCName
****************************************************************/
NET_API_STATUS NetGetAnyDCName(const char * server_name /* [in] [unique] */,
const char * domain_name /* [in] [unique] */,
uint8_t **buffer /* [out] [ref] */)
{
struct NetGetAnyDCName r;
struct libnetapi_ctx *ctx = NULL;
NET_API_STATUS status;
WERROR werr;
status = libnetapi_getctx(&ctx);
if (status != 0) {
return status;
}
/* In parameters */
r.in.server_name = server_name;
r.in.domain_name = domain_name;
/* Out parameters */
r.out.buffer = buffer;
if (DEBUGLEVEL >= 10) {
NDR_PRINT_IN_DEBUG(NetGetAnyDCName, &r);
}
if (LIBNETAPI_LOCAL_SERVER(server_name)) {
werr = NetGetAnyDCName_l(ctx, &r);
} else {
werr = NetGetAnyDCName_r(ctx, &r);
}
r.out.result = W_ERROR_V(werr);
if (DEBUGLEVEL >= 10) {
NDR_PRINT_OUT_DEBUG(NetGetAnyDCName, &r);
}
return r.out.result;
}

View File

@ -0,0 +1,67 @@
#ifndef __LIBNETAPI_LIBNETAPI__
#define __LIBNETAPI_LIBNETAPI__
NET_API_STATUS NetJoinDomain(const char * server /* [in] [unique] */,
const char * domain /* [in] [ref] */,
const char * account_ou /* [in] [unique] */,
const char * account /* [in] [unique] */,
const char * password /* [in] [unique] */,
uint32_t join_flags /* [in] */);
WERROR NetJoinDomain_r(struct libnetapi_ctx *ctx,
struct NetJoinDomain *r);
WERROR NetJoinDomain_l(struct libnetapi_ctx *ctx,
struct NetJoinDomain *r);
NET_API_STATUS NetUnjoinDomain(const char * server_name /* [in] [unique] */,
const char * account /* [in] [unique] */,
const char * password /* [in] [unique] */,
uint32_t unjoin_flags /* [in] */);
WERROR NetUnjoinDomain_r(struct libnetapi_ctx *ctx,
struct NetUnjoinDomain *r);
WERROR NetUnjoinDomain_l(struct libnetapi_ctx *ctx,
struct NetUnjoinDomain *r);
NET_API_STATUS NetGetJoinInformation(const char * server_name /* [in] [unique] */,
const char * *name_buffer /* [out] [ref] */,
uint16_t *name_type /* [out] [ref] */);
WERROR NetGetJoinInformation_r(struct libnetapi_ctx *ctx,
struct NetGetJoinInformation *r);
WERROR NetGetJoinInformation_l(struct libnetapi_ctx *ctx,
struct NetGetJoinInformation *r);
NET_API_STATUS NetGetJoinableOUs(const char * server_name /* [in] [unique] */,
const char * domain /* [in] [ref] */,
const char * account /* [in] [unique] */,
const char * password /* [in] [unique] */,
uint32_t *ou_count /* [out] [ref] */,
const char * **ous /* [out] [ref] */);
WERROR NetGetJoinableOUs_r(struct libnetapi_ctx *ctx,
struct NetGetJoinableOUs *r);
WERROR NetGetJoinableOUs_l(struct libnetapi_ctx *ctx,
struct NetGetJoinableOUs *r);
NET_API_STATUS NetServerGetInfo(const char * server_name /* [in] [unique] */,
uint32_t level /* [in] */,
uint8_t **buffer /* [out] [ref] */);
WERROR NetServerGetInfo_r(struct libnetapi_ctx *ctx,
struct NetServerGetInfo *r);
WERROR NetServerGetInfo_l(struct libnetapi_ctx *ctx,
struct NetServerGetInfo *r);
NET_API_STATUS NetServerSetInfo(const char * server_name /* [in] [unique] */,
uint32_t level /* [in] */,
uint8_t *buffer /* [in] [ref] */,
uint32_t *parm_error /* [out] [ref] */);
WERROR NetServerSetInfo_r(struct libnetapi_ctx *ctx,
struct NetServerSetInfo *r);
WERROR NetServerSetInfo_l(struct libnetapi_ctx *ctx,
struct NetServerSetInfo *r);
NET_API_STATUS NetGetDCName(const char * server_name /* [in] [unique] */,
const char * domain_name /* [in] [unique] */,
uint8_t **buffer /* [out] [ref] */);
WERROR NetGetDCName_r(struct libnetapi_ctx *ctx,
struct NetGetDCName *r);
WERROR NetGetDCName_l(struct libnetapi_ctx *ctx,
struct NetGetDCName *r);
NET_API_STATUS NetGetAnyDCName(const char * server_name /* [in] [unique] */,
const char * domain_name /* [in] [unique] */,
uint8_t **buffer /* [out] [ref] */);
WERROR NetGetAnyDCName_r(struct libnetapi_ctx *ctx,
struct NetGetAnyDCName *r);
WERROR NetGetAnyDCName_l(struct libnetapi_ctx *ctx,
struct NetGetAnyDCName *r);
#endif /* __LIBNETAPI_LIBNETAPI__ */

View File

@ -20,23 +20,13 @@
#ifndef __LIB_NETAPI_H__
#define __LIB_NETAPI_H__
/****************************************************************
include some basic headers
****************************************************************/
#include <inttypes.h>
/****************************************************************
NET_API_STATUS
****************************************************************/
#define NET_API_STATUS uint32_t
#define NET_API_STATUS_SUCCESS 0
/****************************************************************
****************************************************************/
#define LIBNETAPI_LOCAL_SERVER(x) (!x || is_myname_or_ipaddr(x))
typedef enum {
NET_API_STATUS_SUCCESS = 0
} NET_API_STATUS;
/****************************************************************
****************************************************************/
@ -76,72 +66,72 @@ NET_API_STATUS NetApiBufferFree(void *buffer);
NetJoinDomain
****************************************************************/
NET_API_STATUS NetJoinDomain(const char *server,
const char *domain,
const char *account_ou,
const char *account,
const char *password,
uint32_t join_options);
NET_API_STATUS NetJoinDomain(const char * server /* [in] */,
const char * domain /* [in] [ref] */,
const char * account_ou /* [in] */,
const char * account /* [in] */,
const char * password /* [in] */,
uint32_t join_flags /* [in] */);
/****************************************************************
NetUnjoinDomain
****************************************************************/
NET_API_STATUS NetUnjoinDomain(const char *server_name,
const char *account,
const char *password,
uint32_t unjoin_flags);
NET_API_STATUS NetUnjoinDomain(const char * server_name /* [in] */,
const char * account /* [in] */,
const char * password /* [in] */,
uint32_t unjoin_flags /* [in] */);
/****************************************************************
NetGetJoinInformation
****************************************************************/
NET_API_STATUS NetGetJoinInformation(const char *server_name,
const char **name_buffer,
uint16_t *name_type);
NET_API_STATUS NetGetJoinInformation(const char * server_name /* [in] */,
const char * *name_buffer /* [out] [ref] */,
uint16_t *name_type /* [out] [ref] */);
/****************************************************************
NetGetJoinableOUs
****************************************************************/
NET_API_STATUS NetGetJoinableOUs(const char *server_name,
const char *domain,
const char *account,
const char *password,
uint32_t *ou_count,
const char ***ous);
NET_API_STATUS NetGetJoinableOUs(const char * server_name /* [in] */,
const char * domain /* [in] [ref] */,
const char * account /* [in] */,
const char * password /* [in] */,
uint32_t *ou_count /* [out] [ref] */,
const char * **ous /* [out] [ref] */);
/****************************************************************
NetServerGetInfo
****************************************************************/
NET_API_STATUS NetServerGetInfo(const char *server_name,
uint32_t level,
uint8_t **buffer);
NET_API_STATUS NetServerGetInfo(const char * server_name /* [in] */,
uint32_t level /* [in] */,
uint8_t **buffer /* [out] [ref] */);
/****************************************************************
NetServerSetInfo
****************************************************************/
NET_API_STATUS NetServerSetInfo(const char *server_name,
uint32_t level,
uint8_t *buffer,
uint32_t *parm_error);
NET_API_STATUS NetServerSetInfo(const char * server_name /* [in] */,
uint32_t level /* [in] */,
uint8_t *buffer /* [in] [ref] */,
uint32_t *parm_error /* [out] [ref] */);
/****************************************************************
NetGetDCName
****************************************************************/
NET_API_STATUS NetGetDCName(const char *server_name,
const char *domain_name,
uint8_t **buffer);
NET_API_STATUS NetGetDCName(const char * server_name /* [in] */,
const char * domain_name /* [in] */,
uint8_t **buffer /* [out] [ref] */);
/****************************************************************
NetGetAnyDCName
****************************************************************/
NET_API_STATUS NetGetAnyDCName(const char *server_name,
const char *domain_name,
uint8_t **buffer);
NET_API_STATUS NetGetAnyDCName(const char * server_name /* [in] */,
const char * domain_name /* [in] */,
uint8_t **buffer /* [out] [ref] */);
#endif

View File

@ -19,14 +19,16 @@
#include "includes.h"
#include "librpc/gen_ndr/libnetapi.h"
#include "lib/netapi/netapi.h"
#include "lib/netapi/libnetapi.h"
#include "libnet/libnet.h"
/****************************************************************
****************************************************************/
static WERROR NetServerGetInfoLocal_1005(struct libnetapi_ctx *ctx,
uint8_t **buffer)
static WERROR NetServerGetInfo_l_1005(struct libnetapi_ctx *ctx,
uint8_t **buffer)
{
struct srvsvc_NetSrvInfo1005 info1005;
@ -42,14 +44,12 @@ static WERROR NetServerGetInfoLocal_1005(struct libnetapi_ctx *ctx,
/****************************************************************
****************************************************************/
static WERROR NetServerGetInfoLocal(struct libnetapi_ctx *ctx,
const char *server_name,
uint32_t level,
uint8_t **buffer)
WERROR NetServerGetInfo_l(struct libnetapi_ctx *ctx,
struct NetServerGetInfo *r)
{
switch (level) {
switch (r->in.level) {
case 1005:
return NetServerGetInfoLocal_1005(ctx, buffer);
return NetServerGetInfo_l_1005(ctx, r->out.buffer);
default:
return WERR_UNKNOWN_LEVEL;
}
@ -60,10 +60,8 @@ static WERROR NetServerGetInfoLocal(struct libnetapi_ctx *ctx,
/****************************************************************
****************************************************************/
static WERROR NetServerGetInfoRemote(struct libnetapi_ctx *ctx,
const char *server_name,
uint32_t level,
uint8_t **buffer)
WERROR NetServerGetInfo_r(struct libnetapi_ctx *ctx,
struct NetServerGetInfo *r)
{
struct cli_state *cli = NULL;
struct rpc_pipe_client *pipe_cli = NULL;
@ -71,7 +69,7 @@ static WERROR NetServerGetInfoRemote(struct libnetapi_ctx *ctx,
WERROR werr;
union srvsvc_NetSrvInfo info;
status = cli_full_connection(&cli, NULL, server_name,
status = cli_full_connection(&cli, NULL, r->in.server_name,
NULL, 0,
"IPC$", "IPC",
ctx->username,
@ -92,8 +90,8 @@ static WERROR NetServerGetInfoRemote(struct libnetapi_ctx *ctx,
};
status = rpccli_srvsvc_NetSrvGetInfo(pipe_cli, ctx,
server_name,
level,
r->in.server_name,
r->in.level,
&info,
&werr);
if (!NT_STATUS_IS_OK(status)) {
@ -101,7 +99,11 @@ static WERROR NetServerGetInfoRemote(struct libnetapi_ctx *ctx,
goto done;
}
*buffer = (uint8_t *)&info;
*r->out.buffer = talloc_memdup(ctx, &info, sizeof(info));
if (!*r->out.buffer) {
werr = WERR_NOMEM;
goto done;
}
done:
if (cli) {
@ -114,73 +116,22 @@ static WERROR NetServerGetInfoRemote(struct libnetapi_ctx *ctx,
/****************************************************************
****************************************************************/
static WERROR libnetapi_NetServerGetInfo(struct libnetapi_ctx *ctx,
const char *server_name,
uint32_t level,
uint8_t **buffer)
{
if (!server_name || is_myname_or_ipaddr(server_name)) {
return NetServerGetInfoLocal(ctx,
server_name,
level,
buffer);
}
return NetServerGetInfoRemote(ctx,
server_name,
level,
buffer);
}
/****************************************************************
NetServerGetInfo
****************************************************************/
NET_API_STATUS NetServerGetInfo(const char *server_name,
uint32_t level,
uint8_t **buffer)
{
struct libnetapi_ctx *ctx = NULL;
NET_API_STATUS status;
WERROR werr;
status = libnetapi_getctx(&ctx);
if (status != 0) {
return status;
}
werr = libnetapi_NetServerGetInfo(ctx,
server_name,
level,
buffer);
if (!W_ERROR_IS_OK(werr)) {
return W_ERROR_V(werr);
}
return NET_API_STATUS_SUCCESS;
}
/****************************************************************
****************************************************************/
static WERROR NetServerSetInfoLocal_1005(struct libnetapi_ctx *ctx,
uint8_t *buffer,
uint32_t *parm_error)
static WERROR NetServerSetInfo_l_1005(struct libnetapi_ctx *ctx,
struct NetServerSetInfo *r)
{
WERROR werr;
struct smbconf_ctx *conf_ctx;
struct srvsvc_NetSrvInfo1005 *info1005;
if (!buffer) {
*parm_error = 1005; /* sure here ? */
if (!r->in.buffer) {
*r->out.parm_error = 1005; /* sure here ? */
return WERR_INVALID_PARAM;
}
info1005 = (struct srvsvc_NetSrvInfo1005 *)buffer;
info1005 = (struct srvsvc_NetSrvInfo1005 *)r->in.buffer;
if (!info1005->comment) {
*parm_error = 1005;
*r->out.parm_error = 1005;
return WERR_INVALID_PARAM;
}
@ -207,15 +158,12 @@ static WERROR NetServerSetInfoLocal_1005(struct libnetapi_ctx *ctx,
/****************************************************************
****************************************************************/
static WERROR NetServerSetInfoLocal(struct libnetapi_ctx *ctx,
const char *server_name,
uint32_t level,
uint8_t *buffer,
uint32_t *parm_error)
WERROR NetServerSetInfo_l(struct libnetapi_ctx *ctx,
struct NetServerSetInfo *r)
{
switch (level) {
switch (r->in.level) {
case 1005:
return NetServerSetInfoLocal_1005(ctx, buffer, parm_error);
return NetServerSetInfo_l_1005(ctx, r);
default:
return WERR_UNKNOWN_LEVEL;
}
@ -226,11 +174,8 @@ static WERROR NetServerSetInfoLocal(struct libnetapi_ctx *ctx,
/****************************************************************
****************************************************************/
static WERROR NetServerSetInfoRemote(struct libnetapi_ctx *ctx,
const char *server_name,
uint32_t level,
uint8_t *buffer,
uint32_t *parm_error)
WERROR NetServerSetInfo_r(struct libnetapi_ctx *ctx,
struct NetServerSetInfo *r)
{
struct cli_state *cli = NULL;
struct rpc_pipe_client *pipe_cli = NULL;
@ -238,7 +183,7 @@ static WERROR NetServerSetInfoRemote(struct libnetapi_ctx *ctx,
WERROR werr;
union srvsvc_NetSrvInfo info;
status = cli_full_connection(&cli, NULL, server_name,
status = cli_full_connection(&cli, NULL, r->in.server_name,
NULL, 0,
"IPC$", "IPC",
ctx->username,
@ -258,9 +203,9 @@ static WERROR NetServerSetInfoRemote(struct libnetapi_ctx *ctx,
goto done;
};
switch (level) {
switch (r->in.level) {
case 1005:
info.info1005 = (struct srvsvc_NetSrvInfo1005 *)buffer;
info.info1005 = (struct srvsvc_NetSrvInfo1005 *)r->in.buffer;
break;
default:
werr = WERR_NOT_SUPPORTED;
@ -268,10 +213,10 @@ static WERROR NetServerSetInfoRemote(struct libnetapi_ctx *ctx,
}
status = rpccli_srvsvc_NetSrvSetInfo(pipe_cli, ctx,
server_name,
level,
r->in.server_name,
r->in.level,
&info,
parm_error,
r->out.parm_error,
&werr);
if (!NT_STATUS_IS_OK(status)) {
werr = ntstatus_to_werror(status);
@ -285,57 +230,3 @@ static WERROR NetServerSetInfoRemote(struct libnetapi_ctx *ctx,
return werr;
}
/****************************************************************
****************************************************************/
static WERROR libnetapi_NetServerSetInfo(struct libnetapi_ctx *ctx,
const char *server_name,
uint32_t level,
uint8_t *buffer,
uint32_t *parm_error)
{
if (!server_name || is_myname_or_ipaddr(server_name)) {
return NetServerSetInfoLocal(ctx,
server_name,
level,
buffer,
parm_error);
}
return NetServerSetInfoRemote(ctx,
server_name,
level,
buffer,
parm_error);
}
/****************************************************************
NetServerSetInfo
****************************************************************/
NET_API_STATUS NetServerSetInfo(const char *server_name,
uint32_t level,
uint8_t *buffer,
uint32_t *parm_error)
{
struct libnetapi_ctx *ctx = NULL;
NET_API_STATUS status;
WERROR werr;
status = libnetapi_getctx(&ctx);
if (status != 0) {
return status;
}
werr = libnetapi_NetServerSetInfo(ctx,
server_name,
level,
buffer,
parm_error);
if (!W_ERROR_IS_OK(werr)) {
return W_ERROR_V(werr);
}
return NET_API_STATUS_SUCCESS;
}