#include "lib/param/param.h"
#include "lib/util/samba_util.h"
#include "auth/credentials/credentials.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include <gnutls/gnutls.h>
#include <gnutls/crypto.h>
struct wbcAuthUserInfo *info = NULL;
struct wbcAuthErrorInfo *error = NULL;
wbcErr ret;
+ struct cli_credentials *creds = samba_cmdline_get_creds();
ret = wbcAuthenticateUser(cli_credentials_get_username(
- popt_get_cmdline_credentials()), correct_password);
+ creds), correct_password);
torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
"wbcAuthenticateUser of %s failed",
- cli_credentials_get_username(popt_get_cmdline_credentials()));
+ cli_credentials_get_username(creds));
ZERO_STRUCT(params);
params.account_name =
- cli_credentials_get_username(popt_get_cmdline_credentials());
+ cli_credentials_get_username(creds);
params.level = WBC_AUTH_USER_LEVEL_PLAIN;
params.password.plaintext = correct_password;
static bool test_wbc_authenticate_user(struct torture_context *tctx)
{
+ struct cli_credentials *creds = samba_cmdline_get_creds();
+
return test_wbc_authenticate_user_int(tctx,
- cli_credentials_get_password(popt_get_cmdline_credentials()));
+ cli_credentials_get_password(creds));
}
static bool test_wbc_change_password(struct torture_context *tctx)
{
wbcErr ret;
+ struct cli_credentials *creds = samba_cmdline_get_creds();
const char *oldpass =
- cli_credentials_get_password(popt_get_cmdline_credentials());
+ cli_credentials_get_password(creds);
const char *newpass = "Koo8irei%$";
struct samr_CryptPassword new_nt_password;
params.level = WBC_CHANGE_PASSWORD_LEVEL_RESPONSE;
params.account_name =
- cli_credentials_get_username(popt_get_cmdline_credentials());
+ cli_credentials_get_username(creds);
params.domain_name =
- cli_credentials_get_domain(popt_get_cmdline_credentials());
+ cli_credentials_get_domain(creds);
ret = wbcChangeUserPasswordEx(¶ms, NULL, NULL, NULL);
torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
}
ret = wbcChangeUserPassword(
- cli_credentials_get_username(popt_get_cmdline_credentials()),
+ cli_credentials_get_username(creds),
newpass,
- cli_credentials_get_password(popt_get_cmdline_credentials()));
+ cli_credentials_get_password(creds));
torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
"wbcChangeUserPassword for %s failed", params.account_name);
return test_wbc_authenticate_user_int(tctx,
- cli_credentials_get_password(popt_get_cmdline_credentials()));
+ cli_credentials_get_password(creds));
}
static bool test_wbc_logon_user(struct torture_context *tctx)
enum wbcSidType sidtype;
char *sidstr;
wbcErr ret;
+ struct cli_credentials *creds = samba_cmdline_get_creds();
ZERO_STRUCT(params);
"have failed");
params.username =
- cli_credentials_get_username(popt_get_cmdline_credentials());
+ cli_credentials_get_username(creds);
params.password =
- cli_credentials_get_password(popt_get_cmdline_credentials());
+ cli_credentials_get_password(creds);
ret = wbcAddNamedBlob(¶ms.num_blobs, ¶ms.blobs,
"foo", 0, discard_const_p(uint8_t, "bar"), 4);
torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
"%s", "wbcAddNamedBlob failed");
params.password =
- cli_credentials_get_password(popt_get_cmdline_credentials());
+ cli_credentials_get_password(creds);
ret = wbcLogonUser(¶ms, &info, &error, &policy);
torture_assert_wbc_equal(tctx, ret, WBC_ERR_AUTH_ERROR,
"wbcLogonUser for %s should have failed with "
"%s", "wbcInterfaceDetails failed");
ret = wbcLookupName(iface->netbios_domain,
- cli_credentials_get_username(popt_get_cmdline_credentials()),
+ cli_credentials_get_username(creds),
&sid,
&sidtype);
wbcFreeMemory(iface);
torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
"wbcLookupName for %s failed",
- cli_credentials_get_username(popt_get_cmdline_credentials()));
+ cli_credentials_get_username(creds));
ret = wbcSidToString(&sid, &sidstr);
torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
"%s", "wbcAddNamedBlob failed");
wbcFreeMemory(sidstr);
params.password =
- cli_credentials_get_password(popt_get_cmdline_credentials());
+ cli_credentials_get_password(creds);
ret = wbcLogonUser(¶ms, &info, &error, &policy);
torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
"wbcLogonUser for %s failed", params.username);
wbcErr ret;
uint32_t num_groups;
gid_t *groups;
+ struct cli_credentials *creds = samba_cmdline_get_creds();
ret = wbcGetGroups(
- cli_credentials_get_username(popt_get_cmdline_credentials()),
+ cli_credentials_get_username(creds),
&num_groups,
&groups);
torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
"wbcGetGroups for %s failed",
- cli_credentials_get_username(popt_get_cmdline_credentials()));
+ cli_credentials_get_username(creds));
wbcFreeMemory(groups);
return true;
}
^samba.tests.dns.__main__.TestComplexQueries.test_cname_two_chain_not_matching_qtype
# ad_dc requires signing
#
-^samba4.smb.signing.*disabled.*signing=off.*\(ad_dc\)
+^samba4.smb.signing.*disabled.*client-protection=off.*\(ad_dc\)
# fl2000dc doesn't support AES
^samba4.krb5.kdc.*as-req-aes.*fl2000dc
# nt4_member and ad_member don't support ntlmv1 (not even over SMB1)
# 'raw NTLMv2 auth' is not enabled on ad_member
-^samba4.smb.signing.disabled.on.with.-k.no.--option=clientusespnego=no.--signing=off.domain-creds.xcopy\(ad_member\)
+^samba4.smb.signing disabled on with -k no --option=clientusespnego=no --client-protection=off domain-creds.xcopy\(ad_member\)
^samba3.unix.whoami kerberos connection.whoami\(ad_member\)
^samba3.unix.whoami anonymous connection.whoami\(ad_member\)
^samba3.unix.whoami ntlm user@realm.whoami\(ad_member\)
-^samba4.smb.signing disabled on with -k no --signing=off domain-creds.xcopy\(ad_member\)
-^samba4.smb.signing disabled on with -k no --option=gensec:spengo=no --signing=off domain-creds.xcopy\(ad_member\)
-^samba4.smb.signing disabled on with -k yes --signing=off domain-creds.xcopy\(ad_member\)
+^samba4.smb.signing disabled on with -k no --client-protection=off domain-creds.xcopy\(ad_member\)
+^samba4.smb.signing disabled on with -k no --option=gensec:spengo=no --client-protection=off domain-creds.xcopy\(ad_member\)
+^samba4.smb.signing disabled on with -k yes --client-protection=off domain-creds.xcopy\(ad_member\)
^samba4.blackbox.smbclient\(ad_member:local\).Test login with --machine-pass without kerberos\(ad_member:local\)
^samba4.blackbox.smbclient\(ad_member:local\).Test login with --machine-pass and kerberos\(ad_member:local\)
^samba4.blackbox.smbclient\(chgdcpass:local\).Test login with --machine-pass without kerberos\(chgdcpass:local\)
if t == "raw.notify" or t == "raw.oplock":
tmp_env = "nt4_dc_smb1"
# These tests are a little slower so don't duplicate them with ad_dc
- plansmbtorture4testsuite(t, tmp_env, '//$SERVER_IP/tmp -U$USERNAME%$PASSWORD --signing=required')
+ plansmbtorture4testsuite(t, tmp_env, '//$SERVER_IP/tmp -U$USERNAME%$PASSWORD --client-protection=sign')
elif t == "smb2.dosmode":
plansmbtorture4testsuite(t, "simpleserver", '//$SERVER/dosmode -U$USERNAME%$PASSWORD')
elif t == "smb2.kernel-oplocks":
e = ""
a = "smb2"
binding_string = "ncacn_np:$SERVER[%s%s%s]" % (a, s, e)
- options = binding_string + " -k yes --krb5-ccache=$PREFIX/ktest/krb5_ccache-2"
+ options = binding_string + " --use-krb5-ccache=$PREFIX/ktest/krb5_ccache-2"
plansmbtorture4testsuite(test, "ktest", options, 'krb5 with old ccache ncacn_np with [%s%s%s] ' % (a, s, e))
- options = binding_string + " -k yes --krb5-ccache=$PREFIX/ktest/krb5_ccache-3"
+ options = binding_string + " --use-krb5-ccache=$PREFIX/ktest/krb5_ccache-3"
plansmbtorture4testsuite(test, "ktest", options, 'krb5 ncacn_np with [%s%s%s] ' % (a, s, e))
auth_options2 = ["krb5", "spnego,krb5"]
"-k no --option=gensec:spengo=no",
"-k yes",
"-k yes --option=gensec:fake_gssapi_krb5=yes --option=gensec:gssapi_krb5=no"]:
- for signing in ["--signing=on", "--signing=required"]:
+ for signing in ["--option=clientsigning=desired", "--option=clientsigning=required"]:
signoptions = "%s %s" % (mech, signing)
name = "smb.signing on with %s" % signoptions
plansmbtorture4testsuite('base.xcopy', "ad_dc_ntvfs", ['//$NETBIOSNAME/xcopy_share', signoptions, '-U$USERNAME%$PASSWORD'], modname="samba4.%s" % name)
"-k no --option=clientusespnego=no",
"-k no --option=gensec:spengo=no",
"-k yes"]:
- signoptions = "%s --signing=off" % mech
+ signoptions = "%s --client-protection=off" % mech
name = "smb.signing disabled on with %s" % signoptions
plansmbtorture4testsuite('base.xcopy', "s4member", ['//$NETBIOSNAME/xcopy_share', signoptions, '-U$DC_USERNAME%$DC_PASSWORD'], "samba4.%s domain-creds" % name)
plansmbtorture4testsuite('base.xcopy', "ad_member", ['//$NETBIOSNAME/xcopy_share', signoptions, '-U$DC_USERNAME%$DC_PASSWORD'], "samba4.%s domain-creds" % name)
"-k no",
"-k no --option=clientusespnego=no",
"-k no --option=gensec:spengo=no"]:
- signoptions = "%s --signing=off" % mech
+ signoptions = "%s --client-protection=off" % mech
plansmbtorture4testsuite('base.xcopy', "s4member", ['//$NETBIOSNAME/xcopy_share', signoptions, '-U$NETBIOSNAME/$USERNAME%$PASSWORD'], modname="samba4.smb.signing on with %s local-creds" % signoptions)
-plansmbtorture4testsuite('base.xcopy', "ad_dc_ntvfs", ['//$NETBIOSNAME/xcopy_share', '-k', 'no', '--signing=yes', '-U%'], modname="samba4.smb.signing --signing=yes anon")
-plansmbtorture4testsuite('base.xcopy', "ad_dc_ntvfs", ['//$NETBIOSNAME/xcopy_share', '-k', 'no', '--signing=required', '-U%'], modname="samba4.smb.signing --signing=required anon")
-plansmbtorture4testsuite('base.xcopy', "s4member", ['//$NETBIOSNAME/xcopy_share', '-k', 'no', '--signing=no', '-U%'], modname="samba4.smb.signing --signing=no anon")
+plansmbtorture4testsuite('base.xcopy', "ad_dc_ntvfs", ['//$NETBIOSNAME/xcopy_share', '-k', 'no', '--option=clientsigning=desired', '-U%'], modname="samba4.smb.signing --option=clientsigning=desired anon")
+plansmbtorture4testsuite('base.xcopy', "ad_dc_ntvfs", ['//$NETBIOSNAME/xcopy_share', '-k', 'no', '--option=clientsigning=required', '-U%'], modname="samba4.smb.signing --option=clientsigning=required anon")
+plansmbtorture4testsuite('base.xcopy', "s4member", ['//$NETBIOSNAME/xcopy_share', '-k', 'no', '--option=clientsigning=disabled', '-U%'], modname="samba4.smb.signing --option=clientsigning=disabled anon")
# Test SPNEGO without issuing an optimistic token
opt='--option=spnego:client_no_optimistic=yes'
#include "auth/gensec/gensec_internal.h"
#include "auth/ntlmssp/ntlmssp.h"
#include "auth/ntlmssp/ntlmssp_private.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "torture/torture.h"
#include "param/param.h"
#include "torture/auth/proto.h"
lpcfg_gensec_settings(tctx, tctx->lp_ctx)),
"gensec client start");
- gensec_set_credentials(gensec_security, popt_get_cmdline_credentials());
+ gensec_set_credentials(gensec_security, samba_cmdline_get_creds());
gensec_want_feature(gensec_security, GENSEC_FEATURE_SIGN);
gensec_want_feature(gensec_security, GENSEC_FEATURE_SEAL);
lpcfg_gensec_settings(tctx, tctx->lp_ctx)),
"Failed to start GENSEC for NTLMSSP");
- gensec_set_credentials(gensec_security, popt_get_cmdline_credentials());
+ gensec_set_credentials(gensec_security, samba_cmdline_get_creds());
gensec_want_feature(gensec_security, GENSEC_FEATURE_SIGN);
gensec_want_feature(gensec_security, GENSEC_FEATURE_SEAL);
#include "libcli/composite/composite.h"
#include "param/param.h"
#include "torture/basic/proto.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
static bool wait_lock(struct smbcli_state *c, int fnum, uint32_t offset, uint32_t len)
{
smb->in.socket_options = lpcfg_socket_options(tctx->lp_ctx);
smb->in.called_name = strupper_talloc(mem_ctx, host);
smb->in.service_type=NULL;
- smb->in.credentials=popt_get_cmdline_credentials();
+ smb->in.credentials = samba_cmdline_get_creds();
smb->in.fallback_to_anonymous=false;
smb->in.gensec_settings = lpcfg_gensec_settings(mem_ctx, tctx->lp_ctx);
smb->in.workgroup=workgroup;
#include "auth/session.h"
#include "auth/gensec/gensec.h"
#include "auth/credentials/credentials.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
/* Tests that configure multiple DLZs will use this. Increase to add stress. */
#define NUM_DLZS_TO_CONFIGURE 4
torture_assert_ntstatus_ok(tctx, status, "gensec_set_target_service failed");
status = gensec_set_credentials(gensec_client_context,
- popt_get_cmdline_credentials());
+ samba_cmdline_get_creds());
torture_assert_ntstatus_ok(tctx, status, "gensec_set_credentials (client) failed");
status = gensec_start_mech_by_sasl_name(gensec_client_context, mech);
torture_assert_int_equal(tctx, dlz_ssumatch(
cli_credentials_get_username(
- popt_get_cmdline_credentials()),
+ samba_cmdline_get_creds()),
lpcfg_dnsdomain(tctx->lp_ctx),
"127.0.0.1", "type", "key",
client_to_server.length,
torture_assert_ntstatus_ok(tctx, status, "gensec_set_target_service failed");
status = gensec_set_credentials(gensec_client_context,
- popt_get_cmdline_credentials());
+ samba_cmdline_get_creds());
torture_assert_ntstatus_ok(tctx, status, "gensec_set_credentials (client) failed");
status = gensec_start_mech_by_sasl_name(gensec_client_context, "GSS-SPNEGO");
torture_assert_int_equal(tctx, dlz_ssumatch(
cli_credentials_get_username(
- popt_get_cmdline_credentials()),
+ samba_cmdline_get_creds()),
name,
"127.0.0.1",
expected1->records[0].type,
*/
#include "includes.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "librpc/gen_ndr/ndr_drsuapi_c.h"
#include "librpc/gen_ndr/ndr_drsblobs.h"
#include "libcli/cldap/cldap.h"
}
/* ctx->admin ...*/
- ctx->admin.credentials = popt_get_cmdline_credentials();
+ ctx->admin.credentials = samba_cmdline_get_creds();
our_bind_info28 = &ctx->admin.drsuapi.our_bind_info28;
our_bind_info28->supported_extensions = 0xFFFFFFFF;
ctx->admin.drsuapi.req.out.bind_handle = &ctx->admin.drsuapi.bind_handle;
/* ctx->new_dc ...*/
- ctx->new_dc.credentials = popt_get_cmdline_credentials();
+ ctx->new_dc.credentials = samba_cmdline_get_creds();
our_bind_info28 = &ctx->new_dc.drsuapi.our_bind_info28;
our_bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_BASE;
*/
#include "includes.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "librpc/gen_ndr/ndr_drsuapi_c.h"
#include "librpc/gen_ndr/ndr_drsblobs.h"
#include "libcli/cldap/cldap.h"
}
/* populate test suite context */
- ctx->creds = popt_get_cmdline_credentials();
+ ctx->creds = samba_cmdline_get_creds();
ctx->dsa_bind.server_binding = server_binding;
ctx->ldap_url = talloc_asprintf(ctx, "ldap://%s",
autoproto='proto.h',
subsystem='smbtorture',
init_function='torture_drs_init',
- deps='samba-util ldb POPT_SAMBA samba-errors torture ldbsamba talloc dcerpc ndr NDR_DRSUAPI gensec samba-hostconfig RPC_NDR_DRSUAPI DSDB_MODULE_HELPERS asn1util samdb NDR_DRSBLOBS samba-credentials samdb-common LIBCLI_RESOLVE LP_RESOLVE torturemain',
+ deps='samba-util ldb samba-errors torture ldbsamba talloc dcerpc ndr NDR_DRSUAPI gensec samba-hostconfig RPC_NDR_DRSUAPI DSDB_MODULE_HELPERS asn1util samdb NDR_DRSBLOBS samba-credentials samdb-common LIBCLI_RESOLVE LP_RESOLVE torturemain',
internal_module=True,
enabled=bld.PYTHON_BUILD_IS_ENABLED()
)
#include "torture/smbtorture.h"
#include "torture/krb5/proto.h"
#include "auth/credentials/credentials.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "source4/auth/kerberos/kerberos.h"
#include "source4/auth/kerberos/kerberos_util.h"
#include "lib/util/util_net.h"
char *got_principal_string;
char *assertion_message;
const char *password = cli_credentials_get_password(
- popt_get_cmdline_credentials());
+ samba_cmdline_get_creds());
krb5_context k5_context;
struct torture_krb5_context *test_context;
bool ok;
torture_assert(tctx,
test_accept_ticket(tctx,
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
spn_real_realm,
client_to_server),
"test_accept_ticket failed - failed to accept the ticket we just created");
torture_assert(tctx,
test_accept_ticket(tctx,
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
spn,
client_to_server),
"test_accept_ticket failed - failed to accept the ticket we just created");
torture_assert(tctx,
test_accept_ticket(tctx,
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
principal_string,
client_to_server),
"test_accept_ticket failed - failed to accept the ticket we just created");
torture_assert(tctx,
test_accept_ticket(tctx,
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
accept_expected_principal_string,
client_to_server),
"test_accept_ticket failed - failed to accept the ticket we just created");
torture_assert(tctx,
test_accept_ticket(tctx,
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
expected_unparse_principal_string,
client_to_server),
"test_accept_ticket failed - failed to accept the ticket we just created");
test_data->real_realm
= strupper_talloc(test_data,
cli_credentials_get_realm(
- popt_get_cmdline_credentials()));
+ samba_cmdline_get_creds()));
test_data->real_domain = cli_credentials_get_domain(
- popt_get_cmdline_credentials());
+ samba_cmdline_get_creds());
test_data->username = cli_credentials_get_username(
- popt_get_cmdline_credentials());
+ samba_cmdline_get_creds());
test_data->real_username = cli_credentials_get_username(
- popt_get_cmdline_credentials());
+ samba_cmdline_get_creds());
test_data->canonicalize = (i & TEST_CANONICALIZE) != 0;
test_data->enterprise = (i & TEST_ENTERPRISE) != 0;
test_data->upper_realm = (i & TEST_UPPER_REALM) != 0;
#include "torture/winbind/proto.h"
#include "torture/krb5/proto.h"
#include "auth/credentials/credentials.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "source4/auth/kerberos/kerberos.h"
#include "source4/auth/kerberos/kerberos_util.h"
#include "lib/util/util_net.h"
static bool torture_krb5_as_req_cmdline(struct torture_context *tctx)
{
- return torture_krb5_as_req_creds(tctx, popt_get_cmdline_credentials(),
+ return torture_krb5_as_req_creds(tctx, samba_cmdline_get_creds(),
TORTURE_KRB5_TEST_PLAIN);
}
if (torture_setting_bool(tctx, "expect_rodc", false)) {
torture_skip(tctx, "This test needs further investigation in the RODC case against a Windows DC, in particular with non-cached users");
}
- return torture_krb5_as_req_creds(tctx, popt_get_cmdline_credentials(),
+ return torture_krb5_as_req_creds(tctx, samba_cmdline_get_creds(),
TORTURE_KRB5_TEST_PAC_REQUEST);
}
static bool torture_krb5_as_req_break_pw(struct torture_context *tctx)
{
- return torture_krb5_as_req_creds(tctx, popt_get_cmdline_credentials(),
+ return torture_krb5_as_req_creds(tctx, samba_cmdline_get_creds(),
TORTURE_KRB5_TEST_BREAK_PW);
}
static bool torture_krb5_as_req_clock_skew(struct torture_context *tctx)
{
- return torture_krb5_as_req_creds(tctx, popt_get_cmdline_credentials(),
+ return torture_krb5_as_req_creds(tctx, samba_cmdline_get_creds(),
TORTURE_KRB5_TEST_CLOCK_SKEW);
}
static bool torture_krb5_as_req_aes(struct torture_context *tctx)
{
return torture_krb5_as_req_creds(tctx,
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
TORTURE_KRB5_TEST_AES);
}
static bool torture_krb5_as_req_rc4(struct torture_context *tctx)
{
return torture_krb5_as_req_creds(tctx,
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
TORTURE_KRB5_TEST_RC4);
}
static bool torture_krb5_as_req_aes_rc4(struct torture_context *tctx)
{
return torture_krb5_as_req_creds(tctx,
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
TORTURE_KRB5_TEST_AES_RC4);
}
static bool torture_krb5_as_req_change_server_out(struct torture_context *tctx)
{
return torture_krb5_as_req_creds(tctx,
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
TORTURE_KRB5_TEST_CHANGE_SERVER_OUT);
}
static bool torture_krb5_as_req_change_server_in(struct torture_context *tctx)
{
return torture_krb5_as_req_creds(tctx,
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
TORTURE_KRB5_TEST_CHANGE_SERVER_IN);
}
static bool torture_krb5_as_req_change_server_both(struct torture_context *tctx)
{
return torture_krb5_as_req_creds(tctx,
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
TORTURE_KRB5_TEST_CHANGE_SERVER_BOTH);
}
#include "torture/winbind/proto.h"
#include "torture/krb5/proto.h"
#include "auth/credentials/credentials.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "source4/auth/kerberos/kerberos.h"
#include "source4/auth/kerberos/kerberos_util.h"
#include "lib/util/util_net.h"
static bool torture_krb5_as_req_cmdline(struct torture_context *tctx)
{
return torture_krb5_as_req_creds(tctx,
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
TORTURE_KRB5_TEST_PLAIN);
}
"RODC case against a Windows DC, in particular "
"with non-cached users");
}
- return torture_krb5_as_req_creds(tctx, popt_get_cmdline_credentials(),
+ return torture_krb5_as_req_creds(tctx, samba_cmdline_get_creds(),
TORTURE_KRB5_TEST_PAC_REQUEST);
}
#endif /* HAVE_KRB5_GET_INIT_CREDS_OPT_SET_PAC_REQUEST */
static bool torture_krb5_as_req_break_pw(struct torture_context *tctx)
{
return torture_krb5_as_req_creds(tctx,
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
TORTURE_KRB5_TEST_BREAK_PW);
}
static bool torture_krb5_as_req_clock_skew(struct torture_context *tctx)
{
return torture_krb5_as_req_creds(tctx,
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
TORTURE_KRB5_TEST_CLOCK_SKEW);
}
static bool torture_krb5_as_req_aes(struct torture_context *tctx)
{
return torture_krb5_as_req_creds(tctx,
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
TORTURE_KRB5_TEST_AES);
}
static bool torture_krb5_as_req_rc4(struct torture_context *tctx)
{
return torture_krb5_as_req_creds(tctx,
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
TORTURE_KRB5_TEST_RC4);
}
static bool torture_krb5_as_req_aes_rc4(struct torture_context *tctx)
{
return torture_krb5_as_req_creds(tctx,
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
TORTURE_KRB5_TEST_AES_RC4);
}
autoproto='proto.h',
subsystem='smbtorture',
init_function='torture_krb5_init',
- deps='authkrb5 popt POPT_CREDENTIALS torture KERBEROS_UTIL',
+ deps='authkrb5 torture KERBEROS_UTIL',
internal_module=True)
else:
bld.SAMBA_MODULE('TORTURE_KRB5',
autoproto='proto.h',
subsystem='smbtorture',
init_function='torture_krb5_init',
- deps='authkrb5 popt POPT_CREDENTIALS torture KERBEROS_UTIL',
+ deps='authkrb5 torture KERBEROS_UTIL',
internal_module=True)
#include "includes.h"
#include "ldb_wrap.h"
#include "libcli/ldap/ldap_client.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "torture/torture.h"
#include "torture/ldap/proto.h"
}
ldb = ldb_wrap_connect(mem_ctx, tctx->ev, tctx->lp_ctx, url,
- NULL, popt_get_cmdline_credentials(), 0);
+ NULL, samba_cmdline_get_creds(), 0);
/* "partitions[i]" are the partitions for which we search the parents */
for (i = 1; partitions[i] != NULL; i++) {
ret = false;
}
- if (!test_bind_sasl(torture, conn, popt_get_cmdline_credentials())) {
+ if (!test_bind_sasl(torture, conn, samba_cmdline_get_creds())) {
ret = false;
}
#include <ldb_errors.h>
#include "ldb_wrap.h"
#include "param/param.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "libcli/ldap/ldap_client.h"
#include "torture/smbtorture.h"
#include "torture/ldap/proto.h"
ldb = ldb_wrap_connect(torture, torture->ev, torture->lp_ctx, url,
NULL,
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
0);
torture_assert(torture, ldb, "Failed to make LDB connection to target");
#include "includes.h"
#include "ldb.h"
#include "ldb_wrap.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "libcli/ldap/ldap_client.h"
#include "torture/torture.h"
#include "torture/ldap/proto.h"
torture_comment(tctx, "Connecting to: %s\n", url);
sctx->ldb = ldb_wrap_connect(sctx, tctx->ev, tctx->lp_ctx, url,
NULL,
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
0);
torture_assert(tctx, sctx->ldb, "Failed to create ldb connection");
#include "includes.h"
#include "libcli/ldap/ldap_client.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "ldb_wrap.h"
#include "dsdb/samdb/samdb.h"
#include "../lib/util/dlinklist.h"
ldb = ldb_wrap_connect(torture, torture->ev, torture->lp_ctx, url,
NULL,
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
0);
if (!ldb) goto failed;
#include <ldb_errors.h>
#include "ldb_wrap.h"
#include "param/param.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "auth/credentials/credentials.h"
#include "libcli/ldap/ldap_client.h"
#include "torture/smbtorture.h"
bool torture_ldap_session_expiry(struct torture_context *torture)
{
const char *host = torture_setting_string(torture, "host", NULL);
- struct cli_credentials *credentials = popt_get_cmdline_credentials();
+ struct cli_credentials *credentials = samba_cmdline_get_creds();
struct ldb_context *ldb = NULL;
const char *url = NULL;
bool ret = false;
#include "includes.h"
#include "libcli/ldap/ldap_client.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "ldb_wrap.h"
#include "dsdb/samdb/samdb.h"
ldb = ldb_wrap_connect(torture, torture->ev, torture->lp_ctx, url,
NULL,
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
0);
if (!ldb) goto failed;
*/
#include "includes.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "torture/rpc/torture_rpc.h"
#include "libnet/libnet.h"
#include "dsdb/samdb/samdb.h"
torture_assert(torture, s, "libnet_vampire_cb_state_init");
ctx = libnet_context_init(torture->ev, torture->lp_ctx);
- ctx->cred = popt_get_cmdline_credentials();
+ ctx->cred = samba_cmdline_get_creds();
ZERO_STRUCT(b);
b.in.domain_dns_name = torture_join_dom_dns_name(tj);
#include "includes.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "libnet/libnet.h"
#include "librpc/gen_ndr/ndr_samr_c.h"
#include "librpc/gen_ndr/ndr_lsa_c.h"
return false;
}
- ctx->cred = popt_get_cmdline_credentials();
+ ctx->cred = samba_cmdline_get_creds();
ZERO_STRUCT(r);
r.in.type = DOMAIN_LSA;
goto done;
}
- ctx->cred = popt_get_cmdline_credentials();
+ ctx->cred = samba_cmdline_get_creds();
mem_ctx = talloc_init("torture_domain_close_lsa");
status = dcerpc_pipe_connect_b(mem_ctx, &p, binding, &ndr_table_lsarpc,
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
torture->ev, torture->lp_ctx);
if (!NT_STATUS_IS_OK(status)) {
torture_comment(torture, "failed to connect to server: %s\n", nt_errstr(status));
mem_ctx = talloc_init("test_domainopen_lsa");
ctx = libnet_context_init(torture->ev, torture->lp_ctx);
- ctx->cred = popt_get_cmdline_credentials();
+ ctx->cred = samba_cmdline_get_creds();
/* we're accessing domain controller so the domain name should be
passed (it's going to be resolved to dc name and address) instead
goto done;
}
- ctx->cred = popt_get_cmdline_credentials();
+ ctx->cred = samba_cmdline_get_creds();
mem_ctx = talloc_init("torture_domain_close_samr");
status = dcerpc_pipe_connect_b(mem_ctx, &p, binding, &ndr_table_samr,
goto done;
}
- ctx->cred = popt_get_cmdline_credentials();
+ ctx->cred = samba_cmdline_get_creds();
mem_ctx = talloc_init("torture_domain_close_samr");
#include "includes.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "libnet/libnet.h"
#include "librpc/gen_ndr/ndr_samr_c.h"
#include "librpc/gen_ndr/ndr_lsa_c.h"
int i;
ctx = libnet_context_init(torture->ev, torture->lp_ctx);
- ctx->cred = popt_get_cmdline_credentials();
+ ctx->cred = samba_cmdline_get_creds();
domain_name.string = lpcfg_workgroup(torture->lp_ctx);
mem_ctx = talloc_init("torture group list");
mem_ctx = talloc_init("test_creategroup");
ctx = libnet_context_init(torture->ev, torture->lp_ctx);
- ctx->cred = popt_get_cmdline_credentials();
+ ctx->cred = samba_cmdline_get_creds();
req.in.group_name = TEST_GROUPNAME;
req.in.domain_name = lpcfg_workgroup(torture->lp_ctx);
*/
#include "includes.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "libnet/libnet.h"
#include "libcli/libcli.h"
#include "torture/rpc/torture_rpc.h"
mem_ctx = talloc_init("test_lookup");
ctx = libnet_context_init(torture->ev, torture->lp_ctx);
- ctx->cred = popt_get_cmdline_credentials();
+ ctx->cred = samba_cmdline_get_creds();
lookup.in.hostname = torture_setting_string(torture, "host", NULL);
if (lookup.in.hostname == NULL) {
mem_ctx = talloc_init("test_lookup_host");
ctx = libnet_context_init(torture->ev, torture->lp_ctx);
- ctx->cred = popt_get_cmdline_credentials();
+ ctx->cred = samba_cmdline_get_creds();
lookup.in.hostname = torture_setting_string(torture, "host", NULL);
if (lookup.in.hostname == NULL) {
mem_ctx = talloc_init("test_lookup_pdc");
ctx = libnet_context_init(torture->ev, torture->lp_ctx);
- ctx->cred = popt_get_cmdline_credentials();
+ ctx->cred = samba_cmdline_get_creds();
talloc_steal(ctx, mem_ctx);
bool ret = true;
ctx = libnet_context_init(torture->ev, torture->lp_ctx);
- ctx->cred = popt_get_cmdline_credentials();
+ ctx->cred = samba_cmdline_get_creds();
mem_ctx = talloc_init("torture lookup sam name");
if (mem_ctx == NULL) return false;
*/
#include "includes.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "libnet/libnet.h"
#include "libcli/security/security.h"
#include "librpc/gen_ndr/ndr_lsa.h"
struct libnet_context *ctx;
ctx = libnet_context_init(torture->ev, torture->lp_ctx);
- ctx->cred = popt_get_cmdline_credentials();
+ ctx->cred = samba_cmdline_get_creds();
torture_comment(torture, "Testing connection to LSA interface\n");
#include "includes.h"
#include "torture/rpc/torture_rpc.h"
#include "libnet/libnet.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "librpc/gen_ndr/ndr_srvsvc_c.h"
#include "torture/libnet/proto.h"
goto done;
}
- libnetctx->cred = popt_get_cmdline_credentials();
+ libnetctx->cred = samba_cmdline_get_creds();
torture_comment(torture, "Testing libnet_ListShare\n");
torture_assert_ntstatus_ok(torture, status, "Failed to get binding");
libnetctx = libnet_context_init(torture->ev, torture->lp_ctx);
- libnetctx->cred = popt_get_cmdline_credentials();
+ libnetctx->cred = samba_cmdline_get_creds();
status = torture_rpc_connection(torture,
&p,
#include "includes.h"
#include "system/time.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "libnet/libnet.h"
#include "librpc/gen_ndr/ndr_samr_c.h"
#include "librpc/gen_ndr/ndr_lsa_c.h"
int i;
ctx = libnet_context_init(torture->ev, torture->lp_ctx);
- ctx->cred = popt_get_cmdline_credentials();
+ ctx->cred = samba_cmdline_get_creds();
domain_name.string = lpcfg_workgroup(torture->lp_ctx);
mem_ctx = talloc_init("torture user list");
*/
#include "includes.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "torture/rpc/torture_rpc.h"
#include "libnet/libnet.h"
#include "librpc/gen_ndr/ndr_samr_c.h"
ldb = ldb_wrap_connect(tmp_ctx,
tctx->ev, tctx->lp_ctx,
- url, NULL, popt_get_cmdline_credentials(), 0);
+ url, NULL, samba_cmdline_get_creds(), 0);
torture_assert_goto(tctx, ldb != NULL, test_res, done, "Failed to make LDB connection");
ldb_ret = ldb_search(ldb, tmp_ctx, &ldb_res,
torture_assert(tctx, net_ctx != NULL, "Failed to create libnet_context");
/* Use command line credentials for testing */
- net_ctx->cred = popt_get_cmdline_credentials();
+ net_ctx->cred = samba_cmdline_get_creds();
if (rpc_connect) {
/* connect SAMR pipe */
#include "source3/include/includes.h"
#include "torture/smbtorture.h"
#include "auth/credentials/credentials.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "source3/lib/netapi/netapi.h"
#include "source3/lib/netapi/netapi_private.h"
#include "lib/param/param.h"
}
libnetapi_set_username(ctx,
- cli_credentials_get_username(popt_get_cmdline_credentials()));
+ cli_credentials_get_username(samba_cmdline_get_creds()));
libnetapi_set_password(ctx,
- cli_credentials_get_password(popt_get_cmdline_credentials()));
+ cli_credentials_get_password(samba_cmdline_get_creds()));
*ctx_p = ctx;
autoproto='proto.h',
subsystem='smbtorture',
init_function='torture_libnetapi_init',
- deps='POPT_CREDENTIALS netapi',
+ deps='netapi',
internal_module=True,
)
#include "system/dir.h"
#include "torture/smbtorture.h"
#include "auth/credentials/credentials.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include <libsmbclient.h>
#include "torture/libsmbclient/proto.h"
#include "lib/param/loadparm.h"
char *pw, int pwlen)
{
const char *workgroup =
- cli_credentials_get_domain(popt_get_cmdline_credentials());
+ cli_credentials_get_domain(samba_cmdline_get_creds());
const char *username =
- cli_credentials_get_username(popt_get_cmdline_credentials());
+ cli_credentials_get_username(samba_cmdline_get_creds());
const char *password =
- cli_credentials_get_password(popt_get_cmdline_credentials());
+ cli_credentials_get_password(samba_cmdline_get_creds());
ssize_t ret;
if (workgroup != NULL) {
SMBCCTX **ctx_p)
{
const char *workgroup =
- cli_credentials_get_domain(popt_get_cmdline_credentials());
+ cli_credentials_get_domain(samba_cmdline_get_creds());
const char *username =
- cli_credentials_get_username(popt_get_cmdline_credentials());
+ cli_credentials_get_username(samba_cmdline_get_creds());
const char *client_proto =
torture_setting_string(tctx, "clientprotocol", NULL);
SMBCCTX *ctx = NULL;
autoproto='proto.h',
subsystem='smbtorture',
init_function='torture_libsmbclient_init',
- deps='POPT_CREDENTIALS smbclient',
+ deps='smbclient',
internal_module=True
)
fsrvp_state.c
smbtorture_fullname.c'''
-TORTURE_LOCAL_DEPS = 'RPC_NDR_ECHO TDR LIBCLI_SMB MESSAGING iconv POPT_CREDENTIALS TORTURE_AUTH TORTURE_UTIL TORTURE_NDR TORTURE_LIBCRYPTO share torture_registry %s ldb samdb replace-test RPC_FSS_STATE util_str_escape' % provision
+TORTURE_LOCAL_DEPS = 'RPC_NDR_ECHO TDR LIBCLI_SMB MESSAGING iconv TORTURE_AUTH TORTURE_UTIL TORTURE_NDR TORTURE_LIBCRYPTO share torture_registry %s ldb samdb replace-test RPC_FSS_STATE util_str_escape' % provision
bld.SAMBA_MODULE('TORTURE_LOCAL',
source=TORTURE_LOCAL_SOURCE,
#include "libcli/composite/composite.h"
#include "libcli/smb_composite/smb_composite.h"
#include "librpc/gen_ndr/ndr_misc.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "torture/util.h"
#include "param/param.h"
#include "libcli/resolve/resolve.h"
io2.in.service_type = "A:";
io2.in.socket_options = lpcfg_socket_options(tctx->lp_ctx);
- io2.in.credentials = popt_get_cmdline_credentials();
+ io2.in.credentials = samba_cmdline_get_creds();
io2.in.workgroup = lpcfg_workgroup(tctx->lp_ctx);
io2.in.filename = fname;
lpcfg_smbcli_options(tctx->lp_ctx, &io2.in.options);
io1.in.called_name = torture_setting_string(tctx, "host", NULL);
io1.in.service = torture_setting_string(tctx, "share", NULL);
io1.in.service_type = "A:";
- io1.in.credentials = popt_get_cmdline_credentials();
+ io1.in.credentials = samba_cmdline_get_creds();
io1.in.workgroup = lpcfg_workgroup(tctx->lp_ctx);
io1.in.level = RAW_QFS_OBJECTID_INFORMATION;
io1.in.gensec_settings = lpcfg_gensec_settings(tctx, tctx->lp_ctx);
#include "libcli/raw/libcliraw.h"
#include "libcli/raw/raw_proto.h"
#include "libcli/smb_composite/smb_composite.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "libcli/libcli.h"
#include "torture/util.h"
#include "auth/credentials/credentials.h"
setup.in.capabilities = cli->transport->negotiate.capabilities; /* ignored in secondary session setup, except by our libs, which care about the extended security bit */
setup.in.workgroup = lpcfg_workgroup(tctx->lp_ctx);
- setup.in.credentials = popt_get_cmdline_credentials();
+ setup.in.credentials = samba_cmdline_get_creds();
setup.in.gensec_settings = gensec_settings;
status = smb_composite_sesssetup(session, &setup);
setup.in.capabilities = cli->transport->negotiate.capabilities; /* ignored in secondary session setup, except by our libs, which care about the extended security bit */
setup.in.workgroup = lpcfg_workgroup(tctx->lp_ctx);
- setup.in.credentials = popt_get_cmdline_credentials();
+ setup.in.credentials = samba_cmdline_get_creds();
torture_comment(tctx, "vuid1=%d vuid2=%d vuid3=%d\n", cli->session->vuid, session->vuid, vuid3);
setup.in.capabilities &= ~CAP_EXTENDED_SECURITY; /* force a non extended security login (should fail) */
setup.in.workgroup = lpcfg_workgroup(tctx->lp_ctx);
- setup.in.credentials = popt_get_cmdline_credentials();
+ setup.in.credentials = samba_cmdline_get_creds();
status = smb_composite_sesssetup(session3, &setup);
if (!NT_STATUS_EQUAL(status, NT_STATUS_LOGON_FAILURE)) {
setups[i].in.capabilities = cli->transport->negotiate.capabilities; /* ignored in secondary session setup, except by our libs, which care about the extended security bit */
setups[i].in.workgroup = lpcfg_workgroup(tctx->lp_ctx);
- setups[i].in.credentials = popt_get_cmdline_credentials();
+ setups[i].in.credentials = samba_cmdline_get_creds();
setups[i].in.gensec_settings = gensec_settings;
sessions[i] = smbcli_session_init(cli->transport, tctx, false, options);
setup.in.sesskey = cli->transport->negotiate.sesskey;
setup.in.capabilities = cli->transport->negotiate.capabilities;
setup.in.workgroup = lpcfg_workgroup(tctx->lp_ctx);
- setup.in.credentials = popt_get_cmdline_credentials();
+ setup.in.credentials = samba_cmdline_get_creds();
setup.in.gensec_settings = lpcfg_gensec_settings(tctx, tctx->lp_ctx);
status = smb_composite_sesssetup(session1, &setup);
CHECK_STATUS(status, NT_STATUS_OK);
setup.in.sesskey = cli->transport->negotiate.sesskey;
setup.in.capabilities = cli->transport->negotiate.capabilities;
setup.in.workgroup = lpcfg_workgroup(tctx->lp_ctx);
- setup.in.credentials = popt_get_cmdline_credentials();
+ setup.in.credentials = samba_cmdline_get_creds();
setup.in.gensec_settings = lpcfg_gensec_settings(tctx, tctx->lp_ctx);
status = smb_composite_sesssetup(session2, &setup);
CHECK_STATUS(status, NT_STATUS_OK);
setup.in.sesskey = cli->transport->negotiate.sesskey;
setup.in.capabilities = cli->transport->negotiate.capabilities; /* ignored in secondary session setup, except by our libs, which care about the extended security bit */
setup.in.workgroup = lpcfg_workgroup(tctx->lp_ctx);
- setup.in.credentials = popt_get_cmdline_credentials();
+ setup.in.credentials = samba_cmdline_get_creds();
setup.in.gensec_settings = lpcfg_gensec_settings(tctx, tctx->lp_ctx);
status = smb_composite_sesssetup(session, &setup);
#include "torture/util.h"
#include "libcli/composite/composite.h"
#include "libcli/smb_composite/smb_composite.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "param/param.h"
#include "torture/raw/proto.h"
setup.in.sesskey = cli->transport->negotiate.sesskey;
setup.in.capabilities = cli->transport->negotiate.capabilities;
setup.in.workgroup = lpcfg_workgroup(tctx->lp_ctx);
- setup.in.credentials = popt_get_cmdline_credentials();
+ setup.in.credentials = samba_cmdline_get_creds();
setup.in.gensec_settings = lpcfg_gensec_settings(tctx, tctx->lp_ctx);
status = smb_composite_sesssetup(session, &setup);
CHECK_STATUS(status, NT_STATUS_OK);
#include "libcli/libcli.h"
#include "torture/util.h"
#include "lib/events/events.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "libcli/composite/composite.h"
#include "libcli/smb_composite/smb_composite.h"
#include "libcli/resolve/resolve.h"
io->in.called_name = state->called_name;
io->in.service = share;
io->in.service_type = state->service_type;
- io->in.credentials = popt_get_cmdline_credentials();
+ io->in.credentials = samba_cmdline_get_creds();
io->in.fallback_to_anonymous = false;
io->in.workgroup = lpcfg_workgroup(state->tctx->lp_ctx);
lpcfg_smbcli_options(state->tctx->lp_ctx, &io->in.options);
#include "libcli/libcli.h"
#include "torture/util.h"
#include "lib/events/events.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "libcli/composite/composite.h"
#include "libcli/smb_composite/smb_composite.h"
#include "libcli/resolve/resolve.h"
io->in.called_name = state->called_name;
io->in.service = share;
io->in.service_type = state->service_type;
- io->in.credentials = popt_get_cmdline_credentials();
+ io->in.credentials = samba_cmdline_get_creds();
io->in.fallback_to_anonymous = false;
io->in.workgroup = lpcfg_workgroup(state->tctx->lp_ctx);
io->in.gensec_settings = lpcfg_gensec_settings(state->mem_ctx, state->tctx->lp_ctx);
#include "torture/util.h"
#include "lib/events/events.h"
#include "param/param.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "libcli/resolve/resolve.h"
#include "torture/raw/proto.h"
lpcfg_smb_ports(tctx->lp_ctx),
torture_setting_string(tctx, "share", NULL),
NULL, lpcfg_socket_options(tctx->lp_ctx),
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
lpcfg_resolve_context(tctx->lp_ctx),
tctx->ev, &options, &session_options,
lpcfg_gensec_settings(tctx, tctx->lp_ctx));
#include "libcli/libcli.h"
#include "torture/raw/proto.h"
#include "smb_composite/smb_composite.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "param/param.h"
#include "torture/util.h"
#include "auth/credentials/credentials.h"
ZERO_STRUCT(io);
io.in.sesskey = cli->transport->negotiate.sesskey;
io.in.capabilities = cli->transport->negotiate.capabilities;
- io.in.credentials = popt_get_cmdline_credentials();
+ io.in.credentials = samba_cmdline_get_creds();
io.in.workgroup = lpcfg_workgroup(tctx->lp_ctx);
io.in.gensec_settings = lpcfg_gensec_settings(tctx, tctx->lp_ctx);
status = smb_composite_sesssetup(cli->session, &io);
ZERO_STRUCT(io_sesssetup);
io_sesssetup.in.sesskey = cli->transport->negotiate.sesskey;
io_sesssetup.in.capabilities = cli->transport->negotiate.capabilities;
- io_sesssetup.in.credentials = popt_get_cmdline_credentials();
+ io_sesssetup.in.credentials = samba_cmdline_get_creds();
io_sesssetup.in.workgroup = lpcfg_workgroup(tctx->lp_ctx);
io_sesssetup.in.gensec_settings = lpcfg_gensec_settings(
tctx, tctx->lp_ctx);
size_t i;
use_kerberos = cli_credentials_get_kerberos_state(
- popt_get_cmdline_credentials());
+ samba_cmdline_get_creds());
if (use_kerberos != CRED_USE_KERBEROS_REQUIRED) {
torture_warning(tctx, "smb2.session.expire1 requires -k yes!");
torture_skip(tctx, "smb2.session.expire1 requires -k yes!");
lpcfg_smb_ports(tctx->lp_ctx),
share, NULL,
lpcfg_socket_options(tctx->lp_ctx),
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
lpcfg_resolve_context(tctx->lp_ctx),
tctx->ev, &options, &session_options,
lpcfg_gensec_settings(tctx, tctx->lp_ctx));
* the krb5 library may not handle expired creds
* well, lets start with an empty ccache.
*/
- cli_credentials_invalidate_ccache(popt_get_cmdline_credentials(),
+ cli_credentials_invalidate_ccache(samba_cmdline_get_creds(),
CRED_SPECIFIED);
/*
io_sesssetup.in.sesskey = cli->transport->negotiate.sesskey;
io_sesssetup.in.capabilities = cli->transport->negotiate.capabilities;
io_sesssetup.in.capabilities |= CAP_DYNAMIC_REAUTH;
- io_sesssetup.in.credentials = popt_get_cmdline_credentials();
+ io_sesssetup.in.credentials = samba_cmdline_get_creds();
io_sesssetup.in.workgroup = lpcfg_workgroup(tctx->lp_ctx);
io_sesssetup.in.gensec_settings = lpcfg_gensec_settings(tctx,
tctx->lp_ctx);
* well, lets start with an empty ccache.
*/
cli_credentials_invalidate_ccache(
- popt_get_cmdline_credentials(), CRED_SPECIFIED);
+ samba_cmdline_get_creds(), CRED_SPECIFIED);
torture_comment(tctx, "reauth with CAP_DYNAMIC_REAUTH => OK\n");
ZERO_STRUCT(io_sesssetup.out);
* the krb5 library may not handle expired creds
* well, lets start with an empty ccache.
*/
- cli_credentials_invalidate_ccache(popt_get_cmdline_credentials(),
+ cli_credentials_invalidate_ccache(samba_cmdline_get_creds(),
CRED_SPECIFIED);
/*
#include "libcli/libcli.h"
#include "libcli/resolve/resolve.h"
#include "torture/smbtorture.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "param/param.h"
#include "system/filesys.h"
status = smbcli_full_connection(NULL, &cli,
host, lpcfg_smb_ports(tctx->lp_ctx), share,
NULL, lpcfg_socket_options(tctx->lp_ctx),
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
lpcfg_resolve_context(tctx->lp_ctx),
tctx->ev, &options, &session_options,
lpcfg_gensec_settings(tctx, tctx->lp_ctx));
#include "includes.h"
#include "librpc/gen_ndr/ndr_lsa.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "torture/rpc/torture_rpc.h"
/*
if (table == NULL) return false;
/* credentials */
- creds = popt_get_cmdline_credentials();
+ creds = samba_cmdline_get_creds();
/* send bind requests */
for (i = 0; i < torture_numasync; i++) {
#include "librpc/gen_ndr/ndr_backupkey.h"
#include "librpc/gen_ndr/ndr_lsa_c.h"
#include "librpc/gen_ndr/ndr_security.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "libcli/auth/proto.h"
#include <system/network.h>
struct dcerpc_binding_handle *b;
const char *domain = cli_credentials_get_domain(
- popt_get_cmdline_credentials());
+ samba_cmdline_get_creds());
torture_assert_ntstatus_ok(tctx,
torture_rpc_connection(tctx, &p2, &ndr_table_lsarpc),
user = "guest";
} else {
user = cli_credentials_get_username(
- popt_get_cmdline_credentials());
+ samba_cmdline_get_creds());
}
torture_assert_ntstatus_ok(tctx,
dcerpc_pipe_connect_b(tctx, &lsa_p,
lsa_binding, &ndr_table_lsarpc,
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
tctx->ev, tctx->lp_ctx),
"Opening LSA pipe");
lsa_b = lsa_p->binding_handle;
/* Not strictly correct all the time, but good enough for this test */
caller_sid = get_user_sid(tctx, tctx,
cli_credentials_get_username(
- popt_get_cmdline_credentials()));
+ samba_cmdline_get_creds()));
torture_assert_sid_equal(tctx, &rc4payload.sid, caller_sid, "Secret saved with wrong SID");
#include "torture/rpc/torture_rpc.h"
#include "librpc/gen_ndr/ndr_lsa_c.h"
#include "librpc/gen_ndr/ndr_epmapper_c.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
static bool test_openpolicy(struct torture_context *tctx,
struct dcerpc_pipe *p)
torture_assert_ntstatus_ok(tctx,
dcerpc_pipe_connect_b(tctx, &p, binding,
&ndr_table_lsarpc,
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
tctx->ev,
tctx->lp_ctx),
"failed to connect pipe");
torture_assert_ntstatus_ok(tctx,
dcerpc_pipe_connect_b(tctx, &p1, binding1,
&ndr_table_epmapper,
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
tctx->ev,
tctx->lp_ctx),
"failed to connect first pipe");
torture_assert_ntstatus_ok(tctx,
dcerpc_pipe_connect_b(tctx, &p2, binding2,
&ndr_table_epmapper,
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
tctx->ev,
tctx->lp_ctx),
"failed to connect second pipe");
torture_assert_ntstatus_ok(tctx,
dcerpc_pipe_connect_b(tctx, &p2, binding2,
&ndr_table_epmapper,
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
tctx->ev,
tctx->lp_ctx),
"failed to connect second pipe");
#include "libnet/libnet.h"
#include "torture/util.h"
#include "libcli/libcli.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#define SMBTORTURE_DFS_SHARENAME "smbtorture_dfs_share"
#define SMBTORTURE_DFS_DIRNAME "\\smbtorture_dfs_dir"
return false;
}
- libnetctx->cred = popt_get_cmdline_credentials();
+ libnetctx->cred = samba_cmdline_get_creds();
i.name = sharename;
i.type = STYPE_DISKTREE;
return false;
}
- libnetctx->cred = popt_get_cmdline_credentials();
+ libnetctx->cred = samba_cmdline_get_creds();
r.in.share_name = sharename;
r.in.server_name = host;
*/
#include "includes.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "librpc/gen_ndr/ndr_drsuapi_c.h"
#include "librpc/gen_ndr/ndr_drsblobs.h"
#include "libcli/cldap/cldap.h"
}
/* ctx->admin ...*/
- ctx->admin.credentials = popt_get_cmdline_credentials();
+ ctx->admin.credentials = samba_cmdline_get_creds();
our_bind_info28 = &ctx->admin.drsuapi.our_bind_info28;
our_bind_info28->supported_extensions = 0xFFFFFFFF;
#include "librpc/gen_ndr/ndr_security.h"
#include "librpc/gen_ndr/ndr_srvsvc_c.h"
#include "librpc/gen_ndr/ndr_fsrvp_c.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#define FSHARE "fsrvp_share"
#define FNAME "testfss.dat"
lpcfg_smb_ports(tctx->lp_ctx),
FSHARE,
lpcfg_resolve_context(tctx->lp_ctx),
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
&tree_base,
tctx->ev,
&options,
lpcfg_smb_ports(tctx->lp_ctx),
sc_map->ShadowCopyShareName,
lpcfg_resolve_context(tctx->lp_ctx),
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
&tree_snap,
tctx->ev,
&options,
lpcfg_smb_ports(tctx->lp_ctx),
FSHARE,
lpcfg_resolve_context(tctx->lp_ctx),
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
&tree_base,
tctx->ev,
&options,
struct torture_rpc_tcase_data *tcase_data;
*data = tcase_data = talloc_zero(tctx, struct torture_rpc_tcase_data);
- tcase_data->credentials = popt_get_cmdline_credentials();
+ tcase_data->credentials = samba_cmdline_get_creds();
status = torture_rpc_connection(tctx,
&(tcase_data->pipe),
#include "libcli/resolve/resolve.h"
#include "libcli/smb2/smb2.h"
#include "libcli/smb2/smb2_calls.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "system/filesys.h"
#include "lib/util/tftw.h"
lpcfg_smb_ports(tctx->lp_ctx),
share_name, NULL,
lpcfg_socket_options(tctx->lp_ctx),
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
lpcfg_resolve_context(tctx->lp_ctx),
tctx->ev,
&smb_options,
#include "torture/rpc/torture_rpc.h"
#include "librpc/gen_ndr/ndr_mdssvc_c.h"
#include "param/param.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "rpc_server/mdssvc/dalloc.h"
#include "rpc_server/mdssvc/marshalling.h"
#include "includes.h"
#include "lib/events/events.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "torture/rpc/torture_rpc.h"
#include "../lib/crypto/crypto.h"
#include "libcli/auth/libcli_auth.h"
r.in.server_name = NULL;
r.in.account_name = cli_credentials_get_username(
- popt_get_cmdline_credentials());
+ samba_cmdline_get_creds());
r.in.workstation = TEST_MACHINE_NAME;
r.out.info = &info;
r.in.server_name = NULL;
r.in.account_name = cli_credentials_get_username(
- popt_get_cmdline_credentials());
+ samba_cmdline_get_creds());
r.in.workstation = TEST_MACHINE_NAME;
r.out.info = &info;
flags |= CLI_CRED_NTLMv2_AUTH;
}
- cli_credentials_get_ntlm_username_domain(popt_get_cmdline_credentials(),
+ cli_credentials_get_ntlm_username_domain(samba_cmdline_get_creds(),
tctx,
&ninfo.identity_info.account_name.string,
&ninfo.identity_info.domain_name.string);
cli_credentials_get_domain(credentials));
status = cli_credentials_get_ntlm_response(
- popt_get_cmdline_credentials(), tctx,
+ samba_cmdline_get_creds(), tctx,
&flags,
chal,
NULL, /* server_timestamp */
url = talloc_asprintf(tctx, "ldap://%s", dcerpc_server_name(p));
sam_ctx = ldb_wrap_connect(tctx, tctx->ev, tctx->lp_ctx, url,
NULL,
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
0);
torture_assert(tctx, sam_ctx, "Connection to the SAMDB on DC failed!");
url = talloc_asprintf(tctx, "ldap://%s", dcerpc_server_name(p));
sam_ctx = ldb_wrap_connect(tctx, tctx->ev, tctx->lp_ctx, url,
NULL,
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
0);
torture_assert(tctx, sam_ctx, "Connection to the SAMDB on DC failed!");
url = talloc_asprintf(tctx, "ldap://%s", dcerpc_server_name(p));
sam_ctx = ldb_wrap_connect(tctx, tctx->ev, tctx->lp_ctx, url,
NULL,
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
0);
torture_assert(tctx, sam_ctx, "Connection to the SAMDB on DC failed!");
url = talloc_asprintf(tctx, "ldap://%s", dcerpc_server_name(p));
sam_ctx = ldb_wrap_connect(tctx, tctx->ev, tctx->lp_ctx, url,
NULL,
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
0);
torture_assert(tctx, sam_ctx, "Connection to the SAMDB on DC failed!");
#include "auth/kerberos/kerberos.h"
#include "auth/credentials/credentials.h"
#include "auth/credentials/credentials_krb5.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "torture/rpc/torture_rpc.h"
#include "libcli/auth/libcli_auth.h"
#include "libcli/security/security.h"
*/
client_creds =
cli_credentials_shallow_copy(tmp_ctx,
- popt_get_cmdline_credentials());
+ samba_cmdline_get_creds());
torture_assert(tctx,
client_creds,
"Failed to copy of credentials");
* we will get a new clean memory cache.
*/
client_creds = cli_credentials_shallow_copy(tmp_ctx,
- popt_get_cmdline_credentials());
+ samba_cmdline_get_creds());
torture_assert(tctx, client_creds, "Failed to copy of credentials");
/* We use cli_credentials_get_ntlm_response(), so relax krb5 requirements. */
cli_credentials_set_kerberos_state(client_creds,
"Testing S4U2Proxy (secure_channel_type: %d, machine: %s, negotiate_flags: 0x%08x\n",
secure_channel_type, test_machine_name, negotiate_flags);
- impersonate_princ = cli_credentials_get_principal(popt_get_cmdline_credentials(), tctx);
+ impersonate_princ = cli_credentials_get_principal(samba_cmdline_get_creds(), tctx);
torture_assert_not_null(tctx, impersonate_princ, "Failed to get impersonate client name");
server_creds = cli_credentials_shallow_copy(tctx, credentials);
int ret;
url = talloc_asprintf(tctx, "ldap://%s", dcerpc_server_name(p));
- sam_ctx = ldb_wrap_connect(tctx, tctx->ev, tctx->lp_ctx, url, NULL, popt_get_cmdline_credentials(), 0);
+ sam_ctx = ldb_wrap_connect(tctx, tctx->ev, tctx->lp_ctx, url, NULL, samba_cmdline_get_creds(), 0);
torture_assert_not_null(tctx, sam_ctx, "Connection to the SAMDB on DC failed!");
server_dn_str = samdb_search_string(sam_ctx, tctx, ldb_get_default_basedn(sam_ctx), "distinguishedName",
*/
#include "includes.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "torture/rpc/torture_rpc.h"
#include "torture/smbtorture.h"
#include "librpc/ndr/ndr_table.h"
status = dcerpc_pipe_connect_b(tctx,
p, binding, table,
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
tctx->ev, tctx->lp_ctx);
if (NT_STATUS_IS_ERR(status)) {
}
status = dcerpc_pipe_connect_b(tctx, p, binding, table,
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
tctx->ev, tctx->lp_ctx);
if (!NT_STATUS_IS_OK(status)) {
*p = NULL;
return false;
*data = tcase_data = talloc_zero(tctx, struct torture_rpc_tcase_data);
- tcase_data->credentials = popt_get_cmdline_credentials();
+ tcase_data->credentials = samba_cmdline_get_creds();
tcase_data->join_ctx = torture_join_domain(tctx, tcase->machine_name,
ACB_WSTRUST,
&tcase_data->credentials);
return false;
*data = tcase_data = talloc_zero(tctx, struct torture_rpc_tcase_data);
- tcase_data->credentials = popt_get_cmdline_credentials();
+ tcase_data->credentials = samba_cmdline_get_creds();
tcase_data->join_ctx = torture_join_domain(tctx, tcase->machine_name,
ACB_SVRTRUST,
&tcase_data->credentials);
struct torture_rpc_tcase_data *tcase_data;
*data = tcase_data = talloc_zero(tctx, struct torture_rpc_tcase_data);
- tcase_data->credentials = popt_get_cmdline_credentials();
+ tcase_data->credentials = samba_cmdline_get_creds();
status = torture_rpc_connection(tctx,
&(tcase_data->pipe),
#include "librpc/gen_ndr/ndr_winreg_c.h"
#include "librpc/gen_ndr/ndr_wkssvc_c.h"
#include "librpc/gen_ndr/ndr_svcctl_c.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "torture/rpc/torture_rpc.h"
#include "libcli/libcli.h"
#include "libcli/smb_composite/smb_composite.h"
lpcfg_smb_ports(torture->lp_ctx),
"IPC$", NULL,
lpcfg_socket_options(torture->lp_ctx),
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
lpcfg_resolve_context(torture->lp_ctx),
torture->ev, &options, &session_options,
lpcfg_gensec_settings(torture, torture->lp_ctx));
lpcfg_smb_ports(torture->lp_ctx),
"IPC$", NULL,
lpcfg_socket_options(torture->lp_ctx),
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
lpcfg_resolve_context(torture->lp_ctx),
torture->ev, &options, &session_options,
lpcfg_gensec_settings(torture, torture->lp_ctx));
ret = true;
- ret &= bindtest(torture, cli, popt_get_cmdline_credentials(),
+ ret &= bindtest(torture, cli, samba_cmdline_get_creds(),
DCERPC_AUTH_TYPE_NTLMSSP,
DCERPC_AUTH_LEVEL_INTEGRITY);
- ret &= bindtest(torture, cli, popt_get_cmdline_credentials(),
+ ret &= bindtest(torture, cli, samba_cmdline_get_creds(),
DCERPC_AUTH_TYPE_NTLMSSP,
DCERPC_AUTH_LEVEL_PRIVACY);
- ret &= bindtest(torture, cli, popt_get_cmdline_credentials(),
+ ret &= bindtest(torture, cli, samba_cmdline_get_creds(),
DCERPC_AUTH_TYPE_SPNEGO,
DCERPC_AUTH_LEVEL_INTEGRITY);
- ret &= bindtest(torture, cli, popt_get_cmdline_credentials(),
+ ret &= bindtest(torture, cli, samba_cmdline_get_creds(),
DCERPC_AUTH_TYPE_SPNEGO,
DCERPC_AUTH_LEVEL_PRIVACY);
lpcfg_smb_ports(torture->lp_ctx),
"IPC$", NULL,
lpcfg_socket_options(torture->lp_ctx),
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
lpcfg_resolve_context(torture->lp_ctx),
torture->ev, &options, &session_options,
lpcfg_gensec_settings(torture, torture->lp_ctx));
"join failed");
cli_credentials_set_domain(
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
cli_credentials_get_domain(wks_creds),
CRED_SPECIFIED);
for (j=0; j<2; j++) {
torture_assert(torture,
schan(torture, cli, wks_creds,
- popt_get_cmdline_credentials()),
+ samba_cmdline_get_creds()),
"schan failed");
}
}
"join failed");
cli_credentials_set_domain(
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
cli_credentials_get_domain(wks_creds),
CRED_SPECIFIED);
}
torture_assert(torture,
- test_join3(torture, false, popt_get_cmdline_credentials(),
+ test_join3(torture, false, samba_cmdline_get_creds(),
NULL, wks_name),
"join using anonymous bind on an authenticated smb connection failed");
*/
torture_assert(torture,
- test_join3(torture, true, popt_get_cmdline_credentials(),
+ test_join3(torture, true, samba_cmdline_get_creds(),
NULL, wks_name),
"join using anonymous bind on an authenticated smb connection failed");
torture, &cli, torture_setting_string(torture, "host", NULL),
lpcfg_smb_ports(torture->lp_ctx),
"IPC$", NULL, lpcfg_socket_options(torture->lp_ctx),
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
lpcfg_resolve_context(torture->lp_ctx), torture->ev, &options,
&session_options, lpcfg_gensec_settings(torture, torture->lp_ctx));
torture_assert_ntstatus_ok(torture, status, "smbcli_full_connection failed\n");
userlevel1.client = talloc_asprintf(
torture, "\\\\%s", lpcfg_netbios_name(torture->lp_ctx));
userlevel1.user = cli_credentials_get_username(
- popt_get_cmdline_credentials());
+ samba_cmdline_get_creds());
userlevel1.build = 2600;
userlevel1.major = 3;
userlevel1.minor = 0;
lpcfg_smb_ports(torture->lp_ctx),
"IPC$", NULL,
lpcfg_socket_options(torture->lp_ctx),
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
lpcfg_resolve_context(torture->lp_ctx),
torture->ev, &options, &session_options,
lpcfg_gensec_settings(torture, torture->lp_ctx));
ZERO_STRUCT(io);
io.in.sesskey = cli->transport->negotiate.sesskey;
io.in.capabilities = cli->transport->negotiate.capabilities;
- io.in.credentials = popt_get_cmdline_credentials();
+ io.in.credentials = samba_cmdline_get_creds();
io.in.workgroup = lpcfg_workgroup(torture->lp_ctx);
io.in.gensec_settings = lpcfg_gensec_settings(torture, torture->lp_ctx);
lpcfg_smb_ports(torture->lp_ctx),
"IPC$", NULL,
lpcfg_socket_options(torture->lp_ctx),
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
lpcfg_resolve_context(torture->lp_ctx),
torture->ev, &options, &session_options,
lpcfg_gensec_settings(torture, torture->lp_ctx));
ZERO_STRUCT(io);
io.in.sesskey = cli->transport->negotiate.sesskey;
io.in.capabilities = cli->transport->negotiate.capabilities;
- io.in.credentials = popt_get_cmdline_credentials();
+ io.in.credentials = samba_cmdline_get_creds();
io.in.workgroup = lpcfg_workgroup(torture->lp_ctx);
io.in.gensec_settings = lpcfg_gensec_settings(torture, torture->lp_ctx);
lpcfg_smb_ports(torture->lp_ctx),
"IPC$",
lpcfg_resolve_context(torture->lp_ctx),
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
&tree,
torture->ev,
&options,
/* smb re-auth again to the original user */
status = smb2_session_setup_spnego(tree->session,
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
0 /* previous_session_id */);
torture_assert_ntstatus_ok_goto(torture, status, ret, done,
"session reauth to anon failed");
lpcfg_smb_ports(torture->lp_ctx),
"IPC$",
lpcfg_resolve_context(torture->lp_ctx),
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
&tree,
torture->ev,
&options,
/* smb re-auth again to the original user */
status = smb2_session_setup_spnego(tree->session,
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
0 /* previous_session_id */);
torture_assert_ntstatus_ok_goto(torture, status, ret, done,
"session reauth to anon failed");
lpcfg_smb_ports(torture->lp_ctx),
"IPC$", NULL,
lpcfg_socket_options(torture->lp_ctx),
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
lpcfg_resolve_context(torture->lp_ctx),
torture->ev, &options, &session_options,
lpcfg_gensec_settings(torture, torture->lp_ctx));
lpcfg_smb_ports(torture->lp_ctx),
"IPC$",
lpcfg_resolve_context(torture->lp_ctx),
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
&tree,
torture->ev,
&options,
lpcfg_smb_ports(torture->lp_ctx),
"IPC$",
lpcfg_resolve_context(torture->lp_ctx),
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
&tree,
torture->ev,
&options,
lpcfg_smb_ports(torture->lp_ctx),
"IPC$",
lpcfg_resolve_context(torture->lp_ctx),
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
&tree,
torture->ev,
&options,
lpcfg_smb_ports(torture->lp_ctx),
"IPC$",
lpcfg_resolve_context(torture->lp_ctx),
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
&tree,
torture->ev,
&options,
lpcfg_smb_ports(torture->lp_ctx),
"IPC$",
lpcfg_resolve_context(torture->lp_ctx),
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
&tree,
torture->ev,
&options,
lpcfg_smb_ports(torture->lp_ctx),
"IPC$",
lpcfg_resolve_context(torture->lp_ctx),
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
&tree,
torture->ev,
&options,
#include "librpc/gen_ndr/ndr_netlogon.h"
#include "librpc/gen_ndr/ndr_netlogon_c.h"
#include "librpc/gen_ndr/ndr_samr_c.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "torture/rpc/torture_rpc.h"
#include "auth/gensec/gensec.h"
#include "libcli/auth/libcli_auth.h"
{
.comment = "domain\\user",
.domain = cli_credentials_get_domain(
- popt_get_cmdline_credentials()),
+ samba_cmdline_get_creds()),
.username = cli_credentials_get_username(
- popt_get_cmdline_credentials()),
+ samba_cmdline_get_creds()),
.password = cli_credentials_get_password(
- popt_get_cmdline_credentials()),
+ samba_cmdline_get_creds()),
.network_login = true,
.expected_interactive_error = NT_STATUS_OK,
.expected_network_error = NT_STATUS_OK,
{
.comment = "realm\\user",
.domain = cli_credentials_get_realm(
- popt_get_cmdline_credentials()),
+ samba_cmdline_get_creds()),
.username = cli_credentials_get_username(
- popt_get_cmdline_credentials()),
+ samba_cmdline_get_creds()),
.password = cli_credentials_get_password(
- popt_get_cmdline_credentials()),
+ samba_cmdline_get_creds()),
.network_login = true,
.expected_interactive_error = NT_STATUS_OK,
.expected_network_error = NT_STATUS_OK,
.username = talloc_asprintf(mem_ctx,
"%s@%s",
cli_credentials_get_username(
- popt_get_cmdline_credentials()),
+ samba_cmdline_get_creds()),
cli_credentials_get_domain(
- popt_get_cmdline_credentials())
+ samba_cmdline_get_creds())
),
.password = cli_credentials_get_password(
- popt_get_cmdline_credentials()),
+ samba_cmdline_get_creds()),
.network_login = false, /* works for some things, but not NTLMv2. Odd */
.expected_interactive_error = NT_STATUS_OK,
.expected_network_error = NT_STATUS_OK,
.username = talloc_asprintf(mem_ctx,
"%s@%s",
cli_credentials_get_username(
- popt_get_cmdline_credentials()),
+ samba_cmdline_get_creds()),
cli_credentials_get_realm(
- popt_get_cmdline_credentials())
+ samba_cmdline_get_creds())
),
.password = cli_credentials_get_password(
- popt_get_cmdline_credentials()),
+ samba_cmdline_get_creds()),
.network_login = true,
.expected_interactive_error = NT_STATUS_OK,
.expected_network_error = NT_STATUS_OK,
#include "auth/credentials/credentials.h"
#include "auth/credentials/credentials_krb5.h"
#include "torture/rpc/torture_rpc.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "../libcli/auth/schannel.h"
#include "libcli/auth/libcli_auth.h"
#include "libcli/security/security.h"
flags |= CLI_CRED_NTLMv2_AUTH;
}
- cli_credentials_get_ntlm_username_domain(popt_get_cmdline_credentials(),
+ cli_credentials_get_ntlm_username_domain(samba_cmdline_get_creds(),
tctx,
&ninfo.identity_info.account_name.string,
&ninfo.identity_info.domain_name.string);
cli_credentials_get_domain(credentials));
status = cli_credentials_get_ntlm_response(
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
tctx,
&flags,
chal,
s->conns = talloc_zero_array(s, struct torture_schannel_bench_conn, s->nprocs);
s->user1_creds = cli_credentials_shallow_copy(s,
- popt_get_cmdline_credentials());
+ samba_cmdline_get_creds());
tmp = torture_setting_string(s->tctx, "extra_user1", NULL);
if (tmp) {
cli_credentials_parse_string(s->user1_creds, tmp, CRED_SPECIFIED);
}
s->user2_creds = cli_credentials_shallow_copy(s,
- popt_get_cmdline_credentials());
+ samba_cmdline_get_creds());
tmp = torture_setting_string(s->tctx, "extra_user2", NULL);
if (tmp) {
cli_credentials_parse_string(s->user1_creds, tmp, CRED_SPECIFIED);
#include "libcli/auth/libcli_auth.h"
#include "torture/rpc/torture_rpc.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "param/param.h"
static void init_lsa_String(struct lsa_String *name, const char *s)
status = dcerpc_pipe_connect_b(torture, &p, binding,
&ndr_table_lsarpc,
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
torture->ev,
torture->lp_ctx);
#include "libcli/resolve/resolve.h"
#include "libcli/smb2/smb2.h"
#include "libcli/smb2/smb2_calls.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "system/filesys.h"
#include "torture/ndr/ndr.h"
#include "torture/smb2/proto.h"
lpcfg_smb_ports(tctx->lp_ctx),
share,
lpcfg_resolve_context(tctx->lp_ctx),
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
&tree,
tctx->ev,
&options,
lpcfg_smb_ports(tctx->lp_ctx),
share_name, NULL,
lpcfg_socket_options(tctx->lp_ctx),
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
lpcfg_resolve_context(tctx->lp_ctx),
tctx->ev,
&smb_options,
#include "libcli/security/security.h"
#include "torture/rpc/torture_rpc.h"
#include "param/param.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#define TORTURE_USER "torture_user"
#define TORTURE_USER_ADMINGROUP "torture_user_544"
#include "includes.h"
#include "system/time.h"
#include "libnet/libnet.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "librpc/gen_ndr/ndr_lsa_c.h"
#include "librpc/gen_ndr/ndr_samr_c.h"
&join->p,
dc_binding,
&ndr_table_samr,
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
NULL, tctx->lp_ctx);
} else {
tj->libnet_r = libnet_r;
- libnet_ctx->cred = popt_get_cmdline_credentials();
+ libnet_ctx->cred = samba_cmdline_get_creds();
libnet_r->in.binding = dcerpc_binding_string(libnet_r, binding);
if (libnet_r->in.binding == NULL) {
talloc_free(tj);
return NT_STATUS_NO_MEMORY;
}
- ldb_set_opaque(ldb_ctx, "credentials", popt_get_cmdline_credentials());
- ldb_set_opaque(ldb_ctx, "loadparm", cmdline_lp_ctx);
+ ldb_set_opaque(ldb_ctx, "credentials", samba_cmdline_get_creds());
+ ldb_set_opaque(ldb_ctx, "loadparm", samba_cmdline_get_lp_ctx());
rtn = ldb_connect(ldb_ctx, remote_ldb_url, 0, NULL);
if (rtn != LDB_SUCCESS) {
#include "librpc/gen_ndr/ndr_clusapi_c.h"
#include "param/param.h"
#include <tevent.h>
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
struct torture_test_clusapi_state {
struct dcerpc_pipe *p;
torture_assert_ntstatus_ok(tctx,
dcerpc_pipe_connect_b(tctx, &s->clusapi.p, binding,
&ndr_table_clusapi,
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
tctx->ev, tctx->lp_ctx),
"failed to connect dcerpc pipe");
#include "torture/torture.h"
#include "librpc/gen_ndr/ndr_wkssvc_c.h"
#include "torture/rpc/torture_rpc.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "param/param.h"
#include "libcli/auth/libcli_auth.h"
struct wkssvc_NetrWkstaUserGetInfo r;
union wkssvc_NetrWkstaUserInfo info;
const char *dom = lpcfg_workgroup(tctx->lp_ctx);
- struct cli_credentials *creds = popt_get_cmdline_credentials();
+ struct cli_credentials *creds = samba_cmdline_get_creds();
const char *user = cli_credentials_get_username(creds);
int i;
struct dcerpc_binding_handle *b = p->binding_handle;
{
NTSTATUS status;
struct wkssvc_NetrUnjoinDomain r;
- struct cli_credentials *creds = popt_get_cmdline_credentials();
+ struct cli_credentials *creds = samba_cmdline_get_creds();
const char *user = cli_credentials_get_username(creds);
const char *admin_account = NULL;
struct dcerpc_binding_handle *b = p->binding_handle;
{
NTSTATUS status;
struct wkssvc_NetrJoinDomain r;
- struct cli_credentials *creds = popt_get_cmdline_credentials();
+ struct cli_credentials *creds = samba_cmdline_get_creds();
const char *user = cli_credentials_get_username(creds);
const char *admin_account = NULL;
struct dcerpc_binding_handle *b = p->binding_handle;
#include "includes.h"
#include "system/readline.h"
#include "../libcli/smbreadline/smbreadline.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "auth/credentials/credentials.h"
#include "torture/smbtorture.h"
#include "param/param.h"
* stops the credentials system prompting when we use the "auth"
* command to display the current auth parameters.
*/
- cli_credentials_set_password(popt_get_cmdline_credentials(),
+ cli_credentials_set_password(samba_cmdline_get_creds(),
"", CRED_GUESS_ENV);
while (1) {
const char * principal;
username = cli_credentials_get_username(
- popt_get_cmdline_credentials());
+ samba_cmdline_get_creds());
principal = cli_credentials_get_principal(
- popt_get_cmdline_credentials(), tctx);
- domain = cli_credentials_get_domain(popt_get_cmdline_credentials());
- realm = cli_credentials_get_realm(popt_get_cmdline_credentials());
+ samba_cmdline_get_creds(), tctx);
+ domain = cli_credentials_get_domain(samba_cmdline_get_creds());
+ realm = cli_credentials_get_realm(samba_cmdline_get_creds());
password = cli_credentials_get_password(
- popt_get_cmdline_credentials());
+ samba_cmdline_get_creds());
printf("Username: %s\n", username ? username : "");
printf("User Principal: %s\n", principal ? principal : "");
if (!strcmp(argv[0], "username")) {
result = cli_credentials_set_username(
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
argv[1], CRED_SPECIFIED);
} else if (!strcmp(argv[0], "principal")) {
result = cli_credentials_set_principal(
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
argv[1], CRED_SPECIFIED);
} else if (!strcmp(argv[0], "domain")) {
result = cli_credentials_set_domain(
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
argv[1], CRED_SPECIFIED);
} else if (!strcmp(argv[0], "realm")) {
result = cli_credentials_set_realm(
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
argv[1], CRED_SPECIFIED);
} else if (!strcmp(argv[0], "password")) {
result = cli_credentials_set_password(
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
argv[1], CRED_SPECIFIED);
} else {
shell_usage(command);
*/
#include "includes.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "libcli/smb2/smb2.h"
#include "libcli/smb2/smb2_calls.h"
#include "libcli/smb/smbXcli_base.h"
lpcfg_smb_ports(tctx->lp_ctx),
share,
lpcfg_resolve_context(tctx->lp_ctx),
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
0,
tree,
tctx->ev,
#include "system/filesys.h"
#include "auth/credentials/credentials.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "librpc/gen_ndr/security.h"
#include "lib/events/events.h"
#include "librpc/gen_ndr/ndr_security.h"
#include "librpc/gen_ndr/ndr_ioctl.h"
#include "../libcli/smb/smbXcli_base.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "libcli/security/security.h"
#include "libcli/resolve/resolve.h"
#include "lib/param/param.h"
{
const char *host = torture_setting_string(tctx, "host", NULL);
const char *share = torture_setting_string(tctx, "share", NULL);
- struct cli_credentials *credentials = popt_get_cmdline_credentials();
+ struct cli_credentials *credentials = samba_cmdline_get_creds();
NTSTATUS status;
TALLOC_CTX *mem_ctx = talloc_new(tctx);
struct smb2_handle _h;
{
const char *host = torture_setting_string(tctx, "host", NULL);
const char *share = torture_setting_string(tctx, "share", NULL);
- struct cli_credentials *credentials = popt_get_cmdline_credentials();
+ struct cli_credentials *credentials = samba_cmdline_get_creds();
NTSTATUS status;
TALLOC_CTX *mem_ctx = talloc_new(tctx);
struct smb2_handle _h;
{
const char *host = torture_setting_string(tctx, "host", NULL);
const char *share = torture_setting_string(tctx, "share", NULL);
- struct cli_credentials *credentials = popt_get_cmdline_credentials();
+ struct cli_credentials *credentials = samba_cmdline_get_creds();
NTSTATUS status;
TALLOC_CTX *mem_ctx = talloc_new(tctx);
struct test_multichannel_oplock_break_state state = {
{
const char *host = torture_setting_string(tctx, "host", NULL);
const char *share = torture_setting_string(tctx, "share", NULL);
- struct cli_credentials *credentials = popt_get_cmdline_credentials();
+ struct cli_credentials *credentials = samba_cmdline_get_creds();
NTSTATUS status;
TALLOC_CTX *mem_ctx = talloc_new(tctx);
struct test_multichannel_oplock_break_state state = {
{
const char *host = torture_setting_string(tctx, "host", NULL);
const char *share = torture_setting_string(tctx, "share", NULL);
- struct cli_credentials *credentials = popt_get_cmdline_credentials();
+ struct cli_credentials *credentials = samba_cmdline_get_creds();
NTSTATUS status;
TALLOC_CTX *mem_ctx = talloc_new(tctx);
struct smb2_handle _h;
{
const char *host = torture_setting_string(tctx, "host", NULL);
const char *share = torture_setting_string(tctx, "share", NULL);
- struct cli_credentials *credentials = popt_get_cmdline_credentials();
+ struct cli_credentials *credentials = samba_cmdline_get_creds();
NTSTATUS status;
TALLOC_CTX *mem_ctx = talloc_new(tctx);
struct smb2_handle _h;
{
const char *host = torture_setting_string(tctx, "host", NULL);
const char *share = torture_setting_string(tctx, "share", NULL);
- struct cli_credentials *credentials = popt_get_cmdline_credentials();
+ struct cli_credentials *credentials = samba_cmdline_get_creds();
NTSTATUS status;
TALLOC_CTX *mem_ctx = talloc_new(tctx);
struct smb2_handle _h;
{
const char *host = torture_setting_string(tctx, "host", NULL);
const char *share = torture_setting_string(tctx, "share", NULL);
- struct cli_credentials *credentials = popt_get_cmdline_credentials();
+ struct cli_credentials *credentials = samba_cmdline_get_creds();
TALLOC_CTX *mem_ctx = talloc_new(tctx);
bool ret = true;
struct smb2_tree **tree2 = NULL;
torture_assert_ntstatus_equal_goto(tctx,
smb2_session_setup_spnego(session2[i],
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
0 /* previous_session_id */),
expected_status,
ret, done,
{
const char *host = torture_setting_string(tctx, "host", NULL);
const char *share = torture_setting_string(tctx, "share", NULL);
- struct cli_credentials *credentials = popt_get_cmdline_credentials();
+ struct cli_credentials *credentials = samba_cmdline_get_creds();
NTSTATUS status;
TALLOC_CTX *mem_ctx = talloc_new(tctx);
struct test_multichannel_lease_break_state state = {
#include "system/filesys.h"
#include "auth/credentials/credentials.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "librpc/gen_ndr/security.h"
#include "lib/events/events.h"
#include "system/filesys.h"
#include "auth/credentials/credentials.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "librpc/gen_ndr/security.h"
#include "lib/events/events.h"
#include "libcli/resolve/resolve.h"
#include "libcli/smb/smbXcli_base.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "lib/events/events.h"
#include "param/param.h"
status = smb2_connect(tctx, host,
lpcfg_smb_ports(tctx->lp_ctx), share,
lpcfg_resolve_context(tctx->lp_ctx),
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
tree, tctx->ev, &options,
lpcfg_socket_options(tctx->lp_ctx),
lpcfg_gensec_settings(tctx, tctx->lp_ctx));
#include "torture/torture.h"
#include "torture/smb2/proto.h"
#include "../libcli/smb/smbXcli_base.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "auth/credentials/credentials.h"
#include "libcli/security/security.h"
#include "libcli/resolve/resolve.h"
{
const char *host = torture_setting_string(tctx, "host", NULL);
const char *share = torture_setting_string(tctx, "share", NULL);
- struct cli_credentials *credentials = popt_get_cmdline_credentials();
+ struct cli_credentials *credentials = samba_cmdline_get_creds();
NTSTATUS status;
TALLOC_CTX *mem_ctx = talloc_new(tctx);
struct smb2_handle _h1;
{
const char *host = torture_setting_string(tctx, "host", NULL);
const char *share = torture_setting_string(tctx, "share", NULL);
- struct cli_credentials *credentials = popt_get_cmdline_credentials();
+ struct cli_credentials *credentials = samba_cmdline_get_creds();
NTSTATUS status;
TALLOC_CTX *mem_ctx = talloc_new(tctx);
struct smb2_handle _h1;
lpcfg_smb_ports(tctx->lp_ctx),
share,
lpcfg_resolve_context(tctx->lp_ctx),
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
&tree2,
tctx->ev,
&transport1->options,
torture_assert(tctx, session1_2 != NULL, "smb2_session_channel failed");
status = smb2_session_setup_spnego(session1_2,
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
0 /* previous_session_id */);
CHECK_STATUS(status, NT_STATUS_OK);
lpcfg_smb_ports(tctx->lp_ctx),
share,
lpcfg_resolve_context(tctx->lp_ctx),
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
&tree2,
tctx->ev,
&transport1->options,
torture_assert(tctx, session1_2 != NULL, "smb2_session_channel failed");
status = smb2_session_setup_spnego(session1_2,
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
0 /* previous_session_id */);
CHECK_STATUS(status, NT_STATUS_OK);
#include "includes.h"
#include "libcli/smb2/smb2.h"
#include "libcli/smb2/smb2_calls.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "torture/torture.h"
#include "param/param.h"
#include "libcli/resolve/resolve.h"
lpcfg_smb_ports(tctx->lp_ctx),
share,
lpcfg_resolve_context(tctx->lp_ctx),
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
&tree, tctx->ev, &options,
lpcfg_socket_options(tctx->lp_ctx),
lpcfg_gensec_settings(tctx, tctx->lp_ctx));
lpcfg_smb_ports(tctx->lp_ctx),
share,
lpcfg_resolve_context(tctx->lp_ctx),
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
&tree, tctx->ev, &options,
lpcfg_socket_options(tctx->lp_ctx),
lpcfg_gensec_settings(mem_ctx, tctx->lp_ctx));
#include "torture/util.h"
#include "torture/smb2/proto.h"
#include "../libcli/smb/smbXcli_base.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "auth/credentials/credentials.h"
#include "auth/credentials/credentials_krb5.h"
#include "libcli/security/security.h"
"oplock_level incorrect");
status = smb2_session_setup_spnego(tree->session,
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
0 /* previous_session_id */);
torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
"smb2_session_setup_spnego failed");
"smb2_getinfo_file failed");
status = smb2_session_setup_spnego(tree->session,
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
0 /* previous_session_id */);
torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
"smb2_session_setup_spnego failed");
/* re-authenticate as original user again */
status = smb2_session_setup_spnego(tree->session,
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
0 /* previous_session_id */);
torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
"smb2_session_setup_spnego failed");
/* re-authenticate as original user again */
status = smb2_session_setup_spnego(tree->session,
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
0 /* previous_session_id */);
torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
"smb2_session_setup_spnego failed");
/* re-authenticate as original user again */
status = smb2_session_setup_spnego(tree->session,
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
0 /* previous_session_id */);
torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
"smb2_session_setup_spnego failed");
/* re-authenticate as original user again */
status = smb2_session_setup_spnego(tree->session,
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
0 /* previous_session_id */);
torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
"smb2_session_setup_spnego failed");
/* re-authenticate as original user - again */
status = smb2_session_setup_spnego(tree->session,
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
0 /* previous_session_id */);
torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
"smb2_session_setup_spnego failed");
enum credentials_use_kerberos krb_state;
krb_state = cli_credentials_get_kerberos_state(
- popt_get_cmdline_credentials());
+ samba_cmdline_get_creds());
if (krb_state == CRED_USE_KERBEROS_REQUIRED) {
torture_skip(tctx,
"Can't test failing session setup with kerberos.");
*/
broken_creds = cli_credentials_shallow_copy(mem_ctx,
- popt_get_cmdline_credentials());
+ samba_cmdline_get_creds());
torture_assert(tctx, (broken_creds != NULL), "talloc error");
corrupted_password = talloc_asprintf(mem_ctx, "%s%s",
struct smbcli_options options;
const char *host = torture_setting_string(tctx, "host", NULL);
const char *share = torture_setting_string(tctx, "share", NULL);
- struct cli_credentials *credentials = popt_get_cmdline_credentials();
+ struct cli_credentials *credentials = samba_cmdline_get_creds();
struct smb2_tree *tree = NULL;
enum credentials_use_kerberos use_kerberos;
char fname[256];
struct smbcli_options options;
const char *host = torture_setting_string(tctx, "host", NULL);
const char *share = torture_setting_string(tctx, "share", NULL);
- struct cli_credentials *credentials = popt_get_cmdline_credentials();
+ struct cli_credentials *credentials = samba_cmdline_get_creds();
struct smb2_tree *tree = NULL;
const char *unc = NULL;
struct smb2_tree *tree2 = NULL;
struct smbcli_options options;
const char *host = torture_setting_string(tctx, "host", NULL);
const char *share = torture_setting_string(tctx, "share", NULL);
- struct cli_credentials *credentials = popt_get_cmdline_credentials();
+ struct cli_credentials *credentials = samba_cmdline_get_creds();
struct smb2_tree *tree = NULL;
enum credentials_use_kerberos use_kerberos;
char fname[256];
{
const char *host = torture_setting_string(tctx, "host", NULL);
const char *share = torture_setting_string(tctx, "share", NULL);
- struct cli_credentials *credentials = popt_get_cmdline_credentials();
+ struct cli_credentials *credentials = samba_cmdline_get_creds();
NTSTATUS status;
TALLOC_CTX *mem_ctx = talloc_new(tctx);
char fname[256];
torture_assert(tctx, session1_2 != NULL, "smb2_session_channel failed");
status = smb2_session_setup_spnego(session1_2,
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
0 /* previous_session_id */);
torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
"smb2_session_setup_spnego failed");
torture_assert(tctx, session2_1 != NULL, "smb2_session_channel failed");
status = smb2_session_setup_spnego(session2_1,
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
0 /* previous_session_id */);
torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
"smb2_session_setup_spnego failed");
{
const char *host = torture_setting_string(tctx, "host", NULL);
const char *share = torture_setting_string(tctx, "share", NULL);
- struct cli_credentials *credentials = popt_get_cmdline_credentials();
+ struct cli_credentials *credentials = samba_cmdline_get_creds();
NTSTATUS status;
TALLOC_CTX *mem_ctx = talloc_new(tctx);
char fname1[256];
static bool test_session_bind_invalid_auth(struct torture_context *tctx, struct smb2_tree *tree1)
{
- struct cli_credentials *credentials = popt_get_cmdline_credentials();
+ struct cli_credentials *credentials = samba_cmdline_get_creds();
struct cli_credentials *invalid_credentials = NULL;
bool ret = false;
static bool test_session_bind_different_user(struct torture_context *tctx, struct smb2_tree *tree1)
{
- struct cli_credentials *credentials1 = popt_get_cmdline_credentials();
+ struct cli_credentials *credentials1 = samba_cmdline_get_creds();
struct cli_credentials *credentials2 = torture_user2_credentials(tctx, tctx);
char *u1 = cli_credentials_get_unparsed_name(credentials1, tctx);
char *u2 = cli_credentials_get_unparsed_name(credentials2, tctx);
*/
static bool test_session_bind_negative_smb202(struct torture_context *tctx, struct smb2_tree *tree0)
{
- struct cli_credentials *credentials = popt_get_cmdline_credentials();
+ struct cli_credentials *credentials = samba_cmdline_get_creds();
bool ret = false;
struct smb2_transport *transport0 = tree0->session->transport;
struct smbcli_options options1;
static bool test_session_bind_negative_smb210(struct torture_context *tctx, struct smb2_tree *tree0)
{
- struct cli_credentials *credentials = popt_get_cmdline_credentials();
+ struct cli_credentials *credentials = samba_cmdline_get_creds();
bool ret = false;
struct smb2_transport *transport0 = tree0->session->transport;
struct smbcli_options options1;
static bool test_session_bind_negative_smb2to3(struct torture_context *tctx, struct smb2_tree *tree0)
{
- struct cli_credentials *credentials = popt_get_cmdline_credentials();
+ struct cli_credentials *credentials = samba_cmdline_get_creds();
bool ret = false;
struct smb2_transport *transport0 = tree0->session->transport;
struct smbcli_options options1;
static bool test_session_bind_negative_smb3to2(struct torture_context *tctx, struct smb2_tree *tree0)
{
- struct cli_credentials *credentials = popt_get_cmdline_credentials();
+ struct cli_credentials *credentials = samba_cmdline_get_creds();
bool ret = false;
struct smb2_transport *transport0 = tree0->session->transport;
struct smbcli_options options1;
static bool test_session_bind_negative_smb3to3(struct torture_context *tctx, struct smb2_tree *tree0)
{
- struct cli_credentials *credentials = popt_get_cmdline_credentials();
+ struct cli_credentials *credentials = samba_cmdline_get_creds();
bool ret = false;
struct smb2_transport *transport0 = tree0->session->transport;
struct smbcli_options options1;
static bool test_session_bind_negative_smb3encGtoC(struct torture_context *tctx, struct smb2_tree *tree0)
{
- struct cli_credentials *credentials0 = popt_get_cmdline_credentials();
+ struct cli_credentials *credentials0 = samba_cmdline_get_creds();
struct cli_credentials *credentials = NULL;
bool ret = false;
struct smb2_transport *transport0 = tree0->session->transport;
#include "libcli/smb2/smb2.h"
#include "libcli/smb2/smb2_calls.h"
#include "../libcli/smb/smbXcli_base.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "system/time.h"
#include "librpc/gen_ndr/ndr_security.h"
#include "param/param.h"
}
status = smb2_session_setup_spnego(session,
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
previous_session_id);
if (!NT_STATUS_IS_OK(status)) {
torture_comment(tctx, "session setup failed: %s\n", nt_errstr(status));
lpcfg_smb_ports(tctx->lp_ctx),
share,
lpcfg_resolve_context(tctx->lp_ctx),
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
previous_session_id,
tree,
tctx->ev,
lpcfg_smb_ports(tctx->lp_ctx),
share,
lpcfg_resolve_context(tctx->lp_ctx),
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
0,
tree,
tctx->ev,
util.c
''',
subsystem='smbtorture',
- deps='LIBCLI_SMB2 POPT_CREDENTIALS torture NDR_IOCTL',
+ deps='LIBCLI_SMB2 torture NDR_IOCTL',
internal_module=True,
autoproto='proto.h',
init_function='torture_smb2_init'
*/
#include "includes.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "system/time.h"
#include "system/wait.h"
#include "system/filesys.h"
OPT_DANGEROUS,OPT_SMB_PORTS,OPT_ASYNC,OPT_NUMPROGS,
OPT_EXTRA_USER,};
TALLOC_CTX *mem_ctx = NULL;
+ struct loadparm_context *lp_ctx = NULL;
+ bool ok;
struct poptOption long_options[] = {
POPT_AUTOHELP
POPT_COMMON_CONNECTION
POPT_COMMON_CREDENTIALS
POPT_COMMON_VERSION
- {0}
+ POPT_LEGACY_S4
+ POPT_TABLEEND
};
setlinebuf(stdout);
/* we are never interested in SIGPIPE */
BlockSignals(true, SIGPIPE);
- pc = poptGetContext("smbtorture", argc, argv, long_options,
- POPT_CONTEXT_KEEP_FIRST);
+ ok = samba_cmdline_init(mem_ctx,
+ SAMBA_CMDLINE_CONFIG_CLIENT,
+ false /* require_smbconf */);
+ if (!ok) {
+ DBG_ERR("Unable to init cmdline parser\n");
+ TALLOC_FREE(mem_ctx);
+ exit(1);
+ }
+
+ pc = samba_popt_get_context(getprogname(),
+ argc,
+ argv,
+ long_options,
+ POPT_CONTEXT_KEEP_FIRST);
+ if (pc == NULL) {
+ DBG_ERR("Failed cmdline parser\n");
+ TALLOC_FREE(mem_ctx);
+ exit(1);
+ }
poptSetOtherOptionHelp(pc, "<binding>|<unc> TEST1 TEST2 ...");
+ lp_ctx = samba_cmdline_get_lp_ctx();
+
while((opt = poptGetNextOpt(pc)) != -1) {
switch (opt) {
case OPT_LOADFILE:
- lpcfg_set_cmdline(cmdline_lp_ctx, "torture:loadfile", poptGetOptArg(pc));
+ lpcfg_set_cmdline(lp_ctx, "torture:loadfile", poptGetOptArg(pc));
break;
case OPT_UNCLIST:
- lpcfg_set_cmdline(cmdline_lp_ctx, "torture:unclist", poptGetOptArg(pc));
+ lpcfg_set_cmdline(lp_ctx, "torture:unclist", poptGetOptArg(pc));
break;
case OPT_TIMELIMIT:
- lpcfg_set_cmdline(cmdline_lp_ctx, "torture:timelimit", poptGetOptArg(pc));
+ lpcfg_set_cmdline(lp_ctx, "torture:timelimit", poptGetOptArg(pc));
break;
case OPT_NUMPROGS:
- lpcfg_set_cmdline(cmdline_lp_ctx, "torture:nprocs", poptGetOptArg(pc));
+ lpcfg_set_cmdline(lp_ctx, "torture:nprocs", poptGetOptArg(pc));
break;
case OPT_DNS:
- parse_dns(cmdline_lp_ctx, poptGetOptArg(pc));
+ parse_dns(lp_ctx, poptGetOptArg(pc));
break;
case OPT_DANGEROUS:
- lpcfg_set_cmdline(cmdline_lp_ctx, "torture:dangerous", "Yes");
+ lpcfg_set_cmdline(lp_ctx, "torture:dangerous", "Yes");
break;
case OPT_ASYNC:
- lpcfg_set_cmdline(cmdline_lp_ctx, "torture:async", "Yes");
+ lpcfg_set_cmdline(lp_ctx, "torture:async", "Yes");
break;
case OPT_SMB_PORTS:
- lpcfg_set_cmdline(cmdline_lp_ctx, "smb ports", poptGetOptArg(pc));
+ lpcfg_set_cmdline(lp_ctx, "smb ports", poptGetOptArg(pc));
break;
case OPT_EXTRA_USER:
{
talloc_free(mem_ctx);
exit(1);
}
- lpcfg_set_cmdline(cmdline_lp_ctx, option, value);
+ lpcfg_set_cmdline(lp_ctx, option, value);
talloc_free(option);
}
break;
}
if (strcmp(target, "samba3") == 0) {
- lpcfg_set_cmdline(cmdline_lp_ctx, "torture:samba3", "true");
- lpcfg_set_cmdline(cmdline_lp_ctx, "torture:resume_key_support", "false");
+ lpcfg_set_cmdline(lp_ctx, "torture:samba3", "true");
+ lpcfg_set_cmdline(lp_ctx, "torture:resume_key_support", "false");
} else if (strcmp(target, "samba4") == 0) {
- lpcfg_set_cmdline(cmdline_lp_ctx, "torture:samba4", "true");
+ lpcfg_set_cmdline(lp_ctx, "torture:samba4", "true");
} else if (strcmp(target, "samba4-ntvfs") == 0) {
- lpcfg_set_cmdline(cmdline_lp_ctx, "torture:samba4", "true");
- lpcfg_set_cmdline(cmdline_lp_ctx, "torture:samba4-ntvfs", "true");
+ lpcfg_set_cmdline(lp_ctx, "torture:samba4", "true");
+ lpcfg_set_cmdline(lp_ctx, "torture:samba4-ntvfs", "true");
} else if (strcmp(target, "winxp") == 0) {
- lpcfg_set_cmdline(cmdline_lp_ctx, "torture:winxp", "true");
+ lpcfg_set_cmdline(lp_ctx, "torture:winxp", "true");
} else if (strcmp(target, "w2k3") == 0) {
- lpcfg_set_cmdline(cmdline_lp_ctx, "torture:w2k3", "true");
+ lpcfg_set_cmdline(lp_ctx, "torture:w2k3", "true");
} else if (strcmp(target, "w2k8") == 0) {
- lpcfg_set_cmdline(cmdline_lp_ctx, "torture:w2k8", "true");
- lpcfg_set_cmdline(cmdline_lp_ctx,
+ lpcfg_set_cmdline(lp_ctx, "torture:w2k8", "true");
+ lpcfg_set_cmdline(lp_ctx,
"torture:invalid_lock_range_support", "false");
} else if (strcmp(target, "w2k12") == 0) {
- lpcfg_set_cmdline(cmdline_lp_ctx, "torture:w2k12", "true");
+ lpcfg_set_cmdline(lp_ctx, "torture:w2k12", "true");
} else if (strcmp(target, "win7") == 0) {
- lpcfg_set_cmdline(cmdline_lp_ctx, "torture:win7", "true");
- lpcfg_set_cmdline(cmdline_lp_ctx, "torture:resume_key_support", "false");
- lpcfg_set_cmdline(cmdline_lp_ctx, "torture:rewind_support", "false");
+ lpcfg_set_cmdline(lp_ctx, "torture:win7", "true");
+ lpcfg_set_cmdline(lp_ctx, "torture:resume_key_support", "false");
+ lpcfg_set_cmdline(lp_ctx, "torture:rewind_support", "false");
/* RAW-SEARCH for fails for inexplicable reasons against win7 */
- lpcfg_set_cmdline(cmdline_lp_ctx, "torture:search_ea_support", "false");
+ lpcfg_set_cmdline(lp_ctx, "torture:search_ea_support", "false");
- lpcfg_set_cmdline(cmdline_lp_ctx, "torture:hide_on_access_denied",
+ lpcfg_set_cmdline(lp_ctx, "torture:hide_on_access_denied",
"true");
} else if (strcmp(target, "onefs") == 0) {
- lpcfg_set_cmdline(cmdline_lp_ctx, "torture:onefs", "true");
- lpcfg_set_cmdline(cmdline_lp_ctx, "torture:openx_deny_dos_support",
+ lpcfg_set_cmdline(lp_ctx, "torture:onefs", "true");
+ lpcfg_set_cmdline(lp_ctx, "torture:openx_deny_dos_support",
"false");
- lpcfg_set_cmdline(cmdline_lp_ctx, "torture:range_not_locked_on_file_close", "false");
- lpcfg_set_cmdline(cmdline_lp_ctx, "torture:sacl_support", "false");
- lpcfg_set_cmdline(cmdline_lp_ctx, "torture:ea_support", "false");
- lpcfg_set_cmdline(cmdline_lp_ctx, "torture:smbexit_pdu_support",
+ lpcfg_set_cmdline(lp_ctx, "torture:range_not_locked_on_file_close", "false");
+ lpcfg_set_cmdline(lp_ctx, "torture:sacl_support", "false");
+ lpcfg_set_cmdline(lp_ctx, "torture:ea_support", "false");
+ lpcfg_set_cmdline(lp_ctx, "torture:smbexit_pdu_support",
"false");
- lpcfg_set_cmdline(cmdline_lp_ctx, "torture:smblock_pdu_support",
+ lpcfg_set_cmdline(lp_ctx, "torture:smblock_pdu_support",
"false");
- lpcfg_set_cmdline(cmdline_lp_ctx, "torture:2_step_break_to_none",
+ lpcfg_set_cmdline(lp_ctx, "torture:2_step_break_to_none",
"true");
- lpcfg_set_cmdline(cmdline_lp_ctx, "torture:deny_dos_support", "false");
- lpcfg_set_cmdline(cmdline_lp_ctx, "torture:deny_fcb_support", "false");
- lpcfg_set_cmdline(cmdline_lp_ctx, "torture:read_support", "false");
- lpcfg_set_cmdline(cmdline_lp_ctx, "torture:writeclose_support", "false");
- lpcfg_set_cmdline(cmdline_lp_ctx, "torture:resume_key_support", "false");
- lpcfg_set_cmdline(cmdline_lp_ctx, "torture:rewind_support", "false");
- lpcfg_set_cmdline(cmdline_lp_ctx, "torture:raw_search_search", "false");
- lpcfg_set_cmdline(cmdline_lp_ctx, "torture:search_ea_size", "false");
+ lpcfg_set_cmdline(lp_ctx, "torture:deny_dos_support", "false");
+ lpcfg_set_cmdline(lp_ctx, "torture:deny_fcb_support", "false");
+ lpcfg_set_cmdline(lp_ctx, "torture:read_support", "false");
+ lpcfg_set_cmdline(lp_ctx, "torture:writeclose_support", "false");
+ lpcfg_set_cmdline(lp_ctx, "torture:resume_key_support", "false");
+ lpcfg_set_cmdline(lp_ctx, "torture:rewind_support", "false");
+ lpcfg_set_cmdline(lp_ctx, "torture:raw_search_search", "false");
+ lpcfg_set_cmdline(lp_ctx, "torture:search_ea_size", "false");
}
if (max_runtime) {
print_testsuite_list();
poptFreeContext(pc);
talloc_free(mem_ctx);
- popt_free_cmdline_credentials();
return 0;
}
}
poptFreeContext(pc);
talloc_free(mem_ctx);
- popt_free_cmdline_credentials();
return 0;
}
return 1;
}
- torture->lp_ctx = cmdline_lp_ctx;
+ torture->lp_ctx = lp_ctx;
gensec_init();
usage(pc);
torture->results->returncode = 1;
} else if (!torture_parse_target(torture,
- cmdline_lp_ctx, argv_new[1])) {
+ lp_ctx, argv_new[1])) {
/* Take the target name or binding. */
usage(pc);
torture->results->returncode = 1;
if (torture->results->returncode && correct) {
poptFreeContext(pc);
talloc_free(mem_ctx);
- popt_free_cmdline_credentials();
return(0);
} else {
poptFreeContext(pc);
#include "libcli/libcli.h"
#include "torture/util.h"
#include "torture/unix/proto.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "libcli/resolve/resolve.h"
#include "param/param.h"
status = smbcli_full_connection(tctx, &cli, host,
lpcfg_smb_ports(tctx->lp_ctx),
share, NULL, lpcfg_socket_options(tctx->lp_ctx),
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
lpcfg_resolve_context(tctx->lp_ctx),
tctx->ev, &options, &session_options,
lpcfg_gensec_settings(tctx, tctx->lp_ctx));
#include "libcli/raw/raw_proto.h"
#include "torture/torture.h"
#include "torture/unix/proto.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "auth/credentials/credentials.h"
#include "param/param.h"
#include "libcli/resolve/resolve.h"
struct ldb_context *ldb;
const char *addc, *host;
- cli = connect_to_server(torture, popt_get_cmdline_credentials());
+ cli = connect_to_server(torture, samba_cmdline_get_creds());
torture_assert(torture, cli, "connecting to server with authenticated credentials");
/* Test basic authenticated mapping. */
guest ? "YES" : "NO");
torture_assert(torture,
cli_credentials_is_anonymous(
- popt_get_cmdline_credentials()) == guest,
+ samba_cmdline_get_creds()) == guest,
"login did not credentials map to guest");
} else {
torture_comment(torture, "server does not support SMB_WHOAMI_GUEST flag\n");
if (addc) {
ldb = ldb_wrap_connect(torture, torture->ev, torture->lp_ctx, talloc_asprintf(torture, "ldap://%s", addc),
- NULL, popt_get_cmdline_credentials(), 0);
+ NULL, samba_cmdline_get_creds(), 0);
torture_assert(torture, ldb, "ldb connect failed");
/* We skip this testing if we could not contact the LDAP server */
*/
#include "includes.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "libcli/raw/libcliraw.h"
#include "libcli/raw/raw_proto.h"
#include "../libcli/smb/smb_constants.h"
lpcfg_smb_ports(tctx->lp_ctx),
sharename, NULL,
lpcfg_socket_options(tctx->lp_ctx),
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
lpcfg_resolve_context(tctx->lp_ctx),
ev, &options, &session_options,
lpcfg_gensec_settings(tctx, tctx->lp_ctx));
struct cli_credentials *torture_user2_credentials(struct torture_context *tctx,
TALLOC_CTX *mem_ctx)
{
- struct cli_credentials *credentials1 = popt_get_cmdline_credentials();
+ struct cli_credentials *credentials1 = samba_cmdline_get_creds();
const char *user1domain = cli_credentials_get_domain(credentials1);
const char *user2name = torture_setting_string(tctx, "user2name", NULL);
const char *user2domain = torture_setting_string(tctx, "user2domain", user1domain);
*/
#include "includes.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "libcli/smb2/smb2.h"
#include "libcli/smb2/smb2_calls.h"
#include "libcli/smb/smbXcli_base.h"
lpcfg_smb_ports(tctx->lp_ctx),
share,
lpcfg_resolve_context(tctx->lp_ctx),
- popt_get_cmdline_credentials(),
+ samba_cmdline_get_creds(),
0,
tree,
tctx->ev,
#include "libcli/smb2/smb2.h"
#include "libcli/smb2/smb2_calls.h"
#include "libcli/smb/smb2_create_ctx.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "param/param.h"
#include "libcli/resolve/resolve.h"
#include "MacExtensions.h"
#include "libcli/smb2/smb2.h"
#include "libcli/smb2/smb2_calls.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "param/param.h"
#include "libcli/resolve/resolve.h"
#include "auth/kerberos/kerberos.h"
#include "auth/credentials/credentials.h"
#include "param/param.h"
-#include "lib/cmdline/popt_common.h"
+#include "lib/cmdline/cmdline.h"
#include "auth/kerberos/pac_utils.h"
#include "wbclient.h"
torture_assert_ntstatus_ok(tctx, status, "gensec_set_target_hostname (client) failed");
status = gensec_set_credentials(gensec_client_context,
- popt_get_cmdline_credentials());
+ samba_cmdline_get_creds());
torture_assert_ntstatus_ok(tctx, status, "gensec_set_credentials (client) failed");
if (sasl_mech) {
bld.SAMBA_SUBSYSTEM('TORTURE_UTIL',
source='util_smb.c',
- public_deps='torture popt POPT_CREDENTIALS',
+ public_deps='torture',
deps='smbclient-raw'
)
bld.SAMBA_MODULE('TORTURE_BASIC',
source='basic/base.c basic/misc.c basic/scanner.c basic/utable.c basic/charset.c basic/mangle_test.c basic/denytest.c basic/aliases.c basic/locking.c basic/secleak.c basic/rename.c basic/dir.c basic/delete.c basic/unlink.c basic/disconnect.c basic/delaywrite.c basic/attr.c basic/properties.c',
subsystem='smbtorture',
- deps='LIBCLI_SMB popt POPT_CREDENTIALS TORTURE_UTIL smbclient-raw TORTURE_RAW',
+ deps='LIBCLI_SMB TORTURE_UTIL smbclient-raw TORTURE_RAW',
internal_module=True,
autoproto='basic/proto.h',
init_function='torture_base_init',
autoproto='raw/proto.h',
subsystem='smbtorture',
init_function='torture_raw_init',
- deps='LIBCLI_SMB LIBCLI_LSA LIBCLI_SMB_COMPOSITE popt POPT_CREDENTIALS TORTURE_UTIL',
+ deps='LIBCLI_SMB LIBCLI_LSA LIBCLI_SMB_COMPOSITE TORTURE_UTIL',
internal_module=True,
enabled=bld.PYTHON_BUILD_IS_ENABLED()
)
%s
LIBCLI_AUTH
popt
- POPT_CREDENTIALS
+ CMDLINE_S4
TORTURE_LDAP
TORTURE_UTIL
TORTURE_RAP
source='auth/ntlmssp.c auth/pac.c auth/smbencrypt.c',
autoproto='auth/proto.h',
subsystem='smbtorture',
- deps='LIBCLI_SMB gensec auth4 authkrb5 popt POPT_CREDENTIALS smbpasswdparser torture com_err gensec_ntlmssp',
+ deps='LIBCLI_SMB gensec auth4 authkrb5 smbpasswdparser torture com_err gensec_ntlmssp',
internal_module=True
)
ldap/session_expiry.c
''',
subsystem='smbtorture',
- deps='cli-ldap cli_cldap samdb popt POPT_CREDENTIALS torture ldbsamba',
+ deps='cli-ldap cli_cldap samdb torture ldbsamba',
internal_module=True,
autoproto='ldap/proto.h',
init_function='torture_ldap_init'
autoproto='libnet/proto.h',
subsystem='smbtorture',
init_function='torture_net_init',
- deps='%s popt POPT_CREDENTIALS torture_rpc %s' % (provision, samba_net),
+ deps='%s torture_rpc %s' % (provision, samba_net),
internal_module=True,
enabled=bld.PYTHON_BUILD_IS_ENABLED()
)
autoproto='ntp/proto.h',
subsystem='smbtorture',
init_function='torture_ntp_init',
- deps='popt POPT_CREDENTIALS torture_rpc',
+ deps='torture_rpc',
internal_module=True,
enabled=bld.PYTHON_BUILD_IS_ENABLED()
)
bld.SAMBA_MODULE('TORTURE_VFS',
source='vfs/vfs.c vfs/fruit.c vfs/acl_xattr.c',
subsystem='smbtorture',
- deps='LIBCLI_SMB POPT_CREDENTIALS TORTURE_UTIL smbclient-raw TORTURE_RAW',
+ deps='LIBCLI_SMB TORTURE_UTIL smbclient-raw TORTURE_RAW',
internal_module=True,
autoproto='vfs/proto.h',
init_function='torture_vfs_init'
bld.SAMBA_SUBSYSTEM('torturemain',
source='smbtorture.c torture.c shell.c',
subsystem_name='smbtorture',
- deps='torture popt POPT_SAMBA POPT_CREDENTIALS dcerpc LIBCLI_SMB SMBREADLINE ' + TORTURE_MODULES,
+ deps='torture dcerpc LIBCLI_SMB SMBREADLINE ' + TORTURE_MODULES,
enabled=bld.PYTHON_BUILD_IS_ENABLED()
)
source=[],
manpages='man/smbtorture.1',
private_headers='smbtorture.h',
- deps='torturemain torture popt POPT_SAMBA POPT_CREDENTIALS dcerpc LIBCLI_SMB SMBREADLINE ' + TORTURE_MODULES,
+ deps='torturemain torture popt CMDLINE_S4 dcerpc LIBCLI_SMB SMBREADLINE ' + TORTURE_MODULES,
pyembed=True,
enabled=bld.PYTHON_BUILD_IS_ENABLED()
)
git.samba.org / samba.git / commitdiff