#include "includes.h"
#include "torture/torture.h"
#include "librpc/gen_ndr/ndr_wkssvc_c.h"
-#include "torture/rpc/rpc.h"
+#include "torture/rpc/torture_rpc.h"
#include "lib/cmdline/popt_common.h"
#include "param/param.h"
#include "../lib/crypto/crypto.h"
union wkssvc_NetWkstaInfo info;
uint16_t levels[] = {100, 101, 102, 502};
int i;
+ struct dcerpc_binding_handle *b = p->binding_handle;
r.in.server_name = dcerpc_server_name(p);
r.out.info = &info;
for (i=0;i<ARRAY_SIZE(levels);i++) {
r.in.level = levels[i];
- torture_comment(tctx, "testing NetWkstaGetInfo level %u\n",
+ torture_comment(tctx, "Testing NetWkstaGetInfo level %u\n",
r.in.level);
- status = dcerpc_wkssvc_NetWkstaGetInfo(p, tctx, &r);
+ status = dcerpc_wkssvc_NetWkstaGetInfo_r(b, tctx, &r);
torture_assert_ntstatus_ok(tctx, status,
talloc_asprintf(tctx, "NetWkstaGetInfo level %u failed",
r.in.level));
union wkssvc_NetWkstaTransportCtr ctr;
struct wkssvc_NetWkstaTransportCtr0 ctr0;
uint32_t total_entries = 0;
+ struct dcerpc_binding_handle *b = p->binding_handle;
ZERO_STRUCT(ctr0);
ctr.ctr0 = &ctr0;
r.out.info = &info;
r.out.resume_handle = &resume_handle;
- torture_comment(tctx, "testing NetWkstaTransportEnum level 0\n");
+ torture_comment(tctx, "Testing NetWkstaTransportEnum level 0\n");
- status = dcerpc_wkssvc_NetWkstaTransportEnum(p, tctx, &r);
+ status = dcerpc_wkssvc_NetWkstaTransportEnum_r(b, tctx, &r);
torture_assert_ntstatus_ok(tctx, status,
"NetWkstaTransportEnum failed");
torture_assert_werr_ok(tctx, r.out.result, talloc_asprintf(tctx,
struct wkssvc_NetrWkstaTransportAdd r;
struct wkssvc_NetWkstaTransportInfo0 info0;
uint32_t parm_err = 0;
+ struct dcerpc_binding_handle *b = p->binding_handle;
ZERO_STRUCT(info0);
r.in.info0 = &info0;
r.in.parm_err = r.out.parm_err = &parm_err;
- torture_comment(tctx, "testing NetrWkstaTransportAdd level 0\n");
+ torture_comment(tctx, "Testing NetrWkstaTransportAdd level 0\n");
- status = dcerpc_wkssvc_NetrWkstaTransportAdd(p, tctx, &r);
+ status = dcerpc_wkssvc_NetrWkstaTransportAdd_r(b, tctx, &r);
torture_assert_ntstatus_ok(tctx, status,
"NetrWkstaTransportAdd failed");
torture_assert_werr_equal(tctx, r.out.result,
{
NTSTATUS status;
struct wkssvc_NetrWkstaTransportDel r;
+ struct dcerpc_binding_handle *b = p->binding_handle;
r.in.server_name = dcerpc_server_name(p);
r.in.transport_name = SMBTORTURE_TRANSPORT_NAME;
r.in.unknown3 = 0;
- torture_comment(tctx, "testing NetrWkstaTransportDel\n");
+ torture_comment(tctx, "Testing NetrWkstaTransportDel\n");
- status = dcerpc_wkssvc_NetrWkstaTransportDel(p, tctx, &r);
+ status = dcerpc_wkssvc_NetrWkstaTransportDel_r(b, tctx, &r);
torture_assert_ntstatus_ok(tctx, status,
"NetrWkstaTransportDel failed");
torture_assert_werr_ok(tctx, r.out.result,
struct wkssvc_NetWkstaEnumUsersCtr1 *user1;
uint32_t levels[] = { 0, 1 };
int i;
+ struct dcerpc_binding_handle *b = p->binding_handle;
for (i=0; i<ARRAY_SIZE(levels); i++) {
r.out.entries_read = &entries_read;
- torture_comment(tctx, "testing NetWkstaEnumUsers level %u\n",
+ torture_comment(tctx, "Testing NetWkstaEnumUsers level %u\n",
levels[i]);
- status = dcerpc_wkssvc_NetWkstaEnumUsers(p, tctx, &r);
+ status = dcerpc_wkssvc_NetWkstaEnumUsers_r(b, tctx, &r);
torture_assert_ntstatus_ok(tctx, status,
"NetWkstaEnumUsers failed");
torture_assert_werr_ok(tctx, r.out.result,
NTSTATUS status;
struct wkssvc_NetrWkstaUserGetInfo r;
union wkssvc_NetrWkstaUserInfo info;
- const char *dom = lp_workgroup(tctx->lp_ctx);
+ const char *dom = lpcfg_workgroup(tctx->lp_ctx);
struct cli_credentials *creds = cmdline_credentials;
const char *user = cli_credentials_get_username(creds);
int i;
+ struct dcerpc_binding_handle *b = p->binding_handle;
const struct {
const char *unknown;
r.in.level = tests[i].level;
r.out.info = &info;
- torture_comment(tctx, "testing NetrWkstaUserGetInfo level %u\n",
+ torture_comment(tctx, "Testing NetrWkstaUserGetInfo level %u\n",
r.in.level);
- status = dcerpc_wkssvc_NetrWkstaUserGetInfo(p, tctx, &r);
+ status = dcerpc_wkssvc_NetrWkstaUserGetInfo_r(b, tctx, &r);
torture_assert_ntstatus_ok(tctx, status,
"NetrWkstaUserGetInfo failed");
torture_assert_werr_equal(tctx, r.out.result,
struct wkssvc_NetrUseEnumCtr2 *use2;
uint32_t levels[] = { 0, 1, 2 };
int i;
+ struct dcerpc_binding_handle *b = p->binding_handle;
for (i=0; i<ARRAY_SIZE(levels); i++) {
r.out.entries_read = &entries_read;
- torture_comment(tctx, "testing NetrUseEnum level %u\n",
+ torture_comment(tctx, "Testing NetrUseEnum level %u\n",
levels[i]);
- status = dcerpc_wkssvc_NetrUseEnum(p, tctx, &r);
+ status = dcerpc_wkssvc_NetrUseEnum_r(b, tctx, &r);
torture_assert_ntstatus_ok(tctx, status,
"NetrUseEnum failed");
torture_assert_werr_ok(tctx, r.out.result,
struct wkssvc_NetrUseInfo1 info1;
union wkssvc_NetrUseGetInfoCtr *ctr;
uint32_t parm_err = 0;
+ struct dcerpc_binding_handle *b = p->binding_handle;
ctr = talloc(tctx, union wkssvc_NetrUseGetInfoCtr);
r.in.ctr = ctr;
r.in.parm_err = r.out.parm_err = &parm_err;
- torture_comment(tctx, "testing NetrUseAdd level %u\n",
+ torture_comment(tctx, "Testing NetrUseAdd level %u\n",
r.in.level);
- status = dcerpc_wkssvc_NetrUseAdd(p, tctx, &r);
+ status = dcerpc_wkssvc_NetrUseAdd_r(b, tctx, &r);
torture_assert_ntstatus_ok(tctx, status,
"NetrUseAdd failed");
torture_assert_werr_equal(tctx, r.out.result, WERR_UNKNOWN_LEVEL,
r.in.ctr = ctr;
r.in.parm_err = r.out.parm_err = &parm_err;
- torture_comment(tctx, "testing NetrUseAdd level %u\n",
+ torture_comment(tctx, "Testing NetrUseAdd level %u\n",
r.in.level);
- status = dcerpc_wkssvc_NetrUseAdd(p, tctx, &r);
+ status = dcerpc_wkssvc_NetrUseAdd_r(b, tctx, &r);
torture_assert_ntstatus_ok(tctx, status,
"NetrUseAdd failed");
torture_assert_werr_ok(tctx, r.out.result,
{
NTSTATUS status;
struct wkssvc_NetrUseDel r;
+ struct dcerpc_binding_handle *b = p->binding_handle;
r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
r.in.use_name = SMBTORTURE_USE_NAME;
r.in.force_cond = 0;
- torture_comment(tctx, "testing NetrUseDel\n");
+ torture_comment(tctx, "Testing NetrUseDel\n");
- status = dcerpc_wkssvc_NetrUseDel(p, tctx, &r);
+ status = dcerpc_wkssvc_NetrUseDel_r(b, tctx, &r);
torture_assert_ntstatus_ok(tctx, status,
"NetrUseDel failed");
torture_assert_werr_ok(tctx, r.out.result,
NTSTATUS status;
struct wkssvc_NetrUseGetInfo r;
union wkssvc_NetrUseGetInfoCtr ctr;
+ struct dcerpc_binding_handle *b = p->binding_handle;
ZERO_STRUCT(ctr);
r.in.use_name = use_name;
r.in.level = level;
r.out.ctr = &ctr;
- status = dcerpc_wkssvc_NetrUseGetInfo(p, tctx, &r);
+ status = dcerpc_wkssvc_NetrUseGetInfo_r(b, tctx, &r);
torture_assert_ntstatus_ok(tctx, status,
"NetrUseGetInfo failed");
uint32_t levels[] = { 0, 1, 2 };
const char *use_name = NULL;
int i, k;
+ struct dcerpc_binding_handle *b = p->binding_handle;
ZERO_STRUCT(info);
r.in.resume_handle = r.out.resume_handle = &handle;
r.out.entries_read = &entries_read;
- status = dcerpc_wkssvc_NetrUseEnum(p, tctx, &r);
+ status = dcerpc_wkssvc_NetrUseEnum_r(b, tctx, &r);
torture_assert_ntstatus_ok(tctx, status,
"NetrUseEnum failed");
torture_assert_werr_ok(tctx, r.out.result,
{
NTSTATUS status;
struct wkssvc_NetrLogonDomainNameAdd r;
+ struct dcerpc_binding_handle *b = p->binding_handle;
- r.in.domain_name = lp_workgroup(tctx->lp_ctx);
+ r.in.domain_name = lpcfg_workgroup(tctx->lp_ctx);
- torture_comment(tctx, "testing NetrLogonDomainNameAdd\n");
+ torture_comment(tctx, "Testing NetrLogonDomainNameAdd\n");
- status = dcerpc_wkssvc_NetrLogonDomainNameAdd(p, tctx, &r);
+ status = dcerpc_wkssvc_NetrLogonDomainNameAdd_r(b, tctx, &r);
torture_assert_ntstatus_ok(tctx, status,
"NetrLogonDomainNameAdd failed");
torture_assert_werr_equal(tctx, r.out.result, WERR_NOT_SUPPORTED,
{
NTSTATUS status;
struct wkssvc_NetrLogonDomainNameDel r;
+ struct dcerpc_binding_handle *b = p->binding_handle;
- r.in.domain_name = lp_workgroup(tctx->lp_ctx);
+ r.in.domain_name = lpcfg_workgroup(tctx->lp_ctx);
- torture_comment(tctx, "testing NetrLogonDomainNameDel\n");
+ torture_comment(tctx, "Testing NetrLogonDomainNameDel\n");
- status = dcerpc_wkssvc_NetrLogonDomainNameDel(p, tctx, &r);
+ status = dcerpc_wkssvc_NetrLogonDomainNameDel_r(b, tctx, &r);
torture_assert_ntstatus_ok(tctx, status,
"NetrLogonDomainNameDel failed");
torture_assert_werr_equal(tctx, r.out.result, WERR_NOT_SUPPORTED,
struct wkssvc_NetrEnumerateComputerNames r;
struct wkssvc_ComputerNamesCtr *ctr;
int i;
+ struct dcerpc_binding_handle *b = p->binding_handle;
ctr = talloc_zero(tctx, struct wkssvc_ComputerNamesCtr);
r.in.Reserved = 0;
r.out.ctr = &ctr;
- torture_comment(tctx, "testing NetrEnumerateComputerNames level %u\n",
+ torture_comment(tctx, "Testing NetrEnumerateComputerNames level %u\n",
r.in.name_type);
- status = dcerpc_wkssvc_NetrEnumerateComputerNames(p, tctx, &r);
+ status = dcerpc_wkssvc_NetrEnumerateComputerNames_r(b, tctx, &r);
torture_assert_ntstatus_ok(tctx, status,
"NetrEnumerateComputerNames failed");
torture_assert_werr_ok(tctx, r.out.result,
struct wkssvc_NetrValidateName r;
uint16_t levels[] = {0,1,2,3,4,5};
int i;
+ struct dcerpc_binding_handle *b = p->binding_handle;
for (i=0; i<ARRAY_SIZE(levels); i++) {
r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
- r.in.name = lp_workgroup(tctx->lp_ctx);
+ r.in.name = lpcfg_workgroup(tctx->lp_ctx);
r.in.Account = NULL;
r.in.Password = NULL;
r.in.name_type = levels[i];
- torture_comment(tctx, "testing NetrValidateName level %u\n",
+ torture_comment(tctx, "Testing NetrValidateName level %u\n",
r.in.name_type);
- status = dcerpc_wkssvc_NetrValidateName(p, tctx, &r);
+ status = dcerpc_wkssvc_NetrValidateName_r(b, tctx, &r);
torture_assert_ntstatus_ok(tctx, status,
"NetrValidateName failed");
torture_assert_werr_equal(tctx, r.out.result,
struct wkssvc_NetrValidateName2 r;
uint16_t levels[] = {0,1,2,3,4,5};
int i;
+ struct dcerpc_binding_handle *b = p->binding_handle;
for (i=0; i<ARRAY_SIZE(levels); i++) {
r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
- r.in.name = lp_workgroup(tctx->lp_ctx);
+ r.in.name = lpcfg_workgroup(tctx->lp_ctx);
r.in.Account = NULL;
r.in.EncryptedPassword = NULL;
r.in.name_type = levels[i];
- torture_comment(tctx, "testing NetrValidateName2 level %u\n",
+ torture_comment(tctx, "Testing NetrValidateName2 level %u\n",
r.in.name_type);
- status = dcerpc_wkssvc_NetrValidateName2(p, tctx, &r);
+ status = dcerpc_wkssvc_NetrValidateName2_r(b, tctx, &r);
torture_assert_ntstatus_ok(tctx, status,
"NetrValidateName2 failed");
torture_assert_werr_equal(tctx, r.out.result,
const char **names = NULL;
int num_names = 0;
int i;
+ struct dcerpc_binding_handle *b = p->binding_handle;
r.in.server_name = dcerpc_server_name(p);
r.in.NewAlternateMachineName = SMBTORTURE_ALTERNATE_NAME;
r.in.EncryptedPassword = NULL;
r.in.Reserved = 0;
- torture_comment(tctx, "testing NetrAddAlternateComputerName\n");
+ torture_comment(tctx, "Testing NetrAddAlternateComputerName\n");
- status = dcerpc_wkssvc_NetrAddAlternateComputerName(p, tctx, &r);
+ status = dcerpc_wkssvc_NetrAddAlternateComputerName_r(b, tctx, &r);
torture_assert_ntstatus_ok(tctx, status,
"NetrAddAlternateComputerName failed");
torture_assert_werr_ok(tctx, r.out.result,
const char **names = NULL;
int num_names = 0;
int i;
+ struct dcerpc_binding_handle *b = p->binding_handle;
r.in.server_name = dcerpc_server_name(p);
r.in.AlternateMachineNameToRemove = SMBTORTURE_ALTERNATE_NAME;
r.in.EncryptedPassword = NULL;
r.in.Reserved = 0;
- torture_comment(tctx, "testing NetrRemoveAlternateComputerName\n");
+ torture_comment(tctx, "Testing NetrRemoveAlternateComputerName\n");
- status = dcerpc_wkssvc_NetrRemoveAlternateComputerName(p, tctx, &r);
+ status = dcerpc_wkssvc_NetrRemoveAlternateComputerName_r(b, tctx, &r);
torture_assert_ntstatus_ok(tctx, status,
"NetrRemoveAlternateComputerName failed");
torture_assert_werr_ok(tctx, r.out.result,
{
NTSTATUS status;
struct wkssvc_NetrSetPrimaryComputername r;
+ struct dcerpc_binding_handle *b = p->binding_handle;
r.in.server_name = dcerpc_server_name(p);
r.in.primary_name = name;
r.in.EncryptedPassword = NULL;
r.in.Reserved = 0;
- status = dcerpc_wkssvc_NetrSetPrimaryComputername(p, tctx, &r);
+ status = dcerpc_wkssvc_NetrSetPrimaryComputername_r(b, tctx, &r);
torture_assert_ntstatus_ok(tctx, status,
"NetrSetPrimaryComputername failed");
torture_assert_werr_ok(tctx, r.out.result,
const char **names_o = NULL, **names = NULL;
int num_names_o = 0, num_names = 0;
- torture_comment(tctx, "testing NetrSetPrimaryComputername\n");
+ torture_comment(tctx, "Testing NetrSetPrimaryComputername\n");
if (!test_NetrAddAlternateComputerName(tctx, p)) {
return false;
{
NTSTATUS status;
struct wkssvc_NetrRenameMachineInDomain r;
+ struct dcerpc_binding_handle *b = p->binding_handle;
r.in.server_name = dcerpc_server_name(p);
r.in.NewMachineName = SMBTORTURE_MACHINE_NAME;
r.in.password = NULL;
r.in.RenameOptions = 0;
- torture_comment(tctx, "testing NetrRenameMachineInDomain\n");
+ torture_comment(tctx, "Testing NetrRenameMachineInDomain\n");
- status = dcerpc_wkssvc_NetrRenameMachineInDomain(p, tctx, &r);
+ status = dcerpc_wkssvc_NetrRenameMachineInDomain_r(b, tctx, &r);
torture_assert_ntstatus_ok(tctx, status,
"NetrRenameMachineInDomain failed");
torture_assert_werr_equal(tctx, r.out.result, WERR_NOT_SUPPORTED,
{
NTSTATUS status;
struct wkssvc_NetrRenameMachineInDomain2 r;
+ struct dcerpc_binding_handle *b = p->binding_handle;
r.in.server_name = dcerpc_server_name(p);
r.in.NewMachineName = new_name;
r.in.EncryptedPassword = NULL;
r.in.RenameOptions = 0;
- status = dcerpc_wkssvc_NetrRenameMachineInDomain2(p, tctx, &r);
+ status = dcerpc_wkssvc_NetrRenameMachineInDomain2_r(b, tctx, &r);
torture_assert_ntstatus_ok(tctx, status,
"NetrRenameMachineInDomain2 failed");
torture_assert_werr_ok(tctx, r.out.result,
const char **names_o = NULL, **names = NULL;
int num_names_o = 0, num_names = 0;
- torture_comment(tctx, "testing NetrRenameMachineInDomain2\n");
+ torture_comment(tctx, "Testing NetrRenameMachineInDomain2\n");
if (!test_NetrEnumerateComputerNames_level(tctx, p,
NetPrimaryComputerName,
NTSTATUS status;
struct wkssvc_NetrWorkstationStatisticsGet r;
struct wkssvc_NetrWorkstationStatistics *info;
+ struct dcerpc_binding_handle *b = p->binding_handle;
ZERO_STRUCT(r);
r.in.server_name = dcerpc_server_name(p);
r.out.info = &info;
- torture_comment(tctx, "testing NetrWorkstationStatisticsGet\n");
+ torture_comment(tctx, "Testing NetrWorkstationStatisticsGet\n");
- status = dcerpc_wkssvc_NetrWorkstationStatisticsGet(p, tctx, &r);
+ status = dcerpc_wkssvc_NetrWorkstationStatisticsGet_r(b, tctx, &r);
torture_assert_ntstatus_ok(tctx, status,
"NetrWorkstationStatisticsGet failed");
torture_assert_werr_ok(tctx, r.out.result,
struct wkssvc_NetrMessageBufferSend r;
const char *message = SMBTORTURE_MESSAGE;
size_t size;
- uint8_t *msg;
+ uint16_t *msg;
+ struct dcerpc_binding_handle *b = p->binding_handle;
- size = push_ucs2_talloc(tctx, lp_iconv_convenience(tctx->lp_ctx),
- (void **)&msg, message);
+ if (!push_ucs2_talloc(tctx, &msg, message, &size)) {
+ return false;
+ }
r.in.server_name = dcerpc_server_name(p);
r.in.message_name = dcerpc_server_name(p);
r.in.message_sender_name = dcerpc_server_name(p);
- r.in.message_buffer = msg;
+ r.in.message_buffer = (uint8_t *)msg;
r.in.message_size = size;
- torture_comment(tctx, "testing NetrMessageBufferSend\n");
+ torture_comment(tctx, "Testing NetrMessageBufferSend\n");
- status = dcerpc_wkssvc_NetrMessageBufferSend(p, tctx, &r);
+ status = dcerpc_wkssvc_NetrMessageBufferSend_r(b, tctx, &r);
torture_assert_ntstatus_ok(tctx, status,
"NetrMessageBufferSend failed");
torture_assert_werr_ok(tctx, r.out.result,
struct wkssvc_NetrGetJoinInformation r;
enum wkssvc_NetJoinStatus join_status;
const char *name_buffer = "";
+ struct dcerpc_binding_handle *b = p->binding_handle;
r.in.server_name = dcerpc_server_name(p);
r.in.name_buffer = r.out.name_buffer = &name_buffer;
r.out.name_type = &join_status;
- torture_comment(tctx, "testing NetrGetJoinInformation\n");
+ torture_comment(tctx, "Testing NetrGetJoinInformation\n");
- status = dcerpc_wkssvc_NetrGetJoinInformation(p, tctx, &r);
+ status = dcerpc_wkssvc_NetrGetJoinInformation_r(b, tctx, &r);
torture_assert_ntstatus_ok(tctx, status,
"NetrGetJoinInformation failed");
torture_assert_werr_ok(tctx, r.out.result,
struct wkssvc_NetrGetJoinInformation r;
enum wkssvc_NetJoinStatus join_status;
const char *name_buffer = "";
+ struct dcerpc_binding_handle *b = p->binding_handle;
r.in.server_name = dcerpc_server_name(p);
r.in.name_buffer = r.out.name_buffer = &name_buffer;
r.out.name_type = &join_status;
- status = dcerpc_wkssvc_NetrGetJoinInformation(p, tctx, &r);
+ status = dcerpc_wkssvc_NetrGetJoinInformation_r(b, tctx, &r);
torture_assert_ntstatus_ok(tctx, status,
"NetrGetJoinInformation failed");
torture_assert_werr_ok(tctx, r.out.result,
struct wkssvc_NetrGetJoinableOus r;
uint32_t num_ous = 0;
const char **ous = NULL;
+ struct dcerpc_binding_handle *b = p->binding_handle;
r.in.server_name = dcerpc_server_name(p);
- r.in.domain_name = lp_workgroup(tctx->lp_ctx);
+ r.in.domain_name = lpcfg_workgroup(tctx->lp_ctx);
r.in.Account = NULL;
r.in.unknown = NULL;
r.in.num_ous = r.out.num_ous = &num_ous;
r.out.ous = &ous;
- torture_comment(tctx, "testing NetrGetJoinableOus\n");
+ torture_comment(tctx, "Testing NetrGetJoinableOus\n");
- status = dcerpc_wkssvc_NetrGetJoinableOus(p, tctx, &r);
+ status = dcerpc_wkssvc_NetrGetJoinableOus_r(b, tctx, &r);
torture_assert_ntstatus_ok(tctx, status, "NetrGetJoinableOus failed");
torture_assert_werr_equal(tctx, r.out.result,
WERR_NOT_SUPPORTED,
struct wkssvc_NetrGetJoinableOus2 r;
uint32_t num_ous = 0;
const char **ous = NULL;
+ struct dcerpc_binding_handle *b = p->binding_handle;
r.in.server_name = dcerpc_server_name(p);
- r.in.domain_name = lp_workgroup(tctx->lp_ctx);
+ r.in.domain_name = lpcfg_workgroup(tctx->lp_ctx);
r.in.Account = NULL;
r.in.EncryptedPassword = NULL;
r.in.num_ous = r.out.num_ous = &num_ous;
r.out.ous = &ous;
- torture_comment(tctx, "testing NetrGetJoinableOus2\n");
+ torture_comment(tctx, "Testing NetrGetJoinableOus2\n");
- status = dcerpc_wkssvc_NetrGetJoinableOus2(p, tctx, &r);
+ status = dcerpc_wkssvc_NetrGetJoinableOus2_r(b, tctx, &r);
torture_assert_ntstatus_ok(tctx, status, "NetrGetJoinableOus2 failed");
torture_assert_werr_equal(tctx, r.out.result,
WERR_RPC_E_REMOTE_DISABLED,
struct cli_credentials *creds = cmdline_credentials;
const char *user = cli_credentials_get_username(creds);
const char *admin_account = NULL;
+ struct dcerpc_binding_handle *b = p->binding_handle;
admin_account = talloc_asprintf(tctx, "%s\\%s",
- lp_workgroup(tctx->lp_ctx),
+ lpcfg_workgroup(tctx->lp_ctx),
user);
r.in.server_name = dcerpc_server_name(p);
r.in.password = NULL;
r.in.unjoin_flags = 0;
- torture_comment(tctx, "testing NetrUnjoinDomain\n");
+ torture_comment(tctx, "Testing NetrUnjoinDomain\n");
- status = dcerpc_wkssvc_NetrUnjoinDomain(p, tctx, &r);
+ status = dcerpc_wkssvc_NetrUnjoinDomain_r(b, tctx, &r);
torture_assert_ntstatus_ok(tctx, status,
"NetrUnjoinDomain failed");
torture_assert_werr_equal(tctx, r.out.result, WERR_NOT_SUPPORTED,
struct cli_credentials *creds = cmdline_credentials;
const char *user = cli_credentials_get_username(creds);
const char *admin_account = NULL;
+ struct dcerpc_binding_handle *b = p->binding_handle;
admin_account = talloc_asprintf(tctx, "%s\\%s",
- lp_workgroup(tctx->lp_ctx),
+ lpcfg_workgroup(tctx->lp_ctx),
user);
r.in.server_name = dcerpc_server_name(p);
- r.in.domain_name = lp_realm(tctx->lp_ctx);
+ r.in.domain_name = lpcfg_dnsdomain(tctx->lp_ctx);
r.in.account_ou = NULL;
r.in.Account = admin_account;
r.in.password = NULL;
r.in.join_flags = 0;
- torture_comment(tctx, "testing NetrJoinDomain\n");
+ torture_comment(tctx, "Testing NetrJoinDomain\n");
- status = dcerpc_wkssvc_NetrJoinDomain(p, tctx, &r);
+ status = dcerpc_wkssvc_NetrJoinDomain_r(b, tctx, &r);
torture_assert_ntstatus_ok(tctx, status,
"NetrJoinDomain failed");
torture_assert_werr_equal(tctx, r.out.result, WERR_NOT_SUPPORTED,
return true;
}
-/* encode a wkssvc_PasswordBuffer for remote joining/unjoining:
- *
- * similar to samr_CryptPasswordEx. Different: 8byte confounder (instead of
- * 16byte), confounder in front of the 516 byte buffer (instead of after that
- * buffer), calling MD5Update() first with session_key and then with confounder
- * (vice versa in samr) - Guenther */
-
-static void encode_wkssvc_join_password_buffer(TALLOC_CTX *mem_ctx,
- const char *pwd,
- DATA_BLOB *session_key,
- struct wkssvc_PasswordBuffer *pwd_buf)
-{
- uint8_t buffer[516];
- struct MD5Context ctx;
-
- DATA_BLOB confounded_session_key = data_blob_talloc(mem_ctx, NULL, 16);
-
- int confounder_len = 8;
- uint8_t confounder[8];
-
- encode_pw_buffer(buffer, pwd, STR_UNICODE);
-
- generate_random_buffer((uint8_t *)confounder, confounder_len);
-
- MD5Init(&ctx);
- MD5Update(&ctx, session_key->data, session_key->length);
- MD5Update(&ctx, confounder, confounder_len);
- MD5Final(confounded_session_key.data, &ctx);
-
- arcfour_crypt_blob(buffer, 516, &confounded_session_key);
-
- memcpy(&pwd_buf->data[0], confounder, confounder_len);
- memcpy(&pwd_buf->data[8], buffer, 516);
-
- data_blob_free(&confounded_session_key);
-}
-
/*
* prerequisites for remotely joining an unjoined XP SP2 workstation:
* - firewall needs to be disabled (or open for ncacn_np access)
const char *domain_admin_account = NULL;
const char *domain_admin_password = NULL;
const char *domain_name = NULL;
- struct wkssvc_PasswordBuffer pwd_buf;
+ struct wkssvc_PasswordBuffer *pwd_buf;
enum wkssvc_NetJoinStatus join_status;
const char *join_name = NULL;
WERROR expected_err;
DATA_BLOB session_key;
+ struct dcerpc_binding_handle *b = p->binding_handle;
/* FIXME: this test assumes to join workstations / servers and does not
* handle DCs (WERR_SETUP_DOMAIN_CONTROLLER) */
}
switch (join_status) {
- case NetSetupDomainName:
+ case NET_SETUP_DOMAIN_NAME:
expected_err = WERR_SETUP_ALREADY_JOINED;
break;
- case NetSetupUnknownStatus:
- case NetSetupUnjoined:
- case NetSetupWorkgroupName:
+ case NET_SETUP_UNKNOWN_STATUS:
+ case NET_SETUP_UNJOINED:
+ case NET_SETUP_WORKGROUP_NAME:
default:
expected_err = WERR_OK;
break;
r.in.domain_name = domain_name;
r.in.account_ou = NULL;
r.in.admin_account = domain_admin_account;
- r.in.encrypted_password = &pwd_buf;
+ r.in.encrypted_password = pwd_buf;
r.in.join_flags = WKSSVC_JOIN_FLAGS_JOIN_TYPE |
WKSSVC_JOIN_FLAGS_ACCOUNT_CREATE;
- torture_comment(tctx, "testing NetrJoinDomain2 (assuming non-DC)\n");
+ torture_comment(tctx, "Testing NetrJoinDomain2 (assuming non-DC)\n");
- status = dcerpc_wkssvc_NetrJoinDomain2(p, tctx, &r);
+ status = dcerpc_wkssvc_NetrJoinDomain2_r(b, tctx, &r);
torture_assert_ntstatus_ok(tctx, status,
"NetrJoinDomain2 failed");
torture_assert_werr_equal(tctx, r.out.result, expected_err,
return false;
}
- if (join_status != NetSetupDomainName) {
+ if (join_status != NET_SETUP_DOMAIN_NAME) {
torture_comment(tctx,
"Join verify failed: got %d\n", join_status);
return false;
struct wkssvc_NetrUnjoinDomain2 r;
const char *domain_admin_account = NULL;
const char *domain_admin_password = NULL;
- struct wkssvc_PasswordBuffer pwd_buf;
+ struct wkssvc_PasswordBuffer *pwd_buf;
enum wkssvc_NetJoinStatus join_status;
const char *join_name = NULL;
WERROR expected_err;
DATA_BLOB session_key;
+ struct dcerpc_binding_handle *b = p->binding_handle;
/* FIXME: this test assumes to join workstations / servers and does not
* handle DCs (WERR_SETUP_DOMAIN_CONTROLLER) */
}
switch (join_status) {
- case NetSetupUnjoined:
+ case NET_SETUP_UNJOINED:
expected_err = WERR_SETUP_NOT_JOINED;
break;
- case NetSetupDomainName:
- case NetSetupUnknownStatus:
- case NetSetupWorkgroupName:
+ case NET_SETUP_DOMAIN_NAME:
+ case NET_SETUP_UNKNOWN_STATUS:
+ case NET_SETUP_WORKGROUP_NAME:
default:
expected_err = WERR_OK;
break;
r.in.server_name = dcerpc_server_name(p);
r.in.account = domain_admin_account;
- r.in.encrypted_password = &pwd_buf;
+ r.in.encrypted_password = pwd_buf;
r.in.unjoin_flags = 0;
- torture_comment(tctx, "testing NetrUnjoinDomain2 (assuming non-DC)\n");
+ torture_comment(tctx, "Testing NetrUnjoinDomain2 (assuming non-DC)\n");
- status = dcerpc_wkssvc_NetrUnjoinDomain2(p, tctx, &r);
+ status = dcerpc_wkssvc_NetrUnjoinDomain2_r(b, tctx, &r);
torture_assert_ntstatus_ok(tctx, status,
"NetrUnjoinDomain2 failed");
torture_assert_werr_equal(tctx, r.out.result, expected_err,
}
switch (join_status) {
- case NetSetupUnjoined:
- case NetSetupWorkgroupName:
+ case NET_SETUP_UNJOINED:
+ case NET_SETUP_WORKGROUP_NAME:
break;
- case NetSetupUnknown:
- case NetSetupDomainName:
+ case NET_SETUP_UNKNOWN_STATUS:
+ case NET_SETUP_DOMAIN_NAME:
default:
torture_comment(tctx,
"Unjoin verify failed: got %d\n", join_status);
struct torture_rpc_tcase *tcase;
struct torture_test *test;
- suite = torture_suite_create(mem_ctx, "WKSSVC");
+ suite = torture_suite_create(mem_ctx, "wkssvc");
tcase = torture_suite_add_rpc_iface_tcase(suite, "wkssvc",
&ndr_table_wkssvc);
git.samba.org / sfrench / samba-autobuild / .git / blobdiff